Make OverheadObserver::OnOverheadChanged count RTP headers only

webrtc/video/video_send_stream.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include "webrtc/video/video_send_stream.h"
@@ skipping 21 matching lines @@
 #include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/video/call_stats.h"
 #include "webrtc/video/vie_remb.h"
 #include "webrtc/video_send_stream.h"
 
 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,
     RtcpBandwidthObserver* bandwidth_callback,
     TransportFeedbackObserver* transport_feedback_callback,
     RtcpRttStats* rtt_stats,
     RtpPacketSender* paced_sender,
     TransportSequenceNumberAllocator* transport_sequence_number_allocator,
     FlexfecSender* flexfec_sender,
     SendStatisticsProxy* stats_proxy,
@@ skipping 749 matching lines @@
 
   ConfigureProtection();
   ConfigureSsrcs();
 
   // TODO(pbos): Should we set CNAME on all RTP modules?
   rtp_rtcp_modules_.front()->SetCNAME(config_->rtp.c_name.c_str());
 
   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());
   }
 
   RTC_DCHECK(config_->encoder_settings.encoder);
   RTC_DCHECK_GE(config_->encoder_settings.payload_type, 0);
   RTC_DCHECK_LE(config_->encoder_settings.payload_type, 127);
 
   vie_encoder_->SetStartBitrate(bitrate_allocator_->GetStartBitrate(this));
@@ skipping 358 matching lines @@
 uint32_t VideoSendStreamImpl::OnBitrateUpdated(uint32_t bitrate_bps,
                                                uint8_t fraction_loss,
                                                int64_t rtt,
                                                int64_t probing_interval_ms) {
   RTC_DCHECK_RUN_ON(worker_queue_);
   RTC_DCHECK(payload_router_.IsActive())
       << "VideoSendStream::Start has not been called.";
 
   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 -
   // protection overhead.
   encoder_target_rate_bps_ = protection_bitrate_calculator_.SetTargetRates(
       bitrate_bps, stats_proxy_->GetSendFrameRate(), fraction_loss, rtt);
   uint32_t protection_bitrate = bitrate_bps - encoder_target_rate_bps_;
 
   encoder_target_rate_bps_ =
       std::min(encoder_max_bitrate_bps_, encoder_target_rate_bps_);
@@ skipping 48 matching lines @@
   return 0;
 }
 
 void VideoSendStreamImpl::OnOverheadChanged(size_t overhead_bytes_per_packet) {
   rtc::CritScope lock(&overhead_bytes_per_packet_crit_);
   overhead_bytes_per_packet_ = 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);
   }
 }
 
 }  // namespace internal
 }  // namespace webrtc