gst-libs/gst/vaapi/gstvaapiutils_glx.c

   1 /*
   2  *  gstvaapiutils_glx.c - GLX utilties
   3  *
   4  *  gstreamer-vaapi (C) 2010 Splitted-Desktop Systems
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  19  */
  20
  21 #define _GNU_SOURCE 1 /* RTLD_DEFAULT */
  22 #include "config.h"
  23 #include <string.h>
  24 #include <math.h>
  25 #include <dlfcn.h>
  26 #include "gstvaapiutils_glx.h"
  27 #include "gstvaapiutils_x11.h"
  28
  29 #define DEBUG 1
  30 #include "gstvaapidebug.h"
  31
  32 /** Lookup for substring NAME in string EXT using SEP as separators */
  33 static gboolean
  34 find_string(const char *name, const char *ext, const char *sep)
  35 {
  36     const char *end;
  37     int name_len, n;
  38
  39     if (!name || !ext)
  40         return FALSE;
  41
  42     end = ext + strlen(ext);
  43     name_len = strlen(name);
  44     while (ext < end) {
  45         n = strcspn(ext, sep);
  46         if (n == name_len && strncmp(name, ext, n) == 0)
  47             return TRUE;
  48         ext += (n + 1);
  49     }
  50     return FALSE;
  51 }
  52
  53 /**
  54  * gl_get_error_string:
  55  * @error: an OpenGL error enumeration
  56  *
  57  * Retrieves the string representation the OpenGL @error.
  58  *
  59  * Return error: the static string representing the OpenGL @error
  60  */
  61 const char *
  62 gl_get_error_string(GLenum error)
  63 {
  64     static const struct {
  65         GLenum val;
  66         const char *str;
  67     }
  68     gl_errors[] = {
  69         { GL_NO_ERROR,          "no error" },
  70         { GL_INVALID_ENUM,      "invalid enumerant" },
  71         { GL_INVALID_VALUE,     "invalid value" },
  72         { GL_INVALID_OPERATION, "invalid operation" },
  73         { GL_STACK_OVERFLOW,    "stack overflow" },
  74         { GL_STACK_UNDERFLOW,   "stack underflow" },
  75         { GL_OUT_OF_MEMORY,     "out of memory" },
  76 #ifdef GL_INVALID_FRAMEBUFFER_OPERATION_EXT
  77         { GL_INVALID_FRAMEBUFFER_OPERATION_EXT, "invalid framebuffer operation" },
  78 #endif
  79         { ~0, NULL }
  80     };
  81
  82     guint i;
  83     for (i = 0; gl_errors[i].str; i++) {
  84         if (gl_errors[i].val == error)
  85             return gl_errors[i].str;
  86     }
  87     return "unknown";
  88 }
  89
  90 /**
  91  * gl_purge_errors:
  92  *
  93  * Purges all OpenGL errors. This function is generally useful to
  94  * clear up the pending errors prior to calling gl_check_error().
  95  */
  96 void
  97 gl_purge_errors(void)
  98 {
  99     while (glGetError() != GL_NO_ERROR)
 100         ; /* nothing */
 101 }
 102
 103 /**
 104  * gl_check_error:
 105  *
 106  * Checks whether there is any OpenGL error pending.
 107  *
 108  * Return value: %TRUE if an error was encountered
 109  */
 110 gboolean
 111 gl_check_error(void)
 112 {
 113     GLenum error;
 114     gboolean has_errors = FALSE;
 115
 116     while ((error = glGetError()) != GL_NO_ERROR) {
 117         GST_DEBUG("glError: %s caught", gl_get_error_string(error));
 118         has_errors = TRUE;
 119     }
 120     return has_errors;
 121 }
 122
 123 /**
 124  * gl_get_param:
 125  * @param: the parameter name
 126  * @pval: return location for the value
 127  *
 128  * This function is a wrapper around glGetIntegerv() that does extra
 129  * error checking.
 130  *
 131  * Return value: %TRUE on success
 132  */
 133 gboolean
 134 gl_get_param(GLenum param, guint *pval)
 135 {
 136     GLint val;
 137
 138     gl_purge_errors();
 139     glGetIntegerv(param, &val);
 140     if (gl_check_error())
 141         return FALSE;
 142
 143     if (pval)
 144         *pval = val;
 145     return TRUE;
 146 }
 147
 148 /**
 149  * gl_get_texture_param:
 150  * @target: the target to which the texture is bound
 151  * @param: the parameter name
 152  * @pval: return location for the value
 153  *
 154  * This function is a wrapper around glGetTexLevelParameteriv() that
 155  * does extra error checking.
 156  *
 157  * Return value: %TRUE on success
 158  */
 159 gboolean
 160 gl_get_texture_param(GLenum target, GLenum param, guint *pval)
 161 {
 162     GLint val;
 163
 164     gl_purge_errors();
 165     glGetTexLevelParameteriv(target, 0, param, &val);
 166     if (gl_check_error())
 167         return FALSE;
 168
 169     if (pval)
 170         *pval = val;
 171     return TRUE;
 172 }
 173
 174 /**
 175  * gl_set_bgcolor:
 176  * @color: the requested RGB color
 177  *
 178  * Sets background color to the RGB @color. This basically is a
 179  * wrapper around glClearColor().
 180  */
 181 void
 182 gl_set_bgcolor(guint32 color)
 183 {
 184     glClearColor(
 185         ((color >> 16) & 0xff) / 255.0f,
 186         ((color >>  8) & 0xff) / 255.0f,
 187         ( color        & 0xff) / 255.0f,
 188         1.0f
 189     );
 190 }
 191
 192 /**
 193  * gl_perspective:
 194  * @fovy: the field of view angle, in degrees, in the y direction
 195  * @aspect: the aspect ratio that determines the field of view in the
 196  *   x direction.  The aspect ratio is the ratio of x (width) to y
 197  *   (height)
 198  * @zNear: the distance from the viewer to the near clipping plane
 199  *   (always positive)
 200  * @zFar: the distance from the viewer to the far clipping plane
 201  *   (always positive)
 202  *
 203  * Specified a viewing frustum into the world coordinate system. This
 204  * basically is the Mesa implementation of gluPerspective().
 205  */
 206 static void
 207 frustum(GLdouble left, GLdouble right,
 208         GLdouble bottom, GLdouble top,
 209         GLdouble nearval, GLdouble farval)
 210 {
 211     GLdouble x, y, a, b, c, d;
 212     GLdouble m[16];
 213
 214     x = (2.0 * nearval) / (right - left);
 215     y = (2.0 * nearval) / (top - bottom);
 216     a = (right + left) / (right - left);
 217     b = (top + bottom) / (top - bottom);
 218     c = -(farval + nearval) / ( farval - nearval);
 219     d = -(2.0 * farval * nearval) / (farval - nearval);
 220
 221 #define M(row,col)  m[col*4+row]
 222     M(0,0) = x;     M(0,1) = 0.0F;  M(0,2) = a;      M(0,3) = 0.0F;
 223     M(1,0) = 0.0F;  M(1,1) = y;     M(1,2) = b;      M(1,3) = 0.0F;
 224     M(2,0) = 0.0F;  M(2,1) = 0.0F;  M(2,2) = c;      M(2,3) = d;
 225     M(3,0) = 0.0F;  M(3,1) = 0.0F;  M(3,2) = -1.0F;  M(3,3) = 0.0F;
 226 #undef M
 227
 228     glMultMatrixd(m);
 229 }
 230
 231 static void
 232 gl_perspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar)
 233 {
 234     GLdouble xmin, xmax, ymin, ymax;
 235
 236     ymax = zNear * tan(fovy * M_PI / 360.0);
 237     ymin = -ymax;
 238     xmin = ymin * aspect;
 239     xmax = ymax * aspect;
 240
 241     /* Don't call glFrustum() because of error semantics (covglu) */
 242     frustum(xmin, xmax, ymin, ymax, zNear, zFar);
 243 }
 244
 245 /**
 246  * gl_resize:
 247  * @width: the requested width, in pixels
 248  * @height: the requested height, in pixels
 249  *
 250  * Resizes the OpenGL viewport to the specified dimensions, using an
 251  * orthogonal projection. (0,0) represents the top-left corner of the
 252  * window.
 253  */
 254 void
 255 gl_resize(guint width, guint height)
 256 {
 257 #define FOVY     60.0f
 258 #define ASPECT   1.0f
 259 #define Z_NEAR   0.1f
 260 #define Z_FAR    100.0f
 261 #define Z_CAMERA 0.869f
 262
 263     glViewport(0, 0, width, height);
 264     glMatrixMode(GL_PROJECTION);
 265     glLoadIdentity();
 266     gl_perspective(FOVY, ASPECT, Z_NEAR, Z_FAR);
 267     glMatrixMode(GL_MODELVIEW);
 268     glLoadIdentity();
 269
 270     glTranslatef(-0.5f, -0.5f, -Z_CAMERA);
 271     glScalef(1.0f/width, -1.0f/height, 1.0f/width);
 272     glTranslatef(0.0f, -1.0f*height, 0.0f);
 273 }
 274
 275 /**
 276  * gl_create_context:
 277  * @dpy: an X11 #Display
 278  * @screen: the associated screen of @dpy
 279  * @parent: the parent #GLContextState, or %NULL if none is to be used
 280  *
 281  * Creates a GLX context sharing textures and displays lists with
 282  * @parent, if not %NULL.
 283  *
 284  * Return value: the newly created GLX context
 285  */
 286 GLContextState *
 287 gl_create_context(Display *dpy, int screen, GLContextState *parent)
 288 {
 289     GLContextState *cs;
 290     GLXFBConfig *fbconfigs = NULL;
 291     int fbconfig_id, val, n, n_fbconfigs;
 292     Status status;
 293
 294     static GLint fbconfig_attrs[] = {
 295         GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
 296         GLX_RENDER_TYPE,   GLX_RGBA_BIT,
 297         GLX_DOUBLEBUFFER,  True,
 298         GLX_RED_SIZE,      8,
 299         GLX_GREEN_SIZE,    8,
 300         GLX_BLUE_SIZE,     8,
 301         None
 302     };
 303
 304     cs = malloc(sizeof(*cs));
 305     if (!cs)
 306         goto error;
 307
 308     cs->display         = dpy;
 309     cs->window          = parent ? parent->window : None;
 310     cs->visual          = NULL;
 311     cs->context         = NULL;
 312     cs->swapped_buffers = FALSE;
 313
 314     if (parent && parent->context) {
 315         status = glXQueryContext(
 316             parent->display,
 317             parent->context,
 318             GLX_FBCONFIG_ID, &fbconfig_id
 319         );
 320         if (status != Success)
 321             goto error;
 322
 323         if (fbconfig_id == GLX_DONT_CARE)
 324             goto choose_fbconfig;
 325
 326         fbconfigs = glXGetFBConfigs(dpy, screen, &n_fbconfigs);
 327         if (!fbconfigs)
 328             goto error;
 329
 330         /* Find out a GLXFBConfig compatible with the parent context */
 331         for (n = 0; n < n_fbconfigs; n++) {
 332             status = glXGetFBConfigAttrib(
 333                 dpy,
 334                 fbconfigs[n],
 335                 GLX_FBCONFIG_ID, &val
 336             );
 337             if (status == Success && val == fbconfig_id)
 338                 break;
 339         }
 340         if (n == n_fbconfigs)
 341             goto error;
 342     }
 343     else {
 344     choose_fbconfig:
 345         fbconfigs = glXChooseFBConfig(
 346             dpy,
 347             screen,
 348             fbconfig_attrs, &n_fbconfigs
 349         );
 350         if (!fbconfigs)
 351             goto error;
 352
 353         /* Select the first one */
 354         n = 0;
 355     }
 356
 357     cs->visual  = glXGetVisualFromFBConfig(dpy, fbconfigs[n]);
 358     cs->context = glXCreateNewContext(
 359         dpy,
 360         fbconfigs[n],
 361         GLX_RGBA_TYPE,
 362         parent ? parent->context : NULL,
 363         True
 364     );
 365     if (cs->context)
 366         goto end;
 367
 368 error:
 369     gl_destroy_context(cs);
 370     cs = NULL;
 371 end:
 372     if (fbconfigs)
 373         XFree(fbconfigs);
 374     return cs;
 375 }
 376
 377 /**
 378  * gl_destroy_context:
 379  * @cs: a #GLContextState
 380  *
 381  * Destroys the GLX context @cs
 382  */
 383 void
 384 gl_destroy_context(GLContextState *cs)
 385 {
 386     if (!cs)
 387         return;
 388
 389     if (cs->visual) {
 390         XFree(cs->visual);
 391         cs->visual = NULL;
 392     }
 393
 394     if (cs->display && cs->context) {
 395         if (glXGetCurrentContext() == cs->context) {
 396             /* XXX: if buffers were never swapped, the application
 397                will crash later with the NVIDIA driver */
 398             if (!cs->swapped_buffers)
 399                 gl_swap_buffers(cs);
 400             glXMakeCurrent(cs->display, None, NULL);
 401         }
 402         glXDestroyContext(cs->display, cs->context);
 403         cs->display = NULL;
 404         cs->context = NULL;
 405     }
 406     free(cs);
 407 }
 408
 409 /**
 410  * gl_get_current_context:
 411  * @cs: return location to the current #GLContextState
 412  *
 413  * Retrieves the current GLX context, display and drawable packed into
 414  * the #GLContextState struct.
 415  */
 416 void
 417 gl_get_current_context(GLContextState *cs)
 418 {
 419     cs->display = glXGetCurrentDisplay();
 420     cs->window  = glXGetCurrentDrawable();
 421     cs->context = glXGetCurrentContext();
 422 }
 423
 424 /**
 425  * gl_set_current_context:
 426  * @new_cs: the requested new #GLContextState
 427  * @old_cs: return location to the context that was previously current
 428  *
 429  * Makes the @new_cs GLX context the current GLX rendering context of
 430  * the calling thread, replacing the previously current context if
 431  * there was one.
 432  *
 433  * If @old_cs is non %NULL, the previously current GLX context and
 434  * window are recorded.
 435  *
 436  * Return value: %TRUE on success
 437  */
 438 gboolean
 439 gl_set_current_context(GLContextState *new_cs, GLContextState *old_cs)
 440 {
 441     /* If display is NULL, this could be that new_cs was retrieved from
 442        gl_get_current_context() with none set previously. If that case,
 443        the other fields are also NULL and we don't return an error */
 444     if (!new_cs->display)
 445         return !new_cs->window && !new_cs->context;
 446
 447     if (old_cs) {
 448         if (old_cs == new_cs)
 449             return TRUE;
 450         gl_get_current_context(old_cs);
 451         if (old_cs->display == new_cs->display &&
 452             old_cs->window  == new_cs->window  &&
 453             old_cs->context == new_cs->context)
 454             return TRUE;
 455     }
 456     return glXMakeCurrent(new_cs->display, new_cs->window, new_cs->context);
 457 }
 458
 459 /**
 460  * gl_swap_buffers:
 461  * @cs: a #GLContextState
 462  *
 463  * Promotes the contents of the back buffer of the @win window to
 464  * become the contents of the front buffer. This simply is wrapper
 465  * around glXSwapBuffers().
 466  */
 467 void
 468 gl_swap_buffers(GLContextState *cs)
 469 {
 470     glXSwapBuffers(cs->display, cs->window);
 471     cs->swapped_buffers = TRUE;
 472 }
 473
 474 /**
 475  * gl_bind_texture:
 476  * @ts: a #GLTextureState
 477  * @target: the target to which the texture is bound
 478  * @texture: the name of a texture
 479  *
 480  * Binds @texture to the specified @target, while recording the
 481  * previous state in @ts.
 482  *
 483  * Return value: %TRUE on success
 484  */
 485 gboolean
 486 gl_bind_texture(GLTextureState *ts, GLenum target, GLuint texture)
 487 {
 488     ts->target      = target;
 489     ts->old_texture = 0;
 490     ts->was_bound   = 0;
 491     ts->was_enabled = glIsEnabled(target);
 492     if (!ts->was_enabled)
 493         glEnable(target);
 494
 495     GLenum texture_binding;
 496     switch (target) {
 497     case GL_TEXTURE_1D:
 498         texture_binding = GL_TEXTURE_BINDING_1D;
 499         break;
 500     case GL_TEXTURE_2D:
 501         texture_binding = GL_TEXTURE_BINDING_2D;
 502         break;
 503     case GL_TEXTURE_3D:
 504         texture_binding = GL_TEXTURE_BINDING_3D;
 505         break;
 506     case GL_TEXTURE_RECTANGLE_ARB:
 507         texture_binding = GL_TEXTURE_BINDING_RECTANGLE_ARB;
 508         break;
 509     default:
 510         g_assert(!texture);
 511         return FALSE;
 512     }
 513
 514     if (!gl_get_param(texture_binding, &ts->old_texture))
 515         return FALSE;
 516
 517     ts->was_bound = texture == ts->old_texture;
 518     if (!ts->was_bound) {
 519         gl_purge_errors();
 520         glBindTexture(target, texture);
 521         if (gl_check_error())
 522             return FALSE;
 523     }
 524     return TRUE;
 525 }
 526
 527 /**
 528  * gl_unbind_texture:
 529  * @ts: a #GLTextureState
 530  *
 531  * Rebinds the texture that was previously bound and recorded in @ts.
 532  */
 533 void
 534 gl_unbind_texture(GLTextureState *ts)
 535 {
 536     if (!ts->was_bound && ts->old_texture)
 537         glBindTexture(ts->target, ts->old_texture);
 538     if (!ts->was_enabled)
 539         glDisable(ts->target);
 540 }
 541
 542 /**
 543  * gl_create_texture:
 544  * @target: the target to which the texture is bound
 545  * @format: the format of the pixel data
 546  * @width: the requested width, in pixels
 547  * @height: the requested height, in pixels
 548  *
 549  * Creates a texture with the specified dimensions and @format. The
 550  * internal format will be automatically derived from @format.
 551  *
 552  * Return value: the newly created texture name
 553  */
 554 GLuint
 555 gl_create_texture(GLenum target, GLenum format, guint width, guint height)
 556 {
 557     GLenum internal_format;
 558     GLuint texture;
 559     GLTextureState ts;
 560     guint bytes_per_component;
 561
 562     internal_format = format;
 563     switch (format) {
 564     case GL_LUMINANCE:
 565         bytes_per_component = 1;
 566         break;
 567     case GL_LUMINANCE_ALPHA:
 568         bytes_per_component = 2;
 569         break;
 570     case GL_RGBA:
 571     case GL_BGRA:
 572         internal_format = GL_RGBA;
 573         bytes_per_component = 4;
 574         break;
 575     default:
 576         bytes_per_component = 0;
 577         break;
 578     }
 579     g_assert(bytes_per_component > 0);
 580
 581     glGenTextures(1, &texture);
 582     if (!gl_bind_texture(&ts, target, texture))
 583         return 0;
 584     glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 585     glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 586     glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 587     glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 588     glPixelStorei(GL_UNPACK_ALIGNMENT, bytes_per_component);
 589     glTexImage2D(
 590         target,
 591         0,
 592         internal_format,
 593         width, height,
 594         0,
 595         format,
 596         GL_UNSIGNED_BYTE,
 597         NULL
 598     );
 599     gl_unbind_texture(&ts);
 600     return texture;
 601 }
 602
 603 /**
 604  * get_proc_address:
 605  * @name: the name of the OpenGL extension function to lookup
 606  *
 607  * Returns the specified OpenGL extension function
 608  *
 609  * Return value: the OpenGL extension matching @name, or %NULL if none
 610  *   was found
 611  */
 612 typedef void (*GLFuncPtr)(void);
 613 typedef GLFuncPtr (*GLXGetProcAddressProc)(const char *);
 614
 615 static GLFuncPtr
 616 get_proc_address_default(const char *name)
 617 {
 618     return NULL;
 619 }
 620
 621 static GLXGetProcAddressProc
 622 get_proc_address_func(void)
 623 {
 624     GLXGetProcAddressProc get_proc_func;
 625
 626     dlerror();
 627     get_proc_func = (GLXGetProcAddressProc)
 628         dlsym(RTLD_DEFAULT, "glXGetProcAddress");
 629     if (!dlerror())
 630         return get_proc_func;
 631
 632     get_proc_func = (GLXGetProcAddressProc)
 633         dlsym(RTLD_DEFAULT, "glXGetProcAddressARB");
 634     if (!dlerror())
 635         return get_proc_func;
 636
 637     return get_proc_address_default;
 638 }
 639
 640 static inline GLFuncPtr
 641 get_proc_address(const char *name)
 642 {
 643     static GLXGetProcAddressProc get_proc_func = NULL;
 644     if (!get_proc_func)
 645         get_proc_func = get_proc_address_func();
 646     return get_proc_func(name);
 647 }
 648
 649 /**
 650  * gl_init_vtable:
 651  *
 652  * Initializes the global #GLVTable.
 653  *
 654  * Return value: the #GLVTable filled in with OpenGL extensions, or
 655  *   %NULL on error.
 656  */
 657 static GLVTable gl_vtable_static;
 658
 659 static GLVTable *
 660 gl_init_vtable(void)
 661 {
 662     GLVTable * const gl_vtable = &gl_vtable_static;
 663     const gchar *gl_extensions = (const gchar *)glGetString(GL_EXTENSIONS);
 664     gboolean has_extension;
 665
 666     /* GLX_EXT_texture_from_pixmap */
 667     gl_vtable->glx_bind_tex_image = (PFNGLXBINDTEXIMAGEEXTPROC)
 668         get_proc_address("glXBindTexImageEXT");
 669     if (!gl_vtable->glx_bind_tex_image)
 670         return NULL;
 671     gl_vtable->glx_release_tex_image = (PFNGLXRELEASETEXIMAGEEXTPROC)
 672         get_proc_address("glXReleaseTexImageEXT");
 673     if (!gl_vtable->glx_release_tex_image)
 674         return NULL;
 675
 676     /* GL_ARB_framebuffer_object */
 677     has_extension = (
 678         find_string("GL_ARB_framebuffer_object", gl_extensions, " ") ||
 679         find_string("GL_EXT_framebuffer_object", gl_extensions, " ")
 680     );
 681     if (has_extension) {
 682         gl_vtable->gl_gen_framebuffers = (PFNGLGENFRAMEBUFFERSEXTPROC)
 683             get_proc_address("glGenFramebuffersEXT");
 684         if (!gl_vtable->gl_gen_framebuffers)
 685             return NULL;
 686         gl_vtable->gl_delete_framebuffers = (PFNGLDELETEFRAMEBUFFERSEXTPROC)
 687             get_proc_address("glDeleteFramebuffersEXT");
 688         if (!gl_vtable->gl_delete_framebuffers)
 689             return NULL;
 690         gl_vtable->gl_bind_framebuffer = (PFNGLBINDFRAMEBUFFEREXTPROC)
 691             get_proc_address("glBindFramebufferEXT");
 692         if (!gl_vtable->gl_bind_framebuffer)
 693             return NULL;
 694         gl_vtable->gl_gen_renderbuffers = (PFNGLGENRENDERBUFFERSEXTPROC)
 695             get_proc_address("glGenRenderbuffersEXT");
 696         if (!gl_vtable->gl_gen_renderbuffers)
 697             return NULL;
 698         gl_vtable->gl_delete_renderbuffers = (PFNGLDELETERENDERBUFFERSEXTPROC)
 699             get_proc_address("glDeleteRenderbuffersEXT");
 700         if (!gl_vtable->gl_delete_renderbuffers)
 701             return NULL;
 702         gl_vtable->gl_bind_renderbuffer = (PFNGLBINDRENDERBUFFEREXTPROC)
 703             get_proc_address("glBindRenderbufferEXT");
 704         if (!gl_vtable->gl_bind_renderbuffer)
 705             return NULL;
 706         gl_vtable->gl_renderbuffer_storage = (PFNGLRENDERBUFFERSTORAGEEXTPROC)
 707             get_proc_address("glRenderbufferStorageEXT");
 708         if (!gl_vtable->gl_renderbuffer_storage)
 709             return NULL;
 710         gl_vtable->gl_framebuffer_renderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)
 711             get_proc_address("glFramebufferRenderbufferEXT");
 712         if (!gl_vtable->gl_framebuffer_renderbuffer)
 713             return NULL;
 714         gl_vtable->gl_framebuffer_texture_2d = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)
 715             get_proc_address("glFramebufferTexture2DEXT");
 716         if (!gl_vtable->gl_framebuffer_texture_2d)
 717             return NULL;
 718         gl_vtable->gl_check_framebuffer_status = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)
 719             get_proc_address("glCheckFramebufferStatusEXT");
 720         if (!gl_vtable->gl_check_framebuffer_status)
 721             return NULL;
 722         gl_vtable->has_framebuffer_object = TRUE;
 723     }
 724
 725     /* GL_ARB_fragment_program */
 726     has_extension = (
 727         find_string("GL_ARB_fragment_program", gl_extensions, " ")
 728     );
 729     if (has_extension) {
 730         gl_vtable->gl_gen_programs = (PFNGLGENPROGRAMSARBPROC)
 731             get_proc_address("glGenProgramsARB");
 732         if (!gl_vtable->gl_gen_programs)
 733             return NULL;
 734         gl_vtable->gl_delete_programs = (PFNGLDELETEPROGRAMSARBPROC)
 735             get_proc_address("glDeleteProgramsARB");
 736         if (!gl_vtable->gl_delete_programs)
 737             return NULL;
 738         gl_vtable->gl_bind_program = (PFNGLBINDPROGRAMARBPROC)
 739             get_proc_address("glBindProgramARB");
 740         if (!gl_vtable->gl_bind_program)
 741             return NULL;
 742         gl_vtable->gl_program_string = (PFNGLPROGRAMSTRINGARBPROC)
 743             get_proc_address("glProgramStringARB");
 744         if (!gl_vtable->gl_program_string)
 745             return NULL;
 746         gl_vtable->gl_get_program_iv = (PFNGLGETPROGRAMIVARBPROC)
 747             get_proc_address("glGetProgramivARB");
 748         if (!gl_vtable->gl_get_program_iv)
 749             return NULL;
 750         gl_vtable->gl_program_local_parameter_4fv = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC)
 751             get_proc_address("glProgramLocalParameter4fvARB");
 752         if (!gl_vtable->gl_program_local_parameter_4fv)
 753             return NULL;
 754         gl_vtable->has_fragment_program = TRUE;
 755     }
 756
 757     /* GL_ARB_multitexture */
 758     has_extension = (
 759         find_string("GL_ARB_multitexture", gl_extensions, " ")
 760     );
 761     if (has_extension) {
 762         gl_vtable->gl_active_texture = (PFNGLACTIVETEXTUREPROC)
 763             get_proc_address("glActiveTextureARB");
 764         if (!gl_vtable->gl_active_texture)
 765             return NULL;
 766         gl_vtable->gl_multi_tex_coord_2f = (PFNGLMULTITEXCOORD2FPROC)
 767             get_proc_address("glMultiTexCoord2fARB");
 768         if (!gl_vtable->gl_multi_tex_coord_2f)
 769             return NULL;
 770         gl_vtable->has_multitexture = TRUE;
 771     }
 772     return gl_vtable;
 773 }
 774
 775 /**
 776  * gl_get_vtable:
 777  *
 778  * Retrieves a VTable for OpenGL extensions.
 779  *
 780  * Return value: VTable for OpenGL extensions
 781  */
 782 GLVTable *
 783 gl_get_vtable(void)
 784 {
 785     static GStaticMutex mutex          = G_STATIC_MUTEX_INIT;
 786     static gboolean     gl_vtable_init = TRUE;
 787     static GLVTable    *gl_vtable      = NULL;
 788
 789     g_static_mutex_lock(&mutex);
 790     if (gl_vtable_init) {
 791         gl_vtable_init = FALSE;
 792         gl_vtable      = gl_init_vtable();
 793     }
 794     g_static_mutex_unlock(&mutex);
 795     return gl_vtable;
 796 }
 797
 798 /**
 799  * gl_create_pixmap_object:
 800  * @dpy: an X11 #Display
 801  * @width: the request width, in pixels
 802  * @height: the request height, in pixels
 803  *
 804  * Creates a #GLPixmapObject of the specified dimensions. This
 805  * requires the GLX_EXT_texture_from_pixmap extension.
 806  *
 807  * Return value: the newly created #GLPixmapObject object
 808  */
 809 GLPixmapObject *
 810 gl_create_pixmap_object(Display *dpy, guint width, guint height)
 811 {
 812     GLVTable * const    gl_vtable = gl_get_vtable();
 813     GLPixmapObject     *pixo;
 814     GLXFBConfig        *fbconfig;
 815     int                 screen;
 816     Window              rootwin;
 817     XWindowAttributes   wattr;
 818     int                *attr;
 819     int                 n_fbconfig_attrs;
 820
 821     int fbconfig_attrs[32] = {
 822         GLX_DRAWABLE_TYPE,      GLX_PIXMAP_BIT,
 823         GLX_DOUBLEBUFFER,       GL_FALSE,
 824         GLX_RENDER_TYPE,        GLX_RGBA_BIT,
 825         GLX_X_RENDERABLE,       GL_TRUE,
 826         GLX_Y_INVERTED_EXT,     GL_TRUE,
 827         GLX_RED_SIZE,           8,
 828         GLX_GREEN_SIZE,         8,
 829         GLX_BLUE_SIZE,          8,
 830         GL_NONE,
 831     };
 832
 833     int pixmap_attrs[10] = {
 834         GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
 835         GLX_MIPMAP_TEXTURE_EXT, GL_FALSE,
 836         GL_NONE,
 837     };
 838
 839     if (!gl_vtable)
 840         return NULL;
 841
 842     screen  = DefaultScreen(dpy);
 843     rootwin = RootWindow(dpy, screen);
 844
 845     /* XXX: this won't work for different displays */
 846     if (!gl_vtable->has_texture_from_pixmap) {
 847         const char *glx_extensions;
 848         int glx_major, glx_minor;
 849         glx_extensions = glXQueryExtensionsString(dpy, screen);
 850         if (!glx_extensions)
 851             return NULL;
 852         if (!find_string("GLX_EXT_texture_from_pixmap", glx_extensions, " "))
 853             return NULL;
 854         if (!glXQueryVersion(dpy, &glx_major, &glx_minor))
 855             return NULL;
 856         if (glx_major < 1 || (glx_major == 1 && glx_minor < 3)) /* 1.3 */
 857             return NULL;
 858         gl_vtable->has_texture_from_pixmap = TRUE;
 859     }
 860
 861     pixo = calloc(1, sizeof(*pixo));
 862     if (!pixo)
 863         return NULL;
 864
 865     pixo->dpy           = dpy;
 866     pixo->width         = width;
 867     pixo->height        = height;
 868     pixo->pixmap        = None;
 869     pixo->glx_pixmap    = None;
 870     pixo->is_bound      = FALSE;
 871
 872     XGetWindowAttributes(dpy, rootwin, &wattr);
 873     pixo->pixmap  = XCreatePixmap(dpy, rootwin, width, height, wattr.depth);
 874     if (!pixo->pixmap)
 875         goto error;
 876
 877     /* Initialize FBConfig attributes */
 878     for (attr = fbconfig_attrs; *attr != GL_NONE; attr += 2)
 879         ;
 880     *attr++ = GLX_DEPTH_SIZE;                 *attr++ = wattr.depth;
 881     if (wattr.depth == 32) {
 882     *attr++ = GLX_ALPHA_SIZE;                 *attr++ = 8;
 883     *attr++ = GLX_BIND_TO_TEXTURE_RGBA_EXT;   *attr++ = GL_TRUE;
 884     }
 885     else {
 886     *attr++ = GLX_BIND_TO_TEXTURE_RGB_EXT;    *attr++ = GL_TRUE;
 887     }
 888     *attr++ = GL_NONE;
 889
 890     fbconfig = glXChooseFBConfig(
 891         dpy,
 892         screen,
 893         fbconfig_attrs, &n_fbconfig_attrs
 894     );
 895     if (!fbconfig)
 896         goto error;
 897
 898     /* Initialize GLX Pixmap attributes */
 899     for (attr = pixmap_attrs; *attr != GL_NONE; attr += 2)
 900         ;
 901     *attr++ = GLX_TEXTURE_FORMAT_EXT;
 902     if (wattr.depth == 32)
 903     *attr++ = GLX_TEXTURE_FORMAT_RGBA_EXT;
 904     else
 905     *attr++ = GLX_TEXTURE_FORMAT_RGB_EXT;
 906     *attr++ = GL_NONE;
 907
 908     x11_trap_errors();
 909     pixo->glx_pixmap = glXCreatePixmap(dpy, fbconfig[0], pixo->pixmap, pixmap_attrs);
 910     free(fbconfig);
 911     if (x11_untrap_errors() != 0)
 912         goto error;
 913
 914     pixo->target = GL_TEXTURE_2D;
 915     glGenTextures(1, &pixo->texture);
 916     if (!gl_bind_texture(&pixo->old_texture, pixo->target, pixo->texture))
 917         goto error;
 918     glTexParameteri(pixo->target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 919     glTexParameteri(pixo->target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 920     gl_unbind_texture(&pixo->old_texture);
 921     return pixo;
 922
 923 error:
 924     gl_destroy_pixmap_object(pixo);
 925     return NULL;
 926 }
 927
 928 /**
 929  * gl_destroy_pixmap_object:
 930  * @pixo: a #GLPixmapObject
 931  *
 932  * Destroys the #GLPixmapObject object.
 933  */
 934 void
 935 gl_destroy_pixmap_object(GLPixmapObject *pixo)
 936 {
 937     if (!pixo)
 938         return;
 939
 940     gl_unbind_pixmap_object(pixo);
 941
 942     if (pixo->texture) {
 943         glDeleteTextures(1, &pixo->texture);
 944         pixo->texture = 0;
 945     }
 946
 947     if (pixo->glx_pixmap) {
 948         glXDestroyPixmap(pixo->dpy, pixo->glx_pixmap);
 949         pixo->glx_pixmap = None;
 950     }
 951
 952     if (pixo->pixmap) {
 953         XFreePixmap(pixo->dpy, pixo->pixmap);
 954         pixo->pixmap = None;
 955     }
 956     free(pixo);
 957 }
 958
 959 /**
 960  * gl_bind_pixmap_object:
 961  * @pixo: a #GLPixmapObject
 962  *
 963  * Defines a two-dimensional texture image. The texture image is taken
 964  * from the @pixo pixmap and need not be copied. The texture target,
 965  * format and size are derived from attributes of the @pixo pixmap.
 966  *
 967  * Return value: %TRUE on success
 968  */
 969 gboolean
 970 gl_bind_pixmap_object(GLPixmapObject *pixo)
 971 {
 972     GLVTable * const gl_vtable = gl_get_vtable();
 973
 974     if (pixo->is_bound)
 975         return TRUE;
 976
 977     if (!gl_bind_texture(&pixo->old_texture, pixo->target, pixo->texture))
 978         return FALSE;
 979
 980     x11_trap_errors();
 981     gl_vtable->glx_bind_tex_image(
 982         pixo->dpy,
 983         pixo->glx_pixmap,
 984         GLX_FRONT_LEFT_EXT,
 985         NULL
 986     );
 987     XSync(pixo->dpy, False);
 988     if (x11_untrap_errors() != 0) {
 989         GST_DEBUG("failed to bind pixmap");
 990         return FALSE;
 991     }
 992
 993     pixo->is_bound = TRUE;
 994     return TRUE;
 995 }
 996
 997 /**
 998  * gl_unbind_pixmap_object:
 999  * @pixo: a #GLPixmapObject
1000  *
1001  * Releases a color buffers that is being used as a texture.
1002  *
1003  * Return value: %TRUE on success
1004  */
1005 gboolean
1006 gl_unbind_pixmap_object(GLPixmapObject *pixo)
1007 {
1008     GLVTable * const gl_vtable = gl_get_vtable();
1009
1010     if (!pixo->is_bound)
1011         return TRUE;
1012
1013     x11_trap_errors();
1014     gl_vtable->glx_release_tex_image(
1015         pixo->dpy,
1016         pixo->glx_pixmap,
1017         GLX_FRONT_LEFT_EXT
1018     );
1019     XSync(pixo->dpy, False);
1020     if (x11_untrap_errors() != 0) {
1021         GST_DEBUG("failed to release pixmap");
1022         return FALSE;
1023     }
1024
1025     gl_unbind_texture(&pixo->old_texture);
1026
1027     pixo->is_bound = FALSE;
1028     return TRUE;
1029 }
1030
1031 /**
1032  * gl_create_framebuffer_object:
1033  * @target: the target to which the texture is bound
1034  * @texture: the GL texture to hold the framebuffer
1035  * @width: the requested width, in pixels
1036  * @height: the requested height, in pixels
1037  *
1038  * Creates an FBO with the specified texture and size.
1039  *
1040  * Return value: the newly created #GLFramebufferObject, or %NULL if
1041  *   an error occurred
1042  */
1043 GLFramebufferObject *
1044 gl_create_framebuffer_object(
1045     GLenum target,
1046     GLuint texture,
1047     guint  width,
1048     guint  height
1049 )
1050 {
1051     GLVTable * const gl_vtable = gl_get_vtable();
1052     GLFramebufferObject *fbo;
1053     GLenum status;
1054
1055     if (!gl_vtable || !gl_vtable->has_framebuffer_object)
1056         return NULL;
1057
1058     /* XXX: we only support GL_TEXTURE_2D at this time */
1059     if (target != GL_TEXTURE_2D)
1060         return NULL;
1061
1062     fbo = calloc(1, sizeof(*fbo));
1063     if (!fbo)
1064         return NULL;
1065
1066     fbo->width          = width;
1067     fbo->height         = height;
1068     fbo->fbo            = 0;
1069     fbo->old_fbo        = 0;
1070     fbo->is_bound       = FALSE;
1071
1072     gl_get_param(GL_FRAMEBUFFER_BINDING, &fbo->old_fbo);
1073     gl_vtable->gl_gen_framebuffers(1, &fbo->fbo);
1074     gl_vtable->gl_bind_framebuffer(GL_FRAMEBUFFER_EXT, fbo->fbo);
1075     gl_vtable->gl_framebuffer_texture_2d(
1076         GL_FRAMEBUFFER_EXT,
1077         GL_COLOR_ATTACHMENT0_EXT,
1078         target, texture,
1079         0
1080     );
1081
1082     status = gl_vtable->gl_check_framebuffer_status(GL_DRAW_FRAMEBUFFER_EXT);
1083     gl_vtable->gl_bind_framebuffer(GL_FRAMEBUFFER_EXT, fbo->old_fbo);
1084     if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
1085         goto error;
1086     return fbo;
1087
1088 error:
1089     gl_destroy_framebuffer_object(fbo);
1090     return NULL;
1091 }
1092
1093 /**
1094  * gl_destroy_framebuffer_object:
1095  * @fbo: a #GLFramebufferObject
1096  *
1097  * Destroys the @fbo object.
1098  */
1099 void
1100 gl_destroy_framebuffer_object(GLFramebufferObject *fbo)
1101 {
1102     GLVTable * const gl_vtable = gl_get_vtable();
1103
1104     if (!fbo)
1105         return;
1106
1107     gl_unbind_framebuffer_object(fbo);
1108
1109     if (fbo->fbo) {
1110         gl_vtable->gl_delete_framebuffers(1, &fbo->fbo);
1111         fbo->fbo = 0;
1112     }
1113     free(fbo);
1114 }
1115
1116 /**
1117  * gl_bind_framebuffer_object:
1118  * @fbo: a #GLFramebufferObject
1119  *
1120  * Binds @fbo object.
1121  *
1122  * Return value: %TRUE on success
1123  */
1124 gboolean
1125 gl_bind_framebuffer_object(GLFramebufferObject *fbo)
1126 {
1127     GLVTable * const gl_vtable = gl_get_vtable();
1128     const guint width  = fbo->width;
1129     const guint height = fbo->height;
1130
1131     const guint attribs = (GL_VIEWPORT_BIT|
1132                            GL_CURRENT_BIT|
1133                            GL_ENABLE_BIT|
1134                            GL_TEXTURE_BIT|
1135                            GL_COLOR_BUFFER_BIT);
1136
1137     if (fbo->is_bound)
1138         return TRUE;
1139
1140     gl_get_param(GL_FRAMEBUFFER_BINDING, &fbo->old_fbo);
1141     gl_vtable->gl_bind_framebuffer(GL_FRAMEBUFFER_EXT, fbo->fbo);
1142     glPushAttrib(attribs);
1143     glMatrixMode(GL_PROJECTION);
1144     glPushMatrix();
1145     glLoadIdentity();
1146     glMatrixMode(GL_MODELVIEW);
1147     glPushMatrix();
1148     glLoadIdentity();
1149     glViewport(0, 0, width, height);
1150     glTranslatef(-1.0f, -1.0f, 0.0f);
1151     glScalef(2.0f / width, 2.0f / height, 1.0f);
1152
1153     fbo->is_bound = TRUE;
1154     return TRUE;
1155 }
1156
1157 /**
1158  * gl_unbind_framebuffer_object:
1159  * @fbo: a #GLFramebufferObject
1160  *
1161  * Releases @fbo object.
1162  *
1163  * Return value: %TRUE on success
1164  */
1165 gboolean
1166 gl_unbind_framebuffer_object(GLFramebufferObject *fbo)
1167 {
1168     GLVTable * const gl_vtable = gl_get_vtable();
1169
1170     if (!fbo->is_bound)
1171         return TRUE;
1172
1173     glPopAttrib();
1174     glMatrixMode(GL_PROJECTION);
1175     glPopMatrix();
1176     glMatrixMode(GL_MODELVIEW);
1177     glPopMatrix();
1178     gl_vtable->gl_bind_framebuffer(GL_FRAMEBUFFER_EXT, fbo->old_fbo);
1179
1180     fbo->is_bound = FALSE;
1181     return TRUE;
1182 }