Index: /trunk/src/VBox/Additions/3D/win/VBoxGL/GaDrvEnvKMT.cpp =================================================================== --- /trunk/src/VBox/Additions/3D/win/VBoxGL/GaDrvEnvKMT.cpp (revision 75629) +++ /trunk/src/VBox/Additions/3D/win/VBoxGL/GaDrvEnvKMT.cpp (revision 75630) @@ -91,8 +91,8 @@ * KMT specific helpers. */ - int drvEnvKmtRenderCompose(uint32_t u32Cid, - void *pvCommands, - uint32_t cbCommands, - ULONGLONG PresentHistoryToken); + bool drvEnvKmtRenderCompose(uint32_t u32Cid, + void *pvCommands, + uint32_t cbCommands, + ULONGLONG PresentHistoryToken); D3DKMT_HANDLE drvEnvKmtContextHandle(uint32_t u32Cid); D3DKMT_HANDLE drvEnvKmtSurfaceHandle(uint32_t u32Sid); @@ -126,6 +126,6 @@ uint32_t cSizes, uint32_t *pu32Sid); - static DECLCALLBACK(int) gaEnvSurfaceDestroy(void *pvEnv, - uint32_t u32Sid); + static DECLCALLBACK(void) gaEnvSurfaceDestroy(void *pvEnv, + uint32_t u32Sid); static DECLCALLBACK(int) gaEnvRender(void *pvEnv, uint32_t u32Cid, @@ -152,6 +152,6 @@ * Internal. */ - int doRender(uint32_t u32Cid, void *pvCommands, uint32_t cbCommands, - GAFENCEQUERY *pFenceQuery, ULONGLONG PresentHistoryToken, bool fPresentRedirected); + bool doRender(uint32_t u32Cid, void *pvCommands, uint32_t cbCommands, + GAFENCEQUERY *pFenceQuery, ULONGLONG PresentHistoryToken, bool fPresentRedirected); }; @@ -175,6 +175,6 @@ -/// @todo vboxDdi helpers must return NTSTATUS -static NTSTATUS +/// @todo vboxDdi helpers must return a boof success indicator +static bool vboxDdiQueryAdapterInfo(GaKmtCallbacks *pKmtCallbacks, D3DKMT_HANDLE hAdapter, @@ -182,15 +182,13 @@ uint32_t cbAdapterInfo) { - NTSTATUS Status; - D3DKMT_QUERYADAPTERINFO kmtQAI; - - memset(&kmtQAI, 0, sizeof(kmtQAI)); - kmtQAI.hAdapter = hAdapter; - kmtQAI.Type = KMTQAITYPE_UMDRIVERPRIVATE; - kmtQAI.pPrivateDriverData = pAdapterInfo; - kmtQAI.PrivateDriverDataSize = cbAdapterInfo; - - Status = pKmtCallbacks->d3dkmt->pfnD3DKMTQueryAdapterInfo(&kmtQAI); - return Status; + D3DKMT_QUERYADAPTERINFO QAI; + memset(&QAI, 0, sizeof(QAI)); + QAI.hAdapter = hAdapter; + QAI.Type = KMTQAITYPE_UMDRIVERPRIVATE; + QAI.pPrivateDriverData = pAdapterInfo; + QAI.PrivateDriverDataSize = cbAdapterInfo; + + NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTQueryAdapterInfo(&QAI); + return Status == STATUS_SUCCESS; } @@ -201,39 +199,35 @@ if (hDevice) { - D3DKMT_DESTROYDEVICE kmtDestroyDevice; - memset(&kmtDestroyDevice, 0, sizeof(kmtDestroyDevice)); - kmtDestroyDevice.hDevice = hDevice; - pKmtCallbacks->d3dkmt->pfnD3DKMTDestroyDevice(&kmtDestroyDevice); - } -} - -static NTSTATUS + D3DKMT_DESTROYDEVICE DestroyDeviceData; + memset(&DestroyDeviceData, 0, sizeof(DestroyDeviceData)); + DestroyDeviceData.hDevice = hDevice; + pKmtCallbacks->d3dkmt->pfnD3DKMTDestroyDevice(&DestroyDeviceData); + } +} + +static bool vboxDdiDeviceCreate(GaKmtCallbacks *pKmtCallbacks, D3DKMT_HANDLE *phDevice) { - NTSTATUS Status; - D3DKMT_CREATEDEVICE kmtCreateDevice; - - memset(&kmtCreateDevice, 0, sizeof(kmtCreateDevice)); - kmtCreateDevice.hAdapter = pKmtCallbacks->hAdapter; - // kmtCreateDevice.Flags = 0; - - Status = pKmtCallbacks->d3dkmt->pfnD3DKMTCreateDevice(&kmtCreateDevice); + D3DKMT_CREATEDEVICE CreateDeviceData; + memset(&CreateDeviceData, 0, sizeof(CreateDeviceData)); + CreateDeviceData.hAdapter = pKmtCallbacks->hAdapter; + // CreateDeviceData.Flags = 0; + + NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTCreateDevice(&CreateDeviceData); if (Status == STATUS_SUCCESS) { - *phDevice = kmtCreateDevice.hDevice; - } - return Status; -} - -static NTSTATUS + *phDevice = CreateDeviceData.hDevice; + return true; + } + return false; +} + +static bool vboxDdiContextGetId(GaKmtCallbacks *pKmtCallbacks, D3DKMT_HANDLE hContext, uint32_t *pu32Cid) { - NTSTATUS Status; - D3DKMT_ESCAPE kmtEscape; VBOXDISPIFESCAPE_GAGETCID data; - memset(&data, 0, sizeof(data)); data.EscapeHdr.escapeCode = VBOXESC_GAGETCID; @@ -244,20 +238,21 @@ * have also set hDevice to a non-NULL value... */ - memset(&kmtEscape, 0, sizeof(kmtEscape)); - kmtEscape.hAdapter = pKmtCallbacks->hAdapter; - kmtEscape.hDevice = pKmtCallbacks->hDevice; - kmtEscape.Type = D3DKMT_ESCAPE_DRIVERPRIVATE; - // kmtEscape.Flags.HardwareAccess = 0; - kmtEscape.pPrivateDriverData = &data; - kmtEscape.PrivateDriverDataSize = sizeof(data); - kmtEscape.hContext = hContext; - - Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&kmtEscape); + D3DKMT_ESCAPE EscapeData; + memset(&EscapeData, 0, sizeof(EscapeData)); + EscapeData.hAdapter = pKmtCallbacks->hAdapter; + EscapeData.hDevice = pKmtCallbacks->hDevice; + EscapeData.Type = D3DKMT_ESCAPE_DRIVERPRIVATE; + // EscapeData.Flags.HardwareAccess = 0; + EscapeData.pPrivateDriverData = &data; + EscapeData.PrivateDriverDataSize = sizeof(data); + EscapeData.hContext = hContext; + + NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&EscapeData); if (Status == STATUS_SUCCESS) { *pu32Cid = data.u32Cid; - return S_OK; - } - return E_FAIL; + return true; + } + return false; } @@ -268,52 +263,50 @@ if (pContextInfo->hContext) { - D3DKMT_DESTROYCONTEXT kmtDestroyContext; - memset(&kmtDestroyContext, 0, sizeof(kmtDestroyContext)); - kmtDestroyContext.hContext = pContextInfo->hContext; - pKmtCallbacks->d3dkmt->pfnD3DKMTDestroyContext(&kmtDestroyContext); - } -} - -static HRESULT + D3DKMT_DESTROYCONTEXT DestroyContextData; + memset(&DestroyContextData, 0, sizeof(DestroyContextData)); + DestroyContextData.hContext = pContextInfo->hContext; + pKmtCallbacks->d3dkmt->pfnD3DKMTDestroyContext(&DestroyContextData); + } +} + +static bool vboxDdiContextCreate(GaKmtCallbacks *pKmtCallbacks, void *pvPrivateData, uint32_t cbPrivateData, GAWDDMCONTEXTINFO *pContextInfo) { - NTSTATUS Status; - D3DKMT_CREATECONTEXT kmtCreateContext; - - memset(&kmtCreateContext, 0, sizeof(kmtCreateContext)); - kmtCreateContext.hDevice = pKmtCallbacks->hDevice; - // kmtCreateContext.NodeOrdinal = 0; - // kmtCreateContext.EngineAffinity = 0; - // kmtCreateContext.Flags.Value = 0; - kmtCreateContext.pPrivateDriverData = pvPrivateData; - kmtCreateContext.PrivateDriverDataSize = cbPrivateData; - kmtCreateContext.ClientHint = D3DKMT_CLIENTHINT_OPENGL; - - Status = pKmtCallbacks->d3dkmt->pfnD3DKMTCreateContext(&kmtCreateContext); + D3DKMT_CREATECONTEXT CreateContextData; + memset(&CreateContextData, 0, sizeof(CreateContextData)); + CreateContextData.hDevice = pKmtCallbacks->hDevice; + // CreateContextData.NodeOrdinal = 0; + // CreateContextData.EngineAffinity = 0; + // CreateContextData.Flags.Value = 0; + CreateContextData.pPrivateDriverData = pvPrivateData; + CreateContextData.PrivateDriverDataSize = cbPrivateData; + CreateContextData.ClientHint = D3DKMT_CLIENTHINT_OPENGL; + + NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTCreateContext(&CreateContextData); if (Status == STATUS_SUCCESS) { /* Query cid. */ uint32_t u32Cid = 0; - Status = vboxDdiContextGetId(pKmtCallbacks, kmtCreateContext.hContext, &u32Cid); - if (Status == STATUS_SUCCESS) + bool fSuccess = vboxDdiContextGetId(pKmtCallbacks, CreateContextData.hContext, &u32Cid); + if (fSuccess) { pContextInfo->Core.Key = u32Cid; - pContextInfo->hContext = kmtCreateContext.hContext; - pContextInfo->pCommandBuffer = kmtCreateContext.pCommandBuffer; - pContextInfo->CommandBufferSize = kmtCreateContext.CommandBufferSize; - pContextInfo->pAllocationList = kmtCreateContext.pAllocationList; - pContextInfo->AllocationListSize = kmtCreateContext.AllocationListSize; - pContextInfo->pPatchLocationList = kmtCreateContext.pPatchLocationList; - pContextInfo->PatchLocationListSize = kmtCreateContext.PatchLocationListSize; - } - else - { - vboxDdiContextDestroy(pKmtCallbacks, pContextInfo); - } - } - - return (Status == STATUS_SUCCESS) ? S_OK : E_FAIL; + pContextInfo->hContext = CreateContextData.hContext; + pContextInfo->pCommandBuffer = CreateContextData.pCommandBuffer; + pContextInfo->CommandBufferSize = CreateContextData.CommandBufferSize; + pContextInfo->pAllocationList = CreateContextData.pAllocationList; + pContextInfo->AllocationListSize = CreateContextData.AllocationListSize; + pContextInfo->pPatchLocationList = CreateContextData.pPatchLocationList; + pContextInfo->PatchLocationListSize = CreateContextData.PatchLocationListSize; + + return true; + } + + vboxDdiContextDestroy(pKmtCallbacks, pContextInfo); + } + + return false; } @@ -347,21 +340,19 @@ GaDrvEnvKmt *pThis = (GaDrvEnvKmt *)pvEnv; - VBOXWDDM_CREATECONTEXT_INFO privateData; GAWDDMCONTEXTINFO *pContextInfo; - HRESULT hr; - pContextInfo = (GAWDDMCONTEXTINFO *)malloc(sizeof(GAWDDMCONTEXTINFO)); if (!pContextInfo) return (uint32_t)-1; + VBOXWDDM_CREATECONTEXT_INFO privateData; memset(&privateData, 0, sizeof(privateData)); - privateData.u32IfVersion = 9; - privateData.enmType = VBOXWDDM_CONTEXT_TYPE_GA_3D; + privateData.u32IfVersion = 9; + privateData.enmType = VBOXWDDM_CONTEXT_TYPE_GA_3D; privateData.u.vmsvga.u32Flags = extended? VBOXWDDM_F_GA_CONTEXT_EXTENDED: 0; privateData.u.vmsvga.u32Flags |= vgpu10? VBOXWDDM_F_GA_CONTEXT_VGPU10: 0; - hr = vboxDdiContextCreate(&pThis->mKmtCallbacks, - &privateData, sizeof(privateData), pContextInfo); - if (SUCCEEDED(hr)) + bool fSuccess = vboxDdiContextCreate(&pThis->mKmtCallbacks, + &privateData, sizeof(privateData), pContextInfo); + if (fSuccess) { if (RTAvlU32Insert(&pThis->mContextTree, &pContextInfo->Core)) @@ -375,5 +366,4 @@ Assert(0); - free(pContextInfo); return (uint32_t)-1; @@ -392,8 +382,10 @@ case SVGA3D_A1R5G5B5: return D3DDDIFMT_A1R5G5B5; case SVGA3D_LUMINANCE8_ALPHA8: return D3DDDIFMT_A8L8; + case SVGA3D_R5G6B5: return D3DDDIFMT_R5G6B5; default: break; } Assert(0); + VBoxDispMpLoggerLogF("WDDM: EnvKMT: unsupported surface format %d\n", format); return D3DDDIFMT_UNKNOWN; } @@ -408,5 +400,4 @@ GaDrvEnvKmt *pThis = (GaDrvEnvKmt *)pvEnv; - NTSTATUS Status; D3DKMT_ESCAPE EscapeData; VBOXDISPIFESCAPE_GASURFACEDEFINE *pData; @@ -444,5 +435,5 @@ // EscapeData.hContext = 0; - Status = pThis->mKmtCallbacks.d3dkmt->pfnD3DKMTEscape(&EscapeData); + NTSTATUS Status = pThis->mKmtCallbacks.d3dkmt->pfnD3DKMTEscape(&EscapeData); if (Status == STATUS_SUCCESS) { @@ -532,5 +523,5 @@ } -/* static */ DECLCALLBACK(int) +/* static */ DECLCALLBACK(void) GaDrvEnvKmt::gaEnvSurfaceDestroy(void *pvEnv, uint32_t u32Sid) @@ -538,8 +529,5 @@ GaDrvEnvKmt *pThis = (GaDrvEnvKmt *)pvEnv; - NTSTATUS Status; - D3DKMT_ESCAPE kmtEscape; VBOXDISPIFESCAPE_GASURFACEDESTROY data; - memset(&data, 0, sizeof(data)); data.EscapeHdr.escapeCode = VBOXESC_GASURFACEDESTROY; @@ -547,14 +535,15 @@ data.u32Sid = u32Sid; - memset(&kmtEscape, 0, sizeof(kmtEscape)); - kmtEscape.hAdapter = pThis->mKmtCallbacks.hAdapter; - kmtEscape.hDevice = pThis->mKmtCallbacks.hDevice; - kmtEscape.Type = D3DKMT_ESCAPE_DRIVERPRIVATE; - kmtEscape.Flags.HardwareAccess = 1; - kmtEscape.pPrivateDriverData = &data; - kmtEscape.PrivateDriverDataSize = sizeof(data); - // kmtEscape.hContext = 0; - - Status = pThis->mKmtCallbacks.d3dkmt->pfnD3DKMTEscape(&kmtEscape); + D3DKMT_ESCAPE EscapeData; + memset(&EscapeData, 0, sizeof(EscapeData)); + EscapeData.hAdapter = pThis->mKmtCallbacks.hAdapter; + EscapeData.hDevice = pThis->mKmtCallbacks.hDevice; + EscapeData.Type = D3DKMT_ESCAPE_DRIVERPRIVATE; + EscapeData.Flags.HardwareAccess = 1; + EscapeData.pPrivateDriverData = &data; + EscapeData.PrivateDriverDataSize = sizeof(data); + // EscapeData.hContext = 0; + + NTSTATUS Status = pThis->mKmtCallbacks.d3dkmt->pfnD3DKMTEscape(&EscapeData); Assert(Status == STATUS_SUCCESS); @@ -575,6 +564,4 @@ free(pSurfaceInfo); } - - return (Status == STATUS_SUCCESS)? 0: -1; } @@ -585,13 +572,10 @@ } -static HRESULT +static bool vboxDdiFenceCreate(GaKmtCallbacks *pKmtCallbacks, GAWDDMCONTEXTINFO *pContextInfo, uint32_t *pu32FenceHandle) { - NTSTATUS Status; - D3DKMT_ESCAPE kmtEscape; VBOXDISPIFESCAPE_GAFENCECREATE fenceCreate; - memset(&fenceCreate, 0, sizeof(fenceCreate)); fenceCreate.EscapeHdr.escapeCode = VBOXESC_GAFENCECREATE; @@ -601,32 +585,31 @@ * have also set hDevice to a non-NULL value... */ - memset(&kmtEscape, 0, sizeof(kmtEscape)); - kmtEscape.hAdapter = pKmtCallbacks->hAdapter; - kmtEscape.hDevice = pKmtCallbacks->hDevice; - kmtEscape.Type = D3DKMT_ESCAPE_DRIVERPRIVATE; - // kmtEscape.Flags.HardwareAccess = 0; - kmtEscape.pPrivateDriverData = &fenceCreate; - kmtEscape.PrivateDriverDataSize = sizeof(fenceCreate); - kmtEscape.hContext = pContextInfo->hContext; - - Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&kmtEscape); + D3DKMT_ESCAPE EscapeData; + memset(&EscapeData, 0, sizeof(EscapeData)); + EscapeData.hAdapter = pKmtCallbacks->hAdapter; + EscapeData.hDevice = pKmtCallbacks->hDevice; + EscapeData.Type = D3DKMT_ESCAPE_DRIVERPRIVATE; + // EscapeData.Flags.HardwareAccess = 0; + EscapeData.pPrivateDriverData = &fenceCreate; + EscapeData.PrivateDriverDataSize = sizeof(fenceCreate); + EscapeData.hContext = pContextInfo->hContext; + + NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&EscapeData); if (Status == STATUS_SUCCESS) { *pu32FenceHandle = fenceCreate.u32FenceHandle; - } - - Assert(Status == STATUS_SUCCESS); - return (Status == STATUS_SUCCESS) ? S_OK : E_FAIL; -} - -static HRESULT + return true; + } + + Assert(0); + return false; +} + +static bool vboxDdiFenceQuery(GaKmtCallbacks *pKmtCallbacks, uint32_t u32FenceHandle, GAFENCEQUERY *pFenceQuery) { - NTSTATUS Status; - D3DKMT_ESCAPE kmtEscape; VBOXDISPIFESCAPE_GAFENCEQUERY fenceQuery; - memset(&fenceQuery, 0, sizeof(fenceQuery)); fenceQuery.EscapeHdr.escapeCode = VBOXESC_GAFENCEQUERY; @@ -634,14 +617,15 @@ fenceQuery.u32FenceHandle = u32FenceHandle; - memset(&kmtEscape, 0, sizeof(kmtEscape)); - kmtEscape.hAdapter = pKmtCallbacks->hAdapter; - kmtEscape.hDevice = pKmtCallbacks->hDevice; - kmtEscape.Type = D3DKMT_ESCAPE_DRIVERPRIVATE; - // kmtEscape.Flags.HardwareAccess = 0; - kmtEscape.pPrivateDriverData = &fenceQuery; - kmtEscape.PrivateDriverDataSize = sizeof(fenceQuery); - kmtEscape.hContext = 0; - - Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&kmtEscape); + D3DKMT_ESCAPE EscapeData; + memset(&EscapeData, 0, sizeof(EscapeData)); + EscapeData.hAdapter = pKmtCallbacks->hAdapter; + EscapeData.hDevice = pKmtCallbacks->hDevice; + EscapeData.Type = D3DKMT_ESCAPE_DRIVERPRIVATE; + // EscapeData.Flags.HardwareAccess = 0; + EscapeData.pPrivateDriverData = &fenceQuery; + EscapeData.PrivateDriverDataSize = sizeof(fenceQuery); + EscapeData.hContext = 0; + + NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&EscapeData); if (Status == STATUS_SUCCESS) { @@ -650,8 +634,9 @@ pFenceQuery->u32ProcessedSeqNo = fenceQuery.u32ProcessedSeqNo; pFenceQuery->u32FenceStatus = fenceQuery.u32FenceStatus; - } - - Assert(Status == STATUS_SUCCESS); - return (Status == STATUS_SUCCESS) ? S_OK : E_FAIL; + return true; + } + + Assert(0); + return false; } @@ -669,20 +654,14 @@ } - HRESULT hr = vboxDdiFenceQuery(&pThis->mKmtCallbacks, u32FenceHandle, pFenceQuery); - if (FAILED(hr)) - return -1; - - return 0; -} - -static HRESULT + bool fSuccess = vboxDdiFenceQuery(&pThis->mKmtCallbacks, u32FenceHandle, pFenceQuery); + return fSuccess ? 0: -1; +} + +static bool vboxDdiFenceWait(GaKmtCallbacks *pKmtCallbacks, uint32_t u32FenceHandle, uint32_t u32TimeoutUS) { - NTSTATUS Status; - D3DKMT_ESCAPE kmtEscape; VBOXDISPIFESCAPE_GAFENCEWAIT fenceWait; - memset(&fenceWait, 0, sizeof(fenceWait)); fenceWait.EscapeHdr.escapeCode = VBOXESC_GAFENCEWAIT; @@ -691,16 +670,17 @@ fenceWait.u32TimeoutUS = u32TimeoutUS; - memset(&kmtEscape, 0, sizeof(kmtEscape)); - kmtEscape.hAdapter = pKmtCallbacks->hAdapter; - kmtEscape.hDevice = pKmtCallbacks->hDevice; - kmtEscape.Type = D3DKMT_ESCAPE_DRIVERPRIVATE; - // kmtEscape.Flags.HardwareAccess = 0; - kmtEscape.pPrivateDriverData = &fenceWait; - kmtEscape.PrivateDriverDataSize = sizeof(fenceWait); - kmtEscape.hContext = 0; - - Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&kmtEscape); + D3DKMT_ESCAPE EscapeData; + memset(&EscapeData, 0, sizeof(EscapeData)); + EscapeData.hAdapter = pKmtCallbacks->hAdapter; + EscapeData.hDevice = pKmtCallbacks->hDevice; + EscapeData.Type = D3DKMT_ESCAPE_DRIVERPRIVATE; + // EscapeData.Flags.HardwareAccess = 0; + EscapeData.pPrivateDriverData = &fenceWait; + EscapeData.PrivateDriverDataSize = sizeof(fenceWait); + EscapeData.hContext = 0; + + NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&EscapeData); Assert(Status == STATUS_SUCCESS); - return (Status == STATUS_SUCCESS) ? S_OK : E_FAIL; + return Status == STATUS_SUCCESS; } @@ -715,16 +695,13 @@ return 0; - HRESULT hr = vboxDdiFenceWait(&pThis->mKmtCallbacks, u32FenceHandle, u32TimeoutUS); - return SUCCEEDED(hr) ? 0 : -1; -} - -static HRESULT + bool fSuccess = vboxDdiFenceWait(&pThis->mKmtCallbacks, u32FenceHandle, u32TimeoutUS); + return fSuccess ? 0 : -1; +} + +static bool vboxDdiFenceUnref(GaKmtCallbacks *pKmtCallbacks, uint32_t u32FenceHandle) { - NTSTATUS Status; - D3DKMT_ESCAPE kmtEscape; VBOXDISPIFESCAPE_GAFENCEUNREF fenceUnref; - memset(&fenceUnref, 0, sizeof(fenceUnref)); fenceUnref.EscapeHdr.escapeCode = VBOXESC_GAFENCEUNREF; @@ -732,16 +709,17 @@ fenceUnref.u32FenceHandle = u32FenceHandle; - memset(&kmtEscape, 0, sizeof(kmtEscape)); - kmtEscape.hAdapter = pKmtCallbacks->hAdapter; - kmtEscape.hDevice = pKmtCallbacks->hDevice; - kmtEscape.Type = D3DKMT_ESCAPE_DRIVERPRIVATE; - // kmtEscape.Flags.HardwareAccess = 0; - kmtEscape.pPrivateDriverData = &fenceUnref; - kmtEscape.PrivateDriverDataSize = sizeof(fenceUnref); - kmtEscape.hContext = 0; - - Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&kmtEscape); + D3DKMT_ESCAPE EscapeData; + memset(&EscapeData, 0, sizeof(EscapeData)); + EscapeData.hAdapter = pKmtCallbacks->hAdapter; + EscapeData.hDevice = pKmtCallbacks->hDevice; + EscapeData.Type = D3DKMT_ESCAPE_DRIVERPRIVATE; + // EscapeData.Flags.HardwareAccess = 0; + EscapeData.pPrivateDriverData = &fenceUnref; + EscapeData.PrivateDriverDataSize = sizeof(fenceUnref); + EscapeData.hContext = 0; + + NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&EscapeData); Assert(Status == STATUS_SUCCESS); - return (Status == STATUS_SUCCESS) ? S_OK : E_FAIL; + return Status == STATUS_SUCCESS; } @@ -765,9 +743,7 @@ * @param pu32Length Size of commands which will fit in cbAvail bytes. */ -static HRESULT +static bool vboxCalcCommandLength(const uint8_t *pu8Commands, uint32_t cbCommands, uint32_t cbAvail, uint32_t *pu32Length) { - HRESULT hr = S_OK; - uint32_t u32Length = 0; const uint8_t *pu8Src = pu8Commands; @@ -779,6 +755,5 @@ if (cbSrcLeft < sizeof(uint32_t)) { - hr = E_INVALIDARG; - break; + return false; } @@ -791,6 +766,5 @@ if (cbSrcLeft < sizeof(SVGA3dCmdHeader)) { - hr = E_INVALIDARG; - break; + return false; } @@ -799,11 +773,9 @@ if (cbCmd % sizeof(uint32_t) != 0) { - hr = E_INVALIDARG; - break; + return false; } if (cbSrcLeft < cbCmd) { - hr = E_INVALIDARG; - break; + return false; } } @@ -813,6 +785,5 @@ * because the SVGA gallium driver does not use them. */ - hr = E_INVALIDARG; - break; + return false; } @@ -822,5 +793,5 @@ { /* No commands fit into the buffer. */ - hr = E_FAIL; + return false; } break; @@ -832,18 +803,14 @@ *pu32Length = u32Length; - return hr; -} - -static HRESULT + return true; +} + +static bool vboxDdiRender(GaKmtCallbacks *pKmtCallbacks, GAWDDMCONTEXTINFO *pContextInfo, uint32_t u32FenceHandle, void *pvCommands, uint32_t cbCommands, ULONGLONG PresentHistoryToken, bool fPresentRedirected) { - HRESULT hr = S_OK; - D3DKMT_RENDER kmtRender; uint32_t cbLeft; const uint8_t *pu8Src; - - // LogRel(("vboxDdiRender: cbCommands = %d, u32FenceHandle = %d\n", cbCommands, u32FenceHandle)); cbLeft = cbCommands; @@ -856,6 +823,5 @@ if (cbAvail <= sizeof(u32FenceHandle)) { - hr = E_FAIL; - break; + return false; } @@ -878,8 +844,7 @@ /* Get how much commands data will fit in the buffer. */ - hr = vboxCalcCommandLength(pu8Src, cbCommandChunk, cbAvail - sizeof(u32FenceHandle), &cbCommandChunk); - if (hr != S_OK) + if (!vboxCalcCommandLength(pu8Src, cbCommandChunk, cbAvail - sizeof(u32FenceHandle), &cbCommandChunk)) { - break; + return false; } @@ -897,58 +862,56 @@ cbLeft -= cbCommandChunk; - memset(&kmtRender, 0, sizeof(kmtRender)); - kmtRender.hContext = pContextInfo->hContext; - // kmtRender.CommandOffset = 0; - kmtRender.CommandLength = cbToCopy; - // kmtRender.AllocationCount = 0; - // kmtRender.PatchLocationCount = 0; - kmtRender.PresentHistoryToken = PresentHistoryToken; - kmtRender.Flags.PresentRedirected = fPresentRedirected; - - NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTRender(&kmtRender); + D3DKMT_RENDER RenderData; + memset(&RenderData, 0, sizeof(RenderData)); + RenderData.hContext = pContextInfo->hContext; + // RenderData.CommandOffset = 0; + RenderData.CommandLength = cbToCopy; + // RenderData.AllocationCount = 0; + // RenderData.PatchLocationCount = 0; + RenderData.PresentHistoryToken = PresentHistoryToken; + RenderData.Flags.PresentRedirected = fPresentRedirected; + + NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTRender(&RenderData); Assert(Status == STATUS_SUCCESS); if (Status != STATUS_SUCCESS) { - hr = E_FAIL; - break; - } - - pContextInfo->pCommandBuffer = kmtRender.pNewCommandBuffer; - pContextInfo->CommandBufferSize = kmtRender.NewCommandBufferSize; - pContextInfo->pAllocationList = kmtRender.pNewAllocationList; - pContextInfo->AllocationListSize = kmtRender.NewAllocationListSize; - pContextInfo->pPatchLocationList = kmtRender.pNewPatchLocationList; - pContextInfo->PatchLocationListSize = kmtRender.NewPatchLocationListSize; + return false; + } + + pContextInfo->pCommandBuffer = RenderData.pNewCommandBuffer; + pContextInfo->CommandBufferSize = RenderData.NewCommandBufferSize; + pContextInfo->pAllocationList = RenderData.pNewAllocationList; + pContextInfo->AllocationListSize = RenderData.NewAllocationListSize; + pContextInfo->pPatchLocationList = RenderData.pNewPatchLocationList; + pContextInfo->PatchLocationListSize = RenderData.NewPatchLocationListSize; } while (cbLeft); - return hr; -} - -/** @todo return bool */ -int GaDrvEnvKmt::doRender(uint32_t u32Cid, void *pvCommands, uint32_t cbCommands, + return true; +} + +bool GaDrvEnvKmt::doRender(uint32_t u32Cid, void *pvCommands, uint32_t cbCommands, GAFENCEQUERY *pFenceQuery, ULONGLONG PresentHistoryToken, bool fPresentRedirected) { - HRESULT hr = S_OK; uint32_t u32FenceHandle; GAWDDMCONTEXTINFO *pContextInfo = (GAWDDMCONTEXTINFO *)RTAvlU32Get(&mContextTree, u32Cid); if (!pContextInfo) - return -1; - + return false; + + bool fSuccess = true; u32FenceHandle = 0; if (pFenceQuery) { - hr = vboxDdiFenceCreate(&mKmtCallbacks, pContextInfo, &u32FenceHandle); - } - - if (SUCCEEDED(hr)) - { - hr = vboxDdiRender(&mKmtCallbacks, pContextInfo, u32FenceHandle, - pvCommands, cbCommands, PresentHistoryToken, fPresentRedirected); - if (SUCCEEDED(hr)) + fSuccess = vboxDdiFenceCreate(&mKmtCallbacks, pContextInfo, &u32FenceHandle); + } + + if (fSuccess) + { + fSuccess = vboxDdiRender(&mKmtCallbacks, pContextInfo, u32FenceHandle, + pvCommands, cbCommands, PresentHistoryToken, fPresentRedirected); + if (fSuccess) { if (pFenceQuery) { - HRESULT hr2 = vboxDdiFenceQuery(&mKmtCallbacks, u32FenceHandle, pFenceQuery); - if (hr2 != S_OK) + if (!vboxDdiFenceQuery(&mKmtCallbacks, u32FenceHandle, pFenceQuery)) { pFenceQuery->u32FenceStatus = GA_FENCE_STATUS_NULL; @@ -957,5 +920,5 @@ } } - return SUCCEEDED(hr)? 0: 1; + return fSuccess; } @@ -968,11 +931,11 @@ { GaDrvEnvKmt *pThis = (GaDrvEnvKmt *)pvEnv; - return pThis->doRender(u32Cid, pvCommands, cbCommands, pFenceQuery, 0, false); -} - -int GaDrvEnvKmt::drvEnvKmtRenderCompose(uint32_t u32Cid, - void *pvCommands, - uint32_t cbCommands, - ULONGLONG PresentHistoryToken) + return pThis->doRender(u32Cid, pvCommands, cbCommands, pFenceQuery, 0, false) ? 1 : 0; +} + +bool GaDrvEnvKmt::drvEnvKmtRenderCompose(uint32_t u32Cid, + void *pvCommands, + uint32_t cbCommands, + ULONGLONG PresentHistoryToken) { return doRender(u32Cid, pvCommands, cbCommands, NULL, PresentHistoryToken, true); @@ -980,5 +943,5 @@ -static HRESULT +static bool vboxDdiRegionCreate(GaKmtCallbacks *pKmtCallbacks, uint32_t u32RegionSize, @@ -986,8 +949,5 @@ void **ppvMap) { - NTSTATUS Status; - D3DKMT_ESCAPE kmtEscape; VBOXDISPIFESCAPE_GAREGION data; - memset(&data, 0, sizeof(data)); data.EscapeHdr.escapeCode = VBOXESC_GAREGION; @@ -998,21 +958,24 @@ // data.u64UserAddress = 0; - memset(&kmtEscape, 0, sizeof(kmtEscape)); - kmtEscape.hAdapter = pKmtCallbacks->hAdapter; - kmtEscape.hDevice = pKmtCallbacks->hDevice; - kmtEscape.Type = D3DKMT_ESCAPE_DRIVERPRIVATE; - // kmtEscape.Flags.HardwareAccess = 0; - kmtEscape.pPrivateDriverData = &data; - kmtEscape.PrivateDriverDataSize = sizeof(data); - // kmtEscape.hContext = 0; - - Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&kmtEscape); + D3DKMT_ESCAPE EscapeData; + memset(&EscapeData, 0, sizeof(EscapeData)); + EscapeData.hAdapter = pKmtCallbacks->hAdapter; + EscapeData.hDevice = pKmtCallbacks->hDevice; + EscapeData.Type = D3DKMT_ESCAPE_DRIVERPRIVATE; + // EscapeData.Flags.HardwareAccess = 0; + EscapeData.pPrivateDriverData = &data; + EscapeData.PrivateDriverDataSize = sizeof(data); + // EscapeData.hContext = 0; + + NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&EscapeData); if (Status == STATUS_SUCCESS) { *pu32GmrId = data.u32GmrId; *ppvMap = (void *)(uintptr_t)data.u64UserAddress; - } - Assert(Status == STATUS_SUCCESS); - return (Status == STATUS_SUCCESS) ? S_OK : E_FAIL; + return true; + } + + Assert(0); + return false; } @@ -1025,36 +988,27 @@ GaDrvEnvKmt *pThis = (GaDrvEnvKmt *)pvEnv; - int ret; - if (pThis->mKmtCallbacks.hDevice) { /* That is a real device */ - HRESULT hr = vboxDdiRegionCreate(&pThis->mKmtCallbacks, u32RegionSize, pu32GmrId, ppvMap); - ret = SUCCEEDED(hr)? 0: -1; - } - else - { - /* That is a fake device, created when WDDM adapter is initialized. */ - *ppvMap = malloc(u32RegionSize); - if (*ppvMap != NULL) - { - *pu32GmrId = 0; - ret = 0; - } - else - ret = -1; - } - - return ret; -} - -static HRESULT + bool fSuccess = vboxDdiRegionCreate(&pThis->mKmtCallbacks, u32RegionSize, pu32GmrId, ppvMap); + return fSuccess ? 0: -1; + } + + /* That is a fake device, created when WDDM adapter is initialized. */ + *ppvMap = malloc(u32RegionSize); + if (*ppvMap) + { + *pu32GmrId = 0; + return 0; + } + + return -1; +} + +static bool vboxDdiRegionDestroy(GaKmtCallbacks *pKmtCallbacks, uint32_t u32GmrId) { - NTSTATUS Status; - D3DKMT_ESCAPE kmtEscape; VBOXDISPIFESCAPE_GAREGION data; - memset(&data, 0, sizeof(data)); data.EscapeHdr.escapeCode = VBOXESC_GAREGION; @@ -1065,16 +1019,17 @@ // data.u64UserAddress = 0; - memset(&kmtEscape, 0, sizeof(kmtEscape)); - kmtEscape.hAdapter = pKmtCallbacks->hAdapter; - kmtEscape.hDevice = pKmtCallbacks->hDevice; - kmtEscape.Type = D3DKMT_ESCAPE_DRIVERPRIVATE; - // kmtEscape.Flags.HardwareAccess = 0; - kmtEscape.pPrivateDriverData = &data; - kmtEscape.PrivateDriverDataSize = sizeof(data); - // kmtEscape.hContext = 0; - - Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&kmtEscape); + D3DKMT_ESCAPE EscapeData; + memset(&EscapeData, 0, sizeof(EscapeData)); + EscapeData.hAdapter = pKmtCallbacks->hAdapter; + EscapeData.hDevice = pKmtCallbacks->hDevice; + EscapeData.Type = D3DKMT_ESCAPE_DRIVERPRIVATE; + // EscapeData.Flags.HardwareAccess = 0; + EscapeData.pPrivateDriverData = &data; + EscapeData.PrivateDriverDataSize = sizeof(data); + // EscapeData.hContext = 0; + + NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&EscapeData); Assert(Status == STATUS_SUCCESS); - return (Status == STATUS_SUCCESS) ? S_OK : E_FAIL; + return Status == STATUS_SUCCESS; } @@ -1116,17 +1071,14 @@ NTSTATUS Status = vboxDispKmtOpenAdapter2(&mKmtCallbacks.hAdapter, &mKmtCallbacks.AdapterLuid); Assert(Status == STATUS_SUCCESS); - if (Status == STATUS_SUCCESS) { VBOXWDDM_QAI adapterInfo; - Status = vboxDdiQueryAdapterInfo(&mKmtCallbacks, mKmtCallbacks.hAdapter, &adapterInfo, sizeof(adapterInfo)); - Assert(Status == STATUS_SUCCESS); - - if (Status == STATUS_SUCCESS) - { - Status = vboxDdiDeviceCreate(&mKmtCallbacks, &mKmtCallbacks.hDevice); - Assert(Status == STATUS_SUCCESS); - - if (Status == STATUS_SUCCESS) + bool fSuccess = vboxDdiQueryAdapterInfo(&mKmtCallbacks, mKmtCallbacks.hAdapter, &adapterInfo, sizeof(adapterInfo)); + Assert(fSuccess); + if (fSuccess) + { + fSuccess = vboxDdiDeviceCreate(&mKmtCallbacks, &mKmtCallbacks.hDevice); + Assert(fSuccess); + if (fSuccess) { mHWInfo = adapterInfo.u.vmsvga.HWInfo; Index: /trunk/src/VBox/Additions/3D/win/VBoxWddmUmHlp/VBoxWddmUmHlp.h =================================================================== --- /trunk/src/VBox/Additions/3D/win/VBoxWddmUmHlp/VBoxWddmUmHlp.h (revision 75629) +++ /trunk/src/VBox/Additions/3D/win/VBoxWddmUmHlp/VBoxWddmUmHlp.h (revision 75630) @@ -85,4 +85,5 @@ DECLCALLBACK(D3DKMTFUNCTIONS const *) D3DKMTFunctions(void); +DECLCALLBACK(void) VBoxDispMpLoggerLogF(const char *pszString, ...); DECLCALLBACK(void) VBoxWddmUmLog(const char *pszString); Index: /trunk/src/VBox/Additions/3D/win/include/VBoxGaDriver.h =================================================================== --- /trunk/src/VBox/Additions/3D/win/include/VBoxGaDriver.h (revision 75629) +++ /trunk/src/VBox/Additions/3D/win/include/VBoxGaDriver.h (revision 75630) @@ -46,6 +46,6 @@ uint32_t cSizes, uint32_t *pu32Sid); - DECLCALLBACKMEMBER(int, pfnSurfaceDestroy)(void *pvEnv, - uint32_t u32Sid); + DECLCALLBACKMEMBER(void, pfnSurfaceDestroy)(void *pvEnv, + uint32_t u32Sid); DECLCALLBACKMEMBER(int, pfnRender)(void *pvEnv, uint32_t u32Cid, Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/gallium/GaDrvEnvWddm.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/gallium/GaDrvEnvWddm.cpp (revision 75629) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/gallium/GaDrvEnvWddm.cpp (revision 75630) @@ -237,5 +237,5 @@ } -/* static */ DECLCALLBACK(int) +/* static */ DECLCALLBACK(void) GaDrvEnvWddm::gaEnvWddmSurfaceDestroy(void *pvEnv, uint32_t u32Sid) @@ -260,5 +260,5 @@ hr = pThis->mWddmCallbacks.DeviceCallbacks.pfnEscapeCb(pThis->mWddmCallbacks.hAdapter, &ddiEscape); - return SUCCEEDED(hr)? 0: -1; + Assert(SUCCEEDED(hr)); } Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/gallium/GaDrvEnvWddm.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/gallium/GaDrvEnvWddm.h (revision 75629) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/gallium/GaDrvEnvWddm.h (revision 75630) @@ -70,6 +70,6 @@ uint32_t cSizes, uint32_t *pu32Sid); - static DECLCALLBACK(int) gaEnvWddmSurfaceDestroy(void *pvEnv, - uint32_t u32Sid); + static DECLCALLBACK(void) gaEnvWddmSurfaceDestroy(void *pvEnv, + uint32_t u32Sid); static DECLCALLBACK(int) gaEnvWddmRender(void *pvEnv, uint32_t u32Cid,