andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Convert GLX module to use screen private indexes like everything else.

Browse Source
This commit is contained in:
Kristian Høgsberg 2007-05-30 23:25:03 -04:00
parent 72a3d68a2f
commit 781515bb63
7 changed files with 170 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
GL/glx/glxcmds.c
View File

@ -131,8 +131,8 @@ int DoCreateContext(__GLXclientState *cl, GLXContextID gcId,
return BadValue;
}
pScreen = screenInfo.screens[screen];
pGlxScreen = __glXActiveScreens[screen];
pGlxScreen = glxGetScreen(pScreen);
/*
** Check if the visual ID is valid for this screen.
*/
@ -149,7 +149,7 @@ int DoCreateContext(__GLXclientState *cl, GLXContextID gcId,
/*
** Get configuration of the visual. This assumes that the
** glXActiveScreens structure contains visual configurations only for the
** glxScreen structure contains visual configurations only for the
** subset of Visuals that are supported by this implementation of the
** OpenGL.
*/
@ -931,7 +931,7 @@ int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen,
client->errorValue = screen;
return BadValue;
}
pGlxScreen = __glXActiveScreens[screen];
pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
reply.numVisuals = pGlxScreen->numUsableVisuals;
reply.numProps = __GLX_TOTAL_CONFIG;
@ -1119,7 +1119,7 @@ int DoGetFBConfigs(__GLXclientState *cl, unsigned screen, GLboolean do_swap)
client->errorValue = screen;
return BadValue;
}
pGlxScreen = __glXActiveScreens[screen];
pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
/* Create the "extra" 32bpp ARGB visual, if not already added.
* XXX This is questionable place to do so! Re-examine this someday.
@ -1245,7 +1245,7 @@ static int ValidateCreateDrawable(ClientPtr client,
}
/* Get configuration of the visual. */
pGlxScreen = __glXgetActiveScreen(screenNum);
pGlxScreen = glxGetScreen(pScreen);
*modes = _gl_context_modes_find_visual(pGlxScreen->modes, fbconfigId);
if (*modes == NULL) {
/* Visual not support on this screen by this OpenGL implementation. */
@ -1286,7 +1286,7 @@ int DoCreateGLXPixmap(__GLXclientState *cl, XID fbconfigId,
return BadAlloc;
}
pGlxPixmap->pDraw = pDraw;
pGlxPixmap->pGlxScreen = __glXgetActiveScreen(screenNum);
pGlxPixmap->pGlxScreen = glxGetScreen(pDraw->pScreen);
pGlxPixmap->pScreen = pDraw->pScreen;
pGlxPixmap->idExists = True;
#ifdef XF86DRI
@ -1430,7 +1430,7 @@ int __glXDisp_CreateWindow(__GLXclientState *cl, GLbyte *pc)
/* FIXME: We need to check that the window visual is compatible
* with the specified fbconfig. */
screen = __glXgetActiveScreen(req->screen);
screen = glxGetScreen(screenInfo.screens[req->screen]);
glxPriv = screen->createDrawable(screen, pDraw, req->glxwindow, modes);
if (glxPriv == NULL)
return BadAlloc;
@ -2368,7 +2368,7 @@ int __glXDisp_QueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
return BadValue;
}
ptr = __glXActiveScreens[screen]->GLXextensions;
ptr = glxGetScreen(screenInfo.screens[screen])->GLXextensions;
n = strlen(ptr) + 1;
length = __GLX_PAD(n) >> 2;
@ -2404,6 +2404,7 @@ int __glXDisp_QueryServerString(__GLXclientState *cl, GLbyte *pc)
size_t n, length;
const char *ptr;
char *buf;
__GLXscreen *pGlxScreen;
name = req->name;
screen = req->screen;
@ -2414,15 +2415,17 @@ int __glXDisp_QueryServerString(__GLXclientState *cl, GLbyte *pc)
client->errorValue = screen;
return BadValue;
}
pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
switch(name) {
case GLX_VENDOR:
ptr = __glXActiveScreens[screen]->GLXvendor;
ptr = pGlxScreen->GLXvendor;
break;
case GLX_VERSION:
ptr = __glXActiveScreens[screen]->GLXversion;
ptr = pGlxScreen->GLXversion;
break;
case GLX_EXTENSIONS:
ptr = __glXActiveScreens[screen]->GLXextensions;
ptr = pGlxScreen->GLXextensions;
break;
default:
return BadValue;

23
GL/glx/glxdri.c
View File

@ -103,7 +103,7 @@ __glXDRIleaveServer(GLboolean rendering)
for (i = 0; rendering && i < screenInfo.numScreens; i++) {
__GLXDRIscreen * const screen =
(__GLXDRIscreen *) __glXgetActiveScreen(i);
(__GLXDRIscreen *) glxGetScreen(screenInfo.screens[i]);
GLuint lastOverride = screen->lastTexOffsetOverride;
if (lastOverride) {
@ -125,7 +125,7 @@ __glXDRIleaveServer(GLboolean rendering)
for (i = 0; rendering && i < screenInfo.numScreens; i++) {
__GLXDRIscreen * const screen =
(__GLXDRIscreen *) __glXgetActiveScreen(i);
(__GLXDRIscreen *) glxGetScreen(screenInfo.screens[i]);
GLuint lastOverride = screen->lastTexOffsetOverride;
if (lastOverride) {
@ -153,8 +153,8 @@ __glXDRIenterServer(GLboolean rendering)
int i;
for (i = 0; rendering && i < screenInfo.numScreens; i++) {
__GLXDRIscreen * const screen =
(__GLXDRIscreen *) __glXgetActiveScreen(i);
__GLXDRIscreen * const screen = (__GLXDRIscreen *)
glxGetScreen(screenInfo.screens[i]);
if (screen->lastTexOffsetOverride) {
CALL_Flush(GET_DISPATCH(), ());
@ -205,7 +205,7 @@ __glXDRIdrawableSwapInterval(__GLXdrawable *baseDrawable, int interval)
{
__GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseDrawable;
__GLXDRIscreen *screen = (__GLXDRIscreen *)
__glXgetActiveScreen(baseDrawable->pDraw->pScreen->myNum);
glxGetScreen(baseDrawable->pDraw->pScreen);
if (screen->swapControl)
screen->swapControl->setSwapInterval(&draw->driDrawable, interval);
@ -220,7 +220,7 @@ __glXDRIdrawableCopySubBuffer(__GLXdrawable *basePrivate,
{
__GLXDRIdrawable *private = (__GLXDRIdrawable *) basePrivate;
__GLXDRIscreen *screen = (__GLXDRIscreen *)
__glXgetActiveScreen(basePrivate->pDraw->pScreen->myNum);
glxGetScreen(basePrivate->pDraw->pScreen);
if (screen->copySubBuffer)
screen->copySubBuffer->copySubBuffer(&private->driDrawable,
@ -328,8 +328,7 @@ __glXDRIbindTexImage(__GLXcontext *baseContext,
int bpp, override = 0, texname;
GLenum format, type;
ScreenPtr pScreen = glxPixmap->pScreen;
__GLXDRIscreen * const screen =
(__GLXDRIscreen *) __glXgetActiveScreen(pScreen->myNum);
__GLXDRIscreen * const screen = (__GLXDRIscreen *) glxGetScreen(pScreen);
CALL_GetIntegerv(GET_DISPATCH(), (glxPixmap->target == GL_TEXTURE_2D ?
GL_TEXTURE_BINDING_2D :
@ -482,7 +481,7 @@ __glXDRIreleaseTexImage(__GLXcontext *baseContext,
{
ScreenPtr pScreen = pixmap->pScreen;
__GLXDRIscreen * const screen =
(__GLXDRIscreen *) __glXgetActiveScreen(pScreen->myNum);
(__GLXDRIscreen *) glxGetScreen(pScreen);
GLuint lastOverride = screen->lastTexOffsetOverride;
if (lastOverride) {
@ -801,7 +800,8 @@ static const char dri_driver_path[] = DRI_DRIVER_PATH;
static Bool
glxDRIEnterVT (int index, int flags)
{
__GLXDRIscreen *screen = (__GLXDRIscreen *) __glXgetActiveScreen(index);
__GLXDRIscreen *screen = (__GLXDRIscreen *)
glxGetScreen(screenInfo.screens[index]);
LogMessage(X_INFO, "AIGLX: Resuming AIGLX clients after VT switch\n");
@ -816,7 +816,8 @@ glxDRIEnterVT (int index, int flags)
static void
glxDRILeaveVT (int index, int flags)
{
__GLXDRIscreen *screen = (__GLXDRIscreen *) __glXgetActiveScreen(index);
__GLXDRIscreen *screen = (__GLXDRIscreen *)
glxGetScreen(screenInfo.screens[index]);
LogMessage(X_INFO, "AIGLX: Suspending AIGLX clients for VT switch\n");

192
GL/glx/glxext.c
View File

@ -45,7 +45,6 @@ __GLXcontext *__glXLastContext;
** X resources.
*/
RESTYPE __glXContextRes;
RESTYPE __glXClientRes;
RESTYPE __glXPixmapRes;
RESTYPE __glXDrawableRes;
RESTYPE __glXSwapBarrierRes;
@ -55,11 +54,7 @@ RESTYPE __glXSwapBarrierRes;
*/
xGLXSingleReply __glXReply;
/*
** A set of state for each client. The 0th one is unused because client
** indices start at 1, not 0.
*/
static __GLXclientState *__glXClients[MAXCLIENTS + 1];
static int glxClientPrivateIndex;
/*
** Client that called into GLX dispatch.
@ -77,29 +72,6 @@ static int __glXDispatch(ClientPtr);
static void ResetExtension(ExtensionEntry* extEntry)
{
__glXFlushContextCache();
__glXResetScreens();
}
/*
** Initialize the per-client context storage.
*/
static void ResetClientState(int clientIndex)
{
__GLXclientState *cl = __glXClients[clientIndex];
if (cl->returnBuf) xfree(cl->returnBuf);
if (cl->largeCmdBuf) xfree(cl->largeCmdBuf);
if (cl->currentContexts) xfree(cl->currentContexts);
memset(cl, 0, sizeof(__GLXclientState));
/*
** By default, assume that the client supports
** GLX major version 1 minor version 0 protocol.
*/
cl->GLClientmajorVersion = 1;
cl->GLClientminorVersion = 0;
if (cl->GLClientextensions)
xfree(cl->GLClientextensions);
}
/*
@ -129,39 +101,6 @@ static int ContextGone(__GLXcontext* cx, XID id)
return True;
}
/*
** Free a client's state.
*/
static int ClientGone(int clientIndex, XID id)
{
__GLXcontext *cx;
__GLXclientState *cl = __glXClients[clientIndex];
int i;
if (cl) {
/*
** Free all the contexts that are current for this client.
*/
for (i=0; i < cl->numCurrentContexts; i++) {
cx = cl->currentContexts[i];
if (cx) {
cx->isCurrent = GL_FALSE;
if (!cx->idExists) {
__glXFreeContext(cx);
}
}
}
/*
** Re-initialize the client state structure. Don't free it because
** we'll probably get another client with this index and use the struct
** again. There is a maximum of MAXCLIENTS of these structures.
*/
ResetClientState(clientIndex);
}
return True;
}
/*
** Free a GLX Pixmap.
*/
@ -309,22 +248,87 @@ int __glXError(int error)
return __glXErrorBase + error;
}
__GLXclientState *
glxGetClient(ClientPtr pClient)
{
return (__GLXclientState *) pClient->devPrivates[glxClientPrivateIndex].ptr;
}
static void
glxClientCallback (CallbackListPtr *list,
pointer closure,
pointer data)
{
NewClientInfoRec *clientinfo = (NewClientInfoRec *) data;
ClientPtr pClient = clientinfo->client;
__GLXclientState *cl = glxGetClient(pClient);
__GLXcontext *cx;
int i;
switch (pClient->clientState) {
case ClientStateRunning:
/*
** By default, assume that the client supports
** GLX major version 1 minor version 0 protocol.
*/
cl->GLClientmajorVersion = 1;
cl->GLClientminorVersion = 0;
cl->client = pClient;
break;
case ClientStateGone:
for (i = 0; i < cl->numCurrentContexts; i++) {
cx = cl->currentContexts[i];
if (cx) {
cx->isCurrent = GL_FALSE;
if (!cx->idExists)
__glXFreeContext(cx);
}
}
if (cl->returnBuf) xfree(cl->returnBuf);
if (cl->largeCmdBuf) xfree(cl->largeCmdBuf);
if (cl->currentContexts) xfree(cl->currentContexts);
if (cl->GLClientextensions) xfree(cl->GLClientextensions);
break;
default:
break;
}
}
/************************************************************************/
static __GLXprovider *__glXProviderStack;
void GlxPushProvider(__GLXprovider *provider)
{
provider->next = __glXProviderStack;
__glXProviderStack = provider;
}
/*
** Initialize the GLX extension.
*/
void GlxExtensionInit(void)
{
ExtensionEntry *extEntry;
ScreenPtr pScreen;
int i;
__GLXprovider *p;
__glXContextRes = CreateNewResourceType((DeleteType)ContextGone);
__glXClientRes = CreateNewResourceType((DeleteType)ClientGone);
__glXPixmapRes = CreateNewResourceType((DeleteType)PixmapGone);
__glXDrawableRes = CreateNewResourceType((DeleteType)DrawableGone);
__glXSwapBarrierRes = CreateNewResourceType((DeleteType)SwapBarrierGone);
glxClientPrivateIndex = AllocateClientPrivateIndex ();
if (!AllocateClientPrivate (glxClientPrivateIndex,
sizeof (__GLXclientState)))
return;
if (!AddCallback (&ClientStateCallback, glxClientCallback, 0))
return;
/*
** Add extension to server extensions.
*/
@ -343,17 +347,17 @@ void GlxExtensionInit(void)
__glXErrorBase = extEntry->errorBase;
/*
** Initialize table of client state. There is never a client 0.
*/
for (i = 1; i <= MAXCLIENTS; i++) {
__glXClients[i] = 0;
}
for (i = 0; i < screenInfo.numScreens; i++) {
pScreen = screenInfo.screens[i];
/*
** Initialize screen specific data.
*/
__glXInitScreens();
for (p = __glXProviderStack; p != NULL; p = p->next) {
if (p->screenProbe(pScreen) != NULL)
LogMessage(X_INFO,
"GLX: Initialized %s GL provider for screen %d\n",
p->name, i);
break;
}
}
}
/************************************************************************/
@ -421,11 +425,9 @@ void glxSuspendClients(void)
{
int i;
for (i = 1; i <= MAXCLIENTS; i++) {
if (__glXClients[i] == NULL || !__glXClients[i]->inUse)
continue;
IgnoreClient(__glXClients[i]->client);
for (i = 1; i < currentMaxClients; i++) {
if (glxGetClient(clients[i])->inUse)
IgnoreClient(clients[i]);
}
glxBlockClients = TRUE;
@ -438,11 +440,9 @@ void glxResumeClients(void)
glxBlockClients = FALSE;
for (i = 1; i <= MAXCLIENTS; i++) {
if (__glXClients[i] == NULL || !__glXClients[i]->inUse)
continue;
AttendClient(__glXClients[i]->client);
for (i = 1; i < currentMaxClients; i++) {
if (glxGetClient(clients[i])->inUse)
AttendClient(clients[i]);
}
__glXleaveServer(GL_FALSE);
@ -504,29 +504,9 @@ static int __glXDispatch(ClientPtr client)
int retval;
opcode = stuff->glxCode;
cl = __glXClients[client->index];
if (!cl) {
cl = (__GLXclientState *) xalloc(sizeof(__GLXclientState));
__glXClients[client->index] = cl;
if (!cl) {
return BadAlloc;
}
memset(cl, 0, sizeof(__GLXclientState));
}
if (!cl->inUse) {
/*
** This is first request from this client. Associate a resource
** with the client so we will be notified when the client dies.
*/
XID xid = FakeClientID(client->index);
if (!AddResource( xid, __glXClientRes, (pointer)(long)client->index)) {
return BadAlloc;
}
ResetClientState(client->index);
cl->inUse = GL_TRUE;
cl->client = client;
}
cl = glxGetClient(client);
/* Mark it in use so we suspend it on VT switch. */
cl->inUse = TRUE;
/*
** If we're expecting a glXRenderLarge request, this better be one.

126
GL/glx/glxscreens.c
View File

@ -45,6 +45,8 @@
#include "glxutil.h"
#include "glxext.h"
static int glxScreenPrivateIndex;
const char GLServerVersion[] = "1.4";
static const char GLServerExtensions[] =
"GL_ARB_depth_texture "
@ -179,36 +181,31 @@ static char GLXServerExtensions[] =
"GLX_MESA_copy_sub_buffer "
;
__GLXscreen **__glXActiveScreens;
__GLXSwapBarrierExtensionFuncs *__glXSwapBarrierFuncs = NULL;
static int __glXNumSwapBarrierFuncs = 0;
__GLXHyperpipeExtensionFuncs *__glXHyperpipeFuncs = NULL;
static int __glXNumHyperpipeFuncs = 0;
__GLXscreen *__glXgetActiveScreen(int num) {
return __glXActiveScreens[num];
}
/*
** This hook gets called when a window moves or changes size.
*/
static Bool PositionWindow(WindowPtr pWin, int x, int y)
static Bool glxPositionWindow(WindowPtr pWin, int x, int y)
{
ScreenPtr pScreen;
__GLXcontext *glxc;
__GLXdrawable *glxPriv;
Bool ret;
__GLXscreen *pGlxScreen;
/*
** Call wrapped position window routine
*/
pScreen = pWin->drawable.pScreen;
pScreen->PositionWindow =
__glXActiveScreens[pScreen->myNum]->WrappedPositionWindow;
pGlxScreen = glxGetScreen(pScreen);
pScreen->PositionWindow = pGlxScreen->PositionWindow;
ret = (*pScreen->PositionWindow)(pWin, x, y);
pScreen->PositionWindow = PositionWindow;
pScreen->PositionWindow = glxPositionWindow;
/*
** Tell all contexts rendering into this window that the window size
@ -289,80 +286,59 @@ void __glXSwapBarrierInit(int screen, __GLXSwapBarrierExtensionFuncs *funcs)
funcs->queryMaxSwapBarriersFunc;
}
static __GLXprovider *__glXProviderStack;
void GlxPushProvider(__GLXprovider *provider)
static Bool
glxCloseScreen (int index, ScreenPtr pScreen)
{
provider->next = __glXProviderStack;
__glXProviderStack = provider;
__GLXscreen *pGlxScreen = glxGetScreen(pScreen);
pScreen->CloseScreen = pGlxScreen->CloseScreen;
pScreen->PositionWindow = pGlxScreen->PositionWindow;
pGlxScreen->destroy(pGlxScreen);
return pScreen->CloseScreen(index, pScreen);
}
void __glXScreenInit(__GLXscreen *screen, ScreenPtr pScreen)
__GLXscreen *
glxGetScreen(ScreenPtr pScreen)
{
screen->pScreen = pScreen;
screen->GLextensions = xstrdup(GLServerExtensions);
screen->GLXvendor = xstrdup(GLXServerVendorName);
screen->GLXversion = xstrdup(GLXServerVersion);
screen->GLXextensions = xstrdup(GLXServerExtensions);
screen->WrappedPositionWindow = pScreen->PositionWindow;
pScreen->PositionWindow = PositionWindow;
__glXScreenInitVisuals(screen);
return (__GLXscreen *) pScreen->devPrivates[glxScreenPrivateIndex].ptr;
}
void
__glXScreenDestroy(__GLXscreen *screen)
void __glXScreenInit(__GLXscreen *glxScreen, ScreenPtr pScreen)
{
static int glxGeneration;
if (glxGeneration != serverGeneration)
{
glxScreenPrivateIndex = AllocateScreenPrivateIndex ();
if (glxScreenPrivateIndex == -1)
return;
glxGeneration = serverGeneration;
}
glxScreen->pScreen = pScreen;
glxScreen->GLextensions = xstrdup(GLServerExtensions);
glxScreen->GLXvendor = xstrdup(GLXServerVendorName);
glxScreen->GLXversion = xstrdup(GLXServerVersion);
glxScreen->GLXextensions = xstrdup(GLXServerExtensions);
glxScreen->PositionWindow = pScreen->PositionWindow;
pScreen->PositionWindow = glxPositionWindow;
glxScreen->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = glxCloseScreen;
__glXScreenInitVisuals(glxScreen);
pScreen->devPrivates[glxScreenPrivateIndex].ptr = (pointer) glxScreen;
}
void __glXScreenDestroy(__GLXscreen *screen)
{
xfree(screen->GLXvendor);
xfree(screen->GLXversion);
xfree(screen->GLXextensions);
xfree(screen->GLextensions);
}
void __glXInitScreens(void)
{
GLint i;
ScreenPtr pScreen;
__GLXprovider *p;
size_t size;
/*
** This alloc has to work or else the server might as well core dump.
*/
size = screenInfo.numScreens * sizeof(__GLXscreen *);
__glXActiveScreens = xalloc(size);
memset(__glXActiveScreens, 0, size);
for (i = 0; i < screenInfo.numScreens; i++) {
pScreen = screenInfo.screens[i];
for (p = __glXProviderStack; p != NULL; p = p->next) {
__glXActiveScreens[i] = p->screenProbe(pScreen);
if (__glXActiveScreens[i] != NULL) {
LogMessage(X_INFO,
"GLX: Initialized %s GL provider for screen %d\n",
p->name, i);
break;
}
}
}
}
void __glXResetScreens(void)
{
int i;
for (i = 0; i < screenInfo.numScreens; i++)
if (__glXActiveScreens[i])
__glXActiveScreens[i]->destroy(__glXActiveScreens[i]);
xfree(__glXActiveScreens);
xfree(__glXHyperpipeFuncs);
xfree(__glXSwapBarrierFuncs);
__glXNumHyperpipeFuncs = 0;
__glXNumSwapBarrierFuncs = 0;
__glXHyperpipeFuncs = NULL;
__glXSwapBarrierFuncs = NULL;
__glXActiveScreens = NULL;
}

10
GL/glx/glxscreens.h
View File

@ -79,18 +79,12 @@ struct __GLXscreen {
char *GLXversion;
char *GLXextensions;
/*
** Things that are not statically set.
*/
Bool (*WrappedPositionWindow)(WindowPtr pWin, int x, int y);
Bool (*PositionWindow)(WindowPtr pWin, int x, int y);
Bool (*CloseScreen)(int index, ScreenPtr pScreen);
};
void __glXScreenInit(__GLXscreen *screen, ScreenPtr pScreen);
void __glXScreenDestroy(__GLXscreen *screen);
void __glXInitScreens(void);
extern void __glXResetScreens(void);
#endif /* !__GLX_screens_h__ */

5
GL/glx/glxserver.h
View File

@ -90,9 +90,8 @@ typedef XID GLXDrawable;
typedef struct __GLXclientStateRec __GLXclientState;
extern __GLXscreen **__glXActiveScreens;
extern GLint __glXNumActiveScreens;
extern __GLXscreen *__glXgetActiveScreen(int num);
extern __GLXscreen *glxGetScreen(ScreenPtr pScreen);
extern __GLXclientState *glxGetClient(ClientPtr pClient);
/************************************************************************/

4
hw/xfree86/dri/dri.c
View File

@ -972,7 +972,7 @@ static Bool
DRICreateDummyContext(ScreenPtr pScreen, Bool needCtxPriv)
{
DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
__GLXscreen *pGLXScreen = __glXgetActiveScreen(pScreen->myNum);
__GLXscreen *pGLXScreen = glxGetScreen(pScreen);
__GLcontextModes *modes = pGLXScreen->modes;
void **pVisualConfigPriv = pGLXScreen->pVisualPriv;
DRIContextPrivPtr pDRIContextPriv;
@ -1036,7 +1036,7 @@ DRICreateContext(ScreenPtr pScreen, VisualPtr visual,
XID context, drm_context_t * pHWContext)
{
DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
__GLXscreen *pGLXScreen = __glXgetActiveScreen(pScreen->myNum);
__GLXscreen *pGLXScreen = glxGetScreen(pScreen);
__GLcontextModes *modes = pGLXScreen->modes;
void **pVisualConfigPriv = pGLXScreen->pVisualPriv;
DRIContextPrivPtr pDRIContextPriv;