Start using APM directly in WVoMC (not VoEAudioProcessing)

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 535 matching lines @@
   RTC_CHECK_EQ(0, voe_wrapper_->base()->Init(adm_.get(), nullptr,
                                              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_);
+
   // Save the default AGC configuration settings. This must happen before
   // calling ApplyOptions or the default will be overwritten.
   int error = voe_wrapper_->processing()->GetAgcConfig(default_agc_config_);
   RTC_DCHECK_EQ(0, error);
 
   // Set default engine options.
   {
     AudioOptions options;
     options.echo_cancellation = rtc::Optional<bool>(true);
     options.auto_gain_control = rtc::Optional<bool>(true);
@@ skipping 304 matching lines @@
                << (!!level_control_ ? *level_control_ : -1);
   webrtc::AudioProcessing::Config apm_config;
   if (level_control_) {
     apm_config.level_controller.enabled = *level_control_;
     if (options.level_control_initial_peak_level_dbfs) {
       apm_config.level_controller.initial_peak_level_dbfs =
           *options.level_control_initial_peak_level_dbfs;
     }
   }
 
-  // We check audioproc for the benefit of tests, since FakeWebRtcVoiceEngine
-  // returns NULL on audio_processing().
-  webrtc::AudioProcessing* audioproc = voe_wrapper_->base()->audio_processing();
-  if (audioproc) {
-    audioproc->SetExtraOptions(config);
-    audioproc->ApplyConfig(apm_config);
-  }
+  apm()->SetExtraOptions(config);
+  apm()->ApplyConfig(apm_config);
 
   if (options.recording_sample_rate) {
     LOG(LS_INFO) << "Recording sample rate is "
                  << *options.recording_sample_rate;
     if (adm()->SetRecordingSampleRate(*options.recording_sample_rate)) {
       LOG_RTCERR1(SetRecordingSampleRate, *options.recording_sample_rate);
     }
   }
 
   if (options.playout_sample_rate) {
@@ skipping 12 matching lines @@
   int in_id = kDefaultAudioDeviceId;
   int out_id = kDefaultAudioDeviceId;
   LOG(LS_INFO) << "Setting microphone to (id=" << in_id
                << ") and speaker to (id=" << out_id << ")";
 
   bool ret = true;
   if (voe_wrapper_->hw()->SetRecordingDevice(in_id) == -1) {
     LOG_RTCERR1(SetRecordingDevice, in_id);
     ret = false;
   }
-  webrtc::AudioProcessing* ap = voe()->base()->audio_processing();
-  if (ap) {
-    ap->Initialize();
-  }
+
+  apm()->Initialize();
 
   if (voe_wrapper_->hw()->SetPlayoutDevice(out_id) == -1) {
     LOG_RTCERR1(SetPlayoutDevice, out_id);
     ret = false;
   }
 
   if (ret) {
     LOG(LS_INFO) << "Set microphone to (id=" << in_id
                  << ") and speaker to (id=" << out_id << ")";
   }
@@ skipping 100 matching lines @@
                                      int64_t max_size_bytes) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   FILE* aec_dump_file_stream = rtc::FdopenPlatformFileForWriting(file);
   if (!aec_dump_file_stream) {
     LOG(LS_ERROR) << "Could not open AEC dump file stream.";
     if (!rtc::ClosePlatformFile(file))
       LOG(LS_WARNING) << "Could not close file.";
     return false;
   }
   StopAecDump();
-  if (voe_wrapper_->base()->audio_processing()->StartDebugRecording(
-          aec_dump_file_stream, max_size_bytes) !=
+  if (apm()->StartDebugRecording(aec_dump_file_stream, max_size_bytes) !=
       webrtc::AudioProcessing::kNoError) {
     LOG_RTCERR0(StartDebugRecording);
     fclose(aec_dump_file_stream);
     return false;
   }
   is_dumping_aec_ = true;
   return true;
 }
 
 void WebRtcVoiceEngine::StartAecDump(const std::string& filename) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   if (!is_dumping_aec_) {
     // Start dumping AEC when we are not dumping.
-    if (voe_wrapper_->base()->audio_processing()->StartDebugRecording(
-            filename.c_str(), -1) != webrtc::AudioProcessing::kNoError) {
+    if (apm()->StartDebugRecording(filename.c_str(), -1) !=
+        webrtc::AudioProcessing::kNoError) {
       LOG_RTCERR1(StartDebugRecording, filename.c_str());
     } else {
       is_dumping_aec_ = true;
     }
   }
 }
 
 void WebRtcVoiceEngine::StopAecDump() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   if (is_dumping_aec_) {
     // Stop dumping AEC when we are dumping.
-    if (voe_wrapper_->base()->audio_processing()->StopDebugRecording() !=
-        webrtc::AudioProcessing::kNoError) {
+    if (apm()->StopDebugRecording() != webrtc::AudioProcessing::kNoError) {
       LOG_RTCERR0(StopDebugRecording);
     }
     is_dumping_aec_ = false;
   }
 }
 
 int WebRtcVoiceEngine::CreateVoEChannel() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   return voe_wrapper_->base()->CreateChannel(channel_config_);
 }
 
 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_;
+}
+
 AudioCodecs WebRtcVoiceEngine::CollectRecvCodecs() const {
   PayloadTypeMapper mapper;
   AudioCodecs out;
   const std::vector<webrtc::AudioCodecSpec>& specs =
       decoder_factory_->GetSupportedDecoders();
 
   // Only generate CN payload types for these clockrates
   std::map<int, bool, std::greater<int>> generate_cn = {{ 8000,  false },
                                                         { 16000, false },
                                                         { 32000, false }};
@@ skipping 1271 matching lines @@
 
   // TODO(solenberg):
   // We set the AGC to mute state only when all the channels are muted.
   // This implementation is not ideal, instead we should signal the AGC when
   // the mic channel is muted/unmuted. We can't do it today because there
   // is no good way to know which stream is mapping to the mic channel.
   bool all_muted = muted;
   for (const auto& kv : send_streams_) {
     all_muted = all_muted && kv.second->muted();
   }
+  engine()->apm()->set_output_will_be_muted(all_muted);
 
-  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 (!kv.second->SetMaxSendBitrate(max_send_bitrate_bps_)) {
       success = false;
@@ skipping 119 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