[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 14 matching lines @@
   } while (0)
 
 #define VA_SUCCESS_OR_RETURN(va_error, err_msg, ret)       \
   do {                                                     \
     if ((va_error) != VA_STATUS_SUCCESS) {                 \
       LOG_VA_ERROR_AND_REPORT(va_error, err_msg);          \
       return (ret);                                        \
     }                                                      \
   } while (0)
 
+namespace {
+
+uint32_t 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;
+  }
+}
+
+uint32_t 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;
+  }
+}
+
+}  // namespace
+
 namespace content {
 
 // Maximum framerate of encoded profile. This value is an arbitary limit
 // and not taken from HW documentation.
 const int kMaxEncoderFramerate = 30;
 
 base::LazyInstance<VaapiWrapper::VADisplayState>
     VaapiWrapper::va_display_state_ = LAZY_INSTANCE_INITIALIZER;
 
 base::LazyInstance<VaapiWrapper::LazyProfileInfos>
@@ skipping 71 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();
+      return vaapi_wrapper;
   }
   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();
+  return vaapi_wrapper;
 }
 
 // static
 media::VideoEncodeAccelerator::SupportedProfiles
 VaapiWrapper::GetSupportedEncodeProfiles() {
   media::VideoEncodeAccelerator::SupportedProfiles profiles;
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   if (cmd_line->HasSwitch(switches::kDisableVaapiAcceleratedVideoEncode))
     return profiles;
 
@@ skipping 82 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;
 }
 
+scoped_refptr<ui::NativePixmap> VaapiWrapper::ProcessPixmap(
+    const scoped_refptr<ui::NativePixmap>& source_pixmap,
+    const gfx::Size& target_size,
+    gfx::BufferFormat target_format) {
+  scoped_refptr<VASurface> va_surface =
+      CreateVASurfaceForPixmap(source_pixmap, source_pixmap->size());

[kalyank, 2015/11/23 17:51:07]

Now, we create va surface of original pixmap, only to destroy it immediately.
This doesn't look good. How expensive is this (i.e. Is this just a wrapper to
dma_buf id here or will result in some copy etc) ? 

[william.xie1, 2015/11/24 06:19:39]

Dear Kalyan, I measured the cost, it is quit light, less than 1ms,
so it is just a wrapper to dma_buf, no copy.
Regarding to destroying the pixmap immediately, libdrm has optimization for this
usage. There is a cache list in libdrm to reuse the previous "freed" dma buffer
objects as long as the size and format are matched. So the pixmaps are not freed
by libdrm actually, but cached for next allocation.

[kalyank, 2015/11/24 23:00:24]

MiniGBM doesn't use dri infrastructure internally and hence cannot use this.
However, It should be ok if in media driver, va surface would internally just
ref the dma_buf and not blit/copy from it.

+  if (!va_surface) {
+    LOG(ERROR) << "Failed creating VA Surface for source_pixmap";
+    return nullptr;
+  }
+
+  scoped_refptr<ui::NativePixmap> processed_pixmap =
+      CreateNativePixmap(target_size, target_format);
+  if (!processed_pixmap) {
+    LOG(ERROR) << "Failed creating an Ozone NativePixmap for processing";
+    return nullptr;
+  }
+
+  scoped_refptr<VASurface> processed_va_surface =
+      CreateVASurfaceForPixmap(processed_pixmap, target_size);
+  if (!processed_va_surface) {
+    LOG(ERROR) << "Failed creating processed VA Surface for pixmap";
+    return nullptr;
+  }
+
+  DCHECK(processed_pixmap);
+  if (!BlitSurface(va_surface, processed_va_surface)) {
+    LOG(ERROR) << "Failed scaling NativePixmap";
+    return nullptr;
+  }
+
+  return processed_pixmap;
+}
+
+scoped_refptr<ui::NativePixmap> VaapiWrapper::CreateNativePixmap(
+    gfx::Size size,
+    gfx::BufferFormat format) {
+  ui::OzonePlatform* platform = ui::OzonePlatform::GetInstance();
+  ui::SurfaceFactoryOzone* factory = platform->GetSurfaceFactoryOzone();
+
+  // Create a buffer from Ozone.
+  return factory->CreateNativePixmap(gfx::kNullAcceleratedWidget, size, format,
+                                     gfx::BufferUsage::SCANOUT);
+}
+
 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(
+    const scoped_refptr<ui::NativePixmap>& pixmap,
+    const 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