Wiring the RTCRtpEncodingParameters.priority down to the bitrate allocator.

I followed the wiring path for the max bitrate.
Doc:
https://docs.google.com/a/google.com/document/d/1sGT6y00prOIErFuGD44zWZacDpR6Rkjg_HXA_Z3Vw4Q/edit?usp=sharing

Bug: webrtc:8630
Change-Id: I6b861816670442656721c20f81d035ee5eb6218c
Reviewed-on: https://webrtc-review.googlesource.com/30380
Commit-Queue: Seth Hampson <shampson@webrtc.org>
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Reviewed-by: Fredrik Solenberg <solenberg@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Reviewed-by: Elad Alon <eladalon@webrtc.org>
Reviewed-by: Peter Thatcher <pthatcher@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#21397}

api/rtpparameters.h

@@ -73,7 +73,6 @@ enum class DegradationPreference {
 };
 
 extern const double kDefaultBitratePriority;
-enum class PriorityType { VERY_LOW, LOW, MEDIUM, HIGH };
 
 struct RtcpFeedback {
   RtcpFeedbackType type = RtcpFeedbackType::CCM;
@@ -362,9 +361,10 @@ struct RtpEncodingParameters {
   // codec as long as it's present.
   rtc::Optional<DtxStatus> dtx;
 
-  // The relative priority of this encoding.
+  // The relative bitrate priority of this encoding. Currently this is
-  // TODO(deadbeef): Not implemented.
+  // implemented on the sender level (using the first RtpEncodingParameters
-  rtc::Optional<PriorityType> priority;
+  // of the rtp parameters).
+  double bitrate_priority = kDefaultBitratePriority;
 
   // If set, this represents the Transport Independent Application Specific
   // maximum bandwidth defined in RFC3890. If unset, there is no maximum
@@ -408,7 +408,8 @@ struct RtpEncodingParameters {
   bool operator==(const RtpEncodingParameters& o) const {
     return ssrc == o.ssrc && codec_payload_type == o.codec_payload_type &&
            fec == o.fec && rtx == o.rtx && dtx == o.dtx &&
-           priority == o.priority && max_bitrate_bps == o.max_bitrate_bps &&
+           bitrate_priority == o.bitrate_priority &&
+           max_bitrate_bps == o.max_bitrate_bps &&
            max_framerate == o.max_framerate &&
            scale_resolution_down_by == o.scale_resolution_down_by &&
            scale_framerate_down_by == o.scale_framerate_down_by &&

audio/audio_send_stream.cc

@@ -243,7 +243,8 @@ void AudioSendStream::Start() {
        !webrtc::field_trial::IsEnabled("WebRTC-Audio-SendSideBwe"))) {
     // Audio BWE is enabled.
     transport_->packet_sender()->SetAccountForAudioPackets(true);
-    ConfigureBitrateObserver(config_.min_bitrate_bps, config_.max_bitrate_bps);
+    ConfigureBitrateObserver(config_.min_bitrate_bps, config_.max_bitrate_bps,
+                             config_.bitrate_priority);
   }
   channel_proxy_->StartSend();
   sending_ = true;
@@ -631,6 +632,7 @@ void AudioSendStream::ReconfigureBitrateObserver(
       FindExtensionIds(new_config.rtp.extensions).transport_sequence_number;
   if (stream->config_.min_bitrate_bps == new_config.min_bitrate_bps &&
       stream->config_.max_bitrate_bps == new_config.max_bitrate_bps &&
+      stream->config_.bitrate_priority == new_config.bitrate_priority &&
       (FindExtensionIds(stream->config_.rtp.extensions)
                .transport_sequence_number == new_transport_seq_num_id ||
        !webrtc::field_trial::IsEnabled("WebRTC-Audio-SendSideBwe"))) {
@@ -641,14 +643,16 @@ void AudioSendStream::ReconfigureBitrateObserver(
       (new_transport_seq_num_id != 0 ||
        !webrtc::field_trial::IsEnabled("WebRTC-Audio-SendSideBwe"))) {
     stream->ConfigureBitrateObserver(new_config.min_bitrate_bps,
-                                     new_config.max_bitrate_bps);
+                                     new_config.max_bitrate_bps,
+                                     new_config.bitrate_priority);
   } else {
     stream->RemoveBitrateObserver();
   }
 }
 
 void AudioSendStream::ConfigureBitrateObserver(int min_bitrate_bps,
-                                               int max_bitrate_bps) {
+                                               int max_bitrate_bps,
+                                               double bitrate_priority) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   RTC_DCHECK_GE(max_bitrate_bps, min_bitrate_bps);
   rtc::Event thread_sync_event(false /* manual_reset */, false);
@@ -657,8 +661,10 @@ void AudioSendStream::ConfigureBitrateObserver(int min_bitrate_bps,
     // sure the bitrate limits in config_ are up-to-date.
     config_.min_bitrate_bps = min_bitrate_bps;
     config_.max_bitrate_bps = max_bitrate_bps;
+    config_.bitrate_priority = bitrate_priority;
+    // This either updates the current observer or adds a new observer.
     bitrate_allocator_->AddObserver(this, min_bitrate_bps, max_bitrate_bps, 0,
-                                    true, config_.track_id);
+                                    true, config_.track_id, bitrate_priority);
     thread_sync_event.Set();
   });
   thread_sync_event.Wait(rtc::Event::kForever);

audio/audio_send_stream.h

@@ -106,7 +106,9 @@ class AudioSendStream final : public webrtc::AudioSendStream,
   static void ReconfigureBitrateObserver(AudioSendStream* stream,
                                          const Config& new_config);
 
-  void ConfigureBitrateObserver(int min_bitrate_bps, int max_bitrate_bps);
+  void ConfigureBitrateObserver(int min_bitrate_bps,
+                                int max_bitrate_bps,
+                                double bitrate_priority);
   void RemoveBitrateObserver();
 
   void RegisterCngPayloadType(int payload_type, int clockrate_hz);

call/audio_send_stream.h

@@ -104,6 +104,8 @@ class AudioSendStream {
     int min_bitrate_bps = -1;
     int max_bitrate_bps = -1;
 
+    double bitrate_priority = 1.0;
+
     // Defines whether to turn on audio network adaptor, and defines its config
     // string.
     rtc::Optional<std::string> audio_network_adaptor_config;

call/bitrate_allocator.h

@@ -87,10 +87,7 @@ class BitrateAllocator {
                    uint32_t pad_up_bitrate_bps,
                    bool enforce_min_bitrate,
                    std::string track_id,
-                   // TODO(shampson): Take out default value and wire the
+                   double bitrate_priority);
-                   // bitrate_priority up to the AudioSendStream::Config and
-                   // VideoSendStream::Config.
-                   double bitrate_priority = 1.0);
 
   // Removes a previously added observer, but will not trigger a new bitrate
   // allocation.

call/bitrate_allocator_unittest.cc

@@ -61,6 +61,7 @@ class TestBitrateObserver : public BitrateAllocatorObserver {
 
 namespace {
 constexpr int64_t kDefaultProbingIntervalMs = 3000;
+const double kDefaultBitratePriority = 1.0;
 }
 
 class BitrateAllocatorTest : public ::testing::Test {
@@ -82,7 +83,8 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {
   EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(kMinSendBitrateBps,
                                                          kPadUpToBitrateBps));
   allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000,
-                          kPadUpToBitrateBps, true, "");
+                          kPadUpToBitrateBps, true, "",
+                          kDefaultBitratePriority);
   EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
   allocator_->OnNetworkChanged(200000, 0, 0, kDefaultProbingIntervalMs);
   EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer));
@@ -96,11 +98,11 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {
   EXPECT_CALL(limit_observer_,
               OnAllocationLimitsChanged(kMinSendBitrateBps, 0));
   allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 4000000, 0,
-                          true, "");
+                          true, "", kDefaultBitratePriority);
   EXPECT_EQ(4000000, allocator_->GetStartBitrate(&bitrate_observer));
 
   allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000, 0,
-                          true, "");
+                          true, "", kDefaultBitratePriority);
   EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer));
   EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_);
   allocator_->OnNetworkChanged(1500000, 0, 0, kDefaultProbingIntervalMs);
@@ -111,11 +113,13 @@ TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) {
   TestBitrateObserver bitrate_observer_1;
   TestBitrateObserver bitrate_observer_2;
   EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(100000, 0));
-  allocator_->AddObserver(&bitrate_observer_1, 100000, 300000, 0, true, "");
+  allocator_->AddObserver(&bitrate_observer_1, 100000, 300000, 0, true, "",
+                          kDefaultBitratePriority);
   EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
   EXPECT_CALL(limit_observer_,
               OnAllocationLimitsChanged(100000 + 200000, 0));
-  allocator_->AddObserver(&bitrate_observer_2, 200000, 300000, 0, true, "");
+  allocator_->AddObserver(&bitrate_observer_2, 200000, 300000, 0, true, "",
+                          kDefaultBitratePriority);
   EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
 
   // Test too low start bitrate, hence lower than sum of min. Min bitrates
@@ -159,7 +163,8 @@ TEST_F(BitrateAllocatorTest, RemoveObserverTriggersLimitObserver) {
   EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(kMinSendBitrateBps,
                                                          kPadUpToBitrateBps));
   allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000,
-                          kPadUpToBitrateBps, true, "");
+                          kPadUpToBitrateBps, true, "",
+                          kDefaultBitratePriority);
   EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0));
   allocator_->RemoveObserver(&bitrate_observer);
 }
@@ -183,7 +188,8 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) {
   // Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since
   // AddObserver is called with |enforce_min_bitrate| = false.
   EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 120000));
-  allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "");
+  allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "",
+                          kDefaultBitratePriority);
   EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
 
   // High BWE.
@@ -203,14 +209,17 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) {
   TestBitrateObserver bitrate_observer_2;
   TestBitrateObserver bitrate_observer_3;
   // Set up the observers with min bitrates at 100000, 200000, and 300000.
-  allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "");
+  allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "",
+                          kDefaultBitratePriority);
   EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
 
-  allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, "");
+  allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, "",
+                          kDefaultBitratePriority);
   EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
   EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
 
-  allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, 0, false, "");
+  allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, 0, false, "",
+                          kDefaultBitratePriority);
   EXPECT_EQ(0, allocator_->GetStartBitrate(&bitrate_observer_3));
   EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
   EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_);
@@ -264,7 +273,8 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) {
   // Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since
   // AddObserver is called with |enforce_min_bitrate| = false.
   EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 168000));
-  allocator_->AddObserver(&bitrate_observer, 100000, 400000, 0, false, "");
+  allocator_->AddObserver(&bitrate_observer, 100000, 400000, 0, false, "",
+                          kDefaultBitratePriority);
   EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
 
   // High BWE.
@@ -310,9 +320,11 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, TwoBitrateObserverWithPacketLoss) {
   TestBitrateObserver bitrate_observer_1;
   TestBitrateObserver bitrate_observer_2;
 
-  allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "");
+  allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "",
+                          kDefaultBitratePriority);
   EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
-  allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, "");
+  allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, "",
+                          kDefaultBitratePriority);
   EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
   EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
 
@@ -361,14 +373,17 @@ TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowBweEnforceMin) {
   TestBitrateObserver bitrate_observer_2;
   TestBitrateObserver bitrate_observer_3;
 
-  allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, true, "");
+  allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, true, "",
+                          kDefaultBitratePriority);
   EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
 
-  allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, true, "");
+  allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, true, "",
+                          kDefaultBitratePriority);
   EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
   EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
 
-  allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, 0, true, "");
+  allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, 0, true, "",
+                          kDefaultBitratePriority);
   EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_3));
   EXPECT_EQ(100000, static_cast<int>(bitrate_observer_1.last_bitrate_bps_));
   EXPECT_EQ(200000, static_cast<int>(bitrate_observer_2.last_bitrate_bps_));
@@ -389,7 +404,8 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
   TestBitrateObserver bitrate_observer_1;
   EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000, 0));
 
-  allocator_->AddObserver(&bitrate_observer_1, 50000, 400000, 0, true, "");
+  allocator_->AddObserver(&bitrate_observer_1, 50000, 400000, 0, true, "",
+                          kDefaultBitratePriority);
   EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
 
   // Set network down, ie, no available bitrate.
@@ -400,7 +416,8 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
   TestBitrateObserver bitrate_observer_2;
   // Adding an observer while the network is down should not affect the limits.
   EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000 + 50000, 0));
-  allocator_->AddObserver(&bitrate_observer_2, 50000, 400000, 0, true, "");
+  allocator_->AddObserver(&bitrate_observer_2, 50000, 400000, 0, true, "",
+                          kDefaultBitratePriority);
 
   // Expect the start_bitrate to be set as if the network was still up but that
   // the new observer have been notified that the network is down.
@@ -416,11 +433,13 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
 
 TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) {
   TestBitrateObserver enforced_observer;
-  allocator_->AddObserver(&enforced_observer, 6000, 30000, 0, true, "");
+  allocator_->AddObserver(&enforced_observer, 6000, 30000, 0, true, "",
+                          kDefaultBitratePriority);
   EXPECT_EQ(60000, allocator_->GetStartBitrate(&enforced_observer));
 
   TestBitrateObserver not_enforced_observer;
-  allocator_->AddObserver(&not_enforced_observer, 30000, 2500000, 0, false, "");
+  allocator_->AddObserver(&not_enforced_observer, 30000, 2500000, 0, false, "",
+                          kDefaultBitratePriority);
   EXPECT_EQ(270000, allocator_->GetStartBitrate(&not_enforced_observer));
   EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
 
@@ -458,7 +477,8 @@ TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) {
 
 TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) {
   TestBitrateObserver observer;
-  allocator_->AddObserver(&observer, 30000, 300000, 0, false, "");
+  allocator_->AddObserver(&observer, 30000, 300000, 0, false, "",
+                          kDefaultBitratePriority);
   EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
 
   allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs);
@@ -484,7 +504,8 @@ TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) {
 
 TEST_F(BitrateAllocatorTest, AvoidTogglePercent) {
   TestBitrateObserver observer;
-  allocator_->AddObserver(&observer, 300000, 600000, 0, false, "");
+  allocator_->AddObserver(&observer, 300000, 600000, 0, false, "",
+                          kDefaultBitratePriority);
   EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
 
   allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs);
@@ -510,7 +531,8 @@ TEST_F(BitrateAllocatorTest, AvoidTogglePercent) {
 
 TEST_F(BitrateAllocatorTest, PassProbingInterval) {
   TestBitrateObserver observer;
-  allocator_->AddObserver(&observer, 300000, 600000, 0, false, "");
+  allocator_->AddObserver(&observer, 300000, 600000, 0, false, "",
+                          kDefaultBitratePriority);
   EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
 
   allocator_->OnNetworkChanged(300000, 0, 50, 5000);

media/BUILD.gn

@@ -525,6 +525,7 @@ if (rtc_include_tests) {
       ":rtc_media",
       ":rtc_media_base",
       ":rtc_media_tests_utils",
+      "../api:libjingle_peerconnection_api",
       "../api:mock_video_codec_factory",
       "../api:video_frame_api",
       "../api/audio_codecs:builtin_audio_decoder_factory",

media/engine/simulcast.cc

@@ -173,6 +173,7 @@ std::vector<webrtc::VideoStream> GetSimulcastConfig(size_t max_streams,
                                                     int width,
                                                     int height,
                                                     int max_bitrate_bps,
+                                                    double bitrate_priority,
                                                     int max_qp,
                                                     int max_framerate,
                                                     bool is_screencast) {
@@ -276,6 +277,9 @@ std::vector<webrtc::VideoStream> GetSimulcastConfig(size_t max_streams,
     }
   }
 
+  // The bitrate priority currently implemented on a per-sender level, so we
+  // just set it for the first video stream.
+  streams[0].bitrate_priority = bitrate_priority;
   return streams;
 }
 

media/engine/simulcast.h

@@ -52,6 +52,7 @@ std::vector<webrtc::VideoStream> GetSimulcastConfig(size_t max_streams,
                                                     int width,
                                                     int height,
                                                     int max_bitrate_bps,
+                                                    double bitrate_priority,
                                                     int max_qp,
                                                     int max_framerate,
                                                     bool is_screencast = false);

media/engine/webrtcvideoengine.cc

@@ -1787,8 +1787,10 @@ bool WebRtcVideoChannel::WebRtcVideoSendStream::SetRtpParameters(
     return false;
   }
 
-  bool reconfigure_encoder = new_parameters.encodings[0].max_bitrate_bps !=
+  bool reconfigure_encoder = (new_parameters.encodings[0].max_bitrate_bps !=
-                             rtp_parameters_.encodings[0].max_bitrate_bps;
+                              rtp_parameters_.encodings[0].max_bitrate_bps) ||
+                             (new_parameters.encodings[0].bitrate_priority !=
+                              rtp_parameters_.encodings[0].bitrate_priority);
   rtp_parameters_ = new_parameters;
   // Codecs are currently handled at the WebRtcVideoChannel level.
   rtp_parameters_.codecs.clear();
@@ -1818,6 +1820,11 @@ bool WebRtcVideoChannel::WebRtcVideoSendStream::ValidateRtpParameters(
     RTC_LOG(LS_ERROR) << "Attempted to set RtpParameters with modified SSRC";
     return false;
   }
+  if (rtp_parameters.encodings[0].bitrate_priority <= 0) {
+    RTC_LOG(LS_ERROR) << "Attempted to set RtpParameters bitrate_priority to "
+                         "an invalid number. bitrate_priority must be > 0.";
+    return false;
+  }
   return true;
 }
 
@@ -1876,6 +1883,13 @@ WebRtcVideoChannel::WebRtcVideoSendStream::CreateVideoEncoderConfig(
   }
   encoder_config.max_bitrate_bps = stream_max_bitrate;
 
+  // The encoder config's default bitrate priority is set to 1.0,
+  // unless it is set through the sender's encoding parameters.
+  // The bitrate priority, which is used in the bitrate allocation, is done
+  // on a per sender basis, so we use the first encoding's value.
+  encoder_config.bitrate_priority =
+      rtp_parameters_.encodings[0].bitrate_priority;
+
   int max_qp = kDefaultQpMax;
   codec.GetParam(kCodecParamMaxQuantization, &max_qp);
   encoder_config.video_stream_factory =
@@ -2580,7 +2594,8 @@ std::vector<webrtc::VideoStream> EncoderStreamFactory::CreateEncoderStreams(
       (CodecNamesEq(codec_name_, kVp8CodecName) && is_screencast_ &&
        conference_mode_)) {
     return GetSimulcastConfig(encoder_config.number_of_streams, width, height,
-                              encoder_config.max_bitrate_bps, max_qp_,
+                              encoder_config.max_bitrate_bps,
+                              encoder_config.bitrate_priority, max_qp_,
                               max_framerate_, is_screencast_);
   }
 
@@ -2597,6 +2612,7 @@ std::vector<webrtc::VideoStream> EncoderStreamFactory::CreateEncoderStreams(
   stream.min_bitrate_bps = GetMinVideoBitrateBps();
   stream.target_bitrate_bps = stream.max_bitrate_bps = max_bitrate_bps;
   stream.max_qp = max_qp_;
+  stream.bitrate_priority = encoder_config.bitrate_priority;
 
   if (CodecNamesEq(codec_name_, kVp9CodecName) && !is_screencast_) {
     stream.temporal_layer_thresholds_bps.resize(GetDefaultVp9TemporalLayers() -

media/engine/webrtcvideoengine_unittest.cc

@@ -14,6 +14,7 @@
 #include <utility>
 #include <vector>
 
+#include "api/rtpparameters.h"
 #include "api/test/mock_video_decoder_factory.h"
 #include "api/test/mock_video_encoder_factory.h"
 #include "api/video_codecs/sdp_video_format.h"
@@ -4359,6 +4360,122 @@ TEST_F(WebRtcVideoChannelTest, CannotSetSsrcInRtpSendParameters) {
   EXPECT_FALSE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
 }
 
+// Tests that when RTCRtpEncodingParameters.bitrate_priority gets set to
+// a value <= 0, setting the parameters returns false.
+TEST_F(WebRtcVideoChannelTest, SetRtpSendParametersInvalidBitratePriority) {
+  AddSendStream();
+  webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
+  EXPECT_EQ(1UL, parameters.encodings.size());
+  EXPECT_EQ(webrtc::kDefaultBitratePriority,
+            parameters.encodings[0].bitrate_priority);
+
+  parameters.encodings[0].bitrate_priority = 0;
+  EXPECT_FALSE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
+  parameters.encodings[0].bitrate_priority = -2;
+  EXPECT_FALSE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
+}
+
+// Tests when the the RTCRtpEncodingParameters.bitrate_priority gets set
+// properly on the VideoChannel and propogates down to the video encoder.
+TEST_F(WebRtcVideoChannelTest, SetRtpSendParametersPriorityOneStream) {
+  AddSendStream();
+  webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
+  EXPECT_EQ(1UL, parameters.encodings.size());
+  EXPECT_EQ(webrtc::kDefaultBitratePriority,
+            parameters.encodings[0].bitrate_priority);
+
+  // Change the value and set it on the VideoChannel.
+  double new_bitrate_priority = 2.0;
+  parameters.encodings[0].bitrate_priority = new_bitrate_priority;
+  EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
+
+  // Verify that the encoding parameters bitrate_priority is set for the
+  // VideoChannel.
+  parameters = channel_->GetRtpSendParameters(last_ssrc_);
+  EXPECT_EQ(1UL, parameters.encodings.size());
+  EXPECT_EQ(new_bitrate_priority, parameters.encodings[0].bitrate_priority);
+
+  // Verify that the new value propagated down to the encoder.
+  std::vector<FakeVideoSendStream*> video_send_streams =
+      fake_call_->GetVideoSendStreams();
+  EXPECT_EQ(1UL, video_send_streams.size());
+  FakeVideoSendStream* video_send_stream = video_send_streams.front();
+  // Check that the WebRtcVideoSendStream updated the VideoEncoderConfig
+  // appropriately.
+  EXPECT_EQ(new_bitrate_priority,
+            video_send_stream->GetEncoderConfig().bitrate_priority);
+  // Check that the vector of VideoStreams also was propagated correctly. Note
+  // that this is testing the behavior of the FakeVideoSendStream, which mimics
+  // the calls to CreateEncoderStreams to get the VideoStreams.
+  EXPECT_EQ(rtc::Optional<double>(new_bitrate_priority),
+            video_send_stream->GetVideoStreams()[0].bitrate_priority);
+}
+
+// Tests that the RTCRtpEncodingParameters.bitrate_priority is set for the
+// VideoChannel and the value propogates to the video encoder with all simulcast
+// streams.
+TEST_F(WebRtcVideoChannelTest, SetRtpSendParametersPrioritySimulcastStreams) {
+  // Create the stream params with multiple ssrcs for simulcast.
+  const int kNumSimulcastStreams = 3;
+  std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
+  StreamParams stream_params = CreateSimStreamParams("cname", ssrcs);
+  AddSendStream(stream_params);
+  uint32_t primary_ssrc = stream_params.first_ssrc();
+
+  // Using the FakeVideoCapturer, we manually send a full size frame. This
+  // creates multiple VideoStreams for all simulcast layers when reconfiguring,
+  // and allows us to test this behavior.
+  cricket::FakeVideoCapturer capturer;
+  VideoOptions options;
+  EXPECT_TRUE(channel_->SetVideoSend(primary_ssrc, true, &options, &capturer));
+  EXPECT_EQ(cricket::CS_RUNNING,
+            capturer.Start(cricket::VideoFormat(
+                1920, 1080, cricket::VideoFormat::FpsToInterval(30),
+                cricket::FOURCC_I420)));
+  channel_->SetSend(true);
+  EXPECT_TRUE(capturer.CaptureFrame());
+  // Get and set the rtp encoding parameters.
+  webrtc::RtpParameters parameters =
+      channel_->GetRtpSendParameters(primary_ssrc);
+  EXPECT_EQ(1UL, parameters.encodings.size());
+  EXPECT_EQ(webrtc::kDefaultBitratePriority,
+            parameters.encodings[0].bitrate_priority);
+  // Change the value and set it on the VideoChannel.
+  double new_bitrate_priority = 2.0;
+  parameters.encodings[0].bitrate_priority = new_bitrate_priority;
+  EXPECT_TRUE(channel_->SetRtpSendParameters(primary_ssrc, parameters));
+
+  // Verify that the encoding parameters priority is set on the VideoChannel.
+  parameters = channel_->GetRtpSendParameters(primary_ssrc);
+  EXPECT_EQ(1UL, parameters.encodings.size());
+  EXPECT_EQ(new_bitrate_priority, parameters.encodings[0].bitrate_priority);
+
+  // Verify that the new value propagated down to the encoder.
+  std::vector<FakeVideoSendStream*> video_send_streams =
+      fake_call_->GetVideoSendStreams();
+  EXPECT_EQ(1UL, video_send_streams.size());
+  FakeVideoSendStream* video_send_stream = video_send_streams.front();
+  // Check that the WebRtcVideoSendStream updated the VideoEncoderConfig
+  // appropriately.
+  EXPECT_EQ(kNumSimulcastStreams,
+            video_send_stream->GetEncoderConfig().number_of_streams);
+  EXPECT_EQ(new_bitrate_priority,
+            video_send_stream->GetEncoderConfig().bitrate_priority);
+  // Check that the vector of VideoStreams also propagated correctly. The
+  // FakeVideoSendStream calls CreateEncoderStreams, and we are testing that
+  // these are created appropriately for the simulcast case.
+  EXPECT_EQ(kNumSimulcastStreams, video_send_stream->GetVideoStreams().size());
+  EXPECT_EQ(rtc::Optional<double>(new_bitrate_priority),
+            video_send_stream->GetVideoStreams()[0].bitrate_priority);
+  // Since we are only setting bitrate priority per-sender, the other
+  // VideoStreams should have a bitrate priority of 0.
+  EXPECT_EQ(rtc::nullopt,
+            video_send_stream->GetVideoStreams()[1].bitrate_priority);
+  EXPECT_EQ(rtc::nullopt,
+            video_send_stream->GetVideoStreams()[2].bitrate_priority);
+  EXPECT_TRUE(channel_->SetVideoSend(primary_ssrc, true, nullptr, nullptr));
+}
+
 // Test that a stream will not be sending if its encoding is made inactive
 // through SetRtpSendParameters.
 // TODO(deadbeef): Update this test when we start supporting setting parameters
@@ -4708,7 +4825,8 @@ class WebRtcVideoChannelSimulcastTest : public testing::Test {
     if (conference_mode) {
       expected_streams = GetSimulcastConfig(
           num_configured_streams, capture_width, capture_height, 0,
-          kDefaultQpMax, kDefaultVideoMaxFramerate, screenshare);
+          webrtc::kDefaultBitratePriority, kDefaultQpMax,
+          kDefaultVideoMaxFramerate, screenshare);
       if (screenshare) {
         for (const webrtc::VideoStream& stream : expected_streams) {
           // Never scale screen content.

media/engine/webrtcvoiceengine.cc

@@ -980,6 +980,11 @@ class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
       RTC_LOG(LS_ERROR) << "Attempted to set RtpParameters with modified SSRC";
       return false;
     }
+    if (rtp_parameters.encodings[0].bitrate_priority <= 0) {
+      RTC_LOG(LS_ERROR) << "Attempted to set RtpParameters bitrate_priority to "
+                           "an invalid number.";
+      return false;
+    }
     return true;
   }
 
@@ -1000,20 +1005,25 @@ class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
 
     const rtc::Optional<int> old_rtp_max_bitrate =
         rtp_parameters_.encodings[0].max_bitrate_bps;
-
+    double old_priority = rtp_parameters_.encodings[0].bitrate_priority;
     rtp_parameters_ = parameters;
+    config_.bitrate_priority = rtp_parameters_.encodings[0].bitrate_priority;
 
+    bool reconfigure_send_stream =
+        (rtp_parameters_.encodings[0].max_bitrate_bps != old_rtp_max_bitrate) ||
+        (rtp_parameters_.encodings[0].bitrate_priority != old_priority);
     if (rtp_parameters_.encodings[0].max_bitrate_bps != old_rtp_max_bitrate) {
-      // Reconfigure AudioSendStream with new bit rate.
+      // Update the bitrate range.
       if (send_rate) {
         config_.send_codec_spec->target_bitrate_bps = send_rate;
       }
       UpdateAllowedBitrateRange();
+    }
+    if (reconfigure_send_stream) {
       ReconfigureAudioSendStream();
-    } else {
+    }
     // parameters.encodings[0].active could have changed.
     UpdateSendState();
-    }
     return true;
   }
 

media/engine/webrtcvoiceengine_unittest.cc

@@ -13,6 +13,7 @@
 
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
+#include "api/rtpparameters.h"
 #include "call/call.h"
 #include "logging/rtc_event_log/rtc_event_log.h"
 #include "media/base/fakemediaengine.h"
@@ -1085,7 +1086,9 @@ TEST_F(WebRtcVoiceEngineTestFake, SetRtpParametersEncodingsActive) {
   EXPECT_FALSE(GetSendStream(kSsrcX).IsSending());
 
   // Now change it back to active and verify we resume sending.
+  // This should occur even when other parameters are updated.
   parameters.encodings[0].active = true;
+  parameters.encodings[0].max_bitrate_bps = rtc::Optional<int>(6000);
   EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrcX, parameters));
   EXPECT_TRUE(GetSendStream(kSsrcX).IsSending());
 }
@@ -1181,6 +1184,42 @@ TEST_F(WebRtcVoiceEngineTestFake, SetRtpSendParameterUpdatesMaxBitrate) {
   EXPECT_EQ(max_bitrate, kMaxBitrateBps);
 }
 
+// Tests that when RTCRtpEncodingParameters.bitrate_priority gets set to
+// a value <= 0, setting the parameters returns false.
+TEST_F(WebRtcVoiceEngineTestFake, SetRtpSendParameterInvalidBitratePriority) {
+  EXPECT_TRUE(SetupSendStream());
+  webrtc::RtpParameters rtp_parameters = channel_->GetRtpSendParameters(kSsrcX);
+  EXPECT_EQ(1UL, rtp_parameters.encodings.size());
+  EXPECT_EQ(webrtc::kDefaultBitratePriority,
+            rtp_parameters.encodings[0].bitrate_priority);
+
+  rtp_parameters.encodings[0].bitrate_priority = 0;
+  EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrcX, rtp_parameters));
+  rtp_parameters.encodings[0].bitrate_priority = -1.0;
+  EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrcX, rtp_parameters));
+}
+
+// Test that the bitrate_priority in the send stream config gets updated when
+// SetRtpSendParameters is set for the VoiceMediaChannel.
+TEST_F(WebRtcVoiceEngineTestFake, SetRtpSendParameterUpdatesBitratePriority) {
+  EXPECT_TRUE(SetupSendStream());
+  webrtc::RtpParameters rtp_parameters = channel_->GetRtpSendParameters(kSsrcX);
+
+  EXPECT_EQ(1UL, rtp_parameters.encodings.size());
+  EXPECT_EQ(webrtc::kDefaultBitratePriority,
+            rtp_parameters.encodings[0].bitrate_priority);
+  double new_bitrate_priority = 2.0;
+  rtp_parameters.encodings[0].bitrate_priority = new_bitrate_priority;
+  EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrcX, rtp_parameters));
+
+  // The priority should get set for both the audio channel's rtp parameters
+  // and the audio send stream's audio config.
+  EXPECT_EQ(
+      new_bitrate_priority,
+      channel_->GetRtpSendParameters(kSsrcX).encodings[0].bitrate_priority);
+  EXPECT_EQ(new_bitrate_priority, GetSendStreamConfig(kSsrcX).bitrate_priority);
+}
+
 // Test that GetRtpReceiveParameters returns the currently configured codecs.
 TEST_F(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersCodecs) {
   EXPECT_TRUE(SetupRecvStream());

pc/rtpsenderreceiver_unittest.cc

@@ -12,6 +12,7 @@
 #include <string>
 #include <utility>
 
+#include "api/rtpparameters.h"
 #include "media/base/fakemediaengine.h"
 #include "media/base/rtpdataengine.h"
 #include "media/engine/fakewebrtccall.h"
@@ -600,6 +601,28 @@ TEST_F(RtpSenderReceiverTest, SetAudioMaxSendBitrate) {
   DestroyAudioRtpSender();
 }
 
+TEST_F(RtpSenderReceiverTest, SetAudioBitratePriority) {
+  CreateAudioRtpSender();
+
+  webrtc::RtpParameters params = audio_rtp_sender_->GetParameters();
+  EXPECT_EQ(1, params.encodings.size());
+  EXPECT_EQ(webrtc::kDefaultBitratePriority,
+            params.encodings[0].bitrate_priority);
+  double new_bitrate_priority = 2.0;
+  params.encodings[0].bitrate_priority = new_bitrate_priority;
+  EXPECT_TRUE(audio_rtp_sender_->SetParameters(params));
+
+  params = audio_rtp_sender_->GetParameters();
+  EXPECT_EQ(1, params.encodings.size());
+  EXPECT_EQ(new_bitrate_priority, params.encodings[0].bitrate_priority);
+
+  params = voice_media_channel_->GetRtpSendParameters(kAudioSsrc);
+  EXPECT_EQ(1, params.encodings.size());
+  EXPECT_EQ(new_bitrate_priority, params.encodings[0].bitrate_priority);
+
+  DestroyAudioRtpSender();
+}
+
 TEST_F(RtpSenderReceiverTest, VideoSenderCanSetParameters) {
   CreateVideoRtpSender();
 
@@ -636,6 +659,28 @@ TEST_F(RtpSenderReceiverTest, SetVideoMaxSendBitrate) {
   DestroyVideoRtpSender();
 }
 
+TEST_F(RtpSenderReceiverTest, SetVideoBitratePriority) {
+  CreateVideoRtpSender();
+
+  webrtc::RtpParameters params = video_rtp_sender_->GetParameters();
+  EXPECT_EQ(1, params.encodings.size());
+  EXPECT_EQ(webrtc::kDefaultBitratePriority,
+            params.encodings[0].bitrate_priority);
+  double new_bitrate_priority = 2.0;
+  params.encodings[0].bitrate_priority = new_bitrate_priority;
+  EXPECT_TRUE(video_rtp_sender_->SetParameters(params));
+
+  params = video_rtp_sender_->GetParameters();
+  EXPECT_EQ(1, params.encodings.size());
+  EXPECT_EQ(new_bitrate_priority, params.encodings[0].bitrate_priority);
+
+  params = video_media_channel_->GetRtpSendParameters(kVideoSsrc);
+  EXPECT_EQ(1, params.encodings.size());
+  EXPECT_EQ(new_bitrate_priority, params.encodings[0].bitrate_priority);
+
+  DestroyVideoRtpSender();
+}
+
 TEST_F(RtpSenderReceiverTest, AudioReceiverCanSetParameters) {
   CreateAudioRtpReceiver();
 

test/encoder_settings.cc

@@ -55,6 +55,7 @@ std::vector<VideoStream> CreateVideoStreams(
 
   stream_settings[encoder_config.number_of_streams - 1].max_bitrate_bps +=
       bitrate_left_bps;
+  stream_settings[0].bitrate_priority = encoder_config.bitrate_priority;
 
   return stream_settings;
 }

video/video_quality_test.cc

@@ -133,6 +133,8 @@ class VideoStreamFactory
     std::vector<webrtc::VideoStream> streams = streams_;
     streams[streams_.size() - 1].height = height;
     streams[streams_.size() - 1].width = width;
+
+    streams[0].bitrate_priority = encoder_config.bitrate_priority;
     return streams;
   }
 

video/video_send_stream.cc

@@ -257,6 +257,7 @@ class VideoSendStreamImpl : public webrtc::BitrateAllocatorObserver,
       RtcEventLog* event_log,
       const VideoSendStream::Config* config,
       int initial_encoder_max_bitrate,
+      double initial_encoder_bitrate_priority,
       std::map<uint32_t, RtpState> suspended_ssrcs,
       std::map<uint32_t, RtpPayloadState> suspended_payload_states,
       VideoEncoderConfig::ContentType content_type);
@@ -351,6 +352,7 @@ class VideoSendStreamImpl : public webrtc::BitrateAllocatorObserver,
   int encoder_min_bitrate_bps_;
   uint32_t encoder_max_bitrate_bps_;
   uint32_t encoder_target_rate_bps_;
+  double encoder_bitrate_priority_;
 
   VideoStreamEncoder* const video_stream_encoder_;
   EncoderRtcpFeedback encoder_feedback_;
@@ -392,6 +394,7 @@ class VideoSendStream::ConstructionTask : public rtc::QueuedTask {
       RtcEventLog* event_log,
       const VideoSendStream::Config* config,
       int initial_encoder_max_bitrate,
+      double initial_encoder_bitrate_priority,
       const std::map<uint32_t, RtpState>& suspended_ssrcs,
       const std::map<uint32_t, RtpPayloadState>& suspended_payload_states,
       VideoEncoderConfig::ContentType content_type)
@@ -406,6 +409,7 @@ class VideoSendStream::ConstructionTask : public rtc::QueuedTask {
         event_log_(event_log),
         config_(config),
         initial_encoder_max_bitrate_(initial_encoder_max_bitrate),
+        initial_encoder_bitrate_priority_(initial_encoder_bitrate_priority),
         suspended_ssrcs_(suspended_ssrcs),
         suspended_payload_states_(suspended_payload_states),
         content_type_(content_type) {}
@@ -418,8 +422,8 @@ class VideoSendStream::ConstructionTask : public rtc::QueuedTask {
         stats_proxy_, rtc::TaskQueue::Current(), call_stats_, transport_,
         bitrate_allocator_, send_delay_stats_, video_stream_encoder_,
         event_log_, config_, initial_encoder_max_bitrate_,
-        std::move(suspended_ssrcs_), std::move(suspended_payload_states_),
+        initial_encoder_bitrate_priority_, std::move(suspended_ssrcs_),
-        content_type_));
+        std::move(suspended_payload_states_), content_type_));
     return true;
   }
 
@@ -434,6 +438,7 @@ class VideoSendStream::ConstructionTask : public rtc::QueuedTask {
   RtcEventLog* const event_log_;
   const VideoSendStream::Config* config_;
   int initial_encoder_max_bitrate_;
+  double initial_encoder_bitrate_priority_;
   std::map<uint32_t, RtpState> suspended_ssrcs_;
   std::map<uint32_t, RtpPayloadState> suspended_payload_states_;
   const VideoEncoderConfig::ContentType content_type_;
@@ -572,8 +577,8 @@ VideoSendStream::VideoSendStream(
       &send_stream_, &thread_sync_event_, &stats_proxy_,
       video_stream_encoder_.get(), module_process_thread, call_stats, transport,
       bitrate_allocator, send_delay_stats, event_log, &config_,
-      encoder_config.max_bitrate_bps, suspended_ssrcs, suspended_payload_states,
+      encoder_config.max_bitrate_bps, encoder_config.bitrate_priority,
-      encoder_config.content_type)));
+      suspended_ssrcs, suspended_payload_states, encoder_config.content_type)));
 
   // Wait for ConstructionTask to complete so that |send_stream_| can be used.
   // |module_process_thread| must be registered and deregistered on the thread
@@ -691,6 +696,7 @@ VideoSendStreamImpl::VideoSendStreamImpl(
     RtcEventLog* event_log,
     const VideoSendStream::Config* config,
     int initial_encoder_max_bitrate,
+    double initial_encoder_bitrate_priority,
     std::map<uint32_t, RtpState> suspended_ssrcs,
     std::map<uint32_t, RtpPayloadState> suspended_payload_states,
     VideoEncoderConfig::ContentType content_type)
@@ -710,6 +716,7 @@ VideoSendStreamImpl::VideoSendStreamImpl(
       encoder_min_bitrate_bps_(0),
       encoder_max_bitrate_bps_(initial_encoder_max_bitrate),
       encoder_target_rate_bps_(0),
+      encoder_bitrate_priority_(initial_encoder_bitrate_priority),
       video_stream_encoder_(video_stream_encoder),
       encoder_feedback_(Clock::GetRealTimeClock(),
                         config_->rtp.ssrcs,
@@ -746,6 +753,7 @@ VideoSendStreamImpl::VideoSendStreamImpl(
   RTC_DCHECK(call_stats_);
   RTC_DCHECK(transport_);
   RTC_DCHECK(transport_->send_side_cc());
+  RTC_DCHECK_GT(encoder_max_bitrate_bps_, 0);
   RTC_CHECK(field_trial::FindFullName(
                 AlrDetector::kStrictPacingAndProbingExperimentName)
                 .empty() ||
@@ -880,7 +888,7 @@ void VideoSendStreamImpl::Start() {
   bitrate_allocator_->AddObserver(
       this, encoder_min_bitrate_bps_, encoder_max_bitrate_bps_,
       max_padding_bitrate_, !config_->suspend_below_min_bitrate,
-      config_->track_id);
+      config_->track_id, encoder_bitrate_priority_);
 
   // Start monitoring encoder activity.
   {
@@ -934,7 +942,7 @@ void VideoSendStreamImpl::SignalEncoderActive() {
   bitrate_allocator_->AddObserver(
       this, encoder_min_bitrate_bps_, encoder_max_bitrate_bps_,
       max_padding_bitrate_, !config_->suspend_below_min_bitrate,
-      config_->track_id);
+      config_->track_id, encoder_bitrate_priority_);
 }
 
 void VideoSendStreamImpl::OnEncoderConfigurationChanged(
@@ -954,8 +962,16 @@ void VideoSendStreamImpl::OnEncoderConfigurationChanged(
   encoder_min_bitrate_bps_ =
       std::max(streams[0].min_bitrate_bps, GetEncoderMinBitrateBps());
   encoder_max_bitrate_bps_ = 0;
-  for (const auto& stream : streams)
+  double stream_bitrate_priority_sum = 0;
+  for (const auto& stream : streams) {
     encoder_max_bitrate_bps_ += stream.max_bitrate_bps;
+    if (stream.bitrate_priority) {
+      RTC_DCHECK_GT(*stream.bitrate_priority, 0);
+      stream_bitrate_priority_sum += *stream.bitrate_priority;
+    }
+  }
+  RTC_DCHECK_GT(stream_bitrate_priority_sum, 0);
+  encoder_bitrate_priority_ = stream_bitrate_priority_sum;
   max_padding_bitrate_ = CalculateMaxPadBitrateBps(
       streams, min_transmit_bitrate_bps, config_->suspend_below_min_bitrate);
 
@@ -976,7 +992,7 @@ void VideoSendStreamImpl::OnEncoderConfigurationChanged(
     bitrate_allocator_->AddObserver(
         this, encoder_min_bitrate_bps_, encoder_max_bitrate_bps_,
         max_padding_bitrate_, !config_->suspend_below_min_bitrate,
-        config_->track_id);
+        config_->track_id, encoder_bitrate_priority_);
   }
 }