Implement writing mic audio input data to file for debugging purposes.

media/audio/audio_input_controller.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 "media/audio/audio_input_controller.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
+#include "media/audio/audio_input_writer.h"
 #include "media/base/user_input_monitor.h"
 
 using base::TimeDelta;
 
 namespace {
 
 const int kMaxInputChannels = 3;
 
 // TODO(henrika): remove usage of timers and add support for proper
 // notification of when the input device is removed.  This was originally added
@@ skipping 102 matching lines @@
       state_(CLOSED),
       sync_writer_(sync_writer),
       max_volume_(0.0),
       user_input_monitor_(user_input_monitor),
       agc_is_enabled_(agc_is_enabled),
 #if defined(AUDIO_POWER_MONITORING)
       power_measurement_is_enabled_(false),
       log_silence_state_(false),
       silence_state_(SILENCE_STATE_NO_MEASUREMENT),
 #endif
-      prev_key_down_count_(0) {
+      prev_key_down_count_(0),
+      input_writer_(nullptr) {
   DCHECK(creator_task_runner_.get());
 }
 
 AudioInputController::~AudioInputController() {
   DCHECK_EQ(state_, CLOSED);
 }
 
 // static
 scoped_refptr<AudioInputController> AudioInputController::Create(
     AudioManager* audio_manager,
@@ skipping 277 matching lines @@
   if (user_input_monitor_)
     user_input_monitor_->DisableKeyPressMonitoring();
 
 #if defined(AUDIO_POWER_MONITORING)
   // Send UMA stats if enabled.
   if (log_silence_state_)
     LogSilenceState(silence_state_);
   log_silence_state_ = false;
 #endif
 
+  input_writer_ = nullptr;
+
   state_ = CLOSED;
 }
 
 void AudioInputController::DoReportError() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (handler_)
     handler_->OnError(this, STREAM_ERROR);
 }
 
 void AudioInputController::DoSetVolume(double volume) {
@@ skipping 53 matching lines @@
   no_data_timer_->Start(
       FROM_HERE, base::TimeDelta::FromSeconds(kTimerResetIntervalSeconds),
       base::Bind(&AudioInputController::DoCheckForNoData,
       base::Unretained(this)));
 }
 
 void AudioInputController::OnData(AudioInputStream* stream,
                                   const AudioBus* source,
                                   uint32 hardware_delay_bytes,
                                   double volume) {
+  // |input_writer_| should only be accessed on the audio thread, but as a means
+  // to avoid copying data and posting on the audio thread, we just check for
+  // non-null here.
+  if (input_writer_) {
+    scoped_ptr<AudioBus> source_copy =
+        AudioBus::Create(source->channels(), source->frames());
+    source->CopyTo(source_copy.get());
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &AudioInputController::WriteInputDataForDebugging,
+            this,
+            base::Passed(&source_copy)));
+  }
+
   // Mark data as active to ensure that the periodic calls to
   // DoCheckForNoData() does not report an error to the event handler.
   SetDataIsActive(true);
 
   {
     base::AutoLock auto_lock(lock_);
     if (state_ != RECORDING)
       return;
   }
 
@@ skipping 99 matching lines @@
   handler_->OnLog(this, log_string);
 #endif
 }
 
 void AudioInputController::OnError(AudioInputStream* stream) {
   // Handle error on the audio-manager thread.
   task_runner_->PostTask(FROM_HERE, base::Bind(
       &AudioInputController::DoReportError, this));
 }
 
+void AudioInputController::EnableDebugRecording(
+    AudioInputWriter* input_writer) {
+  task_runner_->PostTask(FROM_HERE, base::Bind(
+      &AudioInputController::DoEnableDebugRecording,
+      this,
+      input_writer));
+}
+
+void AudioInputController::DisableDebugRecording(
+    const base::Closure& callback) {
+  DCHECK(creator_task_runner_->BelongsToCurrentThread());
+  DCHECK(!callback.is_null());
+
+  task_runner_->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(&AudioInputController::DoDisableDebugRecording,
+                 this),
+      callback);
+}
+
 void AudioInputController::DoStopCloseAndClearStream() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Allow calling unconditionally and bail if we don't have a stream to close.
   if (stream_ != NULL) {
     stream_->Stop();
     stream_->Close();
     stream_ = NULL;
   }
 
@@ skipping 32 matching lines @@
   }
 }
 
 void AudioInputController::LogSilenceState(SilenceState value) {
   UMA_HISTOGRAM_ENUMERATION("Media.AudioInputControllerSessionSilenceReport",
                             value,
                             SILENCE_STATE_MAX + 1);
 }
 #endif
 
+void AudioInputController::DoEnableDebugRecording(
+    AudioInputWriter* input_writer) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(!input_writer_);
+  input_writer_ = input_writer;
+}
+
+void AudioInputController::DoDisableDebugRecording() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  input_writer_ = nullptr;
+}
+
+void AudioInputController::WriteInputDataForDebugging(
+    scoped_ptr<AudioBus> data) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  if (input_writer_)
+    input_writer_->Write(data.Pass());
+}
+
 }  // namespace media