Support the Aec dump for the APM in chrome

content/renderer/media/media_stream_audio_processor.cc

 // Copyright 2013 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/media_stream_audio_processor.h"
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "content/public/common/content_switches.h"
 #include "content/renderer/media/media_stream_audio_processor_options.h"
@@ skipping 122 matching lines @@
   const media::AudioParameters sink_params_;
 
   // TODO(xians): consider using SincResampler to save some memcpy.
   // Handles mixing and resampling between input and output parameters.
   media::AudioConverter audio_converter_;
   scoped_ptr<media::AudioBus> audio_wrapper_;
   scoped_ptr<media::AudioFifo> fifo_;
 };
 
 MediaStreamAudioProcessor::MediaStreamAudioProcessor(
-    const media::AudioParameters& source_params,
     const blink::WebMediaConstraints& constraints,
     int effects,
     WebRtcPlayoutDataSource* playout_data_source)
     : render_delay_ms_(0),
       playout_data_source_(playout_data_source),
       audio_mirroring_(false),
       typing_detected_(false) {
   capture_thread_checker_.DetachFromThread();
   render_thread_checker_.DetachFromThread();
   InitializeAudioProcessingModule(constraints, effects);
-  InitializeCaptureConverter(source_params);
 }
 
 MediaStreamAudioProcessor::~MediaStreamAudioProcessor() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   StopAudioProcessing();
 }
 
+void MediaStreamAudioProcessor::OnCaptureFormatChanged(
+    const media::AudioParameters& source_params) {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
+  // There is no need to hold a lock here since the caller guarantees that
+  // there is no more PushCaptureData() and ProcessAndConsumeData() callbacks
+  // on the capture thread.
+  InitializeCaptureConverter(source_params);
+
+  // Reset the |capture_thread_checker_| since the capture data will come from
+  // a new capture thread.
+  capture_thread_checker_.DetachFromThread();
+}
+
 void MediaStreamAudioProcessor::PushCaptureData(media::AudioBus* audio_source) {
   DCHECK(capture_thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(audio_source->channels(),
+            capture_converter_->source_parameters().channels());
+  DCHECK_EQ(audio_source->frames(),
+            capture_converter_->source_parameters().frames_per_buffer());
+
   if (audio_mirroring_ &&
       capture_converter_->source_parameters().channel_layout() ==
           media::CHANNEL_LAYOUT_STEREO) {
     // Swap the first and second channels.
     audio_source->SwapChannels(0, 1);
   }
 
   capture_converter_->Push(audio_source);
 }
 
@@ skipping 14 matching lines @@
 }
 
 const media::AudioParameters& MediaStreamAudioProcessor::InputFormat() const {
   return capture_converter_->source_parameters();
 }
 
 const media::AudioParameters& MediaStreamAudioProcessor::OutputFormat() const {
   return capture_converter_->sink_parameters();
 }
 
+void MediaStreamAudioProcessor::StartAecDump(
+    const base::PlatformFile& aec_dump_file) {
+  if (audio_processing_)
+    StartEchoCancellationDump(audio_processing_.get(), aec_dump_file);
+}
+
+void MediaStreamAudioProcessor::StopAecDump() {
+  if (audio_processing_)
+    StopEchoCancellationDump(audio_processing_.get());
+}
+
 void MediaStreamAudioProcessor::OnPlayoutData(media::AudioBus* audio_bus,
                                               int sample_rate,
                                               int audio_delay_milliseconds) {
   DCHECK(render_thread_checker_.CalledOnValidThread());
 #if defined(OS_ANDROID) || defined(OS_IOS)
   DCHECK(audio_processing_->echo_control_mobile()->is_enabled());
 #else
   DCHECK(audio_processing_->echo_cancellation()->is_enabled());
 #endif
 
@@ skipping 117 matching lines @@
   // has to be done after all the needed components are enabled.
   CHECK_EQ(audio_processing_->set_sample_rate_hz(kAudioProcessingSampleRate),
            0);
   CHECK_EQ(audio_processing_->set_num_channels(kAudioProcessingNumberOfChannel,
                                                kAudioProcessingNumberOfChannel),
            0);
 }
 
 void MediaStreamAudioProcessor::InitializeCaptureConverter(
     const media::AudioParameters& source_params) {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(source_params.IsValid());
 
   // Create and initialize audio converter for the source data.
   // When the webrtc AudioProcessing is enabled, the sink format of the
   // converter will be the same as the post-processed data format, which is
   // 32k mono for desktops and 16k mono for Android. When the AudioProcessing
   // is disabled, the sink format will be the same as the source format.
   const int sink_sample_rate = audio_processing_ ?
       kAudioProcessingSampleRate : source_params.sample_rate();
   const media::ChannelLayout sink_channel_layout = audio_processing_ ?
@@ skipping 93 matching lines @@
   // Return 0 if the volume has not been changed, otherwise return the new
   // volume.
   return (agc->stream_analog_level() == volume) ?
       0 : agc->stream_analog_level();
 }
 
 void MediaStreamAudioProcessor::StopAudioProcessing() {
   if (!audio_processing_.get())
     return;
 
+  StopAecDump();
+
   if (playout_data_source_)
     playout_data_source_->RemovePlayoutSink(this);
 
   audio_processing_.reset();
 }
 
 }  // namespace content