VirtualBox

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

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

wddm: driver update w/o reboot working; dummy context creation in CreateDevice
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 86.5 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 {D3DDDIFMT_D16_LOCKABLE, FORMATOP_ZSTENCIL|FORMATOP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH, 0, 0, 0},
130 {D3DDDIFMT_X8D24, FORMATOP_TEXTURE|FORMATOP_ZSTENCIL|FORMATOP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH, 0, 0, 0},
131 {D3DDDIFMT_D32F_LOCKABLE, FORMATOP_TEXTURE|FORMATOP_ZSTENCIL|FORMATOP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH, 0, 0, 0},
132 {D3DDDIFMT_S8D24, FORMATOP_TEXTURE|FORMATOP_ZSTENCIL|FORMATOP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH, 0, 0, 0},
133
134 {D3DDDIFMT_DXT1,
135 FORMATOP_TEXTURE|FORMATOP_CUBETEXTURE|
136 0|
137 0|
138 FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
139 0|
140 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
141
142 {D3DDDIFMT_DXT2,
143 FORMATOP_TEXTURE|FORMATOP_CUBETEXTURE|
144 0|
145 0|
146 FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
147 0|
148 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
149
150 {D3DDDIFMT_DXT3,
151 FORMATOP_TEXTURE|FORMATOP_CUBETEXTURE|
152 0|
153 0|
154 FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
155 0|
156 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
157
158 {D3DDDIFMT_DXT4,
159 FORMATOP_TEXTURE|FORMATOP_CUBETEXTURE|
160 0|
161 0|
162 FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
163 0|
164 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
165
166 {D3DDDIFMT_DXT5,
167 FORMATOP_TEXTURE|FORMATOP_CUBETEXTURE|
168 0|
169 0|
170 FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
171 0|
172 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
173
174 {D3DDDIFMT_X8L8V8U8,
175 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
176 0|
177 0|
178 0|
179 FORMATOP_BUMPMAP|
180 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
181
182 {D3DDDIFMT_A2W10V10U10,
183 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
184 0|
185 0|
186 0|
187 FORMATOP_BUMPMAP|
188 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
189
190 {D3DDDIFMT_V8U8,
191 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
192 0|
193 0|
194 0|
195 FORMATOP_BUMPMAP|
196 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
197
198 {D3DDDIFMT_Q8W8V8U8,
199 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
200 0|
201 0|
202 FORMATOP_OFFSCREENPLAIN|
203 FORMATOP_BUMPMAP|
204 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
205
206 {D3DDDIFMT_CxV8U8, FORMATOP_NOFILTER|FORMATOP_NOALPHABLEND|FORMATOP_NOTEXCOORDWRAPNORMIP, 0, 0, 0},
207
208 {D3DDDIFMT_R16F,
209 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
210 FORMATOP_SAME_FORMAT_RENDERTARGET|
211 0|
212 FORMATOP_OFFSCREENPLAIN|
213 0|
214 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
215
216 {D3DDDIFMT_R32F,
217 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
218 FORMATOP_SAME_FORMAT_RENDERTARGET|
219 0|
220 FORMATOP_OFFSCREENPLAIN|
221 0|
222 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
223
224 {D3DDDIFMT_G16R16F,
225 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
226 FORMATOP_SAME_FORMAT_RENDERTARGET|
227 0|
228 FORMATOP_OFFSCREENPLAIN|
229 0|
230 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
231
232 {D3DDDIFMT_G32R32F,
233 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
234 FORMATOP_SAME_FORMAT_RENDERTARGET|
235 0|
236 FORMATOP_OFFSCREENPLAIN|
237 0|
238 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
239
240 {D3DDDIFMT_A16B16G16R16F,
241 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
242 FORMATOP_SAME_FORMAT_RENDERTARGET|
243 0|
244 FORMATOP_OFFSCREENPLAIN|
245 0|
246 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
247
248 {D3DDDIFMT_A32B32G32R32F,
249 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
250 FORMATOP_SAME_FORMAT_RENDERTARGET|
251 0|
252 FORMATOP_OFFSCREENPLAIN|
253 0|
254 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
255
256 {D3DDDIFMT_G16R16,
257 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
258 FORMATOP_SAME_FORMAT_RENDERTARGET|
259 0|
260 FORMATOP_OFFSCREENPLAIN|
261 0|
262 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
263
264 {D3DDDIFMT_A16B16G16R16,
265 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
266 FORMATOP_SAME_FORMAT_RENDERTARGET|
267 0|
268 FORMATOP_OFFSCREENPLAIN|
269 0|
270 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
271
272 {D3DDDIFMT_V16U16,
273 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
274 0|
275 0|
276 0|
277 FORMATOP_BUMPMAP|
278 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
279
280 {D3DDDIFMT_P8, FORMATOP_DISPLAYMODE|FORMATOP_3DACCELERATION|FORMATOP_OFFSCREENPLAIN, 0, 0, 0},
281
282 {D3DDDIFMT_UYVY,
283 0|
284 0|
285 0|
286 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|
287 FORMATOP_NOFILTER|
288 FORMATOP_NOALPHABLEND|
289 FORMATOP_NOTEXCOORDWRAPNORMIP, 0, 0, 0},
290
291 {D3DDDIFMT_YUY2,
292 0|
293 0|
294 0|
295 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|
296 FORMATOP_NOFILTER|
297 FORMATOP_NOALPHABLEND|
298 FORMATOP_NOTEXCOORDWRAPNORMIP, 0, 0, 0},
299
300 {D3DDDIFMT_Q16W16V16U16,
301 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
302 FORMATOP_SAME_FORMAT_RENDERTARGET|
303 0|
304 FORMATOP_OFFSCREENPLAIN|
305 FORMATOP_BUMPMAP|FORMATOP_DMAP|
306 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
307
308 {D3DDDIFMT_X8B8G8R8,
309 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
310 FORMATOP_SAME_FORMAT_RENDERTARGET|
311 FORMATOP_SAME_FORMAT_UP_TO_ALPHA_RENDERTARGET|
312 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
313 FORMATOP_DMAP|FORMATOP_MEMBEROFGROUP_ARGB|
314 FORMATOP_SRGBWRITE|FORMATOP_AUTOGENMIPMAP|FORMATOP_VERTEXTEXTURE|
315 FORMATOP_OVERLAY, 0, 0, 0},
316
317 {D3DDDIFMT_BINARYBUFFER, FORMATOP_OFFSCREENPLAIN, 0, 0, 0},
318
319 {D3DDDIFMT_A4L4,
320 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
321 0|
322 0|
323 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|
324 FORMATOP_DMAP|
325 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
326
327 {D3DDDIFMT_A2B10G10R10,
328 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
329 FORMATOP_SAME_FORMAT_RENDERTARGET|
330 0|
331 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|
332 FORMATOP_DMAP|FORMATOP_MEMBEROFGROUP_ARGB|
333 FORMATOP_AUTOGENMIPMAP|FORMATOP_VERTEXTEXTURE, 0, 0, 0},
334};
335
336static FORMATOP gVBoxFormatOpsBase[] = {
337 {D3DDDIFMT_X8R8G8B8, FORMATOP_DISPLAYMODE, 0, 0, 0},
338
339 {D3DDDIFMT_R8G8B8, FORMATOP_DISPLAYMODE, 0, 0, 0},
340
341 {D3DDDIFMT_R5G6B5, FORMATOP_DISPLAYMODE, 0, 0, 0},
342
343 {D3DDDIFMT_P8, FORMATOP_DISPLAYMODE, 0, 0, 0},
344};
345
346static DDSURFACEDESC gVBoxSurfDescsBase[] = {
347 {
348 sizeof (DDSURFACEDESC), /* DWORD dwSize; */
349 DDSD_CAPS | DDSD_PIXELFORMAT, /* DWORD dwFlags; */
350 0, /* DWORD dwHeight; */
351 0, /* DWORD dwWidth; */
352 {
353 0, /* Union */
354 /* LONG lPitch; */
355 /* DWORD dwLinearSize; */
356 },
357 0, /* DWORD dwBackBufferCount; */
358 {
359 0, /* Union */
360 /* DWORD dwMipMapCount; */
361 /* DWORD dwZBufferBitDepth; */
362 /* DWORD dwRefreshRate; */
363 },
364 0, /* DWORD dwAlphaBitDepth; */
365 0, /* DWORD dwReserved; */
366 NULL, /* LPVOID lpSurface; */
367 {
368 0, /* DWORD dwColorSpaceLowValue; */
369 0, /* DWORD dwColorSpaceHighValue; */
370 }, /* DDCOLORKEY ddckCKDestOverlay; */
371 {
372 0, /* DWORD dwColorSpaceLowValue; */
373 0, /* DWORD dwColorSpaceHighValue; */
374 }, /* DDCOLORKEY ddckCKDestBlt; */
375 {
376 0, /* DWORD dwColorSpaceLowValue; */
377 0, /* DWORD dwColorSpaceHighValue; */
378 }, /* DDCOLORKEY ddckCKSrcOverlay; */
379 {
380 0, /* DWORD dwColorSpaceLowValue; */
381 0, /* DWORD dwColorSpaceHighValue; */
382 }, /* DDCOLORKEY ddckCKSrcBlt; */
383 {
384 sizeof (DDPIXELFORMAT), /* DWORD dwSize; */
385 DDPF_RGB, /* DWORD dwFlags; */
386 0, /* DWORD dwFourCC; */
387 {
388 32, /* union */
389 /* DWORD dwRGBBitCount; */
390 /* DWORD dwYUVBitCount; */
391 /* DWORD dwZBufferBitDepth; */
392 /* DWORD dwAlphaBitDepth; */
393 /* DWORD dwLuminanceBitCount; */
394 /* DWORD dwBumpBitCount; */
395 },
396 {
397 0xff0000, /* union */
398 /* DWORD dwRBitMask; */
399 /* DWORD dwYBitMask; */
400 /* DWORD dwStencilBitDepth; */
401 /* DWORD dwLuminanceBitMask; */
402 /* DWORD dwBumpDuBitMask; */
403 },
404 {
405 0xff00,
406 /* DWORD dwGBitMask; */
407 /* DWORD dwUBitMask; */
408 /* DWORD dwZBitMask; */
409 /* DWORD dwBumpDvBitMask; */
410 },
411 {
412 0xff,
413 /* DWORD dwBBitMask; */
414 /* DWORD dwVBitMask; */
415 /* DWORD dwStencilBitMask; */
416 /* DWORD dwBumpLuminanceBitMask; */
417 },
418 {
419 0,
420 /* DWORD dwRGBAlphaBitMask; */
421 /* DWORD dwYUVAlphaBitMask; */
422 /* DWORD dwLuminanceAlphaBitMask; */
423 /* DWORD dwRGBZBitMask; */
424 /* DWORD dwYUVZBitMask; */
425 },
426 }, /* DDPIXELFORMAT ddpfPixelFormat; */
427 {
428 DDSCAPS_BACKBUFFER
429 | DDSCAPS_COMPLEX
430 | DDSCAPS_FLIP
431 | DDSCAPS_FRONTBUFFER
432 | DDSCAPS_LOCALVIDMEM
433 | DDSCAPS_PRIMARYSURFACE
434 | DDSCAPS_VIDEOMEMORY
435 | DDSCAPS_VISIBLE /* DWORD dwCaps; */
436 } /* DDSCAPS ddsCaps; */
437 },
438 {
439 sizeof (DDSURFACEDESC), /* DWORD dwSize; */
440 DDSD_CAPS | DDSD_PIXELFORMAT, /* DWORD dwFlags; */
441 0, /* DWORD dwHeight; */
442 0, /* DWORD dwWidth; */
443 {
444 0, /* Union */
445 /* LONG lPitch; */
446 /* DWORD dwLinearSize; */
447 },
448 0, /* DWORD dwBackBufferCount; */
449 {
450 0, /* Union */
451 /* DWORD dwMipMapCount; */
452 /* DWORD dwZBufferBitDepth; */
453 /* DWORD dwRefreshRate; */
454 },
455 0, /* DWORD dwAlphaBitDepth; */
456 0, /* DWORD dwReserved; */
457 NULL, /* LPVOID lpSurface; */
458 {
459 0, /* DWORD dwColorSpaceLowValue; */
460 0, /* DWORD dwColorSpaceHighValue; */
461 }, /* DDCOLORKEY ddckCKDestOverlay; */
462 {
463 0, /* DWORD dwColorSpaceLowValue; */
464 0, /* DWORD dwColorSpaceHighValue; */
465 }, /* DDCOLORKEY ddckCKDestBlt; */
466 {
467 0, /* DWORD dwColorSpaceLowValue; */
468 0, /* DWORD dwColorSpaceHighValue; */
469 }, /* DDCOLORKEY ddckCKSrcOverlay; */
470 {
471 0, /* DWORD dwColorSpaceLowValue; */
472 0, /* DWORD dwColorSpaceHighValue; */
473 }, /* DDCOLORKEY ddckCKSrcBlt; */
474 {
475 sizeof (DDPIXELFORMAT), /* DWORD dwSize; */
476 DDPF_RGB, /* DWORD dwFlags; */
477 0, /* DWORD dwFourCC; */
478 {
479 24, /* union */
480 /* DWORD dwRGBBitCount; */
481 /* DWORD dwYUVBitCount; */
482 /* DWORD dwZBufferBitDepth; */
483 /* DWORD dwAlphaBitDepth; */
484 /* DWORD dwLuminanceBitCount; */
485 /* DWORD dwBumpBitCount; */
486 },
487 {
488 0xff0000, /* union */
489 /* DWORD dwRBitMask; */
490 /* DWORD dwYBitMask; */
491 /* DWORD dwStencilBitDepth; */
492 /* DWORD dwLuminanceBitMask; */
493 /* DWORD dwBumpDuBitMask; */
494 },
495 {
496 0xff00,
497 /* DWORD dwGBitMask; */
498 /* DWORD dwUBitMask; */
499 /* DWORD dwZBitMask; */
500 /* DWORD dwBumpDvBitMask; */
501 },
502 {
503 0xff,
504 /* DWORD dwBBitMask; */
505 /* DWORD dwVBitMask; */
506 /* DWORD dwStencilBitMask; */
507 /* DWORD dwBumpLuminanceBitMask; */
508 },
509 {
510 0,
511 /* DWORD dwRGBAlphaBitMask; */
512 /* DWORD dwYUVAlphaBitMask; */
513 /* DWORD dwLuminanceAlphaBitMask; */
514 /* DWORD dwRGBZBitMask; */
515 /* DWORD dwYUVZBitMask; */
516 },
517 }, /* DDPIXELFORMAT ddpfPixelFormat; */
518 {
519 DDSCAPS_BACKBUFFER
520 | DDSCAPS_COMPLEX
521 | DDSCAPS_FLIP
522 | DDSCAPS_FRONTBUFFER
523 | DDSCAPS_LOCALVIDMEM
524 | DDSCAPS_PRIMARYSURFACE
525 | DDSCAPS_VIDEOMEMORY
526 | DDSCAPS_VISIBLE /* DWORD dwCaps; */
527 } /* DDSCAPS ddsCaps; */
528 },
529 {
530 sizeof (DDSURFACEDESC), /* DWORD dwSize; */
531 DDSD_CAPS | DDSD_PIXELFORMAT, /* DWORD dwFlags; */
532 0, /* DWORD dwHeight; */
533 0, /* DWORD dwWidth; */
534 {
535 0, /* Union */
536 /* LONG lPitch; */
537 /* DWORD dwLinearSize; */
538 },
539 0, /* DWORD dwBackBufferCount; */
540 {
541 0, /* Union */
542 /* DWORD dwMipMapCount; */
543 /* DWORD dwZBufferBitDepth; */
544 /* DWORD dwRefreshRate; */
545 },
546 0, /* DWORD dwAlphaBitDepth; */
547 0, /* DWORD dwReserved; */
548 NULL, /* LPVOID lpSurface; */
549 {
550 0, /* DWORD dwColorSpaceLowValue; */
551 0, /* DWORD dwColorSpaceHighValue; */
552 }, /* DDCOLORKEY ddckCKDestOverlay; */
553 {
554 0, /* DWORD dwColorSpaceLowValue; */
555 0, /* DWORD dwColorSpaceHighValue; */
556 }, /* DDCOLORKEY ddckCKDestBlt; */
557 {
558 0, /* DWORD dwColorSpaceLowValue; */
559 0, /* DWORD dwColorSpaceHighValue; */
560 }, /* DDCOLORKEY ddckCKSrcOverlay; */
561 {
562 0, /* DWORD dwColorSpaceLowValue; */
563 0, /* DWORD dwColorSpaceHighValue; */
564 }, /* DDCOLORKEY ddckCKSrcBlt; */
565 {
566 sizeof (DDPIXELFORMAT), /* DWORD dwSize; */
567 DDPF_RGB, /* DWORD dwFlags; */
568 0, /* DWORD dwFourCC; */
569 {
570 16, /* union */
571 /* DWORD dwRGBBitCount; */
572 /* DWORD dwYUVBitCount; */
573 /* DWORD dwZBufferBitDepth; */
574 /* DWORD dwAlphaBitDepth; */
575 /* DWORD dwLuminanceBitCount; */
576 /* DWORD dwBumpBitCount; */
577 },
578 {
579 0xf800, /* union */
580 /* DWORD dwRBitMask; */
581 /* DWORD dwYBitMask; */
582 /* DWORD dwStencilBitDepth; */
583 /* DWORD dwLuminanceBitMask; */
584 /* DWORD dwBumpDuBitMask; */
585 },
586 {
587 0x7e0,
588 /* DWORD dwGBitMask; */
589 /* DWORD dwUBitMask; */
590 /* DWORD dwZBitMask; */
591 /* DWORD dwBumpDvBitMask; */
592 },
593 {
594 0x1f,
595 /* DWORD dwBBitMask; */
596 /* DWORD dwVBitMask; */
597 /* DWORD dwStencilBitMask; */
598 /* DWORD dwBumpLuminanceBitMask; */
599 },
600 {
601 0,
602 /* DWORD dwRGBAlphaBitMask; */
603 /* DWORD dwYUVAlphaBitMask; */
604 /* DWORD dwLuminanceAlphaBitMask; */
605 /* DWORD dwRGBZBitMask; */
606 /* DWORD dwYUVZBitMask; */
607 },
608 }, /* DDPIXELFORMAT ddpfPixelFormat; */
609 {
610 DDSCAPS_BACKBUFFER
611 | DDSCAPS_COMPLEX
612 | DDSCAPS_FLIP
613 | DDSCAPS_FRONTBUFFER
614 | DDSCAPS_LOCALVIDMEM
615 | DDSCAPS_PRIMARYSURFACE
616 | DDSCAPS_VIDEOMEMORY
617 | DDSCAPS_VISIBLE /* DWORD dwCaps; */
618 } /* DDSCAPS ddsCaps; */
619 },
620};
621
622#ifdef VBOX_WITH_VIDEOHWACCEL
623
624static bool vboxVhwaIsEnabled(PVBOXWDDMDISP_ADAPTER pAdapter)
625{
626 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
627 {
628 if (pAdapter->aHeads[i].Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED)
629 return true;
630 }
631 return false;
632}
633
634static bool vboxVhwaHasCKeying(PVBOXWDDMDISP_ADAPTER pAdapter)
635{
636 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
637 {
638 VBOXVHWA_INFO* pSettings = &pAdapter->aHeads[i].Vhwa.Settings;
639 if ((pSettings->fFlags & VBOXVHWA_F_ENABLED)
640 && ((pSettings->fFlags & VBOXVHWA_F_CKEY_DST)
641 || (pSettings->fFlags & VBOXVHWA_F_CKEY_SRC))
642 )
643 return true;
644 }
645 return false;
646}
647
648static void vboxVhwaPopulateOverlayFourccSurfDesc(DDSURFACEDESC *pDesc, uint32_t fourcc)
649{
650 memset(pDesc, 0, sizeof (DDSURFACEDESC));
651
652 pDesc->dwSize = sizeof (DDSURFACEDESC);
653 pDesc->dwFlags = DDSD_CAPS | DDSD_PIXELFORMAT;
654 pDesc->ddpfPixelFormat.dwSize = sizeof (DDPIXELFORMAT);
655 pDesc->ddpfPixelFormat.dwFlags = DDPF_FOURCC;
656 pDesc->ddpfPixelFormat.dwFourCC = fourcc;
657 pDesc->ddsCaps.dwCaps = DDSCAPS_BACKBUFFER
658 | DDSCAPS_COMPLEX
659 | DDSCAPS_FLIP
660 | DDSCAPS_FRONTBUFFER
661 | DDSCAPS_LOCALVIDMEM
662 | DDSCAPS_OVERLAY
663 | DDSCAPS_VIDEOMEMORY
664 | DDSCAPS_VISIBLE;
665}
666
667#endif
668
669static bool vboxPixFormatMatch(DDPIXELFORMAT *pFormat1, DDPIXELFORMAT *pFormat2)
670{
671 return !memcmp(pFormat1, pFormat2, sizeof (DDPIXELFORMAT));
672}
673
674int vboxSurfDescMerge(DDSURFACEDESC *paDescs, uint32_t *pcDescs, uint32_t cMaxDescs, DDSURFACEDESC *pDesc)
675{
676 uint32_t cDescs = *pcDescs;
677
678 Assert(cMaxDescs >= cDescs);
679 Assert(pDesc->dwFlags == (DDSD_CAPS | DDSD_PIXELFORMAT));
680 if (pDesc->dwFlags != (DDSD_CAPS | DDSD_PIXELFORMAT))
681 return VERR_INVALID_PARAMETER;
682
683 for (uint32_t i = 0; i < cDescs; ++i)
684 {
685 DDSURFACEDESC *pCur = &paDescs[i];
686 if (vboxPixFormatMatch(&pCur->ddpfPixelFormat, &pDesc->ddpfPixelFormat))
687 {
688 if (pDesc->dwFlags & DDSD_CAPS)
689 {
690 pCur->dwFlags |= DDSD_CAPS;
691 pCur->ddsCaps.dwCaps |= pDesc->ddsCaps.dwCaps;
692 }
693 return VINF_SUCCESS;
694 }
695 }
696
697 if (cMaxDescs > cDescs)
698 {
699 paDescs[cDescs] = *pDesc;
700 ++cDescs;
701 *pcDescs = cDescs;
702 return VINF_SUCCESS;
703 }
704 return VERR_BUFFER_OVERFLOW;
705}
706
707int vboxFormatOpsMerge(FORMATOP *paOps, uint32_t *pcOps, uint32_t cMaxOps, FORMATOP *pOp)
708{
709 uint32_t cOps = *pcOps;
710
711 Assert(cMaxOps >= cOps);
712
713 for (uint32_t i = 0; i < cOps; ++i)
714 {
715 FORMATOP *pCur = &paOps[i];
716 if (pCur->Format == pOp->Format)
717 {
718 pCur->Operations |= pOp->Operations;
719 Assert(pCur->FlipMsTypes == pOp->FlipMsTypes);
720 Assert(pCur->BltMsTypes == pOp->BltMsTypes);
721 Assert(pCur->PrivateFormatBitCount == pOp->PrivateFormatBitCount);
722 return VINF_SUCCESS;
723 }
724 }
725
726 if (cMaxOps > cOps)
727 {
728 paOps[cOps] = *pOp;
729 ++cOps;
730 *pcOps = cOps;
731 return VINF_SUCCESS;
732 }
733 return VERR_BUFFER_OVERFLOW;
734}
735
736static uint32_t vboxFormatToFourcc(D3DDDIFORMAT format)
737{
738 uint32_t uFormat = (uint32_t)format;
739 /* assume that in case both four bytes are non-zero, this is a fourcc */
740 if ((format & 0xff000000)
741 && (format & 0x00ff0000)
742 && (format & 0x0000ff00)
743 && (format & 0x000000ff)
744 )
745 return uFormat;
746 return 0;
747}
748
749int vboxCapsInit(PVBOXWDDMDISP_ADAPTER pAdapter)
750{
751 pAdapter->cFormstOps = 0;
752 pAdapter->paFormstOps = NULL;
753 pAdapter->cSurfDescs = 0;
754 pAdapter->paSurfDescs = NULL;
755
756 if (pAdapter->uIfVersion > 7)
757 {
758 if (pAdapter->pD3D9If)
759 {
760 pAdapter->paFormstOps = (FORMATOP*)RTMemAllocZ(sizeof (gVBoxFormatOps3D));
761 Assert(pAdapter->paFormstOps);
762 if (pAdapter->paFormstOps)
763 {
764 memcpy (pAdapter->paFormstOps , gVBoxFormatOps3D, sizeof (gVBoxFormatOps3D));
765 pAdapter->cFormstOps = RT_ELEMENTS(gVBoxFormatOps3D);
766 }
767 else
768 return VERR_OUT_OF_RESOURCES;
769
770 /* @todo: do we need surface caps here ? */
771 }
772 }
773#ifdef VBOX_WITH_VIDEOHWACCEL
774 else
775 {
776 /* just calc the max number of formats */
777 uint32_t cFormats = RT_ELEMENTS(gVBoxFormatOpsBase);
778 uint32_t cSurfDescs = RT_ELEMENTS(gVBoxSurfDescsBase);
779 uint32_t cOverlayFormats = 0;
780 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
781 {
782 VBOXDISPVHWA_INFO *pVhwa = &pAdapter->aHeads[i].Vhwa;
783 if (pVhwa->Settings.fFlags & VBOXVHWA_F_ENABLED)
784 {
785 cOverlayFormats += pVhwa->Settings.cFormats;
786 }
787 }
788
789 cFormats += cOverlayFormats;
790 cSurfDescs += cOverlayFormats;
791
792 uint32_t cbFormatOps = cFormats * sizeof (FORMATOP);
793 cbFormatOps = (cbFormatOps + 7) & ~3;
794 /* ensure the surf descs are 8 byte alligned */
795 uint32_t offSurfDescs = (cbFormatOps + 7) & ~3;
796 uint32_t cbSurfDescs = cSurfDescs * sizeof (DDSURFACEDESC);
797 uint32_t cbBuf = offSurfDescs + cbSurfDescs;
798 uint8_t* pvBuf = (uint8_t*)RTMemAllocZ(cbBuf);
799 Assert(pvBuf);
800 if (pvBuf)
801 {
802 pAdapter->paFormstOps = (FORMATOP*)pvBuf;
803 memcpy (pAdapter->paFormstOps , gVBoxFormatOpsBase, sizeof (gVBoxFormatOpsBase));
804 pAdapter->cFormstOps = RT_ELEMENTS(gVBoxFormatOpsBase);
805
806 FORMATOP fo = {D3DDDIFMT_UNKNOWN, 0, 0, 0, 0};
807 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
808 {
809 VBOXDISPVHWA_INFO *pVhwa = &pAdapter->aHeads[i].Vhwa;
810 if (pVhwa->Settings.fFlags & VBOXVHWA_F_ENABLED)
811 {
812 for (uint32_t j = 0; j < pVhwa->Settings.cFormats; ++j)
813 {
814 fo.Format = pVhwa->Settings.aFormats[j];
815 fo.Operations = FORMATOP_OVERLAY;
816 int rc = vboxFormatOpsMerge(pAdapter->paFormstOps, &pAdapter->cFormstOps, cFormats, &fo);
817 AssertRC(rc);
818 }
819 }
820 }
821
822 pAdapter->paSurfDescs = (DDSURFACEDESC*)(pvBuf + offSurfDescs);
823 memcpy (pAdapter->paSurfDescs , gVBoxSurfDescsBase, sizeof (gVBoxSurfDescsBase));
824 pAdapter->cSurfDescs = RT_ELEMENTS(gVBoxSurfDescsBase);
825
826 DDSURFACEDESC sd;
827 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
828 {
829 VBOXDISPVHWA_INFO *pVhwa = &pAdapter->aHeads[i].Vhwa;
830 if (pVhwa->Settings.fFlags & VBOXVHWA_F_ENABLED)
831 {
832 for (uint32_t j = 0; j < pVhwa->Settings.cFormats; ++j)
833 {
834 uint32_t fourcc = vboxFormatToFourcc(pVhwa->Settings.aFormats[j]);
835 if (fourcc)
836 {
837 vboxVhwaPopulateOverlayFourccSurfDesc(&sd, fourcc);
838 int rc = vboxSurfDescMerge(pAdapter->paSurfDescs, &pAdapter->cSurfDescs, cSurfDescs, &sd);
839 AssertRC(rc);
840 }
841 }
842 }
843 }
844 }
845 else
846 return VERR_OUT_OF_RESOURCES;
847 }
848#endif
849
850 return VINF_SUCCESS;
851}
852
853void vboxCapsFree(PVBOXWDDMDISP_ADAPTER pAdapter)
854{
855 if (pAdapter->paFormstOps)
856 RTMemFree(pAdapter->paFormstOps);
857}
858
859/**
860 * DLL entry point.
861 */
862BOOL WINAPI DllMain(HINSTANCE hInstance,
863 DWORD dwReason,
864 LPVOID lpReserved)
865{
866 switch (dwReason)
867 {
868 case DLL_PROCESS_ATTACH:
869 {
870 RTR3Init();
871
872 vboxVDbgPrint(("VBoxDispD3D: DLL loaded.\n"));
873
874// VbglR3Init();
875 break;
876 }
877
878 case DLL_PROCESS_DETACH:
879 {
880 vboxVDbgPrint(("VBoxDispD3D: DLL unloaded.\n"));
881// VbglR3Term();
882 /// @todo RTR3Term();
883 break;
884 }
885
886 default:
887 break;
888 }
889 return TRUE;
890}
891
892static HRESULT APIENTRY vboxWddmDispGetCaps (HANDLE hAdapter, CONST D3DDDIARG_GETCAPS* pData)
893{
894 vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p), caps type(%d)\n", hAdapter, pData->Type));
895
896 HRESULT hr = S_OK;
897 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
898
899 switch (pData->Type)
900 {
901 case D3DDDICAPS_DDRAW:
902 {
903 Assert(pData->DataSize >= sizeof (DDRAW_CAPS));
904 if (pData->DataSize >= sizeof (DDRAW_CAPS))
905 {
906 memset(pData->pData, 0, sizeof (DDRAW_CAPS));
907#ifdef VBOX_WITH_VIDEOHWACCEL
908 if (vboxVhwaHasCKeying(pAdapter))
909 {
910 DDRAW_CAPS *pCaps = (DDRAW_CAPS*)pData->pData;
911 pCaps->Caps |= DDRAW_CAPS_COLORKEY
912 | DDRAW_CAPS2_DYNAMICTEXTURES
913 | DDRAW_CAPS2_FLIPNOVSYNC
914 ;
915 }
916#endif
917 }
918 else
919 hr = E_INVALIDARG;
920 break;
921 }
922 case D3DDDICAPS_DDRAW_MODE_SPECIFIC:
923 {
924 Assert(pData->DataSize >= sizeof (DDRAW_MODE_SPECIFIC_CAPS));
925 if (pData->DataSize >= sizeof (DDRAW_MODE_SPECIFIC_CAPS))
926 {
927 DDRAW_MODE_SPECIFIC_CAPS * pCaps = (DDRAW_MODE_SPECIFIC_CAPS*)pData->pData;
928 memset(&pCaps->Caps /* do not cleanup the first "Head" field,
929 zero starting with the one following "Head", i.e. Caps */,
930 0, sizeof (DDRAW_MODE_SPECIFIC_CAPS) - RT_OFFSETOF(DDRAW_MODE_SPECIFIC_CAPS, Caps));
931#ifdef VBOX_WITH_VIDEOHWACCEL
932 VBOXVHWA_INFO *pSettings = &pAdapter->aHeads[pCaps->Head].Vhwa.Settings;
933 if (pSettings->fFlags & VBOXVHWA_F_ENABLED)
934 {
935 pCaps->Caps |= MODE_CAPS_OVERLAY | MODE_CAPS_OVERLAYSTRETCH;
936
937 if (pSettings->fFlags & VBOXVHWA_F_CKEY_DST)
938 {
939 pCaps->CKeyCaps |= MODE_CKEYCAPS_DESTOVERLAY
940 | MODE_CKEYCAPS_DESTOVERLAYYUV /* ?? */
941 ;
942 }
943
944 if (pSettings->fFlags & VBOXVHWA_F_CKEY_SRC)
945 {
946 pCaps->CKeyCaps |= MODE_CKEYCAPS_SRCOVERLAY
947 | MODE_CKEYCAPS_SRCOVERLAYCLRSPACE /* ?? */
948 | MODE_CKEYCAPS_SRCOVERLAYCLRSPACEYUV /* ?? */
949 | MODE_CKEYCAPS_SRCOVERLAYYUV /* ?? */
950 ;
951 }
952
953 pCaps->FxCaps = MODE_FXCAPS_OVERLAYSHRINKX
954 | MODE_FXCAPS_OVERLAYSHRINKY
955 | MODE_FXCAPS_OVERLAYSTRETCHX
956 | MODE_FXCAPS_OVERLAYSTRETCHY;
957
958
959 pCaps->MaxVisibleOverlays = pSettings->cOverlaysSupported;
960 pCaps->MinOverlayStretch = 1;
961 pCaps->MaxOverlayStretch = 32000;
962 }
963#endif
964 }
965 else
966 hr = E_INVALIDARG;
967 break;
968 }
969 case D3DDDICAPS_GETFORMATCOUNT:
970 *((uint32_t*)pData->pData) = pAdapter->cFormstOps;
971 break;
972 case D3DDDICAPS_GETFORMATDATA:
973 Assert(pData->DataSize >= pAdapter->cFormstOps * sizeof (FORMATOP));
974 memcpy(pData->pData, pAdapter->paFormstOps, pAdapter->cFormstOps * sizeof (FORMATOP));
975 break;
976 case D3DDDICAPS_GETD3DQUERYCOUNT:
977 *((uint32_t*)pData->pData) = 0;//VBOX_QUERYTYPE_COUNT();
978 break;
979 case D3DDDICAPS_GETD3DQUERYDATA:
980 AssertBreakpoint();
981 memset(pData->pData, 0, pData->DataSize);
982// Assert(pData->DataSize >= VBOX_QUERYTYPE_COUNT() * sizeof (D3DDDIQUERYTYPE));
983// memcpy(pData->pData, gVBoxQueryTypes, VBOX_QUERYTYPE_COUNT() * sizeof (D3DDDIQUERYTYPE));
984 break;
985 case D3DDDICAPS_GETD3D3CAPS:
986 Assert(pData->DataSize >= sizeof (D3DHAL_GLOBALDRIVERDATA));
987 if (pData->DataSize >= sizeof (D3DHAL_GLOBALDRIVERDATA))
988 {
989 D3DHAL_GLOBALDRIVERDATA *pCaps = (D3DHAL_GLOBALDRIVERDATA *)pData->pData;
990 memset (pCaps, 0, sizeof (D3DHAL_GLOBALDRIVERDATA));
991 pCaps->dwSize = sizeof (D3DHAL_GLOBALDRIVERDATA);
992 pCaps->hwCaps.dwSize = sizeof (D3DDEVICEDESC_V1);
993 pCaps->hwCaps.dwFlags = D3DDD_COLORMODEL
994 | D3DDD_DEVCAPS
995 | D3DDD_DEVICERENDERBITDEPTH;
996
997 pCaps->hwCaps.dcmColorModel = D3DCOLOR_RGB;
998 pCaps->hwCaps.dwDevCaps = D3DDEVCAPS_CANRENDERAFTERFLIP
999 | D3DDEVCAPS_DRAWPRIMTLVERTEX
1000 | D3DDEVCAPS_EXECUTESYSTEMMEMORY
1001 | D3DDEVCAPS_FLOATTLVERTEX
1002 | D3DDEVCAPS_HWRASTERIZATION
1003 | D3DDEVCAPS_HWTRANSFORMANDLIGHT
1004 | D3DDEVCAPS_TLVERTEXSYSTEMMEMORY
1005 | D3DDEVCAPS_TEXTUREVIDEOMEMORY;
1006 pCaps->hwCaps.dtcTransformCaps.dwSize = sizeof (D3DTRANSFORMCAPS);
1007 pCaps->hwCaps.dtcTransformCaps.dwCaps = 0;
1008 pCaps->hwCaps.bClipping = FALSE;
1009 pCaps->hwCaps.dlcLightingCaps.dwSize = sizeof (D3DLIGHTINGCAPS);
1010 pCaps->hwCaps.dlcLightingCaps.dwCaps = 0;
1011 pCaps->hwCaps.dlcLightingCaps.dwLightingModel = 0;
1012 pCaps->hwCaps.dlcLightingCaps.dwNumLights = 0;
1013 pCaps->hwCaps.dpcLineCaps.dwSize = sizeof (D3DPRIMCAPS);
1014 pCaps->hwCaps.dpcLineCaps.dwMiscCaps = 0;
1015 pCaps->hwCaps.dpcLineCaps.dwRasterCaps = 0;
1016 pCaps->hwCaps.dpcLineCaps.dwZCmpCaps = 0;
1017 pCaps->hwCaps.dpcLineCaps.dwSrcBlendCaps = 0;
1018 pCaps->hwCaps.dpcLineCaps.dwDestBlendCaps = 0;
1019 pCaps->hwCaps.dpcLineCaps.dwAlphaCmpCaps = 0;
1020 pCaps->hwCaps.dpcLineCaps.dwShadeCaps = 0;
1021 pCaps->hwCaps.dpcLineCaps.dwTextureCaps = 0;
1022 pCaps->hwCaps.dpcLineCaps.dwTextureFilterCaps = 0;
1023 pCaps->hwCaps.dpcLineCaps.dwTextureBlendCaps = 0;
1024 pCaps->hwCaps.dpcLineCaps.dwTextureAddressCaps = 0;
1025 pCaps->hwCaps.dpcLineCaps.dwStippleWidth = 0;
1026 pCaps->hwCaps.dpcLineCaps.dwStippleHeight = 0;
1027
1028 pCaps->hwCaps.dpcTriCaps.dwSize = sizeof (D3DPRIMCAPS);
1029 pCaps->hwCaps.dpcTriCaps.dwMiscCaps = 0;
1030 pCaps->hwCaps.dpcTriCaps.dwRasterCaps = 0;
1031 pCaps->hwCaps.dpcTriCaps.dwZCmpCaps = 0;
1032 pCaps->hwCaps.dpcTriCaps.dwSrcBlendCaps = 0;
1033 pCaps->hwCaps.dpcTriCaps.dwDestBlendCaps = 0;
1034 pCaps->hwCaps.dpcTriCaps.dwAlphaCmpCaps = 0;
1035 pCaps->hwCaps.dpcTriCaps.dwShadeCaps = 0;
1036 pCaps->hwCaps.dpcTriCaps.dwTextureCaps = 0;
1037 pCaps->hwCaps.dpcTriCaps.dwTextureFilterCaps = 0;
1038 pCaps->hwCaps.dpcTriCaps.dwTextureBlendCaps = 0;
1039 pCaps->hwCaps.dpcTriCaps.dwTextureAddressCaps = 0;
1040 pCaps->hwCaps.dpcTriCaps.dwStippleWidth = 0;
1041 pCaps->hwCaps.dpcTriCaps.dwStippleHeight = 0;
1042 pCaps->hwCaps.dwDeviceRenderBitDepth = 0;
1043 pCaps->hwCaps.dwDeviceZBufferBitDepth = DDBD_8 | DDBD_16 | DDBD_24 | DDBD_32;
1044 pCaps->hwCaps.dwMaxBufferSize = 0;
1045 pCaps->hwCaps.dwMaxVertexCount = 0;
1046
1047
1048 pCaps->dwNumVertices = 0;
1049 pCaps->dwNumClipVertices = 0;
1050 pCaps->dwNumTextureFormats = pAdapter->cSurfDescs;
1051 pCaps->lpTextureFormats = pAdapter->paSurfDescs;
1052 }
1053 else
1054 hr = E_INVALIDARG;
1055 break;
1056 case D3DDDICAPS_GETD3D7CAPS:
1057 Assert(pData->DataSize >= sizeof (D3DHAL_D3DEXTENDEDCAPS));
1058 if (pData->DataSize >= sizeof (D3DHAL_D3DEXTENDEDCAPS))
1059 memset(pData->pData, 0, sizeof (D3DHAL_D3DEXTENDEDCAPS));
1060 else
1061 hr = E_INVALIDARG;
1062 break;
1063 case D3DDDICAPS_GETD3D9CAPS:
1064 {
1065 Assert(pData->DataSize >= sizeof (D3DCAPS9));
1066 if (pData->DataSize >= sizeof (D3DCAPS9))
1067 {
1068 if (pAdapter->pD3D9If)
1069 {
1070 hr = pAdapter->pD3D9If->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, (D3DCAPS9*)pData->pData);
1071 Assert(hr == S_OK);
1072 if (hr == S_OK)
1073 break;
1074
1075 vboxVDbgPrintR((__FUNCTION__": GetDeviceCaps hr(%d)\n", hr));
1076 /* let's fall back to the 3D disabled case */
1077 hr = S_OK;
1078 }
1079
1080 memset(pData->pData, 0, sizeof (D3DCAPS9));
1081 }
1082 else
1083 hr = E_INVALIDARG;
1084 break;
1085 }
1086 case D3DDDICAPS_GETGAMMARAMPCAPS:
1087 *((uint32_t*)pData->pData) = 0;
1088 break;
1089 case D3DDDICAPS_GETMULTISAMPLEQUALITYLEVELS:
1090 case D3DDDICAPS_GETD3D5CAPS:
1091 case D3DDDICAPS_GETD3D6CAPS:
1092 case D3DDDICAPS_GETD3D8CAPS:
1093 case D3DDDICAPS_GETDECODEGUIDCOUNT:
1094 case D3DDDICAPS_GETDECODEGUIDS:
1095 case D3DDDICAPS_GETDECODERTFORMATCOUNT:
1096 case D3DDDICAPS_GETDECODERTFORMATS:
1097 case D3DDDICAPS_GETDECODECOMPRESSEDBUFFERINFOCOUNT:
1098 case D3DDDICAPS_GETDECODECOMPRESSEDBUFFERINFO:
1099 case D3DDDICAPS_GETDECODECONFIGURATIONCOUNT:
1100 case D3DDDICAPS_GETDECODECONFIGURATIONS:
1101 case D3DDDICAPS_GETVIDEOPROCESSORDEVICEGUIDCOUNT:
1102 case D3DDDICAPS_GETVIDEOPROCESSORDEVICEGUIDS:
1103 case D3DDDICAPS_GETVIDEOPROCESSORRTFORMATCOUNT:
1104 case D3DDDICAPS_GETVIDEOPROCESSORRTFORMATS:
1105 case D3DDDICAPS_GETVIDEOPROCESSORRTSUBSTREAMFORMATCOUNT:
1106 case D3DDDICAPS_GETVIDEOPROCESSORRTSUBSTREAMFORMATS:
1107 case D3DDDICAPS_GETVIDEOPROCESSORCAPS:
1108 case D3DDDICAPS_GETPROCAMPRANGE:
1109 case D3DDDICAPS_FILTERPROPERTYRANGE:
1110 case D3DDDICAPS_GETEXTENSIONGUIDCOUNT:
1111 case D3DDDICAPS_GETEXTENSIONGUIDS:
1112 case D3DDDICAPS_GETEXTENSIONCAPS:
1113 vboxVDbgPrint((__FUNCTION__": unimplemented caps type(%d)\n", pData->Type));
1114 AssertBreakpoint();
1115 if (pData->pData && pData->DataSize)
1116 memset(pData->pData, 0, pData->DataSize);
1117 break;
1118 default:
1119 vboxVDbgPrint((__FUNCTION__": unknown caps type(%d)\n", pData->Type));
1120 AssertBreakpoint();
1121 }
1122
1123 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p), caps type(%d)\n", hAdapter, pData->Type));
1124
1125 return S_OK;
1126}
1127
1128static HRESULT APIENTRY vboxWddmDDevSetRenderState(HANDLE hDevice, CONST D3DDDIARG_RENDERSTATE* pData)
1129{
1130 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1131 AssertBreakpoint();
1132 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1133 return E_FAIL;
1134}
1135
1136static HRESULT APIENTRY vboxWddmDDevUpdateWInfo(HANDLE hDevice, CONST D3DDDIARG_WINFO* pData)
1137{
1138 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1139 AssertBreakpoint();
1140 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1141 return E_FAIL;
1142}
1143
1144static HRESULT APIENTRY vboxWddmDDevValidateDevice(HANDLE hDevice, D3DDDIARG_VALIDATETEXTURESTAGESTATE* pData)
1145{
1146 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1147 AssertBreakpoint();
1148 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1149 return E_FAIL;
1150}
1151
1152static HRESULT APIENTRY vboxWddmDDevSetTextureStageState(HANDLE hDevice, CONST D3DDDIARG_TEXTURESTAGESTATE* pData)
1153{
1154 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1155 AssertBreakpoint();
1156 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1157 return E_FAIL;
1158}
1159
1160static HRESULT APIENTRY vboxWddmDDevSetTexture(HANDLE hDevice, UINT Stage, HANDLE hTexture)
1161{
1162 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1163 AssertBreakpoint();
1164 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1165 return E_FAIL;
1166}
1167
1168static HRESULT APIENTRY vboxWddmDDevSetPixelShader(HANDLE hDevice, HANDLE hShaderHandle)
1169{
1170 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1171 AssertBreakpoint();
1172 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1173 return E_FAIL;
1174}
1175
1176static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONST* pData, CONST FLOAT* pRegisters)
1177{
1178 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1179 AssertBreakpoint();
1180 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1181 return E_FAIL;
1182}
1183
1184static HRESULT APIENTRY vboxWddmDDevSetStreamSourceUm(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEUM* pData, CONST VOID* pUMBuffer )
1185{
1186 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1187 AssertBreakpoint();
1188 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1189 return E_FAIL;
1190}
1191
1192static HRESULT APIENTRY vboxWddmDDevSetIndices(HANDLE hDevice, CONST D3DDDIARG_SETINDICES* pData)
1193{
1194 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1195 AssertBreakpoint();
1196 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1197 return E_FAIL;
1198}
1199
1200static HRESULT APIENTRY vboxWddmDDevSetIndicesUm(HANDLE hDevice, UINT IndexSize, CONST VOID* pUMBuffer)
1201{
1202 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1203 AssertBreakpoint();
1204 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1205 return E_FAIL;
1206}
1207
1208static HRESULT APIENTRY vboxWddmDDevDrawPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE* pData, CONST UINT* pFlagBuffer)
1209{
1210 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1211 AssertBreakpoint();
1212 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1213 return E_FAIL;
1214}
1215
1216static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE* pData)
1217{
1218 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1219 AssertBreakpoint();
1220 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1221 return E_FAIL;
1222}
1223
1224static HRESULT APIENTRY vboxWddmDDevDrawRectPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWRECTPATCH* pData, CONST D3DDDIRECTPATCH_INFO* pInfo, CONST FLOAT* pPatch)
1225{
1226 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1227 AssertBreakpoint();
1228 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1229 return E_FAIL;
1230}
1231
1232static HRESULT APIENTRY vboxWddmDDevDrawTriPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWTRIPATCH* pData, CONST D3DDDITRIPATCH_INFO* pInfo, CONST FLOAT* pPatch)
1233{
1234 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1235 AssertBreakpoint();
1236 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1237 return E_FAIL;
1238}
1239
1240static HRESULT APIENTRY vboxWddmDDevDrawPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE2* pData)
1241{
1242 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1243 AssertBreakpoint();
1244 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1245 return E_FAIL;
1246}
1247
1248static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE2* pData, UINT dwIndicesSize, CONST VOID* pIndexBuffer, CONST UINT* pFlagBuffer)
1249{
1250 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1251 AssertBreakpoint();
1252 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1253 return E_FAIL;
1254}
1255
1256static HRESULT APIENTRY vboxWddmDDevVolBlt(HANDLE hDevice, CONST D3DDDIARG_VOLUMEBLT* pData)
1257{
1258 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1259 AssertBreakpoint();
1260 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1261 return E_FAIL;
1262}
1263
1264static HRESULT APIENTRY vboxWddmDDevBufBlt(HANDLE hDevice, CONST D3DDDIARG_BUFFERBLT* pData)
1265{
1266 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1267 AssertBreakpoint();
1268 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1269 return E_FAIL;
1270}
1271
1272static HRESULT APIENTRY vboxWddmDDevTexBlt(HANDLE hDevice, CONST D3DDDIARG_TEXBLT* pData)
1273{
1274 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1275 AssertBreakpoint();
1276 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1277 return E_FAIL;
1278}
1279
1280static HRESULT APIENTRY vboxWddmDDevStateSet(HANDLE hDevice, D3DDDIARG_STATESET* 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 vboxWddmDDevSetPriority(HANDLE hDevice, CONST D3DDDIARG_SETPRIORITY* 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 vboxWddmDDevClear(HANDLE hDevice, CONST D3DDDIARG_CLEAR* pData, UINT NumRect, CONST RECT* pRect)
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 vboxWddmDDevUpdatePalette(HANDLE hDevice, CONST D3DDDIARG_UPDATEPALETTE* pData, CONST PALETTEENTRY* pPaletteData)
1302{
1303 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1304 AssertBreakpoint();
1305 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1306 return E_FAIL;
1307}
1308
1309static HRESULT APIENTRY vboxWddmDDevSetPalette(HANDLE hDevice, CONST D3DDDIARG_SETPALETTE* pData)
1310{
1311 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1312 AssertBreakpoint();
1313 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1314 return E_FAIL;
1315}
1316
1317static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONST* pData , CONST VOID* pRegisters)
1318{
1319 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1320 AssertBreakpoint();
1321 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1322 return E_FAIL;
1323}
1324static HRESULT APIENTRY vboxWddmDDevMultiplyTransform(HANDLE hDevice, CONST D3DDDIARG_MULTIPLYTRANSFORM* pData)
1325{
1326 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1327 AssertBreakpoint();
1328 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1329 return E_FAIL;
1330}
1331static HRESULT APIENTRY vboxWddmDDevSetTransform(HANDLE hDevice, CONST D3DDDIARG_SETTRANSFORM* pData)
1332{
1333 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1334 AssertBreakpoint();
1335 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1336 return E_FAIL;
1337}
1338static HRESULT APIENTRY vboxWddmDDevSetViewport(HANDLE hDevice, CONST D3DDDIARG_VIEWPORTINFO* pData)
1339{
1340 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1341 AssertBreakpoint();
1342 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1343 return E_FAIL;
1344}
1345static HRESULT APIENTRY vboxWddmDDevSetZRange(HANDLE hDevice, CONST D3DDDIARG_ZRANGE* pData)
1346{
1347 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1348 AssertBreakpoint();
1349 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1350 return E_FAIL;
1351}
1352static HRESULT APIENTRY vboxWddmDDevSetMaterial(HANDLE hDevice, CONST D3DDDIARG_SETMATERIAL* pData)
1353{
1354 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1355 AssertBreakpoint();
1356 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1357 return E_FAIL;
1358}
1359static HRESULT APIENTRY vboxWddmDDevSetLight(HANDLE hDevice, CONST D3DDDIARG_SETLIGHT* pData, CONST D3DDDI_LIGHT* pLightProperties)
1360{
1361 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1362 AssertBreakpoint();
1363 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1364 return E_FAIL;
1365}
1366static HRESULT APIENTRY vboxWddmDDevCreateLight(HANDLE hDevice, CONST D3DDDIARG_CREATELIGHT* pData)
1367{
1368 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1369 AssertBreakpoint();
1370 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1371 return E_FAIL;
1372}
1373static HRESULT APIENTRY vboxWddmDDevDestroyLight(HANDLE hDevice, CONST D3DDDIARG_DESTROYLIGHT* pData)
1374{
1375 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1376 AssertBreakpoint();
1377 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1378 return E_FAIL;
1379}
1380static HRESULT APIENTRY vboxWddmDDevSetClipPlane(HANDLE hDevice, CONST D3DDDIARG_SETCLIPPLANE* 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 vboxWddmDDevGetInfo(HANDLE hDevice, UINT DevInfoID, VOID* pDevInfoStruct, UINT DevInfoSize)
1389{
1390 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1391 AssertBreakpoint();
1392 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1393 return E_NOTIMPL;
1394}
1395
1396static HRESULT APIENTRY vboxWddmDDevLock(HANDLE hDevice, D3DDDIARG_LOCK* pData)
1397{
1398 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1399 AssertBreakpoint();
1400 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1401 return E_FAIL;
1402}
1403static HRESULT APIENTRY vboxWddmDDevUnlock(HANDLE hDevice, CONST D3DDDIARG_UNLOCK* pData)
1404{
1405 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1406 AssertBreakpoint();
1407 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1408 return E_FAIL;
1409}
1410static HRESULT APIENTRY vboxWddmDDevLockAsync(HANDLE hDevice, D3DDDIARG_LOCKASYNC* pData)
1411{
1412 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1413 AssertBreakpoint();
1414 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1415 return E_FAIL;
1416}
1417static HRESULT APIENTRY vboxWddmDDevUnlockAsync(HANDLE hDevice, CONST D3DDDIARG_UNLOCKASYNC* pData)
1418{
1419 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1420 AssertBreakpoint();
1421 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1422 return E_FAIL;
1423}
1424static HRESULT APIENTRY vboxWddmDDevRename(HANDLE hDevice, CONST D3DDDIARG_RENAME* pData)
1425{
1426 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1427 AssertBreakpoint();
1428 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1429 return E_FAIL;
1430}
1431static HRESULT APIENTRY vboxWddmDDevCreateResource(HANDLE hDevice, D3DDDIARG_CREATERESOURCE* pResource)
1432{
1433 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1434 AssertBreakpoint();
1435 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1436 return E_FAIL;
1437}
1438static HRESULT APIENTRY vboxWddmDDevDestroyResource(HANDLE hDevice, HANDLE hResource)
1439{
1440 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1441 AssertBreakpoint();
1442 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1443 return E_FAIL;
1444}
1445static HRESULT APIENTRY vboxWddmDDevSetDisplayMode(HANDLE hDevice, CONST D3DDDIARG_SETDISPLAYMODE* pData)
1446{
1447 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1448 AssertBreakpoint();
1449 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1450 return E_FAIL;
1451}
1452static HRESULT APIENTRY vboxWddmDDevPresent(HANDLE hDevice, CONST D3DDDIARG_PRESENT* pData)
1453{
1454 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1455 AssertBreakpoint();
1456 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1457 return E_FAIL;
1458}
1459static HRESULT APIENTRY vboxWddmDDevFlush(HANDLE hDevice)
1460{
1461 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1462 AssertBreakpoint();
1463 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1464 return E_FAIL;
1465}
1466static HRESULT APIENTRY vboxWddmDDevCreateVertexShaderDecl(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERDECL* pData, CONST D3DDDIVERTEXELEMENT* pVertexElements)
1467{
1468 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1469 AssertBreakpoint();
1470 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1471 return E_FAIL;
1472}
1473static HRESULT APIENTRY vboxWddmDDevSetVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
1474{
1475 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1476 AssertBreakpoint();
1477 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1478 return E_FAIL;
1479}
1480static HRESULT APIENTRY vboxWddmDDevDeleteVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
1481{
1482 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1483 AssertBreakpoint();
1484 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1485 return E_FAIL;
1486}
1487static HRESULT APIENTRY vboxWddmDDevCreateVertexShaderFunc(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERFUNC* pData, CONST UINT* pCode)
1488{
1489 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1490 AssertBreakpoint();
1491 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1492 return E_FAIL;
1493}
1494static HRESULT APIENTRY vboxWddmDDevSetVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
1495{
1496 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1497 AssertBreakpoint();
1498 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1499 return E_FAIL;
1500}
1501static HRESULT APIENTRY vboxWddmDDevDeleteVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
1502{
1503 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1504 AssertBreakpoint();
1505 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1506 return E_FAIL;
1507}
1508static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTI* pData, CONST INT* pRegisters)
1509{
1510 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1511 AssertBreakpoint();
1512 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1513 return E_FAIL;
1514}
1515static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTB* pData, CONST BOOL* pRegisters)
1516{
1517 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1518 AssertBreakpoint();
1519 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1520 return E_FAIL;
1521}
1522static HRESULT APIENTRY vboxWddmDDevSetScissorRect(HANDLE hDevice, CONST RECT* pRect)
1523{
1524 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1525 AssertBreakpoint();
1526 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1527 return E_FAIL;
1528}
1529static HRESULT APIENTRY vboxWddmDDevSetStreamSource(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCE* pData)
1530{
1531 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1532 AssertBreakpoint();
1533 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1534 return E_FAIL;
1535}
1536static HRESULT APIENTRY vboxWddmDDevSetStreamSourceFreq(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEFREQ* pData)
1537{
1538 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1539 AssertBreakpoint();
1540 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1541 return E_FAIL;
1542}
1543static HRESULT APIENTRY vboxWddmDDevSetConvolutionKernelMono(HANDLE hDevice, CONST D3DDDIARG_SETCONVOLUTIONKERNELMONO* pData)
1544{
1545 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1546 AssertBreakpoint();
1547 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1548 return E_FAIL;
1549}
1550static HRESULT APIENTRY vboxWddmDDevComposeRects(HANDLE hDevice, CONST D3DDDIARG_COMPOSERECTS* pData)
1551{
1552 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1553 AssertBreakpoint();
1554 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1555 return E_FAIL;
1556}
1557static HRESULT APIENTRY vboxWddmDDevBlt(HANDLE hDevice, CONST D3DDDIARG_BLT* pData)
1558{
1559 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1560 AssertBreakpoint();
1561 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1562 return E_FAIL;
1563}
1564static HRESULT APIENTRY vboxWddmDDevColorFill(HANDLE hDevice, CONST D3DDDIARG_COLORFILL* pData)
1565{
1566 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1567 AssertBreakpoint();
1568 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1569 return E_FAIL;
1570}
1571static HRESULT APIENTRY vboxWddmDDevDepthFill(HANDLE hDevice, CONST D3DDDIARG_DEPTHFILL* pData)
1572{
1573 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1574 AssertBreakpoint();
1575 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1576 return E_FAIL;
1577}
1578static HRESULT APIENTRY vboxWddmDDevCreateQuery(HANDLE hDevice, D3DDDIARG_CREATEQUERY* pData)
1579{
1580 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1581 AssertBreakpoint();
1582 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1583 return E_FAIL;
1584}
1585static HRESULT APIENTRY vboxWddmDDevDestroyQuery(HANDLE hDevice, HANDLE hQuery)
1586{
1587 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1588 AssertBreakpoint();
1589 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1590 return E_FAIL;
1591}
1592static HRESULT APIENTRY vboxWddmDDevIssueQuery(HANDLE hDevice, CONST D3DDDIARG_ISSUEQUERY* pData)
1593{
1594 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1595 AssertBreakpoint();
1596 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1597 return E_FAIL;
1598}
1599static HRESULT APIENTRY vboxWddmDDevGetQueryData(HANDLE hDevice, CONST D3DDDIARG_GETQUERYDATA* pData)
1600{
1601 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1602 AssertBreakpoint();
1603 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1604 return E_FAIL;
1605}
1606static HRESULT APIENTRY vboxWddmDDevSetRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETRENDERTARGET* pData)
1607{
1608 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1609 AssertBreakpoint();
1610 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1611 return E_FAIL;
1612}
1613static HRESULT APIENTRY vboxWddmDDevSetDepthStencil(HANDLE hDevice, CONST D3DDDIARG_SETDEPTHSTENCIL* pData)
1614{
1615 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1616 AssertBreakpoint();
1617 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1618 return E_FAIL;
1619}
1620static HRESULT APIENTRY vboxWddmDDevGenerateMipSubLevels(HANDLE hDevice, CONST D3DDDIARG_GENERATEMIPSUBLEVELS* pData)
1621{
1622 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1623 AssertBreakpoint();
1624 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1625 return E_FAIL;
1626}
1627static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTI* pData, CONST INT* pRegisters)
1628{
1629 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1630 AssertBreakpoint();
1631 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1632 return E_FAIL;
1633}
1634static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTB* pData, CONST BOOL* pRegisters)
1635{
1636 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1637 AssertBreakpoint();
1638 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1639 return E_FAIL;
1640}
1641static HRESULT APIENTRY vboxWddmDDevCreatePixelShader(HANDLE hDevice, D3DDDIARG_CREATEPIXELSHADER* pData, CONST UINT* pCode)
1642{
1643 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1644 AssertBreakpoint();
1645 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1646 return E_FAIL;
1647}
1648static HRESULT APIENTRY vboxWddmDDevDeletePixelShader(HANDLE hDevice, HANDLE hShaderHandle)
1649{
1650 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1651 AssertBreakpoint();
1652 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1653 return E_FAIL;
1654}
1655static HRESULT APIENTRY vboxWddmDDevCreateDecodeDevice(HANDLE hDevice, D3DDDIARG_CREATEDECODEDEVICE* pData)
1656{
1657 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1658 AssertBreakpoint();
1659 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1660 return E_FAIL;
1661}
1662static HRESULT APIENTRY vboxWddmDDevDestroyDecodeDevice(HANDLE hDevice, HANDLE hDecodeDevice)
1663{
1664 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1665 AssertBreakpoint();
1666 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1667 return E_FAIL;
1668}
1669static HRESULT APIENTRY vboxWddmDDevSetDecodeRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETDECODERENDERTARGET* pData)
1670{
1671 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1672 AssertBreakpoint();
1673 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1674 return E_FAIL;
1675}
1676static HRESULT APIENTRY vboxWddmDDevDecodeBeginFrame(HANDLE hDevice, D3DDDIARG_DECODEBEGINFRAME* pData)
1677{
1678 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1679 AssertBreakpoint();
1680 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1681 return E_FAIL;
1682}
1683static HRESULT APIENTRY vboxWddmDDevDecodeEndFrame(HANDLE hDevice, D3DDDIARG_DECODEENDFRAME* pData)
1684{
1685 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1686 AssertBreakpoint();
1687 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1688 return E_FAIL;
1689}
1690static HRESULT APIENTRY vboxWddmDDevDecodeExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXECUTE* pData)
1691{
1692 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1693 AssertBreakpoint();
1694 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1695 return E_FAIL;
1696}
1697static HRESULT APIENTRY vboxWddmDDevDecodeExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXTENSIONEXECUTE* pData)
1698{
1699 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1700 AssertBreakpoint();
1701 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1702 return E_FAIL;
1703}
1704static HRESULT APIENTRY vboxWddmDDevCreateVideoProcessDevice(HANDLE hDevice, D3DDDIARG_CREATEVIDEOPROCESSDEVICE* pData)
1705{
1706 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1707 AssertBreakpoint();
1708 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1709 return E_FAIL;
1710}
1711static HRESULT APIENTRY vboxWddmDDevDestroyVideoProcessDevice(HANDLE hDevice, HANDLE hVideoProcessor)
1712{
1713 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1714 AssertBreakpoint();
1715 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1716 return E_FAIL;
1717}
1718static HRESULT APIENTRY vboxWddmDDevVideoProcessBeginFrame(HANDLE hDevice, HANDLE hVideoProcess)
1719{
1720 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1721 AssertBreakpoint();
1722 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1723 return E_FAIL;
1724}
1725static HRESULT APIENTRY vboxWddmDDevVideoProcessEndFrame(HANDLE hDevice, D3DDDIARG_VIDEOPROCESSENDFRAME* pData)
1726{
1727 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1728 AssertBreakpoint();
1729 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1730 return E_FAIL;
1731}
1732static HRESULT APIENTRY vboxWddmDDevSetVideoProcessRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETVIDEOPROCESSRENDERTARGET* pData)
1733{
1734 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1735 AssertBreakpoint();
1736 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1737 return E_FAIL;
1738}
1739static HRESULT APIENTRY vboxWddmDDevVideoProcessBlt(HANDLE hDevice, CONST D3DDDIARG_VIDEOPROCESSBLT* pData)
1740{
1741 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1742 AssertBreakpoint();
1743 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1744 return E_FAIL;
1745}
1746static HRESULT APIENTRY vboxWddmDDevCreateExtensionDevice(HANDLE hDevice, D3DDDIARG_CREATEEXTENSIONDEVICE* pData)
1747{
1748 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1749 AssertBreakpoint();
1750 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1751 return E_FAIL;
1752}
1753static HRESULT APIENTRY vboxWddmDDevDestroyExtensionDevice(HANDLE hDevice, HANDLE hExtension)
1754{
1755 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1756 AssertBreakpoint();
1757 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1758 return E_FAIL;
1759}
1760static HRESULT APIENTRY vboxWddmDDevExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_EXTENSIONEXECUTE* pData)
1761{
1762 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1763 AssertBreakpoint();
1764 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1765 return E_FAIL;
1766}
1767static HRESULT APIENTRY vboxWddmDDevDestroyDevice(IN HANDLE hDevice)
1768{
1769 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1770
1771 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1772 if (pDevice->DefaultContext.ContextInfo.hContext)
1773 {
1774 D3DDDICB_DESTROYCONTEXT DestroyContext;
1775 DestroyContext.hContext = pDevice->DefaultContext.ContextInfo.hContext;
1776 HRESULT tmpHr = pDevice->RtCallbacks.pfnDestroyContextCb(pDevice->hDevice, &DestroyContext);
1777 Assert(tmpHr == S_OK);
1778 }
1779 RTMemFree(hDevice);
1780 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1781 return S_OK;
1782}
1783static HRESULT APIENTRY vboxWddmDDevCreateOverlay(HANDLE hDevice, D3DDDIARG_CREATEOVERLAY* pData)
1784{
1785 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1786 AssertBreakpoint();
1787 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1788 return E_FAIL;
1789}
1790static HRESULT APIENTRY vboxWddmDDevUpdateOverlay(HANDLE hDevice, CONST D3DDDIARG_UPDATEOVERLAY* pData)
1791{
1792 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1793 AssertBreakpoint();
1794 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1795 return E_FAIL;
1796}
1797static HRESULT APIENTRY vboxWddmDDevFlipOverlay(HANDLE hDevice, CONST D3DDDIARG_FLIPOVERLAY* pData)
1798{
1799 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1800 AssertBreakpoint();
1801 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1802 return E_FAIL;
1803}
1804static HRESULT APIENTRY vboxWddmDDevGetOverlayColorControls(HANDLE hDevice, D3DDDIARG_GETOVERLAYCOLORCONTROLS* pData)
1805{
1806 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1807 AssertBreakpoint();
1808 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1809 return E_FAIL;
1810}
1811static HRESULT APIENTRY vboxWddmDDevSetOverlayColorControls(HANDLE hDevice, CONST D3DDDIARG_SETOVERLAYCOLORCONTROLS* pData)
1812{
1813 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1814 AssertBreakpoint();
1815 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1816 return E_FAIL;
1817}
1818static HRESULT APIENTRY vboxWddmDDevDestroyOverlay(HANDLE hDevice, CONST D3DDDIARG_DESTROYOVERLAY* pData)
1819{
1820 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1821 AssertBreakpoint();
1822 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1823 return E_FAIL;
1824}
1825static HRESULT APIENTRY vboxWddmDDevQueryResourceResidency(HANDLE hDevice, CONST D3DDDIARG_QUERYRESOURCERESIDENCY* pData)
1826{
1827 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1828 AssertBreakpoint();
1829 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1830 return E_FAIL;
1831}
1832static HRESULT APIENTRY vboxWddmDDevOpenResource(HANDLE hDevice, D3DDDIARG_OPENRESOURCE* pData)
1833{
1834 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1835 AssertBreakpoint();
1836 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1837 return E_FAIL;
1838}
1839static HRESULT APIENTRY vboxWddmDDevGetCaptureAllocationHandle(HANDLE hDevice, D3DDDIARG_GETCAPTUREALLOCATIONHANDLE* pData)
1840{
1841 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1842 AssertBreakpoint();
1843 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1844 return E_FAIL;
1845}
1846
1847static HRESULT APIENTRY vboxWddmDDevCaptureToSysMem(HANDLE hDevice, CONST D3DDDIARG_CAPTURETOSYSMEM* pData)
1848{
1849 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1850 AssertBreakpoint();
1851 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1852 return E_FAIL;
1853}
1854
1855static HRESULT APIENTRY vboxWddmDispCreateDevice (IN HANDLE hAdapter, IN D3DDDIARG_CREATEDEVICE* pCreateData)
1856{
1857 HRESULT hr = S_OK;
1858 vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p), Interface(%d), Version(%d)\n", hAdapter, pCreateData->Interface, pCreateData->Version));
1859
1860// AssertBreakpoint();
1861
1862 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)RTMemAllocZ(sizeof (VBOXWDDMDISP_DEVICE));
1863 if (pDevice)
1864 {
1865 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
1866
1867 pDevice->hDevice = pCreateData->hDevice;
1868 pDevice->pAdapter = pAdapter;
1869 pDevice->u32IfVersion = pCreateData->Interface;
1870 pDevice->uRtVersion = pCreateData->Version;
1871 pDevice->RtCallbacks = *pCreateData->pCallbacks;
1872 pDevice->pvCmdBuffer = pCreateData->pCommandBuffer;
1873 pDevice->cbCmdBuffer = pCreateData->CommandBufferSize;
1874 pDevice->fFlags = pCreateData->Flags;
1875
1876 Assert(!pCreateData->AllocationListSize);
1877 Assert(!pCreateData->PatchLocationListSize);
1878
1879 pCreateData->hDevice = pDevice;
1880
1881 pCreateData->pDeviceFuncs->pfnSetRenderState = vboxWddmDDevSetRenderState;
1882 pCreateData->pDeviceFuncs->pfnUpdateWInfo = vboxWddmDDevUpdateWInfo;
1883 pCreateData->pDeviceFuncs->pfnValidateDevice = vboxWddmDDevValidateDevice;
1884 pCreateData->pDeviceFuncs->pfnSetTextureStageState = vboxWddmDDevSetTextureStageState;
1885 pCreateData->pDeviceFuncs->pfnSetTexture = vboxWddmDDevSetTexture;
1886 pCreateData->pDeviceFuncs->pfnSetPixelShader = vboxWddmDDevSetPixelShader;
1887 pCreateData->pDeviceFuncs->pfnSetPixelShaderConst = vboxWddmDDevSetPixelShaderConst;
1888 pCreateData->pDeviceFuncs->pfnSetStreamSourceUm = vboxWddmDDevSetStreamSourceUm;
1889 pCreateData->pDeviceFuncs->pfnSetIndices = vboxWddmDDevSetIndices;
1890 pCreateData->pDeviceFuncs->pfnSetIndicesUm = vboxWddmDDevSetIndicesUm;
1891 pCreateData->pDeviceFuncs->pfnDrawPrimitive = vboxWddmDDevDrawPrimitive;
1892 pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive = vboxWddmDDevDrawIndexedPrimitive;
1893 pCreateData->pDeviceFuncs->pfnDrawRectPatch = vboxWddmDDevDrawRectPatch;
1894 pCreateData->pDeviceFuncs->pfnDrawTriPatch = vboxWddmDDevDrawTriPatch;
1895 pCreateData->pDeviceFuncs->pfnDrawPrimitive2 = vboxWddmDDevDrawPrimitive2;
1896 pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive2 = vboxWddmDDevDrawIndexedPrimitive2;
1897 pCreateData->pDeviceFuncs->pfnVolBlt = vboxWddmDDevVolBlt;
1898 pCreateData->pDeviceFuncs->pfnBufBlt = vboxWddmDDevBufBlt;
1899 pCreateData->pDeviceFuncs->pfnTexBlt = vboxWddmDDevTexBlt;
1900 pCreateData->pDeviceFuncs->pfnStateSet = vboxWddmDDevStateSet;
1901 pCreateData->pDeviceFuncs->pfnSetPriority = vboxWddmDDevSetPriority;
1902 pCreateData->pDeviceFuncs->pfnClear = vboxWddmDDevClear;
1903 pCreateData->pDeviceFuncs->pfnUpdatePalette = vboxWddmDDevUpdatePalette;
1904 pCreateData->pDeviceFuncs->pfnSetPalette = vboxWddmDDevSetPalette;
1905 pCreateData->pDeviceFuncs->pfnSetVertexShaderConst = vboxWddmDDevSetVertexShaderConst;
1906 pCreateData->pDeviceFuncs->pfnMultiplyTransform = vboxWddmDDevMultiplyTransform;
1907 pCreateData->pDeviceFuncs->pfnSetTransform = vboxWddmDDevSetTransform;
1908 pCreateData->pDeviceFuncs->pfnSetViewport = vboxWddmDDevSetViewport;
1909 pCreateData->pDeviceFuncs->pfnSetZRange = vboxWddmDDevSetZRange;
1910 pCreateData->pDeviceFuncs->pfnSetMaterial = vboxWddmDDevSetMaterial;
1911 pCreateData->pDeviceFuncs->pfnSetLight = vboxWddmDDevSetLight;
1912 pCreateData->pDeviceFuncs->pfnCreateLight = vboxWddmDDevCreateLight;
1913 pCreateData->pDeviceFuncs->pfnDestroyLight = vboxWddmDDevDestroyLight;
1914 pCreateData->pDeviceFuncs->pfnSetClipPlane = vboxWddmDDevSetClipPlane;
1915 pCreateData->pDeviceFuncs->pfnGetInfo = vboxWddmDDevGetInfo;
1916 pCreateData->pDeviceFuncs->pfnLock = vboxWddmDDevLock;
1917 pCreateData->pDeviceFuncs->pfnUnlock = vboxWddmDDevUnlock;
1918 pCreateData->pDeviceFuncs->pfnCreateResource = vboxWddmDDevCreateResource;
1919 pCreateData->pDeviceFuncs->pfnDestroyResource = vboxWddmDDevDestroyResource;
1920 pCreateData->pDeviceFuncs->pfnSetDisplayMode = vboxWddmDDevSetDisplayMode;
1921 pCreateData->pDeviceFuncs->pfnPresent = vboxWddmDDevPresent;
1922 pCreateData->pDeviceFuncs->pfnFlush = vboxWddmDDevFlush;
1923 pCreateData->pDeviceFuncs->pfnCreateVertexShaderFunc = vboxWddmDDevCreateVertexShaderFunc;
1924 pCreateData->pDeviceFuncs->pfnDeleteVertexShaderFunc = vboxWddmDDevDeleteVertexShaderFunc;
1925 pCreateData->pDeviceFuncs->pfnSetVertexShaderFunc = vboxWddmDDevSetVertexShaderFunc;
1926 pCreateData->pDeviceFuncs->pfnCreateVertexShaderDecl = vboxWddmDDevCreateVertexShaderDecl;
1927 pCreateData->pDeviceFuncs->pfnDeleteVertexShaderDecl = vboxWddmDDevDeleteVertexShaderDecl;
1928 pCreateData->pDeviceFuncs->pfnSetVertexShaderDecl = vboxWddmDDevSetVertexShaderDecl;
1929 pCreateData->pDeviceFuncs->pfnSetVertexShaderConstI = vboxWddmDDevSetVertexShaderConstI;
1930 pCreateData->pDeviceFuncs->pfnSetVertexShaderConstB = vboxWddmDDevSetVertexShaderConstB;
1931 pCreateData->pDeviceFuncs->pfnSetScissorRect = vboxWddmDDevSetScissorRect;
1932 pCreateData->pDeviceFuncs->pfnSetStreamSource = vboxWddmDDevSetStreamSource;
1933 pCreateData->pDeviceFuncs->pfnSetStreamSourceFreq = vboxWddmDDevSetStreamSourceFreq;
1934 pCreateData->pDeviceFuncs->pfnSetConvolutionKernelMono = vboxWddmDDevSetConvolutionKernelMono;
1935 pCreateData->pDeviceFuncs->pfnComposeRects = vboxWddmDDevComposeRects;
1936 pCreateData->pDeviceFuncs->pfnBlt = vboxWddmDDevBlt;
1937 pCreateData->pDeviceFuncs->pfnColorFill = vboxWddmDDevColorFill;
1938 pCreateData->pDeviceFuncs->pfnDepthFill = vboxWddmDDevDepthFill;
1939 pCreateData->pDeviceFuncs->pfnCreateQuery = vboxWddmDDevCreateQuery;
1940 pCreateData->pDeviceFuncs->pfnDestroyQuery = vboxWddmDDevDestroyQuery;
1941 pCreateData->pDeviceFuncs->pfnIssueQuery = vboxWddmDDevIssueQuery;
1942 pCreateData->pDeviceFuncs->pfnGetQueryData = vboxWddmDDevGetQueryData;
1943 pCreateData->pDeviceFuncs->pfnSetRenderTarget = vboxWddmDDevSetRenderTarget;
1944 pCreateData->pDeviceFuncs->pfnSetDepthStencil = vboxWddmDDevSetDepthStencil;
1945 pCreateData->pDeviceFuncs->pfnGenerateMipSubLevels = vboxWddmDDevGenerateMipSubLevels;
1946 pCreateData->pDeviceFuncs->pfnSetPixelShaderConstI = vboxWddmDDevSetPixelShaderConstI;
1947 pCreateData->pDeviceFuncs->pfnSetPixelShaderConstB = vboxWddmDDevSetPixelShaderConstB;
1948 pCreateData->pDeviceFuncs->pfnCreatePixelShader = vboxWddmDDevCreatePixelShader;
1949 pCreateData->pDeviceFuncs->pfnDeletePixelShader = vboxWddmDDevDeletePixelShader;
1950 pCreateData->pDeviceFuncs->pfnCreateDecodeDevice = vboxWddmDDevCreateDecodeDevice;
1951 pCreateData->pDeviceFuncs->pfnDestroyDecodeDevice = vboxWddmDDevDestroyDecodeDevice;
1952 pCreateData->pDeviceFuncs->pfnSetDecodeRenderTarget = vboxWddmDDevSetDecodeRenderTarget;
1953 pCreateData->pDeviceFuncs->pfnDecodeBeginFrame = vboxWddmDDevDecodeBeginFrame;
1954 pCreateData->pDeviceFuncs->pfnDecodeEndFrame = vboxWddmDDevDecodeEndFrame;
1955 pCreateData->pDeviceFuncs->pfnDecodeExecute = vboxWddmDDevDecodeExecute;
1956 pCreateData->pDeviceFuncs->pfnDecodeExtensionExecute = vboxWddmDDevDecodeExtensionExecute;
1957 pCreateData->pDeviceFuncs->pfnCreateVideoProcessDevice = vboxWddmDDevCreateVideoProcessDevice;
1958 pCreateData->pDeviceFuncs->pfnDestroyVideoProcessDevice = vboxWddmDDevDestroyVideoProcessDevice;
1959 pCreateData->pDeviceFuncs->pfnVideoProcessBeginFrame = vboxWddmDDevVideoProcessBeginFrame;
1960 pCreateData->pDeviceFuncs->pfnVideoProcessEndFrame = vboxWddmDDevVideoProcessEndFrame;
1961 pCreateData->pDeviceFuncs->pfnSetVideoProcessRenderTarget = vboxWddmDDevSetVideoProcessRenderTarget;
1962 pCreateData->pDeviceFuncs->pfnVideoProcessBlt = vboxWddmDDevVideoProcessBlt;
1963 pCreateData->pDeviceFuncs->pfnCreateExtensionDevice = vboxWddmDDevCreateExtensionDevice;
1964 pCreateData->pDeviceFuncs->pfnDestroyExtensionDevice = vboxWddmDDevDestroyExtensionDevice;
1965 pCreateData->pDeviceFuncs->pfnExtensionExecute = vboxWddmDDevExtensionExecute;
1966 pCreateData->pDeviceFuncs->pfnCreateOverlay = vboxWddmDDevCreateOverlay;
1967 pCreateData->pDeviceFuncs->pfnUpdateOverlay = vboxWddmDDevUpdateOverlay;
1968 pCreateData->pDeviceFuncs->pfnFlipOverlay = vboxWddmDDevFlipOverlay;
1969 pCreateData->pDeviceFuncs->pfnGetOverlayColorControls = vboxWddmDDevGetOverlayColorControls;
1970 pCreateData->pDeviceFuncs->pfnSetOverlayColorControls = vboxWddmDDevSetOverlayColorControls;
1971 pCreateData->pDeviceFuncs->pfnDestroyOverlay = vboxWddmDDevDestroyOverlay;
1972 pCreateData->pDeviceFuncs->pfnDestroyDevice = vboxWddmDDevDestroyDevice;
1973 pCreateData->pDeviceFuncs->pfnQueryResourceResidency = vboxWddmDDevQueryResourceResidency;
1974 pCreateData->pDeviceFuncs->pfnOpenResource = vboxWddmDDevOpenResource;
1975 pCreateData->pDeviceFuncs->pfnGetCaptureAllocationHandle = vboxWddmDDevGetCaptureAllocationHandle;
1976 pCreateData->pDeviceFuncs->pfnCaptureToSysMem = vboxWddmDDevCaptureToSysMem;
1977 pCreateData->pDeviceFuncs->pfnLockAsync = NULL; //vboxWddmDDevLockAsync;
1978 pCreateData->pDeviceFuncs->pfnUnlockAsync = NULL; //vboxWddmDDevUnlockAsync;
1979 pCreateData->pDeviceFuncs->pfnRename = NULL; //vboxWddmDDevRename;
1980
1981
1982 do
1983 {
1984 Assert(!pCreateData->AllocationListSize
1985 && !pCreateData->PatchLocationListSize);
1986 if (!pCreateData->AllocationListSize
1987 && !pCreateData->PatchLocationListSize)
1988 {
1989 pDevice->DefaultContext.ContextInfo.NodeOrdinal = 0;
1990 pDevice->DefaultContext.ContextInfo.EngineAffinity = 0;
1991 pDevice->DefaultContext.ContextInfo.Flags.Value = 0;
1992 pDevice->DefaultContext.ContextInfo.pPrivateDriverData = NULL;
1993 pDevice->DefaultContext.ContextInfo.PrivateDriverDataSize = 0;
1994 pDevice->DefaultContext.ContextInfo.hContext = 0;
1995 pDevice->DefaultContext.ContextInfo.pCommandBuffer = NULL;
1996 pDevice->DefaultContext.ContextInfo.CommandBufferSize = 0;
1997 pDevice->DefaultContext.ContextInfo.pAllocationList = NULL;
1998 pDevice->DefaultContext.ContextInfo.AllocationListSize = 0;
1999 pDevice->DefaultContext.ContextInfo.pPatchLocationList = NULL;
2000 pDevice->DefaultContext.ContextInfo.PatchLocationListSize = 0;
2001
2002 hr = pDevice->RtCallbacks.pfnCreateContextCb(pDevice->hDevice, &pDevice->DefaultContext.ContextInfo);
2003 Assert(hr == S_OK);
2004 if (hr == S_OK)
2005 {
2006 if (pDevice->u32IfVersion > 7)
2007 {
2008 /* D3D */
2009 if (pAdapter->pD3D9If)
2010 {
2011 /* */
2012 vboxVDbgPrint((__FUNCTION__": TODO: Implement D3D Device Creation\n"));
2013 break;
2014 }
2015 else
2016 {
2017 /* ballback */
2018 vboxVDbgPrint((__FUNCTION__": D3D Device Being Created, but D3D is unavailable\n"));
2019 break;
2020 }
2021 }
2022 else
2023 {
2024 /* DDraw */
2025 vboxVDbgPrint((__FUNCTION__": DirectDraw Device Created\n"));
2026 break;
2027 }
2028
2029 D3DDDICB_DESTROYCONTEXT DestroyContext;
2030 DestroyContext.hContext = pDevice->DefaultContext.ContextInfo.hContext;
2031
2032 HRESULT tmpHr = pDevice->RtCallbacks.pfnDestroyContextCb(pDevice->hDevice, &DestroyContext);
2033 Assert(tmpHr == S_OK);
2034 }
2035 else
2036 vboxVDbgPrintR((__FUNCTION__": pfnCreateContextCb failed, hr(%d)\n", hr));
2037 }
2038 else
2039 {
2040 vboxVDbgPrintR((__FUNCTION__": Not implemented: PatchLocationListSize(%d), AllocationListSize(%d)\n",
2041 pCreateData->PatchLocationListSize, pCreateData->AllocationListSize));
2042 //pCreateData->pAllocationList = ??
2043 hr = E_FAIL;
2044 }
2045
2046 RTMemFree(pDevice);
2047 } while (0);
2048 }
2049 else
2050 {
2051 vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
2052 hr = E_OUTOFMEMORY;
2053 }
2054
2055 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
2056
2057 return hr;
2058}
2059
2060static HRESULT APIENTRY vboxWddmDispCloseAdapter (IN HANDLE hAdapter)
2061{
2062 vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
2063
2064// AssertBreakpoint();
2065
2066 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
2067 if (pAdapter->pD3D9If)
2068 {
2069 HRESULT hr = pAdapter->pD3D9If->Release();
2070 Assert(hr == S_OK);
2071 VBoxDispD3DClose(&pAdapter->D3D);
2072 }
2073
2074 vboxCapsFree(pAdapter);
2075
2076 RTMemFree(pAdapter);
2077
2078 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
2079
2080 return S_OK;
2081}
2082
2083HRESULT APIENTRY OpenAdapter (__inout D3DDDIARG_OPENADAPTER* pOpenData)
2084{
2085 vboxVDbgPrint(("==> "__FUNCTION__"\n"));
2086
2087 VBOXWDDM_QI Query;
2088 D3DDDICB_QUERYADAPTERINFO DdiQuery;
2089 DdiQuery.PrivateDriverDataSize = sizeof(Query);
2090 DdiQuery.pPrivateDriverData = &Query;
2091 HRESULT hr = pOpenData->pAdapterCallbacks->pfnQueryAdapterInfoCb(pOpenData->hAdapter, &DdiQuery);
2092 Assert(hr == S_OK);
2093 if (hr != S_OK)
2094 {
2095 vboxVDbgPrintR((__FUNCTION__": pfnQueryAdapterInfoCb failed, hr (%d)\n", hr));
2096 return E_FAIL;
2097 }
2098
2099 /* check the miniport version match display version */
2100 if (Query.u32Version != VBOXVIDEOIF_VERSION)
2101 {
2102 vboxVDbgPrintR((__FUNCTION__": miniport version mismatch, expected (%d), but was (%d)\n",
2103 VBOXVIDEOIF_VERSION,
2104 Query.u32Version));
2105 return E_FAIL;
2106 }
2107
2108#ifdef VBOX_WITH_VIDEOHWACCEL
2109 Assert(Query.cInfos >= 1);
2110 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(RT_OFFSETOF(VBOXWDDMDISP_ADAPTER, aHeads[Query.cInfos]));
2111#else
2112 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(sizeof (VBOXWDDMDISP_ADAPTER));
2113#endif
2114 Assert(pAdapter);
2115 if (pAdapter)
2116 {
2117 pAdapter->hAdapter = pOpenData->hAdapter;
2118 pAdapter->uIfVersion = pOpenData->Interface;
2119 pAdapter->uRtVersion= pOpenData->Version;
2120 pAdapter->RtCallbacks = *pOpenData->pAdapterCallbacks;
2121
2122 pAdapter->cHeads = Query.cInfos;
2123
2124
2125 pOpenData->hAdapter = pAdapter;
2126 pOpenData->pAdapterFuncs->pfnGetCaps = vboxWddmDispGetCaps;
2127 pOpenData->pAdapterFuncs->pfnCreateDevice = vboxWddmDispCreateDevice;
2128 pOpenData->pAdapterFuncs->pfnCloseAdapter = vboxWddmDispCloseAdapter;
2129 pOpenData->DriverVersion = D3D_UMD_INTERFACE_VERSION;
2130 /*
2131 * here we detect whether we are called by the d3d or ddraw.
2132 * in the d3d case we init our d3d environment
2133 * in the ddraw case we init 2D acceleration
2134 * if interface version is > 7, this is D3D, treat it as so
2135 * otherwise treat it as ddraw
2136 * @todo: need a more clean way of doing this */
2137
2138 if (pAdapter->uIfVersion > 7)
2139 {
2140 do
2141 {
2142 /* try enable the 3D */
2143 hr = VBoxDispD3DOpen(&pAdapter->D3D);
2144 Assert(hr == S_OK);
2145 if (hr == S_OK)
2146 {
2147 hr = pAdapter->D3D.pfnDirect3DCreate9Ex(D3D_SDK_VERSION, &pAdapter->pD3D9If);
2148 Assert(hr == S_OK);
2149 if (hr == S_OK)
2150 {
2151 vboxVDbgPrint((__FUNCTION__": SUCCESS 3D Enabled, pAdapter (0x%p)\n", pAdapter));
2152 break;
2153 }
2154 else
2155 vboxVDbgPrintR((__FUNCTION__": pfnDirect3DCreate9Ex failed, hr (%d)\n", hr));
2156 VBoxDispD3DClose(&pAdapter->D3D);
2157 }
2158 else
2159 vboxVDbgPrintR((__FUNCTION__": VBoxDispD3DOpen failed, hr (%d)\n", hr));
2160 } while (0);
2161 }
2162#ifdef VBOX_WITH_VIDEOHWACCEL
2163 else
2164 {
2165 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
2166 {
2167 pAdapter->aHeads[i].Vhwa.Settings = Query.aInfos[i];
2168 }
2169 }
2170#endif
2171
2172 vboxCapsInit(pAdapter);
2173 hr = S_OK;
2174// RTMemFree(pAdapter);
2175 }
2176 else
2177 {
2178 vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
2179 hr = E_OUTOFMEMORY;
2180 }
2181
2182 vboxVDbgPrint(("<== "__FUNCTION__", hr (%d)\n", hr));
2183
2184 return hr;
2185}
2186
2187#ifdef VBOXWDDMDISP_DEBUG
2188VOID vboxVDbgDoPrint(LPCSTR szString, ...)
2189{
2190 char szBuffer[1024] = {0};
2191 va_list pArgList;
2192 va_start(pArgList, szString);
2193 _vsnprintf(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]), szString, pArgList);
2194 va_end(pArgList);
2195
2196 OutputDebugStringA(szBuffer);
2197}
2198#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