zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move packet type enum from RtpPacketToSend to rtp_rtcp_defines.h

Browse Source 
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}
This commit is contained in:
Björn Terelius
2020-02-06 16:35:46 +01:00
committed by Commit Bot
parent 632a03c0cd
commit 31d0f7cfca
15 changed files with 264 additions and 263 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
modules/pacing/paced_sender_unittest.cc
View File

@ -86,21 +86,21 @@ class PacedSenderTest
}
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 @@ TEST_P(PacedSenderTest, PacesPackets) {
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));

18
modules/pacing/pacing_controller.cc
View File

@ -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<RtpPacketToSend> 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);

3
modules/pacing/pacing_controller.h
View File

@ -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);

187
modules/pacing/pacing_controller_unittest.cc
View File

@ -50,7 +50,7 @@ constexpr uint32_t kFlexFecSsrc = 45678;
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 @@ 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<std::unique_ptr<RtpPacketToSend>> GeneratePadding(
@ -84,7 +84,7 @@ class MockPacingControllerCallback : public PacingController::PacketSender {
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 @@ class PacingControllerPadding : public PacingController::PacketSender {
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 @@ class PacingControllerProbing : public PacingController::PacketSender {
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 @@ class PacingControllerProbing : public PacingController::PacketSender {
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 @@ 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<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 @@ 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<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 @@ 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>()) {
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<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 @@ 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<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 @@ TEST_P(PacingControllerTest, SmallFirstProbePacket) {
.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 @@ 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();

8
modules/pacing/round_robin_packet_queue.cc
View File

@ -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 {

2
modules/pacing/round_robin_packet_queue.h
View File

@ -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;

20
modules/pacing/task_queue_paced_sender_unittest.cc
View File

@ -59,21 +59,21 @@ class TaskQueuePacedSenderTest : public ::testing::Test {
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 @@ class TaskQueuePacedSenderTest : public ::testing::Test {
}
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 @@ 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<double>(), 200.0,

10
modules/rtp_rtcp/include/rtp_rtcp_defines.h
View File

@ -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<RtpPacketMediaType> packet_type;
PacedPacketInfo pacing_info;
};
class NetworkStateEstimateObserver {
public:
virtual void OnRemoteNetworkEstimate(NetworkStateEstimate estimate) = 0;

2
modules/rtp_rtcp/source/flexfec_sender.cc
View File

@ -128,7 +128,7 @@ std::vector<std::unique_ptr<RtpPacketToSend>> FlexfecSender::GetFecPackets() {
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);

18
modules/rtp_rtcp/source/rtp_packet_to_send.h
View File

@ -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<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 @@ class RtpPacketToSend : public RtpPacket {
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_;

6
modules/rtp_rtcp/source/rtp_sender.cc
View File

@ -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<std::unique_ptr<RtpPacketToSend>> packets;
packets.emplace_back(std::move(packet));
paced_sender_->EnqueuePackets(std::move(packets));
@ -334,7 +334,7 @@ std::vector<std::unique_ptr<RtpPacketToSend>> 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<std::unique_ptr<RtpPacketToSend>> RTPSender::GeneratePadding(
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_);

4
modules/rtp_rtcp/source/rtp_sender_audio.cc
View File

@ -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<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--;

24
modules/rtp_rtcp/source/rtp_sender_egress.cc
View File

@ -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);
}

195
modules/rtp_rtcp/source/rtp_sender_unittest.cc
View File

@ -305,7 +305,7 @@ class RtpSenderTest : public ::testing::TestWithParam<TestConfig> {
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<TransportSequenceNumber>(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<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 @@ TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtensionWithoutPacer) {
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 @@ 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<RtpPacketToSend>(*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<RtpPacketToSend>(*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<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 @@ 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<RtpPacketToSend>(*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<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 @@ 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<TransportSequenceNumber>(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<TransportSequenceNumber>(kTransportSequenceNumber);
rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
@ -1270,13 +1267,13 @@ TEST_P(RtpSenderTest, SendFlexfecPackets) {
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, DoesNotUpdateOverheadOnEqualSize) {
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, SendPacketMatchesVideo) {
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, SendPacketMatchesAudio) {
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, SendPacketMatchesRetransmissions) {
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, SendPacketMatchesPadding) {
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, SendPacketMatchesFlexfec) {
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 @@ TEST_P(RtpSenderTest, SendPacketHandlesRetransmissionHistory) {
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 @@ 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<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 @@ TEST_P(RtpSenderTest, SendPacketSetsPacketOptions) {
// 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 @@ TEST_P(RtpSenderTest, SendPacketUpdatesStats) {
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 @@ 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<TransmissionOffset>();
packet->AllocatePayload(sizeof(kPayloadData));

16
modules/rtp_rtcp/source/rtp_sender_video.cc
View File

@ -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<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 @@ 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()) {