Changeset 21939 in vbox

Timestamp:

Aug 3, 2009 11:52:51 AM (16 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

50619

Message:

Video Hw Accel: debugging & better color support (still debugging & perf enhancements needed)

Location:

trunk

Files:

• include/VBox/VBoxVideo.h (modified) (11 diffs)
• src/VBox/Additions/WINNT/Graphics/Display/dd.c (modified) (32 diffs)
• src/VBox/Additions/WINNT/Graphics/Display/driver.h (modified) (3 diffs)
• src/VBox/Additions/WINNT/Graphics/Display/vbox.c (modified) (4 diffs)
• src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.cpp (modified) (1 diff)
• src/VBox/Frontends/VirtualBox/Makefile.kmk (modified) (1 diff)
• src/VBox/Frontends/VirtualBox/include/VBoxDefs.h (modified) (1 diff)
• src/VBox/Frontends/VirtualBox/include/VBoxFrameBuffer.h (modified) (30 diffs)
• src/VBox/Frontends/VirtualBox/src/VBoxConsoleView.cpp (modified) (3 diffs)
• src/VBox/Frontends/VirtualBox/src/VBoxFrameBuffer.cpp (modified) (2 diffs)

trunk/include/VBox/VBoxVideo.h

@@ -276 +276 @@
  * must not be cleared once set, the command completion is performed by issuing a host->guest completion command
  * while keeping this flag unchanged */
-#define VBOXVHWACMD_FLAG_ASYNCH       0x00000001
+#define VBOXVHWACMD_FLAG_HG_ASYNCH               0x00010000
 /* asynch completion is performed by issuing the event */
-#define VBOXVHWACMD_FLAG_ASYNCH_EVENT 0x00000002
+#define VBOXVHWACMD_FLAG_GH_ASYNCH_EVENT         0x00000001
 /* issue interrupt on asynch completion */
-#define VBOXVHWACMD_FLAG_ASYNCH_IRQ   0x00000004
+#define VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ           0x00000002
+/* guest does not do any op on completion of this command, the host may copy the command and indicate that it does not need the command anymore
+ * by setting the VBOXVHWACMD_FLAG_HG_ASYNCH_RETURNED flag */
+#define VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION  0x00000004
+/* the host has copied the VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION command and returned it to the guest */
+#define VBOXVHWACMD_FLAG_HG_ASYNCH_RETURNED      0x00020000
 
 typedef struct _VBOXVHWACMD
@@ -309 +314 @@
 typedef struct _VBOXVHWA_RECTL
 {
-    int32_t x;
-    int32_t y;
-    uint32_t w;
-    uint32_t h;
+    int32_t left;
+    int32_t top;
+    int32_t right;
+    int32_t bottom;
 } VBOXVHWA_RECTL;
 
@@ -348 +353 @@
         uint32_t yuvVBitMask;
     } m3;
+
+    union
+    {
+        uint32_t rgbABitMask;
+    } m4;
 } VBOXVHWA_PIXELFORMAT;
 
@@ -356 +366 @@
     uint32_t width;
     uint32_t pitch;
+    uint32_t bitsPerPixel;
     uint32_t cBackBuffers;
-    uint32_t Reserved1;
     VBOXVHWA_COLORKEY DstOverlayCK;
     VBOXVHWA_COLORKEY DstBltCK;
@@ -398 +408 @@
 #define VBOXVHWA_CAPS_OVERLAYFOURCC   0x00000200
 #define VBOXVHWA_CAPS_OVERLAYSTRETCH  0x00000400
+#define VBOXVHWA_CAPS_OVERLAYCANTCLIP 0x00000800
 
 #define VBOXVHWA_CAPS_COLORKEY        0x00010000
@@ -521 +532 @@
 typedef struct _VBOXVHWACMD_SURF_CANCREATE
 {
-    union
-    {
-        struct
-        {
-            VBOXVHWA_SURFACEDESC SurfInfo;
+    VBOXVHWA_SURFACEDESC SurfInfo;
+    union
+    {
+        struct
+        {
             uint32_t bIsDifferentPixelFormat;
             uint32_t Reserved;
@@ -539 +550 @@
 typedef struct _VBOXVHWACMD_SURF_CREATE
 {
-    union
-    {
-        struct
-        {
-            VBOXVHWA_SURFACEDESC SurfInfo;
+    VBOXVHWA_SURFACEDESC SurfInfo;
+    union
+    {
+        struct
+        {
             uint64_t offSurface;
         } in;
@@ -587 +598 @@
         {
             VBOXVHWA_SURFHANDLE hSurf;
+            uint32_t xUpdatedMemValid;
+            uint32_t reserved;
+            VBOXVHWA_RECTL xUpdatedMemRect;
         } in;
     } u;
@@ -606 +620 @@
             VBOXVHWA_RECTL srcRect;
             uint32_t flags;
-            uint32_t reserved;
+            uint32_t xUpdatedSrcMemValid;
             VBOXVHWA_BLTFX desc;
+            VBOXVHWA_RECTL xUpdatedSrcMemRect;
         } in;
     } u;
@@ -625 +640 @@
             uint64_t offCurrSurface;
             uint32_t flags;
-            uint32_t reserved;
+            uint32_t xUpdatedTargMemValid;
+            VBOXVHWA_RECTL xUpdatedTargMemRect;
         } in;
     } u;
@@ -658 +674 @@
             VBOXVHWA_RECTL srcRect;
             uint32_t flags;
-            uint32_t reserved;
+            uint32_t xUpdatedSrcMemValid;
             VBOXVHWA_OVERLAYFX desc;
+            VBOXVHWA_RECTL xUpdatedSrcMemRect;
         } in;
     } u;

trunk/src/VBox/Additions/WINNT/Graphics/Display/dd.c

@@ -46 +46 @@
 #define VBOXVHWA_CAP(_pdev, _cap) ((_pdev)->vhwaInfo.caps & (_cap))
 static bool getDDHALInfo(PPDEV pDev, DD_HALINFO* pHALInfo);
-static DECLCALLBACK(void) vboxVHWAFreeCmdCompletion(PPDEV ppdev, VBOXVHWACMD * pCmd, void * pContext);
 static DECLCALLBACK(void) vboxVHWASurfBltCompletion(PPDEV ppdev, VBOXVHWACMD * pCmd, void * pContext);
 static DECLCALLBACK(void) vboxVHWASurfFlipCompletion(PPDEV ppdev, VBOXVHWACMD * pCmd, void * pContext);
@@ -76 +75 @@
  *
  */
+
+DD_HALINFO g_h2;
+
 BOOL APIENTRY DrvGetDirectDrawInfo(
     DHPDEV        dhpdev,
@@ -615 +617 @@
         DDPIXELFORMAT * pFormat = &lpSurfaceGlobal->ddpfSurface;
 
-        if(lpSurfaceLocal->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
-        {
-            lBpp = pDev->ulBitCount;
-            lPitch = pDev->lDeltaScreen;
-        }
-        else
-        {
-            if (pFormat->dwFlags & DDPF_PALETTEINDEXED4)
-            {
-                lBpp = 4;
-                lPitch = lpSurfaceGlobal->wWidth/2;
-                lPitch = (lPitch + 31) & ~31;
-            }
-            else
-            if (pFormat->dwFlags & DDPF_PALETTEINDEXED8)
-            {
-                lBpp = 8;
-                lPitch = lpSurfaceGlobal->wWidth;
-                lPitch = (lPitch + 31) & ~31;
-            }
-            else
-            {
-                lBpp   = pFormat->dwRGBBitCount;
-                lPitch = lpSurfaceGlobal->wWidth*(lBpp/8);
-            }
-        }
-
-        DISPDBG((0, "New surface (%d,%d)\n", lpSurfaceGlobal->wWidth, lpSurfaceGlobal->wHeight));
-        DISPDBG((0, "BPP %d lPitch=%d\n", lBpp, lPitch));
-#if 1
-        lpSurfaceGlobal->dwBlockSizeX   = lPitch;
-        lpSurfaceGlobal->dwBlockSizeY   = lpSurfaceGlobal->wHeight;
-        lpSurfaceGlobal->lPitch         = lPitch;
-#else
-        lpSurfaceGlobal->dwBlockSizeX   = lPitch * lpSurfaceGlobal->wHeight;
-        lpSurfaceGlobal->dwBlockSizeY   = 1;
-        lpSurfaceGlobal->lPitch         = lPitch;
-#endif
-
-#if 1
-        lpSurfaceDesc->lPitch   = lpSurfaceGlobal->lPitch;
-        lpSurfaceDesc->dwFlags |= DDSD_PITCH;
-#endif
-
         //
         // Modify surface descriptions as appropriate and let Direct
@@ -683 +641 @@
             memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_CREATE));
 
-            rc = vboxVHWAFromDDSURFACEDESC(&pBody->u.in.SurfInfo, lpSurfaceDesc);
-
-            pBody->u.in.SurfInfo.surfCaps = vboxVHWAFromDDSCAPS(lpSurfaceLocal->ddsCaps.dwCaps);
-            pBody->u.in.SurfInfo.flags |= DDSD_CAPS;
-
-            pBody->u.in.SurfInfo.height = lpSurfaceGlobal->wHeight;
-            pBody->u.in.SurfInfo.width = lpSurfaceGlobal->wWidth;
-            pBody->u.in.SurfInfo.flags |= DDSD_HEIGHT | DDSD_WIDTH;
-
-            vboxVHWAFromDDPIXELFORMAT(&pBody->u.in.SurfInfo.PixelFormat, pFormat);
-            pBody->u.in.SurfInfo.flags |= VBOXVHWA_SD_PIXELFORMAT;
+            rc = vboxVHWAFromDDSURFACEDESC(&pBody->SurfInfo, lpSurfaceDesc);
+
+            pBody->SurfInfo.surfCaps = vboxVHWAFromDDSCAPS(lpSurfaceLocal->ddsCaps.dwCaps);
+            pBody->SurfInfo.flags |= DDSD_CAPS;
+
+            pBody->SurfInfo.height = lpSurfaceGlobal->wHeight;
+            pBody->SurfInfo.width = lpSurfaceGlobal->wWidth;
+            pBody->SurfInfo.flags |= DDSD_HEIGHT | DDSD_WIDTH;
+
+            vboxVHWAFromDDPIXELFORMAT(&pBody->SurfInfo.PixelFormat, pFormat);
+            pBody->SurfInfo.flags |= VBOXVHWA_SD_PIXELFORMAT;
 
             if (lpSurfaceLocal->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
@@ -708 +666 @@
             if(pDesc)
             {
-                pDesc->cBitsPerPixel = lBpp;
                 vboxVHWACommandSubmit(pDev, pCmd);
                 Assert(pCmd->rc == VINF_SUCCESS);
@@ -715 +672 @@
                     pDesc->hHostHandle = pBody->u.out.hSurf;
                     lpSurfaceGlobal->dwReserved1 = (ULONG_PTR)pDesc;
+                    lPitch = pBody->SurfInfo.pitch;
+                    lBpp = pBody->SurfInfo.bitsPerPixel;
+                    pDesc->cBitsPerPixel = lBpp;
+#if 0
+                    lpSurfaceGlobal->dwBlockSizeX   = lPitch;
+                    lpSurfaceGlobal->dwBlockSizeY   = lpSurfaceGlobal->wHeight;
+                    lpSurfaceGlobal->lPitch         = lPitch;
+#else
+                    lpSurfaceGlobal->dwBlockSizeX   = lPitch * lpSurfaceGlobal->wHeight;
+                    lpSurfaceGlobal->dwBlockSizeY   = 1;
+                    lpSurfaceGlobal->lPitch         = lPitch;
+#endif
+#if 1
+                    lpSurfaceDesc->lPitch   = lpSurfaceGlobal->lPitch;
+                    lpSurfaceDesc->dwFlags |= DDSD_PITCH;
+#endif
+
                     lpCreateSurface->ddRVal = DD_OK;
                 }
@@ -831 +805 @@
             memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_CANCREATE));
 
-            rc = vboxVHWAFromDDSURFACEDESC(&pBody->u.in.SurfInfo, lpDDS);
+            rc = vboxVHWAFromDDSURFACEDESC(&pBody->SurfInfo, lpDDS);
             pBody->u.in.bIsDifferentPixelFormat = lpCanCreateSurface->bIsDifferentPixelFormat;
 
@@ -1029 +1003 @@
         DD_SURFACE_GLOBAL*  lpSurfaceGlobal = lpSurfaceLocal->lpGbl;
         PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC)lpSurfaceGlobal->dwReserved1;
-        VBOXVHWACMD* pCmd;
-        /* ensure we have host cmds processed to update pending blits and flips */
-        vboxVHWACommandCheckHostCmds(pDev);
-
-    //    if(VBOXDD_CHECKFLAG(lpLock, DDLOCK_DONOTWAIT))
-        {
+        RECTL tmpRect, *pRect;
+
+        if(ASMAtomicUoReadU32(&pDesc->cPendingBltsSrc)
+                || ASMAtomicUoReadU32(&pDesc->cPendingFlipsCurr)
+                || ASMAtomicUoReadU32(&pDesc->cPendingBltsDst)
+                || ASMAtomicUoReadU32(&pDesc->cPendingFlipsTarg))
+        {
+            /* ensure we have host cmds processed to update pending blits and flips */
+            vboxVHWACommandCheckHostCmds(pDev);
             if(ASMAtomicUoReadU32(&pDesc->cPendingBltsSrc)
-                    || ASMAtomicUoReadU32(&pDesc->cPendingBltsDst)
-                    || ASMAtomicUoReadU32(&pDesc->cPendingFlipsTarg)
-                    || ASMAtomicUoReadU32(&pDesc->cPendingFlipsCurr))
+                        || ASMAtomicUoReadU32(&pDesc->cPendingFlipsCurr)
+                        || ASMAtomicUoReadU32(&pDesc->cPendingBltsDst)
+                        || ASMAtomicUoReadU32(&pDesc->cPendingFlipsTarg))
             {
                 lpLock->ddRVal = DDERR_WASSTILLDRAWING;
@@ -1051 +1028 @@
 //        }
 
-        pCmd = vboxVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_LOCK, sizeof(VBOXVHWACMD_SURF_LOCK));
-        if(pCmd)
-        {
-            VBOXVHWACMD_SURF_LOCK * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_LOCK);
-            RECTL tmpRect, *pRect;
-            memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_LOCK));
-
-            pBody->u.in.offSurface = (uint64_t)lpSurfaceGlobal->fpVidMem;
-
-            if (lpLock->bHasRect)
+        if (lpLock->bHasRect)
+        {
+            pRect = &lpLock->rArea;
+        }
+        else
+        {
+            tmpRect.left=0;
+            tmpRect.top=0;
+            tmpRect.right=lpSurfaceGlobal->wWidth-1;
+            tmpRect.bottom=lpSurfaceGlobal->wHeight-1;
+            pRect = &tmpRect;
+        }
+
+        if(VBOXDD_CHECKFLAG(lpLock->dwFlags, DDLOCK_DISCARDCONTENTS))
+        {
+//            pBody->u.in.flags |= VBOXVHWA_LOCK_DISCARDCONTENTS;
+
+            vboxVHWARegionTrySubstitute(&pDesc->NonupdatedMemRegion, pRect);
+//                /* we're not interested in completion, just send the command */
+//                vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
+            vboxVHWARegionAdd(&pDesc->UpdatedMemRegion, pRect);
+            lpLock->ddRVal = DD_OK;
+        }
+        else if(!vboxVHWARegionIntersects(&pDesc->NonupdatedMemRegion, pRect))
+        {
+//                vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
+            vboxVHWARegionAdd(&pDesc->UpdatedMemRegion, pRect);
+            lpLock->ddRVal = DD_OK;
+        }
+        else
+        {
+            VBOXVHWACMD* pCmd = vboxVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_LOCK, sizeof(VBOXVHWACMD_SURF_LOCK));
+            if(pCmd)
             {
-                DISPDBG((0, "%d,%d %dx%d\n", lpLock->rArea.left, lpLock->rArea.top, lpLock->rArea.right - lpLock->rArea.left, lpLock->rArea.bottom - lpLock->rArea.top));
-                vboxVHWAFromRECTL(&pBody->u.in.rect, &lpLock->rArea);
+                VBOXVHWACMD_SURF_LOCK * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_LOCK);
+                memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_LOCK));
+
+                pBody->u.in.offSurface = (uint64_t)lpSurfaceGlobal->fpVidMem;
+
+//            if (lpLock->bHasRect)
+//            {
+//                DISPDBG((0, "%d,%d %dx%d\n", lpLock->rArea.left, lpLock->rArea.top, lpLock->rArea.right - lpLock->rArea.left, lpLock->rArea.bottom - lpLock->rArea.top));
+//                vboxVHWAFromRECTL(&pBody->u.in.rect, &lpLock->rArea);
+//                pBody->u.in.rectValid = 1;
+//
+//            }
+//            else
+//            {
+//                pBody->u.in.rectValid = 0;
+//            }
+                Assert(pDesc->NonupdatedMemRegion.bValid);
+                vboxVHWAFromRECTL(&pBody->u.in.rect, &pDesc->NonupdatedMemRegion.Rect);
                 pBody->u.in.rectValid = 1;
 
-                pRect = &lpLock->rArea;
-
+                pBody->u.in.hSurf = pDesc->hHostHandle;
+
+                /* wait for the surface to be locked and memory buffer updated */
+                vboxVHWACommandSubmit(pDev, pCmd);
+                vboxVHWACommandFree(pDev, pCmd);
+                vboxVHWARegionClear(&pDesc->NonupdatedMemRegion);
+                lpLock->ddRVal = DD_OK;
             }
             else
             {
-                pBody->u.in.rectValid = 0;
-
-                tmpRect.left=0;
-                tmpRect.top=0;
-                tmpRect.right=lpSurfaceGlobal->wWidth-1;
-                tmpRect.bottom=lpSurfaceGlobal->wHeight-1;
-                pRect = &tmpRect;
+                lpLock->ddRVal = DDERR_GENERIC;
             }
-
-            pBody->u.in.hSurf = pDesc->hHostHandle;
-
-            if(VBOXDD_CHECKFLAG(lpLock->dwFlags, DDLOCK_DISCARDCONTENTS))
-            {
-                pBody->u.in.flags |= VBOXVHWA_LOCK_DISCARDCONTENTS;
-
-                if(vboxVHWARegionIncluded(&pDesc->DirtyRegion, pRect))
-                {
-                    vboxVHWARegionClear(&pDesc->DirtyRegion);
-                }
-//            }
-//            else if(vboxVHWARegionInterse)
-                /* we're not interested in completion, just send the command */
-                vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
-            }
-            else if(!vboxVHWARegionIntersects(&pDesc->DirtyRegion, pRect))
-            {
-                vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
-            }
-            else
-            {
-                /* wait for the surface to be locked and memory buffer updated */
-                vboxVHWACommandSubmit(pDev, pCmd);
-                vboxVHWACommandFree(pDev, pCmd);
-                vboxVHWARegionClear(&pDesc->DirtyRegion);
-            }
-
-            lpLock->ddRVal = DD_OK;
-        }
-        else
-        {
-            lpLock->ddRVal = DDERR_GENERIC;
         }
         return DDHAL_DRIVER_NOTHANDLED;
@@ -1174 +1156 @@
         DD_SURFACE_GLOBAL*  lpSurfaceGlobal = lpSurfaceLocal->lpGbl;
         PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC)lpSurfaceGlobal->dwReserved1;
-        VBOXVHWACMD* pCmd;
 
         //TODO: hadle vrdp properly
@@ -1186 +1167 @@
         }
 
-        /* ensure we have host cmds processed to update pending blits and flips */
-        vboxVHWACommandCheckHostCmds(pDev);
-
-        pCmd = vboxVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_UNLOCK, sizeof(VBOXVHWACMD_SURF_UNLOCK));
-    //    int rc = VERR_GENERAL_FAILURE;
-        if(pCmd)
-        {
-            VBOXVHWACMD_SURF_UNLOCK * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_UNLOCK);
-            memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_UNLOCK));
-
-            pBody->u.in.hSurf = pDesc->hHostHandle;
-
-            vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
-
-            lpUnlock->ddRVal = DD_OK;
-        }
-        else
-        {
-            lpUnlock->ddRVal = DDERR_GENERIC;
+//        /* ensure we have host cmds processed to update pending blits and flips */
+//        vboxVHWACommandCheckHostCmds(pDev);
+
+        if(lpSurfaceLocal->ddsCaps.dwCaps & DDSCAPS_VISIBLE
+                || (
+                        !(lpSurfaceLocal->ddsCaps.dwCaps & DDSCAPS_COMPLEX)
+                        && (
+                                lpSurfaceLocal->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE
+                                || (
+                                        (lpSurfaceLocal->ddsCaps.dwCaps & DDSCAPS_OVERLAY)
+                                        && !pDesc->bHidden
+                                    )
+                           )
+                   )
+          )
+        {
+            VBOXVHWACMD* pCmd = vboxVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_UNLOCK, sizeof(VBOXVHWACMD_SURF_UNLOCK));
+        //    int rc = VERR_GENERAL_FAILURE;
+            if(pCmd)
+            {
+                VBOXVHWACMD_SURF_UNLOCK * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_UNLOCK);
+                memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_UNLOCK));
+
+                pBody->u.in.hSurf = pDesc->hHostHandle;
+                if(pDesc->UpdatedMemRegion.bValid)
+                {
+                    pBody->u.in.xUpdatedMemValid = 1;
+                    vboxVHWAFromRECTL(&pBody->u.in.xUpdatedMemRect, &pDesc->UpdatedMemRegion.Rect);
+                    vboxVHWARegionClear(&pDesc->UpdatedMemRegion);
+                }
+
+                vboxVHWACommandSubmitAsynchAndComplete(pDev, pCmd);
+
+                lpUnlock->ddRVal = DD_OK;
+            }
+            else
+            {
+                lpUnlock->ddRVal = DDERR_GENERIC;
+            }
         }
 
@@ -1308 +1309 @@
 
             /* we're not interested in completion, just send the command */
-            vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
+            vboxVHWACommandSubmitAsynchAndComplete(pDev, pCmd);
 
             vboxVHWASurfDescFree(pDesc);
@@ -1406 +1407 @@
 
 #ifdef VBOX_WITH_VIDEOHWACCEL
+#if 1
 DWORD APIENTRY DdSetColorKey(PDD_SETCOLORKEYDATA  lpSetColorKey)
 {
@@ -1428 +1430 @@
         vboxVHWAFromDDCOLORKEY(&pBody->u.in.CKey, &lpSetColorKey->ckNew);
 
-        vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
+        vboxVHWACommandSubmitAsynchAndComplete(pDev, pCmd);
         lpSetColorKey->ddRVal = DD_OK;
     }
@@ -1482 +1484 @@
             ASMAtomicIncU32(&pDestDesc->cPendingBltsDst);
 
-            vboxVHWARegionAdd(&pDestDesc->DirtyRegion, &lpBlt->rDest);
+            vboxVHWARegionAdd(&pDestDesc->NonupdatedMemRegion, &lpBlt->rDest);
+            vboxVHWARegionTrySubstitute(&pDestDesc->UpdatedMemRegion, &lpBlt->rDest);
+
+            if(pSrcDesc->UpdatedMemRegion.bValid)
+            {
+                pBody->u.in.xUpdatedSrcMemValid = 1;
+                vboxVHWAFromRECTL(&pBody->u.in.xUpdatedSrcMemRect, &pSrcDesc->UpdatedMemRegion.Rect);
+                vboxVHWARegionClear(&pSrcDesc->UpdatedMemRegion);
+            }
+
             vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWASurfBltCompletion, NULL);
 
@@ -1516 +1527 @@
     DISPDBG((0, "%s\n", __FUNCTION__));
 
-    /* ensure we have host cmds processed to update pending blits and flips */
-    vboxVHWACommandCheckHostCmds(pDev);
-
-//    if(VBOXDD_CHECKFLAG(lpLock, DDLOCK_DONOTWAIT))
-    {
-        if(
+    if(
 //                ASMAtomicUoReadU32(&pDesc->cPendingBltsSrc)
 //                || ASMAtomicUoReadU32(&pDesc->cPendingBltsDst)
 //                ||
-                ASMAtomicUoReadU32(&pCurrDesc->cPendingFlipsTarg)
-                || ASMAtomicUoReadU32(&pCurrDesc->cPendingFlipsCurr)
-                || ASMAtomicUoReadU32(&pTargDesc->cPendingFlipsTarg)
-                || ASMAtomicUoReadU32(&pTargDesc->cPendingFlipsCurr))
+            ASMAtomicUoReadU32(&pCurrDesc->cPendingFlipsTarg)
+            || ASMAtomicUoReadU32(&pCurrDesc->cPendingFlipsCurr)
+            || ASMAtomicUoReadU32(&pTargDesc->cPendingFlipsTarg)
+            || ASMAtomicUoReadU32(&pTargDesc->cPendingFlipsCurr))
+    {
+        /* ensure we have host cmds processed to update pending blits and flips */
+        vboxVHWACommandCheckHostCmds(pDev);
+        if(
+    //                ASMAtomicUoReadU32(&pDesc->cPendingBltsSrc)
+    //                || ASMAtomicUoReadU32(&pDesc->cPendingBltsDst)
+    //                ||
+                    ASMAtomicUoReadU32(&pCurrDesc->cPendingFlipsTarg)
+                    || ASMAtomicUoReadU32(&pCurrDesc->cPendingFlipsCurr)
+                    || ASMAtomicUoReadU32(&pTargDesc->cPendingFlipsTarg)
+                    || ASMAtomicUoReadU32(&pTargDesc->cPendingFlipsCurr))
         {
             lpFlip->ddRVal = DDERR_WASSTILLDRAWING;
@@ -1534 +1551 @@
         }
     }
+
 
     pCmd = vboxVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_FLIP, sizeof(VBOXVHWACMD_SURF_FLIP));
@@ -1556 +1574 @@
         ASMAtomicIncU32(&pTargDesc->cPendingFlipsTarg);
 
+        if(pTargDesc->UpdatedMemRegion.bValid)
+        {
+            pBody->u.in.xUpdatedTargMemValid = 1;
+            vboxVHWAFromRECTL(&pBody->u.in.xUpdatedTargMemRect, &pTargDesc->UpdatedMemRegion.Rect);
+            vboxVHWARegionClear(&pTargDesc->UpdatedMemRegion);
+        }
+
         vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWASurfFlipCompletion, NULL);
 
@@ -1582 +1607 @@
         DD_SURFACE_GLOBAL*  lpSurfaceGlobal = lpSurfaceLocal->lpGbl;
         PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC)lpSurfaceGlobal->dwReserved1;
-
-        /* ensure we have host cmds processed to update pending blits and flips */
-        vboxVHWACommandCheckHostCmds(pDev);
 
         if(
@@ -1593 +1615 @@
                     )
         {
-            lpGetBltStatus->ddRVal = DDERR_WASSTILLDRAWING;
+            /* ensure we have host cmds processed to update pending blits and flips */
+            vboxVHWACommandCheckHostCmds(pDev);
+
+            if(
+                        ASMAtomicUoReadU32(&pDesc->cPendingBltsSrc)
+                        || ASMAtomicUoReadU32(&pDesc->cPendingBltsDst)
+        //                || ASMAtomicUoReadU32(&pDesc->cPendingFlipsTarg)
+        //                || ASMAtomicUoReadU32(&pDesc->cPendingFlipsCurr)
+                        )
+            {
+                lpGetBltStatus->ddRVal = DDERR_WASSTILLDRAWING;
+            }
+            else
+            {
+                lpGetBltStatus->ddRVal = DD_OK;
+            }
         }
         else
@@ -1612 +1649 @@
 
     DISPDBG((0, "%s\n", __FUNCTION__));
-
-    /* ensure we have host cmds processed to update pending blits and flips */
-    vboxVHWACommandCheckHostCmds(pDev);
 
     if(
@@ -1624 +1658 @@
                 )
     {
-        lpGetFlipStatus->ddRVal = DDERR_WASSTILLDRAWING;
+        /* ensure we have host cmds processed to update pending blits and flips */
+        vboxVHWACommandCheckHostCmds(pDev);
+
+        if(
+    //                ASMAtomicUoReadU32(&pDesc->cPendingBltsSrc)
+    //                || ASMAtomicUoReadU32(&pDesc->cPendingBltsDst)
+    //                ||
+                    ASMAtomicUoReadU32(&pDesc->cPendingFlipsTarg)
+                    || ASMAtomicUoReadU32(&pDesc->cPendingFlipsCurr)
+                    )
+        {
+            lpGetFlipStatus->ddRVal = DDERR_WASSTILLDRAWING;
+        }
+        else
+        {
+            lpGetFlipStatus->ddRVal = DD_OK;
+        }
     }
     else
@@ -1679 +1729 @@
         pBody->u.in.yPos = lpSetOverlayPosition->lYPos;
 
-        vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
+        vboxVHWACommandSubmitAsynchAndComplete(pDev, pCmd);
         lpSetOverlayPosition->ddRVal = DD_OK;
     }
@@ -1728 +1778 @@
         {
             pSrcDesc->bHidden = false;
+            if(pSrcDesc->UpdatedMemRegion.bValid)
+            {
+                pBody->u.in.xUpdatedSrcMemValid = 1;
+                vboxVHWAFromRECTL(&pBody->u.in.xUpdatedSrcMemRect, &pSrcDesc->UpdatedMemRegion.Rect);
+                vboxVHWARegionClear(&pSrcDesc->UpdatedMemRegion);
+            }
         }
 
@@ -1738 +1794 @@
         }
 
-        vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
+        vboxVHWACommandSubmitAsynchAndComplete(pDev, pCmd);
         lpUpdateOverlay->ddRVal = DD_OK;
     }
@@ -1744 +1800 @@
     return DDHAL_DRIVER_HANDLED;
 }
+#else
+DWORD APIENTRY DdSetColorKey(PDD_SETCOLORKEYDATA  lpSetColorKey)
+{
+    DISPDBG((0, "%s\n", __FUNCTION__));
+    lpSetColorKey->ddRVal = DD_OK;
+    return DDHAL_DRIVER_HANDLED;
+}
+
+DWORD APIENTRY DdAddAttachedSurface(PDD_ADDATTACHEDSURFACEDATA  lpAddAttachedSurface)
+{
+    DISPDBG((0, "%s\n", __FUNCTION__));
+    lpAddAttachedSurface->ddRVal = DD_OK;
+    return DDHAL_DRIVER_HANDLED;
+}
+
+DWORD APIENTRY DdBlt(PDD_BLTDATA  lpBlt)
+{
+    DISPDBG((0, "%s\n", __FUNCTION__));
+    lpBlt->ddRVal = DD_OK;
+    return DDHAL_DRIVER_HANDLED;
+}
+
+//DWORD APIENTRY DdDestroySurface(PDD_DESTROYSURFACEDATA  lpDestroySurface)
+//{
+//    DISPDBG((0, "%s\n", __FUNCTION__));
+//    lpDestroySurface->ddRVal = DD_OK;
+//    return DDHAL_DRIVER_HANDLED;
+//}
+
+DWORD APIENTRY DdFlip(PDD_FLIPDATA  lpFlip)
+{
+    DISPDBG((0, "%s\n", __FUNCTION__));
+    lpFlip->ddRVal = DD_OK;
+    return DDHAL_DRIVER_HANDLED;
+}
+
+DWORD APIENTRY DdGetBltStatus(PDD_GETBLTSTATUSDATA  lpGetBltStatus)
+{
+    DISPDBG((0, "%s\n", __FUNCTION__));
+
+    if(lpGetBltStatus->dwFlags == DDGBS_CANBLT)
+    {
+        lpGetBltStatus->ddRVal = DD_OK;
+    }
+    else
+    {
+        lpGetBltStatus->ddRVal = DD_OK;
+    }
+
+    return DDHAL_DRIVER_HANDLED;
+}
+
+DWORD APIENTRY DdGetFlipStatus(PDD_GETFLIPSTATUSDATA  lpGetFlipStatus)
+{
+    DISPDBG((0, "%s\n", __FUNCTION__));
+    if(lpGetFlipStatus->dwFlags == DDGFS_CANFLIP)
+    {
+        lpGetFlipStatus->ddRVal = DD_OK;
+    }
+    else
+    {
+        lpGetFlipStatus->ddRVal = DD_OK;
+    }
+
+    return DDHAL_DRIVER_HANDLED;
+}
+
+DWORD APIENTRY DdSetOverlayPosition(PDD_SETOVERLAYPOSITIONDATA  lpSetOverlayPosition)
+{
+    DISPDBG((0, "%s\n", __FUNCTION__));
+
+    lpSetOverlayPosition->ddRVal = DD_OK;
+    return DDHAL_DRIVER_HANDLED;
+}
+
+DWORD APIENTRY DdUpdateOverlay(PDD_UPDATEOVERLAYDATA  lpUpdateOverlay)
+{
+    DISPDBG((0, "%s\n", __FUNCTION__));
+
+    lpUpdateOverlay->ddRVal = DD_OK;
+    return DDHAL_DRIVER_HANDLED;
+}
+
+#endif
 
 //-----------------------------------------------------------------------------
@@ -1813 +1953 @@
 static DWORD rops[DD_ROP_SPACE] = { 0 };
 
+#if 1
 static bool
 getDDHALInfo(
@@ -1831 +1972 @@
                      rops,
                      sizeof(ropListNT)/sizeof(ropListNT[0]));
+
+        //
+        // ROPS supported
+        //
+        for( i=0;i<DD_ROP_SPACE;i++ )
+        {
+            pHALInfo->ddCaps.dwRops[i] = rops[i];
+        }
     }
 
@@ -1861 +2010 @@
     // We need to flag we can run in windowed mode, otherwise we
     // might get restricted by apps to run in fullscreen only
-    pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_CANRENDERWINDOWED;
+//    pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_CANRENDERWINDOWED;
 
     // Also permit surfaces wider than the display buffer.
-    pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_WIDESURFACES;
+//    pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_WIDESURFACES;
 //#endif
 
@@ -1931 +2080 @@
     }
 
-    if(VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_BLT)
-            && VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_BLTFOURCC))
-    {
-        pHALInfo->ddCaps.dwCaps |= DDCAPS_BLTFOURCC;
-
-        // Enable copy blts between Four CC formats for DShow acceleration
-        pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_COPYFOURCC;
-    }
-
-    if((VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_BLT) || VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_OVERLAY))
-            && VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_COLORKEY))
+//    if(VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_BLT)
+//            && VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_BLTFOURCC))
+//    {
+//        pHALInfo->ddCaps.dwCaps |= DDCAPS_BLTFOURCC;
+//
+//        // Enable copy blts between Four CC formats for DShow acceleration
+//        pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_COPYFOURCC;
+//    }
+
+//    if((VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_BLT) || VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_OVERLAY))
+//            && VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_COLORKEY))
     {
         pHALInfo->ddCaps.dwCKeyCaps = vboxVHWAToDDCKEYCAPS(pDev->vhwaInfo.colorKeyCaps);
@@ -2055 +2204 @@
 //                                                  DDBD_8;
 
-    //
-    // ROPS supported
-    //
-    for( i=0;i<DD_ROP_SPACE;i++ )
-    {
-        pHALInfo->ddCaps.dwRops[i] = rops[i];
-    }
 
 //Reenable:    // For DX5 and beyond we support this new informational callback.
@@ -2075 +2217 @@
     return true;
 } // getDDHALInfo
-
-static DECLCALLBACK(void) vboxVHWAFreeCmdCompletion(PPDEV ppdev, VBOXVHWACMD * pCmd, void * pContext)
-{
-    vboxVHWACommandFree(ppdev, pCmd);
-}
+#else
+bool
+getDDHALInfo2(
+    PPDEV pDev,
+    DD_HALINFO* pHALInfo)
+{
+    int i;
+
+#if 0
+    /* TODO: only enable features supported by the host backend & host hw
+     * for now this just combines all caps we might use */
+
+    // Setup the ROPS we do.
+    setupRops( ropListNT,
+                 rops,
+                 sizeof(ropListNT)/sizeof(ropListNT[0]));
+
+    // The most basic DirectDraw functionality
+    pHALInfo->ddCaps.dwCaps |=   DDCAPS_BLT
+                                 | DDCAPS_BLTQUEUE
+                                 | DDCAPS_BLTCOLORFILL
+//                                | DDCAPS_READSCANLINE
+                                ;
+#endif
+    pHALInfo->ddCaps.ddsCaps.dwCaps |=   DDSCAPS_OFFSCREENPLAIN
+                                         | DDSCAPS_PRIMARYSURFACE
+                                         | DDSCAPS_FLIP;
+#if 0
+    pHALInfo->ddCaps.dwCaps |= DDCAPS_3D           |
+                               DDCAPS_BLTDEPTHFILL;
+
+    pHALInfo->ddCaps.ddsCaps.dwCaps |= DDSCAPS_3DDEVICE |
+                                       DDSCAPS_ZBUFFER |
+                                       DDSCAPS_ALPHA;
+#endif
+    pHALInfo->ddCaps.dwCaps2 = 0;
+
+//#if DX7_TEXMANAGEMENT
+    // We need to set this bit up in order to be able to do
+    // out own texture management
+//    pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_CANMANAGETEXTURE;
+//#if DX8_DDI
+//    pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_CANMANAGERESOURCE;
+//#endif
+//#endif
+
+//#if DX8_DDI
+    // We need to flag we can run in windowed mode, otherwise we
+    // might get restricted by apps to run in fullscreen only
+    pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_CANRENDERWINDOWED;
+//#endif
+
+//#if DX8_DDI
+    // We need to flag we support dynamic textures. That is , apps can
+        // lock with high frequency video memory textures without paying a
+        // penalty for it. Since on this sample driver we only support
+        // linear memory formats for textures we don't need to do anything
+        // else for this support. Otherwise we would have to keep two surfaces
+        // for textures created with the DDSCAPS2_HINTDYNAMIC hint in order
+        // to efficiently do the linear<->swizzled transformation or keep the
+        // texture permanantly in an unswizzled state.
+//        pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_DYNAMICTEXTURES;
+    #if DX9_DDI
+        // Notice that dynamic textures MUST be supported in order to instantiate a DX9 device
+    #endif // DX9_DDI
+//#endif
+
+//    pHALInfo->ddCaps.dwFXCaps = 0;
+
+    // P3RX can do:
+    // 1. Stretching/Shrinking
+    // 2. YUV->RGB conversion
+    // 3. Mirroring in X and Y
+    // 4. ColorKeying from a source color and a source color space
+    pHALInfo->ddCaps.dwCaps |=
+#if 0
+        DDCAPS_BLTSTRETCH
+                               | DDCAPS_BLTFOURCC
+                               |
+#endif
+                               DDCAPS_COLORKEY
+//                               | DDCAPS_CANBLTSYSMEM
+                               ;
+#if 0
+    // Special effects caps
+    pHALInfo->ddCaps.dwFXCaps |= DDFXCAPS_BLTSTRETCHY  |
+                                DDFXCAPS_BLTSTRETCHX  |
+                                DDFXCAPS_BLTSTRETCHYN |
+                                DDFXCAPS_BLTSTRETCHXN |
+                                DDFXCAPS_BLTSHRINKY   |
+                                DDFXCAPS_BLTSHRINKX   |
+                                DDFXCAPS_BLTSHRINKYN  |
+                                DDFXCAPS_BLTSHRINKXN;
+
+    // ColorKey caps
+    pHALInfo->ddCaps.dwCKeyCaps |= DDCKEYCAPS_SRCBLT         |
+                                  DDCKEYCAPS_SRCBLTCLRSPACE |
+                                  DDCKEYCAPS_DESTBLT        |
+                                  DDCKEYCAPS_DESTBLTCLRSPACE;
+#endif
+//    pHALInfo->ddCaps.dwSVBCaps = DDCAPS_BLT;
+
+//    // We can do a texture from sysmem to video mem.
+//    pHALInfo->ddCaps.dwSVBCKeyCaps |= DDCKEYCAPS_DESTBLT         |
+//                                     DDCKEYCAPS_DESTBLTCLRSPACE;
+    pHALInfo->ddCaps.dwSVBFXCaps = 0;
+
+//    // Fill in the sysmem->vidmem rops (only can copy);
+//    for( i=0;i<DD_ROP_SPACE;i++ )
+//    {
+//        pHALInfo->ddCaps.dwSVBRops[i] = rops[i];
+//    }
+#if 0
+    //mirroring with blitting
+    pHALInfo->ddCaps.dwFXCaps |= DDFXCAPS_BLTMIRRORUPDOWN  |
+                                DDFXCAPS_BLTMIRRORLEFTRIGHT;
+
+    pHALInfo->ddCaps.dwCKeyCaps |=  DDCKEYCAPS_SRCBLTCLRSPACEYUV;
+
+    pHALInfo->ddCaps.ddsCaps.dwCaps |= DDSCAPS_TEXTURE;
+#endif
+//#if DX7_STEREO
+//    // Report the stereo capability back to runtime
+//    pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_STEREO;
+//    pHALInfo->ddCaps.dwSVCaps = DDSVCAPS_STEREOSEQUENTIAL;
+//#endif
+
+    // Z Buffer is only 16 Bits
+//    pHALInfo->ddCaps.dwZBufferBitDepths = DDBD_16;
+//    pHALInfo->ddCaps.ddsCaps.dwCaps |= DDSCAPS_MIPMAP;
+
+        pHALInfo->ddCaps.ddsCaps.dwCaps |= DDSCAPS_LOCALVIDMEM;
+
+    {
+//#ifdef SUPPORT_VIDEOPORT
+//        // We support 1 video port.  Must set CurrVideoPorts to 0
+//        // We can't do interleaved bobbing yet - maybe in the future.
+//        pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_VIDEOPORT            |
+//                                    DDCAPS2_CANBOBNONINTERLEAVED;
+//
+//        pHALInfo->ddCaps.dwMaxVideoPorts = 1;
+//        pHALInfo->ddCaps.dwCurrVideoPorts = 0;
+//
+//
+//#endif // SUPPORT_VIDEOPORT
+
+
+        {
+            // Overlay is free to use.
+            pHALInfo->ddCaps.dwMaxVisibleOverlays = 1;
+            pHALInfo->ddCaps.dwCurrVisibleOverlays = 0;
+
+            pHALInfo->ddCaps.dwCaps |=  DDCAPS_OVERLAY          |
+                                        DDCAPS_OVERLAYFOURCC    |
+                                        DDCAPS_OVERLAYSTRETCH   |
+                                        DDCAPS_COLORKEYHWASSIST |
+                                        DDCAPS_OVERLAYCANTCLIP;
+
+            pHALInfo->ddCaps.dwCKeyCaps |= DDCKEYCAPS_SRCOVERLAY           |
+                                           DDCKEYCAPS_SRCOVERLAYONEACTIVE  |
+                                           DDCKEYCAPS_SRCOVERLAYYUV        |
+                                           DDCKEYCAPS_DESTOVERLAY          |
+                                           DDCKEYCAPS_DESTOVERLAYONEACTIVE |
+                                           DDCKEYCAPS_DESTOVERLAYYUV;
+
+            pHALInfo->ddCaps.ddsCaps.dwCaps |= DDSCAPS_OVERLAY;
+
+            pHALInfo->ddCaps.dwFXCaps |= DDFXCAPS_OVERLAYSHRINKX   |
+                                         DDFXCAPS_OVERLAYSHRINKXN  |
+                                         DDFXCAPS_OVERLAYSHRINKY   |
+                                         DDFXCAPS_OVERLAYSHRINKYN  |
+                                         DDFXCAPS_OVERLAYSTRETCHX  |
+                                         DDFXCAPS_OVERLAYSTRETCHXN |
+                                         DDFXCAPS_OVERLAYSTRETCHY  |
+                                         DDFXCAPS_OVERLAYSTRETCHYN;
+
+            // Indicates that Perm3 has no stretch ratio limitation
+            pHALInfo->ddCaps.dwMinOverlayStretch = 1;
+            pHALInfo->ddCaps.dwMaxOverlayStretch = 32000;
+        }
+    }
+
+//#ifdef W95_DDRAW
+//#ifdef USE_DD_CONTROL_COLOR
+//    // Enable colour control asc brightness, contrast, gamma.
+//    pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_COLORCONTROLPRIMARY;
+//#endif
+//#endif
+
+    // Also permit surfaces wider than the display buffer.
+    pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_WIDESURFACES;
+#if 0
+    // Enable copy blts betweemn Four CC formats for DShow acceleration
+    pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_COPYFOURCC;
+#endif
+    // Won't do Video-Sys mem Blits.
+    pHALInfo->ddCaps.dwVSBCaps = 0;
+    pHALInfo->ddCaps.dwVSBCKeyCaps = 0;
+    pHALInfo->ddCaps.dwVSBFXCaps = 0;
+    for( i=0;i<DD_ROP_SPACE;i++ )
+    {
+        pHALInfo->ddCaps.dwVSBRops[i] = 0;
+    }
+
+    // Won't do Sys-Sys mem Blits
+    pHALInfo->ddCaps.dwSSBCaps = 0;
+    pHALInfo->ddCaps.dwSSBCKeyCaps = 0;
+    pHALInfo->ddCaps.dwSSBFXCaps = 0;
+    for( i=0;i<DD_ROP_SPACE;i++ )
+    {
+        pHALInfo->ddCaps.dwSSBRops[i] = 0;
+    }
+
+    //
+    // bit depths supported for alpha and Z
+    //
+//    pHALInfo->ddCaps.dwAlphaBltConstBitDepths = DDBD_2 |
+//                                                DDBD_4 |
+//                                                DDBD_8;
+//
+//    pHALInfo->ddCaps.dwAlphaBltPixelBitDepths = DDBD_1 |
+//                                                DDBD_8;
+//    pHALInfo->ddCaps.dwAlphaBltSurfaceBitDepths = DDBD_1 |
+//                                                  DDBD_2 |
+//                                                  DDBD_4 |
+//                                                  DDBD_8;
+#if 0
+    // No alpha blending for overlays, so I'm not sure what these should be.
+    // Because we support 32bpp overlays, it's just that you can't use the
+    // alpha bits for blending. Pass.
+    pHALInfo->ddCaps.dwAlphaBltConstBitDepths = DDBD_2 |
+                                                DDBD_4 |
+                                                DDBD_8;
+
+    pHALInfo->ddCaps.dwAlphaBltPixelBitDepths = DDBD_1 |
+                                                DDBD_8;
+
+    pHALInfo->ddCaps.dwAlphaBltSurfaceBitDepths = DDBD_1 |
+                                                  DDBD_2 |
+                                                  DDBD_4 |
+                                                  DDBD_8;
+
+    //
+    // ROPS supported
+    //
+    for( i=0;i<DD_ROP_SPACE;i++ )
+    {
+        pHALInfo->ddCaps.dwRops[i] = rops[i];
+    }
+#endif
+//Reenable:    // For DX5 and beyond we support this new informational callback.
+//    pHALInfo->GetDriverInfo = DdGetDriverInfo;
+//    pHALInfo->dwFlags |= DDHALINFO_GETDRIVERINFOSET;
+//
+//#if DX8_DDI
+//    // Flag our support for a new class of GUIDs that may come through
+//    // GetDriverInfo for DX8 drivers. (This support will be compulsory)
+//    pHALInfo->dwFlags |= DDHALINFO_GETDRIVERINFO2;
+//#endif DX8_DDI
+
+    return true;
+} // getDDHALInfo
+
+#endif
 
 static DECLCALLBACK(void) vboxVHWASurfBltCompletion(PPDEV ppdev, VBOXVHWACMD * pCmd, void * pContext)

trunk/src/VBox/Additions/WINNT/Graphics/Display/driver.h

@@ -110 +110 @@
     uint32_t cBitsPerPixel;
     bool bHidden;
-    VBOXVHWAREGION DirtyRegion;
+    VBOXVHWAREGION UpdatedMemRegion;
+    VBOXVHWAREGION NonupdatedMemRegion;
 }VBOXVHWASURFDESC, *PVBOXVHWASURFDESC;
 
@@ -307 +308 @@
 void vboxVHWARegionInit(PVBOXVHWAREGION pReg);
 void vboxVHWARegionClear(PVBOXVHWAREGION pReg);
+bool vboxVHWARegionValid(PVBOXVHWAREGION pReg);
+void vboxVHWARegionTrySubstitute(PVBOXVHWAREGION pReg, const RECTL *pRect);
 
 VBOXVHWACMD* vboxVHWACommandCreate (PPDEV ppdev, VBOXVHWACMD_TYPE enmCmd, VBOXVHWACMD_LENGTH cbCmd);
@@ -314 +317 @@
 void vboxVHWACommandSubmitAsynchByEvent (PPDEV ppdev, VBOXVHWACMD* pCmd, PEVENT pEvent);
 void vboxVHWACommandCheckHostCmds(PPDEV ppdev);
+void vboxVHWACommandSubmitAsynchAndComplete (PPDEV ppdev, VBOXVHWACMD* pCmd);
 
 int vboxVHWAInitHostInfo1(PPDEV ppdev);

trunk/src/VBox/Additions/WINNT/Graphics/Display/vbox.c

@@ -782 +782 @@
 
     /* complete it asynchronously by setting event */
-    pCmd->Flags |= VBOXVHWACMD_FLAG_ASYNCH_EVENT;
+    pCmd->Flags |= VBOXVHWACMD_FLAG_GH_ASYNCH_EVENT;
     vboxHGSMIBufferSubmit (ppdev, pCmd);
 
-    if(!(ASMAtomicReadU32((volatile uint32_t *)&pCmd->Flags)  & VBOXVHWACMD_FLAG_ASYNCH))
+    if(!(ASMAtomicReadU32((volatile uint32_t *)&pCmd->Flags)  & VBOXVHWACMD_FLAG_HG_ASYNCH))
     {
         /* the command is completed */
@@ -800 +800 @@
     if(brc)
     {
-        pCmd->Flags = VBOXVHWACMD_FLAG_ASYNCH_IRQ;
+        pCmd->Flags |= VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ;
         vboxVHWACommandSubmitAsynchByEvent (ppdev, pCmd, pEvent);
 
@@ -822 +822 @@
     pCmd->GuestVBVAReserved2 = (uintptr_t)pContext;
 
-    pCmd->Flags = 0;
     vboxHGSMIBufferSubmit (ppdev, pCmd);
 
-    if(!(pCmd->Flags  & VBOXVHWACMD_FLAG_ASYNCH))
+    if(!(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH))
     {
         /* the command is completed */
         pfnCompletion(ppdev, pCmd, pContext);
+    }
+}
+
+static DECLCALLBACK(void) vboxVHWAFreeCmdCompletion(PPDEV ppdev, VBOXVHWACMD * pCmd, void * pContext)
+{
+    vboxVHWACommandFree(ppdev, pCmd);
+}
+
+void vboxVHWACommandSubmitAsynchAndComplete (PPDEV ppdev, VBOXVHWACMD* pCmd)
+{
+//    Assert(0);
+    pCmd->GuestVBVAReserved1 = (uintptr_t)vboxVHWAFreeCmdCompletion;
+
+    pCmd->Flags |= VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION;
+
+    vboxHGSMIBufferSubmit (ppdev, pCmd);
+
+    if(!(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH)
+            || pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH_RETURNED)
+    {
+        /* the command is completed */
+        vboxVHWAFreeCmdCompletion(ppdev, pCmd, NULL);
     }
 }
@@ -919 +940 @@
     int rc = VINF_SUCCESS;
 
-    if(pInfo)
+    Assert(pInfo);
+    if(!pInfo)
         return VERR_OUT_OF_RESOURCES;
 

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.cpp

@@ -1327 +1327 @@
         {
             /* schedule a DPC*/
-            BOOLEAN bResult = VideoPortQueueDpc(PrimaryExtension, VBoxVideoHGSMIDpc, NULL);
+            BOOLEAN bResult = VideoPortQueueDpc(PrimaryExtension, VBoxVideoHGSMIDpc, (PVOID)1);
             Assert(bResult);
         }

trunk/src/VBox/Frontends/VirtualBox/Makefile.kmk

@@ -476 +476 @@
 VirtualBox_SOURCES += $(VBOX_VIRTUALBOX4_OUT_DIR)/VirtualBoxBrand.qrc
 $(VBOX_VIRTUALBOX4_OUT_DIR)/VirtualBoxBrand.qrc_RCCFLAGS = -name BRAND
-
+ifdef VBOX_WITH_VIDEOHWACCEL
+VirtualBox_SOURCES += VirtualBoxShaders.qrc
+VirtualBoxShaders.qrc_RCCFLAGS = -name SHADERS
+endif
+ 
 # Import the translation source from VBoxUI.pro and add the qt_xx_YY counterparts
 VirtualBox_QT_TRANSLATIONS := $(TRANSLATIONS) \

trunk/src/VBox/Frontends/VirtualBox/include/VBoxDefs.h

@@ -129 +129 @@
         AddVDMUrlsEventType,
         ChangeDockIconUpdateEventType
-#ifdef VBOX_WITH_VIDEOHWACCEL
+#ifdef VBOX_GUI_USE_QGL
         ,
         VHWACommandProcessType

trunk/src/VBox/Frontends/VirtualBox/include/VBoxFrameBuffer.h

@@ -117 +117 @@
 };
 
-#ifdef VBOX_WITH_VIDEOHWACCEL
+#ifdef VBOX_GUI_USE_QGL
+typedef enum
+{
+    VBOXVHWA_PIPECMD_PAINT = 1,
+    VBOXVHWA_PIPECMD_VHWA,
+
+}VBOXVHWA_PIPECMD_TYPE;
+class VBoxVHWACommandElement
+{
+public:
+    void setVHWACmd(struct _VBOXVHWACMD * pCmd)
+    {
+        mType = VBOXVHWA_PIPECMD_VHWA;
+        mpCmd = pCmd;
+    }
+
+    void setPaintCmd(const QRect & aRect)
+    {
+        mType = VBOXVHWA_PIPECMD_PAINT;
+        mRect = aRect;
+    }
+
+    void setData(VBOXVHWA_PIPECMD_TYPE aType, void * pvData)
+    {
+        switch(aType)
+        {
+        case VBOXVHWA_PIPECMD_PAINT:
+            setPaintCmd(*((QRect*)pvData));
+            break;
+        case VBOXVHWA_PIPECMD_VHWA:
+            setVHWACmd((struct _VBOXVHWACMD *)pvData);
+            break;
+        }
+    }
+
+    VBOXVHWA_PIPECMD_TYPE type() const {return mType;}
+    const QRect & rect() const {return mRect;}
+    struct _VBOXVHWACMD * vhwaCmd() const {return mpCmd;}
+
+private:
+    VBoxVHWACommandElement * mpNext;
+    VBOXVHWA_PIPECMD_TYPE mType;
+    struct _VBOXVHWACMD * mpCmd;
+    QRect                 mRect;
+
+    friend class VBoxVHWACommandElementPipe;
+    friend class VBoxVHWACommandElementStack;
+    friend class VBoxGLWidget;
+};
+
+class VBoxVHWACommandElementPipe
+{
+public:
+    VBoxVHWACommandElementPipe() :
+        mpFirst(NULL),
+        mpLast(NULL)
+    {}
+
+    void put(VBoxVHWACommandElement *pCmd)
+    {
+        if(mpLast)
+        {
+            Assert(mpFirst);
+            mpLast->mpNext = pCmd;
+            mpLast = pCmd;
+        }
+        else
+        {
+            Assert(!mpFirst);
+            mpFirst = pCmd;
+            mpLast = pCmd;
+        }
+        pCmd->mpNext= NULL;
+
+    }
+
+    VBoxVHWACommandElement * detachList()
+    {
+        if(mpLast)
+        {
+            VBoxVHWACommandElement * pHead = mpFirst;
+            mpFirst = NULL;
+            mpLast = NULL;
+            return pHead;
+        }
+        return NULL;
+    }
+private:
+    VBoxVHWACommandElement *mpFirst;
+    VBoxVHWACommandElement *mpLast;
+};
+
+class VBoxVHWACommandElementStack
+{
+public:
+    VBoxVHWACommandElementStack() :
+        mpFirst(NULL) {}
+
+    void push(VBoxVHWACommandElement *pCmd)
+    {
+        pCmd->mpNext = mpFirst;
+        mpFirst = pCmd;
+    }
+
+    void pusha(VBoxVHWACommandElement *pFirst, VBoxVHWACommandElement *pLast)
+    {
+        pLast->mpNext = mpFirst;
+        mpFirst = pFirst;
+    }
+
+    VBoxVHWACommandElement * pop()
+    {
+        if(mpFirst)
+        {
+            VBoxVHWACommandElement * ret = mpFirst;
+            mpFirst = ret->mpNext;
+            return ret;
+        }
+        return NULL;
+    }
+private:
+    VBoxVHWACommandElement *mpFirst;
+};
+
 class VBoxVHWACommandProcessEvent : public QEvent
 {
 public:
-    VBoxVHWACommandProcessEvent (struct _VBOXVHWACMD * pCmd)
+    VBoxVHWACommandProcessEvent (VBoxVHWACommandElement *pEl)
         : QEvent ((QEvent::Type) VBoxDefs::VHWACommandProcessType)
-        , mpCmd (pCmd) {}
-    struct _VBOXVHWACMD * command() { return mpCmd; }
-private:
-    struct _VBOXVHWACMD * mpCmd;
+    {
+        mCmdPipe.put(pEl);
+    }
+    VBoxVHWACommandElementPipe & pipe() { return mCmdPipe; }
+private:
+    VBoxVHWACommandElementPipe mCmdPipe;
+    VBoxVHWACommandProcessEvent *mpNext;
+
+    friend class VBoxGLWidget;
 };
 
@@ -251 +379 @@
     virtual void moveEvent (QMoveEvent * /*me*/ ) {}
 
-#ifdef VBOX_WITH_VIDEOHWACCEL
+#ifdef VBOX_GUI_USE_QGL
     /* this method is called from the GUI thread
      * to perform the actual Video HW Acceleration command processing */
-    virtual void doProcessVHWACommand(struct _VBOXVHWACMD * pCommand);
+    virtual void doProcessVHWACommand(VBoxVHWACommandProcessEvent * pEvent);
 #endif
 
@@ -307 +435 @@
 
 #if defined (VBOX_GUI_USE_QGL)
+
+#ifdef DEBUG
+#include "iprt/stream.h"
+#define VBOXQGLLOG(_m) RTPrintf _m
+#else
+#define VBOXQGLLOG(_m)
+#endif
+#define VBOXQGLLOG_ENTER(_m)
+//do{VBOXQGLLOG(("==>[%s]:", __FUNCTION__)); VBOXQGLLOG(_m);}while(0)
+#define VBOXQGLLOG_EXIT(_m)
+//do{VBOXQGLLOG(("<==[%s]:", __FUNCTION__)); VBOXQGLLOG(_m);}while(0)
+#ifdef DEBUG
+#define VBOXQGL_ASSERTNOERR() \
+    do { GLenum err = glGetError(); \
+        if(err != GL_NO_ERROR) VBOXQGLLOG(("gl error ocured (0x%x)\n", err)); \
+        Assert(err == GL_NO_ERROR); \
+    }while(0)
+
+#define VBOXQGL_CHECKERR(_op) \
+    do { \
+        glGetError(); \
+        _op \
+        VBOXQGL_ASSERTNOERR(); \
+    }while(0)
+#else
+#define VBOXQGL_ASSERTNOERR() \
+    do {}while(0)
+
+#define VBOXQGL_CHECKERR(_op) \
+    do { \
+        _op \
+    }while(0)
+#endif
+
+#ifdef DEBUG
+#include <iprt/time.h>
+
+#define VBOXGETTIME() RTTimeNanoTS()
+
+#define VBOXPRINTDIF(_nano, _m) do{\
+        uint64_t cur = VBOXGETTIME(); \
+        VBOXQGLLOG(_m); \
+        VBOXQGLLOG(("(%Lu)\n", cur - (_nano))); \
+    }while(0)
+
+class VBoxVHWADbgTimeCounter
+{
+public:
+    VBoxVHWADbgTimeCounter(const char* msg) {mTime = VBOXGETTIME(); mMsg=msg;}
+    ~VBoxVHWADbgTimeCounter() {VBOXPRINTDIF(mTime, (mMsg));}
+private:
+    uint64_t mTime;
+    const char* mMsg;
+};
+
+#define VBOXQGLLOG_METHODTIME(_m) VBoxVHWADbgTimeCounter _dbgTimeCounter(_m)
+#else
+#define VBOXQGLLOG_METHODTIME(_m)
+#endif
+
+#define VBOXQGLLOG_QRECT(_p, _pr, _s) do{\
+    VBOXQGLLOG((_p " x(%d), y(%d), w(%d), h(%d)" _s, (_pr)->x(), (_pr)->y(), (_pr)->width(), (_pr)->height()));\
+    }while(0)
+
+#define VBOXQGLLOG_CKEY(_p, _pck, _s) do{\
+    VBOXQGLLOG((_p " l(%d), u(%d)" _s, (_pck)->lower(), (_pck)->upper()));\
+    }while(0)
+
 class VBoxVHWADirtyRect
 {
@@ -398 +594 @@
     uint32_t mLower;
 };
-
-//class VBoxVHWAColorKeyRef
-//{
-//public:
-//    VBoxVHWAColorKeyRef() : mValid(false){}
-//
-//    bool isValid() {return mValid; }
-//
-//    VBoxVHWAColorKey * ckey() { isVreturn mpCKey; }
-//    const VBoxVHWAColorKey * constckey() const { return mpCKey; }
-//
-//    void invalidate() { mValid = false; }
-//    void set(VBoxVHWAColorKey * pKey) { mValid = false; }
-//
-//private:
-//    VBoxVHWAColorKey * mpCKey;
-//    bool mValid;
-//};
 
 class VBoxVHWAColorComponent
@@ -448 +626 @@
 //    VBoxVHWAColorFormat(GLint aInternalFormat, GLenum aFormat, GLenum aType, uint32_t aDataFormat);
     VBoxVHWAColorFormat(uint32_t bitsPerPixel, uint32_t r, uint32_t g, uint32_t b);
-
+    VBoxVHWAColorFormat(uint32_t fourcc);
+    VBoxVHWAColorFormat(){}
     GLint internalFormat() const {return mInternalFormat; }
     GLenum format() const {return mFormat; }
     GLenum type() const {return mType; }
     bool isValid() const {return mBitsPerPixel != 0; }
-    uint32_t dataFormat() const {return mDataFormat;}
+    uint32_t fourcc() const {return mDataFormat;}
     uint32_t bitsPerPixel() const { return mBitsPerPixel; }
+    uint32_t bitsPerPixelDd() const { return mBitsPerPixelDd; }
     void pixel2Normalized(uint32_t pix, float *r, float *g, float *b) const;
+    uint32_t widthCompression() const {return mWidthCompression;}
+    uint32_t heightCompression() const {return mHeightCompression;}
 //    uint32_t r(uint32_t pix);
 //    uint32_t g(uint32_t pix);
@@ -462 +644 @@
 private:
     void VBoxVHWAColorFormat::init(uint32_t bitsPerPixel, uint32_t r, uint32_t g, uint32_t b);
+    void VBoxVHWAColorFormat::init(uint32_t fourcc);
 
     GLint mInternalFormat;
@@ -469 +652 @@
 
     uint32_t mBitsPerPixel;
-
+    uint32_t mBitsPerPixelDd;
+    uint32_t mWidthCompression;
+    uint32_t mHeightCompression;
     VBoxVHWAColorComponent mR;
     VBoxVHWAColorComponent mG;
     VBoxVHWAColorComponent mB;
+    VBoxVHWAColorComponent mA;
+};
+
+class VBoxVHWATexture
+{
+public:
+    VBoxVHWATexture() {}
+    VBoxVHWATexture(const QRect * pRect, const VBoxVHWAColorFormat *pFormat);
+    void init(uchar *pvMem);
+    void setAddress(uchar *pvMem) {mAddress = pvMem;}
+    void uninit();
+    void update(const QRect * pRect);
+    GLuint texture() {return mTexture;}
+    const QRect & texRect() {return mTexRect;}
+    const QRect & rect() {return mRect;}
+    uchar * address(){ return mAddress; }
+    uchar * pointAddress(int x, int y)
+    {
+        x = toXTex(x);
+        y = toYTex(y);
+        return pointAddressTex(x, y);
+    }
+    uchar * pointAddressTex(int x, int y) { return mAddress + y*mBytesPerLine + x*mBytesPerPixel; }
+    int toXTex(int x) {return x/mColorFormat.widthCompression();}
+    int toYTex(int y) {return y/mColorFormat.heightCompression();}
+    ulong memSize(){ return mBytesPerLine * mRect.height()/mColorFormat.heightCompression(); }
+private:
+    uchar * mAddress;
+    GLuint mTexture;
+    uint32_t mBytesPerPixel;
+    uint32_t mBytesPerLine;
+    QRect mTexRect; /* texture size */
+    QRect mRect; /* img size */
+    VBoxVHWAColorFormat mColorFormat;
 };
 
@@ -498 +717 @@
 {
 public:
-    VBoxVHWASurfaceBase(class VBoxVHWAGlContextState *aState, bool aIsYInverted, const QSize * aSize, const QSize * aTargetSize,
+    VBoxVHWASurfaceBase(
+            class VBoxGLWidget *mWidget,
+#if 0
+            class VBoxVHWAGlContextState *aState,
+            bool aIsYInverted,
+#endif
+            const QSize * aSize, const QSize * aTargetSize,
             VBoxVHWAColorFormat & aColorFormat,
             VBoxVHWAColorKey * pSrcBltCKey, VBoxVHWAColorKey * pDstBltCKey,
@@ -505 +730 @@
     virtual ~VBoxVHWASurfaceBase();
 
-    virtual void init(uchar *pvMem);
-
-    virtual void uninit();
+    void init(VBoxVHWASurfaceBase * pPrimary, uchar *pvMem);
+    void setupMatricies(VBoxVHWASurfaceBase *pPrimary);
+
+    void uninit();
 
     static void globalInit();
 
-    int blt(const QRect * aDstRect, VBoxVHWASurfaceBase * aSrtSurface, const QRect * aSrcRect, const VBoxVHWAColorKey * pDstCKeyOverride, const VBoxVHWAColorKey * pSrcCKeyOverride);
-    int overlay(VBoxVHWASurfaceBase * aOverlaySurface);
-
-    virtual int lock(const QRect * pRect, uint32_t flags);
-
-    virtual int unlock();
+//    int blt(const QRect * aDstRect, VBoxVHWASurfaceBase * aSrtSurface, const QRect * aSrcRect, const VBoxVHWAColorKey * pDstCKeyOverride, const VBoxVHWAColorKey * pSrcCKeyOverride);
+//    int overlay(VBoxVHWASurfaceBase * aOverlaySurface);
+
+    int lock(const QRect * pRect, uint32_t flags);
+
+    int unlock();
 
     void updatedMem(const QRect * aRect);
 
-    void performDisplay();
-
-    void setRects(const QRect * aTargRect, const QRect * aSrcRect);
-    void setTargetRectPosition(const QPoint * aPoint);
+    void performDisplay(VBoxVHWASurfaceBase *pPrimary);
+
+    void setRects(VBoxVHWASurfaceBase *pPrimary, const QRect * aTargRect, const QRect * aSrcRect);
+    void setTargetRectPosition(VBoxVHWASurfaceBase *pPrimary, const QPoint * aPoint);
 
     static ulong calcBytesPerPixel(GLenum format, GLenum type);
@@ -531 +757 @@
     bool    addressAlocated() const { return mFreeAddress; }
     uchar * address(){ return mAddress; }
-    uchar * pointAddress(int x, int y) { return mAddress + y*mBytesPerLine + x*mBytesPerPixel; }
-    ulong   memSize(){ return mBytesPerLine * mRect.height(); }
+
+    ulong   memSize();
 
     ulong width()  { return mRect.width();  }
@@ -540 +766 @@
     GLint  internalFormat() { return mColorFormat.internalFormat(); }
     GLenum type() { return mColorFormat.type(); }
-    uint32_t dataFormat() {return mColorFormat.dataFormat(); }
+    uint32_t fourcc() {return mColorFormat.fourcc(); }
 
     ulong  bytesPerPixel() { return mBytesPerPixel; }
     ulong  bitsPerPixel() { return mColorFormat.bitsPerPixel(); }
+    ulong  bitsPerPixelDd() { return mColorFormat.bitsPerPixelDd(); }
     ulong  bytesPerLine() { return mBytesPerLine; }
 
@@ -633 +860 @@
     }
 
+    const VBoxVHWAColorKey * getActiveSrcOverlayCKey()
+    {
+        return mpSrcOverlayCKey;
+    }
+
+    const VBoxVHWAColorKey * getActiveDstOverlayCKey(VBoxVHWASurfaceBase * pPrimary)
+    {
+        return mpDstOverlayCKey ? mpDefaultDstOverlayCKey : pPrimary->mpDstOverlayCKey;
+    }
 
     const VBoxVHWAColorFormat & colorFormat() {return mColorFormat; }
 
     /* clients should treat the returned texture as read-only */
-    GLuint textureSynched(const QRect * aRect) { synchTex(aRect); return mTexture; }
+//    GLuint textureSynched(const QRect * aRect) { /*synchTex(aRect); */synchTexMem(aRect);  return mTexture; }
 
     void setAddress(uchar * addr);
 
     const QRect& rect() {return mRect;}
+    const QRect& texRect() {return mTexRect;}
 
 //    /* surface currently being displayed in a flip chain */
@@ -647 +884 @@
 //    /* surface representing the main framebuffer. */
 //    virtual bool isMainFramebuffer() = 0;
+#if 0
     virtual void makeCurrent() = 0;
     virtual void makeYInvertedCurrent() = 0;
-
     bool isYInverted() {return mIsYInverted; }
 
-    bool isHidden() {return mIsHidden; }
-    void setHidden(bool hidden) { mIsHidden = hidden; }
-
+    bool isHidden() {return mIsYInverted; }
+    void setHidden(bool hidden)
+    {
+        if(hidden == mIsYInverted)
+            return;
+
+        invert();
+    }
     int invert();
 
     bool isFrontBuffer() {return !mIsYInverted; }
+#endif
+
+    class VBoxVHWASurfList * getComplexList() {return mComplexList; }
 
 //    bool isOverlay() { return mIsOverlay; }
 
 #ifdef VBOX_WITH_VIDEOHWACCEL
-    virtual class VBoxVHWAGlProgramMngr * getGlProgramMngr() = 0;
-    static int setCKey(class VBoxVHWAGlProgramVHWA * pProgram, const VBoxVHWAColorFormat * pFormat, const VBoxVHWAColorKey * pCKey);
-#endif
-private:
-    void initDisplay();
+    class VBoxVHWAGlProgramMngr * getGlProgramMngr();
+    static int setCKey(class VBoxVHWAGlProgramVHWA * pProgram, const VBoxVHWAColorFormat * pFormat, const VBoxVHWAColorKey * pCKey, bool bDst);
+#endif
+private:
+    void setComplexList(VBoxVHWASurfList *aComplexList) { mComplexList = aComplexList; }
+    void initDisplay(VBoxVHWASurfaceBase *pPrimary);
     void deleteDisplay();
-    void initDisplay(bool bInverted);
-    void deleteDisplay(bool bInverted);
-    GLuint createDisplay(bool bInverted);
+//    void initDisplay(bool bInverted);
+//    void deleteDisplay(bool bInverted);
+    GLuint createDisplay(VBoxVHWASurfaceBase *pPrimary
+#if 0
+            bool bInverted
+#endif
+            );
+    void doDisplay(VBoxVHWASurfaceBase *pPrimary, VBoxVHWAGlProgramVHWA * pProgram, bool bBindDst);
+    void synchTexMem(const QRect * aRect);
+#if 0
     void synchTex(const QRect * aRect);
-    void synchTexMem(const QRect * aRect);
     void synchTexFB(const QRect * aRect);
     void synchMem(const QRect * aRect);
     void synchFB(const QRect * aRect);
     void synch(const QRect * aRect);
-
+#endif
     int performBlt(const QRect * pDstRect, VBoxVHWASurfaceBase * pSrcSurface, const QRect * pSrcRect, const VBoxVHWAColorKey * pDstCKey, const VBoxVHWAColorKey * pSrcCKey, bool blt);
 
 //    void doTex2FB(const QRect * aRect);
     void doTex2FB(const QRect * pDstRect, const QRect * pSrcRect);
-
-    void doSetupMatrix(const QSize * pSize, bool bInverted);
+    void doMultiTex2FB(const QRect * pDstRect, const QRect * pDstTexSize, const QRect * pSrcRect, int cSrcTex);
+    void doMultiTex2FB(const QRect * pDstRect, const QRect * pSrcRect, int cSrcTex);
+//    void doMultiTex2FB(GLenum tex, const QRect * pDstRect, const QRect * pSrcRect);
+
+    void doSetupMatrix(const QSize * pSize , bool bInverted);
 
     QRect mRect; /* == Inv FB size */
@@ -691 +946 @@
     QRect mTargRect; /* == Vis FB size */
     QRect mTargSize;
-
+#if 0
     GLuint mYInvertedDisplay;
+#endif
     GLuint mVisibleDisplay;
-
+#if 0
     bool mYInvertedDisplayInitialized;
+#endif
     bool mVisibleDisplayInitialized;
 
     uchar * mAddress;
-    GLuint mTexture;
+    VBoxVHWATexture mTex[3];
 
     VBoxVHWAColorFormat mColorFormat;
@@ -730 +987 @@
     /* memory buffer not reflected in fm and texture, e.g if memory buffer is replaced or in case of lock/unlock  */
     VBoxVHWADirtyRect mUpdateMem2TexRect;
+#if 0
     /* memory buffer not reflected in fm and texture, e.g if memory buffer is replaced or in case of lock/unlock  */
     VBoxVHWADirtyRect mUpdateTex2FBRect;
@@ -736 +994 @@
     /*in case of blit the memory buffer does not get updated until we need it, e.g. for paint or lock operations */
     VBoxVHWADirtyRect mUpdateFB2MemRect;
-
-    /* flag for lazy invert post-processing */
-    bool mInverted;
+#endif
 
     bool mFreeAddress;
-
+#if 0
     bool mIsYInverted;
-
-    bool mIsHidden;
-
-//    bool mIsOverlay;
-
+#endif
+
+    class VBoxVHWASurfList *mComplexList;
+
+    class VBoxGLWidget *mWidget;
 protected:
+#if 0
     virtual void init(uchar *pvMem, bool bInverted);
-
     class VBoxVHWAGlContextState *mState;
-
+#endif
+
+    friend class VBoxVHWASurfList;
+
+};
+
+typedef std::list <VBoxVHWASurfaceBase*> SurfList;
+
+class VBoxVHWASurfList
+{
+public:
+
+    VBoxVHWASurfList() : mCurrent(NULL) {}
+    void add(VBoxVHWASurfaceBase *pSurf)
+    {
+        VBoxVHWASurfList * pOld = pSurf->getComplexList();
+        if(pOld)
+        {
+            pOld->remove(pSurf);
+        }
+        mSurfaces.push_back(pSurf);
+        pSurf->setComplexList(this);
+    }
+
+    void clear()
+    {
+        for (SurfList::iterator it = mSurfaces.begin();
+             it != mSurfaces.end(); ++ it)
+        {
+            (*it)->setComplexList(NULL);
+        }
+        mSurfaces.clear();
+        mCurrent = NULL;
+    }
+
+    void remove(VBoxVHWASurfaceBase *pSurf)
+    {
+        mSurfaces.remove(pSurf);
+        pSurf->setComplexList(NULL);
+        if(mCurrent == pSurf)
+            mCurrent = NULL;
+    }
+
+    bool empty() { return mSurfaces.empty(); }
+
+    void setCurrentVisible(VBoxVHWASurfaceBase *pSurf)
+    {
+        mCurrent = pSurf;
+    }
+
+    VBoxVHWASurfaceBase * current() { return mCurrent; }
+    const SurfList & surfaces() const {return mSurfaces;}
+
+private:
+
+    SurfList mSurfaces;
+    VBoxVHWASurfaceBase* mCurrent;
 };
 
@@ -759 +1071 @@
 public:
     VBoxVHWADisplay() :
-        mSurfVGA(NULL),
-        mSurfPrimary(NULL)
+        mSurfVGA(NULL)
+//        ,
+//        mSurfPrimary(NULL)
     {}
 
@@ -767 +1080 @@
         VBoxVHWASurfaceBase * old = mSurfVGA;
         mSurfVGA = pVga;
-        mSurfPrimary = pVga;
+        mPrimary.clear();
+        if(pVga)
+        {
+            mPrimary.add(pVga);
+            mPrimary.setCurrentVisible(pVga);
+        }
+//        mSurfPrimary = pVga;
         mOverlays.clear();
         return old;
@@ -779 +1098 @@
     VBoxVHWASurfaceBase * getPrimary()
     {
-        return mSurfPrimary;
-    }
-
-    void setPrimary(VBoxVHWASurfaceBase * pSurf)
-    {
-        mSurfPrimary = pSurf;
-    }
-
-    void addOverlay(VBoxVHWASurfaceBase * pSurf)
+        return mPrimary.current();
+    }
+//
+//    void setPrimary(VBoxVHWASurfList * pSurf)
+//    {
+//        mSurfPrimary = pSurf;
+//    }
+
+    void addOverlay(VBoxVHWASurfList * pSurf)
     {
         mOverlays.push_back(pSurf);
     }
 
-    void checkAddOverlay(VBoxVHWASurfaceBase * pSurf)
+    void checkAddOverlay(VBoxVHWASurfList * pSurf)
     {
         if(!hasOverlay(pSurf))
@@ -798 +1117 @@
     }
 
-    bool hasOverlay(VBoxVHWASurfaceBase * pSurf)
+    bool hasOverlay(VBoxVHWASurfList * pSurf)
     {
         for (OverlayList::iterator it = mOverlays.begin();
@@ -811 +1130 @@
     }
 
-    void removeOverlay(VBoxVHWASurfaceBase * pSurf)
+    void removeOverlay(VBoxVHWASurfList * pSurf)
     {
         mOverlays.remove(pSurf);
     }
 
-    void flip(VBoxVHWASurfaceBase * pTarg, VBoxVHWASurfaceBase * pCurr)
-    {
-        pCurr->invert();
-        pTarg->invert();
-        if(pCurr == mSurfPrimary) /* flip of the primary surface */
-        {
-            mSurfPrimary = pTarg;
-        }
-        else /* flip of the overlay */
-        {
-            for (OverlayList::iterator it = mOverlays.begin();
-                 it != mOverlays.end(); ++ it)
-            {
-                if((*it) == pCurr)
-                {
-                    (*it) = pTarg;
-                    pCurr->setHidden(false);
-                    break;
-                }
-            }
-        }
-    }
 
     void performDisplay()
     {
-        mSurfPrimary->performDisplay();
+        VBoxVHWASurfaceBase * pPrimary = mPrimary.current();
+        pPrimary->performDisplay(NULL);
 
         for (OverlayList::const_iterator it = mOverlays.begin();
              it != mOverlays.end(); ++ it)
         {
-            mSurfPrimary->overlay(*it);
+            VBoxVHWASurfaceBase * pOverlay = (*it)->current();
+            if(pOverlay)
+            {
+                pOverlay->performDisplay(pPrimary);
+//                pPrimary->overlay(pOverlay);
+            }
         }
     }
@@ -852 +1155 @@
 private:
     VBoxVHWASurfaceBase *mSurfVGA;
-    VBoxVHWASurfaceBase *mSurfPrimary;
-
-    typedef std::list <VBoxVHWASurfaceBase*> OverlayList;
+    VBoxVHWASurfList mPrimary;
+
+    typedef std::list <VBoxVHWASurfList*> OverlayList;
 
     OverlayList mOverlays;
 };
 
-
-
-class VBoxVHWAGlContextState
-{
-public:
-    VBoxVHWAGlContextState() : mContext(NULL), mInverted(false) {}
-
-    void assertCurrent(class VBoxVHWASurfaceBase *aContext, bool bInverted)
-    {
-        mContext = aContext;
-        if(aContext && aContext->isYInverted())
-        {
-            mInverted = true;
-        }
-        else
-        {
-            mInverted = bInverted;
-        }
-    }
-
-    void makeYInvertedCurrent(class VBoxVHWASurfaceBase *aContext)
-    {
-        if(mContext != aContext)
-        {
-//            aContext->makeCurrent();
-            aContext->makeYInvertedCurrent();
-            assertCurrent(aContext, true);
-        }
-        else
-        {
-            if(!aContext->isYInverted() && !mInverted)
-            {
-//                aContext->makeCurrent();
-                aContext->makeYInvertedCurrent();
-                mInverted = true;
-            }
-        }
-    }
-
-    void makeCurrent(class VBoxVHWASurfaceBase *aContext)
-    {
-        if(mContext != aContext)
-        {
-            aContext->makeCurrent();
-            assertCurrent(aContext, false);
-        }
-        else
-        {
-            if(!aContext->isYInverted() && mInverted)
-            {
-                aContext->makeCurrent();
-                mInverted = false;
-            }
-        }
-    }
-
-    void makeCurrent(class VBoxVHWASurfaceBase *aContext, bool mInverted)
-    {
-        if(mInverted)
-        {
-            makeYInvertedCurrent(aContext);
-        }
-        else
-        {
-            makeCurrent(aContext);
-        }
-    }
-
-    class VBoxVHWASurfaceBase * getCurrent() {return mContext; }
-    bool isCurrentYInverted() {return mInverted; }
-
-private:
-
-    class VBoxVHWASurfaceBase *mContext;
-    bool mInverted;
-};
-
-class VBoxVHWASurfaceQGL : public VBoxVHWASurfaceBase
-{
-public:
-    VBoxVHWASurfaceQGL(class VBoxVHWAGlContextState *aState, const QSize * aSize, const QSize * aTargetSize,
-            VBoxVHWAColorFormat & aColorFormat,
-            VBoxVHWAColorKey * pSrcBltCKey, VBoxVHWAColorKey * pDstBltCKey,
-            VBoxVHWAColorKey * pSrcOverlayCKey, VBoxVHWAColorKey * pDstOverlayCKey,
-            class VBoxGLWidget *pWidget,
-            bool bInvisibleBuffer) :
-                VBoxVHWASurfaceBase(aState, bInvisibleBuffer, aSize, aTargetSize,
-                        aColorFormat,
-                        pSrcBltCKey, pDstBltCKey, pSrcOverlayCKey, pDstOverlayCKey),
-                mWidget(pWidget),
-                mBuffer(NULL)
-    {}
-
-    ~VBoxVHWASurfaceQGL();
-
-    void makeCurrent();
-    void makeYInvertedCurrent();
-
-    void init(uchar *pvMem);
-
-    void uninit();
-
-//    int unlock()
-//    {
-//        int rc = VBoxVHWASurfaceBase::unlock();
-//        if(!mBuffer)
-//            performDisplay();
-//        return rc;
-//    }
-#ifdef VBOX_WITH_VIDEOHWACCEL
-    class VBoxVHWAGlProgramMngr * getGlProgramMngr();
-#endif
-private:
-    class VBoxGLWidget *mWidget;
-    class QGLPixelBuffer *mBuffer;
-protected:
-    virtual void init(uchar *pvMem, bool bInverted);
-};
-
 class VBoxGLWidget : public QGLWidget
 {
 public:
-    VBoxGLWidget (QWidget *aParent);
+    VBoxGLWidget (VBoxConsoleView *aView, QWidget *aParent);
     ~VBoxGLWidget();
 
@@ -1000 +1184 @@
     void vboxTestSurfaces () {vboxPerformGLOp(&VBoxGLWidget::vboxDoTestSurfaces, NULL);}
 #endif
+    void vboxProcessVHWACommands(VBoxVHWACommandProcessEvent * pEvent) {vboxPerformGLOp(&VBoxGLWidget::vboxDoProcessVHWACommands, pEvent);}
 #ifdef VBOX_WITH_VIDEOHWACCEL
     void vboxVHWACmd (struct _VBOXVHWACMD * pCmd) {vboxPerformGLOp(&VBoxGLWidget::vboxDoVHWACmd, pCmd);}
-    class VBoxVHWAGlProgramMngr * vboxVHWAGetGlProgramMngr();
+    class VBoxVHWAGlProgramMngr * vboxVHWAGetGlProgramMngr() { return mpMngr; }
 #endif
 
     VBoxVHWASurfaceBase * vboxGetVGASurface() { return mDisplay.getVGA(); }
+
+    void postCmd(VBOXVHWA_PIPECMD_TYPE aType, void * pvData);
 protected:
 //    void resizeGL (int height, int width);
@@ -1011 +1198 @@
     void paintGL()
     {
-        Assert(mState.getCurrent() == NULL);
-        /* we are called with QGLWidget context */
-        mState.assertCurrent(mDisplay.getVGA(), false);
-        (this->*mpfnOp)(mOpContext);
-        /* restore the context */
-        mState.makeCurrent(mDisplay.getVGA());
-        /* clear*/
-        mState.assertCurrent(NULL, false);
+//        Assert(mState.getCurrent() == NULL);
+//        /* we are called with QGLWidget context */
+//        mState.assertCurrent(mDisplay.getVGA(), false);
+        if(mpfnOp)
+        {
+            (this->*mpfnOp)(mOpContext);
+            mpfnOp = NULL;
+        }
+        else
+        {
+            mDisplay.performDisplay();
+        }
+//        /* restore the context */
+//        mState.makeCurrent(mDisplay.getVGA());
+//        /* clear*/
+//        mState.assertCurrent(NULL, false);
     }
 
     void initializeGL();
-
 private:
 //    void vboxDoInitDisplay();
@@ -1029 +1223 @@
     void vboxDoResize(void *re);
     void vboxDoPaint(void *rec);
+
+    void vboxDoUpdateRect(const QRect * pRect);
 #ifdef DEBUG_misha
     void vboxDoTestSurfaces(void *context);
@@ -1057 +1253 @@
     int vhwaQueryInfo1(struct _VBOXVHWACMD_QUERYINFO1 *pCmd);
     int vhwaQueryInfo2(struct _VBOXVHWACMD_QUERYINFO2 *pCmd);
-#endif
+
+    void vhwaDoSurfaceOverlayUpdate(VBoxVHWASurfaceBase *pDstSurf, VBoxVHWASurfaceBase *pSrcSurf, struct _VBOXVHWACMD_SURF_OVERLAY_UPDATE *pCmd);
+#endif
+    static const QGLFormat & vboxGLFormat();
 
 //    VBoxVHWASurfaceQGL * pDisplay;
@@ -1067 +1266 @@
     void vboxPerformGLOp(PFNVBOXQGLOP pfn, void* pContext) {mpfnOp = pfn; mOpContext = pContext; updateGL();}
 
+    void cmdPipeInit();
+    void cmdPipeDelete();
+    void vboxDoProcessVHWACommands(void *pContext);
+
+    VBoxVHWACommandElement * detachCmdList(VBoxVHWACommandElement * pFirst2Free, VBoxVHWACommandElement * pLast2Free);
+    VBoxVHWACommandElement * processCmdList(VBoxVHWACommandElement * pCmd);
+
     PFNVBOXQGLOP mpfnOp;
     void *mOpContext;
@@ -1073 +1279 @@
     ulong  mPixelFormat;
     bool   mUsesGuestVRAM;
-
+#if 0
     VBoxVHWAGlContextState mState;
+#endif
+
+    RTCRITSECT mCritSect;
+    VBoxVHWACommandProcessEvent *mpFirstEvent;
+    VBoxVHWACommandProcessEvent *mpLastEvent;
+    bool mbNewEvent;
+    VBoxVHWACommandElementStack mFreeElements;
+    VBoxVHWACommandElement mElementsBuffer[2048];
+
+    VBoxConsoleView *mView;
+
+    VBoxVHWASurfList *mConstructingList;
+    int32_t mcRemaining2Contruct;
 
 #ifdef VBOX_WITH_VIDEOHWACCEL
@@ -1090 +1309 @@
     STDMETHOD(NotifyUpdate) (ULONG aX, ULONG aY,
                              ULONG aW, ULONG aH);
+#ifdef VBOXQGL_PROF_BASE
+    STDMETHOD(RequestResize) (ULONG aScreenId, ULONG aPixelFormat,
+                              BYTE *aVRAM, ULONG aBitsPerPixel, ULONG aBytesPerLine,
+                              ULONG aWidth, ULONG aHeight,
+                              BOOL *aFinished);
+#endif
 
 #ifdef VBOX_WITH_VIDEOHWACCEL
@@ -1104 +1329 @@
     void paintEvent (QPaintEvent *pe);
     void resizeEvent (VBoxResizeEvent *re);
-#ifdef VBOX_WITH_VIDEOHWACCEL
-    void doProcessVHWACommand(struct _VBOXVHWACMD * pCommand);
-#endif
+    void doProcessVHWACommand(VBoxVHWACommandProcessEvent * pEvent);
 
 private:

trunk/src/VBox/Frontends/VirtualBox/src/VBoxConsoleView.cpp

@@ -772 +772 @@
     setFrameStyle (QFrame::NoFrame);
 
-#ifndef VBOX_WITH_VIDEOHWACCEL
+#ifdef VBOX_GUI_USE_QGL
+    QWidget *pViewport;
+    switch (mode)
+    {
+        case VBoxDefs::QGLMode:
+            pViewport = new VBoxGLWidget (this, this);
+            break;
+        default:
+            pViewport = new VBoxViewport (this);
+    }
+#else
     VBoxViewport *pViewport = new VBoxViewport (this);
-#else
-//    /* TODO: temporary always use VBoxGLWidget for debugging */
-    VBoxGLWidget *pViewport = new VBoxGLWidget (this);
 #endif
     setViewport (pViewport);
@@ -1325 +1332 @@
                 return true;
             }
+
+#ifdef VBOX_GUI_USE_QGL
+            case VBoxDefs::VHWACommandProcessType:
+            {
+                VBoxVHWACommandProcessEvent *cmde = (VBoxVHWACommandProcessEvent *)e;
+                mFrameBuf->doProcessVHWACommand(cmde);
+                return true;
+            }
+#endif
 
             case VBoxDefs::SetRegionEventType:
@@ -1689 +1705 @@
             }
 #endif
-#ifdef VBOX_WITH_VIDEOHWACCEL
-            case VBoxDefs::VHWACommandProcessType:
-            {
-                VBoxVHWACommandProcessEvent *cmde = (VBoxVHWACommandProcessEvent *)e;
-                mFrameBuf->doProcessVHWACommand(cmde->command());
-                return true;
-            }
-#endif
             default:
                 break;

trunk/src/VBox/Frontends/VirtualBox/src/VBoxFrameBuffer.cpp

@@ -30 +30 @@
 #include <QPainter>
 
-#ifdef VBOX_WITH_VIDEOHWACCEL
-#include <VBox/VBoxVideo.h>
-#endif
-
 //
 // VBoxFrameBuffer class
@@ -272 +268 @@
 }
 
-#ifdef VBOX_WITH_VIDEOHWACCEL
-void VBoxFrameBuffer::doProcessVHWACommand(struct _VBOXVHWACMD * pCommand)
-{
-    pCommand->rc = VERR_NOT_IMPLEMENTED;
-    CDisplay display = mView->console().GetDisplay();
-    Assert (!display.isNull());
-
-    display.CompleteVHWACommand((BYTE*)pCommand);
+#ifdef VBOX_GUI_USE_QGL
+void VBoxFrameBuffer::doProcessVHWACommand(VBoxVHWACommandProcessEvent * pEvent)
+{
+//    pCommand->rc = VERR_NOT_IMPLEMENTED;
+//    CDisplay display = mView->console().GetDisplay();
+//    Assert (!display.isNull());
+//
+//    display.CompleteVHWACommand((BYTE*)pCommand);
 }
 #endif