Changeset 20653 in vbox

Timestamp:

Jun 17, 2009 9:26:02 AM (16 years ago)

Author:

vboxsync

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

48745

Message:

video hw accel: fixes for basic ddraw op hanlding

Location:

trunk

Files:

• include/VBox/VBoxVideo.h (modified) (7 diffs)
• src/VBox/Additions/WINNT/Graphics/Display/dd.c (modified) (18 diffs)
• src/VBox/Additions/WINNT/Graphics/Display/driver.h (modified) (3 diffs)
• src/VBox/Additions/WINNT/Graphics/Display/enable.c (modified) (40 diffs)
• src/VBox/Additions/WINNT/Graphics/Display/screen.c (modified) (1 diff)
• src/VBox/Additions/WINNT/Graphics/Display/vbox.c (modified) (7 diffs)
• src/VBox/Frontends/VirtualBox/include/VBoxFrameBuffer.h (modified) (12 diffs)

trunk/include/VBox/VBoxVideo.h

@@ -264 +264 @@
     VBOXVHWACMD_TYPE_SURF_BLT,
     VBOXVHWACMD_TYPE_QUERY_INFO1,
-    VBOXVHWACMD_TYPE_QUERY_INFO2
+    VBOXVHWACMD_TYPE_QUERY_INFO2,
+    VBOXVHWACMD_TYPE_ENABLE,
+    VBOXVHWACMD_TYPE_DISABLE
 } VBOXVHWACMD_TYPE;
 
@@ -282 +284 @@
     uint64_t GuestVBVAReserved1; /* field internally used by the guest VBVA cmd handling, must NOT be modified by clients */
     uint64_t GuestVBVAReserved2; /* field internally used by the guest VBVA cmd handling, must NOT be modified by clients */
+    union
+    {
+        struct _VBOXVHWACMD *pNext;
+        uint32_t             offNext;
+        uint64_t Data; /* the body is 64-bit aligned */
+    } u;
     char body[1];
 } VBOXVHWACMD;
@@ -372 +380 @@
 #define VBOXVHWA_PF_FOURCC              0x00000010
 
+#define VBOXVHWA_LOCK_DISCARDCONTENTS   0x00000001
+
 #define VBOXVHWA_CFG_ENABLED          0x00000001
+
+#define VBOXVHWA_OFFSET64_VOID        (~0L)
 
 typedef struct _VBOXVHWACMD_QUERYINFO1
@@ -417 +429 @@
         {
             VBOXVHWA_SURFINFO SurfInfo;
+            uint64_t offSurface;
         } in;
 
@@ -444 +457 @@
         {
             VBOXVHWA_SURFHANDLE hSurf;
+            uint64_t offSurface;
             uint32_t flags;
-            uint32_t Reserved;
+            uint32_t rectValid;
             VBOXVHWA_RECTL rect;
         } in;
@@ -471 +485 @@
         {
             VBOXVHWA_SURFHANDLE hDstSurf;
+            uint64_t offDstSurface;
             VBOXVHWA_RECTL dstRect;
             VBOXVHWA_SURFHANDLE hSrcSurf;
+            uint64_t offSrcSurface;
             VBOXVHWA_RECTL srcRect;
             uint32_t flags;
@@ -558 +574 @@
     {
         struct _VBVAHOSTCMD *pNext;
-        uint64_t Data; /* the body is 64-bit alligned */
+        uint32_t             offNext;
+        uint64_t Data; /* the body is 64-bit aligned */
     } u;
     char body[1];

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

@@ -42 +42 @@
 
 #ifdef VBOX_WITH_VIDEOHWACCEL
+#include <iprt/asm.h>
+
 #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);
+
 #endif
 
@@ -228 +233 @@
 #endif
 
-#if 0 /* not mandatory */
-    /* DX5 and up */
-    pHalInfo->GetDriverInfo = DdGetDriverInfo;
-    pHalInfo->dwFlags |= DDHALINFO_GETDRIVERINFOSET;
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    if(pDev->vhwaInfo.bVHWAEnabled)
+    {
+        /* we need it to set DDHAL_PRIVATECAP_NOTIFYPRIMARYCREATION to make ddraw call us for primary surface creation */
+        /* DX5 and up */
+        pHalInfo->GetDriverInfo = DdGetDriverInfo;
+        pHalInfo->dwFlags |= DDHALINFO_GETDRIVERINFOSET;
+    }
 #endif
 
@@ -436 +445 @@
         memset(&DDPrivateDriverCaps, 0, sizeof(DDPrivateDriverCaps));
         DDPrivateDriverCaps.dwSize=sizeof(DDPrivateDriverCaps);
-
+#ifndef VBOX_WITH_VIDEOHWACCEL
         DDPrivateDriverCaps.dwPrivateCaps = 0; /* DDHAL_PRIVATECAP_NOTIFYPRIMARYCREATION -> call CreateSurface for the primary surface */
+#else
+        DDPrivateDriverCaps.dwPrivateCaps = DDHAL_PRIVATECAP_NOTIFYPRIMARYCREATION; /* -> call CreateSurface for the primary surface */
+#endif
 
         lpData->dwActualSize =sizeof(DDPrivateDriverCaps);
@@ -448 +460 @@
     if (IsEqualIID(&(lpData->guidInfo), &GUID_DDMoreSurfaceCaps))
     {
+#ifndef VBOX_WITH_VIDEOHWACCEL
         DD_MORESURFACECAPS DDMoreSurfaceCaps;
         DDSCAPSEX   ddsCapsEx, ddsCapsExAlt;
@@ -481 +494 @@
 
         lpData->ddRVal = DD_OK;
+#else
+        DISPDBG((0, " -> GUID_DDMoreSurfaceCaps\n"));
+#endif
     }
     else
@@ -495 +511 @@
     if (IsEqualIID(&lpData->guidInfo, &GUID_NTCallbacks))
     {
+#ifndef VBOX_WITH_VIDEOHWACCEL
         DD_NTCALLBACKS NtCallbacks;
 
@@ -514 +531 @@
 
         lpData->ddRVal = DD_OK;
+#else
+        DISPDBG((0, " -> GUID_NTCallbacks\n"));
+#endif
     }
     else
@@ -589 +609 @@
     lpSurfaceDesc                   = lpCreateSurface->lpDDSurfaceDesc;
 
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    if(pDev->vhwaInfo.bVHWAEnabled && lpSurfaceLocal->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
+    {
+        lBpp = pDev->ulBitCount;
+        lPitch = pDev->lDeltaScreen;
+    }
+    else
+#endif
+    {
     lpSurfaceGlobal->dwReserved1    = 0;
 
@@ -615 +644 @@
     lpSurfaceGlobal->dwBlockSizeY   = lpSurfaceGlobal->wHeight;
     lpSurfaceGlobal->lPitch         = lPitch;
+
+    lpSurfaceDesc->lPitch   = lpSurfaceGlobal->lPitch;
+    lpSurfaceDesc->dwFlags |= DDSD_PITCH;
+    }
 
     //
@@ -631 +664 @@
     }
 
-    lpSurfaceDesc->lPitch   = lpSurfaceGlobal->lPitch;
-    lpSurfaceDesc->dwFlags |= DDSD_PITCH;
-
 #ifdef VBOX_WITH_VIDEOHWACCEL
-    vboxVHWASurfCreate(pDev, lpCreateSurface);
-#endif
-
+    if(pDev->vhwaInfo.bVHWAEnabled)
+    {
+        VBOXVHWACMD* pCmd = vboxVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_CREATE, sizeof(VBOXVHWACMD_SURF_CREATE));
+        if(pCmd)
+        {
+            VBOXVHWACMD_SURF_CREATE * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_CREATE);
+            PVBOXVHWASURFDESC pDesc;
+            memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_CREATE));
+
+            pBody->u.in.SurfInfo.surfCaps = vboxVHWAFromDDSCAPS(lpSurfaceLocal->ddsCaps.dwCaps);
+
+            pBody->u.in.SurfInfo.height = lpSurfaceGlobal->wHeight;
+            pBody->u.in.SurfInfo.width = lpSurfaceGlobal->wWidth;
+
+            vboxVHWAFromDDPIXELFORMAT(&pBody->u.in.SurfInfo.PixelFormat, &lpSurfaceGlobal->ddpfSurface);
+
+            if (lpSurfaceLocal->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
+            {
+                pBody->u.in.offSurface = 0;
+            }
+            else
+            {
+                pBody->u.in.offSurface = VBOXVHWA_OFFSET64_VOID;
+            }
+
+
+            pDesc = vboxVHWASurfDescAlloc();
+            if(pDesc)
+            {
+                pDesc->cBitsPerPixel = lBpp;
+                vboxVHWACommandSubmit(pDev, pCmd);
+                if(pCmd->rc == VINF_SUCCESS)
+                {
+                    pDesc->hHostHandle = pBody->u.out.hSurf;
+                    lpSurfaceGlobal->dwReserved1 = (ULONG_PTR)pDesc;
+                    lpCreateSurface->ddRVal = DD_OK;
+                }
+                else
+                {
+                    vboxVHWASurfDescFree(pDesc);
+                    lpCreateSurface->ddRVal = DDERR_GENERIC;
+                }
+            }
+            vboxVHWACommandFree(pDev, pCmd);
+        }
+    }
+#endif
     return DDHAL_DRIVER_NOTHANDLED;
 }
@@ -680 +754 @@
     }
 
-#ifndef VBOX_WITH_VIDEOHWACCEL
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    if(pDev->vhwaInfo.bVHWAEnabled)
+    {
+        VBOXVHWACMD* pCmd;
+        uint32_t unsupportedSCaps = vboxVHWAUnsupportedDDSCAPS(lpDDS->ddsCaps.dwCaps);
+        if(unsupportedSCaps)
+        {
+            VHWADBG(("vboxVHWASurfCanCreate: unsupported ddscaps: 0x%x", unsupportedSCaps));
+            lpCanCreateSurface->ddRVal = DDERR_INVALIDCAPS;
+            return DDHAL_DRIVER_HANDLED;
+        }
+
+        unsupportedSCaps = vboxVHWAUnsupportedDDPFS(lpDDS->ddpfPixelFormat.dwFlags);
+        if(unsupportedSCaps)
+        {
+            VHWADBG(("vboxVHWASurfCanCreate: unsupported pixel format: 0x%x", unsupportedSCaps));
+            lpCanCreateSurface->ddRVal = DDERR_INVALIDPIXELFORMAT;
+            return DDHAL_DRIVER_HANDLED;
+        }
+
+        pCmd = vboxVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_CANCREATE, sizeof(VBOXVHWACMD_SURF_CANCREATE));
+        if(pCmd)
+        {
+            VBOXVHWACMD_SURF_CANCREATE * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_CANCREATE);
+            memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_CANCREATE));
+
+            pBody->u.in.SurfInfo.surfCaps = vboxVHWAFromDDSCAPS(lpDDS->ddsCaps.dwCaps);
+
+            pBody->u.in.SurfInfo.height = lpDDS->dwHeight;
+            pBody->u.in.SurfInfo.width = lpDDS->dwWidth;
+            vboxVHWAFromDDPIXELFORMAT(&pBody->u.in.SurfInfo.PixelFormat, &lpDDS->ddpfPixelFormat);
+
+            vboxVHWACommandSubmit(pDev, pCmd);
+            Assert(pCmd->rc == VINF_SUCCESS);
+            if(pCmd->rc == VINF_SUCCESS)
+            {
+                if(pBody->u.out.ErrInfo)
+                {
+                    lpCanCreateSurface->ddRVal = DDERR_GENERIC;
+                }
+                else
+                {
+                    lpCanCreateSurface->ddRVal = DD_OK;
+                }
+            }
+            else
+            {
+                lpCanCreateSurface->ddRVal = DDERR_GENERIC;
+            }
+            vboxVHWACommandFree(pDev, pCmd);
+        }
+        else
+        {
+            lpCanCreateSurface->ddRVal = DDERR_GENERIC;
+        }
+        return DDHAL_DRIVER_HANDLED;
+    }
+#endif
     if (lpCanCreateSurface->bIsDifferentPixelFormat && (lpDDS->ddpfPixelFormat.dwFlags & DDPF_FOURCC))
     {
@@ -687 +818 @@
         return DDHAL_DRIVER_HANDLED;
     }
+
     lpCanCreateSurface->ddRVal = DD_OK;
-#else
-    vboxVHWASurfCanCreate(pDev, lpCanCreateSurface);
-#endif
-
     return DDHAL_DRIVER_HANDLED;
 }
@@ -830 +958 @@
 {
     PPDEV pDev = (PPDEV)lpLock->lpDD->dhpdev;
-
-    PDD_SURFACE_LOCAL lpSurfaceLocal = lpLock->lpDDSurface;
+    DD_SURFACE_LOCAL*   lpSurfaceLocal = lpLock->lpDDSurface;
 
     DISPDBG((0, "%s: %p bHasRect = %d fpProcess = %p\n", __FUNCTION__, pDev, lpLock->bHasRect, lpLock->fpProcess));
 
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    if(pDev->vhwaInfo.bVHWAEnabled)
+    {
+        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))
+        {
+            if(ASMAtomicUoReadU32(&pDesc->cPendingBltsSrc)
+                    || ASMAtomicUoReadU32(&pDesc->cPendingBltsDst)
+                    || ASMAtomicUoReadU32(&pDesc->cPendingFlips))
+            {
+                lpLock->ddRVal = DDERR_WASSTILLDRAWING;
+                return DDHAL_DRIVER_HANDLED;
+            }
+        }
+
+        if(VBOXDD_CHECKFLAG(lpLock->dwFlags, DDLOCK_SURFACEMEMORYPTR))
+        {
+            lpLock->lpSurfData = (LPVOID)(lpSurfaceGlobal->fpVidMem + lpSurfaceGlobal->lPitch * lpLock->rArea.top
+                + lpLock->rArea.left * pDesc->cBitsPerPixel/8);
+        }
+
+        pCmd = vboxVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_LOCK, sizeof(VBOXVHWACMD_SURF_LOCK));
+        if(pCmd)
+        {
+            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;
+            }
+
+            pBody->u.in.hSurf = pDesc->hHostHandle;
+
+            if(VBOXDD_CHECKFLAG(lpLock->dwFlags, DDLOCK_DISCARDCONTENTS))
+            {
+                pBody->u.in.flags |= VBOXVHWA_LOCK_DISCARDCONTENTS;
+                /* we're not interested in completion, just send the command */
+                vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
+            }
+            else
+            {
+                /* wait for the surface to be locked and memory buffer updated */
+                vboxVHWACommandSubmit(pDev, pCmd);
+                vboxVHWACommandFree(pDev, pCmd);
+            }
+
+            lpLock->ddRVal = DD_OK;
+        }
+        else
+        {
+            lpLock->ddRVal = DDERR_GENERIC;
+        }
+        return DDHAL_DRIVER_HANDLED;
+    }
+#endif
     if (lpSurfaceLocal->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
     {
@@ -887 +1083 @@
     PPDEV pDev = (PPDEV)lpUnlock->lpDD->dhpdev;
     DISPDBG((0, "%s: %p\n", __FUNCTION__, pDev));
-
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    if (pDev->vhwaInfo.bVHWAEnabled)
+    {
+        DD_SURFACE_LOCAL*   lpSurfaceLocal = lpUnlock->lpDDSurface;
+        DD_SURFACE_GLOBAL*  lpSurfaceGlobal = lpSurfaceLocal->lpGbl;
+        PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC)lpSurfaceGlobal->dwReserved1;
+        VBOXVHWACMD* pCmd;
+
+        //TODO: hadle vrdp properly
+        if (  pDev->pVBVA->u32HostEvents
+            & VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET)
+        {
+            vrdpReset (pDev);
+
+            pDev->pVBVA->u32HostEvents &=
+                      ~VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET;
+        }
+
+        /* 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;
+        }
+
+        return DDHAL_DRIVER_HANDLED;
+    }
+#endif
     if (pDev->ddLock.bLocked)
     {
@@ -964 +1201 @@
 DWORD APIENTRY DdDestroySurface(PDD_DESTROYSURFACEDATA lpDestroySurface)
 {
+#ifdef VBOX_WITH_VIDEOHWACCEL
     PPDEV pDev = (PPDEV)lpDestroySurface->lpDD->dhpdev;
-    DISPDBG((0, "%s: %p\n", __FUNCTION__, pDev));
-
-#ifdef VBOX_WITH_VIDEOHWACCEL
-    vboxVHWASurfDestroy(pDev, lpDestroySurface);
-#else
-    lpDestroySurface->ddRVal = DD_OK;
-#endif
+    if(pDev->vhwaInfo.bVHWAEnabled)
+    {
+        DD_SURFACE_LOCAL*   lpSurfaceLocal = lpDestroySurface->lpDDSurface;
+        DD_SURFACE_GLOBAL*  lpSurfaceGlobal = lpSurfaceLocal->lpGbl;
+        VBOXVHWACMD* pCmd;
+
+        DISPDBG((0, "%s: %p\n", __FUNCTION__, pDev));
+
+        pCmd = vboxVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_DESTROY, sizeof(VBOXVHWACMD_SURF_DESTROY));
+    //    int rc = VERR_GENERAL_FAILURE;
+        if(pCmd)
+        {
+            VBOXVHWACMD_SURF_DESTROY * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_DESTROY);
+            PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC)lpSurfaceGlobal->dwReserved1;
+
+            memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_DESTROY));
+
+            pBody->u.in.hSurf = pDesc->hHostHandle;
+
+            /* we're not interested in completion, just send the command */
+            vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
+
+            vboxVHWASurfDescFree(pDesc);
+
+            lpDestroySurface->ddRVal = DD_OK;
+        }
+        else
+        {
+            lpDestroySurface->ddRVal = DDERR_GENERIC;
+        }
+    }
+    else
+#endif
+        lpDestroySurface->ddRVal = DD_OK;
     return DDHAL_DRIVER_HANDLED;
 }
@@ -1072 +1337 @@
 DWORD APIENTRY DdBlt(PDD_BLTDATA  lpBlt)
 {
+#ifdef VBOX_WITH_VIDEOHWACCEL
     PPDEV pDev = (PPDEV)lpBlt->lpDD->dhpdev;
     DISPDBG((0, "%s\n", __FUNCTION__));
-    vboxVHWASurfBlt(pDev, lpBlt);
+#if DX9_DDI
+    if(VBOXDD_CHECKFLAG(lpBlt->dwFlags, DDBLT_EXTENDED_PRESENTATION_STRETCHFACTOR))
+    {
+        lpBlt->ddRVal = DD_OK;
+    }
+    else
+#endif
+    {
+        DD_SURFACE_LOCAL*   lpDestSurfaceLocal = lpBlt->lpDDDestSurface;
+        DD_SURFACE_GLOBAL*  lpDestSurfaceGlobal = lpDestSurfaceLocal->lpGbl;
+        DD_SURFACE_LOCAL*   lpSrcSurfaceLocal = lpBlt->lpDDSrcSurface;
+        DD_SURFACE_GLOBAL*  lpSrcSurfaceGlobal = lpSrcSurfaceLocal->lpGbl;
+        VBOXVHWACMD* pCmd = vboxVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_BLT, sizeof(VBOXVHWACMD_SURF_BLT));
+    //    int rc = VERR_GENERAL_FAILURE;
+        if(pCmd)
+        {
+            VBOXVHWACMD_SURF_BLT * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_BLT);
+            PVBOXVHWASURFDESC pSrcDesc = (PVBOXVHWASURFDESC)lpSrcSurfaceGlobal->dwReserved1;
+            PVBOXVHWASURFDESC pDestDesc = (PVBOXVHWASURFDESC)lpDestSurfaceGlobal->dwReserved1;
+            memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_BLT));
+
+            pBody->u.in.offSrcSurface = (uint64_t)lpSrcSurfaceGlobal->fpVidMem;
+            pBody->u.in.offDstSurface = (uint64_t)lpDestSurfaceGlobal->fpVidMem;
+
+            pBody->u.in.hDstSurf = pDestDesc->hHostHandle;
+            vboxVHWAFromRECTL(&pBody->u.in.dstRect, &lpBlt->rDest);
+            pBody->u.in.hSrcSurf = pSrcDesc->hHostHandle;
+            vboxVHWAFromRECTL(&pBody->u.in.srcRect, &lpBlt->rSrc);
+            pBody->DstGuestSurfInfo = (uint64_t)pDestDesc;
+            pBody->SrcGuestSurfInfo = (uint64_t)pSrcDesc;
+
+            ASMAtomicIncU32(&pSrcDesc->cPendingBltsSrc);
+            ASMAtomicIncU32(&pDestDesc->cPendingBltsDst);
+
+//            if(VBOXDD_CHECKFLAG(lpBlt->dwFlags, DDBLT_ASYNC))
+//            {
+                vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWASurfBltCompletion, NULL);
+//            }
+//            else
+//            {
+//                vboxVHWACommandSubmit(pDev, pCmd);
+//            }
+            lpBlt->ddRVal = DD_OK;
+        }
+        else
+        {
+            lpBlt->ddRVal = DDERR_GENERIC;
+        }
+    }
+
     return DDHAL_DRIVER_HANDLED;
+#else
+    lpBlt->ddRVal = DDERR_GENERIC;
+    return DDHAL_DRIVER_NOTHANDLED;
+#endif
 }
 
@@ -1207 +1526 @@
 static DWORD rops[DD_ROP_SPACE] = { 0 };
 
-bool
+static bool
 getDDHALInfo(
     PPDEV pDev,
@@ -1527 +1846 @@
 } // getDDHALInfo
 
+static DECLCALLBACK(void) vboxVHWAFreeCmdCompletion(PPDEV ppdev, VBOXVHWACMD * pCmd, void * pContext)
+{
+    vboxVHWACommandFree(ppdev, pCmd);
+}
+
+static DECLCALLBACK(void) vboxVHWASurfBltCompletion(PPDEV ppdev, VBOXVHWACMD * pCmd, void * pContext)
+{
+    VBOXVHWACMD_SURF_BLT * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_BLT);
+    PVBOXVHWASURFDESC pSrcDesc = (PVBOXVHWASURFDESC)pBody->SrcGuestSurfInfo;
+    PVBOXVHWASURFDESC pDestDesc = (PVBOXVHWASURFDESC)pBody->DstGuestSurfInfo;
+
+    ASMAtomicDecU32(&pSrcDesc->cPendingBltsSrc);
+    ASMAtomicDecU32(&pDestDesc->cPendingBltsDst);
+
+    vboxVHWACommandFree(ppdev, pCmd);
+}
 
 #endif

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

@@ -101 +101 @@
     volatile uint32_t cPendingBltsDst;
     volatile uint32_t cPendingFlips;
+    uint32_t cBitsPerPixel;
 }VBOXVHWASURFDESC, *PVBOXVHWASURFDESC;
 
@@ -280 +281 @@
  #ifdef VBOX_WITH_VIDEOHWACCEL
 
+#define VBOXDD_CHECKFLAG(_v, _f) ((_v) & (_f)) == (_f)
+
 typedef DECLCALLBACK(void) FNVBOXVHWACMDCOMPLETION(PPDEV ppdev, VBOXVHWACMD * pCmd, void * pContext);
 typedef FNVBOXVHWACMDCOMPLETION *PFNVBOXVHWACMDCOMPLETION;
 
-VBOXVHWACMD* vboxVHWACommandCreate (PPDEV ppdev, VBOXVHWACMD_LENGTH cbCmd);
+VBOXVHWACMD* vboxVHWACommandCreate (PPDEV ppdev, VBOXVHWACMD_TYPE enmCmd, VBOXVHWACMD_LENGTH cbCmd);
 void vboxVHWACommandFree (PPDEV ppdev, VBOXVHWACMD* pCmd);
 BOOL vboxVHWACommandSubmit (PPDEV ppdev, VBOXVHWACMD* pCmd);
@@ -300 +303 @@
 void vboxVHWAInit();
 void vboxVHWATerm();
-void vboxVHWASurfCanCreate(PPDEV ppdev, PDD_CANCREATESURFACEDATA  lpCanCreateSurface);
-void vboxVHWASurfCreate(PPDEV ppdev, PDD_CREATESURFACEDATA  lpCreateSurface);
-void vboxVHWASurfDestroy(PPDEV ppdev, PDD_DESTROYSURFACEDATA  lpDestroySurface);
-void vboxVHWASurfBlt(PPDEV ppdev, PDD_BLTDATA  lpBlt);
+uint32_t vboxVHWAUnsupportedDDCAPS(uint32_t caps);
+uint32_t vboxVHWAUnsupportedDDSCAPS(uint32_t caps);
+uint32_t vboxVHWAUnsupportedDDPFS(uint32_t caps);
+uint32_t vboxVHWASupportedDDCAPS(uint32_t caps);
+uint32_t vboxVHWASupportedDDSCAPS(uint32_t caps);
+uint32_t vboxVHWASupportedDDPFS(uint32_t caps);
+uint32_t vboxVHWAFromDDCAPS(uint32_t caps);
+uint32_t vboxVHWAToDDCAPS(uint32_t caps);
+uint32_t vboxVHWAFromDDSCAPS(uint32_t caps);
+uint32_t vboxVHWAToDDSCAPS(uint32_t caps);
+uint32_t vboxVHWAFromDDPFS(uint32_t caps);
+uint32_t vboxVHWAToDDPFS(uint32_t caps);
+void vboxVHWAFromDDPIXELFORMAT(VBOXVHWA_PIXELFORMAT *pVHWAFormat, DDPIXELFORMAT *pDdFormat);
+void vboxVHWAFromRECTL(VBOXVHWA_RECTL *pDst, RECTL *pSrc);
+PVBOXVHWASURFDESC vboxVHWASurfDescAlloc();
+void vboxVHWASurfDescFree(PVBOXVHWASURFDESC pDesc);
+
+int vboxVHWAEnable(PPDEV ppdev);
+int vboxVHWADisable(PPDEV ppdev);
+
  #endif
 #endif

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

@@ -101 +101 @@
     case OPENGL_GETINFO:
     {
-        if (    cjOut >= sizeof(OPENGL_INFO) 
-            &&  pvOut) 
-        { 
-            POPENGL_INFO pInfo = (POPENGL_INFO)pvOut; 
-
-            pInfo->dwVersion        = 2; 
-            pInfo->dwDriverVersion  = 1; 
-            pInfo->szDriverName[0]  = 'V'; 
-            pInfo->szDriverName[1]  = 'B'; 
-            pInfo->szDriverName[2]  = 'o'; 
-            pInfo->szDriverName[3]  = 'x'; 
-            pInfo->szDriverName[4]  = 'O'; 
-            pInfo->szDriverName[5]  = 'G'; 
-            pInfo->szDriverName[6]  = 'L'; 
-            pInfo->szDriverName[7]  = 0; 
-
-            DISPDBG((0, "OPENGL_GETINFO\n")); 
-            return cjOut; 
-        } 
-        else 
+        if (    cjOut >= sizeof(OPENGL_INFO)
+            &&  pvOut)
+        {
+            POPENGL_INFO pInfo = (POPENGL_INFO)pvOut;
+
+            pInfo->dwVersion        = 2;
+            pInfo->dwDriverVersion  = 1;
+            pInfo->szDriverName[0]  = 'V';
+            pInfo->szDriverName[1]  = 'B';
+            pInfo->szDriverName[2]  = 'o';
+            pInfo->szDriverName[3]  = 'x';
+            pInfo->szDriverName[4]  = 'O';
+            pInfo->szDriverName[5]  = 'G';
+            pInfo->szDriverName[6]  = 'L';
+            pInfo->szDriverName[7]  = 0;
+
+            DISPDBG((0, "OPENGL_GETINFO\n"));
+            return cjOut;
+        }
+        else
             DISPDBG((0, "OPENGL_GETINFO invalid size %d\n", cjOut));         /* It doesn't matter that we fail here. Opengl32 will fall back to software rendering when this escape is not supported. */
         break;
@@ -238 +238 @@
     return 0;
 }
-    
+
 BOOL DrvConnect (PVOID x1, PVOID x2, PVOID x3, PVOID x4)
 {
@@ -318 +318 @@
 //     {   0x50,                           (PFN) DrvShadowConnect      },       // 0x50
 //     {   0x51,                           (PFN) DrvShadowDisconnect   },       // 0x51
-    
+
 };
 
@@ -443 +443 @@
 
     DISPDBG((0, "VBoxDisp::DrvEnablePDEV called\n"));
-    
+
     UNREFERENCED_PARAMETER(pwszLogAddress);
     UNREFERENCED_PARAMETER(pwszDeviceName);
-    
+
     RtlZeroMemory(&DevInfo, sizeof (DEVINFO));
     RtlZeroMemory(&GdiInfo, sizeof (GDIINFO));
@@ -465 +465 @@
 
     ppdev->hDriver = hDriver;
-    
+
     // Get the current screen mode information.  Set up device caps and devinfo.
 
@@ -481 +481 @@
         DISPDBG((0, "DrvEnablePDEV failed bInitPointer\n"));
     }
-    
+
     // Initialize palette information.
 
@@ -489 +489 @@
         goto error_free;
     }
-    
+
 //    // Start a thread that will process notifications from VMMDev
 //    if (!bInitNotificationThread(ppdev))
@@ -496 +496 @@
 //        goto error_free;
 //    }
-    
+
     // Copy the devinfo into the engine buffer.
-    
+
     DISPDBG((0, "VBoxDisp::DrvEnablePDEV: sizeof(DEVINFO) = %d, cjDevInfo = %d, alpha = %d\n", sizeof(DEVINFO), cjDevInfo, DevInfo.flGraphicsCaps2 & GCAPS2_ALPHACURSOR));
-    
+
 // @todo seems to be not necessary. these bits are initialized in screen.c    DevInfo.flGraphicsCaps |= GCAPS_OPAQUERECT       |
 //                              GCAPS_DITHERONREALIZE  |
@@ -509 +509 @@
 //                              GCAPS_COLOR_DITHER     |
 //                              GCAPS_ASYNCMOVE;
-//                              
+//
 //    DevInfo.flGraphicsCaps |= GCAPS_DITHERONREALIZE;
-    
+
     DevInfo.flGraphicsCaps2 |= GCAPS2_RESERVED1; /* @todo figure out what is this. */
 
@@ -522 +522 @@
 
     DISPDBG((0, "VBoxDisp::DrvEnablePDEV completed %x\n", ppdev));
-    
+
     return((DHPDEV) ppdev);
 
@@ -557 +557 @@
 //    vStopNotificationThread ((PPDEV) dhpdev);
     vDisablePalette((PPDEV) dhpdev);
-    
+
     /* Free the driver's VBVA resources. */
     vboxVbvaDisable ((PPDEV) dhpdev);
@@ -615 +615 @@
 #endif
     DISPDBG((0, "DISP DrvEnableSurface called\n"));
-        
+
     // Create engine bitmap around frame buffer.
 
@@ -630 +630 @@
 
     DISPDBG((0, "DISP DrvEnableSurface bInitSURF success\n"));
-    
+
     sizl.cx = ppdev->cxScreen;
     sizl.cy = ppdev->cyScreen;
@@ -690 +690 @@
                                               ulBitmapType);
     }
- 
+
     if ( hsurf == 0 )
     {
@@ -701 +701 @@
     // GDI. We cant do this on NT4.0 hence we call EngAssociateSurface.
     //
-     
+
     if(g_bOnNT40)
     {
@@ -707 +707 @@
         // We have to associate the surface we just created with our physical
         // device so that GDI can get information related to the PDEV when
-        // it's drawing to the surface (such as, for example, the length of 
+        // it's drawing to the surface (such as, for example, the length of
         // styles on the device when simulating styled lines).
         //
@@ -720 +720 @@
         {
             DISPDBG((0, "DrvEnableSurface: failed EngAssociateSurface\n"));
-            goto l_Failure; 
+            goto l_Failure;
         }
 
@@ -726 +726 @@
         // Jam in the value of dhsurf into screen SURFOBJ. We do this to
         // make sure the driver acclerates Drv calls we hook and not
-        // punt them back to GDI as the SURFOBJ's dhsurf = 0. 
+        // punt them back to GDI as the SURFOBJ's dhsurf = 0.
         //
         ppdev->psoScreenBitmap = EngLockSurface(hsurf);
@@ -732 +732 @@
         {
             DISPDBG((0, "DrvEnableSurface: failed EngLockSurface\n"));
-            goto l_Failure; 
+            goto l_Failure;
         }
 
@@ -767 +767 @@
                                     (ppdev->lDeltaScreen > 0) ? BMF_TOPDOWN : 0,
                                     (PVOID) (ppdev->pjScreen));
-                                     
+
     if (hsurf == (HSURF) 0)
     {
@@ -776 +776 @@
     {
         ppdev->hsurfScreenBitmap = hsurf;
-         
+
         if (!EngAssociateSurface(hsurf, ppdev->hdevEng, 0))
         {
@@ -785 +785 @@
         {
             SURFOBJ *pso = EngLockSurface(hsurf);
-             
+
             ppdev->psoScreenBitmap = pso;
-   
+
             hsurf = (HSURF) EngCreateDeviceSurface((DHSURF)pso,
                                                     sizl,
@@ -816 +816 @@
         }
     }
-#endif /* VBOX_NEW_SURFACE_CODE */    
+#endif /* VBOX_NEW_SURFACE_CODE */
     return ppdev->hsurfScreen;
-     
+
 l_Failure:
 
     DrvDisableSurface(dhpdev);
-    
+
     return((HSURF)0);
 }
@@ -836 +836 @@
 {
     PPDEV ppdev = (PPDEV)dhpdev;
-    
+
     DISPDBG((0, "VBoxDisp::DrvDisableSurface called\n"));
     if (ppdev->psoScreenBitmap)
@@ -861 +861 @@
         ppdev->hsurfScreenBitmap = (HSURF)0;
     }
-#endif    
+#endif
+
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    /* tells we can not process host commands any more and ensures we've completed processing of the host VHWA commands */
+    vboxVHWADisable(ppdev);
+#endif
     vDisableSURF(ppdev);
 }
@@ -879 +884 @@
 
     DISPDBG((0, "DISP DrvAssertMode called bEnable = %d\n", bEnable));
-    
+
     if (bEnable)
     {
@@ -898 +903 @@
             SIZEL sizl;
             SURFOBJ *pso;
-            
+
             DISPDBG((0, "DISP DrvAssertMode Screen pointer has changed!!!\n"));
-            
+
             sizl.cx = ppdev->cxScreen;
             sizl.cy = ppdev->cyScreen;
-            
+
             hsurf = (HSURF) EngCreateBitmap(sizl,
                                             ppdev->lDeltaScreen,
@@ -909 +914 @@
                                             (ppdev->lDeltaScreen > 0) ? BMF_TOPDOWN : 0,
                                             (PVOID) (ppdev->pjScreen));
-                                     
+
             if (hsurf == (HSURF) 0)
             {
@@ -915 +920 @@
                 return FALSE;
             }
-            
+
             pso = EngLockSurface(hsurf);
-             
+
             if (ppdev->psoScreenBitmap)
             {
@@ -929 +934 @@
                 ppdev->hsurfScreenBitmap = (HSURF)0;
             }
-    
+
             ppdev->hsurfScreenBitmap = hsurf;
             ppdev->psoScreenBitmap = pso;
@@ -939 +944 @@
             return FALSE;
         }
-            
+
         if (!EngAssociateSurface(ppdev->hsurfScreen, ppdev->hdevEng, ppdev->flHooks))
         {
@@ -945 +950 @@
             return FALSE;
         }
-            
+
         return TRUE;
     }
     else
     {
+#ifdef VBOX_WITH_VIDEOHWACCEL
+        /* tells we can not process host commands any more and ensures we've completed processing of the host VHWA commands */
+        vboxVHWADisable(ppdev);
+#endif
         //
         // We must give up the display.
@@ -987 +996 @@
 \******************************************************************************/
 
-HBITMAP 
+HBITMAP
 DrvCreateDeviceBitmap(
     DHPDEV      dhpdev,
@@ -1005 +1014 @@
 \******************************************************************************/
 
-VOID 
+VOID
 DrvDeleteDeviceBitmap(
     DHSURF      dhsurf)
@@ -1149 +1158 @@
             ppdev->ptlDevOrg = *(PPOINTL)pvData;
 #ifndef VBOX_WITH_HGSMI
-            DISPDBG((3, "DN_DEVICE_ORIGIN: %d, %d (PSO = %p, pInfo = %p)\n", ppdev->ptlDevOrg.x, 
+            DISPDBG((3, "DN_DEVICE_ORIGIN: %d, %d (PSO = %p, pInfo = %p)\n", ppdev->ptlDevOrg.x,
                      ppdev->ptlDevOrg.y, pso, ppdev->pInfo));
             if (ppdev->pInfo)
@@ -1158 +1167 @@
             }
 #else
-            DISPDBG((3, "DN_DEVICE_ORIGIN: %d, %d (PSO = %p)\n", ppdev->ptlDevOrg.x, 
+            DISPDBG((3, "DN_DEVICE_ORIGIN: %d, %d (PSO = %p)\n", ppdev->ptlDevOrg.x,
                      ppdev->ptlDevOrg.y, pso));
             VBoxProcessDisplayInfo(ppdev);
@@ -1179 +1188 @@
 // Parameters
 //  pDirectDraw-----Points to a DD_DIRECTDRAW_GLOBAL structure that describes
-//                  the DirectDraw object. 
+//                  the DirectDraw object.
 //  pSurface--------Points to a DD_SURFACE_LOCAL structure that describes the
 //                  DirectDraw surface around which to wrap a GDI surface.
@@ -1250 +1259 @@
     {
         SIZEL sizel;
-        DWORD ulBitmapType, flHooks;        
+        DWORD ulBitmapType, flHooks;
 
         sizel.cx = pSurfaceGlobal->wWidth;
@@ -1296 +1305 @@
                     SURFOBJ *surfobj = EngLockSurface ((HSURF)hbmDevice);
                     DISPDBG((0, "DrvDeriveSurface surfobj %x, hsurf = %x\n", surfobj, surfobj->hsurf));
-                
+
                     surfobj->dhpdev = (DHPDEV)pDev;
-                
+
                     EngUnlockSurface(surfobj);
 
@@ -1318 +1327 @@
     DISPDBG((0, "DrvDeriveSurface return NULL\n"));
     DISPDBG((0, "pSurfaceGlobal->ddpfSurface.dwRGBBitCount = %d, lPitch =%ld\n", pSurfaceGlobal->ddpfSurface.dwRGBBitCount,pSurfaceGlobal->lPitch));
-    
+
     return(0);
 }

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

@@ -535 +535 @@
 #endif /* VBOX_WITH_HGSMI */
 
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    /* tells we can process host commands */
+    vboxVHWAEnable(ppdev);
+#endif
+
     return(TRUE);
 }

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

@@ -692 +692 @@
 # ifdef VBOX_WITH_VIDEOHWACCEL
 
-VBOXVHWACMD* vboxVHWACommandCreate (PPDEV ppdev, VBOXVHWACMD_LENGTH cbCmd)
+VBOXVHWACMD* vboxVHWACommandCreate (PPDEV ppdev, VBOXVHWACMD_TYPE enmCmd, VBOXVHWACMD_LENGTH cbCmd)
 {
     VBOXVHWACMD* pHdr = (VBOXVHWACMD*)HGSMIHeapAlloc (&ppdev->hgsmiDisplayHeap,
@@ -702 +702 @@
         DISPDBG((0, "VBoxDISP::vboxVHWACommandCreate: HGSMIHeapAlloc failed\n"));
     }
+    else
+    {
+        memset(pHdr, 0, sizeof(VBOXVHWACMD));
+        pHdr->iDisplay = ppdev->iDevice;
+        pHdr->rc = VERR_GENERAL_FAILURE;
+        pHdr->enmCmd = enmCmd;
+    }
 
     /* temporary hack */
@@ -837 +844 @@
 VBOXVHWACMD_QUERYINFO1* vboxVHWAQueryHostInfo1(PPDEV ppdev)
 {
-    VBOXVHWACMD* pCmd = vboxVHWACommandCreate (ppdev, sizeof(VBOXVHWACMD_QUERYINFO1));
+    VBOXVHWACMD* pCmd = vboxVHWACommandCreate (ppdev, VBOXVHWACMD_TYPE_QUERY_INFO1, sizeof(VBOXVHWACMD_QUERYINFO1));
     if (!pCmd)
     {
@@ -844 +851 @@
     }
 
-    pCmd->enmCmd = VBOXVHWACMD_TYPE_QUERY_INFO1;
     if(vboxVHWACommandSubmit (ppdev, pCmd))
     {
@@ -859 +865 @@
 VBOXVHWACMD_QUERYINFO2* vboxVHWAQueryHostInfo2(PPDEV ppdev, uint32_t numFourCC)
 {
-    VBOXVHWACMD* pCmd = vboxVHWACommandCreate (ppdev, sizeof(VBOXVHWACMD_QUERYINFO2));
+    VBOXVHWACMD* pCmd = vboxVHWACommandCreate (ppdev, VBOXVHWACMD_TYPE_QUERY_INFO2, sizeof(VBOXVHWACMD_QUERYINFO2));
     VBOXVHWACMD_QUERYINFO2 *pInfo2;
     if (!pCmd)
@@ -867 +873 @@
     }
 
-    pCmd->enmCmd = VBOXVHWACMD_TYPE_QUERY_INFO2;
     pInfo2 = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO2);
     pInfo2->numFourCC = numFourCC;
@@ -930 +935 @@
 }
 
+int vboxVHWAEnable(PPDEV ppdev)
+{
+    int rc = VERR_GENERAL_FAILURE;
+    VBOXVHWACMD* pCmd = vboxVHWACommandCreate (ppdev, VBOXVHWACMD_TYPE_ENABLE, 0);
+    if (!pCmd)
+    {
+        DISPDBG((0, "VBoxDISP::vboxVHWAQueryHostInfo1: vboxVHWACommandCreate failed\n"));
+        return NULL;
+    }
+
+    if(vboxVHWACommandSubmit (ppdev, pCmd))
+    {
+        if(RT_SUCCESS(pCmd->rc))
+        {
+            rc = VINF_SUCCESS;
+        }
+    }
+
+    vboxVHWACommandFree (ppdev, pCmd);
+    return rc;
+}
+
+int vboxVHWADisable(PPDEV ppdev)
+{
+    int rc = VERR_GENERAL_FAILURE;
+    VBOXVHWACMD* pCmd = vboxVHWACommandCreate (ppdev, VBOXVHWACMD_TYPE_DISABLE, 0);
+    if (!pCmd)
+    {
+        DISPDBG((0, "VBoxDISP::vboxVHWAQueryHostInfo1: vboxVHWACommandCreate failed\n"));
+        return NULL;
+    }
+
+    if(vboxVHWACommandSubmit (ppdev, pCmd))
+    {
+        if(RT_SUCCESS(pCmd->rc))
+        {
+            rc = VINF_SUCCESS;
+        }
+    }
+
+    vboxVHWACommandFree (ppdev, pCmd);
+
+    vboxVHWACommandCheckHostCmds(ppdev);
+
+    return rc;
+}
 
 # endif

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

@@ -327 +327 @@
 public:
     VBoxVHWADirtyRect() :
-        mIsClear(false)
+        mIsClear(true)
     {}
 
@@ -343 +343 @@
     }
 
-    bool isClear() { return mIsClear; }
+    bool isClear() const { return mIsClear; }
 
     void add(const QRect & aRect)
@@ -363 +363 @@
         {
             mRect = aRect;
+            mIsClear = false;
         }
     }
@@ -368 +369 @@
     void clear() { mIsClear = true; }
 
-    const QRect & rect() {return mRect;}
-
-    bool intersects(const QRect & aRect) {return mIsClear ? false : mRect.intersects(aRect);}
+    const QRect & rect() const {return mRect;}
+
+    bool intersects(const QRect & aRect) const {return mIsClear ? false : mRect.intersects(aRect);}
+
+    bool intersects(const VBoxVHWADirtyRect & aRect) const {return mIsClear ? false : aRect.intersects(mRect);}
+
+    QRect united(const QRect & aRect) const {return mIsClear ? aRect : aRect.united(mRect);}
+
+    bool contains(const QRect & aRect) const {return mIsClear ? false : aRect.contains(mRect);}
+
+    void subst(const VBoxVHWADirtyRect & aRect) { if(!mIsClear && aRect.contains(mRect)) clear(); }
 
 private:
@@ -391 +400 @@
     static void globalInit();
 
-    int blt(const QRect * pDstRect, VBoxVHWASurfaceBase * pSrtSurface, const QRect * pSrcRect);
-
-    int lock(const QRect * pRect);
+    int blt(const QRect * aDstRect, VBoxVHWASurfaceBase * aSrtSurface, const QRect * aSrcRect);
+
+    int lock(const QRect * pRect, uint32_t flags);
 
     int unlock();
@@ -399 +408 @@
     virtual void makeCurrent() = 0;
 
-    void paint(const QRect * pRect);
+    void paint(const QRect * aRect);
 
     void performDisplay() { Assert(mDisplayInitialized); glCallList(mDisplay); }
@@ -407 +416 @@
     static GLsizei makePowerOf2(GLsizei val);
 
+    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 * mDisplayHeight; }
-
-    ulong width()  { return mDisplayWidth;  }
-    ulong height() { return mDisplayHeight; }
+    ulong   memSize(){ return mBytesPerLine * mRect.height(); }
+
+    ulong width()  { return mRect.width();  }
+    ulong height() { return mRect.height(); }
 
     GLenum format() {return mFormat; }
@@ -420 +430 @@
     ulong  bytesPerLine() { return mBytesPerLine; }
 
-    /* clients should treat the rerurned texture as read-only */
+    /* clients should treat the returned texture as read-only */
     GLuint textureSynched(const QRect * aRect) { synchTexture(aRect); return mTexture; }
 
+    void setAddress(uchar * addr);
+
+    const QRect& rect() {return mRect;}
+
+    virtual bool isPrimary() = 0;
 private:
     void initDisplay();
     void deleteDisplay();
-    void updateTexture(const QRect * pRect);
-    void synchTexture(const QRect * pRect);
-    void synchMem(const QRect * pRect);
+    void updateTexture(const QRect * aRect);
+    void synchTexture(const QRect * aRect);
+    void synchMem(const QRect * aRect);
+
+    QRect mRect;
 
     GLuint mDisplay;
@@ -439 +456 @@
     GLint  mInternalFormat;
     GLenum mType;
-    ulong  mDisplayWidth;
-    ulong  mDisplayHeight;
+//    ulong  mDisplayWidth;
+//    ulong  mDisplayHeight;
     ulong  mBytesPerPixel;
     ulong  mBytesPerLine;
 
-    VBoxVHWADirtyRect mLockedRect;
+    int mLockCount;
+    /* memory buffer not reflected in fm and texture, e.g if memory buffer is replaced or in case of lock/unlock  */
+    VBoxVHWADirtyRect mUpdateMemRect;
     /*in case of blit we blit from another surface's texture, so our current texture gets durty  */
     VBoxVHWADirtyRect mUpdateFB2TexRect;
-    /*in case of blit the memory buffer does not get updated until we need it, e.g. for pain or lock operations */
+    /*in case of blit the memory buffer does not get updated until we need it, e.g. for paint or lock operations */
     VBoxVHWADirtyRect mUpdateFB2MemRect;
 
@@ -464 +483 @@
     {}
 
+    bool isPrimary() {return true;}
     void makeCurrent();
 private:
@@ -536 +556 @@
     bool usesGuestVRAM() { return vboxWidget()->vboxUsesGuestVRAM(); }
 
-    uchar *address() { /*Assert(0); */return vboxWidget()->vboxAddress(); }
+    uchar *address() { return vboxWidget()->vboxAddress(); }
     ulong bitsPerPixel() { return vboxWidget()->vboxBitsPerPixel(); }
     ulong bytesPerLine() { return vboxWidget()->vboxBytesPerLine(); }
+
+    uchar *vramAddressFromOffset(uint64_t offset);
 
     void paintEvent (QPaintEvent *pe);
@@ -548 +570 @@
 private:
 #ifdef VBOX_WITH_VIDEOHWACCEL
+    void checkUpdateAddress (VBoxVHWASurfaceBase * pSurface, uint64_t offset)
+    {
+        if (pSurface->addressAlocated())
+        {
+            uchar * addr = vramAddressFromOffset(offset);
+            if(addr)
+            {
+                pSurface->setAddress(addr);
+            }
+        }
+    }
     int vhwaSurfaceCanCreate(struct _VBOXVHWACMD_SURF_CANCREATE *pCmd);
     int vhwaSurfaceCreate(struct _VBOXVHWACMD_SURF_CREATE *pCmd);