Moving overhead counting to bitrate estimators.

webrtc/modules/congestion_controller/delay_based_bwe.cc

 /*
  *  Copyright (c) 2016 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.
  */
 
@@ skipping 143 matching lines @@
       detector_(),
       receiver_incoming_bitrate_(),
       last_seen_packet_ms_(-1),
       uma_recorded_(false),
       probe_bitrate_estimator_(event_log),
       trendline_window_size_(kDefaultTrendlineWindowSize),
       trendline_smoothing_coeff_(kDefaultTrendlineSmoothingCoeff),
       trendline_threshold_gain_(kDefaultTrendlineThresholdGain),
       consecutive_delayed_feedbacks_(0),
       last_logged_bitrate_(0),
-      last_logged_state_(BandwidthUsage::kBwNormal) {
+      last_logged_state_(BandwidthUsage::kBwNormal),
+      send_side_bwe_with_overhead_(
+          webrtc::field_trial::IsEnabled("WebRTC-SendSideBwe-WithOverhead")) {
   LOG(LS_INFO) << "Using Trendline filter for delay change estimation.";
 
   network_thread_.DetachFromThread();
 }
 
 DelayBasedBwe::Result DelayBasedBwe::IncomingPacketFeedbackVector(
     const std::vector<PacketFeedback>& packet_feedback_vector) {
   RTC_DCHECK(network_thread_.CalledOnValidThread());
 
   std::vector<PacketFeedback> sorted_packet_feedback_vector;
@@ skipping 50 matching lines @@
   result.target_bitrate_bps = rate_control_.LatestEstimate();
   LOG(LS_WARNING) << "Long feedback delay detected, reducing BWE to "
                   << result.target_bitrate_bps;
   return result;
 }
 
 void DelayBasedBwe::IncomingPacketFeedback(
     const PacketFeedback& packet_feedback) {
   int64_t now_ms = clock_->TimeInMilliseconds();
 
+  const size_t packet_size = send_side_bwe_with_overhead_
+                                 ? packet_feedback.payload_size +
+                                       packet_feedback.rtp_headers_size +
+                                       packet_feedback.transport_headers_size
+                                 : packet_feedback.payload_size;
   receiver_incoming_bitrate_.Update(packet_feedback.arrival_time_ms,
-                                    packet_feedback.payload_size);
+                                    packet_size);
   Result result;
   // Reset if the stream has timed out.
   if (last_seen_packet_ms_ == -1 ||
       now_ms - last_seen_packet_ms_ > kStreamTimeOutMs) {
     inter_arrival_.reset(
         new InterArrival((kTimestampGroupLengthMs << kInterArrivalShift) / 1000,
                          kTimestampToMs, true));
     trendline_estimator_.reset(new TrendlineEstimator(
         trendline_window_size_, trendline_smoothing_coeff_,
         trendline_threshold_gain_));
   }
   last_seen_packet_ms_ = now_ms;
 
   uint32_t send_time_24bits =
       static_cast<uint32_t>(
           ((static_cast<uint64_t>(packet_feedback.send_time_ms)
             << kAbsSendTimeFraction) +
            500) /
           1000) &
       0x00FFFFFF;
   // Shift up send time to use the full 32 bits that inter_arrival works with,
   // so wrapping works properly.
   uint32_t timestamp = send_time_24bits << kAbsSendTimeInterArrivalUpshift;
 
   uint32_t ts_delta = 0;
   int64_t t_delta = 0;
   int size_delta = 0;
   if (inter_arrival_->ComputeDeltas(timestamp, packet_feedback.arrival_time_ms,
-                                    now_ms, packet_feedback.payload_size,
-                                    &ts_delta, &t_delta, &size_delta)) {
+                                    now_ms, packet_size, &ts_delta, &t_delta,
+                                    &size_delta)) {
     double ts_delta_ms = (1000.0 * ts_delta) / (1 << kInterArrivalShift);
     trendline_estimator_->Update(t_delta, ts_delta_ms,
                                  packet_feedback.arrival_time_ms);
     detector_.Detect(trendline_estimator_->trendline_slope(), ts_delta_ms,
                      trendline_estimator_->num_of_deltas(),
                      packet_feedback.arrival_time_ms);
   }
   if (packet_feedback.pacing_info.probe_cluster_id !=
       PacedPacketInfo::kNotAProbe) {
     probe_bitrate_estimator_.HandleProbeAndEstimateBitrate(packet_feedback);
@@ skipping 78 matching lines @@
 void DelayBasedBwe::SetMinBitrate(int min_bitrate_bps) {
   // Called from both the configuration thread and the network thread. Shouldn't
   // be called from the network thread in the future.
   rate_control_.SetMinBitrate(min_bitrate_bps);
 }
 
 int64_t DelayBasedBwe::GetExpectedBwePeriodMs() const {
   return rate_control_.GetExpectedBandwidthPeriodMs();
 }
 }  // namespace webrtc