content: Add support for Video Decode Acceleration on GBM

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/logging.h"
 #include "base/numerics/safe_conversions.h"
 // Auto-generated for dlopen libva libraries
 #include "content/common/gpu/media/va_stubs.h"
 #include "third_party/libyuv/include/libyuv.h"
 
+#if defined(USE_X11)
 using content_common_gpu_media::kModuleVa;
+#else
+using content_common_gpu_media::kModuleVa_drm;
+#endif
 using content_common_gpu_media::InitializeStubs;
 using content_common_gpu_media::StubPathMap;
 
 // libva-x11 depends on libva, so dlopen libva-x11 is enough
 static const base::FilePath::CharType kVaLib[] =
+#if defined(USE_X11)
     FILE_PATH_LITERAL("libva-x11.so.1");
+#else
+    FILE_PATH_LITERAL("libva-drm.so.1");
+#endif
 
 #define LOG_VA_ERROR_AND_REPORT(va_error, err_msg)         \
   do {                                                     \
     DVLOG(1) << err_msg                                    \
              << " VA error: " << vaErrorStr(va_error);     \
     report_error_to_uma_cb_.Run();                         \
   } while (0)
 
 #define VA_LOG_ON_ERROR(va_error, err_msg)                 \
   do {                                                     \
@@ skipping 87 matching lines @@
 VaapiWrapper::~VaapiWrapper() {
   DestroyPendingBuffers();
   DestroyCodedBuffers();
   DestroySurfaces();
   Deinitialize();
 }
 
 scoped_ptr<VaapiWrapper> VaapiWrapper::Create(
     CodecMode mode,
     media::VideoCodecProfile profile,
-    Display* x_display,
+#if defined(USE_X11)
+    Display* display,
+#else
+    int display,
+#endif
     const base::Closure& report_error_to_uma_cb) {
   scoped_ptr<VaapiWrapper> vaapi_wrapper(new VaapiWrapper());
 
   if (!vaapi_wrapper->Initialize(
-          mode, profile, x_display, report_error_to_uma_cb))
+          mode, profile, display, report_error_to_uma_cb))
     vaapi_wrapper.reset();
 
   return vaapi_wrapper.Pass();
 }
 
 void VaapiWrapper::TryToSetVADisplayAttributeToLocalGPU() {
   VADisplayAttribute item = {VADisplayAttribRenderMode,
                              1,  // At least support '_LOCAL_OVERLAY'.
                              -1,  // The maximum possible support 'ALL'.
                              VA_RENDER_MODE_LOCAL_GPU,
                              VA_DISPLAY_ATTRIB_SETTABLE};
 
   VAStatus va_res = vaSetDisplayAttributes(va_display_, &item, 1);
   if (va_res != VA_STATUS_SUCCESS)
     DVLOG(2) << "vaSetDisplayAttributes unsupported, ignoring by default.";
 }
 
 bool VaapiWrapper::Initialize(CodecMode mode,
                               media::VideoCodecProfile profile,
+#if defined(USE_X11)
                               Display* x_display,
+#else
+                              int display,
+#endif
                               const base::Closure& report_error_to_uma_cb) {
   static bool vaapi_functions_initialized = PostSandboxInitialization();
   if (!vaapi_functions_initialized) {
     DVLOG(1) << "Failed to initialize VAAPI libs";
     return false;
   }
 
   report_error_to_uma_cb_ = report_error_to_uma_cb;
 
   base::AutoLock auto_lock(va_lock_);
-
+#if defined(USE_X11)
   va_display_ = vaGetDisplay(x_display);
+#else
+  va_display_ = vaGetDisplayDRM(display);
+#endif
   if (!vaDisplayIsValid(va_display_)) {
     DVLOG(1) << "Could not get a valid VA display";
     return false;
   }
 
   VAStatus va_res = vaInitialize(va_display_, &major_version_, &minor_version_);
   VA_SUCCESS_OR_RETURN(va_res, "vaInitialize failed", false);
   DVLOG(1) << "VAAPI version: " << major_version_ << "." << minor_version_;
 
   if (VAAPIVersionLessThan(0, 34)) {
@@ skipping 320 matching lines @@
 
   return true;
 }
 
 bool VaapiWrapper::ExecuteAndDestroyPendingBuffers(VASurfaceID va_surface_id) {
   bool result = Execute(va_surface_id);
   DestroyPendingBuffers();
   return result;
 }
 
+#if defined(USE_X11)
 bool VaapiWrapper::PutSurfaceIntoPixmap(VASurfaceID va_surface_id,
                                         Pixmap x_pixmap,
                                         gfx::Size dest_size) {
   base::AutoLock auto_lock(va_lock_);
 
   VAStatus va_res = vaSyncSurface(va_display_, va_surface_id);
   VA_SUCCESS_OR_RETURN(va_res, "Failed syncing surface", false);
 
   // Put the data into an X Pixmap.
   va_res = vaPutSurface(va_display_,
                         va_surface_id,
                         x_pixmap,
                         0, 0, dest_size.width(), dest_size.height(),
                         0, 0, dest_size.width(), dest_size.height(),
                         NULL, 0, 0);
   VA_SUCCESS_OR_RETURN(va_res, "Failed putting surface to pixmap", false);
   return true;
 }
+#else
+bool VaapiWrapper::CreateRGBImage(gfx::Size size, VAImage* image) {
+  base::AutoLock auto_lock(va_lock_);
+  VAStatus va_res;
+  VAImageFormat format;
+  format.fourcc = VA_FOURCC_RGBX;
+  format.byte_order = VA_LSB_FIRST;
+  format.bits_per_pixel = 32;
+  format.depth = 24;
+  format.red_mask = 0xff;
+  format.green_mask = 0xff00;
+  format.blue_mask = 0xff0000;
+  format.alpha_mask = 0;
+  va_res = vaCreateImage(va_display_,
+                         &format,
+                         size.width(),
+                         size.height(),
+                         image);
+  VA_SUCCESS_OR_RETURN(va_res, "Failed to create image", false);
+  return true;
+}
+
+void VaapiWrapper::DestroyImage(VAImage* image) {
+  base::AutoLock auto_lock(va_lock_);
+  vaDestroyImage(va_display_, image->image_id);
+}
+
+bool VaapiWrapper::MapImage(VAImage* image, void** buffer) {
+  base::AutoLock auto_lock(va_lock_);
+
+  VAStatus va_res = vaMapBuffer(va_display_, image->buf, buffer);
+  VA_SUCCESS_OR_RETURN(va_res, "Failed to map image", false);
+  return true;
+}
+
+void VaapiWrapper::UnmapImage(VAImage* image) {
+  base::AutoLock auto_lock(va_lock_);
+  vaUnmapBuffer(va_display_, image->buf);
+}
+
+bool VaapiWrapper::PutSurfaceIntoImage(VASurfaceID va_surface_id,
+                                       VAImage* image) {
+  base::AutoLock auto_lock(va_lock_);
+  VAStatus va_res = vaSyncSurface(va_display_, va_surface_id);
+  VA_SUCCESS_OR_RETURN(va_res, "Failed syncing surface", false);
+
+  va_res = vaGetImage(va_display_,
+                      va_surface_id,
+                      0,
+                      0,
+                      image->width,
+                      image->height,
+                      image->image_id);
+  VA_SUCCESS_OR_RETURN(va_res, "Failed to put surface into image", false);
+  return true;
+}
+#endif
 
 bool VaapiWrapper::GetVaImageForTesting(VASurfaceID va_surface_id,
                                         VAImage* image,
                                         void** mem) {
   base::AutoLock auto_lock(va_lock_);
 
   VAStatus va_res = vaSyncSurface(va_display_, va_surface_id);
   VA_SUCCESS_OR_RETURN(va_res, "Failed syncing surface", false);
 
   // Derive a VAImage from the VASurface
@@ skipping 124 matching lines @@
   VA_LOG_ON_ERROR(va_res, "vaDestroyBuffer failed");
 
   DCHECK(coded_buffers_.erase(buffer_id));
 
   return buffer_segment == NULL;
 }
 
 // static
 bool VaapiWrapper::PostSandboxInitialization() {
   StubPathMap paths;
+#if defined(USE_X11)
   paths[kModuleVa].push_back(kVaLib);
+#else
+  paths[kModuleVa_drm].push_back(kVaLib);
+#endif
 
   return InitializeStubs(paths);
 }
 
 }  // namespace content