Set overuse detector max frame interval based on target frame rate.

webrtc/video/overuse_frame_detector.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.
  */
 
@@ skipping 31 matching lines @@
 // Delay between rampup attempts. Initially uses standard, scales up to max.
 const int kStandardRampUpDelayMs = 40 * 1000;
 const int kMaxRampUpDelayMs = 240 * 1000;
 // Expontential back-off factor, to prevent annoying up-down behaviour.
 const double kRampUpBackoffFactor = 2.0;
 
 // Max number of overuses detected before always applying the rampup delay.
 const int kMaxOverusesBeforeApplyRampupDelay = 4;
 
 // The maximum exponent to use in VCMExpFilter.
-const float kSampleDiffMs = 33.0f;
 const float kMaxExp = 7.0f;
+// Default value used before first reconfiguration.
+const int kDefaultFrameRate = 30;
+// Default sample diff, default frame rate.
+const float kDefaultSampleDiffMs = 1000.0f / kDefaultFrameRate;
+// A factor applied to the sample diff on OnTargetFramerateUpdated to determine
+// a max limit for the sample diff. For instance, with a framerate of 30fps,
+// the sample diff is capped to (1000 / 30) * 1.35 = 45ms. This prevents
+// triggering too soon if there are individual very large outliers.
+const float kMaxSampleDiffMarginFactor = 1.35f;
+// Minimum framerate allowed for usage calculation. This prevents crazy long
+// encode times from being accepted if the frame rate happens to be low.
+const int kMinFramerate = 7;
+const int kMaxFramerate = 30;
 
 const auto kScaleReasonCpu = AdaptationObserverInterface::AdaptReason::kCpu;
 }  // namespace
 
 CpuOveruseOptions::CpuOveruseOptions()
     : high_encode_usage_threshold_percent(85),
       frame_timeout_interval_ms(1500),
       min_frame_samples(120),
       min_process_count(3),
       high_threshold_consecutive_count(2) {
@@ skipping 42 matching lines @@
 
 // Class for calculating the processing usage on the send-side (the average
 // processing time of a frame divided by the average time difference between
 // captured frames).
 class OveruseFrameDetector::SendProcessingUsage {
  public:
   explicit SendProcessingUsage(const CpuOveruseOptions& options)
       : kWeightFactorFrameDiff(0.998f),
         kWeightFactorProcessing(0.995f),
         kInitialSampleDiffMs(40.0f),
-        kMaxSampleDiffMs(45.0f),
         count_(0),
         options_(options),
+        max_sample_diff_ms_(kDefaultSampleDiffMs * kMaxSampleDiffMarginFactor),
         filtered_processing_ms_(new rtc::ExpFilter(kWeightFactorProcessing)),
         filtered_frame_diff_ms_(new rtc::ExpFilter(kWeightFactorFrameDiff)) {
     Reset();
   }
   virtual ~SendProcessingUsage() {}
 
   void Reset() {
     count_ = 0;
+    max_sample_diff_ms_ = kDefaultSampleDiffMs * kMaxSampleDiffMarginFactor;
     filtered_frame_diff_ms_->Reset(kWeightFactorFrameDiff);
     filtered_frame_diff_ms_->Apply(1.0f, kInitialSampleDiffMs);
     filtered_processing_ms_->Reset(kWeightFactorProcessing);
     filtered_processing_ms_->Apply(1.0f, InitialProcessingMs());
   }
 
+  void SetMaxSampleDiffMs(float diff_ms) { max_sample_diff_ms_ = diff_ms; }
+
   void AddCaptureSample(float sample_ms) {
-    float exp = sample_ms / kSampleDiffMs;
+    float exp = sample_ms / kDefaultSampleDiffMs;
     exp = std::min(exp, kMaxExp);
     filtered_frame_diff_ms_->Apply(exp, sample_ms);
   }
 
   void AddSample(float processing_ms, int64_t diff_last_sample_ms) {
     ++count_;
-    float exp = diff_last_sample_ms / kSampleDiffMs;
+    float exp = diff_last_sample_ms / kDefaultSampleDiffMs;
     exp = std::min(exp, kMaxExp);
     filtered_processing_ms_->Apply(exp, processing_ms);
   }
 
   virtual int Value() {
     if (count_ < static_cast<uint32_t>(options_.min_frame_samples)) {
       return static_cast<int>(InitialUsageInPercent() + 0.5f);
     }
     float frame_diff_ms = std::max(filtered_frame_diff_ms_->filtered(), 1.0f);
-    frame_diff_ms = std::min(frame_diff_ms, kMaxSampleDiffMs);
+    frame_diff_ms = std::min(frame_diff_ms, max_sample_diff_ms_);
     float encode_usage_percent =
         100.0f * filtered_processing_ms_->filtered() / frame_diff_ms;
     return static_cast<int>(encode_usage_percent + 0.5);
   }
 
  private:
   float InitialUsageInPercent() const {
     // Start in between the underuse and overuse threshold.
     return (options_.low_encode_usage_threshold_percent +
             options_.high_encode_usage_threshold_percent) / 2.0f;
   }
 
   float InitialProcessingMs() const {
     return InitialUsageInPercent() * kInitialSampleDiffMs / 100;
   }
 
   const float kWeightFactorFrameDiff;
   const float kWeightFactorProcessing;
   const float kInitialSampleDiffMs;
-  const float kMaxSampleDiffMs;
   uint64_t count_;
   const CpuOveruseOptions options_;
+  float max_sample_diff_ms_;
   std::unique_ptr<rtc::ExpFilter> filtered_processing_ms_;
   std::unique_ptr<rtc::ExpFilter> filtered_frame_diff_ms_;
 };
 
 // Class used for manual testing of overuse, enabled via field trial flag.
 class OveruseFrameDetector::OverdoseInjector
     : public OveruseFrameDetector::SendProcessingUsage {
  public:
   OverdoseInjector(const CpuOveruseOptions& options,
                    int64_t normal_period_ms,
@@ skipping 140 matching lines @@
     : check_overuse_task_(nullptr),
       options_(options),
       observer_(observer),
       encoder_timing_(encoder_timing),
       metrics_observer_(metrics_observer),
       num_process_times_(0),
       // TODO(nisse): Use rtc::Optional
       last_capture_time_us_(-1),
       last_processed_capture_time_us_(-1),
       num_pixels_(0),
+      max_framerate_(kDefaultFrameRate),
       last_overuse_time_ms_(-1),
       checks_above_threshold_(0),
       num_overuse_detections_(0),
       last_rampup_time_ms_(-1),
       in_quick_rampup_(false),
       current_rampup_delay_ms_(kStandardRampUpDelayMs),
       usage_(CreateSendProcessingUsage(options)) {
   task_checker_.Detach();
 }
 
@@ skipping 31 matching lines @@
 
 bool OveruseFrameDetector::FrameTimeoutDetected(int64_t now_us) const {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
   if (last_capture_time_us_ == -1)
     return false;
   return (now_us - last_capture_time_us_) >
       options_.frame_timeout_interval_ms * rtc::kNumMicrosecsPerMillisec;
 }
 
 void OveruseFrameDetector::ResetAll(int num_pixels) {
+  // Reset state, as a result resolution being changed. Do not however change
+  // the current frame rate back to the default.
   RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
   num_pixels_ = num_pixels;
   usage_->Reset();
   frame_timing_.clear();
   last_capture_time_us_ = -1;
   last_processed_capture_time_us_ = -1;
   num_process_times_ = 0;
   metrics_ = rtc::Optional<CpuOveruseMetrics>();
+  OnTargetFramerateUpdated(max_framerate_);
+}
+
+void OveruseFrameDetector::OnTargetFramerateUpdated(int framerate_fps) {
+  RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
+  RTC_DCHECK_GE(framerate_fps, 0);
+  max_framerate_ = std::min(kMaxFramerate, framerate_fps);
+  usage_->SetMaxSampleDiffMs((1000 / std::max(kMinFramerate, max_framerate_)) *
+                             kMaxSampleDiffMarginFactor);
 }
 
 void OveruseFrameDetector::FrameCaptured(const VideoFrame& frame,
                                          int64_t time_when_first_seen_us) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
 
   if (FrameSizeChanged(frame.width() * frame.height()) ||
       FrameTimeoutDetected(time_when_first_seen_us)) {
     ResetAll(frame.width() * frame.height());
   }
@@ skipping 123 matching lines @@
                                         int64_t time_now) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
   int delay = in_quick_rampup_ ? kQuickRampUpDelayMs : current_rampup_delay_ms_;
   if (time_now < last_rampup_time_ms_ + delay)
     return false;
 
   return metrics.encode_usage_percent <
          options_.low_encode_usage_threshold_percent;
 }
 }  // namespace webrtc