blob: fefc018b4b0991aa023f8cbb83d770e750a40c3d [file] [log] [blame]
// 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 <stdint.h>
#include <string>
#include "base/callback.h"
#include "base/memory/ref_counted.h"
#include "media/base/audio_bus.h"
#include "media/base/audio_parameters.h"
#include "media/base/output_device_info.h"
namespace media {
// AudioRendererSink is an interface representing the end-point for
// rendered audio. An implementation is expected to
// periodically call Render() on a callback object.
class AudioRendererSink
: public base::RefCountedThreadSafe<media::AudioRendererSink> {
class RenderCallback {
// Attempts to completely fill all channels of |dest|, returns actual
// number of frames filled. |prior_frames_skipped| contains the number of
// frames
// the consumer has skipped, if any.
// The |delay| argument represents audio device output latency,
// |delay_timestamp| represents the time when |delay| was obtained.
virtual int Render(base::TimeDelta delay,
base::TimeTicks delay_timestamp,
int prior_frames_skipped,
AudioBus* dest) = 0;
// Signals an error has occurred.
virtual void OnRenderError() = 0;
virtual ~RenderCallback() {}
// Sets important information about the audio stream format.
// It must be called before any of the other methods.
virtual void Initialize(const AudioParameters& params,
RenderCallback* callback) = 0;
// Starts audio playback.
virtual void Start() = 0;
// Stops audio playback and performs cleanup. It must be called before
// destruction.
virtual void Stop() = 0;
// Pauses playback.
virtual void Pause() = 0;
// Resumes playback after calling Pause().
virtual void Play() = 0;
// Sets the playback volume, with range [0.0, 1.0] inclusive.
// Returns |true| on success.
virtual bool SetVolume(double volume) = 0;
// Returns current output device information. If the information is not
// available yet, this method may block until it becomes available. If the
// sink is not associated with any output device, |device_status| of
// OutputDeviceInfo should be set to OUTPUT_DEVICE_STATUS_ERROR_INTERNAL. Must
// never be called on the IO thread.
// Note: Prefer to use GetOutputDeviceInfoAsync instead if possible.
virtual OutputDeviceInfo GetOutputDeviceInfo() = 0;
// Same as the above, but does not block and will execute |info_cb| when the
// OutputDeviceInfo is available. Callback will be executed on the calling
// thread. Prefer this function to the synchronous version, it does not have a
// timeout so will result in less spurious timeout errors.
// |info_cb| will always be posted (I.e., executed after this function
// returns), even if OutputDeviceInfo is already available.
// Upon destruction if OutputDeviceInfo is still not available, |info_cb| will
// be posted with OUTPUT_DEVICE_STATUS_ERROR_INTERNAL. Note: Because |info_cb|
// is posted it will execute after destruction, so clients must handle
// cancellation of the callback if needed.
using OutputDeviceInfoCB = base::OnceCallback<void(OutputDeviceInfo)>;
virtual void GetOutputDeviceInfoAsync(OutputDeviceInfoCB info_cb) = 0;
// Returns |true| if a source with hardware parameters is preferable.
virtual bool IsOptimizedForHardwareParameters() = 0;
// If DCHECKs are enabled, this function returns true if called on rendering
// thread, otherwise false. With DCHECKs disabled, it returns true. Thus, it
// is intended to be used for DCHECKing.
virtual bool CurrentThreadIsRenderingThread() = 0;
friend class base::RefCountedThreadSafe<AudioRendererSink>;
virtual ~AudioRendererSink() {}
// Same as AudioRendererSink except that Initialize() and Start() can be called
// again after Stop().
// TODO(sandersd): Fold back into AudioRendererSink once all subclasses support
// this.
class RestartableAudioRendererSink : public AudioRendererSink {
~RestartableAudioRendererSink() override {}
class SwitchableAudioRendererSink : public RestartableAudioRendererSink {
// Attempts to switch the audio output device associated with a sink.
// Once the attempt is finished, |callback| is invoked with the
// result of the operation passed as a parameter. The result is a value from
// the media::OutputDeviceStatus enum.
// There is no guarantee about the thread where |callback| will be invoked.
virtual void SwitchOutputDevice(const std::string& device_id,
OutputDeviceStatusCB callback) = 0;
~SwitchableAudioRendererSink() override {}
} // namespace media