VirtualBox

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

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

wddm: unload VBoxD3D9.dll if 3D is unavailable
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 61.7 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 <windows.h>
16#include <d3d9types.h>
17//#include <d3dtypes.h>
18#include <D3dumddi.h>
19#include <d3dhal.h>
20
21
22#include <iprt/initterm.h>
23#include <iprt/log.h>
24#include <iprt/mem.h>
25
26#include <VBox/Log.h>
27
28#include <VBox/VBoxGuestLib.h>
29
30#include "VBoxDispD3D.h"
31#include "VBoxDispD3DCmn.h"
32
33#ifdef VBOXWDDMDISP_DEBUG
34# include <stdio.h>
35#endif
36
37static FORMATOP gVBoxFormatOps3D[] = {
38 {D3DDDIFMT_A8R8G8B8,
39 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
40 FORMATOP_SAME_FORMAT_RENDERTARGET|
41 FORMATOP_SAME_FORMAT_UP_TO_ALPHA_RENDERTARGET|
42 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
43 FORMATOP_MEMBEROFGROUP_ARGB|
44 FORMATOP_SRGBWRITE|FORMATOP_VERTEXTEXTURE, 0, 0, 0},
45
46 {D3DDDIFMT_X8R8G8B8,
47 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
48 FORMATOP_SAME_FORMAT_RENDERTARGET|
49 FORMATOP_DISPLAYMODE|FORMATOP_3DACCELERATION|
50 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
51 FORMATOP_MEMBEROFGROUP_ARGB|
52 FORMATOP_SRGBWRITE|FORMATOP_VERTEXTEXTURE, 0, 0, 0},
53
54 {D3DDDIFMT_A2R10G10B10,
55 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
56 FORMATOP_SAME_FORMAT_RENDERTARGET|
57 0|
58 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|
59 FORMATOP_MEMBEROFGROUP_ARGB|
60 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
61
62 {D3DDDIFMT_X1R5G5B5,
63 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
64 FORMATOP_SAME_FORMAT_RENDERTARGET|
65 0|
66 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|
67 FORMATOP_MEMBEROFGROUP_ARGB|
68 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
69
70 {D3DDDIFMT_A1R5G5B5,
71 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
72 FORMATOP_SAME_FORMAT_RENDERTARGET|
73 FORMATOP_SAME_FORMAT_UP_TO_ALPHA_RENDERTARGET|
74 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|
75 FORMATOP_MEMBEROFGROUP_ARGB|
76 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
77
78 {D3DDDIFMT_A4R4G4B4,
79 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
80 FORMATOP_SAME_FORMAT_RENDERTARGET|
81 FORMATOP_SAME_FORMAT_UP_TO_ALPHA_RENDERTARGET|
82 FORMATOP_OFFSCREENPLAIN|
83 0|
84 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
85
86 {D3DDDIFMT_R5G6B5,
87 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
88 FORMATOP_SAME_FORMAT_RENDERTARGET|
89 FORMATOP_DISPLAYMODE|FORMATOP_3DACCELERATION|
90 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|
91 FORMATOP_MEMBEROFGROUP_ARGB|
92 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
93
94 {D3DDDIFMT_L16,
95 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
96 0|
97 0|
98 FORMATOP_OFFSCREENPLAIN|
99 0|
100 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
101
102 {D3DDDIFMT_A8L8,
103 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
104 0|
105 0|
106 FORMATOP_OFFSCREENPLAIN|
107 0|
108 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
109
110 {D3DDDIFMT_A8,
111 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
112 0|
113 0|
114 FORMATOP_OFFSCREENPLAIN|
115 0|
116 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
117
118 {D3DDDIFMT_L8,
119 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
120 0|
121 0|
122 FORMATOP_OFFSCREENPLAIN|
123 0|
124 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
125
126 {D3DDDIFMT_D16, FORMATOP_TEXTURE|FORMATOP_ZSTENCIL|FORMATOP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH, 0, 0, 0},
127 {D3DDDIFMT_D24S8, FORMATOP_TEXTURE|FORMATOP_ZSTENCIL|FORMATOP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH, 0, 0, 0},
128 {D3DDDIFMT_D24X8, FORMATOP_TEXTURE|FORMATOP_ZSTENCIL|FORMATOP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH, 0, 0, 0},
129
130 {D3DDDIFMT_DXT1,
131 FORMATOP_TEXTURE|FORMATOP_CUBETEXTURE|
132 0|
133 0|
134 FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
135 0|
136 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
137
138 {D3DDDIFMT_DXT2,
139 FORMATOP_TEXTURE|FORMATOP_CUBETEXTURE|
140 0|
141 0|
142 FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
143 0|
144 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
145
146 {D3DDDIFMT_DXT3,
147 FORMATOP_TEXTURE|FORMATOP_CUBETEXTURE|
148 0|
149 0|
150 FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
151 0|
152 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
153
154 {D3DDDIFMT_DXT4,
155 FORMATOP_TEXTURE|FORMATOP_CUBETEXTURE|
156 0|
157 0|
158 FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
159 0|
160 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
161
162 {D3DDDIFMT_DXT5,
163 FORMATOP_TEXTURE|FORMATOP_CUBETEXTURE|
164 0|
165 0|
166 FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
167 0|
168 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
169
170 {D3DDDIFMT_X8L8V8U8,
171 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
172 0|
173 0|
174 0|
175 FORMATOP_BUMPMAP|
176 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
177
178 {D3DDDIFMT_A2W10V10U10,
179 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
180 0|
181 0|
182 0|
183 FORMATOP_BUMPMAP|
184 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
185
186 {D3DDDIFMT_V8U8,
187 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
188 0|
189 0|
190 0|
191 FORMATOP_BUMPMAP|
192 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
193
194 {D3DDDIFMT_Q8W8V8U8,
195 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
196 0|
197 0|
198 FORMATOP_OFFSCREENPLAIN|
199 FORMATOP_BUMPMAP|
200 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
201
202 {D3DDDIFMT_CxV8U8, FORMATOP_NOFILTER|FORMATOP_NOALPHABLEND|FORMATOP_NOTEXCOORDWRAPNORMIP, 0, 0, 0},
203
204 {D3DDDIFMT_R16F,
205 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
206 FORMATOP_SAME_FORMAT_RENDERTARGET|
207 0|
208 FORMATOP_OFFSCREENPLAIN|
209 0|
210 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
211
212 {D3DDDIFMT_R32F,
213 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
214 FORMATOP_SAME_FORMAT_RENDERTARGET|
215 0|
216 FORMATOP_OFFSCREENPLAIN|
217 0|
218 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
219
220 {D3DDDIFMT_G16R16F,
221 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
222 FORMATOP_SAME_FORMAT_RENDERTARGET|
223 0|
224 FORMATOP_OFFSCREENPLAIN|
225 0|
226 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
227
228 {D3DDDIFMT_G32R32F,
229 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
230 FORMATOP_SAME_FORMAT_RENDERTARGET|
231 0|
232 FORMATOP_OFFSCREENPLAIN|
233 0|
234 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
235
236 {D3DDDIFMT_A16B16G16R16F,
237 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
238 FORMATOP_SAME_FORMAT_RENDERTARGET|
239 0|
240 FORMATOP_OFFSCREENPLAIN|
241 0|
242 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
243
244 {D3DDDIFMT_A32B32G32R32F,
245 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
246 FORMATOP_SAME_FORMAT_RENDERTARGET|
247 0|
248 FORMATOP_OFFSCREENPLAIN|
249 0|
250 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
251
252 {D3DDDIFMT_G16R16,
253 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
254 FORMATOP_SAME_FORMAT_RENDERTARGET|
255 0|
256 FORMATOP_OFFSCREENPLAIN|
257 0|
258 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
259
260 {D3DDDIFMT_A16B16G16R16,
261 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
262 FORMATOP_SAME_FORMAT_RENDERTARGET|
263 0|
264 FORMATOP_OFFSCREENPLAIN|
265 0|
266 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
267
268 {D3DDDIFMT_V16U16,
269 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
270 0|
271 0|
272 0|
273 FORMATOP_BUMPMAP|
274 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
275
276 {D3DDDIFMT_P8, FORMATOP_DISPLAYMODE|FORMATOP_3DACCELERATION|FORMATOP_OFFSCREENPLAIN, 0, 0, 0},
277
278 {D3DDDIFMT_UYVY,
279 0|
280 0|
281 0|
282 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|
283 FORMATOP_NOFILTER|
284 FORMATOP_NOALPHABLEND|
285 FORMATOP_NOTEXCOORDWRAPNORMIP, 0, 0, 0},
286
287 {D3DDDIFMT_YUY2,
288 0|
289 0|
290 0|
291 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|
292 FORMATOP_NOFILTER|
293 FORMATOP_NOALPHABLEND|
294 FORMATOP_NOTEXCOORDWRAPNORMIP, 0, 0, 0},
295};
296
297static FORMATOP gVBoxFormatOpsBase[] = {
298 {D3DDDIFMT_X8R8G8B8, FORMATOP_DISPLAYMODE, 0, 0, 0},
299
300 {D3DDDIFMT_R8G8B8, FORMATOP_DISPLAYMODE, 0, 0, 0},
301
302 {D3DDDIFMT_R5G6B5, FORMATOP_DISPLAYMODE, 0, 0, 0},
303
304 {D3DDDIFMT_P8, FORMATOP_DISPLAYMODE, 0, 0, 0},
305};
306
307static FORMATOP gVBoxFormatOps[RT_ELEMENTS(gVBoxFormatOpsBase) /* some base formats we report ?? */
308 + RT_ELEMENTS(gVBoxFormatOps3D)
309#ifdef VBOX_WITH_VIDEOHWACCEL
310 + VBOXVHWA_MAX_FORMATS
311#endif
312 ];
313static uint32_t gcVBoxFormatOps;
314#define VBOX_FORMATOP_COUNT() (gcVBoxFormatOps)
315
316#ifdef VBOX_WITH_VIDEOHWACCEL
317
318static bool vboxVhwaIsEnabled(PVBOXWDDMDISP_ADAPTER pAdapter)
319{
320 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
321 {
322 if (pAdapter->aHeads[i].Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED)
323 return true;
324 }
325 return false;
326}
327
328static bool vboxVhwaHasCKeying(PVBOXWDDMDISP_ADAPTER pAdapter)
329{
330 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
331 {
332 VBOXVHWA_INFO* pSettings = &pAdapter->aHeads[i].Vhwa.Settings;
333 if ((pSettings->fFlags & VBOXVHWA_F_ENABLED)
334 && ((pSettings->fFlags & VBOXVHWA_F_CKEY_DST)
335 || (pSettings->fFlags & VBOXVHWA_F_CKEY_SRC))
336 )
337 return true;
338 }
339 return false;
340}
341
342#endif
343
344int vboxFormatOpsMerge(FORMATOP *paOps, uint32_t *pcOps, uint32_t cMaxOps, FORMATOP *pOp)
345{
346 uint32_t cOps = *pcOps;
347
348 Assert(cMaxOps >= cOps);
349
350 for (uint32_t i = 0; i < cOps; ++i)
351 {
352 FORMATOP *pCur = &paOps[i];
353 if (pCur->Format == pOp->Format)
354 {
355 pCur->Operations |= pOp->Operations;
356 Assert(pCur->FlipMsTypes == pOp->FlipMsTypes);
357 Assert(pCur->BltMsTypes == pOp->BltMsTypes);
358 Assert(pCur->PrivateFormatBitCount == pOp->PrivateFormatBitCount);
359 return VINF_SUCCESS;
360 }
361 }
362
363 if (cMaxOps > cOps)
364 {
365 paOps[cOps] = *pOp;
366 ++cOps;
367 *pcOps = cOps;
368 return VINF_SUCCESS;
369 }
370 return VERR_BUFFER_OVERFLOW;
371}
372
373void vboxFormatOpsInit(PVBOXWDDMDISP_ADAPTER pAdapter)
374{
375 gcVBoxFormatOps = 0;
376 if (pAdapter->pD3D9If)
377 {
378 memcpy (gVBoxFormatOps, gVBoxFormatOps3D, sizeof (gVBoxFormatOps3D));
379 gcVBoxFormatOps = RT_ELEMENTS(gVBoxFormatOps3D);
380 }
381
382 if (gcVBoxFormatOps)
383 {
384 for (uint32_t i = 0; i < RT_ELEMENTS(gVBoxFormatOpsBase); ++i)
385 {
386 int rc = vboxFormatOpsMerge(gVBoxFormatOps, &gcVBoxFormatOps, RT_ELEMENTS(gVBoxFormatOps), &gVBoxFormatOpsBase[i]);
387 AssertRC(rc);
388 }
389 }
390 else
391 {
392 memcpy (gVBoxFormatOps, gVBoxFormatOpsBase, sizeof (gVBoxFormatOpsBase));
393 gcVBoxFormatOps = RT_ELEMENTS(gVBoxFormatOpsBase);
394 }
395
396#ifdef VBOX_WITH_VIDEOHWACCEL
397 FORMATOP fo = {D3DDDIFMT_UNKNOWN, 0, 0, 0, 0};
398 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
399 {
400 VBOXDISPVHWA_INFO *pVhwa = &pAdapter->aHeads[i].Vhwa;
401 if (pVhwa->Settings.fFlags & VBOXVHWA_F_ENABLED)
402 {
403 for (uint32_t j = 0; j < pVhwa->Settings.cFormats; ++j)
404 {
405 fo.Format = pVhwa->Settings.aFormats[j];
406 fo.Operations = FORMATOP_OVERLAY;
407 int rc = vboxFormatOpsMerge(gVBoxFormatOps, &gcVBoxFormatOps, RT_ELEMENTS(gVBoxFormatOps), &fo);
408 AssertRC(rc);
409 }
410 }
411 }
412#endif
413}
414
415
416/**
417 * DLL entry point.
418 */
419BOOL WINAPI DllMain(HINSTANCE hInstance,
420 DWORD dwReason,
421 LPVOID lpReserved)
422{
423 switch (dwReason)
424 {
425 case DLL_PROCESS_ATTACH:
426 {
427 RTR3Init();
428
429 vboxVDbgPrint(("VBoxDispD3D: DLL loaded.\n"));
430
431// VbglR3Init();
432 break;
433 }
434
435 case DLL_PROCESS_DETACH:
436 {
437 vboxVDbgPrint(("VBoxDispD3D: DLL unloaded.\n"));
438// VbglR3Term();
439 /// @todo RTR3Term();
440 break;
441 }
442
443 default:
444 break;
445 }
446 return TRUE;
447}
448
449static HRESULT APIENTRY vboxWddmDispGetCaps (HANDLE hAdapter, CONST D3DDDIARG_GETCAPS* pData)
450{
451 vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p), caps type(%d)\n", hAdapter, pData->Type));
452
453 HRESULT hr = S_OK;
454 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
455
456 switch (pData->Type)
457 {
458 case D3DDDICAPS_DDRAW:
459 {
460 AssertBreakpoint();
461 Assert(pData->DataSize >= sizeof (DDRAW_CAPS));
462 if (pData->DataSize >= sizeof (DDRAW_CAPS))
463 {
464 memset(pData->pData, 0, sizeof (DDRAW_CAPS));
465#ifdef VBOX_WITH_VIDEOHWACCEL
466 if (vboxVhwaHasCKeying(pAdapter))
467 {
468 DDRAW_CAPS *pCaps = (DDRAW_CAPS*)pData->pData;
469 pCaps->Caps |= DDRAW_CAPS_COLORKEY;
470 }
471#endif
472 }
473 else
474 hr = E_INVALIDARG;
475 break;
476 }
477 case D3DDDICAPS_DDRAW_MODE_SPECIFIC:
478 {
479 AssertBreakpoint();
480 Assert(pData->DataSize >= sizeof (DDRAW_MODE_SPECIFIC_CAPS));
481 if (pData->DataSize >= sizeof (DDRAW_MODE_SPECIFIC_CAPS))
482 {
483 DDRAW_MODE_SPECIFIC_CAPS * pCaps = (DDRAW_MODE_SPECIFIC_CAPS*)pData->pData;
484 memset(&pCaps->Caps /* do not cleanup the first "Head" field,
485 zero starting with the one following "Head", i.e. Caps */,
486 0, sizeof (DDRAW_MODE_SPECIFIC_CAPS) - RT_OFFSETOF(DDRAW_MODE_SPECIFIC_CAPS, Caps));
487#ifdef VBOX_WITH_VIDEOHWACCEL
488 VBOXVHWA_INFO *pSettings = &pAdapter->aHeads[pCaps->Head].Vhwa.Settings;
489 if (pSettings->fFlags & VBOXVHWA_F_ENABLED)
490 {
491 pCaps->Caps |= MODE_CAPS_OVERLAY | MODE_CAPS_OVERLAYSTRETCH;
492
493 if (pSettings->fFlags & VBOXVHWA_F_CKEY_DST)
494 {
495 pCaps->CKeyCaps |= MODE_CKEYCAPS_DESTOVERLAY
496 | MODE_CKEYCAPS_DESTOVERLAYYUV /* ?? */
497 ;
498 }
499
500 if (pSettings->fFlags & VBOXVHWA_F_CKEY_SRC)
501 {
502 pCaps->CKeyCaps |= MODE_CKEYCAPS_SRCOVERLAY
503 | MODE_CKEYCAPS_SRCOVERLAYCLRSPACE /* ?? */
504 | MODE_CKEYCAPS_SRCOVERLAYCLRSPACEYUV /* ?? */
505 | MODE_CKEYCAPS_SRCOVERLAYYUV /* ?? */
506 ;
507 }
508
509 pCaps->FxCaps = MODE_FXCAPS_OVERLAYSHRINKX
510 | MODE_FXCAPS_OVERLAYSHRINKY
511 | MODE_FXCAPS_OVERLAYSTRETCHX
512 | MODE_FXCAPS_OVERLAYSTRETCHY;
513
514
515 pCaps->MaxVisibleOverlays = pSettings->cOverlaysSupported;
516 pCaps->MinOverlayStretch = 1;
517 pCaps->MaxOverlayStretch = 32000;
518 }
519#endif
520 }
521 else
522 hr = E_INVALIDARG;
523 break;
524 }
525 case D3DDDICAPS_GETFORMATCOUNT:
526 *((uint32_t*)pData->pData) = VBOX_FORMATOP_COUNT();
527 break;
528 case D3DDDICAPS_GETFORMATDATA:
529 Assert(pData->DataSize >= VBOX_FORMATOP_COUNT() * sizeof(FORMATOP));
530 memcpy(pData->pData, gVBoxFormatOps, VBOX_FORMATOP_COUNT()*sizeof(FORMATOP));
531 break;
532 case D3DDDICAPS_GETD3DQUERYCOUNT:
533 *((uint32_t*)pData->pData) = 0;
534 break;
535 case D3DDDICAPS_GETD3D3CAPS:
536 Assert(pData->DataSize >= sizeof (D3DHAL_GLOBALDRIVERDATA));
537 if (pData->DataSize >= sizeof (D3DHAL_GLOBALDRIVERDATA))
538 memset (pData->pData, 0, sizeof (D3DHAL_GLOBALDRIVERDATA));
539 else
540 hr = E_INVALIDARG;
541 break;
542 case D3DDDICAPS_GETD3D7CAPS:
543 Assert(pData->DataSize >= sizeof (D3DHAL_D3DEXTENDEDCAPS));
544 if (pData->DataSize >= sizeof (D3DHAL_D3DEXTENDEDCAPS))
545 memset(pData->pData, 0, sizeof (D3DHAL_D3DEXTENDEDCAPS));
546 else
547 hr = E_INVALIDARG;
548 break;
549 case D3DDDICAPS_GETD3D9CAPS:
550 {
551 Assert(pData->DataSize >= sizeof (D3DCAPS9));
552 if (pData->DataSize >= sizeof (D3DCAPS9))
553 {
554 if (pAdapter->pD3D9If)
555 {
556 hr = pAdapter->pD3D9If->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, (D3DCAPS9*)pData->pData);
557 Assert(hr == S_OK);
558 if (hr == S_OK)
559 break;
560
561 vboxVDbgPrintR((__FUNCTION__": GetDeviceCaps hr(%d)\n", hr));
562 /* let's fall back to the 3D disabled case */
563 hr = S_OK;
564 }
565
566 memset(pData->pData, 0, sizeof (D3DCAPS9));
567 }
568 else
569 hr = E_INVALIDARG;
570 break;
571 }
572 case D3DDDICAPS_GETGAMMARAMPCAPS:
573 *((uint32_t*)pData->pData) = 0;
574 break;
575 case D3DDDICAPS_GETMULTISAMPLEQUALITYLEVELS:
576 case D3DDDICAPS_GETD3DQUERYDATA:
577 case D3DDDICAPS_GETD3D5CAPS:
578 case D3DDDICAPS_GETD3D6CAPS:
579 case D3DDDICAPS_GETD3D8CAPS:
580 case D3DDDICAPS_GETDECODEGUIDCOUNT:
581 case D3DDDICAPS_GETDECODEGUIDS:
582 case D3DDDICAPS_GETDECODERTFORMATCOUNT:
583 case D3DDDICAPS_GETDECODERTFORMATS:
584 case D3DDDICAPS_GETDECODECOMPRESSEDBUFFERINFOCOUNT:
585 case D3DDDICAPS_GETDECODECOMPRESSEDBUFFERINFO:
586 case D3DDDICAPS_GETDECODECONFIGURATIONCOUNT:
587 case D3DDDICAPS_GETDECODECONFIGURATIONS:
588 case D3DDDICAPS_GETVIDEOPROCESSORDEVICEGUIDCOUNT:
589 case D3DDDICAPS_GETVIDEOPROCESSORDEVICEGUIDS:
590 case D3DDDICAPS_GETVIDEOPROCESSORRTFORMATCOUNT:
591 case D3DDDICAPS_GETVIDEOPROCESSORRTFORMATS:
592 case D3DDDICAPS_GETVIDEOPROCESSORRTSUBSTREAMFORMATCOUNT:
593 case D3DDDICAPS_GETVIDEOPROCESSORRTSUBSTREAMFORMATS:
594 case D3DDDICAPS_GETVIDEOPROCESSORCAPS:
595 case D3DDDICAPS_GETPROCAMPRANGE:
596 case D3DDDICAPS_FILTERPROPERTYRANGE:
597 case D3DDDICAPS_GETEXTENSIONGUIDCOUNT:
598 case D3DDDICAPS_GETEXTENSIONGUIDS:
599 case D3DDDICAPS_GETEXTENSIONCAPS:
600 vboxVDbgPrint((__FUNCTION__": unimplemented caps type(%d)\n", pData->Type));
601 AssertBreakpoint();
602 if (pData->pData && pData->DataSize)
603 memset(pData->pData, 0, pData->DataSize);
604 break;
605 default:
606 vboxVDbgPrint((__FUNCTION__": unknown caps type(%d)\n", pData->Type));
607 AssertBreakpoint();
608 }
609
610 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p), caps type(%d)\n", hAdapter, pData->Type));
611
612 return S_OK;
613}
614
615static HRESULT APIENTRY vboxWddmDDevSetRenderState(HANDLE hDevice, CONST D3DDDIARG_RENDERSTATE* pData)
616{
617 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
618 AssertBreakpoint();
619 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
620 return E_FAIL;
621}
622
623static HRESULT APIENTRY vboxWddmDDevUpdateWInfo(HANDLE hDevice, CONST D3DDDIARG_WINFO* pData)
624{
625 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
626 AssertBreakpoint();
627 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
628 return E_FAIL;
629}
630
631static HRESULT APIENTRY vboxWddmDDevValidateDevice(HANDLE hDevice, D3DDDIARG_VALIDATETEXTURESTAGESTATE* pData)
632{
633 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
634 AssertBreakpoint();
635 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
636 return E_FAIL;
637}
638
639static HRESULT APIENTRY vboxWddmDDevSetTextureStageState(HANDLE hDevice, CONST D3DDDIARG_TEXTURESTAGESTATE* pData)
640{
641 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
642 AssertBreakpoint();
643 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
644 return E_FAIL;
645}
646
647static HRESULT APIENTRY vboxWddmDDevSetTexture(HANDLE hDevice, UINT Stage, HANDLE hTexture)
648{
649 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
650 AssertBreakpoint();
651 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
652 return E_FAIL;
653}
654
655static HRESULT APIENTRY vboxWddmDDevSetPixelShader(HANDLE hDevice, HANDLE hShaderHandle)
656{
657 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
658 AssertBreakpoint();
659 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
660 return E_FAIL;
661}
662
663static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONST* pData, CONST FLOAT* pRegisters)
664{
665 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
666 AssertBreakpoint();
667 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
668 return E_FAIL;
669}
670
671static HRESULT APIENTRY vboxWddmDDevSetStreamSourceUm(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEUM* pData, CONST VOID* pUMBuffer )
672{
673 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
674 AssertBreakpoint();
675 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
676 return E_FAIL;
677}
678
679static HRESULT APIENTRY vboxWddmDDevSetIndices(HANDLE hDevice, CONST D3DDDIARG_SETINDICES* pData)
680{
681 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
682 AssertBreakpoint();
683 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
684 return E_FAIL;
685}
686
687static HRESULT APIENTRY vboxWddmDDevSetIndicesUm(HANDLE hDevice, UINT IndexSize, CONST VOID* pUMBuffer)
688{
689 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
690 AssertBreakpoint();
691 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
692 return E_FAIL;
693}
694
695static HRESULT APIENTRY vboxWddmDDevDrawPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE* pData, CONST UINT* pFlagBuffer)
696{
697 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
698 AssertBreakpoint();
699 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
700 return E_FAIL;
701}
702
703static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE* pData)
704{
705 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
706 AssertBreakpoint();
707 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
708 return E_FAIL;
709}
710
711static HRESULT APIENTRY vboxWddmDDevDrawRectPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWRECTPATCH* pData, CONST D3DDDIRECTPATCH_INFO* pInfo, CONST FLOAT* pPatch)
712{
713 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
714 AssertBreakpoint();
715 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
716 return E_FAIL;
717}
718
719static HRESULT APIENTRY vboxWddmDDevDrawTriPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWTRIPATCH* pData, CONST D3DDDITRIPATCH_INFO* pInfo, CONST FLOAT* pPatch)
720{
721 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
722 AssertBreakpoint();
723 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
724 return E_FAIL;
725}
726
727static HRESULT APIENTRY vboxWddmDDevDrawPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE2* pData)
728{
729 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
730 AssertBreakpoint();
731 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
732 return E_FAIL;
733}
734
735static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE2* pData, UINT dwIndicesSize, CONST VOID* pIndexBuffer, CONST UINT* pFlagBuffer)
736{
737 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
738 AssertBreakpoint();
739 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
740 return E_FAIL;
741}
742
743static HRESULT APIENTRY vboxWddmDDevVolBlt(HANDLE hDevice, CONST D3DDDIARG_VOLUMEBLT* pData)
744{
745 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
746 AssertBreakpoint();
747 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
748 return E_FAIL;
749}
750
751static HRESULT APIENTRY vboxWddmDDevBufBlt(HANDLE hDevice, CONST D3DDDIARG_BUFFERBLT* pData)
752{
753 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
754 AssertBreakpoint();
755 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
756 return E_FAIL;
757}
758
759static HRESULT APIENTRY vboxWddmDDevTexBlt(HANDLE hDevice, CONST D3DDDIARG_TEXBLT* 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}
766
767static HRESULT APIENTRY vboxWddmDDevStateSet(HANDLE hDevice, D3DDDIARG_STATESET* pData)
768{
769 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
770 AssertBreakpoint();
771 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
772 return E_FAIL;
773}
774static HRESULT APIENTRY vboxWddmDDevSetPriority(HANDLE hDevice, CONST D3DDDIARG_SETPRIORITY* pData)
775{
776 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
777 AssertBreakpoint();
778 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
779 return E_FAIL;
780}
781static HRESULT APIENTRY vboxWddmDDevClear(HANDLE hDevice, CONST D3DDDIARG_CLEAR* pData, UINT NumRect, CONST RECT* pRect)
782{
783 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
784 AssertBreakpoint();
785 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
786 return E_FAIL;
787}
788static HRESULT APIENTRY vboxWddmDDevUpdatePalette(HANDLE hDevice, CONST D3DDDIARG_UPDATEPALETTE* pData, CONST PALETTEENTRY* pPaletteData)
789{
790 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
791 AssertBreakpoint();
792 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
793 return E_FAIL;
794}
795
796static HRESULT APIENTRY vboxWddmDDevSetPalette(HANDLE hDevice, CONST D3DDDIARG_SETPALETTE* pData)
797{
798 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
799 AssertBreakpoint();
800 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
801 return E_FAIL;
802}
803
804static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONST* pData , CONST VOID* pRegisters)
805{
806 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
807 AssertBreakpoint();
808 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
809 return E_FAIL;
810}
811static HRESULT APIENTRY vboxWddmDDevMultiplyTransform(HANDLE hDevice, CONST D3DDDIARG_MULTIPLYTRANSFORM* pData)
812{
813 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
814 AssertBreakpoint();
815 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
816 return E_FAIL;
817}
818static HRESULT APIENTRY vboxWddmDDevSetTransform(HANDLE hDevice, CONST D3DDDIARG_SETTRANSFORM* pData)
819{
820 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
821 AssertBreakpoint();
822 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
823 return E_FAIL;
824}
825static HRESULT APIENTRY vboxWddmDDevSetViewport(HANDLE hDevice, CONST D3DDDIARG_VIEWPORTINFO* pData)
826{
827 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
828 AssertBreakpoint();
829 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
830 return E_FAIL;
831}
832static HRESULT APIENTRY vboxWddmDDevSetZRange(HANDLE hDevice, CONST D3DDDIARG_ZRANGE* pData)
833{
834 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
835 AssertBreakpoint();
836 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
837 return E_FAIL;
838}
839static HRESULT APIENTRY vboxWddmDDevSetMaterial(HANDLE hDevice, CONST D3DDDIARG_SETMATERIAL* pData)
840{
841 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
842 AssertBreakpoint();
843 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
844 return E_FAIL;
845}
846static HRESULT APIENTRY vboxWddmDDevSetLight(HANDLE hDevice, CONST D3DDDIARG_SETLIGHT* pData, CONST D3DDDI_LIGHT* pLightProperties)
847{
848 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
849 AssertBreakpoint();
850 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
851 return E_FAIL;
852}
853static HRESULT APIENTRY vboxWddmDDevCreateLight(HANDLE hDevice, CONST D3DDDIARG_CREATELIGHT* pData)
854{
855 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
856 AssertBreakpoint();
857 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
858 return E_FAIL;
859}
860static HRESULT APIENTRY vboxWddmDDevDestroyLight(HANDLE hDevice, CONST D3DDDIARG_DESTROYLIGHT* pData)
861{
862 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
863 AssertBreakpoint();
864 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
865 return E_FAIL;
866}
867static HRESULT APIENTRY vboxWddmDDevSetClipPlane(HANDLE hDevice, CONST D3DDDIARG_SETCLIPPLANE* pData)
868{
869 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
870 AssertBreakpoint();
871 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
872 return E_FAIL;
873}
874
875static HRESULT APIENTRY vboxWddmDDevGetInfo(HANDLE hDevice, UINT DevInfoID, VOID* pDevInfoStruct, UINT DevInfoSize)
876{
877 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
878 AssertBreakpoint();
879 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
880 return E_NOTIMPL;
881}
882
883static HRESULT APIENTRY vboxWddmDDevLock(HANDLE hDevice, D3DDDIARG_LOCK* pData)
884{
885 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
886 AssertBreakpoint();
887 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
888 return E_FAIL;
889}
890static HRESULT APIENTRY vboxWddmDDevUnlock(HANDLE hDevice, CONST D3DDDIARG_UNLOCK* pData)
891{
892 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
893 AssertBreakpoint();
894 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
895 return E_FAIL;
896}
897static HRESULT APIENTRY vboxWddmDDevLockAsync(HANDLE hDevice, D3DDDIARG_LOCKASYNC* pData)
898{
899 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
900 AssertBreakpoint();
901 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
902 return E_FAIL;
903}
904static HRESULT APIENTRY vboxWddmDDevUnlockAsync(HANDLE hDevice, CONST D3DDDIARG_UNLOCKASYNC* pData)
905{
906 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
907 AssertBreakpoint();
908 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
909 return E_FAIL;
910}
911static HRESULT APIENTRY vboxWddmDDevRename(HANDLE hDevice, CONST D3DDDIARG_RENAME* pData)
912{
913 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
914 AssertBreakpoint();
915 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
916 return E_FAIL;
917}
918static HRESULT APIENTRY vboxWddmDDevCreateResource(HANDLE hDevice, D3DDDIARG_CREATERESOURCE* pResource)
919{
920 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
921 AssertBreakpoint();
922 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
923 return E_FAIL;
924}
925static HRESULT APIENTRY vboxWddmDDevDestroyResource(HANDLE hDevice, HANDLE hResource)
926{
927 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
928 AssertBreakpoint();
929 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
930 return E_FAIL;
931}
932static HRESULT APIENTRY vboxWddmDDevSetDisplayMode(HANDLE hDevice, CONST D3DDDIARG_SETDISPLAYMODE* pData)
933{
934 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
935 AssertBreakpoint();
936 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
937 return E_FAIL;
938}
939static HRESULT APIENTRY vboxWddmDDevPresent(HANDLE hDevice, CONST D3DDDIARG_PRESENT* pData)
940{
941 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
942 AssertBreakpoint();
943 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
944 return E_FAIL;
945}
946static HRESULT APIENTRY vboxWddmDDevFlush(HANDLE hDevice)
947{
948 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
949 AssertBreakpoint();
950 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
951 return E_FAIL;
952}
953static HRESULT APIENTRY vboxWddmDDevCreateVertexShaderDecl(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERDECL* pData, CONST D3DDDIVERTEXELEMENT* pVertexElements)
954{
955 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
956 AssertBreakpoint();
957 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
958 return E_FAIL;
959}
960static HRESULT APIENTRY vboxWddmDDevSetVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
961{
962 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
963 AssertBreakpoint();
964 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
965 return E_FAIL;
966}
967static HRESULT APIENTRY vboxWddmDDevDeleteVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
968{
969 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
970 AssertBreakpoint();
971 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
972 return E_FAIL;
973}
974static HRESULT APIENTRY vboxWddmDDevCreateVertexShaderFunc(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERFUNC* pData, CONST UINT* pCode)
975{
976 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
977 AssertBreakpoint();
978 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
979 return E_FAIL;
980}
981static HRESULT APIENTRY vboxWddmDDevSetVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
982{
983 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
984 AssertBreakpoint();
985 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
986 return E_FAIL;
987}
988static HRESULT APIENTRY vboxWddmDDevDeleteVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
989{
990 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
991 AssertBreakpoint();
992 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
993 return E_FAIL;
994}
995static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTI* pData, CONST INT* pRegisters)
996{
997 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
998 AssertBreakpoint();
999 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1000 return E_FAIL;
1001}
1002static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTB* pData, CONST BOOL* pRegisters)
1003{
1004 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1005 AssertBreakpoint();
1006 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1007 return E_FAIL;
1008}
1009static HRESULT APIENTRY vboxWddmDDevSetScissorRect(HANDLE hDevice, CONST RECT* pRect)
1010{
1011 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1012 AssertBreakpoint();
1013 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1014 return E_FAIL;
1015}
1016static HRESULT APIENTRY vboxWddmDDevSetStreamSource(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCE* pData)
1017{
1018 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1019 AssertBreakpoint();
1020 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1021 return E_FAIL;
1022}
1023static HRESULT APIENTRY vboxWddmDDevSetStreamSourceFreq(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEFREQ* pData)
1024{
1025 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1026 AssertBreakpoint();
1027 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1028 return E_FAIL;
1029}
1030static HRESULT APIENTRY vboxWddmDDevSetConvolutionKernelMono(HANDLE hDevice, CONST D3DDDIARG_SETCONVOLUTIONKERNELMONO* pData)
1031{
1032 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1033 AssertBreakpoint();
1034 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1035 return E_FAIL;
1036}
1037static HRESULT APIENTRY vboxWddmDDevComposeRects(HANDLE hDevice, CONST D3DDDIARG_COMPOSERECTS* pData)
1038{
1039 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1040 AssertBreakpoint();
1041 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1042 return E_FAIL;
1043}
1044static HRESULT APIENTRY vboxWddmDDevBlt(HANDLE hDevice, CONST D3DDDIARG_BLT* pData)
1045{
1046 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1047 AssertBreakpoint();
1048 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1049 return E_FAIL;
1050}
1051static HRESULT APIENTRY vboxWddmDDevColorFill(HANDLE hDevice, CONST D3DDDIARG_COLORFILL* pData)
1052{
1053 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1054 AssertBreakpoint();
1055 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1056 return E_FAIL;
1057}
1058static HRESULT APIENTRY vboxWddmDDevDepthFill(HANDLE hDevice, CONST D3DDDIARG_DEPTHFILL* pData)
1059{
1060 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1061 AssertBreakpoint();
1062 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1063 return E_FAIL;
1064}
1065static HRESULT APIENTRY vboxWddmDDevCreateQuery(HANDLE hDevice, D3DDDIARG_CREATEQUERY* pData)
1066{
1067 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1068 AssertBreakpoint();
1069 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1070 return E_FAIL;
1071}
1072static HRESULT APIENTRY vboxWddmDDevDestroyQuery(HANDLE hDevice, HANDLE hQuery)
1073{
1074 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1075 AssertBreakpoint();
1076 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1077 return E_FAIL;
1078}
1079static HRESULT APIENTRY vboxWddmDDevIssueQuery(HANDLE hDevice, CONST D3DDDIARG_ISSUEQUERY* pData)
1080{
1081 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1082 AssertBreakpoint();
1083 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1084 return E_FAIL;
1085}
1086static HRESULT APIENTRY vboxWddmDDevGetQueryData(HANDLE hDevice, CONST D3DDDIARG_GETQUERYDATA* pData)
1087{
1088 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1089 AssertBreakpoint();
1090 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1091 return E_FAIL;
1092}
1093static HRESULT APIENTRY vboxWddmDDevSetRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETRENDERTARGET* pData)
1094{
1095 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1096 AssertBreakpoint();
1097 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1098 return E_FAIL;
1099}
1100static HRESULT APIENTRY vboxWddmDDevSetDepthStencil(HANDLE hDevice, CONST D3DDDIARG_SETDEPTHSTENCIL* pData)
1101{
1102 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1103 AssertBreakpoint();
1104 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1105 return E_FAIL;
1106}
1107static HRESULT APIENTRY vboxWddmDDevGenerateMipSubLevels(HANDLE hDevice, CONST D3DDDIARG_GENERATEMIPSUBLEVELS* pData)
1108{
1109 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1110 AssertBreakpoint();
1111 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1112 return E_FAIL;
1113}
1114static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTI* pData, CONST INT* pRegisters)
1115{
1116 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1117 AssertBreakpoint();
1118 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1119 return E_FAIL;
1120}
1121static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTB* pData, CONST BOOL* pRegisters)
1122{
1123 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1124 AssertBreakpoint();
1125 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1126 return E_FAIL;
1127}
1128static HRESULT APIENTRY vboxWddmDDevCreatePixelShader(HANDLE hDevice, D3DDDIARG_CREATEPIXELSHADER* pData, CONST UINT* pCode)
1129{
1130 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1131 AssertBreakpoint();
1132 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1133 return E_FAIL;
1134}
1135static HRESULT APIENTRY vboxWddmDDevDeletePixelShader(HANDLE hDevice, HANDLE hShaderHandle)
1136{
1137 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1138 AssertBreakpoint();
1139 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1140 return E_FAIL;
1141}
1142static HRESULT APIENTRY vboxWddmDDevCreateDecodeDevice(HANDLE hDevice, D3DDDIARG_CREATEDECODEDEVICE* pData)
1143{
1144 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1145 AssertBreakpoint();
1146 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1147 return E_FAIL;
1148}
1149static HRESULT APIENTRY vboxWddmDDevDestroyDecodeDevice(HANDLE hDevice, HANDLE hDecodeDevice)
1150{
1151 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1152 AssertBreakpoint();
1153 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1154 return E_FAIL;
1155}
1156static HRESULT APIENTRY vboxWddmDDevSetDecodeRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETDECODERENDERTARGET* pData)
1157{
1158 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1159 AssertBreakpoint();
1160 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1161 return E_FAIL;
1162}
1163static HRESULT APIENTRY vboxWddmDDevDecodeBeginFrame(HANDLE hDevice, D3DDDIARG_DECODEBEGINFRAME* pData)
1164{
1165 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1166 AssertBreakpoint();
1167 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1168 return E_FAIL;
1169}
1170static HRESULT APIENTRY vboxWddmDDevDecodeEndFrame(HANDLE hDevice, D3DDDIARG_DECODEENDFRAME* pData)
1171{
1172 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1173 AssertBreakpoint();
1174 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1175 return E_FAIL;
1176}
1177static HRESULT APIENTRY vboxWddmDDevDecodeExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXECUTE* pData)
1178{
1179 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1180 AssertBreakpoint();
1181 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1182 return E_FAIL;
1183}
1184static HRESULT APIENTRY vboxWddmDDevDecodeExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXTENSIONEXECUTE* pData)
1185{
1186 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1187 AssertBreakpoint();
1188 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1189 return E_FAIL;
1190}
1191static HRESULT APIENTRY vboxWddmDDevCreateVideoProcessDevice(HANDLE hDevice, D3DDDIARG_CREATEVIDEOPROCESSDEVICE* pData)
1192{
1193 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1194 AssertBreakpoint();
1195 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1196 return E_FAIL;
1197}
1198static HRESULT APIENTRY vboxWddmDDevDestroyVideoProcessDevice(HANDLE hDevice, HANDLE hVideoProcessor)
1199{
1200 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1201 AssertBreakpoint();
1202 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1203 return E_FAIL;
1204}
1205static HRESULT APIENTRY vboxWddmDDevVideoProcessBeginFrame(HANDLE hDevice, HANDLE hVideoProcess)
1206{
1207 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1208 AssertBreakpoint();
1209 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1210 return E_FAIL;
1211}
1212static HRESULT APIENTRY vboxWddmDDevVideoProcessEndFrame(HANDLE hDevice, D3DDDIARG_VIDEOPROCESSENDFRAME* pData)
1213{
1214 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1215 AssertBreakpoint();
1216 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1217 return E_FAIL;
1218}
1219static HRESULT APIENTRY vboxWddmDDevSetVideoProcessRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETVIDEOPROCESSRENDERTARGET* pData)
1220{
1221 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1222 AssertBreakpoint();
1223 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1224 return E_FAIL;
1225}
1226static HRESULT APIENTRY vboxWddmDDevVideoProcessBlt(HANDLE hDevice, CONST D3DDDIARG_VIDEOPROCESSBLT* pData)
1227{
1228 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1229 AssertBreakpoint();
1230 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1231 return E_FAIL;
1232}
1233static HRESULT APIENTRY vboxWddmDDevCreateExtensionDevice(HANDLE hDevice, D3DDDIARG_CREATEEXTENSIONDEVICE* pData)
1234{
1235 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1236 AssertBreakpoint();
1237 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1238 return E_FAIL;
1239}
1240static HRESULT APIENTRY vboxWddmDDevDestroyExtensionDevice(HANDLE hDevice, HANDLE hExtension)
1241{
1242 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1243 AssertBreakpoint();
1244 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1245 return E_FAIL;
1246}
1247static HRESULT APIENTRY vboxWddmDDevExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_EXTENSIONEXECUTE* pData)
1248{
1249 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1250 AssertBreakpoint();
1251 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1252 return E_FAIL;
1253}
1254static HRESULT APIENTRY vboxWddmDDevDestroyDevice(IN HANDLE hDevice)
1255{
1256 RTMemFree(hDevice);
1257 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1258 AssertBreakpoint();
1259 RTMemFree(hDevice);
1260 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1261 return S_OK;
1262}
1263static HRESULT APIENTRY vboxWddmDDevCreateOverlay(HANDLE hDevice, D3DDDIARG_CREATEOVERLAY* pData)
1264{
1265 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1266 AssertBreakpoint();
1267 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1268 return E_FAIL;
1269}
1270static HRESULT APIENTRY vboxWddmDDevUpdateOverlay(HANDLE hDevice, CONST D3DDDIARG_UPDATEOVERLAY* pData)
1271{
1272 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1273 AssertBreakpoint();
1274 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1275 return E_FAIL;
1276}
1277static HRESULT APIENTRY vboxWddmDDevFlipOverlay(HANDLE hDevice, CONST D3DDDIARG_FLIPOVERLAY* pData)
1278{
1279 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1280 AssertBreakpoint();
1281 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1282 return E_FAIL;
1283}
1284static HRESULT APIENTRY vboxWddmDDevGetOverlayColorControls(HANDLE hDevice, D3DDDIARG_GETOVERLAYCOLORCONTROLS* pData)
1285{
1286 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1287 AssertBreakpoint();
1288 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1289 return E_FAIL;
1290}
1291static HRESULT APIENTRY vboxWddmDDevSetOverlayColorControls(HANDLE hDevice, CONST D3DDDIARG_SETOVERLAYCOLORCONTROLS* pData)
1292{
1293 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1294 AssertBreakpoint();
1295 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1296 return E_FAIL;
1297}
1298static HRESULT APIENTRY vboxWddmDDevDestroyOverlay(HANDLE hDevice, CONST D3DDDIARG_DESTROYOVERLAY* pData)
1299{
1300 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1301 AssertBreakpoint();
1302 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1303 return E_FAIL;
1304}
1305static HRESULT APIENTRY vboxWddmDDevQueryResourceResidency(HANDLE hDevice, CONST D3DDDIARG_QUERYRESOURCERESIDENCY* pData)
1306{
1307 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1308 AssertBreakpoint();
1309 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1310 return E_FAIL;
1311}
1312static HRESULT APIENTRY vboxWddmDDevOpenResource(HANDLE hDevice, D3DDDIARG_OPENRESOURCE* pData)
1313{
1314 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1315 AssertBreakpoint();
1316 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1317 return E_FAIL;
1318}
1319static HRESULT APIENTRY vboxWddmDDevGetCaptureAllocationHandle(HANDLE hDevice, D3DDDIARG_GETCAPTUREALLOCATIONHANDLE* pData)
1320{
1321 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1322 AssertBreakpoint();
1323 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1324 return E_FAIL;
1325}
1326
1327static HRESULT APIENTRY vboxWddmDDevCaptureToSysMem(HANDLE hDevice, CONST D3DDDIARG_CAPTURETOSYSMEM* pData)
1328{
1329 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1330 AssertBreakpoint();
1331 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1332 return E_FAIL;
1333}
1334
1335static HRESULT APIENTRY vboxWddmDispCreateDevice (IN HANDLE hAdapter, IN D3DDDIARG_CREATEDEVICE* pCreateData)
1336{
1337 vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
1338
1339// AssertBreakpoint();
1340
1341 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)RTMemAllocZ(sizeof (VBOXWDDMDISP_DEVICE));
1342 if (!pDevice)
1343 {
1344 vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
1345 return E_OUTOFMEMORY;
1346 }
1347
1348 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
1349
1350 pDevice->hDevice = pCreateData->hDevice;
1351 pDevice->pAdapter = pAdapter;
1352 pDevice->u32IfVersion = pCreateData->Interface;
1353 pDevice->uRtVersion = pCreateData->Version;
1354 pDevice->RtCallbacks = *pCreateData->pCallbacks;
1355 pDevice->pvCmdBuffer = pCreateData->pCommandBuffer;
1356 pDevice->cbCmdBuffer = pCreateData->CommandBufferSize;
1357 pDevice->fFlags = pCreateData->Flags;
1358 Assert(!pCreateData->AllocationListSize);
1359 if (pCreateData->AllocationListSize)
1360 {
1361 vboxVDbgPrintR((__FUNCTION__": Not implemented: AllocationListSize(%d)\n", pCreateData->AllocationListSize));
1362 //pCreateData->pAllocationList = ??
1363 return E_FAIL;
1364 }
1365
1366 Assert(!pCreateData->PatchLocationListSize);
1367 if (pCreateData->PatchLocationListSize)
1368 {
1369 vboxVDbgPrintR((__FUNCTION__": Not implemented: PatchLocationListSize(%d)\n", pCreateData->PatchLocationListSize));
1370 //pCreateData->pPatchLocationList = ??
1371 return E_FAIL;
1372 }
1373
1374 pCreateData->pDeviceFuncs->pfnSetRenderState = vboxWddmDDevSetRenderState;
1375 pCreateData->pDeviceFuncs->pfnUpdateWInfo = vboxWddmDDevUpdateWInfo;
1376 pCreateData->pDeviceFuncs->pfnValidateDevice = vboxWddmDDevValidateDevice;
1377 pCreateData->pDeviceFuncs->pfnSetTextureStageState = vboxWddmDDevSetTextureStageState;
1378 pCreateData->pDeviceFuncs->pfnSetTexture = vboxWddmDDevSetTexture;
1379 pCreateData->pDeviceFuncs->pfnSetPixelShader = vboxWddmDDevSetPixelShader;
1380 pCreateData->pDeviceFuncs->pfnSetPixelShaderConst = vboxWddmDDevSetPixelShaderConst;
1381 pCreateData->pDeviceFuncs->pfnSetStreamSourceUm = vboxWddmDDevSetStreamSourceUm;
1382 pCreateData->pDeviceFuncs->pfnSetIndices = vboxWddmDDevSetIndices;
1383 pCreateData->pDeviceFuncs->pfnSetIndicesUm = vboxWddmDDevSetIndicesUm;
1384 pCreateData->pDeviceFuncs->pfnDrawPrimitive = vboxWddmDDevDrawPrimitive;
1385 pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive = vboxWddmDDevDrawIndexedPrimitive;
1386 pCreateData->pDeviceFuncs->pfnDrawRectPatch = vboxWddmDDevDrawRectPatch;
1387 pCreateData->pDeviceFuncs->pfnDrawTriPatch = vboxWddmDDevDrawTriPatch;
1388 pCreateData->pDeviceFuncs->pfnDrawPrimitive2 = vboxWddmDDevDrawPrimitive2;
1389 pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive2 = vboxWddmDDevDrawIndexedPrimitive2;
1390 pCreateData->pDeviceFuncs->pfnVolBlt = vboxWddmDDevVolBlt;
1391 pCreateData->pDeviceFuncs->pfnBufBlt = vboxWddmDDevBufBlt;
1392 pCreateData->pDeviceFuncs->pfnTexBlt = vboxWddmDDevTexBlt;
1393 pCreateData->pDeviceFuncs->pfnStateSet = vboxWddmDDevStateSet;
1394 pCreateData->pDeviceFuncs->pfnSetPriority = vboxWddmDDevSetPriority;
1395 pCreateData->pDeviceFuncs->pfnClear = vboxWddmDDevClear;
1396 pCreateData->pDeviceFuncs->pfnUpdatePalette = vboxWddmDDevUpdatePalette;
1397 pCreateData->pDeviceFuncs->pfnSetPalette = vboxWddmDDevSetPalette;
1398 pCreateData->pDeviceFuncs->pfnSetVertexShaderConst = vboxWddmDDevSetVertexShaderConst;
1399 pCreateData->pDeviceFuncs->pfnMultiplyTransform = vboxWddmDDevMultiplyTransform;
1400 pCreateData->pDeviceFuncs->pfnSetTransform = vboxWddmDDevSetTransform;
1401 pCreateData->pDeviceFuncs->pfnSetViewport = vboxWddmDDevSetViewport;
1402 pCreateData->pDeviceFuncs->pfnSetZRange = vboxWddmDDevSetZRange;
1403 pCreateData->pDeviceFuncs->pfnSetMaterial = vboxWddmDDevSetMaterial;
1404 pCreateData->pDeviceFuncs->pfnSetLight = vboxWddmDDevSetLight;
1405 pCreateData->pDeviceFuncs->pfnCreateLight = vboxWddmDDevCreateLight;
1406 pCreateData->pDeviceFuncs->pfnDestroyLight = vboxWddmDDevDestroyLight;
1407 pCreateData->pDeviceFuncs->pfnSetClipPlane = vboxWddmDDevSetClipPlane;
1408 pCreateData->pDeviceFuncs->pfnGetInfo = vboxWddmDDevGetInfo;
1409 pCreateData->pDeviceFuncs->pfnLock = vboxWddmDDevLock;
1410 pCreateData->pDeviceFuncs->pfnUnlock = vboxWddmDDevUnlock;
1411 pCreateData->pDeviceFuncs->pfnCreateResource = vboxWddmDDevCreateResource;
1412 pCreateData->pDeviceFuncs->pfnDestroyResource = vboxWddmDDevDestroyResource;
1413 pCreateData->pDeviceFuncs->pfnSetDisplayMode = vboxWddmDDevSetDisplayMode;
1414 pCreateData->pDeviceFuncs->pfnPresent = vboxWddmDDevPresent;
1415 pCreateData->pDeviceFuncs->pfnFlush = vboxWddmDDevFlush;
1416 pCreateData->pDeviceFuncs->pfnCreateVertexShaderFunc = vboxWddmDDevCreateVertexShaderFunc;
1417 pCreateData->pDeviceFuncs->pfnDeleteVertexShaderFunc = vboxWddmDDevDeleteVertexShaderFunc;
1418 pCreateData->pDeviceFuncs->pfnSetVertexShaderFunc = vboxWddmDDevSetVertexShaderFunc;
1419 pCreateData->pDeviceFuncs->pfnCreateVertexShaderDecl = vboxWddmDDevCreateVertexShaderDecl;
1420 pCreateData->pDeviceFuncs->pfnDeleteVertexShaderDecl = vboxWddmDDevDeleteVertexShaderDecl;
1421 pCreateData->pDeviceFuncs->pfnSetVertexShaderDecl = vboxWddmDDevSetVertexShaderDecl;
1422 pCreateData->pDeviceFuncs->pfnSetVertexShaderConstI = vboxWddmDDevSetVertexShaderConstI;
1423 pCreateData->pDeviceFuncs->pfnSetVertexShaderConstB = vboxWddmDDevSetVertexShaderConstB;
1424 pCreateData->pDeviceFuncs->pfnSetScissorRect = vboxWddmDDevSetScissorRect;
1425 pCreateData->pDeviceFuncs->pfnSetStreamSource = vboxWddmDDevSetStreamSource;
1426 pCreateData->pDeviceFuncs->pfnSetStreamSourceFreq = vboxWddmDDevSetStreamSourceFreq;
1427 pCreateData->pDeviceFuncs->pfnSetConvolutionKernelMono = vboxWddmDDevSetConvolutionKernelMono;
1428 pCreateData->pDeviceFuncs->pfnComposeRects = vboxWddmDDevComposeRects;
1429 pCreateData->pDeviceFuncs->pfnBlt = vboxWddmDDevBlt;
1430 pCreateData->pDeviceFuncs->pfnColorFill = vboxWddmDDevColorFill;
1431 pCreateData->pDeviceFuncs->pfnDepthFill = vboxWddmDDevDepthFill;
1432 pCreateData->pDeviceFuncs->pfnCreateQuery = vboxWddmDDevCreateQuery;
1433 pCreateData->pDeviceFuncs->pfnDestroyQuery = vboxWddmDDevDestroyQuery;
1434 pCreateData->pDeviceFuncs->pfnIssueQuery = vboxWddmDDevIssueQuery;
1435 pCreateData->pDeviceFuncs->pfnGetQueryData = vboxWddmDDevGetQueryData;
1436 pCreateData->pDeviceFuncs->pfnSetRenderTarget = vboxWddmDDevSetRenderTarget;
1437 pCreateData->pDeviceFuncs->pfnSetDepthStencil = vboxWddmDDevSetDepthStencil;
1438 pCreateData->pDeviceFuncs->pfnGenerateMipSubLevels = vboxWddmDDevGenerateMipSubLevels;
1439 pCreateData->pDeviceFuncs->pfnSetPixelShaderConstI = vboxWddmDDevSetPixelShaderConstI;
1440 pCreateData->pDeviceFuncs->pfnSetPixelShaderConstB = vboxWddmDDevSetPixelShaderConstB;
1441 pCreateData->pDeviceFuncs->pfnCreatePixelShader = vboxWddmDDevCreatePixelShader;
1442 pCreateData->pDeviceFuncs->pfnDeletePixelShader = vboxWddmDDevDeletePixelShader;
1443 pCreateData->pDeviceFuncs->pfnCreateDecodeDevice = vboxWddmDDevCreateDecodeDevice;
1444 pCreateData->pDeviceFuncs->pfnDestroyDecodeDevice = vboxWddmDDevDestroyDecodeDevice;
1445 pCreateData->pDeviceFuncs->pfnSetDecodeRenderTarget = vboxWddmDDevSetDecodeRenderTarget;
1446 pCreateData->pDeviceFuncs->pfnDecodeBeginFrame = vboxWddmDDevDecodeBeginFrame;
1447 pCreateData->pDeviceFuncs->pfnDecodeEndFrame = vboxWddmDDevDecodeEndFrame;
1448 pCreateData->pDeviceFuncs->pfnDecodeExecute = vboxWddmDDevDecodeExecute;
1449 pCreateData->pDeviceFuncs->pfnDecodeExtensionExecute = vboxWddmDDevDecodeExtensionExecute;
1450 pCreateData->pDeviceFuncs->pfnCreateVideoProcessDevice = vboxWddmDDevCreateVideoProcessDevice;
1451 pCreateData->pDeviceFuncs->pfnDestroyVideoProcessDevice = vboxWddmDDevDestroyVideoProcessDevice;
1452 pCreateData->pDeviceFuncs->pfnVideoProcessBeginFrame = vboxWddmDDevVideoProcessBeginFrame;
1453 pCreateData->pDeviceFuncs->pfnVideoProcessEndFrame = vboxWddmDDevVideoProcessEndFrame;
1454 pCreateData->pDeviceFuncs->pfnSetVideoProcessRenderTarget = vboxWddmDDevSetVideoProcessRenderTarget;
1455 pCreateData->pDeviceFuncs->pfnVideoProcessBlt = vboxWddmDDevVideoProcessBlt;
1456 pCreateData->pDeviceFuncs->pfnCreateExtensionDevice = vboxWddmDDevCreateExtensionDevice;
1457 pCreateData->pDeviceFuncs->pfnDestroyExtensionDevice = vboxWddmDDevDestroyExtensionDevice;
1458 pCreateData->pDeviceFuncs->pfnExtensionExecute = vboxWddmDDevExtensionExecute;
1459 pCreateData->pDeviceFuncs->pfnCreateOverlay = vboxWddmDDevCreateOverlay;
1460 pCreateData->pDeviceFuncs->pfnUpdateOverlay = vboxWddmDDevUpdateOverlay;
1461 pCreateData->pDeviceFuncs->pfnFlipOverlay = vboxWddmDDevFlipOverlay;
1462 pCreateData->pDeviceFuncs->pfnGetOverlayColorControls = vboxWddmDDevGetOverlayColorControls;
1463 pCreateData->pDeviceFuncs->pfnSetOverlayColorControls = vboxWddmDDevSetOverlayColorControls;
1464 pCreateData->pDeviceFuncs->pfnDestroyOverlay = vboxWddmDDevDestroyOverlay;
1465 pCreateData->pDeviceFuncs->pfnDestroyDevice = vboxWddmDDevDestroyDevice;
1466 pCreateData->pDeviceFuncs->pfnQueryResourceResidency = vboxWddmDDevQueryResourceResidency;
1467 pCreateData->pDeviceFuncs->pfnOpenResource = vboxWddmDDevOpenResource;
1468 pCreateData->pDeviceFuncs->pfnGetCaptureAllocationHandle = vboxWddmDDevGetCaptureAllocationHandle;
1469 pCreateData->pDeviceFuncs->pfnCaptureToSysMem = vboxWddmDDevCaptureToSysMem;
1470 pCreateData->pDeviceFuncs->pfnLockAsync = NULL; //vboxWddmDDevLockAsync;
1471 pCreateData->pDeviceFuncs->pfnUnlockAsync = NULL; //vboxWddmDDevUnlockAsync;
1472 pCreateData->pDeviceFuncs->pfnRename = NULL; //vboxWddmDDevRename;
1473
1474 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
1475
1476 return S_OK;
1477}
1478
1479static HRESULT APIENTRY vboxWddmDispCloseAdapter (IN HANDLE hAdapter)
1480{
1481 vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
1482
1483// AssertBreakpoint();
1484
1485 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
1486 if (pAdapter->pD3D9If)
1487 {
1488 HRESULT hr = pAdapter->pD3D9If->Release();
1489 Assert(hr == S_OK);
1490 VBoxDispD3DClose(&pAdapter->D3D);
1491 }
1492
1493 RTMemFree(pAdapter);
1494
1495 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
1496
1497 return S_OK;
1498}
1499
1500HRESULT APIENTRY OpenAdapter (__inout D3DDDIARG_OPENADAPTER* pOpenData)
1501{
1502 vboxVDbgPrint(("==> "__FUNCTION__"\n"));
1503
1504 VBOXWDDM_QI Query;
1505 D3DDDICB_QUERYADAPTERINFO DdiQuery;
1506 DdiQuery.PrivateDriverDataSize = sizeof(Query);
1507 DdiQuery.pPrivateDriverData = &Query;
1508 HRESULT hr = pOpenData->pAdapterCallbacks->pfnQueryAdapterInfoCb(pOpenData->hAdapter, &DdiQuery);
1509 Assert(hr == S_OK);
1510 if (hr != S_OK)
1511 {
1512 vboxVDbgPrintR((__FUNCTION__": pfnQueryAdapterInfoCb failed, hr (%d)\n", hr));
1513 return E_FAIL;
1514 }
1515
1516 /* check the miniport version match display version */
1517 if (Query.u32Version != VBOXVIDEOIF_VERSION)
1518 {
1519 vboxVDbgPrintR((__FUNCTION__": miniport version mismatch, expected (%d), but was (%d)\n",
1520 VBOXVIDEOIF_VERSION,
1521 Query.u32Version));
1522 return E_FAIL;
1523 }
1524
1525#ifdef VBOX_WITH_VIDEOHWACCEL
1526 Assert(Query.cInfos >= 1);
1527 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(RT_OFFSETOF(VBOXWDDMDISP_ADAPTER, aHeads[Query.cInfos]));
1528#else
1529 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(sizeof (VBOXWDDMDISP_ADAPTER));
1530#endif
1531 Assert(pAdapter);
1532 if (pAdapter)
1533 {
1534 pAdapter->hAdapter = pOpenData->hAdapter;
1535 pAdapter->uIfVersion = pOpenData->Interface;
1536 pAdapter->uRtVersion= pOpenData->Version;
1537 pAdapter->RtCallbacks = *pOpenData->pAdapterCallbacks;
1538
1539#ifdef VBOX_WITH_VIDEOHWACCEL
1540 pAdapter->cHeads = Query.cInfos;
1541 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
1542 {
1543 pAdapter->aHeads[i].Vhwa.Settings = Query.aInfos[i];
1544 }
1545#endif
1546
1547 pOpenData->hAdapter = pAdapter;
1548 pOpenData->pAdapterFuncs->pfnGetCaps = vboxWddmDispGetCaps;
1549 pOpenData->pAdapterFuncs->pfnCreateDevice = vboxWddmDispCreateDevice;
1550 pOpenData->pAdapterFuncs->pfnCloseAdapter = vboxWddmDispCloseAdapter;
1551 pOpenData->DriverVersion = D3D_UMD_INTERFACE_VERSION;
1552
1553 do
1554 {
1555 /* try enable the 3D */
1556 hr = VBoxDispD3DOpen(&pAdapter->D3D);
1557 Assert(hr == S_OK);
1558 if (hr == S_OK)
1559 {
1560 hr = pAdapter->D3D.pfnDirect3DCreate9Ex(D3D_SDK_VERSION, &pAdapter->pD3D9If);
1561 Assert(hr == S_OK);
1562 if (hr == S_OK)
1563 {
1564 vboxVDbgPrint((__FUNCTION__": SUCCESS 3D Enabled, pAdapter (0x%p)\n", pAdapter));
1565 break;
1566 }
1567 else
1568 vboxVDbgPrintR((__FUNCTION__": pfnDirect3DCreate9Ex failed, hr (%d)\n", hr));
1569
1570 hr = VBoxDispD3DClose(&pAdapter->D3D);
1571 }
1572 else
1573 vboxVDbgPrintR((__FUNCTION__": VBoxDispD3DOpen failed, hr (%d)\n", hr));
1574 } while (0);
1575
1576 vboxFormatOpsInit(pAdapter);
1577 hr = S_OK;
1578// RTMemFree(pAdapter);
1579 }
1580 else
1581 {
1582 vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
1583 hr = E_OUTOFMEMORY;
1584 }
1585
1586 vboxVDbgPrint(("<== "__FUNCTION__", hr (%d)\n", hr));
1587
1588 return hr;
1589}
1590
1591#ifdef VBOXWDDMDISP_DEBUG
1592VOID vboxVDbgDoPrint(LPCSTR szString, ...)
1593{
1594 char szBuffer[1024] = {0};
1595 va_list pArgList;
1596 va_start(pArgList, szString);
1597 _vsnprintf(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]), szString, pArgList);
1598 va_end(pArgList);
1599
1600 OutputDebugStringA(szBuffer);
1601}
1602#endif
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