VAVDA: Redesign stage 1.

content/common/gpu/media/vaapi_wrapper.cc

Index: content/common/gpu/media/vaapi_wrapper.cc
diff --git a/content/common/gpu/media/vaapi_wrapper.cc b/content/common/gpu/media/vaapi_wrapper.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8ff01524a47f2099cfde596702c5446cf0245a01
--- /dev/null
+++ b/content/common/gpu/media/vaapi_wrapper.cc
@@ -0,0 +1,453 @@
+// Copyright (c) 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 <dlfcn.h>
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "content/common/gpu/media/vaapi_wrapper.h"
+
+#define LOG_VA_ERROR_AND_REPORT(va_error, err_msg)         \
+  do {                                                     \
+    DVLOG(1) << err_msg                                    \
+             << " VA error: " << VAAPI_ErrorStr(va_error); \
+    report_error_to_uma_cb_.Run();                         \
+  } while (0)
+
+#define VA_LOG_ON_ERROR(va_error, err_msg)                 \
+  do {                                                     \
+    if ((va_error) != VA_STATUS_SUCCESS)                   \
+      LOG_VA_ERROR_AND_REPORT(va_error, err_msg);          \
+  } 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 content {
+
+static void *vaapi_handle = NULL;
+static void *vaapi_x11_handle = NULL;
+
+typedef VAStatus (*VaapiBeginPicture)(VADisplay dpy,
+                                      VAContextID context,
+                                      VASurfaceID render_target);
+typedef VAStatus (*VaapiCreateBuffer)(VADisplay dpy,
+                                      VAContextID context,
+                                      VABufferType type,
+                                      unsigned int size,
+                                      unsigned int num_elements,
+                                      void *data,
+                                      VABufferID *buf_id);
+typedef VAStatus (*VaapiCreateConfig)(VADisplay dpy,
+                                      VAProfile profile,
+                                      VAEntrypoint entrypoint,
+                                      VAConfigAttrib *attrib_list,
+                                      int num_attribs,
+                                      VAConfigID *config_id);
+typedef VAStatus (*VaapiCreateContext)(VADisplay dpy,
+                                       VAConfigID config_id,
+                                       int picture_width,
+                                       int picture_height,
+                                       int flag,
+                                       VASurfaceID *render_targets,
+                                       int num_render_targets,
+                                       VAContextID *context);
+typedef VAStatus (*VaapiCreateSurfaces)(VADisplay dpy,
+                                        int width,
+                                        int height,
+                                        int format,
+                                        int num_surfaces,
+                                        VASurfaceID *surfaces);
+typedef VAStatus (*VaapiDestroyBuffer)(VADisplay dpy, VABufferID buffer_id);
+typedef VAStatus (*VaapiDestroyConfig)(VADisplay dpy, VAConfigID config_id);
+typedef VAStatus (*VaapiDestroyContext)(VADisplay dpy, VAContextID context);
+typedef VAStatus (*VaapiDestroySurfaces)(VADisplay dpy,
+                                         VASurfaceID *surfaces,
+                                         int num_surfaces);
+typedef int (*VaapiDisplayIsValid)(VADisplay dpy);
+typedef VAStatus (*VaapiEndPicture)(VADisplay dpy, VAContextID context);
+typedef const char* (*VaapiErrorStr)(VAStatus error_status);
+typedef VAStatus (*VaapiGetConfigAttributes)(VADisplay dpy,
+                                             VAProfile profile,
+                                             VAEntrypoint entrypoint,
+                                             VAConfigAttrib *attrib_list,
+                                             int num_attribs);
+typedef VADisplay (*VaapiGetDisplay)(Display *dpy);
+typedef VAStatus (*VaapiInitialize)(VADisplay dpy,
+                                    int *major_version,
+                                    int *minor_version);
+typedef VAStatus (*VaapiPutSurface)(VADisplay dpy,
+                                    VASurfaceID surface,
+                                    Drawable draw,
+                                    short srcx,
+                                    short srcy,
+                                    unsigned short srcw,
+                                    unsigned short srch,
+                                    short destx,
+                                    short desty,
+                                    unsigned short destw,
+                                    unsigned short desth,
+                                    VARectangle *cliprects,
+                                    unsigned int number_cliprects,
+                                    unsigned int flags);
+typedef VAStatus (*VaapiRenderPicture)(VADisplay dpy,
+                                       VAContextID context,
+                                       VABufferID *buffers,
+                                       int num_buffers);
+typedef VAStatus (*VaapiSyncSurface)(VADisplay dpy, VASurfaceID render_target);
+typedef VAStatus (*VaapiTerminate)(VADisplay dpy);
+
+#define VAAPI_SYM(name, handle) Vaapi##name VAAPI_##name = NULL
+
+VAAPI_SYM(BeginPicture, vaapi_handle);
+VAAPI_SYM(CreateBuffer, vaapi_handle);
+VAAPI_SYM(CreateConfig, vaapi_handle);
+VAAPI_SYM(CreateContext, vaapi_handle);
+VAAPI_SYM(CreateSurfaces, vaapi_handle);
+VAAPI_SYM(DestroyBuffer, vaapi_handle);
+VAAPI_SYM(DestroyConfig, vaapi_handle);
+VAAPI_SYM(DestroyContext, vaapi_handle);
+VAAPI_SYM(DestroySurfaces, vaapi_handle);
+VAAPI_SYM(DisplayIsValid, vaapi_handle);
+VAAPI_SYM(EndPicture, vaapi_handle);
+VAAPI_SYM(ErrorStr, vaapi_handle);
+VAAPI_SYM(GetConfigAttributes, vaapi_handle);
+VAAPI_SYM(GetDisplay, vaapi_x11_handle);
+VAAPI_SYM(Initialize, vaapi_handle);
+VAAPI_SYM(PutSurface, vaapi_x11_handle);
+VAAPI_SYM(RenderPicture, vaapi_handle);
+VAAPI_SYM(SyncSurface, vaapi_x11_handle);
+VAAPI_SYM(Terminate, vaapi_handle);
+
+#undef VAAPI_SYM
+
+// Maps Profile enum values to VaProfile values.
+static bool ProfileToVAProfile(media::VideoCodecProfile profile,
+                               VAProfile* va_profile) {
+  switch (profile) {
+    case media::H264PROFILE_BASELINE:
+      *va_profile = VAProfileH264Baseline;
+      break;
+    case media::H264PROFILE_MAIN:
+      *va_profile = VAProfileH264Main;
+      break;
+    // TODO(posciak): See if we can/want support other variants
+    // of media::H264PROFILE_HIGH*.
+    case media::H264PROFILE_HIGH:
+      *va_profile = VAProfileH264High;
+      break;
+    default:
+      return false;
+  }
+  return true;
+}
+
+VASurface::VASurface(VASurfaceID va_surface_id, const ReleaseCB& release_cb)
+    : va_surface_id_(va_surface_id),
+      release_cb_(release_cb) {
+  DCHECK(!release_cb_.is_null());
+}
+
+VASurface::~VASurface() {
+  release_cb_.Run(va_surface_id_);
+}
+
+VaapiWrapper::VaapiWrapper()
+    : va_display_(NULL),
+      va_config_id_(VA_INVALID_ID),
+      va_context_id_(VA_INVALID_ID) {
+}
+
+VaapiWrapper::~VaapiWrapper() {
+  DestroyPendingBuffers();
+  DestroySurfaces();
+  Deinitialize();
+}
+
+scoped_ptr<VaapiWrapper> VaapiWrapper::Create(
+    media::VideoCodecProfile profile,
+    Display* x_display,
+    const base::Closure& report_error_to_uma_cb) {
+  scoped_ptr<VaapiWrapper> vaapi_wrapper(new VaapiWrapper());
+
+  if (!vaapi_wrapper->Initialize(profile, x_display, report_error_to_uma_cb))
+    vaapi_wrapper.reset();
+
+  return vaapi_wrapper.Pass();
+}
+
+bool VaapiWrapper::Initialize(media::VideoCodecProfile profile,
+                              Display* x_display,
+                              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_);
+
+  VAProfile va_profile;
+  if (!ProfileToVAProfile(profile, &va_profile)) {
+    DVLOG(1) << "Unsupported profile";
+    return false;
+  }
+
+  va_display_ = VAAPI_GetDisplay(x_display);
+  if (!VAAPI_DisplayIsValid(va_display_)) {
+    DVLOG(1) << "Could not get a valid VA display";
+    return false;
+  }
+
+  int major_version, minor_version;
+  VAStatus va_res;
+  va_res = VAAPI_Initialize(va_display_, &major_version, &minor_version);
+  VA_SUCCESS_OR_RETURN(va_res, "vaInitialize failed", false);
+  DVLOG(1) << "VAAPI version: " << major_version << "." << minor_version;
+
+  VAConfigAttrib attrib = {VAConfigAttribRTFormat, 0};
+
+  const VAEntrypoint kEntrypoint = VAEntrypointVLD;
+  va_res = VAAPI_GetConfigAttributes(va_display_, va_profile, kEntrypoint,
+                                     &attrib, 1);
+  VA_SUCCESS_OR_RETURN(va_res, "vaGetConfigAttributes failed", false);
+
+  if (!(attrib.value & VA_RT_FORMAT_YUV420)) {
+    DVLOG(1) << "YUV420 not supported by this VAAPI implementation";
+    return false;
+  }
+
+  va_res = VAAPI_CreateConfig(va_display_, va_profile, kEntrypoint,
+                              &attrib, 1, &va_config_id_);
+  VA_SUCCESS_OR_RETURN(va_res, "vaCreateConfig failed", false);
+
+  return true;
+}
+
+void VaapiWrapper::Deinitialize() {
+  base::AutoLock auto_lock(va_lock_);
+
+  if (va_config_id_ != VA_INVALID_ID) {
+    VAStatus va_res = VAAPI_DestroyConfig(va_display_, va_config_id_);
+    VA_LOG_ON_ERROR(va_res, "vaDestroyConfig failed");
+  }
+
+  if (va_display_) {
+    VAStatus va_res = VAAPI_Terminate(va_display_);
+    VA_LOG_ON_ERROR(va_res, "vaTerminate failed");
+  }
+
+  va_config_id_ = VA_INVALID_ID;
+  va_display_ = NULL;
+}
+
+bool VaapiWrapper::CreateSurfaces(gfx::Size size,
+                                  size_t num_surfaces,
+                                   std::vector<VASurfaceID>* va_surfaces) {
+  base::AutoLock auto_lock(va_lock_);
+
+  DCHECK(va_surfaces->empty());
+  DCHECK(va_surface_ids_.empty());
+  va_surface_ids_.resize(num_surfaces);
+
+  // Allocate surfaces in driver.
+  VAStatus va_res = VAAPI_CreateSurfaces(va_display_,
+                                         size.width(), size.height(),
+                                         VA_RT_FORMAT_YUV420,
+                                         va_surface_ids_.size(),
+                                         &va_surface_ids_[0]);
+  VA_LOG_ON_ERROR(va_res, "vaCreateSurfaces failed");
+  if (va_res != VA_STATUS_SUCCESS) {
+    va_surface_ids_.clear();
+    return false;
+  }
+
+  // And create a context associated with them.
+  va_res = VAAPI_CreateContext(va_display_, va_config_id_,
+                               size.width(), size.height(), VA_PROGRESSIVE,
+                               &va_surface_ids_[0], va_surface_ids_.size(),
+                               &va_context_id_);
+
+  VA_LOG_ON_ERROR(va_res, "vaCreateContext failed");
+  if (va_res != VA_STATUS_SUCCESS) {
+    DestroySurfaces();
+    return false;
+  }
+
+  *va_surfaces = va_surface_ids_;
+  return true;
+}
+
+void VaapiWrapper::DestroySurfaces() {
+  base::AutoLock auto_lock(va_lock_);
+
+  if (va_context_id_ != VA_INVALID_ID) {
+    VAStatus va_res = VAAPI_DestroyContext(va_display_, va_context_id_);
+    VA_LOG_ON_ERROR(va_res, "vaDestroyContext failed");
+  }
+
+  if (!va_surface_ids_.empty()) {
+    VAStatus va_res = VAAPI_DestroySurfaces(va_display_, &va_surface_ids_[0],
+                                            va_surface_ids_.size());
+    VA_LOG_ON_ERROR(va_res, "vaDestroySurfaces failed");
+  }
+
+  va_surface_ids_.clear();
+  va_context_id_ = VA_INVALID_ID;
+}
+
+bool VaapiWrapper::SubmitBuffer(VABufferType va_buffer_type,
+                                size_t size,
+                                void* buffer) {
+  base::AutoLock auto_lock(va_lock_);
+
+  VABufferID buffer_id;
+  VAStatus va_res = VAAPI_CreateBuffer(va_display_, va_context_id_,
+                                       va_buffer_type, size,
+                                       1, buffer, &buffer_id);
+  VA_SUCCESS_OR_RETURN(va_res, "Failed to create a VA buffer", false);
+
+  switch (va_buffer_type) {
+    case VASliceParameterBufferType:
+    case VASliceDataBufferType:
+      pending_slice_bufs_.push_back(buffer_id);
+      break;
+
+    default:
+      pending_va_bufs_.push_back(buffer_id);
+      break;
+  }
+
+  return true;
+}
+
+void VaapiWrapper::DestroyPendingBuffers() {
+  base::AutoLock auto_lock(va_lock_);
+
+  for (size_t i = 0; i < pending_va_bufs_.size(); ++i) {
+    VAStatus va_res = VAAPI_DestroyBuffer(va_display_, pending_va_bufs_[i]);
+    VA_LOG_ON_ERROR(va_res, "vaDestroyBuffer failed");
+  }
+
+  for (size_t i = 0; i < pending_slice_bufs_.size(); ++i) {
+    VAStatus va_res = VAAPI_DestroyBuffer(va_display_, pending_slice_bufs_[i]);
+    VA_LOG_ON_ERROR(va_res, "vaDestroyBuffer failed");
+  }
+
+  pending_va_bufs_.clear();
+  pending_slice_bufs_.clear();
+}
+
+bool VaapiWrapper::SubmitDecode(VASurfaceID va_surface_id) {
+  base::AutoLock auto_lock(va_lock_);
+
+  DVLOG(4) << "Pending VA bufs to commit: " << pending_va_bufs_.size();
+  DVLOG(4) << "Pending slice bufs to commit: " << pending_slice_bufs_.size();
+  DVLOG(4) << "Decoding into VA surface " << va_surface_id;
+
+  // Get ready to decode into surface.
+  VAStatus va_res = VAAPI_BeginPicture(va_display_, va_context_id_,
+                                       va_surface_id);
+  VA_SUCCESS_OR_RETURN(va_res, "vaBeginPicture failed", false);
+
+  // Commit parameter and slice buffers.
+  va_res = VAAPI_RenderPicture(va_display_, va_context_id_,
+                               &pending_va_bufs_[0], pending_va_bufs_.size());
+  VA_SUCCESS_OR_RETURN(va_res, "vaRenderPicture for va_bufs failed", false);
+
+  va_res = VAAPI_RenderPicture(va_display_, va_context_id_,
+                               &pending_slice_bufs_[0],
+                               pending_slice_bufs_.size());
+  VA_SUCCESS_OR_RETURN(va_res, "vaRenderPicture for slices failed", false);
+
+  // Instruct HW decoder to start processing committed buffers (decode this
+  // picture). This does not block until the end of decode.
+  va_res = VAAPI_EndPicture(va_display_, va_context_id_);
+  VA_SUCCESS_OR_RETURN(va_res, "vaEndPicture failed", false);
+
+  return true;
+}
+
+bool VaapiWrapper::DecodeAndDestroyPendingBuffers(VASurfaceID va_surface_id) {
+  bool result = SubmitDecode(va_surface_id);
+  DestroyPendingBuffers();
+  return result;
+}
+
+bool VaapiWrapper::PutSurfaceIntoPixmap(VASurfaceID va_surface_id,
+                                        Pixmap x_pixmap,
+                                        gfx::Size dest_size) {
+  base::AutoLock auto_lock(va_lock_);
+
+  VAStatus va_res = VAAPI_SyncSurface(va_display_, va_surface_id);
+  VA_SUCCESS_OR_RETURN(va_res, "Failed syncing surface", false);
+
+  // Put the data into an X Pixmap.
+  va_res = VAAPI_PutSurface(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 decode surface to pixmap",
+                       false);
+  return true;
+}
+
+// static
+bool VaapiWrapper::pre_sandbox_init_done_ = false;
+
+// static
+void VaapiWrapper::PreSandboxInitialization() {
+  DCHECK(!pre_sandbox_init_done_);
+  vaapi_handle = dlopen("libva.so", RTLD_NOW);
+  vaapi_x11_handle = dlopen("libva-x11.so", RTLD_NOW);
+  pre_sandbox_init_done_ = vaapi_handle && vaapi_x11_handle;
+}
+
+// static
+bool VaapiWrapper::PostSandboxInitialization() {
+  if (!pre_sandbox_init_done_)
+    return false;
+#define VAAPI_DLSYM_OR_RETURN_ON_ERROR(name, handle)                          \
+  do {                                                                        \
+    VAAPI_##name = reinterpret_cast<Vaapi##name>(dlsym((handle), "va"#name)); \
+    if (VAAPI_##name == NULL) {                                               \
+      DVLOG(1) << "Failed to dlsym va"#name;                                  \
+      return false;                                                           \
+    }                                                                         \
+  } while (0)
+
+  VAAPI_DLSYM_OR_RETURN_ON_ERROR(BeginPicture, vaapi_handle);
+  VAAPI_DLSYM_OR_RETURN_ON_ERROR(CreateBuffer, vaapi_handle);
+  VAAPI_DLSYM_OR_RETURN_ON_ERROR(CreateConfig, vaapi_handle);
+  VAAPI_DLSYM_OR_RETURN_ON_ERROR(CreateContext, vaapi_handle);
+  VAAPI_DLSYM_OR_RETURN_ON_ERROR(CreateSurfaces, vaapi_handle);
+  VAAPI_DLSYM_OR_RETURN_ON_ERROR(DestroyBuffer, vaapi_handle);
+  VAAPI_DLSYM_OR_RETURN_ON_ERROR(DestroyConfig, vaapi_handle);
+  VAAPI_DLSYM_OR_RETURN_ON_ERROR(DestroyContext, vaapi_handle);
+  VAAPI_DLSYM_OR_RETURN_ON_ERROR(DestroySurfaces, vaapi_handle);
+  VAAPI_DLSYM_OR_RETURN_ON_ERROR(DisplayIsValid, vaapi_handle);
+  VAAPI_DLSYM_OR_RETURN_ON_ERROR(EndPicture, vaapi_handle);
+  VAAPI_DLSYM_OR_RETURN_ON_ERROR(ErrorStr, vaapi_handle);
+  VAAPI_DLSYM_OR_RETURN_ON_ERROR(GetConfigAttributes, vaapi_handle);
+  VAAPI_DLSYM_OR_RETURN_ON_ERROR(GetDisplay, vaapi_x11_handle);
+  VAAPI_DLSYM_OR_RETURN_ON_ERROR(Initialize, vaapi_handle);
+  VAAPI_DLSYM_OR_RETURN_ON_ERROR(PutSurface, vaapi_x11_handle);
+  VAAPI_DLSYM_OR_RETURN_ON_ERROR(RenderPicture, vaapi_handle);
+  VAAPI_DLSYM_OR_RETURN_ON_ERROR(SyncSurface, vaapi_x11_handle);
+  VAAPI_DLSYM_OR_RETURN_ON_ERROR(Terminate, vaapi_handle);
+#undef VAAPI_DLSYM
+
+  return true;
+}
+
+}  // namespace content