1 /*
2 * Copyright (c) 2017 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_transceiver_impl.h"
12
13 #include <memory>
14 #include <utility>
15 #include <vector>
16
17 #include "absl/memory/memory.h"
18 #include "api/rtp_headers.h"
19 #include "api/test/create_time_controller.h"
20 #include "api/test/time_controller.h"
21 #include "api/units/data_rate.h"
22 #include "api/units/time_delta.h"
23 #include "api/units/timestamp.h"
24 #include "api/video/video_bitrate_allocation.h"
25 #include "modules/rtp_rtcp/include/receive_statistics.h"
26 #include "modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h"
27 #include "modules/rtp_rtcp/source/rtcp_packet/app.h"
28 #include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
29 #include "modules/rtp_rtcp/source/rtcp_packet/compound_packet.h"
30 #include "modules/rtp_rtcp/source/time_util.h"
31 #include "system_wrappers/include/clock.h"
32 #include "test/gmock.h"
33 #include "test/gtest.h"
34 #include "test/mock_transport.h"
35 #include "test/rtcp_packet_parser.h"
36
37 namespace webrtc {
38 namespace {
39
40 using ::testing::_;
41 using ::testing::ElementsAre;
42 using ::testing::ElementsAreArray;
43 using ::testing::Ge;
44 using ::testing::NiceMock;
45 using ::testing::Return;
46 using ::testing::SizeIs;
47 using ::testing::StrictMock;
48 using ::testing::UnorderedElementsAre;
49 using ::testing::WithArg;
50 using ::webrtc::rtcp::Bye;
51 using ::webrtc::rtcp::CompoundPacket;
52 using ::webrtc::rtcp::ReportBlock;
53 using ::webrtc::rtcp::SenderReport;
54 using ::webrtc::test::RtcpPacketParser;
55
56 class MockReceiveStatisticsProvider : public ReceiveStatisticsProvider {
57 public:
58 MOCK_METHOD(std::vector<ReportBlock>, RtcpReportBlocks, (size_t), (override));
59 };
60
61 class MockMediaReceiverRtcpObserver : public MediaReceiverRtcpObserver {
62 public:
63 MOCK_METHOD(void, OnSenderReport, (uint32_t, NtpTime, uint32_t), (override));
64 MOCK_METHOD(void, OnBye, (uint32_t), (override));
65 MOCK_METHOD(void,
66 OnBitrateAllocation,
67 (uint32_t, const VideoBitrateAllocation&),
68 (override));
69 };
70
71 class MockRtpStreamRtcpHandler : public RtpStreamRtcpHandler {
72 public:
MockRtpStreamRtcpHandler()73 MockRtpStreamRtcpHandler() {
74 // With each next call increase number of sent packets and bytes to simulate
75 // active RTP sender.
76 ON_CALL(*this, SentStats).WillByDefault([this] {
77 RtpStats stats;
78 stats.set_num_sent_packets(++num_calls_);
79 stats.set_num_sent_bytes(1'000 * num_calls_);
80 return stats;
81 });
82 }
83
84 MOCK_METHOD(RtpStats, SentStats, (), (override));
85 MOCK_METHOD(void,
86 OnNack,
87 (uint32_t, rtc::ArrayView<const uint16_t>),
88 (override));
89 MOCK_METHOD(void, OnFir, (uint32_t), (override));
90 MOCK_METHOD(void, OnPli, (uint32_t), (override));
91 MOCK_METHOD(void,
92 OnReportBlock,
93 (uint32_t, const rtcp::ReportBlock&),
94 (override));
95
96 private:
97 int num_calls_ = 0;
98 };
99
100 class MockNetworkLinkRtcpObserver : public NetworkLinkRtcpObserver {
101 public:
102 MOCK_METHOD(void,
103 OnRttUpdate,
104 (Timestamp receive_time, TimeDelta rtt),
105 (override));
106 MOCK_METHOD(void,
107 OnTransportFeedback,
108 (Timestamp receive_time, const rtcp::TransportFeedback& feedback),
109 (override));
110 MOCK_METHOD(void,
111 OnReceiverEstimatedMaxBitrate,
112 (Timestamp receive_time, DataRate bitrate),
113 (override));
114 MOCK_METHOD(void,
115 OnReportBlocks,
116 (Timestamp receive_time,
117 rtc::ArrayView<const rtcp::ReportBlock> report_blocks),
118 (override));
119 };
120
121 constexpr TimeDelta kReportPeriod = TimeDelta::Seconds(1);
122 constexpr TimeDelta kAlmostForever = TimeDelta::Seconds(2);
123 constexpr TimeDelta kTimePrecision = TimeDelta::Millis(1);
124
125 MATCHER_P(Near, value, "") {
126 return arg > value - kTimePrecision && arg < value + kTimePrecision;
127 }
128
129 // Helper to wait for an rtcp packet produced on a different thread/task queue.
130 class FakeRtcpTransport : public webrtc::Transport {
131 public:
FakeRtcpTransport(TimeController & time)132 explicit FakeRtcpTransport(TimeController& time) : time_(time) {}
133
SendRtcp(const uint8_t * data,size_t size)134 bool SendRtcp(const uint8_t* data, size_t size) override {
135 sent_rtcp_ = true;
136 return true;
137 }
SendRtp(const uint8_t *,size_t,const webrtc::PacketOptions &)138 bool SendRtp(const uint8_t*, size_t, const webrtc::PacketOptions&) override {
139 ADD_FAILURE() << "RtcpTransciver shouldn't send rtp packets.";
140 return true;
141 }
142
143 // Returns true when packet was received by the transport.
WaitPacket()144 bool WaitPacket() {
145 bool got_packet = time_.Wait([this] { return sent_rtcp_; }, kAlmostForever);
146 // Clear the 'event' to allow waiting for multiple packets.
147 sent_rtcp_ = false;
148 return got_packet;
149 }
150
151 private:
152 TimeController& time_;
153 bool sent_rtcp_ = false;
154 };
155
156 class RtcpParserTransport : public webrtc::Transport {
157 public:
RtcpParserTransport(RtcpPacketParser * parser)158 explicit RtcpParserTransport(RtcpPacketParser* parser) : parser_(parser) {}
159 // Returns total number of rtcp packet received.
num_packets() const160 int num_packets() const { return num_packets_; }
161
162 private:
SendRtcp(const uint8_t * data,size_t size)163 bool SendRtcp(const uint8_t* data, size_t size) override {
164 ++num_packets_;
165 parser_->Parse(data, size);
166 return true;
167 }
168
SendRtp(const uint8_t *,size_t,const webrtc::PacketOptions &)169 bool SendRtp(const uint8_t*, size_t, const webrtc::PacketOptions&) override {
170 ADD_FAILURE() << "RtcpTransciver shouldn't send rtp packets.";
171 return true;
172 }
173
174 RtcpPacketParser* const parser_;
175 int num_packets_ = 0;
176 };
177
178 class RtcpTransceiverImplTest : public ::testing::Test {
179 public:
DefaultTestConfig()180 RtcpTransceiverConfig DefaultTestConfig() {
181 // RtcpTransceiverConfig default constructor sets default values for prod.
182 // Test doesn't need to support all key features: Default test config
183 // returns valid config with all features turned off.
184 RtcpTransceiverConfig config;
185 config.clock = time_->GetClock();
186 config.outgoing_transport = &null_transport_;
187 config.schedule_periodic_compound_packets = false;
188 config.initial_report_delay = kReportPeriod / 2;
189 config.report_period = kReportPeriod;
190 return config;
191 }
192
time_controller()193 TimeController& time_controller() { return *time_; }
CurrentTime()194 Timestamp CurrentTime() { return time_->GetClock()->CurrentTime(); }
AdvanceTime(TimeDelta time)195 void AdvanceTime(TimeDelta time) { time_->AdvanceTime(time); }
CreateTaskQueue()196 std::unique_ptr<TaskQueueBase, TaskQueueDeleter> CreateTaskQueue() {
197 return time_->GetTaskQueueFactory()->CreateTaskQueue(
198 "rtcp", TaskQueueFactory::Priority::NORMAL);
199 }
200
201 private:
202 MockTransport null_transport_;
203 std::unique_ptr<TimeController> time_ = CreateSimulatedTimeController();
204 };
205
TEST_F(RtcpTransceiverImplTest,NeedToStopPeriodicTaskToDestroyOnTaskQueue)206 TEST_F(RtcpTransceiverImplTest, NeedToStopPeriodicTaskToDestroyOnTaskQueue) {
207 FakeRtcpTransport transport(time_controller());
208 auto queue = CreateTaskQueue();
209 RtcpTransceiverConfig config = DefaultTestConfig();
210 config.task_queue = queue.get();
211 config.schedule_periodic_compound_packets = true;
212 config.outgoing_transport = &transport;
213 auto* rtcp_transceiver = new RtcpTransceiverImpl(config);
214 // Wait for a periodic packet.
215 EXPECT_TRUE(transport.WaitPacket());
216
217 bool done = false;
218 queue->PostTask([rtcp_transceiver, &done] {
219 rtcp_transceiver->StopPeriodicTask();
220 delete rtcp_transceiver;
221 done = true;
222 });
223 ASSERT_TRUE(time_controller().Wait([&] { return done; }, kAlmostForever));
224 }
225
TEST_F(RtcpTransceiverImplTest,CanBeDestroyedRightAfterCreation)226 TEST_F(RtcpTransceiverImplTest, CanBeDestroyedRightAfterCreation) {
227 FakeRtcpTransport transport(time_controller());
228 auto queue = CreateTaskQueue();
229 RtcpTransceiverConfig config = DefaultTestConfig();
230 config.task_queue = queue.get();
231 config.schedule_periodic_compound_packets = true;
232 config.outgoing_transport = &transport;
233
234 bool done = false;
235 queue->PostTask([&] {
236 RtcpTransceiverImpl rtcp_transceiver(config);
237 rtcp_transceiver.StopPeriodicTask();
238 done = true;
239 });
240 ASSERT_TRUE(time_controller().Wait([&] { return done; }, kAlmostForever));
241 }
242
TEST_F(RtcpTransceiverImplTest,CanDestroyAfterTaskQueue)243 TEST_F(RtcpTransceiverImplTest, CanDestroyAfterTaskQueue) {
244 FakeRtcpTransport transport(time_controller());
245 auto queue = CreateTaskQueue();
246
247 RtcpTransceiverConfig config = DefaultTestConfig();
248 config.task_queue = queue.get();
249 config.schedule_periodic_compound_packets = true;
250 config.outgoing_transport = &transport;
251 auto* rtcp_transceiver = new RtcpTransceiverImpl(config);
252 // Wait for a periodic packet.
253 EXPECT_TRUE(transport.WaitPacket());
254
255 queue = nullptr;
256 delete rtcp_transceiver;
257 }
258
TEST_F(RtcpTransceiverImplTest,DelaysSendingFirstCompondPacket)259 TEST_F(RtcpTransceiverImplTest, DelaysSendingFirstCompondPacket) {
260 auto queue = CreateTaskQueue();
261 FakeRtcpTransport transport(time_controller());
262 RtcpTransceiverConfig config = DefaultTestConfig();
263 config.schedule_periodic_compound_packets = true;
264 config.outgoing_transport = &transport;
265 config.initial_report_delay = TimeDelta::Millis(10);
266 config.task_queue = queue.get();
267 absl::optional<RtcpTransceiverImpl> rtcp_transceiver;
268
269 Timestamp started = CurrentTime();
270 queue->PostTask([&] { rtcp_transceiver.emplace(config); });
271 EXPECT_TRUE(transport.WaitPacket());
272
273 EXPECT_GE(CurrentTime() - started, config.initial_report_delay);
274
275 // Cleanup.
276 bool done = false;
277 queue->PostTask([&] {
278 rtcp_transceiver->StopPeriodicTask();
279 rtcp_transceiver.reset();
280 done = true;
281 });
282 ASSERT_TRUE(time_controller().Wait([&] { return done; }, kAlmostForever));
283 }
284
TEST_F(RtcpTransceiverImplTest,PeriodicallySendsPackets)285 TEST_F(RtcpTransceiverImplTest, PeriodicallySendsPackets) {
286 auto queue = CreateTaskQueue();
287 FakeRtcpTransport transport(time_controller());
288 RtcpTransceiverConfig config = DefaultTestConfig();
289 config.schedule_periodic_compound_packets = true;
290 config.outgoing_transport = &transport;
291 config.initial_report_delay = TimeDelta::Zero();
292 config.report_period = kReportPeriod;
293 config.task_queue = queue.get();
294 absl::optional<RtcpTransceiverImpl> rtcp_transceiver;
295 Timestamp time_just_before_1st_packet = Timestamp::MinusInfinity();
296 queue->PostTask([&] {
297 // Because initial_report_delay_ms is set to 0, time_just_before_the_packet
298 // should be very close to the time_of_the_packet.
299 time_just_before_1st_packet = CurrentTime();
300 rtcp_transceiver.emplace(config);
301 });
302
303 EXPECT_TRUE(transport.WaitPacket());
304 EXPECT_TRUE(transport.WaitPacket());
305 Timestamp time_just_after_2nd_packet = CurrentTime();
306
307 EXPECT_GE(time_just_after_2nd_packet - time_just_before_1st_packet,
308 config.report_period);
309
310 // Cleanup.
311 bool done = false;
312 queue->PostTask([&] {
313 rtcp_transceiver->StopPeriodicTask();
314 rtcp_transceiver.reset();
315 done = true;
316 });
317 ASSERT_TRUE(time_controller().Wait([&] { return done; }, kAlmostForever));
318 }
319
TEST_F(RtcpTransceiverImplTest,SendCompoundPacketDelaysPeriodicSendPackets)320 TEST_F(RtcpTransceiverImplTest, SendCompoundPacketDelaysPeriodicSendPackets) {
321 auto queue = CreateTaskQueue();
322 FakeRtcpTransport transport(time_controller());
323 RtcpTransceiverConfig config = DefaultTestConfig();
324 config.schedule_periodic_compound_packets = true;
325 config.outgoing_transport = &transport;
326 config.initial_report_delay = TimeDelta::Zero();
327 config.report_period = kReportPeriod;
328 config.task_queue = queue.get();
329 absl::optional<RtcpTransceiverImpl> rtcp_transceiver;
330 queue->PostTask([&] { rtcp_transceiver.emplace(config); });
331
332 // Wait for the first packet.
333 EXPECT_TRUE(transport.WaitPacket());
334 // Send non periodic one after half period.
335 bool non_periodic = false;
336 Timestamp time_of_non_periodic_packet = Timestamp::MinusInfinity();
337 queue->PostDelayedTask(
338 [&] {
339 time_of_non_periodic_packet = CurrentTime();
340 rtcp_transceiver->SendCompoundPacket();
341 non_periodic = true;
342 },
343 config.report_period / 2);
344 // Though non-periodic packet is scheduled just in between periodic, due to
345 // small period and task queue flakiness it migth end-up 1ms after next
346 // periodic packet. To be sure duration after non-periodic packet is tested
347 // wait for transport after ensuring non-periodic packet was sent.
348 EXPECT_TRUE(
349 time_controller().Wait([&] { return non_periodic; }, kAlmostForever));
350 EXPECT_TRUE(transport.WaitPacket());
351 // Wait for next periodic packet.
352 EXPECT_TRUE(transport.WaitPacket());
353 Timestamp time_of_last_periodic_packet = CurrentTime();
354 EXPECT_GE(time_of_last_periodic_packet - time_of_non_periodic_packet,
355 config.report_period);
356
357 // Cleanup.
358 bool done = false;
359 queue->PostTask([&] {
360 rtcp_transceiver->StopPeriodicTask();
361 rtcp_transceiver.reset();
362 done = true;
363 });
364 ASSERT_TRUE(time_controller().Wait([&] { return done; }, kAlmostForever));
365 }
366
TEST_F(RtcpTransceiverImplTest,SendsNoRtcpWhenNetworkStateIsDown)367 TEST_F(RtcpTransceiverImplTest, SendsNoRtcpWhenNetworkStateIsDown) {
368 MockTransport mock_transport;
369 RtcpTransceiverConfig config = DefaultTestConfig();
370 config.initial_ready_to_send = false;
371 config.outgoing_transport = &mock_transport;
372 RtcpTransceiverImpl rtcp_transceiver(config);
373
374 EXPECT_CALL(mock_transport, SendRtcp(_, _)).Times(0);
375
376 const uint8_t raw[] = {1, 2, 3, 4};
377 const std::vector<uint16_t> sequence_numbers = {45, 57};
378 const uint32_t ssrcs[] = {123};
379 rtcp_transceiver.SendCompoundPacket();
380 rtcp_transceiver.SendRawPacket(raw);
381 rtcp_transceiver.SendNack(ssrcs[0], sequence_numbers);
382 rtcp_transceiver.SendPictureLossIndication(ssrcs[0]);
383 rtcp_transceiver.SendFullIntraRequest(ssrcs, true);
384 }
385
TEST_F(RtcpTransceiverImplTest,SendsRtcpWhenNetworkStateIsUp)386 TEST_F(RtcpTransceiverImplTest, SendsRtcpWhenNetworkStateIsUp) {
387 MockTransport mock_transport;
388 RtcpTransceiverConfig config = DefaultTestConfig();
389 config.initial_ready_to_send = false;
390 config.outgoing_transport = &mock_transport;
391 RtcpTransceiverImpl rtcp_transceiver(config);
392
393 rtcp_transceiver.SetReadyToSend(true);
394
395 EXPECT_CALL(mock_transport, SendRtcp(_, _)).Times(5);
396
397 const uint8_t raw[] = {1, 2, 3, 4};
398 const std::vector<uint16_t> sequence_numbers = {45, 57};
399 const uint32_t ssrcs[] = {123};
400 rtcp_transceiver.SendCompoundPacket();
401 rtcp_transceiver.SendRawPacket(raw);
402 rtcp_transceiver.SendNack(ssrcs[0], sequence_numbers);
403 rtcp_transceiver.SendPictureLossIndication(ssrcs[0]);
404 rtcp_transceiver.SendFullIntraRequest(ssrcs, true);
405 }
406
TEST_F(RtcpTransceiverImplTest,SendsPeriodicRtcpWhenNetworkStateIsUp)407 TEST_F(RtcpTransceiverImplTest, SendsPeriodicRtcpWhenNetworkStateIsUp) {
408 auto queue = CreateTaskQueue();
409 FakeRtcpTransport transport(time_controller());
410 RtcpTransceiverConfig config = DefaultTestConfig();
411 config.schedule_periodic_compound_packets = true;
412 config.initial_ready_to_send = false;
413 config.outgoing_transport = &transport;
414 config.task_queue = queue.get();
415 absl::optional<RtcpTransceiverImpl> rtcp_transceiver;
416 rtcp_transceiver.emplace(config);
417
418 queue->PostTask([&] { rtcp_transceiver->SetReadyToSend(true); });
419
420 EXPECT_TRUE(transport.WaitPacket());
421
422 // Cleanup.
423 bool done = false;
424 queue->PostTask([&] {
425 rtcp_transceiver->StopPeriodicTask();
426 rtcp_transceiver.reset();
427 done = true;
428 });
429 ASSERT_TRUE(time_controller().Wait([&] { return done; }, kAlmostForever));
430 }
431
TEST_F(RtcpTransceiverImplTest,SendsMinimalCompoundPacket)432 TEST_F(RtcpTransceiverImplTest, SendsMinimalCompoundPacket) {
433 const uint32_t kSenderSsrc = 12345;
434 RtcpTransceiverConfig config = DefaultTestConfig();
435 config.feedback_ssrc = kSenderSsrc;
436 config.cname = "cname";
437 RtcpPacketParser rtcp_parser;
438 RtcpParserTransport transport(&rtcp_parser);
439 config.outgoing_transport = &transport;
440 config.schedule_periodic_compound_packets = false;
441 RtcpTransceiverImpl rtcp_transceiver(config);
442
443 rtcp_transceiver.SendCompoundPacket();
444
445 // Minimal compound RTCP packet contains sender or receiver report and sdes
446 // with cname.
447 ASSERT_GT(rtcp_parser.receiver_report()->num_packets(), 0);
448 EXPECT_EQ(rtcp_parser.receiver_report()->sender_ssrc(), kSenderSsrc);
449 ASSERT_GT(rtcp_parser.sdes()->num_packets(), 0);
450 ASSERT_EQ(rtcp_parser.sdes()->chunks().size(), 1u);
451 EXPECT_EQ(rtcp_parser.sdes()->chunks()[0].ssrc, kSenderSsrc);
452 EXPECT_EQ(rtcp_parser.sdes()->chunks()[0].cname, config.cname);
453 }
454
TEST_F(RtcpTransceiverImplTest,AvoidsEmptyPacketsInReducedMode)455 TEST_F(RtcpTransceiverImplTest, AvoidsEmptyPacketsInReducedMode) {
456 MockTransport transport;
457 EXPECT_CALL(transport, SendRtcp).Times(0);
458 NiceMock<MockReceiveStatisticsProvider> receive_statistics;
459
460 RtcpTransceiverConfig config = DefaultTestConfig();
461 config.outgoing_transport = &transport;
462 config.rtcp_mode = webrtc::RtcpMode::kReducedSize;
463 config.receive_statistics = &receive_statistics;
464 RtcpTransceiverImpl rtcp_transceiver(config);
465
466 rtcp_transceiver.SendCompoundPacket();
467 }
468
TEST_F(RtcpTransceiverImplTest,AvoidsEmptyReceiverReportsInReducedMode)469 TEST_F(RtcpTransceiverImplTest, AvoidsEmptyReceiverReportsInReducedMode) {
470 RtcpPacketParser rtcp_parser;
471 RtcpParserTransport transport(&rtcp_parser);
472 NiceMock<MockReceiveStatisticsProvider> receive_statistics;
473
474 RtcpTransceiverConfig config = DefaultTestConfig();
475 config.outgoing_transport = &transport;
476 config.rtcp_mode = webrtc::RtcpMode::kReducedSize;
477 config.receive_statistics = &receive_statistics;
478 // Set it to produce something (RRTR) in the "periodic" rtcp packets.
479 config.non_sender_rtt_measurement = true;
480 RtcpTransceiverImpl rtcp_transceiver(config);
481
482 // Rather than waiting for the right time to produce the periodic packet,
483 // trigger it manually.
484 rtcp_transceiver.SendCompoundPacket();
485
486 EXPECT_EQ(rtcp_parser.receiver_report()->num_packets(), 0);
487 EXPECT_GT(rtcp_parser.xr()->num_packets(), 0);
488 }
489
TEST_F(RtcpTransceiverImplTest,SendsNoRembInitially)490 TEST_F(RtcpTransceiverImplTest, SendsNoRembInitially) {
491 const uint32_t kSenderSsrc = 12345;
492 RtcpTransceiverConfig config = DefaultTestConfig();
493 config.feedback_ssrc = kSenderSsrc;
494 RtcpPacketParser rtcp_parser;
495 RtcpParserTransport transport(&rtcp_parser);
496 config.outgoing_transport = &transport;
497 config.schedule_periodic_compound_packets = false;
498 RtcpTransceiverImpl rtcp_transceiver(config);
499
500 rtcp_transceiver.SendCompoundPacket();
501
502 EXPECT_EQ(transport.num_packets(), 1);
503 EXPECT_EQ(rtcp_parser.remb()->num_packets(), 0);
504 }
505
TEST_F(RtcpTransceiverImplTest,SetRembIncludesRembInNextCompoundPacket)506 TEST_F(RtcpTransceiverImplTest, SetRembIncludesRembInNextCompoundPacket) {
507 const uint32_t kSenderSsrc = 12345;
508 RtcpTransceiverConfig config = DefaultTestConfig();
509 config.feedback_ssrc = kSenderSsrc;
510 RtcpPacketParser rtcp_parser;
511 RtcpParserTransport transport(&rtcp_parser);
512 config.outgoing_transport = &transport;
513 config.schedule_periodic_compound_packets = false;
514 RtcpTransceiverImpl rtcp_transceiver(config);
515
516 rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{54321, 64321});
517 rtcp_transceiver.SendCompoundPacket();
518
519 EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
520 EXPECT_EQ(rtcp_parser.remb()->sender_ssrc(), kSenderSsrc);
521 EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 10000);
522 EXPECT_THAT(rtcp_parser.remb()->ssrcs(), ElementsAre(54321, 64321));
523 }
524
TEST_F(RtcpTransceiverImplTest,SetRembUpdatesValuesToSend)525 TEST_F(RtcpTransceiverImplTest, SetRembUpdatesValuesToSend) {
526 const uint32_t kSenderSsrc = 12345;
527 RtcpTransceiverConfig config = DefaultTestConfig();
528 config.feedback_ssrc = kSenderSsrc;
529 RtcpPacketParser rtcp_parser;
530 RtcpParserTransport transport(&rtcp_parser);
531 config.outgoing_transport = &transport;
532 config.schedule_periodic_compound_packets = false;
533 RtcpTransceiverImpl rtcp_transceiver(config);
534
535 rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{54321, 64321});
536 rtcp_transceiver.SendCompoundPacket();
537
538 EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
539 EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 10000);
540 EXPECT_THAT(rtcp_parser.remb()->ssrcs(), ElementsAre(54321, 64321));
541
542 rtcp_transceiver.SetRemb(/*bitrate_bps=*/70000, /*ssrcs=*/{67321});
543 rtcp_transceiver.SendCompoundPacket();
544
545 EXPECT_EQ(rtcp_parser.remb()->num_packets(), 2);
546 EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 70000);
547 EXPECT_THAT(rtcp_parser.remb()->ssrcs(), ElementsAre(67321));
548 }
549
TEST_F(RtcpTransceiverImplTest,SetRembSendsImmediatelyIfSendRembOnChange)550 TEST_F(RtcpTransceiverImplTest, SetRembSendsImmediatelyIfSendRembOnChange) {
551 const uint32_t kSenderSsrc = 12345;
552 RtcpTransceiverConfig config = DefaultTestConfig();
553 config.send_remb_on_change = true;
554 config.feedback_ssrc = kSenderSsrc;
555 RtcpPacketParser rtcp_parser;
556 RtcpParserTransport transport(&rtcp_parser);
557 config.outgoing_transport = &transport;
558 config.schedule_periodic_compound_packets = false;
559 RtcpTransceiverImpl rtcp_transceiver(config);
560
561 rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{});
562 EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
563 EXPECT_EQ(rtcp_parser.remb()->sender_ssrc(), kSenderSsrc);
564 EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 10000);
565
566 // If there is no change, the packet is not sent immediately.
567 rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{});
568 EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
569
570 rtcp_transceiver.SetRemb(/*bitrate_bps=*/20000, /*ssrcs=*/{});
571 EXPECT_EQ(rtcp_parser.remb()->num_packets(), 2);
572 EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 20000);
573 }
574
TEST_F(RtcpTransceiverImplTest,SetRembSendsImmediatelyIfSendRembOnChangeReducedSize)575 TEST_F(RtcpTransceiverImplTest,
576 SetRembSendsImmediatelyIfSendRembOnChangeReducedSize) {
577 const uint32_t kSenderSsrc = 12345;
578 RtcpTransceiverConfig config = DefaultTestConfig();
579 config.send_remb_on_change = true;
580 config.rtcp_mode = webrtc::RtcpMode::kReducedSize;
581 config.feedback_ssrc = kSenderSsrc;
582 RtcpPacketParser rtcp_parser;
583 RtcpParserTransport transport(&rtcp_parser);
584 config.outgoing_transport = &transport;
585 config.schedule_periodic_compound_packets = false;
586 RtcpTransceiverImpl rtcp_transceiver(config);
587
588 rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{});
589 EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
590 EXPECT_EQ(rtcp_parser.remb()->sender_ssrc(), kSenderSsrc);
591 EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 10000);
592 }
593
TEST_F(RtcpTransceiverImplTest,SetRembIncludesRembInAllCompoundPackets)594 TEST_F(RtcpTransceiverImplTest, SetRembIncludesRembInAllCompoundPackets) {
595 const uint32_t kSenderSsrc = 12345;
596 RtcpTransceiverConfig config = DefaultTestConfig();
597 config.feedback_ssrc = kSenderSsrc;
598 RtcpPacketParser rtcp_parser;
599 RtcpParserTransport transport(&rtcp_parser);
600 config.outgoing_transport = &transport;
601 config.schedule_periodic_compound_packets = false;
602 RtcpTransceiverImpl rtcp_transceiver(config);
603
604 rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{54321, 64321});
605 rtcp_transceiver.SendCompoundPacket();
606 rtcp_transceiver.SendCompoundPacket();
607
608 EXPECT_EQ(transport.num_packets(), 2);
609 EXPECT_EQ(rtcp_parser.remb()->num_packets(), 2);
610 }
611
TEST_F(RtcpTransceiverImplTest,SendsNoRembAfterUnset)612 TEST_F(RtcpTransceiverImplTest, SendsNoRembAfterUnset) {
613 const uint32_t kSenderSsrc = 12345;
614 RtcpTransceiverConfig config = DefaultTestConfig();
615 config.feedback_ssrc = kSenderSsrc;
616 RtcpPacketParser rtcp_parser;
617 RtcpParserTransport transport(&rtcp_parser);
618 config.outgoing_transport = &transport;
619 config.schedule_periodic_compound_packets = false;
620 RtcpTransceiverImpl rtcp_transceiver(config);
621
622 rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{54321, 64321});
623 rtcp_transceiver.SendCompoundPacket();
624 EXPECT_EQ(transport.num_packets(), 1);
625 ASSERT_EQ(rtcp_parser.remb()->num_packets(), 1);
626
627 rtcp_transceiver.UnsetRemb();
628 rtcp_transceiver.SendCompoundPacket();
629
630 EXPECT_EQ(transport.num_packets(), 2);
631 EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
632 }
633
TEST_F(RtcpTransceiverImplTest,ReceiverReportUsesReceiveStatistics)634 TEST_F(RtcpTransceiverImplTest, ReceiverReportUsesReceiveStatistics) {
635 const uint32_t kSenderSsrc = 12345;
636 const uint32_t kMediaSsrc = 54321;
637 MockReceiveStatisticsProvider receive_statistics;
638 std::vector<ReportBlock> report_blocks(1);
639 report_blocks[0].SetMediaSsrc(kMediaSsrc);
640 EXPECT_CALL(receive_statistics, RtcpReportBlocks(_))
641 .WillRepeatedly(Return(report_blocks));
642
643 RtcpTransceiverConfig config = DefaultTestConfig();
644 config.feedback_ssrc = kSenderSsrc;
645 RtcpPacketParser rtcp_parser;
646 RtcpParserTransport transport(&rtcp_parser);
647 config.outgoing_transport = &transport;
648 config.receive_statistics = &receive_statistics;
649 config.schedule_periodic_compound_packets = false;
650 RtcpTransceiverImpl rtcp_transceiver(config);
651
652 rtcp_transceiver.SendCompoundPacket();
653
654 ASSERT_GT(rtcp_parser.receiver_report()->num_packets(), 0);
655 EXPECT_EQ(rtcp_parser.receiver_report()->sender_ssrc(), kSenderSsrc);
656 ASSERT_THAT(rtcp_parser.receiver_report()->report_blocks(),
657 SizeIs(report_blocks.size()));
658 EXPECT_EQ(rtcp_parser.receiver_report()->report_blocks()[0].source_ssrc(),
659 kMediaSsrc);
660 }
661
TEST_F(RtcpTransceiverImplTest,MultipleObserversOnSameSsrc)662 TEST_F(RtcpTransceiverImplTest, MultipleObserversOnSameSsrc) {
663 const uint32_t kRemoteSsrc = 12345;
664 StrictMock<MockMediaReceiverRtcpObserver> observer1;
665 StrictMock<MockMediaReceiverRtcpObserver> observer2;
666 RtcpTransceiverConfig config = DefaultTestConfig();
667 RtcpTransceiverImpl rtcp_transceiver(config);
668 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer1);
669 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer2);
670
671 const NtpTime kRemoteNtp(0x9876543211);
672 const uint32_t kRemoteRtp = 0x444555;
673 SenderReport sr;
674 sr.SetSenderSsrc(kRemoteSsrc);
675 sr.SetNtp(kRemoteNtp);
676 sr.SetRtpTimestamp(kRemoteRtp);
677 auto raw_packet = sr.Build();
678
679 EXPECT_CALL(observer1, OnSenderReport(kRemoteSsrc, kRemoteNtp, kRemoteRtp));
680 EXPECT_CALL(observer2, OnSenderReport(kRemoteSsrc, kRemoteNtp, kRemoteRtp));
681 rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
682 }
683
TEST_F(RtcpTransceiverImplTest,DoesntCallsObserverAfterRemoved)684 TEST_F(RtcpTransceiverImplTest, DoesntCallsObserverAfterRemoved) {
685 const uint32_t kRemoteSsrc = 12345;
686 StrictMock<MockMediaReceiverRtcpObserver> observer1;
687 StrictMock<MockMediaReceiverRtcpObserver> observer2;
688 RtcpTransceiverConfig config = DefaultTestConfig();
689 RtcpTransceiverImpl rtcp_transceiver(config);
690 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer1);
691 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer2);
692
693 SenderReport sr;
694 sr.SetSenderSsrc(kRemoteSsrc);
695 auto raw_packet = sr.Build();
696
697 rtcp_transceiver.RemoveMediaReceiverRtcpObserver(kRemoteSsrc, &observer1);
698
699 EXPECT_CALL(observer1, OnSenderReport(_, _, _)).Times(0);
700 EXPECT_CALL(observer2, OnSenderReport(_, _, _));
701 rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
702 }
703
TEST_F(RtcpTransceiverImplTest,CallsObserverOnSenderReportBySenderSsrc)704 TEST_F(RtcpTransceiverImplTest, CallsObserverOnSenderReportBySenderSsrc) {
705 const uint32_t kRemoteSsrc1 = 12345;
706 const uint32_t kRemoteSsrc2 = 22345;
707 StrictMock<MockMediaReceiverRtcpObserver> observer1;
708 StrictMock<MockMediaReceiverRtcpObserver> observer2;
709 RtcpTransceiverConfig config = DefaultTestConfig();
710 RtcpTransceiverImpl rtcp_transceiver(config);
711 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc1, &observer1);
712 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc2, &observer2);
713
714 const NtpTime kRemoteNtp(0x9876543211);
715 const uint32_t kRemoteRtp = 0x444555;
716 SenderReport sr;
717 sr.SetSenderSsrc(kRemoteSsrc1);
718 sr.SetNtp(kRemoteNtp);
719 sr.SetRtpTimestamp(kRemoteRtp);
720 auto raw_packet = sr.Build();
721
722 EXPECT_CALL(observer1, OnSenderReport(kRemoteSsrc1, kRemoteNtp, kRemoteRtp));
723 EXPECT_CALL(observer2, OnSenderReport).Times(0);
724 rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
725 }
726
TEST_F(RtcpTransceiverImplTest,CallsObserverOnByeBySenderSsrc)727 TEST_F(RtcpTransceiverImplTest, CallsObserverOnByeBySenderSsrc) {
728 const uint32_t kRemoteSsrc1 = 12345;
729 const uint32_t kRemoteSsrc2 = 22345;
730 StrictMock<MockMediaReceiverRtcpObserver> observer1;
731 StrictMock<MockMediaReceiverRtcpObserver> observer2;
732 RtcpTransceiverConfig config = DefaultTestConfig();
733 RtcpTransceiverImpl rtcp_transceiver(config);
734 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc1, &observer1);
735 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc2, &observer2);
736
737 Bye bye;
738 bye.SetSenderSsrc(kRemoteSsrc1);
739 auto raw_packet = bye.Build();
740
741 EXPECT_CALL(observer1, OnBye(kRemoteSsrc1));
742 EXPECT_CALL(observer2, OnBye(_)).Times(0);
743 rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
744 }
745
TEST_F(RtcpTransceiverImplTest,CallsObserverOnTargetBitrateBySenderSsrc)746 TEST_F(RtcpTransceiverImplTest, CallsObserverOnTargetBitrateBySenderSsrc) {
747 const uint32_t kRemoteSsrc1 = 12345;
748 const uint32_t kRemoteSsrc2 = 22345;
749 StrictMock<MockMediaReceiverRtcpObserver> observer1;
750 StrictMock<MockMediaReceiverRtcpObserver> observer2;
751 RtcpTransceiverConfig config = DefaultTestConfig();
752 RtcpTransceiverImpl rtcp_transceiver(config);
753 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc1, &observer1);
754 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc2, &observer2);
755
756 webrtc::rtcp::TargetBitrate target_bitrate;
757 target_bitrate.AddTargetBitrate(0, 0, /*target_bitrate_kbps=*/10);
758 target_bitrate.AddTargetBitrate(0, 1, /*target_bitrate_kbps=*/20);
759 target_bitrate.AddTargetBitrate(1, 0, /*target_bitrate_kbps=*/40);
760 target_bitrate.AddTargetBitrate(1, 1, /*target_bitrate_kbps=*/80);
761 webrtc::rtcp::ExtendedReports xr;
762 xr.SetSenderSsrc(kRemoteSsrc1);
763 xr.SetTargetBitrate(target_bitrate);
764 auto raw_packet = xr.Build();
765
766 VideoBitrateAllocation bitrate_allocation;
767 bitrate_allocation.SetBitrate(0, 0, /*bitrate_bps=*/10000);
768 bitrate_allocation.SetBitrate(0, 1, /*bitrate_bps=*/20000);
769 bitrate_allocation.SetBitrate(1, 0, /*bitrate_bps=*/40000);
770 bitrate_allocation.SetBitrate(1, 1, /*bitrate_bps=*/80000);
771 EXPECT_CALL(observer1, OnBitrateAllocation(kRemoteSsrc1, bitrate_allocation));
772 EXPECT_CALL(observer2, OnBitrateAllocation(_, _)).Times(0);
773 rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
774 }
775
TEST_F(RtcpTransceiverImplTest,SkipsIncorrectTargetBitrateEntries)776 TEST_F(RtcpTransceiverImplTest, SkipsIncorrectTargetBitrateEntries) {
777 const uint32_t kRemoteSsrc = 12345;
778 MockMediaReceiverRtcpObserver observer;
779 RtcpTransceiverConfig config = DefaultTestConfig();
780 RtcpTransceiverImpl rtcp_transceiver(config);
781 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer);
782
783 webrtc::rtcp::TargetBitrate target_bitrate;
784 target_bitrate.AddTargetBitrate(0, 0, /*target_bitrate_kbps=*/10);
785 target_bitrate.AddTargetBitrate(0, webrtc::kMaxTemporalStreams, 20);
786 target_bitrate.AddTargetBitrate(webrtc::kMaxSpatialLayers, 0, 40);
787
788 webrtc::rtcp::ExtendedReports xr;
789 xr.SetTargetBitrate(target_bitrate);
790 xr.SetSenderSsrc(kRemoteSsrc);
791 auto raw_packet = xr.Build();
792
793 VideoBitrateAllocation expected_allocation;
794 expected_allocation.SetBitrate(0, 0, /*bitrate_bps=*/10000);
795 EXPECT_CALL(observer, OnBitrateAllocation(kRemoteSsrc, expected_allocation));
796 rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
797 }
798
TEST_F(RtcpTransceiverImplTest,CallsObserverOnByeBehindSenderReport)799 TEST_F(RtcpTransceiverImplTest, CallsObserverOnByeBehindSenderReport) {
800 const uint32_t kRemoteSsrc = 12345;
801 MockMediaReceiverRtcpObserver observer;
802 RtcpTransceiverConfig config = DefaultTestConfig();
803 RtcpTransceiverImpl rtcp_transceiver(config);
804 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer);
805
806 CompoundPacket compound;
807 auto sr = std::make_unique<SenderReport>();
808 sr->SetSenderSsrc(kRemoteSsrc);
809 compound.Append(std::move(sr));
810 auto bye = std::make_unique<Bye>();
811 bye->SetSenderSsrc(kRemoteSsrc);
812 compound.Append(std::move(bye));
813 auto raw_packet = compound.Build();
814
815 EXPECT_CALL(observer, OnBye(kRemoteSsrc));
816 EXPECT_CALL(observer, OnSenderReport(kRemoteSsrc, _, _));
817 rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
818 }
819
TEST_F(RtcpTransceiverImplTest,CallsObserverOnByeBehindUnknownRtcpPacket)820 TEST_F(RtcpTransceiverImplTest, CallsObserverOnByeBehindUnknownRtcpPacket) {
821 const uint32_t kRemoteSsrc = 12345;
822 MockMediaReceiverRtcpObserver observer;
823 RtcpTransceiverConfig config = DefaultTestConfig();
824 RtcpTransceiverImpl rtcp_transceiver(config);
825 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer);
826
827 CompoundPacket compound;
828 // Use Application-Defined rtcp packet as unknown.
829 auto app = std::make_unique<webrtc::rtcp::App>();
830 compound.Append(std::move(app));
831 auto bye = std::make_unique<Bye>();
832 bye->SetSenderSsrc(kRemoteSsrc);
833 compound.Append(std::move(bye));
834 auto raw_packet = compound.Build();
835
836 EXPECT_CALL(observer, OnBye(kRemoteSsrc));
837 rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
838 }
839
TEST_F(RtcpTransceiverImplTest,WhenSendsReceiverReportSetsLastSenderReportTimestampPerRemoteSsrc)840 TEST_F(RtcpTransceiverImplTest,
841 WhenSendsReceiverReportSetsLastSenderReportTimestampPerRemoteSsrc) {
842 const uint32_t kRemoteSsrc1 = 4321;
843 const uint32_t kRemoteSsrc2 = 5321;
844 std::vector<ReportBlock> statistics_report_blocks(2);
845 statistics_report_blocks[0].SetMediaSsrc(kRemoteSsrc1);
846 statistics_report_blocks[1].SetMediaSsrc(kRemoteSsrc2);
847 MockReceiveStatisticsProvider receive_statistics;
848 EXPECT_CALL(receive_statistics, RtcpReportBlocks(_))
849 .WillOnce(Return(statistics_report_blocks));
850
851 RtcpTransceiverConfig config = DefaultTestConfig();
852 config.schedule_periodic_compound_packets = false;
853 RtcpPacketParser rtcp_parser;
854 RtcpParserTransport transport(&rtcp_parser);
855 config.outgoing_transport = &transport;
856 config.receive_statistics = &receive_statistics;
857 RtcpTransceiverImpl rtcp_transceiver(config);
858
859 const NtpTime kRemoteNtp(0x9876543211);
860 // Receive SenderReport for RemoteSsrc1, but no report for RemoteSsrc2.
861 SenderReport sr;
862 sr.SetSenderSsrc(kRemoteSsrc1);
863 sr.SetNtp(kRemoteNtp);
864 auto raw_packet = sr.Build();
865 rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
866
867 // Trigger sending ReceiverReport.
868 rtcp_transceiver.SendCompoundPacket();
869
870 EXPECT_GT(rtcp_parser.receiver_report()->num_packets(), 0);
871 const auto& report_blocks = rtcp_parser.receiver_report()->report_blocks();
872 ASSERT_EQ(report_blocks.size(), 2u);
873 // RtcpTransceiverImpl doesn't guarantee order of the report blocks
874 // match result of ReceiveStatisticsProvider::RtcpReportBlocks callback,
875 // but for simplicity of the test asume it is the same.
876 ASSERT_EQ(report_blocks[0].source_ssrc(), kRemoteSsrc1);
877 EXPECT_EQ(report_blocks[0].last_sr(), CompactNtp(kRemoteNtp));
878
879 ASSERT_EQ(report_blocks[1].source_ssrc(), kRemoteSsrc2);
880 // No matching Sender Report for kRemoteSsrc2, LastSR fields has to be 0.
881 EXPECT_EQ(report_blocks[1].last_sr(), 0u);
882 }
883
TEST_F(RtcpTransceiverImplTest,WhenSendsReceiverReportCalculatesDelaySinceLastSenderReport)884 TEST_F(RtcpTransceiverImplTest,
885 WhenSendsReceiverReportCalculatesDelaySinceLastSenderReport) {
886 const uint32_t kRemoteSsrc1 = 4321;
887 const uint32_t kRemoteSsrc2 = 5321;
888
889 std::vector<ReportBlock> statistics_report_blocks(2);
890 statistics_report_blocks[0].SetMediaSsrc(kRemoteSsrc1);
891 statistics_report_blocks[1].SetMediaSsrc(kRemoteSsrc2);
892 MockReceiveStatisticsProvider receive_statistics;
893 EXPECT_CALL(receive_statistics, RtcpReportBlocks(_))
894 .WillOnce(Return(statistics_report_blocks));
895
896 RtcpTransceiverConfig config = DefaultTestConfig();
897 config.schedule_periodic_compound_packets = false;
898 RtcpPacketParser rtcp_parser;
899 RtcpParserTransport transport(&rtcp_parser);
900 config.outgoing_transport = &transport;
901 config.receive_statistics = &receive_statistics;
902 RtcpTransceiverImpl rtcp_transceiver(config);
903
904 auto receive_sender_report = [&](uint32_t remote_ssrc) {
905 SenderReport sr;
906 sr.SetSenderSsrc(remote_ssrc);
907 rtcp_transceiver.ReceivePacket(sr.Build(), CurrentTime());
908 };
909
910 receive_sender_report(kRemoteSsrc1);
911 time_controller().AdvanceTime(TimeDelta::Millis(100));
912
913 receive_sender_report(kRemoteSsrc2);
914 time_controller().AdvanceTime(TimeDelta::Millis(100));
915
916 // Trigger ReceiverReport back.
917 rtcp_transceiver.SendCompoundPacket();
918
919 EXPECT_GT(rtcp_parser.receiver_report()->num_packets(), 0);
920 const auto& report_blocks = rtcp_parser.receiver_report()->report_blocks();
921 ASSERT_EQ(report_blocks.size(), 2u);
922 // RtcpTransceiverImpl doesn't guarantee order of the report blocks
923 // match result of ReceiveStatisticsProvider::RtcpReportBlocks callback,
924 // but for simplicity of the test asume it is the same.
925 ASSERT_EQ(report_blocks[0].source_ssrc(), kRemoteSsrc1);
926 EXPECT_THAT(CompactNtpRttToTimeDelta(report_blocks[0].delay_since_last_sr()),
927 Near(TimeDelta::Millis(200)));
928
929 ASSERT_EQ(report_blocks[1].source_ssrc(), kRemoteSsrc2);
930 EXPECT_THAT(CompactNtpRttToTimeDelta(report_blocks[1].delay_since_last_sr()),
931 Near(TimeDelta::Millis(100)));
932 }
933
TEST_F(RtcpTransceiverImplTest,MaySendMultipleReceiverReportInSinglePacket)934 TEST_F(RtcpTransceiverImplTest, MaySendMultipleReceiverReportInSinglePacket) {
935 std::vector<ReportBlock> statistics_report_blocks(40);
936 MockReceiveStatisticsProvider receive_statistics;
937 EXPECT_CALL(receive_statistics, RtcpReportBlocks(/*max_blocks=*/Ge(40u)))
938 .WillOnce(Return(statistics_report_blocks));
939
940 RtcpTransceiverConfig config = DefaultTestConfig();
941 RtcpPacketParser rtcp_parser;
942 RtcpParserTransport transport(&rtcp_parser);
943 config.outgoing_transport = &transport;
944 config.receive_statistics = &receive_statistics;
945 RtcpTransceiverImpl rtcp_transceiver(config);
946
947 // Trigger ReceiverReports.
948 rtcp_transceiver.SendCompoundPacket();
949
950 // Expect a single RTCP packet with multiple receiver reports in it.
951 EXPECT_EQ(transport.num_packets(), 1);
952 // Receiver report may contain up to 31 report blocks, thus 2 reports are
953 // needed to carry 40 blocks: 31 in the first, 9 in the last.
954 EXPECT_EQ(rtcp_parser.receiver_report()->num_packets(), 2);
955 // RtcpParser remembers just the last receiver report, thus can't check number
956 // of blocks in the first receiver report.
957 EXPECT_THAT(rtcp_parser.receiver_report()->report_blocks(), SizeIs(9));
958 }
959
TEST_F(RtcpTransceiverImplTest,AttachMaxNumberOfReportBlocksToCompoundPacket)960 TEST_F(RtcpTransceiverImplTest, AttachMaxNumberOfReportBlocksToCompoundPacket) {
961 MockReceiveStatisticsProvider receive_statistics;
962 EXPECT_CALL(receive_statistics, RtcpReportBlocks)
963 .WillOnce([](size_t max_blocks) {
964 return std::vector<ReportBlock>(max_blocks);
965 });
966 RtcpTransceiverConfig config = DefaultTestConfig();
967 config.rtcp_mode = RtcpMode::kCompound;
968 RtcpPacketParser rtcp_parser;
969 RtcpParserTransport transport(&rtcp_parser);
970 config.outgoing_transport = &transport;
971 config.receive_statistics = &receive_statistics;
972 RtcpTransceiverImpl rtcp_transceiver(config);
973
974 EXPECT_EQ(transport.num_packets(), 0);
975 // Send some fast feedback message. Because of compound mode, report blocks
976 // should be attached.
977 rtcp_transceiver.SendPictureLossIndication(/*ssrc=*/123);
978
979 // Expect single RTCP packet with multiple receiver reports and a PLI.
980 EXPECT_EQ(transport.num_packets(), 1);
981 EXPECT_GT(rtcp_parser.receiver_report()->num_packets(), 1);
982 EXPECT_EQ(rtcp_parser.pli()->num_packets(), 1);
983 }
984
TEST_F(RtcpTransceiverImplTest,SendsNack)985 TEST_F(RtcpTransceiverImplTest, SendsNack) {
986 const uint32_t kSenderSsrc = 1234;
987 const uint32_t kRemoteSsrc = 4321;
988 std::vector<uint16_t> kMissingSequenceNumbers = {34, 37, 38};
989 RtcpTransceiverConfig config = DefaultTestConfig();
990 config.feedback_ssrc = kSenderSsrc;
991 config.schedule_periodic_compound_packets = false;
992 RtcpPacketParser rtcp_parser;
993 RtcpParserTransport transport(&rtcp_parser);
994 config.outgoing_transport = &transport;
995 RtcpTransceiverImpl rtcp_transceiver(config);
996
997 rtcp_transceiver.SendNack(kRemoteSsrc, kMissingSequenceNumbers);
998
999 EXPECT_EQ(rtcp_parser.nack()->num_packets(), 1);
1000 EXPECT_EQ(rtcp_parser.nack()->sender_ssrc(), kSenderSsrc);
1001 EXPECT_EQ(rtcp_parser.nack()->media_ssrc(), kRemoteSsrc);
1002 EXPECT_EQ(rtcp_parser.nack()->packet_ids(), kMissingSequenceNumbers);
1003 }
1004
TEST_F(RtcpTransceiverImplTest,ReceivesNack)1005 TEST_F(RtcpTransceiverImplTest, ReceivesNack) {
1006 static constexpr uint32_t kRemoteSsrc = 4321;
1007 static constexpr uint32_t kMediaSsrc1 = 1234;
1008 static constexpr uint32_t kMediaSsrc2 = 1235;
1009 std::vector<uint16_t> kMissingSequenceNumbers = {34, 37, 38};
1010 RtcpTransceiverConfig config = DefaultTestConfig();
1011 RtcpTransceiverImpl rtcp_transceiver(config);
1012
1013 MockRtpStreamRtcpHandler local_stream1;
1014 MockRtpStreamRtcpHandler local_stream2;
1015 EXPECT_CALL(local_stream1,
1016 OnNack(kRemoteSsrc, ElementsAreArray(kMissingSequenceNumbers)));
1017 EXPECT_CALL(local_stream2, OnNack).Times(0);
1018
1019 EXPECT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc1, &local_stream1));
1020 EXPECT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc2, &local_stream2));
1021
1022 rtcp::Nack nack;
1023 nack.SetSenderSsrc(kRemoteSsrc);
1024 nack.SetMediaSsrc(kMediaSsrc1);
1025 nack.SetPacketIds(kMissingSequenceNumbers);
1026 rtcp_transceiver.ReceivePacket(nack.Build(), config.clock->CurrentTime());
1027 }
1028
TEST_F(RtcpTransceiverImplTest,RequestKeyFrameWithPictureLossIndication)1029 TEST_F(RtcpTransceiverImplTest, RequestKeyFrameWithPictureLossIndication) {
1030 const uint32_t kSenderSsrc = 1234;
1031 const uint32_t kRemoteSsrc = 4321;
1032 RtcpTransceiverConfig config = DefaultTestConfig();
1033 config.feedback_ssrc = kSenderSsrc;
1034 config.schedule_periodic_compound_packets = false;
1035 RtcpPacketParser rtcp_parser;
1036 RtcpParserTransport transport(&rtcp_parser);
1037 config.outgoing_transport = &transport;
1038 RtcpTransceiverImpl rtcp_transceiver(config);
1039
1040 rtcp_transceiver.SendPictureLossIndication(kRemoteSsrc);
1041
1042 EXPECT_EQ(transport.num_packets(), 1);
1043 EXPECT_EQ(rtcp_parser.pli()->num_packets(), 1);
1044 EXPECT_EQ(rtcp_parser.pli()->sender_ssrc(), kSenderSsrc);
1045 EXPECT_EQ(rtcp_parser.pli()->media_ssrc(), kRemoteSsrc);
1046 }
1047
TEST_F(RtcpTransceiverImplTest,ReceivesPictureLossIndication)1048 TEST_F(RtcpTransceiverImplTest, ReceivesPictureLossIndication) {
1049 static constexpr uint32_t kRemoteSsrc = 4321;
1050 static constexpr uint32_t kMediaSsrc1 = 1234;
1051 static constexpr uint32_t kMediaSsrc2 = 1235;
1052 RtcpTransceiverConfig config = DefaultTestConfig();
1053 RtcpTransceiverImpl rtcp_transceiver(config);
1054
1055 MockRtpStreamRtcpHandler local_stream1;
1056 MockRtpStreamRtcpHandler local_stream2;
1057 EXPECT_CALL(local_stream1, OnPli(kRemoteSsrc));
1058 EXPECT_CALL(local_stream2, OnPli).Times(0);
1059
1060 EXPECT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc1, &local_stream1));
1061 EXPECT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc2, &local_stream2));
1062
1063 rtcp::Pli pli;
1064 pli.SetSenderSsrc(kRemoteSsrc);
1065 pli.SetMediaSsrc(kMediaSsrc1);
1066 rtcp_transceiver.ReceivePacket(pli.Build(), config.clock->CurrentTime());
1067 }
1068
TEST_F(RtcpTransceiverImplTest,RequestKeyFrameWithFullIntraRequest)1069 TEST_F(RtcpTransceiverImplTest, RequestKeyFrameWithFullIntraRequest) {
1070 const uint32_t kSenderSsrc = 1234;
1071 const uint32_t kRemoteSsrcs[] = {4321, 5321};
1072 RtcpTransceiverConfig config = DefaultTestConfig();
1073 config.feedback_ssrc = kSenderSsrc;
1074 config.schedule_periodic_compound_packets = false;
1075 RtcpPacketParser rtcp_parser;
1076 RtcpParserTransport transport(&rtcp_parser);
1077 config.outgoing_transport = &transport;
1078 RtcpTransceiverImpl rtcp_transceiver(config);
1079
1080 rtcp_transceiver.SendFullIntraRequest(kRemoteSsrcs, true);
1081
1082 EXPECT_EQ(rtcp_parser.fir()->num_packets(), 1);
1083 EXPECT_EQ(rtcp_parser.fir()->sender_ssrc(), kSenderSsrc);
1084 EXPECT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kRemoteSsrcs[0]);
1085 EXPECT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kRemoteSsrcs[1]);
1086 }
1087
TEST_F(RtcpTransceiverImplTest,RequestKeyFrameWithFirIncreaseSeqNoPerSsrc)1088 TEST_F(RtcpTransceiverImplTest, RequestKeyFrameWithFirIncreaseSeqNoPerSsrc) {
1089 RtcpTransceiverConfig config = DefaultTestConfig();
1090 config.schedule_periodic_compound_packets = false;
1091 RtcpPacketParser rtcp_parser;
1092 RtcpParserTransport transport(&rtcp_parser);
1093 config.outgoing_transport = &transport;
1094 RtcpTransceiverImpl rtcp_transceiver(config);
1095
1096 const uint32_t kBothRemoteSsrcs[] = {4321, 5321};
1097 const uint32_t kOneRemoteSsrc[] = {4321};
1098
1099 rtcp_transceiver.SendFullIntraRequest(kBothRemoteSsrcs, true);
1100 ASSERT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kBothRemoteSsrcs[0]);
1101 uint8_t fir_sequence_number0 = rtcp_parser.fir()->requests()[0].seq_nr;
1102 ASSERT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kBothRemoteSsrcs[1]);
1103 uint8_t fir_sequence_number1 = rtcp_parser.fir()->requests()[1].seq_nr;
1104
1105 rtcp_transceiver.SendFullIntraRequest(kOneRemoteSsrc, true);
1106 ASSERT_EQ(rtcp_parser.fir()->requests().size(), 1u);
1107 ASSERT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kBothRemoteSsrcs[0]);
1108 EXPECT_EQ(rtcp_parser.fir()->requests()[0].seq_nr, fir_sequence_number0 + 1);
1109
1110 rtcp_transceiver.SendFullIntraRequest(kBothRemoteSsrcs, true);
1111 ASSERT_EQ(rtcp_parser.fir()->requests().size(), 2u);
1112 ASSERT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kBothRemoteSsrcs[0]);
1113 EXPECT_EQ(rtcp_parser.fir()->requests()[0].seq_nr, fir_sequence_number0 + 2);
1114 ASSERT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kBothRemoteSsrcs[1]);
1115 EXPECT_EQ(rtcp_parser.fir()->requests()[1].seq_nr, fir_sequence_number1 + 1);
1116 }
1117
TEST_F(RtcpTransceiverImplTest,SendFirDoesNotIncreaseSeqNoIfOldRequest)1118 TEST_F(RtcpTransceiverImplTest, SendFirDoesNotIncreaseSeqNoIfOldRequest) {
1119 RtcpTransceiverConfig config = DefaultTestConfig();
1120 config.schedule_periodic_compound_packets = false;
1121 RtcpPacketParser rtcp_parser;
1122 RtcpParserTransport transport(&rtcp_parser);
1123 config.outgoing_transport = &transport;
1124 RtcpTransceiverImpl rtcp_transceiver(config);
1125
1126 const uint32_t kBothRemoteSsrcs[] = {4321, 5321};
1127
1128 rtcp_transceiver.SendFullIntraRequest(kBothRemoteSsrcs, true);
1129 ASSERT_EQ(rtcp_parser.fir()->requests().size(), 2u);
1130 ASSERT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kBothRemoteSsrcs[0]);
1131 uint8_t fir_sequence_number0 = rtcp_parser.fir()->requests()[0].seq_nr;
1132 ASSERT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kBothRemoteSsrcs[1]);
1133 uint8_t fir_sequence_number1 = rtcp_parser.fir()->requests()[1].seq_nr;
1134
1135 rtcp_transceiver.SendFullIntraRequest(kBothRemoteSsrcs, false);
1136 ASSERT_EQ(rtcp_parser.fir()->requests().size(), 2u);
1137 ASSERT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kBothRemoteSsrcs[0]);
1138 EXPECT_EQ(rtcp_parser.fir()->requests()[0].seq_nr, fir_sequence_number0);
1139 ASSERT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kBothRemoteSsrcs[1]);
1140 EXPECT_EQ(rtcp_parser.fir()->requests()[1].seq_nr, fir_sequence_number1);
1141 }
1142
TEST_F(RtcpTransceiverImplTest,ReceivesFir)1143 TEST_F(RtcpTransceiverImplTest, ReceivesFir) {
1144 static constexpr uint32_t kRemoteSsrc = 4321;
1145 static constexpr uint32_t kMediaSsrc1 = 1234;
1146 static constexpr uint32_t kMediaSsrc2 = 1235;
1147 RtcpTransceiverConfig config = DefaultTestConfig();
1148 RtcpTransceiverImpl rtcp_transceiver(config);
1149
1150 MockRtpStreamRtcpHandler local_stream1;
1151 MockRtpStreamRtcpHandler local_stream2;
1152 EXPECT_CALL(local_stream1, OnFir(kRemoteSsrc));
1153 EXPECT_CALL(local_stream2, OnFir).Times(0);
1154
1155 EXPECT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc1, &local_stream1));
1156 EXPECT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc2, &local_stream2));
1157
1158 rtcp::Fir fir;
1159 fir.SetSenderSsrc(kRemoteSsrc);
1160 fir.AddRequestTo(kMediaSsrc1, /*seq_num=*/13);
1161
1162 rtcp_transceiver.ReceivePacket(fir.Build(), config.clock->CurrentTime());
1163 }
1164
TEST_F(RtcpTransceiverImplTest,IgnoresReceivedFirWithRepeatedSequenceNumber)1165 TEST_F(RtcpTransceiverImplTest, IgnoresReceivedFirWithRepeatedSequenceNumber) {
1166 static constexpr uint32_t kRemoteSsrc = 4321;
1167 static constexpr uint32_t kMediaSsrc1 = 1234;
1168 static constexpr uint32_t kMediaSsrc2 = 1235;
1169 RtcpTransceiverConfig config = DefaultTestConfig();
1170 RtcpTransceiverImpl rtcp_transceiver(config);
1171
1172 MockRtpStreamRtcpHandler local_stream1;
1173 MockRtpStreamRtcpHandler local_stream2;
1174 EXPECT_CALL(local_stream1, OnFir(kRemoteSsrc)).Times(1);
1175 EXPECT_CALL(local_stream2, OnFir(kRemoteSsrc)).Times(2);
1176
1177 EXPECT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc1, &local_stream1));
1178 EXPECT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc2, &local_stream2));
1179
1180 rtcp::Fir fir1;
1181 fir1.SetSenderSsrc(kRemoteSsrc);
1182 fir1.AddRequestTo(kMediaSsrc1, /*seq_num=*/132);
1183 fir1.AddRequestTo(kMediaSsrc2, /*seq_num=*/10);
1184 rtcp_transceiver.ReceivePacket(fir1.Build(), config.clock->CurrentTime());
1185
1186 // Repeat request for MediaSsrc1 - expect it to be ignored,
1187 // Change FIR sequence number for MediaSsrc2 - expect a 2nd callback.
1188 rtcp::Fir fir2;
1189 fir2.SetSenderSsrc(kRemoteSsrc);
1190 fir2.AddRequestTo(kMediaSsrc1, /*seq_num=*/132);
1191 fir2.AddRequestTo(kMediaSsrc2, /*seq_num=*/13);
1192 rtcp_transceiver.ReceivePacket(fir2.Build(), config.clock->CurrentTime());
1193 }
1194
TEST_F(RtcpTransceiverImplTest,ReceivedFirTracksSequenceNumberPerRemoteSsrc)1195 TEST_F(RtcpTransceiverImplTest, ReceivedFirTracksSequenceNumberPerRemoteSsrc) {
1196 static constexpr uint32_t kRemoteSsrc1 = 4321;
1197 static constexpr uint32_t kRemoteSsrc2 = 4323;
1198 static constexpr uint32_t kMediaSsrc = 1234;
1199 RtcpTransceiverConfig config = DefaultTestConfig();
1200 RtcpTransceiverImpl rtcp_transceiver(config);
1201
1202 MockRtpStreamRtcpHandler local_stream;
1203 EXPECT_CALL(local_stream, OnFir(kRemoteSsrc1));
1204 EXPECT_CALL(local_stream, OnFir(kRemoteSsrc2));
1205
1206 EXPECT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc, &local_stream));
1207
1208 rtcp::Fir fir1;
1209 fir1.SetSenderSsrc(kRemoteSsrc1);
1210 fir1.AddRequestTo(kMediaSsrc, /*seq_num=*/13);
1211 rtcp_transceiver.ReceivePacket(fir1.Build(), config.clock->CurrentTime());
1212
1213 // Use the same FIR sequence number, but different sender SSRC.
1214 rtcp::Fir fir2;
1215 fir2.SetSenderSsrc(kRemoteSsrc2);
1216 fir2.AddRequestTo(kMediaSsrc, /*seq_num=*/13);
1217 rtcp_transceiver.ReceivePacket(fir2.Build(), config.clock->CurrentTime());
1218 }
1219
TEST_F(RtcpTransceiverImplTest,KeyFrameRequestCreatesCompoundPacket)1220 TEST_F(RtcpTransceiverImplTest, KeyFrameRequestCreatesCompoundPacket) {
1221 const uint32_t kRemoteSsrcs[] = {4321};
1222 RtcpTransceiverConfig config = DefaultTestConfig();
1223 // Turn periodic off to ensure sent rtcp packet is explicitly requested.
1224 config.schedule_periodic_compound_packets = false;
1225 RtcpPacketParser rtcp_parser;
1226 RtcpParserTransport transport(&rtcp_parser);
1227 config.outgoing_transport = &transport;
1228
1229 config.rtcp_mode = webrtc::RtcpMode::kCompound;
1230
1231 RtcpTransceiverImpl rtcp_transceiver(config);
1232 rtcp_transceiver.SendFullIntraRequest(kRemoteSsrcs, true);
1233
1234 // Test sent packet is compound by expecting presense of receiver report.
1235 EXPECT_EQ(transport.num_packets(), 1);
1236 EXPECT_EQ(rtcp_parser.receiver_report()->num_packets(), 1);
1237 }
1238
TEST_F(RtcpTransceiverImplTest,KeyFrameRequestCreatesReducedSizePacket)1239 TEST_F(RtcpTransceiverImplTest, KeyFrameRequestCreatesReducedSizePacket) {
1240 const uint32_t kRemoteSsrcs[] = {4321};
1241 RtcpTransceiverConfig config = DefaultTestConfig();
1242 // Turn periodic off to ensure sent rtcp packet is explicitly requested.
1243 config.schedule_periodic_compound_packets = false;
1244 RtcpPacketParser rtcp_parser;
1245 RtcpParserTransport transport(&rtcp_parser);
1246 config.outgoing_transport = &transport;
1247
1248 config.rtcp_mode = webrtc::RtcpMode::kReducedSize;
1249
1250 RtcpTransceiverImpl rtcp_transceiver(config);
1251 rtcp_transceiver.SendFullIntraRequest(kRemoteSsrcs, true);
1252
1253 // Test sent packet is reduced size by expecting absense of receiver report.
1254 EXPECT_EQ(transport.num_packets(), 1);
1255 EXPECT_EQ(rtcp_parser.receiver_report()->num_packets(), 0);
1256 }
1257
TEST_F(RtcpTransceiverImplTest,SendsXrRrtrWhenEnabled)1258 TEST_F(RtcpTransceiverImplTest, SendsXrRrtrWhenEnabled) {
1259 const uint32_t kSenderSsrc = 4321;
1260 RtcpTransceiverConfig config = DefaultTestConfig();
1261 config.feedback_ssrc = kSenderSsrc;
1262 config.schedule_periodic_compound_packets = false;
1263 RtcpPacketParser rtcp_parser;
1264 RtcpParserTransport transport(&rtcp_parser);
1265 config.outgoing_transport = &transport;
1266 config.non_sender_rtt_measurement = true;
1267 RtcpTransceiverImpl rtcp_transceiver(config);
1268
1269 rtcp_transceiver.SendCompoundPacket();
1270 NtpTime ntp_time_now = config.clock->CurrentNtpTime();
1271
1272 EXPECT_EQ(rtcp_parser.xr()->num_packets(), 1);
1273 EXPECT_EQ(rtcp_parser.xr()->sender_ssrc(), kSenderSsrc);
1274 ASSERT_TRUE(rtcp_parser.xr()->rrtr());
1275 EXPECT_EQ(rtcp_parser.xr()->rrtr()->ntp(), ntp_time_now);
1276 }
1277
TEST_F(RtcpTransceiverImplTest,RepliesToRrtrWhenEnabled)1278 TEST_F(RtcpTransceiverImplTest, RepliesToRrtrWhenEnabled) {
1279 static constexpr uint32_t kSenderSsrc[] = {4321, 9876};
1280 RtcpTransceiverConfig config = DefaultTestConfig();
1281 config.reply_to_non_sender_rtt_measurement = true;
1282 RtcpPacketParser rtcp_parser;
1283 RtcpParserTransport transport(&rtcp_parser);
1284 config.outgoing_transport = &transport;
1285 RtcpTransceiverImpl rtcp_transceiver(config);
1286
1287 rtcp::ExtendedReports xr;
1288 rtcp::Rrtr rrtr;
1289 rrtr.SetNtp(NtpTime(uint64_t{0x1111'2222'3333'4444}));
1290 xr.SetRrtr(rrtr);
1291 xr.SetSenderSsrc(kSenderSsrc[0]);
1292 rtcp_transceiver.ReceivePacket(xr.Build(), CurrentTime());
1293 AdvanceTime(TimeDelta::Millis(1'500));
1294
1295 rrtr.SetNtp(NtpTime(uint64_t{0x4444'5555'6666'7777}));
1296 xr.SetRrtr(rrtr);
1297 xr.SetSenderSsrc(kSenderSsrc[1]);
1298 rtcp_transceiver.ReceivePacket(xr.Build(), CurrentTime());
1299 AdvanceTime(TimeDelta::Millis(500));
1300
1301 rtcp_transceiver.SendCompoundPacket();
1302
1303 EXPECT_EQ(rtcp_parser.xr()->num_packets(), 1);
1304 static constexpr uint32_t kComactNtpOneSecond = 0x0001'0000;
1305 EXPECT_THAT(rtcp_parser.xr()->dlrr().sub_blocks(),
1306 UnorderedElementsAre(
1307 rtcp::ReceiveTimeInfo(kSenderSsrc[0], 0x2222'3333,
1308 /*delay=*/2 * kComactNtpOneSecond),
1309 rtcp::ReceiveTimeInfo(kSenderSsrc[1], 0x5555'6666,
1310 /*delay=*/kComactNtpOneSecond / 2)));
1311 }
1312
TEST_F(RtcpTransceiverImplTest,CanReplyToRrtrOnceForAllLocalSsrcs)1313 TEST_F(RtcpTransceiverImplTest, CanReplyToRrtrOnceForAllLocalSsrcs) {
1314 static constexpr uint32_t kRemoteSsrc = 4321;
1315 static constexpr uint32_t kLocalSsrcs[] = {1234, 5678};
1316 RtcpTransceiverConfig config = DefaultTestConfig();
1317 config.reply_to_non_sender_rtt_measurement = true;
1318 config.reply_to_non_sender_rtt_mesaurments_on_all_ssrcs = false;
1319 RtcpPacketParser rtcp_parser;
1320 RtcpParserTransport transport(&rtcp_parser);
1321 config.outgoing_transport = &transport;
1322 RtcpTransceiverImpl rtcp_transceiver(config);
1323
1324 MockRtpStreamRtcpHandler local_sender0;
1325 MockRtpStreamRtcpHandler local_sender1;
1326 rtcp_transceiver.AddMediaSender(kLocalSsrcs[0], &local_sender0);
1327 rtcp_transceiver.AddMediaSender(kLocalSsrcs[1], &local_sender1);
1328
1329 rtcp::ExtendedReports xr;
1330 rtcp::Rrtr rrtr;
1331 rrtr.SetNtp(NtpTime(uint64_t{0x1111'2222'3333'4444}));
1332 xr.SetRrtr(rrtr);
1333 xr.SetSenderSsrc(kRemoteSsrc);
1334 rtcp_transceiver.ReceivePacket(xr.Build(), CurrentTime());
1335 AdvanceTime(TimeDelta::Millis(1'500));
1336
1337 rtcp_transceiver.SendCompoundPacket();
1338
1339 EXPECT_EQ(rtcp_parser.xr()->num_packets(), 1);
1340 }
1341
TEST_F(RtcpTransceiverImplTest,CanReplyToRrtrForEachLocalSsrc)1342 TEST_F(RtcpTransceiverImplTest, CanReplyToRrtrForEachLocalSsrc) {
1343 static constexpr uint32_t kRemoteSsrc = 4321;
1344 static constexpr uint32_t kLocalSsrc[] = {1234, 5678};
1345 RtcpTransceiverConfig config = DefaultTestConfig();
1346 config.reply_to_non_sender_rtt_measurement = true;
1347 config.reply_to_non_sender_rtt_mesaurments_on_all_ssrcs = true;
1348 RtcpPacketParser rtcp_parser;
1349 RtcpParserTransport transport(&rtcp_parser);
1350 config.outgoing_transport = &transport;
1351 RtcpTransceiverImpl rtcp_transceiver(config);
1352
1353 MockRtpStreamRtcpHandler local_sender0;
1354 MockRtpStreamRtcpHandler local_sender1;
1355 rtcp_transceiver.AddMediaSender(kLocalSsrc[0], &local_sender0);
1356 rtcp_transceiver.AddMediaSender(kLocalSsrc[1], &local_sender1);
1357
1358 rtcp::ExtendedReports xr;
1359 rtcp::Rrtr rrtr;
1360 rrtr.SetNtp(NtpTime(uint64_t{0x1111'2222'3333'4444}));
1361 xr.SetRrtr(rrtr);
1362 xr.SetSenderSsrc(kRemoteSsrc);
1363 rtcp_transceiver.ReceivePacket(xr.Build(), CurrentTime());
1364 AdvanceTime(TimeDelta::Millis(1'500));
1365
1366 rtcp_transceiver.SendCompoundPacket();
1367
1368 EXPECT_EQ(rtcp_parser.xr()->num_packets(), 2);
1369 }
1370
TEST_F(RtcpTransceiverImplTest,SendsNoXrRrtrWhenDisabled)1371 TEST_F(RtcpTransceiverImplTest, SendsNoXrRrtrWhenDisabled) {
1372 RtcpTransceiverConfig config = DefaultTestConfig();
1373 config.schedule_periodic_compound_packets = false;
1374 RtcpPacketParser rtcp_parser;
1375 RtcpParserTransport transport(&rtcp_parser);
1376 config.outgoing_transport = &transport;
1377 config.non_sender_rtt_measurement = false;
1378 RtcpTransceiverImpl rtcp_transceiver(config);
1379
1380 rtcp_transceiver.SendCompoundPacket();
1381
1382 EXPECT_EQ(transport.num_packets(), 1);
1383 // Extended reports rtcp packet might be included for another reason,
1384 // but it shouldn't contain rrtr block.
1385 EXPECT_FALSE(rtcp_parser.xr()->rrtr());
1386 }
1387
TEST_F(RtcpTransceiverImplTest,PassRttFromDlrrToLinkObserver)1388 TEST_F(RtcpTransceiverImplTest, PassRttFromDlrrToLinkObserver) {
1389 const uint32_t kSenderSsrc = 4321;
1390 MockNetworkLinkRtcpObserver link_observer;
1391 RtcpTransceiverConfig config = DefaultTestConfig();
1392 config.feedback_ssrc = kSenderSsrc;
1393 config.network_link_observer = &link_observer;
1394 config.non_sender_rtt_measurement = true;
1395 RtcpTransceiverImpl rtcp_transceiver(config);
1396
1397 Timestamp send_time = Timestamp::Seconds(5678);
1398 Timestamp receive_time = send_time + TimeDelta::Millis(110);
1399 rtcp::ReceiveTimeInfo rti;
1400 rti.ssrc = kSenderSsrc;
1401 rti.last_rr = CompactNtp(config.clock->ConvertTimestampToNtpTime(send_time));
1402 rti.delay_since_last_rr = SaturatedToCompactNtp(TimeDelta::Millis(10));
1403 rtcp::ExtendedReports xr;
1404 xr.AddDlrrItem(rti);
1405
1406 EXPECT_CALL(link_observer,
1407 OnRttUpdate(receive_time, Near(TimeDelta::Millis(100))));
1408 rtcp_transceiver.ReceivePacket(xr.Build(), receive_time);
1409 }
1410
TEST_F(RtcpTransceiverImplTest,CalculatesRoundTripTimeFromReportBlocks)1411 TEST_F(RtcpTransceiverImplTest, CalculatesRoundTripTimeFromReportBlocks) {
1412 MockNetworkLinkRtcpObserver link_observer;
1413 RtcpTransceiverConfig config = DefaultTestConfig();
1414 config.network_link_observer = &link_observer;
1415 RtcpTransceiverImpl rtcp_transceiver(config);
1416
1417 TimeDelta rtt = TimeDelta::Millis(100);
1418 Timestamp send_time = Timestamp::Seconds(5678);
1419 Timestamp receive_time = send_time + TimeDelta::Millis(110);
1420 rtcp::ReceiverReport rr;
1421 rtcp::ReportBlock rb1;
1422 rb1.SetLastSr(CompactNtp(config.clock->ConvertTimestampToNtpTime(
1423 receive_time - rtt - TimeDelta::Millis(10))));
1424 rb1.SetDelayLastSr(SaturatedToCompactNtp(TimeDelta::Millis(10)));
1425 rr.AddReportBlock(rb1);
1426 rtcp::ReportBlock rb2;
1427 rb2.SetLastSr(CompactNtp(config.clock->ConvertTimestampToNtpTime(
1428 receive_time - rtt - TimeDelta::Millis(20))));
1429 rb2.SetDelayLastSr(SaturatedToCompactNtp(TimeDelta::Millis(20)));
1430 rr.AddReportBlock(rb2);
1431
1432 EXPECT_CALL(link_observer, OnRttUpdate(receive_time, Near(rtt)));
1433 rtcp_transceiver.ReceivePacket(rr.Build(), receive_time);
1434 }
1435
TEST_F(RtcpTransceiverImplTest,IgnoresUnknownSsrcInDlrr)1436 TEST_F(RtcpTransceiverImplTest, IgnoresUnknownSsrcInDlrr) {
1437 const uint32_t kSenderSsrc = 4321;
1438 const uint32_t kUnknownSsrc = 4322;
1439 MockNetworkLinkRtcpObserver link_observer;
1440 MockTransport null_transport;
1441 RtcpTransceiverConfig config = DefaultTestConfig();
1442 config.feedback_ssrc = kSenderSsrc;
1443 config.schedule_periodic_compound_packets = false;
1444 config.outgoing_transport = &null_transport;
1445 config.non_sender_rtt_measurement = true;
1446 config.network_link_observer = &link_observer;
1447 RtcpTransceiverImpl rtcp_transceiver(config);
1448
1449 Timestamp time = Timestamp::Micros(12345678);
1450 webrtc::rtcp::ReceiveTimeInfo rti;
1451 rti.ssrc = kUnknownSsrc;
1452 rti.last_rr = CompactNtp(config.clock->ConvertTimestampToNtpTime(time));
1453 webrtc::rtcp::ExtendedReports xr;
1454 xr.AddDlrrItem(rti);
1455 auto raw_packet = xr.Build();
1456
1457 EXPECT_CALL(link_observer, OnRttUpdate).Times(0);
1458 rtcp_transceiver.ReceivePacket(raw_packet, time + TimeDelta::Millis(100));
1459 }
1460
TEST_F(RtcpTransceiverImplTest,ParsesTransportFeedback)1461 TEST_F(RtcpTransceiverImplTest, ParsesTransportFeedback) {
1462 MockNetworkLinkRtcpObserver link_observer;
1463 RtcpTransceiverConfig config = DefaultTestConfig();
1464 config.network_link_observer = &link_observer;
1465 Timestamp receive_time = Timestamp::Seconds(5678);
1466 RtcpTransceiverImpl rtcp_transceiver(config);
1467
1468 EXPECT_CALL(link_observer, OnTransportFeedback(receive_time, _))
1469 .WillOnce(WithArg<1>([](const rtcp::TransportFeedback& message) {
1470 EXPECT_EQ(message.GetBaseSequence(), 321);
1471 EXPECT_THAT(message.GetReceivedPackets(), SizeIs(2));
1472 }));
1473
1474 rtcp::TransportFeedback tb;
1475 tb.SetBase(/*base_sequence=*/321, Timestamp::Micros(15));
1476 tb.AddReceivedPacket(/*base_sequence=*/321, Timestamp::Micros(15));
1477 tb.AddReceivedPacket(/*base_sequence=*/322, Timestamp::Micros(17));
1478 rtcp_transceiver.ReceivePacket(tb.Build(), receive_time);
1479 }
1480
TEST_F(RtcpTransceiverImplTest,ParsesRemb)1481 TEST_F(RtcpTransceiverImplTest, ParsesRemb) {
1482 MockNetworkLinkRtcpObserver link_observer;
1483 RtcpTransceiverConfig config = DefaultTestConfig();
1484 config.network_link_observer = &link_observer;
1485 Timestamp receive_time = Timestamp::Seconds(5678);
1486 RtcpTransceiverImpl rtcp_transceiver(config);
1487
1488 EXPECT_CALL(link_observer,
1489 OnReceiverEstimatedMaxBitrate(receive_time,
1490 DataRate::BitsPerSec(1'234'000)));
1491
1492 rtcp::Remb remb;
1493 remb.SetBitrateBps(1'234'000);
1494 rtcp_transceiver.ReceivePacket(remb.Build(), receive_time);
1495 }
1496
TEST_F(RtcpTransceiverImplTest,CombinesReportBlocksFromSenderAndRecieverReports)1497 TEST_F(RtcpTransceiverImplTest,
1498 CombinesReportBlocksFromSenderAndRecieverReports) {
1499 MockNetworkLinkRtcpObserver link_observer;
1500 RtcpTransceiverConfig config = DefaultTestConfig();
1501 config.network_link_observer = &link_observer;
1502 Timestamp receive_time = Timestamp::Seconds(5678);
1503 RtcpTransceiverImpl rtcp_transceiver(config);
1504
1505 // Assemble compound packet with multiple rtcp packets in it.
1506 rtcp::CompoundPacket packet;
1507 auto sr = std::make_unique<rtcp::SenderReport>();
1508 sr->SetSenderSsrc(1234);
1509 sr->SetReportBlocks(std::vector<ReportBlock>(31));
1510 packet.Append(std::move(sr));
1511 auto rr1 = std::make_unique<rtcp::ReceiverReport>();
1512 rr1->SetReportBlocks(std::vector<ReportBlock>(31));
1513 packet.Append(std::move(rr1));
1514 auto rr2 = std::make_unique<rtcp::ReceiverReport>();
1515 rr2->SetReportBlocks(std::vector<ReportBlock>(2));
1516 packet.Append(std::move(rr2));
1517
1518 EXPECT_CALL(link_observer, OnReportBlocks(receive_time, SizeIs(64)));
1519
1520 rtcp_transceiver.ReceivePacket(packet.Build(), receive_time);
1521 }
1522
TEST_F(RtcpTransceiverImplTest,CallbackOnReportBlocksFromSenderAndReceiverReports)1523 TEST_F(RtcpTransceiverImplTest,
1524 CallbackOnReportBlocksFromSenderAndReceiverReports) {
1525 static constexpr uint32_t kRemoteSsrc = 5678;
1526 // Has registered sender, report block attached to sender report.
1527 static constexpr uint32_t kMediaSsrc1 = 1234;
1528 // No registered sender, report block attached to receiver report.
1529 // Such report block shouldn't prevent handling following report block.
1530 static constexpr uint32_t kMediaSsrc2 = 1235;
1531 // Has registered sender, no report block attached.
1532 static constexpr uint32_t kMediaSsrc3 = 1236;
1533 // Has registered sender, report block attached to receiver report.
1534 static constexpr uint32_t kMediaSsrc4 = 1237;
1535
1536 MockNetworkLinkRtcpObserver link_observer;
1537 RtcpTransceiverConfig config = DefaultTestConfig();
1538 Timestamp receive_time = Timestamp::Seconds(5678);
1539 RtcpTransceiverImpl rtcp_transceiver(config);
1540
1541 MockRtpStreamRtcpHandler local_stream1;
1542 MockRtpStreamRtcpHandler local_stream3;
1543 MockRtpStreamRtcpHandler local_stream4;
1544 EXPECT_CALL(local_stream1, OnReportBlock(kRemoteSsrc, _));
1545 EXPECT_CALL(local_stream3, OnReportBlock).Times(0);
1546 EXPECT_CALL(local_stream4, OnReportBlock(kRemoteSsrc, _));
1547
1548 ASSERT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc1, &local_stream1));
1549 ASSERT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc3, &local_stream3));
1550 ASSERT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc4, &local_stream4));
1551
1552 // Assemble compound packet with multiple RTCP packets in it.
1553 rtcp::CompoundPacket packet;
1554 auto sr = std::make_unique<rtcp::SenderReport>();
1555 sr->SetSenderSsrc(kRemoteSsrc);
1556 std::vector<ReportBlock> rb(1);
1557 rb[0].SetMediaSsrc(kMediaSsrc1);
1558 sr->SetReportBlocks(std::move(rb));
1559 packet.Append(std::move(sr));
1560 auto rr = std::make_unique<rtcp::ReceiverReport>();
1561 rr->SetSenderSsrc(kRemoteSsrc);
1562 rb = std::vector<ReportBlock>(2);
1563 rb[0].SetMediaSsrc(kMediaSsrc2);
1564 rb[1].SetMediaSsrc(kMediaSsrc4);
1565 rr->SetReportBlocks(std::move(rb));
1566 packet.Append(std::move(rr));
1567
1568 rtcp_transceiver.ReceivePacket(packet.Build(), receive_time);
1569 }
1570
TEST_F(RtcpTransceiverImplTest,FailsToRegisterTwoSendersWithTheSameSsrc)1571 TEST_F(RtcpTransceiverImplTest, FailsToRegisterTwoSendersWithTheSameSsrc) {
1572 RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
1573 MockRtpStreamRtcpHandler sender1;
1574 MockRtpStreamRtcpHandler sender2;
1575
1576 EXPECT_TRUE(rtcp_transceiver.AddMediaSender(/*local_ssrc=*/10001, &sender1));
1577 EXPECT_FALSE(rtcp_transceiver.AddMediaSender(/*local_ssrc=*/10001, &sender2));
1578 EXPECT_TRUE(rtcp_transceiver.AddMediaSender(/*local_ssrc=*/10002, &sender2));
1579
1580 EXPECT_TRUE(rtcp_transceiver.RemoveMediaSender(/*local_ssrc=*/10001));
1581 EXPECT_FALSE(rtcp_transceiver.RemoveMediaSender(/*local_ssrc=*/10001));
1582 }
1583
TEST_F(RtcpTransceiverImplTest,SendsSenderReport)1584 TEST_F(RtcpTransceiverImplTest, SendsSenderReport) {
1585 static constexpr uint32_t kFeedbackSsrc = 123;
1586 static constexpr uint32_t kSenderSsrc = 12345;
1587 RtcpTransceiverConfig config = DefaultTestConfig();
1588 config.feedback_ssrc = kFeedbackSsrc;
1589 RtcpPacketParser rtcp_parser;
1590 RtcpParserTransport transport(&rtcp_parser);
1591 config.outgoing_transport = &transport;
1592 config.schedule_periodic_compound_packets = false;
1593 RtcpTransceiverImpl rtcp_transceiver(config);
1594
1595 RtpStreamRtcpHandler::RtpStats sender_stats;
1596 sender_stats.set_num_sent_packets(10);
1597 sender_stats.set_num_sent_bytes(1000);
1598 sender_stats.set_last_rtp_timestamp(0x3333);
1599 sender_stats.set_last_capture_time(CurrentTime() - TimeDelta::Seconds(2));
1600 sender_stats.set_last_clock_rate(0x1000);
1601 MockRtpStreamRtcpHandler sender;
1602 ON_CALL(sender, SentStats).WillByDefault(Return(sender_stats));
1603 rtcp_transceiver.AddMediaSender(kSenderSsrc, &sender);
1604
1605 rtcp_transceiver.SendCompoundPacket();
1606
1607 ASSERT_GT(rtcp_parser.sender_report()->num_packets(), 0);
1608 EXPECT_EQ(rtcp_parser.sender_report()->sender_ssrc(), kSenderSsrc);
1609 EXPECT_EQ(rtcp_parser.sender_report()->ntp(),
1610 time_controller().GetClock()->CurrentNtpTime());
1611 EXPECT_EQ(rtcp_parser.sender_report()->rtp_timestamp(), 0x3333u + 0x2000u);
1612 EXPECT_EQ(rtcp_parser.sender_report()->sender_packet_count(), 10u);
1613 EXPECT_EQ(rtcp_parser.sender_report()->sender_octet_count(), 1000u);
1614 }
1615
TEST_F(RtcpTransceiverImplTest,MaySendBothSenderReportAndReceiverReportInTheSamePacket)1616 TEST_F(RtcpTransceiverImplTest,
1617 MaySendBothSenderReportAndReceiverReportInTheSamePacket) {
1618 RtcpPacketParser rtcp_parser;
1619 RtcpParserTransport transport(&rtcp_parser);
1620 std::vector<ReportBlock> statistics_report_blocks(40);
1621 MockReceiveStatisticsProvider receive_statistics;
1622 EXPECT_CALL(receive_statistics, RtcpReportBlocks(/*max_blocks=*/Ge(40u)))
1623 .WillOnce(Return(statistics_report_blocks));
1624 RtcpTransceiverConfig config = DefaultTestConfig();
1625 config.outgoing_transport = &transport;
1626 config.receive_statistics = &receive_statistics;
1627 RtcpTransceiverImpl rtcp_transceiver(config);
1628
1629 MockRtpStreamRtcpHandler sender;
1630 rtcp_transceiver.AddMediaSender(/*ssrc=*/12345, &sender);
1631
1632 rtcp_transceiver.SendCompoundPacket();
1633
1634 // Expect a single RTCP packet with a sender and a receiver reports in it.
1635 EXPECT_EQ(transport.num_packets(), 1);
1636 ASSERT_EQ(rtcp_parser.sender_report()->num_packets(), 1);
1637 ASSERT_EQ(rtcp_parser.receiver_report()->num_packets(), 1);
1638 // Sender report may contain up to 31 report blocks, thus remaining 9 report
1639 // block should be attached to the receiver report.
1640 EXPECT_THAT(rtcp_parser.sender_report()->report_blocks(), SizeIs(31));
1641 EXPECT_THAT(rtcp_parser.receiver_report()->report_blocks(), SizeIs(9));
1642 }
1643
TEST_F(RtcpTransceiverImplTest,RotatesSendersWhenAllSenderReportDoNotFit)1644 TEST_F(RtcpTransceiverImplTest, RotatesSendersWhenAllSenderReportDoNotFit) {
1645 // Send 6 compound packet, each should contain 5 sender reports,
1646 // each of 6 senders should be mentioned 5 times.
1647 static constexpr int kNumSenders = 6;
1648 static constexpr uint32_t kSenderSsrc[kNumSenders] = {10, 20, 30, 40, 50, 60};
1649 static constexpr int kSendersPerPacket = 5;
1650 // RtcpPacketParser remembers only latest block for each type, but this test
1651 // is about sending multiple sender reports in the same packet, thus need
1652 // a more advance parser: RtcpTranceiver
1653 RtcpTransceiverConfig receiver_config = DefaultTestConfig();
1654 RtcpTransceiverImpl rtcp_receiver(receiver_config);
1655 // Main expectatation: all senders are spread equally across multiple packets.
1656 NiceMock<MockMediaReceiverRtcpObserver> receiver[kNumSenders];
1657 for (int i = 0; i < kNumSenders; ++i) {
1658 SCOPED_TRACE(i);
1659 EXPECT_CALL(receiver[i], OnSenderReport(kSenderSsrc[i], _, _))
1660 .Times(kSendersPerPacket);
1661 rtcp_receiver.AddMediaReceiverRtcpObserver(kSenderSsrc[i], &receiver[i]);
1662 }
1663
1664 MockTransport transport;
1665 EXPECT_CALL(transport, SendRtcp)
1666 .Times(kNumSenders)
1667 .WillRepeatedly([&](const uint8_t* data, size_t size) {
1668 rtcp_receiver.ReceivePacket(rtc::MakeArrayView(data, size),
1669 CurrentTime());
1670 return true;
1671 });
1672 RtcpTransceiverConfig config = DefaultTestConfig();
1673 config.outgoing_transport = &transport;
1674 // Limit packet to have space just for kSendersPerPacket sender reports.
1675 // Sender report without report blocks require 28 bytes.
1676 config.max_packet_size = kSendersPerPacket * 28;
1677 RtcpTransceiverImpl rtcp_transceiver(config);
1678 NiceMock<MockRtpStreamRtcpHandler> sender[kNumSenders];
1679 for (int i = 0; i < kNumSenders; ++i) {
1680 rtcp_transceiver.AddMediaSender(kSenderSsrc[i], &sender[i]);
1681 }
1682
1683 for (int i = 1; i <= kNumSenders; ++i) {
1684 SCOPED_TRACE(i);
1685 rtcp_transceiver.SendCompoundPacket();
1686 }
1687 }
1688
TEST_F(RtcpTransceiverImplTest,SkipsSenderReportForInactiveSender)1689 TEST_F(RtcpTransceiverImplTest, SkipsSenderReportForInactiveSender) {
1690 static constexpr uint32_t kSenderSsrc[] = {12345, 23456};
1691 RtcpTransceiverConfig config = DefaultTestConfig();
1692 RtcpPacketParser rtcp_parser;
1693 RtcpParserTransport transport(&rtcp_parser);
1694 config.outgoing_transport = &transport;
1695 RtcpTransceiverImpl rtcp_transceiver(config);
1696
1697 RtpStreamRtcpHandler::RtpStats sender_stats[2];
1698 NiceMock<MockRtpStreamRtcpHandler> sender[2];
1699 ON_CALL(sender[0], SentStats).WillByDefault([&] { return sender_stats[0]; });
1700 ON_CALL(sender[1], SentStats).WillByDefault([&] { return sender_stats[1]; });
1701 rtcp_transceiver.AddMediaSender(kSenderSsrc[0], &sender[0]);
1702 rtcp_transceiver.AddMediaSender(kSenderSsrc[1], &sender[1]);
1703
1704 // Start with both senders beeing active.
1705 sender_stats[0].set_num_sent_packets(10);
1706 sender_stats[0].set_num_sent_bytes(1'000);
1707 sender_stats[1].set_num_sent_packets(5);
1708 sender_stats[1].set_num_sent_bytes(2'000);
1709 rtcp_transceiver.SendCompoundPacket();
1710 EXPECT_EQ(transport.num_packets(), 1);
1711 EXPECT_EQ(rtcp_parser.sender_report()->num_packets(), 2);
1712
1713 // Keep 1st sender active, but make 2nd second look inactive by returning the
1714 // same RtpStats.
1715 sender_stats[0].set_num_sent_packets(15);
1716 sender_stats[0].set_num_sent_bytes(2'000);
1717 rtcp_transceiver.SendCompoundPacket();
1718 EXPECT_EQ(transport.num_packets(), 2);
1719 EXPECT_EQ(rtcp_parser.sender_report()->num_packets(), 3);
1720 EXPECT_EQ(rtcp_parser.sender_report()->sender_ssrc(), kSenderSsrc[0]);
1721
1722 // Swap active sender.
1723 sender_stats[1].set_num_sent_packets(20);
1724 sender_stats[1].set_num_sent_bytes(3'000);
1725 rtcp_transceiver.SendCompoundPacket();
1726 EXPECT_EQ(transport.num_packets(), 3);
1727 EXPECT_EQ(rtcp_parser.sender_report()->num_packets(), 4);
1728 EXPECT_EQ(rtcp_parser.sender_report()->sender_ssrc(), kSenderSsrc[1]);
1729
1730 // Activate both senders again.
1731 sender_stats[0].set_num_sent_packets(20);
1732 sender_stats[0].set_num_sent_bytes(3'000);
1733 sender_stats[1].set_num_sent_packets(25);
1734 sender_stats[1].set_num_sent_bytes(3'500);
1735 rtcp_transceiver.SendCompoundPacket();
1736 EXPECT_EQ(transport.num_packets(), 4);
1737 EXPECT_EQ(rtcp_parser.sender_report()->num_packets(), 6);
1738 }
1739
1740 } // namespace
1741 } // namespace webrtc
1742