Moving WebRtcVoiceMediaChannel::SendSetCodec to AudioSendStream.

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 446 matching lines @@
     // G722 should be advertised as 8000 Hz because of the RFC "bug".
     {kG722CodecName, 8000, 1, 9, false, {10, 20, 30, 40, 50, 60}},
     {kIlbcCodecName, 8000, 1, 102, false, {20, 30, 40, 60}},
     {kPcmuCodecName, 8000, 1, 0, false, {10, 20, 30, 40, 50, 60}},
     {kPcmaCodecName, 8000, 1, 8, false, {10, 20, 30, 40, 50, 60}},
     {kCnCodecName, 32000, 1, 106, false, {}},
     {kCnCodecName, 16000, 1, 105, false, {}},
     {kCnCodecName, 8000, 1, 13, false, {}},
     {kDtmfCodecName, 8000, 1, 126, false, {}}
 };
-} // namespace {
 
-bool SendCodecSpec::operator==(const SendCodecSpec& rhs) const {
-  if (nack_enabled != rhs.nack_enabled) {
-    return false;
-  }
-  if (transport_cc_enabled != rhs.transport_cc_enabled) {
-    return false;
-  }
-  if (enable_codec_fec != rhs.enable_codec_fec) {
-    return false;
-  }
-  if (enable_opus_dtx != rhs.enable_opus_dtx) {
-    return false;
-  }
-  if (opus_max_playback_rate != rhs.opus_max_playback_rate) {
-    return false;
-  }
-  if (red_payload_type != rhs.red_payload_type) {
-    return false;
-  }
-  if (cng_payload_type != rhs.cng_payload_type) {
-    return false;
-  }
-  if (cng_plfreq != rhs.cng_plfreq) {
-    return false;
-  }
-  if (codec_inst != rhs.codec_inst) {
-    return false;
-  }
-  return true;
-}
-
-bool SendCodecSpec::operator!=(const SendCodecSpec& rhs) const {
-  return !(*this == rhs);
-}
+}  // namespace {
 
 bool WebRtcVoiceEngine::ToCodecInst(const AudioCodec& in,
                                     webrtc::CodecInst* out) {
   return WebRtcVoiceCodecs::ToCodecInst(in, out);
 }
 
 WebRtcVoiceEngine::WebRtcVoiceEngine(
     webrtc::AudioDeviceModule* adm,
     const rtc::scoped_refptr<webrtc::AudioDecoderFactory>& decoder_factory)
     : WebRtcVoiceEngine(adm, decoder_factory, new VoEWrapper()) {
@@ skipping 620 matching lines @@
 
   // Add telephone-event codec last
   map_format({kDtmfCodecName, 8000, 1});
 
   return out;
 }
 
 class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
     : public AudioSource::Sink {
  public:
-  WebRtcAudioSendStream(int ch,
-                        webrtc::AudioTransport* voe_audio_transport,
-                        uint32_t ssrc,
-                        const std::string& c_name,
-                        const SendCodecSpec& send_codec_spec,
-                        const std::vector<webrtc::RtpExtension>& extensions,
-                        webrtc::Call* call,
-                        webrtc::Transport* send_transport)
+  WebRtcAudioSendStream(
+      int ch,
+      webrtc::AudioTransport* voe_audio_transport,
+      uint32_t ssrc,
+      const std::string& c_name,
+      const webrtc::AudioSendStream::Config::SendCodecSpec& send_codec_spec,
+      const std::vector<webrtc::RtpExtension>& extensions,
+      int max_send_bitrate_bps,
+      webrtc::Call* call,
+      webrtc::Transport* send_transport)
       : voe_audio_transport_(voe_audio_transport),
         call_(call),
         config_(send_transport),
+        max_send_bitrate_bps_(max_send_bitrate_bps),
         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);
     config_.rtp.ssrc = ssrc;
     config_.rtp.c_name = c_name;
     config_.voe_channel_id = ch;
     config_.rtp.extensions = extensions;
     RecreateAudioSendStream(send_codec_spec);
   }
 
   ~WebRtcAudioSendStream() override {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     ClearSource();
     call_->DestroyAudioSendStream(stream_);
   }
 
-  void RecreateAudioSendStream(const SendCodecSpec& send_codec_spec) {
+  void RecreateAudioSendStream(
+      const webrtc::AudioSendStream::Config::SendCodecSpec& send_codec_spec) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     config_.rtp.nack.rtp_history_ms =
         send_codec_spec.nack_enabled ? kNackRtpHistoryMs : 0;
+    config_.send_codec_spec = send_codec_spec;
+    config_.send_codec_spec.codec_inst.rate = DecideSendBitrate();
     RecreateAudioSendStream();
   }
 
   void RecreateAudioSendStream(
       const std::vector<webrtc::RtpExtension>& extensions) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     config_.rtp.extensions = extensions;
     RecreateAudioSendStream();
   }
 
+  bool SetMaxSendBitrate(int bps) {
+    RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+    if (!IsMaxSendBitrateValid(
+            MinPositive(bps, rtp_parameters_.encodings[0].max_bitrate_bps))) {
+      return false;
+    }
+    max_send_bitrate_bps_ = bps;
+
+    int new_sent_bitrate_bps = DecideSendBitrate();
+    if (config_.send_codec_spec.codec_inst.rate != new_sent_bitrate_bps) {
+      // Recreate AudioSendStream with new bit rate.
+      config_.send_codec_spec.codec_inst.rate = new_sent_bitrate_bps;
+      RecreateAudioSendStream();
+    }
+    return true;
+  }
+
   bool SendTelephoneEvent(int payload_type, int event, int duration_ms) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     RTC_DCHECK(stream_);
     return stream_->SendTelephoneEvent(payload_type, event, duration_ms);
   }
 
   void SetSend(bool send) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     send_ = send;
     UpdateSendState();
@@ skipping 72 matching lines @@
   // 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 SetRtpParameters(const webrtc::RtpParameters& parameters) {
+  bool SetRtpParameters(const webrtc::RtpParameters& parameters) {
     RTC_CHECK_EQ(1UL, parameters.encodings.size());
+
+    if (!IsMaxSendBitrateValid(MinPositive(
+            max_send_bitrate_bps_, parameters.encodings[0].max_bitrate_bps))) {
+      return false;
+    }
     rtp_parameters_ = parameters;
-    // parameters.encodings[0].active could have changed.
-    UpdateSendState();
+
+    // parameters.encodings[0].encodings[0].max_bitrate_bps could have changed.
+    int new_sent_bitrate_bps = DecideSendBitrate();
+    if (config_.send_codec_spec.codec_inst.rate != new_sent_bitrate_bps) {
+      // Recreate AudioSendStream with new bit rate.
+      config_.send_codec_spec.codec_inst.rate = new_sent_bitrate_bps;
+      RecreateAudioSendStream();
+    } else {
+      // parameters.encodings[0].active could have changed.
+      UpdateSendState();
+    }
+    return true;
   }
 
  private:
   void UpdateSendState() {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     RTC_DCHECK(stream_);
     RTC_DCHECK_EQ(1UL, rtp_parameters_.encodings.size());
     if (send_ && source_ != nullptr && rtp_parameters_.encodings[0].active) {
       stream_->Start();
     } else {  // !send || source_ = nullptr
       stream_->Stop();
     }
   }
 
+  bool IsMaxSendBitrateValid(int bps) const {

[the sun, 2016/10/19 13:02:18]

Is it possible to combine these two functions into a single one which returns
e.g. an rtc::Optional<int> for the bitrate?

+    if (bps <= 0) {
+      return true;
+    }
+
+    if (config_.send_codec_spec.codec_inst.pltype == -1) {
+      LOG(LS_INFO) << "The send codec has not been set up yet. "
+                   << "The send bitrate setting will be applied later.";
+      return true;
+    }
+
+    if (!WebRtcVoiceCodecs::IsCodecMultiRate(
+            config_.send_codec_spec.codec_inst) &&
+        bps < config_.send_codec_spec.codec_inst.rate) {
+      // If codec is not multi-rate and |max_send_bit_rate_| is less than the
+      // fixed bitrate then fail. If codec is not multi-rate and |bps| exceeds
+      // or
+      // equal the fixed bitrate then ignore.
+      LOG(LS_ERROR) << "Failed to set codec "
+                    << config_.send_codec_spec.codec_inst.plname
+                    << " to bitrate " << bps << " bps"
+                    << ", requires at least "
+                    << config_.send_codec_spec.codec_inst.rate << " bps.";
+      return false;
+    }
+
+    return true;
+  }
+
+  int DecideSendBitrate() const {

[the sun, 2016/10/19 13:02:18]

This should be a static function taking 3 parameters:
max_send_bitrate, max_bitrate_bps (from rtp_parameters), and a const CodecInst&.

Then there is no ambiguity regarding the call order - the state of these methods
doesn't need to be latched in before calling the method.

Also, nit: ComputeSendBitrate()

+    const int bps = MinPositive(max_send_bitrate_bps_,
+                                rtp_parameters_.encodings[0].max_bitrate_bps);

[the sun, 2016/10/19 13:02:17]

Should there be an RTC_DCHECK(IsMaxSendBitrateValid(bps)) here?

+    const int current_rate = config_.send_codec_spec.codec_inst.rate;

[the sun, 2016/10/19 13:02:18]

codec_rate would be more descriptive

+
+    // Bitrate is auto by default.
+    // TODO(bemasc): Fix this so that if SetMaxSendBitrate(50) is followed by
+    // SetMaxSendBitrate(0), the second call removes the previous limit.
+    if (bps <= 0) {
+      return current_rate;
+    }
+
+    if (config_.send_codec_spec.codec_inst.pltype == -1) {
+      return current_rate;
+    }
+
+    if (!WebRtcVoiceCodecs::IsCodecMultiRate(
+            config_.send_codec_spec.codec_inst)) {
+      return current_rate;
+    }
+
+    // If codec is multi-rate then just set the bitrate.
+    return std::min(bps, WebRtcVoiceCodecs::MaxBitrateBps(
+                             config_.send_codec_spec.codec_inst));
+  }
+
   void RecreateAudioSendStream() {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     if (stream_) {
       call_->DestroyAudioSendStream(stream_);
       stream_ = nullptr;
     }
     RTC_DCHECK(!stream_);
     if (webrtc::field_trial::FindFullName("WebRTC-AdaptAudioBitrate") ==
         "Enabled") {
       // TODO(mflodman): Keep testing this and set proper values.
@@ skipping 14 matching lines @@
   // 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;
   bool muted_ = false;
+  int max_send_bitrate_bps_;
   webrtc::RtpParameters rtp_parameters_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WebRtcAudioSendStream);
 };
 
 class WebRtcVoiceMediaChannel::WebRtcAudioReceiveStream {
  public:
   WebRtcAudioReceiveStream(
       int ch,
       uint32_t remote_ssrc,
@@ skipping 240 matching lines @@
 
   // TODO(deadbeef): Handle setting parameters with a list of codecs in a
   // different order (which should change the send codec).
   webrtc::RtpParameters current_parameters = GetRtpSendParameters(ssrc);
   if (current_parameters.codecs != parameters.codecs) {
     LOG(LS_ERROR) << "Using SetParameters to change the set of codecs "
                   << "is not currently supported.";
     return false;
   }
 
-  if (!SetChannelSendParameters(it->second->channel(), parameters)) {
-    LOG(LS_WARNING) << "Failed to set send RtpParameters.";
-    return false;
-  }
+  // TODO(minyue): The following legacy actions go into
+  // |WebRtcAudioSendStream::SetRtpParameters()| which is called at the end,
+  // though there are two difference:
+  // 1. |WebRtcVoiceMediaChannel::SetChannelSendParameters()| only calls
+  // |SetSendCodec| while |WebRtcAudioSendStream::SetRtpParameters()| calls
+  // |SetSendCodecs|. The outcome should be the same.
+  // 2. AudioSendStream can be recreated.
+
   // Codecs are handled at the WebRtcVoiceMediaChannel level.
   webrtc::RtpParameters reduced_params = parameters;
   reduced_params.codecs.clear();
-  it->second->SetRtpParameters(reduced_params);
-  return true;
+  return it->second->SetRtpParameters(reduced_params);
 }
 
 webrtc::RtpParameters WebRtcVoiceMediaChannel::GetRtpReceiveParameters(
     uint32_t ssrc) const {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   auto it = recv_streams_.find(ssrc);
   if (it == recv_streams_.end()) {
     LOG(LS_WARNING) << "Attempting to get RTP receive parameters for stream "
                     << "with ssrc " << ssrc << " which doesn't exist.";
     return webrtc::RtpParameters();
@@ skipping 139 matching lines @@
       }
       dtmf_payload_type_ = rtc::Optional<int>(codec.id);
       break;
     }
   }
 
   // Scan through the list to figure out the codec to use for sending, along
   // with the proper configuration for VAD, CNG, NACK and Opus-specific
   // parameters.
   // TODO(solenberg): Refactor this logic once we create AudioEncoders here.
-  SendCodecSpec send_codec_spec;
+  webrtc::AudioSendStream::Config::SendCodecSpec send_codec_spec;
   {
     send_codec_spec.nack_enabled = send_codec_spec_.nack_enabled;
 
     // Find send codec (the first non-telephone-event/CN codec).
     const AudioCodec* codec = WebRtcVoiceCodecs::GetPreferredCodec(
         codecs, &send_codec_spec.codec_inst);
     if (!codec) {
       LOG(LS_WARNING) << "Received empty list of codecs.";
       return false;
     }
@@ skipping 53 matching lines @@
         break;
       }
     }
   }
 
   // Apply new settings to all streams.
   if (send_codec_spec_ != send_codec_spec) {
     send_codec_spec_ = std::move(send_codec_spec);
     for (const auto& kv : send_streams_) {
       kv.second->RecreateAudioSendStream(send_codec_spec_);
-      if (!SetSendCodecs(kv.second->channel(), kv.second->rtp_parameters())) {
-        return false;
-      }
     }
   }
 
   // Check if the transport cc feedback or NACK status 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 ||
       recv_nack_enabled_ != send_codec_spec_.nack_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;
     recv_nack_enabled_ = send_codec_spec_.nack_enabled;
     for (auto& kv : recv_streams_) {
       kv.second->RecreateAudioReceiveStream(recv_transport_cc_enabled_,
                                             recv_nack_enabled_);
     }
   }
 
   send_codecs_ = codecs;
   return true;
 }
 
-// Apply current codec settings to a single voe::Channel used for sending.
-bool WebRtcVoiceMediaChannel::SetSendCodecs(
-    int channel,
-    const webrtc::RtpParameters& rtp_parameters) {
-  // Disable VAD and FEC unless we know the other side wants them.
-  engine()->voe()->codec()->SetVADStatus(channel, false);
-  engine()->voe()->codec()->SetFECStatus(channel, false);
-
-  // Set the codec immediately, since SetVADStatus() depends on whether
-  // the current codec is mono or stereo.
-  if (!SetSendCodec(channel, send_codec_spec_.codec_inst)) {
-    return false;
-  }
-
-  // FEC should be enabled after SetSendCodec.
-  if (send_codec_spec_.enable_codec_fec) {
-    LOG(LS_INFO) << "Attempt to enable codec internal FEC on channel "
-                 << channel;
-    if (engine()->voe()->codec()->SetFECStatus(channel, true) == -1) {
-      // Enable codec internal FEC. Treat any failure as fatal internal error.
-      LOG_RTCERR2(SetFECStatus, channel, true);
-      return false;
-    }
-  }
-
-  if (IsCodec(send_codec_spec_.codec_inst, kOpusCodecName)) {
-    // DTX and maxplaybackrate should be set after SetSendCodec. Because current
-    // send codec has to be Opus.
-
-    // Set Opus internal DTX.
-    LOG(LS_INFO) << "Attempt to "
-                 << (send_codec_spec_.enable_opus_dtx ? "enable" : "disable")
-                 << " Opus DTX on channel "
-                 << channel;
-    if (engine()->voe()->codec()->SetOpusDtx(channel,
-        send_codec_spec_.enable_opus_dtx)) {
-      LOG_RTCERR2(SetOpusDtx, channel, send_codec_spec_.enable_opus_dtx);
-      return false;
-    }
-
-    // If opus_max_playback_rate <= 0, the default maximum playback rate
-    // (48 kHz) will be used.
-    if (send_codec_spec_.opus_max_playback_rate > 0) {
-      LOG(LS_INFO) << "Attempt to set maximum playback rate to "
-                   << send_codec_spec_.opus_max_playback_rate
-                   << " 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;
-      }
-    }
-  }
-  // TODO(solenberg): SetMaxSendBitrate() yields another call to SetSendCodec().
-  // Check if it is possible to fuse with the previous call in this function.
-  SetChannelSendParameters(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;
-        case 32000:
-          cn_freq = webrtc::kFreq32000Hz;
-          break;
-        default:
-          RTC_NOTREACHED();
-          return false;
-      }
-      if (engine()->voe()->codec()->SetSendCNPayloadType(
-              channel, send_codec_spec_.cng_payload_type, cn_freq) == -1) {
-        LOG_RTCERR3(SetSendCNPayloadType, channel,
-                    send_codec_spec_.cng_payload_type, cn_freq);
-        // TODO(ajm): This failure condition will be removed from VoE.
-        // Restore the return here when we update to a new enough webrtc.
-        //
-        // Not returning false because the SetSendCNPayloadType will fail if
-        // the channel is already sending.
-        // This can happen if the remote description is applied twice, for
-        // example in the case of ROAP on top of JSEP, where both side will
-        // send the offer.
-      }
-    }
-
-    // Only turn on VAD if we have a CN payload type that matches the
-    // clockrate for the codec we are going to use.
-    if (send_codec_spec_.cng_plfreq == send_codec_spec_.codec_inst.plfreq &&
-        send_codec_spec_.codec_inst.channels == 1) {
-      // TODO(minyue): If CN frequency == 48000 Hz is allowed, consider the
-      // interaction between VAD and Opus FEC.
-      LOG(LS_INFO) << "Enabling VAD";
-      if (engine()->voe()->codec()->SetVADStatus(channel, true) == -1) {
-        LOG_RTCERR2(SetVADStatus, channel, true);
-        return false;
-      }
-    }
-  }
-  return true;
-}
-
-bool WebRtcVoiceMediaChannel::SetSendCodec(
-    int channel, const webrtc::CodecInst& send_codec) {
-  LOG(LS_INFO) << "Send channel " << channel <<  " selected voice codec "
-               << ToString(send_codec) << ", bitrate=" << send_codec.rate;
-
-  webrtc::CodecInst current_codec = {0};
-  if (engine()->voe()->codec()->GetSendCodec(channel, current_codec) == 0 &&
-      (send_codec == current_codec)) {
-    // Codec is already configured, we can return without setting it again.
-    return true;
-  }
-
-  if (engine()->voe()->codec()->SetSendCodec(channel, send_codec) == -1) {
-    LOG_RTCERR2(SetSendCodec, channel, ToString(send_codec));
-    return false;
-  }
-  return true;
-}
-
 void WebRtcVoiceMediaChannel::SetPlayout(bool playout) {
   TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::SetPlayout");
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   if (playout_ == playout) {
     return;
   }
 
   for (const auto& kv : recv_streams_) {
     kv.second->SetPlayout(playout);
   }
@@ skipping 84 matching lines @@
     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();
 
   WebRtcAudioSendStream* stream = new WebRtcAudioSendStream(
       channel, audio_transport, ssrc, sp.cname, send_codec_spec_,
-      send_rtp_extensions_, call_, this);
+      send_rtp_extensions_, max_send_bitrate_bps_, call_, this);
   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, stream->rtp_parameters())) {
-    RemoveSendStream(ssrc);
-    return false;
-  }
-
   // At this point the stream's local SSRC has been updated. If it is the first
   // send stream, make sure that all the receive streams are updated with the
   // same SSRC in order to send receiver reports.
   if (send_streams_.size() == 1) {
     receiver_reports_ssrc_ = ssrc;
     for (const auto& kv : recv_streams_) {
       // TODO(solenberg): Allow applications to set the RTCP SSRC of receive
       // streams instead, so we can avoid recreating the streams here.
       kv.second->RecreateAudioReceiveStream(ssrc);
       int recv_channel = kv.second->channel();
@@ skipping 353 matching lines @@
   webrtc::AudioProcessing* ap = engine()->voe()->base()->audio_processing();
   if (ap) {
     ap->set_output_will_be_muted(all_muted);
   }
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetMaxSendBitrate(int bps) {
   LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetMaxSendBitrate.";
   max_send_bitrate_bps_ = bps;
-
+  bool success = true;
   for (const auto& kv : send_streams_) {
-    if (!SetChannelSendParameters(kv.second->channel(),
-                                  kv.second->rtp_parameters())) {
-      return false;
+    if (!kv.second->SetMaxSendBitrate(max_send_bitrate_bps_)) {
+      success = false;
     }
   }
-  return true;
-}
-
-bool WebRtcVoiceMediaChannel::SetChannelSendParameters(
-    int channel,
-    const webrtc::RtpParameters& parameters) {
-  RTC_CHECK_EQ(1UL, parameters.encodings.size());
-  // TODO(deadbeef): Handle setting parameters with a list of codecs in a
-  // different order (which should change the send codec).
-  return SetMaxSendBitrate(
-      channel, MinPositive(max_send_bitrate_bps_,
-                           parameters.encodings[0].max_bitrate_bps));
-}
-
-bool WebRtcVoiceMediaChannel::SetMaxSendBitrate(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;
-  }
-
-  if (!HasSendCodec()) {
-    LOG(LS_INFO) << "The send codec has not been set up yet. "
-                 << "The send bitrate setting will be applied later.";
-    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.
-    int max_bitrate_bps = WebRtcVoiceCodecs::MaxBitrateBps(codec);
-    codec.rate = std::min(bps, max_bitrate_bps);
-    LOG(LS_INFO) << "Setting codec " << codec.plname << " to bitrate " << bps
-                 << " bps.";
-    if (!SetSendCodec(channel, codec)) {
-      LOG(LS_ERROR) << "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_ERROR) << "Failed to set codec " << codec.plname << " to bitrate "
-                    << bps << " bps"
-                    << ", requires at least " << codec.rate << " bps.";
-      return false;
-    }
-    return true;
-  }
+  return success;
 }
 
 void WebRtcVoiceMediaChannel::OnReadyToSend(bool ready) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   LOG(LS_VERBOSE) << "OnReadyToSend: " << (ready ? "Ready." : "Not ready.");
   call_->SignalChannelNetworkState(
       webrtc::MediaType::AUDIO,
       ready ? webrtc::kNetworkUp : webrtc::kNetworkDown);
 }
 
@@ skipping 105 matching lines @@
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   const auto it = send_streams_.find(ssrc);
   if (it != send_streams_.end()) {
     return it->second->channel();
   }
   return -1;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE