media/mojo/services/mojo_video_encode_accelerator_provider.cc

   1 // Copyright 2017 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/mojo_video_encode_accelerator_provider.h"
   6
   7 #include <memory>
   8 #include <utility>
   9
  10 #include "base/feature_list.h"
  11 #include "base/memory/scoped_refptr.h"
  12 #include "base/task/sequenced_task_runner.h"
  13 #include "base/task/task_traits.h"
  14 #include "base/task/thread_pool.h"
  15 #include "media/base/limits.h"
  16 #include "media/base/media_switches.h"
  17 #include "media/gpu/gpu_video_encode_accelerator_factory.h"
  18 #include "mojo/public/cpp/bindings/self_owned_receiver.h"
  19 #include "mojo/public/cpp/system/platform_handle.h"
  20
  21 namespace {
  22 void BindVEAProvider(
  23     mojo::PendingReceiver<media::mojom::VideoEncodeAcceleratorProvider>
  24         receiver,
  25     media::MojoVideoEncodeAcceleratorProvider::
  26         CreateAndInitializeVideoEncodeAcceleratorCallback create_vea_callback,
  27     gpu::GpuPreferences gpu_preferences,
  28     gpu::GpuDriverBugWorkarounds gpu_workarounds,
  29     const gpu::GPUInfo::GPUDevice& gpu_device) {
  30   auto vea_provider =
  31       std::make_unique<media::MojoVideoEncodeAcceleratorProvider>(
  32           std::move(create_vea_callback), gpu_preferences, gpu_workarounds,
  33           gpu_device);
  34   mojo::MakeSelfOwnedReceiver(std::move(vea_provider), std::move(receiver));
  35 }
  36 }  // namespace
  37
  38 namespace media {
  39
  40 // static
  41 void MojoVideoEncodeAcceleratorProvider::Create(
  42     mojo::PendingReceiver<mojom::VideoEncodeAcceleratorProvider> receiver,
  43     CreateAndInitializeVideoEncodeAcceleratorCallback create_vea_callback,
  44     const gpu::GpuPreferences& gpu_preferences,
  45     const gpu::GpuDriverBugWorkarounds& gpu_workarounds,
  46     const gpu::GPUInfo::GPUDevice& gpu_device,
  47     scoped_refptr<base::SequencedTaskRunner> runner) {
  48   DCHECK(runner);
  49   runner->PostTask(
  50       FROM_HERE, base::BindOnce(BindVEAProvider, std::move(receiver),
  51                                 std::move(create_vea_callback), gpu_preferences,
  52                                 gpu_workarounds, gpu_device));
  53 }
  54
  55 MojoVideoEncodeAcceleratorProvider::MojoVideoEncodeAcceleratorProvider(
  56     CreateAndInitializeVideoEncodeAcceleratorCallback create_vea_callback,
  57     const gpu::GpuPreferences& gpu_preferences,
  58     const gpu::GpuDriverBugWorkarounds& gpu_workarounds,
  59     const gpu::GPUInfo::GPUDevice& gpu_device)
  60     : create_vea_callback_(std::move(create_vea_callback)),
  61       gpu_preferences_(gpu_preferences),
  62       gpu_workarounds_(gpu_workarounds),
  63       gpu_device_(gpu_device) {}
  64
  65 MojoVideoEncodeAcceleratorProvider::~MojoVideoEncodeAcceleratorProvider() =
  66     default;
  67
  68 void MojoVideoEncodeAcceleratorProvider::CreateVideoEncodeAccelerator(
  69     mojo::PendingReceiver<mojom::VideoEncodeAccelerator> receiver) {
  70   auto create_service_cb = base::BindOnce(
  71       &MojoVideoEncodeAcceleratorService::Create, std::move(receiver),
  72       create_vea_callback_, gpu_preferences_, gpu_workarounds_, gpu_device_);
  73
  74   if (base::FeatureList::IsEnabled(kUseTaskRunnerForMojoVEAService)) {
  75 #if BUILDFLAG(IS_WIN)
  76     base::ThreadPool::CreateCOMSTATaskRunner({base::MayBlock()},
  77         base::SingleThreadTaskRunnerThreadMode::DEDICATED)
  78 #else
  79     base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()})
  80 #endif
  81         ->PostTask(FROM_HERE, std::move(create_service_cb));
  82   } else {
  83     std::move(create_service_cb).Run();
  84   }
  85 }
  86
  87 void MojoVideoEncodeAcceleratorProvider::
  88     GetVideoEncodeAcceleratorSupportedProfiles(
  89         GetVideoEncodeAcceleratorSupportedProfilesCallback callback) {
  90   std::move(callback).Run(
  91       GpuVideoEncodeAcceleratorFactory::GetSupportedProfiles(
  92           gpu_preferences_, gpu_workarounds_, gpu_device_));
  93 }
  94
  95 }  // namespace media