Make QualityScaler not downscale below QVGA.

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"
 
 namespace webrtc {
 
+namespace {
 static const int kMinFps = 5;
 static const int kMeasureSecondsDownscale = 3;
 // Threshold constant used until first downscale (to permit fast rampup).
 static const int kMeasureSecondsFastUpscale = 2;
 static const int kMeasureSecondsUpscale = 5;
 static const int kFramedropPercentThreshold = 60;
 static const int kHdResolutionThreshold = 700 * 500;
 static const int kHdBitrateThresholdKbps = 500;
+// 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;
+}  // namespace
 
 const int QualityScaler::kDefaultLowQpDenominator = 3;
-// Note that this is the same for width and height to permit 120x90 in both
-// portrait and landscape mode.
-const int QualityScaler::kDefaultMinDownscaleDimension = 90;
 
 QualityScaler::QualityScaler()
-    : low_qp_threshold_(-1),
-      framerate_down_(false),
-      min_width_(kDefaultMinDownscaleDimension),
-      min_height_(kDefaultMinDownscaleDimension) {}
+    : low_qp_threshold_(-1), framerate_down_(false) {}
 
 void QualityScaler::Init(int low_qp_threshold,
                          int high_qp_threshold,
                          bool use_framerate_reduction,
                          int initial_bitrate_kbps,
                          int width,
                          int height,
                          int fps) {
   ClearSamples();
   low_qp_threshold_ = low_qp_threshold;
@@ skipping 15 matching lines @@
       ++downscale_shift_;
       width /= 2;
       height /= 2;
     }
   }
   UpdateTargetResolution(init_width, init_height);
   ReportFramerate(fps);
   target_framerate_ = -1;
 }
 
-void QualityScaler::SetMinResolution(int min_width, int min_height) {
-  min_width_ = min_width;
-  min_height_ = min_height;
-}
-
 // Report framerate(fps) to estimate # of samples.
 void QualityScaler::ReportFramerate(int framerate) {
   framerate_ = framerate;
   UpdateSampleCounts();
 }
 
 void QualityScaler::ReportQP(int qp) {
   framedrop_percent_.AddSample(0);
   average_qp_downscale_.AddSample(qp);
   average_qp_upscale_.AddSample(qp);
@@ skipping 68 matching lines @@
   scaled_frame_.set_render_time_ms(frame.render_time_ms());
 
   return scaled_frame_;
 }
 
 void QualityScaler::UpdateTargetResolution(int frame_width, int frame_height) {
   assert(downscale_shift_ >= 0);
   res_.width = frame_width;
   res_.height = frame_height;
   for (int shift = downscale_shift_;
-       shift > 0 && (res_.width / 2 >= min_width_) &&
-       (res_.height / 2 >= min_height_);
+       shift > 0 && (res_.width / 2 >= kMinDownscaleDimension) &&
+       (res_.height / 2 >= kMinDownscaleDimension);
        --shift) {
     res_.width /= 2;
     res_.height /= 2;
   }
 }
 
 void QualityScaler::ClearSamples() {
   framedrop_percent_.Reset();
   average_qp_downscale_.Reset();
   average_qp_upscale_.Reset();
@@ skipping 12 matching lines @@
     downscale_shift_ = 0;
   if (!up) {
     // Hit first downscale, start using a slower threshold for going up.
     measure_seconds_upscale_ = kMeasureSecondsUpscale;
     UpdateSampleCounts();
   }
   ClearSamples();
 }
 
 }  // namespace webrtc