[Ozone] Extends the lifetime of VaapiWrapper

content/common/gpu/media/vaapi_wrapper.cc

 // Copyright 2013 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 "content/common/gpu/media/vaapi_wrapper.h"
 
 #include <dlfcn.h>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/sys_info.h"
 // Auto-generated for dlopen libva libraries
 #include "content/common/gpu/media/va_stubs.h"
 #include "content/common/gpu/media/vaapi_picture.h"
 #include "content/public/common/content_switches.h"
 #include "third_party/libyuv/include/libyuv.h"
 #include "ui/gl/gl_bindings.h"
 #if defined(USE_X11)
 #include "ui/gfx/x/x11_types.h"
 #elif defined(USE_OZONE)
 #include "third_party/libva/va/drm/va_drm.h"
+#include "third_party/libva/va/va_drmcommon.h"
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 #endif  // USE_X11
 
 using content_common_gpu_media::kModuleVa;
 #if defined(USE_X11)
 using content_common_gpu_media::kModuleVa_x11;
 #elif defined(USE_OZONE)
 using content_common_gpu_media::kModuleVa_drm;
 #endif  // USE_X11
@@ skipping 105 matching lines @@
 
 VaapiWrapper::~VaapiWrapper() {
   DestroyPendingBuffers();
   DestroyCodedBuffers();
   DestroySurfaces();
   DeinitializeVpp();
   Deinitialize();
 }
 
 // static
-scoped_ptr<VaapiWrapper> VaapiWrapper::Create(
+scoped_refptr<VaapiWrapper> VaapiWrapper::Create(
     CodecMode mode,
     VAProfile va_profile,
     const base::Closure& report_error_to_uma_cb) {
   if (!profile_infos_.Get().IsProfileSupported(mode, va_profile)) {
     DVLOG(1) << "Unsupported va_profile: " << va_profile;
     return nullptr;
   }
 
-  scoped_ptr<VaapiWrapper> vaapi_wrapper(new VaapiWrapper());
+  scoped_refptr<VaapiWrapper> vaapi_wrapper(new VaapiWrapper());
   if (vaapi_wrapper->VaInitialize(report_error_to_uma_cb)) {
     if (vaapi_wrapper->Initialize(mode, va_profile))
       return vaapi_wrapper.Pass();

[Pawel Osciak, 2015/11/20 10:09:18]

Pass() should not be needed, here and below.

[william.xie1, 2015/11/23 03:33:58]

Done.

   }
   LOG(ERROR) << "Failed to create VaapiWrapper for va_profile: " << va_profile;
   return nullptr;
 }
 
 // static
-scoped_ptr<VaapiWrapper> VaapiWrapper::CreateForVideoCodec(
+scoped_refptr<VaapiWrapper> VaapiWrapper::CreateForVideoCodec(
     CodecMode mode,
     media::VideoCodecProfile profile,
     const base::Closure& report_error_to_uma_cb) {
   VAProfile va_profile = ProfileToVAProfile(profile, mode);
-  scoped_ptr<VaapiWrapper> vaapi_wrapper =
+  scoped_refptr<VaapiWrapper> vaapi_wrapper =
       Create(mode, va_profile, report_error_to_uma_cb);
   return vaapi_wrapper.Pass();
 }
 
 // static
 media::VideoEncodeAccelerator::SupportedProfiles
 VaapiWrapper::GetSupportedEncodeProfiles() {
   media::VideoEncodeAccelerator::SupportedProfiles profiles;
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   if (cmd_line->HasSwitch(switches::kDisableVaapiAcceleratedVideoEncode))
@@ skipping 84 matching lines @@
     // (which in practice is true for a great majority of cases).
     if (profile_infos_.Get().IsProfileSupported(
           mode, VAProfileH264ConstrainedBaseline)) {
       va_profile = VAProfileH264ConstrainedBaseline;
       DVLOG(1) << "Fall back to constrained baseline profile.";
     }
   }
   return va_profile;
 }
 
+// static
+uint32_t VaapiWrapper::BufferFormatToVAFourCC(gfx::BufferFormat fmt) {
+  switch (fmt) {
+    case gfx::BufferFormat::BGRX_8888:
+      return VA_FOURCC_BGRX;
+    case gfx::BufferFormat::UYVY_422:
+      return VA_FOURCC_UYVY;
+    default:
+      NOTREACHED();
+      return 0;
+  }
+}
+
+// static
+uint32_t VaapiWrapper::BufferFormatToVARTFormat(gfx::BufferFormat fmt) {
+  switch (fmt) {
+    case gfx::BufferFormat::UYVY_422:
+      return VA_RT_FORMAT_YUV422;
+    case gfx::BufferFormat::BGRX_8888:
+      return VA_RT_FORMAT_RGB32;
+    default:
+      NOTREACHED();
+      return 0;
+  }
+}
+
 std::vector<VaapiWrapper::ProfileInfo>
 VaapiWrapper::GetSupportedProfileInfosForCodecModeInternal(CodecMode mode) {
   std::vector<ProfileInfo> supported_profile_infos;
   std::vector<VAProfile> va_profiles;
   if (!GetSupportedVaProfiles(&va_profiles))
     return supported_profile_infos;
 
   std::vector<VAConfigAttrib> required_attribs = GetRequiredAttribs(mode);
   VAEntrypoint entrypoint =
       (mode == kEncode ? VAEntrypointEncSlice: VAEntrypointVLD);
@@ skipping 297 matching lines @@
   // This is safe to use Unretained() here, because the VDA takes care
   // of the destruction order. All the surfaces will be destroyed
   // before VaapiWrapper.
   va_surface = new VASurface(
       va_surface_id, size, va_format,
       base::Bind(&VaapiWrapper::DestroyUnownedSurface, base::Unretained(this)));
 
   return va_surface;
 }
 
+scoped_refptr<VASurface> VaapiWrapper::CreateVASurfaceForPixmap(
+    scoped_refptr<ui::NativePixmap> pixmap,
+    gfx::Size pixmap_size) {
+  // Get the dmabuf of the created buffer.
+  int dmabuf_fd = pixmap->GetDmaBufFd();
+  if (dmabuf_fd < 0) {
+    LOG(ERROR) << "Failed to get dmabuf from an Ozone NativePixmap";
+    return nullptr;
+  }
+  int dmabuf_pitch = pixmap->GetDmaBufPitch();
+
+  // Create a VASurface out of the created buffer using the dmabuf.
+  VASurfaceAttribExternalBuffers va_attrib_extbuf;
+  memset(&va_attrib_extbuf, 0, sizeof(va_attrib_extbuf));
+  va_attrib_extbuf.pixel_format =
+      BufferFormatToVAFourCC(pixmap->GetBufferFormat());
+  va_attrib_extbuf.width = pixmap_size.width();
+  va_attrib_extbuf.height = pixmap_size.height();
+  va_attrib_extbuf.data_size = pixmap_size.height() * dmabuf_pitch;
+  va_attrib_extbuf.num_planes = 1;
+  va_attrib_extbuf.pitches[0] = dmabuf_pitch;
+  va_attrib_extbuf.offsets[0] = 0;
+  va_attrib_extbuf.buffers = reinterpret_cast<unsigned long*>(&dmabuf_fd);
+  va_attrib_extbuf.num_buffers = 1;
+  va_attrib_extbuf.flags = 0;
+  va_attrib_extbuf.private_data = NULL;
+
+  std::vector<VASurfaceAttrib> va_attribs;
+  va_attribs.resize(2);
+
+  va_attribs[0].type = VASurfaceAttribMemoryType;
+  va_attribs[0].flags = VA_SURFACE_ATTRIB_SETTABLE;
+  va_attribs[0].value.type = VAGenericValueTypeInteger;
+  va_attribs[0].value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME;
+
+  va_attribs[1].type = VASurfaceAttribExternalBufferDescriptor;
+  va_attribs[1].flags = VA_SURFACE_ATTRIB_SETTABLE;
+  va_attribs[1].value.type = VAGenericValueTypePointer;
+  va_attribs[1].value.value.p = &va_attrib_extbuf;
+
+  scoped_refptr<VASurface> va_surface =
+      CreateUnownedSurface(BufferFormatToVARTFormat(pixmap->GetBufferFormat()),
+                           pixmap_size, va_attribs);
+  if (!va_surface) {
+    LOG(ERROR) << "Failed to create VASurface for an Ozone NativePixmap";
+    return nullptr;
+  }
+
+  return va_surface;
+}
+
 void VaapiWrapper::DestroyUnownedSurface(VASurfaceID va_surface_id) {
   base::AutoLock auto_lock(*va_lock_);
 
   VAStatus va_res = vaDestroySurfaces(va_display_, &va_surface_id, 1);
   VA_LOG_ON_ERROR(va_res, "vaDestroySurfaces on surface failed");
 }
 
 bool VaapiWrapper::SubmitBuffer(VABufferType va_buffer_type,
                                 size_t size,
                                 void* buffer) {
@@ skipping 458 matching lines @@
 #elif defined(USE_OZONE)
   paths[kModuleVa_drm].push_back("libva-drm.so.1");
 #endif
 
   return InitializeStubs(paths);
 }
 
 VaapiWrapper::LazyProfileInfos::LazyProfileInfos() {
   static_assert(arraysize(supported_profiles_) == kCodecModeMax,
                 "The array size of supported profile is incorrect.");
-  scoped_ptr<VaapiWrapper> vaapi_wrapper(new VaapiWrapper());
+  scoped_refptr<VaapiWrapper> vaapi_wrapper(new VaapiWrapper());
   if (!vaapi_wrapper->VaInitialize(base::Bind(&base::DoNothing)))
     return;
   for (size_t i = 0; i < kCodecModeMax; ++i) {
     supported_profiles_[i] =
         vaapi_wrapper->GetSupportedProfileInfosForCodecModeInternal(
             static_cast<CodecMode>(i));
   }
 }
 
 VaapiWrapper::LazyProfileInfos::~LazyProfileInfos() {
@@ skipping 74 matching lines @@
   drm_fd_.reset(HANDLE_EINTR(dup(fd)));
 }
 #endif  // USE_OZONE
 
 bool VaapiWrapper::VADisplayState::VAAPIVersionLessThan(int major, int minor) {
   return (major_version_ < major) ||
       (major_version_ == major && minor_version_ < minor);
 }
 
 }  // namespace content