Audio output debug recording.

media/audio/audio_output_resampler.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_output_resampler.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 15 matching lines @@
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/limits.h"
 
 namespace media {
 
 class OnMoreDataConverter
     : public AudioOutputStream::AudioSourceCallback,
       public AudioConverter::InputCallback {
  public:
   OnMoreDataConverter(const AudioParameters& input_params,
-                      const AudioParameters& output_params);
+                      const AudioParameters& output_params,
+                      std::unique_ptr<AudioDebugRecorder> debug_recorder);
   ~OnMoreDataConverter() override;
 
   // AudioSourceCallback interface.
   int OnMoreData(base::TimeDelta delay,
                  base::TimeTicks delay_timestamp,
                  int prior_frames_skipped,
                  AudioBus* dest) override;
   void OnError(AudioOutputStream* stream) override;
 
   // Sets |source_callback_|.  If this is not a new object, then Stop() must be
@@ skipping 30 matching lines @@
   AudioConverter audio_converter_;
 
   // True if OnError() was ever called.  Should only be read if the underlying
   // stream has been stopped.
   bool error_occurred_;
 
   // Information about input and output buffer sizes to be traced.
   const int input_buffer_size_;
   const int output_buffer_size_;
 
+  // For audio debug recordings.
+  std::unique_ptr<AudioDebugRecorder> debug_recorder_;
+
   DISALLOW_COPY_AND_ASSIGN(OnMoreDataConverter);
 };
 
 // Record UMA statistics for hardware output configuration.
 static void RecordStats(const AudioParameters& output_params) {
   // Note the 'PRESUBMIT_IGNORE_UMA_MAX's below, these silence the PRESUBMIT.py
   // check for uma enum max usage, since we're abusing UMA_HISTOGRAM_ENUMERATION
   // to report a discrete value.
   UMA_HISTOGRAM_ENUMERATION(
       "Media.HardwareAudioBitsPerChannel",
@@ skipping 111 matching lines @@
 
   output_params_ = AudioParameters(
       AudioParameters::AUDIO_PCM_LINEAR, params_.channel_layout(),
       params_.sample_rate(), params_.bits_per_sample(),
       frames_per_buffer);
   device_id_ = "";
   Initialize();
 #endif
 }
 
-AudioOutputResampler::AudioOutputResampler(AudioManager* audio_manager,
-                                           const AudioParameters& input_params,
-                                           const AudioParameters& output_params,
-                                           const std::string& output_device_id,
-                                           const base::TimeDelta& close_delay)
+AudioOutputResampler::AudioOutputResampler(
+    AudioManager* audio_manager,
+    const AudioParameters& input_params,
+    const AudioParameters& output_params,
+    const std::string& output_device_id,
+    base::TimeDelta close_delay,
+    const RegisterDebugRecordingSourceCallback&
+        register_debug_recording_source_callback)
     : AudioOutputDispatcher(audio_manager, input_params, output_device_id),
       close_delay_(close_delay),
       output_params_(output_params),
       original_output_params_(output_params),
       streams_opened_(false),
       reinitialize_timer_(FROM_HERE,
                           close_delay_,
                           base::Bind(&AudioOutputResampler::Reinitialize,
                                      base::Unretained(this)),
                           false),
+      register_debug_recording_source_callback_(
+          register_debug_recording_source_callback),
       weak_factory_(this) {
   DCHECK(input_params.IsValid());
   DCHECK(output_params.IsValid());
   DCHECK_EQ(output_params_.format(), AudioParameters::AUDIO_PCM_LOW_LATENCY);
 
   // Record UMA statistics for the hardware configuration.
   RecordStats(output_params);
 
   Initialize();
 }
@@ skipping 91 matching lines @@
 }
 
 bool AudioOutputResampler::StartStream(
     AudioOutputStream::AudioSourceCallback* callback,
     AudioOutputProxy* stream_proxy) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   OnMoreDataConverter* resampler_callback = nullptr;
   CallbackMap::iterator it = callbacks_.find(stream_proxy);
   if (it == callbacks_.end()) {
-    resampler_callback = new OnMoreDataConverter(params_, output_params_);
+    // If a register callback has been given, register and pass the returned
+    // recoder to the converter. Data is fed to same recorder for the lifetime
+    // of the converter, which is until the stream is closed.
+    std::unique_ptr<AudioDebugRecorder> debug_recorder;
+    if (register_debug_recording_source_callback_) {
+      debug_recorder =
+          register_debug_recording_source_callback_.Run(output_params_);
+    }
+    resampler_callback = new OnMoreDataConverter(params_, output_params_,
+                                                 std::move(debug_recorder));

[o1ka, 2017/02/09 13:04:03]

Just
OnMoreDataConverter(params_, output_params_,
base::WrapUnique<AudioDebugRecorder>(register_debug_recording_source_callback_ ?
register_debug_recording_source_callback_.Run(...) : nullptr)); ?

To simplify it further, we can make |register_debug_recording_source_callback_|
to always be non-empty and just return null if no debug recording.

[Henrik Grunell, 2017/02/10 09:00:56]

Sounds good, changed to always running the callback.

     callbacks_[stream_proxy] =
         base::WrapUnique<OnMoreDataConverter>(resampler_callback);
   } else {
     resampler_callback = it->second.get();
   }
 
   resampler_callback->Start(callback);
   bool result = dispatcher_->StartStream(resampler_callback, stream_proxy);
   if (!result)
     resampler_callback->Stop();
@@ skipping 46 matching lines @@
   // OnMoreDataConverter.
   callback->Stop();
 
   // Destroy idle streams if any errors occurred during output; this ensures
   // bad streams will not be reused.  Note: Errors may occur during the Stop()
   // call above.
   if (callback->error_occurred())
     dispatcher_->CloseAllIdleStreams();
 }
 
-OnMoreDataConverter::OnMoreDataConverter(const AudioParameters& input_params,
-                                         const AudioParameters& output_params)
+OnMoreDataConverter::OnMoreDataConverter(
+    const AudioParameters& input_params,
+    const AudioParameters& output_params,
+    std::unique_ptr<AudioDebugRecorder> debug_recorder)
     : io_ratio_(static_cast<double>(input_params.GetBytesPerSecond()) /
                 output_params.GetBytesPerSecond()),
       source_callback_(nullptr),
       input_samples_per_second_(input_params.sample_rate()),
       audio_converter_(input_params, output_params, false),
       error_occurred_(false),
       input_buffer_size_(input_params.frames_per_buffer()),
-      output_buffer_size_(output_params.frames_per_buffer()) {
+      output_buffer_size_(output_params.frames_per_buffer()),
+      debug_recorder_(std::move(debug_recorder)) {
   RecordRebufferingStats(input_params, output_params);
 }
 
 OnMoreDataConverter::~OnMoreDataConverter() {
   // Ensure Stop() has been called so we don't end up with an AudioOutputStream
   // calling back into OnMoreData() after destruction.
   CHECK(!source_callback_);
 }
 
 void OnMoreDataConverter::Start(
@@ skipping 16 matching lines @@
 int OnMoreDataConverter::OnMoreData(base::TimeDelta delay,
                                     base::TimeTicks delay_timestamp,
                                     int /* prior_frames_skipped */,
                                     AudioBus* dest) {
   TRACE_EVENT2("audio", "OnMoreDataConverter::OnMoreData", "input buffer size",
                input_buffer_size_, "output buffer size", output_buffer_size_);
   current_delay_ = delay;
   current_delay_timestamp_ = delay_timestamp;
   audio_converter_.Convert(dest);
 
+  if (debug_recorder_)
+    debug_recorder_->OnData(dest);
+
   // Always return the full number of frames requested, ProvideInput()
   // will pad with silence if it wasn't able to acquire enough data.
   return dest->frames();
 }
 
 double OnMoreDataConverter::ProvideInput(AudioBus* dest,
                                          uint32_t frames_delayed) {
   base::TimeDelta new_delay =
       current_delay_ + AudioTimestampHelper::FramesToTime(
                            frames_delayed, input_samples_per_second_);
   // Retrieve data from the original callback.
   const int frames = source_callback_->OnMoreData(
       new_delay, current_delay_timestamp_, 0, dest);
 
   // Zero any unfilled frames if anything was filled, otherwise we'll just
   // return a volume of zero and let AudioConverter drop the output.
   if (frames > 0 && frames < dest->frames())
     dest->ZeroFramesPartial(frames, dest->frames() - frames);
   return frames > 0 ? 1 : 0;
 }
 
 void OnMoreDataConverter::OnError(AudioOutputStream* stream) {
   error_occurred_ = true;
   source_callback_->OnError(stream);
 }
 
 }  // namespace media