1 /*
2 * Copyright (c) 2015 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/pacing/packet_router.h"
12
13 #include <cstddef>
14 #include <cstdint>
15 #include <memory>
16 #include <utility>
17
18 #include "api/units/time_delta.h"
19 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
20 #include "modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
21 #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
22 #include "rtc_base/checks.h"
23 #include "rtc_base/fake_clock.h"
24 #include "test/gmock.h"
25 #include "test/gtest.h"
26
27 namespace webrtc {
28
29 // TODO(eladalon): Restructure and/or replace the existing monolithic tests
30 // (only some of the test are monolithic) according to the new
31 // guidelines - small tests for one thing at a time.
32 // (I'm not removing any tests during CL, so as to demonstrate no regressions.)
33
34 namespace {
35
36 using ::testing::_;
37 using ::testing::AnyNumber;
38 using ::testing::AtLeast;
39 using ::testing::Field;
40 using ::testing::Gt;
41 using ::testing::Le;
42 using ::testing::NiceMock;
43 using ::testing::Property;
44 using ::testing::Return;
45 using ::testing::SaveArg;
46
47 constexpr int kProbeMinProbes = 5;
48 constexpr int kProbeMinBytes = 1000;
49
50 } // namespace
51
52 class PacketRouterTest : public ::testing::Test {
53 public:
PacketRouterTest()54 PacketRouterTest() {
55 extension_manager.Register<TransportSequenceNumber>(/*id=*/1);
56 }
57
58 protected:
BuildRtpPacket(uint32_t ssrc)59 std::unique_ptr<RtpPacketToSend> BuildRtpPacket(uint32_t ssrc) {
60 std::unique_ptr<RtpPacketToSend> packet =
61 std::make_unique<RtpPacketToSend>(&extension_manager);
62 packet->SetSsrc(ssrc);
63 return packet;
64 }
65
66 PacketRouter packet_router_;
67 RtpHeaderExtensionMap extension_manager;
68 };
69
TEST_F(PacketRouterTest,Sanity_NoModuleRegistered_GeneratePadding)70 TEST_F(PacketRouterTest, Sanity_NoModuleRegistered_GeneratePadding) {
71 constexpr DataSize bytes = DataSize::Bytes(300);
72 const PacedPacketInfo paced_info(1, kProbeMinProbes, kProbeMinBytes);
73
74 EXPECT_TRUE(packet_router_.GeneratePadding(bytes).empty());
75 }
76
TEST_F(PacketRouterTest,Sanity_NoModuleRegistered_OnReceiveBitrateChanged)77 TEST_F(PacketRouterTest, Sanity_NoModuleRegistered_OnReceiveBitrateChanged) {
78 const std::vector<uint32_t> ssrcs = {1, 2, 3};
79 constexpr uint32_t bitrate_bps = 10000;
80
81 packet_router_.OnReceiveBitrateChanged(ssrcs, bitrate_bps);
82 }
83
TEST_F(PacketRouterTest,Sanity_NoModuleRegistered_SendRemb)84 TEST_F(PacketRouterTest, Sanity_NoModuleRegistered_SendRemb) {
85 const std::vector<uint32_t> ssrcs = {1, 2, 3};
86 constexpr uint32_t bitrate_bps = 10000;
87
88 EXPECT_FALSE(packet_router_.SendRemb(bitrate_bps, ssrcs));
89 }
90
TEST_F(PacketRouterTest,Sanity_NoModuleRegistered_SendTransportFeedback)91 TEST_F(PacketRouterTest, Sanity_NoModuleRegistered_SendTransportFeedback) {
92 std::vector<std::unique_ptr<rtcp::RtcpPacket>> feedback;
93 feedback.push_back(std::make_unique<rtcp::TransportFeedback>());
94
95 EXPECT_FALSE(packet_router_.SendCombinedRtcpPacket(std::move(feedback)));
96 }
97
TEST_F(PacketRouterTest,GeneratePaddingPrioritizesRtx)98 TEST_F(PacketRouterTest, GeneratePaddingPrioritizesRtx) {
99 // Two RTP modules. The first (prioritized due to rtx) isn't sending media so
100 // should not be called.
101 const uint16_t kSsrc1 = 1234;
102 const uint16_t kSsrc2 = 4567;
103
104 NiceMock<MockRtpRtcpInterface> rtp_1;
105 ON_CALL(rtp_1, RtxSendStatus()).WillByDefault(Return(kRtxRedundantPayloads));
106 ON_CALL(rtp_1, SSRC()).WillByDefault(Return(kSsrc1));
107 ON_CALL(rtp_1, SupportsPadding).WillByDefault(Return(false));
108
109 NiceMock<MockRtpRtcpInterface> rtp_2;
110 ON_CALL(rtp_2, RtxSendStatus()).WillByDefault(Return(kRtxOff));
111 ON_CALL(rtp_2, SSRC()).WillByDefault(Return(kSsrc2));
112 ON_CALL(rtp_2, SupportsPadding).WillByDefault(Return(true));
113
114 packet_router_.AddSendRtpModule(&rtp_1, false);
115 packet_router_.AddSendRtpModule(&rtp_2, false);
116
117 const size_t kPaddingSize = 123;
118 const size_t kExpectedPaddingPackets = 1;
119 EXPECT_CALL(rtp_1, GeneratePadding(_)).Times(0);
120 EXPECT_CALL(rtp_2, GeneratePadding(kPaddingSize))
121 .WillOnce([&](size_t padding_size) {
122 return std::vector<std::unique_ptr<RtpPacketToSend>>(
123 kExpectedPaddingPackets);
124 });
125 auto generated_padding =
126 packet_router_.GeneratePadding(DataSize::Bytes(kPaddingSize));
127 EXPECT_EQ(generated_padding.size(), kExpectedPaddingPackets);
128
129 packet_router_.RemoveSendRtpModule(&rtp_1);
130 packet_router_.RemoveSendRtpModule(&rtp_2);
131 }
132
TEST_F(PacketRouterTest,GeneratePaddingPrioritizesVideo)133 TEST_F(PacketRouterTest, GeneratePaddingPrioritizesVideo) {
134 // Two RTP modules. Neither support RTX, both support padding,
135 // but the first one is for audio and second for video.
136 const uint16_t kSsrc1 = 1234;
137 const uint16_t kSsrc2 = 4567;
138 const size_t kPaddingSize = 123;
139 const size_t kExpectedPaddingPackets = 1;
140
141 auto generate_padding = [&](size_t padding_size) {
142 return std::vector<std::unique_ptr<RtpPacketToSend>>(
143 kExpectedPaddingPackets);
144 };
145
146 NiceMock<MockRtpRtcpInterface> audio_module;
147 ON_CALL(audio_module, RtxSendStatus()).WillByDefault(Return(kRtxOff));
148 ON_CALL(audio_module, SSRC()).WillByDefault(Return(kSsrc1));
149 ON_CALL(audio_module, SupportsPadding).WillByDefault(Return(true));
150 ON_CALL(audio_module, IsAudioConfigured).WillByDefault(Return(true));
151
152 NiceMock<MockRtpRtcpInterface> video_module;
153 ON_CALL(video_module, RtxSendStatus()).WillByDefault(Return(kRtxOff));
154 ON_CALL(video_module, SSRC()).WillByDefault(Return(kSsrc2));
155 ON_CALL(video_module, SupportsPadding).WillByDefault(Return(true));
156 ON_CALL(video_module, IsAudioConfigured).WillByDefault(Return(false));
157
158 // First add only the audio module. Since this is the only choice we have,
159 // padding should be sent on the audio ssrc.
160 packet_router_.AddSendRtpModule(&audio_module, false);
161 EXPECT_CALL(audio_module, GeneratePadding(kPaddingSize))
162 .WillOnce(generate_padding);
163 packet_router_.GeneratePadding(DataSize::Bytes(kPaddingSize));
164
165 // Add the video module, this should now be prioritized since we cannot
166 // guarantee that audio packets will be included in the BWE.
167 packet_router_.AddSendRtpModule(&video_module, false);
168 EXPECT_CALL(audio_module, GeneratePadding).Times(0);
169 EXPECT_CALL(video_module, GeneratePadding(kPaddingSize))
170 .WillOnce(generate_padding);
171 packet_router_.GeneratePadding(DataSize::Bytes(kPaddingSize));
172
173 // Remove and the add audio module again. Module order shouldn't matter;
174 // video should still be prioritized.
175 packet_router_.RemoveSendRtpModule(&audio_module);
176 packet_router_.AddSendRtpModule(&audio_module, false);
177 EXPECT_CALL(audio_module, GeneratePadding).Times(0);
178 EXPECT_CALL(video_module, GeneratePadding(kPaddingSize))
179 .WillOnce(generate_padding);
180 packet_router_.GeneratePadding(DataSize::Bytes(kPaddingSize));
181
182 // Remove and the video module, we should fall back to padding on the
183 // audio module again.
184 packet_router_.RemoveSendRtpModule(&video_module);
185 EXPECT_CALL(audio_module, GeneratePadding(kPaddingSize))
186 .WillOnce(generate_padding);
187 packet_router_.GeneratePadding(DataSize::Bytes(kPaddingSize));
188
189 packet_router_.RemoveSendRtpModule(&audio_module);
190 }
191
TEST_F(PacketRouterTest,PadsOnLastActiveMediaStream)192 TEST_F(PacketRouterTest, PadsOnLastActiveMediaStream) {
193 const uint16_t kSsrc1 = 1234;
194 const uint16_t kSsrc2 = 4567;
195 const uint16_t kSsrc3 = 8901;
196
197 // First two rtp modules send media and have rtx.
198 NiceMock<MockRtpRtcpInterface> rtp_1;
199 EXPECT_CALL(rtp_1, SSRC()).WillRepeatedly(Return(kSsrc1));
200 EXPECT_CALL(rtp_1, SupportsPadding).WillRepeatedly(Return(true));
201 EXPECT_CALL(rtp_1, SupportsRtxPayloadPadding).WillRepeatedly(Return(true));
202 EXPECT_CALL(rtp_1, TrySendPacket).WillRepeatedly(Return(false));
203 EXPECT_CALL(
204 rtp_1,
205 TrySendPacket(
206 ::testing::Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc1)), _))
207 .WillRepeatedly(Return(true));
208
209 NiceMock<MockRtpRtcpInterface> rtp_2;
210 EXPECT_CALL(rtp_2, SSRC()).WillRepeatedly(Return(kSsrc2));
211 EXPECT_CALL(rtp_2, SupportsPadding).WillRepeatedly(Return(true));
212 EXPECT_CALL(rtp_2, SupportsRtxPayloadPadding).WillRepeatedly(Return(true));
213 EXPECT_CALL(rtp_2, TrySendPacket).WillRepeatedly(Return(false));
214 EXPECT_CALL(
215 rtp_2,
216 TrySendPacket(
217 ::testing::Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc2)), _))
218 .WillRepeatedly(Return(true));
219
220 // Third module is sending media, but does not support rtx.
221 NiceMock<MockRtpRtcpInterface> rtp_3;
222 EXPECT_CALL(rtp_3, SSRC()).WillRepeatedly(Return(kSsrc3));
223 EXPECT_CALL(rtp_3, SupportsPadding).WillRepeatedly(Return(true));
224 EXPECT_CALL(rtp_3, SupportsRtxPayloadPadding).WillRepeatedly(Return(false));
225 EXPECT_CALL(rtp_3, TrySendPacket).WillRepeatedly(Return(false));
226 EXPECT_CALL(
227 rtp_3,
228 TrySendPacket(
229 ::testing::Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc3)), _))
230 .WillRepeatedly(Return(true));
231
232 packet_router_.AddSendRtpModule(&rtp_1, false);
233 packet_router_.AddSendRtpModule(&rtp_2, false);
234 packet_router_.AddSendRtpModule(&rtp_3, false);
235
236 const size_t kPaddingBytes = 100;
237
238 // Initially, padding will be sent on last added rtp module that sends media
239 // and supports rtx.
240 EXPECT_CALL(rtp_2, GeneratePadding(kPaddingBytes))
241 .Times(1)
242 .WillOnce([&](size_t target_size_bytes) {
243 std::vector<std::unique_ptr<RtpPacketToSend>> packets;
244 packets.push_back(BuildRtpPacket(kSsrc2));
245 return packets;
246 });
247 packet_router_.GeneratePadding(DataSize::Bytes(kPaddingBytes));
248
249 // Send media on first module. Padding should be sent on that module.
250 packet_router_.SendPacket(BuildRtpPacket(kSsrc1), PacedPacketInfo());
251
252 EXPECT_CALL(rtp_1, GeneratePadding(kPaddingBytes))
253 .Times(1)
254 .WillOnce([&](size_t target_size_bytes) {
255 std::vector<std::unique_ptr<RtpPacketToSend>> packets;
256 packets.push_back(BuildRtpPacket(kSsrc1));
257 return packets;
258 });
259 packet_router_.GeneratePadding(DataSize::Bytes(kPaddingBytes));
260
261 // Send media on second module. Padding should be sent there.
262 packet_router_.SendPacket(BuildRtpPacket(kSsrc2), PacedPacketInfo());
263
264 // If the last active module is removed, and no module sends media before
265 // the next padding request, and arbitrary module will be selected.
266 packet_router_.RemoveSendRtpModule(&rtp_2);
267
268 // Send on and then remove all remaining modules.
269 RtpRtcpInterface* last_send_module;
270 EXPECT_CALL(rtp_1, GeneratePadding(kPaddingBytes))
271 .Times(1)
272 .WillOnce([&](size_t target_size_bytes) {
273 last_send_module = &rtp_1;
274 std::vector<std::unique_ptr<RtpPacketToSend>> packets;
275 packets.push_back(BuildRtpPacket(kSsrc1));
276 return packets;
277 });
278 EXPECT_CALL(rtp_3, GeneratePadding(kPaddingBytes))
279 .Times(1)
280 .WillOnce([&](size_t target_size_bytes) {
281 last_send_module = &rtp_3;
282 std::vector<std::unique_ptr<RtpPacketToSend>> packets;
283 packets.push_back(BuildRtpPacket(kSsrc3));
284 return packets;
285 });
286
287 for (int i = 0; i < 2; ++i) {
288 last_send_module = nullptr;
289 packet_router_.GeneratePadding(DataSize::Bytes(kPaddingBytes));
290 EXPECT_NE(last_send_module, nullptr);
291 packet_router_.RemoveSendRtpModule(last_send_module);
292 }
293 }
294
TEST_F(PacketRouterTest,AllocatesTransportSequenceNumbers)295 TEST_F(PacketRouterTest, AllocatesTransportSequenceNumbers) {
296 const uint16_t kStartSeq = 0xFFF0;
297 const size_t kNumPackets = 32;
298 const uint16_t kSsrc1 = 1234;
299
300 PacketRouter packet_router(kStartSeq - 1);
301 NiceMock<MockRtpRtcpInterface> rtp_1;
302 EXPECT_CALL(rtp_1, SSRC()).WillRepeatedly(Return(kSsrc1));
303 EXPECT_CALL(rtp_1, TrySendPacket).WillRepeatedly(Return(true));
304 packet_router.AddSendRtpModule(&rtp_1, false);
305
306 for (size_t i = 0; i < kNumPackets; ++i) {
307 auto packet = BuildRtpPacket(kSsrc1);
308 EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>());
309 packet_router.SendPacket(std::move(packet), PacedPacketInfo());
310 uint32_t expected_unwrapped_seq = static_cast<uint32_t>(kStartSeq) + i;
311 EXPECT_EQ(static_cast<uint16_t>(expected_unwrapped_seq & 0xFFFF),
312 packet_router.CurrentTransportSequenceNumber());
313 }
314
315 packet_router.RemoveSendRtpModule(&rtp_1);
316 }
317
TEST_F(PacketRouterTest,SendTransportFeedback)318 TEST_F(PacketRouterTest, SendTransportFeedback) {
319 NiceMock<MockRtpRtcpInterface> rtp_1;
320 NiceMock<MockRtpRtcpInterface> rtp_2;
321
322 ON_CALL(rtp_1, RTCP()).WillByDefault(Return(RtcpMode::kCompound));
323 ON_CALL(rtp_2, RTCP()).WillByDefault(Return(RtcpMode::kCompound));
324
325 packet_router_.AddSendRtpModule(&rtp_1, false);
326 packet_router_.AddReceiveRtpModule(&rtp_2, false);
327
328 std::vector<std::unique_ptr<rtcp::RtcpPacket>> feedback;
329 feedback.push_back(std::make_unique<rtcp::TransportFeedback>());
330 EXPECT_CALL(rtp_1, SendCombinedRtcpPacket).Times(1);
331 packet_router_.SendCombinedRtcpPacket(std::move(feedback));
332 packet_router_.RemoveSendRtpModule(&rtp_1);
333 EXPECT_CALL(rtp_2, SendCombinedRtcpPacket).Times(1);
334 std::vector<std::unique_ptr<rtcp::RtcpPacket>> new_feedback;
335 new_feedback.push_back(std::make_unique<rtcp::TransportFeedback>());
336 packet_router_.SendCombinedRtcpPacket(std::move(new_feedback));
337 packet_router_.RemoveReceiveRtpModule(&rtp_2);
338 }
339
TEST_F(PacketRouterTest,SendPacketWithoutTransportSequenceNumbers)340 TEST_F(PacketRouterTest, SendPacketWithoutTransportSequenceNumbers) {
341 const uint16_t kSsrc1 = 1234;
342 NiceMock<MockRtpRtcpInterface> rtp_1;
343 ON_CALL(rtp_1, SendingMedia).WillByDefault(Return(true));
344 ON_CALL(rtp_1, SSRC).WillByDefault(Return(kSsrc1));
345 packet_router_.AddSendRtpModule(&rtp_1, false);
346
347 // Send a packet without TransportSequenceNumber extension registered,
348 // packets sent should not have the extension set.
349 RtpHeaderExtensionMap extension_manager;
350 auto packet = std::make_unique<RtpPacketToSend>(&extension_manager);
351 packet->SetSsrc(kSsrc1);
352 EXPECT_CALL(
353 rtp_1,
354 TrySendPacket(
355 Property(&RtpPacketToSend::HasExtension<TransportSequenceNumber>,
356 false),
357 _))
358 .WillOnce(Return(true));
359 packet_router_.SendPacket(std::move(packet), PacedPacketInfo());
360
361 packet_router_.RemoveSendRtpModule(&rtp_1);
362 }
363
TEST_F(PacketRouterTest,SendPacketAssignsTransportSequenceNumbers)364 TEST_F(PacketRouterTest, SendPacketAssignsTransportSequenceNumbers) {
365 NiceMock<MockRtpRtcpInterface> rtp_1;
366 NiceMock<MockRtpRtcpInterface> rtp_2;
367
368 const uint16_t kSsrc1 = 1234;
369 const uint16_t kSsrc2 = 2345;
370
371 ON_CALL(rtp_1, SSRC).WillByDefault(Return(kSsrc1));
372 ON_CALL(rtp_2, SSRC).WillByDefault(Return(kSsrc2));
373
374 packet_router_.AddSendRtpModule(&rtp_1, false);
375 packet_router_.AddSendRtpModule(&rtp_2, false);
376
377 // Transport sequence numbers start at 1, for historical reasons.
378 uint16_t transport_sequence_number = 1;
379
380 auto packet = BuildRtpPacket(kSsrc1);
381 EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>());
382 EXPECT_CALL(
383 rtp_1,
384 TrySendPacket(
385 Property(&RtpPacketToSend::GetExtension<TransportSequenceNumber>,
386 transport_sequence_number),
387 _))
388 .WillOnce(Return(true));
389 packet_router_.SendPacket(std::move(packet), PacedPacketInfo());
390
391 ++transport_sequence_number;
392 packet = BuildRtpPacket(kSsrc2);
393 EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>());
394
395 EXPECT_CALL(
396 rtp_2,
397 TrySendPacket(
398 Property(&RtpPacketToSend::GetExtension<TransportSequenceNumber>,
399 transport_sequence_number),
400 _))
401 .WillOnce(Return(true));
402 packet_router_.SendPacket(std::move(packet), PacedPacketInfo());
403
404 packet_router_.RemoveSendRtpModule(&rtp_1);
405 packet_router_.RemoveSendRtpModule(&rtp_2);
406 }
407
408 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
409 using PacketRouterDeathTest = PacketRouterTest;
TEST_F(PacketRouterDeathTest,DoubleRegistrationOfSendModuleDisallowed)410 TEST_F(PacketRouterDeathTest, DoubleRegistrationOfSendModuleDisallowed) {
411 NiceMock<MockRtpRtcpInterface> module;
412
413 constexpr bool remb_candidate = false; // Value irrelevant.
414 packet_router_.AddSendRtpModule(&module, remb_candidate);
415 EXPECT_DEATH(packet_router_.AddSendRtpModule(&module, remb_candidate), "");
416
417 // Test tear-down
418 packet_router_.RemoveSendRtpModule(&module);
419 }
420
TEST_F(PacketRouterDeathTest,DoubleRegistrationOfReceiveModuleDisallowed)421 TEST_F(PacketRouterDeathTest, DoubleRegistrationOfReceiveModuleDisallowed) {
422 NiceMock<MockRtpRtcpInterface> module;
423
424 constexpr bool remb_candidate = false; // Value irrelevant.
425 packet_router_.AddReceiveRtpModule(&module, remb_candidate);
426 EXPECT_DEATH(packet_router_.AddReceiveRtpModule(&module, remb_candidate), "");
427
428 // Test tear-down
429 packet_router_.RemoveReceiveRtpModule(&module);
430 }
431
TEST_F(PacketRouterDeathTest,RemovalOfNeverAddedSendModuleDisallowed)432 TEST_F(PacketRouterDeathTest, RemovalOfNeverAddedSendModuleDisallowed) {
433 NiceMock<MockRtpRtcpInterface> module;
434
435 EXPECT_DEATH(packet_router_.RemoveSendRtpModule(&module), "");
436 }
437
TEST_F(PacketRouterDeathTest,RemovalOfNeverAddedReceiveModuleDisallowed)438 TEST_F(PacketRouterDeathTest, RemovalOfNeverAddedReceiveModuleDisallowed) {
439 NiceMock<MockRtpRtcpInterface> module;
440
441 EXPECT_DEATH(packet_router_.RemoveReceiveRtpModule(&module), "");
442 }
443 #endif // RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
444
TEST(PacketRouterRembTest,LowerEstimateToSendRemb)445 TEST(PacketRouterRembTest, LowerEstimateToSendRemb) {
446 rtc::ScopedFakeClock clock;
447 NiceMock<MockRtpRtcpInterface> rtp;
448 PacketRouter packet_router;
449
450 packet_router.AddSendRtpModule(&rtp, true);
451
452 uint32_t bitrate_estimate = 456;
453 const std::vector<uint32_t> ssrcs = {1234};
454
455 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
456
457 // Call OnReceiveBitrateChanged twice to get a first estimate.
458 clock.AdvanceTime(TimeDelta::Millis(1000));
459 EXPECT_CALL(rtp, SetRemb(bitrate_estimate, ssrcs)).Times(1);
460 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
461
462 // Lower the estimate with more than 3% to trigger a call to SetRemb right
463 // away.
464 bitrate_estimate = bitrate_estimate - 100;
465 EXPECT_CALL(rtp, SetRemb(bitrate_estimate, ssrcs)).Times(1);
466 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
467
468 packet_router.RemoveSendRtpModule(&rtp);
469 }
470
TEST(PacketRouterRembTest,VerifyIncreasingAndDecreasing)471 TEST(PacketRouterRembTest, VerifyIncreasingAndDecreasing) {
472 rtc::ScopedFakeClock clock;
473 NiceMock<MockRtpRtcpInterface> rtp;
474 PacketRouter packet_router;
475 packet_router.AddSendRtpModule(&rtp, true);
476
477 uint32_t bitrate_estimate[] = {456, 789};
478 std::vector<uint32_t> ssrcs = {1234, 5678};
479
480 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate[0]);
481
482 // Call OnReceiveBitrateChanged twice to get a first estimate.
483 EXPECT_CALL(rtp, SetRemb(bitrate_estimate[0], ssrcs)).Times(1);
484 clock.AdvanceTime(TimeDelta::Millis(1000));
485 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate[0]);
486
487 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate[1] + 100);
488
489 // Lower the estimate to trigger a callback.
490 EXPECT_CALL(rtp, SetRemb(bitrate_estimate[1], ssrcs)).Times(1);
491 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate[1]);
492
493 packet_router.RemoveSendRtpModule(&rtp);
494 }
495
TEST(PacketRouterRembTest,NoRembForIncreasedBitrate)496 TEST(PacketRouterRembTest, NoRembForIncreasedBitrate) {
497 rtc::ScopedFakeClock clock;
498 NiceMock<MockRtpRtcpInterface> rtp;
499 PacketRouter packet_router;
500 packet_router.AddSendRtpModule(&rtp, true);
501
502 uint32_t bitrate_estimate = 456;
503 std::vector<uint32_t> ssrcs = {1234, 5678};
504
505 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
506
507 // Call OnReceiveBitrateChanged twice to get a first estimate.
508 EXPECT_CALL(rtp, SetRemb(bitrate_estimate, ssrcs)).Times(1);
509 clock.AdvanceTime(TimeDelta::Millis(1000));
510 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
511
512 // Increased estimate shouldn't trigger a callback right away.
513 EXPECT_CALL(rtp, SetRemb(_, _)).Times(0);
514 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate + 1);
515
516 // Decreasing the estimate less than 3% shouldn't trigger a new callback.
517 EXPECT_CALL(rtp, SetRemb(_, _)).Times(0);
518 int lower_estimate = bitrate_estimate * 98 / 100;
519 packet_router.OnReceiveBitrateChanged(ssrcs, lower_estimate);
520
521 packet_router.RemoveSendRtpModule(&rtp);
522 }
523
TEST(PacketRouterRembTest,ChangeSendRtpModule)524 TEST(PacketRouterRembTest, ChangeSendRtpModule) {
525 rtc::ScopedFakeClock clock;
526 NiceMock<MockRtpRtcpInterface> rtp_send;
527 NiceMock<MockRtpRtcpInterface> rtp_recv;
528 PacketRouter packet_router;
529 packet_router.AddSendRtpModule(&rtp_send, true);
530 packet_router.AddReceiveRtpModule(&rtp_recv, true);
531
532 uint32_t bitrate_estimate = 456;
533 std::vector<uint32_t> ssrcs = {1234, 5678};
534
535 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
536
537 // Call OnReceiveBitrateChanged twice to get a first estimate.
538 clock.AdvanceTime(TimeDelta::Millis(1000));
539 EXPECT_CALL(rtp_send, SetRemb(bitrate_estimate, ssrcs)).Times(1);
540 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
541
542 // Decrease estimate to trigger a REMB.
543 bitrate_estimate = bitrate_estimate - 100;
544 EXPECT_CALL(rtp_send, SetRemb(bitrate_estimate, ssrcs)).Times(1);
545 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
546
547 // Remove the sending module -> should get remb on the second module.
548 packet_router.RemoveSendRtpModule(&rtp_send);
549
550 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
551
552 bitrate_estimate = bitrate_estimate - 100;
553 EXPECT_CALL(rtp_recv, SetRemb(bitrate_estimate, ssrcs)).Times(1);
554 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
555
556 packet_router.RemoveReceiveRtpModule(&rtp_recv);
557 }
558
TEST(PacketRouterRembTest,OnlyOneRembForRepeatedOnReceiveBitrateChanged)559 TEST(PacketRouterRembTest, OnlyOneRembForRepeatedOnReceiveBitrateChanged) {
560 rtc::ScopedFakeClock clock;
561 NiceMock<MockRtpRtcpInterface> rtp;
562 PacketRouter packet_router;
563 packet_router.AddSendRtpModule(&rtp, true);
564
565 uint32_t bitrate_estimate = 456;
566 const std::vector<uint32_t> ssrcs = {1234};
567
568 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
569
570 // Call OnReceiveBitrateChanged twice to get a first estimate.
571 clock.AdvanceTime(TimeDelta::Millis(1000));
572 EXPECT_CALL(rtp, SetRemb(_, _)).Times(1);
573 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
574
575 // Lower the estimate, should trigger a call to SetRemb right away.
576 bitrate_estimate = bitrate_estimate - 100;
577 EXPECT_CALL(rtp, SetRemb(bitrate_estimate, ssrcs)).Times(1);
578 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
579
580 // Call OnReceiveBitrateChanged again, this should not trigger a new callback.
581 EXPECT_CALL(rtp, SetRemb(_, _)).Times(0);
582 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
583 packet_router.RemoveSendRtpModule(&rtp);
584 }
585
TEST(PacketRouterRembTest,SetMaxDesiredReceiveBitrateLimitsSetRemb)586 TEST(PacketRouterRembTest, SetMaxDesiredReceiveBitrateLimitsSetRemb) {
587 rtc::ScopedFakeClock clock;
588 PacketRouter packet_router;
589 clock.AdvanceTime(TimeDelta::Millis(1000));
590 NiceMock<MockRtpRtcpInterface> remb_sender;
591 constexpr bool remb_candidate = true;
592 packet_router.AddSendRtpModule(&remb_sender, remb_candidate);
593
594 const int64_t cap_bitrate = 100000;
595 EXPECT_CALL(remb_sender, SetRemb(Le(cap_bitrate), _)).Times(AtLeast(1));
596 EXPECT_CALL(remb_sender, SetRemb(Gt(cap_bitrate), _)).Times(0);
597
598 const std::vector<uint32_t> ssrcs = {1234};
599 packet_router.SetMaxDesiredReceiveBitrate(cap_bitrate);
600 packet_router.OnReceiveBitrateChanged(ssrcs, cap_bitrate + 5000);
601 clock.AdvanceTime(TimeDelta::Millis(1000));
602 packet_router.OnReceiveBitrateChanged(ssrcs, cap_bitrate - 5000);
603
604 // Test tear-down.
605 packet_router.RemoveSendRtpModule(&remb_sender);
606 }
607
TEST(PacketRouterRembTest,SetMaxDesiredReceiveBitrateTriggersRembWhenMoreRestrictive)608 TEST(PacketRouterRembTest,
609 SetMaxDesiredReceiveBitrateTriggersRembWhenMoreRestrictive) {
610 rtc::ScopedFakeClock clock;
611 PacketRouter packet_router;
612 clock.AdvanceTime(TimeDelta::Millis(1000));
613 NiceMock<MockRtpRtcpInterface> remb_sender;
614 constexpr bool remb_candidate = true;
615 packet_router.AddSendRtpModule(&remb_sender, remb_candidate);
616
617 const int64_t measured_bitrate_bps = 150000;
618 const int64_t cap_bitrate_bps = measured_bitrate_bps - 5000;
619 const std::vector<uint32_t> ssrcs = {1234};
620 EXPECT_CALL(remb_sender, SetRemb(measured_bitrate_bps, _));
621 packet_router.OnReceiveBitrateChanged(ssrcs, measured_bitrate_bps);
622
623 EXPECT_CALL(remb_sender, SetRemb(cap_bitrate_bps, _));
624 packet_router.SetMaxDesiredReceiveBitrate(cap_bitrate_bps);
625
626 // Test tear-down.
627 packet_router.RemoveSendRtpModule(&remb_sender);
628 }
629
TEST(PacketRouterRembTest,SetMaxDesiredReceiveBitrateDoesNotTriggerRembWhenAsRestrictive)630 TEST(PacketRouterRembTest,
631 SetMaxDesiredReceiveBitrateDoesNotTriggerRembWhenAsRestrictive) {
632 rtc::ScopedFakeClock clock;
633 PacketRouter packet_router;
634 clock.AdvanceTime(TimeDelta::Millis(1000));
635 NiceMock<MockRtpRtcpInterface> remb_sender;
636 constexpr bool remb_candidate = true;
637 packet_router.AddSendRtpModule(&remb_sender, remb_candidate);
638
639 const uint32_t measured_bitrate_bps = 150000;
640 const uint32_t cap_bitrate_bps = measured_bitrate_bps;
641 const std::vector<uint32_t> ssrcs = {1234};
642 EXPECT_CALL(remb_sender, SetRemb(measured_bitrate_bps, _));
643 packet_router.OnReceiveBitrateChanged(ssrcs, measured_bitrate_bps);
644
645 EXPECT_CALL(remb_sender, SetRemb(_, _)).Times(0);
646 packet_router.SetMaxDesiredReceiveBitrate(cap_bitrate_bps);
647
648 // Test tear-down.
649 packet_router.RemoveSendRtpModule(&remb_sender);
650 }
651
TEST(PacketRouterRembTest,SetMaxDesiredReceiveBitrateDoesNotTriggerRembWhenLessRestrictive)652 TEST(PacketRouterRembTest,
653 SetMaxDesiredReceiveBitrateDoesNotTriggerRembWhenLessRestrictive) {
654 rtc::ScopedFakeClock clock;
655 PacketRouter packet_router;
656 clock.AdvanceTime(TimeDelta::Millis(1000));
657 NiceMock<MockRtpRtcpInterface> remb_sender;
658 constexpr bool remb_candidate = true;
659 packet_router.AddSendRtpModule(&remb_sender, remb_candidate);
660
661 const uint32_t measured_bitrate_bps = 150000;
662 const uint32_t cap_bitrate_bps = measured_bitrate_bps + 500;
663 const std::vector<uint32_t> ssrcs = {1234};
664 EXPECT_CALL(remb_sender, SetRemb(measured_bitrate_bps, _));
665 packet_router.OnReceiveBitrateChanged(ssrcs, measured_bitrate_bps);
666
667 EXPECT_CALL(remb_sender, SetRemb(_, _)).Times(0);
668 packet_router.SetMaxDesiredReceiveBitrate(cap_bitrate_bps);
669
670 // Test tear-down.
671 packet_router.RemoveSendRtpModule(&remb_sender);
672 }
673
TEST(PacketRouterRembTest,SetMaxDesiredReceiveBitrateTriggersRembWhenNoRecentMeasure)674 TEST(PacketRouterRembTest,
675 SetMaxDesiredReceiveBitrateTriggersRembWhenNoRecentMeasure) {
676 rtc::ScopedFakeClock clock;
677 PacketRouter packet_router;
678 clock.AdvanceTime(TimeDelta::Millis(1000));
679 NiceMock<MockRtpRtcpInterface> remb_sender;
680 constexpr bool remb_candidate = true;
681 packet_router.AddSendRtpModule(&remb_sender, remb_candidate);
682
683 const uint32_t measured_bitrate_bps = 150000;
684 const uint32_t cap_bitrate_bps = measured_bitrate_bps + 5000;
685 const std::vector<uint32_t> ssrcs = {1234};
686 EXPECT_CALL(remb_sender, SetRemb(measured_bitrate_bps, _));
687 packet_router.OnReceiveBitrateChanged(ssrcs, measured_bitrate_bps);
688 clock.AdvanceTime(TimeDelta::Millis(1000));
689
690 EXPECT_CALL(remb_sender, SetRemb(cap_bitrate_bps, _));
691 packet_router.SetMaxDesiredReceiveBitrate(cap_bitrate_bps);
692
693 // Test tear-down.
694 packet_router.RemoveSendRtpModule(&remb_sender);
695 }
696
TEST(PacketRouterRembTest,SetMaxDesiredReceiveBitrateTriggersRembWhenNoMeasures)697 TEST(PacketRouterRembTest,
698 SetMaxDesiredReceiveBitrateTriggersRembWhenNoMeasures) {
699 rtc::ScopedFakeClock clock;
700 PacketRouter packet_router;
701 clock.AdvanceTime(TimeDelta::Millis(1000));
702 NiceMock<MockRtpRtcpInterface> remb_sender;
703 constexpr bool remb_candidate = true;
704 packet_router.AddSendRtpModule(&remb_sender, remb_candidate);
705
706 // Set cap.
707 EXPECT_CALL(remb_sender, SetRemb(100000, _)).Times(1);
708 packet_router.SetMaxDesiredReceiveBitrate(100000);
709 // Increase cap.
710 EXPECT_CALL(remb_sender, SetRemb(200000, _)).Times(1);
711 packet_router.SetMaxDesiredReceiveBitrate(200000);
712 // Decrease cap.
713 EXPECT_CALL(remb_sender, SetRemb(150000, _)).Times(1);
714 packet_router.SetMaxDesiredReceiveBitrate(150000);
715
716 // Test tear-down.
717 packet_router.RemoveSendRtpModule(&remb_sender);
718 }
719
720 // Only register receiving modules and make sure we fallback to trigger a REMB
721 // packet on this one.
TEST(PacketRouterRembTest,NoSendingRtpModule)722 TEST(PacketRouterRembTest, NoSendingRtpModule) {
723 rtc::ScopedFakeClock clock;
724 NiceMock<MockRtpRtcpInterface> rtp;
725 PacketRouter packet_router;
726
727 packet_router.AddReceiveRtpModule(&rtp, true);
728
729 uint32_t bitrate_estimate = 456;
730 const std::vector<uint32_t> ssrcs = {1234};
731
732 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
733
734 // Call OnReceiveBitrateChanged twice to get a first estimate.
735 clock.AdvanceTime(TimeDelta::Millis(1000));
736 EXPECT_CALL(rtp, SetRemb(bitrate_estimate, ssrcs)).Times(1);
737 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
738
739 // Lower the estimate to trigger a new packet REMB packet.
740 EXPECT_CALL(rtp, SetRemb(bitrate_estimate - 100, ssrcs)).Times(1);
741 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate - 100);
742
743 EXPECT_CALL(rtp, UnsetRemb()).Times(1);
744 packet_router.RemoveReceiveRtpModule(&rtp);
745 }
746
TEST(PacketRouterRembTest,NonCandidateSendRtpModuleNotUsedForRemb)747 TEST(PacketRouterRembTest, NonCandidateSendRtpModuleNotUsedForRemb) {
748 rtc::ScopedFakeClock clock;
749 PacketRouter packet_router;
750 NiceMock<MockRtpRtcpInterface> module;
751
752 constexpr bool remb_candidate = false;
753
754 packet_router.AddSendRtpModule(&module, remb_candidate);
755
756 constexpr uint32_t bitrate_estimate = 456;
757 const std::vector<uint32_t> ssrcs = {1234};
758 EXPECT_CALL(module, SetRemb(_, _)).Times(0);
759 clock.AdvanceTime(TimeDelta::Millis(1000));
760 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
761
762 // Test tear-down
763 packet_router.RemoveSendRtpModule(&module);
764 }
765
TEST(PacketRouterRembTest,CandidateSendRtpModuleUsedForRemb)766 TEST(PacketRouterRembTest, CandidateSendRtpModuleUsedForRemb) {
767 rtc::ScopedFakeClock clock;
768 PacketRouter packet_router;
769 NiceMock<MockRtpRtcpInterface> module;
770
771 constexpr bool remb_candidate = true;
772
773 packet_router.AddSendRtpModule(&module, remb_candidate);
774
775 constexpr uint32_t bitrate_estimate = 456;
776 const std::vector<uint32_t> ssrcs = {1234};
777 EXPECT_CALL(module, SetRemb(bitrate_estimate, ssrcs)).Times(1);
778 clock.AdvanceTime(TimeDelta::Millis(1000));
779 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
780
781 // Test tear-down
782 packet_router.RemoveSendRtpModule(&module);
783 }
784
TEST(PacketRouterRembTest,NonCandidateReceiveRtpModuleNotUsedForRemb)785 TEST(PacketRouterRembTest, NonCandidateReceiveRtpModuleNotUsedForRemb) {
786 rtc::ScopedFakeClock clock;
787 PacketRouter packet_router;
788 NiceMock<MockRtpRtcpInterface> module;
789
790 constexpr bool remb_candidate = false;
791
792 packet_router.AddReceiveRtpModule(&module, remb_candidate);
793
794 constexpr uint32_t bitrate_estimate = 456;
795 const std::vector<uint32_t> ssrcs = {1234};
796 EXPECT_CALL(module, SetRemb(_, _)).Times(0);
797 clock.AdvanceTime(TimeDelta::Millis(1000));
798 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
799
800 // Test tear-down
801 packet_router.RemoveReceiveRtpModule(&module);
802 }
803
TEST(PacketRouterRembTest,CandidateReceiveRtpModuleUsedForRemb)804 TEST(PacketRouterRembTest, CandidateReceiveRtpModuleUsedForRemb) {
805 rtc::ScopedFakeClock clock;
806 PacketRouter packet_router;
807 NiceMock<MockRtpRtcpInterface> module;
808
809 constexpr bool remb_candidate = true;
810
811 packet_router.AddReceiveRtpModule(&module, remb_candidate);
812
813 constexpr uint32_t bitrate_estimate = 456;
814 const std::vector<uint32_t> ssrcs = {1234};
815 EXPECT_CALL(module, SetRemb(bitrate_estimate, ssrcs)).Times(1);
816 clock.AdvanceTime(TimeDelta::Millis(1000));
817 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
818
819 // Test tear-down
820 packet_router.RemoveReceiveRtpModule(&module);
821 }
822
TEST(PacketRouterRembTest,SendCandidatePreferredOverReceiveCandidate_SendModuleAddedFirst)823 TEST(PacketRouterRembTest,
824 SendCandidatePreferredOverReceiveCandidate_SendModuleAddedFirst) {
825 rtc::ScopedFakeClock clock;
826 PacketRouter packet_router;
827 NiceMock<MockRtpRtcpInterface> send_module;
828 NiceMock<MockRtpRtcpInterface> receive_module;
829
830 constexpr bool remb_candidate = true;
831
832 // Send module added - activated.
833 packet_router.AddSendRtpModule(&send_module, remb_candidate);
834
835 // Receive module added - the send module remains the active one.
836 packet_router.AddReceiveRtpModule(&receive_module, remb_candidate);
837
838 constexpr uint32_t bitrate_estimate = 456;
839 const std::vector<uint32_t> ssrcs = {1234};
840 EXPECT_CALL(send_module, SetRemb(bitrate_estimate, ssrcs)).Times(1);
841 EXPECT_CALL(receive_module, SetRemb(_, _)).Times(0);
842
843 clock.AdvanceTime(TimeDelta::Millis(1000));
844 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
845
846 // Test tear-down
847 packet_router.RemoveReceiveRtpModule(&receive_module);
848 packet_router.RemoveSendRtpModule(&send_module);
849 }
850
TEST(PacketRouterRembTest,SendCandidatePreferredOverReceiveCandidate_ReceiveModuleAddedFirst)851 TEST(PacketRouterRembTest,
852 SendCandidatePreferredOverReceiveCandidate_ReceiveModuleAddedFirst) {
853 rtc::ScopedFakeClock clock;
854 PacketRouter packet_router;
855 NiceMock<MockRtpRtcpInterface> send_module;
856 NiceMock<MockRtpRtcpInterface> receive_module;
857
858 constexpr bool remb_candidate = true;
859
860 // Receive module added - activated.
861 packet_router.AddReceiveRtpModule(&receive_module, remb_candidate);
862
863 // Send module added - replaces receive module as active.
864 packet_router.AddSendRtpModule(&send_module, remb_candidate);
865
866 constexpr uint32_t bitrate_estimate = 456;
867 const std::vector<uint32_t> ssrcs = {1234};
868 EXPECT_CALL(send_module, SetRemb(bitrate_estimate, ssrcs)).Times(1);
869 EXPECT_CALL(receive_module, SetRemb(_, _)).Times(0);
870
871 clock.AdvanceTime(TimeDelta::Millis(1000));
872 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
873
874 // Test tear-down
875 packet_router.RemoveReceiveRtpModule(&receive_module);
876 packet_router.RemoveSendRtpModule(&send_module);
877 }
878
TEST(PacketRouterRembTest,ReceiveModuleTakesOverWhenLastSendModuleRemoved)879 TEST(PacketRouterRembTest, ReceiveModuleTakesOverWhenLastSendModuleRemoved) {
880 rtc::ScopedFakeClock clock;
881 PacketRouter packet_router;
882 NiceMock<MockRtpRtcpInterface> send_module;
883 NiceMock<MockRtpRtcpInterface> receive_module;
884
885 constexpr bool remb_candidate = true;
886
887 // Send module active, receive module inactive.
888 packet_router.AddSendRtpModule(&send_module, remb_candidate);
889 packet_router.AddReceiveRtpModule(&receive_module, remb_candidate);
890
891 // Send module removed - receive module becomes active.
892 packet_router.RemoveSendRtpModule(&send_module);
893 constexpr uint32_t bitrate_estimate = 456;
894 const std::vector<uint32_t> ssrcs = {1234};
895 EXPECT_CALL(send_module, SetRemb(_, _)).Times(0);
896 EXPECT_CALL(receive_module, SetRemb(bitrate_estimate, ssrcs)).Times(1);
897
898 clock.AdvanceTime(TimeDelta::Millis(1000));
899 packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
900
901 // Test tear-down
902 packet_router.RemoveReceiveRtpModule(&receive_module);
903 }
904
905 } // namespace webrtc
906