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

Revert "Revert of Propagate probing cluster id to SendTimeHistory. (patchset #5 id:80001 of https://codereview.webrtc.org/2005313003/ )"

Browse Source 
This reverts commit 46948c17fd09e4957bebc8ea61f0a8e77ff84b48.
TBR=mflodman@webrtc.org
BUG=webrtc:5859

Review-Url: https://codereview.webrtc.org/2032473002
Cr-Commit-Position: refs/heads/master@{#12992}
This commit is contained in:
philipel
2016-06-01 06:31:17 -07:00
committed by Commit bot
parent 98bba39816
commit a1ed0b3241
24 changed files with 290 additions and 190 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
webrtc/modules/pacing/paced_sender.cc
View File

@ -389,6 +389,9 @@ void PacedSender::Process() {
int64_t delta_time_ms = std::min(kMaxIntervalTimeMs, elapsed_time_ms); int64_t delta_time_ms = std::min(kMaxIntervalTimeMs, elapsed_time_ms);
UpdateBytesPerInterval(delta_time_ms); UpdateBytesPerInterval(delta_time_ms);
} }
int probe_cluster_id = prober_->IsProbing() ? prober_->CurrentClusterId()
: PacketInfo::kNotAProbe;
while (!packets_->Empty()) { while (!packets_->Empty()) {
if (media_budget_->bytes_remaining() == 0 && !prober_->IsProbing()) if (media_budget_->bytes_remaining() == 0 && !prober_->IsProbing())
return; return;
@ -397,8 +400,6 @@ void PacedSender::Process() {
// element from the priority queue but keep it in storage, so that we can // element from the priority queue but keep it in storage, so that we can
// reinsert it if send fails. // reinsert it if send fails.
const paced_sender::Packet& packet = packets_->BeginPop(); const paced_sender::Packet& packet = packets_->BeginPop();
int probe_cluster_id =
prober_->IsProbing() ? prober_->CurrentClusterId() : -1;
if (SendPacket(packet, probe_cluster_id)) { if (SendPacket(packet, probe_cluster_id)) {
// Send succeeded, remove it from the queue. // Send succeeded, remove it from the queue.
@ -424,7 +425,7 @@ void PacedSender::Process() {
} }
if (padding_needed > 0) if (padding_needed > 0)
SendPadding(static_cast<size_t>(padding_needed)); SendPadding(padding_needed, probe_cluster_id);
} }
bool PacedSender::SendPacket(const paced_sender::Packet& packet, bool PacedSender::SendPacket(const paced_sender::Packet& packet,
@ -454,9 +455,10 @@ bool PacedSender::SendPacket(const paced_sender::Packet& packet,
return success; return success;
} }
void PacedSender::SendPadding(size_t padding_needed) { void PacedSender::SendPadding(size_t padding_needed, int probe_cluster_id) {
critsect_->Leave(); critsect_->Leave();
size_t bytes_sent = packet_sender_->TimeToSendPadding(padding_needed); size_t bytes_sent =
packet_sender_->TimeToSendPadding(padding_needed, probe_cluster_id);
critsect_->Enter(); critsect_->Enter();
if (bytes_sent > 0) { if (bytes_sent > 0) {

5
webrtc/modules/pacing/paced_sender.h
View File

@ -46,7 +46,7 @@ class PacedSender : public Module, public RtpPacketSender {
int probe_cluster_id) = 0; int probe_cluster_id) = 0;
// Called when it's a good time to send a padding data. // Called when it's a good time to send a padding data.
// Returns the number of bytes sent. // Returns the number of bytes sent.
virtual size_t TimeToSendPadding(size_t bytes) = 0; virtual size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) = 0;
protected: protected:
virtual ~PacketSender() {} virtual ~PacketSender() {}
@ -133,7 +133,8 @@ class PacedSender : public Module, public RtpPacketSender {
bool SendPacket(const paced_sender::Packet& packet, int probe_cluster_id) bool SendPacket(const paced_sender::Packet& packet, int probe_cluster_id)
EXCLUSIVE_LOCKS_REQUIRED(critsect_); EXCLUSIVE_LOCKS_REQUIRED(critsect_);
void SendPadding(size_t padding_needed) EXCLUSIVE_LOCKS_REQUIRED(critsect_); void SendPadding(size_t padding_needed, int probe_cluster_id)
EXCLUSIVE_LOCKS_REQUIRED(critsect_);
Clock* const clock_; Clock* const clock_;
PacketSender* const packet_sender_; PacketSender* const packet_sender_;

38
webrtc/modules/pacing/paced_sender_unittest.cc
View File

@ -32,8 +32,7 @@ class MockPacedSenderCallback : public PacedSender::PacketSender {
int64_t capture_time_ms, int64_t capture_time_ms,
bool retransmission, bool retransmission,
int probe_cluster_id)); int probe_cluster_id));
MOCK_METHOD1(TimeToSendPadding, MOCK_METHOD2(TimeToSendPadding, size_t(size_t bytes, int probe_cluster_id));
size_t(size_t bytes));
}; };
class PacedSenderPadding : public PacedSender::PacketSender { class PacedSenderPadding : public PacedSender::PacketSender {
@ -48,7 +47,7 @@ class PacedSenderPadding : public PacedSender::PacketSender {
return true; return true;
} }
size_t TimeToSendPadding(size_t bytes) override { size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) override {
const size_t kPaddingPacketSize = 224; const size_t kPaddingPacketSize = 224;
size_t num_packets = (bytes + kPaddingPacketSize - 1) / kPaddingPacketSize; size_t num_packets = (bytes + kPaddingPacketSize - 1) / kPaddingPacketSize;
padding_sent_ += kPaddingPacketSize * num_packets; padding_sent_ += kPaddingPacketSize * num_packets;
@ -78,7 +77,7 @@ class PacedSenderProbing : public PacedSender::PacketSender {
return true; return true;
} }
size_t TimeToSendPadding(size_t bytes) override { size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) override {
ExpectAndCountPacket(); ExpectAndCountPacket();
return bytes; return bytes;
} }
@ -159,7 +158,7 @@ TEST_F(PacedSenderTest, QueuePacket) {
EXPECT_EQ(packets_to_send + 1, send_bucket_->QueueSizePackets()); EXPECT_EQ(packets_to_send + 1, send_bucket_->QueueSizePackets());
send_bucket_->Process(); send_bucket_->Process();
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0);
clock_.AdvanceTimeMilliseconds(4); clock_.AdvanceTimeMilliseconds(4);
EXPECT_EQ(1, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(1, send_bucket_->TimeUntilNextProcess());
clock_.AdvanceTimeMilliseconds(1); clock_.AdvanceTimeMilliseconds(1);
@ -211,7 +210,7 @@ TEST_F(PacedSenderTest, PaceQueuedPackets) {
send_bucket_->Process(); send_bucket_->Process();
EXPECT_EQ(packets_to_send_per_interval * 10, EXPECT_EQ(packets_to_send_per_interval * 10,
send_bucket_->QueueSizePackets()); send_bucket_->QueueSizePackets());
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0);
for (int k = 0; k < 10; ++k) { for (int k = 0; k < 10; ++k) {
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
clock_.AdvanceTimeMilliseconds(5); clock_.AdvanceTimeMilliseconds(5);
@ -264,7 +263,7 @@ TEST_F(PacedSenderTest, PaceQueuedPacketsWithDuplicates) {
sequence_number++, clock_.TimeInMilliseconds(), sequence_number++, clock_.TimeInMilliseconds(),
250, false); 250, false);
} }
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0);
send_bucket_->Process(); send_bucket_->Process();
for (int k = 0; k < 10; ++k) { for (int k = 0; k < 10; ++k) {
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
@ -335,22 +334,23 @@ TEST_F(PacedSenderTest, Padding) {
clock_.TimeInMilliseconds(), 250, false); clock_.TimeInMilliseconds(), 250, false);
} }
// No padding is expected since we have sent too much already. // No padding is expected since we have sent too much already.
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0);
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
send_bucket_->Process(); send_bucket_->Process();
EXPECT_EQ(0u, send_bucket_->QueueSizePackets()); EXPECT_EQ(0u, send_bucket_->QueueSizePackets());
// 5 milliseconds later should not send padding since we filled the buffers // 5 milliseconds later should not send padding since we filled the buffers
// initially. // initially.
EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(0); EXPECT_CALL(callback_, TimeToSendPadding(250, _)).Times(0);
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
clock_.AdvanceTimeMilliseconds(5); clock_.AdvanceTimeMilliseconds(5);
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
send_bucket_->Process(); send_bucket_->Process();
// 5 milliseconds later we have enough budget to send some padding. // 5 milliseconds later we have enough budget to send some padding.
EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(1). EXPECT_CALL(callback_, TimeToSendPadding(250, _))
WillOnce(Return(250)); .Times(1)
.WillOnce(Return(250));
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
clock_.AdvanceTimeMilliseconds(5); clock_.AdvanceTimeMilliseconds(5);
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
@ -374,8 +374,9 @@ TEST_F(PacedSenderTest, VerifyPaddingUpToBitrate) {
capture_time_ms, capture_time_ms,
250, 250,
false); false);
EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(1). EXPECT_CALL(callback_, TimeToSendPadding(250, _))
WillOnce(Return(250)); .Times(1)
.WillOnce(Return(250));
send_bucket_->Process(); send_bucket_->Process();
clock_.AdvanceTimeMilliseconds(kTimeStep); clock_.AdvanceTimeMilliseconds(kTimeStep);
} }
@ -443,7 +444,7 @@ TEST_F(PacedSenderTest, Priority) {
sequence_number++, capture_time_ms, 250, false); sequence_number++, capture_time_ms, 250, false);
// Expect all high and normal priority to be sent out first. // Expect all high and normal priority to be sent out first.
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0);
EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, capture_time_ms, false, _)) EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, capture_time_ms, false, _))
.Times(packets_to_send_per_interval + 1) .Times(packets_to_send_per_interval + 1)
.WillRepeatedly(Return(true)); .WillRepeatedly(Return(true));
@ -545,7 +546,7 @@ TEST_F(PacedSenderTest, Pause) {
send_bucket_->QueueInMs()); send_bucket_->QueueInMs());
// Expect no packet to come out while paused. // Expect no packet to come out while paused.
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0);
EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _, _)).Times(0); EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _, _)).Times(0);
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
@ -820,7 +821,7 @@ TEST_F(PacedSenderTest, PaddingOveruse) {
clock_.TimeInMilliseconds(), kPacketSize, false); clock_.TimeInMilliseconds(), kPacketSize, false);
EXPECT_LT(5u, send_bucket_->ExpectedQueueTimeMs()); EXPECT_LT(5u, send_bucket_->ExpectedQueueTimeMs());
// Don't send padding if queue is non-empty, even if padding budget > 0. // Don't send padding if queue is non-empty, even if padding budget > 0.
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0);
send_bucket_->Process(); send_bucket_->Process();
} }
@ -869,7 +870,7 @@ TEST_F(PacedSenderTest, AverageQueueTime) {
EXPECT_EQ(0, send_bucket_->AverageQueueTimeMs()); EXPECT_EQ(0, send_bucket_->AverageQueueTimeMs());
} }
TEST_F(PacedSenderTest, ProbeClusterId) { TEST_F(PacedSenderTest, DISABLED_ProbeClusterId) {
uint32_t ssrc = 12346; uint32_t ssrc = 12346;
uint16_t sequence_number = 1234; uint16_t sequence_number = 1234;
const size_t kPacketSize = 1200; const size_t kPacketSize = 1200;
@ -896,8 +897,7 @@ TEST_F(PacedSenderTest, ProbeClusterId) {
send_bucket_->Process(); send_bucket_->Process();
// No more probing packets. // No more probing packets.
EXPECT_CALL(callback_, TimeToSendPadding(_)) EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(1);
.Times(1);
send_bucket_->Process(); send_bucket_->Process();
} }

10
webrtc/modules/pacing/packet_router.cc
View File

@ -50,20 +50,22 @@ bool PacketRouter::TimeToSendPacket(uint32_t ssrc,
for (auto* rtp_module : rtp_modules_) { for (auto* rtp_module : rtp_modules_) {
if (rtp_module->SendingMedia() && ssrc == rtp_module->SSRC()) { if (rtp_module->SendingMedia() && ssrc == rtp_module->SSRC()) {
return rtp_module->TimeToSendPacket(ssrc, sequence_number, return rtp_module->TimeToSendPacket(ssrc, sequence_number,
capture_timestamp, retransmission); capture_timestamp, retransmission,
probe_cluster_id);
} }
} }
return true; return true;
} }
size_t PacketRouter::TimeToSendPadding(size_t bytes_to_send) { size_t PacketRouter::TimeToSendPadding(size_t bytes_to_send,
int probe_cluster_id) {
RTC_DCHECK(pacer_thread_checker_.CalledOnValidThread()); RTC_DCHECK(pacer_thread_checker_.CalledOnValidThread());
size_t total_bytes_sent = 0; size_t total_bytes_sent = 0;
rtc::CritScope cs(&modules_crit_); rtc::CritScope cs(&modules_crit_);
for (RtpRtcp* module : rtp_modules_) { for (RtpRtcp* module : rtp_modules_) {
if (module->SendingMedia()) { if (module->SendingMedia()) {
size_t bytes_sent = size_t bytes_sent = module->TimeToSendPadding(
module->TimeToSendPadding(bytes_to_send - total_bytes_sent); bytes_to_send - total_bytes_sent, probe_cluster_id);
total_bytes_sent += bytes_sent; total_bytes_sent += bytes_sent;
if (total_bytes_sent >= bytes_to_send) if (total_bytes_sent >= bytes_to_send)
break; break;

2
webrtc/modules/pacing/packet_router.h
View File

@ -46,7 +46,7 @@ class PacketRouter : public PacedSender::PacketSender,
bool retransmission, bool retransmission,
int probe_cluster_id) override; int probe_cluster_id) override;
size_t TimeToSendPadding(size_t bytes) override; size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) override;
void SetTransportWideSequenceNumber(uint16_t sequence_number); void SetTransportWideSequenceNumber(uint16_t sequence_number);
uint16_t AllocateSequenceNumber() override; uint16_t AllocateSequenceNumber() override;

65
webrtc/modules/pacing/packet_router_unittest.cc
View File

@ -48,12 +48,12 @@ TEST_F(PacketRouterTest, TimeToSendPacket) {
EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true)); EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true));
EXPECT_CALL(rtp_1, SSRC()).Times(1).WillOnce(Return(kSsrc1)); EXPECT_CALL(rtp_1, SSRC()).Times(1).WillOnce(Return(kSsrc1));
EXPECT_CALL(rtp_1, TimeToSendPacket(kSsrc1, sequence_number, timestamp, EXPECT_CALL(rtp_1, TimeToSendPacket(kSsrc1, sequence_number, timestamp,
retransmission)) retransmission, 1))
.Times(1) .Times(1)
.WillOnce(Return(true)); .WillOnce(Return(true));
EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _)).Times(0); EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0);
EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1, sequence_number, EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1, sequence_number,
timestamp, retransmission, -1)); timestamp, retransmission, 1));
// Send on the second module by letting rtp_2 be sending, but not rtp_1. // Send on the second module by letting rtp_2 be sending, but not rtp_1.
++sequence_number; ++sequence_number;
@ -63,31 +63,31 @@ TEST_F(PacketRouterTest, TimeToSendPacket) {
EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false)); EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false));
EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true));
EXPECT_CALL(rtp_2, SSRC()).Times(1).WillOnce(Return(kSsrc2)); EXPECT_CALL(rtp_2, SSRC()).Times(1).WillOnce(Return(kSsrc2));
EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _)).Times(0); EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _, _)).Times(0);
EXPECT_CALL(rtp_2, TimeToSendPacket(kSsrc2, sequence_number, timestamp, EXPECT_CALL(rtp_2, TimeToSendPacket(kSsrc2, sequence_number, timestamp,
retransmission)) retransmission, 2))
.Times(1) .Times(1)
.WillOnce(Return(true)); .WillOnce(Return(true));
EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc2, sequence_number, EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc2, sequence_number,
timestamp, retransmission, -1)); timestamp, retransmission, 2));
// No module is sending, hence no packet should be sent. // No module is sending, hence no packet should be sent.
EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false)); EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false));
EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _)).Times(0); EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _, _)).Times(0);
EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(false)); EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(false));
EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _)).Times(0); EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0);
EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1, sequence_number, EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1, sequence_number,
timestamp, retransmission, -1)); timestamp, retransmission, 1));
// Add a packet with incorrect ssrc and test it's dropped in the router. // Add a packet with incorrect ssrc and test it's dropped in the router.
EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true)); EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true));
EXPECT_CALL(rtp_1, SSRC()).Times(1).WillOnce(Return(kSsrc1)); EXPECT_CALL(rtp_1, SSRC()).Times(1).WillOnce(Return(kSsrc1));
EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true));
EXPECT_CALL(rtp_2, SSRC()).Times(1).WillOnce(Return(kSsrc2)); EXPECT_CALL(rtp_2, SSRC()).Times(1).WillOnce(Return(kSsrc2));
EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _)).Times(0); EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _, _)).Times(0);
EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _)).Times(0); EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0);
EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1 + kSsrc2, sequence_number, EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1 + kSsrc2, sequence_number,
timestamp, retransmission, -1)); timestamp, retransmission, 1));
packet_router_->RemoveRtpModule(&rtp_1); packet_router_->RemoveRtpModule(&rtp_1);
@ -95,9 +95,10 @@ TEST_F(PacketRouterTest, TimeToSendPacket) {
// it is dropped as expected by not expecting any calls to rtp_1. // it is dropped as expected by not expecting any calls to rtp_1.
EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true));
EXPECT_CALL(rtp_2, SSRC()).Times(1).WillOnce(Return(kSsrc2)); EXPECT_CALL(rtp_2, SSRC()).Times(1).WillOnce(Return(kSsrc2));
EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _)).Times(0); EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0);
EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1, sequence_number, EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1, sequence_number,
timestamp, retransmission, -1)); timestamp, retransmission,
PacketInfo::kNotAProbe));
packet_router_->RemoveRtpModule(&rtp_2); packet_router_->RemoveRtpModule(&rtp_2);
} }
@ -118,42 +119,45 @@ TEST_F(PacketRouterTest, TimeToSendPadding) {
const size_t requested_padding_bytes = 1000; const size_t requested_padding_bytes = 1000;
const size_t sent_padding_bytes = 890; const size_t sent_padding_bytes = 890;
EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true)); EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true));
EXPECT_CALL(rtp_1, TimeToSendPadding(requested_padding_bytes)) EXPECT_CALL(rtp_1, TimeToSendPadding(requested_padding_bytes, 111))
.Times(1) .Times(1)
.WillOnce(Return(sent_padding_bytes)); .WillOnce(Return(sent_padding_bytes));
EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true));
EXPECT_CALL(rtp_2, EXPECT_CALL(rtp_2, TimeToSendPadding(
TimeToSendPadding(requested_padding_bytes - sent_padding_bytes)) requested_padding_bytes - sent_padding_bytes, 111))
.Times(1) .Times(1)
.WillOnce(Return(requested_padding_bytes - sent_padding_bytes)); .WillOnce(Return(requested_padding_bytes - sent_padding_bytes));
EXPECT_EQ(requested_padding_bytes, EXPECT_EQ(requested_padding_bytes,
packet_router_->TimeToSendPadding(requested_padding_bytes)); packet_router_->TimeToSendPadding(requested_padding_bytes, 111));
// Let only the second module be sending and verify the padding request is // Let only the second module be sending and verify the padding request is
// routed there. // routed there.
EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false)); EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false));
EXPECT_CALL(rtp_1, TimeToSendPadding(requested_padding_bytes)).Times(0); EXPECT_CALL(rtp_1, TimeToSendPadding(requested_padding_bytes, _)).Times(0);
EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true));
EXPECT_CALL(rtp_2, TimeToSendPadding(_)) EXPECT_CALL(rtp_2, TimeToSendPadding(_, _))
.Times(1) .Times(1)
.WillOnce(Return(sent_padding_bytes)); .WillOnce(Return(sent_padding_bytes));
EXPECT_EQ(sent_padding_bytes, EXPECT_EQ(sent_padding_bytes,
packet_router_->TimeToSendPadding(requested_padding_bytes)); packet_router_->TimeToSendPadding(requested_padding_bytes,
PacketInfo::kNotAProbe));
// No sending module at all. // No sending module at all.
EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false)); EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false));
EXPECT_CALL(rtp_1, TimeToSendPadding(requested_padding_bytes)).Times(0); EXPECT_CALL(rtp_1, TimeToSendPadding(requested_padding_bytes, _)).Times(0);
EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(false)); EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(false));
EXPECT_CALL(rtp_2, TimeToSendPadding(_)).Times(0); EXPECT_CALL(rtp_2, TimeToSendPadding(_, _)).Times(0);
EXPECT_EQ(0u, packet_router_->TimeToSendPadding(requested_padding_bytes)); EXPECT_EQ(0u, packet_router_->TimeToSendPadding(requested_padding_bytes,
PacketInfo::kNotAProbe));
packet_router_->RemoveRtpModule(&rtp_1); packet_router_->RemoveRtpModule(&rtp_1);
// rtp_1 has been removed, try sending padding and make sure rtp_1 isn't asked // rtp_1 has been removed, try sending padding and make sure rtp_1 isn't asked
// to send by not expecting any calls. Instead verify rtp_2 is called. // to send by not expecting any calls. Instead verify rtp_2 is called.
EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true));
EXPECT_CALL(rtp_2, TimeToSendPadding(requested_padding_bytes)).Times(1); EXPECT_CALL(rtp_2, TimeToSendPadding(requested_padding_bytes, _)).Times(1);
EXPECT_EQ(0u, packet_router_->TimeToSendPadding(requested_padding_bytes)); EXPECT_EQ(0u, packet_router_->TimeToSendPadding(requested_padding_bytes,
PacketInfo::kNotAProbe));
packet_router_->RemoveRtpModule(&rtp_2); packet_router_->RemoveRtpModule(&rtp_2);
} }
@ -166,11 +170,12 @@ TEST_F(PacketRouterTest, SenderOnlyFunctionsRespectSendingMedia) {
EXPECT_CALL(rtp, SendingMedia()).WillRepeatedly(Return(false)); EXPECT_CALL(rtp, SendingMedia()).WillRepeatedly(Return(false));
// Verify that TimeToSendPacket does not end up in a receiver. // Verify that TimeToSendPacket does not end up in a receiver.
EXPECT_CALL(rtp, TimeToSendPacket(_, _, _, _)).Times(0); EXPECT_CALL(rtp, TimeToSendPacket(_, _, _, _, _)).Times(0);
EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc, 1, 1, false, -1)); EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc, 1, 1, false,
PacketInfo::kNotAProbe));
// Verify that TimeToSendPadding does not end up in a receiver. // Verify that TimeToSendPadding does not end up in a receiver.
EXPECT_CALL(rtp, TimeToSendPadding(_)).Times(0); EXPECT_CALL(rtp, TimeToSendPadding(_, _)).Times(0);
EXPECT_EQ(0u, packet_router_->TimeToSendPadding(200)); EXPECT_EQ(0u, packet_router_->TimeToSendPadding(200, PacketInfo::kNotAProbe));
packet_router_->RemoveRtpModule(&rtp); packet_router_->RemoveRtpModule(&rtp);
} }

5
webrtc/modules/remote_bitrate_estimator/include/send_time_history.h
View File

@ -24,7 +24,10 @@ class SendTimeHistory {
SendTimeHistory(Clock* clock, int64_t packet_age_limit); SendTimeHistory(Clock* clock, int64_t packet_age_limit);
virtual ~SendTimeHistory(); virtual ~SendTimeHistory();
void AddAndRemoveOld(uint16_t sequence_number, size_t length, bool was_paced); void AddAndRemoveOld(uint16_t sequence_number,
size_t length,
bool was_paced,
int probe_cluster_id);
bool OnSentPacket(uint16_t sequence_number, int64_t timestamp); bool OnSentPacket(uint16_t sequence_number, int64_t timestamp);
// Look up PacketInfo for a sent packet, based on the sequence number, and // Look up PacketInfo for a sent packet, based on the sequence number, and
// populate all fields except for receive_time. The packet parameter must // populate all fields except for receive_time. The packet parameter must

8
webrtc/modules/remote_bitrate_estimator/send_time_history.cc
View File

@ -28,15 +28,17 @@ void SendTimeHistory::Clear() {
void SendTimeHistory::AddAndRemoveOld(uint16_t sequence_number, void SendTimeHistory::AddAndRemoveOld(uint16_t sequence_number,
size_t length, size_t length,
bool was_paced) { bool was_paced,
int probe_cluster_id) {
EraseOld(); EraseOld();
if (history_.empty()) if (history_.empty())
oldest_sequence_number_ = sequence_number; oldest_sequence_number_ = sequence_number;
history_.insert(std::pair<uint16_t, PacketInfo>( history_.insert(std::pair<uint16_t, PacketInfo>(
sequence_number, PacketInfo(clock_->TimeInMilliseconds(), 0, -1, sequence_number,
sequence_number, length, was_paced))); PacketInfo(clock_->TimeInMilliseconds(), 0, -1, sequence_number, length,
was_paced, probe_cluster_id)));
} }
bool SendTimeHistory::OnSentPacket(uint16_t sequence_number, bool SendTimeHistory::OnSentPacket(uint16_t sequence_number,

101
webrtc/modules/remote_bitrate_estimator/send_time_history_unittest.cc
View File

@ -34,8 +34,10 @@ class SendTimeHistoryTest : public ::testing::Test {
void AddPacketWithSendTime(uint16_t sequence_number, void AddPacketWithSendTime(uint16_t sequence_number,
size_t length, size_t length,
bool was_paced, bool was_paced,
int64_t send_time_ms) { int64_t send_time_ms,
history_.AddAndRemoveOld(sequence_number, length, was_paced); int probe_cluster_id) {
history_.AddAndRemoveOld(sequence_number, length, was_paced,
probe_cluster_id);
history_.OnSentPacket(sequence_number, send_time_ms); history_.OnSentPacket(sequence_number, send_time_ms);
} }
@ -46,42 +48,58 @@ class SendTimeHistoryTest : public ::testing::Test {
// Help class extended so we can do EXPECT_EQ and collections. // Help class extended so we can do EXPECT_EQ and collections.
class PacketInfo : public webrtc::PacketInfo { class PacketInfo : public webrtc::PacketInfo {
public: public:
PacketInfo() : webrtc::PacketInfo(-1, 0, 0, 0, 0, false) {} PacketInfo()
: webrtc::PacketInfo(-1,
0,
0,
0,
0,
false,
webrtc::PacketInfo::kNotAProbe) {}
PacketInfo(int64_t arrival_time_ms, uint16_t sequence_number) PacketInfo(int64_t arrival_time_ms, uint16_t sequence_number)
: PacketInfo(arrival_time_ms, 0, sequence_number, 0, false) {} : PacketInfo(arrival_time_ms,
0,
sequence_number,
0,
false,
PacketInfo::kNotAProbe) {}
PacketInfo(int64_t arrival_time_ms, PacketInfo(int64_t arrival_time_ms,
int64_t send_time_ms, int64_t send_time_ms,
uint16_t sequence_number, uint16_t sequence_number,
size_t payload_size, size_t payload_size,
bool was_paced) bool was_paced,
int probe_cluster_id)
: webrtc::PacketInfo(-1, : webrtc::PacketInfo(-1,
arrival_time_ms, arrival_time_ms,
send_time_ms, send_time_ms,
sequence_number, sequence_number,
payload_size, payload_size,
was_paced) {} was_paced,
probe_cluster_id) {}
bool operator==(const PacketInfo& other) const { bool operator==(const PacketInfo& other) const {
return arrival_time_ms == other.arrival_time_ms && return arrival_time_ms == other.arrival_time_ms &&
send_time_ms == other.send_time_ms && send_time_ms == other.send_time_ms &&
sequence_number == other.sequence_number && sequence_number == other.sequence_number &&
payload_size == other.payload_size && was_paced == other.was_paced; payload_size == other.payload_size && was_paced == other.was_paced &&
probe_cluster_id == other.probe_cluster_id;
} }
}; };
TEST_F(SendTimeHistoryTest, AddRemoveOne) { TEST_F(SendTimeHistoryTest, AddRemoveOne) {
const uint16_t kSeqNo = 10; const uint16_t kSeqNo = 10;
const PacketInfo kSentPacket(0, 1, kSeqNo, 1, true); const int kProbeClusterId = 0;
AddPacketWithSendTime(kSeqNo, 1, true, 1); const PacketInfo kSentPacket(0, 1, kSeqNo, 1, true, kProbeClusterId);
AddPacketWithSendTime(kSeqNo, 1, true, 1, kProbeClusterId);
PacketInfo received_packet(0, 0, kSeqNo, 0, false); PacketInfo received_packet(0, 0, kSeqNo, 0, false, kProbeClusterId);
EXPECT_TRUE(history_.GetInfo(&received_packet, false)); EXPECT_TRUE(history_.GetInfo(&received_packet, false));
EXPECT_EQ(kSentPacket, received_packet); EXPECT_EQ(kSentPacket, received_packet);
PacketInfo received_packet2(0, 0, kSeqNo, 0, false); PacketInfo received_packet2(0, 0, kSeqNo, 0, false, kProbeClusterId);
EXPECT_TRUE(history_.GetInfo(&received_packet2, true)); EXPECT_TRUE(history_.GetInfo(&received_packet2, true));
EXPECT_EQ(kSentPacket, received_packet2); EXPECT_EQ(kSentPacket, received_packet2);
PacketInfo received_packet3(0, 0, kSeqNo, 0, false); PacketInfo received_packet3(0, 0, kSeqNo, 0, false, kProbeClusterId);
EXPECT_FALSE(history_.GetInfo(&received_packet3, true)); EXPECT_FALSE(history_.GetInfo(&received_packet3, true));
} }
@ -92,7 +110,8 @@ TEST_F(SendTimeHistoryTest, PopulatesExpectedFields) {
const size_t kPayloadSize = 42; const size_t kPayloadSize = 42;
const bool kPaced = true; const bool kPaced = true;
AddPacketWithSendTime(kSeqNo, kPayloadSize, kPaced, kSendTime); AddPacketWithSendTime(kSeqNo, kPayloadSize, kPaced, kSendTime,
PacketInfo::kNotAProbe);
PacketInfo info(kReceiveTime, kSeqNo); PacketInfo info(kReceiveTime, kSeqNo);
EXPECT_TRUE(history_.GetInfo(&info, true)); EXPECT_TRUE(history_.GetInfo(&info, true));
@ -110,18 +129,19 @@ TEST_F(SendTimeHistoryTest, AddThenRemoveOutOfOrder) {
const size_t kPacketSize = 400; const size_t kPacketSize = 400;
const size_t kTransmissionTime = 1234; const size_t kTransmissionTime = 1234;
const bool kPaced = true; const bool kPaced = true;
const int kProbeClusterId = 1;
for (size_t i = 0; i < num_items; ++i) { for (size_t i = 0; i < num_items; ++i) {
sent_packets.push_back(PacketInfo(0, static_cast<int64_t>(i), sent_packets.push_back(PacketInfo(0, static_cast<int64_t>(i),
static_cast<uint16_t>(i), kPacketSize, static_cast<uint16_t>(i), kPacketSize,
kPaced)); kPaced, kProbeClusterId));
received_packets.push_back( received_packets.push_back(PacketInfo(
PacketInfo(static_cast<int64_t>(i) + kTransmissionTime, 0, static_cast<int64_t>(i) + kTransmissionTime, 0,
static_cast<uint16_t>(i), kPacketSize, false)); static_cast<uint16_t>(i), kPacketSize, false, PacketInfo::kNotAProbe));
} }
for (size_t i = 0; i < num_items; ++i) { for (size_t i = 0; i < num_items; ++i) {
history_.AddAndRemoveOld(sent_packets[i].sequence_number, history_.AddAndRemoveOld(
sent_packets[i].payload_size, sent_packets[i].sequence_number, sent_packets[i].payload_size,
sent_packets[i].was_paced); sent_packets[i].was_paced, sent_packets[i].probe_cluster_id);
} }
for (size_t i = 0; i < num_items; ++i) for (size_t i = 0; i < num_items; ++i)
history_.OnSentPacket(sent_packets[i].sequence_number, history_.OnSentPacket(sent_packets[i].sequence_number,
@ -143,19 +163,21 @@ TEST_F(SendTimeHistoryTest, HistorySize) {
const int kItems = kDefaultHistoryLengthMs / 100; const int kItems = kDefaultHistoryLengthMs / 100;
for (int i = 0; i < kItems; ++i) { for (int i = 0; i < kItems; ++i) {
clock_.AdvanceTimeMilliseconds(100); clock_.AdvanceTimeMilliseconds(100);
AddPacketWithSendTime(i, 0, false, i * 100); AddPacketWithSendTime(i, 0, false, i * 100, PacketInfo::kNotAProbe);
} }
for (int i = 0; i < kItems; ++i) { for (int i = 0; i < kItems; ++i) {
PacketInfo info(0, 0, static_cast<uint16_t>(i), 0, false); PacketInfo info(0, 0, static_cast<uint16_t>(i), 0, false,
PacketInfo::kNotAProbe);
EXPECT_TRUE(history_.GetInfo(&info, false)); EXPECT_TRUE(history_.GetInfo(&info, false));
EXPECT_EQ(i * 100, info.send_time_ms); EXPECT_EQ(i * 100, info.send_time_ms);
} }
clock_.AdvanceTimeMilliseconds(101); clock_.AdvanceTimeMilliseconds(101);
AddPacketWithSendTime(kItems, 0, false, kItems * 101); AddPacketWithSendTime(kItems, 0, false, kItems * 101, PacketInfo::kNotAProbe);
PacketInfo info(0, 0, 0, 0, false); PacketInfo info(0, 0, 0, 0, false, PacketInfo::kNotAProbe);
EXPECT_FALSE(history_.GetInfo(&info, false)); EXPECT_FALSE(history_.GetInfo(&info, false));
for (int i = 1; i < (kItems + 1); ++i) { for (int i = 1; i < (kItems + 1); ++i) {
PacketInfo info2(0, 0, static_cast<uint16_t>(i), 0, false); PacketInfo info2(0, 0, static_cast<uint16_t>(i), 0, false,
PacketInfo::kNotAProbe);
EXPECT_TRUE(history_.GetInfo(&info2, false)); EXPECT_TRUE(history_.GetInfo(&info2, false));
int64_t expected_time_ms = (i == kItems) ? i * 101 : i * 100; int64_t expected_time_ms = (i == kItems) ? i * 101 : i * 100;
EXPECT_EQ(expected_time_ms, info2.send_time_ms); EXPECT_EQ(expected_time_ms, info2.send_time_ms);
@ -164,16 +186,17 @@ TEST_F(SendTimeHistoryTest, HistorySize) {
TEST_F(SendTimeHistoryTest, HistorySizeWithWraparound) { TEST_F(SendTimeHistoryTest, HistorySizeWithWraparound) {
const uint16_t kMaxSeqNo = std::numeric_limits<uint16_t>::max(); const uint16_t kMaxSeqNo = std::numeric_limits<uint16_t>::max();
AddPacketWithSendTime(kMaxSeqNo - 2, 0, false, 0); AddPacketWithSendTime(kMaxSeqNo - 2, 0, false, 0, PacketInfo::kNotAProbe);
clock_.AdvanceTimeMilliseconds(100); clock_.AdvanceTimeMilliseconds(100);
AddPacketWithSendTime(kMaxSeqNo - 1, 1, false, 100); AddPacketWithSendTime(kMaxSeqNo - 1, 1, false, 100, PacketInfo::kNotAProbe);
clock_.AdvanceTimeMilliseconds(100); clock_.AdvanceTimeMilliseconds(100);
AddPacketWithSendTime(kMaxSeqNo, 0, false, 200); AddPacketWithSendTime(kMaxSeqNo, 0, false, 200, PacketInfo::kNotAProbe);
clock_.AdvanceTimeMilliseconds(kDefaultHistoryLengthMs - 200 + 1); clock_.AdvanceTimeMilliseconds(kDefaultHistoryLengthMs - 200 + 1);
AddPacketWithSendTime(0, 0, false, kDefaultHistoryLengthMs); AddPacketWithSendTime(0, 0, false, kDefaultHistoryLengthMs,
PacketInfo::kNotAProbe);
PacketInfo info(0, static_cast<uint16_t>(kMaxSeqNo - 2)); PacketInfo info(0, static_cast<uint16_t>(kMaxSeqNo - 2));
EXPECT_FALSE(history_.GetInfo(&info, false)); EXPECT_FALSE(history_.GetInfo(&info, false));
@ -189,7 +212,7 @@ TEST_F(SendTimeHistoryTest, HistorySizeWithWraparound) {
EXPECT_TRUE(history_.GetInfo(&info5, true)); EXPECT_TRUE(history_.GetInfo(&info5, true));
clock_.AdvanceTimeMilliseconds(100); clock_.AdvanceTimeMilliseconds(100);
AddPacketWithSendTime(1, 0, false, 1100); AddPacketWithSendTime(1, 0, false, 1100, PacketInfo::kNotAProbe);
PacketInfo info6(0, static_cast<uint16_t>(kMaxSeqNo - 2)); PacketInfo info6(0, static_cast<uint16_t>(kMaxSeqNo - 2));
EXPECT_FALSE(history_.GetInfo(&info6, false)); EXPECT_FALSE(history_.GetInfo(&info6, false));
@ -206,26 +229,26 @@ TEST_F(SendTimeHistoryTest, HistorySizeWithWraparound) {
TEST_F(SendTimeHistoryTest, InterlievedGetAndRemove) { TEST_F(SendTimeHistoryTest, InterlievedGetAndRemove) {
const uint16_t kSeqNo = 1; const uint16_t kSeqNo = 1;
const int64_t kTimestamp = 2; const int64_t kTimestamp = 2;
PacketInfo packets[3] = {{0, kTimestamp, kSeqNo, 0, false}, PacketInfo packets[3] = {{0, kTimestamp, kSeqNo, 0, false, 0},
{0, kTimestamp + 1, kSeqNo + 1, 0, false}, {0, kTimestamp + 1, kSeqNo + 1, 0, false, 1},
{0, kTimestamp + 2, kSeqNo + 2, 0, false}}; {0, kTimestamp + 2, kSeqNo + 2, 0, false, 2}};
AddPacketWithSendTime(packets[0].sequence_number, packets[0].payload_size, AddPacketWithSendTime(packets[0].sequence_number, packets[0].payload_size,
packets[0].was_paced, packets[0].send_time_ms); packets[0].was_paced, packets[0].send_time_ms, 0);
AddPacketWithSendTime(packets[1].sequence_number, packets[1].payload_size, AddPacketWithSendTime(packets[1].sequence_number, packets[1].payload_size,
packets[1].was_paced, packets[1].send_time_ms); packets[1].was_paced, packets[1].send_time_ms, 1);
PacketInfo info(0, 0, packets[0].sequence_number, 0, false); PacketInfo info(0, 0, packets[0].sequence_number, 0, false, 0);
EXPECT_TRUE(history_.GetInfo(&info, true)); EXPECT_TRUE(history_.GetInfo(&info, true));
EXPECT_EQ(packets[0], info); EXPECT_EQ(packets[0], info);
AddPacketWithSendTime(packets[2].sequence_number, packets[2].payload_size, AddPacketWithSendTime(packets[2].sequence_number, packets[2].payload_size,
packets[2].was_paced, packets[2].send_time_ms); packets[2].was_paced, packets[2].send_time_ms, 2);
PacketInfo info2(0, 0, packets[1].sequence_number, 0, false); PacketInfo info2(0, 0, packets[1].sequence_number, 0, false, 1);
EXPECT_TRUE(history_.GetInfo(&info2, true)); EXPECT_TRUE(history_.GetInfo(&info2, true));
EXPECT_EQ(packets[1], info2); EXPECT_EQ(packets[1], info2);
PacketInfo info3(0, 0, packets[2].sequence_number, 0, false); PacketInfo info3(0, 0, packets[2].sequence_number, 0, false, 2);
EXPECT_TRUE(history_.GetInfo(&info3, true)); EXPECT_TRUE(history_.GetInfo(&info3, true));
EXPECT_EQ(packets[2], info3); EXPECT_EQ(packets[2], info3);
} }

8
webrtc/modules/remote_bitrate_estimator/test/estimators/send_side.cc
View File

@ -92,9 +92,11 @@ void FullBweSender::OnPacketsSent(const Packets& packets) {
for (Packet* packet : packets) { for (Packet* packet : packets) {
if (packet->GetPacketType() == Packet::kMedia) { if (packet->GetPacketType() == Packet::kMedia) {
MediaPacket* media_packet = static_cast<MediaPacket*>(packet); MediaPacket* media_packet = static_cast<MediaPacket*>(packet);
send_time_history_.AddAndRemoveOld(media_packet->header().sequenceNumber, // TODO(philipel): Add probe_cluster_id to Packet class in order
media_packet->payload_size(), // to create tests for probing using cluster ids.
packet->paced()); send_time_history_.AddAndRemoveOld(
media_packet->header().sequenceNumber, media_packet->payload_size(),
packet->paced(), PacketInfo::kNotAProbe);
send_time_history_.OnSentPacket(media_packet->header().sequenceNumber, send_time_history_.OnSentPacket(media_packet->header().sequenceNumber,
media_packet->sender_timestamp_ms()); media_packet->sender_timestamp_ms());
} }

2
webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc
View File

@ -299,7 +299,7 @@ bool PacedVideoSender::TimeToSendPacket(uint32_t ssrc,
return false; return false;
} }
size_t PacedVideoSender::TimeToSendPadding(size_t bytes) { size_t PacedVideoSender::TimeToSendPadding(size_t bytes, int probe_cluster_id) {
return 0; return 0;
} }

2
webrtc/modules/remote_bitrate_estimator/test/packet_sender.h
View File

@ -115,7 +115,7 @@ class PacedVideoSender : public VideoSender, public PacedSender::PacketSender {
int64_t capture_time_ms, int64_t capture_time_ms,
bool retransmission, bool retransmission,
int probe_cluster_id) override; int probe_cluster_id) override;
size_t TimeToSendPadding(size_t bytes) override; size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) override;
// Implements BitrateObserver. // Implements BitrateObserver.
void OnNetworkChanged(uint32_t target_bitrate_bps, void OnNetworkChanged(uint32_t target_bitrate_bps,

6
webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.cc
View File

@ -59,9 +59,11 @@ void TransportFeedbackAdapter::SetBitrateEstimator(
void TransportFeedbackAdapter::AddPacket(uint16_t sequence_number, void TransportFeedbackAdapter::AddPacket(uint16_t sequence_number,
size_t length, size_t length,
bool was_paced) { bool was_paced,
int probe_cluster_id) {
rtc::CritScope cs(&lock_); rtc::CritScope cs(&lock_);
send_time_history_.AddAndRemoveOld(sequence_number, length, was_paced); send_time_history_.AddAndRemoveOld(sequence_number, length, was_paced,
probe_cluster_id);
} }
void TransportFeedbackAdapter::OnSentPacket(uint16_t sequence_number, void TransportFeedbackAdapter::OnSentPacket(uint16_t sequence_number,

3
webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.h
View File

@ -40,7 +40,8 @@ class TransportFeedbackAdapter : public TransportFeedbackObserver,
// Implements TransportFeedbackObserver. // Implements TransportFeedbackObserver.
void AddPacket(uint16_t sequence_number, void AddPacket(uint16_t sequence_number,
size_t length, size_t length,
bool was_paced) override; bool was_paced,
int probe_cluster_id) override;
void OnSentPacket(uint16_t sequence_number, int64_t send_time_ms); void OnSentPacket(uint16_t sequence_number, int64_t send_time_ms);
void OnTransportFeedback(const rtcp::TransportFeedback& feedback) override; void OnTransportFeedback(const rtcp::TransportFeedback& feedback) override;

42
webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter_unittest.cc
View File

@ -93,14 +93,15 @@ class TransportFeedbackAdapterTest : public ::testing::Test {
EXPECT_EQ(truth[i].sequence_number, input[i].sequence_number); EXPECT_EQ(truth[i].sequence_number, input[i].sequence_number);
EXPECT_EQ(truth[i].payload_size, input[i].payload_size); EXPECT_EQ(truth[i].payload_size, input[i].payload_size);
EXPECT_EQ(truth[i].was_paced, input[i].was_paced); EXPECT_EQ(truth[i].was_paced, input[i].was_paced);
EXPECT_EQ(truth[i].probe_cluster_id, input[i].probe_cluster_id);
} }
} }
// Utility method, to reset arrival_time_ms before adding send time. // Utility method, to reset arrival_time_ms before adding send time.
void OnSentPacket(PacketInfo info) { void OnSentPacket(PacketInfo info) {
info.arrival_time_ms = 0; info.arrival_time_ms = 0;
adapter_->AddPacket(info.sequence_number, info.payload_size, adapter_->AddPacket(info.sequence_number, info.payload_size, info.was_paced,
info.was_paced); info.probe_cluster_id);
adapter_->OnSentPacket(info.sequence_number, info.send_time_ms); adapter_->OnSentPacket(info.sequence_number, info.send_time_ms);
} }
@ -114,11 +115,11 @@ class TransportFeedbackAdapterTest : public ::testing::Test {
TEST_F(TransportFeedbackAdapterTest, AdaptsFeedbackAndPopulatesSendTimes) { TEST_F(TransportFeedbackAdapterTest, AdaptsFeedbackAndPopulatesSendTimes) {
std::vector<PacketInfo> packets; std::vector<PacketInfo> packets;
packets.push_back(PacketInfo(100, 200, 0, 1500, true)); packets.push_back(PacketInfo(100, 200, 0, 1500, true, 0));
packets.push_back(PacketInfo(110, 210, 1, 1500, true)); packets.push_back(PacketInfo(110, 210, 1, 1500, true, 0));
packets.push_back(PacketInfo(120, 220, 2, 1500, true)); packets.push_back(PacketInfo(120, 220, 2, 1500, true, 0));
packets.push_back(PacketInfo(130, 230, 3, 1500, true)); packets.push_back(PacketInfo(130, 230, 3, 1500, true, 1));
packets.push_back(PacketInfo(140, 240, 4, 1500, true)); packets.push_back(PacketInfo(140, 240, 4, 1500, true, 1));
for (const PacketInfo& packet : packets) for (const PacketInfo& packet : packets)
OnSentPacket(packet); OnSentPacket(packet);
@ -145,11 +146,11 @@ TEST_F(TransportFeedbackAdapterTest, AdaptsFeedbackAndPopulatesSendTimes) {
TEST_F(TransportFeedbackAdapterTest, HandlesDroppedPackets) { TEST_F(TransportFeedbackAdapterTest, HandlesDroppedPackets) {
std::vector<PacketInfo> packets; std::vector<PacketInfo> packets;
packets.push_back(PacketInfo(100, 200, 0, 1500, true)); packets.push_back(PacketInfo(100, 200, 0, 1500, true, 1));
packets.push_back(PacketInfo(110, 210, 1, 1500, true)); packets.push_back(PacketInfo(110, 210, 1, 1500, true, 2));
packets.push_back(PacketInfo(120, 220, 2, 1500, true)); packets.push_back(PacketInfo(120, 220, 2, 1500, true, 3));
packets.push_back(PacketInfo(130, 230, 3, 1500, true)); packets.push_back(PacketInfo(130, 230, 3, 1500, true, 4));
packets.push_back(PacketInfo(140, 240, 4, 1500, true)); packets.push_back(PacketInfo(140, 240, 4, 1500, true, 5));
const uint16_t kSendSideDropBefore = 1; const uint16_t kSendSideDropBefore = 1;
const uint16_t kReceiveSideDropAfter = 3; const uint16_t kReceiveSideDropAfter = 3;
@ -190,9 +191,12 @@ TEST_F(TransportFeedbackAdapterTest, SendTimeWrapsBothWays) {
static_cast<int64_t>(1 << 8) * static_cast<int64_t>(1 << 8) *
static_cast<int64_t>((1 << 23) - 1) / 1000; static_cast<int64_t>((1 << 23) - 1) / 1000;
std::vector<PacketInfo> packets; std::vector<PacketInfo> packets;
packets.push_back(PacketInfo(kHighArrivalTimeMs - 64, 200, 0, 1500, true)); packets.push_back(PacketInfo(kHighArrivalTimeMs - 64, 200, 0, 1500, true,
packets.push_back(PacketInfo(kHighArrivalTimeMs + 64, 210, 1, 1500, true)); PacketInfo::kNotAProbe));
packets.push_back(PacketInfo(kHighArrivalTimeMs, 220, 2, 1500, true)); packets.push_back(PacketInfo(kHighArrivalTimeMs + 64, 210, 1, 1500, true,
PacketInfo::kNotAProbe));
packets.push_back(PacketInfo(kHighArrivalTimeMs, 220, 2, 1500, true,
PacketInfo::kNotAProbe));
for (const PacketInfo& packet : packets) for (const PacketInfo& packet : packets)
OnSentPacket(packet); OnSentPacket(packet);
@ -225,9 +229,9 @@ TEST_F(TransportFeedbackAdapterTest, SendTimeWrapsBothWays) {
TEST_F(TransportFeedbackAdapterTest, HandlesReordering) { TEST_F(TransportFeedbackAdapterTest, HandlesReordering) {
std::vector<PacketInfo> packets; std::vector<PacketInfo> packets;
packets.push_back(PacketInfo(120, 200, 0, 1500, true)); packets.push_back(PacketInfo(120, 200, 0, 1500, true, 0));
packets.push_back(PacketInfo(110, 210, 1, 1500, true)); packets.push_back(PacketInfo(110, 210, 1, 1500, true, 0));
packets.push_back(PacketInfo(100, 220, 2, 1500, true)); packets.push_back(PacketInfo(100, 220, 2, 1500, true, 0));
std::vector<PacketInfo> expected_packets; std::vector<PacketInfo> expected_packets;
expected_packets.push_back(packets[2]); expected_packets.push_back(packets[2]);
expected_packets.push_back(packets[1]); expected_packets.push_back(packets[1]);
@ -267,7 +271,7 @@ TEST_F(TransportFeedbackAdapterTest, TimestampDeltas) {
rtcp::TransportFeedback::kDeltaScaleFactor * rtcp::TransportFeedback::kDeltaScaleFactor *
std::numeric_limits<int16_t>::min(); std::numeric_limits<int16_t>::min();
PacketInfo info(100, 200, 0, 1500, true); PacketInfo info(100, 200, 0, 1500, true, PacketInfo::kNotAProbe);
sent_packets.push_back(info); sent_packets.push_back(info);
info.send_time_ms += kSmallDeltaUs / 1000; info.send_time_ms += kSmallDeltaUs / 1000;

5
webrtc/modules/rtp_rtcp/include/rtp_rtcp.h
View File

@ -315,9 +315,10 @@ class RtpRtcp : public Module {
virtual bool TimeToSendPacket(uint32_t ssrc, virtual bool TimeToSendPacket(uint32_t ssrc,
uint16_t sequence_number, uint16_t sequence_number,
int64_t capture_time_ms, int64_t capture_time_ms,
bool retransmission) = 0; bool retransmission,
int probe_cluster_id) = 0;
virtual size_t TimeToSendPadding(size_t bytes) = 0; virtual size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) = 0;
// Called on generation of new statistics after an RTP send. // Called on generation of new statistics after an RTP send.
virtual void RegisterSendChannelRtpStatisticsCallback( virtual void RegisterSendChannelRtpStatisticsCallback(

27
webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h
View File

@ -245,32 +245,44 @@ class RtcpBandwidthObserver {
struct PacketInfo { struct PacketInfo {
PacketInfo(int64_t arrival_time_ms, uint16_t sequence_number) PacketInfo(int64_t arrival_time_ms, uint16_t sequence_number)
: PacketInfo(-1, arrival_time_ms, -1, sequence_number, 0, false) {} : PacketInfo(-1,
arrival_time_ms,
-1,
sequence_number,
0,
false,
kNotAProbe) {}
PacketInfo(int64_t arrival_time_ms, PacketInfo(int64_t arrival_time_ms,
int64_t send_time_ms, int64_t send_time_ms,
uint16_t sequence_number, uint16_t sequence_number,
size_t payload_size, size_t payload_size,
bool was_paced) bool was_paced,
int probe_cluster_id)
: PacketInfo(-1, : PacketInfo(-1,
arrival_time_ms, arrival_time_ms,
send_time_ms, send_time_ms,
sequence_number, sequence_number,
payload_size, payload_size,
was_paced) {} was_paced,
probe_cluster_id) {}
PacketInfo(int64_t creation_time_ms, PacketInfo(int64_t creation_time_ms,
int64_t arrival_time_ms, int64_t arrival_time_ms,
int64_t send_time_ms, int64_t send_time_ms,
uint16_t sequence_number, uint16_t sequence_number,
size_t payload_size, size_t payload_size,
bool was_paced) bool was_paced,
int probe_cluster_id)
: creation_time_ms(creation_time_ms), : creation_time_ms(creation_time_ms),
arrival_time_ms(arrival_time_ms), arrival_time_ms(arrival_time_ms),
send_time_ms(send_time_ms), send_time_ms(send_time_ms),
sequence_number(sequence_number), sequence_number(sequence_number),
payload_size(payload_size), payload_size(payload_size),
was_paced(was_paced) {} was_paced(was_paced),
probe_cluster_id(probe_cluster_id) {}
static constexpr int kNotAProbe = -1;
// Time corresponding to when this object was created. // Time corresponding to when this object was created.
int64_t creation_time_ms; int64_t creation_time_ms;
@ -287,6 +299,8 @@ struct PacketInfo {
size_t payload_size; size_t payload_size;
// True if the packet was paced out by the pacer. // True if the packet was paced out by the pacer.
bool was_paced; bool was_paced;
// Which probing cluster this packets belongs to.
int probe_cluster_id;
}; };
class TransportFeedbackObserver { class TransportFeedbackObserver {
@ -298,7 +312,8 @@ class TransportFeedbackObserver {
// must be set to 0. // must be set to 0.
virtual void AddPacket(uint16_t sequence_number, virtual void AddPacket(uint16_t sequence_number,
size_t length, size_t length,
bool was_paced) = 0; bool was_paced,
int probe_cluster_id) = 0;
virtual void OnTransportFeedback(const rtcp::TransportFeedback& feedback) = 0; virtual void OnTransportFeedback(const rtcp::TransportFeedback& feedback) = 0;
}; };

12
webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
View File

@ -131,11 +131,13 @@ class MockRtpRtcp : public RtpRtcp {
const size_t payloadSize, const size_t payloadSize,
const RTPFragmentationHeader* fragmentation, const RTPFragmentationHeader* fragmentation,
const RTPVideoHeader* rtpVideoHdr)); const RTPVideoHeader* rtpVideoHdr));
MOCK_METHOD4(TimeToSendPacket, MOCK_METHOD5(TimeToSendPacket,
bool(uint32_t ssrc, uint16_t sequence_number, int64_t capture_time_ms, bool(uint32_t ssrc,
bool retransmission)); uint16_t sequence_number,
MOCK_METHOD1(TimeToSendPadding, int64_t capture_time_ms,
size_t(size_t bytes)); bool retransmission,
int probe_cluster_id));
MOCK_METHOD2(TimeToSendPadding, size_t(size_t bytes, int probe_cluster_id));
MOCK_METHOD2(RegisterRtcpObservers, MOCK_METHOD2(RegisterRtcpObservers,
void(RtcpIntraFrameObserver* intraFrameCallback, void(RtcpIntraFrameObserver* intraFrameCallback,
RtcpBandwidthObserver* bandwidthCallback)); RtcpBandwidthObserver* bandwidthCallback));

12
webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
View File

@ -428,17 +428,19 @@ int32_t ModuleRtpRtcpImpl::SendOutgoingData(
bool ModuleRtpRtcpImpl::TimeToSendPacket(uint32_t ssrc, bool ModuleRtpRtcpImpl::TimeToSendPacket(uint32_t ssrc,
uint16_t sequence_number, uint16_t sequence_number,
int64_t capture_time_ms, int64_t capture_time_ms,
bool retransmission) { bool retransmission,
int probe_cluster_id) {
if (SendingMedia() && ssrc == rtp_sender_.SSRC()) { if (SendingMedia() && ssrc == rtp_sender_.SSRC()) {
return rtp_sender_.TimeToSendPacket( return rtp_sender_.TimeToSendPacket(sequence_number, capture_time_ms,
sequence_number, capture_time_ms, retransmission); retransmission, probe_cluster_id);
} }
// No RTP sender is interested in sending this packet. // No RTP sender is interested in sending this packet.
return true; return true;
} }
size_t ModuleRtpRtcpImpl::TimeToSendPadding(size_t bytes) { size_t ModuleRtpRtcpImpl::TimeToSendPadding(size_t bytes,
return rtp_sender_.TimeToSendPadding(bytes); int probe_cluster_id) {
return rtp_sender_.TimeToSendPadding(bytes, probe_cluster_id);
} }
uint16_t ModuleRtpRtcpImpl::MaxPayloadLength() const { uint16_t ModuleRtpRtcpImpl::MaxPayloadLength() const {

5
webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
View File

@ -123,11 +123,12 @@ class ModuleRtpRtcpImpl : public RtpRtcp {
bool TimeToSendPacket(uint32_t ssrc, bool TimeToSendPacket(uint32_t ssrc,
uint16_t sequence_number, uint16_t sequence_number,
int64_t capture_time_ms, int64_t capture_time_ms,
bool retransmission) override; bool retransmission,
int probe_cluster_id) override;
// Returns the number of padding bytes actually sent, which can be more or // Returns the number of padding bytes actually sent, which can be more or
// less than |bytes|. // less than |bytes|.
size_t TimeToSendPadding(size_t bytes) override; size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) override;
// RTCP part. // RTCP part.

47
webrtc/modules/rtp_rtcp/source/rtp_sender.cc
View File

@ -543,7 +543,8 @@ int32_t RTPSender::SendOutgoingData(FrameType frame_type,
return ret_val; return ret_val;
} }
size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send) { size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send,
int probe_cluster_id) {
{ {
rtc::CritScope lock(&send_critsect_); rtc::CritScope lock(&send_critsect_);
if (!sending_media_) if (!sending_media_)
@ -561,7 +562,8 @@ size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send) {
&capture_time_ms)) { &capture_time_ms)) {
break; break;
} }
if (!PrepareAndSendPacket(buffer, length, capture_time_ms, true, false)) if (!PrepareAndSendPacket(buffer, length, capture_time_ms, true, false,
probe_cluster_id))
break; break;
RtpUtility::RtpHeaderParser rtp_parser(buffer, length); RtpUtility::RtpHeaderParser rtp_parser(buffer, length);
RTPHeader rtp_header; RTPHeader rtp_header;
@ -590,6 +592,15 @@ size_t RTPSender::SendPadData(size_t bytes,
bool timestamp_provided, bool timestamp_provided,
uint32_t timestamp, uint32_t timestamp,
int64_t capture_time_ms) { int64_t capture_time_ms) {
return SendPadData(bytes, timestamp_provided, timestamp, capture_time_ms,
PacketInfo::kNotAProbe);
}
size_t RTPSender::SendPadData(size_t bytes,
bool timestamp_provided,
uint32_t timestamp,
int64_t capture_time_ms,
int probe_cluster_id) {
// Always send full padding packets. This is accounted for by the // Always send full padding packets. This is accounted for by the
// RtpPacketSender, // RtpPacketSender,
// which will make sure we don't send too much padding even if a single packet // which will make sure we don't send too much padding even if a single packet
@ -677,7 +688,7 @@ size_t RTPSender::SendPadData(size_t bytes,
length, rtp_header)) { length, rtp_header)) {
if (transport_feedback_observer_) if (transport_feedback_observer_)
transport_feedback_observer_->AddPacket(options.packet_id, length, transport_feedback_observer_->AddPacket(options.packet_id, length,
true); true, probe_cluster_id);
} }
} }
@ -733,7 +744,8 @@ int32_t RTPSender::ReSendPacket(uint16_t packet_id, int64_t min_resend_time) {
rtx = rtx_; rtx = rtx_;
} }
if (!PrepareAndSendPacket(data_buffer, length, capture_time_ms, if (!PrepareAndSendPacket(data_buffer, length, capture_time_ms,
(rtx & kRtxRetransmitted) > 0, true)) { (rtx & kRtxRetransmitted) > 0, true,
PacketInfo::kNotAProbe)) {
return -1; return -1;
} }
return static_cast<int32_t>(length); return static_cast<int32_t>(length);
@ -869,7 +881,8 @@ void RTPSender::UpdateNACKBitRate(uint32_t bytes, int64_t now) {
// Called from pacer when we can send the packet. // Called from pacer when we can send the packet.
bool RTPSender::TimeToSendPacket(uint16_t sequence_number, bool RTPSender::TimeToSendPacket(uint16_t sequence_number,
int64_t capture_time_ms, int64_t capture_time_ms,
bool retransmission) { bool retransmission,
int probe_cluster_id) {
size_t length = IP_PACKET_SIZE; size_t length = IP_PACKET_SIZE;
uint8_t data_buffer[IP_PACKET_SIZE]; uint8_t data_buffer[IP_PACKET_SIZE];
int64_t stored_time_ms; int64_t stored_time_ms;
@ -889,18 +902,17 @@ bool RTPSender::TimeToSendPacket(uint16_t sequence_number,
rtc::CritScope lock(&send_critsect_); rtc::CritScope lock(&send_critsect_);
rtx = rtx_; rtx = rtx_;
} }
return PrepareAndSendPacket(data_buffer, return PrepareAndSendPacket(data_buffer, length, capture_time_ms,
length,
capture_time_ms,
retransmission && (rtx & kRtxRetransmitted) > 0, retransmission && (rtx & kRtxRetransmitted) > 0,
retransmission); retransmission, probe_cluster_id);
} }
bool RTPSender::PrepareAndSendPacket(uint8_t* buffer, bool RTPSender::PrepareAndSendPacket(uint8_t* buffer,
size_t length, size_t length,
int64_t capture_time_ms, int64_t capture_time_ms,
bool send_over_rtx, bool send_over_rtx,
bool is_retransmit) { bool is_retransmit,
int probe_cluster_id) {
uint8_t* buffer_to_send_ptr = buffer; uint8_t* buffer_to_send_ptr = buffer;
RtpUtility::RtpHeaderParser rtp_parser(buffer, length); RtpUtility::RtpHeaderParser rtp_parser(buffer, length);
@ -932,8 +944,8 @@ bool RTPSender::PrepareAndSendPacket(uint8_t* buffer,
if (UpdateTransportSequenceNumber(options.packet_id, buffer_to_send_ptr, if (UpdateTransportSequenceNumber(options.packet_id, buffer_to_send_ptr,
length, rtp_header)) { length, rtp_header)) {
if (transport_feedback_observer_) if (transport_feedback_observer_)
transport_feedback_observer_->AddPacket(options.packet_id, length, transport_feedback_observer_->AddPacket(options.packet_id, length, true,
true); probe_cluster_id);
} }
} }
@ -1000,12 +1012,13 @@ bool RTPSender::IsFecPacket(const uint8_t* buffer,
buffer[header.headerLength] == pt_fec; buffer[header.headerLength] == pt_fec;
} }
size_t RTPSender::TimeToSendPadding(size_t bytes) { size_t RTPSender::TimeToSendPadding(size_t bytes, int probe_cluster_id) {
if (audio_configured_ || bytes == 0) if (audio_configured_ || bytes == 0)
return 0; return 0;
size_t bytes_sent = TrySendRedundantPayloads(bytes); size_t bytes_sent = TrySendRedundantPayloads(bytes, probe_cluster_id);
if (bytes_sent < bytes) if (bytes_sent < bytes)
bytes_sent += SendPadData(bytes - bytes_sent, false, 0, 0); bytes_sent +=
SendPadData(bytes - bytes_sent, false, 0, 0, probe_cluster_id);
return bytes_sent; return bytes_sent;
} }
@ -1062,8 +1075,8 @@ int32_t RTPSender::SendToNetwork(uint8_t* buffer,
if (UpdateTransportSequenceNumber(options.packet_id, buffer, length, if (UpdateTransportSequenceNumber(options.packet_id, buffer, length,
rtp_header)) { rtp_header)) {
if (transport_feedback_observer_) if (transport_feedback_observer_)
transport_feedback_observer_->AddPacket(options.packet_id, length, transport_feedback_observer_->AddPacket(options.packet_id, length, true,
true); PacketInfo::kNotAProbe);
} }
} }
UpdateDelayStatistics(capture_time_ms, now_ms); UpdateDelayStatistics(capture_time_ms, now_ms);

19
webrtc/modules/rtp_rtcp/source/rtp_sender.h
View File

@ -211,9 +211,11 @@ class RTPSender : public RTPSenderInterface {
const RTPHeader& rtp_header, const RTPHeader& rtp_header,
VideoRotation rotation) const override; VideoRotation rotation) const override;
bool TimeToSendPacket(uint16_t sequence_number, int64_t capture_time_ms, bool TimeToSendPacket(uint16_t sequence_number,
bool retransmission); int64_t capture_time_ms,
size_t TimeToSendPadding(size_t bytes); bool retransmission,
int probe_cluster_id);
size_t TimeToSendPadding(size_t bytes, int probe_cluster_id);
// NACK. // NACK.
int SelectiveRetransmissions() const; int SelectiveRetransmissions() const;
@ -302,6 +304,12 @@ class RTPSender : public RTPSenderInterface {
uint32_t timestamp, uint32_t timestamp,
int64_t capture_time_ms); int64_t capture_time_ms);
size_t SendPadData(size_t bytes,
bool timestamp_provided,
uint32_t timestamp,
int64_t capture_time_ms,
int probe_cluster_id);
// Called on update of RTP statistics. // Called on update of RTP statistics.
void RegisterRtpStatisticsCallback(StreamDataCountersCallback* callback); void RegisterRtpStatisticsCallback(StreamDataCountersCallback* callback);
StreamDataCountersCallback* GetRtpStatisticsCallback() const; StreamDataCountersCallback* GetRtpStatisticsCallback() const;
@ -337,11 +345,12 @@ class RTPSender : public RTPSenderInterface {
size_t length, size_t length,
int64_t capture_time_ms, int64_t capture_time_ms,
bool send_over_rtx, bool send_over_rtx,
bool is_retransmit); bool is_retransmit,
int probe_cluster_id);
// Return the number of bytes sent. Note that both of these functions may // Return the number of bytes sent. Note that both of these functions may
// return a larger value that their argument. // return a larger value that their argument.
size_t TrySendRedundantPayloads(size_t bytes); size_t TrySendRedundantPayloads(size_t bytes, int probe_cluster_id);
void BuildPaddingPacket(uint8_t* packet, void BuildPaddingPacket(uint8_t* packet,
size_t header_length, size_t header_length,

38
webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
View File

@ -766,7 +766,8 @@ TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
const int kStoredTimeInMs = 100; const int kStoredTimeInMs = 100;
fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false); rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false,
PacketInfo::kNotAProbe);
// Process send bucket. Packet should now be sent. // Process send bucket. Packet should now be sent.
EXPECT_EQ(1, transport_.packets_sent_); EXPECT_EQ(1, transport_.packets_sent_);
@ -825,7 +826,8 @@ TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
EXPECT_EQ(rtp_length_int, rtp_sender_->ReSendPacket(kSeqNum)); EXPECT_EQ(rtp_length_int, rtp_sender_->ReSendPacket(kSeqNum));
EXPECT_EQ(0, transport_.packets_sent_); EXPECT_EQ(0, transport_.packets_sent_);
rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false); rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false,
PacketInfo::kNotAProbe);
// Process send bucket. Packet should now be sent. // Process send bucket. Packet should now be sent.
EXPECT_EQ(1, transport_.packets_sent_); EXPECT_EQ(1, transport_.packets_sent_);
@ -901,7 +903,8 @@ TEST_F(RtpSenderTest, SendPadding) {
const int kStoredTimeInMs = 100; const int kStoredTimeInMs = 100;
fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false); rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false,
PacketInfo::kNotAProbe);
// Packet should now be sent. This test doesn't verify the regular video // Packet should now be sent. This test doesn't verify the regular video
// packet, since it is tested in another test. // packet, since it is tested in another test.
EXPECT_EQ(++total_packets_sent, transport_.packets_sent_); EXPECT_EQ(++total_packets_sent, transport_.packets_sent_);
@ -913,7 +916,8 @@ TEST_F(RtpSenderTest, SendPadding) {
const size_t kPaddingBytes = 100; const size_t kPaddingBytes = 100;
const size_t kMaxPaddingLength = 224; // Value taken from rtp_sender.cc. const size_t kMaxPaddingLength = 224; // Value taken from rtp_sender.cc.
// Padding will be forced to full packets. // Padding will be forced to full packets.
EXPECT_EQ(kMaxPaddingLength, rtp_sender_->TimeToSendPadding(kPaddingBytes)); EXPECT_EQ(kMaxPaddingLength, rtp_sender_->TimeToSendPadding(
kPaddingBytes, PacketInfo::kNotAProbe));
// Process send bucket. Padding should now be sent. // Process send bucket. Padding should now be sent.
EXPECT_EQ(++total_packets_sent, transport_.packets_sent_); EXPECT_EQ(++total_packets_sent, transport_.packets_sent_);
@ -954,7 +958,8 @@ TEST_F(RtpSenderTest, SendPadding) {
capture_time_ms, kAllowRetransmission, capture_time_ms, kAllowRetransmission,
RtpPacketSender::kNormalPriority)); RtpPacketSender::kNormalPriority));
rtp_sender_->TimeToSendPacket(seq_num, capture_time_ms, false); rtp_sender_->TimeToSendPacket(seq_num, capture_time_ms, false,
PacketInfo::kNotAProbe);
// Process send bucket. // Process send bucket.
EXPECT_EQ(++total_packets_sent, transport_.packets_sent_); EXPECT_EQ(++total_packets_sent, transport_.packets_sent_);
EXPECT_EQ(rtp_length, transport_.last_sent_packet_len_); EXPECT_EQ(rtp_length, transport_.last_sent_packet_len_);
@ -987,7 +992,7 @@ TEST_F(RtpSenderTest, OnSendPacketUpdated) {
SendGenericPayload(); // Packet passed to pacer. SendGenericPayload(); // Packet passed to pacer.
const bool kIsRetransmit = false; const bool kIsRetransmit = false;
rtp_sender_->TimeToSendPacket(kSeqNum, fake_clock_.TimeInMilliseconds(), rtp_sender_->TimeToSendPacket(kSeqNum, fake_clock_.TimeInMilliseconds(),
kIsRetransmit); kIsRetransmit, PacketInfo::kNotAProbe);
EXPECT_EQ(1, transport_.packets_sent_); EXPECT_EQ(1, transport_.packets_sent_);
} }
@ -1004,7 +1009,7 @@ TEST_F(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) {
SendGenericPayload(); // Packet passed to pacer. SendGenericPayload(); // Packet passed to pacer.
const bool kIsRetransmit = true; const bool kIsRetransmit = true;
rtp_sender_->TimeToSendPacket(kSeqNum, fake_clock_.TimeInMilliseconds(), rtp_sender_->TimeToSendPacket(kSeqNum, fake_clock_.TimeInMilliseconds(),
kIsRetransmit); kIsRetransmit, PacketInfo::kNotAProbe);
EXPECT_EQ(1, transport_.packets_sent_); EXPECT_EQ(1, transport_.packets_sent_);
} }
@ -1022,7 +1027,7 @@ TEST_F(RtpSenderTest, OnSendPacketNotUpdatedWithoutSeqNumAllocator) {
SendGenericPayload(); // Packet passed to pacer. SendGenericPayload(); // Packet passed to pacer.
const bool kIsRetransmit = false; const bool kIsRetransmit = false;
rtp_sender_->TimeToSendPacket(kSeqNum, fake_clock_.TimeInMilliseconds(), rtp_sender_->TimeToSendPacket(kSeqNum, fake_clock_.TimeInMilliseconds(),
kIsRetransmit); kIsRetransmit, PacketInfo::kNotAProbe);
EXPECT_EQ(1, transport_.packets_sent_); EXPECT_EQ(1, transport_.packets_sent_);
} }
@ -1072,7 +1077,8 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) {
int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
EXPECT_CALL(transport, SendRtp(_, _, _)).WillOnce(testing::Return(true)); EXPECT_CALL(transport, SendRtp(_, _, _)).WillOnce(testing::Return(true));
SendPacket(capture_time_ms, kPayloadSizes[i]); SendPacket(capture_time_ms, kPayloadSizes[i]);
rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false); rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false,
PacketInfo::kNotAProbe);
fake_clock_.AdvanceTimeMilliseconds(33); fake_clock_.AdvanceTimeMilliseconds(33);
} }
@ -1083,12 +1089,14 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) {
// The amount of padding to send it too small to send a payload packet. // The amount of padding to send it too small to send a payload packet.
EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _)) EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _))
.WillOnce(testing::Return(true)); .WillOnce(testing::Return(true));
EXPECT_EQ(kMaxPaddingSize, rtp_sender_->TimeToSendPadding(49)); EXPECT_EQ(kMaxPaddingSize,
rtp_sender_->TimeToSendPadding(49, PacketInfo::kNotAProbe));
EXPECT_CALL(transport, EXPECT_CALL(transport,
SendRtp(_, kPayloadSizes[0] + rtp_header_len + kRtxHeaderSize, _)) SendRtp(_, kPayloadSizes[0] + rtp_header_len + kRtxHeaderSize, _))
.WillOnce(testing::Return(true)); .WillOnce(testing::Return(true));
EXPECT_EQ(kPayloadSizes[0], rtp_sender_->TimeToSendPadding(500)); EXPECT_EQ(kPayloadSizes[0],
rtp_sender_->TimeToSendPadding(500, PacketInfo::kNotAProbe));
EXPECT_CALL(transport, SendRtp(_, kPayloadSizes[kNumPayloadSizes - 1] + EXPECT_CALL(transport, SendRtp(_, kPayloadSizes[kNumPayloadSizes - 1] +
rtp_header_len + kRtxHeaderSize, rtp_header_len + kRtxHeaderSize,
@ -1097,7 +1105,7 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) {
EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _)) EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _))
.WillOnce(testing::Return(true)); .WillOnce(testing::Return(true));
EXPECT_EQ(kPayloadSizes[kNumPayloadSizes - 1] + kMaxPaddingSize, EXPECT_EQ(kPayloadSizes[kNumPayloadSizes - 1] + kMaxPaddingSize,
rtp_sender_->TimeToSendPadding(999)); rtp_sender_->TimeToSendPadding(999, PacketInfo::kNotAProbe));
} }
TEST_F(RtpSenderTestWithoutPacer, SendGenericVideo) { TEST_F(RtpSenderTestWithoutPacer, SendGenericVideo) {
@ -1360,7 +1368,7 @@ TEST_F(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) {
callback.Matches(ssrc, expected); callback.Matches(ssrc, expected);
// Send padding. // Send padding.
rtp_sender_->TimeToSendPadding(kMaxPaddingSize); rtp_sender_->TimeToSendPadding(kMaxPaddingSize, PacketInfo::kNotAProbe);
expected.transmitted.payload_bytes = 12; expected.transmitted.payload_bytes = 12;
expected.transmitted.header_bytes = 36; expected.transmitted.header_bytes = 36;
expected.transmitted.padding_bytes = kMaxPaddingSize; expected.transmitted.padding_bytes = kMaxPaddingSize;
@ -1517,8 +1525,8 @@ TEST_F(RtpSenderTestWithoutPacer, BytesReportedCorrectly) {
payload, sizeof(payload), 0)); payload, sizeof(payload), 0));
// Will send 2 full-size padding packets. // Will send 2 full-size padding packets.
rtp_sender_->TimeToSendPadding(1); rtp_sender_->TimeToSendPadding(1, PacketInfo::kNotAProbe);
rtp_sender_->TimeToSendPadding(1); rtp_sender_->TimeToSendPadding(1, PacketInfo::kNotAProbe);
StreamDataCounters rtp_stats; StreamDataCounters rtp_stats;
StreamDataCounters rtx_stats; StreamDataCounters rtx_stats;

6
webrtc/voice_engine/channel.cc
View File

@ -75,11 +75,13 @@ class TransportFeedbackProxy : public TransportFeedbackObserver {
// Implements TransportFeedbackObserver. // Implements TransportFeedbackObserver.
void AddPacket(uint16_t sequence_number, void AddPacket(uint16_t sequence_number,
size_t length, size_t length,
bool was_paced) override { bool was_paced,
int probe_cluster_id) override {
RTC_DCHECK(pacer_thread_.CalledOnValidThread()); RTC_DCHECK(pacer_thread_.CalledOnValidThread());
rtc::CritScope lock(&crit_); rtc::CritScope lock(&crit_);
if (feedback_observer_) if (feedback_observer_)
feedback_observer_->AddPacket(sequence_number, length, was_paced); feedback_observer_->AddPacket(sequence_number, length, was_paced,
probe_cluster_id);
} }
void OnTransportFeedback(const rtcp::TransportFeedback& feedback) override { void OnTransportFeedback(const rtcp::TransportFeedback& feedback) override {
RTC_DCHECK(network_thread_.CalledOnValidThread()); RTC_DCHECK(network_thread_.CalledOnValidThread());