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/video/video_bitrate_allocation.h"
20 #include "modules/rtp_rtcp/include/receive_statistics.h"
21 #include "modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h"
22 #include "modules/rtp_rtcp/source/rtcp_packet/app.h"
23 #include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
24 #include "modules/rtp_rtcp/source/rtcp_packet/compound_packet.h"
25 #include "modules/rtp_rtcp/source/time_util.h"
26 #include "rtc_base/event.h"
27 #include "rtc_base/fake_clock.h"
28 #include "rtc_base/task_queue_for_test.h"
29 #include "test/gmock.h"
30 #include "test/gtest.h"
31 #include "test/mock_transport.h"
32 #include "test/rtcp_packet_parser.h"
33
34 namespace {
35
36 using ::testing::_;
37 using ::testing::ElementsAre;
38 using ::testing::Return;
39 using ::testing::SizeIs;
40 using ::testing::StrictMock;
41 using ::webrtc::CompactNtp;
42 using ::webrtc::CompactNtpRttToMs;
43 using ::webrtc::MockRtcpRttStats;
44 using ::webrtc::MockTransport;
45 using ::webrtc::NtpTime;
46 using ::webrtc::RtcpTransceiverConfig;
47 using ::webrtc::RtcpTransceiverImpl;
48 using ::webrtc::SaturatedUsToCompactNtp;
49 using ::webrtc::TaskQueueForTest;
50 using ::webrtc::TimeMicrosToNtp;
51 using ::webrtc::VideoBitrateAllocation;
52 using ::webrtc::rtcp::Bye;
53 using ::webrtc::rtcp::CompoundPacket;
54 using ::webrtc::rtcp::ReportBlock;
55 using ::webrtc::rtcp::SenderReport;
56 using ::webrtc::test::RtcpPacketParser;
57
58 class MockReceiveStatisticsProvider : public webrtc::ReceiveStatisticsProvider {
59 public:
60 MOCK_METHOD(std::vector<ReportBlock>, RtcpReportBlocks, (size_t), (override));
61 };
62
63 class MockMediaReceiverRtcpObserver : public webrtc::MediaReceiverRtcpObserver {
64 public:
65 MOCK_METHOD(void, OnSenderReport, (uint32_t, NtpTime, uint32_t), (override));
66 MOCK_METHOD(void, OnBye, (uint32_t), (override));
67 MOCK_METHOD(void,
68 OnBitrateAllocation,
69 (uint32_t, const VideoBitrateAllocation&),
70 (override));
71 };
72
73 // Since some tests will need to wait for this period, make it small to avoid
74 // slowing tests too much. As long as there are test bots with high scheduler
75 // granularity, small period should be ok.
76 constexpr int kReportPeriodMs = 10;
77 // On some systems task queue might be slow, instead of guessing right
78 // grace period, use very large timeout, 100x larger expected wait time.
79 // Use finite timeout to fail tests rather than hang them.
80 constexpr int kAlmostForeverMs = 1000;
81
82 // Helper to wait for an rtcp packet produced on a different thread/task queue.
83 class FakeRtcpTransport : public webrtc::Transport {
84 public:
SendRtcp(const uint8_t * data,size_t size)85 bool SendRtcp(const uint8_t* data, size_t size) override {
86 sent_rtcp_.Set();
87 return true;
88 }
SendRtp(const uint8_t *,size_t,const webrtc::PacketOptions &)89 bool SendRtp(const uint8_t*, size_t, const webrtc::PacketOptions&) override {
90 ADD_FAILURE() << "RtcpTransciver shouldn't send rtp packets.";
91 return true;
92 }
93
94 // Returns true when packet was received by the transport.
WaitPacket()95 bool WaitPacket() {
96 // Normally packet should be sent fast, long before the timeout.
97 bool packet_sent = sent_rtcp_.Wait(kAlmostForeverMs);
98 // Disallow tests to wait almost forever for no packets.
99 EXPECT_TRUE(packet_sent);
100 // Return wait result even though it is expected to be true, so that
101 // individual tests can EXPECT on it for better error message.
102 return packet_sent;
103 }
104
105 private:
106 rtc::Event sent_rtcp_;
107 };
108
109 class RtcpParserTransport : public webrtc::Transport {
110 public:
RtcpParserTransport(RtcpPacketParser * parser)111 explicit RtcpParserTransport(RtcpPacketParser* parser) : parser_(parser) {}
112 // Returns total number of rtcp packet received.
num_packets() const113 int num_packets() const { return num_packets_; }
114
115 private:
SendRtcp(const uint8_t * data,size_t size)116 bool SendRtcp(const uint8_t* data, size_t size) override {
117 ++num_packets_;
118 parser_->Parse(data, size);
119 return true;
120 }
121
SendRtp(const uint8_t *,size_t,const webrtc::PacketOptions &)122 bool SendRtp(const uint8_t*, size_t, const webrtc::PacketOptions&) override {
123 ADD_FAILURE() << "RtcpTransciver shouldn't send rtp packets.";
124 return true;
125 }
126
127 RtcpPacketParser* const parser_;
128 int num_packets_ = 0;
129 };
130
DefaultTestConfig()131 RtcpTransceiverConfig DefaultTestConfig() {
132 // RtcpTransceiverConfig default constructor sets default values for prod.
133 // Test doesn't need to support all key features: Default test config returns
134 // valid config with all features turned off.
135 static MockTransport null_transport;
136 RtcpTransceiverConfig config;
137 config.outgoing_transport = &null_transport;
138 config.schedule_periodic_compound_packets = false;
139 config.initial_report_delay_ms = 10;
140 config.report_period_ms = kReportPeriodMs;
141 return config;
142 }
143
TEST(RtcpTransceiverImplTest,NeedToStopPeriodicTaskToDestroyOnTaskQueue)144 TEST(RtcpTransceiverImplTest, NeedToStopPeriodicTaskToDestroyOnTaskQueue) {
145 FakeRtcpTransport transport;
146 TaskQueueForTest queue("rtcp");
147 RtcpTransceiverConfig config = DefaultTestConfig();
148 config.task_queue = queue.Get();
149 config.schedule_periodic_compound_packets = true;
150 config.outgoing_transport = &transport;
151 auto* rtcp_transceiver = new RtcpTransceiverImpl(config);
152 // Wait for a periodic packet.
153 EXPECT_TRUE(transport.WaitPacket());
154
155 rtc::Event done;
156 queue.PostTask([rtcp_transceiver, &done] {
157 rtcp_transceiver->StopPeriodicTask();
158 delete rtcp_transceiver;
159 done.Set();
160 });
161 ASSERT_TRUE(done.Wait(/*milliseconds=*/1000));
162 }
163
TEST(RtcpTransceiverImplTest,CanDestroyAfterTaskQueue)164 TEST(RtcpTransceiverImplTest, CanDestroyAfterTaskQueue) {
165 FakeRtcpTransport transport;
166 auto* queue = new TaskQueueForTest("rtcp");
167 RtcpTransceiverConfig config = DefaultTestConfig();
168 config.task_queue = queue->Get();
169 config.schedule_periodic_compound_packets = true;
170 config.outgoing_transport = &transport;
171 auto* rtcp_transceiver = new RtcpTransceiverImpl(config);
172 // Wait for a periodic packet.
173 EXPECT_TRUE(transport.WaitPacket());
174
175 delete queue;
176 delete rtcp_transceiver;
177 }
178
TEST(RtcpTransceiverImplTest,DelaysSendingFirstCompondPacket)179 TEST(RtcpTransceiverImplTest, DelaysSendingFirstCompondPacket) {
180 TaskQueueForTest queue("rtcp");
181 FakeRtcpTransport transport;
182 RtcpTransceiverConfig config;
183 config.outgoing_transport = &transport;
184 config.initial_report_delay_ms = 10;
185 config.task_queue = queue.Get();
186 absl::optional<RtcpTransceiverImpl> rtcp_transceiver;
187
188 int64_t started_ms = rtc::TimeMillis();
189 queue.PostTask([&] { rtcp_transceiver.emplace(config); });
190 EXPECT_TRUE(transport.WaitPacket());
191
192 EXPECT_GE(rtc::TimeMillis() - started_ms, config.initial_report_delay_ms);
193
194 // Cleanup.
195 rtc::Event done;
196 queue.PostTask([&] {
197 rtcp_transceiver->StopPeriodicTask();
198 rtcp_transceiver.reset();
199 done.Set();
200 });
201 ASSERT_TRUE(done.Wait(kAlmostForeverMs));
202 }
203
TEST(RtcpTransceiverImplTest,PeriodicallySendsPackets)204 TEST(RtcpTransceiverImplTest, PeriodicallySendsPackets) {
205 TaskQueueForTest queue("rtcp");
206 FakeRtcpTransport transport;
207 RtcpTransceiverConfig config;
208 config.outgoing_transport = &transport;
209 config.initial_report_delay_ms = 0;
210 config.report_period_ms = kReportPeriodMs;
211 config.task_queue = queue.Get();
212 absl::optional<RtcpTransceiverImpl> rtcp_transceiver;
213 int64_t time_just_before_1st_packet_ms = 0;
214 queue.PostTask([&] {
215 // Because initial_report_delay_ms is set to 0, time_just_before_the_packet
216 // should be very close to the time_of_the_packet.
217 time_just_before_1st_packet_ms = rtc::TimeMillis();
218 rtcp_transceiver.emplace(config);
219 });
220
221 EXPECT_TRUE(transport.WaitPacket());
222 EXPECT_TRUE(transport.WaitPacket());
223 int64_t time_just_after_2nd_packet_ms = rtc::TimeMillis();
224
225 EXPECT_GE(time_just_after_2nd_packet_ms - time_just_before_1st_packet_ms,
226 config.report_period_ms - 1);
227
228 // Cleanup.
229 rtc::Event done;
230 queue.PostTask([&] {
231 rtcp_transceiver->StopPeriodicTask();
232 rtcp_transceiver.reset();
233 done.Set();
234 });
235 ASSERT_TRUE(done.Wait(kAlmostForeverMs));
236 }
237
TEST(RtcpTransceiverImplTest,SendCompoundPacketDelaysPeriodicSendPackets)238 TEST(RtcpTransceiverImplTest, SendCompoundPacketDelaysPeriodicSendPackets) {
239 TaskQueueForTest queue("rtcp");
240 FakeRtcpTransport transport;
241 RtcpTransceiverConfig config;
242 config.outgoing_transport = &transport;
243 config.initial_report_delay_ms = 0;
244 config.report_period_ms = kReportPeriodMs;
245 config.task_queue = queue.Get();
246 absl::optional<RtcpTransceiverImpl> rtcp_transceiver;
247 queue.PostTask([&] { rtcp_transceiver.emplace(config); });
248
249 // Wait for first packet.
250 EXPECT_TRUE(transport.WaitPacket());
251 // Send non periodic one after half period.
252 rtc::Event non_periodic;
253 int64_t time_of_non_periodic_packet_ms = 0;
254 queue.PostDelayedTask(
255 [&] {
256 time_of_non_periodic_packet_ms = rtc::TimeMillis();
257 rtcp_transceiver->SendCompoundPacket();
258 non_periodic.Set();
259 },
260 config.report_period_ms / 2);
261 // Though non-periodic packet is scheduled just in between periodic, due to
262 // small period and task queue flakiness it migth end-up 1ms after next
263 // periodic packet. To be sure duration after non-periodic packet is tested
264 // wait for transport after ensuring non-periodic packet was sent.
265 EXPECT_TRUE(non_periodic.Wait(kAlmostForeverMs));
266 EXPECT_TRUE(transport.WaitPacket());
267 // Wait for next periodic packet.
268 EXPECT_TRUE(transport.WaitPacket());
269 int64_t time_of_last_periodic_packet_ms = rtc::TimeMillis();
270
271 EXPECT_GE(time_of_last_periodic_packet_ms - time_of_non_periodic_packet_ms,
272 config.report_period_ms - 1);
273
274 // Cleanup.
275 rtc::Event done;
276 queue.PostTask([&] {
277 rtcp_transceiver->StopPeriodicTask();
278 rtcp_transceiver.reset();
279 done.Set();
280 });
281 ASSERT_TRUE(done.Wait(kAlmostForeverMs));
282 }
283
TEST(RtcpTransceiverImplTest,SendsNoRtcpWhenNetworkStateIsDown)284 TEST(RtcpTransceiverImplTest, SendsNoRtcpWhenNetworkStateIsDown) {
285 MockTransport mock_transport;
286 RtcpTransceiverConfig config = DefaultTestConfig();
287 config.initial_ready_to_send = false;
288 config.outgoing_transport = &mock_transport;
289 RtcpTransceiverImpl rtcp_transceiver(config);
290
291 EXPECT_CALL(mock_transport, SendRtcp(_, _)).Times(0);
292
293 const uint8_t raw[] = {1, 2, 3, 4};
294 const std::vector<uint16_t> sequence_numbers = {45, 57};
295 const uint32_t ssrcs[] = {123};
296 rtcp_transceiver.SendCompoundPacket();
297 rtcp_transceiver.SendRawPacket(raw);
298 rtcp_transceiver.SendNack(ssrcs[0], sequence_numbers);
299 rtcp_transceiver.SendPictureLossIndication(ssrcs[0]);
300 rtcp_transceiver.SendFullIntraRequest(ssrcs, true);
301 }
302
TEST(RtcpTransceiverImplTest,SendsRtcpWhenNetworkStateIsUp)303 TEST(RtcpTransceiverImplTest, SendsRtcpWhenNetworkStateIsUp) {
304 MockTransport mock_transport;
305 RtcpTransceiverConfig config = DefaultTestConfig();
306 config.initial_ready_to_send = false;
307 config.outgoing_transport = &mock_transport;
308 RtcpTransceiverImpl rtcp_transceiver(config);
309
310 rtcp_transceiver.SetReadyToSend(true);
311
312 EXPECT_CALL(mock_transport, SendRtcp(_, _)).Times(5);
313
314 const uint8_t raw[] = {1, 2, 3, 4};
315 const std::vector<uint16_t> sequence_numbers = {45, 57};
316 const uint32_t ssrcs[] = {123};
317 rtcp_transceiver.SendCompoundPacket();
318 rtcp_transceiver.SendRawPacket(raw);
319 rtcp_transceiver.SendNack(ssrcs[0], sequence_numbers);
320 rtcp_transceiver.SendPictureLossIndication(ssrcs[0]);
321 rtcp_transceiver.SendFullIntraRequest(ssrcs, true);
322 }
323
TEST(RtcpTransceiverImplTest,SendsPeriodicRtcpWhenNetworkStateIsUp)324 TEST(RtcpTransceiverImplTest, SendsPeriodicRtcpWhenNetworkStateIsUp) {
325 TaskQueueForTest queue("rtcp");
326 FakeRtcpTransport transport;
327 RtcpTransceiverConfig config = DefaultTestConfig();
328 config.schedule_periodic_compound_packets = true;
329 config.initial_ready_to_send = false;
330 config.outgoing_transport = &transport;
331 config.task_queue = queue.Get();
332 absl::optional<RtcpTransceiverImpl> rtcp_transceiver;
333 rtcp_transceiver.emplace(config);
334
335 queue.PostTask([&] { rtcp_transceiver->SetReadyToSend(true); });
336
337 EXPECT_TRUE(transport.WaitPacket());
338
339 // Cleanup.
340 rtc::Event done;
341 queue.PostTask([&] {
342 rtcp_transceiver->StopPeriodicTask();
343 rtcp_transceiver.reset();
344 done.Set();
345 });
346 ASSERT_TRUE(done.Wait(kAlmostForeverMs));
347 }
348
TEST(RtcpTransceiverImplTest,SendsMinimalCompoundPacket)349 TEST(RtcpTransceiverImplTest, SendsMinimalCompoundPacket) {
350 const uint32_t kSenderSsrc = 12345;
351 RtcpTransceiverConfig config;
352 config.feedback_ssrc = kSenderSsrc;
353 config.cname = "cname";
354 RtcpPacketParser rtcp_parser;
355 RtcpParserTransport transport(&rtcp_parser);
356 config.outgoing_transport = &transport;
357 config.schedule_periodic_compound_packets = false;
358 RtcpTransceiverImpl rtcp_transceiver(config);
359
360 rtcp_transceiver.SendCompoundPacket();
361
362 // Minimal compound RTCP packet contains sender or receiver report and sdes
363 // with cname.
364 ASSERT_GT(rtcp_parser.receiver_report()->num_packets(), 0);
365 EXPECT_EQ(rtcp_parser.receiver_report()->sender_ssrc(), kSenderSsrc);
366 ASSERT_GT(rtcp_parser.sdes()->num_packets(), 0);
367 ASSERT_EQ(rtcp_parser.sdes()->chunks().size(), 1u);
368 EXPECT_EQ(rtcp_parser.sdes()->chunks()[0].ssrc, kSenderSsrc);
369 EXPECT_EQ(rtcp_parser.sdes()->chunks()[0].cname, config.cname);
370 }
371
TEST(RtcpTransceiverImplTest,SendsNoRembInitially)372 TEST(RtcpTransceiverImplTest, SendsNoRembInitially) {
373 const uint32_t kSenderSsrc = 12345;
374 RtcpTransceiverConfig config;
375 config.feedback_ssrc = kSenderSsrc;
376 RtcpPacketParser rtcp_parser;
377 RtcpParserTransport transport(&rtcp_parser);
378 config.outgoing_transport = &transport;
379 config.schedule_periodic_compound_packets = false;
380 RtcpTransceiverImpl rtcp_transceiver(config);
381
382 rtcp_transceiver.SendCompoundPacket();
383
384 EXPECT_EQ(transport.num_packets(), 1);
385 EXPECT_EQ(rtcp_parser.remb()->num_packets(), 0);
386 }
387
TEST(RtcpTransceiverImplTest,SetRembIncludesRembInNextCompoundPacket)388 TEST(RtcpTransceiverImplTest, SetRembIncludesRembInNextCompoundPacket) {
389 const uint32_t kSenderSsrc = 12345;
390 RtcpTransceiverConfig config;
391 config.feedback_ssrc = kSenderSsrc;
392 RtcpPacketParser rtcp_parser;
393 RtcpParserTransport transport(&rtcp_parser);
394 config.outgoing_transport = &transport;
395 config.schedule_periodic_compound_packets = false;
396 RtcpTransceiverImpl rtcp_transceiver(config);
397
398 rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{54321, 64321});
399 rtcp_transceiver.SendCompoundPacket();
400
401 EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
402 EXPECT_EQ(rtcp_parser.remb()->sender_ssrc(), kSenderSsrc);
403 EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 10000);
404 EXPECT_THAT(rtcp_parser.remb()->ssrcs(), ElementsAre(54321, 64321));
405 }
406
TEST(RtcpTransceiverImplTest,SetRembUpdatesValuesToSend)407 TEST(RtcpTransceiverImplTest, SetRembUpdatesValuesToSend) {
408 const uint32_t kSenderSsrc = 12345;
409 RtcpTransceiverConfig config;
410 config.feedback_ssrc = kSenderSsrc;
411 RtcpPacketParser rtcp_parser;
412 RtcpParserTransport transport(&rtcp_parser);
413 config.outgoing_transport = &transport;
414 config.schedule_periodic_compound_packets = false;
415 RtcpTransceiverImpl rtcp_transceiver(config);
416
417 rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{54321, 64321});
418 rtcp_transceiver.SendCompoundPacket();
419
420 EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
421 EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 10000);
422 EXPECT_THAT(rtcp_parser.remb()->ssrcs(), ElementsAre(54321, 64321));
423
424 rtcp_transceiver.SetRemb(/*bitrate_bps=*/70000, /*ssrcs=*/{67321});
425 rtcp_transceiver.SendCompoundPacket();
426
427 EXPECT_EQ(rtcp_parser.remb()->num_packets(), 2);
428 EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 70000);
429 EXPECT_THAT(rtcp_parser.remb()->ssrcs(), ElementsAre(67321));
430 }
431
TEST(RtcpTransceiverImplTest,SetRembSendsImmediatelyIfSendRembOnChange)432 TEST(RtcpTransceiverImplTest, SetRembSendsImmediatelyIfSendRembOnChange) {
433 const uint32_t kSenderSsrc = 12345;
434 RtcpTransceiverConfig config;
435 config.send_remb_on_change = true;
436 config.feedback_ssrc = kSenderSsrc;
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.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{});
444 EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
445 EXPECT_EQ(rtcp_parser.remb()->sender_ssrc(), kSenderSsrc);
446 EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 10000);
447
448 // If there is no change, the packet is not sent immediately.
449 rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{});
450 EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
451
452 rtcp_transceiver.SetRemb(/*bitrate_bps=*/20000, /*ssrcs=*/{});
453 EXPECT_EQ(rtcp_parser.remb()->num_packets(), 2);
454 EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 20000);
455 }
456
TEST(RtcpTransceiverImplTest,SetRembSendsImmediatelyIfSendRembOnChangeReducedSize)457 TEST(RtcpTransceiverImplTest,
458 SetRembSendsImmediatelyIfSendRembOnChangeReducedSize) {
459 const uint32_t kSenderSsrc = 12345;
460 RtcpTransceiverConfig config;
461 config.send_remb_on_change = true;
462 config.rtcp_mode = webrtc::RtcpMode::kReducedSize;
463 config.feedback_ssrc = kSenderSsrc;
464 RtcpPacketParser rtcp_parser;
465 RtcpParserTransport transport(&rtcp_parser);
466 config.outgoing_transport = &transport;
467 config.schedule_periodic_compound_packets = false;
468 RtcpTransceiverImpl rtcp_transceiver(config);
469
470 rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{});
471 EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
472 EXPECT_EQ(rtcp_parser.remb()->sender_ssrc(), kSenderSsrc);
473 EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 10000);
474 }
475
TEST(RtcpTransceiverImplTest,SetRembIncludesRembInAllCompoundPackets)476 TEST(RtcpTransceiverImplTest, SetRembIncludesRembInAllCompoundPackets) {
477 const uint32_t kSenderSsrc = 12345;
478 RtcpTransceiverConfig config;
479 config.feedback_ssrc = kSenderSsrc;
480 RtcpPacketParser rtcp_parser;
481 RtcpParserTransport transport(&rtcp_parser);
482 config.outgoing_transport = &transport;
483 config.schedule_periodic_compound_packets = false;
484 RtcpTransceiverImpl rtcp_transceiver(config);
485
486 rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{54321, 64321});
487 rtcp_transceiver.SendCompoundPacket();
488 rtcp_transceiver.SendCompoundPacket();
489
490 EXPECT_EQ(transport.num_packets(), 2);
491 EXPECT_EQ(rtcp_parser.remb()->num_packets(), 2);
492 }
493
TEST(RtcpTransceiverImplTest,SendsNoRembAfterUnset)494 TEST(RtcpTransceiverImplTest, SendsNoRembAfterUnset) {
495 const uint32_t kSenderSsrc = 12345;
496 RtcpTransceiverConfig config;
497 config.feedback_ssrc = kSenderSsrc;
498 RtcpPacketParser rtcp_parser;
499 RtcpParserTransport transport(&rtcp_parser);
500 config.outgoing_transport = &transport;
501 config.schedule_periodic_compound_packets = false;
502 RtcpTransceiverImpl rtcp_transceiver(config);
503
504 rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{54321, 64321});
505 rtcp_transceiver.SendCompoundPacket();
506 EXPECT_EQ(transport.num_packets(), 1);
507 ASSERT_EQ(rtcp_parser.remb()->num_packets(), 1);
508
509 rtcp_transceiver.UnsetRemb();
510 rtcp_transceiver.SendCompoundPacket();
511
512 EXPECT_EQ(transport.num_packets(), 2);
513 EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
514 }
515
TEST(RtcpTransceiverImplTest,ReceiverReportUsesReceiveStatistics)516 TEST(RtcpTransceiverImplTest, ReceiverReportUsesReceiveStatistics) {
517 const uint32_t kSenderSsrc = 12345;
518 const uint32_t kMediaSsrc = 54321;
519 MockReceiveStatisticsProvider receive_statistics;
520 std::vector<ReportBlock> report_blocks(1);
521 report_blocks[0].SetMediaSsrc(kMediaSsrc);
522 EXPECT_CALL(receive_statistics, RtcpReportBlocks(_))
523 .WillRepeatedly(Return(report_blocks));
524
525 RtcpTransceiverConfig config;
526 config.feedback_ssrc = kSenderSsrc;
527 RtcpPacketParser rtcp_parser;
528 RtcpParserTransport transport(&rtcp_parser);
529 config.outgoing_transport = &transport;
530 config.receive_statistics = &receive_statistics;
531 config.schedule_periodic_compound_packets = false;
532 RtcpTransceiverImpl rtcp_transceiver(config);
533
534 rtcp_transceiver.SendCompoundPacket();
535
536 ASSERT_GT(rtcp_parser.receiver_report()->num_packets(), 0);
537 EXPECT_EQ(rtcp_parser.receiver_report()->sender_ssrc(), kSenderSsrc);
538 ASSERT_THAT(rtcp_parser.receiver_report()->report_blocks(),
539 SizeIs(report_blocks.size()));
540 EXPECT_EQ(rtcp_parser.receiver_report()->report_blocks()[0].source_ssrc(),
541 kMediaSsrc);
542 }
543
TEST(RtcpTransceiverImplTest,MultipleObserversOnSameSsrc)544 TEST(RtcpTransceiverImplTest, MultipleObserversOnSameSsrc) {
545 const uint32_t kRemoteSsrc = 12345;
546 StrictMock<MockMediaReceiverRtcpObserver> observer1;
547 StrictMock<MockMediaReceiverRtcpObserver> observer2;
548 RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
549 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer1);
550 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer2);
551
552 const NtpTime kRemoteNtp(0x9876543211);
553 const uint32_t kRemoteRtp = 0x444555;
554 SenderReport sr;
555 sr.SetSenderSsrc(kRemoteSsrc);
556 sr.SetNtp(kRemoteNtp);
557 sr.SetRtpTimestamp(kRemoteRtp);
558 auto raw_packet = sr.Build();
559
560 EXPECT_CALL(observer1, OnSenderReport(kRemoteSsrc, kRemoteNtp, kRemoteRtp));
561 EXPECT_CALL(observer2, OnSenderReport(kRemoteSsrc, kRemoteNtp, kRemoteRtp));
562 rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
563 }
564
TEST(RtcpTransceiverImplTest,DoesntCallsObserverAfterRemoved)565 TEST(RtcpTransceiverImplTest, DoesntCallsObserverAfterRemoved) {
566 const uint32_t kRemoteSsrc = 12345;
567 StrictMock<MockMediaReceiverRtcpObserver> observer1;
568 StrictMock<MockMediaReceiverRtcpObserver> observer2;
569 RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
570 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer1);
571 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer2);
572
573 SenderReport sr;
574 sr.SetSenderSsrc(kRemoteSsrc);
575 auto raw_packet = sr.Build();
576
577 rtcp_transceiver.RemoveMediaReceiverRtcpObserver(kRemoteSsrc, &observer1);
578
579 EXPECT_CALL(observer1, OnSenderReport(_, _, _)).Times(0);
580 EXPECT_CALL(observer2, OnSenderReport(_, _, _));
581 rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
582 }
583
TEST(RtcpTransceiverImplTest,CallsObserverOnSenderReportBySenderSsrc)584 TEST(RtcpTransceiverImplTest, CallsObserverOnSenderReportBySenderSsrc) {
585 const uint32_t kRemoteSsrc1 = 12345;
586 const uint32_t kRemoteSsrc2 = 22345;
587 StrictMock<MockMediaReceiverRtcpObserver> observer1;
588 StrictMock<MockMediaReceiverRtcpObserver> observer2;
589 RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
590 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc1, &observer1);
591 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc2, &observer2);
592
593 const NtpTime kRemoteNtp(0x9876543211);
594 const uint32_t kRemoteRtp = 0x444555;
595 SenderReport sr;
596 sr.SetSenderSsrc(kRemoteSsrc1);
597 sr.SetNtp(kRemoteNtp);
598 sr.SetRtpTimestamp(kRemoteRtp);
599 auto raw_packet = sr.Build();
600
601 EXPECT_CALL(observer1, OnSenderReport(kRemoteSsrc1, kRemoteNtp, kRemoteRtp));
602 EXPECT_CALL(observer2, OnSenderReport(_, _, _)).Times(0);
603 rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
604 }
605
TEST(RtcpTransceiverImplTest,CallsObserverOnByeBySenderSsrc)606 TEST(RtcpTransceiverImplTest, CallsObserverOnByeBySenderSsrc) {
607 const uint32_t kRemoteSsrc1 = 12345;
608 const uint32_t kRemoteSsrc2 = 22345;
609 StrictMock<MockMediaReceiverRtcpObserver> observer1;
610 StrictMock<MockMediaReceiverRtcpObserver> observer2;
611 RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
612 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc1, &observer1);
613 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc2, &observer2);
614
615 Bye bye;
616 bye.SetSenderSsrc(kRemoteSsrc1);
617 auto raw_packet = bye.Build();
618
619 EXPECT_CALL(observer1, OnBye(kRemoteSsrc1));
620 EXPECT_CALL(observer2, OnBye(_)).Times(0);
621 rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
622 }
623
TEST(RtcpTransceiverImplTest,CallsObserverOnTargetBitrateBySenderSsrc)624 TEST(RtcpTransceiverImplTest, CallsObserverOnTargetBitrateBySenderSsrc) {
625 const uint32_t kRemoteSsrc1 = 12345;
626 const uint32_t kRemoteSsrc2 = 22345;
627 StrictMock<MockMediaReceiverRtcpObserver> observer1;
628 StrictMock<MockMediaReceiverRtcpObserver> observer2;
629 RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
630 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc1, &observer1);
631 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc2, &observer2);
632
633 webrtc::rtcp::TargetBitrate target_bitrate;
634 target_bitrate.AddTargetBitrate(0, 0, /*target_bitrate_kbps=*/10);
635 target_bitrate.AddTargetBitrate(0, 1, /*target_bitrate_kbps=*/20);
636 target_bitrate.AddTargetBitrate(1, 0, /*target_bitrate_kbps=*/40);
637 target_bitrate.AddTargetBitrate(1, 1, /*target_bitrate_kbps=*/80);
638 webrtc::rtcp::ExtendedReports xr;
639 xr.SetSenderSsrc(kRemoteSsrc1);
640 xr.SetTargetBitrate(target_bitrate);
641 auto raw_packet = xr.Build();
642
643 VideoBitrateAllocation bitrate_allocation;
644 bitrate_allocation.SetBitrate(0, 0, /*bitrate_bps=*/10000);
645 bitrate_allocation.SetBitrate(0, 1, /*bitrate_bps=*/20000);
646 bitrate_allocation.SetBitrate(1, 0, /*bitrate_bps=*/40000);
647 bitrate_allocation.SetBitrate(1, 1, /*bitrate_bps=*/80000);
648 EXPECT_CALL(observer1, OnBitrateAllocation(kRemoteSsrc1, bitrate_allocation));
649 EXPECT_CALL(observer2, OnBitrateAllocation(_, _)).Times(0);
650 rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
651 }
652
TEST(RtcpTransceiverImplTest,SkipsIncorrectTargetBitrateEntries)653 TEST(RtcpTransceiverImplTest, SkipsIncorrectTargetBitrateEntries) {
654 const uint32_t kRemoteSsrc = 12345;
655 MockMediaReceiverRtcpObserver observer;
656 RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
657 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer);
658
659 webrtc::rtcp::TargetBitrate target_bitrate;
660 target_bitrate.AddTargetBitrate(0, 0, /*target_bitrate_kbps=*/10);
661 target_bitrate.AddTargetBitrate(0, webrtc::kMaxTemporalStreams, 20);
662 target_bitrate.AddTargetBitrate(webrtc::kMaxSpatialLayers, 0, 40);
663
664 webrtc::rtcp::ExtendedReports xr;
665 xr.SetTargetBitrate(target_bitrate);
666 xr.SetSenderSsrc(kRemoteSsrc);
667 auto raw_packet = xr.Build();
668
669 VideoBitrateAllocation expected_allocation;
670 expected_allocation.SetBitrate(0, 0, /*bitrate_bps=*/10000);
671 EXPECT_CALL(observer, OnBitrateAllocation(kRemoteSsrc, expected_allocation));
672 rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
673 }
674
TEST(RtcpTransceiverImplTest,CallsObserverOnByeBehindSenderReport)675 TEST(RtcpTransceiverImplTest, CallsObserverOnByeBehindSenderReport) {
676 const uint32_t kRemoteSsrc = 12345;
677 MockMediaReceiverRtcpObserver observer;
678 RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
679 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer);
680
681 CompoundPacket compound;
682 auto sr = std::make_unique<SenderReport>();
683 sr->SetSenderSsrc(kRemoteSsrc);
684 compound.Append(std::move(sr));
685 auto bye = std::make_unique<Bye>();
686 bye->SetSenderSsrc(kRemoteSsrc);
687 compound.Append(std::move(bye));
688 auto raw_packet = compound.Build();
689
690 EXPECT_CALL(observer, OnBye(kRemoteSsrc));
691 EXPECT_CALL(observer, OnSenderReport(kRemoteSsrc, _, _));
692 rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
693 }
694
TEST(RtcpTransceiverImplTest,CallsObserverOnByeBehindUnknownRtcpPacket)695 TEST(RtcpTransceiverImplTest, CallsObserverOnByeBehindUnknownRtcpPacket) {
696 const uint32_t kRemoteSsrc = 12345;
697 MockMediaReceiverRtcpObserver observer;
698 RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
699 rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer);
700
701 CompoundPacket compound;
702 // Use Application-Defined rtcp packet as unknown.
703 auto app = std::make_unique<webrtc::rtcp::App>();
704 compound.Append(std::move(app));
705 auto bye = std::make_unique<Bye>();
706 bye->SetSenderSsrc(kRemoteSsrc);
707 compound.Append(std::move(bye));
708 auto raw_packet = compound.Build();
709
710 EXPECT_CALL(observer, OnBye(kRemoteSsrc));
711 rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
712 }
713
TEST(RtcpTransceiverImplTest,WhenSendsReceiverReportSetsLastSenderReportTimestampPerRemoteSsrc)714 TEST(RtcpTransceiverImplTest,
715 WhenSendsReceiverReportSetsLastSenderReportTimestampPerRemoteSsrc) {
716 const uint32_t kRemoteSsrc1 = 4321;
717 const uint32_t kRemoteSsrc2 = 5321;
718 std::vector<ReportBlock> statistics_report_blocks(2);
719 statistics_report_blocks[0].SetMediaSsrc(kRemoteSsrc1);
720 statistics_report_blocks[1].SetMediaSsrc(kRemoteSsrc2);
721 MockReceiveStatisticsProvider receive_statistics;
722 EXPECT_CALL(receive_statistics, RtcpReportBlocks(_))
723 .WillOnce(Return(statistics_report_blocks));
724
725 RtcpTransceiverConfig config;
726 config.schedule_periodic_compound_packets = false;
727 RtcpPacketParser rtcp_parser;
728 RtcpParserTransport transport(&rtcp_parser);
729 config.outgoing_transport = &transport;
730 config.receive_statistics = &receive_statistics;
731 RtcpTransceiverImpl rtcp_transceiver(config);
732
733 const NtpTime kRemoteNtp(0x9876543211);
734 // Receive SenderReport for RemoteSsrc1, but no report for RemoteSsrc2.
735 SenderReport sr;
736 sr.SetSenderSsrc(kRemoteSsrc1);
737 sr.SetNtp(kRemoteNtp);
738 auto raw_packet = sr.Build();
739 rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
740
741 // Trigger sending ReceiverReport.
742 rtcp_transceiver.SendCompoundPacket();
743
744 EXPECT_GT(rtcp_parser.receiver_report()->num_packets(), 0);
745 const auto& report_blocks = rtcp_parser.receiver_report()->report_blocks();
746 ASSERT_EQ(report_blocks.size(), 2u);
747 // RtcpTransceiverImpl doesn't guarantee order of the report blocks
748 // match result of ReceiveStatisticsProvider::RtcpReportBlocks callback,
749 // but for simplicity of the test asume it is the same.
750 ASSERT_EQ(report_blocks[0].source_ssrc(), kRemoteSsrc1);
751 EXPECT_EQ(report_blocks[0].last_sr(), CompactNtp(kRemoteNtp));
752
753 ASSERT_EQ(report_blocks[1].source_ssrc(), kRemoteSsrc2);
754 // No matching Sender Report for kRemoteSsrc2, LastSR fields has to be 0.
755 EXPECT_EQ(report_blocks[1].last_sr(), 0u);
756 }
757
TEST(RtcpTransceiverImplTest,WhenSendsReceiverReportCalculatesDelaySinceLastSenderReport)758 TEST(RtcpTransceiverImplTest,
759 WhenSendsReceiverReportCalculatesDelaySinceLastSenderReport) {
760 const uint32_t kRemoteSsrc1 = 4321;
761 const uint32_t kRemoteSsrc2 = 5321;
762 rtc::ScopedFakeClock clock;
763 std::vector<ReportBlock> statistics_report_blocks(2);
764 statistics_report_blocks[0].SetMediaSsrc(kRemoteSsrc1);
765 statistics_report_blocks[1].SetMediaSsrc(kRemoteSsrc2);
766 MockReceiveStatisticsProvider receive_statistics;
767 EXPECT_CALL(receive_statistics, RtcpReportBlocks(_))
768 .WillOnce(Return(statistics_report_blocks));
769
770 RtcpTransceiverConfig config;
771 config.schedule_periodic_compound_packets = false;
772 RtcpPacketParser rtcp_parser;
773 RtcpParserTransport transport(&rtcp_parser);
774 config.outgoing_transport = &transport;
775 config.receive_statistics = &receive_statistics;
776 RtcpTransceiverImpl rtcp_transceiver(config);
777
778 auto receive_sender_report = [&rtcp_transceiver](uint32_t remote_ssrc) {
779 SenderReport sr;
780 sr.SetSenderSsrc(remote_ssrc);
781 auto raw_packet = sr.Build();
782 rtcp_transceiver.ReceivePacket(raw_packet, rtc::TimeMicros());
783 };
784
785 receive_sender_report(kRemoteSsrc1);
786 clock.AdvanceTime(webrtc::TimeDelta::Millis(100));
787
788 receive_sender_report(kRemoteSsrc2);
789 clock.AdvanceTime(webrtc::TimeDelta::Millis(100));
790
791 // Trigger ReceiverReport back.
792 rtcp_transceiver.SendCompoundPacket();
793
794 EXPECT_GT(rtcp_parser.receiver_report()->num_packets(), 0);
795 const auto& report_blocks = rtcp_parser.receiver_report()->report_blocks();
796 ASSERT_EQ(report_blocks.size(), 2u);
797 // RtcpTransceiverImpl doesn't guarantee order of the report blocks
798 // match result of ReceiveStatisticsProvider::RtcpReportBlocks callback,
799 // but for simplicity of the test asume it is the same.
800 ASSERT_EQ(report_blocks[0].source_ssrc(), kRemoteSsrc1);
801 EXPECT_EQ(CompactNtpRttToMs(report_blocks[0].delay_since_last_sr()), 200);
802
803 ASSERT_EQ(report_blocks[1].source_ssrc(), kRemoteSsrc2);
804 EXPECT_EQ(CompactNtpRttToMs(report_blocks[1].delay_since_last_sr()), 100);
805 }
806
TEST(RtcpTransceiverImplTest,SendsNack)807 TEST(RtcpTransceiverImplTest, SendsNack) {
808 const uint32_t kSenderSsrc = 1234;
809 const uint32_t kRemoteSsrc = 4321;
810 std::vector<uint16_t> kMissingSequenceNumbers = {34, 37, 38};
811 RtcpTransceiverConfig config;
812 config.feedback_ssrc = kSenderSsrc;
813 config.schedule_periodic_compound_packets = false;
814 RtcpPacketParser rtcp_parser;
815 RtcpParserTransport transport(&rtcp_parser);
816 config.outgoing_transport = &transport;
817 RtcpTransceiverImpl rtcp_transceiver(config);
818
819 rtcp_transceiver.SendNack(kRemoteSsrc, kMissingSequenceNumbers);
820
821 EXPECT_EQ(rtcp_parser.nack()->num_packets(), 1);
822 EXPECT_EQ(rtcp_parser.nack()->sender_ssrc(), kSenderSsrc);
823 EXPECT_EQ(rtcp_parser.nack()->media_ssrc(), kRemoteSsrc);
824 EXPECT_EQ(rtcp_parser.nack()->packet_ids(), kMissingSequenceNumbers);
825 }
826
TEST(RtcpTransceiverImplTest,RequestKeyFrameWithPictureLossIndication)827 TEST(RtcpTransceiverImplTest, RequestKeyFrameWithPictureLossIndication) {
828 const uint32_t kSenderSsrc = 1234;
829 const uint32_t kRemoteSsrc = 4321;
830 RtcpTransceiverConfig config;
831 config.feedback_ssrc = kSenderSsrc;
832 config.schedule_periodic_compound_packets = false;
833 RtcpPacketParser rtcp_parser;
834 RtcpParserTransport transport(&rtcp_parser);
835 config.outgoing_transport = &transport;
836 RtcpTransceiverImpl rtcp_transceiver(config);
837
838 rtcp_transceiver.SendPictureLossIndication(kRemoteSsrc);
839
840 EXPECT_EQ(transport.num_packets(), 1);
841 EXPECT_EQ(rtcp_parser.pli()->num_packets(), 1);
842 EXPECT_EQ(rtcp_parser.pli()->sender_ssrc(), kSenderSsrc);
843 EXPECT_EQ(rtcp_parser.pli()->media_ssrc(), kRemoteSsrc);
844 }
845
TEST(RtcpTransceiverImplTest,RequestKeyFrameWithFullIntraRequest)846 TEST(RtcpTransceiverImplTest, RequestKeyFrameWithFullIntraRequest) {
847 const uint32_t kSenderSsrc = 1234;
848 const uint32_t kRemoteSsrcs[] = {4321, 5321};
849 RtcpTransceiverConfig config;
850 config.feedback_ssrc = kSenderSsrc;
851 config.schedule_periodic_compound_packets = false;
852 RtcpPacketParser rtcp_parser;
853 RtcpParserTransport transport(&rtcp_parser);
854 config.outgoing_transport = &transport;
855 RtcpTransceiverImpl rtcp_transceiver(config);
856
857 rtcp_transceiver.SendFullIntraRequest(kRemoteSsrcs, true);
858
859 EXPECT_EQ(rtcp_parser.fir()->num_packets(), 1);
860 EXPECT_EQ(rtcp_parser.fir()->sender_ssrc(), kSenderSsrc);
861 EXPECT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kRemoteSsrcs[0]);
862 EXPECT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kRemoteSsrcs[1]);
863 }
864
TEST(RtcpTransceiverImplTest,RequestKeyFrameWithFirIncreaseSeqNoPerSsrc)865 TEST(RtcpTransceiverImplTest, RequestKeyFrameWithFirIncreaseSeqNoPerSsrc) {
866 RtcpTransceiverConfig config;
867 config.schedule_periodic_compound_packets = false;
868 RtcpPacketParser rtcp_parser;
869 RtcpParserTransport transport(&rtcp_parser);
870 config.outgoing_transport = &transport;
871 RtcpTransceiverImpl rtcp_transceiver(config);
872
873 const uint32_t kBothRemoteSsrcs[] = {4321, 5321};
874 const uint32_t kOneRemoteSsrc[] = {4321};
875
876 rtcp_transceiver.SendFullIntraRequest(kBothRemoteSsrcs, true);
877 ASSERT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kBothRemoteSsrcs[0]);
878 uint8_t fir_sequence_number0 = rtcp_parser.fir()->requests()[0].seq_nr;
879 ASSERT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kBothRemoteSsrcs[1]);
880 uint8_t fir_sequence_number1 = rtcp_parser.fir()->requests()[1].seq_nr;
881
882 rtcp_transceiver.SendFullIntraRequest(kOneRemoteSsrc, true);
883 ASSERT_EQ(rtcp_parser.fir()->requests().size(), 1u);
884 ASSERT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kBothRemoteSsrcs[0]);
885 EXPECT_EQ(rtcp_parser.fir()->requests()[0].seq_nr, fir_sequence_number0 + 1);
886
887 rtcp_transceiver.SendFullIntraRequest(kBothRemoteSsrcs, true);
888 ASSERT_EQ(rtcp_parser.fir()->requests().size(), 2u);
889 ASSERT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kBothRemoteSsrcs[0]);
890 EXPECT_EQ(rtcp_parser.fir()->requests()[0].seq_nr, fir_sequence_number0 + 2);
891 ASSERT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kBothRemoteSsrcs[1]);
892 EXPECT_EQ(rtcp_parser.fir()->requests()[1].seq_nr, fir_sequence_number1 + 1);
893 }
894
TEST(RtcpTransceiverImplTest,SendFirDoesNotIncreaseSeqNoIfOldRequest)895 TEST(RtcpTransceiverImplTest, SendFirDoesNotIncreaseSeqNoIfOldRequest) {
896 RtcpTransceiverConfig config;
897 config.schedule_periodic_compound_packets = false;
898 RtcpPacketParser rtcp_parser;
899 RtcpParserTransport transport(&rtcp_parser);
900 config.outgoing_transport = &transport;
901 RtcpTransceiverImpl rtcp_transceiver(config);
902
903 const uint32_t kBothRemoteSsrcs[] = {4321, 5321};
904
905 rtcp_transceiver.SendFullIntraRequest(kBothRemoteSsrcs, true);
906 ASSERT_EQ(rtcp_parser.fir()->requests().size(), 2u);
907 ASSERT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kBothRemoteSsrcs[0]);
908 uint8_t fir_sequence_number0 = rtcp_parser.fir()->requests()[0].seq_nr;
909 ASSERT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kBothRemoteSsrcs[1]);
910 uint8_t fir_sequence_number1 = rtcp_parser.fir()->requests()[1].seq_nr;
911
912 rtcp_transceiver.SendFullIntraRequest(kBothRemoteSsrcs, false);
913 ASSERT_EQ(rtcp_parser.fir()->requests().size(), 2u);
914 ASSERT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kBothRemoteSsrcs[0]);
915 EXPECT_EQ(rtcp_parser.fir()->requests()[0].seq_nr, fir_sequence_number0);
916 ASSERT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kBothRemoteSsrcs[1]);
917 EXPECT_EQ(rtcp_parser.fir()->requests()[1].seq_nr, fir_sequence_number1);
918 }
919
TEST(RtcpTransceiverImplTest,KeyFrameRequestCreatesCompoundPacket)920 TEST(RtcpTransceiverImplTest, KeyFrameRequestCreatesCompoundPacket) {
921 const uint32_t kRemoteSsrcs[] = {4321};
922 RtcpTransceiverConfig config;
923 // Turn periodic off to ensure sent rtcp packet is explicitly requested.
924 config.schedule_periodic_compound_packets = false;
925 RtcpPacketParser rtcp_parser;
926 RtcpParserTransport transport(&rtcp_parser);
927 config.outgoing_transport = &transport;
928
929 config.rtcp_mode = webrtc::RtcpMode::kCompound;
930
931 RtcpTransceiverImpl rtcp_transceiver(config);
932 rtcp_transceiver.SendFullIntraRequest(kRemoteSsrcs, true);
933
934 // Test sent packet is compound by expecting presense of receiver report.
935 EXPECT_EQ(transport.num_packets(), 1);
936 EXPECT_EQ(rtcp_parser.receiver_report()->num_packets(), 1);
937 }
938
TEST(RtcpTransceiverImplTest,KeyFrameRequestCreatesReducedSizePacket)939 TEST(RtcpTransceiverImplTest, KeyFrameRequestCreatesReducedSizePacket) {
940 const uint32_t kRemoteSsrcs[] = {4321};
941 RtcpTransceiverConfig config;
942 // Turn periodic off to ensure sent rtcp packet is explicitly requested.
943 config.schedule_periodic_compound_packets = false;
944 RtcpPacketParser rtcp_parser;
945 RtcpParserTransport transport(&rtcp_parser);
946 config.outgoing_transport = &transport;
947
948 config.rtcp_mode = webrtc::RtcpMode::kReducedSize;
949
950 RtcpTransceiverImpl rtcp_transceiver(config);
951 rtcp_transceiver.SendFullIntraRequest(kRemoteSsrcs, true);
952
953 // Test sent packet is reduced size by expecting absense of receiver report.
954 EXPECT_EQ(transport.num_packets(), 1);
955 EXPECT_EQ(rtcp_parser.receiver_report()->num_packets(), 0);
956 }
957
TEST(RtcpTransceiverImplTest,SendsXrRrtrWhenEnabled)958 TEST(RtcpTransceiverImplTest, SendsXrRrtrWhenEnabled) {
959 const uint32_t kSenderSsrc = 4321;
960 rtc::ScopedFakeClock clock;
961 RtcpTransceiverConfig config;
962 config.feedback_ssrc = kSenderSsrc;
963 config.schedule_periodic_compound_packets = false;
964 RtcpPacketParser rtcp_parser;
965 RtcpParserTransport transport(&rtcp_parser);
966 config.outgoing_transport = &transport;
967 config.non_sender_rtt_measurement = true;
968 RtcpTransceiverImpl rtcp_transceiver(config);
969
970 rtcp_transceiver.SendCompoundPacket();
971 NtpTime ntp_time_now = TimeMicrosToNtp(rtc::TimeMicros());
972
973 EXPECT_EQ(rtcp_parser.xr()->num_packets(), 1);
974 EXPECT_EQ(rtcp_parser.xr()->sender_ssrc(), kSenderSsrc);
975 ASSERT_TRUE(rtcp_parser.xr()->rrtr());
976 EXPECT_EQ(rtcp_parser.xr()->rrtr()->ntp(), ntp_time_now);
977 }
978
TEST(RtcpTransceiverImplTest,SendsNoXrRrtrWhenDisabled)979 TEST(RtcpTransceiverImplTest, SendsNoXrRrtrWhenDisabled) {
980 RtcpTransceiverConfig config;
981 config.schedule_periodic_compound_packets = false;
982 RtcpPacketParser rtcp_parser;
983 RtcpParserTransport transport(&rtcp_parser);
984 config.outgoing_transport = &transport;
985 config.non_sender_rtt_measurement = false;
986 RtcpTransceiverImpl rtcp_transceiver(config);
987
988 rtcp_transceiver.SendCompoundPacket();
989
990 EXPECT_EQ(transport.num_packets(), 1);
991 // Extended reports rtcp packet might be included for another reason,
992 // but it shouldn't contain rrtr block.
993 EXPECT_FALSE(rtcp_parser.xr()->rrtr());
994 }
995
TEST(RtcpTransceiverImplTest,CalculatesRoundTripTimeOnDlrr)996 TEST(RtcpTransceiverImplTest, CalculatesRoundTripTimeOnDlrr) {
997 const uint32_t kSenderSsrc = 4321;
998 MockRtcpRttStats rtt_observer;
999 MockTransport null_transport;
1000 RtcpTransceiverConfig config;
1001 config.feedback_ssrc = kSenderSsrc;
1002 config.schedule_periodic_compound_packets = false;
1003 config.outgoing_transport = &null_transport;
1004 config.non_sender_rtt_measurement = true;
1005 config.rtt_observer = &rtt_observer;
1006 RtcpTransceiverImpl rtcp_transceiver(config);
1007
1008 int64_t time_us = 12345678;
1009 webrtc::rtcp::ReceiveTimeInfo rti;
1010 rti.ssrc = kSenderSsrc;
1011 rti.last_rr = CompactNtp(TimeMicrosToNtp(time_us));
1012 rti.delay_since_last_rr = SaturatedUsToCompactNtp(10 * 1000);
1013 webrtc::rtcp::ExtendedReports xr;
1014 xr.AddDlrrItem(rti);
1015 auto raw_packet = xr.Build();
1016
1017 EXPECT_CALL(rtt_observer, OnRttUpdate(100 /* rtt_ms */));
1018 rtcp_transceiver.ReceivePacket(raw_packet, time_us + 110 * 1000);
1019 }
1020
TEST(RtcpTransceiverImplTest,IgnoresUnknownSsrcInDlrr)1021 TEST(RtcpTransceiverImplTest, IgnoresUnknownSsrcInDlrr) {
1022 const uint32_t kSenderSsrc = 4321;
1023 const uint32_t kUnknownSsrc = 4322;
1024 MockRtcpRttStats rtt_observer;
1025 MockTransport null_transport;
1026 RtcpTransceiverConfig config;
1027 config.feedback_ssrc = kSenderSsrc;
1028 config.schedule_periodic_compound_packets = false;
1029 config.outgoing_transport = &null_transport;
1030 config.non_sender_rtt_measurement = true;
1031 config.rtt_observer = &rtt_observer;
1032 RtcpTransceiverImpl rtcp_transceiver(config);
1033
1034 int64_t time_us = 12345678;
1035 webrtc::rtcp::ReceiveTimeInfo rti;
1036 rti.ssrc = kUnknownSsrc;
1037 rti.last_rr = CompactNtp(TimeMicrosToNtp(time_us));
1038 webrtc::rtcp::ExtendedReports xr;
1039 xr.AddDlrrItem(rti);
1040 auto raw_packet = xr.Build();
1041
1042 EXPECT_CALL(rtt_observer, OnRttUpdate(_)).Times(0);
1043 rtcp_transceiver.ReceivePacket(raw_packet, time_us + 100000);
1044 }
1045
1046 } // namespace
1047