Injectable audio encoders: WebRtcVoiceEngine and company

webrtc/voice_engine/channel_proxy.cc

 /*
  *  Copyright (c) 2015 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 17 matching lines @@
 }
 
 ChannelProxy::~ChannelProxy() {}
 
 bool ChannelProxy::SetEncoder(int payload_type,
                               std::unique_ptr<AudioEncoder> encoder) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   return channel()->SetEncoder(payload_type, std::move(encoder));
 }
 
+void ChannelProxy::ModifyEncoder(
+    rtc::FunctionView<void(std::unique_ptr<AudioEncoder>*)> modifier) {
+  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+  channel()->ModifyEncoder(modifier);
+}
+
 void ChannelProxy::SetRTCPStatus(bool enable) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   channel()->SetRTCPStatus(enable);
 }
 
 void ChannelProxy::SetLocalSSRC(uint32_t ssrc) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   int error = channel()->SetLocalSSRC(ssrc);
   RTC_DCHECK_EQ(0, error);
 }
@@ skipping 171 matching lines @@
 void ChannelProxy::SetChannelOutputVolumeScaling(float scaling) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   channel()->SetChannelOutputVolumeScaling(scaling);
 }
 
 void ChannelProxy::SetRtcEventLog(RtcEventLog* event_log) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   channel()->SetRtcEventLog(event_log);
 }
 
-void ChannelProxy::EnableAudioNetworkAdaptor(const std::string& config_string) {
-  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  bool ret = channel()->EnableAudioNetworkAdaptor(config_string);
-  RTC_DCHECK(ret);
-;}
-
-void ChannelProxy::DisableAudioNetworkAdaptor() {
-  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  channel()->DisableAudioNetworkAdaptor();
-}
-
-void ChannelProxy::SetReceiverFrameLengthRange(int min_frame_length_ms,
-                                               int max_frame_length_ms) {
-  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  channel()->SetReceiverFrameLengthRange(min_frame_length_ms,
-                                         max_frame_length_ms);
-}
-
 AudioMixer::Source::AudioFrameInfo ChannelProxy::GetAudioFrameWithInfo(
     int sample_rate_hz,
     AudioFrame* audio_frame) {
   RTC_DCHECK_RUNS_SERIALIZED(&audio_thread_race_checker_);
   return channel()->GetAudioFrameWithInfo(sample_rate_hz, audio_frame);
 }
 
 int ChannelProxy::NeededFrequency() const {
   RTC_DCHECK_RUNS_SERIALIZED(&audio_thread_race_checker_);
   return static_cast<int>(channel()->NeededFrequency(-1));
@@ skipping 46 matching lines @@
 void ChannelProxy::SetRtcpRttStats(RtcpRttStats* rtcp_rtt_stats) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   channel()->SetRtcpRttStats(rtcp_rtt_stats);
 }
 
 bool ChannelProxy::GetRecCodec(CodecInst* codec_inst) const {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   return channel()->GetRecCodec(*codec_inst) == 0;
 }
 
-bool ChannelProxy::GetSendCodec(CodecInst* codec_inst) const {
-  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  return channel()->GetSendCodec(*codec_inst) == 0;
-}
-
-bool ChannelProxy::SetVADStatus(bool enable) {
-  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  return channel()->SetVADStatus(enable, VADNormal, false) == 0;
-}
-
-bool ChannelProxy::SetCodecFECStatus(bool enable) {
-  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  return channel()->SetCodecFECStatus(enable) == 0;
-}
-
-bool ChannelProxy::SetOpusDtx(bool enable) {
-  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  return channel()->SetOpusDtx(enable) == 0;
-}
-
-bool ChannelProxy::SetOpusMaxPlaybackRate(int frequency_hz) {
-  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  return channel()->SetOpusMaxPlaybackRate(frequency_hz) == 0;
-}
-
-bool ChannelProxy::SetSendCodec(const CodecInst& codec_inst) {
-  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  // Validation code copied from VoECodecImpl::SetSendCodec().
-  if ((STR_CASE_CMP(codec_inst.plname, "L16") == 0) &&
-      (codec_inst.pacsize >= 960)) {
-    return false;
-  }
-  if (!STR_CASE_CMP(codec_inst.plname, "CN") ||
-      !STR_CASE_CMP(codec_inst.plname, "TELEPHONE-EVENT") ||
-      !STR_CASE_CMP(codec_inst.plname, "RED")) {
-    return false;
-  }
-  if ((codec_inst.channels != 1) && (codec_inst.channels != 2)) {
-    return false;
-  }
-  if (!AudioCodingModule::IsCodecValid(codec_inst)) {
-    return false;
-  }
-  return channel()->SetSendCodec(codec_inst) == 0;
-}
-
-bool ChannelProxy::SetSendCNPayloadType(int type,
-                                        PayloadFrequencies frequency) {
-  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  // Validation code copied from VoECodecImpl::SetSendCNPayloadType().
-  if (type < 96 || type > 127) {
-    // Only allow dynamic range: 96 to 127
-    return false;
-  }
-  if ((frequency != kFreq16000Hz) && (frequency != kFreq32000Hz)) {
-    // It is not possible to modify the payload type for CN/8000.
-    // We only allow modification of the CN payload type for CN/16000
-    // and CN/32000.
-    return false;
-  }
-  return channel()->SetSendCNPayloadType(type, frequency) == 0;
-}
-
 Channel* ChannelProxy::channel() const {
   RTC_DCHECK(channel_owner_.channel());
   return channel_owner_.channel();
 }
 
 }  // namespace voe
 }  // namespace webrtc