diff --git a/api/test/mock_video_bitrate_allocator.h b/api/test/mock_video_bitrate_allocator.h
index d25537a2b9..5d21d9147b 100644
--- a/api/test/mock_video_bitrate_allocator.h
+++ b/api/test/mock_video_bitrate_allocator.h
@@ -17,9 +17,9 @@
 namespace webrtc {
 
 class MockVideoBitrateAllocator : public webrtc::VideoBitrateAllocator {
-  MOCK_METHOD2(GetAllocation,
-               VideoBitrateAllocation(uint32_t total_bitrate,
-                                      uint32_t framerate));
+  MOCK_METHOD1(
+      Allocate,
+      VideoBitrateAllocation(VideoBitrateAllocationParameters parameters));
   MOCK_METHOD1(GetPreferredBitrateBps, uint32_t(uint32_t framerate));
 };
 
diff --git a/api/video/BUILD.gn b/api/video/BUILD.gn
index 08f2f36487..ffc0ac4b48 100644
--- a/api/video/BUILD.gn
+++ b/api/video/BUILD.gn
@@ -159,10 +159,12 @@ rtc_source_set("video_bitrate_allocation") {
 rtc_source_set("video_bitrate_allocator") {
   visibility = [ "*" ]
   sources = [
+    "video_bitrate_allocator.cc",
     "video_bitrate_allocator.h",
   ]
   deps = [
     ":video_bitrate_allocation",
+    "../units:data_rate",
   ]
 }
 
diff --git a/api/video/video_bitrate_allocator.cc b/api/video/video_bitrate_allocator.cc
new file mode 100644
index 0000000000..6ad16c93f2
--- /dev/null
+++ b/api/video/video_bitrate_allocator.cc
@@ -0,0 +1,52 @@
+/*
+ *  Copyright (c) 2019 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "api/video/video_bitrate_allocator.h"
+
+namespace webrtc {
+
+VideoBitrateAllocationParameters::VideoBitrateAllocationParameters(
+    uint32_t total_bitrate_bps,
+    uint32_t framerate)
+    : total_bitrate(DataRate::bps(total_bitrate_bps)),
+      stable_bitrate(DataRate::bps(total_bitrate_bps)),
+      framerate(static_cast<double>(framerate)) {}
+
+VideoBitrateAllocationParameters::VideoBitrateAllocationParameters(
+    DataRate total_bitrate,
+    double framerate)
+    : total_bitrate(total_bitrate),
+      stable_bitrate(total_bitrate),
+      framerate(framerate) {}
+
+VideoBitrateAllocationParameters::VideoBitrateAllocationParameters(
+    DataRate total_bitrate,
+    DataRate stable_bitrate,
+    double framerate)
+    : total_bitrate(total_bitrate),
+      stable_bitrate(stable_bitrate),
+      framerate(framerate) {}
+
+VideoBitrateAllocationParameters::~VideoBitrateAllocationParameters() = default;
+
+VideoBitrateAllocation VideoBitrateAllocator::GetAllocation(
+    uint32_t total_bitrate_bps,
+    uint32_t framerate) {
+  return Allocate({DataRate::bps(total_bitrate_bps),
+                   DataRate::bps(total_bitrate_bps),
+                   static_cast<double>(framerate)});
+}
+
+VideoBitrateAllocation VideoBitrateAllocator::Allocate(
+    VideoBitrateAllocationParameters parameters) {
+  return GetAllocation(parameters.total_bitrate.bps(), parameters.framerate);
+}
+
+}  // namespace webrtc
diff --git a/api/video/video_bitrate_allocator.h b/api/video/video_bitrate_allocator.h
index f85c633d0f..04de04c1b0 100644
--- a/api/video/video_bitrate_allocator.h
+++ b/api/video/video_bitrate_allocator.h
@@ -11,17 +11,35 @@
 #ifndef API_VIDEO_VIDEO_BITRATE_ALLOCATOR_H_
 #define API_VIDEO_VIDEO_BITRATE_ALLOCATOR_H_
 
+#include "api/units/data_rate.h"
 #include "api/video/video_bitrate_allocation.h"
 
 namespace webrtc {
 
+struct VideoBitrateAllocationParameters {
+  VideoBitrateAllocationParameters(uint32_t total_bitrate_bps,
+                                   uint32_t framerate);
+  VideoBitrateAllocationParameters(DataRate total_bitrate, double framerate);
+  VideoBitrateAllocationParameters(DataRate total_bitrate,
+                                   DataRate stable_bitrate,
+                                   double framerate);
+  ~VideoBitrateAllocationParameters();
+
+  DataRate total_bitrate;
+  DataRate stable_bitrate;
+  double framerate;
+};
+
 class VideoBitrateAllocator {
  public:
   VideoBitrateAllocator() {}
   virtual ~VideoBitrateAllocator() {}
 
   virtual VideoBitrateAllocation GetAllocation(uint32_t total_bitrate_bps,
-                                               uint32_t framerate) = 0;
+                                               uint32_t framerate);
+
+  virtual VideoBitrateAllocation Allocate(
+      VideoBitrateAllocationParameters parameters);
 };
 
 class VideoBitrateAllocationObserver {
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 32205fa813..7b7d60789d 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
@@ -217,7 +217,9 @@ void VideoEncoderSoftwareFallbackWrapperTest::UtilizeFallbackEncoder() {
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             fallback_wrapper_->InitEncode(&codec_, kSettings));
   fallback_wrapper_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(300000, kFramerate), kFramerate));
+      rate_allocator_->Allocate(
+          VideoBitrateAllocationParameters(300000, kFramerate)),
+      kFramerate));
 
   int callback_count = callback_.callback_count_;
   int encode_count = fake_encoder_->encode_count_;
@@ -236,7 +238,9 @@ void VideoEncoderSoftwareFallbackWrapperTest::FallbackFromEncodeRequest() {
   rate_allocator_.reset(new SimulcastRateAllocator(codec_));
   fallback_wrapper_->InitEncode(&codec_, kSettings);
   fallback_wrapper_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(300000, kFramerate), kFramerate));
+      rate_allocator_->Allocate(
+          VideoBitrateAllocationParameters(300000, kFramerate)),
+      kFramerate));
   EXPECT_EQ(1, fake_encoder_->init_encode_count_);
 
   // Have the non-fallback encoder request a software fallback.
@@ -395,7 +399,8 @@ class ForcedFallbackTest : public VideoEncoderSoftwareFallbackWrapperTest {
 
   void SetRateAllocation(uint32_t bitrate_kbps) {
     fallback_wrapper_->SetRates(VideoEncoder::RateControlParameters(
-        rate_allocator_->GetAllocation(bitrate_kbps * 1000, kFramerate),
+        rate_allocator_->Allocate(
+            VideoBitrateAllocationParameters(bitrate_kbps * 1000, kFramerate)),
         kFramerate));
   }
 
diff --git a/media/engine/simulcast_encoder_adapter.cc b/media/engine/simulcast_encoder_adapter.cc
index 1b4d3b83fa..667b3032e3 100644
--- a/media/engine/simulcast_encoder_adapter.cc
+++ b/media/engine/simulcast_encoder_adapter.cc
@@ -200,8 +200,9 @@ int SimulcastEncoderAdapter::InitEncode(
 
   codec_ = *inst;
   SimulcastRateAllocator rate_allocator(codec_);
-  VideoBitrateAllocation allocation = rate_allocator.GetAllocation(
-      codec_.startBitrate * 1000, codec_.maxFramerate);
+  VideoBitrateAllocation allocation =
+      rate_allocator.Allocate(VideoBitrateAllocationParameters(
+          codec_.startBitrate * 1000, codec_.maxFramerate));
   std::vector<uint32_t> start_bitrates;
   for (int i = 0; i < kMaxSimulcastStreams; ++i) {
     uint32_t stream_bitrate = allocation.GetSpatialLayerSum(i) / 1000;
diff --git a/media/engine/simulcast_encoder_adapter_unittest.cc b/media/engine/simulcast_encoder_adapter_unittest.cc
index 161a3010c9..f6d57e8684 100644
--- a/media/engine/simulcast_encoder_adapter_unittest.cc
+++ b/media/engine/simulcast_encoder_adapter_unittest.cc
@@ -506,7 +506,8 @@ TEST_F(TestSimulcastEncoderAdapterFake, EncodedCallbackForDifferentEncoders) {
 
   // Set bitrates so that we send all layers.
   adapter_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(1200, 30), 30.0));
+      rate_allocator_->Allocate(VideoBitrateAllocationParameters(1200, 30)),
+      30.0));
 
   // 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
@@ -567,7 +568,9 @@ TEST_F(TestSimulcastEncoderAdapterFake, ReusesEncodersInOrder) {
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, kSettings));
   VerifyCodecSettings();
   adapter_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(target_bitrate, 30), 30.0));
+      rate_allocator_->Allocate(
+          VideoBitrateAllocationParameters(target_bitrate, 30)),
+      30.0));
 
   std::vector<MockVideoEncoder*> original_encoders =
       helper_->factory()->encoders();
@@ -594,7 +597,9 @@ TEST_F(TestSimulcastEncoderAdapterFake, ReusesEncodersInOrder) {
   codec_.numberOfSimulcastStreams = 2;
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, kSettings));
   adapter_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(target_bitrate, 30), 30.0));
+      rate_allocator_->Allocate(
+          VideoBitrateAllocationParameters(target_bitrate, 30)),
+      30.0));
   std::vector<MockVideoEncoder*> new_encoders = helper_->factory()->encoders();
   ASSERT_EQ(2u, new_encoders.size());
   ASSERT_EQ(original_encoders[0], new_encoders[0]);
@@ -617,7 +622,9 @@ TEST_F(TestSimulcastEncoderAdapterFake, ReusesEncodersInOrder) {
   codec_.numberOfSimulcastStreams = 1;
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, kSettings));
   adapter_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(target_bitrate, 30), 30.0));
+      rate_allocator_->Allocate(
+          VideoBitrateAllocationParameters(target_bitrate, 30)),
+      30.0));
   new_encoders = helper_->factory()->encoders();
   ASSERT_EQ(1u, new_encoders.size());
   ASSERT_EQ(original_encoders[0], new_encoders[0]);
@@ -635,7 +642,9 @@ TEST_F(TestSimulcastEncoderAdapterFake, ReusesEncodersInOrder) {
   codec_.numberOfSimulcastStreams = 3;
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, kSettings));
   adapter_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(target_bitrate, 30), 30.0));
+      rate_allocator_->Allocate(
+          VideoBitrateAllocationParameters(target_bitrate, 30)),
+      30.0));
   new_encoders = helper_->factory()->encoders();
   ASSERT_EQ(3u, new_encoders.size());
   // The first encoder is reused.
@@ -719,7 +728,8 @@ TEST_F(TestSimulcastEncoderAdapterFake, ReinitDoesNotReorderEncoderSettings) {
 TEST_F(TestSimulcastEncoderAdapterFake, ReinitDoesNotReorderFrameSimulcastIdx) {
   SetupCodec();
   adapter_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(1200, 30), 30.0));
+      rate_allocator_->Allocate(VideoBitrateAllocationParameters(1200, 30)),
+      30.0));
   VerifyCodecSettings();
 
   // Send frames on all streams.
@@ -744,7 +754,8 @@ TEST_F(TestSimulcastEncoderAdapterFake, ReinitDoesNotReorderFrameSimulcastIdx) {
   EXPECT_EQ(0, adapter_->Release());
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, kSettings));
   adapter_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(1200, 30), 30.0));
+      rate_allocator_->Allocate(VideoBitrateAllocationParameters(1200, 30)),
+      30.0));
 
   // Verify that the same encoder sends out frames on the same simulcast index.
   encoders[0]->SendEncodedImage(1152, 704);
@@ -786,15 +797,15 @@ TEST_F(TestSimulcastEncoderAdapterFake, SetRatesUnderMinBitrate) {
   rate_allocator_.reset(new SimulcastRateAllocator(codec_));
 
   // Above min should be respected.
-  VideoBitrateAllocation target_bitrate =
-      rate_allocator_->GetAllocation(codec_.minBitrate * 1000, 30);
+  VideoBitrateAllocation target_bitrate = rate_allocator_->Allocate(
+      VideoBitrateAllocationParameters(codec_.minBitrate * 1000, 30));
   adapter_->SetRates(VideoEncoder::RateControlParameters(target_bitrate, 30.0));
   EXPECT_EQ(target_bitrate,
             helper_->factory()->encoders()[0]->last_set_rates().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);
+  VideoBitrateAllocation too_low_bitrate = rate_allocator_->Allocate(
+      VideoBitrateAllocationParameters((codec_.minBitrate - 1) * 1000, 30));
   adapter_->SetRates(
       VideoEncoder::RateControlParameters(too_low_bitrate, 30.0));
   EXPECT_EQ(target_bitrate,
@@ -1184,8 +1195,9 @@ TEST_F(TestSimulcastEncoderAdapterFake, SetRateDistributesBandwithAllocation) {
 
   // Set bitrates so that we send all layers.
   adapter_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(target_bitrate.bps(), 30), 30.0,
-      bandwidth_allocation));
+      rate_allocator_->Allocate(
+          VideoBitrateAllocationParameters(target_bitrate.bps(), 30)),
+      30.0, bandwidth_allocation));
 
   std::vector<MockVideoEncoder*> encoders = helper_->factory()->encoders();
 
diff --git a/modules/video_coding/codecs/h264/h264_encoder_impl.cc b/modules/video_coding/codecs/h264/h264_encoder_impl.cc
index 7564e85bb7..5ec1187946 100644
--- a/modules/video_coding/codecs/h264/h264_encoder_impl.cc
+++ b/modules/video_coding/codecs/h264/h264_encoder_impl.cc
@@ -294,8 +294,9 @@ int32_t H264EncoderImpl::InitEncode(const VideoCodec* inst,
   }
 
   SimulcastRateAllocator init_allocator(codec_);
-  VideoBitrateAllocation allocation = init_allocator.GetAllocation(
-      codec_.startBitrate * 1000, codec_.maxFramerate);
+  VideoBitrateAllocation allocation =
+      init_allocator.Allocate(VideoBitrateAllocationParameters(
+          DataRate::kbps(codec_.startBitrate), codec_.maxFramerate));
   SetRates(RateControlParameters(allocation, codec_.maxFramerate));
   return WEBRTC_VIDEO_CODEC_OK;
 }
diff --git a/modules/video_coding/codecs/test/videoprocessor.cc b/modules/video_coding/codecs/test/videoprocessor.cc
index 9b0903b334..79525100e1 100644
--- a/modules/video_coding/codecs/test/videoprocessor.cc
+++ b/modules/video_coding/codecs/test/videoprocessor.cc
@@ -305,8 +305,9 @@ void VideoProcessor::ProcessFrame() {
 void VideoProcessor::SetRates(size_t bitrate_kbps, double framerate_fps) {
   RTC_DCHECK_RUN_ON(&sequence_checker_);
   framerate_fps_ = framerate_fps;
-  bitrate_allocation_ = bitrate_allocator_->GetAllocation(
-      static_cast<uint32_t>(bitrate_kbps * 1000), framerate_fps_);
+  bitrate_allocation_ =
+      bitrate_allocator_->Allocate(VideoBitrateAllocationParameters(
+          static_cast<uint32_t>(bitrate_kbps * 1000), framerate_fps_));
   encoder_->SetRates(
       VideoEncoder::RateControlParameters(bitrate_allocation_, framerate_fps_));
 }
diff --git a/modules/video_coding/codecs/vp8/default_temporal_layers_unittest.cc b/modules/video_coding/codecs/vp8/default_temporal_layers_unittest.cc
index dd123cf08f..9085afd8ea 100644
--- a/modules/video_coding/codecs/vp8/default_temporal_layers_unittest.cc
+++ b/modules/video_coding/codecs/vp8/default_temporal_layers_unittest.cc
@@ -96,7 +96,9 @@ std::vector<uint32_t> GetTemporalLayerRates(int target_bitrate_kbps,
   codec.simulcastStream[0].numberOfTemporalLayers = num_temporal_layers;
   codec.simulcastStream[0].active = true;
   SimulcastRateAllocator allocator(codec);
-  return allocator.GetAllocation(target_bitrate_kbps, framerate_fps)
+  return allocator
+      .Allocate(
+          VideoBitrateAllocationParameters(target_bitrate_kbps, framerate_fps))
       .GetTemporalLayerAllocation(0);
 }
 
diff --git a/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc b/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
index ff2c801d26..892d6ffe53 100644
--- a/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
+++ b/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
@@ -642,8 +642,9 @@ int LibvpxVp8Encoder::InitEncode(const VideoCodec* inst,
   // at position 0 and they have highest resolution at position 0.
   const size_t stream_idx_cfg_0 = encoders_.size() - 1;
   SimulcastRateAllocator init_allocator(codec_);
-  VideoBitrateAllocation allocation = init_allocator.GetAllocation(
-      inst->startBitrate * 1000, inst->maxFramerate);
+  VideoBitrateAllocation allocation =
+      init_allocator.Allocate(VideoBitrateAllocationParameters(
+          inst->startBitrate * 1000, inst->maxFramerate));
   std::vector<uint32_t> stream_bitrates;
   for (int i = 0; i == 0 || i < inst->numberOfSimulcastStreams; ++i) {
     uint32_t bitrate = allocation.GetSpatialLayerSum(i) / 1000;
diff --git a/modules/video_coding/codecs/vp9/svc_rate_allocator.cc b/modules/video_coding/codecs/vp9/svc_rate_allocator.cc
index dcbd03ece5..5aa414ea41 100644
--- a/modules/video_coding/codecs/vp9/svc_rate_allocator.cc
+++ b/modules/video_coding/codecs/vp9/svc_rate_allocator.cc
@@ -103,18 +103,18 @@ SvcRateAllocator::SvcRateAllocator(const VideoCodec& codec) : codec_(codec) {
   RTC_DCHECK_GT(codec.VP9().numberOfTemporalLayers, 0u);
 }
 
-VideoBitrateAllocation SvcRateAllocator::GetAllocation(
-    uint32_t total_bitrate_bps,
-    uint32_t framerate_fps) {
+VideoBitrateAllocation SvcRateAllocator::Allocate(
+    VideoBitrateAllocationParameters parameters) {
+  DataRate total_bitrate = parameters.total_bitrate;
   if (codec_.maxBitrate != 0) {
-    total_bitrate_bps = std::min(total_bitrate_bps, codec_.maxBitrate * 1000);
+    total_bitrate = std::min(total_bitrate, DataRate::kbps(codec_.maxBitrate));
   }
 
   if (codec_.spatialLayers[0].targetBitrate == 0) {
     // Delegate rate distribution to VP9 encoder wrapper if bitrate thresholds
     // are not set.
     VideoBitrateAllocation bitrate_allocation;
-    bitrate_allocation.SetBitrate(0, 0, total_bitrate_bps);
+    bitrate_allocation.SetBitrate(0, 0, total_bitrate.bps());
     return bitrate_allocation;
   }
 
@@ -124,9 +124,9 @@ VideoBitrateAllocation SvcRateAllocator::GetAllocation(
   }
 
   if (codec_.mode == VideoCodecMode::kRealtimeVideo) {
-    return GetAllocationNormalVideo(total_bitrate_bps, num_spatial_layers);
+    return GetAllocationNormalVideo(total_bitrate.bps(), num_spatial_layers);
   } else {
-    return GetAllocationScreenSharing(total_bitrate_bps, num_spatial_layers);
+    return GetAllocationScreenSharing(total_bitrate.bps(), num_spatial_layers);
   }
 }
 
diff --git a/modules/video_coding/codecs/vp9/svc_rate_allocator.h b/modules/video_coding/codecs/vp9/svc_rate_allocator.h
index 79bb56b33b..e410964969 100644
--- a/modules/video_coding/codecs/vp9/svc_rate_allocator.h
+++ b/modules/video_coding/codecs/vp9/svc_rate_allocator.h
@@ -26,8 +26,8 @@ class SvcRateAllocator : public VideoBitrateAllocator {
  public:
   explicit SvcRateAllocator(const VideoCodec& codec);
 
-  VideoBitrateAllocation GetAllocation(uint32_t total_bitrate_bps,
-                                       uint32_t framerate_fps) override;
+  VideoBitrateAllocation Allocate(
+      VideoBitrateAllocationParameters parameters) override;
 
   static uint32_t GetMaxBitrateBps(const VideoCodec& codec);
   static uint32_t GetPaddingBitrateBps(const VideoCodec& codec);
diff --git a/modules/video_coding/codecs/vp9/svc_rate_allocator_unittest.cc b/modules/video_coding/codecs/vp9/svc_rate_allocator_unittest.cc
index 71392a9896..c0febb8bf8 100644
--- a/modules/video_coding/codecs/vp9/svc_rate_allocator_unittest.cc
+++ b/modules/video_coding/codecs/vp9/svc_rate_allocator_unittest.cc
@@ -52,7 +52,8 @@ TEST(SvcRateAllocatorTest, SingleLayerFor320x180Input) {
   VideoCodec codec = Configure(320, 180, 3, 3, false);
   SvcRateAllocator allocator = SvcRateAllocator(codec);
 
-  VideoBitrateAllocation allocation = allocator.GetAllocation(1000 * 1000, 30);
+  VideoBitrateAllocation allocation =
+      allocator.Allocate(VideoBitrateAllocationParameters(1000 * 1000, 30));
 
   EXPECT_GT(allocation.GetSpatialLayerSum(0), 0u);
   EXPECT_EQ(allocation.GetSpatialLayerSum(1), 0u);
@@ -62,7 +63,8 @@ TEST(SvcRateAllocatorTest, TwoLayersFor640x360Input) {
   VideoCodec codec = Configure(640, 360, 3, 3, false);
   SvcRateAllocator allocator = SvcRateAllocator(codec);
 
-  VideoBitrateAllocation allocation = allocator.GetAllocation(1000 * 1000, 30);
+  VideoBitrateAllocation allocation =
+      allocator.Allocate(VideoBitrateAllocationParameters(1000 * 1000, 30));
 
   EXPECT_GT(allocation.GetSpatialLayerSum(0), 0u);
   EXPECT_GT(allocation.GetSpatialLayerSum(1), 0u);
@@ -73,7 +75,8 @@ TEST(SvcRateAllocatorTest, ThreeLayersFor1280x720Input) {
   VideoCodec codec = Configure(1280, 720, 3, 3, false);
   SvcRateAllocator allocator = SvcRateAllocator(codec);
 
-  VideoBitrateAllocation allocation = allocator.GetAllocation(1000 * 1000, 30);
+  VideoBitrateAllocation allocation =
+      allocator.Allocate(VideoBitrateAllocationParameters(1000 * 1000, 30));
 
   EXPECT_GT(allocation.GetSpatialLayerSum(0), 0u);
   EXPECT_GT(allocation.GetSpatialLayerSum(1), 0u);
@@ -87,8 +90,8 @@ TEST(SvcRateAllocatorTest,
 
   const SpatialLayer* layers = codec.spatialLayers;
 
-  VideoBitrateAllocation allocation =
-      allocator.GetAllocation(layers[0].minBitrate * 1000 / 2, 30);
+  VideoBitrateAllocation allocation = allocator.Allocate(
+      VideoBitrateAllocationParameters(layers[0].minBitrate * 1000 / 2, 30));
 
   EXPECT_GT(allocation.GetSpatialLayerSum(0), 0u);
   EXPECT_LT(allocation.GetSpatialLayerSum(0), layers[0].minBitrate * 1000);
@@ -104,8 +107,9 @@ TEST(SvcRateAllocatorTest, Disable640x360Layer) {
   size_t min_bitrate_for_640x360_layer_kbps =
       layers[0].minBitrate + layers[1].minBitrate;
 
-  VideoBitrateAllocation allocation = allocator.GetAllocation(
-      min_bitrate_for_640x360_layer_kbps * 1000 - 1, 30);
+  VideoBitrateAllocation allocation =
+      allocator.Allocate(VideoBitrateAllocationParameters(
+          min_bitrate_for_640x360_layer_kbps * 1000 - 1, 30));
 
   EXPECT_GT(allocation.GetSpatialLayerSum(0), 0u);
   EXPECT_EQ(allocation.GetSpatialLayerSum(1), 0u);
@@ -120,8 +124,9 @@ TEST(SvcRateAllocatorTest, Disable1280x720Layer) {
   size_t min_bitrate_for_1280x720_layer_kbps =
       layers[0].minBitrate + layers[1].minBitrate + layers[2].minBitrate;
 
-  VideoBitrateAllocation allocation = allocator.GetAllocation(
-      min_bitrate_for_1280x720_layer_kbps * 1000 - 1, 30);
+  VideoBitrateAllocation allocation =
+      allocator.Allocate(VideoBitrateAllocationParameters(
+          min_bitrate_for_1280x720_layer_kbps * 1000 - 1, 30));
 
   EXPECT_GT(allocation.GetSpatialLayerSum(0), 0u);
   EXPECT_GT(allocation.GetSpatialLayerSum(1), 0u);
@@ -135,8 +140,8 @@ TEST(SvcRateAllocatorTest, BitrateIsCapped) {
   const SpatialLayer* layers = codec.spatialLayers;
 
   const uint32_t link_mbps = 100;
-  VideoBitrateAllocation allocation =
-      allocator.GetAllocation(link_mbps * 1000000, 30);
+  VideoBitrateAllocation allocation = allocator.Allocate(
+      VideoBitrateAllocationParameters(link_mbps * 1000000, 30));
 
   EXPECT_EQ(allocation.get_sum_kbps(),
             layers[0].maxBitrate + layers[1].maxBitrate + layers[2].maxBitrate);
@@ -153,13 +158,13 @@ TEST(SvcRateAllocatorTest, MinBitrateToGetQualityLayer) {
 
   EXPECT_LE(codec.VP9()->numberOfSpatialLayers, 3U);
 
-  VideoBitrateAllocation allocation =
-      allocator.GetAllocation(layers[0].minBitrate * 1000, 30);
+  VideoBitrateAllocation allocation = allocator.Allocate(
+      VideoBitrateAllocationParameters(layers[0].minBitrate * 1000, 30));
   EXPECT_EQ(allocation.GetSpatialLayerSum(0) / 1000, layers[0].minBitrate);
   EXPECT_EQ(allocation.GetSpatialLayerSum(1), 0UL);
 
-  allocation = allocator.GetAllocation(
-      (layers[0].targetBitrate + layers[1].minBitrate) * 1000, 30);
+  allocation = allocator.Allocate(VideoBitrateAllocationParameters(
+      (layers[0].targetBitrate + layers[1].minBitrate) * 1000, 30));
   EXPECT_EQ(allocation.GetSpatialLayerSum(0) / 1000, layers[0].targetBitrate);
   EXPECT_EQ(allocation.GetSpatialLayerSum(1) / 1000, layers[1].minBitrate);
 }
@@ -173,8 +178,8 @@ TEST(SvcRateAllocatorTest, DeativateLayers) {
 
     SvcRateAllocator allocator = SvcRateAllocator(codec);
 
-    VideoBitrateAllocation allocation =
-        allocator.GetAllocation(10 * 1000 * 1000, 30);
+    VideoBitrateAllocation allocation = allocator.Allocate(
+        VideoBitrateAllocationParameters(10 * 1000 * 1000, 30));
 
     // Ensure layers spatial_idx < deactivated_idx are activated.
     for (int spatial_idx = 0; spatial_idx < deactivated_idx; ++spatial_idx) {
@@ -227,14 +232,15 @@ TEST_P(SvcRateAllocatorTestParametrizedContentType, PaddingBitrate) {
 
   uint32_t padding_bitrate_bps = SvcRateAllocator::GetPaddingBitrateBps(codec);
 
-  VideoBitrateAllocation allocation =
-      allocator.GetAllocation(padding_bitrate_bps, 30);
+  VideoBitrateAllocation allocation = allocator.Allocate(
+      VideoBitrateAllocationParameters(padding_bitrate_bps, 30));
   EXPECT_GT(allocation.GetSpatialLayerSum(0), 0UL);
   EXPECT_GT(allocation.GetSpatialLayerSum(1), 0UL);
   EXPECT_GT(allocation.GetSpatialLayerSum(2), 0UL);
 
   // Allocate 90% of padding bitrate. Top layer should be disabled.
-  allocation = allocator.GetAllocation(9 * padding_bitrate_bps / 10, 30);
+  allocation = allocator.Allocate(
+      VideoBitrateAllocationParameters(9 * padding_bitrate_bps / 10, 30));
   EXPECT_GT(allocation.GetSpatialLayerSum(0), 0UL);
   EXPECT_GT(allocation.GetSpatialLayerSum(1), 0UL);
   EXPECT_EQ(allocation.GetSpatialLayerSum(2), 0UL);
@@ -243,12 +249,14 @@ TEST_P(SvcRateAllocatorTestParametrizedContentType, PaddingBitrate) {
   codec.spatialLayers[2].active = false;
 
   padding_bitrate_bps = SvcRateAllocator::GetPaddingBitrateBps(codec);
-  allocation = allocator.GetAllocation(padding_bitrate_bps, 30);
+  allocation = allocator.Allocate(
+      VideoBitrateAllocationParameters(padding_bitrate_bps, 30));
   EXPECT_GT(allocation.GetSpatialLayerSum(0), 0UL);
   EXPECT_GT(allocation.GetSpatialLayerSum(1), 0UL);
   EXPECT_EQ(allocation.GetSpatialLayerSum(2), 0UL);
 
-  allocation = allocator.GetAllocation(9 * padding_bitrate_bps / 10, 30);
+  allocation = allocator.Allocate(
+      VideoBitrateAllocationParameters(9 * padding_bitrate_bps / 10, 30));
   EXPECT_GT(allocation.GetSpatialLayerSum(0), 0UL);
   EXPECT_EQ(allocation.GetSpatialLayerSum(1), 0UL);
   EXPECT_EQ(allocation.GetSpatialLayerSum(2), 0UL);
diff --git a/modules/video_coding/codecs/vp9/vp9_impl.cc b/modules/video_coding/codecs/vp9/vp9_impl.cc
index 9f46ade344..a0f410f186 100644
--- a/modules/video_coding/codecs/vp9/vp9_impl.cc
+++ b/modules/video_coding/codecs/vp9/vp9_impl.cc
@@ -659,8 +659,9 @@ int VP9EncoderImpl::InitAndSetControlSettings(const VideoCodec* inst) {
   }
 
   SvcRateAllocator init_allocator(codec_);
-  current_bitrate_allocation_ = init_allocator.GetAllocation(
-      inst->startBitrate * 1000, inst->maxFramerate);
+  current_bitrate_allocation_ =
+      init_allocator.Allocate(VideoBitrateAllocationParameters(
+          inst->startBitrate * 1000, inst->maxFramerate));
   if (!SetSvcRates(current_bitrate_allocation_)) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
diff --git a/modules/video_coding/utility/default_video_bitrate_allocator.cc b/modules/video_coding/utility/default_video_bitrate_allocator.cc
index 6d3ca53b57..bbb15cdd76 100644
--- a/modules/video_coding/utility/default_video_bitrate_allocator.cc
+++ b/modules/video_coding/utility/default_video_bitrate_allocator.cc
@@ -25,14 +25,13 @@ DefaultVideoBitrateAllocator::~DefaultVideoBitrateAllocator() {}
 
 // TODO(http://crbug.com/webrtc/9671): Do not split bitrate between simulcast
 // streams, but allocate everything to the first stream.
-VideoBitrateAllocation DefaultVideoBitrateAllocator::GetAllocation(
-    uint32_t total_bitrate_bps,
-    uint32_t framerate) {
+VideoBitrateAllocation DefaultVideoBitrateAllocator::Allocate(
+    VideoBitrateAllocationParameters parameters) {
   VideoBitrateAllocation allocation;
-  if (total_bitrate_bps == 0 || !codec_.active)
+  if (parameters.total_bitrate.IsZero() || !codec_.active)
     return allocation;
 
-  uint32_t allocated_bitrate_bps = total_bitrate_bps;
+  uint32_t allocated_bitrate_bps = parameters.total_bitrate.bps();
   allocated_bitrate_bps =
       std::max(allocated_bitrate_bps, codec_.minBitrate * 1000);
   if (codec_.maxBitrate > 0) {
diff --git a/modules/video_coding/utility/default_video_bitrate_allocator.h b/modules/video_coding/utility/default_video_bitrate_allocator.h
index de5c23f7ef..c3eb67036a 100644
--- a/modules/video_coding/utility/default_video_bitrate_allocator.h
+++ b/modules/video_coding/utility/default_video_bitrate_allocator.h
@@ -24,8 +24,8 @@ class DefaultVideoBitrateAllocator : public VideoBitrateAllocator {
   explicit DefaultVideoBitrateAllocator(const VideoCodec& codec);
   ~DefaultVideoBitrateAllocator() override;
 
-  VideoBitrateAllocation GetAllocation(uint32_t total_bitrate,
-                                       uint32_t framerate) override;
+  VideoBitrateAllocation Allocate(
+      VideoBitrateAllocationParameters parameters) override;
 
  private:
   const VideoCodec codec_;
diff --git a/modules/video_coding/utility/default_video_bitrate_allocator_unittest.cc b/modules/video_coding/utility/default_video_bitrate_allocator_unittest.cc
index 4a4ad73bbd..ed0cb5f3ee 100644
--- a/modules/video_coding/utility/default_video_bitrate_allocator_unittest.cc
+++ b/modules/video_coding/utility/default_video_bitrate_allocator_unittest.cc
@@ -42,7 +42,7 @@ class DefaultVideoBitrateAllocatorTest : public ::testing::Test {
 
 TEST_F(DefaultVideoBitrateAllocatorTest, ZeroIsOff) {
   VideoBitrateAllocation allocation =
-      allocator_->GetAllocation(0, kMaxFramerate);
+      allocator_->Allocate(VideoBitrateAllocationParameters(0, kMaxFramerate));
   EXPECT_EQ(0u, allocation.get_sum_bps());
 }
 
@@ -50,41 +50,45 @@ TEST_F(DefaultVideoBitrateAllocatorTest, Inactive) {
   codec_.active = false;
   allocator_.reset(new DefaultVideoBitrateAllocator(codec_));
   VideoBitrateAllocation allocation =
-      allocator_->GetAllocation(1, kMaxFramerate);
+      allocator_->Allocate(VideoBitrateAllocationParameters(1, kMaxFramerate));
   EXPECT_EQ(0u, allocation.get_sum_bps());
 }
 
 TEST_F(DefaultVideoBitrateAllocatorTest, CapsToMin) {
   VideoBitrateAllocation allocation =
-      allocator_->GetAllocation(1, kMaxFramerate);
+      allocator_->Allocate(VideoBitrateAllocationParameters(1, kMaxFramerate));
   EXPECT_EQ(kMinBitrateBps, allocation.get_sum_bps());
 
-  allocation = allocator_->GetAllocation(kMinBitrateBps - 1, kMaxFramerate);
+  allocation = allocator_->Allocate(
+      VideoBitrateAllocationParameters(kMinBitrateBps - 1, kMaxFramerate));
   EXPECT_EQ(kMinBitrateBps, allocation.get_sum_bps());
 
-  allocation = allocator_->GetAllocation(kMinBitrateBps, kMaxFramerate);
+  allocation = allocator_->Allocate(
+      VideoBitrateAllocationParameters(kMinBitrateBps, kMaxFramerate));
   EXPECT_EQ(kMinBitrateBps, allocation.get_sum_bps());
 }
 
 TEST_F(DefaultVideoBitrateAllocatorTest, CapsToMax) {
-  VideoBitrateAllocation allocation =
-      allocator_->GetAllocation(kMaxBitrateBps, kMaxFramerate);
+  VideoBitrateAllocation allocation = allocator_->Allocate(
+      VideoBitrateAllocationParameters(kMaxBitrateBps, kMaxFramerate));
   EXPECT_EQ(kMaxBitrateBps, allocation.get_sum_bps());
 
-  allocation = allocator_->GetAllocation(kMaxBitrateBps + 1, kMaxFramerate);
+  allocation = allocator_->Allocate(
+      VideoBitrateAllocationParameters(kMaxBitrateBps + 1, kMaxFramerate));
   EXPECT_EQ(kMaxBitrateBps, allocation.get_sum_bps());
 
-  allocation = allocator_->GetAllocation(std::numeric_limits<uint32_t>::max(),
-                                         kMaxFramerate);
+  allocation = allocator_->Allocate(VideoBitrateAllocationParameters(
+      std::numeric_limits<uint32_t>::max(), kMaxFramerate));
   EXPECT_EQ(kMaxBitrateBps, allocation.get_sum_bps());
 }
 
 TEST_F(DefaultVideoBitrateAllocatorTest, GoodInBetween) {
-  VideoBitrateAllocation allocation =
-      allocator_->GetAllocation(kMinBitrateBps + 1, kMaxFramerate);
+  VideoBitrateAllocation allocation = allocator_->Allocate(
+      VideoBitrateAllocationParameters(kMinBitrateBps + 1, kMaxFramerate));
   EXPECT_EQ(kMinBitrateBps + 1, allocation.get_sum_bps());
 
-  allocation = allocator_->GetAllocation(kMaxBitrateBps - 1, kMaxFramerate);
+  allocation = allocator_->Allocate(
+      VideoBitrateAllocationParameters(kMaxBitrateBps - 1, kMaxFramerate));
   EXPECT_EQ(kMaxBitrateBps - 1, allocation.get_sum_bps());
 }
 }  // namespace webrtc
diff --git a/modules/video_coding/utility/simulcast_rate_allocator.cc b/modules/video_coding/utility/simulcast_rate_allocator.cc
index ced01a7713..112424103e 100644
--- a/modules/video_coding/utility/simulcast_rate_allocator.cc
+++ b/modules/video_coding/utility/simulcast_rate_allocator.cc
@@ -13,6 +13,7 @@
 #include <stdio.h>
 
 #include <algorithm>
+#include <cmath>
 #include <cstdint>
 #include <numeric>
 #include <string>
@@ -63,13 +64,13 @@ SimulcastRateAllocator::SimulcastRateAllocator(const VideoCodec& codec)
 
 SimulcastRateAllocator::~SimulcastRateAllocator() = default;
 
-VideoBitrateAllocation SimulcastRateAllocator::GetAllocation(
-    uint32_t total_bitrate_bps,
-    uint32_t framerate) {
+VideoBitrateAllocation SimulcastRateAllocator::Allocate(
+    VideoBitrateAllocationParameters parameters) {
   VideoBitrateAllocation allocated_bitrates_bps;
-  DistributeAllocationToSimulcastLayers(total_bitrate_bps,
+  DistributeAllocationToSimulcastLayers(parameters.total_bitrate.bps(),
                                         &allocated_bitrates_bps);
-  DistributeAllocationToTemporalLayers(framerate, &allocated_bitrates_bps);
+  DistributeAllocationToTemporalLayers(std::ceil(parameters.framerate),
+                                       &allocated_bitrates_bps);
   return allocated_bitrates_bps;
 }
 
diff --git a/modules/video_coding/utility/simulcast_rate_allocator.h b/modules/video_coding/utility/simulcast_rate_allocator.h
index 1d865a9eb4..ea9211b93f 100644
--- a/modules/video_coding/utility/simulcast_rate_allocator.h
+++ b/modules/video_coding/utility/simulcast_rate_allocator.h
@@ -28,8 +28,8 @@ class SimulcastRateAllocator : public VideoBitrateAllocator {
   explicit SimulcastRateAllocator(const VideoCodec& codec);
   ~SimulcastRateAllocator() override;
 
-  VideoBitrateAllocation GetAllocation(uint32_t total_bitrate_bps,
-                                       uint32_t framerate) override;
+  VideoBitrateAllocation Allocate(
+      VideoBitrateAllocationParameters parameters) override;
   const VideoCodec& GetCodec() const;
 
   static float GetTemporalRateAllocation(int num_layers, int temporal_id);
diff --git a/modules/video_coding/utility/simulcast_rate_allocator_unittest.cc b/modules/video_coding/utility/simulcast_rate_allocator_unittest.cc
index d2918fb923..2c2b7c7e65 100644
--- a/modules/video_coding/utility/simulcast_rate_allocator_unittest.cc
+++ b/modules/video_coding/utility/simulcast_rate_allocator_unittest.cc
@@ -132,7 +132,8 @@ class SimulcastRateAllocatorTest : public ::testing::TestWithParam<bool> {
   }
 
   VideoBitrateAllocation GetAllocation(uint32_t target_bitrate) {
-    return allocator_->GetAllocation(target_bitrate * 1000U, kDefaultFrameRate);
+    return allocator_->Allocate(VideoBitrateAllocationParameters(
+        DataRate::kbps(target_bitrate), kDefaultFrameRate));
   }
 
  protected:
@@ -563,8 +564,9 @@ TEST_P(ScreenshareRateAllocationTest, BitrateBelowTl0) {
   SetupConferenceScreenshare(GetParam());
   CreateAllocator();
 
-  VideoBitrateAllocation allocation = allocator_->GetAllocation(
-      kLegacyScreenshareTargetBitrateKbps * 1000, kFramerateFps);
+  VideoBitrateAllocation allocation =
+      allocator_->Allocate(VideoBitrateAllocationParameters(
+          kLegacyScreenshareTargetBitrateKbps * 1000, kFramerateFps));
 
   // All allocation should go in TL0.
   EXPECT_EQ(kLegacyScreenshareTargetBitrateKbps, allocation.get_sum_kbps());
@@ -580,7 +582,8 @@ TEST_P(ScreenshareRateAllocationTest, BitrateAboveTl0) {
       (kLegacyScreenshareTargetBitrateKbps + kLegacyScreenshareMaxBitrateKbps) /
       2;
   VideoBitrateAllocation allocation =
-      allocator_->GetAllocation(target_bitrate_kbps * 1000, kFramerateFps);
+      allocator_->Allocate(VideoBitrateAllocationParameters(
+          target_bitrate_kbps * 1000, kFramerateFps));
 
   // Fill TL0, then put the rest in TL1.
   EXPECT_EQ(target_bitrate_kbps, allocation.get_sum_kbps());
@@ -595,8 +598,9 @@ TEST_F(ScreenshareRateAllocationTest, BitrateAboveTl1) {
   SetupConferenceScreenshare(false);
   CreateAllocator();
 
-  VideoBitrateAllocation allocation = allocator_->GetAllocation(
-      kLegacyScreenshareMaxBitrateKbps * 2000, kFramerateFps);
+  VideoBitrateAllocation allocation =
+      allocator_->Allocate(VideoBitrateAllocationParameters(
+          kLegacyScreenshareMaxBitrateKbps * 2000, kFramerateFps));
 
   // Fill both TL0 and TL1, but no more.
   EXPECT_EQ(kLegacyScreenshareMaxBitrateKbps, allocation.get_sum_kbps());
@@ -618,7 +622,8 @@ TEST_P(ScreenshareRateAllocationTest, InactiveScreenshare) {
       (kLegacyScreenshareTargetBitrateKbps + kLegacyScreenshareMaxBitrateKbps) /
       2;
   VideoBitrateAllocation allocation =
-      allocator_->GetAllocation(target_bitrate_kbps * 1000, kFramerateFps);
+      allocator_->Allocate(VideoBitrateAllocationParameters(
+          target_bitrate_kbps * 1000, kFramerateFps));
 
   EXPECT_EQ(0U, allocation.get_sum_kbps());
 }
diff --git a/modules/video_coding/utility/simulcast_test_fixture_impl.cc b/modules/video_coding/utility/simulcast_test_fixture_impl.cc
index 404e6f6f75..7d94182f03 100644
--- a/modules/video_coding/utility/simulcast_test_fixture_impl.cc
+++ b/modules/video_coding/utility/simulcast_test_fixture_impl.cc
@@ -302,7 +302,8 @@ void SimulcastTestFixtureImpl::SetUpRateAllocator() {
 
 void SimulcastTestFixtureImpl::SetRates(uint32_t bitrate_kbps, uint32_t fps) {
   encoder_->SetRates(VideoEncoder::RateControlParameters(
-      rate_allocator_->GetAllocation(bitrate_kbps * 1000, fps),
+      rate_allocator_->Allocate(
+          VideoBitrateAllocationParameters(bitrate_kbps * 1000, fps)),
       static_cast<double>(fps)));
 }
 
diff --git a/modules/video_coding/video_codec_initializer_unittest.cc b/modules/video_coding/video_codec_initializer_unittest.cc
index 25ef3e77bf..ca1da2cc8c 100644
--- a/modules/video_coding/video_codec_initializer_unittest.cc
+++ b/modules/video_coding/video_codec_initializer_unittest.cc
@@ -151,8 +151,9 @@ TEST_F(VideoCodecInitializerTest, SingleStreamVp8Screenshare) {
   streams_.push_back(DefaultStream());
   EXPECT_TRUE(InitializeCodec());
 
-  VideoBitrateAllocation bitrate_allocation = bitrate_allocator_->GetAllocation(
-      kDefaultTargetBitrateBps, kDefaultFrameRate);
+  VideoBitrateAllocation bitrate_allocation =
+      bitrate_allocator_->Allocate(VideoBitrateAllocationParameters(
+          kDefaultTargetBitrateBps, kDefaultFrameRate));
   EXPECT_EQ(1u, codec_out_.numberOfSimulcastStreams);
   EXPECT_EQ(1u, codec_out_.VP8()->numberOfTemporalLayers);
   EXPECT_EQ(kDefaultTargetBitrateBps, bitrate_allocation.get_sum_bps());
@@ -165,8 +166,9 @@ TEST_F(VideoCodecInitializerTest, SingleStreamVp8ScreenshareInactive) {
   streams_.push_back(inactive_stream);
   EXPECT_TRUE(InitializeCodec());
 
-  VideoBitrateAllocation bitrate_allocation = bitrate_allocator_->GetAllocation(
-      kDefaultTargetBitrateBps, kDefaultFrameRate);
+  VideoBitrateAllocation bitrate_allocation =
+      bitrate_allocator_->Allocate(VideoBitrateAllocationParameters(
+          kDefaultTargetBitrateBps, kDefaultFrameRate));
   EXPECT_EQ(1u, codec_out_.numberOfSimulcastStreams);
   EXPECT_EQ(1u, codec_out_.VP8()->numberOfTemporalLayers);
   EXPECT_EQ(0U, bitrate_allocation.get_sum_bps());
@@ -179,8 +181,9 @@ TEST_F(VideoCodecInitializerTest, TemporalLayeredVp8Screenshare) {
 
   EXPECT_EQ(1u, codec_out_.numberOfSimulcastStreams);
   EXPECT_EQ(2u, codec_out_.VP8()->numberOfTemporalLayers);
-  VideoBitrateAllocation bitrate_allocation = bitrate_allocator_->GetAllocation(
-      kScreenshareCodecTargetBitrateBps, kScreenshareDefaultFramerate);
+  VideoBitrateAllocation bitrate_allocation =
+      bitrate_allocator_->Allocate(VideoBitrateAllocationParameters(
+          kScreenshareCodecTargetBitrateBps, kScreenshareDefaultFramerate));
   EXPECT_EQ(kScreenshareCodecTargetBitrateBps,
             bitrate_allocation.get_sum_bps());
   EXPECT_EQ(kScreenshareTl0BitrateBps, bitrate_allocation.GetBitrate(0, 0));
@@ -198,8 +201,9 @@ TEST_F(VideoCodecInitializerTest, SimulcastVp8Screenshare) {
   EXPECT_EQ(1u, codec_out_.VP8()->numberOfTemporalLayers);
   const uint32_t max_bitrate_bps =
       streams_[0].target_bitrate_bps + streams_[1].max_bitrate_bps;
-  VideoBitrateAllocation bitrate_allocation = bitrate_allocator_->GetAllocation(
-      max_bitrate_bps, kScreenshareDefaultFramerate);
+  VideoBitrateAllocation bitrate_allocation =
+      bitrate_allocator_->Allocate(VideoBitrateAllocationParameters(
+          max_bitrate_bps, kScreenshareDefaultFramerate));
   EXPECT_EQ(max_bitrate_bps, bitrate_allocation.get_sum_bps());
   EXPECT_EQ(static_cast<uint32_t>(streams_[0].target_bitrate_bps),
             bitrate_allocation.GetSpatialLayerSum(0));
@@ -222,8 +226,9 @@ TEST_F(VideoCodecInitializerTest, SimulcastVp8ScreenshareInactive) {
   EXPECT_EQ(1u, codec_out_.VP8()->numberOfTemporalLayers);
   const uint32_t target_bitrate =
       streams_[0].target_bitrate_bps + streams_[1].target_bitrate_bps;
-  VideoBitrateAllocation bitrate_allocation = bitrate_allocator_->GetAllocation(
-      target_bitrate, kScreenshareDefaultFramerate);
+  VideoBitrateAllocation bitrate_allocation =
+      bitrate_allocator_->Allocate(VideoBitrateAllocationParameters(
+          target_bitrate, kScreenshareDefaultFramerate));
   EXPECT_EQ(static_cast<uint32_t>(streams_[0].max_bitrate_bps),
             bitrate_allocation.get_sum_bps());
   EXPECT_EQ(static_cast<uint32_t>(streams_[0].max_bitrate_bps),
@@ -245,8 +250,8 @@ TEST_F(VideoCodecInitializerTest, HighFpsSimulcastVp8Screenshare) {
   EXPECT_EQ(3u, codec_out_.VP8()->numberOfTemporalLayers);
   const uint32_t max_bitrate_bps =
       streams_[0].target_bitrate_bps + streams_[1].max_bitrate_bps;
-  VideoBitrateAllocation bitrate_allocation =
-      bitrate_allocator_->GetAllocation(max_bitrate_bps, kDefaultFrameRate);
+  VideoBitrateAllocation bitrate_allocation = bitrate_allocator_->Allocate(
+      VideoBitrateAllocationParameters(max_bitrate_bps, kDefaultFrameRate));
   EXPECT_EQ(max_bitrate_bps, bitrate_allocation.get_sum_bps());
   EXPECT_EQ(static_cast<uint32_t>(streams_[0].target_bitrate_bps),
             bitrate_allocation.GetSpatialLayerSum(0));
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index 2db0f01d7b..f81a178a3b 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -1103,9 +1103,9 @@ VideoStreamEncoder::UpdateBitrateAllocationAndNotifyObserver(
   // Only call allocators if bitrate > 0 (ie, not suspended), otherwise they
   // might cap the bitrate to the min bitrate configured.
   if (rate_allocator_ && rate_settings.encoder_target > DataRate::Zero()) {
-    new_allocation = rate_allocator_->GetAllocation(
+    new_allocation = rate_allocator_->Allocate(VideoBitrateAllocationParameters(
         rate_settings.encoder_target.bps(),
-        static_cast<uint32_t>(rate_settings.framerate_fps + 0.5));
+        static_cast<uint32_t>(rate_settings.framerate_fps + 0.5)));
   }
 
   if (bitrate_observer_ && new_allocation.get_sum_bps() > 0) {
diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc
index c70c3e829f..06f7b183e9 100644
--- a/video/video_stream_encoder_unittest.cc
+++ b/video/video_stream_encoder_unittest.cc
@@ -2685,7 +2685,8 @@ TEST_F(VideoStreamEncoderTest, CallsBitrateObserver) {
   const int kDefaultFps = 30;
   const VideoBitrateAllocation expected_bitrate =
       DefaultVideoBitrateAllocator(fake_encoder_.codec_config())
-          .GetAllocation(kLowTargetBitrateBps, kDefaultFps);
+          .Allocate(VideoBitrateAllocationParameters(kLowTargetBitrateBps,
+                                                     kDefaultFps));
 
   EXPECT_CALL(bitrate_observer, OnBitrateAllocationUpdated(expected_bitrate))
       .Times(1);