Make QualityScaler not downscale below QVGA.

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.
  */
 
@@ skipping 14 matching lines @@
 static const int kNormalQp = 30;
 static const int kHighQp = 40;
 static const int kMaxQp = 56;
 static const int kDisabledBadQpThreshold = kMaxQp + 1;
 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 = 160;
 }  // namespace
 
 class QualityScalerTest : public ::testing::Test {
  public:
   // Temporal and spatial resolution.
   struct Resolution {
     int framerate;
     int width;
     int height;
   };
@@ skipping 148 matching lines @@
   }
 }
 
 void QualityScalerTest::ContinuouslyDownscalesByHalfDimensionsAndBackUp() {
   const int initial_min_dimension = input_frame_.width() < input_frame_.height()
                                         ? input_frame_.width()
                                         : input_frame_.height();
   int min_dimension = initial_min_dimension;
   int current_shift = 0;
   // Drop all frames to force-trigger downscaling.
-  while (min_dimension >= 2 * QualityScaler::kDefaultMinDownscaleDimension) {
+  while (min_dimension >= 2 * kMinDownscaleDimension) {
     EXPECT_TRUE(TriggerScale(kScaleDown)) << "No downscale within "
                                           << kNumSeconds << " seconds.";
     qs_.OnEncodeFrame(input_frame_);
     QualityScaler::Resolution res = qs_.GetScaledResolution();
     min_dimension = res.width < res.height ? res.width : res.height;
     ++current_shift;
     ASSERT_EQ(input_frame_.width() >> current_shift, res.width);
     ASSERT_EQ(input_frame_.height() >> current_shift, res.height);
     ExpectScaleUsingReportedResolution();
   }
@@ skipping 150 matching lines @@
 
 // When starting from a low framerate, only spatial size will be changed.
 TEST_F(QualityScalerTest, ChangeSpatialSizeOnly) {
   qs_.ReportFramerate(kFramerate >> 1);
   VerifyQualityAdaptation(kFramerate >> 1, kMeasureSecondsDownscale * 2,
                           kMeasureSecondsUpscale * 2, true, false);
 }
 
 TEST_F(QualityScalerTest, DoesNotDownscaleBelow2xDefaultMinDimensionsWidth) {
   DoesNotDownscaleFrameDimensions(
-      2 * QualityScaler::kDefaultMinDownscaleDimension - 1, 1000);
+      2 * kMinDownscaleDimension - 1, 1000);
 }
 
 TEST_F(QualityScalerTest, DoesNotDownscaleBelow2xDefaultMinDimensionsHeight) {
   DoesNotDownscaleFrameDimensions(
-      1000, 2 * QualityScaler::kDefaultMinDownscaleDimension - 1);
+      1000, 2 * kMinDownscaleDimension - 1);
 }
 
 TEST_F(QualityScalerTest, DownscaleToVgaOnLowInitialBitrate) {
   qs_.Init(kMaxQp / QualityScaler::kDefaultLowQpDenominator,
            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);
@@ skipping 83 matching lines @@
       EXPECT_EQ(last_height, res.height);
       EXPECT_EQ(end_width, res.width);
       EXPECT_EQ(end_height, res.height);
       break;
     }
     last_width = res.width;
     last_height = res.height;
   }
 }
 
-TEST_F(QualityScalerTest, DefaultDownscalesTo160x90) {
-  DownscaleEndsAt(320, 180, 160, 90);
+TEST_F(QualityScalerTest, DownscalesTo320x180) {
+  DownscaleEndsAt(640, 360, 320, 180);
 }
 
-TEST_F(QualityScalerTest, DefaultDownscalesTo90x160) {
-  DownscaleEndsAt(180, 320, 90, 160);
+TEST_F(QualityScalerTest, DownscalesTo180x320) {
+  DownscaleEndsAt(360, 640, 180, 320);
 }
 
-TEST_F(QualityScalerTest, DefaultDownscalesFrom1280x720To160x90) {
-  DownscaleEndsAt(1280, 720, 160, 90);
+TEST_F(QualityScalerTest, DownscalesFrom1280x720To320x180) {
+  DownscaleEndsAt(1280, 720, 320, 180);
 }
 
-TEST_F(QualityScalerTest, DefaultDoesntDownscaleBelow160x90) {
-  DownscaleEndsAt(320 - 1, 180 - 1, 320 - 1, 180 - 1);
-}
-
-TEST_F(QualityScalerTest, DefaultDoesntDownscaleBelow90x160) {
-  DownscaleEndsAt(180 - 1, 320 - 1, 180 - 1, 320 - 1);
-}
-
-TEST_F(QualityScalerTest, RespectsMinResolutionWidth) {
-  // Should end at 200x100, as width can't go lower.
-  qs_.SetMinResolution(200, 10);
-  DownscaleEndsAt(1600, 800, 200, 100);
-}
-
-TEST_F(QualityScalerTest, RespectsMinResolutionHeight) {
-  // Should end at 100x200, as height can't go lower.
-  qs_.SetMinResolution(10, 200);
-  DownscaleEndsAt(800, 1600, 100, 200);
+TEST_F(QualityScalerTest, DoesntDownscaleInitialQvga) {
+  DownscaleEndsAt(320, 180, 320, 180);
 }
 
 }  // namespace webrtc