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

 // Copyright 2012 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_device_factory.h"

 #include <string>

 #include "base/android/bundle_utils.h"
 #include "base/check.h"
 #include "base/feature_list.h"
 #include "base/logging.h"
 #include "base/task/bind_post_task.h"
 #include "chromecast/base/cast_features.h"
 #include "chromecast/media/audio/cast_audio_output_device.h"
 #include "content/public/renderer/render_frame.h"
 #include "media/audio/audio_output_device.h"
 #include "media/base/audio_capturer_source.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/audio_renderer_sink.h"
 #include "media/base/output_device_info.h"
 #include "third_party/blink/public/platform/browser_interface_broker_proxy.h"
 #include "third_party/blink/public/web/modules/media/audio/audio_output_ipc_factory.h"
 #include "third_party/blink/public/web/web_local_frame.h"

 namespace chromecast {
 namespace media {

 namespace {

 constexpr base::TimeDelta kAuthorizationTimeout = base::Seconds(100);

 content::RenderFrame* GetRenderFrameForToken(
     const blink::LocalFrameToken& frame_token) {
   auto* web_frame = blink::WebLocalFrame::FromFrameToken(frame_token);
   DCHECK(web_frame);

   return content::RenderFrame::FromWebFrame(web_frame);
 }

 scoped_refptr<::media::AudioOutputDevice> NewOutputDevice(
     const blink::LocalFrameToken& frame_token,
     const ::media::AudioSinkParameters& params,
     base::TimeDelta auth_timeout) {
   auto device = base::MakeRefCounted<::media::AudioOutputDevice>(
       blink::AudioOutputIPCFactory::GetInstance().CreateAudioOutputIPC(
           frame_token),
       blink::AudioOutputIPCFactory::GetInstance().io_task_runner(), params,
       auth_timeout);
   device->RequestDeviceAuthorization();
   return device;
 }

 }  // namespace

 class NonSwitchableAudioRendererSink
     : public ::media::SwitchableAudioRendererSink {
  public:
   explicit NonSwitchableAudioRendererSink(
       const blink::LocalFrameToken& frame_token,
       const ::media::AudioSinkParameters& params)
       : frame_token_(frame_token), sink_params_(params) {
     auto* render_frame = GetRenderFrameForToken(frame_token);
     DCHECK(render_frame);
     render_frame->GetBrowserInterfaceBroker().GetInterface(
         pending_audio_socket_broker_.InitWithNewPipeAndPassReceiver());
     render_frame->GetBrowserInterfaceBroker().GetInterface(
         pending_app_media_info_manager_.InitWithNewPipeAndPassReceiver());
   }

   void Initialize(const ::media::AudioParameters& params,
                   RenderCallback* callback) override {
     // NonSwitchableAudioRendererSink derives from RestartableRenderSink which
     // does allow calling Initialize and Play again after stopping.
     if (is_initialized_)
       return;
     is_initialized_ = true;

     if (!(base::android::BundleUtils::IsBundle() ||
           base::FeatureList::IsEnabled(kEnableCastAudioOutputDevice)) ||
         params.IsBitstreamFormat()) {
       output_device_ =
           NewOutputDevice(frame_token_, sink_params_, kAuthorizationTimeout);
       output_device_->Initialize(params, callback);
       return;
     }

     app_media_info_manager_.Bind(std::move(pending_app_media_info_manager_));
     app_media_info_manager_->GetCastApplicationMediaInfo(base::BindOnce(
         &NonSwitchableAudioRendererSink::OnApplicationMediaInfoReceived, this,
         params, callback));
   }

   void Start() override {
     if (output_device_) {
       output_device_->Start();
     } else {
       pending_start_ = true;
     }
   }

   void Stop() override {
     pending_start_ = false;
     if (output_device_) {
       output_device_->Stop();
     }
   }

   void Pause() override {
     if (output_device_) {
       output_device_->Pause();
     } else {
       pending_pause_ = true;
     }
   }

   void Play() override {
     pending_pause_ = false;
     if (output_device_) {
       output_device_->Play();
     }
   }

   bool SetVolume(double volume) override {
     if (output_device_) {
       return output_device_->SetVolume(volume);
     }

     pending_volume_ = volume;
     return true;
   }

   ::media::OutputDeviceInfo GetOutputDeviceInfo() override {
     if (output_device_) {
       return output_device_->GetOutputDeviceInfo();
     }
     // GetOutputDeviceInfo() may be called when the underlying `output_device_`
     // hasn't been constructed. Return the default set of parameters in this
     // case.
     return ::media::OutputDeviceInfo(
         std::string(), ::media::OUTPUT_DEVICE_STATUS_OK,
         ::media::AudioParameters(
             ::media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
             ::media::ChannelLayoutConfig::Stereo(), 48000, 480));
   }

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

   bool IsOptimizedForHardwareParameters() override {
     if (output_device_) {
       return output_device_->IsOptimizedForHardwareParameters();
     }
     return false;
   }

   bool CurrentThreadIsRenderingThread() override {
     return output_device_ && output_device_->CurrentThreadIsRenderingThread();
   }

   void SwitchOutputDevice(const std::string& device_id,
                           ::media::OutputDeviceStatusCB callback) override {
     LOG(ERROR) << __func__ << " is not suported.";
     std::move(callback).Run(::media::OUTPUT_DEVICE_STATUS_ERROR_INTERNAL);
   }

   void Flush() override {
     if (output_device_) {
       output_device_->Flush();
     }
   }

  protected:
   ~NonSwitchableAudioRendererSink() override {
     if (output_device_)
       output_device_->Stop();
   }

  private:
   void OnApplicationMediaInfoReceived(
       const ::media::AudioParameters& params,
       RenderCallback* callback,
       ::media::mojom::CastApplicationMediaInfoPtr application_media_info) {
     // Use CastAudioOutputDevice if either:
     // 1. the playback only has audio stream.
     // 2. the app is an audio only app.
     // Otherwise create Chromium's audio output for better av sync quality.
     if (params.effects() & ::media::AudioParameters::AUDIO_PREFETCH ||
         application_media_info->is_audio_only_session) {
       LOG(INFO) << "Use cast audio output device.";
       output_device_ = base::MakeRefCounted<CastAudioOutputDevice>(
           std::move(pending_audio_socket_broker_),
           application_media_info->application_session_id);
     } else {
       output_device_ =
           NewOutputDevice(frame_token_, sink_params_, kAuthorizationTimeout);
     }

     // The media info manager is only needed to query whether this is an
     // audio-only session and session id; after this, the binding can be reset.
     //
     // If this is not done on the thread on which the binding was created (in
     // Initialize()), then the destructor can run on a different thread and
     // violate a mojo sequence checker assertion.
     app_media_info_manager_.reset();

     output_device_->Initialize(params, callback);

     if (pending_start_) {
       output_device_->Start();
       pending_start_ = false;
     }

     if (pending_pause_) {
       output_device_->Pause();
       pending_pause_ = false;
     }

     if (pending_volume_) {
       output_device_->SetVolume(pending_volume_.value());
       pending_volume_ = std::nullopt;
     }
   }

   const blink::LocalFrameToken frame_token_;
   const ::media::AudioSinkParameters sink_params_;

   mojo::PendingRemote<mojom::AudioSocketBroker> pending_audio_socket_broker_;
   mojo::PendingRemote<::media::mojom::CastApplicationMediaInfoManager>
       pending_app_media_info_manager_;
   mojo::Remote<::media::mojom::CastApplicationMediaInfoManager>
       app_media_info_manager_;
   scoped_refptr<::media::AudioRendererSink> output_device_;
   bool is_initialized_ = false;
   bool pending_start_ = false;
   bool pending_pause_ = false;
   std::optional<double> pending_volume_;
 };

 CastAudioDeviceFactory::CastAudioDeviceFactory() {
   DVLOG(1) << "Register CastAudioDeviceFactory";
 }

 CastAudioDeviceFactory::~CastAudioDeviceFactory() {
   DVLOG(1) << "Unregister CastAudioDeviceFactory";
 }

 scoped_refptr<::media::SwitchableAudioRendererSink>
 CastAudioDeviceFactory::NewMixableSink(
     blink::WebAudioDeviceSourceType source_type,
     const blink::LocalFrameToken& frame_token,
     const blink::FrameToken& main_frame_token,
     const ::media::AudioSinkParameters& params) {
   return base::MakeRefCounted<NonSwitchableAudioRendererSink>(frame_token,
                                                               params);
 }

 }  // namespace media
 }  // namespace chromecast
	// Copyright 2012 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_device_factory.h"

	#include <string>

	#include "base/android/bundle_utils.h"
	#include "base/check.h"
	#include "base/feature_list.h"
	#include "base/logging.h"
	#include "base/task/bind_post_task.h"
	#include "chromecast/base/cast_features.h"
	#include "chromecast/media/audio/cast_audio_output_device.h"
	#include "content/public/renderer/render_frame.h"
	#include "media/audio/audio_output_device.h"
	#include "media/base/audio_capturer_source.h"
	#include "media/base/audio_parameters.h"
	#include "media/base/audio_renderer_sink.h"
	#include "media/base/output_device_info.h"
	#include "third_party/blink/public/platform/browser_interface_broker_proxy.h"
	#include "third_party/blink/public/web/modules/media/audio/audio_output_ipc_factory.h"
	#include "third_party/blink/public/web/web_local_frame.h"

	namespace chromecast {
	namespace media {

	namespace {

	constexpr base::TimeDelta kAuthorizationTimeout = base::Seconds(100);

	content::RenderFrame* GetRenderFrameForToken(
	const blink::LocalFrameToken& frame_token) {
	auto* web_frame = blink::WebLocalFrame::FromFrameToken(frame_token);
	DCHECK(web_frame);

	return content::RenderFrame::FromWebFrame(web_frame);
	}

	scoped_refptr<::media::AudioOutputDevice> NewOutputDevice(
	const blink::LocalFrameToken& frame_token,
	const ::media::AudioSinkParameters& params,
	base::TimeDelta auth_timeout) {
	auto device = base::MakeRefCounted<::media::AudioOutputDevice>(
	blink::AudioOutputIPCFactory::GetInstance().CreateAudioOutputIPC(
	frame_token),
	blink::AudioOutputIPCFactory::GetInstance().io_task_runner(), params,
	auth_timeout);
	device->RequestDeviceAuthorization();
	return device;
	}

	} // namespace

	class NonSwitchableAudioRendererSink
	: public ::media::SwitchableAudioRendererSink {
	public:
	explicit NonSwitchableAudioRendererSink(
	const blink::LocalFrameToken& frame_token,
	const ::media::AudioSinkParameters& params)
	: frame_token_(frame_token), sink_params_(params) {
	auto* render_frame = GetRenderFrameForToken(frame_token);
	DCHECK(render_frame);
	render_frame->GetBrowserInterfaceBroker().GetInterface(
	pending_audio_socket_broker_.InitWithNewPipeAndPassReceiver());
	render_frame->GetBrowserInterfaceBroker().GetInterface(
	pending_app_media_info_manager_.InitWithNewPipeAndPassReceiver());
	}

	void Initialize(const ::media::AudioParameters& params,
	RenderCallback* callback) override {
	// NonSwitchableAudioRendererSink derives from RestartableRenderSink which
	// does allow calling Initialize and Play again after stopping.
	if (is_initialized_)
	return;
	is_initialized_ = true;

	if (!(base::android::BundleUtils::IsBundle() \|\|
	base::FeatureList::IsEnabled(kEnableCastAudioOutputDevice)) \|\|
	params.IsBitstreamFormat()) {
	output_device_ =
	NewOutputDevice(frame_token_, sink_params_, kAuthorizationTimeout);
	output_device_->Initialize(params, callback);
	return;
	}

	app_media_info_manager_.Bind(std::move(pending_app_media_info_manager_));
	app_media_info_manager_->GetCastApplicationMediaInfo(base::BindOnce(
	&NonSwitchableAudioRendererSink::OnApplicationMediaInfoReceived, this,
	params, callback));
	}

	void Start() override {
	if (output_device_) {
	output_device_->Start();
	} else {
	pending_start_ = true;
	}
	}

	void Stop() override {
	pending_start_ = false;
	if (output_device_) {
	output_device_->Stop();
	}
	}

	void Pause() override {
	if (output_device_) {
	output_device_->Pause();
	} else {
	pending_pause_ = true;
	}
	}

	void Play() override {
	pending_pause_ = false;
	if (output_device_) {
	output_device_->Play();
	}
	}

	bool SetVolume(double volume) override {
	if (output_device_) {
	return output_device_->SetVolume(volume);
	}

	pending_volume_ = volume;
	return true;
	}

	::media::OutputDeviceInfo GetOutputDeviceInfo() override {
	if (output_device_) {
	return output_device_->GetOutputDeviceInfo();
	}
	// GetOutputDeviceInfo() may be called when the underlying `output_device_`
	// hasn't been constructed. Return the default set of parameters in this
	// case.
	return ::media::OutputDeviceInfo(
	std::string(), ::media::OUTPUT_DEVICE_STATUS_OK,
	::media::AudioParameters(
	::media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
	::media::ChannelLayoutConfig::Stereo(), 48000, 480));
	}

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

	bool IsOptimizedForHardwareParameters() override {
	if (output_device_) {
	return output_device_->IsOptimizedForHardwareParameters();
	}
	return false;
	}

	bool CurrentThreadIsRenderingThread() override {
	return output_device_ && output_device_->CurrentThreadIsRenderingThread();
	}

	void SwitchOutputDevice(const std::string& device_id,
	::media::OutputDeviceStatusCB callback) override {
	LOG(ERROR) << __func__ << " is not suported.";
	std::move(callback).Run(::media::OUTPUT_DEVICE_STATUS_ERROR_INTERNAL);
	}

	void Flush() override {
	if (output_device_) {
	output_device_->Flush();
	}
	}

	protected:
	~NonSwitchableAudioRendererSink() override {
	if (output_device_)
	output_device_->Stop();
	}

	private:
	void OnApplicationMediaInfoReceived(
	const ::media::AudioParameters& params,
	RenderCallback* callback,
	::media::mojom::CastApplicationMediaInfoPtr application_media_info) {
	// Use CastAudioOutputDevice if either:
	// 1. the playback only has audio stream.
	// 2. the app is an audio only app.
	// Otherwise create Chromium's audio output for better av sync quality.
	if (params.effects() & ::media::AudioParameters::AUDIO_PREFETCH \|\|
	application_media_info->is_audio_only_session) {
	LOG(INFO) << "Use cast audio output device.";
	output_device_ = base::MakeRefCounted<CastAudioOutputDevice>(
	std::move(pending_audio_socket_broker_),
	application_media_info->application_session_id);
	} else {
	output_device_ =
	NewOutputDevice(frame_token_, sink_params_, kAuthorizationTimeout);
	}

	// The media info manager is only needed to query whether this is an
	// audio-only session and session id; after this, the binding can be reset.
	//
	// If this is not done on the thread on which the binding was created (in
	// Initialize()), then the destructor can run on a different thread and
	// violate a mojo sequence checker assertion.
	app_media_info_manager_.reset();

	output_device_->Initialize(params, callback);

	if (pending_start_) {
	output_device_->Start();
	pending_start_ = false;
	}

	if (pending_pause_) {
	output_device_->Pause();
	pending_pause_ = false;
	}

	if (pending_volume_) {
	output_device_->SetVolume(pending_volume_.value());
	pending_volume_ = std::nullopt;
	}
	}

	const blink::LocalFrameToken frame_token_;
	const ::media::AudioSinkParameters sink_params_;

	mojo::PendingRemote<mojom::AudioSocketBroker> pending_audio_socket_broker_;
	mojo::PendingRemote<::media::mojom::CastApplicationMediaInfoManager>
	pending_app_media_info_manager_;
	mojo::Remote<::media::mojom::CastApplicationMediaInfoManager>
	app_media_info_manager_;
	scoped_refptr<::media::AudioRendererSink> output_device_;
	bool is_initialized_ = false;
	bool pending_start_ = false;
	bool pending_pause_ = false;
	std::optional<double> pending_volume_;
	};

	CastAudioDeviceFactory::CastAudioDeviceFactory() {
	DVLOG(1) << "Register CastAudioDeviceFactory";
	}

	CastAudioDeviceFactory::~CastAudioDeviceFactory() {
	DVLOG(1) << "Unregister CastAudioDeviceFactory";
	}

	scoped_refptr<::media::SwitchableAudioRendererSink>
	CastAudioDeviceFactory::NewMixableSink(
	blink::WebAudioDeviceSourceType source_type,
	const blink::LocalFrameToken& frame_token,
	const blink::FrameToken& main_frame_token,
	const ::media::AudioSinkParameters& params) {
	return base::MakeRefCounted<NonSwitchableAudioRendererSink>(frame_token,
	params);
	}

	} // namespace media
	} // namespace chromecast