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 194 matching lines @@
     const blink::WebMediaConstraints& constraints,
     WebRtcAudioDeviceImpl* audio_device)
     : constraints_(constraints),
       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) {
+      audio_device_(audio_device),
+      aec_dump_file_(base::kInvalidPlatformFileValue) {
   DVLOG(1) << "WebRtcAudioCapturer::WebRtcAudioCapturer()";
 }
 
 WebRtcAudioCapturer::~WebRtcAudioCapturer() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(tracks_.IsEmpty());
   DCHECK(!running_);
   DVLOG(1) << "WebRtcAudioCapturer::~WebRtcAudioCapturer()";
 }
 
@@ skipping 65 matching lines @@
   // 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_));
+  // Start the Aec dump on the new audio processor object.
+  if (aec_dump_file_ != base::kInvalidPlatformFileValue)
+    new_audio_processor->StartAecDump(aec_dump_file_);
+
   {
     base::AutoLock auto_lock(lock_);
     audio_processor_ = new_audio_processor;
     need_audio_processing_ = NeedsAudioProcessing(constraints, effects);
 
     // Notify all tracks about the new format.
     tracks_.TagAll();
   }
 
   if (source.get())
@@ skipping 33 matching lines @@
   // 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_);
 }
 
 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 164 matching lines @@
 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_);
 }
 
+void WebRtcAudioCapturer::StartAecDump(
+    const base::PlatformFile& aec_dump_file) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_NE(aec_dump_file, base::kInvalidPlatformFileValue);
+  DCHECK(aec_dump_file_ == base::kInvalidPlatformFileValue ||
+         aec_dump_file_ == aec_dump_file);

[Henrik Grunell, 2014/03/06 10:12:20]

IS it expected to be called multiple times with the same argument?

[no longer working on chromium, 2014/03/06 18:57:21]

The code was removed.

+  // Do nothing if the Aec dump has been started.
+  if (aec_dump_file_ != base::kInvalidPlatformFileValue)
+    return;
+
+  audio_processor_->StartAecDump(aec_dump_file);
+  aec_dump_file_ = aec_dump_file;

[Henrik Grunell, 2014/03/06 10:12:20]

|audio_processor_| takes ownership of |aec_dump_file| so I don't think we should
store it in this class. What's the reason of doing that?

[no longer working on chromium, 2014/03/06 18:57:21]

Done.

+}
+
+void WebRtcAudioCapturer::StopAecDump() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (aec_dump_file_ == base::kInvalidPlatformFileValue)
+    return;
+
+  audio_processor_->StopAecDump();
+  aec_dump_file_ = base::kInvalidPlatformFileValue;
+}
+
 }  // namespace content