src/egl/drivers/glx/egl_glx.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * Copyright 2009-2010 Chia-I Wu <olvaffe@gmail.com>
   5  * Copyright 2010-2011 LunarG, Inc.
   6  * All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the
  10  * "Software"), to deal in the Software without restriction, including
  11  * without limitation the rights to use, copy, modify, merge, publish,
  12  * distribute, sub license, and/or sell copies of the Software, and to
  13  * permit persons to whom the Software is furnished to do so, subject to
  14  * the following conditions:
  15  *
  16  * The above copyright notice and this permission notice (including the
  17  * next paragraph) shall be included in all copies or substantial portions
  18  * of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  23  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  25  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  26  * DEALINGS IN THE SOFTWARE.
  27  *
  28  **************************************************************************/
  29
  30
  31 /**
  32  * This is an EGL driver that wraps GLX. This gives the benefit of being
  33  * completely agnostic of the direct rendering implementation.
  34  *
  35  * Authors: Alan Hourihane <alanh@tungstengraphics.com>
  36  */
  37
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <X11/Xlib.h>
  41 #include <dlfcn.h>
  42 #include "GL/glx.h"
  43
  44 #include "eglconfig.h"
  45 #include "eglcontext.h"
  46 #include "egldefines.h"
  47 #include "egldisplay.h"
  48 #include "egldriver.h"
  49 #include "eglcurrent.h"
  50 #include "egllog.h"
  51 #include "eglsurface.h"
  52
  53 #define CALLOC_STRUCT(T)   (struct T *) calloc(1, sizeof(struct T))
  54
  55 #ifndef GLX_VERSION_1_4
  56 #error "GL/glx.h must be equal to or greater than GLX 1.4"
  57 #endif
  58
  59 /* GLX 1.0 */
  60 typedef GLXContext (*GLXCREATECONTEXTPROC)( Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct );
  61 typedef void (*GLXDESTROYCONTEXTPROC)( Display *dpy, GLXContext ctx );
  62 typedef Bool (*GLXMAKECURRENTPROC)( Display *dpy, GLXDrawable drawable, GLXContext ctx);
  63 typedef void (*GLXSWAPBUFFERSPROC)( Display *dpy, GLXDrawable drawable );
  64 typedef GLXPixmap (*GLXCREATEGLXPIXMAPPROC)( Display *dpy, XVisualInfo *visual, Pixmap pixmap );
  65 typedef void (*GLXDESTROYGLXPIXMAPPROC)( Display *dpy, GLXPixmap pixmap );
  66 typedef Bool (*GLXQUERYVERSIONPROC)( Display *dpy, int *maj, int *min );
  67 typedef int (*GLXGETCONFIGPROC)( Display *dpy, XVisualInfo *visual, int attrib, int *value );
  68 typedef void (*GLXWAITGLPROC)( void );
  69 typedef void (*GLXWAITXPROC)( void );
  70
  71 /* GLX 1.1 */
  72 typedef const char *(*GLXQUERYEXTENSIONSSTRINGPROC)( Display *dpy, int screen );
  73 typedef const char *(*GLXQUERYSERVERSTRINGPROC)( Display *dpy, int screen, int name );
  74 typedef const char *(*GLXGETCLIENTSTRINGPROC)( Display *dpy, int name );
  75
  76 /** subclass of _EGLDriver */
  77 struct GLX_egl_driver
  78 {
  79    _EGLDriver Base;   /**< base class */
  80
  81    void *handle;
  82
  83    /* GLX 1.0 */
  84    GLXCREATECONTEXTPROC glXCreateContext;
  85    GLXDESTROYCONTEXTPROC glXDestroyContext;
  86    GLXMAKECURRENTPROC glXMakeCurrent;
  87    GLXSWAPBUFFERSPROC glXSwapBuffers;
  88    GLXCREATEGLXPIXMAPPROC glXCreateGLXPixmap;
  89    GLXDESTROYGLXPIXMAPPROC glXDestroyGLXPixmap;
  90    GLXQUERYVERSIONPROC glXQueryVersion;
  91    GLXGETCONFIGPROC glXGetConfig;
  92    GLXWAITGLPROC glXWaitGL;
  93    GLXWAITXPROC glXWaitX;
  94
  95    /* GLX 1.1 */
  96    GLXQUERYEXTENSIONSSTRINGPROC glXQueryExtensionsString;
  97    GLXQUERYSERVERSTRINGPROC glXQueryServerString;
  98    GLXGETCLIENTSTRINGPROC glXGetClientString;
  99
 100    /* GLX 1.3 or (GLX_SGI_make_current_read and GLX_SGIX_fbconfig) */
 101    PFNGLXGETFBCONFIGSPROC glXGetFBConfigs;
 102    PFNGLXGETFBCONFIGATTRIBPROC glXGetFBConfigAttrib;
 103    PFNGLXGETVISUALFROMFBCONFIGPROC glXGetVisualFromFBConfig;
 104    PFNGLXCREATEWINDOWPROC glXCreateWindow;
 105    PFNGLXDESTROYWINDOWPROC glXDestroyWindow;
 106    PFNGLXCREATEPIXMAPPROC glXCreatePixmap;
 107    PFNGLXDESTROYPIXMAPPROC glXDestroyPixmap;
 108    PFNGLXCREATEPBUFFERPROC glXCreatePbuffer;
 109    PFNGLXDESTROYPBUFFERPROC glXDestroyPbuffer;
 110    PFNGLXCREATENEWCONTEXTPROC glXCreateNewContext;
 111    PFNGLXMAKECONTEXTCURRENTPROC glXMakeContextCurrent;
 112
 113    /* GLX 1.4 or GLX_ARB_get_proc_address */
 114    PFNGLXGETPROCADDRESSPROC glXGetProcAddress;
 115
 116    /* GLX_SGIX_pbuffer */
 117    PFNGLXCREATEGLXPBUFFERSGIXPROC glXCreateGLXPbufferSGIX;
 118    PFNGLXDESTROYGLXPBUFFERSGIXPROC glXDestroyGLXPbufferSGIX;
 119 };
 120
 121
 122 /** driver data of _EGLDisplay */
 123 struct GLX_egl_display
 124 {
 125    Display *dpy;
 126    XVisualInfo *visuals;
 127    GLXFBConfig *fbconfigs;
 128
 129    int glx_maj, glx_min;
 130
 131    const char *extensions;
 132    EGLBoolean have_1_3;
 133    EGLBoolean have_make_current_read;
 134    EGLBoolean have_fbconfig;
 135    EGLBoolean have_pbuffer;
 136
 137    /* workaround quirks of different GLX implementations */
 138    EGLBoolean single_buffered_quirk;
 139    EGLBoolean glx_window_quirk;
 140 };
 141
 142
 143 /** subclass of _EGLContext */
 144 struct GLX_egl_context
 145 {
 146    _EGLContext Base;   /**< base class */
 147
 148    GLXContext context;
 149 };
 150
 151
 152 /** subclass of _EGLSurface */
 153 struct GLX_egl_surface
 154 {
 155    _EGLSurface Base;   /**< base class */
 156
 157    Drawable drawable;
 158    GLXDrawable glx_drawable;
 159
 160    void (*destroy)(Display *, GLXDrawable);
 161 };
 162
 163
 164 /** subclass of _EGLConfig */
 165 struct GLX_egl_config
 166 {
 167    _EGLConfig Base;   /**< base class */
 168    EGLBoolean double_buffered;
 169    int index;
 170 };
 171
 172 /* standard typecasts */
 173 _EGL_DRIVER_STANDARD_TYPECASTS(GLX_egl)
 174
 175 static int
 176 GLX_egl_config_index(_EGLConfig *conf)
 177 {
 178    struct GLX_egl_config *GLX_conf = GLX_egl_config(conf);
 179    return GLX_conf->index;
 180 }
 181
 182
 183 static const struct {
 184    int attr;
 185    int egl_attr;
 186 } fbconfig_attributes[] = {
 187    /* table 3.1 of GLX 1.4 */
 188    { GLX_FBCONFIG_ID,                  0 },
 189    { GLX_BUFFER_SIZE,                  EGL_BUFFER_SIZE },
 190    { GLX_LEVEL,                        EGL_LEVEL },
 191    { GLX_DOUBLEBUFFER,                 0 },
 192    { GLX_STEREO,                       0 },
 193    { GLX_AUX_BUFFERS,                  0 },
 194    { GLX_RED_SIZE,                     EGL_RED_SIZE },
 195    { GLX_GREEN_SIZE,                   EGL_GREEN_SIZE },
 196    { GLX_BLUE_SIZE,                    EGL_BLUE_SIZE },
 197    { GLX_ALPHA_SIZE,                   EGL_ALPHA_SIZE },
 198    { GLX_DEPTH_SIZE,                   EGL_DEPTH_SIZE },
 199    { GLX_STENCIL_SIZE,                 EGL_STENCIL_SIZE },
 200    { GLX_ACCUM_RED_SIZE,               0 },
 201    { GLX_ACCUM_GREEN_SIZE,             0 },
 202    { GLX_ACCUM_BLUE_SIZE,              0 },
 203    { GLX_ACCUM_ALPHA_SIZE,             0 },
 204    { GLX_SAMPLE_BUFFERS,               EGL_SAMPLE_BUFFERS },
 205    { GLX_SAMPLES,                      EGL_SAMPLES },
 206    { GLX_RENDER_TYPE,                  0 },
 207    { GLX_DRAWABLE_TYPE,                EGL_SURFACE_TYPE },
 208    { GLX_X_RENDERABLE,                 EGL_NATIVE_RENDERABLE },
 209    { GLX_X_VISUAL_TYPE,                EGL_NATIVE_VISUAL_TYPE },
 210    { GLX_CONFIG_CAVEAT,                EGL_CONFIG_CAVEAT },
 211    { GLX_TRANSPARENT_TYPE,             EGL_TRANSPARENT_TYPE },
 212    { GLX_TRANSPARENT_INDEX_VALUE,      0 },
 213    { GLX_TRANSPARENT_RED_VALUE,        EGL_TRANSPARENT_RED_VALUE },
 214    { GLX_TRANSPARENT_GREEN_VALUE,      EGL_TRANSPARENT_GREEN_VALUE },
 215    { GLX_TRANSPARENT_BLUE_VALUE,       EGL_TRANSPARENT_BLUE_VALUE },
 216    { GLX_MAX_PBUFFER_WIDTH,            EGL_MAX_PBUFFER_WIDTH },
 217    { GLX_MAX_PBUFFER_HEIGHT,           EGL_MAX_PBUFFER_HEIGHT },
 218    { GLX_MAX_PBUFFER_PIXELS,           EGL_MAX_PBUFFER_PIXELS },
 219    { GLX_VISUAL_ID,                    EGL_NATIVE_VISUAL_ID }
 220 };
 221
 222
 223 static EGLBoolean
 224 convert_fbconfig(struct GLX_egl_driver *GLX_drv,
 225                  struct GLX_egl_display *GLX_dpy, GLXFBConfig fbconfig,
 226                  struct GLX_egl_config *GLX_conf)
 227 {
 228    Display *dpy = GLX_dpy->dpy;
 229    int err, attr, val;
 230    unsigned i;
 231
 232    /* must have rgba bit */
 233    err = GLX_drv->glXGetFBConfigAttrib(dpy, fbconfig, GLX_RENDER_TYPE, &val);
 234    if (err || !(val & GLX_RGBA_BIT))
 235       return EGL_FALSE;
 236
 237    /* must know whether it is double-buffered */
 238    err = GLX_drv->glXGetFBConfigAttrib(dpy, fbconfig, GLX_DOUBLEBUFFER, &val);
 239    if (err)
 240       return EGL_FALSE;
 241    GLX_conf->double_buffered = val;
 242
 243    GLX_conf->Base.RenderableType = EGL_OPENGL_BIT;
 244    GLX_conf->Base.Conformant = EGL_OPENGL_BIT;
 245
 246    for (i = 0; i < ARRAY_SIZE(fbconfig_attributes); i++) {
 247       EGLint egl_attr, egl_val;
 248
 249       attr = fbconfig_attributes[i].attr;
 250       egl_attr = fbconfig_attributes[i].egl_attr;
 251       if (!egl_attr)
 252          continue;
 253
 254       err = GLX_drv->glXGetFBConfigAttrib(dpy, fbconfig, attr, &val);
 255       if (err) {
 256          if (err == GLX_BAD_ATTRIBUTE) {
 257             err = 0;
 258             continue;
 259          }
 260          break;
 261       }
 262
 263       switch (egl_attr) {
 264       case EGL_SURFACE_TYPE:
 265          egl_val = 0;
 266          if (val & GLX_WINDOW_BIT)
 267             egl_val |= EGL_WINDOW_BIT;
 268          /* pixmap and pbuffer surfaces must be single-buffered in EGL */
 269          if (!GLX_conf->double_buffered) {
 270             if (val & GLX_PIXMAP_BIT)
 271                egl_val |= EGL_PIXMAP_BIT;
 272             if (val & GLX_PBUFFER_BIT)
 273                egl_val |= EGL_PBUFFER_BIT;
 274          }
 275          break;
 276       case EGL_NATIVE_VISUAL_TYPE:
 277          switch (val) {
 278          case GLX_TRUE_COLOR:
 279             egl_val = TrueColor;
 280             break;
 281          case GLX_DIRECT_COLOR:
 282             egl_val = DirectColor;
 283             break;
 284          case GLX_PSEUDO_COLOR:
 285             egl_val = PseudoColor;
 286             break;
 287          case GLX_STATIC_COLOR:
 288             egl_val = StaticColor;
 289             break;
 290          case GLX_GRAY_SCALE:
 291             egl_val = GrayScale;
 292             break;
 293          case GLX_STATIC_GRAY:
 294             egl_val = StaticGray;
 295             break;
 296          default:
 297             egl_val = EGL_NONE;
 298             break;
 299          }
 300          break;
 301       case EGL_CONFIG_CAVEAT:
 302          egl_val = EGL_NONE;
 303          if (val == GLX_SLOW_CONFIG) {
 304             egl_val = EGL_SLOW_CONFIG;
 305          }
 306          else if (val == GLX_NON_CONFORMANT_CONFIG) {
 307             GLX_conf->Base.Conformant &= ~EGL_OPENGL_BIT;
 308             egl_val = EGL_NONE;
 309          }
 310          break;
 311       case EGL_TRANSPARENT_TYPE:
 312          egl_val = (val == GLX_TRANSPARENT_RGB) ?
 313             EGL_TRANSPARENT_RGB : EGL_NONE;
 314          break;
 315       default:
 316          egl_val = val;
 317          break;
 318       }
 319
 320       _eglSetConfigKey(&GLX_conf->Base, egl_attr, egl_val);
 321    }
 322    if (err)
 323       return EGL_FALSE;
 324
 325    if (!GLX_conf->Base.SurfaceType)
 326       return EGL_FALSE;
 327
 328    return EGL_TRUE;
 329 }
 330
 331 static const struct {
 332    int attr;
 333    int egl_attr;
 334 } visual_attributes[] = {
 335    /* table 3.7 of GLX 1.4 */
 336    { GLX_USE_GL,              0 },
 337    { GLX_BUFFER_SIZE,         EGL_BUFFER_SIZE },
 338    { GLX_LEVEL,               EGL_LEVEL },
 339    { GLX_RGBA,                0 },
 340    { GLX_DOUBLEBUFFER,        0 },
 341    { GLX_STEREO,              0 },
 342    { GLX_AUX_BUFFERS,         0 },
 343    { GLX_RED_SIZE,            EGL_RED_SIZE },
 344    { GLX_GREEN_SIZE,          EGL_GREEN_SIZE },
 345    { GLX_BLUE_SIZE,           EGL_BLUE_SIZE },
 346    { GLX_ALPHA_SIZE,          EGL_ALPHA_SIZE },
 347    { GLX_DEPTH_SIZE,          EGL_DEPTH_SIZE },
 348    { GLX_STENCIL_SIZE,        EGL_STENCIL_SIZE },
 349    { GLX_ACCUM_RED_SIZE,      0 },
 350    { GLX_ACCUM_GREEN_SIZE,    0 },
 351    { GLX_ACCUM_BLUE_SIZE,     0 },
 352    { GLX_ACCUM_ALPHA_SIZE,    0 },
 353    { GLX_SAMPLE_BUFFERS,      EGL_SAMPLE_BUFFERS },
 354    { GLX_SAMPLES,             EGL_SAMPLES },
 355    { GLX_FBCONFIG_ID,         0 },
 356    /* GLX_EXT_visual_rating */
 357    { GLX_VISUAL_CAVEAT_EXT,   EGL_CONFIG_CAVEAT }
 358 };
 359
 360 static EGLBoolean
 361 convert_visual(struct GLX_egl_driver *GLX_drv,
 362                struct GLX_egl_display *GLX_dpy, XVisualInfo *vinfo,
 363                struct GLX_egl_config *GLX_conf)
 364 {
 365    Display *dpy = GLX_dpy->dpy;
 366    int err, attr, val;
 367    unsigned i;
 368
 369    /* the visual must support OpenGL and RGBA buffer */
 370    err = GLX_drv->glXGetConfig(dpy, vinfo, GLX_USE_GL, &val);
 371    if (!err && val)
 372       err = GLX_drv->glXGetConfig(dpy, vinfo, GLX_RGBA, &val);
 373    if (err || !val)
 374       return EGL_FALSE;
 375
 376    /* must know whether it is double-buffered */
 377    err = GLX_drv->glXGetConfig(dpy, vinfo, GLX_DOUBLEBUFFER, &val);
 378    if (err)
 379       return EGL_FALSE;
 380    GLX_conf->double_buffered = val;
 381
 382    GLX_conf->Base.RenderableType = EGL_OPENGL_BIT;
 383    GLX_conf->Base.Conformant = EGL_OPENGL_BIT;
 384    GLX_conf->Base.SurfaceType = EGL_WINDOW_BIT;
 385    /* pixmap surfaces must be single-buffered in EGL */
 386    if (!GLX_conf->double_buffered)
 387       GLX_conf->Base.SurfaceType |= EGL_PIXMAP_BIT;
 388
 389    GLX_conf->Base.NativeVisualID = vinfo->visualid;
 390    GLX_conf->Base.NativeVisualType = vinfo->class;
 391    GLX_conf->Base.NativeRenderable = EGL_TRUE;
 392
 393    for (i = 0; i < ARRAY_SIZE(visual_attributes); i++) {
 394       EGLint egl_attr, egl_val;
 395
 396       attr = visual_attributes[i].attr;
 397       egl_attr = visual_attributes[i].egl_attr;
 398       if (!egl_attr)
 399          continue;
 400
 401       err = GLX_drv->glXGetConfig(dpy, vinfo, attr, &val);
 402       if (err) {
 403          if (err == GLX_BAD_ATTRIBUTE) {
 404             err = 0;
 405             continue;
 406          }
 407          break;
 408       }
 409
 410       switch (egl_attr) {
 411       case EGL_CONFIG_CAVEAT:
 412          egl_val = EGL_NONE;
 413          if (val == GLX_SLOW_VISUAL_EXT) {
 414             egl_val = EGL_SLOW_CONFIG;
 415          }
 416          else if (val == GLX_NON_CONFORMANT_VISUAL_EXT) {
 417             GLX_conf->Base.Conformant &= ~EGL_OPENGL_BIT;
 418             egl_val = EGL_NONE;
 419          }
 420          break;
 421          break;
 422       default:
 423          egl_val = val;
 424          break;
 425       }
 426       _eglSetConfigKey(&GLX_conf->Base, egl_attr, egl_val);
 427    }
 428
 429    return (err) ? EGL_FALSE : EGL_TRUE;
 430 }
 431
 432
 433 static void
 434 fix_config(struct GLX_egl_display *GLX_dpy, struct GLX_egl_config *GLX_conf)
 435 {
 436    _EGLConfig *conf = &GLX_conf->Base;
 437
 438    if (!GLX_conf->double_buffered && GLX_dpy->single_buffered_quirk) {
 439       /* some GLX impls do not like single-buffered window surface */
 440       conf->SurfaceType &= ~EGL_WINDOW_BIT;
 441       /* pbuffer bit is usually not set */
 442       if (GLX_dpy->have_pbuffer)
 443          conf->SurfaceType |= EGL_PBUFFER_BIT;
 444    }
 445
 446    /* no visual attribs unless window bit is set */
 447    if (!(conf->SurfaceType & EGL_WINDOW_BIT)) {
 448       conf->NativeVisualID = 0;
 449       conf->NativeVisualType = EGL_NONE;
 450    }
 451
 452    if (conf->TransparentType != EGL_TRANSPARENT_RGB) {
 453       /* some impls set them to -1 (GLX_DONT_CARE) */
 454       conf->TransparentRedValue = 0;
 455       conf->TransparentGreenValue = 0;
 456       conf->TransparentBlueValue = 0;
 457    }
 458
 459    /* make sure buffer size is set correctly */
 460    conf->BufferSize =
 461       conf->RedSize + conf->GreenSize + conf->BlueSize + conf->AlphaSize;
 462 }
 463
 464
 465 static EGLBoolean
 466 create_configs(_EGLDriver *drv, _EGLDisplay *dpy, EGLint screen)
 467 {
 468    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
 469    struct GLX_egl_display *GLX_dpy = GLX_egl_display(dpy);
 470    EGLint num_configs = 0, i;
 471    EGLint id = 1;
 472
 473    if (GLX_dpy->have_fbconfig) {
 474       GLX_dpy->fbconfigs =
 475          GLX_drv->glXGetFBConfigs(GLX_dpy->dpy, screen, &num_configs);
 476    }
 477    else {
 478       XVisualInfo vinfo_template;
 479       long mask;
 480
 481       vinfo_template.screen = screen;
 482       mask = VisualScreenMask;
 483       GLX_dpy->visuals = XGetVisualInfo(GLX_dpy->dpy, mask, &vinfo_template,
 484                                         &num_configs);
 485    }
 486
 487    if (!num_configs)
 488       return EGL_FALSE;
 489
 490    for (i = 0; i < num_configs; i++) {
 491       struct GLX_egl_config *GLX_conf, template;
 492       EGLBoolean ok;
 493
 494       memset(&template, 0, sizeof(template));
 495       _eglInitConfig(&template.Base, dpy, id);
 496       if (GLX_dpy->have_fbconfig) {
 497          ok = convert_fbconfig(GLX_drv, GLX_dpy,
 498                GLX_dpy->fbconfigs[i], &template);
 499       }
 500       else {
 501          ok = convert_visual(GLX_drv, GLX_dpy,
 502                &GLX_dpy->visuals[i], &template);
 503       }
 504       if (!ok)
 505         continue;
 506
 507       fix_config(GLX_dpy, &template);
 508       if (!_eglValidateConfig(&template.Base, EGL_FALSE)) {
 509          _eglLog(_EGL_DEBUG, "GLX: failed to validate config %d", i);
 510          continue;
 511       }
 512
 513       GLX_conf = CALLOC_STRUCT(GLX_egl_config);
 514       if (GLX_conf) {
 515          memcpy(GLX_conf, &template, sizeof(template));
 516          GLX_conf->index = i;
 517
 518          _eglLinkConfig(&GLX_conf->Base);
 519          id++;
 520       }
 521    }
 522
 523    return EGL_TRUE;
 524 }
 525
 526
 527 static void
 528 check_extensions(struct GLX_egl_driver *GLX_drv,
 529                  struct GLX_egl_display *GLX_dpy, EGLint screen)
 530 {
 531    GLX_dpy->extensions =
 532       GLX_drv->glXQueryExtensionsString(GLX_dpy->dpy, screen);
 533    if (GLX_dpy->extensions) {
 534       if (strstr(GLX_dpy->extensions, "GLX_SGI_make_current_read")) {
 535          /* GLX 1.3 entry points are used */
 536          GLX_dpy->have_make_current_read = EGL_TRUE;
 537       }
 538
 539       if (strstr(GLX_dpy->extensions, "GLX_SGIX_fbconfig")) {
 540          /* GLX 1.3 entry points are used */
 541          GLX_dpy->have_fbconfig = EGL_TRUE;
 542       }
 543
 544       if (strstr(GLX_dpy->extensions, "GLX_SGIX_pbuffer")) {
 545          if (GLX_drv->glXCreateGLXPbufferSGIX &&
 546              GLX_drv->glXDestroyGLXPbufferSGIX &&
 547              GLX_dpy->have_fbconfig)
 548             GLX_dpy->have_pbuffer = EGL_TRUE;
 549       }
 550    }
 551
 552    if (GLX_dpy->glx_maj == 1 && GLX_dpy->glx_min >= 3) {
 553       GLX_dpy->have_1_3 = EGL_TRUE;
 554       GLX_dpy->have_make_current_read = EGL_TRUE;
 555       GLX_dpy->have_fbconfig = EGL_TRUE;
 556       GLX_dpy->have_pbuffer = EGL_TRUE;
 557    }
 558 }
 559
 560
 561 static void
 562 check_quirks(struct GLX_egl_driver *GLX_drv,
 563              struct GLX_egl_display *GLX_dpy, EGLint screen)
 564 {
 565    const char *vendor;
 566
 567    GLX_dpy->single_buffered_quirk = EGL_TRUE;
 568    GLX_dpy->glx_window_quirk = EGL_TRUE;
 569
 570    vendor = GLX_drv->glXGetClientString(GLX_dpy->dpy, GLX_VENDOR);
 571    if (vendor && strstr(vendor, "NVIDIA")) {
 572       vendor = GLX_drv->glXQueryServerString(GLX_dpy->dpy, screen, GLX_VENDOR);
 573       if (vendor && strstr(vendor, "NVIDIA")) {
 574          _eglLog(_EGL_DEBUG, "disable quirks");
 575          GLX_dpy->single_buffered_quirk = EGL_FALSE;
 576          GLX_dpy->glx_window_quirk = EGL_FALSE;
 577       }
 578    }
 579 }
 580
 581
 582 /**
 583  * Called via eglInitialize(), GLX_drv->API.Initialize().
 584  */
 585 static EGLBoolean
 586 GLX_eglInitialize(_EGLDriver *drv, _EGLDisplay *disp)
 587 {
 588    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
 589    struct GLX_egl_display *GLX_dpy;
 590
 591    if (disp->Platform != _EGL_PLATFORM_X11)
 592       return EGL_FALSE;
 593
 594    /* this is a fallback driver */
 595    if (!disp->Options.UseFallback)
 596       return EGL_FALSE;
 597
 598    if (disp->Options.TestOnly)
 599       return EGL_TRUE;
 600
 601    GLX_dpy = CALLOC_STRUCT(GLX_egl_display);
 602    if (!GLX_dpy)
 603       return _eglError(EGL_BAD_ALLOC, "eglInitialize");
 604
 605    GLX_dpy->dpy = (Display *) disp->PlatformDisplay;
 606    if (!GLX_dpy->dpy) {
 607       GLX_dpy->dpy = XOpenDisplay(NULL);
 608       if (!GLX_dpy->dpy) {
 609          _eglLog(_EGL_WARNING, "GLX: XOpenDisplay failed");
 610          free(GLX_dpy);
 611          return EGL_FALSE;
 612       }
 613    }
 614
 615    if (!GLX_drv->glXQueryVersion(GLX_dpy->dpy,
 616             &GLX_dpy->glx_maj, &GLX_dpy->glx_min)) {
 617       _eglLog(_EGL_WARNING, "GLX: glXQueryVersion failed");
 618       if (!disp->PlatformDisplay)
 619          XCloseDisplay(GLX_dpy->dpy);
 620       free(GLX_dpy);
 621       return EGL_FALSE;
 622    }
 623
 624    disp->DriverData = (void *) GLX_dpy;
 625    disp->ClientAPIs = EGL_OPENGL_BIT;
 626
 627    check_extensions(GLX_drv, GLX_dpy, DefaultScreen(GLX_dpy->dpy));
 628    check_quirks(GLX_drv, GLX_dpy, DefaultScreen(GLX_dpy->dpy));
 629
 630    create_configs(drv, disp, DefaultScreen(GLX_dpy->dpy));
 631    if (!_eglGetArraySize(disp->Configs)) {
 632       _eglLog(_EGL_WARNING, "GLX: failed to create any config");
 633       if (!disp->PlatformDisplay)
 634          XCloseDisplay(GLX_dpy->dpy);
 635       free(GLX_dpy);
 636       return EGL_FALSE;
 637    }
 638
 639    /* we're supporting EGL 1.4 */
 640    disp->VersionMajor = 1;
 641    disp->VersionMinor = 4;
 642
 643    return EGL_TRUE;
 644 }
 645
 646
 647 /**
 648  * Called via eglTerminate(), drv->API.Terminate().
 649  */
 650 static EGLBoolean
 651 GLX_eglTerminate(_EGLDriver *drv, _EGLDisplay *disp)
 652 {
 653    struct GLX_egl_display *GLX_dpy = GLX_egl_display(disp);
 654
 655    _eglReleaseDisplayResources(drv, disp);
 656    _eglCleanupDisplay(disp);
 657
 658    if (GLX_dpy->visuals)
 659       XFree(GLX_dpy->visuals);
 660    if (GLX_dpy->fbconfigs)
 661       XFree(GLX_dpy->fbconfigs);
 662
 663    if (!disp->PlatformDisplay)
 664       XCloseDisplay(GLX_dpy->dpy);
 665    free(GLX_dpy);
 666
 667    disp->DriverData = NULL;
 668
 669    return EGL_TRUE;
 670 }
 671
 672
 673 /**
 674  * Called via eglCreateContext(), drv->API.CreateContext().
 675  */
 676 static _EGLContext *
 677 GLX_eglCreateContext(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
 678                       _EGLContext *share_list, const EGLint *attrib_list)
 679 {
 680    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
 681    struct GLX_egl_context *GLX_ctx = CALLOC_STRUCT(GLX_egl_context);
 682    struct GLX_egl_display *GLX_dpy = GLX_egl_display(disp);
 683    struct GLX_egl_context *GLX_ctx_shared = GLX_egl_context(share_list);
 684
 685    if (!GLX_ctx) {
 686       _eglError(EGL_BAD_ALLOC, "eglCreateContext");
 687       return NULL;
 688    }
 689
 690    if (!_eglInitContext(&GLX_ctx->Base, disp, conf, attrib_list)) {
 691       free(GLX_ctx);
 692       return NULL;
 693    }
 694
 695    if (GLX_dpy->have_fbconfig) {
 696       GLX_ctx->context = GLX_drv->glXCreateNewContext(GLX_dpy->dpy,
 697             GLX_dpy->fbconfigs[GLX_egl_config_index(conf)],
 698             GLX_RGBA_TYPE,
 699             GLX_ctx_shared ? GLX_ctx_shared->context : NULL,
 700             GL_TRUE);
 701    }
 702    else {
 703       GLX_ctx->context = GLX_drv->glXCreateContext(GLX_dpy->dpy,
 704             &GLX_dpy->visuals[GLX_egl_config_index(conf)],
 705             GLX_ctx_shared ? GLX_ctx_shared->context : NULL,
 706             GL_TRUE);
 707    }
 708    if (!GLX_ctx->context) {
 709       free(GLX_ctx);
 710       return NULL;
 711    }
 712
 713    return &GLX_ctx->Base;
 714 }
 715
 716 /**
 717  * Called via eglDestroyContext(), drv->API.DestroyContext().
 718  */
 719 static EGLBoolean
 720 GLX_eglDestroyContext(_EGLDriver *drv, _EGLDisplay *disp, _EGLContext *ctx)
 721 {
 722    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
 723    struct GLX_egl_display *GLX_dpy = GLX_egl_display(disp);
 724    struct GLX_egl_context *GLX_ctx = GLX_egl_context(ctx);
 725
 726    if (_eglPutContext(ctx)) {
 727       assert(GLX_ctx);
 728       GLX_drv->glXDestroyContext(GLX_dpy->dpy, GLX_ctx->context);
 729
 730       free(GLX_ctx);
 731    }
 732
 733    return EGL_TRUE;
 734 }
 735
 736 /**
 737  * Destroy a surface.  The display is allowed to be uninitialized.
 738  */
 739 static void
 740 destroy_surface(_EGLDisplay *disp, _EGLSurface *surf)
 741 {
 742    struct GLX_egl_display *GLX_dpy = GLX_egl_display(disp);
 743    struct GLX_egl_surface *GLX_surf = GLX_egl_surface(surf);
 744
 745    if (GLX_surf->destroy)
 746       GLX_surf->destroy(GLX_dpy->dpy, GLX_surf->glx_drawable);
 747
 748    free(GLX_surf);
 749 }
 750
 751
 752 /**
 753  * Called via eglMakeCurrent(), drv->API.MakeCurrent().
 754  */
 755 static EGLBoolean
 756 GLX_eglMakeCurrent(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf,
 757                    _EGLSurface *rsurf, _EGLContext *ctx)
 758 {
 759    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
 760    struct GLX_egl_display *GLX_dpy = GLX_egl_display(disp);
 761    struct GLX_egl_surface *GLX_dsurf = GLX_egl_surface(dsurf);
 762    struct GLX_egl_surface *GLX_rsurf = GLX_egl_surface(rsurf);
 763    struct GLX_egl_context *GLX_ctx = GLX_egl_context(ctx);
 764    _EGLContext *old_ctx;
 765    _EGLSurface *old_dsurf, *old_rsurf;
 766    GLXDrawable ddraw, rdraw;
 767    GLXContext cctx;
 768    EGLBoolean ret = EGL_FALSE;
 769
 770    /* make new bindings */
 771    if (!_eglBindContext(ctx, dsurf, rsurf, &old_ctx, &old_dsurf, &old_rsurf))
 772       return EGL_FALSE;
 773
 774    ddraw = (GLX_dsurf) ? GLX_dsurf->glx_drawable : None;
 775    rdraw = (GLX_rsurf) ? GLX_rsurf->glx_drawable : None;
 776    cctx = (GLX_ctx) ? GLX_ctx->context : NULL;
 777
 778    if (GLX_dpy->have_make_current_read)
 779       ret = GLX_drv->glXMakeContextCurrent(GLX_dpy->dpy, ddraw, rdraw, cctx);
 780    else if (ddraw == rdraw)
 781       ret = GLX_drv->glXMakeCurrent(GLX_dpy->dpy, ddraw, cctx);
 782
 783    if (ret) {
 784       if (_eglPutSurface(old_dsurf))
 785          destroy_surface(disp, old_dsurf);
 786       if (_eglPutSurface(old_rsurf))
 787          destroy_surface(disp, old_rsurf);
 788       /* no destroy? */
 789       _eglPutContext(old_ctx);
 790    }
 791    else {
 792       /* undo the previous _eglBindContext */
 793       _eglBindContext(old_ctx, old_dsurf, old_rsurf, &ctx, &dsurf, &rsurf);
 794       assert(&GLX_ctx->Base == ctx &&
 795              &GLX_dsurf->Base == dsurf &&
 796              &GLX_rsurf->Base == rsurf);
 797
 798       _eglPutSurface(dsurf);
 799       _eglPutSurface(rsurf);
 800       _eglPutContext(ctx);
 801
 802       _eglPutSurface(old_dsurf);
 803       _eglPutSurface(old_rsurf);
 804       _eglPutContext(old_ctx);
 805    }
 806
 807    return ret;
 808 }
 809
 810 /** Get size of given window */
 811 static Status
 812 get_drawable_size(Display *dpy, Drawable d, unsigned *width, unsigned *height)
 813 {
 814    Window root;
 815    Status stat;
 816    int xpos, ypos;
 817    unsigned int w, h, bw, depth;
 818    stat = XGetGeometry(dpy, d, &root, &xpos, &ypos, &w, &h, &bw, &depth);
 819    *width = w;
 820    *height = h;
 821    return stat;
 822 }
 823
 824 /**
 825  * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
 826  */
 827 static _EGLSurface *
 828 GLX_eglCreateWindowSurface(_EGLDriver *drv, _EGLDisplay *disp,
 829                            _EGLConfig *conf, EGLNativeWindowType window,
 830                            const EGLint *attrib_list)
 831 {
 832    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
 833    struct GLX_egl_display *GLX_dpy = GLX_egl_display(disp);
 834    struct GLX_egl_surface *GLX_surf;
 835    unsigned width, height;
 836
 837    GLX_surf = CALLOC_STRUCT(GLX_egl_surface);
 838    if (!GLX_surf) {
 839       _eglError(EGL_BAD_ALLOC, "eglCreateWindowSurface");
 840       return NULL;
 841    }
 842
 843    if (!_eglInitSurface(&GLX_surf->Base, disp, EGL_WINDOW_BIT,
 844                         conf, attrib_list)) {
 845       free(GLX_surf);
 846       return NULL;
 847    }
 848
 849    GLX_surf->drawable = window;
 850
 851    if (GLX_dpy->have_1_3 && !GLX_dpy->glx_window_quirk) {
 852       GLX_surf->glx_drawable = GLX_drv->glXCreateWindow(GLX_dpy->dpy,
 853             GLX_dpy->fbconfigs[GLX_egl_config_index(conf)],
 854             GLX_surf->drawable, NULL);
 855    }
 856    else {
 857       GLX_surf->glx_drawable = GLX_surf->drawable;
 858    }
 859
 860    if (!GLX_surf->glx_drawable) {
 861       free(GLX_surf);
 862       return NULL;
 863    }
 864
 865    if (GLX_dpy->have_1_3 && !GLX_dpy->glx_window_quirk)
 866       GLX_surf->destroy = GLX_drv->glXDestroyWindow;
 867
 868    get_drawable_size(GLX_dpy->dpy, window, &width, &height);
 869    GLX_surf->Base.Width = width;
 870    GLX_surf->Base.Height = height;
 871
 872    return &GLX_surf->Base;
 873 }
 874
 875 static _EGLSurface *
 876 GLX_eglCreatePixmapSurface(_EGLDriver *drv, _EGLDisplay *disp,
 877                            _EGLConfig *conf, EGLNativePixmapType pixmap,
 878                            const EGLint *attrib_list)
 879 {
 880    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
 881    struct GLX_egl_display *GLX_dpy = GLX_egl_display(disp);
 882    struct GLX_egl_surface *GLX_surf;
 883    unsigned width, height;
 884
 885    GLX_surf = CALLOC_STRUCT(GLX_egl_surface);
 886    if (!GLX_surf) {
 887       _eglError(EGL_BAD_ALLOC, "eglCreatePixmapSurface");
 888       return NULL;
 889    }
 890
 891    if (!_eglInitSurface(&GLX_surf->Base, disp, EGL_PIXMAP_BIT,
 892                         conf, attrib_list)) {
 893       free(GLX_surf);
 894       return NULL;
 895    }
 896
 897    GLX_surf->drawable = pixmap;
 898
 899    if (GLX_dpy->have_1_3) {
 900       GLX_surf->glx_drawable = GLX_drv->glXCreatePixmap(GLX_dpy->dpy,
 901             GLX_dpy->fbconfigs[GLX_egl_config_index(conf)],
 902             GLX_surf->drawable, NULL);
 903    }
 904    else if (GLX_dpy->have_fbconfig) {
 905       GLXFBConfig fbconfig = GLX_dpy->fbconfigs[GLX_egl_config_index(conf)];
 906       XVisualInfo *vinfo;
 907
 908       vinfo = GLX_drv->glXGetVisualFromFBConfig(GLX_dpy->dpy, fbconfig);
 909       if (vinfo) {
 910          GLX_surf->glx_drawable = GLX_drv->glXCreateGLXPixmap(GLX_dpy->dpy,
 911                vinfo, GLX_surf->drawable);
 912          XFree(vinfo);
 913       }
 914    }
 915    else {
 916       GLX_surf->glx_drawable = GLX_drv->glXCreateGLXPixmap(GLX_dpy->dpy,
 917             &GLX_dpy->visuals[GLX_egl_config_index(conf)],
 918             GLX_surf->drawable);
 919    }
 920
 921    if (!GLX_surf->glx_drawable) {
 922       free(GLX_surf);
 923       return NULL;
 924    }
 925
 926    GLX_surf->destroy = (GLX_dpy->have_1_3) ?
 927       GLX_drv->glXDestroyPixmap : GLX_drv->glXDestroyGLXPixmap;
 928
 929    get_drawable_size(GLX_dpy->dpy, pixmap, &width, &height);
 930    GLX_surf->Base.Width = width;
 931    GLX_surf->Base.Height = height;
 932
 933    return &GLX_surf->Base;
 934 }
 935
 936 static _EGLSurface *
 937 GLX_eglCreatePbufferSurface(_EGLDriver *drv, _EGLDisplay *disp,
 938                             _EGLConfig *conf, const EGLint *attrib_list)
 939 {
 940    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
 941    struct GLX_egl_display *GLX_dpy = GLX_egl_display(disp);
 942    struct GLX_egl_surface *GLX_surf;
 943    int attribs[5];
 944    int i;
 945
 946    GLX_surf = CALLOC_STRUCT(GLX_egl_surface);
 947    if (!GLX_surf) {
 948       _eglError(EGL_BAD_ALLOC, "eglCreatePbufferSurface");
 949       return NULL;
 950    }
 951
 952    if (!_eglInitSurface(&GLX_surf->Base, disp, EGL_PBUFFER_BIT,
 953                         conf, attrib_list)) {
 954       free(GLX_surf);
 955       return NULL;
 956    }
 957
 958    i = 0;
 959    attribs[i] = None;
 960
 961    GLX_surf->drawable = None;
 962
 963    if (GLX_dpy->have_1_3) {
 964       /* put geometry in attribs */
 965       if (GLX_surf->Base.Width) {
 966          attribs[i++] = GLX_PBUFFER_WIDTH;
 967          attribs[i++] = GLX_surf->Base.Width;
 968       }
 969       if (GLX_surf->Base.Height) {
 970          attribs[i++] = GLX_PBUFFER_HEIGHT;
 971          attribs[i++] = GLX_surf->Base.Height;
 972       }
 973       attribs[i] = None;
 974
 975       GLX_surf->glx_drawable = GLX_drv->glXCreatePbuffer(GLX_dpy->dpy,
 976             GLX_dpy->fbconfigs[GLX_egl_config_index(conf)], attribs);
 977    }
 978    else if (GLX_dpy->have_pbuffer) {
 979       GLX_surf->glx_drawable = GLX_drv->glXCreateGLXPbufferSGIX(GLX_dpy->dpy,
 980             GLX_dpy->fbconfigs[GLX_egl_config_index(conf)],
 981             GLX_surf->Base.Width,
 982             GLX_surf->Base.Height,
 983             attribs);
 984    }
 985
 986    if (!GLX_surf->glx_drawable) {
 987       free(GLX_surf);
 988       return NULL;
 989    }
 990
 991    GLX_surf->destroy = (GLX_dpy->have_1_3) ?
 992       GLX_drv->glXDestroyPbuffer : GLX_drv->glXDestroyGLXPbufferSGIX;
 993
 994    return &GLX_surf->Base;
 995 }
 996
 997
 998 static EGLBoolean
 999 GLX_eglDestroySurface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
1000 {
1001    (void) drv;
1002
1003    if (_eglPutSurface(surf))
1004       destroy_surface(disp, surf);
1005
1006    return EGL_TRUE;
1007 }
1008
1009
1010 static EGLBoolean
1011 GLX_eglSwapBuffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
1012 {
1013    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
1014    struct GLX_egl_display *GLX_dpy = GLX_egl_display(disp);
1015    struct GLX_egl_surface *GLX_surf = GLX_egl_surface(draw);
1016
1017    GLX_drv->glXSwapBuffers(GLX_dpy->dpy, GLX_surf->glx_drawable);
1018
1019    return EGL_TRUE;
1020 }
1021
1022 /*
1023  * Called from eglGetProcAddress() via drv->API.GetProcAddress().
1024  */
1025 static _EGLProc
1026 GLX_eglGetProcAddress(_EGLDriver *drv, const char *procname)
1027 {
1028    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
1029
1030    return (_EGLProc) GLX_drv->glXGetProcAddress((const GLubyte *) procname);
1031 }
1032
1033 static EGLBoolean
1034 GLX_eglWaitClient(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx)
1035 {
1036    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
1037
1038    (void) dpy;
1039    (void) ctx;
1040
1041    GLX_drv->glXWaitGL();
1042    return EGL_TRUE;
1043 }
1044
1045 static EGLBoolean
1046 GLX_eglWaitNative(_EGLDriver *drv, _EGLDisplay *dpy, EGLint engine)
1047 {
1048    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
1049
1050    (void) dpy;
1051
1052    if (engine != EGL_CORE_NATIVE_ENGINE)
1053       return _eglError(EGL_BAD_PARAMETER, "eglWaitNative");
1054    GLX_drv->glXWaitX();
1055    return EGL_TRUE;
1056 }
1057
1058 static void
1059 GLX_Unload(_EGLDriver *drv)
1060 {
1061    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
1062
1063    if (GLX_drv->handle)
1064       dlclose(GLX_drv->handle);
1065    free(GLX_drv);
1066 }
1067
1068
1069 static EGLBoolean
1070 GLX_Load(_EGLDriver *drv)
1071 {
1072    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
1073    void *handle = NULL;
1074
1075    GLX_drv->glXGetProcAddress = dlsym(RTLD_DEFAULT, "glXGetProcAddress");
1076    if (!GLX_drv->glXGetProcAddress)
1077       GLX_drv->glXGetProcAddress = dlsym(RTLD_DEFAULT, "glXGetProcAddressARB");
1078    if (!GLX_drv->glXGetProcAddress) {
1079       handle = dlopen("libGL.so", RTLD_LAZY | RTLD_LOCAL);
1080       if (!handle)
1081          goto fail;
1082
1083       GLX_drv->glXGetProcAddress = dlsym(handle, "glXGetProcAddress");
1084       if (!GLX_drv->glXGetProcAddress)
1085          GLX_drv->glXGetProcAddress = dlsym(handle, "glXGetProcAddressARB");
1086       if (!GLX_drv->glXGetProcAddress)
1087          goto fail;
1088    }
1089
1090 #define GET_PROC(proc_type, proc_name, check)                        \
1091    do {                                                              \
1092       GLX_drv->proc_name = (proc_type)                               \
1093          GLX_drv->glXGetProcAddress((const GLubyte *) #proc_name);   \
1094       if (check && !GLX_drv->proc_name) goto fail;                   \
1095    } while (0)
1096
1097    /* GLX 1.0 */
1098    GET_PROC(GLXCREATECONTEXTPROC, glXCreateContext, EGL_TRUE);
1099    GET_PROC(GLXDESTROYCONTEXTPROC, glXDestroyContext, EGL_TRUE);
1100    GET_PROC(GLXMAKECURRENTPROC, glXMakeCurrent, EGL_TRUE);
1101    GET_PROC(GLXSWAPBUFFERSPROC, glXSwapBuffers, EGL_TRUE);
1102    GET_PROC(GLXCREATEGLXPIXMAPPROC, glXCreateGLXPixmap, EGL_TRUE);
1103    GET_PROC(GLXDESTROYGLXPIXMAPPROC, glXDestroyGLXPixmap, EGL_TRUE);
1104    GET_PROC(GLXQUERYVERSIONPROC, glXQueryVersion, EGL_TRUE);
1105    GET_PROC(GLXGETCONFIGPROC, glXGetConfig, EGL_TRUE);
1106    GET_PROC(GLXWAITGLPROC, glXWaitGL, EGL_TRUE);
1107    GET_PROC(GLXWAITXPROC, glXWaitX, EGL_TRUE);
1108
1109    /* GLX 1.1 */
1110    GET_PROC(GLXQUERYEXTENSIONSSTRINGPROC, glXQueryExtensionsString, EGL_TRUE);
1111    GET_PROC(GLXQUERYSERVERSTRINGPROC, glXQueryServerString, EGL_TRUE);
1112    GET_PROC(GLXGETCLIENTSTRINGPROC, glXGetClientString, EGL_TRUE);
1113
1114    /* GLX 1.3 */
1115    GET_PROC(PFNGLXGETFBCONFIGSPROC, glXGetFBConfigs, EGL_FALSE);
1116    GET_PROC(PFNGLXGETFBCONFIGATTRIBPROC, glXGetFBConfigAttrib, EGL_FALSE);
1117    GET_PROC(PFNGLXGETVISUALFROMFBCONFIGPROC, glXGetVisualFromFBConfig, EGL_FALSE);
1118    GET_PROC(PFNGLXCREATEWINDOWPROC, glXCreateWindow, EGL_FALSE);
1119    GET_PROC(PFNGLXDESTROYWINDOWPROC, glXDestroyWindow, EGL_FALSE);
1120    GET_PROC(PFNGLXCREATEPIXMAPPROC, glXCreatePixmap, EGL_FALSE);
1121    GET_PROC(PFNGLXDESTROYPIXMAPPROC, glXDestroyPixmap, EGL_FALSE);
1122    GET_PROC(PFNGLXCREATEPBUFFERPROC, glXCreatePbuffer, EGL_FALSE);
1123    GET_PROC(PFNGLXDESTROYPBUFFERPROC, glXDestroyPbuffer, EGL_FALSE);
1124    GET_PROC(PFNGLXCREATENEWCONTEXTPROC, glXCreateNewContext, EGL_FALSE);
1125    GET_PROC(PFNGLXMAKECONTEXTCURRENTPROC, glXMakeContextCurrent, EGL_FALSE);
1126
1127    /* GLX_SGIX_pbuffer */
1128    GET_PROC(PFNGLXCREATEGLXPBUFFERSGIXPROC,
1129          glXCreateGLXPbufferSGIX, EGL_FALSE);
1130    GET_PROC(PFNGLXDESTROYGLXPBUFFERSGIXPROC,
1131          glXDestroyGLXPbufferSGIX, EGL_FALSE);
1132 #undef GET_PROC
1133
1134    GLX_drv->handle = handle;
1135
1136    return EGL_TRUE;
1137
1138 fail:
1139    if (handle)
1140       dlclose(handle);
1141    return EGL_FALSE;
1142 }
1143
1144
1145 /**
1146  * This is the main entrypoint into the driver, called by libEGL.
1147  * Create a new _EGLDriver object and init its dispatch table.
1148  */
1149 _EGLDriver *
1150 _eglBuiltInDriverGLX(const char *args)
1151 {
1152    struct GLX_egl_driver *GLX_drv = CALLOC_STRUCT(GLX_egl_driver);
1153
1154    (void) args;
1155
1156    if (!GLX_drv)
1157       return NULL;
1158
1159    if (!GLX_Load(&GLX_drv->Base)) {
1160       _eglLog(_EGL_WARNING, "GLX: failed to load GLX");
1161       free(GLX_drv);
1162       return NULL;
1163    }
1164
1165    _eglInitDriverFallbacks(&GLX_drv->Base);
1166    GLX_drv->Base.API.Initialize = GLX_eglInitialize;
1167    GLX_drv->Base.API.Terminate = GLX_eglTerminate;
1168    GLX_drv->Base.API.CreateContext = GLX_eglCreateContext;
1169    GLX_drv->Base.API.DestroyContext = GLX_eglDestroyContext;
1170    GLX_drv->Base.API.MakeCurrent = GLX_eglMakeCurrent;
1171    GLX_drv->Base.API.CreateWindowSurface = GLX_eglCreateWindowSurface;
1172    GLX_drv->Base.API.CreatePixmapSurface = GLX_eglCreatePixmapSurface;
1173    GLX_drv->Base.API.CreatePbufferSurface = GLX_eglCreatePbufferSurface;
1174    GLX_drv->Base.API.DestroySurface = GLX_eglDestroySurface;
1175    GLX_drv->Base.API.SwapBuffers = GLX_eglSwapBuffers;
1176    GLX_drv->Base.API.GetProcAddress = GLX_eglGetProcAddress;
1177    GLX_drv->Base.API.WaitClient = GLX_eglWaitClient;
1178    GLX_drv->Base.API.WaitNative = GLX_eglWaitNative;
1179
1180    GLX_drv->Base.Name = "GLX";
1181    GLX_drv->Base.Unload = GLX_Unload;
1182
1183    return &GLX_drv->Base;
1184 }