glxext.c 31.7 KB
Newer Older
1
/*
Adam Jackson's avatar
Adam Jackson committed
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
 * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice including the dates of first publication and
 * either this permission notice or a reference to
 * http://oss.sgi.com/projects/FreeB/
 * shall be included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * Except as contained in this notice, the name of Silicon Graphics, Inc.
 * shall not be used in advertising or otherwise to promote the sale, use or
 * other dealings in this Software without prior written authorization from
 * Silicon Graphics, Inc.
 */
30
31
32
33
34
35
36
37

/**
 * \file glxext.c
 * GLX protocol interface boot-strap code.
 *
 * Direct rendering support added by Precision Insight, Inc.
 *
 * \author Kevin E. Martin <kevin@precisioninsight.com>
38
 */
39

40
#include <assert.h>
41
#include "glxclient.h"
42
43
#include <X11/extensions/Xext.h>
#include <X11/extensions/extutil.h>
44
45
46
47
#ifdef GLX_USE_APPLEGL
#include "apple_glx.h"
#include "apple_visual.h"
#endif
48
49
#include "glxextensions.h"

Brian Paul's avatar
Brian Paul committed
50
#ifdef USE_XCB
Brian Paul's avatar
Brian Paul committed
51
#include <X11/Xlib-xcb.h>
52
53
#include <xcb/xcb.h>
#include <xcb/glx.h>
Brian Paul's avatar
Brian Paul committed
54
55
#endif

56
57

#ifdef DEBUG
58
void __glXDumpDrawBuffer(struct glx_context * ctx);
59
60
61
62
63
64
#endif

/*
** You can set this cell to 1 to force the gl drawing stuff to be
** one command per packet
*/
65
_X_HIDDEN int __glXDebug = 0;
66
67
68

/* Extension required boiler plate */

69
static const char __glXExtensionName[] = GLX_EXTENSION_NAME;
70
  static struct glx_display *glx_displays;
71
72

static /* const */ char *error_list[] = {
73
74
75
76
77
78
79
80
81
82
83
84
85
   "GLXBadContext",
   "GLXBadContextState",
   "GLXBadDrawable",
   "GLXBadPixmap",
   "GLXBadContextTag",
   "GLXBadCurrentWindow",
   "GLXBadRenderRequest",
   "GLXBadLargeRequest",
   "GLXUnsupportedPrivateRequest",
   "GLXBadFBConfig",
   "GLXBadPbuffer",
   "GLXBadCurrentDrawable",
   "GLXBadWindow",
86
   "GLXBadProfileARB",
87
88
};

89
90
91
92
93
#ifdef GLX_USE_APPLEGL
static char *__glXErrorString(Display *dpy, int code, XExtCodes *codes, 
                              char *buf, int n);
#endif

94
95
96
static
XEXT_GENERATE_ERROR_STRING(__glXErrorString, __glXExtensionName,
                           __GLX_NUMBER_ERRORS, error_list)
97

98
99
100
101
102
103
104
105
106
107
108
109
/*
 * GLX events are a bit funky.  We don't stuff the X event code into
 * our user exposed (via XNextEvent) structure.  Instead we use the GLX
 * private event code namespace (and hope it doesn't conflict).  Clients
 * have to know that bit 15 in the event type field means they're getting
 * a GLX event, and then handle the various sub-event types there, rather
 * than simply checking the event code and handling it directly.
 */

static Bool
__glXWireToEvent(Display *dpy, XEvent *event, xEvent *wire)
{
110
     struct glx_display *glx_dpy = __glXInitialize(dpy);
111

112
113
   if (glx_dpy == NULL)
      return False;
114

115
   switch ((wire->u.u.type & 0x7f) - glx_dpy->codes->first_event) {
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
   case GLX_PbufferClobber:
   {
      GLXPbufferClobberEvent *aevent = (GLXPbufferClobberEvent *)event;
      xGLXPbufferClobberEvent *awire = (xGLXPbufferClobberEvent *)wire;
      aevent->event_type = awire->type;
      aevent->serial = awire->sequenceNumber;
      aevent->event_type = awire->event_type;
      aevent->draw_type = awire->draw_type;
      aevent->drawable = awire->drawable;
      aevent->buffer_mask = awire->buffer_mask;
      aevent->aux_buffer = awire->aux_buffer;
      aevent->x = awire->x;
      aevent->y = awire->y;
      aevent->width = awire->width;
      aevent->height = awire->height;
      aevent->count = awire->count;
      return True;
   }
   case GLX_BufferSwapComplete:
   {
      GLXBufferSwapComplete *aevent = (GLXBufferSwapComplete *)event;
137
      xGLXBufferSwapComplete2 *awire = (xGLXBufferSwapComplete2 *)wire;
138
      struct glx_drawable *glxDraw = GetGLXDrawable(dpy, awire->drawable);
139
140
141
142
      aevent->event_type = awire->event_type;
      aevent->drawable = awire->drawable;
      aevent->ust = ((CARD64)awire->ust_hi << 32) | awire->ust_lo;
      aevent->msc = ((CARD64)awire->msc_hi << 32) | awire->msc_lo;
143
144
145
146
147
148
149
150

      if (!glxDraw)
	 return False;

      if (awire->sbc < glxDraw->lastEventSbc)
	 glxDraw->eventSbcWrap += 0x100000000;
      glxDraw->lastEventSbc = awire->sbc;
      aevent->sbc = awire->sbc + glxDraw->eventSbcWrap;
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
      return True;
   }
   default:
      /* client doesn't support server event */
      break;
   }

   return False;
}

/* We don't actually support this.  It doesn't make sense for clients to
 * send each other GLX events.
 */
static Status
__glXEventToWire(Display *dpy, XEvent *event, xEvent *wire)
{
167
     struct glx_display *glx_dpy = __glXInitialize(dpy);
168

169
170
   if (glx_dpy == NULL)
      return False;
171
172
173
174
175
176

   switch (event->type) {
   case GLX_DAMAGED:
      break;
   case GLX_SAVED:
      break;
177
   case GLX_EXCHANGE_COMPLETE_INTEL:
178
      break;
179
   case GLX_COPY_COMPLETE_INTEL:
180
      break;
181
   case GLX_FLIP_COMPLETE_INTEL:
182
183
184
185
186
187
188
189
190
      break;
   default:
      /* client doesn't support server event */
      break;
   }

   return Success;
}

191
192
193
194
195
/************************************************************************/
/*
** Free the per screen configs data as well as the array of
** __glXScreenConfigs.
*/
196
static void
197
FreeScreenConfigs(struct glx_display * priv)
198
{
199
   struct glx_screen *psc;
200
201
202
203
   GLint i, screens;

   /* Free screen configuration information */
   screens = ScreenCount(priv->dpy);
204
   for (i = 0; i < screens; i++) {
205
      psc = priv->screens[i];
206
      glx_screen_cleanup(psc);
207

208
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
209
      if (psc->driScreen) {
210
211
212
         psc->driScreen->destroyScreen(psc);
      } else {
	 Xfree(psc);
213
      }
214
215
#else
      Xfree(psc);
216
#endif
217
   }
218
219
   XFree((char *) priv->screens);
   priv->screens = NULL;
220
221
}

222
223
static void
glx_display_free(struct glx_display *priv)
224
{
225
   struct glx_context *gc;
226
227

   gc = __glXGetCurrentContext();
228
   if (priv->dpy == gc->currentDpy) {
229
      gc->vtable->destroy(gc);
230
231
      __glXSetCurrentContextNull();
   }
232
233

   FreeScreenConfigs(priv);
234
   if (priv->serverGLXvendor)
235
      Xfree((char *) priv->serverGLXvendor);
236
   if (priv->serverGLXversion)
237
      Xfree((char *) priv->serverGLXversion);
238

239
240
   __glxHashDestroy(priv->glXDrawHash);

241
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
242
243
   __glxHashDestroy(priv->drawHash);

244
245
246
247
248
249
250
251
252
253
254
255
   /* Free the direct rendering per display data */
   if (priv->driswDisplay)
      (*priv->driswDisplay->destroyDisplay) (priv->driswDisplay);
   priv->driswDisplay = NULL;

   if (priv->driDisplay)
      (*priv->driDisplay->destroyDisplay) (priv->driDisplay);
   priv->driDisplay = NULL;

   if (priv->dri2Display)
      (*priv->dri2Display->destroyDisplay) (priv->dri2Display);
   priv->dri2Display = NULL;
256
257
#endif

258
   Xfree((char *) priv);
259
260
261
262
263
}

static int
__glXCloseDisplay(Display * dpy, XExtCodes * codes)
{
264
   struct glx_display *priv, **prev;
265
266
267
268
269

   _XLockMutex(_Xglobal_lock);
   prev = &glx_displays;
   for (priv = glx_displays; priv; prev = &priv->next, priv = priv->next) {
      if (priv->dpy == dpy) {
270
         *prev = priv->next;
271
272
273
	 break;
      }
   }
274
   _XUnlockMutex(_Xglobal_lock);
275
276

   glx_display_free(priv);
277

278
279
   return 1;
}
280
281
282
283
284

/*
** Query the version of the GLX extension.  This procedure works even if
** the client extension is not completely set up.
*/
285
286
static Bool
QueryVersion(Display * dpy, int opcode, int *major, int *minor)
287
{
288
289
#ifdef USE_XCB
   xcb_connection_t *c = XGetXCBConnection(dpy);
290
291
292
293
294
295
296
   xcb_glx_query_version_reply_t *reply = xcb_glx_query_version_reply(c,
                                                                      xcb_glx_query_version
                                                                      (c,
                                                                       GLX_MAJOR_VERSION,
                                                                       GLX_MINOR_VERSION),
                                                                      NULL);

297
298
299
   if (!reply)
     return GL_FALSE;

300
   if (reply->major_version != GLX_MAJOR_VERSION) {
301
302
303
304
305
306
307
308
      free(reply);
      return GL_FALSE;
   }
   *major = reply->major_version;
   *minor = min(reply->minor_version, GLX_MINOR_VERSION);
   free(reply);
   return GL_TRUE;
#else
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
   xGLXQueryVersionReq *req;
   xGLXQueryVersionReply reply;

   /* Send the glXQueryVersion request */
   LockDisplay(dpy);
   GetReq(GLXQueryVersion, req);
   req->reqType = opcode;
   req->glxCode = X_GLXQueryVersion;
   req->majorVersion = GLX_MAJOR_VERSION;
   req->minorVersion = GLX_MINOR_VERSION;
   _XReply(dpy, (xReply *) & reply, 0, False);
   UnlockDisplay(dpy);
   SyncHandle();

   if (reply.majorVersion != GLX_MAJOR_VERSION) {
      /*
       ** The server does not support the same major release as this
       ** client.
       */
      return GL_FALSE;
   }
   *major = reply.majorVersion;
   *minor = min(reply.minorVersion, GLX_MINOR_VERSION);
   return GL_TRUE;
333
#endif /* USE_XCB */
334
335
}

336
337
338
339
340
341
342
343
344
/* 
 * We don't want to enable this GLX_OML_swap_method in glxext.h, 
 * because we can't support it.  The X server writes it out though,
 * so we should handle it somehow, to avoid false warnings.
 */
enum {
    IGNORE_GLX_SWAP_METHOD_OML = 0x8060
};

345

346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
static GLint
convert_from_x_visual_type(int visualType)
{
   static const int glx_visual_types[] = {
      GLX_STATIC_GRAY, GLX_GRAY_SCALE,
      GLX_STATIC_COLOR, GLX_PSEUDO_COLOR,
      GLX_TRUE_COLOR, GLX_DIRECT_COLOR
   };

   if (visualType < ARRAY_SIZE(glx_visual_types))
      return glx_visual_types[visualType];

   return GLX_NONE;
}

361
362
363
364
/*
 * getVisualConfigs uses the !tagged_only path.
 * getFBConfigs uses the tagged_only path.
 */
365
_X_HIDDEN void
366
__glXInitializeVisualConfigFromTags(struct glx_config * config, int count,
367
368
                                    const INT32 * bp, Bool tagged_only,
                                    Bool fbconfig_style_tags)
369
{
370
   int i;
371

372
373
374
   if (!tagged_only) {
      /* Copy in the first set of properties */
      config->visualID = *bp++;
375

376
      config->visualType = convert_from_x_visual_type(*bp++);
377

378
      config->rgbMode = *bp++;
379

380
381
382
383
384
385
386
387
      config->redBits = *bp++;
      config->greenBits = *bp++;
      config->blueBits = *bp++;
      config->alphaBits = *bp++;
      config->accumRedBits = *bp++;
      config->accumGreenBits = *bp++;
      config->accumBlueBits = *bp++;
      config->accumAlphaBits = *bp++;
388

389
390
      config->doubleBufferMode = *bp++;
      config->stereoMode = *bp++;
391

392
393
394
395
396
      config->rgbBits = *bp++;
      config->depthBits = *bp++;
      config->stencilBits = *bp++;
      config->numAuxBuffers = *bp++;
      config->level = *bp++;
397

398
399
400
401
402
403
#ifdef GLX_USE_APPLEGL
       /* AppleSGLX supports pixmap and pbuffers with all config. */
       config->drawableType = GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT;
       /* Unfortunately this can create an ABI compatibility problem. */
       count -= 18;
#else
404
      count -= __GLX_MIN_CONFIG_PROPS;
405
#endif
406
   }
407

408
409
   config->sRGBCapable = GL_FALSE;

410
   /*
411
412
413
414
415
416
417
418
    ** Additional properties may be in a list at the end
    ** of the reply.  They are in pairs of property type
    ** and property value.
    */

#define FETCH_OR_SET(tag) \
    config-> tag = ( fbconfig_style_tags ) ? *bp++ : 1

419
   for (i = 0; i < count; i += 2) {
420
421
422
      long int tag = *bp++;
      
      switch (tag) {
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
      case GLX_RGBA:
         FETCH_OR_SET(rgbMode);
         break;
      case GLX_BUFFER_SIZE:
         config->rgbBits = *bp++;
         break;
      case GLX_LEVEL:
         config->level = *bp++;
         break;
      case GLX_DOUBLEBUFFER:
         FETCH_OR_SET(doubleBufferMode);
         break;
      case GLX_STEREO:
         FETCH_OR_SET(stereoMode);
         break;
      case GLX_AUX_BUFFERS:
         config->numAuxBuffers = *bp++;
         break;
      case GLX_RED_SIZE:
         config->redBits = *bp++;
         break;
      case GLX_GREEN_SIZE:
         config->greenBits = *bp++;
         break;
      case GLX_BLUE_SIZE:
         config->blueBits = *bp++;
         break;
      case GLX_ALPHA_SIZE:
         config->alphaBits = *bp++;
         break;
      case GLX_DEPTH_SIZE:
         config->depthBits = *bp++;
         break;
      case GLX_STENCIL_SIZE:
         config->stencilBits = *bp++;
         break;
      case GLX_ACCUM_RED_SIZE:
         config->accumRedBits = *bp++;
         break;
      case GLX_ACCUM_GREEN_SIZE:
         config->accumGreenBits = *bp++;
         break;
      case GLX_ACCUM_BLUE_SIZE:
         config->accumBlueBits = *bp++;
         break;
      case GLX_ACCUM_ALPHA_SIZE:
         config->accumAlphaBits = *bp++;
         break;
      case GLX_VISUAL_CAVEAT_EXT:
         config->visualRating = *bp++;
         break;
      case GLX_X_VISUAL_TYPE:
         config->visualType = *bp++;
         break;
      case GLX_TRANSPARENT_TYPE:
         config->transparentPixel = *bp++;
         break;
      case GLX_TRANSPARENT_INDEX_VALUE:
         config->transparentIndex = *bp++;
         break;
      case GLX_TRANSPARENT_RED_VALUE:
         config->transparentRed = *bp++;
         break;
      case GLX_TRANSPARENT_GREEN_VALUE:
         config->transparentGreen = *bp++;
         break;
      case GLX_TRANSPARENT_BLUE_VALUE:
         config->transparentBlue = *bp++;
         break;
      case GLX_TRANSPARENT_ALPHA_VALUE:
         config->transparentAlpha = *bp++;
         break;
      case GLX_VISUAL_ID:
         config->visualID = *bp++;
         break;
      case GLX_DRAWABLE_TYPE:
         config->drawableType = *bp++;
500
501
502
503
#ifdef GLX_USE_APPLEGL
         /* AppleSGLX supports pixmap and pbuffers with all config. */
         config->drawableType |= GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT;              
#endif
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
         break;
      case GLX_RENDER_TYPE:
         config->renderType = *bp++;
         break;
      case GLX_X_RENDERABLE:
         config->xRenderable = *bp++;
         break;
      case GLX_FBCONFIG_ID:
         config->fbconfigID = *bp++;
         break;
      case GLX_MAX_PBUFFER_WIDTH:
         config->maxPbufferWidth = *bp++;
         break;
      case GLX_MAX_PBUFFER_HEIGHT:
         config->maxPbufferHeight = *bp++;
         break;
      case GLX_MAX_PBUFFER_PIXELS:
         config->maxPbufferPixels = *bp++;
         break;
523
#ifndef GLX_USE_APPLEGL
524
525
526
527
528
529
530
531
532
533
534
535
      case GLX_OPTIMAL_PBUFFER_WIDTH_SGIX:
         config->optimalPbufferWidth = *bp++;
         break;
      case GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX:
         config->optimalPbufferHeight = *bp++;
         break;
      case GLX_VISUAL_SELECT_GROUP_SGIX:
         config->visualSelectGroup = *bp++;
         break;
      case GLX_SWAP_METHOD_OML:
         config->swapMethod = *bp++;
         break;
536
#endif
537
538
539
540
541
542
      case GLX_SAMPLE_BUFFERS_SGIS:
         config->sampleBuffers = *bp++;
         break;
      case GLX_SAMPLES_SGIS:
         config->samples = *bp++;
         break;
543
544
545
546
547
548
#ifdef GLX_USE_APPLEGL
      case IGNORE_GLX_SWAP_METHOD_OML:
         /* We ignore this tag.  See the comment above this function. */
         ++bp;
         break;
#else
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
      case GLX_BIND_TO_TEXTURE_RGB_EXT:
         config->bindToTextureRgb = *bp++;
         break;
      case GLX_BIND_TO_TEXTURE_RGBA_EXT:
         config->bindToTextureRgba = *bp++;
         break;
      case GLX_BIND_TO_MIPMAP_TEXTURE_EXT:
         config->bindToMipmapTexture = *bp++;
         break;
      case GLX_BIND_TO_TEXTURE_TARGETS_EXT:
         config->bindToTextureTargets = *bp++;
         break;
      case GLX_Y_INVERTED_EXT:
         config->yInverted = *bp++;
         break;
564
#endif
565
      case GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT:
566
         config->sRGBCapable = *bp++;
567
568
         break;

569
      case GLX_USE_GL:
570
571
         if (fbconfig_style_tags)
            bp++;
572
         break;
573
574
575
576
      case None:
         i = count;
         break;
      default:
577
578
579
580
581
582
583
584
         if(getenv("LIBGL_DIAGNOSTIC")) {
             long int tagvalue = *bp++;
             fprintf(stderr, "WARNING: unknown GLX tag from server: "
                     "tag 0x%lx value 0x%lx\n", tag, tagvalue);
         } else {
             /* Ignore the unrecognized tag's value */
             bp++;
         }
585
         break;
586
587
588
589
590
      }
   }

   config->renderType =
      (config->rgbMode) ? GLX_RGBA_BIT : GLX_COLOR_INDEX_BIT;
591
592
}

593
static struct glx_config *
594
595
createConfigsFromProperties(Display * dpy, int nvisuals, int nprops,
                            int screen, GLboolean tagged_only)
596
{
597
598
   INT32 buf[__GLX_TOTAL_CONFIG], *props;
   unsigned prop_size;
599
   struct glx_config *modes, *m;
600
601
602
603
604
605
606
607
608
609
610
611
   int i;

   if (nprops == 0)
      return NULL;

   /* FIXME: Is the __GLX_MIN_CONFIG_PROPS test correct for FBconfigs? */

   /* Check number of properties */
   if (nprops < __GLX_MIN_CONFIG_PROPS || nprops > __GLX_MAX_CONFIG_PROPS)
      return NULL;

   /* Allocate memory for our config structure */
612
   modes = glx_config_create_list(nvisuals);
613
614
615
616
617
618
619
620
621
622
623
624
625
   if (!modes)
      return NULL;

   prop_size = nprops * __GLX_SIZE_INT32;
   if (prop_size <= sizeof(buf))
      props = buf;
   else
      props = Xmalloc(prop_size);

   /* Read each config structure and convert it into our format */
   m = modes;
   for (i = 0; i < nvisuals; i++) {
      _XRead(dpy, (char *) props, prop_size);
626
627
#ifdef GLX_USE_APPLEGL
       /* Older X servers don't send this so we default it here. */
628
      m->drawableType = GLX_WINDOW_BIT;
629
630
631
632
633
634
635
636
637
#else
      /* 
       * The XQuartz 2.3.2.1 X server doesn't set this properly, so
       * set the proper bits here.
       * AppleSGLX supports windows, pixmaps, and pbuffers with all config.
       */
      m->drawableType = GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT;
#endif
       __glXInitializeVisualConfigFromTags(m, nprops, props,
638
639
640
641
642
643
644
645
646
                                          tagged_only, GL_TRUE);
      m->screen = screen;
      m = m->next;
   }

   if (props != buf)
      Xfree(props);

   return modes;
647
648
649
}

static GLboolean
650
getVisualConfigs(struct glx_screen *psc,
651
		  struct glx_display *priv, int screen)
652
{
653
   xGLXGetVisualConfigsReq *req;
654
   xGLXGetVisualConfigsReply reply;
655
   Display *dpy = priv->dpy;
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671

   LockDisplay(dpy);

   psc->visuals = NULL;
   GetReq(GLXGetVisualConfigs, req);
   req->reqType = priv->majorOpcode;
   req->glxCode = X_GLXGetVisualConfigs;
   req->screen = screen;

   if (!_XReply(dpy, (xReply *) & reply, 0, False))
      goto out;

   psc->visuals = createConfigsFromProperties(dpy,
                                              reply.numVisuals,
                                              reply.numProps,
                                              screen, GL_FALSE);
672
673

 out:
674
675
   UnlockDisplay(dpy);
   return psc->visuals != NULL;
676
677
678
}

static GLboolean
679
 getFBConfigs(struct glx_screen *psc, struct glx_display *priv, int screen)
680
{
681
682
683
684
   xGLXGetFBConfigsReq *fb_req;
   xGLXGetFBConfigsSGIXReq *sgi_req;
   xGLXVendorPrivateWithReplyReq *vpreq;
   xGLXGetFBConfigsReply reply;
685
   Display *dpy = priv->dpy;
686

687
688
   psc->serverGLXexts =
      __glXQueryServerString(dpy, priv->majorOpcode, screen, GLX_EXTENSIONS);
689
690
691
692
693
694
695
696
697
698
699
700

   LockDisplay(dpy);

   psc->configs = NULL;
   if (atof(priv->serverGLXversion) >= 1.3) {
      GetReq(GLXGetFBConfigs, fb_req);
      fb_req->reqType = priv->majorOpcode;
      fb_req->glxCode = X_GLXGetFBConfigs;
      fb_req->screen = screen;
   }
   else if (strstr(psc->serverGLXexts, "GLX_SGIX_fbconfig") != NULL) {
      GetReqExtra(GLXVendorPrivateWithReply,
701
                  sz_xGLXGetFBConfigsSGIXReq -
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
                  sz_xGLXVendorPrivateWithReplyReq, vpreq);
      sgi_req = (xGLXGetFBConfigsSGIXReq *) vpreq;
      sgi_req->reqType = priv->majorOpcode;
      sgi_req->glxCode = X_GLXVendorPrivateWithReply;
      sgi_req->vendorCode = X_GLXvop_GetFBConfigsSGIX;
      sgi_req->screen = screen;
   }
   else
      goto out;

   if (!_XReply(dpy, (xReply *) & reply, 0, False))
      goto out;

   psc->configs = createConfigsFromProperties(dpy,
                                              reply.numFBConfigs,
                                              reply.numAttribs * 2,
                                              screen, GL_TRUE);
719
720

 out:
721
722
   UnlockDisplay(dpy);
   return psc->configs != NULL;
723
}
724

725
_X_HIDDEN Bool
726
glx_screen_init(struct glx_screen *psc,
727
		 int screen, struct glx_display * priv)
728
729
730
731
732
{
   /* Initialize per screen dynamic client GLX extensions */
   psc->ext_list_first_time = GL_TRUE;
   psc->scr = screen;
   psc->dpy = priv->dpy;
733
   psc->display = priv;
734
735
736
737
738
739
740

   getVisualConfigs(psc, priv, screen);
   getFBConfigs(psc, priv, screen);

   return GL_TRUE;
}

741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
_X_HIDDEN void
glx_screen_cleanup(struct glx_screen *psc)
{
   if (psc->configs) {
      glx_config_destroy_list(psc->configs);
      if (psc->effectiveGLXexts)
          Xfree(psc->effectiveGLXexts);
      psc->configs = NULL;   /* NOTE: just for paranoia */
   }
   if (psc->visuals) {
      glx_config_destroy_list(psc->visuals);
      psc->visuals = NULL;   /* NOTE: just for paranoia */
   }
   Xfree((char *) psc->serverGLXexts);
}

757
758
759
760
/*
** Allocate the memory for the per screen configs for each screen.
** If that works then fetch the per screen configs data.
*/
761
static Bool
762
AllocAndFetchScreenConfigs(Display * dpy, struct glx_display * priv)
763
{
764
   struct glx_screen *psc;
765
   GLint i, screens;
766

767
   /*
768
769
    ** First allocate memory for the array of per screen configs.
    */
770
   screens = ScreenCount(dpy);
771
772
   priv->screens = Xmalloc(screens * sizeof *priv->screens);
   if (!priv->screens)
773
774
      return GL_FALSE;

775
776
   priv->serverGLXversion =
      __glXQueryServerString(dpy, priv->majorOpcode, 0, GLX_VERSION);
777
778
779
780
781
782
   if (priv->serverGLXversion == NULL) {
      FreeScreenConfigs(priv);
      return GL_FALSE;
   }

   for (i = 0; i < screens; i++, psc++) {
783
      psc = NULL;
784
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
785
      if (priv->dri2Display)
786
787
788
789
790
	 psc = (*priv->dri2Display->createScreen) (i, priv);
      if (psc == NULL && priv->driDisplay)
	 psc = (*priv->driDisplay->createScreen) (i, priv);
      if (psc == NULL && priv->driswDisplay)
	 psc = (*priv->driswDisplay->createScreen) (i, priv);
791
792
#endif
#if defined(GLX_USE_APPLEGL)
793
794
795
      if (psc == NULL)
         psc = applegl_create_screen(i, priv);
#else
796
      if (psc == NULL)
797
	 psc = indirect_create_screen(i, priv);
798
#endif
799
      priv->screens[i] = psc;
800
801
802
   }
   SyncHandle();
   return GL_TRUE;
803
804
805
806
807
}

/*
** Initialize the client side extension code.
*/
808
 _X_HIDDEN struct glx_display *
809
__glXInitialize(Display * dpy)
810
{
811
   struct glx_display *dpyPriv, *d;
812
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
813
   Bool glx_direct, glx_accel;
814
#endif
815
   int i;
816

817
   _XLockMutex(_Xglobal_lock);
818

819
820
821
822
823
   for (dpyPriv = glx_displays; dpyPriv; dpyPriv = dpyPriv->next) {
      if (dpyPriv->dpy == dpy) {
	 _XUnlockMutex(_Xglobal_lock);
	 return dpyPriv;
      }
824
825
   }

826
827
828
   /* Drop the lock while we create the display private. */
   _XUnlockMutex(_Xglobal_lock);

829
830
831
832
833
834
835
836
837
   dpyPriv = Xcalloc(1, sizeof *dpyPriv);
   if (!dpyPriv)
      return NULL;

   dpyPriv->codes = XInitExtension(dpy, __glXExtensionName);
   if (!dpyPriv->codes) {
      Xfree(dpyPriv);
      _XUnlockMutex(_Xglobal_lock);
      return NULL;
838
839
   }

840
841
842
843
844
   dpyPriv->dpy = dpy;
   dpyPriv->majorOpcode = dpyPriv->codes->major_opcode;
   dpyPriv->serverGLXvendor = 0x0;
   dpyPriv->serverGLXversion = 0x0;

845
846
847
   /* See if the versions are compatible.  This GLX implementation does not
    * work with servers that only support GLX 1.0.
    */
848
   if (!QueryVersion(dpy, dpyPriv->majorOpcode,
849
850
		     &dpyPriv->majorVersion, &dpyPriv->minorVersion)
       || (dpyPriv->majorVersion == 1 && dpyPriv->minorVersion < 1)) {
851
852
853
      Xfree(dpyPriv);
      _XUnlockMutex(_Xglobal_lock);
      return NULL;
854
855
   }

856
857
858
   for (i = 0; i < __GLX_NUMBER_EVENTS; i++) {
      XESetWireToEvent(dpy, dpyPriv->codes->first_event + i, __glXWireToEvent);
      XESetEventToWire(dpy, dpyPriv->codes->first_event + i, __glXEventToWire);
859
860
   }

861
862
   XESetCloseDisplay(dpy, dpyPriv->codes->extension, __glXCloseDisplay);
   XESetErrorString (dpy, dpyPriv->codes->extension,__glXErrorString);
863

864
865
   dpyPriv->glXDrawHash = __glxHashCreate();

866
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
867
868
   glx_direct = (getenv("LIBGL_ALWAYS_INDIRECT") == NULL);
   glx_accel = (getenv("LIBGL_ALWAYS_SOFTWARE") == NULL);
869

870
871
   dpyPriv->drawHash = __glxHashCreate();

872
   /*
873
874
875
876
    ** Initialize the direct rendering per display data and functions.
    ** Note: This _must_ be done before calling any other DRI routines
    ** (e.g., those called in AllocAndFetchScreenConfigs).
    */
877
878
879
880
881
882
   if (glx_direct && glx_accel) {
      dpyPriv->dri2Display = dri2CreateDisplay(dpy);
      dpyPriv->driDisplay = driCreateDisplay(dpy);
   }
   if (glx_direct)
      dpyPriv->driswDisplay = driswCreateDisplay(dpy);
883
#endif
884

885
#ifdef GLX_USE_APPLEGL
886
   if (!applegl_create_display(dpyPriv)) {
887
888
889
      Xfree(dpyPriv);
      return NULL;
   }
890
#endif
891
892
893
   if (!AllocAndFetchScreenConfigs(dpy, dpyPriv)) {
      Xfree(dpyPriv);
      return NULL;
894
   }
895

896
897
898
#ifdef USE_XCB
   __glX_send_client_info(dpyPriv);
#else
899
   __glXClientInfo(dpy, dpyPriv->majorOpcode);
900
#endif
901

902
903
904
905
906
907
908
909
910
911
912
913
   /* Grab the lock again and add the dispay private, unless somebody
    * beat us to initializing on this display in the meantime. */
   _XLockMutex(_Xglobal_lock);

   for (d = glx_displays; d; d = d->next) {
      if (d->dpy == dpy) {
	 _XUnlockMutex(_Xglobal_lock);
	 glx_display_free(dpyPriv);
	 return d;
      }
   }

914
915
916
917
   dpyPriv->next = glx_displays;
   glx_displays = dpyPriv;

    _XUnlockMutex(_Xglobal_lock);
918
919

   return dpyPriv;
920
921
922
923
924
925
}

/*
** Setup for sending a GLX command on dpy.  Make sure the extension is
** initialized.  Try to avoid calling __glXInitialize as its kinda slow.
*/
926
927
_X_HIDDEN CARD8
__glXSetupForCommand(Display * dpy)
928
{
929
930
    struct glx_context *gc;
    struct glx_display *priv;
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955

   /* If this thread has a current context, flush its rendering commands */
   gc = __glXGetCurrentContext();
   if (gc->currentDpy) {
      /* Flush rendering buffer of the current context, if any */
      (void) __glXFlushRenderBuffer(gc, gc->pc);

      if (gc->currentDpy == dpy) {
         /* Use opcode from gc because its right */
         return gc->majorOpcode;
      }
      else {
         /*
          ** Have to get info about argument dpy because it might be to
          ** a different server
          */
      }
   }

   /* Forced to lookup extension via the slow initialize route */
   priv = __glXInitialize(dpy);
   if (!priv) {
      return 0;
   }
   return priv->majorOpcode;
956
957
}

958
959
/**
 * Flush the drawing command transport buffer.
960
 *
961
962
 * \param ctx  Context whose transport buffer is to be flushed.
 * \param pc   Pointer to first unused buffer location.
963
 *
964
965
966
967
 * \todo
 * Modify this function to use \c ctx->pc instead of the explicit
 * \c pc parameter.
 */
968
_X_HIDDEN GLubyte *
969
__glXFlushRenderBuffer(struct glx_context * ctx, GLubyte * pc)
970
{
971
   Display *const dpy = ctx->currentDpy;
Brian Paul's avatar
Brian Paul committed
972
#ifdef USE_XCB
973
   xcb_connection_t *c = XGetXCBConnection(dpy);
Brian Paul's avatar
Brian Paul committed
974
#else
975
   xGLXRenderReq *req;
Brian Paul's avatar
Brian Paul committed
976
#endif /* USE_XCB */
977
   const GLint size = pc - ctx->buf;
978

979
   if ((dpy != NULL) && (size > 0)) {
Brian Paul's avatar
Brian Paul committed
980
#ifdef USE_XCB
981
982
      xcb_glx_render(c, ctx->currentContextTag, size,
                     (const uint8_t *) ctx->buf);
Brian Paul's avatar
Brian Paul committed
983
#else
984
985
986
987
988
989
990
991
992
993
      /* Send the entire buffer as an X request */
      LockDisplay(dpy);
      GetReq(GLXRender, req);
      req->reqType = ctx->majorOpcode;
      req->glxCode = X_GLXRender;
      req->contextTag = ctx->currentContextTag;
      req->length += (size + 3) >> 2;
      _XSend(dpy, (char *) ctx->buf, size);
      UnlockDisplay(dpy);
      SyncHandle();
Brian Paul's avatar
Brian Paul committed
994
#endif
995
   }
996

997
998
999
   /* Reset pointer and return it */
   ctx->pc = ctx->buf;
   return ctx->pc;
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
}


/**
 * Send a portion of a GLXRenderLarge command to the server.  The advantage of
 * this function over \c __glXSendLargeCommand is that callers can use the
 * data buffer in the GLX context and may be able to avoid allocating an
 * extra buffer.  The disadvantage is the clients will have to do more
 * GLX protocol work (i.e., calculating \c totalRequests, etc.).
 *
 * \sa __glXSendLargeCommand
 *
 * \param gc             GLX context
 * \param requestNumber  Which part of the whole command is this?  The first
 *                       request is 1.
 * \param totalRequests  How many requests will there be?
 * \param data           Command data.
 * \param dataLen        Size, in bytes, of the command data.
 */
1019
_X_HIDDEN void
1020
__glXSendLargeChunk(struct glx_context * gc, GLint requestNumber,
1021
                    GLint totalRequests, const GLvoid * data, GLint dataLen)
1022
{
1023
   Display *dpy = gc->currentDpy;
Brian Paul's avatar
Brian Paul committed
1024
#ifdef USE_XCB
1025
1026
1027
   xcb_connection_t *c = XGetXCBConnection(dpy);
   xcb_glx_render_large(c, gc->currentContextTag, requestNumber,
                        totalRequests, dataLen, data);
Brian Paul's avatar
Brian Paul committed
1028
#else
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
   xGLXRenderLargeReq *req;

   if (requestNumber == 1) {
      LockDisplay(dpy);
   }

   GetReq(GLXRenderLarge, req);
   req->reqType = gc->majorOpcode;
   req->glxCode = X_GLXRenderLarge;
   req->contextTag = gc->currentContextTag;
   req->length += (dataLen + 3) >> 2;
   req->requestNumber = requestNumber;
   req->requestTotal = totalRequests;
   req->dataBytes = dataLen;
   Data(dpy, data, dataLen);

   if (requestNumber == totalRequests) {
      UnlockDisplay(dpy);
      SyncHandle();
   }
Brian Paul's avatar
Brian Paul committed
1049
#endif /* USE_XCB */
1050
1051
1052
1053
1054
}


/**
 * Send a command that is too large for the GLXRender protocol request.
1055
 *
1056
1057
1058
 * Send a large command, one that is too large for some reason to
 * send using the GLXRender protocol request.  One reason to send
 * a large command is to avoid copying the data.
1059
 *
1060
1061
1062
1063
1064
1065
1066
1067
 * \param ctx        GLX context
 * \param header     Header data.
 * \param headerLen  Size, in bytes, of the header data.  It is assumed that
 *                   the header data will always be small enough to fit in
 *                   a single X protocol packet.
 * \param data       Command data.
 * \param dataLen    Size, in bytes, of the command data.
 */
1068
_X_HIDDEN void
1069
__glXSendLargeCommand(struct glx_context * ctx,
1070
1071
                      const GLvoid * header, GLint headerLen,
                      const GLvoid * data, GLint dataLen)
1072
{
1073
1074
   GLint maxSize;
   GLint totalRequests, requestNumber;
1075

1076
   /*
1077
1078
1079
1080
    ** Calculate the maximum amount of data can be stuffed into a single
    ** packet.  sz_xGLXRenderReq is added because bufSize is the maximum
    ** packet size minus sz_xGLXRenderReq.
    */
1081
1082
1083
1084
   maxSize = (ctx->bufSize + sz_xGLXRenderReq) - sz_xGLXRenderLargeReq;
   totalRequests = 1 + (dataLen / maxSize);
   if (dataLen % maxSize)
      totalRequests++;
1085

1086
   /*
1087
1088
    ** Send all of the command, except the large array, as one request.
    */
1089
1090
   assert(headerLen <= maxSize);
   __glXSendLargeChunk(ctx, 1, totalRequests, header, headerLen);
1091

1092
   /*
1093
1094
    ** Send enough requests until the whole array is sent.
    */
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
   for (requestNumber = 2; requestNumber <= (totalRequests - 1);
        requestNumber++) {
      __glXSendLargeChunk(ctx, requestNumber, totalRequests, data, maxSize);
      data = (const GLvoid *) (((const GLubyte *) data) + maxSize);
      dataLen -= maxSize;
      assert(dataLen > 0);
   }

   assert(dataLen <= maxSize);
   __glXSendLargeChunk(ctx, requestNumber, totalRequests, data, dataLen);
1105
1106
1107
1108
1109
}

/************************************************************************/

#ifdef DEBUG
1110
_X_HIDDEN void
1111
__glXDumpDrawBuffer(struct glx_context * ctx)
1112
{
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
   GLubyte *p = ctx->buf;
   GLubyte *end = ctx->pc;
   GLushort opcode, length;

   while (p < end) {
      /* Fetch opcode */
      opcode = *((GLushort *) p);
      length = *((GLushort *) (p + 2));
      printf("%2x: %5d: ", opcode, length);
      length -= 4;
      p += 4;
      while (length > 0) {
         printf("%08x ", *((unsigned *) p));
         p += 4;
         length -= 4;
      }
      printf("\n");
   }
1131
1132
}
#endif