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