Changeset 31797 in vbox for trunk

Timestamp:

Aug 19, 2010 5:03:40 PM (14 years ago)

Author:

vboxsync

Message:

wddm/3d: multimonitor for fullscreen apps (Aero), shared rc support needed

Location:

trunk/src/VBox/Additions/WINNT/Graphics

Files:

• Display/wddm/VBoxDispD3D.cpp (modified) (90 diffs)
• Display/wddm/VBoxDispD3D.h (modified) (4 diffs)
• Display/wddm/VBoxDispMp.cpp (modified) (1 diff)
• Miniport/wddm/VBoxVideoIf.h (modified) (2 diffs)
• Miniport/wddm/VBoxVideoVdma.cpp (modified) (10 diffs)
• Miniport/wddm/VBoxVideoVdma.h (modified) (1 diff)
• Miniport/wddm/VBoxVideoWddm.cpp (modified) (5 diffs)
• Miniport/wddm/VBoxVideoWddm.h (modified) (1 diff)

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp

@@ -1069 +1069 @@
 static HRESULT vboxWddmRenderTargetUpdateSurface(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pAlloc, uint32_t iBBuf)
 {
+    if (pAlloc->SurfDesc.VidPnSourceId != pDevice->iPrimaryScreen)
+        return S_OK;
+
     IDirect3DSurface9 *pD3D9Surf;
-    HRESULT hr = pDevice->pDevice9If->GetBackBuffer(0 /*UINT iSwapChain*/,
+    IDirect3DDevice9 *pDevice9If = pDevice->aScreens[pDevice->iPrimaryScreen].pDevice9If;
+    HRESULT hr = pDevice9If->GetBackBuffer(0 /*UINT iSwapChain*/,
             iBBuf, D3DBACKBUFFER_TYPE_MONO, &pD3D9Surf);
     Assert(hr == S_OK);
@@ -1085 +1089 @@
 static HRESULT vboxWddmRenderTargetUpdate(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_RESOURCE pRc, uint32_t iNewRTFB)
 {
+    if (pRc->RcDesc.VidPnSourceId != pDevice->iPrimaryScreen)
+        return S_OK;
+
     PVBOXWDDMDISP_ALLOCATION pAlloc;
     UINT iBBuf = 0;
@@ -1134 +1141 @@
     IDirect3DSurface9 *pD3D9Surf;
     Assert(pAlloc->enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE);
-    HRESULT hr = pDevice->pDevice9If->GetBackBuffer(0 /*UINT iSwapChain*/,
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
+    HRESULT hr = pScreen->pDevice9If->GetBackBuffer(0 /*UINT iSwapChain*/,
             iBBuf, D3DBACKBUFFER_TYPE_MONO, &pD3D9Surf);
     Assert(hr == S_OK);
@@ -1182 +1192 @@
 }
 
-# define VBOXVDBG_RTGT_STATECHECK(_pDev) (vboxWddmDbgRenderTargetCheck((_pDev), (_pDev)->pRenderTargetRc, (_pDev)->iRenderTargetFrontBuf))
+# define VBOXVDBG_RTGT_STATECHECK(_pDev) (vboxWddmDbgRenderTargetCheck((_pDev), (_pDev)->aScreens[(_pDev)->iPrimaryScreen].pRenderTargetRc, (_pDev)->aScreens[(_pDev)->iPrimaryScreen].iRenderTargetFrontBuf))
 #else
 # define VBOXVDBG_RTGT_STATECHECK(_pDev) do{}while(0)
@@ -1766 +1776 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
-    HRESULT hr = pDevice->pDevice9If->SetRenderState(vboxDDI2D3DRenderStateType(pData->State), pData->Value);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
+    HRESULT hr = pScreen->pDevice9If->SetRenderState(vboxDDI2D3DRenderStateType(pData->State), pData->Value);
     Assert(hr == S_OK);
     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
@@ -1793 +1805 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
 
     VBOXWDDMDISP_TSS_LOOKUP lookup = vboxDDI2D3DTestureStageStateType(pData->State);
@@ -1800 +1814 @@
     if (!lookup.bSamplerState)
     {
-        hr = pDevice->pDevice9If->SetTextureStageState(pData->Stage, D3DTEXTURESTAGESTATETYPE(lookup.dType), pData->Value);
+        hr = pScreen->pDevice9If->SetTextureStageState(pData->Stage, D3DTEXTURESTAGESTATETYPE(lookup.dType), pData->Value);
     } 
     else
     {
-        hr = pDevice->pDevice9If->SetSamplerState(pData->Stage, D3DSAMPLERSTATETYPE(lookup.dType), pData->Value);
+        hr = pScreen->pDevice9If->SetSamplerState(pData->Stage, D3DSAMPLERSTATETYPE(lookup.dType), pData->Value);
     }
 
@@ -1817 +1831 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)hTexture;
 //    Assert(pRc);
@@ -1830 +1846 @@
 
 //    Assert(pD3DIfTex);
-    HRESULT hr = pDevice->pDevice9If->SetTexture(Stage, pD3DIfTex);
+    HRESULT hr = pScreen->pDevice9If->SetTexture(Stage, pD3DIfTex);
     Assert(hr == S_OK);
     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
@@ -1841 +1857 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     IDirect3DPixelShader9 *pShader = (IDirect3DPixelShader9*)hShaderHandle;
     Assert(pShader);
-    HRESULT hr = pDevice->pDevice9If->SetPixelShader(pShader);
+    HRESULT hr = pScreen->pDevice9If->SetPixelShader(pShader);
     Assert(hr == S_OK);
     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
@@ -1855 +1873 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
-    HRESULT hr = pDevice->pDevice9If->SetPixelShaderConstantF(pData->Register, pRegisters, pData->Count);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
+    HRESULT hr = pScreen->pDevice9If->SetPixelShaderConstantF(pData->Register, pRegisters, pData->Count);
     Assert(hr == S_OK);
     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
@@ -1867 +1887 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     HRESULT hr = S_OK;
 //    IDirect3DVertexBuffer9 *pStreamData;
@@ -1898 +1920 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hIndexBuffer;
     PVBOXWDDMDISP_ALLOCATION pAlloc = NULL;
@@ -1909 +1933 @@
         pIndexBuffer = (IDirect3DIndexBuffer9*)pAlloc->pD3DIf;
     }
-    HRESULT hr = pDevice->pDevice9If->SetIndices(pIndexBuffer);
+    HRESULT hr = pScreen->pDevice9If->SetIndices(pIndexBuffer);
     Assert(hr == S_OK);
     if (hr == S_OK)
@@ -1925 +1949 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     HRESULT hr = S_OK;
     pDevice->IndiciesUm.pvBuffer = pUMBuffer;
@@ -1938 +1964 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     Assert(!pFlagBuffer);
     HRESULT hr = S_OK;
@@ -1958 +1986 @@
             }
 #endif
-            hr = pDevice->pDevice9If->DrawPrimitiveUP(pData->PrimitiveType,
+            hr = pScreen->pDevice9If->DrawPrimitiveUP(pData->PrimitiveType,
                                       pData->PrimitiveCount,
                                       ((uint8_t*)pDevice->aStreamSourceUm[0].pvBuffer) + pData->VStart * pDevice->aStreamSourceUm[0].cbStride,
@@ -1994 +2022 @@
             Assert(cStreams == pDevice->cStreamSources);
 #endif
-        hr = pDevice->pDevice9If->DrawPrimitive(pData->PrimitiveType,
+        hr = pScreen->pDevice9If->DrawPrimitive(pData->PrimitiveType,
                                                 pData->VStart,
                                                 pData->PrimitiveCount);
@@ -2002 +2030 @@
 #if 0
         IDirect3DVertexDeclaration9* pDecl;
-        hr = pDevice->pDevice9If->GetVertexDeclaration(&pDecl);
+        hr = pScreen->pDevice9If->GetVertexDeclaration(&pDecl);
         Assert(hr == S_OK);
         if (hr == S_OK)
@@ -2127 +2155 @@
                             UINT cbOffset;
                             UINT cbStride;
-                            hr = pDevice->pDevice9If->GetStreamSource(iStream, &pCurVb, &cbOffset, &cbStride);
+                            hr = pScreen->pDevice9If->GetStreamSource(iStream, &pCurVb, &cbOffset, &cbStride);
                             Assert(hr == S_OK);
                             if (hr == S_OK)
@@ -2154 +2182 @@
                             if (!pVb)
                             {
-                                hr = pDevice->pDevice9If->CreateVertexBuffer(cbVertexes,
+                                hr = pScreen->pDevice9If->CreateVertexBuffer(cbVertexes,
                                         0, /* DWORD Usage */
                                         0, /* DWORD FVF */
@@ -2163 +2191 @@
                                 if (hr == S_OK)
                                 {
-                                    hr = pDevice->pDevice9If->SetStreamSource(iStream, pVb, 0, pStrSrc->cbStride);
+                                    hr = pScreen->pDevice9If->SetStreamSource(iStream, pVb, 0, pStrSrc->cbStride);
                                     Assert(hr == S_OK);
                                     if (hr == S_OK)
@@ -2200 +2228 @@
             if (hr == S_OK)
             {
-                hr = pDevice->pDevice9If->DrawPrimitive(pData->PrimitiveType,
+                hr = pScreen->pDevice9If->DrawPrimitive(pData->PrimitiveType,
                         0 /* <- since we use our owne StreamSource buffer which has data at the very beginning*/,
                         pData->PrimitiveCount);
@@ -2224 +2252 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
 //#ifdef DEBUG_misha
 //    uint32_t iBackBuf = (pDevice->iRenderTargetFrontBuf + 1) % pDevice->pRenderTargetRc->cAllocations;
@@ -2254 +2284 @@
 #endif
 
-    HRESULT hr = pDevice->pDevice9If->DrawIndexedPrimitive(
+    HRESULT hr = pScreen->pDevice9If->DrawIndexedPrimitive(
             pData->PrimitiveType,
             pData->BaseVertexIndex,
@@ -2295 +2325 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     HRESULT hr;
 
@@ -2325 +2357 @@
     }
 
-    hr = pDevice->pDevice9If->DrawPrimitive(pData->PrimitiveType, pData->FirstVertexOffset, pData->PrimitiveCount);
+    hr = pScreen->pDevice9If->DrawPrimitive(pData->PrimitiveType, pData->FirstVertexOffset, pData->PrimitiveCount);
 #else
 //#ifdef DEBUG_misha
@@ -2354 +2386 @@
 
                 Assert(pLock->fFlags.MightDrawFromLocked && (pLock->fFlags.Discard || pLock->fFlags.NoOverwrite));
-                hr = pDevice->pDevice9If->DrawPrimitiveUP(pData->PrimitiveType, pData->PrimitiveCount,
+                hr = pScreen->pDevice9If->DrawPrimitiveUP(pData->PrimitiveType, pData->PrimitiveCount,
                         (void*)((uintptr_t)pDevice->aStreamSource[stream]->pvMem+pDevice->StreamSourceInfo[stream].uiOffset+pData->FirstVertexOffset),
                          pDevice->StreamSourceInfo[stream].uiStride);
                 Assert(hr == S_OK);
-                hr = pDevice->pDevice9If->SetStreamSource(stream, (IDirect3DVertexBuffer9*)pDevice->aStreamSource[stream]->pD3DIf, pDevice->StreamSourceInfo[stream].uiOffset, pDevice->StreamSourceInfo[stream].uiStride);
+                hr = pScreen->pDevice9If->SetStreamSource(stream, (IDirect3DVertexBuffer9*)pDevice->aStreamSource[stream]->pD3DIf, pDevice->StreamSourceInfo[stream].uiOffset, pDevice->StreamSourceInfo[stream].uiStride);
                 Assert(hr == S_OK);
             }
@@ -2365 +2397 @@
 //                vboxVDbgMpPrint((pDevice, __FUNCTION__": DrawPrimitive\n"));
 
-                hr = pDevice->pDevice9If->DrawPrimitive(pData->PrimitiveType, pData->FirstVertexOffset/pDevice->StreamSourceInfo[stream].uiStride, pData->PrimitiveCount);
+                hr = pScreen->pDevice9If->DrawPrimitive(pData->PrimitiveType, pData->FirstVertexOffset/pDevice->StreamSourceInfo[stream].uiStride, pData->PrimitiveCount);
                 Assert(hr == S_OK);
             }
@@ -2417 +2449 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     PVBOXWDDMDISP_RESOURCE pDstRc = (PVBOXWDDMDISP_RESOURCE)pData->hDstResource;
     PVBOXWDDMDISP_RESOURCE pSrcRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
@@ -2439 +2473 @@
                 && pData->SrcRect.bottom - pData->SrcRect.top == pSrcRc->aAllocations[0].SurfDesc.height)
         {
-            hr = pDevice->pDevice9If->UpdateTexture(pD3DIfSrcTex, pD3DIfDstTex);
+            hr = pScreen->pDevice9If->UpdateTexture(pD3DIfSrcTex, pD3DIfDstTex);
             Assert(hr == S_OK);
         }
@@ -2487 +2521 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
-    HRESULT hr = pDevice->pDevice9If->Clear(NumRect, (D3DRECT*)pRect /* see AssertCompile above */,
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
+    HRESULT hr = pScreen->pDevice9If->Clear(NumRect, (D3DRECT*)pRect /* see AssertCompile above */,
             pData->Flags,
             pData->FillColor,
@@ -2518 +2554 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
-    HRESULT hr = pDevice->pDevice9If->SetVertexShaderConstantF(
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
+    HRESULT hr = pScreen->pDevice9If->SetVertexShaderConstantF(
             pData->Register,
             (CONST float*)pRegisters,
@@ -2546 +2584 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     pDevice->ViewPort.X = pData->X;
     pDevice->ViewPort.Y = pData->Y;
     pDevice->ViewPort.Width = pData->Width;
     pDevice->ViewPort.Height = pData->Height;
-    HRESULT hr = pDevice->pDevice9If->SetViewport(&pDevice->ViewPort);
+    HRESULT hr = pScreen->pDevice9If->SetViewport(&pDevice->ViewPort);
     Assert(hr == S_OK);
     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
@@ -2561 +2601 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     pDevice->ViewPort.MinZ = pData->MinZ;
     pDevice->ViewPort.MaxZ = pData->MaxZ;
-    HRESULT hr = pDevice->pDevice9If->SetViewport(&pDevice->ViewPort);
+    HRESULT hr = pScreen->pDevice9If->SetViewport(&pDevice->ViewPort);
     Assert(hr == S_OK);
     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
@@ -2602 +2644 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
-    HRESULT hr = pDevice->pDevice9If->SetClipPlane(pData->Index, pData->Plane);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
+    HRESULT hr = pScreen->pDevice9If->SetClipPlane(pData->Index, pData->Plane);
     Assert(hr == S_OK);
     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
@@ -2651 +2695 @@
     if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
     {
-        Assert(pRc != pDevice->pRenderTargetRc || pDevice->iRenderTargetFrontBuf != pData->SubResourceIndex);
+        PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+
+        Assert(pRc != pScreen->pRenderTargetRc || pScreen->iRenderTargetFrontBuf != pData->SubResourceIndex);
 
         if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE)
@@ -3330 +3376 @@
             if (pResource->Flags.ZBuffer)
             {
-                Assert(pDevice->pDevice9If);
+                PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+                Assert(pScreen->hWnd);
+                Assert(pScreen->pDevice9If);
                 for (UINT i = 0; i < pResource->SurfCount; ++i)
                 {
                     PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
                     IDirect3DSurface9 *pD3D9Surf;
-                    hr = pDevice->pDevice9If->CreateDepthStencilSurface(pAllocation->SurfDesc.width,
+                    hr = pScreen->pDevice9If->CreateDepthStencilSurface(pAllocation->SurfDesc.width,
                             pAllocation->SurfDesc.height,
                             vboxDDI2D3DFormat(pResource->Format),
@@ -3364 +3412 @@
             else if (pResource->Flags.VertexBuffer)
             {
-                Assert(pDevice->pDevice9If);
+                PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+                Assert(pScreen->hWnd);
+                Assert(pScreen->pDevice9If);
                 for (UINT i = 0; i < pResource->SurfCount; ++i)
                 {
                     PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
                     IDirect3DVertexBuffer9  *pD3D9VBuf;
-                    hr = pDevice->pDevice9If->CreateVertexBuffer(pAllocation->SurfDesc.width,
+                    hr = pScreen->pDevice9If->CreateVertexBuffer(pAllocation->SurfDesc.width,
                             vboxDDI2D3DUsage(pResource->Flags),
                             pResource->Fvf,
@@ -3412 +3462 @@
             else if (pResource->Flags.IndexBuffer)
             {
-                Assert(pDevice->pDevice9If);
+                PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+                Assert(pScreen->hWnd);
+                Assert(pScreen->pDevice9If);
                 for (UINT i = 0; i < pResource->SurfCount; ++i)
                 {
@@ -3418 +3470 @@
                     CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
                     IDirect3DIndexBuffer9  *pD3D9IBuf;
-                    hr = pDevice->pDevice9If->CreateIndexBuffer(pSurf->Width,
+                    hr = pScreen->pDevice9If->CreateIndexBuffer(pSurf->Width,
                             vboxDDI2D3DUsage(pResource->Flags),
                             vboxDDI2D3DFormat(pResource->Format),
@@ -3462 +3514 @@
             else if (pResource->Flags.Texture || pResource->Flags.Value == 0)
             {
-                Assert(pDevice->pDevice9If);
+                PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+                Assert(pScreen->hWnd);
+                Assert(pScreen->pDevice9If);
 #ifdef DEBUG
                 {
@@ -3486 +3540 @@
                 HANDLE hSharedHandle = NULL;
 #if 0
-                hr = pDevice->pDevice9If->CreateTexture(pSurf->Width,
+                hr = pScreen->pDevice9If->CreateTexture(pSurf->Width,
                                             pSurf->Height,
                                             pResource->SurfCount,
@@ -3496 +3550 @@
                                             );
 #else
-                hr = pDevice->pAdapter->D3D.pfnVBoxWineExD3DDev9CreateTexture((IDirect3DDevice9Ex *)pDevice->pDevice9If,
+                hr = pDevice->pAdapter->D3D.pfnVBoxWineExD3DDev9CreateTexture((IDirect3DDevice9Ex *)pScreen->pDevice9If,
                                             pSurf->Width,
                                             pSurf->Height,
@@ -3556 +3610 @@
                 bIssueCreateResource = true;
                 Assert(pResource->SurfCount);
-                if (!pDevice->pDevice9If)
-                {
-                    Assert(!pDevice->hWnd);
+                IDirect3DDevice9 *pPrimaryDevice = pDevice->aScreens[pDevice->iPrimaryScreen].pDevice9If;
+                if (!pPrimaryDevice || pResource->Flags.Primary)
+                {
+                    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pResource->VidPnSourceId];
+                    Assert(!pScreen->pDevice9If);
+                    Assert(!pScreen->hWnd);
                     hr = VBoxDispWndCreate(pAdapter, pResource->pSurfList[0].Width, pResource->pSurfList[0].Height, &hWnd);
                     Assert(hr == S_OK);
                     if (hr == S_OK)
                     {
+                        pScreen->hWnd = hWnd;
+
                         DWORD fFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;
                         if (pDevice->fFlags.AllowMultithreading)
@@ -3574 +3633 @@
                         params.BackBufferFormat = vboxDDI2D3DFormat(pResource->Format);
                         Assert(pResource->SurfCount);
-                        params.BackBufferCount = pResource->SurfCount - 1;
+                        params.BackBufferCount = !pPrimaryDevice ? pResource->SurfCount - 1 : 0;
                         params.MultiSampleType = vboxDDI2D3DMultiSampleType(pResource->MultisampleType);
                         if (pResource->Flags.DiscardRenderTarget)
@@ -3591 +3650 @@
                         if (hr == S_OK)
                         {
-                            pDevice->pDevice9If = pDevice9If;
-                            pDevice->hWnd = hWnd;
-                            pDevice->pRenderTargetRc = pRc;
+                            pScreen->pDevice9If = pDevice9If;
+                            pScreen->pRenderTargetRc = pRc;
+                            ++pDevice->cScreens;
 
                             for (UINT i = 0; i < pResource->SurfCount; ++i)
@@ -3601 +3660 @@
                             }
 
-                            hr = vboxWddmRenderTargetUpdate(pDevice, pRc, 0);
-                            Assert(hr == S_OK);
-                            if (hr == S_OK)
+                            if (pPrimaryDevice)
                             {
                                 for (UINT i = 0; i < pResource->SurfCount; ++i)
                                 {
                                     PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
-                                    pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE;
-                                    hr = vboxWddmSurfSynchMem(pRc, pAllocation);
-                                    Assert(hr == S_OK);
-                                    if (hr != S_OK)
-                                    {
-                                        break;
-                                    }
-                                }
-
-#ifndef VBOXWDDM_WITH_VISIBLE_FB
-                                if (hr == S_OK)
-                                {
-                                    IDirect3DSurface9* pD3D9Surf;
-                                    hr = pDevice->pDevice9If->CreateRenderTarget(pRc->aAllocations[0].SurfDesc.width,
-                                            pRc->aAllocations[0].SurfDesc.height,
+                                    IDirect3DSurface9 *pRt;
+                                    IDirect3DSurface9 *pSecondaryOpenedRt;
+                                    HANDLE hSharedHandle = NULL;
+                                    hr = pPrimaryDevice->CreateRenderTarget(
+                                            pResource->pSurfList[i].Width,
+                                            pResource->pSurfList[i].Height,
                                             vboxDDI2D3DFormat(pResource->Format),
                                             vboxDDI2D3DMultiSampleType(pResource->MultisampleType),
-                                            pResource->MultisampleQuality,
-                                            !pResource->Flags.NotLockable /* BOOL Lockable */,
-                                            &pD3D9Surf,
-                                            NULL /* HANDLE* pSharedHandle */
-                                            );
+                                            0, /*DWORD MultisampleQuality*/
+                                            TRUE, /*BOOL Lockable*/
+                                            &pRt,
+                                            &hSharedHandle);
                                     Assert(hr == S_OK);
                                     if (hr == S_OK)
                                     {
-                                        pDevice->pRenderTargetFbCopy = pD3D9Surf;
+                                        Assert(hSharedHandle != NULL);
+                                        /* open render target for primary device */
+                                        hr = pDevice9If->CreateRenderTarget(
+                                                    pResource->pSurfList[i].Width,
+                                                    pResource->pSurfList[i].Height,
+                                                    vboxDDI2D3DFormat(pResource->Format),
+                                                    vboxDDI2D3DMultiSampleType(pResource->MultisampleType),
+                                                    0, /*DWORD MultisampleQuality*/
+                                                    TRUE, /*BOOL Lockable*/
+                                                    &pSecondaryOpenedRt,
+                                                    &hSharedHandle);
+                                        Assert(hr == S_OK);
+                                        if (hr == S_OK)
+                                        {
+                                            pAllocation->pD3DIf = pRt;
+                                            pAllocation->pSecondaryOpenedD3DIf = pSecondaryOpenedRt;
+                                            pAllocation->hSharedHandle = hSharedHandle;
+                                            continue;
+                                        }
+                                        pRt->Release();
                                     }
+
+                                    for (UINT j = 0; j < i; ++j)
+                                    {
+                                        PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[j];
+                                        pAlloc->pD3DIf->Release();
+                                        pAlloc->pSecondaryOpenedD3DIf->Release();
+                                    }
+
+                                    break;
                                 }
-#endif
-
-                                if (hr != S_OK)
+                            }
+                            else
+                            {
+                                pDevice->iPrimaryScreen = pResource->VidPnSourceId;
+                            }
+
+                            if (hr == S_OK)
+                            {
+                                hr = vboxWddmRenderTargetUpdate(pDevice, pRc, 0);
+                                Assert(hr == S_OK);
+                                if (hr == S_OK)
                                 {
                                     for (UINT i = 0; i < pResource->SurfCount; ++i)
                                     {
                                         PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
-                                        pAllocation->pD3DIf->Release();
+                                        pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE;
+                                        hr = vboxWddmSurfSynchMem(pRc, pAllocation);
+                                        Assert(hr == S_OK);
+                                        if (hr != S_OK)
+                                        {
+                                            break;
+                                        }
+                                    }
+
+#ifndef VBOXWDDM_WITH_VISIBLE_FB
+                                    if (!pPrimaryDevice)
+                                    {
+                                        if (hr == S_OK)
+                                        {
+                                            IDirect3DSurface9* pD3D9Surf;
+                                            hr = pDevice9If->CreateRenderTarget(pRc->aAllocations[0].SurfDesc.width,
+                                                    pRc->aAllocations[0].SurfDesc.height,
+                                                    vboxDDI2D3DFormat(pResource->Format),
+                                                    vboxDDI2D3DMultiSampleType(pResource->MultisampleType),
+                                                    pResource->MultisampleQuality,
+                                                    !pResource->Flags.NotLockable /* BOOL Lockable */,
+                                                    &pD3D9Surf,
+                                                    NULL /* HANDLE* pSharedHandle */
+                                                    );
+                                            Assert(hr == S_OK);
+                                            if (hr == S_OK)
+                                            {
+                                                pDevice->pRenderTargetFbCopy = pD3D9Surf;
+                                            }
+                                        }
+                                    }
+#endif
+
+                                    if (hr != S_OK)
+                                    {
+                                        for (UINT i = 0; i < pResource->SurfCount; ++i)
+                                        {
+                                            PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
+                                            pAllocation->pD3DIf->Release();
+                                        }
                                     }
                                 }
@@ -3649 +3771 @@
 
                             if (hr != S_OK)
+                            {
                                 pDevice9If->Release();
+                                --pDevice->cScreens;
+                                Assert(pDevice->cScreens < UINT32_MAX/2);
+                            }
                         }
 
                         if (hr != S_OK)
                         {
-                            HRESULT tmpHr = VBoxDispWndDestroy(pAdapter, pDevice->hWnd);
+                            HRESULT tmpHr = VBoxDispWndDestroy(pAdapter, pScreen->hWnd);
                             Assert(tmpHr == S_OK);
                         }
                     }
+
+
                 }
                 else
                 {
-                    Assert(pDevice->hWnd);
-                    Assert(pDevice->pDevice9If);
+                    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+                    Assert(pScreen->hWnd);
+                    Assert(pScreen->pDevice9If);
                     for (UINT i = 0; i < pResource->SurfCount; ++i)
                     {
@@ -3668 +3797 @@
 
                         IDirect3DSurface9* pD3D9Surf;
-                        hr = pDevice->pDevice9If->CreateRenderTarget(pAllocation->SurfDesc.width,
+                        hr = pScreen->pDevice9If->CreateRenderTarget(pAllocation->SurfDesc.width,
                                 pAllocation->SurfDesc.height,
                                 vboxDDI2D3DFormat(pResource->Format),
@@ -3702 +3831 @@
             else
             {
-                Assert(pDevice->pDevice9If);
+                PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+                Assert(pScreen->hWnd);
+                Assert(pScreen->pDevice9If);
                 Assert(0);
             }
         }
         else
+        {
             bIssueCreateResource = true;
+        }
 
 
@@ -3828 +3961 @@
     if (VBOXDISPMODE_IS_3D(pAdapter))
     {
-        if (pRc->RcDesc.fFlags.RenderTarget)
-        {
-            Assert(pDevice->hWnd);
-            Assert(pDevice->pDevice9If);
-        }
+//        if (pRc->RcDesc.fFlags.RenderTarget)
+//        {
+//            Assert(pDevice->hWnd);
+//            Assert(pDevice->pDevice9If);
+//        }
 
         for (UINT i = 0; i < pRc->cAllocations; ++i)
@@ -3839 +3972 @@
             if (pAlloc->pD3DIf)
                 pAlloc->pD3DIf->Release();
+            if (pAlloc->pSecondaryOpenedD3DIf)
+                pAlloc->pSecondaryOpenedD3DIf->Release();
         }
     }
@@ -3883 +4018 @@
     PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
     Assert(pRc->RcDesc.fFlags.RenderTarget);
+    Assert(pRc->RcDesc.fFlags.Primary);
     Assert(pAlloc->enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE);
     Assert(pAlloc->hAllocation);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pRc->RcDesc.VidPnSourceId];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     D3DDDICB_SETDISPLAYMODE DdiDm = {0};
     DdiDm.hPrimaryAllocation = pAlloc->hAllocation;
 //    DdiDm.PrivateDriverFormatAttribute = 0;
-    Assert(pDevice->pRenderTargetRc == pRc);
-    Assert(pDevice->iRenderTargetFrontBuf == pData->SubResourceIndex);
+    Assert(pScreen->pRenderTargetRc == pRc);
+    Assert(pScreen->iRenderTargetFrontBuf == pData->SubResourceIndex);
 
 #if 0
-    IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pAlloc->pD3DIf;
-    hr = pDevice->pDevice9If->SetRenderTarget(0, pD3DIfSurf);
+    IDirect3DSurface9 *pSoD3DIfSurf = (IDirect3DSurface9*)pAlloc->pSecondaryOpenedD3DIf;
+    hr = pScreen->pDevice9If->SetRenderTarget(0, pSoD3DIfSurf);
     Assert(hr == S_OK);
     if (hr == S_OK)
@@ -3913 +4052 @@
     if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
     {
-        Assert(pDevice->pDevice9If);
+        PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
+        Assert(pRc);
+        PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pRc->RcDesc.VidPnSourceId];
+        Assert(pScreen->hWnd);
+        Assert(pScreen->pDevice9If);
+        Assert(pRc == pScreen->pRenderTargetRc);
 #if 1
         VBOXVDBG_RTGT_STATECHECK(pDevice);
 
-        hr = pDevice->pDevice9If->Present(NULL, /* CONST RECT * pSourceRect */
+        if (pRc->RcDesc.VidPnSourceId != pDevice->iPrimaryScreen)
+        {
+            PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SrcSubResourceIndex];
+            IDirect3DSurface9 *pSecondaryRt;
+            IDirect3DSurface9 *pDataRt = (IDirect3DSurface9*)pAlloc->pSecondaryOpenedD3DIf;
+            Assert(pDataRt);
+            Assert(pAlloc->enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE);
+            hr = pScreen->pDevice9If->GetRenderTarget(0, &pSecondaryRt);
+            Assert(hr == S_OK);
+            if (hr == S_OK)
+            {
+                hr = pScreen->pDevice9If->StretchRect(pDataRt,
+                                    NULL,
+                                    pSecondaryRt,
+                                    NULL,
+                                    D3DTEXF_NONE);
+                pSecondaryRt->Release();
+            }
+        }
+
+        hr = pScreen->pDevice9If->Present(NULL, /* CONST RECT * pSourceRect */
                 NULL, /* CONST RECT * pDestRect */
                 NULL, /* HWND hDestWindowOverride */
@@ -3933 +4097 @@
             Assert(pData->hSrcResource);
             PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
-            Assert(pDevice->pRenderTargetRc == pRc);
+            PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pRc->RcDesc.VidPnSourceId];
+            Assert(pScreen->hWnd);
+            Assert(pScreen->pDevice9If);
+            Assert(pScreen->pRenderTargetRc == pRc);
             Assert(pRc->cAllocations >= 2);
             Assert(pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE);
             Assert(pRc->RcDesc.fFlags.RenderTarget);
-            uint32_t iNewRTFB = (pDevice->iRenderTargetFrontBuf + 1) % pRc->cAllocations;
-
-            Assert(pDevice->iRenderTargetFrontBuf != iNewRTFB);
+            uint32_t iNewRTFB = (pScreen->iRenderTargetFrontBuf + 1) % pRc->cAllocations;
+
+            Assert(pScreen->iRenderTargetFrontBuf != iNewRTFB);
             Assert(pData->SrcSubResourceIndex == iNewRTFB);
 
@@ -3945 +4112 @@
 
             /* assign a new frontbuffer index */
-            pDevice->iRenderTargetFrontBuf = iNewRTFB;
+            pScreen->iRenderTargetFrontBuf = iNewRTFB;
 
             VBOXVDBG_RTGT_STATECHECK(pDevice);
@@ -3986 +4153 @@
     if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
     {
-        Assert(pDevice->pDevice9If);
-#if 0
-        hr = pDevice->pDevice9If->Present(NULL, /* CONST RECT * pSourceRect */
-                NULL, /* CONST RECT * pDestRect */
-                NULL, /* HWND hDestWindowOverride */
-                NULL /*CONST RGNDATA * pDirtyRegion */
-                );
-        Assert(hr == S_OK);
-#endif
+        Assert(pDevice->cScreens);
+        for (UINT i = 0; i < RT_ELEMENTS(pDevice->aScreens); ++i)
+        {
+            PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[i];
+            if (pScreen->pDevice9If)
+            {
+                /* @todo: make a flush */
+            }
+        }
     }
     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
@@ -4020 +4187 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     IDirect3DVertexDeclaration9 *pDecl;
     static D3DVERTEXELEMENT9 DeclEnd = D3DDECL_END();
@@ -4043 +4212 @@
     if (hr == S_OK)
     {
-        hr = pDevice->pDevice9If->CreateVertexDeclaration(
+        hr = pScreen->pDevice9If->CreateVertexDeclaration(
                 pVe,
                 &pDecl
@@ -4066 +4235 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     IDirect3DVertexDeclaration9 *pDecl = (IDirect3DVertexDeclaration9*)hShaderHandle;
     Assert(pDecl);
-    HRESULT hr = pDevice->pDevice9If->SetVertexDeclaration(pDecl);
+    HRESULT hr = pScreen->pDevice9If->SetVertexDeclaration(pDecl);
     Assert(hr == S_OK);
     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
@@ -4079 +4250 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     IDirect3DVertexDeclaration9 *pDecl = (IDirect3DVertexDeclaration9*)hShaderHandle;
     HRESULT hr = S_OK;
@@ -4091 +4264 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     IDirect3DVertexShader9 *pShader;
     Assert(*((UINT*)((uint8_t*)pCode + pData->Size-4)) == 0x0000FFFF /* end token */);
-    HRESULT hr = pDevice->pDevice9If->CreateVertexShader((const DWORD *)pCode, &pShader);
+    HRESULT hr = pScreen->pDevice9If->CreateVertexShader((const DWORD *)pCode, &pShader);
     Assert(hr == S_OK);
     if (hr == S_OK)
@@ -4109 +4284 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     IDirect3DVertexShader9 *pShader = (IDirect3DVertexShader9*)hShaderHandle;
     Assert(pShader);
-    HRESULT hr = pDevice->pDevice9If->SetVertexShader(pShader);
+    HRESULT hr = pScreen->pDevice9If->SetVertexShader(pShader);
     Assert(hr == S_OK);
     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
@@ -4122 +4299 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     IDirect3DVertexShader9 *pShader = (IDirect3DVertexShader9*)hShaderHandle;
     HRESULT hr = S_OK;
@@ -4134 +4313 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
-    HRESULT hr = pDevice->pDevice9If->SetVertexShaderConstantI(pData->Register, pRegisters, pData->Count);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
+    HRESULT hr = pScreen->pDevice9If->SetVertexShaderConstantI(pData->Register, pRegisters, pData->Count);
     Assert(hr == S_OK);
     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
@@ -4145 +4326 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
-    HRESULT hr = pDevice->pDevice9If->SetVertexShaderConstantB(pData->Register, pRegisters, pData->Count);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
+    HRESULT hr = pScreen->pDevice9If->SetVertexShaderConstantB(pData->Register, pRegisters, pData->Count);
     Assert(hr == S_OK);
     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
@@ -4156 +4339 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
-    HRESULT hr = pDevice->pDevice9If->SetScissorRect(pRect);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
+    HRESULT hr = pScreen->pDevice9If->SetScissorRect(pRect);
     Assert(hr == S_OK);
     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
@@ -4167 +4352 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hVertexBuffer;
     PVBOXWDDMDISP_ALLOCATION pAlloc = NULL;
@@ -4178 +4365 @@
         pStreamData = (IDirect3DVertexBuffer9*)pAlloc->pD3DIf;
     }
-    HRESULT hr = pDevice->pDevice9If->SetStreamSource(pData->Stream, pStreamData, pData->Offset, pData->Stride);
+    HRESULT hr = pScreen->pDevice9If->SetStreamSource(pData->Stream, pStreamData, pData->Offset, pData->Stride);
     Assert(hr == S_OK);
     Assert(pData->Stream<VBOXWDDMDISP_MAX_VERTEX_STREAMS);
@@ -4329 +4516 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     PVBOXWDDMDISP_RESOURCE pDstRc = (PVBOXWDDMDISP_RESOURCE)pData->hDstResource;
     PVBOXWDDMDISP_RESOURCE pSrcRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
     Assert(pDstRc->cAllocations > pData->DstSubResourceIndex);
     Assert(pSrcRc->cAllocations > pData->SrcSubResourceIndex);
-    Assert(pDstRc != pDevice->pRenderTargetRc || pDevice->iRenderTargetFrontBuf != pData->DstSubResourceIndex);
+    Assert(pDstRc != pScreen->pRenderTargetRc || pScreen->iRenderTargetFrontBuf != pData->DstSubResourceIndex);
     HRESULT hr = S_OK;
     /* try StretchRect */
@@ -4347 +4536 @@
         {
 #ifndef VBOXWDDM_WITH_VISIBLE_FB
-            if (pSrcRc == pDevice->pRenderTargetRc && pDevice->iRenderTargetFrontBuf == pData->SrcSubResourceIndex)
+            if (pSrcRc == pScreen->pRenderTargetRc && pScreen->iRenderTargetFrontBuf == pData->SrcSubResourceIndex)
             {
                 PVBOXWDDMDISP_ALLOCATION pSrcAlloc = &pSrcRc->aAllocations[pData->SrcSubResourceIndex];
@@ -4378 +4567 @@
                         && pSrcAlloc->SurfDesc.format == pDstAlloc->SurfDesc.format)
                 {
-                    hr = pDevice->pDevice9If->GetFrontBufferData(0, pDstSurfIf);
+                    hr = pScreen->pDevice9If->GetFrontBufferData(0, pDstSurfIf);
                     Assert(hr == S_OK);
                     break;
@@ -4387 +4576 @@
                     pSrcSurfIf = pDevice->pRenderTargetFbCopy;
                     Assert(pSrcSurfIf);
-                    hr = pDevice->pDevice9If->GetFrontBufferData(0, pDevice->pRenderTargetFbCopy);
+                    hr = pScreen->pDevice9If->GetFrontBufferData(0, pDevice->pRenderTargetFbCopy);
                     Assert(hr == S_OK);
                     if (hr == S_OK)
@@ -4445 +4634 @@
                 /* we support only Point & Linear, we ignore [Begin|Continue|End]PresentToDwm */
                 Assert((pData->Flags.Value & (~(0x00000100 | 0x00000200 | 0x00000400 | 0x00000001  | 0x00000002))) == 0);
-                hr = pDevice->pDevice9If->StretchRect(pSrcSurfIf,
+                hr = pScreen->pDevice9If->StretchRect(pSrcSurfIf,
                                     &pData->SrcRect,
                                     pDstSurfIf,
@@ -4494 +4683 @@
                     )
             {
-                hr = pDevice->pDevice9If->UpdateTexture(pD3DIfSrcTex, pD3DIfDstTex);
+                hr = pScreen->pDevice9If->UpdateTexture(pD3DIfSrcTex, pD3DIfDstTex);
                 Assert(hr == S_OK);
             }
@@ -4585 +4774 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
     Assert(pRc);
@@ -4594 +4785 @@
     {
         Assert(pSurfIf);
-        hr = pDevice->pDevice9If->ColorFill(pSurfIf, &pData->DstRect, pData->Color);
+        hr = pScreen->pDevice9If->ColorFill(pSurfIf, &pData->DstRect, pData->Color);
         Assert(hr == S_OK);
         /* @todo: check what need to do when PresentToDwm flag is set */
@@ -4644 +4835 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hRenderTarget;
     Assert(pRc);
     Assert(pData->SubResourceIndex < pRc->cAllocations);
-    if (pRc == pDevice->pRenderTargetRc)
+    PVBOXWDDMDISP_SCREEN pVisibleScreen = pRc->RcDesc.fFlags.Primary ? &pDevice->aScreens[pRc->RcDesc.VidPnSourceId] : pScreen;
+    if (pRc == pVisibleScreen->pRenderTargetRc)
     {
         /* backbuffer */
-        Assert(pData->SubResourceIndex == ((pDevice->iRenderTargetFrontBuf + 1) % pDevice->pRenderTargetRc->cAllocations));
+        Assert(pData->SubResourceIndex == ((pVisibleScreen->iRenderTargetFrontBuf + 1) % pVisibleScreen->pRenderTargetRc->cAllocations));
     }
 
     HRESULT hr = S_OK;
     IDirect3DSurface9 *pD3D9Surf;
-    if (pRc == pDevice->pRenderTargetRc && pRc->cAllocations == 1 && pData->RenderTargetIndex == 0)
+    if (pRc == pScreen->pRenderTargetRc && pRc->cAllocations == 1 && pData->RenderTargetIndex == 0)
     {
         /* work-around wine double-buffering for the case we have no backbuffers */
-        hr = pDevice->pDevice9If->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pD3D9Surf);
+        hr = pScreen->pDevice9If->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pD3D9Surf);
         Assert(hr == S_OK);
         Assert(pD3D9Surf);
@@ -4672 +4866 @@
     {
         Assert(pD3D9Surf);
-        hr = pDevice->pDevice9If->SetRenderTarget(pData->RenderTargetIndex, pD3D9Surf);
+        hr = pScreen->pDevice9If->SetRenderTarget(pData->RenderTargetIndex, pD3D9Surf);
         Assert(hr == S_OK);
         pD3D9Surf->Release();
@@ -4684 +4878 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hZBuffer;
     IDirect3DSurface9 *pD3D9Surf = NULL;
@@ -4693 +4889 @@
         Assert(pD3D9Surf);
     }
-    HRESULT hr = pDevice->pDevice9If->SetDepthStencilSurface(pD3D9Surf);
+    HRESULT hr = pScreen->pDevice9If->SetDepthStencilSurface(pD3D9Surf);
     Assert(hr == S_OK);
     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
@@ -4710 +4906 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
-    HRESULT hr = pDevice->pDevice9If->SetPixelShaderConstantI(pData->Register, pRegisters, pData->Count);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
+    HRESULT hr = pScreen->pDevice9If->SetPixelShaderConstantI(pData->Register, pRegisters, pData->Count);
     Assert(hr == S_OK);
     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
@@ -4721 +4919 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
-    HRESULT hr = pDevice->pDevice9If->SetPixelShaderConstantB(pData->Register, pRegisters, pData->Count);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
+    HRESULT hr = pScreen->pDevice9If->SetPixelShaderConstantB(pData->Register, pRegisters, pData->Count);
     Assert(hr == S_OK);
     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
@@ -4732 +4932 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     IDirect3DPixelShader9 *pShader;
     Assert(*((UINT*)((uint8_t*)pCode + pData->CodeSize-4)) == 0x0000FFFF /* end token */);
-    HRESULT hr = pDevice->pDevice9If->CreatePixelShader((const DWORD *)pCode, &pShader);
+    HRESULT hr = pScreen->pDevice9If->CreatePixelShader((const DWORD *)pCode, &pShader);
     Assert(hr == S_OK);
     if (hr == S_OK)
@@ -4750 +4952 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     Assert(pDevice);
-    Assert(pDevice->pDevice9If);
+    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+    Assert(pScreen->hWnd);
+    Assert(pScreen->pDevice9If);
     IDirect3DPixelShader9 *pShader = (IDirect3DPixelShader9*)hShaderHandle;
     HRESULT hr = S_OK;
@@ -4875 +5079 @@
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter;
-    if (pDevice->pDevice9If)
-    {
+//    Assert(!pDevice->cScreens);
 #ifndef VBOXWDDM_WITH_VISIBLE_FB
+    if(pDevice->pRenderTargetFbCopy)
         pDevice->pRenderTargetFbCopy->Release();
 #endif
-        pDevice->pDevice9If->Release();
-        Assert(pDevice->hWnd);
-        HRESULT tmpHr = VBoxDispWndDestroy(pAdapter, pDevice->hWnd);
-        Assert(tmpHr == S_OK);
-    }
+    for (UINT i = 0; i < RT_ELEMENTS(pDevice->aScreens); ++i)
+    {
+        PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[i];
+        if (pScreen->pDevice9If)
+        {
+            pScreen->pDevice9If->Release();
+            Assert(pScreen->hWnd);
+            HRESULT tmpHr = VBoxDispWndDestroy(pAdapter, pScreen->hWnd);
+            Assert(tmpHr == S_OK);
+        }
+    }
+
     HRESULT hr = vboxDispCmCtxDestroy(pDevice, &pDevice->DefaultContext);
     Assert(hr == S_OK);
@@ -5215 +5426 @@
                 if (pRc->RcDesc.fFlags.Texture)
                 {
-                    Assert(pDevice->pDevice9If);
-
+                    PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
+                    Assert(pScreen->hWnd);
+                    Assert(pScreen->pDevice9If);
                     PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0];
                     IDirect3DTexture9 *pD3DIfTex;
@@ -5222 +5434 @@
                     Assert(pAllocation->hSharedHandle);
 
-                    hr = pDevice->pAdapter->D3D.pfnVBoxWineExD3DDev9CreateTexture((IDirect3DDevice9Ex *)pDevice->pDevice9If,
+                    hr = pDevice->pAdapter->D3D.pfnVBoxWineExD3DDev9CreateTexture((IDirect3DDevice9Ex *)pScreen->pDevice9If,
                                                 pAllocation->SurfDesc.width,
                                                 pAllocation->SurfDesc.height,
@@ -5673 +5885 @@
     Assert(pRc->cAllocations > iAlloc);
     PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[iAlloc];
+    BOOL bPrimary = pRc->RcDesc.fFlags.Primary;
+    BOOL bFrontBuf = FALSE;
+    if (bPrimary)
+    {
+        PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pRc->RcDesc.VidPnSourceId];
+        Assert(pRc == pScreen->pRenderTargetRc);
+        bFrontBuf = (iAlloc == pScreen->iRenderTargetFrontBuf);
+    }
     vboxVDbgDoMpPrintF(pDevice, "%s width(%d), height(%d), format(%d), usage(%s), %s", pPrefix,
             pAlloc->SurfDesc.width, pAlloc->SurfDesc.height, pAlloc->SurfDesc.format,
-            pRc == pDevice->pRenderTargetRc ?
-                    (iAlloc == pDevice->iRenderTargetFrontBuf ? "Front Buffer" : "Back Buffer")
+            bPrimary ?
+                    (bFrontBuf ? "Front Buffer" : "Back Buffer")
                     : "?Everage? Alloc",
             pSuffix);

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.h

@@ -91 +91 @@
 } VBOXWDDMDISP_INDICES_INFO;
 
+typedef struct VBOXWDDMDISP_SCREEN
+{
+    IDirect3DDevice9 *pDevice9If;
+    struct VBOXWDDMDISP_RESOURCE *pRenderTargetRc;
+    uint32_t iRenderTargetFrontBuf;
+    HWND hWnd;
+} VBOXWDDMDISP_SCREEN, *PVBOXWDDMDISP_SCREEN;
+
 typedef struct VBOXWDDMDISP_DEVICE
 {
@@ -101 +109 @@
     UINT cbCmdBuffer;
     D3DDDI_CREATEDEVICEFLAGS fFlags;
-    HWND hWnd;
 #ifndef VBOXWDDM_WITH_VISIBLE_FB
     IDirect3DSurface9 *pRenderTargetFbCopy;
 #endif
-    struct VBOXWDDMDISP_RESOURCE *pRenderTargetRc;
-    uint32_t iRenderTargetFrontBuf;
     /* number of StreamSources set */
     UINT cStreamSources;
@@ -115 +120 @@
     VBOXWDDMDISP_ALLOCATION *pIndicesAlloc;
     VBOXWDDMDISP_INDICES_INFO IndiciesInfo;
-    IDirect3DDevice9 *pDevice9If;
     /* need to cache the ViewPort data because IDirect3DDevice9::SetViewport
      * is split into two calls : SetViewport & SetZRange */
     D3DVIEWPORT9 ViewPort;
     VBOXWDDMDISP_CONTEXT DefaultContext;
+
+    UINT iPrimaryScreen;
+    UINT cScreens;
+    VBOXWDDMDISP_SCREEN aScreens[VBOX_VIDEO_MAX_SCREENS];
 } VBOXWDDMDISP_DEVICE, *PVBOXWDDMDISP_DEVICE;
 
@@ -150 +158 @@
     /* object type is defined by enmD3DIfType enum */
     IUnknown *pD3DIf;
+    IUnknown *pSecondaryOpenedD3DIf;
     VBOXDISP_D3DIFTYPE enmD3DIfType;
     HANDLE hSharedHandle;

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispMp.cpp

@@ -138 +138 @@
         Assert(pHdr);
         VBOXWDDMDISP_CONTEXT *pContext = (VBOXWDDMDISP_CONTEXT*)pHdr->u64UmData;
-        Assert(pContext->pDevice->hWnd);
-        pRegions->hWnd = pContext->pDevice->hWnd;
-        pRegions->pRegions = (PVBOXVIDEOCM_CMD_RECTS)(((uint8_t*)pHdr) + sizeof (VBOXVIDEOCM_CMD_HDR));
+        PVBOXVIDEOCM_CMD_RECTS_INTERNAL pCmdInternal = (PVBOXVIDEOCM_CMD_RECTS_INTERNAL)(((uint8_t*)pHdr) + sizeof (VBOXVIDEOCM_CMD_HDR));
+        UINT iScreen = pContext->pDevice->cScreens == 1 ? pContext->pDevice->iPrimaryScreen : pCmdInternal->VidPnSourceId;
+        PVBOXWDDMDISP_SCREEN pScreen = &pContext->pDevice->aScreens[iScreen];
+        Assert(pScreen->hWnd);
+        Assert(pScreen->pDevice9If);
+        pRegions->hWnd = pScreen->hWnd;
+        pRegions->pRegions = &pCmdInternal->Cmd;
     }
     return hr;

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoIf.h

@@ -28 +28 @@
 
 
-/* @todo: implement a check to ensure display & miniport versions match.
- * One would increase this whenever definitions in this file are changed */
-#define VBOXVIDEOIF_VERSION 4
+/* One would increase this whenever definitions in this file are changed */
+#define VBOXVIDEOIF_VERSION 5
 
 /* create allocation func */
@@ -213 +212 @@
 } VBOXVIDEOCM_CMD_RECTS, *PVBOXVIDEOCM_CMD_RECTS;
 
-#define VBOXVIDEOCM_CMD_RECTS_SIZE4CRECTS(_cRects) (RT_OFFSETOF(VBOXVIDEOCM_CMD_RECTS, RectsInfo.aRects[(_cRects)]))
-#define VBOXVIDEOCM_CMD_RECTS_SIZE(_pCmd) (VBOXVIDEOCM_CMD_RECTS_SIZE4CRECTS((_pCmd)->cRects))
+typedef struct VBOXVIDEOCM_CMD_RECTS_INTERNAL
+{
+    D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
+    UINT u32Reserved;
+    VBOXVIDEOCM_CMD_RECTS Cmd;
+} VBOXVIDEOCM_CMD_RECTS_INTERNAL, *PVBOXVIDEOCM_CMD_RECTS_INTERNAL;
+
+#define VBOXVIDEOCM_CMD_RECTS_INTERNAL_SIZE4CRECTS(_cRects) (RT_OFFSETOF(VBOXVIDEOCM_CMD_RECTS_INTERNAL, Cmd.RectsInfo.aRects[(_cRects)]))
+#define VBOXVIDEOCM_CMD_RECTS_INTERNAL_SIZE(_pCmd) (VBOXVIDEOCM_CMD_RECTS_INTERNAL_SIZE4CRECTS((_pCmd)->cRects))
 
 typedef struct VBOXWDDM_GETVBOXVIDEOCMCMD_HDR

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVdma.cpp

@@ -310 +310 @@
     PVBOXWDDM_RECTS_INFO pRects = &pRectsInfo->ContextsRects.UpdateRects;
     NTSTATUS Status = STATUS_SUCCESS;
-    PVBOXVIDEOCM_CMD_RECTS pCmd = NULL;
-    uint32_t cbCmd = VBOXVIDEOCM_CMD_RECTS_SIZE4CRECTS(pRects->cRects);
+    PVBOXVIDEOCM_CMD_RECTS_INTERNAL pCmdInternal = NULL;
+    uint32_t cbCmdInternal = VBOXVIDEOCM_CMD_RECTS_INTERNAL_SIZE4CRECTS(pRects->cRects);
     Assert(KeGetCurrentIrql() < DISPATCH_LEVEL);
     ExAcquireFastMutex(&pDevExt->ContextMutex);
@@ -319 +319 @@
         {
             PVBOXWDDM_CONTEXT pCurContext = VBOXWDDMENTRY_2_CONTEXT(pCur);
-            if (!pCmd)
-            {
-                pCmd = (PVBOXVIDEOCM_CMD_RECTS)vboxVideoCmCmdCreate(&pCurContext->CmContext, cbCmd);
-                Assert(pCmd);
-                if (!pCmd)
+            if (!pCmdInternal)
+            {
+                pCmdInternal = (PVBOXVIDEOCM_CMD_RECTS_INTERNAL)vboxVideoCmCmdCreate(&pCurContext->CmContext, cbCmdInternal);
+                Assert(pCmdInternal);
+                if (!pCmdInternal)
                 {
                     Status = STATUS_NO_MEMORY;
@@ -331 +331 @@
             else
             {
-                pCmd = (PVBOXVIDEOCM_CMD_RECTS)vboxVideoCmCmdReinitForContext(pCmd, &pCurContext->CmContext);
+                pCmdInternal = (PVBOXVIDEOCM_CMD_RECTS_INTERNAL)vboxVideoCmCmdReinitForContext(pCmdInternal, &pCurContext->CmContext);
             }
 
-            vboxVdmaDirtyRectsCalcIntersection(&pCurContext->ViewRect, pRects, &pCmd->RectsInfo);
-            if (pCmd->RectsInfo.cRects)
+            vboxVdmaDirtyRectsCalcIntersection(&pCurContext->ViewRect, pRects, &pCmdInternal->Cmd.RectsInfo);
+            if (pCmdInternal->Cmd.RectsInfo.cRects)
             {
                 bool bSend = false;
-                pCmd->fFlags.Value = 0;
-                pCmd->fFlags.bAddHiddenRects = 1;
+                pCmdInternal->Cmd.fFlags.Value = 0;
+                pCmdInternal->Cmd.fFlags.bAddHiddenRects = 1;
                 if (pCurContext->pLastReportedRects)
                 {
-                    if (pCurContext->pLastReportedRects->fFlags.bSetVisibleRects)
+                    if (pCurContext->pLastReportedRects->Cmd.fFlags.bSetVisibleRects)
                     {
                         RECT *paPrevRects;
                         uint32_t cPrevRects;
-                        if (pCurContext->pLastReportedRects->fFlags.bSetViewRect)
+                        if (pCurContext->pLastReportedRects->Cmd.fFlags.bSetViewRect)
                         {
-                            paPrevRects = &pCurContext->pLastReportedRects->RectsInfo.aRects[1];
-                            cPrevRects = pCurContext->pLastReportedRects->RectsInfo.cRects - 1;
+                            paPrevRects = &pCurContext->pLastReportedRects->Cmd.RectsInfo.aRects[1];
+                            cPrevRects = pCurContext->pLastReportedRects->Cmd.RectsInfo.cRects - 1;
                         }
                         else
                         {
-                            paPrevRects = &pCurContext->pLastReportedRects->RectsInfo.aRects[0];
-                            cPrevRects = pCurContext->pLastReportedRects->RectsInfo.cRects;
+                            paPrevRects = &pCurContext->pLastReportedRects->Cmd.RectsInfo.aRects[0];
+                            cPrevRects = pCurContext->pLastReportedRects->Cmd.RectsInfo.cRects;
                         }
 
-                        if (vboxVdmaDirtyRectsHasIntersections(paPrevRects, cPrevRects, pCmd->RectsInfo.aRects, pCmd->RectsInfo.cRects))
+                        if (vboxVdmaDirtyRectsHasIntersections(paPrevRects, cPrevRects,
+                                pCmdInternal->Cmd.RectsInfo.aRects, pCmdInternal->Cmd.RectsInfo.cRects))
                         {
                             bSend = true;
@@ -364 +365 @@
                     else
                     {
-                        Assert(pCurContext->pLastReportedRects->fFlags.bAddHiddenRects);
-                        if (!vboxVdmaDirtyRectsIsCover(pCurContext->pLastReportedRects->RectsInfo.aRects,
-                                pCurContext->pLastReportedRects->RectsInfo.cRects,
-                                pCmd->RectsInfo.aRects, pCmd->RectsInfo.cRects))
+                        Assert(pCurContext->pLastReportedRects->Cmd.fFlags.bAddHiddenRects);
+                        if (!vboxVdmaDirtyRectsIsCover(pCurContext->pLastReportedRects->Cmd.RectsInfo.aRects,
+                                pCurContext->pLastReportedRects->Cmd.RectsInfo.cRects,
+                                pCmdInternal->Cmd.RectsInfo.aRects, pCmdInternal->Cmd.RectsInfo.cRects))
                         {
                             bSend = true;
@@ -380 +381 @@
                     if (pCurContext->pLastReportedRects)
                         vboxVideoCmCmdRelease(pCurContext->pLastReportedRects);
-                    vboxVideoCmCmdRetain(pCmd);
-                    pCurContext->pLastReportedRects = pCmd;
-                    vboxVideoCmCmdSubmit(pCmd, VBOXVIDEOCM_CMD_RECTS_SIZE4CRECTS(pCmd->RectsInfo.cRects));
-                    pCmd = NULL;
+
+                    pCmdInternal->VidPnSourceId = pRectsInfo->VidPnSourceId;
+
+                    vboxVideoCmCmdRetain(pCmdInternal);
+                    pCurContext->pLastReportedRects = pCmdInternal;
+                    vboxVideoCmCmdSubmit(pCmdInternal, VBOXVIDEOCM_CMD_RECTS_INTERNAL_SIZE4CRECTS(pCmdInternal->Cmd.RectsInfo.cRects));
+                    pCmdInternal = NULL;
                 }
             }
@@ -394 +398 @@
                     || pContext->ViewRect.right != pContextRect->right
                     || pContext->ViewRect.bottom != pContextRect->bottom);
-            PVBOXVIDEOCM_CMD_RECTS pDrCmd;
+            PVBOXVIDEOCM_CMD_RECTS_INTERNAL pDrCmdInternal;
 
             bool bSend = false;
@@ -400 +404 @@
             if (bRectShanged)
             {
-                uint32_t cbDrCmd = VBOXVIDEOCM_CMD_RECTS_SIZE4CRECTS(pRects->cRects + 1);
-                pDrCmd = (PVBOXVIDEOCM_CMD_RECTS)vboxVideoCmCmdCreate(&pContext->CmContext, cbDrCmd);
-                Assert(pDrCmd);
-                if (!pDrCmd)
+                uint32_t cbDrCmdInternal = VBOXVIDEOCM_CMD_RECTS_INTERNAL_SIZE4CRECTS(pRects->cRects + 1);
+                pDrCmdInternal = (PVBOXVIDEOCM_CMD_RECTS_INTERNAL)vboxVideoCmCmdCreate(&pContext->CmContext, cbDrCmdInternal);
+                Assert(pDrCmdInternal);
+                if (!pDrCmdInternal)
                 {
                     Status = STATUS_NO_MEMORY;
                     break;
                 }
-                pDrCmd->fFlags.Value = 0;
-                pDrCmd->RectsInfo.cRects = pRects->cRects + 1;
-                pDrCmd->fFlags.bSetViewRect = 1;
-                pDrCmd->RectsInfo.aRects[0] = *pContextRect;
+                pDrCmdInternal->Cmd.fFlags.Value = 0;
+                pDrCmdInternal->Cmd.RectsInfo.cRects = pRects->cRects + 1;
+                pDrCmdInternal->Cmd.fFlags.bSetViewRect = 1;
+                pDrCmdInternal->Cmd.RectsInfo.aRects[0] = *pContextRect;
                 pContext->ViewRect = *pContextRect;
-                memcpy(&pDrCmd->RectsInfo.aRects[1], pRects->aRects, sizeof (RECT) * pRects->cRects);
+                memcpy(&pDrCmdInternal->Cmd.RectsInfo.aRects[1], pRects->aRects, sizeof (RECT) * pRects->cRects);
                 bSend = true;
             }
             else
             {
-                if (pCmd)
-                {
-                    pDrCmd = (PVBOXVIDEOCM_CMD_RECTS)vboxVideoCmCmdReinitForContext(pCmd, &pContext->CmContext);
-                    pCmd = NULL;
+                if (pCmdInternal)
+                {
+                    pDrCmdInternal = (PVBOXVIDEOCM_CMD_RECTS_INTERNAL)vboxVideoCmCmdReinitForContext(pCmdInternal, &pContext->CmContext);
+                    pCmdInternal = NULL;
                 }
                 else
                 {
-                    pDrCmd = (PVBOXVIDEOCM_CMD_RECTS)vboxVideoCmCmdCreate(&pContext->CmContext, cbCmd);
-                    Assert(pDrCmd);
-                    if (!pDrCmd)
+                    pDrCmdInternal = (PVBOXVIDEOCM_CMD_RECTS_INTERNAL)vboxVideoCmCmdCreate(&pContext->CmContext, cbCmdInternal);
+                    Assert(pDrCmdInternal);
+                    if (!pDrCmdInternal)
                     {
                         Status = STATUS_NO_MEMORY;
@@ -433 +437 @@
                     }
                 }
-                pDrCmd->fFlags.Value = 0;
-                pDrCmd->RectsInfo.cRects = pRects->cRects;
-                memcpy(&pDrCmd->RectsInfo.aRects[0], pRects->aRects, sizeof (RECT) * pRects->cRects);
+                pDrCmdInternal->Cmd.fFlags.Value = 0;
+                pDrCmdInternal->Cmd.RectsInfo.cRects = pRects->cRects;
+                memcpy(&pDrCmdInternal->Cmd.RectsInfo.aRects[0], pRects->aRects, sizeof (RECT) * pRects->cRects);
 
                 if (pContext->pLastReportedRects)
                 {
-                    if (pContext->pLastReportedRects->fFlags.bSetVisibleRects)
+                    if (pContext->pLastReportedRects->Cmd.fFlags.bSetVisibleRects)
                     {
                         RECT *paRects;
                         uint32_t cRects;
-                        if (pContext->pLastReportedRects->fFlags.bSetViewRect)
+                        if (pContext->pLastReportedRects->Cmd.fFlags.bSetViewRect)
                         {
-                            paRects = &pContext->pLastReportedRects->RectsInfo.aRects[1];
-                            cRects = pContext->pLastReportedRects->RectsInfo.cRects - 1;
+                            paRects = &pContext->pLastReportedRects->Cmd.RectsInfo.aRects[1];
+                            cRects = pContext->pLastReportedRects->Cmd.RectsInfo.cRects - 1;
                         }
                         else
                         {
-                            paRects = &pContext->pLastReportedRects->RectsInfo.aRects[0];
-                            cRects = pContext->pLastReportedRects->RectsInfo.cRects;
+                            paRects = &pContext->pLastReportedRects->Cmd.RectsInfo.aRects[0];
+                            cRects = pContext->pLastReportedRects->Cmd.RectsInfo.cRects;
                         }
-                        bSend = (pDrCmd->RectsInfo.cRects != cRects)
-                                || memcmp(paRects, pDrCmd->RectsInfo.aRects, cRects * sizeof (RECT));
+                        bSend = (pDrCmdInternal->Cmd.RectsInfo.cRects != cRects)
+                                || memcmp(paRects, pDrCmdInternal->Cmd.RectsInfo.aRects, cRects * sizeof (RECT));
                     }
                     else
                     {
-                        Assert(pContext->pLastReportedRects->fFlags.bAddHiddenRects);
+                        Assert(pContext->pLastReportedRects->Cmd.fFlags.bAddHiddenRects);
                         bSend = true;
                     }
@@ -473 +477 @@
                     vboxVideoCmCmdRelease(pContext->pLastReportedRects);
 
-                pDrCmd->fFlags.bSetVisibleRects = 1;
-
-                vboxVideoCmCmdRetain(pDrCmd);
-                pContext->pLastReportedRects = pDrCmd;
-                vboxVideoCmCmdSubmit(pDrCmd, VBOXVIDEOCM_SUBMITSIZE_DEFAULT);
+                pDrCmdInternal->Cmd.fFlags.bSetVisibleRects = 1;
+                pDrCmdInternal->VidPnSourceId = pRectsInfo->VidPnSourceId;
+
+                vboxVideoCmCmdRetain(pDrCmdInternal);
+                pContext->pLastReportedRects = pDrCmdInternal;
+                vboxVideoCmCmdSubmit(pDrCmdInternal, VBOXVIDEOCM_SUBMITSIZE_DEFAULT);
             }
             else
             {
-                if (!pCmd)
-                    pCmd = pDrCmd;
+                if (!pCmdInternal)
+                    pCmdInternal = pDrCmdInternal;
                 else
-                    vboxVideoCmCmdRelease(pDrCmd);
+                    vboxVideoCmCmdRelease(pDrCmdInternal);
             }
         }
@@ -491 +496 @@
 
 
-    if (pCmd)
-        vboxVideoCmCmdRelease(pCmd);
+    if (pCmdInternal)
+        vboxVideoCmCmdRelease(pCmdInternal);
 
     return Status;

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVdma.h

@@ -79 +79 @@
     VBOXVDMAPIPE_CMD_DR Hdr;
     struct VBOXWDDM_CONTEXT *pContext;
+    D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
     VBOXVDMAPIPE_RECTS ContextsRects;
 } VBOXVDMAPIPE_CMD_RECTSINFO, *PVBOXVDMAPIPE_CMD_RECTSINFO;

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp

@@ -2066 +2066 @@
 }
 
-static void vboxWddmSubmitBltCmd(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_SOURCE pSource, PVBOXWDDM_CONTEXT pContext, PVBOXWDDM_DMA_PRESENT_BLT pBlt)
+static void vboxWddmSubmitBltCmd(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_DMA_PRESENT_BLT pBlt)
 {
     PVBOXVDMAPIPE_CMD_RECTSINFO pRectsCmd = (PVBOXVDMAPIPE_CMD_RECTSINFO)vboxVdmaGgCmdCreate(&pDevExt->u.primary.Vdma.DmaGg, VBOXVDMAPIPE_CMD_TYPE_RECTSINFO, RT_OFFSETOF(VBOXVDMAPIPE_CMD_RECTSINFO, ContextsRects.UpdateRects.aRects[pBlt->DstRects.UpdateRects.cRects]));
@@ -2072 +2072 @@
     if (pRectsCmd)
     {
+        VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pBlt->Hdr.DstAllocInfo.srcId];
+        VBOXWDDM_CONTEXT *pContext = pBlt->Hdr.pContext;
         pRectsCmd->pContext = pContext;
+        pRectsCmd->VidPnSourceId = pBlt->Hdr.SrcAllocInfo.srcId;
         memcpy(&pRectsCmd->ContextsRects, &pBlt->DstRects, RT_OFFSETOF(VBOXVDMAPIPE_RECTS, UpdateRects.aRects[pBlt->DstRects.UpdateRects.cRects]));
         vboxWddmRectTranslate(&pRectsCmd->ContextsRects.ContextRect, pSource->VScreenPos.x, pSource->VScreenPos.y);
@@ -2184 +2187 @@
                                     VBOXVBVA_OP_WITHLOCK_ATDPC(ReportDirtyRect, pDevExt, pSource, &rect);
                                 }
-                                vboxWddmSubmitBltCmd(pDevExt, pSource, pContext, pBlt);
+                                vboxWddmSubmitBltCmd(pDevExt, pBlt);
                                 break;
                             }
@@ -2193 +2196 @@
                                 if (pSrcAlloc->fRcFlags.RenderTarget)
                                 {
-                                    vboxWddmSubmitBltCmd(pDevExt, pSource, pContext, pBlt);
+                                    vboxWddmSubmitBltCmd(pDevExt, pBlt);
                                 }
                                 break;
@@ -2237 +2240 @@
                 VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pPrivateData->SrcAllocInfo.srcId];
                 pRectsCmd->pContext = pContext;
+                pRectsCmd->VidPnSourceId = pPrivateData->SrcAllocInfo.srcId;
                 RECT r;
                 r.left = pSource->VScreenPos.x;

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.h

@@ -132 +132 @@
     UINT uLastCompletedCmdFenceId;
     RECT ViewRect;
-    PVBOXVIDEOCM_CMD_RECTS pLastReportedRects;
+    PVBOXVIDEOCM_CMD_RECTS_INTERNAL pLastReportedRects;
     VBOXVIDEOCM_CTX CmContext;
 } VBOXWDDM_CONTEXT, *PVBOXWDDM_CONTEXT;