Support the Aec dump for the APM in chrome

content/renderer/media/webrtc_audio_device_impl.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/webrtc_audio_device_impl.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
+#include "base/platform_file.h"
 #include "base/strings/string_util.h"
 #include "base/win/windows_version.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
 #include "content/renderer/media/webrtc_audio_renderer.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/audio/audio_parameters.h"
 #include "media/audio/sample_rates.h"
 
 using media::AudioParameters;
 using media::ChannelLayout;
 
 namespace content {
 
 WebRtcAudioDeviceImpl::WebRtcAudioDeviceImpl()
     : ref_count_(0),
       audio_transport_callback_(NULL),
       input_delay_ms_(0),
       output_delay_ms_(0),
       initialized_(false),
       playing_(false),
       recording_(false),
-      microphone_volume_(0) {
+      microphone_volume_(0),
+      aec_dump_file_(base::kInvalidPlatformFileValue) {
   DVLOG(1) << "WebRtcAudioDeviceImpl::WebRtcAudioDeviceImpl()";
 }
 
 WebRtcAudioDeviceImpl::~WebRtcAudioDeviceImpl() {
   DVLOG(1) << "WebRtcAudioDeviceImpl::~WebRtcAudioDeviceImpl()";
   DCHECK(thread_checker_.CalledOnValidThread());
   Terminate();
 }
 
 int32_t WebRtcAudioDeviceImpl::AddRef() {
@@ skipping 166 matching lines @@
   // Calling Terminate() multiple times in a row is OK.
   if (!initialized_)
     return 0;
 
   StopRecording();
   StopPlayout();
 
   DCHECK(!renderer_.get() || !renderer_->IsStarted())
       << "The shared audio renderer shouldn't be running";
 
+  DisableAecDump();
+
   capturers_.clear();
 
   initialized_ = false;
   return 0;
 }
 
 bool WebRtcAudioDeviceImpl::Initialized() const {
   return initialized_;
 }
 
@@ skipping 191 matching lines @@
   renderer_ = renderer;
   return true;
 }
 
 void WebRtcAudioDeviceImpl::AddAudioCapturer(
     const scoped_refptr<WebRtcAudioCapturer>& capturer) {
   DVLOG(1) << "WebRtcAudioDeviceImpl::AddAudioCapturer()";
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(capturer.get());
   DCHECK(!capturer->device_id().empty());
-  base::AutoLock auto_lock(lock_);
-  DCHECK(std::find(capturers_.begin(), capturers_.end(), capturer) ==
-      capturers_.end());
-  capturers_.push_back(capturer);
+  {
+    base::AutoLock auto_lock(lock_);
+    DCHECK(std::find(capturers_.begin(), capturers_.end(), capturer) ==
+        capturers_.end());
+    capturers_.push_back(capturer);
+  }
+
+  // The default capturer might have been changed, call StartAecDump() to start
+  // the Aec dump on the new default capturer in case Aec dump has been enabled.
+  StartAecDump();
 }
 
 void WebRtcAudioDeviceImpl::RemoveAudioCapturer(
     const scoped_refptr<WebRtcAudioCapturer>& capturer) {
   DVLOG(1) << "WebRtcAudioDeviceImpl::AddAudioCapturer()";
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(capturer.get());
-  base::AutoLock auto_lock(lock_);
-  capturers_.remove(capturer);
+  {
+    base::AutoLock auto_lock(lock_);
+    capturers_.remove(capturer);
+  }
+
+  // The default capturer might have been changed, call StartAecDump() to start
+  // the Aec dump on the new default capturer in case Aec dump has been enabled.
+  StartAecDump();

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

Hmm, we re-use |aec_dump_file_| but that likely won't work. The APM that has
previously started dump will close the file stream when stopping the dump and
with that the file descriptor is closed (on posix at least).

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

Done.

 }
 
 scoped_refptr<WebRtcAudioCapturer>
 WebRtcAudioDeviceImpl::GetDefaultCapturer() const {
   base::AutoLock auto_lock(lock_);
   // Use the last |capturer| which is from the latest getUserMedia call as
   // the default capture device.
   for (CapturerList::const_reverse_iterator iter = capturers_.rbegin();
        iter != capturers_.rend(); ++iter) {
     return *iter;
@@ skipping 27 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   // If there is no capturer or there are more than one open capture devices,
   // return false.
   if (capturers_.empty() || capturers_.size() > 1)
     return false;
 
   return GetDefaultCapturer()->GetPairedOutputParameters(
       session_id, output_sample_rate, output_frames_per_buffer);
 }
 
+void WebRtcAudioDeviceImpl::EnableAecDump(
+    IPC::PlatformFileForTransit file_handle) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(aec_dump_file_, base::kInvalidPlatformFileValue);
+  aec_dump_file_ = IPC::PlatformFileForTransitToPlatformFile(file_handle);
+  DCHECK_NE(aec_dump_file_, base::kInvalidPlatformFileValue);
+  StartAecDump();
+}
+
+void WebRtcAudioDeviceImpl::DisableAecDump() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (aec_dump_file_ == base::kInvalidPlatformFileValue)
+    return;
+
+  StopAecDump();
+  base::ClosePlatformFile(aec_dump_file_);
+  aec_dump_file_ = base::kInvalidPlatformFileValue;
+}
+
+void WebRtcAudioDeviceImpl::StartAecDump() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (aec_dump_file_ == base::kInvalidPlatformFileValue)
+    return;
+
+  scoped_refptr<WebRtcAudioCapturer> default_capturer(GetDefaultCapturer());
+  if (!default_capturer)
+    return;
+
+  // We support Aec dump on only one APM. Loop through all the non-default
+  // capturers and call StopAecDump().
+  for (CapturerList::const_iterator iter = capturers_.begin();
+       iter != capturers_.end(); ++iter) {
+    if (*iter != default_capturer)
+      (*iter)->StopAecDump();
+   }
+
+  // Start the Aec dump on the default capturer.
+  default_capturer->StartAecDump(aec_dump_file_);
+}
+
+void WebRtcAudioDeviceImpl::StopAecDump() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  // Only the default capturer can have the Aec dump.
+  scoped_refptr<WebRtcAudioCapturer> default_capturer(GetDefaultCapturer());
+  if (default_capturer)
+    default_capturer->StopAecDump();
+}
+
 }  // namespace content