chromecast/media/audio/cast_audio_output_device.cc - chromium/src.git - Git at Google

 // Copyright 2021 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "chromecast/media/audio/cast_audio_output_device.h"

 #include <cstdint>
 #include <limits>
 #include <string>
 #include <utility>

 #include "base/check.h"
 #include "base/functional/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/task/bind_post_task.h"
 #include "base/task/sequenced_task_runner.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "chromecast/media/audio/audio_io_thread.h"
 #include "chromecast/media/audio/audio_output_service/audio_output_service.pb.h"
 #include "chromecast/media/audio/audio_output_service/output_stream_connection.h"
 #include "chromecast/media/base/default_monotonic_clock.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_glitch_info.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "net/base/io_buffer.h"

 namespace chromecast {
 namespace media {

 namespace {

 constexpr base::TimeDelta kNoBufferReadDelay = base::Milliseconds(50);

 // When to treat lack of audio data in buffer as a underflow.
 constexpr base::TimeDelta kBufferUnderflowThreshold = base::Milliseconds(400);

 // Initial renderer buffer size estimation. The value should be smaller than the
 // audio renderer start capacity.
 constexpr base::TimeDelta kPrefetchRendererBufferSize = base::Seconds(4);
 constexpr base::TimeDelta kDefaultRendererBufferSize = base::Milliseconds(160);

 }  // namespace

 // Internal helper class. The constructor/StartRender/StopRender are called on
 // caller's thread. The other functions including destructor should be used on
 // an IO thread.
 class CastAudioOutputDevice::Internal
     : public audio_output_service::OutputStreamConnection::Delegate {
  public:
   Internal(const ::media::AudioParameters& audio_params,
            RenderCallback* render_callback)
       : audio_params_(audio_params), render_callback_(render_callback) {
     DCHECK(render_callback_);
   }

   Internal(const Internal&) = delete;
   Internal& operator=(const Internal&) = delete;
   ~Internal() override = default;

   // One time init on IO thread.
   void Initialize(
       mojo::PendingRemote<mojom::AudioSocketBroker> audio_socket_broker,
       const std::string& session_id) {
     audio_output_service::CmaBackendParams cma_backend_params;

     audio_output_service::AudioDecoderConfig* audio_config =
         cma_backend_params.mutable_audio_decoder_config();
     audio_config->set_audio_codec(audio_service::AudioCodec::AUDIO_CODEC_PCM);
     audio_config->set_sample_rate(audio_params_.sample_rate());
     audio_config->set_sample_format(
         audio_service::SampleFormat::SAMPLE_FORMAT_INT16_I);
     audio_config->set_num_channels(audio_params_.channels());

     audio_output_service::ApplicationMediaInfo* app_media_info =
         cma_backend_params.mutable_application_media_info();
     app_media_info->set_application_session_id(session_id);

     audio_bus_ = ::media::AudioBus::Create(audio_params_);
     output_connection_ =
         std::make_unique<audio_output_service::OutputStreamConnection>(
             this, cma_backend_params, std::move(audio_socket_broker));
     output_connection_->Connect();
   }

   void StartRender() {
     base::AutoLock lock(callback_lock_);
     active_render_callback_ = render_callback_;
   }

   void StopRender() {
     base::AutoLock lock(callback_lock_);
     active_render_callback_ = nullptr;
   }

   void Start() {
     playback_started_ = true;
     media_pos_frames_ = 0;
     renderer_buffer_size_estimate_ =
         (audio_params_.effects() & ::media::AudioParameters::AUDIO_PREFETCH)
             ? kPrefetchRendererBufferSize
             : kDefaultRendererBufferSize;
     DCHECK_GT(renderer_buffer_size_estimate_,
               audio_params_.GetBufferDuration());

     media_start_time_ = base::TimeTicks::Now();
     if (!backend_initialized_) {
       // Wait for initialization to complete before sending messages through
       // `output_connection_`.
       return;
     }
     output_connection_->StartPlayingFrom(0);
   }

   void Pause() {
     paused_ = true;

     if (!backend_initialized_) {
       return;
     }

     output_connection_->SetPlaybackRate(0.0f);
     push_timer_.Stop();
   }

   void Play() {
     paused_ = false;
     if (!playback_started_) {
       Start();
     }
     if (!backend_initialized_) {
       return;
     }

     last_read_buffer_timestamp_ = base::TimeTicks();
     output_connection_->SetPlaybackRate(1.0f);
   }

   void Flush() {
     if (!backend_initialized_) {
       return;
     }
     media_pos_frames_ = 0;
     media_start_time_ = base::TimeTicks::Now();
     playback_started_ = false;
     paused_ = false;
     push_timer_.Stop();
     output_connection_->StopPlayback();
   }

   void SetVolume(double volume) {
     volume_ = volume;
     if (!backend_initialized_) {
       return;
     }
     output_connection_->SetVolume(volume_);
   }

  private:
   // audio_output_service::OutputStreamConnection::Delegate implementation:
   void OnBackendInitialized(
       const audio_output_service::BackendInitializationStatus& status)
       override {
     if (status.status() !=
         audio_output_service::BackendInitializationStatus::SUCCESS) {
       LOG(ERROR) << "Error initializing the audio backend.";
       base::AutoLock lock(callback_lock_);
       if (active_render_callback_) {
         active_render_callback_->OnRenderError();
       }
       return;
     }

     DCHECK(output_connection_);
     backend_initialized_ = true;
     output_connection_->SetVolume(volume_);
     if (paused_) {
       output_connection_->SetPlaybackRate(0.0f);
     }
     if (!playback_started_) {
       // Wait for Start() to be called before schedule reading buffers.
       return;
     }
     output_connection_->StartPlayingFrom(0);
     if (!paused_) {
       last_read_buffer_timestamp_ = base::TimeTicks();
       output_connection_->SetPlaybackRate(1.0f);
     }
   }

   void OnNextBuffer(int64_t media_timestamp_microseconds,
                     int64_t reference_timestamp_microseconds,
                     int64_t delay_microseconds,
                     int64_t delay_timestamp_microseconds) override {
     rendering_delay_ = base::Microseconds(delay_microseconds);
     rendering_delay_timestamp_us_ = delay_timestamp_microseconds;

     TryPushBuffer();
   }

   void TryPushBuffer() {
     if (paused_ || !backend_initialized_ || !playback_started_ ||
         push_timer_.IsRunning()) {
       return;
     }

     PushBuffer();
   }

   void PushBuffer() {
     auto now = base::TimeTicks::Now();
     if (last_read_buffer_timestamp_.is_null()) {
       last_read_buffer_timestamp_ = now;
     }

     base::TimeDelta elapsed_time = now - last_read_buffer_timestamp_;
     base::TimeDelta time_before_underrun =
         audio_params_.GetBufferDuration() -
         (renderer_buffer_size_estimate_ + elapsed_time);
     if (time_before_underrun > base::TimeDelta()) {
       // Let renderer buffer more data.
       push_timer_.Start(FROM_HERE, now + time_before_underrun, this,
                         &Internal::TryPushBuffer,
                         base::subtle::DelayPolicy::kPrecise);
       return;
     }

     int frames_filled = ReadBuffer(GetDelay(), audio_bus_.get());
     renderer_buffer_size_estimate_ += elapsed_time;
     last_read_buffer_timestamp_ = now;
     auto media_pos = ::media::AudioTimestampHelper::FramesToTime(
         media_pos_frames_, audio_params_.sample_rate());
     if (frames_filled) {
       renderer_buffer_size_estimate_ -=
           ::media::AudioTimestampHelper::FramesToTime(
               frames_filled, audio_params_.sample_rate());
       DCHECK_GE(renderer_buffer_size_estimate_, base::TimeDelta());

       size_t filled_bytes = frames_filled * audio_params_.GetBytesPerFrame(
                                                 ::media::kSampleFormatS16);
       size_t io_buffer_size =
           audio_output_service::OutputSocket::kAudioMessageHeaderSize +
           filled_bytes;
       auto io_buffer =
           base::MakeRefCounted<net::IOBufferWithSize>(io_buffer_size);
       audio_bus_->ToInterleaved<::media::SignedInt16SampleTypeTraits>(
           frames_filled,
           reinterpret_cast<int16_t*>(
               io_buffer->data() +
               audio_output_service::OutputSocket::kAudioMessageHeaderSize));

       DCHECK(output_connection_);
       output_connection_->SendAudioBuffer(std::move(io_buffer), filled_bytes,
                                           media_pos.InMicroseconds());
       media_pos_frames_ += frames_filled;

       // No need to schedule buffer read here since
       // `OnNextBuffer` will be called once the current
       // buffer is pushed to media backend.
       return;
     }

     // Avoid spam calling Render() since each call will advance the |AudioClock|
     // a little bit if 0 frames are rendered.
     // Wait until some rendered data is consumed before retrying Render().
     base::TimeDelta time_left_in_buffer =
         media_pos - (base::TimeTicks::Now() - media_start_time_);
     if (time_left_in_buffer > kBufferUnderflowThreshold) {
       push_timer_.Start(FROM_HERE, base::TimeTicks::Now() + time_left_in_buffer, this,
                         &Internal::TryPushBuffer,
                         base::subtle::DelayPolicy::kPrecise);
       return;
     }

     // No frames filled, schedule read immediately with a small delay.
     push_timer_.Start(FROM_HERE, base::TimeTicks::Now() + kNoBufferReadDelay,
                       this, &Internal::TryPushBuffer,
                       base::subtle::DelayPolicy::kPrecise);
   }

   int ReadBuffer(base::TimeDelta delay, ::media::AudioBus* audio_bus) {
     DCHECK(audio_bus);
     base::AutoLock lock(callback_lock_);
     if (!active_render_callback_) {
       return 0;
     }
     return active_render_callback_->Render(delay, base::TimeTicks(),
                                            /*glitch_info=*/{}, audio_bus);
   }

   base::TimeDelta GetDelay() {
     base::TimeDelta delay;
     if (rendering_delay_ < base::TimeDelta() ||
         rendering_delay_timestamp_us_ < 0) {
       delay = base::TimeDelta();
     } else {
       delay =
           rendering_delay_ + base::Microseconds(rendering_delay_timestamp_us_ -
                                                 MonotonicClockNow());
       if (delay < base::TimeDelta()) {
         delay = base::TimeDelta();
       }
     }
     return delay;
   }

   scoped_refptr<CastAudioOutputDevice> output_device_;
   std::unique_ptr<audio_output_service::OutputStreamConnection>
       output_connection_;

   mojo::PendingRemote<mojom::AudioSocketBroker> pending_socket_broker_;
   ::media::AudioParameters audio_params_;
   size_t media_pos_frames_ = 0;
   // When we start playing media. Used to determine the current position in the track.
   base::TimeTicks media_start_time_ = base::TimeTicks();
   base::TimeDelta rendering_delay_;

   int64_t rendering_delay_timestamp_us_ = INT64_MIN;
   double volume_ = 1.0;
   bool paused_ = false;
   bool playback_started_ = false;
   bool backend_initialized_ = false;
   base::DeadlineTimer push_timer_;
   std::unique_ptr<::media::AudioBus> audio_bus_;

   // Callback to get audio data.
   RenderCallback* const render_callback_;

   // Estimation of the renderer buffer size. We should not pull too much buffer
   // from renderer to avoid underrun.
   base::TimeDelta renderer_buffer_size_estimate_;

   base::TimeTicks last_read_buffer_timestamp_;

   base::Lock callback_lock_;
   // Nullable callback that is only available during StartRender/StopRender.
   RenderCallback* active_render_callback_ GUARDED_BY(callback_lock_) = nullptr;
 };

 CastAudioOutputDevice::CastAudioOutputDevice(
     mojo::PendingRemote<mojom::AudioSocketBroker> audio_socket_broker,
     const std::string& session_id)
     : CastAudioOutputDevice(std::move(audio_socket_broker),
                             session_id,
                             AudioIoThread::Get()->task_runner()) {}

 CastAudioOutputDevice::CastAudioOutputDevice(
     mojo::PendingRemote<mojom::AudioSocketBroker> audio_socket_broker,
     const std::string& session_id,
     scoped_refptr<base::SequencedTaskRunner> task_runner)
     : task_runner_(std::move(task_runner)),
       pending_socket_broker_(std::move(audio_socket_broker)),
       session_id_(session_id) {}

 CastAudioOutputDevice::~CastAudioOutputDevice() {
   if (!internal_) {
     return;
   }

   internal_ptr_->StopRender();
 }

 void CastAudioOutputDevice::Initialize(const ::media::AudioParameters& params,
                                        RenderCallback* callback) {
   DCHECK(callback);
   DCHECK(!internal_);
   DCHECK(!internal_ptr_);

   auto internal = std::make_unique<Internal>(params, callback);
   internal_ptr_ = internal.get();
   internal_.emplace(task_runner_, std::move(internal));

   internal_.AsyncCall(&Internal::Initialize)
       .WithArgs(std::move(pending_socket_broker_), session_id_);
 }

 void CastAudioOutputDevice::Start() {
   internal_ptr_->StartRender();
   internal_.AsyncCall(&Internal::Start);
 }

 void CastAudioOutputDevice::Stop() {
   internal_ptr_->StopRender();
   Flush();
 }

 void CastAudioOutputDevice::Pause() {
   internal_.AsyncCall(&Internal::Pause);
 }

 void CastAudioOutputDevice::Play() {
   internal_.AsyncCall(&Internal::Play);
 }

 void CastAudioOutputDevice::Flush() {
   internal_.AsyncCall(&Internal::Flush);
 }

 bool CastAudioOutputDevice::SetVolume(double volume) {
   internal_.AsyncCall(&Internal::SetVolume).WithArgs(volume);
   return true;
 }

 ::media::OutputDeviceInfo CastAudioOutputDevice::GetOutputDeviceInfo() {
   // Same as the set of parameters returned in
   // CastAudioManager::GetPreferredOutputStreamParameters.
   return ::media::OutputDeviceInfo(
       std::string(), ::media::OUTPUT_DEVICE_STATUS_OK,
       ::media::AudioParameters(::media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                                ::media::ChannelLayoutConfig::Stereo(), 48000,
                                480));
 }

 void CastAudioOutputDevice::GetOutputDeviceInfoAsync(
     OutputDeviceInfoCB info_cb) {
   // Always post to avoid the caller being reentrant.
   base::BindPostTaskToCurrentDefault(
       base::BindOnce(std::move(info_cb), GetOutputDeviceInfo()))
       .Run();
 }

 bool CastAudioOutputDevice::IsOptimizedForHardwareParameters() {
   return false;
 }

 bool CastAudioOutputDevice::CurrentThreadIsRenderingThread() {
   return task_runner_->RunsTasksInCurrentSequence();
 }

 }  // namespace media
 }  // namespace chromecast
	// Copyright 2021 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "chromecast/media/audio/cast_audio_output_device.h"

	#include <cstdint>
	#include <limits>
	#include <string>
	#include <utility>

	#include "base/check.h"
	#include "base/functional/bind.h"
	#include "base/location.h"
	#include "base/logging.h"
	#include "base/memory/ref_counted.h"
	#include "base/task/bind_post_task.h"
	#include "base/task/sequenced_task_runner.h"
	#include "base/time/time.h"
	#include "base/timer/timer.h"
	#include "chromecast/media/audio/audio_io_thread.h"
	#include "chromecast/media/audio/audio_output_service/audio_output_service.pb.h"
	#include "chromecast/media/audio/audio_output_service/output_stream_connection.h"
	#include "chromecast/media/base/default_monotonic_clock.h"
	#include "media/base/audio_bus.h"
	#include "media/base/audio_glitch_info.h"
	#include "media/base/audio_parameters.h"
	#include "media/base/audio_timestamp_helper.h"
	#include "net/base/io_buffer.h"

	namespace chromecast {
	namespace media {

	namespace {

	constexpr base::TimeDelta kNoBufferReadDelay = base::Milliseconds(50);

	// When to treat lack of audio data in buffer as a underflow.
	constexpr base::TimeDelta kBufferUnderflowThreshold = base::Milliseconds(400);

	// Initial renderer buffer size estimation. The value should be smaller than the
	// audio renderer start capacity.
	constexpr base::TimeDelta kPrefetchRendererBufferSize = base::Seconds(4);
	constexpr base::TimeDelta kDefaultRendererBufferSize = base::Milliseconds(160);

	} // namespace

	// Internal helper class. The constructor/StartRender/StopRender are called on
	// caller's thread. The other functions including destructor should be used on
	// an IO thread.
	class CastAudioOutputDevice::Internal
	: public audio_output_service::OutputStreamConnection::Delegate {
	public:
	Internal(const ::media::AudioParameters& audio_params,
	RenderCallback* render_callback)
	: audio_params_(audio_params), render_callback_(render_callback) {
	DCHECK(render_callback_);
	}

	Internal(const Internal&) = delete;
	Internal& operator=(const Internal&) = delete;
	~Internal() override = default;

	// One time init on IO thread.
	void Initialize(
	mojo::PendingRemote<mojom::AudioSocketBroker> audio_socket_broker,
	const std::string& session_id) {
	audio_output_service::CmaBackendParams cma_backend_params;

	audio_output_service::AudioDecoderConfig* audio_config =
	cma_backend_params.mutable_audio_decoder_config();
	audio_config->set_audio_codec(audio_service::AudioCodec::AUDIO_CODEC_PCM);
	audio_config->set_sample_rate(audio_params_.sample_rate());
	audio_config->set_sample_format(
	audio_service::SampleFormat::SAMPLE_FORMAT_INT16_I);
	audio_config->set_num_channels(audio_params_.channels());

	audio_output_service::ApplicationMediaInfo* app_media_info =
	cma_backend_params.mutable_application_media_info();
	app_media_info->set_application_session_id(session_id);

	audio_bus_ = ::media::AudioBus::Create(audio_params_);
	output_connection_ =
	std::make_unique<audio_output_service::OutputStreamConnection>(
	this, cma_backend_params, std::move(audio_socket_broker));
	output_connection_->Connect();
	}

	void StartRender() {
	base::AutoLock lock(callback_lock_);
	active_render_callback_ = render_callback_;
	}

	void StopRender() {
	base::AutoLock lock(callback_lock_);
	active_render_callback_ = nullptr;
	}

	void Start() {
	playback_started_ = true;
	media_pos_frames_ = 0;
	renderer_buffer_size_estimate_ =
	(audio_params_.effects() & ::media::AudioParameters::AUDIO_PREFETCH)
	? kPrefetchRendererBufferSize
	: kDefaultRendererBufferSize;
	DCHECK_GT(renderer_buffer_size_estimate_,
	audio_params_.GetBufferDuration());

	media_start_time_ = base::TimeTicks::Now();
	if (!backend_initialized_) {
	// Wait for initialization to complete before sending messages through
	// `output_connection_`.
	return;
	}
	output_connection_->StartPlayingFrom(0);
	}

	void Pause() {
	paused_ = true;

	if (!backend_initialized_) {
	return;
	}

	output_connection_->SetPlaybackRate(0.0f);
	push_timer_.Stop();
	}

	void Play() {
	paused_ = false;
	if (!playback_started_) {
	Start();
	}
	if (!backend_initialized_) {
	return;
	}

	last_read_buffer_timestamp_ = base::TimeTicks();
	output_connection_->SetPlaybackRate(1.0f);
	}

	void Flush() {
	if (!backend_initialized_) {
	return;
	}
	media_pos_frames_ = 0;
	media_start_time_ = base::TimeTicks::Now();
	playback_started_ = false;
	paused_ = false;
	push_timer_.Stop();
	output_connection_->StopPlayback();
	}

	void SetVolume(double volume) {
	volume_ = volume;
	if (!backend_initialized_) {
	return;
	}
	output_connection_->SetVolume(volume_);
	}

	private:
	// audio_output_service::OutputStreamConnection::Delegate implementation:
	void OnBackendInitialized(
	const audio_output_service::BackendInitializationStatus& status)
	override {
	if (status.status() !=
	audio_output_service::BackendInitializationStatus::SUCCESS) {
	LOG(ERROR) << "Error initializing the audio backend.";
	base::AutoLock lock(callback_lock_);
	if (active_render_callback_) {
	active_render_callback_->OnRenderError();
	}
	return;
	}

	DCHECK(output_connection_);
	backend_initialized_ = true;
	output_connection_->SetVolume(volume_);
	if (paused_) {
	output_connection_->SetPlaybackRate(0.0f);
	}
	if (!playback_started_) {
	// Wait for Start() to be called before schedule reading buffers.
	return;
	}
	output_connection_->StartPlayingFrom(0);
	if (!paused_) {
	last_read_buffer_timestamp_ = base::TimeTicks();
	output_connection_->SetPlaybackRate(1.0f);
	}
	}

	void OnNextBuffer(int64_t media_timestamp_microseconds,
	int64_t reference_timestamp_microseconds,
	int64_t delay_microseconds,
	int64_t delay_timestamp_microseconds) override {
	rendering_delay_ = base::Microseconds(delay_microseconds);
	rendering_delay_timestamp_us_ = delay_timestamp_microseconds;

	TryPushBuffer();
	}

	void TryPushBuffer() {
	if (paused_ \|\| !backend_initialized_ \|\| !playback_started_ \|\|
	push_timer_.IsRunning()) {
	return;
	}

	PushBuffer();
	}

	void PushBuffer() {
	auto now = base::TimeTicks::Now();
	if (last_read_buffer_timestamp_.is_null()) {
	last_read_buffer_timestamp_ = now;
	}

	base::TimeDelta elapsed_time = now - last_read_buffer_timestamp_;
	base::TimeDelta time_before_underrun =
	audio_params_.GetBufferDuration() -
	(renderer_buffer_size_estimate_ + elapsed_time);
	if (time_before_underrun > base::TimeDelta()) {
	// Let renderer buffer more data.
	push_timer_.Start(FROM_HERE, now + time_before_underrun, this,
	&Internal::TryPushBuffer,
	base::subtle::DelayPolicy::kPrecise);
	return;
	}

	int frames_filled = ReadBuffer(GetDelay(), audio_bus_.get());
	renderer_buffer_size_estimate_ += elapsed_time;
	last_read_buffer_timestamp_ = now;
	auto media_pos = ::media::AudioTimestampHelper::FramesToTime(
	media_pos_frames_, audio_params_.sample_rate());
	if (frames_filled) {
	renderer_buffer_size_estimate_ -=
	::media::AudioTimestampHelper::FramesToTime(
	frames_filled, audio_params_.sample_rate());
	DCHECK_GE(renderer_buffer_size_estimate_, base::TimeDelta());

	size_t filled_bytes = frames_filled * audio_params_.GetBytesPerFrame(
	::media::kSampleFormatS16);
	size_t io_buffer_size =
	audio_output_service::OutputSocket::kAudioMessageHeaderSize +
	filled_bytes;
	auto io_buffer =
	base::MakeRefCounted<net::IOBufferWithSize>(io_buffer_size);
	audio_bus_->ToInterleaved<::media::SignedInt16SampleTypeTraits>(
	frames_filled,
	reinterpret_cast<int16_t*>(
	io_buffer->data() +
	audio_output_service::OutputSocket::kAudioMessageHeaderSize));

	DCHECK(output_connection_);
	output_connection_->SendAudioBuffer(std::move(io_buffer), filled_bytes,
	media_pos.InMicroseconds());
	media_pos_frames_ += frames_filled;

	// No need to schedule buffer read here since
	// `OnNextBuffer` will be called once the current
	// buffer is pushed to media backend.
	return;
	}

	// Avoid spam calling Render() since each call will advance the \|AudioClock\|
	// a little bit if 0 frames are rendered.
	// Wait until some rendered data is consumed before retrying Render().
	base::TimeDelta time_left_in_buffer =
	media_pos - (base::TimeTicks::Now() - media_start_time_);
	if (time_left_in_buffer > kBufferUnderflowThreshold) {
	push_timer_.Start(FROM_HERE, base::TimeTicks::Now() + time_left_in_buffer, this,
	&Internal::TryPushBuffer,
	base::subtle::DelayPolicy::kPrecise);
	return;
	}

	// No frames filled, schedule read immediately with a small delay.
	push_timer_.Start(FROM_HERE, base::TimeTicks::Now() + kNoBufferReadDelay,
	this, &Internal::TryPushBuffer,
	base::subtle::DelayPolicy::kPrecise);
	}

	int ReadBuffer(base::TimeDelta delay, ::media::AudioBus* audio_bus) {
	DCHECK(audio_bus);
	base::AutoLock lock(callback_lock_);
	if (!active_render_callback_) {
	return 0;
	}
	return active_render_callback_->Render(delay, base::TimeTicks(),
	/glitch_info=/{}, audio_bus);
	}

	base::TimeDelta GetDelay() {
	base::TimeDelta delay;
	if (rendering_delay_ < base::TimeDelta() \|\|
	rendering_delay_timestamp_us_ < 0) {
	delay = base::TimeDelta();
	} else {
	delay =
	rendering_delay_ + base::Microseconds(rendering_delay_timestamp_us_ -
	MonotonicClockNow());
	if (delay < base::TimeDelta()) {
	delay = base::TimeDelta();
	}
	}
	return delay;
	}

	scoped_refptr<CastAudioOutputDevice> output_device_;
	std::unique_ptr<audio_output_service::OutputStreamConnection>
	output_connection_;

	mojo::PendingRemote<mojom::AudioSocketBroker> pending_socket_broker_;
	::media::AudioParameters audio_params_;
	size_t media_pos_frames_ = 0;
	// When we start playing media. Used to determine the current position in the track.
	base::TimeTicks media_start_time_ = base::TimeTicks();
	base::TimeDelta rendering_delay_;

	int64_t rendering_delay_timestamp_us_ = INT64_MIN;
	double volume_ = 1.0;
	bool paused_ = false;
	bool playback_started_ = false;
	bool backend_initialized_ = false;
	base::DeadlineTimer push_timer_;
	std::unique_ptr<::media::AudioBus> audio_bus_;

	// Callback to get audio data.
	RenderCallback* const render_callback_;

	// Estimation of the renderer buffer size. We should not pull too much buffer
	// from renderer to avoid underrun.
	base::TimeDelta renderer_buffer_size_estimate_;

	base::TimeTicks last_read_buffer_timestamp_;

	base::Lock callback_lock_;
	// Nullable callback that is only available during StartRender/StopRender.
	RenderCallback* active_render_callback_ GUARDED_BY(callback_lock_) = nullptr;
	};

	CastAudioOutputDevice::CastAudioOutputDevice(
	mojo::PendingRemote<mojom::AudioSocketBroker> audio_socket_broker,
	const std::string& session_id)
	: CastAudioOutputDevice(std::move(audio_socket_broker),
	session_id,
	AudioIoThread::Get()->task_runner()) {}

	CastAudioOutputDevice::CastAudioOutputDevice(
	mojo::PendingRemote<mojom::AudioSocketBroker> audio_socket_broker,
	const std::string& session_id,
	scoped_refptr<base::SequencedTaskRunner> task_runner)
	: task_runner_(std::move(task_runner)),
	pending_socket_broker_(std::move(audio_socket_broker)),
	session_id_(session_id) {}

	CastAudioOutputDevice::~CastAudioOutputDevice() {
	if (!internal_) {
	return;
	}

	internal_ptr_->StopRender();
	}

	void CastAudioOutputDevice::Initialize(const ::media::AudioParameters& params,
	RenderCallback* callback) {
	DCHECK(callback);
	DCHECK(!internal_);
	DCHECK(!internal_ptr_);

	auto internal = std::make_unique<Internal>(params, callback);
	internal_ptr_ = internal.get();
	internal_.emplace(task_runner_, std::move(internal));

	internal_.AsyncCall(&Internal::Initialize)
	.WithArgs(std::move(pending_socket_broker_), session_id_);
	}

	void CastAudioOutputDevice::Start() {
	internal_ptr_->StartRender();
	internal_.AsyncCall(&Internal::Start);
	}

	void CastAudioOutputDevice::Stop() {
	internal_ptr_->StopRender();
	Flush();
	}

	void CastAudioOutputDevice::Pause() {
	internal_.AsyncCall(&Internal::Pause);
	}

	void CastAudioOutputDevice::Play() {
	internal_.AsyncCall(&Internal::Play);
	}

	void CastAudioOutputDevice::Flush() {
	internal_.AsyncCall(&Internal::Flush);
	}

	bool CastAudioOutputDevice::SetVolume(double volume) {
	internal_.AsyncCall(&Internal::SetVolume).WithArgs(volume);
	return true;
	}

	::media::OutputDeviceInfo CastAudioOutputDevice::GetOutputDeviceInfo() {
	// Same as the set of parameters returned in
	// CastAudioManager::GetPreferredOutputStreamParameters.
	return ::media::OutputDeviceInfo(
	std::string(), ::media::OUTPUT_DEVICE_STATUS_OK,
	::media::AudioParameters(::media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
	::media::ChannelLayoutConfig::Stereo(), 48000,
	480));
	}

	void CastAudioOutputDevice::GetOutputDeviceInfoAsync(
	OutputDeviceInfoCB info_cb) {
	// Always post to avoid the caller being reentrant.
	base::BindPostTaskToCurrentDefault(
	base::BindOnce(std::move(info_cb), GetOutputDeviceInfo()))
	.Run();
	}

	bool CastAudioOutputDevice::IsOptimizedForHardwareParameters() {
	return false;
	}

	bool CastAudioOutputDevice::CurrentThreadIsRenderingThread() {
	return task_runner_->RunsTasksInCurrentSequence();
	}

	} // namespace media
	} // namespace chromecast