Index: /trunk/include/VBox/VBoxVideo.h
===================================================================
--- /trunk/include/VBox/VBoxVideo.h	(revision 29921)
+++ /trunk/include/VBox/VBoxVideo.h	(revision 29922)
@@ -282,4 +282,7 @@
     VBOXVHWACMD_TYPE_HH_CONSTRUCT,
     VBOXVHWACMD_TYPE_HH_RESET
+#ifdef VBOXWDDM
+    , VBOXVHWACMD_TYPE_SURF_GETINFO
+#endif
 } VBOXVHWACMD_TYPE;
 
@@ -324,5 +327,5 @@
 typedef unsigned int VBOXVHWACMD_LENGTH;
 typedef uint64_t VBOXVHWA_SURFHANDLE;
-#define VBOXVHWA_SURFHANDLE_INVALID 0
+#define VBOXVHWA_SURFHANDLE_INVALID 0ULL
 #define VBOXVHWACMD_BODY(_p, _t) ((_t*)(_p)->body)
 #define VBOXVHWACMD_HEAD(_pb) ((VBOXVHWACMD*)((uint8_t *)(_pb) - RT_OFFSETOF(VBOXVHWACMD, body)))
@@ -606,4 +609,11 @@
     VBOXVHWA_SURFACEDESC SurfInfo;
 } VBOXVHWACMD_SURF_CREATE;
+
+#ifdef VBOXWDDM
+typedef struct _VBOXVHWACMD_SURF_GETINFO
+{
+    VBOXVHWA_SURFACEDESC SurfInfo;
+} VBOXVHWACMD_SURF_GETINFO;
+#endif
 
 typedef struct _VBOXVHWACMD_SURF_DESTROY
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.h
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.h	(revision 29921)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.h	(revision 29922)
@@ -157,5 +157,5 @@
 {
     VBOXVHWA_INFO Settings;
-    bool cOverlaysCreated;
+    volatile uint32_t cOverlaysCreated;
 } VBOXWDDM_VHWA;
 #endif
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.cpp	(revision 29921)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.cpp	(revision 29922)
@@ -477,4 +477,110 @@
 }
 
+int vboxVhwaHlpDestroySurface(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSurf,
+        D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
+{
+    Assert(pSurf->hHostHandle);
+    if (!pSurf->hHostHandle)
+        return VERR_INVALID_STATE;
+
+    VBOXVHWACMD* pCmd = vboxVhwaCommandCreate(pDevExt, VidPnSourceId,
+            VBOXVHWACMD_TYPE_SURF_DESTROY, sizeof(VBOXVHWACMD_SURF_DESTROY));
+    Assert(pCmd);
+    if(pCmd)
+    {
+        VBOXVHWACMD_SURF_DESTROY * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_DESTROY);
+
+        memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_DESTROY));
+
+        pBody->u.in.hSurf = pSurf->hHostHandle;
+
+        /* we're not interested in completion, just send the command */
+        vboxVhwaCommandSubmitAsynchAndComplete(pDevExt, pCmd);
+
+        pSurf->hHostHandle = VBOXVHWA_SURFHANDLE_INVALID;
+
+        return VINF_SUCCESS;
+    }
+
+    return VERR_OUT_OF_RESOURCES;
+}
+
+int vboxVhwaHlpPopulateSurInfo(VBOXVHWA_SURFACEDESC *pInfo, PVBOXWDDM_ALLOCATION pSurf,
+        uint32_t fFlags, uint32_t cBackBuffers, uint32_t fSCaps,
+        D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
+{
+    memset(pInfo, 0, sizeof(VBOXVHWA_SURFACEDESC));
+
+    pInfo->height = pSurf->SurfDesc.height;
+    pInfo->width = pSurf->SurfDesc.width;
+    pInfo->flags |= VBOXVHWA_SD_HEIGHT | VBOXVHWA_SD_WIDTH;
+    if (fFlags & VBOXVHWA_SD_PITCH)
+    {
+        pInfo->pitch = pSurf->SurfDesc.pitch;
+        pInfo->flags |= VBOXVHWA_SD_PITCH;
+        pInfo->sizeX = pSurf->SurfDesc.cbSize;
+        pInfo->sizeY = 1;
+    }
+
+    if (cBackBuffers)
+    {
+        pInfo->cBackBuffers = cBackBuffers;
+        pInfo->flags |= VBOXVHWA_SD_BACKBUFFERCOUNT;
+    }
+    else
+        pInfo->cBackBuffers = 0;
+    pInfo->Reserved = 0;
+        /* @todo: color keys */
+//                        pInfo->DstOverlayCK;
+//                        pInfo->DstBltCK;
+//                        pInfo->SrcOverlayCK;
+//                        pInfo->SrcBltCK;
+    int rc = vboxVhwaHlpTranslateFormat(&pInfo->PixelFormat, pSurf->SurfDesc.format);
+    AssertRC(rc);
+    if (RT_SUCCESS(rc))
+    {
+        pInfo->flags |= VBOXVHWA_SD_PIXELFORMAT;
+        pInfo->surfCaps = fSCaps;
+        pInfo->flags |= VBOXVHWA_SD_CAPS;
+        pInfo->offSurface = pSurf->offVram;
+    }
+
+    return rc;
+}
+
+int vboxVhwaHlpCheckApplySurfInfo(PVBOXWDDM_ALLOCATION pSurf, VBOXVHWA_SURFACEDESC *pInfo,
+        uint32_t fFlags, bool bApplyHostHandle)
+{
+    int rc = VINF_SUCCESS;
+    if (!(fFlags & VBOXVHWA_SD_PITCH))
+    {
+        /* should be set by host */
+        Assert(pInfo->flags & VBOXVHWA_SD_PITCH);
+        pSurf->SurfDesc.cbSize = pInfo->sizeX * pInfo->sizeY;
+        Assert(pSurf->SurfDesc.cbSize);
+        pSurf->SurfDesc.pitch = pInfo->pitch;
+        Assert(pSurf->SurfDesc.pitch);
+    }
+    else
+    {
+        Assert(pSurf->SurfDesc.cbSize ==  pInfo->sizeX);
+        Assert(pInfo->sizeY == 1);
+        Assert(pInfo->pitch == pSurf->SurfDesc.pitch);
+        if (pSurf->SurfDesc.cbSize !=  pInfo->sizeX
+                || pInfo->sizeY != 1
+                || pInfo->pitch != pSurf->SurfDesc.pitch)
+        {
+            rc = VERR_INVALID_PARAMETER;
+        }
+    }
+
+    if (bApplyHostHandle && RT_SUCCESS(rc))
+    {
+        pSurf->hHostHandle = pInfo->hSurf;
+    }
+
+    return rc;
+}
+
 int vboxVhwaHlpCreateSurface(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSurf,
         uint32_t fFlags, uint32_t cBackBuffers, uint32_t fSCaps,
@@ -485,5 +591,5 @@
                 VBOXVHWACMD_TYPE_SURF_CREATE, sizeof(VBOXVHWACMD_SURF_CREATE));
     Assert(pCmd);
-    if(pCmd)
+    if (pCmd)
     {
         VBOXVHWACMD_SURF_CREATE * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_CREATE);
@@ -492,66 +598,15 @@
         memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_CREATE));
 
-        pBody->SurfInfo.height = pSurf->SurfDesc.height;
-        pBody->SurfInfo.width = pSurf->SurfDesc.width;
-        pBody->SurfInfo.flags |= VBOXVHWA_SD_HEIGHT | VBOXVHWA_SD_WIDTH;
-        if (fFlags & VBOXVHWA_SD_PITCH)
-        {
-            pBody->SurfInfo.pitch = pSurf->SurfDesc.pitch;
-            pBody->SurfInfo.flags |= VBOXVHWA_SD_PITCH;
-            pBody->SurfInfo.sizeX = pSurf->SurfDesc.cbSize;
-            pBody->SurfInfo.sizeY = 1;
-        }
-        if (cBackBuffers)
-        {
-            pBody->SurfInfo.cBackBuffers = cBackBuffers;
-            pBody->SurfInfo.flags |= VBOXVHWA_SD_BACKBUFFERCOUNT;
-        }
-        else
-            pBody->SurfInfo.cBackBuffers = 0;
-        pBody->SurfInfo.Reserved = 0;
-        /* @todo: color keys */
-//                        pBody->SurfInfo.DstOverlayCK;
-//                        pBody->SurfInfo.DstBltCK;
-//                        pBody->SurfInfo.SrcOverlayCK;
-//                        pBody->SurfInfo.SrcBltCK;
-        rc = vboxVhwaHlpTranslateFormat(&pBody->SurfInfo.PixelFormat, pSurf->SurfDesc.format);
+        rc = vboxVhwaHlpPopulateSurInfo(&pBody->SurfInfo, pSurf,
+                fFlags, cBackBuffers, fSCaps,
+                VidPnSourceId);
         AssertRC(rc);
         if (RT_SUCCESS(rc))
         {
-            pBody->SurfInfo.flags |= VBOXVHWA_SD_PIXELFORMAT;
-            pBody->SurfInfo.surfCaps = fSCaps;
-            pBody->SurfInfo.flags |= VBOXVHWA_SD_CAPS;
-            pBody->SurfInfo.offSurface = pSurf->offVram;
-
             vboxVhwaCommandSubmit(pDevExt, pCmd);
             Assert(pCmd->rc == VINF_SUCCESS);
             if(pCmd->rc == VINF_SUCCESS)
             {
-                if (!(fFlags & VBOXVHWA_SD_PITCH))
-                {
-                    /* should be set by host */
-                    Assert(pBody->SurfInfo.flags & VBOXVHWA_SD_PITCH);
-                    pSurf->SurfDesc.cbSize = pBody->SurfInfo.sizeX * pBody->SurfInfo.sizeY;
-                    Assert(pSurf->SurfDesc.cbSize);
-                    pSurf->SurfDesc.pitch = pBody->SurfInfo.pitch;
-                    Assert(pSurf->SurfDesc.pitch);
-                }
-                else
-                {
-                    Assert(pSurf->SurfDesc.cbSize ==  pBody->SurfInfo.sizeX);
-                    Assert(pBody->SurfInfo.sizeY == 1);
-                    Assert(pBody->SurfInfo.pitch == pSurf->SurfDesc.pitch);
-                    if (pSurf->SurfDesc.cbSize !=  pBody->SurfInfo.sizeX
-                            || pBody->SurfInfo.sizeY != 1
-                            || pBody->SurfInfo.pitch != pSurf->SurfDesc.pitch)
-                    {
-                        rc = VERR_INVALID_PARAMETER;
-                    }
-                }
-
-                if (RT_SUCCESS(rc))
-                {
-                        pSurf->hHostHandle = pBody->SurfInfo.hSurf;
-                }
+                rc = vboxVhwaHlpCheckApplySurfInfo(pSurf, &pBody->SurfInfo, fFlags, true);
             }
             else
@@ -565,10 +620,57 @@
 }
 
-int vboxVhwaHlpCreatePriary(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_SOURCE pSource, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
-{
-    Assert(!!(pSource->Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED));
-    if (!(pSource->Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED))
-        return VERR_NOT_SUPPORTED;
-
+int vboxVhwaHlpGetSurfInfoForSource(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSurf, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
+{
+    /* the first thing we need is to post create primary */
+    VBOXVHWACMD* pCmd = vboxVhwaCommandCreate(pDevExt, VidPnSourceId,
+            VBOXVHWACMD_TYPE_SURF_GETINFO, sizeof(VBOXVHWACMD_SURF_GETINFO));
+    Assert(pCmd);
+    if (pCmd)
+    {
+        VBOXVHWACMD_SURF_GETINFO * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_GETINFO);
+        int rc = VINF_SUCCESS;
+
+        memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_GETINFO));
+
+        rc = vboxVhwaHlpPopulateSurInfo(&pBody->SurfInfo, pSurf,
+                0, 0, VBOXVHWA_SCAPS_OVERLAY | VBOXVHWA_SCAPS_VIDEOMEMORY | VBOXVHWA_SCAPS_LOCALVIDMEM | VBOXVHWA_SCAPS_COMPLEX,
+                VidPnSourceId);
+        AssertRC(rc);
+        if (RT_SUCCESS(rc))
+        {
+            vboxVhwaCommandSubmit(pDevExt, pCmd);
+            Assert(pCmd->rc == VINF_SUCCESS);
+            if(pCmd->rc == VINF_SUCCESS)
+            {
+                rc = vboxVhwaHlpCheckApplySurfInfo(pSurf, &pBody->SurfInfo, 0, true);
+            }
+            else
+                rc = pCmd->rc;
+        }
+        vboxVhwaCommandFree(pDevExt, pCmd);
+        return rc;
+    }
+
+    return VERR_OUT_OF_RESOURCES;
+}
+
+int vboxVhwaHlpGetSurfInfo(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSurf)
+{
+    for (uint32_t i = 0; i < pDevExt->cSources; ++i)
+    {
+        PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[i];
+        if (pSource->Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED)
+        {
+            int rc = vboxVhwaHlpGetSurfInfoForSource(pDevExt, pSurf, i);
+            AssertRC(rc);
+            return rc;
+        }
+    }
+    AssertBreakpoint();
+    return VERR_NOT_SUPPORTED;
+}
+
+int vboxVhwaHlpDestroyPrimary(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_SOURCE pSource, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
+{
 #ifdef VBOXWDDM_RENDER_FROM_SHADOW
     PVBOXWDDM_ALLOCATION pFbSurf = pSource->pShadowAllocation;
@@ -577,12 +679,20 @@
 #endif
 
-    Assert(!pSource->Vhwa.cOverlaysCreated);
-    if (pSource->Vhwa.cOverlaysCreated)
-    {
-        Assert(pFbSurf->hHostHandle);
-        if (pFbSurf->hHostHandle)
-            return VINF_ALREADY_INITIALIZED;
+    int rc = vboxVhwaHlpDestroySurface(pDevExt, pFbSurf, VidPnSourceId);
+    AssertRC(rc);
+    return rc;
+}
+
+int vboxVhwaHlpCreatePrimary(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_SOURCE pSource, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
+{
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+    PVBOXWDDM_ALLOCATION pFbSurf = pSource->pShadowAllocation;
+#else
+    PVBOXWDDM_ALLOCATION pFbSurf = pSource->pPrimaryAllocation;
+#endif
+    Assert(pSource->Vhwa.cOverlaysCreated == 1);
+    Assert(pFbSurf->hHostHandle == VBOXVHWA_SURFHANDLE_INVALID);
+    if (pFbSurf->hHostHandle != VBOXVHWA_SURFHANDLE_INVALID)
         return VERR_INVALID_STATE;
-    }
 
     int rc = vboxVhwaHlpCreateSurface(pDevExt, pFbSurf,
@@ -593,5 +703,5 @@
 }
 
-int vboxVhwaHlpCreateOverlay(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSurf, uint32_t cBackBuffers, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
+int vboxVhwaHlpCheckInit(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
 {
     Assert(VidPnSourceId < pDevExt->cSources);
@@ -601,5 +711,65 @@
     PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[VidPnSourceId];
 
-    int rc = vboxVhwaHlpCreatePriary(pDevExt, pSource, VidPnSourceId);
+    Assert(!!(pSource->Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED));
+    if (!(pSource->Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED))
+        return VERR_NOT_SUPPORTED;
+
+    int rc = VINF_SUCCESS;
+    /* @todo: need a better synch */
+    uint32_t cNew = ASMAtomicIncU32(&pSource->Vhwa.cOverlaysCreated);
+    if (cNew == 1)
+    {
+        rc = vboxVhwaHlpCreatePrimary(pDevExt, pSource, VidPnSourceId);
+        AssertRC(rc);
+    }
+    else
+    {
+#ifdef VBOXWDDM_RENDER_FROM_SHADOW
+        PVBOXWDDM_ALLOCATION pFbSurf = pSource->pShadowAllocation;
+#else
+        PVBOXWDDM_ALLOCATION pFbSurf = pSource->pPrimaryAllocation;
+#endif
+        Assert(pFbSurf->hHostHandle);
+        if (pFbSurf->hHostHandle)
+            rc = VINF_ALREADY_INITIALIZED;
+        else
+            rc = VERR_INVALID_STATE;
+    }
+
+    if (RT_FAILURE(rc))
+        ASMAtomicDecU32(&pSource->Vhwa.cOverlaysCreated);
+
+    return rc;
+}
+
+int vboxVhwaHlpCheckTerm(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
+{
+    Assert(VidPnSourceId < pDevExt->cSources);
+    if (VidPnSourceId >= pDevExt->cSources)
+        return VERR_INVALID_PARAMETER;
+
+    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[VidPnSourceId];
+
+    Assert(!!(pSource->Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED));
+
+    /* @todo: need a better synch */
+    uint32_t cNew = ASMAtomicDecU32(&pSource->Vhwa.cOverlaysCreated);
+    int rc = VINF_SUCCESS;
+    if (!cNew)
+    {
+        rc = vboxVhwaHlpDestroyPrimary(pDevExt, pSource, VidPnSourceId);
+        AssertRC(rc);
+    }
+    else
+    {
+        Assert(cNew < UINT32_MAX / 2);
+    }
+
+    return rc;
+}
+
+int vboxVhwaHlpCreateOverlay(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSurf, uint32_t cBackBuffers, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
+{
+    int rc = vboxVhwaHlpCheckInit(pDevExt, VidPnSourceId);
     AssertRC(rc);
     if (RT_SUCCESS(rc))
@@ -609,8 +779,19 @@
                     VidPnSourceId);
         AssertRC(rc);
-        if (RT_SUCCESS(rc))
-            ++pSource->Vhwa.cOverlaysCreated;
-    }
-
-    return rc;
-}
+    }
+
+    return rc;
+}
+
+int vboxVhwaHlpDestroyOverlay(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSurf, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
+{
+    int rc = vboxVhwaHlpDestroySurface(pDevExt, pSurf, VidPnSourceId);
+    AssertRC(rc);
+    if (RT_SUCCESS(rc))
+    {
+        rc = vboxVhwaHlpCheckTerm(pDevExt, VidPnSourceId);
+        AssertRC(rc);
+    }
+
+    return rc;
+}
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.h
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.h	(revision 29921)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.h	(revision 29922)
@@ -55,4 +55,6 @@
 
 int vboxVhwaHlpCreateOverlay(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSurf, uint32_t cBackBuffers, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId);
+int vboxVhwaHlpDestroyOverlay(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSurf, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId);
+int vboxVhwaHlpGetSurfInfo(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pSurf);
 
 #endif /* #ifndef ___VBoxVideoVhwa_h___ */
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp	(revision 29921)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp	(revision 29922)
@@ -1372,4 +1372,45 @@
     return Status;
 }
+
+PVBOXWDDM_ALLOCATION vboxWddmAllocationCreateFromResource(PVBOXWDDM_RESOURCE pResource, uint32_t iIndex)
+{
+    PVBOXWDDM_ALLOCATION pAllocation = NULL;
+    if (pResource)
+    {
+        Assert(iIndex < pResource->cAllocations);
+        if (iIndex < pResource->cAllocations)
+        {
+            pAllocation = &pResource->aAllocations[iIndex];
+            memset(pAllocation, 0, sizeof (VBOXWDDM_ALLOCATION));
+        }
+    }
+    else
+        pAllocation = (PVBOXWDDM_ALLOCATION)vboxWddmMemAllocZero(sizeof (VBOXWDDM_ALLOCATION));
+
+    if (pAllocation)
+    {
+        if (pResource)
+        {
+            pAllocation->pResource = pResource;
+            pAllocation->iIndex = iIndex;
+        }
+    }
+
+    return pAllocation;
+}
+
+void vboxWddmAllocationDeleteFromResource(PVBOXWDDM_RESOURCE pResource, PVBOXWDDM_ALLOCATION pAllocation)
+{
+    Assert(pAllocation->pResource == pResource);
+    if (pResource)
+    {
+        Assert(&pResource->aAllocations[pAllocation->iIndex] == pAllocation);
+    }
+    else
+    {
+        vboxWddmMemFree(pAllocation);
+    }
+}
+
 NTSTATUS vboxWddmDestroyAllocation(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pAllocation)
 {
@@ -1399,12 +1440,24 @@
         }
 #endif
+//#ifdef VBOX_WITH_VIDEOHWACCEL
+//        case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC:
+//        {
+//            if (pAllocation->fRcFlags.Overlay)
+//            {
+//                vboxVhwaHlpDestroyOverlay(pDevExt, pAllocation);
+//            }
+//            break;
+//        }
+//#endif
         default:
             break;
     }
-    vboxWddmMemFree(pAllocation);
+
+    vboxWddmAllocationDeleteFromResource(pAllocation->pResource, pAllocation);
+
     return STATUS_SUCCESS;
 }
 
-NTSTATUS vboxWddmCreateAllocation(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_RCINFO pRcInfo, DXGK_ALLOCATIONINFO* pAllocationInfo)
+NTSTATUS vboxWddmCreateAllocation(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_RESOURCE pResource, uint32_t iIndex, DXGK_ALLOCATIONINFO* pAllocationInfo)
 {
     PAGED_CODE();
@@ -1416,5 +1469,5 @@
     {
         PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pAllocationInfo->pPrivateDriverData;
-        PVBOXWDDM_ALLOCATION pAllocation = (PVBOXWDDM_ALLOCATION)vboxWddmMemAllocZero(sizeof (VBOXWDDM_ALLOCATION));
+        PVBOXWDDM_ALLOCATION pAllocation = vboxWddmAllocationCreateFromResource(pResource, iIndex);
         Assert(pAllocation);
         if (pAllocation)
@@ -1454,23 +1507,31 @@
                     break;
                 case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC:
+                    Assert(pResource);
+                    if (pResource)
+                    {
+                        Assert(pResource->cAllocations);
+                        if (pResource->cAllocations)
+                        {
 #ifdef VBOX_WITH_VIDEOHWACCEL
-                    Assert(pRcInfo);
-                    if (pRcInfo)
-                    {
-                        Assert(pRcInfo->cAllocInfos);
-                        if (pRcInfo->cAllocInfos)
-                        {
-                            if (pRcInfo->RcDesc.fFlags.Overlay)
+                            if (pResource->RcDesc.fFlags.Overlay)
                             {
-                                int rc = vboxVhwaHlpCreateOverlay(pDevExt, pAllocation, pRcInfo->cAllocInfos - 1, pRcInfo->RcDesc.VidPnSourceId);
+                                /* actually we can not "properly" issue create overlay commands to the host here
+                                 * because we do not know source VidPn id here, i.e.
+                                 * the primary which is supposed to be overlayed,
+                                 * however we need to get some info like pitch & size from the host here */
+                                int rc = vboxVhwaHlpGetSurfInfo(pDevExt, pAllocation);
                                 AssertRC(rc);
-                                if (RT_FAILURE(rc))
+                                if (RT_SUCCESS(rc))
+                                {
+                                    pAllocInfo->SurfDesc = pAllocation->SurfDesc;
+                                }
+                                else
                                     Status = STATUS_UNSUCCESSFUL;
                             }
+#endif
                         }
                         else
                             Status = STATUS_INVALID_PARAMETER;
                     }
-#endif
                     /* do not break to set CPU visibility flag */
                 case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
@@ -1487,5 +1548,5 @@
 
             if (Status != STATUS_SUCCESS)
-                vboxWddmMemFree(pAllocation);
+                vboxWddmAllocationDeleteFromResource(pResource, pAllocation);
         }
         else
@@ -1518,5 +1579,5 @@
     PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)hAdapter;
     NTSTATUS Status = STATUS_SUCCESS;
-    PVBOXWDDM_RCINFO pRcInfo = NULL;
+    PVBOXWDDM_RESOURCE pResource = NULL;
 
     if (pCreateAllocation->PrivateDriverDataSize)
@@ -1526,7 +1587,17 @@
         if (pCreateAllocation->PrivateDriverDataSize >= sizeof (VBOXWDDM_RCINFO))
         {
-            pRcInfo = (PVBOXWDDM_RCINFO)pCreateAllocation->pPrivateDriverData;
-            Assert(pRcInfo->RcDesc.VidPnSourceId < pDevExt->cSources);
+            PVBOXWDDM_RCINFO pRcInfo = (PVBOXWDDM_RCINFO)pCreateAllocation->pPrivateDriverData;
+//            Assert(pRcInfo->RcDesc.VidPnSourceId < pDevExt->cSources);
             Assert(pRcInfo->cAllocInfos == pCreateAllocation->NumAllocations);
+            pResource = (PVBOXWDDM_RESOURCE)vboxWddmMemAllocZero(RT_OFFSETOF(VBOXWDDM_RESOURCE, aAllocations[pRcInfo->cAllocInfos]));
+            Assert(pResource);
+            if (pResource)
+            {
+                pResource->cAllocations = pRcInfo->cAllocInfos;
+                pResource->fFlags = pRcInfo->fFlags;
+                pResource->RcDesc = pRcInfo->RcDesc;
+            }
+            else
+                Status = STATUS_NO_MEMORY;
         }
         else
@@ -1540,5 +1611,5 @@
         for (UINT i = 0; i < pCreateAllocation->NumAllocations; ++i)
         {
-            Status = vboxWddmCreateAllocation(pDevExt, pRcInfo, &pCreateAllocation->pAllocationInfo[i]);
+            Status = vboxWddmCreateAllocation(pDevExt, pResource, i, &pCreateAllocation->pAllocationInfo[i]);
             Assert(Status == STATUS_SUCCESS);
             if (Status != STATUS_SUCCESS)
@@ -1552,4 +1623,8 @@
             }
         }
+
+        pCreateAllocation->hResource = pResource;
+        if (pResource && Status != STATUS_SUCCESS)
+            vboxWddmMemFree(pResource);
     }
     dfprintf(("<== "__FUNCTION__ ", status(0x%x), context(0x%x)\n", Status, hAdapter));
@@ -1573,7 +1648,21 @@
     NTSTATUS Status = STATUS_SUCCESS;
 
+    PVBOXWDDM_RESOURCE pRc = (PVBOXWDDM_RESOURCE)pDestroyAllocation->hResource;
+
+    if (pRc)
+    {
+        Assert(pRc->cAllocations == pDestroyAllocation->NumAllocations);
+    }
+
     for (UINT i = 0; i < pDestroyAllocation->NumAllocations; ++i)
     {
-        vboxWddmDestroyAllocation((PDEVICE_EXTENSION)hAdapter, (PVBOXWDDM_ALLOCATION)pDestroyAllocation->pAllocationList[i]);
+        PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pDestroyAllocation->pAllocationList[i];
+        Assert(pAlloc->pResource == pRc);
+        vboxWddmDestroyAllocation((PDEVICE_EXTENSION)hAdapter, pAlloc);
+    }
+
+    if (pRc)
+    {
+        vboxWddmMemFree(pRc);
     }
 
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.h
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.h	(revision 29921)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.h	(revision 29922)
@@ -52,4 +52,5 @@
 {
     VBOXWDDM_ALLOC_TYPE enmType;
+//    D3DDDI_RESOURCEFLAGS fRcFlags;
     UINT SegmentId;
     VBOXVIDEOOFFSET offVram;
@@ -60,17 +61,14 @@
     BOOLEAN bAssigned;
     VBOXWDDM_SURFACE_DESC SurfDesc;
+    struct VBOXWDDM_RESOURCE *pResource;
+    uint32_t iIndex;
 } VBOXWDDM_ALLOCATION, *PVBOXWDDM_ALLOCATION;
 
 typedef struct VBOXWDDM_RESOURCE
 {
-    VBOXWDDM_ALLOC_TYPE enmType;
-    UINT SegmentId;
-    VBOXVIDEOOFFSET offVram;
-    D3DDDI_RATIONAL RefreshRate;
-    D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
-    BOOLEAN bVisible;
-    BOOLEAN bAssigned;
-    VBOXWDDM_SURFACE_DESC SurfDesc;
+    uint32_t fFlags;
+    VBOXWDDM_RC_DESC RcDesc;
     uint32_t cAllocations;
+    VBOXWDDM_ALLOCATION aAllocations[1];
 } VBOXWDDM_RESOURCE, *PVBOXWDDM_RESOURCE;
 
Index: /trunk/src/VBox/Frontends/VirtualBox/Makefile.kmk
===================================================================
--- /trunk/src/VBox/Frontends/VirtualBox/Makefile.kmk	(revision 29921)
+++ /trunk/src/VBox/Frontends/VirtualBox/Makefile.kmk	(revision 29922)
@@ -144,5 +144,7 @@
  VirtualBox_DEFS        += VBOX_WITH_VIRTIO
 endif
-
+ifdef VBOXWDDM
+ VirtualBox_DEFS        += VBOXWDDM
+endif
 ifdef VBOX_BLEEDING_EDGE
 VirtualBox_src/VBoxSelectorWnd.cpp_DEFS += \
Index: /trunk/src/VBox/Frontends/VirtualBox/src/VBoxFBOverlay.cpp
===================================================================
--- /trunk/src/VBox/Frontends/VirtualBox/src/VBoxFBOverlay.cpp	(revision 29921)
+++ /trunk/src/VBox/Frontends/VirtualBox/src/VBoxFBOverlay.cpp	(revision 29922)
@@ -2422,4 +2422,33 @@
 }
 
+#ifdef VBOXWDDM
+int VBoxVHWAImage::vhwaSurfaceGetInfo(struct _VBOXVHWACMD_SURF_GETINFO *pCmd)
+{
+    VBoxVHWAColorFormat format;
+    Assert(!format.isValid());
+    if (pCmd->SurfInfo.PixelFormat.flags & VBOXVHWA_PF_RGB)
+        format = VBoxVHWAColorFormat(pCmd->SurfInfo.PixelFormat.c.rgbBitCount,
+                                        pCmd->SurfInfo.PixelFormat.m1.rgbRBitMask,
+                                        pCmd->SurfInfo.PixelFormat.m2.rgbGBitMask,
+                                        pCmd->SurfInfo.PixelFormat.m3.rgbBBitMask);
+    else if (pCmd->SurfInfo.PixelFormat.flags & VBOXVHWA_PF_FOURCC)
+        format = VBoxVHWAColorFormat(pCmd->SurfInfo.PixelFormat.fourCC);
+    else
+        AssertBreakpoint();
+
+    Assert(format.isValid());
+    if (format.isValid())
+    {
+        pCmd->SurfInfo.pitch = format.bitsPerPixel() * pCmd->SurfInfo.width / 8;
+//        pCmd->SurfInfo.pitch = ((pCmd->SurfInfo.pitch + 3) & (~3));
+        pCmd->SurfInfo.sizeX = format.bitsPerPixelMem() * pCmd->SurfInfo.width / 8;
+//        pCmd->SurfInfo.sizeX = ((pCmd->SurfInfo.sizeX + 3) & (~3));
+        pCmd->SurfInfo.sizeX *= pCmd->SurfInfo.height;
+        pCmd->SurfInfo.sizeY = 1;
+        return VINF_SUCCESS;
+    }
+    return VERR_INVALID_PARAMETER;
+}
+#endif
 int VBoxVHWAImage::vhwaSurfaceDestroy(struct _VBOXVHWACMD_SURF_DESTROY *pCmd)
 {
@@ -3883,4 +3912,7 @@
         case FOURCC_AYUV:
             mBitsPerPixel = 32;
+#ifdef VBOXWDDM
+            mBitsPerPixelMem = 32;
+#endif
             mWidthCompression = 1;
             break;
@@ -3888,8 +3920,14 @@
         case FOURCC_YUY2:
             mBitsPerPixel = 16;
+#ifdef VBOXWDDM
+            mBitsPerPixelMem = 16;
+#endif
             mWidthCompression = 2;
             break;
         case FOURCC_YV12:
             mBitsPerPixel = 8;
+#ifdef VBOXWDDM
+            mBitsPerPixelMem = 12;
+#endif
             mWidthCompression = 4;
             break;
@@ -3898,4 +3936,7 @@
             mBitsPerPixel = 0;
             mBitsPerPixelTex = 0;
+#ifdef VBOXWDDM
+            mBitsPerPixelMem = 0;
+#endif
             mWidthCompression = 0;
             break;
@@ -3907,4 +3948,7 @@
     mBitsPerPixel = bitsPerPixel;
     mBitsPerPixelTex = bitsPerPixel;
+#ifdef VBOXWDDM
+    mBitsPerPixelMem = bitsPerPixel;
+#endif
     mDataFormat = 0;
     switch (bitsPerPixel)
@@ -3964,4 +4008,7 @@
             mBitsPerPixel = 0;
             mBitsPerPixelTex = 0;
+#ifdef VBOXWDDM
+            mBitsPerPixelMem = 0;
+#endif
             break;
     }
@@ -4594,4 +4641,11 @@
             pCmd->rc = vhwaConstruct(pBody);
         } break;
+#ifdef VBOXWDDM
+        case VBOXVHWACMD_TYPE_SURF_GETINFO:
+        {
+            VBOXVHWACMD_SURF_GETINFO * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_GETINFO);
+            pCmd->rc = mOverlayImage.vhwaSurfaceGetInfo(pBody);
+        } break;
+#endif
         default:
             Assert(0);
Index: /trunk/src/VBox/Frontends/VirtualBox/src/VBoxFBOverlay.h
===================================================================
--- /trunk/src/VBox/Frontends/VirtualBox/src/VBoxFBOverlay.h	(revision 29921)
+++ /trunk/src/VBox/Frontends/VirtualBox/src/VBoxFBOverlay.h	(revision 29922)
@@ -232,4 +232,7 @@
     uint32_t bitsPerPixel() const { return mBitsPerPixel; }
     uint32_t bitsPerPixelTex() const { return mBitsPerPixelTex; }
+#ifdef VBOXWDDM
+    uint32_t bitsPerPixelMem() const { return mBitsPerPixelMem; }
+#endif
     void pixel2Normalized(uint32_t pix, float *r, float *g, float *b) const;
     uint32_t widthCompression() const {return mWidthCompression;}
@@ -267,4 +270,7 @@
     uint32_t mBitsPerPixel;
     uint32_t mBitsPerPixelTex;
+#ifdef VBOXWDDM
+    uint32_t mBitsPerPixelMem;
+#endif
     uint32_t mWidthCompression;
     uint32_t mHeightCompression;
@@ -1479,4 +1485,7 @@
     int vhwaSurfaceCanCreate(struct _VBOXVHWACMD_SURF_CANCREATE *pCmd);
     int vhwaSurfaceCreate(struct _VBOXVHWACMD_SURF_CREATE *pCmd);
+#ifdef VBOXWDDM
+    int vhwaSurfaceGetInfo(struct _VBOXVHWACMD_SURF_GETINFO *pCmd);
+#endif
     int vhwaSurfaceDestroy(struct _VBOXVHWACMD_SURF_DESTROY *pCmd);
     int vhwaSurfaceLock(struct _VBOXVHWACMD_SURF_LOCK *pCmd);