Add libva to chromium third_party.

third_party/libva/test/egl/va_egl_x11.c

+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/keysym.h>
+#include <GLES/gl.h>
+#include <GLES/glext.h>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <va/va_x11.h>
+#include <va/va_egl.h>
+
+struct va_egl_context
+{
+    Display *x11_dpy;
+    Window win;
+
+    EGLDisplay egl_dpy;
+    EGLContext egl_ctx;
+    EGLSurface egl_surf;
+    unsigned int egl_target;
+    EGLClientBuffer egl_buffer;
+    EGLImageKHR egl_image;
+    PFNEGLCREATEIMAGEKHRPROC egl_create_image_khr;
+    PFNEGLDESTROYIMAGEKHRPROC egl_destroy_image_hkr;
+    PFNGLEGLIMAGETARGETTEXTURE2DOESPROC glegl_image_target_texture2d_oes;
+
+    VADisplay va_dpy;
+    VASurfaceID va_surface;
+    VASurfaceEGL va_egl_surface;
+
+    int x, y;
+    unsigned int width, height;
+    GLuint texture;
+    GLfloat ar;
+    unsigned int box_width;
+    unsigned char ydata;
+};
+
+static void
+va_egl_fini_egl(struct va_egl_context *ctx)
+{
+    eglMakeCurrent(ctx->egl_dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+    eglTerminate(ctx->egl_dpy);
+}
+
+static int
+va_egl_init_egl(struct va_egl_context *ctx)
+{
+    EGLint egl_major, egl_minor;
+    const char *s;
+
+    ctx->egl_dpy = eglGetDisplay(ctx->x11_dpy);
+
+    if (!ctx->egl_dpy) {
+        printf("Error: eglGetDisplay() failed\n");
+        return -1;
+    }
+
+    if (!eglInitialize(ctx->egl_dpy, &egl_major, &egl_minor)) {
+        printf("Error: eglInitialize() failed\n");
+        return -1;
+    }
+
+    s = eglQueryString(ctx->egl_dpy, EGL_VERSION);
+    printf("EGL_VERSION = %s\n", s);
+
+    return 0;
+}
+
+static int 
+yuvgen_planar(int width, int height,
+              unsigned char *Y_start, int Y_pitch,
+              unsigned char *U_start, int U_pitch,
+              unsigned char *V_start, int V_pitch,
+              int UV_interleave, int box_width, unsigned char ydata)
+{
+    int row;
+
+    /* copy Y plane */
+    for (row = 0; row < height; row++) {
+        unsigned char *Y_row = Y_start + row * Y_pitch;
+        int jj, xpos, ypos;
+
+        ypos = (row / box_width) & 0x1;
+
+        for (jj = 0; jj < width; jj++) {
+            xpos = ((jj) / box_width) & 0x1;
+                        
+            if ((xpos == 0) && (ypos == 0))
+                Y_row[jj] = ydata;
+            if ((xpos == 1) && (ypos == 1))
+                Y_row[jj] = ydata;
+                        
+            if ((xpos == 1) && (ypos == 0))
+                Y_row[jj] = 0xff - ydata;
+            if ((xpos == 0) && (ypos == 1))
+                Y_row[jj] = 0xff - ydata;
+        }
+    }
+  
+    /* copy UV data */
+    for( row = 0; row < height/2; row++) {
+        unsigned short value = 0x80;
+
+        if (UV_interleave) {
+            unsigned short *UV_row = (unsigned short *)(U_start + row * U_pitch);
+
+            memset(UV_row, value, width);
+        } else {
+            unsigned char *U_row = U_start + row * U_pitch;
+            unsigned char *V_row = V_start + row * V_pitch;
+            
+            memset(U_row, value, width / 2);
+            memset(V_row, value, width / 2);
+        }
+    }
+
+    return 0;
+}
+
+static int 
+va_egl_upload_surface(struct va_egl_context *ctx)
+{
+    VAImage surface_image;
+    void *surface_p = NULL, *U_start, *V_start;
+    
+    vaDeriveImage(ctx->va_dpy, ctx->va_surface, &surface_image);
+
+    vaMapBuffer(ctx->va_dpy, surface_image.buf, &surface_p);
+        
+    U_start = (char *)surface_p + surface_image.offsets[1];
+    V_start = (char *)surface_p + surface_image.offsets[2];
+
+    /* assume surface is planar format */
+    yuvgen_planar(surface_image.width, surface_image.height,
+                  (unsigned char *)surface_p, surface_image.pitches[0],
+                  (unsigned char *)U_start, surface_image.pitches[1],
+                  (unsigned char *)V_start, surface_image.pitches[2],
+                  (surface_image.format.fourcc==VA_FOURCC_NV12),
+                  ctx->box_width, ctx->ydata);
+        
+    vaUnmapBuffer(ctx->va_dpy,surface_image.buf);
+
+    vaDestroyImage(ctx->va_dpy,surface_image.image_id);
+
+    return 0;
+}
+
+static void
+va_egl_fini_va(struct va_egl_context *ctx)
+{
+    vaDestroySurfaces(ctx->va_dpy, &ctx->va_surface, 1);    
+    vaTerminate(ctx->va_dpy);
+}
+
+static int
+va_egl_init_va(struct va_egl_context *ctx)
+{
+    VAStatus va_status;
+    int major_ver, minor_ver;
+
+    ctx->va_dpy = vaGetDisplayEGL(ctx->x11_dpy, ctx->egl_dpy);
+
+    if (!ctx->va_dpy) {
+        printf("Error: vaGetDisplayEGL() failed\n");
+        return -1;
+    }
+
+    va_status = vaInitialize(ctx->va_dpy, &major_ver, &minor_ver);
+
+    if (va_status != VA_STATUS_SUCCESS) {
+        printf("Error: vaInitialize() failed\n");
+        return -1;
+    }
+
+    va_status = vaCreateSurfaces(ctx->va_dpy,
+                                 ctx->width, ctx->height,
+                                 VA_RT_FORMAT_YUV420, 
+                                 1, &ctx->va_surface);
+
+    if (va_status != VA_STATUS_SUCCESS) {
+        printf("Error: vaCreateSurfaces() failed\n");
+        return -1;
+    }
+
+    va_egl_upload_surface(ctx);
+
+    return 0;
+}
+
+static void
+va_egl_make_window(struct va_egl_context *ctx, const char *title)
+{
+    int scrnum;
+    XSetWindowAttributes attr;
+    unsigned long mask;
+    Window root;
+    XVisualInfo *visInfo, visTemplate;
+    int num_visuals;
+    EGLConfig config;
+    EGLint num_configs, vid;
+    const EGLint attribs[] = {
+        EGL_RED_SIZE, 8,
+        EGL_GREEN_SIZE, 8,
+        EGL_BLUE_SIZE, 8,
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT,
+        EGL_NONE
+    };
+
+    scrnum = DefaultScreen(ctx->x11_dpy);
+    root = RootWindow(ctx->x11_dpy, scrnum);
+
+    if (!eglChooseConfig(ctx->egl_dpy, attribs, &config, 1, &num_configs) ||
+        !num_configs) {
+        printf("Error: couldn't get an EGL visual config\n");
+
+        return;
+    }
+
+    if (!eglGetConfigAttrib(ctx->egl_dpy, config, EGL_NATIVE_VISUAL_ID, &vid)) {
+        printf("Error: eglGetConfigAttrib() failed\n");
+
+        return;
+    }
+
+    /* The X window visual must match the EGL config */
+    visTemplate.visualid = vid;
+    visInfo = XGetVisualInfo(ctx->x11_dpy, VisualIDMask, &visTemplate, &num_visuals);
+
+    if (!visInfo) {
+        printf("Error: couldn't get X visual\n");
+
+        return;
+    }
+
+    /* window attributes */
+    attr.background_pixel = 0;
+    attr.border_pixel = 0;
+    attr.colormap = XCreateColormap(ctx->x11_dpy, root, visInfo->visual, AllocNone);
+    attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
+    attr.override_redirect = 0;
+    mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect;
+
+    ctx->win = XCreateWindow(ctx->x11_dpy,
+                             root,
+                             ctx->x, ctx->y,
+                             ctx->width, ctx->height,
+                             0, visInfo->depth, InputOutput,
+                             visInfo->visual, mask, &attr);
+
+    /* set hints and properties */
+    {
+        XSizeHints sizehints;
+        sizehints.x = ctx->x;
+        sizehints.y = ctx->y;
+        sizehints.width  = ctx->width;
+        sizehints.height = ctx->height;
+        sizehints.flags = USSize | USPosition;
+        XSetNormalHints(ctx->x11_dpy, ctx->win, &sizehints);
+        XSetStandardProperties(ctx->x11_dpy, ctx->win, title, title,
+                               None, (char **)NULL, 0, &sizehints);
+    }
+
+    eglBindAPI(EGL_OPENGL_ES_API);
+
+    ctx->egl_ctx = eglCreateContext(ctx->egl_dpy, config, EGL_NO_CONTEXT, NULL);
+
+    if (!ctx->egl_ctx) {
+        printf("Error: eglCreateContext() failed\n");
+        
+        return;
+    }
+
+    ctx->egl_surf = eglCreateWindowSurface(ctx->egl_dpy, config, ctx->win, NULL);
+    eglMakeCurrent(ctx->egl_dpy, ctx->egl_surf, ctx->egl_surf, ctx->egl_ctx);
+    XFree(visInfo);
+}
+
+static int
+va_egl_init_extension(struct va_egl_context *ctx)
+{
+   const char *exts;
+
+   exts = eglQueryString(ctx->egl_dpy, EGL_EXTENSIONS);
+   ctx->egl_create_image_khr =
+       (PFNEGLCREATEIMAGEKHRPROC)eglGetProcAddress("eglCreateImageKHR");
+   ctx->egl_destroy_image_hkr =
+       (PFNEGLDESTROYIMAGEKHRPROC)eglGetProcAddress("eglDestroyImageKHR");
+
+   if (!exts ||
+       !strstr(exts, "EGL_KHR_image_base") ||
+       !ctx->egl_create_image_khr ||
+       !ctx->egl_destroy_image_hkr) {
+       printf("EGL does not support EGL_KHR_image_base\n");
+       return -1;
+   }
+
+   exts = (const char *)glGetString(GL_EXTENSIONS);
+   ctx->glegl_image_target_texture2d_oes =
+       (PFNGLEGLIMAGETARGETTEXTURE2DOESPROC)eglGetProcAddress("glEGLImageTargetTexture2DOES");
+
+   if (!exts ||
+       !strstr(exts, "GL_OES_EGL_image") ||
+       !ctx->glegl_image_target_texture2d_oes) {
+       printf("OpenGL ES does not support GL_OES_EGL_image\n");
+       return -1;
+   }
+
+   return 0;
+}
+
+static void
+va_egl_fini_gles(struct va_egl_context *ctx)
+{
+    glDeleteTextures(1, &ctx->texture);
+}
+
+static int
+va_egl_init_gles(struct va_egl_context *ctx)
+{
+    glClearColor(0.0, 0.0, 0.0, 0.0);
+    glColor4f(1.0, 1.0, 1.0, 1.0);
+
+    glDisable(GL_BLEND);
+    glDisable(GL_DEPTH_TEST);
+
+    glGenTextures(1, &ctx->texture);
+    glBindTexture(GL_TEXTURE_2D, ctx->texture);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glEnable(GL_TEXTURE_2D);
+
+    return 0;
+}
+
+static void
+va_egl_fini_va_egl(struct va_egl_context *ctx)
+{
+    if (ctx->egl_image)
+        ctx->egl_destroy_image_hkr(ctx->egl_dpy, ctx->egl_image);
+
+    vaDeassociateSurfaceEGL(ctx->va_dpy, ctx->va_egl_surface);
+    vaDestroySurfaceEGL(ctx->va_dpy, ctx->va_egl_surface);
+}
+
+static int
+va_egl_init_va_egl(struct va_egl_context *ctx)
+{
+    VAStatus va_status;
+    int num_max_targets = 0, num_targets = 0;
+    int num_max_attributes = 0, num_attribs = 0;
+    unsigned int *target_list = NULL;
+    EGLint *img_attribs = NULL;
+
+    num_targets = num_max_targets = vaMaxNumSurfaceTargetsEGL(ctx->va_dpy);
+    
+    if (num_max_targets < 1) {
+        printf("Error: vaMaxNumSurfaceTargetsEGL() returns %d\n", num_max_targets);
+        return -1;
+    }
+
+    num_attribs = num_max_attributes = vaMaxNumSurfaceAttributesEGL(ctx->va_dpy);
+
+    if (num_max_attributes < 1) {
+        printf("Error: vaMaxNumSurfaceAttributesEGL() returns %d\n", num_max_attributes);
+        return -1;
+    }
+
+    target_list = malloc(num_max_targets * sizeof(unsigned int));
+    va_status = vaQuerySurfaceTargetsEGL(ctx->va_dpy,
+                                         target_list,
+                                         &num_targets);
+    
+    if (va_status != VA_STATUS_SUCCESS || num_targets < 1) {
+        printf("Error: vaQuerySurfaceTargetsEGL() failed\n");
+        return -1;
+    }
+    
+    va_status = vaCreateSurfaceEGL(ctx->va_dpy,
+                                   target_list[0],
+                                   ctx->width, ctx->height,
+                                   &ctx->va_egl_surface);
+
+    if (va_status != VA_STATUS_SUCCESS) {
+        printf("Error: vaCreateSurfaceEGL() failed\n");
+        return -1;
+    }
+
+    va_status = vaAssociateSurfaceEGL(ctx->va_dpy,
+                                      ctx->va_egl_surface,
+                                      ctx->va_surface,
+                                      0);
+ 
+    if (va_status != VA_STATUS_SUCCESS) {
+        printf("Error: vaAssociateSurfaceEGL() failed\n");
+        return -1;
+    }
+
+    img_attribs = malloc(2 * num_max_attributes * sizeof(EGLint));
+    va_status = vaGetSurfaceInfoEGL(ctx->va_dpy,
+                                    ctx->va_egl_surface,
+                                    &ctx->egl_target,
+                                    &ctx->egl_buffer,
+                                    img_attribs,
+                                    &num_attribs);
+
+    if (va_status != VA_STATUS_SUCCESS) {
+        printf("Error: vaGetSurfaceInfoEGL() failed\n");
+        return -1;
+    }
+
+    ctx->egl_image = ctx->egl_create_image_khr(ctx->egl_dpy,
+                                               EGL_NO_CONTEXT,
+                                               ctx->egl_target,
+                                               ctx->egl_buffer,
+                                               img_attribs);
+
+    vaSyncSurfaceEGL(ctx->va_dpy, ctx->va_egl_surface);
+    ctx->glegl_image_target_texture2d_oes(GL_TEXTURE_2D,
+                                          (GLeglImageOES)ctx->egl_image);
+
+    return 0;
+}
+
+static void
+va_egl_fini(struct va_egl_context *ctx)
+{
+    va_egl_fini_gles(ctx);
+    va_egl_fini_va(ctx);
+    va_egl_fini_egl(ctx);
+    va_egl_fini_gles(ctx);
+    va_egl_fini_va_egl(ctx);
+
+    // XDestroyWindow(ctx->x11_dpy, ctx->win);
+    XCloseDisplay(ctx->x11_dpy);
+}
+
+static int
+va_egl_init(struct va_egl_context *ctx, int argc, char **argv)
+{
+    memset(ctx, 0, sizeof(*ctx));
+    ctx->x11_dpy = XOpenDisplay(NULL);
+    ctx->width = 320;
+    ctx->height = 320;
+    ctx->ar = 1.0;
+    ctx->box_width = 16;
+    ctx->ydata = 0xff;
+
+    if (!ctx->x11_dpy) {
+        printf("Error: couldn't open display %s\n", getenv("DISPLAY"));
+        return -1;
+    }
+
+    if (va_egl_init_egl(ctx) != 0)
+        return -1;
+
+    if (va_egl_init_va(ctx) != 0)
+        return -1;
+
+    va_egl_make_window(ctx, "VA/EGL");
+    va_egl_init_extension(ctx);
+    va_egl_init_gles(ctx);
+    va_egl_init_va_egl(ctx);
+
+    return 0;
+}
+
+static void
+va_egl_reshape(struct va_egl_context *ctx, int width, int height)
+{
+    GLfloat ar = (GLfloat) width / (GLfloat) height;
+
+    ctx->width = width;
+    ctx->height = height;
+    ctx->ar = ar;
+
+    glViewport(0, 0, (GLint) width, (GLint) height);
+
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glOrthof(-ar, ar, -ar, ar, -1.0, 1.0);
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+}
+
+static void
+va_egl_draw(struct va_egl_context *ctx)
+{
+    const GLfloat verts[][3] = {
+        { -ctx->ar, -ctx->ar, 0 },
+        {  ctx->ar, -ctx->ar, 0 },
+        {  ctx->ar,  ctx->ar, 0 },
+        { -ctx->ar,  ctx->ar, 0 }
+    };
+    const GLfloat texs[][2] = {
+        { 0, 0 },
+        { 1, 0 },
+        { 1, 1 },
+        { 0, 1 }
+    };
+
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    glVertexPointer(3, GL_FLOAT, 0, verts);
+    glTexCoordPointer(2, GL_FLOAT, 0, texs);
+
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+}
+
+static void
+va_egl_event_loop(struct va_egl_context *ctx)
+{
+    while (1) {
+        int redraw = 0;
+
+        if (XPending(ctx->x11_dpy) > 0) {
+            XEvent event;
+            XNextEvent(ctx->x11_dpy, &event);
+
+            switch (event.type) {
+            case Expose:
+                redraw = 1;
+                break;
+
+            case ConfigureNotify:
+                va_egl_reshape(ctx, event.xconfigure.width, event.xconfigure.height);
+                redraw = 1;
+                break;
+
+            case KeyPress:
+            {
+                char buffer[10];
+                int code;
+                code = XLookupKeysym(&event.xkey, 0);
+
+                if (code == XK_y) {
+                    ctx->ydata += 0x10;
+                    va_egl_upload_surface(ctx);
+                    vaSyncSurfaceEGL(ctx->va_dpy, ctx->va_egl_surface);
+                    ctx->glegl_image_target_texture2d_oes(GL_TEXTURE_2D,
+                                                          (GLeglImageOES)ctx->egl_image);
+                    redraw = 1;
+                } else {
+                    XLookupString(&event.xkey, buffer, sizeof(buffer),
+                                  NULL, NULL);
+                    
+                    if (buffer[0] == 27) {
+                        /* escape */
+                        return;
+                    }
+                }
+            }
+                
+            break;
+
+            default:
+                ; /*no-op*/
+            }
+        }
+
+        if (redraw) {
+            va_egl_draw(ctx);
+            eglSwapBuffers(ctx->egl_dpy, ctx->egl_surf);
+        }
+    }
+}
+
+static void
+va_egl_run(struct va_egl_context *ctx)
+{
+    XMapWindow(ctx->x11_dpy, ctx->win);
+    va_egl_reshape(ctx, ctx->width, ctx->height);
+    va_egl_event_loop(ctx);
+}
+
+int
+main(int argc, char *argv[])
+{
+    struct va_egl_context ctx;
+
+    printf("Usage: press 'y' to change Y plane \n\n");
+
+    if (va_egl_init(&ctx, argc, argv) == 0) {
+        va_egl_run(&ctx);
+        va_egl_fini(&ctx);
+    }
+
+    return 0;
+}