Allow applications to control audio send bitrate through RtpParameters.

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 1063 matching lines @@
 }
 
 int WebRtcVoiceEngine::CreateVoEChannel() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   return voe_wrapper_->base()->CreateChannel(voe_config_);
 }
 
 class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
     : public AudioSource::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_(CreateRtpParametersWithOneEncoding()) {
     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 90 matching lines @@
     source_ = nullptr;
     UpdateSendState();
   }
 
   // Accessor to the VoE channel ID.
   int channel() const {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     return config_.voe_channel_id;
   }
 
+  const webrtc::RtpParameters& rtp_parameters() const {
+    return rtp_parameters_;
+  }
+
+  void set_rtp_parameters(const webrtc::RtpParameters& parameters) {
+    RTC_CHECK_EQ(1UL, parameters.encodings.size());
+    rtp_parameters_ = parameters;
+  }
+
  private:
   void UpdateSendState() {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     RTC_DCHECK(stream_);
     if (send_ && source_ != nullptr) {
       stream_->Start();
     } else {  // !send || source_ = nullptr
       stream_->Stop();
     }
   }
 
   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 AudioSource owned by LocalAudioTrackHandler.
   // PeerConnection will make sure invalidating the pointer before the object
   // goes away.
   AudioSource* source_ = nullptr;
   bool send_ = false;
+  webrtc::RtpParameters 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 116 matching lines @@
   std::vector<webrtc::RtpExtension> filtered_extensions =
       FilterRtpExtensions(params.extensions,
                           webrtc::RtpExtension::IsSupportedForAudio, true);
   if (send_rtp_extensions_ != filtered_extensions) {
     send_rtp_extensions_.swap(filtered_extensions);
     for (auto& it : send_streams_) {
       it.second->RecreateAudioSendStream(send_rtp_extensions_);
     }
   }
 
-  if (!SetMaxSendBandwidth(params.max_bandwidth_bps)) {
+  if (!SetSendBitrate(params.max_bandwidth_bps)) {
     return false;
   }
   return SetOptions(params.options);
 }
 
 bool WebRtcVoiceMediaChannel::SetRecvParameters(
     const AudioRecvParameters& params) {
   TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::SetRecvParameters");
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetRecvParameters: "
@@ skipping 13 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::RtpParameters WebRtcVoiceMediaChannel::GetRtpParameters(
+    uint32_t ssrc) const {
+  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+  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::RtpParameters();
+  }
+
+  return it->second->rtp_parameters();
+}
+
+bool WebRtcVoiceMediaChannel::SetRtpParameters(
+    uint32_t ssrc,
+    const webrtc::RtpParameters& parameters) {
+  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+  if (!ValidateRtpParameters(parameters)) {
+    return false;
+  }
+  auto it = send_streams_.find(ssrc);
+  if (it == send_streams_.end()) {
+    LOG(LS_WARNING) << "Attempting to set RTP parameters for stream with ssrc "
+                    << ssrc << " which doesn't exist.";
+    return false;
+  }
+
+  if (!SetChannelParameters(it->second->channel(), parameters)) {
+    LOG(LS_WARNING) << "Failed to set RtpParameters.";
+    return false;
+  }
+  it->second->set_rtp_parameters(parameters);
+  return true;
+}
+
+bool WebRtcVoiceMediaChannel::ValidateRtpParameters(
+    const webrtc::RtpParameters& rtp_parameters) {
+  if (rtp_parameters.encodings.size() != 1) {
+    LOG(LS_ERROR)
+        << "Attempted to set RtpParameters without exactly one encoding";
+    return false;
+  }
+  return true;
+}
+
 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 174 matching lines @@
         break;
       }
     }
 
     // Latch in the new state.
     send_codec_spec_ = std::move(send_codec_spec);
   }
 
   // Cache the codecs in order to configure the channel created later.
   for (const auto& ch : send_streams_) {
-    if (!SetSendCodecs(ch.second->channel())) {
+    if (!SetSendCodecs(ch.second->channel(), ch.second->rtp_parameters())) {
       return false;
     }
   }
 
   // Set nack status on receive channels.
   if (!send_streams_.empty()) {
     for (const auto& kv : recv_streams_) {
       SetNack(kv.second->channel(), send_codec_spec_.nack_enabled);
     }
   }
 
   // Check if the transport cc feedback has changed on the preferred send codec,
   // and in that case reconfigure all receive streams.
   if (recv_transport_cc_enabled_ != send_codec_spec_.transport_cc_enabled) {
     LOG(LS_INFO) << "Recreate all the receive streams because the send "
                     "codec has changed.";
     recv_transport_cc_enabled_ = send_codec_spec_.transport_cc_enabled;
     for (auto& kv : recv_streams_) {
       kv.second->RecreateAudioReceiveStream(recv_transport_cc_enabled_);
     }
   }
 
   return true;
 }
 
 // Apply current codec settings to a single voe::Channel used for sending.
-bool WebRtcVoiceMediaChannel::SetSendCodecs(int channel) {
+bool WebRtcVoiceMediaChannel::SetSendCodecs(
+    int channel,
+    const webrtc::RtpParameters& rtp_parameters) {
   // Disable VAD, FEC, and RED unless we know the other side wants them.
   engine()->voe()->codec()->SetVADStatus(channel, false);
   engine()->voe()->rtp()->SetNACKStatus(channel, false, 0);
   engine()->voe()->rtp()->SetREDStatus(channel, false);
   engine()->voe()->codec()->SetFECStatus(channel, false);
 
   if (send_codec_spec_.red_payload_type != -1) {
     // Enable redundant encoding of the specified codec. Treat any
     // failure as a fatal internal error.
     LOG(LS_INFO) << "Enabling RED on channel " << channel;
@@ skipping 47 matching lines @@
                    << " Hz on channel "
                    << channel;
       if (engine()->voe()->codec()->SetOpusMaxPlaybackRate(
           channel, send_codec_spec_.opus_max_playback_rate) == -1) {
         LOG_RTCERR2(SetOpusMaxPlaybackRate, channel,
                     send_codec_spec_.opus_max_playback_rate);
         return false;
       }
     }
   }
-
-  if (send_bitrate_setting_) {
-    SetSendBitrateInternal(send_bitrate_bps_);
-  }
+  // TODO(solenberg): SetSendBitrate() yields another call to SetSendCodec().
+  // Check if it is possible to fuse with the previous call in this function.
+  SetChannelParameters(channel, rtp_parameters);
 
   // Set the CN payloadtype and the VAD status.
   if (send_codec_spec_.cng_payload_type != -1) {
     // The CN payload type for 8000 Hz clockrate is fixed at 13.
     if (send_codec_spec_.cng_plfreq != 8000) {
       webrtc::PayloadFrequencies cn_freq;
       switch (send_codec_spec_.cng_plfreq) {
         case 16000:
           cn_freq = webrtc::kFreq16000Hz;
           break;
@@ skipping 174 matching lines @@
   // Create a new channel for sending audio data.
   int channel = CreateVoEChannel();
   if (channel == -1) {
     return false;
   }
 
   // Save the channel to send_streams_, so that RemoveSendStream() can still
   // delete the channel in case failure happens below.
   webrtc::AudioTransport* audio_transport =
       engine()->voe()->base()->audio_transport();
-  send_streams_.insert(std::make_pair(ssrc, new WebRtcAudioSendStream(
-      channel, audio_transport, ssrc, sp.cname, send_rtp_extensions_, call_)));
+  WebRtcAudioSendStream* stream = new WebRtcAudioSendStream(
+      channel, audio_transport, ssrc, sp.cname, send_rtp_extensions_, call_);
+  send_streams_.insert(std::make_pair(ssrc, stream));
 
   // Set the current codecs to be used for the new channel. We need to do this
   // after adding the channel to send_channels_, because of how max bitrate is
   // currently being configured by SetSendCodec().
-  if (HasSendCodec() && !SetSendCodecs(channel)) {
+  if (HasSendCodec() && !SetSendCodecs(channel, stream->rtp_parameters())) {
     RemoveSendStream(ssrc);
     return false;
   }
 
   // At this point the channel's local SSRC has been updated. If the channel is
   // the first send channel make sure that all the receive channels are updated
   // with the same SSRC in order to send receiver reports.
   if (send_streams_.size() == 1) {
     receiver_reports_ssrc_ = ssrc;
     for (const auto& stream : recv_streams_) {
@@ skipping 403 matching lines @@
     }
   }
 
   webrtc::AudioProcessing* ap = engine()->voe()->base()->audio_processing();
   if (ap) {
     ap->set_output_will_be_muted(all_muted);
   }
   return true;
 }
 
-// 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::SetSendBitrate(int bps) {
+  LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetSendBitrate.";
+  send_bitrate_bps_ = bps;
+
+  for (const auto& kv : send_streams_) {
+    if (!SetChannelParameters(kv.second->channel(),
+                              kv.second->rtp_parameters())) {
+      return false;
+    }
+  }
+  return true;
 }
 
-bool WebRtcVoiceMediaChannel::SetSendBitrateInternal(int bps) {
-  LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetSendBitrateInternal.";
+bool WebRtcVoiceMediaChannel::SetChannelParameters(
+    int channel,
+    const webrtc::RtpParameters& parameters) {
+  RTC_CHECK_EQ(1UL, parameters.encodings.size());
+  return SetSendBitrate(
+      channel,
+      MinPositive(send_bitrate_bps_, parameters.encodings[0].max_bitrate_bps));
+}
 
-  send_bitrate_setting_ = true;
-  send_bitrate_bps_ = bps;
+bool WebRtcVoiceMediaChannel::SetSendBitrate(int channel, int 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;

[pthatcher1, 2016/04/12 18:04:23]

{}s please

 
   if (!HasSendCodec()) {
     LOG(LS_INFO) << "The send codec has not been set up yet. "
                  << "The send bitrate setting will be applied later.";
     return true;
   }
 
-  // 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_spec_.codec_inst;
   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 132 matching lines @@
     }
   } else {
     LOG(LS_INFO) << "Stopping playout for channel #" << channel;
     engine()->voe()->base()->StopPlayout(channel);
   }
   return true;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE