media/mojo/services/test_mojo_media_client.cc

   1 // Copyright 2014 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/mojo/services/test_mojo_media_client.h"
   6
   7 #include <memory>
   8
   9 #include "base/functional/callback_helpers.h"
  10 #include "base/run_loop.h"
  11 #include "base/task/single_thread_task_runner.h"
  12 #include "build/build_config.h"
  13 #include "media/audio/audio_device_description.h"
  14 #include "media/audio/audio_manager.h"
  15 #include "media/audio/audio_thread_impl.h"
  16 #include "media/audio/null_audio_sink.h"
  17 #include "media/base/cdm_factory.h"
  18 #include "media/base/media.h"
  19 #include "media/base/media_log.h"
  20 #include "media/base/null_video_sink.h"
  21 #include "media/base/renderer_factory.h"
  22 #include "media/cdm/default_cdm_factory.h"
  23 #include "media/renderers/default_decoder_factory.h"
  24 #include "media/renderers/renderer_impl_factory.h"
  25
  26 namespace media {
  27
  28 TestMojoMediaClient::TestMojoMediaClient() = default;
  29
  30 TestMojoMediaClient::~TestMojoMediaClient() {
  31   DVLOG(1) << __func__;
  32
  33   if (audio_manager_) {
  34     audio_manager_->Shutdown();
  35     audio_manager_.reset();
  36   }
  37 }
  38
  39 void TestMojoMediaClient::Initialize() {
  40   InitializeMediaLibrary();
  41   // TODO(dalecurtis): We should find a single owner per process for the audio
  42   // manager or make it a lazy instance.  It's not safe to call Get()/Create()
  43   // across multiple threads...
  44   AudioManager* audio_manager = AudioManager::Get();
  45   if (!audio_manager) {
  46     audio_manager_ = media::AudioManager::CreateForTesting(
  47         std::make_unique<AudioThreadImpl>());
  48     // Flush the message loop to ensure that the audio manager is initialized.
  49     base::RunLoop().RunUntilIdle();
  50   }
  51 }
  52
  53 std::unique_ptr<Renderer> TestMojoMediaClient::CreateRenderer(
  54     mojom::FrameInterfaceFactory* frame_interfaces,
  55     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
  56     MediaLog* media_log,
  57     const std::string& /* audio_device_id */) {
  58   // If called the first time, do one time initialization.
  59   if (!decoder_factory_) {
  60     decoder_factory_ = std::make_unique<media::DefaultDecoderFactory>(nullptr);
  61   }
  62
  63   media::MediaPlayerLoggingID player_id = media::GetNextMediaPlayerLoggingID();
  64
  65   if (!renderer_factory_) {
  66 #if BUILDFLAG(IS_ANDROID)
  67     renderer_factory_ = std::make_unique<RendererImplFactory>(
  68         media_log, decoder_factory_.get(),
  69         RendererImplFactory::GetGpuFactoriesCB(), player_id);
  70 #else
  71     renderer_factory_ = std::make_unique<RendererImplFactory>(
  72         media_log, decoder_factory_.get(),
  73         RendererImplFactory::GetGpuFactoriesCB(), player_id, nullptr);
  74 #endif
  75   }
  76
  77   // We cannot share the NullAudioSink or NullVideoSink among different
  78   // RendererImpls. Thus create one for each Renderer creation.
  79   auto audio_sink = base::MakeRefCounted<NullAudioSink>(task_runner);
  80   auto video_sink = std::make_unique<NullVideoSink>(
  81       false, base::Seconds(1.0 / 60), NullVideoSink::NewFrameCB(), task_runner);
  82   auto* video_sink_ptr = video_sink.get();
  83
  84   // Hold created sinks since RendererImplFactory only takes raw pointers to
  85   // the sinks. We are not cleaning up them even after a created Renderer is
  86   // destroyed. But this is fine since this class is only used for tests.
  87   audio_sinks_.push_back(audio_sink);
  88   video_sinks_.push_back(std::move(video_sink));
  89
  90   return renderer_factory_->CreateRenderer(
  91       task_runner, task_runner, audio_sink.get(), video_sink_ptr,
  92       base::NullCallback(), gfx::ColorSpace());
  93 }
  94
  95 #if BUILDFLAG(ENABLE_CAST_RENDERER)
  96 std::unique_ptr<Renderer> TestMojoMediaClient::CreateCastRenderer(
  97     mojom::FrameInterfaceFactory* frame_interfaces,
  98     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
  99     MediaLog* media_log,
 100     const base::UnguessableToken& /* overlay_plane_id */) {
 101   return CreateRenderer(frame_interfaces, task_runner, media_log,
 102                         std::string());
 103 }
 104 #endif  // BUILDFLAG(ENABLE_CAST_RENDERER)
 105
 106 std::unique_ptr<CdmFactory> TestMojoMediaClient::CreateCdmFactory(
 107     mojom::FrameInterfaceFactory* /* frame_interfaces */) {
 108   DVLOG(1) << __func__;
 109   return std::make_unique<DefaultCdmFactory>();
 110 }
 111
 112 }  // namespace media