1 /*
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "modules/rtp_rtcp/source/rtp_sender.h"
12
13 #include <memory>
14 #include <vector>
15
16 #include "absl/strings/string_view.h"
17 #include "api/rtc_event_log/rtc_event.h"
18 #include "api/transport/field_trial_based_config.h"
19 #include "api/video/video_codec_constants.h"
20 #include "api/video/video_timing.h"
21 #include "logging/rtc_event_log/mock/mock_rtc_event_log.h"
22 #include "modules/rtp_rtcp/include/rtp_cvo.h"
23 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
24 #include "modules/rtp_rtcp/include/rtp_packet_sender.h"
25 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
26 #include "modules/rtp_rtcp/source/packet_sequencer.h"
27 #include "modules/rtp_rtcp/source/rtp_format_video_generic.h"
28 #include "modules/rtp_rtcp/source/rtp_generic_frame_descriptor.h"
29 #include "modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension.h"
30 #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
31 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
32 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
33 #include "modules/rtp_rtcp/source/rtp_sender_video.h"
34 #include "modules/rtp_rtcp/source/video_fec_generator.h"
35 #include "rtc_base/arraysize.h"
36 #include "rtc_base/logging.h"
37 #include "rtc_base/rate_limiter.h"
38 #include "rtc_base/strings/string_builder.h"
39 #include "test/field_trial.h"
40 #include "test/gmock.h"
41 #include "test/gtest.h"
42 #include "test/mock_transport.h"
43 #include "test/scoped_key_value_config.h"
44 #include "test/time_controller/simulated_time_controller.h"
45
46 namespace webrtc {
47
48 namespace {
49 enum : int { // The first valid value is 1.
50 kAbsoluteSendTimeExtensionId = 1,
51 kAudioLevelExtensionId,
52 kGenericDescriptorId,
53 kMidExtensionId,
54 kRepairedRidExtensionId,
55 kRidExtensionId,
56 kTransmissionTimeOffsetExtensionId,
57 kTransportSequenceNumberExtensionId,
58 kVideoRotationExtensionId,
59 kVideoTimingExtensionId,
60 };
61
62 const int kPayload = 100;
63 const int kRtxPayload = 98;
64 const uint32_t kTimestamp = 10;
65 const uint16_t kSeqNum = 33;
66 const uint32_t kSsrc = 725242;
67 const uint32_t kRtxSsrc = 12345;
68 const uint32_t kFlexFecSsrc = 45678;
69 const uint64_t kStartTime = 123456789;
70 const size_t kMaxPaddingSize = 224u;
71 const uint8_t kPayloadData[] = {47, 11, 32, 93, 89};
72 const int64_t kDefaultExpectedRetransmissionTimeMs = 125;
73 const size_t kMaxPaddingLength = 224; // Value taken from rtp_sender.cc.
74 const uint32_t kTimestampTicksPerMs = 90; // 90kHz clock.
75 constexpr absl::string_view kMid = "mid";
76 constexpr absl::string_view kRid = "f";
77 constexpr bool kMarkerBit = true;
78
79 using ::testing::_;
80 using ::testing::AllOf;
81 using ::testing::AtLeast;
82 using ::testing::Contains;
83 using ::testing::Each;
84 using ::testing::ElementsAre;
85 using ::testing::Eq;
86 using ::testing::Field;
87 using ::testing::Gt;
88 using ::testing::IsEmpty;
89 using ::testing::NiceMock;
90 using ::testing::Not;
91 using ::testing::Pointee;
92 using ::testing::Property;
93 using ::testing::Return;
94 using ::testing::SizeIs;
95
96 class MockRtpPacketPacer : public RtpPacketSender {
97 public:
MockRtpPacketPacer()98 MockRtpPacketPacer() {}
~MockRtpPacketPacer()99 virtual ~MockRtpPacketPacer() {}
100
101 MOCK_METHOD(void,
102 EnqueuePackets,
103 (std::vector<std::unique_ptr<RtpPacketToSend>>),
104 (override));
105 };
106
107 } // namespace
108
109 class RtpSenderTest : public ::testing::Test {
110 protected:
RtpSenderTest()111 RtpSenderTest()
112 : time_controller_(Timestamp::Millis(kStartTime)),
113 clock_(time_controller_.GetClock()),
114 retransmission_rate_limiter_(clock_, 1000),
115 flexfec_sender_(0,
116 kFlexFecSsrc,
117 kSsrc,
118 "",
119 std::vector<RtpExtension>(),
120 std::vector<RtpExtensionSize>(),
121 nullptr,
122 clock_) {}
123
SetUp()124 void SetUp() override { SetUpRtpSender(true, false, nullptr); }
125
SetUpRtpSender(bool populate_network2,bool always_send_mid_and_rid,VideoFecGenerator * fec_generator)126 void SetUpRtpSender(bool populate_network2,
127 bool always_send_mid_and_rid,
128 VideoFecGenerator* fec_generator) {
129 RtpRtcpInterface::Configuration config = GetDefaultConfig();
130 config.fec_generator = fec_generator;
131 config.populate_network2_timestamp = populate_network2;
132 config.always_send_mid_and_rid = always_send_mid_and_rid;
133 CreateSender(config);
134 }
135
GetDefaultConfig()136 RtpRtcpInterface::Configuration GetDefaultConfig() {
137 RtpRtcpInterface::Configuration config;
138 config.clock = clock_;
139 config.local_media_ssrc = kSsrc;
140 config.rtx_send_ssrc = kRtxSsrc;
141 config.event_log = &mock_rtc_event_log_;
142 config.retransmission_rate_limiter = &retransmission_rate_limiter_;
143 config.paced_sender = &mock_paced_sender_;
144 config.field_trials = &field_trials_;
145 // Configure rid unconditionally, it has effect only if
146 // corresponding header extension is enabled.
147 config.rid = std::string(kRid);
148 return config;
149 }
150
CreateSender(const RtpRtcpInterface::Configuration & config)151 void CreateSender(const RtpRtcpInterface::Configuration& config) {
152 packet_history_ = std::make_unique<RtpPacketHistory>(
153 config.clock, config.enable_rtx_padding_prioritization);
154 sequencer_.emplace(kSsrc, kRtxSsrc,
155 /*require_marker_before_media_padding=*/!config.audio,
156 clock_);
157 rtp_sender_ = std::make_unique<RTPSender>(config, packet_history_.get(),
158 config.paced_sender);
159 sequencer_->set_media_sequence_number(kSeqNum);
160 rtp_sender_->SetTimestampOffset(0);
161 }
162
163 GlobalSimulatedTimeController time_controller_;
164 Clock* const clock_;
165 NiceMock<MockRtcEventLog> mock_rtc_event_log_;
166 MockRtpPacketPacer mock_paced_sender_;
167 RateLimiter retransmission_rate_limiter_;
168 FlexfecSender flexfec_sender_;
169
170 absl::optional<PacketSequencer> sequencer_;
171 std::unique_ptr<RtpPacketHistory> packet_history_;
172 std::unique_ptr<RTPSender> rtp_sender_;
173
174 const test::ScopedKeyValueConfig field_trials_;
175
BuildRtpPacket(int payload_type,bool marker_bit,uint32_t timestamp,int64_t capture_time_ms)176 std::unique_ptr<RtpPacketToSend> BuildRtpPacket(int payload_type,
177 bool marker_bit,
178 uint32_t timestamp,
179 int64_t capture_time_ms) {
180 auto packet = rtp_sender_->AllocatePacket();
181 packet->SetPayloadType(payload_type);
182 packet->set_packet_type(RtpPacketMediaType::kVideo);
183 packet->SetMarker(marker_bit);
184 packet->SetTimestamp(timestamp);
185 packet->set_capture_time(Timestamp::Millis(capture_time_ms));
186 return packet;
187 }
188
SendPacket(int64_t capture_time_ms,int payload_length)189 std::unique_ptr<RtpPacketToSend> SendPacket(int64_t capture_time_ms,
190 int payload_length) {
191 uint32_t timestamp = capture_time_ms * 90;
192 auto packet =
193 BuildRtpPacket(kPayload, kMarkerBit, timestamp, capture_time_ms);
194 packet->AllocatePayload(payload_length);
195 packet->set_allow_retransmission(true);
196
197 // Packet should be stored in a send bucket.
198 EXPECT_TRUE(
199 rtp_sender_->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
200 return packet;
201 }
202
SendGenericPacket()203 std::unique_ptr<RtpPacketToSend> SendGenericPacket() {
204 const int64_t kCaptureTimeMs = clock_->TimeInMilliseconds();
205 // Use maximum allowed size to catch corner cases when packet is dropped
206 // because of lack of capacity for the media packet, or for an rtx packet
207 // containing the media packet.
208 return SendPacket(kCaptureTimeMs,
209 /*payload_length=*/rtp_sender_->MaxRtpPacketSize() -
210 rtp_sender_->ExpectedPerPacketOverhead());
211 }
212
GeneratePadding(size_t target_size_bytes)213 std::vector<std::unique_ptr<RtpPacketToSend>> GeneratePadding(
214 size_t target_size_bytes) {
215 return rtp_sender_->GeneratePadding(
216 target_size_bytes, /*media_has_been_sent=*/true,
217 sequencer_->CanSendPaddingOnMediaSsrc());
218 }
219
Sequence(std::vector<std::unique_ptr<RtpPacketToSend>> packets)220 std::vector<std::unique_ptr<RtpPacketToSend>> Sequence(
221 std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
222 for (auto& packet : packets) {
223 sequencer_->Sequence(*packet);
224 }
225 return packets;
226 }
227
GenerateAndSendPadding(size_t target_size_bytes)228 size_t GenerateAndSendPadding(size_t target_size_bytes) {
229 size_t generated_bytes = 0;
230 for (auto& packet : GeneratePadding(target_size_bytes)) {
231 generated_bytes += packet->payload_size() + packet->padding_size();
232 rtp_sender_->SendToNetwork(std::move(packet));
233 }
234 return generated_bytes;
235 }
236
237 // The following are helpers for configuring the RTPSender. They must be
238 // called before sending any packets.
239
240 // Enable the retransmission stream with sizable packet storage.
EnableRtx()241 void EnableRtx() {
242 // RTX needs to be able to read the source packets from the packet store.
243 // Pick a number of packets to store big enough for any unit test.
244 constexpr uint16_t kNumberOfPacketsToStore = 100;
245 packet_history_->SetStorePacketsStatus(
246 RtpPacketHistory::StorageMode::kStoreAndCull, kNumberOfPacketsToStore);
247 rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
248 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
249 }
250
251 // Enable sending of the MID header extension for both the primary SSRC and
252 // the RTX SSRC.
EnableMidSending(absl::string_view mid)253 void EnableMidSending(absl::string_view mid) {
254 rtp_sender_->RegisterRtpHeaderExtension(RtpMid::Uri(), kMidExtensionId);
255 rtp_sender_->SetMid(mid);
256 }
257
258 // Enable sending of the RSID header extension for the primary SSRC and the
259 // RRSID header extension for the RTX SSRC.
EnableRidSending()260 void EnableRidSending() {
261 rtp_sender_->RegisterRtpHeaderExtension(RtpStreamId::Uri(),
262 kRidExtensionId);
263 rtp_sender_->RegisterRtpHeaderExtension(RepairedRtpStreamId::Uri(),
264 kRepairedRidExtensionId);
265 }
266 };
267
TEST_F(RtpSenderTest,AllocatePacketSetCsrc)268 TEST_F(RtpSenderTest, AllocatePacketSetCsrc) {
269 // Configure rtp_sender with csrc.
270 std::vector<uint32_t> csrcs;
271 csrcs.push_back(0x23456789);
272 rtp_sender_->SetCsrcs(csrcs);
273
274 auto packet = rtp_sender_->AllocatePacket();
275
276 ASSERT_TRUE(packet);
277 EXPECT_EQ(rtp_sender_->SSRC(), packet->Ssrc());
278 EXPECT_EQ(csrcs, packet->Csrcs());
279 }
280
TEST_F(RtpSenderTest,AllocatePacketReserveExtensions)281 TEST_F(RtpSenderTest, AllocatePacketReserveExtensions) {
282 // Configure rtp_sender with extensions.
283 ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
284 TransmissionOffset::Uri(), kTransmissionTimeOffsetExtensionId));
285 ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
286 AbsoluteSendTime::Uri(), kAbsoluteSendTimeExtensionId));
287 ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(AudioLevel::Uri(),
288 kAudioLevelExtensionId));
289 ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
290 TransportSequenceNumber::Uri(), kTransportSequenceNumberExtensionId));
291 ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
292 VideoOrientation::Uri(), kVideoRotationExtensionId));
293
294 auto packet = rtp_sender_->AllocatePacket();
295
296 ASSERT_TRUE(packet);
297 // Preallocate BWE extensions RtpSender set itself.
298 EXPECT_TRUE(packet->HasExtension<TransmissionOffset>());
299 EXPECT_TRUE(packet->HasExtension<AbsoluteSendTime>());
300 EXPECT_TRUE(packet->HasExtension<TransportSequenceNumber>());
301 // Do not allocate media specific extensions.
302 EXPECT_FALSE(packet->HasExtension<AudioLevel>());
303 EXPECT_FALSE(packet->HasExtension<VideoOrientation>());
304 }
305
TEST_F(RtpSenderTest,PaddingAlwaysAllowedOnAudio)306 TEST_F(RtpSenderTest, PaddingAlwaysAllowedOnAudio) {
307 RtpRtcpInterface::Configuration config = GetDefaultConfig();
308 config.audio = true;
309 CreateSender(config);
310
311 std::unique_ptr<RtpPacketToSend> audio_packet = rtp_sender_->AllocatePacket();
312 // Padding on audio stream allowed regardless of marker in the last packet.
313 audio_packet->SetMarker(false);
314 audio_packet->SetPayloadType(kPayload);
315 sequencer_->Sequence(*audio_packet);
316
317 const size_t kPaddingSize = 59;
318
319 EXPECT_CALL(
320 mock_paced_sender_,
321 EnqueuePackets(ElementsAre(AllOf(
322 Pointee(Property(&RtpPacketToSend::packet_type,
323 RtpPacketMediaType::kPadding)),
324 Pointee(Property(&RtpPacketToSend::padding_size, kPaddingSize))))));
325 EXPECT_EQ(kPaddingSize, GenerateAndSendPadding(kPaddingSize));
326
327 // Requested padding size is too small, will send a larger one.
328 const size_t kMinPaddingSize = 50;
329 EXPECT_CALL(mock_paced_sender_,
330 EnqueuePackets(ElementsAre(
331 AllOf(Pointee(Property(&RtpPacketToSend::packet_type,
332 RtpPacketMediaType::kPadding)),
333 Pointee(Property(&RtpPacketToSend::padding_size,
334 kMinPaddingSize))))));
335 EXPECT_EQ(kMinPaddingSize, GenerateAndSendPadding(kMinPaddingSize - 5));
336 }
337
TEST_F(RtpSenderTest,SendToNetworkForwardsPacketsToPacer)338 TEST_F(RtpSenderTest, SendToNetworkForwardsPacketsToPacer) {
339 auto packet = BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, 0);
340 Timestamp now = clock_->CurrentTime();
341
342 EXPECT_CALL(mock_paced_sender_,
343 EnqueuePackets(ElementsAre(AllOf(
344 Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc)),
345 Pointee(Property(&RtpPacketToSend::capture_time, now))))));
346 EXPECT_TRUE(
347 rtp_sender_->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
348 }
349
TEST_F(RtpSenderTest,ReSendPacketForwardsPacketsToPacer)350 TEST_F(RtpSenderTest, ReSendPacketForwardsPacketsToPacer) {
351 packet_history_->SetStorePacketsStatus(
352 RtpPacketHistory::StorageMode::kStoreAndCull, 10);
353 int64_t now_ms = clock_->TimeInMilliseconds();
354 auto packet = BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, now_ms);
355 packet->SetSequenceNumber(kSeqNum);
356 packet->set_allow_retransmission(true);
357 packet_history_->PutRtpPacket(std::move(packet), Timestamp::Millis(now_ms));
358
359 EXPECT_CALL(mock_paced_sender_,
360 EnqueuePackets(ElementsAre(AllOf(
361 Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc)),
362 Pointee(Property(&RtpPacketToSend::SequenceNumber, kSeqNum)),
363 Pointee(Property(&RtpPacketToSend::capture_time,
364 Timestamp::Millis(now_ms))),
365 Pointee(Property(&RtpPacketToSend::packet_type,
366 RtpPacketMediaType::kRetransmission))))));
367 EXPECT_TRUE(rtp_sender_->ReSendPacket(kSeqNum));
368 }
369
370 // This test sends 1 regular video packet, then 4 padding packets, and then
371 // 1 more regular packet.
TEST_F(RtpSenderTest,SendPadding)372 TEST_F(RtpSenderTest, SendPadding) {
373 constexpr int kNumPaddingPackets = 4;
374 EXPECT_CALL(mock_paced_sender_, EnqueuePackets);
375 std::unique_ptr<RtpPacketToSend> media_packet =
376 SendPacket(/*capture_time_ms=*/clock_->TimeInMilliseconds(),
377 /*payload_size=*/100);
378 sequencer_->Sequence(*media_packet);
379
380 // Wait 50 ms before generating each padding packet.
381 for (int i = 0; i < kNumPaddingPackets; ++i) {
382 time_controller_.AdvanceTime(TimeDelta::Millis(50));
383 const size_t kPaddingTargetBytes = 100; // Request 100 bytes of padding.
384
385 // Padding should be sent on the media ssrc, with a continous sequence
386 // number range. Size will be forced to full pack size and the timestamp
387 // shall be that of the last media packet.
388 EXPECT_CALL(mock_paced_sender_,
389 EnqueuePackets(ElementsAre(Pointee(AllOf(
390 Property(&RtpPacketToSend::Ssrc, kSsrc),
391 Property(&RtpPacketToSend::padding_size, kMaxPaddingLength),
392 Property(&RtpPacketToSend::SequenceNumber,
393 media_packet->SequenceNumber() + i + 1),
394 Property(&RtpPacketToSend::Timestamp,
395 media_packet->Timestamp()))))));
396 std::vector<std::unique_ptr<RtpPacketToSend>> padding_packets =
397 Sequence(GeneratePadding(kPaddingTargetBytes));
398 ASSERT_THAT(padding_packets, SizeIs(1));
399 rtp_sender_->SendToNetwork(std::move(padding_packets[0]));
400 }
401
402 // Send a regular video packet again.
403 EXPECT_CALL(
404 mock_paced_sender_,
405 EnqueuePackets(ElementsAre(Pointee(Property(
406 &RtpPacketToSend::Timestamp, Gt(media_packet->Timestamp()))))));
407
408 std::unique_ptr<RtpPacketToSend> next_media_packet =
409 SendPacket(/*capture_time_ms=*/clock_->TimeInMilliseconds(),
410 /*payload_size=*/100);
411 }
412
TEST_F(RtpSenderTest,NoPaddingAsFirstPacketWithoutBweExtensions)413 TEST_F(RtpSenderTest, NoPaddingAsFirstPacketWithoutBweExtensions) {
414 EXPECT_THAT(rtp_sender_->GeneratePadding(
415 /*target_size_bytes=*/100,
416 /*media_has_been_sent=*/false,
417 /*can_send_padding_on_media_ssrc=*/false),
418 IsEmpty());
419
420 // Don't send padding before media even with RTX.
421 EnableRtx();
422 EXPECT_THAT(rtp_sender_->GeneratePadding(
423 /*target_size_bytes=*/100,
424 /*media_has_been_sent=*/false,
425 /*can_send_padding_on_media_ssrc=*/false),
426 IsEmpty());
427 }
428
TEST_F(RtpSenderTest,RequiresRtxSsrcToEnableRtx)429 TEST_F(RtpSenderTest, RequiresRtxSsrcToEnableRtx) {
430 RtpRtcpInterface::Configuration config = GetDefaultConfig();
431 config.rtx_send_ssrc = absl::nullopt;
432 RTPSender rtp_sender(config, packet_history_.get(), config.paced_sender);
433 rtp_sender.SetRtxPayloadType(kRtxPayload, kPayload);
434
435 rtp_sender.SetRtxStatus(kRtxRetransmitted);
436
437 EXPECT_EQ(rtp_sender.RtxStatus(), kRtxOff);
438 }
439
TEST_F(RtpSenderTest,RequiresRtxPayloadTypesToEnableRtx)440 TEST_F(RtpSenderTest, RequiresRtxPayloadTypesToEnableRtx) {
441 RtpRtcpInterface::Configuration config = GetDefaultConfig();
442 config.rtx_send_ssrc = kRtxSsrc;
443 RTPSender rtp_sender(config, packet_history_.get(), config.paced_sender);
444
445 rtp_sender.SetRtxStatus(kRtxRetransmitted);
446
447 EXPECT_EQ(rtp_sender.RtxStatus(), kRtxOff);
448 }
449
TEST_F(RtpSenderTest,CanEnableRtxWhenRtxSsrcAndPayloadTypeAreConfigured)450 TEST_F(RtpSenderTest, CanEnableRtxWhenRtxSsrcAndPayloadTypeAreConfigured) {
451 RtpRtcpInterface::Configuration config = GetDefaultConfig();
452 config.rtx_send_ssrc = kRtxSsrc;
453 RTPSender rtp_sender(config, packet_history_.get(), config.paced_sender);
454 rtp_sender.SetRtxPayloadType(kRtxPayload, kPayload);
455
456 ASSERT_EQ(rtp_sender.RtxStatus(), kRtxOff);
457 rtp_sender.SetRtxStatus(kRtxRetransmitted);
458
459 EXPECT_EQ(rtp_sender.RtxStatus(), kRtxRetransmitted);
460 }
461
TEST_F(RtpSenderTest,AllowPaddingAsFirstPacketOnRtxWithTransportCc)462 TEST_F(RtpSenderTest, AllowPaddingAsFirstPacketOnRtxWithTransportCc) {
463 ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
464 TransportSequenceNumber::Uri(), kTransportSequenceNumberExtensionId));
465
466 // Padding can't be sent as first packet on media SSRC since we don't know
467 // what payload type to assign.
468 EXPECT_THAT(rtp_sender_->GeneratePadding(
469 /*target_size_bytes=*/100,
470 /*media_has_been_sent=*/false,
471 /*can_send_padding_on_media_ssrc=*/false),
472 IsEmpty());
473
474 // With transportcc padding can be sent as first packet on the RTX SSRC.
475 EnableRtx();
476 EXPECT_THAT(rtp_sender_->GeneratePadding(
477 /*target_size_bytes=*/100,
478 /*media_has_been_sent=*/false,
479 /*can_send_padding_on_media_ssrc=*/false),
480 Not(IsEmpty()));
481 }
482
TEST_F(RtpSenderTest,AllowPaddingAsFirstPacketOnRtxWithAbsSendTime)483 TEST_F(RtpSenderTest, AllowPaddingAsFirstPacketOnRtxWithAbsSendTime) {
484 ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
485 AbsoluteSendTime::Uri(), kAbsoluteSendTimeExtensionId));
486
487 // Padding can't be sent as first packet on media SSRC since we don't know
488 // what payload type to assign.
489 EXPECT_THAT(rtp_sender_->GeneratePadding(
490 /*target_size_bytes=*/100,
491 /*media_has_been_sent=*/false,
492 /*can_send_padding_on_media_ssrc=*/false),
493 IsEmpty());
494
495 // With abs send time, padding can be sent as first packet on the RTX SSRC.
496 EnableRtx();
497 EXPECT_THAT(rtp_sender_->GeneratePadding(
498 /*target_size_bytes=*/100,
499 /*media_has_been_sent=*/false,
500 /*can_send_padding_on_media_ssrc=*/false),
501 Not(IsEmpty()));
502 }
503
TEST_F(RtpSenderTest,UpdatesTimestampsOnPlainRtxPadding)504 TEST_F(RtpSenderTest, UpdatesTimestampsOnPlainRtxPadding) {
505 EnableRtx();
506 // Timestamps as set based on capture time in RtpSenderTest.
507 const int64_t start_time = clock_->TimeInMilliseconds();
508 const uint32_t start_timestamp = start_time * kTimestampTicksPerMs;
509
510 // Start by sending one media packet.
511 EXPECT_CALL(
512 mock_paced_sender_,
513 EnqueuePackets(ElementsAre(
514 AllOf(Pointee(Property(&RtpPacketToSend::padding_size, 0u)),
515 Pointee(Property(&RtpPacketToSend::Timestamp, start_timestamp)),
516 Pointee(Property(&RtpPacketToSend::capture_time,
517 Timestamp::Millis(start_time)))))));
518 std::unique_ptr<RtpPacketToSend> media_packet =
519 SendPacket(start_time, /*payload_size=*/600);
520 sequencer_->Sequence(*media_packet);
521
522 // Advance time before sending padding.
523 const TimeDelta kTimeDiff = TimeDelta::Millis(17);
524 time_controller_.AdvanceTime(kTimeDiff);
525
526 // Timestamps on padding should be offset from the sent media.
527 EXPECT_THAT(
528 Sequence(GeneratePadding(/*target_size_bytes=*/100)),
529 Each(Pointee(AllOf(
530 Property(&RtpPacketToSend::padding_size, kMaxPaddingLength),
531 Property(&RtpPacketToSend::Timestamp,
532 start_timestamp + (kTimestampTicksPerMs * kTimeDiff.ms())),
533 Property(&RtpPacketToSend::capture_time,
534 Timestamp::Millis(start_time) + kTimeDiff)))));
535 }
536
TEST_F(RtpSenderTest,KeepsTimestampsOnPayloadPadding)537 TEST_F(RtpSenderTest, KeepsTimestampsOnPayloadPadding) {
538 ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
539 TransportSequenceNumber::Uri(), kTransportSequenceNumberExtensionId));
540 EnableRtx();
541 // Timestamps as set based on capture time in RtpSenderTest.
542 const int64_t start_time = clock_->TimeInMilliseconds();
543 const uint32_t start_timestamp = start_time * kTimestampTicksPerMs;
544 const size_t kPayloadSize = 200;
545 const size_t kRtxHeaderSize = 2;
546
547 // Start by sending one media packet and putting in the packet history.
548 EXPECT_CALL(
549 mock_paced_sender_,
550 EnqueuePackets(ElementsAre(
551 AllOf(Pointee(Property(&RtpPacketToSend::padding_size, 0u)),
552 Pointee(Property(&RtpPacketToSend::Timestamp, start_timestamp)),
553 Pointee(Property(&RtpPacketToSend::capture_time,
554 Timestamp::Millis(start_time)))))));
555 std::unique_ptr<RtpPacketToSend> media_packet =
556 SendPacket(start_time, kPayloadSize);
557 packet_history_->PutRtpPacket(std::move(media_packet),
558 Timestamp::Millis(start_time));
559
560 // Advance time before sending padding.
561 const TimeDelta kTimeDiff = TimeDelta::Millis(17);
562 time_controller_.AdvanceTime(kTimeDiff);
563
564 // Timestamps on payload padding should be set to original.
565 EXPECT_THAT(GeneratePadding(/*target_size_bytes=*/100),
566 Each(AllOf(Pointee(Property(&RtpPacketToSend::padding_size, 0u)),
567 Pointee(Property(&RtpPacketToSend::payload_size,
568 kPayloadSize + kRtxHeaderSize)),
569 Pointee(Property(&RtpPacketToSend::Timestamp,
570 start_timestamp)),
571 Pointee(Property(&RtpPacketToSend::capture_time,
572 Timestamp::Millis(start_time))))));
573 }
574
575 // Test that the MID header extension is included on sent packets when
576 // configured.
TEST_F(RtpSenderTest,MidIncludedOnSentPackets)577 TEST_F(RtpSenderTest, MidIncludedOnSentPackets) {
578 EnableMidSending(kMid);
579
580 // Send a couple packets, expect both packets to have the MID set.
581 EXPECT_CALL(mock_paced_sender_,
582 EnqueuePackets(ElementsAre(Pointee(
583 Property(&RtpPacketToSend::GetExtension<RtpMid>, kMid)))))
584 .Times(2);
585 SendGenericPacket();
586 SendGenericPacket();
587 }
588
TEST_F(RtpSenderTest,RidIncludedOnSentPackets)589 TEST_F(RtpSenderTest, RidIncludedOnSentPackets) {
590 EnableRidSending();
591
592 EXPECT_CALL(mock_paced_sender_,
593 EnqueuePackets(ElementsAre(Pointee(Property(
594 &RtpPacketToSend::GetExtension<RtpStreamId>, kRid)))));
595 SendGenericPacket();
596 }
597
TEST_F(RtpSenderTest,RidIncludedOnRtxSentPackets)598 TEST_F(RtpSenderTest, RidIncludedOnRtxSentPackets) {
599 EnableRtx();
600 EnableRidSending();
601
602 EXPECT_CALL(mock_paced_sender_,
603 EnqueuePackets(ElementsAre(Pointee(AllOf(
604 Property(&RtpPacketToSend::GetExtension<RtpStreamId>, kRid),
605 Property(&RtpPacketToSend::HasExtension<RepairedRtpStreamId>,
606 false))))))
607 .WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
608 sequencer_->Sequence(*packets[0]);
609 packet_history_->PutRtpPacket(std::move(packets[0]),
610 clock_->CurrentTime());
611 });
612 SendGenericPacket();
613
614 EXPECT_CALL(
615 mock_paced_sender_,
616 EnqueuePackets(ElementsAre(Pointee(AllOf(
617 Property(&RtpPacketToSend::GetExtension<RepairedRtpStreamId>, kRid),
618 Property(&RtpPacketToSend::HasExtension<RtpStreamId>, false))))));
619 rtp_sender_->ReSendPacket(kSeqNum);
620 }
621
TEST_F(RtpSenderTest,MidAndRidNotIncludedOnSentPacketsAfterAck)622 TEST_F(RtpSenderTest, MidAndRidNotIncludedOnSentPacketsAfterAck) {
623 EnableMidSending(kMid);
624 EnableRidSending();
625
626 // This first packet should include both MID and RID.
627 EXPECT_CALL(
628 mock_paced_sender_,
629 EnqueuePackets(ElementsAre(Pointee(AllOf(
630 Property(&RtpPacketToSend::GetExtension<RtpMid>, kMid),
631 Property(&RtpPacketToSend::GetExtension<RtpStreamId>, kRid))))));
632 auto first_built_packet = SendGenericPacket();
633 rtp_sender_->OnReceivedAckOnSsrc(first_built_packet->SequenceNumber());
634
635 // The second packet should include neither since an ack was received.
636 EXPECT_CALL(
637 mock_paced_sender_,
638 EnqueuePackets(ElementsAre(Pointee(AllOf(
639 Property(&RtpPacketToSend::HasExtension<RtpMid>, false),
640 Property(&RtpPacketToSend::HasExtension<RtpStreamId>, false))))));
641 SendGenericPacket();
642 }
643
TEST_F(RtpSenderTest,MidAndRidAlwaysIncludedOnSentPacketsWhenConfigured)644 TEST_F(RtpSenderTest, MidAndRidAlwaysIncludedOnSentPacketsWhenConfigured) {
645 SetUpRtpSender(false, /*always_send_mid_and_rid=*/true, nullptr);
646 EnableMidSending(kMid);
647 EnableRidSending();
648
649 // Send two media packets: one before and one after the ack.
650 // Due to the configuration, both sent packets should contain MID and RID.
651 EXPECT_CALL(
652 mock_paced_sender_,
653 EnqueuePackets(ElementsAre(Pointee(
654 AllOf(Property(&RtpPacketToSend::GetExtension<RtpMid>, kMid),
655 Property(&RtpPacketToSend::GetExtension<RtpStreamId>, kRid))))))
656 .Times(2);
657 auto first_built_packet = SendGenericPacket();
658 rtp_sender_->OnReceivedAckOnSsrc(first_built_packet->SequenceNumber());
659 SendGenericPacket();
660 }
661
662 // Test that the first RTX packet includes both MID and RRID even if the packet
663 // being retransmitted did not have MID or RID. The MID and RID are needed on
664 // the first packets for a given SSRC, and RTX packets are sent on a separate
665 // SSRC.
TEST_F(RtpSenderTest,MidAndRidIncludedOnFirstRtxPacket)666 TEST_F(RtpSenderTest, MidAndRidIncludedOnFirstRtxPacket) {
667 EnableRtx();
668 EnableMidSending(kMid);
669 EnableRidSending();
670
671 // This first packet will include both MID and RID.
672 EXPECT_CALL(mock_paced_sender_, EnqueuePackets);
673 auto first_built_packet = SendGenericPacket();
674 rtp_sender_->OnReceivedAckOnSsrc(first_built_packet->SequenceNumber());
675
676 // The second packet will include neither since an ack was received, put
677 // it in the packet history for retransmission.
678 EXPECT_CALL(mock_paced_sender_, EnqueuePackets(SizeIs(1)))
679 .WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
680 packet_history_->PutRtpPacket(std::move(packets[0]),
681 clock_->CurrentTime());
682 });
683 auto second_built_packet = SendGenericPacket();
684
685 // The first RTX packet should include MID and RRID.
686 EXPECT_CALL(mock_paced_sender_,
687 EnqueuePackets(ElementsAre(Pointee(AllOf(
688 Property(&RtpPacketToSend::GetExtension<RtpMid>, kMid),
689 Property(&RtpPacketToSend::GetExtension<RepairedRtpStreamId>,
690 kRid))))));
691 rtp_sender_->ReSendPacket(second_built_packet->SequenceNumber());
692 }
693
694 // Test that the RTX packets sent after receving an ACK on the RTX SSRC does
695 // not include either MID or RRID even if the packet being retransmitted did
696 // had a MID or RID.
TEST_F(RtpSenderTest,MidAndRidNotIncludedOnRtxPacketsAfterAck)697 TEST_F(RtpSenderTest, MidAndRidNotIncludedOnRtxPacketsAfterAck) {
698 EnableRtx();
699 EnableMidSending(kMid);
700 EnableRidSending();
701
702 // This first packet will include both MID and RID.
703 auto first_built_packet = SendGenericPacket();
704 sequencer_->Sequence(*first_built_packet);
705 packet_history_->PutRtpPacket(
706 std::make_unique<RtpPacketToSend>(*first_built_packet),
707 /*send_time=*/clock_->CurrentTime());
708 rtp_sender_->OnReceivedAckOnSsrc(first_built_packet->SequenceNumber());
709
710 // The second packet will include neither since an ack was received.
711 auto second_built_packet = SendGenericPacket();
712 sequencer_->Sequence(*second_built_packet);
713 packet_history_->PutRtpPacket(
714 std::make_unique<RtpPacketToSend>(*second_built_packet),
715 /*send_time=*/clock_->CurrentTime());
716
717 // The first RTX packet will include MID and RRID.
718 EXPECT_CALL(mock_paced_sender_, EnqueuePackets(SizeIs(1)))
719 .WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
720 rtp_sender_->OnReceivedAckOnRtxSsrc(packets[0]->SequenceNumber());
721 packet_history_->MarkPacketAsSent(
722 *packets[0]->retransmitted_sequence_number());
723 });
724 rtp_sender_->ReSendPacket(second_built_packet->SequenceNumber());
725
726 // The second and third RTX packets should not include MID nor RRID.
727 EXPECT_CALL(mock_paced_sender_,
728 EnqueuePackets(ElementsAre(Pointee(AllOf(
729 Property(&RtpPacketToSend::HasExtension<RtpMid>, false),
730 Property(&RtpPacketToSend::HasExtension<RepairedRtpStreamId>,
731 false))))))
732 .Times(2);
733 rtp_sender_->ReSendPacket(first_built_packet->SequenceNumber());
734 rtp_sender_->ReSendPacket(second_built_packet->SequenceNumber());
735 }
736
TEST_F(RtpSenderTest,MidAndRidAlwaysIncludedOnRtxPacketsWhenConfigured)737 TEST_F(RtpSenderTest, MidAndRidAlwaysIncludedOnRtxPacketsWhenConfigured) {
738 SetUpRtpSender(false, /*always_send_mid_and_rid=*/true, nullptr);
739 EnableRtx();
740 EnableMidSending(kMid);
741 EnableRidSending();
742
743 // Send two media packets: one before and one after the ack.
744 EXPECT_CALL(
745 mock_paced_sender_,
746 EnqueuePackets(ElementsAre(Pointee(
747 AllOf(Property(&RtpPacketToSend::GetExtension<RtpMid>, kMid),
748 Property(&RtpPacketToSend::GetExtension<RtpStreamId>, kRid))))))
749 .Times(2)
750 .WillRepeatedly(
751 [&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
752 packet_history_->PutRtpPacket(std::move(packets[0]),
753 clock_->CurrentTime());
754 });
755 auto media_packet1 = SendGenericPacket();
756 rtp_sender_->OnReceivedAckOnSsrc(media_packet1->SequenceNumber());
757 auto media_packet2 = SendGenericPacket();
758
759 // Send three RTX packets with different combinations of orders w.r.t. the
760 // media and RTX acks.
761 // Due to the configuration, all sent packets should contain MID
762 // and either RID (media) or RRID (RTX).
763 EXPECT_CALL(mock_paced_sender_,
764 EnqueuePackets(ElementsAre(Pointee(AllOf(
765 Property(&RtpPacketToSend::GetExtension<RtpMid>, kMid),
766 Property(&RtpPacketToSend::GetExtension<RepairedRtpStreamId>,
767 kRid))))))
768 .Times(3)
769 .WillRepeatedly(
770 [&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
771 rtp_sender_->OnReceivedAckOnRtxSsrc(packets[0]->SequenceNumber());
772 packet_history_->MarkPacketAsSent(
773 *packets[0]->retransmitted_sequence_number());
774 });
775 rtp_sender_->ReSendPacket(media_packet2->SequenceNumber());
776 rtp_sender_->ReSendPacket(media_packet1->SequenceNumber());
777 rtp_sender_->ReSendPacket(media_packet2->SequenceNumber());
778 }
779
780 // Test that if the RtpState indicates an ACK has been received on that SSRC
781 // then neither the MID nor RID header extensions will be sent.
TEST_F(RtpSenderTest,MidAndRidNotIncludedOnSentPacketsAfterRtpStateRestored)782 TEST_F(RtpSenderTest, MidAndRidNotIncludedOnSentPacketsAfterRtpStateRestored) {
783 EnableMidSending(kMid);
784 EnableRidSending();
785
786 RtpState state = rtp_sender_->GetRtpState();
787 EXPECT_FALSE(state.ssrc_has_acked);
788 state.ssrc_has_acked = true;
789 rtp_sender_->SetRtpState(state);
790
791 EXPECT_CALL(
792 mock_paced_sender_,
793 EnqueuePackets(ElementsAre(Pointee(AllOf(
794 Property(&RtpPacketToSend::HasExtension<RtpMid>, false),
795 Property(&RtpPacketToSend::HasExtension<RtpStreamId>, false))))));
796 SendGenericPacket();
797 }
798
799 // Test that if the RTX RtpState indicates an ACK has been received on that
800 // RTX SSRC then neither the MID nor RRID header extensions will be sent on
801 // RTX packets.
TEST_F(RtpSenderTest,MidAndRridNotIncludedOnRtxPacketsAfterRtpStateRestored)802 TEST_F(RtpSenderTest, MidAndRridNotIncludedOnRtxPacketsAfterRtpStateRestored) {
803 EnableRtx();
804 EnableMidSending(kMid);
805 EnableRidSending();
806
807 RtpState rtx_state = rtp_sender_->GetRtxRtpState();
808 EXPECT_FALSE(rtx_state.ssrc_has_acked);
809 rtx_state.ssrc_has_acked = true;
810 rtp_sender_->SetRtxRtpState(rtx_state);
811
812 EXPECT_CALL(mock_paced_sender_, EnqueuePackets(SizeIs(1)))
813 .WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
814 packet_history_->PutRtpPacket(std::move(packets[0]),
815 clock_->CurrentTime());
816 });
817 auto built_packet = SendGenericPacket();
818
819 EXPECT_CALL(
820 mock_paced_sender_,
821 EnqueuePackets(ElementsAre(Pointee(AllOf(
822 Property(&RtpPacketToSend::HasExtension<RtpMid>, false),
823 Property(&RtpPacketToSend::HasExtension<RtpStreamId>, false))))));
824 ASSERT_LT(0, rtp_sender_->ReSendPacket(built_packet->SequenceNumber()));
825 }
826
TEST_F(RtpSenderTest,RespectsNackBitrateLimit)827 TEST_F(RtpSenderTest, RespectsNackBitrateLimit) {
828 const int32_t kPacketSize = 1400;
829 const int32_t kNumPackets = 30;
830 retransmission_rate_limiter_.SetMaxRate(kPacketSize * kNumPackets * 8);
831 EnableRtx();
832
833 std::vector<uint16_t> sequence_numbers;
834 for (int32_t i = 0; i < kNumPackets; ++i) {
835 std::unique_ptr<RtpPacketToSend> packet =
836 BuildRtpPacket(kPayload, /*marker_bit=*/true, /*timestamp=*/0,
837 /*capture_time_ms=*/clock_->TimeInMilliseconds());
838 packet->set_allow_retransmission(true);
839 sequencer_->Sequence(*packet);
840 sequence_numbers.push_back(packet->SequenceNumber());
841 packet_history_->PutRtpPacket(std::move(packet),
842 /*send_time=*/clock_->CurrentTime());
843 time_controller_.AdvanceTime(TimeDelta::Millis(1));
844 }
845
846 time_controller_.AdvanceTime(TimeDelta::Millis(1000 - kNumPackets));
847
848 // Resending should work - brings the bandwidth up to the limit.
849 // NACK bitrate is capped to the same bitrate as the encoder, since the max
850 // protection overhead is 50% (see MediaOptimization::SetTargetRates).
851 EXPECT_CALL(mock_paced_sender_, EnqueuePackets(ElementsAre(Pointee(Property(
852 &RtpPacketToSend::packet_type,
853 RtpPacketMediaType::kRetransmission)))))
854 .Times(kNumPackets)
855 .WillRepeatedly(
856 [&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
857 for (const auto& packet : packets) {
858 packet_history_->MarkPacketAsSent(
859 *packet->retransmitted_sequence_number());
860 }
861 });
862 rtp_sender_->OnReceivedNack(sequence_numbers, 0);
863
864 // Must be at least 5ms in between retransmission attempts.
865 time_controller_.AdvanceTime(TimeDelta::Millis(5));
866
867 // Resending should not work, bandwidth exceeded.
868 EXPECT_CALL(mock_paced_sender_, EnqueuePackets).Times(0);
869 rtp_sender_->OnReceivedNack(sequence_numbers, 0);
870 }
871
TEST_F(RtpSenderTest,UpdatingCsrcsUpdatedOverhead)872 TEST_F(RtpSenderTest, UpdatingCsrcsUpdatedOverhead) {
873 RtpRtcpInterface::Configuration config = GetDefaultConfig();
874 config.rtx_send_ssrc = {};
875 CreateSender(config);
876
877 // Base RTP overhead is 12B.
878 EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 12u);
879
880 // Adding two csrcs adds 2*4 bytes to the header.
881 rtp_sender_->SetCsrcs({1, 2});
882 EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 20u);
883 }
884
TEST_F(RtpSenderTest,OnOverheadChanged)885 TEST_F(RtpSenderTest, OnOverheadChanged) {
886 RtpRtcpInterface::Configuration config = GetDefaultConfig();
887 config.rtx_send_ssrc = {};
888 CreateSender(config);
889
890 // Base RTP overhead is 12B.
891 EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 12u);
892
893 rtp_sender_->RegisterRtpHeaderExtension(TransmissionOffset::Uri(),
894 kTransmissionTimeOffsetExtensionId);
895
896 // TransmissionTimeOffset extension has a size of 3B, but with the addition
897 // of header index and rounding to 4 byte boundary we end up with 20B total.
898 EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 20u);
899 }
900
TEST_F(RtpSenderTest,CountMidOnlyUntilAcked)901 TEST_F(RtpSenderTest, CountMidOnlyUntilAcked) {
902 RtpRtcpInterface::Configuration config = GetDefaultConfig();
903 config.rtx_send_ssrc = {};
904 CreateSender(config);
905
906 // Base RTP overhead is 12B.
907 EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 12u);
908
909 rtp_sender_->RegisterRtpHeaderExtension(RtpMid::Uri(), kMidExtensionId);
910
911 // Counted only if set.
912 EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 12u);
913 rtp_sender_->SetMid("foo");
914 EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 36u);
915 rtp_sender_->RegisterRtpHeaderExtension(RtpStreamId::Uri(), kRidExtensionId);
916 EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 52u);
917
918 // Ack received, mid/rid no longer sent.
919 rtp_sender_->OnReceivedAckOnSsrc(0);
920 EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 12u);
921 }
922
TEST_F(RtpSenderTest,DontCountVolatileExtensionsIntoOverhead)923 TEST_F(RtpSenderTest, DontCountVolatileExtensionsIntoOverhead) {
924 RtpRtcpInterface::Configuration config = GetDefaultConfig();
925 config.rtx_send_ssrc = {};
926 CreateSender(config);
927
928 // Base RTP overhead is 12B.
929 EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 12u);
930
931 rtp_sender_->RegisterRtpHeaderExtension(InbandComfortNoiseExtension::Uri(),
932 1);
933 rtp_sender_->RegisterRtpHeaderExtension(AbsoluteCaptureTimeExtension::Uri(),
934 2);
935 rtp_sender_->RegisterRtpHeaderExtension(VideoOrientation::Uri(), 3);
936 rtp_sender_->RegisterRtpHeaderExtension(PlayoutDelayLimits::Uri(), 4);
937 rtp_sender_->RegisterRtpHeaderExtension(VideoContentTypeExtension::Uri(), 5);
938 rtp_sender_->RegisterRtpHeaderExtension(VideoTimingExtension::Uri(), 6);
939 rtp_sender_->RegisterRtpHeaderExtension(RepairedRtpStreamId::Uri(), 7);
940 rtp_sender_->RegisterRtpHeaderExtension(ColorSpaceExtension::Uri(), 8);
941
942 // Still only 12B counted since can't count on above being sent.
943 EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 12u);
944 }
945
TEST_F(RtpSenderTest,SendPacketHandlesRetransmissionHistory)946 TEST_F(RtpSenderTest, SendPacketHandlesRetransmissionHistory) {
947 packet_history_->SetStorePacketsStatus(
948 RtpPacketHistory::StorageMode::kStoreAndCull, 10);
949
950 // Ignore calls to EnqueuePackets() for this test.
951 EXPECT_CALL(mock_paced_sender_, EnqueuePackets).WillRepeatedly(Return());
952
953 // Build a media packet and put in the packet history.
954 std::unique_ptr<RtpPacketToSend> packet =
955 BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds());
956 const uint16_t media_sequence_number = packet->SequenceNumber();
957 packet->set_allow_retransmission(true);
958 packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime());
959
960 // Simulate successful retransmission request.
961 time_controller_.AdvanceTime(TimeDelta::Millis(30));
962 EXPECT_THAT(rtp_sender_->ReSendPacket(media_sequence_number), Gt(0));
963
964 // Packet already pending, retransmission not allowed.
965 time_controller_.AdvanceTime(TimeDelta::Millis(30));
966 EXPECT_THAT(rtp_sender_->ReSendPacket(media_sequence_number), Eq(0));
967
968 // Simulate packet exiting pacer, mark as not longer pending.
969 packet_history_->MarkPacketAsSent(media_sequence_number);
970
971 // Retransmissions allowed again.
972 time_controller_.AdvanceTime(TimeDelta::Millis(30));
973 EXPECT_THAT(rtp_sender_->ReSendPacket(media_sequence_number), Gt(0));
974 }
975
TEST_F(RtpSenderTest,MarksRetransmittedPackets)976 TEST_F(RtpSenderTest, MarksRetransmittedPackets) {
977 packet_history_->SetStorePacketsStatus(
978 RtpPacketHistory::StorageMode::kStoreAndCull, 10);
979
980 // Build a media packet and put in the packet history.
981 std::unique_ptr<RtpPacketToSend> packet =
982 BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds());
983 const uint16_t media_sequence_number = packet->SequenceNumber();
984 packet->set_allow_retransmission(true);
985 packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime());
986
987 // Expect a retransmission packet marked with which packet it is a
988 // retransmit of.
989 EXPECT_CALL(
990 mock_paced_sender_,
991 EnqueuePackets(ElementsAre(AllOf(
992 Pointee(Property(&RtpPacketToSend::packet_type,
993 RtpPacketMediaType::kRetransmission)),
994 Pointee(Property(&RtpPacketToSend::retransmitted_sequence_number,
995 Eq(media_sequence_number)))))));
996 EXPECT_THAT(rtp_sender_->ReSendPacket(media_sequence_number), Gt(0));
997 }
998
TEST_F(RtpSenderTest,GeneratedPaddingHasBweExtensions)999 TEST_F(RtpSenderTest, GeneratedPaddingHasBweExtensions) {
1000 // Min requested size in order to use RTX payload.
1001 const size_t kMinPaddingSize = 50;
1002 EnableRtx();
1003
1004 ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
1005 TransmissionOffset::Uri(), kTransmissionTimeOffsetExtensionId));
1006 ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
1007 AbsoluteSendTime::Uri(), kAbsoluteSendTimeExtensionId));
1008 ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
1009 TransportSequenceNumber::Uri(), kTransportSequenceNumberExtensionId));
1010
1011 // Put a packet in the history, in order to facilitate payload padding.
1012 std::unique_ptr<RtpPacketToSend> packet =
1013 BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds());
1014 packet->set_allow_retransmission(true);
1015 packet->SetPayloadSize(kMinPaddingSize);
1016 packet->set_packet_type(RtpPacketMediaType::kVideo);
1017 packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime());
1018
1019 // Generate a plain padding packet, check that extensions are registered.
1020 std::vector<std::unique_ptr<RtpPacketToSend>> generated_packets =
1021 GeneratePadding(/*target_size_bytes=*/1);
1022 ASSERT_THAT(generated_packets, SizeIs(1));
1023 auto& plain_padding = generated_packets.front();
1024 EXPECT_GT(plain_padding->padding_size(), 0u);
1025 EXPECT_TRUE(plain_padding->HasExtension<TransportSequenceNumber>());
1026 EXPECT_TRUE(plain_padding->HasExtension<AbsoluteSendTime>());
1027 EXPECT_TRUE(plain_padding->HasExtension<TransmissionOffset>());
1028 EXPECT_GT(plain_padding->padding_size(), 0u);
1029
1030 // Generate a payload padding packets, check that extensions are registered.
1031 generated_packets = GeneratePadding(kMinPaddingSize);
1032 ASSERT_EQ(generated_packets.size(), 1u);
1033 auto& payload_padding = generated_packets.front();
1034 EXPECT_EQ(payload_padding->padding_size(), 0u);
1035 EXPECT_TRUE(payload_padding->HasExtension<TransportSequenceNumber>());
1036 EXPECT_TRUE(payload_padding->HasExtension<AbsoluteSendTime>());
1037 EXPECT_TRUE(payload_padding->HasExtension<TransmissionOffset>());
1038 EXPECT_GT(payload_padding->payload_size(), 0u);
1039 }
1040
TEST_F(RtpSenderTest,GeneratePaddingResendsOldPacketsWithRtx)1041 TEST_F(RtpSenderTest, GeneratePaddingResendsOldPacketsWithRtx) {
1042 // Min requested size in order to use RTX payload.
1043 const size_t kMinPaddingSize = 50;
1044
1045 rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
1046 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
1047 packet_history_->SetStorePacketsStatus(
1048 RtpPacketHistory::StorageMode::kStoreAndCull, 1);
1049
1050 ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
1051 TransportSequenceNumber::Uri(), kTransportSequenceNumberExtensionId));
1052
1053 const size_t kPayloadPacketSize = kMinPaddingSize;
1054 std::unique_ptr<RtpPacketToSend> packet =
1055 BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds());
1056 packet->set_allow_retransmission(true);
1057 packet->SetPayloadSize(kPayloadPacketSize);
1058 packet->set_packet_type(RtpPacketMediaType::kVideo);
1059 packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime());
1060
1061 // Generated padding has large enough budget that the video packet should be
1062 // retransmitted as padding.
1063 std::vector<std::unique_ptr<RtpPacketToSend>> generated_packets =
1064 GeneratePadding(kMinPaddingSize);
1065 ASSERT_EQ(generated_packets.size(), 1u);
1066 auto& padding_packet = generated_packets.front();
1067 EXPECT_EQ(padding_packet->packet_type(), RtpPacketMediaType::kPadding);
1068 EXPECT_EQ(padding_packet->Ssrc(), kRtxSsrc);
1069 EXPECT_EQ(padding_packet->payload_size(),
1070 kPayloadPacketSize + kRtxHeaderSize);
1071
1072 // Not enough budged for payload padding, use plain padding instead.
1073 const size_t kPaddingBytesRequested = kMinPaddingSize - 1;
1074
1075 size_t padding_bytes_generated = 0;
1076 generated_packets = GeneratePadding(kPaddingBytesRequested);
1077 EXPECT_EQ(generated_packets.size(), 1u);
1078 for (auto& packet : generated_packets) {
1079 EXPECT_EQ(packet->packet_type(), RtpPacketMediaType::kPadding);
1080 EXPECT_EQ(packet->Ssrc(), kRtxSsrc);
1081 EXPECT_EQ(packet->payload_size(), 0u);
1082 EXPECT_GT(packet->padding_size(), 0u);
1083 padding_bytes_generated += packet->padding_size();
1084 }
1085
1086 EXPECT_EQ(padding_bytes_generated, kMaxPaddingSize);
1087 }
1088
TEST_F(RtpSenderTest,LimitsPayloadPaddingSize)1089 TEST_F(RtpSenderTest, LimitsPayloadPaddingSize) {
1090 // RTX payload padding is limited to 3x target size.
1091 const double kFactor = 3.0;
1092 SetUpRtpSender(false, false, nullptr);
1093 rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
1094 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
1095 packet_history_->SetStorePacketsStatus(
1096 RtpPacketHistory::StorageMode::kStoreAndCull, 1);
1097
1098 ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
1099 TransportSequenceNumber::Uri(), kTransportSequenceNumberExtensionId));
1100
1101 // Send a dummy video packet so it ends up in the packet history.
1102 const size_t kPayloadPacketSize = 1234u;
1103 std::unique_ptr<RtpPacketToSend> packet =
1104 BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds());
1105 packet->set_allow_retransmission(true);
1106 packet->SetPayloadSize(kPayloadPacketSize);
1107 packet->set_packet_type(RtpPacketMediaType::kVideo);
1108 packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime());
1109
1110 // Smallest target size that will result in the sent packet being returned as
1111 // padding.
1112 const size_t kMinTargerSizeForPayload =
1113 (kPayloadPacketSize + kRtxHeaderSize) / kFactor;
1114
1115 // Generated padding has large enough budget that the video packet should be
1116 // retransmitted as padding.
1117 EXPECT_THAT(
1118 GeneratePadding(kMinTargerSizeForPayload),
1119 AllOf(Not(IsEmpty()),
1120 Each(Pointee(Property(&RtpPacketToSend::padding_size, Eq(0u))))));
1121
1122 // If payload padding is > 2x requested size, plain padding is returned
1123 // instead.
1124 EXPECT_THAT(
1125 GeneratePadding(kMinTargerSizeForPayload - 1),
1126 AllOf(Not(IsEmpty()),
1127 Each(Pointee(Property(&RtpPacketToSend::padding_size, Gt(0u))))));
1128 }
1129
TEST_F(RtpSenderTest,GeneratePaddingCreatesPurePaddingWithoutRtx)1130 TEST_F(RtpSenderTest, GeneratePaddingCreatesPurePaddingWithoutRtx) {
1131 packet_history_->SetStorePacketsStatus(
1132 RtpPacketHistory::StorageMode::kStoreAndCull, 1);
1133 ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
1134 TransmissionOffset::Uri(), kTransmissionTimeOffsetExtensionId));
1135 ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
1136 AbsoluteSendTime::Uri(), kAbsoluteSendTimeExtensionId));
1137 ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
1138 TransportSequenceNumber::Uri(), kTransportSequenceNumberExtensionId));
1139
1140 const size_t kPayloadPacketSize = 1234;
1141 // Send a dummy video packet so it ends up in the packet history. Since we
1142 // are not using RTX, it should never be used as padding.
1143 std::unique_ptr<RtpPacketToSend> packet =
1144 BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds());
1145 packet->set_allow_retransmission(true);
1146 packet->SetPayloadSize(kPayloadPacketSize);
1147 packet->set_packet_type(RtpPacketMediaType::kVideo);
1148 sequencer_->Sequence(*packet);
1149 packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime());
1150
1151 // Payload padding not available without RTX, only generate plain padding on
1152 // the media SSRC.
1153 // Number of padding packets is the requested padding size divided by max
1154 // padding packet size, rounded up. Pure padding packets are always of the
1155 // maximum size.
1156 const size_t kPaddingBytesRequested = kPayloadPacketSize + kRtxHeaderSize;
1157 const size_t kExpectedNumPaddingPackets =
1158 (kPaddingBytesRequested + kMaxPaddingSize - 1) / kMaxPaddingSize;
1159 size_t padding_bytes_generated = 0;
1160 std::vector<std::unique_ptr<RtpPacketToSend>> padding_packets =
1161 GeneratePadding(kPaddingBytesRequested);
1162 EXPECT_EQ(padding_packets.size(), kExpectedNumPaddingPackets);
1163 for (auto& packet : padding_packets) {
1164 EXPECT_EQ(packet->packet_type(), RtpPacketMediaType::kPadding);
1165 EXPECT_EQ(packet->Ssrc(), kSsrc);
1166 EXPECT_EQ(packet->payload_size(), 0u);
1167 EXPECT_GT(packet->padding_size(), 0u);
1168 padding_bytes_generated += packet->padding_size();
1169 EXPECT_TRUE(packet->HasExtension<TransportSequenceNumber>());
1170 EXPECT_TRUE(packet->HasExtension<AbsoluteSendTime>());
1171 EXPECT_TRUE(packet->HasExtension<TransmissionOffset>());
1172 }
1173
1174 EXPECT_EQ(padding_bytes_generated,
1175 kExpectedNumPaddingPackets * kMaxPaddingSize);
1176 }
1177
TEST_F(RtpSenderTest,SupportsPadding)1178 TEST_F(RtpSenderTest, SupportsPadding) {
1179 bool kSendingMediaStats[] = {true, false};
1180 bool kEnableRedundantPayloads[] = {true, false};
1181 absl::string_view kBweExtensionUris[] = {
1182 TransportSequenceNumber::Uri(), TransportSequenceNumberV2::Uri(),
1183 AbsoluteSendTime::Uri(), TransmissionOffset::Uri()};
1184 const int kExtensionsId = 7;
1185
1186 for (bool sending_media : kSendingMediaStats) {
1187 rtp_sender_->SetSendingMediaStatus(sending_media);
1188 for (bool redundant_payloads : kEnableRedundantPayloads) {
1189 int rtx_mode = kRtxRetransmitted;
1190 if (redundant_payloads) {
1191 rtx_mode |= kRtxRedundantPayloads;
1192 }
1193 rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
1194 rtp_sender_->SetRtxStatus(rtx_mode);
1195
1196 for (auto extension_uri : kBweExtensionUris) {
1197 EXPECT_FALSE(rtp_sender_->SupportsPadding());
1198 rtp_sender_->RegisterRtpHeaderExtension(extension_uri, kExtensionsId);
1199 if (!sending_media) {
1200 EXPECT_FALSE(rtp_sender_->SupportsPadding());
1201 } else {
1202 EXPECT_TRUE(rtp_sender_->SupportsPadding());
1203 if (redundant_payloads) {
1204 EXPECT_TRUE(rtp_sender_->SupportsRtxPayloadPadding());
1205 } else {
1206 EXPECT_FALSE(rtp_sender_->SupportsRtxPayloadPadding());
1207 }
1208 }
1209 rtp_sender_->DeregisterRtpHeaderExtension(extension_uri);
1210 EXPECT_FALSE(rtp_sender_->SupportsPadding());
1211 }
1212 }
1213 }
1214 }
1215
TEST_F(RtpSenderTest,SetsCaptureTimeOnRtxRetransmissions)1216 TEST_F(RtpSenderTest, SetsCaptureTimeOnRtxRetransmissions) {
1217 EnableRtx();
1218
1219 // Put a packet in the packet history, with current time as capture time.
1220 const int64_t start_time_ms = clock_->TimeInMilliseconds();
1221 std::unique_ptr<RtpPacketToSend> packet =
1222 BuildRtpPacket(kPayload, kMarkerBit, start_time_ms,
1223 /*capture_time_ms=*/start_time_ms);
1224 packet->set_allow_retransmission(true);
1225 sequencer_->Sequence(*packet);
1226 packet_history_->PutRtpPacket(std::move(packet),
1227 Timestamp::Millis(start_time_ms));
1228
1229 // Advance time, request an RTX retransmission. Capture timestamp should be
1230 // preserved.
1231 time_controller_.AdvanceTime(TimeDelta::Millis(10));
1232
1233 EXPECT_CALL(
1234 mock_paced_sender_,
1235 EnqueuePackets(ElementsAre(Pointee(Property(
1236 &RtpPacketToSend::capture_time, Timestamp::Millis(start_time_ms))))));
1237 EXPECT_GT(rtp_sender_->ReSendPacket(kSeqNum), 0);
1238 }
1239
TEST_F(RtpSenderTest,IgnoresNackAfterDisablingMedia)1240 TEST_F(RtpSenderTest, IgnoresNackAfterDisablingMedia) {
1241 const TimeDelta kRtt = TimeDelta::Millis(10);
1242
1243 EnableRtx();
1244 packet_history_->SetRtt(kRtt);
1245
1246 // Put a packet in the history.
1247 const int64_t start_time_ms = clock_->TimeInMilliseconds();
1248 std::unique_ptr<RtpPacketToSend> packet =
1249 BuildRtpPacket(kPayload, kMarkerBit, start_time_ms,
1250 /*capture_time_ms=*/start_time_ms);
1251 packet->set_allow_retransmission(true);
1252 sequencer_->Sequence(*packet);
1253 packet_history_->PutRtpPacket(std::move(packet),
1254 Timestamp::Millis(start_time_ms));
1255
1256 // Disable media sending and try to retransmit the packet, it should fail.
1257 rtp_sender_->SetSendingMediaStatus(false);
1258 time_controller_.AdvanceTime(kRtt);
1259 EXPECT_LT(rtp_sender_->ReSendPacket(kSeqNum), 0);
1260 }
1261
TEST_F(RtpSenderTest,DoesntFecProtectRetransmissions)1262 TEST_F(RtpSenderTest, DoesntFecProtectRetransmissions) {
1263 // Set up retranmission without RTX, so that a plain copy of the old packet is
1264 // re-sent instead.
1265 const TimeDelta kRtt = TimeDelta::Millis(10);
1266 rtp_sender_->SetSendingMediaStatus(true);
1267 rtp_sender_->SetRtxStatus(kRtxOff);
1268 packet_history_->SetStorePacketsStatus(
1269 RtpPacketHistory::StorageMode::kStoreAndCull, 10);
1270 packet_history_->SetRtt(kRtt);
1271
1272 // Put a fec protected packet in the history.
1273 const int64_t start_time_ms = clock_->TimeInMilliseconds();
1274 std::unique_ptr<RtpPacketToSend> packet =
1275 BuildRtpPacket(kPayload, kMarkerBit, start_time_ms,
1276 /*capture_time_ms=*/start_time_ms);
1277 packet->set_allow_retransmission(true);
1278 packet->set_fec_protect_packet(true);
1279 sequencer_->Sequence(*packet);
1280 packet_history_->PutRtpPacket(std::move(packet),
1281 Timestamp::Millis(start_time_ms));
1282
1283 // Re-send packet, the retransmitted packet should not have the FEC protection
1284 // flag set.
1285 EXPECT_CALL(mock_paced_sender_,
1286 EnqueuePackets(ElementsAre(Pointee(
1287 Property(&RtpPacketToSend::fec_protect_packet, false)))));
1288
1289 time_controller_.AdvanceTime(kRtt);
1290 EXPECT_GT(rtp_sender_->ReSendPacket(kSeqNum), 0);
1291 }
1292
TEST_F(RtpSenderTest,MarksPacketsWithKeyframeStatus)1293 TEST_F(RtpSenderTest, MarksPacketsWithKeyframeStatus) {
1294 RTPSenderVideo::Config video_config;
1295 video_config.clock = clock_;
1296 video_config.rtp_sender = rtp_sender_.get();
1297 video_config.field_trials = &field_trials_;
1298 RTPSenderVideo rtp_sender_video(video_config);
1299
1300 const uint8_t kPayloadType = 127;
1301 const absl::optional<VideoCodecType> kCodecType =
1302 VideoCodecType::kVideoCodecGeneric;
1303
1304 const uint32_t kCaptureTimeMsToRtpTimestamp = 90; // 90 kHz clock
1305
1306 {
1307 EXPECT_CALL(mock_paced_sender_,
1308 EnqueuePackets(Each(
1309 Pointee(Property(&RtpPacketToSend::is_key_frame, true)))))
1310 .Times(AtLeast(1));
1311 RTPVideoHeader video_header;
1312 video_header.frame_type = VideoFrameType::kVideoFrameKey;
1313 int64_t capture_time_ms = clock_->TimeInMilliseconds();
1314 EXPECT_TRUE(rtp_sender_video.SendVideo(
1315 kPayloadType, kCodecType,
1316 capture_time_ms * kCaptureTimeMsToRtpTimestamp, capture_time_ms,
1317 kPayloadData, video_header, kDefaultExpectedRetransmissionTimeMs));
1318
1319 time_controller_.AdvanceTime(TimeDelta::Millis(33));
1320 }
1321
1322 {
1323 EXPECT_CALL(mock_paced_sender_,
1324 EnqueuePackets(Each(
1325 Pointee(Property(&RtpPacketToSend::is_key_frame, false)))))
1326 .Times(AtLeast(1));
1327 RTPVideoHeader video_header;
1328 video_header.frame_type = VideoFrameType::kVideoFrameDelta;
1329 int64_t capture_time_ms = clock_->TimeInMilliseconds();
1330 EXPECT_TRUE(rtp_sender_video.SendVideo(
1331 kPayloadType, kCodecType,
1332 capture_time_ms * kCaptureTimeMsToRtpTimestamp, capture_time_ms,
1333 kPayloadData, video_header, kDefaultExpectedRetransmissionTimeMs));
1334
1335 time_controller_.AdvanceTime(TimeDelta::Millis(33));
1336 }
1337 }
1338
1339 } // namespace webrtc
1340