1 /*
2 * Copyright (c) 2021 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_egress.h"
12
13 #include <string>
14
15 #include "absl/types/optional.h"
16 #include "api/array_view.h"
17 #include "api/call/transport.h"
18 #include "api/field_trials_registry.h"
19 #include "api/units/data_size.h"
20 #include "api/units/timestamp.h"
21 #include "logging/rtc_event_log/mock/mock_rtc_event_log.h"
22 #include "modules/rtp_rtcp/include/flexfec_sender.h"
23 #include "modules/rtp_rtcp/include/rtp_rtcp.h"
24 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
25 #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
26 #include "modules/rtp_rtcp/source/rtp_packet_history.h"
27 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
28 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
29 #include "test/explicit_key_value_config.h"
30 #include "test/gmock.h"
31 #include "test/gtest.h"
32 #include "test/time_controller/simulated_time_controller.h"
33
34 namespace webrtc {
35 namespace {
36
37 using ::testing::_;
38 using ::testing::Field;
39 using ::testing::NiceMock;
40 using ::testing::Optional;
41 using ::testing::StrictMock;
42
43 constexpr Timestamp kStartTime = Timestamp::Millis(123456789);
44 constexpr int kDefaultPayloadType = 100;
45 constexpr int kFlexfectPayloadType = 110;
46 constexpr uint16_t kStartSequenceNumber = 33;
47 constexpr uint32_t kSsrc = 725242;
48 constexpr uint32_t kRtxSsrc = 12345;
49 constexpr uint32_t kFlexFecSsrc = 23456;
50 enum : int {
51 kTransportSequenceNumberExtensionId = 1,
52 kAbsoluteSendTimeExtensionId,
53 kTransmissionOffsetExtensionId,
54 kVideoTimingExtensionId,
55 };
56
57 class MockSendPacketObserver : public SendPacketObserver {
58 public:
59 MOCK_METHOD(void, OnSendPacket, (uint16_t, int64_t, uint32_t), (override));
60 };
61
62 class MockTransportFeedbackObserver : public TransportFeedbackObserver {
63 public:
64 MOCK_METHOD(void, OnAddPacket, (const RtpPacketSendInfo&), (override));
65 MOCK_METHOD(void,
66 OnTransportFeedback,
67 (const rtcp::TransportFeedback&),
68 (override));
69 };
70
71 class MockStreamDataCountersCallback : public StreamDataCountersCallback {
72 public:
73 MOCK_METHOD(void,
74 DataCountersUpdated,
75 (const StreamDataCounters& counters, uint32_t ssrc),
76 (override));
77 };
78
79 class MockSendSideDelayObserver : public SendSideDelayObserver {
80 public:
81 MOCK_METHOD(void, SendSideDelayUpdated, (int, int, uint32_t), (override));
82 };
83
84 struct TransmittedPacket {
TransmittedPacketwebrtc::__anonf79f61b30111::TransmittedPacket85 TransmittedPacket(rtc::ArrayView<const uint8_t> data,
86 const PacketOptions& packet_options,
87 RtpHeaderExtensionMap* extensions)
88 : packet(extensions), options(packet_options) {
89 EXPECT_TRUE(packet.Parse(data));
90 }
91 RtpPacketReceived packet;
92 PacketOptions options;
93 };
94
95 class TestTransport : public Transport {
96 public:
TestTransport(RtpHeaderExtensionMap * extensions)97 explicit TestTransport(RtpHeaderExtensionMap* extensions)
98 : total_data_sent_(DataSize::Zero()), extensions_(extensions) {}
SendRtp(const uint8_t * packet,size_t length,const PacketOptions & options)99 bool SendRtp(const uint8_t* packet,
100 size_t length,
101 const PacketOptions& options) override {
102 total_data_sent_ += DataSize::Bytes(length);
103 last_packet_.emplace(rtc::MakeArrayView(packet, length), options,
104 extensions_);
105 return true;
106 }
107
SendRtcp(const uint8_t *,size_t)108 bool SendRtcp(const uint8_t*, size_t) override { RTC_CHECK_NOTREACHED(); }
109
last_packet()110 absl::optional<TransmittedPacket> last_packet() { return last_packet_; }
111
112 private:
113 DataSize total_data_sent_;
114 absl::optional<TransmittedPacket> last_packet_;
115 RtpHeaderExtensionMap* const extensions_;
116 };
117
118 } // namespace
119
120 class RtpSenderEgressTest : public ::testing::Test {
121 protected:
RtpSenderEgressTest()122 RtpSenderEgressTest()
123 : time_controller_(kStartTime),
124 clock_(time_controller_.GetClock()),
125 transport_(&header_extensions_),
126 packet_history_(clock_, /*enable_rtx_padding_prioritization=*/true),
127 trials_(""),
128 sequence_number_(kStartSequenceNumber) {}
129
CreateRtpSenderEgress()130 std::unique_ptr<RtpSenderEgress> CreateRtpSenderEgress() {
131 return std::make_unique<RtpSenderEgress>(DefaultConfig(), &packet_history_);
132 }
133
DefaultConfig()134 RtpRtcpInterface::Configuration DefaultConfig() {
135 RtpRtcpInterface::Configuration config;
136 config.clock = clock_;
137 config.outgoing_transport = &transport_;
138 config.local_media_ssrc = kSsrc;
139 config.rtx_send_ssrc = kRtxSsrc;
140 config.fec_generator = nullptr;
141 config.event_log = &mock_rtc_event_log_;
142 config.send_packet_observer = &send_packet_observer_;
143 config.rtp_stats_callback = &mock_rtp_stats_callback_;
144 config.transport_feedback_callback = &feedback_observer_;
145 config.populate_network2_timestamp = false;
146 config.field_trials = &trials_;
147 return config;
148 }
149
BuildRtpPacket(bool marker_bit,int64_t capture_time_ms)150 std::unique_ptr<RtpPacketToSend> BuildRtpPacket(bool marker_bit,
151 int64_t capture_time_ms) {
152 auto packet = std::make_unique<RtpPacketToSend>(&header_extensions_);
153 packet->SetSsrc(kSsrc);
154 packet->ReserveExtension<AbsoluteSendTime>();
155 packet->ReserveExtension<TransmissionOffset>();
156 packet->ReserveExtension<TransportSequenceNumber>();
157
158 packet->SetPayloadType(kDefaultPayloadType);
159 packet->set_packet_type(RtpPacketMediaType::kVideo);
160 packet->SetMarker(marker_bit);
161 packet->SetTimestamp(capture_time_ms * 90);
162 packet->set_capture_time(Timestamp::Millis(capture_time_ms));
163 packet->SetSequenceNumber(sequence_number_++);
164 return packet;
165 }
166
BuildRtpPacket()167 std::unique_ptr<RtpPacketToSend> BuildRtpPacket() {
168 return BuildRtpPacket(/*marker_bit=*/true, clock_->CurrentTime().ms());
169 }
170
171 GlobalSimulatedTimeController time_controller_;
172 Clock* const clock_;
173 NiceMock<MockRtcEventLog> mock_rtc_event_log_;
174 NiceMock<MockStreamDataCountersCallback> mock_rtp_stats_callback_;
175 NiceMock<MockSendPacketObserver> send_packet_observer_;
176 NiceMock<MockTransportFeedbackObserver> feedback_observer_;
177 RtpHeaderExtensionMap header_extensions_;
178 TestTransport transport_;
179 RtpPacketHistory packet_history_;
180 test::ExplicitKeyValueConfig trials_;
181 uint16_t sequence_number_;
182 };
183
TEST_F(RtpSenderEgressTest,TransportFeedbackObserverGetsCorrectByteCount)184 TEST_F(RtpSenderEgressTest, TransportFeedbackObserverGetsCorrectByteCount) {
185 constexpr size_t kRtpOverheadBytesPerPacket = 12 + 8;
186 constexpr size_t kPayloadSize = 1400;
187 const uint16_t kTransportSequenceNumber = 17;
188
189 header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId,
190 TransportSequenceNumber::Uri());
191
192 const size_t expected_bytes = kPayloadSize + kRtpOverheadBytesPerPacket;
193
194 EXPECT_CALL(
195 feedback_observer_,
196 OnAddPacket(AllOf(
197 Field(&RtpPacketSendInfo::media_ssrc, kSsrc),
198 Field(&RtpPacketSendInfo::transport_sequence_number,
199 kTransportSequenceNumber),
200 Field(&RtpPacketSendInfo::rtp_sequence_number, kStartSequenceNumber),
201 Field(&RtpPacketSendInfo::length, expected_bytes),
202 Field(&RtpPacketSendInfo::pacing_info, PacedPacketInfo()))));
203
204 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket();
205 packet->SetExtension<TransportSequenceNumber>(kTransportSequenceNumber);
206 packet->AllocatePayload(kPayloadSize);
207
208 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
209 sender->SendPacket(packet.get(), PacedPacketInfo());
210 }
211
TEST_F(RtpSenderEgressTest,PacketOptionsIsRetransmitSetByPacketType)212 TEST_F(RtpSenderEgressTest, PacketOptionsIsRetransmitSetByPacketType) {
213 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
214
215 std::unique_ptr<RtpPacketToSend> media_packet = BuildRtpPacket();
216 media_packet->set_packet_type(RtpPacketMediaType::kVideo);
217 sender->SendPacket(media_packet.get(), PacedPacketInfo());
218 EXPECT_FALSE(transport_.last_packet()->options.is_retransmit);
219
220 std::unique_ptr<RtpPacketToSend> retransmission = BuildRtpPacket();
221 retransmission->set_packet_type(RtpPacketMediaType::kRetransmission);
222 retransmission->set_retransmitted_sequence_number(
223 media_packet->SequenceNumber());
224 sender->SendPacket(retransmission.get(), PacedPacketInfo());
225 EXPECT_TRUE(transport_.last_packet()->options.is_retransmit);
226 }
227
TEST_F(RtpSenderEgressTest,DoesnSetIncludedInAllocationByDefault)228 TEST_F(RtpSenderEgressTest, DoesnSetIncludedInAllocationByDefault) {
229 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
230
231 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket();
232 sender->SendPacket(packet.get(), PacedPacketInfo());
233 EXPECT_FALSE(transport_.last_packet()->options.included_in_feedback);
234 EXPECT_FALSE(transport_.last_packet()->options.included_in_allocation);
235 }
236
TEST_F(RtpSenderEgressTest,SetsIncludedInFeedbackWhenTransportSequenceNumberExtensionIsRegistered)237 TEST_F(RtpSenderEgressTest,
238 SetsIncludedInFeedbackWhenTransportSequenceNumberExtensionIsRegistered) {
239 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
240
241 header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId,
242 TransportSequenceNumber::Uri());
243 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket();
244 sender->SendPacket(packet.get(), PacedPacketInfo());
245 EXPECT_TRUE(transport_.last_packet()->options.included_in_feedback);
246 }
247
TEST_F(RtpSenderEgressTest,SetsIncludedInAllocationWhenTransportSequenceNumberExtensionIsRegistered)248 TEST_F(
249 RtpSenderEgressTest,
250 SetsIncludedInAllocationWhenTransportSequenceNumberExtensionIsRegistered) {
251 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
252
253 header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId,
254 TransportSequenceNumber::Uri());
255 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket();
256 sender->SendPacket(packet.get(), PacedPacketInfo());
257 EXPECT_TRUE(transport_.last_packet()->options.included_in_allocation);
258 }
259
TEST_F(RtpSenderEgressTest,SetsIncludedInAllocationWhenForcedAsPartOfAllocation)260 TEST_F(RtpSenderEgressTest,
261 SetsIncludedInAllocationWhenForcedAsPartOfAllocation) {
262 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
263 sender->ForceIncludeSendPacketsInAllocation(true);
264
265 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket();
266 sender->SendPacket(packet.get(), PacedPacketInfo());
267 EXPECT_FALSE(transport_.last_packet()->options.included_in_feedback);
268 EXPECT_TRUE(transport_.last_packet()->options.included_in_allocation);
269 }
270
TEST_F(RtpSenderEgressTest,OnSendSideDelayUpdated)271 TEST_F(RtpSenderEgressTest, OnSendSideDelayUpdated) {
272 StrictMock<MockSendSideDelayObserver> send_side_delay_observer;
273 RtpRtcpInterface::Configuration config = DefaultConfig();
274 config.send_side_delay_observer = &send_side_delay_observer;
275 auto sender = std::make_unique<RtpSenderEgress>(config, &packet_history_);
276
277 // Send packet with 10 ms send-side delay. The average, max and total should
278 // be 10 ms.
279 EXPECT_CALL(send_side_delay_observer, SendSideDelayUpdated(10, 10, kSsrc));
280 int64_t capture_time_ms = clock_->TimeInMilliseconds();
281 time_controller_.AdvanceTime(TimeDelta::Millis(10));
282 sender->SendPacket(BuildRtpPacket(/*marker=*/true, capture_time_ms).get(),
283 PacedPacketInfo());
284
285 // Send another packet with 20 ms delay. The average, max and total should be
286 // 15, 20 and 30 ms respectively.
287 EXPECT_CALL(send_side_delay_observer, SendSideDelayUpdated(15, 20, kSsrc));
288 capture_time_ms = clock_->TimeInMilliseconds();
289 time_controller_.AdvanceTime(TimeDelta::Millis(20));
290 sender->SendPacket(BuildRtpPacket(/*marker=*/true, capture_time_ms).get(),
291 PacedPacketInfo());
292
293 // Send another packet at the same time, which replaces the last packet.
294 // Since this packet has 0 ms delay, the average is now 5 ms and max is 10 ms.
295 // The total counter stays the same though.
296 // TODO(terelius): Is is not clear that this is the right behavior.
297 EXPECT_CALL(send_side_delay_observer, SendSideDelayUpdated(5, 10, kSsrc));
298 capture_time_ms = clock_->TimeInMilliseconds();
299 sender->SendPacket(BuildRtpPacket(/*marker=*/true, capture_time_ms).get(),
300 PacedPacketInfo());
301
302 // Send a packet 1 second later. The earlier packets should have timed
303 // out, so both max and average should be the delay of this packet. The total
304 // keeps increasing.
305 time_controller_.AdvanceTime(TimeDelta::Seconds(1));
306 EXPECT_CALL(send_side_delay_observer, SendSideDelayUpdated(1, 1, kSsrc));
307 capture_time_ms = clock_->TimeInMilliseconds();
308 time_controller_.AdvanceTime(TimeDelta::Millis(1));
309 sender->SendPacket(BuildRtpPacket(/*marker=*/true, capture_time_ms).get(),
310 PacedPacketInfo());
311 }
312
TEST_F(RtpSenderEgressTest,WritesPacerExitToTimingExtension)313 TEST_F(RtpSenderEgressTest, WritesPacerExitToTimingExtension) {
314 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
315 header_extensions_.RegisterByUri(kVideoTimingExtensionId,
316 VideoTimingExtension::Uri());
317
318 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket();
319 packet->SetExtension<VideoTimingExtension>(VideoSendTiming{});
320
321 const int kStoredTimeInMs = 100;
322 time_controller_.AdvanceTime(TimeDelta::Millis(kStoredTimeInMs));
323 sender->SendPacket(packet.get(), PacedPacketInfo());
324 ASSERT_TRUE(transport_.last_packet().has_value());
325
326 VideoSendTiming video_timing;
327 EXPECT_TRUE(
328 transport_.last_packet()->packet.GetExtension<VideoTimingExtension>(
329 &video_timing));
330 EXPECT_EQ(video_timing.pacer_exit_delta_ms, kStoredTimeInMs);
331 }
332
TEST_F(RtpSenderEgressTest,WritesNetwork2ToTimingExtension)333 TEST_F(RtpSenderEgressTest, WritesNetwork2ToTimingExtension) {
334 RtpRtcpInterface::Configuration rtp_config = DefaultConfig();
335 rtp_config.populate_network2_timestamp = true;
336 auto sender = std::make_unique<RtpSenderEgress>(rtp_config, &packet_history_);
337 header_extensions_.RegisterByUri(kVideoTimingExtensionId,
338 VideoTimingExtension::Uri());
339
340 const uint16_t kPacerExitMs = 1234u;
341 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket();
342 VideoSendTiming send_timing = {};
343 send_timing.pacer_exit_delta_ms = kPacerExitMs;
344 packet->SetExtension<VideoTimingExtension>(send_timing);
345
346 const int kStoredTimeInMs = 100;
347 time_controller_.AdvanceTime(TimeDelta::Millis(kStoredTimeInMs));
348 sender->SendPacket(packet.get(), PacedPacketInfo());
349 ASSERT_TRUE(transport_.last_packet().has_value());
350
351 VideoSendTiming video_timing;
352 EXPECT_TRUE(
353 transport_.last_packet()->packet.GetExtension<VideoTimingExtension>(
354 &video_timing));
355 EXPECT_EQ(video_timing.network2_timestamp_delta_ms, kStoredTimeInMs);
356 EXPECT_EQ(video_timing.pacer_exit_delta_ms, kPacerExitMs);
357 }
358
TEST_F(RtpSenderEgressTest,OnSendPacketUpdated)359 TEST_F(RtpSenderEgressTest, OnSendPacketUpdated) {
360 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
361 header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId,
362 TransportSequenceNumber::Uri());
363
364 const uint16_t kTransportSequenceNumber = 1;
365 EXPECT_CALL(send_packet_observer_,
366 OnSendPacket(kTransportSequenceNumber,
367 clock_->TimeInMilliseconds(), kSsrc));
368 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket();
369 packet->SetExtension<TransportSequenceNumber>(kTransportSequenceNumber);
370 sender->SendPacket(packet.get(), PacedPacketInfo());
371 }
372
TEST_F(RtpSenderEgressTest,OnSendPacketNotUpdatedForRetransmits)373 TEST_F(RtpSenderEgressTest, OnSendPacketNotUpdatedForRetransmits) {
374 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
375 header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId,
376 TransportSequenceNumber::Uri());
377
378 const uint16_t kTransportSequenceNumber = 1;
379 EXPECT_CALL(send_packet_observer_, OnSendPacket).Times(0);
380 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket();
381 packet->SetExtension<TransportSequenceNumber>(kTransportSequenceNumber);
382 packet->set_packet_type(RtpPacketMediaType::kRetransmission);
383 packet->set_retransmitted_sequence_number(packet->SequenceNumber());
384 sender->SendPacket(packet.get(), PacedPacketInfo());
385 }
386
TEST_F(RtpSenderEgressTest,ReportsFecRate)387 TEST_F(RtpSenderEgressTest, ReportsFecRate) {
388 constexpr int kNumPackets = 10;
389 constexpr TimeDelta kTimeBetweenPackets = TimeDelta::Millis(33);
390
391 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
392 DataSize total_fec_data_sent = DataSize::Zero();
393 // Send some packets, alternating between media and FEC.
394 for (size_t i = 0; i < kNumPackets; ++i) {
395 std::unique_ptr<RtpPacketToSend> media_packet = BuildRtpPacket();
396 media_packet->set_packet_type(RtpPacketMediaType::kVideo);
397 media_packet->SetPayloadSize(500);
398 sender->SendPacket(media_packet.get(), PacedPacketInfo());
399
400 std::unique_ptr<RtpPacketToSend> fec_packet = BuildRtpPacket();
401 fec_packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection);
402 fec_packet->SetPayloadSize(123);
403 sender->SendPacket(fec_packet.get(), PacedPacketInfo());
404 total_fec_data_sent += DataSize::Bytes(fec_packet->size());
405
406 time_controller_.AdvanceTime(kTimeBetweenPackets);
407 }
408
409 EXPECT_NEAR(
410 (sender->GetSendRates()[RtpPacketMediaType::kForwardErrorCorrection])
411 .bps(),
412 (total_fec_data_sent / (kTimeBetweenPackets * kNumPackets)).bps(), 500);
413 }
414
TEST_F(RtpSenderEgressTest,BitrateCallbacks)415 TEST_F(RtpSenderEgressTest, BitrateCallbacks) {
416 class MockBitrateStaticsObserver : public BitrateStatisticsObserver {
417 public:
418 MOCK_METHOD(void, Notify, (uint32_t, uint32_t, uint32_t), (override));
419 } observer;
420
421 RtpRtcpInterface::Configuration config = DefaultConfig();
422 config.send_bitrate_observer = &observer;
423 auto sender = std::make_unique<RtpSenderEgress>(config, &packet_history_);
424
425 // Simulate kNumPackets sent with kPacketInterval intervals, with the
426 // number of packets selected so that we fill (but don't overflow) the one
427 // second averaging window.
428 const TimeDelta kWindowSize = TimeDelta::Seconds(1);
429 const TimeDelta kPacketInterval = TimeDelta::Millis(20);
430 const int kNumPackets = (kWindowSize - kPacketInterval) / kPacketInterval;
431
432 DataSize total_data_sent = DataSize::Zero();
433
434 // Send all but on of the packets, expect a call for each packet but don't
435 // verify bitrate yet (noisy measurements in the beginning).
436 for (int i = 0; i < kNumPackets; ++i) {
437 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket();
438 packet->SetPayloadSize(500);
439 // Mark all packets as retransmissions - will cause total and retransmission
440 // rates to be equal.
441 packet->set_packet_type(RtpPacketMediaType::kRetransmission);
442 packet->set_retransmitted_sequence_number(packet->SequenceNumber());
443 total_data_sent += DataSize::Bytes(packet->size());
444
445 EXPECT_CALL(observer, Notify(_, _, kSsrc))
446 .WillOnce([&](uint32_t total_bitrate_bps,
447 uint32_t retransmission_bitrate_bps, uint32_t /*ssrc*/) {
448 TimeDelta window_size = i * kPacketInterval + TimeDelta::Millis(1);
449 // If there is just a single data point, there is no well defined
450 // averaging window so a bitrate of zero will be reported.
451 const double expected_bitrate_bps =
452 i == 0 ? 0.0 : (total_data_sent / window_size).bps();
453 EXPECT_NEAR(total_bitrate_bps, expected_bitrate_bps, 500);
454 EXPECT_NEAR(retransmission_bitrate_bps, expected_bitrate_bps, 500);
455 });
456
457 sender->SendPacket(packet.get(), PacedPacketInfo());
458 time_controller_.AdvanceTime(kPacketInterval);
459 }
460 }
461
TEST_F(RtpSenderEgressTest,DoesNotPutNotRetransmittablePacketsInHistory)462 TEST_F(RtpSenderEgressTest, DoesNotPutNotRetransmittablePacketsInHistory) {
463 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
464 packet_history_.SetStorePacketsStatus(
465 RtpPacketHistory::StorageMode::kStoreAndCull, 10);
466
467 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket();
468 packet->set_allow_retransmission(false);
469 sender->SendPacket(packet.get(), PacedPacketInfo());
470 EXPECT_FALSE(packet_history_.GetPacketState(packet->SequenceNumber()));
471 }
472
TEST_F(RtpSenderEgressTest,PutsRetransmittablePacketsInHistory)473 TEST_F(RtpSenderEgressTest, PutsRetransmittablePacketsInHistory) {
474 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
475 packet_history_.SetStorePacketsStatus(
476 RtpPacketHistory::StorageMode::kStoreAndCull, 10);
477
478 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket();
479 packet->set_allow_retransmission(true);
480 sender->SendPacket(packet.get(), PacedPacketInfo());
481 EXPECT_TRUE(packet_history_.GetPacketState(packet->SequenceNumber()));
482 }
483
TEST_F(RtpSenderEgressTest,DoesNotPutNonMediaInHistory)484 TEST_F(RtpSenderEgressTest, DoesNotPutNonMediaInHistory) {
485 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
486 packet_history_.SetStorePacketsStatus(
487 RtpPacketHistory::StorageMode::kStoreAndCull, 10);
488
489 // Non-media packets, even when marked as retransmittable, are not put into
490 // the packet history.
491 std::unique_ptr<RtpPacketToSend> retransmission = BuildRtpPacket();
492 retransmission->set_allow_retransmission(true);
493 retransmission->set_packet_type(RtpPacketMediaType::kRetransmission);
494 retransmission->set_retransmitted_sequence_number(
495 retransmission->SequenceNumber());
496 sender->SendPacket(retransmission.get(), PacedPacketInfo());
497 EXPECT_FALSE(
498 packet_history_.GetPacketState(retransmission->SequenceNumber()));
499
500 std::unique_ptr<RtpPacketToSend> fec = BuildRtpPacket();
501 fec->set_allow_retransmission(true);
502 fec->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection);
503 sender->SendPacket(fec.get(), PacedPacketInfo());
504 EXPECT_FALSE(packet_history_.GetPacketState(fec->SequenceNumber()));
505
506 std::unique_ptr<RtpPacketToSend> padding = BuildRtpPacket();
507 padding->set_allow_retransmission(true);
508 padding->set_packet_type(RtpPacketMediaType::kPadding);
509 sender->SendPacket(padding.get(), PacedPacketInfo());
510 EXPECT_FALSE(packet_history_.GetPacketState(padding->SequenceNumber()));
511 }
512
TEST_F(RtpSenderEgressTest,UpdatesSendStatusOfRetransmittedPackets)513 TEST_F(RtpSenderEgressTest, UpdatesSendStatusOfRetransmittedPackets) {
514 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
515 packet_history_.SetStorePacketsStatus(
516 RtpPacketHistory::StorageMode::kStoreAndCull, 10);
517
518 // Send a packet, putting it in the history.
519 std::unique_ptr<RtpPacketToSend> media_packet = BuildRtpPacket();
520 media_packet->set_allow_retransmission(true);
521 sender->SendPacket(media_packet.get(), PacedPacketInfo());
522 EXPECT_TRUE(packet_history_.GetPacketState(media_packet->SequenceNumber()));
523
524 // Simulate a retransmission, marking the packet as pending.
525 std::unique_ptr<RtpPacketToSend> retransmission =
526 packet_history_.GetPacketAndMarkAsPending(media_packet->SequenceNumber());
527 retransmission->set_retransmitted_sequence_number(
528 media_packet->SequenceNumber());
529 retransmission->set_packet_type(RtpPacketMediaType::kRetransmission);
530 EXPECT_TRUE(packet_history_.GetPacketState(media_packet->SequenceNumber()));
531
532 // Simulate packet leaving pacer, the packet should be marked as non-pending.
533 sender->SendPacket(retransmission.get(), PacedPacketInfo());
534 EXPECT_TRUE(packet_history_.GetPacketState(media_packet->SequenceNumber()));
535 }
536
TEST_F(RtpSenderEgressTest,StreamDataCountersCallbacks)537 TEST_F(RtpSenderEgressTest, StreamDataCountersCallbacks) {
538 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
539
540 const RtpPacketCounter kEmptyCounter;
541 RtpPacketCounter expected_transmitted_counter;
542 RtpPacketCounter expected_retransmission_counter;
543
544 // Send a media packet.
545 std::unique_ptr<RtpPacketToSend> media_packet = BuildRtpPacket();
546 media_packet->SetPayloadSize(6);
547 media_packet->SetSequenceNumber(kStartSequenceNumber);
548 media_packet->set_time_in_send_queue(TimeDelta::Millis(10));
549 expected_transmitted_counter.packets += 1;
550 expected_transmitted_counter.payload_bytes += media_packet->payload_size();
551 expected_transmitted_counter.header_bytes += media_packet->headers_size();
552 expected_transmitted_counter.total_packet_delay += TimeDelta::Millis(10);
553
554 EXPECT_CALL(
555 mock_rtp_stats_callback_,
556 DataCountersUpdated(AllOf(Field(&StreamDataCounters::transmitted,
557 expected_transmitted_counter),
558 Field(&StreamDataCounters::retransmitted,
559 expected_retransmission_counter),
560 Field(&StreamDataCounters::fec, kEmptyCounter)),
561 kSsrc));
562 sender->SendPacket(media_packet.get(), PacedPacketInfo());
563 time_controller_.AdvanceTime(TimeDelta::Zero());
564
565 // Send a retransmission. Retransmissions are counted into both transmitted
566 // and retransmitted packet statistics.
567 std::unique_ptr<RtpPacketToSend> retransmission_packet = BuildRtpPacket();
568 retransmission_packet->set_packet_type(RtpPacketMediaType::kRetransmission);
569 retransmission_packet->SetSequenceNumber(kStartSequenceNumber);
570 retransmission_packet->set_retransmitted_sequence_number(
571 kStartSequenceNumber);
572 retransmission_packet->set_time_in_send_queue(TimeDelta::Millis(20));
573 media_packet->SetPayloadSize(7);
574 expected_transmitted_counter.packets += 1;
575 expected_transmitted_counter.payload_bytes +=
576 retransmission_packet->payload_size();
577 expected_transmitted_counter.header_bytes +=
578 retransmission_packet->headers_size();
579 expected_transmitted_counter.total_packet_delay += TimeDelta::Millis(20);
580
581 expected_retransmission_counter.packets += 1;
582 expected_retransmission_counter.payload_bytes +=
583 retransmission_packet->payload_size();
584 expected_retransmission_counter.header_bytes +=
585 retransmission_packet->headers_size();
586 expected_retransmission_counter.total_packet_delay += TimeDelta::Millis(20);
587
588 EXPECT_CALL(
589 mock_rtp_stats_callback_,
590 DataCountersUpdated(AllOf(Field(&StreamDataCounters::transmitted,
591 expected_transmitted_counter),
592 Field(&StreamDataCounters::retransmitted,
593 expected_retransmission_counter),
594 Field(&StreamDataCounters::fec, kEmptyCounter)),
595 kSsrc));
596 sender->SendPacket(retransmission_packet.get(), PacedPacketInfo());
597 time_controller_.AdvanceTime(TimeDelta::Zero());
598
599 // Send a padding packet.
600 std::unique_ptr<RtpPacketToSend> padding_packet = BuildRtpPacket();
601 padding_packet->set_packet_type(RtpPacketMediaType::kPadding);
602 padding_packet->SetPadding(224);
603 padding_packet->SetSequenceNumber(kStartSequenceNumber + 1);
604 padding_packet->set_time_in_send_queue(TimeDelta::Millis(30));
605 expected_transmitted_counter.packets += 1;
606 expected_transmitted_counter.padding_bytes += padding_packet->padding_size();
607 expected_transmitted_counter.header_bytes += padding_packet->headers_size();
608 expected_transmitted_counter.total_packet_delay += TimeDelta::Millis(30);
609
610 EXPECT_CALL(
611 mock_rtp_stats_callback_,
612 DataCountersUpdated(AllOf(Field(&StreamDataCounters::transmitted,
613 expected_transmitted_counter),
614 Field(&StreamDataCounters::retransmitted,
615 expected_retransmission_counter),
616 Field(&StreamDataCounters::fec, kEmptyCounter)),
617 kSsrc));
618 sender->SendPacket(padding_packet.get(), PacedPacketInfo());
619 time_controller_.AdvanceTime(TimeDelta::Zero());
620 }
621
TEST_F(RtpSenderEgressTest,StreamDataCountersCallbacksFec)622 TEST_F(RtpSenderEgressTest, StreamDataCountersCallbacksFec) {
623 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
624
625 const RtpPacketCounter kEmptyCounter;
626 RtpPacketCounter expected_transmitted_counter;
627 RtpPacketCounter expected_fec_counter;
628
629 // Send a media packet.
630 std::unique_ptr<RtpPacketToSend> media_packet = BuildRtpPacket();
631 media_packet->SetPayloadSize(6);
632 expected_transmitted_counter.packets += 1;
633 expected_transmitted_counter.payload_bytes += media_packet->payload_size();
634 expected_transmitted_counter.header_bytes += media_packet->headers_size();
635
636 EXPECT_CALL(
637 mock_rtp_stats_callback_,
638 DataCountersUpdated(
639 AllOf(Field(&StreamDataCounters::transmitted,
640 expected_transmitted_counter),
641 Field(&StreamDataCounters::retransmitted, kEmptyCounter),
642 Field(&StreamDataCounters::fec, expected_fec_counter)),
643 kSsrc));
644 sender->SendPacket(media_packet.get(), PacedPacketInfo());
645 time_controller_.AdvanceTime(TimeDelta::Zero());
646
647 // Send and FEC packet. FEC is counted into both transmitted and FEC packet
648 // statistics.
649 std::unique_ptr<RtpPacketToSend> fec_packet = BuildRtpPacket();
650 fec_packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection);
651 fec_packet->SetPayloadSize(6);
652 expected_transmitted_counter.packets += 1;
653 expected_transmitted_counter.payload_bytes += fec_packet->payload_size();
654 expected_transmitted_counter.header_bytes += fec_packet->headers_size();
655
656 expected_fec_counter.packets += 1;
657 expected_fec_counter.payload_bytes += fec_packet->payload_size();
658 expected_fec_counter.header_bytes += fec_packet->headers_size();
659
660 EXPECT_CALL(
661 mock_rtp_stats_callback_,
662 DataCountersUpdated(
663 AllOf(Field(&StreamDataCounters::transmitted,
664 expected_transmitted_counter),
665 Field(&StreamDataCounters::retransmitted, kEmptyCounter),
666 Field(&StreamDataCounters::fec, expected_fec_counter)),
667 kSsrc));
668 sender->SendPacket(fec_packet.get(), PacedPacketInfo());
669 time_controller_.AdvanceTime(TimeDelta::Zero());
670 }
671
TEST_F(RtpSenderEgressTest,UpdatesDataCounters)672 TEST_F(RtpSenderEgressTest, UpdatesDataCounters) {
673 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
674
675 const RtpPacketCounter kEmptyCounter;
676
677 // Send a media packet.
678 std::unique_ptr<RtpPacketToSend> media_packet = BuildRtpPacket();
679 media_packet->SetPayloadSize(6);
680 sender->SendPacket(media_packet.get(), PacedPacketInfo());
681 time_controller_.AdvanceTime(TimeDelta::Zero());
682
683 // Send an RTX retransmission packet.
684 std::unique_ptr<RtpPacketToSend> rtx_packet = BuildRtpPacket();
685 rtx_packet->set_packet_type(RtpPacketMediaType::kRetransmission);
686 rtx_packet->SetSsrc(kRtxSsrc);
687 rtx_packet->SetPayloadSize(7);
688 rtx_packet->set_retransmitted_sequence_number(media_packet->SequenceNumber());
689 sender->SendPacket(rtx_packet.get(), PacedPacketInfo());
690 time_controller_.AdvanceTime(TimeDelta::Zero());
691
692 StreamDataCounters rtp_stats;
693 StreamDataCounters rtx_stats;
694 sender->GetDataCounters(&rtp_stats, &rtx_stats);
695
696 EXPECT_EQ(rtp_stats.transmitted.packets, 1u);
697 EXPECT_EQ(rtp_stats.transmitted.payload_bytes, media_packet->payload_size());
698 EXPECT_EQ(rtp_stats.transmitted.padding_bytes, media_packet->padding_size());
699 EXPECT_EQ(rtp_stats.transmitted.header_bytes, media_packet->headers_size());
700 EXPECT_EQ(rtp_stats.retransmitted, kEmptyCounter);
701 EXPECT_EQ(rtp_stats.fec, kEmptyCounter);
702
703 // Retransmissions are counted both into transmitted and retransmitted
704 // packet counts.
705 EXPECT_EQ(rtx_stats.transmitted.packets, 1u);
706 EXPECT_EQ(rtx_stats.transmitted.payload_bytes, rtx_packet->payload_size());
707 EXPECT_EQ(rtx_stats.transmitted.padding_bytes, rtx_packet->padding_size());
708 EXPECT_EQ(rtx_stats.transmitted.header_bytes, rtx_packet->headers_size());
709 EXPECT_EQ(rtx_stats.retransmitted, rtx_stats.transmitted);
710 EXPECT_EQ(rtx_stats.fec, kEmptyCounter);
711 }
712
TEST_F(RtpSenderEgressTest,SendPacketUpdatesExtensions)713 TEST_F(RtpSenderEgressTest, SendPacketUpdatesExtensions) {
714 header_extensions_.RegisterByUri(kVideoTimingExtensionId,
715 VideoTimingExtension::Uri());
716 header_extensions_.RegisterByUri(kAbsoluteSendTimeExtensionId,
717 AbsoluteSendTime::Uri());
718 header_extensions_.RegisterByUri(kTransmissionOffsetExtensionId,
719 TransmissionOffset::Uri());
720 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
721
722 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket();
723 packet->set_packetization_finish_time(clock_->CurrentTime());
724
725 const int32_t kDiffMs = 10;
726 time_controller_.AdvanceTime(TimeDelta::Millis(kDiffMs));
727
728 sender->SendPacket(packet.get(), PacedPacketInfo());
729
730 RtpPacketReceived received_packet = transport_.last_packet()->packet;
731
732 EXPECT_EQ(received_packet.GetExtension<TransmissionOffset>(), kDiffMs * 90);
733
734 EXPECT_EQ(received_packet.GetExtension<AbsoluteSendTime>(),
735 AbsoluteSendTime::To24Bits(clock_->CurrentTime()));
736
737 VideoSendTiming timing;
738 EXPECT_TRUE(received_packet.GetExtension<VideoTimingExtension>(&timing));
739 EXPECT_EQ(timing.pacer_exit_delta_ms, kDiffMs);
740 }
741
TEST_F(RtpSenderEgressTest,SendPacketSetsPacketOptions)742 TEST_F(RtpSenderEgressTest, SendPacketSetsPacketOptions) {
743 const uint16_t kPacketId = 42;
744 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
745 header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId,
746 TransportSequenceNumber::Uri());
747
748 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket();
749 packet->SetExtension<TransportSequenceNumber>(kPacketId);
750 EXPECT_CALL(send_packet_observer_, OnSendPacket);
751 sender->SendPacket(packet.get(), PacedPacketInfo());
752
753 PacketOptions packet_options = transport_.last_packet()->options;
754
755 EXPECT_EQ(packet_options.packet_id, kPacketId);
756 EXPECT_TRUE(packet_options.included_in_allocation);
757 EXPECT_TRUE(packet_options.included_in_feedback);
758 EXPECT_FALSE(packet_options.is_retransmit);
759
760 // Send another packet as retransmission, verify options are populated.
761 std::unique_ptr<RtpPacketToSend> retransmission = BuildRtpPacket();
762 retransmission->SetExtension<TransportSequenceNumber>(kPacketId + 1);
763 retransmission->set_packet_type(RtpPacketMediaType::kRetransmission);
764 retransmission->set_retransmitted_sequence_number(packet->SequenceNumber());
765 sender->SendPacket(retransmission.get(), PacedPacketInfo());
766 EXPECT_TRUE(transport_.last_packet()->options.is_retransmit);
767 }
768
TEST_F(RtpSenderEgressTest,SendPacketUpdatesStats)769 TEST_F(RtpSenderEgressTest, SendPacketUpdatesStats) {
770 const size_t kPayloadSize = 1000;
771 StrictMock<MockSendSideDelayObserver> send_side_delay_observer;
772
773 const rtc::ArrayView<const RtpExtensionSize> kNoRtpHeaderExtensionSizes;
774 FlexfecSender flexfec(kFlexfectPayloadType, kFlexFecSsrc, kSsrc, /*mid=*/"",
775 /*header_extensions=*/{}, kNoRtpHeaderExtensionSizes,
776 /*rtp_state=*/nullptr, time_controller_.GetClock());
777 RtpRtcpInterface::Configuration config = DefaultConfig();
778 config.fec_generator = &flexfec;
779 config.send_side_delay_observer = &send_side_delay_observer;
780 auto sender = std::make_unique<RtpSenderEgress>(config, &packet_history_);
781
782 header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId,
783 TransportSequenceNumber::Uri());
784
785 const int64_t capture_time_ms = clock_->TimeInMilliseconds();
786
787 std::unique_ptr<RtpPacketToSend> video_packet = BuildRtpPacket();
788 video_packet->set_packet_type(RtpPacketMediaType::kVideo);
789 video_packet->SetPayloadSize(kPayloadSize);
790 video_packet->SetExtension<TransportSequenceNumber>(1);
791
792 std::unique_ptr<RtpPacketToSend> rtx_packet = BuildRtpPacket();
793 rtx_packet->SetSsrc(kRtxSsrc);
794 rtx_packet->set_packet_type(RtpPacketMediaType::kRetransmission);
795 rtx_packet->set_retransmitted_sequence_number(video_packet->SequenceNumber());
796 rtx_packet->SetPayloadSize(kPayloadSize);
797 rtx_packet->SetExtension<TransportSequenceNumber>(2);
798
799 std::unique_ptr<RtpPacketToSend> fec_packet = BuildRtpPacket();
800 fec_packet->SetSsrc(kFlexFecSsrc);
801 fec_packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection);
802 fec_packet->SetPayloadSize(kPayloadSize);
803 fec_packet->SetExtension<TransportSequenceNumber>(3);
804
805 const int64_t kDiffMs = 25;
806 time_controller_.AdvanceTime(TimeDelta::Millis(kDiffMs));
807
808 EXPECT_CALL(send_side_delay_observer,
809 SendSideDelayUpdated(kDiffMs, kDiffMs, kSsrc));
810 EXPECT_CALL(send_side_delay_observer,
811 SendSideDelayUpdated(kDiffMs, kDiffMs, kFlexFecSsrc));
812
813 EXPECT_CALL(send_packet_observer_, OnSendPacket(1, capture_time_ms, kSsrc));
814
815 sender->SendPacket(video_packet.get(), PacedPacketInfo());
816
817 // Send packet observer not called for padding/retransmissions.
818 EXPECT_CALL(send_packet_observer_, OnSendPacket(2, _, _)).Times(0);
819 sender->SendPacket(rtx_packet.get(), PacedPacketInfo());
820
821 EXPECT_CALL(send_packet_observer_,
822 OnSendPacket(3, capture_time_ms, kFlexFecSsrc));
823 sender->SendPacket(fec_packet.get(), PacedPacketInfo());
824
825 time_controller_.AdvanceTime(TimeDelta::Zero());
826 StreamDataCounters rtp_stats;
827 StreamDataCounters rtx_stats;
828 sender->GetDataCounters(&rtp_stats, &rtx_stats);
829 EXPECT_EQ(rtp_stats.transmitted.packets, 2u);
830 EXPECT_EQ(rtp_stats.fec.packets, 1u);
831 EXPECT_EQ(rtx_stats.retransmitted.packets, 1u);
832 }
833
TEST_F(RtpSenderEgressTest,TransportFeedbackObserverWithRetransmission)834 TEST_F(RtpSenderEgressTest, TransportFeedbackObserverWithRetransmission) {
835 const uint16_t kTransportSequenceNumber = 17;
836 header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId,
837 TransportSequenceNumber::Uri());
838 std::unique_ptr<RtpPacketToSend> retransmission = BuildRtpPacket();
839 retransmission->set_packet_type(RtpPacketMediaType::kRetransmission);
840 retransmission->SetExtension<TransportSequenceNumber>(
841 kTransportSequenceNumber);
842 uint16_t retransmitted_seq = retransmission->SequenceNumber() - 2;
843 retransmission->set_retransmitted_sequence_number(retransmitted_seq);
844
845 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
846 EXPECT_CALL(
847 feedback_observer_,
848 OnAddPacket(AllOf(
849 Field(&RtpPacketSendInfo::media_ssrc, kSsrc),
850 Field(&RtpPacketSendInfo::rtp_sequence_number, retransmitted_seq),
851 Field(&RtpPacketSendInfo::transport_sequence_number,
852 kTransportSequenceNumber))));
853 sender->SendPacket(retransmission.get(), PacedPacketInfo());
854 }
855
TEST_F(RtpSenderEgressTest,TransportFeedbackObserverWithRtxRetransmission)856 TEST_F(RtpSenderEgressTest, TransportFeedbackObserverWithRtxRetransmission) {
857 const uint16_t kTransportSequenceNumber = 17;
858 header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId,
859 TransportSequenceNumber::Uri());
860
861 std::unique_ptr<RtpPacketToSend> rtx_retransmission = BuildRtpPacket();
862 rtx_retransmission->SetSsrc(kRtxSsrc);
863 rtx_retransmission->SetExtension<TransportSequenceNumber>(
864 kTransportSequenceNumber);
865 rtx_retransmission->set_packet_type(RtpPacketMediaType::kRetransmission);
866 uint16_t rtx_retransmitted_seq = rtx_retransmission->SequenceNumber() - 2;
867 rtx_retransmission->set_retransmitted_sequence_number(rtx_retransmitted_seq);
868
869 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
870 EXPECT_CALL(
871 feedback_observer_,
872 OnAddPacket(AllOf(
873 Field(&RtpPacketSendInfo::media_ssrc, kSsrc),
874 Field(&RtpPacketSendInfo::rtp_sequence_number, rtx_retransmitted_seq),
875 Field(&RtpPacketSendInfo::transport_sequence_number,
876 kTransportSequenceNumber))));
877 sender->SendPacket(rtx_retransmission.get(), PacedPacketInfo());
878 }
879
TEST_F(RtpSenderEgressTest,TransportFeedbackObserverPadding)880 TEST_F(RtpSenderEgressTest, TransportFeedbackObserverPadding) {
881 const uint16_t kTransportSequenceNumber = 17;
882 header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId,
883 TransportSequenceNumber::Uri());
884 std::unique_ptr<RtpPacketToSend> padding = BuildRtpPacket();
885 padding->SetPadding(224);
886 padding->set_packet_type(RtpPacketMediaType::kPadding);
887 padding->SetExtension<TransportSequenceNumber>(kTransportSequenceNumber);
888
889 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
890 EXPECT_CALL(
891 feedback_observer_,
892 OnAddPacket(AllOf(Field(&RtpPacketSendInfo::media_ssrc, absl::nullopt),
893 Field(&RtpPacketSendInfo::transport_sequence_number,
894 kTransportSequenceNumber))));
895 sender->SendPacket(padding.get(), PacedPacketInfo());
896 }
897
TEST_F(RtpSenderEgressTest,TransportFeedbackObserverRtxPadding)898 TEST_F(RtpSenderEgressTest, TransportFeedbackObserverRtxPadding) {
899 const uint16_t kTransportSequenceNumber = 17;
900 header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId,
901 TransportSequenceNumber::Uri());
902
903 std::unique_ptr<RtpPacketToSend> rtx_padding = BuildRtpPacket();
904 rtx_padding->SetPadding(224);
905 rtx_padding->SetSsrc(kRtxSsrc);
906 rtx_padding->set_packet_type(RtpPacketMediaType::kPadding);
907 rtx_padding->SetExtension<TransportSequenceNumber>(kTransportSequenceNumber);
908
909 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
910 EXPECT_CALL(
911 feedback_observer_,
912 OnAddPacket(AllOf(Field(&RtpPacketSendInfo::media_ssrc, absl::nullopt),
913 Field(&RtpPacketSendInfo::transport_sequence_number,
914 kTransportSequenceNumber))));
915 sender->SendPacket(rtx_padding.get(), PacedPacketInfo());
916 }
917
TEST_F(RtpSenderEgressTest,TransportFeedbackObserverFec)918 TEST_F(RtpSenderEgressTest, TransportFeedbackObserverFec) {
919 const uint16_t kTransportSequenceNumber = 17;
920 header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId,
921 TransportSequenceNumber::Uri());
922
923 std::unique_ptr<RtpPacketToSend> fec_packet = BuildRtpPacket();
924 fec_packet->SetSsrc(kFlexFecSsrc);
925 fec_packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection);
926 fec_packet->SetExtension<TransportSequenceNumber>(kTransportSequenceNumber);
927
928 const rtc::ArrayView<const RtpExtensionSize> kNoRtpHeaderExtensionSizes;
929 FlexfecSender flexfec(kFlexfectPayloadType, kFlexFecSsrc, kSsrc, /*mid=*/"",
930 /*header_extensions=*/{}, kNoRtpHeaderExtensionSizes,
931 /*rtp_state=*/nullptr, time_controller_.GetClock());
932 RtpRtcpInterface::Configuration config = DefaultConfig();
933 config.fec_generator = &flexfec;
934 auto sender = std::make_unique<RtpSenderEgress>(config, &packet_history_);
935 EXPECT_CALL(
936 feedback_observer_,
937 OnAddPacket(AllOf(Field(&RtpPacketSendInfo::media_ssrc, absl::nullopt),
938 Field(&RtpPacketSendInfo::transport_sequence_number,
939 kTransportSequenceNumber))));
940 sender->SendPacket(fec_packet.get(), PacedPacketInfo());
941 }
942
TEST_F(RtpSenderEgressTest,SupportsAbortingRetransmissions)943 TEST_F(RtpSenderEgressTest, SupportsAbortingRetransmissions) {
944 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
945 packet_history_.SetStorePacketsStatus(
946 RtpPacketHistory::StorageMode::kStoreAndCull, 10);
947
948 // Create a packet and send it so it is put in the history.
949 std::unique_ptr<RtpPacketToSend> media_packet = BuildRtpPacket();
950 media_packet->set_packet_type(RtpPacketMediaType::kVideo);
951 media_packet->set_allow_retransmission(true);
952 const uint16_t media_sequence_number = media_packet->SequenceNumber();
953 sender->SendPacket(media_packet.get(), PacedPacketInfo());
954
955 // Fetch a retranmission packet from the history, this should mark the
956 // media packets as pending so it is not available to grab again.
957 std::unique_ptr<RtpPacketToSend> retransmission_packet =
958 packet_history_.GetPacketAndMarkAsPending(media_sequence_number);
959 ASSERT_TRUE(retransmission_packet);
960 EXPECT_FALSE(
961 packet_history_.GetPacketAndMarkAsPending(media_sequence_number));
962
963 // Mark retransmission as aborted, fetching packet is possible again.
964 retransmission_packet.reset();
965 uint16_t kAbortedSequenceNumbers[] = {media_sequence_number};
966 sender->OnAbortedRetransmissions(kAbortedSequenceNumbers);
967 EXPECT_TRUE(packet_history_.GetPacketAndMarkAsPending(media_sequence_number));
968 }
969
970 } // namespace webrtc
971