Rename adaptation api methods, extended vie_encoder unit test.

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/api/video/i420_buffer.h"
 #include "webrtc/base/logging.h"
+#include "webrtc/media/base/videoadapter.h"
 #include "webrtc/modules/video_coding/utility/default_video_bitrate_allocator.h"
 #include "webrtc/system_wrappers/include/metrics_default.h"
 #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/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;
 #else
 const int kMinPixelsPerFrame = 120 * 90;
 #endif
 }
 
 namespace webrtc {
 
 using DegredationPreference = VideoSendStream::DegradationPreference;
-using ScaleReason = ScalingObserverInterface::ScaleReason;
+using ScaleReason = AdaptationObserverInterface::AdaptReason;
 using ::testing::_;
 using ::testing::Return;
 
 namespace {
 const size_t kMaxPayloadLength = 1440;
 const int kTargetBitrateBps = 100000;
 
 class TestBuffer : public webrtc::I420Buffer {
  public:
   TestBuffer(rtc::Event* event, int width, int height)
@@ skipping 11 matching lines @@
 class ViEEncoderUnderTest : public ViEEncoder {
  public:
   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 PostTaskAndWait(bool down, ScaleReason reason) {
+  void PostTaskAndWait(bool down, AdaptReason reason) {
     rtc::Event event(false, false);
     encoder_queue()->PostTask([this, &event, reason, down] {
-      down ? ScaleDown(reason) : ScaleUp(reason);
+      down ? AdaptDown(reason) : AdaptUp(reason);
       event.Set();
     });
     RTC_DCHECK(event.Wait(5000));
   }
 
-  void TriggerCpuOveruse() { PostTaskAndWait(true, ScaleReason::kCpu); }
+  void TriggerCpuOveruse() { PostTaskAndWait(true, AdaptReason::kCpu); }
 
-  void TriggerCpuNormalUsage() { PostTaskAndWait(false, ScaleReason::kCpu); }
+  void TriggerCpuNormalUsage() { PostTaskAndWait(false, AdaptReason::kCpu); }
 
-  void TriggerQualityLow() { PostTaskAndWait(true, ScaleReason::kQuality); }
+  void TriggerQualityLow() { PostTaskAndWait(true, AdaptReason::kQuality); }
 
-  void TriggerQualityHigh() { PostTaskAndWait(false, ScaleReason::kQuality); }
+  void TriggerQualityHigh() { PostTaskAndWait(false, AdaptReason::kQuality); }
 };
 
 class VideoStreamFactory
     : public VideoEncoderConfig::VideoStreamFactoryInterface {
  public:
   explicit VideoStreamFactory(size_t num_temporal_layers)
       : num_temporal_layers_(num_temporal_layers) {
     EXPECT_GT(num_temporal_layers, 0u);
   }
 
  private:
   std::vector<VideoStream> CreateEncoderStreams(
       int width,
       int height,
       const VideoEncoderConfig& encoder_config) override {
     std::vector<VideoStream> streams =
         test::CreateVideoStreams(width, height, encoder_config);
     for (VideoStream& stream : streams) {
       stream.temporal_layer_thresholds_bps.resize(num_temporal_layers_ - 1);
     }
     return streams;
   }
   const size_t num_temporal_layers_;
 };
 
+class AdaptingFrameForwarder : public test::FrameForwarder {
+ public:
+  AdaptingFrameForwarder() : adaptation_enabled_(false) {}
+  virtual ~AdaptingFrameForwarder() {}
+
+  void set_adaptation_enabled(bool enabled) {
+    rtc::CritScope cs(&crit_);
+    adaptation_enabled_ = enabled;
+  }
+
+  bool adaption_enabled() {
+    rtc::CritScope cs(&crit_);
+    return adaptation_enabled_;
+  }
+
+  void IncomingCapturedFrame(const VideoFrame& video_frame) override {
+    int cropped_width = 0;
+    int cropped_height = 0;
+    int out_width = 0;
+    int out_height = 0;
+    if (adaption_enabled() &&
+        adapter_.AdaptFrameResolution(video_frame.width(), video_frame.height(),
+                                      video_frame.timestamp_us() * 1000,
+                                      &cropped_width, &cropped_height,
+                                      &out_width, &out_height)) {
+      VideoFrame adapted_frame(
+          new rtc::RefCountedObject<TestBuffer>(nullptr, out_width, out_height),
+          99, 99, kVideoRotation_0);
+      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);
+    test::FrameForwarder::AddOrUpdateSink(sink, wants);
+  }
+
+  cricket::VideoAdapter adapter_;
+  bool adaptation_enabled_ GUARDED_BY(crit_);
+};
 }  // namespace
 
 class ViEEncoderTest : public ::testing::Test {
  public:
   static const int kDefaultTimeoutMs = 30 * 1000;
 
   ViEEncoderTest()
       : video_send_config_(VideoSendStream::Config(nullptr)),
         codec_width_(320),
         codec_height_(240),
@@ skipping 128 matching lines @@
   class TestSink : public ViEEncoder::EncoderSink {
    public:
     explicit TestSink(TestEncoder* test_encoder)
         : test_encoder_(test_encoder), encoded_frame_event_(false, false) {}
 
     void WaitForEncodedFrame(int64_t expected_ntp_time) {
       uint32_t timestamp = 0;
       EXPECT_TRUE(encoded_frame_event_.Wait(kDefaultTimeoutMs));
       {
         rtc::CritScope lock(&crit_);
-        timestamp = timestamp_;
+        timestamp = last_timestamp_;
       }
       test_encoder_->CheckLastTimeStampsMatch(expected_ntp_time, timestamp);
     }
 
+    void WaitForEncodedFrame(uint32_t expected_width,
+                             uint32_t expected_height) {
+      uint32_t width = 0;
+      uint32_t height = 0;
+      EXPECT_TRUE(encoded_frame_event_.Wait(kDefaultTimeoutMs));
+      {
+        rtc::CritScope lock(&crit_);
+        width = last_width_;
+        height = last_height_;
+      }
+      EXPECT_EQ(expected_height, height);
+      EXPECT_EQ(expected_width, width);
+    }
+
     void SetExpectNoFrames() {
       rtc::CritScope lock(&crit_);
       expect_frames_ = false;
     }
 
     int number_of_reconfigurations() {
       rtc::CritScope lock(&crit_);
       return number_of_reconfigurations_;
     }
 
     int last_min_transmit_bitrate() {
       rtc::CritScope lock(&crit_);
       return min_transmit_bitrate_bps_;
     }
 
    private:
     Result OnEncodedImage(
         const EncodedImage& encoded_image,
         const CodecSpecificInfo* codec_specific_info,
         const RTPFragmentationHeader* fragmentation) override {
       rtc::CritScope lock(&crit_);
       EXPECT_TRUE(expect_frames_);
-      timestamp_ = encoded_image._timeStamp;
+      last_timestamp_ = encoded_image._timeStamp;
+      last_width_ = encoded_image._encodedWidth;
+      last_height_ = encoded_image._encodedHeight;
       encoded_frame_event_.Set();
-      return Result(Result::OK, timestamp_);
+      return Result(Result::OK, last_timestamp_);
     }
 
     void OnEncoderConfigurationChanged(std::vector<VideoStream> streams,
                                        int min_transmit_bitrate_bps) override {
       rtc::CriticalSection crit_;
       ++number_of_reconfigurations_;
       min_transmit_bitrate_bps_ = min_transmit_bitrate_bps;
     }
 
     rtc::CriticalSection crit_;
     TestEncoder* test_encoder_;
     rtc::Event encoded_frame_event_;
-    uint32_t timestamp_ = 0;
+    uint32_t last_timestamp_ = 0;
+    uint32_t last_height_ = 0;
+    uint32_t last_width_ = 0;
     bool expect_frames_ = true;
     int number_of_reconfigurations_ = 0;
     int min_transmit_bitrate_bps_ = 0;
   };
 
   VideoSendStream::Config video_send_config_;
   VideoEncoderConfig video_encoder_config_;
   int codec_width_;
   int codec_height_;
   TestEncoder fake_encoder_;
   std::unique_ptr<SendStatisticsProxy> stats_proxy_;
   TestSink sink_;
-  test::FrameForwarder video_source_;
+  AdaptingFrameForwarder video_source_;
   std::unique_ptr<ViEEncoderUnderTest> vie_encoder_;
 };
 
 TEST_F(ViEEncoderTest, EncodeOneFrame) {
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
   rtc::Event frame_destroyed_event(false, false);
   video_source_.IncomingCapturedFrame(CreateFrame(1, &frame_destroyed_event));
   sink_.WaitForEncodedFrame(1);
   EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeoutMs));
   vie_encoder_->Stop();
@@ skipping 695 matching lines @@
   SleepMs(kProcessIntervalMs + 1000 / kDefaultFps);
   EXPECT_CALL(bitrate_observer, OnBitrateAllocationUpdated(expected_bitrate))
       .Times(1);
   video_source_.IncomingCapturedFrame(CreateFrame(
       kStartTimeMs + kProcessIntervalMs, codec_width_, codec_height_));
   sink_.WaitForEncodedFrame(kStartTimeMs + kProcessIntervalMs);
 
   vie_encoder_->Stop();
 }
 
+// TODO(sprang): Extend this with fps throttling and any "balanced" extensions.
+TEST_F(ViEEncoderTest, AdaptsResolutionOnOveruse) {
+  vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
+
+  const int kFrameWidth = 1280;
+  const int kFrameHeight = 720;
+  // Enabled default VideoAdapter downscaling. First step is 3/4, not 3/5 as
+  // requested by ViEEncoder::VideoSourceProxy::RequestResolutionLowerThan().
+  video_source_.set_adaptation_enabled(true);
+
+  video_source_.IncomingCapturedFrame(
+      CreateFrame(1, kFrameWidth, kFrameHeight));
+  sink_.WaitForEncodedFrame(kFrameWidth, kFrameHeight);
+
+  // Trigger CPU overuse, downscale by 3/4.
+  vie_encoder_->TriggerCpuOveruse();
+  video_source_.IncomingCapturedFrame(
+      CreateFrame(2, kFrameWidth, kFrameHeight));
+  sink_.WaitForEncodedFrame((kFrameWidth * 3) / 4, (kFrameHeight * 3) / 4);
+
+  // 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