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