diff --git a/api/video/video_stream_encoder_interface.h b/api/video/video_stream_encoder_interface.h
index 253fb04..8e1df0f 100644
--- a/api/video/video_stream_encoder_interface.h
+++ b/api/video/video_stream_encoder_interface.h
@@ -44,6 +44,7 @@
    public:
     virtual void OnEncoderConfigurationChanged(
         std::vector<VideoStream> streams,
+        bool is_svc,
         VideoEncoderConfig::ContentType content_type,
         int min_transmit_bitrate_bps) = 0;
   };
diff --git a/video/video_send_stream_impl.cc b/video/video_send_stream_impl.cc
index 405de7c..bfd6216 100644
--- a/video/video_send_stream_impl.cc
+++ b/video/video_send_stream_impl.cc
@@ -58,12 +58,16 @@
 
 // Calculate max padding bitrate for a multi layer codec.
 int CalculateMaxPadBitrateBps(const std::vector<VideoStream>& streams,
+                              bool is_svc,
                               VideoEncoderConfig::ContentType content_type,
                               int min_transmit_bitrate_bps,
                               bool pad_to_min_bitrate,
                               bool alr_probing) {
   int pad_up_to_bitrate_bps = 0;
 
+  RTC_DCHECK(!is_svc || streams.size() <= 1) << "Only one stream is allowed in "
+                                                "SVC mode.";
+
   // Filter out only the active streams;
   std::vector<VideoStream> active_streams;
   for (const VideoStream& stream : streams) {
@@ -71,7 +75,13 @@
       active_streams.emplace_back(stream);
   }
 
-  if (active_streams.size() > 1) {
+  if (active_streams.size() > 1 || (!active_streams.empty() && is_svc)) {
+    // Simulcast or SVC is used.
+    // if SVC is used, stream bitrates should already encode svc bitrates:
+    // min_bitrate = min bitrate of a lowest svc layer.
+    // target_bitrate = sum of target bitrates of lower layers + min bitrate
+    // of the last one (as used in the calculations below).
+    // max_bitrate = sum of all active layers' max_bitrate.
     if (alr_probing) {
       // With alr probing, just pad to the min bitrate of the lowest stream,
       // probing will handle the rest of the rampup.
@@ -471,22 +481,23 @@
 
 void VideoSendStreamImpl::OnEncoderConfigurationChanged(
     std::vector<VideoStream> streams,
+    bool is_svc,
     VideoEncoderConfig::ContentType content_type,
     int min_transmit_bitrate_bps) {
   if (!worker_queue_->IsCurrent()) {
     rtc::WeakPtr<VideoSendStreamImpl> send_stream = weak_ptr_;
-    worker_queue_->PostTask([send_stream, streams, content_type,
+    worker_queue_->PostTask([send_stream, streams, is_svc, content_type,
                              min_transmit_bitrate_bps]() mutable {
       if (send_stream) {
         send_stream->OnEncoderConfigurationChanged(
-            std::move(streams), content_type, min_transmit_bitrate_bps);
+            std::move(streams), is_svc, content_type, min_transmit_bitrate_bps);
       }
     });
     return;
   }
+
   RTC_DCHECK_GE(config_->rtp.ssrcs.size(), streams.size());
   TRACE_EVENT0("webrtc", "VideoSendStream::OnEncoderConfigurationChanged");
-  RTC_DCHECK_GE(config_->rtp.ssrcs.size(), streams.size());
   RTC_DCHECK_RUN_ON(worker_queue_);
 
   const VideoCodecType codec_type =
@@ -516,14 +527,9 @@
                encoder_max_bitrate_bps_);
 
   // TODO(bugs.webrtc.org/10266): Query the VideoBitrateAllocator instead.
-  if (codec_type == kVideoCodecVP9) {
-    max_padding_bitrate_ = has_alr_probing_ ? streams[0].min_bitrate_bps
-                                            : streams[0].target_bitrate_bps;
-  } else {
-    max_padding_bitrate_ = CalculateMaxPadBitrateBps(
-        streams, content_type, min_transmit_bitrate_bps,
-        config_->suspend_below_min_bitrate, has_alr_probing_);
-  }
+  max_padding_bitrate_ = CalculateMaxPadBitrateBps(
+      streams, is_svc, content_type, min_transmit_bitrate_bps,
+      config_->suspend_below_min_bitrate, has_alr_probing_);
 
   // Clear stats for disabled layers.
   for (size_t i = streams.size(); i < config_->rtp.ssrcs.size(); ++i) {
diff --git a/video/video_send_stream_impl.h b/video/video_send_stream_impl.h
index 4195efc..d3f87e3 100644
--- a/video/video_send_stream_impl.h
+++ b/video/video_send_stream_impl.h
@@ -116,6 +116,7 @@
 
   void OnEncoderConfigurationChanged(
       std::vector<VideoStream> streams,
+      bool is_svc,
       VideoEncoderConfig::ContentType content_type,
       int min_transmit_bitrate_bps) override;
 
diff --git a/video/video_send_stream_impl_unittest.cc b/video/video_send_stream_impl_unittest.cc
index 2b5a90a..24519b1 100644
--- a/video/video_send_stream_impl_unittest.cc
+++ b/video/video_send_stream_impl_unittest.cc
@@ -241,7 +241,7 @@
 
         static_cast<VideoStreamEncoderInterface::EncoderSink*>(vss_impl.get())
             ->OnEncoderConfigurationChanged(
-                std::vector<VideoStream>{qvga_stream, vga_stream},
+                std::vector<VideoStream>{qvga_stream, vga_stream}, false,
                 VideoEncoderConfig::ContentType::kRealtimeVideo,
                 min_transmit_bitrate_bps);
         vss_impl->Stop();
@@ -309,7 +309,7 @@
 
         static_cast<VideoStreamEncoderInterface::EncoderSink*>(vss_impl.get())
             ->OnEncoderConfigurationChanged(
-                std::vector<VideoStream>{low_stream, high_stream},
+                std::vector<VideoStream>{low_stream, high_stream}, false,
                 VideoEncoderConfig::ContentType::kScreen,
                 min_transmit_bitrate_bps);
         vss_impl->Stop();
@@ -371,7 +371,7 @@
 
         static_cast<VideoStreamEncoderInterface::EncoderSink*>(vss_impl.get())
             ->OnEncoderConfigurationChanged(
-                std::vector<VideoStream>{low_stream, high_stream},
+                std::vector<VideoStream>{low_stream, high_stream}, false,
                 VideoEncoderConfig::ContentType::kRealtimeVideo,
                 /*min_transmit_bitrate_bps=*/0);
         vss_impl->Stop();
@@ -690,7 +690,7 @@
 
         static_cast<VideoStreamEncoderInterface::EncoderSink*>(vss_impl.get())
             ->OnEncoderConfigurationChanged(
-                std::vector<VideoStream>{qvga_stream},
+                std::vector<VideoStream>{qvga_stream}, false,
                 VideoEncoderConfig::ContentType::kRealtimeVideo,
                 min_transmit_bitrate_bps);
 
@@ -816,7 +816,7 @@
         // Reconfigure e.g. due to a fake frame.
         static_cast<VideoStreamEncoderInterface::EncoderSink*>(vss_impl.get())
             ->OnEncoderConfigurationChanged(
-                std::vector<VideoStream>{qvga_stream},
+                std::vector<VideoStream>{qvga_stream}, false,
                 VideoEncoderConfig::ContentType::kRealtimeVideo,
                 min_transmit_bitrate_bps);
         // Still no padding because no actual frames were passed, only
@@ -893,5 +893,112 @@
   ASSERT_TRUE(done.Wait(5000));
 }
 
+TEST_F(VideoSendStreamImplTest, ConfiguresBitratesForSvcWithAlr) {
+  test_queue_.SendTask(
+      [this] {
+        const bool kSuspend = false;
+        config_.suspend_below_min_bitrate = kSuspend;
+        config_.rtp.extensions.emplace_back(
+            RtpExtension::kTransportSequenceNumberUri, 1);
+        config_.periodic_alr_bandwidth_probing = true;
+        auto vss_impl = CreateVideoSendStreamImpl(
+            kDefaultInitialBitrateBps, kDefaultBitratePriority,
+            VideoEncoderConfig::ContentType::kScreen);
+        vss_impl->Start();
+
+        // Svc
+        VideoStream stream;
+        stream.width = 1920;
+        stream.height = 1080;
+        stream.max_framerate = 30;
+        stream.min_bitrate_bps = 60000;
+        stream.target_bitrate_bps = 6000000;
+        stream.max_bitrate_bps = 1250000;
+        stream.num_temporal_layers = 2;
+        stream.max_qp = 56;
+        stream.bitrate_priority = 1;
+
+        int min_transmit_bitrate_bps = 400000;
+
+        config_.rtp.ssrcs.emplace_back(1);
+        config_.rtp.ssrcs.emplace_back(2);
+
+        EXPECT_CALL(bitrate_allocator_, AddObserver(vss_impl.get(), _))
+            .WillRepeatedly(Invoke([&](BitrateAllocatorObserver*,
+                                       MediaStreamAllocationConfig config) {
+              EXPECT_EQ(config.min_bitrate_bps,
+                        static_cast<uint32_t>(stream.min_bitrate_bps));
+              EXPECT_EQ(config.max_bitrate_bps,
+                        static_cast<uint32_t>(stream.max_bitrate_bps));
+              if (config.pad_up_bitrate_bps != 0) {
+                EXPECT_EQ(config.pad_up_bitrate_bps,
+                          static_cast<uint32_t>(min_transmit_bitrate_bps));
+              }
+              EXPECT_EQ(config.enforce_min_bitrate, !kSuspend);
+            }));
+
+        static_cast<VideoStreamEncoderInterface::EncoderSink*>(vss_impl.get())
+            ->OnEncoderConfigurationChanged(
+                std::vector<VideoStream>{stream}, true,
+                VideoEncoderConfig::ContentType::kScreen,
+                min_transmit_bitrate_bps);
+        vss_impl->Stop();
+      },
+      RTC_FROM_HERE);
+}
+
+TEST_F(VideoSendStreamImplTest, ConfiguresBitratesForSvcNoAlr) {
+  test_queue_.SendTask(
+      [this] {
+        const bool kSuspend = false;
+        config_.suspend_below_min_bitrate = kSuspend;
+        config_.rtp.extensions.emplace_back(
+            RtpExtension::kTransportSequenceNumberUri, 1);
+        config_.periodic_alr_bandwidth_probing = false;
+        auto vss_impl = CreateVideoSendStreamImpl(
+            kDefaultInitialBitrateBps, kDefaultBitratePriority,
+            VideoEncoderConfig::ContentType::kScreen);
+        vss_impl->Start();
+
+        // Svc
+        VideoStream stream;
+        stream.width = 1920;
+        stream.height = 1080;
+        stream.max_framerate = 30;
+        stream.min_bitrate_bps = 60000;
+        stream.target_bitrate_bps = 6000000;
+        stream.max_bitrate_bps = 1250000;
+        stream.num_temporal_layers = 2;
+        stream.max_qp = 56;
+        stream.bitrate_priority = 1;
+
+        int min_transmit_bitrate_bps = 400000;
+
+        config_.rtp.ssrcs.emplace_back(1);
+        config_.rtp.ssrcs.emplace_back(2);
+
+        EXPECT_CALL(bitrate_allocator_, AddObserver(vss_impl.get(), _))
+            .WillRepeatedly(Invoke([&](BitrateAllocatorObserver*,
+                                       MediaStreamAllocationConfig config) {
+              EXPECT_EQ(config.min_bitrate_bps,
+                        static_cast<uint32_t>(stream.min_bitrate_bps));
+              EXPECT_EQ(config.max_bitrate_bps,
+                        static_cast<uint32_t>(stream.max_bitrate_bps));
+              if (config.pad_up_bitrate_bps != 0) {
+                EXPECT_EQ(config.pad_up_bitrate_bps,
+                          static_cast<uint32_t>(stream.target_bitrate_bps));
+              }
+              EXPECT_EQ(config.enforce_min_bitrate, !kSuspend);
+            }));
+
+        static_cast<VideoStreamEncoderInterface::EncoderSink*>(vss_impl.get())
+            ->OnEncoderConfigurationChanged(
+                std::vector<VideoStream>{stream}, true,
+                VideoEncoderConfig::ContentType::kScreen,
+                min_transmit_bitrate_bps);
+        vss_impl->Stop();
+      },
+      RTC_FROM_HERE);
+}
 }  // namespace internal
 }  // namespace webrtc
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index 8252cb2..4ad9a52 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -516,18 +516,6 @@
     RTC_LOG(LS_ERROR) << "Failed to create encoder configuration.";
   }
 
-  // Set min_bitrate_bps, max_bitrate_bps, and max padding bit rate for VP9.
-  if (encoder_config_.codec_type == kVideoCodecVP9) {
-    // Lower max bitrate to the level codec actually can produce.
-    streams[0].max_bitrate_bps =
-        std::min(streams[0].max_bitrate_bps,
-                 SvcRateAllocator::GetMaxBitrate(codec).bps<int>());
-    streams[0].min_bitrate_bps = codec.spatialLayers[0].minBitrate * 1000;
-    // target_bitrate_bps specifies the maximum padding bitrate.
-    streams[0].target_bitrate_bps =
-        SvcRateAllocator::GetPaddingBitrate(codec).bps<int>();
-  }
-
   char log_stream_buf[4 * 1024];
   rtc::SimpleStringBuilder log_stream(log_stream_buf);
   log_stream << "ReconfigureEncoder:\n";
@@ -717,8 +705,26 @@
 
   pending_encoder_reconfiguration_ = false;
 
+  bool is_svc = false;
+  // Set min_bitrate_bps, max_bitrate_bps, and max padding bit rate for VP9
+  // and leave only one stream containing all necessary information.
+  if (encoder_config_.codec_type == kVideoCodecVP9) {
+    // Lower max bitrate to the level codec actually can produce.
+    streams[0].max_bitrate_bps =
+        std::min(streams[0].max_bitrate_bps,
+                 SvcRateAllocator::GetMaxBitrate(codec).bps<int>());
+    streams[0].min_bitrate_bps = codec.spatialLayers[0].minBitrate * 1000;
+    // target_bitrate_bps specifies the maximum padding bitrate.
+    streams[0].target_bitrate_bps =
+        SvcRateAllocator::GetPaddingBitrate(codec).bps<int>();
+    streams[0].width = streams.back().width;
+    streams[0].height = streams.back().height;
+    is_svc = codec.VP9()->numberOfSpatialLayers > 1;
+    streams.resize(1);
+  }
+
   sink_->OnEncoderConfigurationChanged(
-      std::move(streams), encoder_config_.content_type,
+      std::move(streams), is_svc, encoder_config_.content_type,
       encoder_config_.min_transmit_bitrate_bps);
 
   resource_adaptation_processor_->ConfigureQualityScaler(info);
diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc
index 934bf09..bb85776 100644
--- a/video/video_stream_encoder_unittest.cc
+++ b/video/video_stream_encoder_unittest.cc
@@ -1141,6 +1141,7 @@
 
     void OnEncoderConfigurationChanged(
         std::vector<VideoStream> streams,
+        bool is_svc,
         VideoEncoderConfig::ContentType content_type,
         int min_transmit_bitrate_bps) override {
       rtc::CritScope lock(&crit_);