Move SendPacketUpdates* tests to rtp_sender_egress_unittest.
These should be the last of the testis from rtp_sender_unittest.cc that
should be moved and refactored to just test RtpSenderEgress.
Bug: webrtc:11340
Change-Id: Id09d7bbade608dd7194dcd8843d4f2887842a372
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/220140
Commit-Queue: Erik Språng <sprang@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#34118}
diff --git a/modules/rtp_rtcp/source/rtp_sender_egress_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_egress_unittest.cc
index c31e5c1..663638f 100644
--- a/modules/rtp_rtcp/source/rtp_sender_egress_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_egress_unittest.cc
@@ -18,6 +18,7 @@
#include "api/units/data_size.h"
#include "api/units/timestamp.h"
#include "logging/rtc_event_log/mock/mock_rtc_event_log.h"
+#include "modules/rtp_rtcp/include/flexfec_sender.h"
#include "modules/rtp_rtcp/include/rtp_rtcp.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
@@ -39,12 +40,16 @@
constexpr Timestamp kStartTime = Timestamp::Millis(123456789);
constexpr int kDefaultPayloadType = 100;
+constexpr int kFlexfectPayloadType = 110;
constexpr uint16_t kStartSequenceNumber = 33;
constexpr uint32_t kSsrc = 725242;
constexpr uint32_t kRtxSsrc = 12345;
+constexpr uint32_t kFlexFecSsrc = 23456;
enum : int {
kTransportSequenceNumberExtensionId = 1,
- kVideoTimingExtensionExtensionId,
+ kAbsoluteSendTimeExtensionId,
+ kTransmissionOffsetExtensionId,
+ kVideoTimingExtensionId,
};
struct TestConfig {
@@ -334,7 +339,7 @@
TEST_P(RtpSenderEgressTest, WritesPacerExitToTimingExtension) {
std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
- header_extensions_.RegisterByUri(kVideoTimingExtensionExtensionId,
+ header_extensions_.RegisterByUri(kVideoTimingExtensionId,
VideoTimingExtension::kUri);
std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket();
@@ -356,7 +361,7 @@
RtpRtcpInterface::Configuration rtp_config = DefaultConfig();
rtp_config.populate_network2_timestamp = true;
auto sender = std::make_unique<RtpSenderEgress>(rtp_config, &packet_history_);
- header_extensions_.RegisterByUri(kVideoTimingExtensionExtensionId,
+ header_extensions_.RegisterByUri(kVideoTimingExtensionId,
VideoTimingExtension::kUri);
const uint16_t kPacerExitMs = 1234u;
@@ -729,6 +734,126 @@
EXPECT_EQ(rtx_stats.fec, kEmptyCounter);
}
+TEST_P(RtpSenderEgressTest, SendPacketUpdatesExtensions) {
+ header_extensions_.RegisterByUri(kVideoTimingExtensionId,
+ VideoTimingExtension::kUri);
+ header_extensions_.RegisterByUri(kAbsoluteSendTimeExtensionId,
+ AbsoluteSendTime::kUri);
+ header_extensions_.RegisterByUri(kTransmissionOffsetExtensionId,
+ TransmissionOffset::kUri);
+ std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
+
+ std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket();
+ packet->set_packetization_finish_time_ms(clock_->TimeInMilliseconds());
+
+ const int32_t kDiffMs = 10;
+ time_controller_.AdvanceTime(TimeDelta::Millis(kDiffMs));
+
+ sender->SendPacket(packet.get(), PacedPacketInfo());
+
+ RtpPacketReceived received_packet = transport_.last_packet()->packet;
+
+ EXPECT_EQ(received_packet.GetExtension<TransmissionOffset>(), kDiffMs * 90);
+
+ EXPECT_EQ(received_packet.GetExtension<AbsoluteSendTime>(),
+ AbsoluteSendTime::MsTo24Bits(clock_->TimeInMilliseconds()));
+
+ VideoSendTiming timing;
+ EXPECT_TRUE(received_packet.GetExtension<VideoTimingExtension>(&timing));
+ EXPECT_EQ(timing.pacer_exit_delta_ms, kDiffMs);
+}
+
+TEST_P(RtpSenderEgressTest, SendPacketSetsPacketOptions) {
+ const uint16_t kPacketId = 42;
+ std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress();
+ header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId,
+ TransportSequenceNumber::kUri);
+
+ std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket();
+ packet->SetExtension<TransportSequenceNumber>(kPacketId);
+ EXPECT_CALL(send_packet_observer_, OnSendPacket);
+ sender->SendPacket(packet.get(), PacedPacketInfo());
+
+ PacketOptions packet_options = transport_.last_packet()->options;
+
+ EXPECT_EQ(packet_options.packet_id, kPacketId);
+ EXPECT_TRUE(packet_options.included_in_allocation);
+ EXPECT_TRUE(packet_options.included_in_feedback);
+ EXPECT_FALSE(packet_options.is_retransmit);
+
+ // Send another packet as retransmission, verify options are populated.
+ std::unique_ptr<RtpPacketToSend> retransmission = BuildRtpPacket();
+ retransmission->SetExtension<TransportSequenceNumber>(kPacketId + 1);
+ retransmission->set_packet_type(RtpPacketMediaType::kRetransmission);
+ sender->SendPacket(retransmission.get(), PacedPacketInfo());
+ EXPECT_TRUE(transport_.last_packet()->options.is_retransmit);
+}
+
+TEST_P(RtpSenderEgressTest, SendPacketUpdatesStats) {
+ const size_t kPayloadSize = 1000;
+ StrictMock<MockSendSideDelayObserver> send_side_delay_observer;
+
+ const rtc::ArrayView<const RtpExtensionSize> kNoRtpHeaderExtensionSizes;
+ FlexfecSender flexfec(kFlexfectPayloadType, kFlexFecSsrc, kSsrc, /*mid=*/"",
+ /*header_extensions=*/{}, kNoRtpHeaderExtensionSizes,
+ /*rtp_state=*/nullptr, time_controller_.GetClock());
+ RtpRtcpInterface::Configuration config = DefaultConfig();
+ config.fec_generator = &flexfec;
+ config.send_side_delay_observer = &send_side_delay_observer;
+ auto sender = std::make_unique<RtpSenderEgress>(config, &packet_history_);
+
+ header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId,
+ TransportSequenceNumber::kUri);
+
+ const int64_t capture_time_ms = clock_->TimeInMilliseconds();
+
+ std::unique_ptr<RtpPacketToSend> video_packet = BuildRtpPacket();
+ video_packet->set_packet_type(RtpPacketMediaType::kVideo);
+ video_packet->SetPayloadSize(kPayloadSize);
+ video_packet->SetExtension<TransportSequenceNumber>(1);
+
+ std::unique_ptr<RtpPacketToSend> rtx_packet = BuildRtpPacket();
+ rtx_packet->SetSsrc(kRtxSsrc);
+ rtx_packet->set_packet_type(RtpPacketMediaType::kRetransmission);
+ rtx_packet->SetPayloadSize(kPayloadSize);
+ rtx_packet->SetExtension<TransportSequenceNumber>(2);
+
+ std::unique_ptr<RtpPacketToSend> fec_packet = BuildRtpPacket();
+ fec_packet->SetSsrc(kFlexFecSsrc);
+ fec_packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection);
+ fec_packet->SetPayloadSize(kPayloadSize);
+ fec_packet->SetExtension<TransportSequenceNumber>(3);
+
+ const int64_t kDiffMs = 25;
+ time_controller_.AdvanceTime(TimeDelta::Millis(kDiffMs));
+
+ EXPECT_CALL(send_side_delay_observer,
+ SendSideDelayUpdated(kDiffMs, kDiffMs, kDiffMs, kSsrc));
+ EXPECT_CALL(
+ send_side_delay_observer,
+ SendSideDelayUpdated(kDiffMs, kDiffMs, 2 * kDiffMs, kFlexFecSsrc));
+
+ EXPECT_CALL(send_packet_observer_, OnSendPacket(1, capture_time_ms, kSsrc));
+
+ sender->SendPacket(video_packet.get(), PacedPacketInfo());
+
+ // Send packet observer not called for padding/retransmissions.
+ EXPECT_CALL(send_packet_observer_, OnSendPacket(2, _, _)).Times(0);
+ sender->SendPacket(rtx_packet.get(), PacedPacketInfo());
+
+ EXPECT_CALL(send_packet_observer_,
+ OnSendPacket(3, capture_time_ms, kFlexFecSsrc));
+ sender->SendPacket(fec_packet.get(), PacedPacketInfo());
+
+ time_controller_.AdvanceTime(TimeDelta::Zero());
+ StreamDataCounters rtp_stats;
+ StreamDataCounters rtx_stats;
+ sender->GetDataCounters(&rtp_stats, &rtx_stats);
+ EXPECT_EQ(rtp_stats.transmitted.packets, 2u);
+ EXPECT_EQ(rtp_stats.fec.packets, 1u);
+ EXPECT_EQ(rtx_stats.retransmitted.packets, 1u);
+}
+
INSTANTIATE_TEST_SUITE_P(WithAndWithoutOverhead,
RtpSenderEgressTest,
::testing::Values(TestConfig(false),
diff --git a/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_unittest.cc
index d7a7b53..0e3ecd4 100644
--- a/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@@ -1157,131 +1157,6 @@
EXPECT_THAT(rtp_sender()->ReSendPacket(media_sequence_number), Gt(0));
}
-TEST_P(RtpSenderTest, SendPacketUpdatesExtensions) {
- ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
- TransmissionOffset::kUri, kTransmissionTimeOffsetExtensionId));
- ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
- AbsoluteSendTime::kUri, kAbsoluteSendTimeExtensionId));
- ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
- VideoTimingExtension::kUri, kVideoTimingExtensionId));
-
- std::unique_ptr<RtpPacketToSend> packet =
- BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds());
- packet->set_packetization_finish_time_ms(clock_->TimeInMilliseconds());
-
- const int32_t kDiffMs = 10;
- time_controller_.AdvanceTime(TimeDelta::Millis(kDiffMs));
-
- packet->set_packet_type(RtpPacketMediaType::kVideo);
- rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo());
-
- const RtpPacketReceived& received_packet = transport_.last_sent_packet();
-
- EXPECT_EQ(received_packet.GetExtension<TransmissionOffset>(), kDiffMs * 90);
-
- EXPECT_EQ(received_packet.GetExtension<AbsoluteSendTime>(),
- AbsoluteSendTime::MsTo24Bits(clock_->TimeInMilliseconds()));
-
- VideoSendTiming timing;
- EXPECT_TRUE(received_packet.GetExtension<VideoTimingExtension>(&timing));
- EXPECT_EQ(timing.pacer_exit_delta_ms, kDiffMs);
-}
-
-TEST_P(RtpSenderTest, SendPacketSetsPacketOptions) {
- const uint16_t kPacketId = 42;
- ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
- TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
- std::unique_ptr<RtpPacketToSend> packet =
- BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds());
- packet->SetExtension<TransportSequenceNumber>(kPacketId);
-
- packet->set_packet_type(RtpPacketMediaType::kVideo);
- EXPECT_CALL(send_packet_observer_, OnSendPacket);
- rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo());
-
- EXPECT_EQ(transport_.last_options_.packet_id, kPacketId);
- EXPECT_TRUE(transport_.last_options_.included_in_allocation);
- EXPECT_TRUE(transport_.last_options_.included_in_feedback);
- EXPECT_FALSE(transport_.last_options_.is_retransmit);
-
- // Send another packet as retransmission, verify options are populated.
- packet = BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds());
- packet->SetExtension<TransportSequenceNumber>(kPacketId + 1);
- packet->set_packet_type(RtpPacketMediaType::kRetransmission);
- rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo());
- EXPECT_TRUE(transport_.last_options_.is_retransmit);
-}
-
-TEST_P(RtpSenderTest, SendPacketUpdatesStats) {
- const size_t kPayloadSize = 1000;
-
- StrictMock<MockSendSideDelayObserver> send_side_delay_observer;
-
- RtpRtcpInterface::Configuration config;
- config.clock = clock_;
- config.outgoing_transport = &transport_;
- config.local_media_ssrc = kSsrc;
- config.rtx_send_ssrc = kRtxSsrc;
- config.fec_generator = &flexfec_sender_;
- config.send_side_delay_observer = &send_side_delay_observer;
- config.event_log = &mock_rtc_event_log_;
- config.send_packet_observer = &send_packet_observer_;
- rtp_sender_context_ =
- std::make_unique<RtpSenderContext>(config, &time_controller_);
- ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
- TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
-
- const int64_t capture_time_ms = clock_->TimeInMilliseconds();
-
- std::unique_ptr<RtpPacketToSend> video_packet =
- BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds());
- video_packet->set_packet_type(RtpPacketMediaType::kVideo);
- video_packet->SetPayloadSize(kPayloadSize);
- video_packet->SetExtension<TransportSequenceNumber>(1);
-
- std::unique_ptr<RtpPacketToSend> rtx_packet =
- BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds());
- rtx_packet->SetSsrc(kRtxSsrc);
- rtx_packet->set_packet_type(RtpPacketMediaType::kRetransmission);
- rtx_packet->SetPayloadSize(kPayloadSize);
- rtx_packet->SetExtension<TransportSequenceNumber>(2);
-
- std::unique_ptr<RtpPacketToSend> fec_packet =
- BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds());
- fec_packet->SetSsrc(kFlexFecSsrc);
- fec_packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection);
- fec_packet->SetPayloadSize(kPayloadSize);
- fec_packet->SetExtension<TransportSequenceNumber>(3);
-
- const int64_t kDiffMs = 25;
- time_controller_.AdvanceTime(TimeDelta::Millis(kDiffMs));
-
- EXPECT_CALL(send_side_delay_observer,
- SendSideDelayUpdated(kDiffMs, kDiffMs, kDiffMs, kSsrc));
- EXPECT_CALL(
- send_side_delay_observer,
- SendSideDelayUpdated(kDiffMs, kDiffMs, 2 * kDiffMs, kFlexFecSsrc));
-
- EXPECT_CALL(send_packet_observer_, OnSendPacket(1, capture_time_ms, kSsrc));
-
- rtp_sender_context_->InjectPacket(std::move(video_packet), PacedPacketInfo());
-
- // Send packet observer not called for padding/retransmissions.
- EXPECT_CALL(send_packet_observer_, OnSendPacket(2, _, _)).Times(0);
- rtp_sender_context_->InjectPacket(std::move(rtx_packet), PacedPacketInfo());
-
- EXPECT_CALL(send_packet_observer_,
- OnSendPacket(3, capture_time_ms, kFlexFecSsrc));
- rtp_sender_context_->InjectPacket(std::move(fec_packet), PacedPacketInfo());
-
- StreamDataCounters rtp_stats;
- StreamDataCounters rtx_stats;
- rtp_egress()->GetDataCounters(&rtp_stats, &rtx_stats);
- EXPECT_EQ(rtp_stats.transmitted.packets, 2u);
- EXPECT_EQ(rtp_stats.fec.packets, 1u);
- EXPECT_EQ(rtx_stats.retransmitted.packets, 1u);
-}
-
TEST_P(RtpSenderTest, GeneratedPaddingHasBweExtensions) {
// Min requested size in order to use RTX payload.
const size_t kMinPaddingSize = 50;
