generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Only use paced packets for estimating bitrate probes.

Browse Source 
BUG=4778
R=mflodman@webrtc.org, solenberg@webrtc.org

Review URL: https://codereview.webrtc.org/1188823007.

Cr-Commit-Position: refs/heads/master@{#9463}
This commit is contained in:
Stefan Holmer 2015-06-18 16:01:33 +02:00
parent 141725f50f
commit ff4ea9310e
13 changed files with 98 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h
View File

@ -67,11 +67,13 @@ struct PacketInfo {
PacketInfo(int64_t arrival_time_ms, PacketInfo(int64_t arrival_time_ms,
int64_t send_time_ms, int64_t send_time_ms,
uint16_t sequence_number, uint16_t sequence_number,
size_t payload_size) size_t payload_size,
bool was_paced)
: arrival_time_ms(arrival_time_ms), : arrival_time_ms(arrival_time_ms),
send_time_ms(send_time_ms), send_time_ms(send_time_ms),
sequence_number(sequence_number), sequence_number(sequence_number),
payload_size(payload_size) {} payload_size(payload_size),
was_paced(was_paced) {}
// Time corresponding to when the packet was received. Timestamped with the // Time corresponding to when the packet was received. Timestamped with the
// receiver's clock. // receiver's clock.
int64_t arrival_time_ms; int64_t arrival_time_ms;
@ -83,6 +85,8 @@ struct PacketInfo {
uint16_t sequence_number; uint16_t sequence_number;
// Size of the packet excluding RTP headers. // Size of the packet excluding RTP headers.
size_t payload_size; size_t payload_size;
// True if the packet was paced out by the pacer.
bool was_paced;
}; };
class RemoteBitrateEstimator : public CallStatsObserver, public Module { class RemoteBitrateEstimator : public CallStatsObserver, public Module {
@ -101,7 +105,8 @@ class RemoteBitrateEstimator : public CallStatsObserver, public Module {
// Note that |arrival_time_ms| can be of an arbitrary time base. // Note that |arrival_time_ms| can be of an arbitrary time base.
virtual void IncomingPacket(int64_t arrival_time_ms, virtual void IncomingPacket(int64_t arrival_time_ms,
size_t payload_size, size_t payload_size,
const RTPHeader& header) = 0; const RTPHeader& header,
bool was_paced) = 0;
// Removes all data for |ssrc|. // Removes all data for |ssrc|.
virtual void RemoveStream(unsigned int ssrc) = 0; virtual void RemoveStream(unsigned int ssrc) = 0;

21
webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.cc
View File

@ -116,7 +116,8 @@ class RemoteBitrateEstimatorAbsSendTimeImpl : public RemoteBitrateEstimator {
void IncomingPacket(int64_t arrival_time_ms, void IncomingPacket(int64_t arrival_time_ms,
size_t payload_size, size_t payload_size,
const RTPHeader& header) override; const RTPHeader& header,
bool was_paced) override;
// This class relies on Process() being called periodically (at least once // This class relies on Process() being called periodically (at least once
// every other second) for streams to be timed out properly. Therefore it // every other second) for streams to be timed out properly. Therefore it
// shouldn't be detached from the ProcessThread except if it's about to be // shouldn't be detached from the ProcessThread except if it's about to be
@ -155,7 +156,8 @@ class RemoteBitrateEstimatorAbsSendTimeImpl : public RemoteBitrateEstimator {
void IncomingPacketInfo(int64_t arrival_time_ms, void IncomingPacketInfo(int64_t arrival_time_ms,
uint32_t send_time_24bits, uint32_t send_time_24bits,
size_t payload_size, size_t payload_size,
uint32_t ssrc); uint32_t ssrc,
bool was_paced);
bool IsProbe(int64_t send_time_ms, int payload_size) const bool IsProbe(int64_t send_time_ms, int payload_size) const
EXCLUSIVE_LOCKS_REQUIRED(crit_sect_.get()); EXCLUSIVE_LOCKS_REQUIRED(crit_sect_.get());
@ -338,27 +340,29 @@ void RemoteBitrateEstimatorAbsSendTimeImpl::IncomingPacketFeedbackVector(
uint32_t send_time_24bits = uint32_t send_time_24bits =
send_time_32bits >> kAbsSendTimeInterArrivalUpshift; send_time_32bits >> kAbsSendTimeInterArrivalUpshift;
IncomingPacketInfo(packet_info.arrival_time_ms, send_time_24bits, IncomingPacketInfo(packet_info.arrival_time_ms, send_time_24bits,
packet_info.payload_size, 0); packet_info.payload_size, 0, packet_info.was_paced);
} }
} }
void RemoteBitrateEstimatorAbsSendTimeImpl::IncomingPacket( void RemoteBitrateEstimatorAbsSendTimeImpl::IncomingPacket(
int64_t arrival_time_ms, int64_t arrival_time_ms,
size_t payload_size, size_t payload_size,
const RTPHeader& header) { const RTPHeader& header,
bool was_paced) {
if (!header.extension.hasAbsoluteSendTime) { if (!header.extension.hasAbsoluteSendTime) {
LOG(LS_WARNING) << "RemoteBitrateEstimatorAbsSendTimeImpl: Incoming packet " LOG(LS_WARNING) << "RemoteBitrateEstimatorAbsSendTimeImpl: Incoming packet "
"is missing absolute send time extension!"; "is missing absolute send time extension!";
} }
IncomingPacketInfo(arrival_time_ms, header.extension.absoluteSendTime, IncomingPacketInfo(arrival_time_ms, header.extension.absoluteSendTime,
payload_size, header.ssrc); payload_size, header.ssrc, was_paced);
} }
void RemoteBitrateEstimatorAbsSendTimeImpl::IncomingPacketInfo( void RemoteBitrateEstimatorAbsSendTimeImpl::IncomingPacketInfo(
int64_t arrival_time_ms, int64_t arrival_time_ms,
uint32_t send_time_24bits, uint32_t send_time_24bits,
size_t payload_size, size_t payload_size,
uint32_t ssrc) { uint32_t ssrc,
bool was_paced) {
assert(send_time_24bits < (1ul << 24)); assert(send_time_24bits < (1ul << 24));
// Shift up send time to use the full 32 bits that inter_arrival works with, // Shift up send time to use the full 32 bits that inter_arrival works with,
// so wrapping works properly. // so wrapping works properly.
@ -380,8 +384,9 @@ void RemoteBitrateEstimatorAbsSendTimeImpl::IncomingPacketInfo(
int64_t t_delta = 0; int64_t t_delta = 0;
int size_delta = 0; int size_delta = 0;
// For now only try to detect probes while we don't have a valid estimate. // For now only try to detect probes while we don't have a valid estimate.
if (!remote_rate_->ValidEstimate() || if (was_paced &&
now_ms - first_packet_time_ms_ < kInitialProbingIntervalMs) { (!remote_rate_->ValidEstimate() ||
now_ms - first_packet_time_ms_ < kInitialProbingIntervalMs)) {
// TODO(holmer): Use a map instead to get correct order? // TODO(holmer): Use a map instead to get correct order?
if (total_probes_received_ < kMaxProbePackets) { if (total_probes_received_ < kMaxProbePackets) {
int send_delta_ms = -1; int send_delta_ms = -1;

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

@ -99,7 +99,7 @@ TEST_F(RemoteBitrateEstimatorAbsSendTimeTest, TestProcessAfterTimeout) {
// RemoteBitrateEstimator. // RemoteBitrateEstimator.
const int64_t kStreamTimeOutMs = 2000; const int64_t kStreamTimeOutMs = 2000;
const int64_t kProcessIntervalMs = 1000; const int64_t kProcessIntervalMs = 1000;
IncomingPacket(0, 1000, clock_.TimeInMilliseconds(), 0, 0); IncomingPacket(0, 1000, clock_.TimeInMilliseconds(), 0, 0, true);
clock_.AdvanceTimeMilliseconds(kStreamTimeOutMs + 1); clock_.AdvanceTimeMilliseconds(kStreamTimeOutMs + 1);
// Trigger timeout. // Trigger timeout.
EXPECT_EQ(0, bitrate_estimator_->Process()); EXPECT_EQ(0, bitrate_estimator_->Process());
@ -115,14 +115,16 @@ TEST_F(RemoteBitrateEstimatorAbsSendTimeTest, TestProbeDetection) {
for (int i = 0; i < kProbeLength; ++i) { for (int i = 0; i < kProbeLength; ++i) {
clock_.AdvanceTimeMilliseconds(10); clock_.AdvanceTimeMilliseconds(10);
now_ms = clock_.TimeInMilliseconds(); now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000)); IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000),
true);
} }
// Second burst sent at 8 * 1000 / 5 = 1600 kbps. // Second burst sent at 8 * 1000 / 5 = 1600 kbps.
for (int i = 0; i < kProbeLength; ++i) { for (int i = 0; i < kProbeLength; ++i) {
clock_.AdvanceTimeMilliseconds(5); clock_.AdvanceTimeMilliseconds(5);
now_ms = clock_.TimeInMilliseconds(); now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000)); IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000),
true);
} }
EXPECT_EQ(0, bitrate_estimator_->Process()); EXPECT_EQ(0, bitrate_estimator_->Process());
@ -130,6 +132,28 @@ TEST_F(RemoteBitrateEstimatorAbsSendTimeTest, TestProbeDetection) {
EXPECT_GT(bitrate_observer_->latest_bitrate(), 1500000u); EXPECT_GT(bitrate_observer_->latest_bitrate(), 1500000u);
} }
TEST_F(RemoteBitrateEstimatorAbsSendTimeTest,
TestProbeDetectionNonPacedPackets) {
const int kProbeLength = 5;
int64_t now_ms = clock_.TimeInMilliseconds();
// First burst sent at 8 * 1000 / 10 = 800 kbps, but with every other packet
// not being paced which could mess things up.
for (int i = 0; i < kProbeLength; ++i) {
clock_.AdvanceTimeMilliseconds(5);
now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000),
true);
// Non-paced packet, arriving 5 ms after.
clock_.AdvanceTimeMilliseconds(5);
IncomingPacket(0, 100, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000),
false);
}
EXPECT_EQ(0, bitrate_estimator_->Process());
EXPECT_TRUE(bitrate_observer_->updated());
EXPECT_GT(bitrate_observer_->latest_bitrate(), 800000u);
}
// Packets will require 5 ms to be transmitted to the receiver, causing packets // Packets will require 5 ms to be transmitted to the receiver, causing packets
// of the second probe to be dispersed. // of the second probe to be dispersed.
TEST_F(RemoteBitrateEstimatorAbsSendTimeTest, TEST_F(RemoteBitrateEstimatorAbsSendTimeTest,
@ -143,7 +167,7 @@ TEST_F(RemoteBitrateEstimatorAbsSendTimeTest,
now_ms = clock_.TimeInMilliseconds(); now_ms = clock_.TimeInMilliseconds();
send_time_ms += 10; send_time_ms += 10;
IncomingPacket(0, 1000, now_ms, 90 * send_time_ms, IncomingPacket(0, 1000, now_ms, 90 * send_time_ms,
AbsSendTime(send_time_ms, 1000)); AbsSendTime(send_time_ms, 1000), true);
} }
// Second burst sent at 8 * 1000 / 5 = 1600 kbps, arriving at 8 * 1000 / 8 = // Second burst sent at 8 * 1000 / 5 = 1600 kbps, arriving at 8 * 1000 / 8 =
@ -153,7 +177,7 @@ TEST_F(RemoteBitrateEstimatorAbsSendTimeTest,
now_ms = clock_.TimeInMilliseconds(); now_ms = clock_.TimeInMilliseconds();
send_time_ms += 5; send_time_ms += 5;
IncomingPacket(0, 1000, now_ms, send_time_ms, IncomingPacket(0, 1000, now_ms, send_time_ms,
AbsSendTime(send_time_ms, 1000)); AbsSendTime(send_time_ms, 1000), true);
} }
EXPECT_EQ(0, bitrate_estimator_->Process()); EXPECT_EQ(0, bitrate_estimator_->Process());
@ -173,7 +197,7 @@ TEST_F(RemoteBitrateEstimatorAbsSendTimeTest,
send_time_ms += 10; send_time_ms += 10;
now_ms = clock_.TimeInMilliseconds(); now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * send_time_ms, IncomingPacket(0, 1000, now_ms, 90 * send_time_ms,
AbsSendTime(send_time_ms, 1000)); AbsSendTime(send_time_ms, 1000), true);
} }
EXPECT_EQ(0, bitrate_estimator_->Process()); EXPECT_EQ(0, bitrate_estimator_->Process());
@ -192,7 +216,7 @@ TEST_F(RemoteBitrateEstimatorAbsSendTimeTest, TestProbeDetectionFasterArrival) {
send_time_ms += 10; send_time_ms += 10;
now_ms = clock_.TimeInMilliseconds(); now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * send_time_ms, IncomingPacket(0, 1000, now_ms, 90 * send_time_ms,
AbsSendTime(send_time_ms, 1000)); AbsSendTime(send_time_ms, 1000), true);
} }
EXPECT_EQ(0, bitrate_estimator_->Process()); EXPECT_EQ(0, bitrate_estimator_->Process());
@ -210,7 +234,7 @@ TEST_F(RemoteBitrateEstimatorAbsSendTimeTest, TestProbeDetectionSlowerArrival) {
send_time_ms += 5; send_time_ms += 5;
now_ms = clock_.TimeInMilliseconds(); now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * send_time_ms, IncomingPacket(0, 1000, now_ms, 90 * send_time_ms,
AbsSendTime(send_time_ms, 1000)); AbsSendTime(send_time_ms, 1000), true);
} }
EXPECT_EQ(0, bitrate_estimator_->Process()); EXPECT_EQ(0, bitrate_estimator_->Process());
@ -230,7 +254,7 @@ TEST_F(RemoteBitrateEstimatorAbsSendTimeTest,
send_time_ms += 1; send_time_ms += 1;
now_ms = clock_.TimeInMilliseconds(); now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * send_time_ms, IncomingPacket(0, 1000, now_ms, 90 * send_time_ms,
AbsSendTime(send_time_ms, 1000)); AbsSendTime(send_time_ms, 1000), true);
} }
EXPECT_EQ(0, bitrate_estimator_->Process()); EXPECT_EQ(0, bitrate_estimator_->Process());

9
webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc
View File

@ -38,7 +38,8 @@ class RemoteBitrateEstimatorImpl : public RemoteBitrateEstimator {
void IncomingPacket(int64_t arrival_time_ms, void IncomingPacket(int64_t arrival_time_ms,
size_t payload_size, size_t payload_size,
const RTPHeader& header) override; const RTPHeader& header,
bool was_paced) override;
int32_t Process() override; int32_t Process() override;
int64_t TimeUntilNextProcess() override; int64_t TimeUntilNextProcess() override;
void OnRttUpdate(int64_t rtt) override; void OnRttUpdate(int64_t rtt) override;
@ -107,10 +108,10 @@ RemoteBitrateEstimatorImpl::~RemoteBitrateEstimatorImpl() {
} }
} }
void RemoteBitrateEstimatorImpl::IncomingPacket( void RemoteBitrateEstimatorImpl::IncomingPacket(int64_t arrival_time_ms,
int64_t arrival_time_ms,
size_t payload_size, size_t payload_size,
const RTPHeader& header) { const RTPHeader& header,
bool was_paced) {
uint32_t ssrc = header.ssrc; uint32_t ssrc = header.ssrc;
uint32_t rtp_timestamp = header.timestamp + uint32_t rtp_timestamp = header.timestamp +
header.extension.transmissionTimeOffset; header.extension.transmissionTimeOffset;

44
webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.cc
View File

@ -221,7 +221,8 @@ void RemoteBitrateEstimatorTest::IncomingPacket(uint32_t ssrc,
size_t payload_size, size_t payload_size,
int64_t arrival_time, int64_t arrival_time,
uint32_t rtp_timestamp, uint32_t rtp_timestamp,
uint32_t absolute_send_time) { uint32_t absolute_send_time,
bool was_paced) {
RTPHeader header; RTPHeader header;
memset(&header, 0, sizeof(header)); memset(&header, 0, sizeof(header));
header.ssrc = ssrc; header.ssrc = ssrc;
@ -229,7 +230,7 @@ void RemoteBitrateEstimatorTest::IncomingPacket(uint32_t ssrc,
header.extension.hasAbsoluteSendTime = true; header.extension.hasAbsoluteSendTime = true;
header.extension.absoluteSendTime = absolute_send_time; header.extension.absoluteSendTime = absolute_send_time;
bitrate_estimator_->IncomingPacket(arrival_time + kArrivalTimeClockOffsetMs, bitrate_estimator_->IncomingPacket(arrival_time + kArrivalTimeClockOffsetMs,
payload_size, header); payload_size, header, was_paced);
} }
// Generates a frame of packets belonging to a stream at a given bitrate and // Generates a frame of packets belonging to a stream at a given bitrate and
@ -252,11 +253,9 @@ bool RemoteBitrateEstimatorTest::GenerateAndProcessFrame(unsigned int ssrc,
// since both are used in IncomingPacket(). // since both are used in IncomingPacket().
clock_.AdvanceTimeMicroseconds(packet->arrival_time - clock_.AdvanceTimeMicroseconds(packet->arrival_time -
clock_.TimeInMicroseconds()); clock_.TimeInMicroseconds());
IncomingPacket(packet->ssrc, IncomingPacket(packet->ssrc, packet->size,
packet->size, (packet->arrival_time + 500) / 1000, packet->rtp_timestamp,
(packet->arrival_time + 500) / 1000, AbsSendTime(packet->send_time, 1000000), true);
packet->rtp_timestamp,
AbsSendTime(packet->send_time, 1000000));
if (bitrate_observer_->updated()) { if (bitrate_observer_->updated()) {
// Verify that new estimates only are triggered by an overuse and a // Verify that new estimates only are triggered by an overuse and a
// rate decrease. // rate decrease.
@ -323,7 +322,7 @@ void RemoteBitrateEstimatorTest::InitialBehaviorTestHelper(
clock_.AdvanceTimeMilliseconds(1000); clock_.AdvanceTimeMilliseconds(1000);
// Inserting a packet. Still no valid estimate. We need to wait 1 second. // Inserting a packet. Still no valid estimate. We need to wait 1 second.
IncomingPacket(kDefaultSsrc, kMtu, clock_.TimeInMilliseconds(), timestamp, IncomingPacket(kDefaultSsrc, kMtu, clock_.TimeInMilliseconds(), timestamp,
absolute_send_time); absolute_send_time, true);
bitrate_estimator_->Process(); bitrate_estimator_->Process();
EXPECT_FALSE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps)); EXPECT_FALSE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps));
EXPECT_EQ(0u, ssrcs.size()); EXPECT_EQ(0u, ssrcs.size());
@ -332,7 +331,7 @@ void RemoteBitrateEstimatorTest::InitialBehaviorTestHelper(
// Inserting packets for one second to get a valid estimate. // Inserting packets for one second to get a valid estimate.
for (int i = 0; i < kFramerate; ++i) { for (int i = 0; i < kFramerate; ++i) {
IncomingPacket(kDefaultSsrc, kMtu, clock_.TimeInMilliseconds(), timestamp, IncomingPacket(kDefaultSsrc, kMtu, clock_.TimeInMilliseconds(), timestamp,
absolute_send_time); absolute_send_time, true);
clock_.AdvanceTimeMilliseconds(1000 / kFramerate); clock_.AdvanceTimeMilliseconds(1000 / kFramerate);
timestamp += 90 * kFrameIntervalMs; timestamp += 90 * kFrameIntervalMs;
absolute_send_time = AddAbsSendTime(absolute_send_time, absolute_send_time = AddAbsSendTime(absolute_send_time,
@ -360,13 +359,13 @@ void RemoteBitrateEstimatorTest::RateIncreaseReorderingTestHelper(
uint32_t timestamp = 0; uint32_t timestamp = 0;
uint32_t absolute_send_time = 0; uint32_t absolute_send_time = 0;
IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp, IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
absolute_send_time); absolute_send_time, true);
bitrate_estimator_->Process(); bitrate_estimator_->Process();
EXPECT_FALSE(bitrate_observer_->updated()); // No valid estimate. EXPECT_FALSE(bitrate_observer_->updated()); // No valid estimate.
// Inserting packets for one second to get a valid estimate. // Inserting packets for one second to get a valid estimate.
for (int i = 0; i < kFramerate; ++i) { for (int i = 0; i < kFramerate; ++i) {
IncomingPacket(kDefaultSsrc, kMtu, clock_.TimeInMilliseconds(), timestamp, IncomingPacket(kDefaultSsrc, kMtu, clock_.TimeInMilliseconds(), timestamp,
absolute_send_time); absolute_send_time, true);
clock_.AdvanceTimeMilliseconds(kFrameIntervalMs); clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
timestamp += 90 * kFrameIntervalMs; timestamp += 90 * kFrameIntervalMs;
absolute_send_time = AddAbsSendTime(absolute_send_time, absolute_send_time = AddAbsSendTime(absolute_send_time,
@ -383,11 +382,12 @@ void RemoteBitrateEstimatorTest::RateIncreaseReorderingTestHelper(
absolute_send_time = AddAbsSendTime(absolute_send_time, absolute_send_time = AddAbsSendTime(absolute_send_time,
2 * kFrameIntervalAbsSendTime); 2 * kFrameIntervalAbsSendTime);
IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp, IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
absolute_send_time); absolute_send_time, true);
IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), IncomingPacket(
kDefaultSsrc, 1000, clock_.TimeInMilliseconds(),
timestamp - 90 * kFrameIntervalMs, timestamp - 90 * kFrameIntervalMs,
AddAbsSendTime(absolute_send_time, AddAbsSendTime(absolute_send_time, -int(kFrameIntervalAbsSendTime)),
-int(kFrameIntervalAbsSendTime))); true);
} }
bitrate_estimator_->Process(); bitrate_estimator_->Process();
EXPECT_TRUE(bitrate_observer_->updated()); EXPECT_TRUE(bitrate_observer_->updated());
@ -525,7 +525,7 @@ void RemoteBitrateEstimatorTest::TestTimestampGroupingTestHelper() {
// Initial set of frames to increase the bitrate. // Initial set of frames to increase the bitrate.
for (int i = 0; i <= 100; ++i) { for (int i = 0; i <= 100; ++i) {
IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp, IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
absolute_send_time); absolute_send_time, true);
bitrate_estimator_->Process(); bitrate_estimator_->Process();
clock_.AdvanceTimeMilliseconds(kFrameIntervalMs); clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
timestamp += 90 * kFrameIntervalMs; timestamp += 90 * kFrameIntervalMs;
@ -546,7 +546,7 @@ void RemoteBitrateEstimatorTest::TestTimestampGroupingTestHelper() {
// Insert |kTimestampGroupLength| frames with just 1 timestamp ticks in // Insert |kTimestampGroupLength| frames with just 1 timestamp ticks in
// between. Should be treated as part of the same group by the estimator. // between. Should be treated as part of the same group by the estimator.
IncomingPacket(kDefaultSsrc, 100, clock_.TimeInMilliseconds(), timestamp, IncomingPacket(kDefaultSsrc, 100, clock_.TimeInMilliseconds(), timestamp,
absolute_send_time); absolute_send_time, true);
clock_.AdvanceTimeMilliseconds(kFrameIntervalMs / kTimestampGroupLength); clock_.AdvanceTimeMilliseconds(kFrameIntervalMs / kTimestampGroupLength);
timestamp += 1; timestamp += 1;
absolute_send_time = AddAbsSendTime(absolute_send_time, absolute_send_time = AddAbsSendTime(absolute_send_time,
@ -579,7 +579,7 @@ void RemoteBitrateEstimatorTest::TestGetStatsHelper() {
// Inject propagation_time_delta of kFrameIntervalMs. // Inject propagation_time_delta of kFrameIntervalMs.
for (size_t i = 0; i < 3; ++i) { for (size_t i = 0; i < 3; ++i) {
IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp, IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
absolute_send_time); absolute_send_time, true);
timestamp += kFrameIntervalMs; timestamp += kFrameIntervalMs;
// Insert a kFrameIntervalMs propagation_time_delta. // Insert a kFrameIntervalMs propagation_time_delta.
clock_.AdvanceTimeMilliseconds(kFrameIntervalMs * 2); clock_.AdvanceTimeMilliseconds(kFrameIntervalMs * 2);
@ -597,7 +597,7 @@ void RemoteBitrateEstimatorTest::TestGetStatsHelper() {
// should be adjusted to 0. // should be adjusted to 0.
for (size_t i = 0; i < 3; ++i) { for (size_t i = 0; i < 3; ++i) {
IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp, IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
absolute_send_time); absolute_send_time, true);
timestamp += 10 * kFrameIntervalMs; timestamp += 10 * kFrameIntervalMs;
clock_.AdvanceTimeMilliseconds(kBurstThresholdMs + 1); clock_.AdvanceTimeMilliseconds(kBurstThresholdMs + 1);
absolute_send_time = AddAbsSendTime(absolute_send_time, absolute_send_time = AddAbsSendTime(absolute_send_time,
@ -610,7 +610,7 @@ void RemoteBitrateEstimatorTest::TestGetStatsHelper() {
// limits. // limits.
for (size_t i = 0; i < 1001; ++i) { for (size_t i = 0; i < 1001; ++i) {
IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp, IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
absolute_send_time); absolute_send_time, true);
timestamp += kFrameIntervalMs; timestamp += kFrameIntervalMs;
absolute_send_time = AddAbsSendTime(absolute_send_time, absolute_send_time = AddAbsSendTime(absolute_send_time,
kFrameIntervalAbsSendTime); kFrameIntervalAbsSendTime);
@ -635,7 +635,7 @@ void RemoteBitrateEstimatorTest::TestWrappingHelper(
for (size_t i = 0; i < 3000; ++i) { for (size_t i = 0; i < 3000; ++i) {
IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp, IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
absolute_send_time); absolute_send_time, true);
timestamp += kFrameIntervalMs; timestamp += kFrameIntervalMs;
clock_.AdvanceTimeMilliseconds(kFrameIntervalMs); clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
absolute_send_time = AddAbsSendTime(absolute_send_time, absolute_send_time = AddAbsSendTime(absolute_send_time,
@ -652,7 +652,7 @@ void RemoteBitrateEstimatorTest::TestWrappingHelper(
bitrate_estimator_->Process(); bitrate_estimator_->Process();
for (size_t i = 0; i < 100; ++i) { for (size_t i = 0; i < 100; ++i) {
IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp, IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
absolute_send_time); absolute_send_time, true);
timestamp += kFrameIntervalMs; timestamp += kFrameIntervalMs;
clock_.AdvanceTimeMilliseconds(2 * kFrameIntervalMs); clock_.AdvanceTimeMilliseconds(2 * kFrameIntervalMs);
absolute_send_time = AddAbsSendTime(absolute_send_time, absolute_send_time = AddAbsSendTime(absolute_send_time,

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

@ -168,7 +168,8 @@ class RemoteBitrateEstimatorTest : public ::testing::Test {
size_t payload_size, size_t payload_size,
int64_t arrival_time, int64_t arrival_time,
uint32_t rtp_timestamp, uint32_t rtp_timestamp,
uint32_t absolute_send_time); uint32_t absolute_send_time,
bool was_paced);
// Generates a frame of packets belonging to a stream at a given bitrate and // 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 // with a given ssrc. The stream is pushed through a very simple simulated

2
webrtc/modules/remote_bitrate_estimator/test/estimators/remb.cc
View File

@ -96,7 +96,7 @@ void RembReceiver::ReceivePacket(int64_t arrival_time_ms,
step_ms = std::max<int64_t>(estimator_->TimeUntilNextProcess(), 0); step_ms = std::max<int64_t>(estimator_->TimeUntilNextProcess(), 0);
} }
estimator_->IncomingPacket(arrival_time_ms, media_packet.payload_size(), estimator_->IncomingPacket(arrival_time_ms, media_packet.payload_size(),
media_packet.header()); media_packet.header(), true);
clock_.AdvanceTimeMilliseconds(arrival_time_ms - clock_.TimeInMilliseconds()); clock_.AdvanceTimeMilliseconds(arrival_time_ms - clock_.TimeInMilliseconds());
ASSERT_TRUE(arrival_time_ms == clock_.TimeInMilliseconds()); ASSERT_TRUE(arrival_time_ms == clock_.TimeInMilliseconds());

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

@ -126,7 +126,7 @@ void SendSideBweReceiver::ReceivePacket(int64_t arrival_time_ms,
const MediaPacket& media_packet) { const MediaPacket& media_packet) {
packet_feedback_vector_.push_back(PacketInfo( packet_feedback_vector_.push_back(PacketInfo(
arrival_time_ms, media_packet.sender_timestamp_us() / 1000, arrival_time_ms, media_packet.sender_timestamp_us() / 1000,
media_packet.header().sequenceNumber, media_packet.payload_size())); media_packet.header().sequenceNumber, media_packet.payload_size(), true));
received_packets_.Insert(media_packet.sequence_number(), received_packets_.Insert(media_packet.sequence_number(),
media_packet.send_time_ms(), arrival_time_ms, media_packet.send_time_ms(), arrival_time_ms,

3
webrtc/modules/remote_bitrate_estimator/tools/bwe_rtp_play.cc
View File

@ -90,8 +90,7 @@ int main(int argc, char** argv) {
packet_length = packet.original_length; packet_length = packet.original_length;
} }
rbe->IncomingPacket(clock.TimeInMilliseconds(), rbe->IncomingPacket(clock.TimeInMilliseconds(),
packet_length - header.headerLength, packet_length - header.headerLength, header, true);
header);
++packet_counter; ++packet_counter;
if (!rtp_reader->NextPacket(&packet)) { if (!rtp_reader->NextPacket(&packet)) {
break; break;

2
webrtc/video/audio_receive_stream.cc
View File

@ -83,7 +83,7 @@ bool AudioReceiveStream::DeliverRtp(const uint8_t* packet, size_t length) {
int64_t arrival_time_ms = TickTime::MillisecondTimestamp(); int64_t arrival_time_ms = TickTime::MillisecondTimestamp();
size_t payload_size = length - header.headerLength; size_t payload_size = length - header.headerLength;
remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, payload_size, remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, payload_size,
header); header, false);
} }
return true; return true;
} }

8
webrtc/video/rampup_tests.cc
View File

@ -121,8 +121,8 @@ bool StreamObserver::SendRtp(const uint8_t* packet, size_t length) {
EXPECT_TRUE(rtp_parser_->Parse(packet, length, &header)); EXPECT_TRUE(rtp_parser_->Parse(packet, length, &header));
receive_stats_->IncomingPacket(header, length, false); receive_stats_->IncomingPacket(header, length, false);
payload_registry_->SetIncomingPayloadType(header); payload_registry_->SetIncomingPayloadType(header);
remote_bitrate_estimator_->IncomingPacket( remote_bitrate_estimator_->IncomingPacket(clock_->TimeInMilliseconds(),
clock_->TimeInMilliseconds(), length - 12, header); length - 12, header, true);
if (remote_bitrate_estimator_->TimeUntilNextProcess() <= 0) { if (remote_bitrate_estimator_->TimeUntilNextProcess() <= 0) {
remote_bitrate_estimator_->Process(); remote_bitrate_estimator_->Process();
} }
@ -267,8 +267,8 @@ PacketReceiver::DeliveryStatus LowRateStreamObserver::DeliverPacket(
RTPHeader header; RTPHeader header;
EXPECT_TRUE(rtp_parser_->Parse(packet, length, &header)); EXPECT_TRUE(rtp_parser_->Parse(packet, length, &header));
receive_stats_->IncomingPacket(header, length, false); receive_stats_->IncomingPacket(header, length, false);
remote_bitrate_estimator_->IncomingPacket( remote_bitrate_estimator_->IncomingPacket(clock_->TimeInMilliseconds(),
clock_->TimeInMilliseconds(), length - 12, header); length - 12, header, true);
if (remote_bitrate_estimator_->TimeUntilNextProcess() <= 0) { if (remote_bitrate_estimator_->TimeUntilNextProcess() <= 0) {
remote_bitrate_estimator_->Process(); remote_bitrate_estimator_->Process();
} }

5
webrtc/video_engine/vie_channel_group.cc
View File

@ -55,10 +55,11 @@ class WrappingBitrateEstimator : public RemoteBitrateEstimator {
void IncomingPacket(int64_t arrival_time_ms, void IncomingPacket(int64_t arrival_time_ms,
size_t payload_size, size_t payload_size,
const RTPHeader& header) override { const RTPHeader& header,
bool was_paced) override {
CriticalSectionScoped cs(crit_sect_.get()); CriticalSectionScoped cs(crit_sect_.get());
PickEstimatorFromHeader(header); PickEstimatorFromHeader(header);
rbe_->IncomingPacket(arrival_time_ms, payload_size, header); rbe_->IncomingPacket(arrival_time_ms, payload_size, header, was_paced);
} }
int32_t Process() override { int32_t Process() override {

4
webrtc/video_engine/vie_receiver.cc
View File

@ -280,8 +280,8 @@ int ViEReceiver::InsertRTPPacket(const uint8_t* rtp_packet,
} }
} }
remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, payload_length,
payload_length, header); header, true);
header.payload_type_frequency = kVideoPayloadTypeFrequency; header.payload_type_frequency = kVideoPayloadTypeFrequency;
bool in_order = IsPacketInOrder(header); bool in_order = IsPacketInOrder(header);