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

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

Browse Source 
Reason for revert:
Breaks google3 buildbot:  http://webrtc-buildbot-master.mtv.corp.google.com:21000/builders/WebRTC%20google3%20Importer/builds/8640

Original issue's description:
> Propagate probing cluster id to SendTimeHistory, both for packets and padding.
>
> BUG=webrtc:5859
>
> Committed: https://crrev.com/5be28c848b91bc6e4800eac07a3f5ac09a32ad70
> Cr-Commit-Position: refs/heads/master@{#12985}

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

Review-Url: https://codereview.webrtc.org/2032463003
Cr-Commit-Position: refs/heads/master@{#12987}
This commit is contained in:
philipel
2016-06-01 04:04:40 -07:00
committed by Commit bot
parent ce8d58c20e
commit 46948c17fd
24 changed files with 192 additions and 279 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

@ -245,44 +245,32 @@ class RtcpBandwidthObserver {
struct PacketInfo {
PacketInfo(int64_t arrival_time_ms, uint16_t sequence_number)
: PacketInfo(-1,
arrival_time_ms,
-1,
sequence_number,
0,
false,
kNotAProbe) {}
: PacketInfo(-1, arrival_time_ms, -1, sequence_number, 0, false) {}
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)
bool was_paced)
: PacketInfo(-1,
arrival_time_ms,
send_time_ms,
sequence_number,
payload_size,
was_paced,
probe_cluster_id) {}
was_paced) {}
PacketInfo(int64_t creation_time_ms,
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)
bool was_paced)
: 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;
was_paced(was_paced) {}
// Time corresponding to when this object was created.
int64_t creation_time_ms;
@ -299,8 +287,6 @@ struct PacketInfo {
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;
};
class TransportFeedbackObserver {
@ -312,8 +298,7 @@ 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;
bool was_paced) = 0;
virtual void OnTransportFeedback(const rtcp::TransportFeedback& feedback) = 0;
};

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

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

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

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

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

@ -123,12 +123,11 @@ class ModuleRtpRtcpImpl : public RtpRtcp {
bool TimeToSendPacket(uint32_t ssrc,
uint16_t sequence_number,
int64_t capture_time_ms,
bool retransmission,
int probe_cluster_id) override;
bool retransmission) 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) override;
// RTCP part.

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

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

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

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

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

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