Attachment 3727 Details for Bug 4988 – accelerated indirect rendering patch

[patch] accelerated indirect rendering patch

air.patch (text/plain), 110.86 KB, created by Kristian Høgsberg on 2005-11-07 20:48:37 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Kristian Høgsberg

Created: 2005-11-07 20:48:37 UTC

Size: 110.86 KB

patch

obsolete

>--- /dev/null	2005-11-03 11:11:37.448403000 -0500
>+++ programs/Xserver/GL/glx/glxvisuals.c	2005-11-06 11:17:06.000000000 -0500
>@@ -0,0 +1,519 @@
>+/*
>+ * Copyright Â© 2005  Red Hat, Inc.
>+ * (C) Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
>+ * All Rights Reserved.
>+ * 
>+ * Permission is hereby granted, free of charge, to any person obtaining a
>+ * copy of this software and associated documentation files (the "Software"),
>+ * to deal in the Software without restriction, including without limitation
>+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
>+ * and/or sell copies of the Software, and to permit persons to whom the
>+ * Software is furnished to do so, subject to the following conditions:
>+ * 
>+ * The above copyright notice and this permission notice (including the next
>+ * paragraph) shall be included in all copies or substantial portions of the
>+ * Software.
>+ * 
>+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
>+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
>+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
>+ * RED HAT, INC, OR PRECISION INSIGHT AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY
>+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
>+ * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
>+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
>+ */
>+
>+/*
>+ * Authors:
>+ *   Kevin E. Martin <kevin@precisioninsight.com>
>+ *   Brian Paul <brian@precisioninsight.com>
>+ *   Kristian HÃ¸gsberg <krh@redhat.com>
>+ *
>+ */
>+
>+#ifdef HAVE_DIX_CONFIG_H
>+#include <dix-config.h>
>+#endif
>+
>+#include <regionstr.h>
>+#include <resource.h>
>+#include <GL/gl.h>
>+#include <GL/glxint.h>
>+#include <GL/glxtokens.h>
>+#include <GL/internal/glcore.h>
>+#include <scrnintstr.h>
>+#include <config.h>
>+#include <glxserver.h>
>+#include <glxscreens.h>
>+#include <glxdrawable.h>
>+#include <glxvisuals.h>
>+#include <glxcontext.h>
>+#include <glxext.h>
>+#include <glxutil.h>
>+#include <micmap.h>
>+
>+void GlxWrapInitVisuals(miInitVisualsProcPtr *);
>+
>+#include "glcontextmodes.h"
>+
>+struct ScreenVisualsRec {
>+    int num_vis;
>+    void *private;
>+    __GLcontextModes *modes;
>+};
>+typedef struct ScreenVisualsRec ScreenVisuals;
>+
>+static ScreenVisuals screenVisuals[MAXSCREENS];
>+
>+static int                 numConfigs     = 0;
>+static __GLXvisualConfig  *visualConfigs  = NULL;
>+static void              **visualPrivates = NULL;
>+
>+static int count_bits(unsigned int n)
>+{
>+   int bits = 0;
>+
>+   while (n > 0) {
>+      if (n & 1) bits++;
>+      n >>= 1;
>+   }
>+   return bits;
>+}
>+
>+/*
>+ * 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 */
>+  },
>+};
>+
>+
>+static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
>+			 VisualID *defaultVisp,
>+			 int ndepth, DepthPtr pdepth,
>+			 int rootDepth)
>+{
>+    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;
>+    }
>+
>+    /* Alloc space for the list of new GLX visual privates */
>+    pNewVisualPriv = (void **) __glXMalloc(numNewConfigs * sizeof(void *));
>+    if (!pNewVisualPriv) {
>+	__glXFree(pNewVisualConfigs);
>+	return FALSE;
>+    }
>+
>+    /*
>+    ** 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];
>+        }
>+    }
>+
>+    /* 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++;
>+    }
>+
>+    /* 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;
>+    }
>+
>+    /* Reset variables for use with the next screen/driver's visual configs */
>+    visualConfigs = NULL;
>+    numConfigs = 0;
>+
>+    /* 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;
>+    }
>+
>+    /* 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;
>+    }
>+
>+    /* 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;
>+    }
>+
>+    /* 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;
>+    }
>+
>+    /* Initialize the new visuals */
>+    found_default = FALSE;
>+    screenVisuals[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 );
>+
>+	    /* Initialize the new visual */
>+	    pVisualNew[j] = pVisual[i];
>+	    pVisualNew[j].vid = FakeClientID(0);
>+
>+	    /* Check for the default visual */
>+	    if (!found_default && pVisual[i].vid == *defaultVisp) {
>+		*defaultVisp = pVisualNew[j].vid;
>+		found_default = TRUE;
>+	    }
>+
>+	    /* 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 (modes->fbconfigID == GLX_DONT_CARE)
>+		modes->fbconfigID = modes->visualID;
>+
>+	    /*
>+	     * 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;
>+	    }
>+
>+	    /* Save the device-dependent private for this visual */
>+	    glXVisualPriv[j] = pNewVisualPriv[k];
>+
>+	    j++;
>+	    modes = modes->next;
>+	}
>+    }
>+
>+    assert(j <= numNewVisuals);
>+
>+    /* Save the GLX visuals in the screen structure */
>+    screenVisuals[screenInfo.numScreens-1].num_vis = numNewVisuals;
>+    screenVisuals[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;
>+    }
>+
>+    /* Update the X server's visuals */
>+    *nvisualp = numNewVisuals;
>+    *visualp = pVisualNew;
>+
>+    /* Free the old list of the X server's visuals */
>+    __glXFree(pVisual);
>+
>+    /* Clean up temporary allocations */
>+    __glXFree(orig_vid);
>+    __glXFree(pNewVisualPriv);
>+    __glXFree(pNewVisualConfigs);
>+
>+    /* Free the private list created by DDX HW driver */
>+    if (visualPrivates)
>+        xfree(visualPrivates);
>+    visualPrivates = NULL;
>+
>+    return TRUE;
>+}
>+
>+void GlxSetVisualConfigs(int nconfigs, 
>+                         __GLXvisualConfig *configs, void **privates)
>+{
>+    numConfigs = nconfigs;
>+    visualConfigs = configs;
>+    visualPrivates = privates;
>+}
>+
>+static miInitVisualsProcPtr saveInitVisualsProc;
>+
>+static Bool __glXInitVisuals(VisualPtr *visualp, DepthPtr *depthp,
>+			     int *nvisualp, int *ndepthp,
>+			     int *rootDepthp, VisualID *defaultVisp,
>+			     unsigned long sizes, int bitsPerRGB,
>+			     int preferredVis)
>+{
>+    Bool ret;
>+
>+    if (saveInitVisualsProc) {
>+        ret = saveInitVisualsProc(visualp, depthp, nvisualp, ndepthp,
>+                                  rootDepthp, defaultVisp, sizes, bitsPerRGB,
>+                                  preferredVis);
>+        if (!ret)
>+            return False;
>+    }
>+
>+    /*
>+     * Setup the visuals supported by this particular screen.
>+     */
>+    return init_visuals(nvisualp, visualp, defaultVisp,
>+			*ndepthp, *depthp, *rootDepthp);
>+}
>+
>+void
>+GlxWrapInitVisuals(miInitVisualsProcPtr *initVisProc)
>+{
>+    saveInitVisualsProc = *initVisProc;
>+    *initVisProc = __glXInitVisuals;
>+}
>+
>+static void fixup_visuals(int screen)
>+{
>+    ScreenPtr pScreen = screenInfo.screens[screen];
>+    ScreenVisuals *psv = &screenVisuals[screen];
>+    int j;
>+    __GLcontextModes *modes;
>+
>+    for ( modes = psv->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;
>+
>+	/* 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);
>+	    }
>+	}
>+    }
>+}
>+
>+void __glXVisualsInitScreen(__GLXscreenInfo *info, int screen)
>+{
>+    info->modes = screenVisuals[screen].modes;
>+    info->pVisualPriv = screenVisuals[screen].private;
>+    info->numVisuals = screenVisuals[screen].num_vis;
>+    info->numUsableVisuals = screenVisuals[screen].num_vis;
>+    fixup_visuals(screen);
>+
>+    return TRUE;
>+}
>+
>+
>+void __glXVisualsReset(void)
>+{
>+    int i, j;
>+
>+    for (i = 0; i < screenInfo.numScreens; i++) {
>+	_gl_context_modes_destroy(screenVisuals[i].modes );
>+	screenVisuals[i].modes = NULL;
>+	__glXFree(screenVisuals[i].private);
>+	screenVisuals[i].private = NULL;
>+	screenVisuals[i].num_vis = 0;
>+    }
>+}
>--- /dev/null	2005-11-03 11:11:37.448403000 -0500
>+++ programs/Xserver/GL/glx/glxvisuals.h	2005-11-06 08:22:42.000000000 -0500
>@@ -0,0 +1,33 @@
>+/*
>+ * Copyright Â© 2005  Red Hat, Inc.
>+ * All Rights Reserved.
>+ * 
>+ * Permission is hereby granted, free of charge, to any person obtaining a
>+ * copy of this software and associated documentation files (the "Software"),
>+ * to deal in the Software without restriction, including without limitation
>+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
>+ * and/or sell copies of the Software, and to permit persons to whom the
>+ * Software is furnished to do so, subject to the following conditions:
>+ * 
>+ * The above copyright notice and this permission notice (including the next
>+ * paragraph) shall be included in all copies or substantial portions of the
>+ * Software.
>+ * 
>+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
>+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
>+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
>+ * RED HAT, INC, AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
>+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
>+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
>+ * DEALINGS IN THE SOFTWARE.
>+ */
>+
>+#ifndef __GLX_VISUALS_H__
>+#define __GLX_VISUALS_H__
>+
>+void __glXVisualsInitScreen(__GLXscreenInfo *info, int screen);
>+
>+void GlxSetVisualConfigs(int nconfigs, 
>+                         __GLXvisualConfig *configs, void **privates);
>+
>+#endif /* __GLX_VISUALS_H__ */
>--- /dev/null	2005-11-03 11:11:37.448403000 -0500
>+++ programs/Xserver/GL/glx/glxloader.c	2005-11-06 11:40:38.000000000 -0500
>@@ -0,0 +1,791 @@
>+/*
>+ * Copyright Â© 2005  Red Hat, Inc.
>+ * (C) Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
>+ * All Rights Reserved.
>+ * 
>+ * Permission is hereby granted, free of charge, to any person obtaining a
>+ * copy of this software and associated documentation files (the "Software"),
>+ * to deal in the Software without restriction, including without limitation
>+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
>+ * and/or sell copies of the Software, and to permit persons to whom the
>+ * Software is furnished to do so, subject to the following conditions:
>+ * 
>+ * The above copyright notice and this permission notice (including the next
>+ * paragraph) shall be included in all copies or substantial portions of the
>+ * Software.
>+ * 
>+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
>+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
>+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
>+ * RED HAT, INC, OR PRECISION INSIGHT AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY
>+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
>+ * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
>+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
>+ */
>+
>+/*
>+ * Authors:
>+ *   Kevin E. Martin <kevin@precisioninsight.com>
>+ *   Brian Paul <brian@precisioninsight.com>
>+ *   Kristian HÃ¸gsberg <krh@redhat.com>
>+ *
>+ */
>+
>+#ifdef HAVE_DIX_CONFIG_H
>+#include <dix-config.h>
>+#endif
>+
>+#include <windowstr.h>
>+#include <os.h>
>+
>+#include <dlfcn.h>
>+#include <stdarg.h>
>+#include <stdint.h>
>+
>+#include <GL/gl.h>
>+#include <GL/internal/dri_interface.h>
>+
>+#include <drm_sarea.h>
>+#include <xf86drm.h>
>+#include <xf86str.h>
>+#include <xf86.h>
>+#define _XF86DRI_SERVER_
>+#include "../dri/xf86dristr.h"
>+#include "../dri/dri.h"
>+
>+#define DRI_NEW_INTERFACE_ONLY
>+#include "glxserver.h"
>+#include "glxutil.h"
>+#include "glxloader.h"
>+#include "glcontextmodes.h"
>+
>+#ifndef DEFAULT_DRIVER_DIR
>+/* this is normally defined in the Imakefile */
>+#define DEFAULT_DRIVER_DIR "/usr/X11R6/lib/modules/dri"
>+#endif
>+
>+/*
>+** We keep a linked list of these structures, one per DRI device driver.
>+*/
>+
>+/* Not sure if the DRIdriver struct is really necessary...  We could
>+ * just dlopen() the driver for every screen.  This won't cause the
>+ * library to be loaded again, and the libraries are ref-counted so
>+ * dlclose()'ing the driver for one screen won't close it for
>+ * another. /KRH */
>+
>+struct __DRIdriverRec {
>+   const char *name;
>+   void *handle;
>+   PFNCREATENEWSCREENFUNC createNewScreenFunc;
>+   struct __DRIdriverRec *next;
>+};
>+
>+static __DRIdriver *Drivers = NULL;
>+
>+
>+
>+/**
>+ * Extract the ith directory path out of a colon-separated list of paths.  No
>+ * more than \c dirLen characters, including the terminating \c NUL, will be
>+ * written to \c dir.
>+ *
>+ * \param index  Index of path to extract (starting at zero)
>+ * \param paths  The colon-separated list of paths
>+ * \param dirLen Maximum length of result to store in \c dir
>+ * \param dir    Buffer to hold the extracted directory path
>+ *
>+ * \returns
>+ * The number of characters that would have been written to \c dir had there
>+ * been enough room.  This does not include the terminating \c NUL.  When
>+ * extraction fails, zero will be returned.
>+ * 
>+ * \todo
>+ * It seems like this function could be rewritten to use \c strchr.
>+ */
>+static size_t
>+ExtractDir(int index, const char *paths, int dirLen, char *dir)
>+{
>+   int i, len;
>+   const char *start, *end;
>+
>+   /* find ith colon */
>+   start = paths;
>+   i = 0;
>+   while (i < index) {
>+      if (*start == ':') {
>+         i++;
>+         start++;
>+      }
>+      else if (*start == 0) {
>+         /* end of string and couldn't find ith colon */
>+         dir[0] = 0;
>+         return 0;
>+      }
>+      else {
>+         start++;
>+      }
>+   }
>+
>+   while (*start == ':')
>+      start++;
>+
>+   /* find next colon, or end of string */
>+   end = start + 1;
>+   while (*end != ':' && *end != 0) {
>+      end++;
>+   }
>+
>+   /* copy string between <start> and <end> into result string */
>+   len = end - start;
>+   if (len > dirLen - 1)
>+      len = dirLen - 1;
>+   strncpy(dir, start, len);
>+   dir[len] = 0;
>+
>+   return( end - start );
>+}
>+
>+
>+/**
>+ * Versioned name of the expected \c __driCreateNewScreen function.
>+ * 
>+ * The version of the last incompatible loader/driver inteface change is
>+ * appended to the name of the \c __driCreateNewScreen function.  This
>+ * prevents loaders from trying to load drivers that are too old.
>+ * 
>+ * \todo
>+ * Create a macro or something so that this is automatically updated.
>+ */
>+static const char createNewScreenName[] = "__driCreateNewScreen_20050727";
>+
>+
>+/**
>+ * Try to \c dlopen the named driver.
>+ *
>+ * This function adds the "_dri.so" suffix to the driver name and searches the
>+ * directories specified by the \c LIBGL_DRIVERS_PATH environment variable in
>+ * order to find the driver.
>+ *
>+ * \param driverName - a name like "tdfx", "i810", "mga", etc.
>+ *
>+ * \returns
>+ * A handle from \c dlopen, or \c NULL if driver file not found.
>+ */
>+static __DRIdriver *OpenDriver(const char *driverName, ScreenPtr pScreen)
>+{
>+   char *libPaths = NULL;
>+   char libDir[1000];
>+   int i;
>+   __DRIdriver *driver;
>+
>+   /* First, search Drivers list to see if we've already opened this driver */
>+   for (driver = Drivers; driver; driver = driver->next) {
>+      if (strcmp(driver->name, driverName) == 0) {
>+         /* found it */
>+         return driver;
>+      }
>+   }
>+
>+   /* We probably want to control this similar to how we handle the
>+    * -modulepath cmd line option.  For now, this is convenient
>+    * though. */
>+   libPaths = getenv("LIBGL_DRIVERS_PATH");
>+   if (!libPaths)
>+       libPaths = getenv("LIBGL_DRIVERS_DIR"); /* deprecated */
>+   if (!libPaths)
>+      libPaths = DEFAULT_DRIVER_DIR;
>+
>+   for ( i = 0 ; ExtractDir(i, libPaths, sizeof libDir, libDir) != 0 ; i++ ) {
>+      char realDriverName[200];
>+      void *handle = NULL;
>+
>+      snprintf(realDriverName, sizeof realDriverName,
>+	       "%s/%s_dri.so", libDir, driverName);
>+
>+      xf86DrvMsg(pScreen->myNum, X_INFO,
>+		 "OpenDriver: trying %s\n", realDriverName);
>+      handle = dlopen(realDriverName, RTLD_NOW | RTLD_GLOBAL);
>+
>+      if ( handle != NULL ) {
>+         /* allocate __DRIdriver struct */
>+         driver = (__DRIdriver *) __glXMalloc(sizeof(__DRIdriver));
>+         if (!driver)
>+            return NULL; /* out of memory! */
>+         /* init the struct */
>+         driver->name = Xstrdup(driverName);
>+         if (!driver->name) {
>+            Xfree(driver);
>+            return NULL; /* out of memory! */
>+         }
>+
>+         driver->createNewScreenFunc = (PFNCREATENEWSCREENFUNC)
>+            dlsym(handle, createNewScreenName);
>+
>+         if ( driver->createNewScreenFunc == NULL ) {
>+            /* If the driver doesn't have this symbol then something's
>+             * really, really wrong.
>+             */
>+	     xf86DrvMsg(pScreen->myNum, X_ERROR,
>+			"%s not defined in %s_dri.so!\n"
>+			"Your driver may be too old for this GLX module.\n",
>+			createNewScreenName, driverName);
>+            Xfree(driver);
>+            dlclose(handle);
>+            continue;
>+         }
>+         driver->handle = handle;
>+         /* put at head of linked list */
>+         driver->next = Drivers;
>+         Drivers = driver;
>+
>+         return driver;
>+      }
>+      else {
>+	  xf86DrvMsg(pScreen->myNum, X_ERROR,
>+		     "dlopen %s failed (%s)\n", realDriverName, dlerror());
>+      }
>+   }
>+
>+   xf86DrvMsg(pScreen->myNum, X_ERROR,
>+	      "unable to find driver: %s_dri.so\n", driverName);
>+
>+   return NULL;
>+}
>+
>+
>+/*
>+ * Given a display pointer and screen number, determine the name of
>+ * the DRI driver for the screen. (I.e. "r128", "tdfx", etc).
>+ * Return True for success, False for failure.
>+ */
>+static Bool GetDriverName(ScreenPtr pScreen, char **driverName)
>+{
>+   int directCapable;
>+   Bool b;
>+   int driverMajor, driverMinor, driverPatch;
>+
>+   *driverName = NULL;
>+
>+   if (!DRIQueryDirectRenderingCapable(pScreen, &directCapable)) {
>+       xf86DrvMsg(pScreen->myNum, X_ERROR,
>+		  "DRIQueryDirectRenderingCapable failed\n");
>+      return False;
>+   }
>+   if (!directCapable) {
>+       xf86DrvMsg(pScreen->myNum, X_ERROR,
>+		  "DRIQueryDirectRenderingCapable returned false\n");
>+       return False;
>+   }
>+
>+   b = DRIGetClientDriverName(pScreen, &driverMajor, &driverMinor,
>+			      &driverPatch, driverName);
>+   if (!b) {
>+       xf86DrvMsg(pScreen->myNum, X_ERROR,
>+		  "Cannot determine driver name for screen %d\n",
>+		  pScreen->myNum);
>+      return False;
>+   }
>+
>+   xf86DrvMsg(pScreen->myNum, X_INFO,
>+	      "DRIGetClientDriverName: %d.%d.%d %s (screen %d)\n",
>+	      driverMajor, driverMinor, driverPatch,
>+	      *driverName, pScreen->myNum);
>+
>+   return True;
>+}
>+
>+
>+/*
>+ * Given a display pointer and screen number, return a __DRIdriver handle.
>+ * Return NULL if anything goes wrong.
>+ */
>+static __DRIdriver *driGetDriver(ScreenPtr pScreen)
>+{
>+   char *driverName;
>+
>+   if (GetDriverName(pScreen, &driverName)) {
>+      __DRIdriver *ret;
>+      ret = OpenDriver(driverName, pScreen);
>+
>+      return ret;
>+   }
>+
>+   return NULL;
>+}
>+
>+static unsigned
>+filter_modes(__GLcontextModes **server_modes,
>+	     const __GLcontextModes *driver_modes)
>+{
>+    __GLcontextModes * m;
>+    __GLcontextModes ** prev_next;
>+    const __GLcontextModes * check;
>+    unsigned modes_count = 0;
>+
>+    if ( driver_modes == NULL ) {
>+	fprintf(stderr, "libGL warning: 3D driver returned no fbconfigs.\n");
>+	return 0;
>+    }
>+
>+    /* For each mode in server_modes, check to see if a matching mode exists
>+     * in driver_modes.  If not, then the mode is not available.
>+     */
>+
>+    prev_next = server_modes;
>+    for ( m = *prev_next ; m != NULL ; m = *prev_next ) {
>+	GLboolean do_delete = GL_TRUE;
>+
>+	for ( check = driver_modes ; check != NULL ; check = check->next ) {
>+	    if ( _gl_context_modes_are_same( m, check ) ) {
>+		do_delete = GL_FALSE;
>+		break;
>+	    }
>+	}
>+
>+	/* The 3D has to support all the modes that match the GLX visuals
>+	 * sent from the X server.
>+	 */
>+	if ( do_delete && (m->visualID != 0) ) {
>+	    do_delete = GL_FALSE;
>+
>+	    fprintf(stderr, "libGL warning: 3D driver claims to not support "
>+		    "visual 0x%02x\n", m->visualID);
>+	}
>+
>+	if ( do_delete ) {
>+	    *prev_next = m->next;
>+
>+	    m->next = NULL;
>+	    _gl_context_modes_destroy( m );
>+	}
>+	else {
>+	    modes_count++;
>+	    prev_next = & m->next;
>+	}
>+    }
>+
>+    return modes_count;
>+}
>+
>+
>+static __DRIfuncPtr getProcAddress(const char *proc_name)
>+{
>+    return NULL;
>+}
>+
>+static __DRIscreen *findScreen(__DRInativeDisplay *dpy, int scrn)
>+{
>+    return &__glXActiveScreens[scrn].driScreen;
>+}
>+
>+static GLboolean windowExists(__DRInativeDisplay *dpy, __DRIid draw)
>+{
>+    WindowPtr pWin = (WindowPtr) LookupIDByType(draw, RT_WINDOW);
>+
>+    return pWin == NULL ? GL_FALSE : GL_TRUE;
>+}
>+
>+static GLboolean createContext(__DRInativeDisplay *dpy, int screen,
>+			       int configID, void *contextID,
>+			       drm_context_t *hw_context)
>+{
>+    XID fakeID;
>+    VisualPtr visual;
>+    int i;
>+    ScreenPtr pScreen;
>+
>+    pScreen = screenInfo.screens[screen];
>+
>+    /* Find the requested X visual */
>+    visual = pScreen->visuals;
>+    for (i = 0; i < pScreen->numVisuals; i++, visual++)
>+	if (visual->vid == configID)
>+	    break;
>+    if (i == pScreen->numVisuals)
>+	return GL_FALSE;
>+
>+    fakeID = FakeClientID(0);
>+    *(XID *) contextID = fakeID;
>+
>+    return DRICreateContext(pScreen, visual, fakeID, hw_context);
>+}
>+
>+static GLboolean destroyContext(__DRInativeDisplay *dpy, int screen,
>+				__DRIid context)
>+{
>+    return DRIDestroyContext(screenInfo.screens[screen], context);
>+}
>+
>+static GLboolean
>+createDrawable(__DRInativeDisplay *dpy, int screen,
>+	       __DRIid drawable, drm_drawable_t *hHWDrawable)
>+{
>+    DrawablePtr pDrawable;
>+
>+    pDrawable = (DrawablePtr) LookupIDByClass(drawable, RC_DRAWABLE);
>+    if (!pDrawable)
>+	return GL_FALSE;
>+
>+    return DRICreateDrawable(screenInfo.screens[screen],
>+			     drawable,
>+			     pDrawable,
>+			     hHWDrawable);
>+}
>+
>+static GLboolean
>+destroyDrawable(__DRInativeDisplay *dpy, int screen, __DRIid drawable)
>+{
>+    DrawablePtr pDrawable;
>+
>+    pDrawable = (DrawablePtr) LookupIDByClass(drawable, RC_DRAWABLE);
>+    if (!pDrawable)
>+	return GL_FALSE;
>+
>+    return DRIDestroyDrawable(screenInfo.screens[screen],
>+			      drawable,
>+			      pDrawable);
>+}
>+
>+static GLboolean
>+getDrawableInfo(__DRInativeDisplay *dpy, int screen,
>+		__DRIid drawable, unsigned int *index, unsigned int *stamp,
>+		int *x, int *y, int *width, int *height,
>+		int *numClipRects, drm_clip_rect_t **ppClipRects,
>+		int *backX, int *backY,
>+		int *numBackClipRects, drm_clip_rect_t **ppBackClipRects)
>+{
>+    DrawablePtr pDrawable;
>+    drm_clip_rect_t *pClipRects, *pBackClipRects;
>+    GLboolean retval;
>+    size_t size;
>+
>+    pDrawable = (DrawablePtr) LookupIDByClass(drawable, RC_DRAWABLE);
>+    if (!pDrawable)
>+	return GL_FALSE;
>+
>+    retval = DRIGetDrawableInfo(screenInfo.screens[screen],
>+				pDrawable, index, stamp,
>+				x, y, width, height,
>+				numClipRects, &pClipRects,
>+				backX, backY,
>+				numBackClipRects, &pBackClipRects);
>+
>+    size = sizeof (drm_clip_rect_t) * *numClipRects;
>+    *ppClipRects = __glXMalloc (size);
>+    if (*ppClipRects == NULL)
>+	return GL_FALSE;
>+    memcpy (*ppClipRects, pClipRects, size);
>+
>+    size = sizeof (drm_clip_rect_t) * *numBackClipRects;
>+    *ppBackClipRects = __glXMalloc (size);
>+    if (*ppBackClipRects == NULL) {
>+	__glXFree(*ppClipRects);
>+	return GL_FALSE;
>+    }	    
>+    memcpy (*ppBackClipRects, pBackClipRects, size);
>+
>+    return GL_TRUE;
>+}
>+
>+/* Table of functions exported by the loader to the driver. */
>+static const __DRIinterfaceMethods interface_methods = {
>+    getProcAddress,
>+
>+    _gl_context_modes_create,
>+    _gl_context_modes_destroy,
>+      
>+    findScreen,
>+    windowExists,
>+      
>+    createContext,
>+    destroyContext,
>+
>+    createDrawable,
>+    destroyDrawable,
>+    getDrawableInfo,
>+
>+    NULL, /* __glXGetUST, */
>+    NULL, /* glXGetMscRateOML, */
>+};
>+
>+/**
>+ * Retrieves the verion of the internal libGL API in YYYYMMDD format.  This
>+ * might be used by the DRI drivers to determine how new libGL is at runtime.
>+ * Drivers should not call this function directly.  They should instead use
>+ * \c glXGetProcAddress to obtain a pointer to the function.
>+ * 
>+ * \returns An 8-digit decimal number representing the internal libGL API in
>+ *          YYYYMMDD format.
>+ * 
>+ * \sa glXGetProcAddress, PFNGLXGETINTERNALVERSIONPROC
>+ *
>+ * \since Internal API version 20021121.
>+ */
>+static int __glXGetInternalVersion(void)
>+{
>+    /* History:
>+     * 20021121 - Initial version
>+     * 20021128 - Added __glXWindowExists() function
>+     * 20021207 - Added support for dynamic GLX extensions,
>+     *            GLX_SGI_swap_control, GLX_SGI_video_sync,
>+     *            GLX_OML_sync_control, and GLX_MESA_swap_control.
>+     *            Never officially released.  Do NOT test against
>+     *            this version.  Use 20030317 instead.
>+     * 20030317 - Added support GLX_SGIX_fbconfig,
>+     *            GLX_MESA_swap_frame_usage, GLX_OML_swap_method,
>+     *            GLX_{ARB,SGIS}_multisample, and
>+     *            GLX_SGIX_visual_select_group.
>+     * 20030606 - Added support for GLX_SGI_make_current_read.
>+     * 20030813 - Made support for dynamic extensions multi-head aware.
>+     * 20030818 - Added support for GLX_MESA_allocate_memory in place of the
>+     *            deprecated GLX_NV_vertex_array_range & GLX_MESA_agp_offset
>+     *            interfaces.
>+     * 20031201 - Added support for the first round of DRI interface changes.
>+     *            Do NOT test against this version!  It has binary
>+     *            compatibility bugs, use 20040317 instead.
>+     * 20040317 - Added the 'mode' field to __DRIcontextRec.
>+     * 20040415 - Added support for bindContext3 and unbindContext3.
>+     * 20040602 - Add __glXGetDrawableInfo.  I though that was there
>+     *            months ago. :(
>+     * 20050727 - Gut all the old interfaces.  This breaks compatability with
>+     *            any DRI driver built to any previous version.
>+     */
>+    return 20050727;
>+}
>+
>+/**
>+ * Perform the required libGL-side initialization and call the client-side
>+ * driver's \c __driCreateNewScreen function.
>+ * 
>+ * \param dpy    Display pointer.
>+ * \param scrn   Screen number on the display.
>+ * \param psc    DRI screen information.
>+ * \param driDpy DRI display information.
>+ * \param createNewScreen  Pointer to the client-side driver's
>+ *               \c __driCreateNewScreen function.
>+ * \returns A pointer to the \c __DRIscreenPrivate structure returned by
>+ *          the client-side driver on success, or \c NULL on failure.
>+ * 
>+ * \todo This function needs to be modified to remove context-modes from the
>+ *       list stored in the \c __GLXscreenConfigsRec to match the list
>+ *       returned by the client-side driver.
>+ */
>+static void *
>+CallCreateNewScreen(ScreenPtr pScreen, __DRIscreen *psc,
>+		    PFNCREATENEWSCREENFUNC createNewScreen)
>+{
>+    drm_handle_t hSAREA;
>+    drmAddress pSAREA = MAP_FAILED;
>+    char *BusID;
>+    __DRIversion   ddx_version;
>+    __DRIversion   dri_version;
>+    __DRIversion   drm_version;
>+    __DRIframebuffer  framebuffer;
>+    int   fd = -1;
>+    int   status;
>+    const char * err_msg;
>+    const char * err_extra = NULL;
>+    int api_ver = __glXGetInternalVersion();
>+    drm_magic_t magic;
>+    drmVersionPtr version;
>+    char *driverName;
>+    drm_handle_t  hFB;
>+    int        junk;
>+    __GLcontextModes * driver_modes;
>+    __GLXscreenInfo *pGlxScreen;
>+
>+    /* DRI protocol version. */
>+    dri_version.major = XF86DRI_MAJOR_VERSION;
>+    dri_version.minor = XF86DRI_MINOR_VERSION;
>+    dri_version.patch = XF86DRI_PATCH_VERSION;
>+
>+    framebuffer.base = MAP_FAILED;
>+    framebuffer.dev_priv = NULL;
>+
>+    if (!DRIOpenConnection(pScreen, &hSAREA, &BusID)) {
>+	err_msg = "DRIOpenConnection";
>+	err_extra = NULL;
>+	goto handle_error;
>+    }
>+
>+    fd = drmOpen(NULL, BusID);
>+    Xfree(BusID); /* No longer needed */
>+
>+    if (fd < 0) {
>+	err_msg = "open DRM";
>+	err_extra = strerror( -fd );
>+	goto handle_error;
>+    }
>+
>+    if (drmGetMagic(fd, &magic)) {
>+	err_msg = "drmGetMagic";
>+	err_extra = NULL;
>+	goto handle_error;
>+    }
>+
>+    version = drmGetVersion(fd);
>+    if (version) {
>+	drm_version.major = version->version_major;
>+	drm_version.minor = version->version_minor;
>+	drm_version.patch = version->version_patchlevel;
>+	drmFreeVersion(version);
>+    }
>+    else {
>+	drm_version.major = -1;
>+	drm_version.minor = -1;
>+	drm_version.patch = -1;
>+    }
>+
>+    if (!DRIAuthConnection(pScreen, magic)) {
>+	err_msg = "DRIAuthConnection";
>+	goto handle_error;
>+    }
>+
>+    /* Get device name (like "tdfx") and the ddx version numbers.
>+     * We'll check the version in each DRI driver's "createNewScreen"
>+     * function. */
>+    if (!DRIGetClientDriverName(pScreen,
>+				&ddx_version.major,
>+				&ddx_version.minor,
>+				&ddx_version.patch,
>+				&driverName)) {
>+	err_msg = "DRIGetClientDriverName";
>+	goto handle_error;
>+    }
>+
>+    /*
>+     * Get device-specific info.  pDevPriv will point to a struct
>+     * (such as DRIRADEONRec in xfree86/driver/ati/radeon_dri.h) that
>+     * has information about the screen size, depth, pitch, ancilliary
>+     * buffers, DRM mmap handles, etc.
>+     */
>+    if (!DRIGetDeviceInfo(pScreen, &hFB, &junk,
>+			  &framebuffer.size, &framebuffer.stride,
>+			  &framebuffer.dev_priv_size, &framebuffer.dev_priv)) {
>+	err_msg = "XF86DRIGetDeviceInfo";
>+	goto handle_error;
>+    }
>+
>+    framebuffer.width = pScreen->width;
>+    framebuffer.height = pScreen->height;
>+
>+    /* Map the framebuffer region. */
>+    status = drmMap(fd, hFB, framebuffer.size, 
>+		    (drmAddressPtr)&framebuffer.base);
>+    if (status != 0) {
>+	err_msg = "drmMap of framebuffer";
>+	err_extra = strerror( -status );
>+	goto handle_error;
>+    }
>+
>+    /* Map the SAREA region.  Further mmap regions may be setup in
>+     * each DRI driver's "createNewScreen" function.
>+     */
>+    status = drmMap(fd, hSAREA, SAREA_MAX, &pSAREA);
>+    if (status != 0) {
>+	err_msg = "drmMap of sarea";
>+	err_extra = strerror( -status );
>+	goto handle_error;
>+    }
>+    
>+    driver_modes = NULL;
>+
>+    pGlxScreen = &__glXActiveScreens[pScreen->myNum];
>+
>+    __glXActiveScreens[pScreen->myNum].driScreen.private =
>+	(*createNewScreen)(NULL, pScreen->myNum,
>+			   &__glXActiveScreens[pScreen->myNum].driScreen,
>+			   pGlxScreen->modes,
>+			   &ddx_version,
>+			   &dri_version,
>+			   &drm_version,
>+			   &framebuffer,
>+			   pSAREA,
>+			   fd,
>+			   api_ver,
>+			   &interface_methods,
>+			   &driver_modes);
>+
>+    if (__glXActiveScreens[pScreen->myNum].driScreen.private == NULL) {
>+	err_msg = "InitDriver";
>+	err_extra = NULL;
>+	goto handle_error;
>+    }
>+
>+    filter_modes(&pGlxScreen->modes, driver_modes);
>+    _gl_context_modes_destroy(driver_modes);
>+
>+    return __glXActiveScreens[pScreen->myNum].driScreen.private;
>+
>+ handle_error:
>+    if (pSAREA != MAP_FAILED)
>+	drmUnmap(pSAREA, SAREA_MAX);
>+
>+    if (framebuffer.base != MAP_FAILED)
>+	drmUnmap((drmAddress)framebuffer.base, framebuffer.size);
>+
>+    if (framebuffer.dev_priv != NULL)
>+	Xfree(framebuffer.dev_priv);
>+
>+    if (fd >= 0)
>+	drmClose(fd);
>+
>+    DRICloseConnection(pScreen);
>+
>+    if (err_extra != NULL)
>+	fprintf(stderr, "libGL error: %s failed (%s)\n", err_msg,
>+		err_extra);
>+    else
>+	fprintf(stderr, "libGL error: %s failed\n", err_msg );
>+
>+    fprintf(stderr, "libGL error: reverting to (slow) indirect rendering\n");
>+
>+    return NULL;
>+}
>+
>+#if 0
>+/* This function isn't currently used.
>+ */
>+static void driDestroyDisplay(Display *dpy, void *private)
>+{
>+    __DRIdisplayPrivate *pdpyp = (__DRIdisplayPrivate *)private;
>+
>+    if (pdpyp) {
>+        const int numScreens = ScreenCount(dpy);
>+        int i;
>+        for (i = 0; i < numScreens; i++) {
>+            if (pdpyp->libraryHandles[i])
>+                dlclose(pdpyp->libraryHandles[i]);
>+        }
>+        Xfree(pdpyp->libraryHandles);
>+	Xfree(pdpyp);
>+    }
>+}
>+#endif
>+
>+void __glXLoaderInitScreen(int screen)
>+{
>+    ScreenPtr pScreen;
>+    __DRIdriver *driver;
>+
>+    /* dynamically discover DRI drivers for all screens, saving each
>+     * driver's "__driCreateScreen" function pointer.  That's the bootstrap
>+     * entrypoint for all DRI drivers.
>+     */
>+    pScreen = screenInfo.screens[screen];
>+    driver = driGetDriver(pScreen);
>+
>+    if (driver) {
>+	__glXActiveScreens[screen].driver = driver;
>+
>+	CallCreateNewScreen(pScreen,
>+			    &__glXActiveScreens[screen].driScreen,
>+			    driver->createNewScreenFunc);
>+	__glXActiveScreens[screen].driScreen.screenConfigs = 
>+	    &__glXActiveScreens[screen];
>+    }
>+    else {
>+	/* FIXME: Fall back to loading sw dri driver here. */
>+    }
>+}
>--- /dev/null	2005-11-03 11:11:37.448403000 -0500
>+++ programs/Xserver/GL/glx/glxloader.h	2005-11-06 09:37:00.000000000 -0500
>@@ -0,0 +1,30 @@
>+/*
>+ * Copyright Â© 2005  Red Hat, Inc.
>+ * All Rights Reserved.
>+ * 
>+ * Permission is hereby granted, free of charge, to any person obtaining a
>+ * copy of this software and associated documentation files (the "Software"),
>+ * to deal in the Software without restriction, including without limitation
>+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
>+ * and/or sell copies of the Software, and to permit persons to whom the
>+ * Software is furnished to do so, subject to the following conditions:
>+ * 
>+ * The above copyright notice and this permission notice (including the next
>+ * paragraph) shall be included in all copies or substantial portions of the
>+ * Software.
>+ * 
>+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
>+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
>+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
>+ * RED HAT, INC, AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
>+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
>+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
>+ * DEALINGS IN THE SOFTWARE.
>+ */
>+
>+#ifndef __GLX_LOADER_H__
>+#define __GLX_LOADER_H__
>+
>+void __glXLoaderInitScreen(int screen);
>+
>+#endif /* __GLX_LOADER_H__ */
>Index: extras/Mesa/include/GL/internal/dri_interface.h
>===================================================================
>RCS file: /cvs/xorg/xc/extras/Mesa/include/GL/internal/dri_interface.h,v
>retrieving revision 1.1.1.5
>diff -u -p -r1.1.1.5 dri_interface.h
>--- extras/Mesa/include/GL/internal/dri_interface.h	18 Oct 2005 02:51:49 -0000	1.1.1.5
>+++ extras/Mesa/include/GL/internal/dri_interface.h	8 Nov 2005 04:05:40 -0000
>@@ -39,7 +39,6 @@
> #define DRI_INTERFACE_H
> 
> #include <GL/internal/glcore.h>
>-#include <xf86drm.h>
> #include <drm.h>
> 
> /**
>Index: extras/Mesa/src/mesa/drivers/dri/common/dri_util.c
>===================================================================
>RCS file: /cvs/xorg/xc/extras/Mesa/src/mesa/drivers/dri/common/dri_util.c,v
>retrieving revision 1.5
>diff -u -p -r1.5 dri_util.c
>--- extras/Mesa/src/mesa/drivers/dri/common/dri_util.c	18 Oct 2005 03:10:14 -0000	1.5
>+++ extras/Mesa/src/mesa/drivers/dri/common/dri_util.c	8 Nov 2005 04:05:40 -0000
>@@ -131,9 +131,8 @@ static void __driGarbageCollectDrawables
> 	    __DRIdrawablePrivate *pdp = (__DRIdrawablePrivate *)pdraw->private;
> 	    dpy = pdp->driScreenPriv->display;
> 	    if (! (*dri_interface->windowExists)(dpy, draw)) {
>-		/* Destroy the local drawable data in the hash table, if the
>-		   drawable no longer exists in the Xserver */
>-	        drmHashDelete(drawHash, draw);
>+		/* Destroy the local drawable data, if the drawable no
>+		   longer exists in the Xserver */
> 		(*pdraw->destroyDrawable)(dpy, pdraw->private);
> 		_mesa_free(pdraw);
> 	    }
>@@ -664,6 +663,7 @@ static void driDestroyDrawable(__DRInati
>         (*psp->DriverAPI.DestroyBuffer)(pdp);
> 	if ((*dri_interface->windowExists)(dpy, pdp->draw))
> 	    (void)(*dri_interface->destroyDrawable)(dpy, scrn, pdp->draw);
>+	drmHashDelete(psp->drawHash, pdp->draw);
> 	if (pdp->pClipRects) {
> 	    _mesa_free(pdp->pClipRects);
> 	    pdp->pClipRects = NULL;
>Index: extras/Mesa/src/mesa/drivers/dri/common/dri_util.h
>===================================================================
>RCS file: /cvs/xorg/xc/extras/Mesa/src/mesa/drivers/dri/common/dri_util.h,v
>retrieving revision 1.1.1.4
>diff -u -p -r1.1.1.4 dri_util.h
>--- extras/Mesa/src/mesa/drivers/dri/common/dri_util.h	31 Jul 2005 16:47:10 -0000	1.1.1.4
>+++ extras/Mesa/src/mesa/drivers/dri/common/dri_util.h	8 Nov 2005 04:05:40 -0000
>@@ -54,6 +54,7 @@
> #include <GL/gl.h>
> #include "drm.h"
> #include "drm_sarea.h"
>+#include "xf86drm.h"
> #include "GL/internal/glcore.h"
> #include "GL/internal/dri_interface.h"
> 
>Index: extras/Mesa/src/mesa/drivers/dri/common/glcontextmodes.c
>===================================================================
>RCS file: /cvs/xorg/xc/extras/Mesa/src/mesa/drivers/dri/common/glcontextmodes.c,v
>retrieving revision 1.1.1.3
>diff -u -p -r1.1.1.3 glcontextmodes.c
>--- extras/Mesa/src/mesa/drivers/dri/common/glcontextmodes.c	18 Oct 2005 02:51:57 -0000	1.1.1.3
>+++ extras/Mesa/src/mesa/drivers/dri/common/glcontextmodes.c	8 Nov 2005 04:05:40 -0000
>@@ -157,8 +157,8 @@ _gl_copy_visual_to_context_mode( __GLcon
>     mode->greenMask = config->greenMask;
>     mode->blueMask = config->blueMask;
>     mode->alphaMask = config->alphaMask;
>-    mode->rgbBits = config->bufferSize;
>-    mode->indexBits = config->bufferSize;
>+    mode->rgbBits = mode->rgbMode ? config->bufferSize : 0;
>+    mode->indexBits = mode->colorIndexMode ? config->bufferSize : 0;
> 
>     mode->accumRedBits = config->accumRedSize;
>     mode->accumGreenBits = config->accumGreenSize;
>Index: lib/Imakefile
>===================================================================
>RCS file: /cvs/xorg/xc/lib/Imakefile,v
>retrieving revision 1.12
>diff -u -p -r1.12 Imakefile
>--- lib/Imakefile	10 Oct 2005 04:18:08 -0000	1.12
>+++ lib/Imakefile	8 Nov 2005 04:05:43 -0000
>@@ -61,10 +61,12 @@ XF86DGALIBDIR = Xxf86dga
> XF86RUSHLIBDIR = Xxf86rush
> #endif
> 
>+#if 0
> #if BuildXvLibrary
> XVLIBDIR = Xv
> XVMCLIBDIR = XvMC
> #endif
>+#endif
> 
> #if BuildXineramaLibrary
> XINERAMADIR=Xinerama
>Index: programs/Xserver/Imakefile
>===================================================================
>RCS file: /cvs/xorg/xc/programs/Xserver/Imakefile,v
>retrieving revision 1.34
>diff -u -p -r1.34 Imakefile
>--- programs/Xserver/Imakefile	11 Jul 2005 20:30:31 -0000	1.34
>+++ programs/Xserver/Imakefile	8 Nov 2005 04:05:44 -0000
>@@ -66,24 +66,17 @@ INSTPGMFLAGS = 
>       DRILIB = 
> # endif
> # if GlxUseSGISI
>-      GLXLIB = GL/glx/ModuleLibraryTargetName(glx) \
>-               GL/sgi-si/ModuleLibraryTargetName(GLcore) \
>-               $(DRILIB)
>+      GLXLIB = GL/glx/ModuleLibraryTargetName(glx) $(DRILIB)
> # else
> #  if defined(GlxUseWindows) && GlxUseWindows
>-      XWin_GL.exe.GLXLIB = GL/glx/ModuleLibraryTargetName(glx_stdcall) \
>-               GL/windows/ModuleLibraryTargetName(GLcore)
>+      XWin_GL.exe.GLXLIB = GL/glx/ModuleLibraryTargetName(glx_stdcall)
> #  endif /* GlxUseWindows */
> #  if defined(Win32Architecture) && defined(GlxUseWindows) && GlxUseWindows
>-      GLXLIB = GL/glx/ModuleLibraryTargetName(glx_stdcall) \
>-               GL/windows/ModuleLibraryTargetName(GLcore)
>+      GLXLIB = GL/glx/ModuleLibraryTargetName(glx_stdcall)
> #  elif DoLoadableServer
>-      GLXLIB = GL/glx/ModuleLibraryTargetName(glx) \
>-               GL/mesa/GLcore/ModuleLibraryTargetName(GLcore)
>+      GLXLIB = GL/glx/ModuleLibraryTargetName(glx)
> #  else
>-      GLXLIB = GL/glx/ModuleLibraryTargetName(glx) \
>-               GL/mesa/GLcore/ModuleLibraryTargetName(GLcore) \
>-               $(DRILIB)
>+      GLXLIB = GL/glx/ModuleLibraryTargetName(glx) $(DRILIB)
> #  endif
> # endif
>       GLXDIR = GL
>@@ -1160,18 +1153,16 @@ BundleProgramTarget(fullscreen,XDarwinAp
>  * GLX bundles for Quartz
>  * (installed in their own bundles inside XDarwin's)
>  */
>-BundleProgramTarget(glxAGL,XDarwinApp,GL,GL/glx/glxext.o,GL/glx/libglx.a \
>-	GL/apple/libAGLcore.a, \
>+BundleProgramTarget(glxAGL,XDarwinApp,GL,GL/glx/glxext.o,GL/glx/libglx.a, \
> 	-framework AGL -framework OpenGL,$(XDARWINAPPDIR)/Resources)
> 
> #if BuildAppleDRI
>-BundleProgramTarget(glxCGL,XDarwinApp,GL,GL/glx/glxext.o,GL/glx/libglx.a \
>-	GL/apple/libCGLcore.a, \
>+BundleProgramTarget(glxCGL,XDarwinApp,GL,GL/glx/glxext.o,GL/glx/libglx.a, \
> 	-framework OpenGL $(XPLUGINLIB),$(XDARWINAPPDIR)/Resources)
> #endif
> 
>-BundleProgramTarget(glxMesa,XDarwinApp,GL,GL/glx/glxext.o,GL/glx/libglx.a \
>-	GL/mesa/GLcore/libGLcore.a,NullParameter,$(XDARWINAPPDIR)/Resources)
>+BundleProgramTarget(glxMesa,XDarwinApp,GL,GL/glx/glxext.o,GL/glx/libglx.a, \
>+	NullParameter,$(XDARWINAPPDIR)/Resources)
> 
> #else /* !DarwinQuartzSupport */
> 
>Index: programs/Xserver/GL/Imakefile
>===================================================================
>RCS file: /cvs/xorg/xc/programs/Xserver/GL/Imakefile,v
>retrieving revision 1.6
>diff -u -p -r1.6 Imakefile
>--- programs/Xserver/GL/Imakefile	15 Nov 2004 15:06:46 -0000	1.6
>+++ programs/Xserver/GL/Imakefile	8 Nov 2005 04:05:44 -0000
>@@ -5,24 +5,12 @@ XCOMM $XFree86: xc/programs/Xserver/GL/I
> 
> #define IHaveSubdirs
> 
>-#if GlxUseSGISI
>- CORE_SUBDIR = /* opengl */
>-#elif defined(DarwinArchitecture) && DarwinQuartzSupport
>- CORE_SUBDIR = apple mesa
>-#elif defined(cygwinArchitecture) && GlxUseWindows
>- CORE_SUBDIR = windows mesa
>-#elif defined(Win32Architecture) && GlxUseWindows
>- CORE_SUBDIR = windows
>-#else
>- CORE_SUBDIR = mesa
>-#endif
>-
> #if BuildXF86DRI && ((defined(XF86Server) && XF86Server) \
> 	|| (defined(XorgServer) && XorgServer))
> DRI_SUBDIR = dri
> #endif
> 
>-SUBDIRS = glx $(DRI_SUBDIR) $(CORE_SUBDIR)
>+SUBDIRS = glx $(DRI_SUBDIR)
> 
> #if DoLoadableServer
> MSRCS = glxmodule.c
>Index: programs/Xserver/GL/glxmodule.c
>===================================================================
>RCS file: /cvs/xorg/xc/programs/Xserver/GL/glxmodule.c,v
>retrieving revision 1.6
>diff -u -p -r1.6 glxmodule.c
>--- programs/Xserver/GL/glxmodule.c	28 Sep 2005 03:37:22 -0000	1.6
>+++ programs/Xserver/GL/glxmodule.c	8 Nov 2005 04:05:44 -0000
>@@ -45,7 +45,6 @@ static MODULESETUPPROTO(glxSetup);
> 
> extern void GlxExtensionInit(INITARGS);
> extern void GlxWrapInitVisuals(miInitVisualsProcPtr *);
>-extern void InitGlxWrapInitVisuals(void (*f)(miInitVisualsProcPtr *));
> 
> static const char *initdeps[] = { "DOUBLE-BUFFER", NULL };
> 
>@@ -58,1168 +57,6 @@ ExtensionModule GLXExt =
>     initdeps
> };
> 
>-static const char *glcoreSymbols[] = {
>-    "__glCallLists_size",
>-    "__glColorTableParameterfv_size",
>-    "__glColorTableParameteriv_size",
>-    "__glConvolutionParameterfv_size",
>-    "__glConvolutionParameteriv_size",
>-    "__glDDXExtensionInfo",
>-    "__glDDXScreenInfo",
>-    "__glFloorLog2",
>-    "__glFogfv_size",
>-    "__glFogiv_size",
>-    "__glGetBooleanv_size",
>-    "__glGetColorTableParameterfv_size",
>-    "__glGetColorTableParameteriv_size",
>-    "__glGetConvolutionParameterfv_size",
>-    "__glGetConvolutionParameteriv_size",
>-    "__glGetDoublev_size",
>-    "__glGetFloatv_size",
>-    "__glGetHistogramParameterfv_size",
>-    "__glGetHistogramParameteriv_size",
>-    "__glGetIntegerv_size",
>-    "__glGetLightfv_size",
>-    "__glGetLightiv_size",
>-    "__glGetMapdv_size",
>-    "__glGetMapfv_size",
>-    "__glGetMapiv_size",
>-    "__glGetMaterialfv_size",
>-    "__glGetMaterialiv_size",
>-    "__glGetMinmaxParameterfv_size",
>-    "__glGetMinmaxParameteriv_size",
>-    "__glGetPixelMapfv_size",
>-    "__glGetPixelMapuiv_size",
>-    "__glGetPixelMapusv_size",
>-    "__glGetTexEnvfv_size",
>-    "__glGetTexEnviv_size",
>-    "__glGetTexGendv_size",
>-    "__glGetTexGenfv_size",
>-    "__glGetTexGeniv_size",
>-    "__glGetTexImage_size",
>-    "__glGetTexLevelParameterfv_size",
>-    "__glGetTexLevelParameteriv_size",
>-    "__glGetTexParameterfv_size",
>-    "__glGetTexParameteriv_size",
>-    "__glLightModelfv_size",
>-    "__glLightModeliv_size",
>-    "__glLightfv_size",
>-    "__glLightiv_size",
>-    "__glMaterialfv_size",
>-    "__glMaterialiv_size",
>-    "__glPointParameterfvARB_size",
>-    "__glReadPixels_size",
>-    "__glTexEnvfv_size",
>-    "__glTexEnviv_size",
>-    "__glTexGendv_size",
>-    "__glTexGenfv_size",
>-    "__glTexGeniv_size",
>-    "__glTexParameterfv_size",
>-    "__glTexParameteriv_size",
>-    "__glXglDDXExtensionInfo",
>-    "__glXglDDXScreenInfo",
>-    "__glXActiveScreens",
>-    "__glXAssociateContext",
>-    "__glXBadContext",
>-    "__glXBadContextState",
>-    "__glXBadContextTag",
>-    "__glXBadCurrentWindow",
>-    "__glXBadDrawable",
>-    "__glXBadLargeRequest",
>-    "__glXBadPixmap",
>-    "__glXBadRenderRequest",
>-    "__glXBitmapReqSize",
>-    "__glXCacheDrawableSize",
>-    "__glXCallListsReqSize",
>-    "__glXClearErrorOccured",
>-    "__glXClientInfo",
>-    "__glXClientRes",
>-    "__glXClients",
>-    "__glXColorSubTableReqSize",
>-    "__glXColorTableParameterfvReqSize",
>-    "__glXColorTableParameterivReqSize",
>-    "__glXColorTableReqSize",
>-    "__glXContextRes",
>-    "__glXConvolutionFilter1DReqSize",
>-    "__glXConvolutionFilter2DReqSize",
>-    "__glXConvolutionParameterfvReqSize",
>-    "__glXConvolutionParameterivReqSize",
>-    "__glXCopyContext",
>-    "__glXCoreType",
>-    "__glXCreateContext",
>-    "__glXCreateGLXPixmap",
>-    "__glXDeassociateContext",
>-    "__glXDestroyContext",
>-    "__glXDestroyGLXPixmap",
>-    "__glXDispSwap_Accum",
>-    "__glXDispSwap_ActiveStencilFaceEXT",
>-    "__glXDispSwap_ActiveTextureARB",
>-    "__glXDispSwap_AlphaFunc",
>-    "__glXDispSwap_AreTexturesResident",
>-    "__glXDispSwap_AreTexturesResidentEXT",
>-    "__glXDispSwap_Begin",
>-    "__glXDispSwap_BindTexture",
>-    "__glXDispSwap_Bitmap",
>-    "__glXDispSwap_BlendColor",
>-    "__glXDispSwap_BlendEquation",
>-    "__glXDispSwap_BlendFunc",
>-    "__glXDispSwap_CallList",
>-    "__glXDispSwap_CallLists",
>-    "__glXDispSwap_Clear",
>-    "__glXDispSwap_ClearAccum",
>-    "__glXDispSwap_ClearColor",
>-    "__glXDispSwap_ClearDepth",
>-    "__glXDispSwap_ClearIndex",
>-    "__glXDispSwap_ClearStencil",
>-    "__glXDispSwap_ClipPlane",
>-    "__glXDispSwap_Color3bv",
>-    "__glXDispSwap_Color3dv",
>-    "__glXDispSwap_Color3fv",
>-    "__glXDispSwap_Color3iv",
>-    "__glXDispSwap_Color3sv",
>-    "__glXDispSwap_Color3ubv",
>-    "__glXDispSwap_Color3uiv",
>-    "__glXDispSwap_Color3usv",
>-    "__glXDispSwap_Color4bv",
>-    "__glXDispSwap_Color4dv",
>-    "__glXDispSwap_Color4fv",
>-    "__glXDispSwap_Color4iv",
>-    "__glXDispSwap_Color4sv",
>-    "__glXDispSwap_Color4ubv",
>-    "__glXDispSwap_Color4uiv",
>-    "__glXDispSwap_Color4usv",
>-    "__glXDispSwap_ColorMask",
>-    "__glXDispSwap_ColorMaterial",
>-    "__glXDispSwap_ColorSubTable",
>-    "__glXDispSwap_ColorTable",
>-    "__glXDispSwap_ColorTableParameterfv",
>-    "__glXDispSwap_ColorTableParameteriv",
>-    "__glXDispSwap_ConvolutionFilter1D",
>-    "__glXDispSwap_ConvolutionFilter2D",
>-    "__glXDispSwap_ConvolutionParameterf",
>-    "__glXDispSwap_ConvolutionParameterfv",
>-    "__glXDispSwap_ConvolutionParameteri",
>-    "__glXDispSwap_ConvolutionParameteriv",
>-    "__glXDispSwap_CopyColorSubTable",
>-    "__glXDispSwap_CopyColorTable",
>-    "__glXDispSwap_CopyConvolutionFilter1D",
>-    "__glXDispSwap_CopyConvolutionFilter2D",
>-    "__glXDispSwap_CopyPixels",
>-    "__glXDispSwap_CopyTexImage1D",
>-    "__glXDispSwap_CopyTexImage2D",
>-    "__glXDispSwap_CopyTexSubImage1D",
>-    "__glXDispSwap_CopyTexSubImage2D",
>-    "__glXDispSwap_CopyTexSubImage3D",
>-    "__glXDispSwap_CullFace",
>-    "__glXDispSwap_DeleteLists",
>-    "__glXDispSwap_DeleteTextures",
>-    "__glXDispSwap_DeleteTexturesEXT",
>-    "__glXDispSwap_DepthFunc",
>-    "__glXDispSwap_DepthMask",
>-    "__glXDispSwap_DepthRange",
>-    "__glXDispSwap_Disable",
>-    "__glXDispSwap_DrawArrays",
>-    "__glXDispSwap_DrawArraysEXT",
>-    "__glXDispSwap_DrawBuffer",
>-    "__glXDispSwap_DrawPixels",
>-    "__glXDispSwap_EdgeFlagv",
>-    "__glXDispSwap_Enable",
>-    "__glXDispSwap_End",
>-    "__glXDispSwap_EndList",
>-    "__glXDispSwap_EvalCoord1dv",
>-    "__glXDispSwap_EvalCoord1fv",
>-    "__glXDispSwap_EvalCoord2dv",
>-    "__glXDispSwap_EvalCoord2fv",
>-    "__glXDispSwap_EvalMesh1",
>-    "__glXDispSwap_EvalMesh2",
>-    "__glXDispSwap_EvalPoint1",
>-    "__glXDispSwap_EvalPoint2",
>-    "__glXDispSwap_FeedbackBuffer",
>-    "__glXDispSwap_Finish",
>-    "__glXDispSwap_Flush",
>-    "__glXDispSwap_Fogf",
>-    "__glXDispSwap_Fogfv",
>-    "__glXDispSwap_Fogi",
>-    "__glXDispSwap_Fogiv",
>-    "__glXDispSwap_FrontFace",
>-    "__glXDispSwap_Frustum",
>-    "__glXDispSwap_GenLists",
>-    "__glXDispSwap_GenTextures",
>-    "__glXDispSwap_GenTexturesEXT",
>-    "__glXDispSwap_GetBooleanv",
>-    "__glXDispSwap_GetClipPlane",
>-    "__glXDispSwap_GetColorTable",
>-    "__glXDispSwap_GetColorTableParameterfv",
>-    "__glXDispSwap_GetColorTableParameteriv",
>-    "__glXDispSwap_GetConvolutionFilter",
>-    "__glXDispSwap_GetConvolutionParameterfv",
>-    "__glXDispSwap_GetConvolutionParameteriv",
>-    "__glXDispSwap_GetDoublev",
>-    "__glXDispSwap_GetError",
>-    "__glXDispSwap_GetFloatv",
>-    "__glXDispSwap_GetHistogram",
>-    "__glXDispSwap_GetHistogramParameterfv",
>-    "__glXDispSwap_GetHistogramParameteriv",
>-    "__glXDispSwap_GetIntegerv",
>-    "__glXDispSwap_GetLightfv",
>-    "__glXDispSwap_GetLightiv",
>-    "__glXDispSwap_GetMapdv",
>-    "__glXDispSwap_GetMapfv",
>-    "__glXDispSwap_GetMapiv",
>-    "__glXDispSwap_GetMaterialfv",
>-    "__glXDispSwap_GetMaterialiv",
>-    "__glXDispSwap_GetMinmax",
>-    "__glXDispSwap_GetMinmaxParameterfv",
>-    "__glXDispSwap_GetMinmaxParameteriv",
>-    "__glXDispSwap_GetPixelMapfv",
>-    "__glXDispSwap_GetPixelMapuiv",
>-    "__glXDispSwap_GetPixelMapusv",
>-    "__glXDispSwap_GetPolygonStipple",
>-    "__glXDispSwap_GetSeparableFilter",
>-    "__glXDispSwap_GetString",
>-    "__glXDispSwap_GetTexEnvfv",
>-    "__glXDispSwap_GetTexEnviv",
>-    "__glXDispSwap_GetTexGendv",
>-    "__glXDispSwap_GetTexGenfv",
>-    "__glXDispSwap_GetTexGeniv",
>-    "__glXDispSwap_GetTexImage",
>-    "__glXDispSwap_GetTexLevelParameterfv",
>-    "__glXDispSwap_GetTexLevelParameteriv",
>-    "__glXDispSwap_GetTexParameterfv",
>-    "__glXDispSwap_GetTexParameteriv",
>-    "__glXDispSwap_Hint",
>-    "__glXDispSwap_Histogram",
>-    "__glXDispSwap_IndexMask",
>-    "__glXDispSwap_Indexdv",
>-    "__glXDispSwap_Indexfv",
>-    "__glXDispSwap_Indexiv",
>-    "__glXDispSwap_Indexsv",
>-    "__glXDispSwap_Indexubv",
>-    "__glXDispSwap_InitNames",
>-    "__glXDispSwap_IsEnabled",
>-    "__glXDispSwap_IsList",
>-    "__glXDispSwap_IsTexture",
>-    "__glXDispSwap_IsTextureEXT",
>-    "__glXDispSwap_LightModelf",
>-    "__glXDispSwap_LightModelfv",
>-    "__glXDispSwap_LightModeli",
>-    "__glXDispSwap_LightModeliv",
>-    "__glXDispSwap_Lightf",
>-    "__glXDispSwap_Lightfv",
>-    "__glXDispSwap_Lighti",
>-    "__glXDispSwap_Lightiv",
>-    "__glXDispSwap_LineStipple",
>-    "__glXDispSwap_LineWidth",
>-    "__glXDispSwap_ListBase",
>-    "__glXDispSwap_LoadIdentity",
>-    "__glXDispSwap_LoadMatrixd",
>-    "__glXDispSwap_LoadMatrixf",
>-    "__glXDispSwap_LoadName",
>-    "__glXDispSwap_LogicOp",
>-    "__glXDispSwap_Map1d",
>-    "__glXDispSwap_Map1f",
>-    "__glXDispSwap_Map2d",
>-    "__glXDispSwap_Map2f",
>-    "__glXDispSwap_MapGrid1d",
>-    "__glXDispSwap_MapGrid1f",
>-    "__glXDispSwap_MapGrid2d",
>-    "__glXDispSwap_MapGrid2f",
>-    "__glXDispSwap_Materialf",
>-    "__glXDispSwap_Materialfv",
>-    "__glXDispSwap_Materiali",
>-    "__glXDispSwap_Materialiv",
>-    "__glXDispSwap_MatrixMode",
>-    "__glXDispSwap_Minmax",
>-    "__glXDispSwap_MultMatrixd",
>-    "__glXDispSwap_MultMatrixf",
>-    "__glXDispSwap_MultiTexCoord1dvARB",
>-    "__glXDispSwap_MultiTexCoord1fvARB",
>-    "__glXDispSwap_MultiTexCoord1ivARB",
>-    "__glXDispSwap_MultiTexCoord1svARB",
>-    "__glXDispSwap_MultiTexCoord2dvARB",
>-    "__glXDispSwap_MultiTexCoord2fvARB",
>-    "__glXDispSwap_MultiTexCoord2ivARB",
>-    "__glXDispSwap_MultiTexCoord2svARB",
>-    "__glXDispSwap_MultiTexCoord3dvARB",
>-    "__glXDispSwap_MultiTexCoord3fvARB",
>-    "__glXDispSwap_MultiTexCoord3ivARB",
>-    "__glXDispSwap_MultiTexCoord3svARB",
>-    "__glXDispSwap_MultiTexCoord4dvARB",
>-    "__glXDispSwap_MultiTexCoord4fvARB",
>-    "__glXDispSwap_MultiTexCoord4ivARB",
>-    "__glXDispSwap_MultiTexCoord4svARB",
>-    "__glXDispSwap_NewList",
>-    "__glXDispSwap_Normal3bv",
>-    "__glXDispSwap_Normal3dv",
>-    "__glXDispSwap_Normal3fv",
>-    "__glXDispSwap_Normal3iv",
>-    "__glXDispSwap_Normal3sv",
>-    "__glXDispSwap_Ortho",
>-    "__glXDispSwap_PassThrough",
>-    "__glXDispSwap_PixelMapfv",
>-    "__glXDispSwap_PixelMapuiv",
>-    "__glXDispSwap_PixelMapusv",
>-    "__glXDispSwap_PixelStoref",
>-    "__glXDispSwap_PixelStorei",
>-    "__glXDispSwap_PixelTransferf",
>-    "__glXDispSwap_PixelTransferi",
>-    "__glXDispSwap_PixelZoom",
>-    "__glXDispSwap_PointParameterfARB",
>-    "__glXDispSwap_PointParameterfvARB",
>-    "__glXDispSwap_PointSize",
>-    "__glXDispSwap_PolygonMode",
>-    "__glXDispSwap_PolygonOffset",
>-    "__glXDispSwap_PolygonStipple",
>-    "__glXDispSwap_PopAttrib",
>-    "__glXDispSwap_PopMatrix",
>-    "__glXDispSwap_PopName",
>-    "__glXDispSwap_PrioritizeTextures",
>-    "__glXDispSwap_PushAttrib",
>-    "__glXDispSwap_PushMatrix",
>-    "__glXDispSwap_PushName",
>-    "__glXDispSwap_RasterPos2dv",
>-    "__glXDispSwap_RasterPos2fv",
>-    "__glXDispSwap_RasterPos2iv",
>-    "__glXDispSwap_RasterPos2sv",
>-    "__glXDispSwap_RasterPos3dv",
>-    "__glXDispSwap_RasterPos3fv",
>-    "__glXDispSwap_RasterPos3iv",
>-    "__glXDispSwap_RasterPos3sv",
>-    "__glXDispSwap_RasterPos4dv",
>-    "__glXDispSwap_RasterPos4fv",
>-    "__glXDispSwap_RasterPos4iv",
>-    "__glXDispSwap_RasterPos4sv",
>-    "__glXDispSwap_ReadBuffer",
>-    "__glXDispSwap_ReadPixels",
>-    "__glXDispSwap_Rectdv",
>-    "__glXDispSwap_Rectfv",
>-    "__glXDispSwap_Rectiv",
>-    "__glXDispSwap_Rectsv",
>-    "__glXDispSwap_RenderMode",
>-    "__glXDispSwap_ResetHistogram",
>-    "__glXDispSwap_ResetMinmax",
>-    "__glXDispSwap_Rotated",
>-    "__glXDispSwap_Rotatef",
>-    "__glXDispSwap_Scaled",
>-    "__glXDispSwap_Scalef",
>-    "__glXDispSwap_Scissor",
>-    "__glXDispSwap_SelectBuffer",
>-    "__glXDispSwap_SeparableFilter2D",
>-    "__glXDispSwap_ShadeModel",
>-    "__glXDispSwap_StencilFunc",
>-    "__glXDispSwap_StencilMask",
>-    "__glXDispSwap_StencilOp",
>-    "__glXDispSwap_TexCoord1dv",
>-    "__glXDispSwap_TexCoord1fv",
>-    "__glXDispSwap_TexCoord1iv",
>-    "__glXDispSwap_TexCoord1sv",
>-    "__glXDispSwap_TexCoord2dv",
>-    "__glXDispSwap_TexCoord2fv",
>-    "__glXDispSwap_TexCoord2iv",
>-    "__glXDispSwap_TexCoord2sv",
>-    "__glXDispSwap_TexCoord3dv",
>-    "__glXDispSwap_TexCoord3fv",
>-    "__glXDispSwap_TexCoord3iv",
>-    "__glXDispSwap_TexCoord3sv",
>-    "__glXDispSwap_TexCoord4dv",
>-    "__glXDispSwap_TexCoord4fv",
>-    "__glXDispSwap_TexCoord4iv",
>-    "__glXDispSwap_TexCoord4sv",
>-    "__glXDispSwap_TexEnvf",
>-    "__glXDispSwap_TexEnvfv",
>-    "__glXDispSwap_TexEnvi",
>-    "__glXDispSwap_TexEnviv",
>-    "__glXDispSwap_TexGend",
>-    "__glXDispSwap_TexGendv",
>-    "__glXDispSwap_TexGenf",
>-    "__glXDispSwap_TexGenfv",
>-    "__glXDispSwap_TexGeni",
>-    "__glXDispSwap_TexGeniv",
>-    "__glXDispSwap_TexImage1D",
>-    "__glXDispSwap_TexImage2D",
>-    "__glXDispSwap_TexImage3D",
>-    "__glXDispSwap_TexParameterf",
>-    "__glXDispSwap_TexParameterfv",
>-    "__glXDispSwap_TexParameteri",
>-    "__glXDispSwap_TexParameteriv",
>-    "__glXDispSwap_TexSubImage1D",
>-    "__glXDispSwap_TexSubImage2D",
>-    "__glXDispSwap_TexSubImage3D",
>-    "__glXDispSwap_Translated",
>-    "__glXDispSwap_Translatef",
>-    "__glXDispSwap_Vertex2dv",
>-    "__glXDispSwap_Vertex2fv",
>-    "__glXDispSwap_Vertex2iv",
>-    "__glXDispSwap_Vertex2sv",
>-    "__glXDispSwap_Vertex3dv",
>-    "__glXDispSwap_Vertex3fv",
>-    "__glXDispSwap_Vertex3iv",
>-    "__glXDispSwap_Vertex3sv",
>-    "__glXDispSwap_Vertex4dv",
>-    "__glXDispSwap_Vertex4fv",
>-    "__glXDispSwap_Vertex4iv",
>-    "__glXDispSwap_Vertex4sv",
>-    "__glXDispSwap_Viewport",
>-    "__glXDispSwap_WindowPos3fARB",
>-    "__glXDisp_Accum",
>-    "__glXDisp_ActiveStencilFaceEXT",
>-    "__glXDisp_ActiveTextureARB",
>-    "__glXDisp_AlphaFunc",
>-    "__glXDisp_AreTexturesResident",
>-    "__glXDisp_AreTexturesResidentEXT",
>-    "__glXDisp_Begin",
>-    "__glXDisp_BindTexture",
>-    "__glXDisp_Bitmap",
>-    "__glXDisp_BlendColor",
>-    "__glXDisp_BlendEquation",
>-    "__glXDisp_BlendFunc",
>-    "__glXDisp_CallList",
>-    "__glXDisp_CallLists",
>-    "__glXDisp_Clear",
>-    "__glXDisp_ClearAccum",
>-    "__glXDisp_ClearColor",
>-    "__glXDisp_ClearDepth",
>-    "__glXDisp_ClearIndex",
>-    "__glXDisp_ClearStencil",
>-    "__glXDisp_ClipPlane",
>-    "__glXDisp_Color3bv",
>-    "__glXDisp_Color3dv",
>-    "__glXDisp_Color3fv",
>-    "__glXDisp_Color3iv",
>-    "__glXDisp_Color3sv",
>-    "__glXDisp_Color3ubv",
>-    "__glXDisp_Color3uiv",
>-    "__glXDisp_Color3usv",
>-    "__glXDisp_Color4bv",
>-    "__glXDisp_Color4dv",
>-    "__glXDisp_Color4fv",
>-    "__glXDisp_Color4iv",
>-    "__glXDisp_Color4sv",
>-    "__glXDisp_Color4ubv",
>-    "__glXDisp_Color4uiv",
>-    "__glXDisp_Color4usv",
>-    "__glXDisp_ColorMask",
>-    "__glXDisp_ColorMaterial",
>-    "__glXDisp_ColorSubTable",
>-    "__glXDisp_ColorTable",
>-    "__glXDisp_ColorTableParameterfv",
>-    "__glXDisp_ColorTableParameteriv",
>-    "__glXDisp_ConvolutionFilter1D",
>-    "__glXDisp_ConvolutionFilter2D",
>-    "__glXDisp_ConvolutionParameterf",
>-    "__glXDisp_ConvolutionParameterfv",
>-    "__glXDisp_ConvolutionParameteri",
>-    "__glXDisp_ConvolutionParameteriv",
>-    "__glXDisp_CopyColorSubTable",
>-    "__glXDisp_CopyColorTable",
>-    "__glXDisp_CopyConvolutionFilter1D",
>-    "__glXDisp_CopyConvolutionFilter2D",
>-    "__glXDisp_CopyPixels",
>-    "__glXDisp_CopyTexImage1D",
>-    "__glXDisp_CopyTexImage2D",
>-    "__glXDisp_CopyTexSubImage1D",
>-    "__glXDisp_CopyTexSubImage2D",
>-    "__glXDisp_CopyTexSubImage3D",
>-    "__glXDisp_CullFace",
>-    "__glXDisp_DeleteLists",
>-    "__glXDisp_DeleteTextures",
>-    "__glXDisp_DeleteTexturesEXT",
>-    "__glXDisp_DepthFunc",
>-    "__glXDisp_DepthMask",
>-    "__glXDisp_DepthRange",
>-    "__glXDisp_Disable",
>-    "__glXDisp_DrawArrays",
>-    "__glXDisp_DrawArraysEXT",
>-    "__glXDisp_DrawBuffer",
>-    "__glXDisp_DrawPixels",
>-    "__glXDisp_EdgeFlagv",
>-    "__glXDisp_Enable",
>-    "__glXDisp_End",
>-    "__glXDisp_EndList",
>-    "__glXDisp_EvalCoord1dv",
>-    "__glXDisp_EvalCoord1fv",
>-    "__glXDisp_EvalCoord2dv",
>-    "__glXDisp_EvalCoord2fv",
>-    "__glXDisp_EvalMesh1",
>-    "__glXDisp_EvalMesh2",
>-    "__glXDisp_EvalPoint1",
>-    "__glXDisp_EvalPoint2",
>-    "__glXDisp_FeedbackBuffer",
>-    "__glXDisp_Finish",
>-    "__glXDisp_Flush",
>-    "__glXDisp_Fogf",
>-    "__glXDisp_Fogfv",
>-    "__glXDisp_Fogi",
>-    "__glXDisp_Fogiv",
>-    "__glXDisp_FrontFace",
>-    "__glXDisp_Frustum",
>-    "__glXDisp_GenLists",
>-    "__glXDisp_GenTextures",
>-    "__glXDisp_GenTexturesEXT",
>-    "__glXDisp_GetBooleanv",
>-    "__glXDisp_GetClipPlane",
>-    "__glXDisp_GetColorTable",
>-    "__glXDisp_GetColorTableParameterfv",
>-    "__glXDisp_GetColorTableParameteriv",
>-    "__glXDisp_GetConvolutionFilter",
>-    "__glXDisp_GetConvolutionParameterfv",
>-    "__glXDisp_GetConvolutionParameteriv",
>-    "__glXDisp_GetDoublev",
>-    "__glXDisp_GetError",
>-    "__glXDisp_GetFloatv",
>-    "__glXDisp_GetHistogram",
>-    "__glXDisp_GetHistogramParameterfv",
>-    "__glXDisp_GetHistogramParameteriv",
>-    "__glXDisp_GetIntegerv",
>-    "__glXDisp_GetLightfv",
>-    "__glXDisp_GetLightiv",
>-    "__glXDisp_GetMapdv",
>-    "__glXDisp_GetMapfv",
>-    "__glXDisp_GetMapiv",
>-    "__glXDisp_GetMaterialfv",
>-    "__glXDisp_GetMaterialiv",
>-    "__glXDisp_GetMinmax",
>-    "__glXDisp_GetMinmaxParameterfv",
>-    "__glXDisp_GetMinmaxParameteriv",
>-    "__glXDisp_GetPixelMapfv",
>-    "__glXDisp_GetPixelMapuiv",
>-    "__glXDisp_GetPixelMapusv",
>-    "__glXDisp_GetPolygonStipple",
>-    "__glXDisp_GetSeparableFilter",
>-    "__glXDisp_GetString",
>-    "__glXDisp_GetTexEnvfv",
>-    "__glXDisp_GetTexEnviv",
>-    "__glXDisp_GetTexGendv",
>-    "__glXDisp_GetTexGenfv",
>-    "__glXDisp_GetTexGeniv",
>-    "__glXDisp_GetTexImage",
>-    "__glXDisp_GetTexLevelParameterfv",
>-    "__glXDisp_GetTexLevelParameteriv",
>-    "__glXDisp_GetTexParameterfv",
>-    "__glXDisp_GetTexParameteriv",
>-    "__glXDisp_Hint",
>-    "__glXDisp_Histogram",
>-    "__glXDisp_IndexMask",
>-    "__glXDisp_Indexdv",
>-    "__glXDisp_Indexfv",
>-    "__glXDisp_Indexiv",
>-    "__glXDisp_Indexsv",
>-    "__glXDisp_Indexubv",
>-    "__glXDisp_InitNames",
>-    "__glXDisp_IsEnabled",
>-    "__glXDisp_IsList",
>-    "__glXDisp_IsTexture",
>-    "__glXDisp_IsTextureEXT",
>-    "__glXDisp_LightModelf",
>-    "__glXDisp_LightModelfv",
>-    "__glXDisp_LightModeli",
>-    "__glXDisp_LightModeliv",
>-    "__glXDisp_Lightf",
>-    "__glXDisp_Lightfv",
>-    "__glXDisp_Lighti",
>-    "__glXDisp_Lightiv",
>-    "__glXDisp_LineStipple",
>-    "__glXDisp_LineWidth",
>-    "__glXDisp_ListBase",
>-    "__glXDisp_LoadIdentity",
>-    "__glXDisp_LoadMatrixd",
>-    "__glXDisp_LoadMatrixf",
>-    "__glXDisp_LoadName",
>-    "__glXDisp_LogicOp",
>-    "__glXDisp_Map1d",
>-    "__glXDisp_Map1f",
>-    "__glXDisp_Map2d",
>-    "__glXDisp_Map2f",
>-    "__glXDisp_MapGrid1d",
>-    "__glXDisp_MapGrid1f",
>-    "__glXDisp_MapGrid2d",
>-    "__glXDisp_MapGrid2f",
>-    "__glXDisp_Materialf",
>-    "__glXDisp_Materialfv",
>-    "__glXDisp_Materiali",
>-    "__glXDisp_Materialiv",
>-    "__glXDisp_MatrixMode",
>-    "__glXDisp_Minmax",
>-    "__glXDisp_MultMatrixd",
>-    "__glXDisp_MultMatrixf",
>-    "__glXDisp_MultiTexCoord1dvARB",
>-    "__glXDisp_MultiTexCoord1fvARB",
>-    "__glXDisp_MultiTexCoord1ivARB",
>-    "__glXDisp_MultiTexCoord1svARB",
>-    "__glXDisp_MultiTexCoord2dvARB",
>-    "__glXDisp_MultiTexCoord2fvARB",
>-    "__glXDisp_MultiTexCoord2ivARB",
>-    "__glXDisp_MultiTexCoord2svARB",
>-    "__glXDisp_MultiTexCoord3dvARB",
>-    "__glXDisp_MultiTexCoord3fvARB",
>-    "__glXDisp_MultiTexCoord3ivARB",
>-    "__glXDisp_MultiTexCoord3svARB",
>-    "__glXDisp_MultiTexCoord4dvARB",
>-    "__glXDisp_MultiTexCoord4fvARB",
>-    "__glXDisp_MultiTexCoord4ivARB",
>-    "__glXDisp_MultiTexCoord4svARB",
>-    "__glXDisp_NewList",
>-    "__glXDisp_Normal3bv",
>-    "__glXDisp_Normal3dv",
>-    "__glXDisp_Normal3fv",
>-    "__glXDisp_Normal3iv",
>-    "__glXDisp_Normal3sv",
>-    "__glXDisp_Ortho",
>-    "__glXDisp_PassThrough",
>-    "__glXDisp_PixelMapfv",
>-    "__glXDisp_PixelMapuiv",
>-    "__glXDisp_PixelMapusv",
>-    "__glXDisp_PixelStoref",
>-    "__glXDisp_PixelStorei",
>-    "__glXDisp_PixelTransferf",
>-    "__glXDisp_PixelTransferi",
>-    "__glXDisp_PixelZoom",
>-    "__glXDisp_PointParameterfARB",
>-    "__glXDisp_PointParameterfvARB",
>-    "__glXDisp_PointSize",
>-    "__glXDisp_PolygonMode",
>-    "__glXDisp_PolygonOffset",
>-    "__glXDisp_PolygonStipple",
>-    "__glXDisp_PopAttrib",
>-    "__glXDisp_PopMatrix",
>-    "__glXDisp_PopName",
>-    "__glXDisp_PrioritizeTextures",
>-    "__glXDisp_PushAttrib",
>-    "__glXDisp_PushMatrix",
>-    "__glXDisp_PushName",
>-    "__glXDisp_RasterPos2dv",
>-    "__glXDisp_RasterPos2fv",
>-    "__glXDisp_RasterPos2iv",
>-    "__glXDisp_RasterPos2sv",
>-    "__glXDisp_RasterPos3dv",
>-    "__glXDisp_RasterPos3fv",
>-    "__glXDisp_RasterPos3iv",
>-    "__glXDisp_RasterPos3sv",
>-    "__glXDisp_RasterPos4dv",
>-    "__glXDisp_RasterPos4fv",
>-    "__glXDisp_RasterPos4iv",
>-    "__glXDisp_RasterPos4sv",
>-    "__glXDisp_ReadBuffer",
>-    "__glXDisp_ReadPixels",
>-    "__glXDisp_Rectdv",
>-    "__glXDisp_Rectfv",
>-    "__glXDisp_Rectiv",
>-    "__glXDisp_Rectsv",
>-    "__glXDisp_RenderMode",
>-    "__glXDisp_ResetHistogram",
>-    "__glXDisp_ResetMinmax",
>-    "__glXDisp_Rotated",
>-    "__glXDisp_Rotatef",
>-    "__glXDisp_Scaled",
>-    "__glXDisp_Scalef",
>-    "__glXDisp_Scissor",
>-    "__glXDisp_SelectBuffer",
>-    "__glXDisp_SeparableFilter2D",
>-    "__glXDisp_ShadeModel",
>-    "__glXDisp_StencilFunc",
>-    "__glXDisp_StencilMask",
>-    "__glXDisp_StencilOp",
>-    "__glXDisp_TexCoord1dv",
>-    "__glXDisp_TexCoord1fv",
>-    "__glXDisp_TexCoord1iv",
>-    "__glXDisp_TexCoord1sv",
>-    "__glXDisp_TexCoord2dv",
>-    "__glXDisp_TexCoord2fv",
>-    "__glXDisp_TexCoord2iv",
>-    "__glXDisp_TexCoord2sv",
>-    "__glXDisp_TexCoord3dv",
>-    "__glXDisp_TexCoord3fv",
>-    "__glXDisp_TexCoord3iv",
>-    "__glXDisp_TexCoord3sv",
>-    "__glXDisp_TexCoord4dv",
>-    "__glXDisp_TexCoord4fv",
>-    "__glXDisp_TexCoord4iv",
>-    "__glXDisp_TexCoord4sv",
>-    "__glXDisp_TexEnvf",
>-    "__glXDisp_TexEnvfv",
>-    "__glXDisp_TexEnvi",
>-    "__glXDisp_TexEnviv",
>-    "__glXDisp_TexGend",
>-    "__glXDisp_TexGendv",
>-    "__glXDisp_TexGenf",
>-    "__glXDisp_TexGenfv",
>-    "__glXDisp_TexGeni",
>-    "__glXDisp_TexGeniv",
>-    "__glXDisp_TexImage1D",
>-    "__glXDisp_TexImage2D",
>-    "__glXDisp_TexImage3D",
>-    "__glXDisp_TexParameterf",
>-    "__glXDisp_TexParameterfv",
>-    "__glXDisp_TexParameteri",
>-    "__glXDisp_TexParameteriv",
>-    "__glXDisp_TexSubImage1D",
>-    "__glXDisp_TexSubImage2D",
>-    "__glXDisp_TexSubImage3D",
>-    "__glXDisp_Translated",
>-    "__glXDisp_Translatef",
>-    "__glXDisp_Vertex2dv",
>-    "__glXDisp_Vertex2fv",
>-    "__glXDisp_Vertex2iv",
>-    "__glXDisp_Vertex2sv",
>-    "__glXDisp_Vertex3dv",
>-    "__glXDisp_Vertex3fv",
>-    "__glXDisp_Vertex3iv",
>-    "__glXDisp_Vertex3sv",
>-    "__glXDisp_Vertex4dv",
>-    "__glXDisp_Vertex4fv",
>-    "__glXDisp_Vertex4iv",
>-    "__glXDisp_Vertex4sv",
>-    "__glXDisp_Viewport",
>-    "__glXDisp_WindowPos3fARB",
>-    "__glXDrawArraysSize",
>-    "__glXDrawPixelsReqSize",
>-    "__glXDrawableRes",
>-    "__glXErrorOccured",
>-    "__glXFBInitDrawable",
>-    "__glXFBMemSwapBuffers",
>-    "__glXFindDrawablePrivate",
>-    "__glXFogfvReqSize",
>-    "__glXFogivReqSize",
>-    "__glXForceCurrent",
>-    "__glXFree",
>-    "__glXFreeBuffers",
>-    "__glXFreeContext",
>-    "__glXGetDrawablePrivate",
>-    "__glXGetVisualConfigs",
>-    "__glXImageSize",
>-    "__glXImpAtoi",
>-    "__glXImpCalloc",
>-    "__glXImpFatal",
>-    "__glXImpFclose",
>-    "__glXImpFopen",
>-    "__glXImpFprintf",
>-    "__glXImpFree",
>-    "__glXImpGetDrawablePrivate",
>-    "__glXImpGetenv",
>-    "__glXImpMalloc",
>-    "__glXImpRealloc",
>-    "__glXImpSprintf",
>-    "__glXImpWarning",
>-    "__glXInitFB",
>-    "__glXInitMem",
>-    "__glXInitPix",
>-    "__glXIsDirect",
>-    "__glXLastContext",
>-    "__glXLightModelfvReqSize",
>-    "__glXLightModelivReqSize",
>-    "__glXLightfvReqSize",
>-    "__glXLightivReqSize",
>-    "__glXLookupContextByTag",
>-    "__glXMakeCurrent",
>-    "__glXMalloc",
>-    "__glXMap1dReqSize",
>-    "__glXMap1fReqSize",
>-    "__glXMap2dReqSize",
>-    "__glXMap2fReqSize",
>-    "__glXMaterialfvReqSize",
>-    "__glXMaterialivReqSize",
>-    "__glXNoSuchRenderOpcode",
>-    "__glXNoSuchSingleOpcode",
>-    "__glXNop",
>-    "__glXPixInitDrawable",
>-    "__glXPixelMapfvReqSize",
>-    "__glXPixelMapuivReqSize",
>-    "__glXPixelMapusvReqSize",
>-    "__glXPixmapRes",
>-    "__glXPrioritizeTexturesReqSize",
>-    "__glXQueryContextInfoEXT",
>-    "__glXQueryExtensionsString",
>-    "__glXQueryServerString",
>-    "__glXQueryVersion",
>-    "__glXRealloc",
>-    "__glXRender",
>-    "__glXRenderLarge",
>-    "__glXRenderSizeTable",
>-    "__glXRenderSizeTable_EXT",
>-    "__glXRenderTable",
>-    "__glXRenderTable_EXT",
>-    "__glXReply",
>-    "__glXResetLargeCommandStatus",
>-    "__glXResizeBuffers",
>-    "__glXResizeDrawableBuffers",
>-    "__glXScreenInit",
>-    "__glXScreenReset",
>-    "__glXSeparableFilter2DReqSize",
>-    "__glXSingleTable",
>-    "__glXSwapBuffers",
>-    "__glXSwapClientInfo",
>-    "__glXSwapCopyContext",
>-    "__glXSwapCreateContext",
>-    "__glXSwapCreateGLXPixmap",
>-    "__glXSwapDestroyContext",
>-    "__glXSwapDestroyGLXPixmap",
>-    "__glXSwapGetVisualConfigs",
>-    "__glXSwapIsDirect",
>-    "__glXSwapIsDirectReply",
>-    "__glXSwapMakeCurrent",
>-    "__glXSwapMakeCurrentReply",
>-    "__glXSwapQueryContextInfoEXTReply",
>-    "__glXSwapQueryExtensionsString",
>-    "__glXSwapQueryServerString",
>-    "__glXSwapQueryVersion",
>-    "__glXSwapQueryVersionReply",
>-    "__glXSwapRender",
>-    "__glXSwapRenderLarge",
>-    "__glXSwapRenderTable",
>-    "__glXSwapRenderTable_EXT",
>-    "__glXSwapSingleTable",
>-    "__glXSwapSwapBuffers",
>-    "__glXSwapUseXFont",
>-    "__glXSwapVendorPrivTable_EXT",
>-    "__glXSwapVendorPrivate",
>-    "__glXSwapVendorPrivateWithReply",
>-    "__glXSwapWaitGL",
>-    "__glXSwapWaitX",
>-    "__glXTexEnvfvReqSize",
>-    "__glXTexEnvivReqSize",
>-    "__glXTexGendvReqSize",
>-    "__glXTexGenfvReqSize",
>-    "__glXTexGenivReqSize",
>-    "__glXTexImage1DReqSize",
>-    "__glXTexImage2DReqSize",
>-    "__glXTexImage3DReqSize",
>-    "__glXTexParameterfvReqSize",
>-    "__glXTexParameterivReqSize",
>-    "__glXTexSubImage1DReqSize",
>-    "__glXTexSubImage2DReqSize",
>-    "__glXTexSubImage3DReqSize",
>-    "__glXTypeSize",
>-    "__glXUnrefDrawablePrivate",
>-    "__glXUnsupportedPrivateRequest",
>-    "__glXUseXFont",
>-    "__glXVendorPrivTable_EXT",
>-    "__glXVendorPrivate",
>-    "__glXVendorPrivateWithReply",
>-    "__glXWaitGL",
>-    "__glXWaitX",
>-    "__glXcombine_strings",
>-    "glAccum",
>-    "glActiveStencilFaceEXT",
>-    "glActiveTextureARB",
>-    "glAlphaFunc",
>-    "glAreTexturesResident",
>-    "glAreTexturesResidentEXT",
>-    "glBegin",
>-    "glBindTexture",
>-    "glBitmap",
>-    "glBlendColor",
>-    "glBlendEquation",
>-    "glBlendFunc",
>-    "glCallList",
>-    "glCallLists",
>-    "glClear",
>-    "glClearAccum",
>-    "glClearColor",
>-    "glClearDepth",
>-    "glClearIndex",
>-    "glClearStencil",
>-    "glClipPlane",
>-    "glColor3bv",
>-    "glColor3dv",
>-    "glColor3fv",
>-    "glColor3iv",
>-    "glColor3sv",
>-    "glColor3ubv",
>-    "glColor3uiv",
>-    "glColor3usv",
>-    "glColor4bv",
>-    "glColor4dv",
>-    "glColor4fv",
>-    "glColor4iv",
>-    "glColor4sv",
>-    "glColor4ubv",
>-    "glColor4uiv",
>-    "glColor4usv",
>-    "glColorMask",
>-    "glColorMaterial",
>-    "glColorPointer",
>-    "glColorSubTable",
>-    "glColorTable",
>-    "glColorTableParameterfv",
>-    "glColorTableParameteriv",
>-    "glConvolutionFilter1D",
>-    "glConvolutionFilter2D",
>-    "glConvolutionParameterf",
>-    "glConvolutionParameterfv",
>-    "glConvolutionParameteri",
>-    "glConvolutionParameteriv",
>-    "glCopyColorSubTable",
>-    "glCopyColorTable",
>-    "glCopyConvolutionFilter1D",
>-    "glCopyConvolutionFilter2D",
>-    "glCopyPixels",
>-    "glCopyTexImage1D",
>-    "glCopyTexImage2D",
>-    "glCopyTexSubImage1D",
>-    "glCopyTexSubImage2D",
>-    "glCopyTexSubImage3D",
>-    "glCullFace",
>-    "glDeleteLists",
>-    "glDeleteTextures",
>-    "glDeleteTexturesEXT",
>-    "glDepthFunc",
>-    "glDepthMask",
>-    "glDepthRange",
>-    "glDisable",
>-    "glDisableClientState",
>-    "glDrawArrays",
>-    "glDrawBuffer",
>-    "glDrawPixels",
>-    "glEdgeFlagPointer",
>-    "glEdgeFlagv",
>-    "glEnable",
>-    "glEnableClientState",
>-    "glEnd",
>-    "glEndList",
>-    "glEvalCoord1dv",
>-    "glEvalCoord1fv",
>-    "glEvalCoord2dv",
>-    "glEvalCoord2fv",
>-    "glEvalMesh1",
>-    "glEvalMesh2",
>-    "glEvalPoint1",
>-    "glEvalPoint2",
>-    "glFeedbackBuffer",
>-    "glFinish",
>-    "glFlush",
>-    "glFogf",
>-    "glFogfv",
>-    "glFogi",
>-    "glFogiv",
>-    "glFrontFace",
>-    "glFrustum",
>-    "glGenLists",
>-    "glGenTextures",
>-    "glGenTexturesEXT",
>-    "glGetBooleanv",
>-    "glGetClipPlane",
>-    "glGetColorTable",
>-    "glGetColorTableParameterfv",
>-    "glGetColorTableParameteriv",
>-    "glGetConvolutionFilter",
>-    "glGetConvolutionParameterfv",
>-    "glGetConvolutionParameteriv",
>-    "glGetDoublev",
>-    "glGetError",
>-    "glGetFloatv",
>-    "glGetHistogram",
>-    "glGetHistogramParameterfv",
>-    "glGetHistogramParameteriv",
>-    "glGetIntegerv",
>-    "glGetLightfv",
>-    "glGetLightiv",
>-    "glGetMapdv",
>-    "glGetMapfv",
>-    "glGetMapiv",
>-    "glGetMaterialfv",
>-    "glGetMaterialiv",
>-    "glGetMinmax",
>-    "glGetMinmaxParameterfv",
>-    "glGetMinmaxParameteriv",
>-    "glGetPixelMapfv",
>-    "glGetPixelMapuiv",
>-    "glGetPixelMapusv",
>-    "glGetPolygonStipple",
>-    "glGetSeparableFilter",
>-    "glGetString",
>-    "glGetTexEnvfv",
>-    "glGetTexEnviv",
>-    "glGetTexGendv",
>-    "glGetTexGenfv",
>-    "glGetTexGeniv",
>-    "glGetTexImage",
>-    "glGetTexLevelParameterfv",
>-    "glGetTexLevelParameteriv",
>-    "glGetTexParameterfv",
>-    "glGetTexParameteriv",
>-    "glHint",
>-    "glHistogram",
>-    "glIndexMask",
>-    "glIndexPointer",
>-    "glIndexdv",
>-    "glIndexfv",
>-    "glIndexiv",
>-    "glIndexsv",
>-    "glIndexubv",
>-    "glInitNames",
>-    "glIsEnabled",
>-    "glIsList",
>-    "glIsTexture",
>-    "glIsTextureEXT",
>-    "glLightModelf",
>-    "glLightModelfv",
>-    "glLightModeli",
>-    "glLightModeliv",
>-    "glLightf",
>-    "glLightfv",
>-    "glLighti",
>-    "glLightiv",
>-    "glLineStipple",
>-    "glLineWidth",
>-    "glListBase",
>-    "glLoadIdentity",
>-    "glLoadMatrixd",
>-    "glLoadMatrixf",
>-    "glLoadName",
>-    "glLogicOp",
>-    "glMap1d",
>-    "glMap1f",
>-    "glMap2d",
>-    "glMap2f",
>-    "glMapGrid1d",
>-    "glMapGrid1f",
>-    "glMapGrid2d",
>-    "glMapGrid2f",
>-    "glMaterialf",
>-    "glMaterialfv",
>-    "glMateriali",
>-    "glMaterialiv",
>-    "glMatrixMode",
>-    "glMinmax",
>-    "glMultMatrixd",
>-    "glMultMatrixf",
>-    "glMultiTexCoord1dvARB",
>-    "glMultiTexCoord1fvARB",
>-    "glMultiTexCoord1ivARB",
>-    "glMultiTexCoord1svARB",
>-    "glMultiTexCoord2dvARB",
>-    "glMultiTexCoord2fvARB",
>-    "glMultiTexCoord2ivARB",
>-    "glMultiTexCoord2svARB",
>-    "glMultiTexCoord3dvARB",
>-    "glMultiTexCoord3fvARB",
>-    "glMultiTexCoord3ivARB",
>-    "glMultiTexCoord3svARB",
>-    "glMultiTexCoord4dvARB",
>-    "glMultiTexCoord4fvARB",
>-    "glMultiTexCoord4ivARB",
>-    "glMultiTexCoord4svARB",
>-    "glNewList",
>-    "glNormal3bv",
>-    "glNormal3dv",
>-    "glNormal3fv",
>-    "glNormal3iv",
>-    "glNormal3sv",
>-    "glNormalPointer",
>-    "glOrtho",
>-    "glPassThrough",
>-    "glPixelMapfv",
>-    "glPixelMapuiv",
>-    "glPixelMapusv",
>-    "glPixelStoref",
>-    "glPixelStorei",
>-    "glPixelTransferf",
>-    "glPixelTransferi",
>-    "glPixelZoom",
>-    "glPointParameterfARB",
>-    "glPointParameterfvARB",
>-    "glPointSize",
>-    "glPolygonMode",
>-    "glPolygonOffset",
>-    "glPolygonStipple",
>-    "glPopAttrib",
>-    "glPopMatrix",
>-    "glPopName",
>-    "glPrioritizeTextures",
>-    "glPushAttrib",
>-    "glPushMatrix",
>-    "glPushName",
>-    "glRasterPos2dv",
>-    "glRasterPos2fv",
>-    "glRasterPos2iv",
>-    "glRasterPos2sv",
>-    "glRasterPos3dv",
>-    "glRasterPos3fv",
>-    "glRasterPos3iv",
>-    "glRasterPos3sv",
>-    "glRasterPos4dv",
>-    "glRasterPos4fv",
>-    "glRasterPos4iv",
>-    "glRasterPos4sv",
>-    "glReadBuffer",
>-    "glReadPixels",
>-    "glRectdv",
>-    "glRectfv",
>-    "glRectiv",
>-    "glRectsv",
>-    "glRenderMode",
>-    "glResetHistogram",
>-    "glResetMinmax",
>-    "glRotated",
>-    "glRotatef",
>-    "glScaled",
>-    "glScalef",
>-    "glScissor",
>-    "glSelectBuffer",
>-    "glSeparableFilter2D",
>-    "glShadeModel",
>-    "glStencilFunc",
>-    "glStencilMask",
>-    "glStencilOp",
>-    "glTexCoord1dv",
>-    "glTexCoord1fv",
>-    "glTexCoord1iv",
>-    "glTexCoord1sv",
>-    "glTexCoord2dv",
>-    "glTexCoord2fv",
>-    "glTexCoord2iv",
>-    "glTexCoord2sv",
>-    "glTexCoord3dv",
>-    "glTexCoord3fv",
>-    "glTexCoord3iv",
>-    "glTexCoord3sv",
>-    "glTexCoord4dv",
>-    "glTexCoord4fv",
>-    "glTexCoord4iv",
>-    "glTexCoord4sv",
>-    "glTexCoordPointer",
>-    "glTexEnvf",
>-    "glTexEnvfv",
>-    "glTexEnvi",
>-    "glTexEnviv",
>-    "glTexGend",
>-    "glTexGendv",
>-    "glTexGenf",
>-    "glTexGenfv",
>-    "glTexGeni",
>-    "glTexGeniv",
>-    "glTexImage1D",
>-    "glTexImage2D",
>-    "glTexImage3D",
>-    "glTexParameterf",
>-    "glTexParameterfv",
>-    "glTexParameteri",
>-    "glTexParameteriv",
>-    "glTexSubImage1D",
>-    "glTexSubImage2D",
>-    "glTexSubImage3D",
>-    "glTranslated",
>-    "glTranslatef",
>-    "glVertex2dv",
>-    "glVertex2fv",
>-    "glVertex2iv",
>-    "glVertex2sv",
>-    "glVertex3dv",
>-    "glVertex3fv",
>-    "glVertex3iv",
>-    "glVertex3sv",
>-    "glVertex4dv",
>-    "glVertex4fv",
>-    "glVertex4iv",
>-    "glVertex4sv",
>-    "glVertexPointer",
>-    "glViewport",
>-    "glWindowPos3fARB",
>-    "glxSwapQueryExtensionsStringReply",
>-    "glxSwapQueryServerStringReply",
>-    NULL
>-};
>-
> static XF86ModuleVersionInfo VersRec =
> {
>         "glx",
>@@ -1240,31 +77,19 @@ static pointer
> glxSetup(pointer module, pointer opts, int *errmaj, int *errmin)
> {
>     static Bool setupDone = FALSE;
>-    pointer GLcore  = NULL;
>-#ifdef GLX_USE_SGI_SI
>-    char GLcoreName[] = "GL";
>-#else
>-    char GLcoreName[] = "GLcore";
>-#endif
> 
>     if (!setupDone) {
>     	setupDone = TRUE;
> 
>-    	GLcore = LoadSubModule(module, GLcoreName, NULL, NULL, NULL, NULL, 
>-			   errmaj, errmin);
>-    	if (!GLcore) {
>-	    if (errmaj) *errmaj = LDR_NOSUBENT;
>-    	} else {
>-	    LoaderReqSymLists(glcoreSymbols, NULL);
>-    	    LoadExtension(&GLXExt, FALSE);
>-    	    /* Wrap the init visuals routine in micmap.c */
>-    	    GlxWrapInitVisuals(&miInitVisualsProc);
>-    	    /* Make sure this gets wrapped each time InitVisualWrap is called */
>-    	    miHookInitVisuals(NULL, GlxWrapInitVisuals);
>-	}
>+	LoadExtension(&GLXExt, FALSE);
>+	/* Wrap the init visuals routine in micmap.c */
>+	GlxWrapInitVisuals(&miInitVisualsProc);
>+	/* Make sure this gets wrapped each time InitVisualWrap is called */
>+	miHookInitVisuals(NULL, GlxWrapInitVisuals);
>     } else {
> 	if (errmaj) *errmaj = LDR_ONCEONLY;
>     }
>+
>     /* Need a non-NULL return value to indicate success */
>-    return GLcore;
>+    return module;
> }
>Index: programs/Xserver/GL/dri/dri.c
>===================================================================
>RCS file: /cvs/xorg/xc/programs/Xserver/GL/dri/dri.c,v
>retrieving revision 1.16
>diff -u -p -r1.16 dri.c
>--- programs/Xserver/GL/dri/dri.c	24 Sep 2005 18:45:45 -0000	1.16
>+++ programs/Xserver/GL/dri/dri.c	8 Nov 2005 04:05:45 -0000
>@@ -43,6 +43,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN
> #include "xf86_ansic.h"
> #else
> #include <sys/time.h>
>+#include <sys/types.h>
> #include <unistd.h>
> #endif
> 
>@@ -1057,6 +1058,11 @@ DRIDestroyDrawable(ScreenPtr pScreen, Dr
>     if (pDrawable->type == DRAWABLE_WINDOW) {
> 	pWin = (WindowPtr)pDrawable;
> 	pDRIDrawablePriv = DRI_DRAWABLE_PRIV_FROM_WINDOW(pWin);
>+	/* Workaround to handle the case where both the DRI resource
>+	 * cleanup and the glx resource clean up calls this
>+	 * function. */
>+	if (pDRIDrawablePriv == NULL)
>+	    return TRUE;
> 	pDRIDrawablePriv->refCount--;
> 	if (pDRIDrawablePriv->refCount <= 0) {
> 	    /* This calls back DRIDrawablePrivDelete which frees private area */
>@@ -1924,6 +1930,17 @@ DRIUnlock(ScreenPtr pScreen)
>         DRM_UNLOCK(pDRIPriv->drmFD, pDRIPriv->pSAREA, pDRIPriv->myContext);
> }
> 
>+void
>+DRIUnlockedCallback(ScreenPtr pScreen, int flags,
>+		    DRICallback callback, void *data)
>+{
>+    DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
>+
>+    DRM_UNLOCK(pDRIPriv->drmFD, pDRIPriv->pSAREA, pDRIPriv->myContext);
>+    callback(data);
>+    DRM_LOCK(pDRIPriv->drmFD, pDRIPriv->pSAREA, pDRIPriv->myContext, flags);
>+}
>+
> void *
> DRIGetSAREAPrivate(ScreenPtr pScreen)
> {
>Index: programs/Xserver/GL/dri/dri.h
>===================================================================
>RCS file: /cvs/xorg/xc/programs/Xserver/GL/dri/dri.h,v
>retrieving revision 1.8
>diff -u -p -r1.8 dri.h
>--- programs/Xserver/GL/dri/dri.h	24 Sep 2005 18:45:45 -0000	1.8
>+++ programs/Xserver/GL/dri/dri.h	8 Nov 2005 04:05:45 -0000
>@@ -37,7 +37,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN
> #ifndef _DRI_H_
> 
> #include "scrnintstr.h"
>-#include "xf86dri.h"
>+#include "drm.h"
> 
> typedef int DRISyncType;
> 
>@@ -306,6 +306,10 @@ extern void DRILock(ScreenPtr pScreen, i
> 
> extern void DRIUnlock(ScreenPtr pScreen);
> 
>+typedef void (*DRICallback)(void *);
>+extern void DRIUnlockedCallback(ScreenPtr pScreen, int flags,
>+				DRICallback callback, void *data);
>+
> extern DRIWrappedFuncsRec *DRIGetWrappedFuncs(ScreenPtr pScreen);
> 
> extern void *DRIGetSAREAPrivate(ScreenPtr pScreen);
>Index: programs/Xserver/GL/glx/Imakefile
>===================================================================
>RCS file: /cvs/xorg/xc/programs/Xserver/GL/glx/Imakefile,v
>retrieving revision 1.8.2.1
>diff -u -p -r1.8.2.1 Imakefile
>--- programs/Xserver/GL/glx/Imakefile	3 Nov 2005 17:19:08 -0000	1.8.2.1
>+++ programs/Xserver/GL/glx/Imakefile	8 Nov 2005 04:05:45 -0000
>@@ -23,9 +23,9 @@ LinkSourceFile(indirect_size.h, $(MESASR
> LinkSourceFile(glapi.c, $(MESASRCDIR)/src/mesa/glapi)
> LinkSourceFile(glthread.c, $(MESASRCDIR)/src/mesa/glapi)
> 
>-         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 \
>+         SRCS = global.c glxcmds.c glxcmdsswap.c glxext.c \
>+		glxvisuals.c glxloader.c \
>+                glxscreens.c glxutil.c render2.c render2swap.c renderpix.c \
>                 renderpixswap.c rensize.c rensizetab.c single2.c \
>                 single2swap.c singlepix.c singlepixswap.c \
>                 singlesize.c xfont.c g_disptab.c g_disptab_EXT.c \
>@@ -36,12 +36,15 @@ LinkSourceFile(glthread.c, $(MESASRCDIR)
> 
>          OBJS = $(SRCS:.c=.o)
> 
>-     INCLUDES = -I$(SERVERSRC)/GL/glx -I$(SERVERSRC)/GL/include -I$(SERVERSRC)/include -I$(INCLUDESRC) -I$(MESASRCDIR)/include \
>+     INCLUDES = -I$(SERVERSRC)/GL/glx -I$(SERVERSRC)/GL/include \
>+		-I$(SERVERSRC)/include -I$(INCLUDESRC) \
>+		-I$(MESASRCDIR)/include \
>                 -I$(MESASRCDIR)/src/mesa/glapi \
> 		-I$(MESASRCDIR)/src/mesa/main \
>                 -I$(XINCLUDESRC) -I$(SERVERSRC)/mi \
>                 -I$(EXTINCSRC) -I$(FONTINCSRC) -I$(LIBSRC)/GL/include \
>-                -I$(XF86SRC)
>+		-I$(XF86OSSRC) -I$(XF86SRC) -I$(XF86COMSRC) \
>+		-I$(DRMSRCDIR)/shared-core
> 
> #if defined(DarwinArchitecture) && ((OSMajorVersion == 6 && OSMinorVersion < 3) || OSMajorVersion < 6)
>   NO_EXT_DEFS = -DMISSING_GL_EXTS
>Index: programs/Xserver/GL/glx/glxcmds.c
>===================================================================
>RCS file: /cvs/xorg/xc/programs/Xserver/GL/glx/glxcmds.c,v
>retrieving revision 1.8.2.1
>diff -u -p -r1.8.2.1 glxcmds.c
>--- programs/Xserver/GL/glx/glxcmds.c	3 Nov 2005 17:19:09 -0000	1.8.2.1
>+++ programs/Xserver/GL/glx/glxcmds.c	8 Nov 2005 04:05:45 -0000
>@@ -47,7 +47,6 @@
> #include <pixmapstr.h>
> #include <windowstr.h>
> #include "g_disptab_EXT.h"
>-#include "glximports.h"
> #include "glxutil.h"
> #include "glxext.h"
> #include "GL/glx_ansic.h"
>@@ -59,24 +58,6 @@
> 
> /************************************************************************/
> 
>-static __GLimports imports = {
>-    __glXImpMalloc,
>-    __glXImpCalloc,
>-    __glXImpRealloc,
>-    __glXImpFree,
>-    __glXImpWarning,
>-    __glXImpFatal,
>-    __glXImpGetenv,
>-    __glXImpAtoi,
>-    __glXImpSprintf,
>-    __glXImpFopen,
>-    __glXImpFclose,
>-    __glXImpFprintf,
>-    __glXImpGetDrawablePrivate,
>-    __glXImpGetReadablePrivate,
>-    NULL
>-};
>-
> static int __glXGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc);
> static int __glXCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
> static int __glXCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
>@@ -110,7 +91,7 @@ int DoCreateContext(__GLXclientState *cl
>     __GLXcontext *glxc, *shareglxc;
>     __GLcontextModes *modes;
>     __GLXscreenInfo *pGlxScreen;
>-    __GLinterface *shareGC;
>+    void *share;
>     GLint i;
> 
>     LEGAL_NEW_RESOURCE(gcId, client);
>@@ -165,7 +146,7 @@ int DoCreateContext(__GLXclientState *cl
>     ** for multithreaded servers, we don't do this.  
>     */
>     if (shareList == None) {
>-	shareGC = 0;
>+	share = 0;
>     } else {
> 	shareglxc = (__GLXcontext *) LookupIDByType(shareList, __glXContextRes);
> 	if (!shareglxc) {
>@@ -191,7 +172,7 @@ int DoCreateContext(__GLXclientState *cl
> 	    */
> 	    isDirect = GL_FALSE;
> 	}
>-	shareGC = shareglxc->gc;
>+	share = shareglxc->driContext.private;
>     }
> 
>     /*
>@@ -213,13 +194,11 @@ int DoCreateContext(__GLXclientState *cl
>     glxc->modes = modes;
> 
>     if (!isDirect) {
>-
>-	/*
>-	** Allocate a GL context
>-	*/
>-	imports.other = (void *)glxc;
>-	glxc->gc = (*pGlxScreen->createContext)(&imports, glxc->modes, shareGC);
>-	if (!glxc->gc) {
>+	glxc->driContext.private = 
>+	    (*pGlxScreen->driScreen.createNewContext)(NULL, modes, 0,
>+						      share,
>+						      &glxc->driContext);
>+	if (glxc->driContext.private == NULL) {
> 	    __glXFree(glxc);
> 	    client->errorValue = gcId;
> 	    return BadAlloc;
>@@ -228,14 +207,15 @@ int DoCreateContext(__GLXclientState *cl
> 	/*
> 	** Don't need local GL context for a direct context.
> 	*/
>-	glxc->gc = 0;
>+	glxc->driContext.private = NULL;
>     }
>     /*
>     ** Register this context as a resource.
>     */
>     if (!AddResource(gcId, __glXContextRes, (pointer)glxc)) {
> 	if (!isDirect) {
>-	    (*glxc->gc->exports.destroyContext)((__GLcontext *)glxc->gc);
>+	    (*glxc->driContext.destroyContext)(NULL, screen,
>+					       glxc->driContext.private);
>         }
> 	__glXFree(glxc);
> 	client->errorValue = gcId;
>@@ -518,7 +498,6 @@ int DoMakeCurrent( __GLXclientState *cl,
>     __GLXpixmap *drawPixmap = NULL;
>     __GLXpixmap *readPixmap = NULL;
>     __GLXcontext *glxc, *prevglxc;
>-    __GLinterface *gc, *prevgc;
>     __GLXdrawablePrivate *drawPriv = NULL;
>     __GLXdrawablePrivate *readPriv = NULL;
>     GLint error;
>@@ -552,10 +531,8 @@ int DoMakeCurrent( __GLXclientState *cl,
> 	    client->errorValue = prevglxc->id;
> 	    return __glXBadContextState;
> 	}
>-	prevgc = prevglxc->gc;
>     } else {
> 	prevglxc = 0;
>-	prevgc = 0;
>     }
> 
>     /*
>@@ -573,8 +550,6 @@ int DoMakeCurrent( __GLXclientState *cl,
> 	    /* Context is current to somebody else */
> 	    return BadAccess;
> 	}
>-	gc = glxc->gc;
>-
> 
> 	assert( drawId != None );
> 	assert( readId != None );
>@@ -616,7 +591,6 @@ int DoMakeCurrent( __GLXclientState *cl,
>     } else {
> 	/* Switching to no context.  Ignore new drawable. */
> 	glxc = 0;
>-	gc = 0;
> 	pDraw = 0;
> 	pRead = 0;
>     }
>@@ -638,7 +612,14 @@ int DoMakeCurrent( __GLXclientState *cl,
> 	/*
> 	** Make the previous context not current.
> 	*/
>-	if (!(*prevgc->exports.loseCurrent)((__GLcontext *)prevgc)) {
>+
>+	/* FIXME-KRH: this is where we need the looseContext function
>+	 * in the DRIcontext interface. */
>+
>+	if (!(*prevglxc->driContext.unbindContext)(NULL, pDraw->pScreen->myNum,
>+						   0, /* prev draw */
>+						   0, /* prev read */
>+						   &prevglxc->driContext)) {
> 	    return __glXBadContext;
> 	}
> 	__glXDeassociateContext(prevglxc);
>@@ -652,12 +633,15 @@ int DoMakeCurrent( __GLXclientState *cl,
> 	__glXCacheDrawableSize(drawPriv);
> 
> 	/* make the context current */
>-	if (!(*gc->exports.makeCurrent)((__GLcontext *)gc)) {
>+	if (!(*glxc->driContext.bindContext)(NULL, pDraw->pScreen->myNum,
>+					     drawId, readId,
>+					     &glxc->driContext)) {
> 	    glxc->drawPriv = NULL;
> 	    glxc->readPriv = NULL;
> 	    return __glXBadContext;
> 	}
> 
>+#if 0
> 	/* resize the buffers */
> 	if (!__glXResizeDrawableBuffers(drawPriv)) {
> 	    /* could not do initial resize.  make current failed */
>@@ -666,8 +650,11 @@ int DoMakeCurrent( __GLXclientState *cl,
> 	    glxc->readPriv = NULL;
> 	    return __glXBadContext;
> 	}
>+#endif
> 
> 	glxc->isCurrent = GL_TRUE;
>+	/* FIXME: Is this assignment ok?  Why wasn't it here already? */
>+	__glXLastContext = glxc;
> 	__glXAssociateContext(glxc);
> 	assert(drawPriv->drawGlxc == glxc);
> 	assert(readPriv->readGlxc == glxc);
>@@ -906,6 +893,11 @@ int __glXCopyContext(__GLXclientState *c
> 	    return error;
> 	}
>     }
>+
>+#if 0
>+    /* FIXME: We probably need to add DRIcontext::copyContext for
>+     * this. */
>+
>     /*
>     ** Issue copy.  The only reason for failure is a bad mask.
>     */
>@@ -915,6 +907,8 @@ int __glXCopyContext(__GLXclientState *c
> 	client->errorValue = mask;
> 	return BadValue;
>     }
>+#endif
>+
>     return Success;
> }
> 
>@@ -1353,9 +1347,7 @@ int __glXSwapBuffers(__GLXclientState *c
> 	    }
> 	}
> 
>-	if ((*glxPriv->swapBuffers)(glxPriv) == GL_FALSE) {
>-	    return __glXBadDrawable;
>-	}
>+	(*glxPriv->driDrawable.swapBuffers)(NULL, glxPriv->driDrawable.private);
>     }
> 
>     return Success;
>Index: programs/Xserver/GL/glx/glxcontext.h
>===================================================================
>RCS file: /cvs/xorg/xc/programs/Xserver/GL/glx/glxcontext.h,v
>retrieving revision 1.4
>diff -u -p -r1.4 glxcontext.h
>--- programs/Xserver/GL/glx/glxcontext.h	3 Jul 2005 07:01:02 -0000	1.4
>+++ programs/Xserver/GL/glx/glxcontext.h	8 Nov 2005 04:05:45 -0000
>@@ -47,6 +47,7 @@ typedef struct __GLXcontextRec __GLXcont
> #define CAPI
> 
> #include "GL/internal/glcore.h"
>+#include "GL/internal/dri_interface.h"
> 
> struct __GLXcontextRec {
>     /*
>@@ -62,11 +63,9 @@ struct __GLXcontextRec {
>     struct __GLXcontextRec *nextReadPriv;
> 
>     /*
>-    ** Opaque pointer the context object created by the GL that the
>-    ** server is bound with.  Never dereferenced by this code, but used
>-    ** as a handle to feed to the routines in the screen info struct.
>+    ** The DRI context initialized by the DRI driver.
>     */
>-    __GLinterface *gc;
>+    __DRIcontext driContext;
> 
>     /*
>     ** mode struct for this context
>Index: programs/Xserver/GL/glx/glxdrawable.h
>===================================================================
>RCS file: /cvs/xorg/xc/programs/Xserver/GL/glx/glxdrawable.h,v
>retrieving revision 1.4
>diff -u -p -r1.4 glxdrawable.h
>--- programs/Xserver/GL/glx/glxdrawable.h	3 Jul 2005 07:01:02 -0000	1.4
>+++ programs/Xserver/GL/glx/glxdrawable.h	8 Nov 2005 04:05:45 -0000
>@@ -92,17 +92,12 @@ struct __GLXdrawablePrivateRec {
>     struct __GLXcontextRec *readGlxc;
> 
>     /*
>-    ** "methods" that the drawble should be able to respond to.
>-    */
>-    void (*freeBuffers)(struct __GLXdrawablePrivateRec *);
>-    void (*updatePalette)(struct __GLXdrawablePrivateRec *);
>-    GLboolean (*swapBuffers)(struct __GLXdrawablePrivateRec *);
>-
>-    /*
>     ** The GL drawable (information shared between GLX and the GL core)
>     */
>     __GLdrawablePrivate glPriv;
> 
>+    __DRIdrawable driDrawable;
>+
>     /*
>     ** reference count
>     */
>Index: programs/Xserver/GL/glx/glxext.c
>===================================================================
>RCS file: /cvs/xorg/xc/programs/Xserver/GL/glx/glxext.c,v
>retrieving revision 1.6
>diff -u -p -r1.6 glxext.c
>--- programs/Xserver/GL/glx/glxext.c	5 Oct 2005 22:39:41 -0000	1.6
>+++ programs/Xserver/GL/glx/glxext.c	8 Nov 2005 04:05:45 -0000
>@@ -33,12 +33,9 @@
> #include "glxext.h"
> #include "micmap.h"
> 
>+#include "xf86.h"
>+#include "../dri/dri.h"
> 
>-void GlxWrapInitVisuals(miInitVisualsProcPtr *);
>-void GlxSetVisualConfigs(int nconfigs, 
>-                         __GLXvisualConfig *configs, void **privates);
>-
>-static __GLXextensionInfo *__glXExt /* = &__glDDXExtensionInfo */;
> 
> /*
> ** Forward declarations.
>@@ -46,13 +43,15 @@ static __GLXextensionInfo *__glXExt /* =
> static int __glXSwapDispatch(ClientPtr);
> static int __glXDispatch(ClientPtr);
> 
>+void __glXVisualsReset(void);
>+
> /*
> ** Called when the extension is reset.
> */
> static void ResetExtension(ExtensionEntry* extEntry)
> {
>     __glXFlushContextCache();
>-    (*__glXExt->resetExtension)();
>+    __glXVisualsReset();
>     __glXScreenReset();
> }
> 
>@@ -166,9 +165,8 @@ GLboolean __glXFreeContext(__GLXcontext 
>     if (cx->idExists || cx->isCurrent) return GL_FALSE;
>     
>     if (!cx->isDirect) {
>-	if ((*cx->gc->exports.destroyContext)((__GLcontext *)cx->gc) == GL_FALSE) {
>-	    return GL_FALSE;
>-	}
>+	(*cx->driContext.destroyContext)(NULL, cx->screen,
>+					 cx->driContext.private);
>     }
>     if (cx->feedbackBuf) __glXFree(cx->feedbackBuf);
>     if (cx->selectBuf) __glXFree(cx->selectBuf);
>@@ -232,6 +230,7 @@ GLboolean __glXErrorOccured(void)
> /*
> ** Initialize the GLX extension.
> */
>+
> void GlxExtensionInit(void)
> {
>     ExtensionEntry *extEntry;
>@@ -287,46 +286,8 @@ void GlxExtensionInit(void)
> 
> Bool __glXCoreType(void)
> {
>-    return __glXExt->type;
>-}
>-
>-/************************************************************************/
>-
>-void GlxSetVisualConfigs(int nconfigs, 
>-                         __GLXvisualConfig *configs, void **privates)
>-{
>-    (*__glXExt->setVisualConfigs)(nconfigs, configs, privates);
>-}
>-
>-static miInitVisualsProcPtr saveInitVisualsProc;
>-
>-Bool GlxInitVisuals(VisualPtr *visualp, DepthPtr *depthp,
>-		    int *nvisualp, int *ndepthp,
>-		    int *rootDepthp, VisualID *defaultVisp,
>-		    unsigned long sizes, int bitsPerRGB,
>-		    int preferredVis)
>-{
>-    Bool ret;
>-
>-    if (saveInitVisualsProc) {
>-        ret = saveInitVisualsProc(visualp, depthp, nvisualp, ndepthp,
>-                                  rootDepthp, defaultVisp, sizes, bitsPerRGB,
>-                                  preferredVis);
>-        if (!ret)
>-            return False;
>-    }
>-    (*__glXExt->initVisuals)(visualp, depthp, nvisualp, ndepthp, rootDepthp,
>-                             defaultVisp, sizes, bitsPerRGB);
>-    return True;
>-}
>-
>-void
>-GlxWrapInitVisuals(miInitVisualsProcPtr *initVisProc)
>-{
>-    saveInitVisualsProc = *initVisProc;
>-    *initVisProc = GlxInitVisuals;
>-    /* HACK: this shouldn't be done here but it's the earliest time */
>-    __glXExt = __glXglDDXExtensionInfo();       /* from GLcore */
>+    /* This can't be right... what is this used for anyway? */
>+    return GL_CORE_MESA;
> }
> 
> /************************************************************************/
>@@ -375,6 +336,11 @@ __GLXcontext *__glXForceCurrent(__GLXcli
> 	return cx;
>     }
> 
>+#if 0
>+    /* FIXME: Here wee need to hook up bindContext() but a better
>+     * solution would be to expose the forceCurrent from the
>+     * underlying __GLcontext in the DRIcontext.  According to idr,
>+     * this is much faster for this purpose. */
>     /* Make this context the current one for the GL. */
>     if (!cx->isDirect) {
> 	if (!(*cx->gc->exports.forceCurrent)((__GLcontext *)cx->gc)) {
>@@ -384,12 +350,29 @@ __GLXcontext *__glXForceCurrent(__GLXcli
> 	    return 0;
>     	}
>     }
>+#endif
>+
>     __glXLastContext = cx;
>     return cx;
> }
> 
> /************************************************************************/
> 
>+typedef struct {
>+    int (*proc)(__GLXclientState *cl, GLbyte *pc);
>+    __GLXclientState *clientState;
>+    GLbyte *stuff;
>+    int retval;
>+} __GLXdispatchData;
>+
>+static void __glXCallDispatch(void *data)
>+{
>+    __GLXdispatchData *dispatchData = data;
>+
>+    dispatchData->retval = 
>+	(*dispatchData->proc)(dispatchData->clientState, dispatchData->stuff);
>+}
>+
> /*
> ** Top level dispatcher; all commands are executed from here down.
> */
>@@ -397,8 +380,9 @@ static int __glXDispatch(ClientPtr clien
> {
>     REQUEST(xGLXSingleReq);
>     CARD8 opcode;
>-    int (*proc)(__GLXclientState *cl, GLbyte *pc);
>     __GLXclientState *cl;
>+    __GLXdispatchData dispatchData;
>+    ScreenPtr pScreen;
> 
>     opcode = stuff->glxCode;
>     cl = __glXClients[client->index];
>@@ -443,16 +427,24 @@ static int __glXDispatch(ClientPtr clien
>     /*
>     ** Use the opcode to index into the procedure table.
>     */
>-    proc = __glXSingleTable[opcode];
>-    return (*proc)(cl, (GLbyte *) stuff);
>+    dispatchData.proc = __glXSingleTable[opcode];
>+    dispatchData.clientState = cl;
>+    dispatchData.stuff = (GLbyte *) stuff;
>+
>+    pScreen = screenInfo.screens[0];
>+
>+    DRIUnlockedCallback(pScreen, 0, __glXCallDispatch, &dispatchData);
>+
>+    return dispatchData.retval;
> }
> 
> static int __glXSwapDispatch(ClientPtr client)
> {
>     REQUEST(xGLXSingleReq);
>     CARD8 opcode;
>-    int (*proc)(__GLXclientState *cl, GLbyte *pc);
>     __GLXclientState *cl;
>+    __GLXdispatchData dispatchData;
>+    ScreenPtr pScreen;
> 
>     opcode = stuff->glxCode;
>     cl = __glXClients[client->index];
>@@ -489,8 +481,15 @@ static int __glXSwapDispatch(ClientPtr c
>     /*
>     ** Use the opcode to index into the procedure table.
>     */
>-    proc = __glXSwapSingleTable[opcode];
>-    return (*proc)(cl, (GLbyte *) stuff);
>+    dispatchData.proc = __glXSwapSingleTable[opcode];
>+    dispatchData.clientState = cl;
>+    dispatchData.stuff = (GLbyte *) stuff;
>+
>+    pScreen = screenInfo.screens[0];
>+
>+    DRIUnlockedCallback(pScreen, 0, __glXCallDispatch, &dispatchData);
>+
>+    return dispatchData.retval;
> }
> 
> int __glXNoSuchSingleOpcode(__GLXclientState *cl, GLbyte *pc)
>Index: programs/Xserver/GL/glx/glxscreens.c
>===================================================================
>RCS file: /cvs/xorg/xc/programs/Xserver/GL/glx/glxscreens.c,v
>retrieving revision 1.8
>diff -u -p -r1.8 glxscreens.c
>--- programs/Xserver/GL/glx/glxscreens.c	5 Oct 2005 22:39:41 -0000	1.8
>+++ programs/Xserver/GL/glx/glxscreens.c	8 Nov 2005 04:05:45 -0000
>@@ -48,8 +48,10 @@
> #include <windowstr.h>
> 
> #include "glxserver.h"
>+#include "glxvisuals.h"
> #include "glxutil.h"
> #include "glxext.h"
>+#include "glxloader.h"
> 
> const char GLServerVersion[] = "1.2";
> static const char GLServerExtensions[] = 
>@@ -142,18 +144,6 @@ static char GLXServerExtensions[] =
> 			"GLX_SGIX_fbconfig "
> 			;
> 
>-/*
>- * __glDDXScreenInfo comes from GLcore, so we can't resolve this symbol at
>- * module open time.  Leave a placeholder, and fill this in when we first
>- * need it (in __glXScreenInit).  XXX Why make this an array?
>- */
>-static __GLXscreenInfo *__glXScreens[] = {
>-    NULL /* &__glDDXScreenInfo */ ,
>-};
>-
>-static GLint __glXNumStaticScreens =
>-	(sizeof __glXScreens / sizeof __glXScreens[0]);
>-
> __GLXscreenInfo *__glXActiveScreens;
> GLint __glXNumActiveScreens;
> 
>@@ -324,9 +314,7 @@ void __glXSwapBarrierInit(int screen, __
> 
> void __glXScreenInit(GLint numscreens)
> {
>-    GLint i,j;
>-
>-    __glXScreens[0] = __glXglDDXScreenInfo(); /* from GLcore */
>+    GLint i;
> 
>     /*
>     ** This alloc has to work or else the server might as well core dump.
>@@ -334,24 +322,17 @@ void __glXScreenInit(GLint numscreens)
>     __glXActiveScreens =
>       (__GLXscreenInfo *) __glXMalloc(sizeof(__GLXscreenInfo) * numscreens);
>     
>-    for (i=0; i < numscreens; i++) {
>-	/*
>-	** Probe each static screen to see which exists.
>-	*/
>-	for (j=0; j < __glXNumStaticScreens; j++) {
>-	    if ((*__glXScreens[j]->screenProbe)(i)) {
>-		__glXActiveScreens[i] = *__glXScreens[j];
>-
>-		__glXActiveScreens[i].numUsableVisuals = __glXActiveScreens[i].numVisuals;
>-		__glXActiveScreens[i].GLextensions = __glXStrdup(GLServerExtensions);
>-		__glXActiveScreens[i].GLXvendor = __glXStrdup(GLXServerVendorName);
>-		__glXActiveScreens[i].GLXversion = __glXStrdup(GLXServerVersion);
>-		__glXActiveScreens[i].GLXextensions = __glXStrdup(GLXServerExtensions);
>-
>-		__glXDrawableRes = CreateNewResourceType((DeleteType)DrawableGone);
>-		wrapPositionWindow(i);
>-	    }
>-	}
>+    for (i = 0; i < numscreens; i++) {
>+	__glXVisualsInitScreen(&__glXActiveScreens[i], i);
>+	__glXActiveScreens[i].GLextensions = __glXStrdup(GLServerExtensions);
>+	__glXActiveScreens[i].GLXvendor = __glXStrdup(GLXServerVendorName);
>+	__glXActiveScreens[i].GLXversion = __glXStrdup(GLXServerVersion);
>+	__glXActiveScreens[i].GLXextensions = __glXStrdup(GLXServerExtensions);
>+
>+	__glXDrawableRes = CreateNewResourceType((DeleteType)DrawableGone);
>+	wrapPositionWindow(i);
>+
>+	__glXLoaderInitScreen(i);
>     }
>     __glXNumActiveScreens = numscreens;
> }
>Index: programs/Xserver/GL/glx/glxscreens.h
>===================================================================
>RCS file: /cvs/xorg/xc/programs/Xserver/GL/glx/glxscreens.h,v
>retrieving revision 1.4
>diff -u -p -r1.4 glxscreens.h
>--- programs/Xserver/GL/glx/glxscreens.h	3 Jul 2005 07:01:02 -0000	1.4
>+++ programs/Xserver/GL/glx/glxscreens.h	8 Nov 2005 04:05:45 -0000
>@@ -44,7 +44,9 @@
> /* XXX: should be defined somewhere globally */
> #define CAPI
> 
>+#include <stdint.h>
> #include "GL/internal/glcore.h"
>+#include "GL/internal/dri_interface.h"
> 
> /*
> ** Screen dependent data.  These methods are the interface between the DIX
>@@ -52,28 +54,6 @@
> ** interface for context management on a screen.
> */
> typedef struct {
>-    /*
>-    ** Probe the screen and see if it supports GL rendering.  It will
>-    ** return GL_FALSE if it doesn't, GL_TRUE otherwise.
>-    */
>-    Bool (*screenProbe)(int screen);
>-
>-    /*
>-    ** Create a context using configuration information from modes.
>-    ** Use imports as callbacks back to the OS. Return an opaque handle
>-    ** on the context (NULL if failure).
>-    */
>-    __GLinterface *(*createContext)(__GLimports *imports,
>-				    __GLcontextModes *modes,
>-				    __GLinterface *shareGC);
>-
>-    /*
>-    ** Create a buffer using information from glxPriv.  This routine
>-    ** sets up any wrappers necessary to resize, swap or destroy the
>-    ** buffer.
>-    */
>-    void (*createBuffer)(__GLXdrawablePrivate *glxPriv);
>-
>     /**
>      * Linked list of valid context modes for this screen.
>      */
>@@ -89,6 +69,9 @@ typedef struct {
>     char *GLXversion;
>     char *GLXextensions;
> 
>+    void *driver;
>+    __DRIscreen driScreen;
>+
>     /*
>     ** Things that are not statically set.
>     */
>Index: programs/Xserver/GL/glx/glxserver.h
>===================================================================
>RCS file: /cvs/xorg/xc/programs/Xserver/GL/glx/glxserver.h,v
>retrieving revision 1.5.2.1
>diff -u -p -r1.5.2.1 glxserver.h
>--- programs/Xserver/GL/glx/glxserver.h	3 Nov 2005 17:19:09 -0000	1.5.2.1
>+++ programs/Xserver/GL/glx/glxserver.h	8 Nov 2005 04:05:45 -0000
>@@ -52,6 +52,7 @@
> #include <resource.h>
> #include <scrnintstr.h>
> #include "GL/glx_ansic.h"
>+#include <stdint.h>
> 
> 
> /*
>@@ -64,6 +65,7 @@
> #include <GL/gl.h>
> #include <GL/glxproto.h>
> #include <GL/glxint.h>
>+#include <GL/internal/dri_interface.h>
> 
> /* For glxscreens.h */
> typedef struct __GLXdrawablePrivateRec __GLXdrawablePrivate;
>Index: programs/Xserver/GL/glx/glxutil.c
>===================================================================
>RCS file: /cvs/xorg/xc/programs/Xserver/GL/glx/glxutil.c,v
>retrieving revision 1.4
>diff -u -p -r1.4 glxutil.c
>--- programs/Xserver/GL/glx/glxutil.c	3 Jul 2005 07:01:02 -0000	1.4
>+++ programs/Xserver/GL/glx/glxutil.c	8 Nov 2005 04:05:45 -0000
>@@ -337,23 +337,17 @@ __glXCreateDrawablePrivate(DrawablePtr p
> 	(__GLregionRect *)__glXCalloc(1, sizeof(__GLregionRect));
>     glPriv->ownershipRegion.numRects = 1;
> 
>-    glxPriv->freeBuffers = __glXFreeBuffers;
>-    glxPriv->updatePalette = (void (*)(__GLXdrawablePrivate *)) __glXNop;
>-
>     pGlxScreen = &__glXActiveScreens[pDraw->pScreen->myNum];
> 
>-    if (glxPriv->type == DRAWABLE_WINDOW) {
>-	VisualID vid = wVisual((WindowPtr)pDraw);
>-
>-	glxPriv->modes = _gl_context_modes_find_visual( pGlxScreen->modes, vid );
>-	__glXFBInitDrawable(glxPriv, modes);
>-    } else {
>-	glxPriv->modes = glxPriv->pGlxPixmap->modes;
>-	__glXPixInitDrawable(glxPriv, modes);
>-    }
>+    /* The last argument is 'attrs', which is used with pbuffers which
>+     * we currently don't support. */
> 
>-    /* initialize the core's private buffer information */
>-    (*pGlxScreen->createBuffer)(glxPriv);
>+    glxPriv->driDrawable.private =
>+	(pGlxScreen->driScreen.createNewDrawable)(NULL, modes,
>+						  drawId,
>+						  &glxPriv->driDrawable,
>+						  0,
>+						  NULL);
> 
>     return glxPriv;
> }
>@@ -366,16 +360,14 @@ __glXDestroyDrawablePrivate(__GLXdrawabl
>     /* remove the drawable from the drawable list */
>     FreeResourceByType(glxPriv->drawId, __glXDrawableRes, FALSE);
> 
>+    (*glxPriv->driDrawable.destroyDrawable)(NULL,
>+					    glxPriv->driDrawable.private);
>+
>     /* Have the core free any memory it may have attached to the drawable */
>     if (glPriv->freePrivate) {
> 	(*glPriv->freePrivate)(glPriv);
>     }
> 
>-    /* Free any framebuffer memory attached to the drawable */
>-    if (glxPriv->freeBuffers) {
>-	(*glxPriv->freeBuffers)(glxPriv);
>-    }
>-
>     /* Free the drawable Private */
>     __glXFree(glxPriv->glPriv.modes);
>     __glXFree(glxPriv->glPriv.ownershipRegion.rects);
>@@ -495,9 +487,6 @@ __glXResizeDrawableBuffers(__GLXdrawable
> 	glPriv->xOffset = xOffset;
> 	glPriv->yOffset = yOffset;
> #endif
>-
>-	/* notify the buffers */
>-	status = __glXResizeBuffers(glPriv, x, y, w, h);
>     }
> 
>     return status;
>Index: programs/Xserver/hw/xfree86/drivers/ati/r128.h
>===================================================================
>RCS file: /cvs/xorg/xc/programs/Xserver/hw/xfree86/drivers/ati/r128.h,v
>retrieving revision 1.5
>diff -u -p -r1.5 r128.h
>--- programs/Xserver/hw/xfree86/drivers/ati/r128.h	19 Dec 2004 19:49:33 -0000	1.5
>+++ programs/Xserver/hw/xfree86/drivers/ati/r128.h	8 Nov 2005 04:05:46 -0000
>@@ -39,6 +39,7 @@
> #define _R128_H_
> 
> #include "xf86str.h"
>+#include "xf86drm.h"
> 
> 				/* PCI support */
> #include "xf86Pci.h"

Actions: View | Splinter Review

Attachments on bug 4988: 3727 | 3802 | 3873 | 4390

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.