Allow an external audio processing module to be used in WebRTC

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 145 matching lines @@
       options.audio_network_adaptor_config) {
     // Turn on audio network adaptor only when |options_.audio_network_adaptor|
     // equals true and |options_.audio_network_adaptor_config| has a value.
     return options.audio_network_adaptor_config;
   }
   return rtc::Optional<std::string>();
 }
 
 webrtc::AudioState::Config MakeAudioStateConfig(
     VoEWrapper* voe_wrapper,
-    rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer) {
+    rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer,
+    rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing) {
   webrtc::AudioState::Config config;
   config.voice_engine = voe_wrapper->engine();
   if (audio_mixer) {
     config.audio_mixer = audio_mixer;
   } else {
     config.audio_mixer = webrtc::AudioMixerImpl::Create();
   }
+  config.audio_processing = audio_processing;
   return config;
 }
 
 // |max_send_bitrate_bps| is the bitrate from "b=" in SDP.
 // |rtp_max_bitrate_bps| is the bitrate from RtpSender::SetParameters.
 rtc::Optional<int> ComputeSendBitrate(int max_send_bitrate_bps,
                                       rtc::Optional<int> rtp_max_bitrate_bps,
                                       const webrtc::AudioCodecSpec& spec) {
   // If application-configured bitrate is set, take minimum of that and SDP
   // bitrate.
@@ skipping 23 matching lines @@
     return rtc::Optional<int>(std::min(bps, spec.info.max_bitrate_bps));
   }
 }
 
 }  // namespace
 
 WebRtcVoiceEngine::WebRtcVoiceEngine(
     webrtc::AudioDeviceModule* adm,
     const rtc::scoped_refptr<webrtc::AudioEncoderFactory>& encoder_factory,
     const rtc::scoped_refptr<webrtc::AudioDecoderFactory>& decoder_factory,
-    rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer)
+    rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer,
+    rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing)
     : WebRtcVoiceEngine(adm,
                         encoder_factory,
                         decoder_factory,
                         audio_mixer,
+                        audio_processing,
                         nullptr) {}
 
 WebRtcVoiceEngine::WebRtcVoiceEngine(
     webrtc::AudioDeviceModule* adm,
     const rtc::scoped_refptr<webrtc::AudioEncoderFactory>& encoder_factory,
     const rtc::scoped_refptr<webrtc::AudioDecoderFactory>& decoder_factory,
     rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer,
+    rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing,
     VoEWrapper* voe_wrapper)
     : adm_(adm),
       encoder_factory_(encoder_factory),
       decoder_factory_(decoder_factory),
       audio_mixer_(audio_mixer),
+      apm_(audio_processing),
       voe_wrapper_(voe_wrapper) {
   // This may be called from any thread, so detach thread checkers.
   worker_thread_checker_.DetachFromThread();
   signal_thread_checker_.DetachFromThread();
   LOG(LS_INFO) << "WebRtcVoiceEngine::WebRtcVoiceEngine";
   RTC_DCHECK(decoder_factory);
   RTC_DCHECK(encoder_factory);
+  RTC_DCHECK(audio_processing);
   // The rest of our initialization will happen in Init.
 }
 
 WebRtcVoiceEngine::~WebRtcVoiceEngine() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   LOG(LS_INFO) << "WebRtcVoiceEngine::~WebRtcVoiceEngine";
   if (initialized_) {
     StopAecDump();
     voe_wrapper_->base()->Terminate();
     webrtc::Trace::SetTraceCallback(nullptr);
@@ skipping 26 matching lines @@
   for (const AudioCodec& codec : recv_codecs_) {
     LOG(LS_INFO) << ToString(codec);
   }
 
   channel_config_.enable_voice_pacing = true;
 
   // Temporarily turn logging level up for the Init() call.
   webrtc::Trace::SetTraceCallback(this);
   webrtc::Trace::set_level_filter(kElevatedTraceFilter);
   LOG(LS_INFO) << webrtc::VoiceEngine::GetVersionString();
-  RTC_CHECK_EQ(0, voe_wrapper_->base()->Init(adm_.get(), nullptr,
-                                             decoder_factory_));
+  RTC_CHECK_EQ(0,
+               voe_wrapper_->base()->Init(adm_.get(), apm(), decoder_factory_));
   webrtc::Trace::set_level_filter(kDefaultTraceFilter);
 
   // No ADM supplied? Get the default one from VoE.
   if (!adm_) {
     adm_ = voe_wrapper_->base()->audio_device_module();
   }
   RTC_DCHECK(adm_);
 
-  apm_ = voe_wrapper_->base()->audio_processing();
-  RTC_DCHECK(apm_);
-
   transmit_mixer_ = voe_wrapper_->base()->transmit_mixer();
   RTC_DCHECK(transmit_mixer_);
 
   // Save the default AGC configuration settings. This must happen before
   // calling ApplyOptions or the default will be overwritten.
-  default_agc_config_ = webrtc::apm_helpers::GetAgcConfig(apm_);
+  default_agc_config_ = webrtc::apm_helpers::GetAgcConfig(apm());
 
   // Set default engine options.
   {
     AudioOptions options;
     options.echo_cancellation = rtc::Optional<bool>(true);
     options.auto_gain_control = rtc::Optional<bool>(true);
     options.noise_suppression = rtc::Optional<bool>(true);
     options.highpass_filter = rtc::Optional<bool>(true);
     options.stereo_swapping = rtc::Optional<bool>(false);
     options.audio_jitter_buffer_max_packets = rtc::Optional<int>(50);
@@ skipping 13 matching lines @@
 
   // Set default audio devices.
 #if !defined(WEBRTC_IOS)
   webrtc::adm_helpers::SetRecordingDevice(adm_);
   apm()->Initialize();
   webrtc::adm_helpers::SetPlayoutDevice(adm_);
 #endif  // !WEBRTC_IOS
 
   // May be null for VoE injected for testing.
   if (voe()->engine()) {
-    audio_state_ =
-        webrtc::AudioState::Create(MakeAudioStateConfig(voe(), audio_mixer_));
+    audio_state_ = webrtc::AudioState::Create(
+        MakeAudioStateConfig(voe(), audio_mixer_, apm_));

[Taylor Brandstetter, 2017/06/25 19:13:12]

nit: Should use either "apm_" or "apm()" consistently

[peah-webrtc, 2017/06/27 14:57:40]

That does not work here, as apm() returns a AudioProcessing* pointer, and
MakeAudioStateConfig requires the scoped_refptr<AudioProcessing> which is stored
in apm_.

   }
 
   initialized_ = true;
 }
 
 rtc::scoped_refptr<webrtc::AudioState>
     WebRtcVoiceEngine::GetAudioState() const {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   return audio_state_;
 }
@@ skipping 149 matching lines @@
     default_agc_config_.limiterEnable =
         options.tx_agc_limiter.value_or(default_agc_config_.limiterEnable);
 
     webrtc::AgcConfig config = default_agc_config_;
     if (options.adjust_agc_delta) {
       config.targetLeveldBOv -= *options.adjust_agc_delta;
       LOG(LS_INFO) << "Adjusting AGC level from default -"
                    << default_agc_config_.targetLeveldBOv << "dB to -"
                    << config.targetLeveldBOv << "dB";
     }
-    webrtc::apm_helpers::SetAgcConfig(apm_, config);
+    webrtc::apm_helpers::SetAgcConfig(apm(), config);
   }
 
   if (options.intelligibility_enhancer) {
     intelligibility_enhancer_ = options.intelligibility_enhancer;
   }
   if (intelligibility_enhancer_ && *intelligibility_enhancer_) {
     LOG(LS_INFO) << "Enabling NS when Intelligibility Enhancer is active.";
     options.noise_suppression = intelligibility_enhancer_;
   }
 
@@ skipping 222 matching lines @@
 }
 
 webrtc::AudioDeviceModule* WebRtcVoiceEngine::adm() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   RTC_DCHECK(adm_);
   return adm_;
 }
 
 webrtc::AudioProcessing* WebRtcVoiceEngine::apm() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  RTC_DCHECK(apm_);
-  return apm_;
+  return apm_.get();
 }
 
 webrtc::voe::TransmitMixer* WebRtcVoiceEngine::transmit_mixer() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   RTC_DCHECK(transmit_mixer_);
   return transmit_mixer_;
 }
 
 AudioCodecs WebRtcVoiceEngine::CollectCodecs(
     const std::vector<webrtc::AudioCodecSpec>& specs) const {
@@ skipping 1600 matching lines @@
                       ssrc);
   if (it != unsignaled_recv_ssrcs_.end()) {
     unsignaled_recv_ssrcs_.erase(it);
     return true;
   }
   return false;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE