Audio output debug recording.

media/audio/pulse/pulse_output.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/pulse/pulse_output.h"
 
 #include <pulse/pulseaudio.h>
 #include <stdint.h>
 
+#include "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
+#include "media/audio/audio_debug_recording_helper.h"
 #include "media/audio/audio_device_description.h"
+#include "media/audio/audio_file_writer.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/audio/pulse/pulse_util.h"
 #include "media/base/audio_sample_types.h"
 
 namespace media {
 
 using pulse::AutoPulseLock;
 using pulse::WaitForOperationCompletion;
 
 // static, pa_stream_notify_cb
@@ skipping 28 matching lines @@
                               // want 32 because we're outputting
                               // floats.
                               32,
                               params.frames_per_buffer())),
       device_id_(device_id),
       manager_(manager),
       pa_context_(NULL),
       pa_mainloop_(NULL),
       pa_stream_(NULL),
       volume_(1.0f),
-      source_callback_(NULL) {
+      source_callback_(NULL),
+      debug_recording_helper_(base::MakeUnique<AudioDebugRecordingHelper>(

[o1ka, 2017/01/20 11:36:26]

Set it to nullptr for non-webrtc-enabled builds?

[Henrik Grunell, 2017/01/26 10:25:09]

Good point. That should be the right things to do. Right now, recording can only
be enabled in WebRTC-enabled builds. Will do that.

+          manager,
+          manager_->GetTaskRunner())) {
   CHECK(params_.IsValid());
   audio_bus_ = AudioBus::Create(params_);
 }
 
 PulseAudioOutputStream::~PulseAudioOutputStream() {
   // All internal structures should already have been freed in Close(), which
   // calls AudioManagerBase::ReleaseOutputStream() which deletes this object.
   DCHECK(!pa_stream_);
   DCHECK(!pa_context_);
   DCHECK(!pa_mainloop_);
@@ skipping 77 matching lines @@
       if (frames_filled < audio_bus_->frames()) {
         audio_bus_->ZeroFramesPartial(
             frames_filled, audio_bus_->frames() - frames_filled);
       }
 
       audio_bus_->Scale(volume_);
       audio_bus_->ToInterleaved<Float32SampleTypeTraits>(
           audio_bus_->frames(), reinterpret_cast<float*>(buffer));
     } else {
       memset(buffer, 0, bytes_to_fill);
+
+      // If we'll write the data to a debug file, also zero out the |audio_bus_|
+      // as it will be copied.
+      if (debug_recording_helper_->WillWrite())
+        audio_bus_->Zero();
     }
 
     if (pa_stream_write(pa_stream_, buffer, bytes_to_fill, NULL, 0LL,
                         PA_SEEK_RELATIVE) < 0) {
       if (source_callback_) {
         source_callback_->OnError(this);
       }
     }
 
     // NOTE: As mentioned above, |bytes_remaining| may be negative after this.
     bytes_remaining -= bytes_to_fill;
 
+    debug_recording_helper_->MaybeWrite(audio_bus_.get());
+
     // Despite telling Pulse to only request certain buffer sizes, it will not
     // always obey.  In these cases we need to avoid back to back reads from
     // the renderer as it won't have time to complete the request.
     //
     // We can't defer the callback as Pulse will never call us again until we've
     // satisfied writing the requested number of bytes.
     //
     // TODO(dalecurtis): It might be worth choosing the sleep duration based on
     // the hardware latency return above.  Watch http://crbug.com/366433 to see
     // if a more complicated wait process is necessary.  We may also need to see
@@ skipping 57 matching lines @@
   AutoPulseLock auto_lock(pa_mainloop_);
   volume_ = static_cast<float>(volume);
 }
 
 void PulseAudioOutputStream::GetVolume(double* volume) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   *volume = volume_;
 }
 
+void PulseAudioOutputStream::EnableDebugRecording(
+    const base::FilePath& file_name) {
+  debug_recording_helper_->EnableDebugRecording(params_, file_name);
+}
+
+void PulseAudioOutputStream::DisableDebugRecording() {
+  debug_recording_helper_->DisableDebugRecording();
+}
+
 }  // namespace media