Enable platform echo cancellation through the AudioRecord path.

content/renderer/media/webrtc_audio_capturer.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/webrtc_audio_capturer.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
@@ skipping 86 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TrackOwner);
 };
 
 // static
 scoped_refptr<WebRtcAudioCapturer> WebRtcAudioCapturer::CreateCapturer() {
   scoped_refptr<WebRtcAudioCapturer> capturer = new WebRtcAudioCapturer();
   return capturer;
 }
 
 void WebRtcAudioCapturer::Reconfigure(int sample_rate,
-                                      media::ChannelLayout channel_layout) {
+                                      media::ChannelLayout channel_layout,
+                                      bool use_platform_aec) {
   DCHECK(thread_checker_.CalledOnValidThread());
   int buffer_size = GetBufferSize(sample_rate);
   DVLOG(1) << "Using WebRTC input buffer size: " << buffer_size;
 
   media::AudioParameters::Format format =
       media::AudioParameters::AUDIO_PCM_LOW_LATENCY;
 
   // bits_per_sample is always 16 for now.
   int bits_per_sample = 16;
   media::AudioParameters params(format, channel_layout, sample_rate,
                                 bits_per_sample, buffer_size);
+  params.set_use_platform_aec(use_platform_aec);
 
   {
     base::AutoLock auto_lock(lock_);
     params_ = params;
 
     // Copy |tracks_| to |tracks_to_notify_format_| to notify all the tracks
     // on the new format.
     tracks_to_notify_format_ = tracks_;
   }
 }
 
 bool WebRtcAudioCapturer::Initialize(int render_view_id,
                                      media::ChannelLayout channel_layout,
                                      int sample_rate,
                                      int buffer_size,
                                      int session_id,
                                      const std::string& device_id,
                                      int paired_output_sample_rate,
-                                     int paired_output_frames_per_buffer) {
+                                     int paired_output_frames_per_buffer,
+                                     bool use_platform_aec) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "WebRtcAudioCapturer::Initialize()";
 
   DVLOG(1) << "Audio input hardware channel layout: " << channel_layout;
   UMA_HISTOGRAM_ENUMERATION("WebRTC.AudioInputChannelLayout",
                             channel_layout, media::CHANNEL_LAYOUT_MAX);
 
   WebRtcLogMessage(base::StringPrintf(
       "WAC::Initialize. render_view_id=%d"
       ", channel_layout=%d, sample_rate=%d, buffer_size=%d"
@@ skipping 45 matching lines @@
           &kValidInputRates[arraysize(kValidInputRates)]) {
     DLOG(ERROR) << sample_rate << " is not a supported input rate.";
     return false;
   }
 
   // Create and configure the default audio capturing source. The |source_|
   // will be overwritten if an external client later calls SetCapturerSource()
   // providing an alternative media::AudioCapturerSource.
   SetCapturerSource(AudioDeviceFactory::NewInputDevice(render_view_id),
                     channel_layout,
-                    static_cast<float>(sample_rate));
+                    static_cast<float>(sample_rate),
+                    use_platform_aec);
 
   return true;
 }
 
 WebRtcAudioCapturer::WebRtcAudioCapturer()
     : running_(false),
       render_view_id_(-1),
       hardware_buffer_size_(0),
       session_id_(0),
       volume_(0),
@@ skipping 65 matching lines @@
     stop_source = tracks_.empty();
   }
 
   if (stop_source)
     Stop();
 }
 
 void WebRtcAudioCapturer::SetCapturerSource(
     const scoped_refptr<media::AudioCapturerSource>& source,
     media::ChannelLayout channel_layout,
-    float sample_rate) {
+    float sample_rate,
+    bool use_platform_aec) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "SetCapturerSource(channel_layout=" << channel_layout << ","
-           << "sample_rate=" << sample_rate << ")";
+           << "sample_rate=" << sample_rate << "," << "use_platform_aec="
+           << use_platform_aec << ")";
   scoped_refptr<media::AudioCapturerSource> old_source;
   bool restart_source = false;
   {
     base::AutoLock auto_lock(lock_);
     if (source_.get() == source.get())
       return;
 
     source_.swap(old_source);
     source_ = source;
 
     // Reset the flag to allow starting the new source.
     restart_source = running_;
     running_ = false;
   }
 
   DVLOG(1) << "Switching to a new capture source.";
   if (old_source.get())
     old_source->Stop();
 
   // Dispatch the new parameters both to the sink(s) and to the new source.
   // The idea is to get rid of any dependency of the microphone parameters
   // which would normally be used by default.
-  Reconfigure(sample_rate, channel_layout);
+  Reconfigure(sample_rate, channel_layout, use_platform_aec);
 
   // Make sure to grab the new parameters in case they were reconfigured.
   media::AudioParameters params = audio_parameters();
   if (source.get())
     source->Initialize(params, this, session_id_);
 
   if (restart_source)
     Start();
 }
 
@@ skipping 18 matching lines @@
 
   // Do nothing if the current buffer size is the WebRtc native buffer size.
   media::AudioParameters params = audio_parameters();
   if (GetBufferSize(params.sample_rate()) == params.frames_per_buffer())
     return;
 
   // Create a new audio stream as source which will open the hardware using
   // WebRtc native buffer size.
   SetCapturerSource(AudioDeviceFactory::NewInputDevice(render_view_id),
                     params.channel_layout(),
-                    static_cast<float>(params.sample_rate()));
+                    static_cast<float>(params.sample_rate()),
+                    params.use_platform_aec());
 }
 
 void WebRtcAudioCapturer::Start() {
   DVLOG(1) << "WebRtcAudioCapturer::Start()";
   base::AutoLock auto_lock(lock_);
   if (running_ || !source_)
     return;
 
   // Start the data source, i.e., start capturing data from the current source.
   // We need to set the AGC control before starting the stream.
@@ skipping 145 matching lines @@
 
 void WebRtcAudioCapturer::GetAudioProcessingParams(
     base::TimeDelta* delay, int* volume, bool* key_pressed) {
   base::AutoLock auto_lock(lock_);
   *delay = audio_delay_;
   *volume = volume_;
   *key_pressed = key_pressed_;
 }
 
 }  // namespace content