Enable setting the maximum bitrate limit in RtpSender.

webrtc/media/engine/webrtcvoiceengine.cc

 /*
  *  Copyright (c) 2004 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.
  */
 
@@ skipping 1120 matching lines @@
 }
 
 int WebRtcVoiceEngine::CreateVoEChannel() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   return voe_wrapper_->base()->CreateChannel(voe_config_);
 }
 
 class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
     : public AudioRenderer::Sink {
  public:
-  WebRtcAudioSendStream(int ch, webrtc::AudioTransport* voe_audio_transport,
-                        uint32_t ssrc, const std::string& c_name,
+  WebRtcAudioSendStream(int ch,
+                        webrtc::AudioTransport* voe_audio_transport,
+                        uint32_t ssrc,
+                        const std::string& c_name,
                         const std::vector<webrtc::RtpExtension>& extensions,
                         webrtc::Call* call)
       : voe_audio_transport_(voe_audio_transport),
         call_(call),
-        config_(nullptr) {
+        config_(nullptr),
+        rtp_parameters_(webrtc::RTCRtpParameters::CreateDefault()) {
     RTC_DCHECK_GE(ch, 0);
     // TODO(solenberg): Once we're not using FakeWebRtcVoiceEngine anymore:
     // RTC_DCHECK(voe_audio_transport);
     RTC_DCHECK(call);
     audio_capture_thread_checker_.DetachFromThread();
     config_.rtp.ssrc = ssrc;
     config_.rtp.c_name = c_name;
     config_.voe_channel_id = ch;
     RecreateAudioSendStream(extensions);
   }
@@ skipping 82 matching lines @@
     // the renderer.
     renderer_ = nullptr;
   }
 
   // Accessor to the VoE channel ID.
   int channel() const {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     return config_.voe_channel_id;
   }
 
+  webrtc::RTCRtpParameters rtp_parameters() const { return rtp_parameters_; }
+
+  void set_rtp_parameters(const webrtc::RTCRtpParameters& parameters) {
+    rtp_parameters_ = parameters;
+  }
+
  private:
   rtc::ThreadChecker worker_thread_checker_;
   rtc::ThreadChecker audio_capture_thread_checker_;
   webrtc::AudioTransport* const voe_audio_transport_ = nullptr;
   webrtc::Call* call_ = nullptr;
   webrtc::AudioSendStream::Config config_;
   // The stream is owned by WebRtcAudioSendStream and may be reallocated if
   // configuration changes.
   webrtc::AudioSendStream* stream_ = nullptr;
 
   // Raw pointer to AudioRenderer owned by LocalAudioTrackHandler.
   // PeerConnection will make sure invalidating the pointer before the object
   // goes away.
   AudioRenderer* renderer_ = nullptr;
+  webrtc::RTCRtpParameters rtp_parameters_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WebRtcAudioSendStream);
 };
 
 class WebRtcVoiceMediaChannel::WebRtcAudioReceiveStream {
  public:
   WebRtcAudioReceiveStream(int ch,
                            uint32_t remote_ssrc,
                            uint32_t local_ssrc,
                            bool use_transport_cc,
@@ skipping 148 matching lines @@
                           webrtc::RtpExtension::IsSupportedForAudio, false);
   if (recv_rtp_extensions_ != filtered_extensions) {
     recv_rtp_extensions_.swap(filtered_extensions);
     for (auto& it : recv_streams_) {
       it.second->RecreateAudioReceiveStream(recv_rtp_extensions_);
     }
   }
   return true;
 }
 
+webrtc::RTCRtpParameters WebRtcVoiceMediaChannel::GetRtpParameters(

[pthatcher1, 2016/03/12 01:21:04]

Can you split this into a CL for video and a second CL for audio?  I think we'll
be able to land the video one faster that way, and it's more important.

+    uint32_t ssrc) {
+  auto it = send_streams_.find(ssrc);
+  if (it == send_streams_.end()) {
+    LOG(LS_WARNING) << "Attempting to get RTP parameters for stream with ssrc "
+                    << ssrc << " which doesn't exist.";
+    return webrtc::RTCRtpParameters();
+  }
+  return it->second->rtp_parameters();
+}
+
+bool WebRtcVoiceMediaChannel::SetRtpParameters(
+    uint32_t ssrc,
+    const webrtc::RTCRtpParameters& parameters) {
+  auto it = send_streams_.find(ssrc);
+  if (it == send_streams_.end()) {
+    LOG(LS_WARNING) << "Trying to set RTP parameters for stream with ssrc "
+                    << ssrc << " which doesn't exist.";
+    return false;
+  }
+
+  if (parameters.encodings.size() != 1) {
+    LOG(LS_WARNING)
+        << "Attempting to set RTP parameters without exactly 1 encoding";
+    return false;
+  }
+  if (ApplyBitrateLimits(it->second->channel(), send_bitrate_bps_,
+                         parameters.encodings[0].max_bitrate_bps)) {
+    it->second->set_rtp_parameters(parameters);
+    return true;
+  }

[pthatcher1, 2016/03/12 01:21:04]

It feels like we should move the ApplyBitrateLimits to the send stream, perhaps
calls it SetBitrate, and pass in the already calculated min.  Actually, we
should probably mirror the video send stream and have SetParameters that does
the min calculation internal to the stream.

+  return false;
+}
+
 bool WebRtcVoiceMediaChannel::SetOptions(const AudioOptions& options) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   LOG(LS_INFO) << "Setting voice channel options: "
                << options.ToString();
 
   // We retain all of the existing options, and apply the given ones
   // on top.  This means there is no way to "clear" options such that
   // they go back to the engine default.
   options_.SetAll(options);
   if (!engine()->ApplyOptions(options_)) {
@@ skipping 907 matching lines @@
 // TODO(minyue): SetMaxSendBandwidth() is subject to be renamed to
 // SetMaxSendBitrate() in future.
 bool WebRtcVoiceMediaChannel::SetMaxSendBandwidth(int bps) {
   LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetMaxSendBandwidth.";
   return SetSendBitrateInternal(bps);
 }
 
 bool WebRtcVoiceMediaChannel::SetSendBitrateInternal(int bps) {
   LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetSendBitrateInternal.";
 
+  for (const auto& ch : send_streams_) {
+    if (!ApplyBitrateLimits(
+            ch.second->channel(), bps,
+            ch.second->rtp_parameters().encodings[0].max_bitrate_bps)) {
+      LOG(LS_INFO) << "Failed to limit max bitrate of a stream";
+      return false;
+    }
+  }
+
+  if (send_streams_.size() == 0) {
+    LOG(LS_ERROR) << "send_streams_ empty!";
+  }
+
   send_bitrate_setting_ = true;
   send_bitrate_bps_ = bps;
+  return true;
+}
 
+bool WebRtcVoiceMediaChannel::ApplyBitrateLimits(int channel,
+                                                 int global_limit,
+                                                 int local_limit) {

[pthatcher1, 2016/03/12 01:21:04]

Why not just pass in one value and do the min() before?

   if (!send_codec_) {
     LOG(LS_INFO) << "The send codec has not been set up yet. "
                  << "The send bitrate setting will be applied later.";
     return true;
   }
 
+  int bps = MinPositive(global_limit, local_limit);
+
+  LOG(LS_INFO) << "Applying bandwidth limit to channel " << channel
+               << ": global_limit=" << global_limit
+               << " local_limit=" << local_limit << " result=" << bps;
+
   // Bitrate is auto by default.
   // TODO(bemasc): Fix this so that if SetMaxSendBandwidth(50) is followed by
   // SetMaxSendBandwith(0), the second call removes the previous limit.
   if (bps <= 0)
     return true;
 
   webrtc::CodecInst codec = *send_codec_;
   bool is_multi_rate = WebRtcVoiceCodecs::IsCodecMultiRate(codec);
 
   if (is_multi_rate) {
     // If codec is multi-rate then just set the bitrate.
     codec.rate = bps;
-    for (const auto& ch : send_streams_) {
-      if (!SetSendCodec(ch.second->channel(), codec)) {
-        LOG(LS_INFO) << "Failed to set codec " << codec.plname
-                     << " to bitrate " << bps << " bps.";
-        return false;
-      }
+    if (!SetSendCodec(channel, codec)) {
+      LOG(LS_INFO) << "Failed to set codec " << codec.plname << " to bitrate "
+                   << bps << " bps.";
+      return false;
     }
     return true;
   } else {
     // If codec is not multi-rate and |bps| is less than the fixed bitrate
     // then fail. If codec is not multi-rate and |bps| exceeds or equal the
     // fixed bitrate then ignore.
     if (bps < codec.rate) {
       LOG(LS_INFO) << "Failed to set codec " << codec.plname
                    << " to bitrate " << bps << " bps"
                    << ", requires at least " << codec.rate << " bps.";
@@ skipping 124 matching lines @@
     }
   } else {
     LOG(LS_INFO) << "Stopping playout for channel #" << channel;
     engine()->voe()->base()->StopPlayout(channel);
   }
   return true;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE