| /* |
| * 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; |
| } |
