src/glx/glxext.c

   1 /*
   2  * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
   3  * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice including the dates of first publication and
  13  * either this permission notice or a reference to
  14  * http://oss.sgi.com/projects/FreeB/
  15  * shall be included in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  20  * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  21  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  22  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  *
  25  * Except as contained in this notice, the name of Silicon Graphics, Inc.
  26  * shall not be used in advertising or otherwise to promote the sale, use or
  27  * other dealings in this Software without prior written authorization from
  28  * Silicon Graphics, Inc.
  29  */
  30
  31 /**
  32  * \file glxext.c
  33  * GLX protocol interface boot-strap code.
  34  *
  35  * Direct rendering support added by Precision Insight, Inc.
  36  *
  37  * \author Kevin E. Martin <kevin@precisioninsight.com>
  38  */
  39
  40 #include <assert.h>
  41 #include "glxclient.h"
  42 #include <X11/extensions/Xext.h>
  43 #include <X11/extensions/extutil.h>
  44 #ifdef GLX_USE_APPLEGL
  45 #include "apple_glx.h"
  46 #include "apple_visual.h"
  47 #endif
  48 #include "glxextensions.h"
  49
  50 #include <X11/Xlib-xcb.h>
  51 #include <xcb/xcb.h>
  52 #include <xcb/glx.h>
  53
  54
  55 #ifdef DEBUG
  56 void __glXDumpDrawBuffer(struct glx_context * ctx);
  57 #endif
  58
  59 /*
  60 ** You can set this cell to 1 to force the gl drawing stuff to be
  61 ** one command per packet
  62 */
  63 _X_HIDDEN int __glXDebug = 0;
  64
  65 /* Extension required boiler plate */
  66
  67 static const char __glXExtensionName[] = GLX_EXTENSION_NAME;
  68   static struct glx_display *glx_displays;
  69
  70 static /* const */ char *error_list[] = {
  71    "GLXBadContext",
  72    "GLXBadContextState",
  73    "GLXBadDrawable",
  74    "GLXBadPixmap",
  75    "GLXBadContextTag",
  76    "GLXBadCurrentWindow",
  77    "GLXBadRenderRequest",
  78    "GLXBadLargeRequest",
  79    "GLXUnsupportedPrivateRequest",
  80    "GLXBadFBConfig",
  81    "GLXBadPbuffer",
  82    "GLXBadCurrentDrawable",
  83    "GLXBadWindow",
  84    "GLXBadProfileARB",
  85 };
  86
  87 #ifdef GLX_USE_APPLEGL
  88 static char *__glXErrorString(Display *dpy, int code, XExtCodes *codes,
  89                               char *buf, int n);
  90 #endif
  91
  92 static
  93 XEXT_GENERATE_ERROR_STRING(__glXErrorString, __glXExtensionName,
  94                            __GLX_NUMBER_ERRORS, error_list)
  95
  96 /*
  97  * GLX events are a bit funky.  We don't stuff the X event code into
  98  * our user exposed (via XNextEvent) structure.  Instead we use the GLX
  99  * private event code namespace (and hope it doesn't conflict).  Clients
 100  * have to know that bit 15 in the event type field means they're getting
 101  * a GLX event, and then handle the various sub-event types there, rather
 102  * than simply checking the event code and handling it directly.
 103  */
 104
 105 static Bool
 106 __glXWireToEvent(Display *dpy, XEvent *event, xEvent *wire)
 107 {
 108      struct glx_display *glx_dpy = __glXInitialize(dpy);
 109
 110    if (glx_dpy == NULL)
 111       return False;
 112
 113    switch ((wire->u.u.type & 0x7f) - glx_dpy->codes->first_event) {
 114    case GLX_PbufferClobber:
 115    {
 116       GLXPbufferClobberEvent *aevent = (GLXPbufferClobberEvent *)event;
 117       xGLXPbufferClobberEvent *awire = (xGLXPbufferClobberEvent *)wire;
 118       aevent->event_type = awire->type;
 119       aevent->serial = awire->sequenceNumber;
 120       aevent->event_type = awire->event_type;
 121       aevent->draw_type = awire->draw_type;
 122       aevent->drawable = awire->drawable;
 123       aevent->buffer_mask = awire->buffer_mask;
 124       aevent->aux_buffer = awire->aux_buffer;
 125       aevent->x = awire->x;
 126       aevent->y = awire->y;
 127       aevent->width = awire->width;
 128       aevent->height = awire->height;
 129       aevent->count = awire->count;
 130       return True;
 131    }
 132    case GLX_BufferSwapComplete:
 133    {
 134       GLXBufferSwapComplete *aevent = (GLXBufferSwapComplete *)event;
 135       xGLXBufferSwapComplete2 *awire = (xGLXBufferSwapComplete2 *)wire;
 136       struct glx_drawable *glxDraw = GetGLXDrawable(dpy, awire->drawable);
 137       aevent->event_type = awire->event_type;
 138       aevent->drawable = awire->drawable;
 139       aevent->ust = ((CARD64)awire->ust_hi << 32) | awire->ust_lo;
 140       aevent->msc = ((CARD64)awire->msc_hi << 32) | awire->msc_lo;
 141
 142       if (!glxDraw)
 143          return False;
 144
 145       if (awire->sbc < glxDraw->lastEventSbc)
 146          glxDraw->eventSbcWrap += 0x100000000;
 147       glxDraw->lastEventSbc = awire->sbc;
 148       aevent->sbc = awire->sbc + glxDraw->eventSbcWrap;
 149       return True;
 150    }
 151    default:
 152       /* client doesn't support server event */
 153       break;
 154    }
 155
 156    return False;
 157 }
 158
 159 /* We don't actually support this.  It doesn't make sense for clients to
 160  * send each other GLX events.
 161  */
 162 static Status
 163 __glXEventToWire(Display *dpy, XEvent *event, xEvent *wire)
 164 {
 165      struct glx_display *glx_dpy = __glXInitialize(dpy);
 166
 167    if (glx_dpy == NULL)
 168       return False;
 169
 170    switch (event->type) {
 171    case GLX_DAMAGED:
 172       break;
 173    case GLX_SAVED:
 174       break;
 175    case GLX_EXCHANGE_COMPLETE_INTEL:
 176       break;
 177    case GLX_COPY_COMPLETE_INTEL:
 178       break;
 179    case GLX_FLIP_COMPLETE_INTEL:
 180       break;
 181    default:
 182       /* client doesn't support server event */
 183       break;
 184    }
 185
 186    return Success;
 187 }
 188
 189 /************************************************************************/
 190 /*
 191 ** Free the per screen configs data as well as the array of
 192 ** __glXScreenConfigs.
 193 */
 194 static void
 195 FreeScreenConfigs(struct glx_display * priv)
 196 {
 197    struct glx_screen *psc;
 198    GLint i, screens;
 199
 200    /* Free screen configuration information */
 201    screens = ScreenCount(priv->dpy);
 202    for (i = 0; i < screens; i++) {
 203       psc = priv->screens[i];
 204       glx_screen_cleanup(psc);
 205
 206 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
 207       if (psc->driScreen) {
 208          psc->driScreen->destroyScreen(psc);
 209       } else {
 210          free(psc);
 211       }
 212 #else
 213       free(psc);
 214 #endif
 215    }
 216    free((char *) priv->screens);
 217    priv->screens = NULL;
 218 }
 219
 220 static void
 221 glx_display_free(struct glx_display *priv)
 222 {
 223    struct glx_context *gc;
 224
 225    gc = __glXGetCurrentContext();
 226    if (priv->dpy == gc->currentDpy) {
 227       gc->vtable->destroy(gc);
 228       __glXSetCurrentContextNull();
 229    }
 230
 231    FreeScreenConfigs(priv);
 232    free((char *) priv->serverGLXvendor);
 233    free((char *) priv->serverGLXversion);
 234
 235    __glxHashDestroy(priv->glXDrawHash);
 236
 237 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
 238    __glxHashDestroy(priv->drawHash);
 239
 240    /* Free the direct rendering per display data */
 241    if (priv->driswDisplay)
 242       (*priv->driswDisplay->destroyDisplay) (priv->driswDisplay);
 243    priv->driswDisplay = NULL;
 244
 245    if (priv->driDisplay)
 246       (*priv->driDisplay->destroyDisplay) (priv->driDisplay);
 247    priv->driDisplay = NULL;
 248
 249    if (priv->dri2Display)
 250       (*priv->dri2Display->destroyDisplay) (priv->dri2Display);
 251    priv->dri2Display = NULL;
 252 #endif
 253
 254    free((char *) priv);
 255 }
 256
 257 static int
 258 __glXCloseDisplay(Display * dpy, XExtCodes * codes)
 259 {
 260    struct glx_display *priv, **prev;
 261
 262    _XLockMutex(_Xglobal_lock);
 263    prev = &glx_displays;
 264    for (priv = glx_displays; priv; prev = &priv->next, priv = priv->next) {
 265       if (priv->dpy == dpy) {
 266          *prev = priv->next;
 267          break;
 268       }
 269    }
 270    _XUnlockMutex(_Xglobal_lock);
 271
 272    glx_display_free(priv);
 273
 274    return 1;
 275 }
 276
 277 /*
 278 ** Query the version of the GLX extension.  This procedure works even if
 279 ** the client extension is not completely set up.
 280 */
 281 static Bool
 282 QueryVersion(Display * dpy, int opcode, int *major, int *minor)
 283 {
 284    xcb_connection_t *c = XGetXCBConnection(dpy);
 285    xcb_glx_query_version_reply_t *reply = xcb_glx_query_version_reply(c,
 286                                                                       xcb_glx_query_version
 287                                                                       (c,
 288                                                                        GLX_MAJOR_VERSION,
 289                                                                        GLX_MINOR_VERSION),
 290                                                                       NULL);
 291
 292    if (!reply)
 293      return GL_FALSE;
 294
 295    if (reply->major_version != GLX_MAJOR_VERSION) {
 296       free(reply);
 297       return GL_FALSE;
 298    }
 299    *major = reply->major_version;
 300    *minor = min(reply->minor_version, GLX_MINOR_VERSION);
 301    free(reply);
 302    return GL_TRUE;
 303 }
 304
 305 /*
 306  * We don't want to enable this GLX_OML_swap_method in glxext.h,
 307  * because we can't support it.  The X server writes it out though,
 308  * so we should handle it somehow, to avoid false warnings.
 309  */
 310 enum {
 311     IGNORE_GLX_SWAP_METHOD_OML = 0x8060
 312 };
 313
 314
 315 static GLint
 316 convert_from_x_visual_type(int visualType)
 317 {
 318    static const int glx_visual_types[] = {
 319       GLX_STATIC_GRAY, GLX_GRAY_SCALE,
 320       GLX_STATIC_COLOR, GLX_PSEUDO_COLOR,
 321       GLX_TRUE_COLOR, GLX_DIRECT_COLOR
 322    };
 323
 324    if (visualType < ARRAY_SIZE(glx_visual_types))
 325       return glx_visual_types[visualType];
 326
 327    return GLX_NONE;
 328 }
 329
 330 /*
 331  * getVisualConfigs uses the !tagged_only path.
 332  * getFBConfigs uses the tagged_only path.
 333  */
 334 _X_HIDDEN void
 335 __glXInitializeVisualConfigFromTags(struct glx_config * config, int count,
 336                                     const INT32 * bp, Bool tagged_only,
 337                                     Bool fbconfig_style_tags)
 338 {
 339    int i;
 340
 341    if (!tagged_only) {
 342       /* Copy in the first set of properties */
 343       config->visualID = *bp++;
 344
 345       config->visualType = convert_from_x_visual_type(*bp++);
 346
 347       config->rgbMode = *bp++;
 348
 349       config->redBits = *bp++;
 350       config->greenBits = *bp++;
 351       config->blueBits = *bp++;
 352       config->alphaBits = *bp++;
 353       config->accumRedBits = *bp++;
 354       config->accumGreenBits = *bp++;
 355       config->accumBlueBits = *bp++;
 356       config->accumAlphaBits = *bp++;
 357
 358       config->doubleBufferMode = *bp++;
 359       config->stereoMode = *bp++;
 360
 361       config->rgbBits = *bp++;
 362       config->depthBits = *bp++;
 363       config->stencilBits = *bp++;
 364       config->numAuxBuffers = *bp++;
 365       config->level = *bp++;
 366
 367 #ifdef GLX_USE_APPLEGL
 368        /* AppleSGLX supports pixmap and pbuffers with all config. */
 369        config->drawableType = GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT;
 370        /* Unfortunately this can create an ABI compatibility problem. */
 371        count -= 18;
 372 #else
 373       count -= __GLX_MIN_CONFIG_PROPS;
 374 #endif
 375    }
 376
 377    /*
 378     ** Additional properties may be in a list at the end
 379     ** of the reply.  They are in pairs of property type
 380     ** and property value.
 381     */
 382
 383 #define FETCH_OR_SET(tag) \
 384     config-> tag = ( fbconfig_style_tags ) ? *bp++ : 1
 385
 386    for (i = 0; i < count; i += 2) {
 387       long int tag = *bp++;
 388
 389       switch (tag) {
 390       case GLX_RGBA:
 391          FETCH_OR_SET(rgbMode);
 392          break;
 393       case GLX_BUFFER_SIZE:
 394          config->rgbBits = *bp++;
 395          break;
 396       case GLX_LEVEL:
 397          config->level = *bp++;
 398          break;
 399       case GLX_DOUBLEBUFFER:
 400          FETCH_OR_SET(doubleBufferMode);
 401          break;
 402       case GLX_STEREO:
 403          FETCH_OR_SET(stereoMode);
 404          break;
 405       case GLX_AUX_BUFFERS:
 406          config->numAuxBuffers = *bp++;
 407          break;
 408       case GLX_RED_SIZE:
 409          config->redBits = *bp++;
 410          break;
 411       case GLX_GREEN_SIZE:
 412          config->greenBits = *bp++;
 413          break;
 414       case GLX_BLUE_SIZE:
 415          config->blueBits = *bp++;
 416          break;
 417       case GLX_ALPHA_SIZE:
 418          config->alphaBits = *bp++;
 419          break;
 420       case GLX_DEPTH_SIZE:
 421          config->depthBits = *bp++;
 422          break;
 423       case GLX_STENCIL_SIZE:
 424          config->stencilBits = *bp++;
 425          break;
 426       case GLX_ACCUM_RED_SIZE:
 427          config->accumRedBits = *bp++;
 428          break;
 429       case GLX_ACCUM_GREEN_SIZE:
 430          config->accumGreenBits = *bp++;
 431          break;
 432       case GLX_ACCUM_BLUE_SIZE:
 433          config->accumBlueBits = *bp++;
 434          break;
 435       case GLX_ACCUM_ALPHA_SIZE:
 436          config->accumAlphaBits = *bp++;
 437          break;
 438       case GLX_VISUAL_CAVEAT_EXT:
 439          config->visualRating = *bp++;
 440          break;
 441       case GLX_X_VISUAL_TYPE:
 442          config->visualType = *bp++;
 443          break;
 444       case GLX_TRANSPARENT_TYPE:
 445          config->transparentPixel = *bp++;
 446          break;
 447       case GLX_TRANSPARENT_INDEX_VALUE:
 448          config->transparentIndex = *bp++;
 449          break;
 450       case GLX_TRANSPARENT_RED_VALUE:
 451          config->transparentRed = *bp++;
 452          break;
 453       case GLX_TRANSPARENT_GREEN_VALUE:
 454          config->transparentGreen = *bp++;
 455          break;
 456       case GLX_TRANSPARENT_BLUE_VALUE:
 457          config->transparentBlue = *bp++;
 458          break;
 459       case GLX_TRANSPARENT_ALPHA_VALUE:
 460          config->transparentAlpha = *bp++;
 461          break;
 462       case GLX_VISUAL_ID:
 463          config->visualID = *bp++;
 464          break;
 465       case GLX_DRAWABLE_TYPE:
 466          config->drawableType = *bp++;
 467 #ifdef GLX_USE_APPLEGL
 468          /* AppleSGLX supports pixmap and pbuffers with all config. */
 469          config->drawableType |= GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT;
 470 #endif
 471          break;
 472       case GLX_RENDER_TYPE:
 473          config->renderType = *bp++;
 474          break;
 475       case GLX_X_RENDERABLE:
 476          config->xRenderable = *bp++;
 477          break;
 478       case GLX_FBCONFIG_ID:
 479          config->fbconfigID = *bp++;
 480          break;
 481       case GLX_MAX_PBUFFER_WIDTH:
 482          config->maxPbufferWidth = *bp++;
 483          break;
 484       case GLX_MAX_PBUFFER_HEIGHT:
 485          config->maxPbufferHeight = *bp++;
 486          break;
 487       case GLX_MAX_PBUFFER_PIXELS:
 488          config->maxPbufferPixels = *bp++;
 489          break;
 490 #ifndef GLX_USE_APPLEGL
 491       case GLX_OPTIMAL_PBUFFER_WIDTH_SGIX:
 492          config->optimalPbufferWidth = *bp++;
 493          break;
 494       case GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX:
 495          config->optimalPbufferHeight = *bp++;
 496          break;
 497       case GLX_VISUAL_SELECT_GROUP_SGIX:
 498          config->visualSelectGroup = *bp++;
 499          break;
 500       case GLX_SWAP_METHOD_OML:
 501          config->swapMethod = *bp++;
 502          break;
 503 #endif
 504       case GLX_SAMPLE_BUFFERS_SGIS:
 505          config->sampleBuffers = *bp++;
 506          break;
 507       case GLX_SAMPLES_SGIS:
 508          config->samples = *bp++;
 509          break;
 510 #ifdef GLX_USE_APPLEGL
 511       case IGNORE_GLX_SWAP_METHOD_OML:
 512          /* We ignore this tag.  See the comment above this function. */
 513          ++bp;
 514          break;
 515 #else
 516       case GLX_BIND_TO_TEXTURE_RGB_EXT:
 517          config->bindToTextureRgb = *bp++;
 518          break;
 519       case GLX_BIND_TO_TEXTURE_RGBA_EXT:
 520          config->bindToTextureRgba = *bp++;
 521          break;
 522       case GLX_BIND_TO_MIPMAP_TEXTURE_EXT:
 523          config->bindToMipmapTexture = *bp++;
 524          break;
 525       case GLX_BIND_TO_TEXTURE_TARGETS_EXT:
 526          config->bindToTextureTargets = *bp++;
 527          break;
 528       case GLX_Y_INVERTED_EXT:
 529          config->yInverted = *bp++;
 530          break;
 531 #endif
 532       case GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT:
 533          config->sRGBCapable = *bp++;
 534          break;
 535
 536       case GLX_USE_GL:
 537          if (fbconfig_style_tags)
 538             bp++;
 539          break;
 540       case None:
 541          i = count;
 542          break;
 543       default:
 544          if(getenv("LIBGL_DIAGNOSTIC")) {
 545              long int tagvalue = *bp++;
 546              fprintf(stderr, "WARNING: unknown GLX tag from server: "
 547                      "tag 0x%lx value 0x%lx\n", tag, tagvalue);
 548          } else {
 549              /* Ignore the unrecognized tag's value */
 550              bp++;
 551          }
 552          break;
 553       }
 554    }
 555
 556    config->renderType =
 557       (config->rgbMode) ? GLX_RGBA_BIT : GLX_COLOR_INDEX_BIT;
 558 }
 559
 560 static struct glx_config *
 561 createConfigsFromProperties(Display * dpy, int nvisuals, int nprops,
 562                             int screen, GLboolean tagged_only)
 563 {
 564    INT32 buf[__GLX_TOTAL_CONFIG], *props;
 565    unsigned prop_size;
 566    struct glx_config *modes, *m;
 567    int i;
 568
 569    if (nprops == 0)
 570       return NULL;
 571
 572    /* FIXME: Is the __GLX_MIN_CONFIG_PROPS test correct for FBconfigs? */
 573
 574    /* Check number of properties */
 575    if (nprops < __GLX_MIN_CONFIG_PROPS || nprops > __GLX_MAX_CONFIG_PROPS)
 576       return NULL;
 577
 578    /* Allocate memory for our config structure */
 579    modes = glx_config_create_list(nvisuals);
 580    if (!modes)
 581       return NULL;
 582
 583    prop_size = nprops * __GLX_SIZE_INT32;
 584    if (prop_size <= sizeof(buf))
 585       props = buf;
 586    else
 587       props = malloc(prop_size);
 588
 589    /* Read each config structure and convert it into our format */
 590    m = modes;
 591    for (i = 0; i < nvisuals; i++) {
 592       _XRead(dpy, (char *) props, prop_size);
 593 #ifdef GLX_USE_APPLEGL
 594        /* Older X servers don't send this so we default it here. */
 595       m->drawableType = GLX_WINDOW_BIT;
 596 #else
 597       /*
 598        * The XQuartz 2.3.2.1 X server doesn't set this properly, so
 599        * set the proper bits here.
 600        * AppleSGLX supports windows, pixmaps, and pbuffers with all config.
 601        */
 602       m->drawableType = GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT;
 603 #endif
 604        __glXInitializeVisualConfigFromTags(m, nprops, props,
 605                                           tagged_only, GL_TRUE);
 606       m->screen = screen;
 607       m = m->next;
 608    }
 609
 610    if (props != buf)
 611       free(props);
 612
 613    return modes;
 614 }
 615
 616 static GLboolean
 617 getVisualConfigs(struct glx_screen *psc,
 618                   struct glx_display *priv, int screen)
 619 {
 620    xGLXGetVisualConfigsReq *req;
 621    xGLXGetVisualConfigsReply reply;
 622    Display *dpy = priv->dpy;
 623
 624    LockDisplay(dpy);
 625
 626    psc->visuals = NULL;
 627    GetReq(GLXGetVisualConfigs, req);
 628    req->reqType = priv->majorOpcode;
 629    req->glxCode = X_GLXGetVisualConfigs;
 630    req->screen = screen;
 631
 632    if (!_XReply(dpy, (xReply *) & reply, 0, False))
 633       goto out;
 634
 635    psc->visuals = createConfigsFromProperties(dpy,
 636                                               reply.numVisuals,
 637                                               reply.numProps,
 638                                               screen, GL_FALSE);
 639
 640  out:
 641    UnlockDisplay(dpy);
 642    return psc->visuals != NULL;
 643 }
 644
 645 static GLboolean
 646  getFBConfigs(struct glx_screen *psc, struct glx_display *priv, int screen)
 647 {
 648    xGLXGetFBConfigsReq *fb_req;
 649    xGLXGetFBConfigsSGIXReq *sgi_req;
 650    xGLXVendorPrivateWithReplyReq *vpreq;
 651    xGLXGetFBConfigsReply reply;
 652    Display *dpy = priv->dpy;
 653
 654    psc->serverGLXexts =
 655       __glXQueryServerString(dpy, priv->majorOpcode, screen, GLX_EXTENSIONS);
 656
 657    LockDisplay(dpy);
 658
 659    psc->configs = NULL;
 660    if (atof(priv->serverGLXversion) >= 1.3) {
 661       GetReq(GLXGetFBConfigs, fb_req);
 662       fb_req->reqType = priv->majorOpcode;
 663       fb_req->glxCode = X_GLXGetFBConfigs;
 664       fb_req->screen = screen;
 665    }
 666    else if (strstr(psc->serverGLXexts, "GLX_SGIX_fbconfig") != NULL) {
 667       GetReqExtra(GLXVendorPrivateWithReply,
 668                   sz_xGLXGetFBConfigsSGIXReq -
 669                   sz_xGLXVendorPrivateWithReplyReq, vpreq);
 670       sgi_req = (xGLXGetFBConfigsSGIXReq *) vpreq;
 671       sgi_req->reqType = priv->majorOpcode;
 672       sgi_req->glxCode = X_GLXVendorPrivateWithReply;
 673       sgi_req->vendorCode = X_GLXvop_GetFBConfigsSGIX;
 674       sgi_req->screen = screen;
 675    }
 676    else
 677       goto out;
 678
 679    if (!_XReply(dpy, (xReply *) & reply, 0, False))
 680       goto out;
 681
 682    psc->configs = createConfigsFromProperties(dpy,
 683                                               reply.numFBConfigs,
 684                                               reply.numAttribs * 2,
 685                                               screen, GL_TRUE);
 686
 687  out:
 688    UnlockDisplay(dpy);
 689    return psc->configs != NULL;
 690 }
 691
 692 _X_HIDDEN Bool
 693 glx_screen_init(struct glx_screen *psc,
 694                  int screen, struct glx_display * priv)
 695 {
 696    /* Initialize per screen dynamic client GLX extensions */
 697    psc->ext_list_first_time = GL_TRUE;
 698    psc->scr = screen;
 699    psc->dpy = priv->dpy;
 700    psc->display = priv;
 701
 702    getVisualConfigs(psc, priv, screen);
 703    getFBConfigs(psc, priv, screen);
 704
 705    return GL_TRUE;
 706 }
 707
 708 _X_HIDDEN void
 709 glx_screen_cleanup(struct glx_screen *psc)
 710 {
 711    if (psc->configs) {
 712       glx_config_destroy_list(psc->configs);
 713       free(psc->effectiveGLXexts);
 714       psc->configs = NULL;   /* NOTE: just for paranoia */
 715    }
 716    if (psc->visuals) {
 717       glx_config_destroy_list(psc->visuals);
 718       psc->visuals = NULL;   /* NOTE: just for paranoia */
 719    }
 720    free((char *) psc->serverGLXexts);
 721 }
 722
 723 /*
 724 ** Allocate the memory for the per screen configs for each screen.
 725 ** If that works then fetch the per screen configs data.
 726 */
 727 static Bool
 728 AllocAndFetchScreenConfigs(Display * dpy, struct glx_display * priv)
 729 {
 730    struct glx_screen *psc;
 731    GLint i, screens;
 732
 733    /*
 734     ** First allocate memory for the array of per screen configs.
 735     */
 736    screens = ScreenCount(dpy);
 737    priv->screens = malloc(screens * sizeof *priv->screens);
 738    if (!priv->screens)
 739       return GL_FALSE;
 740
 741    priv->serverGLXversion =
 742       __glXQueryServerString(dpy, priv->majorOpcode, 0, GLX_VERSION);
 743    if (priv->serverGLXversion == NULL) {
 744       FreeScreenConfigs(priv);
 745       return GL_FALSE;
 746    }
 747
 748    for (i = 0; i < screens; i++, psc++) {
 749       psc = NULL;
 750 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
 751       if (priv->dri2Display)
 752          psc = (*priv->dri2Display->createScreen) (i, priv);
 753       if (psc == NULL && priv->driDisplay)
 754          psc = (*priv->driDisplay->createScreen) (i, priv);
 755       if (psc == NULL && priv->driswDisplay)
 756          psc = (*priv->driswDisplay->createScreen) (i, priv);
 757 #endif
 758 #if defined(GLX_USE_APPLEGL)
 759       if (psc == NULL)
 760          psc = applegl_create_screen(i, priv);
 761 #else
 762       if (psc == NULL)
 763          psc = indirect_create_screen(i, priv);
 764 #endif
 765       priv->screens[i] = psc;
 766    }
 767    SyncHandle();
 768    return GL_TRUE;
 769 }
 770
 771 /*
 772 ** Initialize the client side extension code.
 773 */
 774  _X_HIDDEN struct glx_display *
 775 __glXInitialize(Display * dpy)
 776 {
 777    struct glx_display *dpyPriv, *d;
 778 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
 779    Bool glx_direct, glx_accel;
 780 #endif
 781    int i;
 782
 783    _XLockMutex(_Xglobal_lock);
 784
 785    for (dpyPriv = glx_displays; dpyPriv; dpyPriv = dpyPriv->next) {
 786       if (dpyPriv->dpy == dpy) {
 787          _XUnlockMutex(_Xglobal_lock);
 788          return dpyPriv;
 789       }
 790    }
 791
 792    /* Drop the lock while we create the display private. */
 793    _XUnlockMutex(_Xglobal_lock);
 794
 795    dpyPriv = calloc(1, sizeof *dpyPriv);
 796    if (!dpyPriv)
 797       return NULL;
 798
 799    dpyPriv->codes = XInitExtension(dpy, __glXExtensionName);
 800    if (!dpyPriv->codes) {
 801       free(dpyPriv);
 802       _XUnlockMutex(_Xglobal_lock);
 803       return NULL;
 804    }
 805
 806    dpyPriv->dpy = dpy;
 807    dpyPriv->majorOpcode = dpyPriv->codes->major_opcode;
 808    dpyPriv->serverGLXvendor = 0x0;
 809    dpyPriv->serverGLXversion = 0x0;
 810
 811    /* See if the versions are compatible.  This GLX implementation does not
 812     * work with servers that only support GLX 1.0.
 813     */
 814    if (!QueryVersion(dpy, dpyPriv->majorOpcode,
 815                      &dpyPriv->majorVersion, &dpyPriv->minorVersion)
 816        || (dpyPriv->majorVersion == 1 && dpyPriv->minorVersion < 1)) {
 817       free(dpyPriv);
 818       _XUnlockMutex(_Xglobal_lock);
 819       return NULL;
 820    }
 821
 822    for (i = 0; i < __GLX_NUMBER_EVENTS; i++) {
 823       XESetWireToEvent(dpy, dpyPriv->codes->first_event + i, __glXWireToEvent);
 824       XESetEventToWire(dpy, dpyPriv->codes->first_event + i, __glXEventToWire);
 825    }
 826
 827    XESetCloseDisplay(dpy, dpyPriv->codes->extension, __glXCloseDisplay);
 828    XESetErrorString (dpy, dpyPriv->codes->extension,__glXErrorString);
 829
 830    dpyPriv->glXDrawHash = __glxHashCreate();
 831
 832 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
 833    glx_direct = (getenv("LIBGL_ALWAYS_INDIRECT") == NULL);
 834    glx_accel = (getenv("LIBGL_ALWAYS_SOFTWARE") == NULL);
 835
 836    dpyPriv->drawHash = __glxHashCreate();
 837
 838    /*
 839     ** Initialize the direct rendering per display data and functions.
 840     ** Note: This _must_ be done before calling any other DRI routines
 841     ** (e.g., those called in AllocAndFetchScreenConfigs).
 842     */
 843    if (glx_direct && glx_accel) {
 844       dpyPriv->dri2Display = dri2CreateDisplay(dpy);
 845       dpyPriv->driDisplay = driCreateDisplay(dpy);
 846    }
 847    if (glx_direct)
 848       dpyPriv->driswDisplay = driswCreateDisplay(dpy);
 849 #endif
 850
 851 #ifdef GLX_USE_APPLEGL
 852    if (!applegl_create_display(dpyPriv)) {
 853       free(dpyPriv);
 854       return NULL;
 855    }
 856 #endif
 857    if (!AllocAndFetchScreenConfigs(dpy, dpyPriv)) {
 858       free(dpyPriv);
 859       return NULL;
 860    }
 861
 862    __glX_send_client_info(dpyPriv);
 863
 864    /* Grab the lock again and add the dispay private, unless somebody
 865     * beat us to initializing on this display in the meantime. */
 866    _XLockMutex(_Xglobal_lock);
 867
 868    for (d = glx_displays; d; d = d->next) {
 869       if (d->dpy == dpy) {
 870          _XUnlockMutex(_Xglobal_lock);
 871          glx_display_free(dpyPriv);
 872          return d;
 873       }
 874    }
 875
 876    dpyPriv->next = glx_displays;
 877    glx_displays = dpyPriv;
 878
 879     _XUnlockMutex(_Xglobal_lock);
 880
 881    return dpyPriv;
 882 }
 883
 884 /*
 885 ** Setup for sending a GLX command on dpy.  Make sure the extension is
 886 ** initialized.  Try to avoid calling __glXInitialize as its kinda slow.
 887 */
 888 _X_HIDDEN CARD8
 889 __glXSetupForCommand(Display * dpy)
 890 {
 891     struct glx_context *gc;
 892     struct glx_display *priv;
 893
 894    /* If this thread has a current context, flush its rendering commands */
 895    gc = __glXGetCurrentContext();
 896    if (gc->currentDpy) {
 897       /* Flush rendering buffer of the current context, if any */
 898       (void) __glXFlushRenderBuffer(gc, gc->pc);
 899
 900       if (gc->currentDpy == dpy) {
 901          /* Use opcode from gc because its right */
 902          return gc->majorOpcode;
 903       }
 904       else {
 905          /*
 906           ** Have to get info about argument dpy because it might be to
 907           ** a different server
 908           */
 909       }
 910    }
 911
 912    /* Forced to lookup extension via the slow initialize route */
 913    priv = __glXInitialize(dpy);
 914    if (!priv) {
 915       return 0;
 916    }
 917    return priv->majorOpcode;
 918 }
 919
 920 /**
 921  * Flush the drawing command transport buffer.
 922  *
 923  * \param ctx  Context whose transport buffer is to be flushed.
 924  * \param pc   Pointer to first unused buffer location.
 925  *
 926  * \todo
 927  * Modify this function to use \c ctx->pc instead of the explicit
 928  * \c pc parameter.
 929  */
 930 _X_HIDDEN GLubyte *
 931 __glXFlushRenderBuffer(struct glx_context * ctx, GLubyte * pc)
 932 {
 933    Display *const dpy = ctx->currentDpy;
 934    xcb_connection_t *c = XGetXCBConnection(dpy);
 935    const GLint size = pc - ctx->buf;
 936
 937    if ((dpy != NULL) && (size > 0)) {
 938       xcb_glx_render(c, ctx->currentContextTag, size,
 939                      (const uint8_t *) ctx->buf);
 940    }
 941
 942    /* Reset pointer and return it */
 943    ctx->pc = ctx->buf;
 944    return ctx->pc;
 945 }
 946
 947
 948 /**
 949  * Send a portion of a GLXRenderLarge command to the server.  The advantage of
 950  * this function over \c __glXSendLargeCommand is that callers can use the
 951  * data buffer in the GLX context and may be able to avoid allocating an
 952  * extra buffer.  The disadvantage is the clients will have to do more
 953  * GLX protocol work (i.e., calculating \c totalRequests, etc.).
 954  *
 955  * \sa __glXSendLargeCommand
 956  *
 957  * \param gc             GLX context
 958  * \param requestNumber  Which part of the whole command is this?  The first
 959  *                       request is 1.
 960  * \param totalRequests  How many requests will there be?
 961  * \param data           Command data.
 962  * \param dataLen        Size, in bytes, of the command data.
 963  */
 964 _X_HIDDEN void
 965 __glXSendLargeChunk(struct glx_context * gc, GLint requestNumber,
 966                     GLint totalRequests, const GLvoid * data, GLint dataLen)
 967 {
 968    Display *dpy = gc->currentDpy;
 969    xcb_connection_t *c = XGetXCBConnection(dpy);
 970    xcb_glx_render_large(c, gc->currentContextTag, requestNumber,
 971                         totalRequests, dataLen, data);
 972 }
 973
 974
 975 /**
 976  * Send a command that is too large for the GLXRender protocol request.
 977  *
 978  * Send a large command, one that is too large for some reason to
 979  * send using the GLXRender protocol request.  One reason to send
 980  * a large command is to avoid copying the data.
 981  *
 982  * \param ctx        GLX context
 983  * \param header     Header data.
 984  * \param headerLen  Size, in bytes, of the header data.  It is assumed that
 985  *                   the header data will always be small enough to fit in
 986  *                   a single X protocol packet.
 987  * \param data       Command data.
 988  * \param dataLen    Size, in bytes, of the command data.
 989  */
 990 _X_HIDDEN void
 991 __glXSendLargeCommand(struct glx_context * ctx,
 992                       const GLvoid * header, GLint headerLen,
 993                       const GLvoid * data, GLint dataLen)
 994 {
 995    GLint maxSize;
 996    GLint totalRequests, requestNumber;
 997
 998    /*
 999     ** Calculate the maximum amount of data can be stuffed into a single
1000     ** packet.  sz_xGLXRenderReq is added because bufSize is the maximum
1001     ** packet size minus sz_xGLXRenderReq.
1002     */
1003    maxSize = (ctx->bufSize + sz_xGLXRenderReq) - sz_xGLXRenderLargeReq;
1004    totalRequests = 1 + (dataLen / maxSize);
1005    if (dataLen % maxSize)
1006       totalRequests++;
1007
1008    /*
1009     ** Send all of the command, except the large array, as one request.
1010     */
1011    assert(headerLen <= maxSize);
1012    __glXSendLargeChunk(ctx, 1, totalRequests, header, headerLen);
1013
1014    /*
1015     ** Send enough requests until the whole array is sent.
1016     */
1017    for (requestNumber = 2; requestNumber <= (totalRequests - 1);
1018         requestNumber++) {
1019       __glXSendLargeChunk(ctx, requestNumber, totalRequests, data, maxSize);
1020       data = (const GLvoid *) (((const GLubyte *) data) + maxSize);
1021       dataLen -= maxSize;
1022       assert(dataLen > 0);
1023    }
1024
1025    assert(dataLen <= maxSize);
1026    __glXSendLargeChunk(ctx, requestNumber, totalRequests, data, dataLen);
1027 }
1028
1029 /************************************************************************/
1030
1031 #ifdef DEBUG
1032 _X_HIDDEN void
1033 __glXDumpDrawBuffer(struct glx_context * ctx)
1034 {
1035    GLubyte *p = ctx->buf;
1036    GLubyte *end = ctx->pc;
1037    GLushort opcode, length;
1038
1039    while (p < end) {
1040       /* Fetch opcode */
1041       opcode = *((GLushort *) p);
1042       length = *((GLushort *) (p + 2));
1043       printf("%2x: %5d: ", opcode, length);
1044       length -= 4;
1045       p += 4;
1046       while (length > 0) {
1047          printf("%08x ", *((unsigned *) p));
1048          p += 4;
1049          length -= 4;
1050       }
1051       printf("\n");
1052    }
1053 }
1054 #endif