Merge UpdateBandwidthEstimate with Update in AimdRateControl.

webrtc/modules/remote_bitrate_estimator/aimd_rate_control.cc

 /*
  *  Copyright (c) 2014 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 17 matching lines @@
 
 AimdRateControl::AimdRateControl()
     : min_configured_bitrate_bps_(congestion_controller::GetMinBitrateBps()),
       max_configured_bitrate_bps_(30000000),
       current_bitrate_bps_(max_configured_bitrate_bps_),
       avg_max_bitrate_kbps_(-1.0f),
       var_max_bitrate_kbps_(0.4f),
       rate_control_state_(kRcHold),
       rate_control_region_(kRcMaxUnknown),
       time_last_bitrate_change_(-1),
-      current_input_(kBwNormal, rtc::Optional<uint32_t>(), 1.0),
-      updated_(false),
       time_first_incoming_estimate_(-1),
       bitrate_is_initialized_(false),
       beta_(0.85f),
       rtt_(kDefaultRttMs),
       in_experiment_(!AdaptiveThresholdExperimentIsDisabled()) {}
 
 AimdRateControl::~AimdRateControl() {}
 
 void AimdRateControl::SetStartBitrate(int start_bitrate_bps) {
   current_bitrate_bps_ = start_bitrate_bps;
@@ skipping 33 matching lines @@
     const uint32_t threshold = static_cast<uint32_t> (0.5 * LatestEstimate());
     return incoming_bitrate_bps < threshold;
   }
   return false;
 }
 
 uint32_t AimdRateControl::LatestEstimate() const {
   return current_bitrate_bps_;
 }
 
-uint32_t AimdRateControl::UpdateBandwidthEstimate(int64_t now_ms) {
-  current_bitrate_bps_ = ChangeBitrate(
-      current_bitrate_bps_,
-      current_input_.incoming_bitrate.value_or(current_bitrate_bps_), now_ms);
-  return current_bitrate_bps_;
-}
-
 void AimdRateControl::SetRtt(int64_t rtt) {
   rtt_ = rtt;
 }
 
-void AimdRateControl::Update(const RateControlInput* input, int64_t now_ms) {
+uint32_t AimdRateControl::Update(const RateControlInput* input,
+                                 int64_t now_ms) {
   RTC_CHECK(input);
 
   // Set the initial bit rate value to what we're receiving the first half
   // second.
   if (!bitrate_is_initialized_) {
     const int64_t kInitializationTimeMs = 5000;
     RTC_DCHECK_LE(kBitrateWindowMs, kInitializationTimeMs);
     if (time_first_incoming_estimate_ < 0) {
       if (input->incoming_bitrate)
         time_first_incoming_estimate_ = now_ms;
     } else if (now_ms - time_first_incoming_estimate_ > kInitializationTimeMs &&
                input->incoming_bitrate) {
       current_bitrate_bps_ = *input->incoming_bitrate;
       bitrate_is_initialized_ = true;
     }
   }
 
-  if (updated_ && current_input_.bw_state == kBwOverusing) {
-    // Only update delay factor and incoming bit rate. We always want to react
-    // on an over-use.
-    current_input_.noise_var = input->noise_var;
-    current_input_.incoming_bitrate = input->incoming_bitrate;
-  } else {
-    updated_ = true;
-    current_input_ = *input;
-  }
+  current_bitrate_bps_ = ChangeBitrate(current_bitrate_bps_, *input, now_ms);
+  return current_bitrate_bps_;
 }
 
 void AimdRateControl::SetEstimate(int bitrate_bps, int64_t now_ms) {
-  updated_ = true;
   bitrate_is_initialized_ = true;
   current_bitrate_bps_ = ClampBitrate(bitrate_bps, bitrate_bps);
   time_last_bitrate_change_ = now_ms;
 }
 
 int AimdRateControl::GetNearMaxIncreaseRateBps() const {
   RTC_DCHECK_GT(current_bitrate_bps_, 0);
   double bits_per_frame = static_cast<double>(current_bitrate_bps_) / 30.0;
   double packets_per_frame = std::ceil(bits_per_frame / (8.0 * 1200.0));
   double avg_packet_size_bits = bits_per_frame / packets_per_frame;
   // Approximate the over-use estimator delay to 100 ms.
   const int64_t response_time = in_experiment_ ? (rtt_ + 100) * 2 : rtt_ + 100;
 
   constexpr double kMinIncreaseRateBps = 4000;
   return static_cast<int>(std::max(
       kMinIncreaseRateBps, (avg_packet_size_bits * 1000) / response_time));
 }
 
 rtc::Optional<int> AimdRateControl::GetLastBitrateDecreaseBps() const {
   return last_decrease_;
 }
 
 uint32_t AimdRateControl::ChangeBitrate(uint32_t new_bitrate_bps,
-                                        uint32_t incoming_bitrate_bps,
+                                        const RateControlInput& input,
                                         int64_t now_ms) {
-  if (!updated_) {
-    return current_bitrate_bps_;
-  }
+  uint32_t incoming_bitrate_bps =
+      input.incoming_bitrate.value_or(current_bitrate_bps_);
+
   // An over-use should always trigger us to reduce the bitrate, even though
   // we have not yet established our first estimate. By acting on the over-use,
   // we will end up with a valid estimate.
-  if (!bitrate_is_initialized_ && current_input_.bw_state != kBwOverusing)
+  if (!bitrate_is_initialized_ && input.bw_state != kBwOverusing)
     return current_bitrate_bps_;
-  updated_ = false;
-  ChangeState(current_input_, now_ms);
+
+  ChangeState(input, now_ms);
   // Calculated here because it's used in multiple places.
   const float incoming_bitrate_kbps = incoming_bitrate_bps / 1000.0f;
   // Calculate the max bit rate std dev given the normalized
   // variance and the current incoming bit rate.
   const float std_max_bit_rate = sqrt(var_max_bitrate_kbps_ *
                                       avg_max_bitrate_kbps_);
   switch (rate_control_state_) {
     case kRcHold:
       break;
 
@@ skipping 37 matching lines @@
         last_decrease_ =
             rtc::Optional<int>(current_bitrate_bps_ - new_bitrate_bps);
       }
       if (incoming_bitrate_kbps <
           avg_max_bitrate_kbps_ - 3 * std_max_bit_rate) {
         avg_max_bitrate_kbps_ = -1.0f;
       }
 
       UpdateMaxBitRateEstimate(incoming_bitrate_kbps);
       // Stay on hold until the pipes are cleared.
-      ChangeState(kRcHold);
+      rate_control_state_ = kRcHold;
       time_last_bitrate_change_ = now_ms;
       break;
 
     default:
       assert(false);
   }
   return ClampBitrate(new_bitrate_bps, incoming_bitrate_bps);
 }
 
 uint32_t AimdRateControl::ClampBitrate(uint32_t new_bitrate_bps,
@@ skipping 49 matching lines @@
     var_max_bitrate_kbps_ = 0.4f;
   }
   // 2.5f ~= 35 kbit/s at 500 kbit/s
   if (var_max_bitrate_kbps_ > 2.5f) {
     var_max_bitrate_kbps_ = 2.5f;
   }
 }
 
 void AimdRateControl::ChangeState(const RateControlInput& input,
                                   int64_t now_ms) {
-  switch (current_input_.bw_state) {
+  switch (input.bw_state) {
     case kBwNormal:
       if (rate_control_state_ == kRcHold) {
         time_last_bitrate_change_ = now_ms;
-        ChangeState(kRcIncrease);
+        rate_control_state_ = kRcIncrease;
       }
       break;
     case kBwOverusing:
       if (rate_control_state_ != kRcDecrease) {
-        ChangeState(kRcDecrease);
+        rate_control_state_ = kRcDecrease;
       }
       break;
     case kBwUnderusing:
-      ChangeState(kRcHold);
+      rate_control_state_ = kRcHold;
       break;
     default:
       assert(false);
   }
 }
 
 void AimdRateControl::ChangeRegion(RateControlRegion region) {
   rate_control_region_ = region;
 }
 
-void AimdRateControl::ChangeState(RateControlState new_state) {
-  rate_control_state_ = new_state;
-}
 }  // namespace webrtc