Move kMinPixelsPerFrame constant in VideoStreamEncoder to VideoEncoder::ScalingSettings.

webrtc/media/engine/videoencodersoftwarefallbackwrapper_unittest.cc

 /*
  *  Copyright (c) 2015 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/test/field_trial.h"
 #include "webrtc/test/gtest.h"
 
 namespace webrtc {
 namespace {
 const int kWidth = 320;
 const int kHeight = 240;
 const int kNumCores = 2;
 const uint32_t kFramerate = 30;
 const size_t kMaxPayloadSize = 800;
+const int kDefaultMinPixelsPerFrame = 320 * 180;
 }  // namespace
 
 class VideoEncoderSoftwareFallbackWrapperTest : public ::testing::Test {
  protected:
   VideoEncoderSoftwareFallbackWrapperTest()
       : VideoEncoderSoftwareFallbackWrapperTest("") {}
   explicit VideoEncoderSoftwareFallbackWrapperTest(
       const std::string& field_trials)
       : override_field_trials_(field_trials),
         fallback_wrapper_(cricket::VideoCodec("VP8"), &fake_encoder_) {}
@@ skipping 44 matching lines @@
 
     bool SupportsNativeHandle() const override {
       ++supports_native_handle_count_;
       return supports_native_handle_;
     }
 
     const char* ImplementationName() const override {
       return "fake-encoder";
     }
 
+    VideoEncoder::ScalingSettings GetScalingSettings() const override {
+      return VideoEncoder::ScalingSettings(true);
+    }
+
     int init_encode_count_ = 0;
     int32_t init_encode_return_code_ = WEBRTC_VIDEO_CODEC_OK;
     int32_t encode_return_code_ = WEBRTC_VIDEO_CODEC_OK;
     int encode_count_ = 0;
     EncodedImageCallback* encode_complete_callback_ = nullptr;
     int release_count_ = 0;
     int set_channel_parameters_count_ = 0;
     int set_rates_count_ = 0;
     mutable int supports_native_handle_count_ = 0;
     bool supports_native_handle_ = false;
@@ skipping 28 matching lines @@
   VideoCodec codec_ = {};
   std::unique_ptr<VideoFrame> frame_;
   std::unique_ptr<SimulcastRateAllocator> rate_allocator_;
 };
 
 void VideoEncoderSoftwareFallbackWrapperTest::EncodeFrame() {
   EncodeFrame(WEBRTC_VIDEO_CODEC_OK);
 }
 
 void VideoEncoderSoftwareFallbackWrapperTest::EncodeFrame(int expected_ret) {
-  rtc::scoped_refptr<I420Buffer> buffer = I420Buffer::Create(kWidth, kHeight);
+  rtc::scoped_refptr<I420Buffer> buffer =
+      I420Buffer::Create(codec_.width, codec_.height);
   I420Buffer::SetBlack(buffer);
   std::vector<FrameType> types(1, kVideoFrameKey);
 
   frame_.reset(new VideoFrame(buffer, 0, 0, webrtc::kVideoRotation_0));
   EXPECT_EQ(expected_ret, fallback_wrapper_.Encode(*frame_, nullptr, &types));
 }
 
 void VideoEncoderSoftwareFallbackWrapperTest::UtilizeFallbackEncoder() {
   fallback_wrapper_.RegisterEncodeCompleteCallback(&callback_);
   EXPECT_EQ(&callback_, fake_encoder_.encode_complete_callback_);
@@ skipping 137 matching lines @@
 
 TEST_F(VideoEncoderSoftwareFallbackWrapperTest,
        SupportsNativeHandleNotForwardedDuringFallback) {
   UtilizeFallbackEncoder();
   fallback_wrapper_.SupportsNativeHandle();
   EXPECT_EQ(0, fake_encoder_.supports_native_handle_count_);
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.Release());
 }
 
 TEST_F(VideoEncoderSoftwareFallbackWrapperTest, ReportsImplementationName) {
-  VideoCodec codec = {};
+  codec_.width = kWidth;
+  codec_.height = kHeight;
   fallback_wrapper_.RegisterEncodeCompleteCallback(&callback_);
-  fallback_wrapper_.InitEncode(&codec, kNumCores, kMaxPayloadSize);
+  fallback_wrapper_.InitEncode(&codec_, kNumCores, kMaxPayloadSize);
   EncodeFrame();
   CheckLastEncoderName("fake-encoder");
 }
 
 TEST_F(VideoEncoderSoftwareFallbackWrapperTest,
        ReportsFallbackImplementationName) {
   UtilizeFallbackEncoder();
   // Hard coded expected value since libvpx is the software implementation name
   // for VP8. Change accordingly if the underlying implementation does.
   CheckLastEncoderName("libvpx");
 }
 
 namespace {
 const int kLowKbps = 220;
 const int kHighKbps = 300;
 const int kMinLowDurationMs = 4000;
+const int kMinPixelsPerFrame = 1;
+const int kMinPixelsStop = 320 * 180;
 const std::string kFieldTrial = "WebRTC-VP8-Forced-Fallback-Encoder";
 }  // namespace
 
 class ForcedFallbackTest : public VideoEncoderSoftwareFallbackWrapperTest {
  public:
   ForcedFallbackTest(const std::string& field_trials)
       : VideoEncoderSoftwareFallbackWrapperTest(field_trials) {}
 
   ~ForcedFallbackTest() override {}
 
@@ skipping 12 matching lines @@
 
   void ConfigureVp8Codec() {
     fallback_wrapper_.RegisterEncodeCompleteCallback(&callback_);
     std::unique_ptr<TemporalLayersFactory> tl_factory(
         new TemporalLayersFactory());
     codec_.codecType = kVideoCodecVP8;
     codec_.maxFramerate = kFramerate;
     codec_.width = kWidth;
     codec_.height = kHeight;
     codec_.VP8()->numberOfTemporalLayers = 1;
+    codec_.VP8()->automaticResizeOn = true;
+    codec_.VP8()->frameDroppingOn = true;
     codec_.VP8()->tl_factory = tl_factory.get();
     rate_allocator_.reset(
         new SimulcastRateAllocator(codec_, std::move(tl_factory)));
   }
 
   void SetRateAllocation(uint32_t bitrate_kbps) {
     EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.SetRateAllocation(
                                          rate_allocator_->GetAllocation(
                                              bitrate_kbps * 1000, kFramerate),
                                          kFramerate));
@@ skipping 11 matching lines @@
 
   rtc::ScopedFakeClock clock_;
 };
 
 class ForcedFallbackTestEnabled : public ForcedFallbackTest {
  public:
   ForcedFallbackTestEnabled()
       : ForcedFallbackTest(kFieldTrial + "/Enabled-" +
                            std::to_string(kLowKbps) + "," +
                            std::to_string(kHighKbps) + "," +
-                           std::to_string(kMinLowDurationMs) + "/") {}
+                           std::to_string(kMinLowDurationMs) + "," +
+                           std::to_string(kMinPixelsPerFrame) + "/") {}
 };
 
 class ForcedFallbackTestDisabled : public ForcedFallbackTest {
  public:
   ForcedFallbackTestDisabled()
       : ForcedFallbackTest(kFieldTrial + "/Disabled/") {}
 };
 
 TEST_F(ForcedFallbackTestDisabled, NoFallbackWithoutFieldTrial) {
   // Bitrate at low threshold.
@@ skipping 173 matching lines @@
             fallback_wrapper_.InitEncode(&codec_, kNumCores, kMaxPayloadSize));
   EXPECT_EQ(3, fake_encoder_.init_encode_count_);
   // Bitrate at low threshold.
   SetRateAllocation(kLowKbps);
   EncodeFrameAndVerifyLastName("fake-encoder");
   // Duration passed, expect no fallback.
   clock_.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kMinLowDurationMs));
   EncodeFrameAndVerifyLastName("fake-encoder");
 }
 
+TEST_F(ForcedFallbackTestEnabled, GetScaleSettingsWithoutFallback) {
+  // Bitrate at low threshold.
+  SetRateAllocation(kLowKbps);
+  EncodeFrameAndVerifyLastName("fake-encoder");
+  // Default min pixels per frame should be used.
+  const auto settings = fallback_wrapper_.GetScalingSettings();
+  EXPECT_TRUE(settings.enabled);
+  EXPECT_EQ(kDefaultMinPixelsPerFrame, settings.min_pixels_per_frame);
+}
+
+TEST_F(ForcedFallbackTestEnabled, GetScaleSettingsWithFallback) {
+  // Bitrate at low threshold.
+  SetRateAllocation(kLowKbps);
+  EncodeFrameAndVerifyLastName("fake-encoder");
+  // Duration passed, expect fallback.
+  clock_.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kMinLowDurationMs));
+  EncodeFrameAndVerifyLastName("libvpx");
+  // Configured min pixels per frame should be used.
+  const auto settings = fallback_wrapper_.GetScalingSettings();
+  EXPECT_TRUE(settings.enabled);
+  EXPECT_EQ(kMinPixelsPerFrame, settings.min_pixels_per_frame);
+}
+
+TEST_F(ForcedFallbackTestEnabled, FallbackIsKeptIfResolutionIsTooSmall) {
+  // Bitrate at low threshold.
+  SetRateAllocation(kLowKbps);
+  EncodeFrameAndVerifyLastName("fake-encoder");
+  // Duration passed, expect fallback.
+  clock_.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kMinLowDurationMs));
+  EncodeFrameAndVerifyLastName("libvpx");
+
+  // Re-initialize encoder with a resolution less than |kMinPixelsStop|.
+  codec_.height = kMinPixelsStop / codec_.width - 1;
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+            fallback_wrapper_.InitEncode(&codec_, kNumCores, kMaxPayloadSize));
+  EXPECT_EQ(1, fake_encoder_.init_encode_count_);  // No change
+  SetRateAllocation(kHighKbps - 1);
+  EncodeFrameAndVerifyLastName("libvpx");
+  // Bitrate at high threshold but resolution too small for fallback to end.
+  SetRateAllocation(kHighKbps);
+  EncodeFrameAndVerifyLastName("libvpx");
+
+  // Re-initialize encoder with a resolution equal to |kMinPixelsStop|.
+  codec_.height++;
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+            fallback_wrapper_.InitEncode(&codec_, kNumCores, kMaxPayloadSize));
+  EXPECT_EQ(1, fake_encoder_.init_encode_count_);  // No change
+  SetRateAllocation(kHighKbps - 1);
+  EncodeFrameAndVerifyLastName("libvpx");
+  // Bitrate at high threshold and resolution large enough for fallback to end.
+  SetRateAllocation(kHighKbps);
+  EncodeFrameAndVerifyLastName("fake-encoder");
+}
+
 }  // namespace webrtc