Remove unused overuse detection metric (capture jitter).

webrtc/video_engine/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_engine/overuse_frame_detector.h"
 
 #include <assert.h>
 #include <math.h>
 
 #include <algorithm>
 #include <list>
 #include <map>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/exp_filter.h"
 #include "webrtc/system_wrappers/interface/clock.h"
 #include "webrtc/system_wrappers/interface/logging.h"
 
 namespace webrtc {
 
-// TODO(mflodman) Test different values for all of these to trigger correctly,
-// avoid fluctuations etc.
 namespace {
 const int64_t kProcessIntervalMs = 5000;
 
-// Weight factor to apply to the standard deviation.
-const float kWeightFactor = 0.997f;
-// Weight factor to apply to the average.
-const float kWeightFactorMean = 0.98f;
-
 // Delay between consecutive rampups. (Used for quick recovery.)
 const int kQuickRampUpDelayMs = 10 * 1000;
 // 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;
 
 }  // namespace
 
-// TODO(asapersson): Remove this class. Not used.
-Statistics::Statistics(const CpuOveruseOptions& options)
-    : sum_(0.0),
-      count_(0),
-      options_(options),
-      filtered_samples_(new rtc::ExpFilter(kWeightFactorMean)),
-      filtered_variance_(new rtc::ExpFilter(kWeightFactor)) {
-  Reset();
-}
-
-void Statistics::Reset() {
-  sum_ =  0.0;
-  count_ = 0;
-  filtered_variance_->Reset(kWeightFactor);
-  filtered_variance_->Apply(1.0f, InitialVariance());
-}
-
-void Statistics::AddSample(float sample_ms) {
-  sum_ += sample_ms;
-  ++count_;
-
-  if (count_ < static_cast<uint32_t>(options_.min_frame_samples)) {
-    // Initialize filtered samples.
-    filtered_samples_->Reset(kWeightFactorMean);
-    filtered_samples_->Apply(1.0f, InitialMean());
-    return;
-  }
-
-  float exp = sample_ms / kSampleDiffMs;
-  exp = std::min(exp, kMaxExp);
-  filtered_samples_->Apply(exp, sample_ms);
-  filtered_variance_->Apply(exp, (sample_ms - filtered_samples_->filtered()) *
-                                 (sample_ms - filtered_samples_->filtered()));
-}
-
-float Statistics::InitialMean() const {
-  if (count_ == 0)
-    return 0.0;
-  return sum_ / count_;
-}
-
-float Statistics::InitialVariance() const {
-  // Start in between the underuse and overuse threshold.
-  float average_stddev = (options_.low_capture_jitter_threshold_ms +
-                          options_.high_capture_jitter_threshold_ms) / 2.0f;
-  return average_stddev * average_stddev;
-}
-
-float Statistics::Mean() const { return filtered_samples_->filtered(); }
-
-float Statistics::StdDev() const {
-  return sqrt(std::max(filtered_variance_->filtered(), 0.0f));
-}
-
-uint64_t Statistics::Count() const { return count_; }
-
-
 // Class for calculating the average encode time.
 class OveruseFrameDetector::EncodeTimeAvg {
  public:
   EncodeTimeAvg()
       : kWeightFactor(0.5f),
         kInitialAvgEncodeTimeMs(5.0f),
         filtered_encode_time_ms_(new rtc::ExpFilter(kWeightFactor)) {
     filtered_encode_time_ms_->Apply(1.0f, kInitialAvgEncodeTimeMs);
   }
   ~EncodeTimeAvg() {}
@@ skipping 137 matching lines @@
     Clock* clock,
     const CpuOveruseOptions& options,
     CpuOveruseObserver* observer,
     CpuOveruseMetricsObserver* metrics_observer)
     : options_(options),
       observer_(observer),
       metrics_observer_(metrics_observer),
       clock_(clock),
       next_process_time_(clock_->TimeInMilliseconds()),
       num_process_times_(0),
-      capture_deltas_(options),
       last_capture_time_(0),
       last_overuse_time_(0),
       checks_above_threshold_(0),
       num_overuse_detections_(0),
       last_rampup_time_(0),
       in_quick_rampup_(false),
       current_rampup_delay_ms_(kStandardRampUpDelayMs),
       num_pixels_(0),
       last_encode_sample_ms_(0),
       encode_time_(new EncodeTimeAvg()),
@@ skipping 15 matching lines @@
   rtc::CritScope cs(&crit_);
   return frame_queue_->last_processing_time_ms();
 }
 
 int OveruseFrameDetector::FramesInQueue() const {
   rtc::CritScope cs(&crit_);
   return frame_queue_->NumFrames();
 }
 
 void OveruseFrameDetector::UpdateCpuOveruseMetrics() {
-  metrics_.capture_jitter_ms = static_cast<int>(capture_deltas_.StdDev() + 0.5);
   metrics_.avg_encode_time_ms = encode_time_->Value();
   metrics_.encode_usage_percent = usage_->Value();
 
   metrics_observer_->CpuOveruseMetricsUpdated(metrics_);
 }
 
 int64_t OveruseFrameDetector::TimeUntilNextProcess() {
   DCHECK(processing_thread_.CalledOnValidThread());
   return next_process_time_ - clock_->TimeInMilliseconds();
 }
 
 bool OveruseFrameDetector::FrameSizeChanged(int num_pixels) const {
   if (num_pixels != num_pixels_) {
     return true;
   }
   return false;
 }
 
 bool OveruseFrameDetector::FrameTimeoutDetected(int64_t now) const {
   if (last_capture_time_ == 0) {
     return false;
   }
   return (now - last_capture_time_) > options_.frame_timeout_interval_ms;
 }
 
 void OveruseFrameDetector::ResetAll(int num_pixels) {
   num_pixels_ = num_pixels;
-  capture_deltas_.Reset();
   usage_->Reset();
   frame_queue_->Reset();
   last_capture_time_ = 0;
   num_process_times_ = 0;
   UpdateCpuOveruseMetrics();
 }
 
 void OveruseFrameDetector::FrameCaptured(int width,
                                          int height,
                                          int64_t capture_time_ms) {
   rtc::CritScope cs(&crit_);
 
   int64_t now = clock_->TimeInMilliseconds();
   if (FrameSizeChanged(width * height) || FrameTimeoutDetected(now)) {
     ResetAll(width * height);
   }
 
   if (last_capture_time_ != 0) {

[pbos-webrtc, 2015/07/21 18:14:09]

remove {}s

[åsapersson, 2015/07/22 05:50:24]

Done.

-    capture_deltas_.AddSample(now - last_capture_time_);
     usage_->AddCaptureSample(now - last_capture_time_);
   }
   last_capture_time_ = now;
 
   if (options_.enable_extended_processing_usage) {
     frame_queue_->Start(capture_time_ms, now);
   }
-  UpdateCpuOveruseMetrics();
 }
 
 void OveruseFrameDetector::FrameEncoded(int encode_time_ms) {
   rtc::CritScope cs(&crit_);
   int64_t now = clock_->TimeInMilliseconds();
   if (last_encode_sample_ms_ != 0) {
     int64_t diff_ms = now - last_encode_sample_ms_;
     encode_time_->AddSample(encode_time_ms, diff_ms);
   }
   last_encode_sample_ms_ = now;
@@ skipping 72 matching lines @@
   } else if (IsUnderusing(now)) {
     last_rampup_time_ = now;
     in_quick_rampup_ = true;
 
     if (observer_ != NULL)
       observer_->NormalUsage();
   }
 
   int rampup_delay =
       in_quick_rampup_ ? kQuickRampUpDelayMs : current_rampup_delay_ms_;
-  LOG(LS_VERBOSE) << " Frame stats: capture avg: " << capture_deltas_.Mean()
-                  << " capture stddev " << capture_deltas_.StdDev()
-                  << " encode usage " << usage_->Value()
+  LOG(LS_VERBOSE) << " Frame stats: encode usage: " << usage_->Value()
                   << " overuse detections " << num_overuse_detections_
                   << " rampup delay " << rampup_delay;
 
   return 0;
 }
 
 bool OveruseFrameDetector::IsOverusing() {
   bool overusing = false;
-  if (options_.enable_capture_jitter_method) {
-    overusing = capture_deltas_.StdDev() >=
-        options_.high_capture_jitter_threshold_ms;
-  } else if (options_.enable_encode_usage_method) {
+  if (options_.enable_encode_usage_method) {

[pbos-webrtc, 2015/07/21 18:14:09]

remove {}s

[åsapersson, 2015/07/22 05:50:24]

Done.

     overusing = usage_->Value() >= options_.high_encode_usage_threshold_percent;
   }
 
   if (overusing) {
     ++checks_above_threshold_;
   } else {
     checks_above_threshold_ = 0;
   }
   return checks_above_threshold_ >= options_.high_threshold_consecutive_count;
 }
 
 bool OveruseFrameDetector::IsUnderusing(int64_t time_now) {
   int delay = in_quick_rampup_ ? kQuickRampUpDelayMs : current_rampup_delay_ms_;
   if (time_now < last_rampup_time_ + delay)
     return false;
 
   bool underusing = false;
-  if (options_.enable_capture_jitter_method) {
-    underusing = capture_deltas_.StdDev() <
-        options_.low_capture_jitter_threshold_ms;
-  } else if (options_.enable_encode_usage_method) {
+  if (options_.enable_encode_usage_method) {

[pbos-webrtc, 2015/07/21 18:14:09]

remove {}s

[åsapersson, 2015/07/22 05:50:24]

Done.

     underusing = usage_->Value() < options_.low_encode_usage_threshold_percent;
   }
   return underusing;
 }
 }  // namespace webrtc