Audio output debug recording.

media/audio/audio_output_resampler.h

 // 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.
 
 #ifndef MEDIA_AUDIO_AUDIO_OUTPUT_RESAMPLER_H_
 #define MEDIA_AUDIO_AUDIO_OUTPUT_RESAMPLER_H_
 
 #include <map>
 
 #include "base/macros.h"
@@ skipping 13 matching lines @@
 // AudioConverter class for details on the conversion process.
 //
 // AOR works by intercepting the AudioSourceCallback provided to StartStream()
 // and redirecting it through an AudioConverter instance.
 //
 // AOR will automatically fall back from AUDIO_PCM_LOW_LATENCY to
 // AUDIO_PCM_LINEAR if the output device fails to open at the requested output
 // parameters. If opening still fails, it will fallback to AUDIO_FAKE.
 class MEDIA_EXPORT AudioOutputResampler : public AudioOutputDispatcher {
  public:
+  // Callbacks for debug recording. RegisterDebugRecordingSourceCallback is used
+  // for registering a stream so that recording can be setup. The Unregister-
+  // counterpart ungeisters for shutting down recording. DebugRecordingCallback
+  // is used for passing data. The int in all callbacks is a unique id to
+  // identify the stream.
+  using RegisterDebugRecordingSourceCallback =
+      base::Callback<void(int, const AudioParameters&)>;
+  using UnregisterDebugRecordingSourceCallback = base::Callback<void(int)>;
+  using DebugRecordingCallback = base::Callback<void(int, AudioBus*)>;
+
   AudioOutputResampler(AudioManager* audio_manager,
                        const AudioParameters& input_params,
                        const AudioParameters& output_params,
                        const std::string& output_device_id,
                        const base::TimeDelta& close_delay);
   ~AudioOutputResampler() override;
 
   // AudioOutputDispatcher interface.
   AudioOutputProxy* CreateStreamProxy() override;
   bool OpenStream() override;
   bool StartStream(AudioOutputStream::AudioSourceCallback* callback,
                    AudioOutputProxy* stream_proxy) override;
   void StopStream(AudioOutputProxy* stream_proxy) override;
   void StreamVolumeSet(AudioOutputProxy* stream_proxy, double volume) override;
   void CloseStream(AudioOutputProxy* stream_proxy) override;
 
+  // Sets debug recording callbacks. See comment on callback definitions above.
+  void SetDebugRecordingCallbacks(
+      const RegisterDebugRecordingSourceCallback&
+          register_debug_recording_source_callback,
+      const UnregisterDebugRecordingSourceCallback&
+          unregister_debug_recording_source_callback,
+      const DebugRecordingCallback& debug_recording_callback);
+
  private:
   using CallbackMap =
       std::map<AudioOutputProxy*, std::unique_ptr<OnMoreDataConverter>>;
 
   // Converts low latency based output parameters into high latency
   // appropriate output parameters in error situations.
   void SetupFallbackParams();
 
   // Used to reinitialize |dispatcher_|.
   void Reinitialize();
@@ skipping 23 matching lines @@
   // Whether any streams have been opened through |dispatcher_|, if so we can't
   // fallback on future OpenStream() failures.
   bool streams_opened_;
 
   // The reinitialization timer provides a way to recover from temporary failure
   // states by clearing the dispatcher if all proxies have been closed and none
   // have been created within |close_delay_|.  Without this, audio may be lost
   // to a fake stream indefinitely for transient errors.
   base::Timer reinitialize_timer_;
 
+  // Used for audio debug recordings. See comment on callback definitions above.
+  RegisterDebugRecordingSourceCallback
+      register_debug_recording_source_callback_;
+  UnregisterDebugRecordingSourceCallback
+      unregister_debug_recording_source_callback_;
+  DebugRecordingCallback debug_recording_callback_;
+
   base::WeakPtrFactory<AudioOutputResampler> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(AudioOutputResampler);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_AUDIO_AUDIO_OUTPUT_RESAMPLER_H_