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 allows for user calculation. This prevents crazy long
+// encode times from being accepted if the frame rate happens to be low.
+const int kMinFramerate = 7;
 
 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),
+      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 39 matching lines @@
 
 void OveruseFrameDetector::ResetAll(int num_pixels) {
   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(framerate_);

[kthelgason, 2017/06/12 11:56:47]

is this supposed to be the last framerate and not the default framerate?
If yes then what's the point of this call?

[sprang_webrtc, 2017/06/14 08:39:16]

The state is reset if the resolution is changed, in which case we do not want to
change to the default framerate.

+}
+
+void OveruseFrameDetector::OnTargetFramerateUpdated(int framerate_fps) {
+  RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
+  RTC_DCHECK(framerate_fps > 0);
+  framerate_ = framerate_fps;

[åsapersson, 2017/06/13 12:15:09]

Add a max limit for framerate_ to 30? 

[sprang_webrtc, 2017/06/14 08:39:16]

Do we really want to? I think we at least support up to 60fps, right?
I'll add a dcheck here and maybe cap it in vie_encoder instead.

[åsapersson, 2017/06/14 10:50:26]

What if max is 60fps and input 30fps. Wouldn't max_sample_diff_ms_ be 22.5 ms
when running at 30fps?

[sprang_webrtc, 2017/06/14 13:41:28]

Yes, if the user configures a max framerate of 60fps, then the
max_sample_diff_ms_ will be 22.5ms regardless of input fps.
Running this code in chrome however it seems we are never fed the actual fps
capability of the capturer, but rather a default value of 60 is provided. This
is problematic.

I think maybe we may want to change the behavior to update the max framerate
based (reliable) measurements, if available, but that will complicate things
further.

Just capping to 30fps will not give a worse experience than the previous and
will still improve the low fps case. Let's just do that for now and revisit in
the future.

+  usage_->SetMaxSampleDiffMs((1000 / std::max(kMinFramerate, framerate_fps)) *
+                             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