Merge accel_indirect branch to HEAD.

2 files changed, 217 insertions, 754 deletions

diff --git a/GL/mesa/X/xf86glx.c b/GL/mesa/X/xf86glx.c
index 5dd4e7c37..b185a958a 100644
--- a/GL/mesa/X/xf86glx.c
+++ b/GL/mesa/X/xf86glx.c
@@ -37,12 +37,14 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include <dix-config.h>
 #endif
 
+#include <string.h>
 #include <regionstr.h>
 #include <resource.h>
 #include <GL/gl.h>
 #include <GL/glxint.h>
 #include <GL/glxtokens.h>
 #include <scrnintstr.h>
+#include <windowstr.h>
 #include <config.h>
 #include <glxserver.h>
 #include <glxscreens.h>
@@ -50,12 +52,14 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include <glxcontext.h>
 #include <glxext.h>
 #include <glxutil.h>
-#include "xf86glxint.h"
 #include "context.h"
 #include "xmesaP.h"
 #include <GL/xf86glx.h>
 #include "context.h"
 
+#include "glcontextmodes.h"
+#include "os.h"
+
 /*
  * This define is for the glcore.h header file.
  * If you add it here, then make sure you also add it in
@@ -69,489 +73,265 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include <GL/internal/glcore.h>
 #endif
 
-#include "glcontextmodes.h"
+typedef struct __GLXMESAscreen   __GLXMESAscreen;
+typedef struct __GLXMESAcontext  __GLXMESAcontext;
+typedef struct __GLXMESAdrawable __GLXMESAdrawable;
 
-/*
- * This structure is statically allocated in the __glXScreens[]
- * structure.  This struct is not used anywhere other than in
- * __glXScreenInit to initialize each of the active screens
- * (__glXActiveScreens[]).  Several of the fields must be initialized by
- * the screenProbe routine before they are copied to the active screens
- * struct.  In particular, the contextCreate, pGlxVisual, numVisuals,
- * and numUsableVisuals fields must be initialized.
- */
-static __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 modes in probe */
-    NULL,                 /* Set up pVisualPriv in probe */
-    0,                    /* Set up numVisuals in probe */
-    0,                    /* Set up numUsableVisuals in probe */
-    NULL,                 /* GLextensions is overwritten by __glXScreenInit */
-    "Vendor String",      /* GLXvendor is overwritten by __glXScreenInit */
-    "Version String",     /* GLXversion is overwritten by __glXScreenInit */
-    "Extensions String",  /* GLXextensions is overwritten by __glXScreenInit */
-    NULL                  /* WrappedPositionWindow is overwritten */
+struct __GLXMESAscreen {
+    __GLXscreen   base;
+    int           index;
+    XMesaVisual  *xm_vis;
 };
 
-void *__glXglDDXScreenInfo(void) {
-    return &__glDDXScreenInfo;
-}
+struct __GLXMESAcontext {
+    __GLXcontext base;
+    XMesaContext xmesa;
+};
 
-static __GLXextensionInfo __glDDXExtensionInfo = {
-    GL_CORE_MESA,
-    __MESA_resetExtension,
-    __MESA_initVisuals,
-    __MESA_setVisualConfigs
+struct __GLXMESAdrawable {
+    __GLXdrawable base;
+    XMesaBuffer   xm_buf;
 };
 
-void *__glXglDDXExtensionInfo(void) {
-    return &__glDDXExtensionInfo;
-}
+static XMesaVisual find_mesa_visual(__GLXscreen *screen, VisualID vid);
 
-static __MESA_screen  MESAScreens[MAXSCREENS];
-static __GLcontext   *MESA_CC        = NULL;
 
-static int                 numConfigs     = 0;
-static __GLXvisualConfig  *visualConfigs  = NULL;
-static void              **visualPrivates = NULL;
+static void
+__glXMesaDrawableDestroy(__GLXdrawable *base)
+{
+    __GLXMESAdrawable *glxPriv = (__GLXMESAdrawable *) base;
 
+    XMesaDestroyBuffer(glxPriv->xm_buf);
+    xfree(glxPriv);
+}
 
-static int count_bits(unsigned int n)
+static GLboolean
+__glXMesaDrawableResize(__GLXdrawable *base)
 {
-   int bits = 0;
+    __GLXMESAdrawable *glxPriv = (__GLXMESAdrawable *) base;
 
-   while (n > 0) {
-      if (n & 1) bits++;
-      n >>= 1;
-   }
-   return bits;
-}
+    XMesaResizeBuffers(glxPriv->xm_buf);
 
+    return GL_TRUE;
+}
 
-static XMesaVisual find_mesa_visual(int screen, VisualID vid)
+static GLboolean
+__glXMesaDrawableSwapBuffers(__GLXdrawable *base)
 {
-    __MESA_screen * const pMScr = &MESAScreens[screen];
-    const __GLcontextModes *modes;
-    unsigned i = 0;
+    __GLXMESAdrawable *glxPriv = (__GLXMESAdrawable *) base;
 
-    for ( modes = pMScr->modes ; modes != NULL ; modes = modes->next ) {
-	if ( modes->visualID == vid ) {
-	    break;
-	}
+    /* This is terrifying: XMesaSwapBuffers() ends up calling CopyArea
+     * to do the buffer swap, but this assumes that the server holds
+     * the lock and has its context visible.  If another screen uses a
+     * DRI driver, that will have installed the DRI enter/leave server
+     * functions, which lifts the lock during GLX dispatch.  This is
+     * why we need to re-take the lock and swap in the server context
+     * before calling XMesaSwapBuffers() here.  /me shakes head. */
 
-	i++;
-    }
+    __glXenterServer();
 
-    return (modes != NULL) ? pMScr->xm_vis[i] : NULL;
-}
+    XMesaSwapBuffers(glxPriv->xm_buf);
 
+    __glXleaveServer();
 
-/*
- * In the case the driver defines no GLX visuals we'll use these.
- * Note that for TrueColor and DirectColor visuals, bufferSize is the 
- * sum of redSize, greenSize, blueSize and alphaSize, which may be larger 
- * than the nplanes/rootDepth of the server's X11 visuals
- */
-#define NUM_FALLBACK_CONFIGS 5
-static __GLXvisualConfig FallbackConfigs[NUM_FALLBACK_CONFIGS] = {
-  /* [0] = RGB, double buffered, Z */
-  {
-    -1,                 /* vid */
-    -1,                 /* class */
-    True,               /* rgba */
-    -1, -1, -1, 0,      /* rgba sizes */
-    -1, -1, -1, 0,      /* rgba masks */
-     0,  0,  0, 0,      /* rgba accum sizes */
-    True,               /* doubleBuffer */
-    False,              /* stereo */
-    -1,                 /* bufferSize */
-    16,                 /* depthSize */
-    0,                  /* stencilSize */
-    0,                  /* auxBuffers */
-    0,                  /* level */
-    GLX_NONE,           /* visualRating */
-    GLX_NONE,           /* transparentPixel */
-    0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
-    0                   /* transparentIndex */
-  },
-  /* [1] = RGB, double buffered, Z, stencil, accum */
-  {
-    -1,                 /* vid */
-    -1,                 /* class */
-    True,               /* rgba */
-    -1, -1, -1, 0,      /* rgba sizes */
-    -1, -1, -1, 0,      /* rgba masks */
-    16, 16, 16, 0,      /* rgba accum sizes */
-    True,               /* doubleBuffer */
-    False,              /* stereo */
-    -1,                 /* bufferSize */
-    16,                 /* depthSize */
-    8,                  /* stencilSize */
-    0,                  /* auxBuffers */
-    0,                  /* level */
-    GLX_NONE,           /* visualRating */
-    GLX_NONE,           /* transparentPixel */
-    0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
-    0                   /* transparentIndex */
-  },
-  /* [2] = RGB+Alpha, double buffered, Z, stencil, accum */
-  {
-    -1,                 /* vid */
-    -1,                 /* class */
-    True,               /* rgba */
-    -1, -1, -1, 8,      /* rgba sizes */
-    -1, -1, -1, -1,     /* rgba masks */
-    16, 16, 16, 16,     /* rgba accum sizes */
-    True,               /* doubleBuffer */
-    False,              /* stereo */
-    -1,                 /* bufferSize */
-    16,                 /* depthSize */
-    8,                  /* stencilSize */
-    0,                  /* auxBuffers */
-    0,                  /* level */
-    GLX_NONE,           /* visualRating */
-    GLX_NONE,           /* transparentPixel */
-    0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
-    0                   /* transparentIndex */
-  },
-  /* [3] = RGB+Alpha, single buffered, Z, stencil, accum */
-  {
-    -1,                 /* vid */
-    -1,                 /* class */
-    True,               /* rgba */
-    -1, -1, -1, 8,      /* rgba sizes */
-    -1, -1, -1, -1,     /* rgba masks */
-    16, 16, 16, 16,     /* rgba accum sizes */
-    False,              /* doubleBuffer */
-    False,              /* stereo */
-    -1,                 /* bufferSize */
-    16,                 /* depthSize */
-    8,                  /* stencilSize */
-    0,                  /* auxBuffers */
-    0,                  /* level */
-    GLX_NONE,           /* visualRating */
-    GLX_NONE,           /* transparentPixel */
-    0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
-    0                   /* transparentIndex */
-  },
-  /* [4] = CI, double buffered, Z */
-  {
-    -1,                 /* vid */
-    -1,                 /* class */
-    False,              /* rgba? (false = color index) */
-    -1, -1, -1, 0,      /* rgba sizes */
-    -1, -1, -1, 0,      /* rgba masks */
-     0,  0,  0, 0,      /* rgba accum sizes */
-    True,               /* doubleBuffer */
-    False,              /* stereo */
-    -1,                 /* bufferSize */
-    16,                 /* depthSize */
-    0,                  /* stencilSize */
-    0,                  /* auxBuffers */
-    0,                  /* level */
-    GLX_NONE,           /* visualRating */
-    GLX_NONE,           /* transparentPixel */
-    0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
-    0                   /* transparentIndex */
-  },
-};
+    return GL_TRUE;
+}
 
 
-static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
-			 VisualID *defaultVisp,
-			 int ndepth, DepthPtr pdepth,
-			 int rootDepth)
+static __GLXdrawable *
+__glXMesaContextCreateDrawable(__GLXcontext *context,
+			       DrawablePtr pDraw,
+			       XID drawId)
 {
-    int numRGBconfigs;
-    int numCIconfigs;
-    int numVisuals = *nvisualp;
-    int numNewVisuals;
-    int numNewConfigs;
-    VisualPtr pVisual = *visualp;
-    VisualPtr pVisualNew = NULL;
-    VisualID *orig_vid = NULL;
-    __GLcontextModes *modes;
-    __GLXvisualConfig *pNewVisualConfigs = NULL;
-    void **glXVisualPriv;
-    void **pNewVisualPriv;
-    int found_default;
-    int i, j, k;
-
-    if (numConfigs > 0)
-        numNewConfigs = numConfigs;
-    else
-        numNewConfigs = NUM_FALLBACK_CONFIGS;
-
-    /* Alloc space for the list of new GLX visuals */
-    pNewVisualConfigs = (__GLXvisualConfig *)
-                     __glXMalloc(numNewConfigs * sizeof(__GLXvisualConfig));
-    if (!pNewVisualConfigs) {
-	return FALSE;
-    }
+    __GLXMESAdrawable *glxPriv;
+    __GLXscreen *pGlxScreen;
+    XMesaVisual xm_vis;
 
-    /* Alloc space for the list of new GLX visual privates */
-    pNewVisualPriv = (void **) __glXMalloc(numNewConfigs * sizeof(void *));
-    if (!pNewVisualPriv) {
-	__glXFree(pNewVisualConfigs);
-	return FALSE;
-    }
+    glxPriv = xalloc(sizeof *glxPriv);
+    if (glxPriv == NULL)
+	return NULL;
 
-    /*
-    ** If SetVisualConfigs was not called, then use default GLX
-    ** visual configs.
-    */
-    if (numConfigs == 0) {
-	memcpy(pNewVisualConfigs, FallbackConfigs,
-               NUM_FALLBACK_CONFIGS * sizeof(__GLXvisualConfig));
-	memset(pNewVisualPriv, 0, NUM_FALLBACK_CONFIGS * sizeof(void *));
-    }
-    else {
-        /* copy driver's visual config info */
-        for (i = 0; i < numConfigs; i++) {
-            pNewVisualConfigs[i] = visualConfigs[i];
-            pNewVisualPriv[i] = visualPrivates[i];
-        }
-    }
+    memset(glxPriv, 0, sizeof *glxPriv);
 
-    /* Count the number of RGB and CI visual configs */
-    numRGBconfigs = 0;
-    numCIconfigs = 0;
-    for (i = 0; i < numNewConfigs; i++) {
-	if (pNewVisualConfigs[i].rgba)
-	    numRGBconfigs++;
-	else
-	    numCIconfigs++;
+    if (!__glXDrawableInit(&glxPriv->base, context, pDraw, drawId)) {
+        xfree(glxPriv);
+	return NULL;
     }
 
-    /* Count the total number of visuals to compute */
-    numNewVisuals = 0;
-    for (i = 0; i < numVisuals; i++) {
-        numNewVisuals +=
-	    (pVisual[i].class == TrueColor || pVisual[i].class == DirectColor)
-	    ? numRGBconfigs : numCIconfigs;
-    }
+    glxPriv->base.destroy       = __glXMesaDrawableDestroy;
+    glxPriv->base.resize        = __glXMesaDrawableResize;
+    glxPriv->base.swapBuffers   = __glXMesaDrawableSwapBuffers;
 
-    /* Reset variables for use with the next screen/driver's visual configs */
-    visualConfigs = NULL;
-    numConfigs = 0;
+    pGlxScreen = __glXActiveScreens[pDraw->pScreen->myNum];
 
-    /* Alloc temp space for the list of orig VisualIDs for each new visual */
-    orig_vid = (VisualID *)__glXMalloc(numNewVisuals * sizeof(VisualID));
-    if (!orig_vid) {
-	__glXFree(pNewVisualPriv);
-	__glXFree(pNewVisualConfigs);
-	return FALSE;
-    }
+    if (glxPriv->base.type == DRAWABLE_WINDOW) {
+	VisualID vid = wVisual((WindowPtr)pDraw);
 
-    /* Alloc space for the list of glXVisuals */
-    modes = _gl_context_modes_create(numNewVisuals, sizeof(__GLcontextModes));
-    if (modes == NULL) {
-	__glXFree(orig_vid);
-	__glXFree(pNewVisualPriv);
-	__glXFree(pNewVisualConfigs);
-	return FALSE;
+	glxPriv->base.modes = _gl_context_modes_find_visual(pGlxScreen->modes,
+							    vid);
+    } else {
+	glxPriv->base.modes = glxPriv->base.pGlxPixmap->modes;
     }
 
-    /* Alloc space for the list of glXVisualPrivates */
-    glXVisualPriv = (void **)__glXMalloc(numNewVisuals * sizeof(void *));
-    if (!glXVisualPriv) {
-	_gl_context_modes_destroy( modes );
-	__glXFree(orig_vid);
-	__glXFree(pNewVisualPriv);
-	__glXFree(pNewVisualConfigs);
-	return FALSE;
+    xm_vis = find_mesa_visual(pGlxScreen, glxPriv->base.modes->visualID);
+    if (xm_vis == NULL) {
+	ErrorF("find_mesa_visual returned NULL for visualID = 0x%04x\n",
+	       glxPriv->base.modes->visualID);
+	xfree(glxPriv);
+	return NULL;
     }
 
-    /* Alloc space for the new list of the X server's visuals */
-    pVisualNew = (VisualPtr)__glXMalloc(numNewVisuals * sizeof(VisualRec));
-    if (!pVisualNew) {
-	__glXFree(glXVisualPriv);
-	_gl_context_modes_destroy( modes );
-	__glXFree(orig_vid);
-	__glXFree(pNewVisualPriv);
-	__glXFree(pNewVisualConfigs);
-	return FALSE;
+    if (glxPriv->base.type == DRAWABLE_WINDOW) {
+	glxPriv->xm_buf = XMesaCreateWindowBuffer(xm_vis, (WindowPtr)pDraw);
+    } else {
+	glxPriv->xm_buf = XMesaCreatePixmapBuffer(xm_vis, (PixmapPtr)pDraw, 0);
     }
 
-    /* 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);
-
-	for (k = 0; k < numNewConfigs; k++) {
-	    if (pNewVisualConfigs[k].rgba != is_rgb)
-		continue;
-
-	    assert( modes != NULL );
+    return &glxPriv->base;
+}
 
-	    /* Initialize the new visual */
-	    pVisualNew[j] = pVisual[i];
-	    pVisualNew[j].vid = FakeClientID(0);
+static void
+__glXMesaContextDestroy(__GLXcontext *baseContext)
+{
+    __GLXMESAcontext *context = (__GLXMESAcontext *) baseContext;
 
-	    /* Check for the default visual */
-	    if (!found_default && pVisual[i].vid == *defaultVisp) {
-		*defaultVisp = pVisualNew[j].vid;
-		found_default = TRUE;
-	    }
+    XMesaDestroyContext(context->xmesa);
+    xfree(context);
+}
 
-	    /* Save the old VisualID */
-	    orig_vid[j] = pVisual[i].vid;
-
-	    /* Initialize the glXVisual */
-	    _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
-	     * is identical to what GLX needs, and take them from the X
-	     * visual.  NOTE: if class != -1, then all other fields MUST
-	     * be initialized.
-	     */
-	    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;
-	    }
+static int
+__glXMesaContextMakeCurrent(__GLXcontext *baseContext)
 
-	    /* Save the device-dependent private for this visual */
-	    glXVisualPriv[j] = pNewVisualPriv[k];
+{
+    __GLXMESAcontext *context = (__GLXMESAcontext *) baseContext;
+    __GLXMESAdrawable *drawPriv = (__GLXMESAdrawable *) context->base.drawPriv;
+    __GLXMESAdrawable *readPriv = (__GLXMESAdrawable *) context->base.readPriv;
 
-	    j++;
-	    modes = modes->next;
-	}
-    }
+    return XMesaMakeCurrent2(context->xmesa,
+			     drawPriv->xm_buf,
+			     readPriv->xm_buf);
+}
 
-    assert(j <= numNewVisuals);
-
-    /* Save the GLX visuals in the screen structure */
-    MESAScreens[screenInfo.numScreens-1].num_vis = numNewVisuals;
-    MESAScreens[screenInfo.numScreens-1].private = glXVisualPriv;
-
-    /* Set up depth's VisualIDs */
-    for (i = 0; i < ndepth; i++) {
-	int numVids = 0;
-	VisualID *pVids = NULL;
-	int k, n = 0;
-
-	/* Count the new number of VisualIDs at this depth */
-	for (j = 0; j < pdepth[i].numVids; j++)
-	    for (k = 0; k < numNewVisuals; k++)
-		if (pdepth[i].vids[j] == orig_vid[k])
-		    numVids++;
-
-	/* Allocate a new list of VisualIDs for this depth */
-	pVids = (VisualID *)__glXMalloc(numVids * sizeof(VisualID));
-
-	/* Initialize the new list of VisualIDs for this depth */
-	for (j = 0; j < pdepth[i].numVids; j++)
-	    for (k = 0; k < numNewVisuals; k++)
-		if (pdepth[i].vids[j] == orig_vid[k])
-		    pVids[n++] = pVisualNew[k].vid;
-
-	/* Update this depth's list of VisualIDs */
-	__glXFree(pdepth[i].vids);
-	pdepth[i].vids = pVids;
-	pdepth[i].numVids = numVids;
-    }
+static int
+__glXMesaContextLoseCurrent(__GLXcontext *baseContext)
+{
+    __GLXMESAcontext *context = (__GLXMESAcontext *) baseContext;
 
-    /* Update the X server's visuals */
-    *nvisualp = numNewVisuals;
-    *visualp = pVisualNew;
+    return XMesaLoseCurrent(context->xmesa);
+}
 
-    /* Free the old list of the X server's visuals */
-    __glXFree(pVisual);
+static int
+__glXMesaContextCopy(__GLXcontext *baseDst,
+		     __GLXcontext *baseSrc,
+		     unsigned long mask)
+{
+    __GLXMESAcontext *dst = (__GLXMESAcontext *) baseDst;
+    __GLXMESAcontext *src = (__GLXMESAcontext *) baseSrc;
 
-    /* Clean up temporary allocations */
-    __glXFree(orig_vid);
-    __glXFree(pNewVisualPriv);
-    __glXFree(pNewVisualConfigs);
+    _mesa_copy_context(&src->xmesa->mesa, &dst->xmesa->mesa, mask);
+    return GL_TRUE;
+}
 
-    /* Free the private list created by DDX HW driver */
-    if (visualPrivates)
-        xfree(visualPrivates);
-    visualPrivates = NULL;
+static int
+__glXMesaContextForceCurrent(__GLXcontext *baseContext)
+{
+    __GLXMESAcontext *context = (__GLXMESAcontext *) baseContext;
 
-    return TRUE;
+    return XMesaForceCurrent(context->xmesa);
 }
 
-void __MESA_setVisualConfigs(int nconfigs, __GLXvisualConfig *configs,
-			     void **privates)
+static __GLXcontext *
+__glXMesaScreenCreateContext(__GLXscreen *screen,
+			     __GLcontextModes *modes,
+			     __GLXcontext *baseShareContext)
 {
-    numConfigs = nconfigs;
-    visualConfigs = configs;
-    visualPrivates = privates;
+    __GLXMESAcontext *context;
+    __GLXMESAcontext *shareContext = (__GLXMESAcontext *) baseShareContext;
+    XMesaVisual xm_vis;
+    XMesaContext xm_share;
+
+    context = xalloc (sizeof (__GLXMESAcontext));
+    if (context == NULL)
+	return NULL;
+
+    memset(context, 0, sizeof *context);
+
+    context->base.pGlxScreen = screen;
+    context->base.modes      = modes;
+
+    context->base.destroy        = __glXMesaContextDestroy;
+    context->base.makeCurrent    = __glXMesaContextMakeCurrent;
+    context->base.loseCurrent    = __glXMesaContextLoseCurrent;
+    context->base.copy           = __glXMesaContextCopy;
+    context->base.forceCurrent   = __glXMesaContextForceCurrent;
+    context->base.createDrawable = __glXMesaContextCreateDrawable;
+
+    xm_vis = find_mesa_visual(screen, modes->visualID);
+    if (!xm_vis) {
+	ErrorF("find_mesa_visual returned NULL for visualID = 0x%04x\n",
+	       modes->visualID);
+	xfree(context);
+	return NULL;
+    }
+
+    xm_share = shareContext ? shareContext->xmesa : NULL;
+    context->xmesa = XMesaCreateContext(xm_vis, xm_share);
+    if (!context->xmesa) {
+	xfree(context);
+	return NULL;
+    }
+
+    return &context->base;
 }
 
-Bool __MESA_initVisuals(VisualPtr *visualp, DepthPtr *depthp,
-			int *nvisualp, int *ndepthp, int *rootDepthp,
-			VisualID *defaultVisp, unsigned long sizes,
-			int bitsPerRGB)
+static void
+__glXMesaScreenDestroy(__GLXscreen *screen)
 {
-    /*
-     * Setup the visuals supported by this particular screen.
-     */
-    return init_visuals(nvisualp, visualp, defaultVisp,
-			*ndepthp, *depthp, *rootDepthp);
+    __GLXMESAscreen *mesaScreen = (__GLXMESAscreen *) screen;
+    int i;
+
+    for (i = 0; i < screen->numVisuals; i++) {
+	if (mesaScreen->xm_vis[i])
+	    XMesaDestroyVisual(mesaScreen->xm_vis[i]);
+    }
+
+    xfree(mesaScreen->xm_vis);
+
+    __glXScreenDestroy(screen);
+
+    xfree(screen);
 }
 
-static void fixup_visuals(int screen)
+static XMesaVisual
+find_mesa_visual(__GLXscreen *screen, VisualID vid)
 {
-    ScreenPtr pScreen = screenInfo.screens[screen];
-    __MESA_screen *pMScr = &MESAScreens[screen];
-    int j;
-    __GLcontextModes *modes;
-
-    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 pVis = pScreen->visuals;
+    __GLXMESAscreen *mesaScreen = (__GLXMESAscreen *) screen;
+    const __GLcontextModes *modes;
+    unsigned i = 0;
 
-	/* Find a visual that matches the GLX visual's class and size */
-	for (j = 0; j < pScreen->numVisuals; j++) {
-	    if (pVis[j].class == vis_class &&
-		pVis[j].nplanes == nplanes) {
-
-		/* Fixup the masks */
-		modes->redMask   = pVis[j].redMask;
-		modes->greenMask = pVis[j].greenMask;
-		modes->blueMask  = pVis[j].blueMask;
-
-		/* Recalc the sizes */
-		modes->redBits   = count_bits(modes->redMask);
-		modes->greenBits = count_bits(modes->greenMask);
-		modes->blueBits  = count_bits(modes->blueMask);
-	    }
+    for ( modes = screen->modes ; modes != NULL ; modes = modes->next ) {
+	if ( modes->visualID == vid ) {
+	    break;
 	}
+
+	i++;
     }
+
+    return (modes != NULL) ? mesaScreen->xm_vis[i] : NULL;
 }
 
-static void init_screen_visuals(int screen)
+static void init_screen_visuals(__GLXMESAscreen *screen)
 {
-    ScreenPtr pScreen = screenInfo.screens[screen];
+    ScreenPtr pScreen = screen->base.pScreen;
     __GLcontextModes *modes;
     XMesaVisual *pXMesaVisual;
     int *used;
-    int i, j;
+    int i, j, size;
 
     /* Alloc space for the list of XMesa visuals */
-    pXMesaVisual = (XMesaVisual *)__glXMalloc(MESAScreens[screen].num_vis *
-					      sizeof(XMesaVisual));
-    __glXMemset(pXMesaVisual, 0,
-		MESAScreens[screen].num_vis * sizeof(XMesaVisual));
+    size = screen->base.numVisuals * sizeof(XMesaVisual);
+    pXMesaVisual = (XMesaVisual *) xalloc(size);
+    memset(pXMesaVisual, 0, size);
 
     /* 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
@@ -559,13 +339,11 @@ static void init_screen_visuals(int screen)
      * 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));
+    used = (int *) xalloc(pScreen->numVisuals * sizeof(int));
+    memset(used, 0, pScreen->numVisuals * sizeof(int));
 
     i = 0;
-    for ( modes = MESAScreens[screen].modes 
-	  ; modes != NULL
-	  ; modes = modes->next ) {
+    for ( modes = screen->base.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 pVis = pScreen->visuals;
@@ -621,30 +399,23 @@ static void init_screen_visuals(int screen)
 
     __glXFree(used);
 
-    MESAScreens[screen].xm_vis = pXMesaVisual;
+    screen->xm_vis = pXMesaVisual;
 }
 
-Bool __MESA_screenProbe(int screen)
+static __GLXscreen *
+__glXMesaScreenProbe(ScreenPtr pScreen)
 {
-    /*
-     * Set up the current screen's visuals.
-     */
-    __glDDXScreenInfo.modes = MESAScreens[screen].modes;
-    __glDDXScreenInfo.pVisualPriv = MESAScreens[screen].private;
-    __glDDXScreenInfo.numVisuals =
-	__glDDXScreenInfo.numUsableVisuals = MESAScreens[screen].num_vis;
+    __GLXMESAscreen *screen;
 
-    /*
-     * Set the current screen's createContext routine.  This could be
-     * wrapped by a DDX GLX context creation routine.
-     */
-    __glDDXScreenInfo.createContext = __MESA_createContext;
+    screen = xalloc(sizeof *screen);
+    if (screen == NULL)
+	return NULL;
 
-    /*
-     * The ordering of the rgb compenents might have been changed by the
-     * driver after mi initialized them.
-     */
-    fixup_visuals(screen);
+    __glXScreenInit(&screen->base, pScreen);
+
+    screen->base.destroy       = __glXMesaScreenDestroy;
+    screen->base.createContext = __glXMesaScreenCreateContext;
+    screen->base.pScreen       = pScreen;
 
     /*
      * Find the GLX visuals that are supported by this screen and create
@@ -652,263 +423,11 @@ Bool __MESA_screenProbe(int screen)
      */
     init_screen_visuals(screen);
 
-    return TRUE;
-}
-
-extern void __MESA_resetExtension(void)
-{
-    int i, j;
-
-    XMesaReset();
-
-    for (i = 0; i < screenInfo.numScreens; i++) {
-	for (j = 0; j < MESAScreens[i].num_vis; j++) {
-	  if (MESAScreens[i].xm_vis[j]) {
-	        XMesaDestroyVisual(MESAScreens[i].xm_vis[j]);
-		MESAScreens[i].xm_vis[j] = 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.modes = NULL;
-    MESA_CC = NULL;
-}
-
-void __MESA_createBuffer(__GLXdrawablePrivate *glxPriv)
-{
-    DrawablePtr pDraw = glxPriv->pDraw;
-    XMesaVisual xm_vis = find_mesa_visual(pDraw->pScreen->myNum,
-					  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 */
-    if (glxPriv->type == DRAWABLE_WINDOW) {
-	buf->xm_buf = (void *)XMesaCreateWindowBuffer(xm_vis,
-						      (WindowPtr)pDraw);
-    } else {
-	buf->xm_buf = (void *)XMesaCreatePixmapBuffer(xm_vis,
-						      (PixmapPtr)pDraw, 0);
-    }
-
-    /* Wrap the front buffer's resize routine */
-    buf->fbresize = glPriv->frontBuffer.resize;
-    glPriv->frontBuffer.resize = __MESA_resizeBuffers;
-
-    /* Wrap the swap buffers routine */
-    buf->fbswap = glxPriv->swapBuffers;
-    glxPriv->swapBuffers = __MESA_swapBuffers;
-
-    /* Save Mesa's private buffer structure */
-    glPriv->private = (void *)buf;
-    glPriv->freePrivate = __MESA_destroyBuffer;
-}
-
-GLboolean __MESA_resizeBuffers(__GLdrawableBuffer *buffer,
-			       GLint x, GLint y,
-			       GLuint width, GLuint height, 
-			       __GLdrawablePrivate *glPriv,
-			       GLuint bufferMask)
-{
-    __MESA_buffer buf = (__MESA_buffer)glPriv->private;
-
-    if (buf->xm_buf)
-	XMesaResizeBuffers(buf->xm_buf);
-
-    return (*buf->fbresize)(buffer, x, y, width, height, glPriv, bufferMask);
-}
-
-GLboolean __MESA_swapBuffers(__GLXdrawablePrivate *glxPriv)
-{
-    __MESA_buffer buf = (__MESA_buffer)glxPriv->glPriv.private;
-
-    /*
-    ** Do not call the wrapped swap buffers routine since Mesa has
-    ** already done the swap.
-    */
-    XMesaSwapBuffers(buf->xm_buf);
-
-    return GL_TRUE;
-}
-
-void __MESA_destroyBuffer(__GLdrawablePrivate *glPriv)
-{
-    __MESA_buffer buf = (__MESA_buffer)glPriv->private;
-    __GLXdrawablePrivate *glxPriv = (__GLXdrawablePrivate *)glPriv->other;
-
-    /* Destroy Mesa's buffers */
-    if (buf->xm_buf)
-	XMesaDestroyBuffer(buf->xm_buf);
-
-    /* Unwrap these routines */
-    glxPriv->swapBuffers = buf->fbswap;
-    glPriv->frontBuffer.resize = buf->fbresize;
-
-    __glXFree(glPriv->private);
-    glPriv->private = NULL;
-}
-
-__GLinterface *__MESA_createContext(__GLimports *imports,
-				    __GLcontextModes *modes,
-				    __GLinterface *shareGC)
-{
-    __GLcontext *gl_ctx = NULL;
-    __GLcontext *m_share = NULL;
-    __GLXcontext *glxc = (__GLXcontext *)imports->other;
-    XMesaVisual xm_vis;
-
-    if (shareGC) 
-       m_share = (__GLcontext *)shareGC;
-
-    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;
-	
-    gl_ctx->imports = *imports;
-    gl_ctx->exports.destroyContext = __MESA_destroyContext;
-    gl_ctx->exports.loseCurrent = __MESA_loseCurrent;
-    gl_ctx->exports.makeCurrent = __MESA_makeCurrent;
-    gl_ctx->exports.shareContext = __MESA_shareContext;
-    gl_ctx->exports.copyContext = __MESA_copyContext;
-    gl_ctx->exports.forceCurrent = __MESA_forceCurrent;
-    gl_ctx->exports.notifyResize = __MESA_notifyResize;
-    gl_ctx->exports.notifyDestroy = __MESA_notifyDestroy;
-    gl_ctx->exports.notifySwapBuffers = __MESA_notifySwapBuffers;
-    gl_ctx->exports.dispatchExec = __MESA_dispatchExec;
-    gl_ctx->exports.beginDispatchOverride = __MESA_beginDispatchOverride;
-    gl_ctx->exports.endDispatchOverride = __MESA_endDispatchOverride;
-
-    return (__GLinterface *)gl_ctx;
-}
-
-GLboolean __MESA_destroyContext(__GLcontext *gc)
-{
-    XMesaContext xmesa = (XMesaContext) gc->DriverCtx;
-    XMesaDestroyContext( xmesa );
-    return GL_TRUE;
-}
-
-GLboolean __MESA_loseCurrent(__GLcontext *gc)
-{
-    XMesaContext xmesa = (XMesaContext) gc->DriverCtx;
-    MESA_CC = NULL;
-    __glXLastContext = NULL;
-    return XMesaLoseCurrent(xmesa);
-}
-
-GLboolean __MESA_makeCurrent(__GLcontext *gc)
-{
-    __GLdrawablePrivate *drawPriv = gc->imports.getDrawablePrivate( gc );
-    __MESA_buffer drawBuf = (__MESA_buffer)drawPriv->private;
-    __GLdrawablePrivate *readPriv = gc->imports.getReadablePrivate( gc );
-    __MESA_buffer readBuf = (__MESA_buffer)readPriv->private;
-    XMesaContext xmesa = (XMesaContext) gc->DriverCtx;
-
-    MESA_CC = gc;
-    return XMesaMakeCurrent2(xmesa, drawBuf->xm_buf, readBuf->xm_buf);
-}
-
-GLboolean __MESA_shareContext(__GLcontext *gc, __GLcontext *gcShare)
-{
-    /* NOT_DONE */
-    /* XXX I don't see where/how this could ever be called */
-    ErrorF("__MESA_shareContext\n");
-    return GL_FALSE;
-}
-
-GLboolean __MESA_copyContext(__GLcontext *dst, const __GLcontext *src,
-			     GLuint mask)
-{
-    XMesaContext xm_dst = (XMesaContext) dst->DriverCtx;
-    const XMesaContext xm_src = (const XMesaContext) src->DriverCtx;
-    _mesa_copy_context(&xm_src->mesa, &xm_dst->mesa, mask);
-    return GL_TRUE;
-}
-
-GLboolean __MESA_forceCurrent(__GLcontext *gc)
-{
-    XMesaContext xmesa = (XMesaContext) gc->DriverCtx;
-    MESA_CC = gc;
-    return XMesaForceCurrent(xmesa);
-}
-
-GLboolean __MESA_notifyResize(__GLcontext *gc)
-{
-    /* NOT_DONE */
-    ErrorF("__MESA_notifyResize\n");
-    return GL_FALSE;
-}
-
-void __MESA_notifyDestroy(__GLcontext *gc)
-{
-    /* NOT_DONE */
-    ErrorF("__MESA_notifyDestroy\n");
-    return;
-}
-
-void __MESA_notifySwapBuffers(__GLcontext *gc)
-{
-    _mesa_notifySwapBuffers(gc);
-}
-
-struct __GLdispatchStateRec *__MESA_dispatchExec(__GLcontext *gc)
-{
-    /* NOT_DONE */
-    ErrorF("__MESA_dispatchExec\n");
-    return NULL;
-}
-
-void __MESA_beginDispatchOverride(__GLcontext *gc)
-{
-    /* NOT_DONE */
-    ErrorF("__MESA_beginDispatchOverride\n");
-    return;
-}
-
-void __MESA_endDispatchOverride(__GLcontext *gc)
-{
-    /* NOT_DONE */
-    ErrorF("__MESA_endDispatchOverride\n");
-    return;
-}
-
-
-/*
- * Server-side GLX uses these functions which are normally defined
- * in the OpenGL SI.
- */
-
-GLuint __glFloorLog2(GLuint val)
-{
-    int c = 0;
-
-    while (val > 1) {
-	c++;
-	val >>= 1;
-    }
-    return c;
+    return &screen->base;
 }
 
+__GLXprovider __glXMesaProvider = {
+    __glXMesaScreenProbe,
+    "MESA",
+    NULL
+};
diff --git a/GL/mesa/X/xf86glxint.h b/GL/mesa/X/xf86glxint.h
index 974ff0364..4e51215bc 100644
--- a/GL/mesa/X/xf86glxint.h
+++ b/GL/mesa/X/xf86glxint.h
@@ -43,60 +43,4 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include <GL/gl.h>
 #include <GL/xmesa.h>
 
-typedef struct __MESA_screenRec __MESA_screen;
-struct __MESA_screenRec {
-    int num_vis;
-    __GLcontextModes *modes;
-    XMesaVisual *xm_vis;
-    void **private;
-};
-
-typedef struct __MESA_bufferRec *__MESA_buffer;
-struct __MESA_bufferRec {
-    XMesaBuffer xm_buf;
-    GLboolean (*fbresize)(__GLdrawableBuffer *buf,
-			  GLint x, GLint y, GLuint width, GLuint height, 
-			  __GLdrawablePrivate *glPriv, GLuint bufferMask);
-    GLboolean (*fbswap)(__GLXdrawablePrivate *glxPriv);
-};
-
-extern void __MESA_setVisualConfigs(int nconfigs, __GLXvisualConfig *configs,
-				    void **privates);
-extern Bool __MESA_initVisuals(VisualPtr *visualp, DepthPtr *depthp,
-			       int *nvisualp, int *ndepthp, int *rootDepthp,
-			       VisualID *defaultVisp, unsigned long sizes,
-			       int bitsPerRGB);
-extern Bool __MESA_screenProbe(int screen);
-
-extern void __MESA_resetExtension(void);
-
-extern void __MESA_createBuffer(__GLXdrawablePrivate *glxPriv);
-extern GLboolean __MESA_resizeBuffers(__GLdrawableBuffer *buf,
-				      GLint x, GLint y,
-				      GLuint width, GLuint height, 
-				      __GLdrawablePrivate *glPriv,
-				      GLuint bufferMask);
-extern GLboolean __MESA_swapBuffers(__GLXdrawablePrivate *glxPriv);
-extern void __MESA_destroyBuffer(__GLdrawablePrivate *glPriv);
-
-extern __GLinterface *__MESA_createContext(__GLimports *imports,
-					   __GLcontextModes *modes,
-					   __GLinterface *shareGC);
-extern GLboolean __MESA_destroyContext(__GLcontext *gc);
-extern GLboolean __MESA_loseCurrent(__GLcontext *gc);
-extern GLboolean __MESA_makeCurrent(__GLcontext *gc);
-extern GLboolean __MESA_shareContext(__GLcontext *gc, __GLcontext *gcShare);
-extern GLboolean __MESA_copyContext(__GLcontext *dst, const __GLcontext *src,
-				GLuint mask);
-extern GLboolean __MESA_forceCurrent(__GLcontext *gc);
-
-extern GLboolean __MESA_notifyResize(__GLcontext *gc);
-extern void __MESA_notifyDestroy(__GLcontext *gc);
-extern void __MESA_notifySwapBuffers(__GLcontext *gc);
-extern struct __GLdispatchStateRec *__MESA_dispatchExec(__GLcontext *gc);
-extern void __MESA_beginDispatchOverride(__GLcontext *gc);
-extern void __MESA_endDispatchOverride(__GLcontext *gc);
-
-extern GLuint __glFloorLog2(GLuint val);
-
 #endif /* _XF86GLXINT_H_ */