From 31d0f7cfcaf8389ed4d5b45d6f39222b0bc049fc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B6rn=20Terelius?= Date: Thu, 6 Feb 2020 16:35:46 +0100 Subject: [PATCH] Move packet type enum from RtpPacketToSend to rtp_rtcp_defines.h MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This is in preparation of an upcoming CL that will propagate this information through the TransportFeedbackAdapter. Bug: webrtc:10932 Change-Id: Ic2a026b5ef72d6bf01e698e7634864fedc659b4e Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/168220 Reviewed-by: Erik Språng Reviewed-by: Sebastian Jansson Commit-Queue: Björn Terelius Cr-Commit-Position: refs/heads/master@{#30476} --- modules/pacing/paced_sender_unittest.cc | 14 +- modules/pacing/pacing_controller.cc | 18 +- modules/pacing/pacing_controller.h | 3 +- modules/pacing/pacing_controller_unittest.cc | 187 +++++++++-------- modules/pacing/round_robin_packet_queue.cc | 8 +- modules/pacing/round_robin_packet_queue.h | 2 +- .../task_queue_paced_sender_unittest.cc | 20 +- modules/rtp_rtcp/include/rtp_rtcp_defines.h | 10 + modules/rtp_rtcp/source/flexfec_sender.cc | 2 +- modules/rtp_rtcp/source/rtp_packet_to_send.h | 18 +- modules/rtp_rtcp/source/rtp_sender.cc | 6 +- modules/rtp_rtcp/source/rtp_sender_audio.cc | 4 +- modules/rtp_rtcp/source/rtp_sender_egress.cc | 24 +-- .../rtp_rtcp/source/rtp_sender_unittest.cc | 195 +++++++++--------- modules/rtp_rtcp/source/rtp_sender_video.cc | 16 +- 15 files changed, 264 insertions(+), 263 deletions(-) diff --git a/modules/pacing/paced_sender_unittest.cc b/modules/pacing/paced_sender_unittest.cc index 7d1b4cb92b..c4d821fcb8 100644 --- a/modules/pacing/paced_sender_unittest.cc +++ b/modules/pacing/paced_sender_unittest.cc @@ -86,21 +86,21 @@ class PacedSenderTest } protected: - std::unique_ptr BuildRtpPacket(RtpPacketToSend::Type type) { + std::unique_ptr BuildRtpPacket(RtpPacketMediaType type) { auto packet = std::make_unique(nullptr); packet->set_packet_type(type); switch (type) { - case RtpPacketToSend::Type::kAudio: + case RtpPacketMediaType::kAudio: packet->SetSsrc(kAudioSsrc); break; - case RtpPacketToSend::Type::kVideo: + case RtpPacketMediaType::kVideo: packet->SetSsrc(kVideoSsrc); break; - case RtpPacketToSend::Type::kRetransmission: - case RtpPacketToSend::Type::kPadding: + case RtpPacketMediaType::kRetransmission: + case RtpPacketMediaType::kPadding: packet->SetSsrc(kVideoRtxSsrc); break; - case RtpPacketToSend::Type::kForwardErrorCorrection: + case RtpPacketMediaType::kForwardErrorCorrection: packet->SetSsrc(kFlexFecSsrc); break; } @@ -124,7 +124,7 @@ TEST_P(PacedSenderTest, PacesPackets) { DataRate::Zero()); std::vector> packets; for (size_t i = 0; i < kPacketsToSend; ++i) { - packets.emplace_back(BuildRtpPacket(RtpPacketToSend::Type::kVideo)); + packets.emplace_back(BuildRtpPacket(RtpPacketMediaType::kVideo)); } pacer_->EnqueuePackets(std::move(packets)); diff --git a/modules/pacing/pacing_controller.cc b/modules/pacing/pacing_controller.cc index 1f3849e8e9..86c1b897ba 100644 --- a/modules/pacing/pacing_controller.cc +++ b/modules/pacing/pacing_controller.cc @@ -50,22 +50,22 @@ bool IsEnabled(const WebRtcKeyValueConfig& field_trials, return field_trials.Lookup(key).find("Enabled") == 0; } -int GetPriorityForType(RtpPacketToSend::Type type) { +int GetPriorityForType(RtpPacketMediaType type) { // Lower number takes priority over higher. switch (type) { - case RtpPacketToSend::Type::kAudio: + case RtpPacketMediaType::kAudio: // Audio is always prioritized over other packet types. return kFirstPriority + 1; - case RtpPacketToSend::Type::kRetransmission: + case RtpPacketMediaType::kRetransmission: // Send retransmissions before new media. return kFirstPriority + 2; - case RtpPacketToSend::Type::kVideo: - case RtpPacketToSend::Type::kForwardErrorCorrection: + case RtpPacketMediaType::kVideo: + case RtpPacketMediaType::kForwardErrorCorrection: // Video has "normal" priority, in the old speak. // Send redundancy concurrently to video. If it is delayed it might have a // lower chance of being useful. return kFirstPriority + 3; - case RtpPacketToSend::Type::kPadding: + case RtpPacketMediaType::kPadding: // Packets that are in themselves likely useless, only sent to keep the // BWE high. return kFirstPriority + 4; @@ -530,7 +530,7 @@ void PacingController::ProcessPackets() { RTC_DCHECK(rtp_packet); RTC_DCHECK(rtp_packet->packet_type().has_value()); - const RtpPacketToSend::Type packet_type = *rtp_packet->packet_type(); + const RtpPacketMediaType packet_type = *rtp_packet->packet_type(); DataSize packet_size = DataSize::bytes(rtp_packet->payload_size() + rtp_packet->padding_size()); @@ -643,13 +643,13 @@ std::unique_ptr PacingController::GetPendingPacket( return packet_queue_.Pop(); } -void PacingController::OnPacketSent(RtpPacketToSend::Type packet_type, +void PacingController::OnPacketSent(RtpPacketMediaType packet_type, DataSize packet_size, Timestamp send_time) { if (!first_sent_packet_time_) { first_sent_packet_time_ = send_time; } - bool audio_packet = packet_type == RtpPacketToSend::Type::kAudio; + bool audio_packet = packet_type == RtpPacketMediaType::kAudio; if (!audio_packet || account_for_audio_) { // Update media bytes sent. UpdateBudgetWithSentData(packet_size); diff --git a/modules/pacing/pacing_controller.h b/modules/pacing/pacing_controller.h index c1b3942dfa..4ffcbd3afc 100644 --- a/modules/pacing/pacing_controller.h +++ b/modules/pacing/pacing_controller.h @@ -29,6 +29,7 @@ #include "modules/pacing/round_robin_packet_queue.h" #include "modules/pacing/rtp_packet_pacer.h" #include "modules/rtp_rtcp/include/rtp_packet_sender.h" +#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "modules/rtp_rtcp/source/rtp_packet_to_send.h" #include "rtc_base/critical_section.h" #include "rtc_base/experiments/field_trial_parser.h" @@ -162,7 +163,7 @@ class PacingController { const PacedPacketInfo& pacing_info, Timestamp target_send_time, Timestamp now); - void OnPacketSent(RtpPacketToSend::Type packet_type, + void OnPacketSent(RtpPacketMediaType packet_type, DataSize packet_size, Timestamp send_time); void OnPaddingSent(DataSize padding_sent); diff --git a/modules/pacing/pacing_controller_unittest.cc b/modules/pacing/pacing_controller_unittest.cc index 2e4e564b7e..3f6238201c 100644 --- a/modules/pacing/pacing_controller_unittest.cc +++ b/modules/pacing/pacing_controller_unittest.cc @@ -50,7 +50,7 @@ constexpr uint32_t kFlexFecSsrc = 45678; constexpr DataRate kTargetRate = DataRate::KilobitsPerSec<800>(); -std::unique_ptr BuildPacket(RtpPacketToSend::Type type, +std::unique_ptr BuildPacket(RtpPacketMediaType type, uint32_t ssrc, uint16_t sequence_number, int64_t capture_time_ms, @@ -73,8 +73,8 @@ class MockPacingControllerCallback : public PacingController::PacketSender { const PacedPacketInfo& cluster_info) override { SendPacket(packet->Ssrc(), packet->SequenceNumber(), packet->capture_time_ms(), - packet->packet_type() == RtpPacketToSend::Type::kRetransmission, - packet->packet_type() == RtpPacketToSend::Type::kPadding); + packet->packet_type() == RtpPacketMediaType::kRetransmission, + packet->packet_type() == RtpPacketMediaType::kPadding); } std::vector> GeneratePadding( @@ -84,7 +84,7 @@ class MockPacingControllerCallback : public PacingController::PacketSender { if (padding_size > 0) { auto packet = std::make_unique(nullptr); packet->SetPayloadSize(padding_size); - packet->set_packet_type(RtpPacketToSend::Type::kPadding); + packet->set_packet_type(RtpPacketMediaType::kPadding); ret.emplace_back(std::move(packet)); } return ret; @@ -129,7 +129,7 @@ class PacingControllerPadding : public PacingController::PacketSender { for (size_t i = 0; i < num_packets; ++i) { packets.emplace_back(std::make_unique(nullptr)); packets.back()->SetPadding(kPaddingPacketSize); - packets.back()->set_packet_type(RtpPacketToSend::Type::kPadding); + packets.back()->set_packet_type(RtpPacketMediaType::kPadding); padding_sent_ += kPaddingPacketSize; } return packets; @@ -149,7 +149,7 @@ class PacingControllerProbing : public PacingController::PacketSender { void SendRtpPacket(std::unique_ptr packet, const PacedPacketInfo& pacing_info) override { - if (packet->packet_type() != RtpPacketToSend::Type::kPadding) { + if (packet->packet_type() != RtpPacketMediaType::kPadding) { ++packets_sent_; } } @@ -165,7 +165,7 @@ class PacingControllerProbing : public PacingController::PacketSender { DataSize padding_size = std::min(kMaxPadding, target_size); packets.emplace_back(std::make_unique(nullptr)); packets.back()->SetPadding(padding_size.bytes()); - packets.back()->set_packet_type(RtpPacketToSend::Type::kPadding); + packets.back()->set_packet_type(RtpPacketMediaType::kPadding); padding_sent_ += padding_size.bytes(); target_size -= padding_size; } @@ -208,7 +208,7 @@ class PacingControllerTest clock_.AdvanceTime(TimeUntilNextProcess()); } - void Send(RtpPacketToSend::Type type, + void Send(RtpPacketMediaType type, uint32_t ssrc, uint16_t sequence_number, int64_t capture_time_ms, @@ -217,34 +217,33 @@ class PacingControllerTest BuildPacket(type, ssrc, sequence_number, capture_time_ms, size)); } - void SendAndExpectPacket(RtpPacketToSend::Type type, + void SendAndExpectPacket(RtpPacketMediaType type, uint32_t ssrc, uint16_t sequence_number, int64_t capture_time_ms, size_t size) { Send(type, ssrc, sequence_number, capture_time_ms, size); - EXPECT_CALL( - callback_, - SendPacket(ssrc, sequence_number, capture_time_ms, - type == RtpPacketToSend::Type::kRetransmission, false)) + EXPECT_CALL(callback_, + SendPacket(ssrc, sequence_number, capture_time_ms, + type == RtpPacketMediaType::kRetransmission, false)) .Times(1); } - std::unique_ptr BuildRtpPacket(RtpPacketToSend::Type type) { + std::unique_ptr BuildRtpPacket(RtpPacketMediaType type) { auto packet = std::make_unique(nullptr); packet->set_packet_type(type); switch (type) { - case RtpPacketToSend::Type::kAudio: + case RtpPacketMediaType::kAudio: packet->SetSsrc(kAudioSsrc); break; - case RtpPacketToSend::Type::kVideo: + case RtpPacketMediaType::kVideo: packet->SetSsrc(kVideoSsrc); break; - case RtpPacketToSend::Type::kRetransmission: - case RtpPacketToSend::Type::kPadding: + case RtpPacketMediaType::kRetransmission: + case RtpPacketMediaType::kPadding: packet->SetSsrc(kVideoRtxSsrc); break; - case RtpPacketToSend::Type::kForwardErrorCorrection: + case RtpPacketMediaType::kForwardErrorCorrection: packet->SetSsrc(kFlexFecSsrc); break; } @@ -279,8 +278,8 @@ class PacingControllerTest const size_t packets_to_send_per_interval = kTargetRate.bps() * kPaceMultiplier / (8 * kPacketSize * 200); for (size_t i = 0; i < packets_to_send_per_interval; ++i) { - SendAndExpectPacket(RtpPacketToSend::Type::kVideo, kSsrc, - sequence_number++, capture_time_ms, kPacketSize); + SendAndExpectPacket(RtpPacketMediaType::kVideo, kSsrc, sequence_number++, + capture_time_ms, kPacketSize); } while (pacer_->QueueSizePackets() > 0) { @@ -302,7 +301,7 @@ class PacingControllerFieldTrialTest : public ::testing::TestWithParam { protected: struct MediaStream { - const RtpPacketToSend::Type type; + const RtpPacketMediaType type; const uint32_t ssrc; const size_t packet_size; uint16_t seq_num; @@ -330,9 +329,9 @@ class PacingControllerFieldTrialTest clock_.AdvanceTime(wait_time); pacer->ProcessPackets(); } - MediaStream audio{/*type*/ RtpPacketToSend::Type::kAudio, + MediaStream audio{/*type*/ RtpPacketMediaType::kAudio, /*ssrc*/ 3333, /*packet_size*/ 100, /*seq_num*/ 1000}; - MediaStream video{/*type*/ RtpPacketToSend::Type::kVideo, + MediaStream video{/*type*/ RtpPacketMediaType::kVideo, /*ssrc*/ 4444, /*packet_size*/ 1000, /*seq_num*/ 1000}; SimulatedClock clock_; MockPacingControllerCallback callback_; @@ -472,7 +471,7 @@ TEST_P(PacingControllerTest, FirstSentPacketTimeIsSet) { EXPECT_FALSE(pacer_->FirstSentPacketTime().has_value()); for (size_t i = 0; i < kPacketToSend; ++i) { - SendAndExpectPacket(RtpPacketToSend::Type::kVideo, kSsrc, sequence_number++, + SendAndExpectPacket(RtpPacketMediaType::kVideo, kSsrc, sequence_number++, clock_.TimeInMilliseconds(), kSizeBytes); clock_.AdvanceTime(TimeUntilNextProcess()); pacer_->ProcessPackets(); @@ -494,14 +493,14 @@ TEST_P(PacingControllerTest, QueuePacket) { const size_t kPacketsToSend = kTargetRate.bps() * kPaceMultiplier / (8 * 250 * 200); for (size_t i = 0; i < kPacketsToSend; ++i) { - SendAndExpectPacket(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number++, clock_.TimeInMilliseconds(), 250); } EXPECT_CALL(callback_, SendPadding).Times(0); // Enqueue one extra packet. int64_t queued_packet_timestamp = clock_.TimeInMilliseconds(); - Send(RtpPacketToSend::Type::kVideo, ssrc, sequence_number, + Send(RtpPacketMediaType::kVideo, ssrc, sequence_number, queued_packet_timestamp, 250); EXPECT_EQ(kPacketsToSend + 1, pacer_->QueueSizePackets()); @@ -522,10 +521,10 @@ TEST_P(PacingControllerTest, QueuePacket) { // We can send packets_to_send -1 packets of size 250 during the current // interval since one packet has already been sent. for (size_t i = 0; i < kPacketsToSend - 1; ++i) { - SendAndExpectPacket(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number++, clock_.TimeInMilliseconds(), 250); } - Send(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + Send(RtpPacketMediaType::kVideo, ssrc, sequence_number++, clock_.TimeInMilliseconds(), 250); EXPECT_EQ(kPacketsToSend, pacer_->QueueSizePackets()); pacer_->ProcessPackets(); @@ -549,14 +548,14 @@ TEST_P(PacingControllerTest, QueueAndPacePackets) { kPaceMultiplier / kPackeSize.bytes(); for (size_t i = 0; i < kPacketsToSend; ++i) { - SendAndExpectPacket(RtpPacketToSend::Type::kVideo, kSsrc, sequence_number++, + SendAndExpectPacket(RtpPacketMediaType::kVideo, kSsrc, sequence_number++, clock_.TimeInMilliseconds(), kPackeSize.bytes()); } EXPECT_CALL(callback_, SendPadding).Times(0); // Enqueue one extra packet. int64_t queued_packet_timestamp = clock_.TimeInMilliseconds(); - Send(RtpPacketToSend::Type::kVideo, kSsrc, sequence_number, + Send(RtpPacketMediaType::kVideo, kSsrc, sequence_number, queued_packet_timestamp, kPackeSize.bytes()); EXPECT_EQ(kPacketsToSend + 1, pacer_->QueueSizePackets()); @@ -587,12 +586,12 @@ TEST_P(PacingControllerTest, PaceQueuedPackets) { const size_t packets_to_send_per_interval = kTargetRate.bps() * kPaceMultiplier / (8 * kPacketSize * 200); for (size_t i = 0; i < packets_to_send_per_interval; ++i) { - SendAndExpectPacket(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number++, clock_.TimeInMilliseconds(), kPacketSize); } for (size_t j = 0; j < packets_to_send_per_interval * 10; ++j) { - Send(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + Send(RtpPacketMediaType::kVideo, ssrc, sequence_number++, clock_.TimeInMilliseconds(), kPacketSize); } EXPECT_EQ(packets_to_send_per_interval + packets_to_send_per_interval * 10, @@ -633,7 +632,7 @@ TEST_P(PacingControllerTest, PaceQueuedPackets) { // Send some more packet, just show that we can..? for (size_t i = 0; i < packets_to_send_per_interval; ++i) { - SendAndExpectPacket(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number++, clock_.TimeInMilliseconds(), 250); } EXPECT_EQ(packets_to_send_per_interval, pacer_->QueueSizePackets()); @@ -654,10 +653,10 @@ TEST_P(PacingControllerTest, RepeatedRetransmissionsAllowed) { constexpr uint16_t sequence_number = 444; constexpr size_t bytes = 250; bool is_retransmission = (i != 0); // Original followed by retransmissions. - SendAndExpectPacket( - is_retransmission ? RtpPacketToSend::Type::kRetransmission - : RtpPacketToSend::Type::kVideo, - ssrc, sequence_number, clock_.TimeInMilliseconds(), bytes); + SendAndExpectPacket(is_retransmission ? RtpPacketMediaType::kRetransmission + : RtpPacketMediaType::kVideo, + ssrc, sequence_number, clock_.TimeInMilliseconds(), + bytes); clock_.AdvanceTimeMilliseconds(5); } if (PeriodicProcess()) { @@ -674,11 +673,11 @@ TEST_P(PacingControllerTest, uint32_t ssrc = 12345; uint16_t sequence_number = 1234; - SendAndExpectPacket(RtpPacketToSend::Type::kVideo, ssrc, sequence_number, + SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number, clock_.TimeInMilliseconds(), 250); // Expect packet on second ssrc to be queued and sent as well. - SendAndExpectPacket(RtpPacketToSend::Type::kVideo, ssrc + 1, sequence_number, + SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc + 1, sequence_number, clock_.TimeInMilliseconds(), 250); clock_.AdvanceTimeMilliseconds(1000); @@ -715,9 +714,8 @@ TEST_P(PacingControllerTest, Padding) { } else { const size_t kPacketsToSend = 20; for (size_t i = 0; i < kPacketsToSend; ++i) { - SendAndExpectPacket(RtpPacketToSend::Type::kVideo, ssrc, - sequence_number++, clock_.TimeInMilliseconds(), - kPacketSize); + SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number++, + clock_.TimeInMilliseconds(), kPacketSize); } const TimeDelta expected_pace_time = DataSize::bytes(pacer_->QueueSizePackets() * kPacketSize) / @@ -794,7 +792,7 @@ TEST_P(PacingControllerTest, NoPaddingBeforeNormalPacket) { uint16_t sequence_number = 1234; int64_t capture_time_ms = 56789; - SendAndExpectPacket(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number++, capture_time_ms, 250); bool padding_sent = false; EXPECT_CALL(callback_, SendPadding).WillOnce([&](size_t padding) { @@ -826,7 +824,7 @@ TEST_P(PacingControllerTest, VerifyPaddingUpToBitrate) { int64_t start_time = clock_.TimeInMilliseconds(); while (clock_.TimeInMilliseconds() - start_time < kBitrateWindow) { - SendAndExpectPacket(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number++, capture_time_ms, 250); EXPECT_CALL(callback_, SendPadding(250)).WillOnce(Return(250)); EXPECT_CALL(callback_, SendPacket(_, _, _, _, true)).Times(1); @@ -856,8 +854,8 @@ TEST_P(PacingControllerTest, VerifyAverageBitrateVaryingMediaPayload) { media_bytes < (kTargetRate * (clock_.CurrentTime() - start_time)).bytes()) { size_t media_payload = rand_value % 400 + 800; // [400, 1200] bytes. - Send(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, - capture_time_ms, media_payload); + Send(RtpPacketMediaType::kVideo, ssrc, sequence_number++, capture_time_ms, + media_payload); media_bytes += media_payload; } @@ -886,16 +884,16 @@ TEST_P(PacingControllerTest, Priority) { ConsumeInitialBudget(); // Expect normal and low priority to be queued and high to pass through. - Send(RtpPacketToSend::Type::kVideo, ssrc_low_priority, sequence_number++, + Send(RtpPacketMediaType::kVideo, ssrc_low_priority, sequence_number++, capture_time_ms_low_priority, 250); const size_t packets_to_send_per_interval = kTargetRate.bps() * kPaceMultiplier / (8 * 250 * 200); for (size_t i = 0; i < packets_to_send_per_interval; ++i) { - Send(RtpPacketToSend::Type::kRetransmission, ssrc, sequence_number++, + Send(RtpPacketMediaType::kRetransmission, ssrc, sequence_number++, capture_time_ms, 250); } - Send(RtpPacketToSend::Type::kAudio, ssrc, sequence_number++, capture_time_ms, + Send(RtpPacketMediaType::kAudio, ssrc, sequence_number++, capture_time_ms, 250); // Expect all high and normal priority to be sent out first. @@ -941,9 +939,9 @@ TEST_P(PacingControllerTest, RetransmissionPriority) { // Alternate retransmissions and normal packets. for (size_t i = 0; i < packets_to_send_per_interval; ++i) { - Send(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, - capture_time_ms, 250); - Send(RtpPacketToSend::Type::kRetransmission, ssrc, sequence_number++, + Send(RtpPacketMediaType::kVideo, ssrc, sequence_number++, capture_time_ms, + 250); + Send(RtpPacketMediaType::kRetransmission, ssrc, sequence_number++, capture_time_ms_retransmission, 250); } EXPECT_EQ(2 * packets_to_send_per_interval, pacer_->QueueSizePackets()); @@ -994,7 +992,7 @@ TEST_P(PacingControllerTest, HighPrioDoesntAffectBudget) { // a high number of them at once. const size_t kNumAudioPackets = 25; for (size_t i = 0; i < kNumAudioPackets; ++i) { - SendAndExpectPacket(RtpPacketToSend::Type::kAudio, ssrc, sequence_number++, + SendAndExpectPacket(RtpPacketMediaType::kAudio, ssrc, sequence_number++, capture_time_ms, kPacketSize); } pacer_->ProcessPackets(); @@ -1005,7 +1003,7 @@ TEST_P(PacingControllerTest, HighPrioDoesntAffectBudget) { const size_t kPacketsToSendPerInterval = kTargetRate.bps() * kPaceMultiplier / (8 * kPacketSize * 200); for (size_t i = 0; i < kPacketsToSendPerInterval; ++i) { - SendAndExpectPacket(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number++, clock_.TimeInMilliseconds(), kPacketSize); } @@ -1041,7 +1039,7 @@ TEST_P(PacingControllerTest, SendsOnlyPaddingWhenCongested) { int sent_data = 0; while (sent_data < kCongestionWindow) { sent_data += kPacketSize; - SendAndExpectPacket(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number++, clock_.TimeInMilliseconds(), kPacketSize); AdvanceTimeAndProcess(); } @@ -1052,7 +1050,7 @@ TEST_P(PacingControllerTest, SendsOnlyPaddingWhenCongested) { size_t blocked_packets = 0; int64_t expected_time_until_padding = 500; while (expected_time_until_padding > 5) { - Send(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + Send(RtpPacketMediaType::kVideo, ssrc, sequence_number++, clock_.TimeInMilliseconds(), kPacketSize); blocked_packets++; clock_.AdvanceTimeMilliseconds(5); @@ -1080,28 +1078,28 @@ TEST_P(PacingControllerTest, DoesNotAllowOveruseAfterCongestion) { pacer_->SetCongestionWindow(DataSize::bytes(800)); pacer_->UpdateOutstandingData(DataSize::Zero()); // Not yet budget limited or congested, packet is sent. - Send(RtpPacketToSend::Type::kVideo, ssrc, seq_num++, now_ms(), size); + Send(RtpPacketMediaType::kVideo, ssrc, seq_num++, now_ms(), size); EXPECT_CALL(callback_, SendPacket).Times(1); clock_.AdvanceTimeMilliseconds(5); pacer_->ProcessPackets(); // Packet blocked due to congestion. - Send(RtpPacketToSend::Type::kVideo, ssrc, seq_num++, now_ms(), size); + Send(RtpPacketMediaType::kVideo, ssrc, seq_num++, now_ms(), size); EXPECT_CALL(callback_, SendPacket).Times(0); clock_.AdvanceTimeMilliseconds(5); pacer_->ProcessPackets(); // Packet blocked due to congestion. - Send(RtpPacketToSend::Type::kVideo, ssrc, seq_num++, now_ms(), size); + Send(RtpPacketMediaType::kVideo, ssrc, seq_num++, now_ms(), size); EXPECT_CALL(callback_, SendPacket).Times(0); clock_.AdvanceTimeMilliseconds(5); pacer_->ProcessPackets(); // Congestion removed and budget has recovered, packet is sent. - Send(RtpPacketToSend::Type::kVideo, ssrc, seq_num++, now_ms(), size); + Send(RtpPacketMediaType::kVideo, ssrc, seq_num++, now_ms(), size); EXPECT_CALL(callback_, SendPacket).Times(1); clock_.AdvanceTimeMilliseconds(5); pacer_->UpdateOutstandingData(DataSize::Zero()); pacer_->ProcessPackets(); // Should be blocked due to budget limitation as congestion has be removed. - Send(RtpPacketToSend::Type::kVideo, ssrc, seq_num++, now_ms(), size); + Send(RtpPacketMediaType::kVideo, ssrc, seq_num++, now_ms(), size); EXPECT_CALL(callback_, SendPacket).Times(0); clock_.AdvanceTimeMilliseconds(5); pacer_->ProcessPackets(); @@ -1120,7 +1118,7 @@ TEST_P(PacingControllerTest, ResumesSendingWhenCongestionEnds) { int sent_data = 0; while (sent_data < kCongestionWindow) { sent_data += kPacketSize; - SendAndExpectPacket(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number++, clock_.TimeInMilliseconds(), kPacketSize); clock_.AdvanceTimeMilliseconds(5); pacer_->ProcessPackets(); @@ -1129,7 +1127,7 @@ TEST_P(PacingControllerTest, ResumesSendingWhenCongestionEnds) { EXPECT_CALL(callback_, SendPacket).Times(0); int unacked_packets = 0; for (int duration = 0; duration < kCongestionTimeMs; duration += 5) { - Send(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + Send(RtpPacketMediaType::kVideo, ssrc, sequence_number++, clock_.TimeInMilliseconds(), kPacketSize); unacked_packets++; clock_.AdvanceTimeMilliseconds(5); @@ -1178,21 +1176,21 @@ TEST_P(PacingControllerTest, Pause) { const size_t packets_to_send_per_interval = kTargetRate.bps() * kPaceMultiplier / (8 * 250 * 200); for (size_t i = 0; i < packets_to_send_per_interval; ++i) { - Send(RtpPacketToSend::Type::kVideo, ssrc_low_priority, sequence_number++, + Send(RtpPacketMediaType::kVideo, ssrc_low_priority, sequence_number++, capture_time_ms, 250); - Send(RtpPacketToSend::Type::kRetransmission, ssrc, sequence_number++, + Send(RtpPacketMediaType::kRetransmission, ssrc, sequence_number++, capture_time_ms, 250); - Send(RtpPacketToSend::Type::kAudio, ssrc_high_priority, sequence_number++, + Send(RtpPacketMediaType::kAudio, ssrc_high_priority, sequence_number++, capture_time_ms, 250); } clock_.AdvanceTimeMilliseconds(10000); int64_t second_capture_time_ms = clock_.TimeInMilliseconds(); for (size_t i = 0; i < packets_to_send_per_interval; ++i) { - Send(RtpPacketToSend::Type::kVideo, ssrc_low_priority, sequence_number++, + Send(RtpPacketMediaType::kVideo, ssrc_low_priority, sequence_number++, second_capture_time_ms, 250); - Send(RtpPacketToSend::Type::kRetransmission, ssrc, sequence_number++, + Send(RtpPacketMediaType::kRetransmission, ssrc, sequence_number++, second_capture_time_ms, 250); - Send(RtpPacketToSend::Type::kAudio, ssrc_high_priority, sequence_number++, + Send(RtpPacketMediaType::kAudio, ssrc_high_priority, sequence_number++, second_capture_time_ms, 250); } @@ -1329,7 +1327,7 @@ TEST_P(PacingControllerTest, ExpectedQueueTimeMs) { pacer_->SetPacingRates(DataRate::bps(30000 * kPaceMultiplier), DataRate::Zero()); for (size_t i = 0; i < kNumPackets; ++i) { - SendAndExpectPacket(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number++, clock_.TimeInMilliseconds(), kPacketSize); } @@ -1361,7 +1359,7 @@ TEST_P(PacingControllerTest, QueueTimeGrowsOverTime) { pacer_->SetPacingRates(DataRate::bps(30000 * kPaceMultiplier), DataRate::Zero()); - SendAndExpectPacket(RtpPacketToSend::Type::kVideo, ssrc, sequence_number, + SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number, clock_.TimeInMilliseconds(), 1200); clock_.AdvanceTimeMilliseconds(500); @@ -1387,7 +1385,7 @@ TEST_P(PacingControllerTest, ProbingWithInsertedPackets) { DataRate::Zero()); for (int i = 0; i < 10; ++i) { - Send(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + Send(RtpPacketMediaType::kVideo, ssrc, sequence_number++, clock_.TimeInMilliseconds(), kPacketSize); } @@ -1430,7 +1428,7 @@ TEST_P(PacingControllerTest, SkipsProbesWhenProcessIntervalTooLarge) { DataRate::Zero()); for (int i = 0; i < 10; ++i) { - Send(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + Send(RtpPacketMediaType::kVideo, ssrc, sequence_number++, clock_.TimeInMilliseconds(), kPacketSize); } while (pacer_->QueueSizePackets() > 0) { @@ -1442,7 +1440,7 @@ TEST_P(PacingControllerTest, SkipsProbesWhenProcessIntervalTooLarge) { pacer_->CreateProbeCluster(DataRate::kbps(10000), // 10 Mbps. /*cluster_id=*/3); // We need one packet to start the probe. - Send(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + Send(RtpPacketMediaType::kVideo, ssrc, sequence_number++, clock_.TimeInMilliseconds(), kPacketSize); const int packets_sent_before_probe = packet_sender.packets_sent(); clock_.AdvanceTime(TimeUntilNextProcess()); @@ -1457,7 +1455,7 @@ TEST_P(PacingControllerTest, SkipsProbesWhenProcessIntervalTooLarge) { clock_.AdvanceTime(time_between_probes); // Send second probe packet. - Send(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + Send(RtpPacketMediaType::kVideo, ssrc, sequence_number++, clock_.TimeInMilliseconds(), kPacketSize); pacer_->ProcessPackets(); EXPECT_EQ(packet_sender.packets_sent(), packets_sent_before_probe + 2); @@ -1493,7 +1491,7 @@ TEST_P(PacingControllerTest, ProbingWithPaddingSupport) { DataRate::Zero()); for (int i = 0; i < 3; ++i) { - Send(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + Send(RtpPacketMediaType::kVideo, ssrc, sequence_number++, clock_.TimeInMilliseconds(), kPacketSize); } @@ -1525,7 +1523,7 @@ TEST_P(PacingControllerTest, PaddingOveruse) { pacer_->SetPacingRates(DataRate::bps(60000 * kPaceMultiplier), DataRate::Zero()); - SendAndExpectPacket(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number++, clock_.TimeInMilliseconds(), kPacketSize); pacer_->ProcessPackets(); @@ -1535,7 +1533,7 @@ TEST_P(PacingControllerTest, PaddingOveruse) { pacer_->SetPacingRates(DataRate::bps(60000 * kPaceMultiplier), DataRate::bps(30000)); - SendAndExpectPacket(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number++, clock_.TimeInMilliseconds(), kPacketSize); EXPECT_LT(TimeDelta::ms(5), pacer_->ExpectedQueueTime()); // Don't send padding if queue is non-empty, even if padding budget > 0. @@ -1561,7 +1559,7 @@ TEST_P(PacingControllerTest, ProbeClusterId) { pacer_->SetPacingRates(kTargetRate * kPaceMultiplier, kTargetRate); pacer_->SetProbingEnabled(true); for (int i = 0; i < 10; ++i) { - Send(RtpPacketToSend::Type::kVideo, ssrc, sequence_number++, + Send(RtpPacketMediaType::kVideo, ssrc, sequence_number++, clock_.TimeInMilliseconds(), kPacketSize); } @@ -1589,7 +1587,7 @@ TEST_P(PacingControllerTest, ProbeClusterId) { EXPECT_CALL(callback, GeneratePadding).WillOnce([&](DataSize padding_size) { std::vector> padding_packets; padding_packets.emplace_back( - BuildPacket(RtpPacketToSend::Type::kPadding, ssrc, sequence_number++, + BuildPacket(RtpPacketMediaType::kPadding, ssrc, sequence_number++, clock_.TimeInMilliseconds(), padding_size.bytes())); return padding_packets; }); @@ -1614,11 +1612,10 @@ TEST_P(PacingControllerTest, OwnedPacketPrioritizedOnType) { // Insert a packet of each type, from low to high priority. Since priority // is weighted higher than insert order, these should come out of the pacer // in backwards order with the exception of FEC and Video. - for (RtpPacketToSend::Type type : - {RtpPacketToSend::Type::kPadding, - RtpPacketToSend::Type::kForwardErrorCorrection, - RtpPacketToSend::Type::kVideo, RtpPacketToSend::Type::kRetransmission, - RtpPacketToSend::Type::kAudio}) { + for (RtpPacketMediaType type : + {RtpPacketMediaType::kPadding, + RtpPacketMediaType::kForwardErrorCorrection, RtpPacketMediaType::kVideo, + RtpPacketMediaType::kRetransmission, RtpPacketMediaType::kAudio}) { pacer_->EnqueuePacket(BuildRtpPacket(type)); } @@ -1662,14 +1659,14 @@ TEST_P(PacingControllerTest, SmallFirstProbePacket) { pacer_->SetPacingRates(kTargetRate * kPaceMultiplier, DataRate::Zero()); // Add high prio media. - pacer_->EnqueuePacket(BuildRtpPacket(RtpPacketToSend::Type::kAudio)); + pacer_->EnqueuePacket(BuildRtpPacket(RtpPacketMediaType::kAudio)); // Expect small padding packet to be requested. EXPECT_CALL(callback, GeneratePadding(DataSize::bytes(1))) .WillOnce([&](DataSize padding_size) { std::vector> padding_packets; padding_packets.emplace_back( - BuildPacket(RtpPacketToSend::Type::kPadding, kAudioSsrc, 1, + BuildPacket(RtpPacketMediaType::kPadding, kAudioSsrc, 1, clock_.TimeInMilliseconds(), 1)); return padding_packets; }); @@ -1681,9 +1678,9 @@ TEST_P(PacingControllerTest, SmallFirstProbePacket) { .WillRepeatedly([&](std::unique_ptr packet, const PacedPacketInfo& cluster_info) { if (packets_sent == 0) { - EXPECT_EQ(packet->packet_type(), RtpPacketToSend::Type::kPadding); + EXPECT_EQ(packet->packet_type(), RtpPacketMediaType::kPadding); } else { - if (packet->packet_type() == RtpPacketToSend::Type::kAudio) { + if (packet->packet_type() == RtpPacketMediaType::kAudio) { media_seen = true; } } @@ -1706,10 +1703,10 @@ TEST_P(PacingControllerTest, TaskLate) { pacer_->SetPacingRates(kSendRate, DataRate::Zero()); // Add four packets of equal size and priority. - pacer_->EnqueuePacket(BuildRtpPacket(RtpPacketToSend::Type::kVideo)); - pacer_->EnqueuePacket(BuildRtpPacket(RtpPacketToSend::Type::kVideo)); - pacer_->EnqueuePacket(BuildRtpPacket(RtpPacketToSend::Type::kVideo)); - pacer_->EnqueuePacket(BuildRtpPacket(RtpPacketToSend::Type::kVideo)); + pacer_->EnqueuePacket(BuildRtpPacket(RtpPacketMediaType::kVideo)); + pacer_->EnqueuePacket(BuildRtpPacket(RtpPacketMediaType::kVideo)); + pacer_->EnqueuePacket(BuildRtpPacket(RtpPacketMediaType::kVideo)); + pacer_->EnqueuePacket(BuildRtpPacket(RtpPacketMediaType::kVideo)); // Process packets, only first should be sent. EXPECT_CALL(callback_, SendPacket).Times(1); @@ -1744,7 +1741,7 @@ TEST_P(PacingControllerTest, NoProbingWhilePaused) { pacer_->SetProbingEnabled(true); // Send at least one packet so probing can initate. - SendAndExpectPacket(RtpPacketToSend::Type::kVideo, ssrc, sequence_number, + SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number, clock_.TimeInMilliseconds(), 250); while (pacer_->QueueSizePackets() > 0) { AdvanceTimeAndProcess(); diff --git a/modules/pacing/round_robin_packet_queue.cc b/modules/pacing/round_robin_packet_queue.cc index 7c2a7d2ae8..ace9d7643d 100644 --- a/modules/pacing/round_robin_packet_queue.cc +++ b/modules/pacing/round_robin_packet_queue.cc @@ -35,7 +35,7 @@ RoundRobinPacketQueue::QueuedPacket::QueuedPacket( enqueue_time_(enqueue_time), enqueue_order_(enqueue_order), is_retransmission_(packet->packet_type() == - RtpPacketToSend::Type::kRetransmission), + RtpPacketMediaType::kRetransmission), enqueue_time_it_(enqueue_time_it), owned_packet_(packet.release()) {} @@ -53,7 +53,7 @@ int RoundRobinPacketQueue::QueuedPacket::Priority() const { return priority_; } -RtpPacketToSend::Type RoundRobinPacketQueue::QueuedPacket::Type() const { +RtpPacketMediaType RoundRobinPacketQueue::QueuedPacket::Type() const { return *owned_packet_->packet_type(); } @@ -66,7 +66,7 @@ Timestamp RoundRobinPacketQueue::QueuedPacket::EnqueueTime() const { } bool RoundRobinPacketQueue::QueuedPacket::IsRetransmission() const { - return Type() == RtpPacketToSend::Type::kRetransmission; + return Type() == RtpPacketMediaType::kRetransmission; } uint64_t RoundRobinPacketQueue::QueuedPacket::EnqueueOrder() const { @@ -215,7 +215,7 @@ bool RoundRobinPacketQueue::NextPacketIsAudio() const { auto stream_info_it = streams_.find(ssrc); return stream_info_it->second.packet_queue.top().Type() == - RtpPacketToSend::Type::kAudio; + RtpPacketMediaType::kAudio; } Timestamp RoundRobinPacketQueue::OldestEnqueueTime() const { diff --git a/modules/pacing/round_robin_packet_queue.h b/modules/pacing/round_robin_packet_queue.h index 225e137753..c256679f7b 100644 --- a/modules/pacing/round_robin_packet_queue.h +++ b/modules/pacing/round_robin_packet_queue.h @@ -69,7 +69,7 @@ class RoundRobinPacketQueue { bool operator<(const QueuedPacket& other) const; int Priority() const; - RtpPacketToSend::Type Type() const; + RtpPacketMediaType Type() const; uint32_t Ssrc() const; Timestamp EnqueueTime() const; bool IsRetransmission() const; diff --git a/modules/pacing/task_queue_paced_sender_unittest.cc b/modules/pacing/task_queue_paced_sender_unittest.cc index 0c3a092400..0633d8dc2e 100644 --- a/modules/pacing/task_queue_paced_sender_unittest.cc +++ b/modules/pacing/task_queue_paced_sender_unittest.cc @@ -59,21 +59,21 @@ class TaskQueuePacedSenderTest : public ::testing::Test { time_controller_.GetTaskQueueFactory()) {} protected: - std::unique_ptr BuildRtpPacket(RtpPacketToSend::Type type) { + std::unique_ptr BuildRtpPacket(RtpPacketMediaType type) { auto packet = std::make_unique(nullptr); packet->set_packet_type(type); switch (type) { - case RtpPacketToSend::Type::kAudio: + case RtpPacketMediaType::kAudio: packet->SetSsrc(kAudioSsrc); break; - case RtpPacketToSend::Type::kVideo: + case RtpPacketMediaType::kVideo: packet->SetSsrc(kVideoSsrc); break; - case RtpPacketToSend::Type::kRetransmission: - case RtpPacketToSend::Type::kPadding: + case RtpPacketMediaType::kRetransmission: + case RtpPacketMediaType::kPadding: packet->SetSsrc(kVideoRtxSsrc); break; - case RtpPacketToSend::Type::kForwardErrorCorrection: + case RtpPacketMediaType::kForwardErrorCorrection: packet->SetSsrc(kFlexFecSsrc); break; } @@ -83,7 +83,7 @@ class TaskQueuePacedSenderTest : public ::testing::Test { } std::vector> GeneratePackets( - RtpPacketToSend::Type type, + RtpPacketMediaType type, size_t num_packets) { std::vector> packets; for (size_t i = 0; i < num_packets; ++i) { @@ -105,7 +105,7 @@ TEST_F(TaskQueuePacedSenderTest, PacesPackets) { pacer_.SetPacingRates(DataRate::bps(kDefaultPacketSize * 8 * kPacketsToSend), DataRate::Zero()); pacer_.EnqueuePackets( - GeneratePackets(RtpPacketToSend::Type::kVideo, kPacketsToSend)); + GeneratePackets(RtpPacketMediaType::kVideo, kPacketsToSend)); // Expect all of them to be sent. size_t packets_sent = 0; @@ -139,7 +139,7 @@ TEST_F(TaskQueuePacedSenderTest, ReschedulesProcessOnRateChange) { // Send some initial packets to be rid of any probes. EXPECT_CALL(packet_router_, SendPacket).Times(kPacketsPerSecond); pacer_.EnqueuePackets( - GeneratePackets(RtpPacketToSend::Type::kVideo, kPacketsPerSecond)); + GeneratePackets(RtpPacketMediaType::kVideo, kPacketsPerSecond)); time_controller_.AdvanceTime(TimeDelta::seconds(1)); // Insert three packets, and record send time of each of them. @@ -163,7 +163,7 @@ TEST_F(TaskQueuePacedSenderTest, ReschedulesProcessOnRateChange) { } }); - pacer_.EnqueuePackets(GeneratePackets(RtpPacketToSend::Type::kVideo, 3)); + pacer_.EnqueuePackets(GeneratePackets(RtpPacketMediaType::kVideo, 3)); time_controller_.AdvanceTime(TimeDelta::ms(500)); ASSERT_TRUE(third_packet_time.IsFinite()); EXPECT_NEAR((second_packet_time - first_packet_time).ms(), 200.0, diff --git a/modules/rtp_rtcp/include/rtp_rtcp_defines.h b/modules/rtp_rtcp/include/rtp_rtcp_defines.h index 8cd402e227..25a9d29077 100644 --- a/modules/rtp_rtcp/include/rtp_rtcp_defines.h +++ b/modules/rtp_rtcp/include/rtp_rtcp_defines.h @@ -212,6 +212,14 @@ class RtcpBandwidthObserver { virtual ~RtcpBandwidthObserver() {} }; +enum class RtpPacketMediaType { + kAudio, // Audio media packets. + kVideo, // Video media packets. + kRetransmission, // RTX (usually) packets send as response to NACK. + kForwardErrorCorrection, // FEC packets. + kPadding // RTX or plain padding sent to maintain BWE. +}; + struct RtpPacketSendInfo { public: RtpPacketSendInfo() = default; @@ -222,8 +230,10 @@ struct RtpPacketSendInfo { // Get rid of this flag when all code paths populate |rtp_sequence_number|. bool has_rtp_sequence_number = false; size_t length = 0; + absl::optional packet_type; PacedPacketInfo pacing_info; }; + class NetworkStateEstimateObserver { public: virtual void OnRemoteNetworkEstimate(NetworkStateEstimate estimate) = 0; diff --git a/modules/rtp_rtcp/source/flexfec_sender.cc b/modules/rtp_rtcp/source/flexfec_sender.cc index 70f1666647..de0d4129ce 100644 --- a/modules/rtp_rtcp/source/flexfec_sender.cc +++ b/modules/rtp_rtcp/source/flexfec_sender.cc @@ -128,7 +128,7 @@ std::vector> FlexfecSender::GetFecPackets() { std::unique_ptr fec_packet_to_send( new RtpPacketToSend(&rtp_header_extension_map_)); fec_packet_to_send->set_packet_type( - RtpPacketToSend::Type::kForwardErrorCorrection); + RtpPacketMediaType::kForwardErrorCorrection); // RTP header. fec_packet_to_send->SetMarker(false); diff --git a/modules/rtp_rtcp/source/rtp_packet_to_send.h b/modules/rtp_rtcp/source/rtp_packet_to_send.h index 07e6ea8588..d30bbbf3ad 100644 --- a/modules/rtp_rtcp/source/rtp_packet_to_send.h +++ b/modules/rtp_rtcp/source/rtp_packet_to_send.h @@ -18,6 +18,7 @@ #include "absl/types/optional.h" #include "api/array_view.h" #include "api/video/video_timing.h" +#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "modules/rtp_rtcp/source/rtp_header_extensions.h" #include "modules/rtp_rtcp/source/rtp_packet.h" @@ -25,13 +26,8 @@ namespace webrtc { // Class to hold rtp packet with metadata for sender side. class RtpPacketToSend : public RtpPacket { public: - enum class Type { - kAudio, // Audio media packets. - kVideo, // Video media packets. - kRetransmission, // RTX (usually) packets send as response to NACK. - kForwardErrorCorrection, // FEC packets. - kPadding // RTX or plain padding sent to maintain BWE. - }; + // RtpPacketToSend::Type is deprecated. Use RtpPacketMediaType directly. + using Type = RtpPacketMediaType; explicit RtpPacketToSend(const ExtensionManager* extensions); RtpPacketToSend(const ExtensionManager* extensions, size_t capacity); @@ -48,8 +44,10 @@ class RtpPacketToSend : public RtpPacket { void set_capture_time_ms(int64_t time) { capture_time_ms_ = time; } - void set_packet_type(Type type) { packet_type_ = type; } - absl::optional packet_type() const { return packet_type_; } + void set_packet_type(RtpPacketMediaType type) { packet_type_ = type; } + absl::optional packet_type() const { + return packet_type_; + } // If this is a retransmission, indicates the sequence number of the original // media packet that this packet represents. If RTX is used this will likely @@ -102,7 +100,7 @@ class RtpPacketToSend : public RtpPacket { private: int64_t capture_time_ms_ = 0; - absl::optional packet_type_; + absl::optional packet_type_; bool allow_retransmission_ = false; absl::optional retransmitted_sequence_number_; std::vector application_data_; diff --git a/modules/rtp_rtcp/source/rtp_sender.cc b/modules/rtp_rtcp/source/rtp_sender.cc index c993e47c2e..3277c67314 100644 --- a/modules/rtp_rtcp/source/rtp_sender.cc +++ b/modules/rtp_rtcp/source/rtp_sender.cc @@ -266,7 +266,7 @@ int32_t RTPSender::ReSendPacket(uint16_t packet_id) { if (!packet) { return -1; } - packet->set_packet_type(RtpPacketToSend::Type::kRetransmission); + packet->set_packet_type(RtpPacketMediaType::kRetransmission); std::vector> packets; packets.emplace_back(std::move(packet)); paced_sender_->EnqueuePackets(std::move(packets)); @@ -334,7 +334,7 @@ std::vector> RTPSender::GeneratePadding( } bytes_left -= std::min(bytes_left, packet->payload_size()); - packet->set_packet_type(RtpPacketToSend::Type::kPadding); + packet->set_packet_type(RtpPacketMediaType::kPadding); padding_packets.push_back(std::move(packet)); } } @@ -362,7 +362,7 @@ std::vector> RTPSender::GeneratePadding( while (bytes_left > 0) { auto padding_packet = std::make_unique(&rtp_header_extension_map_); - padding_packet->set_packet_type(RtpPacketToSend::Type::kPadding); + padding_packet->set_packet_type(RtpPacketMediaType::kPadding); padding_packet->SetMarker(false); padding_packet->SetTimestamp(last_rtp_timestamp_); padding_packet->set_capture_time_ms(capture_time_ms_); diff --git a/modules/rtp_rtcp/source/rtp_sender_audio.cc b/modules/rtp_rtcp/source/rtp_sender_audio.cc index 4a47d33573..c8d83db297 100644 --- a/modules/rtp_rtcp/source/rtp_sender_audio.cc +++ b/modules/rtp_rtcp/source/rtp_sender_audio.cc @@ -302,7 +302,7 @@ bool RTPSenderAudio::SendAudio(AudioFrameType frame_type, TRACE_EVENT_ASYNC_END2("webrtc", "Audio", rtp_timestamp, "timestamp", packet->Timestamp(), "seqnum", packet->SequenceNumber()); - packet->set_packet_type(RtpPacketToSend::Type::kAudio); + packet->set_packet_type(RtpPacketMediaType::kAudio); packet->set_allow_retransmission(true); bool send_result = rtp_sender_->SendToNetwork(std::move(packet)); if (first_packet_sent_()) { @@ -387,7 +387,7 @@ bool RTPSenderAudio::SendTelephoneEventPacket(bool ended, dtmfbuffer[1] = E | R | volume; ByteWriter::WriteBigEndian(dtmfbuffer + 2, duration); - packet->set_packet_type(RtpPacketToSend::Type::kAudio); + packet->set_packet_type(RtpPacketMediaType::kAudio); packet->set_allow_retransmission(true); result = rtp_sender_->SendToNetwork(std::move(packet)); send_count--; diff --git a/modules/rtp_rtcp/source/rtp_sender_egress.cc b/modules/rtp_rtcp/source/rtp_sender_egress.cc index 2244927291..dc888f9881 100644 --- a/modules/rtp_rtcp/source/rtp_sender_egress.cc +++ b/modules/rtp_rtcp/source/rtp_sender_egress.cc @@ -140,9 +140,8 @@ void RtpSenderEgress::SendPacket(RtpPacketToSend* packet, } } - const bool is_media = - packet->packet_type() == RtpPacketToSend::Type::kAudio || - packet->packet_type() == RtpPacketToSend::Type::kVideo; + const bool is_media = packet->packet_type() == RtpPacketMediaType::kAudio || + packet->packet_type() == RtpPacketMediaType::kVideo; // Downstream code actually uses this flag to distinguish between media and // everything else. @@ -157,8 +156,8 @@ void RtpSenderEgress::SendPacket(RtpPacketToSend* packet, options.application_data.assign(packet->application_data().begin(), packet->application_data().end()); - if (packet->packet_type() != RtpPacketToSend::Type::kPadding && - packet->packet_type() != RtpPacketToSend::Type::kRetransmission) { + if (packet->packet_type() != RtpPacketMediaType::kPadding && + packet->packet_type() != RtpPacketMediaType::kRetransmission) { UpdateDelayStatistics(packet->capture_time_ms(), now_ms, packet_ssrc); UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(), packet_ssrc); @@ -229,15 +228,15 @@ void RtpSenderEgress::SetMediaHasBeenSent(bool media_sent) { bool RtpSenderEgress::HasCorrectSsrc(const RtpPacketToSend& packet) const { switch (*packet.packet_type()) { - case RtpPacketToSend::Type::kAudio: - case RtpPacketToSend::Type::kVideo: + case RtpPacketMediaType::kAudio: + case RtpPacketMediaType::kVideo: return packet.Ssrc() == ssrc_; - case RtpPacketToSend::Type::kRetransmission: - case RtpPacketToSend::Type::kPadding: + case RtpPacketMediaType::kRetransmission: + case RtpPacketMediaType::kPadding: // Both padding and retransmission must be on either the media or the // RTX stream. return packet.Ssrc() == rtx_ssrc_ || packet.Ssrc() == ssrc_; - case RtpPacketToSend::Type::kForwardErrorCorrection: + case RtpPacketMediaType::kForwardErrorCorrection: // FlexFEC is on separate SSRC, ULPFEC uses media SSRC. return packet.Ssrc() == ssrc_ || packet.Ssrc() == flexfec_ssrc_; } @@ -261,6 +260,7 @@ void RtpSenderEgress::AddPacketToTransportFeedback( packet_info.rtp_sequence_number = packet.SequenceNumber(); packet_info.length = packet_size; packet_info.pacing_info = pacing_info; + packet_info.packet_type = packet.packet_type(); transport_feedback_observer_->OnAddPacket(packet_info); } } @@ -409,11 +409,11 @@ void RtpSenderEgress::UpdateRtpStats(const RtpPacketToSend& packet) { counters->first_packet_time_ms = now_ms; } - if (packet.packet_type() == RtpPacketToSend::Type::kForwardErrorCorrection) { + if (packet.packet_type() == RtpPacketMediaType::kForwardErrorCorrection) { counters->fec.AddPacket(packet); } - if (packet.packet_type() == RtpPacketToSend::Type::kRetransmission) { + if (packet.packet_type() == RtpPacketMediaType::kRetransmission) { counters->retransmitted.AddPacket(packet); nack_bitrate_sent_.Update(packet.size(), now_ms); } diff --git a/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_unittest.cc index 5ca4e70de8..69a09d8183 100644 --- a/modules/rtp_rtcp/source/rtp_sender_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_sender_unittest.cc @@ -305,7 +305,7 @@ class RtpSenderTest : public ::testing::TestWithParam { int64_t capture_time_ms) { auto packet = rtp_sender()->AllocatePacket(); packet->SetPayloadType(payload_type); - packet->set_packet_type(RtpPacketToSend::Type::kVideo); + packet->set_packet_type(RtpPacketMediaType::kVideo); packet->SetMarker(marker_bit); packet->SetTimestamp(timestamp); packet->set_capture_time_ms(capture_time_ms); @@ -767,7 +767,7 @@ TEST_P(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) { Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc)), Pointee(Property(&RtpPacketToSend::SequenceNumber, kSeqNum)))))); auto packet = SendGenericPacket(); - packet->set_packet_type(RtpPacketToSend::Type::kVideo); + packet->set_packet_type(RtpPacketMediaType::kVideo); // Transport sequence number is set by PacketRouter, before SendPacket(). packet->SetExtension(kTransportSequenceNumber); rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); @@ -797,7 +797,7 @@ TEST_P(RtpSenderTest, WritesPacerExitToTimingExtension) { size_t packet_size = packet->size(); const int kStoredTimeInMs = 100; - packet->set_packet_type(RtpPacketToSend::Type::kVideo); + packet->set_packet_type(RtpPacketMediaType::kVideo); packet->set_allow_retransmission(true); EXPECT_CALL(mock_paced_sender_, EnqueuePackets(Contains(Pointee(Property( &RtpPacketToSend::Ssrc, kSsrc))))); @@ -834,24 +834,23 @@ TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtensionWithPacer) { const int kStoredTimeInMs = 100; - packet->set_packet_type(RtpPacketToSend::Type::kVideo); - packet->set_allow_retransmission(true); - EXPECT_CALL(mock_paced_sender_, EnqueuePackets(Contains(Pointee(Property( - &RtpPacketToSend::Ssrc, kSsrc))))); - EXPECT_TRUE(rtp_sender()->SendToNetwork( - std::make_unique(*packet))); - fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + packet->set_packet_type(RtpPacketMediaType::kVideo); + packet->set_allow_retransmission(true); + EXPECT_CALL(mock_paced_sender_, EnqueuePackets(Contains(Pointee(Property( + &RtpPacketToSend::Ssrc, kSsrc))))); + EXPECT_TRUE( + rtp_sender()->SendToNetwork(std::make_unique(*packet))); + fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); + rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); - EXPECT_EQ(1, transport_.packets_sent()); - EXPECT_EQ(packet_size, transport_.last_sent_packet().size()); + EXPECT_EQ(1, transport_.packets_sent()); + EXPECT_EQ(packet_size, transport_.last_sent_packet().size()); - VideoSendTiming video_timing; - EXPECT_TRUE( - transport_.last_sent_packet().GetExtension( - &video_timing)); - EXPECT_EQ(kStoredTimeInMs, video_timing.network2_timestamp_delta_ms); - EXPECT_EQ(kPacerExitMs, video_timing.pacer_exit_delta_ms); + VideoSendTiming video_timing; + EXPECT_TRUE(transport_.last_sent_packet().GetExtension( + &video_timing)); + EXPECT_EQ(kStoredTimeInMs, video_timing.network2_timestamp_delta_ms); + EXPECT_EQ(kPacerExitMs, video_timing.pacer_exit_delta_ms); } TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtensionWithoutPacer) { @@ -865,7 +864,7 @@ TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtensionWithoutPacer) { packet->SetExtension(kVideoTiming); packet->set_allow_retransmission(true); EXPECT_TRUE(rtp_sender()->AssignSequenceNumber(packet.get())); - packet->set_packet_type(RtpPacketToSend::Type::kVideo); + packet->set_packet_type(RtpPacketMediaType::kVideo); const int kPropagateTimeMs = 10; fake_clock_.AdvanceTimeMilliseconds(kPropagateTimeMs); @@ -902,7 +901,7 @@ TEST_P(RtpSenderTest, TrafficSmoothingWithExtensions) { EnqueuePackets(Contains(AllOf( Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc)), Pointee(Property(&RtpPacketToSend::SequenceNumber, kSeqNum)))))); - packet->set_packet_type(RtpPacketToSend::Type::kVideo); + packet->set_packet_type(RtpPacketMediaType::kVideo); packet->set_allow_retransmission(true); EXPECT_TRUE( rtp_sender()->SendToNetwork(std::make_unique(*packet))); @@ -947,7 +946,7 @@ TEST_P(RtpSenderTest, TrafficSmoothingRetransmits) { EnqueuePackets(Contains(AllOf( Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc)), Pointee(Property(&RtpPacketToSend::SequenceNumber, kSeqNum)))))); - packet->set_packet_type(RtpPacketToSend::Type::kVideo); + packet->set_packet_type(RtpPacketMediaType::kVideo); packet->set_allow_retransmission(true); EXPECT_TRUE( rtp_sender()->SendToNetwork(std::make_unique(*packet))); @@ -962,31 +961,29 @@ TEST_P(RtpSenderTest, TrafficSmoothingRetransmits) { EXPECT_CALL(mock_rtc_event_log_, LogProxy(SameRtcEventTypeAs(RtcEvent::Type::RtpPacketOutgoing))); - packet->set_packet_type(RtpPacketToSend::Type::kRetransmission); - packet->set_retransmitted_sequence_number(kSeqNum); - EXPECT_CALL( - mock_paced_sender_, - EnqueuePackets(Contains(AllOf( - Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc)), - Pointee(Property(&RtpPacketToSend::SequenceNumber, kSeqNum)))))); - EXPECT_EQ(static_cast(packet_size), - rtp_sender()->ReSendPacket(kSeqNum)); - EXPECT_EQ(1, transport_.packets_sent()); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + packet->set_packet_type(RtpPacketMediaType::kRetransmission); + packet->set_retransmitted_sequence_number(kSeqNum); + EXPECT_CALL( + mock_paced_sender_, + EnqueuePackets(Contains(AllOf( + Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc)), + Pointee(Property(&RtpPacketToSend::SequenceNumber, kSeqNum)))))); + EXPECT_EQ(static_cast(packet_size), rtp_sender()->ReSendPacket(kSeqNum)); + EXPECT_EQ(1, transport_.packets_sent()); + rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); - // Process send bucket. Packet should now be sent. - EXPECT_EQ(2, transport_.packets_sent()); - EXPECT_EQ(packet_size, transport_.last_sent_packet().size()); + // Process send bucket. Packet should now be sent. + EXPECT_EQ(2, transport_.packets_sent()); + EXPECT_EQ(packet_size, transport_.last_sent_packet().size()); - webrtc::RTPHeader rtp_header; - transport_.last_sent_packet().GetHeader(&rtp_header); + webrtc::RTPHeader rtp_header; + transport_.last_sent_packet().GetHeader(&rtp_header); - // Verify transmission time offset. - EXPECT_EQ(kStoredTimeInMs * 90, - rtp_header.extension.transmissionTimeOffset); - uint64_t expected_send_time = - ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); - EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); + // Verify transmission time offset. + EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset); + uint64_t expected_send_time = + ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); + EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); } // This test sends 1 regular video packet, then 4 padding packets, and then @@ -1028,7 +1025,7 @@ TEST_P(RtpSenderTest, SendPadding) { EnqueuePackets(Contains(AllOf( Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc)), Pointee(Property(&RtpPacketToSend::SequenceNumber, kSeqNum)))))); - packet->set_packet_type(RtpPacketToSend::Type::kVideo); + packet->set_packet_type(RtpPacketMediaType::kVideo); packet->set_allow_retransmission(true); EXPECT_TRUE( rtp_sender()->SendToNetwork(std::make_unique(*packet))); @@ -1077,30 +1074,30 @@ TEST_P(RtpSenderTest, SendPadding) { packet = BuildRtpPacket(kPayload, kMarkerBit, timestamp, capture_time_ms); packet_size = packet->size(); - packet->set_packet_type(RtpPacketToSend::Type::kVideo); - packet->set_allow_retransmission(true); - EXPECT_CALL( - mock_paced_sender_, - EnqueuePackets(Contains(AllOf( - Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc)), - Pointee(Property(&RtpPacketToSend::SequenceNumber, seq_num)))))); - EXPECT_TRUE(rtp_sender()->SendToNetwork( - std::make_unique(*packet))); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + packet->set_packet_type(RtpPacketMediaType::kVideo); + packet->set_allow_retransmission(true); + EXPECT_CALL( + mock_paced_sender_, + EnqueuePackets(Contains(AllOf( + Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc)), + Pointee(Property(&RtpPacketToSend::SequenceNumber, seq_num)))))); + EXPECT_TRUE( + rtp_sender()->SendToNetwork(std::make_unique(*packet))); + rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); - // Process send bucket. - EXPECT_EQ(++total_packets_sent, transport_.packets_sent()); - EXPECT_EQ(packet_size, transport_.last_sent_packet().size()); - transport_.last_sent_packet().GetHeader(&rtp_header); + // Process send bucket. + EXPECT_EQ(++total_packets_sent, transport_.packets_sent()); + EXPECT_EQ(packet_size, transport_.last_sent_packet().size()); + transport_.last_sent_packet().GetHeader(&rtp_header); - // Verify sequence number and timestamp. - EXPECT_EQ(seq_num, rtp_header.sequenceNumber); - EXPECT_EQ(timestamp, rtp_header.timestamp); - // Verify transmission time offset. This packet is sent without delay. - EXPECT_EQ(0, rtp_header.extension.transmissionTimeOffset); - uint64_t expected_send_time = - ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); - EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); + // Verify sequence number and timestamp. + EXPECT_EQ(seq_num, rtp_header.sequenceNumber); + EXPECT_EQ(timestamp, rtp_header.timestamp); + // Verify transmission time offset. This packet is sent without delay. + EXPECT_EQ(0, rtp_header.extension.transmissionTimeOffset); + uint64_t expected_send_time = + ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); + EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); } TEST_P(RtpSenderTest, OnSendPacketUpdated) { @@ -1120,7 +1117,7 @@ TEST_P(RtpSenderTest, OnSendPacketUpdated) { Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc)), Pointee(Property(&RtpPacketToSend::SequenceNumber, kSeqNum)))))); auto packet = SendGenericPacket(); - packet->set_packet_type(RtpPacketToSend::Type::kVideo); + packet->set_packet_type(RtpPacketMediaType::kVideo); packet->SetExtension(kTransportSequenceNumber); rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); @@ -1142,7 +1139,7 @@ TEST_P(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) { Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc)), Pointee(Property(&RtpPacketToSend::SequenceNumber, kSeqNum)))))); auto packet = SendGenericPacket(); - packet->set_packet_type(RtpPacketToSend::Type::kRetransmission); + packet->set_packet_type(RtpPacketMediaType::kRetransmission); packet->SetExtension(kTransportSequenceNumber); rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); @@ -1270,13 +1267,13 @@ TEST_P(RtpSenderTest, SendFlexfecPackets) { EXPECT_CALL(mock_paced_sender_, EnqueuePackets) .WillOnce([&](std::vector> packets) { for (auto& packet : packets) { - if (packet->packet_type() == RtpPacketToSend::Type::kVideo) { + if (packet->packet_type() == RtpPacketMediaType::kVideo) { EXPECT_EQ(packet->Ssrc(), kSsrc); EXPECT_EQ(packet->SequenceNumber(), kSeqNum); media_packet = std::move(packet); } else { EXPECT_EQ(packet->packet_type(), - RtpPacketToSend::Type::kForwardErrorCorrection); + RtpPacketMediaType::kForwardErrorCorrection); EXPECT_EQ(packet->Ssrc(), kFlexFecSsrc); fec_packet = std::move(packet); } @@ -1942,12 +1939,12 @@ TEST_P(RtpSenderTest, DoesNotUpdateOverheadOnEqualSize) { TEST_P(RtpSenderTest, SendPacketMatchesVideo) { std::unique_ptr packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); - packet->set_packet_type(RtpPacketToSend::Type::kVideo); + packet->set_packet_type(RtpPacketMediaType::kVideo); // Verify sent with correct SSRC. packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); packet->SetSsrc(kSsrc); - packet->set_packet_type(RtpPacketToSend::Type::kVideo); + packet->set_packet_type(RtpPacketMediaType::kVideo); rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); EXPECT_EQ(transport_.packets_sent(), 1); } @@ -1955,12 +1952,12 @@ TEST_P(RtpSenderTest, SendPacketMatchesVideo) { TEST_P(RtpSenderTest, SendPacketMatchesAudio) { std::unique_ptr packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); - packet->set_packet_type(RtpPacketToSend::Type::kAudio); + packet->set_packet_type(RtpPacketMediaType::kAudio); // Verify sent with correct SSRC. packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); packet->SetSsrc(kSsrc); - packet->set_packet_type(RtpPacketToSend::Type::kAudio); + packet->set_packet_type(RtpPacketMediaType::kAudio); rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); EXPECT_EQ(transport_.packets_sent(), 1); } @@ -1968,19 +1965,19 @@ TEST_P(RtpSenderTest, SendPacketMatchesAudio) { TEST_P(RtpSenderTest, SendPacketMatchesRetransmissions) { std::unique_ptr packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); - packet->set_packet_type(RtpPacketToSend::Type::kRetransmission); + packet->set_packet_type(RtpPacketMediaType::kRetransmission); // Verify sent with correct SSRC (non-RTX). packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); packet->SetSsrc(kSsrc); - packet->set_packet_type(RtpPacketToSend::Type::kRetransmission); + packet->set_packet_type(RtpPacketMediaType::kRetransmission); rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); EXPECT_EQ(transport_.packets_sent(), 1); // RTX retransmission. packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); packet->SetSsrc(kRtxSsrc); - packet->set_packet_type(RtpPacketToSend::Type::kRetransmission); + packet->set_packet_type(RtpPacketMediaType::kRetransmission); rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); EXPECT_EQ(transport_.packets_sent(), 2); } @@ -1988,19 +1985,19 @@ TEST_P(RtpSenderTest, SendPacketMatchesRetransmissions) { TEST_P(RtpSenderTest, SendPacketMatchesPadding) { std::unique_ptr packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); - packet->set_packet_type(RtpPacketToSend::Type::kPadding); + packet->set_packet_type(RtpPacketMediaType::kPadding); // Verify sent with correct SSRC (non-RTX). packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); packet->SetSsrc(kSsrc); - packet->set_packet_type(RtpPacketToSend::Type::kPadding); + packet->set_packet_type(RtpPacketMediaType::kPadding); rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); EXPECT_EQ(transport_.packets_sent(), 1); // RTX padding. packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); packet->SetSsrc(kRtxSsrc); - packet->set_packet_type(RtpPacketToSend::Type::kPadding); + packet->set_packet_type(RtpPacketMediaType::kPadding); rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); EXPECT_EQ(transport_.packets_sent(), 2); } @@ -2008,12 +2005,12 @@ TEST_P(RtpSenderTest, SendPacketMatchesPadding) { TEST_P(RtpSenderTest, SendPacketMatchesFlexfec) { std::unique_ptr packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); - packet->set_packet_type(RtpPacketToSend::Type::kForwardErrorCorrection); + packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection); // Verify sent with correct SSRC. packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); packet->SetSsrc(kFlexFecSsrc); - packet->set_packet_type(RtpPacketToSend::Type::kForwardErrorCorrection); + packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection); rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); EXPECT_EQ(transport_.packets_sent(), 1); } @@ -2021,12 +2018,12 @@ TEST_P(RtpSenderTest, SendPacketMatchesFlexfec) { TEST_P(RtpSenderTest, SendPacketMatchesUlpfec) { std::unique_ptr packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); - packet->set_packet_type(RtpPacketToSend::Type::kForwardErrorCorrection); + packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection); // Verify sent with correct SSRC. packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); packet->SetSsrc(kSsrc); - packet->set_packet_type(RtpPacketToSend::Type::kForwardErrorCorrection); + packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection); rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); EXPECT_EQ(transport_.packets_sent(), 1); } @@ -2039,7 +2036,7 @@ TEST_P(RtpSenderTest, SendPacketHandlesRetransmissionHistory) { std::unique_ptr packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); const uint16_t media_sequence_number = packet->SequenceNumber(); - packet->set_packet_type(RtpPacketToSend::Type::kVideo); + packet->set_packet_type(RtpPacketMediaType::kVideo); packet->set_allow_retransmission(true); rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); @@ -2054,7 +2051,7 @@ TEST_P(RtpSenderTest, SendPacketHandlesRetransmissionHistory) { // Packet exiting pacer, mark as not longer pending. packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); EXPECT_NE(packet->SequenceNumber(), media_sequence_number); - packet->set_packet_type(RtpPacketToSend::Type::kRetransmission); + packet->set_packet_type(RtpPacketMediaType::kRetransmission); packet->SetSsrc(kRtxSsrc); packet->set_retransmitted_sequence_number(media_sequence_number); packet->set_allow_retransmission(false); @@ -2087,7 +2084,7 @@ TEST_P(RtpSenderTest, SendPacketUpdatesExtensions) { const int32_t kDiffMs = 10; fake_clock_.AdvanceTimeMilliseconds(kDiffMs); - packet->set_packet_type(RtpPacketToSend::Type::kVideo); + packet->set_packet_type(RtpPacketMediaType::kVideo); rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); const RtpPacketReceived& received_packet = transport_.last_sent_packet(); @@ -2112,7 +2109,7 @@ TEST_P(RtpSenderTest, SendPacketSetsPacketOptions) { BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); packet->SetExtension(kPacketId); - packet->set_packet_type(RtpPacketToSend::Type::kVideo); + packet->set_packet_type(RtpPacketMediaType::kVideo); EXPECT_CALL(send_packet_observer_, OnSendPacket); rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); @@ -2124,7 +2121,7 @@ TEST_P(RtpSenderTest, SendPacketSetsPacketOptions) { // Send another packet as retransmission, verify options are populated. packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); packet->SetExtension(kPacketId + 1); - packet->set_packet_type(RtpPacketToSend::Type::kRetransmission); + packet->set_packet_type(RtpPacketMediaType::kRetransmission); rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); EXPECT_TRUE(transport_.last_options_.is_retransmit); } @@ -2152,21 +2149,21 @@ TEST_P(RtpSenderTest, SendPacketUpdatesStats) { std::unique_ptr video_packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); - video_packet->set_packet_type(RtpPacketToSend::Type::kVideo); + video_packet->set_packet_type(RtpPacketMediaType::kVideo); video_packet->SetPayloadSize(kPayloadSize); video_packet->SetExtension(1); std::unique_ptr rtx_packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); rtx_packet->SetSsrc(kRtxSsrc); - rtx_packet->set_packet_type(RtpPacketToSend::Type::kRetransmission); + rtx_packet->set_packet_type(RtpPacketMediaType::kRetransmission); rtx_packet->SetPayloadSize(kPayloadSize); rtx_packet->SetExtension(2); std::unique_ptr fec_packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); fec_packet->SetSsrc(kFlexFecSsrc); - fec_packet->set_packet_type(RtpPacketToSend::Type::kForwardErrorCorrection); + fec_packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection); fec_packet->SetPayloadSize(kPayloadSize); fec_packet->SetExtension(3); @@ -2223,7 +2220,7 @@ TEST_P(RtpSenderTest, GeneratePaddingResendsOldPacketsWithRtx) { BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); packet->set_allow_retransmission(true); packet->SetPayloadSize(kPayloadPacketSize); - packet->set_packet_type(RtpPacketToSend::Type::kVideo); + packet->set_packet_type(RtpPacketMediaType::kVideo); // Send a dummy video packet so it ends up in the packet history. EXPECT_CALL(send_packet_observer_, OnSendPacket).Times(1); @@ -2235,7 +2232,7 @@ TEST_P(RtpSenderTest, GeneratePaddingResendsOldPacketsWithRtx) { rtp_sender()->GeneratePadding(kMinPaddingSize, true); ASSERT_EQ(generated_packets.size(), 1u); auto& padding_packet = generated_packets.front(); - EXPECT_EQ(padding_packet->packet_type(), RtpPacketToSend::Type::kPadding); + EXPECT_EQ(padding_packet->packet_type(), RtpPacketMediaType::kPadding); EXPECT_EQ(padding_packet->Ssrc(), kRtxSsrc); EXPECT_EQ(padding_packet->payload_size(), kPayloadPacketSize + kRtxHeaderSize); @@ -2259,7 +2256,7 @@ TEST_P(RtpSenderTest, GeneratePaddingResendsOldPacketsWithRtx) { rtp_sender()->GeneratePadding(kPaddingBytesRequested, true); EXPECT_EQ(generated_packets.size(), 1u); for (auto& packet : generated_packets) { - EXPECT_EQ(packet->packet_type(), RtpPacketToSend::Type::kPadding); + EXPECT_EQ(packet->packet_type(), RtpPacketMediaType::kPadding); EXPECT_EQ(packet->Ssrc(), kRtxSsrc); EXPECT_EQ(packet->payload_size(), 0u); EXPECT_GT(packet->padding_size(), 0u); @@ -2301,7 +2298,7 @@ TEST_P(RtpSenderTest, GeneratePaddingCreatesPurePaddingWithoutRtx) { BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); packet->set_allow_retransmission(true); packet->SetPayloadSize(kPayloadPacketSize); - packet->set_packet_type(RtpPacketToSend::Type::kVideo); + packet->set_packet_type(RtpPacketMediaType::kVideo); EXPECT_CALL(send_packet_observer_, OnSendPacket).Times(1); rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); @@ -2318,7 +2315,7 @@ TEST_P(RtpSenderTest, GeneratePaddingCreatesPurePaddingWithoutRtx) { rtp_sender()->GeneratePadding(kPaddingBytesRequested, true); EXPECT_EQ(padding_packets.size(), kExpectedNumPaddingPackets); for (auto& packet : padding_packets) { - EXPECT_EQ(packet->packet_type(), RtpPacketToSend::Type::kPadding); + EXPECT_EQ(packet->packet_type(), RtpPacketMediaType::kPadding); EXPECT_EQ(packet->Ssrc(), kSsrc); EXPECT_EQ(packet->payload_size(), 0u); EXPECT_GT(packet->padding_size(), 0u); @@ -2395,7 +2392,7 @@ TEST_P(RtpSenderTest, SetsCaptureTimeAndPopulatesTransmissionOffset) { auto packet = BuildRtpPacket(kPayload, kMarkerBit, fake_clock_.TimeInMilliseconds(), kMissingCaptureTimeMs); - packet->set_packet_type(RtpPacketToSend::Type::kVideo); + packet->set_packet_type(RtpPacketMediaType::kVideo); packet->ReserveExtension(); packet->AllocatePayload(sizeof(kPayloadData)); diff --git a/modules/rtp_rtcp/source/rtp_sender_video.cc b/modules/rtp_rtcp/source/rtp_sender_video.cc index fc176c96cd..e2ef16de51 100644 --- a/modules/rtp_rtcp/source/rtp_sender_video.cc +++ b/modules/rtp_rtcp/source/rtp_sender_video.cc @@ -346,7 +346,7 @@ void RTPSenderVideo::AppendAsRedMaybeWithUlpfec( } // Send |red_packet| instead of |packet| for allocated sequence number. - red_packet->set_packet_type(RtpPacketToSend::Type::kVideo); + red_packet->set_packet_type(RtpPacketMediaType::kVideo); red_packet->set_allow_retransmission(media_packet->allow_retransmission()); packets->emplace_back(std::move(red_packet)); @@ -357,7 +357,7 @@ void RTPSenderVideo::AppendAsRedMaybeWithUlpfec( new RtpPacketToSend(*media_packet)); RTC_CHECK(rtp_packet->Parse(fec_packet->data(), fec_packet->length())); rtp_packet->set_capture_time_ms(media_packet->capture_time_ms()); - rtp_packet->set_packet_type(RtpPacketToSend::Type::kForwardErrorCorrection); + rtp_packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection); rtp_packet->set_allow_retransmission(false); RTC_DCHECK_EQ(fec_packet->length(), rtp_packet->size()); packets->emplace_back(std::move(rtp_packet)); @@ -372,8 +372,7 @@ void RTPSenderVideo::GenerateAndAppendFlexfec( std::vector> fec_packets = flexfec_sender_->GetFecPackets(); for (auto& fec_packet : fec_packets) { - fec_packet->set_packet_type( - RtpPacketToSend::Type::kForwardErrorCorrection); + fec_packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection); fec_packet->set_allow_retransmission(false); packets->emplace_back(std::move(fec_packet)); } @@ -386,8 +385,7 @@ void RTPSenderVideo::LogAndSendToNetwork( int64_t now_ms = clock_->TimeInMilliseconds(); #if BWE_TEST_LOGGING_COMPILE_TIME_ENABLE for (const auto& packet : packets) { - if (packet->packet_type() == - RtpPacketToSend::Type::kForwardErrorCorrection) { + if (packet->packet_type() == RtpPacketMediaType::kForwardErrorCorrection) { const uint32_t ssrc = packet->Ssrc(); BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "VideoFecBitrate_kbps", now_ms, FecOverheadRate() / 1000, ssrc); @@ -400,11 +398,11 @@ void RTPSenderVideo::LogAndSendToNetwork( size_t packetized_payload_size = 0; for (const auto& packet : packets) { switch (*packet->packet_type()) { - case RtpPacketToSend::Type::kVideo: + case RtpPacketMediaType::kVideo: video_bitrate_.Update(packet->size(), now_ms); packetized_payload_size += packet->payload_size(); break; - case RtpPacketToSend::Type::kForwardErrorCorrection: + case RtpPacketMediaType::kForwardErrorCorrection: fec_bitrate_.Update(packet->size(), clock_->TimeInMilliseconds()); break; default: @@ -763,7 +761,7 @@ bool RTPSenderVideo::SendVideo( AppendAsRedMaybeWithUlpfec(std::move(packet), protect_packet, &rtp_packets); } else { - packet->set_packet_type(RtpPacketToSend::Type::kVideo); + packet->set_packet_type(RtpPacketMediaType::kVideo); const RtpPacketToSend& media_packet = *packet; rtp_packets.emplace_back(std::move(packet)); if (flexfec_enabled()) {