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

Reland of move audio/video distinction for probe packets. (patchset #1 id:1 of https://codereview.webrtc.org/2086633002/ )

Browse Source 
Reason for revert:
Fix already landed in google3, this revert actually breaks the import.

Original issue's description:
> Revert of Remove audio/video distinction for probe packets. (patchset #2 id:20001 of https://codereview.webrtc.org/2061193002/ )
>
> Reason for revert:
> Revert this because it broke the google3 import build.
> http://webrtc-buildbot-master.mtv.corp.google.com:21000/builders/WebRTC%20google3%20Importer%20%28Shem%20TOT%29/builds/67/steps/blaze_regular_tests/logs/stdio
>
> Original issue's description:
> > Remove audio/video distinction for probe packets.
> >
> > Allows detecting large-enough audio packets as part of a probe,
> > speculative fix for a rampup-time regression in M50. These packets are
> > accounted on the send side when probing.
> >
> > BUG=webrtc:5985
> > R=mflodman@webrtc.org, philipel@webrtc.org
> >
> > Committed: https://crrev.com/a7d88d38448f6a5677a017562765ab505b89d468
> > Cr-Commit-Position: refs/heads/master@{#13210}
>
> TBR=mflodman@webrtc.org,philipel@webrtc.org,pbos@webrtc.org
> # Skipping CQ checks because original CL landed less than 1 days ago.
> NOPRESUBMIT=true
> NOTREECHECKS=true
> NOTRY=true
> BUG=webrtc:5985
>
> Committed: https://crrev.com/17bde8c96ee8b5a7e496a7dc98828b84f9756925
> Cr-Commit-Position: refs/heads/master@{#13221}

TBR=mflodman@webrtc.org,philipel@webrtc.org,honghaiz@webrtc.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=webrtc:5985

Review-Url: https://codereview.webrtc.org/2085653002
Cr-Commit-Position: refs/heads/master@{#13223}
This commit is contained in:
pbos 2016-06-20 11:53:02 -07:00 committed by Commit bot
parent 6d3e0c22c3
commit 2169d8bc68
34 changed files with 139 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
webrtc/audio/audio_receive_stream.cc
View File

@ -254,7 +254,7 @@ bool AudioReceiveStream::DeliverRtp(const uint8_t* packet,
arrival_time_ms = (packet_time.timestamp + 500) / 1000;
size_t payload_size = length - header.headerLength;
remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, payload_size,
header, false);
header);
}
return channel_proxy_->ReceivedRTPPacket(packet, length, packet_time);

2
webrtc/audio/audio_receive_stream_unittest.cc
View File

@ -279,7 +279,7 @@ TEST(AudioReceiveStreamTest, ReceiveRtpPacket) {
EXPECT_CALL(*helper.remote_bitrate_estimator(),
IncomingPacket(packet_time.timestamp / 1000,
rtp_packet.size() - kExpectedHeaderLength,
VerifyHeaderExtension(expected_extension), false))
VerifyHeaderExtension(expected_extension)))
.Times(1);
EXPECT_CALL(*helper.channel_proxy(),
ReceivedRTPPacket(&rtp_packet[0],

5
webrtc/modules/congestion_controller/congestion_controller.cc
View File

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

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

@ -198,15 +198,14 @@ void DelayBasedBwe::IncomingPacketFeedbackVector(
for (const auto& packet_info : packet_feedback_vector) {
IncomingPacketInfo(packet_info.arrival_time_ms,
ConvertMsTo24Bits(packet_info.send_time_ms),
packet_info.payload_size, 0, packet_info.was_paced,
packet_info.payload_size, 0,
packet_info.probe_cluster_id);
}
}
void DelayBasedBwe::IncomingPacket(int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header,
bool was_paced) {
const RTPHeader& header) {
RTC_DCHECK(network_thread_.CalledOnValidThread());
if (!header.extension.hasAbsoluteSendTime) {
// NOTE! The BitrateEstimatorTest relies on this EXACT log line.
@ -215,14 +214,12 @@ void DelayBasedBwe::IncomingPacket(int64_t arrival_time_ms,
return;
}
IncomingPacketInfo(arrival_time_ms, header.extension.absoluteSendTime,
payload_size, header.ssrc, was_paced,
PacketInfo::kNotAProbe);
payload_size, header.ssrc, PacketInfo::kNotAProbe);
}
void DelayBasedBwe::IncomingPacket(int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header,
bool was_paced,
int probe_cluster_id) {
RTC_DCHECK(network_thread_.CalledOnValidThread());
if (!header.extension.hasAbsoluteSendTime) {
@ -232,14 +229,13 @@ void DelayBasedBwe::IncomingPacket(int64_t arrival_time_ms,
return;
}
IncomingPacketInfo(arrival_time_ms, header.extension.absoluteSendTime,
payload_size, header.ssrc, was_paced, probe_cluster_id);
payload_size, header.ssrc, probe_cluster_id);
}
void DelayBasedBwe::IncomingPacketInfo(int64_t arrival_time_ms,
uint32_t send_time_24bits,
size_t payload_size,
uint32_t ssrc,
bool was_paced,
int probe_cluster_id) {
assert(send_time_24bits < (1ul << 24));
// Shift up send time to use the full 32 bits that inter_arrival works with,

5
webrtc/modules/congestion_controller/delay_based_bwe.h
View File

@ -40,13 +40,11 @@ class DelayBasedBwe : public RemoteBitrateEstimator {
void IncomingPacket(int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header,
bool was_paced) override;
const RTPHeader& header) override;
void IncomingPacket(int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header,
bool was_paced,
int probe_cluster_id);
// This class relies on Process() being called periodically (at least once
@ -112,7 +110,6 @@ class DelayBasedBwe : public RemoteBitrateEstimator {
uint32_t send_time_24bits,
size_t payload_size,
uint32_t ssrc,
bool was_paced,
int probe_cluster_id);
void ComputeClusters(std::list<Cluster>* clusters) const;

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

@ -33,7 +33,6 @@ class TestDelayBasedBwe : public ::testing::Test, public RemoteBitrateObserver {
int64_t arrival_time,
uint32_t rtp_timestamp,
uint32_t absolute_send_time,
bool was_paced,
int probe_cluster_id) {
RTPHeader header;
memset(&header, 0, sizeof(header));
@ -42,7 +41,7 @@ class TestDelayBasedBwe : public ::testing::Test, public RemoteBitrateObserver {
header.extension.hasAbsoluteSendTime = true;
header.extension.absoluteSendTime = absolute_send_time;
bwe_.IncomingPacket(arrival_time + kArrivalTimeClockOffsetMs, payload_size,
header, was_paced, probe_cluster_id);
header, probe_cluster_id);
}
void OnReceiveBitrateChanged(const std::vector<uint32_t>& ssrcs,
@ -74,8 +73,7 @@ TEST_F(TestDelayBasedBwe, ProbeDetection) {
for (int i = 0; i < kNumProbes; ++i) {
clock_.AdvanceTimeMilliseconds(10);
now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000),
true, 0);
IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000), 0);
}
EXPECT_TRUE(bitrate_updated());
@ -83,8 +81,7 @@ TEST_F(TestDelayBasedBwe, ProbeDetection) {
for (int i = 0; i < kNumProbes; ++i) {
clock_.AdvanceTimeMilliseconds(5);
now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000),
true, 1);
IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000), 1);
}
EXPECT_TRUE(bitrate_updated());
@ -98,12 +95,11 @@ TEST_F(TestDelayBasedBwe, ProbeDetectionNonPacedPackets) {
for (int i = 0; i < kNumProbes; ++i) {
clock_.AdvanceTimeMilliseconds(5);
now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000),
true, 0);
IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000), 0);
// Non-paced packet, arriving 5 ms after.
clock_.AdvanceTimeMilliseconds(5);
IncomingPacket(0, PacedSender::kMinProbePacketSize + 1, now_ms, 90 * now_ms,
AbsSendTime(now_ms, 1000), false, PacketInfo::kNotAProbe);
AbsSendTime(now_ms, 1000), PacketInfo::kNotAProbe);
}
EXPECT_TRUE(bitrate_updated());
@ -121,7 +117,7 @@ TEST_F(TestDelayBasedBwe, ProbeDetectionTooHighBitrate) {
now_ms = clock_.TimeInMilliseconds();
send_time_ms += 10;
IncomingPacket(0, 1000, now_ms, 90 * send_time_ms,
AbsSendTime(send_time_ms, 1000), true, 0);
AbsSendTime(send_time_ms, 1000), 0);
}
// Second burst sent at 8 * 1000 / 5 = 1600 kbps, arriving at 8 * 1000 / 8 =
@ -131,7 +127,7 @@ TEST_F(TestDelayBasedBwe, ProbeDetectionTooHighBitrate) {
now_ms = clock_.TimeInMilliseconds();
send_time_ms += 5;
IncomingPacket(0, 1000, now_ms, send_time_ms,
AbsSendTime(send_time_ms, 1000), true, 1);
AbsSendTime(send_time_ms, 1000), 1);
}
EXPECT_TRUE(bitrate_updated());
@ -148,7 +144,7 @@ TEST_F(TestDelayBasedBwe, ProbeDetectionSlightlyFasterArrival) {
send_time_ms += 10;
now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * send_time_ms,
AbsSendTime(send_time_ms, 1000), true, 23);
AbsSendTime(send_time_ms, 1000), 23);
}
EXPECT_TRUE(bitrate_updated());
@ -165,7 +161,7 @@ TEST_F(TestDelayBasedBwe, ProbeDetectionFasterArrival) {
send_time_ms += 10;
now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * send_time_ms,
AbsSendTime(send_time_ms, 1000), true, 0);
AbsSendTime(send_time_ms, 1000), 0);
}
EXPECT_FALSE(bitrate_updated());
@ -181,7 +177,7 @@ TEST_F(TestDelayBasedBwe, ProbeDetectionSlowerArrival) {
send_time_ms += 5;
now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * send_time_ms,
AbsSendTime(send_time_ms, 1000), true, 1);
AbsSendTime(send_time_ms, 1000), 1);
}
EXPECT_TRUE(bitrate_updated());
@ -198,7 +194,7 @@ TEST_F(TestDelayBasedBwe, ProbeDetectionSlowerArrivalHighBitrate) {
send_time_ms += 1;
now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * send_time_ms,
AbsSendTime(send_time_ms, 1000), true, 1);
AbsSendTime(send_time_ms, 1000), 1);
}
EXPECT_TRUE(bitrate_updated());
@ -213,7 +209,7 @@ TEST_F(TestDelayBasedBwe, ProbingIgnoresSmallPackets) {
clock_.AdvanceTimeMilliseconds(10);
now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, PacedSender::kMinProbePacketSize, now_ms, 90 * now_ms,
AbsSendTime(now_ms, 1000), true, 1);
AbsSendTime(now_ms, 1000), 1);
}
EXPECT_FALSE(bitrate_updated());
@ -223,8 +219,7 @@ TEST_F(TestDelayBasedBwe, ProbingIgnoresSmallPackets) {
for (int i = 0; i < kNumProbes; ++i) {
clock_.AdvanceTimeMilliseconds(10);
now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000),
true, 1);
IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000), 1);
}
// Wait long enough so that we can call Process again.

2
webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitrate_estimator.h
View File

@ -28,7 +28,7 @@ class MockRemoteBitrateEstimator : public RemoteBitrateEstimator {
public:
MOCK_METHOD1(IncomingPacketFeedbackVector,
void(const std::vector<PacketInfo>&));
MOCK_METHOD4(IncomingPacket, void(int64_t, size_t, const RTPHeader&, bool));
MOCK_METHOD3(IncomingPacket, void(int64_t, size_t, const RTPHeader&));
MOCK_METHOD1(RemoveStream, void(uint32_t));
MOCK_CONST_METHOD2(LatestEstimate, bool(std::vector<uint32_t>*, uint32_t*));

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

@ -58,8 +58,7 @@ class RemoteBitrateEstimator : public CallStatsObserver, public Module {
// Note that |arrival_time_ms| can be of an arbitrary time base.
virtual void IncomingPacket(int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header,
bool was_paced) = 0;
const RTPHeader& header) = 0;
// Removes all data for |ssrc|.
virtual void RemoveStream(uint32_t ssrc) = 0;

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

@ -26,7 +26,6 @@ class SendTimeHistory {
void AddAndRemoveOld(uint16_t sequence_number,
size_t length,
bool was_paced,
int probe_cluster_id);
bool OnSentPacket(uint16_t sequence_number, int64_t timestamp);
// Look up PacketInfo for a sent packet, based on the sequence number, and

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

@ -211,14 +211,14 @@ void RemoteBitrateEstimatorAbsSendTime::IncomingPacketFeedbackVector(
for (const auto& packet_info : packet_feedback_vector) {
IncomingPacketInfo(packet_info.arrival_time_ms,
ConvertMsTo24Bits(packet_info.send_time_ms),
packet_info.payload_size, 0, packet_info.was_paced);
packet_info.payload_size, 0);
}
}
void RemoteBitrateEstimatorAbsSendTime::IncomingPacket(int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header,
bool was_paced) {
void RemoteBitrateEstimatorAbsSendTime::IncomingPacket(
int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header) {
RTC_DCHECK(network_thread_.CalledOnValidThread());
if (!header.extension.hasAbsoluteSendTime) {
LOG(LS_WARNING) << "RemoteBitrateEstimatorAbsSendTimeImpl: Incoming packet "
@ -226,15 +226,14 @@ void RemoteBitrateEstimatorAbsSendTime::IncomingPacket(int64_t arrival_time_ms,
return;
}
IncomingPacketInfo(arrival_time_ms, header.extension.absoluteSendTime,
payload_size, header.ssrc, was_paced);
payload_size, header.ssrc);
}
void RemoteBitrateEstimatorAbsSendTime::IncomingPacketInfo(
int64_t arrival_time_ms,
uint32_t send_time_24bits,
size_t payload_size,
uint32_t ssrc,
bool was_paced) {
uint32_t ssrc) {
assert(send_time_24bits < (1ul << 24));
// Shift up send time to use the full 32 bits that inter_arrival works with,
// so wrapping works properly.
@ -264,10 +263,6 @@ void RemoteBitrateEstimatorAbsSendTime::IncomingPacketInfo(
uint32_t ts_delta = 0;
int64_t t_delta = 0;
int size_delta = 0;
// For now only try to detect probes while we don't have a valid estimate, and
// make sure the packet was paced. We currently assume that only packets
// larger than 200 bytes are paced by the sender.
was_paced = was_paced && payload_size > PacedSender::kMinProbePacketSize;
bool update_estimate = false;
uint32_t target_bitrate_bps = 0;
std::vector<uint32_t> ssrcs;
@ -279,7 +274,10 @@ void RemoteBitrateEstimatorAbsSendTime::IncomingPacketInfo(
RTC_DCHECK(estimator_.get());
ssrcs_[ssrc] = now_ms;
if (was_paced &&
// For now only try to detect probes while we don't have a valid estimate.
// We currently assume that only packets larger than 200 bytes are paced by
// the sender.
if (payload_size > PacedSender::kMinProbePacketSize &&
(!remote_rate_.ValidEstimate() ||
now_ms - first_packet_time_ms_ < kInitialProbingIntervalMs)) {
// TODO(holmer): Use a map instead to get correct order?

6
webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.h
View File

@ -76,8 +76,7 @@ class RemoteBitrateEstimatorAbsSendTime : public RemoteBitrateEstimator {
void IncomingPacket(int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header,
bool was_paced) override;
const RTPHeader& header) override;
// This class relies on Process() being called periodically (at least once
// 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
@ -102,8 +101,7 @@ class RemoteBitrateEstimatorAbsSendTime : public RemoteBitrateEstimator {
void IncomingPacketInfo(int64_t arrival_time_ms,
uint32_t send_time_24bits,
size_t payload_size,
uint32_t ssrc,
bool was_paced);
uint32_t ssrc);
void ComputeClusters(std::list<Cluster>* clusters) const;

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

@ -90,7 +90,7 @@ TEST_F(RemoteBitrateEstimatorAbsSendTimeTest, TestProcessAfterTimeout) {
// RemoteBitrateEstimator.
const int64_t kStreamTimeOutMs = 2000;
const int64_t kProcessIntervalMs = 1000;
IncomingPacket(0, 1000, clock_.TimeInMilliseconds(), 0, 0, true);
IncomingPacket(0, 1000, clock_.TimeInMilliseconds(), 0, 0);
clock_.AdvanceTimeMilliseconds(kStreamTimeOutMs + 1);
// Trigger timeout.
bitrate_estimator_->Process();
@ -106,16 +106,14 @@ TEST_F(RemoteBitrateEstimatorAbsSendTimeTest, TestProbeDetection) {
for (int i = 0; i < kProbeLength; ++i) {
clock_.AdvanceTimeMilliseconds(10);
now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000),
true);
IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000));
}
// Second burst sent at 8 * 1000 / 5 = 1600 kbps.
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);
IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000));
}
bitrate_estimator_->Process();
@ -132,12 +130,10 @@ TEST_F(RemoteBitrateEstimatorAbsSendTimeTest,
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);
IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000));
// Non-paced packet, arriving 5 ms after.
clock_.AdvanceTimeMilliseconds(5);
IncomingPacket(0, 100, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000),
false);
IncomingPacket(0, 100, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000));
}
bitrate_estimator_->Process();
@ -158,7 +154,7 @@ TEST_F(RemoteBitrateEstimatorAbsSendTimeTest,
now_ms = clock_.TimeInMilliseconds();
send_time_ms += 10;
IncomingPacket(0, 1000, now_ms, 90 * send_time_ms,
AbsSendTime(send_time_ms, 1000), true);
AbsSendTime(send_time_ms, 1000));
}
// Second burst sent at 8 * 1000 / 5 = 1600 kbps, arriving at 8 * 1000 / 8 =
@ -168,7 +164,7 @@ TEST_F(RemoteBitrateEstimatorAbsSendTimeTest,
now_ms = clock_.TimeInMilliseconds();
send_time_ms += 5;
IncomingPacket(0, 1000, now_ms, send_time_ms,
AbsSendTime(send_time_ms, 1000), true);
AbsSendTime(send_time_ms, 1000));
}
bitrate_estimator_->Process();
@ -188,7 +184,7 @@ TEST_F(RemoteBitrateEstimatorAbsSendTimeTest,
send_time_ms += 10;
now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * send_time_ms,
AbsSendTime(send_time_ms, 1000), true);
AbsSendTime(send_time_ms, 1000));
}
bitrate_estimator_->Process();
@ -207,7 +203,7 @@ TEST_F(RemoteBitrateEstimatorAbsSendTimeTest, TestProbeDetectionFasterArrival) {
send_time_ms += 10;
now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * send_time_ms,
AbsSendTime(send_time_ms, 1000), true);
AbsSendTime(send_time_ms, 1000));
}
bitrate_estimator_->Process();
@ -225,7 +221,7 @@ TEST_F(RemoteBitrateEstimatorAbsSendTimeTest, TestProbeDetectionSlowerArrival) {
send_time_ms += 5;
now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * send_time_ms,
AbsSendTime(send_time_ms, 1000), true);
AbsSendTime(send_time_ms, 1000));
}
bitrate_estimator_->Process();
@ -245,7 +241,7 @@ TEST_F(RemoteBitrateEstimatorAbsSendTimeTest,
send_time_ms += 1;
now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * send_time_ms,
AbsSendTime(send_time_ms, 1000), true);
AbsSendTime(send_time_ms, 1000));
}
bitrate_estimator_->Process();
@ -261,8 +257,7 @@ TEST_F(RemoteBitrateEstimatorAbsSendTimeTest, ProbingIgnoresSmallPackets) {
for (int i = 0; i < kProbeLength; ++i) {
clock_.AdvanceTimeMilliseconds(10);
now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 200, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000),
true);
IncomingPacket(0, 200, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000));
}
bitrate_estimator_->Process();
@ -273,8 +268,7 @@ TEST_F(RemoteBitrateEstimatorAbsSendTimeTest, ProbingIgnoresSmallPackets) {
for (int i = 0; i < kProbeLength; ++i) {
clock_.AdvanceTimeMilliseconds(10);
now_ms = clock_.TimeInMilliseconds();
IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000),
true);
IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000));
}
// Wait long enough so that we can call Process again.

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

@ -67,10 +67,10 @@ RemoteBitrateEstimatorSingleStream::~RemoteBitrateEstimatorSingleStream() {
}
}
void RemoteBitrateEstimatorSingleStream::IncomingPacket(int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header,
bool was_paced) {
void RemoteBitrateEstimatorSingleStream::IncomingPacket(
int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header) {
uint32_t ssrc = header.ssrc;
uint32_t rtp_timestamp = header.timestamp +
header.extension.transmissionTimeOffset;

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

@ -31,8 +31,7 @@ class RemoteBitrateEstimatorSingleStream : public RemoteBitrateEstimator {
void IncomingPacket(int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header,
bool was_paced) override;
const RTPHeader& header) override;
void Process() override;
int64_t TimeUntilNextProcess() override;
void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override;

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

@ -224,8 +224,7 @@ void RemoteBitrateEstimatorTest::IncomingPacket(uint32_t ssrc,
size_t payload_size,
int64_t arrival_time,
uint32_t rtp_timestamp,
uint32_t absolute_send_time,
bool was_paced) {
uint32_t absolute_send_time) {
RTPHeader header;
memset(&header, 0, sizeof(header));
header.ssrc = ssrc;
@ -233,7 +232,7 @@ void RemoteBitrateEstimatorTest::IncomingPacket(uint32_t ssrc,
header.extension.hasAbsoluteSendTime = true;
header.extension.absoluteSendTime = absolute_send_time;
bitrate_estimator_->IncomingPacket(arrival_time + kArrivalTimeClockOffsetMs,
payload_size, header, was_paced);
payload_size, header);
}
// Generates a frame of packets belonging to a stream at a given bitrate and
@ -258,7 +257,7 @@ bool RemoteBitrateEstimatorTest::GenerateAndProcessFrame(uint32_t ssrc,
clock_.TimeInMicroseconds());
IncomingPacket(packet->ssrc, packet->size,
(packet->arrival_time + 500) / 1000, packet->rtp_timestamp,
AbsSendTime(packet->send_time, 1000000), true);
AbsSendTime(packet->send_time, 1000000));
if (bitrate_observer_->updated()) {
if (bitrate_observer_->latest_bitrate() < bitrate_bps)
overuse = true;
@ -331,7 +330,7 @@ void RemoteBitrateEstimatorTest::InitialBehaviorTestHelper(
}
IncomingPacket(kDefaultSsrc, kMtu, clock_.TimeInMilliseconds(), timestamp,
absolute_send_time, true);
absolute_send_time);
clock_.AdvanceTimeMilliseconds(1000 / kFramerate);
timestamp += 90 * kFrameIntervalMs;
absolute_send_time = AddAbsSendTime(absolute_send_time,
@ -369,7 +368,7 @@ void RemoteBitrateEstimatorTest::RateIncreaseReorderingTestHelper(
}
IncomingPacket(kDefaultSsrc, kMtu, clock_.TimeInMilliseconds(), timestamp,
absolute_send_time, true);
absolute_send_time);
clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
timestamp += 90 * kFrameIntervalMs;
absolute_send_time = AddAbsSendTime(absolute_send_time,
@ -386,12 +385,12 @@ void RemoteBitrateEstimatorTest::RateIncreaseReorderingTestHelper(
absolute_send_time = AddAbsSendTime(absolute_send_time,
2 * kFrameIntervalAbsSendTime);
IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
absolute_send_time, true);
IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(),
timestamp - 90 * kFrameIntervalMs,
AddAbsSendTime(absolute_send_time,
-static_cast<int>(kFrameIntervalAbsSendTime)),
true);
absolute_send_time);
IncomingPacket(
kDefaultSsrc, 1000, clock_.TimeInMilliseconds(),
timestamp - 90 * kFrameIntervalMs,
AddAbsSendTime(absolute_send_time,
-static_cast<int>(kFrameIntervalAbsSendTime)));
}
bitrate_estimator_->Process();
EXPECT_TRUE(bitrate_observer_->updated());
@ -524,7 +523,7 @@ void RemoteBitrateEstimatorTest::TestTimestampGroupingTestHelper() {
// time for the first estimate to be generated and for Process() to be called.
for (int i = 0; i <= 6 * kFramerate; ++i) {
IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
absolute_send_time, true);
absolute_send_time);
bitrate_estimator_->Process();
clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
timestamp += 90 * kFrameIntervalMs;
@ -545,7 +544,7 @@ void RemoteBitrateEstimatorTest::TestTimestampGroupingTestHelper() {
// Insert |kTimestampGroupLength| frames with just 1 timestamp ticks in
// between. Should be treated as part of the same group by the estimator.
IncomingPacket(kDefaultSsrc, 100, clock_.TimeInMilliseconds(), timestamp,
absolute_send_time, true);
absolute_send_time);
clock_.AdvanceTimeMilliseconds(kFrameIntervalMs / kTimestampGroupLength);
timestamp += 1;
absolute_send_time = AddAbsSendTime(absolute_send_time,
@ -575,7 +574,7 @@ void RemoteBitrateEstimatorTest::TestWrappingHelper(
for (size_t i = 0; i < 3000; ++i) {
IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
absolute_send_time, true);
absolute_send_time);
timestamp += kFrameIntervalMs;
clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
absolute_send_time = AddAbsSendTime(absolute_send_time,
@ -592,7 +591,7 @@ void RemoteBitrateEstimatorTest::TestWrappingHelper(
bitrate_estimator_->Process();
for (size_t i = 0; i < 21; ++i) {
IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
absolute_send_time, true);
absolute_send_time);
timestamp += kFrameIntervalMs;
clock_.AdvanceTimeMilliseconds(2 * kFrameIntervalMs);
absolute_send_time = AddAbsSendTime(absolute_send_time,

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

@ -173,8 +173,7 @@ class RemoteBitrateEstimatorTest : public ::testing::Test {
size_t payload_size,
int64_t arrival_time,
uint32_t rtp_timestamp,
uint32_t absolute_send_time,
bool was_paced);
uint32_t absolute_send_time);
// 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

3
webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.cc
View File

@ -43,8 +43,7 @@ void RemoteEstimatorProxy::IncomingPacketFeedbackVector(
void RemoteEstimatorProxy::IncomingPacket(int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header,
bool was_paced) {
const RTPHeader& header) {
if (!header.extension.hasTransportSequenceNumber) {
LOG(LS_WARNING) << "RemoteEstimatorProxy: Incoming packet "
"is missing the transport sequence number extension!";

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

@ -39,8 +39,7 @@ class RemoteEstimatorProxy : public RemoteBitrateEstimator {
const std::vector<PacketInfo>& packet_feedback_vector) override;
void IncomingPacket(int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header,
bool was_paced) override;
const RTPHeader& header) override;
void RemoveStream(uint32_t ssrc) override {}
bool LatestEstimate(std::vector<unsigned int>* ssrcs,
unsigned int* bitrate_bps) const override;

2
webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy_unittest.cc
View File

@ -37,7 +37,7 @@ class RemoteEstimatorProxyTest : public ::testing::Test {
header.extension.hasTransportSequenceNumber = true;
header.extension.transportSequenceNumber = seq;
header.ssrc = kMediaSsrc;
proxy_.IncomingPacket(time_ms, kDefaultPacketSize, header, true);
proxy_.IncomingPacket(time_ms, kDefaultPacketSize, header);
}
void Process() {

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

@ -28,7 +28,6 @@ void SendTimeHistory::Clear() {
void SendTimeHistory::AddAndRemoveOld(uint16_t sequence_number,
size_t length,
bool was_paced,
int probe_cluster_id) {
EraseOld();
@ -36,9 +35,8 @@ void SendTimeHistory::AddAndRemoveOld(uint16_t sequence_number,
oldest_sequence_number_ = sequence_number;
history_.insert(std::pair<uint16_t, PacketInfo>(
sequence_number,
PacketInfo(clock_->TimeInMilliseconds(), 0, -1, sequence_number, length,
was_paced, probe_cluster_id)));
sequence_number, PacketInfo(clock_->TimeInMilliseconds(), 0, -1,
sequence_number, length, probe_cluster_id)));
}
bool SendTimeHistory::OnSentPacket(uint16_t sequence_number,

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

@ -33,11 +33,9 @@ class SendTimeHistoryTest : public ::testing::Test {
void AddPacketWithSendTime(uint16_t sequence_number,
size_t length,
bool was_paced,
int64_t send_time_ms,
int probe_cluster_id) {
history_.AddAndRemoveOld(sequence_number, length, was_paced,
probe_cluster_id);
history_.AddAndRemoveOld(sequence_number, length, probe_cluster_id);
history_.OnSentPacket(sequence_number, send_time_ms);
}
@ -48,39 +46,28 @@ class SendTimeHistoryTest : public ::testing::Test {
// Help class extended so we can do EXPECT_EQ and collections.
class PacketInfo : public webrtc::PacketInfo {
public:
PacketInfo()
: webrtc::PacketInfo(-1,
0,
0,
0,
0,
false,
webrtc::PacketInfo::kNotAProbe) {}
PacketInfo(int64_t arrival_time_ms, uint16_t sequence_number)
: PacketInfo(arrival_time_ms,
0,
sequence_number,
0,
false,
PacketInfo::kNotAProbe) {}
PacketInfo(int64_t arrival_time_ms,
int64_t send_time_ms,
uint16_t sequence_number,
size_t payload_size,
bool was_paced,
int probe_cluster_id)
: webrtc::PacketInfo(-1,
arrival_time_ms,
send_time_ms,
sequence_number,
payload_size,
was_paced,
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 && was_paced == other.was_paced &&
payload_size == other.payload_size &&
probe_cluster_id == other.probe_cluster_id;
}
};
@ -88,18 +75,18 @@ class PacketInfo : public webrtc::PacketInfo {
TEST_F(SendTimeHistoryTest, AddRemoveOne) {
const uint16_t kSeqNo = 10;
const int kProbeClusterId = 0;
const PacketInfo kSentPacket(0, 1, kSeqNo, 1, true, kProbeClusterId);
AddPacketWithSendTime(kSeqNo, 1, true, 1, kProbeClusterId);
const PacketInfo kSentPacket(0, 1, kSeqNo, 1, kProbeClusterId);
AddPacketWithSendTime(kSeqNo, 1, 1, kProbeClusterId);
PacketInfo received_packet(0, 0, kSeqNo, 0, false, kProbeClusterId);
PacketInfo received_packet(0, 0, kSeqNo, 0, kProbeClusterId);
EXPECT_TRUE(history_.GetInfo(&received_packet, false));
EXPECT_EQ(kSentPacket, received_packet);
PacketInfo received_packet2(0, 0, kSeqNo, 0, false, kProbeClusterId);
PacketInfo received_packet2(0, 0, kSeqNo, 0, kProbeClusterId);
EXPECT_TRUE(history_.GetInfo(&received_packet2, true));
EXPECT_EQ(kSentPacket, received_packet2);
PacketInfo received_packet3(0, 0, kSeqNo, 0, false, kProbeClusterId);
PacketInfo received_packet3(0, 0, kSeqNo, 0, kProbeClusterId);
EXPECT_FALSE(history_.GetInfo(&received_packet3, true));
}
@ -108,9 +95,8 @@ TEST_F(SendTimeHistoryTest, PopulatesExpectedFields) {
const int64_t kSendTime = 1000;
const int64_t kReceiveTime = 2000;
const size_t kPayloadSize = 42;
const bool kPaced = true;
AddPacketWithSendTime(kSeqNo, kPayloadSize, kPaced, kSendTime,
AddPacketWithSendTime(kSeqNo, kPayloadSize, kSendTime,
PacketInfo::kNotAProbe);
PacketInfo info(kReceiveTime, kSeqNo);
@ -119,7 +105,6 @@ 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(kPaced, info.was_paced);
}
TEST_F(SendTimeHistoryTest, AddThenRemoveOutOfOrder) {
@ -128,20 +113,19 @@ TEST_F(SendTimeHistoryTest, AddThenRemoveOutOfOrder) {
const size_t num_items = 100;
const size_t kPacketSize = 400;
const size_t kTransmissionTime = 1234;
const bool kPaced = true;
const int kProbeClusterId = 1;
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,
kPaced, kProbeClusterId));
kProbeClusterId));
received_packets.push_back(PacketInfo(
static_cast<int64_t>(i) + kTransmissionTime, 0,
static_cast<uint16_t>(i), kPacketSize, false, PacketInfo::kNotAProbe));
static_cast<uint16_t>(i), kPacketSize, PacketInfo::kNotAProbe));
}
for (size_t i = 0; i < num_items; ++i) {
history_.AddAndRemoveOld(
sent_packets[i].sequence_number, sent_packets[i].payload_size,
sent_packets[i].was_paced, sent_packets[i].probe_cluster_id);
history_.AddAndRemoveOld(sent_packets[i].sequence_number,
sent_packets[i].payload_size,
sent_packets[i].probe_cluster_id);
}
for (size_t i = 0; i < num_items; ++i)
history_.OnSentPacket(sent_packets[i].sequence_number,
@ -163,21 +147,19 @@ TEST_F(SendTimeHistoryTest, HistorySize) {
const int kItems = kDefaultHistoryLengthMs / 100;
for (int i = 0; i < kItems; ++i) {
clock_.AdvanceTimeMilliseconds(100);
AddPacketWithSendTime(i, 0, false, i * 100, PacketInfo::kNotAProbe);
AddPacketWithSendTime(i, 0, i * 100, PacketInfo::kNotAProbe);
}
for (int i = 0; i < kItems; ++i) {
PacketInfo info(0, 0, static_cast<uint16_t>(i), 0, false,
PacketInfo::kNotAProbe);
PacketInfo info(0, 0, static_cast<uint16_t>(i), 0, PacketInfo::kNotAProbe);
EXPECT_TRUE(history_.GetInfo(&info, false));
EXPECT_EQ(i * 100, info.send_time_ms);
}
clock_.AdvanceTimeMilliseconds(101);
AddPacketWithSendTime(kItems, 0, false, kItems * 101, PacketInfo::kNotAProbe);
PacketInfo info(0, 0, 0, 0, false, PacketInfo::kNotAProbe);
AddPacketWithSendTime(kItems, 0, kItems * 101, PacketInfo::kNotAProbe);
PacketInfo info(0, 0, 0, 0, PacketInfo::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, false,
PacketInfo::kNotAProbe);
PacketInfo info2(0, 0, static_cast<uint16_t>(i), 0, PacketInfo::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);
@ -186,17 +168,16 @@ TEST_F(SendTimeHistoryTest, HistorySize) {
TEST_F(SendTimeHistoryTest, HistorySizeWithWraparound) {
const uint16_t kMaxSeqNo = std::numeric_limits<uint16_t>::max();
AddPacketWithSendTime(kMaxSeqNo - 2, 0, false, 0, PacketInfo::kNotAProbe);
AddPacketWithSendTime(kMaxSeqNo - 2, 0, 0, PacketInfo::kNotAProbe);
clock_.AdvanceTimeMilliseconds(100);
AddPacketWithSendTime(kMaxSeqNo - 1, 1, false, 100, PacketInfo::kNotAProbe);
AddPacketWithSendTime(kMaxSeqNo - 1, 1, 100, PacketInfo::kNotAProbe);
clock_.AdvanceTimeMilliseconds(100);
AddPacketWithSendTime(kMaxSeqNo, 0, false, 200, PacketInfo::kNotAProbe);
AddPacketWithSendTime(kMaxSeqNo, 0, 200, PacketInfo::kNotAProbe);
clock_.AdvanceTimeMilliseconds(kDefaultHistoryLengthMs - 200 + 1);
AddPacketWithSendTime(0, 0, false, kDefaultHistoryLengthMs,
PacketInfo::kNotAProbe);
AddPacketWithSendTime(0, 0, kDefaultHistoryLengthMs, PacketInfo::kNotAProbe);
PacketInfo info(0, static_cast<uint16_t>(kMaxSeqNo - 2));
EXPECT_FALSE(history_.GetInfo(&info, false));
@ -212,7 +193,7 @@ TEST_F(SendTimeHistoryTest, HistorySizeWithWraparound) {
EXPECT_TRUE(history_.GetInfo(&info5, true));
clock_.AdvanceTimeMilliseconds(100);
AddPacketWithSendTime(1, 0, false, 1100, PacketInfo::kNotAProbe);
AddPacketWithSendTime(1, 0, 1100, PacketInfo::kNotAProbe);
PacketInfo info6(0, static_cast<uint16_t>(kMaxSeqNo - 2));
EXPECT_FALSE(history_.GetInfo(&info6, false));
@ -229,26 +210,26 @@ 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, false, 0},
{0, kTimestamp + 1, kSeqNo + 1, 0, false, 1},
{0, kTimestamp + 2, kSeqNo + 2, 0, false, 2}};
PacketInfo packets[3] = {{0, kTimestamp, kSeqNo, 0, 0},
{0, kTimestamp + 1, kSeqNo + 1, 0, 1},
{0, kTimestamp + 2, kSeqNo + 2, 0, 2}};
AddPacketWithSendTime(packets[0].sequence_number, packets[0].payload_size,
packets[0].was_paced, packets[0].send_time_ms, 0);
packets[0].send_time_ms, 0);
AddPacketWithSendTime(packets[1].sequence_number, packets[1].payload_size,
packets[1].was_paced, packets[1].send_time_ms, 1);
PacketInfo info(0, 0, packets[0].sequence_number, 0, false, 0);
packets[1].send_time_ms, 1);
PacketInfo info(0, 0, packets[0].sequence_number, 0, 0);
EXPECT_TRUE(history_.GetInfo(&info, true));
EXPECT_EQ(packets[0], info);
AddPacketWithSendTime(packets[2].sequence_number, packets[2].payload_size,
packets[2].was_paced, packets[2].send_time_ms, 2);
packets[2].send_time_ms, 2);
PacketInfo info2(0, 0, packets[1].sequence_number, 0, false, 1);
PacketInfo info2(0, 0, packets[1].sequence_number, 0, 1);
EXPECT_TRUE(history_.GetInfo(&info2, true));
EXPECT_EQ(packets[1], info2);
PacketInfo info3(0, 0, packets[2].sequence_number, 0, false, 2);
PacketInfo info3(0, 0, packets[2].sequence_number, 0, 2);
EXPECT_TRUE(history_.GetInfo(&info3, true));
EXPECT_EQ(packets[2], info3);
}

8
webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework.cc
View File

@ -99,18 +99,14 @@ Packet::Packet()
creation_time_us_(-1),
send_time_us_(-1),
sender_timestamp_us_(-1),
payload_size_(0),
paced_(false) {
}
payload_size_(0) {}
Packet::Packet(int flow_id, int64_t send_time_us, size_t payload_size)
: flow_id_(flow_id),
creation_time_us_(send_time_us),
send_time_us_(send_time_us),
sender_timestamp_us_(send_time_us),
payload_size_(payload_size),
paced_(false) {
}
payload_size_(payload_size) {}
Packet::~Packet() {
}

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

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

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

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

3
webrtc/modules/remote_bitrate_estimator/test/packet.h
View File

@ -42,8 +42,6 @@ class Packet {
virtual void set_sender_timestamp_us(int64_t sender_timestamp_us) {
sender_timestamp_us_ = sender_timestamp_us;
}
virtual void set_paced(bool paced) { paced_ = paced; }
virtual bool paced() const { return paced_; }
virtual int64_t creation_time_ms() const {
return (creation_time_us_ + 500) / 1000;
}
@ -58,7 +56,6 @@ class Packet {
int64_t send_time_us_; // Time the packet left last processor touching it.
int64_t sender_timestamp_us_; // Time the packet left the Sender.
size_t payload_size_; // Size of the (non-existent, simulated) payload.
bool paced_; // True if sent through paced sender.
};
class MediaPacket : public Packet {

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

@ -267,8 +267,6 @@ void PacedVideoSender::QueuePackets(Packets* batch,
}
Packets to_transfer;
to_transfer.splice(to_transfer.begin(), queue_, queue_.begin(), it);
for (Packet* packet : to_transfer)
packet->set_paced(true);
bwe_->OnPacketsSent(to_transfer);
batch->merge(to_transfer, DereferencingComparator<Packet>);
}

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

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

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

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

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

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

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

@ -92,7 +92,6 @@ 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].was_paced, input[i].was_paced);
EXPECT_EQ(truth[i].probe_cluster_id, input[i].probe_cluster_id);
}
}
@ -100,7 +99,7 @@ class TransportFeedbackAdapterTest : public ::testing::Test {
// Utility method, to reset arrival_time_ms before adding send time.
void OnSentPacket(PacketInfo info) {
info.arrival_time_ms = 0;
adapter_->AddPacket(info.sequence_number, info.payload_size, info.was_paced,
adapter_->AddPacket(info.sequence_number, info.payload_size,
info.probe_cluster_id);
adapter_->OnSentPacket(info.sequence_number, info.send_time_ms);
}
@ -115,11 +114,11 @@ class TransportFeedbackAdapterTest : public ::testing::Test {
TEST_F(TransportFeedbackAdapterTest, AdaptsFeedbackAndPopulatesSendTimes) {
std::vector<PacketInfo> packets;
packets.push_back(PacketInfo(100, 200, 0, 1500, true, 0));
packets.push_back(PacketInfo(110, 210, 1, 1500, true, 0));
packets.push_back(PacketInfo(120, 220, 2, 1500, true, 0));
packets.push_back(PacketInfo(130, 230, 3, 1500, true, 1));
packets.push_back(PacketInfo(140, 240, 4, 1500, true, 1));
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));
for (const PacketInfo& packet : packets)
OnSentPacket(packet);
@ -146,11 +145,11 @@ TEST_F(TransportFeedbackAdapterTest, AdaptsFeedbackAndPopulatesSendTimes) {
TEST_F(TransportFeedbackAdapterTest, HandlesDroppedPackets) {
std::vector<PacketInfo> packets;
packets.push_back(PacketInfo(100, 200, 0, 1500, true, 1));
packets.push_back(PacketInfo(110, 210, 1, 1500, true, 2));
packets.push_back(PacketInfo(120, 220, 2, 1500, true, 3));
packets.push_back(PacketInfo(130, 230, 3, 1500, true, 4));
packets.push_back(PacketInfo(140, 240, 4, 1500, true, 5));
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));
const uint16_t kSendSideDropBefore = 1;
const uint16_t kReceiveSideDropAfter = 3;
@ -191,12 +190,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, true,
packets.push_back(PacketInfo(kHighArrivalTimeMs - 64, 200, 0, 1500,
PacketInfo::kNotAProbe));
packets.push_back(PacketInfo(kHighArrivalTimeMs + 64, 210, 1, 1500, true,
PacketInfo::kNotAProbe));
packets.push_back(PacketInfo(kHighArrivalTimeMs, 220, 2, 1500, true,
packets.push_back(PacketInfo(kHighArrivalTimeMs + 64, 210, 1, 1500,
PacketInfo::kNotAProbe));
packets.push_back(
PacketInfo(kHighArrivalTimeMs, 220, 2, 1500, PacketInfo::kNotAProbe));
for (const PacketInfo& packet : packets)
OnSentPacket(packet);
@ -229,9 +228,9 @@ TEST_F(TransportFeedbackAdapterTest, SendTimeWrapsBothWays) {
TEST_F(TransportFeedbackAdapterTest, HandlesReordering) {
std::vector<PacketInfo> packets;
packets.push_back(PacketInfo(120, 200, 0, 1500, true, 0));
packets.push_back(PacketInfo(110, 210, 1, 1500, true, 0));
packets.push_back(PacketInfo(100, 220, 2, 1500, true, 0));
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));
std::vector<PacketInfo> expected_packets;
expected_packets.push_back(packets[2]);
expected_packets.push_back(packets[1]);

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

@ -251,21 +251,18 @@ struct PacketInfo {
-1,
sequence_number,
0,
false,
kNotAProbe) {}
PacketInfo(int64_t arrival_time_ms,
int64_t send_time_ms,
uint16_t sequence_number,
size_t payload_size,
bool was_paced,
int probe_cluster_id)
: PacketInfo(-1,
arrival_time_ms,
send_time_ms,
sequence_number,
payload_size,
was_paced,
probe_cluster_id) {}
PacketInfo(int64_t creation_time_ms,
@ -273,14 +270,12 @@ struct PacketInfo {
int64_t send_time_ms,
uint16_t sequence_number,
size_t payload_size,
bool was_paced,
int probe_cluster_id)
: 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),
was_paced(was_paced),
probe_cluster_id(probe_cluster_id) {}
static constexpr int kNotAProbe = -1;
@ -298,8 +293,6 @@ struct PacketInfo {
uint16_t sequence_number;
// Size of the packet excluding RTP headers.
size_t payload_size;
// True if the packet was paced out by the pacer.
bool was_paced;
// Which probing cluster this packets belongs to.
int probe_cluster_id;
};
@ -313,7 +306,6 @@ class TransportFeedbackObserver {
// must be set to 0.
virtual void AddPacket(uint16_t sequence_number,
size_t length,
bool was_paced,
int probe_cluster_id) = 0;
virtual void OnTransportFeedback(const rtcp::TransportFeedback& feedback) = 0;

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

@ -719,7 +719,7 @@ size_t RTPSender::SendPadData(size_t bytes,
length, rtp_header)) {
if (transport_feedback_observer_)
transport_feedback_observer_->AddPacket(options.packet_id, length,
true, probe_cluster_id);
probe_cluster_id);
}
}
@ -980,7 +980,7 @@ bool RTPSender::PrepareAndSendPacket(uint8_t* buffer,
if (UpdateTransportSequenceNumber(options.packet_id, buffer_to_send_ptr,
length, rtp_header)) {
if (transport_feedback_observer_)
transport_feedback_observer_->AddPacket(options.packet_id, length, true,
transport_feedback_observer_->AddPacket(options.packet_id, length,
probe_cluster_id);
}
}
@ -1111,7 +1111,7 @@ int32_t RTPSender::SendToNetwork(uint8_t* buffer,
if (UpdateTransportSequenceNumber(options.packet_id, buffer, length,
rtp_header)) {
if (transport_feedback_observer_)
transport_feedback_observer_->AddPacket(options.packet_id, length, true,
transport_feedback_observer_->AddPacket(options.packet_id, length,
PacketInfo::kNotAProbe);
}
}

2
webrtc/video/rtp_stream_receiver.cc
View File

@ -310,7 +310,7 @@ bool RtpStreamReceiver::DeliverRtp(const uint8_t* rtp_packet,
}
remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, payload_length,
header, true);
header);
header.payload_type_frequency = kVideoPayloadTypeFrequency;
bool in_order = IsPacketInOrder(header);

4
webrtc/voice_engine/channel.cc
View File

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