src/gallium/state_trackers/glx/xlib/glx_api.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
   5  * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * 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  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  21  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  22  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  23  * OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26
  27 /**
  28  * "Fake" GLX API implemented in terms of the XMesa*() functions.
  29  */
  30
  31
  32
  33 #define GLX_GLXEXT_PROTOTYPES
  34 #include "GL/glx.h"
  35
  36 #include <stdio.h>
  37 #include <string.h>
  38 #include <X11/Xmd.h>
  39 #include <GL/glxproto.h>
  40
  41 #include "xm_api.h"
  42 #include "main/imports.h"
  43 #include "main/errors.h"
  44 #include "util/u_math.h"
  45
  46 /* An "Atrribs/Attribs" typo was fixed in glxproto.h in Nov 2014.
  47  * This is in case we don't have the updated header.
  48  */
  49 #if !defined(X_GLXCreateContextAttribsARB) && \
  50      defined(X_GLXCreateContextAtrribsARB)
  51 #define X_GLXCreateContextAttribsARB X_GLXCreateContextAtrribsARB
  52 #endif
  53
  54 /* This indicates the client-side GLX API and GLX encoder version. */
  55 #define CLIENT_MAJOR_VERSION 1
  56 #define CLIENT_MINOR_VERSION 4  /* but don't have 1.3's pbuffers, etc yet */
  57
  58 /* This indicates the server-side GLX decoder version.
  59  * GLX 1.4 indicates OpenGL 1.3 support
  60  */
  61 #define SERVER_MAJOR_VERSION 1
  62 #define SERVER_MINOR_VERSION 4
  63
  64 /* Who implemented this GLX? */
  65 #define VENDOR "Brian Paul"
  66
  67 #define EXTENSIONS \
  68    "GLX_MESA_copy_sub_buffer " \
  69    "GLX_MESA_pixmap_colormap " \
  70    "GLX_MESA_release_buffers " \
  71    "GLX_ARB_create_context " \
  72    "GLX_ARB_create_context_profile " \
  73    "GLX_ARB_get_proc_address " \
  74    "GLX_EXT_create_context_es_profile " \
  75    "GLX_EXT_create_context_es2_profile " \
  76    "GLX_EXT_texture_from_pixmap " \
  77    "GLX_EXT_visual_info " \
  78    "GLX_EXT_visual_rating " \
  79    /*"GLX_SGI_video_sync "*/ \
  80    "GLX_SGIX_fbconfig " \
  81    "GLX_SGIX_pbuffer "
  82
  83 #define DEFAULT_DIRECT GL_TRUE
  84
  85
  86 /** XXX this could be based on gallium's max texture size */
  87 #define PBUFFER_MAX_SIZE 16384
  88
  89
  90 /**
  91  * The GLXContext typedef is defined as a pointer to this structure.
  92  */
  93 struct __GLXcontextRec
  94 {
  95    Display *currentDpy;
  96    GLboolean isDirect;
  97    GLXDrawable currentDrawable;
  98    GLXDrawable currentReadable;
  99    XID xid;
 100
 101    XMesaContext xmesaContext;
 102 };
 103
 104
 105
 106 static pipe_tsd ContextTSD;
 107
 108 /** Set current context for calling thread */
 109 static void
 110 SetCurrentContext(GLXContext c)
 111 {
 112    pipe_tsd_set(&ContextTSD, c);
 113 }
 114
 115 /** Get current context for calling thread */
 116 static GLXContext
 117 GetCurrentContext(void)
 118 {
 119    return pipe_tsd_get(&ContextTSD);
 120 }
 121
 122
 123
 124 /**********************************************************************/
 125 /***                       GLX Visual Code                          ***/
 126 /**********************************************************************/
 127
 128 #define DONT_CARE -1
 129
 130
 131 static XMesaVisual *VisualTable = NULL;
 132 static int NumVisuals = 0;
 133
 134
 135
 136 /* Macro to handle c_class vs class field name in XVisualInfo struct */
 137 #if defined(__cplusplus) || defined(c_plusplus)
 138 #define CLASS c_class
 139 #else
 140 #define CLASS class
 141 #endif
 142
 143
 144
 145 /*
 146  * Test if the given XVisualInfo is usable for Mesa rendering.
 147  */
 148 static GLboolean
 149 is_usable_visual( XVisualInfo *vinfo )
 150 {
 151    switch (vinfo->CLASS) {
 152       case StaticGray:
 153       case GrayScale:
 154          /* Any StaticGray/GrayScale visual works in RGB or CI mode */
 155          return GL_TRUE;
 156       case StaticColor:
 157       case PseudoColor:
 158          /* Any StaticColor/PseudoColor visual of at least 4 bits */
 159          if (vinfo->depth>=4) {
 160             return GL_TRUE;
 161          }
 162          else {
 163             return GL_FALSE;
 164          }
 165       case TrueColor:
 166       case DirectColor:
 167          /* Any depth of TrueColor or DirectColor works in RGB mode */
 168          return GL_TRUE;
 169       default:
 170          /* This should never happen */
 171          return GL_FALSE;
 172    }
 173 }
 174
 175
 176 /*
 177  * Given an XVisualInfo and RGB, Double, and Depth buffer flags, save the
 178  * configuration in our list of GLX visuals.
 179  */
 180 static XMesaVisual
 181 save_glx_visual( Display *dpy, XVisualInfo *vinfo,
 182                  GLboolean rgbFlag, GLboolean alphaFlag, GLboolean dbFlag,
 183                  GLboolean stereoFlag,
 184                  GLint depth_size, GLint stencil_size,
 185                  GLint accumRedSize, GLint accumGreenSize,
 186                  GLint accumBlueSize, GLint accumAlphaSize,
 187                  GLint level, GLint numAuxBuffers, GLuint num_samples )
 188 {
 189    GLboolean ximageFlag = GL_TRUE;
 190    XMesaVisual xmvis;
 191    GLint i;
 192    GLboolean comparePointers;
 193
 194    if (!rgbFlag)
 195       return NULL;
 196
 197    if (dbFlag) {
 198       /* Check if the MESA_BACK_BUFFER env var is set */
 199       char *backbuffer = getenv("MESA_BACK_BUFFER");
 200       if (backbuffer) {
 201          if (backbuffer[0]=='p' || backbuffer[0]=='P') {
 202             ximageFlag = GL_FALSE;
 203          }
 204          else if (backbuffer[0]=='x' || backbuffer[0]=='X') {
 205             ximageFlag = GL_TRUE;
 206          }
 207          else {
 208             _mesa_warning(NULL, "Mesa: invalid value for MESA_BACK_BUFFER environment variable, using an XImage.");
 209          }
 210       }
 211    }
 212
 213    if (stereoFlag) {
 214       /* stereo not supported */
 215       return NULL;
 216    }
 217
 218    if (stencil_size > 0 && depth_size > 0)
 219       depth_size = 24;
 220
 221    /* Comparing IDs uses less memory but sometimes fails. */
 222    /* XXX revisit this after 3.0 is finished. */
 223    if (getenv("MESA_GLX_VISUAL_HACK"))
 224       comparePointers = GL_TRUE;
 225    else
 226       comparePointers = GL_FALSE;
 227
 228    /* Force the visual to have an alpha channel */
 229    if (rgbFlag && getenv("MESA_GLX_FORCE_ALPHA"))
 230       alphaFlag = GL_TRUE;
 231
 232    /* First check if a matching visual is already in the list */
 233    for (i=0; i<NumVisuals; i++) {
 234       XMesaVisual v = VisualTable[i];
 235       if (v->display == dpy
 236           && v->mesa_visual.level == level
 237           && v->mesa_visual.numAuxBuffers == numAuxBuffers
 238           && v->mesa_visual.samples == num_samples
 239           && v->ximage_flag == ximageFlag
 240           && v->mesa_visual.doubleBufferMode == dbFlag
 241           && v->mesa_visual.stereoMode == stereoFlag
 242           && (v->mesa_visual.alphaBits > 0) == alphaFlag
 243           && (v->mesa_visual.depthBits >= depth_size || depth_size == 0)
 244           && (v->mesa_visual.stencilBits >= stencil_size || stencil_size == 0)
 245           && (v->mesa_visual.accumRedBits >= accumRedSize || accumRedSize == 0)
 246           && (v->mesa_visual.accumGreenBits >= accumGreenSize || accumGreenSize == 0)
 247           && (v->mesa_visual.accumBlueBits >= accumBlueSize || accumBlueSize == 0)
 248           && (v->mesa_visual.accumAlphaBits >= accumAlphaSize || accumAlphaSize == 0)) {
 249          /* now either compare XVisualInfo pointers or visual IDs */
 250          if ((!comparePointers && v->visinfo->visualid == vinfo->visualid)
 251              || (comparePointers && v->vishandle == vinfo)) {
 252             return v;
 253          }
 254       }
 255    }
 256
 257    /* Create a new visual and add it to the list. */
 258
 259    xmvis = XMesaCreateVisual( dpy, vinfo, rgbFlag, alphaFlag, dbFlag,
 260                               stereoFlag, ximageFlag,
 261                               depth_size, stencil_size,
 262                               accumRedSize, accumBlueSize,
 263                               accumBlueSize, accumAlphaSize, num_samples, level,
 264                               GLX_NONE_EXT );
 265    if (xmvis) {
 266       /* Save a copy of the pointer now so we can find this visual again
 267        * if we need to search for it in find_glx_visual().
 268        */
 269       xmvis->vishandle = vinfo;
 270       /* Allocate more space for additional visual */
 271       VisualTable = realloc(VisualTable, sizeof(XMesaVisual) * (NumVisuals + 1));
 272       /* add xmvis to the list */
 273       VisualTable[NumVisuals] = xmvis;
 274       NumVisuals++;
 275       /* XXX minor hack, because XMesaCreateVisual doesn't support an
 276        * aux buffers parameter.
 277        */
 278       xmvis->mesa_visual.numAuxBuffers = numAuxBuffers;
 279    }
 280    return xmvis;
 281 }
 282
 283
 284 /**
 285  * Return the default number of bits for the Z buffer.
 286  * If defined, use the MESA_GLX_DEPTH_BITS env var value.
 287  * Otherwise, use the DEFAULT_SOFTWARE_DEPTH_BITS constant.
 288  * XXX probably do the same thing for stencil, accum, etc.
 289  */
 290 static GLint
 291 default_depth_bits(void)
 292 {
 293    int zBits;
 294    const char *zEnv = getenv("MESA_GLX_DEPTH_BITS");
 295    if (zEnv)
 296       zBits = atoi(zEnv);
 297    else
 298       zBits = 24;
 299    return zBits;
 300 }
 301
 302 static GLint
 303 default_alpha_bits(void)
 304 {
 305    int aBits;
 306    const char *aEnv = getenv("MESA_GLX_ALPHA_BITS");
 307    if (aEnv)
 308       aBits = atoi(aEnv);
 309    else
 310       aBits = 0;
 311    return aBits;
 312 }
 313
 314 static GLint
 315 default_accum_bits(void)
 316 {
 317    return 16;
 318 }
 319
 320
 321
 322 /*
 323  * Create a GLX visual from a regular XVisualInfo.
 324  * This is called when Fake GLX is given an XVisualInfo which wasn't
 325  * returned by glXChooseVisual.  Since this is the first time we're
 326  * considering this visual we'll take a guess at reasonable values
 327  * for depth buffer size, stencil size, accum size, etc.
 328  * This is the best we can do with a client-side emulation of GLX.
 329  */
 330 static XMesaVisual
 331 create_glx_visual( Display *dpy, XVisualInfo *visinfo )
 332 {
 333    GLint zBits = default_depth_bits();
 334    GLint accBits = default_accum_bits();
 335    GLboolean alphaFlag = default_alpha_bits() > 0;
 336
 337    if (is_usable_visual( visinfo )) {
 338       /* Configure this visual as RGB, double-buffered, depth-buffered. */
 339       /* This is surely wrong for some people's needs but what else */
 340       /* can be done?  They should use glXChooseVisual(). */
 341       return save_glx_visual( dpy, visinfo,
 342                               GL_TRUE,   /* rgb */
 343                               alphaFlag, /* alpha */
 344                               GL_TRUE,   /* double */
 345                               GL_FALSE,  /* stereo */
 346                               zBits,
 347                               8,       /* stencil bits */
 348                               accBits, /* r */
 349                               accBits, /* g */
 350                               accBits, /* b */
 351                               accBits, /* a */
 352                               0,         /* level */
 353                               0,         /* numAux */
 354                               0          /* numSamples */
 355          );
 356    }
 357    else {
 358       _mesa_warning(NULL, "Mesa: error in glXCreateContext: bad visual\n");
 359       return NULL;
 360    }
 361 }
 362
 363
 364
 365 /*
 366  * Find the GLX visual associated with an XVisualInfo.
 367  */
 368 static XMesaVisual
 369 find_glx_visual( Display *dpy, XVisualInfo *vinfo )
 370 {
 371    int i;
 372
 373    /* try to match visual id */
 374    for (i=0;i<NumVisuals;i++) {
 375       if (VisualTable[i]->display==dpy
 376           && VisualTable[i]->visinfo->visualid == vinfo->visualid) {
 377          return VisualTable[i];
 378       }
 379    }
 380
 381    /* if that fails, try to match pointers */
 382    for (i=0;i<NumVisuals;i++) {
 383       if (VisualTable[i]->display==dpy && VisualTable[i]->vishandle==vinfo) {
 384          return VisualTable[i];
 385       }
 386    }
 387
 388    return NULL;
 389 }
 390
 391
 392 /**
 393  * Try to get an X visual which matches the given arguments.
 394  */
 395 static XVisualInfo *
 396 get_visual( Display *dpy, int scr, unsigned int depth, int xclass )
 397 {
 398    XVisualInfo temp, *vis;
 399    long mask;
 400    int n;
 401    unsigned int default_depth;
 402    int default_class;
 403
 404    mask = VisualScreenMask | VisualDepthMask | VisualClassMask;
 405    temp.screen = scr;
 406    temp.depth = depth;
 407    temp.CLASS = xclass;
 408
 409    default_depth = DefaultDepth(dpy,scr);
 410    default_class = DefaultVisual(dpy,scr)->CLASS;
 411
 412    if (depth==default_depth && xclass==default_class) {
 413       /* try to get root window's visual */
 414       temp.visualid = DefaultVisual(dpy,scr)->visualid;
 415       mask |= VisualIDMask;
 416    }
 417
 418    vis = XGetVisualInfo( dpy, mask, &temp, &n );
 419
 420    /* In case bits/pixel > 24, make sure color channels are still <=8 bits.
 421     * An SGI Infinite Reality system, for example, can have 30bpp pixels:
 422     * 10 bits per color channel.  Mesa's limited to a max of 8 bits/channel.
 423     */
 424    if (vis && depth > 24 && (xclass==TrueColor || xclass==DirectColor)) {
 425       if (util_bitcount((GLuint) vis->red_mask  ) <= 8 &&
 426           util_bitcount((GLuint) vis->green_mask) <= 8 &&
 427           util_bitcount((GLuint) vis->blue_mask ) <= 8) {
 428          return vis;
 429       }
 430       else {
 431          free((void *) vis);
 432          return NULL;
 433       }
 434    }
 435
 436    return vis;
 437 }
 438
 439
 440 /*
 441  * Retrieve the value of the given environment variable and find
 442  * the X visual which matches it.
 443  * Input:  dpy - the display
 444  *         screen - the screen number
 445  *         varname - the name of the environment variable
 446  * Return:  an XVisualInfo pointer to NULL if error.
 447  */
 448 static XVisualInfo *
 449 get_env_visual(Display *dpy, int scr, const char *varname)
 450 {
 451    char value[100], type[100];
 452    int depth, xclass = -1;
 453    XVisualInfo *vis;
 454
 455    if (!getenv( varname )) {
 456       return NULL;
 457    }
 458
 459    strncpy( value, getenv(varname), 100 );
 460    value[99] = 0;
 461
 462    sscanf( value, "%s %d", type, &depth );
 463
 464    if (strcmp(type,"TrueColor")==0)          xclass = TrueColor;
 465    else if (strcmp(type,"DirectColor")==0)   xclass = DirectColor;
 466    else if (strcmp(type,"PseudoColor")==0)   xclass = PseudoColor;
 467    else if (strcmp(type,"StaticColor")==0)   xclass = StaticColor;
 468    else if (strcmp(type,"GrayScale")==0)     xclass = GrayScale;
 469    else if (strcmp(type,"StaticGray")==0)    xclass = StaticGray;
 470
 471    if (xclass>-1 && depth>0) {
 472       vis = get_visual( dpy, scr, depth, xclass );
 473       if (vis) {
 474          return vis;
 475       }
 476    }
 477
 478    _mesa_warning(NULL, "GLX unable to find visual class=%s, depth=%d.",
 479                  type, depth);
 480
 481    return NULL;
 482 }
 483
 484
 485
 486 /*
 487  * Select an X visual which satisfies the RGBA flag and minimum depth.
 488  * Input:  dpy,
 489  *         screen - X display and screen number
 490  *         min_depth - minimum visual depth
 491  *         preferred_class - preferred GLX visual class or DONT_CARE
 492  * Return:  pointer to an XVisualInfo or NULL.
 493  */
 494 static XVisualInfo *
 495 choose_x_visual( Display *dpy, int screen, int min_depth,
 496                  int preferred_class )
 497 {
 498    XVisualInfo *vis;
 499    int xclass, visclass = 0;
 500    int depth;
 501
 502    /* First see if the MESA_RGB_VISUAL env var is defined */
 503    vis = get_env_visual( dpy, screen, "MESA_RGB_VISUAL" );
 504    if (vis) {
 505       return vis;
 506    }
 507    /* Otherwise, search for a suitable visual */
 508    if (preferred_class==DONT_CARE) {
 509       for (xclass=0;xclass<6;xclass++) {
 510          switch (xclass) {
 511          case 0:  visclass = TrueColor;    break;
 512          case 1:  visclass = DirectColor;  break;
 513          case 2:  visclass = PseudoColor;  break;
 514          case 3:  visclass = StaticColor;  break;
 515          case 4:  visclass = GrayScale;    break;
 516          case 5:  visclass = StaticGray;   break;
 517          }
 518          if (min_depth==0) {
 519             /* start with shallowest */
 520             for (depth=0;depth<=32;depth++) {
 521                if (visclass==TrueColor && depth==8) {
 522                   /* Special case:  try to get 8-bit PseudoColor before */
 523                   /* 8-bit TrueColor */
 524                   vis = get_visual( dpy, screen, 8, PseudoColor );
 525                   if (vis) {
 526                      return vis;
 527                   }
 528                }
 529                vis = get_visual( dpy, screen, depth, visclass );
 530                if (vis) {
 531                   return vis;
 532                }
 533             }
 534          }
 535          else {
 536             /* start with deepest */
 537             for (depth=32;depth>=min_depth;depth--) {
 538                if (visclass==TrueColor && depth==8) {
 539                   /* Special case:  try to get 8-bit PseudoColor before */
 540                   /* 8-bit TrueColor */
 541                   vis = get_visual( dpy, screen, 8, PseudoColor );
 542                   if (vis) {
 543                      return vis;
 544                   }
 545                }
 546                vis = get_visual( dpy, screen, depth, visclass );
 547                if (vis) {
 548                   return vis;
 549                }
 550             }
 551          }
 552       }
 553    }
 554    else {
 555       /* search for a specific visual class */
 556       switch (preferred_class) {
 557       case GLX_TRUE_COLOR_EXT:    visclass = TrueColor;    break;
 558       case GLX_DIRECT_COLOR_EXT:  visclass = DirectColor;  break;
 559       case GLX_PSEUDO_COLOR_EXT:  visclass = PseudoColor;  break;
 560       case GLX_STATIC_COLOR_EXT:  visclass = StaticColor;  break;
 561       case GLX_GRAY_SCALE_EXT:    visclass = GrayScale;    break;
 562       case GLX_STATIC_GRAY_EXT:   visclass = StaticGray;   break;
 563       default:   return NULL;
 564       }
 565       if (min_depth==0) {
 566          /* start with shallowest */
 567          for (depth=0;depth<=32;depth++) {
 568             vis = get_visual( dpy, screen, depth, visclass );
 569             if (vis) {
 570                return vis;
 571             }
 572          }
 573       }
 574       else {
 575          /* start with deepest */
 576          for (depth=32;depth>=min_depth;depth--) {
 577             vis = get_visual( dpy, screen, depth, visclass );
 578             if (vis) {
 579                return vis;
 580             }
 581          }
 582       }
 583    }
 584
 585    /* didn't find a visual */
 586    return NULL;
 587 }
 588
 589
 590
 591
 592 /**********************************************************************/
 593 /***             Display-related functions                          ***/
 594 /**********************************************************************/
 595
 596
 597 /**
 598  * Free all XMesaVisuals which are associated with the given display.
 599  */
 600 static void
 601 destroy_visuals_on_display(Display *dpy)
 602 {
 603    int i;
 604    for (i = 0; i < NumVisuals; i++) {
 605       if (VisualTable[i]->display == dpy) {
 606          /* remove this visual */
 607          int j;
 608          free(VisualTable[i]);
 609          for (j = i; j < NumVisuals - 1; j++)
 610             VisualTable[j] = VisualTable[j + 1];
 611          NumVisuals--;
 612       }
 613    }
 614 }
 615
 616
 617 /**
 618  * Called from XCloseDisplay() to let us free our display-related data.
 619  */
 620 static int
 621 close_display_callback(Display *dpy, XExtCodes *codes)
 622 {
 623    xmesa_destroy_buffers_on_display(dpy);
 624    destroy_visuals_on_display(dpy);
 625    xmesa_close_display(dpy);
 626    return 0;
 627 }
 628
 629
 630 /**
 631  * Look for the named extension on given display and return a pointer
 632  * to the _XExtension data, or NULL if extension not found.
 633  */
 634 static _XExtension *
 635 lookup_extension(Display *dpy, const char *extName)
 636 {
 637    _XExtension *ext;
 638    for (ext = dpy->ext_procs; ext; ext = ext->next) {
 639       if (ext->name && strcmp(ext->name, extName) == 0) {
 640          return ext;
 641       }
 642    }
 643    return NULL;
 644 }
 645
 646
 647 /**
 648  * Whenever we're given a new Display pointer, call this function to
 649  * register our close_display_callback function.
 650  */
 651 static void
 652 register_with_display(Display *dpy)
 653 {
 654    const char *extName = "MesaGLX";
 655    _XExtension *ext;
 656
 657    ext = lookup_extension(dpy, extName);
 658    if (!ext) {
 659       XExtCodes *c = XAddExtension(dpy);
 660       ext = dpy->ext_procs;  /* new extension is at head of list */
 661       assert(c->extension == ext->codes.extension);
 662       (void) c;
 663       ext->name = strdup(extName);
 664       ext->close_display = close_display_callback;
 665    }
 666 }
 667
 668
 669 /**
 670  * Fake an error.
 671  */
 672 static int
 673 generate_error(Display *dpy,
 674                unsigned char error_code,
 675                XID resourceid,
 676                unsigned char minor_code,
 677                Bool core)
 678 {
 679    XErrorHandler handler;
 680    int major_opcode;
 681    int first_event;
 682    int first_error;
 683    XEvent event;
 684
 685    handler = XSetErrorHandler(NULL);
 686    XSetErrorHandler(handler);
 687    if (!handler) {
 688       return 0;
 689    }
 690
 691    if (!XQueryExtension(dpy, GLX_EXTENSION_NAME, &major_opcode, &first_event, &first_error)) {
 692       major_opcode = 0;
 693       first_event = 0;
 694       first_error = 0;
 695    }
 696
 697    if (!core) {
 698       error_code += first_error;
 699    }
 700
 701    memset(&event, 0, sizeof event);
 702
 703    event.xerror.type = X_Error;
 704    event.xerror.display = dpy;
 705    event.xerror.resourceid = resourceid;
 706    event.xerror.serial = NextRequest(dpy) - 1;
 707    event.xerror.error_code = error_code;
 708    event.xerror.request_code = major_opcode;
 709    event.xerror.minor_code = minor_code;
 710
 711    return handler(dpy, &event.xerror);
 712 }
 713
 714
 715 /**********************************************************************/
 716 /***                  Begin Fake GLX API Functions                  ***/
 717 /**********************************************************************/
 718
 719
 720 /**
 721  * Helper used by glXChooseVisual and glXChooseFBConfig.
 722  * The fbConfig parameter must be GL_FALSE for the former and GL_TRUE for
 723  * the later.
 724  * In either case, the attribute list is terminated with the value 'None'.
 725  */
 726 static XMesaVisual
 727 choose_visual( Display *dpy, int screen, const int *list, GLboolean fbConfig )
 728 {
 729    const GLboolean rgbModeDefault = fbConfig;
 730    const int *parselist;
 731    XVisualInfo *vis;
 732    int min_red=0, min_green=0, min_blue=0;
 733    GLboolean rgb_flag = rgbModeDefault;
 734    GLboolean alpha_flag = GL_FALSE;
 735    GLboolean double_flag = GL_FALSE;
 736    GLboolean stereo_flag = GL_FALSE;
 737    GLint depth_size = 0;
 738    GLint stencil_size = 0;
 739    GLint accumRedSize = 0;
 740    GLint accumGreenSize = 0;
 741    GLint accumBlueSize = 0;
 742    GLint accumAlphaSize = 0;
 743    int level = 0;
 744    int visual_type = DONT_CARE;
 745    GLint caveat = DONT_CARE;
 746    XMesaVisual xmvis = NULL;
 747    int desiredVisualID = -1;
 748    int numAux = 0;
 749    GLint num_samples = 0;
 750
 751    if (xmesa_init( dpy ) != 0) {
 752       _mesa_warning(NULL, "Failed to initialize display");
 753       return NULL;
 754    }
 755
 756    parselist = list;
 757
 758    while (*parselist) {
 759
 760       if (fbConfig &&
 761           parselist[1] == GLX_DONT_CARE &&
 762           parselist[0] != GLX_LEVEL) {
 763          /* For glXChooseFBConfig(), skip attributes whose value is
 764           * GLX_DONT_CARE, unless it's GLX_LEVEL (which can legitimately be
 765           * a negative value).
 766           *
 767           * From page 17 (23 of the pdf) of the GLX 1.4 spec:
 768           * GLX DONT CARE may be specified for all attributes except GLX LEVEL.
 769           */
 770          parselist += 2;
 771          continue;
 772       }
 773
 774       switch (*parselist) {
 775          case GLX_USE_GL:
 776             if (fbConfig) {
 777                /* invalid token */
 778                return NULL;
 779             }
 780             else {
 781                /* skip */
 782                parselist++;
 783             }
 784             break;
 785          case GLX_BUFFER_SIZE:
 786             parselist++;
 787             parselist++;
 788             break;
 789          case GLX_LEVEL:
 790             parselist++;
 791             level = *parselist++;
 792             break;
 793          case GLX_RGBA:
 794             if (fbConfig) {
 795                /* invalid token */
 796                return NULL;
 797             }
 798             else {
 799                rgb_flag = GL_TRUE;
 800                parselist++;
 801             }
 802             break;
 803          case GLX_DOUBLEBUFFER:
 804             parselist++;
 805             if (fbConfig) {
 806                double_flag = *parselist++;
 807             }
 808             else {
 809                double_flag = GL_TRUE;
 810             }
 811             break;
 812          case GLX_STEREO:
 813             parselist++;
 814             if (fbConfig) {
 815                stereo_flag = *parselist++;
 816             }
 817             else {
 818                stereo_flag = GL_TRUE;
 819             }
 820             break;
 821          case GLX_AUX_BUFFERS:
 822             parselist++;
 823             numAux = *parselist++;
 824             if (numAux > MAX_AUX_BUFFERS)
 825                return NULL;
 826             break;
 827          case GLX_RED_SIZE:
 828             parselist++;
 829             min_red = *parselist++;
 830             break;
 831          case GLX_GREEN_SIZE:
 832             parselist++;
 833             min_green = *parselist++;
 834             break;
 835          case GLX_BLUE_SIZE:
 836             parselist++;
 837             min_blue = *parselist++;
 838             break;
 839          case GLX_ALPHA_SIZE:
 840             parselist++;
 841             {
 842                GLint size = *parselist++;
 843                alpha_flag = size ? GL_TRUE : GL_FALSE;
 844             }
 845             break;
 846          case GLX_DEPTH_SIZE:
 847             parselist++;
 848             depth_size = *parselist++;
 849             break;
 850          case GLX_STENCIL_SIZE:
 851             parselist++;
 852             stencil_size = *parselist++;
 853             break;
 854          case GLX_ACCUM_RED_SIZE:
 855             parselist++;
 856             {
 857                GLint size = *parselist++;
 858                accumRedSize = MAX2( accumRedSize, size );
 859             }
 860             break;
 861          case GLX_ACCUM_GREEN_SIZE:
 862             parselist++;
 863             {
 864                GLint size = *parselist++;
 865                accumGreenSize = MAX2( accumGreenSize, size );
 866             }
 867             break;
 868          case GLX_ACCUM_BLUE_SIZE:
 869             parselist++;
 870             {
 871                GLint size = *parselist++;
 872                accumBlueSize = MAX2( accumBlueSize, size );
 873             }
 874             break;
 875          case GLX_ACCUM_ALPHA_SIZE:
 876             parselist++;
 877             {
 878                GLint size = *parselist++;
 879                accumAlphaSize = MAX2( accumAlphaSize, size );
 880             }
 881             break;
 882
 883          /*
 884           * GLX_EXT_visual_info extension
 885           */
 886          case GLX_X_VISUAL_TYPE_EXT:
 887             parselist++;
 888             visual_type = *parselist++;
 889             break;
 890          case GLX_TRANSPARENT_TYPE_EXT:
 891             parselist++;
 892             parselist++;
 893             break;
 894          case GLX_TRANSPARENT_INDEX_VALUE_EXT:
 895             parselist++;
 896             parselist++;
 897             break;
 898          case GLX_TRANSPARENT_RED_VALUE_EXT:
 899          case GLX_TRANSPARENT_GREEN_VALUE_EXT:
 900          case GLX_TRANSPARENT_BLUE_VALUE_EXT:
 901          case GLX_TRANSPARENT_ALPHA_VALUE_EXT:
 902             /* ignore */
 903             parselist++;
 904             parselist++;
 905             break;
 906
 907          /*
 908           * GLX_EXT_visual_info extension
 909           */
 910          case GLX_VISUAL_CAVEAT_EXT:
 911             parselist++;
 912             caveat = *parselist++; /* ignored for now */
 913             break;
 914
 915          /*
 916           * GLX_ARB_multisample
 917           */
 918          case GLX_SAMPLE_BUFFERS_ARB:
 919             /* ignore */
 920             parselist++;
 921             parselist++;
 922             break;
 923          case GLX_SAMPLES_ARB:
 924             parselist++;
 925             num_samples = *parselist++;
 926             break;
 927
 928          /*
 929           * FBConfig attribs.
 930           */
 931          case GLX_RENDER_TYPE:
 932             if (!fbConfig)
 933                return NULL;
 934             parselist++;
 935             if (*parselist & GLX_RGBA_BIT) {
 936                rgb_flag = GL_TRUE;
 937             }
 938             else if (*parselist & GLX_COLOR_INDEX_BIT) {
 939                rgb_flag = GL_FALSE;
 940             }
 941             else if (*parselist == 0) {
 942                rgb_flag = GL_TRUE;
 943             }
 944             parselist++;
 945             break;
 946          case GLX_DRAWABLE_TYPE:
 947             if (!fbConfig)
 948                return NULL;
 949             parselist++;
 950             if (*parselist & ~(GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT)) {
 951                return NULL; /* bad bit */
 952             }
 953             parselist++;
 954             break;
 955          case GLX_FBCONFIG_ID:
 956          case GLX_VISUAL_ID:
 957             if (!fbConfig)
 958                return NULL;
 959             parselist++;
 960             desiredVisualID = *parselist++;
 961             break;
 962          case GLX_X_RENDERABLE:
 963          case GLX_MAX_PBUFFER_WIDTH:
 964          case GLX_MAX_PBUFFER_HEIGHT:
 965          case GLX_MAX_PBUFFER_PIXELS:
 966             if (!fbConfig)
 967                return NULL; /* invalid config option */
 968             parselist += 2; /* ignore the parameter */
 969             break;
 970
 971          case GLX_BIND_TO_TEXTURE_RGB_EXT:
 972             parselist++; /*skip*/
 973             break;
 974          case GLX_BIND_TO_TEXTURE_RGBA_EXT:
 975             parselist++; /*skip*/
 976             break;
 977          case GLX_BIND_TO_MIPMAP_TEXTURE_EXT:
 978             parselist++; /*skip*/
 979             break;
 980          case GLX_BIND_TO_TEXTURE_TARGETS_EXT:
 981             parselist++;
 982             if (*parselist & ~(GLX_TEXTURE_1D_BIT_EXT |
 983                                GLX_TEXTURE_2D_BIT_EXT |
 984                                GLX_TEXTURE_RECTANGLE_BIT_EXT)) {
 985                /* invalid bit */
 986                return NULL;
 987             }
 988             break;
 989          case GLX_Y_INVERTED_EXT:
 990             parselist++; /*skip*/
 991             break;
 992
 993          case None:
 994             /* end of list */
 995             break;
 996
 997          default:
 998             /* undefined attribute */
 999             _mesa_warning(NULL, "unexpected attrib 0x%x in choose_visual()",
1000                           *parselist);
1001             return NULL;
1002       }
1003    }
1004
1005    (void) caveat;
1006
1007    if (num_samples < 0) {
1008       _mesa_warning(NULL, "GLX_SAMPLES_ARB: number of samples must not be negative");
1009       return NULL;
1010    }
1011
1012    /*
1013     * Since we're only simulating the GLX extension this function will never
1014     * find any real GL visuals.  Instead, all we can do is try to find an RGB
1015     * or CI visual of appropriate depth.  Other requested attributes such as
1016     * double buffering, depth buffer, etc. will be associated with the X
1017     * visual and stored in the VisualTable[].
1018     */
1019    if (desiredVisualID != -1) {
1020       /* try to get a specific visual, by visualID */
1021       XVisualInfo temp;
1022       int n;
1023       temp.visualid = desiredVisualID;
1024       temp.screen = screen;
1025       vis = XGetVisualInfo(dpy, VisualIDMask | VisualScreenMask, &temp, &n);
1026       if (vis) {
1027          /* give the visual some useful GLX attributes */
1028          double_flag = GL_TRUE;
1029          rgb_flag = GL_TRUE;
1030       }
1031    }
1032    else if (level==0) {
1033       /* normal color planes */
1034       /* Get an RGB visual */
1035       int min_rgb = min_red + min_green + min_blue;
1036       if (min_rgb>1 && min_rgb<8) {
1037          /* a special case to be sure we can get a monochrome visual */
1038          min_rgb = 1;
1039       }
1040       vis = choose_x_visual( dpy, screen, min_rgb, visual_type );
1041    }
1042    else {
1043       _mesa_warning(NULL, "overlay not supported");
1044       return NULL;
1045    }
1046
1047    if (vis) {
1048       /* Note: we're not exactly obeying the glXChooseVisual rules here.
1049        * When GLX_DEPTH_SIZE = 1 is specified we're supposed to choose the
1050        * largest depth buffer size, which is 32bits/value.  Instead, we
1051        * return 16 to maintain performance with earlier versions of Mesa.
1052        */
1053       if (stencil_size > 0)
1054          depth_size = 24;  /* if Z and stencil, always use 24+8 format */
1055       else if (depth_size > 24)
1056          depth_size = 32;
1057       else if (depth_size > 16)
1058          depth_size = 24;
1059       else if (depth_size > 0) {
1060          depth_size = default_depth_bits();
1061       }
1062
1063       if (!alpha_flag) {
1064          alpha_flag = default_alpha_bits() > 0;
1065       }
1066
1067       /* we only support one size of stencil and accum buffers. */
1068       if (stencil_size > 0)
1069          stencil_size = 8;
1070
1071       if (accumRedSize > 0 ||
1072           accumGreenSize > 0 ||
1073           accumBlueSize > 0 ||
1074           accumAlphaSize > 0) {
1075
1076          accumRedSize =
1077             accumGreenSize =
1078             accumBlueSize = default_accum_bits();
1079
1080          accumAlphaSize = alpha_flag ? accumRedSize : 0;
1081       }
1082
1083       xmvis = save_glx_visual( dpy, vis, rgb_flag, alpha_flag, double_flag,
1084                                stereo_flag, depth_size, stencil_size,
1085                                accumRedSize, accumGreenSize,
1086                                accumBlueSize, accumAlphaSize, level, numAux,
1087                                num_samples );
1088    }
1089
1090    return xmvis;
1091 }
1092
1093
1094 PUBLIC XVisualInfo *
1095 glXChooseVisual( Display *dpy, int screen, int *list )
1096 {
1097    XMesaVisual xmvis;
1098
1099    /* register ourselves as an extension on this display */
1100    register_with_display(dpy);
1101
1102    xmvis = choose_visual(dpy, screen, list, GL_FALSE);
1103    if (xmvis) {
1104       /* create a new vishandle - the cached one may be stale */
1105       xmvis->vishandle = malloc(sizeof(XVisualInfo));
1106       if (xmvis->vishandle) {
1107          memcpy(xmvis->vishandle, xmvis->visinfo, sizeof(XVisualInfo));
1108       }
1109       return xmvis->vishandle;
1110    }
1111    else
1112       return NULL;
1113 }
1114
1115
1116 /**
1117  * Helper function used by other glXCreateContext functions.
1118  */
1119 static GLXContext
1120 create_context(Display *dpy, XMesaVisual xmvis,
1121                XMesaContext shareCtx, Bool direct,
1122                unsigned major, unsigned minor,
1123                unsigned profileMask, unsigned contextFlags)
1124 {
1125    GLXContext glxCtx;
1126
1127    if (!dpy || !xmvis)
1128       return 0;
1129
1130    glxCtx = CALLOC_STRUCT(__GLXcontextRec);
1131    if (!glxCtx)
1132       return 0;
1133
1134    /* deallocate unused windows/buffers */
1135 #if 0
1136    XMesaGarbageCollect();
1137 #endif
1138
1139    glxCtx->xmesaContext = XMesaCreateContext(xmvis, shareCtx, major, minor,
1140                                              profileMask, contextFlags);
1141    if (!glxCtx->xmesaContext) {
1142       free(glxCtx);
1143       return NULL;
1144    }
1145
1146    glxCtx->isDirect = DEFAULT_DIRECT;
1147    glxCtx->currentDpy = dpy;
1148    glxCtx->xid = (XID) glxCtx;  /* self pointer */
1149
1150    return glxCtx;
1151 }
1152
1153
1154 PUBLIC GLXContext
1155 glXCreateContext( Display *dpy, XVisualInfo *visinfo,
1156                   GLXContext shareCtx, Bool direct )
1157 {
1158    XMesaVisual xmvis;
1159
1160    xmvis = find_glx_visual( dpy, visinfo );
1161    if (!xmvis) {
1162       /* This visual wasn't found with glXChooseVisual() */
1163       xmvis = create_glx_visual( dpy, visinfo );
1164       if (!xmvis) {
1165          /* unusable visual */
1166          return NULL;
1167       }
1168    }
1169
1170    return create_context(dpy, xmvis,
1171                          shareCtx ? shareCtx->xmesaContext : NULL,
1172                          direct,
1173                          1, 0, GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB, 0x0);
1174 }
1175
1176
1177 /* GLX 1.3 and later */
1178 PUBLIC Bool
1179 glXMakeContextCurrent( Display *dpy, GLXDrawable draw,
1180                        GLXDrawable read, GLXContext ctx )
1181 {
1182    GLXContext glxCtx = ctx;
1183    GLXContext current = GetCurrentContext();
1184    static boolean firsttime = 1, no_rast = 0;
1185
1186    if (firsttime) {
1187       no_rast = getenv("SP_NO_RAST") != NULL;
1188       firsttime = 0;
1189    }
1190
1191    if (ctx && draw && read) {
1192       XMesaBuffer drawBuffer, readBuffer;
1193       XMesaContext xmctx = glxCtx->xmesaContext;
1194
1195       /* Find the XMesaBuffer which corresponds to the GLXDrawable 'draw' */
1196       if (ctx == current) {
1197          drawBuffer = XMesaFindBuffer( dpy, draw );
1198       }
1199       if (!drawBuffer) {
1200          /* drawable must be a new window! */
1201          drawBuffer = XMesaCreateWindowBuffer( xmctx->xm_visual, draw );
1202          if (!drawBuffer) {
1203             /* Out of memory, or context/drawable depth mismatch */
1204             return False;
1205          }
1206       }
1207
1208       /* Find the XMesaBuffer which corresponds to the GLXDrawable 'read' */
1209       if (ctx == current) {
1210          readBuffer = XMesaFindBuffer( dpy, read );
1211       }
1212       if (!readBuffer) {
1213          /* drawable must be a new window! */
1214          readBuffer = XMesaCreateWindowBuffer( xmctx->xm_visual, read );
1215          if (!readBuffer) {
1216             /* Out of memory, or context/drawable depth mismatch */
1217             return False;
1218          }
1219       }
1220
1221       if (no_rast && current == ctx)
1222          return True;
1223
1224       /* Now make current! */
1225       if (XMesaMakeCurrent2(xmctx, drawBuffer, readBuffer)) {
1226          ctx->currentDpy = dpy;
1227          ctx->currentDrawable = draw;
1228          ctx->currentReadable = read;
1229          SetCurrentContext(ctx);
1230          return True;
1231       }
1232       else {
1233          return False;
1234       }
1235    }
1236    else if (!ctx && !draw && !read) {
1237       /* release current context w/out assigning new one. */
1238       XMesaMakeCurrent2( NULL, NULL, NULL );
1239       SetCurrentContext(NULL);
1240       return True;
1241    }
1242    else {
1243       /* The args must either all be non-zero or all zero.
1244        * This is an error.
1245        */
1246       return False;
1247    }
1248 }
1249
1250
1251 PUBLIC Bool
1252 glXMakeCurrent( Display *dpy, GLXDrawable drawable, GLXContext ctx )
1253 {
1254    return glXMakeContextCurrent( dpy, drawable, drawable, ctx );
1255 }
1256
1257
1258 PUBLIC GLXContext
1259 glXGetCurrentContext(void)
1260 {
1261    return GetCurrentContext();
1262 }
1263
1264
1265 PUBLIC Display *
1266 glXGetCurrentDisplay(void)
1267 {
1268    GLXContext glxCtx = glXGetCurrentContext();
1269
1270    return glxCtx ? glxCtx->currentDpy : NULL;
1271 }
1272
1273
1274 PUBLIC Display *
1275 glXGetCurrentDisplayEXT(void)
1276 {
1277    return glXGetCurrentDisplay();
1278 }
1279
1280
1281 PUBLIC GLXDrawable
1282 glXGetCurrentDrawable(void)
1283 {
1284    GLXContext gc = glXGetCurrentContext();
1285    return gc ? gc->currentDrawable : 0;
1286 }
1287
1288
1289 PUBLIC GLXDrawable
1290 glXGetCurrentReadDrawable(void)
1291 {
1292    GLXContext gc = glXGetCurrentContext();
1293    return gc ? gc->currentReadable : 0;
1294 }
1295
1296
1297 PUBLIC GLXDrawable
1298 glXGetCurrentReadDrawableSGI(void)
1299 {
1300    return glXGetCurrentReadDrawable();
1301 }
1302
1303
1304 PUBLIC GLXPixmap
1305 glXCreateGLXPixmap( Display *dpy, XVisualInfo *visinfo, Pixmap pixmap )
1306 {
1307    XMesaVisual v;
1308    XMesaBuffer b;
1309
1310    v = find_glx_visual( dpy, visinfo );
1311    if (!v) {
1312       v = create_glx_visual( dpy, visinfo );
1313       if (!v) {
1314          /* unusable visual */
1315          return 0;
1316       }
1317    }
1318
1319    b = XMesaCreatePixmapBuffer( v, pixmap, 0 );
1320    if (!b) {
1321       return 0;
1322    }
1323    return b->ws.drawable;
1324 }
1325
1326
1327 /*** GLX_MESA_pixmap_colormap ***/
1328
1329 PUBLIC GLXPixmap
1330 glXCreateGLXPixmapMESA( Display *dpy, XVisualInfo *visinfo,
1331                         Pixmap pixmap, Colormap cmap )
1332 {
1333    XMesaVisual v;
1334    XMesaBuffer b;
1335
1336    v = find_glx_visual( dpy, visinfo );
1337    if (!v) {
1338       v = create_glx_visual( dpy, visinfo );
1339       if (!v) {
1340          /* unusable visual */
1341          return 0;
1342       }
1343    }
1344
1345    b = XMesaCreatePixmapBuffer( v, pixmap, cmap );
1346    if (!b) {
1347       return 0;
1348    }
1349    return b->ws.drawable;
1350 }
1351
1352
1353 PUBLIC void
1354 glXDestroyGLXPixmap( Display *dpy, GLXPixmap pixmap )
1355 {
1356    XMesaBuffer b = XMesaFindBuffer(dpy, pixmap);
1357    if (b) {
1358       XMesaDestroyBuffer(b);
1359    }
1360    else if (getenv("MESA_DEBUG")) {
1361       _mesa_warning(NULL, "Mesa: glXDestroyGLXPixmap: invalid pixmap\n");
1362    }
1363 }
1364
1365
1366 PUBLIC void
1367 glXCopyContext( Display *dpy, GLXContext src, GLXContext dst,
1368                 unsigned long mask )
1369 {
1370    XMesaContext xm_src = src->xmesaContext;
1371    XMesaContext xm_dst = dst->xmesaContext;
1372    (void) dpy;
1373    if (GetCurrentContext() == src) {
1374       glFlush();
1375    }
1376    XMesaCopyContext(xm_src, xm_dst, mask);
1377 }
1378
1379
1380 PUBLIC Bool
1381 glXQueryExtension( Display *dpy, int *errorBase, int *eventBase )
1382 {
1383    int op, ev, err;
1384    /* Mesa's GLX isn't really an X extension but we try to act like one. */
1385    if (!XQueryExtension(dpy, GLX_EXTENSION_NAME, &op, &ev, &err))
1386       ev = err = 0;
1387    if (errorBase)
1388       *errorBase = err;
1389    if (eventBase)
1390       *eventBase = ev;
1391    return True; /* we're faking GLX so always return success */
1392 }
1393
1394
1395 PUBLIC void
1396 glXDestroyContext( Display *dpy, GLXContext ctx )
1397 {
1398    if (ctx) {
1399       GLXContext glxCtx = ctx;
1400       (void) dpy;
1401       XMesaDestroyContext( glxCtx->xmesaContext );
1402       XMesaGarbageCollect();
1403       free(glxCtx);
1404    }
1405 }
1406
1407
1408 PUBLIC Bool
1409 glXIsDirect( Display *dpy, GLXContext ctx )
1410 {
1411    return ctx ? ctx->isDirect : False;
1412 }
1413
1414
1415
1416 PUBLIC void
1417 glXSwapBuffers( Display *dpy, GLXDrawable drawable )
1418 {
1419    XMesaBuffer buffer = XMesaFindBuffer( dpy, drawable );
1420    static boolean firsttime = 1, no_rast = 0;
1421
1422    if (firsttime) {
1423       no_rast = getenv("SP_NO_RAST") != NULL;
1424       firsttime = 0;
1425    }
1426
1427    if (no_rast)
1428       return;
1429
1430    if (buffer) {
1431       XMesaSwapBuffers(buffer);
1432    }
1433    else if (getenv("MESA_DEBUG")) {
1434       _mesa_warning(NULL, "glXSwapBuffers: invalid drawable 0x%x\n",
1435                     (int) drawable);
1436    }
1437 }
1438
1439
1440
1441 /*** GLX_MESA_copy_sub_buffer ***/
1442
1443 PUBLIC void
1444 glXCopySubBufferMESA(Display *dpy, GLXDrawable drawable,
1445                      int x, int y, int width, int height)
1446 {
1447    XMesaBuffer buffer = XMesaFindBuffer( dpy, drawable );
1448    if (buffer) {
1449       XMesaCopySubBuffer(buffer, x, y, width, height);
1450    }
1451    else if (getenv("MESA_DEBUG")) {
1452       _mesa_warning(NULL, "Mesa: glXCopySubBufferMESA: invalid drawable\n");
1453    }
1454 }
1455
1456
1457 PUBLIC Bool
1458 glXQueryVersion( Display *dpy, int *maj, int *min )
1459 {
1460    (void) dpy;
1461    /* Return GLX version, not Mesa version */
1462    assert(CLIENT_MAJOR_VERSION == SERVER_MAJOR_VERSION);
1463    *maj = CLIENT_MAJOR_VERSION;
1464    *min = MIN2( CLIENT_MINOR_VERSION, SERVER_MINOR_VERSION );
1465    return True;
1466 }
1467
1468
1469 /*
1470  * Query the GLX attributes of the given XVisualInfo.
1471  */
1472 static int
1473 get_config( XMesaVisual xmvis, int attrib, int *value, GLboolean fbconfig )
1474 {
1475    assert(xmvis);
1476    switch(attrib) {
1477       case GLX_USE_GL:
1478          if (fbconfig)
1479             return GLX_BAD_ATTRIBUTE;
1480          *value = (int) True;
1481          return 0;
1482       case GLX_BUFFER_SIZE:
1483          *value = xmvis->visinfo->depth;
1484          return 0;
1485       case GLX_LEVEL:
1486          *value = xmvis->mesa_visual.level;
1487          return 0;
1488       case GLX_RGBA:
1489          if (fbconfig)
1490             return GLX_BAD_ATTRIBUTE;
1491          *value = True;
1492          return 0;
1493       case GLX_DOUBLEBUFFER:
1494          *value = (int) xmvis->mesa_visual.doubleBufferMode;
1495          return 0;
1496       case GLX_STEREO:
1497          *value = (int) xmvis->mesa_visual.stereoMode;
1498          return 0;
1499       case GLX_AUX_BUFFERS:
1500          *value = xmvis->mesa_visual.numAuxBuffers;
1501          return 0;
1502       case GLX_RED_SIZE:
1503          *value = xmvis->mesa_visual.redBits;
1504          return 0;
1505       case GLX_GREEN_SIZE:
1506          *value = xmvis->mesa_visual.greenBits;
1507          return 0;
1508       case GLX_BLUE_SIZE:
1509          *value = xmvis->mesa_visual.blueBits;
1510          return 0;
1511       case GLX_ALPHA_SIZE:
1512          *value = xmvis->mesa_visual.alphaBits;
1513          return 0;
1514       case GLX_DEPTH_SIZE:
1515          *value = xmvis->mesa_visual.depthBits;
1516          return 0;
1517       case GLX_STENCIL_SIZE:
1518          *value = xmvis->mesa_visual.stencilBits;
1519          return 0;
1520       case GLX_ACCUM_RED_SIZE:
1521          *value = xmvis->mesa_visual.accumRedBits;
1522          return 0;
1523       case GLX_ACCUM_GREEN_SIZE:
1524          *value = xmvis->mesa_visual.accumGreenBits;
1525          return 0;
1526       case GLX_ACCUM_BLUE_SIZE:
1527          *value = xmvis->mesa_visual.accumBlueBits;
1528          return 0;
1529       case GLX_ACCUM_ALPHA_SIZE:
1530          *value = xmvis->mesa_visual.accumAlphaBits;
1531          return 0;
1532
1533       /*
1534        * GLX_EXT_visual_info extension
1535        */
1536       case GLX_X_VISUAL_TYPE_EXT:
1537          switch (xmvis->visinfo->CLASS) {
1538             case StaticGray:   *value = GLX_STATIC_GRAY_EXT;   return 0;
1539             case GrayScale:    *value = GLX_GRAY_SCALE_EXT;    return 0;
1540             case StaticColor:  *value = GLX_STATIC_GRAY_EXT;   return 0;
1541             case PseudoColor:  *value = GLX_PSEUDO_COLOR_EXT;  return 0;
1542             case TrueColor:    *value = GLX_TRUE_COLOR_EXT;    return 0;
1543             case DirectColor:  *value = GLX_DIRECT_COLOR_EXT;  return 0;
1544          }
1545          return 0;
1546       case GLX_TRANSPARENT_TYPE_EXT:
1547          /* normal planes */
1548          *value = GLX_NONE_EXT;
1549          return 0;
1550       case GLX_TRANSPARENT_INDEX_VALUE_EXT:
1551          /* undefined */
1552          return 0;
1553       case GLX_TRANSPARENT_RED_VALUE_EXT:
1554          /* undefined */
1555          return 0;
1556       case GLX_TRANSPARENT_GREEN_VALUE_EXT:
1557          /* undefined */
1558          return 0;
1559       case GLX_TRANSPARENT_BLUE_VALUE_EXT:
1560          /* undefined */
1561          return 0;
1562       case GLX_TRANSPARENT_ALPHA_VALUE_EXT:
1563          /* undefined */
1564          return 0;
1565
1566       /*
1567        * GLX_EXT_visual_info extension
1568        */
1569       case GLX_VISUAL_CAVEAT_EXT:
1570          /* test for zero, just in case */
1571          if (xmvis->mesa_visual.visualRating > 0)
1572             *value = xmvis->mesa_visual.visualRating;
1573          else
1574             *value = GLX_NONE_EXT;
1575          return 0;
1576
1577       /*
1578        * GLX_ARB_multisample
1579        */
1580       case GLX_SAMPLE_BUFFERS_ARB:
1581          *value = xmvis->mesa_visual.sampleBuffers;
1582          return 0;
1583       case GLX_SAMPLES_ARB:
1584          *value = xmvis->mesa_visual.samples;
1585          return 0;
1586
1587       /*
1588        * For FBConfigs:
1589        */
1590       case GLX_SCREEN_EXT:
1591          if (!fbconfig)
1592             return GLX_BAD_ATTRIBUTE;
1593          *value = xmvis->visinfo->screen;
1594          break;
1595       case GLX_DRAWABLE_TYPE: /*SGIX too */
1596          if (!fbconfig)
1597             return GLX_BAD_ATTRIBUTE;
1598          *value = GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT;
1599          break;
1600       case GLX_RENDER_TYPE_SGIX:
1601          if (!fbconfig)
1602             return GLX_BAD_ATTRIBUTE;
1603          *value = GLX_RGBA_BIT;
1604          break;
1605       case GLX_X_RENDERABLE_SGIX:
1606          if (!fbconfig)
1607             return GLX_BAD_ATTRIBUTE;
1608          *value = True; /* XXX really? */
1609          break;
1610       case GLX_FBCONFIG_ID_SGIX:
1611          if (!fbconfig)
1612             return GLX_BAD_ATTRIBUTE;
1613          *value = xmvis->visinfo->visualid;
1614          break;
1615       case GLX_MAX_PBUFFER_WIDTH:
1616          if (!fbconfig)
1617             return GLX_BAD_ATTRIBUTE;
1618          /* XXX should be same as ctx->Const.MaxRenderbufferSize */
1619          *value = DisplayWidth(xmvis->display, xmvis->visinfo->screen);
1620          break;
1621       case GLX_MAX_PBUFFER_HEIGHT:
1622          if (!fbconfig)
1623             return GLX_BAD_ATTRIBUTE;
1624          *value = DisplayHeight(xmvis->display, xmvis->visinfo->screen);
1625          break;
1626       case GLX_MAX_PBUFFER_PIXELS:
1627          if (!fbconfig)
1628             return GLX_BAD_ATTRIBUTE;
1629          *value = DisplayWidth(xmvis->display, xmvis->visinfo->screen) *
1630                   DisplayHeight(xmvis->display, xmvis->visinfo->screen);
1631          break;
1632       case GLX_VISUAL_ID:
1633          if (!fbconfig)
1634             return GLX_BAD_ATTRIBUTE;
1635          *value = xmvis->visinfo->visualid;
1636          break;
1637
1638       case GLX_BIND_TO_TEXTURE_RGB_EXT:
1639          *value = True; /*XXX*/
1640          break;
1641       case GLX_BIND_TO_TEXTURE_RGBA_EXT:
1642          /* XXX review */
1643          *value = xmvis->mesa_visual.alphaBits > 0 ? True : False;
1644          break;
1645       case GLX_BIND_TO_MIPMAP_TEXTURE_EXT:
1646          *value = True; /*XXX*/
1647          break;
1648       case GLX_BIND_TO_TEXTURE_TARGETS_EXT:
1649          *value = (GLX_TEXTURE_1D_BIT_EXT |
1650                    GLX_TEXTURE_2D_BIT_EXT |
1651                    GLX_TEXTURE_RECTANGLE_BIT_EXT); /*XXX*/
1652          break;
1653       case GLX_Y_INVERTED_EXT:
1654          *value = True; /*XXX*/
1655          break;
1656
1657       default:
1658          return GLX_BAD_ATTRIBUTE;
1659    }
1660    return Success;
1661 }
1662
1663
1664 PUBLIC int
1665 glXGetConfig( Display *dpy, XVisualInfo *visinfo,
1666                    int attrib, int *value )
1667 {
1668    XMesaVisual xmvis;
1669    int k;
1670    if (!dpy || !visinfo)
1671       return GLX_BAD_ATTRIBUTE;
1672
1673    xmvis = find_glx_visual( dpy, visinfo );
1674    if (!xmvis) {
1675       /* this visual wasn't obtained with glXChooseVisual */
1676       xmvis = create_glx_visual( dpy, visinfo );
1677       if (!xmvis) {
1678          /* this visual can't be used for GL rendering */
1679          if (attrib==GLX_USE_GL) {
1680             *value = (int) False;
1681             return 0;
1682          }
1683          else {
1684             return GLX_BAD_VISUAL;
1685          }
1686       }
1687    }
1688
1689    k = get_config(xmvis, attrib, value, GL_FALSE);
1690    return k;
1691 }
1692
1693
1694 PUBLIC void
1695 glXWaitGL( void )
1696 {
1697    XMesaContext xmesa = XMesaGetCurrentContext();
1698    XMesaFlush( xmesa );
1699 }
1700
1701
1702
1703 PUBLIC void
1704 glXWaitX( void )
1705 {
1706    XMesaContext xmesa = XMesaGetCurrentContext();
1707    XMesaFlush( xmesa );
1708 }
1709
1710
1711 static const char *
1712 get_extensions( void )
1713 {
1714    return EXTENSIONS;
1715 }
1716
1717
1718
1719 /* GLX 1.1 and later */
1720 PUBLIC const char *
1721 glXQueryExtensionsString( Display *dpy, int screen )
1722 {
1723    (void) dpy;
1724    (void) screen;
1725    return get_extensions();
1726 }
1727
1728
1729
1730 /* GLX 1.1 and later */
1731 PUBLIC const char *
1732 glXQueryServerString( Display *dpy, int screen, int name )
1733 {
1734    static char version[1000];
1735    sprintf(version, "%d.%d %s",
1736            SERVER_MAJOR_VERSION, SERVER_MINOR_VERSION, xmesa_get_name());
1737
1738    (void) dpy;
1739    (void) screen;
1740
1741    switch (name) {
1742       case GLX_EXTENSIONS:
1743          return get_extensions();
1744       case GLX_VENDOR:
1745          return VENDOR;
1746       case GLX_VERSION:
1747          return version;
1748       default:
1749          return NULL;
1750    }
1751 }
1752
1753
1754
1755 /* GLX 1.1 and later */
1756 PUBLIC const char *
1757 glXGetClientString( Display *dpy, int name )
1758 {
1759    static char version[1000];
1760    sprintf(version, "%d.%d %s", CLIENT_MAJOR_VERSION,
1761            CLIENT_MINOR_VERSION, xmesa_get_name());
1762
1763    (void) dpy;
1764
1765    switch (name) {
1766       case GLX_EXTENSIONS:
1767          return get_extensions();
1768       case GLX_VENDOR:
1769          return VENDOR;
1770       case GLX_VERSION:
1771          return version;
1772       default:
1773          return NULL;
1774    }
1775 }
1776
1777
1778
1779 /*
1780  * GLX 1.3 and later
1781  */
1782
1783
1784 PUBLIC int
1785 glXGetFBConfigAttrib(Display *dpy, GLXFBConfig config,
1786                      int attribute, int *value)
1787 {
1788    XMesaVisual v = (XMesaVisual) config;
1789    (void) dpy;
1790    (void) config;
1791
1792    if (!dpy || !config || !value)
1793       return -1;
1794
1795    return get_config(v, attribute, value, GL_TRUE);
1796 }
1797
1798
1799 PUBLIC GLXFBConfig *
1800 glXGetFBConfigs( Display *dpy, int screen, int *nelements )
1801 {
1802    XVisualInfo *visuals, visTemplate;
1803    const long visMask = VisualScreenMask;
1804    int i;
1805
1806    /* Get list of all X visuals */
1807    visTemplate.screen = screen;
1808    visuals = XGetVisualInfo(dpy, visMask, &visTemplate, nelements);
1809    if (*nelements > 0) {
1810       XMesaVisual *results = malloc(*nelements * sizeof(XMesaVisual));
1811       if (!results) {
1812          *nelements = 0;
1813          return NULL;
1814       }
1815       for (i = 0; i < *nelements; i++) {
1816          results[i] = create_glx_visual(dpy, visuals + i);
1817          if (!results[i]) {
1818             *nelements = i;
1819             break;
1820          }
1821       }
1822       return (GLXFBConfig *) results;
1823    }
1824    return NULL;
1825 }
1826
1827
1828 PUBLIC GLXFBConfig *
1829 glXChooseFBConfig(Display *dpy, int screen,
1830                   const int *attribList, int *nitems)
1831 {
1832    XMesaVisual xmvis;
1833
1834    /* register ourselves as an extension on this display */
1835    register_with_display(dpy);
1836
1837    if (!attribList || !attribList[0]) {
1838       /* return list of all configs (per GLX_SGIX_fbconfig spec) */
1839       return glXGetFBConfigs(dpy, screen, nitems);
1840    }
1841
1842    xmvis = choose_visual(dpy, screen, attribList, GL_TRUE);
1843    if (xmvis) {
1844       GLXFBConfig *config = malloc(sizeof(XMesaVisual));
1845       if (!config) {
1846          *nitems = 0;
1847          return NULL;
1848       }
1849       *nitems = 1;
1850       config[0] = (GLXFBConfig) xmvis;
1851       return (GLXFBConfig *) config;
1852    }
1853    else {
1854       *nitems = 0;
1855       return NULL;
1856    }
1857 }
1858
1859
1860 PUBLIC XVisualInfo *
1861 glXGetVisualFromFBConfig( Display *dpy, GLXFBConfig config )
1862 {
1863    if (dpy && config) {
1864       XMesaVisual xmvis = (XMesaVisual) config;
1865 #if 0
1866       return xmvis->vishandle;
1867 #else
1868       /* create a new vishandle - the cached one may be stale */
1869       xmvis->vishandle = malloc(sizeof(XVisualInfo));
1870       if (xmvis->vishandle) {
1871          memcpy(xmvis->vishandle, xmvis->visinfo, sizeof(XVisualInfo));
1872       }
1873       return xmvis->vishandle;
1874 #endif
1875    }
1876    else {
1877       return NULL;
1878    }
1879 }
1880
1881
1882 PUBLIC GLXWindow
1883 glXCreateWindow(Display *dpy, GLXFBConfig config, Window win,
1884                 const int *attribList)
1885 {
1886    XMesaVisual xmvis = (XMesaVisual) config;
1887    XMesaBuffer xmbuf;
1888    if (!xmvis)
1889       return 0;
1890
1891    xmbuf = XMesaCreateWindowBuffer(xmvis, win);
1892    if (!xmbuf)
1893       return 0;
1894
1895    (void) dpy;
1896    (void) attribList;  /* Ignored in GLX 1.3 */
1897
1898    return win;  /* A hack for now */
1899 }
1900
1901
1902 PUBLIC void
1903 glXDestroyWindow( Display *dpy, GLXWindow window )
1904 {
1905    XMesaBuffer b = XMesaFindBuffer(dpy, (Drawable) window);
1906    if (b)
1907       XMesaDestroyBuffer(b);
1908    /* don't destroy X window */
1909 }
1910
1911
1912 /* XXX untested */
1913 PUBLIC GLXPixmap
1914 glXCreatePixmap(Display *dpy, GLXFBConfig config, Pixmap pixmap,
1915                 const int *attribList)
1916 {
1917    XMesaVisual v = (XMesaVisual) config;
1918    XMesaBuffer b;
1919    const int *attr;
1920    int target = 0, format = 0, mipmap = 0;
1921    int value;
1922
1923    if (!dpy || !config || !pixmap)
1924       return 0;
1925
1926    for (attr = attribList; attr && *attr; attr++) {
1927       switch (*attr) {
1928       case GLX_TEXTURE_FORMAT_EXT:
1929          attr++;
1930          switch (*attr) {
1931          case GLX_TEXTURE_FORMAT_NONE_EXT:
1932          case GLX_TEXTURE_FORMAT_RGB_EXT:
1933          case GLX_TEXTURE_FORMAT_RGBA_EXT:
1934             format = *attr;
1935             break;
1936          default:
1937             /* error */
1938             return 0;
1939          }
1940          break;
1941       case GLX_TEXTURE_TARGET_EXT:
1942          attr++;
1943          switch (*attr) {
1944          case GLX_TEXTURE_1D_EXT:
1945          case GLX_TEXTURE_2D_EXT:
1946          case GLX_TEXTURE_RECTANGLE_EXT:
1947             target = *attr;
1948             break;
1949          default:
1950             /* error */
1951             return 0;
1952          }
1953          break;
1954       case GLX_MIPMAP_TEXTURE_EXT:
1955          attr++;
1956          if (*attr)
1957             mipmap = 1;
1958          break;
1959       default:
1960          /* error */
1961          return 0;
1962       }
1963    }
1964
1965    if (format == GLX_TEXTURE_FORMAT_RGB_EXT) {
1966       if (get_config(v, GLX_BIND_TO_TEXTURE_RGB_EXT,
1967                      &value, GL_TRUE) != Success
1968           || !value) {
1969          return 0; /* error! */
1970       }
1971    }
1972    else if (format == GLX_TEXTURE_FORMAT_RGBA_EXT) {
1973       if (get_config(v, GLX_BIND_TO_TEXTURE_RGBA_EXT,
1974                      &value, GL_TRUE) != Success
1975           || !value) {
1976          return 0; /* error! */
1977       }
1978    }
1979    if (mipmap) {
1980       if (get_config(v, GLX_BIND_TO_MIPMAP_TEXTURE_EXT,
1981                      &value, GL_TRUE) != Success
1982           || !value) {
1983          return 0; /* error! */
1984       }
1985    }
1986    if (target == GLX_TEXTURE_1D_EXT) {
1987       if (get_config(v, GLX_BIND_TO_TEXTURE_TARGETS_EXT,
1988                      &value, GL_TRUE) != Success
1989           || (value & GLX_TEXTURE_1D_BIT_EXT) == 0) {
1990          return 0; /* error! */
1991       }
1992    }
1993    else if (target == GLX_TEXTURE_2D_EXT) {
1994       if (get_config(v, GLX_BIND_TO_TEXTURE_TARGETS_EXT,
1995                      &value, GL_TRUE) != Success
1996           || (value & GLX_TEXTURE_2D_BIT_EXT) == 0) {
1997          return 0; /* error! */
1998       }
1999    }
2000    if (target == GLX_TEXTURE_RECTANGLE_EXT) {
2001       if (get_config(v, GLX_BIND_TO_TEXTURE_TARGETS_EXT,
2002                      &value, GL_TRUE) != Success
2003           || (value & GLX_TEXTURE_RECTANGLE_BIT_EXT) == 0) {
2004          return 0; /* error! */
2005       }
2006    }
2007
2008    if (format || target || mipmap) {
2009       /* texture from pixmap */
2010       b = XMesaCreatePixmapTextureBuffer(v, pixmap, 0, format, target, mipmap);
2011    }
2012    else {
2013       b = XMesaCreatePixmapBuffer( v, pixmap, 0 );
2014    }
2015    if (!b) {
2016       return 0;
2017    }
2018
2019    return pixmap;
2020 }
2021
2022
2023 PUBLIC void
2024 glXDestroyPixmap( Display *dpy, GLXPixmap pixmap )
2025 {
2026    XMesaBuffer b = XMesaFindBuffer(dpy, (Drawable)pixmap);
2027    if (b)
2028       XMesaDestroyBuffer(b);
2029    /* don't destroy X pixmap */
2030 }
2031
2032
2033 PUBLIC GLXPbuffer
2034 glXCreatePbuffer(Display *dpy, GLXFBConfig config, const int *attribList)
2035 {
2036    XMesaVisual xmvis = (XMesaVisual) config;
2037    XMesaBuffer xmbuf;
2038    const int *attrib;
2039    int width = 0, height = 0;
2040    GLboolean useLargest = GL_FALSE, preserveContents = GL_FALSE;
2041
2042    (void) dpy;
2043
2044    for (attrib = attribList; *attrib; attrib++) {
2045       switch (*attrib) {
2046          case GLX_PBUFFER_WIDTH:
2047             attrib++;
2048             width = *attrib;
2049             break;
2050          case GLX_PBUFFER_HEIGHT:
2051             attrib++;
2052             height = *attrib;
2053             break;
2054          case GLX_PRESERVED_CONTENTS:
2055             attrib++;
2056             preserveContents = *attrib;
2057             break;
2058          case GLX_LARGEST_PBUFFER:
2059             attrib++;
2060             useLargest = *attrib;
2061             break;
2062          default:
2063             return 0;
2064       }
2065    }
2066
2067    if (width == 0 || height == 0)
2068       return 0;
2069
2070    if (width > PBUFFER_MAX_SIZE || height > PBUFFER_MAX_SIZE) {
2071       /* If allocation would have failed and GLX_LARGEST_PBUFFER is set,
2072        * allocate the largest possible buffer.
2073        */
2074       if (useLargest) {
2075          width = PBUFFER_MAX_SIZE;
2076          height = PBUFFER_MAX_SIZE;
2077       }
2078    }
2079
2080    xmbuf = XMesaCreatePBuffer( xmvis, 0, width, height);
2081    /* A GLXPbuffer handle must be an X Drawable because that's what
2082     * glXMakeCurrent takes.
2083     */
2084    if (xmbuf) {
2085       xmbuf->largestPbuffer = useLargest;
2086       xmbuf->preservedContents = preserveContents;
2087       return (GLXPbuffer) xmbuf->ws.drawable;
2088    }
2089    else {
2090       return 0;
2091    }
2092 }
2093
2094
2095 PUBLIC void
2096 glXDestroyPbuffer( Display *dpy, GLXPbuffer pbuf )
2097 {
2098    XMesaBuffer b = XMesaFindBuffer(dpy, pbuf);
2099    if (b) {
2100       XMesaDestroyBuffer(b);
2101    }
2102 }
2103
2104
2105 PUBLIC void
2106 glXQueryDrawable(Display *dpy, GLXDrawable draw, int attribute,
2107                  unsigned int *value)
2108 {
2109    GLuint width, height;
2110    XMesaBuffer xmbuf = XMesaFindBuffer(dpy, draw);
2111    if (!xmbuf) {
2112       generate_error(dpy, GLXBadDrawable, draw, X_GLXGetDrawableAttributes, False);
2113       return;
2114    }
2115
2116    /* make sure buffer's dimensions are up to date */
2117    xmesa_get_window_size(dpy, xmbuf, &width, &height);
2118
2119    switch (attribute) {
2120       case GLX_WIDTH:
2121          *value = width;
2122          break;
2123       case GLX_HEIGHT:
2124          *value = height;
2125          break;
2126       case GLX_PRESERVED_CONTENTS:
2127          *value = xmbuf->preservedContents;
2128          break;
2129       case GLX_LARGEST_PBUFFER:
2130          *value = xmbuf->largestPbuffer;
2131          break;
2132       case GLX_FBCONFIG_ID:
2133          *value = xmbuf->xm_visual->visinfo->visualid;
2134          return;
2135       case GLX_TEXTURE_FORMAT_EXT:
2136          *value = xmbuf->TextureFormat;
2137          break;
2138       case GLX_TEXTURE_TARGET_EXT:
2139          *value = xmbuf->TextureTarget;
2140          break;
2141       case GLX_MIPMAP_TEXTURE_EXT:
2142          *value = xmbuf->TextureMipmap;
2143          break;
2144
2145       default:
2146          generate_error(dpy, BadValue, 0, X_GLXCreateContextAttribsARB, true);
2147          return;
2148    }
2149 }
2150
2151
2152 PUBLIC GLXContext
2153 glXCreateNewContext( Display *dpy, GLXFBConfig config,
2154                      int renderType, GLXContext shareCtx, Bool direct )
2155 {
2156    XMesaVisual xmvis = (XMesaVisual) config;
2157
2158    if (!dpy || !config ||
2159        (renderType != GLX_RGBA_TYPE && renderType != GLX_COLOR_INDEX_TYPE))
2160       return 0;
2161
2162    return create_context(dpy, xmvis,
2163                          shareCtx ? shareCtx->xmesaContext : NULL,
2164                          direct,
2165                          1, 0, GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB, 0x0);
2166 }
2167
2168
2169 PUBLIC int
2170 glXQueryContext( Display *dpy, GLXContext ctx, int attribute, int *value )
2171 {
2172    GLXContext glxCtx = ctx;
2173    XMesaContext xmctx = glxCtx->xmesaContext;
2174
2175    (void) dpy;
2176    (void) ctx;
2177
2178    switch (attribute) {
2179    case GLX_FBCONFIG_ID:
2180       *value = xmctx->xm_visual->visinfo->visualid;
2181       break;
2182    case GLX_RENDER_TYPE:
2183       *value = GLX_RGBA_TYPE;
2184       break;
2185    case GLX_SCREEN:
2186       *value = 0;
2187       return Success;
2188    default:
2189       return GLX_BAD_ATTRIBUTE;
2190    }
2191    return 0;
2192 }
2193
2194
2195 PUBLIC void
2196 glXSelectEvent( Display *dpy, GLXDrawable drawable, unsigned long mask )
2197 {
2198    XMesaBuffer xmbuf = XMesaFindBuffer(dpy, drawable);
2199    if (xmbuf)
2200       xmbuf->selectedEvents = mask;
2201 }
2202
2203
2204 PUBLIC void
2205 glXGetSelectedEvent(Display *dpy, GLXDrawable drawable, unsigned long *mask)
2206 {
2207    XMesaBuffer xmbuf = XMesaFindBuffer(dpy, drawable);
2208    if (xmbuf)
2209       *mask = xmbuf->selectedEvents;
2210    else
2211       *mask = 0;
2212 }
2213
2214
2215
2216 /*** GLX_SGI_swap_control ***/
2217
2218 PUBLIC int
2219 glXSwapIntervalSGI(int interval)
2220 {
2221    (void) interval;
2222    return 0;
2223 }
2224
2225
2226
2227 /*** GLX_SGI_video_sync ***/
2228
2229 static unsigned int FrameCounter = 0;
2230
2231 PUBLIC int
2232 glXGetVideoSyncSGI(unsigned int *count)
2233 {
2234    /* this is a bogus implementation */
2235    *count = FrameCounter++;
2236    return 0;
2237 }
2238
2239 PUBLIC int
2240 glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count)
2241 {
2242    if (divisor <= 0 || remainder < 0)
2243       return GLX_BAD_VALUE;
2244    /* this is a bogus implementation */
2245    FrameCounter++;
2246    while (FrameCounter % divisor != remainder)
2247       FrameCounter++;
2248    *count = FrameCounter;
2249    return 0;
2250 }
2251
2252
2253
2254 /*** GLX_SGI_make_current_read ***/
2255
2256 PUBLIC Bool
2257 glXMakeCurrentReadSGI(Display *dpy, GLXDrawable draw, GLXDrawable read,
2258                       GLXContext ctx)
2259 {
2260    return glXMakeContextCurrent( dpy, draw, read, ctx );
2261 }
2262
2263 /* not used
2264 static GLXDrawable
2265 glXGetCurrentReadDrawableSGI(void)
2266 {
2267    return 0;
2268 }
2269 */
2270
2271
2272 /*** GLX_SGIX_video_source ***/
2273 #if defined(_VL_H)
2274
2275 PUBLIC GLXVideoSourceSGIX
2276 glXCreateGLXVideoSourceSGIX(Display *dpy, int screen, VLServer server,
2277                             VLPath path, int nodeClass, VLNode drainNode)
2278 {
2279    (void) dpy;
2280    (void) screen;
2281    (void) server;
2282    (void) path;
2283    (void) nodeClass;
2284    (void) drainNode;
2285    return 0;
2286 }
2287
2288 PUBLIC void
2289 glXDestroyGLXVideoSourceSGIX(Display *dpy, GLXVideoSourceSGIX src)
2290 {
2291    (void) dpy;
2292    (void) src;
2293 }
2294
2295 #endif
2296
2297
2298 /*** GLX_EXT_import_context ***/
2299
2300 PUBLIC void
2301 glXFreeContextEXT(Display *dpy, GLXContext context)
2302 {
2303    (void) dpy;
2304    (void) context;
2305 }
2306
2307 PUBLIC GLXContextID
2308 glXGetContextIDEXT(const GLXContext context)
2309 {
2310    (void) context;
2311    return 0;
2312 }
2313
2314 PUBLIC GLXContext
2315 glXImportContextEXT(Display *dpy, GLXContextID contextID)
2316 {
2317    (void) dpy;
2318    (void) contextID;
2319    return 0;
2320 }
2321
2322 PUBLIC int
2323 glXQueryContextInfoEXT(Display *dpy, GLXContext context, int attribute,
2324                        int *value)
2325 {
2326    (void) dpy;
2327    (void) context;
2328    (void) attribute;
2329    (void) value;
2330    return 0;
2331 }
2332
2333
2334
2335 /*** GLX_SGIX_fbconfig ***/
2336
2337 PUBLIC int
2338 glXGetFBConfigAttribSGIX(Display *dpy, GLXFBConfigSGIX config,
2339                          int attribute, int *value)
2340 {
2341    return glXGetFBConfigAttrib(dpy, config, attribute, value);
2342 }
2343
2344 PUBLIC GLXFBConfigSGIX *
2345 glXChooseFBConfigSGIX(Display *dpy, int screen, int *attrib_list,
2346                       int *nelements)
2347 {
2348    return (GLXFBConfig *) glXChooseFBConfig(dpy, screen,
2349                                             attrib_list, nelements);
2350 }
2351
2352
2353 PUBLIC GLXPixmap
2354 glXCreateGLXPixmapWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config,
2355                                  Pixmap pixmap)
2356 {
2357    XMesaVisual xmvis = (XMesaVisual) config;
2358    XMesaBuffer xmbuf = XMesaCreatePixmapBuffer(xmvis, pixmap, 0);
2359    return xmbuf->ws.drawable; /* need to return an X ID */
2360 }
2361
2362
2363 PUBLIC GLXContext
2364 glXCreateContextWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config,
2365                                int renderType, GLXContext shareCtx,
2366                                Bool direct)
2367 {
2368    XMesaVisual xmvis = (XMesaVisual) config;
2369
2370    if (!dpy || !config ||
2371        (renderType != GLX_RGBA_TYPE && renderType != GLX_COLOR_INDEX_TYPE))
2372       return 0;
2373
2374    return create_context(dpy, xmvis,
2375                          shareCtx ? shareCtx->xmesaContext : NULL,
2376                          direct,
2377                          1, 0, GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB, 0x0);
2378 }
2379
2380
2381 PUBLIC XVisualInfo *
2382 glXGetVisualFromFBConfigSGIX(Display *dpy, GLXFBConfigSGIX config)
2383 {
2384    return glXGetVisualFromFBConfig(dpy, config);
2385 }
2386
2387
2388 PUBLIC GLXFBConfigSGIX
2389 glXGetFBConfigFromVisualSGIX(Display *dpy, XVisualInfo *vis)
2390 {
2391    XMesaVisual xmvis = find_glx_visual(dpy, vis);
2392    if (!xmvis) {
2393       /* This visual wasn't found with glXChooseVisual() */
2394       xmvis = create_glx_visual(dpy, vis);
2395    }
2396
2397    return (GLXFBConfigSGIX) xmvis;
2398 }
2399
2400
2401
2402 /*** GLX_SGIX_pbuffer ***/
2403
2404 PUBLIC GLXPbufferSGIX
2405 glXCreateGLXPbufferSGIX(Display *dpy, GLXFBConfigSGIX config,
2406                         unsigned int width, unsigned int height,
2407                         int *attribList)
2408 {
2409    XMesaVisual xmvis = (XMesaVisual) config;
2410    XMesaBuffer xmbuf;
2411    const int *attrib;
2412    GLboolean useLargest = GL_FALSE, preserveContents = GL_FALSE;
2413
2414    (void) dpy;
2415
2416    for (attrib = attribList; attrib && *attrib; attrib++) {
2417       switch (*attrib) {
2418          case GLX_PRESERVED_CONTENTS_SGIX:
2419             attrib++;
2420             preserveContents = *attrib; /* ignored */
2421             break;
2422          case GLX_LARGEST_PBUFFER_SGIX:
2423             attrib++;
2424             useLargest = *attrib; /* ignored */
2425             break;
2426          default:
2427             return 0;
2428       }
2429    }
2430
2431    /* not used at this time */
2432    (void) useLargest;
2433    (void) preserveContents;
2434
2435    xmbuf = XMesaCreatePBuffer( xmvis, 0, width, height);
2436    /* A GLXPbuffer handle must be an X Drawable because that's what
2437     * glXMakeCurrent takes.
2438     */
2439    return (GLXPbuffer) xmbuf->ws.drawable;
2440 }
2441
2442
2443 PUBLIC void
2444 glXDestroyGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf)
2445 {
2446    XMesaBuffer xmbuf = XMesaFindBuffer(dpy, pbuf);
2447    if (xmbuf) {
2448       XMesaDestroyBuffer(xmbuf);
2449    }
2450 }
2451
2452
2453 PUBLIC void
2454 glXQueryGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf, int attribute,
2455                        unsigned int *value)
2456 {
2457    const XMesaBuffer xmbuf = XMesaFindBuffer(dpy, pbuf);
2458
2459    if (!xmbuf) {
2460       /* Generate GLXBadPbufferSGIX for bad pbuffer */
2461       return;
2462    }
2463
2464    switch (attribute) {
2465       case GLX_PRESERVED_CONTENTS_SGIX:
2466          *value = True;
2467          break;
2468       case GLX_LARGEST_PBUFFER_SGIX:
2469          *value = xmesa_buffer_width(xmbuf) * xmesa_buffer_height(xmbuf);
2470          break;
2471       case GLX_WIDTH_SGIX:
2472          *value = xmesa_buffer_width(xmbuf);
2473          break;
2474       case GLX_HEIGHT_SGIX:
2475          *value = xmesa_buffer_height(xmbuf);
2476          break;
2477       case GLX_EVENT_MASK_SGIX:
2478          *value = 0;  /* XXX might be wrong */
2479          break;
2480       default:
2481          *value = 0;
2482    }
2483 }
2484
2485
2486 PUBLIC void
2487 glXSelectEventSGIX(Display *dpy, GLXDrawable drawable, unsigned long mask)
2488 {
2489    XMesaBuffer xmbuf = XMesaFindBuffer(dpy, drawable);
2490    if (xmbuf) {
2491       /* Note: we'll never generate clobber events */
2492       xmbuf->selectedEvents = mask;
2493    }
2494 }
2495
2496
2497 PUBLIC void
2498 glXGetSelectedEventSGIX(Display *dpy, GLXDrawable drawable,
2499                         unsigned long *mask)
2500 {
2501    XMesaBuffer xmbuf = XMesaFindBuffer(dpy, drawable);
2502    if (xmbuf) {
2503       *mask = xmbuf->selectedEvents;
2504    }
2505    else {
2506       *mask = 0;
2507    }
2508 }
2509
2510
2511
2512 /*** GLX_SGI_cushion ***/
2513
2514 PUBLIC void
2515 glXCushionSGI(Display *dpy, Window win, float cushion)
2516 {
2517    (void) dpy;
2518    (void) win;
2519    (void) cushion;
2520 }
2521
2522
2523
2524 /*** GLX_SGIX_video_resize ***/
2525
2526 PUBLIC int
2527 glXBindChannelToWindowSGIX(Display *dpy, int screen, int channel,
2528                            Window window)
2529 {
2530    (void) dpy;
2531    (void) screen;
2532    (void) channel;
2533    (void) window;
2534    return 0;
2535 }
2536
2537 PUBLIC int
2538 glXChannelRectSGIX(Display *dpy, int screen, int channel,
2539                    int x, int y, int w, int h)
2540 {
2541    (void) dpy;
2542    (void) screen;
2543    (void) channel;
2544    (void) x;
2545    (void) y;
2546    (void) w;
2547    (void) h;
2548    return 0;
2549 }
2550
2551 PUBLIC int
2552 glXQueryChannelRectSGIX(Display *dpy, int screen, int channel,
2553                         int *x, int *y, int *w, int *h)
2554 {
2555    (void) dpy;
2556    (void) screen;
2557    (void) channel;
2558    (void) x;
2559    (void) y;
2560    (void) w;
2561    (void) h;
2562    return 0;
2563 }
2564
2565 PUBLIC int
2566 glXQueryChannelDeltasSGIX(Display *dpy, int screen, int channel,
2567                           int *dx, int *dy, int *dw, int *dh)
2568 {
2569    (void) dpy;
2570    (void) screen;
2571    (void) channel;
2572    (void) dx;
2573    (void) dy;
2574    (void) dw;
2575    (void) dh;
2576    return 0;
2577 }
2578
2579 PUBLIC int
2580 glXChannelRectSyncSGIX(Display *dpy, int screen, int channel, GLenum synctype)
2581 {
2582    (void) dpy;
2583    (void) screen;
2584    (void) channel;
2585    (void) synctype;
2586    return 0;
2587 }
2588
2589
2590
2591 /*** GLX_SGIX_dmbuffer **/
2592
2593 #if defined(_DM_BUFFER_H_)
2594 PUBLIC Bool
2595 glXAssociateDMPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuffer,
2596                           DMparams *params, DMbuffer dmbuffer)
2597 {
2598    (void) dpy;
2599    (void) pbuffer;
2600    (void) params;
2601    (void) dmbuffer;
2602    return False;
2603 }
2604 #endif
2605
2606
2607 /*** GLX_SUN_get_transparent_index ***/
2608
2609 PUBLIC Status
2610 glXGetTransparentIndexSUN(Display *dpy, Window overlay, Window underlay,
2611                           unsigned long *pTransparent)
2612 {
2613    (void) dpy;
2614    (void) overlay;
2615    (void) underlay;
2616    (void) pTransparent;
2617    return 0;
2618 }
2619
2620
2621
2622 /*** GLX_MESA_release_buffers ***/
2623
2624 /*
2625  * Release the depth, stencil, accum buffers attached to a GLXDrawable
2626  * (a window or pixmap) prior to destroying the GLXDrawable.
2627  */
2628 PUBLIC Bool
2629 glXReleaseBuffersMESA( Display *dpy, GLXDrawable d )
2630 {
2631    XMesaBuffer b = XMesaFindBuffer(dpy, d);
2632    if (b) {
2633       XMesaDestroyBuffer(b);
2634       return True;
2635    }
2636    return False;
2637 }
2638
2639 /*** GLX_EXT_texture_from_pixmap ***/
2640
2641 PUBLIC void
2642 glXBindTexImageEXT(Display *dpy, GLXDrawable drawable, int buffer,
2643                         const int *attrib_list)
2644 {
2645    XMesaBuffer b = XMesaFindBuffer(dpy, drawable);
2646    if (b)
2647       XMesaBindTexImage(dpy, b, buffer, attrib_list);
2648 }
2649
2650 PUBLIC void
2651 glXReleaseTexImageEXT(Display *dpy, GLXDrawable drawable, int buffer)
2652 {
2653    XMesaBuffer b = XMesaFindBuffer(dpy, drawable);
2654    if (b)
2655       XMesaReleaseTexImage(dpy, b, buffer);
2656 }
2657
2658
2659
2660 /*** GLX_ARB_create_context ***/
2661
2662
2663 GLXContext
2664 glXCreateContextAttribsARB(Display *dpy, GLXFBConfig config,
2665                            GLXContext shareCtx, Bool direct,
2666                            const int *attrib_list)
2667 {
2668    XMesaVisual xmvis = (XMesaVisual) config;
2669    int majorVersion = 1, minorVersion = 0;
2670    int contextFlags = 0x0;
2671    int profileMask = GLX_CONTEXT_CORE_PROFILE_BIT_ARB;
2672    int renderType = GLX_RGBA_TYPE;
2673    unsigned i;
2674    Bool done = False;
2675    const int contextFlagsAll = (GLX_CONTEXT_DEBUG_BIT_ARB |
2676                                 GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB);
2677    GLXContext ctx;
2678
2679    /* parse attrib_list */
2680    for (i = 0; !done && attrib_list && attrib_list[i]; i++) {
2681       switch (attrib_list[i]) {
2682       case GLX_CONTEXT_MAJOR_VERSION_ARB:
2683          majorVersion = attrib_list[++i];
2684          break;
2685       case GLX_CONTEXT_MINOR_VERSION_ARB:
2686          minorVersion = attrib_list[++i];
2687          break;
2688       case GLX_CONTEXT_FLAGS_ARB:
2689          contextFlags = attrib_list[++i];
2690          break;
2691       case GLX_CONTEXT_PROFILE_MASK_ARB:
2692          profileMask = attrib_list[++i];
2693          break;
2694       case GLX_RENDER_TYPE:
2695          renderType = attrib_list[++i];
2696          break;
2697       case 0:
2698          /* end of list */
2699          done = True;
2700          break;
2701       default:
2702          /* bad attribute */
2703          generate_error(dpy, BadValue, 0, X_GLXCreateContextAttribsARB, True);
2704          return NULL;
2705       }
2706    }
2707
2708    /* check contextFlags */
2709    if (contextFlags & ~contextFlagsAll) {
2710       generate_error(dpy, BadValue, 0, X_GLXCreateContextAttribsARB, True);
2711       return NULL;
2712    }
2713
2714    /* check profileMask */
2715    if (profileMask != GLX_CONTEXT_CORE_PROFILE_BIT_ARB &&
2716        profileMask != GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB &&
2717        profileMask != GLX_CONTEXT_ES_PROFILE_BIT_EXT) {
2718       generate_error(dpy, GLXBadProfileARB, 0, X_GLXCreateContextAttribsARB, False);
2719       return NULL;
2720    }
2721
2722    /* check renderType */
2723    if (renderType != GLX_RGBA_TYPE &&
2724        renderType != GLX_COLOR_INDEX_TYPE) {
2725       generate_error(dpy, BadValue, 0, X_GLXCreateContextAttribsARB, True);
2726       return NULL;
2727    }
2728
2729    /* check version */
2730    if (majorVersion <= 0 ||
2731        minorVersion < 0 ||
2732        (profileMask != GLX_CONTEXT_ES_PROFILE_BIT_EXT &&
2733         ((majorVersion == 1 && minorVersion > 5) ||
2734          (majorVersion == 2 && minorVersion > 1) ||
2735          (majorVersion == 3 && minorVersion > 3) ||
2736          (majorVersion == 4 && minorVersion > 5) ||
2737          majorVersion > 4))) {
2738       generate_error(dpy, BadMatch, 0, X_GLXCreateContextAttribsARB, True);
2739       return NULL;
2740    }
2741    if (profileMask == GLX_CONTEXT_ES_PROFILE_BIT_EXT &&
2742        ((majorVersion == 1 && minorVersion > 1) ||
2743         (majorVersion == 2 && minorVersion > 0) ||
2744         (majorVersion == 3 && minorVersion > 1) ||
2745         majorVersion > 3)) {
2746       /* GLX_EXT_create_context_es2_profile says nothing to justifying a
2747        * different error code for invalid ES versions, but this is what NVIDIA
2748        * does and piglit expects.
2749        */
2750       generate_error(dpy, GLXBadProfileARB, 0, X_GLXCreateContextAttribsARB, False);
2751       return NULL;
2752    }
2753
2754    if ((contextFlags & GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB) &&
2755        majorVersion < 3) {
2756       generate_error(dpy, BadMatch, 0, X_GLXCreateContextAttribsARB, True);
2757       return NULL;
2758    }
2759
2760    if (renderType == GLX_COLOR_INDEX_TYPE && majorVersion >= 3) {
2761       generate_error(dpy, BadMatch, 0, X_GLXCreateContextAttribsARB, True);
2762       return NULL;
2763    }
2764
2765    ctx = create_context(dpy, xmvis,
2766                         shareCtx ? shareCtx->xmesaContext : NULL,
2767                         direct,
2768                         majorVersion, minorVersion,
2769                         profileMask, contextFlags);
2770    if (!ctx) {
2771       generate_error(dpy, GLXBadFBConfig, 0, X_GLXCreateContextAttribsARB, False);
2772    }
2773
2774    return ctx;
2775 }