Remove QualityScaler kDefaultLowQpDenominator.

webrtc/modules/video_coding/utility/quality_scaler_unittest.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 "testing/gtest/include/gtest/gtest.h"
 
 namespace webrtc {
 namespace {
 static const int kNumSeconds = 10;
 static const int kWidth = 1920;
 static const int kWidthVga = 640;
 static const int kHalfWidth = kWidth / 2;
 static const int kHeight = 1080;
 static const int kHeightVga = 480;
 static const int kFramerate = 30;
 static const int kLowQp = 15;
 static const int kNormalQp = 30;
+static const int kLowQpThreshold = 18;
 static const int kHighQp = 40;
-static const int kMaxQp = 56;
-static const int kDisabledBadQpThreshold = kMaxQp + 1;
+static const int kDisabledBadQpThreshold = 64;
 static const int kLowInitialBitrateKbps = 300;
 // These values need to be in sync with corresponding constants
 // in quality_scaler.cc
 static const int kMeasureSecondsDownscale = 3;
 static const int kMeasureSecondsFastUpscale = 2;
 static const int kMeasureSecondsUpscale = 5;
 static const int kMinDownscaleDimension = 140;
 }  // namespace
 
 class QualityScalerTest : public ::testing::Test {
@@ skipping 10 matching lines @@
     kKeepScaleAtHighQp,
     kScaleDown,
     kScaleDownAboveHighQp,
     kScaleUp
   };
   enum BadQualityMetric { kDropFrame, kReportLowQP };
 
   QualityScalerTest() {
     input_frame_.CreateEmptyFrame(kWidth, kHeight, kWidth, kHalfWidth,
                                   kHalfWidth);
-    qs_.Init(kMaxQp / QualityScaler::kDefaultLowQpDenominator, kHighQp, false,
-             0, 0, 0, kFramerate);
+    qs_.Init(kLowQpThreshold, kHighQp, false, 0, 0, 0, kFramerate);
     qs_.OnEncodeFrame(input_frame_);
   }
 
   bool TriggerScale(ScaleDirection scale_direction) {
     qs_.OnEncodeFrame(input_frame_);
     int initial_width = qs_.GetScaledResolution().width;
     for (int i = 0; i < kFramerate * kNumSeconds; ++i) {
       switch (scale_direction) {
         case kScaleUp:
           qs_.ReportQP(kLowQp);
@@ skipping 230 matching lines @@
   }
   return res;
 }
 
 void QualityScalerTest::VerifyQualityAdaptation(
     int initial_framerate,
     int seconds_downscale,
     int seconds_upscale,
     bool expect_spatial_resize,
     bool expect_framerate_reduction) {
-  qs_.Init(kMaxQp / QualityScaler::kDefaultLowQpDenominator,
-           kDisabledBadQpThreshold, true, 0, 0, 0, initial_framerate);
+  qs_.Init(kLowQpThreshold, kDisabledBadQpThreshold, true, 0, 0, 0,
+           initial_framerate);
   qs_.OnEncodeFrame(input_frame_);
   int init_width = qs_.GetScaledResolution().width;
   int init_height = qs_.GetScaledResolution().height;
 
   // Test reducing framerate by dropping frame continuously.
   QualityScalerTest::Resolution res =
       TriggerResolutionChange(kDropFrame, seconds_downscale, initial_framerate);
 
   if (expect_framerate_reduction) {
     EXPECT_LT(res.framerate, initial_framerate);
@@ skipping 51 matching lines @@
   DoesNotDownscaleFrameDimensions(
       2 * kMinDownscaleDimension - 1, 1000);
 }
 
 TEST_F(QualityScalerTest, DoesNotDownscaleBelow2xDefaultMinDimensionsHeight) {
   DoesNotDownscaleFrameDimensions(
       1000, 2 * kMinDownscaleDimension - 1);
 }
 
 TEST_F(QualityScalerTest, DownscaleToVgaOnLowInitialBitrate) {
-  qs_.Init(kMaxQp / QualityScaler::kDefaultLowQpDenominator,
-           kDisabledBadQpThreshold, true,
+  qs_.Init(kLowQpThreshold, kDisabledBadQpThreshold, true,
            kLowInitialBitrateKbps, kWidth, kHeight, kFramerate);
   qs_.OnEncodeFrame(input_frame_);
   int init_width = qs_.GetScaledResolution().width;
   int init_height = qs_.GetScaledResolution().height;
   EXPECT_LE(init_width, kWidthVga);
   EXPECT_LE(init_height, kHeightVga);
 }
 
 TEST_F(QualityScalerTest, DownscaleAfterMeasuredSecondsThenSlowerBackUp) {
   QualityScalerTest::Resolution initial_res;
-  qs_.Init(kMaxQp / QualityScaler::kDefaultLowQpDenominator, kHighQp, false, 0,
-           kWidth, kHeight, kFramerate);
+  qs_.Init(kLowQpThreshold, kHighQp, false, 0, kWidth, kHeight, kFramerate);
   qs_.OnEncodeFrame(input_frame_);
   initial_res.width = qs_.GetScaledResolution().width;
   initial_res.height = qs_.GetScaledResolution().height;
 
   // Should not downscale if less than kMeasureSecondsDownscale seconds passed.
   for (int i = 0; i < kFramerate * kMeasureSecondsDownscale - 1; ++i) {
     qs_.ReportQP(kHighQp + 1);
     qs_.OnEncodeFrame(input_frame_);
   }
   EXPECT_EQ(initial_res.width, qs_.GetScaledResolution().width);
@@ skipping 18 matching lines @@
   // Should upscale (back to initial) if kMeasureSecondsUpscale seconds passed
   // (add last frame).
   qs_.ReportQP(kLowQp);
   qs_.OnEncodeFrame(input_frame_);
   EXPECT_EQ(initial_res.width, qs_.GetScaledResolution().width);
   EXPECT_EQ(initial_res.height, qs_.GetScaledResolution().height);
 }
 
 TEST_F(QualityScalerTest, UpscaleQuicklyInitiallyAfterMeasuredSeconds) {
   QualityScalerTest::Resolution initial_res;
-  qs_.Init(kMaxQp / QualityScaler::kDefaultLowQpDenominator, kHighQp, false,
-           kLowInitialBitrateKbps, kWidth, kHeight, kFramerate);
+  qs_.Init(kLowQpThreshold, kHighQp, false, kLowInitialBitrateKbps, kWidth,
+           kHeight, kFramerate);
   qs_.OnEncodeFrame(input_frame_);
   initial_res.width = qs_.GetScaledResolution().width;
   initial_res.height = qs_.GetScaledResolution().height;
 
   // Should not upscale if less than kMeasureSecondsFastUpscale seconds passed.
   for (int i = 0; i < kFramerate * kMeasureSecondsFastUpscale - 1; ++i) {
     qs_.ReportQP(kLowQp);
     qs_.OnEncodeFrame(input_frame_);
   }
   EXPECT_EQ(initial_res.width, qs_.GetScaledResolution().width);
@@ skipping 43 matching lines @@
 
 TEST_F(QualityScalerTest, DownscalesFrom1280x720To320x180) {
   DownscaleEndsAt(1280, 720, 320, 180);
 }
 
 TEST_F(QualityScalerTest, DoesntDownscaleInitialQvga) {
   DownscaleEndsAt(320, 180, 320, 180);
 }
 
 }  // namespace webrtc