Support the Aec dump for the APM in chrome

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 169 matching lines @@
                 device_info_.device.input.sample_rate) ==
           &kValidInputRates[arraysize(kValidInputRates)]) {
     DLOG(ERROR) << device_info_.device.input.sample_rate
                 << " is not a supported input rate.";
     return false;
   }
 
   // Create and configure the default audio capturing source.
   SetCapturerSource(AudioDeviceFactory::NewInputDevice(render_view_id_),
                     channel_layout,
-                    static_cast<float>(device_info_.device.input.sample_rate),
-                    device_info_.device.input.effects,
-                    constraints_);
+                    static_cast<float>(device_info_.device.input.sample_rate));
 
   // Add the capturer to the WebRtcAudioDeviceImpl since it needs some hardware
   // information from the capturer.
   if (audio_device_)
     audio_device_->AddAudioCapturer(this);
 
   return true;
 }
 
 WebRtcAudioCapturer::WebRtcAudioCapturer(
     int render_view_id,
     const StreamDeviceInfo& device_info,
     const blink::WebMediaConstraints& constraints,
     WebRtcAudioDeviceImpl* audio_device)
     : constraints_(constraints),
+      audio_processor_(new MediaStreamAudioProcessor(
+          constraints, device_info.device.input.effects, audio_device)),
       running_(false),
       render_view_id_(render_view_id),
       device_info_(device_info),
       volume_(0),
       peer_connection_mode_(false),
       key_pressed_(false),
       need_audio_processing_(false),
       audio_device_(audio_device) {
   DVLOG(1) << "WebRtcAudioCapturer::WebRtcAudioCapturer()";
 }
@@ skipping 36 matching lines @@
   // Clear the delegate to ensure that no more capture callbacks will
   // be sent to this sink. Also avoids a possible crash which can happen
   // if this method is called while capturing is active.
   if (removed_item.get())
     removed_item->Reset();
 }
 
 void WebRtcAudioCapturer::SetCapturerSource(
     const scoped_refptr<media::AudioCapturerSource>& source,
     media::ChannelLayout channel_layout,
-    float sample_rate,
-    int effects,
-    const blink::WebMediaConstraints& constraints) {
+    float sample_rate) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "SetCapturerSource(channel_layout=" << channel_layout << ","
            << "sample_rate=" << sample_rate << ")";
   scoped_refptr<media::AudioCapturerSource> old_source;
   bool restart_source = false;
   {
     base::AutoLock auto_lock(lock_);
     if (source_.get() == source.get())
       return;
 
@@ skipping 10 matching lines @@
     old_source->Stop();
 
   // Dispatch the new parameters both to the sink(s) and to the new source,
   // also apply the new |constraints|.
   // The idea is to get rid of any dependency of the microphone parameters
   // which would normally be used by default.
   // bits_per_sample is always 16 for now.
   int buffer_size = GetBufferSize(sample_rate);
   media::AudioParameters params(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                                 channel_layout, 0, sample_rate,
-                                16, buffer_size, effects);
-  scoped_refptr<MediaStreamAudioProcessor> new_audio_processor(
-      new MediaStreamAudioProcessor(params, constraints, effects,
-                                    audio_device_));
+                                16, buffer_size,
+                                device_info_.device.input.effects);
+
   {
     base::AutoLock auto_lock(lock_);
-    audio_processor_ = new_audio_processor;
-    need_audio_processing_ = NeedsAudioProcessing(constraints, effects);
+    // Notify the |audio_processor_| of the new format.
+    audio_processor_->OnCaptureFormatChanged(params);
 
+    need_audio_processing_ = NeedsAudioProcessing(
+        constraints_, device_info_.device.input.effects);
     // Notify all tracks about the new format.
     tracks_.TagAll();
   }
 
   if (source.get())
     source->Initialize(params, this, session_id());
 
   if (restart_source)
     Start();
 }
@@ skipping 22 matching lines @@
   // Do nothing if the current buffer size is the WebRtc native buffer size.
   if (GetBufferSize(input_params.sample_rate()) ==
           input_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),
                     input_params.channel_layout(),
-                    static_cast<float>(input_params.sample_rate()),
-                    input_params.effects(),
-                    constraints_);
+                    static_cast<float>(input_params.sample_rate()));
 }
 
 void WebRtcAudioCapturer::Start() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   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.
   source_->SetAutomaticGainControl(true);
   source_->Start();
   running_ = true;
 }
 
 void WebRtcAudioCapturer::Stop() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "WebRtcAudioCapturer::Stop()";
   scoped_refptr<media::AudioCapturerSource> source;
   TrackList::ItemList tracks;
   {
     base::AutoLock auto_lock(lock_);
     if (!running_)
       return;
 
     source = source_;
     tracks = tracks_.Items();
     tracks_.Clear();
     running_ = false;
   }
 
   // Remove the capturer object from the WebRtcAudioDeviceImpl.
   if (audio_device_)
     audio_device_->RemoveAudioCapturer(this);
 
+  // Stop the Aec dump.
+  StopAecDump();
+
   for (TrackList::ItemList::const_iterator it = tracks.begin();
        it != tracks.end();
        ++it) {
     (*it)->Stop();
   }
 
   if (source.get())
     source->Stop();
 }
 
@@ skipping 30 matching lines @@
   // allows the user to set a scaling that is higher than 100%. It means that
   // even if the reported maximum levels is N, the actual microphone level can
   // go up to 1.5x*N and that corresponds to a normalized |volume| of 1.5x.
   DCHECK_LE(volume, 1.6);
 #endif
 
   TrackList::ItemList tracks;
   TrackList::ItemList tracks_to_notify_format;
   int current_volume = 0;
   base::TimeDelta audio_delay;
-  scoped_refptr<MediaStreamAudioProcessor> audio_processor;
   bool need_audio_processing = true;
   {
     base::AutoLock auto_lock(lock_);
     if (!running_)
       return;
 
     // Map internal volume range of [0.0, 1.0] into [0, 255] used by the
     // webrtc::VoiceEngine. webrtc::VoiceEngine will handle the case when the
     // volume is higher than 255.
     volume_ = static_cast<int>((volume * MaxVolume()) + 0.5);
     current_volume = volume_;
     audio_delay = base::TimeDelta::FromMilliseconds(audio_delay_milliseconds);
     audio_delay_ = audio_delay;
     key_pressed_ = key_pressed;
     tracks = tracks_.Items();
     tracks_.RetrieveAndClearTags(&tracks_to_notify_format);
-    audio_processor = audio_processor_;
 
     // Set the flag to turn on the audio processing in PeerConnection level.
     // Note that, we turn off the audio processing in PeerConnection if the
     // processor has already processed the data.
     need_audio_processing = need_audio_processing_ ?
-        !audio_processor->has_audio_processing() : false;
+        !audio_processor_->has_audio_processing() : false;
   }
 
-  DCHECK(audio_processor->InputFormat().IsValid());
+  DCHECK(audio_processor_->InputFormat().IsValid());
   DCHECK_EQ(audio_source->channels(),
-            audio_processor->InputFormat().channels());
+            audio_processor_->InputFormat().channels());
   DCHECK_EQ(audio_source->frames(),
-           audio_processor->InputFormat().frames_per_buffer());
+            audio_processor_->InputFormat().frames_per_buffer());
 
   // Notify the tracks on when the format changes. This will do nothing if
   // |tracks_to_notify_format| is empty.
   media::AudioParameters output_params = audio_processor_->OutputFormat();
   for (TrackList::ItemList::const_iterator it = tracks_to_notify_format.begin();
        it != tracks_to_notify_format.end(); ++it) {
     (*it)->OnSetFormat(output_params);
   }
 
   // Push the data to the processor for processing.
-  audio_processor->PushCaptureData(audio_source);
+  audio_processor_->PushCaptureData(audio_source);
 
   // Process and consume the data in the processor until there is not enough
   // data in the processor.
   int16* output = NULL;
   int new_volume = 0;
-  while (audio_processor->ProcessAndConsumeData(
+  while (audio_processor_->ProcessAndConsumeData(
       audio_delay, current_volume, key_pressed, &new_volume, &output)) {
     // Feed the post-processed data to the tracks.
     for (TrackList::ItemList::const_iterator it = tracks.begin();
          it != tracks.end(); ++it) {
       (*it)->Capture(output, audio_delay, current_volume, key_pressed,
                      need_audio_processing);
     }
 
     if (new_volume) {
       SetVolume(new_volume);
@@ skipping 61 matching lines @@
   *delay = audio_delay_;
   *volume = volume_;
   *key_pressed = key_pressed_;
 }
 
 void WebRtcAudioCapturer::SetCapturerSourceForTesting(
     const scoped_refptr<media::AudioCapturerSource>& source,
     media::AudioParameters params) {
   // Create a new audio stream as source which uses the new source.
   SetCapturerSource(source, params.channel_layout(),
-                    static_cast<float>(params.sample_rate()),
-                    params.effects(),
-                    constraints_);
+                    static_cast<float>(params.sample_rate()));
+}
+
+void WebRtcAudioCapturer::StartAecDump(
+    const base::PlatformFile& aec_dump_file) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_NE(aec_dump_file, base::kInvalidPlatformFileValue);
+  audio_processor_->StartAecDump(aec_dump_file);
+}
+
+void WebRtcAudioCapturer::StopAecDump() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  audio_processor_->StopAecDump();
 }
 
 }  // namespace content