All of the libglx.a and libGLcore.a code now uses __GLcontextModes todriinterface-0-0-2-branch

track FBconfigs / visuals.

10 files changed, 216 insertions, 270 deletions

diff --git a/xc/programs/Xserver/GL/dri/dri.c b/xc/programs/Xserver/GL/dri/dri.c
index fbda42ab9..50c481e23 100644
--- a/xc/programs/Xserver/GL/dri/dri.c
+++ b/xc/programs/Xserver/GL/dri/dri.c
@@ -780,7 +780,7 @@ DRICreateDummyContext(ScreenPtr pScreen, Bool needCtxPriv)
 {
     DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
     __GLXscreenInfo *pGLXScreen = &__glXActiveScreens[pScreen->myNum];
-    __GLXvisualConfig *pGLXVis = pGLXScreen->pGlxVisual;
+    __GLcontextModes *modes = pGLXScreen->modes;
     void **pVisualConfigPriv = pGLXScreen->pVisualPriv;
     DRIContextPrivPtr pDRIContextPriv;
     void *contextStore;
@@ -793,7 +793,7 @@ DRICreateDummyContext(ScreenPtr pScreen, Bool needCtxPriv)
     for (visNum = 0;
 	 visNum < pScreen->numVisuals;
 	 visNum++, visual++) {
-	if (pGLXVis->vid == visual->vid)
+	if (modes->visualID == visual->vid)
 	    break;
     }
     if (visNum == pScreen->numVisuals) return FALSE;
@@ -844,11 +844,10 @@ DRICreateContext(ScreenPtr pScreen, VisualPtr visual,
 {
     DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
     __GLXscreenInfo *pGLXScreen = &__glXActiveScreens[pScreen->myNum];
-    __GLXvisualConfig *pGLXVis = pGLXScreen->pGlxVisual;
+    __GLcontextModes *modes = pGLXScreen->modes;
     void **pVisualConfigPriv = pGLXScreen->pVisualPriv;
     DRIContextPrivPtr pDRIContextPriv;
     void *contextStore;
-    int visNum;
 
     if (pDRIPriv->createDummyCtx && !pDRIPriv->dummyCtxPriv) {
         if (!DRICreateDummyContext(pScreen, pDRIPriv->createDummyCtxPriv)) {
@@ -859,12 +858,13 @@ DRICreateContext(ScreenPtr pScreen, VisualPtr visual,
     }
 
     /* Find the GLX visual associated with the one requested */
-    for (visNum = 0;
-	 visNum < pGLXScreen->numVisuals;
-	 visNum++, pGLXVis++, pVisualConfigPriv++)
-	if (pGLXVis->vid == visual->vid)
+    for (modes = pGLXScreen->modes; modes != NULL; modes = modes->next) {
+	if (modes->visualID == visual->vid)
 	    break;
-    if (visNum == pGLXScreen->numVisuals) {
+	pVisualConfigPriv++;
+    }
+
+    if (modes == NULL) {
 	/* No matching GLX visual found */
 	return FALSE;
     }
diff --git a/xc/programs/Xserver/GL/glx/Imakefile b/xc/programs/Xserver/GL/glx/Imakefile
index af7d1a118..a2e232b3d 100644
--- a/xc/programs/Xserver/GL/glx/Imakefile
+++ b/xc/programs/Xserver/GL/glx/Imakefile
@@ -11,6 +11,9 @@ SUBDIRS = module
 
 #include <Server.tmpl>
 
+LinkSourceFile(glcontextmodes.c,$(LIBSRC)/GL/glx)
+LinkSourceFile(glcontextmodes.h,$(LIBSRC)/GL/glx)
+
          SRCS = global.c glxbuf.c glxcmds.c glxcmdsswap.c glxext.c \
                 glxfb.c glximports.c glxmem.c glxpix.c glxscreens.c \
                 glxutil.c render2.c render2swap.c renderpix.c \
@@ -18,7 +21,7 @@ SUBDIRS = module
                 single2swap.c singlepix.c singlepixswap.c \
                 singlesize.c xfont.c g_disptab.c g_disptab_EXT.c \
                 g_render.c g_renderswap.c g_single.c g_singleswap.c \
-                $(MSRCS)
+                glcontextmodes.c $(MSRCS)
 
          OBJS = global.o glxbuf.o glxcmds.o glxcmdsswap.o glxext.o \
                 glxfb.o glximports.o glxmem.o glxpix.o glxscreens.o \
@@ -27,7 +30,7 @@ SUBDIRS = module
                 single2swap.o singlepix.o singlepixswap.o \
                 singlesize.o xfont.o g_disptab.o g_disptab_EXT.o \
                 g_render.o g_renderswap.o g_single.o g_singleswap.o \
-                $(MOBJS)
+                glcontextmodes.o $(MOBJS)
 
      INCLUDES = -I$(SERVERSRC)/GL/glx -I$(SERVERSRC)/GL/include -I$(SERVERSRC)/include -I$(INCLUDESRC) -I$(MESASRCDIR)/include \
                 -I$(XINCLUDESRC) -I$(SERVERSRC)/mi \
diff --git a/xc/programs/Xserver/GL/glx/glxcmds.c b/xc/programs/Xserver/GL/glx/glxcmds.c
index e3dab2f24..38199f129 100644
--- a/xc/programs/Xserver/GL/glx/glxcmds.c
+++ b/xc/programs/Xserver/GL/glx/glxcmds.c
@@ -47,6 +47,7 @@
 #include "glxutil.h"
 #include "glxext.h"
 #include "GL/glx_ansic.h"
+#include "glcontextmodes.h"
 
 /************************************************************************/
 
@@ -83,7 +84,7 @@ int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
     VisualPtr pVisual;
     ScreenPtr pScreen;
     __GLXcontext *glxc, *shareglxc;
-    __GLXvisualConfig *pGlxVisual;
+    __GLcontextModes *modes;
     __GLXscreenInfo *pGlxScreen;
     __GLinterface *shareGC;
     GLXContextID gcId = req->context;
@@ -123,13 +124,9 @@ int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
     ** subset of Visuals that are supported by this implementation of the
     ** OpenGL.
     */
-    pGlxVisual = pGlxScreen->pGlxVisual;
-    for (i = 0; i < pGlxScreen->numVisuals; i++, pGlxVisual++) {
-	if (pGlxVisual->vid == visual) {
-	    break;
-	}
-    }
-    if (i == pGlxScreen->numVisuals) {
+
+    modes = _gl_context_modes_find_visual( pGlxScreen->modes, visual );
+    if (modes == NULL) {
 	/*
 	** Visual not support on this screen by this OpenGL implementation.
 	*/
@@ -192,22 +189,15 @@ int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
     glxc->pScreen = pScreen;
     glxc->pGlxScreen = pGlxScreen;
     glxc->pVisual = pVisual;
-    glxc->pGlxVisual = pGlxVisual;
+    glxc->modes = modes;
 
     if (!isDirect) {
-	__GLcontextModes *modes;
-	/*
-	** first build __GLcontextModes from __GLXvisualConfig
-	*/
-	modes = (__GLcontextModes *) __glXMalloc(sizeof(__GLcontextModes));
-	glxc->modes = modes;
-	__glXFormatGLModes(modes, pGlxVisual);
 
 	/*
 	** Allocate a GL context
 	*/
 	imports.other = (void *)glxc;
-	glxc->gc = (*pGlxScreen->createContext)(&imports, modes, shareGC);
+	glxc->gc = (*pGlxScreen->createContext)(&imports, glxc->modes, shareGC);
 	if (!glxc->gc) {
 	    __glXFree(glxc);
 	    client->errorValue = gcId;
@@ -449,7 +439,7 @@ static int GetDrawableOrPixmap( __GLXcontext *glxc, GLXDrawable drawId,
 	    ** Check if pixmap and context are similar.
 	    */
 	    if (drawPixmap->pScreen != glxc->pScreen ||
-		drawPixmap->pGlxVisual != glxc->pGlxVisual) {
+		drawPixmap->modes->visualID != glxc->modes->visualID) {
 		client->errorValue = drawId;
 		return BadMatch;
 	    }
@@ -886,9 +876,9 @@ int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen,
     ClientPtr client = cl->client;
     xGLXGetVisualConfigsReply reply;
     __GLXscreenInfo *pGlxScreen;
-    __GLXvisualConfig *pGlxVisual;
+    __GLcontextModes *modes;
     CARD32 buf[__GLX_TOTAL_CONFIG];
-    int i, p;
+    int p;
     __GLX_DECLARE_SWAP_VARIABLES;
     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 
@@ -915,51 +905,50 @@ int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen,
 
     WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char *)&reply);
 
-    for (i=0; i < pGlxScreen->numVisuals; i++) {
-	pGlxVisual = &pGlxScreen->pGlxVisual[i];
-	if (pGlxVisual->vid == 0) {
+    for ( modes = pGlxScreen->modes ; modes != NULL ; modes = modes->next ) {
+	if (modes->visualID == 0) {
 	    /* not a usable visual */
 	    continue;
 	}
 	p = 0;
-	buf[p++] = pGlxVisual->vid;
-	buf[p++] = pGlxVisual->class;
-	buf[p++] = pGlxVisual->rgba;
-
-	buf[p++] = pGlxVisual->redSize;
-	buf[p++] = pGlxVisual->greenSize;
-	buf[p++] = pGlxVisual->blueSize;
-	buf[p++] = pGlxVisual->alphaSize;
-	buf[p++] = pGlxVisual->accumRedSize;
-	buf[p++] = pGlxVisual->accumGreenSize;
-	buf[p++] = pGlxVisual->accumBlueSize;
-	buf[p++] = pGlxVisual->accumAlphaSize;
-
-	buf[p++] = pGlxVisual->doubleBuffer;
-	buf[p++] = pGlxVisual->stereo;
-
-	buf[p++] = pGlxVisual->bufferSize;
-	buf[p++] = pGlxVisual->depthSize;
-	buf[p++] = pGlxVisual->stencilSize;
-	buf[p++] = pGlxVisual->auxBuffers;
-	buf[p++] = pGlxVisual->level;
+	buf[p++] = modes->visualID;
+	buf[p++] = _gl_convert_to_x_visual_type( modes->visualType );
+	buf[p++] = modes->rgbMode;
+
+	buf[p++] = modes->redBits;
+	buf[p++] = modes->greenBits;
+	buf[p++] = modes->blueBits;
+	buf[p++] = modes->alphaBits;
+	buf[p++] = modes->accumRedBits;
+	buf[p++] = modes->accumGreenBits;
+	buf[p++] = modes->accumBlueBits;
+	buf[p++] = modes->accumAlphaBits;
+
+	buf[p++] = modes->doubleBufferMode;
+	buf[p++] = modes->stereoMode;
+
+	buf[p++] = modes->rgbBits;
+	buf[p++] = modes->depthBits;
+	buf[p++] = modes->stencilBits;
+	buf[p++] = modes->numAuxBuffers;
+	buf[p++] = modes->level;
 	/* 
 	** Add token/value pairs for extensions.
 	*/
 	buf[p++] = GLX_VISUAL_CAVEAT_EXT;
-	buf[p++] = pGlxVisual->visualRating;
-	buf[p++] = GLX_TRANSPARENT_TYPE_EXT;
-	buf[p++] = pGlxVisual->transparentPixel;
-	buf[p++] = GLX_TRANSPARENT_RED_VALUE_EXT;
-	buf[p++] = pGlxVisual->transparentRed;
-	buf[p++] = GLX_TRANSPARENT_GREEN_VALUE_EXT;
-	buf[p++] = pGlxVisual->transparentGreen;
-	buf[p++] = GLX_TRANSPARENT_BLUE_VALUE_EXT;
-	buf[p++] = pGlxVisual->transparentBlue;
-	buf[p++] = GLX_TRANSPARENT_ALPHA_VALUE_EXT;
-	buf[p++] = pGlxVisual->transparentAlpha;
-	buf[p++] = GLX_TRANSPARENT_INDEX_VALUE_EXT;
-	buf[p++] = pGlxVisual->transparentIndex;
+	buf[p++] = modes->visualRating;
+	buf[p++] = GLX_TRANSPARENT_TYPE;
+	buf[p++] = modes->transparentPixel;
+	buf[p++] = GLX_TRANSPARENT_RED_VALUE;
+	buf[p++] = modes->transparentRed;
+	buf[p++] = GLX_TRANSPARENT_GREEN_VALUE;
+	buf[p++] = modes->transparentGreen;
+	buf[p++] = GLX_TRANSPARENT_BLUE_VALUE;
+	buf[p++] = modes->transparentBlue;
+	buf[p++] = GLX_TRANSPARENT_ALPHA_VALUE;
+	buf[p++] = modes->transparentAlpha;
+	buf[p++] = GLX_TRANSPARENT_INDEX_VALUE;
+	buf[p++] = modes->transparentIndex;
 
 	if ( do_swap ) {
 	    __GLX_SWAP_INT_ARRAY(buf, __GLX_TOTAL_CONFIG);
@@ -992,7 +981,7 @@ int __glXCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
     VisualPtr pVisual;
     __GLXpixmap *pGlxPixmap;
     __GLXscreenInfo *pGlxScreen;
-    __GLXvisualConfig *pGlxVisual;
+    __GLcontextModes *modes;
     int i;
 
     pDraw = (DrawablePtr) LookupDrawable(pixmapId, client);
@@ -1033,13 +1022,8 @@ int __glXCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
     ** Get configuration of the visual.
     */
     pGlxScreen = &__glXActiveScreens[screenNum];
-    pGlxVisual = pGlxScreen->pGlxVisual;
-    for (i = 0; i < pGlxScreen->numVisuals; i++, pGlxVisual++) {
-	if (pGlxVisual->vid == visual) {
-	    break;
-	}
-    }
-    if (i == pGlxScreen->numVisuals) {
+    modes = _gl_context_modes_find_visual( pGlxScreen->modes, visual );
+    if (modes == NULL) {
 	/*
 	** Visual not support on this screen by this OpenGL implementation.
 	*/
@@ -1056,11 +1040,12 @@ int __glXCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
     }
     pGlxPixmap->pDraw = pDraw;
     pGlxPixmap->pGlxScreen = pGlxScreen;
-    pGlxPixmap->pGlxVisual = pGlxVisual;
     pGlxPixmap->pScreen = pScreen;
     pGlxPixmap->idExists = True;
     pGlxPixmap->refcnt = 0;
 
+    pGlxPixmap->modes = modes;
+
     /*
     ** Bump the ref count on the X pixmap so it won't disappear.
     */
diff --git a/xc/programs/Xserver/GL/glx/glxcontext.h b/xc/programs/Xserver/GL/glx/glxcontext.h
index 5eb72177e..9a16851f0 100644
--- a/xc/programs/Xserver/GL/glx/glxcontext.h
+++ b/xc/programs/Xserver/GL/glx/glxcontext.h
@@ -80,7 +80,6 @@ struct __GLXcontextRec {
     ** This context is created with respect to this visual.
     */
     VisualRec *pVisual;
-    __GLXvisualConfig *pGlxVisual;
 
     /*
     ** The XID of this context.
diff --git a/xc/programs/Xserver/GL/glx/glxdrawable.h b/xc/programs/Xserver/GL/glx/glxdrawable.h
index 972a6045f..1d7f44352 100644
--- a/xc/programs/Xserver/GL/glx/glxdrawable.h
+++ b/xc/programs/Xserver/GL/glx/glxdrawable.h
@@ -40,7 +40,7 @@
 typedef struct {
 
     DrawablePtr pDraw;
-    __GLXvisualConfig *pGlxVisual;
+    __GLcontextModes *modes;
     __GLXscreenInfo *pGlxScreen;
     ScreenPtr pScreen;
     Bool idExists;
@@ -69,11 +69,12 @@ struct __GLXdrawablePrivateRec {
     /*
     ** Configuration of the visual to which this drawable was created.
     */
-    __GLXvisualConfig *pGlxVisual;
+    __GLcontextModes *modes;
 
     /*
     ** cached drawable size and origin
     */
+
     GLint xorigin, yorigin;
     GLint width, height;
 
diff --git a/xc/programs/Xserver/GL/glx/glxscreens.c b/xc/programs/Xserver/GL/glx/glxscreens.c
index fb90ff90d..d2b92a2d6 100644
--- a/xc/programs/Xserver/GL/glx/glxscreens.c
+++ b/xc/programs/Xserver/GL/glx/glxscreens.c
@@ -151,81 +151,6 @@ GLint __glXNumActiveScreens;
 
 RESTYPE __glXDrawableRes;
 
-#if 0
-static int
-CountBits(unsigned long mask)
-{
-    int count = 0;
-
-    while(mask) {
-	count += (mask&1);
-	mask >>= 1;
-    }
-
-    return count;
-}
-#endif
-
-#if 0
-/*
-** A typical implementation would not probably not run through the screen's
-** visuals to find ones that match the visual configs supplied by the DDX
-** Sample OpenGL as we do here; we have done this to make this code easy to
-** drop into an existing X server.
-*/
-static int matchVisuals(__GLXvisualConfig *pGlxVisual, int numVisuals,
-			 int screen)
-{
-    int i, j;
-    __GLXvisualConfig *pvis = pGlxVisual;
-    ScreenPtr pScreen = screenInfo.screens[screen];
-    VisualPtr pVisual;
-    int numMatchingVisuals = 0; 
-    int *used;
-
-    used = (int *)__glXMalloc(pScreen->numVisuals*sizeof(int));
-    __glXMemset(used, 0, pScreen->numVisuals*sizeof(int));
-
-    for (i=0; i < numVisuals; i++, pvis++) {
-	/*
-	** Look through all the server's visuals to see which match.
-	*/
-	pvis->vid = 0;
-	pVisual = pScreen->visuals;
-	for (j=0; j < pScreen->numVisuals; j++, pVisual++) {
-	    if (pvis->class == pVisual->class &&
-		pvis->bufferSize == pVisual->nplanes &&
-		!used[j]) {
-		int rBits, gBits, bBits, aBits;
-
-		/* count bits per rgb */
-		rBits = CountBits(pVisual->redMask);
-		gBits = CountBits(pVisual->greenMask);
-		bBits = CountBits(pVisual->blueMask);
-		aBits = 0;
-		if ((pvis->redSize == rBits) &&
-		    (pvis->greenSize == gBits) &&
-		    (pvis->blueSize == bBits) &&
-		    (pvis->alphaSize == aBits)) {
-		    /*
-		    ** We'll consider this a match.
-		    */
-		    pvis->vid = pVisual->vid;
-		    pvis->redMask = pVisual->redMask;
-		    pvis->greenMask = pVisual->greenMask;
-		    pvis->blueMask = pVisual->blueMask;
-		    pvis->alphaMask = 0;
-		    numMatchingVisuals++;
-		    used[j] = 1;
-		    break;
-		}
-	    }
-	}
-    }
-    __glXFree(used);
-    return numMatchingVisuals;
-}
-#endif
 
 /*
 ** Destroy routine that gets called when a drawable is freed.  A drawable
@@ -355,14 +280,7 @@ void __glXScreenInit(GLint numscreens)
 	    if ((*__glXScreens[j]->screenProbe)(i)) {
 		__glXActiveScreens[i] = *__glXScreens[j];
 
-#if 0
-                /* we don't use this since matchVisuals doesn't allow alpha */
-		__glXActiveScreens[i].numUsableVisuals =
-		    matchVisuals(__glXActiveScreens[i].pGlxVisual,
-			         __glXActiveScreens[i].numVisuals, i); 
-#else
 		__glXActiveScreens[i].numUsableVisuals = __glXActiveScreens[i].numVisuals;
-#endif
 		__glXActiveScreens[i].GLextensions = __glXStrdup(GLServerExtensions);
 		__glXActiveScreens[i].GLXvendor = __glXStrdup(GLXServerVendorName);
 		__glXActiveScreens[i].GLXversion = __glXStrdup(GLXServerVersion);
diff --git a/xc/programs/Xserver/GL/glx/glxscreens.h b/xc/programs/Xserver/GL/glx/glxscreens.h
index 99f76dc38..9ca166b74 100644
--- a/xc/programs/Xserver/GL/glx/glxscreens.h
+++ b/xc/programs/Xserver/GL/glx/glxscreens.h
@@ -70,7 +70,11 @@ typedef struct {
     */
     void (*createBuffer)(__GLXdrawablePrivate *glxPriv);
 
-    __GLXvisualConfig *pGlxVisual;
+    /**
+     * Linked list of valid context modes for this screen.
+     */
+    __GLcontextModes *modes;
+
     void **pVisualPriv;
     GLint numVisuals;
     GLint numUsableVisuals;
diff --git a/xc/programs/Xserver/GL/glx/glxutil.c b/xc/programs/Xserver/GL/glx/glxutil.c
index 7aafd0065..f66657246 100644
--- a/xc/programs/Xserver/GL/glx/glxutil.c
+++ b/xc/programs/Xserver/GL/glx/glxutil.c
@@ -44,6 +44,9 @@
 #include "glxutil.h"
 #include "glxbuf.h"
 #include "GL/glx_ansic.h"
+#include "GL/internal/glcore.h"
+#include "GL/glxint.h"
+#include "glcontextmodes.h"
 
 /************************************************************************/
 
@@ -219,8 +222,17 @@ __glXResizeDrawable(__GLdrawablePrivate *glPriv)
 void
 __glXFormatGLModes(__GLcontextModes *modes, __GLXvisualConfig *config)
 {
+    /* FIXME: Use _gl_copy_visual_to_context_mode instead!
+     */
+
     __glXMemset(modes, 0, sizeof(__GLcontextModes));
 
+    modes->visualID = config->vid;
+    modes->visualType = _gl_convert_from_x_visual_type( config->class );
+    modes->xRenderable = GL_TRUE;
+    modes->fbconfigID = GLX_DONT_CARE;
+    modes->drawableType = GLX_WINDOW_BIT;
+
     modes->rgbMode = (config->rgba != 0);
     modes->colorIndexMode = !(modes->rgbMode);
     modes->doubleBufferMode = (config->doubleBuffer != 0);
@@ -257,8 +269,15 @@ __glXFormatGLModes(__GLcontextModes *modes, __GLXvisualConfig *config)
     modes->stencilBits = config->stencilSize;
 
     modes->numAuxBuffers = 0;	/* XXX: should be picked up from the visual */
-
     modes->level = config->level;
+
+    modes->visualRating = config->visualRating;
+    modes->transparentPixel = config->transparentPixel;
+    modes->transparentRed   = config->transparentRed;
+    modes->transparentGreen = config->transparentGreen;
+    modes->transparentBlue  = config->transparentBlue;
+    modes->transparentAlpha = config->transparentAlpha;
+    modes->transparentIndex = config->transparentIndex;
 }
 
 /*****************************************************************************/
@@ -382,21 +401,13 @@ __glXCreateDrawablePrivate(DrawablePtr pDraw, XID drawId,
 
     pGlxScreen = &__glXActiveScreens[pDraw->pScreen->myNum];
 
-    /* allocate the buffers */
     if (glxPriv->type == DRAWABLE_WINDOW) {
-	int i;
 	VisualID vid = wVisual((WindowPtr)pDraw);
-	__GLXvisualConfig *pGlxVisual = pGlxScreen->pGlxVisual;
 
-	for (i = 0; i < pGlxScreen->numVisuals; i++, pGlxVisual++) {
-	    if (pGlxVisual->vid == vid) {
-		glxPriv->pGlxVisual = pGlxVisual;
-		break;
-	    }
-	}
+	glxPriv->modes = _gl_context_modes_find_visual( pGlxScreen->modes, vid );
 	__glXFBInitDrawable(glxPriv, modes);
     } else {
-	glxPriv->pGlxVisual = glxPriv->pGlxPixmap->pGlxVisual;
+	glxPriv->modes = glxPriv->pGlxPixmap->modes;
 	__glXPixInitDrawable(glxPriv, modes);
     }
 
diff --git a/xc/programs/Xserver/GL/mesa/X/xf86glx.c b/xc/programs/Xserver/GL/mesa/X/xf86glx.c
index 19b8ba7c8..9782cbfcd 100644
--- a/xc/programs/Xserver/GL/mesa/X/xf86glx.c
+++ b/xc/programs/Xserver/GL/mesa/X/xf86glx.c
@@ -65,6 +65,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include <GL/internal/glcore.h>
 #endif
 
+#include "glcontextmodes.h"
 
 /*
  * This structure is statically allocated in the __glXScreens[]
@@ -79,7 +80,7 @@ __GLXscreenInfo __glDDXScreenInfo = {
     __MESA_screenProbe,   /* Must be generic and handle all screens */
     __MESA_createContext, /* Substitute screen's createContext routine */
     __MESA_createBuffer,  /* Substitute screen's createBuffer routine */
-    NULL,                 /* Set up pGlxVisual in probe */
+    NULL,                 /* Set up modes in probe */
     NULL,                 /* Set up pVisualPriv in probe */
     0,                    /* Set up numVisuals in probe */
     0,                    /* Set up numUsableVisuals in probe */
@@ -118,18 +119,19 @@ static int count_bits(unsigned int n)
 
 static XMesaVisual find_mesa_visual(int screen, VisualID vid)
 {
-    XMesaVisual xm_vis = NULL;
-    __MESA_screen *pMScr = &MESAScreens[screen];
-    int i;
+    __MESA_screen * const pMScr = &MESAScreens[screen];
+    const __GLcontextModes *modes;
+    unsigned i = 0;
 
-    for (i = 0; i < pMScr->num_vis; i++) {
-	if (pMScr->glx_vis[i].vid == vid) {
-	    xm_vis = pMScr->xm_vis[i];
+    for ( modes = pMScr->modes ; modes != NULL ; modes = modes->next ) {
+	if ( modes->visualID == vid ) {
 	    break;
 	}
+
+	i++;
     }
 
-    return xm_vis;
+    return (modes != NULL) ? pMScr->xm_vis[i] : NULL;
 }
 
 
@@ -257,7 +259,7 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     VisualPtr pVisual = *visualp;
     VisualPtr pVisualNew = NULL;
     VisualID *orig_vid = NULL;
-    __GLXvisualConfig *glXVisualPtr = NULL;
+    __GLcontextModes *modes;
     __GLXvisualConfig *pNewVisualConfigs = NULL;
     void **glXVisualPriv;
     void **pNewVisualPriv;
@@ -331,9 +333,8 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     }
 
     /* Alloc space for the list of glXVisuals */
-    glXVisualPtr = (__GLXvisualConfig *)__glXMalloc(numNewVisuals *
-						    sizeof(__GLXvisualConfig));
-    if (!glXVisualPtr) {
+    modes = _gl_context_modes_create(numNewVisuals, sizeof(__GLcontextModes));
+    if (modes == NULL) {
 	__glXFree(orig_vid);
 	__glXFree(pNewVisualPriv);
 	__glXFree(pNewVisualConfigs);
@@ -343,7 +344,7 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     /* Alloc space for the list of glXVisualPrivates */
     glXVisualPriv = (void **)__glXMalloc(numNewVisuals * sizeof(void *));
     if (!glXVisualPriv) {
-	__glXFree(glXVisualPtr);
+	_gl_context_modes_destroy( modes );
 	__glXFree(orig_vid);
 	__glXFree(pNewVisualPriv);
 	__glXFree(pNewVisualConfigs);
@@ -354,7 +355,7 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     pVisualNew = (VisualPtr)__glXMalloc(numNewVisuals * sizeof(VisualRec));
     if (!pVisualNew) {
 	__glXFree(glXVisualPriv);
-	__glXFree(glXVisualPtr);
+	_gl_context_modes_destroy( modes );
 	__glXFree(orig_vid);
 	__glXFree(pNewVisualPriv);
 	__glXFree(pNewVisualConfigs);
@@ -363,6 +364,7 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
 
     /* Initialize the new visuals */
     found_default = FALSE;
+    MESAScreens[screenInfo.numScreens-1].modes = modes;
     for (i = j = 0; i < numVisuals; i++) {
         int is_rgb = (pVisual[i].class == TrueColor ||
 		      pVisual[i].class == DirectColor);
@@ -371,6 +373,8 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
 	    if (pNewVisualConfigs[k].rgba != is_rgb)
 		continue;
 
+	    assert( modes != NULL );
+
 	    /* Initialize the new visual */
 	    pVisualNew[j] = pVisual[i];
 	    pVisualNew[j].vid = FakeClientID(0);
@@ -385,8 +389,8 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
 	    orig_vid[j] = pVisual[i].vid;
 
 	    /* Initialize the glXVisual */
-	    glXVisualPtr[j] = pNewVisualConfigs[k];
-	    glXVisualPtr[j].vid = pVisualNew[j].vid;
+	    _gl_copy_visual_to_context_mode( modes, & pNewVisualConfigs[k] );
+	    modes->visualID = pVisualNew[j].vid;
 
 	    /*
 	     * If the class is -1, then assume the X visual information
@@ -394,30 +398,27 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
 	     * visual.  NOTE: if class != -1, then all other fields MUST
 	     * be initialized.
 	     */
-	    if (glXVisualPtr[j].class == -1) {
-		glXVisualPtr[j].class      = pVisual[i].class;
-		glXVisualPtr[j].redSize    = count_bits(pVisual[i].redMask);
-		glXVisualPtr[j].greenSize  = count_bits(pVisual[i].greenMask);
-		glXVisualPtr[j].blueSize   = count_bits(pVisual[i].blueMask);
-		glXVisualPtr[j].alphaSize  = glXVisualPtr[j].alphaSize;
-		glXVisualPtr[j].redMask    = pVisual[i].redMask;
-		glXVisualPtr[j].greenMask  = pVisual[i].greenMask;
-		glXVisualPtr[j].blueMask   = pVisual[i].blueMask;
-		glXVisualPtr[j].alphaMask  = glXVisualPtr[j].alphaMask;
-		if (is_rgb) {
-		    glXVisualPtr[j].bufferSize = glXVisualPtr[j].redSize +
-		                                 glXVisualPtr[j].greenSize +
-		                                 glXVisualPtr[j].blueSize +
-		                                 glXVisualPtr[j].alphaSize;
-		} else {
-		    glXVisualPtr[j].bufferSize = rootDepth;
-		}
+	    if (modes->visualType == GLX_NONE) {
+		modes->visualType = _gl_convert_from_x_visual_type( pVisual[i].class );
+		modes->redBits    = count_bits(pVisual[i].redMask);
+		modes->greenBits  = count_bits(pVisual[i].greenMask);
+		modes->blueBits   = count_bits(pVisual[i].blueMask);
+		modes->alphaBits  = modes->alphaBits;
+		modes->redMask    = pVisual[i].redMask;
+		modes->greenMask  = pVisual[i].greenMask;
+		modes->blueMask   = pVisual[i].blueMask;
+		modes->alphaMask  = modes->alphaMask;
+		modes->rgbBits = (is_rgb)
+		    ? (modes->redBits + modes->greenBits +
+		       modes->blueBits + modes->alphaBits)
+		    : rootDepth;
 	    }
 
 	    /* Save the device-dependent private for this visual */
 	    glXVisualPriv[j] = pNewVisualPriv[k];
 
 	    j++;
+	    modes = modes->next;
 	}
     }
 
@@ -425,7 +426,6 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
 
     /* Save the GLX visuals in the screen structure */
     MESAScreens[screenInfo.numScreens-1].num_vis = numNewVisuals;
-    MESAScreens[screenInfo.numScreens-1].glx_vis = glXVisualPtr;
     MESAScreens[screenInfo.numScreens-1].private = glXVisualPriv;
 
     /* Set up depth's VisualIDs */
@@ -501,27 +501,28 @@ static void fixup_visuals(int screen)
 {
     ScreenPtr pScreen = screenInfo.screens[screen];
     __MESA_screen *pMScr = &MESAScreens[screen];
-    __GLXvisualConfig *pGLXVis  = pMScr->glx_vis;
-    VisualPtr pVis;
-    int i, j;
+    int j;
+    __GLcontextModes *modes;
 
-    for (i = 0; i < pMScr->num_vis; i++, pGLXVis++) {
-	pVis = pScreen->visuals;
+    for ( modes = pMScr->modes ; modes != NULL ; modes = modes->next ) {
+	const int vis_class = _gl_convert_to_x_visual_type( modes->visualType );
+	const int nplanes = (modes->rgbBits - modes->alphaBits);
+	const VisualPtr const pVis = pScreen->visuals;
 
 	/* Find a visual that matches the GLX visual's class and size */
 	for (j = 0; j < pScreen->numVisuals; j++, pVis++) {
-	    if (pVis->class == pGLXVis->class &&
-		pVis->nplanes == (pGLXVis->bufferSize - pGLXVis->alphaSize)) {
+	    if (pVis->class == vis_class &&
+		pVis->nplanes == nplanes) {
 
 		/* Fixup the masks */
-		pGLXVis->redMask   = pVis->redMask;
-		pGLXVis->greenMask = pVis->greenMask;
-		pGLXVis->blueMask  = pVis->blueMask;
+		modes->redMask   = pVis->redMask;
+		modes->greenMask = pVis->greenMask;
+		modes->blueMask  = pVis->blueMask;
 
 		/* Recalc the sizes */
-		pGLXVis->redSize   = count_bits(pGLXVis->redMask);
-		pGLXVis->greenSize = count_bits(pGLXVis->greenMask);
-		pGLXVis->blueSize  = count_bits(pGLXVis->blueMask);
+		modes->redBits   = count_bits(modes->redMask);
+		modes->greenBits = count_bits(modes->greenMask);
+		modes->blueBits  = count_bits(modes->blueMask);
 	    }
 	}
     }
@@ -530,9 +531,8 @@ static void fixup_visuals(int screen)
 static void init_screen_visuals(int screen)
 {
     ScreenPtr pScreen = screenInfo.screens[screen];
-    __GLXvisualConfig *pGLXVis = MESAScreens[screen].glx_vis;
+    __GLcontextModes *modes;
     XMesaVisual *pXMesaVisual;
-    VisualPtr pVis;
     int *used;
     int i, j;
 
@@ -542,49 +542,70 @@ static void init_screen_visuals(int screen)
     __glXMemset(pXMesaVisual, 0,
 		MESAScreens[screen].num_vis * sizeof(XMesaVisual));
 
+    /* FIXME: Change 'used' to be a array of bits (rather than of ints),
+     * FIXME: create a stack array of 8 or 16 bytes.  If 'numVisuals' is less
+     * FIXME: than 64 or 128 the stack array can be used instead of calling
+     * FIXME: __glXMalloc / __glXFree.  If nothing else, convert 'used' to
+     * FIXME: array of bytes instead of ints!
+     */
     used = (int *)__glXMalloc(pScreen->numVisuals * sizeof(int));
     __glXMemset(used, 0, pScreen->numVisuals * sizeof(int));
 
-    for (i = 0; i < MESAScreens[screen].num_vis; i++, pGLXVis++) {
+    i = 0;
+    for ( modes = MESAScreens[screen].modes 
+	  ; modes != NULL
+	  ; modes = modes->next ) {
+	const int vis_class = _gl_convert_to_x_visual_type( modes->visualType );
+	const int nplanes = (modes->rgbBits - modes->alphaBits);
+	const VisualPtr const pVis = pScreen->visuals;
 
-	pVis = pScreen->visuals;
 	for (j = 0; j < pScreen->numVisuals; j++, pVis++) {
-
-	    if (pVis->class == pGLXVis->class &&
-		pVis->nplanes == (pGLXVis->bufferSize - pGLXVis->alphaSize) &&
+	    if (pVis->class     == vis_class &&
+		pVis->nplanes   == nplanes &&
+		pVis->redMask   == modes->redMask &&
+		pVis->greenMask == modes->greenMask &&
+		pVis->blueMask  == modes->blueMask &&
 		!used[j]) {
 
-		if (pVis->redMask   == pGLXVis->redMask &&
-		    pVis->greenMask == pGLXVis->greenMask &&
-		    pVis->blueMask  == pGLXVis->blueMask) {
-
-		    /* Create the XMesa visual */
-		    pXMesaVisual[i] =
-                         XMesaCreateVisual(pScreen,
-					   pVis,
-					   pGLXVis->rgba,
-					   (pGLXVis->alphaSize > 0),
-					   pGLXVis->doubleBuffer,
-					   pGLXVis->stereo,
-					   GL_TRUE, /* ximage_flag */
-					   pGLXVis->depthSize,
-					   pGLXVis->stencilSize,
-					   pGLXVis->accumRedSize,
-					   pGLXVis->accumGreenSize,
-					   pGLXVis->accumBlueSize,
-					   pGLXVis->accumAlphaSize,
-                                           0,  /* numSamples */
-					   pGLXVis->level,
-                                           pGLXVis->visualRating );
-		    /* Set the VisualID */
-		    pGLXVis->vid = pVis->vid;
-
-		    /* Mark this visual used */
-		    used[j] = 1;
-		    break;
-		}
+		/* Create the XMesa visual */
+		pXMesaVisual[i] =
+		    XMesaCreateVisual(pScreen,
+				      pVis,
+				      modes->rgbMode,
+				      (modes->alphaBits > 0),
+				      modes->doubleBufferMode,
+				      modes->stereoMode,
+				      GL_TRUE, /* ximage_flag */
+				      modes->depthBits,
+				      modes->stencilBits,
+				      modes->accumRedBits,
+				      modes->accumGreenBits,
+				      modes->accumBlueBits,
+				      modes->accumAlphaBits,
+				      modes->samples,
+				      modes->level,
+				      modes->visualRating);
+		/* Set the VisualID */
+		modes->visualID = pVis->vid;
+
+		/* Mark this visual used */
+		used[j] = 1;
+		break;
 	    }
 	}
+
+	if ( j == pScreen->numVisuals ) {
+	    ErrorF("No matching visual for __GLcontextMode with "
+		   "visual class = %d (%d), nplanes = %u\n",
+		   vis_class, 
+		   modes->visualType,
+		   (modes->rgbBits - modes->alphaBits) );
+	}
+	else if ( modes->visualID == -1 ) {
+	    FatalError( "Matching visual found, but visualID still -1!\n" );
+	}
+
+	i++;
     }
 
     __glXFree(used);
@@ -597,7 +618,7 @@ Bool __MESA_screenProbe(int screen)
     /*
      * Set up the current screen's visuals.
      */
-    __glDDXScreenInfo.pGlxVisual = MESAScreens[screen].glx_vis;
+    __glDDXScreenInfo.modes = MESAScreens[screen].modes;
     __glDDXScreenInfo.pVisualPriv = MESAScreens[screen].private;
     __glDDXScreenInfo.numVisuals =
 	__glDDXScreenInfo.numUsableVisuals = MESAScreens[screen].num_vis;
@@ -636,15 +657,15 @@ extern void __MESA_resetExtension(void)
 		MESAScreens[i].xm_vis[j] = NULL;
 	  }
 	}
-	__glXFree(MESAScreens[i].glx_vis);
-	MESAScreens[i].glx_vis = NULL;
+	_gl_context_modes_destroy( MESAScreens[i].modes );
+	MESAScreens[i].modes = NULL;
 	__glXFree(MESAScreens[i].private);
 	MESAScreens[i].private = NULL;
 	__glXFree(MESAScreens[i].xm_vis);
 	MESAScreens[i].xm_vis = NULL;
 	MESAScreens[i].num_vis = 0;
     }
-    __glDDXScreenInfo.pGlxVisual = NULL;
+    __glDDXScreenInfo.modes = NULL;
     MESA_CC = NULL;
 }
 
@@ -652,10 +673,14 @@ void __MESA_createBuffer(__GLXdrawablePrivate *glxPriv)
 {
     DrawablePtr pDraw = glxPriv->pDraw;
     XMesaVisual xm_vis = find_mesa_visual(pDraw->pScreen->myNum,
-					  glxPriv->pGlxVisual->vid);
+					  glxPriv->modes->visualID);
     __GLdrawablePrivate *glPriv = &glxPriv->glPriv;
     __MESA_buffer buf;
 
+    if (xm_vis == NULL) {
+	ErrorF("find_mesa_visual returned NULL for visualID = 0x%04x\n",
+	       glxPriv->modes->visualID);
+    }
     buf = (__MESA_buffer)__glXMalloc(sizeof(struct __MESA_bufferRec));
 
     /* Create Mesa's buffers */
@@ -736,12 +761,17 @@ __GLinterface *__MESA_createContext(__GLimports *imports,
     if (shareGC) 
        m_share = (__GLcontext *)shareGC;
 
-    xm_vis = find_mesa_visual(glxc->pScreen->myNum, glxc->pGlxVisual->vid);
+    xm_vis = find_mesa_visual(glxc->pScreen->myNum, glxc->modes->visualID);
     if (xm_vis) {
        XMesaContext xmshare = m_share ? m_share->DriverCtx : 0;
        XMesaContext xmctx = XMesaCreateContext(xm_vis, xmshare);
        gl_ctx = xmctx ? &xmctx->mesa : 0;
     }
+    else {
+	ErrorF("find_mesa_visual returned NULL for visualID = 0x%04x\n",
+	       glxc->modes->visualID);
+    }
+
 
     if (!gl_ctx)
        return NULL;
diff --git a/xc/programs/Xserver/GL/mesa/X/xf86glxint.h b/xc/programs/Xserver/GL/mesa/X/xf86glxint.h
index 47c8e7608..3d7dcec6f 100644
--- a/xc/programs/Xserver/GL/mesa/X/xf86glxint.h
+++ b/xc/programs/Xserver/GL/mesa/X/xf86glxint.h
@@ -39,15 +39,10 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include <GL/gl.h>
 #include <GL/xmesa.h>
 
-/*  struct __GLcontextRec { */
-/*      __GLinterface iface; */
-/*      XMesaContext xm_ctx; */
-/*  }; */
-
 typedef struct __MESA_screenRec __MESA_screen;
 struct __MESA_screenRec {
     int num_vis;
-    __GLXvisualConfig *glx_vis;
+    __GLcontextModes *modes;
     XMesaVisual *xm_vis;
     void **private;
 };