Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/common/wddm/VBoxMPIf.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/common/wddm/VBoxMPIf.h (revision 43235) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/common/wddm/VBoxMPIf.h (revision 43236) @@ -574,7 +574,4 @@ return 8; case D3DDDIFMT_INDEX32: -#ifdef DEBUG_misha - Assert(0); /* <- test correctness */ -#endif return 8; default: Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/Makefile.kmk =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/Makefile.kmk (revision 43235) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/Makefile.kmk (revision 43236) @@ -118,4 +118,5 @@ wddm/VBoxDispKmt.cpp \ wddm/VBoxDispDbg.cpp \ + wddm/VBoxD3DIf.cpp \ wddm/VBoxDispD3D.rc \ wddm/VBoxDispD3D.def Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxD3DIf.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxD3DIf.cpp (revision 43236) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxD3DIf.cpp (revision 43236) @@ -0,0 +1,872 @@ +/* $Id$ */ + +/** @file + * VBoxVideo Display D3D User mode dll + */ + +/* + * Copyright (C) 2012 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ +#include "VBoxDispD3DCmn.h" + +/* DDI2D3D */ + +D3DFORMAT vboxDDI2D3DFormat(D3DDDIFORMAT format) +{ + /* @todo: check they are all equal */ + return (D3DFORMAT)format; +} + +D3DMULTISAMPLE_TYPE vboxDDI2D3DMultiSampleType(D3DDDIMULTISAMPLE_TYPE enmType) +{ + /* @todo: check they are all equal */ + return (D3DMULTISAMPLE_TYPE)enmType; +} + +D3DPOOL vboxDDI2D3DPool(D3DDDI_POOL enmPool) +{ + /* @todo: check they are all equal */ + switch (enmPool) + { + case D3DDDIPOOL_SYSTEMMEM: + return D3DPOOL_SYSTEMMEM; + case D3DDDIPOOL_VIDEOMEMORY: + case D3DDDIPOOL_LOCALVIDMEM: + case D3DDDIPOOL_NONLOCALVIDMEM: + /* @todo: what would be proper here? */ + return D3DPOOL_DEFAULT; + default: + Assert(0); + } + return D3DPOOL_DEFAULT; +} + +D3DRENDERSTATETYPE vboxDDI2D3DRenderStateType(D3DDDIRENDERSTATETYPE enmType) +{ + /* @todo: @fixme: not entirely correct, need to check */ + return (D3DRENDERSTATETYPE)enmType; +} + +VBOXWDDMDISP_TSS_LOOKUP vboxDDI2D3DTestureStageStateType(D3DDDITEXTURESTAGESTATETYPE enmType) +{ + static const VBOXWDDMDISP_TSS_LOOKUP lookup[] = + { + {FALSE, D3DTSS_FORCE_DWORD}, /* 0, D3DDDITSS_TEXTUREMAP */ + {FALSE, D3DTSS_COLOROP}, /* 1, D3DDDITSS_COLOROP */ + {FALSE, D3DTSS_COLORARG1}, /* 2, D3DDDITSS_COLORARG1 */ + {FALSE, D3DTSS_COLORARG2}, /* 3, D3DDDITSS_COLORARG2 */ + {FALSE, D3DTSS_ALPHAOP}, /* 4, D3DDDITSS_ALPHAOP */ + {FALSE, D3DTSS_ALPHAARG1}, /* 5, D3DDDITSS_ALPHAARG1 */ + {FALSE, D3DTSS_ALPHAARG2}, /* 6, D3DDDITSS_ALPHAARG2 */ + {FALSE, D3DTSS_BUMPENVMAT00}, /* 7, D3DDDITSS_BUMPENVMAT00 */ + {FALSE, D3DTSS_BUMPENVMAT01}, /* 8, D3DDDITSS_BUMPENVMAT01 */ + {FALSE, D3DTSS_BUMPENVMAT10}, /* 9, D3DDDITSS_BUMPENVMAT10 */ + {FALSE, D3DTSS_BUMPENVMAT11}, /* 10, D3DDDITSS_BUMPENVMAT11 */ + {FALSE, D3DTSS_TEXCOORDINDEX}, /* 11, D3DDDITSS_TEXCOORDINDEX */ + {FALSE, D3DTSS_FORCE_DWORD}, /* 12, unused */ + {TRUE, D3DSAMP_ADDRESSU}, /* 13, D3DDDITSS_ADDRESSU */ + {TRUE, D3DSAMP_ADDRESSV}, /* 14, D3DDDITSS_ADDRESSV */ + {TRUE, D3DSAMP_BORDERCOLOR}, /* 15, D3DDDITSS_BORDERCOLOR */ + {TRUE, D3DSAMP_MAGFILTER}, /* 16, D3DDDITSS_MAGFILTER */ + {TRUE, D3DSAMP_MINFILTER}, /* 17, D3DDDITSS_MINFILTER */ + {TRUE, D3DSAMP_MIPFILTER}, /* 18, D3DDDITSS_MIPFILTER */ + {TRUE, D3DSAMP_MIPMAPLODBIAS}, /* 19, D3DDDITSS_MIPMAPLODBIAS */ + {TRUE, D3DSAMP_MAXMIPLEVEL}, /* 20, D3DDDITSS_MAXMIPLEVEL */ + {TRUE, D3DSAMP_MAXANISOTROPY}, /* 21, D3DDDITSS_MAXANISOTROPY */ + {FALSE, D3DTSS_BUMPENVLSCALE}, /* 22, D3DDDITSS_BUMPENVLSCALE */ + {FALSE, D3DTSS_BUMPENVLOFFSET}, /* 23, D3DDDITSS_BUMPENVLOFFSET */ + {FALSE, D3DTSS_TEXTURETRANSFORMFLAGS}, /* 24, D3DDDITSS_TEXTURETRANSFORMFLAGS */ + {TRUE, D3DSAMP_ADDRESSW}, /* 25, D3DDDITSS_ADDRESSW */ + {FALSE, D3DTSS_COLORARG0}, /* 26, D3DDDITSS_COLORARG0 */ + {FALSE, D3DTSS_ALPHAARG0}, /* 27, D3DDDITSS_ALPHAARG0 */ + {FALSE, D3DTSS_RESULTARG}, /* 28, D3DDDITSS_RESULTARG */ + {TRUE, D3DSAMP_SRGBTEXTURE}, /* 29, D3DDDITSS_SRGBTEXTURE */ + {TRUE, D3DSAMP_ELEMENTINDEX}, /* 30, D3DDDITSS_ELEMENTINDEX */ + {TRUE, D3DSAMP_DMAPOFFSET}, /* 31, D3DDDITSS_DMAPOFFSET */ + {FALSE, D3DTSS_CONSTANT}, /* 32, D3DDDITSS_CONSTANT */ + {FALSE, D3DTSS_FORCE_DWORD}, /* 33, D3DDDITSS_DISABLETEXTURECOLORKEY */ + {FALSE, D3DTSS_FORCE_DWORD}, /* 34, D3DDDITSS_TEXTURECOLORKEYVAL */ + }; + + Assert(enmType > 0); + Assert(enmType < RT_ELEMENTS(lookup)); + Assert(lookup[enmType].dType != D3DTSS_FORCE_DWORD); + + return lookup[enmType]; +} + +DWORD vboxDDI2D3DUsage(D3DDDI_RESOURCEFLAGS fFlags) +{ + DWORD fUsage = 0; + if (fFlags.Dynamic) + fUsage |= D3DUSAGE_DYNAMIC; + if (fFlags.AutogenMipmap) + fUsage |= D3DUSAGE_AUTOGENMIPMAP; + if (fFlags.DMap) + fUsage |= D3DUSAGE_DMAP; + if (fFlags.WriteOnly) + fUsage |= D3DUSAGE_WRITEONLY; + if (fFlags.NPatches) + fUsage |= D3DUSAGE_NPATCHES; + if (fFlags.Points) + fUsage |= D3DUSAGE_POINTS; + if (fFlags.RenderTarget) + fUsage |= D3DUSAGE_RENDERTARGET; + if (fFlags.RtPatches) + fUsage |= D3DUSAGE_RTPATCHES; + if (fFlags.TextApi) + fUsage |= D3DUSAGE_TEXTAPI; + if (fFlags.WriteOnly) + fUsage |= D3DUSAGE_WRITEONLY; + //below are wddm 1.1-specific +// if (fFlags.RestrictedContent) +// fUsage |= D3DUSAGE_RESTRICTED_CONTENT; +// if (fFlags.RestrictSharedAccess) +// fUsage |= D3DUSAGE_RESTRICT_SHARED_RESOURCE; + return fUsage; +} + +DWORD vboxDDI2D3DLockFlags(D3DDDI_LOCKFLAGS fLockFlags) +{ + DWORD fFlags = 0; + if (fLockFlags.Discard) + fFlags |= D3DLOCK_DISCARD; + if (fLockFlags.NoOverwrite) + fFlags |= D3DLOCK_NOOVERWRITE; + if (fLockFlags.ReadOnly) + fFlags |= D3DLOCK_READONLY; + if (fLockFlags.DoNotWait) + fFlags |= D3DLOCK_DONOTWAIT; + return fFlags; +} + +D3DTEXTUREFILTERTYPE vboxDDI2D3DBltFlags(D3DDDI_BLTFLAGS fFlags) +{ + if (fFlags.Point) + { + /* no flags other than [Begin|Continue|End]PresentToDwm are set */ + Assert((fFlags.Value & (~(0x00000100 | 0x00000200 | 0x00000400))) == 1); + return D3DTEXF_POINT; + } + if (fFlags.Linear) + { + /* no flags other than [Begin|Continue|End]PresentToDwm are set */ + Assert((fFlags.Value & (~(0x00000100 | 0x00000200 | 0x00000400))) == 2); + return D3DTEXF_LINEAR; + } + /* no flags other than [Begin|Continue|End]PresentToDwm are set */ + Assert((fFlags.Value & (~(0x00000100 | 0x00000200 | 0x00000400))) == 0); + return D3DTEXF_NONE; +} + +D3DQUERYTYPE vboxDDI2D3DQueryType(D3DDDIQUERYTYPE enmType) +{ + return (D3DQUERYTYPE)enmType; +} + +DWORD vboxDDI2D3DIssueQueryFlags(D3DDDI_ISSUEQUERYFLAGS Flags) +{ + DWORD fFlags = 0; + if (Flags.Begin) + fFlags |= D3DISSUE_BEGIN; + if (Flags.End) + fFlags |= D3DISSUE_END; + return fFlags; +} + +/**/ + +/* D3DIf API */ +static HRESULT vboxDispD3DIfSurfSynchMem(PVBOXWDDMDISP_RESOURCE pRc) +{ + if (pRc->RcDesc.enmPool != D3DDDIPOOL_SYSTEMMEM) + { + return S_OK; + } + + for (UINT i = 0; i < pRc->cAllocations; ++i) + { + D3DLOCKED_RECT Rect; + HRESULT hr = VBoxD3DIfLockRect(pRc, i, &Rect, NULL, D3DLOCK_DISCARD); + if (FAILED(hr)) + { + WARN(("VBoxD3DIfLockRect failed, hr(0x%x)", hr)); + return hr; + } + + PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i]; + Assert(pAlloc->pvMem); + + VBoxD3DIfLockUnlockMemSynch(pAlloc, &Rect, NULL, true /*bool bToLockInfo*/); + + hr = VBoxD3DIfUnlockRect(pRc, i); + Assert(SUCCEEDED(hr)); + } + return S_OK; +} + +void VBoxD3DIfLockUnlockMemSynch(PVBOXWDDMDISP_ALLOCATION pAlloc, D3DLOCKED_RECT *pLockInfo, RECT *pRect, bool bToLockInfo) +{ + Assert(pAlloc->SurfDesc.pitch); + Assert(pAlloc->pvMem); + + if (!pRect) + { + if (pAlloc->SurfDesc.pitch == pLockInfo->Pitch) + { + Assert(pAlloc->SurfDesc.cbSize); + if (bToLockInfo) + memcpy(pLockInfo->pBits, pAlloc->pvMem, pAlloc->SurfDesc.cbSize); + else + memcpy(pAlloc->pvMem, pLockInfo->pBits, pAlloc->SurfDesc.cbSize); + } + else + { + uint8_t *pvSrc, *pvDst; + uint32_t srcPitch, dstPitch; + if (bToLockInfo) + { + pvSrc = (uint8_t *)pAlloc->pvMem; + pvDst = (uint8_t *)pLockInfo->pBits; + srcPitch = pAlloc->SurfDesc.pitch; + dstPitch = pLockInfo->Pitch; + } + else + { + pvDst = (uint8_t *)pAlloc->pvMem; + pvSrc = (uint8_t *)pLockInfo->pBits; + dstPitch = pAlloc->SurfDesc.pitch; + srcPitch = (uint32_t)pLockInfo->Pitch; + } + + uint32_t cRows = vboxWddmCalcNumRows(0, pAlloc->SurfDesc.height, pAlloc->SurfDesc.format); + uint32_t pitch = RT_MIN(srcPitch, dstPitch); + Assert(pitch); + for (UINT j = 0; j < cRows; ++j) + { + memcpy(pvDst, pvSrc, pitch); + pvSrc += srcPitch; + pvDst += dstPitch; + } + } + } + else + { + uint8_t *pvSrc, *pvDst; + uint32_t srcPitch, dstPitch; + uint8_t * pvAllocMemStart = (uint8_t *)pAlloc->pvMem; + uint32_t offAllocMemStart = vboxWddmCalcOffXYrd(pRect->left, pRect->top, pAlloc->SurfDesc.pitch, pAlloc->SurfDesc.format); + pvAllocMemStart += offAllocMemStart; + + if (bToLockInfo) + { + pvSrc = (uint8_t *)pvAllocMemStart; + pvDst = (uint8_t *)pLockInfo->pBits; + srcPitch = pAlloc->SurfDesc.pitch; + dstPitch = pLockInfo->Pitch; + } + else + { + pvDst = (uint8_t *)pvAllocMemStart; + pvSrc = (uint8_t *)pLockInfo->pBits; + dstPitch = pAlloc->SurfDesc.pitch; + srcPitch = (uint32_t)pLockInfo->Pitch; + } + + if (pRect->right - pRect->left == pAlloc->SurfDesc.width && srcPitch == dstPitch) + { + uint32_t cbSize = vboxWddmCalcSize(pAlloc->SurfDesc.pitch, pRect->bottom - pRect->top, pAlloc->SurfDesc.format); + memcpy(pvDst, pvSrc, cbSize); + } + else + { + uint32_t pitch = RT_MIN(srcPitch, dstPitch); + uint32_t cbCopyLine = vboxWddmCalcRowSize(pRect->left, pRect->right, pAlloc->SurfDesc.format); + Assert(pitch); + uint32_t cRows = vboxWddmCalcNumRows(pRect->top, pRect->bottom, pAlloc->SurfDesc.format); + for (UINT j = 0; j < cRows; ++j) + { + memcpy(pvDst, pvSrc, cbCopyLine); + pvSrc += srcPitch; + pvDst += dstPitch; + } + } + } +} + +HRESULT VBoxD3DIfLockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc, + D3DLOCKED_RECT * pLockedRect, + CONST RECT *pRect, + DWORD fLockFlags) +{ + HRESULT hr = E_FAIL; + Assert(!pRc->aAllocations[iAlloc].LockInfo.cLocks); + Assert(pRc->cAllocations > iAlloc); + switch (pRc->aAllocations[0].enmD3DIfType) + { + case VBOXDISP_D3DIFTYPE_SURFACE: + { + IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pRc->aAllocations[iAlloc].pD3DIf; + Assert(pD3DIfSurf); + hr = pD3DIfSurf->LockRect(pLockedRect, pRect, fLockFlags); + Assert(hr == S_OK); + break; + } + case VBOXDISP_D3DIFTYPE_TEXTURE: + { + IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf; + Assert(pD3DIfTex); + hr = pD3DIfTex->LockRect(iAlloc, pLockedRect, pRect, fLockFlags); + Assert(hr == S_OK); + break; + } + case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE: + { + IDirect3DCubeTexture9 *pD3DIfCubeTex = (IDirect3DCubeTexture9*)pRc->aAllocations[0].pD3DIf; + Assert(pD3DIfCubeTex); + hr = pD3DIfCubeTex->LockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, iAlloc), + VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, iAlloc), pLockedRect, pRect, fLockFlags); + Assert(hr == S_OK); + break; + } + case VBOXDISP_D3DIFTYPE_VERTEXBUFFER: + { + IDirect3DVertexBuffer9 *pD3D9VBuf = (IDirect3DVertexBuffer9*)pRc->aAllocations[iAlloc].pD3DIf; + Assert(pD3D9VBuf); + hr = pD3D9VBuf->Lock(pRect ? pRect->left : 0/* offset */, + pRect ? pRect->right : 0 /* size 2 lock - 0 means all */, + &pLockedRect->pBits, fLockFlags); + Assert(hr == S_OK); + pLockedRect->Pitch = pRc->aAllocations[iAlloc].SurfDesc.pitch; + break; + } + case VBOXDISP_D3DIFTYPE_INDEXBUFFER: + { + IDirect3DIndexBuffer9 *pD3D9IBuf = (IDirect3DIndexBuffer9*)pRc->aAllocations[iAlloc].pD3DIf; + Assert(pD3D9IBuf); + hr = pD3D9IBuf->Lock(pRect ? pRect->left : 0/* offset */, + pRect ? pRect->right : 0 /* size 2 lock - 0 means all */, + &pLockedRect->pBits, fLockFlags); + Assert(hr == S_OK); + pLockedRect->Pitch = pRc->aAllocations[iAlloc].SurfDesc.pitch; + break; + } + default: + WARN(("uknown if type %d", pRc->aAllocations[0].enmD3DIfType)); + break; + } + return hr; +} + +HRESULT VBoxD3DIfUnlockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc) +{ + HRESULT hr = S_OK; + Assert(pRc->cAllocations > iAlloc); + switch (pRc->aAllocations[0].enmD3DIfType) + { + case VBOXDISP_D3DIFTYPE_SURFACE: + { + IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pRc->aAllocations[iAlloc].pD3DIf; + Assert(pD3DIfSurf); + hr = pD3DIfSurf->UnlockRect(); + Assert(hr == S_OK); + break; + } + case VBOXDISP_D3DIFTYPE_TEXTURE: + { + IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf; + Assert(pD3DIfTex); + hr = pD3DIfTex->UnlockRect(iAlloc); + Assert(hr == S_OK); + break; + } + case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE: + { + IDirect3DCubeTexture9 *pD3DIfCubeTex = (IDirect3DCubeTexture9*)pRc->aAllocations[0].pD3DIf; + Assert(pD3DIfCubeTex); + hr = pD3DIfCubeTex->UnlockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, iAlloc), + VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, iAlloc)); + Assert(hr == S_OK); + break; + } + case VBOXDISP_D3DIFTYPE_VERTEXBUFFER: + { + IDirect3DVertexBuffer9 *pD3D9VBuf = (IDirect3DVertexBuffer9*)pRc->aAllocations[iAlloc].pD3DIf; + Assert(pD3D9VBuf); + hr = pD3D9VBuf->Unlock(); + Assert(hr == S_OK); + break; + } + case VBOXDISP_D3DIFTYPE_INDEXBUFFER: + { + IDirect3DIndexBuffer9 *pD3D9IBuf = (IDirect3DIndexBuffer9*)pRc->aAllocations[iAlloc].pD3DIf; + Assert(pD3D9IBuf); + hr = pD3D9IBuf->Unlock(); + Assert(hr == S_OK); + break; + } + default: + WARN(("uknown if type %d", pRc->aAllocations[0].enmD3DIfType)); + hr = E_FAIL; + break; + } + return hr; +} + +HRESULT VBoxD3DIfCreateForRc(struct VBOXWDDMDISP_RESOURCE *pRc) +{ + PVBOXWDDMDISP_DEVICE pDevice = pRc->pDevice; + HRESULT hr = E_FAIL; + IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice); + if (pRc->RcDesc.fFlags.ZBuffer) + { + for (UINT i = 0; i < pRc->cAllocations; ++i) + { + PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i]; + IDirect3DSurface9 *pD3D9Surf; + hr = pDevice9If->CreateDepthStencilSurface(pAllocation->SurfDesc.width, + pAllocation->SurfDesc.height, + vboxDDI2D3DFormat(pRc->RcDesc.enmFormat), + vboxDDI2D3DMultiSampleType(pRc->RcDesc.enmMultisampleType), + pRc->RcDesc.MultisampleQuality, + TRUE /* @todo: BOOL Discard */, + &pD3D9Surf, + NULL /*HANDLE* pSharedHandle*/); + Assert(hr == S_OK); + if (hr == S_OK) + { + Assert(pD3D9Surf); + pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE; + pAllocation->pD3DIf = pD3D9Surf; + } + else + { + for (UINT j = 0; j < i; ++j) + { + pRc->aAllocations[j].pD3DIf->Release(); + } + break; + } + } + + if (SUCCEEDED(hr)) + { + if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM) + { + vboxDispD3DIfSurfSynchMem(pRc); + } + } + } + else if (pRc->RcDesc.fFlags.VertexBuffer) + { + for (UINT i = 0; i < pRc->cAllocations; ++i) + { + PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i]; + IDirect3DVertexBuffer9 *pD3D9VBuf; + hr = pDevice9If->CreateVertexBuffer(pAllocation->SurfDesc.width, + vboxDDI2D3DUsage(pRc->RcDesc.fFlags), + pRc->RcDesc.Fvf, + vboxDDI2D3DPool(pRc->RcDesc.enmPool), + &pD3D9VBuf, + NULL /*HANDLE* pSharedHandle*/); + Assert(hr == S_OK); + if (hr == S_OK) + { + Assert(pD3D9VBuf); + pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_VERTEXBUFFER; + pAllocation->pD3DIf = pD3D9VBuf; + } + else + { + for (UINT j = 0; j < i; ++j) + { + pRc->aAllocations[j].pD3DIf->Release(); + } + break; + } + } + + if (SUCCEEDED(hr)) + { + if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM) + { + vboxDispD3DIfSurfSynchMem(pRc); + } + } + } + else if (pRc->RcDesc.fFlags.IndexBuffer) + { + for (UINT i = 0; i < pRc->cAllocations; ++i) + { + PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i]; + IDirect3DIndexBuffer9 *pD3D9IBuf; + hr = pDevice9If->CreateIndexBuffer(pAllocation->SurfDesc.width, + vboxDDI2D3DUsage(pRc->RcDesc.fFlags), + vboxDDI2D3DFormat(pRc->RcDesc.enmFormat), + vboxDDI2D3DPool(pRc->RcDesc.enmPool), + &pD3D9IBuf, + NULL /*HANDLE* pSharedHandle*/ + ); + Assert(hr == S_OK); + if (hr == S_OK) + { + Assert(pD3D9IBuf); + pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_INDEXBUFFER; + pAllocation->pD3DIf = pD3D9IBuf; + } + else + { + for (UINT j = 0; j < i; ++j) + { + pRc->aAllocations[j].pD3DIf->Release(); + } + break; + } + } + + if (SUCCEEDED(hr)) + { + if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM) + { + vboxDispD3DIfSurfSynchMem(pRc); + } + } + } + else if (VBOXWDDMDISP_IS_TEXTURE(pRc->RcDesc.fFlags)) + { + if (!pRc->RcDesc.fFlags.CubeMap) + { +#ifdef DEBUG + { + PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[0]; + uint32_t tstW = pAlloc->SurfDesc.width; + uint32_t tstH = pAlloc->SurfDesc.height; + for (UINT i = 1; i < pRc->cAllocations; ++i) + { + tstW /= 2; + tstH /= 2; + pAlloc = &pRc->aAllocations[i]; + Assert((pAlloc->SurfDesc.width == tstW) || (!tstW && (pAlloc->SurfDesc.width==1))); + Assert((pAlloc->SurfDesc.height == tstH) || (!tstH && (pAlloc->SurfDesc.height==1))); + } + } +#endif + PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0]; + IDirect3DTexture9 *pD3DIfTex; + HANDLE hSharedHandle = pAllocation->hSharedHandle; + void **pavClientMem = NULL; + hr = S_OK; + if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM) + { + Assert(pAllocation->pvMem); + Assert(pAllocation->SurfDesc.pitch); + UINT minPitch = vboxWddmCalcPitch(pAllocation->SurfDesc.width, pAllocation->SurfDesc.format); + Assert(minPitch); + if (minPitch) + { + if (pAllocation->SurfDesc.pitch != minPitch) + { + Assert(pAllocation->SurfDesc.pitch > minPitch); + pAllocation->D3DWidth = vboxWddmCalcWidthForPitch(pAllocation->SurfDesc.pitch, pAllocation->SurfDesc.format); + } + Assert(pAllocation->D3DWidth >= pAllocation->SurfDesc.width); + } + else + { + Assert(pAllocation->D3DWidth == pAllocation->SurfDesc.width); + } + } + if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM) + { + pavClientMem = (void**)RTMemAlloc(sizeof (pavClientMem[0]) * pRc->cAllocations); + Assert(pavClientMem); + if (pavClientMem) + { + for (UINT i = 0; i < pRc->cAllocations; ++i) + { + Assert(pRc->aAllocations[i].pvMem); + pavClientMem[i] = pRc->aAllocations[i].pvMem; + } + } + else + hr = E_FAIL; + } + if (hr == S_OK) + { + hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9CreateTexture((IDirect3DDevice9Ex *)pDevice9If, + pAllocation->D3DWidth, + pAllocation->SurfDesc.height, + pRc->cAllocations, + vboxDDI2D3DUsage(pRc->RcDesc.fFlags), + vboxDDI2D3DFormat(pRc->RcDesc.enmFormat), + vboxDDI2D3DPool(pRc->RcDesc.enmPool), + &pD3DIfTex, +#ifdef VBOXWDDMDISP_DEBUG_NOSHARED + NULL, +#else + pRc->RcDesc.fFlags.SharedResource ? &hSharedHandle : NULL, +#endif + pavClientMem); + Assert(hr == S_OK); + if (hr == S_OK) + { + Assert(pD3DIfTex); +#ifndef VBOXWDDMDISP_DEBUG_NOSHARED + Assert(!!(pRc->RcDesc.fFlags.SharedResource) == !!(hSharedHandle)); +#endif + for (UINT i = 0; i < pRc->cAllocations; ++i) + { + PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i]; + pAlloc->enmD3DIfType = VBOXDISP_D3DIFTYPE_TEXTURE; + pAlloc->pD3DIf = pD3DIfTex; + pAlloc->hSharedHandle = hSharedHandle; + if (i > 0) + pD3DIfTex->AddRef(); + } + } + + if (pavClientMem) + RTMemFree(pavClientMem); + } + } + else /*pRc->RcDesc.fFlags.CubeMap*/ + { + PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0]; + IDirect3DCubeTexture9 *pD3DIfCubeTex; + HANDLE hSharedHandle = pAllocation->hSharedHandle; + void **pavClientMem = NULL; + + if ( (pAllocation->SurfDesc.width!=pAllocation->SurfDesc.height) + || (pRc->cAllocations%6!=0)) + { + Assert(0); + hr = E_INVALIDARG; + } + else + { + hr = S_OK; + if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM) + { + pavClientMem = (void**)RTMemAlloc(sizeof (pavClientMem[0]) * pRc->cAllocations); + Assert(pavClientMem); + if (pavClientMem) + { + for (UINT i = 0; i < pRc->cAllocations; ++i) + { + pavClientMem[i] = pRc->aAllocations[i].pvMem; + } + } + else + hr = E_FAIL; + } + + if (hr == S_OK) + { + hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9CreateCubeTexture((IDirect3DDevice9Ex *)pDevice9If, + pAllocation->SurfDesc.width, + VBOXDISP_CUBEMAP_LEVELS_COUNT(pRc), + vboxDDI2D3DUsage(pRc->RcDesc.fFlags), + vboxDDI2D3DFormat(pRc->RcDesc.enmFormat), + vboxDDI2D3DPool(pRc->RcDesc.enmPool), + &pD3DIfCubeTex, +#ifdef VBOXWDDMDISP_DEBUG_NOSHARED + NULL, +#else + pRc->RcDesc.fFlags.SharedResource ? &hSharedHandle : NULL, +#endif + pavClientMem); + Assert(hr == S_OK); + if (hr == S_OK) + { + Assert(pD3DIfCubeTex); +#ifndef VBOXWDDMDISP_DEBUG_NOSHARED + Assert(!!(pRc->RcDesc.fFlags.SharedResource) == !!(hSharedHandle)); +#endif + + for (UINT i = 0; i < pRc->cAllocations; ++i) + { + PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i]; + pAlloc->enmD3DIfType = VBOXDISP_D3DIFTYPE_CUBE_TEXTURE; + pAlloc->pD3DIf = pD3DIfCubeTex; + pAlloc->hSharedHandle = hSharedHandle; + if (i > 0) + pD3DIfCubeTex->AddRef(); + } + } + + if (pavClientMem) + RTMemFree(pavClientMem); + } + } + } + } + else if (pRc->RcDesc.fFlags.RenderTarget || pRc->RcDesc.fFlags.Primary) + { + for (UINT i = 0; i < pRc->cAllocations; ++i) + { + PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i]; + HANDLE hSharedHandle = pAllocation->hSharedHandle; + IDirect3DSurface9* pD3D9Surf; + switch (pAllocation->enmType) + { + case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC: + { + hr = pDevice9If->CreateRenderTarget(pAllocation->SurfDesc.width, + pAllocation->SurfDesc.height, + vboxDDI2D3DFormat(pRc->RcDesc.enmFormat), + vboxDDI2D3DMultiSampleType(pRc->RcDesc.enmMultisampleType), + pRc->RcDesc.MultisampleQuality, + !pRc->RcDesc.fFlags.NotLockable /* BOOL Lockable */, + &pD3D9Surf, +#ifdef VBOXWDDMDISP_DEBUG_NOSHARED + NULL +#else + pRc->RcDesc.fFlags.SharedResource ? &hSharedHandle : NULL +#endif + ); + Assert(hr == S_OK); + break; + } + case VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE: + { + BOOL bNeedPresent; + if (pRc->cAllocations != 1) + { + WARN(("unexpected config: more than one (%d) shared primary for rc", pRc->cAllocations)); + hr = E_FAIL; + break; + } + PVBOXWDDMDISP_SWAPCHAIN pSwapchain = vboxWddmSwapchainFindCreate(pDevice, pAllocation, &bNeedPresent); + Assert(bNeedPresent); + if (!pSwapchain) + { + WARN(("vboxWddmSwapchainFindCreate failed")); + hr = E_OUTOFMEMORY; + break; + } + + hr = vboxWddmSwapchainChkCreateIf(pDevice, pSwapchain); + if (!SUCCEEDED(hr)) + { + WARN(("vboxWddmSwapchainChkCreateIf failed hr 0x%x", hr)); + Assert(pAllocation->enmD3DIfType == VBOXDISP_D3DIFTYPE_UNDEFINED); + Assert(!pAllocation->pD3DIf); + vboxWddmSwapchainDestroy(pDevice, pSwapchain); + break; + } + + Assert(pAllocation->enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE); + Assert(pAllocation->pD3DIf); + pD3D9Surf = (IDirect3DSurface9*)pAllocation->pD3DIf; + break; + } + default: + { + WARN(("unexpected alloc type %d", pAllocation->enmType)); + hr = E_FAIL; + break; + } + } + + if (SUCCEEDED(hr)) + { + Assert(pD3D9Surf); + pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE; + pAllocation->pD3DIf = pD3D9Surf; +#ifndef VBOXWDDMDISP_DEBUG_NOSHARED + Assert(!!(pRc->RcDesc.fFlags.SharedResource) == !!(hSharedHandle)); +#endif + pAllocation->hSharedHandle = hSharedHandle; + hr = S_OK; + continue; + + /* fail branch */ + pD3D9Surf->Release(); + } + + for (UINT j = 0; j < i; ++j) + { + pRc->aAllocations[j].pD3DIf->Release(); + } + break; + } + + if (SUCCEEDED(hr)) + { + if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM) + { + Assert(0); + vboxDispD3DIfSurfSynchMem(pRc); + } + } + } + else + { + hr = E_FAIL; + WARN(("unsupported rc flags, %d", pRc->RcDesc.fFlags.Value)); + } + + return hr; +} + +VOID VBoxD3DIfFillPresentParams(D3DPRESENT_PARAMETERS *pParams, PVBOXWDDMDISP_RESOURCE pRc, UINT cRTs) +{ + Assert(cRTs); + memset(pParams, 0, sizeof (D3DPRESENT_PARAMETERS)); + pParams->BackBufferWidth = pRc->aAllocations[0].SurfDesc.width; + pParams->BackBufferHeight = pRc->aAllocations[0].SurfDesc.height; + pParams->BackBufferFormat = vboxDDI2D3DFormat(pRc->aAllocations[0].SurfDesc.format); + pParams->BackBufferCount = cRTs - 1; + pParams->MultiSampleType = vboxDDI2D3DMultiSampleType(pRc->RcDesc.enmMultisampleType); + pParams->MultiSampleQuality = pRc->RcDesc.MultisampleQuality; +#if 0 //def VBOXDISP_WITH_WINE_BB_WORKAROUND /* this does not work so far any way :( */ + if (cRTs == 1) + pParams->SwapEffect = D3DSWAPEFFECT_COPY; + else +#endif + if (pRc->RcDesc.fFlags.DiscardRenderTarget) + pParams->SwapEffect = D3DSWAPEFFECT_DISCARD; + pParams->Windowed = TRUE; +} + +HRESULT VBoxD3DIfDeviceCreateDummy(PVBOXWDDMDISP_DEVICE pDevice) +{ + VBOXWDDMDISP_RESOURCE Rc; + vboxWddmResourceInit(&Rc, 1); + + Rc.RcDesc.enmFormat = D3DDDIFMT_A8R8G8B8; + Rc.RcDesc.enmPool = D3DDDIPOOL_LOCALVIDMEM; + Rc.RcDesc.enmMultisampleType = D3DDDIMULTISAMPLE_NONE; + Rc.RcDesc.MultisampleQuality = 0; + PVBOXWDDMDISP_ALLOCATION pAlloc = &Rc.aAllocations[0]; + pAlloc->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE; + pAlloc->SurfDesc.width = 0x4; + pAlloc->SurfDesc.height = 0x4; + pAlloc->SurfDesc.format = D3DDDIFMT_A8R8G8B8; + Assert(!pDevice->pDevice9If); + VBOXWINEEX_D3DPRESENT_PARAMETERS Params; + VBoxD3DIfFillPresentParams(&Params.Base, &Rc, 2); + Params.pHgsmi = &pDevice->Uhgsmi.BasePrivate.Base; + DWORD fFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING; + PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter; + IDirect3DDevice9 * pDevice9If = NULL; + + HRESULT hr = pAdapter->D3D.pD3D9If->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, NULL, fFlags, &Params.Base, &pDevice9If); + if (!SUCCEEDED(hr)) + { + WARN(("CreateDevice failed hr 0x%x", hr)); + return hr; + } + + pDevice->pDevice9If = pDevice9If; + return S_OK; +} + Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxD3DIf.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxD3DIf.h (revision 43236) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxD3DIf.h (revision 43236) @@ -0,0 +1,154 @@ +/* $Id$ */ + +/** @file + * VBoxVideo Display D3D User mode dll + */ + +/* + * Copyright (C) 2012 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#ifndef ___VBoxDispD3DRcIf_h__ +#define ___VBoxDispD3DRcIf_h__ + +#include "VBoxDispD3DCmn.h" + +static D3DFORMAT vboxDDI2D3DFormat(D3DDDIFORMAT format); +D3DMULTISAMPLE_TYPE vboxDDI2D3DMultiSampleType(D3DDDIMULTISAMPLE_TYPE enmType); +D3DPOOL vboxDDI2D3DPool(D3DDDI_POOL enmPool); +D3DRENDERSTATETYPE vboxDDI2D3DRenderStateType(D3DDDIRENDERSTATETYPE enmType); +VBOXWDDMDISP_TSS_LOOKUP vboxDDI2D3DTestureStageStateType(D3DDDITEXTURESTAGESTATETYPE enmType); +DWORD vboxDDI2D3DUsage(D3DDDI_RESOURCEFLAGS fFlags); +DWORD vboxDDI2D3DLockFlags(D3DDDI_LOCKFLAGS fLockFlags); +D3DTEXTUREFILTERTYPE vboxDDI2D3DBltFlags(D3DDDI_BLTFLAGS fFlags); +D3DQUERYTYPE vboxDDI2D3DQueryType(D3DDDIQUERYTYPE enmType); +DWORD vboxDDI2D3DIssueQueryFlags(D3DDDI_ISSUEQUERYFLAGS Flags); + +HRESULT VBoxD3DIfCreateForRc(struct VBOXWDDMDISP_RESOURCE *pRc); +HRESULT VBoxD3DIfLockRect(struct VBOXWDDMDISP_RESOURCE *pRc, UINT iAlloc, + D3DLOCKED_RECT * pLockedRect, + CONST RECT *pRect, + DWORD fLockFlags); +HRESULT VBoxD3DIfUnlockRect(struct VBOXWDDMDISP_RESOURCE *pRc, UINT iAlloc); +void VBoxD3DIfLockUnlockMemSynch(struct VBOXWDDMDISP_ALLOCATION *pAlloc, D3DLOCKED_RECT *pLockInfo, RECT *pRect, bool bToLockInfo); + +/* NOTE: does NOT increment a ref counter! NO Release needed!! */ +DECLINLINE(IUnknown*) VBoxD3DIfGet(PVBOXWDDMDISP_ALLOCATION pAlloc) +{ + if (pAlloc->pD3DIf) + return pAlloc->pD3DIf; + + if (pAlloc->enmType != VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE) + { + WARN(("dynamic creation is supported for VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE only!, current type is %d", pAlloc->enmType)); + return NULL; + } + + HRESULT hr = VBoxD3DIfCreateForRc(pAlloc->pRc); + if (!SUCCEEDED(hr)) + { + WARN(("VBoxD3DIfCreateForRc failed, hr 0x%x", hr)); + return NULL; + } + + Assert(pAlloc->pD3DIf); + Assert(pAlloc->enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE); + + return pAlloc->pD3DIf; +} + +/* on success increments the surface ref counter, + * i.e. one must call pSurf->Release() once the surface is not needed*/ +DECLINLINE(HRESULT) VBoxD3DIfSurfGet(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc, IDirect3DSurface9 **ppSurf) +{ + HRESULT hr = S_OK; + Assert(pRc->cAllocations > iAlloc); + *ppSurf = NULL; + IUnknown* pD3DIf = VBoxD3DIfGet(&pRc->aAllocations[iAlloc]); + + switch (pRc->aAllocations[0].enmD3DIfType) + { + case VBOXDISP_D3DIFTYPE_SURFACE: + { + IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pD3DIf; + Assert(pD3DIfSurf); + pD3DIfSurf->AddRef(); + *ppSurf = pD3DIfSurf; + break; + } + case VBOXDISP_D3DIFTYPE_TEXTURE: + { + Assert(pRc->cAllocations == 1); /* <- VBoxD3DIfSurfGet is typically used in Blt & ColorFill functions + * in this case, if texture is used as a destination, + * we should update sub-layers as well which is not done currently + * so for now check VBoxD3DIfSurfGet is used for one-level textures */ + IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pD3DIf; + IDirect3DSurface9 *pSurfaceLevel; + Assert(pD3DIfTex); + hr = pD3DIfTex->GetSurfaceLevel(iAlloc, &pSurfaceLevel); + Assert(hr == S_OK); + if (hr == S_OK) + { + *ppSurf = pSurfaceLevel; + } + break; + } + case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE: + { + Assert(0); + IDirect3DCubeTexture9 *pD3DIfCubeTex = (IDirect3DCubeTexture9*)pD3DIf; + IDirect3DSurface9 *pSurfaceLevel; + Assert(pD3DIfCubeTex); + hr = pD3DIfCubeTex->GetCubeMapSurface(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, iAlloc), + VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, iAlloc), &pSurfaceLevel); + Assert(hr == S_OK); + if (hr == S_OK) + { + *ppSurf = pSurfaceLevel; + } + break; + } + default: + { + WARN(("unexpected enmD3DIfType %d", pRc->aAllocations[0].enmD3DIfType)); + hr = E_FAIL; + break; + } + } + return hr; +} + +VOID VBoxD3DIfFillPresentParams(D3DPRESENT_PARAMETERS *pParams, PVBOXWDDMDISP_RESOURCE pRc, UINT cRTs); +HRESULT VBoxD3DIfDeviceCreateDummy(PVBOXWDDMDISP_DEVICE pDevice); + +DECLINLINE(IDirect3DDevice9*) VBoxD3DIfDeviceGet(PVBOXWDDMDISP_DEVICE pDevice) +{ + if (pDevice->pDevice9If) + return pDevice->pDevice9If; + +#ifdef VBOXWDDMDISP_DEBUG + g_VBoxVDbgInternalDevice = pDevice; +#endif + + HRESULT hr = VBoxD3DIfDeviceCreateDummy(pDevice); + Assert(hr == S_OK); + Assert(pDevice->pDevice9If); + return pDevice->pDevice9If; +} + +#define VBOXDISPMODE_IS_3D(_p) (!!((_p)->D3D.pD3D9If)) +#ifdef VBOXDISP_EARLYCREATEDEVICE +#define VBOXDISP_D3DEV(_p) (_p)->pDevice9If +#else +#define VBOXDISP_D3DEV(_p) VBoxD3DIfDeviceGet(_p) +#endif + +#endif /* ___VBoxDispD3DRcIf_h__ */ Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.cpp (revision 43235) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.cpp (revision 43236) @@ -449,5 +449,5 @@ } -static void vboxResourceInit(PVBOXWDDMDISP_RESOURCE pRc, UINT cAllocs) +void vboxWddmResourceInit(PVBOXWDDMDISP_RESOURCE pRc, UINT cAllocs) { memset(pRc, 0, RT_OFFSETOF(VBOXWDDMDISP_RESOURCE, aAllocations[cAllocs])); @@ -466,244 +466,8 @@ if (pRc) { - vboxResourceInit(pRc, cAllocs); + vboxWddmResourceInit(pRc, cAllocs); return pRc; } return NULL; -} - -static void vboxWddmLockUnlockMemSynch(PVBOXWDDMDISP_ALLOCATION pAlloc, D3DLOCKED_RECT *pLockInfo, RECT *pRect, bool bToLockInfo) -{ - Assert(pAlloc->SurfDesc.pitch); - Assert(pAlloc->pvMem); - - if (!pRect) - { - if (pAlloc->SurfDesc.pitch == pLockInfo->Pitch) - { - Assert(pAlloc->SurfDesc.cbSize); - if (bToLockInfo) - memcpy(pLockInfo->pBits, pAlloc->pvMem, pAlloc->SurfDesc.cbSize); - else - memcpy(pAlloc->pvMem, pLockInfo->pBits, pAlloc->SurfDesc.cbSize); - } - else - { - uint8_t *pvSrc, *pvDst; - uint32_t srcPitch, dstPitch; - if (bToLockInfo) - { - pvSrc = (uint8_t *)pAlloc->pvMem; - pvDst = (uint8_t *)pLockInfo->pBits; - srcPitch = pAlloc->SurfDesc.pitch; - dstPitch = pLockInfo->Pitch; - } - else - { - pvDst = (uint8_t *)pAlloc->pvMem; - pvSrc = (uint8_t *)pLockInfo->pBits; - dstPitch = pAlloc->SurfDesc.pitch; - srcPitch = (uint32_t)pLockInfo->Pitch; - } - - uint32_t cRows = vboxWddmCalcNumRows(0, pAlloc->SurfDesc.height, pAlloc->SurfDesc.format); - uint32_t pitch = RT_MIN(srcPitch, dstPitch); - Assert(pitch); - for (UINT j = 0; j < cRows; ++j) - { - memcpy(pvDst, pvSrc, pitch); - pvSrc += srcPitch; - pvDst += dstPitch; - } - } - } - else - { - uint8_t *pvSrc, *pvDst; - uint32_t srcPitch, dstPitch; - uint8_t * pvAllocMemStart = (uint8_t *)pAlloc->pvMem; - uint32_t offAllocMemStart = vboxWddmCalcOffXYrd(pRect->left, pRect->top, pAlloc->SurfDesc.pitch, pAlloc->SurfDesc.format); - pvAllocMemStart += offAllocMemStart; - - if (bToLockInfo) - { - pvSrc = (uint8_t *)pvAllocMemStart; - pvDst = (uint8_t *)pLockInfo->pBits; - srcPitch = pAlloc->SurfDesc.pitch; - dstPitch = pLockInfo->Pitch; - } - else - { - pvDst = (uint8_t *)pvAllocMemStart; - pvSrc = (uint8_t *)pLockInfo->pBits; - dstPitch = pAlloc->SurfDesc.pitch; - srcPitch = (uint32_t)pLockInfo->Pitch; - } - - if (pRect->right - pRect->left == pAlloc->SurfDesc.width && srcPitch == dstPitch) - { - uint32_t cbSize = vboxWddmCalcSize(pAlloc->SurfDesc.pitch, pRect->bottom - pRect->top, pAlloc->SurfDesc.format); - memcpy(pvDst, pvSrc, cbSize); - } - else - { - uint32_t pitch = RT_MIN(srcPitch, dstPitch); - uint32_t cbCopyLine = vboxWddmCalcRowSize(pRect->left, pRect->right, pAlloc->SurfDesc.format); - Assert(pitch); - uint32_t cRows = vboxWddmCalcNumRows(pRect->top, pRect->bottom, pAlloc->SurfDesc.format); - for (UINT j = 0; j < cRows; ++j) - { - memcpy(pvDst, pvSrc, cbCopyLine); - pvSrc += srcPitch; - pvDst += dstPitch; - } - } - } -} - -HRESULT vboxWddmLockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc, - D3DLOCKED_RECT * pLockedRect, - CONST RECT *pRect, - DWORD fLockFlags) -{ - HRESULT hr = E_FAIL; - Assert(!pRc->aAllocations[iAlloc].LockInfo.cLocks); - Assert(pRc->cAllocations > iAlloc); - switch (pRc->aAllocations[0].enmD3DIfType) - { - case VBOXDISP_D3DIFTYPE_SURFACE: - { - IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pRc->aAllocations[iAlloc].pD3DIf; - Assert(pD3DIfSurf); - hr = pD3DIfSurf->LockRect(pLockedRect, pRect, fLockFlags); - Assert(hr == S_OK); - break; - } - case VBOXDISP_D3DIFTYPE_TEXTURE: - { - IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf; - Assert(pD3DIfTex); - hr = pD3DIfTex->LockRect(iAlloc, pLockedRect, pRect, fLockFlags); - Assert(hr == S_OK); - break; - } - case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE: - { - IDirect3DCubeTexture9 *pD3DIfCubeTex = (IDirect3DCubeTexture9*)pRc->aAllocations[0].pD3DIf; - Assert(pD3DIfCubeTex); - hr = pD3DIfCubeTex->LockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, iAlloc), - VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, iAlloc), pLockedRect, pRect, fLockFlags); - Assert(hr == S_OK); - break; - } - case VBOXDISP_D3DIFTYPE_VERTEXBUFFER: - { - IDirect3DVertexBuffer9 *pD3D9VBuf = (IDirect3DVertexBuffer9*)pRc->aAllocations[iAlloc].pD3DIf; - Assert(pD3D9VBuf); - hr = pD3D9VBuf->Lock(pRect ? pRect->left : 0/* offset */, - pRect ? pRect->right : 0 /* size 2 lock - 0 means all */, - &pLockedRect->pBits, fLockFlags); - Assert(hr == S_OK); - pLockedRect->Pitch = pRc->aAllocations[iAlloc].SurfDesc.pitch; - break; - } - case VBOXDISP_D3DIFTYPE_INDEXBUFFER: - { - IDirect3DIndexBuffer9 *pD3D9IBuf = (IDirect3DIndexBuffer9*)pRc->aAllocations[iAlloc].pD3DIf; - Assert(pD3D9IBuf); - hr = pD3D9IBuf->Lock(pRect ? pRect->left : 0/* offset */, - pRect ? pRect->right : 0 /* size 2 lock - 0 means all */, - &pLockedRect->pBits, fLockFlags); - Assert(hr == S_OK); - pLockedRect->Pitch = pRc->aAllocations[iAlloc].SurfDesc.pitch; - break; - } - default: - Assert(0); - break; - } - return hr; -} - -HRESULT vboxWddmUnlockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc) -{ - HRESULT hr = S_OK; - Assert(pRc->cAllocations > iAlloc); - switch (pRc->aAllocations[0].enmD3DIfType) - { - case VBOXDISP_D3DIFTYPE_SURFACE: - { - IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pRc->aAllocations[iAlloc].pD3DIf; - Assert(pD3DIfSurf); - hr = pD3DIfSurf->UnlockRect(); - Assert(hr == S_OK); - break; - } - case VBOXDISP_D3DIFTYPE_TEXTURE: - { - IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf; - Assert(pD3DIfTex); - hr = pD3DIfTex->UnlockRect(iAlloc); - Assert(hr == S_OK); - break; - } - case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE: - { - IDirect3DCubeTexture9 *pD3DIfCubeTex = (IDirect3DCubeTexture9*)pRc->aAllocations[0].pD3DIf; - Assert(pD3DIfCubeTex); - hr = pD3DIfCubeTex->UnlockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, iAlloc), - VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, iAlloc)); - Assert(hr == S_OK); - break; - } - case VBOXDISP_D3DIFTYPE_VERTEXBUFFER: - { - IDirect3DVertexBuffer9 *pD3D9VBuf = (IDirect3DVertexBuffer9*)pRc->aAllocations[iAlloc].pD3DIf; - Assert(pD3D9VBuf); - hr = pD3D9VBuf->Unlock(); - Assert(hr == S_OK); - break; - } - case VBOXDISP_D3DIFTYPE_INDEXBUFFER: - { - IDirect3DIndexBuffer9 *pD3D9IBuf = (IDirect3DIndexBuffer9*)pRc->aAllocations[iAlloc].pD3DIf; - Assert(pD3D9IBuf); - hr = pD3D9IBuf->Unlock(); - Assert(hr == S_OK); - break; - } - default: - Assert(0); - hr = E_FAIL; - break; - } - return hr; -} - -static HRESULT vboxWddmSurfSynchMem(PVBOXWDDMDISP_RESOURCE pRc) -{ - if (pRc->RcDesc.enmPool != D3DDDIPOOL_SYSTEMMEM) - { - return S_OK; - } - - for (UINT i = 0; i < pRc->cAllocations; ++i) - { - D3DLOCKED_RECT Rect; - HRESULT hr = vboxWddmLockRect(pRc, i, &Rect, NULL, D3DLOCK_DISCARD); - if (FAILED(hr)) - { - WARN(("vboxWddmLockRect failed, hr(0x%x)", hr)); - return hr; - } - - PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i]; - Assert(pAlloc->pvMem); - - vboxWddmLockUnlockMemSynch(pAlloc, &Rect, NULL, true /*bool bToLockInfo*/); - - hr = vboxWddmUnlockRect(pRc, i); - Assert(SUCCEEDED(hr)); - } - return S_OK; } @@ -764,8 +528,8 @@ { D3DLOCKED_RECT Rect; - HRESULT hr = vboxWddmLockRect(pRc, i, &Rect, NULL, D3DLOCK_READONLY); + HRESULT hr = VBoxD3DIfLockRect(pRc, i, &Rect, NULL, D3DLOCK_READONLY); if (FAILED(hr)) { - WARN(("vboxWddmLockRect failed, hr(0x%x)", hr)); + WARN(("VBoxD3DIfLockRect failed, hr(0x%x)", hr)); return; } @@ -776,5 +540,5 @@ vboxWddmDbgSynchMemCheck(pAlloc, &Rect); - hr = vboxWddmUnlockRect(pRc, i); + hr = VBoxD3DIfUnlockRect(pRc, i); Assert(SUCCEEDED(hr)); } @@ -782,167 +546,4 @@ #endif - -static D3DFORMAT vboxDDI2D3DFormat(D3DDDIFORMAT format) -{ - /* @todo: check they are all equal */ - return (D3DFORMAT)format; -} - -D3DMULTISAMPLE_TYPE vboxDDI2D3DMultiSampleType(D3DDDIMULTISAMPLE_TYPE enmType) -{ - /* @todo: check they are all equal */ - return (D3DMULTISAMPLE_TYPE)enmType; -} - -D3DPOOL vboxDDI2D3DPool(D3DDDI_POOL enmPool) -{ - /* @todo: check they are all equal */ - switch (enmPool) - { - case D3DDDIPOOL_SYSTEMMEM: - return D3DPOOL_SYSTEMMEM; - case D3DDDIPOOL_VIDEOMEMORY: - case D3DDDIPOOL_LOCALVIDMEM: - case D3DDDIPOOL_NONLOCALVIDMEM: - /* @todo: what would be proper here? */ - return D3DPOOL_DEFAULT; - default: - Assert(0); - } - return D3DPOOL_DEFAULT; -} - -D3DRENDERSTATETYPE vboxDDI2D3DRenderStateType(D3DDDIRENDERSTATETYPE enmType) -{ - /* @todo: @fixme: not entirely correct, need to check */ - return (D3DRENDERSTATETYPE)enmType; -} - -VBOXWDDMDISP_TSS_LOOKUP vboxDDI2D3DTestureStageStateType(D3DDDITEXTURESTAGESTATETYPE enmType) -{ - static const VBOXWDDMDISP_TSS_LOOKUP lookup[] = - { - {FALSE, D3DTSS_FORCE_DWORD}, /* 0, D3DDDITSS_TEXTUREMAP */ - {FALSE, D3DTSS_COLOROP}, /* 1, D3DDDITSS_COLOROP */ - {FALSE, D3DTSS_COLORARG1}, /* 2, D3DDDITSS_COLORARG1 */ - {FALSE, D3DTSS_COLORARG2}, /* 3, D3DDDITSS_COLORARG2 */ - {FALSE, D3DTSS_ALPHAOP}, /* 4, D3DDDITSS_ALPHAOP */ - {FALSE, D3DTSS_ALPHAARG1}, /* 5, D3DDDITSS_ALPHAARG1 */ - {FALSE, D3DTSS_ALPHAARG2}, /* 6, D3DDDITSS_ALPHAARG2 */ - {FALSE, D3DTSS_BUMPENVMAT00}, /* 7, D3DDDITSS_BUMPENVMAT00 */ - {FALSE, D3DTSS_BUMPENVMAT01}, /* 8, D3DDDITSS_BUMPENVMAT01 */ - {FALSE, D3DTSS_BUMPENVMAT10}, /* 9, D3DDDITSS_BUMPENVMAT10 */ - {FALSE, D3DTSS_BUMPENVMAT11}, /* 10, D3DDDITSS_BUMPENVMAT11 */ - {FALSE, D3DTSS_TEXCOORDINDEX}, /* 11, D3DDDITSS_TEXCOORDINDEX */ - {FALSE, D3DTSS_FORCE_DWORD}, /* 12, unused */ - {TRUE, D3DSAMP_ADDRESSU}, /* 13, D3DDDITSS_ADDRESSU */ - {TRUE, D3DSAMP_ADDRESSV}, /* 14, D3DDDITSS_ADDRESSV */ - {TRUE, D3DSAMP_BORDERCOLOR}, /* 15, D3DDDITSS_BORDERCOLOR */ - {TRUE, D3DSAMP_MAGFILTER}, /* 16, D3DDDITSS_MAGFILTER */ - {TRUE, D3DSAMP_MINFILTER}, /* 17, D3DDDITSS_MINFILTER */ - {TRUE, D3DSAMP_MIPFILTER}, /* 18, D3DDDITSS_MIPFILTER */ - {TRUE, D3DSAMP_MIPMAPLODBIAS}, /* 19, D3DDDITSS_MIPMAPLODBIAS */ - {TRUE, D3DSAMP_MAXMIPLEVEL}, /* 20, D3DDDITSS_MAXMIPLEVEL */ - {TRUE, D3DSAMP_MAXANISOTROPY}, /* 21, D3DDDITSS_MAXANISOTROPY */ - {FALSE, D3DTSS_BUMPENVLSCALE}, /* 22, D3DDDITSS_BUMPENVLSCALE */ - {FALSE, D3DTSS_BUMPENVLOFFSET}, /* 23, D3DDDITSS_BUMPENVLOFFSET */ - {FALSE, D3DTSS_TEXTURETRANSFORMFLAGS}, /* 24, D3DDDITSS_TEXTURETRANSFORMFLAGS */ - {TRUE, D3DSAMP_ADDRESSW}, /* 25, D3DDDITSS_ADDRESSW */ - {FALSE, D3DTSS_COLORARG0}, /* 26, D3DDDITSS_COLORARG0 */ - {FALSE, D3DTSS_ALPHAARG0}, /* 27, D3DDDITSS_ALPHAARG0 */ - {FALSE, D3DTSS_RESULTARG}, /* 28, D3DDDITSS_RESULTARG */ - {TRUE, D3DSAMP_SRGBTEXTURE}, /* 29, D3DDDITSS_SRGBTEXTURE */ - {TRUE, D3DSAMP_ELEMENTINDEX}, /* 30, D3DDDITSS_ELEMENTINDEX */ - {TRUE, D3DSAMP_DMAPOFFSET}, /* 31, D3DDDITSS_DMAPOFFSET */ - {FALSE, D3DTSS_CONSTANT}, /* 32, D3DDDITSS_CONSTANT */ - {FALSE, D3DTSS_FORCE_DWORD}, /* 33, D3DDDITSS_DISABLETEXTURECOLORKEY */ - {FALSE, D3DTSS_FORCE_DWORD}, /* 34, D3DDDITSS_TEXTURECOLORKEYVAL */ - }; - - Assert(enmType > 0); - Assert(enmType < RT_ELEMENTS(lookup)); - Assert(lookup[enmType].dType != D3DTSS_FORCE_DWORD); - - return lookup[enmType]; -} - -DWORD vboxDDI2D3DUsage(D3DDDI_RESOURCEFLAGS fFlags) -{ - DWORD fUsage = 0; - if (fFlags.Dynamic) - fUsage |= D3DUSAGE_DYNAMIC; - if (fFlags.AutogenMipmap) - fUsage |= D3DUSAGE_AUTOGENMIPMAP; - if (fFlags.DMap) - fUsage |= D3DUSAGE_DMAP; - if (fFlags.WriteOnly) - fUsage |= D3DUSAGE_WRITEONLY; - if (fFlags.NPatches) - fUsage |= D3DUSAGE_NPATCHES; - if (fFlags.Points) - fUsage |= D3DUSAGE_POINTS; - if (fFlags.RenderTarget) - fUsage |= D3DUSAGE_RENDERTARGET; - if (fFlags.RtPatches) - fUsage |= D3DUSAGE_RTPATCHES; - if (fFlags.TextApi) - fUsage |= D3DUSAGE_TEXTAPI; - if (fFlags.WriteOnly) - fUsage |= D3DUSAGE_WRITEONLY; - //below are wddm 1.1-specific -// if (fFlags.RestrictedContent) -// fUsage |= D3DUSAGE_RESTRICTED_CONTENT; -// if (fFlags.RestrictSharedAccess) -// fUsage |= D3DUSAGE_RESTRICT_SHARED_RESOURCE; - return fUsage; -} - -DWORD vboxDDI2D3DLockFlags(D3DDDI_LOCKFLAGS fLockFlags) -{ - DWORD fFlags = 0; - if (fLockFlags.Discard) - fFlags |= D3DLOCK_DISCARD; - if (fLockFlags.NoOverwrite) - fFlags |= D3DLOCK_NOOVERWRITE; - if (fLockFlags.ReadOnly) - fFlags |= D3DLOCK_READONLY; - if (fLockFlags.DoNotWait) - fFlags |= D3DLOCK_DONOTWAIT; - return fFlags; -} - -D3DTEXTUREFILTERTYPE vboxDDI2D3DBltFlags(D3DDDI_BLTFLAGS fFlags) -{ - if (fFlags.Point) - { - /* no flags other than [Begin|Continue|End]PresentToDwm are set */ - Assert((fFlags.Value & (~(0x00000100 | 0x00000200 | 0x00000400))) == 1); - return D3DTEXF_POINT; - } - if (fFlags.Linear) - { - /* no flags other than [Begin|Continue|End]PresentToDwm are set */ - Assert((fFlags.Value & (~(0x00000100 | 0x00000200 | 0x00000400))) == 2); - return D3DTEXF_LINEAR; - } - /* no flags other than [Begin|Continue|End]PresentToDwm are set */ - Assert((fFlags.Value & (~(0x00000100 | 0x00000200 | 0x00000400))) == 0); - return D3DTEXF_NONE; -} - -static D3DQUERYTYPE vboxDDI2D3DQueryType(D3DDDIQUERYTYPE enmType) -{ - return (D3DQUERYTYPE)enmType; -} - -static DWORD vboxDDI2D3DIssueQueryFlags(D3DDDI_ISSUEQUERYFLAGS Flags) -{ - DWORD fFlags = 0; - if (Flags.Begin) - fFlags |= D3DISSUE_BEGIN; - if (Flags.End) - fFlags |= D3DISSUE_END; - return fFlags; -} /******/ @@ -1056,5 +657,5 @@ } -static VOID vboxWddmSwapchainDestroy(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain) +VOID vboxWddmSwapchainDestroy(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain) { vboxWddmSwapchainClear(pDevice, pSwapchain); @@ -1202,5 +803,5 @@ } -static PVBOXWDDMDISP_SWAPCHAIN vboxWddmSwapchainFindCreate(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pBbAlloc, BOOL *pbNeedPresent) +PVBOXWDDMDISP_SWAPCHAIN vboxWddmSwapchainFindCreate(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pBbAlloc, BOOL *pbNeedPresent) { PVBOXWDDMDISP_SWAPCHAIN pSwapchain = pBbAlloc->pSwapchain; @@ -1243,9 +844,7 @@ * thus the aRTs[0] is a backbuffer */ { - PVBOXWDDMDISP_RESOURCE pBbRc = pBbAlloc->pRc; - PVBOXWDDMDISP_RESOURCE pRtRc = pRt->pAlloc->pRc; if (pBbAlloc->SurfDesc.width == pRt->pAlloc->SurfDesc.width && pBbAlloc->SurfDesc.height == pRt->pAlloc->SurfDesc.height - && pBbAlloc->SurfDesc.format == pRt->pAlloc->SurfDesc.format + && vboxWddmFmtNoAlphaFormat(pBbAlloc->SurfDesc.format) == vboxWddmFmtNoAlphaFormat(pRt->pAlloc->SurfDesc.format) && pBbAlloc->SurfDesc.VidPnSourceId == pRt->pAlloc->SurfDesc.VidPnSourceId ) @@ -1329,9 +928,9 @@ if (pAlloc->pD3DIf) { - /* since this can be texture, need to do the vboxWddmSurfGet magic */ - hr = vboxWddmSurfGet(pAlloc->pRc, pAlloc->iAlloc, &pD3D9OldSurf); + /* since this can be texture, need to do the VBoxD3DIfSurfGet magic */ + hr = VBoxD3DIfSurfGet(pAlloc->pRc, pAlloc->iAlloc, &pD3D9OldSurf); if (FAILED(hr)) { - WARN(("vboxWddmSurfGet failed, hr (0x%x)",hr)); + WARN(("VBoxD3DIfSurfGet failed, hr (0x%x)",hr)); pD3D9Surf->Release(); return hr; @@ -1457,24 +1056,4 @@ } -static VOID vboxWddmFillPresentParams(D3DPRESENT_PARAMETERS *pParams, PVBOXWDDMDISP_RESOURCE pRc, UINT cRTs) -{ - Assert(cRTs); - memset(pParams, 0, sizeof (D3DPRESENT_PARAMETERS)); - pParams->BackBufferWidth = pRc->aAllocations[0].SurfDesc.width; - pParams->BackBufferHeight = pRc->aAllocations[0].SurfDesc.height; - pParams->BackBufferFormat = vboxDDI2D3DFormat(pRc->aAllocations[0].SurfDesc.format); - pParams->BackBufferCount = cRTs - 1; - pParams->MultiSampleType = vboxDDI2D3DMultiSampleType(pRc->RcDesc.enmMultisampleType); - pParams->MultiSampleQuality = pRc->RcDesc.MultisampleQuality; -#if 0 //def VBOXDISP_WITH_WINE_BB_WORKAROUND /* this does not work so far any way :( */ - if (cRTs == 1) - pParams->SwapEffect = D3DSWAPEFFECT_COPY; - else -#endif - if (pRc->RcDesc.fFlags.DiscardRenderTarget) - pParams->SwapEffect = D3DSWAPEFFECT_DISCARD; - pParams->Windowed = TRUE; -} - static VOID vboxWddmSwapchainFillPresentParams(PVBOXWDDMDISP_SWAPCHAIN pSwapchain, D3DPRESENT_PARAMETERS *pParams) { @@ -1486,5 +1065,5 @@ PVBOXWDDMDISP_RENDERTGT pRt = vboxWddmSwapchainGetBb(pSwapchain); PVBOXWDDMDISP_RESOURCE pRc = pRt->pAlloc->pRc; - vboxWddmFillPresentParams(pParams, pRc, pSwapchain->cRTs); + VBoxD3DIfFillPresentParams(pParams, pRc, pSwapchain->cRTs); } @@ -1525,6 +1104,6 @@ { VOID *pvSwapchain = NULL; - /* since this can be texture, need to do the vboxWddmSurfGet magic */ - hr = vboxWddmSurfGet(pRT->pAlloc->pRc, pRT->pAlloc->iAlloc, &pD3D9OldSurf); + /* since this can be texture, need to do the VBoxD3DIfSurfGet magic */ + hr = VBoxD3DIfSurfGet(pRT->pAlloc->pRc, pRT->pAlloc->iAlloc, &pD3D9OldSurf); Assert(hr == S_OK); hr = pD3D9OldSurf->GetContainer(IID_IDirect3DSwapChain9, &pvSwapchain); @@ -1643,5 +1222,5 @@ } -static HRESULT vboxWddmSwapchainChkCreateIf(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain) +HRESULT vboxWddmSwapchainChkCreateIf(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain) { if (!pSwapchain->fFlags.bChanged && pSwapchain->pSwapChainIf) @@ -1664,5 +1243,8 @@ for (UINT i = 0; i < pSwapchain->cRTs; ++i) { - if (pSwapchain->aRTs[i].pAlloc->enmD3DIfType != VBOXDISP_D3DIFTYPE_SURFACE) + if (pSwapchain->aRTs[i].pAlloc->enmD3DIfType != VBOXDISP_D3DIFTYPE_SURFACE + && (pSwapchain->aRTs[i].pAlloc->enmD3DIfType != VBOXDISP_D3DIFTYPE_UNDEFINED + || pSwapchain->aRTs[i].pAlloc->enmType != VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE + )) { fNeedRtPresentSwitch = TRUE; @@ -1945,5 +1527,5 @@ /* if this is not a front-buffer - just return the surface associated with the allocation */ - return vboxWddmSurfGet(pAlloc->pRc, pAlloc->iAlloc, ppSurf); + return VBoxD3DIfSurfGet(pAlloc->pRc, pAlloc->iAlloc, ppSurf); } @@ -2132,52 +1714,4 @@ #endif -static HRESULT vboxWddmD3DDeviceCreateDummy(PVBOXWDDMDISP_DEVICE pDevice) -{ - VBOXWDDMDISP_RESOURCE Rc; - vboxResourceInit(&Rc, 1); - - Rc.RcDesc.enmFormat = D3DDDIFMT_A8R8G8B8; - Rc.RcDesc.enmPool = D3DDDIPOOL_LOCALVIDMEM; - Rc.RcDesc.enmMultisampleType = D3DDDIMULTISAMPLE_NONE; - Rc.RcDesc.MultisampleQuality = 0; - PVBOXWDDMDISP_ALLOCATION pAlloc = &Rc.aAllocations[0]; - pAlloc->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE; - pAlloc->SurfDesc.width = 0x4; - pAlloc->SurfDesc.height = 0x4; - pAlloc->SurfDesc.format = D3DDDIFMT_A8R8G8B8; - Assert(!pDevice->pDevice9If); - VBOXWINEEX_D3DPRESENT_PARAMETERS Params; - vboxWddmFillPresentParams(&Params.Base, &Rc, 2); - Params.pHgsmi = &pDevice->Uhgsmi.BasePrivate.Base; - DWORD fFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING; - PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter; - IDirect3DDevice9 * pDevice9If = NULL; - - HRESULT hr = pAdapter->D3D.pD3D9If->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, NULL, fFlags, &Params.Base, &pDevice9If); - if (!SUCCEEDED(hr)) - { - WARN(("CreateDevice failed hr 0x%x", hr)); - return hr; - } - - pDevice->pDevice9If = pDevice9If; - return S_OK; -} - -DECLINLINE(IDirect3DDevice9*) vboxWddmD3DDeviceGet(PVBOXWDDMDISP_DEVICE pDevice) -{ - if (pDevice->pDevice9If) - return pDevice->pDevice9If; - -#ifdef VBOXWDDMDISP_DEBUG - g_VBoxVDbgInternalDevice = pDevice; -#endif - - HRESULT hr = vboxWddmD3DDeviceCreateDummy(pDevice); - Assert(hr == S_OK); - Assert(pDevice->pDevice9If); - return pDevice->pDevice9If; -} - /******/ @@ -2199,8 +1733,8 @@ else { - hr = vboxWddmSurfGet(pAlloc->pRc, pAlloc->iAlloc, &pD3D9Surf); + hr = VBoxD3DIfSurfGet(pAlloc->pRc, pAlloc->iAlloc, &pD3D9Surf); if (FAILED(hr)) { - WARN(("vboxWddmSurfGet failed, hr(0x%x)",hr)); + WARN(("VBoxD3DIfSurfGet failed, hr(0x%x)",hr)); return hr; } @@ -3021,5 +2555,5 @@ r.right = pLock->Range.Offset + pLock->Range.Size; - vboxWddmLockUnlockMemSynch(pDevice->aStreamSource[stream], &pLock->LockedRect, &r, true /*bool bToLockInfo*/); + VBoxD3DIfLockUnlockMemSynch(pDevice->aStreamSource[stream], &pLock->LockedRect, &r, true /*bool bToLockInfo*/); pD3D9VBuf->Unlock(); @@ -3172,9 +2706,9 @@ IDirect3DSurface9 *pSrcSurfIf = NULL; IDirect3DSurface9 *pDstSurfIf = NULL; - hr = vboxWddmSurfGet(pDstRc, 0, &pDstSurfIf); + hr = VBoxD3DIfSurfGet(pDstRc, 0, &pDstSurfIf); Assert(hr == S_OK); if (hr == S_OK) { - hr = vboxWddmSurfGet(pSrcRc, 0, &pSrcSurfIf); + hr = VBoxD3DIfSurfGet(pSrcRc, 0, &pSrcSurfIf); Assert(hr == S_OK); if (hr == S_OK) @@ -3702,5 +3236,5 @@ else pr = NULL; - vboxWddmLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect, pr, false /*bool bToLockInfo*/); + VBoxD3DIfLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect, pr, false /*bool bToLockInfo*/); } } @@ -3796,5 +3330,5 @@ else pr = NULL; - vboxWddmLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect, pr, false /*bool bToLockInfo*/); + VBoxD3DIfLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect, pr, false /*bool bToLockInfo*/); } } @@ -3983,5 +3517,5 @@ else pr = NULL; - vboxWddmLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect, + VBoxD3DIfLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect, pr, true /*bool bToLockInfo*/); @@ -4024,5 +3558,5 @@ else pr = NULL; - vboxWddmLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect, + VBoxD3DIfLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect, pr, true /*bool bToLockInfo*/); @@ -4077,5 +3611,5 @@ LRect.Pitch = ((pAlloc->SurfDesc.bpp * pAlloc->SurfDesc.width) + 7) >> 3; Assert(pAlloc->DirtyRegion.fFlags & VBOXWDDM_DIRTYREGION_F_VALID); - vboxWddmLockUnlockMemSynch(pAlloc, &LRect, &pAlloc->DirtyRegion.Rect, TRUE /* bool bToLockInfo*/); + VBoxD3DIfLockUnlockMemSynch(pAlloc, &LRect, &pAlloc->DirtyRegion.Rect, TRUE /* bool bToLockInfo*/); vboxWddmDirtyRegionClear(&pAlloc->DirtyRegion); fDoUnlock = TRUE; @@ -4213,5 +3747,4 @@ } bool bIssueCreateResource = false; - bool bCreateSwapchain = false; bool bCreateKMResource = false; @@ -4264,5 +3797,5 @@ if (VBOXDISPMODE_IS_3D(pAdapter)) { - if (pResource->Flags.SharedResource) + if (pRc->RcDesc.fFlags.SharedResource) { bIssueCreateResource = true; @@ -4270,383 +3803,13 @@ } - if (pResource->Flags.ZBuffer) - { - IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice); - for (UINT i = 0; i < pResource->SurfCount; ++i) - { - PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i]; - IDirect3DSurface9 *pD3D9Surf; - hr = pDevice9If->CreateDepthStencilSurface(pAllocation->SurfDesc.width, - pAllocation->SurfDesc.height, - vboxDDI2D3DFormat(pResource->Format), - vboxDDI2D3DMultiSampleType(pResource->MultisampleType), - pResource->MultisampleQuality, - TRUE /* @todo: BOOL Discard */, - &pD3D9Surf, - NULL /*HANDLE* pSharedHandle*/); - Assert(hr == S_OK); - if (hr == S_OK) - { - Assert(pD3D9Surf); - pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE; - pAllocation->pD3DIf = pD3D9Surf; - } - else - { - for (UINT j = 0; j < i; ++j) - { - pRc->aAllocations[j].pD3DIf->Release(); - } - break; - } - } - - if (SUCCEEDED(hr)) - { - if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM) - { - vboxWddmSurfSynchMem(pRc); - } - } - } - else if (pResource->Flags.VertexBuffer) - { - IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice); - - for (UINT i = 0; i < pResource->SurfCount; ++i) - { - PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i]; - IDirect3DVertexBuffer9 *pD3D9VBuf; - hr = pDevice9If->CreateVertexBuffer(pAllocation->SurfDesc.width, - vboxDDI2D3DUsage(pResource->Flags), - pResource->Fvf, - vboxDDI2D3DPool(pResource->Pool), - &pD3D9VBuf, - NULL /*HANDLE* pSharedHandle*/); - Assert(hr == S_OK); - if (hr == S_OK) - { - Assert(pD3D9VBuf); - pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_VERTEXBUFFER; - pAllocation->pD3DIf = pD3D9VBuf; - } - else - { - for (UINT j = 0; j < i; ++j) - { - pRc->aAllocations[j].pD3DIf->Release(); - } - break; - } - } - - if (SUCCEEDED(hr)) - { - if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM) - { - vboxWddmSurfSynchMem(pRc); - } - } - } - else if (pResource->Flags.IndexBuffer) - { - IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice); - - for (UINT i = 0; i < pResource->SurfCount; ++i) - { - PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i]; - CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i]; - IDirect3DIndexBuffer9 *pD3D9IBuf; - hr = pDevice9If->CreateIndexBuffer(pSurf->Width, - vboxDDI2D3DUsage(pResource->Flags), - vboxDDI2D3DFormat(pResource->Format), - vboxDDI2D3DPool(pResource->Pool), - &pD3D9IBuf, - NULL /*HANDLE* pSharedHandle*/ - ); - Assert(hr == S_OK); - if (hr == S_OK) - { - Assert(pD3D9IBuf); - pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_INDEXBUFFER; - pAllocation->pD3DIf = pD3D9IBuf; - } - else - { - for (UINT j = 0; j < i; ++j) - { - pRc->aAllocations[j].pD3DIf->Release(); - } - break; - } - } - - if (SUCCEEDED(hr)) - { - if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM) - { - vboxWddmSurfSynchMem(pRc); - } - } - } - else if (VBOXWDDMDISP_IS_TEXTURE(pResource->Flags)) - { - IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice); - - if (pResource->Flags.RenderTarget && !pResource->Flags.Texture) - { - bIssueCreateResource = true; - } - - if (!pResource->Flags.CubeMap) - { -#ifdef DEBUG - { - uint32_t tstW = pResource->pSurfList[0].Width; - uint32_t tstH = pResource->pSurfList[0].Height; - for (UINT i = 1; i < pResource->SurfCount; ++i) - { - tstW /= 2; - tstH /= 2; - CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i]; - Assert((pSurf->Width == tstW) || (!tstW && (pSurf->Width==1))); - Assert((pSurf->Height == tstH) || (!tstH && (pSurf->Height==1))); - } - } -#endif - PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0]; - CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[0]; - IDirect3DTexture9 *pD3DIfTex; - HANDLE hSharedHandle = NULL; - void **pavClientMem = NULL; - if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM) - { - Assert(pSurf->pSysMem); - Assert(pSurf->SysMemPitch); - UINT minPitch = vboxWddmCalcPitch(pAllocation->SurfDesc.width, pAllocation->SurfDesc.format); - Assert(minPitch); - if (minPitch) - { - if (pSurf->SysMemPitch != minPitch) - pAllocation->D3DWidth = vboxWddmCalcWidthForPitch(pSurf->SysMemPitch, pAllocation->SurfDesc.format); - Assert(pAllocation->D3DWidth >= pSurf->Width); - } - else - { - Assert(pAllocation->D3DWidth == pSurf->Width); - } - } - if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM) - { - pavClientMem = (void**)RTMemAlloc(sizeof (pavClientMem[0]) * pResource->SurfCount); - Assert(pavClientMem); - if (pavClientMem) - { - for (UINT i = 0; i < pResource->SurfCount; ++i) - { - pavClientMem[i] = pRc->aAllocations[i].pvMem; - } - } - else - hr = E_FAIL; - } - if (hr == S_OK) - { - hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9CreateTexture((IDirect3DDevice9Ex *)pDevice9If, - pAllocation->D3DWidth, - pSurf->Height, - pResource->SurfCount, - vboxDDI2D3DUsage(pResource->Flags), - vboxDDI2D3DFormat(pResource->Format), - vboxDDI2D3DPool(pResource->Pool), - &pD3DIfTex, -#ifdef VBOXWDDMDISP_DEBUG_NOSHARED - NULL, -#else - pResource->Flags.SharedResource ? &hSharedHandle : NULL, -#endif - pavClientMem); - Assert(hr == S_OK); - if (hr == S_OK) - { - Assert(pD3DIfTex); - pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_TEXTURE; - pAllocation->pD3DIf = pD3DIfTex; -#ifndef VBOXWDDMDISP_DEBUG_NOSHARED - Assert(!!(pResource->Flags.SharedResource) == !!(hSharedHandle)); -#endif - pAllocation->hSharedHandle = hSharedHandle; - - if (!pavClientMem) - { - /* zero-init texture memory */ - - } - } - - if (pavClientMem) - RTMemFree(pavClientMem); - } - } - else /*pResource->Flags.CubeMap*/ - { - IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice); - PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0]; - CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[0]; - IDirect3DCubeTexture9 *pD3DIfCubeTex; - HANDLE hSharedHandle = NULL; - void **pavClientMem = NULL; - - if ( (pAllocation->SurfDesc.width!=pAllocation->SurfDesc.height) - || (pResource->SurfCount%6!=0)) - { - Assert(0); - hr = E_INVALIDARG; - } - else - { - if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM) - { - pavClientMem = (void**)RTMemAlloc(sizeof (pavClientMem[0]) * pResource->SurfCount); - Assert(pavClientMem); - if (pavClientMem) - { - for (UINT i = 0; i < pResource->SurfCount; ++i) - { - pavClientMem[i] = pRc->aAllocations[i].pvMem; - } - } - else - hr = E_FAIL; - } - - if (hr == S_OK) - { - hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9CreateCubeTexture((IDirect3DDevice9Ex *)pDevice9If, - pAllocation->SurfDesc.width, - VBOXDISP_CUBEMAP_LEVELS_COUNT(pRc), - vboxDDI2D3DUsage(pResource->Flags), - vboxDDI2D3DFormat(pResource->Format), - vboxDDI2D3DPool(pResource->Pool), - &pD3DIfCubeTex, -#ifdef VBOXWDDMDISP_DEBUG_NOSHARED - NULL, -#else - pResource->Flags.SharedResource ? &hSharedHandle : NULL, -#endif - pavClientMem); - Assert(hr == S_OK); - if (hr == S_OK) - { - Assert(pD3DIfCubeTex); - pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_CUBE_TEXTURE; - pAllocation->pD3DIf = pD3DIfCubeTex; -#ifndef VBOXWDDMDISP_DEBUG_NOSHARED - Assert(!!(pResource->Flags.SharedResource) == !!(hSharedHandle)); -#endif - pAllocation->hSharedHandle = hSharedHandle; - } - - if (pavClientMem) - RTMemFree(pavClientMem); - } - } - } - } - else if (pResource->Flags.RenderTarget) - { - HWND hWnd = NULL; + if (pRc->RcDesc.fFlags.RenderTarget) + { bIssueCreateResource = true; - Assert(pResource->SurfCount); - -#ifdef VBOXWDDMDISP_DEBUG - if (g_VBoxVDbgCfgForceDummyDevCreate) - { - VBOXDISP_D3DEV(pDevice); - Assert(!RTListIsEmpty(&pDevice->SwapchainList)); - g_VBoxVDbgInternalRc = pRc; - } -#endif - -#if 0 /* <- always create an offscreen render target here since wined3dwddm makes host - * to postpone any host window sizing until it becomes visible (which is done to prevent flikering on *nix hosts) - * and thus back/front-buffer data is invalid until then - * and in case the 3d app is running under Aero enabled, the window will never become visible and thus never resized - * to the requested values */ - if (!pResource->Flags.SharedResource /* <- the Shared must NOT be a swapchain (on-screen) render target - * since it will be non-upside-down, - * while the app opening the resource would use it as an off-screen, - * i.e. upside-down */ - && RTListIsEmpty(&pDevice->SwapchainList)) - { - bCreateSwapchain = true; - Assert(bIssueCreateResource); - for (UINT i = 0; i < pRc->cAllocations; ++i) - { - PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i]; - pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE; - } - } - else -#endif - { - /* make sure the device is created */ - IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice); - for (UINT i = 0; i < pResource->SurfCount; ++i) - { - PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i]; - HANDLE hSharedHandle = NULL; - - IDirect3DSurface9* pD3D9Surf; - hr = pDevice9If->CreateRenderTarget(pAllocation->SurfDesc.width, - pAllocation->SurfDesc.height, - vboxDDI2D3DFormat(pResource->Format), - vboxDDI2D3DMultiSampleType(pResource->MultisampleType), - pResource->MultisampleQuality, - !pResource->Flags.NotLockable /* BOOL Lockable */, - &pD3D9Surf, -#ifdef VBOXWDDMDISP_DEBUG_NOSHARED - NULL -#else - pResource->Flags.SharedResource ? &hSharedHandle : NULL -#endif - ); - Assert(hr == S_OK); - if (hr == S_OK) - { - Assert(pD3D9Surf); - pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE; - pAllocation->pD3DIf = pD3D9Surf; -#ifndef VBOXWDDMDISP_DEBUG_NOSHARED - Assert(!!(pResource->Flags.SharedResource) == !!(hSharedHandle)); -#endif - pAllocation->hSharedHandle = hSharedHandle; - continue; - - /* fail branch */ - pD3D9Surf->Release(); - } - - for (UINT j = 0; j < i; ++j) - { - pRc->aAllocations[j].pD3DIf->Release(); - } - break; - } - - if (SUCCEEDED(hr)) - { - if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM) - { - Assert(0); - vboxWddmSurfSynchMem(pRc); - } - } - } - } - else - { - hr = E_FAIL; - Assert(0); + } + + hr = VBoxD3DIfCreateForRc(pRc); + if (!SUCCEEDED(hr)) + { + WARN(("VBoxD3DIfCreateForRc failed, hr 0x%x", hr)); } } @@ -4657,6 +3820,5 @@ } - - if (hr == S_OK && bIssueCreateResource) + if (SUCCEEDED(hr) && bIssueCreateResource) { pRc->fFlags.KmResource = bCreateKMResource; @@ -4728,5 +3890,5 @@ Assert(hr == S_OK); Assert(!pDdiAllocate->hKMResource); - if (hr == S_OK) + if (SUCCEEDED(hr)) { Assert(pDdiAllocate->pAllocationInfo->hAllocation); @@ -4751,5 +3913,5 @@ } - if (hr == S_OK) + if (SUCCEEDED(hr)) { pRc->hKMResource = pDdiAllocate->hKMResource; @@ -4780,14 +3942,5 @@ } - if(bCreateSwapchain) - { - PVBOXWDDMDISP_SWAPCHAIN pSwapchain; - hr = vboxWddmSwapchainCreateIfForRc(pDevice, pRc, &pSwapchain); - Assert(hr == S_OK); - } - else - { - VBOXVDBG_CREATE_CHECK_SWAPCHAIN(); - } + VBOXVDBG_CREATE_CHECK_SWAPCHAIN(); } @@ -4802,6 +3955,9 @@ VBOXVDBG_BREAK_SHARED(pRc); - if (hr == S_OK) + if (SUCCEEDED(hr)) + { pResource->hResource = pRc; + hr = S_OK; + } else vboxResourceFree(pRc); @@ -5310,5 +4466,5 @@ VBOXVDBG_BREAK_SHARED(pDstRc); - hr = vboxWddmSurfGet(pDstRc, pData->DstSubResourceIndex, &pDstSurfIf); + hr = VBoxD3DIfSurfGet(pDstRc, pData->DstSubResourceIndex, &pDstSurfIf); Assert(hr == S_OK); if (hr == S_OK) @@ -5324,5 +4480,5 @@ else { - hr = vboxWddmSurfGet(pSrcRc, pData->SrcSubResourceIndex, &pSrcSurfIf); + hr = VBoxD3DIfSurfGet(pSrcRc, pData->SrcSubResourceIndex, &pSrcSurfIf); Assert(hr == S_OK); } @@ -5372,5 +4528,5 @@ Assert(pRc); IDirect3DSurface9 *pSurfIf = NULL; - HRESULT hr = vboxWddmSurfGet(pRc, pData->SubResourceIndex, &pSurfIf); + HRESULT hr = VBoxD3DIfSurfGet(pRc, pData->SubResourceIndex, &pSurfIf); Assert(hr == S_OK); if (hr == S_OK) @@ -6062,28 +5218,4 @@ } -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) { @@ -6108,7 +5240,36 @@ pRc->RcDesc.enmRotation = pData->Rotation; pRc->fFlags.Value = 0; - pRc->fFlags.Generic = 1; pRc->fFlags.Opened = 1; pRc->fFlags.KmResource = 1; + + for (UINT i = 0; i < pData->NumAllocations; ++i) + { + PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i]; + D3DDDI_OPENALLOCATIONINFO* pOAI = pData->pOpenAllocationInfo; + Assert(pOAI->PrivateDriverDataSize == sizeof (VBOXWDDM_ALLOCINFO)); + if (pOAI->PrivateDriverDataSize != sizeof (VBOXWDDM_ALLOCINFO)) + { + hr = E_INVALIDARG; + break; + } + Assert(pOAI->pPrivateDriverData); + PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pOAI->pPrivateDriverData; + pAllocation->hAllocation = pOAI->hAllocation; + pAllocation->enmType = pAllocInfo->enmType; + pAllocation->hSharedHandle = (HANDLE)pAllocInfo->hSharedHandle; + pAllocation->SurfDesc = pAllocInfo->SurfDesc; + pAllocation->pvMem = NULL; +#ifndef VBOXWDDMDISP_DEBUG_NOSHARED + Assert(!pAllocation->hSharedHandle == (pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE)); +#endif +#ifdef VBOXWDDMDISP_DEBUG_PRINT_SHARED_CREATE + vboxVDbgPrint(("\n\n********\n(0x%x:0n%d)Shared OPENNED pAlloc(0x%p), hRc(0x%p), hAl(0x%p), " + "Handle(0x%x), (0n%d) \n***********\n\n", + GetCurrentProcessId(), GetCurrentProcessId(), + pAllocation, pRc->hKMResource, pAllocation->hAllocation, + pAllocation->hSharedHandle, pAllocation->hSharedHandle + )); +#endif + } if (!pData->pPrivateDriverData || !pData->PrivateDriverDataSize) { @@ -6122,7 +5283,17 @@ pRc->RcDesc.MipLevels = 0; pRc->RcDesc.Fvf; - pRc->RcDesc.fFlags.Value = 0; - - Assert(pData->NumAllocations); + + if (pData->NumAllocations != 1) + { + WARN(("NumAllocations is expected to be 1, but was %d", pData->NumAllocations)); + } + + for (UINT i = 0; i < pData->NumAllocations; ++i) + { + PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i]; + pAlloc->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE; + pAlloc->pD3DIf = NULL; + } + D3DDDI_OPENALLOCATIONINFO* pDdiAllocInfo = &pData->pOpenAllocationInfo[0]; Assert(pDdiAllocInfo->pPrivateDriverData); @@ -6159,133 +5330,18 @@ Assert(!pRcInfo->fFlags.Opened); Assert(pRcInfo->cAllocInfos == pData->NumAllocations); - pRc->fFlags = pRcInfo->fFlags; - pRc->fFlags.Opened = 1; + pRc->fFlags.Value |= pRcInfo->fFlags.Value; + pRc->fFlags.Generic = 1; pRc->RcDesc = pRcInfo->RcDesc; pRc->cAllocations = pData->NumAllocations; - - for (UINT i = 0; i < pData->NumAllocations; ++i) + Assert(pRc->RcDesc.fFlags.SharedResource); + + hr = VBoxD3DIfCreateForRc(pRc); + if (!SUCCEEDED(hr)) { - PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i]; - D3DDDI_OPENALLOCATIONINFO* pOAI = pData->pOpenAllocationInfo; - Assert(pOAI->PrivateDriverDataSize == sizeof (VBOXWDDM_ALLOCINFO)); - if (pOAI->PrivateDriverDataSize != sizeof (VBOXWDDM_ALLOCINFO)) - { - hr = E_INVALIDARG; - break; - } - Assert(pOAI->pPrivateDriverData); - PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pOAI->pPrivateDriverData; - pAllocation->hAllocation = pOAI->hAllocation; - pAllocation->enmType = pAllocInfo->enmType; - pAllocation->hSharedHandle = (HANDLE)pAllocInfo->hSharedHandle; - pAllocation->SurfDesc = pAllocInfo->SurfDesc; -#ifndef VBOXWDDMDISP_DEBUG_NOSHARED - Assert(pAllocation->hSharedHandle); -#endif -#ifdef VBOXWDDMDISP_DEBUG_PRINT_SHARED_CREATE - vboxVDbgPrint(("\n\n********\n(0x%x:0n%d)Shared OPENNED pAlloc(0x%p), hRc(0x%p), hAl(0x%p), " - "Handle(0x%x), (0n%d) \n***********\n\n", - GetCurrentProcessId(), GetCurrentProcessId(), - pAllocation, pRc->hKMResource, pAllocation->hAllocation, - pAllocation->hSharedHandle, pAllocation->hSharedHandle - )); -#endif - } - - Assert(pRc->RcDesc.fFlags.SharedResource); - if (VBOXWDDMDISP_IS_TEXTURE(pRc->RcDesc.fFlags)) - { - IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice); - PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0]; - HANDLE hSharedHandle = pAllocation->hSharedHandle; -#ifndef VBOXWDDMDISP_DEBUG_NOSHARED - Assert(pAllocation->hSharedHandle); -#endif - - if (!pRc->RcDesc.fFlags.CubeMap) - { - IDirect3DTexture9 *pD3DIfTex; - hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9CreateTexture((IDirect3DDevice9Ex *)pDevice9If, - pAllocation->SurfDesc.width, - pAllocation->SurfDesc.height, - pRc->cAllocations, - vboxDDI2D3DUsage(pRc->RcDesc.fFlags), - vboxDDI2D3DFormat(pRc->RcDesc.enmFormat), - vboxDDI2D3DPool(pRc->RcDesc.enmPool), - &pD3DIfTex, -#ifdef VBOXWDDMDISP_DEBUG_NOSHARED - NULL, -#else - &hSharedHandle, -#endif - NULL); - Assert(hr == S_OK); - if (hr == S_OK) - { - Assert(pD3DIfTex); - pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_TEXTURE; - pAllocation->pD3DIf = pD3DIfTex; - Assert(pAllocation->hSharedHandle == hSharedHandle); -#ifndef VBOXWDDMDISP_DEBUG_NOSHARED - Assert(pAllocation->hSharedHandle); -#endif - } - } - else - { - IDirect3DCubeTexture9 *pD3DIfCubeTex; - - if ( (pAllocation->SurfDesc.width!=pAllocation->SurfDesc.height) - || (pRc->cAllocations%6!=0)) - { - Assert(0); - hr = E_INVALIDARG; - } - hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9CreateCubeTexture((IDirect3DDevice9Ex *)pDevice9If, - pAllocation->SurfDesc.width, - VBOXDISP_CUBEMAP_LEVELS_COUNT(pRc), - vboxDDI2D3DUsage(pRc->RcDesc.fFlags), - vboxDDI2D3DFormat(pRc->RcDesc.enmFormat), - vboxDDI2D3DPool(pRc->RcDesc.enmPool), - &pD3DIfCubeTex, -#ifdef VBOXWDDMDISP_DEBUG_NOSHARED - NULL, -#else - &hSharedHandle, -#endif - NULL); - Assert(hr == S_OK); - if (hr == S_OK) - { - Assert(pD3DIfCubeTex); - pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_CUBE_TEXTURE; - pAllocation->pD3DIf = pD3DIfCubeTex; - Assert(pAllocation->hSharedHandle == hSharedHandle); -#ifndef VBOXWDDMDISP_DEBUG_NOSHARED - Assert(pAllocation->hSharedHandle); -#endif - } - - } - } - else - { - /* impl */ - Assert(0); + WARN(("VBoxD3DIfCreateForRc failed, hr %d", hr)); } } 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; - } } @@ -6623,5 +5679,4 @@ } - HRESULT APIENTRY OpenAdapter(__inout D3DDDIARG_OPENADAPTER* pOpenData) { Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.h (revision 43235) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.h (revision 43236) @@ -337,71 +337,11 @@ } -/* on success increments the surface ref counter, - * i.e. one must call pSurf->Release() once the surface is not needed*/ -DECLINLINE(HRESULT) vboxWddmSurfGet(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc, IDirect3DSurface9 **ppSurf) -{ - HRESULT hr = S_OK; - Assert(pRc->cAllocations > iAlloc); - switch (pRc->aAllocations[0].enmD3DIfType) - { - case VBOXDISP_D3DIFTYPE_SURFACE: - { - IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pRc->aAllocations[iAlloc].pD3DIf; - Assert(pD3DIfSurf); - pD3DIfSurf->AddRef(); - *ppSurf = pD3DIfSurf; - break; - } - case VBOXDISP_D3DIFTYPE_TEXTURE: - { - Assert(pRc->cAllocations == 1); /* <- vboxWddmSurfGet is typically used in Blt & ColorFill functions - * in this case, if texture is used as a destination, - * we should update sub-layers as well which is not done currently - * so for now check vboxWddmSurfGet is used for one-level textures */ - IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf; - IDirect3DSurface9 *pSurfaceLevel; - Assert(pD3DIfTex); - hr = pD3DIfTex->GetSurfaceLevel(iAlloc, &pSurfaceLevel); - Assert(hr == S_OK); - if (hr == S_OK) - { - *ppSurf = pSurfaceLevel; - } - break; - } - case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE: - { - Assert(0); - IDirect3DCubeTexture9 *pD3DIfCubeTex = (IDirect3DCubeTexture9*)pRc->aAllocations[0].pD3DIf; - IDirect3DSurface9 *pSurfaceLevel; - Assert(pD3DIfCubeTex); - hr = pD3DIfCubeTex->GetCubeMapSurface(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, iAlloc), - VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, iAlloc), &pSurfaceLevel); - Assert(hr == S_OK); - if (hr == S_OK) - { - *ppSurf = pSurfaceLevel; - } - break; - } - default: - Assert(0); - hr = E_FAIL; - break; - } - return hr; -} - -HRESULT vboxWddmLockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc, - D3DLOCKED_RECT * pLockedRect, - CONST RECT *pRect, - DWORD fLockFlags); -HRESULT vboxWddmUnlockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc); - -#define VBOXDISPMODE_IS_3D(_p) (!!((_p)->D3D.pD3D9If)) -#ifdef VBOXDISP_EARLYCREATEDEVICE -#define VBOXDISP_D3DEV(_p) (_p)->pDevice9If -#else -#define VBOXDISP_D3DEV(_p) vboxWddmD3DDeviceGet(_p) +void vboxWddmResourceInit(PVBOXWDDMDISP_RESOURCE pRc, UINT cAllocs); + +#ifndef IN_VBOXCRHGSMI +PVBOXWDDMDISP_SWAPCHAIN vboxWddmSwapchainFindCreate(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pBbAlloc, BOOL *pbNeedPresent); +HRESULT vboxWddmSwapchainChkCreateIf(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain); +VOID vboxWddmSwapchainDestroy(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain); + #endif Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3DCmn.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3DCmn.h (revision 43235) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3DCmn.h (revision 43236) @@ -64,5 +64,7 @@ #endif #include "VBoxDispD3D.h" - +#ifndef IN_VBOXCRHGSMI +#include "VBoxD3DIf.h" +#endif # ifdef VBOXWDDMDISP Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispDbg.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispDbg.cpp (revision 43235) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispDbg.cpp (revision 43236) @@ -88,4 +88,10 @@ #ifdef VBOXWDDMDISP_DEBUG + +DWORD g_VBoxVDbgFLogRel = 1; +DWORD g_VBoxVDbgFLog = 1; +DWORD g_VBoxVDbgFLogFlow = 0; + +# ifndef IN_VBOXCRHGSMI #define VBOXWDDMDISP_DEBUG_DUMP_DEFAULT 0 DWORD g_VBoxVDbgFDumpSetTexture = VBOXWDDMDISP_DEBUG_DUMP_DEFAULT; @@ -112,8 +118,4 @@ DWORD g_VBoxVDbgFSkipCheckTexBltDwmWndUpdate = 1; -DWORD g_VBoxVDbgFLogRel = 1; -DWORD g_VBoxVDbgFLog = 1; -DWORD g_VBoxVDbgFLogFlow = 0; - DWORD g_VBoxVDbgCfgMaxDirectRts = 3; DWORD g_VBoxVDbgCfgForceDummyDevCreate = 0; @@ -277,8 +279,8 @@ const RECT *pRect = pInfo->pRect; IDirect3DSurface9 *pSurf; - HRESULT hr = vboxWddmSurfGet(pAlloc->pRc, pAlloc->iAlloc, &pSurf); + HRESULT hr = VBoxD3DIfSurfGet(pAlloc->pRc, pAlloc->iAlloc, &pSurf); if (hr != S_OK) { - WARN(("vboxWddmSurfGet failed, hr 0x%x", hr)); + WARN(("VBoxD3DIfSurfGet failed, hr 0x%x", hr)); return; } @@ -527,5 +529,4 @@ } -#ifndef IN_VBOXCRHGSMI BOOL vboxVDbgDoCheckRectsMatch(const PVBOXWDDMDISP_RESOURCE pDstRc, uint32_t iDstAlloc, const PVBOXWDDMDISP_RESOURCE pSrcRc, uint32_t iSrcAlloc, @@ -592,16 +593,16 @@ D3DLOCKED_RECT SrcLRect, DstLRect; - HRESULT hr = vboxWddmLockRect(pDstRc, iDstAlloc, &DstLRect, pDstRect, D3DLOCK_READONLY); + HRESULT hr = VBoxD3DIfLockRect(pDstRc, iDstAlloc, &DstLRect, pDstRect, D3DLOCK_READONLY); if (FAILED(hr)) { - WARN(("vboxWddmLockRect failed, hr(0x%x)", hr)); - return FALSE; - } - - hr = vboxWddmLockRect(pSrcRc, iSrcAlloc, &SrcLRect, pSrcRect, D3DLOCK_READONLY); + WARN(("VBoxD3DIfLockRect failed, hr(0x%x)", hr)); + return FALSE; + } + + hr = VBoxD3DIfLockRect(pSrcRc, iSrcAlloc, &SrcLRect, pSrcRect, D3DLOCK_READONLY); if (FAILED(hr)) { - WARN(("vboxWddmLockRect failed, hr(0x%x)", hr)); - hr = vboxWddmUnlockRect(pDstRc, iDstAlloc); + WARN(("VBoxD3DIfLockRect failed, hr(0x%x)", hr)); + hr = VBoxD3DIfUnlockRect(pDstRc, iDstAlloc); return FALSE; } @@ -609,13 +610,12 @@ fMatch = vboxVDbgDoCheckLRects(&DstLRect, pDstRect, &SrcLRect, pSrcRect, bpp, fBreakOnMismatch); - hr = vboxWddmUnlockRect(pDstRc, iDstAlloc); + hr = VBoxD3DIfUnlockRect(pDstRc, iDstAlloc); Assert(hr == S_OK); - hr = vboxWddmUnlockRect(pSrcRc, iSrcAlloc); + hr = VBoxD3DIfUnlockRect(pSrcRc, iSrcAlloc); Assert(hr == S_OK); return fMatch; } -#endif void vboxVDbgDoPrintAlloc(const char * pPrefix, const PVBOXWDDMDISP_RESOURCE pRc, uint32_t iAlloc, const char * pSuffix) @@ -643,4 +643,6 @@ vboxVDbgPrint(("%s left(%d), top(%d), right(%d), bottom(%d) %s", pPrefix, pRect->left, pRect->top, pRect->right, pRect->bottom, pSuffix)); } + +# endif static VOID CALLBACK vboxVDbgTimerCb(__in PVOID lpParameter, __in BOOLEAN TimerOrWaitFired) Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispDbg.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispDbg.h (revision 43235) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispDbg.h (revision 43236) @@ -50,4 +50,10 @@ # endif +/* log enable flags */ +extern DWORD g_VBoxVDbgFLogRel; +extern DWORD g_VBoxVDbgFLog; +extern DWORD g_VBoxVDbgFLogFlow; + +# ifndef IN_VBOXCRHGSMI /* debug config vars */ extern DWORD g_VBoxVDbgFDumpSetTexture; @@ -74,9 +80,4 @@ extern DWORD g_VBoxVDbgFSkipCheckTexBltDwmWndUpdate; -/* log enable flags */ -extern DWORD g_VBoxVDbgFLogRel; -extern DWORD g_VBoxVDbgFLog; -extern DWORD g_VBoxVDbgFLogFlow; - extern DWORD g_VBoxVDbgCfgMaxDirectRts; extern DWORD g_VBoxVDbgCfgForceDummyDevCreate; @@ -87,19 +88,5 @@ extern DWORD g_VBoxVDbgCfgCreateSwapchainOnDdiOnce; -#endif - -#if 0 -# ifdef Assert -# undef Assert -# define Assert(_a) do{}while(0) -# endif -# ifdef AssertBreakpoint -# undef AssertBreakpoint -# define AssertBreakpoint() do{}while(0) -# endif -# ifdef AssertFailed -# undef AssertFailed -# define AssertFailed() do{}while(0) -# endif +# endif /* #ifndef IN_VBOXCRHGSMI */ #endif @@ -212,4 +199,5 @@ void vboxDispLogDbgPrintF(char * szString, ...); +# ifndef IN_VBOXCRHGSMI typedef struct VBOXWDDMDISP_ALLOCATION *PVBOXWDDMDISP_ALLOCATION; typedef struct VBOXWDDMDISP_RESOURCE *PVBOXWDDMDISP_RESOURCE; @@ -640,4 +628,5 @@ } while (0) +# endif /* # ifndef IN_VBOXCRHGSMI */ #else #define VBOXVDBG_DUMP_DRAWPRIM_ENTER(_pDevice) do { } while (0)