VirtualBox

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

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

wddm: more fix to getcaps & create device
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 66.2 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 Assert(pData->DataSize >= sizeof (DDRAW_CAPS));
461 if (pData->DataSize >= sizeof (DDRAW_CAPS))
462 {
463 memset(pData->pData, 0, sizeof (DDRAW_CAPS));
464#ifdef VBOX_WITH_VIDEOHWACCEL
465 if (vboxVhwaHasCKeying(pAdapter))
466 {
467 DDRAW_CAPS *pCaps = (DDRAW_CAPS*)pData->pData;
468 pCaps->Caps |= DDRAW_CAPS_COLORKEY;
469 }
470#endif
471 }
472 else
473 hr = E_INVALIDARG;
474 break;
475 }
476 case D3DDDICAPS_DDRAW_MODE_SPECIFIC:
477 {
478 Assert(pData->DataSize >= sizeof (DDRAW_MODE_SPECIFIC_CAPS));
479 if (pData->DataSize >= sizeof (DDRAW_MODE_SPECIFIC_CAPS))
480 {
481 DDRAW_MODE_SPECIFIC_CAPS * pCaps = (DDRAW_MODE_SPECIFIC_CAPS*)pData->pData;
482 memset(&pCaps->Caps /* do not cleanup the first "Head" field,
483 zero starting with the one following "Head", i.e. Caps */,
484 0, sizeof (DDRAW_MODE_SPECIFIC_CAPS) - RT_OFFSETOF(DDRAW_MODE_SPECIFIC_CAPS, Caps));
485#ifdef VBOX_WITH_VIDEOHWACCEL
486 VBOXVHWA_INFO *pSettings = &pAdapter->aHeads[pCaps->Head].Vhwa.Settings;
487 if (pSettings->fFlags & VBOXVHWA_F_ENABLED)
488 {
489 pCaps->Caps |= MODE_CAPS_OVERLAY | MODE_CAPS_OVERLAYSTRETCH;
490
491 if (pSettings->fFlags & VBOXVHWA_F_CKEY_DST)
492 {
493 pCaps->CKeyCaps |= MODE_CKEYCAPS_DESTOVERLAY
494 | MODE_CKEYCAPS_DESTOVERLAYYUV /* ?? */
495 ;
496 }
497
498 if (pSettings->fFlags & VBOXVHWA_F_CKEY_SRC)
499 {
500 pCaps->CKeyCaps |= MODE_CKEYCAPS_SRCOVERLAY
501 | MODE_CKEYCAPS_SRCOVERLAYCLRSPACE /* ?? */
502 | MODE_CKEYCAPS_SRCOVERLAYCLRSPACEYUV /* ?? */
503 | MODE_CKEYCAPS_SRCOVERLAYYUV /* ?? */
504 ;
505 }
506
507 pCaps->FxCaps = MODE_FXCAPS_OVERLAYSHRINKX
508 | MODE_FXCAPS_OVERLAYSHRINKY
509 | MODE_FXCAPS_OVERLAYSTRETCHX
510 | MODE_FXCAPS_OVERLAYSTRETCHY;
511
512
513 pCaps->MaxVisibleOverlays = pSettings->cOverlaysSupported;
514 pCaps->MinOverlayStretch = 1;
515 pCaps->MaxOverlayStretch = 32000;
516 }
517#endif
518 }
519 else
520 hr = E_INVALIDARG;
521 break;
522 }
523 case D3DDDICAPS_GETFORMATCOUNT:
524 *((uint32_t*)pData->pData) = VBOX_FORMATOP_COUNT();
525 break;
526 case D3DDDICAPS_GETFORMATDATA:
527 Assert(pData->DataSize >= VBOX_FORMATOP_COUNT() * sizeof(FORMATOP));
528 memcpy(pData->pData, gVBoxFormatOps, VBOX_FORMATOP_COUNT()*sizeof(FORMATOP));
529 break;
530 case D3DDDICAPS_GETD3DQUERYCOUNT:
531 *((uint32_t*)pData->pData) = 0;
532 break;
533 case D3DDDICAPS_GETD3D3CAPS:
534 Assert(pData->DataSize >= sizeof (D3DHAL_GLOBALDRIVERDATA));
535 if (pData->DataSize >= sizeof (D3DHAL_GLOBALDRIVERDATA))
536 {
537 D3DHAL_GLOBALDRIVERDATA *pCaps = (D3DHAL_GLOBALDRIVERDATA *)pData->pData;
538 memset (pCaps, 0, sizeof (D3DHAL_GLOBALDRIVERDATA));
539 pCaps->dwSize = sizeof (D3DHAL_GLOBALDRIVERDATA);
540 pCaps->hwCaps.dwSize = sizeof (D3DDEVICEDESC_V1);
541 pCaps->hwCaps.dwFlags = D3DDD_COLORMODEL
542 | D3DDD_DEVCAPS;
543
544 pCaps->hwCaps.dcmColorModel = D3DCOLOR_RGB;
545 pCaps->hwCaps.dwDevCaps = 0;
546 pCaps->hwCaps.dtcTransformCaps.dwSize = sizeof (D3DTRANSFORMCAPS);
547 pCaps->hwCaps.dtcTransformCaps.dwCaps = 0;
548 pCaps->hwCaps.bClipping = FALSE;
549 pCaps->hwCaps.dlcLightingCaps.dwSize = sizeof (D3DLIGHTINGCAPS);
550 pCaps->hwCaps.dlcLightingCaps.dwCaps = 0;
551 pCaps->hwCaps.dlcLightingCaps.dwLightingModel = 0;
552 pCaps->hwCaps.dlcLightingCaps.dwNumLights = 0;
553 pCaps->hwCaps.dpcLineCaps.dwSize = sizeof (D3DPRIMCAPS);
554 pCaps->hwCaps.dpcLineCaps.dwMiscCaps = 0;
555 pCaps->hwCaps.dpcLineCaps.dwRasterCaps = 0;
556 pCaps->hwCaps.dpcLineCaps.dwZCmpCaps = 0;
557 pCaps->hwCaps.dpcLineCaps.dwSrcBlendCaps = 0;
558 pCaps->hwCaps.dpcLineCaps.dwDestBlendCaps = 0;
559 pCaps->hwCaps.dpcLineCaps.dwAlphaCmpCaps = 0;
560 pCaps->hwCaps.dpcLineCaps.dwShadeCaps = 0;
561 pCaps->hwCaps.dpcLineCaps.dwTextureCaps = 0;
562 pCaps->hwCaps.dpcLineCaps.dwTextureFilterCaps = 0;
563 pCaps->hwCaps.dpcLineCaps.dwTextureBlendCaps = 0;
564 pCaps->hwCaps.dpcLineCaps.dwTextureAddressCaps = 0;
565 pCaps->hwCaps.dpcLineCaps.dwStippleWidth = 0;
566 pCaps->hwCaps.dpcLineCaps.dwStippleHeight = 0;
567
568 pCaps->hwCaps.dpcTriCaps.dwSize = sizeof (D3DPRIMCAPS);
569 pCaps->hwCaps.dpcTriCaps.dwMiscCaps = 0;
570 pCaps->hwCaps.dpcTriCaps.dwRasterCaps = 0;
571 pCaps->hwCaps.dpcTriCaps.dwZCmpCaps = 0;
572 pCaps->hwCaps.dpcTriCaps.dwSrcBlendCaps = 0;
573 pCaps->hwCaps.dpcTriCaps.dwDestBlendCaps = 0;
574 pCaps->hwCaps.dpcTriCaps.dwAlphaCmpCaps = 0;
575 pCaps->hwCaps.dpcTriCaps.dwShadeCaps = 0;
576 pCaps->hwCaps.dpcTriCaps.dwTextureCaps = 0;
577 pCaps->hwCaps.dpcTriCaps.dwTextureFilterCaps = 0;
578 pCaps->hwCaps.dpcTriCaps.dwTextureBlendCaps = 0;
579 pCaps->hwCaps.dpcTriCaps.dwTextureAddressCaps = 0;
580 pCaps->hwCaps.dpcTriCaps.dwStippleWidth = 0;
581 pCaps->hwCaps.dpcTriCaps.dwStippleHeight = 0;
582 pCaps->hwCaps.dwDeviceRenderBitDepth = 0;
583 pCaps->hwCaps.dwDeviceZBufferBitDepth = 0;
584 pCaps->hwCaps.dwMaxBufferSize = 0;
585 pCaps->hwCaps.dwMaxVertexCount = 0;
586
587
588 pCaps->dwNumVertices = 0;
589 pCaps->dwNumClipVertices = 0;
590 pCaps->dwNumTextureFormats = 0;
591 pCaps->lpTextureFormats = NULL;
592 }
593 else
594 hr = E_INVALIDARG;
595 break;
596 case D3DDDICAPS_GETD3D7CAPS:
597 Assert(pData->DataSize >= sizeof (D3DHAL_D3DEXTENDEDCAPS));
598 if (pData->DataSize >= sizeof (D3DHAL_D3DEXTENDEDCAPS))
599 memset(pData->pData, 0, sizeof (D3DHAL_D3DEXTENDEDCAPS));
600 else
601 hr = E_INVALIDARG;
602 break;
603 case D3DDDICAPS_GETD3D9CAPS:
604 {
605 Assert(pData->DataSize >= sizeof (D3DCAPS9));
606 if (pData->DataSize >= sizeof (D3DCAPS9))
607 {
608 if (pAdapter->pD3D9If)
609 {
610 hr = pAdapter->pD3D9If->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, (D3DCAPS9*)pData->pData);
611 Assert(hr == S_OK);
612 if (hr == S_OK)
613 break;
614
615 vboxVDbgPrintR((__FUNCTION__": GetDeviceCaps hr(%d)\n", hr));
616 /* let's fall back to the 3D disabled case */
617 hr = S_OK;
618 }
619
620 memset(pData->pData, 0, sizeof (D3DCAPS9));
621 }
622 else
623 hr = E_INVALIDARG;
624 break;
625 }
626 case D3DDDICAPS_GETGAMMARAMPCAPS:
627 *((uint32_t*)pData->pData) = 0;
628 break;
629 case D3DDDICAPS_GETMULTISAMPLEQUALITYLEVELS:
630 case D3DDDICAPS_GETD3DQUERYDATA:
631 case D3DDDICAPS_GETD3D5CAPS:
632 case D3DDDICAPS_GETD3D6CAPS:
633 case D3DDDICAPS_GETD3D8CAPS:
634 case D3DDDICAPS_GETDECODEGUIDCOUNT:
635 case D3DDDICAPS_GETDECODEGUIDS:
636 case D3DDDICAPS_GETDECODERTFORMATCOUNT:
637 case D3DDDICAPS_GETDECODERTFORMATS:
638 case D3DDDICAPS_GETDECODECOMPRESSEDBUFFERINFOCOUNT:
639 case D3DDDICAPS_GETDECODECOMPRESSEDBUFFERINFO:
640 case D3DDDICAPS_GETDECODECONFIGURATIONCOUNT:
641 case D3DDDICAPS_GETDECODECONFIGURATIONS:
642 case D3DDDICAPS_GETVIDEOPROCESSORDEVICEGUIDCOUNT:
643 case D3DDDICAPS_GETVIDEOPROCESSORDEVICEGUIDS:
644 case D3DDDICAPS_GETVIDEOPROCESSORRTFORMATCOUNT:
645 case D3DDDICAPS_GETVIDEOPROCESSORRTFORMATS:
646 case D3DDDICAPS_GETVIDEOPROCESSORRTSUBSTREAMFORMATCOUNT:
647 case D3DDDICAPS_GETVIDEOPROCESSORRTSUBSTREAMFORMATS:
648 case D3DDDICAPS_GETVIDEOPROCESSORCAPS:
649 case D3DDDICAPS_GETPROCAMPRANGE:
650 case D3DDDICAPS_FILTERPROPERTYRANGE:
651 case D3DDDICAPS_GETEXTENSIONGUIDCOUNT:
652 case D3DDDICAPS_GETEXTENSIONGUIDS:
653 case D3DDDICAPS_GETEXTENSIONCAPS:
654 vboxVDbgPrint((__FUNCTION__": unimplemented caps type(%d)\n", pData->Type));
655 AssertBreakpoint();
656 if (pData->pData && pData->DataSize)
657 memset(pData->pData, 0, pData->DataSize);
658 break;
659 default:
660 vboxVDbgPrint((__FUNCTION__": unknown caps type(%d)\n", pData->Type));
661 AssertBreakpoint();
662 }
663
664 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p), caps type(%d)\n", hAdapter, pData->Type));
665
666 return S_OK;
667}
668
669static HRESULT APIENTRY vboxWddmDDevSetRenderState(HANDLE hDevice, CONST D3DDDIARG_RENDERSTATE* pData)
670{
671 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
672 AssertBreakpoint();
673 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
674 return E_FAIL;
675}
676
677static HRESULT APIENTRY vboxWddmDDevUpdateWInfo(HANDLE hDevice, CONST D3DDDIARG_WINFO* pData)
678{
679 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
680 AssertBreakpoint();
681 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
682 return E_FAIL;
683}
684
685static HRESULT APIENTRY vboxWddmDDevValidateDevice(HANDLE hDevice, D3DDDIARG_VALIDATETEXTURESTAGESTATE* pData)
686{
687 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
688 AssertBreakpoint();
689 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
690 return E_FAIL;
691}
692
693static HRESULT APIENTRY vboxWddmDDevSetTextureStageState(HANDLE hDevice, CONST D3DDDIARG_TEXTURESTAGESTATE* pData)
694{
695 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
696 AssertBreakpoint();
697 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
698 return E_FAIL;
699}
700
701static HRESULT APIENTRY vboxWddmDDevSetTexture(HANDLE hDevice, UINT Stage, HANDLE hTexture)
702{
703 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
704 AssertBreakpoint();
705 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
706 return E_FAIL;
707}
708
709static HRESULT APIENTRY vboxWddmDDevSetPixelShader(HANDLE hDevice, HANDLE hShaderHandle)
710{
711 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
712 AssertBreakpoint();
713 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
714 return E_FAIL;
715}
716
717static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONST* pData, CONST FLOAT* pRegisters)
718{
719 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
720 AssertBreakpoint();
721 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
722 return E_FAIL;
723}
724
725static HRESULT APIENTRY vboxWddmDDevSetStreamSourceUm(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEUM* pData, CONST VOID* pUMBuffer )
726{
727 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
728 AssertBreakpoint();
729 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
730 return E_FAIL;
731}
732
733static HRESULT APIENTRY vboxWddmDDevSetIndices(HANDLE hDevice, CONST D3DDDIARG_SETINDICES* pData)
734{
735 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
736 AssertBreakpoint();
737 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
738 return E_FAIL;
739}
740
741static HRESULT APIENTRY vboxWddmDDevSetIndicesUm(HANDLE hDevice, UINT IndexSize, CONST VOID* pUMBuffer)
742{
743 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
744 AssertBreakpoint();
745 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
746 return E_FAIL;
747}
748
749static HRESULT APIENTRY vboxWddmDDevDrawPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE* pData, CONST UINT* pFlagBuffer)
750{
751 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
752 AssertBreakpoint();
753 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
754 return E_FAIL;
755}
756
757static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE* pData)
758{
759 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
760 AssertBreakpoint();
761 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
762 return E_FAIL;
763}
764
765static HRESULT APIENTRY vboxWddmDDevDrawRectPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWRECTPATCH* pData, CONST D3DDDIRECTPATCH_INFO* pInfo, CONST FLOAT* pPatch)
766{
767 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
768 AssertBreakpoint();
769 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
770 return E_FAIL;
771}
772
773static HRESULT APIENTRY vboxWddmDDevDrawTriPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWTRIPATCH* pData, CONST D3DDDITRIPATCH_INFO* pInfo, CONST FLOAT* pPatch)
774{
775 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
776 AssertBreakpoint();
777 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
778 return E_FAIL;
779}
780
781static HRESULT APIENTRY vboxWddmDDevDrawPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE2* pData)
782{
783 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
784 AssertBreakpoint();
785 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
786 return E_FAIL;
787}
788
789static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE2* pData, UINT dwIndicesSize, CONST VOID* pIndexBuffer, CONST UINT* pFlagBuffer)
790{
791 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
792 AssertBreakpoint();
793 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
794 return E_FAIL;
795}
796
797static HRESULT APIENTRY vboxWddmDDevVolBlt(HANDLE hDevice, CONST D3DDDIARG_VOLUMEBLT* pData)
798{
799 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
800 AssertBreakpoint();
801 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
802 return E_FAIL;
803}
804
805static HRESULT APIENTRY vboxWddmDDevBufBlt(HANDLE hDevice, CONST D3DDDIARG_BUFFERBLT* pData)
806{
807 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
808 AssertBreakpoint();
809 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
810 return E_FAIL;
811}
812
813static HRESULT APIENTRY vboxWddmDDevTexBlt(HANDLE hDevice, CONST D3DDDIARG_TEXBLT* pData)
814{
815 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
816 AssertBreakpoint();
817 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
818 return E_FAIL;
819}
820
821static HRESULT APIENTRY vboxWddmDDevStateSet(HANDLE hDevice, D3DDDIARG_STATESET* pData)
822{
823 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
824 AssertBreakpoint();
825 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
826 return E_FAIL;
827}
828static HRESULT APIENTRY vboxWddmDDevSetPriority(HANDLE hDevice, CONST D3DDDIARG_SETPRIORITY* pData)
829{
830 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
831 AssertBreakpoint();
832 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
833 return E_FAIL;
834}
835static HRESULT APIENTRY vboxWddmDDevClear(HANDLE hDevice, CONST D3DDDIARG_CLEAR* pData, UINT NumRect, CONST RECT* pRect)
836{
837 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
838 AssertBreakpoint();
839 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
840 return E_FAIL;
841}
842static HRESULT APIENTRY vboxWddmDDevUpdatePalette(HANDLE hDevice, CONST D3DDDIARG_UPDATEPALETTE* pData, CONST PALETTEENTRY* pPaletteData)
843{
844 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
845 AssertBreakpoint();
846 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
847 return E_FAIL;
848}
849
850static HRESULT APIENTRY vboxWddmDDevSetPalette(HANDLE hDevice, CONST D3DDDIARG_SETPALETTE* pData)
851{
852 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
853 AssertBreakpoint();
854 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
855 return E_FAIL;
856}
857
858static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONST* pData , CONST VOID* pRegisters)
859{
860 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
861 AssertBreakpoint();
862 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
863 return E_FAIL;
864}
865static HRESULT APIENTRY vboxWddmDDevMultiplyTransform(HANDLE hDevice, CONST D3DDDIARG_MULTIPLYTRANSFORM* pData)
866{
867 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
868 AssertBreakpoint();
869 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
870 return E_FAIL;
871}
872static HRESULT APIENTRY vboxWddmDDevSetTransform(HANDLE hDevice, CONST D3DDDIARG_SETTRANSFORM* pData)
873{
874 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
875 AssertBreakpoint();
876 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
877 return E_FAIL;
878}
879static HRESULT APIENTRY vboxWddmDDevSetViewport(HANDLE hDevice, CONST D3DDDIARG_VIEWPORTINFO* pData)
880{
881 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
882 AssertBreakpoint();
883 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
884 return E_FAIL;
885}
886static HRESULT APIENTRY vboxWddmDDevSetZRange(HANDLE hDevice, CONST D3DDDIARG_ZRANGE* pData)
887{
888 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
889 AssertBreakpoint();
890 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
891 return E_FAIL;
892}
893static HRESULT APIENTRY vboxWddmDDevSetMaterial(HANDLE hDevice, CONST D3DDDIARG_SETMATERIAL* pData)
894{
895 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
896 AssertBreakpoint();
897 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
898 return E_FAIL;
899}
900static HRESULT APIENTRY vboxWddmDDevSetLight(HANDLE hDevice, CONST D3DDDIARG_SETLIGHT* pData, CONST D3DDDI_LIGHT* pLightProperties)
901{
902 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
903 AssertBreakpoint();
904 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
905 return E_FAIL;
906}
907static HRESULT APIENTRY vboxWddmDDevCreateLight(HANDLE hDevice, CONST D3DDDIARG_CREATELIGHT* pData)
908{
909 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
910 AssertBreakpoint();
911 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
912 return E_FAIL;
913}
914static HRESULT APIENTRY vboxWddmDDevDestroyLight(HANDLE hDevice, CONST D3DDDIARG_DESTROYLIGHT* pData)
915{
916 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
917 AssertBreakpoint();
918 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
919 return E_FAIL;
920}
921static HRESULT APIENTRY vboxWddmDDevSetClipPlane(HANDLE hDevice, CONST D3DDDIARG_SETCLIPPLANE* pData)
922{
923 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
924 AssertBreakpoint();
925 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
926 return E_FAIL;
927}
928
929static HRESULT APIENTRY vboxWddmDDevGetInfo(HANDLE hDevice, UINT DevInfoID, VOID* pDevInfoStruct, UINT DevInfoSize)
930{
931 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
932 AssertBreakpoint();
933 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
934 return E_NOTIMPL;
935}
936
937static HRESULT APIENTRY vboxWddmDDevLock(HANDLE hDevice, D3DDDIARG_LOCK* pData)
938{
939 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
940 AssertBreakpoint();
941 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
942 return E_FAIL;
943}
944static HRESULT APIENTRY vboxWddmDDevUnlock(HANDLE hDevice, CONST D3DDDIARG_UNLOCK* pData)
945{
946 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
947 AssertBreakpoint();
948 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
949 return E_FAIL;
950}
951static HRESULT APIENTRY vboxWddmDDevLockAsync(HANDLE hDevice, D3DDDIARG_LOCKASYNC* pData)
952{
953 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
954 AssertBreakpoint();
955 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
956 return E_FAIL;
957}
958static HRESULT APIENTRY vboxWddmDDevUnlockAsync(HANDLE hDevice, CONST D3DDDIARG_UNLOCKASYNC* pData)
959{
960 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
961 AssertBreakpoint();
962 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
963 return E_FAIL;
964}
965static HRESULT APIENTRY vboxWddmDDevRename(HANDLE hDevice, CONST D3DDDIARG_RENAME* pData)
966{
967 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
968 AssertBreakpoint();
969 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
970 return E_FAIL;
971}
972static HRESULT APIENTRY vboxWddmDDevCreateResource(HANDLE hDevice, D3DDDIARG_CREATERESOURCE* pResource)
973{
974 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
975 AssertBreakpoint();
976 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
977 return E_FAIL;
978}
979static HRESULT APIENTRY vboxWddmDDevDestroyResource(HANDLE hDevice, HANDLE hResource)
980{
981 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
982 AssertBreakpoint();
983 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
984 return E_FAIL;
985}
986static HRESULT APIENTRY vboxWddmDDevSetDisplayMode(HANDLE hDevice, CONST D3DDDIARG_SETDISPLAYMODE* pData)
987{
988 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
989 AssertBreakpoint();
990 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
991 return E_FAIL;
992}
993static HRESULT APIENTRY vboxWddmDDevPresent(HANDLE hDevice, CONST D3DDDIARG_PRESENT* pData)
994{
995 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
996 AssertBreakpoint();
997 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
998 return E_FAIL;
999}
1000static HRESULT APIENTRY vboxWddmDDevFlush(HANDLE hDevice)
1001{
1002 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1003 AssertBreakpoint();
1004 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1005 return E_FAIL;
1006}
1007static HRESULT APIENTRY vboxWddmDDevCreateVertexShaderDecl(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERDECL* pData, CONST D3DDDIVERTEXELEMENT* pVertexElements)
1008{
1009 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1010 AssertBreakpoint();
1011 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1012 return E_FAIL;
1013}
1014static HRESULT APIENTRY vboxWddmDDevSetVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
1015{
1016 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1017 AssertBreakpoint();
1018 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1019 return E_FAIL;
1020}
1021static HRESULT APIENTRY vboxWddmDDevDeleteVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
1022{
1023 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1024 AssertBreakpoint();
1025 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1026 return E_FAIL;
1027}
1028static HRESULT APIENTRY vboxWddmDDevCreateVertexShaderFunc(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERFUNC* pData, CONST UINT* pCode)
1029{
1030 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1031 AssertBreakpoint();
1032 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1033 return E_FAIL;
1034}
1035static HRESULT APIENTRY vboxWddmDDevSetVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
1036{
1037 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1038 AssertBreakpoint();
1039 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1040 return E_FAIL;
1041}
1042static HRESULT APIENTRY vboxWddmDDevDeleteVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
1043{
1044 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1045 AssertBreakpoint();
1046 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1047 return E_FAIL;
1048}
1049static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTI* pData, CONST INT* pRegisters)
1050{
1051 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1052 AssertBreakpoint();
1053 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1054 return E_FAIL;
1055}
1056static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTB* pData, CONST BOOL* pRegisters)
1057{
1058 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1059 AssertBreakpoint();
1060 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1061 return E_FAIL;
1062}
1063static HRESULT APIENTRY vboxWddmDDevSetScissorRect(HANDLE hDevice, CONST RECT* pRect)
1064{
1065 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1066 AssertBreakpoint();
1067 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1068 return E_FAIL;
1069}
1070static HRESULT APIENTRY vboxWddmDDevSetStreamSource(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCE* pData)
1071{
1072 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1073 AssertBreakpoint();
1074 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1075 return E_FAIL;
1076}
1077static HRESULT APIENTRY vboxWddmDDevSetStreamSourceFreq(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEFREQ* pData)
1078{
1079 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1080 AssertBreakpoint();
1081 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1082 return E_FAIL;
1083}
1084static HRESULT APIENTRY vboxWddmDDevSetConvolutionKernelMono(HANDLE hDevice, CONST D3DDDIARG_SETCONVOLUTIONKERNELMONO* pData)
1085{
1086 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1087 AssertBreakpoint();
1088 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1089 return E_FAIL;
1090}
1091static HRESULT APIENTRY vboxWddmDDevComposeRects(HANDLE hDevice, CONST D3DDDIARG_COMPOSERECTS* pData)
1092{
1093 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1094 AssertBreakpoint();
1095 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1096 return E_FAIL;
1097}
1098static HRESULT APIENTRY vboxWddmDDevBlt(HANDLE hDevice, CONST D3DDDIARG_BLT* pData)
1099{
1100 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1101 AssertBreakpoint();
1102 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1103 return E_FAIL;
1104}
1105static HRESULT APIENTRY vboxWddmDDevColorFill(HANDLE hDevice, CONST D3DDDIARG_COLORFILL* pData)
1106{
1107 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1108 AssertBreakpoint();
1109 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1110 return E_FAIL;
1111}
1112static HRESULT APIENTRY vboxWddmDDevDepthFill(HANDLE hDevice, CONST D3DDDIARG_DEPTHFILL* pData)
1113{
1114 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1115 AssertBreakpoint();
1116 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1117 return E_FAIL;
1118}
1119static HRESULT APIENTRY vboxWddmDDevCreateQuery(HANDLE hDevice, D3DDDIARG_CREATEQUERY* pData)
1120{
1121 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1122 AssertBreakpoint();
1123 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1124 return E_FAIL;
1125}
1126static HRESULT APIENTRY vboxWddmDDevDestroyQuery(HANDLE hDevice, HANDLE hQuery)
1127{
1128 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1129 AssertBreakpoint();
1130 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1131 return E_FAIL;
1132}
1133static HRESULT APIENTRY vboxWddmDDevIssueQuery(HANDLE hDevice, CONST D3DDDIARG_ISSUEQUERY* pData)
1134{
1135 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1136 AssertBreakpoint();
1137 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1138 return E_FAIL;
1139}
1140static HRESULT APIENTRY vboxWddmDDevGetQueryData(HANDLE hDevice, CONST D3DDDIARG_GETQUERYDATA* pData)
1141{
1142 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1143 AssertBreakpoint();
1144 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1145 return E_FAIL;
1146}
1147static HRESULT APIENTRY vboxWddmDDevSetRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETRENDERTARGET* pData)
1148{
1149 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1150 AssertBreakpoint();
1151 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1152 return E_FAIL;
1153}
1154static HRESULT APIENTRY vboxWddmDDevSetDepthStencil(HANDLE hDevice, CONST D3DDDIARG_SETDEPTHSTENCIL* pData)
1155{
1156 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1157 AssertBreakpoint();
1158 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1159 return E_FAIL;
1160}
1161static HRESULT APIENTRY vboxWddmDDevGenerateMipSubLevels(HANDLE hDevice, CONST D3DDDIARG_GENERATEMIPSUBLEVELS* pData)
1162{
1163 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1164 AssertBreakpoint();
1165 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1166 return E_FAIL;
1167}
1168static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTI* pData, CONST INT* pRegisters)
1169{
1170 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1171 AssertBreakpoint();
1172 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1173 return E_FAIL;
1174}
1175static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTB* pData, CONST BOOL* pRegisters)
1176{
1177 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1178 AssertBreakpoint();
1179 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1180 return E_FAIL;
1181}
1182static HRESULT APIENTRY vboxWddmDDevCreatePixelShader(HANDLE hDevice, D3DDDIARG_CREATEPIXELSHADER* pData, CONST UINT* pCode)
1183{
1184 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1185 AssertBreakpoint();
1186 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1187 return E_FAIL;
1188}
1189static HRESULT APIENTRY vboxWddmDDevDeletePixelShader(HANDLE hDevice, HANDLE hShaderHandle)
1190{
1191 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1192 AssertBreakpoint();
1193 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1194 return E_FAIL;
1195}
1196static HRESULT APIENTRY vboxWddmDDevCreateDecodeDevice(HANDLE hDevice, D3DDDIARG_CREATEDECODEDEVICE* pData)
1197{
1198 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1199 AssertBreakpoint();
1200 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1201 return E_FAIL;
1202}
1203static HRESULT APIENTRY vboxWddmDDevDestroyDecodeDevice(HANDLE hDevice, HANDLE hDecodeDevice)
1204{
1205 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1206 AssertBreakpoint();
1207 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1208 return E_FAIL;
1209}
1210static HRESULT APIENTRY vboxWddmDDevSetDecodeRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETDECODERENDERTARGET* pData)
1211{
1212 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1213 AssertBreakpoint();
1214 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1215 return E_FAIL;
1216}
1217static HRESULT APIENTRY vboxWddmDDevDecodeBeginFrame(HANDLE hDevice, D3DDDIARG_DECODEBEGINFRAME* pData)
1218{
1219 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1220 AssertBreakpoint();
1221 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1222 return E_FAIL;
1223}
1224static HRESULT APIENTRY vboxWddmDDevDecodeEndFrame(HANDLE hDevice, D3DDDIARG_DECODEENDFRAME* pData)
1225{
1226 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1227 AssertBreakpoint();
1228 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1229 return E_FAIL;
1230}
1231static HRESULT APIENTRY vboxWddmDDevDecodeExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXECUTE* pData)
1232{
1233 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1234 AssertBreakpoint();
1235 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1236 return E_FAIL;
1237}
1238static HRESULT APIENTRY vboxWddmDDevDecodeExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXTENSIONEXECUTE* pData)
1239{
1240 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1241 AssertBreakpoint();
1242 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1243 return E_FAIL;
1244}
1245static HRESULT APIENTRY vboxWddmDDevCreateVideoProcessDevice(HANDLE hDevice, D3DDDIARG_CREATEVIDEOPROCESSDEVICE* pData)
1246{
1247 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1248 AssertBreakpoint();
1249 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1250 return E_FAIL;
1251}
1252static HRESULT APIENTRY vboxWddmDDevDestroyVideoProcessDevice(HANDLE hDevice, HANDLE hVideoProcessor)
1253{
1254 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1255 AssertBreakpoint();
1256 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1257 return E_FAIL;
1258}
1259static HRESULT APIENTRY vboxWddmDDevVideoProcessBeginFrame(HANDLE hDevice, HANDLE hVideoProcess)
1260{
1261 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1262 AssertBreakpoint();
1263 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1264 return E_FAIL;
1265}
1266static HRESULT APIENTRY vboxWddmDDevVideoProcessEndFrame(HANDLE hDevice, D3DDDIARG_VIDEOPROCESSENDFRAME* pData)
1267{
1268 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1269 AssertBreakpoint();
1270 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1271 return E_FAIL;
1272}
1273static HRESULT APIENTRY vboxWddmDDevSetVideoProcessRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETVIDEOPROCESSRENDERTARGET* pData)
1274{
1275 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1276 AssertBreakpoint();
1277 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1278 return E_FAIL;
1279}
1280static HRESULT APIENTRY vboxWddmDDevVideoProcessBlt(HANDLE hDevice, CONST D3DDDIARG_VIDEOPROCESSBLT* pData)
1281{
1282 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1283 AssertBreakpoint();
1284 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1285 return E_FAIL;
1286}
1287static HRESULT APIENTRY vboxWddmDDevCreateExtensionDevice(HANDLE hDevice, D3DDDIARG_CREATEEXTENSIONDEVICE* pData)
1288{
1289 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1290 AssertBreakpoint();
1291 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1292 return E_FAIL;
1293}
1294static HRESULT APIENTRY vboxWddmDDevDestroyExtensionDevice(HANDLE hDevice, HANDLE hExtension)
1295{
1296 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1297 AssertBreakpoint();
1298 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1299 return E_FAIL;
1300}
1301static HRESULT APIENTRY vboxWddmDDevExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_EXTENSIONEXECUTE* pData)
1302{
1303 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1304 AssertBreakpoint();
1305 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1306 return E_FAIL;
1307}
1308static HRESULT APIENTRY vboxWddmDDevDestroyDevice(IN HANDLE hDevice)
1309{
1310 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1311 AssertBreakpoint();
1312 RTMemFree(hDevice);
1313 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1314 return S_OK;
1315}
1316static HRESULT APIENTRY vboxWddmDDevCreateOverlay(HANDLE hDevice, D3DDDIARG_CREATEOVERLAY* pData)
1317{
1318 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1319 AssertBreakpoint();
1320 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1321 return E_FAIL;
1322}
1323static HRESULT APIENTRY vboxWddmDDevUpdateOverlay(HANDLE hDevice, CONST D3DDDIARG_UPDATEOVERLAY* pData)
1324{
1325 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1326 AssertBreakpoint();
1327 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1328 return E_FAIL;
1329}
1330static HRESULT APIENTRY vboxWddmDDevFlipOverlay(HANDLE hDevice, CONST D3DDDIARG_FLIPOVERLAY* pData)
1331{
1332 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1333 AssertBreakpoint();
1334 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1335 return E_FAIL;
1336}
1337static HRESULT APIENTRY vboxWddmDDevGetOverlayColorControls(HANDLE hDevice, D3DDDIARG_GETOVERLAYCOLORCONTROLS* pData)
1338{
1339 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1340 AssertBreakpoint();
1341 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1342 return E_FAIL;
1343}
1344static HRESULT APIENTRY vboxWddmDDevSetOverlayColorControls(HANDLE hDevice, CONST D3DDDIARG_SETOVERLAYCOLORCONTROLS* pData)
1345{
1346 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1347 AssertBreakpoint();
1348 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1349 return E_FAIL;
1350}
1351static HRESULT APIENTRY vboxWddmDDevDestroyOverlay(HANDLE hDevice, CONST D3DDDIARG_DESTROYOVERLAY* pData)
1352{
1353 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1354 AssertBreakpoint();
1355 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1356 return E_FAIL;
1357}
1358static HRESULT APIENTRY vboxWddmDDevQueryResourceResidency(HANDLE hDevice, CONST D3DDDIARG_QUERYRESOURCERESIDENCY* pData)
1359{
1360 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1361 AssertBreakpoint();
1362 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1363 return E_FAIL;
1364}
1365static HRESULT APIENTRY vboxWddmDDevOpenResource(HANDLE hDevice, D3DDDIARG_OPENRESOURCE* pData)
1366{
1367 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1368 AssertBreakpoint();
1369 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1370 return E_FAIL;
1371}
1372static HRESULT APIENTRY vboxWddmDDevGetCaptureAllocationHandle(HANDLE hDevice, D3DDDIARG_GETCAPTUREALLOCATIONHANDLE* pData)
1373{
1374 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1375 AssertBreakpoint();
1376 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1377 return E_FAIL;
1378}
1379
1380static HRESULT APIENTRY vboxWddmDDevCaptureToSysMem(HANDLE hDevice, CONST D3DDDIARG_CAPTURETOSYSMEM* pData)
1381{
1382 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1383 AssertBreakpoint();
1384 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1385 return E_FAIL;
1386}
1387
1388static HRESULT APIENTRY vboxWddmDispCreateDevice (IN HANDLE hAdapter, IN D3DDDIARG_CREATEDEVICE* pCreateData)
1389{
1390 HRESULT hr = S_OK;
1391 vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p), Interface(%d), Version(%d)\n", hAdapter, pCreateData->Interface, pCreateData->Version));
1392
1393// AssertBreakpoint();
1394
1395 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)RTMemAllocZ(sizeof (VBOXWDDMDISP_DEVICE));
1396 if (pDevice)
1397 {
1398 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
1399
1400 pDevice->hDevice = pCreateData->hDevice;
1401 pDevice->pAdapter = pAdapter;
1402 pDevice->u32IfVersion = pCreateData->Interface;
1403 pDevice->uRtVersion = pCreateData->Version;
1404 pDevice->RtCallbacks = *pCreateData->pCallbacks;
1405 pDevice->pvCmdBuffer = pCreateData->pCommandBuffer;
1406 pDevice->cbCmdBuffer = pCreateData->CommandBufferSize;
1407 pDevice->fFlags = pCreateData->Flags;
1408
1409 Assert(!pCreateData->AllocationListSize);
1410 Assert(!pCreateData->PatchLocationListSize);
1411
1412 pCreateData->hDevice = pDevice;
1413
1414 pCreateData->pDeviceFuncs->pfnSetRenderState = vboxWddmDDevSetRenderState;
1415 pCreateData->pDeviceFuncs->pfnUpdateWInfo = vboxWddmDDevUpdateWInfo;
1416 pCreateData->pDeviceFuncs->pfnValidateDevice = vboxWddmDDevValidateDevice;
1417 pCreateData->pDeviceFuncs->pfnSetTextureStageState = vboxWddmDDevSetTextureStageState;
1418 pCreateData->pDeviceFuncs->pfnSetTexture = vboxWddmDDevSetTexture;
1419 pCreateData->pDeviceFuncs->pfnSetPixelShader = vboxWddmDDevSetPixelShader;
1420 pCreateData->pDeviceFuncs->pfnSetPixelShaderConst = vboxWddmDDevSetPixelShaderConst;
1421 pCreateData->pDeviceFuncs->pfnSetStreamSourceUm = vboxWddmDDevSetStreamSourceUm;
1422 pCreateData->pDeviceFuncs->pfnSetIndices = vboxWddmDDevSetIndices;
1423 pCreateData->pDeviceFuncs->pfnSetIndicesUm = vboxWddmDDevSetIndicesUm;
1424 pCreateData->pDeviceFuncs->pfnDrawPrimitive = vboxWddmDDevDrawPrimitive;
1425 pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive = vboxWddmDDevDrawIndexedPrimitive;
1426 pCreateData->pDeviceFuncs->pfnDrawRectPatch = vboxWddmDDevDrawRectPatch;
1427 pCreateData->pDeviceFuncs->pfnDrawTriPatch = vboxWddmDDevDrawTriPatch;
1428 pCreateData->pDeviceFuncs->pfnDrawPrimitive2 = vboxWddmDDevDrawPrimitive2;
1429 pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive2 = vboxWddmDDevDrawIndexedPrimitive2;
1430 pCreateData->pDeviceFuncs->pfnVolBlt = vboxWddmDDevVolBlt;
1431 pCreateData->pDeviceFuncs->pfnBufBlt = vboxWddmDDevBufBlt;
1432 pCreateData->pDeviceFuncs->pfnTexBlt = vboxWddmDDevTexBlt;
1433 pCreateData->pDeviceFuncs->pfnStateSet = vboxWddmDDevStateSet;
1434 pCreateData->pDeviceFuncs->pfnSetPriority = vboxWddmDDevSetPriority;
1435 pCreateData->pDeviceFuncs->pfnClear = vboxWddmDDevClear;
1436 pCreateData->pDeviceFuncs->pfnUpdatePalette = vboxWddmDDevUpdatePalette;
1437 pCreateData->pDeviceFuncs->pfnSetPalette = vboxWddmDDevSetPalette;
1438 pCreateData->pDeviceFuncs->pfnSetVertexShaderConst = vboxWddmDDevSetVertexShaderConst;
1439 pCreateData->pDeviceFuncs->pfnMultiplyTransform = vboxWddmDDevMultiplyTransform;
1440 pCreateData->pDeviceFuncs->pfnSetTransform = vboxWddmDDevSetTransform;
1441 pCreateData->pDeviceFuncs->pfnSetViewport = vboxWddmDDevSetViewport;
1442 pCreateData->pDeviceFuncs->pfnSetZRange = vboxWddmDDevSetZRange;
1443 pCreateData->pDeviceFuncs->pfnSetMaterial = vboxWddmDDevSetMaterial;
1444 pCreateData->pDeviceFuncs->pfnSetLight = vboxWddmDDevSetLight;
1445 pCreateData->pDeviceFuncs->pfnCreateLight = vboxWddmDDevCreateLight;
1446 pCreateData->pDeviceFuncs->pfnDestroyLight = vboxWddmDDevDestroyLight;
1447 pCreateData->pDeviceFuncs->pfnSetClipPlane = vboxWddmDDevSetClipPlane;
1448 pCreateData->pDeviceFuncs->pfnGetInfo = vboxWddmDDevGetInfo;
1449 pCreateData->pDeviceFuncs->pfnLock = vboxWddmDDevLock;
1450 pCreateData->pDeviceFuncs->pfnUnlock = vboxWddmDDevUnlock;
1451 pCreateData->pDeviceFuncs->pfnCreateResource = vboxWddmDDevCreateResource;
1452 pCreateData->pDeviceFuncs->pfnDestroyResource = vboxWddmDDevDestroyResource;
1453 pCreateData->pDeviceFuncs->pfnSetDisplayMode = vboxWddmDDevSetDisplayMode;
1454 pCreateData->pDeviceFuncs->pfnPresent = vboxWddmDDevPresent;
1455 pCreateData->pDeviceFuncs->pfnFlush = vboxWddmDDevFlush;
1456 pCreateData->pDeviceFuncs->pfnCreateVertexShaderFunc = vboxWddmDDevCreateVertexShaderFunc;
1457 pCreateData->pDeviceFuncs->pfnDeleteVertexShaderFunc = vboxWddmDDevDeleteVertexShaderFunc;
1458 pCreateData->pDeviceFuncs->pfnSetVertexShaderFunc = vboxWddmDDevSetVertexShaderFunc;
1459 pCreateData->pDeviceFuncs->pfnCreateVertexShaderDecl = vboxWddmDDevCreateVertexShaderDecl;
1460 pCreateData->pDeviceFuncs->pfnDeleteVertexShaderDecl = vboxWddmDDevDeleteVertexShaderDecl;
1461 pCreateData->pDeviceFuncs->pfnSetVertexShaderDecl = vboxWddmDDevSetVertexShaderDecl;
1462 pCreateData->pDeviceFuncs->pfnSetVertexShaderConstI = vboxWddmDDevSetVertexShaderConstI;
1463 pCreateData->pDeviceFuncs->pfnSetVertexShaderConstB = vboxWddmDDevSetVertexShaderConstB;
1464 pCreateData->pDeviceFuncs->pfnSetScissorRect = vboxWddmDDevSetScissorRect;
1465 pCreateData->pDeviceFuncs->pfnSetStreamSource = vboxWddmDDevSetStreamSource;
1466 pCreateData->pDeviceFuncs->pfnSetStreamSourceFreq = vboxWddmDDevSetStreamSourceFreq;
1467 pCreateData->pDeviceFuncs->pfnSetConvolutionKernelMono = vboxWddmDDevSetConvolutionKernelMono;
1468 pCreateData->pDeviceFuncs->pfnComposeRects = vboxWddmDDevComposeRects;
1469 pCreateData->pDeviceFuncs->pfnBlt = vboxWddmDDevBlt;
1470 pCreateData->pDeviceFuncs->pfnColorFill = vboxWddmDDevColorFill;
1471 pCreateData->pDeviceFuncs->pfnDepthFill = vboxWddmDDevDepthFill;
1472 pCreateData->pDeviceFuncs->pfnCreateQuery = vboxWddmDDevCreateQuery;
1473 pCreateData->pDeviceFuncs->pfnDestroyQuery = vboxWddmDDevDestroyQuery;
1474 pCreateData->pDeviceFuncs->pfnIssueQuery = vboxWddmDDevIssueQuery;
1475 pCreateData->pDeviceFuncs->pfnGetQueryData = vboxWddmDDevGetQueryData;
1476 pCreateData->pDeviceFuncs->pfnSetRenderTarget = vboxWddmDDevSetRenderTarget;
1477 pCreateData->pDeviceFuncs->pfnSetDepthStencil = vboxWddmDDevSetDepthStencil;
1478 pCreateData->pDeviceFuncs->pfnGenerateMipSubLevels = vboxWddmDDevGenerateMipSubLevels;
1479 pCreateData->pDeviceFuncs->pfnSetPixelShaderConstI = vboxWddmDDevSetPixelShaderConstI;
1480 pCreateData->pDeviceFuncs->pfnSetPixelShaderConstB = vboxWddmDDevSetPixelShaderConstB;
1481 pCreateData->pDeviceFuncs->pfnCreatePixelShader = vboxWddmDDevCreatePixelShader;
1482 pCreateData->pDeviceFuncs->pfnDeletePixelShader = vboxWddmDDevDeletePixelShader;
1483 pCreateData->pDeviceFuncs->pfnCreateDecodeDevice = vboxWddmDDevCreateDecodeDevice;
1484 pCreateData->pDeviceFuncs->pfnDestroyDecodeDevice = vboxWddmDDevDestroyDecodeDevice;
1485 pCreateData->pDeviceFuncs->pfnSetDecodeRenderTarget = vboxWddmDDevSetDecodeRenderTarget;
1486 pCreateData->pDeviceFuncs->pfnDecodeBeginFrame = vboxWddmDDevDecodeBeginFrame;
1487 pCreateData->pDeviceFuncs->pfnDecodeEndFrame = vboxWddmDDevDecodeEndFrame;
1488 pCreateData->pDeviceFuncs->pfnDecodeExecute = vboxWddmDDevDecodeExecute;
1489 pCreateData->pDeviceFuncs->pfnDecodeExtensionExecute = vboxWddmDDevDecodeExtensionExecute;
1490 pCreateData->pDeviceFuncs->pfnCreateVideoProcessDevice = vboxWddmDDevCreateVideoProcessDevice;
1491 pCreateData->pDeviceFuncs->pfnDestroyVideoProcessDevice = vboxWddmDDevDestroyVideoProcessDevice;
1492 pCreateData->pDeviceFuncs->pfnVideoProcessBeginFrame = vboxWddmDDevVideoProcessBeginFrame;
1493 pCreateData->pDeviceFuncs->pfnVideoProcessEndFrame = vboxWddmDDevVideoProcessEndFrame;
1494 pCreateData->pDeviceFuncs->pfnSetVideoProcessRenderTarget = vboxWddmDDevSetVideoProcessRenderTarget;
1495 pCreateData->pDeviceFuncs->pfnVideoProcessBlt = vboxWddmDDevVideoProcessBlt;
1496 pCreateData->pDeviceFuncs->pfnCreateExtensionDevice = vboxWddmDDevCreateExtensionDevice;
1497 pCreateData->pDeviceFuncs->pfnDestroyExtensionDevice = vboxWddmDDevDestroyExtensionDevice;
1498 pCreateData->pDeviceFuncs->pfnExtensionExecute = vboxWddmDDevExtensionExecute;
1499 pCreateData->pDeviceFuncs->pfnCreateOverlay = vboxWddmDDevCreateOverlay;
1500 pCreateData->pDeviceFuncs->pfnUpdateOverlay = vboxWddmDDevUpdateOverlay;
1501 pCreateData->pDeviceFuncs->pfnFlipOverlay = vboxWddmDDevFlipOverlay;
1502 pCreateData->pDeviceFuncs->pfnGetOverlayColorControls = vboxWddmDDevGetOverlayColorControls;
1503 pCreateData->pDeviceFuncs->pfnSetOverlayColorControls = vboxWddmDDevSetOverlayColorControls;
1504 pCreateData->pDeviceFuncs->pfnDestroyOverlay = vboxWddmDDevDestroyOverlay;
1505 pCreateData->pDeviceFuncs->pfnDestroyDevice = vboxWddmDDevDestroyDevice;
1506 pCreateData->pDeviceFuncs->pfnQueryResourceResidency = vboxWddmDDevQueryResourceResidency;
1507 pCreateData->pDeviceFuncs->pfnOpenResource = vboxWddmDDevOpenResource;
1508 pCreateData->pDeviceFuncs->pfnGetCaptureAllocationHandle = vboxWddmDDevGetCaptureAllocationHandle;
1509 pCreateData->pDeviceFuncs->pfnCaptureToSysMem = vboxWddmDDevCaptureToSysMem;
1510 pCreateData->pDeviceFuncs->pfnLockAsync = NULL; //vboxWddmDDevLockAsync;
1511 pCreateData->pDeviceFuncs->pfnUnlockAsync = NULL; //vboxWddmDDevUnlockAsync;
1512 pCreateData->pDeviceFuncs->pfnRename = NULL; //vboxWddmDDevRename;
1513
1514
1515 do
1516 {
1517 if (!pCreateData->AllocationListSize
1518 && !pCreateData->PatchLocationListSize)
1519 {
1520 /* check whether this is a D3D or DDraw, use wine lib only in the former (D3D) case */
1521 /* TODO: is this a correct way to check this ? */
1522 if (pDevice->RtCallbacks.pfnCreateOverlayCb)
1523 {
1524 /* DDraw */
1525 vboxVDbgPrint((__FUNCTION__": DirectDraw Device Created\n"));
1526 break;
1527 }
1528 else
1529 {
1530 /* D3D */
1531 if (pAdapter->pD3D9If)
1532 {
1533 /* */
1534 vboxVDbgPrint((__FUNCTION__": TODO: Implement D3D Device Creation\n"));
1535 break;
1536 }
1537 else
1538 {
1539 /* ballback */
1540 vboxVDbgPrint((__FUNCTION__": D3D Device Being Created, but D3D is unavailable\n"));
1541 break;
1542 }
1543 }
1544 }
1545 else
1546 {
1547 vboxVDbgPrintR((__FUNCTION__": Not implemented: PatchLocationListSize(%d), AllocationListSize(%d)\n",
1548 pCreateData->PatchLocationListSize, pCreateData->AllocationListSize));
1549 //pCreateData->pAllocationList = ??
1550 hr = E_FAIL;
1551 }
1552
1553 RTMemFree(pDevice);
1554 } while (0);
1555 }
1556 else
1557 {
1558 vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
1559 hr = E_OUTOFMEMORY;
1560 }
1561
1562 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
1563
1564 return hr;
1565}
1566
1567static HRESULT APIENTRY vboxWddmDispCloseAdapter (IN HANDLE hAdapter)
1568{
1569 vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
1570
1571// AssertBreakpoint();
1572
1573 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
1574 if (pAdapter->pD3D9If)
1575 {
1576 HRESULT hr = pAdapter->pD3D9If->Release();
1577 Assert(hr == S_OK);
1578 VBoxDispD3DClose(&pAdapter->D3D);
1579 }
1580
1581 RTMemFree(pAdapter);
1582
1583 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
1584
1585 return S_OK;
1586}
1587
1588HRESULT APIENTRY OpenAdapter (__inout D3DDDIARG_OPENADAPTER* pOpenData)
1589{
1590 vboxVDbgPrint(("==> "__FUNCTION__"\n"));
1591
1592 VBOXWDDM_QI Query;
1593 D3DDDICB_QUERYADAPTERINFO DdiQuery;
1594 DdiQuery.PrivateDriverDataSize = sizeof(Query);
1595 DdiQuery.pPrivateDriverData = &Query;
1596 HRESULT hr = pOpenData->pAdapterCallbacks->pfnQueryAdapterInfoCb(pOpenData->hAdapter, &DdiQuery);
1597 Assert(hr == S_OK);
1598 if (hr != S_OK)
1599 {
1600 vboxVDbgPrintR((__FUNCTION__": pfnQueryAdapterInfoCb failed, hr (%d)\n", hr));
1601 return E_FAIL;
1602 }
1603
1604 /* check the miniport version match display version */
1605 if (Query.u32Version != VBOXVIDEOIF_VERSION)
1606 {
1607 vboxVDbgPrintR((__FUNCTION__": miniport version mismatch, expected (%d), but was (%d)\n",
1608 VBOXVIDEOIF_VERSION,
1609 Query.u32Version));
1610 return E_FAIL;
1611 }
1612
1613#ifdef VBOX_WITH_VIDEOHWACCEL
1614 Assert(Query.cInfos >= 1);
1615 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(RT_OFFSETOF(VBOXWDDMDISP_ADAPTER, aHeads[Query.cInfos]));
1616#else
1617 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(sizeof (VBOXWDDMDISP_ADAPTER));
1618#endif
1619 Assert(pAdapter);
1620 if (pAdapter)
1621 {
1622 pAdapter->hAdapter = pOpenData->hAdapter;
1623 pAdapter->uIfVersion = pOpenData->Interface;
1624 pAdapter->uRtVersion= pOpenData->Version;
1625 pAdapter->RtCallbacks = *pOpenData->pAdapterCallbacks;
1626
1627#ifdef VBOX_WITH_VIDEOHWACCEL
1628 pAdapter->cHeads = Query.cInfos;
1629 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
1630 {
1631 pAdapter->aHeads[i].Vhwa.Settings = Query.aInfos[i];
1632 }
1633#endif
1634
1635 pOpenData->hAdapter = pAdapter;
1636 pOpenData->pAdapterFuncs->pfnGetCaps = vboxWddmDispGetCaps;
1637 pOpenData->pAdapterFuncs->pfnCreateDevice = vboxWddmDispCreateDevice;
1638 pOpenData->pAdapterFuncs->pfnCloseAdapter = vboxWddmDispCloseAdapter;
1639 pOpenData->DriverVersion = D3D_UMD_INTERFACE_VERSION;
1640
1641 do
1642 {
1643 /* try enable the 3D */
1644 hr = VBoxDispD3DOpen(&pAdapter->D3D);
1645 Assert(hr == S_OK);
1646 if (hr == S_OK)
1647 {
1648 hr = pAdapter->D3D.pfnDirect3DCreate9Ex(D3D_SDK_VERSION, &pAdapter->pD3D9If);
1649 Assert(hr == S_OK);
1650 if (hr == S_OK)
1651 {
1652 vboxVDbgPrint((__FUNCTION__": SUCCESS 3D Enabled, pAdapter (0x%p)\n", pAdapter));
1653 break;
1654 }
1655 else
1656 vboxVDbgPrintR((__FUNCTION__": pfnDirect3DCreate9Ex failed, hr (%d)\n", hr));
1657
1658 VBoxDispD3DClose(&pAdapter->D3D);
1659 }
1660 else
1661 vboxVDbgPrintR((__FUNCTION__": VBoxDispD3DOpen failed, hr (%d)\n", hr));
1662 } while (0);
1663
1664 vboxFormatOpsInit(pAdapter);
1665 hr = S_OK;
1666// RTMemFree(pAdapter);
1667 }
1668 else
1669 {
1670 vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
1671 hr = E_OUTOFMEMORY;
1672 }
1673
1674 vboxVDbgPrint(("<== "__FUNCTION__", hr (%d)\n", hr));
1675
1676 return hr;
1677}
1678
1679#ifdef VBOXWDDMDISP_DEBUG
1680VOID vboxVDbgDoPrint(LPCSTR szString, ...)
1681{
1682 char szBuffer[1024] = {0};
1683 va_list pArgList;
1684 va_start(pArgList, szString);
1685 _vsnprintf(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]), szString, pArgList);
1686 va_end(pArgList);
1687
1688 OutputDebugStringA(szBuffer);
1689}
1690#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