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 #include <memory>
12
13 #include "api/array_view.h"
14 #include "common_types.h" // NOLINT(build/include)
15 #include "common_video/include/video_bitrate_allocator.h"
16 #include "modules/rtp_rtcp/source/byte_io.h"
17 #include "modules/rtp_rtcp/source/rtcp_packet.h"
18 #include "modules/rtp_rtcp/source/rtcp_packet/app.h"
19 #include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
20 #include "modules/rtp_rtcp/source/rtcp_packet/compound_packet.h"
21 #include "modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h"
22 #include "modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
23 #include "modules/rtp_rtcp/source/rtcp_packet/fir.h"
24 #include "modules/rtp_rtcp/source/rtcp_packet/nack.h"
25 #include "modules/rtp_rtcp/source/rtcp_packet/pli.h"
26 #include "modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h"
27 #include "modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
28 #include "modules/rtp_rtcp/source/rtcp_packet/remb.h"
29 #include "modules/rtp_rtcp/source/rtcp_packet/sdes.h"
30 #include "modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
31 #include "modules/rtp_rtcp/source/rtcp_packet/tmmbr.h"
32 #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
33 #include "modules/rtp_rtcp/source/rtcp_receiver.h"
34 #include "modules/rtp_rtcp/source/time_util.h"
35 #include "rtc_base/arraysize.h"
36 #include "rtc_base/random.h"
37 #include "system_wrappers/include/ntp_time.h"
38 #include "test/gmock.h"
39 #include "test/gtest.h"
40
41 namespace webrtc {
42 namespace {
43
44 using ::testing::_;
45 using ::testing::AllOf;
46 using ::testing::ElementsAreArray;
47 using ::testing::Field;
48 using ::testing::IsEmpty;
49 using ::testing::NiceMock;
50 using ::testing::Property;
51 using ::testing::SizeIs;
52 using ::testing::StrEq;
53 using ::testing::StrictMock;
54 using ::testing::UnorderedElementsAre;
55 using rtcp::ReceiveTimeInfo;
56
57 class MockRtcpPacketTypeCounterObserver : public RtcpPacketTypeCounterObserver {
58 public:
59 MOCK_METHOD2(RtcpPacketTypesCounterUpdated,
60 void(uint32_t, const RtcpPacketTypeCounter&));
61 };
62
63 class MockRtcpIntraFrameObserver : public RtcpIntraFrameObserver {
64 public:
65 MOCK_METHOD1(OnReceivedIntraFrameRequest, void(uint32_t));
66 };
67
68 class MockRtcpCallbackImpl : public RtcpStatisticsCallback {
69 public:
70 MOCK_METHOD2(StatisticsUpdated, void(const RtcpStatistics&, uint32_t));
71 MOCK_METHOD2(CNameChanged, void(const char*, uint32_t));
72 };
73
74 class MockTransportFeedbackObserver : public TransportFeedbackObserver {
75 public:
76 MOCK_METHOD3(AddPacket, void(uint32_t, uint16_t, size_t));
77 MOCK_METHOD4(AddPacket,
78 void(uint32_t, uint16_t, size_t, const PacedPacketInfo&));
79 MOCK_METHOD1(OnTransportFeedback, void(const rtcp::TransportFeedback&));
80 MOCK_CONST_METHOD0(GetTransportFeedbackVector, std::vector<PacketFeedback>());
81 };
82
83 class MockRtcpBandwidthObserver : public RtcpBandwidthObserver {
84 public:
85 MOCK_METHOD1(OnReceivedEstimatedBitrate, void(uint32_t));
86 MOCK_METHOD3(OnReceivedRtcpReceiverReport,
87 void(const ReportBlockList&, int64_t, int64_t));
88 };
89
90 class MockModuleRtpRtcp : public RTCPReceiver::ModuleRtpRtcp {
91 public:
92 MOCK_METHOD4(GetSendReportMetadata, bool(uint32_t, uint64_t*, uint32_t*, uint64_t*));
93 MOCK_METHOD1(SetTmmbn, void(std::vector<rtcp::TmmbItem>));
94 MOCK_METHOD0(OnRequestSendReport, void());
95 MOCK_METHOD1(OnReceivedNack, void(const std::vector<uint16_t>&));
96 MOCK_METHOD1(OnReceivedRtcpReportBlocks, void(const ReportBlockList&));
97 };
98
99 class MockVideoBitrateAllocationObserver
100 : public VideoBitrateAllocationObserver {
101 public:
102 MOCK_METHOD1(OnBitrateAllocationUpdated,
103 void(const BitrateAllocation& allocation));
104 };
105
106 // SSRC of remote peer, that sends rtcp packet to the rtcp receiver under test.
107 constexpr uint32_t kSenderSsrc = 0x10203;
108 // SSRCs of local peer, that rtcp packet addressed to.
109 constexpr uint32_t kReceiverMainSsrc = 0x123456;
110 // RtcpReceiver can accept several ssrc, e.g. regular and rtx streams.
111 constexpr uint32_t kReceiverExtraSsrc = 0x1234567;
112 // SSRCs to ignore (i.e. not configured in RtcpReceiver).
113 constexpr uint32_t kNotToUsSsrc = 0x654321;
114 constexpr uint32_t kUnknownSenderSsrc = 0x54321;
115
116 } // namespace
117
118 class RtcpReceiverTest : public ::testing::Test {
119 protected:
RtcpReceiverTest()120 RtcpReceiverTest()
121 : system_clock_(1335900000),
122 rtcp_receiver_(&system_clock_,
123 false,
124 &packet_type_counter_observer_,
125 &bandwidth_observer_,
126 &intra_frame_observer_,
127 &transport_feedback_observer_,
128 &bitrate_allocation_observer_,
129 &rtp_rtcp_impl_) {}
SetUp()130 void SetUp() {
131 std::set<uint32_t> ssrcs = {kReceiverMainSsrc, kReceiverExtraSsrc};
132 rtcp_receiver_.SetSsrcs(kReceiverMainSsrc, ssrcs);
133
134 rtcp_receiver_.SetRemoteSSRC(kSenderSsrc);
135 }
136
InjectRtcpPacket(rtc::ArrayView<const uint8_t> raw)137 void InjectRtcpPacket(rtc::ArrayView<const uint8_t> raw) {
138 rtcp_receiver_.IncomingPacket(raw.data(), raw.size());
139 }
140
InjectRtcpPacket(const rtcp::RtcpPacket & packet)141 void InjectRtcpPacket(const rtcp::RtcpPacket& packet) {
142 rtc::Buffer raw = packet.Build();
143 rtcp_receiver_.IncomingPacket(raw.data(), raw.size());
144 }
145
146 SimulatedClock system_clock_;
147 // Callbacks to packet_type_counter_observer are frequent but most of the time
148 // are not interesting.
149 NiceMock<MockRtcpPacketTypeCounterObserver> packet_type_counter_observer_;
150 StrictMock<MockRtcpBandwidthObserver> bandwidth_observer_;
151 StrictMock<MockRtcpIntraFrameObserver> intra_frame_observer_;
152 StrictMock<MockTransportFeedbackObserver> transport_feedback_observer_;
153 StrictMock<MockVideoBitrateAllocationObserver> bitrate_allocation_observer_;
154 StrictMock<MockModuleRtpRtcp> rtp_rtcp_impl_;
155
156 RTCPReceiver rtcp_receiver_;
157 };
158
TEST_F(RtcpReceiverTest,BrokenPacketIsIgnored)159 TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) {
160 const uint8_t bad_packet[] = {0, 0, 0, 0};
161 EXPECT_CALL(packet_type_counter_observer_,
162 RtcpPacketTypesCounterUpdated(_, _))
163 .Times(0);
164 InjectRtcpPacket(bad_packet);
165 }
166
TEST_F(RtcpReceiverTest,InvalidFeedbackPacketIsIgnored)167 TEST_F(RtcpReceiverTest, InvalidFeedbackPacketIsIgnored) {
168 // Too short feedback packet.
169 const uint8_t bad_packet[] = {0x81, rtcp::Rtpfb::kPacketType, 0, 0};
170
171 // TODO(danilchap): Add expectation RtcpPacketTypesCounterUpdated
172 // is not called once parser would be adjusted to avoid that callback on
173 // semi-valid packets.
174 InjectRtcpPacket(bad_packet);
175 }
176
TEST_F(RtcpReceiverTest,InjectSrPacket)177 TEST_F(RtcpReceiverTest, InjectSrPacket) {
178 EXPECT_FALSE(rtcp_receiver_.NTP(nullptr, nullptr, nullptr, nullptr, nullptr));
179
180 int64_t now = system_clock_.TimeInMilliseconds();
181 rtcp::SenderReport sr;
182 sr.SetSenderSsrc(kSenderSsrc);
183
184 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty()));
185 EXPECT_CALL(bandwidth_observer_,
186 OnReceivedRtcpReceiverReport(IsEmpty(), _, now));
187 InjectRtcpPacket(sr);
188
189 EXPECT_TRUE(rtcp_receiver_.NTP(nullptr, nullptr, nullptr, nullptr, nullptr));
190 }
191
TEST_F(RtcpReceiverTest,InjectSrPacketFromUnknownSender)192 TEST_F(RtcpReceiverTest, InjectSrPacketFromUnknownSender) {
193 int64_t now = system_clock_.TimeInMilliseconds();
194 rtcp::SenderReport sr;
195 sr.SetSenderSsrc(kUnknownSenderSsrc);
196
197 // The parser will handle report blocks in Sender Report from other than his
198 // expected peer.
199 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
200 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, now));
201 InjectRtcpPacket(sr);
202
203 // But will not flag that he's gotten sender information.
204 EXPECT_FALSE(rtcp_receiver_.NTP(nullptr, nullptr, nullptr, nullptr, nullptr));
205 }
206
TEST_F(RtcpReceiverTest,InjectSrPacketCalculatesRTT)207 TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesRTT) {
208 Random r(0x0123456789abcdef);
209 const int64_t kRttMs = r.Rand(1, 9 * 3600 * 1000);
210 const uint32_t kDelayNtp = r.Rand(0, 0x7fffffff);
211 const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp);
212
213 int64_t rtt_ms = 0;
214 EXPECT_EQ(
215 -1, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr));
216
217 uint32_t sent_ntp = CompactNtp(system_clock_.CurrentNtpTime());
218 system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
219
220 rtcp::SenderReport sr;
221 sr.SetSenderSsrc(kSenderSsrc);
222 rtcp::ReportBlock block;
223 block.SetMediaSsrc(kReceiverMainSsrc);
224 block.SetLastSr(sent_ntp);
225 block.SetDelayLastSr(kDelayNtp);
226 sr.AddReportBlock(block);
227
228 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
229 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
230 InjectRtcpPacket(sr);
231
232 EXPECT_EQ(
233 0, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr));
234 EXPECT_NEAR(kRttMs, rtt_ms, 1);
235 }
236
TEST_F(RtcpReceiverTest,InjectSrPacketCalculatesNegativeRTTAsOne)237 TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesNegativeRTTAsOne) {
238 Random r(0x0123456789abcdef);
239 const int64_t kRttMs = r.Rand(-3600 * 1000, -1);
240 const uint32_t kDelayNtp = r.Rand(0, 0x7fffffff);
241 const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp);
242
243 int64_t rtt_ms = 0;
244 EXPECT_EQ(
245 -1, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr));
246
247 uint32_t sent_ntp = CompactNtp(system_clock_.CurrentNtpTime());
248 system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
249
250 rtcp::SenderReport sr;
251 sr.SetSenderSsrc(kSenderSsrc);
252 rtcp::ReportBlock block;
253 block.SetMediaSsrc(kReceiverMainSsrc);
254 block.SetLastSr(sent_ntp);
255 block.SetDelayLastSr(kDelayNtp);
256 sr.AddReportBlock(block);
257
258 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1)));
259 EXPECT_CALL(bandwidth_observer_,
260 OnReceivedRtcpReceiverReport(SizeIs(1), _, _));
261 InjectRtcpPacket(sr);
262
263 EXPECT_EQ(
264 0, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr));
265 EXPECT_EQ(1, rtt_ms);
266 }
267
TEST_F(RtcpReceiverTest,InjectRrPacket)268 TEST_F(RtcpReceiverTest, InjectRrPacket) {
269 int64_t now = system_clock_.TimeInMilliseconds();
270 rtcp::ReceiverReport rr;
271 rr.SetSenderSsrc(kSenderSsrc);
272
273 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty()));
274 EXPECT_CALL(bandwidth_observer_,
275 OnReceivedRtcpReceiverReport(IsEmpty(), _, now));
276 InjectRtcpPacket(rr);
277
278 std::vector<RTCPReportBlock> report_blocks;
279 rtcp_receiver_.StatisticsReceived(&report_blocks);
280 EXPECT_TRUE(report_blocks.empty());
281 }
282
TEST_F(RtcpReceiverTest,InjectRrPacketWithReportBlockNotToUsIgnored)283 TEST_F(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) {
284 int64_t now = system_clock_.TimeInMilliseconds();
285 rtcp::ReportBlock rb;
286 rb.SetMediaSsrc(kNotToUsSsrc);
287 rtcp::ReceiverReport rr;
288 rr.SetSenderSsrc(kSenderSsrc);
289 rr.AddReportBlock(rb);
290
291 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty()));
292 EXPECT_CALL(bandwidth_observer_,
293 OnReceivedRtcpReceiverReport(IsEmpty(), _, now));
294 InjectRtcpPacket(rr);
295
296 EXPECT_EQ(0, rtcp_receiver_.LastReceivedReportBlockMs());
297 std::vector<RTCPReportBlock> received_blocks;
298 rtcp_receiver_.StatisticsReceived(&received_blocks);
299 EXPECT_TRUE(received_blocks.empty());
300 }
301
TEST_F(RtcpReceiverTest,InjectRrPacketWithOneReportBlock)302 TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) {
303 int64_t now = system_clock_.TimeInMilliseconds();
304
305 rtcp::ReportBlock rb;
306 rb.SetMediaSsrc(kReceiverMainSsrc);
307 rtcp::ReceiverReport rr;
308 rr.SetSenderSsrc(kSenderSsrc);
309 rr.AddReportBlock(rb);
310
311 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1)));
312 EXPECT_CALL(bandwidth_observer_,
313 OnReceivedRtcpReceiverReport(SizeIs(1), _, now));
314 InjectRtcpPacket(rr);
315
316 EXPECT_EQ(now, rtcp_receiver_.LastReceivedReportBlockMs());
317 std::vector<RTCPReportBlock> received_blocks;
318 rtcp_receiver_.StatisticsReceived(&received_blocks);
319 EXPECT_EQ(1u, received_blocks.size());
320 }
321
TEST_F(RtcpReceiverTest,InjectSrPacketWithOneReportBlock)322 TEST_F(RtcpReceiverTest, InjectSrPacketWithOneReportBlock) {
323 int64_t now = system_clock_.TimeInMilliseconds();
324
325 rtcp::ReportBlock rb;
326 rb.SetMediaSsrc(kReceiverMainSsrc);
327 rtcp::SenderReport sr;
328 sr.SetSenderSsrc(kSenderSsrc);
329 sr.AddReportBlock(rb);
330
331 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1)));
332 EXPECT_CALL(bandwidth_observer_,
333 OnReceivedRtcpReceiverReport(SizeIs(1), _, now));
334 InjectRtcpPacket(sr);
335
336 EXPECT_EQ(now, rtcp_receiver_.LastReceivedReportBlockMs());
337 std::vector<RTCPReportBlock> received_blocks;
338 rtcp_receiver_.StatisticsReceived(&received_blocks);
339 EXPECT_EQ(1u, received_blocks.size());
340 }
341
TEST_F(RtcpReceiverTest,InjectRrPacketWithTwoReportBlocks)342 TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) {
343 const uint16_t kSequenceNumbers[] = {10, 12423};
344 const uint32_t kCumLost[] = {13, 555};
345 const uint8_t kFracLost[] = {20, 11};
346 int64_t now = system_clock_.TimeInMilliseconds();
347
348 rtcp::ReportBlock rb1;
349 rb1.SetMediaSsrc(kReceiverMainSsrc);
350 rb1.SetExtHighestSeqNum(kSequenceNumbers[0]);
351 rb1.SetFractionLost(10);
352
353 rtcp::ReportBlock rb2;
354 rb2.SetMediaSsrc(kReceiverExtraSsrc);
355 rb2.SetExtHighestSeqNum(kSequenceNumbers[1]);
356 rb2.SetFractionLost(0);
357
358 rtcp::ReceiverReport rr1;
359 rr1.SetSenderSsrc(kSenderSsrc);
360 rr1.AddReportBlock(rb1);
361 rr1.AddReportBlock(rb2);
362
363 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(2)));
364 EXPECT_CALL(bandwidth_observer_,
365 OnReceivedRtcpReceiverReport(SizeIs(2), _, now));
366 InjectRtcpPacket(rr1);
367
368 EXPECT_EQ(now, rtcp_receiver_.LastReceivedReportBlockMs());
369 std::vector<RTCPReportBlock> received_blocks;
370 rtcp_receiver_.StatisticsReceived(&received_blocks);
371 EXPECT_THAT(received_blocks,
372 UnorderedElementsAre(Field(&RTCPReportBlock::fraction_lost, 0),
373 Field(&RTCPReportBlock::fraction_lost, 10)));
374
375 // Insert next receiver report with same ssrc but new values.
376 rtcp::ReportBlock rb3;
377 rb3.SetMediaSsrc(kReceiverMainSsrc);
378 rb3.SetExtHighestSeqNum(kSequenceNumbers[0]);
379 rb3.SetFractionLost(kFracLost[0]);
380 rb3.SetCumulativeLost(kCumLost[0]);
381
382 rtcp::ReportBlock rb4;
383 rb4.SetMediaSsrc(kReceiverExtraSsrc);
384 rb4.SetExtHighestSeqNum(kSequenceNumbers[1]);
385 rb4.SetFractionLost(kFracLost[1]);
386 rb4.SetCumulativeLost(kCumLost[1]);
387
388 rtcp::ReceiverReport rr2;
389 rr2.SetSenderSsrc(kSenderSsrc);
390 rr2.AddReportBlock(rb3);
391 rr2.AddReportBlock(rb4);
392
393 // Advance time to make 1st sent time and 2nd sent time different.
394 system_clock_.AdvanceTimeMilliseconds(500);
395 now = system_clock_.TimeInMilliseconds();
396
397 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(2)));
398 EXPECT_CALL(bandwidth_observer_,
399 OnReceivedRtcpReceiverReport(SizeIs(2), _, now));
400 InjectRtcpPacket(rr2);
401
402 received_blocks.clear();
403 rtcp_receiver_.StatisticsReceived(&received_blocks);
404 EXPECT_EQ(2u, received_blocks.size());
405 EXPECT_THAT(
406 received_blocks,
407 UnorderedElementsAre(
408 AllOf(Field(&RTCPReportBlock::source_ssrc, kReceiverMainSsrc),
409 Field(&RTCPReportBlock::fraction_lost, kFracLost[0]),
410 Field(&RTCPReportBlock::packets_lost, kCumLost[0]),
411 Field(&RTCPReportBlock::extended_highest_sequence_number,
412 kSequenceNumbers[0])),
413 AllOf(Field(&RTCPReportBlock::source_ssrc, kReceiverExtraSsrc),
414 Field(&RTCPReportBlock::fraction_lost, kFracLost[1]),
415 Field(&RTCPReportBlock::packets_lost, kCumLost[1]),
416 Field(&RTCPReportBlock::extended_highest_sequence_number,
417 kSequenceNumbers[1]))));
418 }
419
TEST_F(RtcpReceiverTest,InjectRrPacketsFromTwoRemoteSsrcs)420 TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) {
421 const uint32_t kSenderSsrc2 = 0x20304;
422 const uint16_t kSequenceNumbers[] = {10, 12423};
423 const uint32_t kCumLost[] = {13, 555};
424 const uint8_t kFracLost[] = {20, 11};
425
426 rtcp::ReportBlock rb1;
427 rb1.SetMediaSsrc(kReceiverMainSsrc);
428 rb1.SetExtHighestSeqNum(kSequenceNumbers[0]);
429 rb1.SetFractionLost(kFracLost[0]);
430 rb1.SetCumulativeLost(kCumLost[0]);
431 rtcp::ReceiverReport rr1;
432 rr1.SetSenderSsrc(kSenderSsrc);
433 rr1.AddReportBlock(rb1);
434
435 int64_t now = system_clock_.TimeInMilliseconds();
436
437 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1)));
438 EXPECT_CALL(bandwidth_observer_,
439 OnReceivedRtcpReceiverReport(SizeIs(1), _, now));
440 InjectRtcpPacket(rr1);
441
442 EXPECT_EQ(now, rtcp_receiver_.LastReceivedReportBlockMs());
443
444 std::vector<RTCPReportBlock> received_blocks;
445 rtcp_receiver_.StatisticsReceived(&received_blocks);
446 EXPECT_EQ(1u, received_blocks.size());
447 EXPECT_EQ(kSenderSsrc, received_blocks[0].sender_ssrc);
448 EXPECT_EQ(kReceiverMainSsrc, received_blocks[0].source_ssrc);
449 EXPECT_EQ(kFracLost[0], received_blocks[0].fraction_lost);
450 EXPECT_EQ(kCumLost[0], received_blocks[0].packets_lost);
451 EXPECT_EQ(kSequenceNumbers[0],
452 received_blocks[0].extended_highest_sequence_number);
453
454 rtcp::ReportBlock rb2;
455 rb2.SetMediaSsrc(kReceiverMainSsrc);
456 rb2.SetExtHighestSeqNum(kSequenceNumbers[1]);
457 rb2.SetFractionLost(kFracLost[1]);
458 rb2.SetCumulativeLost(kCumLost[1]);
459 rtcp::ReceiverReport rr2;
460 rr2.SetSenderSsrc(kSenderSsrc2);
461 rr2.AddReportBlock(rb2);
462
463 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1)));
464 EXPECT_CALL(bandwidth_observer_,
465 OnReceivedRtcpReceiverReport(SizeIs(1), _, now));
466 InjectRtcpPacket(rr2);
467
468 received_blocks.clear();
469 rtcp_receiver_.StatisticsReceived(&received_blocks);
470 ASSERT_EQ(2u, received_blocks.size());
471 EXPECT_THAT(
472 received_blocks,
473 UnorderedElementsAre(
474 AllOf(Field(&RTCPReportBlock::source_ssrc, kReceiverMainSsrc),
475 Field(&RTCPReportBlock::sender_ssrc, kSenderSsrc),
476 Field(&RTCPReportBlock::fraction_lost, kFracLost[0]),
477 Field(&RTCPReportBlock::packets_lost, kCumLost[0]),
478 Field(&RTCPReportBlock::extended_highest_sequence_number,
479 kSequenceNumbers[0])),
480 AllOf(Field(&RTCPReportBlock::source_ssrc, kReceiverMainSsrc),
481 Field(&RTCPReportBlock::sender_ssrc, kSenderSsrc2),
482 Field(&RTCPReportBlock::fraction_lost, kFracLost[1]),
483 Field(&RTCPReportBlock::packets_lost, kCumLost[1]),
484 Field(&RTCPReportBlock::extended_highest_sequence_number,
485 kSequenceNumbers[1]))));
486 }
487
TEST_F(RtcpReceiverTest,GetRtt)488 TEST_F(RtcpReceiverTest, GetRtt) {
489 const uint32_t kSentCompactNtp = 0x1234;
490 const uint32_t kDelayCompactNtp = 0x222;
491 // No report block received.
492 EXPECT_EQ(
493 -1, rtcp_receiver_.RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr));
494
495 rtcp::ReportBlock rb;
496 rb.SetMediaSsrc(kReceiverMainSsrc);
497 rb.SetLastSr(kSentCompactNtp);
498 rb.SetDelayLastSr(kDelayCompactNtp);
499
500 rtcp::ReceiverReport rr;
501 rr.SetSenderSsrc(kSenderSsrc);
502 rr.AddReportBlock(rb);
503 int64_t now = system_clock_.TimeInMilliseconds();
504
505 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
506 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
507 InjectRtcpPacket(rr);
508
509 EXPECT_EQ(now, rtcp_receiver_.LastReceivedReportBlockMs());
510 EXPECT_EQ(
511 0, rtcp_receiver_.RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr));
512 }
513
514 // Ij packets are ignored.
TEST_F(RtcpReceiverTest,InjectIjWithNoItem)515 TEST_F(RtcpReceiverTest, InjectIjWithNoItem) {
516 rtcp::ExtendedJitterReport ij;
517 InjectRtcpPacket(ij);
518 }
519
520 // App packets are ignored.
TEST_F(RtcpReceiverTest,InjectApp)521 TEST_F(RtcpReceiverTest, InjectApp) {
522 rtcp::App app;
523 app.SetSubType(30);
524 app.SetName(0x17a177e);
525 const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'};
526 app.SetData(kData, sizeof(kData));
527
528 InjectRtcpPacket(app);
529 }
530
TEST_F(RtcpReceiverTest,InjectSdesWithOneChunk)531 TEST_F(RtcpReceiverTest, InjectSdesWithOneChunk) {
532 const char kCname[] = "alice@host";
533 MockRtcpCallbackImpl callback;
534 rtcp_receiver_.RegisterRtcpStatisticsCallback(&callback);
535 rtcp::Sdes sdes;
536 sdes.AddCName(kSenderSsrc, kCname);
537
538 EXPECT_CALL(callback, CNameChanged(StrEq(kCname), kSenderSsrc));
539 InjectRtcpPacket(sdes);
540
541 char cName[RTCP_CNAME_SIZE];
542 EXPECT_EQ(0, rtcp_receiver_.CNAME(kSenderSsrc, cName));
543 EXPECT_EQ(0, strncmp(cName, kCname, RTCP_CNAME_SIZE));
544 }
545
TEST_F(RtcpReceiverTest,InjectByePacket_RemovesCname)546 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) {
547 const char kCname[] = "alice@host";
548 rtcp::Sdes sdes;
549 sdes.AddCName(kSenderSsrc, kCname);
550
551 InjectRtcpPacket(sdes);
552
553 char cName[RTCP_CNAME_SIZE];
554 EXPECT_EQ(0, rtcp_receiver_.CNAME(kSenderSsrc, cName));
555
556 // Verify that BYE removes the CNAME.
557 rtcp::Bye bye;
558 bye.SetSenderSsrc(kSenderSsrc);
559
560 InjectRtcpPacket(bye);
561
562 EXPECT_EQ(-1, rtcp_receiver_.CNAME(kSenderSsrc, cName));
563 }
564
TEST_F(RtcpReceiverTest,InjectByePacket_RemovesReportBlocks)565 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) {
566 rtcp::ReportBlock rb1;
567 rb1.SetMediaSsrc(kReceiverMainSsrc);
568 rtcp::ReportBlock rb2;
569 rb2.SetMediaSsrc(kReceiverExtraSsrc);
570 rtcp::ReceiverReport rr;
571 rr.SetSenderSsrc(kSenderSsrc);
572 rr.AddReportBlock(rb1);
573 rr.AddReportBlock(rb2);
574
575 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
576 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
577 InjectRtcpPacket(rr);
578
579 std::vector<RTCPReportBlock> received_blocks;
580 rtcp_receiver_.StatisticsReceived(&received_blocks);
581 EXPECT_EQ(2u, received_blocks.size());
582
583 // Verify that BYE removes the report blocks.
584 rtcp::Bye bye;
585 bye.SetSenderSsrc(kSenderSsrc);
586
587 InjectRtcpPacket(bye);
588
589 received_blocks.clear();
590 rtcp_receiver_.StatisticsReceived(&received_blocks);
591 EXPECT_TRUE(received_blocks.empty());
592
593 // Inject packet again.
594 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
595 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
596 InjectRtcpPacket(rr);
597
598 received_blocks.clear();
599 rtcp_receiver_.StatisticsReceived(&received_blocks);
600 EXPECT_EQ(2u, received_blocks.size());
601 }
602
TEST_F(RtcpReceiverTest,InjectPliPacket)603 TEST_F(RtcpReceiverTest, InjectPliPacket) {
604 rtcp::Pli pli;
605 pli.SetMediaSsrc(kReceiverMainSsrc);
606
607 EXPECT_CALL(
608 packet_type_counter_observer_,
609 RtcpPacketTypesCounterUpdated(
610 kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::pli_packets, 1)));
611 EXPECT_CALL(intra_frame_observer_,
612 OnReceivedIntraFrameRequest(kReceiverMainSsrc));
613 InjectRtcpPacket(pli);
614 }
615
TEST_F(RtcpReceiverTest,PliPacketNotToUsIgnored)616 TEST_F(RtcpReceiverTest, PliPacketNotToUsIgnored) {
617 rtcp::Pli pli;
618 pli.SetMediaSsrc(kNotToUsSsrc);
619
620 EXPECT_CALL(
621 packet_type_counter_observer_,
622 RtcpPacketTypesCounterUpdated(
623 kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::pli_packets, 0)));
624 EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(_)).Times(0);
625 InjectRtcpPacket(pli);
626 }
627
TEST_F(RtcpReceiverTest,InjectFirPacket)628 TEST_F(RtcpReceiverTest, InjectFirPacket) {
629 rtcp::Fir fir;
630 fir.AddRequestTo(kReceiverMainSsrc, 13);
631
632 EXPECT_CALL(
633 packet_type_counter_observer_,
634 RtcpPacketTypesCounterUpdated(
635 kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::fir_packets, 1)));
636 EXPECT_CALL(intra_frame_observer_,
637 OnReceivedIntraFrameRequest(kReceiverMainSsrc));
638 InjectRtcpPacket(fir);
639 }
640
TEST_F(RtcpReceiverTest,FirPacketNotToUsIgnored)641 TEST_F(RtcpReceiverTest, FirPacketNotToUsIgnored) {
642 rtcp::Fir fir;
643 fir.AddRequestTo(kNotToUsSsrc, 13);
644
645 EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(_)).Times(0);
646 InjectRtcpPacket(fir);
647 }
648
TEST_F(RtcpReceiverTest,ExtendedReportsPacketWithZeroReportBlocksIgnored)649 TEST_F(RtcpReceiverTest, ExtendedReportsPacketWithZeroReportBlocksIgnored) {
650 rtcp::ExtendedReports xr;
651 xr.SetSenderSsrc(kSenderSsrc);
652
653 InjectRtcpPacket(xr);
654 }
655
656 // VOiP reports are ignored.
TEST_F(RtcpReceiverTest,InjectExtendedReportsVoipPacket)657 TEST_F(RtcpReceiverTest, InjectExtendedReportsVoipPacket) {
658 const uint8_t kLossRate = 123;
659 rtcp::VoipMetric voip_metric;
660 voip_metric.SetMediaSsrc(kReceiverMainSsrc);
661 RTCPVoIPMetric metric;
662 metric.lossRate = kLossRate;
663 voip_metric.SetVoipMetric(metric);
664 rtcp::ExtendedReports xr;
665 xr.SetSenderSsrc(kSenderSsrc);
666 xr.SetVoipMetric(voip_metric);
667
668 InjectRtcpPacket(xr);
669 }
670
TEST_F(RtcpReceiverTest,ExtendedReportsVoipPacketNotToUsIgnored)671 TEST_F(RtcpReceiverTest, ExtendedReportsVoipPacketNotToUsIgnored) {
672 rtcp::VoipMetric voip_metric;
673 voip_metric.SetMediaSsrc(kNotToUsSsrc);
674 rtcp::ExtendedReports xr;
675 xr.SetSenderSsrc(kSenderSsrc);
676 xr.SetVoipMetric(voip_metric);
677
678 InjectRtcpPacket(xr);
679 }
680
TEST_F(RtcpReceiverTest,InjectExtendedReportsReceiverReferenceTimePacket)681 TEST_F(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) {
682 const NtpTime kNtp(0x10203, 0x40506);
683 rtcp::Rrtr rrtr;
684 rrtr.SetNtp(kNtp);
685 rtcp::ExtendedReports xr;
686 xr.SetSenderSsrc(kSenderSsrc);
687 xr.SetRrtr(rrtr);
688
689 ReceiveTimeInfo rrtime;
690 EXPECT_FALSE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime));
691
692 InjectRtcpPacket(xr);
693
694 EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime));
695 EXPECT_EQ(rrtime.ssrc, kSenderSsrc);
696 EXPECT_EQ(rrtime.last_rr, CompactNtp(kNtp));
697 EXPECT_EQ(0U, rrtime.delay_since_last_rr);
698
699 system_clock_.AdvanceTimeMilliseconds(1500);
700 EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime));
701 EXPECT_NEAR(1500, CompactNtpRttToMs(rrtime.delay_since_last_rr), 1);
702 }
703
TEST_F(RtcpReceiverTest,ExtendedReportsDlrrPacketNotToUsIgnored)704 TEST_F(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) {
705 // Allow calculate rtt using dlrr/rrtr, simulating media receiver side.
706 rtcp_receiver_.SetRtcpXrRrtrStatus(true);
707
708 rtcp::ExtendedReports xr;
709 xr.SetSenderSsrc(kSenderSsrc);
710 xr.AddDlrrItem(ReceiveTimeInfo(kNotToUsSsrc, 0x12345, 0x67890));
711
712 InjectRtcpPacket(xr);
713
714 int64_t rtt_ms = 0;
715 EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
716 }
717
TEST_F(RtcpReceiverTest,InjectExtendedReportsDlrrPacketWithSubBlock)718 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) {
719 const uint32_t kLastRR = 0x12345;
720 const uint32_t kDelay = 0x23456;
721 rtcp_receiver_.SetRtcpXrRrtrStatus(true);
722 int64_t rtt_ms = 0;
723 EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
724
725 rtcp::ExtendedReports xr;
726 xr.SetSenderSsrc(kSenderSsrc);
727 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, kLastRR, kDelay));
728
729 InjectRtcpPacket(xr);
730
731 uint32_t compact_ntp_now = CompactNtp(system_clock_.CurrentNtpTime());
732 EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
733 uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR;
734 EXPECT_NEAR(CompactNtpRttToMs(rtt_ntp), rtt_ms, 1);
735 }
736
TEST_F(RtcpReceiverTest,InjectExtendedReportsDlrrPacketWithMultipleSubBlocks)737 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) {
738 const uint32_t kLastRR = 0x12345;
739 const uint32_t kDelay = 0x56789;
740 rtcp_receiver_.SetRtcpXrRrtrStatus(true);
741
742 rtcp::ExtendedReports xr;
743 xr.SetSenderSsrc(kSenderSsrc);
744 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, kLastRR, kDelay));
745 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc + 1, 0x12345, 0x67890));
746 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc + 2, 0x12345, 0x67890));
747
748 InjectRtcpPacket(xr);
749
750 uint32_t compact_ntp_now = CompactNtp(system_clock_.CurrentNtpTime());
751 int64_t rtt_ms = 0;
752 EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
753 uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR;
754 EXPECT_NEAR(CompactNtpRttToMs(rtt_ntp), rtt_ms, 1);
755 }
756
TEST_F(RtcpReceiverTest,InjectExtendedReportsPacketWithMultipleReportBlocks)757 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) {
758 rtcp_receiver_.SetRtcpXrRrtrStatus(true);
759
760 rtcp::Rrtr rrtr;
761 rtcp::VoipMetric metric;
762 metric.SetMediaSsrc(kReceiverMainSsrc);
763 rtcp::ExtendedReports xr;
764 xr.SetSenderSsrc(kSenderSsrc);
765 xr.SetRrtr(rrtr);
766 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, 0x12345, 0x67890));
767 xr.SetVoipMetric(metric);
768
769 InjectRtcpPacket(xr);
770
771 ReceiveTimeInfo rrtime;
772 EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime));
773 int64_t rtt_ms = 0;
774 EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
775 }
776
TEST_F(RtcpReceiverTest,InjectExtendedReportsPacketWithUnknownReportBlock)777 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) {
778 rtcp_receiver_.SetRtcpXrRrtrStatus(true);
779
780 rtcp::Rrtr rrtr;
781 rtcp::VoipMetric metric;
782 metric.SetMediaSsrc(kReceiverMainSsrc);
783 rtcp::ExtendedReports xr;
784 xr.SetSenderSsrc(kSenderSsrc);
785 xr.SetRrtr(rrtr);
786 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, 0x12345, 0x67890));
787 xr.SetVoipMetric(metric);
788
789 rtc::Buffer packet = xr.Build();
790 // Modify the DLRR block to have an unsupported block type, from 5 to 6.
791 ASSERT_EQ(5, packet.data()[20]);
792 packet.data()[20] = 6;
793 InjectRtcpPacket(packet);
794
795 // Validate Rrtr was received and processed.
796 ReceiveTimeInfo rrtime;
797 EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime));
798 // Validate Dlrr report wasn't processed.
799 int64_t rtt_ms = 0;
800 EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
801 }
802
TEST_F(RtcpReceiverTest,TestExtendedReportsRrRttInitiallyFalse)803 TEST_F(RtcpReceiverTest, TestExtendedReportsRrRttInitiallyFalse) {
804 rtcp_receiver_.SetRtcpXrRrtrStatus(true);
805
806 int64_t rtt_ms;
807 EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
808 }
809
TEST_F(RtcpReceiverTest,RttCalculatedAfterExtendedReportsDlrr)810 TEST_F(RtcpReceiverTest, RttCalculatedAfterExtendedReportsDlrr) {
811 Random rand(0x0123456789abcdef);
812 const int64_t kRttMs = rand.Rand(1, 9 * 3600 * 1000);
813 const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff);
814 const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp);
815 rtcp_receiver_.SetRtcpXrRrtrStatus(true);
816 NtpTime now = system_clock_.CurrentNtpTime();
817 uint32_t sent_ntp = CompactNtp(now);
818 system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
819
820 rtcp::ExtendedReports xr;
821 xr.SetSenderSsrc(kSenderSsrc);
822 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, sent_ntp, kDelayNtp));
823
824 InjectRtcpPacket(xr);
825
826 int64_t rtt_ms = 0;
827 EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
828 EXPECT_NEAR(kRttMs, rtt_ms, 1);
829 }
830
TEST_F(RtcpReceiverTest,XrDlrrCalculatesNegativeRttAsOne)831 TEST_F(RtcpReceiverTest, XrDlrrCalculatesNegativeRttAsOne) {
832 Random rand(0x0123456789abcdef);
833 const int64_t kRttMs = rand.Rand(-3600 * 1000, -1);
834 const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff);
835 const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp);
836 NtpTime now = system_clock_.CurrentNtpTime();
837 uint32_t sent_ntp = CompactNtp(now);
838 system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
839 rtcp_receiver_.SetRtcpXrRrtrStatus(true);
840
841 rtcp::ExtendedReports xr;
842 xr.SetSenderSsrc(kSenderSsrc);
843 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, sent_ntp, kDelayNtp));
844
845 InjectRtcpPacket(xr);
846
847 int64_t rtt_ms = 0;
848 EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
849 EXPECT_EQ(1, rtt_ms);
850 }
851
TEST_F(RtcpReceiverTest,LastReceivedXrReferenceTimeInfoInitiallyFalse)852 TEST_F(RtcpReceiverTest, LastReceivedXrReferenceTimeInfoInitiallyFalse) {
853 ReceiveTimeInfo info;
854 EXPECT_FALSE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&info));
855 }
856
TEST_F(RtcpReceiverTest,GetLastReceivedExtendedReportsReferenceTimeInfo)857 TEST_F(RtcpReceiverTest, GetLastReceivedExtendedReportsReferenceTimeInfo) {
858 const NtpTime kNtp(0x10203, 0x40506);
859 const uint32_t kNtpMid = CompactNtp(kNtp);
860
861 rtcp::Rrtr rrtr;
862 rrtr.SetNtp(kNtp);
863 rtcp::ExtendedReports xr;
864 xr.SetSenderSsrc(kSenderSsrc);
865 xr.SetRrtr(rrtr);
866
867 InjectRtcpPacket(xr);
868
869 ReceiveTimeInfo info;
870 EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&info));
871 EXPECT_EQ(kSenderSsrc, info.ssrc);
872 EXPECT_EQ(kNtpMid, info.last_rr);
873 EXPECT_EQ(0U, info.delay_since_last_rr);
874
875 system_clock_.AdvanceTimeMilliseconds(1000);
876 EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&info));
877 EXPECT_EQ(65536U, info.delay_since_last_rr);
878 }
879
TEST_F(RtcpReceiverTest,ReceiveReportTimeout)880 TEST_F(RtcpReceiverTest, ReceiveReportTimeout) {
881 const int64_t kRtcpIntervalMs = 1000;
882 const uint16_t kSequenceNumber = 1234;
883 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs);
884
885 // No RR received, shouldn't trigger a timeout.
886 EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs));
887 EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
888
889 // Add a RR and advance the clock just enough to not trigger a timeout.
890 rtcp::ReportBlock rb1;
891 rb1.SetMediaSsrc(kReceiverMainSsrc);
892 rb1.SetExtHighestSeqNum(kSequenceNumber);
893 rtcp::ReceiverReport rr1;
894 rr1.SetSenderSsrc(kSenderSsrc);
895 rr1.AddReportBlock(rb1);
896
897 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
898 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
899 InjectRtcpPacket(rr1);
900
901 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs - 1);
902 EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs));
903 EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
904
905 // Add a RR with the same extended max as the previous RR to trigger a
906 // sequence number timeout, but not a RR timeout.
907 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
908 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
909 InjectRtcpPacket(rr1);
910
911 system_clock_.AdvanceTimeMilliseconds(2);
912 EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs));
913 EXPECT_TRUE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
914
915 // Advance clock enough to trigger an RR timeout too.
916 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs);
917 EXPECT_TRUE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs));
918
919 // We should only get one timeout even though we still haven't received a new
920 // RR.
921 EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs));
922 EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
923
924 // Add a new RR with increase sequence number to reset timers.
925 rtcp::ReportBlock rb2;
926 rb2.SetMediaSsrc(kReceiverMainSsrc);
927 rb2.SetExtHighestSeqNum(kSequenceNumber + 1);
928 rtcp::ReceiverReport rr2;
929 rr2.SetSenderSsrc(kSenderSsrc);
930 rr2.AddReportBlock(rb2);
931
932 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
933 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
934 InjectRtcpPacket(rr2);
935
936 EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs));
937 EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
938
939 // Verify we can get a timeout again once we've received new RR.
940 system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs);
941 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
942 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
943 InjectRtcpPacket(rr2);
944
945 system_clock_.AdvanceTimeMilliseconds(kRtcpIntervalMs + 1);
946 EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs));
947 EXPECT_TRUE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
948
949 system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs);
950 EXPECT_TRUE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs));
951 }
952
TEST_F(RtcpReceiverTest,TmmbrReceivedWithNoIncomingPacket)953 TEST_F(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) {
954 EXPECT_EQ(0u, rtcp_receiver_.TmmbrReceived().size());
955 }
956
TEST_F(RtcpReceiverTest,TmmbrPacketAccepted)957 TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) {
958 const uint32_t kBitrateBps = 30000;
959 rtcp::Tmmbr tmmbr;
960 tmmbr.SetSenderSsrc(kSenderSsrc);
961 tmmbr.AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, kBitrateBps, 0));
962 rtcp::SenderReport sr;
963 sr.SetSenderSsrc(kSenderSsrc);
964 rtcp::CompoundPacket compound;
965 compound.Append(&sr);
966 compound.Append(&tmmbr);
967
968 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
969 EXPECT_CALL(rtp_rtcp_impl_, SetTmmbn(SizeIs(1)));
970 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
971 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps));
972 InjectRtcpPacket(compound);
973
974 std::vector<rtcp::TmmbItem> tmmbr_received = rtcp_receiver_.TmmbrReceived();
975 ASSERT_EQ(1u, tmmbr_received.size());
976 EXPECT_EQ(kBitrateBps, tmmbr_received[0].bitrate_bps());
977 EXPECT_EQ(kSenderSsrc, tmmbr_received[0].ssrc());
978 }
979
TEST_F(RtcpReceiverTest,TmmbrPacketNotForUsIgnored)980 TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) {
981 const uint32_t kBitrateBps = 30000;
982 rtcp::Tmmbr tmmbr;
983 tmmbr.SetSenderSsrc(kSenderSsrc);
984 tmmbr.AddTmmbr(rtcp::TmmbItem(kNotToUsSsrc, kBitrateBps, 0));
985
986 rtcp::SenderReport sr;
987 sr.SetSenderSsrc(kSenderSsrc);
988 rtcp::CompoundPacket compound;
989 compound.Append(&sr);
990 compound.Append(&tmmbr);
991
992 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
993 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
994 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)).Times(0);
995 InjectRtcpPacket(compound);
996
997 EXPECT_EQ(0u, rtcp_receiver_.TmmbrReceived().size());
998 }
999
TEST_F(RtcpReceiverTest,TmmbrPacketZeroRateIgnored)1000 TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) {
1001 rtcp::Tmmbr tmmbr;
1002 tmmbr.SetSenderSsrc(kSenderSsrc);
1003 tmmbr.AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 0, 0));
1004 rtcp::SenderReport sr;
1005 sr.SetSenderSsrc(kSenderSsrc);
1006 rtcp::CompoundPacket compound;
1007 compound.Append(&sr);
1008 compound.Append(&tmmbr);
1009
1010 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
1011 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
1012 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)).Times(0);
1013 InjectRtcpPacket(compound);
1014
1015 EXPECT_EQ(0u, rtcp_receiver_.TmmbrReceived().size());
1016 }
1017
TEST_F(RtcpReceiverTest,TmmbrThreeConstraintsTimeOut)1018 TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) {
1019 // Inject 3 packets "from" kSenderSsrc, kSenderSsrc+1, kSenderSsrc+2.
1020 // The times of arrival are starttime + 0, starttime + 5 and starttime + 10.
1021 for (uint32_t ssrc = kSenderSsrc; ssrc < kSenderSsrc + 3; ++ssrc) {
1022 rtcp::Tmmbr tmmbr;
1023 tmmbr.SetSenderSsrc(ssrc);
1024 tmmbr.AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 30000, 0));
1025 rtcp::SenderReport sr;
1026 sr.SetSenderSsrc(ssrc);
1027 rtcp::CompoundPacket compound;
1028 compound.Append(&sr);
1029 compound.Append(&tmmbr);
1030
1031 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
1032 EXPECT_CALL(rtp_rtcp_impl_, SetTmmbn(_));
1033 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
1034 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_));
1035 InjectRtcpPacket(compound);
1036
1037 // 5 seconds between each packet.
1038 system_clock_.AdvanceTimeMilliseconds(5000);
1039 }
1040 // It is now starttime + 15.
1041 std::vector<rtcp::TmmbItem> candidate_set = rtcp_receiver_.TmmbrReceived();
1042 ASSERT_EQ(3u, candidate_set.size());
1043 EXPECT_EQ(30000U, candidate_set[0].bitrate_bps());
1044
1045 // We expect the timeout to be 25 seconds. Advance the clock by 12
1046 // seconds, timing out the first packet.
1047 system_clock_.AdvanceTimeMilliseconds(12000);
1048 candidate_set = rtcp_receiver_.TmmbrReceived();
1049 ASSERT_EQ(2u, candidate_set.size());
1050 EXPECT_EQ(kSenderSsrc + 1, candidate_set[0].ssrc());
1051 }
1052
TEST_F(RtcpReceiverTest,Callbacks)1053 TEST_F(RtcpReceiverTest, Callbacks) {
1054 MockRtcpCallbackImpl callback;
1055 rtcp_receiver_.RegisterRtcpStatisticsCallback(&callback);
1056
1057 const uint8_t kFractionLoss = 3;
1058 const uint32_t kCumulativeLoss = 7;
1059 const uint32_t kJitter = 9;
1060 const uint16_t kSequenceNumber = 1234;
1061
1062 // First packet, all numbers should just propagate.
1063 rtcp::ReportBlock rb1;
1064 rb1.SetMediaSsrc(kReceiverMainSsrc);
1065 rb1.SetExtHighestSeqNum(kSequenceNumber);
1066 rb1.SetFractionLost(kFractionLoss);
1067 rb1.SetCumulativeLost(kCumulativeLoss);
1068 rb1.SetJitter(kJitter);
1069
1070 rtcp::ReceiverReport rr1;
1071 rr1.SetSenderSsrc(kSenderSsrc);
1072 rr1.AddReportBlock(rb1);
1073 EXPECT_CALL(callback,
1074 StatisticsUpdated(
1075 AllOf(Field(&RtcpStatistics::fraction_lost, kFractionLoss),
1076 Field(&RtcpStatistics::packets_lost, kCumulativeLoss),
1077 Field(&RtcpStatistics::extended_highest_sequence_number,
1078 kSequenceNumber),
1079 Field(&RtcpStatistics::jitter, kJitter)),
1080 kReceiverMainSsrc));
1081 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
1082 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
1083 InjectRtcpPacket(rr1);
1084
1085 rtcp_receiver_.RegisterRtcpStatisticsCallback(nullptr);
1086
1087 // Add arbitrary numbers, callback should not be called.
1088 rtcp::ReportBlock rb2;
1089 rb2.SetMediaSsrc(kReceiverMainSsrc);
1090 rb2.SetExtHighestSeqNum(kSequenceNumber + 1);
1091 rb2.SetFractionLost(42);
1092 rb2.SetCumulativeLost(137);
1093 rb2.SetJitter(4711);
1094
1095 rtcp::ReceiverReport rr2;
1096 rr2.SetSenderSsrc(kSenderSsrc);
1097 rr2.AddReportBlock(rb2);
1098
1099 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
1100 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
1101 EXPECT_CALL(callback, StatisticsUpdated(_, _)).Times(0);
1102 InjectRtcpPacket(rr2);
1103 }
1104
TEST_F(RtcpReceiverTest,ReceivesTransportFeedback)1105 TEST_F(RtcpReceiverTest, ReceivesTransportFeedback) {
1106 rtcp::TransportFeedback packet;
1107 packet.SetMediaSsrc(kReceiverMainSsrc);
1108 packet.SetSenderSsrc(kSenderSsrc);
1109 packet.SetBase(1, 1000);
1110 packet.AddReceivedPacket(1, 1000);
1111
1112 EXPECT_CALL(
1113 transport_feedback_observer_,
1114 OnTransportFeedback(AllOf(
1115 Property(&rtcp::TransportFeedback::media_ssrc, kReceiverMainSsrc),
1116 Property(&rtcp::TransportFeedback::sender_ssrc, kSenderSsrc))));
1117 InjectRtcpPacket(packet);
1118 }
1119
TEST_F(RtcpReceiverTest,ReceivesRemb)1120 TEST_F(RtcpReceiverTest, ReceivesRemb) {
1121 const uint32_t kBitrateBps = 500000;
1122 rtcp::Remb remb;
1123 remb.SetSenderSsrc(kSenderSsrc);
1124 remb.SetBitrateBps(kBitrateBps);
1125
1126 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps));
1127 InjectRtcpPacket(remb);
1128 }
1129
TEST_F(RtcpReceiverTest,HandlesInvalidTransportFeedback)1130 TEST_F(RtcpReceiverTest, HandlesInvalidTransportFeedback) {
1131 // Send a compound packet with a TransportFeedback followed by something else.
1132 rtcp::TransportFeedback packet;
1133 packet.SetMediaSsrc(kReceiverMainSsrc);
1134 packet.SetSenderSsrc(kSenderSsrc);
1135 packet.SetBase(1, 1000);
1136 packet.AddReceivedPacket(1, 1000);
1137
1138 static uint32_t kBitrateBps = 50000;
1139 rtcp::Remb remb;
1140 remb.SetSenderSsrc(kSenderSsrc);
1141 remb.SetBitrateBps(kBitrateBps);
1142 rtcp::CompoundPacket compound;
1143 compound.Append(&packet);
1144 compound.Append(&remb);
1145 rtc::Buffer built_packet = compound.Build();
1146
1147 // Modify the TransportFeedback packet so that it is invalid.
1148 const size_t kStatusCountOffset = 14;
1149 ByteWriter<uint16_t>::WriteBigEndian(
1150 &built_packet.data()[kStatusCountOffset], 42);
1151
1152 // Stress no transport feedback is expected.
1153 EXPECT_CALL(transport_feedback_observer_, OnTransportFeedback(_)).Times(0);
1154 // But remb should be processed and cause a callback
1155 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps));
1156 InjectRtcpPacket(built_packet);
1157 }
1158
TEST_F(RtcpReceiverTest,Nack)1159 TEST_F(RtcpReceiverTest, Nack) {
1160 const uint16_t kNackList1[] = {1, 2, 3, 5};
1161 const uint16_t kNackList23[] = {5, 7, 30, 40, 41, 58, 59, 61, 63};
1162 const size_t kNackListLength2 = 4;
1163 const size_t kNackListLength3 = arraysize(kNackList23) - kNackListLength2;
1164 std::set<uint16_t> nack_set;
1165 nack_set.insert(std::begin(kNackList1), std::end(kNackList1));
1166 nack_set.insert(std::begin(kNackList23), std::end(kNackList23));
1167
1168 rtcp::Nack nack1;
1169 nack1.SetSenderSsrc(kSenderSsrc);
1170 nack1.SetMediaSsrc(kReceiverMainSsrc);
1171 nack1.SetPacketIds(kNackList1, arraysize(kNackList1));
1172
1173 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedNack(ElementsAreArray(kNackList1)));
1174 EXPECT_CALL(packet_type_counter_observer_,
1175 RtcpPacketTypesCounterUpdated(
1176 kReceiverMainSsrc,
1177 AllOf(Field(&RtcpPacketTypeCounter::nack_requests,
1178 arraysize(kNackList1)),
1179 Field(&RtcpPacketTypeCounter::unique_nack_requests,
1180 arraysize(kNackList1)))));
1181 InjectRtcpPacket(nack1);
1182
1183 rtcp::Nack nack2;
1184 nack2.SetSenderSsrc(kSenderSsrc);
1185 nack2.SetMediaSsrc(kReceiverMainSsrc);
1186 nack2.SetPacketIds(kNackList23, kNackListLength2);
1187
1188 rtcp::Nack nack3;
1189 nack3.SetSenderSsrc(kSenderSsrc);
1190 nack3.SetMediaSsrc(kReceiverMainSsrc);
1191 nack3.SetPacketIds(kNackList23 + kNackListLength2, kNackListLength3);
1192
1193 rtcp::CompoundPacket two_nacks;
1194 two_nacks.Append(&nack2);
1195 two_nacks.Append(&nack3);
1196
1197 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedNack(ElementsAreArray(kNackList23)));
1198 EXPECT_CALL(packet_type_counter_observer_,
1199 RtcpPacketTypesCounterUpdated(
1200 kReceiverMainSsrc,
1201 AllOf(Field(&RtcpPacketTypeCounter::nack_requests,
1202 arraysize(kNackList1) + arraysize(kNackList23)),
1203 Field(&RtcpPacketTypeCounter::unique_nack_requests,
1204 nack_set.size()))));
1205 InjectRtcpPacket(two_nacks);
1206 }
1207
TEST_F(RtcpReceiverTest,NackNotForUsIgnored)1208 TEST_F(RtcpReceiverTest, NackNotForUsIgnored) {
1209 const uint16_t kNackList1[] = {1, 2, 3, 5};
1210 const size_t kNackListLength1 = std::end(kNackList1) - std::begin(kNackList1);
1211
1212 rtcp::Nack nack;
1213 nack.SetSenderSsrc(kSenderSsrc);
1214 nack.SetMediaSsrc(kNotToUsSsrc);
1215 nack.SetPacketIds(kNackList1, kNackListLength1);
1216
1217 EXPECT_CALL(packet_type_counter_observer_,
1218 RtcpPacketTypesCounterUpdated(
1219 _, Field(&RtcpPacketTypeCounter::nack_requests, 0)));
1220 InjectRtcpPacket(nack);
1221 }
1222
TEST_F(RtcpReceiverTest,ForceSenderReport)1223 TEST_F(RtcpReceiverTest, ForceSenderReport) {
1224 rtcp::RapidResyncRequest rr;
1225 rr.SetSenderSsrc(kSenderSsrc);
1226 rr.SetMediaSsrc(kReceiverMainSsrc);
1227
1228 EXPECT_CALL(rtp_rtcp_impl_, OnRequestSendReport());
1229 InjectRtcpPacket(rr);
1230 }
1231
TEST_F(RtcpReceiverTest,ReceivesTargetBitrate)1232 TEST_F(RtcpReceiverTest, ReceivesTargetBitrate) {
1233 BitrateAllocation expected_allocation;
1234 expected_allocation.SetBitrate(0, 0, 10000);
1235 expected_allocation.SetBitrate(0, 1, 20000);
1236 expected_allocation.SetBitrate(1, 0, 40000);
1237 expected_allocation.SetBitrate(1, 1, 80000);
1238
1239 rtcp::TargetBitrate bitrate;
1240 bitrate.AddTargetBitrate(0, 0, expected_allocation.GetBitrate(0, 0) / 1000);
1241 bitrate.AddTargetBitrate(0, 1, expected_allocation.GetBitrate(0, 1) / 1000);
1242 bitrate.AddTargetBitrate(1, 0, expected_allocation.GetBitrate(1, 0) / 1000);
1243 bitrate.AddTargetBitrate(1, 1, expected_allocation.GetBitrate(1, 1) / 1000);
1244
1245 rtcp::ExtendedReports xr;
1246 xr.SetTargetBitrate(bitrate);
1247
1248 // Wrong sender ssrc, target bitrate should be discarded.
1249 xr.SetSenderSsrc(kSenderSsrc + 1);
1250 EXPECT_CALL(bitrate_allocation_observer_,
1251 OnBitrateAllocationUpdated(expected_allocation))
1252 .Times(0);
1253 InjectRtcpPacket(xr);
1254
1255 // Set correct ssrc, callback should be called once.
1256 xr.SetSenderSsrc(kSenderSsrc);
1257 EXPECT_CALL(bitrate_allocation_observer_,
1258 OnBitrateAllocationUpdated(expected_allocation));
1259 InjectRtcpPacket(xr);
1260 }
1261
TEST_F(RtcpReceiverTest,HandlesIncorrectTargetBitrate)1262 TEST_F(RtcpReceiverTest, HandlesIncorrectTargetBitrate) {
1263 BitrateAllocation expected_allocation;
1264 expected_allocation.SetBitrate(0, 0, 10000);
1265
1266 rtcp::TargetBitrate bitrate;
1267 bitrate.AddTargetBitrate(0, 0, expected_allocation.GetBitrate(0, 0) / 1000);
1268 bitrate.AddTargetBitrate(0, kMaxTemporalStreams, 20000);
1269 bitrate.AddTargetBitrate(kMaxSpatialLayers, 0, 40000);
1270
1271 rtcp::ExtendedReports xr;
1272 xr.SetTargetBitrate(bitrate);
1273 xr.SetSenderSsrc(kSenderSsrc);
1274
1275 EXPECT_CALL(bitrate_allocation_observer_,
1276 OnBitrateAllocationUpdated(expected_allocation));
1277 InjectRtcpPacket(xr);
1278 }
1279
1280 } // namespace webrtc
1281