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

webrtc/modules/video_coding/video_sender_unittest.cc

 /*
  *  Copyright (c) 2013 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 <memory>
 #include <vector>
 
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8_common_types.h"
 #include "webrtc/modules/video_coding/codecs/vp8/temporal_layers.h"
 #include "webrtc/modules/video_coding/include/mock/mock_vcm_callbacks.h"
 #include "webrtc/modules/video_coding/include/mock/mock_video_codec_interface.h"
 #include "webrtc/modules/video_coding/include/video_coding.h"
 #include "webrtc/modules/video_coding/test/test_util.h"
 #include "webrtc/modules/video_coding/video_coding_impl.h"
+#include "webrtc/modules/video_coding/utility/default_video_bitrate_allocator.h"
+#include "webrtc/modules/video_coding/utility/simulcast_rate_allocator.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/test/frame_generator.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/testsupport/fileutils.h"
 
 using ::testing::_;
 using ::testing::AllOf;
 using ::testing::ElementsAre;
 using ::testing::ElementsAreArray;
 using ::testing::Field;
@@ skipping 157 matching lines @@
 
   SimulatedClock clock_;
   EncodedImageCallbackImpl encoded_frame_callback_;
   // Used by subclassing tests, need to outlive sender_.
   std::unique_ptr<VideoEncoder> encoder_;
   std::unique_ptr<VideoSender> sender_;
   std::unique_ptr<FrameGenerator> generator_;
 };
 
 class TestVideoSenderWithMockEncoder : public TestVideoSender {
+ public:
+  TestVideoSenderWithMockEncoder() {}
+  ~TestVideoSenderWithMockEncoder() override {}
+
  protected:
   void SetUp() override {
     TestVideoSender::SetUp();
     sender_->RegisterExternalEncoder(&encoder_, kUnusedPayloadType, false);
     VideoCodingModule::Codec(kVideoCodecVP8, &settings_);
     settings_.numberOfSimulcastStreams = kNumberOfStreams;
     ConfigureStream(kDefaultWidth / 4, kDefaultHeight / 4, 100,
                     &settings_.simulcastStream[0]);
     ConfigureStream(kDefaultWidth / 2, kDefaultHeight / 2, 500,
                     &settings_.simulcastStream[1]);
     ConfigureStream(kDefaultWidth, kDefaultHeight, 1200,
                     &settings_.simulcastStream[2]);
     settings_.plType = kUnusedPayloadType;  // Use the mocked encoder.
     generator_.reset(
         new EmptyFrameGenerator(settings_.width, settings_.height));
     EXPECT_EQ(0, sender_->RegisterSendCodec(&settings_, 1, 1200));
+    rate_allocator_.reset(new DefaultVideoBitrateAllocator(settings_));
   }
 
   void TearDown() override { sender_.reset(); }
 
   void ExpectIntraRequest(int stream) {
     ExpectEncodeWithFrameTypes(stream, false);
   }
 
   void ExpectInitialKeyFrames() {
     ExpectEncodeWithFrameTypes(-1, true);
@@ skipping 29 matching lines @@
     assert(stream);
     stream->width = width;
     stream->height = height;
     stream->maxBitrate = max_bitrate;
     stream->numberOfTemporalLayers = kNumberOfLayers;
     stream->qpMax = 45;
   }
 
   VideoCodec settings_;
   NiceMock<MockVideoEncoder> encoder_;
+  std::unique_ptr<DefaultVideoBitrateAllocator> rate_allocator_;
 };
 
 TEST_F(TestVideoSenderWithMockEncoder, TestIntraRequests) {
   // Initial request should be all keyframes.
   ExpectInitialKeyFrames();
   AddFrame();
   EXPECT_EQ(0, sender_->IntraFrameRequest(0));
   ExpectIntraRequest(0);
   AddFrame();
   ExpectIntraRequest(-1);
@@ skipping 10 matching lines @@
   AddFrame();
   ExpectIntraRequest(-1);
   AddFrame();
 
   EXPECT_EQ(-1, sender_->IntraFrameRequest(3));
   ExpectIntraRequest(-1);
   AddFrame();
 }
 
 TEST_F(TestVideoSenderWithMockEncoder, TestSetRate) {
-  const uint32_t new_bitrate = settings_.startBitrate + 300;
-  EXPECT_CALL(encoder_, SetRates(new_bitrate, _)).Times(1).WillOnce(Return(0));
-  sender_->SetChannelParameters(new_bitrate * 1000, 0, 200);
+  const uint32_t new_bitrate_kbps = settings_.startBitrate + 300;
+  BitrateAllocation new_rate_allocation = rate_allocator_->GetAllocation(
+      new_bitrate_kbps * 1000, settings_.maxFramerate);
+  EXPECT_CALL(encoder_, SetRateAllocation(new_rate_allocation, _))
+      .Times(1)
+      .WillOnce(Return(0));
+  sender_->SetChannelParameters(new_bitrate_kbps * 1000, 0, 200,
+                                rate_allocator_.get());
   AddFrame();
 
   // Expect no call to encoder_.SetRates if the new bitrate is zero.
-  EXPECT_CALL(encoder_, SetRates(new_bitrate, _)).Times(0);
-  sender_->SetChannelParameters(0, 0, 200);
+  EXPECT_CALL(encoder_, SetRateAllocation(_, _)).Times(0);
+  sender_->SetChannelParameters(0, 0, 200, rate_allocator_.get());
   AddFrame();
 }
 
 TEST_F(TestVideoSenderWithMockEncoder, TestIntraRequestsInternalCapture) {
   // De-register current external encoder.
   sender_->RegisterExternalEncoder(nullptr, kUnusedPayloadType, false);
   // Register encoder with internal capture.
   sender_->RegisterExternalEncoder(&encoder_, kUnusedPayloadType, true);
   EXPECT_EQ(0, sender_->RegisterSendCodec(&settings_, 1, 1200));
   // Initial request should be all keyframes.
@@ skipping 10 matching lines @@
 }
 
 TEST_F(TestVideoSenderWithMockEncoder, TestEncoderParametersForInternalSource) {
   // De-register current external encoder.
   sender_->RegisterExternalEncoder(nullptr, kUnusedPayloadType, false);
   // Register encoder with internal capture.
   sender_->RegisterExternalEncoder(&encoder_, kUnusedPayloadType, true);
   EXPECT_EQ(0, sender_->RegisterSendCodec(&settings_, 1, 1200));
   // Update encoder bitrate parameters. We expect that to immediately call
   // SetRates on the encoder without waiting for AddFrame processing.
-  const uint32_t new_bitrate = settings_.startBitrate + 300;
-  EXPECT_CALL(encoder_, SetRates(new_bitrate, _)).Times(1).WillOnce(Return(0));
-  sender_->SetChannelParameters(new_bitrate * 1000, 0, 200);
+  const uint32_t new_bitrate_kbps = settings_.startBitrate + 300;
+  BitrateAllocation new_rate_allocation = rate_allocator_->GetAllocation(
+      new_bitrate_kbps * 1000, settings_.maxFramerate);
+  EXPECT_CALL(encoder_, SetRateAllocation(new_rate_allocation, _))
+      .Times(1)
+      .WillOnce(Return(0));
+  sender_->SetChannelParameters(new_bitrate_kbps * 1000, 0, 200,
+                                rate_allocator_.get());
 }
 
 TEST_F(TestVideoSenderWithMockEncoder, EncoderFramerateUpdatedViaProcess) {
-  sender_->SetChannelParameters(settings_.startBitrate * 1000, 0, 200);
+  sender_->SetChannelParameters(settings_.startBitrate * 1000, 0, 200,
+                                rate_allocator_.get());
   const int64_t kRateStatsWindowMs = 2000;
   const uint32_t kInputFps = 20;
   int64_t start_time = clock_.TimeInMilliseconds();
   while (clock_.TimeInMilliseconds() < start_time + kRateStatsWindowMs) {
     AddFrame();
     clock_.AdvanceTimeMilliseconds(1000 / kInputFps);
   }
-  EXPECT_CALL(encoder_, SetRates(_, kInputFps)).Times(1).WillOnce(Return(0));
+  EXPECT_CALL(encoder_, SetRateAllocation(_, kInputFps))
+      .Times(1)
+      .WillOnce(Return(0));
   sender_->Process();
   AddFrame();
 }
 
 TEST_F(TestVideoSenderWithMockEncoder,
        NoRedundantSetChannelParameterOrSetRatesCalls) {
   const uint8_t kLossRate = 4;
   const uint8_t kRtt = 200;
   const int64_t kRateStatsWindowMs = 2000;
   const uint32_t kInputFps = 20;
   int64_t start_time = clock_.TimeInMilliseconds();
   // Expect initial call to SetChannelParameters. Rates are initialized through
   // InitEncode and expects no additional call before the framerate (or bitrate)
   // updates.
   EXPECT_CALL(encoder_, SetChannelParameters(kLossRate, kRtt))
       .Times(1)
       .WillOnce(Return(0));
-  sender_->SetChannelParameters(settings_.startBitrate * 1000, kLossRate, kRtt);
+  sender_->SetChannelParameters(settings_.startBitrate * 1000, kLossRate, kRtt,
+                                rate_allocator_.get());
   while (clock_.TimeInMilliseconds() < start_time + kRateStatsWindowMs) {
     AddFrame();
     clock_.AdvanceTimeMilliseconds(1000 / kInputFps);
   }
   // After process, input framerate should be updated but not ChannelParameters
   // as they are the same as before.
-  EXPECT_CALL(encoder_, SetRates(_, kInputFps)).Times(1).WillOnce(Return(0));
+  EXPECT_CALL(encoder_, SetRateAllocation(_, kInputFps))
+      .Times(1)
+      .WillOnce(Return(0));
   sender_->Process();
   AddFrame();
   // Call to SetChannelParameters with changed bitrate should call encoder
   // SetRates but not encoder SetChannelParameters (that are unchanged).
-  EXPECT_CALL(encoder_, SetRates(2 * settings_.startBitrate, kInputFps))
+  uint32_t new_bitrate_bps = 2 * settings_.startBitrate * 1000;
+  BitrateAllocation new_rate_allocation =
+      rate_allocator_->GetAllocation(new_bitrate_bps, kInputFps);
+  EXPECT_CALL(encoder_, SetRateAllocation(new_rate_allocation, kInputFps))
       .Times(1)
       .WillOnce(Return(0));
-  sender_->SetChannelParameters(2 * settings_.startBitrate * 1000, kLossRate,
-                                kRtt);
+  sender_->SetChannelParameters(new_bitrate_bps, kLossRate, kRtt,
+                                rate_allocator_.get());
   AddFrame();
 }
 
 class TestVideoSenderWithVp8 : public TestVideoSender {
  public:
   TestVideoSenderWithVp8()
       : codec_bitrate_kbps_(300), available_bitrate_kbps_(1000) {}
 
   void SetUp() override {
     TestVideoSender::SetUp();
 
     const char* input_video = "foreman_cif";
     const int width = 352;
     const int height = 288;
     generator_.reset(FrameGenerator::CreateFromYuvFile(
         std::vector<std::string>(1, test::ResourcePath(input_video, "yuv")),
         width, height, 1));
 
     codec_ = MakeVp8VideoCodec(width, height, 3);
     codec_.minBitrate = 10;
     codec_.startBitrate = codec_bitrate_kbps_;
     codec_.maxBitrate = codec_bitrate_kbps_;
+
+    rate_allocator_.reset(new SimulcastRateAllocator(codec_));
+    tl_factory_.reset(new TemporalLayersFactory());
+    tl_factory_->SetListener(rate_allocator_.get());
+    codec_.codecSpecific.VP8.tl_factory = tl_factory_.get();
+
     encoder_.reset(VP8Encoder::Create());
     sender_->RegisterExternalEncoder(encoder_.get(), codec_.plType, false);
     EXPECT_EQ(0, sender_->RegisterSendCodec(&codec_, 1, 1200));
   }
 
   static VideoCodec MakeVp8VideoCodec(int width,
                                       int height,
                                       int temporal_layers) {
     VideoCodec codec;
     VideoCodingModule::Codec(kVideoCodecVP8, &codec);
     codec.width = width;
     codec.height = height;
     codec.codecSpecific.VP8.numberOfTemporalLayers = temporal_layers;
     return codec;
   }
 
   void InsertFrames(float framerate, float seconds) {
     for (int i = 0; i < seconds * framerate; ++i) {
       clock_.AdvanceTimeMilliseconds(1000.0f / framerate);
       AddFrame();
       // SetChannelParameters needs to be called frequently to propagate
       // framerate from the media optimization into the encoder.
       // Note: SetChannelParameters fails if less than 2 frames are in the
       // buffer since it will fail to calculate the framerate.
       if (i != 0) {
-        EXPECT_EQ(VCM_OK, sender_->SetChannelParameters(
-                              available_bitrate_kbps_ * 1000, 0, 200));
+        EXPECT_EQ(VCM_OK,
+                  sender_->SetChannelParameters(available_bitrate_kbps_ * 1000,
+                                                0, 200, rate_allocator_.get()));
       }
     }
   }
 
   Vp8StreamInfo SimulateWithFramerate(float framerate) {
     const float short_simulation_interval = 5.0;
     const float long_simulation_interval = 10.0;
     // It appears that this 5 seconds simulation is needed to allow
     // bitrate and framerate to stabilize.
     InsertFrames(framerate, short_simulation_interval);
     encoded_frame_callback_.Reset();
 
     InsertFrames(framerate, long_simulation_interval);
     return encoded_frame_callback_.CalculateVp8StreamInfo();
   }
 
  protected:
   VideoCodec codec_;
   int codec_bitrate_kbps_;
   int available_bitrate_kbps_;
+  std::unique_ptr<SimulcastRateAllocator> rate_allocator_;
+  std::unique_ptr<TemporalLayersFactory> tl_factory_;
 };
 
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
 #define MAYBE_FixedTemporalLayersStrategy DISABLED_FixedTemporalLayersStrategy
 #else
 #define MAYBE_FixedTemporalLayersStrategy FixedTemporalLayersStrategy
 #endif
 TEST_F(TestVideoSenderWithVp8, MAYBE_FixedTemporalLayersStrategy) {
   const int low_b = codec_bitrate_kbps_ * kVp8LayerRateAlloction[2][0];
   const int mid_b = codec_bitrate_kbps_ * kVp8LayerRateAlloction[2][1];
   const int high_b = codec_bitrate_kbps_ * kVp8LayerRateAlloction[2][2];
   {
     Vp8StreamInfo expected = {{7.5, 15.0, 30.0}, {low_b, mid_b, high_b}};
     EXPECT_THAT(SimulateWithFramerate(30.0), MatchesVp8StreamInfo(expected));
   }
   {
     Vp8StreamInfo expected = {{3.75, 7.5, 15.0}, {low_b, mid_b, high_b}};
     EXPECT_THAT(SimulateWithFramerate(15.0), MatchesVp8StreamInfo(expected));
   }
 }
 
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
 #define MAYBE_RealTimeTemporalLayersStrategy \
   DISABLED_RealTimeTemporalLayersStrategy
 #else
 #define MAYBE_RealTimeTemporalLayersStrategy RealTimeTemporalLayersStrategy
 #endif
 TEST_F(TestVideoSenderWithVp8, MAYBE_RealTimeTemporalLayersStrategy) {
   VideoCodec codec = MakeVp8VideoCodec(352, 288, 3);
-  RealTimeTemporalLayersFactory realtime_tl_factory;
-  codec.codecSpecific.VP8.tl_factory = &realtime_tl_factory;
   codec.minBitrate = 10;
   codec.startBitrate = codec_bitrate_kbps_;
   codec.maxBitrate = codec_bitrate_kbps_;
+
+  rate_allocator_.reset(new SimulcastRateAllocator(codec));
+  tl_factory_.reset(new RealTimeTemporalLayersFactory());
+  tl_factory_->SetListener(rate_allocator_.get());
+  codec.codecSpecific.VP8.tl_factory = tl_factory_.get();
+
   EXPECT_EQ(0, sender_->RegisterSendCodec(&codec, 1, 1200));
 
   const int low_b = codec_bitrate_kbps_ * 0.4;
   const int mid_b = codec_bitrate_kbps_ * 0.6;
   const int high_b = codec_bitrate_kbps_;
 
   {
     Vp8StreamInfo expected = {{7.5, 15.0, 30.0}, {low_b, mid_b, high_b}};
     EXPECT_THAT(SimulateWithFramerate(30.0), MatchesVp8StreamInfo(expected));
   }
@@ skipping 11 matching lines @@
   }
   {
     // TODO(andresp): Find out why this fails with framerate = 7.5
     Vp8StreamInfo expected = {{7.0, 7.0, 7.0}, {high_b, high_b, high_b}};
     EXPECT_THAT(SimulateWithFramerate(7.0), MatchesVp8StreamInfo(expected));
   }
 }
 }  // namespace
 }  // namespace vcm
 }  // namespace webrtc