VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxUhgsmiKmt.cpp@ 33306

Last change on this file since 33306 was 33241, checked in by vboxsync, 14 years ago

wddm/3d: chromium hgsmi working (still disabled to make some cleaning)
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 17.6 KB
Line 
1/** @file
2 *
3 * VBoxVideo Display D3D User mode dll
4 *
5 * Copyright (C) 2010 Oracle Corporation
6 *
7 * This file is part of VirtualBox Open Source Edition (OSE), as
8 * available from http://www.virtualbox.org. This file is free software;
9 * you can redistribute it and/or modify it under the terms of the GNU
10 * General Public License (GPL) as published by the Free Software
11 * Foundation, in version 2 as it comes in the "COPYING" file of the
12 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
13 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
14 */
15#include "VBoxDispD3DCmn.h"
16
17#include <iprt/mem.h>
18#include <iprt/err.h>
19
20typedef struct VBOXUHGSMI_BUFFER_PRIVATE_KMT
21{
22 VBOXUHGSMI_BUFFER_PRIVATE_BASE BasePrivate;
23 PVBOXUHGSMI_PRIVATE_KMT pHgsmi;
24 CRITICAL_SECTION CritSect;
25 UINT aLockPageIndices[1];
26} VBOXUHGSMI_BUFFER_PRIVATE_KMT, *PVBOXUHGSMI_BUFFER_PRIVATE_KMT;
27
28DECLCALLBACK(int) vboxUhgsmiKmtBufferDestroy(PVBOXUHGSMI_BUFFER pBuf)
29{
30 PVBOXUHGSMI_BUFFER_PRIVATE_KMT pBuffer = VBOXUHGSMIKMT_GET_BUFFER(pBuf);
31 D3DKMT_DESTROYALLOCATION DdiDealloc;
32 DdiDealloc.hDevice = pBuffer->pHgsmi->Device.hDevice;
33 DdiDealloc.hResource = NULL;
34 DdiDealloc.phAllocationList = &pBuffer->BasePrivate.hAllocation;
35 DdiDealloc.AllocationCount = 1;
36 NTSTATUS Status = pBuffer->pHgsmi->Callbacks.pfnD3DKMTDestroyAllocation(&DdiDealloc);
37 Assert(!Status);
38 if (!Status)
39 {
40 if (pBuffer->BasePrivate.Base.bSynchCreated)
41 {
42 CloseHandle(pBuffer->BasePrivate.Base.hSynch);
43 }
44 RTMemFree(pBuffer);
45 return VINF_SUCCESS;
46 }
47 return VERR_GENERAL_FAILURE;
48}
49
50DECLCALLBACK(int) vboxUhgsmiKmtBufferLock(PVBOXUHGSMI_BUFFER pBuf, uint32_t offLock, uint32_t cbLock, VBOXUHGSMI_BUFFER_LOCK_FLAGS fFlags, void**pvLock)
51{
52 PVBOXUHGSMI_BUFFER_PRIVATE_KMT pBuffer = VBOXUHGSMIKMT_GET_BUFFER(pBuf);
53 D3DKMT_LOCK DdiLock = {0};
54 DdiLock.hDevice = pBuffer->pHgsmi->Device.hDevice;
55 DdiLock.hAllocation = pBuffer->BasePrivate.hAllocation;
56 DdiLock.PrivateDriverData = NULL;
57
58 EnterCriticalSection(&pBuffer->CritSect);
59
60 int rc = vboxUhgsmiBaseLockData(pBuf, offLock, cbLock, fFlags,
61 &DdiLock.Flags, &DdiLock.NumPages, pBuffer->aLockPageIndices);
62 AssertRC(rc);
63 if (RT_FAILURE(rc))
64 return rc;
65
66 if (DdiLock.NumPages)
67 DdiLock.pPages = pBuffer->aLockPageIndices;
68 else
69 DdiLock.pPages = NULL;
70
71 NTSTATUS Status = pBuffer->pHgsmi->Callbacks.pfnD3DKMTLock(&DdiLock);
72 Assert(!Status);
73 LeaveCriticalSection(&pBuffer->CritSect);
74 if (!Status)
75 {
76 *pvLock = (void*)(((uint8_t*)DdiLock.pData) + (offLock & 0xfff));
77 return VINF_SUCCESS;
78 }
79 return VERR_GENERAL_FAILURE;
80}
81
82DECLCALLBACK(int) vboxUhgsmiKmtBufferUnlock(PVBOXUHGSMI_BUFFER pBuf)
83{
84 PVBOXUHGSMI_BUFFER_PRIVATE_KMT pBuffer = VBOXUHGSMIKMT_GET_BUFFER(pBuf);
85 D3DKMT_UNLOCK DdiUnlock;
86
87 DdiUnlock.hDevice = pBuffer->pHgsmi->Device.hDevice;
88 DdiUnlock.NumAllocations = 1;
89 DdiUnlock.phAllocations = &pBuffer->BasePrivate.hAllocation;
90 NTSTATUS Status = pBuffer->pHgsmi->Callbacks.pfnD3DKMTUnlock(&DdiUnlock);
91 Assert(!Status);
92 if (!Status)
93 return VINF_SUCCESS;
94 return VERR_GENERAL_FAILURE;
95}
96
97DECLCALLBACK(int) vboxUhgsmiKmtBufferCreate(PVBOXUHGSMI pHgsmi, uint32_t cbBuf,
98 VBOXUHGSMI_SYNCHOBJECT_TYPE enmSynchType, HVBOXUHGSMI_SYNCHOBJECT hSynch,
99 PVBOXUHGSMI_BUFFER* ppBuf)
100{
101 bool bSynchCreated = false;
102 if (!cbBuf)
103 return VERR_INVALID_PARAMETER;
104
105 int rc = vboxUhgsmiBaseEventChkCreate(enmSynchType, &hSynch, &bSynchCreated);
106 AssertRC(rc);
107 if (RT_FAILURE(rc))
108 return rc;
109
110 cbBuf = VBOXWDDM_ROUNDBOUND(cbBuf, 0x1000);
111 Assert(cbBuf);
112 uint32_t cPages = cbBuf >> 12;
113 Assert(cPages);
114
115 PVBOXUHGSMI_PRIVATE_KMT pPrivate = VBOXUHGSMIKMT_GET(pHgsmi);
116 PVBOXUHGSMI_BUFFER_PRIVATE_KMT pBuf = (PVBOXUHGSMI_BUFFER_PRIVATE_KMT)RTMemAllocZ(RT_OFFSETOF(VBOXUHGSMI_BUFFER_PRIVATE_KMT, aLockPageIndices[cPages]));
117 Assert(pBuf);
118 if (pBuf)
119 {
120 struct
121 {
122 D3DKMT_CREATEALLOCATION DdiAlloc;
123 D3DDDI_ALLOCATIONINFO DdiAllocInfo;
124 VBOXWDDM_ALLOCINFO AllocInfo;
125 } Buf;
126 memset(&Buf, 0, sizeof (Buf));
127 Buf.DdiAlloc.hDevice = pPrivate->Device.hDevice;
128 Buf.DdiAlloc.NumAllocations = 1;
129 Buf.DdiAlloc.pAllocationInfo = &Buf.DdiAllocInfo;
130 Buf.DdiAllocInfo.pPrivateDriverData = &Buf.AllocInfo;
131 Buf.DdiAllocInfo.PrivateDriverDataSize = sizeof (Buf.AllocInfo);
132 Buf.AllocInfo.enmType = VBOXWDDM_ALLOC_TYPE_UMD_HGSMI_BUFFER;
133 Buf.AllocInfo.cbBuffer = cbBuf;
134 Buf.AllocInfo.hSynch = hSynch;
135 Buf.AllocInfo.enmSynchType = enmSynchType;
136
137 HRESULT hr = pPrivate->Callbacks.pfnD3DKMTCreateAllocation(&Buf.DdiAlloc);
138 Assert(hr == S_OK);
139 if (hr == S_OK)
140 {
141 InitializeCriticalSection(&pBuf->CritSect);
142
143 Assert(Buf.DdiAllocInfo.hAllocation);
144 pBuf->BasePrivate.Base.pfnLock = vboxUhgsmiKmtBufferLock;
145 pBuf->BasePrivate.Base.pfnUnlock = vboxUhgsmiKmtBufferUnlock;
146// pBuf->Base.pfnAdjustValidDataRange = vboxUhgsmiKmtBufferAdjustValidDataRange;
147 pBuf->BasePrivate.Base.pfnDestroy = vboxUhgsmiKmtBufferDestroy;
148
149 pBuf->BasePrivate.Base.hSynch = hSynch;
150 pBuf->BasePrivate.Base.enmSynchType = enmSynchType;
151 pBuf->BasePrivate.Base.cbBuffer = cbBuf;
152 pBuf->BasePrivate.Base.bSynchCreated = bSynchCreated;
153
154 pBuf->pHgsmi = pPrivate;
155 pBuf->BasePrivate.hAllocation = Buf.DdiAllocInfo.hAllocation;
156
157 *ppBuf = &pBuf->BasePrivate.Base;
158
159 return VINF_SUCCESS;
160 }
161
162 RTMemFree(pBuf);
163 }
164 else
165 rc = VERR_NO_MEMORY;
166
167 if (bSynchCreated)
168 CloseHandle(hSynch);
169
170 return rc;
171}
172
173DECLCALLBACK(int) vboxUhgsmiKmtBufferSubmitAsynch(PVBOXUHGSMI pHgsmi, PVBOXUHGSMI_BUFFER_SUBMIT aBuffers, uint32_t cBuffers)
174{
175 PVBOXUHGSMI_PRIVATE_KMT pHg = VBOXUHGSMIKMT_GET(pHgsmi);
176 UINT cbDmaCmd = pHg->Context.CommandBufferSize;
177 int rc = vboxUhgsmiBaseDmaFill(aBuffers, cBuffers,
178 pHg->Context.pCommandBuffer, &cbDmaCmd,
179 pHg->Context.pAllocationList, pHg->Context.AllocationListSize,
180 pHg->Context.pPatchLocationList, pHg->Context.PatchLocationListSize);
181 AssertRC(rc);
182 if (RT_FAILURE(rc))
183 return rc;
184
185 D3DKMT_RENDER DdiRender = {0};
186 DdiRender.hContext = pHg->Context.hContext;
187 DdiRender.CommandLength = cbDmaCmd;
188 DdiRender.AllocationCount = cBuffers;
189 Assert(DdiRender.CommandLength);
190 Assert(DdiRender.CommandLength < UINT32_MAX/2);
191
192 HRESULT hr = pHg->Callbacks.pfnD3DKMTRender(&DdiRender);
193 Assert(hr == S_OK);
194 if (hr == S_OK)
195 {
196 pHg->Context.CommandBufferSize = DdiRender.NewCommandBufferSize;
197 pHg->Context.pCommandBuffer = DdiRender.pNewCommandBuffer;
198 pHg->Context.AllocationListSize = DdiRender.NewAllocationListSize;
199 pHg->Context.pAllocationList = DdiRender.pNewAllocationList;
200 pHg->Context.PatchLocationListSize = DdiRender.NewPatchLocationListSize;
201 pHg->Context.pPatchLocationList = DdiRender.pNewPatchLocationList;
202
203 return VINF_SUCCESS;
204 }
205
206 return VERR_GENERAL_FAILURE;
207}
208
209HRESULT vboxUhgsmiKmtCreate(PVBOXUHGSMI_PRIVATE_KMT pHgsmi, BOOL bD3D)
210{
211 pHgsmi->BasePrivate.Base.pfnBufferCreate = vboxUhgsmiKmtBufferCreate;
212 pHgsmi->BasePrivate.Base.pfnBufferSubmitAsynch = vboxUhgsmiKmtBufferSubmitAsynch;
213 pHgsmi->BasePrivate.hClient = NULL;
214
215 HRESULT hr = vboxDispKmtCallbacksInit(&pHgsmi->Callbacks);
216 Assert(hr == S_OK);
217 if (hr == S_OK)
218 {
219 hr = vboxDispKmtOpenAdapter(&pHgsmi->Callbacks, &pHgsmi->Adapter);
220 Assert(hr == S_OK);
221 if (hr == S_OK)
222 {
223 hr = vboxDispKmtCreateDevice(&pHgsmi->Adapter, &pHgsmi->Device);
224 Assert(hr == S_OK);
225 if (hr == S_OK)
226 {
227 hr = vboxDispKmtCreateContext(&pHgsmi->Device, &pHgsmi->Context, bD3D);
228 Assert(hr == S_OK);
229 if (hr == S_OK)
230 {
231 return S_OK;
232 }
233 vboxDispKmtDestroyDevice(&pHgsmi->Device);
234 }
235 vboxDispKmtCloseAdapter(&pHgsmi->Adapter);
236 }
237 vboxDispKmtCallbacksTerm(&pHgsmi->Callbacks);
238 }
239 return hr;
240}
241
242
243HRESULT vboxUhgsmiKmtDestroy(PVBOXUHGSMI_PRIVATE_KMT pHgsmi)
244{
245 Assert(0);
246 HRESULT hr = vboxDispKmtDestroyContext(&pHgsmi->Context);
247 Assert(hr == S_OK);
248 if (hr == S_OK)
249 {
250 hr = vboxDispKmtDestroyDevice(&pHgsmi->Device);
251 Assert(hr == S_OK);
252 if (hr == S_OK)
253 {
254 hr = vboxDispKmtCloseAdapter(&pHgsmi->Adapter);
255 Assert(hr == S_OK);
256 if (hr == S_OK)
257 {
258 hr = vboxDispKmtCallbacksTerm(&pHgsmi->Callbacks);
259 Assert(hr == S_OK);
260 if (hr == S_OK)
261 return S_OK;
262 }
263 }
264 }
265 return hr;
266}
267
268HRESULT vboxDispKmtCallbacksInit(PVBOXDISPKMT_CALLBACKS pCallbacks)
269{
270 HRESULT hr = S_OK;
271
272 memset(pCallbacks, 0, sizeof (*pCallbacks));
273
274 pCallbacks->hGdi32 = LoadLibraryW(L"gdi32.dll");
275 if (pCallbacks->hGdi32 != NULL)
276 {
277 bool bSupported = true;
278 pCallbacks->pfnD3DKMTOpenAdapterFromHdc = (PFND3DKMT_OPENADAPTERFROMHDC)GetProcAddress(pCallbacks->hGdi32, "D3DKMTOpenAdapterFromHdc");
279 Log((__FUNCTION__"pfnD3DKMTOpenAdapterFromHdc = %p\n", pCallbacks->pfnD3DKMTOpenAdapterFromHdc));
280 bSupported &= !!(pCallbacks->pfnD3DKMTOpenAdapterFromHdc);
281
282 pCallbacks->pfnD3DKMTOpenAdapterFromGdiDisplayName = (PFND3DKMT_OPENADAPTERFROMGDIDISPLAYNAME)GetProcAddress(pCallbacks->hGdi32, "D3DKMTOpenAdapterFromGdiDisplayName");
283 Log((__FUNCTION__": pfnD3DKMTOpenAdapterFromGdiDisplayName = %p\n", pCallbacks->pfnD3DKMTOpenAdapterFromGdiDisplayName));
284 bSupported &= !!(pCallbacks->pfnD3DKMTOpenAdapterFromGdiDisplayName);
285
286 pCallbacks->pfnD3DKMTCloseAdapter = (PFND3DKMT_CLOSEADAPTER)GetProcAddress(pCallbacks->hGdi32, "D3DKMTCloseAdapter");
287 Log((__FUNCTION__": pfnD3DKMTCloseAdapter = %p\n", pCallbacks->pfnD3DKMTCloseAdapter));
288 bSupported &= !!(pCallbacks->pfnD3DKMTCloseAdapter);
289
290 pCallbacks->pfnD3DKMTEscape = (PFND3DKMT_ESCAPE)GetProcAddress(pCallbacks->hGdi32, "D3DKMTEscape");
291 Log((__FUNCTION__": pfnD3DKMTEscape = %p\n", pCallbacks->pfnD3DKMTEscape));
292 bSupported &= !!(pCallbacks->pfnD3DKMTEscape);
293
294 pCallbacks->pfnD3DKMTCreateDevice = (PFND3DKMT_CREATEDEVICE)GetProcAddress(pCallbacks->hGdi32, "D3DKMTCreateDevice");
295 Log((__FUNCTION__": pfnD3DKMTCreateDevice = %p\n", pCallbacks->pfnD3DKMTCreateDevice));
296 bSupported &= !!(pCallbacks->pfnD3DKMTCreateDevice);
297
298 pCallbacks->pfnD3DKMTDestroyDevice = (PFND3DKMT_DESTROYDEVICE)GetProcAddress(pCallbacks->hGdi32, "D3DKMTDestroyDevice");
299 Log((__FUNCTION__": pfnD3DKMTDestroyDevice = %p\n", pCallbacks->pfnD3DKMTDestroyDevice));
300 bSupported &= !!(pCallbacks->pfnD3DKMTDestroyDevice);
301
302 pCallbacks->pfnD3DKMTCreateContext = (PFND3DKMT_CREATECONTEXT)GetProcAddress(pCallbacks->hGdi32, "D3DKMTCreateContext");
303 Log((__FUNCTION__": pfnD3DKMTCreateContext = %p\n", pCallbacks->pfnD3DKMTCreateContext));
304 bSupported &= !!(pCallbacks->pfnD3DKMTCreateContext);
305
306 pCallbacks->pfnD3DKMTDestroyContext = (PFND3DKMT_DESTROYCONTEXT)GetProcAddress(pCallbacks->hGdi32, "D3DKMTDestroyContext");
307 Log((__FUNCTION__": pfnD3DKMTDestroyContext = %p\n", pCallbacks->pfnD3DKMTDestroyContext));
308 bSupported &= !!(pCallbacks->pfnD3DKMTDestroyContext);
309
310 pCallbacks->pfnD3DKMTRender = (PFND3DKMT_RENDER)GetProcAddress(pCallbacks->hGdi32, "D3DKMTRender");
311 Log((__FUNCTION__": pfnD3DKMTRender = %p\n", pCallbacks->pfnD3DKMTRender));
312 bSupported &= !!(pCallbacks->pfnD3DKMTRender);
313
314 pCallbacks->pfnD3DKMTCreateAllocation = (PFND3DKMT_CREATEALLOCATION)GetProcAddress(pCallbacks->hGdi32, "D3DKMTCreateAllocation");
315 Log((__FUNCTION__": pfnD3DKMTCreateAllocation = %p\n", pCallbacks->pfnD3DKMTCreateAllocation));
316 bSupported &= !!(pCallbacks->pfnD3DKMTCreateAllocation);
317
318 pCallbacks->pfnD3DKMTDestroyAllocation = (PFND3DKMT_DESTROYALLOCATION)GetProcAddress(pCallbacks->hGdi32, "D3DKMTDestroyAllocation");
319 Log((__FUNCTION__": pfnD3DKMTDestroyAllocation = %p\n", pCallbacks->pfnD3DKMTDestroyAllocation));
320 bSupported &= !!(pCallbacks->pfnD3DKMTDestroyAllocation);
321
322 pCallbacks->pfnD3DKMTLock = (PFND3DKMT_LOCK)GetProcAddress(pCallbacks->hGdi32, "D3DKMTLock");
323 Log((__FUNCTION__": pfnD3DKMTLock = %p\n", pCallbacks->pfnD3DKMTLock));
324 bSupported &= !!(pCallbacks->pfnD3DKMTLock);
325
326 pCallbacks->pfnD3DKMTUnlock = (PFND3DKMT_UNLOCK)GetProcAddress(pCallbacks->hGdi32, "D3DKMTUnlock");
327 Log((__FUNCTION__": pfnD3DKMTUnlock = %p\n", pCallbacks->pfnD3DKMTUnlock));
328 bSupported &= !!(pCallbacks->pfnD3DKMTUnlock);
329
330 Assert(bSupported);
331 if (bSupported)
332 {
333 return S_OK;
334 }
335 else
336 {
337 Log((__FUNCTION__": one of pfnD3DKMT function pointers failed to initialize\n"));
338 hr = E_NOINTERFACE;
339 }
340
341 FreeLibrary(pCallbacks->hGdi32);
342 }
343 else
344 {
345 DWORD winEr = GetLastError();
346 hr = HRESULT_FROM_WIN32(winEr);
347 Assert(0);
348 Assert(hr != S_OK);
349 Assert(hr != S_FALSE);
350 if (hr == S_OK || hr == S_FALSE)
351 hr = E_FAIL;
352 }
353
354 return hr;
355}
356
357HRESULT vboxDispKmtCallbacksTerm(PVBOXDISPKMT_CALLBACKS pCallbacks)
358{
359 FreeLibrary(pCallbacks->hGdi32);
360 return S_OK;
361}
362
363HRESULT vboxDispKmtOpenAdapter(PVBOXDISPKMT_CALLBACKS pCallbacks, PVBOXDISPKMT_ADAPTER pAdapter)
364{
365 D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME OpenAdapterData = {0};
366 wcsncpy(OpenAdapterData.DeviceName, L"\\\\.\\DISPLAY1", RT_ELEMENTS(OpenAdapterData.DeviceName) - 1 /* the last one is always \0 */);
367 HRESULT hr = S_OK;
368 NTSTATUS Status = pCallbacks->pfnD3DKMTOpenAdapterFromGdiDisplayName(&OpenAdapterData);
369 Assert(!Status);
370 if (!Status)
371 {
372 pAdapter->hAdapter = OpenAdapterData.hAdapter;
373 pAdapter->pCallbacks = pCallbacks;
374 return S_OK;
375 }
376 else
377 {
378 Log((__FUNCTION__": pfnD3DKMTOpenAdapterFromGdiDisplayName failed, Status (0x%x)\n", Status));
379 hr = E_FAIL;
380 }
381
382 return hr;
383
384}
385
386HRESULT vboxDispKmtCloseAdapter(PVBOXDISPKMT_ADAPTER pAdapter)
387{
388 D3DKMT_CLOSEADAPTER ClosaAdapterData = {0};
389 ClosaAdapterData.hAdapter = pAdapter->hAdapter;
390 NTSTATUS Status = pAdapter->pCallbacks->pfnD3DKMTCloseAdapter(&ClosaAdapterData);
391 Assert(!Status);
392 if (!Status)
393 {
394 return S_OK;
395 }
396
397 Log((__FUNCTION__": pfnD3DKMTCloseAdapter failed, Status (0x%x)\n", Status));
398 /* ignore */
399 Status = 0;
400 return E_FAIL;
401}
402
403HRESULT vboxDispKmtCreateDevice(PVBOXDISPKMT_ADAPTER pAdapter, PVBOXDISPKMT_DEVICE pDevice)
404{
405 D3DKMT_CREATEDEVICE CreateDeviceData = {0};
406 CreateDeviceData.hAdapter = pAdapter->hAdapter;
407 NTSTATUS Status = pAdapter->pCallbacks->pfnD3DKMTCreateDevice(&CreateDeviceData);
408 Assert(!Status);
409 if (!Status)
410 {
411 pDevice->pAdapter = pAdapter;
412 pDevice->hDevice = CreateDeviceData.hDevice;
413 pDevice->pCommandBuffer = CreateDeviceData.pCommandBuffer;
414 pDevice->CommandBufferSize = CreateDeviceData.CommandBufferSize;
415 pDevice->pAllocationList = CreateDeviceData.pAllocationList;
416 pDevice->AllocationListSize = CreateDeviceData.AllocationListSize;
417 pDevice->pPatchLocationList = CreateDeviceData.pPatchLocationList;
418 pDevice->PatchLocationListSize = CreateDeviceData.PatchLocationListSize;
419
420 return S_OK;
421 }
422
423 return E_FAIL;
424}
425
426HRESULT vboxDispKmtDestroyDevice(PVBOXDISPKMT_DEVICE pDevice)
427{
428 D3DKMT_DESTROYDEVICE DestroyDeviceData = {0};
429 DestroyDeviceData.hDevice = pDevice->hDevice;
430 NTSTATUS Status = pDevice->pAdapter->pCallbacks->pfnD3DKMTDestroyDevice(&DestroyDeviceData);
431 Assert(!Status);
432 if (!Status)
433 {
434 return S_OK;
435 }
436 return E_FAIL;
437}
438
439HRESULT vboxDispKmtCreateContext(PVBOXDISPKMT_DEVICE pDevice, PVBOXDISPKMT_CONTEXT pContext, BOOL bD3D)
440{
441 VBOXWDDM_CREATECONTEXT_INFO Info = {0};
442 Info.u32IfVersion = 9;
443 Info.enmType = bD3D ? VBOXWDDM_CONTEXT_TYPE_CUSTOM_UHGSMI_3D : VBOXWDDM_CONTEXT_TYPE_CUSTOM_UHGSMI_GL;
444 D3DKMT_CREATECONTEXT ContextData = {0};
445 ContextData.hDevice = pDevice->hDevice;
446 ContextData.NodeOrdinal = 0;
447 ContextData.EngineAffinity = 0;
448 ContextData.pPrivateDriverData = &Info;
449 ContextData.PrivateDriverDataSize = sizeof (Info);
450 ContextData.ClientHint = bD3D ? D3DKMT_CLIENTHINT_DX9 : D3DKMT_CLIENTHINT_OPENGL;
451 NTSTATUS Status = pDevice->pAdapter->pCallbacks->pfnD3DKMTCreateContext(&ContextData);
452 Assert(!Status);
453 if (!Status)
454 {
455 pContext->pDevice = pDevice;
456 pContext->hContext = ContextData.hContext;
457 pContext->pCommandBuffer = ContextData.pCommandBuffer;
458 pContext->CommandBufferSize = ContextData.CommandBufferSize;
459 pContext->pAllocationList = ContextData.pAllocationList;
460 pContext->AllocationListSize = ContextData.AllocationListSize;
461 pContext->pPatchLocationList = ContextData.pPatchLocationList;
462 pContext->PatchLocationListSize = ContextData.PatchLocationListSize;
463 return S_OK;
464 }
465 return E_FAIL;
466}
467
468HRESULT vboxDispKmtDestroyContext(PVBOXDISPKMT_CONTEXT pContext)
469{
470 D3DKMT_DESTROYCONTEXT DestroyContextData = {0};
471 DestroyContextData.hContext = pContext->hContext;
472 NTSTATUS Status = pContext->pDevice->pAdapter->pCallbacks->pfnD3DKMTDestroyContext(&DestroyContextData);
473 Assert(!Status);
474 if (!Status)
475 return S_OK;
476 return E_FAIL;
477}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette