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 10 matching lines @@
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/sample_rates.h"
 #include "media/base/audio_converter.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/limits.h"
 
 namespace media {
 
+namespace {
+// Global running id for OnMoreDataConverters. Used for debug recording.
+int g_next_stream_id = 1;
+}  // namespace
+
 class OnMoreDataConverter
     : public AudioOutputStream::AudioSourceCallback,
       public AudioConverter::InputCallback {
  public:
   OnMoreDataConverter(const AudioParameters& input_params,
                       const AudioParameters& output_params);
   ~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
   // called before Start().
   void Start(AudioOutputStream::AudioSourceCallback* callback);
 
   // Clears |source_callback_| and flushes the resampler.
   void Stop();
 
+  // Sets the debug recording callback which is used to pass data after
+  // resampling/buffering. Must be called before Start().
+  void SetDebugRecordingCallback(
+      const AudioOutputResampler::DebugRecordingCallback&
+          debug_recording_callback);
+
   bool started() const { return source_callback_ != nullptr; }
 
   bool error_occurred() const { return error_occurred_; }
 
+  int id() const { return id_; }
+
+  const AudioParameters& output_params() const { return output_params_; }
+
  private:
   // AudioConverter::InputCallback implementation.
   double ProvideInput(AudioBus* audio_bus, uint32_t frames_delayed) override;
 
   // Ratio of input bytes to output bytes used to correct playback delay with
   // regard to buffering and resampling.
   const double io_ratio_;
 
   // Source callback.
   AudioOutputStream::AudioSourceCallback* source_callback_;
 
   // Last |delay| and |delay_timestamp| received via OnMoreData(). Used to
   // correct playback delay in ProvideInput() before calling |source_callback_|.
   base::TimeDelta current_delay_;
   base::TimeTicks current_delay_timestamp_;
 
   const int input_samples_per_second_;
 
   // Handles resampling, buffering, and channel mixing between input and output
   // parameters.
   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.
+  // Information about input buffer sizes to be traced.
   const int input_buffer_size_;
-  const int output_buffer_size_;
+
+  // Output parameters used for buffer size tracing and for users to get.
+  const AudioParameters output_params_;
+
+  // Used for audio debug recordings. See comment on SetDebugRecordingCallback()
+  // above. |id_| is a unique running id used in the callback.
+  AudioOutputResampler::DebugRecordingCallback debug_recording_callback_;
+  const int id_;
 
   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(
@@ skipping 241 matching lines @@
     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_);
     callbacks_[stream_proxy] =
         base::WrapUnique<OnMoreDataConverter>(resampler_callback);
+    if (register_debug_recording_source_callback_)
+      register_debug_recording_source_callback_.Run(resampler_callback->id(),
+                                                    output_params_);
+    resampler_callback->SetDebugRecordingCallback(debug_recording_callback_);

[o1ka, 2017/01/25 17:47:00]

Sorry I can't process it :) Why can't you still call it EnableDebugRecording?

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

This only sets the callback to forward the data. The recording may or may not be
enabled.

   } else {
     resampler_callback = it->second.get();
   }
 
   resampler_callback->Start(callback);
   bool result = dispatcher_->StartStream(resampler_callback, stream_proxy);
   if (!result)
     resampler_callback->Stop();
   return result;
 }
@@ skipping 23 matching lines @@
 
   // Start the reinitialization timer if there are no active proxies and we're
   // not using the originally requested output parameters.  This allows us to
   // recover from transient output creation errors.
   if (!dispatcher_->HasOutputProxies() && callbacks_.empty() &&
       !output_params_.Equals(original_output_params_)) {
     reinitialize_timer_.Reset();
   }
 }
 
+void AudioOutputResampler::SetDebugRecordingCallbacks(
+    const RegisterDebugRecordingSourceCallback&
+        register_debug_recording_source_callback,
+    const UnregisterDebugRecordingSourceCallback&
+        unregister_debug_recording_source_callback,
+    const DebugRecordingCallback& debug_recording_callback) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+
+  register_debug_recording_source_callback_ =
+      register_debug_recording_source_callback;
+  unregister_debug_recording_source_callback_ =
+      unregister_debug_recording_source_callback;
+  debug_recording_callback_ = debug_recording_callback;
+
+  for (const auto& it : callbacks_) {
+    register_debug_recording_source_callback.Run(it.second->id(),

[o1ka, 2017/01/25 17:47:00]

Way too many callbacks :( the code is unreadable.

I find the previous version much cleaner. To separate debug recording logic you
can have a helper object, for example.

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

Yes, exactly what I thought myself later yesterday.

+                                                 it.second->output_params());
+    it.second->SetDebugRecordingCallback(debug_recording_callback);
+  }
+}
+
 void AudioOutputResampler::StopStreamInternal(
     const CallbackMap::value_type& item) {
   AudioOutputProxy* stream_proxy = item.first;
   OnMoreDataConverter* callback = item.second.get();
   DCHECK(callback->started());
 
   // Stop the underlying physical stream.
   dispatcher_->StopStream(stream_proxy);
 
   // Now that StopStream() has completed the underlying physical stream should
   // be stopped and no longer calling OnMoreData(), making it safe to Stop() the
   // 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();
+
+  if (unregister_debug_recording_source_callback_)
+    unregister_debug_recording_source_callback_.Run(callback->id());
 }
 
 OnMoreDataConverter::OnMoreDataConverter(const AudioParameters& input_params,
                                          const AudioParameters& output_params)
     : 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_params_(output_params),
+      id_(g_next_stream_id++) {
   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 11 matching lines @@
   CHECK(source_callback_);
   source_callback_ = nullptr;
   audio_converter_.RemoveInput(this);
 }
 
 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_);
+               input_buffer_size_, "output buffer size",
+               output_params_.frames_per_buffer());
   current_delay_ = delay;
   current_delay_timestamp_ = delay_timestamp;
   audio_converter_.Convert(dest);
 
+  if (debug_recording_callback_)
+    debug_recording_callback_.Run(id_, 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);
 }
 
+void OnMoreDataConverter::SetDebugRecordingCallback(
+    const AudioOutputResampler::DebugRecordingCallback&
+        debug_recording_callback) {
+  CHECK(!source_callback_);
+  debug_recording_callback_ = debug_recording_callback;
+}
+
 }  // namespace media