Reland "Replace usage of old SetRates/SetRateAllocation methods"

This is a reland of 7ac0d5f348f0b956089c4ed65c46e65bac125508

Original change's description:
> Replace usage of old SetRates/SetRateAllocation methods
>
> This rather large CL replaces all relevant usage of the old
> VideoEncoder::SetRates()/SetRateAllocation() methods in WebRTC.
> API is unchanged to allow downstream projects to update without
> breakage.
>
> Bug: webrtc:10481
> Change-Id: Iab8f292ce6be6c3f5056a239d26361962b14bb38
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/131949
> Commit-Queue: Erik Språng <sprang@webrtc.org>
> Reviewed-by: Per Kjellander <perkj@webrtc.org>
> Reviewed-by: Niels Moller <nisse@webrtc.org>
> Reviewed-by: Sami Kalliomäki <sakal@webrtc.org>
> Reviewed-by: Rasmus Brandt <brandtr@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#27554}

TBR=brandtr@webrtc.org,sakal@webrtc.org,perkj@webrtc.org

Bug: webrtc:10481
Change-Id: I2978d5c527a18e885b7845c4e53a2424e8ad5b4b
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/132551
Commit-Queue: Erik Språng <sprang@webrtc.org>
Reviewed-by: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#27593}

modules/video_coding/codecs/h264/h264_encoder_impl.cc

@@ -306,7 +306,8 @@ int32_t H264EncoderImpl::InitEncode(const VideoCodec* inst,
   SimulcastRateAllocator init_allocator(codec_);
   VideoBitrateAllocation allocation = init_allocator.GetAllocation(
       codec_.startBitrate * 1000, codec_.maxFramerate);
-  return SetRateAllocation(allocation, codec_.maxFramerate);
+  SetRates(RateControlParameters(allocation, codec_.maxFramerate));
+  return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t H264EncoderImpl::Release() {
@@ -331,36 +332,40 @@ int32_t H264EncoderImpl::RegisterEncodeCompleteCallback(
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
-int32_t H264EncoderImpl::SetRateAllocation(
-    const VideoBitrateAllocation& bitrate,
-    uint32_t new_framerate) {
-  if (encoders_.empty())
-    return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
+void H264EncoderImpl::SetRates(const RateControlParameters& parameters) {
+  if (encoders_.empty()) {
+    RTC_LOG(LS_WARNING) << "SetRates() while uninitialized.";
+    return;
+  }
 
-  if (new_framerate < 1)
-    return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
+  if (parameters.framerate_fps < 1.0) {
+    RTC_LOG(LS_WARNING) << "Invalid frame rate: " << parameters.framerate_fps;
+    return;
+  }
 
-  if (bitrate.get_sum_bps() == 0) {
+  if (parameters.bitrate.get_sum_bps() == 0) {
     // Encoder paused, turn off all encoding.
     for (size_t i = 0; i < configurations_.size(); ++i)
       configurations_[i].SetStreamState(false);
-    return WEBRTC_VIDEO_CODEC_OK;
+    return;
   }
 
   // At this point, bitrate allocation should already match codec settings.
   if (codec_.maxBitrate > 0)
-    RTC_DCHECK_LE(bitrate.get_sum_kbps(), codec_.maxBitrate);
-  RTC_DCHECK_GE(bitrate.get_sum_kbps(), codec_.minBitrate);
+    RTC_DCHECK_LE(parameters.bitrate.get_sum_kbps(), codec_.maxBitrate);
+  RTC_DCHECK_GE(parameters.bitrate.get_sum_kbps(), codec_.minBitrate);
   if (codec_.numberOfSimulcastStreams > 0)
-    RTC_DCHECK_GE(bitrate.get_sum_kbps(), codec_.simulcastStream[0].minBitrate);
+    RTC_DCHECK_GE(parameters.bitrate.get_sum_kbps(),
+                  codec_.simulcastStream[0].minBitrate);
 
-  codec_.maxFramerate = new_framerate;
+  codec_.maxFramerate = static_cast<uint32_t>(parameters.framerate_fps);
 
   size_t stream_idx = encoders_.size() - 1;
   for (size_t i = 0; i < encoders_.size(); ++i, --stream_idx) {
     // Update layer config.
-    configurations_[i].target_bps = bitrate.GetSpatialLayerSum(stream_idx);
-    configurations_[i].max_frame_rate = static_cast<float>(new_framerate);
+    configurations_[i].target_bps =
+        parameters.bitrate.GetSpatialLayerSum(stream_idx);
+    configurations_[i].max_frame_rate = parameters.framerate_fps;
 
     if (configurations_[i].target_bps) {
       configurations_[i].SetStreamState(true);
@@ -377,8 +382,6 @@ int32_t H264EncoderImpl::SetRateAllocation(
       configurations_[i].SetStreamState(false);
     }
   }
-
-  return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t H264EncoderImpl::Encode(

modules/video_coding/codecs/h264/h264_encoder_impl.h

@@ -61,8 +61,7 @@ class H264EncoderImpl : public H264Encoder {
 
   int32_t RegisterEncodeCompleteCallback(
       EncodedImageCallback* callback) override;
-  int32_t SetRateAllocation(const VideoBitrateAllocation& bitrate_allocation,
-                            uint32_t framerate) override;
+  void SetRates(const RateControlParameters& parameters) override;
 
   // The result of encoding - an EncodedImage and RTPFragmentationHeader - are
   // passed to the encode complete callback.

modules/video_coding/codecs/multiplex/include/multiplex_encoder_adapter.h

@@ -45,8 +45,7 @@ class MultiplexEncoderAdapter : public VideoEncoder {
   int Encode(const VideoFrame& input_image,
              const std::vector<VideoFrameType>* frame_types) override;
   int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
-  int SetRateAllocation(const VideoBitrateAllocation& bitrate,
-                        uint32_t new_framerate) override;
+  void SetRates(const RateControlParameters& parameters) override;
   int Release() override;
   EncoderInfo GetEncoderInfo() const override;
 

modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc

@@ -216,23 +216,21 @@ int MultiplexEncoderAdapter::RegisterEncodeCompleteCallback(
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
-int MultiplexEncoderAdapter::SetRateAllocation(
-    const VideoBitrateAllocation& bitrate,
-    uint32_t framerate) {
-  VideoBitrateAllocation bitrate_allocation(bitrate);
+void MultiplexEncoderAdapter::SetRates(
+    const RateControlParameters& parameters) {
+  VideoBitrateAllocation bitrate_allocation(parameters.bitrate);
   bitrate_allocation.SetBitrate(
-      0, 0, bitrate.GetBitrate(0, 0) - augmenting_data_size_);
+      0, 0, parameters.bitrate.GetBitrate(0, 0) - augmenting_data_size_);
   for (auto& encoder : encoders_) {
     // TODO(emircan): |framerate| is used to calculate duration in encoder
     // instances. We report the total frame rate to keep real time for now.
     // Remove this after refactoring duration logic.
-    const int rv = encoder->SetRateAllocation(
+    encoder->SetRates(RateControlParameters(
         bitrate_allocation,
-        static_cast<uint32_t>(encoders_.size()) * framerate);
-    if (rv)
-      return rv;
+        static_cast<uint32_t>(encoders_.size() * parameters.framerate_fps),
+        parameters.bandwidth_allocation -
+            DataRate::bps(augmenting_data_size_)));
   }
-  return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int MultiplexEncoderAdapter::Release() {

modules/video_coding/codecs/test/videoprocessor.cc

@@ -300,10 +300,8 @@ void VideoProcessor::SetRates(size_t bitrate_kbps, size_t framerate_fps) {
   framerate_fps_ = static_cast<uint32_t>(framerate_fps);
   bitrate_allocation_ = bitrate_allocator_->GetAllocation(
       static_cast<uint32_t>(bitrate_kbps * 1000), framerate_fps_);
-  const int set_rates_result =
-      encoder_->SetRateAllocation(bitrate_allocation_, framerate_fps_);
-  RTC_DCHECK_GE(set_rates_result, 0)
-      << "Failed to update encoder with new rate " << bitrate_kbps << ".";
+  encoder_->SetRates(VideoEncoder::RateControlParameters(
+      bitrate_allocation_, static_cast<double>(framerate_fps_)));
 }
 
 int32_t VideoProcessor::VideoProcessorDecodeCompleteCallback::Decoded(

modules/video_coding/codecs/test/videoprocessor_unittest.cc

@@ -25,7 +25,10 @@
 #include "test/testsupport/mock/mock_frame_reader.h"
 
 using ::testing::_;
+using ::testing::AllOf;
+using ::testing::Field;
 using ::testing::Property;
+using ::testing::ResultOf;
 using ::testing::Return;
 
 namespace webrtc {
@@ -96,9 +99,11 @@ TEST_F(VideoProcessorTest, InitRelease) {
 TEST_F(VideoProcessorTest, ProcessFrames_FixedFramerate) {
   const int kBitrateKbps = 456;
   const int kFramerateFps = 31;
-  EXPECT_CALL(encoder_mock_, SetRateAllocation(_, kFramerateFps))
-      .Times(1)
-      .WillOnce(Return(0));
+  EXPECT_CALL(
+      encoder_mock_,
+      SetRates(Field(&VideoEncoder::RateControlParameters::framerate_fps,
+                     static_cast<double>(kFramerateFps))))
+      .Times(1);
   q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); });
 
   EXPECT_CALL(frame_reader_mock_, ReadFrame())
@@ -122,9 +127,11 @@ TEST_F(VideoProcessorTest, ProcessFrames_VariableFramerate) {
   const int kBitrateKbps = 456;
   const int kStartFramerateFps = 27;
   const int kStartTimestamp = 90000 / kStartFramerateFps;
-  EXPECT_CALL(encoder_mock_, SetRateAllocation(_, kStartFramerateFps))
-      .Times(1)
-      .WillOnce(Return(0));
+  EXPECT_CALL(
+      encoder_mock_,
+      SetRates(Field(&VideoEncoder::RateControlParameters::framerate_fps,
+                     static_cast<double>(kStartFramerateFps))))
+      .Times(1);
   q_.SendTask(
       [=] { video_processor_->SetRates(kBitrateKbps, kStartFramerateFps); });
 
@@ -136,9 +143,11 @@ TEST_F(VideoProcessorTest, ProcessFrames_VariableFramerate) {
   q_.SendTask([this] { video_processor_->ProcessFrame(); });
 
   const int kNewFramerateFps = 13;
-  EXPECT_CALL(encoder_mock_, SetRateAllocation(_, kNewFramerateFps))
-      .Times(1)
-      .WillOnce(Return(0));
+  EXPECT_CALL(
+      encoder_mock_,
+      SetRates(Field(&VideoEncoder::RateControlParameters::framerate_fps,
+                     static_cast<double>(kNewFramerateFps))))
+      .Times(1);
   q_.SendTask(
       [=] { video_processor_->SetRates(kBitrateKbps, kNewFramerateFps); });
 
@@ -153,21 +162,32 @@ TEST_F(VideoProcessorTest, ProcessFrames_VariableFramerate) {
 }
 
 TEST_F(VideoProcessorTest, SetRates) {
-  const int kBitrateKbps = 123;
+  const uint32_t kBitrateKbps = 123;
   const int kFramerateFps = 17;
-  EXPECT_CALL(encoder_mock_,
-              SetRateAllocation(
-                  Property(&VideoBitrateAllocation::get_sum_kbps, kBitrateKbps),
-                  kFramerateFps))
+
+  EXPECT_CALL(
+      encoder_mock_,
+      SetRates(AllOf(ResultOf(
+                         [](const VideoEncoder::RateControlParameters& params) {
+                           return params.bitrate.get_sum_kbps();
+                         },
+                         kBitrateKbps),
+                     Field(&VideoEncoder::RateControlParameters::framerate_fps,
+                           static_cast<double>(kFramerateFps)))))
       .Times(1);
   q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); });
 
-  const int kNewBitrateKbps = 456;
+  const uint32_t kNewBitrateKbps = 456;
   const int kNewFramerateFps = 34;
-  EXPECT_CALL(encoder_mock_,
-              SetRateAllocation(Property(&VideoBitrateAllocation::get_sum_kbps,
-                                         kNewBitrateKbps),
-                                kNewFramerateFps))
+  EXPECT_CALL(
+      encoder_mock_,
+      SetRates(AllOf(ResultOf(
+                         [](const VideoEncoder::RateControlParameters& params) {
+                           return params.bitrate.get_sum_kbps();
+                         },
+                         kNewBitrateKbps),
+                     Field(&VideoEncoder::RateControlParameters::framerate_fps,
+                           static_cast<double>(kNewFramerateFps)))))
       .Times(1);
   q_.SendTask(
       [=] { video_processor_->SetRates(kNewBitrateKbps, kNewFramerateFps); });

modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc

@@ -36,6 +36,7 @@
 #include "rtc_base/checks.h"
 #include "rtc_base/experiments/field_trial_parser.h"
 #include "rtc_base/experiments/field_trial_units.h"
+#include "rtc_base/logging.h"
 #include "rtc_base/trace_event.h"
 #include "system_wrappers/include/field_trial.h"
 #include "third_party/libyuv/include/libyuv/scale.h"
@@ -247,33 +248,40 @@ int LibvpxVp8Encoder::Release() {
   return ret_val;
 }
 
-int LibvpxVp8Encoder::SetRateAllocation(const VideoBitrateAllocation& bitrate,
-                                        uint32_t new_framerate) {
-  if (!inited_)
-    return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
+void LibvpxVp8Encoder::SetRates(const RateControlParameters& parameters) {
+  if (!inited_) {
+    RTC_LOG(LS_WARNING) << "SetRates() while not initialize";
+    return;
+  }
 
-  if (encoders_[0].err)
-    return WEBRTC_VIDEO_CODEC_ERROR;
+  if (encoders_[0].err) {
+    RTC_LOG(LS_WARNING) << "Encoder in error state.";
+    return;
+  }
 
-  if (new_framerate < 1)
-    return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
+  if (parameters.framerate_fps < 1.0) {
+    RTC_LOG(LS_WARNING) << "Unsupported framerate (must be >= 1.0): "
+                        << parameters.framerate_fps;
+    return;
+  }
 
-  if (bitrate.get_sum_bps() == 0) {
+  if (parameters.bitrate.get_sum_bps() == 0) {
     // Encoder paused, turn off all encoding.
     const int num_streams = static_cast<size_t>(encoders_.size());
     for (int i = 0; i < num_streams; ++i)
       SetStreamState(false, i);
-    return WEBRTC_VIDEO_CODEC_OK;
+    return;
   }
 
   // At this point, bitrate allocation should already match codec settings.
   if (codec_.maxBitrate > 0)
-    RTC_DCHECK_LE(bitrate.get_sum_kbps(), codec_.maxBitrate);
-  RTC_DCHECK_GE(bitrate.get_sum_kbps(), codec_.minBitrate);
+    RTC_DCHECK_LE(parameters.bitrate.get_sum_kbps(), codec_.maxBitrate);
+  RTC_DCHECK_GE(parameters.bitrate.get_sum_kbps(), codec_.minBitrate);
   if (codec_.numberOfSimulcastStreams > 0)
-    RTC_DCHECK_GE(bitrate.get_sum_kbps(), codec_.simulcastStream[0].minBitrate);
+    RTC_DCHECK_GE(parameters.bitrate.get_sum_kbps(),
+                  codec_.simulcastStream[0].minBitrate);
 
-  codec_.maxFramerate = new_framerate;
+  codec_.maxFramerate = static_cast<uint32_t>(parameters.framerate_fps + 0.5);
 
   if (encoders_.size() > 1) {
     // If we have more than 1 stream, reduce the qp_max for the low resolution
@@ -282,7 +290,7 @@ int LibvpxVp8Encoder::SetRateAllocation(const VideoBitrateAllocation& bitrate,
     // above some threshold (base temporal layer is down to 1/4 for 3 layers).
     // We may want to condition this on bitrate later.
     if (rate_control_settings_.Vp8BoostBaseLayerQuality() &&
-        new_framerate > 20) {
+        parameters.framerate_fps > 20.0) {
       configurations_[encoders_.size() - 1].rc_max_quantizer = 45;
     } else {
       // Go back to default value set in InitEncode.
@@ -293,7 +301,7 @@ int LibvpxVp8Encoder::SetRateAllocation(const VideoBitrateAllocation& bitrate,
   size_t stream_idx = encoders_.size() - 1;
   for (size_t i = 0; i < encoders_.size(); ++i, --stream_idx) {
     unsigned int target_bitrate_kbps =
-        bitrate.GetSpatialLayerSum(stream_idx) / 1000;
+        parameters.bitrate.GetSpatialLayerSum(stream_idx) / 1000;
 
     bool send_stream = target_bitrate_kbps > 0;
     if (send_stream || encoders_.size() > 1)
@@ -302,18 +310,19 @@ int LibvpxVp8Encoder::SetRateAllocation(const VideoBitrateAllocation& bitrate,
     configurations_[i].rc_target_bitrate = target_bitrate_kbps;
     if (send_stream) {
       frame_buffer_controller_->OnRatesUpdated(
-          stream_idx, bitrate.GetTemporalLayerAllocation(stream_idx),
-          new_framerate);
+          stream_idx, parameters.bitrate.GetTemporalLayerAllocation(stream_idx),
+          static_cast<int>(parameters.framerate_fps + 0.5));
     }
 
     UpdateVpxConfiguration(stream_idx, frame_buffer_controller_.get(),
                            &configurations_[i]);
 
-    if (libvpx_->codec_enc_config_set(&encoders_[i], &configurations_[i])) {
-      return WEBRTC_VIDEO_CODEC_ERROR;
+    vpx_codec_err_t err =
+        libvpx_->codec_enc_config_set(&encoders_[i], &configurations_[i]);
+    if (err != VPX_CODEC_OK) {
+      RTC_LOG(LS_WARNING) << "Error configuring codec, error code: " << err;
     }
   }
-  return WEBRTC_VIDEO_CODEC_OK;
 }
 
 void LibvpxVp8Encoder::OnPacketLossRateUpdate(float packet_loss_rate) {

modules/video_coding/codecs/vp8/libvpx_vp8_encoder.h

@@ -54,8 +54,7 @@ class LibvpxVp8Encoder : public VideoEncoder {
 
   int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
 
-  int SetRateAllocation(const VideoBitrateAllocation& bitrate,
-                        uint32_t new_framerate) override;
+  void SetRates(const RateControlParameters& parameters) override;
 
   void OnPacketLossRateUpdate(float packet_loss_rate) override;
 

modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc

@@ -110,20 +110,23 @@ class TestVp8Impl : public VideoCodecUnitTest {
   }
 };
 
-TEST_F(TestVp8Impl, SetRateAllocation) {
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, encoder_->Release());
+TEST_F(TestVp8Impl, SetRates) {
+  auto* const vpx = new NiceMock<MockLibvpxVp8Interface>();
+  LibvpxVp8Encoder encoder((std::unique_ptr<LibvpxInterface>(vpx)));
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+            encoder.InitEncode(&codec_settings_, 1, 1000));
 
-  const int kBitrateBps = 300000;
+  const uint32_t kBitrateBps = 300000;
   VideoBitrateAllocation bitrate_allocation;
   bitrate_allocation.SetBitrate(0, 0, kBitrateBps);
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_UNINITIALIZED,
-            encoder_->SetRateAllocation(bitrate_allocation,
-                                        codec_settings_.maxFramerate));
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->InitEncode(&codec_settings_, kNumCores, kMaxPayloadSize));
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->SetRateAllocation(bitrate_allocation,
-                                        codec_settings_.maxFramerate));
+  EXPECT_CALL(*vpx, codec_enc_config_set(_, _))
+      .WillOnce(
+          Invoke([&](vpx_codec_ctx_t* ctx, const vpx_codec_enc_cfg_t* cfg) {
+            EXPECT_EQ(cfg->rc_target_bitrate, kBitrateBps / 1000);
+            return VPX_CODEC_OK;
+          }));
+  encoder.SetRates(VideoEncoder::RateControlParameters(
+      bitrate_allocation, static_cast<double>(codec_settings_.maxFramerate)));
 }
 
 TEST_F(TestVp8Impl, EncodeFrameAndRelease) {
@@ -437,7 +440,8 @@ TEST_F(TestVp8Impl, DontDropKeyframes) {
   VideoBitrateAllocation bitrate_allocation;
   // Bitrate only enough for TL0.
   bitrate_allocation.SetBitrate(0, 0, 200000);
-  encoder_->SetRateAllocation(bitrate_allocation, 5);
+  encoder_->SetRates(
+      VideoEncoder::RateControlParameters(bitrate_allocation, 5.0));
 
   EncodedImage encoded_frame;
   CodecSpecificInfo codec_specific_info;

modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc

@@ -371,9 +371,8 @@ TEST_F(TestVp9Impl, EnableDisableSpatialLayers) {
     bitrate_allocation.SetBitrate(
         sl_idx, 0,
         codec_settings_.spatialLayers[sl_idx].targetBitrate * 1000 * 2);
-    EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-              encoder_->SetRateAllocation(bitrate_allocation,
-                                          codec_settings_.maxFramerate));
+    encoder_->SetRates(VideoEncoder::RateControlParameters(
+        bitrate_allocation, codec_settings_.maxFramerate));
 
     for (size_t frame_num = 0; frame_num < num_frames_to_encode; ++frame_num) {
       SetWaitForEncodedFramesThreshold(sl_idx + 1);
@@ -390,9 +389,8 @@ TEST_F(TestVp9Impl, EnableDisableSpatialLayers) {
   for (size_t i = 0; i < num_spatial_layers - 1; ++i) {
     const size_t sl_idx = num_spatial_layers - i - 1;
     bitrate_allocation.SetBitrate(sl_idx, 0, 0);
-    EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-              encoder_->SetRateAllocation(bitrate_allocation,
-                                          codec_settings_.maxFramerate));
+    encoder_->SetRates(VideoEncoder::RateControlParameters(
+        bitrate_allocation, codec_settings_.maxFramerate));
 
     for (size_t frame_num = 0; frame_num < num_frames_to_encode; ++frame_num) {
       SetWaitForEncodedFramesThreshold(sl_idx);
@@ -422,9 +420,8 @@ TEST_F(TestVp9Impl, EndOfPicture) {
       0, 0, codec_settings_.spatialLayers[0].targetBitrate * 1000);
   bitrate_allocation.SetBitrate(
       1, 0, codec_settings_.spatialLayers[1].targetBitrate * 1000);
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->SetRateAllocation(bitrate_allocation,
-                                        codec_settings_.maxFramerate));
+  encoder_->SetRates(VideoEncoder::RateControlParameters(
+      bitrate_allocation, codec_settings_.maxFramerate));
   SetWaitForEncodedFramesThreshold(2);
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             encoder_->Encode(*NextInputFrame(), nullptr));
@@ -438,9 +435,8 @@ TEST_F(TestVp9Impl, EndOfPicture) {
   // Encode only base layer. Check that end-of-superframe flag is
   // set on base layer frame.
   bitrate_allocation.SetBitrate(1, 0, 0);
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->SetRateAllocation(bitrate_allocation,
-                                        codec_settings_.maxFramerate));
+  encoder_->SetRates(VideoEncoder::RateControlParameters(
+      bitrate_allocation, codec_settings_.maxFramerate));
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             encoder_->InitEncode(&codec_settings_, 1 /* number of cores */,
                                  0 /* max payload size (unused) */));
@@ -475,9 +471,8 @@ TEST_F(TestVp9Impl, InterLayerPred) {
               encoder_->InitEncode(&codec_settings_, 1 /* number of cores */,
                                    0 /* max payload size (unused) */));
 
-    EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-              encoder_->SetRateAllocation(bitrate_allocation,
-                                          codec_settings_.maxFramerate));
+    encoder_->SetRates(VideoEncoder::RateControlParameters(
+        bitrate_allocation, codec_settings_.maxFramerate));
 
     SetWaitForEncodedFramesThreshold(2);
     EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
@@ -546,9 +541,8 @@ TEST_F(TestVp9Impl,
       bitrate_allocation.SetBitrate(
           sl_idx, 0,
           codec_settings_.spatialLayers[sl_idx].targetBitrate * 1000);
-      EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-                encoder_->SetRateAllocation(bitrate_allocation,
-                                            codec_settings_.maxFramerate));
+      encoder_->SetRates(VideoEncoder::RateControlParameters(
+          bitrate_allocation, codec_settings_.maxFramerate));
 
       for (size_t frame_num = 0; frame_num < num_frames_to_encode;
            ++frame_num) {
@@ -606,9 +600,8 @@ TEST_F(TestVp9Impl,
       bitrate_allocation.SetBitrate(
           sl_idx, 0,
           codec_settings_.spatialLayers[sl_idx].targetBitrate * 1000);
-      EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-                encoder_->SetRateAllocation(bitrate_allocation,
-                                            codec_settings_.maxFramerate));
+      encoder_->SetRates(VideoEncoder::RateControlParameters(
+          bitrate_allocation, codec_settings_.maxFramerate));
 
       for (size_t frame_num = 0; frame_num < num_frames_to_encode;
            ++frame_num) {
@@ -664,9 +657,8 @@ TEST_F(TestVp9Impl, EnablingDisablingUpperLayerInTheSameGof) {
       1, 0, codec_settings_.spatialLayers[1].targetBitrate * 1000 / 2);
   bitrate_allocation.SetBitrate(
       1, 1, codec_settings_.spatialLayers[1].targetBitrate * 1000 / 2);
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->SetRateAllocation(bitrate_allocation,
-                                        codec_settings_.maxFramerate));
+  encoder_->SetRates(VideoEncoder::RateControlParameters(
+      bitrate_allocation, codec_settings_.maxFramerate));
 
   std::vector<EncodedImage> encoded_frame;
   std::vector<CodecSpecificInfo> codec_specific_info;
@@ -683,9 +675,8 @@ TEST_F(TestVp9Impl, EnablingDisablingUpperLayerInTheSameGof) {
   // Disable SL1 layer.
   bitrate_allocation.SetBitrate(1, 0, 0);
   bitrate_allocation.SetBitrate(1, 1, 0);
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->SetRateAllocation(bitrate_allocation,
-                                        codec_settings_.maxFramerate));
+  encoder_->SetRates(VideoEncoder::RateControlParameters(
+      bitrate_allocation, codec_settings_.maxFramerate));
 
   // Encode 1 frame.
   SetWaitForEncodedFramesThreshold(1);
@@ -702,9 +693,8 @@ TEST_F(TestVp9Impl, EnablingDisablingUpperLayerInTheSameGof) {
       1, 0, codec_settings_.spatialLayers[1].targetBitrate * 1000 / 2);
   bitrate_allocation.SetBitrate(
       1, 1, codec_settings_.spatialLayers[1].targetBitrate * 1000 / 2);
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->SetRateAllocation(bitrate_allocation,
-                                        codec_settings_.maxFramerate));
+  encoder_->SetRates(VideoEncoder::RateControlParameters(
+      bitrate_allocation, codec_settings_.maxFramerate));
 
   // Encode 1 frame.
   SetWaitForEncodedFramesThreshold(2);
@@ -742,9 +732,8 @@ TEST_F(TestVp9Impl, EnablingDisablingUpperLayerAccrossGof) {
       1, 0, codec_settings_.spatialLayers[1].targetBitrate * 1000 / 2);
   bitrate_allocation.SetBitrate(
       1, 1, codec_settings_.spatialLayers[1].targetBitrate * 1000 / 2);
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->SetRateAllocation(bitrate_allocation,
-                                        codec_settings_.maxFramerate));
+  encoder_->SetRates(VideoEncoder::RateControlParameters(
+      bitrate_allocation, codec_settings_.maxFramerate));
 
   std::vector<EncodedImage> encoded_frame;
   std::vector<CodecSpecificInfo> codec_specific_info;
@@ -761,9 +750,8 @@ TEST_F(TestVp9Impl, EnablingDisablingUpperLayerAccrossGof) {
   // Disable SL1 layer.
   bitrate_allocation.SetBitrate(1, 0, 0);
   bitrate_allocation.SetBitrate(1, 1, 0);
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->SetRateAllocation(bitrate_allocation,
-                                        codec_settings_.maxFramerate));
+  encoder_->SetRates(VideoEncoder::RateControlParameters(
+      bitrate_allocation, codec_settings_.maxFramerate));
 
   // Encode 11 frames. More than Gof length 2, and odd to end at TL1 frame.
   for (int i = 0; i < 11; ++i) {
@@ -783,9 +771,8 @@ TEST_F(TestVp9Impl, EnablingDisablingUpperLayerAccrossGof) {
       1, 0, codec_settings_.spatialLayers[1].targetBitrate * 1000 / 2);
   bitrate_allocation.SetBitrate(
       1, 1, codec_settings_.spatialLayers[1].targetBitrate * 1000 / 2);
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->SetRateAllocation(bitrate_allocation,
-                                        codec_settings_.maxFramerate));
+  encoder_->SetRates(VideoEncoder::RateControlParameters(
+      bitrate_allocation, codec_settings_.maxFramerate));
 
   // Encode 1 frame.
   SetWaitForEncodedFramesThreshold(2);
@@ -831,9 +818,8 @@ TEST_F(TestVp9Impl, EnablingNewLayerIsDelayedInScreenshareAndAddsSsInfo) {
     bitrate_allocation.SetBitrate(
         sl_idx, 0, codec_settings_.spatialLayers[sl_idx].targetBitrate * 1000);
   }
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->SetRateAllocation(bitrate_allocation,
-                                        codec_settings_.maxFramerate));
+  encoder_->SetRates(VideoEncoder::RateControlParameters(
+      bitrate_allocation, codec_settings_.maxFramerate));
 
   // Encode enough frames to force drop due to framerate capping.
   for (size_t frame_num = 0; frame_num < num_frames_to_encode_before_drop;
@@ -851,9 +837,8 @@ TEST_F(TestVp9Impl, EnablingNewLayerIsDelayedInScreenshareAndAddsSsInfo) {
       num_spatial_layers - 1, 0,
       codec_settings_.spatialLayers[num_spatial_layers - 1].targetBitrate *
           1000);
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->SetRateAllocation(bitrate_allocation,
-                                        codec_settings_.maxFramerate));
+  encoder_->SetRates(VideoEncoder::RateControlParameters(
+      bitrate_allocation, codec_settings_.maxFramerate));
 
   for (size_t frame_num = 0; frame_num < num_dropped_frames; ++frame_num) {
     SetWaitForEncodedFramesThreshold(1);
@@ -909,9 +894,8 @@ TEST_F(TestVp9Impl, RemovingLayerIsNotDelayedInScreenshareAndAddsSsInfo) {
     bitrate_allocation.SetBitrate(
         sl_idx, 0, codec_settings_.spatialLayers[sl_idx].targetBitrate * 1000);
   }
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->SetRateAllocation(bitrate_allocation,
-                                        codec_settings_.maxFramerate));
+  encoder_->SetRates(VideoEncoder::RateControlParameters(
+      bitrate_allocation, codec_settings_.maxFramerate));
 
   // Encode enough frames to force drop due to framerate capping.
   for (size_t frame_num = 0; frame_num < num_frames_to_encode_before_drop;
@@ -940,9 +924,8 @@ TEST_F(TestVp9Impl, RemovingLayerIsNotDelayedInScreenshareAndAddsSsInfo) {
 
   // Disable the last layer.
   bitrate_allocation.SetBitrate(num_spatial_layers - 1, 0, 0);
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->SetRateAllocation(bitrate_allocation,
-                                        codec_settings_.maxFramerate));
+  encoder_->SetRates(VideoEncoder::RateControlParameters(
+      bitrate_allocation, codec_settings_.maxFramerate));
 
   // Still expected to drop first layer. Last layer has to be disable also.
   for (size_t frame_num = num_dropped_frames - 2;
@@ -998,9 +981,8 @@ TEST_F(TestVp9Impl, DisableNewLayerInVideoDelaysSsInfoTillTL0) {
               num_temporal_layers);
     }
   }
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->SetRateAllocation(bitrate_allocation,
-                                        codec_settings_.maxFramerate));
+  encoder_->SetRates(VideoEncoder::RateControlParameters(
+      bitrate_allocation, codec_settings_.maxFramerate));
 
   std::vector<EncodedImage> encoded_frames;
   std::vector<CodecSpecificInfo> codec_specific_info;
@@ -1016,9 +998,8 @@ TEST_F(TestVp9Impl, DisableNewLayerInVideoDelaysSsInfoTillTL0) {
   for (size_t tl_idx = 0; tl_idx < num_temporal_layers; ++tl_idx) {
     bitrate_allocation.SetBitrate(num_spatial_layers - 1, tl_idx, 0);
   }
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->SetRateAllocation(bitrate_allocation,
-                                        codec_settings_.maxFramerate));
+  encoder_->SetRates(VideoEncoder::RateControlParameters(
+      bitrate_allocation, codec_settings_.maxFramerate));
 
   // Next is TL1 frame. The last layer is disabled immediately, but SS structure
   // is not provided here.
@@ -1055,9 +1036,8 @@ TEST_F(TestVp9Impl,
   VideoBitrateAllocation bitrate_allocation;
   bitrate_allocation.SetBitrate(
       0, 0, codec_settings_.spatialLayers[0].targetBitrate * 1000);
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->SetRateAllocation(bitrate_allocation,
-                                        codec_settings_.maxFramerate));
+  encoder_->SetRates(VideoEncoder::RateControlParameters(
+      bitrate_allocation, codec_settings_.maxFramerate));
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             encoder_->Encode(*NextInputFrame(), nullptr));
   EncodedImage encoded_frame;
@@ -1325,9 +1305,8 @@ TEST_F(TestVp9ImplFrameDropping, DifferentFrameratePerSpatialLayer) {
             encoder_->InitEncode(&codec_settings_, 1 /* number of cores */,
                                  0 /* max payload size (unused) */));
 
-  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            encoder_->SetRateAllocation(bitrate_allocation,
-                                        codec_settings_.maxFramerate));
+  encoder_->SetRates(VideoEncoder::RateControlParameters(
+      bitrate_allocation, codec_settings_.maxFramerate));
 
   VideoFrame* input_frame = NextInputFrame();
   for (size_t frame_num = 0; frame_num < num_input_frames; ++frame_num) {
@@ -1380,9 +1359,8 @@ TEST_F(TestVp9ImplFrameDropping, LayerMaxFramerateIsCappedByCodecMaxFramerate) {
             encoder_->InitEncode(&codec_settings_, 1 /* number of cores */,
                                  0 /* max payload size (unused) */));
 
-  EXPECT_EQ(
-      WEBRTC_VIDEO_CODEC_OK,
-      encoder_->SetRateAllocation(bitrate_allocation, codec_max_framerate_fps));
+  encoder_->SetRates(VideoEncoder::RateControlParameters(
+      bitrate_allocation, codec_max_framerate_fps));
 
   VideoFrame* input_frame = NextInputFrame();
   for (size_t frame_num = 0; frame_num < num_input_frames; ++frame_num) {

modules/video_coding/codecs/vp9/vp9_impl.cc

@@ -309,29 +309,33 @@ bool VP9EncoderImpl::SetSvcRates(
   return true;
 }
 
-int VP9EncoderImpl::SetRateAllocation(
-    const VideoBitrateAllocation& bitrate_allocation,
-    uint32_t frame_rate) {
+void VP9EncoderImpl::SetRates(const RateControlParameters& parameters) {
   if (!inited_) {
-    return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
+    RTC_LOG(LS_WARNING) << "SetRates() calll while uninitialzied.";
+    return;
   }
   if (encoder_->err) {
-    return WEBRTC_VIDEO_CODEC_ERROR;
+    RTC_LOG(LS_WARNING) << "Encoder in error state: " << encoder_->err;
+    return;
   }
-  if (frame_rate < 1) {
-    return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
+  if (parameters.framerate_fps < 1.0) {
+    RTC_LOG(LS_WARNING) << "Unsupported framerate: "
+                        << parameters.framerate_fps;
+    return;
   }
   // Update bit rate
   if (codec_.maxBitrate > 0 &&
-      bitrate_allocation.get_sum_kbps() > codec_.maxBitrate) {
-    return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
+      parameters.bitrate.get_sum_kbps() > codec_.maxBitrate) {
+    RTC_LOG(LS_WARNING) << "Target bitrate exceeds maximum: "
+                        << parameters.bitrate.get_sum_kbps() << " vs "
+                        << codec_.maxBitrate;
+    return;
   }
 
-  codec_.maxFramerate = frame_rate;
+  codec_.maxFramerate = static_cast<uint32_t>(parameters.framerate_fps + 0.5);
+  requested_bitrate_allocation_ = parameters.bitrate;
 
-  requested_bitrate_allocation_ = bitrate_allocation;
-
-  return WEBRTC_VIDEO_CODEC_OK;
+  return;
 }
 
 int VP9EncoderImpl::InitEncode(const VideoCodec* inst,

modules/video_coding/codecs/vp9/vp9_impl.h

@@ -48,8 +48,7 @@ class VP9EncoderImpl : public VP9Encoder {
 
   int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
 
-  int SetRateAllocation(const VideoBitrateAllocation& bitrate_allocation,
-                        uint32_t frame_rate) override;
+  void SetRates(const RateControlParameters& parameters) override;
 
   EncoderInfo GetEncoderInfo() const override;
 

modules/video_coding/utility/simulcast_test_fixture_impl.cc

@@ -288,8 +288,9 @@ void SimulcastTestFixtureImpl::SetUpRateAllocator() {
 }
 
 void SimulcastTestFixtureImpl::SetRates(uint32_t bitrate_kbps, uint32_t fps) {
-  encoder_->SetRateAllocation(
-      rate_allocator_->GetAllocation(bitrate_kbps * 1000, fps), fps);
+  encoder_->SetRates(VideoEncoder::RateControlParameters(
+      rate_allocator_->GetAllocation(bitrate_kbps * 1000, fps),
+      static_cast<double>(fps)));
 }
 
 void SimulcastTestFixtureImpl::RunActiveStreamsTest(