Index: /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp (revision 29882) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp (revision 29883) @@ -857,4 +857,21 @@ } +static PVBOXWDDMDISP_RESOURCE vboxResourceAlloc(UINT cAllocs) +{ + PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)RTMemAllocZ(RT_OFFSETOF(VBOXWDDMDISP_RESOURCE, aAllocations[cAllocs])); + Assert(pRc); + if (pRc) + { + pRc->cAllocations = cAllocs; + return pRc; + } + return NULL; +} + +static void vboxResourceFree(PVBOXWDDMDISP_RESOURCE pRc) +{ + RTMemFree(pRc); +} + /** * DLL entry point. @@ -1396,15 +1413,90 @@ static HRESULT APIENTRY vboxWddmDDevLock(HANDLE hDevice, D3DDDIARG_LOCK* pData) { - vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice)); - AssertBreakpoint(); - vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice)); - return E_FAIL; + vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice)); + AssertBreakpoint(); + PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice; + PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource; + Assert(pData->SubResourceIndex < pRc->cAllocations); + if (pData->SubResourceIndex >= pRc->cAllocations) + return E_INVALIDARG; + + PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex]; + D3DDDICB_LOCK LockData; + LockData.hAllocation = pAlloc->hAllocation; + LockData.PrivateDriverData = 0; + LockData.NumPages = 0; + LockData.pPages = NULL; + LockData.pData = NULL; /* out */ + LockData.Flags.Value = 0; + LockData.Flags.Discard = pData->Flags.Discard; + LockData.Flags.DonotWait = pData->Flags.DoNotWait; + + + HRESULT hr = pDevice->RtCallbacks.pfnLockCb(hDevice, &LockData); + Assert(hr == S_OK || (hr == D3DERR_WASSTILLDRAWING && pData->Flags.DoNotWait)); + if (hr == S_OK) + { + uintptr_t offset; + if (pData->Flags.AreaValid) + { + offset = pAlloc->SurfDesc.pitch * pData->Area.top + + ((pAlloc->SurfDesc.bpp * pData->Area.left) >> 3); + } + else if (pData->Flags.RangeValid) + { + offset = pData->Range.Offset; + } + else if (pData->Flags.BoxValid) + { + vboxVDbgPrintF((__FUNCTION__": Implement Box area")); + AssertBreakpoint(); + } + else + { + AssertBreakpoint(); + } + + if (pData->Flags.Discard) + { + /* check if the surface was renamed */ + if (LockData.hAllocation) + pAlloc->hAllocation = LockData.hAllocation; + } + + pData->pSurfData = ((uint8_t*)LockData.pData) + offset; + pData->Pitch = pAlloc->SurfDesc.pitch; + pData->SlicePitch = pAlloc->SurfDesc.slicePitch; + } + + vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice)); + return hr; } static HRESULT APIENTRY vboxWddmDDevUnlock(HANDLE hDevice, CONST D3DDDIARG_UNLOCK* pData) { - vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice)); - AssertBreakpoint(); - vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice)); - return E_FAIL; + vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice)); + AssertBreakpoint(); + PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice; + PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource; + HRESULT hr = S_OK; + + Assert(pData->SubResourceIndex < pRc->cAllocations); + if (pData->SubResourceIndex >= pRc->cAllocations) + return E_INVALIDARG; + + struct + { + D3DDDICB_UNLOCK Unlock; + D3DKMT_HANDLE hAllocation; + } UnlockData; + + UnlockData.Unlock.NumAllocations = 1; + UnlockData.Unlock.phAllocations = &UnlockData.hAllocation; + UnlockData.hAllocation = pRc->aAllocations[pData->SubResourceIndex].hAllocation; + + hr = pDevice->RtCallbacks.pfnUnlockCb(hDevice, &UnlockData.Unlock); + Assert(hr == S_OK); + + vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice)); + return hr; } static HRESULT APIENTRY vboxWddmDDevLockAsync(HANDLE hDevice, D3DDDIARG_LOCKASYNC* pData) @@ -1429,17 +1521,159 @@ return E_FAIL; } + static HRESULT APIENTRY vboxWddmDDevCreateResource(HANDLE hDevice, D3DDDIARG_CREATERESOURCE* pResource) { - vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice)); - AssertBreakpoint(); - vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice)); - return E_FAIL; -} + vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice)); + HRESULT hr = S_OK; + PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice; + Assert(pDevice); + Assert(pResource); + + /* allocate buffer for D3DDDICB_ALLOCATE + D3DDDI_ALLOCATIONINFO * numAllocs + PVBOXWDDM_RCINFO with aAllocInfos[numAllocs] */ + uint32_t cbBuf = sizeof (D3DDDICB_ALLOCATE); + uint32_t offDdiAllocInfos = (cbBuf + 7) & ~3; + uint32_t cbDdiAllocInfos = sizeof (D3DDDI_ALLOCATIONINFO) * pResource->SurfCount; + cbBuf = offDdiAllocInfos + cbDdiAllocInfos; + uint32_t offRcInfo = (cbBuf + 7) & ~3; + uint32_t cbRcInfo = sizeof (VBOXWDDM_RCINFO); + cbBuf = offRcInfo + cbRcInfo; + uint32_t offAllocInfos = (cbBuf + 7) & ~3; + uint32_t cbAllocInfos = sizeof (VBOXWDDM_ALLOCINFO) * pResource->SurfCount; + cbBuf = offAllocInfos + cbAllocInfos; + uint8_t *pvBuf = (uint8_t*)RTMemAllocZ(cbBuf); + if (pvBuf) + { + D3DDDICB_ALLOCATE *pAllocate = (D3DDDICB_ALLOCATE*)pvBuf; + D3DDDI_ALLOCATIONINFO* pDdiAllocInfos = (D3DDDI_ALLOCATIONINFO*)(pvBuf + offDdiAllocInfos); + PVBOXWDDM_RCINFO pRcInfo = (PVBOXWDDM_RCINFO)(pvBuf + offRcInfo); + PVBOXWDDM_ALLOCINFO pAllocInfos = (PVBOXWDDM_ALLOCINFO)(pvBuf + offAllocInfos); + pAllocate->pPrivateDriverData = pRcInfo; + pAllocate->PrivateDriverDataSize = cbRcInfo; + pAllocate->hResource = pResource->hResource; + pAllocate->hKMResource = NULL; + pAllocate->NumAllocations = pResource->SurfCount; + pAllocate->pAllocationInfo = pDdiAllocInfos; + + pRcInfo->fFlags = VBOXWDDM_RESOURCE_F_TYPE_GENERIC; + pRcInfo->RcDesc.fFlags = pResource->Flags; + pRcInfo->RcDesc.enmFormat = pResource->Format; + pRcInfo->RcDesc.enmPool = pResource->Pool; + pRcInfo->RcDesc.enmMultisampleType = pResource->MultisampleType; + pRcInfo->RcDesc.MultisampleQuality = pResource->MultisampleQuality; + pRcInfo->RcDesc.MipLevels = pResource->MipLevels; + pRcInfo->RcDesc.Fvf = pResource->Fvf; + pRcInfo->RcDesc.VidPnSourceId = pResource->VidPnSourceId; + pRcInfo->RcDesc.RefreshRate = pResource->RefreshRate; + pRcInfo->RcDesc.enmRotation = pResource->Rotation; + pRcInfo->cAllocInfos = pResource->SurfCount; + + for (UINT i = 0; i < pResource->SurfCount; ++i) + { + PVBOXWDDM_ALLOCINFO pAllocInfo = &pAllocInfos[i]; + D3DDDI_ALLOCATIONINFO* pDdiAllocInfo = &pDdiAllocInfos[i]; + CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i]; + pDdiAllocInfo->hAllocation = NULL; + pDdiAllocInfo->pSystemMem = pSurf->pSysMem; + Assert((!!(pSurf->pSysMem)) == (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)); + pDdiAllocInfo->pPrivateDriverData = pAllocInfo; + pDdiAllocInfo->PrivateDriverDataSize = sizeof (VBOXWDDM_ALLOCINFO); + pDdiAllocInfo->VidPnSourceId = pResource->VidPnSourceId; + pDdiAllocInfo->Flags.Value = 0; + if (pResource->Flags.Primary) + pDdiAllocInfo->Flags.Primary = 1; + + pAllocInfo->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC; + pAllocInfo->SurfDesc.width = pSurf->Width; + pAllocInfo->SurfDesc.height = pSurf->Height; + pAllocInfo->SurfDesc.format = pResource->Format; + pAllocInfo->SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pResource->Format); + + if (pSurf->SysMemPitch) + { + pAllocInfo->SurfDesc.pitch = pSurf->SysMemPitch; +#ifdef DEBUG + UINT tst = vboxWddmCalcPitch(pSurf->Width, pAllocInfo->SurfDesc.bpp); + Assert(tst == pSurf->SysMemPitch); +#endif + } + else + pAllocInfo->SurfDesc.pitch = vboxWddmCalcPitch(pSurf->Width, pAllocInfo->SurfDesc.bpp); + + pAllocInfo->SurfDesc.depth = pSurf->Depth; + pAllocInfo->SurfDesc.slicePitch = pSurf->SysMemSlicePitch; + pAllocInfo->SurfDesc.VidPnSourceId = pResource->VidPnSourceId; + pAllocInfo->SurfDesc.RefreshRate = pResource->RefreshRate; + } + + hr = pDevice->RtCallbacks.pfnAllocateCb(pDevice->hDevice, pAllocate); + Assert(hr == S_OK); + if (hr == S_OK) + { + Assert(pAllocate->hKMResource); + PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(pResource->SurfCount); + if (pRc) + { + pRc->hResource = pResource->hResource; + pRc->hKMResource = pAllocate->hKMResource; + pRc->pDevice = pDevice; + pRc->fFlags = pRcInfo->fFlags; + pRc->RcDesc = pRcInfo->RcDesc; + pRc->cAllocations = pRcInfo->cAllocInfos; + for (UINT i = 0; i < pRcInfo->cAllocInfos; ++i) + { + PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[1]; + D3DDDI_ALLOCATIONINFO* pDdiAllocInfo = &pDdiAllocInfos[i]; + PVBOXWDDM_ALLOCINFO pAllocInfo = &pAllocInfos[i]; + CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i]; + pAllocation->hAllocation = pDdiAllocInfo->hAllocation; + pAllocation->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC; + pAllocation->pvMem = pSurf->pSysMem; + pAllocation->SurfDesc = pAllocInfo->SurfDesc; + } + + pResource->hResource = pRc; +// vboxResourceFree(pRc); + } + else + { + hr = E_OUTOFMEMORY; + } + } + + RTMemFree(pvBuf); + } + else + { + hr = E_OUTOFMEMORY; + } + + vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice)); + return hr; +} + static HRESULT APIENTRY vboxWddmDDevDestroyResource(HANDLE hDevice, HANDLE hResource) { - vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice)); - AssertBreakpoint(); - vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice)); - return E_FAIL; + vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice)); + PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice; + HRESULT hr = S_OK; + + Assert(pDevice); + Assert(hResource); + PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)hResource; + if (!(pRc->fFlags & VBOXWDDM_RESOURCE_F_OPENNED)) + { + D3DDDICB_DEALLOCATE Dealloc; + Dealloc.hResource = pRc->hResource; + Assert(pRc->hResource); + /* according to the docs the below two are ignored in case we set the hResource */ + Dealloc.NumAllocations = 0; + Dealloc.HandleList = NULL; + hr = pDevice->RtCallbacks.pfnDeallocateCb(pDevice->hDevice, &Dealloc); + Assert(hr == S_OK); + } + + vboxResourceFree(pRc); + vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice)); + return hr; } static HRESULT APIENTRY vboxWddmDDevSetDisplayMode(HANDLE hDevice, CONST D3DDDIARG_SETDISPLAYMODE* pData) @@ -1830,10 +2064,125 @@ return E_FAIL; } + +static HRESULT vboxAllocationInit(PVBOXWDDMDISP_ALLOCATION pAlloc, D3DDDI_OPENALLOCATIONINFO *pInfo) +{ + HRESULT hr = S_OK; + pAlloc->hAllocation = pInfo->hAllocation; + Assert(pInfo->PrivateDriverDataSize == sizeof (VBOXWDDM_ALLOCINFO)); + Assert(pInfo->pPrivateDriverData); + if (pInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO)) + { + PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pInfo->pPrivateDriverData; + pAlloc->enmType = pAllocInfo->enmType; + Assert(pAllocInfo->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE + || VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE + || VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE); + pAlloc->pvMem = NULL; + pAlloc->SurfDesc = pAllocInfo->SurfDesc; + } + else + { + vboxVDbgPrintR((__FUNCTION__": ERROR: PrivateDriverDataSize(%d) < (%d)\n", pInfo->PrivateDriverDataSize, sizeof (VBOXWDDM_ALLOCINFO))); + hr = E_INVALIDARG; + } + return hr; +} + static HRESULT APIENTRY vboxWddmDDevOpenResource(HANDLE hDevice, D3DDDIARG_OPENRESOURCE* pData) { - vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice)); - AssertBreakpoint(); - vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice)); - return E_FAIL; + vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice)); + PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice; + HRESULT hr = S_OK; + + Assert(pDevice); + Assert(pData->NumAllocations); + PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(pData->NumAllocations); + Assert(pRc); + if (pRc) + { + pRc->hResource = pData->hResource; + pRc->hKMResource = pData->hKMResource; + pRc->pDevice = pDevice; + pRc->RcDesc.enmRotation = pData->Rotation; + pRc->fFlags = VBOXWDDM_RESOURCE_F_OPENNED; + if (!pData->pPrivateDriverData || !pData->PrivateDriverDataSize) + { + /* this is a "standard" allocation resource */ + + /* both should be actually zero */ + Assert(!pData->pPrivateDriverData && !pData->PrivateDriverDataSize); + pRc->RcDesc.enmPool = D3DDDIPOOL_LOCALVIDMEM; + pRc->RcDesc.enmMultisampleType = D3DDDIMULTISAMPLE_NONE; + pRc->RcDesc.MultisampleQuality = 0; + pRc->RcDesc.MipLevels = 0; + pRc->RcDesc.Fvf; + pRc->RcDesc.fFlags.Value = 0; + + Assert(pData->NumAllocations); + D3DDDI_OPENALLOCATIONINFO* pDdiAllocInfo = &pData->pOpenAllocationInfo[0]; + Assert(pDdiAllocInfo->pPrivateDriverData); + Assert(pDdiAllocInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO)); + if (pDdiAllocInfo->pPrivateDriverData && pDdiAllocInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO)) + { + PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pDdiAllocInfo->pPrivateDriverData; + switch(pAllocInfo->enmType) + { + case VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE: + pRc->RcDesc.fFlags.Primary = 1; + case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE: + case VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE: + pRc->RcDesc.enmFormat = pAllocInfo->SurfDesc.format; + pRc->RcDesc.VidPnSourceId = pAllocInfo->SurfDesc.VidPnSourceId; + pRc->RcDesc.RefreshRate = pAllocInfo->SurfDesc.RefreshRate; + break; + default: + AssertBreakpoint(); + hr = E_INVALIDARG; + } + } + else + hr = E_INVALIDARG; + } + else + { + /* this is a "generic" resource whose creation is initiaded by the UMD */ + Assert(pData->PrivateDriverDataSize == sizeof (VBOXWDDM_RCINFO)); + if (pData->PrivateDriverDataSize >= sizeof (VBOXWDDM_RCINFO)) + { + VBOXWDDM_RCINFO *pRcInfo = (VBOXWDDM_RCINFO*)pData->pPrivateDriverData; + Assert(pRcInfo->fFlags == VBOXWDDM_RESOURCE_F_TYPE_GENERIC); + Assert(pRcInfo->cAllocInfos == pData->NumAllocations); + pRc->fFlags = pRcInfo->fFlags | VBOXWDDM_RESOURCE_F_OPENNED; + pRc->RcDesc = pRcInfo->RcDesc; + pRc->cAllocations = pData->NumAllocations; + } + else + hr = E_INVALIDARG; + } + + if (hr == S_OK) + { + for (UINT i = 0; i < pData->NumAllocations; ++i) + { + hr = vboxAllocationInit(&pRc->aAllocations[i], &pData->pOpenAllocationInfo[i]); + Assert(hr == S_OK); + if (hr != S_OK) + break; + } + } + + if (hr == S_OK) + pData->hResource = pRc; + else + vboxResourceFree(pRc); + } + else + { + vboxVDbgPrintR((__FUNCTION__": vboxResourceAlloc failed for hDevice(0x%p), NumAllocations(%d)\n", hDevice, pData->NumAllocations)); + hr = E_OUTOFMEMORY; + } + + vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice)); + return hr; } static HRESULT APIENTRY vboxWddmDDevGetCaptureAllocationHandle(HANDLE hDevice, D3DDDIARG_GETCAPTUREALLOCATIONHANDLE* pData) Index: /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.h (revision 29882) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.h (revision 29883) @@ -74,4 +74,23 @@ } VBOXWDDMDISP_DEVICE, *PVBOXWDDMDISP_DEVICE; +typedef struct VBOXWDDMDISP_ALLOCATION +{ + D3DKMT_HANDLE hAllocation; + VBOXWDDM_ALLOC_TYPE enmType; + CONST VOID* pvMem; + VBOXWDDM_SURFACE_DESC SurfDesc; +} VBOXWDDMDISP_ALLOCATION, *PVBOXWDDMDISP_ALLOCATION; + +typedef struct VBOXWDDMDISP_RESOURCE +{ + HANDLE hResource; + D3DKMT_HANDLE hKMResource; + PVBOXWDDMDISP_DEVICE pDevice; + uint32_t fFlags; + VBOXWDDM_RC_DESC RcDesc; + UINT cAllocations; + VBOXWDDMDISP_ALLOCATION aAllocations[1]; +} VBOXWDDMDISP_RESOURCE, *PVBOXWDDMDISP_RESOURCE; + DECLINLINE(bool) vboxDispD3DIs3DEnabled(VBOXWDDMDISP_ADAPTER * pAdapter) { Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.cpp (revision 29882) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.cpp (revision 29883) @@ -985,9 +985,9 @@ { if (!xres) - xres = DeviceExtension->aSources[0].pPrimaryAllocation->u.SurfInfo.width; + xres = DeviceExtension->aSources[0].pPrimaryAllocation->SurfDesc.width; if (!yres) - yres = DeviceExtension->aSources[0].pPrimaryAllocation->u.SurfInfo.height; + yres = DeviceExtension->aSources[0].pPrimaryAllocation->SurfDesc.height; if (!bpp) - bpp = DeviceExtension->aSources[0].pPrimaryAllocation->u.SurfInfo.bpp; + bpp = DeviceExtension->aSources[0].pPrimaryAllocation->SurfDesc.bpp; } #endif Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.h (revision 29882) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.h (revision 29883) @@ -166,5 +166,5 @@ struct VBOXWDDM_ALLOCATION * pShadowAllocation; VBOXVIDEOOFFSET offVram; - VBOXWDDM_SURFACE_DESC SurfInfo; + VBOXWDDM_SURFACE_DESC SurfDesc; VBOXVBVAINFO Vbva; #endif @@ -636,5 +636,4 @@ D3DDDIFORMAT vboxWddmCalcPixelFormat(VIDEO_MODE_INFORMATION *pInfo); -UINT vboxWddmCalcBitsPerPixel(D3DDDIFORMAT format); DECLINLINE(ULONG) vboxWddmVramCpuVisibleSize(PDEVICE_EXTENSION pDevExt) @@ -668,5 +667,5 @@ } -DECLINLINE(bool) vboxWddmCmpSurfDescs(VBOXWDDM_SURFACE_DESC *pDesc1, VBOXWDDM_SURFACE_DESC *pDesc2) +DECLINLINE(bool) vboxWddmCmpSurfDescsBase(VBOXWDDM_SURFACE_DESC *pDesc1, VBOXWDDM_SURFACE_DESC *pDesc2) { if (pDesc1->width != pDesc2->width) @@ -691,24 +690,22 @@ { PVBOXWDDM_ALLOCATION pOldAlloc = pSource->pShadowAllocation; - PVBOXWDDM_ALLOCATION_SHADOWSURFACE pOldShadowInfo = VBOXWDDM_ALLOCATION_BODY(pOldAlloc, VBOXWDDM_ALLOCATION_SHADOWSURFACE); /* clear the visibility info fo the current primary */ - pOldShadowInfo->bVisible = FALSE; - pOldShadowInfo->bAssigned = FALSE; - Assert(pOldShadowInfo->VidPnSourceId == srcId); + pOldAlloc->bVisible = FALSE; + pOldAlloc->bAssigned = FALSE; + Assert(pOldAlloc->SurfDesc.VidPnSourceId == srcId); /* release the shadow surface */ - pOldShadowInfo->VidPnSourceId = D3DDDI_ID_UNINITIALIZED; + pOldAlloc->SurfDesc.VidPnSourceId = D3DDDI_ID_UNINITIALIZED; } if (pAllocation) { - PVBOXWDDM_ALLOCATION_SHADOWSURFACE pShadowInfo = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHADOWSURFACE); - pShadowInfo->bVisible = FALSE; + pAllocation->bVisible = FALSE; /* this check ensures the shadow is not used for other source simultaneously */ - Assert(pShadowInfo->VidPnSourceId == D3DDDI_ID_UNINITIALIZED); - pShadowInfo->VidPnSourceId = srcId; - pShadowInfo->bAssigned = TRUE; - if (!vboxWddmCmpSurfDescs(&pSource->SurfInfo, &pAllocation->u.SurfInfo)) + Assert(pAllocation->SurfDesc.VidPnSourceId == D3DDDI_ID_UNINITIALIZED); + pAllocation->SurfDesc.VidPnSourceId = srcId; + pAllocation->bAssigned = TRUE; + if (!vboxWddmCmpSurfDescsBase(&pSource->SurfDesc, &pAllocation->SurfDesc)) pSource->offVram = VBOXVIDEOOFFSET_VOID; /* force guest->host notification */ - pSource->SurfInfo = pAllocation->u.SurfInfo; + pSource->SurfDesc = pAllocation->SurfDesc; } @@ -725,18 +722,16 @@ { PVBOXWDDM_ALLOCATION pOldAlloc = pSource->pPrimaryAllocation; - PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pOldPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pOldAlloc, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE); /* clear the visibility info fo the current primary */ - pOldPrimaryInfo->bVisible = FALSE; - pOldPrimaryInfo->bAssigned = FALSE; - Assert(pOldPrimaryInfo->VidPnSourceId == srcId); + pOldAlloc->bVisible = FALSE; + pOldAlloc->bAssigned = FALSE; + Assert(pOldAlloc->SurfDesc.VidPnSourceId == srcId); } if (pAllocation) { - PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE); - pPrimaryInfo->bVisible = FALSE; - Assert(pPrimaryInfo->VidPnSourceId == srcId); - pPrimaryInfo->VidPnSourceId = srcId; - pPrimaryInfo->bAssigned = TRUE; + pAllocation->bVisible = FALSE; + Assert(pAllocation->SurfDesc.VidPnSourceId == srcId); + pAllocation->SurfDesc.VidPnSourceId = srcId; + pAllocation->bAssigned = TRUE; } Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideoHGSMI.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideoHGSMI.cpp (revision 29882) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideoHGSMI.cpp (revision 29883) @@ -1048,5 +1048,5 @@ int VBoxFreeDisplaysHGSMI(PDEVICE_EXTENSION PrimaryExtension) { - int rc; + int rc = VINF_SUCCESS; for (int i = PrimaryExtension->cSources-1; i >= 0; --i) { @@ -1057,33 +1057,35 @@ rc = vboxVbvaDestroy(PrimaryExtension, &PrimaryExtension->aSources[i].Vbva); AssertRC(rc); + if (RT_FAILURE(rc)) + { + /* @todo: */ + } + } + } + + rc = vboxVdmaDisable(PrimaryExtension, &PrimaryExtension->u.primary.Vdma); + AssertRC(rc); + if (RT_SUCCESS(rc)) + { + rc = vboxVdmaDestroy(PrimaryExtension, &PrimaryExtension->u.primary.Vdma); + AssertRC(rc); + if (RT_SUCCESS(rc)) + { + /*rc = */VBoxUnmapAdapterMemory(PrimaryExtension, &PrimaryExtension->u.primary.pvMiniportHeap, PrimaryExtension->u.primary.cbMiniportHeap); +/* + AssertRC(rc); if (RT_SUCCESS(rc)) - { - rc = vboxVdmaDisable(PrimaryExtension, &PrimaryExtension->u.primary.Vdma); +*/ + { + HGSMIHeapDestroy(&PrimaryExtension->u.primary.hgsmiAdapterHeap); + + /* Map the adapter information. It will be needed for HGSMI IO. */ + /*rc = */VBoxUnmapAdapterMemory(PrimaryExtension, &PrimaryExtension->u.primary.pvAdapterInformation, VBVA_ADAPTER_INFORMATION_SIZE); +/* AssertRC(rc); - if (RT_SUCCESS(rc)) - { - rc = vboxVdmaDestroy(PrimaryExtension, &PrimaryExtension->u.primary.Vdma); - AssertRC(rc); - if (RT_SUCCESS(rc)) - { - /*rc = */VBoxUnmapAdapterMemory(PrimaryExtension, &PrimaryExtension->u.primary.pvMiniportHeap, PrimaryExtension->u.primary.cbMiniportHeap); -/* - AssertRC(rc); - if (RT_SUCCESS(rc)) + if (RT_FAILURE(rc)) + drprintf((__FUNCTION__"VBoxUnmapAdapterMemory PrimaryExtension->u.primary.pvAdapterInformation failed, rc(%d)\n", rc)); */ - { - HGSMIHeapDestroy(&PrimaryExtension->u.primary.hgsmiAdapterHeap); - - /* Map the adapter information. It will be needed for HGSMI IO. */ - /*rc = */VBoxUnmapAdapterMemory(PrimaryExtension, &PrimaryExtension->u.primary.pvAdapterInformation, VBVA_ADAPTER_INFORMATION_SIZE); -/* - AssertRC(rc); - if (RT_FAILURE(rc)) - drprintf((__FUNCTION__"VBoxUnmapAdapterMemory PrimaryExtension->u.primary.pvAdapterInformation failed, rc(%d)\n", rc)); -*/ - - } - } - } + } } Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoIf.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoIf.h (revision 29882) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoIf.h (revision 29883) @@ -24,7 +24,7 @@ #include -/* @todo: implement a check to ensure display & miniport versions match - * one would increase this whenever defines in this file change */ -#define VBOXVIDEOIF_VERSION 1 +/* @todo: implement a check to ensure display & miniport versions match. + * One would increase this whenever definitions in this file are changed */ +#define VBOXVIDEOIF_VERSION 2 /* create allocation func */ @@ -38,4 +38,5 @@ VBOXWDDM_ALLOC_TYPE_STD_GDISURFACE /* custom allocation types requested from user-mode d3d module will go here */ + , VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC } VBOXWDDM_ALLOC_TYPE; @@ -47,4 +48,8 @@ UINT bpp; UINT pitch; + UINT depth; + UINT slicePitch; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + D3DDDI_RATIONAL RefreshRate; } VBOXWDDM_SURFACE_DESC, *PVBOXWDDM_SURFACE_DESC; @@ -52,16 +57,39 @@ { VBOXWDDM_ALLOC_TYPE enmType; - union - { - VBOXWDDM_SURFACE_DESC SurfInfo; - } u; + VBOXWDDM_SURFACE_DESC SurfDesc; } VBOXWDDM_ALLOCINFO, *PVBOXWDDM_ALLOCINFO; -#define VBOXWDDM_ALLOCINFO_HEADSIZE() (sizeof (VBOXWDDM_ALLOCINFO)) -#define VBOXWDDM_ALLOCINFO_SIZE_FROMBODYSIZE(_s) (VBOXWDDM_ALLOCINFO_HEADSIZE() + (_s)) -#define VBOXWDDM_ALLOCINFO_SIZE(_tCmd) (VBOXWDDM_ALLOCINFO_SIZE_FROMBODYSIZE(sizeof(_tCmd))) -#define VBOXWDDM_ALLOCINFO_BODY(_p, _t) ( (_t*)(((uint8_t*)(_p)) + VBOXWDDM_ALLOCINFO_HEADSIZE()) ) -#define VBOXWDDM_ALLOCINFO_HEAD(_pb) ((VBOXWDDM_ALLOCINFO*)((uint8_t *)(_pb) - VBOXWDDM_ALLOCATION_HEADSIZE())) +//#define VBOXWDDM_ALLOCINFO_HEADSIZE() (sizeof (VBOXWDDM_ALLOCINFO)) +//#define VBOXWDDM_ALLOCINFO_SIZE_FROMBODYSIZE(_s) (VBOXWDDM_ALLOCINFO_HEADSIZE() + (_s)) +//#define VBOXWDDM_ALLOCINFO_SIZE(_tCmd) (VBOXWDDM_ALLOCINFO_SIZE_FROMBODYSIZE(sizeof(_tCmd))) +//#define VBOXWDDM_ALLOCINFO_BODY(_p, _t) ( (_t*)(((uint8_t*)(_p)) + VBOXWDDM_ALLOCINFO_HEADSIZE()) ) +//#define VBOXWDDM_ALLOCINFO_HEAD(_pb) ((VBOXWDDM_ALLOCINFO*)((uint8_t *)(_pb) - VBOXWDDM_ALLOCATION_HEADSIZE())) +/* this resource is OpenResource'd rather than CreateResource'd */ +#define VBOXWDDM_RESOURCE_F_OPENNED 0x00000001 +/* identifies this is a resource created with CreateResource, the VBOXWDDMDISP_RESOURCE::fRcFlags is valid */ +#define VBOXWDDM_RESOURCE_F_TYPE_GENERIC 0x00000002 + +typedef struct VBOXWDDM_RC_DESC +{ + D3DDDI_RESOURCEFLAGS fFlags; + D3DDDIFORMAT enmFormat; + D3DDDI_POOL enmPool; + D3DDDIMULTISAMPLE_TYPE enmMultisampleType; + UINT MultisampleQuality; + UINT MipLevels; + UINT Fvf; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + D3DDDI_RATIONAL RefreshRate; + D3DDDI_ROTATION enmRotation; +} VBOXWDDM_RC_DESC, *PVBOXWDDM_RC_DESC; + +typedef struct VBOXWDDM_RCINFO +{ + uint32_t fFlags; + VBOXWDDM_RC_DESC RcDesc; + uint32_t cAllocInfos; +// VBOXWDDM_ALLOCINFO aAllocInfos[1]; +} VBOXWDDM_RCINFO, *PVBOXWDDM_RCINFO; #define VBOXVHWA_F_ENABLED 0x00000001 @@ -89,3 +117,54 @@ /* submit cmd func */ + + + +/* tooling */ +DECLINLINE(UINT) vboxWddmCalcBitsPerPixel(D3DDDIFORMAT format) +{ + switch (format) + { + case D3DDDIFMT_R8G8B8: + return 24; + case D3DDDIFMT_A8R8G8B8: + case D3DDDIFMT_X8R8G8B8: + return 32; + case D3DDDIFMT_R5G6B5: + case D3DDDIFMT_X1R5G5B5: + case D3DDDIFMT_A1R5G5B5: + case D3DDDIFMT_A4R4G4B4: + return 16; + case D3DDDIFMT_R3G3B2: + case D3DDDIFMT_A8: + return 8; + case D3DDDIFMT_A8R3G3B2: + case D3DDDIFMT_X4R4G4B4: + return 16; + case D3DDDIFMT_A2B10G10R10: + case D3DDDIFMT_A8B8G8R8: + case D3DDDIFMT_X8B8G8R8: + case D3DDDIFMT_G16R16: + case D3DDDIFMT_A2R10G10B10: + return 32; + case D3DDDIFMT_A16B16G16R16: + return 64; + case D3DDDIFMT_A8P8: + return 16; + case D3DDDIFMT_P8: + return 8; + default: + AssertBreakpoint(); + return 0; + } +} + +#define VBOXWDDM_ROUNDBOUND(_v, _b) (((_v) + ((_b) - 1)) & ~((_b) - 1)) + +DECLINLINE(UINT) vboxWddmCalcPitch(UINT w, UINT bitsPerPixel) +{ + UINT Pitch = bitsPerPixel * w; + /* pitch is now in bits, translate in bytes */ + return VBOXWDDM_ROUNDBOUND(Pitch, 8) >> 3; +} + #endif /* #ifndef ___VBoxVideoIf_h___ */ Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp (revision 29882) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp (revision 29883) @@ -76,5 +76,5 @@ } -NTSTATUS vboxWddmGhDisplayPostInfoScreen (PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pAllocation, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId) +NTSTATUS vboxWddmGhDisplayPostInfoScreen (PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pAllocation) { VBOXVIDEOOFFSET offVram = pAllocation->offVram; @@ -83,5 +83,4 @@ // return STATUS_INVALID_PARAMETER; -// PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE); /* Issue the screen info command. */ void *p = vboxHGSMIBufferAlloc (pDevExt, @@ -94,12 +93,12 @@ VBVAINFOSCREEN *pScreen = (VBVAINFOSCREEN *)p; - pScreen->u32ViewIndex = /*pPrimaryInfo->*/VidPnSourceId; + pScreen->u32ViewIndex = pAllocation->SurfDesc.VidPnSourceId; pScreen->i32OriginX = 0; pScreen->i32OriginY = 0; pScreen->u32StartOffset = 0; //(uint32_t)offVram; /* we pretend the view is located at the start of each framebuffer */ - pScreen->u32LineSize = pAllocation->u.SurfInfo.pitch; - pScreen->u32Width = pAllocation->u.SurfInfo.width; - pScreen->u32Height = pAllocation->u.SurfInfo.height; - pScreen->u16BitsPerPixel = (uint16_t)pAllocation->u.SurfInfo.bpp; + pScreen->u32LineSize = pAllocation->SurfDesc.pitch; + pScreen->u32Width = pAllocation->SurfDesc.width; + pScreen->u32Height = pAllocation->SurfDesc.height; + pScreen->u16BitsPerPixel = (uint16_t)pAllocation->SurfDesc.bpp; pScreen->u16Flags = VBVA_SCREEN_F_ACTIVE; @@ -112,5 +111,5 @@ } -NTSTATUS vboxWddmGhDisplayPostInfoView (PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pAllocation, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId) +NTSTATUS vboxWddmGhDisplayPostInfoView(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pAllocation) { VBOXVIDEOOFFSET offVram = pAllocation->offVram; @@ -119,5 +118,4 @@ return STATUS_INVALID_PARAMETER; -// PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE); /* Issue the screen info command. */ void *p = vboxHGSMIBufferAlloc (pDevExt, @@ -130,5 +128,5 @@ VBVAINFOVIEW *pView = (VBVAINFOVIEW *)p; - pView->u32ViewIndex = /*pPrimaryInfo->*/VidPnSourceId; + pView->u32ViewIndex = pAllocation->SurfDesc.VidPnSourceId; pView->u32ViewOffset = (uint32_t)offVram; /* we pretend the view is located at the start of each framebuffer */ pView->u32ViewSize = vboxWddmVramCpuVisibleSegmentSize(pDevExt)/pDevExt->cSources; @@ -144,12 +142,12 @@ } -NTSTATUS vboxWddmGhDisplaySetMode (PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pAllocation, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId) +NTSTATUS vboxWddmGhDisplaySetMode(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pAllocation) { // PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE); - if (/*pPrimaryInfo->*/VidPnSourceId) + if (/*pPrimaryInfo->*/pAllocation->SurfDesc.VidPnSourceId) return STATUS_SUCCESS; - if (VBoxVideoSetCurrentModePerform(pDevExt, pAllocation->u.SurfInfo.width, - pAllocation->u.SurfInfo.height, pAllocation->u.SurfInfo.bpp, + if (VBoxVideoSetCurrentModePerform(pDevExt, pAllocation->SurfDesc.width, + pAllocation->SurfDesc.height, pAllocation->SurfDesc.bpp, (ULONG)pAllocation->offVram)) return STATUS_SUCCESS; @@ -166,8 +164,6 @@ #ifndef VBOXWDDM_RENDER_FROM_SHADOW PVBOXWDDM_ALLOCATION pAllocation = pSource->pPrimaryAllocation; - PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE); #else PVBOXWDDM_ALLOCATION pAllocation = pSource->pShadowAllocation; - PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pSource->pPrimaryAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE); #endif VBOXVIDEOOFFSET offVram = vboxWddmValidatePrimary(pAllocation); @@ -179,13 +175,13 @@ * Set the current mode into the hardware. */ - NTSTATUS Status = vboxWddmGhDisplaySetMode (pDevExt, pAllocation, pPrimaryInfo->VidPnSourceId); + NTSTATUS Status = vboxWddmGhDisplaySetMode(pDevExt, pAllocation); Assert(Status == STATUS_SUCCESS); if (Status == STATUS_SUCCESS) { - Status = vboxWddmGhDisplayPostInfoView (pDevExt, pAllocation, pPrimaryInfo->VidPnSourceId); + Status = vboxWddmGhDisplayPostInfoView(pDevExt, pAllocation); Assert(Status == STATUS_SUCCESS); if (Status == STATUS_SUCCESS) { - Status = vboxWddmGhDisplayPostInfoScreen (pDevExt, pAllocation, pPrimaryInfo->VidPnSourceId); + Status = vboxWddmGhDisplayPostInfoScreen(pDevExt, pAllocation); Assert(Status == STATUS_SUCCESS); if (Status != STATUS_SUCCESS) @@ -407,42 +403,4 @@ } -UINT vboxWddmCalcBitsPerPixel(D3DDDIFORMAT format) -{ - switch (format) - { - case D3DDDIFMT_R8G8B8: - return 24; - case D3DDDIFMT_A8R8G8B8: - case D3DDDIFMT_X8R8G8B8: - return 32; - case D3DDDIFMT_R5G6B5: - case D3DDDIFMT_X1R5G5B5: - case D3DDDIFMT_A1R5G5B5: - case D3DDDIFMT_A4R4G4B4: - return 16; - case D3DDDIFMT_R3G3B2: - case D3DDDIFMT_A8: - return 8; - case D3DDDIFMT_A8R3G3B2: - case D3DDDIFMT_X4R4G4B4: - return 16; - case D3DDDIFMT_A2B10G10R10: - case D3DDDIFMT_A8B8G8R8: - case D3DDDIFMT_X8B8G8R8: - case D3DDDIFMT_G16R16: - case D3DDDIFMT_A2R10G10B10: - return 32; - case D3DDDIFMT_A16B16G16R16: - return 64; - case D3DDDIFMT_A8P8: - return 16; - case D3DDDIFMT_P8: - return 8; - default: - AssertBreakpoint(); - return 0; - } -} - D3DDDIFORMAT vboxWddmCalcPixelFormat(VIDEO_MODE_INFORMATION *pInfo) { @@ -509,16 +467,4 @@ return D3DDDIFMT_UNKNOWN; -} - -UINT vboxWddmCalcPitch(UINT w, UINT bitsPerPixel) -{ - UINT Pitch = bitsPerPixel * w; - /* pitch is now in bits, translate in bytes */ - if(Pitch & 7) - Pitch = (Pitch >> 3) + 1; - else - Pitch = (Pitch >> 3); - - return Pitch; } @@ -1434,9 +1380,8 @@ case VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE: { - PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pAlloc = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE); - if (pAlloc->bAssigned) + if (pAllocation->bAssigned) { /* @todo: do we need to notify host? */ - vboxWddmAssignPrimary(pDevExt, &pDevExt->aSources[pAlloc->VidPnSourceId], NULL, pAlloc->VidPnSourceId); + vboxWddmAssignPrimary(pDevExt, &pDevExt->aSources[pAllocation->SurfDesc.VidPnSourceId], NULL, pAllocation->SurfDesc.VidPnSourceId); } break; @@ -1445,10 +1390,9 @@ case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE: { - PVBOXWDDM_ALLOCATION_SHADOWSURFACE pAlloc = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHADOWSURFACE); - if (pAlloc->bAssigned) - { - Assert(pAlloc->VidPnSourceId != D3DDDI_ID_UNINITIALIZED); + if (pAllocation->bAssigned) + { + Assert(pAllocation->SurfDesc.VidPnSourceId != D3DDDI_ID_UNINITIALIZED); /* @todo: do we need to notify host? */ - vboxWddmAssignShadow(pDevExt, &pDevExt->aSources[pAlloc->VidPnSourceId], NULL, pAlloc->VidPnSourceId); + vboxWddmAssignShadow(pDevExt, &pDevExt->aSources[pAllocation->SurfDesc.VidPnSourceId], NULL, pAllocation->SurfDesc.VidPnSourceId); } break; @@ -1468,175 +1412,71 @@ NTSTATUS Status = STATUS_SUCCESS; - Assert(pAllocationInfo->PrivateDriverDataSize >= VBOXWDDM_ALLOCINFO_HEADSIZE()); - if (pAllocationInfo->PrivateDriverDataSize >= VBOXWDDM_ALLOCINFO_HEADSIZE()) + Assert(pAllocationInfo->PrivateDriverDataSize == sizeof (VBOXWDDM_ALLOCINFO)); + if (pAllocationInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO)) { PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pAllocationInfo->pPrivateDriverData; - switch (pAllocInfo->enmType) - { - case VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE: - { - Assert(pAllocationInfo->PrivateDriverDataSize >= VBOXWDDM_ALLOCINFO_SIZE(VBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE)); - if (pAllocationInfo->PrivateDriverDataSize >= VBOXWDDM_ALLOCINFO_SIZE(VBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE)) - { - if (pAllocInfo->u.SurfInfo.bpp != 0) - { - PVBOXWDDM_ALLOCATION pAllocation = (PVBOXWDDM_ALLOCATION)vboxWddmMemAllocZero(VBOXWDDM_ALLOCATION_SIZE(VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE)); - Assert(pAllocation); - if (pAllocation) - { - pAllocation->enmType = VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE; - pAllocation->offVram = VBOXVIDEOOFFSET_VOID; - pAllocation->u.SurfInfo = pAllocInfo->u.SurfInfo; - PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pAlloc = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE); - PVBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE pAllocI = VBOXWDDM_ALLOCINFO_BODY(pAllocInfo, VBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE); - pAlloc->RefreshRate = pAllocI->RefreshRate; - pAlloc->VidPnSourceId = pAllocI->VidPnSourceId; -// pAlloc->offAddress = VBOXVIDEOOFFSET_VOID; - pAlloc->bVisible = FALSE; - - pAllocationInfo->pPrivateDriverData = NULL; - pAllocationInfo->PrivateDriverDataSize = 0; - pAllocationInfo->Alignment = 0; - pAllocationInfo->Size = pAllocInfo->u.SurfInfo.pitch * pAllocInfo->u.SurfInfo.height; - pAllocationInfo->PitchAlignedSize = 0; - pAllocationInfo->HintedBank.Value = 0; - pAllocationInfo->PreferredSegment.Value = 0; -#if 1 //defined(VBOXWDDM_RENDER_FROM_SHADOW) - pAllocationInfo->SupportedReadSegmentSet = 1; - pAllocationInfo->SupportedWriteSegmentSet = 1; -#else - pAllocationInfo->SupportedReadSegmentSet = 2; - pAllocationInfo->SupportedWriteSegmentSet = 2; + PVBOXWDDM_ALLOCATION pAllocation = (PVBOXWDDM_ALLOCATION)vboxWddmMemAllocZero(sizeof (VBOXWDDM_ALLOCATION)); + Assert(pAllocation); + if (pAllocation) + { + pAllocation->enmType = pAllocInfo->enmType; + pAllocation->offVram = VBOXVIDEOOFFSET_VOID; + pAllocation->SurfDesc = pAllocInfo->SurfDesc; + pAllocation->bVisible = FALSE; + pAllocation->bAssigned = FALSE; + + pAllocationInfo->pPrivateDriverData = NULL; + pAllocationInfo->PrivateDriverDataSize = 0; + pAllocationInfo->Alignment = 0; + pAllocationInfo->Size = pAllocInfo->SurfDesc.pitch * pAllocInfo->SurfDesc.height; + pAllocationInfo->PitchAlignedSize = 0; + pAllocationInfo->HintedBank.Value = 0; + pAllocationInfo->PreferredSegment.Value = 0; + pAllocationInfo->SupportedReadSegmentSet = 1; + pAllocationInfo->SupportedWriteSegmentSet = 1; + pAllocationInfo->EvictionSegmentSet = 0; + pAllocationInfo->MaximumRenamingListLength = 0; + pAllocationInfo->hAllocation = pAllocation; + pAllocationInfo->Flags.Value = 0; + pAllocationInfo->pAllocationUsageHint = NULL; + pAllocationInfo->AllocationPriority = D3DDDI_ALLOCATIONPRIORITY_NORMAL; + + switch (pAllocInfo->enmType) + { + case VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE: +#if 0 //defined(VBOXWDDM_RENDER_FROM_SHADOW) + pAllocationInfo->SupportedReadSegmentSet = 2; + pAllocationInfo->SupportedWriteSegmentSet = 2; #endif - pAllocationInfo->EvictionSegmentSet = 0; - pAllocationInfo->MaximumRenamingListLength = 0; - pAllocationInfo->hAllocation = pAllocation; - pAllocationInfo->Flags.Value = 0; #ifndef VBOXWDDM_RENDER_FROM_SHADOW - pAllocationInfo->Flags.CpuVisible = 1; + pAllocationInfo->Flags.CpuVisible = 1; #endif - pAllocationInfo->pAllocationUsageHint = NULL; - pAllocationInfo->AllocationPriority = D3DDDI_ALLOCATIONPRIORITY_NORMAL; - } - else - { - drprintf((__FUNCTION__ ": ERROR: failed to create allocation description\n")); - Status = STATUS_NO_MEMORY; - } - } - else - { - drprintf((__FUNCTION__ ": Invalid format (%d)\n", pAllocInfo->u.SurfInfo.format)); - Status = STATUS_INVALID_PARAMETER; - } - } - else - { - drprintf((__FUNCTION__ ": ERROR: PrivateDriverDataSize(%d) less than VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE cmd size(%d)\n", pAllocationInfo->PrivateDriverDataSize, VBOXWDDM_ALLOCINFO_SIZE(VBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE))); + break; + case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE: + case VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE: + case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC: + pAllocationInfo->Flags.Value = 0; + pAllocationInfo->Flags.CpuVisible = 1; + break; + default: + drprintf((__FUNCTION__ ": ERROR: invalid alloc info type(%d)\n", pAllocInfo->enmType)); + AssertBreakpoint(); Status = STATUS_INVALID_PARAMETER; - } - break; - } - case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE: -#ifdef VBOXWDDM_RENDER_FROM_SHADOW - { - Assert(pAllocationInfo->PrivateDriverDataSize >= VBOXWDDM_ALLOCINFO_HEADSIZE()); - if (pAllocationInfo->PrivateDriverDataSize >= VBOXWDDM_ALLOCINFO_HEADSIZE()) - { - PVBOXWDDM_ALLOCATION pAllocation = (PVBOXWDDM_ALLOCATION)vboxWddmMemAllocZero(VBOXWDDM_ALLOCATION_SIZE(VBOXWDDM_ALLOCATION_SHADOWSURFACE)); - Assert(pAllocation); - if (pAllocation) - { - pAllocation->enmType = pAllocInfo->enmType; - pAllocation->offVram = VBOXVIDEOOFFSET_VOID; - pAllocation->u.SurfInfo = pAllocInfo->u.SurfInfo; - - pAllocationInfo->pPrivateDriverData = NULL; - pAllocationInfo->PrivateDriverDataSize = 0; - pAllocationInfo->Alignment = 0; - pAllocationInfo->Size = pAllocInfo->u.SurfInfo.pitch * pAllocInfo->u.SurfInfo.height; - pAllocationInfo->PitchAlignedSize = 0; - pAllocationInfo->HintedBank.Value = 0; - pAllocationInfo->PreferredSegment.Value = 0; - pAllocationInfo->SupportedReadSegmentSet = 1; - pAllocationInfo->SupportedWriteSegmentSet = 1; - pAllocationInfo->EvictionSegmentSet = 0; - pAllocationInfo->MaximumRenamingListLength = 0; - pAllocationInfo->hAllocation = pAllocation; - pAllocationInfo->Flags.Value = 0; - pAllocationInfo->Flags.CpuVisible = 1; - pAllocationInfo->pAllocationUsageHint = NULL; - pAllocationInfo->AllocationPriority = D3DDDI_ALLOCATIONPRIORITY_NORMAL; - PVBOXWDDM_ALLOCATION_SHADOWSURFACE pAlloc = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHADOWSURFACE); - pAlloc->VidPnSourceId = D3DDDI_ID_UNINITIALIZED; -// pAlloc->bVisible = FALSE; -// pAlloc->bAssigned = FALSE; - } - else - { - drprintf((__FUNCTION__ ": ERROR: failed to create allocation description\n")); - Status = STATUS_NO_MEMORY; - } - } - else - { - drprintf((__FUNCTION__ ": ERROR: PrivateDriverDataSize(%d) less than cmd size(%d)\n", pAllocationInfo->PrivateDriverDataSize, VBOXWDDM_ALLOCINFO_HEADSIZE())); - Status = STATUS_INVALID_PARAMETER; - } - break; - } -#endif - case VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE: - { - Assert(pAllocationInfo->PrivateDriverDataSize >= VBOXWDDM_ALLOCINFO_HEADSIZE()); - if (pAllocationInfo->PrivateDriverDataSize >= VBOXWDDM_ALLOCINFO_HEADSIZE()) - { - PVBOXWDDM_ALLOCATION pAllocation = (PVBOXWDDM_ALLOCATION)vboxWddmMemAllocZero(VBOXWDDM_ALLOCATION_HEADSIZE()); - Assert(pAllocation); - if (pAllocation) - { - pAllocation->enmType = pAllocInfo->enmType; - pAllocation->offVram = VBOXVIDEOOFFSET_VOID; - pAllocation->u.SurfInfo = pAllocInfo->u.SurfInfo; - - pAllocationInfo->pPrivateDriverData = NULL; - pAllocationInfo->PrivateDriverDataSize = 0; - pAllocationInfo->Alignment = 0; - pAllocationInfo->Size = pAllocInfo->u.SurfInfo.pitch * pAllocInfo->u.SurfInfo.height; - pAllocationInfo->PitchAlignedSize = 0; - pAllocationInfo->HintedBank.Value = 0; - pAllocationInfo->PreferredSegment.Value = 0; - pAllocationInfo->SupportedReadSegmentSet = 1; - pAllocationInfo->SupportedWriteSegmentSet = 1; - pAllocationInfo->EvictionSegmentSet = 0; - pAllocationInfo->MaximumRenamingListLength = 0; - pAllocationInfo->hAllocation = pAllocation; - pAllocationInfo->Flags.Value = 0; - pAllocationInfo->Flags.CpuVisible = 1; - pAllocationInfo->pAllocationUsageHint = NULL; - pAllocationInfo->AllocationPriority = D3DDDI_ALLOCATIONPRIORITY_NORMAL; - } - else - { - drprintf((__FUNCTION__ ": ERROR: failed to create allocation description\n")); - Status = STATUS_NO_MEMORY; - } - } - else - { - drprintf((__FUNCTION__ ": ERROR: PrivateDriverDataSize(%d) less than cmd size(%d)\n", pAllocationInfo->PrivateDriverDataSize, VBOXWDDM_ALLOCINFO_HEADSIZE())); - Status = STATUS_INVALID_PARAMETER; - } - break; - } - default: - drprintf((__FUNCTION__ ": ERROR: invalid alloc info type(%d)\n", pAllocInfo->enmType)); - Status = STATUS_INVALID_PARAMETER; - break; - } + break; + } + + if (Status != STATUS_SUCCESS) + vboxWddmMemFree(pAllocation); + } + else + { + drprintf((__FUNCTION__ ": ERROR: failed to create allocation description\n")); + Status = STATUS_NO_MEMORY; + } + } else { - drprintf((__FUNCTION__ ": ERROR: PrivateDriverDataSize(%d) less than header size(%d)\n", pAllocationInfo->PrivateDriverDataSize, VBOXWDDM_ALLOCINFO_HEADSIZE())); + drprintf((__FUNCTION__ ": ERROR: PrivateDriverDataSize(%d) less than header size(%d)\n", pAllocationInfo->PrivateDriverDataSize, sizeof (VBOXWDDM_ALLOCINFO))); Status = STATUS_INVALID_PARAMETER; } @@ -1658,4 +1498,10 @@ NTSTATUS Status = STATUS_SUCCESS; + if (pCreateAllocation->PrivateDriverDataSize) + { + /* @todo: Implement Resource Data Handling */ + drprintf((__FUNCTION__ ": WARNING: Implement Resource Data Handling\n")); + } + for (UINT i = 0; i < pCreateAllocation->NumAllocations; ++i) { @@ -1717,7 +1563,7 @@ PVBOXWDDM_ALLOCATION pAllocation = (PVBOXWDDM_ALLOCATION)pDescribeAllocation->hAllocation; - pDescribeAllocation->Width = pAllocation->u.SurfInfo.width; - pDescribeAllocation->Height = pAllocation->u.SurfInfo.height; - pDescribeAllocation->Format = pAllocation->u.SurfInfo.format; + pDescribeAllocation->Width = pAllocation->SurfDesc.width; + pDescribeAllocation->Height = pAllocation->SurfDesc.height; + pDescribeAllocation->Format = pAllocation->SurfDesc.format; memset (&pDescribeAllocation->MultisampleMethod, 0, sizeof (pDescribeAllocation->MultisampleMethod)); pDescribeAllocation->RefreshRate.Numerator = 60000; @@ -1757,15 +1603,17 @@ { pAllocInfo = (PVBOXWDDM_ALLOCINFO)pGetStandardAllocationDriverData->pAllocationPrivateDriverData; + memset (pAllocInfo, 0, sizeof (VBOXWDDM_ALLOCINFO)); pAllocInfo->enmType = VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE; - pAllocInfo->u.SurfInfo.width = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Width; - pAllocInfo->u.SurfInfo.height = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Height; - pAllocInfo->u.SurfInfo.format = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Format; - pAllocInfo->u.SurfInfo.bpp = vboxWddmCalcBitsPerPixel(pAllocInfo->u.SurfInfo.format); - pAllocInfo->u.SurfInfo.pitch = vboxWddmCalcPitch(pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Width, pAllocInfo->u.SurfInfo.bpp); - PVBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE pInfo = VBOXWDDM_ALLOCINFO_BODY(pAllocInfo, VBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE); - pInfo->RefreshRate = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->RefreshRate; - pInfo->VidPnSourceId = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->VidPnSourceId; - } - pGetStandardAllocationDriverData->AllocationPrivateDriverDataSize = VBOXWDDM_ALLOCINFO_SIZE(VBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE); + pAllocInfo->SurfDesc.width = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Width; + pAllocInfo->SurfDesc.height = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Height; + pAllocInfo->SurfDesc.format = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Format; + pAllocInfo->SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pAllocInfo->SurfDesc.format); + pAllocInfo->SurfDesc.pitch = vboxWddmCalcPitch(pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Width, pAllocInfo->SurfDesc.bpp); + pAllocInfo->SurfDesc.depth = 0; + pAllocInfo->SurfDesc.slicePitch = 0; + pAllocInfo->SurfDesc.RefreshRate = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->RefreshRate; + pAllocInfo->SurfDesc.VidPnSourceId = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->VidPnSourceId; + } + pGetStandardAllocationDriverData->AllocationPrivateDriverDataSize = sizeof (VBOXWDDM_ALLOCINFO); pGetStandardAllocationDriverData->ResourcePrivateDriverDataSize = 0; @@ -1788,13 +1636,18 @@ pAllocInfo = (PVBOXWDDM_ALLOCINFO)pGetStandardAllocationDriverData->pAllocationPrivateDriverData; pAllocInfo->enmType = VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE; - pAllocInfo->u.SurfInfo.width = pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Width; - pAllocInfo->u.SurfInfo.height = pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Height; - pAllocInfo->u.SurfInfo.format = pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Format; - pAllocInfo->u.SurfInfo.bpp = vboxWddmCalcBitsPerPixel(pAllocInfo->u.SurfInfo.format); - pAllocInfo->u.SurfInfo.pitch = vboxWddmCalcPitch(pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Width, pAllocInfo->u.SurfInfo.bpp); - - pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Pitch = pAllocInfo->u.SurfInfo.pitch; + pAllocInfo->SurfDesc.width = pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Width; + pAllocInfo->SurfDesc.height = pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Height; + pAllocInfo->SurfDesc.format = pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Format; + pAllocInfo->SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pAllocInfo->SurfDesc.format); + pAllocInfo->SurfDesc.pitch = vboxWddmCalcPitch(pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Width, pAllocInfo->SurfDesc.bpp); + pAllocInfo->SurfDesc.depth = 0; + pAllocInfo->SurfDesc.slicePitch = 0; + pAllocInfo->SurfDesc.RefreshRate.Numerator = 0; + pAllocInfo->SurfDesc.RefreshRate.Denominator = 1000; + pAllocInfo->SurfDesc.VidPnSourceId = D3DDDI_ID_UNINITIALIZED; + + pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Pitch = pAllocInfo->SurfDesc.pitch; } - pGetStandardAllocationDriverData->AllocationPrivateDriverDataSize = VBOXWDDM_ALLOCINFO_HEADSIZE(); + pGetStandardAllocationDriverData->AllocationPrivateDriverDataSize = sizeof (VBOXWDDM_ALLOCINFO); pGetStandardAllocationDriverData->ResourcePrivateDriverDataSize = 0; @@ -1814,13 +1667,18 @@ pAllocInfo = (PVBOXWDDM_ALLOCINFO)pGetStandardAllocationDriverData->pAllocationPrivateDriverData; pAllocInfo->enmType = VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE; - pAllocInfo->u.SurfInfo.width = pGetStandardAllocationDriverData->pCreateStagingSurfaceData->Width; - pAllocInfo->u.SurfInfo.height = pGetStandardAllocationDriverData->pCreateStagingSurfaceData->Height; - pAllocInfo->u.SurfInfo.format = D3DDDIFMT_X8R8G8B8; /* staging has always always D3DDDIFMT_X8R8G8B8 */ - pAllocInfo->u.SurfInfo.bpp = vboxWddmCalcBitsPerPixel(pAllocInfo->u.SurfInfo.format); - pAllocInfo->u.SurfInfo.pitch = vboxWddmCalcPitch(pGetStandardAllocationDriverData->pCreateStagingSurfaceData->Width, pAllocInfo->u.SurfInfo.bpp); - - pGetStandardAllocationDriverData->pCreateStagingSurfaceData->Pitch = pAllocInfo->u.SurfInfo.pitch; - } - pGetStandardAllocationDriverData->AllocationPrivateDriverDataSize = VBOXWDDM_ALLOCINFO_HEADSIZE(); + pAllocInfo->SurfDesc.width = pGetStandardAllocationDriverData->pCreateStagingSurfaceData->Width; + pAllocInfo->SurfDesc.height = pGetStandardAllocationDriverData->pCreateStagingSurfaceData->Height; + pAllocInfo->SurfDesc.format = D3DDDIFMT_X8R8G8B8; /* staging has always always D3DDDIFMT_X8R8G8B8 */ + pAllocInfo->SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pAllocInfo->SurfDesc.format); + pAllocInfo->SurfDesc.pitch = vboxWddmCalcPitch(pGetStandardAllocationDriverData->pCreateStagingSurfaceData->Width, pAllocInfo->SurfDesc.bpp); + pAllocInfo->SurfDesc.depth = 0; + pAllocInfo->SurfDesc.slicePitch = 0; + pAllocInfo->SurfDesc.RefreshRate.Numerator = 0; + pAllocInfo->SurfDesc.RefreshRate.Denominator = 1000; + pAllocInfo->SurfDesc.VidPnSourceId = D3DDDI_ID_UNINITIALIZED; + + pGetStandardAllocationDriverData->pCreateStagingSurfaceData->Pitch = pAllocInfo->SurfDesc.pitch; + } + pGetStandardAllocationDriverData->AllocationPrivateDriverDataSize = sizeof (VBOXWDDM_ALLOCINFO); pGetStandardAllocationDriverData->ResourcePrivateDriverDataSize = 0; @@ -2929,11 +2787,10 @@ { Assert(pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE); - PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimary = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE); pAllocation->offVram = (VBOXVIDEOOFFSET)pSetVidPnSourceAddress->PrimaryAddress.QuadPart; pAllocation->SegmentId = pSetVidPnSourceAddress->PrimarySegment; Assert (pAllocation->SegmentId); - Assert (!pPrimary->bVisible); + Assert (!pAllocation->bVisible); #ifndef VBOXWDDM_RENDER_FROM_SHADOW - if (pPrimary->bVisible) + if (pAllocation->bVisible) { /* should not generally happen, but still inform host*/ @@ -2983,12 +2840,11 @@ PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pSetVidPnSourceVisibility->VidPnSourceId]; PVBOXWDDM_ALLOCATION pAllocation = pSource->pPrimaryAllocation; - PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimary = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE); - - Assert(pPrimary->bVisible != pSetVidPnSourceVisibility->Visible); - if (pPrimary->bVisible != pSetVidPnSourceVisibility->Visible) - { - pPrimary->bVisible = pSetVidPnSourceVisibility->Visible; + + Assert(pAllocation->bVisible != pSetVidPnSourceVisibility->Visible); + if (pAllocation->bVisible != pSetVidPnSourceVisibility->Visible) + { + pAllocation->bVisible = pSetVidPnSourceVisibility->Visible; #ifndef VBOXWDDM_RENDER_FROM_SHADOW - if (pPrimary->bVisible) + if (pAllocation->bVisible) { Status = vboxWddmGhDisplaySetInfo(pDevExt, pSource); @@ -3368,9 +3224,9 @@ DECLINLINE(VOID) vboxWddmSurfDescFromAllocation(PVBOXWDDM_ALLOCATION pAllocation, PVBOXVDMA_SURF_DESC pDesc) { - pDesc->width = pAllocation->u.SurfInfo.width; - pDesc->height = pAllocation->u.SurfInfo.height; - pDesc->format = vboxWddmFromPixFormat(pAllocation->u.SurfInfo.format); - pDesc->bpp = pAllocation->u.SurfInfo.bpp; - pDesc->pitch = pAllocation->u.SurfInfo.pitch; + pDesc->width = pAllocation->SurfDesc.width; + pDesc->height = pAllocation->SurfDesc.height; + pDesc->format = vboxWddmFromPixFormat(pAllocation->SurfDesc.format); + pDesc->bpp = pAllocation->SurfDesc.bpp; + pDesc->pitch = pAllocation->SurfDesc.pitch; pDesc->fFlags = 0; } @@ -3384,22 +3240,21 @@ } -DECLINLINE(PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE) vboxWddmCheckForVisiblePrimary(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pAllocation) +DECLINLINE(bool) vboxWddmCheckForVisiblePrimary(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pAllocation) { if (pAllocation->enmType != VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE) - return NULL; - - PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimary = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE); - if (!pPrimary->bVisible) - return NULL; - - D3DDDI_VIDEO_PRESENT_SOURCE_ID id = pPrimary->VidPnSourceId; + return false; + + if (!pAllocation->bVisible) + return false; + + D3DDDI_VIDEO_PRESENT_SOURCE_ID id = pAllocation->SurfDesc.VidPnSourceId; if (id >= pDevExt->cSources) - return NULL; + return false; PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[id]; if (pSource->pPrimaryAllocation != pAllocation) - return NULL; - - return pPrimary; + return false; + + return true; } @@ -3456,12 +3311,11 @@ && pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE) { - PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimaryInfo = VBOXWDDM_ALLOCATION_BODY(pDstAlloc, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE); - Assert(pPrimaryInfo->bAssigned); - Assert(pPrimaryInfo->bVisible); - if (pPrimaryInfo->bAssigned - && pPrimaryInfo->bVisible) + Assert(pDstAlloc->bAssigned); + Assert(pDstAlloc->bVisible); + if (pDstAlloc->bAssigned + && pDstAlloc->bVisible) { - VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pPrimaryInfo->VidPnSourceId]; - vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pPrimaryInfo->VidPnSourceId); + VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pDstAlloc->SurfDesc.VidPnSourceId]; + vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pDstAlloc->SurfDesc.VidPnSourceId); Assert(pPresent->SrcRect.left == pPresent->DstRect.left); Assert(pPresent->SrcRect.right == pPresent->DstRect.right); @@ -3507,5 +3361,5 @@ /* we do not know the shadow address yet, perform dummy DMA cycle */ pPrivateData->rect = rect; - pPrivateData->srcId = pPrimaryInfo->VidPnSourceId; + pPrivateData->srcId = pDstAlloc->SurfDesc.VidPnSourceId; pPrivateData->enmCmd = VBOXVDMACMD_TYPE_DMA_PRESENT_SHADOW2PRIMARY; if (pSrc->SegmentId) @@ -3537,5 +3391,5 @@ if (cbCmd >= VBOXVDMACMD_DMA_PRESENT_BLT_MINSIZE()) { - if (vboxWddmPixFormatConversionSupported(pSrcAlloc->u.SurfInfo.format, pDstAlloc->u.SurfInfo.format)) + if (vboxWddmPixFormatConversionSupported(pSrcAlloc->SurfDesc.format, pDstAlloc->SurfDesc.format)) { memset(pPresent->pPatchLocationListOut, 0, 2*sizeof (D3DDDI_PATCHLOCATIONLIST)); @@ -3582,5 +3436,5 @@ { AssertBreakpoint(); - drprintf((__FUNCTION__": unsupported format conversion from(%d) to (%d)\n",pSrcAlloc->u.SurfInfo.format, pDstAlloc->u.SurfInfo.format)); + drprintf((__FUNCTION__": unsupported format conversion from(%d) to (%d)\n",pSrcAlloc->SurfDesc.format, pDstAlloc->SurfDesc.format)); Status = STATUS_GRAPHICS_CANNOTCOLORCONVERT; } @@ -3626,5 +3480,5 @@ if (pDstAlloc) { - if (vboxWddmPixFormatConversionSupported(pSrcAlloc->u.SurfInfo.format, pDstAlloc->u.SurfInfo.format)) + if (vboxWddmPixFormatConversionSupported(pSrcAlloc->SurfDesc.format, pDstAlloc->SurfDesc.format)) { memset(pPresent->pPatchLocationListOut, 0, 2*sizeof (D3DDDI_PATCHLOCATIONLIST)); @@ -3670,5 +3524,5 @@ { AssertBreakpoint(); - drprintf((__FUNCTION__": unsupported format conversion from(%d) to (%d)\n",pSrcAlloc->u.SurfInfo.format, pDstAlloc->u.SurfInfo.format)); + drprintf((__FUNCTION__": unsupported format conversion from(%d) to (%d)\n",pSrcAlloc->SurfDesc.format, pDstAlloc->SurfDesc.format)); Status = STATUS_GRAPHICS_CANNOTCOLORCONVERT; } Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.h (revision 29882) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.h (revision 29883) @@ -44,15 +44,7 @@ #endif -#define VBOXWDDM_ROUNDBOUND(_v, _b) (((_v) + ((_b) - 1)) & ~((_b) - 1)) - PVOID vboxWddmMemAlloc(IN SIZE_T cbSize); PVOID vboxWddmMemAllocZero(IN SIZE_T cbSize); VOID vboxWddmMemFree(PVOID pvMem); - -typedef struct VBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE -{ - D3DDDI_RATIONAL RefreshRate; - D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; -} VBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE, *PVBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE; /* allocation */ @@ -62,35 +54,22 @@ UINT SegmentId; VBOXVIDEOOFFSET offVram; - union - { - VBOXWDDM_SURFACE_DESC SurfInfo; - } u; + BOOLEAN bVisible; + BOOLEAN bAssigned; + VBOXWDDM_SURFACE_DESC SurfDesc; } VBOXWDDM_ALLOCATION, *PVBOXWDDM_ALLOCATION; -#define VBOXWDDM_ALLOCATION_HEADSIZE() (sizeof (VBOXWDDM_ALLOCATION)) -#define VBOXWDDM_ALLOCATION_SIZE_FROMBODYSIZE(_s) (VBOXWDDM_ALLOCATION_HEADSIZE() + (_s)) -#define VBOXWDDM_ALLOCATION_SIZE(_tCmd) (VBOXWDDM_ALLOCATION_SIZE_FROMBODYSIZE(sizeof(_tCmd))) -#define VBOXWDDM_ALLOCATION_BODY(_p, _t) ( (_t*)(((uint8_t*)(_p)) + VBOXWDDM_ALLOCATION_HEADSIZE()) ) -#define VBOXWDDM_ALLOCATION_HEAD(_pb) ((VBOXWDDM_ALLOCATION*)((uint8_t *)(_pb) - VBOXWDDM_ALLOCATION_HEADSIZE())) - - -typedef struct VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE +typedef struct VBOXWDDM_RESOURCE { + VBOXWDDM_ALLOC_TYPE enmType; + UINT SegmentId; + VBOXVIDEOOFFSET offVram; D3DDDI_RATIONAL RefreshRate; D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; -// VBOXVIDEOOFFSET offAddress; BOOLEAN bVisible; BOOLEAN bAssigned; -} VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE, *PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE; + VBOXWDDM_SURFACE_DESC SurfDesc; + uint32_t cAllocations; +} VBOXWDDM_RESOURCE, *PVBOXWDDM_RESOURCE; -#ifdef VBOXWDDM_RENDER_FROM_SHADOW -typedef struct VBOXWDDM_ALLOCATION_SHADOWSURFACE -{ - D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; -// VBOXVIDEOOFFSET offAddress; - BOOLEAN bVisible; - BOOLEAN bAssigned; -} VBOXWDDM_ALLOCATION_SHADOWSURFACE, *PVBOXWDDM_ALLOCATION_SHADOWSURFACE; -#endif typedef enum