Refactor QualityScaler and MovingAverage

webrtc/modules/video_coding/utility/quality_scaler.cc

 /*
  *  Copyright (c) 2014 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/modules/video_coding/utility/quality_scaler.h"
 
+#include <algorithm>
+
 namespace webrtc {
 
 namespace {
-static const int kMinFps = 5;
 // Threshold constant used until first downscale (to permit fast rampup).
 static const int kMeasureSecondsFastUpscale = 2;
 static const int kMeasureSecondsUpscale = 5;
 static const int kMeasureSecondsDownscale = 5;
 static const int kFramedropPercentThreshold = 60;
 // Min width/height to downscale to, set to not go below QVGA, but with some
 // margin to permit "almost-QVGA" resolutions, such as QCIF.
 static const int kMinDownscaleDimension = 140;
 // Initial resolutions corresponding to a bitrate. Aa bit above their actual
 // values to permit near-VGA and near-QVGA resolutions to use the same
@@ skipping 20 matching lines @@
 #endif
 
 QualityScaler::QualityScaler() : low_qp_threshold_(-1) {}
 
 void QualityScaler::Init(int low_qp_threshold,
                          int high_qp_threshold,
                          int initial_bitrate_kbps,
                          int width,
                          int height,
                          int fps) {
-  ClearSamples();
   low_qp_threshold_ = low_qp_threshold;
   high_qp_threshold_ = high_qp_threshold;
   downscale_shift_ = 0;
-  // Use a faster window for upscaling initially (but be more graceful later).
-  // This enables faster initial rampups without risking strong up-down
-  // behavior later.
-  measure_seconds_upscale_ = kMeasureSecondsFastUpscale;
+
+  fast_rampup_ = true;
+
+  ClearSamples();
+  ReportFramerate(fps);
+
   const int init_width = width;
   const int init_height = height;
   if (initial_bitrate_kbps > 0) {
     int init_num_pixels = width * height;
     if (initial_bitrate_kbps < kVgaBitrateThresholdKbps)
       init_num_pixels = kVgaNumPixels;
     if (initial_bitrate_kbps < kQvgaBitrateThresholdKbps)
       init_num_pixels = kQvgaNumPixels;
     while (width * height > init_num_pixels) {
       ++downscale_shift_;
       width /= 2;
       height /= 2;
     }
   }
-
-  // Zero out width/height so they can be checked against inside
-  // UpdateTargetResolution.
-  res_.width = res_.height = 0;
   UpdateTargetResolution(init_width, init_height);
   ReportFramerate(fps);
 }
 
 // Report framerate(fps) to estimate # of samples.
 void QualityScaler::ReportFramerate(int framerate) {
-  framerate_ = framerate;
-  UpdateSampleCounts();
+  // Use a faster window for upscaling initially.
+  // This enables faster initial rampups without risking strong up-down
+  // behavior later.
+  if (fast_rampup_)

[magjed_webrtc, 2016/09/05 15:01:52]

I would prefer to write this as:
num_samples_upscale_ = framerate * (fast_rampup_ ? kMeasureSecondsFastUpscale :
kMeasureSecondsUpscale);

+    num_samples_upscale_ = framerate * kMeasureSecondsFastUpscale;
+  else
+    num_samples_upscale_ = framerate * kMeasureSecondsUpscale;
+  num_samples_downscale_ = framerate * kMeasureSecondsDownscale;
 }
 
 void QualityScaler::ReportQP(int qp) {
   framedrop_percent_.AddSample(0);
-  average_qp_downscale_.AddSample(qp);
-  average_qp_upscale_.AddSample(qp);
+  average_qp_.AddSample(qp);
 }
 
 void QualityScaler::ReportDroppedFrame() {
   framedrop_percent_.AddSample(100);
 }
 
 void QualityScaler::OnEncodeFrame(int width, int height) {
   // Should be set through InitEncode -> Should be set by now.
   RTC_DCHECK_GE(low_qp_threshold_, 0);
-  RTC_DCHECK_GT(num_samples_upscale_, 0u);
-  RTC_DCHECK_GT(num_samples_downscale_, 0u);
+  if (res_.width != width || res_.height != height) {
+    UpdateTargetResolution(width, height);
+  }
 
-  // Update scale factor.
-  int avg_drop = 0;
-  int avg_qp = 0;
-
-  if ((framedrop_percent_.GetAverage(num_samples_downscale_, &avg_drop) &&
-       avg_drop >= kFramedropPercentThreshold) ||
-      (average_qp_downscale_.GetAverage(num_samples_downscale_, &avg_qp) &&
-       avg_qp > high_qp_threshold_)) {
-    AdjustScale(false);
-  } else if (average_qp_upscale_.GetAverage(num_samples_upscale_, &avg_qp) &&
-             avg_qp <= low_qp_threshold_) {
-    AdjustScale(true);
+  if ((framedrop_percent_.size() >= num_samples_downscale_ &&
+      (framedrop_percent_.GetAverage(num_samples_downscale_) >=
+       kFramedropPercentThreshold)) ||
+      (average_qp_.size() >= num_samples_downscale_ &&
+      (average_qp_.GetAverage(num_samples_downscale_) > high_qp_threshold_))) {
+    // too much framedrop or too high QP. We want to scale down.

[magjed_webrtc, 2016/09/05 15:01:52]

nit: Start with capital letter in comments.

+    downscale_shift_ = std::min(maximum_shift_, downscale_shift_ + 1);
+    if (fast_rampup_) {
+      fast_rampup_ = false;
+      num_samples_upscale_ =
+          (num_samples_upscale_ / kMeasureSecondsFastUpscale)
+          * kMeasureSecondsUpscale;
+    }
+    ClearSamples();
+  } else if (average_qp_.size() >= num_samples_upscale_ &&
+      average_qp_.GetAverage(num_samples_upscale_) <= low_qp_threshold_) {
+    // QP has been high. We want to try a higher resolution.
+    downscale_shift_ = std::max(0, downscale_shift_ - 1);
+    ClearSamples();
   }
-  UpdateTargetResolution(width, height);
 }
 
 QualityScaler::Resolution QualityScaler::GetScaledResolution() const {
-  return res_;
+  int frame_width = res_.width >> downscale_shift_;

[magjed_webrtc, 2016/09/05 15:01:52]

Use const (or inline these).

+  int frame_height = res_.height >> downscale_shift_;
+  return Resolution{frame_width, frame_height};
 }
 
 rtc::scoped_refptr<VideoFrameBuffer> QualityScaler::GetScaledBuffer(
     const rtc::scoped_refptr<VideoFrameBuffer>& frame) {
   Resolution res = GetScaledResolution();
   int src_width = frame->width();
   int src_height = frame->height();
 
   if (res.width == src_width && res.height == src_height)
     return frame;
   rtc::scoped_refptr<I420Buffer> scaled_buffer =
       pool_.CreateBuffer(res.width, res.height);
 
   scaled_buffer->ScaleFrom(frame);
 
   return scaled_buffer;
 }
 
-void QualityScaler::UpdateTargetResolution(int frame_width, int frame_height) {
-  RTC_DCHECK_GE(downscale_shift_, 0);
-  int shifts_performed = 0;
-  for (int shift = downscale_shift_;
-       shift > 0 && (frame_width / 2 >= kMinDownscaleDimension) &&
-       (frame_height / 2 >= kMinDownscaleDimension);
-       --shift, ++shifts_performed) {
-    frame_width /= 2;
-    frame_height /= 2;
+void QualityScaler::UpdateTargetResolution(int width, int height) {
+  if (width < kMinDownscaleDimension || height < kMinDownscaleDimension) {
+    maximum_shift_ = 0;
+  } else {
+    maximum_shift_ = static_cast<int>(
+        std::log2(std::min(width, height)/kMinDownscaleDimension));

[magjed_webrtc, 2016/09/05 15:01:52]

nit: formatting. Use git cl format.

   }
-  // Clamp to number of shifts actually performed to not be stuck trying to
-  // scale way beyond QVGA.
-  downscale_shift_ = shifts_performed;
-  if (res_.width == frame_width && res_.height == frame_height) {
-    // No reset done/needed, using same resolution.
-    return;
-  }
-  res_.width = frame_width;
-  res_.height = frame_height;
-  ClearSamples();
+  res_ = Resolution{width, height};

[magjed_webrtc, 2016/09/05 15:01:52]

Maybe this variable should be called target_resolution_ instead.

 }
 
 void QualityScaler::ClearSamples() {
   framedrop_percent_.Reset();
-  average_qp_downscale_.Reset();
-  average_qp_upscale_.Reset();
+  average_qp_.Reset();
 }
 
-void QualityScaler::UpdateSampleCounts() {
-  num_samples_downscale_ = static_cast<size_t>(
-      kMeasureSecondsDownscale * (framerate_ < kMinFps ? kMinFps : framerate_));
-  num_samples_upscale_ = static_cast<size_t>(
-      measure_seconds_upscale_ * (framerate_ < kMinFps ? kMinFps : framerate_));
-}
-
-void QualityScaler::AdjustScale(bool up) {
-  downscale_shift_ += up ? -1 : 1;
-  if (downscale_shift_ < 0)
-    downscale_shift_ = 0;
-  if (!up) {
-    // First downscale hit, start using a slower threshold for going up.
-    measure_seconds_upscale_ = kMeasureSecondsUpscale;
-    UpdateSampleCounts();
-  }
-}
 
 }  // namespace webrtc