Rate limit the low bandwidth / min bitrate warning to once every 10 seconds.

webrtc/modules/bitrate_controller/send_side_bandwidth_estimation.cc

 /*
  *  Copyright (c) 2012 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/modules/bitrate_controller/send_side_bandwidth_estimation.h"
 
 #include <cmath>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/system_wrappers/interface/field_trial.h"
 #include "webrtc/system_wrappers/interface/logging.h"
 #include "webrtc/system_wrappers/interface/metrics.h"
 
 namespace webrtc {
 namespace {
 const int64_t kBweIncreaseIntervalMs = 1000;
 const int64_t kBweDecreaseIntervalMs = 300;
 const int64_t kStartPhaseMs = 2000;
 const int64_t kBweConverganceTimeMs = 20000;
 const int kLimitNumPackets = 20;
 const int kAvgPacketSizeBytes = 1000;
 const int kDefaultMinBitrateBps = 10000;
 const int kDefaultMaxBitrateBps = 1000000000;
+const int64_t kLowBitrateLogPeriodMs = 10000;
 
 struct UmaRampUpMetric {
   const char* metric_name;
   int bitrate_kbps;
 };
 
 const UmaRampUpMetric kUmaRampupMetrics[] = {
     {"WebRTC.BWE.RampUpTimeTo500kbpsInMs", 500},
     {"WebRTC.BWE.RampUpTimeTo1000kbpsInMs", 1000},
     {"WebRTC.BWE.RampUpTimeTo2000kbpsInMs", 2000}};
@@ skipping 24 matching lines @@
   return (static_cast<uint32_t>(X * 8));
 }
 }
 
 SendSideBandwidthEstimation::SendSideBandwidthEstimation()
     : accumulate_lost_packets_Q8_(0),
       accumulate_expected_packets_(0),
       bitrate_(0),
       min_bitrate_configured_(kDefaultMinBitrateBps),
       max_bitrate_configured_(kDefaultMaxBitrateBps),
+      last_low_bitrate_log_ms_(-1),
       time_last_receiver_block_ms_(0),
       last_fraction_loss_(0),
       last_round_trip_time_ms_(0),
       bwe_incoming_(0),
       time_last_decrease_ms_(0),
       first_report_time_ms_(-1),
       initially_lost_packets_(0),
       bitrate_at_2_seconds_kbps_(0),
       uma_update_state_(kNoUpdate),
       rampup_uma_stats_updated_(kNumUmaRampupMetrics, false) {
@@ skipping 27 matching lines @@
 }
 
 void SendSideBandwidthEstimation::CurrentEstimate(int* bitrate,
                                                   uint8_t* loss,
                                                   int64_t* rtt) const {
   *bitrate = bitrate_;
   *loss = last_fraction_loss_;
   *rtt = last_round_trip_time_ms_;
 }
 
-void SendSideBandwidthEstimation::UpdateReceiverEstimate(uint32_t bandwidth) {
+void SendSideBandwidthEstimation::UpdateReceiverEstimate(
+    int64_t now_ms, uint32_t bandwidth) {
   bwe_incoming_ = bandwidth;
-  bitrate_ = CapBitrateToThresholds(bitrate_);
+  bitrate_ = CapBitrateToThresholds(now_ms, bitrate_);
 }
 
 void SendSideBandwidthEstimation::UpdateReceiverBlock(uint8_t fraction_loss,
                                                       int64_t rtt,
                                                       int number_of_packets,
                                                       int64_t now_ms) {
   if (first_report_time_ms_ == -1)
     first_report_time_ms_ = now_ms;
 
   // Update RTT.
@@ skipping 59 matching lines @@
     RTC_HISTOGRAM_COUNTS(
         "WebRTC.BWE.InitialVsConvergedDiff", bitrate_diff_kbps, 0, 2000, 50);
   }
 }
 
 void SendSideBandwidthEstimation::UpdateEstimate(int64_t now_ms) {
   // We trust the REMB during the first 2 seconds if we haven't had any
   // packet loss reported, to allow startup bitrate probing.
   if (last_fraction_loss_ == 0 && IsInStartPhase(now_ms) &&
       bwe_incoming_ > bitrate_) {
-    bitrate_ = CapBitrateToThresholds(bwe_incoming_);
+    bitrate_ = CapBitrateToThresholds(now_ms, bwe_incoming_);
     min_bitrate_history_.clear();
     min_bitrate_history_.push_back(std::make_pair(now_ms, bitrate_));
     return;
   }
   UpdateMinHistory(now_ms);
   // Only start updating bitrate when receiving receiver blocks.
   if (time_last_receiver_block_ms_ != 0) {
     if (last_fraction_loss_ <= 5) {
       // Loss < 2%: Increase rate by 8% of the min bitrate in the last
       // kBweIncreaseIntervalMs.
@@ skipping 30 matching lines @@
             512.0);
 
         // Calculate what rate TFRC would apply in this situation and to not
         // reduce further than it.
         bitrate_ = std::max(
             bitrate_,
             CalcTfrcBps(last_round_trip_time_ms_, last_fraction_loss_));
       }
     }
   }
-  bitrate_ = CapBitrateToThresholds(bitrate_);
+  bitrate_ = CapBitrateToThresholds(now_ms, bitrate_);
 }
 
 bool SendSideBandwidthEstimation::IsInStartPhase(int64_t now_ms) const {
   return first_report_time_ms_ == -1 ||
          now_ms - first_report_time_ms_ < kStartPhaseMs;
 }
 
 void SendSideBandwidthEstimation::UpdateMinHistory(int64_t now_ms) {
   // Remove old data points from history.
   // Since history precision is in ms, add one so it is able to increase
   // bitrate if it is off by as little as 0.5ms.
   while (!min_bitrate_history_.empty() &&
          now_ms - min_bitrate_history_.front().first + 1 >
              kBweIncreaseIntervalMs) {
     min_bitrate_history_.pop_front();
   }
 
   // Typical minimum sliding-window algorithm: Pop values higher than current
   // bitrate before pushing it.
   while (!min_bitrate_history_.empty() &&
          bitrate_ <= min_bitrate_history_.back().second) {
     min_bitrate_history_.pop_back();
   }
 
   min_bitrate_history_.push_back(std::make_pair(now_ms, bitrate_));
 }
 
-uint32_t SendSideBandwidthEstimation::CapBitrateToThresholds(uint32_t bitrate) {
+uint32_t SendSideBandwidthEstimation::CapBitrateToThresholds(
+    int64_t now_ms, uint32_t bitrate) {
   if (bwe_incoming_ > 0 && bitrate > bwe_incoming_) {
     bitrate = bwe_incoming_;
   }
   if (bitrate > max_bitrate_configured_) {
     bitrate = max_bitrate_configured_;
   }
   if (bitrate < min_bitrate_configured_) {
-    LOG(LS_WARNING) << "Estimated available bandwidth " << bitrate / 1000
-                    << " kbps is below configured min bitrate "
-                    << min_bitrate_configured_ / 1000 << " kbps.";
+    if (last_low_bitrate_log_ms_ == -1 ||
+        now_ms - last_low_bitrate_log_ms_ > kLowBitrateLogPeriodMs) {
+      LOG(LS_WARNING) << "Estimated available bandwidth " << bitrate / 1000
+                      << " kbps is below configured min bitrate "
+                      << min_bitrate_configured_ / 1000 << " kbps.";
+      last_low_bitrate_log_ms_ = now_ms;
+    }
     bitrate = min_bitrate_configured_;
   }
   return bitrate;
 }
 }  // namespace webrtc