1 /* 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 12 /* 13 * This file includes unit tests for the RTCPReceiver. 14 */ 15 #include "testing/gmock/include/gmock/gmock.h" 16 #include "testing/gtest/include/gtest/gtest.h" 17 18 // Note: This file has no directory. Lint warning must be ignored. 19 #include "webrtc/common_types.h" 20 #include "webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitrate_observer.h" 21 #include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h" 22 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h" 23 #include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h" 24 #include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h" 25 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h" 26 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h" 27 28 namespace webrtc { 29 30 namespace { // Anonymous namespace; hide utility functions and classes. 31 32 // This test transport verifies that no functions get called. 33 class TestTransport : public Transport, 34 public NullRtpData { 35 public: 36 explicit TestTransport() 37 : rtcp_receiver_(NULL) { 38 } 39 void SetRTCPReceiver(RTCPReceiver* rtcp_receiver) { 40 rtcp_receiver_ = rtcp_receiver; 41 } 42 virtual int SendPacket(int /*ch*/, const void* /*data*/, int /*len*/) { 43 ADD_FAILURE(); // FAIL() gives a compile error. 44 return -1; 45 } 46 47 // Injects an RTCP packet into the receiver. 48 virtual int SendRTCPPacket(int /* ch */, const void *packet, int packet_len) { 49 ADD_FAILURE(); 50 return 0; 51 } 52 53 virtual int OnReceivedPayloadData(const uint8_t* payloadData, 54 const uint16_t payloadSize, 55 const WebRtcRTPHeader* rtpHeader) { 56 ADD_FAILURE(); 57 return 0; 58 } 59 RTCPReceiver* rtcp_receiver_; 60 }; 61 62 class RtcpReceiverTest : public ::testing::Test { 63 protected: 64 static const uint32_t kRemoteBitrateEstimatorMinBitrateBps = 30000; 65 66 RtcpReceiverTest() 67 : over_use_detector_options_(), 68 system_clock_(1335900000), 69 remote_bitrate_observer_(), 70 remote_bitrate_estimator_( 71 RemoteBitrateEstimatorFactory().Create( 72 &remote_bitrate_observer_, 73 &system_clock_, 74 kMimdControl, 75 kRemoteBitrateEstimatorMinBitrateBps)) { 76 test_transport_ = new TestTransport(); 77 78 RtpRtcp::Configuration configuration; 79 configuration.id = 0; 80 configuration.audio = false; 81 configuration.clock = &system_clock_; 82 configuration.outgoing_transport = test_transport_; 83 configuration.remote_bitrate_estimator = remote_bitrate_estimator_.get(); 84 rtp_rtcp_impl_ = new ModuleRtpRtcpImpl(configuration); 85 rtcp_receiver_ = new RTCPReceiver(0, &system_clock_, rtp_rtcp_impl_); 86 test_transport_->SetRTCPReceiver(rtcp_receiver_); 87 } 88 ~RtcpReceiverTest() { 89 delete rtcp_receiver_; 90 delete rtp_rtcp_impl_; 91 delete test_transport_; 92 } 93 94 // Injects an RTCP packet into the receiver. 95 // Returns 0 for OK, non-0 for failure. 96 int InjectRtcpPacket(const uint8_t* packet, 97 uint16_t packet_len) { 98 RTCPUtility::RTCPParserV2 rtcpParser(packet, 99 packet_len, 100 true); // Allow non-compound RTCP 101 102 RTCPHelp::RTCPPacketInformation rtcpPacketInformation; 103 EXPECT_EQ(0, rtcp_receiver_->IncomingRTCPPacket(rtcpPacketInformation, 104 &rtcpParser)); 105 rtcp_receiver_->TriggerCallbacksFromRTCPPacket(rtcpPacketInformation); 106 // The NACK list is on purpose not copied below as it isn't needed by the 107 // test. 108 rtcp_packet_info_.rtcpPacketTypeFlags = 109 rtcpPacketInformation.rtcpPacketTypeFlags; 110 rtcp_packet_info_.remoteSSRC = rtcpPacketInformation.remoteSSRC; 111 rtcp_packet_info_.applicationSubType = 112 rtcpPacketInformation.applicationSubType; 113 rtcp_packet_info_.applicationName = rtcpPacketInformation.applicationName; 114 rtcp_packet_info_.applicationLength = 115 rtcpPacketInformation.applicationLength; 116 rtcp_packet_info_.report_blocks = rtcpPacketInformation.report_blocks; 117 rtcp_packet_info_.rtt = rtcpPacketInformation.rtt; 118 rtcp_packet_info_.interArrivalJitter = 119 rtcpPacketInformation.interArrivalJitter; 120 rtcp_packet_info_.sliPictureId = rtcpPacketInformation.sliPictureId; 121 rtcp_packet_info_.rpsiPictureId = rtcpPacketInformation.rpsiPictureId; 122 rtcp_packet_info_.receiverEstimatedMaxBitrate = 123 rtcpPacketInformation.receiverEstimatedMaxBitrate; 124 rtcp_packet_info_.ntp_secs = rtcpPacketInformation.ntp_secs; 125 rtcp_packet_info_.ntp_frac = rtcpPacketInformation.ntp_frac; 126 rtcp_packet_info_.rtp_timestamp = rtcpPacketInformation.rtp_timestamp; 127 rtcp_packet_info_.xr_dlrr_item = rtcpPacketInformation.xr_dlrr_item; 128 if (rtcpPacketInformation.VoIPMetric) { 129 rtcp_packet_info_.AddVoIPMetric(rtcpPacketInformation.VoIPMetric); 130 } 131 return 0; 132 } 133 134 OverUseDetectorOptions over_use_detector_options_; 135 SimulatedClock system_clock_; 136 ModuleRtpRtcpImpl* rtp_rtcp_impl_; 137 RTCPReceiver* rtcp_receiver_; 138 TestTransport* test_transport_; 139 RTCPHelp::RTCPPacketInformation rtcp_packet_info_; 140 MockRemoteBitrateObserver remote_bitrate_observer_; 141 scoped_ptr<RemoteBitrateEstimator> remote_bitrate_estimator_; 142 }; 143 144 145 TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) { 146 const uint8_t bad_packet[] = {0, 0, 0, 0}; 147 EXPECT_EQ(0, InjectRtcpPacket(bad_packet, sizeof(bad_packet))); 148 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 149 } 150 151 TEST_F(RtcpReceiverTest, InjectSrPacket) { 152 const uint32_t kSenderSsrc = 0x10203; 153 rtcp::SenderReport sr; 154 sr.From(kSenderSsrc); 155 rtcp::RawPacket p = sr.Build(); 156 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 157 // The parser will note the remote SSRC on a SR from other than his 158 // expected peer, but will not flag that he's gotten a packet. 159 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); 160 EXPECT_EQ(0U, 161 kRtcpSr & rtcp_packet_info_.rtcpPacketTypeFlags); 162 } 163 164 TEST_F(RtcpReceiverTest, InjectSrPacketFromExpectedPeer) { 165 const uint32_t kSenderSsrc = 0x10203; 166 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); 167 rtcp::SenderReport sr; 168 sr.From(kSenderSsrc); 169 rtcp::RawPacket p = sr.Build(); 170 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 171 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); 172 EXPECT_EQ(kRtcpSr, rtcp_packet_info_.rtcpPacketTypeFlags); 173 } 174 175 TEST_F(RtcpReceiverTest, InjectRrPacket) { 176 const uint32_t kSenderSsrc = 0x10203; 177 rtcp::ReceiverReport rr; 178 rr.From(kSenderSsrc); 179 rtcp::RawPacket p = rr.Build(); 180 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 181 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); 182 EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags); 183 ASSERT_EQ(0u, rtcp_packet_info_.report_blocks.size()); 184 } 185 186 TEST_F(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) { 187 const uint32_t kSenderSsrc = 0x10203; 188 const uint32_t kSourceSsrc = 0x123456; 189 std::set<uint32_t> ssrcs; 190 ssrcs.insert(kSourceSsrc); 191 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 192 193 rtcp::ReportBlock rb; 194 rb.To(kSourceSsrc + 1); 195 rtcp::ReceiverReport rr; 196 rr.From(kSenderSsrc); 197 rr.WithReportBlock(&rb); 198 rtcp::RawPacket p = rr.Build(); 199 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 200 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); 201 EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags); 202 ASSERT_EQ(0u, rtcp_packet_info_.report_blocks.size()); 203 } 204 205 TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) { 206 const uint32_t kSenderSsrc = 0x10203; 207 const uint32_t kSourceSsrc = 0x123456; 208 std::set<uint32_t> ssrcs; 209 ssrcs.insert(kSourceSsrc); 210 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 211 212 rtcp::ReportBlock rb; 213 rb.To(kSourceSsrc); 214 rtcp::ReceiverReport rr; 215 rr.From(kSenderSsrc); 216 rr.WithReportBlock(&rb); 217 rtcp::RawPacket p = rr.Build(); 218 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 219 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); 220 EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags); 221 ASSERT_EQ(1u, rtcp_packet_info_.report_blocks.size()); 222 } 223 224 TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) { 225 const uint32_t kSenderSsrc = 0x10203; 226 const uint32_t kSourceSsrcs[] = {0x40506, 0x50607}; 227 const uint16_t kSequenceNumbers[] = {10, 12423}; 228 const int kNumSsrcs = sizeof(kSourceSsrcs) / sizeof(kSourceSsrcs[0]); 229 230 std::set<uint32_t> ssrcs(kSourceSsrcs, kSourceSsrcs + kNumSsrcs); 231 rtcp_receiver_->SetSsrcs(kSourceSsrcs[0], ssrcs); 232 233 rtcp::ReportBlock rb1; 234 rb1.To(kSourceSsrcs[0]); 235 rb1.WithExtHighestSeqNum(kSequenceNumbers[0]); 236 rb1.WithFractionLost(10); 237 rb1.WithCumulativeLost(5); 238 239 rtcp::ReportBlock rb2; 240 rb2.To(kSourceSsrcs[1]); 241 rb2.WithExtHighestSeqNum(kSequenceNumbers[1]); 242 243 rtcp::ReceiverReport rr1; 244 rr1.From(kSenderSsrc); 245 rr1.WithReportBlock(&rb1); 246 rr1.WithReportBlock(&rb2); 247 248 rtcp::RawPacket p1 = rr1.Build(); 249 EXPECT_EQ(0, InjectRtcpPacket(p1.buffer(), p1.buffer_length())); 250 ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size()); 251 EXPECT_EQ(10, rtcp_packet_info_.report_blocks.front().fractionLost); 252 EXPECT_EQ(0, rtcp_packet_info_.report_blocks.back().fractionLost); 253 254 rtcp::ReportBlock rb3; 255 rb3.To(kSourceSsrcs[0]); 256 rb3.WithExtHighestSeqNum(kSequenceNumbers[0]); 257 258 rtcp::ReportBlock rb4; 259 rb4.To(kSourceSsrcs[1]); 260 rb4.WithExtHighestSeqNum(kSequenceNumbers[1]); 261 rb4.WithFractionLost(20); 262 rb4.WithCumulativeLost(10); 263 264 rtcp::ReceiverReport rr2; 265 rr2.From(kSenderSsrc); 266 rr2.WithReportBlock(&rb3); 267 rr2.WithReportBlock(&rb4); 268 269 rtcp::RawPacket p2 = rr2.Build(); 270 EXPECT_EQ(0, InjectRtcpPacket(p2.buffer(), p2.buffer_length())); 271 ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size()); 272 EXPECT_EQ(0, rtcp_packet_info_.report_blocks.front().fractionLost); 273 EXPECT_EQ(20, rtcp_packet_info_.report_blocks.back().fractionLost); 274 } 275 276 TEST_F(RtcpReceiverTest, InjectIjWithNoItem) { 277 rtcp::Ij ij; 278 rtcp::RawPacket p = ij.Build(); 279 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 280 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 281 } 282 283 TEST_F(RtcpReceiverTest, InjectIjWithOneItem) { 284 rtcp::Ij ij; 285 ij.WithJitterItem(0x11111111); 286 287 rtcp::RawPacket p = ij.Build(); 288 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 289 EXPECT_EQ(kRtcpTransmissionTimeOffset, rtcp_packet_info_.rtcpPacketTypeFlags); 290 EXPECT_EQ(0x11111111U, rtcp_packet_info_.interArrivalJitter); 291 } 292 293 TEST_F(RtcpReceiverTest, InjectAppWithNoData) { 294 rtcp::App app; 295 app.WithSubType(30); 296 uint32_t name = 'n' << 24; 297 name += 'a' << 16; 298 name += 'm' << 8; 299 name += 'e'; 300 app.WithName(name); 301 302 rtcp::RawPacket p = app.Build(); 303 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 304 EXPECT_EQ(kRtcpApp, rtcp_packet_info_.rtcpPacketTypeFlags); 305 EXPECT_EQ(30, rtcp_packet_info_.applicationSubType); 306 EXPECT_EQ(name, rtcp_packet_info_.applicationName); 307 EXPECT_EQ(0, rtcp_packet_info_.applicationLength); 308 } 309 310 TEST_F(RtcpReceiverTest, InjectAppWithData) { 311 rtcp::App app; 312 app.WithSubType(30); 313 uint32_t name = 'n' << 24; 314 name += 'a' << 16; 315 name += 'm' << 8; 316 name += 'e'; 317 app.WithName(name); 318 const char kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'}; 319 const size_t kDataLength = sizeof(kData) / sizeof(kData[0]); 320 app.WithData((const uint8_t*)kData, kDataLength); 321 322 rtcp::RawPacket p = app.Build(); 323 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 324 EXPECT_EQ(kRtcpApp, rtcp_packet_info_.rtcpPacketTypeFlags); 325 EXPECT_EQ(30, rtcp_packet_info_.applicationSubType); 326 EXPECT_EQ(name, rtcp_packet_info_.applicationName); 327 EXPECT_EQ(kDataLength, rtcp_packet_info_.applicationLength); 328 } 329 330 TEST_F(RtcpReceiverTest, InjectSdesWithOneChunk) { 331 const uint32_t kSenderSsrc = 0x123456; 332 rtcp::Sdes sdes; 333 sdes.WithCName(kSenderSsrc, "alice@host"); 334 335 rtcp::RawPacket p = sdes.Build(); 336 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 337 char cName[RTCP_CNAME_SIZE]; 338 EXPECT_EQ(0, rtcp_receiver_->CNAME(kSenderSsrc, cName)); 339 EXPECT_EQ(0, strncmp(cName, "alice@host", RTCP_CNAME_SIZE)); 340 } 341 342 TEST_F(RtcpReceiverTest, InjectByePacket) { 343 const uint32_t kSenderSsrc = 0x123456; 344 rtcp::Sdes sdes; 345 sdes.WithCName(kSenderSsrc, "alice@host"); 346 347 rtcp::RawPacket p = sdes.Build(); 348 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 349 char cName[RTCP_CNAME_SIZE]; 350 EXPECT_EQ(0, rtcp_receiver_->CNAME(kSenderSsrc, cName)); 351 352 // Verify that BYE removes the CNAME. 353 rtcp::Bye bye; 354 bye.From(kSenderSsrc); 355 rtcp::RawPacket p2 = bye.Build(); 356 EXPECT_EQ(0, InjectRtcpPacket(p2.buffer(), p2.buffer_length())); 357 EXPECT_EQ(-1, rtcp_receiver_->CNAME(kSenderSsrc, cName)); 358 } 359 360 TEST_F(RtcpReceiverTest, InjectPliPacket) { 361 const uint32_t kSourceSsrc = 0x123456; 362 std::set<uint32_t> ssrcs; 363 ssrcs.insert(kSourceSsrc); 364 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 365 366 rtcp::Pli pli; 367 pli.To(kSourceSsrc); 368 rtcp::RawPacket p = pli.Build(); 369 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 370 EXPECT_EQ(kRtcpPli, rtcp_packet_info_.rtcpPacketTypeFlags); 371 } 372 373 TEST_F(RtcpReceiverTest, PliPacketNotToUsIgnored) { 374 const uint32_t kSourceSsrc = 0x123456; 375 std::set<uint32_t> ssrcs; 376 ssrcs.insert(kSourceSsrc); 377 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 378 379 rtcp::Pli pli; 380 pli.To(kSourceSsrc + 1); 381 rtcp::RawPacket p = pli.Build(); 382 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 383 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 384 } 385 386 TEST_F(RtcpReceiverTest, InjectFirPacket) { 387 const uint32_t kSourceSsrc = 0x123456; 388 std::set<uint32_t> ssrcs; 389 ssrcs.insert(kSourceSsrc); 390 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 391 392 rtcp::Fir fir; 393 fir.To(kSourceSsrc); 394 rtcp::RawPacket p = fir.Build(); 395 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 396 EXPECT_EQ(kRtcpFir, rtcp_packet_info_.rtcpPacketTypeFlags); 397 } 398 399 TEST_F(RtcpReceiverTest, FirPacketNotToUsIgnored) { 400 const uint32_t kSourceSsrc = 0x123456; 401 std::set<uint32_t> ssrcs; 402 ssrcs.insert(kSourceSsrc); 403 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 404 405 rtcp::Fir fir; 406 fir.To(kSourceSsrc + 1); 407 rtcp::RawPacket p = fir.Build(); 408 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 409 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 410 } 411 412 TEST_F(RtcpReceiverTest, InjectSliPacket) { 413 rtcp::Sli sli; 414 sli.WithPictureId(40); 415 rtcp::RawPacket p = sli.Build(); 416 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 417 EXPECT_EQ(kRtcpSli, rtcp_packet_info_.rtcpPacketTypeFlags); 418 EXPECT_EQ(40, rtcp_packet_info_.sliPictureId); 419 } 420 421 TEST_F(RtcpReceiverTest, XrPacketWithZeroReportBlocksIgnored) { 422 rtcp::Xr xr; 423 xr.From(0x2345); 424 rtcp::RawPacket p = xr.Build(); 425 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 426 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 427 } 428 429 TEST_F(RtcpReceiverTest, InjectXrVoipPacket) { 430 const uint32_t kSourceSsrc = 0x123456; 431 std::set<uint32_t> ssrcs; 432 ssrcs.insert(kSourceSsrc); 433 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 434 435 const uint8_t kLossRate = 123; 436 rtcp::VoipMetric voip_metric; 437 voip_metric.To(kSourceSsrc); 438 voip_metric.LossRate(kLossRate); 439 rtcp::Xr xr; 440 xr.From(0x2345); 441 xr.WithVoipMetric(&voip_metric); 442 rtcp::RawPacket p = xr.Build(); 443 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 444 ASSERT_TRUE(rtcp_packet_info_.VoIPMetric != NULL); 445 EXPECT_EQ(kLossRate, rtcp_packet_info_.VoIPMetric->lossRate); 446 EXPECT_EQ(kRtcpXrVoipMetric, rtcp_packet_info_.rtcpPacketTypeFlags); 447 } 448 449 TEST_F(RtcpReceiverTest, XrVoipPacketNotToUsIgnored) { 450 const uint32_t kSourceSsrc = 0x123456; 451 std::set<uint32_t> ssrcs; 452 ssrcs.insert(kSourceSsrc); 453 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 454 455 rtcp::VoipMetric voip_metric; 456 voip_metric.To(kSourceSsrc + 1); 457 rtcp::Xr xr; 458 xr.From(0x2345); 459 xr.WithVoipMetric(&voip_metric); 460 rtcp::RawPacket p = xr.Build(); 461 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 462 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 463 } 464 465 TEST_F(RtcpReceiverTest, InjectXrReceiverReferenceTimePacket) { 466 rtcp::Rrtr rrtr; 467 rrtr.WithNtpSec(0x10203); 468 rrtr.WithNtpFrac(0x40506); 469 rtcp::Xr xr; 470 xr.From(0x2345); 471 xr.WithRrtr(&rrtr); 472 473 rtcp::RawPacket p = xr.Build(); 474 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 475 EXPECT_EQ(kRtcpXrReceiverReferenceTime, 476 rtcp_packet_info_.rtcpPacketTypeFlags); 477 } 478 479 TEST_F(RtcpReceiverTest, XrDlrrPacketNotToUsIgnored) { 480 const uint32_t kSourceSsrc = 0x123456; 481 std::set<uint32_t> ssrcs; 482 ssrcs.insert(kSourceSsrc); 483 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 484 485 rtcp::Dlrr dlrr; 486 dlrr.WithDlrrItem(kSourceSsrc + 1, 0x12345, 0x67890); 487 rtcp::Xr xr; 488 xr.From(0x2345); 489 xr.WithDlrr(&dlrr); 490 rtcp::RawPacket p = xr.Build(); 491 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 492 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 493 EXPECT_FALSE(rtcp_packet_info_.xr_dlrr_item); 494 } 495 496 TEST_F(RtcpReceiverTest, InjectXrDlrrPacketWithSubBlock) { 497 const uint32_t kSourceSsrc = 0x123456; 498 std::set<uint32_t> ssrcs; 499 ssrcs.insert(kSourceSsrc); 500 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 501 502 rtcp::Dlrr dlrr; 503 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890); 504 rtcp::Xr xr; 505 xr.From(0x2345); 506 xr.WithDlrr(&dlrr); 507 rtcp::RawPacket p = xr.Build(); 508 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 509 // The parser should note the DLRR report block item, but not flag the packet 510 // since the RTT is not estimated. 511 EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item); 512 } 513 514 TEST_F(RtcpReceiverTest, InjectXrDlrrPacketWithMultipleSubBlocks) { 515 const uint32_t kSourceSsrc = 0x123456; 516 std::set<uint32_t> ssrcs; 517 ssrcs.insert(kSourceSsrc); 518 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 519 520 rtcp::Dlrr dlrr; 521 dlrr.WithDlrrItem(kSourceSsrc + 1, 0x12345, 0x67890); 522 dlrr.WithDlrrItem(kSourceSsrc + 2, 0x12345, 0x67890); 523 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890); 524 rtcp::Xr xr; 525 xr.From(0x2345); 526 xr.WithDlrr(&dlrr); 527 rtcp::RawPacket p = xr.Build(); 528 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 529 // The parser should note the DLRR report block item, but not flag the packet 530 // since the RTT is not estimated. 531 EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item); 532 } 533 534 TEST_F(RtcpReceiverTest, InjectXrPacketWithMultipleReportBlocks) { 535 const uint32_t kSourceSsrc = 0x123456; 536 std::set<uint32_t> ssrcs; 537 ssrcs.insert(kSourceSsrc); 538 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 539 540 rtcp::Rrtr rrtr; 541 rtcp::Dlrr dlrr; 542 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890); 543 rtcp::VoipMetric metric; 544 metric.To(kSourceSsrc); 545 rtcp::Xr xr; 546 xr.From(0x2345); 547 xr.WithRrtr(&rrtr); 548 xr.WithDlrr(&dlrr); 549 xr.WithVoipMetric(&metric); 550 rtcp::RawPacket p = xr.Build(); 551 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 552 EXPECT_EQ(static_cast<unsigned int>(kRtcpXrReceiverReferenceTime + 553 kRtcpXrVoipMetric), 554 rtcp_packet_info_.rtcpPacketTypeFlags); 555 // The parser should note the DLRR report block item, but not flag the packet 556 // since the RTT is not estimated. 557 EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item); 558 } 559 560 TEST_F(RtcpReceiverTest, InjectXrPacketWithUnknownReportBlock) { 561 const uint32_t kSourceSsrc = 0x123456; 562 std::set<uint32_t> ssrcs; 563 ssrcs.insert(kSourceSsrc); 564 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 565 std::vector<uint32_t> remote_ssrcs; 566 remote_ssrcs.push_back(kSourceSsrc); 567 568 rtcp::Rrtr rrtr; 569 rtcp::Dlrr dlrr; 570 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890); 571 rtcp::VoipMetric metric; 572 metric.To(kSourceSsrc); 573 rtcp::Xr xr; 574 xr.From(0x2345); 575 xr.WithRrtr(&rrtr); 576 xr.WithDlrr(&dlrr); 577 xr.WithVoipMetric(&metric); 578 rtcp::RawPacket p = xr.Build(); 579 // Modify the DLRR block to have an unsupported block type, from 5 to 6. 580 uint8_t* buffer = const_cast<uint8_t*>(p.buffer()); 581 EXPECT_EQ(5, buffer[20]); 582 buffer[20] = 6; 583 584 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 585 EXPECT_EQ(static_cast<unsigned int>(kRtcpXrReceiverReferenceTime + 586 kRtcpXrVoipMetric), 587 rtcp_packet_info_.rtcpPacketTypeFlags); 588 EXPECT_FALSE(rtcp_packet_info_.xr_dlrr_item); 589 } 590 591 TEST(RtcpUtilityTest, MidNtp) { 592 const uint32_t kNtpSec = 0x12345678; 593 const uint32_t kNtpFrac = 0x23456789; 594 const uint32_t kNtpMid = 0x56782345; 595 EXPECT_EQ(kNtpMid, RTCPUtility::MidNtp(kNtpSec, kNtpFrac)); 596 } 597 598 TEST_F(RtcpReceiverTest, TestXrRrRttInitiallyFalse) { 599 uint16_t rtt_ms; 600 EXPECT_FALSE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms)); 601 } 602 603 TEST_F(RtcpReceiverTest, LastReceivedXrReferenceTimeInfoInitiallyFalse) { 604 RtcpReceiveTimeInfo info; 605 EXPECT_FALSE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info)); 606 } 607 608 TEST_F(RtcpReceiverTest, GetLastReceivedXrReferenceTimeInfo) { 609 const uint32_t kSenderSsrc = 0x123456; 610 const uint32_t kNtpSec = 0x10203; 611 const uint32_t kNtpFrac = 0x40506; 612 const uint32_t kNtpMid = RTCPUtility::MidNtp(kNtpSec, kNtpFrac); 613 614 rtcp::Rrtr rrtr; 615 rrtr.WithNtpSec(kNtpSec); 616 rrtr.WithNtpFrac(kNtpFrac); 617 rtcp::Xr xr; 618 xr.From(kSenderSsrc); 619 xr.WithRrtr(&rrtr); 620 rtcp::RawPacket p = xr.Build(); 621 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 622 EXPECT_EQ(kRtcpXrReceiverReferenceTime, 623 rtcp_packet_info_.rtcpPacketTypeFlags); 624 625 RtcpReceiveTimeInfo info; 626 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info)); 627 EXPECT_EQ(kSenderSsrc, info.sourceSSRC); 628 EXPECT_EQ(kNtpMid, info.lastRR); 629 EXPECT_EQ(0U, info.delaySinceLastRR); 630 631 system_clock_.AdvanceTimeMilliseconds(1000); 632 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info)); 633 EXPECT_EQ(65536U, info.delaySinceLastRR); 634 } 635 636 TEST_F(RtcpReceiverTest, ReceiveReportTimeout) { 637 const uint32_t kSenderSsrc = 0x10203; 638 const uint32_t kSourceSsrc = 0x40506; 639 const int64_t kRtcpIntervalMs = 1000; 640 641 std::set<uint32_t> ssrcs; 642 ssrcs.insert(kSourceSsrc); 643 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 644 645 const uint16_t kSequenceNumber = 1234; 646 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); 647 648 // No RR received, shouldn't trigger a timeout. 649 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 650 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 651 652 // Add a RR and advance the clock just enough to not trigger a timeout. 653 rtcp::ReportBlock rb1; 654 rb1.To(kSourceSsrc); 655 rb1.WithExtHighestSeqNum(kSequenceNumber); 656 rtcp::ReceiverReport rr1; 657 rr1.From(kSenderSsrc); 658 rr1.WithReportBlock(&rb1); 659 rtcp::RawPacket p1 = rr1.Build(); 660 EXPECT_EQ(0, InjectRtcpPacket(p1.buffer(), p1.buffer_length())); 661 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs - 1); 662 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 663 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 664 665 // Add a RR with the same extended max as the previous RR to trigger a 666 // sequence number timeout, but not a RR timeout. 667 EXPECT_EQ(0, InjectRtcpPacket(p1.buffer(), p1.buffer_length())); 668 system_clock_.AdvanceTimeMilliseconds(2); 669 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 670 EXPECT_TRUE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 671 672 // Advance clock enough to trigger an RR timeout too. 673 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); 674 EXPECT_TRUE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 675 676 // We should only get one timeout even though we still haven't received a new 677 // RR. 678 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 679 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 680 681 // Add a new RR with increase sequence number to reset timers. 682 rtcp::ReportBlock rb2; 683 rb2.To(kSourceSsrc); 684 rb2.WithExtHighestSeqNum(kSequenceNumber + 1); 685 rtcp::ReceiverReport rr2; 686 rr2.From(kSenderSsrc); 687 rr2.WithReportBlock(&rb2); 688 rtcp::RawPacket p2 = rr2.Build(); 689 EXPECT_EQ(0, InjectRtcpPacket(p2.buffer(), p2.buffer_length())); 690 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 691 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 692 693 // Verify we can get a timeout again once we've received new RR. 694 system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); 695 EXPECT_EQ(0, InjectRtcpPacket(p2.buffer(), p2.buffer_length())); 696 system_clock_.AdvanceTimeMilliseconds(kRtcpIntervalMs + 1); 697 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 698 EXPECT_TRUE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 699 system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); 700 EXPECT_TRUE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 701 } 702 703 TEST_F(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) { 704 // This call is expected to fail because no data has arrived. 705 EXPECT_EQ(-1, rtcp_receiver_->TMMBRReceived(0, 0, NULL)); 706 } 707 708 TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) { 709 const uint32_t kMediaFlowSsrc = 0x2040608; 710 const uint32_t kSenderSsrc = 0x10203; 711 std::set<uint32_t> ssrcs; 712 ssrcs.insert(kMediaFlowSsrc); // Matches "media source" above. 713 rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs); 714 715 rtcp::Tmmbr tmmbr; 716 tmmbr.From(kSenderSsrc); 717 tmmbr.To(kMediaFlowSsrc); 718 tmmbr.WithBitrateKbps(30); 719 720 rtcp::SenderReport sr; 721 sr.From(kSenderSsrc); 722 sr.Append(&tmmbr); 723 rtcp::RawPacket p = sr.Build(); 724 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 725 726 EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(0, 0, NULL)); 727 TMMBRSet candidate_set; 728 candidate_set.VerifyAndAllocateSet(1); 729 EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(1, 0, &candidate_set)); 730 EXPECT_LT(0U, candidate_set.Tmmbr(0)); 731 EXPECT_EQ(kSenderSsrc, candidate_set.Ssrc(0)); 732 } 733 734 TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) { 735 const uint32_t kMediaFlowSsrc = 0x2040608; 736 const uint32_t kSenderSsrc = 0x10203; 737 738 rtcp::Tmmbr tmmbr; 739 tmmbr.From(kSenderSsrc); 740 tmmbr.To(kMediaFlowSsrc + 1); // This SSRC is not what we are sending. 741 tmmbr.WithBitrateKbps(30); 742 743 rtcp::SenderReport sr; 744 sr.From(kSenderSsrc); 745 sr.Append(&tmmbr); 746 rtcp::RawPacket p = sr.Build(); 747 748 std::set<uint32_t> ssrcs; 749 ssrcs.insert(kMediaFlowSsrc); 750 rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs); 751 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 752 EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, NULL)); 753 } 754 755 TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) { 756 const uint32_t kMediaFlowSsrc = 0x2040608; 757 const uint32_t kSenderSsrc = 0x10203; 758 std::set<uint32_t> ssrcs; 759 ssrcs.insert(kMediaFlowSsrc); // Matches "media source" above. 760 rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs); 761 762 rtcp::Tmmbr tmmbr; 763 tmmbr.From(kSenderSsrc); 764 tmmbr.To(kMediaFlowSsrc); 765 tmmbr.WithBitrateKbps(0); 766 767 rtcp::SenderReport sr; 768 sr.From(kSenderSsrc); 769 sr.Append(&tmmbr); 770 rtcp::RawPacket p = sr.Build(); 771 772 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 773 EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, NULL)); 774 } 775 776 TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) { 777 const uint32_t kMediaFlowSsrc = 0x2040608; 778 const uint32_t kSenderSsrc = 0x10203; 779 std::set<uint32_t> ssrcs; 780 ssrcs.insert(kMediaFlowSsrc); // Matches "media source" above. 781 rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs); 782 783 // Inject 3 packets "from" kSenderSsrc, kSenderSsrc+1, kSenderSsrc+2. 784 // The times of arrival are starttime + 0, starttime + 5 and starttime + 10. 785 for (uint32_t ssrc = kSenderSsrc; ssrc < kSenderSsrc + 3; ++ssrc) { 786 rtcp::Tmmbr tmmbr; 787 tmmbr.From(ssrc); 788 tmmbr.To(kMediaFlowSsrc); 789 tmmbr.WithBitrateKbps(30); 790 791 rtcp::SenderReport sr; 792 sr.From(ssrc); 793 sr.Append(&tmmbr); 794 rtcp::RawPacket p = sr.Build(); 795 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 796 // 5 seconds between each packet. 797 system_clock_.AdvanceTimeMilliseconds(5000); 798 } 799 // It is now starttime + 15. 800 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, NULL)); 801 TMMBRSet candidate_set; 802 candidate_set.VerifyAndAllocateSet(3); 803 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set)); 804 EXPECT_LT(0U, candidate_set.Tmmbr(0)); 805 // We expect the timeout to be 25 seconds. Advance the clock by 12 806 // seconds, timing out the first packet. 807 system_clock_.AdvanceTimeMilliseconds(12000); 808 // Odd behaviour: Just counting them does not trigger the timeout. 809 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, NULL)); 810 EXPECT_EQ(2, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set)); 811 EXPECT_EQ(kSenderSsrc + 1, candidate_set.Ssrc(0)); 812 } 813 814 TEST_F(RtcpReceiverTest, Callbacks) { 815 class RtcpCallbackImpl : public RtcpStatisticsCallback { 816 public: 817 RtcpCallbackImpl() : RtcpStatisticsCallback(), ssrc_(0) {} 818 virtual ~RtcpCallbackImpl() {} 819 820 virtual void StatisticsUpdated(const RtcpStatistics& statistics, 821 uint32_t ssrc) { 822 stats_ = statistics; 823 ssrc_ = ssrc; 824 } 825 826 bool Matches(uint32_t ssrc, uint32_t extended_max, uint8_t fraction_loss, 827 uint32_t cumulative_loss, uint32_t jitter) { 828 return ssrc_ == ssrc && 829 stats_.fraction_lost == fraction_loss && 830 stats_.cumulative_lost == cumulative_loss && 831 stats_.extended_max_sequence_number == extended_max && 832 stats_.jitter == jitter; 833 } 834 835 RtcpStatistics stats_; 836 uint32_t ssrc_; 837 } callback; 838 839 rtcp_receiver_->RegisterRtcpStatisticsCallback(&callback); 840 841 const uint32_t kSenderSsrc = 0x10203; 842 const uint32_t kSourceSsrc = 0x123456; 843 const uint8_t kFractionLoss = 3; 844 const uint32_t kCumulativeLoss = 7; 845 const uint32_t kJitter = 9; 846 const uint16_t kSequenceNumber = 1234; 847 848 std::set<uint32_t> ssrcs; 849 ssrcs.insert(kSourceSsrc); 850 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 851 852 // First packet, all numbers should just propagate. 853 rtcp::ReportBlock rb1; 854 rb1.To(kSourceSsrc); 855 rb1.WithExtHighestSeqNum(kSequenceNumber); 856 rb1.WithFractionLost(kFractionLoss); 857 rb1.WithCumulativeLost(kCumulativeLoss); 858 rb1.WithJitter(kJitter); 859 860 rtcp::ReceiverReport rr1; 861 rr1.From(kSenderSsrc); 862 rr1.WithReportBlock(&rb1); 863 rtcp::RawPacket p1 = rr1.Build(); 864 EXPECT_EQ(0, InjectRtcpPacket(p1.buffer(), p1.buffer_length())); 865 EXPECT_TRUE(callback.Matches(kSourceSsrc, kSequenceNumber, kFractionLoss, 866 kCumulativeLoss, kJitter)); 867 868 rtcp_receiver_->RegisterRtcpStatisticsCallback(NULL); 869 870 // Add arbitrary numbers, callback should not be called (retain old values). 871 rtcp::ReportBlock rb2; 872 rb2.To(kSourceSsrc); 873 rb2.WithExtHighestSeqNum(kSequenceNumber + 1); 874 rb2.WithFractionLost(42); 875 rb2.WithCumulativeLost(137); 876 rb2.WithJitter(4711); 877 878 rtcp::ReceiverReport rr2; 879 rr2.From(kSenderSsrc); 880 rr2.WithReportBlock(&rb2); 881 rtcp::RawPacket p2 = rr2.Build(); 882 EXPECT_EQ(0, InjectRtcpPacket(p2.buffer(), p2.buffer_length())); 883 EXPECT_TRUE(callback.Matches(kSourceSsrc, kSequenceNumber, kFractionLoss, 884 kCumulativeLoss, kJitter)); 885 } 886 887 } // Anonymous namespace 888 889 } // namespace webrtc 890
