Change rtc::VideoSinkWants to have target and a max pixel count

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.
  */
 
@@ skipping 131 matching lines @@
       adapted_frame.set_ntp_time_ms(video_frame.ntp_time_ms());
       test::FrameForwarder::IncomingCapturedFrame(adapted_frame);
     } else {
       test::FrameForwarder::IncomingCapturedFrame(video_frame);
     }
   }
 
   void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
                        const rtc::VideoSinkWants& wants) override {
     rtc::CritScope cs(&crit_);
-    adapter_.OnResolutionRequest(wants.max_pixel_count,
-                                 wants.max_pixel_count_step_up);
+    adapter_.OnResolutionRequest(wants.target_pixel_count,
+                                 wants.max_pixel_count);
     test::FrameForwarder::AddOrUpdateSink(sink, wants);
   }
 
   cricket::VideoAdapter adapter_;
   bool adaptation_enabled_ GUARDED_BY(crit_);
 };
 }  // namespace
 
 class ViEEncoderTest : public ::testing::Test {
  public:
@@ skipping 441 matching lines @@
 TEST_F(ViEEncoderTest, SinkWantsRotationApplied) {
   EXPECT_FALSE(video_source_.sink_wants().rotation_applied);
   vie_encoder_->SetSink(&sink_, true /*rotation_applied*/);
   EXPECT_TRUE(video_source_.sink_wants().rotation_applied);
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, SinkWantsFromOveruseDetector) {
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
+  EXPECT_FALSE(video_source_.sink_wants().target_pixel_count);
   EXPECT_FALSE(video_source_.sink_wants().max_pixel_count);
-  EXPECT_FALSE(video_source_.sink_wants().max_pixel_count_step_up);
 
   int frame_width = 1280;
   int frame_height = 720;
 
   // Trigger CPU overuse kMaxCpuDowngrades times. Every time, ViEEncoder should
   // request lower resolution.
   for (int i = 1; i <= ViEEncoder::kMaxCpuDowngrades; ++i) {
     video_source_.IncomingCapturedFrame(
         CreateFrame(i, frame_width, frame_height));
     sink_.WaitForEncodedFrame(i);
 
     vie_encoder_->TriggerCpuOveruse();
 
+    EXPECT_FALSE(video_source_.sink_wants().target_pixel_count);
     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 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().target_pixel_count,
+            current_wants.target_pixel_count);
   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);
 
   // Trigger CPU normal use.
   vie_encoder_->TriggerCpuNormalUsage();
-  EXPECT_FALSE(video_source_.sink_wants().max_pixel_count);
-  EXPECT_EQ(video_source_.sink_wants().max_pixel_count_step_up.value_or(0),
-            frame_width * frame_height);
+  EXPECT_EQ(frame_width * frame_height * 5 / 3,
+            video_source_.sink_wants().target_pixel_count.value_or(0));
+  EXPECT_EQ(frame_width * frame_height * 4,
+            video_source_.sink_wants().max_pixel_count.value_or(0));
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest,
        ResolutionSinkWantsResetOnSetSourceWithDisabledResolutionScaling) {
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
+  EXPECT_FALSE(video_source_.sink_wants().target_pixel_count);
   EXPECT_FALSE(video_source_.sink_wants().max_pixel_count);
-  EXPECT_FALSE(video_source_.sink_wants().max_pixel_count_step_up);
 
   int frame_width = 1280;
   int frame_height = 720;
 
   video_source_.IncomingCapturedFrame(
       CreateFrame(1, frame_width, frame_height));
   sink_.WaitForEncodedFrame(1);
   // Trigger CPU overuse.
   vie_encoder_->TriggerCpuOveruse();
 
   video_source_.IncomingCapturedFrame(
       CreateFrame(2, frame_width, frame_height));
   sink_.WaitForEncodedFrame(2);
+  EXPECT_FALSE(video_source_.sink_wants().target_pixel_count);
   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);
 
   // Set new source.
   test::FrameForwarder new_video_source;
   vie_encoder_->SetSource(
       &new_video_source,
       VideoSendStream::DegradationPreference::kMaintainResolution);
 
+  EXPECT_FALSE(new_video_source.sink_wants().target_pixel_count);
   EXPECT_FALSE(new_video_source.sink_wants().max_pixel_count);
-  EXPECT_FALSE(new_video_source.sink_wants().max_pixel_count_step_up);
 
   new_video_source.IncomingCapturedFrame(
       CreateFrame(3, frame_width, frame_height));
   sink_.WaitForEncodedFrame(3);
+  EXPECT_FALSE(new_video_source.sink_wants().target_pixel_count);
   EXPECT_FALSE(new_video_source.sink_wants().max_pixel_count);
-  EXPECT_FALSE(new_video_source.sink_wants().max_pixel_count_step_up);
 
   // Calling SetSource with resolution scaling enabled apply the old SinkWants.
   vie_encoder_->SetSource(&new_video_source,
                           VideoSendStream::DegradationPreference::kBalanced);
   EXPECT_LT(new_video_source.sink_wants().max_pixel_count.value_or(
                 std::numeric_limits<int>::max()),
             frame_width * frame_height);
-  EXPECT_FALSE(new_video_source.sink_wants().max_pixel_count_step_up);
+  EXPECT_FALSE(new_video_source.sink_wants().target_pixel_count);
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, StatsTracksAdaptationStats) {
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   int frame_width = 1280;
   int frame_height = 720;
 
@@ skipping 155 matching lines @@
   stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_FALSE(stats.bw_limited_resolution);
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, StatsTracksAdaptationStatsWhenSwitchingSource) {
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
-  // Trigger CPU overuse.
-  vie_encoder_->TriggerCpuOveruse();
   int frame_width = 1280;
   int frame_height = 720;
+  int sequence = 1;
 
+  // Trigger CPU overuse, won't bite before first frame.
+  vie_encoder_->TriggerCpuOveruse();
   video_source_.IncomingCapturedFrame(
-      CreateFrame(1, frame_width, frame_height));
-  sink_.WaitForEncodedFrame(1);
+      CreateFrame(sequence, frame_width, frame_height));
+  sink_.WaitForEncodedFrame(sequence++);
 
   VideoSendStream::Stats stats = stats_proxy_->GetStats();
+  EXPECT_FALSE(stats.cpu_limited_resolution);
+  EXPECT_EQ(0, stats.number_of_cpu_adapt_changes);
+
+  // Trigger CPU overuse again, should now adapt down.
+  vie_encoder_->TriggerCpuOveruse();
+  video_source_.IncomingCapturedFrame(
+      CreateFrame(sequence, frame_width, frame_height));
+  sink_.WaitForEncodedFrame(sequence++);
+
+  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(sequence, frame_width, frame_height));
+  sink_.WaitForEncodedFrame(sequence++);
   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(sequence, frame_width, frame_height));
+  sink_.WaitForEncodedFrame(sequence++);
   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_,
                           VideoSendStream::DegradationPreference::kBalanced);
   video_source_.IncomingCapturedFrame(
-      CreateFrame(4, frame_width, frame_height));
-  sink_.WaitForEncodedFrame(4);
+      CreateFrame(sequence, frame_width, frame_height));
+  sink_.WaitForEncodedFrame(sequence++);
   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);
+      CreateFrame(sequence, frame_width, frame_height));
+  sink_.WaitForEncodedFrame(sequence++);
   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, StatsTracksPreferredBitrate) {
   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().target_pixel_count);
   EXPECT_FALSE(video_source_.sink_wants().max_pixel_count);
-  EXPECT_FALSE(video_source_.sink_wants().max_pixel_count_step_up);
 
   video_source_.IncomingCapturedFrame(
       CreateFrame(1, frame_width, frame_height));
   sink_.WaitForEncodedFrame(1);
 
   // Trigger scale down
   vie_encoder_->TriggerQualityLow();
 
   video_source_.IncomingCapturedFrame(
       CreateFrame(2, frame_width, frame_height));
@@ skipping 145 matching lines @@
 
   // Trigger CPU normal use, return to original resoluton;
   vie_encoder_->TriggerCpuNormalUsage();
   video_source_.IncomingCapturedFrame(
       CreateFrame(3, kFrameWidth, kFrameHeight));
   sink_.WaitForEncodedFrame(kFrameWidth, kFrameHeight);
 
   vie_encoder_->Stop();
 }
 }  // namespace webrtc