rtcp_receiver_unittest.cc revision e75d78d32d7283adc53cd91a85094245a7428d84
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 28namespace webrtc { 29 30namespace { // Anonymous namespace; hide utility functions and classes. 31 32// This test transport verifies that no functions get called. 33class 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 62class 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_.report_blocks = rtcpPacketInformation.report_blocks; 115 rtcp_packet_info_.rtt = rtcpPacketInformation.rtt; 116 rtcp_packet_info_.interArrivalJitter = 117 rtcpPacketInformation.interArrivalJitter; 118 rtcp_packet_info_.sliPictureId = rtcpPacketInformation.sliPictureId; 119 rtcp_packet_info_.rpsiPictureId = rtcpPacketInformation.rpsiPictureId; 120 rtcp_packet_info_.receiverEstimatedMaxBitrate = 121 rtcpPacketInformation.receiverEstimatedMaxBitrate; 122 rtcp_packet_info_.ntp_secs = rtcpPacketInformation.ntp_secs; 123 rtcp_packet_info_.ntp_frac = rtcpPacketInformation.ntp_frac; 124 rtcp_packet_info_.rtp_timestamp = rtcpPacketInformation.rtp_timestamp; 125 rtcp_packet_info_.xr_dlrr_item = rtcpPacketInformation.xr_dlrr_item; 126 if (rtcpPacketInformation.VoIPMetric) { 127 rtcp_packet_info_.AddVoIPMetric(rtcpPacketInformation.VoIPMetric); 128 } 129 return 0; 130 } 131 132 OverUseDetectorOptions over_use_detector_options_; 133 SimulatedClock system_clock_; 134 ModuleRtpRtcpImpl* rtp_rtcp_impl_; 135 RTCPReceiver* rtcp_receiver_; 136 TestTransport* test_transport_; 137 RTCPHelp::RTCPPacketInformation rtcp_packet_info_; 138 MockRemoteBitrateObserver remote_bitrate_observer_; 139 scoped_ptr<RemoteBitrateEstimator> remote_bitrate_estimator_; 140}; 141 142 143TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) { 144 const uint8_t bad_packet[] = {0, 0, 0, 0}; 145 EXPECT_EQ(0, InjectRtcpPacket(bad_packet, sizeof(bad_packet))); 146 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 147} 148 149TEST_F(RtcpReceiverTest, InjectSrPacket) { 150 const uint32_t kSenderSsrc = 0x10203; 151 rtcp::SenderReport sr; 152 sr.From(kSenderSsrc); 153 rtcp::RawPacket p = sr.Build(); 154 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 155 // The parser will note the remote SSRC on a SR from other than his 156 // expected peer, but will not flag that he's gotten a packet. 157 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); 158 EXPECT_EQ(0U, 159 kRtcpSr & rtcp_packet_info_.rtcpPacketTypeFlags); 160} 161 162TEST_F(RtcpReceiverTest, XrPacketWithZeroReportBlocksIgnored) { 163 rtcp::Xr xr; 164 xr.From(0x2345); 165 rtcp::RawPacket p = xr.Build(); 166 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 167 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 168} 169 170TEST_F(RtcpReceiverTest, InjectXrVoipPacket) { 171 const uint32_t kSourceSsrc = 0x123456; 172 std::set<uint32_t> ssrcs; 173 ssrcs.insert(kSourceSsrc); 174 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 175 176 const uint8_t kLossRate = 123; 177 rtcp::VoipMetric voip_metric; 178 voip_metric.To(kSourceSsrc); 179 voip_metric.LossRate(kLossRate); 180 rtcp::Xr xr; 181 xr.From(0x2345); 182 xr.WithVoipMetric(&voip_metric); 183 rtcp::RawPacket p = xr.Build(); 184 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 185 ASSERT_TRUE(rtcp_packet_info_.VoIPMetric != NULL); 186 EXPECT_EQ(kLossRate, rtcp_packet_info_.VoIPMetric->lossRate); 187 EXPECT_EQ(kRtcpXrVoipMetric, rtcp_packet_info_.rtcpPacketTypeFlags); 188} 189 190TEST_F(RtcpReceiverTest, XrVoipPacketNotToUsIgnored) { 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::VoipMetric voip_metric; 197 voip_metric.To(kSourceSsrc + 1); 198 rtcp::Xr xr; 199 xr.From(0x2345); 200 xr.WithVoipMetric(&voip_metric); 201 rtcp::RawPacket p = xr.Build(); 202 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 203 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 204} 205 206TEST_F(RtcpReceiverTest, InjectXrReceiverReferenceTimePacket) { 207 rtcp::Rrtr rrtr; 208 rrtr.WithNtpSec(0x10203); 209 rrtr.WithNtpFrac(0x40506); 210 rtcp::Xr xr; 211 xr.From(0x2345); 212 xr.WithRrtr(&rrtr); 213 214 rtcp::RawPacket p = xr.Build(); 215 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 216 EXPECT_EQ(kRtcpXrReceiverReferenceTime, 217 rtcp_packet_info_.rtcpPacketTypeFlags); 218} 219 220TEST_F(RtcpReceiverTest, XrDlrrPacketNotToUsIgnored) { 221 const uint32_t kSourceSsrc = 0x123456; 222 std::set<uint32_t> ssrcs; 223 ssrcs.insert(kSourceSsrc); 224 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 225 226 rtcp::Dlrr dlrr; 227 dlrr.WithDlrrItem(kSourceSsrc + 1, 0x12345, 0x67890); 228 rtcp::Xr xr; 229 xr.From(0x2345); 230 xr.WithDlrr(&dlrr); 231 rtcp::RawPacket p = xr.Build(); 232 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 233 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 234 EXPECT_FALSE(rtcp_packet_info_.xr_dlrr_item); 235} 236 237TEST_F(RtcpReceiverTest, InjectXrDlrrPacketWithSubBlock) { 238 const uint32_t kSourceSsrc = 0x123456; 239 std::set<uint32_t> ssrcs; 240 ssrcs.insert(kSourceSsrc); 241 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 242 243 rtcp::Dlrr dlrr; 244 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890); 245 rtcp::Xr xr; 246 xr.From(0x2345); 247 xr.WithDlrr(&dlrr); 248 rtcp::RawPacket p = xr.Build(); 249 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 250 // The parser should note the DLRR report block item, but not flag the packet 251 // since the RTT is not estimated. 252 EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item); 253} 254 255TEST_F(RtcpReceiverTest, InjectXrDlrrPacketWithMultipleSubBlocks) { 256 const uint32_t kSourceSsrc = 0x123456; 257 std::set<uint32_t> ssrcs; 258 ssrcs.insert(kSourceSsrc); 259 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 260 261 rtcp::Dlrr dlrr; 262 dlrr.WithDlrrItem(kSourceSsrc + 1, 0x12345, 0x67890); 263 dlrr.WithDlrrItem(kSourceSsrc + 2, 0x12345, 0x67890); 264 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890); 265 rtcp::Xr xr; 266 xr.From(0x2345); 267 xr.WithDlrr(&dlrr); 268 rtcp::RawPacket p = xr.Build(); 269 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 270 // The parser should note the DLRR report block item, but not flag the packet 271 // since the RTT is not estimated. 272 EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item); 273} 274 275TEST_F(RtcpReceiverTest, InjectXrPacketWithMultipleReportBlocks) { 276 const uint32_t kSourceSsrc = 0x123456; 277 std::set<uint32_t> ssrcs; 278 ssrcs.insert(kSourceSsrc); 279 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 280 281 rtcp::Rrtr rrtr; 282 rtcp::Dlrr dlrr; 283 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890); 284 rtcp::VoipMetric metric; 285 metric.To(kSourceSsrc); 286 rtcp::Xr xr; 287 xr.From(0x2345); 288 xr.WithRrtr(&rrtr); 289 xr.WithDlrr(&dlrr); 290 xr.WithVoipMetric(&metric); 291 rtcp::RawPacket p = xr.Build(); 292 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 293 EXPECT_EQ(static_cast<unsigned int>(kRtcpXrReceiverReferenceTime + 294 kRtcpXrVoipMetric), 295 rtcp_packet_info_.rtcpPacketTypeFlags); 296 // The parser should note the DLRR report block item, but not flag the packet 297 // since the RTT is not estimated. 298 EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item); 299} 300 301TEST_F(RtcpReceiverTest, InjectXrPacketWithUnknownReportBlock) { 302 const uint32_t kSourceSsrc = 0x123456; 303 std::set<uint32_t> ssrcs; 304 ssrcs.insert(kSourceSsrc); 305 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 306 std::vector<uint32_t> remote_ssrcs; 307 remote_ssrcs.push_back(kSourceSsrc); 308 309 rtcp::Rrtr rrtr; 310 rtcp::Dlrr dlrr; 311 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890); 312 rtcp::VoipMetric metric; 313 metric.To(kSourceSsrc); 314 rtcp::Xr xr; 315 xr.From(0x2345); 316 xr.WithRrtr(&rrtr); 317 xr.WithDlrr(&dlrr); 318 xr.WithVoipMetric(&metric); 319 rtcp::RawPacket p = xr.Build(); 320 // Modify the DLRR block to have an unsupported block type, from 5 to 6. 321 uint8_t* buffer = const_cast<uint8_t*>(p.buffer()); 322 EXPECT_EQ(5, buffer[20]); 323 buffer[20] = 6; 324 325 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 326 EXPECT_EQ(static_cast<unsigned int>(kRtcpXrReceiverReferenceTime + 327 kRtcpXrVoipMetric), 328 rtcp_packet_info_.rtcpPacketTypeFlags); 329 EXPECT_FALSE(rtcp_packet_info_.xr_dlrr_item); 330} 331 332TEST(RtcpUtilityTest, MidNtp) { 333 const uint32_t kNtpSec = 0x12345678; 334 const uint32_t kNtpFrac = 0x23456789; 335 const uint32_t kNtpMid = 0x56782345; 336 EXPECT_EQ(kNtpMid, RTCPUtility::MidNtp(kNtpSec, kNtpFrac)); 337} 338 339TEST_F(RtcpReceiverTest, TestXrRrRttInitiallyFalse) { 340 uint16_t rtt_ms; 341 EXPECT_FALSE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms)); 342} 343 344TEST_F(RtcpReceiverTest, LastReceivedXrReferenceTimeInfoInitiallyFalse) { 345 RtcpReceiveTimeInfo info; 346 EXPECT_FALSE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info)); 347} 348 349TEST_F(RtcpReceiverTest, GetLastReceivedXrReferenceTimeInfo) { 350 const uint32_t kSenderSsrc = 0x123456; 351 const uint32_t kNtpSec = 0x10203; 352 const uint32_t kNtpFrac = 0x40506; 353 const uint32_t kNtpMid = RTCPUtility::MidNtp(kNtpSec, kNtpFrac); 354 355 rtcp::Rrtr rrtr; 356 rrtr.WithNtpSec(kNtpSec); 357 rrtr.WithNtpFrac(kNtpFrac); 358 rtcp::Xr xr; 359 xr.From(kSenderSsrc); 360 xr.WithRrtr(&rrtr); 361 rtcp::RawPacket p = xr.Build(); 362 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 363 EXPECT_EQ(kRtcpXrReceiverReferenceTime, 364 rtcp_packet_info_.rtcpPacketTypeFlags); 365 366 RtcpReceiveTimeInfo info; 367 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info)); 368 EXPECT_EQ(kSenderSsrc, info.sourceSSRC); 369 EXPECT_EQ(kNtpMid, info.lastRR); 370 EXPECT_EQ(0U, info.delaySinceLastRR); 371 372 system_clock_.AdvanceTimeMilliseconds(1000); 373 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info)); 374 EXPECT_EQ(65536U, info.delaySinceLastRR); 375} 376 377TEST_F(RtcpReceiverTest, ReceiveReportTimeout) { 378 const uint32_t kSenderSsrc = 0x10203; 379 const uint32_t kSourceSsrc = 0x40506; 380 const int64_t kRtcpIntervalMs = 1000; 381 382 std::set<uint32_t> ssrcs; 383 ssrcs.insert(kSourceSsrc); 384 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 385 386 const uint16_t kSequenceNumber = 1234; 387 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); 388 389 // No RR received, shouldn't trigger a timeout. 390 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 391 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 392 393 // Add a RR and advance the clock just enough to not trigger a timeout. 394 rtcp::ReportBlock rb1; 395 rb1.To(kSourceSsrc); 396 rb1.WithExtHighestSeqNum(kSequenceNumber); 397 rtcp::ReceiverReport rr1; 398 rr1.From(kSenderSsrc); 399 rr1.WithReportBlock(&rb1); 400 rtcp::RawPacket p1 = rr1.Build(); 401 EXPECT_EQ(0, InjectRtcpPacket(p1.buffer(), p1.buffer_length())); 402 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs - 1); 403 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 404 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 405 406 // Add a RR with the same extended max as the previous RR to trigger a 407 // sequence number timeout, but not a RR timeout. 408 EXPECT_EQ(0, InjectRtcpPacket(p1.buffer(), p1.buffer_length())); 409 system_clock_.AdvanceTimeMilliseconds(2); 410 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 411 EXPECT_TRUE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 412 413 // Advance clock enough to trigger an RR timeout too. 414 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); 415 EXPECT_TRUE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 416 417 // We should only get one timeout even though we still haven't received a new 418 // RR. 419 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 420 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 421 422 // Add a new RR with increase sequence number to reset timers. 423 rtcp::ReportBlock rb2; 424 rb2.To(kSourceSsrc); 425 rb2.WithExtHighestSeqNum(kSequenceNumber + 1); 426 rtcp::ReceiverReport rr2; 427 rr2.From(kSenderSsrc); 428 rr2.WithReportBlock(&rb2); 429 rtcp::RawPacket p2 = rr2.Build(); 430 EXPECT_EQ(0, InjectRtcpPacket(p2.buffer(), p2.buffer_length())); 431 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 432 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 433 434 // Verify we can get a timeout again once we've received new RR. 435 system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); 436 EXPECT_EQ(0, InjectRtcpPacket(p2.buffer(), p2.buffer_length())); 437 system_clock_.AdvanceTimeMilliseconds(kRtcpIntervalMs + 1); 438 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 439 EXPECT_TRUE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 440 system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); 441 EXPECT_TRUE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 442} 443 444TEST_F(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) { 445 // This call is expected to fail because no data has arrived. 446 EXPECT_EQ(-1, rtcp_receiver_->TMMBRReceived(0, 0, NULL)); 447} 448 449TEST_F(RtcpReceiverTest, TwoReportBlocks) { 450 const uint32_t kSenderSsrc = 0x10203; 451 const uint32_t kSourceSsrcs[] = {0x40506, 0x50607}; 452 const uint16_t kSequenceNumbers[] = {10, 12423}; 453 const int kNumSsrcs = sizeof(kSourceSsrcs) / sizeof(kSourceSsrcs[0]); 454 455 std::set<uint32_t> ssrcs(kSourceSsrcs, kSourceSsrcs + kNumSsrcs); 456 rtcp_receiver_->SetSsrcs(kSourceSsrcs[0], ssrcs); 457 458 rtcp::ReportBlock rb1; 459 rb1.To(kSourceSsrcs[0]); 460 rb1.WithExtHighestSeqNum(kSequenceNumbers[0]); 461 rb1.WithFractionLost(10); 462 rb1.WithCumulativeLost(5); 463 464 rtcp::ReportBlock rb2; 465 rb2.To(kSourceSsrcs[1]); 466 rb2.WithExtHighestSeqNum(kSequenceNumbers[1]); 467 468 rtcp::ReceiverReport rr1; 469 rr1.From(kSenderSsrc); 470 rr1.WithReportBlock(&rb1); 471 rr1.WithReportBlock(&rb2); 472 473 rtcp::RawPacket p1 = rr1.Build(); 474 EXPECT_EQ(0, InjectRtcpPacket(p1.buffer(), p1.buffer_length())); 475 ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size()); 476 EXPECT_EQ(10, rtcp_packet_info_.report_blocks.front().fractionLost); 477 EXPECT_EQ(0, rtcp_packet_info_.report_blocks.back().fractionLost); 478 479 rtcp::ReportBlock rb3; 480 rb3.To(kSourceSsrcs[0]); 481 rb3.WithExtHighestSeqNum(kSequenceNumbers[0]); 482 483 rtcp::ReportBlock rb4; 484 rb4.To(kSourceSsrcs[1]); 485 rb4.WithExtHighestSeqNum(kSequenceNumbers[1]); 486 rb4.WithFractionLost(20); 487 rb4.WithCumulativeLost(10); 488 489 rtcp::ReceiverReport rr2; 490 rr2.From(kSenderSsrc); 491 rr2.WithReportBlock(&rb3); 492 rr2.WithReportBlock(&rb4); 493 494 rtcp::RawPacket p2 = rr2.Build(); 495 EXPECT_EQ(0, InjectRtcpPacket(p2.buffer(), p2.buffer_length())); 496 ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size()); 497 EXPECT_EQ(0, rtcp_packet_info_.report_blocks.front().fractionLost); 498 EXPECT_EQ(20, rtcp_packet_info_.report_blocks.back().fractionLost); 499} 500 501TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) { 502 const uint32_t kMediaFlowSsrc = 0x2040608; 503 const uint32_t kSenderSsrc = 0x10203; 504 std::set<uint32_t> ssrcs; 505 ssrcs.insert(kMediaFlowSsrc); // Matches "media source" above. 506 rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs); 507 508 rtcp::Tmmbr tmmbr; 509 tmmbr.From(kSenderSsrc); 510 tmmbr.To(kMediaFlowSsrc); 511 tmmbr.WithBitrateKbps(30); 512 513 rtcp::SenderReport sr; 514 sr.From(kSenderSsrc); 515 sr.Append(&tmmbr); 516 rtcp::RawPacket p = sr.Build(); 517 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 518 519 EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(0, 0, NULL)); 520 TMMBRSet candidate_set; 521 candidate_set.VerifyAndAllocateSet(1); 522 EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(1, 0, &candidate_set)); 523 EXPECT_LT(0U, candidate_set.Tmmbr(0)); 524 EXPECT_EQ(kSenderSsrc, candidate_set.Ssrc(0)); 525} 526 527TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) { 528 const uint32_t kMediaFlowSsrc = 0x2040608; 529 const uint32_t kSenderSsrc = 0x10203; 530 531 rtcp::Tmmbr tmmbr; 532 tmmbr.From(kSenderSsrc); 533 tmmbr.To(kMediaFlowSsrc + 1); // This SSRC is not what we are sending. 534 tmmbr.WithBitrateKbps(30); 535 536 rtcp::SenderReport sr; 537 sr.From(kSenderSsrc); 538 sr.Append(&tmmbr); 539 rtcp::RawPacket p = sr.Build(); 540 541 std::set<uint32_t> ssrcs; 542 ssrcs.insert(kMediaFlowSsrc); 543 rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs); 544 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 545 EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, NULL)); 546} 547 548TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) { 549 const uint32_t kMediaFlowSsrc = 0x2040608; 550 const uint32_t kSenderSsrc = 0x10203; 551 std::set<uint32_t> ssrcs; 552 ssrcs.insert(kMediaFlowSsrc); // Matches "media source" above. 553 rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs); 554 555 rtcp::Tmmbr tmmbr; 556 tmmbr.From(kSenderSsrc); 557 tmmbr.To(kMediaFlowSsrc); 558 tmmbr.WithBitrateKbps(0); 559 560 rtcp::SenderReport sr; 561 sr.From(kSenderSsrc); 562 sr.Append(&tmmbr); 563 rtcp::RawPacket p = sr.Build(); 564 565 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 566 EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, NULL)); 567} 568 569TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) { 570 const uint32_t kMediaFlowSsrc = 0x2040608; 571 const uint32_t kSenderSsrc = 0x10203; 572 std::set<uint32_t> ssrcs; 573 ssrcs.insert(kMediaFlowSsrc); // Matches "media source" above. 574 rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs); 575 576 // Inject 3 packets "from" kSenderSsrc, kSenderSsrc+1, kSenderSsrc+2. 577 // The times of arrival are starttime + 0, starttime + 5 and starttime + 10. 578 for (uint32_t ssrc = kSenderSsrc; ssrc < kSenderSsrc + 3; ++ssrc) { 579 rtcp::Tmmbr tmmbr; 580 tmmbr.From(ssrc); 581 tmmbr.To(kMediaFlowSsrc); 582 tmmbr.WithBitrateKbps(30); 583 584 rtcp::SenderReport sr; 585 sr.From(ssrc); 586 sr.Append(&tmmbr); 587 rtcp::RawPacket p = sr.Build(); 588 EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length())); 589 // 5 seconds between each packet. 590 system_clock_.AdvanceTimeMilliseconds(5000); 591 } 592 // It is now starttime + 15. 593 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, NULL)); 594 TMMBRSet candidate_set; 595 candidate_set.VerifyAndAllocateSet(3); 596 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set)); 597 EXPECT_LT(0U, candidate_set.Tmmbr(0)); 598 // We expect the timeout to be 25 seconds. Advance the clock by 12 599 // seconds, timing out the first packet. 600 system_clock_.AdvanceTimeMilliseconds(12000); 601 // Odd behaviour: Just counting them does not trigger the timeout. 602 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, NULL)); 603 EXPECT_EQ(2, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set)); 604 EXPECT_EQ(kSenderSsrc + 1, candidate_set.Ssrc(0)); 605} 606 607TEST_F(RtcpReceiverTest, Callbacks) { 608 class RtcpCallbackImpl : public RtcpStatisticsCallback { 609 public: 610 RtcpCallbackImpl() : RtcpStatisticsCallback(), ssrc_(0) {} 611 virtual ~RtcpCallbackImpl() {} 612 613 virtual void StatisticsUpdated(const RtcpStatistics& statistics, 614 uint32_t ssrc) { 615 stats_ = statistics; 616 ssrc_ = ssrc; 617 } 618 619 bool Matches(uint32_t ssrc, uint32_t extended_max, uint8_t fraction_loss, 620 uint32_t cumulative_loss, uint32_t jitter) { 621 return ssrc_ == ssrc && 622 stats_.fraction_lost == fraction_loss && 623 stats_.cumulative_lost == cumulative_loss && 624 stats_.extended_max_sequence_number == extended_max && 625 stats_.jitter == jitter; 626 } 627 628 RtcpStatistics stats_; 629 uint32_t ssrc_; 630 } callback; 631 632 rtcp_receiver_->RegisterRtcpStatisticsCallback(&callback); 633 634 const uint32_t kSenderSsrc = 0x10203; 635 const uint32_t kSourceSsrc = 0x123456; 636 const uint8_t kFractionLoss = 3; 637 const uint32_t kCumulativeLoss = 7; 638 const uint32_t kJitter = 9; 639 const uint16_t kSequenceNumber = 1234; 640 641 std::set<uint32_t> ssrcs; 642 ssrcs.insert(kSourceSsrc); 643 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 644 645 // First packet, all numbers should just propagate. 646 rtcp::ReportBlock rb1; 647 rb1.To(kSourceSsrc); 648 rb1.WithExtHighestSeqNum(kSequenceNumber); 649 rb1.WithFractionLost(kFractionLoss); 650 rb1.WithCumulativeLost(kCumulativeLoss); 651 rb1.WithJitter(kJitter); 652 653 rtcp::ReceiverReport rr1; 654 rr1.From(kSenderSsrc); 655 rr1.WithReportBlock(&rb1); 656 rtcp::RawPacket p1 = rr1.Build(); 657 EXPECT_EQ(0, InjectRtcpPacket(p1.buffer(), p1.buffer_length())); 658 EXPECT_TRUE(callback.Matches(kSourceSsrc, kSequenceNumber, kFractionLoss, 659 kCumulativeLoss, kJitter)); 660 661 rtcp_receiver_->RegisterRtcpStatisticsCallback(NULL); 662 663 // Add arbitrary numbers, callback should not be called (retain old values). 664 rtcp::ReportBlock rb2; 665 rb2.To(kSourceSsrc); 666 rb2.WithExtHighestSeqNum(kSequenceNumber + 1); 667 rb2.WithFractionLost(42); 668 rb2.WithCumulativeLost(137); 669 rb2.WithJitter(4711); 670 671 rtcp::ReceiverReport rr2; 672 rr2.From(kSenderSsrc); 673 rr2.WithReportBlock(&rb2); 674 rtcp::RawPacket p2 = rr2.Build(); 675 EXPECT_EQ(0, InjectRtcpPacket(p2.buffer(), p2.buffer_length())); 676 EXPECT_TRUE(callback.Matches(kSourceSsrc, kSequenceNumber, kFractionLoss, 677 kCumulativeLoss, kJitter)); 678} 679 680} // Anonymous namespace 681 682} // namespace webrtc 683