Adding upstream version 6.0.4-dfsg.upstream/6.0.4-dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2042 insertions, 0 deletions

diff --git a/src/VBox/HostServices/SharedOpenGL/render/renderspu_glx.c b/src/VBox/HostServices/SharedOpenGL/render/renderspu_glx.c
new file mode 100644
index 00000000..8a1a61ff
--- /dev/null
+++ b/src/VBox/HostServices/SharedOpenGL/render/renderspu_glx.c
@@ -0,0 +1,2042 @@
+/* Copyright (c) 2001, Stanford University
+ * All rights reserved
+ *
+ * See the file LICENSE.txt for information on redistributing this software.
+ */
+#if 00 /*TEMPORARY*/
+#include <unistd.h>
+#include "cr_rand.h"
+#endif
+
+#include <GL/glx.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xmu/StdCmap.h>
+#include <X11/Xatom.h>
+#include <X11/extensions/shape.h>
+#include <sys/time.h>
+#include <stdio.h>
+
+#include "cr_environment.h"
+#include "cr_error.h"
+#include "cr_string.h"
+#include "cr_mem.h"
+#include "cr_process.h"
+#include "renderspu.h"
+
+
+/*
+ * Stuff from MwmUtils.h
+ */
+typedef struct
+{
+    unsigned long       flags;
+    unsigned long       functions;
+    unsigned long       decorations;
+    long                inputMode;
+    unsigned long       status;
+} PropMotifWmHints;
+
+#define PROP_MOTIF_WM_HINTS_ELEMENTS    5
+#define MWM_HINTS_DECORATIONS   (1L << 1)
+
+
+#define WINDOW_NAME window->title
+
+static Bool WindowExistsFlag;
+
+static int
+WindowExistsErrorHandler( Display *dpy, XErrorEvent *xerr )
+{
+    if (xerr->error_code == BadWindow)
+    {
+        WindowExistsFlag = GL_FALSE;
+    }
+    return 0;
+}
+
+static GLboolean
+WindowExists( Display *dpy, Window w )
+{
+    XWindowAttributes xwa;
+    int (*oldXErrorHandler)(Display *, XErrorEvent *);
+
+    WindowExistsFlag = GL_TRUE;
+    oldXErrorHandler = XSetErrorHandler(WindowExistsErrorHandler);
+    XGetWindowAttributes(dpy, w, &xwa); /* dummy request */
+    XSetErrorHandler(oldXErrorHandler);
+    return WindowExistsFlag;
+}
+
+static Colormap 
+GetLUTColormap( Display *dpy, XVisualInfo *vi )
+{
+    int a;  
+    XColor col;
+    Colormap cmap;
+
+#if defined(__cplusplus) || defined(c_plusplus)
+    int localclass = vi->c_class; /* C++ */
+#else
+    int localclass = vi->class; /* C */
+#endif
+    
+    if ( localclass != DirectColor )
+    {
+        crError( "No support for non-DirectColor visuals with LUTs" );
+    }
+
+    cmap = XCreateColormap( dpy, RootWindow(dpy, vi->screen), 
+            vi->visual, AllocAll );
+
+    for (a=0; a<256; a++)
+    {   
+        col.red = render_spu.lut8[0][a]<<8;
+        col.green = col.blue = 0;
+        col.pixel = a<<16;
+        col.flags = DoRed;
+        XStoreColor(dpy, cmap, &col);
+    }
+       
+    for (a=0; a<256; a++)
+    {   
+        col.green = render_spu.lut8[1][a]<<8;
+        col.red = col.blue = 0;
+        col.pixel = a<<8;
+        col.flags = DoGreen;
+        XStoreColor(dpy, cmap, &col);
+    }
+   
+    for (a=0; a<256; a++)
+    {   
+        col.blue = render_spu.lut8[2][a]<<8;
+        col.red = col.green= 0;
+        col.pixel = a;
+        col.flags = DoBlue;
+        XStoreColor(dpy, cmap, &col);
+    }
+   
+    return cmap;
+}
+
+static Colormap 
+GetShareableColormap( Display *dpy, XVisualInfo *vi )
+{
+    Status status;
+    XStandardColormap *standardCmaps;
+    Colormap cmap;
+    int i, numCmaps;
+
+#if defined(__cplusplus) || defined(c_plusplus)
+    int localclass = vi->c_class; /* C++ */
+#else
+    int localclass = vi->class; /* C */
+#endif
+    
+    if ( localclass != TrueColor )
+    {
+        crError( "No support for non-TrueColor visuals." );
+    }
+
+    status = XmuLookupStandardColormap( dpy, vi->screen, vi->visualid,
+            vi->depth, XA_RGB_DEFAULT_MAP,
+            False, True );
+
+    if ( status == 1 )
+    {
+        status = XGetRGBColormaps( dpy, RootWindow( dpy, vi->screen), 
+                &standardCmaps, &numCmaps, 
+                XA_RGB_DEFAULT_MAP );
+        if ( status == 1 )
+        {
+            for (i = 0 ; i < numCmaps ; i++)
+            {
+                if (standardCmaps[i].visualid == vi->visualid)
+                {
+                    cmap = standardCmaps[i].colormap;
+                    XFree( standardCmaps);
+                    return cmap;
+                }
+            }
+        }
+    }
+
+    cmap = XCreateColormap( dpy, RootWindow(dpy, vi->screen), 
+            vi->visual, AllocNone );
+    return cmap;
+}
+
+
+static int
+WaitForMapNotify( Display *display, XEvent *event, char *arg )
+{
+    (void)display;
+    return ( event->type == MapNotify && event->xmap.window == (Window)arg );
+}
+
+
+/**
+ * Return the X Visual ID of the given window
+ */
+static int
+GetWindowVisualID( Display *dpy, Window w )
+{
+    XWindowAttributes attr;
+    int k = XGetWindowAttributes(dpy, w, &attr);
+    if (!k)
+        return -1;
+    return attr.visual->visualid;
+}
+
+
+/**
+ * Wrapper for glXGetConfig().
+ */
+static int
+Attrib( const VisualInfo *visual, int attrib )
+{
+    int value = 0;
+    render_spu.ws.glXGetConfig( visual->dpy, visual->visual, attrib, &value );
+    return value;
+}
+
+
+
+/**
+ * Find a visual with the specified attributes.  If we fail, turn off an
+ * attribute (like multisample or stereo) and try again.
+ */
+static XVisualInfo *
+chooseVisualRetry( Display *dpy, int screen, GLbitfield visAttribs )
+{
+    while (1) {
+        XVisualInfo *vis = crChooseVisual(&render_spu.ws, dpy, screen,
+                                          (GLboolean) render_spu.use_lut8,
+                                          visAttribs);
+        if (vis)
+            return vis;
+
+        if (visAttribs & CR_MULTISAMPLE_BIT)
+            visAttribs &= ~CR_MULTISAMPLE_BIT;
+        else if (visAttribs & CR_OVERLAY_BIT)
+            visAttribs &= ~CR_OVERLAY_BIT;
+        else if (visAttribs & CR_STEREO_BIT)
+            visAttribs &= ~CR_STEREO_BIT;
+        else if (visAttribs & CR_ACCUM_BIT)
+            visAttribs &= ~CR_ACCUM_BIT;
+        else if (visAttribs & CR_ALPHA_BIT)
+            visAttribs &= ~CR_ALPHA_BIT;
+        else
+            return NULL;
+    }
+}
+
+
+/**
+ * Get an FBconfig for the specified attributes
+ */
+#ifdef GLX_VERSION_1_3
+static GLXFBConfig
+chooseFBConfig( Display *dpy, int screen, GLbitfield visAttribs )
+{
+    GLXFBConfig *fbconfig;
+    int attribs[1000], attrCount = 0, numConfigs;
+    int major, minor;
+
+    CRASSERT(visAttribs & CR_PBUFFER_BIT);
+
+    /* Make sure pbuffers are supported */
+    render_spu.ws.glXQueryVersion(dpy, &major, &minor);
+    if (major * 100 + minor < 103) {
+        crWarning("Render SPU: GLX %d.%d doesn't support pbuffers", major, minor);
+        return 0;
+    }
+
+    attribs[attrCount++] = GLX_DRAWABLE_TYPE;
+    attribs[attrCount++] = GLX_PBUFFER_BIT;
+
+    if (visAttribs & CR_RGB_BIT) {
+        attribs[attrCount++] = GLX_RENDER_TYPE;
+        attribs[attrCount++] = GLX_RGBA_BIT;
+        attribs[attrCount++] = GLX_RED_SIZE;
+        attribs[attrCount++] = 1;
+        attribs[attrCount++] = GLX_GREEN_SIZE;
+        attribs[attrCount++] = 1;
+        attribs[attrCount++] = GLX_BLUE_SIZE;
+        attribs[attrCount++] = 1;
+        if (visAttribs & CR_ALPHA_BIT) {
+            attribs[attrCount++] = GLX_ALPHA_SIZE;
+            attribs[attrCount++] = 1;
+        }
+    }
+
+    if (visAttribs & CR_DEPTH_BIT) {
+        attribs[attrCount++] = GLX_DEPTH_SIZE;
+        attribs[attrCount++] = 1;
+    }
+
+    if (visAttribs & CR_DOUBLE_BIT) {
+        attribs[attrCount++] = GLX_DOUBLEBUFFER;
+        attribs[attrCount++] = True;
+    }
+    else {
+        /* don't care */
+    }
+
+    if (visAttribs & CR_STENCIL_BIT) {
+        attribs[attrCount++] = GLX_STENCIL_SIZE;
+        attribs[attrCount++] = 1;
+    }
+
+    if (visAttribs & CR_ACCUM_BIT) {
+        attribs[attrCount++] = GLX_ACCUM_RED_SIZE;
+        attribs[attrCount++] = 1;
+        attribs[attrCount++] = GLX_ACCUM_GREEN_SIZE;
+        attribs[attrCount++] = 1;
+        attribs[attrCount++] = GLX_ACCUM_BLUE_SIZE;
+        attribs[attrCount++] = 1;
+        if (visAttribs & CR_ALPHA_BIT) {
+            attribs[attrCount++] = GLX_ACCUM_ALPHA_SIZE;
+            attribs[attrCount++] = 1;
+        }
+    }
+
+    if (visAttribs & CR_MULTISAMPLE_BIT) {
+        attribs[attrCount++] = GLX_SAMPLE_BUFFERS_SGIS;
+        attribs[attrCount++] = 1;
+        attribs[attrCount++] = GLX_SAMPLES_SGIS;
+        attribs[attrCount++] = 4;
+    }
+
+    if (visAttribs & CR_STEREO_BIT) {
+        attribs[attrCount++] = GLX_STEREO;
+        attribs[attrCount++] = 1;
+    }
+
+    /* terminate */
+    attribs[attrCount++] = 0;
+
+    fbconfig = render_spu.ws.glXChooseFBConfig(dpy, screen, attribs, &numConfigs);
+    if (!fbconfig || numConfigs == 0) {
+        /* no matches! */
+        return 0;
+    }
+    if (numConfigs == 1) {
+        /* one match */
+        return fbconfig[0];
+    }
+    else {
+        /* found several matches - try to find best one */
+        int i;
+
+        crDebug("Render SPU: glXChooseFBConfig found %d matches for visBits 0x%x",
+                        numConfigs, visAttribs);
+        /* Skip/omit configs that have unneeded Z buffer or unneeded double
+         * buffering.  Possible add other tests in the future.
+         */
+        for (i = 0; i < numConfigs; i++) {
+            int zBits, db;
+            render_spu.ws.glXGetFBConfigAttrib(dpy, fbconfig[i],
+                                               GLX_DEPTH_SIZE, &zBits);
+            if ((visAttribs & CR_DEPTH_BIT) == 0 && zBits > 0) {
+                /* omit fbconfig with unneeded Z */
+                continue;
+            }
+            render_spu.ws.glXGetFBConfigAttrib(dpy, fbconfig[i],
+                                               GLX_DOUBLEBUFFER, &db);
+            if ((visAttribs & CR_DOUBLE_BIT) == 0 && db) {
+                /* omit fbconfig with unneeded DB */
+                continue;
+            }
+
+            /* if we get here, use this config */
+            return fbconfig[i];
+        }
+
+        /* if we get here, we didn't find a better fbconfig */
+        return fbconfig[0];
+    }
+}
+#endif /* GLX_VERSION_1_3 */
+
+static const char * renderspuGetDisplayName()
+{
+    const char *dpyName;
+
+    if (render_spu.display_string[0])
+        dpyName = render_spu.display_string;
+    else
+    {
+        crWarning("Render SPU: no display..");
+        dpyName = NULL;
+    }
+    return dpyName;
+}
+
+static int renderspuWinCmdWinCreate(WindowInfo *pWindow)
+{
+    return VERR_NOT_IMPLEMENTED;
+}
+
+static int renderspuWinCmdWinDestroy(WindowInfo *pWindow)
+{
+    return VERR_NOT_IMPLEMENTED;
+}
+
+static int renderspuWinCmdInit()
+{
+    const char * dpyName;
+    int rc = VERR_GENERAL_FAILURE;
+    
+    if (!crHashtableAllocRegisterKey(render_spu.windowTable, CR_RENDER_WINCMD_ID))
+    {
+        crError("CR_RENDER_WINCMD_ID %d is occupied already", CR_RENDER_WINCMD_ID);
+        return VERR_INVALID_STATE;
+    }
+    
+    render_spu.pWinToInfoTable = crAllocHashtable();
+    if (render_spu.pWinToInfoTable)
+    {
+        dpyName = renderspuGetDisplayName();
+        if (dpyName)
+        {
+            GLboolean bRc = renderspuInitVisual(&render_spu.WinCmdVisual, dpyName, render_spu.default_visual);
+            if (bRc)
+            {
+                bRc = renderspuWinInitWithVisual(&render_spu.WinCmdWindow, &render_spu.WinCmdVisual, GL_FALSE, CR_RENDER_WINCMD_ID);
+                if (bRc)
+                {
+                    XSelectInput(render_spu.WinCmdVisual.dpy, render_spu.WinCmdWindow.window, StructureNotifyMask);
+                    render_spu.WinCmdAtom = XInternAtom(render_spu.WinCmdVisual.dpy, "VBoxWinCmd", False);
+                    CRASSERT(render_spu.WinCmdAtom != None);
+                    return VINF_SUCCESS;
+                }
+                else
+                {
+                    crError("renderspuWinInitWithVisual failed");
+                }
+                /* there is no visual destroy impl currently
+                 * @todo: implement */
+            }
+            else
+            {
+                crError("renderspuInitVisual failed");
+            }
+        }
+        else
+        {
+            crError("Render SPU: no display, aborting");
+        }
+        crFreeHashtable(render_spu.pWinToInfoTable, NULL);
+        render_spu.pWinToInfoTable = NULL;
+    }
+    else
+    {
+        crError("crAllocHashtable failed");
+    }
+    return rc;
+}
+
+static void renderspuWinCmdTerm()
+{
+    /* the window is not in the table, this will just ensure the key is freed */
+    crHashtableDelete(render_spu.windowTable, CR_RENDER_WINCMD_ID, NULL);
+    renderspuWinCleanup(&render_spu.WinCmdWindow);
+    crFreeHashtable(render_spu.pWinToInfoTable, NULL);
+    /* we do not have visual destroy functionality 
+     * @todo implement */
+}
+
+
+static bool renderspuWinCmdProcess(CR_RENDER_WINCMD* pWinCmd)
+{
+    bool fExit = false;
+    /* process commands */
+    switch (pWinCmd->enmCmd)
+    {
+        case CR_RENDER_WINCMD_TYPE_WIN_ON_CREATE:
+            crHashtableAdd(render_spu.pWinToInfoTable, pWinCmd->pWindow->window, pWinCmd->pWindow);
+            XSelectInput(render_spu.WinCmdVisual.dpy, pWinCmd->pWindow->window, ExposureMask);
+            pWinCmd->rc = VINF_SUCCESS;
+            break;
+        case CR_RENDER_WINCMD_TYPE_WIN_ON_DESTROY:
+            crHashtableDelete(render_spu.pWinToInfoTable, pWinCmd->pWindow->window, NULL);
+            pWinCmd->rc = VINF_SUCCESS;
+            break;
+        case CR_RENDER_WINCMD_TYPE_NOP:
+            pWinCmd->rc = VINF_SUCCESS;
+            break;
+        case CR_RENDER_WINCMD_TYPE_EXIT:
+            renderspuWinCmdTerm();
+            pWinCmd->rc = VINF_SUCCESS;
+            fExit = true;
+            pWinCmd->rc = VINF_SUCCESS;
+            break;
+        case CR_RENDER_WINCMD_TYPE_WIN_CREATE:
+            pWinCmd->rc = renderspuWinCmdWinCreate(pWinCmd->pWindow);
+            break;  
+        case CR_RENDER_WINCMD_TYPE_WIN_DESTROY:
+            pWinCmd->rc = renderspuWinCmdWinDestroy(pWinCmd->pWindow);
+            break;
+        default:
+            crError("unknown WinCmd command! %d", pWinCmd->enmCmd);
+            pWinCmd->rc = VERR_INVALID_PARAMETER;
+            break;
+    }
+
+    RTSemEventSignal(render_spu.hWinCmdCompleteEvent);
+    return fExit;
+}
+
+static DECLCALLBACK(int) renderspuWinCmdThreadProc(RTTHREAD ThreadSelf, void *pvUser)
+{
+    int rc;
+    bool fExit = false;
+    crDebug("RenderSPU: Window thread started (%x)", crThreadID());
+    
+    rc = renderspuWinCmdInit();
+
+    /* notify the main cmd thread that we have started */
+    RTSemEventSignal(render_spu.hWinCmdCompleteEvent);
+    
+    if (!RT_SUCCESS(rc))
+    {
+        CRASSERT(!render_spu.pWinToInfoTable);
+        return rc;
+    }
+
+    do
+    {
+    	XEvent event;
+    	XNextEvent(render_spu.WinCmdVisual.dpy, &event);
+        
+    	switch (event.type)
+    	{
+            case ClientMessage:
+            {
+                CRASSERT(event.xclient.window == render_spu.WinCmdWindow.window);
+                if (event.xclient.window == render_spu.WinCmdWindow.window)
+                {
+                    if (render_spu.WinCmdAtom == event.xclient.message_type)
+                    {
+                        CR_RENDER_WINCMD *pWinCmd;
+                        memcpy(&pWinCmd, event.xclient.data.b, sizeof (pWinCmd));
+                        fExit = renderspuWinCmdProcess(pWinCmd);
+                    }
+                }
+                
+                break;
+            }
+            case Expose:
+            {
+                if (!event.xexpose.count)
+                {    
+                    WindowInfo *pWindow = (WindowInfo*)crHashtableSearch(render_spu.pWinToInfoTable, event.xexpose.window);
+                    if (pWindow)
+                    {
+                        const struct VBOXVR_SCR_COMPOSITOR * pCompositor;
+
+                        pCompositor = renderspuVBoxCompositorAcquire(pWindow);
+                        if (pCompositor)
+                        {
+                            renderspuVBoxPresentCompositionGeneric(pWindow, pCompositor, NULL, 0, false);
+                            renderspuVBoxCompositorRelease(pWindow);
+                        }
+                    }
+                }
+                break;
+            }
+            default:
+                break;
+    	}
+    } while (!fExit);
+
+    return 0;
+}
+
+static int renderspuWinCmdSubmit(CR_RENDER_WINCMD_TYPE enmCmd, WindowInfo *pWindow)
+{
+    Status status;
+    XEvent event;
+    CR_RENDER_WINCMD WinCmd, *pWinCmd;
+    int rc;
+    
+    pWinCmd = &WinCmd;
+    pWinCmd->enmCmd = enmCmd;
+    pWinCmd->rc = VERR_GENERAL_FAILURE;
+    pWinCmd->pWindow = pWindow;
+    
+    memset(&event, 0, sizeof (event));
+    event.type = ClientMessage;
+    event.xclient.window = render_spu.WinCmdWindow.window;
+    event.xclient.message_type = render_spu.WinCmdAtom;
+    event.xclient.format = 8;
+    memcpy(event.xclient.data.b, &pWinCmd, sizeof (pWinCmd));
+    
+    status = XSendEvent(render_spu.pCommunicationDisplay, render_spu.WinCmdWindow.window, False, StructureNotifyMask, &event);
+    if (!status)
+    {
+        Assert(0);
+        crWarning("XSendEvent returned null");
+        return VERR_GENERAL_FAILURE;
+    }
+    
+    XFlush(render_spu.pCommunicationDisplay);
+    rc = RTSemEventWaitNoResume(render_spu.hWinCmdCompleteEvent, RT_INDEFINITE_WAIT);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("RTSemEventWaitNoResume failed rc %d", rc);
+	return rc;
+    }
+    return pWinCmd->rc;
+}
+
+int renderspu_SystemInit()
+{
+    const char * dpyName;
+    int rc = VERR_GENERAL_FAILURE;
+    
+    if (!render_spu.use_glxchoosevisual) {
+        /* sometimes want to set this option with ATI drivers */
+        render_spu.ws.glXChooseVisual = NULL;
+    }
+
+    /* setup communication display connection */
+    dpyName = renderspuGetDisplayName();
+    if (!dpyName)
+    {
+        crWarning("no display name, aborting");
+        return VERR_GENERAL_FAILURE;
+    }
+    
+    render_spu.pCommunicationDisplay = XOpenDisplay(dpyName);
+    if (!render_spu.pCommunicationDisplay)
+    {
+        crWarning( "Couldn't open X display named '%s'", dpyName );
+        return VERR_GENERAL_FAILURE;
+    }
+
+    if ( !render_spu.ws.glXQueryExtension( render_spu.pCommunicationDisplay, NULL, NULL ) )
+    {
+        crWarning( "Render SPU: Display %s doesn't support GLX", dpyName );
+        return VERR_GENERAL_FAILURE;
+    }
+
+    rc = RTSemEventCreate(&render_spu.hWinCmdCompleteEvent);
+    if (RT_SUCCESS(rc))
+    {
+        rc = RTThreadCreate(&render_spu.hWinCmdThread, renderspuWinCmdThreadProc, NULL, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "VBoxCrWinCmd");
+	if (RT_SUCCESS(rc))
+	{
+	    rc = RTSemEventWait(render_spu.hWinCmdCompleteEvent, RT_INDEFINITE_WAIT);
+	    if (RT_SUCCESS(rc))
+	    {
+	        return VINF_SUCCESS;
+	    }
+	    else
+	    {
+            crWarning("RTSemEventWait failed rc %d", rc);
+        }
+
+        RTThreadWait(render_spu.hWinCmdThread, RT_INDEFINITE_WAIT, NULL);
+        }
+        else
+        {
+            crWarning("RTThreadCreate failed rc %d", rc);
+        }
+	    RTSemEventDestroy(render_spu.hWinCmdCompleteEvent);
+    }
+    else
+    {
+        crWarning("RTSemEventCreate failed rc %d", rc);
+    }
+    
+    return rc;
+}
+
+int renderspu_SystemTerm()
+{
+	int rc = renderspuWinCmdSubmit(CR_RENDER_WINCMD_TYPE_EXIT, NULL);
+	if (!RT_SUCCESS(rc))
+	{
+	    crWarning("renderspuWinCmdSubmit EXIT failed rc %d", rc);
+	    return rc;
+	}
+
+	RTThreadWait(render_spu.hWinCmdThread, RT_INDEFINITE_WAIT, NULL);
+	RTSemEventDestroy(render_spu.hWinCmdCompleteEvent);
+	return VINF_SUCCESS;
+}
+
+GLboolean
+renderspu_SystemInitVisual( VisualInfo *visual )
+{
+    const char *dpyName;
+    int screen;
+
+    CRASSERT(visual);
+
+#ifdef USE_OSMESA
+    if (render_spu.use_osmesa) {
+        /* A dummy visual - being non null is enough.  */
+        visual->visual =(XVisualInfo *) "os";
+        return GL_TRUE;
+    }
+#endif
+    
+    dpyName = renderspuGetDisplayName();
+    if (!dpyName)
+    {
+        crWarning("Render SPU: no display, aborting");
+        return GL_FALSE;
+    }
+
+
+    crInfo("Render SPU: Opening display %s", dpyName);
+
+    if (dpyName &&
+            (crStrncmp(dpyName, "localhost:11", 12) == 0 ||
+             crStrncmp(dpyName, "localhost:12", 12) == 0 ||
+             crStrncmp(dpyName, "localhost:13", 12) == 0)) {
+        /* Issue both debug and warning messages to make sure the
+         * message gets noticed!
+         */
+        crDebug("Render SPU: display string looks like a proxy X server!");
+        crDebug("Render SPU: This is usually a problem!");
+        crWarning("Render SPU: display string looks like a proxy X server!");
+        crWarning("Render SPU: This is usually a problem!");
+    }
+
+    visual->dpy = XOpenDisplay(dpyName);  
+    if (!visual->dpy)
+    {
+        crWarning( "Couldn't open X display named '%s'", dpyName );
+        return GL_FALSE;
+    }
+
+    if ( !render_spu.ws.glXQueryExtension( visual->dpy, NULL, NULL ) )
+    {
+        crWarning( "Render SPU: Display %s doesn't support GLX", visual->displayName );
+        return GL_FALSE;
+    }
+
+    screen = DefaultScreen(visual->dpy);
+
+#ifdef GLX_VERSION_1_3
+    if (visual->visAttribs & CR_PBUFFER_BIT)
+    {
+        visual->fbconfig = chooseFBConfig(visual->dpy, screen, visual->visAttribs);
+        if (!visual->fbconfig) {
+            char s[1000];
+            renderspuMakeVisString( visual->visAttribs, s );
+            crWarning( "Render SPU: Display %s doesn't have the necessary fbconfig: %s",
+                                 dpyName, s );
+            XCloseDisplay(visual->dpy);
+            return GL_FALSE;
+        }
+    }
+    else
+#endif /* GLX_VERSION_1_3 */
+    {
+        visual->visual = chooseVisualRetry(visual->dpy, screen, visual->visAttribs);
+        if (!visual->visual) {
+            char s[1000];
+            renderspuMakeVisString( visual->visAttribs, s );
+            crWarning("Render SPU: Display %s doesn't have the necessary visual: %s",
+                                dpyName, s );
+            XCloseDisplay(visual->dpy);
+            return GL_FALSE;
+        }
+    }
+
+    if ( render_spu.sync )
+    {
+        crDebug( "Render SPU: Turning on XSynchronize" );
+        XSynchronize( visual->dpy, True );
+    }
+
+    if (visual->visual) {
+            crDebug( "Render SPU: Choose visual id=0x%x: RGBA=(%d,%d,%d,%d) Z=%d"
+                     " stencil=%d double=%d stereo=%d accum=(%d,%d,%d,%d)",
+                     (int) visual->visual->visualid,
+                     Attrib( visual, GLX_RED_SIZE ),
+                     Attrib( visual, GLX_GREEN_SIZE ),
+                     Attrib( visual, GLX_BLUE_SIZE ),
+                     Attrib( visual, GLX_ALPHA_SIZE ),
+                     Attrib( visual, GLX_DEPTH_SIZE ),
+                     Attrib( visual, GLX_STENCIL_SIZE ),
+                     Attrib( visual, GLX_DOUBLEBUFFER ),
+                     Attrib( visual, GLX_STEREO ),
+                     Attrib( visual, GLX_ACCUM_RED_SIZE ),
+                     Attrib( visual, GLX_ACCUM_GREEN_SIZE ),
+                     Attrib( visual, GLX_ACCUM_BLUE_SIZE ),
+                     Attrib( visual, GLX_ACCUM_ALPHA_SIZE )
+                     );
+    }
+    else if (visual->fbconfig) {
+        int id;
+        render_spu.ws.glXGetFBConfigAttrib(visual->dpy, visual->fbconfig,
+                                                                             GLX_FBCONFIG_ID, &id);
+        crDebug("Render SPU: Chose FBConfig 0x%x, visBits=0x%x",
+                        id, visual->visAttribs);
+    }
+
+    return GL_TRUE;
+}
+
+
+/*
+ * Add a GLX window to a swap group for inter-machine SwapBuffer
+ * synchronization.
+ * Only supported on NVIDIA Quadro 3000G hardware.
+ */
+static void
+JoinSwapGroup(Display *dpy, int screen, Window window,
+                            GLuint group, GLuint barrier)
+{
+    GLuint maxGroups, maxBarriers;
+    const char *ext;
+    Bool b;
+
+    /*
+     * XXX maybe query glXGetClientString() instead???
+     */
+    ext = render_spu.ws.glXQueryExtensionsString(dpy, screen);
+
+    if (!crStrstr(ext, "GLX_NV_swap_group") ||
+            !render_spu.ws.glXQueryMaxSwapGroupsNV ||
+            !render_spu.ws.glXJoinSwapGroupNV ||
+            !render_spu.ws.glXBindSwapBarrierNV) {
+        crWarning("Render SPU: nv_swap_group is set but GLX_NV_swap_group is not supported on this system!");
+        return;
+    }
+
+    b = render_spu.ws.glXQueryMaxSwapGroupsNV(dpy, screen,
+                                              &maxGroups, &maxBarriers);
+    if (!b)
+        crWarning("Render SPU: call to glXQueryMaxSwapGroupsNV() failed!");
+
+    if (group >= maxGroups) {
+        crWarning("Render SPU: nv_swap_group too large (%d > %d)",
+                        group, (int) maxGroups);
+        return;
+    }
+    crDebug("Render SPU: max swap groups = %d, max barriers = %d",
+                    maxGroups, maxBarriers);
+
+    /* add this window to the swap group */
+    b = render_spu.ws.glXJoinSwapGroupNV(dpy, window, group);
+    if (!b) {
+        crWarning("Render SPU: call to glXJoinSwapGroupNV() failed!");
+        return;
+    }
+    else {
+        crDebug("Render SPU: call to glXJoinSwapGroupNV() worked!");
+    }
+
+    /* ... and bind window to barrier of same ID */
+    b = render_spu.ws.glXBindSwapBarrierNV(dpy, group, barrier);
+    if (!b) {
+        crWarning("Render SPU: call to glXBindSwapBarrierNV(group=%d barrier=%d) failed!", group, barrier);
+        return;
+    }
+    else {
+         crDebug("Render SPU: call to glXBindSwapBarrierNV(group=%d barrier=%d) worked!", group, barrier);
+    }
+
+    crDebug("Render SPU: window has joined swap group %d", group);
+}
+
+
+
+static GLboolean
+createWindow( VisualInfo *visual, GLboolean showIt, WindowInfo *window )
+{
+    Display             *dpy;
+    Colormap             cmap;
+    XSetWindowAttributes swa;
+    XSizeHints           hints = {0};
+    XEvent               event;
+    XTextProperty        text_prop;
+    XClassHint          *class_hints = NULL;
+    Window               parent;
+    char                *name;
+    unsigned long        flags;
+    unsigned int vncWin;
+
+    CRASSERT(visual);
+    window->visual = visual;
+    window->nativeWindow = 0;
+
+#ifdef USE_OSMESA
+    if (render_spu.use_osmesa)
+        return GL_TRUE;
+#endif
+
+    dpy = visual->dpy;
+
+    if ( render_spu.use_L2 )
+    {
+        crWarning( "Render SPU: Going fullscreen because we think we're using Lightning-2." );
+        render_spu.fullscreen = 1;
+    }
+
+    /*
+     * Query screen size if we're going full-screen
+     */
+    if ( render_spu.fullscreen )
+    {
+        XWindowAttributes xwa;
+        Window root_window;
+
+        /* disable the screensaver */
+        XSetScreenSaver( dpy, 0, 0, PreferBlanking, AllowExposures );
+        crDebug( "Render SPU: Just turned off the screensaver" );
+
+        /* Figure out how big the screen is, and make the window that size */
+        root_window = DefaultRootWindow( dpy );
+        XGetWindowAttributes( dpy, root_window, &xwa );
+
+        crDebug( "Render SPU: root window size: %d x %d", xwa.width, xwa.height );
+
+        window->x = 0;
+        window->y = 0;
+        window->BltInfo.width  = xwa.width;
+        window->BltInfo.height = xwa.height;
+    }
+
+    /* i've changed default window size to be 0,0 but X doesn't like it */
+    /*CRASSERT(window->BltInfo.width >= 1);
+    CRASSERT(window->BltInfo.height >= 1);*/
+    if (window->BltInfo.width < 1) window->BltInfo.width = 1;
+    if (window->BltInfo.height < 1) window->BltInfo.height = 1;
+
+    /*
+     * Get a colormap.
+     */
+    if (render_spu.use_lut8)
+        cmap = GetLUTColormap( dpy, visual->visual );
+    else
+        cmap = GetShareableColormap( dpy, visual->visual );
+    if ( !cmap ) {
+        crError( "Render SPU: Unable to get a colormap!" );
+        return GL_FALSE;
+    }
+
+    /* destroy existing window if there is one */
+    if (window->window) {
+        XDestroyWindow(dpy, window->window);
+    }
+
+    /*
+     * Create the window
+     *
+     * POSSIBLE OPTIMIZATION:
+     * If we're using the render_to_app_window or render_to_crut_window option
+     * (or DMX) we may never actually use this X window.  So we could perhaps
+     * delay its creation until glXMakeCurrent is called.  With NVIDIA's OpenGL
+     * driver, creating a lot of GLX windows can eat up a lot of VRAM and lead
+     * to slow, software-fallback rendering.  Apps that use render_to_app_window,
+     * etc should set the default window size very small to avoid this.
+     * See dmx.conf for example.
+     */
+    swa.colormap     = cmap;
+    swa.border_pixel = 0;
+    swa.event_mask   = ExposureMask | StructureNotifyMask;
+    swa.override_redirect = 1;
+
+    flags = CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect;
+
+    /* 
+     * We pass the VNC's desktop windowID via an environment variable.
+     * If we don't find one, we're not on a 3D-capable vncviewer, or
+     * if we do find one, then create the renderspu subwindow as a
+     * child of the vncviewer's desktop window. 
+     *
+     * This is purely for the replicateSPU.
+     *
+     * NOTE: This is crufty, and will do for now. FIXME.
+     */
+    vncWin = crStrToInt( crGetenv("CRVNCWINDOW") );
+    if (vncWin)
+        parent = (Window) vncWin;
+    else
+        parent = RootWindow(dpy, visual->visual->screen);
+
+    if (render_spu_parent_window_id>0)
+    {
+        crDebug("Render SPU: VBox parent window_id is: %x", render_spu_parent_window_id);
+        window->window = XCreateWindow(dpy, render_spu_parent_window_id,
+                                       window->x, window->y,
+                                       window->BltInfo.width, window->BltInfo.height,
+                                       0, visual->visual->depth, InputOutput,
+                                       visual->visual->visual, flags, &swa);
+    }
+    else
+    {
+        /* This should happen only at the call from crVBoxServerInit. At this point we don't
+         * know render_spu_parent_window_id yet, nor we need it for default window which is hidden.
+         */
+
+        crDebug("Render SPU: Creating global window, parent: %x", RootWindow(dpy, visual->visual->screen));
+        window->window = XCreateWindow(dpy, RootWindow(dpy, visual->visual->screen),
+                                       window->x, window->y,
+                                       window->BltInfo.width, window->BltInfo.height,
+                                       0, visual->visual->depth, InputOutput,
+                                       visual->visual->visual, flags, &swa);
+    }
+
+    if (!window->window) {
+        crWarning( "Render SPU: unable to create window" );
+        return GL_FALSE;
+    }
+
+    crDebug( "Render SPU: Created window 0x%x on display %s, Xvisual 0x%x",
+                     (int) window->window,
+                     DisplayString(visual->dpy),
+                     (int) visual->visual->visual->visualid  /* yikes */
+                     );
+
+    if (render_spu.fullscreen || render_spu.borderless)
+    {
+        /* Disable border/decorations with an MWM property (observed by most
+         * modern window managers.
+         */
+        PropMotifWmHints motif_hints;
+        Atom prop, proptype;
+
+        /* setup the property */
+        motif_hints.flags = MWM_HINTS_DECORATIONS;
+        motif_hints.decorations = 0; /* Turn off all decorations */
+
+        /* get the atom for the property */
+        prop = XInternAtom( dpy, "_MOTIF_WM_HINTS", True );
+        if (prop) {
+            /* not sure this is correct, seems to work, XA_WM_HINTS didn't work */
+            proptype = prop;
+            XChangeProperty( dpy, window->window,        /* display, window */
+                                             prop, proptype,              /* property, type */
+                                             32,                          /* format: 32-bit datums */
+                                             PropModeReplace,                /* mode */
+                                             (unsigned char *) &motif_hints, /* data */
+                                             PROP_MOTIF_WM_HINTS_ELEMENTS    /* nelements */
+                                             );
+        }
+    }
+
+    /* Make a clear cursor to get rid of the monitor cursor */
+    if ( render_spu.fullscreen )
+    {
+        Pixmap pixmap;
+        Cursor cursor;
+        XColor colour;
+        char clearByte = 0;
+        
+        /* AdB - Only bother to create a 1x1 cursor (byte) */
+        pixmap = XCreatePixmapFromBitmapData(dpy, window->window, &clearByte,
+                                             1, 1, 1, 0, 1);
+        if(!pixmap){
+            crWarning("Unable to create clear cursor pixmap");
+            return GL_FALSE;
+        }
+        
+        cursor = XCreatePixmapCursor(dpy, pixmap, pixmap, &colour, &colour, 0, 0);
+        if(!cursor){
+            crWarning("Unable to create clear cursor from zero byte pixmap");
+            return GL_FALSE;
+        }
+        XDefineCursor(dpy, window->window, cursor);
+        XFreePixmap(dpy, pixmap);
+    }
+    
+    hints.x = window->x;
+    hints.y = window->y;
+    hints.width = window->BltInfo.width;
+    hints.height = window->BltInfo.height;
+    hints.min_width = hints.width;
+    hints.min_height = hints.height;
+    hints.max_width = hints.width;
+    hints.max_height = hints.height;
+    if (render_spu.resizable)
+        hints.flags = USPosition | USSize;
+    else
+        hints.flags = USPosition | USSize | PMinSize | PMaxSize;
+    XSetStandardProperties( dpy, window->window,
+            WINDOW_NAME, WINDOW_NAME,
+            None, NULL, 0, &hints );
+
+    /* New item!  This is needed so that the sgimouse server can find
+     * the crDebug window. 
+     */
+    name = WINDOW_NAME;
+    XStringListToTextProperty( &name, 1, &text_prop );
+    XSetWMName( dpy, window->window, &text_prop );
+
+    /* Set window name, resource class */
+    class_hints = XAllocClassHint( );
+    class_hints->res_name = crStrdup( "foo" );
+    class_hints->res_class = crStrdup( "Chromium" );
+    XSetClassHint( dpy, window->window, class_hints );
+    crFree( class_hints->res_name );
+    crFree( class_hints->res_class );
+    XFree( class_hints );
+
+    if (showIt) {
+        XMapWindow( dpy, window->window );
+        XIfEvent( dpy, &event, WaitForMapNotify, 
+                            (char *) window->window );
+    }
+
+    if ((window->visual->visAttribs & CR_DOUBLE_BIT) && render_spu.nvSwapGroup) {
+        /* NOTE:
+         * If this SPU creates N windows we don't want to gang the N windows
+         * together!
+         * By adding the window ID to the nvSwapGroup ID we can be sure each
+         * app window is in a separate swap group while all the back-end windows
+         * which form a mural are in the same swap group.
+         */
+        GLuint group = 0; /*render_spu.nvSwapGroup + window->BltInfo.Base.id;*/
+        GLuint barrier = 0;
+        JoinSwapGroup(dpy, visual->visual->screen, window->window, group, barrier);
+    }
+
+    /*
+     * End GLX code
+     */
+    crDebug( "Render SPU: actual window x, y, width, height: %d, %d, %d, %d",
+                     window->x, window->y, window->BltInfo.width, window->BltInfo.height );
+
+    XSync(dpy, 0);
+    
+    if (window->BltInfo.Base.id != CR_RENDER_WINCMD_ID)
+    {
+        int rc = renderspuWinCmdSubmit(CR_RENDER_WINCMD_TYPE_WIN_ON_CREATE, window);
+        AssertRC(rc);
+    }
+
+    return GL_TRUE;
+}
+
+
+static GLboolean
+createPBuffer( VisualInfo *visual, WindowInfo *window )
+{
+    window->visual = visual;
+    window->x = 0;
+    window->y = 0;
+    window->nativeWindow = 0;
+
+    CRASSERT(window->BltInfo.width > 0);
+    CRASSERT(window->BltInfo.height > 0);
+
+#ifdef GLX_VERSION_1_3
+    {
+        int attribs[100], i = 0, w, h;
+        CRASSERT(visual->fbconfig);
+        w = window->BltInfo.width;
+        h = window->BltInfo.height;
+        attribs[i++] = GLX_PRESERVED_CONTENTS;
+        attribs[i++] = True;
+        attribs[i++] = GLX_PBUFFER_WIDTH;
+        attribs[i++] = w;
+        attribs[i++] = GLX_PBUFFER_HEIGHT;
+        attribs[i++] = h;
+        attribs[i++] = 0; /* terminator */
+        window->window = render_spu.ws.glXCreatePbuffer(visual->dpy,
+                                                        visual->fbconfig, attribs);
+        if (window->window) {
+            crDebug("Render SPU: Allocated %d x %d pbuffer", w, h);
+            return GL_TRUE;
+        }
+        else {
+            crWarning("Render SPU: Failed to allocate %d x %d pbuffer", w, h);
+            return GL_FALSE;
+        }
+    }
+#endif /* GLX_VERSION_1_3 */
+    return GL_FALSE;
+}
+
+
+GLboolean
+renderspu_SystemCreateWindow( VisualInfo *visual, GLboolean showIt, WindowInfo *window )
+{
+    if (visual->visAttribs & CR_PBUFFER_BIT) {
+        window->BltInfo.width = render_spu.defaultWidth;
+        window->BltInfo.height = render_spu.defaultHeight;
+        return createPBuffer(visual, window);
+    }
+    else {
+        return createWindow(visual, showIt, window);
+    }
+}
+
+GLboolean
+renderspu_SystemVBoxCreateWindow( VisualInfo *visual, GLboolean showIt, WindowInfo *window )
+{
+    return renderspu_SystemCreateWindow(visual, showIt, window);
+}
+
+void
+renderspu_SystemDestroyWindow( WindowInfo *window )
+{
+    CRASSERT(window);
+    CRASSERT(window->visual);
+
+#ifdef USE_OSMESA
+    if (render_spu.use_osmesa) 
+    {
+        crFree(window->buffer);
+        window->buffer = NULL;
+    }
+    else
+#endif
+    {
+        if (window->visual->visAttribs & CR_PBUFFER_BIT) {
+#ifdef GLX_VERSION_1_3
+            render_spu.ws.glXDestroyPbuffer(window->visual->dpy, window->window);
+#endif
+        }
+        else {
+            /* The value window->nativeWindow will only be non-NULL if the
+             * render_to_app_window option is set to true.  In this case, we
+             * don't want to do anything, since we're not responsible for this
+             * window.  I know...personal responsibility and all...
+             */
+            if (!window->nativeWindow) {
+                if (window->BltInfo.Base.id != CR_RENDER_WINCMD_ID)
+                {
+                    int rc = renderspuWinCmdSubmit(CR_RENDER_WINCMD_TYPE_WIN_ON_DESTROY, window);
+                    AssertRC(rc);
+                }
+                XDestroyWindow(window->visual->dpy, window->window);
+                XSync(window->visual->dpy, 0);
+            }
+        }
+    }
+    window->visual = NULL;
+    window->window = 0;
+}
+
+
+GLboolean
+renderspu_SystemCreateContext( VisualInfo *visual, ContextInfo *context, ContextInfo *sharedContext )
+{
+    Bool is_direct;
+    GLXContext sharedSystemContext = NULL;
+
+    CRASSERT(visual);
+    CRASSERT(context);
+
+    context->visual = visual;
+
+    if (sharedContext != NULL) {
+        sharedSystemContext = sharedContext->context;
+    }
+
+
+
+#ifdef USE_OSMESA
+    if (render_spu.use_osmesa) {
+        context->context = (GLXContext) render_spu.OSMesaCreateContext(OSMESA_RGB, 0);
+        if (context->context)
+            return GL_TRUE;
+        else
+            return GL_FALSE;
+    }
+#endif
+
+#ifdef  GLX_VERSION_1_3
+    if (visual->visAttribs & CR_PBUFFER_BIT) {
+        context->context = render_spu.ws.glXCreateNewContext( visual->dpy, 
+                                                              visual->fbconfig,
+                                                              GLX_RGBA_TYPE,
+                                                              sharedSystemContext,
+                                                              render_spu.try_direct);
+    }
+    else
+#endif
+    {
+         context->context = render_spu.ws.glXCreateContext( visual->dpy, 
+                                                            visual->visual,
+                                                            sharedSystemContext,
+                                                            render_spu.try_direct);
+    }
+    if (!context->context) {
+        crError( "Render SPU: Couldn't create rendering context" ); 
+        return GL_FALSE;
+    }
+
+    is_direct = render_spu.ws.glXIsDirect( visual->dpy, context->context );
+    if (visual->visual)
+        crDebug("Render SPU: Created %s context (%d) on display %s for visAttribs 0x%x",
+                        is_direct ? "DIRECT" : "INDIRECT",
+                        context->BltInfo.Base.id,
+                        DisplayString(visual->dpy),
+                        visual->visAttribs);
+
+    if ( render_spu.force_direct && !is_direct )
+    {
+        crError( "Render SPU: Direct rendering not possible." );
+        return GL_FALSE;
+    }
+
+    return GL_TRUE;
+}
+
+
+#define USE_GLX_COPYCONTEXT 0
+
+#if !USE_GLX_COPYCONTEXT
+
+/**
+ * Unfortunately, glXCopyContext() is broken sometimes (NVIDIA 76.76 driver).
+ * This bit of code gets and sets GL state we need to copy between contexts.
+ */
+struct saved_state
+{
+    /* XXX depending on the app, more state may be needed here */
+    GLboolean Lighting;
+    GLboolean LightEnabled[8];
+    GLfloat LightPos[8][4];
+    GLfloat LightAmbient[8][4];
+    GLfloat LightDiffuse[8][4];
+    GLfloat LightSpecular[8][4];
+    GLboolean DepthTest;
+};
+
+static struct saved_state SavedState;
+
+static void
+get_state(struct saved_state *s)
+{
+    int i;
+
+    s->Lighting = render_spu.self.IsEnabled(GL_LIGHTING);
+    for (i = 0; i < 8; i++) {
+        s->LightEnabled[i] = render_spu.self.IsEnabled(GL_LIGHT0 + i);
+        render_spu.self.GetLightfv(GL_LIGHT0 + i, GL_POSITION, s->LightPos[i]);
+        render_spu.self.GetLightfv(GL_LIGHT0 + i, GL_AMBIENT, s->LightAmbient[i]);
+        render_spu.self.GetLightfv(GL_LIGHT0 + i, GL_DIFFUSE, s->LightDiffuse[i]);
+        render_spu.self.GetLightfv(GL_LIGHT0 + i, GL_SPECULAR, s->LightSpecular[i]);
+    }
+
+    s->DepthTest = render_spu.self.IsEnabled(GL_DEPTH_TEST);
+}
+
+static void
+set_state(const struct saved_state *s)
+{
+    int i;
+
+    if (s->Lighting) {
+        render_spu.self.Enable(GL_LIGHTING);
+    }
+    else {
+        render_spu.self.Disable(GL_LIGHTING);
+    }
+
+    for (i = 0; i < 8; i++) {
+        if (s->LightEnabled[i]) {
+            render_spu.self.Enable(GL_LIGHT0 + i);
+        }
+        else {
+            render_spu.self.Disable(GL_LIGHT0 + i);
+        }
+        render_spu.self.Lightfv(GL_LIGHT0 + i, GL_POSITION, s->LightPos[i]);
+        render_spu.self.Lightfv(GL_LIGHT0 + i, GL_AMBIENT, s->LightAmbient[i]);
+        render_spu.self.Lightfv(GL_LIGHT0 + i, GL_DIFFUSE, s->LightDiffuse[i]);
+        render_spu.self.Lightfv(GL_LIGHT0 + i, GL_SPECULAR, s->LightSpecular[i]);
+    }
+
+    if (s->DepthTest)
+        render_spu.self.Enable(GL_DEPTH_TEST);
+    else
+        render_spu.self.Disable(GL_DEPTH_TEST);
+}
+
+#endif /* !USE_GLX_COPYCONTEXT */
+
+/**
+ * Recreate the GLX context for ContextInfo.  The new context will use the
+ * visual specified by newVisualID.
+ */
+static void
+renderspu_RecreateContext( ContextInfo *context, int newVisualID )
+{
+    XVisualInfo templateVis, *vis;
+    long templateFlags;
+    int screen = 0, count;
+    GLXContext oldContext = context->context;
+
+    templateFlags = VisualScreenMask | VisualIDMask;
+    templateVis.screen = screen;
+    templateVis.visualid = newVisualID;
+    vis = XGetVisualInfo(context->visual->dpy, templateFlags, &templateVis, &count);
+    CRASSERT(vis);
+    if (!vis)
+        return;
+
+    /* create new context */
+    crDebug("Render SPU: Creating new GLX context with visual 0x%x", newVisualID);
+    context->context = render_spu.ws.glXCreateContext(context->visual->dpy,
+                                                                                                        vis, NULL,
+                                                                                                        render_spu.try_direct);
+    CRASSERT(context->context);
+
+#if USE_GLX_COPYCONTEXT
+    /* copy old context state to new context */
+    render_spu.ws.glXCopyContext(context->visual->dpy,
+                                                             oldContext, context->context, ~0);
+    crDebug("Render SPU: Done copying context state");
+#endif
+
+    /* destroy old context */
+    render_spu.ws.glXDestroyContext(context->visual->dpy, oldContext);
+
+    context->visual->visual = vis;
+}
+
+
+void
+renderspu_SystemDestroyContext( ContextInfo *context )
+{
+#ifdef USE_OSMESA
+    if (render_spu.use_osmesa) 
+    {
+        render_spu.OSMesaDestroyContext( (OSMesaContext) context->context );
+    }
+    else
+#endif
+    {
+#if 0
+        /* XXX disable for now - causes segfaults w/ NVIDIA's driver */
+        render_spu.ws.glXDestroyContext( context->visual->dpy, context->context );
+#endif
+    }
+    context->visual = NULL;
+    context->context = 0;
+}
+
+
+#ifdef USE_OSMESA
+static void
+check_buffer_size( WindowInfo *window )
+{
+    if (window->BltInfo.width != window->in_buffer_width
+        || window->BltInfo.height != window->in_buffer_height
+        || ! window->buffer) {
+        crFree(window->buffer);
+
+        window->buffer = crCalloc(window->BltInfo.width * window->BltInfo.height
+                                                            * 4 * sizeof (GLubyte));
+        
+        window->in_buffer_width = window->BltInfo.width;
+        window->in_buffer_height = window->BltInfo.height;
+
+        crDebug("Render SPU: dimensions changed to %d x %d", window->BltInfo.width, window->BltInfo.height);
+    }
+}
+#endif
+
+
+void
+renderspu_SystemMakeCurrent( WindowInfo *window, GLint nativeWindow,
+                             ContextInfo *context )
+{
+    Bool b;
+
+    CRASSERT(render_spu.ws.glXMakeCurrent);
+
+    /*crDebug("%s nativeWindow=0x%x", __FUNCTION__, (int) nativeWindow);*/
+
+#ifdef USE_OSMESA
+    if (render_spu.use_osmesa) {
+        check_buffer_size(window);
+        render_spu.OSMesaMakeCurrent( (OSMesaContext) context->context, 
+                                                                    window->buffer, GL_UNSIGNED_BYTE,
+                                                                    window->BltInfo.width, window->BltInfo.height);
+        return;
+    }
+#endif
+
+    nativeWindow = 0;
+
+    if (window && context) {
+        window->appWindow = nativeWindow;
+
+        if (window->visual != context->visual) {
+            crDebug("Render SPU: MakeCurrent visual mismatch (win(%d) bits:0x%x != ctx(%d) bits:0x%x); remaking window.",
+                            window->BltInfo.Base.id, window->visual->visAttribs,
+                            context->BltInfo.Base.id, context->visual->visAttribs);
+            /*
+             * XXX have to revisit this issue!!!
+             *
+             * But for now we destroy the current window
+             * and re-create it with the context's visual abilities
+             */
+#ifndef SOLARIS_9_X_BUG
+          /*
+            I'm having some really weird issues if I destroy this window 
+            when I'm using the version of sunX that comes with Solaris 9.
+            Subsiquent glX calls return GLXBadCurrentWindow error. 
+
+            This is an issue even when running Linux version and using 
+            the Solaris 9 sunX as a display.
+            -- jw
+
+                jw: we might have to call glXMakeCurrent(dpy, 0, 0) to unbind
+        the context from the window before destroying it. -Brian
+          */
+            render_spu.ws.glXMakeCurrent(window->visual->dpy, 0, 0);
+            renderspu_SystemDestroyWindow( window );
+#endif 
+            renderspu_SystemCreateWindow( context->visual, window->visible, window );
+            /*
+            crError("In renderspu_SystemMakeCurrent() window and context"
+                            " weren't created with same visual!");
+            */
+        }
+
+        CRASSERT(context->context);
+
+#if 0
+        if (render_spu.render_to_crut_window) {
+            if (render_spu.crut_drawable == 0) {
+                /* We don't know the X drawable ID yet.  Ask mothership for it. */
+                char response[8096];
+                CRConnection *conn = crMothershipConnect();
+                if (!conn)
+                {
+                    crError("Couldn't connect to the mothership to get CRUT drawable-- "
+                                    "I have no idea what to do!");
+                }
+                crMothershipGetParam( conn, "crut_drawable", response );
+                render_spu.crut_drawable = crStrToInt(response);
+                crMothershipDisconnect(conn);
+
+                crDebug("Render SPU: using CRUT drawable: 0x%x",
+                                render_spu.crut_drawable);
+                if (!render_spu.crut_drawable) {
+                    crDebug("Render SPU: Crut drawable 0 is invalid");
+                    /* Continue with nativeWindow = 0; we'll render to the window that
+                     * we (the Render SPU) previously created.
+                     */
+                }
+            }
+
+            nativeWindow = render_spu.crut_drawable;
+        }
+#endif
+
+        if ((render_spu.render_to_crut_window || render_spu.render_to_app_window)
+                && nativeWindow)
+        {
+            /* We're about to bind the rendering context to a window that we
+             * (the Render SPU) did not create.  The window was created by the
+             * application or the CRUT server.
+             * Make sure the window ID is valid and that the window's X visual is
+             * the same as the rendering context's.
+             */
+            if (WindowExists(window->visual->dpy, nativeWindow))
+            {
+                int vid = GetWindowVisualID(window->visual->dpy, nativeWindow);
+                GLboolean recreated = GL_FALSE;
+
+                /* check that the window's visual and context's visual match */
+                if (vid != (int) context->visual->visual->visualid) {
+                    crWarning("Render SPU: Can't bind context %d to CRUT/native window "
+                                        "0x%x because of different X visuals (0x%x != 0x%x)!",
+                                        context->BltInfo.Base.id, (int) nativeWindow,
+                                        vid, (int) context->visual->visual->visualid);
+                    crWarning("Render SPU: Trying to recreate GLX context to match.");
+                    /* Try to recreate the GLX context so that it uses the same
+                     * GLX visual as the window.
+                     */
+#if !USE_GLX_COPYCONTEXT
+                    if (context->everCurrent) {
+                        get_state(&SavedState);
+                    }
+#endif
+                    renderspu_RecreateContext(context, vid);
+                    recreated = GL_TRUE;
+                }
+
+                /* OK, this should work */
+                window->nativeWindow = (Window) nativeWindow;
+                b = render_spu.ws.glXMakeCurrent( window->visual->dpy,
+                                                  window->nativeWindow,
+                                                  context->context );
+                CRASSERT(b);
+#if !USE_GLX_COPYCONTEXT
+                if (recreated) {
+                    set_state(&SavedState);
+                }
+#endif
+            }
+            else
+            {
+                crWarning("Render SPU: render_to_app/crut_window option is set but "
+                                    "the window ID 0x%x is invalid on the display named %s",
+                                    (unsigned int) nativeWindow,
+                                    DisplayString(window->visual->dpy));
+                CRASSERT(window->window);
+                b = render_spu.ws.glXMakeCurrent( window->visual->dpy,
+                                                  window->window, context->context );
+                CRASSERT(b);
+            }
+        }
+        else
+        {
+            /* This is the normal case - rendering to the render SPU's own window */
+            CRASSERT(window->window);
+#if 0
+            crDebug("calling glXMakecurrent(%p, 0x%x, 0x%x)",
+                                    window->visual->dpy,
+                                    (int) window->window, (int) context->context );
+#endif
+            b = render_spu.ws.glXMakeCurrent( window->visual->dpy,
+                                              window->window, context->context );
+            if (!b) {
+                crWarning("glXMakeCurrent(%p, 0x%x, %p) failed! (winId %d, ctxId %d)",
+                                    window->visual->dpy,
+                                    (int) window->window, (void *) context->context,
+                                    window->BltInfo.Base.id, context->BltInfo.Base.id );
+            }
+            /*CRASSERT(b);*/
+        }
+
+        /* XXX this is a total hack to work around an NVIDIA driver bug */
+#if 0
+        if (render_spu.self.GetFloatv && context->haveWindowPosARB) {
+            GLfloat f[4];
+            render_spu.self.GetFloatv(GL_CURRENT_RASTER_POSITION, f);
+            if (!window->everCurrent || f[1] < 0.0) {
+                crDebug("Render SPU: Resetting raster pos");
+                render_spu.self.WindowPos2iARB(0, 0);
+            }
+        }
+#endif
+    }
+    else
+    {
+        GET_CONTEXT(pCurCtx);
+        if (pCurCtx)
+        {
+            b = render_spu.ws.glXMakeCurrent( pCurCtx->currentWindow->visual->dpy, None, NULL);
+            if (!b) {
+                crWarning("glXMakeCurrent(%p, None, NULL) failed!", pCurCtx->currentWindow->visual->dpy);
+            }
+        }
+
+    }
+}
+
+
+/**
+ * Set window (or pbuffer) size.
+ */
+void
+renderspu_SystemWindowSize( WindowInfo *window, GLint w, GLint h )
+{
+#ifdef USE_OSMESA
+    if (render_spu.use_osmesa) {
+        window->BltInfo.width = w;
+        window->BltInfo.height = h;
+        check_buffer_size(window);
+        return;
+    }
+#endif
+
+    CRASSERT(window);
+    CRASSERT(window->visual);
+    if (window->visual->visAttribs & CR_PBUFFER_BIT)
+    {
+        /* resizing a pbuffer */
+        if (render_spu.pbufferWidth != 0 || render_spu.pbufferHeight != 0) {
+            /* size limit check */
+            if (w > render_spu.pbufferWidth || h > render_spu.pbufferHeight) {
+                crWarning("Render SPU: Request for %d x %d pbuffer is larger than "
+                                    "the configured size of %d x %d. ('pbuffer_size')",
+                                    w, h, render_spu.pbufferWidth, render_spu.pbufferHeight);
+                return;
+            }
+            /*
+             * If the requested new pbuffer size is greater than 1/2 the size of
+             * the max pbuffer, just use the max pbuffer size.  This helps avoid
+             * problems with VRAM memory fragmentation.  If we run out of VRAM
+             * for pbuffers, some drivers revert to software rendering.  We want
+             * to avoid that!
+             */
+            if (w * h >= render_spu.pbufferWidth * render_spu.pbufferHeight / 2) {
+                /* increase the dimensions to the max pbuffer size now */
+                w = render_spu.pbufferWidth;
+                h = render_spu.pbufferHeight;
+            }
+        }
+
+        if (window->BltInfo.width != w || window->BltInfo.height != h) {
+            /* Only resize if the new dimensions really are different */
+#ifdef CHROMIUM_THREADSAFE
+            ContextInfo *currentContext = (ContextInfo *) crGetTSD(&_RenderTSD);
+#else
+            ContextInfo *currentContext = render_spu.currentContext;
+#endif
+            /* Can't resize pbuffers, so destroy it and make a new one */
+            render_spu.ws.glXDestroyPbuffer(window->visual->dpy, window->window);
+            window->BltInfo.width = w;
+            window->BltInfo.height = h;
+            crDebug("Render SPU: Creating new %d x %d PBuffer (id=%d)",
+                            w, h, window->BltInfo.Base.id);
+            if (!createPBuffer(window->visual, window)) {
+                crWarning("Render SPU: Unable to create PBuffer (out of VRAM?)!");
+            }
+            else if (currentContext && currentContext->currentWindow == window) {
+                /* Determine if we need to bind the current context to new pbuffer */
+                render_spu.ws.glXMakeCurrent(window->visual->dpy,
+                                             window->window,
+                                             currentContext->context );
+            }
+        }
+    }
+    else {
+        if (!w || !h)
+        {
+            /* X can not handle zero sizes */
+            if (window->visible)
+            {
+                renderspu_SystemShowWindow( window, GL_FALSE );
+            }
+            return;
+        }
+        /* Resize ordinary X window */
+        /*
+         * This is ugly, but it seems to be the only thing that works.
+         * Basically, XResizeWindow() doesn't seem to always take effect
+         * immediately.
+         * Even after an XSync(), the GetWindowAttributes() call will sometimes
+         * return the old window size.  So, we use a loop to repeat the window
+         * resize until it seems to take effect.
+         */
+        int attempt;
+        crDebug("Render SPU: XResizeWindow (%x, %x, %d, %d)", window->visual->dpy, window->window, w, h);
+        XResizeWindow(window->visual->dpy, window->window, w, h);
+        XSync(window->visual->dpy, 0);
+        
+        if (!window->BltInfo.width || !window->BltInfo.height)
+        {
+            /* we have hidden the window instead of sizing it to (0;0) since X is unable to handle zero sizes */
+            if (window->visible)
+            {
+                renderspu_SystemShowWindow( window, GL_TRUE );
+                return;
+            }
+        }
+#if 0
+        for (attempt = 0; attempt < 3; attempt++) { /* try three times max */
+            XWindowAttributes attribs;
+            /* Now, query the window size */
+            XGetWindowAttributes(window->visual->dpy, window->window, &attribs);
+            if (attribs.width == w && attribs.height == h)
+                break;
+            /* sleep for a millisecond and try again */
+            crMsleep(1);
+        }
+#endif
+    }
+}
+
+
+void
+renderspu_SystemGetWindowGeometry( WindowInfo *window,
+                                   GLint *x, GLint *y, GLint *w, GLint *h )
+{
+#ifdef USE_OSMESA
+    if (render_spu.use_osmesa) {
+        *w = window->BltInfo.width;
+        *h = window->BltInfo.height;
+        return;
+    }
+#endif
+
+    CRASSERT(window);
+    CRASSERT(window->visual);
+    CRASSERT(window->window);
+    if (window->visual->visAttribs & CR_PBUFFER_BIT)
+    {
+        *x = 0;
+        *y = 0;
+        *w = window->BltInfo.width;
+        *h = window->BltInfo.height;
+    }
+    else
+    {
+        Window xw, child, root;
+        unsigned int width, height, bw, d;
+        int rx, ry;
+
+        if ((render_spu.render_to_app_window || render_spu.render_to_crut_window)
+                && window->nativeWindow) {
+            xw = window->nativeWindow;
+        }
+        else {
+            xw = window->window;
+        }
+
+        XGetGeometry(window->visual->dpy, xw, &root,
+                                 x, y, &width, &height, &bw, &d);
+
+        /* translate x/y to screen coords */
+        if (!XTranslateCoordinates(window->visual->dpy, xw, root,
+                                   0, 0, &rx, &ry, &child)) {
+            rx = ry = 0;
+        }
+        *x = rx;
+        *y = ry;
+        *w = (int) width;
+        *h = (int) height;
+    }
+}
+
+
+void
+renderspu_SystemGetMaxWindowSize( WindowInfo *window, GLint *w, GLint *h )
+{
+     int scrn;
+#ifdef USE_OSMESA
+    if (render_spu.use_osmesa) {
+        *w = 2048;
+        *h = 2048;
+        return;
+    }
+#endif
+
+    CRASSERT(window);
+    CRASSERT(window->visual);
+    CRASSERT(window->window);
+
+    scrn = DefaultScreen(window->visual->dpy);
+    *w = DisplayWidth(window->visual->dpy, scrn);
+    *h = DisplayHeight(window->visual->dpy, scrn);
+}
+
+
+void
+renderspu_SystemWindowPosition( WindowInfo *window, GLint x, GLint y )
+{
+#ifdef USE_OSMESA
+    if (render_spu.use_osmesa)
+        return;
+#endif
+
+    CRASSERT(window);
+    CRASSERT(window->visual);
+    if ((window->visual->visAttribs & CR_PBUFFER_BIT) == 0)
+    {
+        crDebug("Render SPU: XMoveWindow (%x, %x, %d, %d)", window->visual->dpy, window->window, x, y);
+        XMoveWindow(window->visual->dpy, window->window, x, y);
+        XSync(window->visual->dpy, 0);
+    }
+}
+
+GLboolean renderspu_SystemWindowNeedEmptyPresent(WindowInfo *window)
+{
+    return GL_FALSE;
+}
+
+void
+renderspu_SystemWindowVisibleRegion( WindowInfo *window, GLint cRects, const GLint *pRects )
+{
+#ifdef USE_OSMESA
+    if (render_spu.use_osmesa)
+        return;
+#endif
+
+    CRASSERT(window);
+    CRASSERT(window->visual);
+    if ((window->visual->visAttribs & CR_PBUFFER_BIT) == 0)
+    {
+        int evb, erb, i;
+        XRectangle *pXRects;
+
+        if (!XShapeQueryExtension(window->visual->dpy, &evb, &erb))
+        {
+            crWarning("Render SPU: Display %s doesn't support SHAPE extension", window->visual->displayName);
+            return;
+        }
+
+        if (cRects>0)
+        {
+            pXRects = (XRectangle *) crAlloc(cRects * sizeof(XRectangle));
+
+            for (i=0; i<cRects; ++i)
+            {
+                pXRects[i].x = (short) pRects[4*i];
+                pXRects[i].y = (short) pRects[4*i+1];
+                pXRects[i].width = (unsigned short) (pRects[4*i+2]-pRects[4*i]);
+                pXRects[i].height = (unsigned short) (pRects[4*i+3]-pRects[4*i+1]);
+            }
+        }
+        else
+        {
+            pXRects = (XRectangle *) crAlloc(sizeof(XRectangle));
+            pXRects[0].x = 0;
+            pXRects[0].y = 0;
+            pXRects[0].width = 0;
+            pXRects[0].height = 0;
+            cRects = 1;
+        }
+
+        crDebug("Render SPU: XShapeCombineRectangles (%x, %x, cRects=%i)", window->visual->dpy, window->window, cRects);
+
+        XShapeCombineRectangles(window->visual->dpy, window->window, ShapeBounding, 0, 0,
+                                pXRects, cRects, ShapeSet, YXBanded);
+        XSync(window->visual->dpy, 0);
+        crFree(pXRects);
+    }
+}
+
+/* Either show or hide the render SPU's window. */
+void
+renderspu_SystemShowWindow( WindowInfo *window, GLboolean showIt )
+{
+#ifdef USE_OSMESA
+    if (render_spu.use_osmesa)
+        return;
+#endif
+
+    if (window->visual->dpy && window->window &&
+            (window->visual->visAttribs & CR_PBUFFER_BIT) == 0)
+    {
+        if (showIt)
+        {
+            if (window->BltInfo.width && window->BltInfo.height)
+            {
+                XMapWindow( window->visual->dpy, window->window );
+                XSync(window->visual->dpy, 0);
+            }
+        }
+        else
+        {
+            XUnmapWindow( window->visual->dpy, window->window );
+            XSync(window->visual->dpy, 0);
+        }
+    }
+}
+
+void renderspu_SystemVBoxPresentComposition( WindowInfo *window, const struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry )
+{
+    /* The !render_spu.force_present_main_thread code flow is actually inspired
+     * by cocoa backend impl, here it forces rendering in WinCmd thread rather
+     * than a Main thread.  It defaults to 1, because otherwise there were
+     * 3D driver incompatibilities on some systems. Elsewhere it causes flicker
+     * on NVidia GPUs. In principle would need root cause investigation. */
+    if (!render_spu.force_present_main_thread)
+    {
+        const struct VBOXVR_SCR_COMPOSITOR *pCompositor;
+        /* we do not want to be blocked with the GUI thread here, so only draw here if we are really able to do that w/o blocking */
+        int rc = renderspuVBoxCompositorTryAcquire(window, &pCompositor);
+        if (RT_SUCCESS(rc))
+        {
+            renderspuVBoxPresentCompositionGeneric(window, pCompositor, pChangedEntry, 0, false);
+            renderspuVBoxCompositorRelease(window);
+        }
+        else if (rc != VERR_SEM_BUSY)
+        {
+            /* this is somewhat we do not expect */
+            WARN(("renderspuVBoxCompositorTryAcquire failed rc %d", rc));
+            return;
+        }
+    }
+
+    {
+        Status status;
+        XEvent event;
+        render_spu.self.Flush();
+//        renderspuVBoxPresentBlitterEnsureCreated(window, 0);
+
+        crMemset(&event, 0, sizeof (event));
+        event.type = Expose;
+        event.xexpose.window = window->window;
+        event.xexpose.width = window->BltInfo.width;
+        event.xexpose.height = window->BltInfo.height;
+        status = XSendEvent(render_spu.pCommunicationDisplay, render_spu.WinCmdWindow.window, False, 0, &event);
+        if (!status)
+        {
+            WARN(("XSendEvent returned null"));
+        }
+        XFlush(render_spu.pCommunicationDisplay);
+    }
+}
+
+static void
+MarkWindow(WindowInfo *w)
+{
+    static GC gc = 0;  /* XXX per-window??? */
+    if (!gc) {
+        /* Create a GC for drawing invisible lines */
+        XGCValues gcValues;
+        gcValues.function = GXnoop;
+        gc = XCreateGC(w->visual->dpy, w->nativeWindow, GCFunction, &gcValues);
+    }
+    XDrawLine(w->visual->dpy, w->nativeWindow, gc, 0, 0, w->BltInfo.width, w->BltInfo.height);
+}
+
+
+void
+renderspu_SystemSwapBuffers( WindowInfo *w, GLint flags )
+{
+    CRASSERT(w);
+
+#if 00 /*TEMPORARY - FOR TESTING SWAP LOCK*/
+    if (1) {
+        /* random delay */
+        int k = crRandInt(1000 * 100, 750*1000);
+        static int first = 1;
+        if (first) {
+             crRandAutoSeed();
+             first = 0;
+        }
+        usleep(k);
+    }
+#endif
+
+    /* render_to_app_window:
+     * w->nativeWindow will only be non-zero if the
+     * render_spu.render_to_app_window option is true and
+     * MakeCurrent() recorded the nativeWindow handle in the WindowInfo
+     * structure.
+     */
+    if (w->nativeWindow) {
+        render_spu.ws.glXSwapBuffers( w->visual->dpy, w->nativeWindow );
+#if 0
+        MarkWindow(w);
+#else
+        (void) MarkWindow;
+#endif
+    }
+    else {
+        render_spu.ws.glXSwapBuffers( w->visual->dpy, w->window );
+    }
+}
+
+void renderspu_SystemReparentWindow(WindowInfo *window)
+{
+    Window parent;
+
+    parent = render_spu_parent_window_id>0 ? render_spu_parent_window_id : 
+                                             RootWindow(window->visual->dpy, window->visual->visual->screen);
+
+    XReparentWindow(window->visual->dpy, window->window, parent, window->x, window->y);
+    XSync(window->visual->dpy, False);
+}
+
+void renderspu_SystemDefaultSharedContextChanged(ContextInfo *fromContext, ContextInfo *toContext)
+{
+
+}
+
+uint32_t renderspu_SystemPostprocessFunctions(SPUNamedFunctionTable *aFunctions, uint32_t cFunctions, uint32_t cTable)
+{
+    return cFunctions;
+}