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

Propagate packet pacing information to SenTimeHistory.

Browse Source 
In order to not make this CL too large I have broken it down into at least two steps. In this CL we only propagate the pacing information part of the way:

webrtc::PacedSender::Process                        <--- propagate from here
webrtc::PacedSender::SendPacket
webrtc::PacketRouter::TimeToSendPacket
webrtc::ModuleRtpRtcpImpl::TimeToSendPacket         <--- to here
webrtc::RTPSender::TimeToSendPacket
webrtc::RTPSender::PrepareAndSendPacket
webrtc::RTPSender::AddPacketToTransportFeedback
webrtc::TransportFeedbackAdapter::AddPacket
webrtc::SendTimeHistory::AddAndRemoveOld            <--- goal is to propagte it here

BUG=webrtc:6822

Review-Url: https://codereview.webrtc.org/2628563003
Cr-Commit-Position: refs/heads/master@{#16664}
This commit is contained in:
philipel
2017-02-17 03:59:43 -08:00
committed by Commit bot
parent 0baf55d23b
commit c7bf32a110
27 changed files with 235 additions and 157 deletions
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 != PacketInfo::kNotAProbe) {
if (info.probe_cluster_id != PacedPacketInfo::kNotAProbe) {
probing_bps = probe_bitrate_estimator_.HandleProbeAndEstimateBitrate(info);
}
rtc::Optional<uint32_t> acked_bitrate_bps =

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

@ -57,7 +57,8 @@ TEST_F(DelayBasedBweTest, ProbeDetectionNonPacedPackets) {
IncomingFeedback(now_ms, now_ms, seq_num++, 1000, 0);
// Non-paced packet, arriving 5 ms after.
clock_.AdvanceTimeMilliseconds(5);
IncomingFeedback(now_ms, now_ms, seq_num++, 100, PacketInfo::kNotAProbe);
IncomingFeedback(now_ms, now_ms, seq_num++, 100,
PacedPacketInfo::kNotAProbe);
}
EXPECT_TRUE(bitrate_observer_.updated());

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

@ -60,7 +60,7 @@ 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 = PacketInfo::kNotAProbe;
packet.probe_cluster_id = PacedPacketInfo::kNotAProbe;
packets->push_back(packet);
}
next_rtp_time_ = time_now_us + (1000000 + fps_ / 2) / fps_;
@ -169,7 +169,7 @@ 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,
PacketInfo::kNotAProbe);
PacedPacketInfo::kNotAProbe);
}
void DelayBasedBweTest::IncomingFeedback(int64_t arrival_time_ms,
@ -280,7 +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 : PacketInfo::kNotAProbe;
int cluster_id =
i < kInitialProbingPackets ? 0 : PacedPacketInfo::kNotAProbe;
if (i == kNumInitialPackets) {
EXPECT_FALSE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps));
@ -312,7 +313,8 @@ void DelayBasedBweTest::RateIncreaseReorderingTestHelper(
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 : PacketInfo::kNotAProbe;
int cluster_id =
i < kInitialProbingPackets ? 0 : PacedPacketInfo::kNotAProbe;
// TODO(sprang): Remove this hack once the single stream estimator is gone,
// as it doesn't do anything in Process().

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

@ -38,7 +38,7 @@ ProbeBitrateEstimator::ProbeBitrateEstimator() {}
int ProbeBitrateEstimator::HandleProbeAndEstimateBitrate(
const PacketInfo& packet_info) {
RTC_DCHECK_NE(packet_info.probe_cluster_id, PacketInfo::kNotAProbe);
RTC_DCHECK_NE(packet_info.probe_cluster_id, PacedPacketInfo::kNotAProbe);
EraseOldClusters(packet_info.arrival_time_ms - kMaxClusterHistoryMs);

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

@ -258,11 +258,11 @@ TEST_F(TransportFeedbackAdapterTest, SendTimeWrapsBothWays) {
static_cast<int64_t>((1 << 23) - 1) / 1000;
std::vector<PacketInfo> packets;
packets.push_back(PacketInfo(kHighArrivalTimeMs - 64, 200, 0, 1500,
PacketInfo::kNotAProbe));
PacedPacketInfo::kNotAProbe));
packets.push_back(PacketInfo(kHighArrivalTimeMs + 64, 210, 1, 1500,
PacketInfo::kNotAProbe));
packets.push_back(
PacketInfo(kHighArrivalTimeMs, 220, 2, 1500, PacketInfo::kNotAProbe));
PacedPacketInfo::kNotAProbe));
packets.push_back(PacketInfo(kHighArrivalTimeMs, 220, 2, 1500,
PacedPacketInfo::kNotAProbe));
for (const PacketInfo& packet : packets)
OnSentPacket(packet);
@ -329,7 +329,7 @@ TEST_F(TransportFeedbackAdapterTest, TimestampDeltas) {
rtcp::TransportFeedback::kDeltaScaleFactor *
std::numeric_limits<int16_t>::min();
PacketInfo info(100, 200, 0, 1500, true, PacketInfo::kNotAProbe);
PacketInfo info(100, 200, 0, 1500, true, PacedPacketInfo::kNotAProbe);
sent_packets.push_back(info);
info.send_time_ms += kSmallDeltaUs / 1000;
@ -418,7 +418,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, PacketInfo::kNotAProbe);
seq_num, kPayloadSize, PacedPacketInfo::kNotAProbe);
OnSentPacket(packet);
// Create expected feedback and send into adapter.
std::unique_ptr<rtcp::TransportFeedback> feedback(

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

@ -529,6 +529,22 @@ class SequenceNumberUnwrapper {
int64_t last_seq_;
};
struct PacedPacketInfo {
PacedPacketInfo() {}
PacedPacketInfo(int probe_cluster_id,
int probe_cluster_min_probes,
int probe_cluster_min_bytes)
: probe_cluster_id(probe_cluster_id),
probe_cluster_min_probes(probe_cluster_min_probes),
probe_cluster_min_bytes(probe_cluster_min_bytes) {}
static constexpr int kNotAProbe = -1;
int send_bitrate_bps = -1;
int probe_cluster_id = kNotAProbe;
int probe_cluster_min_probes = -1;
int probe_cluster_min_bytes = -1;
};
} // namespace webrtc
#endif // WEBRTC_MODULES_INCLUDE_MODULE_COMMON_TYPES_H_

34
webrtc/modules/pacing/bitrate_prober.cc
View File

@ -88,16 +88,18 @@ void BitrateProber::CreateProbeCluster(int bitrate_bps, int64_t now_ms) {
}
ProbeCluster cluster;
cluster.min_probes = kMinProbePacketsSent;
cluster.min_bytes = bitrate_bps * kMinProbeDurationMs / 8000;
cluster.bitrate_bps = bitrate_bps;
cluster.time_created_ms = now_ms;
cluster.id = next_cluster_id_++;
cluster.pace_info.probe_cluster_min_probes = kMinProbePacketsSent;
cluster.pace_info.probe_cluster_min_bytes =
bitrate_bps * kMinProbeDurationMs / 8000;
cluster.pace_info.send_bitrate_bps = bitrate_bps;
cluster.pace_info.probe_cluster_id = next_cluster_id_++;
clusters_.push(cluster);
LOG(LS_INFO) << "Probe cluster (bitrate:min bytes:min packets): ("
<< cluster.bitrate_bps << ":" << cluster.min_bytes << ":"
<< cluster.min_probes << ")";
<< cluster.pace_info.send_bitrate_bps << ":"
<< cluster.pace_info.probe_cluster_min_bytes << ":"
<< cluster.pace_info.probe_cluster_min_probes << ")";
// If we are already probing, continue to do so. Otherwise set it to
// kInactive and wait for OnIncomingPacket to start the probing.
if (probing_state_ != ProbingState::kActive)
@ -112,7 +114,7 @@ void BitrateProber::ResetState(int64_t now_ms) {
clusters.swap(clusters_);
while (!clusters.empty()) {
if (clusters.front().retries < kMaxRetryAttempts) {
CreateProbeCluster(clusters.front().bitrate_bps, now_ms);
CreateProbeCluster(clusters.front().pace_info.send_bitrate_bps, now_ms);
clusters_.back().retries = clusters.front().retries + 1;
}
clusters.pop();
@ -138,10 +140,10 @@ int BitrateProber::TimeUntilNextProbe(int64_t now_ms) {
return std::max(time_until_probe_ms, 0);
}
int BitrateProber::CurrentClusterId() const {
PacedPacketInfo BitrateProber::CurrentCluster() const {
RTC_DCHECK(!clusters_.empty());
RTC_DCHECK(ProbingState::kActive == probing_state_);
return clusters_.front().id;
return clusters_.front().pace_info;
}
// Probe size is recommended based on the probe bitrate required. We choose
@ -149,7 +151,8 @@ int BitrateProber::CurrentClusterId() const {
// feasible.
size_t BitrateProber::RecommendedMinProbeSize() const {
RTC_DCHECK(!clusters_.empty());
return clusters_.front().bitrate_bps * 2 * kMinProbeDeltaMs / (8 * 1000);
return clusters_.front().pace_info.send_bitrate_bps * 2 * kMinProbeDeltaMs /
(8 * 1000);
}
void BitrateProber::ProbeSent(int64_t now_ms, size_t bytes) {
@ -165,8 +168,8 @@ void BitrateProber::ProbeSent(int64_t now_ms, size_t bytes) {
cluster->sent_bytes += static_cast<int>(bytes);
cluster->sent_probes += 1;
next_probe_time_ms_ = GetNextProbeTime(clusters_.front());
if (cluster->sent_bytes >= cluster->min_bytes &&
cluster->sent_probes >= cluster->min_probes) {
if (cluster->sent_bytes >= cluster->pace_info.probe_cluster_min_bytes &&
cluster->sent_probes >= cluster->pace_info.probe_cluster_min_probes) {
clusters_.pop();
}
if (clusters_.empty())
@ -175,13 +178,14 @@ void BitrateProber::ProbeSent(int64_t now_ms, size_t bytes) {
}
int64_t BitrateProber::GetNextProbeTime(const ProbeCluster& cluster) {
RTC_CHECK_GT(cluster.bitrate_bps, 0);
RTC_CHECK_GT(cluster.pace_info.send_bitrate_bps, 0);
RTC_CHECK_GE(cluster.time_started_ms, 0);
// Compute the time delta from the cluster start to ensure probe bitrate stays
// close to the target bitrate. Result is in milliseconds.
int64_t delta_ms = (8000ll * cluster.sent_bytes + cluster.bitrate_bps / 2) /
cluster.bitrate_bps;
int64_t delta_ms =
(8000ll * cluster.sent_bytes + cluster.pace_info.send_bitrate_bps / 2) /
cluster.pace_info.send_bitrate_bps;
return cluster.time_started_ms + delta_ms;
}

11
webrtc/modules/pacing/bitrate_prober.h
View File

@ -14,6 +14,7 @@
#include <queue>
#include "webrtc/base/basictypes.h"
#include "webrtc/modules/include/module_common_types.h"
#include "webrtc/typedefs.h"
namespace webrtc {
@ -44,8 +45,8 @@ class BitrateProber {
// get accurate probing.
int TimeUntilNextProbe(int64_t now_ms);
// Which cluster that is currently being used for probing.
int CurrentClusterId() const;
// Information about the current probing cluster.
PacedPacketInfo CurrentCluster() const;
// Returns the minimum number of bytes that the prober recommends for
// the next probe.
@ -74,16 +75,12 @@ class BitrateProber {
// A probe cluster consists of a set of probes. Each probe in turn can be
// divided into a number of packets to accommodate the MTU on the network.
struct ProbeCluster {
int min_probes = 0;
int min_bytes = 0;
int bitrate_bps = 0;
int id = -1;
PacedPacketInfo pace_info;
int sent_probes = 0;
int sent_bytes = 0;
int64_t time_created_ms = -1;
int64_t time_started_ms = -1;
int retries = 0;
};

6
webrtc/modules/pacing/bitrate_prober_unittest.cc
View File

@ -33,7 +33,7 @@ TEST(BitrateProberTest, VerifyStatesAndTimeBetweenProbes) {
prober.OnIncomingPacket(kProbeSize);
EXPECT_TRUE(prober.IsProbing());
EXPECT_EQ(0, prober.CurrentClusterId());
EXPECT_EQ(0, prober.CurrentCluster().probe_cluster_id);
// First packet should probe as soon as possible.
EXPECT_EQ(0, prober.TimeUntilNextProbe(now_ms));
@ -41,7 +41,7 @@ TEST(BitrateProberTest, VerifyStatesAndTimeBetweenProbes) {
for (int i = 0; i < kClusterSize; ++i) {
now_ms += prober.TimeUntilNextProbe(now_ms);
EXPECT_EQ(0, prober.TimeUntilNextProbe(now_ms));
EXPECT_EQ(0, prober.CurrentClusterId());
EXPECT_EQ(0, prober.CurrentCluster().probe_cluster_id);
prober.ProbeSent(now_ms, kProbeSize);
}
@ -57,7 +57,7 @@ TEST(BitrateProberTest, VerifyStatesAndTimeBetweenProbes) {
for (int i = 0; i < kClusterSize; ++i) {
now_ms += prober.TimeUntilNextProbe(now_ms);
EXPECT_EQ(0, prober.TimeUntilNextProbe(now_ms));
EXPECT_EQ(1, prober.CurrentClusterId());
EXPECT_EQ(1, prober.CurrentCluster().probe_cluster_id);
prober.ProbeSent(now_ms, kProbeSize);
}

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

@ -410,11 +410,11 @@ void PacedSender::Process() {
}
bool is_probing = prober_->IsProbing();
int probe_cluster_id = PacketInfo::kNotAProbe;
PacedPacketInfo pacing_info;
size_t bytes_sent = 0;
size_t recommended_probe_size = 0;
if (is_probing) {
probe_cluster_id = prober_->CurrentClusterId();
pacing_info = prober_->CurrentCluster();
recommended_probe_size = prober_->RecommendedMinProbeSize();
}
while (!packets_->Empty()) {
@ -423,7 +423,7 @@ void PacedSender::Process() {
// reinsert it if send fails.
const paced_sender::Packet& packet = packets_->BeginPop();
if (SendPacket(packet, probe_cluster_id)) {
if (SendPacket(packet, pacing_info)) {
// Send succeeded, remove it from the queue.
bytes_sent += packet.bytes;
packets_->FinalizePop(packet);
@ -445,7 +445,7 @@ void PacedSender::Process() {
: padding_budget_->bytes_remaining());
if (padding_needed > 0)
bytes_sent += SendPadding(padding_needed, probe_cluster_id);
bytes_sent += SendPadding(padding_needed, pacing_info);
}
}
if (is_probing && bytes_sent > 0)
@ -454,17 +454,18 @@ void PacedSender::Process() {
}
bool PacedSender::SendPacket(const paced_sender::Packet& packet,
int probe_cluster_id) {
const PacedPacketInfo& pacing_info) {
if (paused_)
return false;
if (media_budget_->bytes_remaining() == 0 &&
probe_cluster_id == PacketInfo::kNotAProbe) {
pacing_info.probe_cluster_id == PacedPacketInfo::kNotAProbe) {
return false;
}
critsect_->Leave();
const bool success = packet_sender_->TimeToSendPacket(
packet.ssrc, packet.sequence_number, packet.capture_time_ms,
packet.retransmission, probe_cluster_id);
packet.retransmission, pacing_info);
critsect_->Enter();
if (success) {
@ -479,10 +480,11 @@ bool PacedSender::SendPacket(const paced_sender::Packet& packet,
return success;
}
size_t PacedSender::SendPadding(size_t padding_needed, int probe_cluster_id) {
size_t PacedSender::SendPadding(size_t padding_needed,
const PacedPacketInfo& pacing_info) {
critsect_->Leave();
size_t bytes_sent =
packet_sender_->TimeToSendPadding(padding_needed, probe_cluster_id);
packet_sender_->TimeToSendPadding(padding_needed, pacing_info);
critsect_->Enter();
if (bytes_sent > 0) {

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

@ -46,10 +46,11 @@ class PacedSender : public Module, public RtpPacketSender {
uint16_t sequence_number,
int64_t capture_time_ms,
bool retransmission,
int probe_cluster_id) = 0;
const PacedPacketInfo& cluster_info) = 0;
// Called when it's a good time to send a padding data.
// Returns the number of bytes sent.
virtual size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) = 0;
virtual size_t TimeToSendPadding(size_t bytes,
const PacedPacketInfo& cluster_info) = 0;
protected:
virtual ~PacketSender() {}
@ -145,9 +146,10 @@ class PacedSender : public Module, public RtpPacketSender {
void UpdateBudgetWithBytesSent(size_t bytes)
EXCLUSIVE_LOCKS_REQUIRED(critsect_);
bool SendPacket(const paced_sender::Packet& packet, int probe_cluster_id)
bool SendPacket(const paced_sender::Packet& packet,
const PacedPacketInfo& cluster_info)
EXCLUSIVE_LOCKS_REQUIRED(critsect_);
size_t SendPadding(size_t padding_needed, int probe_cluster_id)
size_t SendPadding(size_t padding_needed, const PacedPacketInfo& cluster_info)
EXCLUSIVE_LOCKS_REQUIRED(critsect_);
Clock* const clock_;

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

@ -17,6 +17,7 @@
#include "webrtc/test/gtest.h"
using testing::_;
using testing::Field;
using testing::Return;
namespace {
@ -41,8 +42,9 @@ class MockPacedSenderCallback : public PacedSender::PacketSender {
uint16_t sequence_number,
int64_t capture_time_ms,
bool retransmission,
int probe_cluster_id));
MOCK_METHOD2(TimeToSendPadding, size_t(size_t bytes, int probe_cluster_id));
const PacedPacketInfo& pacing_info));
MOCK_METHOD2(TimeToSendPadding,
size_t(size_t bytes, const PacedPacketInfo& pacing_info));
};
class PacedSenderPadding : public PacedSender::PacketSender {
@ -53,11 +55,12 @@ class PacedSenderPadding : public PacedSender::PacketSender {
uint16_t sequence_number,
int64_t capture_time_ms,
bool retransmission,
int probe_cluster_id) override {
const PacedPacketInfo& pacing_info) override {
return true;
}
size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) override {
size_t TimeToSendPadding(size_t bytes,
const PacedPacketInfo& pacing_info) override {
const size_t kPaddingPacketSize = 224;
size_t num_packets = (bytes + kPaddingPacketSize - 1) / kPaddingPacketSize;
padding_sent_ += kPaddingPacketSize * num_packets;
@ -78,12 +81,13 @@ class PacedSenderProbing : public PacedSender::PacketSender {
uint16_t sequence_number,
int64_t capture_time_ms,
bool retransmission,
int probe_cluster_id) override {
const PacedPacketInfo& pacing_info) override {
packets_sent_++;
return true;
}
size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) override {
size_t TimeToSendPadding(size_t bytes,
const PacedPacketInfo& pacing_info) override {
padding_sent_ += bytes;
return padding_sent_;
}
@ -127,7 +131,6 @@ class PacedSenderTest : public ::testing::Test {
.Times(1)
.WillRepeatedly(Return(true));
}
SimulatedClock clock_;
MockPacedSenderCallback callback_;
std::unique_ptr<PacedSender> send_bucket_;
@ -1011,7 +1014,9 @@ TEST_F(PacedSenderTest, ProbeClusterId) {
}
// First probing cluster.
EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _, 0))
EXPECT_CALL(callback_,
TimeToSendPacket(_, _, _, _,
Field(&PacedPacketInfo::probe_cluster_id, 0)))
.Times(5)
.WillRepeatedly(Return(true));
for (int i = 0; i < 5; ++i) {
@ -1020,7 +1025,9 @@ TEST_F(PacedSenderTest, ProbeClusterId) {
}
// Second probing cluster.
EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _, 1))
EXPECT_CALL(callback_,
TimeToSendPacket(_, _, _, _,
Field(&PacedPacketInfo::probe_cluster_id, 1)))
.Times(5)
.WillRepeatedly(Return(true));
for (int i = 0; i < 5; ++i) {
@ -1028,10 +1035,14 @@ TEST_F(PacedSenderTest, ProbeClusterId) {
send_bucket_->Process();
}
// Needed for the Field comparer below.
const int kNotAProbe = PacedPacketInfo::kNotAProbe;
// No more probing packets.
EXPECT_CALL(callback_, TimeToSendPadding(_, PacketInfo::kNotAProbe))
.Times(1)
.WillRepeatedly(Return(500));
EXPECT_CALL(callback_,
TimeToSendPadding(
_, Field(&PacedPacketInfo::probe_cluster_id, kNotAProbe)))
.Times(1)
.WillRepeatedly(Return(500));
send_bucket_->Process();
}

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

@ -50,7 +50,7 @@ bool PacketRouter::TimeToSendPacket(uint32_t ssrc,
uint16_t sequence_number,
int64_t capture_timestamp,
bool retransmission,
int probe_cluster_id) {
const PacedPacketInfo& pacing_info) {
RTC_DCHECK(pacer_thread_checker_.CalledOnValidThread());
rtc::CritScope cs(&modules_crit_);
for (auto* rtp_module : rtp_modules_) {
@ -59,14 +59,14 @@ bool PacketRouter::TimeToSendPacket(uint32_t ssrc,
if (ssrc == rtp_module->SSRC() || ssrc == rtp_module->FlexfecSsrc()) {
return rtp_module->TimeToSendPacket(ssrc, sequence_number,
capture_timestamp, retransmission,
probe_cluster_id);
pacing_info);
}
}
return true;
}
size_t PacketRouter::TimeToSendPadding(size_t bytes_to_send,
int probe_cluster_id) {
const PacedPacketInfo& pacing_info) {
RTC_DCHECK(pacer_thread_checker_.CalledOnValidThread());
size_t total_bytes_sent = 0;
rtc::CritScope cs(&modules_crit_);
@ -74,7 +74,7 @@ size_t PacketRouter::TimeToSendPadding(size_t bytes_to_send,
for (RtpRtcp* module : rtp_modules_) {
if (module->SendingMedia() && module->HasBweExtensions()) {
size_t bytes_sent = module->TimeToSendPadding(
bytes_to_send - total_bytes_sent, probe_cluster_id);
bytes_to_send - total_bytes_sent, pacing_info);
total_bytes_sent += bytes_sent;
if (total_bytes_sent >= bytes_to_send)
break;

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

@ -44,9 +44,10 @@ class PacketRouter : public PacedSender::PacketSender,
uint16_t sequence_number,
int64_t capture_timestamp,
bool retransmission,
int probe_cluster_id) override;
const PacedPacketInfo& packet_info) override;
size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) override;
size_t TimeToSendPadding(size_t bytes,
const PacedPacketInfo& packet_info) override;
void SetTransportWideSequenceNumber(uint16_t sequence_number);
uint16_t AllocateSequenceNumber() override;

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

@ -21,6 +21,7 @@
using ::testing::_;
using ::testing::AnyNumber;
using ::testing::Field;
using ::testing::NiceMock;
using ::testing::Return;
@ -30,6 +31,8 @@ class PacketRouterTest : public ::testing::Test {
public:
PacketRouterTest() : packet_router_(new PacketRouter()) {}
protected:
static const int kProbeMinProbes = 5;
static const int kProbeMinBytes = 1000;
const std::unique_ptr<PacketRouter> packet_router_;
};
@ -47,13 +50,15 @@ TEST_F(PacketRouterTest, TimeToSendPacket) {
// Send on the first module by letting rtp_1 be sending with correct ssrc.
EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true));
EXPECT_CALL(rtp_1, SSRC()).Times(1).WillOnce(Return(kSsrc1));
EXPECT_CALL(rtp_1, TimeToSendPacket(kSsrc1, sequence_number, timestamp,
retransmission, 1))
EXPECT_CALL(rtp_1, TimeToSendPacket(
kSsrc1, sequence_number, timestamp, retransmission,
Field(&PacedPacketInfo::probe_cluster_id, 1)))
.Times(1)
.WillOnce(Return(true));
EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0);
EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1, sequence_number,
timestamp, retransmission, 1));
EXPECT_TRUE(packet_router_->TimeToSendPacket(
kSsrc1, sequence_number, timestamp, retransmission,
PacedPacketInfo(1, kProbeMinProbes, kProbeMinBytes)));
// Send on the second module by letting rtp_2 be sending, but not rtp_1.
++sequence_number;
@ -64,20 +69,23 @@ TEST_F(PacketRouterTest, TimeToSendPacket) {
EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true));
EXPECT_CALL(rtp_2, SSRC()).Times(1).WillOnce(Return(kSsrc2));
EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _, _)).Times(0);
EXPECT_CALL(rtp_2, TimeToSendPacket(kSsrc2, sequence_number, timestamp,
retransmission, 2))
EXPECT_CALL(rtp_2, TimeToSendPacket(
kSsrc2, sequence_number, timestamp, retransmission,
Field(&PacedPacketInfo::probe_cluster_id, 2)))
.Times(1)
.WillOnce(Return(true));
EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc2, sequence_number,
timestamp, retransmission, 2));
EXPECT_TRUE(packet_router_->TimeToSendPacket(
kSsrc2, sequence_number, timestamp, retransmission,
PacedPacketInfo(2, kProbeMinProbes, kProbeMinBytes)));
// No module is sending, hence no packet should be sent.
EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false));
EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _, _)).Times(0);
EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(false));
EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0);
EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1, sequence_number,
timestamp, retransmission, 1));
EXPECT_TRUE(packet_router_->TimeToSendPacket(
kSsrc1, sequence_number, timestamp, retransmission,
PacedPacketInfo(1, kProbeMinProbes, kProbeMinBytes)));
// Add a packet with incorrect ssrc and test it's dropped in the router.
EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true));
@ -86,8 +94,9 @@ TEST_F(PacketRouterTest, TimeToSendPacket) {
EXPECT_CALL(rtp_2, SSRC()).Times(1).WillOnce(Return(kSsrc2));
EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _, _)).Times(0);
EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0);
EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1 + kSsrc2, sequence_number,
timestamp, retransmission, 1));
EXPECT_TRUE(packet_router_->TimeToSendPacket(
kSsrc1 + kSsrc2, sequence_number, timestamp, retransmission,
PacedPacketInfo(1, kProbeMinProbes, kProbeMinBytes)));
packet_router_->RemoveRtpModule(&rtp_1);
@ -96,9 +105,10 @@ TEST_F(PacketRouterTest, TimeToSendPacket) {
EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true));
EXPECT_CALL(rtp_2, SSRC()).Times(1).WillOnce(Return(kSsrc2));
EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0);
EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1, sequence_number,
timestamp, retransmission,
PacketInfo::kNotAProbe));
EXPECT_TRUE(packet_router_->TimeToSendPacket(
kSsrc1, sequence_number, timestamp, retransmission,
PacedPacketInfo(PacedPacketInfo::kNotAProbe, kProbeMinBytes,
kProbeMinBytes)));
packet_router_->RemoveRtpModule(&rtp_2);
}
@ -123,17 +133,22 @@ TEST_F(PacketRouterTest, TimeToSendPadding) {
const size_t sent_padding_bytes = 890;
EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true));
EXPECT_CALL(rtp_2, HasBweExtensions()).Times(1).WillOnce(Return(true));
EXPECT_CALL(rtp_2, TimeToSendPadding(requested_padding_bytes, 111))
EXPECT_CALL(rtp_2,
TimeToSendPadding(requested_padding_bytes,
Field(&PacedPacketInfo::probe_cluster_id, 111)))
.Times(1)
.WillOnce(Return(sent_padding_bytes));
EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true));
EXPECT_CALL(rtp_1, HasBweExtensions()).Times(1).WillOnce(Return(true));
EXPECT_CALL(rtp_1, TimeToSendPadding(
requested_padding_bytes - sent_padding_bytes, 111))
EXPECT_CALL(rtp_1,
TimeToSendPadding(requested_padding_bytes - sent_padding_bytes,
Field(&PacedPacketInfo::probe_cluster_id, 111)))
.Times(1)
.WillOnce(Return(requested_padding_bytes - sent_padding_bytes));
EXPECT_EQ(requested_padding_bytes,
packet_router_->TimeToSendPadding(requested_padding_bytes, 111));
packet_router_->TimeToSendPadding(
requested_padding_bytes,
PacedPacketInfo(111, kProbeMinBytes, kProbeMinBytes)));
// Let only the lower priority module be sending and verify the padding
// request is routed there.
@ -145,16 +160,21 @@ TEST_F(PacketRouterTest, TimeToSendPadding) {
.Times(1)
.WillOnce(Return(sent_padding_bytes));
EXPECT_EQ(sent_padding_bytes,
packet_router_->TimeToSendPadding(requested_padding_bytes,
PacketInfo::kNotAProbe));
packet_router_->TimeToSendPadding(
requested_padding_bytes,
PacedPacketInfo(PacedPacketInfo::kNotAProbe, kProbeMinBytes,
kProbeMinBytes)));
// No sending module at all.
EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false));
EXPECT_CALL(rtp_1, TimeToSendPadding(requested_padding_bytes, _)).Times(0);
EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(false));
EXPECT_CALL(rtp_2, TimeToSendPadding(_, _)).Times(0);
EXPECT_EQ(0u, packet_router_->TimeToSendPadding(requested_padding_bytes,
PacketInfo::kNotAProbe));
EXPECT_EQ(0u,
packet_router_->TimeToSendPadding(
requested_padding_bytes,
PacedPacketInfo(PacedPacketInfo::kNotAProbe, kProbeMinBytes,
kProbeMinBytes)));
// Only one module has BWE extensions.
EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true));
@ -166,8 +186,10 @@ TEST_F(PacketRouterTest, TimeToSendPadding) {
.Times(1)
.WillOnce(Return(sent_padding_bytes));
EXPECT_EQ(sent_padding_bytes,
packet_router_->TimeToSendPadding(requested_padding_bytes,
PacketInfo::kNotAProbe));
packet_router_->TimeToSendPadding(
requested_padding_bytes,
PacedPacketInfo(PacedPacketInfo::kNotAProbe, kProbeMinBytes,
kProbeMinBytes)));
packet_router_->RemoveRtpModule(&rtp_1);
@ -176,8 +198,11 @@ TEST_F(PacketRouterTest, TimeToSendPadding) {
EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true));
EXPECT_CALL(rtp_2, HasBweExtensions()).Times(1).WillOnce(Return(true));
EXPECT_CALL(rtp_2, TimeToSendPadding(requested_padding_bytes, _)).Times(1);
EXPECT_EQ(0u, packet_router_->TimeToSendPadding(requested_padding_bytes,
PacketInfo::kNotAProbe));
EXPECT_EQ(0u,
packet_router_->TimeToSendPadding(
requested_padding_bytes,
PacedPacketInfo(PacedPacketInfo::kNotAProbe, kProbeMinBytes,
kProbeMinBytes)));
packet_router_->RemoveRtpModule(&rtp_2);
}
@ -191,11 +216,15 @@ TEST_F(PacketRouterTest, SenderOnlyFunctionsRespectSendingMedia) {
// Verify that TimeToSendPacket does not end up in a receiver.
EXPECT_CALL(rtp, TimeToSendPacket(_, _, _, _, _)).Times(0);
EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc, 1, 1, false,
PacketInfo::kNotAProbe));
EXPECT_TRUE(packet_router_->TimeToSendPacket(
kSsrc, 1, 1, false, PacedPacketInfo(PacedPacketInfo::kNotAProbe,
kProbeMinBytes, kProbeMinBytes)));
// Verify that TimeToSendPadding does not end up in a receiver.
EXPECT_CALL(rtp, TimeToSendPadding(_, _)).Times(0);
EXPECT_EQ(0u, packet_router_->TimeToSendPadding(200, PacketInfo::kNotAProbe));
EXPECT_EQ(0u,
packet_router_->TimeToSendPadding(
200, PacedPacketInfo(PacedPacketInfo::kNotAProbe,
kProbeMinBytes, kProbeMinBytes)));
packet_router_->RemoveRtpModule(&rtp);
}

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

@ -52,7 +52,7 @@ class PacketInfo : public webrtc::PacketInfo {
0,
sequence_number,
0,
PacketInfo::kNotAProbe) {}
PacedPacketInfo::kNotAProbe) {}
PacketInfo(int64_t arrival_time_ms,
int64_t send_time_ms,
uint16_t sequence_number,
@ -98,7 +98,7 @@ TEST_F(SendTimeHistoryTest, PopulatesExpectedFields) {
const size_t kPayloadSize = 42;
AddPacketWithSendTime(kSeqNo, kPayloadSize, kSendTime,
PacketInfo::kNotAProbe);
PacedPacketInfo::kNotAProbe);
PacketInfo info(kReceiveTime, kSeqNo);
EXPECT_TRUE(history_.GetInfo(&info, true));
@ -121,7 +121,7 @@ TEST_F(SendTimeHistoryTest, AddThenRemoveOutOfOrder) {
kProbeClusterId));
received_packets.push_back(PacketInfo(
static_cast<int64_t>(i) + kTransmissionTime, 0,
static_cast<uint16_t>(i), kPacketSize, PacketInfo::kNotAProbe));
static_cast<uint16_t>(i), kPacketSize, PacedPacketInfo::kNotAProbe));
}
for (size_t i = 0; i < num_items; ++i) {
history_.AddAndRemoveOld(sent_packets[i].sequence_number,
@ -148,19 +148,21 @@ TEST_F(SendTimeHistoryTest, HistorySize) {
const int kItems = kDefaultHistoryLengthMs / 100;
for (int i = 0; i < kItems; ++i) {
clock_.AdvanceTimeMilliseconds(100);
AddPacketWithSendTime(i, 0, i * 100, PacketInfo::kNotAProbe);
AddPacketWithSendTime(i, 0, i * 100, PacedPacketInfo::kNotAProbe);
}
for (int i = 0; i < kItems; ++i) {
PacketInfo info(0, 0, static_cast<uint16_t>(i), 0, PacketInfo::kNotAProbe);
PacketInfo info(0, 0, static_cast<uint16_t>(i), 0,
PacedPacketInfo::kNotAProbe);
EXPECT_TRUE(history_.GetInfo(&info, false));
EXPECT_EQ(i * 100, info.send_time_ms);
}
clock_.AdvanceTimeMilliseconds(101);
AddPacketWithSendTime(kItems, 0, kItems * 101, PacketInfo::kNotAProbe);
PacketInfo info(0, 0, 0, 0, PacketInfo::kNotAProbe);
AddPacketWithSendTime(kItems, 0, kItems * 101, PacedPacketInfo::kNotAProbe);
PacketInfo info(0, 0, 0, 0, PacedPacketInfo::kNotAProbe);
EXPECT_FALSE(history_.GetInfo(&info, false));
for (int i = 1; i < (kItems + 1); ++i) {
PacketInfo info2(0, 0, static_cast<uint16_t>(i), 0, PacketInfo::kNotAProbe);
PacketInfo info2(0, 0, static_cast<uint16_t>(i), 0,
PacedPacketInfo::kNotAProbe);
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);
@ -169,16 +171,17 @@ TEST_F(SendTimeHistoryTest, HistorySize) {
TEST_F(SendTimeHistoryTest, HistorySizeWithWraparound) {
const uint16_t kMaxSeqNo = std::numeric_limits<uint16_t>::max();
AddPacketWithSendTime(kMaxSeqNo - 2, 0, 0, PacketInfo::kNotAProbe);
AddPacketWithSendTime(kMaxSeqNo - 2, 0, 0, PacedPacketInfo::kNotAProbe);
clock_.AdvanceTimeMilliseconds(100);
AddPacketWithSendTime(kMaxSeqNo - 1, 1, 100, PacketInfo::kNotAProbe);
AddPacketWithSendTime(kMaxSeqNo - 1, 1, 100, PacedPacketInfo::kNotAProbe);
clock_.AdvanceTimeMilliseconds(100);
AddPacketWithSendTime(kMaxSeqNo, 0, 200, PacketInfo::kNotAProbe);
AddPacketWithSendTime(kMaxSeqNo, 0, 200, PacedPacketInfo::kNotAProbe);
clock_.AdvanceTimeMilliseconds(kDefaultHistoryLengthMs - 200 + 1);
AddPacketWithSendTime(0, 0, kDefaultHistoryLengthMs, PacketInfo::kNotAProbe);
AddPacketWithSendTime(0, 0, kDefaultHistoryLengthMs,
PacedPacketInfo::kNotAProbe);
PacketInfo info(0, static_cast<uint16_t>(kMaxSeqNo - 2));
EXPECT_FALSE(history_.GetInfo(&info, false));
@ -194,7 +197,7 @@ TEST_F(SendTimeHistoryTest, HistorySizeWithWraparound) {
EXPECT_TRUE(history_.GetInfo(&info5, true));
clock_.AdvanceTimeMilliseconds(100);
AddPacketWithSendTime(1, 0, 1100, PacketInfo::kNotAProbe);
AddPacketWithSendTime(1, 0, 1100, PacedPacketInfo::kNotAProbe);
PacketInfo info6(0, static_cast<uint16_t>(kMaxSeqNo - 2));
EXPECT_FALSE(history_.GetInfo(&info6, false));

2
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(),
PacketInfo::kNotAProbe);
PacedPacketInfo::kNotAProbe);
send_time_history_.OnSentPacket(media_packet->header().sequenceNumber,
media_packet->sender_timestamp_ms());
}

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

@ -275,7 +275,7 @@ bool PacedVideoSender::TimeToSendPacket(uint32_t ssrc,
uint16_t sequence_number,
int64_t capture_time_ms,
bool retransmission,
int probe_cluster_id) {
const PacedPacketInfo& pacing_info) {
for (Packets::iterator it = pacer_queue_.begin(); it != pacer_queue_.end();
++it) {
MediaPacket* media_packet = static_cast<MediaPacket*>(*it);
@ -297,7 +297,8 @@ bool PacedVideoSender::TimeToSendPacket(uint32_t ssrc,
return false;
}
size_t PacedVideoSender::TimeToSendPadding(size_t bytes, int probe_cluster_id) {
size_t PacedVideoSender::TimeToSendPadding(size_t bytes,
const PacedPacketInfo& pacing_info) {
return 0;
}

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

@ -114,8 +114,9 @@ class PacedVideoSender : public VideoSender, public PacedSender::PacketSender {
uint16_t sequence_number,
int64_t capture_time_ms,
bool retransmission,
int probe_cluster_id) override;
size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) override;
const PacedPacketInfo& pacing_info) override;
size_t TimeToSendPadding(size_t bytes,
const PacedPacketInfo& pacing_info) override;
// Implements BitrateObserver.
void OnNetworkChanged(uint32_t target_bitrate_bps,

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

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

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

@ -251,7 +251,7 @@ struct PacketInfo {
-1,
sequence_number,
0,
kNotAProbe) {}
PacedPacketInfo::kNotAProbe) {}
PacketInfo(int64_t arrival_time_ms,
int64_t send_time_ms,
@ -278,8 +278,6 @@ struct PacketInfo {
payload_size(payload_size),
probe_cluster_id(probe_cluster_id) {}
static constexpr int kNotAProbe = -1;
// Time corresponding to when this object was created.
int64_t creation_time_ms;
// Time corresponding to when the packet was received. Timestamped with the
@ -294,6 +292,7 @@ struct PacketInfo {
// 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;
};

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

@ -114,8 +114,9 @@ class MockRtpRtcp : public RtpRtcp {
uint16_t sequence_number,
int64_t capture_time_ms,
bool retransmission,
int probe_cluster_id));
MOCK_METHOD2(TimeToSendPadding, size_t(size_t bytes, int probe_cluster_id));
const PacedPacketInfo& pacing_info));
MOCK_METHOD2(TimeToSendPadding,
size_t(size_t bytes, const PacedPacketInfo& pacing_info));
MOCK_METHOD2(RegisterRtcpObservers,
void(RtcpIntraFrameObserver* intra_frame_callback,
RtcpBandwidthObserver* bandwidth_callback));

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

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

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

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

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

@ -622,7 +622,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,
PacketInfo::kNotAProbe))
PacedPacketInfo::kNotAProbe))
return -1;
return packet_size;
}
@ -880,7 +880,7 @@ bool RTPSender::SendToNetwork(std::unique_ptr<RtpPacketToSend> packet,
PacketOptions options;
if (UpdateTransportSequenceNumber(packet.get(), &options.packet_id)) {
AddPacketToTransportFeedback(options.packet_id, *packet.get(),
PacketInfo::kNotAProbe);
PacedPacketInfo::kNotAProbe);
}
UpdateDelayStatistics(packet->capture_time_ms(), now_ms);

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

@ -355,7 +355,7 @@ TEST_F(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
EXPECT_CALL(feedback_observer_,
AddPacket(kTransportSequenceNumber,
sizeof(kPayloadData) + kGenericHeaderLength,
PacketInfo::kNotAProbe))
PacedPacketInfo::kNotAProbe))
.Times(1);
SendGenericPayload();
@ -450,7 +450,7 @@ TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum, capture_time_ms, false,
PacketInfo::kNotAProbe);
PacedPacketInfo::kNotAProbe);
// Process send bucket. Packet should now be sent.
EXPECT_EQ(1, transport_.packets_sent());
@ -501,7 +501,7 @@ TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
EXPECT_EQ(0, transport_.packets_sent());
rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum, capture_time_ms, false,
PacketInfo::kNotAProbe);
PacedPacketInfo::kNotAProbe);
// Process send bucket. Packet should now be sent.
EXPECT_EQ(1, transport_.packets_sent());
@ -560,7 +560,7 @@ TEST_F(RtpSenderTest, SendPadding) {
const int kStoredTimeInMs = 100;
fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
rtp_sender_->TimeToSendPacket(kSsrc, seq_num++, capture_time_ms, false,
PacketInfo::kNotAProbe);
PacedPacketInfo::kNotAProbe);
// 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());
@ -572,8 +572,9 @@ TEST_F(RtpSenderTest, SendPadding) {
const size_t kPaddingBytes = 100;
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, PacketInfo::kNotAProbe));
EXPECT_EQ(kMaxPaddingLength,
rtp_sender_->TimeToSendPadding(kPaddingBytes,
PacedPacketInfo::kNotAProbe));
// Process send bucket. Padding should now be sent.
EXPECT_EQ(++total_packets_sent, transport_.packets_sent());
@ -611,7 +612,7 @@ TEST_F(RtpSenderTest, SendPadding) {
RtpPacketSender::kNormalPriority));
rtp_sender_->TimeToSendPacket(kSsrc, seq_num, capture_time_ms, false,
PacketInfo::kNotAProbe);
PacedPacketInfo::kNotAProbe);
// Process send bucket.
EXPECT_EQ(++total_packets_sent, transport_.packets_sent());
EXPECT_EQ(packet_size, transport_.last_sent_packet().size());
@ -645,7 +646,7 @@ TEST_F(RtpSenderTest, OnSendPacketUpdated) {
const bool kIsRetransmit = false;
rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum,
fake_clock_.TimeInMilliseconds(), kIsRetransmit,
PacketInfo::kNotAProbe);
PacedPacketInfo::kNotAProbe);
EXPECT_EQ(1, transport_.packets_sent());
}
@ -665,7 +666,7 @@ TEST_F(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) {
const bool kIsRetransmit = true;
rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum,
fake_clock_.TimeInMilliseconds(), kIsRetransmit,
PacketInfo::kNotAProbe);
PacedPacketInfo::kNotAProbe);
EXPECT_EQ(1, transport_.packets_sent());
}
@ -691,7 +692,7 @@ TEST_F(RtpSenderTest, OnSendPacketNotUpdatedWithoutSeqNumAllocator) {
const bool kIsRetransmit = false;
rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum,
fake_clock_.TimeInMilliseconds(), kIsRetransmit,
PacketInfo::kNotAProbe);
PacedPacketInfo::kNotAProbe);
EXPECT_EQ(1, transport_.packets_sent());
}
@ -734,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,
PacketInfo::kNotAProbe);
PacedPacketInfo::kNotAProbe);
fake_clock_.AdvanceTimeMilliseconds(33);
}
@ -746,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, PacketInfo::kNotAProbe));
rtp_sender_->TimeToSendPadding(49, PacedPacketInfo::kNotAProbe));
EXPECT_CALL(transport,
SendRtp(_, kPayloadSizes[0] + rtp_header_len + kRtxHeaderSize, _))
.WillOnce(testing::Return(true));
EXPECT_EQ(kPayloadSizes[0],
rtp_sender_->TimeToSendPadding(500, PacketInfo::kNotAProbe));
rtp_sender_->TimeToSendPadding(500, PacedPacketInfo::kNotAProbe));
EXPECT_CALL(transport, SendRtp(_, kPayloadSizes[kNumPayloadSizes - 1] +
rtp_header_len + kRtxHeaderSize,
@ -761,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, PacketInfo::kNotAProbe));
rtp_sender_->TimeToSendPadding(999, PacedPacketInfo::kNotAProbe));
}
TEST_F(RtpSenderTestWithoutPacer, SendGenericVideo) {
@ -1155,7 +1156,7 @@ TEST_F(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) {
callback.Matches(ssrc, expected);
// Send padding.
rtp_sender_->TimeToSendPadding(kMaxPaddingSize, PacketInfo::kNotAProbe);
rtp_sender_->TimeToSendPadding(kMaxPaddingSize, PacedPacketInfo::kNotAProbe);
expected.transmitted.payload_bytes = 12;
expected.transmitted.header_bytes = 36;
expected.transmitted.padding_bytes = kMaxPaddingSize;
@ -1283,8 +1284,8 @@ TEST_F(RtpSenderTestWithoutPacer, BytesReportedCorrectly) {
sizeof(payload), nullptr, nullptr, nullptr));
// Will send 2 full-size padding packets.
rtp_sender_->TimeToSendPadding(1, PacketInfo::kNotAProbe);
rtp_sender_->TimeToSendPadding(1, PacketInfo::kNotAProbe);
rtp_sender_->TimeToSendPadding(1, PacedPacketInfo::kNotAProbe);
rtp_sender_->TimeToSendPadding(1, PacedPacketInfo::kNotAProbe);
StreamDataCounters rtp_stats;
StreamDataCounters rtx_stats;
@ -1483,7 +1484,7 @@ TEST_F(RtpSenderTest, AddOverheadToTransportFeedbackObserver) {
AddPacket(kTransportSequenceNumber,
sizeof(kPayloadData) + kGenericHeaderLength +
kRtpOverheadBytesPerPacket,
PacketInfo::kNotAProbe))
PacedPacketInfo::kNotAProbe))
.Times(1);
EXPECT_CALL(mock_overhead_observer,
OnOverheadChanged(kRtpOverheadBytesPerPacket))
@ -1506,14 +1507,16 @@ TEST_F(RtpSenderTest, SendAudioPadding) {
const size_t kPaddingSize = 59;
EXPECT_CALL(transport, SendRtp(_, kPaddingSize + kRtpHeaderSize, _))
.WillOnce(testing::Return(true));
EXPECT_EQ(kPaddingSize, rtp_sender_->TimeToSendPadding(
kPaddingSize, PacketInfo::kNotAProbe));
EXPECT_EQ(kPaddingSize,
rtp_sender_->TimeToSendPadding(kPaddingSize,
PacedPacketInfo::kNotAProbe));
// 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, PacketInfo::kNotAProbe));
EXPECT_EQ(kMinPaddingSize,
rtp_sender_->TimeToSendPadding(kMinPaddingSize - 5,
PacedPacketInfo::kNotAProbe));
}
} // namespace webrtc

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

@ -1054,7 +1054,7 @@ void EventLogAnalyzer::CreateBweSimulationGraph(Plot* plot) {
RTC_DCHECK(rtp.header.extension.hasTransportSequenceNumber);
cc.GetTransportFeedbackObserver()->AddPacket(
rtp.header.extension.transportSequenceNumber, rtp.total_length,
PacketInfo::kNotAProbe);
PacedPacketInfo::kNotAProbe);
rtc::SentPacket sent_packet(
rtp.header.extension.transportSequenceNumber, rtp.timestamp / 1000);
cc.OnSentPacket(sent_packet);
@ -1184,7 +1184,8 @@ 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, PacketInfo::kNotAProbe);
rtp.total_length,
PacedPacketInfo::kNotAProbe);
feedback_adapter.OnSentPacket(
rtp.header.extension.transportSequenceNumber, rtp.timestamp / 1000);
}