/*
 * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sub license, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 * 
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial portions
 * of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#define _GNU_SOURCE 1
#include "sysdeps.h"
#include "va_glx_private.h"
#include "va_glx_impl.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <assert.h>
#include <dlfcn.h>

static void va_glx_error_message(const char *format, ...)
{
    va_list args;
    va_start(args, format);
    fprintf(stderr, "libva-glx error: ");
    vfprintf(stderr, format, args);
    va_end(args);
}

// X error trap
static int x11_error_code = 0;
static int (*old_error_handler)(Display *, XErrorEvent *);

static int error_handler(Display *dpy, XErrorEvent *error)
{
    x11_error_code = error->error_code;
    return 0;
}

static void x11_trap_errors(void)
{
    x11_error_code    = 0;
    old_error_handler = XSetErrorHandler(error_handler);
}

static int x11_untrap_errors(void)
{
    XSetErrorHandler(old_error_handler);
    return x11_error_code;
}

// Returns a string representation of an OpenGL error
static const char *gl_get_error_string(GLenum error)
{
    static const struct {
        GLenum val;
        const char *str;
    }
    gl_errors[] = {
        { GL_NO_ERROR,          "no error" },
        { GL_INVALID_ENUM,      "invalid enumerant" },
        { GL_INVALID_VALUE,     "invalid value" },
        { GL_INVALID_OPERATION, "invalid operation" },
        { GL_STACK_OVERFLOW,    "stack overflow" },
        { GL_STACK_UNDERFLOW,   "stack underflow" },
        { GL_OUT_OF_MEMORY,     "out of memory" },
#ifdef GL_INVALID_FRAMEBUFFER_OPERATION_EXT
        { GL_INVALID_FRAMEBUFFER_OPERATION_EXT, "invalid framebuffer operation" },
#endif
        { ~0, NULL }
    };

    int i;
    for (i = 0; gl_errors[i].str; i++) {
        if (gl_errors[i].val == error)
            return gl_errors[i].str;
    }
    return "unknown";
}

static inline int gl_do_check_error(int report)
{
    GLenum error;
    int is_error = 0;
    while ((error = glGetError()) != GL_NO_ERROR) {
        if (report)
            va_glx_error_message("glError: %s caught\n",
                                 gl_get_error_string(error));
        is_error = 1;
    }
    return is_error;
}

static inline void gl_purge_errors(void)
{
    gl_do_check_error(0);
}

static inline int gl_check_error(void)
{
    return gl_do_check_error(1);
}

// glGetTexLevelParameteriv() wrapper
static int gl_get_texture_param(GLenum param, unsigned int *pval)
{
    GLint val;

    gl_purge_errors();
    glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, param, &val);
    if (gl_check_error())
        return 0;
    if (pval)
        *pval = val;
    return 1;
}

// Returns the OpenGL VTable
static inline VAOpenGLVTableP gl_get_vtable(VADriverContextP ctx)
{
    return &VA_DRIVER_CONTEXT_GLX(ctx)->gl_vtable;
}

// Lookup for a GLX function
typedef void (*GLFuncPtr)(void);
typedef GLFuncPtr (*GLXGetProcAddressProc)(const char *);

static GLFuncPtr get_proc_address_default(const char *name)
{
    return NULL;
}

static GLXGetProcAddressProc get_proc_address_func(void)
{
    GLXGetProcAddressProc get_proc_func;

    dlerror();
    get_proc_func = (GLXGetProcAddressProc)
        dlsym(RTLD_DEFAULT, "glXGetProcAddress");
    if (!dlerror())
        return get_proc_func;

    get_proc_func = (GLXGetProcAddressProc)
        dlsym(RTLD_DEFAULT, "glXGetProcAddressARB");
    if (!dlerror())
        return get_proc_func;

    return get_proc_address_default;
}

static inline GLFuncPtr get_proc_address(const char *name)
{
    static GLXGetProcAddressProc get_proc_func = NULL;
    if (!get_proc_func)
        get_proc_func = get_proc_address_func();
    return get_proc_func(name);
}

// Check for GLX extensions (TFP, FBO)
static int check_extension(const char *name, const char *ext)
{
    const char *end;
    int name_len, n;

    if (!name || !ext)
        return 0;

    end = ext + strlen(ext);
    name_len = strlen(name);
    while (ext < end) {
        n = strcspn(ext, " ");
        if (n == name_len && strncmp(name, ext, n) == 0)
            return 1;
        ext += (n + 1);
    }
    return 0;
}

static int check_extension3(const char *name)
{
    int nbExtensions, i;
    PFNGLGETSTRINGIPROC glGetStringi = 0;

    glGetStringi = (PFNGLGETSTRINGIPROC) get_proc_address("glGetStringi");
    if(!glGetStringi)
        return 0;


    glGetIntegerv(GL_NUM_EXTENSIONS, &nbExtensions);
    for(i = 0; i < nbExtensions; i++)
    {
        const GLubyte *strExtension = glGetStringi(GL_EXTENSIONS, i);
        if(strcmp((const char *) strExtension, name) == 0)
            return 1;
    }

    return 0;
}

static int check_tfp_extensions(VADriverContextP ctx)
{
    const char *gl_extensions;
    const char *glx_extensions;

    gl_extensions = (const char *)glGetString(GL_EXTENSIONS);
    if (!check_extension("GL_ARB_texture_non_power_of_two", gl_extensions) && !check_extension3("GL_ARB_texture_non_power_of_two"))
        return 0;

    glx_extensions = glXQueryExtensionsString(ctx->native_dpy, ctx->x11_screen);
    if (!check_extension("GLX_EXT_texture_from_pixmap", glx_extensions))
        return 0;

    return 1;
}

static int check_fbo_extensions(VADriverContextP ctx)
{
    const char *gl_extensions;

    gl_extensions = (const char *)glGetString(GL_EXTENSIONS);
    if (check_extension("GL_ARB_framebuffer_object", gl_extensions) || check_extension3("GL_ARB_framebuffer_object"))
        return 1;
    if (check_extension("GL_EXT_framebuffer_object", gl_extensions) || check_extension3("GL_EXT_framebuffer_object"))
        return 1;

    return 0;
}

// Load GLX extensions
static int load_tfp_extensions(VADriverContextP ctx)
{
    VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx);

    pOpenGLVTable->glx_create_pixmap = (PFNGLXCREATEPIXMAPPROC)
        get_proc_address("glXCreatePixmap");
    if (!pOpenGLVTable->glx_create_pixmap)
        return 0;
    pOpenGLVTable->glx_destroy_pixmap = (PFNGLXDESTROYPIXMAPPROC)
        get_proc_address("glXDestroyPixmap");
    if (!pOpenGLVTable->glx_destroy_pixmap)
        return 0;
    pOpenGLVTable->glx_bind_tex_image = (PFNGLXBINDTEXIMAGEEXTPROC)
        get_proc_address("glXBindTexImageEXT");
    if (!pOpenGLVTable->glx_bind_tex_image)
        return 0;
    pOpenGLVTable->glx_release_tex_image = (PFNGLXRELEASETEXIMAGEEXTPROC)
        get_proc_address("glXReleaseTexImageEXT");
    if (!pOpenGLVTable->glx_release_tex_image)
        return 0;
    return 1;
}

static int load_fbo_extensions(VADriverContextP ctx)
{
    VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx);

    pOpenGLVTable->gl_gen_framebuffers = (PFNGLGENFRAMEBUFFERSEXTPROC)
        get_proc_address("glGenFramebuffersEXT");
    if (!pOpenGLVTable->gl_gen_framebuffers)
        return 0;
    pOpenGLVTable->gl_delete_framebuffers = (PFNGLDELETEFRAMEBUFFERSEXTPROC)
        get_proc_address("glDeleteFramebuffersEXT");
    if (!pOpenGLVTable->gl_delete_framebuffers)
        return 0;
    pOpenGLVTable->gl_bind_framebuffer = (PFNGLBINDFRAMEBUFFEREXTPROC)
        get_proc_address("glBindFramebufferEXT");
    if (!pOpenGLVTable->gl_bind_framebuffer)
        return 0;
    pOpenGLVTable->gl_gen_renderbuffers = (PFNGLGENRENDERBUFFERSEXTPROC)
        get_proc_address("glGenRenderbuffersEXT");
    if (!pOpenGLVTable->gl_gen_renderbuffers)
        return 0;
    pOpenGLVTable->gl_delete_renderbuffers = (PFNGLDELETERENDERBUFFERSEXTPROC)
        get_proc_address("glDeleteRenderbuffersEXT");
    if (!pOpenGLVTable->gl_delete_renderbuffers)
        return 0;
    pOpenGLVTable->gl_bind_renderbuffer = (PFNGLBINDRENDERBUFFEREXTPROC)
        get_proc_address("glBindRenderbufferEXT");
    if (!pOpenGLVTable->gl_bind_renderbuffer)
        return 0;
    pOpenGLVTable->gl_renderbuffer_storage = (PFNGLRENDERBUFFERSTORAGEEXTPROC)
        get_proc_address("glRenderbufferStorageEXT");
    if (!pOpenGLVTable->gl_renderbuffer_storage)
        return 0;
    pOpenGLVTable->gl_framebuffer_renderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)
        get_proc_address("glFramebufferRenderbufferEXT");
    if (!pOpenGLVTable->gl_framebuffer_renderbuffer)
        return 0;
    pOpenGLVTable->gl_framebuffer_texture_2d = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)
        get_proc_address("glFramebufferTexture2DEXT");
    if (!pOpenGLVTable->gl_framebuffer_texture_2d)
        return 0;
    pOpenGLVTable->gl_check_framebuffer_status = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)
        get_proc_address("glCheckFramebufferStatusEXT");
    if (!pOpenGLVTable->gl_check_framebuffer_status)
        return 0;
    return 1;
}


/* ========================================================================= */
/* === VA/GLX helpers                                                    === */
/* ========================================================================= */

// OpenGL context state
typedef struct OpenGLContextState *OpenGLContextStateP;

struct OpenGLContextState {
    Display     *display;
    Window       window;
    GLXContext   context;
};

static void
gl_destroy_context(OpenGLContextStateP cs)
{
    if (!cs)
        return;

    if (cs->display && cs->context) {
        if (glXGetCurrentContext() == cs->context)
            glXMakeCurrent(cs->display, None, NULL);
        glXDestroyContext(cs->display, cs->context);
        cs->display = NULL;
        cs->context = NULL;
    }
    free(cs);
}

static OpenGLContextStateP
gl_create_context(VADriverContextP ctx, OpenGLContextStateP parent)
{
    OpenGLContextStateP cs;
    GLXFBConfig *fbconfigs = NULL;
    int fbconfig_id, val, n, n_fbconfigs;
    Status status;

    static GLint fbconfig_attrs[] = {
        GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
        GLX_RENDER_TYPE,   GLX_RGBA_BIT,
        GLX_DOUBLEBUFFER,  True,
        GLX_RED_SIZE,      8,
        GLX_GREEN_SIZE,    8, 
        GLX_BLUE_SIZE,     8,
        None
    };

    cs = malloc(sizeof(*cs));
    if (!cs)
        goto error;

    if (parent) {
        cs->display = parent->display;
        cs->window  = parent->window;
    }
    else {
        cs->display = ctx->native_dpy;
        cs->window  = None;
    }
    cs->context = NULL;

    if (parent && parent->context) {
        status = glXQueryContext(
            parent->display,
            parent->context,
            GLX_FBCONFIG_ID, &fbconfig_id
        );
        if (status != Success)
            goto error;

        if (fbconfig_id == GLX_DONT_CARE)
            goto choose_fbconfig;

        fbconfigs = glXGetFBConfigs(
            parent->display,
            DefaultScreen(parent->display),
            &n_fbconfigs
        );
        if (!fbconfigs)
            goto error;

        /* Find out a GLXFBConfig compatible with the parent context */
        for (n = 0; n < n_fbconfigs; n++) {
            status = glXGetFBConfigAttrib(
                cs->display,
                fbconfigs[n],
                GLX_FBCONFIG_ID, &val
            );
            if (status == Success && val == fbconfig_id)
                break;
        }
        if (n == n_fbconfigs)
            goto error;
    }
    else {
    choose_fbconfig:
        fbconfigs = glXChooseFBConfig(
            ctx->native_dpy,
            ctx->x11_screen,
            fbconfig_attrs, &n_fbconfigs
        );
        if (!fbconfigs)
            goto error;

        /* Select the first one */
        n = 0;
    }

    cs->context = glXCreateNewContext(
        cs->display,
        fbconfigs[n],
        GLX_RGBA_TYPE,
        parent ? parent->context : NULL,
        True
    );
    if (cs->context)
        goto end;

error:
    gl_destroy_context(cs);
    cs = NULL;
end:
    if (fbconfigs)
        XFree(fbconfigs);
    return cs;
}

static void gl_get_current_context(OpenGLContextStateP cs)
{
    cs->display = glXGetCurrentDisplay();
    cs->window  = glXGetCurrentDrawable();
    cs->context = glXGetCurrentContext();
}

static int
gl_set_current_context(OpenGLContextStateP new_cs, OpenGLContextStateP old_cs)
{
    /* If display is NULL, this could be that new_cs was retrieved from
       gl_get_current_context() with none set previously. If that case,
       the other fields are also NULL and we don't return an error */
    if (!new_cs->display)
        return !new_cs->window && !new_cs->context;

    if (old_cs) {
        if (old_cs == new_cs)
            return 1;
        gl_get_current_context(old_cs);
        if (old_cs->display == new_cs->display &&
            old_cs->window  == new_cs->window  &&
            old_cs->context == new_cs->context)
            return 1;
    }
    return glXMakeCurrent(new_cs->display, new_cs->window, new_cs->context);
}

/** Unique VASurfaceGLX identifier */
#define VA_SURFACE_GLX_MAGIC VA_FOURCC('V','A','G','L')

struct VASurfaceGLX {
    uint32_t            magic;      ///< Magic number identifying a VASurfaceGLX
    GLenum              target;     ///< GL target to which the texture is bound
    GLuint              texture;    ///< GL texture
    VASurfaceID         surface;    ///< Associated VA surface
    unsigned int        width;
    unsigned int        height;
    OpenGLContextStateP gl_context;
    int                 is_bound;
    Pixmap              pixmap;
    GLuint              pix_texture;
    GLXPixmap           glx_pixmap;
    GLuint              fbo;
};

// Create Pixmaps for GLX texture-from-pixmap extension
static int create_tfp_surface(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
{
    VAOpenGLVTableP const pOpenGLVTable = gl_get_vtable(ctx);
    const unsigned int    width         = pSurfaceGLX->width;
    const unsigned int    height        = pSurfaceGLX->height;
    Pixmap                pixmap        = None;
    GLXFBConfig          *fbconfig      = NULL;
    GLXPixmap             glx_pixmap    = None;
    Window                root_window;
    XWindowAttributes     wattr;
    int                  *attrib;
    int                   n_fbconfig_attrs;

    root_window = RootWindow(ctx->native_dpy, ctx->x11_screen);
    XGetWindowAttributes(ctx->native_dpy, root_window, &wattr);
    if (wattr.depth != 24 && wattr.depth != 32)
        return 0;
    pixmap = XCreatePixmap(
        ctx->native_dpy,
        root_window,
        width,
        height,
        wattr.depth
    );
    if (!pixmap)
        return 0;
    pSurfaceGLX->pixmap = pixmap;

    int fbconfig_attrs[32] = {
        GLX_DRAWABLE_TYPE,      GLX_PIXMAP_BIT,
        GLX_DOUBLEBUFFER,       GL_TRUE,
        GLX_RENDER_TYPE,        GLX_RGBA_BIT,
        GLX_X_RENDERABLE,       GL_TRUE,
        GLX_Y_INVERTED_EXT,     GL_TRUE,
        GLX_RED_SIZE,           8,
        GLX_GREEN_SIZE,         8,
        GLX_BLUE_SIZE,          8,
        /*
         * depth test isn't enabled in the implementaion of VA GLX,
         * so depth buffer is unnecessary. However to workaround a
         * bug in older verson of xorg-server, always require a depth
         * buffer.
         *
         * See https://bugs.freedesktop.org/show_bug.cgi?id=76755
         */
        GLX_DEPTH_SIZE,         1,
        GL_NONE,
    };
    for (attrib = fbconfig_attrs; *attrib != GL_NONE; attrib += 2)
        ;
    if (wattr.depth == 32) {
    *attrib++ = GLX_ALPHA_SIZE;                 *attrib++ = 8;
    *attrib++ = GLX_BIND_TO_TEXTURE_RGBA_EXT;   *attrib++ = GL_TRUE;
    }
    else {
    *attrib++ = GLX_BIND_TO_TEXTURE_RGB_EXT;    *attrib++ = GL_TRUE;
    }
    *attrib++ = GL_NONE;

    fbconfig = glXChooseFBConfig(
        ctx->native_dpy,
        ctx->x11_screen,
        fbconfig_attrs,
        &n_fbconfig_attrs
    );
    if (!fbconfig)
        return 0;

    int pixmap_attrs[10] = {
        GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
        GLX_MIPMAP_TEXTURE_EXT, GL_FALSE,
        GL_NONE,
    };
    for (attrib = pixmap_attrs; *attrib != GL_NONE; attrib += 2)
        ;
    *attrib++ = GLX_TEXTURE_FORMAT_EXT;
    if (wattr.depth == 32)
    *attrib++ = GLX_TEXTURE_FORMAT_RGBA_EXT;
    else
    *attrib++ = GLX_TEXTURE_FORMAT_RGB_EXT;
    *attrib++ = GL_NONE;

    x11_trap_errors();
    glx_pixmap = pOpenGLVTable->glx_create_pixmap(
        ctx->native_dpy,
        fbconfig[0],
        pixmap,
        pixmap_attrs
    );
    free(fbconfig);
    if (x11_untrap_errors() != 0)
        return 0;
    pSurfaceGLX->glx_pixmap = glx_pixmap;

    glGenTextures(1, &pSurfaceGLX->pix_texture);
    glBindTexture(GL_TEXTURE_2D, pSurfaceGLX->pix_texture);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    return 1;
}

// Destroy Pixmaps used for TFP
static void destroy_tfp_surface(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
{
    VAOpenGLVTableP const pOpenGLVTable = gl_get_vtable(ctx);

    if (pSurfaceGLX->pix_texture) {
        glDeleteTextures(1, &pSurfaceGLX->pix_texture);
        pSurfaceGLX->pix_texture = 0;
    }

    if (pSurfaceGLX->glx_pixmap) {
        pOpenGLVTable->glx_destroy_pixmap(ctx->native_dpy, pSurfaceGLX->glx_pixmap);
        pSurfaceGLX->glx_pixmap = None;
    }

    if (pSurfaceGLX->pixmap) {
        XFreePixmap(ctx->native_dpy, pSurfaceGLX->pixmap);
        pSurfaceGLX->pixmap = None;
    }
}

// Bind GLX Pixmap to texture
static int bind_pixmap(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
{
    VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx);

    if (pSurfaceGLX->is_bound)
        return 1;

    glBindTexture(GL_TEXTURE_2D, pSurfaceGLX->pix_texture);

    x11_trap_errors();
    pOpenGLVTable->glx_bind_tex_image(
        ctx->native_dpy,
        pSurfaceGLX->glx_pixmap,
        GLX_FRONT_LEFT_EXT,
        NULL
    );
    XSync(ctx->native_dpy, False);
    if (x11_untrap_errors() != 0) {
        va_glx_error_message("failed to bind pixmap\n");
        return 0;
    }

    pSurfaceGLX->is_bound = 1;
    return 1;
}

// Release GLX Pixmap from texture
static int unbind_pixmap(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
{
    VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx);

    if (!pSurfaceGLX->is_bound)
        return 1;

    x11_trap_errors();
    pOpenGLVTable->glx_release_tex_image(
        ctx->native_dpy,
        pSurfaceGLX->glx_pixmap,
        GLX_FRONT_LEFT_EXT
    );
    XSync(ctx->native_dpy, False);
    if (x11_untrap_errors() != 0) {
        va_glx_error_message("failed to release pixmap\n");
        return 0;
    }

    glBindTexture(GL_TEXTURE_2D, 0);

    pSurfaceGLX->is_bound = 0;
    return 1;
}

// Render GLX Pixmap to texture
static void render_pixmap(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
{
    const unsigned int w = pSurfaceGLX->width;
    const unsigned int h = pSurfaceGLX->height;

    glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
    glBegin(GL_QUADS);
    {
        glTexCoord2f(0.0f, 0.0f); glVertex2i(0, 0);
        glTexCoord2f(0.0f, 1.0f); glVertex2i(0, h);
        glTexCoord2f(1.0f, 1.0f); glVertex2i(w, h);
        glTexCoord2f(1.0f, 0.0f); glVertex2i(w, 0);
    }
    glEnd();
}

// Create offscreen surface
static int create_fbo_surface(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
{
    VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx);
    GLuint fbo;
    GLenum status;

    pOpenGLVTable->gl_gen_framebuffers(1, &fbo);
    pOpenGLVTable->gl_bind_framebuffer(GL_FRAMEBUFFER_EXT, fbo);
    pOpenGLVTable->gl_framebuffer_texture_2d(
        GL_FRAMEBUFFER_EXT,
        GL_COLOR_ATTACHMENT0_EXT,
        GL_TEXTURE_2D,
        pSurfaceGLX->texture,
        0
    );

    status = pOpenGLVTable->gl_check_framebuffer_status(GL_DRAW_FRAMEBUFFER_EXT);
    pOpenGLVTable->gl_bind_framebuffer(GL_FRAMEBUFFER_EXT, 0);
    if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
        return 0;

    pSurfaceGLX->fbo = fbo;
    return 1;
}

// Destroy offscreen surface
static void destroy_fbo_surface(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
{
    VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx);

    if (pSurfaceGLX->fbo) {
        pOpenGLVTable->gl_delete_framebuffers(1, &pSurfaceGLX->fbo);
        pSurfaceGLX->fbo = 0;
    }
}

// Setup matrices to match the FBO texture dimensions
static void fbo_enter(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
{
    VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx);
    const unsigned int width  = pSurfaceGLX->width;
    const unsigned int height = pSurfaceGLX->height;

    pOpenGLVTable->gl_bind_framebuffer(GL_FRAMEBUFFER_EXT, pSurfaceGLX->fbo);
    glPushAttrib(GL_VIEWPORT_BIT);
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();
    glViewport(0, 0, width, height);
    glTranslatef(-1.0f, -1.0f, 0.0f);
    glScalef(2.0f / width, 2.0f / height, 1.0f);
}

// Restore original OpenGL matrices
static void fbo_leave(VADriverContextP ctx)
{
    VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx);

    glPopAttrib();
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);
    glPopMatrix();
    pOpenGLVTable->gl_bind_framebuffer(GL_FRAMEBUFFER_EXT, 0);
}

// Check internal texture format is supported
static int is_supported_internal_format(GLenum format)
{
    /* XXX: we don't support other textures than RGBA */
    switch (format) {
    case 4:
    case GL_RGBA:
    case GL_RGBA8:
        return 1;
    }
    return 0;
}

// Destroy VA/GLX surface
static void
destroy_surface(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
{
    unbind_pixmap(ctx, pSurfaceGLX);
    destroy_fbo_surface(ctx, pSurfaceGLX);
    destroy_tfp_surface(ctx, pSurfaceGLX);
    free(pSurfaceGLX);
}

// Create VA/GLX surface
static VASurfaceGLXP
create_surface(VADriverContextP ctx, GLenum target, GLuint texture)
{
    VASurfaceGLXP pSurfaceGLX = NULL;
    unsigned int internal_format, border_width, width, height;
    int is_error = 1;

    pSurfaceGLX = malloc(sizeof(*pSurfaceGLX));
    if (!pSurfaceGLX)
        goto end;

    pSurfaceGLX->magic          = VA_SURFACE_GLX_MAGIC;
    pSurfaceGLX->target         = target;
    pSurfaceGLX->texture        = texture;
    pSurfaceGLX->surface        = VA_INVALID_SURFACE;
    pSurfaceGLX->gl_context     = NULL;
    pSurfaceGLX->is_bound       = 0;
    pSurfaceGLX->pixmap         = None;
    pSurfaceGLX->pix_texture    = 0;
    pSurfaceGLX->glx_pixmap     = None;
    pSurfaceGLX->fbo            = 0;

    glEnable(target);
    glBindTexture(target, texture);
    if (!gl_get_texture_param(GL_TEXTURE_INTERNAL_FORMAT, &internal_format))
        goto end;
    if (!is_supported_internal_format(internal_format))
        goto end;

    /* Check texture dimensions */
    if (!gl_get_texture_param(GL_TEXTURE_BORDER, &border_width))
        goto end;
    if (!gl_get_texture_param(GL_TEXTURE_WIDTH, &width))
        goto end;
    if (!gl_get_texture_param(GL_TEXTURE_HEIGHT, &height))
        goto end;

    width  -= 2 * border_width;
    height -= 2 * border_width;
    if (width == 0 || height == 0)
        goto end;

    pSurfaceGLX->width  = width;
    pSurfaceGLX->height = height;

    /* Create TFP objects */
    if (!create_tfp_surface(ctx, pSurfaceGLX))
        goto end;

    /* Create FBO objects */
    if (!create_fbo_surface(ctx, pSurfaceGLX))
        goto end;

    is_error = 0;
end:
    if (is_error && pSurfaceGLX) {
        destroy_surface(ctx, pSurfaceGLX);
        pSurfaceGLX = NULL;
    }
    return pSurfaceGLX;
}


/* ========================================================================= */
/* === VA/GLX implementation from the driver (fordward calls)            === */
/* ========================================================================= */

#define INVOKE(ctx, func, args) do {                    \
        VADriverVTableGLXP vtable = (ctx)->vtable_glx;  \
        if (!vtable->va##func##GLX)                     \
            return VA_STATUS_ERROR_UNIMPLEMENTED;       \
                                                        \
        VAStatus status = vtable->va##func##GLX args;   \
        if (status != VA_STATUS_SUCCESS)                \
            return status;                              \
    } while (0)

static VAStatus
vaCreateSurfaceGLX_impl_driver(
    VADriverContextP    ctx,
    GLenum              target,
    GLuint              texture,
    void              **gl_surface
)
{
    INVOKE(ctx, CreateSurface, (ctx, target, texture, gl_surface));
    return VA_STATUS_SUCCESS;
}

static VAStatus
vaDestroySurfaceGLX_impl_driver(VADriverContextP ctx, void *gl_surface)
{
    INVOKE(ctx, DestroySurface, (ctx, gl_surface));
    return VA_STATUS_SUCCESS;
}

static VAStatus
vaCopySurfaceGLX_impl_driver(
    VADriverContextP    ctx,
    void               *gl_surface,
    VASurfaceID         surface,
    unsigned int        flags
)
{
    INVOKE(ctx, CopySurface, (ctx, gl_surface, surface, flags));
    return VA_STATUS_SUCCESS;
}

#undef INVOKE


/* ========================================================================= */
/* === VA/GLX implementation from libVA (generic and suboptimal path)    === */
/* ========================================================================= */

#define INIT_SURFACE(surface, surface_arg) do {         \
        surface = (VASurfaceGLXP)(surface_arg);         \
        if (!check_surface(surface))                    \
            return VA_STATUS_ERROR_INVALID_SURFACE;     \
    } while (0)

// Check VASurfaceGLX is valid
static inline int check_surface(VASurfaceGLXP pSurfaceGLX)
{
    return pSurfaceGLX && pSurfaceGLX->magic == VA_SURFACE_GLX_MAGIC;
}

static VAStatus
vaCreateSurfaceGLX_impl_libva(
    VADriverContextP    ctx,
    GLenum              target,
    GLuint              texture,
    void              **gl_surface
)
{
    VASurfaceGLXP pSurfaceGLX;
    struct OpenGLContextState old_cs, *new_cs;

    gl_get_current_context(&old_cs);
    new_cs = gl_create_context(ctx, &old_cs);
    if (!new_cs)
        goto error;
    if (!gl_set_current_context(new_cs, NULL))
        goto error;

    pSurfaceGLX = create_surface(ctx, target, texture);
    if (!pSurfaceGLX)
        goto error;

    pSurfaceGLX->gl_context = new_cs;
    *gl_surface = pSurfaceGLX;

    gl_set_current_context(&old_cs, NULL);
    return VA_STATUS_SUCCESS;

error:
    if (new_cs)
        gl_destroy_context(new_cs);

    return VA_STATUS_ERROR_ALLOCATION_FAILED;    
}

static VAStatus
vaDestroySurfaceGLX_impl_libva(VADriverContextP ctx, void *gl_surface)
{
    VASurfaceGLXP pSurfaceGLX;
    struct OpenGLContextState old_cs = {0}, *new_cs;

    INIT_SURFACE(pSurfaceGLX, gl_surface);

    new_cs = pSurfaceGLX->gl_context;
    if (!gl_set_current_context(new_cs, &old_cs))
        return VA_STATUS_ERROR_OPERATION_FAILED;

    destroy_surface(ctx, pSurfaceGLX);

    gl_destroy_context(new_cs);
    gl_set_current_context(&old_cs, NULL);
    return VA_STATUS_SUCCESS;
}

static inline VAStatus
deassociate_surface(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
{
    if (!unbind_pixmap(ctx, pSurfaceGLX))
        return VA_STATUS_ERROR_OPERATION_FAILED;

    pSurfaceGLX->surface = VA_INVALID_SURFACE;
    return VA_STATUS_SUCCESS;
}

static VAStatus
associate_surface(
    VADriverContextP    ctx,
    VASurfaceGLXP       pSurfaceGLX,
    VASurfaceID         surface,
    unsigned int        flags
)
{
    VAStatus status;

    /* XXX: optimise case where we are associating the same VA surface
       as before an no changed occurred to it */
    status = deassociate_surface(ctx, pSurfaceGLX);
    if (status != VA_STATUS_SUCCESS)
        return status;

    x11_trap_errors();
    status = ctx->vtable->vaPutSurface(
        ctx,
        surface,
        (void *)pSurfaceGLX->pixmap,
        0, 0, pSurfaceGLX->width, pSurfaceGLX->height,
        0, 0, pSurfaceGLX->width, pSurfaceGLX->height,
        NULL, 0,
        flags
    );
    XSync(ctx->native_dpy, False);
    if (x11_untrap_errors() != 0)
        return VA_STATUS_ERROR_OPERATION_FAILED;
    if (status != VA_STATUS_SUCCESS)
        return status;

    pSurfaceGLX->surface = surface;
    return VA_STATUS_SUCCESS;
}

static inline VAStatus
sync_surface(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
{
    if (pSurfaceGLX->surface == VA_INVALID_SURFACE)
        return VA_STATUS_ERROR_INVALID_SURFACE;

    return ctx->vtable->vaSyncSurface(ctx, pSurfaceGLX->surface);
}

static inline VAStatus
begin_render_surface(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
{
    VAStatus status;

    status = sync_surface(ctx, pSurfaceGLX);
    if (status != VA_STATUS_SUCCESS)
        return status;

    if (!bind_pixmap(ctx, pSurfaceGLX))
        return VA_STATUS_ERROR_OPERATION_FAILED;

    return VA_STATUS_SUCCESS;
}

static inline VAStatus
end_render_surface(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
{
    if (!unbind_pixmap(ctx, pSurfaceGLX))
        return VA_STATUS_ERROR_OPERATION_FAILED;

    return VA_STATUS_SUCCESS;
}

static VAStatus
copy_surface(
    VADriverContextP    ctx,
    VASurfaceGLXP       pSurfaceGLX,
    VASurfaceID         surface,
    unsigned int        flags
)
{
    VAStatus status;

    /* Associate VA surface */
    status = associate_surface(ctx, pSurfaceGLX, surface, flags);
    if (status != VA_STATUS_SUCCESS)
        return status;

    /* Render to FBO */
    fbo_enter(ctx, pSurfaceGLX);
    status = begin_render_surface(ctx, pSurfaceGLX);
    if (status == VA_STATUS_SUCCESS) {
        render_pixmap(ctx, pSurfaceGLX);
        status = end_render_surface(ctx, pSurfaceGLX);
    }
    fbo_leave(ctx);
    if (status != VA_STATUS_SUCCESS)
        return status;

    return deassociate_surface(ctx, pSurfaceGLX);
}

static VAStatus
vaCopySurfaceGLX_impl_libva(
    VADriverContextP    ctx,
    void               *gl_surface,
    VASurfaceID         surface,
    unsigned int        flags
)
{
    VASurfaceGLXP pSurfaceGLX;
    VAStatus status;
    struct OpenGLContextState old_cs = {0};

    INIT_SURFACE(pSurfaceGLX, gl_surface);

    if (!gl_set_current_context(pSurfaceGLX->gl_context, &old_cs))
        return VA_STATUS_ERROR_OPERATION_FAILED;

    status = copy_surface(ctx, pSurfaceGLX, surface, flags);

    gl_set_current_context(&old_cs, NULL);
    return status;
}

#undef INIT_SURFACE


/* ========================================================================= */
/* === Private VA/GLX vtable initialization                              === */
/* ========================================================================= */

// Initialize GLX driver context
VAStatus va_glx_init_context(VADriverContextP ctx)
{
    VADriverContextGLXP glx_ctx = VA_DRIVER_CONTEXT_GLX(ctx);
    VADriverVTableGLXP  vtable  = &glx_ctx->vtable;
    int glx_major, glx_minor;

    if (glx_ctx->is_initialized)
        return VA_STATUS_SUCCESS;

    if (ctx->vtable_glx && ctx->vtable_glx->vaCopySurfaceGLX) {
        vtable->vaCreateSurfaceGLX      = vaCreateSurfaceGLX_impl_driver;
        vtable->vaDestroySurfaceGLX     = vaDestroySurfaceGLX_impl_driver;
        vtable->vaCopySurfaceGLX        = vaCopySurfaceGLX_impl_driver;
    }
    else {
        vtable->vaCreateSurfaceGLX      = vaCreateSurfaceGLX_impl_libva;
        vtable->vaDestroySurfaceGLX     = vaDestroySurfaceGLX_impl_libva;
        vtable->vaCopySurfaceGLX        = vaCopySurfaceGLX_impl_libva;

        if (!glXQueryVersion(ctx->native_dpy, &glx_major, &glx_minor))
            return VA_STATUS_ERROR_UNIMPLEMENTED;

        if (!check_tfp_extensions(ctx) || !load_tfp_extensions(ctx))
            return VA_STATUS_ERROR_UNIMPLEMENTED;

        if (!check_fbo_extensions(ctx) || !load_fbo_extensions(ctx))
            return VA_STATUS_ERROR_UNIMPLEMENTED;
    }

    glx_ctx->is_initialized = 1;
    return VA_STATUS_SUCCESS;
}