Introduce GpuVideoDecodeAcceleratorFactory.

content/common/gpu/media/gpu_video_decode_accelerator_factory.cc

+// Copyright 2016 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 "base/command_line.h"
+#include "content/common/gpu/media/gpu_video_accelerator_util.h"
+#include "content/common/gpu/media/gpu_video_decode_accelerator.h"
+#include "content/public/common/content_switches.h"
+#include "content/public/gpu/gpu_video_decode_accelerator_factory.h"
+
+#if defined(OS_WIN)
+#include "base/win/windows_version.h"
+#include "content/common/gpu/media/dxva_video_decode_accelerator_win.h"
+#elif defined(OS_MACOSX)
+#include "content/common/gpu/media/vt_video_decode_accelerator_mac.h"
+#elif defined(OS_CHROMEOS)
+#if defined(USE_V4L2_CODEC)
+#include "content/common/gpu/media/v4l2_device.h"
+#include "content/common/gpu/media/v4l2_slice_video_decode_accelerator.h"
+#include "content/common/gpu/media/v4l2_video_decode_accelerator.h"
+#include "ui/gl/gl_surface_egl.h"
+#endif
+#if defined(ARCH_CPU_X86_FAMILY)
+#include "content/common/gpu/media/vaapi_video_decode_accelerator.h"
+#include "ui/gl/gl_implementation.h"
+#endif
+#elif defined(USE_OZONE)
+#include "media/ozone/media_ozone_platform.h"
+#elif defined(OS_ANDROID)
+#include "content/common/gpu/media/android_video_decode_accelerator.h"
+#endif
+
+namespace content {
+
+namespace {
+static base::WeakPtr<gpu::gles2::GLES2Decoder> GetEmptyGLES2Decoder() {
+  NOTREACHED() << "VDA requests a GLES2Decoder, but client did not provide it";
+  return base::WeakPtr<gpu::gles2::GLES2Decoder>();
+}
+}
+
+// static
+scoped_ptr<GpuVideoDecodeAcceleratorFactory>
+GpuVideoDecodeAcceleratorFactory::Create(
+    const GetGLContextCallback& get_gl_context_cb,
+    const MakeGLContextCurrentCallback& make_context_current_cb,
+    const BindGLImageCallback& bind_image_cb) {
+  return make_scoped_ptr(new GpuVideoDecodeAcceleratorFactory(
+      get_gl_context_cb, make_context_current_cb, bind_image_cb,
+      base::Bind(&GetEmptyGLES2Decoder)));
+}
+
+// static
+scoped_ptr<GpuVideoDecodeAcceleratorFactory>
+GpuVideoDecodeAcceleratorFactory::CreateWithGLES2Decoder(
+    const GetGLContextCallback& get_gl_context_cb,
+    const MakeGLContextCurrentCallback& make_context_current_cb,
+    const BindGLImageCallback& bind_image_cb,
+    const GetGLES2DecoderCallback& get_gles2_decoder_cb) {
+  return make_scoped_ptr(new GpuVideoDecodeAcceleratorFactory(
+      get_gl_context_cb, make_context_current_cb, bind_image_cb,
+      get_gles2_decoder_cb));
+}
+
+// static
+gpu::VideoDecodeAcceleratorCapabilities
+GpuVideoDecodeAcceleratorFactory::GetDecoderCapabilities() {
+  media::VideoDecodeAccelerator::Capabilities capabilities;
+  const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
+  if (cmd_line->HasSwitch(switches::kDisableAcceleratedVideoDecode))
+    return gpu::VideoDecodeAcceleratorCapabilities();
+
+  // Query VDAs for their capabilities and construct a set of supported
+  // profiles for current platform. This must be done in the same order as in
+  // CreateVDA(), as we currently preserve additional capabilities (such as
+  // resolutions supported) only for the first VDA supporting the given codec
+  // profile (instead of calculating a superset).
+  // TODO(posciak,henryhsu): improve this so that we choose a superset of
+  // resolutions and other supported profile parameters.
+#if defined(OS_WIN)
+  capabilities.supported_profiles =
+      DXVAVideoDecodeAccelerator::GetSupportedProfiles();
+#elif defined(OS_CHROMEOS)
+  media::VideoDecodeAccelerator::SupportedProfiles vda_profiles;
+#if defined(USE_V4L2_CODEC)
+  vda_profiles = V4L2VideoDecodeAccelerator::GetSupportedProfiles();
+  GpuVideoAcceleratorUtil::InsertUniqueDecodeProfiles(
+      vda_profiles, &capabilities.supported_profiles);
+  vda_profiles = V4L2SliceVideoDecodeAccelerator::GetSupportedProfiles();
+  GpuVideoAcceleratorUtil::InsertUniqueDecodeProfiles(
+      vda_profiles, &capabilities.supported_profiles);
+#endif
+#if defined(ARCH_CPU_X86_FAMILY)
+  vda_profiles = VaapiVideoDecodeAccelerator::GetSupportedProfiles();
+  GpuVideoAcceleratorUtil::InsertUniqueDecodeProfiles(
+      vda_profiles, &capabilities.supported_profiles);
+#endif
+#elif defined(OS_MACOSX)
+  capabilities.supported_profiles =
+      VTVideoDecodeAccelerator::GetSupportedProfiles();
+#elif defined(OS_ANDROID)
+  capabilities = AndroidVideoDecodeAccelerator::GetCapabilities();
+#endif
+  return GpuVideoAcceleratorUtil::ConvertMediaToGpuDecodeCapabilities(
+      capabilities);
+}
+
+scoped_ptr<media::VideoDecodeAccelerator>
+GpuVideoDecodeAcceleratorFactory::CreateVDA(
+    media::VideoDecodeAccelerator::Client* client,
+    const media::VideoDecodeAccelerator::Config& config) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // Array of Create..VDA() function pointers, potentially usable on current
+  // platform. This list is ordered by priority, from most to least preferred,
+  // if applicable. This list must be in the same order as the querying order
+  // in GetDecoderCapabilities() above.
+  using CreateVDAFp = scoped_ptr<media::VideoDecodeAccelerator> (
+      GpuVideoDecodeAcceleratorFactory::*)() const;
+  const CreateVDAFp create_vda_fps[] = {
+      &GpuVideoDecodeAcceleratorFactory::CreateDXVAVDA,
+      &GpuVideoDecodeAcceleratorFactory::CreateV4L2VDA,
+      &GpuVideoDecodeAcceleratorFactory::CreateV4L2SVDA,
+      &GpuVideoDecodeAcceleratorFactory::CreateVaapiVDA,
+      &GpuVideoDecodeAcceleratorFactory::CreateVTVDA,
+      &GpuVideoDecodeAcceleratorFactory::CreateOzoneVDA,
+      &GpuVideoDecodeAcceleratorFactory::CreateAndroidVDA};
+
+  scoped_ptr<media::VideoDecodeAccelerator> vda;
+
+  for (const auto& create_vda_function : create_vda_fps) {
+    vda = (this->*create_vda_function)();
+    if (vda && vda->Initialize(config, client))
+      return vda;
+  }
+
+  return nullptr;
+}
+
+scoped_ptr<media::VideoDecodeAccelerator>
+GpuVideoDecodeAcceleratorFactory::CreateDXVAVDA() const {
+  scoped_ptr<media::VideoDecodeAccelerator> decoder;
+#if defined(OS_WIN)
+  if (base::win::GetVersion() >= base::win::VERSION_WIN7) {
+    DVLOG(0) << "Initializing DXVA HW decoder for windows.";
+    decoder.reset(new DXVAVideoDecodeAccelerator(get_gl_context_cb_,
+                                                 make_context_current_cb_));
+  }
+#endif
+  return decoder;
+}
+
+scoped_ptr<media::VideoDecodeAccelerator>
+GpuVideoDecodeAcceleratorFactory::CreateV4L2VDA() const {
+  scoped_ptr<media::VideoDecodeAccelerator> decoder;
+#if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
+  scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
+  if (device.get()) {
+    decoder.reset(new V4L2VideoDecodeAccelerator(
+        gfx::GLSurfaceEGL::GetHardwareDisplay(), get_gl_context_cb_,
+        make_context_current_cb_, device));
+  }
+#endif
+  return decoder;
+}
+
+scoped_ptr<media::VideoDecodeAccelerator>
+GpuVideoDecodeAcceleratorFactory::CreateV4L2SVDA() const {
+  scoped_ptr<media::VideoDecodeAccelerator> decoder;
+#if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
+  scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
+  if (device.get()) {
+    decoder.reset(new V4L2SliceVideoDecodeAccelerator(
+        device, gfx::GLSurfaceEGL::GetHardwareDisplay(), get_gl_context_cb_,
+        make_context_current_cb_));
+  }
+#endif
+  return decoder;
+}
+
+scoped_ptr<media::VideoDecodeAccelerator>
+GpuVideoDecodeAcceleratorFactory::CreateVaapiVDA() const {
+  scoped_ptr<media::VideoDecodeAccelerator> decoder;
+#if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
+  decoder.reset(new VaapiVideoDecodeAccelerator(make_context_current_cb_,
+                                                bind_image_cb_));
+#endif
+  return decoder;
+}
+
+scoped_ptr<media::VideoDecodeAccelerator>
+GpuVideoDecodeAcceleratorFactory::CreateVTVDA() const {
+  scoped_ptr<media::VideoDecodeAccelerator> decoder;
+#if defined(OS_MACOSX)
+  decoder.reset(
+      new VTVideoDecodeAccelerator(make_context_current_cb_, bind_image_cb_));
+#endif
+  return decoder;
+}
+
+scoped_ptr<media::VideoDecodeAccelerator>
+GpuVideoDecodeAcceleratorFactory::CreateOzoneVDA() const {
+  scoped_ptr<media::VideoDecodeAccelerator> decoder;
+#if !defined(OS_CHROMEOS) && defined(USE_OZONE)
+  media::MediaOzonePlatform* platform =
+      media::MediaOzonePlatform::GetInstance();
+  decoder.reset(
+      platform->CreateVideoDecodeAccelerator(make_context_current_cb_));
+#endif
+  return decoder;
+}
+
+scoped_ptr<media::VideoDecodeAccelerator>
+GpuVideoDecodeAcceleratorFactory::CreateAndroidVDA() const {
+  scoped_ptr<media::VideoDecodeAccelerator> decoder;
+#if defined(OS_ANDROID)
+  decoder.reset(new AndroidVideoDecodeAccelerator(make_context_current_cb_,
+                                                  get_gles2_decoder_cb_));
+#endif
+  return decoder;
+}
+
+GpuVideoDecodeAcceleratorFactory::GpuVideoDecodeAcceleratorFactory(
+    const GetGLContextCallback& get_gl_context_cb,
+    const MakeGLContextCurrentCallback& make_context_current_cb,
+    const BindGLImageCallback& bind_image_cb,
+    const GetGLES2DecoderCallback& get_gles2_decoder_cb)
+    : get_gl_context_cb_(get_gl_context_cb),
+      make_context_current_cb_(make_context_current_cb),
+      bind_image_cb_(bind_image_cb),
+      get_gles2_decoder_cb_(get_gles2_decoder_cb) {}
+
+GpuVideoDecodeAcceleratorFactory::~GpuVideoDecodeAcceleratorFactory() {}
+
+}  // namespace content