Update sink wants with ranges for both pixel count and frame rate.

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 11 matching lines @@
 #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/vie_encoder.h"
 
 namespace {
 #if defined(WEBRTC_ANDROID)
 // TODO(kthelgason): Lower this limit when better testing
 // on MediaCodec and fallback implementations are in place.
-const int kMinPixelsPerFrame = 320 * 180;
+const uint32_t kMinPixelsPerFrame = 320 * 180;
 #else
-const int kMinPixelsPerFrame = 120 * 90;
+const uint32_t kMinPixelsPerFrame = 120 * 90;
 #endif
 }
 
 namespace webrtc {
 
 using DegredationPreference = VideoSendStream::DegradationPreference;
 using ScaleReason = AdaptationObserverInterface::AdaptReason;
 using ::testing::_;
 using ::testing::Return;
 
@@ skipping 99 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.target_pixel_count,
-                                 wants.max_pixel_count);
+    adapter_.OnSinkWantsUpdated(wants);
     test::FrameForwarder::AddOrUpdateSink(sink, wants);
   }
 
   cricket::VideoAdapter adapter_;
   bool adaptation_enabled_ GUARDED_BY(crit_);
 };
 }  // namespace
 
 class ViEEncoderTest : public ::testing::Test {
  public:
@@ skipping 448 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().pixel_count);
 
   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);
+    ASSERT_TRUE(static_cast<bool>(video_source_.sink_wants().pixel_count));
+    EXPECT_LT(video_source_.sink_wants().pixel_count->max,
+              static_cast<uint32_t>(frame_width * frame_height));
 
     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);
+  ASSERT_TRUE(static_cast<bool>(video_source_.sink_wants().pixel_count));
+  ASSERT_TRUE(static_cast<bool>(current_wants.pixel_count));
+  EXPECT_EQ(video_source_.sink_wants().pixel_count->min,
+            current_wants.pixel_count->min);
+  EXPECT_EQ(video_source_.sink_wants().pixel_count->target,
+            current_wants.pixel_count->target);
+  EXPECT_EQ(video_source_.sink_wants().pixel_count->max,
+            current_wants.pixel_count->max);
 
   // Trigger CPU normal use.
   vie_encoder_->TriggerCpuNormalUsage();
-  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));
+  EXPECT_GT(video_source_.sink_wants().pixel_count->min, 0U);
+  EXPECT_LE(video_source_.sink_wants().pixel_count->min,
+            video_source_.sink_wants().pixel_count->target);
+  EXPECT_EQ(static_cast<uint32_t>(frame_width * frame_height * 5 / 3),
+            video_source_.sink_wants().pixel_count->target);
+  EXPECT_EQ(static_cast<uint32_t>(frame_width * frame_height * 4),
+            video_source_.sink_wants().pixel_count->max);
 
   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(static_cast<bool>(video_source_.sink_wants().pixel_count));
 
   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);
+  ASSERT_TRUE(static_cast<bool>(video_source_.sink_wants().pixel_count));
+  EXPECT_LT(video_source_.sink_wants().pixel_count->max,
+            static_cast<uint32_t>(frame_width * frame_height));
 
   // 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(static_cast<bool>(video_source_.sink_wants().pixel_count));
 
   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(static_cast<bool>(video_source_.sink_wants().pixel_count));
 
   // 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().target_pixel_count);
+  ASSERT_TRUE(static_cast<bool>(video_source_.sink_wants().pixel_count));
+  EXPECT_LT(video_source_.sink_wants().pixel_count->max,
+            static_cast<uint32_t>(frame_width * frame_height));
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, StatsTracksAdaptationStats) {
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   int frame_width = 1280;
   int frame_height = 720;
 
@@ skipping 238 matching lines @@
             stats.preferred_media_bitrate_bps);
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, ScalingUpAndDownDoesNothingWithMaintainResolution) {
   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 no scaling to begin with.
+  EXPECT_FALSE(static_cast<bool>(video_source_.sink_wants().pixel_count));
 
   video_source_.IncomingCapturedFrame(
       CreateFrame(1, frame_width, frame_height));
   sink_.WaitForEncodedFrame(1);
 
-  // Trigger scale down
+  // Trigger scale down.
   vie_encoder_->TriggerQualityLow();
 
   video_source_.IncomingCapturedFrame(
       CreateFrame(2, frame_width, frame_height));
   sink_.WaitForEncodedFrame(2);
 
   // 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);
+  ASSERT_TRUE(static_cast<bool>(video_source_.sink_wants().pixel_count));
+  EXPECT_LT(video_source_.sink_wants().pixel_count->max,
+            static_cast<uint32_t>(frame_width * frame_height));
 
   // Set adaptation disabled.
   test::FrameForwarder new_video_source;
   vie_encoder_->SetSource(
       &new_video_source,
       VideoSendStream::DegradationPreference::kMaintainResolution);
 
-  // Trigger scale down
+  // Trigger scale down.
   vie_encoder_->TriggerQualityLow();
   new_video_source.IncomingCapturedFrame(
       CreateFrame(3, frame_width, frame_height));
   sink_.WaitForEncodedFrame(3);
 
-  // Expect no scaling
-  EXPECT_FALSE(new_video_source.sink_wants().max_pixel_count);
+  // Expect no scaling.
+  EXPECT_FALSE(static_cast<bool>(video_source_.sink_wants().pixel_count));
 
-  // Trigger scale up
+  // Trigger scale up.
   vie_encoder_->TriggerQualityHigh();
   new_video_source.IncomingCapturedFrame(
       CreateFrame(4, frame_width, frame_height));
   sink_.WaitForEncodedFrame(4);
 
-  // Expect nothing to change, still no scaling
-  EXPECT_FALSE(new_video_source.sink_wants().max_pixel_count);
+  // Expect nothing to change, still no scaling.
+  EXPECT_FALSE(static_cast<bool>(video_source_.sink_wants().pixel_count));
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, DoesNotScaleBelowSetLimit) {
   int frame_width = 1280;
   int frame_height = 720;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   for (size_t i = 1; i <= 10; i++) {
     video_source_.IncomingCapturedFrame(
         CreateFrame(i, frame_width, frame_height));
     sink_.WaitForEncodedFrame(i);
     // Trigger scale down
     vie_encoder_->TriggerQualityLow();
-    EXPECT_GE(*video_source_.sink_wants().max_pixel_count, kMinPixelsPerFrame);
+    ASSERT_TRUE(video_source_.sink_wants().pixel_count);
+    EXPECT_GE(video_source_.sink_wants().pixel_count->min, kMinPixelsPerFrame);
+    EXPECT_GE(video_source_.sink_wants().pixel_count->max, kMinPixelsPerFrame);
   }
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, UMACpuLimitedResolutionInPercent) {
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   int frame_width = 640;
   int frame_height = 360;
@@ skipping 71 matching lines @@
   int frame_width = 640;
   int frame_height = 360;
 
   video_source_.IncomingCapturedFrame(
       CreateFrame(1, frame_width, frame_height));
 
   // Expect to drop this frame, the wait should time out.
   sink_.ExpectDroppedFrame();
 
   // Expect the sink_wants to specify a scaled frame.
-  EXPECT_TRUE(video_source_.sink_wants().max_pixel_count);
-  EXPECT_LT(*video_source_.sink_wants().max_pixel_count, 1000 * 1000);
+  ASSERT_TRUE(static_cast<bool>(video_source_.sink_wants().pixel_count));
+  EXPECT_LT(video_source_.sink_wants().pixel_count->max,
+            static_cast<uint32_t>(1000 * 1000));
 
-  int last_pixel_count = *video_source_.sink_wants().max_pixel_count;
+  int last_pixel_count = video_source_.sink_wants().pixel_count->max;
 
-  // Next frame is scaled
+  // Next frame is scaled.
   video_source_.IncomingCapturedFrame(
       CreateFrame(2, frame_width * 3 / 4, frame_height * 3 / 4));
 
   // Expect to drop this frame, the wait should time out.
   sink_.ExpectDroppedFrame();
 
-  EXPECT_LT(*video_source_.sink_wants().max_pixel_count, last_pixel_count);
+  EXPECT_LT(video_source_.sink_wants().pixel_count->max,
+            static_cast<uint32_t>(last_pixel_count));
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, NrOfDroppedFramesLimited) {
   // 1kbps. This can never be achieved.
   vie_encoder_->OnBitrateUpdated(1000, 0, 0);
   int frame_width = 640;
   int frame_height = 360;
 
   // We expect the n initial frames to get dropped.
   int i;
   for (i = 1; i <= kMaxInitialFramedrop; ++i) {
     video_source_.IncomingCapturedFrame(
         CreateFrame(i, frame_width, frame_height));
     sink_.ExpectDroppedFrame();
   }
   // The n+1th frame should not be dropped, even though it's size is too large.
   video_source_.IncomingCapturedFrame(
       CreateFrame(i, frame_width, frame_height));
   sink_.WaitForEncodedFrame(i);
 
   // Expect the sink_wants to specify a scaled frame.
-  EXPECT_TRUE(video_source_.sink_wants().max_pixel_count);
-  EXPECT_LT(*video_source_.sink_wants().max_pixel_count, 1000 * 1000);
+  ASSERT_TRUE(static_cast<bool>(video_source_.sink_wants().pixel_count));
+  EXPECT_LT(video_source_.sink_wants().pixel_count->max,
+            static_cast<uint32_t>(1000 * 1000));
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, InitialFrameDropOffWithMaintainResolutionPreference) {
   int frame_width = 640;
   int frame_height = 360;
   vie_encoder_->OnBitrateUpdated(kLowTargetBitrateBps, 0, 0);
 
   // Set degradation preference.
@@ skipping 49 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