admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Propagate packet pacing information to SendTimeHistory.

Browse Source 
In order to not make this CL too large I have broken it down into at least two
steps. Previous CL: https://codereview.chromium.org/2628563003/

webrtc::PacedSender::Process                        <--- previous CL start here
webrtc::PacedSender::SendPacket
webrtc::PacketRouter::TimeToSendPacket
webrtc::ModuleRtpRtcpImpl::TimeToSendPacket         <--- previous CL end here, this Cl start here
webrtc::RTPSender::TimeToSendPacket
webrtc::RTPSender::PrepareAndSendPacket
webrtc::RTPSender::AddPacketToTransportFeedback
webrtc::TransportFeedbackAdapter::AddPacket
webrtc::SendTimeHistory::AddAndRemoveOld            <--- this CL end here

BUG=webrtc:6822

Review-Url: https://codereview.webrtc.org/2708873003
Cr-Commit-Position: refs/heads/master@{#16796}
This commit is contained in:
philipel 2017-02-23 02:56:13 -08:00 committed by Commit bot
parent 7adadb1fdf
commit 8aadd50b96
22 changed files with 240 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
webrtc/modules/congestion_controller/delay_based_bwe.cc
View File

@ -361,7 +361,7 @@ DelayBasedBwe::Result DelayBasedBwe::IncomingPacketInfo(
}
int probing_bps = 0;
if (info.probe_cluster_id != PacedPacketInfo::kNotAProbe) {
if (info.pacing_info.probe_cluster_id != PacedPacketInfo::kNotAProbe) {
probing_bps = probe_bitrate_estimator_.HandleProbeAndEstimateBitrate(info);
}
rtc::Optional<uint32_t> acked_bitrate_bps =

18
webrtc/modules/congestion_controller/delay_based_bwe_unittest.cc
View File

@ -19,7 +19,8 @@
namespace webrtc {
namespace {
const PacedPacketInfo kPacingInfo0(0, 5, 2000);
const PacedPacketInfo kPacingInfo1(1, 8, 4000);
constexpr int kNumProbes = 5;
} // namespace
@ -31,7 +32,7 @@ TEST_F(DelayBasedBweTest, ProbeDetection) {
for (int i = 0; i < kNumProbes; ++i) {
clock_.AdvanceTimeMilliseconds(10);
now_ms = clock_.TimeInMilliseconds();
IncomingFeedback(now_ms, now_ms, seq_num++, 1000, 0);
IncomingFeedback(now_ms, now_ms, seq_num++, 1000, kPacingInfo0);
}
EXPECT_TRUE(bitrate_observer_.updated());
@ -39,7 +40,7 @@ TEST_F(DelayBasedBweTest, ProbeDetection) {
for (int i = 0; i < kNumProbes; ++i) {
clock_.AdvanceTimeMilliseconds(5);
now_ms = clock_.TimeInMilliseconds();
IncomingFeedback(now_ms, now_ms, seq_num++, 1000, 1);
IncomingFeedback(now_ms, now_ms, seq_num++, 1000, kPacingInfo1);
}
EXPECT_TRUE(bitrate_observer_.updated());
@ -54,11 +55,10 @@ TEST_F(DelayBasedBweTest, ProbeDetectionNonPacedPackets) {
for (int i = 0; i < kNumProbes; ++i) {
clock_.AdvanceTimeMilliseconds(5);
now_ms = clock_.TimeInMilliseconds();
IncomingFeedback(now_ms, now_ms, seq_num++, 1000, 0);
IncomingFeedback(now_ms, now_ms, seq_num++, 1000, kPacingInfo0);
// Non-paced packet, arriving 5 ms after.
clock_.AdvanceTimeMilliseconds(5);
IncomingFeedback(now_ms, now_ms, seq_num++, 100,
PacedPacketInfo::kNotAProbe);
IncomingFeedback(now_ms, now_ms, seq_num++, 100, PacedPacketInfo());
}
EXPECT_TRUE(bitrate_observer_.updated());
@ -75,7 +75,7 @@ TEST_F(DelayBasedBweTest, ProbeDetectionFasterArrival) {
clock_.AdvanceTimeMilliseconds(1);
send_time_ms += 10;
now_ms = clock_.TimeInMilliseconds();
IncomingFeedback(now_ms, send_time_ms, seq_num++, 1000, 0);
IncomingFeedback(now_ms, send_time_ms, seq_num++, 1000, kPacingInfo0);
}
EXPECT_FALSE(bitrate_observer_.updated());
@ -91,7 +91,7 @@ TEST_F(DelayBasedBweTest, ProbeDetectionSlowerArrival) {
clock_.AdvanceTimeMilliseconds(7);
send_time_ms += 5;
now_ms = clock_.TimeInMilliseconds();
IncomingFeedback(now_ms, send_time_ms, seq_num++, 1000, 1);
IncomingFeedback(now_ms, send_time_ms, seq_num++, 1000, kPacingInfo1);
}
EXPECT_TRUE(bitrate_observer_.updated());
@ -108,7 +108,7 @@ TEST_F(DelayBasedBweTest, ProbeDetectionSlowerArrivalHighBitrate) {
clock_.AdvanceTimeMilliseconds(2);
send_time_ms += 1;
now_ms = clock_.TimeInMilliseconds();
IncomingFeedback(now_ms, send_time_ms, seq_num++, 1000, 1);
IncomingFeedback(now_ms, send_time_ms, seq_num++, 1000, kPacingInfo1);
}
EXPECT_TRUE(bitrate_observer_.updated());

21
webrtc/modules/congestion_controller/delay_based_bwe_unittest_helper.cc
View File

@ -60,7 +60,6 @@ int64_t RtpStream::GenerateFrame(int64_t time_now_us,
PacketInfo packet(-1, sequence_number_++);
packet.send_time_ms = (time_now_us + kSendSideOffsetUs) / 1000;
packet.payload_size = payload_size;
packet.probe_cluster_id = PacedPacketInfo::kNotAProbe;
packets->push_back(packet);
}
next_rtp_time_ = time_now_us + (1000000 + fps_ / 2) / fps_;
@ -169,17 +168,17 @@ void DelayBasedBweTest::IncomingFeedback(int64_t arrival_time_ms,
uint16_t sequence_number,
size_t payload_size) {
IncomingFeedback(arrival_time_ms, send_time_ms, sequence_number, payload_size,
PacedPacketInfo::kNotAProbe);
PacedPacketInfo());
}
void DelayBasedBweTest::IncomingFeedback(int64_t arrival_time_ms,
int64_t send_time_ms,
uint16_t sequence_number,
size_t payload_size,
int probe_cluster_id) {
const PacedPacketInfo& pacing_info) {
RTC_CHECK_GE(arrival_time_ms + arrival_time_offset_ms_, 0);
PacketInfo packet(arrival_time_ms + arrival_time_offset_ms_, send_time_ms,
sequence_number, payload_size, probe_cluster_id);
sequence_number, payload_size, pacing_info);
std::vector<PacketInfo> packets;
packets.push_back(packet);
DelayBasedBwe::Result result =
@ -265,6 +264,7 @@ void DelayBasedBweTest::InitialBehaviorTestHelper(
uint32_t expected_converge_bitrate) {
const int kFramerate = 50; // 50 fps to avoid rounding errors.
const int kFrameIntervalMs = 1000 / kFramerate;
const PacedPacketInfo kPacingInfo(0, 1, 100);
uint32_t bitrate_bps = 0;
int64_t send_time_ms = 0;
uint16_t sequence_number = 0;
@ -280,8 +280,8 @@ void DelayBasedBweTest::InitialBehaviorTestHelper(
for (int i = 0; i < 5 * kFramerate + 1 + kNumInitialPackets; ++i) {
// NOTE!!! If the following line is moved under the if case then this test
// wont work on windows realease bots.
int cluster_id =
i < kInitialProbingPackets ? 0 : PacedPacketInfo::kNotAProbe;
PacedPacketInfo pacing_info =
i < kInitialProbingPackets ? kPacingInfo : PacedPacketInfo();
if (i == kNumInitialPackets) {
EXPECT_FALSE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps));
@ -290,7 +290,7 @@ void DelayBasedBweTest::InitialBehaviorTestHelper(
bitrate_observer_.Reset();
}
IncomingFeedback(clock_.TimeInMilliseconds(), send_time_ms,
sequence_number++, kMtu, cluster_id);
sequence_number++, kMtu, pacing_info);
clock_.AdvanceTimeMilliseconds(1000 / kFramerate);
send_time_ms += kFrameIntervalMs;
}
@ -307,14 +307,15 @@ void DelayBasedBweTest::RateIncreaseReorderingTestHelper(
uint32_t expected_bitrate_bps) {
const int kFramerate = 50; // 50 fps to avoid rounding errors.
const int kFrameIntervalMs = 1000 / kFramerate;
const PacedPacketInfo kPacingInfo(0, 1, 100);
int64_t send_time_ms = 0;
uint16_t sequence_number = 0;
// Inserting packets for five seconds to get a valid estimate.
for (int i = 0; i < 5 * kFramerate + 1 + kNumInitialPackets; ++i) {
// NOTE!!! If the following line is moved under the if case then this test
// wont work on windows realease bots.
int cluster_id =
i < kInitialProbingPackets ? 0 : PacedPacketInfo::kNotAProbe;
PacedPacketInfo pacing_info =
i < kInitialProbingPackets ? kPacingInfo : PacedPacketInfo();
// TODO(sprang): Remove this hack once the single stream estimator is gone,
// as it doesn't do anything in Process().
@ -324,7 +325,7 @@ void DelayBasedBweTest::RateIncreaseReorderingTestHelper(
EXPECT_FALSE(bitrate_observer_.updated()); // No valid estimate.
}
IncomingFeedback(clock_.TimeInMilliseconds(), send_time_ms,
sequence_number++, kMtu, cluster_id);
sequence_number++, kMtu, pacing_info);
clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
send_time_ms += kFrameIntervalMs;
}

2
webrtc/modules/congestion_controller/delay_based_bwe_unittest_helper.h
View File

@ -125,7 +125,7 @@ class DelayBasedBweTest : public ::testing::Test {
int64_t send_time_ms,
uint16_t sequence_number,
size_t payload_size,
int probe_cluster_id);
const PacedPacketInfo& pacing_info);
// Generates a frame of packets belonging to a stream at a given bitrate and
// with a given ssrc. The stream is pushed through a very simple simulated

17
webrtc/modules/congestion_controller/probe_bitrate_estimator.cc
View File

@ -38,12 +38,13 @@ ProbeBitrateEstimator::ProbeBitrateEstimator() {}
int ProbeBitrateEstimator::HandleProbeAndEstimateBitrate(
const PacketInfo& packet_info) {
RTC_DCHECK_NE(packet_info.probe_cluster_id, PacedPacketInfo::kNotAProbe);
int cluster_id = packet_info.pacing_info.probe_cluster_id;
RTC_DCHECK_NE(cluster_id, PacedPacketInfo::kNotAProbe);
EraseOldClusters(packet_info.arrival_time_ms - kMaxClusterHistoryMs);
int payload_size_bits = packet_info.payload_size * 8;
AggregatedCluster* cluster = &clusters_[packet_info.probe_cluster_id];
AggregatedCluster* cluster = &clusters_[cluster_id];
if (packet_info.send_time_ms < cluster->first_send_ms) {
cluster->first_send_ms = packet_info.send_time_ms;
@ -72,7 +73,7 @@ int ProbeBitrateEstimator::HandleProbeAndEstimateBitrate(
if (send_interval_ms <= 0 || send_interval_ms > kMaxProbeIntervalMs ||
receive_interval_ms <= 0 || receive_interval_ms > kMaxProbeIntervalMs) {
LOG(LS_INFO) << "Probing unsuccessful, invalid send/receive interval"
<< " [cluster id: " << packet_info.probe_cluster_id
<< " [cluster id: " << cluster_id
<< "] [send interval: " << send_interval_ms << " ms]"
<< " [receive interval: " << receive_interval_ms << " ms]";
return -1;
@ -94,8 +95,8 @@ int ProbeBitrateEstimator::HandleProbeAndEstimateBitrate(
float ratio = receive_bps / send_bps;
if (ratio > kValidRatio) {
LOG(LS_INFO) << "Probing unsuccessful, receive/send ratio too high"
<< " [cluster id: " << packet_info.probe_cluster_id
<< "] [send: " << send_size << " bytes / " << send_interval_ms
<< " [cluster id: " << cluster_id << "] [send: " << send_size
<< " bytes / " << send_interval_ms
<< " ms = " << send_bps / 1000 << " kb/s]"
<< " [receive: " << receive_size << " bytes / "
<< receive_interval_ms << " ms = " << receive_bps / 1000
@ -106,9 +107,9 @@ int ProbeBitrateEstimator::HandleProbeAndEstimateBitrate(
return -1;
}
LOG(LS_INFO) << "Probing successful"
<< " [cluster id: " << packet_info.probe_cluster_id
<< "] [send: " << send_size << " bytes / " << send_interval_ms
<< " ms = " << send_bps / 1000 << " kb/s]"
<< " [cluster id: " << cluster_id << "] [send: " << send_size
<< " bytes / " << send_interval_ms << " ms = " << send_bps / 1000
<< " kb/s]"
<< " [receive: " << receive_size << " bytes / "
<< receive_interval_ms << " ms = " << receive_bps / 1000
<< " kb/s]";

4
webrtc/modules/congestion_controller/probe_bitrate_estimator_unittest.cc
View File

@ -25,12 +25,14 @@ class TestProbeBitrateEstimator : public ::testing::Test {
public:
TestProbeBitrateEstimator() : probe_bitrate_estimator_() {}
// TODO(philipel): Use PacedPacketInfo when ProbeBitrateEstimator is rewritten
// to use that information.
void AddPacketFeedback(int probe_cluster_id,
size_t size_bytes,
int64_t send_time_ms,
int64_t arrival_time_ms) {
PacketInfo info(arrival_time_ms, send_time_ms, 0, size_bytes,
probe_cluster_id);
PacedPacketInfo(probe_cluster_id, -1, -1));
measured_bps_ =
probe_bitrate_estimator_.HandleProbeAndEstimateBitrate(info);
}

4
webrtc/modules/congestion_controller/transport_feedback_adapter.cc
View File

@ -65,12 +65,12 @@ void TransportFeedbackAdapter::InitBwe() {
void TransportFeedbackAdapter::AddPacket(uint16_t sequence_number,
size_t length,
int probe_cluster_id) {
const PacedPacketInfo& pacing_info) {
rtc::CritScope cs(&lock_);
if (send_side_bwe_with_overhead_) {
length += transport_overhead_bytes_per_packet_;
}
send_time_history_.AddAndRemoveOld(sequence_number, length, probe_cluster_id);
send_time_history_.AddAndRemoveOld(sequence_number, length, pacing_info);
}
void TransportFeedbackAdapter::OnSentPacket(uint16_t sequence_number,

2
webrtc/modules/congestion_controller/transport_feedback_adapter.h
View File

@ -39,7 +39,7 @@ class TransportFeedbackAdapter : public TransportFeedbackObserver,
// Implements TransportFeedbackObserver.
void AddPacket(uint16_t sequence_number,
size_t length,
int probe_cluster_id) override;
const PacedPacketInfo& pacing_info) override;
void OnSentPacket(uint16_t sequence_number, int64_t send_time_ms);
// TODO(holmer): This method should return DelayBasedBwe::Result so that we

89
webrtc/modules/congestion_controller/transport_feedback_adapter_unittest.cc
View File

@ -26,6 +26,15 @@ using ::testing::_;
using ::testing::Invoke;
namespace webrtc {
namespace {
const PacedPacketInfo kPacingInfo0(0, 5, 2000);
const PacedPacketInfo kPacingInfo1(1, 8, 4000);
const PacedPacketInfo kPacingInfo2(2, 14, 7000);
const PacedPacketInfo kPacingInfo3(3, 20, 10000);
const PacedPacketInfo kPacingInfo4(4, 22, 10000);
}
namespace test {
class TransportFeedbackAdapterTest : public ::testing::Test {
@ -86,15 +95,16 @@ class TransportFeedbackAdapterTest : public ::testing::Test {
EXPECT_EQ(truth[i].send_time_ms, input[i].send_time_ms);
EXPECT_EQ(truth[i].sequence_number, input[i].sequence_number);
EXPECT_EQ(truth[i].payload_size, input[i].payload_size);
EXPECT_EQ(truth[i].probe_cluster_id, input[i].probe_cluster_id);
EXPECT_EQ(truth[i].pacing_info, input[i].pacing_info);
}
}
// Utility method, to reset arrival_time_ms before adding send time.
void OnSentPacket(PacketInfo info) {
info.arrival_time_ms = 0;
// TODO(philipel): Change -1, -1 to some values.
adapter_->AddPacket(info.sequence_number, info.payload_size,
info.probe_cluster_id);
info.pacing_info);
adapter_->OnSentPacket(info.sequence_number, info.send_time_ms);
}
@ -107,11 +117,11 @@ class TransportFeedbackAdapterTest : public ::testing::Test {
TEST_F(TransportFeedbackAdapterTest, AdaptsFeedbackAndPopulatesSendTimes) {
std::vector<PacketInfo> packets;
packets.push_back(PacketInfo(100, 200, 0, 1500, 0));
packets.push_back(PacketInfo(110, 210, 1, 1500, 0));
packets.push_back(PacketInfo(120, 220, 2, 1500, 0));
packets.push_back(PacketInfo(130, 230, 3, 1500, 1));
packets.push_back(PacketInfo(140, 240, 4, 1500, 1));
packets.push_back(PacketInfo(100, 200, 0, 1500, kPacingInfo0));
packets.push_back(PacketInfo(110, 210, 1, 1500, kPacingInfo0));
packets.push_back(PacketInfo(120, 220, 2, 1500, kPacingInfo0));
packets.push_back(PacketInfo(130, 230, 3, 1500, kPacingInfo1));
packets.push_back(PacketInfo(140, 240, 4, 1500, kPacingInfo1));
for (const PacketInfo& packet : packets)
OnSentPacket(packet);
@ -136,11 +146,15 @@ TEST_F(TransportFeedbackAdapterTest, LongFeedbackDelays) {
const int kMaxConsecutiveFailedLookups = 5;
for (int i = 0; i < kMaxConsecutiveFailedLookups; ++i) {
std::vector<PacketInfo> packets;
packets.push_back(PacketInfo(i * 100, 2 * i * 100, 0, 1500, 0));
packets.push_back(PacketInfo(i * 100 + 10, 2 * i * 100 + 10, 1, 1500, 0));
packets.push_back(PacketInfo(i * 100 + 20, 2 * i * 100 + 20, 2, 1500, 0));
packets.push_back(PacketInfo(i * 100 + 30, 2 * i * 100 + 30, 3, 1500, 1));
packets.push_back(PacketInfo(i * 100 + 40, 2 * i * 100 + 40, 4, 1500, 1));
packets.push_back(PacketInfo(i * 100, 2 * i * 100, 0, 1500, kPacingInfo0));
packets.push_back(
PacketInfo(i * 100 + 10, 2 * i * 100 + 10, 1, 1500, kPacingInfo0));
packets.push_back(
PacketInfo(i * 100 + 20, 2 * i * 100 + 20, 2, 1500, kPacingInfo0));
packets.push_back(
PacketInfo(i * 100 + 30, 2 * i * 100 + 30, 3, 1500, kPacingInfo1));
packets.push_back(
PacketInfo(i * 100 + 40, 2 * i * 100 + 40, 4, 1500, kPacingInfo1));
for (const PacketInfo& packet : packets)
OnSentPacket(packet);
@ -158,7 +172,8 @@ TEST_F(TransportFeedbackAdapterTest, LongFeedbackDelays) {
clock_.AdvanceTimeMilliseconds(kFeedbackTimeoutMs);
PacketInfo later_packet(kFeedbackTimeoutMs + i * 100 + 40,
kFeedbackTimeoutMs + i * 200 + 40, 5, 1500, 1);
kFeedbackTimeoutMs + i * 200 + 40, 5, 1500,
kPacingInfo1);
OnSentPacket(later_packet);
adapter_->OnTransportFeedback(feedback);
@ -167,7 +182,7 @@ TEST_F(TransportFeedbackAdapterTest, LongFeedbackDelays) {
for (PacketInfo& packet : packets) {
packet.send_time_ms = -1;
packet.payload_size = 0;
packet.probe_cluster_id = -1;
packet.pacing_info = PacedPacketInfo();
}
ComparePacketVectors(packets, adapter_->GetTransportFeedbackVector());
}
@ -178,11 +193,11 @@ TEST_F(TransportFeedbackAdapterTest, LongFeedbackDelays) {
// Test with feedback that isn't late enough to time out.
{
std::vector<PacketInfo> packets;
packets.push_back(PacketInfo(100, 200, 0, 1500, 0));
packets.push_back(PacketInfo(110, 210, 1, 1500, 0));
packets.push_back(PacketInfo(120, 220, 2, 1500, 0));
packets.push_back(PacketInfo(130, 230, 3, 1500, 1));
packets.push_back(PacketInfo(140, 240, 4, 1500, 1));
packets.push_back(PacketInfo(100, 200, 0, 1500, kPacingInfo0));
packets.push_back(PacketInfo(110, 210, 1, 1500, kPacingInfo0));
packets.push_back(PacketInfo(120, 220, 2, 1500, kPacingInfo0));
packets.push_back(PacketInfo(130, 230, 3, 1500, kPacingInfo1));
packets.push_back(PacketInfo(140, 240, 4, 1500, kPacingInfo1));
for (const PacketInfo& packet : packets)
OnSentPacket(packet);
@ -200,7 +215,7 @@ TEST_F(TransportFeedbackAdapterTest, LongFeedbackDelays) {
clock_.AdvanceTimeMilliseconds(kFeedbackTimeoutMs - 1);
PacketInfo later_packet(kFeedbackTimeoutMs + 140, kFeedbackTimeoutMs + 240,
5, 1500, 1);
5, 1500, kPacingInfo1);
OnSentPacket(later_packet);
adapter_->OnTransportFeedback(feedback);
@ -210,11 +225,11 @@ TEST_F(TransportFeedbackAdapterTest, LongFeedbackDelays) {
TEST_F(TransportFeedbackAdapterTest, HandlesDroppedPackets) {
std::vector<PacketInfo> packets;
packets.push_back(PacketInfo(100, 200, 0, 1500, 1));
packets.push_back(PacketInfo(110, 210, 1, 1500, 2));
packets.push_back(PacketInfo(120, 220, 2, 1500, 3));
packets.push_back(PacketInfo(130, 230, 3, 1500, 4));
packets.push_back(PacketInfo(140, 240, 4, 1500, 5));
packets.push_back(PacketInfo(100, 200, 0, 1500, kPacingInfo0));
packets.push_back(PacketInfo(110, 210, 1, 1500, kPacingInfo1));
packets.push_back(PacketInfo(120, 220, 2, 1500, kPacingInfo2));
packets.push_back(PacketInfo(130, 230, 3, 1500, kPacingInfo3));
packets.push_back(PacketInfo(140, 240, 4, 1500, kPacingInfo4));
const uint16_t kSendSideDropBefore = 1;
const uint16_t kReceiveSideDropAfter = 3;
@ -243,8 +258,8 @@ TEST_F(TransportFeedbackAdapterTest, HandlesDroppedPackets) {
// information stored on the send-side.
for (size_t i = 0; i < kSendSideDropBefore; ++i) {
expected_packets[i].send_time_ms = -1;
expected_packets[i].probe_cluster_id = -1;
expected_packets[i].payload_size = 0;
expected_packets[i].pacing_info = PacedPacketInfo();
}
adapter_->OnTransportFeedback(feedback);
@ -257,12 +272,12 @@ TEST_F(TransportFeedbackAdapterTest, SendTimeWrapsBothWays) {
static_cast<int64_t>(1 << 8) *
static_cast<int64_t>((1 << 23) - 1) / 1000;
std::vector<PacketInfo> packets;
packets.push_back(PacketInfo(kHighArrivalTimeMs - 64, 200, 0, 1500,
PacedPacketInfo::kNotAProbe));
packets.push_back(PacketInfo(kHighArrivalTimeMs + 64, 210, 1, 1500,
PacedPacketInfo::kNotAProbe));
packets.push_back(PacketInfo(kHighArrivalTimeMs, 220, 2, 1500,
PacedPacketInfo::kNotAProbe));
packets.push_back(
PacketInfo(kHighArrivalTimeMs - 64, 200, 0, 1500, PacedPacketInfo()));
packets.push_back(
PacketInfo(kHighArrivalTimeMs + 64, 210, 1, 1500, PacedPacketInfo()));
packets.push_back(
PacketInfo(kHighArrivalTimeMs, 220, 2, 1500, PacedPacketInfo()));
for (const PacketInfo& packet : packets)
OnSentPacket(packet);
@ -291,9 +306,9 @@ TEST_F(TransportFeedbackAdapterTest, SendTimeWrapsBothWays) {
TEST_F(TransportFeedbackAdapterTest, HandlesReordering) {
std::vector<PacketInfo> packets;
packets.push_back(PacketInfo(120, 200, 0, 1500, 0));
packets.push_back(PacketInfo(110, 210, 1, 1500, 0));
packets.push_back(PacketInfo(100, 220, 2, 1500, 0));
packets.push_back(PacketInfo(120, 200, 0, 1500, kPacingInfo0));
packets.push_back(PacketInfo(110, 210, 1, 1500, kPacingInfo0));
packets.push_back(PacketInfo(100, 220, 2, 1500, kPacingInfo0));
std::vector<PacketInfo> expected_packets;
expected_packets.push_back(packets[2]);
expected_packets.push_back(packets[1]);
@ -329,7 +344,7 @@ TEST_F(TransportFeedbackAdapterTest, TimestampDeltas) {
rtcp::TransportFeedback::kDeltaScaleFactor *
std::numeric_limits<int16_t>::min();
PacketInfo info(100, 200, 0, 1500, true, PacedPacketInfo::kNotAProbe);
PacketInfo info(100, 200, 0, 1500, true, PacedPacketInfo());
sent_packets.push_back(info);
info.send_time_ms += kSmallDeltaUs / 1000;
@ -418,7 +433,7 @@ TEST_F(TransportFeedbackAdapterTest, UpdatesDelayBasedEstimate) {
int64_t start_time_ms = clock_.TimeInMilliseconds();
while (clock_.TimeInMilliseconds() - start_time_ms < kRunTimeMs) {
PacketInfo packet(clock_.TimeInMilliseconds(), clock_.TimeInMilliseconds(),
seq_num, kPayloadSize, PacedPacketInfo::kNotAProbe);
seq_num, kPayloadSize, PacedPacketInfo());
OnSentPacket(packet);
// Create expected feedback and send into adapter.
std::unique_ptr<rtcp::TransportFeedback> feedback(

7
webrtc/modules/include/module_common_types.h
View File

@ -538,6 +538,13 @@ struct PacedPacketInfo {
probe_cluster_min_probes(probe_cluster_min_probes),
probe_cluster_min_bytes(probe_cluster_min_bytes) {}
bool operator==(const PacedPacketInfo& rhs) const {
return send_bitrate_bps == rhs.send_bitrate_bps &&
probe_cluster_id == rhs.probe_cluster_id &&
probe_cluster_min_probes == rhs.probe_cluster_min_probes &&
probe_cluster_min_bytes == rhs.probe_cluster_min_bytes;
}
static constexpr int kNotAProbe = -1;
int send_bitrate_bps = -1;
int probe_cluster_id = kNotAProbe;

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

@ -31,7 +31,7 @@ class SendTimeHistory {
// Cleanup old entries, then add new packet info with provided parameters.
void AddAndRemoveOld(uint16_t sequence_number,
size_t payload_size,
int probe_cluster_id);
const PacedPacketInfo& pacing_info);
// Updates packet info identified by |sequence_number| with |send_time_ms|.
// Return false if not found.

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

@ -27,7 +27,7 @@ void SendTimeHistory::Clear() {
void SendTimeHistory::AddAndRemoveOld(uint16_t sequence_number,
size_t payload_size,
int probe_cluster_id) {
const PacedPacketInfo& pacing_info) {
int64_t now_ms = clock_->TimeInMilliseconds();
// Remove old.
while (!history_.empty() &&
@ -45,7 +45,7 @@ void SendTimeHistory::AddAndRemoveOld(uint16_t sequence_number,
history_.insert(std::make_pair(
unwrapped_seq_num,
PacketInfo(creation_time_ms, kNoArrivalTimeMs, kNoSendTimeMs,
sequence_number, payload_size, probe_cluster_id)));
sequence_number, payload_size, pacing_info)));
}
bool SendTimeHistory::OnSentPacket(uint16_t sequence_number,

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

@ -35,8 +35,8 @@ class SendTimeHistoryTest : public ::testing::Test {
void AddPacketWithSendTime(uint16_t sequence_number,
size_t length,
int64_t send_time_ms,
int probe_cluster_id) {
history_.AddAndRemoveOld(sequence_number, length, probe_cluster_id);
const PacedPacketInfo& pacing_info) {
history_.AddAndRemoveOld(sequence_number, length, pacing_info);
history_.OnSentPacket(sequence_number, send_time_ms);
}
@ -44,50 +44,22 @@ class SendTimeHistoryTest : public ::testing::Test {
SendTimeHistory history_;
};
// Help class extended so we can do EXPECT_EQ and collections.
class PacketInfo : public webrtc::PacketInfo {
public:
PacketInfo(int64_t arrival_time_ms, uint16_t sequence_number)
: PacketInfo(arrival_time_ms,
0,
sequence_number,
0,
PacedPacketInfo::kNotAProbe) {}
PacketInfo(int64_t arrival_time_ms,
int64_t send_time_ms,
uint16_t sequence_number,
size_t payload_size,
int probe_cluster_id)
: webrtc::PacketInfo(-1,
arrival_time_ms,
send_time_ms,
sequence_number,
payload_size,
probe_cluster_id) {}
bool operator==(const PacketInfo& other) const {
return arrival_time_ms == other.arrival_time_ms &&
send_time_ms == other.send_time_ms &&
sequence_number == other.sequence_number &&
payload_size == other.payload_size &&
probe_cluster_id == other.probe_cluster_id;
}
};
TEST_F(SendTimeHistoryTest, AddRemoveOne) {
const uint16_t kSeqNo = 10;
const int kProbeClusterId = 0;
const PacketInfo kSentPacket(0, 1, kSeqNo, 1, kProbeClusterId);
AddPacketWithSendTime(kSeqNo, 1, 1, kProbeClusterId);
// TODO(philipel): Fix PacedPacketInfo constructor?
const PacedPacketInfo kPacingInfo(0, 5, 1200);
const PacketInfo kSentPacket(0, 1, kSeqNo, 1, kPacingInfo);
AddPacketWithSendTime(kSeqNo, 1, 1, kPacingInfo);
PacketInfo received_packet(0, 0, kSeqNo, 0, kProbeClusterId);
PacketInfo received_packet(0, 0, kSeqNo, 0, kPacingInfo);
EXPECT_TRUE(history_.GetInfo(&received_packet, false));
EXPECT_EQ(kSentPacket, received_packet);
PacketInfo received_packet2(0, 0, kSeqNo, 0, kProbeClusterId);
PacketInfo received_packet2(0, 0, kSeqNo, 0, kPacingInfo);
EXPECT_TRUE(history_.GetInfo(&received_packet2, true));
EXPECT_EQ(kSentPacket, received_packet2);
PacketInfo received_packet3(0, 0, kSeqNo, 0, kProbeClusterId);
PacketInfo received_packet3(0, 0, kSeqNo, 0, kPacingInfo);
EXPECT_FALSE(history_.GetInfo(&received_packet3, true));
}
@ -96,9 +68,9 @@ TEST_F(SendTimeHistoryTest, PopulatesExpectedFields) {
const int64_t kSendTime = 1000;
const int64_t kReceiveTime = 2000;
const size_t kPayloadSize = 42;
const PacedPacketInfo kPacingInfo(3, 10, 1212);
AddPacketWithSendTime(kSeqNo, kPayloadSize, kSendTime,
PacedPacketInfo::kNotAProbe);
AddPacketWithSendTime(kSeqNo, kPayloadSize, kSendTime, kPacingInfo);
PacketInfo info(kReceiveTime, kSeqNo);
EXPECT_TRUE(history_.GetInfo(&info, true));
@ -106,6 +78,7 @@ TEST_F(SendTimeHistoryTest, PopulatesExpectedFields) {
EXPECT_EQ(kSendTime, info.send_time_ms);
EXPECT_EQ(kSeqNo, info.sequence_number);
EXPECT_EQ(kPayloadSize, info.payload_size);
EXPECT_EQ(kPacingInfo, info.pacing_info);
}
TEST_F(SendTimeHistoryTest, AddThenRemoveOutOfOrder) {
@ -114,19 +87,19 @@ TEST_F(SendTimeHistoryTest, AddThenRemoveOutOfOrder) {
const size_t num_items = 100;
const size_t kPacketSize = 400;
const size_t kTransmissionTime = 1234;
const int kProbeClusterId = 1;
const PacedPacketInfo kPacingInfo(1, 2, 200);
for (size_t i = 0; i < num_items; ++i) {
sent_packets.push_back(PacketInfo(0, static_cast<int64_t>(i),
static_cast<uint16_t>(i), kPacketSize,
kProbeClusterId));
received_packets.push_back(PacketInfo(
static_cast<int64_t>(i) + kTransmissionTime, 0,
static_cast<uint16_t>(i), kPacketSize, PacedPacketInfo::kNotAProbe));
kPacingInfo));
received_packets.push_back(
PacketInfo(static_cast<int64_t>(i) + kTransmissionTime, 0,
static_cast<uint16_t>(i), kPacketSize, PacedPacketInfo()));
}
for (size_t i = 0; i < num_items; ++i) {
history_.AddAndRemoveOld(sent_packets[i].sequence_number,
sent_packets[i].payload_size,
sent_packets[i].probe_cluster_id);
PacedPacketInfo(1, 2, 200));
}
for (size_t i = 0; i < num_items; ++i)
history_.OnSentPacket(sent_packets[i].sequence_number,
@ -148,21 +121,19 @@ TEST_F(SendTimeHistoryTest, HistorySize) {
const int kItems = kDefaultHistoryLengthMs / 100;
for (int i = 0; i < kItems; ++i) {
clock_.AdvanceTimeMilliseconds(100);
AddPacketWithSendTime(i, 0, i * 100, PacedPacketInfo::kNotAProbe);
AddPacketWithSendTime(i, 0, i * 100, PacedPacketInfo());
}
for (int i = 0; i < kItems; ++i) {
PacketInfo info(0, 0, static_cast<uint16_t>(i), 0,
PacedPacketInfo::kNotAProbe);
PacketInfo info(0, 0, static_cast<uint16_t>(i), 0, PacedPacketInfo());
EXPECT_TRUE(history_.GetInfo(&info, false));
EXPECT_EQ(i * 100, info.send_time_ms);
}
clock_.AdvanceTimeMilliseconds(101);
AddPacketWithSendTime(kItems, 0, kItems * 101, PacedPacketInfo::kNotAProbe);
PacketInfo info(0, 0, 0, 0, PacedPacketInfo::kNotAProbe);
AddPacketWithSendTime(kItems, 0, kItems * 101, PacedPacketInfo());
PacketInfo info(0, 0, 0, 0, PacedPacketInfo());
EXPECT_FALSE(history_.GetInfo(&info, false));
for (int i = 1; i < (kItems + 1); ++i) {
PacketInfo info2(0, 0, static_cast<uint16_t>(i), 0,
PacedPacketInfo::kNotAProbe);
PacketInfo info2(0, 0, static_cast<uint16_t>(i), 0, PacedPacketInfo());
EXPECT_TRUE(history_.GetInfo(&info2, false));
int64_t expected_time_ms = (i == kItems) ? i * 101 : i * 100;
EXPECT_EQ(expected_time_ms, info2.send_time_ms);
@ -171,17 +142,16 @@ TEST_F(SendTimeHistoryTest, HistorySize) {
TEST_F(SendTimeHistoryTest, HistorySizeWithWraparound) {
const uint16_t kMaxSeqNo = std::numeric_limits<uint16_t>::max();
AddPacketWithSendTime(kMaxSeqNo - 2, 0, 0, PacedPacketInfo::kNotAProbe);
AddPacketWithSendTime(kMaxSeqNo - 2, 0, 0, PacedPacketInfo());
clock_.AdvanceTimeMilliseconds(100);
AddPacketWithSendTime(kMaxSeqNo - 1, 1, 100, PacedPacketInfo::kNotAProbe);
AddPacketWithSendTime(kMaxSeqNo - 1, 1, 100, PacedPacketInfo());
clock_.AdvanceTimeMilliseconds(100);
AddPacketWithSendTime(kMaxSeqNo, 0, 200, PacedPacketInfo::kNotAProbe);
AddPacketWithSendTime(kMaxSeqNo, 0, 200, PacedPacketInfo());
clock_.AdvanceTimeMilliseconds(kDefaultHistoryLengthMs - 200 + 1);
AddPacketWithSendTime(0, 0, kDefaultHistoryLengthMs,
PacedPacketInfo::kNotAProbe);
AddPacketWithSendTime(0, 0, kDefaultHistoryLengthMs, PacedPacketInfo());
PacketInfo info(0, static_cast<uint16_t>(kMaxSeqNo - 2));
EXPECT_FALSE(history_.GetInfo(&info, false));
@ -197,7 +167,7 @@ TEST_F(SendTimeHistoryTest, HistorySizeWithWraparound) {
EXPECT_TRUE(history_.GetInfo(&info5, true));
clock_.AdvanceTimeMilliseconds(100);
AddPacketWithSendTime(1, 0, 1100, PacedPacketInfo::kNotAProbe);
AddPacketWithSendTime(1, 0, 1100, PacedPacketInfo());
PacketInfo info6(0, static_cast<uint16_t>(kMaxSeqNo - 2));
EXPECT_FALSE(history_.GetInfo(&info6, false));
@ -214,26 +184,29 @@ TEST_F(SendTimeHistoryTest, HistorySizeWithWraparound) {
TEST_F(SendTimeHistoryTest, InterlievedGetAndRemove) {
const uint16_t kSeqNo = 1;
const int64_t kTimestamp = 2;
PacketInfo packets[3] = {{0, kTimestamp, kSeqNo, 0, 0},
{0, kTimestamp + 1, kSeqNo + 1, 0, 1},
{0, kTimestamp + 2, kSeqNo + 2, 0, 2}};
const PacedPacketInfo kPacingInfo1(1, 1, 100);
const PacedPacketInfo kPacingInfo2(2, 2, 200);
const PacedPacketInfo kPacingInfo3(3, 3, 300);
PacketInfo packets[3] = {{0, kTimestamp, kSeqNo, 0, kPacingInfo1},
{0, kTimestamp + 1, kSeqNo + 1, 0, kPacingInfo2},
{0, kTimestamp + 2, kSeqNo + 2, 0, kPacingInfo3}};
AddPacketWithSendTime(packets[0].sequence_number, packets[0].payload_size,
packets[0].send_time_ms, 0);
packets[0].send_time_ms, packets[0].pacing_info);
AddPacketWithSendTime(packets[1].sequence_number, packets[1].payload_size,
packets[1].send_time_ms, 1);
PacketInfo info(0, 0, packets[0].sequence_number, 0, 0);
packets[1].send_time_ms, packets[1].pacing_info);
PacketInfo info(0, 0, packets[0].sequence_number, 0, PacedPacketInfo());
EXPECT_TRUE(history_.GetInfo(&info, true));
EXPECT_EQ(packets[0], info);
AddPacketWithSendTime(packets[2].sequence_number, packets[2].payload_size,
packets[2].send_time_ms, 2);
packets[2].send_time_ms, packets[2].pacing_info);
PacketInfo info2(0, 0, packets[1].sequence_number, 0, 1);
PacketInfo info2(0, 0, packets[1].sequence_number, 0, kPacingInfo1);
EXPECT_TRUE(history_.GetInfo(&info2, true));
EXPECT_EQ(packets[1], info2);
PacketInfo info3(0, 0, packets[2].sequence_number, 0, 2);
PacketInfo info3(0, 0, packets[2].sequence_number, 0, kPacingInfo2);
EXPECT_TRUE(history_.GetInfo(&info3, true));
EXPECT_EQ(packets[2], info3);
}

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

@ -112,7 +112,7 @@ void SendSideBweSender::OnPacketsSent(const Packets& packets) {
// to create tests for probing using cluster ids.
send_time_history_.AddAndRemoveOld(media_packet->header().sequenceNumber,
media_packet->payload_size(),
PacedPacketInfo::kNotAProbe);
PacedPacketInfo());
send_time_history_.OnSentPacket(media_packet->header().sequenceNumber,
media_packet->sender_timestamp_ms());
}
@ -142,9 +142,10 @@ SendSideBweReceiver::~SendSideBweReceiver() {
void SendSideBweReceiver::ReceivePacket(int64_t arrival_time_ms,
const MediaPacket& media_packet) {
packet_feedback_vector_.push_back(PacketInfo(
-1, arrival_time_ms, media_packet.sender_timestamp_ms(),
media_packet.header().sequenceNumber, media_packet.payload_size(), true));
packet_feedback_vector_.push_back(
PacketInfo(-1, arrival_time_ms, media_packet.sender_timestamp_ms(),
media_packet.header().sequenceNumber,
media_packet.payload_size(), PacedPacketInfo()));
// Log received packet information.
BweReceiver::ReceivePacket(arrival_time_ms, media_packet);

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

@ -251,32 +251,46 @@ struct PacketInfo {
-1,
sequence_number,
0,
PacedPacketInfo::kNotAProbe) {}
PacedPacketInfo()) {}
PacketInfo(int64_t arrival_time_ms,
int64_t send_time_ms,
uint16_t sequence_number,
size_t payload_size,
int probe_cluster_id)
const PacedPacketInfo& pacing_info)
: PacketInfo(-1,
arrival_time_ms,
send_time_ms,
sequence_number,
payload_size,
probe_cluster_id) {}
pacing_info) {}
PacketInfo(int64_t creation_time_ms,
int64_t arrival_time_ms,
int64_t send_time_ms,
uint16_t sequence_number,
size_t payload_size,
int probe_cluster_id)
const PacedPacketInfo& pacing_info)
: creation_time_ms(creation_time_ms),
arrival_time_ms(arrival_time_ms),
send_time_ms(send_time_ms),
sequence_number(sequence_number),
payload_size(payload_size),
probe_cluster_id(probe_cluster_id) {}
pacing_info(pacing_info) {}
static constexpr int kNotAProbe = -1;
// NOTE! The variable |creation_time_ms| is not used when testing equality.
// This is due to |creation_time_ms| only being used by SendTimeHistory
// for book-keeping, and is of no interest outside that class.
// TODO(philipel): Remove |creation_time_ms| from PacketInfo when cleaning up
// SendTimeHistory.
bool operator==(const PacketInfo& rhs) const {
return arrival_time_ms == rhs.arrival_time_ms &&
send_time_ms == rhs.send_time_ms &&
sequence_number == rhs.sequence_number &&
payload_size == rhs.payload_size && pacing_info == rhs.pacing_info;
}
// Time corresponding to when this object was created.
int64_t creation_time_ms;
@ -291,9 +305,8 @@ struct PacketInfo {
uint16_t sequence_number;
// Size of the packet excluding RTP headers.
size_t payload_size;
// Which probing cluster this packets belongs to.
// TODO(philipel): replace this with pacing information when it is available.
int probe_cluster_id;
// Pacing information about this packet.
PacedPacketInfo pacing_info;
};
class TransportFeedbackObserver {
@ -301,11 +314,10 @@ class TransportFeedbackObserver {
TransportFeedbackObserver() {}
virtual ~TransportFeedbackObserver() {}
// Note: Transport-wide sequence number as sequence number. Arrival time
// must be set to 0.
// Note: Transport-wide sequence number as sequence number.
virtual void AddPacket(uint16_t sequence_number,
size_t length,
int probe_cluster_id) = 0;
const PacedPacketInfo& pacing_info) = 0;
virtual void OnTransportFeedback(const rtcp::TransportFeedback& feedback) = 0;

3
webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
View File

@ -77,7 +77,8 @@ class MockRtcpCallbackImpl : public RtcpStatisticsCallback {
class MockTransportFeedbackObserver : public TransportFeedbackObserver {
public:
MOCK_METHOD3(AddPacket, void(uint16_t, size_t, int));
MOCK_METHOD2(AddPacket, void(uint16_t, size_t));
MOCK_METHOD3(AddPacket, void(uint16_t, size_t, const PacedPacketInfo&));
MOCK_METHOD1(OnTransportFeedback, void(const rtcp::TransportFeedback&));
MOCK_CONST_METHOD0(GetTransportFeedbackVector, std::vector<PacketInfo>());
};

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

@ -394,14 +394,13 @@ bool ModuleRtpRtcpImpl::TimeToSendPacket(uint32_t ssrc,
bool retransmission,
const PacedPacketInfo& pacing_info) {
return rtp_sender_.TimeToSendPacket(ssrc, sequence_number, capture_time_ms,
retransmission,
pacing_info.probe_cluster_id);
retransmission, pacing_info);
}
size_t ModuleRtpRtcpImpl::TimeToSendPadding(
size_t bytes,
const PacedPacketInfo& pacing_info) {
return rtp_sender_.TimeToSendPadding(bytes, pacing_info.probe_cluster_id);
return rtp_sender_.TimeToSendPadding(bytes, pacing_info);
}
size_t ModuleRtpRtcpImpl::MaxPayloadSize() const {

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

@ -448,7 +448,7 @@ bool RTPSender::SendOutgoingData(FrameType frame_type,
}
size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send,
int probe_cluster_id) {
const PacedPacketInfo& pacing_info) {
{
rtc::CritScope lock(&send_critsect_);
if (!sending_media_)
@ -464,14 +464,15 @@ size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send,
if (!packet)
break;
size_t payload_size = packet->payload_size();
if (!PrepareAndSendPacket(std::move(packet), true, false, probe_cluster_id))
if (!PrepareAndSendPacket(std::move(packet), true, false, pacing_info))
break;
bytes_left -= payload_size;
}
return bytes_to_send - bytes_left;
}
size_t RTPSender::SendPadData(size_t bytes, int probe_cluster_id) {
size_t RTPSender::SendPadData(size_t bytes,
const PacedPacketInfo& pacing_info) {
size_t padding_bytes_in_packet;
if (audio_configured_) {
// Allow smaller padding packets for audio.
@ -574,7 +575,7 @@ size_t RTPSender::SendPadData(size_t bytes, int probe_cluster_id) {
if (has_transport_seq_num) {
AddPacketToTransportFeedback(options.packet_id, padding_packet,
probe_cluster_id);
pacing_info);
}
if (!SendPacketToNetwork(padding_packet, options))
@ -623,8 +624,7 @@ int32_t RTPSender::ReSendPacket(uint16_t packet_id, int64_t min_resend_time) {
}
bool rtx = (RtxStatus() & kRtxRetransmitted) > 0;
int32_t packet_size = static_cast<int32_t>(packet->size());
if (!PrepareAndSendPacket(std::move(packet), rtx, true,
PacedPacketInfo::kNotAProbe))
if (!PrepareAndSendPacket(std::move(packet), rtx, true, PacedPacketInfo()))
return -1;
return packet_size;
}
@ -693,7 +693,7 @@ bool RTPSender::TimeToSendPacket(uint32_t ssrc,
uint16_t sequence_number,
int64_t capture_time_ms,
bool retransmission,
int probe_cluster_id) {
const PacedPacketInfo& pacing_info) {
if (!SendingMedia())
return true;
@ -714,13 +714,13 @@ bool RTPSender::TimeToSendPacket(uint32_t ssrc,
return PrepareAndSendPacket(
std::move(packet),
retransmission && (RtxStatus() & kRtxRetransmitted) > 0, retransmission,
probe_cluster_id);
pacing_info);
}
bool RTPSender::PrepareAndSendPacket(std::unique_ptr<RtpPacketToSend> packet,
bool send_over_rtx,
bool is_retransmit,
int probe_cluster_id) {
const PacedPacketInfo& pacing_info) {
RTC_DCHECK(packet);
int64_t capture_time_ms = packet->capture_time_ms();
RtpPacketToSend* packet_to_send = packet.get();
@ -751,7 +751,7 @@ bool RTPSender::PrepareAndSendPacket(std::unique_ptr<RtpPacketToSend> packet,
PacketOptions options;
if (UpdateTransportSequenceNumber(packet_to_send, &options.packet_id)) {
AddPacketToTransportFeedback(options.packet_id, *packet_to_send,
probe_cluster_id);
pacing_info);
}
if (!is_retransmit && !send_over_rtx) {
@ -813,12 +813,13 @@ bool RTPSender::IsFecPacket(const RtpPacketToSend& packet) const {
static_cast<int>(packet.payload()[0]) == pt_fec;
}
size_t RTPSender::TimeToSendPadding(size_t bytes, int probe_cluster_id) {
size_t RTPSender::TimeToSendPadding(size_t bytes,
const PacedPacketInfo& pacing_info) {
if (bytes == 0)
return 0;
size_t bytes_sent = TrySendRedundantPayloads(bytes, probe_cluster_id);
size_t bytes_sent = TrySendRedundantPayloads(bytes, pacing_info);
if (bytes_sent < bytes)
bytes_sent += SendPadData(bytes - bytes_sent, probe_cluster_id);
bytes_sent += SendPadData(bytes - bytes_sent, pacing_info);
return bytes_sent;
}
@ -882,7 +883,7 @@ bool RTPSender::SendToNetwork(std::unique_ptr<RtpPacketToSend> packet,
PacketOptions options;
if (UpdateTransportSequenceNumber(packet.get(), &options.packet_id)) {
AddPacketToTransportFeedback(options.packet_id, *packet.get(),
PacedPacketInfo::kNotAProbe);
PacedPacketInfo());
}
UpdateDelayStatistics(packet->capture_time_ms(), now_ms);
@ -1249,9 +1250,10 @@ RtpState RTPSender::GetRtxRtpState() const {
return state;
}
void RTPSender::AddPacketToTransportFeedback(uint16_t packet_id,
const RtpPacketToSend& packet,
int probe_cluster_id) {
void RTPSender::AddPacketToTransportFeedback(
uint16_t packet_id,
const RtpPacketToSend& packet,
const PacedPacketInfo& pacing_info) {
size_t packet_size = packet.payload_size() + packet.padding_size();
if (send_side_bwe_with_overhead_) {
packet_size = packet.size();
@ -1259,7 +1261,7 @@ void RTPSender::AddPacketToTransportFeedback(uint16_t packet_id,
if (transport_feedback_observer_) {
transport_feedback_observer_->AddPacket(packet_id, packet_size,
probe_cluster_id);
pacing_info);
}
}

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

@ -123,8 +123,8 @@ class RTPSender {
uint16_t sequence_number,
int64_t capture_time_ms,
bool retransmission,
int probe_cluster_id);
size_t TimeToSendPadding(size_t bytes, int probe_cluster_id);
const PacedPacketInfo& pacing_info);
size_t TimeToSendPadding(size_t bytes, const PacedPacketInfo& pacing_info);
// NACK.
int SelectiveRetransmissions() const;
@ -214,16 +214,17 @@ class RTPSender {
// time.
typedef std::map<int64_t, int> SendDelayMap;
size_t SendPadData(size_t bytes, int probe_cluster_id);
size_t SendPadData(size_t bytes, const PacedPacketInfo& pacing_info);
bool PrepareAndSendPacket(std::unique_ptr<RtpPacketToSend> packet,
bool send_over_rtx,
bool is_retransmit,
int probe_cluster_id);
const PacedPacketInfo& pacing_info);
// Return the number of bytes sent. Note that both of these functions may
// return a larger value that their argument.
size_t TrySendRedundantPayloads(size_t bytes, int probe_cluster_id);
size_t TrySendRedundantPayloads(size_t bytes,
const PacedPacketInfo& pacing_info);
std::unique_ptr<RtpPacketToSend> BuildRtxPacket(
const RtpPacketToSend& packet);
@ -246,7 +247,7 @@ class RTPSender {
void AddPacketToTransportFeedback(uint16_t packet_id,
const RtpPacketToSend& packet,
int probe_cluster_id);
const PacedPacketInfo& pacing_info);
void UpdateRtpOverhead(const RtpPacketToSend& packet);

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

@ -126,7 +126,7 @@ class MockSendPacketObserver : public SendPacketObserver {
class MockTransportFeedbackObserver : public TransportFeedbackObserver {
public:
MOCK_METHOD3(AddPacket, void(uint16_t, size_t, int));
MOCK_METHOD3(AddPacket, void(uint16_t, size_t, const PacedPacketInfo&));
MOCK_METHOD1(OnTransportFeedback, void(const rtcp::TransportFeedback&));
MOCK_CONST_METHOD0(GetTransportFeedbackVector, std::vector<PacketInfo>());
};
@ -311,16 +311,16 @@ TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberMayAllowPadding) {
auto packet = rtp_sender_->AllocatePacket();
ASSERT_TRUE(packet);
ASSERT_FALSE(rtp_sender_->TimeToSendPadding(kPaddingSize, -1));
ASSERT_FALSE(rtp_sender_->TimeToSendPadding(kPaddingSize, PacedPacketInfo()));
packet->SetMarker(false);
ASSERT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
// Packet without marker bit doesn't allow padding.
EXPECT_FALSE(rtp_sender_->TimeToSendPadding(kPaddingSize, -1));
EXPECT_FALSE(rtp_sender_->TimeToSendPadding(kPaddingSize, PacedPacketInfo()));
packet->SetMarker(true);
ASSERT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
// Packet with marker bit allows send padding.
EXPECT_TRUE(rtp_sender_->TimeToSendPadding(kPaddingSize, -1));
EXPECT_TRUE(rtp_sender_->TimeToSendPadding(kPaddingSize, PacedPacketInfo()));
}
TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberSetPaddingTimestamps) {
@ -331,7 +331,7 @@ TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberSetPaddingTimestamps) {
packet->SetTimestamp(kTimestamp);
ASSERT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
ASSERT_TRUE(rtp_sender_->TimeToSendPadding(kPaddingSize, -1));
ASSERT_TRUE(rtp_sender_->TimeToSendPadding(kPaddingSize, PacedPacketInfo()));
ASSERT_EQ(1u, transport_.sent_packets_.size());
// Verify padding packet timestamp.
@ -353,10 +353,10 @@ TEST_F(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
EXPECT_CALL(send_packet_observer_,
OnSendPacket(kTransportSequenceNumber, _, _))
.Times(1);
EXPECT_CALL(feedback_observer_,
AddPacket(kTransportSequenceNumber,
sizeof(kPayloadData) + kGenericHeaderLength,
PacedPacketInfo::kNotAProbe))
EXPECT_CALL(
feedback_observer_,
AddPacket(kTransportSequenceNumber,
sizeof(kPayloadData) + kGenericHeaderLength, PacedPacketInfo()))
.Times(1);
SendGenericPayload();
@ -404,16 +404,16 @@ TEST_F(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
EXPECT_CALL(send_packet_observer_,
OnSendPacket(kTransportSequenceNumber, _, _))
.Times(1);
const int kProbeClusterId = 1;
EXPECT_CALL(
feedback_observer_,
AddPacket(kTransportSequenceNumber,
sizeof(kPayloadData) + kGenericHeaderLength, kProbeClusterId))
sizeof(kPayloadData) + kGenericHeaderLength, PacedPacketInfo()))
.Times(1);
SendGenericPayload();
rtp_sender_->TimeToSendPacket(
kSsrc, kSeqNum, fake_clock_.TimeInMilliseconds(), false, kProbeClusterId);
rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum,
fake_clock_.TimeInMilliseconds(), false,
PacedPacketInfo());
const auto& packet = transport_.last_sent_packet();
uint16_t transport_seq_no;
@ -451,7 +451,7 @@ TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum, capture_time_ms, false,
PacedPacketInfo::kNotAProbe);
PacedPacketInfo());
// Process send bucket. Packet should now be sent.
EXPECT_EQ(1, transport_.packets_sent());
@ -502,7 +502,7 @@ TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
EXPECT_EQ(0, transport_.packets_sent());
rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum, capture_time_ms, false,
PacedPacketInfo::kNotAProbe);
PacedPacketInfo());
// Process send bucket. Packet should now be sent.
EXPECT_EQ(1, transport_.packets_sent());
@ -561,7 +561,7 @@ TEST_F(RtpSenderTest, SendPadding) {
const int kStoredTimeInMs = 100;
fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
rtp_sender_->TimeToSendPacket(kSsrc, seq_num++, capture_time_ms, false,
PacedPacketInfo::kNotAProbe);
PacedPacketInfo());
// Packet should now be sent. This test doesn't verify the regular video
// packet, since it is tested in another test.
EXPECT_EQ(++total_packets_sent, transport_.packets_sent());
@ -574,8 +574,7 @@ TEST_F(RtpSenderTest, SendPadding) {
const size_t kMaxPaddingLength = 224; // Value taken from rtp_sender.cc.
// Padding will be forced to full packets.
EXPECT_EQ(kMaxPaddingLength,
rtp_sender_->TimeToSendPadding(kPaddingBytes,
PacedPacketInfo::kNotAProbe));
rtp_sender_->TimeToSendPadding(kPaddingBytes, PacedPacketInfo()));
// Process send bucket. Padding should now be sent.
EXPECT_EQ(++total_packets_sent, transport_.packets_sent());
@ -613,7 +612,7 @@ TEST_F(RtpSenderTest, SendPadding) {
RtpPacketSender::kNormalPriority));
rtp_sender_->TimeToSendPacket(kSsrc, seq_num, capture_time_ms, false,
PacedPacketInfo::kNotAProbe);
PacedPacketInfo());
// Process send bucket.
EXPECT_EQ(++total_packets_sent, transport_.packets_sent());
EXPECT_EQ(packet_size, transport_.last_sent_packet().size());
@ -647,7 +646,7 @@ TEST_F(RtpSenderTest, OnSendPacketUpdated) {
const bool kIsRetransmit = false;
rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum,
fake_clock_.TimeInMilliseconds(), kIsRetransmit,
PacedPacketInfo::kNotAProbe);
PacedPacketInfo());
EXPECT_EQ(1, transport_.packets_sent());
}
@ -667,7 +666,7 @@ TEST_F(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) {
const bool kIsRetransmit = true;
rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum,
fake_clock_.TimeInMilliseconds(), kIsRetransmit,
PacedPacketInfo::kNotAProbe);
PacedPacketInfo());
EXPECT_EQ(1, transport_.packets_sent());
}
@ -693,7 +692,7 @@ TEST_F(RtpSenderTest, OnSendPacketNotUpdatedWithoutSeqNumAllocator) {
const bool kIsRetransmit = false;
rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum,
fake_clock_.TimeInMilliseconds(), kIsRetransmit,
PacedPacketInfo::kNotAProbe);
PacedPacketInfo());
EXPECT_EQ(1, transport_.packets_sent());
}
@ -736,7 +735,7 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) {
EXPECT_CALL(transport, SendRtp(_, _, _)).WillOnce(testing::Return(true));
SendPacket(capture_time_ms, kPayloadSizes[i]);
rtp_sender_->TimeToSendPacket(kSsrc, seq_num++, capture_time_ms, false,
PacedPacketInfo::kNotAProbe);
PacedPacketInfo());
fake_clock_.AdvanceTimeMilliseconds(33);
}
@ -748,13 +747,13 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) {
EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _))
.WillOnce(testing::Return(true));
EXPECT_EQ(kMaxPaddingSize,
rtp_sender_->TimeToSendPadding(49, PacedPacketInfo::kNotAProbe));
rtp_sender_->TimeToSendPadding(49, PacedPacketInfo()));
EXPECT_CALL(transport,
SendRtp(_, kPayloadSizes[0] + rtp_header_len + kRtxHeaderSize, _))
.WillOnce(testing::Return(true));
EXPECT_EQ(kPayloadSizes[0],
rtp_sender_->TimeToSendPadding(500, PacedPacketInfo::kNotAProbe));
rtp_sender_->TimeToSendPadding(500, PacedPacketInfo()));
EXPECT_CALL(transport, SendRtp(_, kPayloadSizes[kNumPayloadSizes - 1] +
rtp_header_len + kRtxHeaderSize,
@ -763,7 +762,7 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) {
EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _))
.WillOnce(testing::Return(true));
EXPECT_EQ(kPayloadSizes[kNumPayloadSizes - 1] + kMaxPaddingSize,
rtp_sender_->TimeToSendPadding(999, PacedPacketInfo::kNotAProbe));
rtp_sender_->TimeToSendPadding(999, PacedPacketInfo()));
}
TEST_F(RtpSenderTestWithoutPacer, SendGenericVideo) {
@ -838,11 +837,12 @@ TEST_F(RtpSenderTest, SendFlexfecPackets) {
EXPECT_CALL(mock_rtc_event_log_,
LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _))
.Times(2);
EXPECT_TRUE(rtp_sender_->TimeToSendPacket(
kMediaSsrc, kSeqNum, fake_clock_.TimeInMilliseconds(), false, 0));
EXPECT_TRUE(rtp_sender_->TimeToSendPacket(kMediaSsrc, kSeqNum,
fake_clock_.TimeInMilliseconds(),
false, PacedPacketInfo()));
EXPECT_TRUE(rtp_sender_->TimeToSendPacket(kFlexfecSsrc, flexfec_seq_num,
fake_clock_.TimeInMilliseconds(),
false, 0));
false, PacedPacketInfo()));
ASSERT_EQ(2, transport_.packets_sent());
const RtpPacketReceived& media_packet = transport_.sent_packets_[0];
EXPECT_EQ(kMediaPayloadType, media_packet.PayloadType());
@ -1159,7 +1159,7 @@ TEST_F(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) {
callback.Matches(ssrc, expected);
// Send padding.
rtp_sender_->TimeToSendPadding(kMaxPaddingSize, PacedPacketInfo::kNotAProbe);
rtp_sender_->TimeToSendPadding(kMaxPaddingSize, PacedPacketInfo());
expected.transmitted.payload_bytes = 12;
expected.transmitted.header_bytes = 36;
expected.transmitted.padding_bytes = kMaxPaddingSize;
@ -1287,8 +1287,8 @@ TEST_F(RtpSenderTestWithoutPacer, BytesReportedCorrectly) {
sizeof(payload), nullptr, nullptr, nullptr));
// Will send 2 full-size padding packets.
rtp_sender_->TimeToSendPadding(1, PacedPacketInfo::kNotAProbe);
rtp_sender_->TimeToSendPadding(1, PacedPacketInfo::kNotAProbe);
rtp_sender_->TimeToSendPadding(1, PacedPacketInfo());
rtp_sender_->TimeToSendPadding(1, PacedPacketInfo());
StreamDataCounters rtp_stats;
StreamDataCounters rtx_stats;
@ -1490,7 +1490,7 @@ TEST_F(RtpSenderTest, AddOverheadToTransportFeedbackObserver) {
AddPacket(kTransportSequenceNumber,
sizeof(kPayloadData) + kGenericHeaderLength +
kRtpOverheadBytesPerPacket,
PacedPacketInfo::kNotAProbe))
PacedPacketInfo()))
.Times(1);
EXPECT_CALL(mock_overhead_observer,
OnOverheadChanged(kRtpOverheadBytesPerPacket))
@ -1514,15 +1514,14 @@ TEST_F(RtpSenderTest, SendAudioPadding) {
EXPECT_CALL(transport, SendRtp(_, kPaddingSize + kRtpHeaderSize, _))
.WillOnce(testing::Return(true));
EXPECT_EQ(kPaddingSize,
rtp_sender_->TimeToSendPadding(kPaddingSize,
PacedPacketInfo::kNotAProbe));
rtp_sender_->TimeToSendPadding(kPaddingSize, PacedPacketInfo()));
// Requested padding size is too small, will send a larger one.
const size_t kMinPaddingSize = 50;
EXPECT_CALL(transport, SendRtp(_, kMinPaddingSize + kRtpHeaderSize, _))
.WillOnce(testing::Return(true));
EXPECT_EQ(kMinPaddingSize,
rtp_sender_->TimeToSendPadding(kMinPaddingSize - 5,
PacedPacketInfo::kNotAProbe));
EXPECT_EQ(
kMinPaddingSize,
rtp_sender_->TimeToSendPadding(kMinPaddingSize - 5, PacedPacketInfo()));
}
} // namespace webrtc

5
webrtc/tools/event_log_visualizer/analyzer.cc
View File

@ -1073,7 +1073,7 @@ void EventLogAnalyzer::CreateBweSimulationGraph(Plot* plot) {
RTC_DCHECK(rtp.header.extension.hasTransportSequenceNumber);
cc.GetTransportFeedbackObserver()->AddPacket(
rtp.header.extension.transportSequenceNumber, rtp.total_length,
PacedPacketInfo::kNotAProbe);
PacedPacketInfo());
rtc::SentPacket sent_packet(
rtp.header.extension.transportSequenceNumber, rtp.timestamp / 1000);
cc.OnSentPacket(sent_packet);
@ -1203,8 +1203,7 @@ void EventLogAnalyzer::CreateNetworkDelayFeedbackGraph(Plot* plot) {
if (rtp.header.extension.hasTransportSequenceNumber) {
RTC_DCHECK(rtp.header.extension.hasTransportSequenceNumber);
feedback_adapter.AddPacket(rtp.header.extension.transportSequenceNumber,
rtp.total_length,
PacedPacketInfo::kNotAProbe);
rtp.total_length, PacedPacketInfo());
feedback_adapter.OnSentPacket(
rtp.header.extension.transportSequenceNumber, rtp.timestamp / 1000);
}

5
webrtc/voice_engine/channel.cc
View File

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