Reland: Refactor Vaapi video decoder/encoder in preparation of Freon support

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"
 #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 "third_party/libyuv/include/libyuv.h"
+#include "ui/gl/gl_bindings.h"
+#if defined(USE_X11)
+#include "ui/gfx/x/x11_types.h"
+#endif  // USE_X11
 
 using content_common_gpu_media::kModuleVa;
+#if defined(USE_X11)
+using content_common_gpu_media::kModuleVa_x11;
+#endif  // USE_X11
 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[] =
-    FILE_PATH_LITERAL("libva-x11.so.1");
-
 #define LOG_VA_ERROR_AND_REPORT(va_error, err_msg)         \
   do {                                                     \
     LOG(ERROR) << 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 {                                                     \
     if ((va_error) != VA_STATUS_SUCCESS)                   \
@@ skipping 80 matching lines @@
                   VAProfileH264ConstrainedBaseline) !=
         supported_profiles.end()) {
       va_profile = VAProfileH264ConstrainedBaseline;
       DVLOG(1) << "Falling back to constrained baseline profile.";
     }
   }
 
   return va_profile;
 }
 
-VASurface::VASurface(VASurfaceID va_surface_id, const ReleaseCB& release_cb)
-    : va_surface_id_(va_surface_id),
-      release_cb_(release_cb) {
+VASurface::VASurface(VASurfaceID va_surface_id,
+                     const gfx::Size& size,
+                     const ReleaseCB& release_cb)
+    : va_surface_id_(va_surface_id), size_(size), 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),
       va_initialized_(false) {
 }
 
 VaapiWrapper::~VaapiWrapper() {

[piman, 2014/12/22 19:21:52]

Can you add a DCHECK that this is called on the main thread?
Also, can you describe why, despite refcounting, this is ensured?

[llandwerlin-old, 2014/12/22 23:36:42]

All the pictures are owned by VaapiVideoDecodeAccelerator, these are the only
classes having references to VaapiWrapper (apart from
VaapiVideoDecodeAccelerator itself).
Therefore when VaapiVideoDecodeAccelerator is destroyed, all the references on
VaapiWrapper will be released and it will be destroyed by the same thread that
destroys VaapiVideoDecodeAccelerator.

I notice (only now) that VaapiH264Decoder has a simple pointer to VaapiWrapper.
I guess we could avoid refcounting entirely, the destruction of the resources
doesn't change thread before/after this CL. We're just trying to make the code
look like it's been called from different places.

   DestroyPendingBuffers();
   DestroyCodedBuffers();
   DestroySurfaces();
   Deinitialize();
 }
 
-scoped_ptr<VaapiWrapper> VaapiWrapper::Create(
+scoped_refptr<VaapiWrapper> VaapiWrapper::Create(
     CodecMode mode,
     media::VideoCodecProfile profile,
-    Display* x_display,
     const base::Closure& report_error_to_uma_cb) {
-  scoped_ptr<VaapiWrapper> vaapi_wrapper(new VaapiWrapper());
+  scoped_refptr<VaapiWrapper> vaapi_wrapper(new VaapiWrapper());
 
-  if (!vaapi_wrapper->Initialize(
-          mode, profile, x_display, report_error_to_uma_cb))
-    vaapi_wrapper.reset();
+  if (!vaapi_wrapper->Initialize(mode, profile, report_error_to_uma_cb))
+    vaapi_wrapper = NULL;
 
-  return vaapi_wrapper.Pass();
+  return vaapi_wrapper;
 }
 
 std::vector<media::VideoCodecProfile> VaapiWrapper::GetSupportedEncodeProfiles(
-    Display* x_display,
     const base::Closure& report_error_to_uma_cb) {
   std::vector<media::VideoCodecProfile> supported_profiles;
 
-  scoped_ptr<VaapiWrapper> wrapper(new VaapiWrapper());
-  if (!wrapper->VaInitialize(x_display, report_error_to_uma_cb)) {
+  scoped_refptr<VaapiWrapper> wrapper(new VaapiWrapper());
+  if (!wrapper->VaInitialize(report_error_to_uma_cb)) {
     return supported_profiles;
   }
 
   std::vector<VAProfile> va_profiles;
   if (!wrapper->GetSupportedVaProfiles(&va_profiles))
     return supported_profiles;
 
   std::vector<VAConfigAttrib> required_attribs = GetRequiredAttribs(kEncode);
   for (size_t i = 0; i < arraysize(kProfileMap); i++) {
     VAProfile va_profile =
@@ skipping 14 matching lines @@
                              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::VaInitialize(Display* x_display,
-                                const base::Closure& report_error_to_uma_cb) {
+bool VaapiWrapper::VaInitialize(const base::Closure& report_error_to_uma_cb) {
   static bool vaapi_functions_initialized = PostSandboxInitialization();
   if (!vaapi_functions_initialized) {
     bool running_on_chromeos = false;
 #if defined(OS_CHROMEOS)
     // When chrome runs on linux with chromeos=1, do not log error message
     // without VAAPI libraries.
     running_on_chromeos = base::SysInfo::IsRunningOnChromeOS();
 #endif
     static const char kErrorMsg[] = "Failed to initialize VAAPI libs";
     if (running_on_chromeos)
       LOG(ERROR) << kErrorMsg;
     else
       DVLOG(1) << kErrorMsg;
     return false;
   }
 
   report_error_to_uma_cb_ = report_error_to_uma_cb;
 
   base::AutoLock auto_lock(va_lock_);
 
-  va_display_ = vaGetDisplay(x_display);
+#if defined(USE_X11)
+  va_display_ = vaGetDisplay(gfx::GetXDisplay());
+#endif  // USE_X11
+
   if (!vaDisplayIsValid(va_display_)) {
     LOG(ERROR) << "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);
   va_initialized_ = true;
   DVLOG(1) << "VAAPI version: " << major_version_ << "." << minor_version_;
 
@@ skipping 76 matching lines @@
       DVLOG(1) << "Unsupported value " << required_attribs[i].value
                << " for attribute type " << required_attribs[i].type;
       return false;
     }
   }
   return true;
 }
 
 bool VaapiWrapper::Initialize(CodecMode mode,
                               media::VideoCodecProfile profile,
-                              Display* x_display,
                               const base::Closure& report_error_to_uma_cb) {
-  if (!VaInitialize(x_display, report_error_to_uma_cb))
+  if (!VaInitialize(report_error_to_uma_cb))
     return false;
   std::vector<VAProfile> supported_va_profiles;
   if (!GetSupportedVaProfiles(&supported_va_profiles))
     return false;
   VAProfile va_profile = ProfileToVAProfile(profile, supported_va_profiles);
   if (va_profile == VAProfileNone) {
     DVLOG(1) << "Unsupported profile";
     return false;
   }
   VAEntrypoint entrypoint =
@@ skipping 39 matching lines @@
   va_config_id_ = VA_INVALID_ID;
   va_display_ = NULL;
   va_initialized_ = false;
 }
 
 bool VaapiWrapper::VAAPIVersionLessThan(int major, int minor) {
   return (major_version_ < major) ||
       (major_version_ == major && minor_version_ < minor);
 }
 
-bool VaapiWrapper::CreateSurfaces(gfx::Size size,
+bool VaapiWrapper::CreateSurfaces(const gfx::Size& size,
                                   size_t num_surfaces,
                                   std::vector<VASurfaceID>* va_surfaces) {
   base::AutoLock auto_lock(va_lock_);
   DVLOG(2) << "Creating " << num_surfaces << " surfaces";
 
   DCHECK(va_surfaces->empty());
   DCHECK(va_surface_ids_.empty());
   va_surface_ids_.resize(num_surfaces);
 
   // Allocate surfaces in driver.
@@ skipping 189 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;
 }
+#endif  // USE_X11
 
 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;
-  paths[kModuleVa].push_back(kVaLib);
+
+  paths[kModuleVa].push_back("libva.so.1");
+
+#if defined(USE_X11)
+  paths[kModuleVa_x11].push_back("libva-x11.so.1");
+#endif
 
   return InitializeStubs(paths);
 }
 
 }  // namespace content