VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxUhgsmiKmt.cpp@ 37840

Last change on this file since 37840 was 37300, checked in by vboxsync, 14 years ago

wddm: memory leaks fixes, some cleanup
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 16.7 KB
Line 
1/* $Id: VBoxUhgsmiKmt.cpp 37300 2011-06-01 19:45:51Z vboxsync $ */
2
3/** @file
4 * VBoxVideo Display D3D User mode dll
5 */
6
7/*
8 * Copyright (C) 2011 Oracle Corporation
9 *
10 * This file is part of VirtualBox Open Source Edition (OSE), as
11 * available from http://www.virtualbox.org. This file is free software;
12 * you can redistribute it and/or modify it under the terms of the GNU
13 * General Public License (GPL) as published by the Free Software
14 * Foundation, in version 2 as it comes in the "COPYING" file of the
15 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17 */
18
19#include "VBoxDispD3DCmn.h"
20
21#include <iprt/mem.h>
22#include <iprt/err.h>
23
24typedef struct VBOXUHGSMI_BUFFER_PRIVATE_KMT
25{
26 VBOXUHGSMI_BUFFER_PRIVATE_BASE BasePrivate;
27 PVBOXUHGSMI_PRIVATE_KMT pHgsmi;
28 CRITICAL_SECTION CritSect;
29 UINT aLockPageIndices[1];
30} VBOXUHGSMI_BUFFER_PRIVATE_KMT, *PVBOXUHGSMI_BUFFER_PRIVATE_KMT;
31
32typedef struct VBOXUHGSMI_BUFFER_PRIVATE_KMT_ESC
33{
34 VBOXUHGSMI_BUFFER Base;
35 PVBOXUHGSMI_PRIVATE_KMT pHgsmi;
36 VBOXVIDEOCM_UM_ALLOC Alloc;
37} VBOXUHGSMI_BUFFER_PRIVATE_KMT_ESC, *PVBOXUHGSMI_BUFFER_PRIVATE_KMT_ESC;
38
39#define VBOXUHGSMIKMT_GET_BUFFER(_p) VBOXUHGSMIKMT_GET_PRIVATE(_p, VBOXUHGSMI_BUFFER_PRIVATE_KMT)
40#define VBOXUHGSMIKMTESC_GET_PRIVATE(_p, _t) ((_t*)(((uint8_t*)_p) - RT_OFFSETOF(_t, Base)))
41#define VBOXUHGSMIKMTESC_GET_BUFFER(_p) VBOXUHGSMIKMTESC_GET_PRIVATE(_p, VBOXUHGSMI_BUFFER_PRIVATE_KMT_ESC)
42
43DECLCALLBACK(int) vboxUhgsmiKmtBufferDestroy(PVBOXUHGSMI_BUFFER pBuf)
44{
45 PVBOXUHGSMI_BUFFER_PRIVATE_KMT pBuffer = VBOXUHGSMIKMT_GET_BUFFER(pBuf);
46 D3DKMT_DESTROYALLOCATION DdiDealloc;
47 DdiDealloc.hDevice = pBuffer->pHgsmi->Device.hDevice;
48 DdiDealloc.hResource = NULL;
49 DdiDealloc.phAllocationList = &pBuffer->BasePrivate.hAllocation;
50 DdiDealloc.AllocationCount = 1;
51 NTSTATUS Status = pBuffer->pHgsmi->Callbacks.pfnD3DKMTDestroyAllocation(&DdiDealloc);
52 Assert(!Status);
53 if (!Status)
54 {
55 if (pBuffer->BasePrivate.Base.bSynchCreated)
56 {
57 CloseHandle(pBuffer->BasePrivate.Base.hSynch);
58 }
59 RTMemFree(pBuffer);
60 return VINF_SUCCESS;
61 }
62 return VERR_GENERAL_FAILURE;
63}
64
65DECLCALLBACK(int) vboxUhgsmiKmtBufferLock(PVBOXUHGSMI_BUFFER pBuf, uint32_t offLock, uint32_t cbLock, VBOXUHGSMI_BUFFER_LOCK_FLAGS fFlags, void**pvLock)
66{
67 PVBOXUHGSMI_BUFFER_PRIVATE_KMT pBuffer = VBOXUHGSMIKMT_GET_BUFFER(pBuf);
68 D3DKMT_LOCK DdiLock = {0};
69 DdiLock.hDevice = pBuffer->pHgsmi->Device.hDevice;
70 DdiLock.hAllocation = pBuffer->BasePrivate.hAllocation;
71 DdiLock.PrivateDriverData = NULL;
72
73 EnterCriticalSection(&pBuffer->CritSect);
74
75 int rc = vboxUhgsmiBaseLockData(pBuf, offLock, cbLock, fFlags,
76 &DdiLock.Flags, &DdiLock.NumPages, pBuffer->aLockPageIndices);
77 AssertRC(rc);
78 if (RT_FAILURE(rc))
79 return rc;
80
81 if (DdiLock.NumPages)
82 DdiLock.pPages = pBuffer->aLockPageIndices;
83 else
84 DdiLock.pPages = NULL;
85
86 NTSTATUS Status = pBuffer->pHgsmi->Callbacks.pfnD3DKMTLock(&DdiLock);
87 Assert(!Status);
88 LeaveCriticalSection(&pBuffer->CritSect);
89 if (!Status)
90 {
91 *pvLock = (void*)(((uint8_t*)DdiLock.pData) + (offLock & 0xfff));
92 return VINF_SUCCESS;
93 }
94 return VERR_GENERAL_FAILURE;
95}
96
97DECLCALLBACK(int) vboxUhgsmiKmtBufferUnlock(PVBOXUHGSMI_BUFFER pBuf)
98{
99 PVBOXUHGSMI_BUFFER_PRIVATE_KMT pBuffer = VBOXUHGSMIKMT_GET_BUFFER(pBuf);
100 D3DKMT_UNLOCK DdiUnlock;
101
102 DdiUnlock.hDevice = pBuffer->pHgsmi->Device.hDevice;
103 DdiUnlock.NumAllocations = 1;
104 DdiUnlock.phAllocations = &pBuffer->BasePrivate.hAllocation;
105 NTSTATUS Status = pBuffer->pHgsmi->Callbacks.pfnD3DKMTUnlock(&DdiUnlock);
106 Assert(!Status);
107 if (!Status)
108 return VINF_SUCCESS;
109 return VERR_GENERAL_FAILURE;
110}
111
112DECLCALLBACK(int) vboxUhgsmiKmtBufferCreate(PVBOXUHGSMI pHgsmi, uint32_t cbBuf,
113 VBOXUHGSMI_SYNCHOBJECT_TYPE enmSynchType, HVBOXUHGSMI_SYNCHOBJECT hSynch,
114 PVBOXUHGSMI_BUFFER* ppBuf)
115{
116 bool bSynchCreated = false;
117 if (!cbBuf)
118 return VERR_INVALID_PARAMETER;
119
120 int rc = vboxUhgsmiBaseEventChkCreate(enmSynchType, &hSynch, &bSynchCreated);
121 AssertRC(rc);
122 if (RT_FAILURE(rc))
123 return rc;
124
125 cbBuf = VBOXWDDM_ROUNDBOUND(cbBuf, 0x1000);
126 Assert(cbBuf);
127 uint32_t cPages = cbBuf >> 12;
128 Assert(cPages);
129
130 PVBOXUHGSMI_PRIVATE_KMT pPrivate = VBOXUHGSMIKMT_GET(pHgsmi);
131 PVBOXUHGSMI_BUFFER_PRIVATE_KMT pBuf = (PVBOXUHGSMI_BUFFER_PRIVATE_KMT)RTMemAllocZ(RT_OFFSETOF(VBOXUHGSMI_BUFFER_PRIVATE_KMT, aLockPageIndices[cPages]));
132 Assert(pBuf);
133 if (pBuf)
134 {
135 struct
136 {
137 D3DKMT_CREATEALLOCATION DdiAlloc;
138 D3DDDI_ALLOCATIONINFO DdiAllocInfo;
139 VBOXWDDM_ALLOCINFO AllocInfo;
140 } Buf;
141 memset(&Buf, 0, sizeof (Buf));
142 Buf.DdiAlloc.hDevice = pPrivate->Device.hDevice;
143 Buf.DdiAlloc.NumAllocations = 1;
144 Buf.DdiAlloc.pAllocationInfo = &Buf.DdiAllocInfo;
145 Buf.DdiAllocInfo.pPrivateDriverData = &Buf.AllocInfo;
146 Buf.DdiAllocInfo.PrivateDriverDataSize = sizeof (Buf.AllocInfo);
147 Buf.AllocInfo.enmType = VBOXWDDM_ALLOC_TYPE_UMD_HGSMI_BUFFER;
148 Buf.AllocInfo.cbBuffer = cbBuf;
149 Buf.AllocInfo.hSynch = (uint64_t)hSynch;
150 Buf.AllocInfo.enmSynchType = enmSynchType;
151
152 HRESULT hr = pPrivate->Callbacks.pfnD3DKMTCreateAllocation(&Buf.DdiAlloc);
153 Assert(hr == S_OK);
154 if (hr == S_OK)
155 {
156 InitializeCriticalSection(&pBuf->CritSect);
157
158 Assert(Buf.DdiAllocInfo.hAllocation);
159 pBuf->BasePrivate.Base.pfnLock = vboxUhgsmiKmtBufferLock;
160 pBuf->BasePrivate.Base.pfnUnlock = vboxUhgsmiKmtBufferUnlock;
161// pBuf->Base.pfnAdjustValidDataRange = vboxUhgsmiKmtBufferAdjustValidDataRange;
162 pBuf->BasePrivate.Base.pfnDestroy = vboxUhgsmiKmtBufferDestroy;
163
164 pBuf->BasePrivate.Base.hSynch = hSynch;
165 pBuf->BasePrivate.Base.enmSynchType = enmSynchType;
166 pBuf->BasePrivate.Base.cbBuffer = cbBuf;
167 pBuf->BasePrivate.Base.bSynchCreated = bSynchCreated;
168
169 pBuf->pHgsmi = pPrivate;
170 pBuf->BasePrivate.hAllocation = Buf.DdiAllocInfo.hAllocation;
171
172 *ppBuf = &pBuf->BasePrivate.Base;
173
174 return VINF_SUCCESS;
175 }
176 else
177 {
178 rc = VERR_OUT_OF_RESOURCES;
179 }
180
181 RTMemFree(pBuf);
182 }
183 else
184 rc = VERR_NO_MEMORY;
185
186 if (bSynchCreated)
187 CloseHandle(hSynch);
188
189 return rc;
190}
191
192DECLCALLBACK(int) vboxUhgsmiKmtBufferSubmitAsynch(PVBOXUHGSMI pHgsmi, PVBOXUHGSMI_BUFFER_SUBMIT aBuffers, uint32_t cBuffers)
193{
194 PVBOXUHGSMI_PRIVATE_KMT pHg = VBOXUHGSMIKMT_GET(pHgsmi);
195 UINT cbDmaCmd = pHg->Context.CommandBufferSize;
196 int rc = vboxUhgsmiBaseDmaFill(aBuffers, cBuffers,
197 pHg->Context.pCommandBuffer, &cbDmaCmd,
198 pHg->Context.pAllocationList, pHg->Context.AllocationListSize,
199 pHg->Context.pPatchLocationList, pHg->Context.PatchLocationListSize);
200 AssertRC(rc);
201 if (RT_FAILURE(rc))
202 return rc;
203
204 D3DKMT_RENDER DdiRender = {0};
205 DdiRender.hContext = pHg->Context.hContext;
206 DdiRender.CommandLength = cbDmaCmd;
207 DdiRender.AllocationCount = cBuffers;
208 Assert(DdiRender.CommandLength);
209 Assert(DdiRender.CommandLength < UINT32_MAX/2);
210
211 HRESULT hr = pHg->Callbacks.pfnD3DKMTRender(&DdiRender);
212 Assert(hr == S_OK);
213 if (hr == S_OK)
214 {
215 pHg->Context.CommandBufferSize = DdiRender.NewCommandBufferSize;
216 pHg->Context.pCommandBuffer = DdiRender.pNewCommandBuffer;
217 pHg->Context.AllocationListSize = DdiRender.NewAllocationListSize;
218 pHg->Context.pAllocationList = DdiRender.pNewAllocationList;
219 pHg->Context.PatchLocationListSize = DdiRender.NewPatchLocationListSize;
220 pHg->Context.pPatchLocationList = DdiRender.pNewPatchLocationList;
221
222 return VINF_SUCCESS;
223 }
224
225 return VERR_GENERAL_FAILURE;
226}
227
228
229DECLCALLBACK(int) vboxUhgsmiKmtEscBufferLock(PVBOXUHGSMI_BUFFER pBuf, uint32_t offLock, uint32_t cbLock, VBOXUHGSMI_BUFFER_LOCK_FLAGS fFlags, void**pvLock)
230{
231 PVBOXUHGSMI_BUFFER_PRIVATE_KMT_ESC pBuffer = VBOXUHGSMIKMTESC_GET_BUFFER(pBuf);
232 *pvLock = (void*)(pBuffer->Alloc.pvData + offLock);
233 return VINF_SUCCESS;
234}
235
236DECLCALLBACK(int) vboxUhgsmiKmtEscBufferUnlock(PVBOXUHGSMI_BUFFER pBuf)
237{
238 return VINF_SUCCESS;
239}
240
241DECLCALLBACK(int) vboxUhgsmiKmtEscBufferDestroy(PVBOXUHGSMI_BUFFER pBuf)
242{
243 PVBOXUHGSMI_BUFFER_PRIVATE_KMT_ESC pBuffer = VBOXUHGSMIKMTESC_GET_BUFFER(pBuf);
244 PVBOXUHGSMI_PRIVATE_KMT pPrivate = pBuffer->pHgsmi;
245 D3DKMT_ESCAPE DdiEscape = {0};
246 VBOXDISPIFESCAPE_UHGSMI_DEALLOCATE DeallocInfo = {0};
247 DdiEscape.hAdapter = pPrivate->Adapter.hAdapter;
248 DdiEscape.hDevice = pPrivate->Device.hDevice;
249 DdiEscape.Type = D3DKMT_ESCAPE_DRIVERPRIVATE;
250 //Buf.DdiEscape.Flags.HardwareAccess = 1;
251 DdiEscape.pPrivateDriverData = &DeallocInfo;
252 DdiEscape.PrivateDriverDataSize = sizeof (DeallocInfo);
253 DdiEscape.hContext = pPrivate->Context.hContext;
254
255 DeallocInfo.EscapeHdr.escapeCode = VBOXESC_UHGSMI_DEALLOCATE;
256 DeallocInfo.hAlloc = pBuffer->Alloc.hAlloc;
257
258 HRESULT hr = pPrivate->Callbacks.pfnD3DKMTEscape(&DdiEscape);
259 Assert(hr == S_OK);
260 if (hr == S_OK)
261 {
262 if (pBuffer->Base.bSynchCreated)
263 {
264 CloseHandle(pBuffer->Base.hSynch);
265 }
266 RTMemFree(pBuffer);
267 return VINF_SUCCESS;
268 }
269
270 return VERR_GENERAL_FAILURE;
271}
272
273DECLCALLBACK(int) vboxUhgsmiKmtEscBufferCreate(PVBOXUHGSMI pHgsmi, uint32_t cbBuf,
274 VBOXUHGSMI_SYNCHOBJECT_TYPE enmSynchType, HVBOXUHGSMI_SYNCHOBJECT hSynch,
275 PVBOXUHGSMI_BUFFER* ppBuf)
276{
277 bool bSynchCreated = false;
278 if (!cbBuf)
279 return VERR_INVALID_PARAMETER;
280
281 int rc = vboxUhgsmiBaseEventChkCreate(enmSynchType, &hSynch, &bSynchCreated);
282 AssertRC(rc);
283 if (RT_FAILURE(rc))
284 return rc;
285
286 cbBuf = VBOXWDDM_ROUNDBOUND(cbBuf, 0x1000);
287 Assert(cbBuf);
288 uint32_t cPages = cbBuf >> 12;
289 Assert(cPages);
290
291 PVBOXUHGSMI_PRIVATE_KMT pPrivate = VBOXUHGSMIKMT_GET(pHgsmi);
292 PVBOXUHGSMI_BUFFER_PRIVATE_KMT_ESC pBuf = (PVBOXUHGSMI_BUFFER_PRIVATE_KMT_ESC)RTMemAllocZ(RT_OFFSETOF(VBOXUHGSMI_BUFFER_PRIVATE_KMT, aLockPageIndices[cPages]));
293 Assert(pBuf);
294 if (pBuf)
295 {
296 struct
297 {
298 D3DKMT_ESCAPE DdiEscape;
299 VBOXDISPIFESCAPE_UHGSMI_ALLOCATE AllocInfo;
300 } Buf;
301 memset(&Buf, 0, sizeof (Buf));
302 Buf.DdiEscape.hAdapter = pPrivate->Adapter.hAdapter;
303 Buf.DdiEscape.hDevice = pPrivate->Device.hDevice;
304 Buf.DdiEscape.Type = D3DKMT_ESCAPE_DRIVERPRIVATE;
305 //Buf.DdiEscape.Flags.HardwareAccess = 1;
306 Buf.DdiEscape.pPrivateDriverData = &Buf.AllocInfo;
307 Buf.DdiEscape.PrivateDriverDataSize = sizeof (Buf.AllocInfo);
308 Buf.DdiEscape.hContext = pPrivate->Context.hContext;
309
310 Buf.AllocInfo.EscapeHdr.escapeCode = VBOXESC_UHGSMI_ALLOCATE;
311 Buf.AllocInfo.Alloc.cbData = cbBuf;
312 Buf.AllocInfo.Alloc.hSynch = (uint64_t)hSynch;
313 Buf.AllocInfo.Alloc.enmSynchType = enmSynchType;
314
315 HRESULT hr = pPrivate->Callbacks.pfnD3DKMTEscape(&Buf.DdiEscape);
316 Assert(hr == S_OK);
317 if (hr == S_OK)
318 {
319 pBuf->Alloc = Buf.AllocInfo.Alloc;
320 Assert(pBuf->Alloc.pvData);
321 pBuf->pHgsmi = pPrivate;
322 pBuf->Base.pfnLock = vboxUhgsmiKmtEscBufferLock;
323 pBuf->Base.pfnUnlock = vboxUhgsmiKmtEscBufferUnlock;
324// pBuf->Base.pfnAdjustValidDataRange = vboxUhgsmiKmtBufferAdjustValidDataRange;
325 pBuf->Base.pfnDestroy = vboxUhgsmiKmtEscBufferDestroy;
326
327 pBuf->Base.hSynch = hSynch;
328 pBuf->Base.enmSynchType = enmSynchType;
329 pBuf->Base.cbBuffer = Buf.AllocInfo.Alloc.cbData;
330 pBuf->Base.bSynchCreated = bSynchCreated;
331
332 *ppBuf = &pBuf->Base;
333
334 return VINF_SUCCESS;
335 }
336 else
337 {
338 rc = VERR_OUT_OF_RESOURCES;
339 }
340
341 RTMemFree(pBuf);
342 }
343 else
344 rc = VERR_NO_MEMORY;
345
346 if (bSynchCreated)
347 CloseHandle(hSynch);
348
349 return rc;
350}
351
352DECLCALLBACK(int) vboxUhgsmiKmtEscBufferSubmitAsynch(PVBOXUHGSMI pHgsmi, PVBOXUHGSMI_BUFFER_SUBMIT aBuffers, uint32_t cBuffers)
353{
354 /* we no chromium will not submit more than three buffers actually,
355 * for simplicity allocate it statically on the stack */
356 struct
357 {
358 VBOXDISPIFESCAPE_UHGSMI_SUBMIT SubmitInfo;
359 VBOXWDDM_UHGSMI_BUFFER_UI_INFO_ESCAPE aBufInfos[3];
360 } Buf;
361
362 if (cBuffers > RT_ELEMENTS(Buf.aBufInfos) + 1)
363 {
364 Assert(0);
365 return VERR_INVALID_PARAMETER;
366 }
367
368
369 PVBOXUHGSMI_PRIVATE_KMT pPrivate = VBOXUHGSMIKMT_GET(pHgsmi);
370 D3DKMT_ESCAPE DdiEscape = {0};
371
372 DdiEscape.hAdapter = pPrivate->Adapter.hAdapter;
373 DdiEscape.hDevice = pPrivate->Device.hDevice;
374 DdiEscape.Type = D3DKMT_ESCAPE_DRIVERPRIVATE;
375 //Buf.DdiEscape.Flags.HardwareAccess = 1;
376 DdiEscape.pPrivateDriverData = &Buf.SubmitInfo;
377 DdiEscape.PrivateDriverDataSize = RT_OFFSETOF(VBOXDISPIFESCAPE_UHGSMI_SUBMIT, aBuffers[cBuffers]);
378 DdiEscape.hContext = pPrivate->Context.hContext;
379
380 Buf.SubmitInfo.EscapeHdr.escapeCode = VBOXESC_UHGSMI_SUBMIT;
381 Buf.SubmitInfo.EscapeHdr.u32CmdSpecific = cBuffers;
382 for (UINT i = 0; i < cBuffers; ++i)
383 {
384 VBOXWDDM_UHGSMI_BUFFER_UI_INFO_ESCAPE *pSubmInfo = &Buf.SubmitInfo.aBuffers[i];
385 PVBOXUHGSMI_BUFFER_SUBMIT pBufInfo = &aBuffers[i];
386 PVBOXUHGSMI_BUFFER_PRIVATE_KMT_ESC pBuf = VBOXUHGSMIKMTESC_GET_BUFFER(pBufInfo->pBuf);
387 pSubmInfo->hAlloc = pBuf->Alloc.hAlloc;
388 pSubmInfo->Info.fSubFlags = pBufInfo->fFlags;
389 if (pBufInfo->fFlags.bEntireBuffer)
390 {
391 pSubmInfo->Info.offData = 0;
392 pSubmInfo->Info.cbData = pBuf->Base.cbBuffer;
393 }
394 else
395 {
396 pSubmInfo->Info.offData = pBufInfo->offData;
397 pSubmInfo->Info.cbData = pBufInfo->cbData;
398 }
399 }
400
401 HRESULT hr = pPrivate->Callbacks.pfnD3DKMTEscape(&DdiEscape);
402 Assert(hr == S_OK);
403 if (hr == S_OK)
404 {
405 return VINF_SUCCESS;
406 }
407
408 return VERR_GENERAL_FAILURE;
409}
410
411static HRESULT vboxUhgsmiKmtEngineCreate(PVBOXUHGSMI_PRIVATE_KMT pHgsmi, BOOL bD3D)
412{
413 HRESULT hr = vboxDispKmtCallbacksInit(&pHgsmi->Callbacks);
414 if (hr == S_OK)
415 {
416 hr = vboxDispKmtOpenAdapter(&pHgsmi->Callbacks, &pHgsmi->Adapter);
417 if (hr == S_OK)
418 {
419 hr = vboxDispKmtCreateDevice(&pHgsmi->Adapter, &pHgsmi->Device);
420 if (hr == S_OK)
421 {
422 hr = vboxDispKmtCreateContext(&pHgsmi->Device, &pHgsmi->Context,
423 bD3D ? VBOXWDDM_CONTEXT_TYPE_CUSTOM_UHGSMI_3D : VBOXWDDM_CONTEXT_TYPE_CUSTOM_UHGSMI_GL,
424 NULL, 0);
425 if (hr == S_OK)
426 {
427 return S_OK;
428 }
429 else
430 {
431 WARN(("vboxDispKmtCreateContext failed, hr(0x%x)", hr));
432 }
433 vboxDispKmtDestroyDevice(&pHgsmi->Device);
434 }
435 else
436 {
437 WARN(("vboxDispKmtCreateDevice failed, hr(0x%x)", hr));
438 }
439 vboxDispKmtCloseAdapter(&pHgsmi->Adapter);
440 }
441 else
442 {
443 WARN(("vboxDispKmtOpenAdapter failed, hr(0x%x)", hr));
444 }
445
446 vboxDispKmtCallbacksTerm(&pHgsmi->Callbacks);
447 }
448 else
449 {
450 WARN(("vboxDispKmtCallbacksInit failed, hr(0x%x)", hr));
451 }
452 return hr;
453}
454HRESULT vboxUhgsmiKmtCreate(PVBOXUHGSMI_PRIVATE_KMT pHgsmi, BOOL bD3D)
455{
456 pHgsmi->BasePrivate.Base.pfnBufferCreate = vboxUhgsmiKmtBufferCreate;
457 pHgsmi->BasePrivate.Base.pfnBufferSubmitAsynch = vboxUhgsmiKmtBufferSubmitAsynch;
458#ifdef VBOX_CRHGSMI_WITH_D3DDEV
459 pHgsmi->BasePrivate.hClient = NULL;
460#endif
461 return vboxUhgsmiKmtEngineCreate(pHgsmi, bD3D);
462}
463
464HRESULT vboxUhgsmiKmtEscCreate(PVBOXUHGSMI_PRIVATE_KMT pHgsmi, BOOL bD3D)
465{
466 pHgsmi->BasePrivate.Base.pfnBufferCreate = vboxUhgsmiKmtEscBufferCreate;
467 pHgsmi->BasePrivate.Base.pfnBufferSubmitAsynch = vboxUhgsmiKmtEscBufferSubmitAsynch;
468#ifdef VBOX_CRHGSMI_WITH_D3DDEV
469 pHgsmi->BasePrivate.hClient = NULL;
470#endif
471 return vboxUhgsmiKmtEngineCreate(pHgsmi, bD3D);
472}
473
474HRESULT vboxUhgsmiKmtDestroy(PVBOXUHGSMI_PRIVATE_KMT pHgsmi)
475{
476 HRESULT hr = vboxDispKmtDestroyContext(&pHgsmi->Context);
477 Assert(hr == S_OK);
478 if (hr == S_OK)
479 {
480 hr = vboxDispKmtDestroyDevice(&pHgsmi->Device);
481 Assert(hr == S_OK);
482 if (hr == S_OK)
483 {
484 hr = vboxDispKmtCloseAdapter(&pHgsmi->Adapter);
485 Assert(hr == S_OK);
486 if (hr == S_OK)
487 {
488 hr = vboxDispKmtCallbacksTerm(&pHgsmi->Callbacks);
489 Assert(hr == S_OK);
490 if (hr == S_OK)
491 return S_OK;
492 }
493 }
494 }
495 return hr;
496}
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