Add vaapi_h264_decoder_test.

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 58 matching lines @@
                                          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 (*VaapiDeriveImage)(VADisplay dpy,
+                                     VASurfaceID surface,
+                                     VAImage* image);
 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 (*VaapiDestroyImage)(VADisplay dpy, VAImageID image);
 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 (*VaapiMapBuffer)(VADisplay dpy,
+                                   VABufferID buf_id,
+                                   void** pbuf);
 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);
+typedef VAStatus (*VaapiUnmapBuffer)(VADisplay dpy, VABufferID buf_id);
 
 #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(DeriveImage, vaapi_handle);
 VAAPI_SYM(DestroyBuffer, vaapi_handle);
 VAAPI_SYM(DestroyConfig, vaapi_handle);
 VAAPI_SYM(DestroyContext, vaapi_handle);
+VAAPI_SYM(DestroyImage, 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(MapBuffer, vaapi_handle);
 VAAPI_SYM(PutSurface, vaapi_x11_handle);
 VAAPI_SYM(RenderPicture, vaapi_handle);
 VAAPI_SYM(SyncSurface, vaapi_x11_handle);
 VAAPI_SYM(Terminate, vaapi_handle);
+VAAPI_SYM(UnmapBuffer, 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;
@@ skipping 277 matching lines @@
                             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 scoped_refptr<media::VideoFrame> CopyNV12ToI420(VAImage* image,
+                                                       void* mem) {
+  DVLOG(1) << "CopyNV12ToI420 width=" << image->width
+           << ", height=" << image->height;
+
+  const gfx::Size coded_size(image->width, image->height);
+  const gfx::Rect visible_rect(image->width, image->height);
+  const gfx::Size natural_size(image->width, image->height);
+
+  scoped_refptr<media::VideoFrame> frame =
+      media::VideoFrame::CreateFrame(media::VideoFrame::I420,
+                                     coded_size,
+                                     visible_rect,
+                                     natural_size,
+                                     base::TimeDelta());
+
+  uint8_t* mem_byte_ptr = static_cast<uint8_t*>(mem);
+  uint8_t* srcY = mem_byte_ptr + image->offsets[0];
+  uint8_t* srcU = mem_byte_ptr + image->offsets[1];
+  uint8_t* srcV = srcU + 1;
+
+  uint8_t* dstY = frame->data(media::VideoFrame::kYPlane);
+  uint8_t* dstU = frame->data(media::VideoFrame::kUPlane);
+  uint8_t* dstV = frame->data(media::VideoFrame::kVPlane);
+
+  for (int i = 0; i < image->height; i++) {
+    memcpy(dstY, srcY, image->width);
+    srcY += image->pitches[0];
+    dstY += frame->stride(media::VideoFrame::kYPlane);
+
+    // U/V components are subsampled, so there is only one U/V row for every two
+    // Y rows.
+    if ((i & 1) == 1)
+      continue;
+    for (int j = 0, k = 0; j < image->width; j += 2, k++) {
+      dstU[k] = srcU[j];
+      dstV[k] = srcV[j];
+    }
+    srcU += image->pitches[1];
+    srcV += image->pitches[1];
+    dstU += frame->stride(media::VideoFrame::kUPlane);
+    dstV += frame->stride(media::VideoFrame::kVPlane);
+  }
+
+  return frame;
+}
+
+scoped_refptr<media::VideoFrame> VaapiWrapper::VideoFrameFromVASurface(
+    VASurfaceID va_surface_id) {
+  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", NULL);
+
+  VAImage image;
+  void* mem = NULL;
+  scoped_refptr<media::VideoFrame> frame;
+
+  // Derive a VAImage from the VASurface
+  va_res = VAAPI_DeriveImage(va_display_, va_surface_id, &image);
+  VA_LOG_ON_ERROR(va_res, "vaDeriveImage failed");
+  if (va_res != VA_STATUS_SUCCESS)
+    return frame;
+
+  // Check if the format is NV12
+  if (image.format.fourcc == VA_FOURCC_NV12) {
+    // Map the buffer
+    va_res = VAAPI_MapBuffer(va_display_, image.buf, &mem);
+    VA_LOG_ON_ERROR(va_res, "vaMapBuffer failed");
+    if (va_res == VA_STATUS_SUCCESS) {
+      frame = CopyNV12ToI420(&image, mem);
+      // Unmap the buffer
+      VAAPI_UnmapBuffer(va_display_, image.buf);
+    }
+  } else {
+    DVLOG(ERROR) << "unexpected image format: " << image.format.fourcc;

[Pawel Osciak, 2013/12/03 08:52:06]

The convention is to use numeric constants for *VLOG()s.

[chihchung, 2013/12/03 10:57:40]

Moved to test and changed to LOG.

+  }
+  VAAPI_DestroyImage(va_display_, image.image_id);
+
+  return frame;
+}
+
 // static
 bool VaapiWrapper::PostSandboxInitialization() {
   vaapi_handle = dlopen("libva.so.1", RTLD_NOW);
   vaapi_x11_handle = dlopen("libva-x11.so.1", RTLD_NOW);
 
   if (!vaapi_handle || !vaapi_x11_handle)
     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(DeriveImage, 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(DestroyImage, 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(MapBuffer, 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_handle);
   VAAPI_DLSYM_OR_RETURN_ON_ERROR(Terminate, vaapi_handle);
+  VAAPI_DLSYM_OR_RETURN_ON_ERROR(UnmapBuffer, vaapi_handle);
 #undef VAAPI_DLSYM
 
   return true;
 }
 
 }  // namespace content