Changeset 30440 in vbox

Timestamp:

Jun 24, 2010 6:51:20 PM (14 years ago)

Author:

vboxsync

Message:

crOpenGL: wddm friendly windows info tracking + more consistent updates (disabled except windows yet)

Location:

trunk

Files:

• include/VBox/HostServices/VBoxCrOpenGLSvc.h (modified) (3 diffs)
• src/VBox/Additions/common/crOpenGL/Makefile.kmk (modified) (2 diffs)
• src/VBox/Additions/common/crOpenGL/context.c (modified) (10 diffs)
• src/VBox/Additions/common/crOpenGL/fakedri_drv.c (modified) (2 diffs)
• src/VBox/Additions/common/crOpenGL/glx.c (modified) (20 diffs)
• src/VBox/Additions/common/crOpenGL/load.c (modified) (16 diffs)
• src/VBox/Additions/common/crOpenGL/pack/packspu.h (modified) (1 diff)
• src/VBox/Additions/common/crOpenGL/pack/packspu_context.c (modified) (1 diff)
• src/VBox/Additions/common/crOpenGL/pack/packspu_misc.c (modified) (2 diffs)
• src/VBox/Additions/common/crOpenGL/pack/packspu_special (modified) (1 diff)
• src/VBox/Additions/common/crOpenGL/stub.c (modified) (8 diffs)
• src/VBox/Additions/common/crOpenGL/stub.h (modified) (4 diffs)
• src/VBox/GuestHost/OpenGL/glapi_parser/APIspec.txt (modified) (1 diff)
• src/VBox/GuestHost/OpenGL/glapi_parser/apiutil.py (modified) (1 diff)
• src/VBox/GuestHost/OpenGL/include/cr_net.h (modified) (1 diff)
• src/VBox/GuestHost/OpenGL/state_tracker/state_init.c (modified) (1 diff)
• src/VBox/GuestHost/OpenGL/util/vboxhgcm.c (modified) (3 diffs)
• src/VBox/HostServices/SharedOpenGL/crserver/crservice.cpp (modified) (1 diff)
• src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c (modified) (2 diffs)

trunk/include/VBox/HostServices/VBoxCrOpenGLSvc.h

@@ -43 +43 @@
 #define SHCRGL_GUEST_FN_WRITE_READ  (4)
 #define SHCRGL_GUEST_FN_SET_VERSION (6)
+#define SHCRGL_GUEST_FN_INJECT      (9)
 
 /* Parameters count */
@@ -53 +54 @@
 #define SHCRGL_CPARMS_SET_VERSION (2)
 #define SHCRGL_CPARMS_SCREEN_CHANGED (1)
+#define SHCRGL_CPARMS_INJECT (2)
 
 /**
@@ -125 +127 @@
 } CRVBOXHGCMSETVERSION;
 
+/** GUEST_FN_INJECT Parameters structure. */
+typedef struct
+{
+    VBoxGuestHGCMCallInfo   hdr;
+
+    /** 32bit, in
+     *  ClientID to inject commands buffer for
+     */
+    HGCMFunctionParameter   u32ClientID;
+    /** pointer, in
+     *  Data buffer
+     */
+    HGCMFunctionParameter   pBuffer;
+} CRVBOXHGCMINJECT;
+
 #endif

trunk/src/VBox/Additions/common/crOpenGL/Makefile.kmk

@@ -130 +130 @@
    VBoxOGL_SOURCES.solaris += \
         $(VBOX_PATH_CROGL_GENFILES)/solaris_glxapi_exports.asm \
-        $(VBOX_PATH_CROGL_GENFILES)/solaris_exports_dri.asm \
+        $(VBOX_PATH_CROGL_GENFILES)/solaris_exports_dri.asm
    VBoxOGL_SOURCES.linux += \
         $(VBOX_PATH_CROGL_GENFILES)/linux_glxapi_exports.asm \
@@ -136 +136 @@
    VBoxOGL_SOURCES.freebsd += \
         $(VBOX_PATH_CROGL_GENFILES)/freebsd_glxapi_exports.asm \
-        $(VBOX_PATH_CROGL_GENFILES)/freebsd_exports_dri.asm \
-
+        $(VBOX_PATH_CROGL_GENFILES)/freebsd_exports_dri.asm
   else
    VBoxOGL_SOURCES.solaris += \

trunk/src/VBox/Additions/common/crOpenGL/context.c

@@ -140 +140 @@
     winInfo->cVisibleRegions = 0;
 #endif
+#ifdef CR_NEWWINTRACK
+    winInfo->u32ClientID = stub.spu->dispatch_table.VBoxPackGetInjectID();
+#endif
     winInfo->spuWindow = spuWin;
 
@@ -158 +161 @@
     if (win->dpy) {
     XWindowAttributes attr;
+    XLOCK(win->dpy);
     XGetWindowAttributes(win->dpy, win->drawable, &attr);
+    XUNLOCK(win->dpy);
     return (attr.map_state != IsUnmapped);
     }
@@ -216 +221 @@
     winInfo->mapped = -1; /* don't know */
     winInfo->pOwner = NULL;
+#ifdef CR_NEWWINTRACK
+    winInfo->u32ClientID = -1;
+#endif
 #ifndef WINDOWS
     crHashtableAdd(stub.windowTable, (unsigned int) drawable, winInfo);
@@ -570 +578 @@
     //       Disabling those tripples glxgears fps, thus using xevens instead of per frame polling is much more preffered.
     //@todo: Check similiar on windows guests, though doubtfull as there're no XSync like calls on windows.
+    if (window && window->dpy)
+    {
+        XLOCK(window->dpy);
+    }
+
     if (!window
         || !window->dpy
@@ -581 +594 @@
         *x = *y = 0;
         *w = *h = 0;
+    }
+
+    if (window && window->dpy)
+    {
+        XUNLOCK(window->dpy);
     }
 }
@@ -638 +656 @@
     unsigned int mask;
     int x, y;
+
+    XLOCK(window->dpy);
+
     Bool q = XQueryPointer(window->dpy, window->drawable, &root, &child,
                                                  &rootX, &rootY, &pos[0], &pos[1], &mask);
@@ -649 +670 @@
         pos[0] = pos[1] = 0;
     }
+
+    XUNLOCK(window->dpy);
 }
 
@@ -854 +877 @@
                 /*crDebug("(1)stubMakeCurrent ctx=%p(%i) window=%p(%i)", context, context->spuContext, window, window->spuWindow);*/
                 window->spuWindow = stub.spu->dispatch_table.WindowCreate( window->dpyName, context->visBits );
+#ifdef CR_NEWWINTRACK
+                window->u32ClientID = stub.spu->dispatch_table.VBoxPackGetInjectID();
+#endif
+
             }
         }
@@ -922 +949 @@
                         unsigned int border, depth, w, h;
 
+                        XLOCK(context->currentDrawable->dpy);
                         if (!XGetGeometry(context->currentDrawable->dpy, context->currentDrawable->drawable, &root, &x, &y, &w, &h, &border, &depth))
                         {
                             crWindowDestroy((GLint)context->currentDrawable->drawable);
                         }
+                        XUNLOCK(context->currentDrawable->dpy);
 #endif
                     
@@ -980 +1009 @@
         if (stub.trackWindowSize)
             stub.spuDispatch.WindowSize( window->spuWindow, winW, winH );
+        if (stub.trackWindowPos)
+            stub.spuDispatch.WindowPosition(window->spuWindow, x, y);
         if (winW > 0 && winH > 0)
             stub.spu->dispatch_table.Viewport( 0, 0, winW, winH );

trunk/src/VBox/Additions/common/crOpenGL/fakedri_drv.c

@@ -334 +334 @@
 void __attribute__ ((constructor)) vbox_install_into_mesa(void)
 {
-    if (!stubInit())
-    {
-        crDebug("vboxdriInitScreen: stubInit failed");
-        return;
-    }
-
     {
         void (*pxf86Msg)(MessageType type, const char *format, ...) _printf_attribute(2,3);
@@ -354 +348 @@
             return;
         }
+    }
+
+    if (!stubInit())
+    {
+        crDebug("vboxdriInitScreen: stubInit failed");
+        return;
     }
 

trunk/src/VBox/Additions/common/crOpenGL/glx.c

@@ -457 +457 @@
         return NULL;
 
+    XLOCK(dpy);
     searchvis.visualid = XVisualIDFromVisual(DefaultVisual(dpy, screen));
     pret = XGetVisualInfo(dpy, VisualIDMask, &searchvis, &nvisuals);
+    XUNLOCK(dpy);
       
     if (nvisuals!=1) crWarning("glXChooseVisual: XGetVisualInfo returned %i visuals for %x", nvisuals, (unsigned int) searchvis.visualid);
@@ -644 +646 @@
 
         if (context && context->type == UNDECIDED) {
+            XLOCK(dpy);
             XSync(dpy, 0); /* sync to force window creation on the server */
+            XUNLOCK(dpy);
         }
     }
@@ -1452 +1456 @@
     if (pGlxPixmap)
     {
+        XLOCK(dpy);
         if (pGlxPixmap->gc)
         {
@@ -1461 +1466 @@
             XFreePixmap(dpy, pGlxPixmap->hShmPixmap);
         }
+        XUNLOCK(dpy);
 
         if (pGlxPixmap->hDamage>0)
@@ -1637 +1643 @@
     /*@todo doesn't really list all the common visuals, have to use some static list*/
     searchvis.screen = screen;
+    XLOCK(dpy);
     pVisuals = XGetVisualInfo(dpy, VisualScreenMask, &searchvis, nelements);
+    XUNLOCK(dpy);
 
     if (*nelements)
@@ -1664 +1672 @@
 
     *nelements = 1;
+    XLOCK(dpy);
     *pGLXFBConfigs = (GLXFBConfig) XVisualIDFromVisual(DefaultVisual(dpy, screen));
+    XUNLOCK(dpy);
 
     crDebug("glXGetFBConfigs returned %i configs", *nelements);
@@ -1712 +1722 @@
 
         temp.visualid = (VisualID)config;
+        XLOCK(dpy);
         pret = XGetVisualInfo(dpy, VisualIDMask, &temp, &nret);
+        XUNLOCK(dpy);
         
         if (nret!=1) crWarning("XGetVisualInfo returned %i visuals for %p", nret, config);
@@ -1781 +1793 @@
 
     /* Check for extension and pixmaps format */
-
+    XLOCK(dpy);
     if (!XShmQueryExtension(dpy))
     {
         crWarning("No XSHM extension");
+        XUNLOCK(dpy);
         return;
     }
@@ -1791 +1804 @@
     {
         crWarning("XSHM extension doesn't support pixmaps");
+        XUNLOCK(dpy);
         return;
     }
@@ -1797 +1811 @@
     {
         crWarning("XSHM extension doesn't support ZPixmap format");
+        XUNLOCK(dpy);
         return;
     }
+    XUNLOCK(dpy);
 
     /* Alloc shared memory, so far using hardcoded value...could fail for bigger displays one day */
@@ -1817 +1833 @@
     }
 
-
+    XLOCK(dpy);
     if (!XShmAttach(dpy, &stub.xshmSI))
     {
@@ -1823 +1839 @@
         shmctl(stub.xshmSI.shmid, IPC_RMID, 0);
         shmdt(stub.xshmSI.shmaddr);
+        XUNLOCK(dpy);
         return;
     }
+    XUNLOCK(dpy);
 
     stub.bShmInitFailed = GL_FALSE;
@@ -1915 +1933 @@
     CRASSERT(pContext && pCreateInfoPixmap);
 
+    XLOCK(dpy);
     if (!XGetGeometry(dpy, (Pixmap)draw, &root, &x, &y, &w, &h, &border, &depth))
     {
@@ -1921 +1940 @@
         {
             crWarning("stubInitGlxPixmap failed in call to XGetGeometry for 0x%x", (int) draw);
+            XUNLOCK(dpy);
             return NULL;
         }
@@ -1929 +1949 @@
     {
         crWarning("stubInitGlxPixmap failed to allocate memory");
+        XUNLOCK(dpy);
         return NULL;
     }
@@ -1965 +1986 @@
         pGlxPixmap->hShmPixmap = 0;
     }
+    XUNLOCK(dpy);
 
     stubInitXDamageExtension(pContext);
@@ -2036 +2058 @@
     else
     {
+        XLOCK(dpy);
         XCopyArea(dpy, (Pixmap)draw, pGlxPixmap->hShmPixmap, pGlxPixmap->gc, 
                   pGlxPixmap->x, pGlxPixmap->y, pGlxPixmap->w, pGlxPixmap->h, 0, 0);
         /* Have to make sure XCopyArea is processed */
         XSync(dpy, False);
+        XUNLOCK(dpy);
         stub.spu->dispatch_table.TexImage2D(pGlxPixmap->target, 0, pGlxPixmap->format, pGlxPixmap->w, pGlxPixmap->h, 0, 
                                             GL_BGRA, GL_UNSIGNED_BYTE, stub.xshmSI.shmaddr);
@@ -2078 +2102 @@
         GLint origUnpackRowLength;
 
+        XLOCK(dpy);
         XCopyArea(dpy, (Pixmap)draw, pGlxPixmap->hShmPixmap, pGlxPixmap->gc, 
                   pRect->x, pRect->y, pRect->width, pRect->height, 0, 0);
         /* Have to make sure XCopyArea is processed */
         XSync(dpy, False);
+        XUNLOCK(dpy);
 
         /* Save original value, doesn't cause sync as it's reported by state tracker*/
@@ -2159 +2185 @@
         /* Sync connections, note that order of syncs is important here.
          * First make sure client commands are finished, then make sure we get all the damage events back*/
+        XLOCK(dpy);
         XSync(dpy, False);
+        XUNLOCK(dpy);
         XSync(stub.currentContext->damageDpy, False);
 
@@ -2179 +2207 @@
         XImage *pxim;
 
+        XLOCK(dpy);
         pxim = XGetImage(dpy, (Pixmap)draw, pGlxPixmap->x, pGlxPixmap->y, pGlxPixmap->w, pGlxPixmap->h, AllPlanes, ZPixmap);
+        XUNLOCK(dpy);
         /*if (pxim)
         {

trunk/src/VBox/Additions/common/crOpenGL/load.c

@@ -19 +19 @@
 #include <string.h>
 #include <signal.h>
+#include <iprt/initterm.h>
+#include <iprt/thread.h>
+#include <iprt/err.h>
+#include <iprt/asm.h>
 #ifndef WINDOWS
-#include <sys/types.h>
-#include <unistd.h>
+# include <sys/types.h>
+# include <unistd.h>
 #endif
 #ifdef CHROMIUM_THREADSAFE
@@ -80 +84 @@
 static ScissorFunc_t origScissor;
 
-static void stubCheckWindowState(WindowInfo *window)
+static void stubCheckWindowState(WindowInfo *window, GLboolean bFlushOnChange)
 {
     bool bForceUpdate = false;
+    bool bChanged = false;
 
 #ifdef WINDOWS
@@ -102 +107 @@
 #endif
 
-    stubUpdateWindowGeometry(window, bForceUpdate);
+    bChanged = stubUpdateWindowGeometry(window, bForceUpdate) || bForceUpdate;
 
 #if defined(GLX) || defined (WINDOWS)
     if (stub.trackWindowVisibleRgn)
     {
-        stubUpdateWindowVisibileRegions(window);
+        bChanged = stubUpdateWindowVisibileRegions(window) || bChanged;
     }
 #endif
@@ -117 +122 @@
             stub.spu->dispatch_table.WindowShow(window->spuWindow, mapped);
             window->mapped = mapped;
-        }
+            bChanged = true;
+        }
+    }
+
+    if (bFlushOnChange && bChanged)
+    {
+        stub.spu->dispatch_table.Flush();
     }
 }
@@ -133 +144 @@
     unsigned int border, depth, w, h;
 
+    XLOCK(pWindow->dpy);
     if (!XGetGeometry(pWindow->dpy, pWindow->drawable, &root, &x, &y, &w, &h, &border, &depth))
     {
+        XUNLOCK(pWindow->dpy);
         return false;
     }
+    XUNLOCK(pWindow->dpy);
 #endif
 
@@ -164 +178 @@
     }
 
-    stubCheckWindowState(pWindow);
+    stubCheckWindowState(pWindow, GL_FALSE);
 }
 
@@ -174 +188 @@
         return;
 
-    stubCheckWindowState(stub.currentContext->currentDrawable);
-
+#if defined(CR_NEWWINTRACK) && !defined(WINDOWS)
+    crLockMutex(&stub.mutex);
+#endif
+
+    stubCheckWindowState(stub.currentContext->currentDrawable, GL_TRUE);
     crHashtableWalk(stub.windowTable, stubCheckWindowsCB, stub.currentContext);
+
+#if defined(CR_NEWWINTRACK) && !defined(WINDOWS)
+    crUnlockMutex(&stub.mutex);
+#endif
 }
 
@@ -253 +274 @@
         origDrawBuffer = stub.spuDispatch.DrawBuffer;
         origScissor = stub.spuDispatch.Scissor;
+#ifndef CR_NEWWINTRACK
         stub.spuDispatch.Clear = trapClear;
         stub.spuDispatch.Viewport = trapViewport;
+#endif
         if (stub.viewportHack)
             stub.spuDispatch.Scissor = trapScissor;
@@ -282 +305 @@
 
 #ifdef WINDOWS
+# ifndef CR_NEWWINTRACK
     stubUninstallWindowMessageHook();
+# endif
+#endif
+
+#ifdef CR_NEWWINTRACK
+    ASMAtomicWriteBool(&stub.bShutdownSyncThread, true);
 #endif
   
@@ -330 +359 @@
 #endif
     crDebug("stubSPUSafeTearDown");
+
+#ifdef WINDOWS
+# ifndef CR_NEWWINTRACK
+    stubUninstallWindowMessageHook();
+# endif
+#endif
+
+#if defined(WINDOWS) && defined(CR_NEWWINTRACK)
+    crUnlockMutex(mutex);
+    if (RTThreadGetState(stub.hSyncThread)!=RTTHREADSTATE_TERMINATED)
+    {
+        ASMAtomicWriteBool(&stub.bShutdownSyncThread, true);
+        if (PostThreadMessage(RTThreadGetNative(stub.hSyncThread), WM_QUIT, 0, 0))
+        {
+            RTThreadWait(stub.hSyncThread, 1000, NULL);
+        }
+        else
+        {
+            crDebug("Sync thread killed before DLL_PROCESS_DETACH");
+        }
+    }
+    crLockMutex(mutex);
+#endif
+
     crNetTearDown();
-#ifdef WINDOWS
-    stubUninstallWindowMessageHook();
-#endif
     crMemset(&stub, 0, sizeof(stub));
 #ifdef CHROMIUM_THREADSAFE
@@ -393 +443 @@
 
     stub.windowTable = crAllocHashtable();
+
+#ifdef CR_NEWWINTRACK
+    stub.bShutdownSyncThread = false;
+    stub.hSyncThread = NIL_RTTHREAD;
+#endif
 
     defaultWin = (WindowInfo *) crCalloc(sizeof(WindowInfo));
@@ -595 +650 @@
 }
 
+#ifdef CR_NEWWINTRACK
+static void stubSyncTrCheckWindowsCB(unsigned long key, void *data1, void *data2)
+{
+    WindowInfo *pWindow = (WindowInfo *) data1;
+    ContextInfo *pCtx = (ContextInfo *) data2;
+
+    if (pWindow->type!=CHROMIUM || pWindow->spuWindow==0)
+    {
+        return;
+    }
+
+    stub.spu->dispatch_table.VBoxPackSetInjectID(pWindow->u32ClientID);
+
+    if (!stubSystemWindowExist(pWindow))
+    {
+#ifdef WINDOWS
+        crWindowDestroy((GLint)pWindow->hWnd);
+#else
+        crWindowDestroy((GLint)pWindow->drawable);
+#endif
+        /*No need to flush here as crWindowDestroy does it*/
+        return;
+    }
+
+    stubCheckWindowState(pWindow, GL_TRUE);
+}
+
+static DECLCALLBACK(int) stubSyncThreadProc(RTTHREAD ThreadSelf, void *pvUser)
+{
+#ifdef WINDOWS
+    MSG msg;
+#endif
+
+    (void) pvUser;
+
+    crDebug("Sync thread started");
+#ifdef WINDOWS
+    PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
+#endif
+
+    crLockMutex(&stub.mutex);
+    stub.spu->dispatch_table.VBoxPackSetInjectThread();
+    crUnlockMutex(&stub.mutex);
+
+    RTThreadUserSignal(ThreadSelf);
+
+    while(!stub.bShutdownSyncThread)
+    {
+#ifdef WINDOWS
+        if (!PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
+        {
+            crHashtableWalk(stub.windowTable, stubSyncTrCheckWindowsCB, NULL);
+            RTThreadSleep(50);
+        }
+        else
+        {
+            if (WM_QUIT==msg.message)
+            {
+                crDebug("Sync thread got WM_QUIT");
+                break;
+            }
+            else
+            {
+                TranslateMessage(&msg);
+                DispatchMessage(&msg);
+            }
+        }
+#else
+        crLockMutex(&stub.mutex);
+        crHashtableWalk(stub.windowTable, stubSyncTrCheckWindowsCB, NULL);
+        crUnlockMutex(&stub.mutex);
+        RTThreadSleep(50);
+#endif
+    }
+
+    crDebug("Sync thread stopped");
+    return 0;
+}
+#endif
+
 /**
  * Do one-time initializations for the faker.
@@ -623 +758 @@
     stubInitVars();
 
+    crGetProcName(response, 1024);
+    crDebug("Stub launched for %s", response);
+
     /* @todo check if it'd be of any use on other than guests, no use for windows */
     app_id = crGetenv( "CR_APPLICATION_ID_NUMBER" );
@@ -644 +782 @@
             crNetFreeConnection(ns.conn);
         }
+#ifdef CR_NEWWINTRACK
+        {
+            Status st = XInitThreads();
+            if (st==0)
+            {
+                crWarning("XInitThreads returned %i", (int)st);
+            }
+        }
+#endif
     }
 #endif
@@ -692 +839 @@
 
 #ifdef WINDOWS
+# ifndef CR_NEWWINTRACK
     stubInstallWindowMessageHook();
+# endif
+#endif
+
+#ifdef CR_NEWWINTRACK
+    {
+        int rc;
+
+        RTR3Init();
+
+        crDebug("Starting sync thread");
+
+        rc = RTThreadCreate(&stub.hSyncThread, stubSyncThreadProc, NULL, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "Sync");
+        if (RT_FAILURE(rc))
+        {
+            crError("Failed to start sync thread! (%x)", rc);
+        }
+        RTThreadUserWait(stub.hSyncThread, 60 * 1000);
+        RTThreadUserReset(stub.hSyncThread);
+
+        crDebug("Going on");
+    }
 #endif
 
@@ -704 +873 @@
     return true;
 }
-
-
 
 /* Sigh -- we can't do initialization at load time, since Windows forbids 

trunk/src/VBox/Additions/common/crOpenGL/pack/packspu.h

@@ -35 +35 @@
     CRPackContext *packer;
     int writeback;
+    GLboolean bInjectThread;
 };
 

trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_context.c

@@ -36 +36 @@
     thread->id = id;
     thread->currentContext = NULL;
+    thread->bInjectThread = GL_FALSE;
 
     /* connect to the server */

trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_misc.c

@@ -108 +108 @@
     int writeback = 1;
 
-    crPackFlush();
-
-    if (packspuSyncOnFlushes())
-    {
-        crPackWriteback(&writeback);
+    if (!thread->bInjectThread)
+    {
+        crPackFlush();
+        if (packspuSyncOnFlushes())
+        {
+            crPackWriteback(&writeback);
+            packspuFlush( (void *) thread );
+            while (writeback)
+                crNetRecv();
+        }
+    }
+    else
+    {
         packspuFlush( (void *) thread );
-        while (writeback)
-            crNetRecv();
     }
 }
@@ -336 +342 @@
     }
 }
+
+#ifdef CHROMIUM_THREADSAFE
+void PACKSPU_APIENTRY packspu_VBoxPackSetInjectThread(void)
+{
+    crLockMutex(&_PackMutex);
+    {
+        GET_THREAD(thread);
+        CRASSERT(!thread);
+        CRASSERT((pack_spu.numThreads>0) && (pack_spu.numThreads<MAX_THREADS));
+
+        thread = &(pack_spu.thread[pack_spu.numThreads]);
+        thread->id = crThreadID();
+        thread->currentContext = NULL;
+        thread->bInjectThread = GL_TRUE;
+
+        thread->netServer.name = crStrdup(pack_spu.name);
+        thread->netServer.buffer_size = 64 * 1024;
+
+        crNetNewClient(pack_spu.thread[0].netServer.conn, &(thread->netServer));
+        CRASSERT(thread->netServer.conn);
+
+        CRASSERT(thread->packer == NULL);
+        thread->packer = crPackNewContext( pack_spu.swap );
+        CRASSERT(thread->packer);
+        crPackInitBuffer(&(thread->buffer), crNetAlloc(thread->netServer.conn),
+                         thread->netServer.conn->buffer_size, thread->netServer.conn->mtu);
+        thread->buffer.canBarf = thread->netServer.conn->Barf ? GL_TRUE : GL_FALSE;
+
+        crPackSetBuffer( thread->packer, &thread->buffer );
+        crPackFlushFunc( thread->packer, packspuFlush );
+        crPackFlushArg( thread->packer, (void *) thread );
+        crPackSendHugeFunc( thread->packer, packspuHuge );
+        crPackSetContext( thread->packer );
+
+        crSetTSD(&_PackTSD, thread);
+
+        pack_spu.numThreads++;
+    }
+    crUnlockMutex(&_PackMutex);
+}
+
+GLuint PACKSPU_APIENTRY packspu_VBoxPackGetInjectID(void)
+{
+    GLuint ret;
+
+    crLockMutex(&_PackMutex);
+    {
+        GET_THREAD(thread);
+        CRASSERT(thread && thread->netServer.conn && thread->netServer.conn->type==CR_VBOXHGCM);
+        ret = thread->netServer.conn->u32ClientID;
+    }
+    crUnlockMutex(&_PackMutex);
+
+    return ret;
+}
+
+void PACKSPU_APIENTRY packspu_VBoxPackSetInjectID(GLuint id)
+{
+    crLockMutex(&_PackMutex);
+    {
+        GET_THREAD(thread);
+        CRASSERT(thread && thread->netServer.conn && thread->netServer.conn->type==CR_VBOXHGCM);
+        thread->netServer.conn->u32InjectClientID = id;
+    }
+    crUnlockMutex(&_PackMutex);
+}
+#else  /*ifdef CHROMIUM_THREADSAFE*/
+void PACKSPU_APIENTRY packspu_VBoxPackSetInjectThread(void)
+{
+}
+
+GLuint PACKSPU_APIENTRY packspu_VBoxPackGetInjectID(void)
+{
+    return 0;
+}
+
+void PACKSPU_APIENTRY packspu_VBoxPackSetInjectID(GLuint id)
+{
+    (void) id;
+}
+#endif /*CHROMIUM_THREADSAFE*/

trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_special

@@ -102 +102 @@
 GetCompressedTexImageARB
 BindRenderbufferEXT
+VBoxPackSetInjectThread
+VBoxPackGetInjectID
+VBoxPackSetInjectID

trunk/src/VBox/Additions/common/crOpenGL/stub.c

@@ -17 +17 @@
 static void crForcedFlush()
 {
+#if 0
     GLint buffer;
     stub.spu->dispatch_table.GetIntegerv(GL_DRAW_BUFFER, &buffer);
@@ -22 +23 @@
     stub.spu->dispatch_table.Flush();
     stub.spu->dispatch_table.DrawBuffer(buffer);
+#else
+    stub.spu->dispatch_table.Flush();
+#endif
 }
 
@@ -291 +295 @@
 }
 
+# ifndef CR_NEWWINTRACK
 static void stubCBCheckWindowsInfo(unsigned long key, void *data1, void *data2)
 {
@@ -393 +398 @@
         UnhookWindowsHookEx(stub.hMessageHook);
 }
+# endif /*# ifndef CR_NEWWINTRACK*/
+
 #elif defined(GLX) //#ifdef WINDOWS
 static GLboolean stubCheckXExtensions(WindowInfo *pWindow)
@@ -398 +405 @@
     int evb, erb, vmi=0, vma=0;
 
+    XLOCK(pWindow->dpy);
     if (XCompositeQueryExtension(pWindow->dpy, &evb, &erb) 
         && XCompositeQueryVersion(pWindow->dpy, &vma, &vmi) 
@@ -410 +418 @@
         {
             crDebug("XFixes %i.%i", vma, vmi);
+            XUNLOCK(pWindow->dpy);
             return GL_TRUE;
         }
@@ -421 +430 @@
         crWarning("XComposite not found or old version (%i.%i), no VisibilityTracking", vma, vmi);
     }
+    XUNLOCK(pWindow->dpy);
     return GL_FALSE;
 }
@@ -450 +460 @@
     * it seems there's no way to get even based updates for this. Or I've failed to find the appropriate extension.
     */
+    XLOCK(pWindow->dpy);
     xreg = XCompositeCreateRegionFromBorderClip(pWindow->dpy, pWindow->drawable);
     pXRects = XFixesFetchRegion(pWindow->dpy, xreg, &cRects);
     XFixesDestroyRegion(pWindow->dpy, xreg);
+    XUNLOCK(pWindow->dpy);
 
     /* @todo For some odd reason *first* run of compiz on freshly booted VM gives us 0 cRects all the time.

trunk/src/VBox/Additions/common/crOpenGL/stub.h

@@ -46 +46 @@
 #endif
 
+#ifdef WINDOWS
+#define CR_NEWWINTRACK
+#endif
+
+#if !defined(CHROMIUM_THREADSAFE) && defined(CR_NEWWINTRACK)
+# error CHROMIUM_THREADSAFE have to be defined
+#endif
+
+#if defined(CR_NEWWINTRACK) && !defined(WINDOWS)
+#define XLOCK(dpy) XLockDisplay(dpy)
+#define XUNLOCK(dpy) XUnlockDisplay(dpy)
+#else
+#define XLOCK(dpy)
+#define XUNLOCK(dpy)
+#endif
 
 /* When we first create a rendering context we can't be sure whether
@@ -140 +155 @@
     GLboolean mapped;
 #ifdef WINDOWS
-    HDC drawable;
-    HRGN hVisibleRegion;
-    DWORD dmPelsWidth;
-    DWORD dmPelsHeight;
-    HWND  hWnd;
+    HDC      drawable;
+    HRGN     hVisibleRegion;
+    DWORD    dmPelsWidth;
+    DWORD    dmPelsHeight;
+    HWND     hWnd;
 #elif defined(DARWIN)
     CGSConnectionID connection;
@@ -154 +169 @@
     XRectangle *pVisibleRegions;
     GLint cVisibleRegions;
+#endif
+#ifdef CR_NEWWINTRACK
+    uint32_t u32ClientID;
 #endif
 };
@@ -214 +232 @@
 
 #ifdef WINDOWS
-    HHOOK       hMessageHook;
-#endif
+# ifndef CR_NEWWINTRACK
+    HHOOK           hMessageHook;
+# endif
+#endif
+
+#ifdef CR_NEWWINTRACK
+    RTTHREAD        hSyncThread;
+    bool volatile   bShutdownSyncThread;
+#endif
+
 } Stub;
 

trunk/src/VBox/GuestHost/OpenGL/glapi_parser/APIspec.txt

@@ -8500 +8500 @@
 chromium    extpack
 
+name        VBoxPackSetInjectThread
+return      void
+category    VBox
+chromium    nopack
+
+name        VBoxPackGetInjectID
+return      GLuint
+category    VBox
+chromium    nopack
+
+name        VBoxPackSetInjectID
+return      void
+param       id          GLuint
+category    VBox
+chromium    nopack
 
 # OpenGL 1.5

trunk/src/VBox/GuestHost/OpenGL/glapi_parser/apiutil.py

@@ -353 +353 @@
                 cat == "1.2" or
                 cat == "Chromium" or
-                cat == "GL_chromium"):
+                cat == "GL_chromium" or
+                cat == "VBox"):
                 return ''
         elif (cat == '1.3' or

trunk/src/VBox/GuestHost/OpenGL/include/cr_net.h

@@ -220 +220 @@
     uint32_t cbHostBufferAllocated;
     uint32_t cbHostBuffer;
+#ifdef IN_GUEST
+    uint32_t u32InjectClientID;
+#endif
     /* Used on host side to indicate that we are not allowed to store above pointers for later use
      * in crVBoxHGCMReceiveMessage. As those messages are going to be processed after the correspoding 

trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_init.c

@@ -232 +232 @@
          * Ensures context bits are reset */
         crStateFreeContext(defaultContext);
+#ifdef CHROMIUM_THREADSAFE
+        crSetTSD(&__contextTSD, NULL);
+#else
+        __currentContext = NULL;
+#endif
     }
 

trunk/src/VBox/GuestHost/OpenGL/util/vboxhgcm.c

@@ -331 +331 @@
 static void crVBoxHGCMWriteExact(CRConnection *conn, const void *buf, unsigned int len)
 {
-    CRVBOXHGCMWRITE parms;
     int rc;
-
-    parms.hdr.result      = VERR_WRONG_ORDER;
-    parms.hdr.u32ClientID = conn->u32ClientID;
-    parms.hdr.u32Function = SHCRGL_GUEST_FN_WRITE;
-    parms.hdr.cParms      = SHCRGL_CPARMS_WRITE;
-
-    parms.pBuffer.type                   = VMMDevHGCMParmType_LinAddr_In;
-    parms.pBuffer.u.Pointer.size         = len;
-    parms.pBuffer.u.Pointer.u.linearAddr = (uintptr_t) buf;
-
-    rc = crVBoxHGCMCall(&parms, sizeof(parms));
-
-    if (RT_FAILURE(rc) || RT_FAILURE(parms.hdr.result))
-    {
-        crWarning("SHCRGL_GUEST_FN_WRITE failed with %x %x\n", rc, parms.hdr.result);
+    int32_t callRes;
+
+#ifdef IN_GUEST
+    if (conn->u32InjectClientID)
+    {
+        CRVBOXHGCMINJECT parms;
+
+        parms.hdr.result      = VERR_WRONG_ORDER;
+        parms.hdr.u32ClientID = conn->u32ClientID;
+        parms.hdr.u32Function = SHCRGL_GUEST_FN_INJECT;
+        parms.hdr.cParms      = SHCRGL_CPARMS_INJECT;
+
+        parms.u32ClientID.type       = VMMDevHGCMParmType_32bit;
+        parms.u32ClientID.u.value32  = conn->u32InjectClientID;
+
+        parms.pBuffer.type                   = VMMDevHGCMParmType_LinAddr_In;
+        parms.pBuffer.u.Pointer.size         = len;
+        parms.pBuffer.u.Pointer.u.linearAddr = (uintptr_t) buf;
+
+        rc = crVBoxHGCMCall(&parms, sizeof(parms));
+        callRes = parms.hdr.result;
+    }
+    else
+#endif
+    {
+        CRVBOXHGCMWRITE parms;
+
+        parms.hdr.result      = VERR_WRONG_ORDER;
+        parms.hdr.u32ClientID = conn->u32ClientID;
+        parms.hdr.u32Function = SHCRGL_GUEST_FN_WRITE;
+        parms.hdr.cParms      = SHCRGL_CPARMS_WRITE;
+
+        parms.pBuffer.type                   = VMMDevHGCMParmType_LinAddr_In;
+        parms.pBuffer.u.Pointer.size         = len;
+        parms.pBuffer.u.Pointer.u.linearAddr = (uintptr_t) buf;
+
+        rc = crVBoxHGCMCall(&parms, sizeof(parms));
+        callRes = parms.hdr.result;
+    }
+
+    if (RT_FAILURE(rc) || RT_FAILURE(callRes))
+    {
+        crWarning("SHCRGL_GUEST_FN_WRITE failed with %x %x\n", rc, callRes);
     }
 }
@@ -476 +503 @@
             _crVBoxHGCMWriteBytes(conn, start, len);
 #else
+            CRASSERT(!conn->u32InjectClientID);
             crDebug("SHCRGL: sending userbuf with %d bytes\n", len);
             crVBoxHGCMWriteReadExact(conn, start, len, CR_VBOXHGCM_USERALLOCATED);
@@ -493 +521 @@
      * No need to prepend it to the buffer
      */
+#ifdef IN_GUEST
+    if (conn->u32InjectClientID)
+    {
+        crVBoxHGCMWriteExact(conn, start, len);
+    }
+    else
+#endif
     crVBoxHGCMWriteReadExact(conn, start, len, hgcm_buffer->kind);
 

trunk/src/VBox/HostServices/SharedOpenGL/crserver/crservice.cpp

@@ -277 +277 @@
         }
 
+        case SHCRGL_GUEST_FN_INJECT:
+        {
+            Log(("svcCall: SHCRGL_GUEST_FN_INJECT\n"));
+
+            /* Verify parameter count and types. */
+            if (cParms != SHCRGL_CPARMS_INJECT)
+            {
+                rc = VERR_INVALID_PARAMETER;
+            }
+            else
+            if (    paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* u32ClientID */
+                 || paParms[1].type != VBOX_HGCM_SVC_PARM_PTR   /* pBuffer */
+               )
+            {
+                rc = VERR_INVALID_PARAMETER;
+            }
+            else
+            {
+                /* Fetch parameters. */
+                uint32_t u32InjectClientID = paParms[0].u.uint32;
+                uint8_t *pBuffer  = (uint8_t *)paParms[1].u.pointer.addr;
+                uint32_t cbBuffer = paParms[1].u.pointer.size;
+
+                /* Execute the function. */
+                rc = crVBoxServerClientWrite(u32InjectClientID, pBuffer, cbBuffer);
+                if (!RT_SUCCESS(rc))
+                {
+                    Assert(VERR_NOT_SUPPORTED==rc);
+                    svcClientVersionUnsupported(0, 0);
+                }
+
+            }
+            break;
+        }
+
         case SHCRGL_GUEST_FN_READ:
         {

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c

@@ -381 +381 @@
     int32_t i;
 
-    //crDebug("crServer: [%x] ClientWrite u32ClientID=%d", crThreadID(), u32ClientID);
+    /*crDebug("=>crServer: ClientWrite u32ClientID=%d", u32ClientID);*/
 
     for (i = 0; i < cr_server.numClients; i++)
@@ -451 +451 @@
 
     CRASSERT(!pClient->conn->allow_redir_ptr || crNetNumMessages(pClient->conn)==0);
+
+    /*crDebug("<=crServer: ClientWrite u32ClientID=%d", u32ClientID);*/
 
     return VINF_SUCCESS;