Move kMinPixelsPerFrame constant in VideoStreamEncoder to VideoEncoder::ScalingSettings.

webrtc/video/video_stream_encoder_unittest.cc

 /*
  *  Copyright (c) 2016 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 11 matching lines @@
 #include "webrtc/system_wrappers/include/sleep.h"
 #include "webrtc/test/encoder_settings.h"
 #include "webrtc/test/fake_encoder.h"
 #include "webrtc/test/frame_generator.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/video/send_statistics_proxy.h"
 #include "webrtc/video/video_stream_encoder.h"
 
 namespace {
-// TODO(kthelgason): Lower this limit when better testing
-// on MediaCodec and fallback implementations are in place.
 const int kMinPixelsPerFrame = 320 * 180;
 const int kMinFramerateFps = 2;
 const int64_t kFrameTimeoutMs = 100;
 }  // namespace
 
 namespace webrtc {
 
 using DegredationPreference = VideoSendStream::DegradationPreference;
 using ScaleReason = AdaptationObserverInterface::AdaptReason;
 using ::testing::_;
@@ skipping 422 matching lines @@
     }
 
     void BlockNextEncode() {
       rtc::CritScope lock(&local_crit_sect_);
       block_next_encode_ = true;
     }
 
     VideoEncoder::ScalingSettings GetScalingSettings() const override {
       rtc::CritScope lock(&local_crit_sect_);
       if (quality_scaling_)
-        return VideoEncoder::ScalingSettings(true, 1, 2);
+        return VideoEncoder::ScalingSettings(true, 1, 2, kMinPixelsPerFrame);
       return VideoEncoder::ScalingSettings(false);
     }
 
     void ContinueEncode() { continue_encode_event_.Set(); }
 
     void CheckLastTimeStampsMatch(int64_t ntp_time_ms,
                                   uint32_t timestamp) const {
       rtc::CritScope lock(&local_crit_sect_);
       EXPECT_EQ(timestamp_, timestamp);
       EXPECT_EQ(ntp_time_ms_, ntp_time_ms);
@@ skipping 1318 matching lines @@
 }
 
 TEST_F(VideoStreamEncoderTest, DoesNotScaleBelowSetResolutionLimit) {
   const int kWidth = 1280;
   const int kHeight = 720;
   const size_t kNumFrames = 10;
 
   video_stream_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   // Enable adapter, expected input resolutions when downscaling:
-  // 1280x720 -> 960x540 -> 640x360 -> 480x270 -> 320x180 (min resolution limit)
+  // 1280x720 -> 960x540 -> 640x360 -> 480x270 -> 320x180 (kMinPixelsPerFrame)
   video_source_.set_adaptation_enabled(true);
 
   EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
   EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes);
 
   int downscales = 0;
   for (size_t i = 1; i <= kNumFrames; i++) {
     video_source_.IncomingCapturedFrame(CreateFrame(i, kWidth, kHeight));
     WaitForEncodedFrame(i);
 
@@ skipping 1350 matching lines @@
   // Bitrate observer should not be called.
   EXPECT_CALL(bitrate_observer, OnBitrateAllocationUpdated(_)).Times(0);
   video_source_.IncomingCapturedFrame(
       CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight));
   ExpectDroppedFrame();
 
   video_stream_encoder_->Stop();
 }
 
 }  // namespace webrtc