Make OverheadObserver::OnOverheadChanged count RTP headers only

webrtc/video/video_send_stream.cc

Index: webrtc/video/video_send_stream.cc
diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc
index 9a3b51e278a0c4f69608e9ea5966f9b82e7f76d2..439d2bf93254eabd4a1d8b671c03c74f81e97bd9 100644
--- a/webrtc/video/video_send_stream.cc
+++ b/webrtc/video/video_send_stream.cc
@@ -39,6 +39,9 @@ namespace webrtc {
 static const int kMinSendSidePacketHistorySize = 600;
 namespace {
 
+// We don't to MTU discovery, so assume that we have the standard ethernet MTU.

[stefan-webrtc, 2016/12/20 13:05:01]

we don't do

[nisse-webrtc, 2016/12/20 13:38:13]

Done.

+const size_t kPathMTU = 1500;
+
 std::vector<RtpRtcp*> CreateRtpRtcpModules(
     Transport* outgoing_transport,
     RtcpIntraFrameObserver* intra_frame_callback,
@@ -808,8 +811,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 +1190,22 @@ 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;
+    // Substract total overhead (transport + rtp) from bitrate.

[stefan-webrtc, 2016/12/20 13:05:01]

Subtract

[nisse-webrtc, 2016/12/20 13:38:13]

Done.

+    int rtp_overhead;

[stefan-webrtc, 2016/12/20 13:05:01]

Should probably change this to a size_t to avoid casting

[nisse-webrtc, 2016/12/20 13:38:13]

Done. (For some reason I thought the overhead_bytes_per_packet_ member was an
int, but it's also a size_t).

+    {
+      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 (static_cast<size_t>(rtp_overhead) >= config_->rtp.max_packet_size) {
+      bitrate_bps = 0;

[stefan-webrtc, 2016/12/20 13:05:01]

I would log a warning if this ever happens... :)

[nisse-webrtc, 2016/12/20 13:38:13]

Done.

+    } else {
+      bitrate_bps =
+          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 -
@@ -1264,14 +1274,22 @@ void VideoSendStreamImpl::OnOverheadChanged(size_t overhead_bytes_per_packet) {
 
 void VideoSendStreamImpl::SetTransportOverhead(
     int transport_overhead_bytes_per_packet) {
+  if (transport_overhead_bytes_per_packet >= static_cast<int>(kPathMTU)) {
+    LOG(LS_ERROR) << "transport_overhead exceeds size of ethrnet frame";

[stefan-webrtc, 2016/12/20 13:05:01]

"Transport overhead exceeds size of ethernet frame"

[nisse-webrtc, 2016/12/20 13:38:13]

Done.

+    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);
   }
 }