src/egl/drivers/glx/egl_glx.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28
  29 /**
  30  * This is an EGL driver that wraps GLX. This gives the benefit of being
  31  * completely agnostic of the direct rendering implementation.
  32  *
  33  * Authors: Alan Hourihane <alanh@tungstengraphics.com>
  34  */
  35
  36 /*
  37  * TODO:
  38  *
  39  * test eglBind/ReleaseTexImage
  40  */
  41
  42
  43 #include <assert.h>
  44 #include <stdio.h>
  45 #include <sys/types.h>
  46 #include <sys/stat.h>
  47 #include <fcntl.h>
  48 #include "dlfcn.h"
  49 #include <X11/Xlib.h>
  50 #include <GL/gl.h>
  51 #include "glxclient.h"
  52
  53 #define _EGL_PLATFORM_X
  54
  55 #include "eglconfig.h"
  56 #include "eglcontext.h"
  57 #include "egldisplay.h"
  58 #include "egldriver.h"
  59 #include "eglglobals.h"
  60 #include "eglhash.h"
  61 #include "egllog.h"
  62 #include "eglsurface.h"
  63
  64 #include <GL/gl.h>
  65
  66 #define CALLOC_STRUCT(T)   (struct T *) calloc(1, sizeof(struct T))
  67
  68 static const EGLint all_apis = (EGL_OPENGL_ES_BIT
  69                                 | EGL_OPENGL_ES2_BIT
  70                                 | EGL_OPENVG_BIT
  71                                 /* | EGL_OPENGL_BIT */); /* can't do */
  72
  73 struct visual_attribs
  74 {
  75    /* X visual attribs */
  76    int id;
  77    int klass;
  78    int depth;
  79    int redMask, greenMask, blueMask;
  80    int colormapSize;
  81    int bitsPerRGB;
  82
  83    /* GL visual attribs */
  84    int supportsGL;
  85    int transparentType;
  86    int transparentRedValue;
  87    int transparentGreenValue;
  88    int transparentBlueValue;
  89    int transparentAlphaValue;
  90    int transparentIndexValue;
  91    int bufferSize;
  92    int level;
  93    int render_type;
  94    int doubleBuffer;
  95    int stereo;
  96    int auxBuffers;
  97    int redSize, greenSize, blueSize, alphaSize;
  98    int depthSize;
  99    int stencilSize;
 100    int accumRedSize, accumGreenSize, accumBlueSize, accumAlphaSize;
 101    int numSamples, numMultisample;
 102    int visualCaveat;
 103 };
 104
 105 /** subclass of _EGLDriver */
 106 struct GLX_egl_driver
 107 {
 108    _EGLDriver Base;   /**< base class */
 109
 110    XVisualInfo *visuals;
 111    GLXFBConfig *fbconfigs;
 112
 113    int glx_maj, glx_min;
 114 };
 115
 116
 117 /** subclass of _EGLContext */
 118 struct GLX_egl_context
 119 {
 120    _EGLContext Base;   /**< base class */
 121
 122    GLXContext context;
 123 };
 124
 125
 126 /** subclass of _EGLSurface */
 127 struct GLX_egl_surface
 128 {
 129    _EGLSurface Base;   /**< base class */
 130
 131    GLXDrawable drawable;
 132 };
 133
 134
 135 /** subclass of _EGLConfig */
 136 struct GLX_egl_config
 137 {
 138    _EGLConfig Base;   /**< base class */
 139 };
 140
 141 /** cast wrapper */
 142 static struct GLX_egl_driver *
 143 GLX_egl_driver(_EGLDriver *drv)
 144 {
 145    return (struct GLX_egl_driver *) drv;
 146 }
 147
 148 static struct GLX_egl_context *
 149 GLX_egl_context(_EGLContext *ctx)
 150 {
 151    return (struct GLX_egl_context *) ctx;
 152 }
 153
 154 static struct GLX_egl_surface *
 155 GLX_egl_surface(_EGLSurface *surf)
 156 {
 157    return (struct GLX_egl_surface *) surf;
 158 }
 159
 160 static GLboolean
 161 get_visual_attribs(Display *dpy, XVisualInfo *vInfo,
 162                    struct visual_attribs *attribs)
 163 {
 164    const char *ext = glXQueryExtensionsString(dpy, vInfo->screen);
 165    int rgba;
 166
 167    memset(attribs, 0, sizeof(struct visual_attribs));
 168
 169    attribs->id = vInfo->visualid;
 170 #if defined(__cplusplus) || defined(c_plusplus)
 171    attribs->klass = vInfo->c_class;
 172 #else
 173    attribs->klass = vInfo->class;
 174 #endif
 175    attribs->depth = vInfo->depth;
 176    attribs->redMask = vInfo->red_mask;
 177    attribs->greenMask = vInfo->green_mask;
 178    attribs->blueMask = vInfo->blue_mask;
 179    attribs->colormapSize = vInfo->colormap_size;
 180    attribs->bitsPerRGB = vInfo->bits_per_rgb;
 181
 182    if (glXGetConfig(dpy, vInfo, GLX_USE_GL, &attribs->supportsGL) != 0 ||
 183        !attribs->supportsGL)
 184       return GL_FALSE;
 185    glXGetConfig(dpy, vInfo, GLX_BUFFER_SIZE, &attribs->bufferSize);
 186    glXGetConfig(dpy, vInfo, GLX_LEVEL, &attribs->level);
 187    glXGetConfig(dpy, vInfo, GLX_RGBA, &rgba);
 188    if (!rgba)
 189       return GL_FALSE;
 190    attribs->render_type = GLX_RGBA_BIT;
 191
 192    glXGetConfig(dpy, vInfo, GLX_DOUBLEBUFFER, &attribs->doubleBuffer);
 193    if (!attribs->doubleBuffer)
 194       return GL_FALSE;
 195
 196    glXGetConfig(dpy, vInfo, GLX_STEREO, &attribs->stereo);
 197    glXGetConfig(dpy, vInfo, GLX_AUX_BUFFERS, &attribs->auxBuffers);
 198    glXGetConfig(dpy, vInfo, GLX_RED_SIZE, &attribs->redSize);
 199    glXGetConfig(dpy, vInfo, GLX_GREEN_SIZE, &attribs->greenSize);
 200    glXGetConfig(dpy, vInfo, GLX_BLUE_SIZE, &attribs->blueSize);
 201    glXGetConfig(dpy, vInfo, GLX_ALPHA_SIZE, &attribs->alphaSize);
 202    glXGetConfig(dpy, vInfo, GLX_DEPTH_SIZE, &attribs->depthSize);
 203    glXGetConfig(dpy, vInfo, GLX_STENCIL_SIZE, &attribs->stencilSize);
 204    glXGetConfig(dpy, vInfo, GLX_ACCUM_RED_SIZE, &attribs->accumRedSize);
 205    glXGetConfig(dpy, vInfo, GLX_ACCUM_GREEN_SIZE, &attribs->accumGreenSize);
 206    glXGetConfig(dpy, vInfo, GLX_ACCUM_BLUE_SIZE, &attribs->accumBlueSize);
 207    glXGetConfig(dpy, vInfo, GLX_ACCUM_ALPHA_SIZE, &attribs->accumAlphaSize);
 208
 209    /* get transparent pixel stuff */
 210    glXGetConfig(dpy, vInfo,GLX_TRANSPARENT_TYPE, &attribs->transparentType);
 211    if (attribs->transparentType == GLX_TRANSPARENT_RGB) {
 212      glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_RED_VALUE, &attribs->transparentRedValue);
 213      glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_GREEN_VALUE, &attribs->transparentGreenValue);
 214      glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_BLUE_VALUE, &attribs->transparentBlueValue);
 215      glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_ALPHA_VALUE, &attribs->transparentAlphaValue);
 216    }
 217    else if (attribs->transparentType == GLX_TRANSPARENT_INDEX) {
 218      glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_INDEX_VALUE, &attribs->transparentIndexValue);
 219    }
 220
 221    /* multisample attribs */
 222 #ifdef GLX_ARB_multisample
 223    if (ext && strstr(ext, "GLX_ARB_multisample")) {
 224       glXGetConfig(dpy, vInfo, GLX_SAMPLE_BUFFERS_ARB, &attribs->numMultisample);
 225       glXGetConfig(dpy, vInfo, GLX_SAMPLES_ARB, &attribs->numSamples);
 226    }
 227 #endif
 228    else {
 229       attribs->numSamples = 0;
 230       attribs->numMultisample = 0;
 231    }
 232
 233 #if defined(GLX_EXT_visual_rating)
 234    if (ext && strstr(ext, "GLX_EXT_visual_rating")) {
 235       glXGetConfig(dpy, vInfo, GLX_VISUAL_CAVEAT_EXT, &attribs->visualCaveat);
 236    }
 237    else {
 238       attribs->visualCaveat = GLX_NONE_EXT;
 239    }
 240 #else
 241    attribs->visualCaveat = 0;
 242 #endif
 243
 244    return GL_TRUE;
 245 }
 246
 247 #ifdef GLX_VERSION_1_3
 248
 249 static int
 250 glx_token_to_visual_class(int visual_type)
 251 {
 252    switch (visual_type) {
 253    case GLX_TRUE_COLOR:
 254       return TrueColor;
 255    case GLX_DIRECT_COLOR:
 256       return DirectColor;
 257    case GLX_PSEUDO_COLOR:
 258       return PseudoColor;
 259    case GLX_STATIC_COLOR:
 260       return StaticColor;
 261    case GLX_GRAY_SCALE:
 262       return GrayScale;
 263    case GLX_STATIC_GRAY:
 264       return StaticGray;
 265    case GLX_NONE:
 266    default:
 267       return None;
 268    }
 269 }
 270 static GLboolean
 271 get_fbconfig_attribs(Display *dpy, GLXFBConfig fbconfig,
 272                      struct visual_attribs *attribs)
 273 {
 274    int visual_type;
 275
 276    memset(attribs, 0, sizeof(struct visual_attribs));
 277
 278    /* We don't use the GLX_FBCONFIG_ID here */
 279    glXGetFBConfigAttrib(dpy, fbconfig, GLX_VISUAL_ID, &attribs->id);
 280
 281 #if 0
 282    attribs->depth = vInfo->depth;
 283    attribs->redMask = vInfo->red_mask;
 284    attribs->greenMask = vInfo->green_mask;
 285    attribs->blueMask = vInfo->blue_mask;
 286    attribs->colormapSize = vInfo->colormap_size;
 287    attribs->bitsPerRGB = vInfo->bits_per_rgb;
 288 #endif
 289
 290    glXGetFBConfigAttrib(dpy, fbconfig, GLX_X_VISUAL_TYPE, &visual_type);
 291    attribs->klass = glx_token_to_visual_class(visual_type);
 292
 293    glXGetFBConfigAttrib(dpy, fbconfig, GLX_BUFFER_SIZE, &attribs->bufferSize);
 294    glXGetFBConfigAttrib(dpy, fbconfig, GLX_LEVEL, &attribs->level);
 295    glXGetFBConfigAttrib(dpy, fbconfig, GLX_RENDER_TYPE, &attribs->render_type);
 296    if (!(attribs->render_type & GLX_RGBA_BIT))
 297       return GL_FALSE;
 298
 299    glXGetFBConfigAttrib(dpy, fbconfig, GLX_DOUBLEBUFFER, &attribs->doubleBuffer);
 300    if (!attribs->doubleBuffer)
 301       return GL_FALSE;
 302
 303    glXGetFBConfigAttrib(dpy, fbconfig, GLX_STEREO, &attribs->stereo);
 304    glXGetFBConfigAttrib(dpy, fbconfig, GLX_AUX_BUFFERS, &attribs->auxBuffers);
 305
 306    glXGetFBConfigAttrib(dpy, fbconfig, GLX_RED_SIZE, &attribs->redSize);
 307    glXGetFBConfigAttrib(dpy, fbconfig, GLX_GREEN_SIZE, &attribs->greenSize);
 308    glXGetFBConfigAttrib(dpy, fbconfig, GLX_BLUE_SIZE, &attribs->blueSize);
 309    glXGetFBConfigAttrib(dpy, fbconfig, GLX_ALPHA_SIZE, &attribs->alphaSize);
 310    glXGetFBConfigAttrib(dpy, fbconfig, GLX_DEPTH_SIZE, &attribs->depthSize);
 311    glXGetFBConfigAttrib(dpy, fbconfig, GLX_STENCIL_SIZE, &attribs->stencilSize);
 312
 313    glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_RED_SIZE, &attribs->accumRedSize);
 314    glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_GREEN_SIZE, &attribs->accumGreenSize);
 315    glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_BLUE_SIZE, &attribs->accumBlueSize);
 316    glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_ALPHA_SIZE, &attribs->accumAlphaSize);
 317
 318    /* get transparent pixel stuff */
 319    glXGetFBConfigAttrib(dpy, fbconfig,GLX_TRANSPARENT_TYPE, &attribs->transparentType);
 320    if (attribs->transparentType == GLX_TRANSPARENT_RGB) {
 321      glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_RED_VALUE, &attribs->transparentRedValue);
 322      glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_GREEN_VALUE, &attribs->transparentGreenValue);
 323      glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_BLUE_VALUE, &attribs->transparentBlueValue);
 324      glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_ALPHA_VALUE, &attribs->transparentAlphaValue);
 325    }
 326    else if (attribs->transparentType == GLX_TRANSPARENT_INDEX) {
 327      glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_INDEX_VALUE, &attribs->transparentIndexValue);
 328    }
 329
 330    glXGetFBConfigAttrib(dpy, fbconfig, GLX_SAMPLE_BUFFERS, &attribs->numMultisample);
 331    glXGetFBConfigAttrib(dpy, fbconfig, GLX_SAMPLES, &attribs->numSamples);
 332
 333    glXGetFBConfigAttrib(dpy, fbconfig, GLX_CONFIG_CAVEAT, &attribs->visualCaveat);
 334
 335    return GL_TRUE;
 336 }
 337
 338 #endif
 339
 340 static EGLBoolean
 341 create_configs(_EGLDisplay *disp, struct GLX_egl_driver *GLX_drv)
 342 {
 343    XVisualInfo theTemplate;
 344    int numVisuals;
 345    long mask;
 346    int i;
 347    struct visual_attribs attribs;
 348
 349    GLX_drv->fbconfigs = NULL;
 350
 351 #ifdef GLX_VERSION_1_3
 352    /* get list of all fbconfigs on this screen */
 353    GLX_drv->fbconfigs = glXGetFBConfigs(disp->Xdpy, DefaultScreen(disp->Xdpy), &numVisuals);
 354
 355    if (numVisuals == 0) {
 356       GLX_drv->fbconfigs = NULL;
 357       goto xvisual;
 358    }
 359
 360    for (i = 0; i < numVisuals; i++) {
 361       struct GLX_egl_config *config;
 362
 363       if (!get_fbconfig_attribs(disp->Xdpy, GLX_drv->fbconfigs[i], &attribs))
 364          continue;
 365
 366       config = CALLOC_STRUCT(GLX_egl_config);
 367
 368       _eglInitConfig(&config->Base, i+1);
 369       SET_CONFIG_ATTRIB(&config->Base, EGL_NATIVE_VISUAL_ID, attribs.id);
 370       SET_CONFIG_ATTRIB(&config->Base, EGL_BUFFER_SIZE, attribs.bufferSize);
 371       SET_CONFIG_ATTRIB(&config->Base, EGL_RED_SIZE, attribs.redSize);
 372       SET_CONFIG_ATTRIB(&config->Base, EGL_GREEN_SIZE, attribs.greenSize);
 373       SET_CONFIG_ATTRIB(&config->Base, EGL_BLUE_SIZE, attribs.blueSize);
 374       SET_CONFIG_ATTRIB(&config->Base, EGL_ALPHA_SIZE, attribs.alphaSize);
 375       SET_CONFIG_ATTRIB(&config->Base, EGL_DEPTH_SIZE, attribs.depthSize);
 376       SET_CONFIG_ATTRIB(&config->Base, EGL_STENCIL_SIZE, attribs.stencilSize);
 377       SET_CONFIG_ATTRIB(&config->Base, EGL_SAMPLES, attribs.numSamples);
 378       SET_CONFIG_ATTRIB(&config->Base, EGL_SAMPLE_BUFFERS, attribs.numMultisample);
 379       SET_CONFIG_ATTRIB(&config->Base, EGL_CONFORMANT, all_apis);
 380       SET_CONFIG_ATTRIB(&config->Base, EGL_RENDERABLE_TYPE, all_apis);
 381       SET_CONFIG_ATTRIB(&config->Base, EGL_SURFACE_TYPE,
 382                         (EGL_WINDOW_BIT | EGL_PBUFFER_BIT | EGL_PIXMAP_BIT));
 383
 384       /* XXX possibly other things to init... */
 385
 386       _eglAddConfig(disp, &config->Base);
 387    }
 388
 389    goto end;
 390 #endif
 391
 392 xvisual:
 393    /* get list of all visuals on this screen */
 394    theTemplate.screen = DefaultScreen(disp->Xdpy);
 395    mask = VisualScreenMask;
 396    GLX_drv->visuals = XGetVisualInfo(disp->Xdpy, mask, &theTemplate, &numVisuals);
 397
 398    for (i = 0; i < numVisuals; i++) {
 399       struct GLX_egl_config *config;
 400
 401       if (!get_visual_attribs(disp->Xdpy, &GLX_drv->visuals[i], &attribs))
 402          continue;
 403
 404       config = CALLOC_STRUCT(GLX_egl_config);
 405
 406       _eglInitConfig(&config->Base, i+1);
 407       SET_CONFIG_ATTRIB(&config->Base, EGL_NATIVE_VISUAL_ID, attribs.id);
 408       SET_CONFIG_ATTRIB(&config->Base, EGL_BUFFER_SIZE, attribs.bufferSize);
 409       SET_CONFIG_ATTRIB(&config->Base, EGL_RED_SIZE, attribs.redSize);
 410       SET_CONFIG_ATTRIB(&config->Base, EGL_GREEN_SIZE, attribs.greenSize);
 411       SET_CONFIG_ATTRIB(&config->Base, EGL_BLUE_SIZE, attribs.blueSize);
 412       SET_CONFIG_ATTRIB(&config->Base, EGL_ALPHA_SIZE, attribs.alphaSize);
 413       SET_CONFIG_ATTRIB(&config->Base, EGL_DEPTH_SIZE, attribs.depthSize);
 414       SET_CONFIG_ATTRIB(&config->Base, EGL_STENCIL_SIZE, attribs.stencilSize);
 415       SET_CONFIG_ATTRIB(&config->Base, EGL_SAMPLES, attribs.numSamples);
 416       SET_CONFIG_ATTRIB(&config->Base, EGL_SAMPLE_BUFFERS, attribs.numMultisample);
 417       SET_CONFIG_ATTRIB(&config->Base, EGL_CONFORMANT, all_apis);
 418       SET_CONFIG_ATTRIB(&config->Base, EGL_RENDERABLE_TYPE, all_apis);
 419       SET_CONFIG_ATTRIB(&config->Base, EGL_SURFACE_TYPE,
 420                         (EGL_WINDOW_BIT /*| EGL_PBUFFER_BIT | EGL_PIXMAP_BIT*/));
 421
 422       /* XXX possibly other things to init... */
 423
 424       _eglAddConfig(disp, &config->Base);
 425    }
 426
 427 end:
 428    return EGL_TRUE;
 429 }
 430
 431 /**
 432  * Called via eglInitialize(), GLX_drv->API.Initialize().
 433  */
 434 static EGLBoolean
 435 GLX_eglInitialize(_EGLDriver *drv, EGLDisplay dpy,
 436                    EGLint *minor, EGLint *major)
 437 {
 438    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
 439    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 440
 441    _eglLog(_EGL_DEBUG, "GLX: eglInitialize");
 442
 443    if (!disp->Xdpy) {
 444       disp->Xdpy = XOpenDisplay(NULL);
 445       if (!disp->Xdpy) {
 446          _eglLog(_EGL_WARNING, "GLX: XOpenDisplay failed");
 447          return EGL_FALSE;
 448       }
 449    }
 450
 451    glXQueryVersion(disp->Xdpy, &GLX_drv->glx_maj, &GLX_drv->glx_min);
 452
 453    GLX_drv->Base.Initialized = EGL_TRUE;
 454
 455    GLX_drv->Base.Name = "GLX";
 456
 457    /* we're supporting EGL 1.4 */
 458    *minor = 1;
 459    *major = 4;
 460
 461    create_configs(disp, GLX_drv);
 462
 463    return EGL_TRUE;
 464 }
 465
 466 /*
 467  * Do some clean-up that normally occurs in XCloseDisplay().
 468  * We do this here because we're about to unload a dynamic library
 469  * that has added some per-display extension data and callbacks.
 470  * If we don't do this here we'll crash in XCloseDisplay() because it'll
 471  * try to call functions that went away when the driver library was unloaded.
 472  */
 473 static void
 474 FreeDisplayExt(Display *dpy)
 475 {
 476    _XExtension *ext, *next;
 477
 478    for (ext = dpy->ext_procs; ext; ext = next) {
 479       next = ext->next;
 480       if (ext->close_display) {
 481          ext->close_display(dpy, &ext->codes);
 482          ext->close_display = NULL;
 483       }
 484       if (ext->name)
 485          Xfree(ext->name);
 486       Xfree(ext);
 487    }
 488    dpy->ext_procs = NULL;
 489
 490    _XFreeExtData (dpy->ext_data);
 491    dpy->ext_data = NULL;
 492 }
 493
 494 /**
 495  * Called via eglTerminate(), drv->API.Terminate().
 496  */
 497 static EGLBoolean
 498 GLX_eglTerminate(_EGLDriver *drv, EGLDisplay dpy)
 499 {
 500    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 501
 502    _eglLog(_EGL_DEBUG, "GLX: eglTerminate");
 503
 504    FreeDisplayExt(disp->Xdpy);
 505
 506    return EGL_TRUE;
 507 }
 508
 509
 510 /**
 511  * Called via eglCreateContext(), drv->API.CreateContext().
 512  */
 513 static EGLContext
 514 GLX_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 515                       EGLContext share_list, const EGLint *attrib_list)
 516 {
 517    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 518    struct GLX_egl_context *GLX_ctx = CALLOC_STRUCT(GLX_egl_context);
 519    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
 520    struct GLX_egl_context *GLX_ctx_shared = NULL;
 521    _EGLConfig *conf;
 522
 523    if (!GLX_ctx)
 524       return EGL_NO_CONTEXT;
 525
 526    if (!_eglInitContext(drv, dpy, &GLX_ctx->Base, config, attrib_list)) {
 527       free(GLX_ctx);
 528       return EGL_NO_CONTEXT;
 529    }
 530
 531    if (share_list != EGL_NO_CONTEXT) {
 532       _EGLContext *shareCtx = _eglLookupContext(share_list);
 533       if (!shareCtx) {
 534          _eglError(EGL_BAD_CONTEXT, "eglCreateContext(share_list)");
 535          return EGL_FALSE;
 536       }
 537       GLX_ctx_shared = GLX_egl_context(shareCtx);
 538    }
 539
 540    conf = _eglLookupConfig(drv, dpy, config);
 541    assert(conf);
 542
 543 #ifdef GLX_VERSION_1_3
 544    if (GLX_drv->fbconfigs)
 545       GLX_ctx->context = glXCreateNewContext(disp->Xdpy, GLX_drv->fbconfigs[(int)config-1], GLX_RGBA_TYPE, GLX_ctx_shared ? GLX_ctx_shared->context : NULL, GL_TRUE);
 546    else
 547 #endif
 548       GLX_ctx->context = glXCreateContext(disp->Xdpy, &GLX_drv->visuals[(int)config-1], GLX_ctx_shared ? GLX_ctx_shared->context : NULL, GL_TRUE);
 549    if (!GLX_ctx->context)
 550       return EGL_FALSE;
 551
 552 #if 1
 553    /* (maybe?) need to have a direct rendering context */
 554    if (!glXIsDirect(disp->Xdpy, GLX_ctx->context))
 555       return EGL_FALSE;
 556 #endif
 557
 558    return _eglGetContextHandle(&GLX_ctx->Base);
 559 }
 560
 561
 562 /**
 563  * Called via eglMakeCurrent(), drv->API.MakeCurrent().
 564  */
 565 static EGLBoolean
 566 GLX_eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface d,
 567                     EGLSurface r, EGLContext context)
 568 {
 569    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 570    _EGLContext *ctx = _eglLookupContext(context);
 571    _EGLSurface *dsurf = _eglLookupSurface(d);
 572    _EGLSurface *rsurf = _eglLookupSurface(r);
 573    struct GLX_egl_surface *GLX_dsurf = GLX_egl_surface(dsurf);
 574    struct GLX_egl_surface *GLX_rsurf = GLX_egl_surface(rsurf);
 575    struct GLX_egl_context *GLX_ctx = GLX_egl_context(ctx);
 576
 577    if (!_eglMakeCurrent(drv, dpy, d, r, context))
 578       return EGL_FALSE;
 579
 580 #ifdef GLX_VERSION_1_3
 581    if (!glXMakeContextCurrent(disp->Xdpy, GLX_dsurf ? GLX_dsurf->drawable : 0, GLX_rsurf ? GLX_rsurf->drawable : 0, GLX_ctx ? GLX_ctx->context : NULL))
 582 #endif
 583       if (!glXMakeCurrent(disp->Xdpy, GLX_dsurf ? GLX_dsurf->drawable : 0, GLX_ctx ? GLX_ctx->context : NULL))
 584          return EGL_FALSE;
 585
 586    return EGL_TRUE;
 587 }
 588
 589 /** Get size of given window */
 590 static Status
 591 get_drawable_size(Display *dpy, Drawable d, uint *width, uint *height)
 592 {
 593    Window root;
 594    Status stat;
 595    int xpos, ypos;
 596    unsigned int w, h, bw, depth;
 597    stat = XGetGeometry(dpy, d, &root, &xpos, &ypos, &w, &h, &bw, &depth);
 598    *width = w;
 599    *height = h;
 600    return stat;
 601 }
 602
 603 /**
 604  * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
 605  */
 606 static EGLSurface
 607 GLX_eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 608                             NativeWindowType window, const EGLint *attrib_list)
 609 {
 610    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 611    struct GLX_egl_surface *GLX_surf;
 612    uint width, height;
 613
 614    GLX_surf = CALLOC_STRUCT(GLX_egl_surface);
 615    if (!GLX_surf)
 616       return EGL_NO_SURFACE;
 617
 618    if (!_eglInitSurface(drv, dpy, &GLX_surf->Base, EGL_WINDOW_BIT,
 619                         config, attrib_list)) {
 620       free(GLX_surf);
 621       return EGL_FALSE;
 622    }
 623
 624    _eglSaveSurface(&GLX_surf->Base);
 625
 626    GLX_surf->drawable = window;
 627    get_drawable_size(disp->Xdpy, window, &width, &height);
 628    GLX_surf->Base.Width = width;
 629    GLX_surf->Base.Height = height;
 630
 631    return _eglGetSurfaceHandle(&GLX_surf->Base);
 632 }
 633
 634 #ifdef GLX_VERSION_1_3
 635 static EGLSurface
 636 GLX_eglCreatePixmapSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 637                            NativePixmapType pixmap, const EGLint *attrib_list)
 638 {
 639    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
 640    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 641    struct GLX_egl_surface *GLX_surf;
 642    int i;
 643
 644    GLX_surf = CALLOC_STRUCT(GLX_egl_surface);
 645    if (!GLX_surf)
 646       return EGL_NO_SURFACE;
 647
 648    if (!_eglInitSurface(drv, dpy, &GLX_surf->Base, EGL_PIXMAP_BIT,
 649                         config, attrib_list)) {
 650       free(GLX_surf);
 651       return EGL_FALSE;
 652    }
 653
 654    _eglSaveSurface(&GLX_surf->Base);
 655
 656    for (i = 0; attrib_list && attrib_list[i] != EGL_NONE; i++) {
 657       switch (attrib_list[i]) {
 658          /* no attribs at this time */
 659       default:
 660          _eglError(EGL_BAD_ATTRIBUTE, "eglCreatePixmapSurface");
 661          return EGL_NO_SURFACE;
 662       }
 663    }
 664
 665    GLX_surf->drawable = glXCreatePixmap(disp->Xdpy, GLX_drv->fbconfigs[(int)config-1], pixmap, NULL);
 666
 667    return _eglGetSurfaceHandle(&GLX_surf->Base);
 668 }
 669
 670 static EGLSurface
 671 GLX_eglCreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 672                             const EGLint *attrib_list)
 673 {
 674    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
 675    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 676    struct GLX_egl_surface *GLX_surf;
 677    int attribs[5];
 678    int i = 0, j = 0;
 679
 680    GLX_surf = CALLOC_STRUCT(GLX_egl_surface);
 681    if (!GLX_surf)
 682       return EGL_NO_SURFACE;
 683
 684    if (!_eglInitSurface(drv, dpy, &GLX_surf->Base, EGL_PBUFFER_BIT,
 685                         config, attrib_list)) {
 686       free(GLX_surf);
 687       return EGL_NO_SURFACE;
 688    }
 689
 690    _eglSaveSurface(&GLX_surf->Base);
 691
 692    while(attrib_list[i] != EGL_NONE) {
 693       switch (attrib_list[i]) {
 694          case EGL_WIDTH:
 695             attribs[j++] = GLX_PBUFFER_WIDTH;
 696             attribs[j++] = attrib_list[i+1];
 697             break;
 698          case EGL_HEIGHT:
 699             attribs[j++] = GLX_PBUFFER_HEIGHT;
 700             attribs[j++] = attrib_list[i+1];
 701             break;
 702       }
 703       i++;
 704    }
 705    attribs[j++] = 0;
 706
 707    GLX_surf->drawable = glXCreatePbuffer(disp->Xdpy, GLX_drv->fbconfigs[(int)config-1], attribs);
 708
 709    return _eglGetSurfaceHandle(&GLX_surf->Base);
 710 }
 711 #endif
 712
 713 static EGLBoolean
 714 GLX_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 715 {
 716    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 717    _EGLSurface *surf = _eglLookupSurface(surface);
 718    return EGL_TRUE;
 719    if (surf) {
 720       _eglHashRemove(_eglGlobal.Surfaces, (EGLuint) surface);
 721       if (surf->IsBound) {
 722          surf->DeletePending = EGL_TRUE;
 723       }
 724       else {
 725          free(surf);
 726       }
 727
 728       return EGL_TRUE;
 729    }
 730    else {
 731       _eglError(EGL_BAD_SURFACE, "eglDestroySurface");
 732       return EGL_FALSE;
 733    }
 734 }
 735
 736
 737 static EGLBoolean
 738 GLX_eglBindTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface,
 739                      EGLint buffer)
 740 {
 741    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 742    _EGLSurface *surf = _eglLookupSurface(surface);
 743    struct GLX_egl_surface *GLX_surf = GLX_egl_surface(surf);
 744
 745    /* buffer ?? */
 746    glXBindTexImageEXT(disp->Xdpy, GLX_surf->drawable, GLX_FRONT_LEFT_EXT, NULL);
 747
 748    return EGL_TRUE;
 749 }
 750
 751
 752 static EGLBoolean
 753 GLX_eglReleaseTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface,
 754                         EGLint buffer)
 755 {
 756    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 757    _EGLSurface *surf = _eglLookupSurface(surface);
 758    struct GLX_egl_surface *GLX_surf = GLX_egl_surface(surf);
 759
 760    /* buffer ?? */
 761    glXReleaseTexImageEXT(disp->Xdpy, GLX_surf->drawable, GLX_FRONT_LEFT_EXT);
 762
 763    return EGL_TRUE;
 764 }
 765
 766
 767 static EGLBoolean
 768 GLX_eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
 769 {
 770    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 771    _EGLSurface *surf = _eglLookupSurface(draw);
 772    struct GLX_egl_surface *GLX_surf = GLX_egl_surface(surf);
 773
 774    _eglLog(_EGL_DEBUG, "GLX: EGL SwapBuffers 0x%x",draw);
 775
 776    /* error checking step: */
 777    if (!_eglSwapBuffers(drv, dpy, draw))
 778       return EGL_FALSE;
 779
 780    glXSwapBuffers(disp->Xdpy, GLX_surf->drawable);
 781
 782    return EGL_TRUE;
 783 }
 784
 785 /*
 786  * Called from eglGetProcAddress() via drv->API.GetProcAddress().
 787  */
 788 static _EGLProc
 789 GLX_eglGetProcAddress(const char *procname)
 790 {
 791    return (_EGLProc)glXGetProcAddress((const GLubyte *)procname);
 792 }
 793
 794
 795 /**
 796  * This is the main entrypoint into the driver, called by libEGL.
 797  * Create a new _EGLDriver object and init its dispatch table.
 798  */
 799 _EGLDriver *
 800 _eglMain(_EGLDisplay *disp, const char *args)
 801 {
 802    struct GLX_egl_driver *GLX_drv = CALLOC_STRUCT(GLX_egl_driver);
 803    char *env;
 804    int maj = 0, min = 0;
 805
 806    if (!GLX_drv)
 807       return NULL;
 808
 809    _eglInitDriverFallbacks(&GLX_drv->Base);
 810    GLX_drv->Base.API.Initialize = GLX_eglInitialize;
 811    GLX_drv->Base.API.Terminate = GLX_eglTerminate;
 812    GLX_drv->Base.API.CreateContext = GLX_eglCreateContext;
 813    GLX_drv->Base.API.MakeCurrent = GLX_eglMakeCurrent;
 814    GLX_drv->Base.API.CreateWindowSurface = GLX_eglCreateWindowSurface;
 815 #ifdef GLX_VERSION_1_3
 816    if (GLX_drv->glx_maj == 1 && GLX_drv->glx_min >= 3) {
 817       GLX_drv->Base.API.CreatePixmapSurface = GLX_eglCreatePixmapSurface;
 818       GLX_drv->Base.API.CreatePbufferSurface = GLX_eglCreatePbufferSurface;
 819       printf("GLX: Pbuffer and Pixmap support\n");
 820    } else {
 821       printf("GLX: No pbuffer or pixmap support\n");
 822    }
 823 #endif
 824    GLX_drv->Base.API.DestroySurface = GLX_eglDestroySurface;
 825    GLX_drv->Base.API.BindTexImage = GLX_eglBindTexImage;
 826    GLX_drv->Base.API.ReleaseTexImage = GLX_eglReleaseTexImage;
 827    GLX_drv->Base.API.SwapBuffers = GLX_eglSwapBuffers;
 828    GLX_drv->Base.API.GetProcAddress = GLX_eglGetProcAddress;
 829
 830    GLX_drv->Base.ClientAPIsMask = all_apis;
 831    GLX_drv->Base.Name = "GLX";
 832
 833    _eglLog(_EGL_DEBUG, "GLX: main(%s)", args);
 834
 835    /* set new DRI path to pick up EGL version (which doesn't contain any mesa
 836     * code), but don't override if one is already set.
 837     */
 838    env = getenv("LIBGL_DRIVERS_PATH");
 839    if (env) {
 840       if (!strstr(env, "egl")) {
 841          sprintf(env, "%s/egl", env);
 842          setenv("LIBGL_DRIVERS_PATH", env, 1);
 843       }
 844    } else
 845       setenv("LIBGL_DRIVERS_PATH", DEFAULT_DRIVER_DIR"/egl", 0);
 846
 847    return &GLX_drv->Base;
 848 }