Move packet type enum from RtpPacketToSend to rtp_rtcp_defines.h
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 <sprang@webrtc.org>
Reviewed-by: Sebastian Jansson <srte@webrtc.org>
Commit-Queue: Björn Terelius <terelius@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#30476}
diff --git a/modules/pacing/paced_sender_unittest.cc b/modules/pacing/paced_sender_unittest.cc
index 7d1b4cb..c4d821f 100644
--- a/modules/pacing/paced_sender_unittest.cc
+++ b/modules/pacing/paced_sender_unittest.cc
@@ -86,21 +86,21 @@
}
protected:
- std::unique_ptr<RtpPacketToSend> BuildRtpPacket(RtpPacketToSend::Type type) {
+ std::unique_ptr<RtpPacketToSend> BuildRtpPacket(RtpPacketMediaType type) {
auto packet = std::make_unique<RtpPacketToSend>(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 @@
DataRate::Zero());
std::vector<std::unique_ptr<RtpPacketToSend>> 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 1f3849e..86c1b89 100644
--- a/modules/pacing/pacing_controller.cc
+++ b/modules/pacing/pacing_controller.cc
@@ -50,22 +50,22 @@
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 @@
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 @@
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 c1b3942..4ffcbd3 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 @@
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 2e4e564..3f62382 100644
--- a/modules/pacing/pacing_controller_unittest.cc
+++ b/modules/pacing/pacing_controller_unittest.cc
@@ -50,7 +50,7 @@
constexpr DataRate kTargetRate = DataRate::KilobitsPerSec<800>();
-std::unique_ptr<RtpPacketToSend> BuildPacket(RtpPacketToSend::Type type,
+std::unique_ptr<RtpPacketToSend> BuildPacket(RtpPacketMediaType type,
uint32_t ssrc,
uint16_t sequence_number,
int64_t capture_time_ms,
@@ -73,8 +73,8 @@
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<std::unique_ptr<RtpPacketToSend>> GeneratePadding(
@@ -84,7 +84,7 @@
if (padding_size > 0) {
auto packet = std::make_unique<RtpPacketToSend>(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 @@
for (size_t i = 0; i < num_packets; ++i) {
packets.emplace_back(std::make_unique<RtpPacketToSend>(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 @@
void SendRtpPacket(std::unique_ptr<RtpPacketToSend> 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 @@
DataSize padding_size = std::min(kMaxPadding, target_size);
packets.emplace_back(std::make_unique<RtpPacketToSend>(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 @@
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 @@
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<RtpPacketToSend> BuildRtpPacket(RtpPacketToSend::Type type) {
+ std::unique_ptr<RtpPacketToSend> BuildRtpPacket(RtpPacketMediaType type) {
auto packet = std::make_unique<RtpPacketToSend>(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 @@
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 @@
: public ::testing::TestWithParam<PacingController::ProcessMode> {
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
media_bytes <
(kTargetRate * (clock_.CurrentTime() - start_time)).bytes<size_t>()) {
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 @@
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 @@
// 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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
EXPECT_CALL(callback, GeneratePadding).WillOnce([&](DataSize padding_size) {
std::vector<std::unique_ptr<RtpPacketToSend>> 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 @@
// 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 @@
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<std::unique_ptr<RtpPacketToSend>> 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 @@
.WillRepeatedly([&](std::unique_ptr<RtpPacketToSend> 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 @@
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 @@
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 7c2a7d2..ace9d76 100644
--- a/modules/pacing/round_robin_packet_queue.cc
+++ b/modules/pacing/round_robin_packet_queue.cc
@@ -35,7 +35,7 @@
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 @@
return priority_;
}
-RtpPacketToSend::Type RoundRobinPacketQueue::QueuedPacket::Type() const {
+RtpPacketMediaType RoundRobinPacketQueue::QueuedPacket::Type() const {
return *owned_packet_->packet_type();
}
@@ -66,7 +66,7 @@
}
bool RoundRobinPacketQueue::QueuedPacket::IsRetransmission() const {
- return Type() == RtpPacketToSend::Type::kRetransmission;
+ return Type() == RtpPacketMediaType::kRetransmission;
}
uint64_t RoundRobinPacketQueue::QueuedPacket::EnqueueOrder() const {
@@ -215,7 +215,7 @@
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 225e137..c256679 100644
--- a/modules/pacing/round_robin_packet_queue.h
+++ b/modules/pacing/round_robin_packet_queue.h
@@ -69,7 +69,7 @@
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 0c3a092..0633d8d 100644
--- a/modules/pacing/task_queue_paced_sender_unittest.cc
+++ b/modules/pacing/task_queue_paced_sender_unittest.cc
@@ -59,21 +59,21 @@
time_controller_.GetTaskQueueFactory()) {}
protected:
- std::unique_ptr<RtpPacketToSend> BuildRtpPacket(RtpPacketToSend::Type type) {
+ std::unique_ptr<RtpPacketToSend> BuildRtpPacket(RtpPacketMediaType type) {
auto packet = std::make_unique<RtpPacketToSend>(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 @@
}
std::vector<std::unique_ptr<RtpPacketToSend>> GeneratePackets(
- RtpPacketToSend::Type type,
+ RtpPacketMediaType type,
size_t num_packets) {
std::vector<std::unique_ptr<RtpPacketToSend>> packets;
for (size_t i = 0; i < num_packets; ++i) {
@@ -105,7 +105,7 @@
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 @@
// 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 @@
}
});
- 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<double>(), 200.0,
diff --git a/modules/rtp_rtcp/include/rtp_rtcp_defines.h b/modules/rtp_rtcp/include/rtp_rtcp_defines.h
index 8cd402e..25a9d29 100644
--- a/modules/rtp_rtcp/include/rtp_rtcp_defines.h
+++ b/modules/rtp_rtcp/include/rtp_rtcp_defines.h
@@ -212,6 +212,14 @@
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 @@
// 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<RtpPacketMediaType> 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 70f1666..de0d412 100644
--- a/modules/rtp_rtcp/source/flexfec_sender.cc
+++ b/modules/rtp_rtcp/source/flexfec_sender.cc
@@ -128,7 +128,7 @@
std::unique_ptr<RtpPacketToSend> 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 07e6ea8..d30bbbf 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 @@
// 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 @@
void set_capture_time_ms(int64_t time) { capture_time_ms_ = time; }
- void set_packet_type(Type type) { packet_type_ = type; }
- absl::optional<Type> packet_type() const { return packet_type_; }
+ void set_packet_type(RtpPacketMediaType type) { packet_type_ = type; }
+ absl::optional<RtpPacketMediaType> 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 @@
private:
int64_t capture_time_ms_ = 0;
- absl::optional<Type> packet_type_;
+ absl::optional<RtpPacketMediaType> packet_type_;
bool allow_retransmission_ = false;
absl::optional<uint16_t> retransmitted_sequence_number_;
std::vector<uint8_t> application_data_;
diff --git a/modules/rtp_rtcp/source/rtp_sender.cc b/modules/rtp_rtcp/source/rtp_sender.cc
index c993e47..3277c67 100644
--- a/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/modules/rtp_rtcp/source/rtp_sender.cc
@@ -266,7 +266,7 @@
if (!packet) {
return -1;
}
- packet->set_packet_type(RtpPacketToSend::Type::kRetransmission);
+ packet->set_packet_type(RtpPacketMediaType::kRetransmission);
std::vector<std::unique_ptr<RtpPacketToSend>> packets;
packets.emplace_back(std::move(packet));
paced_sender_->EnqueuePackets(std::move(packets));
@@ -334,7 +334,7 @@
}
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 @@
while (bytes_left > 0) {
auto padding_packet =
std::make_unique<RtpPacketToSend>(&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 4a47d33..c8d83db 100644
--- a/modules/rtp_rtcp/source/rtp_sender_audio.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_audio.cc
@@ -302,7 +302,7 @@
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 @@
dtmfbuffer[1] = E | R | volume;
ByteWriter<uint16_t>::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 2244927..dc888f9 100644
--- a/modules/rtp_rtcp/source/rtp_sender_egress.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_egress.cc
@@ -140,9 +140,8 @@
}
}
- 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 @@
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 @@
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 @@
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 @@
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 5ca4e70..69a09d8 100644
--- a/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@@ -305,7 +305,7 @@
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 @@
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<TransportSequenceNumber>(kTransportSequenceNumber);
rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
@@ -797,7 +797,7 @@
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 @@
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<RtpPacketToSend>(*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<RtpPacketToSend>(*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<VideoTimingExtension>(
- &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<VideoTimingExtension>(
+ &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 @@
packet->SetExtension<VideoTimingExtension>(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 @@
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<RtpPacketToSend>(*packet)));
@@ -947,7 +946,7 @@
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<RtpPacketToSend>(*packet)));
@@ -962,31 +961,29 @@
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<int>(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<int>(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 @@
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<RtpPacketToSend>(*packet)));
@@ -1077,30 +1074,30 @@
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<RtpPacketToSend>(*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<RtpPacketToSend>(*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 @@
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<TransportSequenceNumber>(kTransportSequenceNumber);
rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
@@ -1142,7 +1139,7 @@
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<TransportSequenceNumber>(kTransportSequenceNumber);
rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
@@ -1270,13 +1267,13 @@
EXPECT_CALL(mock_paced_sender_, EnqueuePackets)
.WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> 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, SendPacketMatchesVideo) {
std::unique_ptr<RtpPacketToSend> 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, SendPacketMatchesAudio) {
std::unique_ptr<RtpPacketToSend> 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, SendPacketMatchesRetransmissions) {
std::unique_ptr<RtpPacketToSend> 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, SendPacketMatchesPadding) {
std::unique_ptr<RtpPacketToSend> 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, SendPacketMatchesFlexfec) {
std::unique_ptr<RtpPacketToSend> 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, SendPacketMatchesUlpfec) {
std::unique_ptr<RtpPacketToSend> 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 @@
std::unique_ptr<RtpPacketToSend> 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 @@
// 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 @@
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 @@
BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds());
packet->SetExtension<TransportSequenceNumber>(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 @@
// Send another packet as retransmission, verify options are populated.
packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds());
packet->SetExtension<TransportSequenceNumber>(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 @@
std::unique_ptr<RtpPacketToSend> 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<TransportSequenceNumber>(1);
std::unique_ptr<RtpPacketToSend> 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<TransportSequenceNumber>(2);
std::unique_ptr<RtpPacketToSend> 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<TransportSequenceNumber>(3);
@@ -2223,7 +2220,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
auto packet =
BuildRtpPacket(kPayload, kMarkerBit, fake_clock_.TimeInMilliseconds(),
kMissingCaptureTimeMs);
- packet->set_packet_type(RtpPacketToSend::Type::kVideo);
+ packet->set_packet_type(RtpPacketMediaType::kVideo);
packet->ReserveExtension<TransmissionOffset>();
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 fc176c9..e2ef16d 100644
--- a/modules/rtp_rtcp/source/rtp_sender_video.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_video.cc
@@ -346,7 +346,7 @@
}
// 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 @@
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 @@
std::vector<std::unique_ptr<RtpPacketToSend>> 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 @@
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 @@
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 @@
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()) {