glxcmds.c revision eeaab2047cfce8a7445fd9f835e737682eb503ac 
1/*
2 * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
3 * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice including the dates of first publication and
13 * either this permission notice or a reference to
14 * http://oss.sgi.com/projects/FreeB/
15 * shall be included in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
22 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 * SOFTWARE.
24 *
25 * Except as contained in this notice, the name of Silicon Graphics, Inc.
26 * shall not be used in advertising or otherwise to promote the sale, use or
27 * other dealings in this Software without prior written authorization from
28 * Silicon Graphics, Inc.
29 */
30
31/**
32 * \file glxcmds.c
33 * Client-side GLX interface.
34 */
35
36#include "glxclient.h"
37#include "glapi.h"
38#include "glxextensions.h"
39#include "glcontextmodes.h"
40
41#ifdef GLX_DIRECT_RENDERING
42#ifdef GLX_USE_APPLEGL
43#include "apple_glx_context.h"
44#include "apple_glx.h"
45#include "glx_error.h"
46#define GC_IS_DIRECT(gc) ((gc)->isDirect)
47#else
48#include <sys/time.h>
49#include <X11/extensions/xf86vmode.h>
50#include "xf86dri.h"
51#define GC_IS_DIRECT(gc) ((gc)->driContext != NULL)
52#endif
53#else
54#define GC_IS_DIRECT(gc) (0)
55#endif
56
57#if defined(USE_XCB)
58#include <X11/Xlib-xcb.h>
59#include <xcb/xcb.h>
60#include <xcb/glx.h>
61#endif
62
63static const char __glXGLXClientVendorName[] = "Mesa Project and SGI";
64static const char __glXGLXClientVersion[] = "1.4";
65static const struct glx_context_vtable indirect_context_vtable;
66
67#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
68
69static Bool windowExistsFlag;
70static int
71windowExistsErrorHandler(Display * dpy, XErrorEvent * xerr)
72{
73   (void) dpy;
74
75   if (xerr->error_code == BadWindow) {
76      windowExistsFlag = GL_FALSE;
77   }
78   return 0;
79}
80
81/**
82 * Find drawables in the local hash that have been destroyed on the
83 * server.
84 *
85 * \param dpy    Display to destroy drawables for
86 * \param screen Screen number to destroy drawables for
87 */
88static void
89GarbageCollectDRIDrawables(__GLXscreenConfigs * sc)
90{
91   XID draw;
92   __GLXDRIdrawable *pdraw;
93   __GLXdisplayPrivate *priv = sc->display;
94   XWindowAttributes xwa;
95   int (*oldXErrorHandler) (Display *, XErrorEvent *);
96
97   /* Set no-op error handler so Xlib doesn't bail out if the windows
98    * has alreay been destroyed on the server. */
99   XSync(priv->dpy, GL_FALSE);
100   oldXErrorHandler = XSetErrorHandler(windowExistsErrorHandler);
101
102   if (__glxHashFirst(priv->drawHash, &draw, (void *) &pdraw) == 1) {
103      do {
104         windowExistsFlag = GL_TRUE;
105         XGetWindowAttributes(priv->dpy, draw, &xwa); /* dummy request */
106         if (!windowExistsFlag) {
107            /* Destroy the local drawable data, if the drawable no
108               longer exists in the Xserver */
109            (*pdraw->destroyDrawable) (pdraw);
110            __glxHashDelete(priv->drawHash, draw);
111         }
112      } while (__glxHashNext(priv->drawHash, &draw, (void *) &pdraw) == 1);
113   }
114
115   XSync(priv->dpy, GL_FALSE);
116   XSetErrorHandler(oldXErrorHandler);
117}
118
119/**
120 * Get the __DRIdrawable for the drawable associated with a GLXContext
121 *
122 * \param dpy       The display associated with \c drawable.
123 * \param drawable  GLXDrawable whose __DRIdrawable part is to be retrieved.
124 * \param scrn_num  If non-NULL, the drawables screen is stored there
125 * \returns  A pointer to the context's __DRIdrawable on success, or NULL if
126 *           the drawable is not associated with a direct-rendering context.
127 */
128_X_HIDDEN __GLXDRIdrawable *
129GetGLXDRIDrawable(Display * dpy, GLXDrawable drawable)
130{
131   __GLXdisplayPrivate *priv = __glXInitialize(dpy);
132   __GLXDRIdrawable *pdraw;
133
134   if (priv == NULL)
135      return NULL;
136
137   if (__glxHashLookup(priv->drawHash, drawable, (void *) &pdraw) == 0)
138      return pdraw;
139
140   return NULL;
141}
142
143#endif
144
145
146/**
147 * Get the GLX per-screen data structure associated with a GLX context.
148 *
149 * \param dpy   Display for which the GLX per-screen information is to be
150 *              retrieved.
151 * \param scrn  Screen on \c dpy for which the GLX per-screen information is
152 *              to be retrieved.
153 * \returns A pointer to the GLX per-screen data if \c dpy and \c scrn
154 *          specify a valid GLX screen, or NULL otherwise.
155 *
156 * \todo Should this function validate that \c scrn is within the screen
157 *       number range for \c dpy?
158 */
159
160static __GLXscreenConfigs *
161GetGLXScreenConfigs(Display * dpy, int scrn)
162{
163   __GLXdisplayPrivate *const priv = __glXInitialize(dpy);
164
165   return (priv
166           && priv->screenConfigs !=
167           NULL) ? priv->screenConfigs[scrn] : NULL;
168}
169
170
171static int
172GetGLXPrivScreenConfig(Display * dpy, int scrn, __GLXdisplayPrivate ** ppriv,
173                       __GLXscreenConfigs ** ppsc)
174{
175   /* Initialize the extension, if needed .  This has the added value
176    * of initializing/allocating the display private
177    */
178
179   if (dpy == NULL) {
180      return GLX_NO_EXTENSION;
181   }
182
183   *ppriv = __glXInitialize(dpy);
184   if (*ppriv == NULL) {
185      return GLX_NO_EXTENSION;
186   }
187
188   /* Check screen number to see if its valid */
189   if ((scrn < 0) || (scrn >= ScreenCount(dpy))) {
190      return GLX_BAD_SCREEN;
191   }
192
193   /* Check to see if the GL is supported on this screen */
194   *ppsc = (*ppriv)->screenConfigs[scrn];
195   if ((*ppsc)->configs == NULL) {
196      /* No support for GL on this screen regardless of visual */
197      return GLX_BAD_VISUAL;
198   }
199
200   return Success;
201}
202
203
204/**
205 * Determine if a \c GLXFBConfig supplied by the application is valid.
206 *
207 * \param dpy     Application supplied \c Display pointer.
208 * \param config  Application supplied \c GLXFBConfig.
209 *
210 * \returns If the \c GLXFBConfig is valid, the a pointer to the matching
211 *          \c __GLcontextModes structure is returned.  Otherwise, \c NULL
212 *          is returned.
213 */
214static __GLcontextModes *
215ValidateGLXFBConfig(Display * dpy, GLXFBConfig config)
216{
217   __GLXdisplayPrivate *const priv = __glXInitialize(dpy);
218   const unsigned num_screens = ScreenCount(dpy);
219   unsigned i;
220   const __GLcontextModes *modes;
221
222
223   if (priv != NULL) {
224      for (i = 0; i < num_screens; i++) {
225         for (modes = priv->screenConfigs[i]->configs; modes != NULL;
226              modes = modes->next) {
227            if (modes == (__GLcontextModes *) config) {
228               return (__GLcontextModes *) config;
229            }
230         }
231      }
232   }
233
234   return NULL;
235}
236
237
238/**
239 * \todo It should be possible to move the allocate of \c client_state_private
240 * later in the function for direct-rendering contexts.  Direct-rendering
241 * contexts don't need to track client state, so they don't need that memory
242 * at all.
243 *
244 * \todo Eliminate \c __glXInitVertexArrayState.  Replace it with a new
245 * function called \c __glXAllocateClientState that allocates the memory and
246 * does all the initialization (including the pixel pack / unpack).
247 */
248static GLXContext
249AllocateGLXContext(Display * dpy)
250{
251   GLXContext gc;
252   int bufSize;
253   CARD8 opcode;
254   __GLXattribute *state;
255
256   if (!dpy)
257      return NULL;
258
259   opcode = __glXSetupForCommand(dpy);
260   if (!opcode) {
261      return NULL;
262   }
263
264   /* Allocate our context record */
265   gc = (GLXContext) Xmalloc(sizeof(struct __GLXcontextRec));
266   if (!gc) {
267      /* Out of memory */
268      return NULL;
269   }
270   memset(gc, 0, sizeof(struct __GLXcontextRec));
271
272   gc->vtable = &indirect_context_vtable;
273   state = Xmalloc(sizeof(struct __GLXattributeRec));
274   if (state == NULL) {
275      /* Out of memory */
276      Xfree(gc);
277      return NULL;
278   }
279   gc->client_state_private = state;
280   memset(gc->client_state_private, 0, sizeof(struct __GLXattributeRec));
281   state->NoDrawArraysProtocol = (getenv("LIBGL_NO_DRAWARRAYS") != NULL);
282
283   /*
284    ** Create a temporary buffer to hold GLX rendering commands.  The size
285    ** of the buffer is selected so that the maximum number of GLX rendering
286    ** commands can fit in a single X packet and still have room in the X
287    ** packet for the GLXRenderReq header.
288    */
289
290   bufSize = (XMaxRequestSize(dpy) * 4) - sz_xGLXRenderReq;
291   gc->buf = (GLubyte *) Xmalloc(bufSize);
292   if (!gc->buf) {
293      Xfree(gc->client_state_private);
294      Xfree(gc);
295      return NULL;
296   }
297   gc->bufSize = bufSize;
298
299   /* Fill in the new context */
300   gc->renderMode = GL_RENDER;
301
302   state->storePack.alignment = 4;
303   state->storeUnpack.alignment = 4;
304
305   gc->attributes.stackPointer = &gc->attributes.stack[0];
306
307   /*
308    ** PERFORMANCE NOTE: A mode dependent fill image can speed things up.
309    ** Other code uses the fastImageUnpack bit, but it is never set
310    ** to GL_TRUE.
311    */
312   gc->fastImageUnpack = GL_FALSE;
313   gc->fillImage = __glFillImage;
314   gc->pc = gc->buf;
315   gc->bufEnd = gc->buf + bufSize;
316   gc->isDirect = GL_FALSE;
317   if (__glXDebug) {
318      /*
319       ** Set limit register so that there will be one command per packet
320       */
321      gc->limit = gc->buf;
322   }
323   else {
324      gc->limit = gc->buf + bufSize - __GLX_BUFFER_LIMIT_SIZE;
325   }
326   gc->majorOpcode = opcode;
327
328   /*
329    ** Constrain the maximum drawing command size allowed to be
330    ** transfered using the X_GLXRender protocol request.  First
331    ** constrain by a software limit, then constrain by the protocl
332    ** limit.
333    */
334   if (bufSize > __GLX_RENDER_CMD_SIZE_LIMIT) {
335      bufSize = __GLX_RENDER_CMD_SIZE_LIMIT;
336   }
337   if (bufSize > __GLX_MAX_RENDER_CMD_SIZE) {
338      bufSize = __GLX_MAX_RENDER_CMD_SIZE;
339   }
340   gc->maxSmallRenderCommandSize = bufSize;
341
342#ifdef GLX_USE_APPLEGL
343   gc->driContext = NULL;
344   gc->do_destroy = False;
345#endif
346
347   return gc;
348}
349
350_X_HIDDEN Bool
351glx_context_init(__GLXcontext *gc,
352		 __GLXscreenConfigs *psc, const __GLcontextModes *fbconfig)
353{
354   gc->majorOpcode = __glXSetupForCommand(psc->display->dpy);
355   if (!gc->majorOpcode)
356      return GL_FALSE;
357
358   gc->screen = psc->scr;
359   gc->psc = psc;
360   gc->mode = fbconfig;
361   gc->isDirect = GL_TRUE;
362
363   return GL_TRUE;
364}
365
366
367/**
368 * Create a new context.  Exactly one of \c vis and \c fbconfig should be
369 * non-NULL.
370 *
371 * \param use_glx_1_3  For FBConfigs, should GLX 1.3 protocol or
372 *                     SGIX_fbconfig protocol be used?
373 * \param renderType   For FBConfigs, what is the rendering type?
374 */
375
376static GLXContext
377CreateContext(Display * dpy, int generic_id,
378              const __GLcontextModes * const fbconfig,
379              GLXContext shareList,
380              Bool allowDirect,
381	      unsigned code, int renderType, int screen)
382{
383   GLXContext gc = NULL;
384   __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, screen);
385#if defined(GLX_DIRECT_RENDERING) && defined(GLX_USE_APPLEGL)
386   int errorcode;
387   bool x11error;
388#endif
389
390   if (dpy == NULL)
391      return NULL;
392
393   if (generic_id == None)
394      return NULL;
395
396#ifndef GLX_USE_APPLEGL  /* TODO: darwin indirect */
397#ifdef GLX_DIRECT_RENDERING
398   if (allowDirect && psc->driScreen) {
399      gc = psc->driScreen->createContext(psc, fbconfig,
400					 shareList, renderType);
401   }
402#endif
403
404   if (!gc)
405      gc = AllocateGLXContext(dpy);
406   if (!gc)
407      return NULL;
408
409   LockDisplay(dpy);
410   switch (code) {
411   case X_GLXCreateContext: {
412      xGLXCreateContextReq *req;
413
414      /* Send the glXCreateContext request */
415      GetReq(GLXCreateContext, req);
416      req->reqType = gc->majorOpcode;
417      req->glxCode = X_GLXCreateContext;
418      req->context = gc->xid = XAllocID(dpy);
419      req->visual = generic_id;
420      req->screen = screen;
421      req->shareList = shareList ? shareList->xid : None;
422      req->isDirect = GC_IS_DIRECT(gc);
423      break;
424   }
425
426   case X_GLXCreateNewContext: {
427      xGLXCreateNewContextReq *req;
428
429      /* Send the glXCreateNewContext request */
430      GetReq(GLXCreateNewContext, req);
431      req->reqType = gc->majorOpcode;
432      req->glxCode = X_GLXCreateNewContext;
433      req->context = gc->xid = XAllocID(dpy);
434      req->fbconfig = generic_id;
435      req->screen = screen;
436      req->renderType = renderType;
437      req->shareList = shareList ? shareList->xid : None;
438      req->isDirect = GC_IS_DIRECT(gc);
439      break;
440   }
441
442   case X_GLXvop_CreateContextWithConfigSGIX: {
443      xGLXVendorPrivateWithReplyReq *vpreq;
444      xGLXCreateContextWithConfigSGIXReq *req;
445
446      /* Send the glXCreateNewContext request */
447      GetReqExtra(GLXVendorPrivateWithReply,
448		  sz_xGLXCreateContextWithConfigSGIXReq -
449		  sz_xGLXVendorPrivateWithReplyReq, vpreq);
450      req = (xGLXCreateContextWithConfigSGIXReq *) vpreq;
451      req->reqType = gc->majorOpcode;
452      req->glxCode = X_GLXVendorPrivateWithReply;
453      req->vendorCode = X_GLXvop_CreateContextWithConfigSGIX;
454      req->context = gc->xid = XAllocID(dpy);
455      req->fbconfig = generic_id;
456      req->screen = screen;
457      req->renderType = renderType;
458      req->shareList = shareList ? shareList->xid : None;
459      req->isDirect = GC_IS_DIRECT(gc);
460      break;
461   }
462
463   default:
464      /* What to do here?  This case is the sign of an internal error.  It
465       * should never be reachable.
466       */
467      break;
468   }
469
470   UnlockDisplay(dpy);
471   SyncHandle();
472#endif
473
474   gc->imported = GL_FALSE;
475   gc->renderType = renderType;
476
477   /* TODO: darwin: Integrate with above to do indirect */
478#ifdef GLX_USE_APPLEGL
479   if(apple_glx_create_context(&gc->driContext, dpy, screen, fbconfig,
480                               shareList ? shareList->driContext : NULL,
481                               &errorcode, &x11error)) {
482      __glXSendError(dpy, errorcode, 0, X_GLXCreateContext, x11error);
483      __glXFreeContext(gc);
484      return NULL;
485   }
486
487   gc->currentContextTag = -1;
488   gc->mode = fbconfig;
489   gc->isDirect = allowDirect;
490#endif
491
492   return gc;
493}
494
495PUBLIC GLXContext
496glXCreateContext(Display * dpy, XVisualInfo * vis,
497                 GLXContext shareList, Bool allowDirect)
498{
499   const __GLcontextModes *mode = NULL;
500   int renderType = 0;
501
502#if defined(GLX_DIRECT_RENDERING) || defined(GLX_USE_APPLEGL)
503   __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, vis->screen);
504
505   mode = _gl_context_modes_find_visual(psc->visuals, vis->visualid);
506   if (mode == NULL) {
507      xError error;
508
509      error.errorCode = BadValue;
510      error.resourceID = vis->visualid;
511      error.sequenceNumber = dpy->request;
512      error.type = X_Error;
513      error.majorCode = __glXSetupForCommand(dpy);
514      error.minorCode = X_GLXCreateContext;
515      _XError(dpy, &error);
516      return None;
517   }
518
519   renderType = mode->rgbMode ? GLX_RGBA_TYPE : GLX_COLOR_INDEX_TYPE;
520#endif
521
522   return CreateContext(dpy, vis->visualid, mode, shareList, allowDirect,
523                        X_GLXCreateContext, renderType, vis->screen);
524}
525
526_X_HIDDEN void
527__glXFreeContext(__GLXcontext * gc)
528{
529   if (gc->vendor)
530      XFree((char *) gc->vendor);
531   if (gc->renderer)
532      XFree((char *) gc->renderer);
533   if (gc->version)
534      XFree((char *) gc->version);
535   if (gc->extensions)
536      XFree((char *) gc->extensions);
537   __glFreeAttributeState(gc);
538   XFree((char *) gc->buf);
539   Xfree((char *) gc->client_state_private);
540   XFree((char *) gc);
541
542}
543
544/*
545** Destroy the named context
546*/
547static void
548DestroyContext(Display * dpy, GLXContext gc)
549{
550#ifndef GLX_USE_APPLEGL /* TODO: darwin: indirect */
551   xGLXDestroyContextReq *req;
552   GLXContextID xid;
553   CARD8 opcode;
554   GLboolean imported;
555
556   opcode = __glXSetupForCommand(dpy);
557   if (!opcode || !gc) {
558      return;
559   }
560
561   __glXLock();
562   xid = gc->xid;
563   imported = gc->imported;
564   gc->xid = None;
565
566   if (gc->currentDpy) {
567      /* This context is bound to some thread.  According to the man page,
568       * we should not actually delete the context until it's unbound.
569       * Note that we set gc->xid = None above.  In MakeContextCurrent()
570       * we check for that and delete the context there.
571       */
572      __glXUnlock();
573      return;
574   }
575
576#if defined(GLX_DIRECT_RENDERING)
577   /* Destroy the direct rendering context */
578   if (gc->driContext) {
579      GarbageCollectDRIDrawables(gc->psc);
580      if (gc->extensions)
581	 XFree((char *) gc->extensions);
582      (*gc->driContext->destroyContext) (gc);
583   }
584   else
585#endif
586   {
587      __glXFreeVertexArrayState(gc);
588      __glXFreeContext(gc);
589   }
590
591   if (!imported) {
592      /*
593       ** This dpy also created the server side part of the context.
594       ** Send the glXDestroyContext request.
595       */
596      LockDisplay(dpy);
597      GetReq(GLXDestroyContext, req);
598      req->reqType = opcode;
599      req->glxCode = X_GLXDestroyContext;
600      req->context = xid;
601      UnlockDisplay(dpy);
602      SyncHandle();
603   }
604
605#else
606
607   __glXLock();
608   if (gc->currentDpy) {
609      /*
610       * Set the Bool that indicates that we should destroy this GLX context
611       * when the context is no longer current.
612       */
613      gc->do_destroy = True;
614      /* Have to free later cuz it's in use now */
615      __glXUnlock();
616   }
617   else {
618      /* Destroy the handle if not current to anybody */
619      __glXUnlock();
620      if(gc->driContext)
621	 apple_glx_destroy_context(&gc->driContext, dpy);
622      __glXFreeContext(gc);
623   }
624#endif
625}
626
627PUBLIC void
628glXDestroyContext(Display * dpy, GLXContext gc)
629{
630   DestroyContext(dpy, gc);
631}
632
633/*
634** Return the major and minor version #s for the GLX extension
635*/
636PUBLIC Bool
637glXQueryVersion(Display * dpy, int *major, int *minor)
638{
639   __GLXdisplayPrivate *priv;
640
641   /* Init the extension.  This fetches the major and minor version. */
642   priv = __glXInitialize(dpy);
643   if (!priv)
644      return GL_FALSE;
645
646   if (major)
647      *major = priv->majorVersion;
648   if (minor)
649      *minor = priv->minorVersion;
650   return GL_TRUE;
651}
652
653/*
654** Query the existance of the GLX extension
655*/
656PUBLIC Bool
657glXQueryExtension(Display * dpy, int *errorBase, int *eventBase)
658{
659   int major_op, erb, evb;
660   Bool rv;
661
662   rv = XQueryExtension(dpy, GLX_EXTENSION_NAME, &major_op, &evb, &erb);
663   if (rv) {
664      if (errorBase)
665         *errorBase = erb;
666      if (eventBase)
667         *eventBase = evb;
668   }
669   return rv;
670}
671
672static void
673indirect_wait_gl(__GLXcontext *gc)
674{
675   xGLXWaitGLReq *req;
676   Display *dpy = gc->currentDpy;
677
678   /* Flush any pending commands out */
679   __glXFlushRenderBuffer(gc, gc->pc);
680
681   /* Send the glXWaitGL request */
682   LockDisplay(dpy);
683   GetReq(GLXWaitGL, req);
684   req->reqType = gc->majorOpcode;
685   req->glxCode = X_GLXWaitGL;
686   req->contextTag = gc->currentContextTag;
687   UnlockDisplay(dpy);
688   SyncHandle();
689}
690
691/*
692** Put a barrier in the token stream that forces the GL to finish its
693** work before X can proceed.
694*/
695PUBLIC void
696glXWaitGL(void)
697{
698   GLXContext gc = __glXGetCurrentContext();
699
700   if (gc && gc->vtable->use_x_font)
701      gc->vtable->wait_gl(gc);
702}
703
704static void
705indirect_wait_x(__GLXcontext *gc)
706{
707   xGLXWaitXReq *req;
708   Display *dpy = gc->currentDpy;
709
710   /* Flush any pending commands out */
711   __glXFlushRenderBuffer(gc, gc->pc);
712
713   LockDisplay(dpy);
714   GetReq(GLXWaitX, req);
715   req->reqType = gc->majorOpcode;
716   req->glxCode = X_GLXWaitX;
717   req->contextTag = gc->currentContextTag;
718   UnlockDisplay(dpy);
719   SyncHandle();
720}
721
722/*
723** Put a barrier in the token stream that forces X to finish its
724** work before GL can proceed.
725*/
726PUBLIC void
727glXWaitX(void)
728{
729   GLXContext gc = __glXGetCurrentContext();
730
731   if (gc && gc->vtable->use_x_font)
732      gc->vtable->wait_x(gc);
733}
734
735static void
736indirect_use_x_font(__GLXcontext *gc,
737		    Font font, int first, int count, int listBase)
738{
739   xGLXUseXFontReq *req;
740   Display *dpy = gc->currentDpy;
741
742   /* Flush any pending commands out */
743   __glXFlushRenderBuffer(gc, gc->pc);
744
745   /* Send the glXUseFont request */
746   LockDisplay(dpy);
747   GetReq(GLXUseXFont, req);
748   req->reqType = gc->majorOpcode;
749   req->glxCode = X_GLXUseXFont;
750   req->contextTag = gc->currentContextTag;
751   req->font = font;
752   req->first = first;
753   req->count = count;
754   req->listBase = listBase;
755   UnlockDisplay(dpy);
756   SyncHandle();
757}
758
759#ifdef GLX_USE_APPLEGL
760
761static void
762applegl_wait_gl(__GLXcontext *gc)
763{
764   glFinish();
765}
766
767static void
768applegl_wait_x(__GLXcontext *gc)
769{
770   apple_glx_waitx(gc->dpy, gc->driContext);
771}
772
773static const struct glx_context_vtable applegl_context_vtable = {
774   applegl_wait_gl,
775   applegl_wait_x,
776   DRI_glXUseXFont,
777   NULL, /* bind_tex_image, */
778   NULL, /* release_tex_image, */
779};
780
781#endif
782
783PUBLIC void
784glXUseXFont(Font font, int first, int count, int listBase)
785{
786   GLXContext gc = __glXGetCurrentContext();
787
788   if (gc && gc->vtable->use_x_font)
789      gc->vtable->use_x_font(gc, font, first, count, listBase);
790}
791
792/************************************************************************/
793
794/*
795** Copy the source context to the destination context using the
796** attribute "mask".
797*/
798PUBLIC void
799glXCopyContext(Display * dpy, GLXContext source,
800               GLXContext dest, unsigned long mask)
801{
802#ifdef GLX_USE_APPLEGL
803   GLXContext gc = __glXGetCurrentContext();
804   int errorcode;
805   bool x11error;
806
807   if(apple_glx_copy_context(gc->driContext, source->driContext, dest->driContext,
808                             mask, &errorcode, &x11error)) {
809      __glXSendError(dpy, errorcode, 0, X_GLXCopyContext, x11error);
810   }
811
812#else
813   xGLXCopyContextReq *req;
814   GLXContext gc = __glXGetCurrentContext();
815   GLXContextTag tag;
816   CARD8 opcode;
817
818   opcode = __glXSetupForCommand(dpy);
819   if (!opcode) {
820      return;
821   }
822
823#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
824   if (gc->driContext) {
825      /* NOT_DONE: This does not work yet */
826   }
827#endif
828
829   /*
830    ** If the source is the current context, send its tag so that the context
831    ** can be flushed before the copy.
832    */
833   if (source == gc && dpy == gc->currentDpy) {
834      tag = gc->currentContextTag;
835   }
836   else {
837      tag = 0;
838   }
839
840   /* Send the glXCopyContext request */
841   LockDisplay(dpy);
842   GetReq(GLXCopyContext, req);
843   req->reqType = opcode;
844   req->glxCode = X_GLXCopyContext;
845   req->source = source ? source->xid : None;
846   req->dest = dest ? dest->xid : None;
847   req->mask = mask;
848   req->contextTag = tag;
849   UnlockDisplay(dpy);
850   SyncHandle();
851#endif /* GLX_USE_APPLEGL */
852}
853
854
855/**
856 * Determine if a context uses direct rendering.
857 *
858 * \param dpy        Display where the context was created.
859 * \param contextID  ID of the context to be tested.
860 *
861 * \returns \c GL_TRUE if the context is direct rendering or not.
862 */
863static Bool
864__glXIsDirect(Display * dpy, GLXContextID contextID)
865{
866#if !defined(USE_XCB)
867   xGLXIsDirectReq *req;
868   xGLXIsDirectReply reply;
869#endif
870   CARD8 opcode;
871
872   opcode = __glXSetupForCommand(dpy);
873   if (!opcode) {
874      return GL_FALSE;
875   }
876
877#ifdef USE_XCB
878   xcb_connection_t *c = XGetXCBConnection(dpy);
879   xcb_glx_is_direct_reply_t *reply = xcb_glx_is_direct_reply(c,
880                                                              xcb_glx_is_direct
881                                                              (c, contextID),
882                                                              NULL);
883
884   const Bool is_direct = reply->is_direct ? True : False;
885   free(reply);
886
887   return is_direct;
888#else
889   /* Send the glXIsDirect request */
890   LockDisplay(dpy);
891   GetReq(GLXIsDirect, req);
892   req->reqType = opcode;
893   req->glxCode = X_GLXIsDirect;
894   req->context = contextID;
895   _XReply(dpy, (xReply *) & reply, 0, False);
896   UnlockDisplay(dpy);
897   SyncHandle();
898
899   return reply.isDirect;
900#endif /* USE_XCB */
901}
902
903/**
904 * \todo
905 * Shouldn't this function \b always return \c GL_FALSE when
906 * \c GLX_DIRECT_RENDERING is not defined?  Do we really need to bother with
907 * the GLX protocol here at all?
908 */
909PUBLIC Bool
910glXIsDirect(Display * dpy, GLXContext gc)
911{
912   if (!gc) {
913      return GL_FALSE;
914   }
915   else if (GC_IS_DIRECT(gc)) {
916      return GL_TRUE;
917   }
918#ifdef GLX_USE_APPLEGL  /* TODO: indirect on darwin */
919      return GL_FALSE;
920#else
921   return __glXIsDirect(dpy, gc->xid);
922#endif
923}
924
925PUBLIC GLXPixmap
926glXCreateGLXPixmap(Display * dpy, XVisualInfo * vis, Pixmap pixmap)
927{
928#ifdef GLX_USE_APPLEGL
929   int screen = vis->screen;
930   __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, screen);
931   const __GLcontextModes *modes;
932
933   modes = _gl_context_modes_find_visual(psc->visuals, vis->visualid);
934
935   if(apple_glx_pixmap_create(dpy, vis->screen, pixmap, modes))
936      return None;
937
938   return pixmap;
939#else
940   xGLXCreateGLXPixmapReq *req;
941   GLXPixmap xid;
942   CARD8 opcode;
943
944   opcode = __glXSetupForCommand(dpy);
945   if (!opcode) {
946      return None;
947   }
948
949   /* Send the glXCreateGLXPixmap request */
950   LockDisplay(dpy);
951   GetReq(GLXCreateGLXPixmap, req);
952   req->reqType = opcode;
953   req->glxCode = X_GLXCreateGLXPixmap;
954   req->screen = vis->screen;
955   req->visual = vis->visualid;
956   req->pixmap = pixmap;
957   req->glxpixmap = xid = XAllocID(dpy);
958   UnlockDisplay(dpy);
959   SyncHandle();
960
961#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
962   do {
963      /* FIXME: Maybe delay __DRIdrawable creation until the drawable
964       * is actually bound to a context... */
965
966      __GLXdisplayPrivate *const priv = __glXInitialize(dpy);
967      __GLXDRIdrawable *pdraw;
968      __GLXscreenConfigs *psc;
969      __GLcontextModes *modes;
970
971      psc = priv->screenConfigs[vis->screen];
972      if (psc->driScreen == NULL)
973         break;
974      modes = _gl_context_modes_find_visual(psc->visuals, vis->visualid);
975      pdraw = psc->driScreen->createDrawable(psc, pixmap, req->glxpixmap, modes);
976      if (pdraw == NULL) {
977         fprintf(stderr, "failed to create pixmap\n");
978         break;
979      }
980
981      if (__glxHashInsert(priv->drawHash, req->glxpixmap, pdraw)) {
982         (*pdraw->destroyDrawable) (pdraw);
983         return None;           /* FIXME: Check what we're supposed to do here... */
984      }
985   } while (0);
986#endif
987
988   return xid;
989#endif
990}
991
992/*
993** Destroy the named pixmap
994*/
995PUBLIC void
996glXDestroyGLXPixmap(Display * dpy, GLXPixmap glxpixmap)
997{
998#ifdef GLX_USE_APPLEGL
999   if(apple_glx_pixmap_destroy(dpy, glxpixmap))
1000      __glXSendError(dpy, GLXBadPixmap, glxpixmap, X_GLXDestroyPixmap, false);
1001#else
1002   xGLXDestroyGLXPixmapReq *req;
1003   CARD8 opcode;
1004
1005   opcode = __glXSetupForCommand(dpy);
1006   if (!opcode) {
1007      return;
1008   }
1009
1010   /* Send the glXDestroyGLXPixmap request */
1011   LockDisplay(dpy);
1012   GetReq(GLXDestroyGLXPixmap, req);
1013   req->reqType = opcode;
1014   req->glxCode = X_GLXDestroyGLXPixmap;
1015   req->glxpixmap = glxpixmap;
1016   UnlockDisplay(dpy);
1017   SyncHandle();
1018
1019#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
1020   {
1021      __GLXdisplayPrivate *const priv = __glXInitialize(dpy);
1022      __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, glxpixmap);
1023
1024      if (pdraw != NULL) {
1025         (*pdraw->destroyDrawable) (pdraw);
1026         __glxHashDelete(priv->drawHash, glxpixmap);
1027      }
1028   }
1029#endif
1030#endif /* GLX_USE_APPLEGL */
1031}
1032
1033PUBLIC void
1034glXSwapBuffers(Display * dpy, GLXDrawable drawable)
1035{
1036#ifdef GLX_USE_APPLEGL
1037   GLXContext gc = glXGetCurrentContext();
1038   if(gc && apple_glx_is_current_drawable(dpy, gc->driContext, drawable)) {
1039      apple_glx_swap_buffers(gc->driContext);
1040   } else {
1041      __glXSendError(dpy, GLXBadCurrentWindow, 0, X_GLXSwapBuffers, false);
1042   }
1043#else
1044   GLXContext gc;
1045   GLXContextTag tag;
1046   CARD8 opcode;
1047#ifdef USE_XCB
1048   xcb_connection_t *c;
1049#else
1050   xGLXSwapBuffersReq *req;
1051#endif
1052
1053#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
1054   __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable);
1055
1056   if (pdraw != NULL) {
1057      glFlush();
1058      (*pdraw->psc->driScreen->swapBuffers)(pdraw, 0, 0, 0);
1059      return;
1060   }
1061#endif
1062
1063   opcode = __glXSetupForCommand(dpy);
1064   if (!opcode) {
1065      return;
1066   }
1067
1068   /*
1069    ** The calling thread may or may not have a current context.  If it
1070    ** does, send the context tag so the server can do a flush.
1071    */
1072   gc = __glXGetCurrentContext();
1073   if ((gc != NULL) && (dpy == gc->currentDpy) &&
1074       ((drawable == gc->currentDrawable)
1075        || (drawable == gc->currentReadable))) {
1076      tag = gc->currentContextTag;
1077   }
1078   else {
1079      tag = 0;
1080   }
1081
1082#ifdef USE_XCB
1083   c = XGetXCBConnection(dpy);
1084   xcb_glx_swap_buffers(c, tag, drawable);
1085   xcb_flush(c);
1086#else
1087   /* Send the glXSwapBuffers request */
1088   LockDisplay(dpy);
1089   GetReq(GLXSwapBuffers, req);
1090   req->reqType = opcode;
1091   req->glxCode = X_GLXSwapBuffers;
1092   req->drawable = drawable;
1093   req->contextTag = tag;
1094   UnlockDisplay(dpy);
1095   SyncHandle();
1096   XFlush(dpy);
1097#endif /* USE_XCB */
1098#endif /* GLX_USE_APPLEGL */
1099}
1100
1101
1102/*
1103** Return configuration information for the given display, screen and
1104** visual combination.
1105*/
1106PUBLIC int
1107glXGetConfig(Display * dpy, XVisualInfo * vis, int attribute,
1108             int *value_return)
1109{
1110   __GLXdisplayPrivate *priv;
1111   __GLXscreenConfigs *psc;
1112   __GLcontextModes *modes;
1113   int status;
1114
1115   status = GetGLXPrivScreenConfig(dpy, vis->screen, &priv, &psc);
1116   if (status == Success) {
1117      modes = _gl_context_modes_find_visual(psc->visuals, vis->visualid);
1118
1119      /* Lookup attribute after first finding a match on the visual */
1120      if (modes != NULL) {
1121         return _gl_get_context_mode_data(modes, attribute, value_return);
1122      }
1123
1124      status = GLX_BAD_VISUAL;
1125   }
1126
1127   /*
1128    ** If we can't find the config for this visual, this visual is not
1129    ** supported by the OpenGL implementation on the server.
1130    */
1131   if ((status == GLX_BAD_VISUAL) && (attribute == GLX_USE_GL)) {
1132      *value_return = GL_FALSE;
1133      status = Success;
1134   }
1135
1136   return status;
1137}
1138
1139/************************************************************************/
1140
1141static void
1142init_fbconfig_for_chooser(__GLcontextModes * config,
1143                          GLboolean fbconfig_style_tags)
1144{
1145   memset(config, 0, sizeof(__GLcontextModes));
1146   config->visualID = (XID) GLX_DONT_CARE;
1147   config->visualType = GLX_DONT_CARE;
1148
1149   /* glXChooseFBConfig specifies different defaults for these two than
1150    * glXChooseVisual.
1151    */
1152   if (fbconfig_style_tags) {
1153      config->rgbMode = GL_TRUE;
1154      config->doubleBufferMode = GLX_DONT_CARE;
1155   }
1156
1157   config->visualRating = GLX_DONT_CARE;
1158   config->transparentPixel = GLX_NONE;
1159   config->transparentRed = GLX_DONT_CARE;
1160   config->transparentGreen = GLX_DONT_CARE;
1161   config->transparentBlue = GLX_DONT_CARE;
1162   config->transparentAlpha = GLX_DONT_CARE;
1163   config->transparentIndex = GLX_DONT_CARE;
1164
1165   config->drawableType = GLX_WINDOW_BIT;
1166   config->renderType =
1167      (config->rgbMode) ? GLX_RGBA_BIT : GLX_COLOR_INDEX_BIT;
1168   config->xRenderable = GLX_DONT_CARE;
1169   config->fbconfigID = (GLXFBConfigID) (GLX_DONT_CARE);
1170
1171   config->swapMethod = GLX_DONT_CARE;
1172}
1173
1174#define MATCH_DONT_CARE( param )        \
1175  do {                                  \
1176    if ( ((int) a-> param != (int) GLX_DONT_CARE)   \
1177         && (a-> param != b-> param) ) {        \
1178      return False;                             \
1179    }                                           \
1180  } while ( 0 )
1181
1182#define MATCH_MINIMUM( param )                  \
1183  do {                                          \
1184    if ( ((int) a-> param != (int) GLX_DONT_CARE)	\
1185         && (a-> param > b-> param) ) {         \
1186      return False;                             \
1187    }                                           \
1188  } while ( 0 )
1189
1190#define MATCH_EXACT( param )                    \
1191  do {                                          \
1192    if ( a-> param != b-> param) {              \
1193      return False;                             \
1194    }                                           \
1195  } while ( 0 )
1196
1197/* Test that all bits from a are contained in b */
1198#define MATCH_MASK(param)			\
1199  do {						\
1200    if ((a->param & ~b->param) != 0)		\
1201      return False;				\
1202  } while (0);
1203
1204/**
1205 * Determine if two GLXFBConfigs are compatible.
1206 *
1207 * \param a  Application specified config to test.
1208 * \param b  Server specified config to test against \c a.
1209 */
1210static Bool
1211fbconfigs_compatible(const __GLcontextModes * const a,
1212                     const __GLcontextModes * const b)
1213{
1214   MATCH_DONT_CARE(doubleBufferMode);
1215   MATCH_DONT_CARE(visualType);
1216   MATCH_DONT_CARE(visualRating);
1217   MATCH_DONT_CARE(xRenderable);
1218   MATCH_DONT_CARE(fbconfigID);
1219   MATCH_DONT_CARE(swapMethod);
1220
1221   MATCH_MINIMUM(rgbBits);
1222   MATCH_MINIMUM(numAuxBuffers);
1223   MATCH_MINIMUM(redBits);
1224   MATCH_MINIMUM(greenBits);
1225   MATCH_MINIMUM(blueBits);
1226   MATCH_MINIMUM(alphaBits);
1227   MATCH_MINIMUM(depthBits);
1228   MATCH_MINIMUM(stencilBits);
1229   MATCH_MINIMUM(accumRedBits);
1230   MATCH_MINIMUM(accumGreenBits);
1231   MATCH_MINIMUM(accumBlueBits);
1232   MATCH_MINIMUM(accumAlphaBits);
1233   MATCH_MINIMUM(sampleBuffers);
1234   MATCH_MINIMUM(maxPbufferWidth);
1235   MATCH_MINIMUM(maxPbufferHeight);
1236   MATCH_MINIMUM(maxPbufferPixels);
1237   MATCH_MINIMUM(samples);
1238
1239   MATCH_DONT_CARE(stereoMode);
1240   MATCH_EXACT(level);
1241
1242   MATCH_MASK(drawableType);
1243   MATCH_MASK(renderType);
1244
1245   /* There is a bug in a few of the XFree86 DDX drivers.  They contain
1246    * visuals with a "transparent type" of 0 when they really mean GLX_NONE.
1247    * Technically speaking, it is a bug in the DDX driver, but there is
1248    * enough of an installed base to work around the problem here.  In any
1249    * case, 0 is not a valid value of the transparent type, so we'll treat 0
1250    * from the app as GLX_DONT_CARE. We'll consider GLX_NONE from the app and
1251    * 0 from the server to be a match to maintain backward compatibility with
1252    * the (broken) drivers.
1253    */
1254
1255   if (a->transparentPixel != (int) GLX_DONT_CARE && a->transparentPixel != 0) {
1256      if (a->transparentPixel == GLX_NONE) {
1257         if (b->transparentPixel != GLX_NONE && b->transparentPixel != 0)
1258            return False;
1259      }
1260      else {
1261         MATCH_EXACT(transparentPixel);
1262      }
1263
1264      switch (a->transparentPixel) {
1265      case GLX_TRANSPARENT_RGB:
1266         MATCH_DONT_CARE(transparentRed);
1267         MATCH_DONT_CARE(transparentGreen);
1268         MATCH_DONT_CARE(transparentBlue);
1269         MATCH_DONT_CARE(transparentAlpha);
1270         break;
1271
1272      case GLX_TRANSPARENT_INDEX:
1273         MATCH_DONT_CARE(transparentIndex);
1274         break;
1275
1276      default:
1277         break;
1278      }
1279   }
1280
1281   return True;
1282}
1283
1284
1285/* There's some trickly language in the GLX spec about how this is supposed
1286 * to work.  Basically, if a given component size is either not specified
1287 * or the requested size is zero, it is supposed to act like PERFER_SMALLER.
1288 * Well, that's really hard to do with the code as-is.  This behavior is
1289 * closer to correct, but still not technically right.
1290 */
1291#define PREFER_LARGER_OR_ZERO(comp)             \
1292  do {                                          \
1293    if ( ((*a)-> comp) != ((*b)-> comp) ) {     \
1294      if ( ((*a)-> comp) == 0 ) {               \
1295        return -1;                              \
1296      }                                         \
1297      else if ( ((*b)-> comp) == 0 ) {          \
1298        return 1;                               \
1299      }                                         \
1300      else {                                    \
1301        return ((*b)-> comp) - ((*a)-> comp) ;  \
1302      }                                         \
1303    }                                           \
1304  } while( 0 )
1305
1306#define PREFER_LARGER(comp)                     \
1307  do {                                          \
1308    if ( ((*a)-> comp) != ((*b)-> comp) ) {     \
1309      return ((*b)-> comp) - ((*a)-> comp) ;    \
1310    }                                           \
1311  } while( 0 )
1312
1313#define PREFER_SMALLER(comp)                    \
1314  do {                                          \
1315    if ( ((*a)-> comp) != ((*b)-> comp) ) {     \
1316      return ((*a)-> comp) - ((*b)-> comp) ;    \
1317    }                                           \
1318  } while( 0 )
1319
1320/**
1321 * Compare two GLXFBConfigs.  This function is intended to be used as the
1322 * compare function passed in to qsort.
1323 *
1324 * \returns If \c a is a "better" config, according to the specification of
1325 *          SGIX_fbconfig, a number less than zero is returned.  If \c b is
1326 *          better, then a number greater than zero is return.  If both are
1327 *          equal, zero is returned.
1328 * \sa qsort, glXChooseVisual, glXChooseFBConfig, glXChooseFBConfigSGIX
1329 */
1330static int
1331fbconfig_compare(const __GLcontextModes * const *const a,
1332                 const __GLcontextModes * const *const b)
1333{
1334   /* The order of these comparisons must NOT change.  It is defined by
1335    * the GLX 1.3 spec and ARB_multisample.
1336    */
1337
1338   PREFER_SMALLER(visualSelectGroup);
1339
1340   /* The sort order for the visualRating is GLX_NONE, GLX_SLOW, and
1341    * GLX_NON_CONFORMANT_CONFIG.  It just so happens that this is the
1342    * numerical sort order of the enums (0x8000, 0x8001, and 0x800D).
1343    */
1344   PREFER_SMALLER(visualRating);
1345
1346   /* This isn't quite right.  It is supposed to compare the sum of the
1347    * components the user specifically set minimums for.
1348    */
1349   PREFER_LARGER_OR_ZERO(redBits);
1350   PREFER_LARGER_OR_ZERO(greenBits);
1351   PREFER_LARGER_OR_ZERO(blueBits);
1352   PREFER_LARGER_OR_ZERO(alphaBits);
1353
1354   PREFER_SMALLER(rgbBits);
1355
1356   if (((*a)->doubleBufferMode != (*b)->doubleBufferMode)) {
1357      /* Prefer single-buffer.
1358       */
1359      return (!(*a)->doubleBufferMode) ? -1 : 1;
1360   }
1361
1362   PREFER_SMALLER(numAuxBuffers);
1363
1364   PREFER_LARGER_OR_ZERO(depthBits);
1365   PREFER_SMALLER(stencilBits);
1366
1367   /* This isn't quite right.  It is supposed to compare the sum of the
1368    * components the user specifically set minimums for.
1369    */
1370   PREFER_LARGER_OR_ZERO(accumRedBits);
1371   PREFER_LARGER_OR_ZERO(accumGreenBits);
1372   PREFER_LARGER_OR_ZERO(accumBlueBits);
1373   PREFER_LARGER_OR_ZERO(accumAlphaBits);
1374
1375   PREFER_SMALLER(visualType);
1376
1377   /* None of the multisample specs say where this comparison should happen,
1378    * so I put it near the end.
1379    */
1380   PREFER_SMALLER(sampleBuffers);
1381   PREFER_SMALLER(samples);
1382
1383   /* None of the pbuffer or fbconfig specs say that this comparison needs
1384    * to happen at all, but it seems like it should.
1385    */
1386   PREFER_LARGER(maxPbufferWidth);
1387   PREFER_LARGER(maxPbufferHeight);
1388   PREFER_LARGER(maxPbufferPixels);
1389
1390   return 0;
1391}
1392
1393
1394/**
1395 * Selects and sorts a subset of the supplied configs based on the attributes.
1396 * This function forms to basis of \c glXChooseVisual, \c glXChooseFBConfig,
1397 * and \c glXChooseFBConfigSGIX.
1398 *
1399 * \param configs   Array of pointers to possible configs.  The elements of
1400 *                  this array that do not meet the criteria will be set to
1401 *                  NULL.  The remaining elements will be sorted according to
1402 *                  the various visual / FBConfig selection rules.
1403 * \param num_configs  Number of elements in the \c configs array.
1404 * \param attribList   Attributes used select from \c configs.  This array is
1405 *                     terminated by a \c None tag.  The array can either take
1406 *                     the form expected by \c glXChooseVisual (where boolean
1407 *                     tags do not have a value) or by \c glXChooseFBConfig
1408 *                     (where every tag has a value).
1409 * \param fbconfig_style_tags  Selects whether \c attribList is in
1410 *                             \c glXChooseVisual style or
1411 *                             \c glXChooseFBConfig style.
1412 * \returns The number of valid elements left in \c configs.
1413 *
1414 * \sa glXChooseVisual, glXChooseFBConfig, glXChooseFBConfigSGIX
1415 */
1416static int
1417choose_visual(__GLcontextModes ** configs, int num_configs,
1418              const int *attribList, GLboolean fbconfig_style_tags)
1419{
1420   __GLcontextModes test_config;
1421   int base;
1422   int i;
1423
1424   /* This is a fairly direct implementation of the selection method
1425    * described by GLX_SGIX_fbconfig.  Start by culling out all the
1426    * configs that are not compatible with the selected parameter
1427    * list.
1428    */
1429
1430   init_fbconfig_for_chooser(&test_config, fbconfig_style_tags);
1431   __glXInitializeVisualConfigFromTags(&test_config, 512,
1432                                       (const INT32 *) attribList,
1433                                       GL_TRUE, fbconfig_style_tags);
1434
1435   base = 0;
1436   for (i = 0; i < num_configs; i++) {
1437      if (fbconfigs_compatible(&test_config, configs[i])) {
1438         configs[base] = configs[i];
1439         base++;
1440      }
1441   }
1442
1443   if (base == 0) {
1444      return 0;
1445   }
1446
1447   if (base < num_configs) {
1448      (void) memset(&configs[base], 0, sizeof(void *) * (num_configs - base));
1449   }
1450
1451   /* After the incompatible configs are removed, the resulting
1452    * list is sorted according to the rules set out in the various
1453    * specifications.
1454    */
1455
1456   qsort(configs, base, sizeof(__GLcontextModes *),
1457         (int (*)(const void *, const void *)) fbconfig_compare);
1458   return base;
1459}
1460
1461
1462
1463
1464/*
1465** Return the visual that best matches the template.  Return None if no
1466** visual matches the template.
1467*/
1468PUBLIC XVisualInfo *
1469glXChooseVisual(Display * dpy, int screen, int *attribList)
1470{
1471   XVisualInfo *visualList = NULL;
1472   __GLXdisplayPrivate *priv;
1473   __GLXscreenConfigs *psc;
1474   __GLcontextModes test_config;
1475   __GLcontextModes *modes;
1476   const __GLcontextModes *best_config = NULL;
1477
1478   /*
1479    ** Get a list of all visuals, return if list is empty
1480    */
1481   if (GetGLXPrivScreenConfig(dpy, screen, &priv, &psc) != Success) {
1482      return None;
1483   }
1484
1485
1486   /*
1487    ** Build a template from the defaults and the attribute list
1488    ** Free visual list and return if an unexpected token is encountered
1489    */
1490   init_fbconfig_for_chooser(&test_config, GL_FALSE);
1491   __glXInitializeVisualConfigFromTags(&test_config, 512,
1492                                       (const INT32 *) attribList,
1493                                       GL_TRUE, GL_FALSE);
1494
1495   /*
1496    ** Eliminate visuals that don't meet minimum requirements
1497    ** Compute a score for those that do
1498    ** Remember which visual, if any, got the highest score
1499    ** If no visual is acceptable, return None
1500    ** Otherwise, create an XVisualInfo list with just the selected X visual
1501    ** and return this.
1502    */
1503   for (modes = psc->visuals; modes != NULL; modes = modes->next) {
1504      if (fbconfigs_compatible(&test_config, modes)
1505          && ((best_config == NULL)
1506              ||
1507              (fbconfig_compare
1508               ((const __GLcontextModes * const *const) &modes,
1509                &best_config) < 0))) {
1510         XVisualInfo visualTemplate;
1511         XVisualInfo *newList;
1512         int i;
1513
1514         visualTemplate.screen = screen;
1515         visualTemplate.visualid = modes->visualID;
1516         newList = XGetVisualInfo(dpy, VisualScreenMask | VisualIDMask,
1517                                  &visualTemplate, &i);
1518
1519         if (newList) {
1520            Xfree(visualList);
1521            visualList = newList;
1522            best_config = modes;
1523         }
1524      }
1525   }
1526
1527#ifdef GLX_USE_APPLEGL
1528   if(visualList && getenv("LIBGL_DUMP_VISUALID")) {
1529      printf("visualid 0x%lx\n", visualList[0].visualid);
1530   }
1531#endif
1532
1533   return visualList;
1534}
1535
1536
1537PUBLIC const char *
1538glXQueryExtensionsString(Display * dpy, int screen)
1539{
1540   __GLXscreenConfigs *psc;
1541   __GLXdisplayPrivate *priv;
1542
1543   if (GetGLXPrivScreenConfig(dpy, screen, &priv, &psc) != Success) {
1544      return NULL;
1545   }
1546
1547   if (!psc->effectiveGLXexts) {
1548      if (!psc->serverGLXexts) {
1549         psc->serverGLXexts =
1550            __glXQueryServerString(dpy, priv->majorOpcode, screen,
1551                                   GLX_EXTENSIONS);
1552      }
1553
1554      __glXCalculateUsableExtensions(psc,
1555#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
1556                                     (psc->driScreen != NULL),
1557#else
1558                                     GL_FALSE,
1559#endif
1560                                     priv->minorVersion);
1561   }
1562
1563   return psc->effectiveGLXexts;
1564}
1565
1566PUBLIC const char *
1567glXGetClientString(Display * dpy, int name)
1568{
1569   (void) dpy;
1570
1571   switch (name) {
1572   case GLX_VENDOR:
1573      return (__glXGLXClientVendorName);
1574   case GLX_VERSION:
1575      return (__glXGLXClientVersion);
1576   case GLX_EXTENSIONS:
1577      return (__glXGetClientExtensions());
1578   default:
1579      return NULL;
1580   }
1581}
1582
1583PUBLIC const char *
1584glXQueryServerString(Display * dpy, int screen, int name)
1585{
1586   __GLXscreenConfigs *psc;
1587   __GLXdisplayPrivate *priv;
1588   const char **str;
1589
1590
1591   if (GetGLXPrivScreenConfig(dpy, screen, &priv, &psc) != Success) {
1592      return NULL;
1593   }
1594
1595   switch (name) {
1596   case GLX_VENDOR:
1597      str = &priv->serverGLXvendor;
1598      break;
1599   case GLX_VERSION:
1600      str = &priv->serverGLXversion;
1601      break;
1602   case GLX_EXTENSIONS:
1603      str = &psc->serverGLXexts;
1604      break;
1605   default:
1606      return NULL;
1607   }
1608
1609   if (*str == NULL) {
1610      *str = __glXQueryServerString(dpy, priv->majorOpcode, screen, name);
1611   }
1612
1613   return *str;
1614}
1615
1616void
1617__glXClientInfo(Display * dpy, int opcode)
1618{
1619   char *ext_str = __glXGetClientGLExtensionString();
1620   int size = strlen(ext_str) + 1;
1621
1622#ifdef USE_XCB
1623   xcb_connection_t *c = XGetXCBConnection(dpy);
1624   xcb_glx_client_info(c,
1625                       GLX_MAJOR_VERSION, GLX_MINOR_VERSION, size, ext_str);
1626#else
1627   xGLXClientInfoReq *req;
1628
1629   /* Send the glXClientInfo request */
1630   LockDisplay(dpy);
1631   GetReq(GLXClientInfo, req);
1632   req->reqType = opcode;
1633   req->glxCode = X_GLXClientInfo;
1634   req->major = GLX_MAJOR_VERSION;
1635   req->minor = GLX_MINOR_VERSION;
1636
1637   req->length += (size + 3) >> 2;
1638   req->numbytes = size;
1639   Data(dpy, ext_str, size);
1640
1641   UnlockDisplay(dpy);
1642   SyncHandle();
1643#endif /* USE_XCB */
1644
1645   Xfree(ext_str);
1646}
1647
1648
1649/*
1650** EXT_import_context
1651*/
1652
1653PUBLIC Display *
1654glXGetCurrentDisplay(void)
1655{
1656   GLXContext gc = __glXGetCurrentContext();
1657   if (NULL == gc)
1658      return NULL;
1659   return gc->currentDpy;
1660}
1661
1662PUBLIC
1663GLX_ALIAS(Display *, glXGetCurrentDisplayEXT, (void), (),
1664          glXGetCurrentDisplay)
1665
1666#ifndef GLX_USE_APPLEGL
1667/**
1668 * Used internally by libGL to send \c xGLXQueryContextinfoExtReq requests
1669 * to the X-server.
1670 *
1671 * \param dpy  Display where \c ctx was created.
1672 * \param ctx  Context to query.
1673 * \returns  \c Success on success.  \c GLX_BAD_CONTEXT if \c ctx is invalid,
1674 *           or zero if the request failed due to internal problems (i.e.,
1675 *           unable to allocate temporary memory, etc.)
1676 *
1677 * \note
1678 * This function dynamically determines whether to use the EXT_import_context
1679 * version of the protocol or the GLX 1.3 version of the protocol.
1680 */
1681static int __glXQueryContextInfo(Display * dpy, GLXContext ctx)
1682{
1683   __GLXdisplayPrivate *priv = __glXInitialize(dpy);
1684   xGLXQueryContextReply reply;
1685   CARD8 opcode;
1686   GLuint numValues;
1687   int retval;
1688
1689   if (ctx == NULL) {
1690      return GLX_BAD_CONTEXT;
1691   }
1692   opcode = __glXSetupForCommand(dpy);
1693   if (!opcode) {
1694      return 0;
1695   }
1696
1697   /* Send the glXQueryContextInfoEXT request */
1698   LockDisplay(dpy);
1699
1700   if ((priv->majorVersion > 1) || (priv->minorVersion >= 3)) {
1701      xGLXQueryContextReq *req;
1702
1703      GetReq(GLXQueryContext, req);
1704
1705      req->reqType = opcode;
1706      req->glxCode = X_GLXQueryContext;
1707      req->context = (unsigned int) (ctx->xid);
1708   }
1709   else {
1710      xGLXVendorPrivateReq *vpreq;
1711      xGLXQueryContextInfoEXTReq *req;
1712
1713      GetReqExtra(GLXVendorPrivate,
1714                  sz_xGLXQueryContextInfoEXTReq - sz_xGLXVendorPrivateReq,
1715                  vpreq);
1716      req = (xGLXQueryContextInfoEXTReq *) vpreq;
1717      req->reqType = opcode;
1718      req->glxCode = X_GLXVendorPrivateWithReply;
1719      req->vendorCode = X_GLXvop_QueryContextInfoEXT;
1720      req->context = (unsigned int) (ctx->xid);
1721   }
1722
1723   _XReply(dpy, (xReply *) & reply, 0, False);
1724
1725   numValues = reply.n;
1726   if (numValues == 0)
1727      retval = Success;
1728   else if (numValues > __GLX_MAX_CONTEXT_PROPS)
1729      retval = 0;
1730   else {
1731      int *propList, *pProp;
1732      int nPropListBytes;
1733
1734      nPropListBytes = numValues << 3;
1735      propList = (int *) Xmalloc(nPropListBytes);
1736      if (NULL == propList) {
1737         retval = 0;
1738      }
1739      else {
1740	 unsigned i;
1741
1742         _XRead(dpy, (char *) propList, nPropListBytes);
1743
1744	 /* Look up screen first so we can look up visuals/fbconfigs later */
1745         pProp = propList;
1746         for (i = 0; i < numValues; i++, pProp += 2)
1747	     if (pProp[0] == GLX_SCREEN) {
1748		 ctx->screen = pProp[1];
1749		 ctx->psc = GetGLXScreenConfigs(dpy, ctx->screen);
1750	     }
1751
1752         pProp = propList;
1753         for (i = 0; i < numValues; i++) {
1754            switch (*pProp++) {
1755            case GLX_SHARE_CONTEXT_EXT:
1756               ctx->share_xid = *pProp++;
1757               break;
1758            case GLX_VISUAL_ID_EXT:
1759               ctx->mode =
1760                  _gl_context_modes_find_visual(ctx->psc->visuals, *pProp++);
1761               break;
1762            case GLX_FBCONFIG_ID:
1763               ctx->mode =
1764                  _gl_context_modes_find_fbconfig(ctx->psc->configs,
1765                                                  *pProp++);
1766               break;
1767            case GLX_RENDER_TYPE:
1768               ctx->renderType = *pProp++;
1769               break;
1770            case GLX_SCREEN:
1771            default:
1772               pProp++;
1773               continue;
1774            }
1775         }
1776         Xfree((char *) propList);
1777         retval = Success;
1778      }
1779   }
1780   UnlockDisplay(dpy);
1781   SyncHandle();
1782   return retval;
1783}
1784
1785#endif
1786
1787PUBLIC int
1788glXQueryContext(Display * dpy, GLXContext ctx, int attribute, int *value)
1789{
1790#ifndef GLX_USE_APPLEGL
1791   int retVal;
1792
1793   /* get the information from the server if we don't have it already */
1794#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
1795   if (!ctx->driContext && (ctx->mode == NULL)) {
1796#else
1797   if (ctx->mode == NULL) {
1798#endif
1799      retVal = __glXQueryContextInfo(dpy, ctx);
1800      if (Success != retVal)
1801         return retVal;
1802   }
1803#endif
1804
1805   switch (attribute) {
1806#ifndef GLX_USE_APPLEGL
1807      case GLX_SHARE_CONTEXT_EXT:
1808      *value = (int) (ctx->share_xid);
1809      break;
1810   case GLX_VISUAL_ID_EXT:
1811      *value = ctx->mode ? ctx->mode->visualID : None;
1812      break;
1813#endif
1814   case GLX_SCREEN:
1815      *value = (int) (ctx->screen);
1816      break;
1817   case GLX_FBCONFIG_ID:
1818      *value = ctx->mode ? ctx->mode->fbconfigID : None;
1819      break;
1820   case GLX_RENDER_TYPE:
1821      *value = (int) (ctx->renderType);
1822      break;
1823   default:
1824      return GLX_BAD_ATTRIBUTE;
1825   }
1826   return Success;
1827}
1828
1829PUBLIC
1830GLX_ALIAS(int, glXQueryContextInfoEXT,
1831          (Display * dpy, GLXContext ctx, int attribute, int *value),
1832          (dpy, ctx, attribute, value), glXQueryContext)
1833
1834PUBLIC GLXContextID glXGetContextIDEXT(const GLXContext ctx)
1835{
1836   return ctx->xid;
1837}
1838
1839PUBLIC GLXContext
1840glXImportContextEXT(Display * dpy, GLXContextID contextID)
1841{
1842#ifdef GLX_USE_APPLEGL
1843   return NULL;
1844#else
1845   GLXContext ctx;
1846
1847   if (contextID == None) {
1848      return NULL;
1849   }
1850   if (__glXIsDirect(dpy, contextID)) {
1851      return NULL;
1852   }
1853
1854   ctx = AllocateGLXContext(dpy);
1855   if (NULL != ctx) {
1856      ctx->xid = contextID;
1857      ctx->imported = GL_TRUE;
1858
1859      if (Success != __glXQueryContextInfo(dpy, ctx)) {
1860	 __glXFreeContext(ctx);
1861	 ctx = NULL;
1862      }
1863   }
1864   return ctx;
1865#endif
1866}
1867
1868PUBLIC void
1869glXFreeContextEXT(Display * dpy, GLXContext ctx)
1870{
1871   DestroyContext(dpy, ctx);
1872}
1873
1874
1875
1876/*
1877 * GLX 1.3 functions - these are just stubs for now!
1878 */
1879
1880PUBLIC GLXFBConfig *
1881glXChooseFBConfig(Display * dpy, int screen,
1882                  const int *attribList, int *nitems)
1883{
1884   __GLcontextModes **config_list;
1885   int list_size;
1886
1887
1888   config_list = (__GLcontextModes **)
1889      glXGetFBConfigs(dpy, screen, &list_size);
1890
1891   if ((config_list != NULL) && (list_size > 0) && (attribList != NULL)) {
1892      list_size = choose_visual(config_list, list_size, attribList, GL_TRUE);
1893      if (list_size == 0) {
1894         XFree(config_list);
1895         config_list = NULL;
1896      }
1897   }
1898
1899   *nitems = list_size;
1900   return (GLXFBConfig *) config_list;
1901}
1902
1903
1904PUBLIC GLXContext
1905glXCreateNewContext(Display * dpy, GLXFBConfig config,
1906                    int renderType, GLXContext shareList, Bool allowDirect)
1907{
1908   const __GLcontextModes *const fbconfig =
1909      (const __GLcontextModes *const) config;
1910
1911   return CreateContext(dpy, fbconfig->fbconfigID, fbconfig, shareList,
1912                        allowDirect, X_GLXCreateNewContext, renderType,
1913			fbconfig->screen);
1914}
1915
1916
1917PUBLIC GLXDrawable
1918glXGetCurrentReadDrawable(void)
1919{
1920   GLXContext gc = __glXGetCurrentContext();
1921   return gc->currentReadable;
1922}
1923
1924
1925PUBLIC GLXFBConfig *
1926glXGetFBConfigs(Display * dpy, int screen, int *nelements)
1927{
1928   __GLXdisplayPrivate *priv = __glXInitialize(dpy);
1929   __GLcontextModes **config = NULL;
1930   int i;
1931
1932   *nelements = 0;
1933   if (priv && (priv->screenConfigs != NULL)
1934       && (screen >= 0) && (screen <= ScreenCount(dpy))
1935       && (priv->screenConfigs[screen]->configs != NULL)
1936       && (priv->screenConfigs[screen]->configs->fbconfigID
1937	   != (int) GLX_DONT_CARE)) {
1938      unsigned num_configs = 0;
1939      __GLcontextModes *modes;
1940
1941
1942      for (modes = priv->screenConfigs[screen]->configs; modes != NULL;
1943           modes = modes->next) {
1944         if (modes->fbconfigID != (int) GLX_DONT_CARE) {
1945            num_configs++;
1946         }
1947      }
1948
1949      config = (__GLcontextModes **) Xmalloc(sizeof(__GLcontextModes *)
1950                                             * num_configs);
1951      if (config != NULL) {
1952         *nelements = num_configs;
1953         i = 0;
1954         for (modes = priv->screenConfigs[screen]->configs; modes != NULL;
1955              modes = modes->next) {
1956            if (modes->fbconfigID != (int) GLX_DONT_CARE) {
1957               config[i] = modes;
1958               i++;
1959            }
1960         }
1961      }
1962   }
1963   return (GLXFBConfig *) config;
1964}
1965
1966
1967PUBLIC int
1968glXGetFBConfigAttrib(Display * dpy, GLXFBConfig config,
1969                     int attribute, int *value)
1970{
1971   __GLcontextModes *const modes = ValidateGLXFBConfig(dpy, config);
1972
1973   return (modes != NULL)
1974      ? _gl_get_context_mode_data(modes, attribute, value)
1975      : GLXBadFBConfig;
1976}
1977
1978
1979PUBLIC XVisualInfo *
1980glXGetVisualFromFBConfig(Display * dpy, GLXFBConfig config)
1981{
1982   XVisualInfo visualTemplate;
1983   __GLcontextModes *fbconfig = (__GLcontextModes *) config;
1984   int count;
1985
1986   /*
1987    ** Get a list of all visuals, return if list is empty
1988    */
1989   visualTemplate.visualid = fbconfig->visualID;
1990   return XGetVisualInfo(dpy, VisualIDMask, &visualTemplate, &count);
1991}
1992
1993#ifndef GLX_USE_APPLEGL
1994/*
1995** GLX_SGI_swap_control
1996*/
1997static int
1998__glXSwapIntervalSGI(int interval)
1999{
2000   xGLXVendorPrivateReq *req;
2001   GLXContext gc = __glXGetCurrentContext();
2002   __GLXscreenConfigs *psc;
2003   Display *dpy;
2004   CARD32 *interval_ptr;
2005   CARD8 opcode;
2006
2007   if (gc == NULL) {
2008      return GLX_BAD_CONTEXT;
2009   }
2010
2011   if (interval <= 0) {
2012      return GLX_BAD_VALUE;
2013   }
2014
2015   psc = GetGLXScreenConfigs( gc->currentDpy, gc->screen);
2016
2017#ifdef GLX_DIRECT_RENDERING
2018   if (gc->driContext && psc->driScreen && psc->driScreen->setSwapInterval) {
2019      __GLXDRIdrawable *pdraw =
2020	 GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable);
2021      psc->driScreen->setSwapInterval(pdraw, interval);
2022      return 0;
2023   }
2024#endif
2025
2026   dpy = gc->currentDpy;
2027   opcode = __glXSetupForCommand(dpy);
2028   if (!opcode) {
2029      return 0;
2030   }
2031
2032   /* Send the glXSwapIntervalSGI request */
2033   LockDisplay(dpy);
2034   GetReqExtra(GLXVendorPrivate, sizeof(CARD32), req);
2035   req->reqType = opcode;
2036   req->glxCode = X_GLXVendorPrivate;
2037   req->vendorCode = X_GLXvop_SwapIntervalSGI;
2038   req->contextTag = gc->currentContextTag;
2039
2040   interval_ptr = (CARD32 *) (req + 1);
2041   *interval_ptr = interval;
2042
2043   UnlockDisplay(dpy);
2044   SyncHandle();
2045   XFlush(dpy);
2046
2047   return 0;
2048}
2049
2050
2051/*
2052** GLX_MESA_swap_control
2053*/
2054static int
2055__glXSwapIntervalMESA(unsigned int interval)
2056{
2057#ifdef GLX_DIRECT_RENDERING
2058   GLXContext gc = __glXGetCurrentContext();
2059
2060   if (gc != NULL && gc->driContext) {
2061      __GLXscreenConfigs *psc;
2062
2063      psc = GetGLXScreenConfigs( gc->currentDpy, gc->screen);
2064      if (psc->driScreen && psc->driScreen->setSwapInterval) {
2065         __GLXDRIdrawable *pdraw =
2066	    GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable);
2067	 return psc->driScreen->setSwapInterval(pdraw, interval);
2068      }
2069   }
2070#endif
2071
2072   return GLX_BAD_CONTEXT;
2073}
2074
2075
2076static int
2077__glXGetSwapIntervalMESA(void)
2078{
2079#ifdef GLX_DIRECT_RENDERING
2080   GLXContext gc = __glXGetCurrentContext();
2081
2082   if (gc != NULL && gc->driContext) {
2083      __GLXscreenConfigs *psc;
2084
2085      psc = GetGLXScreenConfigs( gc->currentDpy, gc->screen);
2086      if (psc->driScreen && psc->driScreen->getSwapInterval) {
2087         __GLXDRIdrawable *pdraw =
2088	    GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable);
2089	 return psc->driScreen->getSwapInterval(pdraw);
2090      }
2091   }
2092#endif
2093
2094   return 0;
2095}
2096
2097
2098/*
2099** GLX_SGI_video_sync
2100*/
2101static int
2102__glXGetVideoSyncSGI(unsigned int *count)
2103{
2104   int64_t ust, msc, sbc;
2105   int ret;
2106   GLXContext gc = __glXGetCurrentContext();
2107   __GLXscreenConfigs *psc;
2108#ifdef GLX_DIRECT_RENDERING
2109   __GLXDRIdrawable *pdraw;
2110#endif
2111
2112   if (!gc)
2113      return GLX_BAD_CONTEXT;
2114
2115#ifdef GLX_DIRECT_RENDERING
2116   if (!gc->driContext)
2117      return GLX_BAD_CONTEXT;
2118#endif
2119
2120   psc = GetGLXScreenConfigs(gc->currentDpy, gc->screen);
2121#ifdef GLX_DIRECT_RENDERING
2122   pdraw = GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable);
2123#endif
2124
2125   /* FIXME: Looking at the GLX_SGI_video_sync spec in the extension registry,
2126    * FIXME: there should be a GLX encoding for this call.  I can find no
2127    * FIXME: documentation for the GLX encoding.
2128    */
2129#ifdef GLX_DIRECT_RENDERING
2130   if (psc->driScreen && psc->driScreen->getDrawableMSC) {
2131      ret = psc->driScreen->getDrawableMSC(psc, pdraw, &ust, &msc, &sbc);
2132      *count = (unsigned) msc;
2133      return (ret == True) ? 0 : GLX_BAD_CONTEXT;
2134   }
2135#endif
2136
2137   return GLX_BAD_CONTEXT;
2138}
2139
2140static int
2141__glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count)
2142{
2143   GLXContext gc = __glXGetCurrentContext();
2144   __GLXscreenConfigs *psc;
2145#ifdef GLX_DIRECT_RENDERING
2146   __GLXDRIdrawable *pdraw;
2147#endif
2148   int64_t ust, msc, sbc;
2149   int ret;
2150
2151   if (divisor <= 0 || remainder < 0)
2152      return GLX_BAD_VALUE;
2153
2154   if (!gc)
2155      return GLX_BAD_CONTEXT;
2156
2157#ifdef GLX_DIRECT_RENDERING
2158   if (!gc->driContext)
2159      return GLX_BAD_CONTEXT;
2160#endif
2161
2162   psc = GetGLXScreenConfigs( gc->currentDpy, gc->screen);
2163#ifdef GLX_DIRECT_RENDERING
2164   pdraw = GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable);
2165#endif
2166
2167#ifdef GLX_DIRECT_RENDERING
2168   if (psc->driScreen && psc->driScreen->waitForMSC) {
2169      ret = psc->driScreen->waitForMSC(pdraw, 0, divisor, remainder, &ust, &msc,
2170				       &sbc);
2171      *count = (unsigned) msc;
2172      return (ret == True) ? 0 : GLX_BAD_CONTEXT;
2173   }
2174#endif
2175
2176   return GLX_BAD_CONTEXT;
2177}
2178
2179#endif /* GLX_USE_APPLEGL */
2180
2181/*
2182** GLX_SGIX_fbconfig
2183** Many of these functions are aliased to GLX 1.3 entry points in the
2184** GLX_functions table.
2185*/
2186
2187PUBLIC
2188GLX_ALIAS(int, glXGetFBConfigAttribSGIX,
2189          (Display * dpy, GLXFBConfigSGIX config, int attribute, int *value),
2190          (dpy, config, attribute, value), glXGetFBConfigAttrib)
2191
2192PUBLIC GLX_ALIAS(GLXFBConfigSGIX *, glXChooseFBConfigSGIX,
2193                 (Display * dpy, int screen, int *attrib_list,
2194                  int *nelements), (dpy, screen, attrib_list, nelements),
2195                 glXChooseFBConfig)
2196
2197PUBLIC GLX_ALIAS(XVisualInfo *, glXGetVisualFromFBConfigSGIX,
2198                 (Display * dpy, GLXFBConfigSGIX config),
2199                 (dpy, config), glXGetVisualFromFBConfig)
2200
2201PUBLIC GLXPixmap
2202glXCreateGLXPixmapWithConfigSGIX(Display * dpy,
2203                                 GLXFBConfigSGIX config,
2204                                 Pixmap pixmap)
2205{
2206#ifndef GLX_USE_APPLEGL
2207   xGLXVendorPrivateWithReplyReq *vpreq;
2208   xGLXCreateGLXPixmapWithConfigSGIXReq *req;
2209   GLXPixmap xid = None;
2210   CARD8 opcode;
2211   __GLXscreenConfigs *psc;
2212#endif
2213   const __GLcontextModes *const fbconfig = (__GLcontextModes *) config;
2214
2215
2216   if ((dpy == NULL) || (config == NULL)) {
2217      return None;
2218   }
2219#ifdef GLX_USE_APPLEGL
2220   if(apple_glx_pixmap_create(dpy, fbconfig->screen, pixmap, fbconfig))
2221      return None;
2222   return pixmap;
2223#else
2224
2225   psc = GetGLXScreenConfigs(dpy, fbconfig->screen);
2226   if ((psc != NULL)
2227       && __glXExtensionBitIsEnabled(psc, SGIX_fbconfig_bit)) {
2228      opcode = __glXSetupForCommand(dpy);
2229      if (!opcode) {
2230         return None;
2231      }
2232
2233      /* Send the glXCreateGLXPixmapWithConfigSGIX request */
2234      LockDisplay(dpy);
2235      GetReqExtra(GLXVendorPrivateWithReply,
2236                  sz_xGLXCreateGLXPixmapWithConfigSGIXReq -
2237                  sz_xGLXVendorPrivateWithReplyReq, vpreq);
2238      req = (xGLXCreateGLXPixmapWithConfigSGIXReq *) vpreq;
2239      req->reqType = opcode;
2240      req->glxCode = X_GLXVendorPrivateWithReply;
2241      req->vendorCode = X_GLXvop_CreateGLXPixmapWithConfigSGIX;
2242      req->screen = fbconfig->screen;
2243      req->fbconfig = fbconfig->fbconfigID;
2244      req->pixmap = pixmap;
2245      req->glxpixmap = xid = XAllocID(dpy);
2246      UnlockDisplay(dpy);
2247      SyncHandle();
2248   }
2249
2250   return xid;
2251#endif
2252}
2253
2254PUBLIC GLXContext
2255glXCreateContextWithConfigSGIX(Display * dpy,
2256                               GLXFBConfigSGIX config, int renderType,
2257                               GLXContext shareList, Bool allowDirect)
2258{
2259   GLXContext gc = NULL;
2260   const __GLcontextModes *const fbconfig = (__GLcontextModes *) config;
2261   __GLXscreenConfigs *psc;
2262
2263
2264   if ((dpy == NULL) || (config == NULL)) {
2265      return None;
2266   }
2267
2268   psc = GetGLXScreenConfigs(dpy, fbconfig->screen);
2269   if ((psc != NULL)
2270       && __glXExtensionBitIsEnabled(psc, SGIX_fbconfig_bit)) {
2271      gc = CreateContext(dpy, fbconfig->fbconfigID, fbconfig, shareList,
2272                         allowDirect,
2273			 X_GLXvop_CreateContextWithConfigSGIX, renderType,
2274			 fbconfig->screen);
2275   }
2276
2277   return gc;
2278}
2279
2280
2281PUBLIC GLXFBConfigSGIX
2282glXGetFBConfigFromVisualSGIX(Display * dpy, XVisualInfo * vis)
2283{
2284   __GLXdisplayPrivate *priv;
2285   __GLXscreenConfigs *psc = NULL;
2286
2287   if ((GetGLXPrivScreenConfig(dpy, vis->screen, &priv, &psc) != Success)
2288       && __glXExtensionBitIsEnabled(psc, SGIX_fbconfig_bit)
2289       && (psc->configs->fbconfigID != (int) GLX_DONT_CARE)) {
2290      return (GLXFBConfigSGIX) _gl_context_modes_find_visual(psc->configs,
2291                                                             vis->visualid);
2292   }
2293
2294   return NULL;
2295}
2296
2297#ifndef GLX_USE_APPLEGL
2298/*
2299** GLX_SGIX_swap_group
2300*/
2301static void
2302__glXJoinSwapGroupSGIX(Display * dpy, GLXDrawable drawable,
2303                       GLXDrawable member)
2304{
2305   (void) dpy;
2306   (void) drawable;
2307   (void) member;
2308}
2309
2310
2311/*
2312** GLX_SGIX_swap_barrier
2313*/
2314static void
2315__glXBindSwapBarrierSGIX(Display * dpy, GLXDrawable drawable, int barrier)
2316{
2317   (void) dpy;
2318   (void) drawable;
2319   (void) barrier;
2320}
2321
2322static Bool
2323__glXQueryMaxSwapBarriersSGIX(Display * dpy, int screen, int *max)
2324{
2325   (void) dpy;
2326   (void) screen;
2327   (void) max;
2328   return False;
2329}
2330
2331
2332/*
2333** GLX_OML_sync_control
2334*/
2335static Bool
2336__glXGetSyncValuesOML(Display * dpy, GLXDrawable drawable,
2337                      int64_t * ust, int64_t * msc, int64_t * sbc)
2338{
2339   __GLXdisplayPrivate * const priv = __glXInitialize(dpy);
2340   int ret;
2341#ifdef GLX_DIRECT_RENDERING
2342   __GLXDRIdrawable *pdraw;
2343#endif
2344   __GLXscreenConfigs *psc;
2345
2346   if (!priv)
2347      return False;
2348
2349#ifdef GLX_DIRECT_RENDERING
2350   pdraw = GetGLXDRIDrawable(dpy, drawable);
2351   psc = pdraw ? pdraw->psc : NULL;
2352   if (pdraw && psc->driScreen->getDrawableMSC) {
2353      ret = psc->driScreen->getDrawableMSC(psc, pdraw, ust, msc, sbc);
2354      return ret;
2355   }
2356#endif
2357
2358   return False;
2359}
2360
2361#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
2362_X_HIDDEN GLboolean
2363__glxGetMscRate(__GLXDRIdrawable *glxDraw,
2364		int32_t * numerator, int32_t * denominator)
2365{
2366#ifdef XF86VIDMODE
2367   __GLXscreenConfigs *psc;
2368   XF86VidModeModeLine mode_line;
2369   int dot_clock;
2370   int i;
2371
2372   psc = glxDraw->psc;
2373   if (XF86VidModeQueryVersion(psc->dpy, &i, &i) &&
2374       XF86VidModeGetModeLine(psc->dpy, psc->scr, &dot_clock, &mode_line)) {
2375      unsigned n = dot_clock * 1000;
2376      unsigned d = mode_line.vtotal * mode_line.htotal;
2377
2378# define V_INTERLACE 0x010
2379# define V_DBLSCAN   0x020
2380
2381      if (mode_line.flags & V_INTERLACE)
2382         n *= 2;
2383      else if (mode_line.flags & V_DBLSCAN)
2384         d *= 2;
2385
2386      /* The OML_sync_control spec requires that if the refresh rate is a
2387       * whole number, that the returned numerator be equal to the refresh
2388       * rate and the denominator be 1.
2389       */
2390
2391      if (n % d == 0) {
2392         n /= d;
2393         d = 1;
2394      }
2395      else {
2396         static const unsigned f[] = { 13, 11, 7, 5, 3, 2, 0 };
2397
2398         /* This is a poor man's way to reduce a fraction.  It's far from
2399          * perfect, but it will work well enough for this situation.
2400          */
2401
2402         for (i = 0; f[i] != 0; i++) {
2403            while (n % f[i] == 0 && d % f[i] == 0) {
2404               d /= f[i];
2405               n /= f[i];
2406            }
2407         }
2408      }
2409
2410      *numerator = n;
2411      *denominator = d;
2412
2413      return True;
2414   }
2415   else
2416      return False;
2417#else
2418   (void) draw;
2419   (void) numerator;
2420   (void) denominator;
2421   (void) private;
2422
2423   return False;
2424#endif
2425}
2426#endif
2427
2428/**
2429 * Determine the refresh rate of the specified drawable and display.
2430 *
2431 * \param dpy          Display whose refresh rate is to be determined.
2432 * \param drawable     Drawable whose refresh rate is to be determined.
2433 * \param numerator    Numerator of the refresh rate.
2434 * \param demoninator  Denominator of the refresh rate.
2435 * \return  If the refresh rate for the specified display and drawable could
2436 *          be calculated, True is returned.  Otherwise False is returned.
2437 *
2438 * \note This function is implemented entirely client-side.  A lot of other
2439 *       functionality is required to export GLX_OML_sync_control, so on
2440 *       XFree86 this function can be called for direct-rendering contexts
2441 *       when GLX_OML_sync_control appears in the client extension string.
2442 */
2443
2444_X_HIDDEN GLboolean
2445__glXGetMscRateOML(Display * dpy, GLXDrawable drawable,
2446                   int32_t * numerator, int32_t * denominator)
2447{
2448#if defined( GLX_DIRECT_RENDERING ) && defined( XF86VIDMODE )
2449   __GLXDRIdrawable *draw = GetGLXDRIDrawable(dpy, drawable);
2450
2451   if (draw == NULL)
2452      return False;
2453
2454   return __glxGetMscRate(draw, numerator, denominator);
2455#else
2456   (void) dpy;
2457   (void) drawable;
2458   (void) numerator;
2459   (void) denominator;
2460#endif
2461   return False;
2462}
2463
2464
2465static int64_t
2466__glXSwapBuffersMscOML(Display * dpy, GLXDrawable drawable,
2467                       int64_t target_msc, int64_t divisor, int64_t remainder)
2468{
2469   GLXContext gc = __glXGetCurrentContext();
2470#ifdef GLX_DIRECT_RENDERING
2471   __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable);
2472   __GLXscreenConfigs *psc = pdraw ? pdraw->psc : NULL;
2473#endif
2474
2475   if (!gc) /* no GLX for this */
2476      return -1;
2477
2478#ifdef GLX_DIRECT_RENDERING
2479   if (!pdraw || !gc->driContext)
2480      return -1;
2481#endif
2482
2483   /* The OML_sync_control spec says these should "generate a GLX_BAD_VALUE
2484    * error", but it also says "It [glXSwapBuffersMscOML] will return a value
2485    * of -1 if the function failed because of errors detected in the input
2486    * parameters"
2487    */
2488   if (divisor < 0 || remainder < 0 || target_msc < 0)
2489      return -1;
2490   if (divisor > 0 && remainder >= divisor)
2491      return -1;
2492
2493   if (target_msc == 0 && divisor == 0 && remainder == 0)
2494      remainder = 1;
2495
2496#ifdef GLX_DIRECT_RENDERING
2497   if (psc->driScreen && psc->driScreen->swapBuffers)
2498      return (*psc->driScreen->swapBuffers)(pdraw, target_msc, divisor,
2499					    remainder);
2500#endif
2501
2502   return -1;
2503}
2504
2505
2506static Bool
2507__glXWaitForMscOML(Display * dpy, GLXDrawable drawable,
2508                   int64_t target_msc, int64_t divisor,
2509                   int64_t remainder, int64_t * ust,
2510                   int64_t * msc, int64_t * sbc)
2511{
2512#ifdef GLX_DIRECT_RENDERING
2513   __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable);
2514#endif
2515   __GLXscreenConfigs *psc = pdraw ? pdraw->psc : NULL;
2516   int ret;
2517
2518
2519   /* The OML_sync_control spec says these should "generate a GLX_BAD_VALUE
2520    * error", but the return type in the spec is Bool.
2521    */
2522   if (divisor < 0 || remainder < 0 || target_msc < 0)
2523      return False;
2524   if (divisor > 0 && remainder >= divisor)
2525      return False;
2526
2527#ifdef GLX_DIRECT_RENDERING
2528   if (pdraw && psc->driScreen && psc->driScreen->waitForMSC) {
2529      ret = psc->driScreen->waitForMSC(pdraw, target_msc, divisor, remainder,
2530				       ust, msc, sbc);
2531      return ret;
2532   }
2533#endif
2534
2535   return False;
2536}
2537
2538
2539static Bool
2540__glXWaitForSbcOML(Display * dpy, GLXDrawable drawable,
2541                   int64_t target_sbc, int64_t * ust,
2542                   int64_t * msc, int64_t * sbc)
2543{
2544#ifdef GLX_DIRECT_RENDERING
2545   __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable);
2546#endif
2547   __GLXscreenConfigs *psc = pdraw ? pdraw->psc : NULL;
2548   int ret;
2549
2550   /* The OML_sync_control spec says this should "generate a GLX_BAD_VALUE
2551    * error", but the return type in the spec is Bool.
2552    */
2553   if (target_sbc < 0)
2554      return False;
2555
2556#ifdef GLX_DIRECT_RENDERING
2557   if (pdraw && psc->driScreen && psc->driScreen->waitForSBC) {
2558      ret = psc->driScreen->waitForSBC(pdraw, target_sbc, ust, msc, sbc);
2559      return ret;
2560   }
2561#endif
2562
2563   return False;
2564}
2565
2566/*@}*/
2567
2568
2569/**
2570 * Mesa extension stubs.  These will help reduce portability problems.
2571 */
2572/*@{*/
2573
2574/**
2575 * Release all buffers associated with the specified GLX drawable.
2576 *
2577 * \todo
2578 * This function was intended for stand-alone Mesa.  The issue there is that
2579 * the library doesn't get any notification when a window is closed.  In
2580 * DRI there is a similar but slightly different issue.  When GLX 1.3 is
2581 * supported, there are 3 different functions to destroy a drawable.  It
2582 * should be possible to create GLX protocol (or have it determine which
2583 * protocol to use based on the type of the drawable) to have one function
2584 * do the work of 3.  For the direct-rendering case, this function could
2585 * just call the driver's \c __DRIdrawableRec::destroyDrawable function.
2586 * This would reduce the frequency with which \c __driGarbageCollectDrawables
2587 * would need to be used.  This really should be done as part of the new DRI
2588 * interface work.
2589 *
2590 * \sa http://oss.sgi.com/projects/ogl-sample/registry/MESA/release_buffers.txt
2591 *     __driGarbageCollectDrawables
2592 *     glXDestroyGLXPixmap
2593 *     glXDestroyPbuffer glXDestroyPixmap glXDestroyWindow
2594 *     glXDestroyGLXPbufferSGIX glXDestroyGLXVideoSourceSGIX
2595 */
2596static Bool
2597__glXReleaseBuffersMESA(Display * dpy, GLXDrawable d)
2598{
2599   (void) dpy;
2600   (void) d;
2601   return False;
2602}
2603
2604
2605PUBLIC GLXPixmap
2606glXCreateGLXPixmapMESA(Display * dpy, XVisualInfo * visual,
2607                       Pixmap pixmap, Colormap cmap)
2608{
2609   (void) dpy;
2610   (void) visual;
2611   (void) pixmap;
2612   (void) cmap;
2613   return 0;
2614}
2615
2616/*@}*/
2617
2618
2619/**
2620 * GLX_MESA_copy_sub_buffer
2621 */
2622#define X_GLXvop_CopySubBufferMESA 5154 /* temporary */
2623static void
2624__glXCopySubBufferMESA(Display * dpy, GLXDrawable drawable,
2625                       int x, int y, int width, int height)
2626{
2627   xGLXVendorPrivateReq *req;
2628   GLXContext gc;
2629   GLXContextTag tag;
2630   CARD32 *drawable_ptr;
2631   INT32 *x_ptr, *y_ptr, *w_ptr, *h_ptr;
2632   CARD8 opcode;
2633
2634#ifdef __DRI_COPY_SUB_BUFFER
2635   __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable);
2636   if (pdraw != NULL) {
2637      __GLXscreenConfigs *psc = pdraw->psc;
2638      if (psc->driScreen->copySubBuffer != NULL) {
2639         glFlush();
2640         (*psc->driScreen->copySubBuffer) (pdraw, x, y, width, height);
2641      }
2642
2643      return;
2644   }
2645#endif
2646
2647   opcode = __glXSetupForCommand(dpy);
2648   if (!opcode)
2649      return;
2650
2651   /*
2652    ** The calling thread may or may not have a current context.  If it
2653    ** does, send the context tag so the server can do a flush.
2654    */
2655   gc = __glXGetCurrentContext();
2656   if ((gc != NULL) && (dpy == gc->currentDpy) &&
2657       ((drawable == gc->currentDrawable) ||
2658        (drawable == gc->currentReadable))) {
2659      tag = gc->currentContextTag;
2660   }
2661   else {
2662      tag = 0;
2663   }
2664
2665   LockDisplay(dpy);
2666   GetReqExtra(GLXVendorPrivate, sizeof(CARD32) + sizeof(INT32) * 4, req);
2667   req->reqType = opcode;
2668   req->glxCode = X_GLXVendorPrivate;
2669   req->vendorCode = X_GLXvop_CopySubBufferMESA;
2670   req->contextTag = tag;
2671
2672   drawable_ptr = (CARD32 *) (req + 1);
2673   x_ptr = (INT32 *) (drawable_ptr + 1);
2674   y_ptr = (INT32 *) (drawable_ptr + 2);
2675   w_ptr = (INT32 *) (drawable_ptr + 3);
2676   h_ptr = (INT32 *) (drawable_ptr + 4);
2677
2678   *drawable_ptr = drawable;
2679   *x_ptr = x;
2680   *y_ptr = y;
2681   *w_ptr = width;
2682   *h_ptr = height;
2683
2684   UnlockDisplay(dpy);
2685   SyncHandle();
2686}
2687
2688
2689/**
2690 * GLX_EXT_texture_from_pixmap
2691 */
2692static void
2693indirect_bind_tex_image(Display * dpy,
2694			GLXDrawable drawable,
2695			int buffer, const int *attrib_list)
2696{
2697   xGLXVendorPrivateReq *req;
2698   GLXContext gc = __glXGetCurrentContext();
2699   CARD32 *drawable_ptr;
2700   INT32 *buffer_ptr;
2701   CARD32 *num_attrib_ptr;
2702   CARD32 *attrib_ptr;
2703   CARD8 opcode;
2704   unsigned int i;
2705
2706   i = 0;
2707   if (attrib_list) {
2708      while (attrib_list[i * 2] != None)
2709         i++;
2710   }
2711
2712   opcode = __glXSetupForCommand(dpy);
2713   if (!opcode)
2714      return;
2715
2716   LockDisplay(dpy);
2717   GetReqExtra(GLXVendorPrivate, 12 + 8 * i, req);
2718   req->reqType = opcode;
2719   req->glxCode = X_GLXVendorPrivate;
2720   req->vendorCode = X_GLXvop_BindTexImageEXT;
2721   req->contextTag = gc->currentContextTag;
2722
2723   drawable_ptr = (CARD32 *) (req + 1);
2724   buffer_ptr = (INT32 *) (drawable_ptr + 1);
2725   num_attrib_ptr = (CARD32 *) (buffer_ptr + 1);
2726   attrib_ptr = (CARD32 *) (num_attrib_ptr + 1);
2727
2728   *drawable_ptr = drawable;
2729   *buffer_ptr = buffer;
2730   *num_attrib_ptr = (CARD32) i;
2731
2732   i = 0;
2733   if (attrib_list) {
2734      while (attrib_list[i * 2] != None) {
2735         *attrib_ptr++ = (CARD32) attrib_list[i * 2 + 0];
2736         *attrib_ptr++ = (CARD32) attrib_list[i * 2 + 1];
2737         i++;
2738      }
2739   }
2740
2741   UnlockDisplay(dpy);
2742   SyncHandle();
2743}
2744
2745static void
2746indirect_release_tex_image(Display * dpy, GLXDrawable drawable, int buffer)
2747{
2748   xGLXVendorPrivateReq *req;
2749   GLXContext gc = __glXGetCurrentContext();
2750   CARD32 *drawable_ptr;
2751   INT32 *buffer_ptr;
2752   CARD8 opcode;
2753
2754   opcode = __glXSetupForCommand(dpy);
2755   if (!opcode)
2756      return;
2757
2758   LockDisplay(dpy);
2759   GetReqExtra(GLXVendorPrivate, sizeof(CARD32) + sizeof(INT32), req);
2760   req->reqType = opcode;
2761   req->glxCode = X_GLXVendorPrivate;
2762   req->vendorCode = X_GLXvop_ReleaseTexImageEXT;
2763   req->contextTag = gc->currentContextTag;
2764
2765   drawable_ptr = (CARD32 *) (req + 1);
2766   buffer_ptr = (INT32 *) (drawable_ptr + 1);
2767
2768   *drawable_ptr = drawable;
2769   *buffer_ptr = buffer;
2770
2771   UnlockDisplay(dpy);
2772   SyncHandle();
2773}
2774
2775static const struct glx_context_vtable indirect_context_vtable = {
2776   indirect_wait_gl,
2777   indirect_wait_x,
2778   indirect_use_x_font,
2779   indirect_bind_tex_image,
2780   indirect_release_tex_image,
2781};
2782
2783/*@{*/
2784static void
2785__glXBindTexImageEXT(Display * dpy,
2786                     GLXDrawable drawable, int buffer, const int *attrib_list)
2787{
2788   GLXContext gc = __glXGetCurrentContext();
2789
2790   if (gc == NULL || gc->vtable->bind_tex_image == NULL)
2791      return;
2792
2793   gc->vtable->bind_tex_image(dpy, drawable, buffer, attrib_list);
2794}
2795
2796static void
2797__glXReleaseTexImageEXT(Display * dpy, GLXDrawable drawable, int buffer)
2798{
2799   GLXContext gc = __glXGetCurrentContext();
2800
2801   if (gc == NULL || gc->vtable->release_tex_image == NULL)
2802      return;
2803
2804   gc->vtable->release_tex_image(dpy, drawable, buffer);
2805}
2806
2807/*@}*/
2808
2809#endif /* GLX_USE_APPLEGL */
2810
2811/**
2812 * \c strdup is actually not a standard ANSI C or POSIX routine.
2813 * Irix will not define it if ANSI mode is in effect.
2814 *
2815 * \sa strdup
2816 */
2817_X_HIDDEN char *
2818__glXstrdup(const char *str)
2819{
2820   char *copy;
2821   copy = (char *) Xmalloc(strlen(str) + 1);
2822   if (!copy)
2823      return NULL;
2824   strcpy(copy, str);
2825   return copy;
2826}
2827
2828/*
2829** glXGetProcAddress support
2830*/
2831
2832struct name_address_pair
2833{
2834   const char *Name;
2835   GLvoid *Address;
2836};
2837
2838#define GLX_FUNCTION(f) { # f, (GLvoid *) f }
2839#define GLX_FUNCTION2(n,f) { # n, (GLvoid *) f }
2840
2841static const struct name_address_pair GLX_functions[] = {
2842   /*** GLX_VERSION_1_0 ***/
2843   GLX_FUNCTION(glXChooseVisual),
2844   GLX_FUNCTION(glXCopyContext),
2845   GLX_FUNCTION(glXCreateContext),
2846   GLX_FUNCTION(glXCreateGLXPixmap),
2847   GLX_FUNCTION(glXDestroyContext),
2848   GLX_FUNCTION(glXDestroyGLXPixmap),
2849   GLX_FUNCTION(glXGetConfig),
2850   GLX_FUNCTION(glXGetCurrentContext),
2851   GLX_FUNCTION(glXGetCurrentDrawable),
2852   GLX_FUNCTION(glXIsDirect),
2853   GLX_FUNCTION(glXMakeCurrent),
2854   GLX_FUNCTION(glXQueryExtension),
2855   GLX_FUNCTION(glXQueryVersion),
2856   GLX_FUNCTION(glXSwapBuffers),
2857   GLX_FUNCTION(glXUseXFont),
2858   GLX_FUNCTION(glXWaitGL),
2859   GLX_FUNCTION(glXWaitX),
2860
2861   /*** GLX_VERSION_1_1 ***/
2862   GLX_FUNCTION(glXGetClientString),
2863   GLX_FUNCTION(glXQueryExtensionsString),
2864   GLX_FUNCTION(glXQueryServerString),
2865
2866   /*** GLX_VERSION_1_2 ***/
2867   GLX_FUNCTION(glXGetCurrentDisplay),
2868
2869   /*** GLX_VERSION_1_3 ***/
2870   GLX_FUNCTION(glXChooseFBConfig),
2871   GLX_FUNCTION(glXCreateNewContext),
2872   GLX_FUNCTION(glXCreatePbuffer),
2873   GLX_FUNCTION(glXCreatePixmap),
2874   GLX_FUNCTION(glXCreateWindow),
2875   GLX_FUNCTION(glXDestroyPbuffer),
2876   GLX_FUNCTION(glXDestroyPixmap),
2877   GLX_FUNCTION(glXDestroyWindow),
2878   GLX_FUNCTION(glXGetCurrentReadDrawable),
2879   GLX_FUNCTION(glXGetFBConfigAttrib),
2880   GLX_FUNCTION(glXGetFBConfigs),
2881   GLX_FUNCTION(glXGetSelectedEvent),
2882   GLX_FUNCTION(glXGetVisualFromFBConfig),
2883   GLX_FUNCTION(glXMakeContextCurrent),
2884   GLX_FUNCTION(glXQueryContext),
2885   GLX_FUNCTION(glXQueryDrawable),
2886   GLX_FUNCTION(glXSelectEvent),
2887
2888#ifndef GLX_USE_APPLEGL
2889   /*** GLX_SGI_swap_control ***/
2890   GLX_FUNCTION2(glXSwapIntervalSGI, __glXSwapIntervalSGI),
2891
2892   /*** GLX_SGI_video_sync ***/
2893   GLX_FUNCTION2(glXGetVideoSyncSGI, __glXGetVideoSyncSGI),
2894   GLX_FUNCTION2(glXWaitVideoSyncSGI, __glXWaitVideoSyncSGI),
2895
2896   /*** GLX_SGI_make_current_read ***/
2897   GLX_FUNCTION2(glXMakeCurrentReadSGI, glXMakeContextCurrent),
2898   GLX_FUNCTION2(glXGetCurrentReadDrawableSGI, glXGetCurrentReadDrawable),
2899
2900   /*** GLX_EXT_import_context ***/
2901   GLX_FUNCTION(glXFreeContextEXT),
2902   GLX_FUNCTION(glXGetContextIDEXT),
2903   GLX_FUNCTION2(glXGetCurrentDisplayEXT, glXGetCurrentDisplay),
2904   GLX_FUNCTION(glXImportContextEXT),
2905   GLX_FUNCTION2(glXQueryContextInfoEXT, glXQueryContext),
2906#endif
2907
2908   /*** GLX_SGIX_fbconfig ***/
2909   GLX_FUNCTION2(glXGetFBConfigAttribSGIX, glXGetFBConfigAttrib),
2910   GLX_FUNCTION2(glXChooseFBConfigSGIX, glXChooseFBConfig),
2911   GLX_FUNCTION(glXCreateGLXPixmapWithConfigSGIX),
2912   GLX_FUNCTION(glXCreateContextWithConfigSGIX),
2913   GLX_FUNCTION2(glXGetVisualFromFBConfigSGIX, glXGetVisualFromFBConfig),
2914   GLX_FUNCTION(glXGetFBConfigFromVisualSGIX),
2915
2916#ifndef GLX_USE_APPLEGL
2917   /*** GLX_SGIX_pbuffer ***/
2918   GLX_FUNCTION(glXCreateGLXPbufferSGIX),
2919   GLX_FUNCTION(glXDestroyGLXPbufferSGIX),
2920   GLX_FUNCTION(glXQueryGLXPbufferSGIX),
2921   GLX_FUNCTION(glXSelectEventSGIX),
2922   GLX_FUNCTION(glXGetSelectedEventSGIX),
2923
2924   /*** GLX_SGIX_swap_group ***/
2925   GLX_FUNCTION2(glXJoinSwapGroupSGIX, __glXJoinSwapGroupSGIX),
2926
2927   /*** GLX_SGIX_swap_barrier ***/
2928   GLX_FUNCTION2(glXBindSwapBarrierSGIX, __glXBindSwapBarrierSGIX),
2929   GLX_FUNCTION2(glXQueryMaxSwapBarriersSGIX, __glXQueryMaxSwapBarriersSGIX),
2930
2931   /*** GLX_MESA_copy_sub_buffer ***/
2932   GLX_FUNCTION2(glXCopySubBufferMESA, __glXCopySubBufferMESA),
2933
2934   /*** GLX_MESA_pixmap_colormap ***/
2935   GLX_FUNCTION(glXCreateGLXPixmapMESA),
2936
2937   /*** GLX_MESA_release_buffers ***/
2938   GLX_FUNCTION2(glXReleaseBuffersMESA, __glXReleaseBuffersMESA),
2939
2940   /*** GLX_MESA_swap_control ***/
2941   GLX_FUNCTION2(glXSwapIntervalMESA, __glXSwapIntervalMESA),
2942   GLX_FUNCTION2(glXGetSwapIntervalMESA, __glXGetSwapIntervalMESA),
2943#endif
2944
2945   /*** GLX_ARB_get_proc_address ***/
2946   GLX_FUNCTION(glXGetProcAddressARB),
2947
2948   /*** GLX 1.4 ***/
2949   GLX_FUNCTION2(glXGetProcAddress, glXGetProcAddressARB),
2950
2951#ifndef GLX_USE_APPLEGL
2952   /*** GLX_OML_sync_control ***/
2953   GLX_FUNCTION2(glXWaitForSbcOML, __glXWaitForSbcOML),
2954   GLX_FUNCTION2(glXWaitForMscOML, __glXWaitForMscOML),
2955   GLX_FUNCTION2(glXSwapBuffersMscOML, __glXSwapBuffersMscOML),
2956   GLX_FUNCTION2(glXGetMscRateOML, __glXGetMscRateOML),
2957   GLX_FUNCTION2(glXGetSyncValuesOML, __glXGetSyncValuesOML),
2958
2959   /*** GLX_EXT_texture_from_pixmap ***/
2960   GLX_FUNCTION2(glXBindTexImageEXT, __glXBindTexImageEXT),
2961   GLX_FUNCTION2(glXReleaseTexImageEXT, __glXReleaseTexImageEXT),
2962#endif
2963
2964#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
2965   /*** DRI configuration ***/
2966   GLX_FUNCTION(glXGetScreenDriver),
2967   GLX_FUNCTION(glXGetDriverConfig),
2968#endif
2969
2970   {NULL, NULL}                 /* end of list */
2971};
2972
2973#ifndef GLX_USE_APPLEGL
2974static const GLvoid *
2975get_glx_proc_address(const char *funcName)
2976{
2977   GLuint i;
2978
2979   /* try static functions */
2980   for (i = 0; GLX_functions[i].Name; i++) {
2981      if (strcmp(GLX_functions[i].Name, funcName) == 0)
2982         return GLX_functions[i].Address;
2983   }
2984
2985   return NULL;
2986}
2987#endif
2988
2989/**
2990 * Get the address of a named GL function.  This is the pre-GLX 1.4 name for
2991 * \c glXGetProcAddress.
2992 *
2993 * \param procName  Name of a GL or GLX function.
2994 * \returns         A pointer to the named function
2995 *
2996 * \sa glXGetProcAddress
2997 */
2998PUBLIC void (*glXGetProcAddressARB(const GLubyte * procName)) (void)
2999{
3000   typedef void (*gl_function) (void);
3001   gl_function f;
3002
3003
3004   /* Search the table of GLX and internal functions first.  If that
3005    * fails and the supplied name could be a valid core GL name, try
3006    * searching the core GL function table.  This check is done to prevent
3007    * DRI based drivers from searching the core GL function table for
3008    * internal API functions.
3009    */
3010#ifdef GLX_USE_APPLEGL
3011   f = (gl_function) apple_glx_get_proc_address(procName);
3012#else
3013   f = (gl_function) get_glx_proc_address((const char *) procName);
3014   if ((f == NULL) && (procName[0] == 'g') && (procName[1] == 'l')
3015       && (procName[2] != 'X')) {
3016      f = (gl_function) _glapi_get_proc_address((const char *) procName);
3017   }
3018#endif
3019   return f;
3020}
3021
3022/**
3023 * Get the address of a named GL function.  This is the GLX 1.4 name for
3024 * \c glXGetProcAddressARB.
3025 *
3026 * \param procName  Name of a GL or GLX function.
3027 * \returns         A pointer to the named function
3028 *
3029 * \sa glXGetProcAddressARB
3030 */
3031PUBLIC void (*glXGetProcAddress(const GLubyte * procName)) (void)
3032#if defined(__GNUC__) && !defined(GLX_ALIAS_UNSUPPORTED)
3033   __attribute__ ((alias("glXGetProcAddressARB")));
3034#else
3035{
3036   return glXGetProcAddressARB(procName);
3037}
3038#endif /* __GNUC__ */
3039
3040
3041#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
3042/**
3043 * Get the unadjusted system time (UST).  Currently, the UST is measured in
3044 * microseconds since Epoc.  The actual resolution of the UST may vary from
3045 * system to system, and the units may vary from release to release.
3046 * Drivers should not call this function directly.  They should instead use
3047 * \c glXGetProcAddress to obtain a pointer to the function.
3048 *
3049 * \param ust Location to store the 64-bit UST
3050 * \returns Zero on success or a negative errno value on failure.
3051 *
3052 * \sa glXGetProcAddress, PFNGLXGETUSTPROC
3053 *
3054 * \since Internal API version 20030317.
3055 */
3056_X_HIDDEN int
3057__glXGetUST(int64_t * ust)
3058{
3059   struct timeval tv;
3060
3061   if (ust == NULL) {
3062      return -EFAULT;
3063   }
3064
3065   if (gettimeofday(&tv, NULL) == 0) {
3066      ust[0] = (tv.tv_sec * 1000000) + tv.tv_usec;
3067      return 0;
3068   }
3069   else {
3070      return -errno;
3071   }
3072}
3073#endif /* GLX_DIRECT_RENDERING */
3074