Revert of 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 gfx::Size& size,
-                     const ReleaseCB& release_cb)
-    : va_surface_id_(va_surface_id), size_(size), release_cb_(release_cb) {
+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),
       va_initialized_(false) {
 }
 
 VaapiWrapper::~VaapiWrapper() {
   DestroyPendingBuffers();
   DestroyCodedBuffers();
   DestroySurfaces();
   Deinitialize();
 }
 
-scoped_refptr<VaapiWrapper> VaapiWrapper::Create(
+scoped_ptr<VaapiWrapper> VaapiWrapper::Create(
     CodecMode mode,
     media::VideoCodecProfile profile,
+    Display* x_display,
     const base::Closure& report_error_to_uma_cb) {
-  scoped_refptr<VaapiWrapper> vaapi_wrapper(new VaapiWrapper());
+  scoped_ptr<VaapiWrapper> vaapi_wrapper(new VaapiWrapper());
 
-  if (!vaapi_wrapper->Initialize(mode, profile, report_error_to_uma_cb))
-    vaapi_wrapper = NULL;
+  if (!vaapi_wrapper->Initialize(
+          mode, profile, x_display, report_error_to_uma_cb))
+    vaapi_wrapper.reset();
 
-  return vaapi_wrapper;
+  return vaapi_wrapper.Pass();
 }
 
 std::vector<media::VideoCodecProfile> VaapiWrapper::GetSupportedEncodeProfiles(
+    Display* x_display,
     const base::Closure& report_error_to_uma_cb) {
   std::vector<media::VideoCodecProfile> supported_profiles;
 
-  scoped_refptr<VaapiWrapper> wrapper(new VaapiWrapper());
-  if (!wrapper->VaInitialize(report_error_to_uma_cb)) {
+  scoped_ptr<VaapiWrapper> wrapper(new VaapiWrapper());
+  if (!wrapper->VaInitialize(x_display, 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(const base::Closure& report_error_to_uma_cb) {
+bool VaapiWrapper::VaInitialize(Display* x_display,
+                                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_);
 
-#if defined(USE_X11)
-  va_display_ = vaGetDisplay(gfx::GetXDisplay());
-#endif  // USE_X11
-
+  va_display_ = vaGetDisplay(x_display);
   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(report_error_to_uma_cb))
+  if (!VaInitialize(x_display, 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(const gfx::Size& size,
+bool VaapiWrapper::CreateSurfaces(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;
 }
 
+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;
+}
+
 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
   va_res = vaDeriveImage(va_display_, va_surface_id, image);
@@ skipping 120 matching lines @@
   VA_LOG_ON_ERROR(va_res, "vaUnmapBuffer failed");
 
   va_res = vaDestroyBuffer(va_display_, buffer_id);
   VA_LOG_ON_ERROR(va_res, "vaDestroyBuffer failed");
 
   DCHECK(coded_buffers_.erase(buffer_id));
 
   return buffer_segment == NULL;
 }
 
-#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
-
 // static
 bool VaapiWrapper::PostSandboxInitialization() {
   StubPathMap paths;
-
-  paths[kModuleVa].push_back("libva.so.1");
-
-#if defined(USE_X11)
-  paths[kModuleVa_x11].push_back("libva-x11.so.1");
-#endif
+  paths[kModuleVa].push_back(kVaLib);
 
   return InitializeStubs(paths);
 }
 
 }  // namespace content