glxclient.h revision 7eed3dba58740a8ade94cfab315afa198d1beebe 
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 glxclient.h
33 * Direct rendering support added by Precision Insight, Inc.
34 *
35 * \author Kevin E. Martin <kevin@precisioninsight.com>
36 */
37
38#ifndef _GLX_client_h_
39#define _GLX_client_h_
40#include <X11/Xproto.h>
41#include <X11/Xlibint.h>
42#include <X11/Xfuncproto.h>
43#include <X11/extensions/extutil.h>
44#define GLX_GLXEXT_PROTOTYPES
45#include <GL/glx.h>
46#include <GL/glxext.h>
47#include <string.h>
48#include <stdlib.h>
49#include <stdio.h>
50#ifdef WIN32
51#include <stdint.h>
52#endif
53#include "GL/glxproto.h"
54#include "glapi/glapitable.h"
55#include "glxconfig.h"
56#include "glxhash.h"
57#if defined( PTHREADS )
58# include <pthread.h>
59#endif
60
61#include "glxextensions.h"
62
63#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
64
65#define GLX_MAJOR_VERSION 1       /* current version numbers */
66#define GLX_MINOR_VERSION 4
67
68#define __GLX_MAX_TEXTURE_UNITS 32
69
70struct glx_display;
71struct glx_context;
72
73/************************************************************************/
74
75#ifdef GLX_DIRECT_RENDERING
76
77extern void DRI_glXUseXFont(struct glx_context *ctx,
78			    Font font, int first, int count, int listbase);
79
80#endif
81
82#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
83
84/**
85 * Display dependent methods.  This structure is initialized during the
86 * \c driCreateDisplay call.
87 */
88typedef struct __GLXDRIdisplayRec __GLXDRIdisplay;
89typedef struct __GLXDRIscreenRec __GLXDRIscreen;
90typedef struct __GLXDRIdrawableRec __GLXDRIdrawable;
91
92struct __GLXDRIdisplayRec
93{
94    /**
95     * Method to destroy the private DRI display data.
96     */
97   void (*destroyDisplay) (__GLXDRIdisplay * display);
98
99   struct glx_screen *(*createScreen)(int screen, struct glx_display * priv);
100};
101
102struct __GLXDRIscreenRec {
103
104   void (*destroyScreen)(struct glx_screen *psc);
105
106   struct glx_context *(*createContext)(struct glx_screen *psc,
107					struct glx_config *config,
108					struct glx_context *shareList,
109					int renderType);
110
111   __GLXDRIdrawable *(*createDrawable)(struct glx_screen *psc,
112				       XID drawable,
113				       GLXDrawable glxDrawable,
114				       struct glx_config *config);
115
116   int64_t (*swapBuffers)(__GLXDRIdrawable *pdraw, int64_t target_msc,
117			  int64_t divisor, int64_t remainder);
118   void (*copySubBuffer)(__GLXDRIdrawable *pdraw,
119			 int x, int y, int width, int height);
120   int (*getDrawableMSC)(struct glx_screen *psc, __GLXDRIdrawable *pdraw,
121			 int64_t *ust, int64_t *msc, int64_t *sbc);
122   int (*waitForMSC)(__GLXDRIdrawable *pdraw, int64_t target_msc,
123		     int64_t divisor, int64_t remainder, int64_t *ust,
124		     int64_t *msc, int64_t *sbc);
125   int (*waitForSBC)(__GLXDRIdrawable *pdraw, int64_t target_sbc, int64_t *ust,
126		     int64_t *msc, int64_t *sbc);
127   int (*setSwapInterval)(__GLXDRIdrawable *pdraw, int interval);
128   int (*getSwapInterval)(__GLXDRIdrawable *pdraw);
129};
130
131struct __GLXDRIdrawableRec
132{
133   void (*destroyDrawable) (__GLXDRIdrawable * drawable);
134
135   XID xDrawable;
136   XID drawable;
137   struct glx_screen *psc;
138   GLenum textureTarget;
139   GLenum textureFormat;        /* EXT_texture_from_pixmap support */
140   unsigned long eventMask;
141};
142
143/*
144** Function to create and DRI display data and initialize the display
145** dependent methods.
146*/
147extern __GLXDRIdisplay *driswCreateDisplay(Display * dpy);
148extern __GLXDRIdisplay *driCreateDisplay(Display * dpy);
149extern __GLXDRIdisplay *dri2CreateDisplay(Display * dpy);
150extern void dri2InvalidateBuffers(Display *dpy, XID drawable);
151extern unsigned dri2GetSwapEventType(Display *dpy, XID drawable);
152
153
154/*
155** Functions to obtain driver configuration information from a direct
156** rendering client application
157*/
158extern const char *glXGetScreenDriver(Display * dpy, int scrNum);
159
160extern const char *glXGetDriverConfig(const char *driverName);
161
162#endif
163
164/************************************************************************/
165
166#define __GL_CLIENT_ATTRIB_STACK_DEPTH 16
167
168typedef struct __GLXpixelStoreModeRec
169{
170   GLboolean swapEndian;
171   GLboolean lsbFirst;
172   GLuint rowLength;
173   GLuint imageHeight;
174   GLuint imageDepth;
175   GLuint skipRows;
176   GLuint skipPixels;
177   GLuint skipImages;
178   GLuint alignment;
179} __GLXpixelStoreMode;
180
181
182typedef struct __GLXattributeRec
183{
184   GLuint mask;
185
186    /**
187     * Pixel storage state.  Most of the pixel store mode state is kept
188     * here and used by the client code to manage the packing and
189     * unpacking of data sent to/received from the server.
190     */
191   __GLXpixelStoreMode storePack, storeUnpack;
192
193    /**
194     * Is EXT_vertex_array / GL 1.1 DrawArrays protocol specifically
195     * disabled?
196     */
197   GLboolean NoDrawArraysProtocol;
198
199    /**
200     * Vertex Array storage state.  The vertex array component
201     * state is stored here and is used to manage the packing of
202     * DrawArrays data sent to the server.
203     */
204   struct array_state_vector *array_state;
205} __GLXattribute;
206
207typedef struct __GLXattributeMachineRec
208{
209   __GLXattribute *stack[__GL_CLIENT_ATTRIB_STACK_DEPTH];
210   __GLXattribute **stackPointer;
211} __GLXattributeMachine;
212
213struct glx_context_vtable {
214   void (*destroy)(struct glx_context *ctx);
215   int (*bind)(struct glx_context *context, struct glx_context *old,
216	       GLXDrawable draw, GLXDrawable read);
217   void (*unbind)(struct glx_context *context, struct glx_context *new);
218   void (*wait_gl)(struct glx_context *ctx);
219   void (*wait_x)(struct glx_context *ctx);
220   void (*use_x_font)(struct glx_context *ctx,
221		      Font font, int first, int count, int listBase);
222   void (*bind_tex_image)(Display * dpy,
223			  GLXDrawable drawable,
224			  int buffer, const int *attrib_list);
225   void (*release_tex_image)(Display * dpy, GLXDrawable drawable, int buffer);
226
227};
228
229extern void
230glx_send_destroy_context(Display *dpy, XID xid);
231
232/**
233 * GLX state that needs to be kept on the client.  One of these records
234 * exist for each context that has been made current by this client.
235 */
236struct glx_context
237{
238    /**
239     * \name Drawing command buffer.
240     *
241     * Drawing commands are packed into this buffer before being sent as a
242     * single GLX protocol request.  The buffer is sent when it overflows or
243     * is flushed by \c __glXFlushRenderBuffer.  \c pc is the next location
244     * in the buffer to be filled.  \c limit is described above in the buffer
245     * slop discussion.
246     *
247     * Commands that require large amounts of data to be transfered will
248     * also use this buffer to hold a header that describes the large
249     * command.
250     *
251     * These must be the first 6 fields since they are static initialized
252     * in the dummy context in glxext.c
253     */
254   /*@{ */
255   GLubyte *buf;
256   GLubyte *pc;
257   GLubyte *limit;
258   GLubyte *bufEnd;
259   GLint bufSize;
260   /*@} */
261
262   const struct glx_context_vtable *vtable;
263
264    /**
265     * The XID of this rendering context.  When the context is created a
266     * new XID is allocated.  This is set to None when the context is
267     * destroyed but is still current to some thread. In this case the
268     * context will be freed on next MakeCurrent.
269     */
270   XID xid;
271
272    /**
273     * The XID of the \c shareList context.
274     */
275   XID share_xid;
276
277    /**
278     * Screen number.
279     */
280   GLint screen;
281   struct glx_screen *psc;
282
283    /**
284     * \c GL_TRUE if the context was created with ImportContext, which
285     * means the server-side context was created by another X client.
286     */
287   GLboolean imported;
288
289    /**
290     * The context tag returned by MakeCurrent when this context is made
291     * current. This tag is used to identify the context that a thread has
292     * current so that proper server context management can be done.  It is
293     * used for all context specific commands (i.e., \c Render, \c RenderLarge,
294     * \c WaitX, \c WaitGL, \c UseXFont, and \c MakeCurrent (for the old
295     * context)).
296     */
297   GLXContextTag currentContextTag;
298
299    /**
300     * \name Rendering mode
301     *
302     * The rendering mode is kept on the client as well as the server.
303     * When \c glRenderMode is called, the buffer associated with the
304     * previous rendering mode (feedback or select) is filled.
305     */
306   /*@{ */
307   GLenum renderMode;
308   GLfloat *feedbackBuf;
309   GLuint *selectBuf;
310   /*@} */
311
312    /**
313     * This is \c GL_TRUE if the pixel unpack modes are such that an image
314     * can be unpacked from the clients memory by just copying.  It may
315     * still be true that the server will have to do some work.  This
316     * just promises that a straight copy will fetch the correct bytes.
317     */
318   GLboolean fastImageUnpack;
319
320    /**
321     * Fill newImage with the unpacked form of \c oldImage getting it
322     * ready for transport to the server.
323     */
324   void (*fillImage) (struct glx_context *, GLint, GLint, GLint, GLint, GLenum,
325                      GLenum, const GLvoid *, GLubyte *, GLubyte *);
326
327    /**
328     * Client side attribs.
329     */
330   __GLXattributeMachine attributes;
331
332    /**
333     * Client side error code.  This is set when client side gl API
334     * routines need to set an error because of a bad enumerant or
335     * running out of memory, etc.
336     */
337   GLenum error;
338
339    /**
340     * Whether this context does direct rendering.
341     */
342   Bool isDirect;
343
344    /**
345     * \c dpy of current display for this context.  Will be \c NULL if not
346     * current to any display, or if this is the "dummy context".
347     */
348   Display *currentDpy;
349
350    /**
351     * The current drawable for this context.  Will be None if this
352     * context is not current to any drawable.  currentReadable is below.
353     */
354   GLXDrawable currentDrawable;
355
356    /**
357     * \name GL Constant Strings
358     *
359     * Constant strings that describe the server implementation
360     * These pertain to GL attributes, not to be confused with
361     * GLX versioning attributes.
362     */
363   /*@{ */
364   GLubyte *vendor;
365   GLubyte *renderer;
366   GLubyte *version;
367   GLubyte *extensions;
368   /*@} */
369
370    /**
371     * Maximum small render command size.  This is the smaller of 64k and
372     * the size of the above buffer.
373     */
374   GLint maxSmallRenderCommandSize;
375
376    /**
377     * Major opcode for the extension.  Copied here so a lookup isn't
378     * needed.
379     */
380   GLint majorOpcode;
381
382    /**
383     * Pointer to the config used to create this context.
384     */
385   struct glx_config *config;
386
387    /**
388     * The current read-drawable for this context.  Will be None if this
389     * context is not current to any drawable.
390     *
391     * \since Internal API version 20030606.
392     */
393   GLXDrawable currentReadable;
394
395   /**
396    * Pointer to client-state data that is private to libGL.  This is only
397    * used for indirect rendering contexts.
398    *
399    * No internal API version change was made for this change.  Client-side
400    * drivers should NEVER use this data or even care that it exists.
401    */
402   void *client_state_private;
403
404   /**
405    * Stored value for \c glXQueryContext attribute \c GLX_RENDER_TYPE.
406    */
407   int renderType;
408
409   /**
410    * \name Raw server GL version
411    *
412    * True core GL version supported by the server.  This is the raw value
413    * returned by the server, and it may not reflect what is actually
414    * supported (or reported) by the client-side library.
415    */
416   /*@{ */
417   int server_major;        /**< Major version number. */
418   int server_minor;        /**< Minor version number. */
419   /*@} */
420
421   /**
422    * Thread ID we're currently current in. Zero if none.
423    */
424   unsigned long thread_id;
425
426   char gl_extension_bits[__GL_EXT_BYTES];
427};
428
429extern Bool
430glx_context_init(struct glx_context *gc,
431		 struct glx_screen *psc, struct glx_config *fbconfig);
432
433#define __glXSetError(gc,code)  \
434   if (!(gc)->error) {          \
435      (gc)->error = code;       \
436   }
437
438extern void __glFreeAttributeState(struct glx_context *);
439
440/************************************************************************/
441
442/**
443 * The size of the largest drawing command known to the implementation
444 * that will use the GLXRender GLX command.  In this case it is
445 * \c glPolygonStipple.
446 */
447#define __GLX_MAX_SMALL_RENDER_CMD_SIZE 156
448
449/**
450 * To keep the implementation fast, the code uses a "limit" pointer
451 * to determine when the drawing command buffer is too full to hold
452 * another fixed size command.  This constant defines the amount of
453 * space that must always be available in the drawing command buffer
454 * at all times for the implementation to work.  It is important that
455 * the number be just large enough, but not so large as to reduce the
456 * efficacy of the buffer.  The "+32" is just to keep the code working
457 * in case somebody counts wrong.
458 */
459#define __GLX_BUFFER_LIMIT_SIZE (__GLX_MAX_SMALL_RENDER_CMD_SIZE + 32)
460
461/**
462 * This implementation uses a smaller threshold for switching
463 * to the RenderLarge protocol than the protcol requires so that
464 * large copies don't occur.
465 */
466#define __GLX_RENDER_CMD_SIZE_LIMIT 4096
467
468/**
469 * One of these records exists per screen of the display.  It contains
470 * a pointer to the config data for that screen (if the screen supports GL).
471 */
472struct glx_screen_vtable {
473   struct glx_context *(*create_context)(struct glx_screen *psc,
474					 struct glx_config *config,
475					 struct glx_context *shareList,
476					 int renderType);
477};
478
479struct glx_screen
480{
481   const struct glx_screen_vtable *vtable;
482
483    /**
484     * GLX extension string reported by the X-server.
485     */
486   const char *serverGLXexts;
487
488    /**
489     * GLX extension string to be reported to applications.  This is the
490     * set of extensions that the application can actually use.
491     */
492   char *effectiveGLXexts;
493
494   struct glx_display *display;
495
496   Display *dpy;
497   int scr;
498
499#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
500    /**
501     * Per screen direct rendering interface functions and data.
502     */
503   __GLXDRIscreen *driScreen;
504#endif
505
506    /**
507     * Linked list of glx visuals and  fbconfigs for this screen.
508     */
509   struct glx_config *visuals, *configs;
510
511    /**
512     * Per-screen dynamic GLX extension tracking.  The \c direct_support
513     * field only contains enough bits for 64 extensions.  Should libGL
514     * ever need to track more than 64 GLX extensions, we can safely grow
515     * this field.  The \c struct glx_screen structure is not used outside
516     * libGL.
517     */
518   /*@{ */
519   unsigned char direct_support[8];
520   GLboolean ext_list_first_time;
521   /*@} */
522
523};
524
525/**
526 * Per display private data.  One of these records exists for each display
527 * that is using the OpenGL (GLX) extension.
528 */
529struct glx_display
530{
531   /* The extension protocol codes */
532   XExtCodes *codes;
533   struct glx_display *next;
534
535    /**
536     * Back pointer to the display
537     */
538   Display *dpy;
539
540    /**
541     * The \c majorOpcode is common to all connections to the same server.
542     * It is also copied into the context structure.
543     */
544   int majorOpcode;
545
546    /**
547     * \name Server Version
548     *
549     * Major and minor version returned by the server during initialization.
550     */
551   /*@{ */
552   int majorVersion, minorVersion;
553   /*@} */
554
555    /**
556     * \name Storage for the servers GLX vendor and versions strings.
557     *
558     * These are the same for all screens on this display. These fields will
559     * be filled in on demand.
560     */
561   /*@{ */
562   const char *serverGLXvendor;
563   const char *serverGLXversion;
564   /*@} */
565
566    /**
567     * Configurations of visuals for all screens on this display.
568     * Also, per screen data which now includes the server \c GLX_EXTENSION
569     * string.
570     */
571   struct glx_screen **screens;
572
573#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
574   __glxHashTable *drawHash;
575
576    /**
577     * Per display direct rendering interface functions and data.
578     */
579   __GLXDRIdisplay *driswDisplay;
580   __GLXDRIdisplay *driDisplay;
581   __GLXDRIdisplay *dri2Display;
582#endif
583};
584
585extern int
586glx_screen_init(struct glx_screen *psc,
587		int screen, struct glx_display * priv);
588
589#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
590extern __GLXDRIdrawable *
591dri2GetGlxDrawableFromXDrawableId(Display *dpy, XID id);
592#endif
593
594extern GLubyte *__glXFlushRenderBuffer(struct glx_context *, GLubyte *);
595
596extern void __glXSendLargeChunk(struct glx_context * gc, GLint requestNumber,
597                                GLint totalRequests,
598                                const GLvoid * data, GLint dataLen);
599
600extern void __glXSendLargeCommand(struct glx_context *, const GLvoid *, GLint,
601                                  const GLvoid *, GLint);
602
603/* Initialize the GLX extension for dpy */
604extern struct glx_display *__glXInitialize(Display *);
605
606extern void __glXPreferEGL(int state);
607
608/************************************************************************/
609
610extern int __glXDebug;
611
612/* This is per-thread storage in an MT environment */
613#if defined( PTHREADS )
614
615extern void __glXSetCurrentContext(struct glx_context * c);
616
617# if defined( GLX_USE_TLS )
618
619extern __thread void *__glX_tls_Context
620   __attribute__ ((tls_model("initial-exec")));
621
622#  define __glXGetCurrentContext() __glX_tls_Context
623
624# else
625
626extern struct glx_context *__glXGetCurrentContext(void);
627
628# endif /* defined( GLX_USE_TLS ) */
629
630#else
631
632extern struct glx_context *__glXcurrentContext;
633#define __glXGetCurrentContext() __glXcurrentContext
634#define __glXSetCurrentContext(gc) __glXcurrentContext = gc
635
636#endif /* defined( PTHREADS ) */
637
638extern void __glXSetCurrentContextNull(void);
639
640
641/*
642** Global lock for all threads in this address space using the GLX
643** extension
644*/
645#if defined( PTHREADS )
646extern pthread_mutex_t __glXmutex;
647#define __glXLock()    pthread_mutex_lock(&__glXmutex)
648#define __glXUnlock()  pthread_mutex_unlock(&__glXmutex)
649#else
650#define __glXLock()
651#define __glXUnlock()
652#endif
653
654/*
655** Setup for a command.  Initialize the extension for dpy if necessary.
656*/
657extern CARD8 __glXSetupForCommand(Display * dpy);
658
659/************************************************************************/
660
661/*
662** Data conversion and packing support.
663*/
664
665extern const GLuint __glXDefaultPixelStore[9];
666
667/* Send an image to the server using RenderLarge. */
668extern void __glXSendLargeImage(struct glx_context * gc, GLint compsize, GLint dim,
669                                GLint width, GLint height, GLint depth,
670                                GLenum format, GLenum type,
671                                const GLvoid * src, GLubyte * pc,
672                                GLubyte * modes);
673
674/* Return the size, in bytes, of some pixel data */
675extern GLint __glImageSize(GLint, GLint, GLint, GLenum, GLenum, GLenum);
676
677/* Return the number of elements per group of a specified format*/
678extern GLint __glElementsPerGroup(GLenum format, GLenum type);
679
680/* Return the number of bytes per element, based on the element type (other
681** than GL_BITMAP).
682*/
683extern GLint __glBytesPerElement(GLenum type);
684
685/*
686** Fill the transport buffer with the data from the users buffer,
687** applying some of the pixel store modes (unpack modes) to the data
688** first.  As a side effect of this call, the "modes" field is
689** updated to contain the modes needed by the server to decode the
690** sent data.
691*/
692extern void __glFillImage(struct glx_context *, GLint, GLint, GLint, GLint, GLenum,
693                          GLenum, const GLvoid *, GLubyte *, GLubyte *);
694
695/* Copy map data with a stride into a packed buffer */
696extern void __glFillMap1f(GLint, GLint, GLint, const GLfloat *, GLubyte *);
697extern void __glFillMap1d(GLint, GLint, GLint, const GLdouble *, GLubyte *);
698extern void __glFillMap2f(GLint, GLint, GLint, GLint, GLint,
699                          const GLfloat *, GLfloat *);
700extern void __glFillMap2d(GLint, GLint, GLint, GLint, GLint,
701                          const GLdouble *, GLdouble *);
702
703/*
704** Empty an image out of the reply buffer into the clients memory applying
705** the pack modes to pack back into the clients requested format.
706*/
707extern void __glEmptyImage(struct glx_context *, GLint, GLint, GLint, GLint, GLenum,
708                           GLenum, const GLubyte *, GLvoid *);
709
710
711/*
712** Allocate and Initialize Vertex Array client state, and free.
713*/
714extern void __glXInitVertexArrayState(struct glx_context *);
715extern void __glXFreeVertexArrayState(struct glx_context *);
716
717/*
718** Inform the Server of the major and minor numbers and of the client
719** libraries extension string.
720*/
721extern void __glXClientInfo(Display * dpy, int opcode);
722
723/************************************************************************/
724
725/*
726** Declarations that should be in Xlib
727*/
728#ifdef __GL_USE_OUR_PROTOTYPES
729extern void _XFlush(Display *);
730extern Status _XReply(Display *, xReply *, int, Bool);
731extern void _XRead(Display *, void *, long);
732extern void _XSend(Display *, const void *, long);
733#endif
734
735
736extern void __glXInitializeVisualConfigFromTags(struct glx_config * config,
737                                                int count, const INT32 * bp,
738                                                Bool tagged_only,
739                                                Bool fbconfig_style_tags);
740
741extern char *__glXQueryServerString(Display * dpy, int opcode,
742                                    CARD32 screen, CARD32 name);
743extern char *__glXGetString(Display * dpy, int opcode,
744                            CARD32 screen, CARD32 name);
745
746extern char *__glXstrdup(const char *str);
747
748
749extern const char __glXGLClientVersion[];
750extern const char __glXGLClientExtensions[];
751
752/* Get the unadjusted system time */
753extern int __glXGetUST(int64_t * ust);
754
755extern GLboolean __glXGetMscRateOML(Display * dpy, GLXDrawable drawable,
756                                    int32_t * numerator,
757                                    int32_t * denominator);
758
759#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
760extern GLboolean
761__glxGetMscRate(__GLXDRIdrawable *glxDraw,
762		int32_t * numerator, int32_t * denominator);
763
764/* So that dri2.c:DRI2WireToEvent() can access
765 * glx_info->codes->first_event */
766XExtDisplayInfo *__glXFindDisplay (Display *dpy);
767
768extern void
769GarbageCollectDRIDrawables(struct glx_screen *psc);
770
771extern __GLXDRIdrawable *
772GetGLXDRIDrawable(Display *dpy, GLXDrawable drawable);
773
774#endif
775
776extern struct glx_context dummyContext;
777
778extern struct glx_screen *
779indirect_create_screen(int screen, struct glx_display * priv);
780extern struct glx_context *
781indirect_create_context(struct glx_screen *psc,
782			struct glx_config *mode,
783			struct glx_context *shareList, int renderType);
784
785#endif /* !__GLX_client_h__ */
786