VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp@ 27516

Last change on this file since 27516 was 27516, checked in by vboxsync, 15 years ago

wddm: yet another fix to make dwm & stuff more happy
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 45.8 KB
Line 
1/** @file
2 *
3 * VBoxVideo Display D3D User mode dll
4 *
5 * Copyright (C) 2010 Sun Microsystems, Inc.
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 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
16 * Clara, CA 95054 USA or visit http://www.sun.com if you need
17 * additional information or have any questions.
18 */
19#include <windows.h>
20#include <d3d9types.h>
21//#include <d3dtypes.h>
22#include <D3dumddi.h>
23#include <d3dhal.h>
24
25
26#include <iprt/initterm.h>
27#include <iprt/log.h>
28#include <iprt/mem.h>
29
30#include <VBox/Log.h>
31
32#include <VBox/VBoxGuestLib.h>
33
34#include "VBoxDispD3D.h"
35
36#ifdef VBOXWDDMDISP_DEBUG
37# include <stdio.h>
38#endif
39
40/**
41 * DLL entry point.
42 */
43BOOL WINAPI DllMain(HINSTANCE hInstance,
44 DWORD dwReason,
45 LPVOID lpReserved)
46{
47 switch (dwReason)
48 {
49 case DLL_PROCESS_ATTACH:
50 {
51 /* there __try __except are just to ensure the library does not assertion fail in case VBoxGuest is not present
52 * and VbglR3Init / VbglR3Term assertion fail */
53 __try
54 {
55// LogRel(("VBoxDispD3D: DLL loaded.\n"));
56 RTR3Init();
57// VbglR3Init();
58 }
59 __except (EXCEPTION_CONTINUE_EXECUTION)
60 {
61 }
62
63 break;
64 }
65
66 case DLL_PROCESS_DETACH:
67 {
68 /* there __try __except are just to ensure the library does not assertion fail in case VBoxGuest is not present
69 * and VbglR3Init / VbglR3Term assertion fail */
70// __try
71// {
72// LogRel(("VBoxDispD3D: DLL unloaded.\n"));
73// VbglR3Term();
74// }
75// __except (EXCEPTION_CONTINUE_EXECUTION)
76// {
77// }
78 /// @todo RTR3Term();
79 break;
80 }
81
82 default:
83 break;
84 }
85 return TRUE;
86}
87
88static HRESULT APIENTRY vboxWddmDispGetCaps (HANDLE hAdapter, CONST D3DDDIARG_GETCAPS* pData)
89{
90 vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p), caps type(%d)\n", hAdapter, pData->Type));
91
92 HRESULT hr = S_OK;
93
94 switch (pData->Type)
95 {
96 case D3DDDICAPS_DDRAW:
97 Assert(pData->DataSize >= sizeof (DDRAW_CAPS));
98 if (pData->DataSize >= sizeof (DDRAW_CAPS))
99 memset(pData->pData, 0, sizeof (DDRAW_CAPS));
100 else
101 hr = E_INVALIDARG;
102 break;
103 case D3DDDICAPS_DDRAW_MODE_SPECIFIC:
104 Assert(pData->DataSize >= sizeof (DDRAW_MODE_SPECIFIC_CAPS));
105 if (pData->DataSize >= sizeof (DDRAW_MODE_SPECIFIC_CAPS))
106 memset(pData->pData, 0, sizeof (DDRAW_MODE_SPECIFIC_CAPS));
107 else
108 hr = E_INVALIDARG;
109 break;
110 case D3DDDICAPS_GETFORMATCOUNT:
111 *((uint32_t*)pData->pData) = 0;
112 break;
113 case D3DDDICAPS_GETFORMATDATA:
114 /* TODO: fill the array of FORMATOP structures of size reported with D3DDDICAPS_GETFORMATCOUNT (currently 0) */
115 break;
116 case D3DDDICAPS_GETD3DQUERYCOUNT:
117 *((uint32_t*)pData->pData) = 0;
118 break;
119 case D3DDDICAPS_GETD3D3CAPS:
120 Assert(pData->DataSize >= sizeof (D3DHAL_GLOBALDRIVERDATA));
121 if (pData->DataSize >= sizeof (D3DHAL_GLOBALDRIVERDATA))
122 memset (pData->pData, 0, sizeof (D3DHAL_GLOBALDRIVERDATA));
123 else
124 hr = E_INVALIDARG;
125 break;
126 case D3DDDICAPS_GETD3D7CAPS:
127 Assert(pData->DataSize >= sizeof (D3DHAL_D3DEXTENDEDCAPS));
128 if (pData->DataSize >= sizeof (D3DHAL_D3DEXTENDEDCAPS))
129 memset(pData->pData, 0, sizeof (D3DHAL_D3DEXTENDEDCAPS));
130 else
131 hr = E_INVALIDARG;
132 break;
133 case D3DDDICAPS_GETD3D9CAPS:
134 Assert(pData->DataSize >= sizeof (D3DCAPS9));
135 if (pData->DataSize >= sizeof (D3DCAPS9))
136 memset(pData->pData, 0, sizeof (D3DCAPS9));
137 else
138 hr = E_INVALIDARG;
139 break;
140 case D3DDDICAPS_GETGAMMARAMPCAPS:
141 *((uint32_t*)pData->pData) = 0;
142 break;
143 case D3DDDICAPS_GETMULTISAMPLEQUALITYLEVELS:
144 case D3DDDICAPS_GETD3DQUERYDATA:
145 case D3DDDICAPS_GETD3D5CAPS:
146 case D3DDDICAPS_GETD3D6CAPS:
147 case D3DDDICAPS_GETD3D8CAPS:
148 case D3DDDICAPS_GETDECODEGUIDCOUNT:
149 case D3DDDICAPS_GETDECODEGUIDS:
150 case D3DDDICAPS_GETDECODERTFORMATCOUNT:
151 case D3DDDICAPS_GETDECODERTFORMATS:
152 case D3DDDICAPS_GETDECODECOMPRESSEDBUFFERINFOCOUNT:
153 case D3DDDICAPS_GETDECODECOMPRESSEDBUFFERINFO:
154 case D3DDDICAPS_GETDECODECONFIGURATIONCOUNT:
155 case D3DDDICAPS_GETDECODECONFIGURATIONS:
156 case D3DDDICAPS_GETVIDEOPROCESSORDEVICEGUIDCOUNT:
157 case D3DDDICAPS_GETVIDEOPROCESSORDEVICEGUIDS:
158 case D3DDDICAPS_GETVIDEOPROCESSORRTFORMATCOUNT:
159 case D3DDDICAPS_GETVIDEOPROCESSORRTFORMATS:
160 case D3DDDICAPS_GETVIDEOPROCESSORRTSUBSTREAMFORMATCOUNT:
161 case D3DDDICAPS_GETVIDEOPROCESSORRTSUBSTREAMFORMATS:
162 case D3DDDICAPS_GETVIDEOPROCESSORCAPS:
163 case D3DDDICAPS_GETPROCAMPRANGE:
164 case D3DDDICAPS_FILTERPROPERTYRANGE:
165 case D3DDDICAPS_GETEXTENSIONGUIDCOUNT:
166 case D3DDDICAPS_GETEXTENSIONGUIDS:
167 case D3DDDICAPS_GETEXTENSIONCAPS:
168 vboxVDbgPrint((__FUNCTION__": unimplemented caps type(%d)\n", pData->Type));
169 AssertBreakpoint();
170 if (pData->pData && pData->DataSize)
171 memset(pData->pData, 0, pData->DataSize);
172 break;
173 default:
174 vboxVDbgPrint((__FUNCTION__": unknown caps type(%d)\n", pData->Type));
175 AssertBreakpoint();
176 }
177
178 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p), caps type(%d)\n", hAdapter, pData->Type));
179
180 return S_OK;
181}
182
183static HRESULT APIENTRY vboxWddmDDevSetRenderState(HANDLE hDevice, CONST D3DDDIARG_RENDERSTATE* pData)
184{
185 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
186 AssertBreakpoint();
187 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
188 return E_FAIL;
189}
190
191static HRESULT APIENTRY vboxWddmDDevUpdateWInfo(HANDLE hDevice, CONST D3DDDIARG_WINFO* pData)
192{
193 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
194 AssertBreakpoint();
195 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
196 return E_FAIL;
197}
198
199static HRESULT APIENTRY vboxWddmDDevValidateDevice(HANDLE hDevice, D3DDDIARG_VALIDATETEXTURESTAGESTATE* pData)
200{
201 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
202 AssertBreakpoint();
203 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
204 return E_FAIL;
205}
206
207static HRESULT APIENTRY vboxWddmDDevSetTextureStageState(HANDLE hDevice, CONST D3DDDIARG_TEXTURESTAGESTATE* pData)
208{
209 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
210 AssertBreakpoint();
211 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
212 return E_FAIL;
213}
214
215static HRESULT APIENTRY vboxWddmDDevSetTexture(HANDLE hDevice, UINT Stage, HANDLE hTexture)
216{
217 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
218 AssertBreakpoint();
219 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
220 return E_FAIL;
221}
222
223static HRESULT APIENTRY vboxWddmDDevSetPixelShader(HANDLE hDevice, HANDLE hShaderHandle)
224{
225 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
226 AssertBreakpoint();
227 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
228 return E_FAIL;
229}
230
231static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONST* pData, CONST FLOAT* pRegisters)
232{
233 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
234 AssertBreakpoint();
235 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
236 return E_FAIL;
237}
238
239static HRESULT APIENTRY vboxWddmDDevSetStreamSourceUm(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEUM* pData, CONST VOID* pUMBuffer )
240{
241 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
242 AssertBreakpoint();
243 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
244 return E_FAIL;
245}
246
247static HRESULT APIENTRY vboxWddmDDevSetIndices(HANDLE hDevice, CONST D3DDDIARG_SETINDICES* pData)
248{
249 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
250 AssertBreakpoint();
251 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
252 return E_FAIL;
253}
254
255static HRESULT APIENTRY vboxWddmDDevSetIndicesUm(HANDLE hDevice, UINT IndexSize, CONST VOID* pUMBuffer)
256{
257 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
258 AssertBreakpoint();
259 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
260 return E_FAIL;
261}
262
263static HRESULT APIENTRY vboxWddmDDevDrawPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE* pData, CONST UINT* pFlagBuffer)
264{
265 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
266 AssertBreakpoint();
267 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
268 return E_FAIL;
269}
270
271static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE* pData)
272{
273 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
274 AssertBreakpoint();
275 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
276 return E_FAIL;
277}
278
279static HRESULT APIENTRY vboxWddmDDevDrawRectPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWRECTPATCH* pData, CONST D3DDDIRECTPATCH_INFO* pInfo, CONST FLOAT* pPatch)
280{
281 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
282 AssertBreakpoint();
283 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
284 return E_FAIL;
285}
286
287static HRESULT APIENTRY vboxWddmDDevDrawTriPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWTRIPATCH* pData, CONST D3DDDITRIPATCH_INFO* pInfo, CONST FLOAT* pPatch)
288{
289 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
290 AssertBreakpoint();
291 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
292 return E_FAIL;
293}
294
295static HRESULT APIENTRY vboxWddmDDevDrawPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE2* pData)
296{
297 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
298 AssertBreakpoint();
299 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
300 return E_FAIL;
301}
302
303static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE2* pData, UINT dwIndicesSize, CONST VOID* pIndexBuffer, CONST UINT* pFlagBuffer)
304{
305 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
306 AssertBreakpoint();
307 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
308 return E_FAIL;
309}
310
311static HRESULT APIENTRY vboxWddmDDevVolBlt(HANDLE hDevice, CONST D3DDDIARG_VOLUMEBLT* pData)
312{
313 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
314 AssertBreakpoint();
315 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
316 return E_FAIL;
317}
318
319static HRESULT APIENTRY vboxWddmDDevBufBlt(HANDLE hDevice, CONST D3DDDIARG_BUFFERBLT* pData)
320{
321 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
322 AssertBreakpoint();
323 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
324 return E_FAIL;
325}
326
327static HRESULT APIENTRY vboxWddmDDevTexBlt(HANDLE hDevice, CONST D3DDDIARG_TEXBLT* pData)
328{
329 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
330 AssertBreakpoint();
331 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
332 return E_FAIL;
333}
334
335static HRESULT APIENTRY vboxWddmDDevStateSet(HANDLE hDevice, D3DDDIARG_STATESET* pData)
336{
337 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
338 AssertBreakpoint();
339 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
340 return E_FAIL;
341}
342static HRESULT APIENTRY vboxWddmDDevSetPriority(HANDLE hDevice, CONST D3DDDIARG_SETPRIORITY* pData)
343{
344 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
345 AssertBreakpoint();
346 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
347 return E_FAIL;
348}
349static HRESULT APIENTRY vboxWddmDDevClear(HANDLE hDevice, CONST D3DDDIARG_CLEAR* pData, UINT NumRect, CONST RECT* pRect)
350{
351 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
352 AssertBreakpoint();
353 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
354 return E_FAIL;
355}
356static HRESULT APIENTRY vboxWddmDDevUpdatePalette(HANDLE hDevice, CONST D3DDDIARG_UPDATEPALETTE* pData, CONST PALETTEENTRY* pPaletteData)
357{
358 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
359 AssertBreakpoint();
360 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
361 return E_FAIL;
362}
363
364static HRESULT APIENTRY vboxWddmDDevSetPalette(HANDLE hDevice, CONST D3DDDIARG_SETPALETTE* pData)
365{
366 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
367 AssertBreakpoint();
368 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
369 return E_FAIL;
370}
371
372static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONST* pData , CONST VOID* pRegisters)
373{
374 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
375 AssertBreakpoint();
376 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
377 return E_FAIL;
378}
379static HRESULT APIENTRY vboxWddmDDevMultiplyTransform(HANDLE hDevice, CONST D3DDDIARG_MULTIPLYTRANSFORM* pData)
380{
381 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
382 AssertBreakpoint();
383 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
384 return E_FAIL;
385}
386static HRESULT APIENTRY vboxWddmDDevSetTransform(HANDLE hDevice, CONST D3DDDIARG_SETTRANSFORM* pData)
387{
388 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
389 AssertBreakpoint();
390 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
391 return E_FAIL;
392}
393static HRESULT APIENTRY vboxWddmDDevSetViewport(HANDLE hDevice, CONST D3DDDIARG_VIEWPORTINFO* pData)
394{
395 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
396 AssertBreakpoint();
397 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
398 return E_FAIL;
399}
400static HRESULT APIENTRY vboxWddmDDevSetZRange(HANDLE hDevice, CONST D3DDDIARG_ZRANGE* pData)
401{
402 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
403 AssertBreakpoint();
404 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
405 return E_FAIL;
406}
407static HRESULT APIENTRY vboxWddmDDevSetMaterial(HANDLE hDevice, CONST D3DDDIARG_SETMATERIAL* pData)
408{
409 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
410 AssertBreakpoint();
411 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
412 return E_FAIL;
413}
414static HRESULT APIENTRY vboxWddmDDevSetLight(HANDLE hDevice, CONST D3DDDIARG_SETLIGHT* pData, CONST D3DDDI_LIGHT* pLightProperties)
415{
416 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
417 AssertBreakpoint();
418 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
419 return E_FAIL;
420}
421static HRESULT APIENTRY vboxWddmDDevCreateLight(HANDLE hDevice, CONST D3DDDIARG_CREATELIGHT* pData)
422{
423 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
424 AssertBreakpoint();
425 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
426 return E_FAIL;
427}
428static HRESULT APIENTRY vboxWddmDDevDestroyLight(HANDLE hDevice, CONST D3DDDIARG_DESTROYLIGHT* pData)
429{
430 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
431 AssertBreakpoint();
432 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
433 return E_FAIL;
434}
435static HRESULT APIENTRY vboxWddmDDevSetClipPlane(HANDLE hDevice, CONST D3DDDIARG_SETCLIPPLANE* pData)
436{
437 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
438 AssertBreakpoint();
439 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
440 return E_FAIL;
441}
442
443static HRESULT APIENTRY vboxWddmDDevGetInfo(HANDLE hDevice, UINT DevInfoID, VOID* pDevInfoStruct, UINT DevInfoSize)
444{
445 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
446 AssertBreakpoint();
447 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
448 return E_NOTIMPL;
449}
450
451static HRESULT APIENTRY vboxWddmDDevLock(HANDLE hDevice, D3DDDIARG_LOCK* pData)
452{
453 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
454 AssertBreakpoint();
455 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
456 return E_FAIL;
457}
458static HRESULT APIENTRY vboxWddmDDevUnlock(HANDLE hDevice, CONST D3DDDIARG_UNLOCK* pData)
459{
460 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
461 AssertBreakpoint();
462 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
463 return E_FAIL;
464}
465static HRESULT APIENTRY vboxWddmDDevLockAsync(HANDLE hDevice, D3DDDIARG_LOCKASYNC* pData)
466{
467 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
468 AssertBreakpoint();
469 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
470 return E_FAIL;
471}
472static HRESULT APIENTRY vboxWddmDDevUnlockAsync(HANDLE hDevice, CONST D3DDDIARG_UNLOCKASYNC* pData)
473{
474 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
475 AssertBreakpoint();
476 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
477 return E_FAIL;
478}
479static HRESULT APIENTRY vboxWddmDDevRename(HANDLE hDevice, CONST D3DDDIARG_RENAME* pData)
480{
481 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
482 AssertBreakpoint();
483 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
484 return E_FAIL;
485}
486static HRESULT APIENTRY vboxWddmDDevCreateResource(HANDLE hDevice, D3DDDIARG_CREATERESOURCE* pResource)
487{
488 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
489 AssertBreakpoint();
490 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
491 return E_FAIL;
492}
493static HRESULT APIENTRY vboxWddmDDevDestroyResource(HANDLE hDevice, HANDLE hResource)
494{
495 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
496 AssertBreakpoint();
497 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
498 return E_FAIL;
499}
500static HRESULT APIENTRY vboxWddmDDevSetDisplayMode(HANDLE hDevice, CONST D3DDDIARG_SETDISPLAYMODE* pData)
501{
502 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
503 AssertBreakpoint();
504 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
505 return E_FAIL;
506}
507static HRESULT APIENTRY vboxWddmDDevPresent(HANDLE hDevice, CONST D3DDDIARG_PRESENT* pData)
508{
509 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
510 AssertBreakpoint();
511 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
512 return E_FAIL;
513}
514static HRESULT APIENTRY vboxWddmDDevFlush(HANDLE hDevice)
515{
516 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
517 AssertBreakpoint();
518 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
519 return E_FAIL;
520}
521static HRESULT APIENTRY vboxWddmDDevCreateVertexShaderDecl(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERDECL* pData, CONST D3DDDIVERTEXELEMENT* pVertexElements)
522{
523 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
524 AssertBreakpoint();
525 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
526 return E_FAIL;
527}
528static HRESULT APIENTRY vboxWddmDDevSetVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
529{
530 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
531 AssertBreakpoint();
532 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
533 return E_FAIL;
534}
535static HRESULT APIENTRY vboxWddmDDevDeleteVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
536{
537 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
538 AssertBreakpoint();
539 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
540 return E_FAIL;
541}
542static HRESULT APIENTRY vboxWddmDDevCreateVertexShaderFunc(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERFUNC* pData, CONST UINT* pCode)
543{
544 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
545 AssertBreakpoint();
546 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
547 return E_FAIL;
548}
549static HRESULT APIENTRY vboxWddmDDevSetVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
550{
551 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
552 AssertBreakpoint();
553 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
554 return E_FAIL;
555}
556static HRESULT APIENTRY vboxWddmDDevDeleteVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
557{
558 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
559 AssertBreakpoint();
560 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
561 return E_FAIL;
562}
563static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTI* pData, CONST INT* pRegisters)
564{
565 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
566 AssertBreakpoint();
567 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
568 return E_FAIL;
569}
570static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTB* pData, CONST BOOL* pRegisters)
571{
572 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
573 AssertBreakpoint();
574 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
575 return E_FAIL;
576}
577static HRESULT APIENTRY vboxWddmDDevSetScissorRect(HANDLE hDevice, CONST RECT* pRect)
578{
579 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
580 AssertBreakpoint();
581 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
582 return E_FAIL;
583}
584static HRESULT APIENTRY vboxWddmDDevSetStreamSource(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCE* pData)
585{
586 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
587 AssertBreakpoint();
588 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
589 return E_FAIL;
590}
591static HRESULT APIENTRY vboxWddmDDevSetStreamSourceFreq(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEFREQ* pData)
592{
593 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
594 AssertBreakpoint();
595 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
596 return E_FAIL;
597}
598static HRESULT APIENTRY vboxWddmDDevSetConvolutionKernelMono(HANDLE hDevice, CONST D3DDDIARG_SETCONVOLUTIONKERNELMONO* pData)
599{
600 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
601 AssertBreakpoint();
602 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
603 return E_FAIL;
604}
605static HRESULT APIENTRY vboxWddmDDevComposeRects(HANDLE hDevice, CONST D3DDDIARG_COMPOSERECTS* pData)
606{
607 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
608 AssertBreakpoint();
609 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
610 return E_FAIL;
611}
612static HRESULT APIENTRY vboxWddmDDevBlt(HANDLE hDevice, CONST D3DDDIARG_BLT* pData)
613{
614 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
615 AssertBreakpoint();
616 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
617 return E_FAIL;
618}
619static HRESULT APIENTRY vboxWddmDDevColorFill(HANDLE hDevice, CONST D3DDDIARG_COLORFILL* pData)
620{
621 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
622 AssertBreakpoint();
623 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
624 return E_FAIL;
625}
626static HRESULT APIENTRY vboxWddmDDevDepthFill(HANDLE hDevice, CONST D3DDDIARG_DEPTHFILL* pData)
627{
628 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
629 AssertBreakpoint();
630 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
631 return E_FAIL;
632}
633static HRESULT APIENTRY vboxWddmDDevCreateQuery(HANDLE hDevice, D3DDDIARG_CREATEQUERY* pData)
634{
635 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
636 AssertBreakpoint();
637 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
638 return E_FAIL;
639}
640static HRESULT APIENTRY vboxWddmDDevDestroyQuery(HANDLE hDevice, HANDLE hQuery)
641{
642 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
643 AssertBreakpoint();
644 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
645 return E_FAIL;
646}
647static HRESULT APIENTRY vboxWddmDDevIssueQuery(HANDLE hDevice, CONST D3DDDIARG_ISSUEQUERY* pData)
648{
649 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
650 AssertBreakpoint();
651 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
652 return E_FAIL;
653}
654static HRESULT APIENTRY vboxWddmDDevGetQueryData(HANDLE hDevice, CONST D3DDDIARG_GETQUERYDATA* pData)
655{
656 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
657 AssertBreakpoint();
658 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
659 return E_FAIL;
660}
661static HRESULT APIENTRY vboxWddmDDevSetRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETRENDERTARGET* pData)
662{
663 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
664 AssertBreakpoint();
665 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
666 return E_FAIL;
667}
668static HRESULT APIENTRY vboxWddmDDevSetDepthStencil(HANDLE hDevice, CONST D3DDDIARG_SETDEPTHSTENCIL* pData)
669{
670 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
671 AssertBreakpoint();
672 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
673 return E_FAIL;
674}
675static HRESULT APIENTRY vboxWddmDDevGenerateMipSubLevels(HANDLE hDevice, CONST D3DDDIARG_GENERATEMIPSUBLEVELS* pData)
676{
677 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
678 AssertBreakpoint();
679 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
680 return E_FAIL;
681}
682static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTI* pData, CONST INT* pRegisters)
683{
684 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
685 AssertBreakpoint();
686 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
687 return E_FAIL;
688}
689static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTB* pData, CONST BOOL* pRegisters)
690{
691 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
692 AssertBreakpoint();
693 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
694 return E_FAIL;
695}
696static HRESULT APIENTRY vboxWddmDDevCreatePixelShader(HANDLE hDevice, D3DDDIARG_CREATEPIXELSHADER* pData, CONST UINT* pCode)
697{
698 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
699 AssertBreakpoint();
700 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
701 return E_FAIL;
702}
703static HRESULT APIENTRY vboxWddmDDevDeletePixelShader(HANDLE hDevice, HANDLE hShaderHandle)
704{
705 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
706 AssertBreakpoint();
707 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
708 return E_FAIL;
709}
710static HRESULT APIENTRY vboxWddmDDevCreateDecodeDevice(HANDLE hDevice, D3DDDIARG_CREATEDECODEDEVICE* pData)
711{
712 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
713 AssertBreakpoint();
714 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
715 return E_FAIL;
716}
717static HRESULT APIENTRY vboxWddmDDevDestroyDecodeDevice(HANDLE hDevice, HANDLE hDecodeDevice)
718{
719 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
720 AssertBreakpoint();
721 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
722 return E_FAIL;
723}
724static HRESULT APIENTRY vboxWddmDDevSetDecodeRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETDECODERENDERTARGET* pData)
725{
726 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
727 AssertBreakpoint();
728 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
729 return E_FAIL;
730}
731static HRESULT APIENTRY vboxWddmDDevDecodeBeginFrame(HANDLE hDevice, D3DDDIARG_DECODEBEGINFRAME* pData)
732{
733 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
734 AssertBreakpoint();
735 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
736 return E_FAIL;
737}
738static HRESULT APIENTRY vboxWddmDDevDecodeEndFrame(HANDLE hDevice, D3DDDIARG_DECODEENDFRAME* pData)
739{
740 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
741 AssertBreakpoint();
742 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
743 return E_FAIL;
744}
745static HRESULT APIENTRY vboxWddmDDevDecodeExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXECUTE* pData)
746{
747 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
748 AssertBreakpoint();
749 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
750 return E_FAIL;
751}
752static HRESULT APIENTRY vboxWddmDDevDecodeExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXTENSIONEXECUTE* pData)
753{
754 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
755 AssertBreakpoint();
756 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
757 return E_FAIL;
758}
759static HRESULT APIENTRY vboxWddmDDevCreateVideoProcessDevice(HANDLE hDevice, D3DDDIARG_CREATEVIDEOPROCESSDEVICE* pData)
760{
761 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
762 AssertBreakpoint();
763 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
764 return E_FAIL;
765}
766static HRESULT APIENTRY vboxWddmDDevDestroyVideoProcessDevice(HANDLE hDevice, HANDLE hVideoProcessor)
767{
768 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
769 AssertBreakpoint();
770 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
771 return E_FAIL;
772}
773static HRESULT APIENTRY vboxWddmDDevVideoProcessBeginFrame(HANDLE hDevice, HANDLE hVideoProcess)
774{
775 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
776 AssertBreakpoint();
777 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
778 return E_FAIL;
779}
780static HRESULT APIENTRY vboxWddmDDevVideoProcessEndFrame(HANDLE hDevice, D3DDDIARG_VIDEOPROCESSENDFRAME* pData)
781{
782 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
783 AssertBreakpoint();
784 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
785 return E_FAIL;
786}
787static HRESULT APIENTRY vboxWddmDDevSetVideoProcessRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETVIDEOPROCESSRENDERTARGET* pData)
788{
789 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
790 AssertBreakpoint();
791 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
792 return E_FAIL;
793}
794static HRESULT APIENTRY vboxWddmDDevVideoProcessBlt(HANDLE hDevice, CONST D3DDDIARG_VIDEOPROCESSBLT* pData)
795{
796 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
797 AssertBreakpoint();
798 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
799 return E_FAIL;
800}
801static HRESULT APIENTRY vboxWddmDDevCreateExtensionDevice(HANDLE hDevice, D3DDDIARG_CREATEEXTENSIONDEVICE* pData)
802{
803 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
804 AssertBreakpoint();
805 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
806 return E_FAIL;
807}
808static HRESULT APIENTRY vboxWddmDDevDestroyExtensionDevice(HANDLE hDevice, HANDLE hExtension)
809{
810 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
811 AssertBreakpoint();
812 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
813 return E_FAIL;
814}
815static HRESULT APIENTRY vboxWddmDDevExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_EXTENSIONEXECUTE* pData)
816{
817 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
818 AssertBreakpoint();
819 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
820 return E_FAIL;
821}
822static HRESULT APIENTRY vboxWddmDDevDestroyDevice(IN HANDLE hDevice)
823{
824 RTMemFree(hDevice);
825 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
826 AssertBreakpoint();
827 RTMemFree(hDevice);
828 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
829 return S_OK;
830}
831static HRESULT APIENTRY vboxWddmDDevCreateOverlay(HANDLE hDevice, D3DDDIARG_CREATEOVERLAY* pData)
832{
833 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
834 AssertBreakpoint();
835 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
836 return E_FAIL;
837}
838static HRESULT APIENTRY vboxWddmDDevUpdateOverlay(HANDLE hDevice, CONST D3DDDIARG_UPDATEOVERLAY* pData)
839{
840 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
841 AssertBreakpoint();
842 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
843 return E_FAIL;
844}
845static HRESULT APIENTRY vboxWddmDDevFlipOverlay(HANDLE hDevice, CONST D3DDDIARG_FLIPOVERLAY* pData)
846{
847 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
848 AssertBreakpoint();
849 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
850 return E_FAIL;
851}
852static HRESULT APIENTRY vboxWddmDDevGetOverlayColorControls(HANDLE hDevice, D3DDDIARG_GETOVERLAYCOLORCONTROLS* pData)
853{
854 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
855 AssertBreakpoint();
856 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
857 return E_FAIL;
858}
859static HRESULT APIENTRY vboxWddmDDevSetOverlayColorControls(HANDLE hDevice, CONST D3DDDIARG_SETOVERLAYCOLORCONTROLS* pData)
860{
861 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
862 AssertBreakpoint();
863 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
864 return E_FAIL;
865}
866static HRESULT APIENTRY vboxWddmDDevDestroyOverlay(HANDLE hDevice, CONST D3DDDIARG_DESTROYOVERLAY* pData)
867{
868 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
869 AssertBreakpoint();
870 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
871 return E_FAIL;
872}
873static HRESULT APIENTRY vboxWddmDDevQueryResourceResidency(HANDLE hDevice, CONST D3DDDIARG_QUERYRESOURCERESIDENCY* pData)
874{
875 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
876 AssertBreakpoint();
877 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
878 return E_FAIL;
879}
880static HRESULT APIENTRY vboxWddmDDevOpenResource(HANDLE hDevice, D3DDDIARG_OPENRESOURCE* pData)
881{
882 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
883 AssertBreakpoint();
884 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
885 return E_FAIL;
886}
887static HRESULT APIENTRY vboxWddmDDevGetCaptureAllocationHandle(HANDLE hDevice, D3DDDIARG_GETCAPTUREALLOCATIONHANDLE* pData)
888{
889 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
890 AssertBreakpoint();
891 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
892 return E_FAIL;
893}
894
895static HRESULT APIENTRY vboxWddmDDevCaptureToSysMem(HANDLE hDevice, CONST D3DDDIARG_CAPTURETOSYSMEM* pData)
896{
897 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
898 AssertBreakpoint();
899 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
900 return E_FAIL;
901}
902
903static HRESULT APIENTRY vboxWddmDispCreateDevice (IN HANDLE hAdapter, IN D3DDDIARG_CREATEDEVICE* pCreateData)
904{
905 vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
906
907 AssertBreakpoint();
908
909 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)RTMemAllocZ(sizeof (VBOXWDDMDISP_DEVICE));
910 if (!pDevice)
911 {
912 vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
913 return E_OUTOFMEMORY;
914 }
915
916 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
917
918 pDevice->hDevice = pCreateData->hDevice;
919 pDevice->pAdapter = pAdapter;
920 pDevice->u32IfVersion = pCreateData->Interface;
921 pDevice->uRtVersion = pCreateData->Version;
922 pDevice->RtCallbacks = *pCreateData->pCallbacks;
923 pDevice->pvCmdBuffer = pCreateData->pCommandBuffer;
924 pDevice->cbCmdBuffer = pCreateData->CommandBufferSize;
925 pDevice->fFlags = pCreateData->Flags;
926 Assert(!pCreateData->AllocationListSize);
927 if (pCreateData->AllocationListSize)
928 {
929 vboxVDbgPrintR((__FUNCTION__": Not implemented: AllocationListSize(%d)\n", pCreateData->AllocationListSize));
930 //pCreateData->pAllocationList = ??
931 return E_FAIL;
932 }
933
934 Assert(!pCreateData->PatchLocationListSize);
935 if (pCreateData->PatchLocationListSize)
936 {
937 vboxVDbgPrintR((__FUNCTION__": Not implemented: PatchLocationListSize(%d)\n", pCreateData->PatchLocationListSize));
938 //pCreateData->pPatchLocationList = ??
939 return E_FAIL;
940 }
941
942 pCreateData->pDeviceFuncs->pfnSetRenderState = vboxWddmDDevSetRenderState;
943 pCreateData->pDeviceFuncs->pfnUpdateWInfo = vboxWddmDDevUpdateWInfo;
944 pCreateData->pDeviceFuncs->pfnValidateDevice = vboxWddmDDevValidateDevice;
945 pCreateData->pDeviceFuncs->pfnSetTextureStageState = vboxWddmDDevSetTextureStageState;
946 pCreateData->pDeviceFuncs->pfnSetTexture = vboxWddmDDevSetTexture;
947 pCreateData->pDeviceFuncs->pfnSetPixelShader = vboxWddmDDevSetPixelShader;
948 pCreateData->pDeviceFuncs->pfnSetPixelShaderConst = vboxWddmDDevSetPixelShaderConst;
949 pCreateData->pDeviceFuncs->pfnSetStreamSourceUm = vboxWddmDDevSetStreamSourceUm;
950 pCreateData->pDeviceFuncs->pfnSetIndices = vboxWddmDDevSetIndices;
951 pCreateData->pDeviceFuncs->pfnSetIndicesUm = vboxWddmDDevSetIndicesUm;
952 pCreateData->pDeviceFuncs->pfnDrawPrimitive = vboxWddmDDevDrawPrimitive;
953 pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive = vboxWddmDDevDrawIndexedPrimitive;
954 pCreateData->pDeviceFuncs->pfnDrawRectPatch = vboxWddmDDevDrawRectPatch;
955 pCreateData->pDeviceFuncs->pfnDrawTriPatch = vboxWddmDDevDrawTriPatch;
956 pCreateData->pDeviceFuncs->pfnDrawPrimitive2 = vboxWddmDDevDrawPrimitive2;
957 pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive2 = vboxWddmDDevDrawIndexedPrimitive2;
958 pCreateData->pDeviceFuncs->pfnVolBlt = vboxWddmDDevVolBlt;
959 pCreateData->pDeviceFuncs->pfnBufBlt = vboxWddmDDevBufBlt;
960 pCreateData->pDeviceFuncs->pfnTexBlt = vboxWddmDDevTexBlt;
961 pCreateData->pDeviceFuncs->pfnStateSet = vboxWddmDDevStateSet;
962 pCreateData->pDeviceFuncs->pfnSetPriority = vboxWddmDDevSetPriority;
963 pCreateData->pDeviceFuncs->pfnClear = vboxWddmDDevClear;
964 pCreateData->pDeviceFuncs->pfnUpdatePalette = vboxWddmDDevUpdatePalette;
965 pCreateData->pDeviceFuncs->pfnSetPalette = vboxWddmDDevSetPalette;
966 pCreateData->pDeviceFuncs->pfnSetVertexShaderConst = vboxWddmDDevSetVertexShaderConst;
967 pCreateData->pDeviceFuncs->pfnMultiplyTransform = vboxWddmDDevMultiplyTransform;
968 pCreateData->pDeviceFuncs->pfnSetTransform = vboxWddmDDevSetTransform;
969 pCreateData->pDeviceFuncs->pfnSetViewport = vboxWddmDDevSetViewport;
970 pCreateData->pDeviceFuncs->pfnSetZRange = vboxWddmDDevSetZRange;
971 pCreateData->pDeviceFuncs->pfnSetMaterial = vboxWddmDDevSetMaterial;
972 pCreateData->pDeviceFuncs->pfnSetLight = vboxWddmDDevSetLight;
973 pCreateData->pDeviceFuncs->pfnCreateLight = vboxWddmDDevCreateLight;
974 pCreateData->pDeviceFuncs->pfnDestroyLight = vboxWddmDDevDestroyLight;
975 pCreateData->pDeviceFuncs->pfnSetClipPlane = vboxWddmDDevSetClipPlane;
976 pCreateData->pDeviceFuncs->pfnGetInfo = vboxWddmDDevGetInfo;
977 pCreateData->pDeviceFuncs->pfnLock = vboxWddmDDevLock;
978 pCreateData->pDeviceFuncs->pfnUnlock = vboxWddmDDevUnlock;
979 pCreateData->pDeviceFuncs->pfnCreateResource = vboxWddmDDevCreateResource;
980 pCreateData->pDeviceFuncs->pfnDestroyResource = vboxWddmDDevDestroyResource;
981 pCreateData->pDeviceFuncs->pfnSetDisplayMode = vboxWddmDDevSetDisplayMode;
982 pCreateData->pDeviceFuncs->pfnPresent = vboxWddmDDevPresent;
983 pCreateData->pDeviceFuncs->pfnFlush = vboxWddmDDevFlush;
984 pCreateData->pDeviceFuncs->pfnCreateVertexShaderFunc = vboxWddmDDevCreateVertexShaderFunc;
985 pCreateData->pDeviceFuncs->pfnDeleteVertexShaderFunc = vboxWddmDDevDeleteVertexShaderFunc;
986 pCreateData->pDeviceFuncs->pfnSetVertexShaderFunc = vboxWddmDDevSetVertexShaderFunc;
987 pCreateData->pDeviceFuncs->pfnCreateVertexShaderDecl = vboxWddmDDevCreateVertexShaderDecl;
988 pCreateData->pDeviceFuncs->pfnDeleteVertexShaderDecl = vboxWddmDDevDeleteVertexShaderDecl;
989 pCreateData->pDeviceFuncs->pfnSetVertexShaderDecl = vboxWddmDDevSetVertexShaderDecl;
990 pCreateData->pDeviceFuncs->pfnSetVertexShaderConstI = vboxWddmDDevSetVertexShaderConstI;
991 pCreateData->pDeviceFuncs->pfnSetVertexShaderConstB = vboxWddmDDevSetVertexShaderConstB;
992 pCreateData->pDeviceFuncs->pfnSetScissorRect = vboxWddmDDevSetScissorRect;
993 pCreateData->pDeviceFuncs->pfnSetStreamSource = vboxWddmDDevSetStreamSource;
994 pCreateData->pDeviceFuncs->pfnSetStreamSourceFreq = vboxWddmDDevSetStreamSourceFreq;
995 pCreateData->pDeviceFuncs->pfnSetConvolutionKernelMono = vboxWddmDDevSetConvolutionKernelMono;
996 pCreateData->pDeviceFuncs->pfnComposeRects = vboxWddmDDevComposeRects;
997 pCreateData->pDeviceFuncs->pfnBlt = vboxWddmDDevBlt;
998 pCreateData->pDeviceFuncs->pfnColorFill = vboxWddmDDevColorFill;
999 pCreateData->pDeviceFuncs->pfnDepthFill = vboxWddmDDevDepthFill;
1000 pCreateData->pDeviceFuncs->pfnCreateQuery = vboxWddmDDevCreateQuery;
1001 pCreateData->pDeviceFuncs->pfnDestroyQuery = vboxWddmDDevDestroyQuery;
1002 pCreateData->pDeviceFuncs->pfnIssueQuery = vboxWddmDDevIssueQuery;
1003 pCreateData->pDeviceFuncs->pfnGetQueryData = vboxWddmDDevGetQueryData;
1004 pCreateData->pDeviceFuncs->pfnSetRenderTarget = vboxWddmDDevSetRenderTarget;
1005 pCreateData->pDeviceFuncs->pfnSetDepthStencil = vboxWddmDDevSetDepthStencil;
1006 pCreateData->pDeviceFuncs->pfnGenerateMipSubLevels = vboxWddmDDevGenerateMipSubLevels;
1007 pCreateData->pDeviceFuncs->pfnSetPixelShaderConstI = vboxWddmDDevSetPixelShaderConstI;
1008 pCreateData->pDeviceFuncs->pfnSetPixelShaderConstB = vboxWddmDDevSetPixelShaderConstB;
1009 pCreateData->pDeviceFuncs->pfnCreatePixelShader = vboxWddmDDevCreatePixelShader;
1010 pCreateData->pDeviceFuncs->pfnDeletePixelShader = vboxWddmDDevDeletePixelShader;
1011 pCreateData->pDeviceFuncs->pfnCreateDecodeDevice = vboxWddmDDevCreateDecodeDevice;
1012 pCreateData->pDeviceFuncs->pfnDestroyDecodeDevice = vboxWddmDDevDestroyDecodeDevice;
1013 pCreateData->pDeviceFuncs->pfnSetDecodeRenderTarget = vboxWddmDDevSetDecodeRenderTarget;
1014 pCreateData->pDeviceFuncs->pfnDecodeBeginFrame = vboxWddmDDevDecodeBeginFrame;
1015 pCreateData->pDeviceFuncs->pfnDecodeEndFrame = vboxWddmDDevDecodeEndFrame;
1016 pCreateData->pDeviceFuncs->pfnDecodeExecute = vboxWddmDDevDecodeExecute;
1017 pCreateData->pDeviceFuncs->pfnDecodeExtensionExecute = vboxWddmDDevDecodeExtensionExecute;
1018 pCreateData->pDeviceFuncs->pfnCreateVideoProcessDevice = vboxWddmDDevCreateVideoProcessDevice;
1019 pCreateData->pDeviceFuncs->pfnDestroyVideoProcessDevice = vboxWddmDDevDestroyVideoProcessDevice;
1020 pCreateData->pDeviceFuncs->pfnVideoProcessBeginFrame = vboxWddmDDevVideoProcessBeginFrame;
1021 pCreateData->pDeviceFuncs->pfnVideoProcessEndFrame = vboxWddmDDevVideoProcessEndFrame;
1022 pCreateData->pDeviceFuncs->pfnSetVideoProcessRenderTarget = vboxWddmDDevSetVideoProcessRenderTarget;
1023 pCreateData->pDeviceFuncs->pfnVideoProcessBlt = vboxWddmDDevVideoProcessBlt;
1024 pCreateData->pDeviceFuncs->pfnCreateExtensionDevice = vboxWddmDDevCreateExtensionDevice;
1025 pCreateData->pDeviceFuncs->pfnDestroyExtensionDevice = vboxWddmDDevDestroyExtensionDevice;
1026 pCreateData->pDeviceFuncs->pfnExtensionExecute = vboxWddmDDevExtensionExecute;
1027 pCreateData->pDeviceFuncs->pfnCreateOverlay = vboxWddmDDevCreateOverlay;
1028 pCreateData->pDeviceFuncs->pfnUpdateOverlay = vboxWddmDDevUpdateOverlay;
1029 pCreateData->pDeviceFuncs->pfnFlipOverlay = vboxWddmDDevFlipOverlay;
1030 pCreateData->pDeviceFuncs->pfnGetOverlayColorControls = vboxWddmDDevGetOverlayColorControls;
1031 pCreateData->pDeviceFuncs->pfnSetOverlayColorControls = vboxWddmDDevSetOverlayColorControls;
1032 pCreateData->pDeviceFuncs->pfnDestroyOverlay = vboxWddmDDevDestroyOverlay;
1033 pCreateData->pDeviceFuncs->pfnDestroyDevice = vboxWddmDDevDestroyDevice;
1034 pCreateData->pDeviceFuncs->pfnQueryResourceResidency = vboxWddmDDevQueryResourceResidency;
1035 pCreateData->pDeviceFuncs->pfnOpenResource = vboxWddmDDevOpenResource;
1036 pCreateData->pDeviceFuncs->pfnGetCaptureAllocationHandle = vboxWddmDDevGetCaptureAllocationHandle;
1037 pCreateData->pDeviceFuncs->pfnCaptureToSysMem = vboxWddmDDevCaptureToSysMem;
1038 pCreateData->pDeviceFuncs->pfnLockAsync = NULL; //vboxWddmDDevLockAsync;
1039 pCreateData->pDeviceFuncs->pfnUnlockAsync = NULL; //vboxWddmDDevUnlockAsync;
1040 pCreateData->pDeviceFuncs->pfnRename = NULL; //vboxWddmDDevRename;
1041
1042 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
1043
1044 return E_FAIL;
1045}
1046
1047static HRESULT APIENTRY vboxWddmDispCloseAdapter (IN HANDLE hAdapter)
1048{
1049 vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
1050
1051 AssertBreakpoint();
1052
1053 RTMemFree(hAdapter);
1054
1055 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
1056
1057 return S_OK;
1058}
1059
1060HRESULT APIENTRY OpenAdapter (__inout D3DDDIARG_OPENADAPTER* pOpenData)
1061{
1062 vboxVDbgPrint(("==> "__FUNCTION__"\n"));
1063
1064 AssertBreakpoint();
1065
1066 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(sizeof (VBOXWDDMDISP_ADAPTER));
1067 Assert(pAdapter);
1068 if (!pAdapter)
1069 {
1070 vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
1071 return E_OUTOFMEMORY;
1072 }
1073
1074 pAdapter->hAdapter = pOpenData->hAdapter;
1075 pAdapter->uIfVersion = pOpenData->Interface;
1076 pAdapter->uRtVersion= pOpenData->Version;
1077 pAdapter->RtCallbacks = *pOpenData->pAdapterCallbacks;
1078
1079 pOpenData->hAdapter = pAdapter;
1080 pOpenData->pAdapterFuncs->pfnGetCaps = vboxWddmDispGetCaps;
1081 pOpenData->pAdapterFuncs->pfnCreateDevice = vboxWddmDispCreateDevice;
1082 pOpenData->pAdapterFuncs->pfnCloseAdapter = vboxWddmDispCloseAdapter;
1083 pOpenData->DriverVersion = D3D_UMD_INTERFACE_VERSION;
1084
1085 vboxVDbgPrint(("<== "__FUNCTION__", pAdapter(0x%p)\n", pAdapter));
1086
1087 return S_OK;
1088}
1089
1090#ifdef VBOXWDDMDISP_DEBUG
1091VOID vboxVDbgDoPrint(LPCSTR szString, ...)
1092{
1093 char szBuffer[1024] = {0};
1094 va_list pArgList;
1095 va_start(pArgList, szString);
1096 _vsnprintf(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]), szString, pArgList);
1097 va_end(pArgList);
1098
1099 OutputDebugStringA(szBuffer);
1100}
1101#endif
Note: See TracBrowser for help on using the repository browser.

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