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