Extract bitrate allocation of spatial/temporal layers out of codec impl.

webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc

 /*
  *  Copyright (c) 2014 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 77 matching lines @@
 }
 
 TEST_F(TestSimulcastEncoderAdapter, TestSaptioTemporalLayers333PatternEncoder) {
   TestVp8Simulcast::TestSaptioTemporalLayers333PatternEncoder();
 }
 
 TEST_F(TestSimulcastEncoderAdapter, TestSpatioTemporalLayers321PatternEncoder) {
   TestVp8Simulcast::TestSpatioTemporalLayers321PatternEncoder();
 }
 
-// TODO(ronghuawu): Enable this test when SkipEncodingUnusedStreams option is
-// implemented for SimulcastEncoderAdapter.
-TEST_F(TestSimulcastEncoderAdapter, DISABLED_TestSkipEncodingUnusedStreams) {
-  TestVp8Simulcast::TestSkipEncodingUnusedStreams();
-}
-
 TEST_F(TestSimulcastEncoderAdapter, DISABLED_TestRPSIEncoder) {
   TestVp8Simulcast::TestRPSIEncoder();
 }
 
 class MockVideoEncoder : public VideoEncoder {
  public:
   // TODO(nisse): Valid overrides commented out, because the gmock
   // methods don't use any override declarations, and we want to avoid
   // warnings from -Winconsistent-missing-override. See
   // http://crbug.com/428099.
@@ skipping 11 matching lines @@
               const std::vector<FrameType>* frame_types) /* override */);
 
   int32_t RegisterEncodeCompleteCallback(
       EncodedImageCallback* callback) /* override */ {
     callback_ = callback;
     return 0;
   }
 
   int32_t Release() /* override */ { return 0; }
 
-  int32_t SetRates(uint32_t newBitRate, uint32_t frameRate) /* override */ {
-    last_set_bitrate_ = static_cast<int32_t>(newBitRate);
+  int32_t SetRateAllocation(const BitrateAllocation& bitrate_allocation,
+                            uint32_t framerate) {
+    last_set_bitrate_ = bitrate_allocation;
     return 0;
   }
 
   MOCK_METHOD2(SetChannelParameters, int32_t(uint32_t packetLoss, int64_t rtt));
 
   bool SupportsNativeHandle() const /* override */ {
     return supports_native_handle_;
   }
 
   virtual ~MockVideoEncoder() {}
 
   const VideoCodec& codec() const { return codec_; }
 
   void SendEncodedImage(int width, int height) {
     // Sends a fake image of the given width/height.
     EncodedImage image;
     image._encodedWidth = width;
     image._encodedHeight = height;
     CodecSpecificInfo codecSpecificInfo;
     memset(&codecSpecificInfo, 0, sizeof(codecSpecificInfo));
     callback_->Encoded(image, &codecSpecificInfo, NULL);
   }
 
   void set_supports_native_handle(bool enabled) {
     supports_native_handle_ = enabled;
   }
-  int32_t last_set_bitrate() const { return last_set_bitrate_; }
+  BitrateAllocation last_set_bitrate() const { return last_set_bitrate_; }
 
   MOCK_CONST_METHOD0(ImplementationName, const char*());
 
  private:
   bool supports_native_handle_ = false;
-  int32_t last_set_bitrate_ = -1;
+  BitrateAllocation last_set_bitrate_;
 
   VideoCodec codec_;
   EncodedImageCallback* callback_;
 };
 
 class MockVideoEncoderFactory : public VideoEncoderFactory {
  public:
   VideoEncoder* Create() override {
     MockVideoEncoder* encoder = new
         ::testing::NiceMock<MockVideoEncoder>();
@@ skipping 86 matching lines @@
     }
     *out_width = last_encoded_image_width_;
     *out_height = last_encoded_image_height_;
     *out_simulcast_index = last_encoded_image_simulcast_index_;
     return true;
   }
 
   void SetupCodec() {
     TestVp8Simulcast::DefaultSettings(
         &codec_, static_cast<const int*>(kTestTemporalLayerProfile));
+    rate_allocator_.reset(new SimulcastRateAllocator(codec_, nullptr));
+    tl_factory_.SetListener(rate_allocator_.get());
+    codec_.codecSpecific.VP8.tl_factory = &tl_factory_;
     EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
     adapter_->RegisterEncodeCompleteCallback(this);
   }
 
   void VerifyCodec(const VideoCodec& ref, int stream_index) {
     const VideoCodec& target =
         helper_->factory()->encoders()[stream_index]->codec();
     EXPECT_EQ(ref.codecType, target.codecType);
     EXPECT_EQ(0, strcmp(ref.plName, target.plName));
     EXPECT_EQ(ref.plType, target.plType);
@@ skipping 16 matching lines @@
     EXPECT_EQ(ref.codecSpecific.VP8.denoisingOn,
               target.codecSpecific.VP8.denoisingOn);
     EXPECT_EQ(ref.codecSpecific.VP8.errorConcealmentOn,
               target.codecSpecific.VP8.errorConcealmentOn);
     EXPECT_EQ(ref.codecSpecific.VP8.automaticResizeOn,
               target.codecSpecific.VP8.automaticResizeOn);
     EXPECT_EQ(ref.codecSpecific.VP8.frameDroppingOn,
               target.codecSpecific.VP8.frameDroppingOn);
     EXPECT_EQ(ref.codecSpecific.VP8.keyFrameInterval,
               target.codecSpecific.VP8.keyFrameInterval);
-    EXPECT_EQ(ref.codecSpecific.VP8.tl_factory,
-              target.codecSpecific.VP8.tl_factory);
     EXPECT_EQ(ref.qpMax, target.qpMax);
     EXPECT_EQ(0, target.numberOfSimulcastStreams);
     EXPECT_EQ(ref.mode, target.mode);
 
     // No need to compare simulcastStream as numberOfSimulcastStreams should
     // always be 0.
   }
 
   void InitRefCodec(int stream_index, VideoCodec* ref_codec) {
     *ref_codec = codec_;
     ref_codec->codecSpecific.VP8.numberOfTemporalLayers =
         kTestTemporalLayerProfile[stream_index];
+    ref_codec->codecSpecific.VP8.tl_factory = &tl_factory_;
     ref_codec->width = codec_.simulcastStream[stream_index].width;
     ref_codec->height = codec_.simulcastStream[stream_index].height;
     ref_codec->maxBitrate = codec_.simulcastStream[stream_index].maxBitrate;
     ref_codec->minBitrate = codec_.simulcastStream[stream_index].minBitrate;
     ref_codec->qpMax = codec_.simulcastStream[stream_index].qpMax;
   }
 
   void VerifyCodecSettings() {
     EXPECT_EQ(3u, helper_->factory()->encoders().size());
     VideoCodec ref_codec;
@@ skipping 23 matching lines @@
     VerifyCodec(ref_codec, 2);
   }
 
  protected:
   std::unique_ptr<TestSimulcastEncoderAdapterFakeHelper> helper_;
   std::unique_ptr<VP8Encoder> adapter_;
   VideoCodec codec_;
   int last_encoded_image_width_;
   int last_encoded_image_height_;
   int last_encoded_image_simulcast_index_;
+  TemporalLayersFactory tl_factory_;
+  std::unique_ptr<SimulcastRateAllocator> rate_allocator_;
 };
 
 TEST_F(TestSimulcastEncoderAdapterFake, InitEncode) {
   SetupCodec();
   VerifyCodecSettings();
 }
 
 TEST_F(TestSimulcastEncoderAdapterFake, SetChannelParameters) {
   SetupCodec();
   const uint32_t packetLoss = 5;
   const int64_t rtt = 30;
   helper_->ExpectCallSetChannelParameters(packetLoss, rtt);
   adapter_->SetChannelParameters(packetLoss, rtt);
 }
 
 TEST_F(TestSimulcastEncoderAdapterFake, EncodedCallbackForDifferentEncoders) {
   SetupCodec();
 
   // Set bitrates so that we send all layers.
-  adapter_->SetRates(1200, 30);
+  adapter_->SetRateAllocation(rate_allocator_->GetAllocation(1200, 30), 30);
 
   // At this point, the simulcast encoder adapter should have 3 streams: HD,
   // quarter HD, and quarter quarter HD. We're going to mostly ignore the exact
   // resolutions, to test that the adapter forwards on the correct resolution
   // and simulcast index values, going only off the encoder that generates the
   // image.
   EXPECT_EQ(3u, helper_->factory()->encoders().size());
   helper_->factory()->encoders()[0]->SendEncodedImage(1152, 704);
   int width;
   int height;
@@ skipping 12 matching lines @@
   helper_->factory()->encoders()[2]->SendEncodedImage(120, 240);
   EXPECT_TRUE(GetLastEncodedImageInfo(&width, &height, &simulcast_index));
   EXPECT_EQ(120, width);
   EXPECT_EQ(240, height);
   EXPECT_EQ(2, simulcast_index);
 }
 
 TEST_F(TestSimulcastEncoderAdapterFake, SupportsNativeHandleForSingleStreams) {
   TestVp8Simulcast::DefaultSettings(
       &codec_, static_cast<const int*>(kTestTemporalLayerProfile));
+  codec_.codecSpecific.VP8.tl_factory = &tl_factory_;
   codec_.numberOfSimulcastStreams = 1;
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
   adapter_->RegisterEncodeCompleteCallback(this);
   ASSERT_EQ(1u, helper_->factory()->encoders().size());
   helper_->factory()->encoders()[0]->set_supports_native_handle(true);
   EXPECT_TRUE(adapter_->SupportsNativeHandle());
   helper_->factory()->encoders()[0]->set_supports_native_handle(false);
   EXPECT_FALSE(adapter_->SupportsNativeHandle());
 }
 
 TEST_F(TestSimulcastEncoderAdapterFake, SetRatesUnderMinBitrate) {
   TestVp8Simulcast::DefaultSettings(
       &codec_, static_cast<const int*>(kTestTemporalLayerProfile));
+  codec_.codecSpecific.VP8.tl_factory = &tl_factory_;
   codec_.minBitrate = 50;
   codec_.numberOfSimulcastStreams = 1;
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
+  rate_allocator_.reset(new SimulcastRateAllocator(codec_, nullptr));
 
   // Above min should be respected.
-  adapter_->SetRates(100, 30);
-  EXPECT_EQ(100, helper_->factory()->encoders()[0]->last_set_bitrate());
+  BitrateAllocation target_bitrate =
+      rate_allocator_->GetAllocation(codec_.minBitrate * 1000, 30);
+  adapter_->SetRateAllocation(target_bitrate, 30);
+  EXPECT_EQ(target_bitrate,
+            helper_->factory()->encoders()[0]->last_set_bitrate());
 
   // Below min but non-zero should be replaced with the min bitrate.
-  adapter_->SetRates(15, 30);
-  EXPECT_EQ(50, helper_->factory()->encoders()[0]->last_set_bitrate());
+  BitrateAllocation too_low_bitrate =
+      rate_allocator_->GetAllocation((codec_.minBitrate - 1) * 1000, 30);
+  adapter_->SetRateAllocation(too_low_bitrate, 30);
+  EXPECT_EQ(target_bitrate,
+            helper_->factory()->encoders()[0]->last_set_bitrate());
 
   // Zero should be passed on as is, since it means "pause".
-  adapter_->SetRates(0, 30);
-  EXPECT_EQ(0, helper_->factory()->encoders()[0]->last_set_bitrate());
+  adapter_->SetRateAllocation(BitrateAllocation(), 30);
+  EXPECT_EQ(BitrateAllocation(),
+            helper_->factory()->encoders()[0]->last_set_bitrate());
 }
 
 TEST_F(TestSimulcastEncoderAdapterFake, SupportsImplementationName) {
   EXPECT_STREQ("SimulcastEncoderAdapter", adapter_->ImplementationName());
   TestVp8Simulcast::DefaultSettings(
       &codec_, static_cast<const int*>(kTestTemporalLayerProfile));
+  codec_.codecSpecific.VP8.tl_factory = &tl_factory_;
   std::vector<const char*> encoder_names;
   encoder_names.push_back("codec1");
   encoder_names.push_back("codec2");
   encoder_names.push_back("codec3");
   helper_->factory()->SetEncoderNames(encoder_names);
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
   EXPECT_STREQ("SimulcastEncoderAdapter (codec1, codec2, codec3)",
                adapter_->ImplementationName());
 
   // Single streams should not expose "SimulcastEncoderAdapter" in name.
   adapter_->Release();
   codec_.numberOfSimulcastStreams = 1;
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
   adapter_->RegisterEncodeCompleteCallback(this);
   ASSERT_EQ(1u, helper_->factory()->encoders().size());
   EXPECT_STREQ("codec1", adapter_->ImplementationName());
 }
 
 TEST_F(TestSimulcastEncoderAdapterFake,
        SupportsNativeHandleForMultipleStreams) {
   TestVp8Simulcast::DefaultSettings(
       &codec_, static_cast<const int*>(kTestTemporalLayerProfile));
+  codec_.codecSpecific.VP8.tl_factory = &tl_factory_;
   codec_.numberOfSimulcastStreams = 3;
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
   adapter_->RegisterEncodeCompleteCallback(this);
   ASSERT_EQ(3u, helper_->factory()->encoders().size());
   for (MockVideoEncoder* encoder : helper_->factory()->encoders())
     encoder->set_supports_native_handle(true);
   // If one encoder doesn't support it, then overall support is disabled.
   helper_->factory()->encoders()[0]->set_supports_native_handle(false);
   EXPECT_FALSE(adapter_->SupportsNativeHandle());
   // Once all do, then the adapter claims support.
   helper_->factory()->encoders()[0]->set_supports_native_handle(true);
   EXPECT_TRUE(adapter_->SupportsNativeHandle());
 }
 
 class FakeNativeHandleBuffer : public NativeHandleBuffer {
  public:
   FakeNativeHandleBuffer(void* native_handle, int width, int height)
       : NativeHandleBuffer(native_handle, width, height) {}
   rtc::scoped_refptr<VideoFrameBuffer> NativeToI420Buffer() override {
     RTC_NOTREACHED();
     return nullptr;
   }
 };
 
 TEST_F(TestSimulcastEncoderAdapterFake,
        NativeHandleForwardingForMultipleStreams) {
   TestVp8Simulcast::DefaultSettings(
       &codec_, static_cast<const int*>(kTestTemporalLayerProfile));
+  codec_.codecSpecific.VP8.tl_factory = &tl_factory_;
   codec_.numberOfSimulcastStreams = 3;
   // High start bitrate, so all streams are enabled.
   codec_.startBitrate = 3000;
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
   adapter_->RegisterEncodeCompleteCallback(this);
   ASSERT_EQ(3u, helper_->factory()->encoders().size());
   for (MockVideoEncoder* encoder : helper_->factory()->encoders())
     encoder->set_supports_native_handle(true);
   EXPECT_TRUE(adapter_->SupportsNativeHandle());
 
   rtc::scoped_refptr<VideoFrameBuffer> buffer(
       new rtc::RefCountedObject<FakeNativeHandleBuffer>(this, 1280, 720));
   VideoFrame input_frame(buffer, 100, 1000, kVideoRotation_180);
   // Expect calls with the given video frame verbatim, since it's a texture
   // frame and can't otherwise be modified/resized.
   for (MockVideoEncoder* encoder : helper_->factory()->encoders())
     EXPECT_CALL(*encoder, Encode(::testing::Ref(input_frame), _, _)).Times(1);
   std::vector<FrameType> frame_types(3, kVideoFrameKey);
   EXPECT_EQ(0, adapter_->Encode(input_frame, NULL, &frame_types));
 }
 
 TEST_F(TestSimulcastEncoderAdapterFake, TestFailureReturnCodesFromEncodeCalls) {
   TestVp8Simulcast::DefaultSettings(
       &codec_, static_cast<const int*>(kTestTemporalLayerProfile));
+  codec_.codecSpecific.VP8.tl_factory = &tl_factory_;
   codec_.numberOfSimulcastStreams = 3;
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
   adapter_->RegisterEncodeCompleteCallback(this);
   ASSERT_EQ(3u, helper_->factory()->encoders().size());
   // Tell the 2nd encoder to request software fallback.
   EXPECT_CALL(*helper_->factory()->encoders()[1], Encode(_, _, _))
       .WillOnce(Return(WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE));
 
   // Send a fake frame and assert the return is software fallback.
   int half_width = (kDefaultWidth + 1) / 2;
   rtc::scoped_refptr<I420Buffer> input_buffer = I420Buffer::Create(
       kDefaultWidth, kDefaultHeight, kDefaultWidth, half_width, half_width);
   input_buffer->InitializeData();
   VideoFrame input_frame(input_buffer, 0, 0, webrtc::kVideoRotation_0);
   std::vector<FrameType> frame_types(3, kVideoFrameKey);
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE,
             adapter_->Encode(input_frame, nullptr, &frame_types));
 }
 
 }  // namespace testing
 }  // namespace webrtc