Move the QP scaling thresholds to the relevant encoders

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 <math.h>
 
 #include <algorithm>
 
+#include "webrtc/base/checks.h"
+
 // TODO(kthelgason): Some versions of Android have issues with log2.
 // See https://code.google.com/p/android/issues/detail?id=212634 for details
 #if defined(WEBRTC_ANDROID)
 #define log2(x) (log(x) / log(2))
 #endif
 
 namespace webrtc {
 
 namespace {
 // 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
 // mechanism.
 static const int kVgaBitrateThresholdKbps = 500;
 static const int kVgaNumPixels = 700 * 500;  // 640x480
 static const int kQvgaBitrateThresholdKbps = 250;
 static const int kQvgaNumPixels = 400 * 300;  // 320x240
+
+// QP scaling threshold defaults:
+static const int kLowH264QpThreshold = 28;
+static const int kHighH264QpThreshold = 39;
+// QP is obtained from VP8-bitstream for HW, so the QP corresponds to the
+// bitstream range of [0, 127] and not the user-level range of [0,63].
+static const int kLowVp8QpThreshold = 29;
+static const int kHighVp8QpThreshold = 95;
 }  // namespace
 
-// QP thresholds are chosen to be high enough to be hit in practice when quality
-// is good, but also low enough to not cause a flip-flop behavior (e.g. going up
-// in resolution shouldn't give so bad quality that we should go back down).
-
-const int QualityScaler::kLowVp8QpThreshold = 29;
-const int QualityScaler::kBadVp8QpThreshold = 95;
-
-#if defined(WEBRTC_IOS)
-const int QualityScaler::kLowH264QpThreshold = 32;
-const int QualityScaler::kBadH264QpThreshold = 42;
-#else
-const int QualityScaler::kLowH264QpThreshold = 24;
-const int QualityScaler::kBadH264QpThreshold = 37;
-#endif
-
 // Default values. Should immediately get set to something more sensible.
 QualityScaler::QualityScaler()
     : average_qp_(kMeasureSecondsUpscale * 30),
       framedrop_percent_(kMeasureSecondsUpscale * 30),
       low_qp_threshold_(-1) {}
 
-void QualityScaler::Init(int low_qp_threshold,
-                         int high_qp_threshold,
+void QualityScaler::Init(VideoCodecType codec_type,
                          int initial_bitrate_kbps,
                          int width,
                          int height,
                          int fps) {
-  low_qp_threshold_ = low_qp_threshold;
-  high_qp_threshold_ = high_qp_threshold;
+  ClearSamples();

[pbos-webrtc, 2016/09/19 14:06:57]

Have this function just get low/high thresholds and then call the other Init
function with found high/low parameters.

E.g. this function just gets the default parameters for QP, then forwards to the
other Init().

+  switch (codec_type) {
+    case kVideoCodecH264:
+      low_qp_threshold_ = kLowH264QpThreshold;
+      high_qp_threshold_ = kHighH264QpThreshold;
+      break;
+    case kVideoCodecVP8:
+      low_qp_threshold_ = kLowVp8QpThreshold;
+      high_qp_threshold_ = kHighVp8QpThreshold;
+      break;
+    default:
+      RTC_NOTREACHED() << "Invalid codec type for QualityScaler.";
+  }
   downscale_shift_ = 0;
 
   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;
     }
   }
   UpdateTargetResolution(init_width, init_height);
   ReportFramerate(fps);
 }
 
+void QualityScaler::Init(VideoCodecType codec_type,
+                         int initial_bitrate_kbps,
+                         int width,
+                         int height,
+                         int fps,
+                         int highQpThreshold,

[pbos-webrtc, 2016/09/19 14:06:57]

high_qp_threshold, same for low

+                         int lowQpThreshold) {
+  Init(codec_type, initial_bitrate_kbps, width, height, fps);
+  low_qp_threshold_ = highQpThreshold;
+  high_qp_threshold_ = lowQpThreshold;
+}
+
 // Report framerate(fps) to estimate # of samples.
 void QualityScaler::ReportFramerate(int framerate) {
   // Use a faster window for upscaling initially.
   // This enables faster initial rampups without risking strong up-down
   // behavior later.
   num_samples_upscale_ = framerate * (fast_rampup_ ? kMeasureSecondsFastUpscale
                                                    : kMeasureSecondsUpscale);
   num_samples_downscale_ = framerate * kMeasureSecondsDownscale;
 
   average_qp_ =
@@ skipping 87 matching lines @@
   target_res_ = Resolution{width, height};
 }
 
 void QualityScaler::ClearSamples() {
   framedrop_percent_.Reset();
   average_qp_.Reset();
 }
 
 
 }  // namespace webrtc