Remove unused metric in overuse detector.

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.
  */
 
@@ skipping 235 matching lines @@
   void Reset() { frame_times_.clear(); }
   int NumFrames() const { return static_cast<int>(frame_times_.size()); }
   int last_processing_time_ms() const { return last_processing_time_ms_; }
 
  private:
   // Captured frames mapped by the capture time.
   std::map<int64_t, int64_t> frame_times_;
   int last_processing_time_ms_;
 };
 
-// TODO(asapersson): Remove this class. Not used.
-// Class for calculating the capture queue delay change.
-class OveruseFrameDetector::CaptureQueueDelay {
- public:
-  CaptureQueueDelay()
-      : kWeightFactor(0.5f),
-        delay_ms_(0),
-        filtered_delay_ms_per_s_(new rtc::ExpFilter(kWeightFactor)) {
-    filtered_delay_ms_per_s_->Apply(1.0f, 0.0f);
-  }
-  ~CaptureQueueDelay() {}
-
-  void FrameCaptured(int64_t now) {
-    const size_t kMaxSize = 200;
-    if (frames_.size() > kMaxSize) {
-      frames_.pop_front();
-    }
-    frames_.push_back(now);
-  }
-
-  void FrameProcessingStarted(int64_t now) {
-    if (frames_.empty()) {
-      return;
-    }
-    delay_ms_ = now - frames_.front();
-    frames_.pop_front();
-  }
-
-  void CalculateDelayChange(int64_t diff_last_sample_ms) {
-    if (diff_last_sample_ms <= 0) {
-      return;
-    }
-    float exp = static_cast<float>(diff_last_sample_ms) / kProcessIntervalMs;
-    exp = std::min(exp, kMaxExp);
-    filtered_delay_ms_per_s_->Apply(exp,
-                                    delay_ms_ * 1000.0f / diff_last_sample_ms);
-    ClearFrames();
-  }
-
-  void ClearFrames() {
-    frames_.clear();
-  }
-
-  int delay_ms() const {
-    return delay_ms_;
-  }
-
-  int Value() const {
-    return static_cast<int>(filtered_delay_ms_per_s_->filtered() + 0.5);
-  }
-
- private:
-  const float kWeightFactor;
-  std::list<int64_t> frames_;
-  int delay_ms_;
-  rtc::scoped_ptr<rtc::ExpFilter> filtered_delay_ms_per_s_;
-};
 
 OveruseFrameDetector::OveruseFrameDetector(
     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()),
       usage_(new SendProcessingUsage(options)),
       frame_queue_(new FrameQueue()),
-      last_sample_time_ms_(0),
-      capture_queue_delay_(new CaptureQueueDelay()) {
+      last_sample_time_ms_(0) {
   DCHECK(metrics_observer != nullptr);
   // Make sure stats are initially up-to-date. This simplifies unit testing
   // since we don't have to trigger an update using one of the methods which
   // would also alter the overuse state.
   UpdateCpuOveruseMetrics();
   processing_thread_.DetachFromThread();
 }
 
 OveruseFrameDetector::~OveruseFrameDetector() {
 }
 
-int OveruseFrameDetector::CaptureQueueDelayMsPerS() const {
-  rtc::CritScope cs(&crit_);
-  return capture_queue_delay_->delay_ms();
-}
-
 int OveruseFrameDetector::LastProcessingTimeMs() const {
   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_.capture_queue_delay_ms_per_s = capture_queue_delay_->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();
-  capture_queue_delay_->ClearFrames();
   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) {
     capture_deltas_.AddSample(now - last_capture_time_);
     usage_->AddCaptureSample(now - last_capture_time_);
   }
   last_capture_time_ = now;
 
-  capture_queue_delay_->FrameCaptured(now);
-
   if (options_.enable_extended_processing_usage) {
     frame_queue_->Start(capture_time_ms, now);
   }
   UpdateCpuOveruseMetrics();
 }
 
-void OveruseFrameDetector::FrameProcessingStarted() {
-  rtc::CritScope cs(&crit_);
-  capture_queue_delay_->FrameProcessingStarted(clock_->TimeInMilliseconds());
-}
-
 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;
 
   if (!options_.enable_extended_processing_usage) {
@@ skipping 26 matching lines @@
 
 int32_t OveruseFrameDetector::Process() {
   DCHECK(processing_thread_.CalledOnValidThread());
 
   int64_t now = clock_->TimeInMilliseconds();
 
   // Used to protect against Process() being called too often.
   if (now < next_process_time_)
     return 0;
 
-  int64_t diff_ms = now - next_process_time_ + kProcessIntervalMs;
   next_process_time_ = now + kProcessIntervalMs;
 
   rtc::CritScope cs(&crit_);
   ++num_process_times_;
 
-  capture_queue_delay_->CalculateDelayChange(diff_ms);
-  UpdateCpuOveruseMetrics();
-
   if (num_process_times_ <= options_.min_process_count) {
     return 0;
   }
 
   if (IsOverusing()) {
     // If the last thing we did was going up, and now have to back down, we need
     // to check if this peak was short. If so we should back off to avoid going
     // back and forth between this load, the system doesn't seem to handle it.
     bool check_for_backoff = last_rampup_time_ > last_overuse_time_;
     if (check_for_backoff) {
@@ skipping 60 matching lines @@
   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) {
     underusing = usage_->Value() < options_.low_encode_usage_threshold_percent;
   }
   return underusing;
 }
 }  // namespace webrtc