Update libva headers to the latest release (1.2.1).

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 <dlfcn.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "content/common/gpu/media/vaapi_wrapper.h"
 
@@ skipping 40 matching lines @@
                                       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);
+/* In VAAPI version < 0.34, vaCreateSurface has 6 parameters, but in VAAPI

[Pawel Osciak, 2013/11/21 05:36:36]

Please use // style comments (both are allowed, but we should be consistent). I
guess this is a short-lived patch, but just for the future.

[chihchung, 2013/11/21 06:45:18]

Done.

+ * version >= 0.34, vaCreateSurface has 8 parameters. */
+typedef void *VaapiCreateSurfaces;
+typedef VAStatus (*VaapiCreateSurfaces6)(VADisplay dpy,
+                                         int width,
+                                         int height,
+                                         int format,
+                                         int num_surfaces,
+                                         VASurfaceID *surfaces);
+typedef VAStatus (*VaapiCreateSurfaces8)(VADisplay dpy,
+                                         unsigned int format,
+                                         unsigned int width,
+                                         unsigned int height,
+                                         VASurfaceID *surfaces,
+                                         unsigned int num_surfaces,
+                                         VASurfaceAttrib *attrib_list,
+                                         unsigned int num_attribs);
 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,
@@ skipping 123 matching lines @@
     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_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;
+  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";
@@ skipping 17 matching lines @@
 
   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::VAAPIVersionLessThan(int major, int minor) {
+  return (major_version_ < major) ||
+      (major_version_ == major && minor_version_ < minor);
+}
+
 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.
-  VAStatus va_res = VAAPI_CreateSurfaces(va_display_,
-                                         size.width(), size.height(),
-                                         VA_RT_FORMAT_YUV420,
-                                         va_surface_ids_.size(),
-                                         &va_surface_ids_[0]);
+  VAStatus va_res;
+  if (VAAPIVersionLessThan(0, 34)) {
+    va_res = reinterpret_cast<VaapiCreateSurfaces6>(VAAPI_CreateSurfaces)(
+        va_display_,
+        size.width(), size.height(),
+        VA_RT_FORMAT_YUV420,
+        va_surface_ids_.size(),
+        &va_surface_ids_[0]);
+  } else {
+    va_res = reinterpret_cast<VaapiCreateSurfaces8>(VAAPI_CreateSurfaces)(
+        va_display_,
+        VA_RT_FORMAT_YUV420,
+        size.width(), size.height(),
+        &va_surface_ids_[0],
+        va_surface_ids_.size(),
+        NULL, 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(),
@@ skipping 168 matching lines @@
   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_handle);
   VAAPI_DLSYM_OR_RETURN_ON_ERROR(Terminate, vaapi_handle);
 #undef VAAPI_DLSYM
 
   return true;
 }
 
 }  // namespace content