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 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,
     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 267 matching lines @@
   void SignalNetworkState(NetworkState state);
   bool DeliverRtcp(const uint8_t* packet, size_t length);
   void Start();
   void Stop();
 
   VideoSendStream::RtpStateMap GetRtpStates() const;
 
   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;
   class EncoderReconfiguredTask;
 
   // Implements BitrateAllocatorObserver.
   uint32_t OnBitrateUpdated(uint32_t bitrate_bps,
                             uint8_t fraction_loss,
                             int64_t rtt,
                             int64_t probing_interval_ms) override;
@@ skipping 342 matching lines @@
   vie_encoder_->DeRegisterProcessThread();
   VideoSendStream::RtpStateMap state_map;
   send_stream_->DeRegisterProcessThread();
   worker_queue_->PostTask(
       std::unique_ptr<rtc::QueuedTask>(new DestructAndGetRtpStateTask(
           &state_map, std::move(send_stream_), &thread_sync_event_)));
   thread_sync_event_.Wait(rtc::Event::kForever);
   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] {
     send_stream->SetTransportOverhead(transport_overhead_per_packet);
   });
 }
 
 bool VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
   // Called on a network thread.
   return send_stream_->DeliverRtcp(packet, length);
@@ skipping 98 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;
+    // 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 -
   // 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 47 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) {
+    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);
   }
 }
 
 }  // namespace internal
 }  // namespace webrtc