Remove avg encode time from CpuOveruseMetric struct and use value from OnEncodedFrame instead.

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 26 matching lines @@
 
 // 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
 
-// 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() {}
-
-  void AddSample(float encode_time_ms, int64_t diff_last_sample_ms) {
-    float exp =  diff_last_sample_ms / kSampleDiffMs;
-    exp = std::min(exp, kMaxExp);
-    filtered_encode_time_ms_->Apply(exp, encode_time_ms);
-  }
-
-  int Value() const {
-    return static_cast<int>(filtered_encode_time_ms_->filtered() + 0.5);
-  }
-
- private:
-  const float kWeightFactor;
-  const float kInitialAvgEncodeTimeMs;
-  rtc::scoped_ptr<rtc::ExpFilter> filtered_encode_time_ms_;
-};
-
 // 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),
@@ skipping 118 matching lines @@
       num_process_times_(0),
       last_capture_time_(0),
       num_pixels_(0),
       next_process_time_(clock_->TimeInMilliseconds()),
       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),
-      last_encode_sample_ms_(0),
       last_sample_time_ms_(0),
-      encode_time_(new EncodeTimeAvg()),
       usage_(new SendProcessingUsage(options)),
       frame_queue_(new FrameQueue()) {
   RTC_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::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_.avg_encode_time_ms = encode_time_->Value();
   metrics_.encode_usage_percent = usage_->Value();
 
   metrics_observer_->CpuOveruseMetricsUpdated(metrics_);
 }
 
 int64_t OveruseFrameDetector::TimeUntilNextProcess() {
   RTC_DCHECK(processing_thread_.CalledOnValidThread());
   return next_process_time_ - clock_->TimeInMilliseconds();
 }
 
@@ skipping 34 matching lines @@
     usage_->AddCaptureSample(now - last_capture_time_);
 
   last_capture_time_ = now;
 
   if (options_.enable_extended_processing_usage) {
     frame_queue_->Start(capture_time_ms, now);
   }
 }
 
 void OveruseFrameDetector::FrameEncoded(int encode_time_ms) {
+  if (options_.enable_extended_processing_usage)
+    return;
+
   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) {
-    AddProcessingTime(encode_time_ms);
-  }
-  UpdateCpuOveruseMetrics();
+  AddProcessingTime(encode_time_ms);
 }
 
 void OveruseFrameDetector::FrameSent(int64_t capture_time_ms) {
+  if (!options_.enable_extended_processing_usage)
+    return;
+
   rtc::CritScope cs(&crit_);
-  if (!options_.enable_extended_processing_usage) {
-    return;
-  }
   int delay_ms = frame_queue_->End(capture_time_ms,
                                    clock_->TimeInMilliseconds());
   if (delay_ms > 0) {
     AddProcessingTime(delay_ms);
   }
-  UpdateCpuOveruseMetrics();
 }
 
 void OveruseFrameDetector::AddProcessingTime(int elapsed_ms) {
   int64_t now = clock_->TimeInMilliseconds();
   if (last_sample_time_ms_ != 0) {
     int64_t diff_ms = now - last_sample_time_ms_;
     usage_->AddSample(elapsed_ms, diff_ms);
   }
   last_sample_time_ms_ = now;
+  UpdateCpuOveruseMetrics();
 }
 
 int32_t OveruseFrameDetector::Process() {
   RTC_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;
@@ skipping 75 matching lines @@
     return false;
 
   bool underusing = false;
   if (options_.enable_encode_usage_method) {
     underusing = metrics.encode_usage_percent <
                  options_.low_encode_usage_threshold_percent;
   }
   return underusing;
 }
 }  // namespace webrtc