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 "modules/rtp_rtcp/source/rtcp_receiver.h"
12
13 #include <memory>
14 #include <set>
15 #include <utility>
16
17 #include "api/array_view.h"
18 #include "api/units/time_delta.h"
19 #include "api/units/timestamp.h"
20 #include "api/video/video_bitrate_allocation.h"
21 #include "api/video/video_bitrate_allocator.h"
22 #include "modules/rtp_rtcp/include/report_block_data.h"
23 #include "modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.h"
24 #include "modules/rtp_rtcp/source/byte_io.h"
25 #include "modules/rtp_rtcp/source/rtcp_packet.h"
26 #include "modules/rtp_rtcp/source/rtcp_packet/app.h"
27 #include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
28 #include "modules/rtp_rtcp/source/rtcp_packet/compound_packet.h"
29 #include "modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
30 #include "modules/rtp_rtcp/source/rtcp_packet/fir.h"
31 #include "modules/rtp_rtcp/source/rtcp_packet/nack.h"
32 #include "modules/rtp_rtcp/source/rtcp_packet/pli.h"
33 #include "modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h"
34 #include "modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
35 #include "modules/rtp_rtcp/source/rtcp_packet/remb.h"
36 #include "modules/rtp_rtcp/source/rtcp_packet/sdes.h"
37 #include "modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
38 #include "modules/rtp_rtcp/source/rtcp_packet/tmmbr.h"
39 #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
40 #include "modules/rtp_rtcp/source/time_util.h"
41 #include "rtc_base/arraysize.h"
42 #include "rtc_base/fake_clock.h"
43 #include "rtc_base/random.h"
44 #include "system_wrappers/include/ntp_time.h"
45 #include "test/gmock.h"
46 #include "test/gtest.h"
47
48 namespace webrtc {
49 namespace {
50
51 using rtcp::ReceiveTimeInfo;
52 using ::testing::_;
53 using ::testing::AllOf;
54 using ::testing::ElementsAreArray;
55 using ::testing::Eq;
56 using ::testing::Field;
57 using ::testing::InSequence;
58 using ::testing::IsEmpty;
59 using ::testing::NiceMock;
60 using ::testing::Property;
61 using ::testing::SizeIs;
62 using ::testing::StrEq;
63 using ::testing::StrictMock;
64 using ::testing::UnorderedElementsAre;
65
66 class MockRtcpPacketTypeCounterObserver : public RtcpPacketTypeCounterObserver {
67 public:
68 MOCK_METHOD(void,
69 RtcpPacketTypesCounterUpdated,
70 (uint32_t, const RtcpPacketTypeCounter&),
71 (override));
72 };
73
74 class MockRtcpIntraFrameObserver : public RtcpIntraFrameObserver {
75 public:
76 MOCK_METHOD(void, OnReceivedIntraFrameRequest, (uint32_t), (override));
77 };
78
79 class MockRtcpLossNotificationObserver : public RtcpLossNotificationObserver {
80 public:
81 ~MockRtcpLossNotificationObserver() override = default;
82 MOCK_METHOD(void,
83 OnReceivedLossNotification,
84 (uint32_t ssrc,
85 uint16_t seq_num_of_last_decodable,
86 uint16_t seq_num_of_last_received,
87 bool decodability_flag),
88 (override));
89 };
90
91 class MockCnameCallbackImpl : public RtcpCnameCallback {
92 public:
93 MOCK_METHOD(void, OnCname, (uint32_t, absl::string_view), (override));
94 };
95
96 class MockReportBlockDataObserverImpl : public ReportBlockDataObserver {
97 public:
98 MOCK_METHOD(void, OnReportBlockDataUpdated, (ReportBlockData), (override));
99 };
100
101 class MockTransportFeedbackObserver : public TransportFeedbackObserver {
102 public:
103 MOCK_METHOD(void, OnAddPacket, (const RtpPacketSendInfo&), (override));
104 MOCK_METHOD(void,
105 OnTransportFeedback,
106 (const rtcp::TransportFeedback&),
107 (override));
108 };
109
110 class MockModuleRtpRtcp : public RTCPReceiver::ModuleRtpRtcp {
111 public:
112 MOCK_METHOD(void, SetTmmbn, (std::vector<rtcp::TmmbItem>), (override));
113 MOCK_METHOD(void, OnRequestSendReport, (), (override));
114 MOCK_METHOD(void, OnReceivedNack, (const std::vector<uint16_t>&), (override));
115 MOCK_METHOD(void,
116 OnReceivedRtcpReportBlocks,
117 (const ReportBlockList&),
118 (override));
119 };
120
121 class MockVideoBitrateAllocationObserver
122 : public VideoBitrateAllocationObserver {
123 public:
124 MOCK_METHOD(void,
125 OnBitrateAllocationUpdated,
126 (const VideoBitrateAllocation& allocation),
127 (override));
128 };
129
130 // SSRC of remote peer, that sends rtcp packet to the rtcp receiver under test.
131 constexpr uint32_t kSenderSsrc = 0x10203;
132 // SSRCs of local peer, that rtcp packet addressed to.
133 constexpr uint32_t kReceiverMainSsrc = 0x123456;
134 // RtcpReceiver can accept several ssrc, e.g. regular and rtx streams.
135 constexpr uint32_t kReceiverExtraSsrc = 0x1234567;
136 // SSRCs to ignore (i.e. not configured in RtcpReceiver).
137 constexpr uint32_t kNotToUsSsrc = 0x654321;
138 constexpr uint32_t kUnknownSenderSsrc = 0x54321;
139
140 constexpr int64_t kRtcpIntervalMs = 1000;
141
142 } // namespace
143
144 struct ReceiverMocks {
ReceiverMockswebrtc::ReceiverMocks145 ReceiverMocks() : clock(1335900000) {}
146
147 SimulatedClock clock;
148 // Callbacks to packet_type_counter_observer are frequent but most of the time
149 // are not interesting.
150 NiceMock<MockRtcpPacketTypeCounterObserver> packet_type_counter_observer;
151 StrictMock<MockRtcpBandwidthObserver> bandwidth_observer;
152 StrictMock<MockRtcpIntraFrameObserver> intra_frame_observer;
153 StrictMock<MockRtcpLossNotificationObserver> rtcp_loss_notification_observer;
154 StrictMock<MockTransportFeedbackObserver> transport_feedback_observer;
155 StrictMock<MockVideoBitrateAllocationObserver> bitrate_allocation_observer;
156 StrictMock<MockModuleRtpRtcp> rtp_rtcp_impl;
157 };
158
DefaultConfiguration(ReceiverMocks * mocks)159 RtpRtcpInterface::Configuration DefaultConfiguration(ReceiverMocks* mocks) {
160 RtpRtcpInterface::Configuration config;
161 config.clock = &mocks->clock;
162 config.receiver_only = false;
163 config.rtcp_packet_type_counter_observer =
164 &mocks->packet_type_counter_observer;
165 config.bandwidth_callback = &mocks->bandwidth_observer;
166 config.intra_frame_callback = &mocks->intra_frame_observer;
167 config.rtcp_loss_notification_observer =
168 &mocks->rtcp_loss_notification_observer;
169 config.transport_feedback_callback = &mocks->transport_feedback_observer;
170 config.bitrate_allocation_observer = &mocks->bitrate_allocation_observer;
171 config.rtcp_report_interval_ms = kRtcpIntervalMs;
172 config.local_media_ssrc = kReceiverMainSsrc;
173 config.rtx_send_ssrc = kReceiverExtraSsrc;
174 return config;
175 }
176
TEST(RtcpReceiverTest,BrokenPacketIsIgnored)177 TEST(RtcpReceiverTest, BrokenPacketIsIgnored) {
178 ReceiverMocks mocks;
179 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
180
181 const uint8_t bad_packet[] = {0, 0, 0, 0};
182 EXPECT_CALL(mocks.packet_type_counter_observer, RtcpPacketTypesCounterUpdated)
183 .Times(0);
184 receiver.IncomingPacket(bad_packet);
185 }
186
TEST(RtcpReceiverTest,InvalidFeedbackPacketIsIgnored)187 TEST(RtcpReceiverTest, InvalidFeedbackPacketIsIgnored) {
188 ReceiverMocks mocks;
189 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
190
191 // Too short feedback packet.
192 const uint8_t bad_packet[] = {0x81, rtcp::Rtpfb::kPacketType, 0, 0};
193
194 // TODO(danilchap): Add expectation RtcpPacketTypesCounterUpdated
195 // is not called once parser would be adjusted to avoid that callback on
196 // semi-valid packets.
197 receiver.IncomingPacket(bad_packet);
198 }
199
TEST(RtcpReceiverTest,InjectSrPacket)200 TEST(RtcpReceiverTest, InjectSrPacket) {
201 ReceiverMocks mocks;
202 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
203 receiver.SetRemoteSSRC(kSenderSsrc);
204
205 EXPECT_FALSE(receiver.NTP(nullptr, nullptr, nullptr, nullptr, nullptr,
206 nullptr, nullptr, nullptr));
207
208 int64_t now = mocks.clock.TimeInMilliseconds();
209 rtcp::SenderReport sr;
210 sr.SetSenderSsrc(kSenderSsrc);
211
212 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(IsEmpty()));
213 EXPECT_CALL(mocks.bandwidth_observer,
214 OnReceivedRtcpReceiverReport(IsEmpty(), _, now));
215 receiver.IncomingPacket(sr.Build());
216
217 EXPECT_TRUE(receiver.NTP(nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
218 nullptr, nullptr));
219 }
220
TEST(RtcpReceiverTest,InjectSrPacketFromUnknownSender)221 TEST(RtcpReceiverTest, InjectSrPacketFromUnknownSender) {
222 ReceiverMocks mocks;
223 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
224 receiver.SetRemoteSSRC(kSenderSsrc);
225
226 int64_t now = mocks.clock.TimeInMilliseconds();
227 rtcp::SenderReport sr;
228 sr.SetSenderSsrc(kUnknownSenderSsrc);
229
230 // The parser will handle report blocks in Sender Report from other than their
231 // expected peer.
232 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
233 EXPECT_CALL(mocks.bandwidth_observer,
234 OnReceivedRtcpReceiverReport(_, _, now));
235 receiver.IncomingPacket(sr.Build());
236
237 // But will not flag that he's gotten sender information.
238 EXPECT_FALSE(receiver.NTP(nullptr, nullptr, nullptr, nullptr, nullptr,
239 nullptr, nullptr, nullptr));
240 }
241
TEST(RtcpReceiverTest,InjectSrPacketCalculatesRTT)242 TEST(RtcpReceiverTest, InjectSrPacketCalculatesRTT) {
243 ReceiverMocks mocks;
244 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
245 receiver.SetRemoteSSRC(kSenderSsrc);
246
247 const TimeDelta kRtt = TimeDelta::Millis(123);
248 const uint32_t kDelayNtp = 0x4321;
249 const TimeDelta kDelay = CompactNtpRttToTimeDelta(kDelayNtp);
250
251 int64_t rtt_ms = 0;
252 EXPECT_EQ(-1, receiver.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr));
253
254 uint32_t sent_ntp = CompactNtp(mocks.clock.CurrentNtpTime());
255 mocks.clock.AdvanceTime(kRtt + kDelay);
256
257 rtcp::SenderReport sr;
258 sr.SetSenderSsrc(kSenderSsrc);
259 rtcp::ReportBlock block;
260 block.SetMediaSsrc(kReceiverMainSsrc);
261 block.SetLastSr(sent_ntp);
262 block.SetDelayLastSr(kDelayNtp);
263 sr.AddReportBlock(block);
264
265 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
266 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport);
267 receiver.IncomingPacket(sr.Build());
268
269 EXPECT_EQ(0, receiver.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr));
270 EXPECT_NEAR(rtt_ms, kRtt.ms(), 1);
271 }
272
TEST(RtcpReceiverTest,InjectSrPacketCalculatesNegativeRTTAsOne)273 TEST(RtcpReceiverTest, InjectSrPacketCalculatesNegativeRTTAsOne) {
274 ReceiverMocks mocks;
275 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
276 receiver.SetRemoteSSRC(kSenderSsrc);
277
278 const TimeDelta kRtt = TimeDelta::Millis(-13);
279 const uint32_t kDelayNtp = 0x4321;
280 const TimeDelta kDelay = CompactNtpRttToTimeDelta(kDelayNtp);
281
282 int64_t rtt_ms = 0;
283 EXPECT_EQ(-1, receiver.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr));
284
285 uint32_t sent_ntp = CompactNtp(mocks.clock.CurrentNtpTime());
286 mocks.clock.AdvanceTime(kRtt + kDelay);
287
288 rtcp::SenderReport sr;
289 sr.SetSenderSsrc(kSenderSsrc);
290 rtcp::ReportBlock block;
291 block.SetMediaSsrc(kReceiverMainSsrc);
292 block.SetLastSr(sent_ntp);
293 block.SetDelayLastSr(kDelayNtp);
294 sr.AddReportBlock(block);
295
296 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(SizeIs(1)));
297 EXPECT_CALL(mocks.bandwidth_observer,
298 OnReceivedRtcpReceiverReport(SizeIs(1), _, _));
299 receiver.IncomingPacket(sr.Build());
300
301 EXPECT_EQ(0, receiver.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr));
302 EXPECT_EQ(1, rtt_ms);
303 }
304
TEST(RtcpReceiverTest,TwoReportBlocksWithLastOneWithoutLastSrCalculatesRttForBandwidthObserver)305 TEST(RtcpReceiverTest,
306 TwoReportBlocksWithLastOneWithoutLastSrCalculatesRttForBandwidthObserver) {
307 ReceiverMocks mocks;
308 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
309 receiver.SetRemoteSSRC(kSenderSsrc);
310
311 const TimeDelta kRtt = TimeDelta::Millis(120);
312 const uint32_t kDelayNtp = 123000;
313 const TimeDelta kDelay = CompactNtpRttToTimeDelta(kDelayNtp);
314
315 uint32_t sent_ntp = CompactNtp(mocks.clock.CurrentNtpTime());
316 mocks.clock.AdvanceTime(kRtt + kDelay);
317
318 rtcp::SenderReport sr;
319 sr.SetSenderSsrc(kSenderSsrc);
320 rtcp::ReportBlock block;
321 block.SetMediaSsrc(kReceiverMainSsrc);
322 block.SetLastSr(sent_ntp);
323 block.SetDelayLastSr(kDelayNtp);
324 sr.AddReportBlock(block);
325 block.SetMediaSsrc(kReceiverExtraSsrc);
326 block.SetLastSr(0);
327 sr.AddReportBlock(block);
328
329 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(SizeIs(2)));
330 EXPECT_CALL(mocks.bandwidth_observer,
331 OnReceivedRtcpReceiverReport(SizeIs(2), kRtt.ms(), _));
332 receiver.IncomingPacket(sr.Build());
333 }
334
TEST(RtcpReceiverTest,InjectRrPacket)335 TEST(RtcpReceiverTest, InjectRrPacket) {
336 ReceiverMocks mocks;
337 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
338 receiver.SetRemoteSSRC(kSenderSsrc);
339
340 int64_t now = mocks.clock.TimeInMilliseconds();
341 rtcp::ReceiverReport rr;
342 rr.SetSenderSsrc(kSenderSsrc);
343
344 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(IsEmpty()));
345 EXPECT_CALL(mocks.bandwidth_observer,
346 OnReceivedRtcpReceiverReport(IsEmpty(), _, now));
347 receiver.IncomingPacket(rr.Build());
348
349 EXPECT_THAT(receiver.GetLatestReportBlockData(), IsEmpty());
350 }
351
TEST(RtcpReceiverTest,InjectRrPacketWithReportBlockNotToUsIgnored)352 TEST(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) {
353 ReceiverMocks mocks;
354 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
355 receiver.SetRemoteSSRC(kSenderSsrc);
356
357 int64_t now = mocks.clock.TimeInMilliseconds();
358 rtcp::ReportBlock rb;
359 rb.SetMediaSsrc(kNotToUsSsrc);
360 rtcp::ReceiverReport rr;
361 rr.SetSenderSsrc(kSenderSsrc);
362 rr.AddReportBlock(rb);
363
364 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(IsEmpty()));
365 EXPECT_CALL(mocks.bandwidth_observer,
366 OnReceivedRtcpReceiverReport(IsEmpty(), _, now));
367 receiver.IncomingPacket(rr.Build());
368
369 EXPECT_EQ(0, receiver.LastReceivedReportBlockMs());
370 EXPECT_THAT(receiver.GetLatestReportBlockData(), IsEmpty());
371 }
372
TEST(RtcpReceiverTest,InjectRrPacketWithOneReportBlock)373 TEST(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) {
374 ReceiverMocks mocks;
375 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
376 receiver.SetRemoteSSRC(kSenderSsrc);
377
378 int64_t now = mocks.clock.TimeInMilliseconds();
379
380 rtcp::ReportBlock rb;
381 rb.SetMediaSsrc(kReceiverMainSsrc);
382 rtcp::ReceiverReport rr;
383 rr.SetSenderSsrc(kSenderSsrc);
384 rr.AddReportBlock(rb);
385
386 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(SizeIs(1)));
387 EXPECT_CALL(mocks.bandwidth_observer,
388 OnReceivedRtcpReceiverReport(SizeIs(1), _, now));
389 receiver.IncomingPacket(rr.Build());
390
391 EXPECT_EQ(now, receiver.LastReceivedReportBlockMs());
392 EXPECT_THAT(receiver.GetLatestReportBlockData(), SizeIs(1));
393 }
394
TEST(RtcpReceiverTest,InjectSrPacketWithOneReportBlock)395 TEST(RtcpReceiverTest, InjectSrPacketWithOneReportBlock) {
396 ReceiverMocks mocks;
397 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
398 receiver.SetRemoteSSRC(kSenderSsrc);
399
400 int64_t now = mocks.clock.TimeInMilliseconds();
401
402 rtcp::ReportBlock rb;
403 rb.SetMediaSsrc(kReceiverMainSsrc);
404 rtcp::SenderReport sr;
405 sr.SetSenderSsrc(kSenderSsrc);
406 sr.AddReportBlock(rb);
407
408 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(SizeIs(1)));
409 EXPECT_CALL(mocks.bandwidth_observer,
410 OnReceivedRtcpReceiverReport(SizeIs(1), _, now));
411 receiver.IncomingPacket(sr.Build());
412
413 EXPECT_EQ(now, receiver.LastReceivedReportBlockMs());
414 EXPECT_THAT(receiver.GetLatestReportBlockData(), SizeIs(1));
415 }
416
TEST(RtcpReceiverTest,InjectRrPacketWithTwoReportBlocks)417 TEST(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) {
418 const uint16_t kSequenceNumbers[] = {10, 12423};
419 const uint32_t kCumLost[] = {13, 555};
420 const uint8_t kFracLost[] = {20, 11};
421 ReceiverMocks mocks;
422 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
423 receiver.SetRemoteSSRC(kSenderSsrc);
424
425 int64_t now = mocks.clock.TimeInMilliseconds();
426
427 rtcp::ReportBlock rb1;
428 rb1.SetMediaSsrc(kReceiverMainSsrc);
429 rb1.SetExtHighestSeqNum(kSequenceNumbers[0]);
430 rb1.SetFractionLost(10);
431
432 rtcp::ReportBlock rb2;
433 rb2.SetMediaSsrc(kReceiverExtraSsrc);
434 rb2.SetExtHighestSeqNum(kSequenceNumbers[1]);
435 rb2.SetFractionLost(0);
436
437 rtcp::ReceiverReport rr1;
438 rr1.SetSenderSsrc(kSenderSsrc);
439 rr1.AddReportBlock(rb1);
440 rr1.AddReportBlock(rb2);
441
442 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(SizeIs(2)));
443 EXPECT_CALL(mocks.bandwidth_observer,
444 OnReceivedRtcpReceiverReport(SizeIs(2), _, now));
445 receiver.IncomingPacket(rr1.Build());
446
447 EXPECT_EQ(now, receiver.LastReceivedReportBlockMs());
448 EXPECT_THAT(receiver.GetLatestReportBlockData(),
449 UnorderedElementsAre(
450 Property(&ReportBlockData::report_block,
451 Field(&RTCPReportBlock::fraction_lost, 0)),
452 Property(&ReportBlockData::report_block,
453 Field(&RTCPReportBlock::fraction_lost, 10))));
454
455 // Insert next receiver report with same ssrc but new values.
456 rtcp::ReportBlock rb3;
457 rb3.SetMediaSsrc(kReceiverMainSsrc);
458 rb3.SetExtHighestSeqNum(kSequenceNumbers[0]);
459 rb3.SetFractionLost(kFracLost[0]);
460 rb3.SetCumulativeLost(kCumLost[0]);
461
462 rtcp::ReportBlock rb4;
463 rb4.SetMediaSsrc(kReceiverExtraSsrc);
464 rb4.SetExtHighestSeqNum(kSequenceNumbers[1]);
465 rb4.SetFractionLost(kFracLost[1]);
466 rb4.SetCumulativeLost(kCumLost[1]);
467
468 rtcp::ReceiverReport rr2;
469 rr2.SetSenderSsrc(kSenderSsrc);
470 rr2.AddReportBlock(rb3);
471 rr2.AddReportBlock(rb4);
472
473 // Advance time to make 1st sent time and 2nd sent time different.
474 mocks.clock.AdvanceTimeMilliseconds(500);
475 now = mocks.clock.TimeInMilliseconds();
476
477 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(SizeIs(2)));
478 EXPECT_CALL(mocks.bandwidth_observer,
479 OnReceivedRtcpReceiverReport(SizeIs(2), _, now));
480 receiver.IncomingPacket(rr2.Build());
481
482 EXPECT_THAT(
483 receiver.GetLatestReportBlockData(),
484 UnorderedElementsAre(
485 Property(
486 &ReportBlockData::report_block,
487 AllOf(Field(&RTCPReportBlock::source_ssrc, kReceiverMainSsrc),
488 Field(&RTCPReportBlock::fraction_lost, kFracLost[0]),
489 Field(&RTCPReportBlock::packets_lost, kCumLost[0]),
490 Field(&RTCPReportBlock::extended_highest_sequence_number,
491 kSequenceNumbers[0]))),
492 Property(
493 &ReportBlockData::report_block,
494 AllOf(Field(&RTCPReportBlock::source_ssrc, kReceiverExtraSsrc),
495 Field(&RTCPReportBlock::fraction_lost, kFracLost[1]),
496 Field(&RTCPReportBlock::packets_lost, kCumLost[1]),
497 Field(&RTCPReportBlock::extended_highest_sequence_number,
498 kSequenceNumbers[1])))));
499 }
500
TEST(RtcpReceiverTest,InjectRrPacketsFromTwoRemoteSsrcsReturnsLatestReportBlock)501 TEST(RtcpReceiverTest,
502 InjectRrPacketsFromTwoRemoteSsrcsReturnsLatestReportBlock) {
503 const uint32_t kSenderSsrc2 = 0x20304;
504 const uint16_t kSequenceNumbers[] = {10, 12423};
505 const int32_t kCumLost[] = {13, 555};
506 const uint8_t kFracLost[] = {20, 11};
507 ReceiverMocks mocks;
508 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
509 receiver.SetRemoteSSRC(kSenderSsrc);
510
511 rtcp::ReportBlock rb1;
512 rb1.SetMediaSsrc(kReceiverMainSsrc);
513 rb1.SetExtHighestSeqNum(kSequenceNumbers[0]);
514 rb1.SetFractionLost(kFracLost[0]);
515 rb1.SetCumulativeLost(kCumLost[0]);
516 rtcp::ReceiverReport rr1;
517 rr1.SetSenderSsrc(kSenderSsrc);
518 rr1.AddReportBlock(rb1);
519
520 int64_t now = mocks.clock.TimeInMilliseconds();
521
522 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(SizeIs(1)));
523 EXPECT_CALL(mocks.bandwidth_observer,
524 OnReceivedRtcpReceiverReport(SizeIs(1), _, now));
525 receiver.IncomingPacket(rr1.Build());
526
527 EXPECT_EQ(now, receiver.LastReceivedReportBlockMs());
528
529 EXPECT_THAT(
530 receiver.GetLatestReportBlockData(),
531 ElementsAre(Property(
532 &ReportBlockData::report_block,
533 AllOf(Field(&RTCPReportBlock::source_ssrc, kReceiverMainSsrc),
534 Field(&RTCPReportBlock::sender_ssrc, kSenderSsrc),
535 Field(&RTCPReportBlock::fraction_lost, kFracLost[0]),
536 Field(&RTCPReportBlock::packets_lost, kCumLost[0]),
537 Field(&RTCPReportBlock::extended_highest_sequence_number,
538 kSequenceNumbers[0])))));
539
540 rtcp::ReportBlock rb2;
541 rb2.SetMediaSsrc(kReceiverMainSsrc);
542 rb2.SetExtHighestSeqNum(kSequenceNumbers[1]);
543 rb2.SetFractionLost(kFracLost[1]);
544 rb2.SetCumulativeLost(kCumLost[1]);
545 rtcp::ReceiverReport rr2;
546 rr2.SetSenderSsrc(kSenderSsrc2);
547 rr2.AddReportBlock(rb2);
548
549 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(SizeIs(1)));
550 EXPECT_CALL(mocks.bandwidth_observer,
551 OnReceivedRtcpReceiverReport(SizeIs(1), _, now));
552 receiver.IncomingPacket(rr2.Build());
553
554 EXPECT_THAT(
555 receiver.GetLatestReportBlockData(),
556 UnorderedElementsAre(
557 Property(
558 &ReportBlockData::report_block,
559 AllOf(Field(&RTCPReportBlock::source_ssrc, kReceiverMainSsrc),
560 Field(&RTCPReportBlock::sender_ssrc, kSenderSsrc2),
561 Field(&RTCPReportBlock::fraction_lost, kFracLost[1]),
562 Field(&RTCPReportBlock::packets_lost, kCumLost[1]),
563 Field(&RTCPReportBlock::extended_highest_sequence_number,
564 kSequenceNumbers[1])))));
565 }
566
TEST(RtcpReceiverTest,GetRtt)567 TEST(RtcpReceiverTest, GetRtt) {
568 const uint32_t kSentCompactNtp = 0x1234;
569 const uint32_t kDelayCompactNtp = 0x222;
570 ReceiverMocks mocks;
571 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
572 receiver.SetRemoteSSRC(kSenderSsrc);
573
574 // No report block received.
575 EXPECT_EQ(-1, receiver.RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr));
576
577 rtcp::ReportBlock rb;
578 rb.SetMediaSsrc(kReceiverMainSsrc);
579 rb.SetLastSr(kSentCompactNtp);
580 rb.SetDelayLastSr(kDelayCompactNtp);
581
582 rtcp::ReceiverReport rr;
583 rr.SetSenderSsrc(kSenderSsrc);
584 rr.AddReportBlock(rb);
585 int64_t now = mocks.clock.TimeInMilliseconds();
586
587 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
588 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport);
589 receiver.IncomingPacket(rr.Build());
590
591 EXPECT_EQ(now, receiver.LastReceivedReportBlockMs());
592 EXPECT_EQ(0, receiver.RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr));
593 }
594
595 // App packets are ignored.
TEST(RtcpReceiverTest,InjectApp)596 TEST(RtcpReceiverTest, InjectApp) {
597 ReceiverMocks mocks;
598 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
599 receiver.SetRemoteSSRC(kSenderSsrc);
600
601 rtcp::App app;
602 app.SetSubType(30);
603 app.SetName(0x17a177e);
604 const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'};
605 app.SetData(kData, sizeof(kData));
606
607 receiver.IncomingPacket(app.Build());
608 }
609
TEST(RtcpReceiverTest,InjectSdesWithOneChunk)610 TEST(RtcpReceiverTest, InjectSdesWithOneChunk) {
611 ReceiverMocks mocks;
612 MockCnameCallbackImpl callback;
613 RtpRtcpInterface::Configuration config = DefaultConfiguration(&mocks);
614 config.rtcp_cname_callback = &callback;
615 RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
616 receiver.SetRemoteSSRC(kSenderSsrc);
617
618 const char kCname[] = "alice@host";
619 rtcp::Sdes sdes;
620 sdes.AddCName(kSenderSsrc, kCname);
621
622 EXPECT_CALL(callback, OnCname(kSenderSsrc, StrEq(kCname)));
623 receiver.IncomingPacket(sdes.Build());
624 }
625
TEST(RtcpReceiverTest,InjectByePacket_RemovesReportBlocks)626 TEST(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) {
627 ReceiverMocks mocks;
628 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
629 receiver.SetRemoteSSRC(kSenderSsrc);
630
631 rtcp::ReportBlock rb1;
632 rb1.SetMediaSsrc(kReceiverMainSsrc);
633 rtcp::ReportBlock rb2;
634 rb2.SetMediaSsrc(kReceiverExtraSsrc);
635 rtcp::ReceiverReport rr;
636 rr.SetSenderSsrc(kSenderSsrc);
637 rr.AddReportBlock(rb1);
638 rr.AddReportBlock(rb2);
639
640 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
641 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport);
642 receiver.IncomingPacket(rr.Build());
643
644 EXPECT_THAT(receiver.GetLatestReportBlockData(), SizeIs(2));
645
646 // Verify that BYE removes the report blocks.
647 rtcp::Bye bye;
648 bye.SetSenderSsrc(kSenderSsrc);
649
650 receiver.IncomingPacket(bye.Build());
651
652 EXPECT_THAT(receiver.GetLatestReportBlockData(), IsEmpty());
653
654 // Inject packet again.
655 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
656 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport);
657 receiver.IncomingPacket(rr.Build());
658
659 EXPECT_THAT(receiver.GetLatestReportBlockData(), SizeIs(2));
660 }
661
TEST(RtcpReceiverTest,InjectByePacketRemovesReferenceTimeInfo)662 TEST(RtcpReceiverTest, InjectByePacketRemovesReferenceTimeInfo) {
663 ReceiverMocks mocks;
664 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
665 receiver.SetRemoteSSRC(kSenderSsrc);
666
667 rtcp::ExtendedReports xr;
668 xr.SetSenderSsrc(kSenderSsrc);
669 rtcp::Rrtr rrtr;
670 rrtr.SetNtp(NtpTime(0x10203, 0x40506));
671 xr.SetRrtr(rrtr);
672 receiver.IncomingPacket(xr.Build());
673
674 rtcp::Bye bye;
675 bye.SetSenderSsrc(kSenderSsrc);
676 receiver.IncomingPacket(bye.Build());
677
678 EXPECT_THAT(receiver.ConsumeReceivedXrReferenceTimeInfo(), IsEmpty());
679 }
680
TEST(RtcpReceiverTest,InjectPliPacket)681 TEST(RtcpReceiverTest, InjectPliPacket) {
682 ReceiverMocks mocks;
683 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
684 receiver.SetRemoteSSRC(kSenderSsrc);
685
686 rtcp::Pli pli;
687 pli.SetMediaSsrc(kReceiverMainSsrc);
688
689 EXPECT_CALL(
690 mocks.packet_type_counter_observer,
691 RtcpPacketTypesCounterUpdated(
692 kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::pli_packets, 1)));
693 EXPECT_CALL(mocks.intra_frame_observer,
694 OnReceivedIntraFrameRequest(kReceiverMainSsrc));
695 receiver.IncomingPacket(pli.Build());
696 }
697
TEST(RtcpReceiverTest,PliPacketNotToUsIgnored)698 TEST(RtcpReceiverTest, PliPacketNotToUsIgnored) {
699 ReceiverMocks mocks;
700 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
701 receiver.SetRemoteSSRC(kSenderSsrc);
702
703 rtcp::Pli pli;
704 pli.SetMediaSsrc(kNotToUsSsrc);
705
706 EXPECT_CALL(
707 mocks.packet_type_counter_observer,
708 RtcpPacketTypesCounterUpdated(
709 kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::pli_packets, 0)));
710 EXPECT_CALL(mocks.intra_frame_observer, OnReceivedIntraFrameRequest).Times(0);
711 receiver.IncomingPacket(pli.Build());
712 }
713
TEST(RtcpReceiverTest,InjectFirPacket)714 TEST(RtcpReceiverTest, InjectFirPacket) {
715 ReceiverMocks mocks;
716 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
717 receiver.SetRemoteSSRC(kSenderSsrc);
718
719 rtcp::Fir fir;
720 fir.AddRequestTo(kReceiverMainSsrc, 13);
721
722 EXPECT_CALL(
723 mocks.packet_type_counter_observer,
724 RtcpPacketTypesCounterUpdated(
725 kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::fir_packets, 1)));
726 EXPECT_CALL(mocks.intra_frame_observer,
727 OnReceivedIntraFrameRequest(kReceiverMainSsrc));
728 receiver.IncomingPacket(fir.Build());
729 }
730
TEST(RtcpReceiverTest,FirPacketNotToUsIgnored)731 TEST(RtcpReceiverTest, FirPacketNotToUsIgnored) {
732 ReceiverMocks mocks;
733 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
734 receiver.SetRemoteSSRC(kSenderSsrc);
735
736 rtcp::Fir fir;
737 fir.AddRequestTo(kNotToUsSsrc, 13);
738
739 EXPECT_CALL(mocks.intra_frame_observer, OnReceivedIntraFrameRequest).Times(0);
740 receiver.IncomingPacket(fir.Build());
741 }
742
TEST(RtcpReceiverTest,ExtendedReportsPacketWithZeroReportBlocksIgnored)743 TEST(RtcpReceiverTest, ExtendedReportsPacketWithZeroReportBlocksIgnored) {
744 ReceiverMocks mocks;
745 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
746 receiver.SetRemoteSSRC(kSenderSsrc);
747
748 rtcp::ExtendedReports xr;
749 xr.SetSenderSsrc(kSenderSsrc);
750
751 receiver.IncomingPacket(xr.Build());
752 }
753
TEST(RtcpReceiverTest,InjectExtendedReportsReceiverReferenceTimePacket)754 TEST(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) {
755 ReceiverMocks mocks;
756 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
757 receiver.SetRemoteSSRC(kSenderSsrc);
758
759 const NtpTime kNtp(0x10203, 0x40506);
760 rtcp::Rrtr rrtr;
761 rrtr.SetNtp(kNtp);
762 rtcp::ExtendedReports xr;
763 xr.SetSenderSsrc(kSenderSsrc);
764 xr.SetRrtr(rrtr);
765
766 std::vector<rtcp::ReceiveTimeInfo> last_xr_rtis =
767 receiver.ConsumeReceivedXrReferenceTimeInfo();
768 EXPECT_THAT(last_xr_rtis, IsEmpty());
769
770 receiver.IncomingPacket(xr.Build());
771
772 last_xr_rtis = receiver.ConsumeReceivedXrReferenceTimeInfo();
773 ASSERT_THAT(last_xr_rtis, SizeIs(1));
774 EXPECT_EQ(kSenderSsrc, last_xr_rtis[0].ssrc);
775 EXPECT_EQ(CompactNtp(kNtp), last_xr_rtis[0].last_rr);
776 EXPECT_EQ(0U, last_xr_rtis[0].delay_since_last_rr);
777 }
778
TEST(RtcpReceiverTest,ExtendedReportsDlrrPacketNotToUsIgnored)779 TEST(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) {
780 ReceiverMocks mocks;
781 auto config = DefaultConfiguration(&mocks);
782 // Allow calculate rtt using dlrr/rrtr, simulating media receiver side.
783 config.non_sender_rtt_measurement = true;
784 RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
785 receiver.SetRemoteSSRC(kSenderSsrc);
786
787 rtcp::ExtendedReports xr;
788 xr.SetSenderSsrc(kSenderSsrc);
789 xr.AddDlrrItem(ReceiveTimeInfo(kNotToUsSsrc, 0x12345, 0x67890));
790
791 receiver.IncomingPacket(xr.Build());
792
793 int64_t rtt_ms = 0;
794 EXPECT_FALSE(receiver.GetAndResetXrRrRtt(&rtt_ms));
795 RTCPReceiver::NonSenderRttStats non_sender_rtt_stats =
796 receiver.GetNonSenderRTT();
797 EXPECT_FALSE(non_sender_rtt_stats.round_trip_time().has_value());
798 EXPECT_TRUE(non_sender_rtt_stats.total_round_trip_time().IsZero());
799 EXPECT_EQ(non_sender_rtt_stats.round_trip_time_measurements(), 0);
800 }
801
TEST(RtcpReceiverTest,InjectExtendedReportsDlrrPacketWithSubBlock)802 TEST(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) {
803 ReceiverMocks mocks;
804 auto config = DefaultConfiguration(&mocks);
805 config.non_sender_rtt_measurement = true;
806 RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
807 receiver.SetRemoteSSRC(kSenderSsrc);
808
809 const uint32_t kLastRR = 0x12345;
810 const uint32_t kDelay = 0x23456;
811 int64_t rtt_ms = 0;
812 EXPECT_FALSE(receiver.GetAndResetXrRrRtt(&rtt_ms));
813
814 rtcp::ExtendedReports xr;
815 xr.SetSenderSsrc(kSenderSsrc);
816 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, kLastRR, kDelay));
817
818 receiver.IncomingPacket(xr.Build());
819
820 uint32_t compact_ntp_now = CompactNtp(mocks.clock.CurrentNtpTime());
821 EXPECT_TRUE(receiver.GetAndResetXrRrRtt(&rtt_ms));
822 uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR;
823 EXPECT_NEAR(CompactNtpRttToTimeDelta(rtt_ntp).ms(), rtt_ms, 1);
824 RTCPReceiver::NonSenderRttStats non_sender_rtt_stats =
825 receiver.GetNonSenderRTT();
826 EXPECT_GT(non_sender_rtt_stats.round_trip_time(), TimeDelta::Zero());
827 EXPECT_FALSE(non_sender_rtt_stats.total_round_trip_time().IsZero());
828 EXPECT_GT(non_sender_rtt_stats.round_trip_time_measurements(), 0);
829 }
830
TEST(RtcpReceiverTest,InjectExtendedReportsDlrrPacketWithMultipleSubBlocks)831 TEST(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) {
832 ReceiverMocks mocks;
833 auto config = DefaultConfiguration(&mocks);
834 config.non_sender_rtt_measurement = true;
835 RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
836 receiver.SetRemoteSSRC(kSenderSsrc);
837
838 const uint32_t kLastRR = 0x12345;
839 const uint32_t kDelay = 0x56789;
840
841 rtcp::ExtendedReports xr;
842 xr.SetSenderSsrc(kSenderSsrc);
843 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, kLastRR, kDelay));
844 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc + 1, 0x12345, 0x67890));
845 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc + 2, 0x12345, 0x67890));
846
847 receiver.IncomingPacket(xr.Build());
848
849 uint32_t compact_ntp_now = CompactNtp(mocks.clock.CurrentNtpTime());
850 int64_t rtt_ms = 0;
851 EXPECT_TRUE(receiver.GetAndResetXrRrRtt(&rtt_ms));
852 uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR;
853 EXPECT_NEAR(CompactNtpRttToTimeDelta(rtt_ntp).ms(), rtt_ms, 1);
854 RTCPReceiver::NonSenderRttStats non_sender_rtt_stats =
855 receiver.GetNonSenderRTT();
856 EXPECT_GT(non_sender_rtt_stats.round_trip_time(), TimeDelta::Zero());
857 EXPECT_FALSE(non_sender_rtt_stats.total_round_trip_time().IsZero());
858 EXPECT_GT(non_sender_rtt_stats.round_trip_time_measurements(), 0);
859 }
860
TEST(RtcpReceiverTest,InjectExtendedReportsPacketWithMultipleReportBlocks)861 TEST(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) {
862 ReceiverMocks mocks;
863 auto config = DefaultConfiguration(&mocks);
864 config.non_sender_rtt_measurement = true;
865 RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
866 receiver.SetRemoteSSRC(kSenderSsrc);
867
868 rtcp::Rrtr rrtr;
869 rtcp::ExtendedReports xr;
870 xr.SetSenderSsrc(kSenderSsrc);
871 xr.SetRrtr(rrtr);
872 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, 0x12345, 0x67890));
873
874 receiver.IncomingPacket(xr.Build());
875
876 std::vector<rtcp::ReceiveTimeInfo> last_xr_rtis =
877 receiver.ConsumeReceivedXrReferenceTimeInfo();
878 EXPECT_THAT(last_xr_rtis, SizeIs(1));
879 int64_t rtt_ms = 0;
880 EXPECT_TRUE(receiver.GetAndResetXrRrRtt(&rtt_ms));
881 }
882
TEST(RtcpReceiverTest,InjectExtendedReportsPacketWithUnknownReportBlock)883 TEST(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) {
884 ReceiverMocks mocks;
885 auto config = DefaultConfiguration(&mocks);
886 config.non_sender_rtt_measurement = true;
887 RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
888 receiver.SetRemoteSSRC(kSenderSsrc);
889
890 rtcp::Rrtr rrtr;
891 rtcp::ExtendedReports xr;
892 xr.SetSenderSsrc(kSenderSsrc);
893 xr.SetRrtr(rrtr);
894 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, 0x12345, 0x67890));
895
896 rtc::Buffer packet = xr.Build();
897 // Modify the DLRR block to have an unsupported block type, from 5 to 6.
898 ASSERT_EQ(5, packet.data()[20]);
899 packet.data()[20] = 6;
900 receiver.IncomingPacket(packet);
901
902 // Validate Rrtr was received and processed.
903 std::vector<rtcp::ReceiveTimeInfo> last_xr_rtis =
904 receiver.ConsumeReceivedXrReferenceTimeInfo();
905 EXPECT_THAT(last_xr_rtis, SizeIs(1));
906 // Validate Dlrr report wasn't processed.
907 int64_t rtt_ms = 0;
908 EXPECT_FALSE(receiver.GetAndResetXrRrRtt(&rtt_ms));
909 RTCPReceiver::NonSenderRttStats non_sender_rtt_stats =
910 receiver.GetNonSenderRTT();
911 EXPECT_FALSE(non_sender_rtt_stats.round_trip_time().has_value());
912 EXPECT_TRUE(non_sender_rtt_stats.total_round_trip_time().IsZero());
913 EXPECT_EQ(non_sender_rtt_stats.round_trip_time_measurements(), 0);
914 }
915
TEST(RtcpReceiverTest,TestExtendedReportsRrRttInitiallyFalse)916 TEST(RtcpReceiverTest, TestExtendedReportsRrRttInitiallyFalse) {
917 ReceiverMocks mocks;
918 auto config = DefaultConfiguration(&mocks);
919 config.non_sender_rtt_measurement = true;
920 RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
921 receiver.SetRemoteSSRC(kSenderSsrc);
922
923 int64_t rtt_ms;
924 EXPECT_FALSE(receiver.GetAndResetXrRrRtt(&rtt_ms));
925 RTCPReceiver::NonSenderRttStats non_sender_rtt_stats =
926 receiver.GetNonSenderRTT();
927 EXPECT_FALSE(non_sender_rtt_stats.round_trip_time().has_value());
928 EXPECT_TRUE(non_sender_rtt_stats.total_round_trip_time().IsZero());
929 EXPECT_EQ(non_sender_rtt_stats.round_trip_time_measurements(), 0);
930 }
931
TEST(RtcpReceiverTest,RttCalculatedAfterExtendedReportsDlrr)932 TEST(RtcpReceiverTest, RttCalculatedAfterExtendedReportsDlrr) {
933 ReceiverMocks mocks;
934 auto config = DefaultConfiguration(&mocks);
935 config.non_sender_rtt_measurement = true;
936 RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
937 receiver.SetRemoteSSRC(kSenderSsrc);
938
939 Random rand(0x0123456789abcdef);
940 const TimeDelta kRtt = TimeDelta::Millis(rand.Rand(1, 9 * 3600 * 1000));
941 const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff);
942 const TimeDelta kDelay = CompactNtpRttToTimeDelta(kDelayNtp);
943 NtpTime now = mocks.clock.CurrentNtpTime();
944 uint32_t sent_ntp = CompactNtp(now);
945 mocks.clock.AdvanceTime(kRtt + kDelay);
946
947 rtcp::ExtendedReports xr;
948 xr.SetSenderSsrc(kSenderSsrc);
949 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, sent_ntp, kDelayNtp));
950
951 receiver.IncomingPacket(xr.Build());
952
953 int64_t rtt_ms = 0;
954 EXPECT_TRUE(receiver.GetAndResetXrRrRtt(&rtt_ms));
955 EXPECT_NEAR(kRtt.ms(), rtt_ms, 1);
956 RTCPReceiver::NonSenderRttStats non_sender_rtt_stats =
957 receiver.GetNonSenderRTT();
958 EXPECT_TRUE(non_sender_rtt_stats.round_trip_time().has_value());
959 EXPECT_FALSE(non_sender_rtt_stats.round_trip_time().value().IsZero());
960 EXPECT_FALSE(non_sender_rtt_stats.total_round_trip_time().IsZero());
961 EXPECT_GT(non_sender_rtt_stats.round_trip_time_measurements(), 0);
962 }
963
964 // Same test as above but enables receive-side RTT using the setter instead of
965 // the config struct.
TEST(RtcpReceiverTest,SetterEnablesReceiverRtt)966 TEST(RtcpReceiverTest, SetterEnablesReceiverRtt) {
967 ReceiverMocks mocks;
968 auto config = DefaultConfiguration(&mocks);
969 config.non_sender_rtt_measurement = false;
970 RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
971 receiver.SetRemoteSSRC(kSenderSsrc);
972 receiver.SetNonSenderRttMeasurement(true);
973
974 Random rand(0x0123456789abcdef);
975 const TimeDelta kRtt = TimeDelta::Millis(rand.Rand(1, 9 * 3600 * 1000));
976 const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff);
977 const TimeDelta kDelay = CompactNtpRttToTimeDelta(kDelayNtp);
978 NtpTime now = mocks.clock.CurrentNtpTime();
979 uint32_t sent_ntp = CompactNtp(now);
980 mocks.clock.AdvanceTime(kRtt + kDelay);
981
982 rtcp::ExtendedReports xr;
983 xr.SetSenderSsrc(kSenderSsrc);
984 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, sent_ntp, kDelayNtp));
985
986 receiver.IncomingPacket(xr.Build());
987
988 int64_t rtt_ms = 0;
989 EXPECT_TRUE(receiver.GetAndResetXrRrRtt(&rtt_ms));
990 EXPECT_NEAR(rtt_ms, kRtt.ms(), 1);
991 RTCPReceiver::NonSenderRttStats non_sender_rtt_stats =
992 receiver.GetNonSenderRTT();
993 EXPECT_TRUE(non_sender_rtt_stats.round_trip_time().has_value());
994 EXPECT_FALSE(non_sender_rtt_stats.round_trip_time().value().IsZero());
995 EXPECT_FALSE(non_sender_rtt_stats.total_round_trip_time().IsZero());
996 EXPECT_GT(non_sender_rtt_stats.round_trip_time_measurements(), 0);
997 }
998
999 // Same test as above but disables receive-side RTT using the setter instead of
1000 // the config struct.
TEST(RtcpReceiverTest,DoesntCalculateRttOnReceivedDlrr)1001 TEST(RtcpReceiverTest, DoesntCalculateRttOnReceivedDlrr) {
1002 ReceiverMocks mocks;
1003 auto config = DefaultConfiguration(&mocks);
1004 config.non_sender_rtt_measurement = true;
1005 RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
1006 receiver.SetRemoteSSRC(kSenderSsrc);
1007 receiver.SetNonSenderRttMeasurement(false);
1008
1009 Random rand(0x0123456789abcdef);
1010 const TimeDelta kRtt = TimeDelta::Millis(rand.Rand(1, 9 * 3600 * 1000));
1011 const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff);
1012 const TimeDelta kDelay = CompactNtpRttToTimeDelta(kDelayNtp);
1013 NtpTime now = mocks.clock.CurrentNtpTime();
1014 uint32_t sent_ntp = CompactNtp(now);
1015 mocks.clock.AdvanceTime(kRtt + kDelay);
1016
1017 rtcp::ExtendedReports xr;
1018 xr.SetSenderSsrc(kSenderSsrc);
1019 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, sent_ntp, kDelayNtp));
1020
1021 receiver.IncomingPacket(xr.Build());
1022
1023 // We expect that no RTT is available (because receive-side RTT was disabled).
1024 int64_t rtt_ms = 0;
1025 EXPECT_FALSE(receiver.GetAndResetXrRrRtt(&rtt_ms));
1026 RTCPReceiver::NonSenderRttStats non_sender_rtt_stats =
1027 receiver.GetNonSenderRTT();
1028 EXPECT_FALSE(non_sender_rtt_stats.round_trip_time().has_value());
1029 EXPECT_TRUE(non_sender_rtt_stats.total_round_trip_time().IsZero());
1030 EXPECT_EQ(non_sender_rtt_stats.round_trip_time_measurements(), 0);
1031 }
1032
TEST(RtcpReceiverTest,XrDlrrCalculatesNegativeRttAsOne)1033 TEST(RtcpReceiverTest, XrDlrrCalculatesNegativeRttAsOne) {
1034 ReceiverMocks mocks;
1035 auto config = DefaultConfiguration(&mocks);
1036 config.non_sender_rtt_measurement = true;
1037 RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
1038 receiver.SetRemoteSSRC(kSenderSsrc);
1039
1040 Random rand(0x0123456789abcdef);
1041 const TimeDelta kRtt = TimeDelta::Millis(rand.Rand(-3600 * 1000, -1));
1042 const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff);
1043 const TimeDelta kDelay = CompactNtpRttToTimeDelta(kDelayNtp);
1044 NtpTime now = mocks.clock.CurrentNtpTime();
1045 uint32_t sent_ntp = CompactNtp(now);
1046 mocks.clock.AdvanceTime(kRtt + kDelay);
1047
1048 rtcp::ExtendedReports xr;
1049 xr.SetSenderSsrc(kSenderSsrc);
1050 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, sent_ntp, kDelayNtp));
1051
1052 receiver.IncomingPacket(xr.Build());
1053
1054 int64_t rtt_ms = 0;
1055 EXPECT_TRUE(receiver.GetAndResetXrRrRtt(&rtt_ms));
1056 EXPECT_EQ(1, rtt_ms);
1057 RTCPReceiver::NonSenderRttStats non_sender_rtt_stats =
1058 receiver.GetNonSenderRTT();
1059 EXPECT_TRUE(non_sender_rtt_stats.round_trip_time().has_value());
1060 EXPECT_FALSE(non_sender_rtt_stats.round_trip_time().value().IsZero());
1061 EXPECT_FALSE(non_sender_rtt_stats.total_round_trip_time().IsZero());
1062 EXPECT_GT(non_sender_rtt_stats.round_trip_time_measurements(), 0);
1063 }
1064
1065 // Test receiver RTT stats with multiple measurements.
TEST(RtcpReceiverTest,ReceiverRttWithMultipleMeasurements)1066 TEST(RtcpReceiverTest, ReceiverRttWithMultipleMeasurements) {
1067 ReceiverMocks mocks;
1068 auto config = DefaultConfiguration(&mocks);
1069 config.non_sender_rtt_measurement = true;
1070 RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
1071 receiver.SetRemoteSSRC(kSenderSsrc);
1072
1073 Random rand(0x0123456789abcdef);
1074 const TimeDelta kRtt = TimeDelta::Millis(rand.Rand(1, 9 * 3600 * 1000));
1075 const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff);
1076 const TimeDelta kDelay = CompactNtpRttToTimeDelta(kDelayNtp);
1077 NtpTime now = mocks.clock.CurrentNtpTime();
1078 uint32_t sent_ntp = CompactNtp(now);
1079 mocks.clock.AdvanceTime(kRtt + kDelay);
1080
1081 rtcp::ExtendedReports xr;
1082 xr.SetSenderSsrc(kSenderSsrc);
1083 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, sent_ntp, kDelayNtp));
1084
1085 receiver.IncomingPacket(xr.Build());
1086
1087 // Check that the non-sender RTT stats are valid and based on a single
1088 // measurement.
1089 RTCPReceiver::NonSenderRttStats non_sender_rtt_stats =
1090 receiver.GetNonSenderRTT();
1091 EXPECT_TRUE(non_sender_rtt_stats.round_trip_time().has_value());
1092 EXPECT_NEAR(non_sender_rtt_stats.round_trip_time()->ms(), kRtt.ms(), 1);
1093 EXPECT_EQ(non_sender_rtt_stats.round_trip_time_measurements(), 1);
1094 EXPECT_EQ(non_sender_rtt_stats.total_round_trip_time().ms(),
1095 non_sender_rtt_stats.round_trip_time()->ms());
1096
1097 // Generate another XR report with the same RTT and delay.
1098 NtpTime now2 = mocks.clock.CurrentNtpTime();
1099 uint32_t sent_ntp2 = CompactNtp(now2);
1100 mocks.clock.AdvanceTime(kRtt + kDelay);
1101
1102 rtcp::ExtendedReports xr2;
1103 xr2.SetSenderSsrc(kSenderSsrc);
1104 xr2.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, sent_ntp2, kDelayNtp));
1105
1106 receiver.IncomingPacket(xr2.Build());
1107
1108 // Check that the non-sender RTT stats are based on 2 measurements, and that
1109 // the values are as expected.
1110 non_sender_rtt_stats = receiver.GetNonSenderRTT();
1111 EXPECT_TRUE(non_sender_rtt_stats.round_trip_time().has_value());
1112 EXPECT_NEAR(non_sender_rtt_stats.round_trip_time()->ms(), kRtt.ms(), 1);
1113 EXPECT_EQ(non_sender_rtt_stats.round_trip_time_measurements(), 2);
1114 EXPECT_NEAR(non_sender_rtt_stats.total_round_trip_time().ms(), 2 * kRtt.ms(),
1115 2);
1116 }
1117
1118 // Test that the receiver RTT stat resets when receiving a SR without XR. This
1119 // behavior is described in the standard, see
1120 // https://www.w3.org/TR/webrtc-stats/#dom-rtcremoteoutboundrtpstreamstats-roundtriptime.
TEST(RtcpReceiverTest,ReceiverRttResetOnSrWithoutXr)1121 TEST(RtcpReceiverTest, ReceiverRttResetOnSrWithoutXr) {
1122 ReceiverMocks mocks;
1123 auto config = DefaultConfiguration(&mocks);
1124 config.non_sender_rtt_measurement = true;
1125 RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
1126 receiver.SetRemoteSSRC(kSenderSsrc);
1127
1128 Random rand(0x0123456789abcdef);
1129 const TimeDelta kRtt = TimeDelta::Millis(rand.Rand(1, 9 * 3600 * 1000));
1130 const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff);
1131 const TimeDelta kDelay = CompactNtpRttToTimeDelta(kDelayNtp);
1132 NtpTime now = mocks.clock.CurrentNtpTime();
1133 uint32_t sent_ntp = CompactNtp(now);
1134 mocks.clock.AdvanceTime(kRtt + kDelay);
1135
1136 rtcp::ExtendedReports xr;
1137 xr.SetSenderSsrc(kSenderSsrc);
1138 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, sent_ntp, kDelayNtp));
1139
1140 receiver.IncomingPacket(xr.Build());
1141
1142 RTCPReceiver::NonSenderRttStats non_sender_rtt_stats =
1143 receiver.GetNonSenderRTT();
1144 EXPECT_TRUE(non_sender_rtt_stats.round_trip_time().has_value());
1145 EXPECT_NEAR(non_sender_rtt_stats.round_trip_time()->ms(), kRtt.ms(), 1);
1146
1147 // Generate a SR without XR.
1148 rtcp::ReportBlock rb;
1149 rb.SetMediaSsrc(kReceiverMainSsrc);
1150 rtcp::SenderReport sr;
1151 sr.SetSenderSsrc(kSenderSsrc);
1152 sr.AddReportBlock(rb);
1153 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
1154 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport);
1155
1156 receiver.IncomingPacket(sr.Build());
1157
1158 // Check that the non-sender RTT stat is not set.
1159 non_sender_rtt_stats = receiver.GetNonSenderRTT();
1160 EXPECT_FALSE(non_sender_rtt_stats.round_trip_time().has_value());
1161 }
1162
1163 // Test that the receiver RTT stat resets when receiving a DLRR with a timestamp
1164 // of zero. This behavior is described in the standard, see
1165 // https://www.w3.org/TR/webrtc-stats/#dom-rtcremoteoutboundrtpstreamstats-roundtriptime.
TEST(RtcpReceiverTest,ReceiverRttResetOnDlrrWithZeroTimestamp)1166 TEST(RtcpReceiverTest, ReceiverRttResetOnDlrrWithZeroTimestamp) {
1167 ReceiverMocks mocks;
1168 auto config = DefaultConfiguration(&mocks);
1169 config.non_sender_rtt_measurement = true;
1170 RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
1171 receiver.SetRemoteSSRC(kSenderSsrc);
1172
1173 Random rand(0x0123456789abcdef);
1174 const TimeDelta kRtt = TimeDelta::Millis(rand.Rand(1, 9 * 3600 * 1000));
1175 const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff);
1176 const TimeDelta kDelay = CompactNtpRttToTimeDelta(kDelayNtp);
1177 NtpTime now = mocks.clock.CurrentNtpTime();
1178 uint32_t sent_ntp = CompactNtp(now);
1179 mocks.clock.AdvanceTime(kRtt + kDelay);
1180
1181 rtcp::ExtendedReports xr;
1182 xr.SetSenderSsrc(kSenderSsrc);
1183 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, sent_ntp, kDelayNtp));
1184
1185 receiver.IncomingPacket(xr.Build());
1186
1187 RTCPReceiver::NonSenderRttStats non_sender_rtt_stats =
1188 receiver.GetNonSenderRTT();
1189 EXPECT_TRUE(non_sender_rtt_stats.round_trip_time().has_value());
1190 EXPECT_NEAR(non_sender_rtt_stats.round_trip_time()->ms(), kRtt.ms(), 1);
1191
1192 // Generate an XR+DLRR with zero timestamp.
1193 rtcp::ExtendedReports xr2;
1194 xr2.SetSenderSsrc(kSenderSsrc);
1195 xr2.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, 0, kDelayNtp));
1196
1197 receiver.IncomingPacket(xr2.Build());
1198
1199 // Check that the non-sender RTT stat is not set.
1200 non_sender_rtt_stats = receiver.GetNonSenderRTT();
1201 EXPECT_FALSE(non_sender_rtt_stats.round_trip_time().has_value());
1202 }
1203
1204 // Check that the receiver RTT works correctly when the remote SSRC changes.
TEST(RtcpReceiverTest,ReceiverRttWithMultipleRemoteSsrcs)1205 TEST(RtcpReceiverTest, ReceiverRttWithMultipleRemoteSsrcs) {
1206 ReceiverMocks mocks;
1207 auto config = DefaultConfiguration(&mocks);
1208 config.non_sender_rtt_measurement = false;
1209 RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
1210 receiver.SetRemoteSSRC(kSenderSsrc);
1211 receiver.SetNonSenderRttMeasurement(true);
1212
1213 Random rand(0x0123456789abcdef);
1214 const TimeDelta kRtt = TimeDelta::Millis(rand.Rand(1, 9 * 3600 * 1000));
1215 const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff);
1216 const TimeDelta kDelay = CompactNtpRttToTimeDelta(kDelayNtp);
1217 NtpTime now = mocks.clock.CurrentNtpTime();
1218 uint32_t sent_ntp = CompactNtp(now);
1219 mocks.clock.AdvanceTime(kRtt + kDelay);
1220
1221 rtcp::ExtendedReports xr;
1222 xr.SetSenderSsrc(kSenderSsrc);
1223 xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, sent_ntp, kDelayNtp));
1224
1225 receiver.IncomingPacket(xr.Build());
1226
1227 // Generate an XR report for another SSRC.
1228 const TimeDelta kRtt2 = TimeDelta::Millis(rand.Rand(1, 9 * 3600 * 1000));
1229 const uint32_t kDelayNtp2 = rand.Rand(0, 0x7fffffff);
1230 const TimeDelta kDelay2 = CompactNtpRttToTimeDelta(kDelayNtp2);
1231 NtpTime now2 = mocks.clock.CurrentNtpTime();
1232 uint32_t sent_ntp2 = CompactNtp(now2);
1233 mocks.clock.AdvanceTime(kRtt2 + kDelay2);
1234
1235 rtcp::ExtendedReports xr2;
1236 xr2.SetSenderSsrc(kSenderSsrc + 1);
1237 xr2.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, sent_ntp2, kDelayNtp2));
1238
1239 receiver.IncomingPacket(xr2.Build());
1240
1241 // Check that the non-sender RTT stats match the first XR.
1242 RTCPReceiver::NonSenderRttStats non_sender_rtt_stats =
1243 receiver.GetNonSenderRTT();
1244 EXPECT_TRUE(non_sender_rtt_stats.round_trip_time().has_value());
1245 EXPECT_NEAR(non_sender_rtt_stats.round_trip_time()->ms(), kRtt.ms(), 1);
1246 EXPECT_FALSE(non_sender_rtt_stats.total_round_trip_time().IsZero());
1247 EXPECT_GT(non_sender_rtt_stats.round_trip_time_measurements(), 0);
1248
1249 // Change the remote SSRC and check that the stats match the second XR.
1250 receiver.SetRemoteSSRC(kSenderSsrc + 1);
1251 RTCPReceiver::NonSenderRttStats non_sender_rtt_stats2 =
1252 receiver.GetNonSenderRTT();
1253 EXPECT_TRUE(non_sender_rtt_stats2.round_trip_time().has_value());
1254 EXPECT_NEAR(non_sender_rtt_stats2.round_trip_time()->ms(), kRtt2.ms(), 1);
1255 EXPECT_FALSE(non_sender_rtt_stats2.total_round_trip_time().IsZero());
1256 EXPECT_GT(non_sender_rtt_stats2.round_trip_time_measurements(), 0);
1257 }
1258
TEST(RtcpReceiverTest,ConsumeReceivedXrReferenceTimeInfoInitiallyEmpty)1259 TEST(RtcpReceiverTest, ConsumeReceivedXrReferenceTimeInfoInitiallyEmpty) {
1260 ReceiverMocks mocks;
1261 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1262 receiver.SetRemoteSSRC(kSenderSsrc);
1263
1264 EXPECT_THAT(receiver.ConsumeReceivedXrReferenceTimeInfo(), IsEmpty());
1265 }
1266
TEST(RtcpReceiverTest,ConsumeReceivedXrReferenceTimeInfo)1267 TEST(RtcpReceiverTest, ConsumeReceivedXrReferenceTimeInfo) {
1268 ReceiverMocks mocks;
1269 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1270 receiver.SetRemoteSSRC(kSenderSsrc);
1271
1272 const NtpTime kNtp(0x10203, 0x40506);
1273 const uint32_t kNtpMid = CompactNtp(kNtp);
1274
1275 rtcp::Rrtr rrtr;
1276 rrtr.SetNtp(kNtp);
1277 rtcp::ExtendedReports xr;
1278 xr.SetSenderSsrc(kSenderSsrc);
1279 xr.SetRrtr(rrtr);
1280
1281 receiver.IncomingPacket(xr.Build());
1282
1283 mocks.clock.AdvanceTimeMilliseconds(1000);
1284
1285 std::vector<rtcp::ReceiveTimeInfo> last_xr_rtis =
1286 receiver.ConsumeReceivedXrReferenceTimeInfo();
1287 ASSERT_THAT(last_xr_rtis, SizeIs(1));
1288 EXPECT_EQ(kSenderSsrc, last_xr_rtis[0].ssrc);
1289 EXPECT_EQ(kNtpMid, last_xr_rtis[0].last_rr);
1290 EXPECT_EQ(65536U, last_xr_rtis[0].delay_since_last_rr);
1291 }
1292
TEST(RtcpReceiverTest,ReceivedRrtrFromSameSsrcUpdatesReceivedReferenceTimeInfo)1293 TEST(RtcpReceiverTest,
1294 ReceivedRrtrFromSameSsrcUpdatesReceivedReferenceTimeInfo) {
1295 ReceiverMocks mocks;
1296 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1297 receiver.SetRemoteSSRC(kSenderSsrc);
1298
1299 const NtpTime kNtp1(0x10203, 0x40506);
1300 const NtpTime kNtp2(0x11223, 0x44556);
1301 const int64_t kDelayMs = 2000;
1302
1303 rtcp::ExtendedReports xr;
1304 xr.SetSenderSsrc(kSenderSsrc);
1305 rtcp::Rrtr rrtr1;
1306 rrtr1.SetNtp(kNtp1);
1307 xr.SetRrtr(rrtr1);
1308 receiver.IncomingPacket(xr.Build());
1309 mocks.clock.AdvanceTimeMilliseconds(kDelayMs);
1310 rtcp::Rrtr rrtr2;
1311 rrtr2.SetNtp(kNtp2);
1312 xr.SetRrtr(rrtr2);
1313 receiver.IncomingPacket(xr.Build());
1314 mocks.clock.AdvanceTimeMilliseconds(kDelayMs);
1315
1316 std::vector<rtcp::ReceiveTimeInfo> last_xr_rtis =
1317 receiver.ConsumeReceivedXrReferenceTimeInfo();
1318 ASSERT_THAT(last_xr_rtis, SizeIs(1));
1319 EXPECT_EQ(kSenderSsrc, last_xr_rtis[0].ssrc);
1320 EXPECT_EQ(CompactNtp(kNtp2), last_xr_rtis[0].last_rr);
1321 EXPECT_EQ(kDelayMs * 65536 / 1000, last_xr_rtis[0].delay_since_last_rr);
1322 }
1323
TEST(RtcpReceiverTest,StoresLastReceivedRrtrPerSsrc)1324 TEST(RtcpReceiverTest, StoresLastReceivedRrtrPerSsrc) {
1325 ReceiverMocks mocks;
1326 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1327 receiver.SetRemoteSSRC(kSenderSsrc);
1328
1329 const size_t kNumBufferedReports = 1;
1330 const size_t kNumReports =
1331 rtcp::ExtendedReports::kMaxNumberOfDlrrItems + kNumBufferedReports;
1332 for (size_t i = 0; i < kNumReports; ++i) {
1333 rtcp::ExtendedReports xr;
1334 xr.SetSenderSsrc(i * 100);
1335 rtcp::Rrtr rrtr;
1336 rrtr.SetNtp(NtpTime(i * 200, i * 300));
1337 xr.SetRrtr(rrtr);
1338 receiver.IncomingPacket(xr.Build());
1339 mocks.clock.AdvanceTimeMilliseconds(1000);
1340 }
1341
1342 std::vector<rtcp::ReceiveTimeInfo> last_xr_rtis =
1343 receiver.ConsumeReceivedXrReferenceTimeInfo();
1344 ASSERT_THAT(last_xr_rtis,
1345 SizeIs(rtcp::ExtendedReports::kMaxNumberOfDlrrItems));
1346 for (size_t i = 0; i < rtcp::ExtendedReports::kMaxNumberOfDlrrItems; ++i) {
1347 EXPECT_EQ(i * 100, last_xr_rtis[i].ssrc);
1348 EXPECT_EQ(CompactNtp(NtpTime(i * 200, i * 300)), last_xr_rtis[i].last_rr);
1349 EXPECT_EQ(65536U * (kNumReports - i), last_xr_rtis[i].delay_since_last_rr);
1350 }
1351
1352 last_xr_rtis = receiver.ConsumeReceivedXrReferenceTimeInfo();
1353 ASSERT_THAT(last_xr_rtis, SizeIs(kNumBufferedReports));
1354 }
1355
TEST(RtcpReceiverTest,ReceiveReportTimeout)1356 TEST(RtcpReceiverTest, ReceiveReportTimeout) {
1357 ReceiverMocks mocks;
1358 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1359 receiver.SetRemoteSSRC(kSenderSsrc);
1360
1361 const uint16_t kSequenceNumber = 1234;
1362 mocks.clock.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs);
1363
1364 // No RR received, shouldn't trigger a timeout.
1365 EXPECT_FALSE(receiver.RtcpRrTimeout());
1366 EXPECT_FALSE(receiver.RtcpRrSequenceNumberTimeout());
1367
1368 // Add a RR and advance the clock just enough to not trigger a timeout.
1369 rtcp::ReportBlock rb1;
1370 rb1.SetMediaSsrc(kReceiverMainSsrc);
1371 rb1.SetExtHighestSeqNum(kSequenceNumber);
1372 rtcp::ReceiverReport rr1;
1373 rr1.SetSenderSsrc(kSenderSsrc);
1374 rr1.AddReportBlock(rb1);
1375
1376 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
1377 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport);
1378 receiver.IncomingPacket(rr1.Build());
1379
1380 mocks.clock.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs - 1);
1381 EXPECT_FALSE(receiver.RtcpRrTimeout());
1382 EXPECT_FALSE(receiver.RtcpRrSequenceNumberTimeout());
1383
1384 // Add a RR with the same extended max as the previous RR to trigger a
1385 // sequence number timeout, but not a RR timeout.
1386 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
1387 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport);
1388 receiver.IncomingPacket(rr1.Build());
1389
1390 mocks.clock.AdvanceTimeMilliseconds(2);
1391 EXPECT_FALSE(receiver.RtcpRrTimeout());
1392 EXPECT_TRUE(receiver.RtcpRrSequenceNumberTimeout());
1393
1394 // Advance clock enough to trigger an RR timeout too.
1395 mocks.clock.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs);
1396 EXPECT_TRUE(receiver.RtcpRrTimeout());
1397
1398 // We should only get one timeout even though we still haven't received a new
1399 // RR.
1400 EXPECT_FALSE(receiver.RtcpRrTimeout());
1401 EXPECT_FALSE(receiver.RtcpRrSequenceNumberTimeout());
1402
1403 // Add a new RR with increase sequence number to reset timers.
1404 rtcp::ReportBlock rb2;
1405 rb2.SetMediaSsrc(kReceiverMainSsrc);
1406 rb2.SetExtHighestSeqNum(kSequenceNumber + 1);
1407 rtcp::ReceiverReport rr2;
1408 rr2.SetSenderSsrc(kSenderSsrc);
1409 rr2.AddReportBlock(rb2);
1410
1411 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
1412 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport);
1413 receiver.IncomingPacket(rr2.Build());
1414
1415 EXPECT_FALSE(receiver.RtcpRrTimeout());
1416 EXPECT_FALSE(receiver.RtcpRrSequenceNumberTimeout());
1417
1418 // Verify we can get a timeout again once we've received new RR.
1419 mocks.clock.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs);
1420 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
1421 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport);
1422 receiver.IncomingPacket(rr2.Build());
1423
1424 mocks.clock.AdvanceTimeMilliseconds(kRtcpIntervalMs + 1);
1425 EXPECT_FALSE(receiver.RtcpRrTimeout());
1426 EXPECT_TRUE(receiver.RtcpRrSequenceNumberTimeout());
1427
1428 mocks.clock.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs);
1429 EXPECT_TRUE(receiver.RtcpRrTimeout());
1430 }
1431
TEST(RtcpReceiverTest,TmmbrReceivedWithNoIncomingPacket)1432 TEST(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) {
1433 ReceiverMocks mocks;
1434 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1435 receiver.SetRemoteSSRC(kSenderSsrc);
1436
1437 EXPECT_THAT(receiver.TmmbrReceived(), IsEmpty());
1438 }
1439
TEST(RtcpReceiverTest,TmmbrPacketAccepted)1440 TEST(RtcpReceiverTest, TmmbrPacketAccepted) {
1441 ReceiverMocks mocks;
1442 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1443 receiver.SetRemoteSSRC(kSenderSsrc);
1444
1445 const uint32_t kBitrateBps = 30000;
1446 auto tmmbr = std::make_unique<rtcp::Tmmbr>();
1447 tmmbr->SetSenderSsrc(kSenderSsrc);
1448 tmmbr->AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, kBitrateBps, 0));
1449 auto sr = std::make_unique<rtcp::SenderReport>();
1450 sr->SetSenderSsrc(kSenderSsrc);
1451 rtcp::CompoundPacket compound;
1452 compound.Append(std::move(sr));
1453 compound.Append(std::move(tmmbr));
1454
1455 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
1456 EXPECT_CALL(mocks.rtp_rtcp_impl, SetTmmbn(SizeIs(1)));
1457 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport);
1458 EXPECT_CALL(mocks.bandwidth_observer,
1459 OnReceivedEstimatedBitrate(kBitrateBps));
1460 receiver.IncomingPacket(compound.Build());
1461
1462 std::vector<rtcp::TmmbItem> tmmbr_received = receiver.TmmbrReceived();
1463 ASSERT_EQ(1u, tmmbr_received.size());
1464 EXPECT_EQ(kBitrateBps, tmmbr_received[0].bitrate_bps());
1465 EXPECT_EQ(kSenderSsrc, tmmbr_received[0].ssrc());
1466 }
1467
TEST(RtcpReceiverTest,TmmbrPacketNotForUsIgnored)1468 TEST(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) {
1469 ReceiverMocks mocks;
1470 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1471 receiver.SetRemoteSSRC(kSenderSsrc);
1472
1473 const uint32_t kBitrateBps = 30000;
1474 auto tmmbr = std::make_unique<rtcp::Tmmbr>();
1475 tmmbr->SetSenderSsrc(kSenderSsrc);
1476 tmmbr->AddTmmbr(rtcp::TmmbItem(kNotToUsSsrc, kBitrateBps, 0));
1477
1478 auto sr = std::make_unique<rtcp::SenderReport>();
1479 sr->SetSenderSsrc(kSenderSsrc);
1480 rtcp::CompoundPacket compound;
1481 compound.Append(std::move(sr));
1482 compound.Append(std::move(tmmbr));
1483
1484 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
1485 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport);
1486 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedEstimatedBitrate).Times(0);
1487 receiver.IncomingPacket(compound.Build());
1488
1489 EXPECT_EQ(0u, receiver.TmmbrReceived().size());
1490 }
1491
TEST(RtcpReceiverTest,TmmbrPacketZeroRateIgnored)1492 TEST(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) {
1493 ReceiverMocks mocks;
1494 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1495 receiver.SetRemoteSSRC(kSenderSsrc);
1496
1497 auto tmmbr = std::make_unique<rtcp::Tmmbr>();
1498 tmmbr->SetSenderSsrc(kSenderSsrc);
1499 tmmbr->AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 0, 0));
1500 auto sr = std::make_unique<rtcp::SenderReport>();
1501 sr->SetSenderSsrc(kSenderSsrc);
1502 rtcp::CompoundPacket compound;
1503 compound.Append(std::move(sr));
1504 compound.Append(std::move(tmmbr));
1505
1506 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
1507 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport);
1508 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedEstimatedBitrate).Times(0);
1509 receiver.IncomingPacket(compound.Build());
1510
1511 EXPECT_EQ(0u, receiver.TmmbrReceived().size());
1512 }
1513
TEST(RtcpReceiverTest,TmmbrThreeConstraintsTimeOut)1514 TEST(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) {
1515 ReceiverMocks mocks;
1516 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1517 receiver.SetRemoteSSRC(kSenderSsrc);
1518
1519 // Inject 3 packets "from" kSenderSsrc, kSenderSsrc+1, kSenderSsrc+2.
1520 // The times of arrival are starttime + 0, starttime + 5 and starttime + 10.
1521 for (uint32_t ssrc = kSenderSsrc; ssrc < kSenderSsrc + 3; ++ssrc) {
1522 auto tmmbr = std::make_unique<rtcp::Tmmbr>();
1523 tmmbr->SetSenderSsrc(ssrc);
1524 tmmbr->AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 30000, 0));
1525 auto sr = std::make_unique<rtcp::SenderReport>();
1526 sr->SetSenderSsrc(ssrc);
1527 rtcp::CompoundPacket compound;
1528 compound.Append(std::move(sr));
1529 compound.Append(std::move(tmmbr));
1530
1531 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
1532 EXPECT_CALL(mocks.rtp_rtcp_impl, SetTmmbn);
1533 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport);
1534 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedEstimatedBitrate);
1535 receiver.IncomingPacket(compound.Build());
1536
1537 // 5 seconds between each packet.
1538 mocks.clock.AdvanceTimeMilliseconds(5000);
1539 }
1540 // It is now starttime + 15.
1541 EXPECT_THAT(receiver.TmmbrReceived(),
1542 AllOf(SizeIs(3),
1543 Each(Property(&rtcp::TmmbItem::bitrate_bps, Eq(30'000U)))));
1544
1545 // We expect the timeout to be 25 seconds. Advance the clock by 12
1546 // seconds, timing out the first packet.
1547 mocks.clock.AdvanceTimeMilliseconds(12000);
1548 EXPECT_THAT(receiver.TmmbrReceived(),
1549 UnorderedElementsAre(
1550 Property(&rtcp::TmmbItem::ssrc, Eq(kSenderSsrc + 1)),
1551 Property(&rtcp::TmmbItem::ssrc, Eq(kSenderSsrc + 2))));
1552 }
1553
TEST(RtcpReceiverTest,VerifyBlockAndTimestampObtainedFromReportBlockDataObserver)1554 TEST(RtcpReceiverTest,
1555 VerifyBlockAndTimestampObtainedFromReportBlockDataObserver) {
1556 ReceiverMocks mocks;
1557 MockReportBlockDataObserverImpl observer;
1558 RtpRtcpInterface::Configuration config = DefaultConfiguration(&mocks);
1559 config.report_block_data_observer = &observer;
1560 RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
1561 receiver.SetRemoteSSRC(kSenderSsrc);
1562
1563 const uint8_t kFractionLoss = 3;
1564 const uint32_t kCumulativeLoss = 7;
1565 const uint32_t kJitter = 9;
1566 const uint16_t kSequenceNumber = 1234;
1567 const int64_t kNtpNowMs =
1568 mocks.clock.CurrentNtpInMilliseconds() - rtc::kNtpJan1970Millisecs;
1569
1570 rtcp::ReportBlock rtcp_block;
1571 rtcp_block.SetMediaSsrc(kReceiverMainSsrc);
1572 rtcp_block.SetExtHighestSeqNum(kSequenceNumber);
1573 rtcp_block.SetFractionLost(kFractionLoss);
1574 rtcp_block.SetCumulativeLost(kCumulativeLoss);
1575 rtcp_block.SetJitter(kJitter);
1576
1577 rtcp::ReceiverReport rtcp_report;
1578 rtcp_report.SetSenderSsrc(kSenderSsrc);
1579 rtcp_report.AddReportBlock(rtcp_block);
1580 EXPECT_CALL(observer, OnReportBlockDataUpdated)
1581 .WillOnce([&](ReportBlockData report_block_data) {
1582 const auto& report_block = report_block_data.report_block();
1583 EXPECT_EQ(rtcp_block.source_ssrc(), report_block.source_ssrc);
1584 EXPECT_EQ(kSenderSsrc, report_block.sender_ssrc);
1585 EXPECT_EQ(rtcp_block.fraction_lost(), report_block.fraction_lost);
1586 EXPECT_EQ(rtcp_block.cumulative_lost_signed(),
1587 report_block.packets_lost);
1588 EXPECT_EQ(rtcp_block.extended_high_seq_num(),
1589 report_block.extended_highest_sequence_number);
1590 EXPECT_EQ(rtcp_block.jitter(), report_block.jitter);
1591 EXPECT_EQ(kNtpNowMs * rtc::kNumMicrosecsPerMillisec,
1592 report_block_data.report_block_timestamp_utc_us());
1593 // No RTT is calculated in this test.
1594 EXPECT_EQ(0u, report_block_data.num_rtts());
1595 });
1596 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
1597 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport);
1598 receiver.IncomingPacket(rtcp_report.Build());
1599 }
1600
TEST(RtcpReceiverTest,VerifyRttObtainedFromReportBlockDataObserver)1601 TEST(RtcpReceiverTest, VerifyRttObtainedFromReportBlockDataObserver) {
1602 ReceiverMocks mocks;
1603 MockReportBlockDataObserverImpl observer;
1604 RtpRtcpInterface::Configuration config = DefaultConfiguration(&mocks);
1605 config.report_block_data_observer = &observer;
1606 RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
1607 receiver.SetRemoteSSRC(kSenderSsrc);
1608
1609 const TimeDelta kRtt = TimeDelta::Millis(120);
1610 const uint32_t kDelayNtp = 123000;
1611 const TimeDelta kDelay = CompactNtpRttToTimeDelta(kDelayNtp);
1612
1613 uint32_t sent_ntp = CompactNtp(mocks.clock.CurrentNtpTime());
1614 mocks.clock.AdvanceTime(kRtt + kDelay);
1615
1616 rtcp::SenderReport sr;
1617 sr.SetSenderSsrc(kSenderSsrc);
1618 rtcp::ReportBlock block;
1619 block.SetMediaSsrc(kReceiverMainSsrc);
1620 block.SetLastSr(sent_ntp);
1621 block.SetDelayLastSr(kDelayNtp);
1622 sr.AddReportBlock(block);
1623 block.SetMediaSsrc(kReceiverExtraSsrc);
1624 block.SetLastSr(0);
1625 sr.AddReportBlock(block);
1626
1627 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
1628 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport);
1629 InSequence sequence;
1630 EXPECT_CALL(observer, OnReportBlockDataUpdated)
1631 .WillOnce([&](ReportBlockData report_block_data) {
1632 EXPECT_EQ(kReceiverMainSsrc,
1633 report_block_data.report_block().source_ssrc);
1634 EXPECT_EQ(1u, report_block_data.num_rtts());
1635 EXPECT_EQ(kRtt.ms(), report_block_data.min_rtt_ms());
1636 EXPECT_EQ(kRtt.ms(), report_block_data.max_rtt_ms());
1637 EXPECT_EQ(kRtt.ms(), report_block_data.sum_rtt_ms());
1638 EXPECT_EQ(kRtt.ms(), report_block_data.last_rtt_ms());
1639 });
1640 EXPECT_CALL(observer, OnReportBlockDataUpdated)
1641 .WillOnce([](ReportBlockData report_block_data) {
1642 EXPECT_EQ(kReceiverExtraSsrc,
1643 report_block_data.report_block().source_ssrc);
1644 EXPECT_EQ(0u, report_block_data.num_rtts());
1645 });
1646 receiver.IncomingPacket(sr.Build());
1647 }
1648
TEST(RtcpReceiverTest,GetReportBlockDataAfterOneReportBlock)1649 TEST(RtcpReceiverTest, GetReportBlockDataAfterOneReportBlock) {
1650 ReceiverMocks mocks;
1651 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1652 receiver.SetRemoteSSRC(kSenderSsrc);
1653
1654 const uint16_t kSequenceNumber = 1234;
1655
1656 rtcp::ReportBlock rtcp_block;
1657 rtcp_block.SetMediaSsrc(kReceiverMainSsrc);
1658 rtcp_block.SetExtHighestSeqNum(kSequenceNumber);
1659
1660 rtcp::ReceiverReport rtcp_report;
1661 rtcp_report.SetSenderSsrc(kSenderSsrc);
1662 rtcp_report.AddReportBlock(rtcp_block);
1663 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
1664 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport);
1665 receiver.IncomingPacket(rtcp_report.Build());
1666
1667 auto report_block_datas = receiver.GetLatestReportBlockData();
1668 ASSERT_THAT(report_block_datas, SizeIs(1));
1669 EXPECT_EQ(kReceiverMainSsrc,
1670 report_block_datas[0].report_block().source_ssrc);
1671 EXPECT_EQ(
1672 kSequenceNumber,
1673 report_block_datas[0].report_block().extended_highest_sequence_number);
1674 }
1675
TEST(RtcpReceiverTest,GetReportBlockDataAfterTwoReportBlocksOfSameSsrc)1676 TEST(RtcpReceiverTest, GetReportBlockDataAfterTwoReportBlocksOfSameSsrc) {
1677 ReceiverMocks mocks;
1678 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1679 receiver.SetRemoteSSRC(kSenderSsrc);
1680
1681 const uint16_t kSequenceNumber1 = 1234;
1682 const uint16_t kSequenceNumber2 = 1235;
1683
1684 rtcp::ReportBlock rtcp_block1;
1685 rtcp_block1.SetMediaSsrc(kReceiverMainSsrc);
1686 rtcp_block1.SetExtHighestSeqNum(kSequenceNumber1);
1687
1688 rtcp::ReceiverReport rtcp_report1;
1689 rtcp_report1.SetSenderSsrc(kSenderSsrc);
1690 rtcp_report1.AddReportBlock(rtcp_block1);
1691 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
1692 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport);
1693 receiver.IncomingPacket(rtcp_report1.Build());
1694
1695 // Inject a report block with an increased the sequence number for the same
1696 // source SSRC.
1697 rtcp::ReportBlock rtcp_block2;
1698 rtcp_block2.SetMediaSsrc(kReceiverMainSsrc);
1699 rtcp_block2.SetExtHighestSeqNum(kSequenceNumber2);
1700
1701 rtcp::ReceiverReport rtcp_report2;
1702 rtcp_report2.SetSenderSsrc(kSenderSsrc);
1703 rtcp_report2.AddReportBlock(rtcp_block2);
1704 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
1705 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport);
1706 receiver.IncomingPacket(rtcp_report2.Build());
1707
1708 // Only the latest block should be returned.
1709 auto report_block_datas = receiver.GetLatestReportBlockData();
1710 ASSERT_THAT(report_block_datas, SizeIs(1));
1711 EXPECT_EQ(kReceiverMainSsrc,
1712 report_block_datas[0].report_block().source_ssrc);
1713 EXPECT_EQ(
1714 kSequenceNumber2,
1715 report_block_datas[0].report_block().extended_highest_sequence_number);
1716 }
1717
TEST(RtcpReceiverTest,GetReportBlockDataAfterTwoReportBlocksOfDifferentSsrcs)1718 TEST(RtcpReceiverTest, GetReportBlockDataAfterTwoReportBlocksOfDifferentSsrcs) {
1719 ReceiverMocks mocks;
1720 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1721 receiver.SetRemoteSSRC(kSenderSsrc);
1722
1723 const uint16_t kSequenceNumber1 = 1234;
1724 const uint16_t kSequenceNumber2 = 42;
1725
1726 rtcp::ReportBlock rtcp_block1;
1727 rtcp_block1.SetMediaSsrc(kReceiverMainSsrc);
1728 rtcp_block1.SetExtHighestSeqNum(kSequenceNumber1);
1729
1730 rtcp::ReceiverReport rtcp_report1;
1731 rtcp_report1.SetSenderSsrc(kSenderSsrc);
1732 rtcp_report1.AddReportBlock(rtcp_block1);
1733 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
1734 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport);
1735 receiver.IncomingPacket(rtcp_report1.Build());
1736
1737 // Inject a report block for a different source SSRC.
1738 rtcp::ReportBlock rtcp_block2;
1739 rtcp_block2.SetMediaSsrc(kReceiverExtraSsrc);
1740 rtcp_block2.SetExtHighestSeqNum(kSequenceNumber2);
1741
1742 rtcp::ReceiverReport rtcp_report2;
1743 rtcp_report2.SetSenderSsrc(kSenderSsrc);
1744 rtcp_report2.AddReportBlock(rtcp_block2);
1745 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks);
1746 EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport);
1747 receiver.IncomingPacket(rtcp_report2.Build());
1748
1749 // Both report blocks should be returned.
1750 auto report_block_datas = receiver.GetLatestReportBlockData();
1751 ASSERT_THAT(report_block_datas, SizeIs(2));
1752 EXPECT_EQ(kReceiverMainSsrc,
1753 report_block_datas[0].report_block().source_ssrc);
1754 EXPECT_EQ(
1755 kSequenceNumber1,
1756 report_block_datas[0].report_block().extended_highest_sequence_number);
1757 EXPECT_EQ(kReceiverExtraSsrc,
1758 report_block_datas[1].report_block().source_ssrc);
1759 EXPECT_EQ(
1760 kSequenceNumber2,
1761 report_block_datas[1].report_block().extended_highest_sequence_number);
1762 }
1763
TEST(RtcpReceiverTest,ReceivesTransportFeedback)1764 TEST(RtcpReceiverTest, ReceivesTransportFeedback) {
1765 ReceiverMocks mocks;
1766 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1767 receiver.SetRemoteSSRC(kSenderSsrc);
1768
1769 rtcp::TransportFeedback packet;
1770 packet.SetMediaSsrc(kReceiverMainSsrc);
1771 packet.SetSenderSsrc(kSenderSsrc);
1772 packet.SetBase(1, Timestamp::Millis(1));
1773 packet.AddReceivedPacket(1, Timestamp::Millis(1));
1774
1775 EXPECT_CALL(
1776 mocks.transport_feedback_observer,
1777 OnTransportFeedback(AllOf(
1778 Property(&rtcp::TransportFeedback::media_ssrc, kReceiverMainSsrc),
1779 Property(&rtcp::TransportFeedback::sender_ssrc, kSenderSsrc))));
1780 receiver.IncomingPacket(packet.Build());
1781 }
1782
TEST(RtcpReceiverTest,ReceivesRemb)1783 TEST(RtcpReceiverTest, ReceivesRemb) {
1784 ReceiverMocks mocks;
1785 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1786 receiver.SetRemoteSSRC(kSenderSsrc);
1787
1788 const uint32_t kBitrateBps = 500000;
1789 rtcp::Remb remb;
1790 remb.SetSenderSsrc(kSenderSsrc);
1791 remb.SetBitrateBps(kBitrateBps);
1792
1793 EXPECT_CALL(mocks.bandwidth_observer,
1794 OnReceivedEstimatedBitrate(kBitrateBps));
1795 receiver.IncomingPacket(remb.Build());
1796 }
1797
TEST(RtcpReceiverTest,HandlesInvalidTransportFeedback)1798 TEST(RtcpReceiverTest, HandlesInvalidTransportFeedback) {
1799 ReceiverMocks mocks;
1800 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1801 receiver.SetRemoteSSRC(kSenderSsrc);
1802
1803 // Send a compound packet with a TransportFeedback followed by something else.
1804 auto packet = std::make_unique<rtcp::TransportFeedback>();
1805 packet->SetMediaSsrc(kReceiverMainSsrc);
1806 packet->SetSenderSsrc(kSenderSsrc);
1807 packet->SetBase(1, Timestamp::Millis(1));
1808 packet->AddReceivedPacket(1, Timestamp::Millis(1));
1809
1810 static uint32_t kBitrateBps = 50000;
1811 auto remb = std::make_unique<rtcp::Remb>();
1812 remb->SetSenderSsrc(kSenderSsrc);
1813 remb->SetBitrateBps(kBitrateBps);
1814 rtcp::CompoundPacket compound;
1815 compound.Append(std::move(packet));
1816 compound.Append(std::move(remb));
1817 rtc::Buffer built_packet = compound.Build();
1818
1819 // Modify the TransportFeedback packet so that it is invalid.
1820 const size_t kStatusCountOffset = 14;
1821 ByteWriter<uint16_t>::WriteBigEndian(&built_packet.data()[kStatusCountOffset],
1822 42);
1823
1824 // Stress no transport feedback is expected.
1825 EXPECT_CALL(mocks.transport_feedback_observer, OnTransportFeedback).Times(0);
1826 // But remb should be processed and cause a callback
1827 EXPECT_CALL(mocks.bandwidth_observer,
1828 OnReceivedEstimatedBitrate(kBitrateBps));
1829 receiver.IncomingPacket(built_packet);
1830 }
1831
TEST(RtcpReceiverTest,Nack)1832 TEST(RtcpReceiverTest, Nack) {
1833 ReceiverMocks mocks;
1834 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1835 receiver.SetRemoteSSRC(kSenderSsrc);
1836
1837 const uint16_t kNackList1[] = {1, 2, 3, 5};
1838 const uint16_t kNackList23[] = {5, 7, 30, 40, 41, 58, 59, 61, 63};
1839 const size_t kNackListLength2 = 4;
1840 const size_t kNackListLength3 = arraysize(kNackList23) - kNackListLength2;
1841 std::set<uint16_t> nack_set;
1842 nack_set.insert(std::begin(kNackList1), std::end(kNackList1));
1843 nack_set.insert(std::begin(kNackList23), std::end(kNackList23));
1844
1845 auto nack1 = std::make_unique<rtcp::Nack>();
1846 nack1->SetSenderSsrc(kSenderSsrc);
1847 nack1->SetMediaSsrc(kReceiverMainSsrc);
1848 nack1->SetPacketIds(kNackList1, arraysize(kNackList1));
1849
1850 EXPECT_CALL(mocks.rtp_rtcp_impl,
1851 OnReceivedNack(ElementsAreArray(kNackList1)));
1852 EXPECT_CALL(mocks.packet_type_counter_observer,
1853 RtcpPacketTypesCounterUpdated(
1854 kReceiverMainSsrc,
1855 AllOf(Field(&RtcpPacketTypeCounter::nack_requests,
1856 arraysize(kNackList1)),
1857 Field(&RtcpPacketTypeCounter::unique_nack_requests,
1858 arraysize(kNackList1)))));
1859 receiver.IncomingPacket(nack1->Build());
1860
1861 auto nack2 = std::make_unique<rtcp::Nack>();
1862 nack2->SetSenderSsrc(kSenderSsrc);
1863 nack2->SetMediaSsrc(kReceiverMainSsrc);
1864 nack2->SetPacketIds(kNackList23, kNackListLength2);
1865
1866 auto nack3 = std::make_unique<rtcp::Nack>();
1867 nack3->SetSenderSsrc(kSenderSsrc);
1868 nack3->SetMediaSsrc(kReceiverMainSsrc);
1869 nack3->SetPacketIds(kNackList23 + kNackListLength2, kNackListLength3);
1870
1871 rtcp::CompoundPacket two_nacks;
1872 two_nacks.Append(std::move(nack2));
1873 two_nacks.Append(std::move(nack3));
1874
1875 EXPECT_CALL(mocks.rtp_rtcp_impl,
1876 OnReceivedNack(ElementsAreArray(kNackList23)));
1877 EXPECT_CALL(mocks.packet_type_counter_observer,
1878 RtcpPacketTypesCounterUpdated(
1879 kReceiverMainSsrc,
1880 AllOf(Field(&RtcpPacketTypeCounter::nack_requests,
1881 arraysize(kNackList1) + arraysize(kNackList23)),
1882 Field(&RtcpPacketTypeCounter::unique_nack_requests,
1883 nack_set.size()))));
1884 receiver.IncomingPacket(two_nacks.Build());
1885 }
1886
TEST(RtcpReceiverTest,NackNotForUsIgnored)1887 TEST(RtcpReceiverTest, NackNotForUsIgnored) {
1888 ReceiverMocks mocks;
1889 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1890 receiver.SetRemoteSSRC(kSenderSsrc);
1891
1892 const uint16_t kNackList1[] = {1, 2, 3, 5};
1893 const size_t kNackListLength1 = std::end(kNackList1) - std::begin(kNackList1);
1894
1895 rtcp::Nack nack;
1896 nack.SetSenderSsrc(kSenderSsrc);
1897 nack.SetMediaSsrc(kNotToUsSsrc);
1898 nack.SetPacketIds(kNackList1, kNackListLength1);
1899
1900 EXPECT_CALL(mocks.packet_type_counter_observer,
1901 RtcpPacketTypesCounterUpdated(
1902 _, Field(&RtcpPacketTypeCounter::nack_requests, 0)));
1903 receiver.IncomingPacket(nack.Build());
1904 }
1905
TEST(RtcpReceiverTest,ForceSenderReport)1906 TEST(RtcpReceiverTest, ForceSenderReport) {
1907 ReceiverMocks mocks;
1908 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1909 receiver.SetRemoteSSRC(kSenderSsrc);
1910
1911 rtcp::RapidResyncRequest rr;
1912 rr.SetSenderSsrc(kSenderSsrc);
1913 rr.SetMediaSsrc(kReceiverMainSsrc);
1914
1915 EXPECT_CALL(mocks.rtp_rtcp_impl, OnRequestSendReport());
1916 receiver.IncomingPacket(rr.Build());
1917 }
1918
TEST(RtcpReceiverTest,ReceivesTargetBitrate)1919 TEST(RtcpReceiverTest, ReceivesTargetBitrate) {
1920 ReceiverMocks mocks;
1921 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1922 receiver.SetRemoteSSRC(kSenderSsrc);
1923
1924 VideoBitrateAllocation expected_allocation;
1925 expected_allocation.SetBitrate(0, 0, 10000);
1926 expected_allocation.SetBitrate(0, 1, 20000);
1927 expected_allocation.SetBitrate(1, 0, 40000);
1928 expected_allocation.SetBitrate(1, 1, 80000);
1929
1930 rtcp::TargetBitrate bitrate;
1931 bitrate.AddTargetBitrate(0, 0, expected_allocation.GetBitrate(0, 0) / 1000);
1932 bitrate.AddTargetBitrate(0, 1, expected_allocation.GetBitrate(0, 1) / 1000);
1933 bitrate.AddTargetBitrate(1, 0, expected_allocation.GetBitrate(1, 0) / 1000);
1934 bitrate.AddTargetBitrate(1, 1, expected_allocation.GetBitrate(1, 1) / 1000);
1935
1936 rtcp::ExtendedReports xr;
1937 xr.SetTargetBitrate(bitrate);
1938
1939 // Wrong sender ssrc, target bitrate should be discarded.
1940 xr.SetSenderSsrc(kSenderSsrc + 1);
1941 EXPECT_CALL(mocks.bitrate_allocation_observer,
1942 OnBitrateAllocationUpdated(expected_allocation))
1943 .Times(0);
1944 receiver.IncomingPacket(xr.Build());
1945
1946 // Set correct ssrc, callback should be called once.
1947 xr.SetSenderSsrc(kSenderSsrc);
1948 EXPECT_CALL(mocks.bitrate_allocation_observer,
1949 OnBitrateAllocationUpdated(expected_allocation));
1950 receiver.IncomingPacket(xr.Build());
1951 }
1952
TEST(RtcpReceiverTest,HandlesIncorrectTargetBitrate)1953 TEST(RtcpReceiverTest, HandlesIncorrectTargetBitrate) {
1954 ReceiverMocks mocks;
1955 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1956 receiver.SetRemoteSSRC(kSenderSsrc);
1957
1958 VideoBitrateAllocation expected_allocation;
1959 expected_allocation.SetBitrate(0, 0, 10000);
1960
1961 rtcp::TargetBitrate bitrate;
1962 bitrate.AddTargetBitrate(0, 0, expected_allocation.GetBitrate(0, 0) / 1000);
1963 bitrate.AddTargetBitrate(0, kMaxTemporalStreams, 20000);
1964 bitrate.AddTargetBitrate(kMaxSpatialLayers, 0, 40000);
1965
1966 rtcp::ExtendedReports xr;
1967 xr.SetTargetBitrate(bitrate);
1968 xr.SetSenderSsrc(kSenderSsrc);
1969
1970 EXPECT_CALL(mocks.bitrate_allocation_observer,
1971 OnBitrateAllocationUpdated(expected_allocation));
1972 receiver.IncomingPacket(xr.Build());
1973 }
1974
TEST(RtcpReceiverTest,ChangeLocalMediaSsrc)1975 TEST(RtcpReceiverTest, ChangeLocalMediaSsrc) {
1976 ReceiverMocks mocks;
1977 // Construct a receiver with `kReceiverMainSsrc` (default) local media ssrc.
1978 RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
1979 receiver.SetRemoteSSRC(kSenderSsrc);
1980
1981 constexpr uint32_t kSecondarySsrc = kReceiverMainSsrc + 1;
1982
1983 // Expect to only get the `OnReceivedNack()` callback once since we'll
1984 // configure it for the `kReceiverMainSsrc` media ssrc.
1985 EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedNack);
1986
1987 // We'll get two callbacks to RtcpPacketTypesCounterUpdated, one for each
1988 // call to `IncomingPacket`, differentiated by the local media ssrc.
1989 EXPECT_CALL(mocks.packet_type_counter_observer,
1990 RtcpPacketTypesCounterUpdated(kReceiverMainSsrc, _));
1991 EXPECT_CALL(mocks.packet_type_counter_observer,
1992 RtcpPacketTypesCounterUpdated(kSecondarySsrc, _));
1993
1994 // Construct a test nack packet with media ssrc set to `kReceiverMainSsrc`.
1995 rtcp::Nack nack;
1996 nack.SetSenderSsrc(kSenderSsrc);
1997 nack.SetMediaSsrc(kReceiverMainSsrc);
1998 const uint16_t kNackList[] = {1, 2, 3, 5};
1999 nack.SetPacketIds(kNackList, std::size(kNackList));
2000
2001 // Deliver the first callback.
2002 receiver.IncomingPacket(nack.Build());
2003
2004 // Change the set local media ssrc.
2005 receiver.set_local_media_ssrc(kSecondarySsrc);
2006
2007 // Deliver another packet - this time there will be no callback to
2008 // OnReceivedNack due to the ssrc not matching.
2009 receiver.IncomingPacket(nack.Build());
2010 }
2011
2012 } // namespace webrtc
2013