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

Make OverheadObserver::OnOverheadChanged count RTP headers only

Browse Source 
This lets the RTP code be unaware of lower layers, and the
SetTransportOverhead method is deleted from RTPSender and RtpRtcp.

Instead, that method is added to CongestionController and
TransportFeedbackAdapter, where it is more appropriate.

BUG=wertc:6847

Review-Url: https://codereview.webrtc.org/2589743002
Cr-Commit-Position: refs/heads/master@{#15995}
This commit is contained in:
nisse 2017-01-10 08:58:32 -08:00 committed by Commit bot
parent c0ce6cc85e
commit 284542b882
19 changed files with 163 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -306,6 +306,12 @@ void CongestionController::SignalNetworkState(NetworkState state) {
MaybeTriggerOnNetworkChanged();
}
void CongestionController::SetTransportOverhead(
size_t transport_overhead_bytes_per_packet) {
transport_feedback_adapter_.SetTransportOverhead(
transport_overhead_bytes_per_packet);
}
void CongestionController::OnSentPacket(const rtc::SentPacket& sent_packet) {
// We're not interested in packets without an id, which may be stun packets,
// etc, sent on the same transport.

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

@ -81,6 +81,8 @@ class CongestionController : public CallStatsObserver, public Module {
int min_bitrate_bps,
int max_bitrate_bps);
virtual void SignalNetworkState(NetworkState state);
virtual void SetTransportOverhead(size_t transport_overhead_bytes_per_packet);
virtual BitrateController* GetBitrateController() const;
virtual RemoteBitrateEstimator* GetRemoteBitrateEstimator(
bool send_side_bwe);

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

@ -19,6 +19,7 @@
#include "webrtc/modules/congestion_controller/delay_based_bwe.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
#include "webrtc/modules/utility/include/process_thread.h"
#include "webrtc/system_wrappers/include/field_trial.h"
namespace webrtc {
@ -59,6 +60,10 @@ void TransportFeedbackAdapter::AddPacket(uint16_t sequence_number,
size_t length,
int probe_cluster_id) {
rtc::CritScope cs(&lock_);
if (webrtc::field_trial::FindFullName("WebRTC-SendSideBwe-WithOverhead") ==
"Enabled") {
length += transport_overhead_bytes_per_packet_;
}
send_time_history_.AddAndRemoveOld(sequence_number, length, probe_cluster_id);
}
@ -73,6 +78,12 @@ void TransportFeedbackAdapter::SetMinBitrate(int min_bitrate_bps) {
delay_based_bwe_->SetMinBitrate(min_bitrate_bps);
}
void TransportFeedbackAdapter::SetTransportOverhead(
int transport_overhead_bytes_per_packet) {
rtc::CritScope cs(&lock_);
transport_overhead_bytes_per_packet_ = transport_overhead_bytes_per_packet;
}
int64_t TransportFeedbackAdapter::GetProbingIntervalMs() const {
rtc::CritScope cs(&bwe_lock_);
return delay_based_bwe_->GetProbingIntervalMs();

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

@ -49,6 +49,7 @@ class TransportFeedbackAdapter : public TransportFeedbackObserver,
void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override;
void SetMinBitrate(int min_bitrate_bps);
void SetTransportOverhead(int transport_overhead_bytes_per_packet);
int64_t GetProbingIntervalMs() const;
@ -58,6 +59,7 @@ class TransportFeedbackAdapter : public TransportFeedbackObserver,
rtc::CriticalSection lock_;
rtc::CriticalSection bwe_lock_;
int transport_overhead_bytes_per_packet_ GUARDED_BY(&lock_);
SendTimeHistory send_time_history_ GUARDED_BY(&lock_);
std::unique_ptr<DelayBasedBwe> delay_based_bwe_ GUARDED_BY(&bwe_lock_);
Clock* const clock_;

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

@ -114,36 +114,25 @@ class RtpRtcp : public Module {
// Sender
// **************************************************************************
// Sets MTU.
// |size| - Max transfer unit in bytes, default is 1500.
// Returns -1 on failure else 0.
virtual int32_t SetMaxTransferUnit(uint16_t size) = 0;
// TODO(nisse): Deprecated. Kept temporarily, as an alias for the
// new function which has slighly different semantics. Delete as
// soon as known applications are updated.
virtual int32_t SetMaxTransferUnit(uint16_t size) {
SetMaxRtpPacketSize(size);
return 0;
}
// Sets transport overhead. Default is IPv4 and UDP with no encryption.
// |tcp| - true for TCP false UDP.
// |ipv6| - true for IP version 6 false for version 4.
// |authentication_overhead| - number of bytes to leave for an authentication
// header.
// Returns -1 on failure else 0
// TODO(michaelt): deprecate the function.
virtual int32_t SetTransportOverhead(bool tcp,
bool ipv6,
uint8_t authentication_overhead = 0) = 0;
// Sets the maximum size of an RTP packet, including RTP headers.
virtual void SetMaxRtpPacketSize(size_t size) = 0;
// Sets transport overhead per packet.
virtual void SetTransportOverhead(int transport_overhead_per_packet) = 0;
// Returns max payload length, which is a combination of the configuration
// MaxTransferUnit and TransportOverhead.
// Returns max payload length.
// Does not account for RTP headers and FEC/ULP/RED overhead (when FEC is
// enabled).
virtual uint16_t MaxPayloadLength() const = 0;
virtual size_t MaxPayloadSize() const = 0;
// Returns max data payload length, which is a combination of the
// configuration MaxTransferUnit, headers and TransportOverhead.
// Takes into account RTP headers and FEC/ULP/RED overhead (when FEC is
// enabled).
virtual uint16_t MaxDataPayloadLength() const = 0;
// Returns max RTP packet size. Takes into account RTP headers and
// FEC/ULP/RED overhead (when FEC is enabled).
virtual size_t MaxRtpPacketSize() const = 0;
// Sets codec name and payload type. Returns -1 on failure else 0.
virtual int32_t RegisterSendPayload(const CodecInst& voice_codec) = 0;

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

@ -53,12 +53,10 @@ class MockRtpRtcp : public RtpRtcp {
uint32_t audio_rtcp_arrival_time_frac));
MOCK_METHOD0(InitSender, int32_t());
MOCK_METHOD1(RegisterSendTransport, int32_t(Transport* outgoing_transport));
MOCK_METHOD1(SetMaxTransferUnit, int32_t(uint16_t size));
MOCK_METHOD3(SetTransportOverhead,
int32_t(bool tcp, bool ipv6, uint8_t authentication_overhead));
MOCK_METHOD1(SetMaxRtpPacketSize, void(size_t size));
MOCK_METHOD1(SetTransportOverhead, void(int transport_overhead_per_packet));
MOCK_CONST_METHOD0(MaxPayloadLength, uint16_t());
MOCK_CONST_METHOD0(MaxDataPayloadLength, uint16_t());
MOCK_CONST_METHOD0(MaxPayloadSize, size_t());
MOCK_CONST_METHOD0(MaxRtpPacketSize, size_t());
MOCK_METHOD1(RegisterSendPayload, int32_t(const CodecInst& voice_codec));
MOCK_METHOD1(RegisterSendPayload, int32_t(const VideoCodec& video_codec));
MOCK_METHOD2(RegisterVideoSendPayload,

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

@ -176,7 +176,7 @@ RTCPSender::RTCPSender(
tmmbr_send_bps_(0),
packet_oh_send_(0),
max_payload_length_(IP_PACKET_SIZE - 28), // IPv4 + UDP by default.
max_packet_size_(IP_PACKET_SIZE - 28), // IPv4 + UDP by default.
app_sub_type_(0),
app_name_(0),
@ -283,8 +283,8 @@ void RTCPSender::SetTMMBRStatus(bool enable) {
}
}
void RTCPSender::SetMaxPayloadLength(size_t max_payload_length) {
max_payload_length_ = max_payload_length;
void RTCPSender::SetMaxRtpPacketSize(size_t max_packet_size) {
max_packet_size_ = max_packet_size;
}
void RTCPSender::SetTimestampOffset(uint32_t timestamp_offset) {
@ -828,7 +828,7 @@ int32_t RTCPSender::SendCompoundRTCP(
RTC_DCHECK(AllVolatileFlagsConsumed());
}
size_t bytes_sent = container.SendPackets(max_payload_length_);
size_t bytes_sent = container.SendPackets(max_packet_size_);
return bytes_sent == 0 ? -1 : 0;
}
@ -1049,9 +1049,9 @@ bool RTCPSender::SendFeedbackPacket(const rtcp::TransportFeedback& packet) {
// but we can't because of an incorrect warning (C4822) in MVS 2013.
} sender(transport_, event_log_);
RTC_DCHECK_LE(max_payload_length_, IP_PACKET_SIZE);
RTC_DCHECK_LE(max_packet_size_, IP_PACKET_SIZE);
uint8_t buffer[IP_PACKET_SIZE];
return packet.BuildExternalBuffer(buffer, max_payload_length_, &sender) &&
return packet.BuildExternalBuffer(buffer, max_packet_size_, &sender) &&
!sender.send_failure_;
}

4
webrtc/modules/rtp_rtcp/source/rtcp_sender.h
View File

@ -133,7 +133,7 @@ class RTCPSender {
void SetTMMBRStatus(bool enable);
void SetMaxPayloadLength(size_t max_payload_length);
void SetMaxRtpPacketSize(size_t max_packet_size);
void SetTmmbn(std::vector<rtcp::TmmbItem> bounding_set);
@ -240,7 +240,7 @@ class RTCPSender {
GUARDED_BY(critical_section_rtcp_sender_);
uint32_t tmmbr_send_bps_ GUARDED_BY(critical_section_rtcp_sender_);
uint32_t packet_oh_send_ GUARDED_BY(critical_section_rtcp_sender_);
size_t max_payload_length_;
size_t max_packet_size_;
// APP
uint8_t app_sub_type_ GUARDED_BY(critical_section_rtcp_sender_);

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

@ -121,7 +121,10 @@ ModuleRtpRtcpImpl::ModuleRtpRtcpImpl(const Configuration& configuration)
rtcp_sender_.SetTimestampOffset(rtp_sender_.TimestampOffset());
// Set default packet size limit.
SetMaxTransferUnit(IP_PACKET_SIZE);
// TODO(nisse): Kind-of duplicates
// webrtc::VideoSendStream::Config::Rtp::kDefaultMaxPacketSize.
const size_t kTcpOverIpv4HeaderSize = 40;
SetMaxRtpPacketSize(IP_PACKET_SIZE - kTcpOverIpv4HeaderSize);
}
// Returns the number of milliseconds until the module want a worker thread
@ -415,65 +418,22 @@ size_t ModuleRtpRtcpImpl::TimeToSendPadding(size_t bytes,
return rtp_sender_.TimeToSendPadding(bytes, probe_cluster_id);
}
uint16_t ModuleRtpRtcpImpl::MaxPayloadLength() const {
return rtp_sender_.MaxPayloadLength();
size_t ModuleRtpRtcpImpl::MaxPayloadSize() const {
return rtp_sender_.MaxPayloadSize();
}
uint16_t ModuleRtpRtcpImpl::MaxDataPayloadLength() const {
return rtp_sender_.MaxDataPayloadLength();
size_t ModuleRtpRtcpImpl::MaxRtpPacketSize() const {
return rtp_sender_.MaxRtpPacketSize();
}
int32_t ModuleRtpRtcpImpl::SetTransportOverhead(
const bool tcp,
const bool ipv6,
const uint8_t authentication_overhead) {
uint16_t packet_overhead = 0;
if (ipv6) {
packet_overhead = 40;
} else {
packet_overhead = 20;
}
if (tcp) {
// TCP.
packet_overhead += 20;
} else {
// UDP.
packet_overhead += 8;
}
packet_overhead += authentication_overhead;
void ModuleRtpRtcpImpl::SetMaxRtpPacketSize(size_t rtp_packet_size) {
RTC_DCHECK_LE(rtp_packet_size, IP_PACKET_SIZE)
<< "rtp packet size too large: " << rtp_packet_size;
RTC_DCHECK_GT(rtp_packet_size, packet_overhead_)
<< "rtp packet size too small: " << rtp_packet_size;
if (packet_overhead == packet_overhead_) {
// Ok same as before.
return 0;
}
size_t mtu = rtp_sender_.MaxPayloadLength() + packet_overhead_;
size_t max_payload_length = mtu - packet_overhead;
packet_overhead_ = packet_overhead;
rtcp_sender_.SetMaxPayloadLength(max_payload_length);
rtp_sender_.SetMaxPayloadLength(max_payload_length);
return 0;
}
void ModuleRtpRtcpImpl::SetTransportOverhead(
int transport_overhead_per_packet) {
RTC_DCHECK_GT(transport_overhead_per_packet, 0);
int mtu = rtp_sender_.MaxPayloadLength() + packet_overhead_;
RTC_DCHECK_LT(transport_overhead_per_packet, mtu);
size_t max_payload_length = mtu - transport_overhead_per_packet;
packet_overhead_ = transport_overhead_per_packet;
rtp_sender_.SetTransportOverhead(packet_overhead_);
rtcp_sender_.SetMaxPayloadLength(max_payload_length);
rtp_sender_.SetMaxPayloadLength(max_payload_length);
}
int32_t ModuleRtpRtcpImpl::SetMaxTransferUnit(uint16_t mtu) {
RTC_DCHECK_LE(mtu, IP_PACKET_SIZE) << "MTU too large: " << mtu;
RTC_DCHECK_GT(mtu, packet_overhead_) << "MTU too small: " << mtu;
size_t max_payload_length = mtu - packet_overhead_;
rtcp_sender_.SetMaxPayloadLength(max_payload_length);
rtp_sender_.SetMaxPayloadLength(max_payload_length);
return 0;
rtcp_sender_.SetMaxRtpPacketSize(rtp_packet_size);
rtp_sender_.SetMaxRtpPacketSize(rtp_packet_size);
}
RtcpMode ModuleRtpRtcpImpl::RTCP() const {

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

@ -207,18 +207,11 @@ class ModuleRtpRtcpImpl : public RtpRtcp, public RTCPReceiver::ModuleRtpRtcp {
void SetTmmbn(std::vector<rtcp::TmmbItem> bounding_set) override;
uint16_t MaxPayloadLength() const override;
size_t MaxPayloadSize() const override;
uint16_t MaxDataPayloadLength() const override;
size_t MaxRtpPacketSize() const override;
int32_t SetMaxTransferUnit(uint16_t size) override;
// TODO(michaelt): deprecate the function.
int32_t SetTransportOverhead(bool tcp,
bool ipv6,
uint8_t authentication_overhead = 0) override;
void SetTransportOverhead(int transport_overhead_per_packet) override;
void SetMaxRtpPacketSize(size_t max_packet_size) override;
// (NACK) Negative acknowledgment part.

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

@ -92,8 +92,8 @@ RTPSender::RTPSender(
transport_feedback_observer_(transport_feedback_observer),
last_capture_time_ms_sent_(0),
transport_(transport),
sending_media_(true), // Default to sending media.
max_payload_length_(IP_PACKET_SIZE - 28), // Default is IP-v4/UDP.
sending_media_(true), // Default to sending media.
max_packet_size_(IP_PACKET_SIZE - 28), // Default is IP-v4/UDP.
payload_type_(-1),
payload_type_map_(),
rtp_header_extension_map_(),
@ -121,7 +121,6 @@ RTPSender::RTPSender(
last_packet_marker_bit_(false),
csrcs_(),
rtx_(kRtxOff),
transport_overhead_bytes_per_packet_(0),
rtp_overhead_bytes_per_packet_(0),
retransmission_rate_limiter_(retransmission_rate_limiter),
overhead_observer_(overhead_observer) {
@ -297,26 +296,26 @@ int8_t RTPSender::SendPayloadType() const {
return payload_type_;
}
void RTPSender::SetMaxPayloadLength(size_t max_payload_length) {
void RTPSender::SetMaxRtpPacketSize(size_t max_packet_size) {
// Sanity check.
RTC_DCHECK(max_payload_length >= 100 && max_payload_length <= IP_PACKET_SIZE)
<< "Invalid max payload length: " << max_payload_length;
RTC_DCHECK(max_packet_size >= 100 && max_packet_size <= IP_PACKET_SIZE)
<< "Invalid max payload length: " << max_packet_size;
rtc::CritScope lock(&send_critsect_);
max_payload_length_ = max_payload_length;
max_packet_size_ = max_packet_size;
}
size_t RTPSender::MaxDataPayloadLength() const {
size_t RTPSender::MaxPayloadSize() const {
if (audio_configured_) {
return max_payload_length_ - RtpHeaderLength();
return max_packet_size_ - RtpHeaderLength();
} else {
return max_payload_length_ - RtpHeaderLength() // RTP overhead.
- video_->FecPacketOverhead() // FEC/ULP/RED overhead.
- (RtxStatus() ? kRtxHeaderSize : 0); // RTX overhead.
return max_packet_size_ - RtpHeaderLength() // RTP overhead.
- video_->FecPacketOverhead() // FEC/ULP/RED overhead.
- (RtxStatus() ? kRtxHeaderSize : 0); // RTX overhead.
}
}
size_t RTPSender::MaxPayloadLength() const {
return max_payload_length_;
size_t RTPSender::MaxRtpPacketSize() const {
return max_packet_size_;
}
void RTPSender::SetRtxStatus(int mode) {
@ -483,7 +482,7 @@ size_t RTPSender::SendPadData(size_t bytes, int probe_cluster_id) {
// RtpPacketSender, which will make sure we don't send too much padding even
// if a single packet is larger than requested.
size_t padding_bytes_in_packet =
std::min(MaxDataPayloadLength(), kMaxPaddingLength);
std::min(MaxPayloadSize(), kMaxPaddingLength);
size_t bytes_sent = 0;
while (bytes_sent < bytes) {
int64_t now_ms = clock_->TimeInMilliseconds();
@ -974,7 +973,7 @@ void RTPSender::GetDataCounters(StreamDataCounters* rtp_stats,
std::unique_ptr<RtpPacketToSend> RTPSender::AllocatePacket() const {
rtc::CritScope lock(&send_critsect_);
std::unique_ptr<RtpPacketToSend> packet(
new RtpPacketToSend(&rtp_header_extension_map_, max_payload_length_));
new RtpPacketToSend(&rtp_header_extension_map_, max_packet_size_));
packet->SetSsrc(ssrc_);
packet->SetCsrcs(csrcs_);
// Reserve extensions, if registered, RtpSender set in SendToNetwork.
@ -1253,31 +1252,13 @@ RtpState RTPSender::GetRtxRtpState() const {
return state;
}
void RTPSender::SetTransportOverhead(int transport_overhead) {
if (!overhead_observer_)
return;
size_t overhead_bytes_per_packet = 0;
{
rtc::CritScope lock(&send_critsect_);
if (transport_overhead_bytes_per_packet_ ==
static_cast<size_t>(transport_overhead)) {
return;
}
transport_overhead_bytes_per_packet_ = transport_overhead;
overhead_bytes_per_packet =
rtp_overhead_bytes_per_packet_ + transport_overhead_bytes_per_packet_;
}
overhead_observer_->OnOverheadChanged(overhead_bytes_per_packet);
}
void RTPSender::AddPacketToTransportFeedback(uint16_t packet_id,
const RtpPacketToSend& packet,
int probe_cluster_id) {
size_t packet_size = packet.payload_size() + packet.padding_size();
if (webrtc::field_trial::FindFullName("WebRTC-SendSideBwe-WithOverhead") ==
"Enabled") {
rtc::CritScope lock(&send_critsect_);
packet_size = packet.size() + transport_overhead_bytes_per_packet_;
packet_size = packet.size();
}
if (transport_feedback_observer_) {
@ -1289,15 +1270,14 @@ void RTPSender::AddPacketToTransportFeedback(uint16_t packet_id,
void RTPSender::UpdateRtpOverhead(const RtpPacketToSend& packet) {
if (!overhead_observer_)
return;
size_t overhead_bytes_per_packet = 0;
size_t overhead_bytes_per_packet;
{
rtc::CritScope lock(&send_critsect_);
if (rtp_overhead_bytes_per_packet_ == packet.headers_size()) {
return;
}
rtp_overhead_bytes_per_packet_ = packet.headers_size();
overhead_bytes_per_packet =
rtp_overhead_bytes_per_packet_ + transport_overhead_bytes_per_packet_;
overhead_bytes_per_packet = rtp_overhead_bytes_per_packet_;
}
overhead_observer_->OnOverheadChanged(overhead_bytes_per_packet);
}

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

@ -72,8 +72,8 @@ class RTPSender {
uint32_t FecOverheadRate() const;
uint32_t NackOverheadRate() const;
// Includes size of RTP and FEC headers.
size_t MaxDataPayloadLength() const;
// Excluding size of RTP and FEC headers.
size_t MaxPayloadSize() const;
int32_t RegisterPayload(const char* payload_name,
const int8_t payload_type,
@ -106,7 +106,7 @@ class RTPSender {
void SetCsrcs(const std::vector<uint32_t>& csrcs);
void SetMaxPayloadLength(size_t max_payload_length);
void SetMaxRtpPacketSize(size_t max_packet_size);
bool SendOutgoingData(FrameType frame_type,
int8_t payload_type,
@ -164,7 +164,8 @@ class RTPSender {
size_t RtpHeaderLength() const;
uint16_t AllocateSequenceNumber(uint16_t packets_to_send);
size_t MaxPayloadLength() const;
// Including RTP headers.
size_t MaxRtpPacketSize() const;
uint32_t SSRC() const;
@ -208,8 +209,6 @@ class RTPSender {
void SetRtxRtpState(const RtpState& rtp_state);
RtpState GetRtxRtpState() const;
void SetTransportOverhead(int transport_overhead);
protected:
int32_t CheckPayloadType(int8_t payload_type, RtpVideoCodecTypes* video_type);
@ -272,7 +271,7 @@ class RTPSender {
Transport* transport_;
bool sending_media_ GUARDED_BY(send_critsect_);
size_t max_payload_length_;
size_t max_packet_size_;
int8_t payload_type_ GUARDED_BY(send_critsect_);
std::map<int8_t, RtpUtility::Payload*> payload_type_map_;
@ -323,7 +322,6 @@ class RTPSender {
uint32_t ssrc_rtx_ GUARDED_BY(send_critsect_);
// Mapping rtx_payload_type_map_[associated] = rtx.
std::map<int8_t, int8_t> rtx_payload_type_map_ GUARDED_BY(send_critsect_);
size_t transport_overhead_bytes_per_packet_ GUARDED_BY(send_critsect_);
size_t rtp_overhead_bytes_per_packet_ GUARDED_BY(send_critsect_);
RateLimiter* const retransmission_rate_limiter_;

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

@ -1394,21 +1394,16 @@ TEST_F(RtpSenderTest, OnOverheadChanged) {
nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
&retransmission_rate_limiter_, &mock_overhead_observer));
// Transport overhead is set to 28B.
EXPECT_CALL(mock_overhead_observer, OnOverheadChanged(28)).Times(1);
rtp_sender_->SetTransportOverhead(28);
// RTP overhead is 12B.
// 28B + 12B = 40B
EXPECT_CALL(mock_overhead_observer, OnOverheadChanged(40)).Times(1);
EXPECT_CALL(mock_overhead_observer, OnOverheadChanged(12)).Times(1);
SendGenericPayload();
rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
kTransmissionTimeOffsetExtensionId);
// TransmissionTimeOffset extension has a size of 8B.
// 28B + 12B + 8B = 48B
EXPECT_CALL(mock_overhead_observer, OnOverheadChanged(48)).Times(1);
// 12B + 8B = 20B
EXPECT_CALL(mock_overhead_observer, OnOverheadChanged(20)).Times(1);
SendGenericPayload();
}
@ -1419,17 +1414,12 @@ TEST_F(RtpSenderTest, DoesNotUpdateOverheadOnEqualSize) {
nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
&retransmission_rate_limiter_, &mock_overhead_observer));
EXPECT_CALL(mock_overhead_observer, OnOverheadChanged(_)).Times(1);
rtp_sender_->SetTransportOverhead(28);
rtp_sender_->SetTransportOverhead(28);
EXPECT_CALL(mock_overhead_observer, OnOverheadChanged(_)).Times(1);
SendGenericPayload();
SendGenericPayload();
}
TEST_F(RtpSenderTest, AddOverheadToTransportFeedbackObserver) {
constexpr int kTransportOverheadBytesPerPacket = 28;
constexpr int kRtpOverheadBytesPerPacket = 12 + 8;
test::ScopedFieldTrials override_field_trials(
"WebRTC-SendSideBwe-WithOverhead/Enabled/");
@ -1438,7 +1428,6 @@ TEST_F(RtpSenderTest, AddOverheadToTransportFeedbackObserver) {
false, &fake_clock_, &transport_, nullptr, nullptr, &seq_num_allocator_,
&feedback_observer_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
nullptr, &retransmission_rate_limiter_, &mock_overhead_observer));
rtp_sender_->SetTransportOverhead(kTransportOverheadBytesPerPacket);
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber,
kTransportSequenceNumberExtensionId));
@ -1447,13 +1436,11 @@ TEST_F(RtpSenderTest, AddOverheadToTransportFeedbackObserver) {
EXPECT_CALL(feedback_observer_,
AddPacket(kTransportSequenceNumber,
sizeof(kPayloadData) + kGenericHeaderLength +
kRtpOverheadBytesPerPacket +
kTransportOverheadBytesPerPacket,
kRtpOverheadBytesPerPacket,
PacketInfo::kNotAProbe))
.Times(1);
EXPECT_CALL(mock_overhead_observer,
OnOverheadChanged(kTransportOverheadBytesPerPacket +
kRtpOverheadBytesPerPacket))
OnOverheadChanged(kRtpOverheadBytesPerPacket))
.Times(1);
SendGenericPayload();
}

2
webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
View File

@ -337,7 +337,7 @@ bool RTPSenderVideo::SendVideo(RtpVideoCodecTypes video_type,
retransmission_settings = retransmission_settings_;
}
size_t packet_capacity = rtp_sender_->MaxPayloadLength() -
size_t packet_capacity = rtp_sender_->MaxRtpPacketSize() -
fec_packet_overhead -
(rtp_sender_->RtxStatus() ? kRtxHeaderSize : 0);
RTC_DCHECK_LE(packet_capacity, rtp_header->capacity());

18
webrtc/modules/rtp_rtcp/test/testAPI/test_api.cc
View File

@ -130,20 +130,10 @@ TEST_F(RtpRtcpAPITest, Basic) {
EXPECT_TRUE(module_->Sending());
}
TEST_F(RtpRtcpAPITest, MTU) {
EXPECT_EQ(0, module_->SetMaxTransferUnit(1234));
EXPECT_EQ(1234 - 20 - 8, module_->MaxPayloadLength());
EXPECT_EQ(0, module_->SetTransportOverhead(true, true, 12));
EXPECT_EQ(1234 - 20 - 20 - 20 - 12, module_->MaxPayloadLength());
EXPECT_EQ(0, module_->SetTransportOverhead(false, false, 0));
EXPECT_EQ(1234 - 20 - 8, module_->MaxPayloadLength());
module_->SetTransportOverhead(28);
EXPECT_EQ(1234 - 28, module_->MaxPayloadLength());
module_->SetTransportOverhead(44);
EXPECT_EQ(1234 - 44, module_->MaxPayloadLength());
TEST_F(RtpRtcpAPITest, PacketSize) {
module_->SetMaxRtpPacketSize(1234);
EXPECT_EQ(1234u, module_->MaxRtpPacketSize());
EXPECT_EQ(1234u - 12u /* Minimum RTP header */, module_->MaxPayloadSize());
}
TEST_F(RtpRtcpAPITest, SSRC) {

62
webrtc/video/video_send_stream.cc
View File

@ -39,6 +39,9 @@ namespace webrtc {
static const int kMinSendSidePacketHistorySize = 600;
namespace {
// We don't do MTU discovery, so assume that we have the standard ethernet MTU.
const size_t kPathMTU = 1500;
std::vector<RtpRtcp*> CreateRtpRtcpModules(
Transport* outgoing_transport,
RtcpIntraFrameObserver* intra_frame_callback,
@ -326,7 +329,7 @@ class VideoSendStreamImpl : public webrtc::BitrateAllocatorObserver,
void EnableEncodedFrameRecording(const std::vector<rtc::PlatformFile>& files,
size_t byte_limit);
void SetTransportOverhead(int transport_overhead_per_packet);
void SetTransportOverhead(size_t transport_overhead_per_packet);
private:
class CheckEncoderActivityTask;
@ -689,7 +692,8 @@ VideoSendStream::RtpStateMap VideoSendStream::StopPermanentlyAndGetRtpStates() {
return state_map;
}
void VideoSendStream::SetTransportOverhead(int transport_overhead_per_packet) {
void VideoSendStream::SetTransportOverhead(
size_t transport_overhead_per_packet) {
RTC_DCHECK_RUN_ON(&thread_checker_);
VideoSendStreamImpl* send_stream = send_stream_.get();
worker_queue_->PostTask([send_stream, transport_overhead_per_packet] {
@ -808,8 +812,7 @@ VideoSendStreamImpl::VideoSendStreamImpl(
for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
rtp_rtcp->RegisterRtcpStatisticsCallback(stats_proxy_);
rtp_rtcp->RegisterSendChannelRtpStatisticsCallback(stats_proxy_);
rtp_rtcp->SetMaxTransferUnit(
static_cast<uint16_t>(config_->rtp.max_packet_size));
rtp_rtcp->SetMaxRtpPacketSize(config_->rtp.max_packet_size);
rtp_rtcp->RegisterVideoSendPayload(
config_->encoder_settings.payload_type,
config_->encoder_settings.payload_name.c_str());
@ -1188,14 +1191,27 @@ uint32_t VideoSendStreamImpl::OnBitrateUpdated(uint32_t bitrate_bps,
if (webrtc::field_trial::FindFullName("WebRTC-SendSideBwe-WithOverhead") ==
"Enabled") {
// Substract overhead from bitrate.
rtc::CritScope lock(&overhead_bytes_per_packet_crit_);
int packets_per_second =
std::ceil(bitrate_bps / (8 * (config_->rtp.max_packet_size +
transport_overhead_bytes_per_packet_)));
uint32_t overhead_bps = static_cast<uint32_t>(
8 * overhead_bytes_per_packet_ * packets_per_second);
bitrate_bps = overhead_bps > bitrate_bps ? 0u : bitrate_bps - overhead_bps;
// Subtract total overhead (transport + rtp) from bitrate.
size_t rtp_overhead;
{
rtc::CritScope lock(&overhead_bytes_per_packet_crit_);
rtp_overhead = overhead_bytes_per_packet_;
}
RTC_CHECK_GE(rtp_overhead, 0);
RTC_DCHECK_LT(rtp_overhead, config_->rtp.max_packet_size);
if (rtp_overhead >= config_->rtp.max_packet_size) {
LOG(LS_WARNING) << "RTP overhead (" << rtp_overhead << " bytes)"
<< "exceeds maximum packet size ("
<< config_->rtp.max_packet_size << " bytes)";
bitrate_bps = 0;
} else {
bitrate_bps =
static_cast<uint32_t>(static_cast<uint64_t>(bitrate_bps) *
(config_->rtp.max_packet_size - rtp_overhead) /
(config_->rtp.max_packet_size +
transport_overhead_bytes_per_packet_));
}
}
// Get the encoder target rate. It is the estimated network rate -
@ -1263,15 +1279,23 @@ void VideoSendStreamImpl::OnOverheadChanged(size_t overhead_bytes_per_packet) {
}
void VideoSendStreamImpl::SetTransportOverhead(
int transport_overhead_bytes_per_packet) {
size_t transport_overhead_bytes_per_packet) {
if (transport_overhead_bytes_per_packet >= static_cast<int>(kPathMTU)) {
LOG(LS_ERROR) << "Transport overhead exceeds size of ethernet frame";
return;
}
transport_overhead_bytes_per_packet_ = transport_overhead_bytes_per_packet;
RTC_DCHECK_LE(config_->rtp.max_packet_size,
0xFFFFu + transport_overhead_bytes_per_packet);
const uint16_t mtu = static_cast<uint16_t>(
config_->rtp.max_packet_size + transport_overhead_bytes_per_packet);
congestion_controller_->SetTransportOverhead(
transport_overhead_bytes_per_packet_);
size_t rtp_packet_size =
std::min(config_->rtp.max_packet_size,
kPathMTU - transport_overhead_bytes_per_packet_);
for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
rtp_rtcp->SetTransportOverhead(transport_overhead_bytes_per_packet);
rtp_rtcp->SetMaxTransferUnit(mtu);
rtp_rtcp->SetMaxRtpPacketSize(rtp_packet_size);
}
}

2
webrtc/video/video_send_stream.h
View File

@ -92,7 +92,7 @@ class VideoSendStream : public webrtc::VideoSendStream {
RtpStateMap StopPermanentlyAndGetRtpStates();
void SetTransportOverhead(int transport_overhead_per_packet);
void SetTransportOverhead(size_t transport_overhead_per_packet);
private:
class ConstructionTask;

23
webrtc/voice_engine/channel.cc
View File

@ -914,6 +914,8 @@ Channel::Channel(int32_t channelId,
_lastLocalTimeStamp(0),
_lastPayloadType(0),
_includeAudioLevelIndication(false),
transport_overhead_per_packet_(0),
rtp_overhead_per_packet_(0),
_outputSpeechType(AudioFrame::kNormalSpeech),
restored_packet_in_use_(false),
rtcp_observer_(new VoERtcpObserver(this)),
@ -2878,16 +2880,23 @@ void Channel::SetRtcpRttStats(RtcpRttStats* rtcp_rtt_stats) {
rtcp_rtt_stats_proxy_->SetRtcpRttStats(rtcp_rtt_stats);
}
void Channel::SetTransportOverhead(int transport_overhead_per_packet) {
_rtpRtcpModule->SetTransportOverhead(transport_overhead_per_packet);
void Channel::UpdateOverheadForEncoder() {
audio_coding_->ModifyEncoder([&](std::unique_ptr<AudioEncoder>* encoder) {
if (*encoder) {
(*encoder)->OnReceivedOverhead(transport_overhead_per_packet_ +
rtp_overhead_per_packet_);
}
});
}
void Channel::SetTransportOverhead(size_t transport_overhead_per_packet) {
transport_overhead_per_packet_ = transport_overhead_per_packet;
UpdateOverheadForEncoder();
}
void Channel::OnOverheadChanged(size_t overhead_bytes_per_packet) {
audio_coding_->ModifyEncoder([&](std::unique_ptr<AudioEncoder>* encoder) {
if (*encoder) {
(*encoder)->OnReceivedOverhead(overhead_bytes_per_packet);
}
});
rtp_overhead_per_packet_ = overhead_bytes_per_packet;
UpdateOverheadForEncoder();
}
int Channel::RegisterExternalMediaProcessing(ProcessingTypes type,

6
webrtc/voice_engine/channel.h
View File

@ -415,7 +415,7 @@ class Channel
void SetRtcEventLog(RtcEventLog* event_log);
void SetRtcpRttStats(RtcpRttStats* rtcp_rtt_stats);
void SetTransportOverhead(int transport_overhead_per_packet);
void SetTransportOverhead(size_t transport_overhead_per_packet);
// From OverheadObserver in the RTP/RTCP module
void OnOverheadChanged(size_t overhead_bytes_per_packet) override;
@ -443,6 +443,8 @@ class Channel
RTPExtensionType type,
unsigned char id);
void UpdateOverheadForEncoder();
int GetRtpTimestampRateHz() const;
int64_t GetRTT(bool allow_associate_channel) const;
@ -529,6 +531,8 @@ class Channel
uint32_t _lastLocalTimeStamp;
int8_t _lastPayloadType;
bool _includeAudioLevelIndication;
size_t transport_overhead_per_packet_;
size_t rtp_overhead_per_packet_;
// VoENetwork
AudioFrame::SpeechType _outputSpeechType;
// VoEVideoSync