Move usage of QualityScaler to ViEEncoder.

webrtc/video/vie_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.
  */
 
 #include <limits>
 #include <utility>
 
 #include "webrtc/base/logging.h"
 #include "webrtc/system_wrappers/include/metrics_default.h"
 #include "webrtc/test/encoder_settings.h"
 #include "webrtc/test/fake_encoder.h"
 #include "webrtc/test/frame_generator.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/video/send_statistics_proxy.h"
 #include "webrtc/video/vie_encoder.h"
 
 namespace webrtc {
 
+using DegredationPreference = VideoSendStream::DegradationPreference;
+using ScaleReason = ScalingObserverInterface::ScaleReason;
+
 namespace {
 class TestBuffer : public webrtc::I420Buffer {
  public:
   TestBuffer(rtc::Event* event, int width, int height)
       : I420Buffer(width, height), event_(event) {}
 
  private:
   friend class rtc::RefCountedObject<TestBuffer>;
   ~TestBuffer() override {
     if (event_)
       event_->Set();
   }
   rtc::Event* const event_;
 };
 
 class ViEEncoderUnderTest : public ViEEncoder {
  public:
-  ViEEncoderUnderTest(
-      SendStatisticsProxy* stats_proxy,
-      const webrtc::VideoSendStream::Config::EncoderSettings& settings)
+  ViEEncoderUnderTest(SendStatisticsProxy* stats_proxy,
+                      const VideoSendStream::Config::EncoderSettings& settings)
       : ViEEncoder(1 /* number_of_cores */,
                    stats_proxy,
                    settings,
                    nullptr /* pre_encode_callback */,
                    nullptr /* encoder_timing */) {}
 
-  void TriggerCpuOveruse() {
+  void PostTaskAndWait(bool down, ScaleReason reason) {
     rtc::Event event(false, false);
-    encoder_queue()->PostTask([this, &event] {
-      OveruseDetected();
+    encoder_queue()->PostTask([this, &event, reason, down] {
+      down ? ScaleDown(reason) : ScaleUp(reason);
       event.Set();
     });
-    event.Wait(rtc::Event::kForever);
+    RTC_DCHECK(event.Wait(5000));
   }
 
-  void TriggerCpuNormalUsage() {
-    rtc::Event event(false, false);
-    encoder_queue()->PostTask([this, &event] {
-      NormalUsage();
-      event.Set();
-    });
-    event.Wait(rtc::Event::kForever);
-  }
+  void TriggerCpuOveruse() { PostTaskAndWait(true, ScaleReason::kCpu); }
+
+  void TriggerCpuNormalUsage() { PostTaskAndWait(false, ScaleReason::kCpu); }
+
+  void TriggerQualityLow() { PostTaskAndWait(true, ScaleReason::kQuality); }
+
+  void TriggerQualityHigh() { PostTaskAndWait(false, ScaleReason::kQuality); }
 };
 
 }  // namespace
 
 class ViEEncoderTest : public ::testing::Test {
  public:
   static const int kDefaultTimeoutMs = 30 * 1000;
 
   ViEEncoderTest()
       : video_send_config_(VideoSendStream::Config(nullptr)),
@@ skipping 50 matching lines @@
     VideoCodec codec_config() {
       rtc::CritScope lock(&crit_);
       return config_;
     }
 
     void BlockNextEncode() {
       rtc::CritScope lock(&crit_);
       block_next_encode_ = true;
     }
 
+    VideoEncoder::ScalingSettings GetScalingSettings() const override {
+      return VideoEncoder::ScalingSettings(true, 1, 2);
+    }
+
     void ContinueEncode() { continue_encode_event_.Set(); }
 
     void CheckLastTimeStampsMatch(int64_t ntp_time_ms,
                                   uint32_t timestamp) const {
       rtc::CritScope lock(&crit_);
       EXPECT_EQ(timestamp_, timestamp);
       EXPECT_EQ(ntp_time_ms_, ntp_time_ms);
     }
 
    private:
@@ skipping 274 matching lines @@
 
     EXPECT_LT(video_source_.sink_wants().max_pixel_count.value_or(
                   std::numeric_limits<int>::max()),
               frame_width * frame_height);
     EXPECT_FALSE(video_source_.sink_wants().max_pixel_count_step_up);
 
     frame_width /= 2;
     frame_height /= 2;
   }
 
-  // Trigger CPU overuse a one more time. This should not trigger request for
+  // Trigger CPU overuse one more time. This should not trigger a request for
   // lower resolution.
   rtc::VideoSinkWants current_wants = video_source_.sink_wants();
   video_source_.IncomingCapturedFrame(CreateFrame(
       ViEEncoder::kMaxCpuDowngrades + 1, frame_width, frame_height));
   sink_.WaitForEncodedFrame(ViEEncoder::kMaxCpuDowngrades + 1);
   vie_encoder_->TriggerCpuOveruse();
   EXPECT_EQ(video_source_.sink_wants().max_pixel_count,
             current_wants.max_pixel_count);
   EXPECT_EQ(video_source_.sink_wants().max_pixel_count_step_up,
             current_wants.max_pixel_count_step_up);
@@ skipping 85 matching lines @@
       CreateFrame(3, frame_width, frame_height));
   sink_.WaitForEncodedFrame(3);
 
   stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_EQ(2, stats.number_of_cpu_adapt_changes);
 
   vie_encoder_->Stop();
 }
 
-TEST_F(ViEEncoderTest, StatsTracksAdaptationStatsWhenSwitchingSource) {
+TEST_F(ViEEncoderTest, SwitchingSourceKeepsCpuAdaptation) {
   const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
-  // Trigger CPU overuse.
-  vie_encoder_->TriggerCpuOveruse();
   int frame_width = 1280;
   int frame_height = 720;
-
   video_source_.IncomingCapturedFrame(
       CreateFrame(1, frame_width, frame_height));
   sink_.WaitForEncodedFrame(1);
 
   VideoSendStream::Stats stats = stats_proxy_->GetStats();
+  EXPECT_FALSE(stats.cpu_limited_resolution);
+  EXPECT_EQ(0, stats.number_of_cpu_adapt_changes);
+
+  vie_encoder_->TriggerCpuOveruse();
+
+  video_source_.IncomingCapturedFrame(
+      CreateFrame(2, frame_width, frame_height));
+  sink_.WaitForEncodedFrame(2);
+  stats = stats_proxy_->GetStats();
   EXPECT_TRUE(stats.cpu_limited_resolution);
   EXPECT_EQ(1, stats.number_of_cpu_adapt_changes);
 
   // Set new source with adaptation still enabled.
   test::FrameForwarder new_video_source;
   vie_encoder_->SetSource(&new_video_source,
                           VideoSendStream::DegradationPreference::kBalanced);
 
   new_video_source.IncomingCapturedFrame(
-      CreateFrame(2, frame_width, frame_height));
-  sink_.WaitForEncodedFrame(2);
+      CreateFrame(3, frame_width, frame_height));
+  sink_.WaitForEncodedFrame(3);
   stats = stats_proxy_->GetStats();
   EXPECT_TRUE(stats.cpu_limited_resolution);
   EXPECT_EQ(1, stats.number_of_cpu_adapt_changes);
 
   // Set adaptation disabled.
   vie_encoder_->SetSource(
       &new_video_source,
       VideoSendStream::DegradationPreference::kMaintainResolution);
+
   new_video_source.IncomingCapturedFrame(
-      CreateFrame(3, frame_width, frame_height));
-  sink_.WaitForEncodedFrame(3);
+      CreateFrame(4, frame_width, frame_height));
+  sink_.WaitForEncodedFrame(4);
   stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_EQ(1, stats.number_of_cpu_adapt_changes);
 
-  // Switch back the source with adaptation enabled.
-  vie_encoder_->SetSource(&video_source_,
+  // Set adaptation back to enabled.
+  vie_encoder_->SetSource(&new_video_source,
                           VideoSendStream::DegradationPreference::kBalanced);
-  video_source_.IncomingCapturedFrame(
-      CreateFrame(4, frame_width, frame_height));
-  sink_.WaitForEncodedFrame(4);
+
+  new_video_source.IncomingCapturedFrame(
+      CreateFrame(5, frame_width, frame_height));
+  sink_.WaitForEncodedFrame(5);
   stats = stats_proxy_->GetStats();
   EXPECT_TRUE(stats.cpu_limited_resolution);
   EXPECT_EQ(1, stats.number_of_cpu_adapt_changes);
 
-  // Trigger CPU normal usage.
   vie_encoder_->TriggerCpuNormalUsage();
-  video_source_.IncomingCapturedFrame(
-      CreateFrame(5, frame_width, frame_height));
-  sink_.WaitForEncodedFrame(5);
+
+  new_video_source.IncomingCapturedFrame(
+      CreateFrame(6, frame_width, frame_height));
+  sink_.WaitForEncodedFrame(6);
   stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_EQ(2, stats.number_of_cpu_adapt_changes);
 
   vie_encoder_->Stop();
 }
+
+TEST_F(ViEEncoderTest, SwitchingSourceKeepsQualityAdaptation) {
+  const int kTargetBitrateBps = 100000;
+  vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
+
+  int frame_width = 1280;
+  int frame_height = 720;
+  video_source_.IncomingCapturedFrame(
+      CreateFrame(1, frame_width, frame_height));
+  sink_.WaitForEncodedFrame(1);
+
+  VideoSendStream::Stats stats = stats_proxy_->GetStats();
+  EXPECT_FALSE(stats.cpu_limited_resolution);
+  EXPECT_FALSE(stats.bw_limited_resolution);
+  EXPECT_EQ(0, stats.number_of_cpu_adapt_changes);
+
+  // Set new source with adaptation still enabled.
+  test::FrameForwarder new_video_source;
+  vie_encoder_->SetSource(&new_video_source,
+                          VideoSendStream::DegradationPreference::kBalanced);
+
+  new_video_source.IncomingCapturedFrame(
+      CreateFrame(2, frame_width, frame_height));
+  sink_.WaitForEncodedFrame(2);
+  stats = stats_proxy_->GetStats();
+  EXPECT_FALSE(stats.cpu_limited_resolution);
+  EXPECT_FALSE(stats.bw_limited_resolution);
+  EXPECT_EQ(0, stats.number_of_cpu_adapt_changes);
+
+  vie_encoder_->TriggerQualityLow();
+
+  new_video_source.IncomingCapturedFrame(
+      CreateFrame(3, frame_width, frame_height));
+  sink_.WaitForEncodedFrame(3);
+  stats = stats_proxy_->GetStats();
+  EXPECT_FALSE(stats.cpu_limited_resolution);
+  EXPECT_TRUE(stats.bw_limited_resolution);
+
+  vie_encoder_->SetSource(&new_video_source,
+                          VideoSendStream::DegradationPreference::kBalanced);
+
+  new_video_source.IncomingCapturedFrame(
+      CreateFrame(4, frame_width, frame_height));
+  sink_.WaitForEncodedFrame(4);
+  stats = stats_proxy_->GetStats();
+  EXPECT_FALSE(stats.cpu_limited_resolution);
+  EXPECT_TRUE(stats.bw_limited_resolution);
+
+  // Set adaptation disabled.
+  vie_encoder_->SetSource(
+      &new_video_source,
+      VideoSendStream::DegradationPreference::kMaintainResolution);
+
+  new_video_source.IncomingCapturedFrame(
+      CreateFrame(5, frame_width, frame_height));
+  sink_.WaitForEncodedFrame(5);
+  stats = stats_proxy_->GetStats();
+  EXPECT_FALSE(stats.cpu_limited_resolution);
+  EXPECT_FALSE(stats.bw_limited_resolution);
+
+  vie_encoder_->Stop();
+}
 
 TEST_F(ViEEncoderTest, StatsTracksPreferredBitrate) {
   const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   video_source_.IncomingCapturedFrame(CreateFrame(1, 1280, 720));
   sink_.WaitForEncodedFrame(1);
 
   VideoSendStream::Stats stats = stats_proxy_->GetStats();
   EXPECT_EQ(video_encoder_config_.max_bitrate_bps,
             stats.preferred_media_bitrate_bps);
 
   vie_encoder_->Stop();
 }
 
+TEST_F(ViEEncoderTest, ScalingUpAndDownDoesNothingWithMaintainResolution) {
+  const int kTargetBitrateBps = 100000;
+  int frame_width = 1280;
+  int frame_height = 720;
+  vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
+
+  // Expect no scaling to begin with
+  EXPECT_FALSE(video_source_.sink_wants().max_pixel_count);
+  EXPECT_FALSE(video_source_.sink_wants().max_pixel_count_step_up);
+
+  // Trigger scale down
+  vie_encoder_->TriggerQualityLow();
+  video_source_.IncomingCapturedFrame(
+      CreateFrame(1, frame_width, frame_height));
+  sink_.WaitForEncodedFrame(1);
+
+  // Expect a scale down.
+  EXPECT_TRUE(video_source_.sink_wants().max_pixel_count);
+  EXPECT_LT(*video_source_.sink_wants().max_pixel_count,
+            frame_width * frame_height);
+
+  // Set adaptation disabled.
+  test::FrameForwarder new_video_source;
+  vie_encoder_->SetSource(
+      &new_video_source,
+      VideoSendStream::DegradationPreference::kMaintainResolution);
+
+  // Trigger scale down
+  vie_encoder_->TriggerQualityLow();
+  new_video_source.IncomingCapturedFrame(
+      CreateFrame(2, frame_width, frame_height));
+  sink_.WaitForEncodedFrame(2);
+
+  // Expect no scaling
+  EXPECT_FALSE(new_video_source.sink_wants().max_pixel_count);
+
+  // Trigger scale up
+  vie_encoder_->TriggerQualityHigh();
+  new_video_source.IncomingCapturedFrame(
+      CreateFrame(3, frame_width, frame_height));
+  sink_.WaitForEncodedFrame(3);
+
+  // Expect nothing to change, still no scaling
+  EXPECT_FALSE(new_video_source.sink_wants().max_pixel_count);
+
+  vie_encoder_->Stop();
+}
+
 TEST_F(ViEEncoderTest, UMACpuLimitedResolutionInPercent) {
   const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   int frame_width = 640;
   int frame_height = 360;
 
   for (int i = 1; i <= SendStatisticsProxy::kMinRequiredMetricsSamples; ++i) {
     video_source_.IncomingCapturedFrame(
         CreateFrame(i, frame_width, frame_height));
@@ skipping 12 matching lines @@
   vie_encoder_->Stop();
 
   stats_proxy_.reset();
   EXPECT_EQ(1,
             metrics::NumSamples("WebRTC.Video.CpuLimitedResolutionInPercent"));
   EXPECT_EQ(
       1, metrics::NumEvents("WebRTC.Video.CpuLimitedResolutionInPercent", 50));
 }
 
 }  // namespace webrtc