Replace a few calls to VoEHardware with direct calls on the ADM, in WVoMC.

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 637 matching lines @@
   }
 #endif
 
   webrtc::VoEAudioProcessing* voep = voe_wrapper_->processing();
 
   if (options.echo_cancellation) {
     // Check if platform supports built-in EC. Currently only supported on
     // Android and in combination with Java based audio layer.
     // TODO(henrika): investigate possibility to support built-in EC also
     // in combination with Open SL ES audio.
-    const bool built_in_aec = voe_wrapper_->hw()->BuiltInAECIsAvailable();
+    const bool built_in_aec = adm()->BuiltInAECIsAvailable();
     if (built_in_aec) {
       // Built-in EC exists on this device and use_delay_agnostic_aec is not
       // overriding it. Enable/Disable it according to the echo_cancellation
       // audio option.
       const bool enable_built_in_aec =
           *options.echo_cancellation && !use_delay_agnostic_aec;
-      if (voe_wrapper_->hw()->EnableBuiltInAEC(enable_built_in_aec) == 0 &&
+      if (adm()->EnableBuiltInAEC(enable_built_in_aec) == 0 &&
           enable_built_in_aec) {
         // Disable internal software EC if built-in EC is enabled,
         // i.e., replace the software EC with the built-in EC.
         options.echo_cancellation = rtc::Optional<bool>(false);
         LOG(LS_INFO) << "Disabling EC since built-in EC will be used instead";
       }
     }
     if (voep->SetEcStatus(*options.echo_cancellation, ec_mode) == -1) {
       LOG_RTCERR2(SetEcStatus, *options.echo_cancellation, ec_mode);
       return false;
@@ skipping 11 matching lines @@
     if (ec_mode == webrtc::kEcAecm) {
       bool cn = options.aecm_generate_comfort_noise.value_or(false);
       if (voep->SetAecmMode(aecm_mode, cn) != 0) {
         LOG_RTCERR2(SetAecmMode, aecm_mode, cn);
         return false;
       }
     }
   }
 
   if (options.auto_gain_control) {
-    const bool built_in_agc = voe_wrapper_->hw()->BuiltInAGCIsAvailable();
+    const bool built_in_agc = adm()->BuiltInAGCIsAvailable();
     if (built_in_agc) {
-      if (voe_wrapper_->hw()->EnableBuiltInAGC(*options.auto_gain_control) ==
-              0 &&
+      if (adm()->EnableBuiltInAGC(*options.auto_gain_control) == 0 &&
           *options.auto_gain_control) {
         // Disable internal software AGC if built-in AGC is enabled,
         // i.e., replace the software AGC with the built-in AGC.
         options.auto_gain_control = rtc::Optional<bool>(false);
         LOG(LS_INFO) << "Disabling AGC since built-in AGC will be used instead";
       }
     }
     if (voep->SetAgcStatus(*options.auto_gain_control, agc_mode) == -1) {
       LOG_RTCERR2(SetAgcStatus, *options.auto_gain_control, agc_mode);
       return false;
@@ skipping 23 matching lines @@
     if (voe_wrapper_->processing()->SetAgcConfig(default_agc_config_) == -1) {
       LOG_RTCERR3(SetAgcConfig,
                   default_agc_config_.targetLeveldBOv,
                   default_agc_config_.digitalCompressionGaindB,
                   default_agc_config_.limiterEnable);
       return false;
     }
   }
 
   if (options.noise_suppression) {
-    const bool built_in_ns = voe_wrapper_->hw()->BuiltInNSIsAvailable();
+    const bool built_in_ns = adm()->BuiltInNSIsAvailable();
     if (built_in_ns) {
-      if (voe_wrapper_->hw()->EnableBuiltInNS(*options.noise_suppression) ==
-              0 &&
+      if (adm()->EnableBuiltInNS(*options.noise_suppression) == 0 &&
           *options.noise_suppression) {
         // Disable internal software NS if built-in NS is enabled,
         // i.e., replace the software NS with the built-in NS.
         options.noise_suppression = rtc::Optional<bool>(false);
         LOG(LS_INFO) << "Disabling NS since built-in NS will be used instead";
       }
     }
     if (voep->SetNsStatus(*options.noise_suppression, ns_mode) == -1) {
       LOG_RTCERR2(SetNsStatus, *options.noise_suppression, ns_mode);
       return false;
@@ skipping 83 matching lines @@
   // 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);
   }
 
   if (options.recording_sample_rate) {
     LOG(LS_INFO) << "Recording sample rate is "
                  << *options.recording_sample_rate;
-    if (voe_wrapper_->hw()->SetRecordingSampleRate(
-            *options.recording_sample_rate)) {
+    if (adm()->SetRecordingSampleRate(*options.recording_sample_rate)) {
       LOG_RTCERR1(SetRecordingSampleRate, *options.recording_sample_rate);
     }
   }
 
   if (options.playout_sample_rate) {
     LOG(LS_INFO) << "Playout sample rate is " << *options.playout_sample_rate;
-    if (voe_wrapper_->hw()->SetPlayoutSampleRate(
-            *options.playout_sample_rate)) {
+    if (adm()->SetPlayoutSampleRate(*options.playout_sample_rate)) {
       LOG_RTCERR1(SetPlayoutSampleRate, *options.playout_sample_rate);
     }
   }
 
   return true;
 }
 
 void WebRtcVoiceEngine::SetDefaultDevices() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
 #if !defined(WEBRTC_IOS)
@@ skipping 200 matching lines @@
     return;
   }
   LOG_RTCERR0(StopRtcEventLog);
 }
 
 int WebRtcVoiceEngine::CreateVoEChannel() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   return voe_wrapper_->base()->CreateChannel(voe_config_);
 }
 
+webrtc::AudioDeviceModule* WebRtcVoiceEngine::adm() {
+  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(adm_);
+  return adm_;
+}
+
 class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
     : public AudioSource::Sink {
  public:
   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),
@@ skipping 1469 matching lines @@
     }
   } else {
     LOG(LS_INFO) << "Stopping playout for channel #" << channel;
     engine()->voe()->base()->StopPlayout(channel);
   }
   return true;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE