diff --git a/api/test/mock_video_encoder.h b/api/test/mock_video_encoder.h
index f99f7e3..d4f7baf 100644
--- a/api/test/mock_video_encoder.h
+++ b/api/test/mock_video_encoder.h
@@ -48,7 +48,6 @@
   MOCK_METHOD2(SetRateAllocation,
                int32_t(const VideoBitrateAllocation& newBitRate,
                        uint32_t frameRate));
-  MOCK_METHOD1(SetRates, void(const RateControlParameters& parameters));
   MOCK_CONST_METHOD0(GetEncoderInfo, EncoderInfo(void));
 };
 
diff --git a/api/test/peerconnection_quality_test_fixture.h b/api/test/peerconnection_quality_test_fixture.h
index 289f850..b22b392 100644
--- a/api/test/peerconnection_quality_test_fixture.h
+++ b/api/test/peerconnection_quality_test_fixture.h
@@ -186,7 +186,7 @@
     // used to emulate overshooting of video encoders. This multiplier will
     // be applied for all video encoder on both sides for all layers. Bitrate
     // estimated by WebRTC stack will be multiplied on this multiplier and then
-    // provided into VideoEncoder::SetRates(...).
+    // provided into VideoEncoder::SetRateAllocation(...).
     double video_encoder_bitrate_multiplier = 1.0;
   };
 
diff --git a/api/video_codecs/test/video_encoder_software_fallback_wrapper_unittest.cc b/api/video_codecs/test/video_encoder_software_fallback_wrapper_unittest.cc
index 2a382ef..8ccafcc 100644
--- a/api/video_codecs/test/video_encoder_software_fallback_wrapper_unittest.cc
+++ b/api/video_codecs/test/video_encoder_software_fallback_wrapper_unittest.cc
@@ -114,8 +114,10 @@
       return WEBRTC_VIDEO_CODEC_OK;
     }
 
-    void SetRates(const RateControlParameters& parameters) override {
+    int32_t SetRateAllocation(const VideoBitrateAllocation& bitrate_allocation,
+                              uint32_t framerate) override {
       ++set_rates_count_;
+      return WEBRTC_VIDEO_CODEC_OK;
     }
 
     EncoderInfo GetEncoderInfo() const override {
@@ -203,8 +205,10 @@
   fake_encoder_->init_encode_return_code_ = WEBRTC_VIDEO_CODEC_ERROR;
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             fallback_wrapper_->InitEncode(&codec_, kNumCores, kMaxPayloadSize));
-  fallback_wrapper_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(300000, kFramerate), kFramerate));
+  EXPECT_EQ(
+      WEBRTC_VIDEO_CODEC_OK,
+      fallback_wrapper_->SetRateAllocation(
+          rate_allocator_->GetAllocation(300000, kFramerate), kFramerate));
 
   int callback_count = callback_.callback_count_;
   int encode_count = fake_encoder_->encode_count_;
@@ -222,8 +226,10 @@
   codec_.VP8()->numberOfTemporalLayers = 1;
   rate_allocator_.reset(new SimulcastRateAllocator(codec_));
   fallback_wrapper_->InitEncode(&codec_, 2, kMaxPayloadSize);
-  fallback_wrapper_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(300000, kFramerate), kFramerate));
+  EXPECT_EQ(
+      WEBRTC_VIDEO_CODEC_OK,
+      fallback_wrapper_->SetRateAllocation(
+          rate_allocator_->GetAllocation(300000, kFramerate), kFramerate));
   EXPECT_EQ(1, fake_encoder_->init_encode_count_);
 
   // Have the non-fallback encoder request a software fallback.
@@ -296,8 +302,7 @@
        SetRatesForwardedDuringFallback) {
   UtilizeFallbackEncoder();
   EXPECT_EQ(1, fake_encoder_->set_rates_count_);
-  fallback_wrapper_->SetRates(
-      VideoEncoder::RateControlParameters(VideoBitrateAllocation(), 1));
+  fallback_wrapper_->SetRateAllocation(VideoBitrateAllocation(), 1);
   EXPECT_EQ(2, fake_encoder_->set_rates_count_);
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_->Release());
 }
@@ -381,9 +386,10 @@
   }
 
   void SetRateAllocation(uint32_t bitrate_kbps) {
-    fallback_wrapper_->SetRates(VideoEncoder::RateControlParameters(
-        rate_allocator_->GetAllocation(bitrate_kbps * 1000, kFramerate),
-        kFramerate));
+    EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_->SetRateAllocation(
+                                         rate_allocator_->GetAllocation(
+                                             bitrate_kbps * 1000, kFramerate),
+                                         kFramerate));
   }
 
   void EncodeFrameAndVerifyLastName(const char* expected_name) {
diff --git a/api/video_codecs/video_encoder.cc b/api/video_codecs/video_encoder.cc
index d91bb4e..66ba9e4 100644
--- a/api/video_codecs/video_encoder.cc
+++ b/api/video_codecs/video_encoder.cc
@@ -108,13 +108,6 @@
 
 VideoEncoder::RateControlParameters::RateControlParameters(
     const VideoBitrateAllocation& bitrate,
-    double framerate_fps)
-    : bitrate(bitrate),
-      framerate_fps(framerate_fps),
-      bandwidth_allocation(DataRate::bps(bitrate.get_sum_bps())) {}
-
-VideoEncoder::RateControlParameters::RateControlParameters(
-    const VideoBitrateAllocation& bitrate,
     double framerate_fps,
     DataRate bandwidth_allocation)
     : bitrate(bitrate),
diff --git a/api/video_codecs/video_encoder.h b/api/video_codecs/video_encoder.h
index 3af7dfd..1c8dfd5 100644
--- a/api/video_codecs/video_encoder.h
+++ b/api/video_codecs/video_encoder.h
@@ -196,8 +196,6 @@
   struct RateControlParameters {
     RateControlParameters();
     RateControlParameters(const VideoBitrateAllocation& bitrate,
-                          double framerate_fps);
-    RateControlParameters(const VideoBitrateAllocation& bitrate,
                           double framerate_fps,
                           DataRate bandwidth_allocation);
     virtual ~RateControlParameters();
diff --git a/api/video_codecs/video_encoder_software_fallback_wrapper.cc b/api/video_codecs/video_encoder_software_fallback_wrapper.cc
index a687b84..46659a4 100644
--- a/api/video_codecs/video_encoder_software_fallback_wrapper.cc
+++ b/api/video_codecs/video_encoder_software_fallback_wrapper.cc
@@ -88,7 +88,8 @@
   int32_t Release() override;
   int32_t Encode(const VideoFrame& frame,
                  const std::vector<VideoFrameType>* frame_types) override;
-  void SetRates(const RateControlParameters& parameters) override;
+  int32_t SetRateAllocation(const VideoBitrateAllocation& bitrate_allocation,
+                            uint32_t framerate) override;
   EncoderInfo GetEncoderInfo() const override;
 
  private:
@@ -121,8 +122,10 @@
   int32_t number_of_cores_;
   size_t max_payload_size_;
 
-  // The last rate control settings, if set.
-  absl::optional<RateControlParameters> rate_control_parameters_;
+  // The last bitrate/framerate set, and a flag for noting they are set.
+  bool rates_set_;
+  VideoBitrateAllocation bitrate_allocation_;
+  uint32_t framerate_;
 
   // The last channel parameters set, and a flag for noting they are set.
   bool channel_parameters_set_;
@@ -144,6 +147,8 @@
     std::unique_ptr<webrtc::VideoEncoder> hw_encoder)
     : number_of_cores_(0),
       max_payload_size_(0),
+      rates_set_(false),
+      framerate_(0),
       channel_parameters_set_(false),
       packet_loss_(0),
       rtt_(0),
@@ -176,8 +181,8 @@
   // Replay callback, rates, and channel parameters.
   if (callback_)
     fallback_encoder_->RegisterEncodeCompleteCallback(callback_);
-  if (rate_control_parameters_)
-    fallback_encoder_->SetRates(*rate_control_parameters_);
+  if (rates_set_)
+    fallback_encoder_->SetRateAllocation(bitrate_allocation_, framerate_);
 
   // Since we're switching to the fallback encoder, Release the real encoder. It
   // may be re-initialized via InitEncode later, and it will continue to get
@@ -196,7 +201,7 @@
   number_of_cores_ = number_of_cores;
   max_payload_size_ = max_payload_size;
   // Clear stored rate/channel parameters.
-  rate_control_parameters_ = absl::nullopt;
+  rates_set_ = false;
   ValidateSettingsForForcedFallback();
 
   // Try to reinit forced software codec if it is in use.
@@ -259,12 +264,16 @@
   return ret;
 }
 
-void VideoEncoderSoftwareFallbackWrapper::SetRates(
-    const RateControlParameters& parameters) {
-  rate_control_parameters_ = parameters;
-  encoder_->SetRates(parameters);
+int32_t VideoEncoderSoftwareFallbackWrapper::SetRateAllocation(
+    const VideoBitrateAllocation& bitrate_allocation,
+    uint32_t framerate) {
+  rates_set_ = true;
+  bitrate_allocation_ = bitrate_allocation;
+  framerate_ = framerate;
+  int32_t ret = encoder_->SetRateAllocation(bitrate_allocation_, framerate);
   if (use_fallback_encoder_)
-    fallback_encoder_->SetRates(parameters);
+    return fallback_encoder_->SetRateAllocation(bitrate_allocation_, framerate);
+  return ret;
 }
 
 VideoEncoder::EncoderInfo VideoEncoderSoftwareFallbackWrapper::GetEncoderInfo()
diff --git a/call/call_perf_tests.cc b/call/call_perf_tests.cc
index 4a686ed..f3955c9 100644
--- a/call/call_perf_tests.cc
+++ b/call/call_perf_tests.cc
@@ -774,13 +774,14 @@
       return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
     }
 
-    void SetRates(const RateControlParameters& parameters) override {
-      last_set_bitrate_kbps_ = parameters.bitrate.get_sum_kbps();
+    int32_t SetRateAllocation(const VideoBitrateAllocation& rate_allocation,
+                              uint32_t framerate) override {
+      last_set_bitrate_kbps_ = rate_allocation.get_sum_kbps();
       if (encoder_inits_ == 1 &&
-          parameters.bitrate.get_sum_kbps() > kReconfigureThresholdKbps) {
+          rate_allocation.get_sum_kbps() > kReconfigureThresholdKbps) {
         time_to_reconfigure_.Set();
       }
-      FakeEncoder::SetRates(parameters);
+      return FakeEncoder::SetRateAllocation(rate_allocation, framerate);
     }
 
     void ModifySenderBitrateConfig(
diff --git a/media/engine/encoder_simulcast_proxy.cc b/media/engine/encoder_simulcast_proxy.cc
index f2c87ff..8c2f825 100644
--- a/media/engine/encoder_simulcast_proxy.cc
+++ b/media/engine/encoder_simulcast_proxy.cc
@@ -55,8 +55,10 @@
   return encoder_->RegisterEncodeCompleteCallback(callback);
 }
 
-void EncoderSimulcastProxy::SetRates(const RateControlParameters& parameters) {
-  return encoder_->SetRates(parameters);
+int EncoderSimulcastProxy::SetRateAllocation(
+    const VideoBitrateAllocation& bitrate,
+    uint32_t new_framerate) {
+  return encoder_->SetRateAllocation(bitrate, new_framerate);
 }
 
 void EncoderSimulcastProxy::OnPacketLossRateUpdate(float packet_loss_rate) {
diff --git a/media/engine/encoder_simulcast_proxy.h b/media/engine/encoder_simulcast_proxy.h
index 41ffcba..1251e58 100644
--- a/media/engine/encoder_simulcast_proxy.h
+++ b/media/engine/encoder_simulcast_proxy.h
@@ -48,7 +48,8 @@
   int Encode(const VideoFrame& input_image,
              const std::vector<VideoFrameType>* frame_types) override;
   int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
-  void SetRates(const RateControlParameters& parameters) override;
+  int SetRateAllocation(const VideoBitrateAllocation& bitrate,
+                        uint32_t new_framerate) override;
   void OnPacketLossRateUpdate(float packet_loss_rate) override;
   void OnRttUpdate(int64_t rtt_ms) override;
   void OnLossNotification(const LossNotification& loss_notification) override;
diff --git a/media/engine/fake_webrtc_video_engine.cc b/media/engine/fake_webrtc_video_engine.cc
index 5d657fe..d4de300 100644
--- a/media/engine/fake_webrtc_video_engine.cc
+++ b/media/engine/fake_webrtc_video_engine.cc
@@ -166,7 +166,10 @@
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
-void FakeWebRtcVideoEncoder::SetRates(const RateControlParameters& parameters) {
+int32_t FakeWebRtcVideoEncoder::SetRateAllocation(
+    const webrtc::VideoBitrateAllocation& allocation,
+    uint32_t framerate) {
+  return WEBRTC_VIDEO_CODEC_OK;
 }
 
 webrtc::VideoEncoder::EncoderInfo FakeWebRtcVideoEncoder::GetEncoderInfo()
diff --git a/media/engine/fake_webrtc_video_engine.h b/media/engine/fake_webrtc_video_engine.h
index 662caf1..3265274 100644
--- a/media/engine/fake_webrtc_video_engine.h
+++ b/media/engine/fake_webrtc_video_engine.h
@@ -93,7 +93,8 @@
   int32_t RegisterEncodeCompleteCallback(
       webrtc::EncodedImageCallback* callback) override;
   int32_t Release() override;
-  void SetRates(const RateControlParameters& parameters) override;
+  int32_t SetRateAllocation(const webrtc::VideoBitrateAllocation& allocation,
+                            uint32_t framerate) override;
   webrtc::VideoEncoder::EncoderInfo GetEncoderInfo() const override;
 
   bool WaitForInitEncode();
diff --git a/media/engine/simulcast_encoder_adapter.cc b/media/engine/simulcast_encoder_adapter.cc
index 1147d45..09b0545 100644
--- a/media/engine/simulcast_encoder_adapter.cc
+++ b/media/engine/simulcast_encoder_adapter.cc
@@ -28,7 +28,6 @@
 #include "rtc_base/atomic_ops.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/experiments/rate_control_settings.h"
-#include "rtc_base/logging.h"
 #include "system_wrappers/include/field_trial.h"
 #include "third_party/libyuv/include/libyuv/scale.h"
 
@@ -444,54 +443,41 @@
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
-void SimulcastEncoderAdapter::SetRates(
-    const RateControlParameters& parameters) {
+int SimulcastEncoderAdapter::SetRateAllocation(
+    const VideoBitrateAllocation& bitrate,
+    uint32_t new_framerate) {
   RTC_DCHECK_RUN_ON(&encoder_queue_);
 
   if (!Initialized()) {
-    RTC_LOG(LS_WARNING) << "SetRates while not initialized";
-    return;
+    return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
 
-  if (parameters.framerate_fps < 1.0) {
-    RTC_LOG(LS_WARNING) << "Invalid framerate: " << parameters.framerate_fps;
-    return;
+  if (new_framerate < 1) {
+    return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
 
-  if (codec_.maxBitrate > 0 &&
-      parameters.bitrate.get_sum_kbps() > codec_.maxBitrate) {
-    RTC_LOG(LS_WARNING) << "Total bitrate " << parameters.bitrate.get_sum_kbps()
-                        << " exceeds max bitrate: " << codec_.maxBitrate;
-    return;
+  if (codec_.maxBitrate > 0 && bitrate.get_sum_kbps() > codec_.maxBitrate) {
+    return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
 
-  if (parameters.bitrate.get_sum_bps() > 0) {
+  if (bitrate.get_sum_bps() > 0) {
     // Make sure the bitrate fits the configured min bitrates. 0 is a special
     // value that means paused, though, so leave it alone.
-    if (parameters.bitrate.get_sum_kbps() < codec_.minBitrate) {
-      RTC_LOG(LS_WARNING) << "Total bitrate "
-                          << parameters.bitrate.get_sum_kbps()
-                          << " is lower than minimum bitrate: "
-                          << codec_.minBitrate;
-      return;
+    if (bitrate.get_sum_kbps() < codec_.minBitrate) {
+      return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
     }
 
     if (codec_.numberOfSimulcastStreams > 0 &&
-        parameters.bitrate.get_sum_kbps() <
-            codec_.simulcastStream[0].minBitrate) {
-      RTC_LOG(LS_WARNING) << "Total bitrate "
-                          << parameters.bitrate.get_sum_kbps()
-                          << " is lower than minimum bitrate of base layer: "
-                          << codec_.simulcastStream[0].minBitrate;
-      return;
+        bitrate.get_sum_kbps() < codec_.simulcastStream[0].minBitrate) {
+      return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
     }
   }
 
-  codec_.maxFramerate = static_cast<uint32_t>(parameters.framerate_fps + 0.5);
+  codec_.maxFramerate = new_framerate;
 
   for (size_t stream_idx = 0; stream_idx < streaminfos_.size(); ++stream_idx) {
     uint32_t stream_bitrate_kbps =
-        parameters.bitrate.GetSpatialLayerSum(stream_idx) / 1000;
+        bitrate.GetSpatialLayerSum(stream_idx) / 1000;
 
     // Need a key frame if we have not sent this stream before.
     if (stream_bitrate_kbps > 0 && !streaminfos_[stream_idx].send_stream) {
@@ -501,31 +487,17 @@
 
     // Slice the temporal layers out of the full allocation and pass it on to
     // the encoder handling the current simulcast stream.
-    RateControlParameters stream_parameters = parameters;
-    stream_parameters.bitrate = VideoBitrateAllocation();
+    VideoBitrateAllocation stream_allocation;
     for (int i = 0; i < kMaxTemporalStreams; ++i) {
-      if (parameters.bitrate.HasBitrate(stream_idx, i)) {
-        stream_parameters.bitrate.SetBitrate(
-            0, i, parameters.bitrate.GetBitrate(stream_idx, i));
+      if (bitrate.HasBitrate(stream_idx, i)) {
+        stream_allocation.SetBitrate(0, i, bitrate.GetBitrate(stream_idx, i));
       }
     }
-
-    // Assign link allocation proportionally to spatial layer allocation.
-    if (parameters.bandwidth_allocation != DataRate::Zero()) {
-      stream_parameters.bandwidth_allocation =
-          DataRate::bps((parameters.bandwidth_allocation.bps() *
-                         stream_parameters.bitrate.get_sum_bps()) /
-                        parameters.bitrate.get_sum_bps());
-      // Make sure we don't allocate bandwidth lower than target bitrate.
-      if (stream_parameters.bandwidth_allocation.bps() <
-          stream_parameters.bitrate.get_sum_bps()) {
-        stream_parameters.bandwidth_allocation =
-            DataRate::bps(stream_parameters.bitrate.get_sum_bps());
-      }
-    }
-
-    streaminfos_[stream_idx].encoder->SetRates(stream_parameters);
+    streaminfos_[stream_idx].encoder->SetRateAllocation(stream_allocation,
+                                                        new_framerate);
   }
+
+  return WEBRTC_VIDEO_CODEC_OK;
 }
 
 // TODO(brandtr): Add task checker to this member function, when all encoder
diff --git a/media/engine/simulcast_encoder_adapter.h b/media/engine/simulcast_encoder_adapter.h
index 5bc0bec..a7b0361 100644
--- a/media/engine/simulcast_encoder_adapter.h
+++ b/media/engine/simulcast_encoder_adapter.h
@@ -48,7 +48,8 @@
   int Encode(const VideoFrame& input_image,
              const std::vector<VideoFrameType>* frame_types) override;
   int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
-  void SetRates(const RateControlParameters& parameters) override;
+  int SetRateAllocation(const VideoBitrateAllocation& bitrate,
+                        uint32_t new_framerate) override;
 
   // Eventual handler for the contained encoders' EncodedImageCallbacks, but
   // called from an internal helper that also knows the correct stream
diff --git a/media/engine/simulcast_encoder_adapter_unittest.cc b/media/engine/simulcast_encoder_adapter_unittest.cc
index 1bab49a..8d68fa1 100644
--- a/media/engine/simulcast_encoder_adapter_unittest.cc
+++ b/media/engine/simulcast_encoder_adapter_unittest.cc
@@ -207,8 +207,10 @@
 
   MOCK_METHOD0(Release, int32_t());
 
-  void SetRates(const RateControlParameters& parameters) {
-    last_set_rates_ = parameters;
+  int32_t SetRateAllocation(const VideoBitrateAllocation& bitrate_allocation,
+                            uint32_t framerate) {
+    last_set_bitrate_ = bitrate_allocation;
+    return 0;
   }
 
   EncoderInfo GetEncoderInfo() const override {
@@ -269,7 +271,7 @@
     fps_allocation_ = fps_allocation;
   }
 
-  RateControlParameters last_set_rates() const { return last_set_rates_; }
+  VideoBitrateAllocation last_set_bitrate() const { return last_set_bitrate_; }
 
  private:
   MockVideoEncoderFactory* const factory_;
@@ -280,7 +282,7 @@
   bool is_hardware_accelerated_ = false;
   bool has_internal_source_ = false;
   int32_t init_encode_return_value_ = 0;
-  VideoEncoder::RateControlParameters last_set_rates_;
+  VideoBitrateAllocation last_set_bitrate_;
   FramerateFractions fps_allocation_;
 
   VideoCodec codec_;
@@ -498,8 +500,7 @@
   SetupCodec();
 
   // Set bitrates so that we send all layers.
-  adapter_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(1200, 30), 30.0));
+  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
@@ -559,8 +560,8 @@
   // Encode with three streams.
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
   VerifyCodecSettings();
-  adapter_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(target_bitrate, 30), 30.0));
+  adapter_->SetRateAllocation(
+      rate_allocator_->GetAllocation(target_bitrate, 30), 30);
 
   std::vector<MockVideoEncoder*> original_encoders =
       helper_->factory()->encoders();
@@ -586,8 +587,8 @@
   codec_.height /= 2;
   codec_.numberOfSimulcastStreams = 2;
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
-  adapter_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(target_bitrate, 30), 30.0));
+  adapter_->SetRateAllocation(
+      rate_allocator_->GetAllocation(target_bitrate, 30), 30);
   std::vector<MockVideoEncoder*> new_encoders = helper_->factory()->encoders();
   ASSERT_EQ(2u, new_encoders.size());
   ASSERT_EQ(original_encoders[0], new_encoders[0]);
@@ -609,8 +610,8 @@
   codec_.height /= 2;
   codec_.numberOfSimulcastStreams = 1;
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
-  adapter_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(target_bitrate, 30), 30.0));
+  adapter_->SetRateAllocation(
+      rate_allocator_->GetAllocation(target_bitrate, 30), 30);
   new_encoders = helper_->factory()->encoders();
   ASSERT_EQ(1u, new_encoders.size());
   ASSERT_EQ(original_encoders[0], new_encoders[0]);
@@ -627,8 +628,8 @@
   codec_.height *= 4;
   codec_.numberOfSimulcastStreams = 3;
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
-  adapter_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(target_bitrate, 30), 30.0));
+  adapter_->SetRateAllocation(
+      rate_allocator_->GetAllocation(target_bitrate, 30), 30);
   new_encoders = helper_->factory()->encoders();
   ASSERT_EQ(3u, new_encoders.size());
   // The first encoder is reused.
@@ -711,8 +712,7 @@
 // discontinuities.
 TEST_F(TestSimulcastEncoderAdapterFake, ReinitDoesNotReorderFrameSimulcastIdx) {
   SetupCodec();
-  adapter_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(1200, 30), 30.0));
+  adapter_->SetRateAllocation(rate_allocator_->GetAllocation(1200, 30), 30);
   VerifyCodecSettings();
 
   // Send frames on all streams.
@@ -736,8 +736,7 @@
   // Reinitialize.
   EXPECT_EQ(0, adapter_->Release());
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
-  adapter_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(1200, 30), 30.0));
+  adapter_->SetRateAllocation(rate_allocator_->GetAllocation(1200, 30), 30);
 
   // Verify that the same encoder sends out frames on the same simulcast index.
   encoders[0]->SendEncodedImage(1152, 704);
@@ -781,23 +780,21 @@
   // Above min should be respected.
   VideoBitrateAllocation target_bitrate =
       rate_allocator_->GetAllocation(codec_.minBitrate * 1000, 30);
-  adapter_->SetRates(VideoEncoder::RateControlParameters(target_bitrate, 30.0));
+  adapter_->SetRateAllocation(target_bitrate, 30);
   EXPECT_EQ(target_bitrate,
-            helper_->factory()->encoders()[0]->last_set_rates().bitrate);
+            helper_->factory()->encoders()[0]->last_set_bitrate());
 
   // Below min but non-zero should be replaced with the min bitrate.
   VideoBitrateAllocation too_low_bitrate =
       rate_allocator_->GetAllocation((codec_.minBitrate - 1) * 1000, 30);
-  adapter_->SetRates(
-      VideoEncoder::RateControlParameters(too_low_bitrate, 30.0));
+  adapter_->SetRateAllocation(too_low_bitrate, 30);
   EXPECT_EQ(target_bitrate,
-            helper_->factory()->encoders()[0]->last_set_rates().bitrate);
+            helper_->factory()->encoders()[0]->last_set_bitrate());
 
   // Zero should be passed on as is, since it means "pause".
-  adapter_->SetRates(
-      VideoEncoder::RateControlParameters(VideoBitrateAllocation(), 30.0));
+  adapter_->SetRateAllocation(VideoBitrateAllocation(), 30);
   EXPECT_EQ(VideoBitrateAllocation(),
-            helper_->factory()->encoders()[0]->last_set_rates().bitrate);
+            helper_->factory()->encoders()[0]->last_set_bitrate());
 }
 
 TEST_F(TestSimulcastEncoderAdapterFake, SupportsImplementationName) {
@@ -1160,45 +1157,5 @@
               ::testing::ElementsAreArray(expected_fps_allocation));
 }
 
-TEST_F(TestSimulcastEncoderAdapterFake, SetRateDistributesBandwithAllocation) {
-  SimulcastTestFixtureImpl::DefaultSettings(
-      &codec_, static_cast<const int*>(kTestTemporalLayerProfile),
-      kVideoCodecVP8);
-  codec_.numberOfSimulcastStreams = 3;
-  const DataRate target_bitrate =
-      DataRate::kbps(codec_.simulcastStream[0].targetBitrate +
-                     codec_.simulcastStream[1].targetBitrate +
-                     codec_.simulcastStream[2].minBitrate);
-  const DataRate bandwidth_allocation = target_bitrate + DataRate::kbps(600);
-
-  rate_allocator_.reset(new SimulcastRateAllocator(codec_));
-  EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
-  adapter_->RegisterEncodeCompleteCallback(this);
-
-  // Set bitrates so that we send all layers.
-  adapter_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(target_bitrate.bps(), 30), 30.0,
-      bandwidth_allocation));
-
-  std::vector<MockVideoEncoder*> encoders = helper_->factory()->encoders();
-
-  ASSERT_EQ(3u, encoders.size());
-
-  for (size_t i = 0; i < 3; ++i) {
-    const uint32_t layer_bitrate_bps =
-        (i < static_cast<size_t>(codec_.numberOfSimulcastStreams) - 1
-             ? codec_.simulcastStream[i].targetBitrate
-             : codec_.simulcastStream[i].minBitrate) *
-        1000;
-    EXPECT_EQ(layer_bitrate_bps,
-              encoders[i]->last_set_rates().bitrate.get_sum_bps())
-        << i;
-    EXPECT_EQ(
-        (layer_bitrate_bps * bandwidth_allocation.bps()) / target_bitrate.bps(),
-        encoders[i]->last_set_rates().bandwidth_allocation.bps())
-        << i;
-  }
-}
-
 }  // namespace test
 }  // namespace webrtc
diff --git a/modules/video_coding/codecs/h264/h264_encoder_impl.cc b/modules/video_coding/codecs/h264/h264_encoder_impl.cc
index 495c11a..9d96100 100644
--- a/modules/video_coding/codecs/h264/h264_encoder_impl.cc
+++ b/modules/video_coding/codecs/h264/h264_encoder_impl.cc
@@ -306,8 +306,7 @@
   SimulcastRateAllocator init_allocator(codec_);
   VideoBitrateAllocation allocation = init_allocator.GetAllocation(
       codec_.startBitrate * 1000, codec_.maxFramerate);
-  SetRates(RateControlParameters(allocation, codec_.maxFramerate));
-  return WEBRTC_VIDEO_CODEC_OK;
+  return SetRateAllocation(allocation, codec_.maxFramerate);
 }
 
 int32_t H264EncoderImpl::Release() {
@@ -332,40 +331,36 @@
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
-void H264EncoderImpl::SetRates(const RateControlParameters& parameters) {
-  if (encoders_.empty()) {
-    RTC_LOG(LS_WARNING) << "SetRates() while uninitialized.";
-    return;
-  }
+int32_t H264EncoderImpl::SetRateAllocation(
+    const VideoBitrateAllocation& bitrate,
+    uint32_t new_framerate) {
+  if (encoders_.empty())
+    return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
 
-  if (parameters.framerate_fps < 1.0) {
-    RTC_LOG(LS_WARNING) << "Invalid frame rate: " << parameters.framerate_fps;
-    return;
-  }
+  if (new_framerate < 1)
+    return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
 
-  if (parameters.bitrate.get_sum_bps() == 0) {
+  if (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;
+    return WEBRTC_VIDEO_CODEC_OK;
   }
 
   // At this point, bitrate allocation should already match codec settings.
   if (codec_.maxBitrate > 0)
-    RTC_DCHECK_LE(parameters.bitrate.get_sum_kbps(), codec_.maxBitrate);
-  RTC_DCHECK_GE(parameters.bitrate.get_sum_kbps(), codec_.minBitrate);
+    RTC_DCHECK_LE(bitrate.get_sum_kbps(), codec_.maxBitrate);
+  RTC_DCHECK_GE(bitrate.get_sum_kbps(), codec_.minBitrate);
   if (codec_.numberOfSimulcastStreams > 0)
-    RTC_DCHECK_GE(parameters.bitrate.get_sum_kbps(),
-                  codec_.simulcastStream[0].minBitrate);
+    RTC_DCHECK_GE(bitrate.get_sum_kbps(), codec_.simulcastStream[0].minBitrate);
 
-  codec_.maxFramerate = static_cast<uint32_t>(parameters.framerate_fps);
+  codec_.maxFramerate = new_framerate;
 
   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 =
-        parameters.bitrate.GetSpatialLayerSum(stream_idx);
-    configurations_[i].max_frame_rate = parameters.framerate_fps;
+    configurations_[i].target_bps = bitrate.GetSpatialLayerSum(stream_idx);
+    configurations_[i].max_frame_rate = static_cast<float>(new_framerate);
 
     if (configurations_[i].target_bps) {
       configurations_[i].SetStreamState(true);
@@ -382,6 +377,8 @@
       configurations_[i].SetStreamState(false);
     }
   }
+
+  return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t H264EncoderImpl::Encode(
diff --git a/modules/video_coding/codecs/h264/h264_encoder_impl.h b/modules/video_coding/codecs/h264/h264_encoder_impl.h
index 74592ef..d0cde34 100644
--- a/modules/video_coding/codecs/h264/h264_encoder_impl.h
+++ b/modules/video_coding/codecs/h264/h264_encoder_impl.h
@@ -61,7 +61,8 @@
 
   int32_t RegisterEncodeCompleteCallback(
       EncodedImageCallback* callback) override;
-  void SetRates(const RateControlParameters& parameters) override;
+  int32_t SetRateAllocation(const VideoBitrateAllocation& bitrate_allocation,
+                            uint32_t framerate) override;
 
   // The result of encoding - an EncodedImage and RTPFragmentationHeader - are
   // passed to the encode complete callback.
diff --git a/modules/video_coding/codecs/multiplex/include/multiplex_encoder_adapter.h b/modules/video_coding/codecs/multiplex/include/multiplex_encoder_adapter.h
index bb00b54..de010c9 100644
--- a/modules/video_coding/codecs/multiplex/include/multiplex_encoder_adapter.h
+++ b/modules/video_coding/codecs/multiplex/include/multiplex_encoder_adapter.h
@@ -45,7 +45,8 @@
   int Encode(const VideoFrame& input_image,
              const std::vector<VideoFrameType>* frame_types) override;
   int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
-  void SetRates(const RateControlParameters& parameters) override;
+  int SetRateAllocation(const VideoBitrateAllocation& bitrate,
+                        uint32_t new_framerate) override;
   int Release() override;
   EncoderInfo GetEncoderInfo() const override;
 
diff --git a/modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc b/modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc
index 8c86699..16bcd51 100644
--- a/modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc
+++ b/modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc
@@ -216,21 +216,23 @@
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
-void MultiplexEncoderAdapter::SetRates(
-    const RateControlParameters& parameters) {
-  VideoBitrateAllocation bitrate_allocation(parameters.bitrate);
+int MultiplexEncoderAdapter::SetRateAllocation(
+    const VideoBitrateAllocation& bitrate,
+    uint32_t framerate) {
+  VideoBitrateAllocation bitrate_allocation(bitrate);
   bitrate_allocation.SetBitrate(
-      0, 0, parameters.bitrate.GetBitrate(0, 0) - augmenting_data_size_);
+      0, 0, 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.
-    encoder->SetRates(RateControlParameters(
+    const int rv = encoder->SetRateAllocation(
         bitrate_allocation,
-        static_cast<uint32_t>(encoders_.size() * parameters.framerate_fps),
-        parameters.bandwidth_allocation -
-            DataRate::bps(augmenting_data_size_)));
+        static_cast<uint32_t>(encoders_.size()) * framerate);
+    if (rv)
+      return rv;
   }
+  return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int MultiplexEncoderAdapter::Release() {
diff --git a/modules/video_coding/codecs/test/videoprocessor.cc b/modules/video_coding/codecs/test/videoprocessor.cc
index 8d6d3ad..708f6fe 100644
--- a/modules/video_coding/codecs/test/videoprocessor.cc
+++ b/modules/video_coding/codecs/test/videoprocessor.cc
@@ -300,8 +300,10 @@
   framerate_fps_ = static_cast<uint32_t>(framerate_fps);
   bitrate_allocation_ = bitrate_allocator_->GetAllocation(
       static_cast<uint32_t>(bitrate_kbps * 1000), framerate_fps_);
-  encoder_->SetRates(VideoEncoder::RateControlParameters(
-      bitrate_allocation_, static_cast<double>(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 << ".";
 }
 
 int32_t VideoProcessor::VideoProcessorDecodeCompleteCallback::Decoded(
diff --git a/modules/video_coding/codecs/test/videoprocessor_unittest.cc b/modules/video_coding/codecs/test/videoprocessor_unittest.cc
index de1d798..842ad7e 100644
--- a/modules/video_coding/codecs/test/videoprocessor_unittest.cc
+++ b/modules/video_coding/codecs/test/videoprocessor_unittest.cc
@@ -25,10 +25,7 @@
 #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 {
@@ -99,11 +96,9 @@
 TEST_F(VideoProcessorTest, ProcessFrames_FixedFramerate) {
   const int kBitrateKbps = 456;
   const int kFramerateFps = 31;
-  EXPECT_CALL(
-      encoder_mock_,
-      SetRates(Field(&VideoEncoder::RateControlParameters::framerate_fps,
-                     static_cast<double>(kFramerateFps))))
-      .Times(1);
+  EXPECT_CALL(encoder_mock_, SetRateAllocation(_, kFramerateFps))
+      .Times(1)
+      .WillOnce(Return(0));
   q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); });
 
   EXPECT_CALL(frame_reader_mock_, ReadFrame())
@@ -127,11 +122,9 @@
   const int kBitrateKbps = 456;
   const int kStartFramerateFps = 27;
   const int kStartTimestamp = 90000 / kStartFramerateFps;
-  EXPECT_CALL(
-      encoder_mock_,
-      SetRates(Field(&VideoEncoder::RateControlParameters::framerate_fps,
-                     static_cast<double>(kStartFramerateFps))))
-      .Times(1);
+  EXPECT_CALL(encoder_mock_, SetRateAllocation(_, kStartFramerateFps))
+      .Times(1)
+      .WillOnce(Return(0));
   q_.SendTask(
       [=] { video_processor_->SetRates(kBitrateKbps, kStartFramerateFps); });
 
@@ -143,11 +136,9 @@
   q_.SendTask([this] { video_processor_->ProcessFrame(); });
 
   const int kNewFramerateFps = 13;
-  EXPECT_CALL(
-      encoder_mock_,
-      SetRates(Field(&VideoEncoder::RateControlParameters::framerate_fps,
-                     static_cast<double>(kNewFramerateFps))))
-      .Times(1);
+  EXPECT_CALL(encoder_mock_, SetRateAllocation(_, kNewFramerateFps))
+      .Times(1)
+      .WillOnce(Return(0));
   q_.SendTask(
       [=] { video_processor_->SetRates(kBitrateKbps, kNewFramerateFps); });
 
@@ -162,32 +153,21 @@
 }
 
 TEST_F(VideoProcessorTest, SetRates) {
-  const uint32_t kBitrateKbps = 123;
+  const int kBitrateKbps = 123;
   const int kFramerateFps = 17;
-
-  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)))))
+  EXPECT_CALL(encoder_mock_,
+              SetRateAllocation(
+                  Property(&VideoBitrateAllocation::get_sum_kbps, kBitrateKbps),
+                  kFramerateFps))
       .Times(1);
   q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); });
 
-  const uint32_t kNewBitrateKbps = 456;
+  const int kNewBitrateKbps = 456;
   const int kNewFramerateFps = 34;
-  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)))))
+  EXPECT_CALL(encoder_mock_,
+              SetRateAllocation(Property(&VideoBitrateAllocation::get_sum_kbps,
+                                         kNewBitrateKbps),
+                                kNewFramerateFps))
       .Times(1);
   q_.SendTask(
       [=] { video_processor_->SetRates(kNewBitrateKbps, kNewFramerateFps); });
diff --git a/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc b/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
index 9329f22..e2d4089 100644
--- a/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
+++ b/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
@@ -36,7 +36,6 @@
 #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"
@@ -248,40 +247,33 @@
   return ret_val;
 }
 
-void LibvpxVp8Encoder::SetRates(const RateControlParameters& parameters) {
-  if (!inited_) {
-    RTC_LOG(LS_WARNING) << "SetRates() while not initialize";
-    return;
-  }
+int LibvpxVp8Encoder::SetRateAllocation(const VideoBitrateAllocation& bitrate,
+                                        uint32_t new_framerate) {
+  if (!inited_)
+    return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
 
-  if (encoders_[0].err) {
-    RTC_LOG(LS_WARNING) << "Encoder in error state.";
-    return;
-  }
+  if (encoders_[0].err)
+    return WEBRTC_VIDEO_CODEC_ERROR;
 
-  if (parameters.framerate_fps < 1.0) {
-    RTC_LOG(LS_WARNING) << "Unsupported framerate (must be >= 1.0): "
-                        << parameters.framerate_fps;
-    return;
-  }
+  if (new_framerate < 1)
+    return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
 
-  if (parameters.bitrate.get_sum_bps() == 0) {
+  if (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;
+    return WEBRTC_VIDEO_CODEC_OK;
   }
 
   // At this point, bitrate allocation should already match codec settings.
   if (codec_.maxBitrate > 0)
-    RTC_DCHECK_LE(parameters.bitrate.get_sum_kbps(), codec_.maxBitrate);
-  RTC_DCHECK_GE(parameters.bitrate.get_sum_kbps(), codec_.minBitrate);
+    RTC_DCHECK_LE(bitrate.get_sum_kbps(), codec_.maxBitrate);
+  RTC_DCHECK_GE(bitrate.get_sum_kbps(), codec_.minBitrate);
   if (codec_.numberOfSimulcastStreams > 0)
-    RTC_DCHECK_GE(parameters.bitrate.get_sum_kbps(),
-                  codec_.simulcastStream[0].minBitrate);
+    RTC_DCHECK_GE(bitrate.get_sum_kbps(), codec_.simulcastStream[0].minBitrate);
 
-  codec_.maxFramerate = static_cast<uint32_t>(parameters.framerate_fps + 0.5);
+  codec_.maxFramerate = new_framerate;
 
   if (encoders_.size() > 1) {
     // If we have more than 1 stream, reduce the qp_max for the low resolution
@@ -290,7 +282,7 @@
     // 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() &&
-        parameters.framerate_fps > 20.0) {
+        new_framerate > 20) {
       configurations_[encoders_.size() - 1].rc_max_quantizer = 45;
     } else {
       // Go back to default value set in InitEncode.
@@ -301,7 +293,7 @@
   size_t stream_idx = encoders_.size() - 1;
   for (size_t i = 0; i < encoders_.size(); ++i, --stream_idx) {
     unsigned int target_bitrate_kbps =
-        parameters.bitrate.GetSpatialLayerSum(stream_idx) / 1000;
+        bitrate.GetSpatialLayerSum(stream_idx) / 1000;
 
     bool send_stream = target_bitrate_kbps > 0;
     if (send_stream || encoders_.size() > 1)
@@ -310,19 +302,18 @@
     configurations_[i].rc_target_bitrate = target_bitrate_kbps;
     if (send_stream) {
       frame_buffer_controller_->OnRatesUpdated(
-          stream_idx, parameters.bitrate.GetTemporalLayerAllocation(stream_idx),
-          static_cast<int>(parameters.framerate_fps + 0.5));
+          stream_idx, bitrate.GetTemporalLayerAllocation(stream_idx),
+          new_framerate);
     }
 
     UpdateVpxConfiguration(stream_idx, frame_buffer_controller_.get(),
                            &configurations_[i]);
 
-    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;
+    if (libvpx_->codec_enc_config_set(&encoders_[i], &configurations_[i])) {
+      return WEBRTC_VIDEO_CODEC_ERROR;
     }
   }
+  return WEBRTC_VIDEO_CODEC_OK;
 }
 
 void LibvpxVp8Encoder::OnPacketLossRateUpdate(float packet_loss_rate) {
diff --git a/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.h b/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.h
index 0913f5b..535f032 100644
--- a/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.h
+++ b/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.h
@@ -54,7 +54,8 @@
 
   int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
 
-  void SetRates(const RateControlParameters& parameters) override;
+  int SetRateAllocation(const VideoBitrateAllocation& bitrate,
+                        uint32_t new_framerate) override;
 
   void OnPacketLossRateUpdate(float packet_loss_rate) override;
 
diff --git a/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc b/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
index a5381c3..a9248bd 100644
--- a/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
+++ b/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
@@ -110,23 +110,20 @@
   }
 };
 
-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));
+TEST_F(TestVp8Impl, SetRateAllocation) {
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, encoder_->Release());
 
-  const uint32_t kBitrateBps = 300000;
+  const int kBitrateBps = 300000;
   VideoBitrateAllocation bitrate_allocation;
   bitrate_allocation.SetBitrate(0, 0, kBitrateBps);
-  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)));
+  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));
 }
 
 TEST_F(TestVp8Impl, EncodeFrameAndRelease) {
@@ -444,8 +441,7 @@
   VideoBitrateAllocation bitrate_allocation;
   // Bitrate only enough for TL0.
   bitrate_allocation.SetBitrate(0, 0, 200000);
-  encoder_->SetRates(
-      VideoEncoder::RateControlParameters(bitrate_allocation, 5.0));
+  encoder_->SetRateAllocation(bitrate_allocation, 5);
 
   EncodedImage encoded_frame;
   CodecSpecificInfo codec_specific_info;
diff --git a/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc b/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
index 3db7c93..87f991d 100644
--- a/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
+++ b/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
@@ -375,8 +375,9 @@
     bitrate_allocation.SetBitrate(
         sl_idx, 0,
         codec_settings_.spatialLayers[sl_idx].targetBitrate * 1000 * 2);
-    encoder_->SetRates(VideoEncoder::RateControlParameters(
-        bitrate_allocation, codec_settings_.maxFramerate));
+    EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+              encoder_->SetRateAllocation(bitrate_allocation,
+                                          codec_settings_.maxFramerate));
 
     for (size_t frame_num = 0; frame_num < num_frames_to_encode; ++frame_num) {
       SetWaitForEncodedFramesThreshold(sl_idx + 1);
@@ -393,8 +394,9 @@
   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);
-    encoder_->SetRates(VideoEncoder::RateControlParameters(
-        bitrate_allocation, codec_settings_.maxFramerate));
+    EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+              encoder_->SetRateAllocation(bitrate_allocation,
+                                          codec_settings_.maxFramerate));
 
     for (size_t frame_num = 0; frame_num < num_frames_to_encode; ++frame_num) {
       SetWaitForEncodedFramesThreshold(sl_idx);
@@ -424,8 +426,9 @@
       0, 0, codec_settings_.spatialLayers[0].targetBitrate * 1000);
   bitrate_allocation.SetBitrate(
       1, 0, codec_settings_.spatialLayers[1].targetBitrate * 1000);
-  encoder_->SetRates(VideoEncoder::RateControlParameters(
-      bitrate_allocation, codec_settings_.maxFramerate));
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+            encoder_->SetRateAllocation(bitrate_allocation,
+                                        codec_settings_.maxFramerate));
   SetWaitForEncodedFramesThreshold(2);
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             encoder_->Encode(*NextInputFrame(), nullptr));
@@ -439,8 +442,9 @@
   // Encode only base layer. Check that end-of-superframe flag is
   // set on base layer frame.
   bitrate_allocation.SetBitrate(1, 0, 0);
-  encoder_->SetRates(VideoEncoder::RateControlParameters(
-      bitrate_allocation, codec_settings_.maxFramerate));
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+            encoder_->SetRateAllocation(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,8 +479,9 @@
               encoder_->InitEncode(&codec_settings_, 1 /* number of cores */,
                                    0 /* max payload size (unused) */));
 
-    encoder_->SetRates(VideoEncoder::RateControlParameters(
-        bitrate_allocation, codec_settings_.maxFramerate));
+    EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+              encoder_->SetRateAllocation(bitrate_allocation,
+                                          codec_settings_.maxFramerate));
 
     SetWaitForEncodedFramesThreshold(2);
     EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
@@ -545,8 +550,9 @@
       bitrate_allocation.SetBitrate(
           sl_idx, 0,
           codec_settings_.spatialLayers[sl_idx].targetBitrate * 1000);
-      encoder_->SetRates(VideoEncoder::RateControlParameters(
-          bitrate_allocation, codec_settings_.maxFramerate));
+      EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+                encoder_->SetRateAllocation(bitrate_allocation,
+                                            codec_settings_.maxFramerate));
 
       for (size_t frame_num = 0; frame_num < num_frames_to_encode;
            ++frame_num) {
@@ -604,8 +610,9 @@
       bitrate_allocation.SetBitrate(
           sl_idx, 0,
           codec_settings_.spatialLayers[sl_idx].targetBitrate * 1000);
-      encoder_->SetRates(VideoEncoder::RateControlParameters(
-          bitrate_allocation, codec_settings_.maxFramerate));
+      EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+                encoder_->SetRateAllocation(bitrate_allocation,
+                                            codec_settings_.maxFramerate));
 
       for (size_t frame_num = 0; frame_num < num_frames_to_encode;
            ++frame_num) {
@@ -661,8 +668,9 @@
       1, 0, codec_settings_.spatialLayers[1].targetBitrate * 1000 / 2);
   bitrate_allocation.SetBitrate(
       1, 1, codec_settings_.spatialLayers[1].targetBitrate * 1000 / 2);
-  encoder_->SetRates(VideoEncoder::RateControlParameters(
-      bitrate_allocation, codec_settings_.maxFramerate));
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+            encoder_->SetRateAllocation(bitrate_allocation,
+                                        codec_settings_.maxFramerate));
 
   std::vector<EncodedImage> encoded_frame;
   std::vector<CodecSpecificInfo> codec_specific_info;
@@ -679,8 +687,9 @@
   // Disable SL1 layer.
   bitrate_allocation.SetBitrate(1, 0, 0);
   bitrate_allocation.SetBitrate(1, 1, 0);
-  encoder_->SetRates(VideoEncoder::RateControlParameters(
-      bitrate_allocation, codec_settings_.maxFramerate));
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+            encoder_->SetRateAllocation(bitrate_allocation,
+                                        codec_settings_.maxFramerate));
 
   // Encode 1 frame.
   SetWaitForEncodedFramesThreshold(1);
@@ -697,8 +706,9 @@
       1, 0, codec_settings_.spatialLayers[1].targetBitrate * 1000 / 2);
   bitrate_allocation.SetBitrate(
       1, 1, codec_settings_.spatialLayers[1].targetBitrate * 1000 / 2);
-  encoder_->SetRates(VideoEncoder::RateControlParameters(
-      bitrate_allocation, codec_settings_.maxFramerate));
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+            encoder_->SetRateAllocation(bitrate_allocation,
+                                        codec_settings_.maxFramerate));
 
   // Encode 1 frame.
   SetWaitForEncodedFramesThreshold(2);
@@ -736,8 +746,9 @@
       1, 0, codec_settings_.spatialLayers[1].targetBitrate * 1000 / 2);
   bitrate_allocation.SetBitrate(
       1, 1, codec_settings_.spatialLayers[1].targetBitrate * 1000 / 2);
-  encoder_->SetRates(VideoEncoder::RateControlParameters(
-      bitrate_allocation, codec_settings_.maxFramerate));
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+            encoder_->SetRateAllocation(bitrate_allocation,
+                                        codec_settings_.maxFramerate));
 
   std::vector<EncodedImage> encoded_frame;
   std::vector<CodecSpecificInfo> codec_specific_info;
@@ -754,8 +765,9 @@
   // Disable SL1 layer.
   bitrate_allocation.SetBitrate(1, 0, 0);
   bitrate_allocation.SetBitrate(1, 1, 0);
-  encoder_->SetRates(VideoEncoder::RateControlParameters(
-      bitrate_allocation, codec_settings_.maxFramerate));
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+            encoder_->SetRateAllocation(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) {
@@ -775,8 +787,9 @@
       1, 0, codec_settings_.spatialLayers[1].targetBitrate * 1000 / 2);
   bitrate_allocation.SetBitrate(
       1, 1, codec_settings_.spatialLayers[1].targetBitrate * 1000 / 2);
-  encoder_->SetRates(VideoEncoder::RateControlParameters(
-      bitrate_allocation, codec_settings_.maxFramerate));
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+            encoder_->SetRateAllocation(bitrate_allocation,
+                                        codec_settings_.maxFramerate));
 
   // Encode 1 frame.
   SetWaitForEncodedFramesThreshold(2);
@@ -822,8 +835,9 @@
     bitrate_allocation.SetBitrate(
         sl_idx, 0, codec_settings_.spatialLayers[sl_idx].targetBitrate * 1000);
   }
-  encoder_->SetRates(VideoEncoder::RateControlParameters(
-      bitrate_allocation, codec_settings_.maxFramerate));
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+            encoder_->SetRateAllocation(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;
@@ -841,8 +855,9 @@
       num_spatial_layers - 1, 0,
       codec_settings_.spatialLayers[num_spatial_layers - 1].targetBitrate *
           1000);
-  encoder_->SetRates(VideoEncoder::RateControlParameters(
-      bitrate_allocation, codec_settings_.maxFramerate));
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+            encoder_->SetRateAllocation(bitrate_allocation,
+                                        codec_settings_.maxFramerate));
 
   for (size_t frame_num = 0; frame_num < num_dropped_frames; ++frame_num) {
     SetWaitForEncodedFramesThreshold(1);
@@ -898,8 +913,9 @@
     bitrate_allocation.SetBitrate(
         sl_idx, 0, codec_settings_.spatialLayers[sl_idx].targetBitrate * 1000);
   }
-  encoder_->SetRates(VideoEncoder::RateControlParameters(
-      bitrate_allocation, codec_settings_.maxFramerate));
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+            encoder_->SetRateAllocation(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;
@@ -928,8 +944,9 @@
 
   // Disable the last layer.
   bitrate_allocation.SetBitrate(num_spatial_layers - 1, 0, 0);
-  encoder_->SetRates(VideoEncoder::RateControlParameters(
-      bitrate_allocation, codec_settings_.maxFramerate));
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+            encoder_->SetRateAllocation(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;
@@ -985,8 +1002,9 @@
               num_temporal_layers);
     }
   }
-  encoder_->SetRates(VideoEncoder::RateControlParameters(
-      bitrate_allocation, codec_settings_.maxFramerate));
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+            encoder_->SetRateAllocation(bitrate_allocation,
+                                        codec_settings_.maxFramerate));
 
   std::vector<EncodedImage> encoded_frames;
   std::vector<CodecSpecificInfo> codec_specific_info;
@@ -1002,8 +1020,9 @@
   for (size_t tl_idx = 0; tl_idx < num_temporal_layers; ++tl_idx) {
     bitrate_allocation.SetBitrate(num_spatial_layers - 1, tl_idx, 0);
   }
-  encoder_->SetRates(VideoEncoder::RateControlParameters(
-      bitrate_allocation, codec_settings_.maxFramerate));
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+            encoder_->SetRateAllocation(bitrate_allocation,
+                                        codec_settings_.maxFramerate));
 
   // Next is TL1 frame. The last layer is disabled immediately, but SS structure
   // is not provided here.
@@ -1040,8 +1059,9 @@
   VideoBitrateAllocation bitrate_allocation;
   bitrate_allocation.SetBitrate(
       0, 0, codec_settings_.spatialLayers[0].targetBitrate * 1000);
-  encoder_->SetRates(VideoEncoder::RateControlParameters(
-      bitrate_allocation, codec_settings_.maxFramerate));
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+            encoder_->SetRateAllocation(bitrate_allocation,
+                                        codec_settings_.maxFramerate));
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             encoder_->Encode(*NextInputFrame(), nullptr));
   EncodedImage encoded_frame;
@@ -1309,8 +1329,9 @@
             encoder_->InitEncode(&codec_settings_, 1 /* number of cores */,
                                  0 /* max payload size (unused) */));
 
-  encoder_->SetRates(VideoEncoder::RateControlParameters(
-      bitrate_allocation, codec_settings_.maxFramerate));
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+            encoder_->SetRateAllocation(bitrate_allocation,
+                                        codec_settings_.maxFramerate));
 
   VideoFrame* input_frame = NextInputFrame();
   for (size_t frame_num = 0; frame_num < num_input_frames; ++frame_num) {
@@ -1363,8 +1384,9 @@
             encoder_->InitEncode(&codec_settings_, 1 /* number of cores */,
                                  0 /* max payload size (unused) */));
 
-  encoder_->SetRates(VideoEncoder::RateControlParameters(
-      bitrate_allocation, codec_max_framerate_fps));
+  EXPECT_EQ(
+      WEBRTC_VIDEO_CODEC_OK,
+      encoder_->SetRateAllocation(bitrate_allocation, codec_max_framerate_fps));
 
   VideoFrame* input_frame = NextInputFrame();
   for (size_t frame_num = 0; frame_num < num_input_frames; ++frame_num) {
diff --git a/modules/video_coding/codecs/vp9/vp9_impl.cc b/modules/video_coding/codecs/vp9/vp9_impl.cc
index b012d6b..a6c7643 100644
--- a/modules/video_coding/codecs/vp9/vp9_impl.cc
+++ b/modules/video_coding/codecs/vp9/vp9_impl.cc
@@ -309,33 +309,29 @@
   return true;
 }
 
-void VP9EncoderImpl::SetRates(const RateControlParameters& parameters) {
+int VP9EncoderImpl::SetRateAllocation(
+    const VideoBitrateAllocation& bitrate_allocation,
+    uint32_t frame_rate) {
   if (!inited_) {
-    RTC_LOG(LS_WARNING) << "SetRates() calll while uninitialzied.";
-    return;
+    return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
   if (encoder_->err) {
-    RTC_LOG(LS_WARNING) << "Encoder in error state: " << encoder_->err;
-    return;
+    return WEBRTC_VIDEO_CODEC_ERROR;
   }
-  if (parameters.framerate_fps < 1.0) {
-    RTC_LOG(LS_WARNING) << "Unsupported framerate: "
-                        << parameters.framerate_fps;
-    return;
+  if (frame_rate < 1) {
+    return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   // Update bit rate
   if (codec_.maxBitrate > 0 &&
-      parameters.bitrate.get_sum_kbps() > codec_.maxBitrate) {
-    RTC_LOG(LS_WARNING) << "Target bitrate exceeds maximum: "
-                        << parameters.bitrate.get_sum_kbps() << " vs "
-                        << codec_.maxBitrate;
-    return;
+      bitrate_allocation.get_sum_kbps() > codec_.maxBitrate) {
+    return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
 
-  codec_.maxFramerate = static_cast<uint32_t>(parameters.framerate_fps + 0.5);
-  requested_bitrate_allocation_ = parameters.bitrate;
+  codec_.maxFramerate = frame_rate;
 
-  return;
+  requested_bitrate_allocation_ = bitrate_allocation;
+
+  return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int VP9EncoderImpl::InitEncode(const VideoCodec* inst,
diff --git a/modules/video_coding/codecs/vp9/vp9_impl.h b/modules/video_coding/codecs/vp9/vp9_impl.h
index 9fa4750..3fc5398 100644
--- a/modules/video_coding/codecs/vp9/vp9_impl.h
+++ b/modules/video_coding/codecs/vp9/vp9_impl.h
@@ -48,7 +48,8 @@
 
   int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
 
-  void SetRates(const RateControlParameters& parameters) override;
+  int SetRateAllocation(const VideoBitrateAllocation& bitrate_allocation,
+                        uint32_t frame_rate) override;
 
   EncoderInfo GetEncoderInfo() const override;
 
diff --git a/modules/video_coding/utility/simulcast_test_fixture_impl.cc b/modules/video_coding/utility/simulcast_test_fixture_impl.cc
index 0646270..b745fae 100644
--- a/modules/video_coding/utility/simulcast_test_fixture_impl.cc
+++ b/modules/video_coding/utility/simulcast_test_fixture_impl.cc
@@ -288,9 +288,8 @@
 }
 
 void SimulcastTestFixtureImpl::SetRates(uint32_t bitrate_kbps, uint32_t fps) {
-  encoder_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(bitrate_kbps * 1000, fps),
-      static_cast<double>(fps)));
+  encoder_->SetRateAllocation(
+      rate_allocator_->GetAllocation(bitrate_kbps * 1000, fps), fps);
 }
 
 void SimulcastTestFixtureImpl::RunActiveStreamsTest(
diff --git a/sdk/android/src/jni/android_media_encoder.cc b/sdk/android/src/jni/android_media_encoder.cc
index 863b4b2..dbf2b31 100644
--- a/sdk/android/src/jni/android_media_encoder.cc
+++ b/sdk/android/src/jni/android_media_encoder.cc
@@ -104,7 +104,8 @@
   int32_t RegisterEncodeCompleteCallback(
       EncodedImageCallback* callback) override;
   int32_t Release() override;
-  void SetRates(const RateControlParameters& parameters) override;
+  int32_t SetRateAllocation(const VideoBitrateAllocation& rate_allocation,
+                            uint32_t frame_rate) override;
   EncoderInfo GetEncoderInfo() const override;
 
   // Fills the input buffer with data from the buffers passed as parameters.
@@ -899,16 +900,17 @@
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
-void MediaCodecVideoEncoder::SetRates(const RateControlParameters& parameters) {
+int32_t MediaCodecVideoEncoder::SetRateAllocation(
+    const VideoBitrateAllocation& rate_allocation,
+    uint32_t frame_rate) {
   RTC_DCHECK_RUN_ON(&encoder_queue_checker_);
-  const uint32_t new_bit_rate = parameters.bitrate.get_sum_kbps();
+  const uint32_t new_bit_rate = rate_allocation.get_sum_kbps();
   if (sw_fallback_required_)
-    return;
-  uint32_t frame_rate = static_cast<uint32_t>(parameters.framerate_fps + 0.5);
+    return WEBRTC_VIDEO_CODEC_OK;
   frame_rate =
       (frame_rate < MAX_ALLOWED_VIDEO_FPS) ? frame_rate : MAX_ALLOWED_VIDEO_FPS;
   if (last_set_bitrate_kbps_ == new_bit_rate && last_set_fps_ == frame_rate) {
-    return;
+    return WEBRTC_VIDEO_CODEC_OK;
   }
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
@@ -924,7 +926,10 @@
       rtc::dchecked_cast<int>(last_set_fps_));
   if (CheckException(jni) || !ret) {
     ProcessHWError(true /* reset_if_fallback_unavailable */);
+    return sw_fallback_required_ ? WEBRTC_VIDEO_CODEC_OK
+                                 : WEBRTC_VIDEO_CODEC_ERROR;
   }
+  return WEBRTC_VIDEO_CODEC_OK;
 }
 
 VideoEncoder::EncoderInfo MediaCodecVideoEncoder::GetEncoderInfo() const {
diff --git a/sdk/android/src/jni/video_encoder_wrapper.cc b/sdk/android/src/jni/video_encoder_wrapper.cc
index 6238e94..960847f 100644
--- a/sdk/android/src/jni/video_encoder_wrapper.cc
+++ b/sdk/android/src/jni/video_encoder_wrapper.cc
@@ -146,15 +146,16 @@
   return HandleReturnCode(jni, ret, "encode");
 }
 
-void VideoEncoderWrapper::SetRates(const RateControlParameters& parameters) {
+int32_t VideoEncoderWrapper::SetRateAllocation(
+    const VideoBitrateAllocation& allocation,
+    uint32_t framerate) {
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
 
   ScopedJavaLocalRef<jobject> j_bitrate_allocation =
-      ToJavaBitrateAllocation(jni, parameters.bitrate);
+      ToJavaBitrateAllocation(jni, allocation);
   ScopedJavaLocalRef<jobject> ret = Java_VideoEncoder_setRateAllocation(
-      jni, encoder_, j_bitrate_allocation,
-      (jint)(parameters.framerate_fps + 0.5));
-  HandleReturnCode(jni, ret, "setRateAllocation");
+      jni, encoder_, j_bitrate_allocation, (jint)framerate);
+  return HandleReturnCode(jni, ret, "setRateAllocation");
 }
 
 VideoEncoder::EncoderInfo VideoEncoderWrapper::GetEncoderInfo() const {
diff --git a/sdk/android/src/jni/video_encoder_wrapper.h b/sdk/android/src/jni/video_encoder_wrapper.h
index c140495..65940d6 100644
--- a/sdk/android/src/jni/video_encoder_wrapper.h
+++ b/sdk/android/src/jni/video_encoder_wrapper.h
@@ -44,7 +44,8 @@
   int32_t Encode(const VideoFrame& frame,
                  const std::vector<VideoFrameType>* frame_types) override;
 
-  void SetRates(const RateControlParameters& parameters) override;
+  int32_t SetRateAllocation(const VideoBitrateAllocation& allocation,
+                            uint32_t framerate) override;
 
   EncoderInfo GetEncoderInfo() const override;
 
diff --git a/test/configurable_frame_size_encoder.cc b/test/configurable_frame_size_encoder.cc
index ba529cb..a0a42f0 100644
--- a/test/configurable_frame_size_encoder.cc
+++ b/test/configurable_frame_size_encoder.cc
@@ -74,8 +74,11 @@
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
-void ConfigurableFrameSizeEncoder::SetRates(
-    const RateControlParameters& parameters) {}
+int32_t ConfigurableFrameSizeEncoder::SetRateAllocation(
+    const VideoBitrateAllocation& allocation,
+    uint32_t framerate) {
+  return WEBRTC_VIDEO_CODEC_OK;
+}
 
 int32_t ConfigurableFrameSizeEncoder::SetFrameSize(size_t size) {
   RTC_DCHECK_LE(size, max_frame_size_);
diff --git a/test/configurable_frame_size_encoder.h b/test/configurable_frame_size_encoder.h
index ddf763f..9daf13e 100644
--- a/test/configurable_frame_size_encoder.h
+++ b/test/configurable_frame_size_encoder.h
@@ -44,7 +44,8 @@
 
   int32_t Release() override;
 
-  void SetRates(const RateControlParameters& parameters) override;
+  int32_t SetRateAllocation(const VideoBitrateAllocation& allocation,
+                            uint32_t framerate) override;
 
   int32_t SetFrameSize(size_t size);
 
diff --git a/test/fake_encoder.cc b/test/fake_encoder.cc
index 7c24b84..ac59dfd 100644
--- a/test/fake_encoder.cc
+++ b/test/fake_encoder.cc
@@ -51,6 +51,7 @@
 FakeEncoder::FakeEncoder(Clock* clock)
     : clock_(clock),
       callback_(nullptr),
+      configured_input_framerate_(-1),
       max_target_bitrate_kbps_(-1),
       pending_keyframe_(true),
       counter_(0),
@@ -64,7 +65,7 @@
   RTC_DCHECK_GE(max_kbps, -1);  // max_kbps == -1 disables it.
   rtc::CritScope cs(&crit_sect_);
   max_target_bitrate_kbps_ = max_kbps;
-  SetRates(current_rate_settings_);
+  SetRateAllocation(target_bitrate_, configured_input_framerate_);
 }
 
 int32_t FakeEncoder::InitEncode(const VideoCodec* config,
@@ -72,8 +73,8 @@
                                 size_t max_payload_size) {
   rtc::CritScope cs(&crit_sect_);
   config_ = *config;
-  current_rate_settings_.bitrate.SetBitrate(0, 0, config_.startBitrate * 1000);
-  current_rate_settings_.framerate_fps = config_.maxFramerate;
+  target_bitrate_.SetBitrate(0, 0, config_.startBitrate * 1000);
+  configured_input_framerate_ = config_.maxFramerate;
   pending_keyframe_ = true;
   last_frame_info_ = FrameInfo();
   return 0;
@@ -85,7 +86,8 @@
   unsigned char num_simulcast_streams;
   SimulcastStream simulcast_streams[kMaxSimulcastStreams];
   EncodedImageCallback* callback;
-  RateControlParameters rates;
+  VideoBitrateAllocation target_bitrate;
+  int framerate;
   VideoCodecMode mode;
   bool keyframe;
   uint32_t counter;
@@ -97,10 +99,12 @@
       simulcast_streams[i] = config_.simulcastStream[i];
     }
     callback = callback_;
-    rates = current_rate_settings_;
+    target_bitrate = target_bitrate_;
     mode = config_.mode;
-    if (rates.framerate_fps <= 0.0) {
-      rates.framerate_fps = max_framerate;
+    if (configured_input_framerate_ > 0) {
+      framerate = configured_input_framerate_;
+    } else {
+      framerate = max_framerate;
     }
     keyframe = pending_keyframe_;
     pending_keyframe_ = false;
@@ -108,8 +112,8 @@
   }
 
   FrameInfo frame_info =
-      NextFrame(frame_types, keyframe, num_simulcast_streams, rates.bitrate,
-                simulcast_streams, static_cast<int>(rates.framerate_fps + 0.5));
+      NextFrame(frame_types, keyframe, num_simulcast_streams, target_bitrate,
+                simulcast_streams, framerate);
   for (uint8_t i = 0; i < frame_info.layers.size(); ++i) {
     constexpr int kMinPayLoadLength = 14;
     if (frame_info.layers[i].size < kMinPayLoadLength) {
@@ -233,10 +237,12 @@
   return 0;
 }
 
-void FakeEncoder::SetRates(const RateControlParameters& parameters) {
+int32_t FakeEncoder::SetRateAllocation(
+    const VideoBitrateAllocation& rate_allocation,
+    uint32_t framerate) {
   rtc::CritScope cs(&crit_sect_);
-  current_rate_settings_ = parameters;
-  int allocated_bitrate_kbps = parameters.bitrate.get_sum_kbps();
+  target_bitrate_ = rate_allocation;
+  int allocated_bitrate_kbps = target_bitrate_.get_sum_kbps();
 
   // Scale bitrate allocation to not exceed the given max target bitrate.
   if (max_target_bitrate_kbps_ > 0 &&
@@ -245,19 +251,20 @@
          ++spatial_idx) {
       for (uint8_t temporal_idx = 0; temporal_idx < kMaxTemporalStreams;
            ++temporal_idx) {
-        if (current_rate_settings_.bitrate.HasBitrate(spatial_idx,
-                                                      temporal_idx)) {
-          uint32_t bitrate = current_rate_settings_.bitrate.GetBitrate(
-              spatial_idx, temporal_idx);
+        if (target_bitrate_.HasBitrate(spatial_idx, temporal_idx)) {
+          uint32_t bitrate =
+              target_bitrate_.GetBitrate(spatial_idx, temporal_idx);
           bitrate = static_cast<uint32_t>(
               (bitrate * int64_t{max_target_bitrate_kbps_}) /
               allocated_bitrate_kbps);
-          current_rate_settings_.bitrate.SetBitrate(spatial_idx, temporal_idx,
-                                                    bitrate);
+          target_bitrate_.SetBitrate(spatial_idx, temporal_idx, bitrate);
         }
       }
     }
   }
+
+  configured_input_framerate_ = framerate;
+  return 0;
 }
 
 const char* FakeEncoder::kImplementationName = "fake_encoder";
@@ -269,7 +276,7 @@
 
 int FakeEncoder::GetConfiguredInputFramerate() const {
   rtc::CritScope cs(&crit_sect_);
-  return static_cast<int>(current_rate_settings_.framerate_fps + 0.5);
+  return configured_input_framerate_;
 }
 
 FakeH264Encoder::FakeH264Encoder(Clock* clock)
diff --git a/test/fake_encoder.h b/test/fake_encoder.h
index 7e1c1a1..95b4b20 100644
--- a/test/fake_encoder.h
+++ b/test/fake_encoder.h
@@ -48,7 +48,8 @@
   int32_t RegisterEncodeCompleteCallback(
       EncodedImageCallback* callback) override;
   int32_t Release() override;
-  void SetRates(const RateControlParameters& parameters) override;
+  int32_t SetRateAllocation(const VideoBitrateAllocation& rate_allocation,
+                            uint32_t framerate) override;
   int GetConfiguredInputFramerate() const;
   EncoderInfo GetEncoderInfo() const override;
 
@@ -88,7 +89,8 @@
 
   VideoCodec config_ RTC_GUARDED_BY(crit_sect_);
   EncodedImageCallback* callback_ RTC_GUARDED_BY(crit_sect_);
-  RateControlParameters current_rate_settings_ RTC_GUARDED_BY(crit_sect_);
+  VideoBitrateAllocation target_bitrate_ RTC_GUARDED_BY(crit_sect_);
+  int configured_input_framerate_ RTC_GUARDED_BY(crit_sect_);
   int max_target_bitrate_kbps_ RTC_GUARDED_BY(crit_sect_);
   bool pending_keyframe_ RTC_GUARDED_BY(crit_sect_);
   uint32_t counter_ RTC_GUARDED_BY(crit_sect_);
diff --git a/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.cc b/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.cc
index 272f80f..39d5701 100644
--- a/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.cc
+++ b/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.cc
@@ -63,9 +63,7 @@
       bitrate_multiplier_(bitrate_multiplier),
       stream_required_spatial_index_(std::move(stream_required_spatial_index)),
       injector_(injector),
-      analyzer_(analyzer),
-      mode_(SimulcastMode::kNormal),
-      delegate_callback_(nullptr) {}
+      analyzer_(analyzer) {}
 QualityAnalyzingVideoEncoder::~QualityAnalyzingVideoEncoder() = default;
 
 int32_t QualityAnalyzingVideoEncoder::InitEncode(
@@ -149,11 +147,17 @@
   return result;
 }
 
-void QualityAnalyzingVideoEncoder::SetRates(
-    const VideoEncoder::RateControlParameters& parameters) {
+int32_t QualityAnalyzingVideoEncoder::SetRates(uint32_t bitrate,
+                                               uint32_t framerate) {
+  return delegate_->SetRates(bitrate, framerate);
+}
+
+int32_t QualityAnalyzingVideoEncoder::SetRateAllocation(
+    const VideoBitrateAllocation& allocation,
+    uint32_t framerate) {
   RTC_DCHECK_GT(bitrate_multiplier_, 0.0);
   if (fabs(bitrate_multiplier_ - kNoMultiplier) < kEps) {
-    return delegate_->SetRates(parameters);
+    return delegate_->SetRateAllocation(allocation, framerate);
   }
 
   // Simulating encoder overshooting target bitrate, by configuring actual
@@ -162,7 +166,7 @@
   VideoBitrateAllocation multiplied_allocation;
   for (size_t si = 0; si < kMaxSpatialLayers; ++si) {
     const uint32_t spatial_layer_bitrate_bps =
-        parameters.bitrate.GetSpatialLayerSum(si);
+        allocation.GetSpatialLayerSum(si);
     if (spatial_layer_bitrate_bps == 0) {
       continue;
     }
@@ -181,18 +185,16 @@
     }
 
     for (size_t ti = 0; ti < kMaxTemporalStreams; ++ti) {
-      if (parameters.bitrate.HasBitrate(si, ti)) {
+      if (allocation.HasBitrate(si, ti)) {
         multiplied_allocation.SetBitrate(
             si, ti,
             rtc::checked_cast<uint32_t>(bitrate_multiplier *
-                                        parameters.bitrate.GetBitrate(si, ti)));
+                                        allocation.GetBitrate(si, ti)));
       }
     }
   }
 
-  RateControlParameters adjusted_params = parameters;
-  adjusted_params.bitrate = multiplied_allocation;
-  return delegate_->SetRates(adjusted_params);
+  return delegate_->SetRateAllocation(multiplied_allocation, framerate);
 }
 
 VideoEncoder::EncoderInfo QualityAnalyzingVideoEncoder::GetEncoderInfo() const {
diff --git a/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.h b/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.h
index 4861d4c..d7dd5d1 100644
--- a/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.h
+++ b/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.h
@@ -70,7 +70,9 @@
   int32_t Release() override;
   int32_t Encode(const VideoFrame& frame,
                  const std::vector<VideoFrameType>* frame_types) override;
-  void SetRates(const VideoEncoder::RateControlParameters& parameters) override;
+  int32_t SetRates(uint32_t bitrate, uint32_t framerate) override;
+  int32_t SetRateAllocation(const VideoBitrateAllocation& allocation,
+                            uint32_t framerate) override;
   EncoderInfo GetEncoderInfo() const override;
 
   // Methods of EncodedImageCallback interface.
diff --git a/test/video_encoder_proxy_factory.h b/test/video_encoder_proxy_factory.h
index 49a4e2d..55a01a1 100644
--- a/test/video_encoder_proxy_factory.h
+++ b/test/video_encoder_proxy_factory.h
@@ -75,8 +75,9 @@
       return encoder_->RegisterEncodeCompleteCallback(callback);
     }
     int32_t Release() override { return encoder_->Release(); }
-    void SetRates(const RateControlParameters& parameters) override {
-      encoder_->SetRates(parameters);
+    int32_t SetRateAllocation(const VideoBitrateAllocation& rate_allocation,
+                              uint32_t framerate) override {
+      return encoder_->SetRateAllocation(rate_allocation, framerate);
     }
     VideoEncoder::EncoderInfo GetEncoderInfo() const override {
       return encoder_->GetEncoderInfo();
diff --git a/video/end_to_end_tests/bandwidth_tests.cc b/video/end_to_end_tests/bandwidth_tests.cc
index 163e84d..3ee0e2b 100644
--- a/video/end_to_end_tests/bandwidth_tests.cc
+++ b/video/end_to_end_tests/bandwidth_tests.cc
@@ -307,13 +307,15 @@
       RTC_DCHECK_EQ(1, encoder_config->number_of_streams);
     }
 
-    void SetRates(const RateControlParameters& parameters) override {
+    int32_t SetRateAllocation(const VideoBitrateAllocation& rate_allocation,
+                              uint32_t framerate) override {
       // Make sure not to trigger on any default zero bitrates.
-      if (parameters.bitrate.get_sum_bps() == 0)
-        return;
+      if (rate_allocation.get_sum_bps() == 0)
+        return 0;
       rtc::CritScope lock(&crit_);
-      bitrate_kbps_ = parameters.bitrate.get_sum_kbps();
+      bitrate_kbps_ = rate_allocation.get_sum_kbps();
       observation_complete_.Set();
+      return 0;
     }
 
     void PerformTest() override {
diff --git a/video/video_quality_test.cc b/video/video_quality_test.cc
index e6760ee..5aead68 100644
--- a/video/video_quality_test.cc
+++ b/video/video_quality_test.cc
@@ -149,11 +149,11 @@
     }
     return encoder_->Encode(frame, frame_types);
   }
-  void SetRates(const RateControlParameters& parameters) override {
+  int32_t SetRateAllocation(const VideoBitrateAllocation& allocation,
+                            uint32_t framerate) override {
     RTC_DCHECK_GT(overshoot_factor_, 0.0);
     if (overshoot_factor_ == 1.0) {
-      encoder_->SetRates(parameters);
-      return;
+      return encoder_->SetRateAllocation(allocation, framerate);
     }
 
     // Simulating encoder overshooting target bitrate, by configuring actual
@@ -162,7 +162,7 @@
     VideoBitrateAllocation overshot_allocation;
     for (size_t si = 0; si < kMaxSpatialLayers; ++si) {
       const uint32_t spatial_layer_bitrate_bps =
-          parameters.bitrate.GetSpatialLayerSum(si);
+          allocation.GetSpatialLayerSum(si);
       if (spatial_layer_bitrate_bps == 0) {
         continue;
       }
@@ -181,18 +181,16 @@
       }
 
       for (size_t ti = 0; ti < kMaxTemporalStreams; ++ti) {
-        if (parameters.bitrate.HasBitrate(si, ti)) {
+        if (allocation.HasBitrate(si, ti)) {
           overshot_allocation.SetBitrate(
               si, ti,
-              rtc::checked_cast<uint32_t>(
-                  overshoot_factor * parameters.bitrate.GetBitrate(si, ti)));
+              rtc::checked_cast<uint32_t>(overshoot_factor *
+                                          allocation.GetBitrate(si, ti)));
         }
       }
     }
 
-    return encoder_->SetRates(
-        RateControlParameters(overshot_allocation, parameters.framerate_fps,
-                              parameters.bandwidth_allocation));
+    return encoder_->SetRateAllocation(overshot_allocation, framerate);
   }
   EncoderInfo GetEncoderInfo() const override {
     EncoderInfo info = encoder_->GetEncoderInfo();
diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc
index 2338997..0793843 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -2045,11 +2045,11 @@
       return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
     }
 
-    void SetRates(const RateControlParameters& parameters) override {
+    int32_t SetRates(uint32_t new_target_bitrate, uint32_t framerate) override {
       rtc::CritScope lock(&crit_);
-      start_bitrate_kbps_ = parameters.bitrate.get_sum_kbps();
+      start_bitrate_kbps_ = new_target_bitrate;
       start_bitrate_changed_.Set();
-      FakeEncoder::SetRates(parameters);
+      return FakeEncoder::SetRates(new_target_bitrate, framerate);
     }
 
     int GetStartBitrateKbps() const {
@@ -2118,11 +2118,12 @@
     return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
   }
 
-  void SetRates(const RateControlParameters& parameters) override {
+  int32_t SetRateAllocation(const VideoBitrateAllocation& bitrate,
+                            uint32_t framerate) override {
     rtc::CritScope lock(&crit_);
-    bitrate_kbps_ = parameters.bitrate.get_sum_kbps();
+    bitrate_kbps_ = bitrate.get_sum_kbps();
     bitrate_changed_.Set();
-    FakeEncoder::SetRates(parameters);
+    return FakeEncoder::SetRateAllocation(bitrate, framerate);
   }
 
   bool WaitForEncoderInit() {
@@ -2853,17 +2854,17 @@
                                      maxPayloadSize);
     }
 
-    void SetRates(const RateControlParameters& parameters) override {
+    int32_t SetRateAllocation(const VideoBitrateAllocation& bitrate,
+                              uint32_t frameRate) override {
       {
         rtc::CritScope lock(&crit_);
-        if (target_bitrate_ == parameters.bitrate.get_sum_kbps()) {
-          FakeEncoder::SetRates(parameters);
-          return;
+        if (target_bitrate_ == bitrate.get_sum_kbps()) {
+          return FakeEncoder::SetRateAllocation(bitrate, frameRate);
         }
-        target_bitrate_ = parameters.bitrate.get_sum_kbps();
+        target_bitrate_ = bitrate.get_sum_kbps();
       }
       bitrate_changed_event_.Set();
-      FakeEncoder::SetRates(parameters);
+      return FakeEncoder::SetRateAllocation(bitrate, frameRate);
     }
 
     void WaitForSetRates(uint32_t expected_bitrate) {
@@ -3652,15 +3653,16 @@
           max_bitrate_bps_(0),
           first_packet_sent_(false) {}
 
-    void SetRates(const RateControlParameters& parameters) override {
+    int32_t SetRateAllocation(const VideoBitrateAllocation& bitrate,
+                              uint32_t frameRate) override {
       rtc::CritScope lock(&crit_);
       // Wait for the first sent packet so that videosendstream knows
       // rtp_overhead.
       if (first_packet_sent_) {
-        max_bitrate_bps_ = parameters.bitrate.get_sum_bps();
+        max_bitrate_bps_ = bitrate.get_sum_bps();
         bitrate_changed_event_.Set();
       }
-      return FakeEncoder::SetRates(parameters);
+      return FakeEncoder::SetRateAllocation(bitrate, frameRate);
     }
 
     void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc
index 23480e7..f9b2355 100644
--- a/video/video_stream_encoder_unittest.cc
+++ b/video/video_stream_encoder_unittest.cc
@@ -726,24 +726,24 @@
       return FakeEncoder::Release();
     }
 
-    void SetRates(const RateControlParameters& parameters) {
+    int32_t SetRateAllocation(const VideoBitrateAllocation& rate_allocation,
+                              uint32_t framerate) {
       rtc::CritScope lock(&local_crit_sect_);
       VideoBitrateAllocation adjusted_rate_allocation;
       for (size_t si = 0; si < kMaxSpatialLayers; ++si) {
         for (size_t ti = 0; ti < kMaxTemporalStreams; ++ti) {
-          if (parameters.bitrate.HasBitrate(si, ti)) {
+          if (rate_allocation.HasBitrate(si, ti)) {
             adjusted_rate_allocation.SetBitrate(
                 si, ti,
-                static_cast<uint32_t>(parameters.bitrate.GetBitrate(si, ti) *
+                static_cast<uint32_t>(rate_allocation.GetBitrate(si, ti) *
                                       rate_factor_));
           }
         }
       }
-      last_framerate_ = static_cast<uint32_t>(parameters.framerate_fps + 0.5);
-      last_bitrate_allocation_ = parameters.bitrate;
-      RateControlParameters adjusted_paramters = parameters;
-      adjusted_paramters.bitrate = adjusted_rate_allocation;
-      FakeEncoder::SetRates(adjusted_paramters);
+      last_framerate_ = framerate;
+      last_bitrate_allocation_ = rate_allocation;
+      return FakeEncoder::SetRateAllocation(adjusted_rate_allocation,
+                                            framerate);
     }
 
     rtc::CriticalSection local_crit_sect_;