Add framerate to VideoSinkWants and ability to signal on overuse

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.
  */
 
 #include "webrtc/video/overuse_frame_detector.h"
 
 #include <assert.h>
 #include <math.h>
 
 #include <algorithm>
 #include <list>
 #include <map>
+#include <string>
+#include <utility>
 
 #include "webrtc/api/video/video_frame.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/numerics/exp_filter.h"
 #include "webrtc/common_video/include/frame_callback.h"
+#include "webrtc/system_wrappers/include/field_trial.h"
 
 #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
 #include <mach/mach.h>
 #endif  // defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
 
 namespace webrtc {
 
 namespace {
 const int64_t kCheckForOveruseIntervalMs = 5000;
 const int64_t kTimeToFirstCheckForOveruseMs = 100;
@@ skipping 74 matching lines @@
       : kWeightFactorFrameDiff(0.998f),
         kWeightFactorProcessing(0.995f),
         kInitialSampleDiffMs(40.0f),
         kMaxSampleDiffMs(45.0f),
         count_(0),
         options_(options),
         filtered_processing_ms_(new rtc::ExpFilter(kWeightFactorProcessing)),
         filtered_frame_diff_ms_(new rtc::ExpFilter(kWeightFactorFrameDiff)) {
     Reset();
   }
-  ~SendProcessingUsage() {}
+  virtual ~SendProcessingUsage() {}
 
   void Reset() {
     count_ = 0;
     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 AddCaptureSample(float sample_ms) {
     float exp = sample_ms / kSampleDiffMs;
     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;
     exp = std::min(exp, kMaxExp);
     filtered_processing_ms_->Apply(exp, processing_ms);
   }
 
-  int Value() const {
+  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);
     float encode_usage_percent =
         100.0f * filtered_processing_ms_->filtered() / frame_diff_ms;
     return static_cast<int>(encode_usage_percent + 0.5);
   }
 
@@ skipping 11 matching lines @@
   const float kWeightFactorFrameDiff;
   const float kWeightFactorProcessing;
   const float kInitialSampleDiffMs;
   const float kMaxSampleDiffMs;
   uint64_t count_;
   const CpuOveruseOptions options_;
   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 overuse_period_ms,
+                   int64_t normal_period_ms)
+      : OveruseFrameDetector::SendProcessingUsage(options),
+        overuse_period_ms_(overuse_period_ms),
+        normal_period_ms_(normal_period_ms),
+        is_overusing_(false),
+        last_toggling_ms_(-1) {
+    RTC_DCHECK_GT(overuse_period_ms, 0);
+    RTC_DCHECK_GT(normal_period_ms, 0);
+    LOG(LS_INFO) << "Simulating overuse with intervals " << normal_period_ms
+                 << "ms normal mode, " << overuse_period_ms
+                 << "ms overuse mode.";
+  }
+
+  ~OverdoseInjector() override {}
+
+  int Value() override {
+    int64_t now_ms = rtc::TimeMillis();
+    if (last_toggling_ms_ == -1) {
+      last_toggling_ms_ = now_ms;
+    } else {
+      int64_t toggle_time_ms =
+          last_toggling_ms_ +
+          (is_overusing_ ? overuse_period_ms_ : normal_period_ms_);
+      if (now_ms > toggle_time_ms) {
+        is_overusing_ = !is_overusing_;
+        last_toggling_ms_ = now_ms;
+        if (is_overusing_) {
+          LOG(LS_INFO) << "Simulating CPU overuse.";
+        } else {
+          LOG(LS_INFO) << "Disabling CPU overuse simulation.";
+        }
+      }
+    }
+
+    if (is_overusing_)
+      return 250;  // 250% should be enough for anyone.
+
+    return SendProcessingUsage::Value();
+  }
+
+ private:
+  const int64_t overuse_period_ms_;
+  const int64_t normal_period_ms_;
+  bool is_overusing_;
+  int64_t last_toggling_ms_;
+};
+
+std::unique_ptr<OveruseFrameDetector::SendProcessingUsage>
+OveruseFrameDetector::CreateSendProcessingUsage(
+    const CpuOveruseOptions& options) {
+  std::unique_ptr<SendProcessingUsage> instance;
+  std::string toggling_interval =
+      field_trial::FindFullName("WebRTC-ForceSimulatedOveruseIntervalMs");
+  if (!toggling_interval.empty()) {
+    int overuse_period_ms = 0;
+    int normal_period_ms = 0;
+    if (sscanf(toggling_interval.c_str(), "%d-%d", &overuse_period_ms,
+               &normal_period_ms) == 2) {
+      if (overuse_period_ms > 0 && normal_period_ms > 0) {
+        instance.reset(
+            new OverdoseInjector(options, overuse_period_ms, normal_period_ms));
+      } else {
+        LOG(LS_WARNING) << "Invalid (non-positive) overuse / normal periods: "
+                        << overuse_period_ms << " / " << normal_period_ms;
+      }
+    } else {
+      LOG(LS_WARNING) << "Malformed toggling interval: " << toggling_interval;
+    }
+  }
+
+  if (!instance) {
+    // No valid overuse simulation parameters set, use normal usage class.
+    instance.reset(new SendProcessingUsage(options));
+  }
+
+  return instance;
+}
+
 class OveruseFrameDetector::CheckOveruseTask : public rtc::QueuedTask {
  public:
   explicit CheckOveruseTask(OveruseFrameDetector* overuse_detector)
       : overuse_detector_(overuse_detector) {
     rtc::TaskQueue::Current()->PostDelayedTask(
         std::unique_ptr<rtc::QueuedTask>(this), kTimeToFirstCheckForOveruseMs);
   }
 
   void Stop() {
     RTC_CHECK(task_checker_.CalledSequentially());
@@ skipping 31 matching lines @@
       // TODO(nisse): Use rtc::Optional
       last_capture_time_us_(-1),
       last_processed_capture_time_us_(-1),
       num_pixels_(0),
       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_(new SendProcessingUsage(options)) {
+      usage_(CreateSendProcessingUsage(options)) {
   task_checker_.Detach();
 }
 
 OveruseFrameDetector::~OveruseFrameDetector() {
   RTC_DCHECK(!check_overuse_task_) << "StopCheckForOverUse must be called.";
 }
 
 void OveruseFrameDetector::StartCheckForOveruse() {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
   RTC_DCHECK(!check_overuse_task_);
@@ skipping 77 matching lines @@
   }
   // TODO(pbos): Handle the case/log errors when not finding the corresponding
   // frame (either very slow encoding or incorrect wrong timestamps returned
   // from the encoder).
   // This is currently the case for all frames on ChromeOS, so logging them
   // would be spammy, and triggering overuse would be wrong.
   // https://crbug.com/350106
   while (!frame_timing_.empty()) {
     FrameTiming timing = frame_timing_.front();
     if (time_sent_in_us - timing.capture_us <
-        kEncodingTimeMeasureWindowMs * rtc::kNumMicrosecsPerMillisec)
+        kEncodingTimeMeasureWindowMs * rtc::kNumMicrosecsPerMillisec) {
       break;
+    }
     if (timing.last_send_us != -1) {
       int encode_duration_us =
           static_cast<int>(timing.last_send_us - timing.capture_us);
       if (encoder_timing_) {
         // TODO(nisse): Update encoder_timing_ to also use us units.
         encoder_timing_->OnEncodeTiming(timing.capture_time_us /
                                         rtc::kNumMicrosecsPerMillisec,
                                         encode_duration_us /
                                         rtc::kNumMicrosecsPerMillisec);
       }
@@ skipping 54 matching lines @@
       in_quick_rampup_ ? kQuickRampUpDelayMs : current_rampup_delay_ms_;
 
   LOG(LS_VERBOSE) << " Frame stats: "
                   << " encode usage " << metrics_->encode_usage_percent
                   << " overuse detections " << num_overuse_detections_
                   << " rampup delay " << rampup_delay;
 }
 
 bool OveruseFrameDetector::IsOverusing(const CpuOveruseMetrics& metrics) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
+
   if (metrics.encode_usage_percent >=
       options_.high_encode_usage_threshold_percent) {
     ++checks_above_threshold_;
   } else {
     checks_above_threshold_ = 0;
   }
   return checks_above_threshold_ >= options_.high_threshold_consecutive_count;
 }
 
 bool OveruseFrameDetector::IsUnderusing(const CpuOveruseMetrics& metrics,
                                         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