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 #include "webrtc/common_types.h" 19 #include "webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitrate_observer.h" 20 #include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.h" 21 #include "webrtc/modules/rtp_rtcp/source/byte_io.h" 22 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h" 23 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h" 24 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h" 25 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h" 26 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.h" 27 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h" 28 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sli.h" 29 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h" 30 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" 31 #include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h" 32 #include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h" 33 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h" 34 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h" 35 36 namespace webrtc { 37 38 namespace { // Anonymous namespace; hide utility functions and classes. 39 40 // This test transport verifies that no functions get called. 41 class TestTransport : public Transport, 42 public NullRtpData { 43 public: 44 explicit TestTransport() : rtcp_receiver_(nullptr) {} 45 void SetRTCPReceiver(RTCPReceiver* rtcp_receiver) { 46 rtcp_receiver_ = rtcp_receiver; 47 } 48 bool SendRtp(const uint8_t* /*data*/, 49 size_t /*len*/, 50 const PacketOptions& options) override { 51 ADD_FAILURE(); // FAIL() gives a compile error. 52 return false; 53 } 54 55 bool SendRtcp(const uint8_t* packet, size_t packet_len) override { 56 ADD_FAILURE(); 57 return true; 58 } 59 60 int OnReceivedPayloadData(const uint8_t* payloadData, 61 const size_t payloadSize, 62 const WebRtcRTPHeader* rtpHeader) override { 63 ADD_FAILURE(); 64 return 0; 65 } 66 RTCPReceiver* rtcp_receiver_; 67 }; 68 69 class RtcpReceiverTest : public ::testing::Test { 70 protected: 71 RtcpReceiverTest() 72 : over_use_detector_options_(), 73 system_clock_(1335900000), 74 remote_bitrate_observer_(), 75 remote_bitrate_estimator_( 76 new RemoteBitrateEstimatorSingleStream(&remote_bitrate_observer_, 77 &system_clock_)) { 78 test_transport_ = new TestTransport(); 79 80 RtpRtcp::Configuration configuration; 81 configuration.audio = false; 82 configuration.clock = &system_clock_; 83 configuration.outgoing_transport = test_transport_; 84 configuration.remote_bitrate_estimator = remote_bitrate_estimator_.get(); 85 rtp_rtcp_impl_ = new ModuleRtpRtcpImpl(configuration); 86 rtcp_receiver_ = new RTCPReceiver(&system_clock_, false, nullptr, nullptr, 87 nullptr, nullptr, rtp_rtcp_impl_); 88 test_transport_->SetRTCPReceiver(rtcp_receiver_); 89 } 90 ~RtcpReceiverTest() { 91 delete rtcp_receiver_; 92 delete rtp_rtcp_impl_; 93 delete test_transport_; 94 } 95 96 // Injects an RTCP packet into the receiver. 97 // Returns 0 for OK, non-0 for failure. 98 int InjectRtcpPacket(const uint8_t* packet, 99 uint16_t packet_len) { 100 RTCPUtility::RTCPParserV2 rtcpParser(packet, 101 packet_len, 102 true); // Allow non-compound RTCP 103 104 RTCPHelp::RTCPPacketInformation rtcpPacketInformation; 105 EXPECT_EQ(0, rtcp_receiver_->IncomingRTCPPacket(rtcpPacketInformation, 106 &rtcpParser)); 107 rtcp_receiver_->TriggerCallbacksFromRTCPPacket(rtcpPacketInformation); 108 // The NACK list is on purpose not copied below as it isn't needed by the 109 // test. 110 rtcp_packet_info_.rtcpPacketTypeFlags = 111 rtcpPacketInformation.rtcpPacketTypeFlags; 112 rtcp_packet_info_.remoteSSRC = rtcpPacketInformation.remoteSSRC; 113 rtcp_packet_info_.applicationSubType = 114 rtcpPacketInformation.applicationSubType; 115 rtcp_packet_info_.applicationName = rtcpPacketInformation.applicationName; 116 rtcp_packet_info_.applicationLength = 117 rtcpPacketInformation.applicationLength; 118 rtcp_packet_info_.report_blocks = rtcpPacketInformation.report_blocks; 119 rtcp_packet_info_.rtt = rtcpPacketInformation.rtt; 120 rtcp_packet_info_.interArrivalJitter = 121 rtcpPacketInformation.interArrivalJitter; 122 rtcp_packet_info_.sliPictureId = rtcpPacketInformation.sliPictureId; 123 rtcp_packet_info_.rpsiPictureId = rtcpPacketInformation.rpsiPictureId; 124 rtcp_packet_info_.receiverEstimatedMaxBitrate = 125 rtcpPacketInformation.receiverEstimatedMaxBitrate; 126 rtcp_packet_info_.ntp_secs = rtcpPacketInformation.ntp_secs; 127 rtcp_packet_info_.ntp_frac = rtcpPacketInformation.ntp_frac; 128 rtcp_packet_info_.rtp_timestamp = rtcpPacketInformation.rtp_timestamp; 129 rtcp_packet_info_.xr_dlrr_item = rtcpPacketInformation.xr_dlrr_item; 130 if (rtcpPacketInformation.VoIPMetric) 131 rtcp_packet_info_.AddVoIPMetric(rtcpPacketInformation.VoIPMetric); 132 rtcp_packet_info_.transport_feedback_.reset( 133 rtcpPacketInformation.transport_feedback_.release()); 134 return 0; 135 } 136 137 OverUseDetectorOptions over_use_detector_options_; 138 SimulatedClock system_clock_; 139 ModuleRtpRtcpImpl* rtp_rtcp_impl_; 140 RTCPReceiver* rtcp_receiver_; 141 TestTransport* test_transport_; 142 RTCPHelp::RTCPPacketInformation rtcp_packet_info_; 143 MockRemoteBitrateObserver remote_bitrate_observer_; 144 rtc::scoped_ptr<RemoteBitrateEstimator> remote_bitrate_estimator_; 145 }; 146 147 148 TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) { 149 const uint8_t bad_packet[] = {0, 0, 0, 0}; 150 EXPECT_EQ(0, InjectRtcpPacket(bad_packet, sizeof(bad_packet))); 151 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 152 } 153 154 TEST_F(RtcpReceiverTest, InjectSrPacket) { 155 const uint32_t kSenderSsrc = 0x10203; 156 rtcp::SenderReport sr; 157 sr.From(kSenderSsrc); 158 rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build()); 159 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 160 // The parser will note the remote SSRC on a SR from other than his 161 // expected peer, but will not flag that he's gotten a packet. 162 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); 163 EXPECT_EQ(0U, 164 kRtcpSr & rtcp_packet_info_.rtcpPacketTypeFlags); 165 } 166 167 TEST_F(RtcpReceiverTest, InjectSrPacketFromExpectedPeer) { 168 const uint32_t kSenderSsrc = 0x10203; 169 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); 170 rtcp::SenderReport sr; 171 sr.From(kSenderSsrc); 172 rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build()); 173 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 174 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); 175 EXPECT_EQ(kRtcpSr, rtcp_packet_info_.rtcpPacketTypeFlags); 176 } 177 178 TEST_F(RtcpReceiverTest, InjectRrPacket) { 179 const uint32_t kSenderSsrc = 0x10203; 180 rtcp::ReceiverReport rr; 181 rr.From(kSenderSsrc); 182 rtc::scoped_ptr<rtcp::RawPacket> packet(rr.Build()); 183 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 184 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); 185 EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags); 186 ASSERT_EQ(0u, rtcp_packet_info_.report_blocks.size()); 187 } 188 189 TEST_F(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) { 190 const uint32_t kSenderSsrc = 0x10203; 191 const uint32_t kSourceSsrc = 0x123456; 192 std::set<uint32_t> ssrcs; 193 ssrcs.insert(kSourceSsrc); 194 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 195 196 rtcp::ReportBlock rb; 197 rb.To(kSourceSsrc + 1); 198 rtcp::ReceiverReport rr; 199 rr.From(kSenderSsrc); 200 rr.WithReportBlock(rb); 201 rtc::scoped_ptr<rtcp::RawPacket> packet(rr.Build()); 202 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 203 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); 204 EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags); 205 ASSERT_EQ(0u, rtcp_packet_info_.report_blocks.size()); 206 207 std::vector<RTCPReportBlock> received_blocks; 208 rtcp_receiver_->StatisticsReceived(&received_blocks); 209 EXPECT_TRUE(received_blocks.empty()); 210 } 211 212 TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) { 213 const uint32_t kSenderSsrc = 0x10203; 214 const uint32_t kSourceSsrc = 0x123456; 215 std::set<uint32_t> ssrcs; 216 ssrcs.insert(kSourceSsrc); 217 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 218 219 rtcp::ReportBlock rb; 220 rb.To(kSourceSsrc); 221 rtcp::ReceiverReport rr; 222 rr.From(kSenderSsrc); 223 rr.WithReportBlock(rb); 224 rtc::scoped_ptr<rtcp::RawPacket> packet(rr.Build()); 225 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 226 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); 227 EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags); 228 ASSERT_EQ(1u, rtcp_packet_info_.report_blocks.size()); 229 230 std::vector<RTCPReportBlock> received_blocks; 231 rtcp_receiver_->StatisticsReceived(&received_blocks); 232 EXPECT_EQ(1u, received_blocks.size()); 233 } 234 235 TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) { 236 const uint32_t kSenderSsrc = 0x10203; 237 const uint32_t kSourceSsrcs[] = {0x40506, 0x50607}; 238 const uint16_t kSequenceNumbers[] = {10, 12423}; 239 const uint32_t kCumLost[] = {13, 555}; 240 const uint8_t kFracLost[] = {20, 11}; 241 const int kNumSsrcs = sizeof(kSourceSsrcs) / sizeof(kSourceSsrcs[0]); 242 243 std::set<uint32_t> ssrcs(kSourceSsrcs, kSourceSsrcs + kNumSsrcs); 244 rtcp_receiver_->SetSsrcs(kSourceSsrcs[0], ssrcs); 245 246 rtcp::ReportBlock rb1; 247 rb1.To(kSourceSsrcs[0]); 248 rb1.WithExtHighestSeqNum(kSequenceNumbers[0]); 249 rb1.WithFractionLost(10); 250 rb1.WithCumulativeLost(5); 251 252 rtcp::ReportBlock rb2; 253 rb2.To(kSourceSsrcs[1]); 254 rb2.WithExtHighestSeqNum(kSequenceNumbers[1]); 255 256 rtcp::ReceiverReport rr1; 257 rr1.From(kSenderSsrc); 258 rr1.WithReportBlock(rb1); 259 rr1.WithReportBlock(rb2); 260 261 rtc::scoped_ptr<rtcp::RawPacket> p1(rr1.Build()); 262 EXPECT_EQ(0, InjectRtcpPacket(p1->Buffer(), p1->Length())); 263 ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size()); 264 EXPECT_EQ(10, rtcp_packet_info_.report_blocks.front().fractionLost); 265 EXPECT_EQ(0, rtcp_packet_info_.report_blocks.back().fractionLost); 266 267 rtcp::ReportBlock rb3; 268 rb3.To(kSourceSsrcs[0]); 269 rb3.WithExtHighestSeqNum(kSequenceNumbers[0]); 270 rb3.WithFractionLost(kFracLost[0]); 271 rb3.WithCumulativeLost(kCumLost[0]); 272 273 rtcp::ReportBlock rb4; 274 rb4.To(kSourceSsrcs[1]); 275 rb4.WithExtHighestSeqNum(kSequenceNumbers[1]); 276 rb4.WithFractionLost(kFracLost[1]); 277 rb4.WithCumulativeLost(kCumLost[1]); 278 279 rtcp::ReceiverReport rr2; 280 rr2.From(kSenderSsrc); 281 rr2.WithReportBlock(rb3); 282 rr2.WithReportBlock(rb4); 283 284 rtc::scoped_ptr<rtcp::RawPacket> p2(rr2.Build()); 285 EXPECT_EQ(0, InjectRtcpPacket(p2->Buffer(), p2->Length())); 286 ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size()); 287 EXPECT_EQ(kFracLost[0], rtcp_packet_info_.report_blocks.front().fractionLost); 288 EXPECT_EQ(kFracLost[1], rtcp_packet_info_.report_blocks.back().fractionLost); 289 290 std::vector<RTCPReportBlock> received_blocks; 291 rtcp_receiver_->StatisticsReceived(&received_blocks); 292 EXPECT_EQ(2u, received_blocks.size()); 293 for (size_t i = 0; i < received_blocks.size(); ++i) { 294 EXPECT_EQ(kSenderSsrc, received_blocks[i].remoteSSRC); 295 EXPECT_EQ(kSourceSsrcs[i], received_blocks[i].sourceSSRC); 296 EXPECT_EQ(kFracLost[i], received_blocks[i].fractionLost); 297 EXPECT_EQ(kCumLost[i], received_blocks[i].cumulativeLost); 298 EXPECT_EQ(kSequenceNumbers[i], received_blocks[i].extendedHighSeqNum); 299 } 300 } 301 302 TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) { 303 const uint32_t kSenderSsrc1 = 0x10203; 304 const uint32_t kSenderSsrc2 = 0x20304; 305 const uint32_t kSourceSsrcs[] = {0x40506, 0x50607}; 306 const uint16_t kSequenceNumbers[] = {10, 12423}; 307 const uint32_t kCumLost[] = {13, 555}; 308 const uint8_t kFracLost[] = {20, 11}; 309 const int kNumSsrcs = sizeof(kSourceSsrcs) / sizeof(kSourceSsrcs[0]); 310 311 std::set<uint32_t> ssrcs(kSourceSsrcs, kSourceSsrcs + kNumSsrcs); 312 rtcp_receiver_->SetSsrcs(kSourceSsrcs[0], ssrcs); 313 314 rtcp::ReportBlock rb1; 315 rb1.To(kSourceSsrcs[0]); 316 rb1.WithExtHighestSeqNum(kSequenceNumbers[0]); 317 rb1.WithFractionLost(kFracLost[0]); 318 rb1.WithCumulativeLost(kCumLost[0]); 319 rtcp::ReceiverReport rr1; 320 rr1.From(kSenderSsrc1); 321 rr1.WithReportBlock(rb1); 322 323 rtc::scoped_ptr<rtcp::RawPacket> p1(rr1.Build()); 324 EXPECT_EQ(0, InjectRtcpPacket(p1->Buffer(), p1->Length())); 325 ASSERT_EQ(1u, rtcp_packet_info_.report_blocks.size()); 326 EXPECT_EQ(kFracLost[0], rtcp_packet_info_.report_blocks.front().fractionLost); 327 328 std::vector<RTCPReportBlock> received_blocks; 329 rtcp_receiver_->StatisticsReceived(&received_blocks); 330 EXPECT_EQ(1u, received_blocks.size()); 331 EXPECT_EQ(kSenderSsrc1, received_blocks[0].remoteSSRC); 332 EXPECT_EQ(kSourceSsrcs[0], received_blocks[0].sourceSSRC); 333 EXPECT_EQ(kFracLost[0], received_blocks[0].fractionLost); 334 EXPECT_EQ(kCumLost[0], received_blocks[0].cumulativeLost); 335 EXPECT_EQ(kSequenceNumbers[0], received_blocks[0].extendedHighSeqNum); 336 337 rtcp::ReportBlock rb2; 338 rb2.To(kSourceSsrcs[0]); 339 rb2.WithExtHighestSeqNum(kSequenceNumbers[1]); 340 rb2.WithFractionLost(kFracLost[1]); 341 rb2.WithCumulativeLost(kCumLost[1]); 342 rtcp::ReceiverReport rr2; 343 rr2.From(kSenderSsrc2); 344 rr2.WithReportBlock(rb2); 345 rtc::scoped_ptr<rtcp::RawPacket> p2(rr2.Build()); 346 EXPECT_EQ(0, InjectRtcpPacket(p2->Buffer(), p2->Length())); 347 ASSERT_EQ(1u, rtcp_packet_info_.report_blocks.size()); 348 EXPECT_EQ(kFracLost[1], rtcp_packet_info_.report_blocks.front().fractionLost); 349 350 received_blocks.clear(); 351 rtcp_receiver_->StatisticsReceived(&received_blocks); 352 ASSERT_EQ(2u, received_blocks.size()); 353 EXPECT_EQ(kSenderSsrc1, received_blocks[0].remoteSSRC); 354 EXPECT_EQ(kSenderSsrc2, received_blocks[1].remoteSSRC); 355 for (size_t i = 0; i < received_blocks.size(); ++i) { 356 EXPECT_EQ(kSourceSsrcs[0], received_blocks[i].sourceSSRC); 357 EXPECT_EQ(kFracLost[i], received_blocks[i].fractionLost); 358 EXPECT_EQ(kCumLost[i], received_blocks[i].cumulativeLost); 359 EXPECT_EQ(kSequenceNumbers[i], received_blocks[i].extendedHighSeqNum); 360 } 361 } 362 363 TEST_F(RtcpReceiverTest, GetRtt) { 364 const uint32_t kSenderSsrc = 0x10203; 365 const uint32_t kSourceSsrc = 0x123456; 366 std::set<uint32_t> ssrcs; 367 ssrcs.insert(kSourceSsrc); 368 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 369 370 // No report block received. 371 EXPECT_EQ( 372 -1, rtcp_receiver_->RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr)); 373 374 rtcp::ReportBlock rb; 375 rb.To(kSourceSsrc); 376 rtcp::ReceiverReport rr; 377 rr.From(kSenderSsrc); 378 rr.WithReportBlock(rb); 379 rtc::scoped_ptr<rtcp::RawPacket> packet(rr.Build()); 380 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 381 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); 382 EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags); 383 EXPECT_EQ(1u, rtcp_packet_info_.report_blocks.size()); 384 EXPECT_EQ( 385 0, rtcp_receiver_->RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr)); 386 387 // Report block not received. 388 EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc + 1, nullptr, nullptr, nullptr, 389 nullptr)); 390 } 391 392 TEST_F(RtcpReceiverTest, InjectIjWithNoItem) { 393 rtcp::ExtendedJitterReport ij; 394 rtc::scoped_ptr<rtcp::RawPacket> packet(ij.Build()); 395 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 396 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 397 } 398 399 TEST_F(RtcpReceiverTest, InjectIjWithOneItem) { 400 rtcp::ExtendedJitterReport ij; 401 ij.WithJitter(0x11213141); 402 403 rtc::scoped_ptr<rtcp::RawPacket> packet(ij.Build()); 404 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 405 EXPECT_EQ(kRtcpTransmissionTimeOffset, rtcp_packet_info_.rtcpPacketTypeFlags); 406 EXPECT_EQ(0x11213141U, rtcp_packet_info_.interArrivalJitter); 407 } 408 409 TEST_F(RtcpReceiverTest, InjectAppWithNoData) { 410 rtcp::App app; 411 app.WithSubType(30); 412 uint32_t name = 'n' << 24; 413 name += 'a' << 16; 414 name += 'm' << 8; 415 name += 'e'; 416 app.WithName(name); 417 418 rtc::scoped_ptr<rtcp::RawPacket> packet(app.Build()); 419 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 420 EXPECT_EQ(kRtcpApp, rtcp_packet_info_.rtcpPacketTypeFlags); 421 EXPECT_EQ(30, rtcp_packet_info_.applicationSubType); 422 EXPECT_EQ(name, rtcp_packet_info_.applicationName); 423 EXPECT_EQ(0, rtcp_packet_info_.applicationLength); 424 } 425 426 TEST_F(RtcpReceiverTest, InjectAppWithData) { 427 rtcp::App app; 428 app.WithSubType(30); 429 uint32_t name = 'n' << 24; 430 name += 'a' << 16; 431 name += 'm' << 8; 432 name += 'e'; 433 app.WithName(name); 434 const char kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'}; 435 const size_t kDataLength = sizeof(kData) / sizeof(kData[0]); 436 app.WithData((const uint8_t*)kData, kDataLength); 437 438 rtc::scoped_ptr<rtcp::RawPacket> packet(app.Build()); 439 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 440 EXPECT_EQ(kRtcpApp, rtcp_packet_info_.rtcpPacketTypeFlags); 441 EXPECT_EQ(30, rtcp_packet_info_.applicationSubType); 442 EXPECT_EQ(name, rtcp_packet_info_.applicationName); 443 EXPECT_EQ(kDataLength, rtcp_packet_info_.applicationLength); 444 } 445 446 TEST_F(RtcpReceiverTest, InjectSdesWithOneChunk) { 447 const uint32_t kSenderSsrc = 0x123456; 448 rtcp::Sdes sdes; 449 sdes.WithCName(kSenderSsrc, "alice@host"); 450 451 rtc::scoped_ptr<rtcp::RawPacket> packet(sdes.Build()); 452 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 453 char cName[RTCP_CNAME_SIZE]; 454 EXPECT_EQ(0, rtcp_receiver_->CNAME(kSenderSsrc, cName)); 455 EXPECT_EQ(0, strncmp(cName, "alice@host", RTCP_CNAME_SIZE)); 456 } 457 458 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) { 459 const uint32_t kSenderSsrc = 0x123456; 460 rtcp::Sdes sdes; 461 sdes.WithCName(kSenderSsrc, "alice@host"); 462 463 rtc::scoped_ptr<rtcp::RawPacket> packet(sdes.Build()); 464 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 465 char cName[RTCP_CNAME_SIZE]; 466 EXPECT_EQ(0, rtcp_receiver_->CNAME(kSenderSsrc, cName)); 467 468 // Verify that BYE removes the CNAME. 469 rtcp::Bye bye; 470 bye.From(kSenderSsrc); 471 rtc::scoped_ptr<rtcp::RawPacket> p2(bye.Build()); 472 EXPECT_EQ(0, InjectRtcpPacket(p2->Buffer(), p2->Length())); 473 EXPECT_EQ(-1, rtcp_receiver_->CNAME(kSenderSsrc, cName)); 474 } 475 476 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) { 477 const uint32_t kSenderSsrc = 0x10203; 478 const uint32_t kSourceSsrcs[] = {0x40506, 0x50607}; 479 const int kNumSsrcs = sizeof(kSourceSsrcs) / sizeof(kSourceSsrcs[0]); 480 481 std::set<uint32_t> ssrcs(kSourceSsrcs, kSourceSsrcs + kNumSsrcs); 482 rtcp_receiver_->SetSsrcs(kSourceSsrcs[0], ssrcs); 483 484 rtcp::ReportBlock rb1; 485 rb1.To(kSourceSsrcs[0]); 486 rtcp::ReportBlock rb2; 487 rb2.To(kSourceSsrcs[1]); 488 rtcp::ReceiverReport rr; 489 rr.From(kSenderSsrc); 490 rr.WithReportBlock(rb1); 491 rr.WithReportBlock(rb2); 492 493 rtc::scoped_ptr<rtcp::RawPacket> p1(rr.Build()); 494 EXPECT_EQ(0, InjectRtcpPacket(p1->Buffer(), p1->Length())); 495 ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size()); 496 std::vector<RTCPReportBlock> received_blocks; 497 rtcp_receiver_->StatisticsReceived(&received_blocks); 498 EXPECT_EQ(2u, received_blocks.size()); 499 500 // Verify that BYE removes the report blocks. 501 rtcp::Bye bye; 502 bye.From(kSenderSsrc); 503 rtc::scoped_ptr<rtcp::RawPacket> p2(bye.Build()); 504 EXPECT_EQ(0, InjectRtcpPacket(p2->Buffer(), p2->Length())); 505 received_blocks.clear(); 506 rtcp_receiver_->StatisticsReceived(&received_blocks); 507 EXPECT_TRUE(received_blocks.empty()); 508 509 // Inject packet. 510 EXPECT_EQ(0, InjectRtcpPacket(p1->Buffer(), p1->Length())); 511 ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size()); 512 received_blocks.clear(); 513 rtcp_receiver_->StatisticsReceived(&received_blocks); 514 EXPECT_EQ(2u, received_blocks.size()); 515 } 516 517 TEST_F(RtcpReceiverTest, InjectPliPacket) { 518 const uint32_t kSourceSsrc = 0x123456; 519 std::set<uint32_t> ssrcs; 520 ssrcs.insert(kSourceSsrc); 521 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 522 523 rtcp::Pli pli; 524 pli.To(kSourceSsrc); 525 rtc::scoped_ptr<rtcp::RawPacket> packet(pli.Build()); 526 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 527 EXPECT_EQ(kRtcpPli, rtcp_packet_info_.rtcpPacketTypeFlags); 528 } 529 530 TEST_F(RtcpReceiverTest, PliPacketNotToUsIgnored) { 531 const uint32_t kSourceSsrc = 0x123456; 532 std::set<uint32_t> ssrcs; 533 ssrcs.insert(kSourceSsrc); 534 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 535 536 rtcp::Pli pli; 537 pli.To(kSourceSsrc + 1); 538 rtc::scoped_ptr<rtcp::RawPacket> packet(pli.Build()); 539 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 540 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 541 } 542 543 TEST_F(RtcpReceiverTest, InjectFirPacket) { 544 const uint32_t kSourceSsrc = 0x123456; 545 std::set<uint32_t> ssrcs; 546 ssrcs.insert(kSourceSsrc); 547 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 548 549 rtcp::Fir fir; 550 fir.To(kSourceSsrc); 551 rtc::scoped_ptr<rtcp::RawPacket> packet(fir.Build()); 552 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 553 EXPECT_EQ(kRtcpFir, rtcp_packet_info_.rtcpPacketTypeFlags); 554 } 555 556 TEST_F(RtcpReceiverTest, FirPacketNotToUsIgnored) { 557 const uint32_t kSourceSsrc = 0x123456; 558 std::set<uint32_t> ssrcs; 559 ssrcs.insert(kSourceSsrc); 560 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 561 562 rtcp::Fir fir; 563 fir.To(kSourceSsrc + 1); 564 rtc::scoped_ptr<rtcp::RawPacket> packet(fir.Build()); 565 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 566 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 567 } 568 569 TEST_F(RtcpReceiverTest, InjectSliPacket) { 570 rtcp::Sli sli; 571 sli.WithPictureId(40); 572 rtc::scoped_ptr<rtcp::RawPacket> packet(sli.Build()); 573 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 574 EXPECT_EQ(kRtcpSli, rtcp_packet_info_.rtcpPacketTypeFlags); 575 EXPECT_EQ(40, rtcp_packet_info_.sliPictureId); 576 } 577 578 TEST_F(RtcpReceiverTest, XrPacketWithZeroReportBlocksIgnored) { 579 rtcp::Xr xr; 580 xr.From(0x2345); 581 rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build()); 582 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 583 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 584 } 585 586 TEST_F(RtcpReceiverTest, InjectXrVoipPacket) { 587 const uint32_t kSourceSsrc = 0x123456; 588 std::set<uint32_t> ssrcs; 589 ssrcs.insert(kSourceSsrc); 590 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 591 592 const uint8_t kLossRate = 123; 593 rtcp::VoipMetric voip_metric; 594 voip_metric.To(kSourceSsrc); 595 RTCPVoIPMetric metric; 596 metric.lossRate = kLossRate; 597 voip_metric.WithVoipMetric(metric); 598 rtcp::Xr xr; 599 xr.From(0x2345); 600 xr.WithVoipMetric(&voip_metric); 601 rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build()); 602 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 603 ASSERT_TRUE(rtcp_packet_info_.VoIPMetric != nullptr); 604 EXPECT_EQ(kLossRate, rtcp_packet_info_.VoIPMetric->lossRate); 605 EXPECT_EQ(kRtcpXrVoipMetric, rtcp_packet_info_.rtcpPacketTypeFlags); 606 } 607 608 TEST_F(RtcpReceiverTest, XrVoipPacketNotToUsIgnored) { 609 const uint32_t kSourceSsrc = 0x123456; 610 std::set<uint32_t> ssrcs; 611 ssrcs.insert(kSourceSsrc); 612 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 613 614 rtcp::VoipMetric voip_metric; 615 voip_metric.To(kSourceSsrc + 1); 616 rtcp::Xr xr; 617 xr.From(0x2345); 618 xr.WithVoipMetric(&voip_metric); 619 rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build()); 620 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 621 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 622 } 623 624 TEST_F(RtcpReceiverTest, InjectXrReceiverReferenceTimePacket) { 625 rtcp::Rrtr rrtr; 626 rrtr.WithNtp(NtpTime(0x10203, 0x40506)); 627 rtcp::Xr xr; 628 xr.From(0x2345); 629 xr.WithRrtr(&rrtr); 630 631 rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build()); 632 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 633 EXPECT_EQ(kRtcpXrReceiverReferenceTime, 634 rtcp_packet_info_.rtcpPacketTypeFlags); 635 } 636 637 TEST_F(RtcpReceiverTest, XrDlrrPacketNotToUsIgnored) { 638 const uint32_t kSourceSsrc = 0x123456; 639 std::set<uint32_t> ssrcs; 640 ssrcs.insert(kSourceSsrc); 641 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 642 643 rtcp::Dlrr dlrr; 644 dlrr.WithDlrrItem(kSourceSsrc + 1, 0x12345, 0x67890); 645 rtcp::Xr xr; 646 xr.From(0x2345); 647 xr.WithDlrr(&dlrr); 648 rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build()); 649 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 650 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 651 EXPECT_FALSE(rtcp_packet_info_.xr_dlrr_item); 652 } 653 654 TEST_F(RtcpReceiverTest, InjectXrDlrrPacketWithSubBlock) { 655 const uint32_t kSourceSsrc = 0x123456; 656 std::set<uint32_t> ssrcs; 657 ssrcs.insert(kSourceSsrc); 658 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 659 660 rtcp::Dlrr dlrr; 661 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890); 662 rtcp::Xr xr; 663 xr.From(0x2345); 664 xr.WithDlrr(&dlrr); 665 rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build()); 666 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 667 // The parser should note the DLRR report block item, but not flag the packet 668 // since the RTT is not estimated. 669 EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item); 670 } 671 672 TEST_F(RtcpReceiverTest, InjectXrDlrrPacketWithMultipleSubBlocks) { 673 const uint32_t kSourceSsrc = 0x123456; 674 std::set<uint32_t> ssrcs; 675 ssrcs.insert(kSourceSsrc); 676 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 677 678 rtcp::Dlrr dlrr; 679 dlrr.WithDlrrItem(kSourceSsrc + 1, 0x12345, 0x67890); 680 dlrr.WithDlrrItem(kSourceSsrc + 2, 0x12345, 0x67890); 681 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890); 682 rtcp::Xr xr; 683 xr.From(0x2345); 684 xr.WithDlrr(&dlrr); 685 rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build()); 686 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 687 // The parser should note the DLRR report block item, but not flag the packet 688 // since the RTT is not estimated. 689 EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item); 690 } 691 692 TEST_F(RtcpReceiverTest, InjectXrPacketWithMultipleReportBlocks) { 693 const uint32_t kSourceSsrc = 0x123456; 694 std::set<uint32_t> ssrcs; 695 ssrcs.insert(kSourceSsrc); 696 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 697 698 rtcp::Rrtr rrtr; 699 rtcp::Dlrr dlrr; 700 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890); 701 rtcp::VoipMetric metric; 702 metric.To(kSourceSsrc); 703 rtcp::Xr xr; 704 xr.From(0x2345); 705 xr.WithRrtr(&rrtr); 706 xr.WithDlrr(&dlrr); 707 xr.WithVoipMetric(&metric); 708 rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build()); 709 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 710 EXPECT_EQ(static_cast<unsigned int>(kRtcpXrReceiverReferenceTime + 711 kRtcpXrVoipMetric), 712 rtcp_packet_info_.rtcpPacketTypeFlags); 713 // The parser should note the DLRR report block item, but not flag the packet 714 // since the RTT is not estimated. 715 EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item); 716 } 717 718 TEST_F(RtcpReceiverTest, InjectXrPacketWithUnknownReportBlock) { 719 const uint32_t kSourceSsrc = 0x123456; 720 std::set<uint32_t> ssrcs; 721 ssrcs.insert(kSourceSsrc); 722 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 723 std::vector<uint32_t> remote_ssrcs; 724 remote_ssrcs.push_back(kSourceSsrc); 725 726 rtcp::Rrtr rrtr; 727 rtcp::Dlrr dlrr; 728 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890); 729 rtcp::VoipMetric metric; 730 metric.To(kSourceSsrc); 731 rtcp::Xr xr; 732 xr.From(0x2345); 733 xr.WithRrtr(&rrtr); 734 xr.WithDlrr(&dlrr); 735 xr.WithVoipMetric(&metric); 736 rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build()); 737 // Modify the DLRR block to have an unsupported block type, from 5 to 6. 738 uint8_t* buffer = const_cast<uint8_t*>(packet->Buffer()); 739 EXPECT_EQ(5, buffer[20]); 740 buffer[20] = 6; 741 742 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 743 EXPECT_EQ(static_cast<unsigned int>(kRtcpXrReceiverReferenceTime + 744 kRtcpXrVoipMetric), 745 rtcp_packet_info_.rtcpPacketTypeFlags); 746 EXPECT_FALSE(rtcp_packet_info_.xr_dlrr_item); 747 } 748 749 TEST_F(RtcpReceiverTest, TestXrRrRttInitiallyFalse) { 750 int64_t rtt_ms; 751 EXPECT_FALSE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms)); 752 } 753 754 TEST_F(RtcpReceiverTest, LastReceivedXrReferenceTimeInfoInitiallyFalse) { 755 RtcpReceiveTimeInfo info; 756 EXPECT_FALSE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info)); 757 } 758 759 TEST_F(RtcpReceiverTest, GetLastReceivedXrReferenceTimeInfo) { 760 const uint32_t kSenderSsrc = 0x123456; 761 const NtpTime kNtp(0x10203, 0x40506); 762 const uint32_t kNtpMid = 763 RTCPUtility::MidNtp(kNtp.seconds(), kNtp.fractions()); 764 765 rtcp::Rrtr rrtr; 766 rrtr.WithNtp(kNtp); 767 rtcp::Xr xr; 768 xr.From(kSenderSsrc); 769 xr.WithRrtr(&rrtr); 770 rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build()); 771 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 772 EXPECT_EQ(kRtcpXrReceiverReferenceTime, 773 rtcp_packet_info_.rtcpPacketTypeFlags); 774 775 RtcpReceiveTimeInfo info; 776 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info)); 777 EXPECT_EQ(kSenderSsrc, info.sourceSSRC); 778 EXPECT_EQ(kNtpMid, info.lastRR); 779 EXPECT_EQ(0U, info.delaySinceLastRR); 780 781 system_clock_.AdvanceTimeMilliseconds(1000); 782 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info)); 783 EXPECT_EQ(65536U, info.delaySinceLastRR); 784 } 785 786 TEST_F(RtcpReceiverTest, ReceiveReportTimeout) { 787 const uint32_t kSenderSsrc = 0x10203; 788 const uint32_t kSourceSsrc = 0x40506; 789 const int64_t kRtcpIntervalMs = 1000; 790 791 std::set<uint32_t> ssrcs; 792 ssrcs.insert(kSourceSsrc); 793 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 794 795 const uint16_t kSequenceNumber = 1234; 796 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); 797 798 // No RR received, shouldn't trigger a timeout. 799 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 800 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 801 802 // Add a RR and advance the clock just enough to not trigger a timeout. 803 rtcp::ReportBlock rb1; 804 rb1.To(kSourceSsrc); 805 rb1.WithExtHighestSeqNum(kSequenceNumber); 806 rtcp::ReceiverReport rr1; 807 rr1.From(kSenderSsrc); 808 rr1.WithReportBlock(rb1); 809 rtc::scoped_ptr<rtcp::RawPacket> p1(rr1.Build()); 810 EXPECT_EQ(0, InjectRtcpPacket(p1->Buffer(), p1->Length())); 811 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs - 1); 812 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 813 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 814 815 // Add a RR with the same extended max as the previous RR to trigger a 816 // sequence number timeout, but not a RR timeout. 817 EXPECT_EQ(0, InjectRtcpPacket(p1->Buffer(), p1->Length())); 818 system_clock_.AdvanceTimeMilliseconds(2); 819 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 820 EXPECT_TRUE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 821 822 // Advance clock enough to trigger an RR timeout too. 823 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); 824 EXPECT_TRUE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 825 826 // We should only get one timeout even though we still haven't received a new 827 // RR. 828 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 829 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 830 831 // Add a new RR with increase sequence number to reset timers. 832 rtcp::ReportBlock rb2; 833 rb2.To(kSourceSsrc); 834 rb2.WithExtHighestSeqNum(kSequenceNumber + 1); 835 rtcp::ReceiverReport rr2; 836 rr2.From(kSenderSsrc); 837 rr2.WithReportBlock(rb2); 838 rtc::scoped_ptr<rtcp::RawPacket> p2(rr2.Build()); 839 EXPECT_EQ(0, InjectRtcpPacket(p2->Buffer(), p2->Length())); 840 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 841 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 842 843 // Verify we can get a timeout again once we've received new RR. 844 system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); 845 EXPECT_EQ(0, InjectRtcpPacket(p2->Buffer(), p2->Length())); 846 system_clock_.AdvanceTimeMilliseconds(kRtcpIntervalMs + 1); 847 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 848 EXPECT_TRUE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 849 system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); 850 EXPECT_TRUE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 851 } 852 853 TEST_F(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) { 854 // This call is expected to fail because no data has arrived. 855 EXPECT_EQ(-1, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); 856 } 857 858 TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) { 859 const uint32_t kMediaFlowSsrc = 0x2040608; 860 const uint32_t kSenderSsrc = 0x10203; 861 std::set<uint32_t> ssrcs; 862 ssrcs.insert(kMediaFlowSsrc); // Matches "media source" above. 863 rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs); 864 865 rtcp::Tmmbr tmmbr; 866 tmmbr.From(kSenderSsrc); 867 tmmbr.To(kMediaFlowSsrc); 868 tmmbr.WithBitrateKbps(30); 869 870 rtcp::SenderReport sr; 871 sr.From(kSenderSsrc); 872 sr.Append(&tmmbr); 873 rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build()); 874 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 875 876 EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); 877 TMMBRSet candidate_set; 878 candidate_set.VerifyAndAllocateSet(1); 879 EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(1, 0, &candidate_set)); 880 EXPECT_LT(0U, candidate_set.Tmmbr(0)); 881 EXPECT_EQ(kSenderSsrc, candidate_set.Ssrc(0)); 882 } 883 884 TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) { 885 const uint32_t kMediaFlowSsrc = 0x2040608; 886 const uint32_t kSenderSsrc = 0x10203; 887 888 rtcp::Tmmbr tmmbr; 889 tmmbr.From(kSenderSsrc); 890 tmmbr.To(kMediaFlowSsrc + 1); // This SSRC is not what we are sending. 891 tmmbr.WithBitrateKbps(30); 892 893 rtcp::SenderReport sr; 894 sr.From(kSenderSsrc); 895 sr.Append(&tmmbr); 896 rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build()); 897 898 std::set<uint32_t> ssrcs; 899 ssrcs.insert(kMediaFlowSsrc); 900 rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs); 901 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 902 EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); 903 } 904 905 TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) { 906 const uint32_t kMediaFlowSsrc = 0x2040608; 907 const uint32_t kSenderSsrc = 0x10203; 908 std::set<uint32_t> ssrcs; 909 ssrcs.insert(kMediaFlowSsrc); // Matches "media source" above. 910 rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs); 911 912 rtcp::Tmmbr tmmbr; 913 tmmbr.From(kSenderSsrc); 914 tmmbr.To(kMediaFlowSsrc); 915 tmmbr.WithBitrateKbps(0); 916 917 rtcp::SenderReport sr; 918 sr.From(kSenderSsrc); 919 sr.Append(&tmmbr); 920 rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build()); 921 922 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 923 EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); 924 } 925 926 TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) { 927 const uint32_t kMediaFlowSsrc = 0x2040608; 928 const uint32_t kSenderSsrc = 0x10203; 929 std::set<uint32_t> ssrcs; 930 ssrcs.insert(kMediaFlowSsrc); // Matches "media source" above. 931 rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs); 932 933 // Inject 3 packets "from" kSenderSsrc, kSenderSsrc+1, kSenderSsrc+2. 934 // The times of arrival are starttime + 0, starttime + 5 and starttime + 10. 935 for (uint32_t ssrc = kSenderSsrc; ssrc < kSenderSsrc + 3; ++ssrc) { 936 rtcp::Tmmbr tmmbr; 937 tmmbr.From(ssrc); 938 tmmbr.To(kMediaFlowSsrc); 939 tmmbr.WithBitrateKbps(30); 940 941 rtcp::SenderReport sr; 942 sr.From(ssrc); 943 sr.Append(&tmmbr); 944 rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build()); 945 EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length())); 946 // 5 seconds between each packet. 947 system_clock_.AdvanceTimeMilliseconds(5000); 948 } 949 // It is now starttime + 15. 950 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); 951 TMMBRSet candidate_set; 952 candidate_set.VerifyAndAllocateSet(3); 953 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set)); 954 EXPECT_LT(0U, candidate_set.Tmmbr(0)); 955 // We expect the timeout to be 25 seconds. Advance the clock by 12 956 // seconds, timing out the first packet. 957 system_clock_.AdvanceTimeMilliseconds(12000); 958 // Odd behaviour: Just counting them does not trigger the timeout. 959 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); 960 EXPECT_EQ(2, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set)); 961 EXPECT_EQ(kSenderSsrc + 1, candidate_set.Ssrc(0)); 962 } 963 964 TEST_F(RtcpReceiverTest, Callbacks) { 965 class RtcpCallbackImpl : public RtcpStatisticsCallback { 966 public: 967 RtcpCallbackImpl() : RtcpStatisticsCallback(), ssrc_(0) {} 968 virtual ~RtcpCallbackImpl() {} 969 970 void StatisticsUpdated(const RtcpStatistics& statistics, 971 uint32_t ssrc) override { 972 stats_ = statistics; 973 ssrc_ = ssrc; 974 } 975 976 void CNameChanged(const char* cname, uint32_t ssrc) override {} 977 978 bool Matches(uint32_t ssrc, uint32_t extended_max, uint8_t fraction_loss, 979 uint32_t cumulative_loss, uint32_t jitter) { 980 return ssrc_ == ssrc && 981 stats_.fraction_lost == fraction_loss && 982 stats_.cumulative_lost == cumulative_loss && 983 stats_.extended_max_sequence_number == extended_max && 984 stats_.jitter == jitter; 985 } 986 987 RtcpStatistics stats_; 988 uint32_t ssrc_; 989 } callback; 990 991 rtcp_receiver_->RegisterRtcpStatisticsCallback(&callback); 992 993 const uint32_t kSenderSsrc = 0x10203; 994 const uint32_t kSourceSsrc = 0x123456; 995 const uint8_t kFractionLoss = 3; 996 const uint32_t kCumulativeLoss = 7; 997 const uint32_t kJitter = 9; 998 const uint16_t kSequenceNumber = 1234; 999 1000 std::set<uint32_t> ssrcs; 1001 ssrcs.insert(kSourceSsrc); 1002 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 1003 1004 // First packet, all numbers should just propagate. 1005 rtcp::ReportBlock rb1; 1006 rb1.To(kSourceSsrc); 1007 rb1.WithExtHighestSeqNum(kSequenceNumber); 1008 rb1.WithFractionLost(kFractionLoss); 1009 rb1.WithCumulativeLost(kCumulativeLoss); 1010 rb1.WithJitter(kJitter); 1011 1012 rtcp::ReceiverReport rr1; 1013 rr1.From(kSenderSsrc); 1014 rr1.WithReportBlock(rb1); 1015 rtc::scoped_ptr<rtcp::RawPacket> p1(rr1.Build()); 1016 EXPECT_EQ(0, InjectRtcpPacket(p1->Buffer(), p1->Length())); 1017 EXPECT_TRUE(callback.Matches(kSourceSsrc, kSequenceNumber, kFractionLoss, 1018 kCumulativeLoss, kJitter)); 1019 1020 rtcp_receiver_->RegisterRtcpStatisticsCallback(nullptr); 1021 1022 // Add arbitrary numbers, callback should not be called (retain old values). 1023 rtcp::ReportBlock rb2; 1024 rb2.To(kSourceSsrc); 1025 rb2.WithExtHighestSeqNum(kSequenceNumber + 1); 1026 rb2.WithFractionLost(42); 1027 rb2.WithCumulativeLost(137); 1028 rb2.WithJitter(4711); 1029 1030 rtcp::ReceiverReport rr2; 1031 rr2.From(kSenderSsrc); 1032 rr2.WithReportBlock(rb2); 1033 rtc::scoped_ptr<rtcp::RawPacket> p2(rr2.Build()); 1034 EXPECT_EQ(0, InjectRtcpPacket(p2->Buffer(), p2->Length())); 1035 EXPECT_TRUE(callback.Matches(kSourceSsrc, kSequenceNumber, kFractionLoss, 1036 kCumulativeLoss, kJitter)); 1037 } 1038 1039 TEST_F(RtcpReceiverTest, ReceivesTransportFeedback) { 1040 const uint32_t kSenderSsrc = 0x10203; 1041 const uint32_t kSourceSsrc = 0x123456; 1042 1043 std::set<uint32_t> ssrcs; 1044 ssrcs.insert(kSourceSsrc); 1045 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 1046 1047 rtcp::TransportFeedback packet; 1048 packet.WithMediaSourceSsrc(kSourceSsrc); 1049 packet.WithPacketSenderSsrc(kSenderSsrc); 1050 packet.WithBase(1, 1000); 1051 packet.WithReceivedPacket(1, 1000); 1052 1053 rtc::scoped_ptr<rtcp::RawPacket> built_packet = packet.Build(); 1054 ASSERT_TRUE(built_packet.get() != nullptr); 1055 1056 EXPECT_EQ(0, 1057 InjectRtcpPacket(built_packet->Buffer(), built_packet->Length())); 1058 1059 EXPECT_NE(0u, rtcp_packet_info_.rtcpPacketTypeFlags & kRtcpTransportFeedback); 1060 EXPECT_TRUE(rtcp_packet_info_.transport_feedback_.get() != nullptr); 1061 } 1062 1063 TEST_F(RtcpReceiverTest, HandlesInvalidTransportFeedback) { 1064 const uint32_t kSenderSsrc = 0x10203; 1065 const uint32_t kSourceSsrc = 0x123456; 1066 1067 std::set<uint32_t> ssrcs; 1068 ssrcs.insert(kSourceSsrc); 1069 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 1070 1071 // Send a compound packet with a TransportFeedback followed by something else. 1072 rtcp::TransportFeedback packet; 1073 packet.WithMediaSourceSsrc(kSourceSsrc); 1074 packet.WithPacketSenderSsrc(kSenderSsrc); 1075 packet.WithBase(1, 1000); 1076 packet.WithReceivedPacket(1, 1000); 1077 1078 static uint32_t kBitrateBps = 50000; 1079 rtcp::Remb remb; 1080 remb.From(kSourceSsrc); 1081 remb.WithBitrateBps(kBitrateBps); 1082 packet.Append(&remb); 1083 1084 rtc::scoped_ptr<rtcp::RawPacket> built_packet = packet.Build(); 1085 ASSERT_TRUE(built_packet.get() != nullptr); 1086 1087 // Modify the TransportFeedback packet so that it is invalid. 1088 const size_t kStatusCountOffset = 14; 1089 ByteWriter<uint16_t>::WriteBigEndian( 1090 &built_packet->MutableBuffer()[kStatusCountOffset], 42); 1091 1092 EXPECT_EQ(0, 1093 InjectRtcpPacket(built_packet->Buffer(), built_packet->Length())); 1094 1095 // Transport feedback should be ignored, but next packet should work. 1096 EXPECT_EQ(0u, rtcp_packet_info_.rtcpPacketTypeFlags & kRtcpTransportFeedback); 1097 EXPECT_NE(0u, rtcp_packet_info_.rtcpPacketTypeFlags & kRtcpRemb); 1098 EXPECT_EQ(kBitrateBps, rtcp_packet_info_.receiverEstimatedMaxBitrate); 1099 } 1100 1101 } // Anonymous namespace 1102 1103 } // namespace webrtc 1104
