VirtualBox

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

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

wddm/3d: more impl
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 138.0 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
622static D3DDDIQUERYTYPE gVBoxQueryTypes[] = {
623 D3DDDIQUERYTYPE_EVENT,
624 D3DDDIQUERYTYPE_OCCLUSION
625};
626
627#define VBOX_QUERYTYPE_COUNT() RT_ELEMENTS(gVBoxQueryTypes)
628
629#ifdef VBOX_WITH_VIDEOHWACCEL
630
631static bool vboxVhwaIsEnabled(PVBOXWDDMDISP_ADAPTER pAdapter)
632{
633 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
634 {
635 if (pAdapter->aHeads[i].Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED)
636 return true;
637 }
638 return false;
639}
640
641static bool vboxVhwaHasCKeying(PVBOXWDDMDISP_ADAPTER pAdapter)
642{
643 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
644 {
645 VBOXVHWA_INFO* pSettings = &pAdapter->aHeads[i].Vhwa.Settings;
646 if ((pSettings->fFlags & VBOXVHWA_F_ENABLED)
647 && ((pSettings->fFlags & VBOXVHWA_F_CKEY_DST)
648 || (pSettings->fFlags & VBOXVHWA_F_CKEY_SRC))
649 )
650 return true;
651 }
652 return false;
653}
654
655static void vboxVhwaPopulateOverlayFourccSurfDesc(DDSURFACEDESC *pDesc, uint32_t fourcc)
656{
657 memset(pDesc, 0, sizeof (DDSURFACEDESC));
658
659 pDesc->dwSize = sizeof (DDSURFACEDESC);
660 pDesc->dwFlags = DDSD_CAPS | DDSD_PIXELFORMAT;
661 pDesc->ddpfPixelFormat.dwSize = sizeof (DDPIXELFORMAT);
662 pDesc->ddpfPixelFormat.dwFlags = DDPF_FOURCC;
663 pDesc->ddpfPixelFormat.dwFourCC = fourcc;
664 pDesc->ddsCaps.dwCaps = DDSCAPS_BACKBUFFER
665 | DDSCAPS_COMPLEX
666 | DDSCAPS_FLIP
667 | DDSCAPS_FRONTBUFFER
668 | DDSCAPS_LOCALVIDMEM
669 | DDSCAPS_OVERLAY
670 | DDSCAPS_VIDEOMEMORY
671 | DDSCAPS_VISIBLE;
672}
673
674#endif
675
676static bool vboxPixFormatMatch(DDPIXELFORMAT *pFormat1, DDPIXELFORMAT *pFormat2)
677{
678 return !memcmp(pFormat1, pFormat2, sizeof (DDPIXELFORMAT));
679}
680
681int vboxSurfDescMerge(DDSURFACEDESC *paDescs, uint32_t *pcDescs, uint32_t cMaxDescs, DDSURFACEDESC *pDesc)
682{
683 uint32_t cDescs = *pcDescs;
684
685 Assert(cMaxDescs >= cDescs);
686 Assert(pDesc->dwFlags == (DDSD_CAPS | DDSD_PIXELFORMAT));
687 if (pDesc->dwFlags != (DDSD_CAPS | DDSD_PIXELFORMAT))
688 return VERR_INVALID_PARAMETER;
689
690 for (uint32_t i = 0; i < cDescs; ++i)
691 {
692 DDSURFACEDESC *pCur = &paDescs[i];
693 if (vboxPixFormatMatch(&pCur->ddpfPixelFormat, &pDesc->ddpfPixelFormat))
694 {
695 if (pDesc->dwFlags & DDSD_CAPS)
696 {
697 pCur->dwFlags |= DDSD_CAPS;
698 pCur->ddsCaps.dwCaps |= pDesc->ddsCaps.dwCaps;
699 }
700 return VINF_SUCCESS;
701 }
702 }
703
704 if (cMaxDescs > cDescs)
705 {
706 paDescs[cDescs] = *pDesc;
707 ++cDescs;
708 *pcDescs = cDescs;
709 return VINF_SUCCESS;
710 }
711 return VERR_BUFFER_OVERFLOW;
712}
713
714int vboxFormatOpsMerge(FORMATOP *paOps, uint32_t *pcOps, uint32_t cMaxOps, FORMATOP *pOp)
715{
716 uint32_t cOps = *pcOps;
717
718 Assert(cMaxOps >= cOps);
719
720 for (uint32_t i = 0; i < cOps; ++i)
721 {
722 FORMATOP *pCur = &paOps[i];
723 if (pCur->Format == pOp->Format)
724 {
725 pCur->Operations |= pOp->Operations;
726 Assert(pCur->FlipMsTypes == pOp->FlipMsTypes);
727 Assert(pCur->BltMsTypes == pOp->BltMsTypes);
728 Assert(pCur->PrivateFormatBitCount == pOp->PrivateFormatBitCount);
729 return VINF_SUCCESS;
730 }
731 }
732
733 if (cMaxOps > cOps)
734 {
735 paOps[cOps] = *pOp;
736 ++cOps;
737 *pcOps = cOps;
738 return VINF_SUCCESS;
739 }
740 return VERR_BUFFER_OVERFLOW;
741}
742
743int vboxCapsInit(PVBOXWDDMDISP_ADAPTER pAdapter)
744{
745 pAdapter->cFormstOps = 0;
746 pAdapter->paFormstOps = NULL;
747 pAdapter->cSurfDescs = 0;
748 pAdapter->paSurfDescs = NULL;
749
750 if (pAdapter->uIfVersion > 7)
751 {
752 if (pAdapter->pD3D9If)
753 {
754 pAdapter->paFormstOps = (FORMATOP*)RTMemAllocZ(sizeof (gVBoxFormatOps3D));
755 Assert(pAdapter->paFormstOps);
756 if (pAdapter->paFormstOps)
757 {
758 memcpy (pAdapter->paFormstOps , gVBoxFormatOps3D, sizeof (gVBoxFormatOps3D));
759 pAdapter->cFormstOps = RT_ELEMENTS(gVBoxFormatOps3D);
760 }
761 else
762 return VERR_OUT_OF_RESOURCES;
763
764 /* @todo: do we need surface caps here ? */
765 }
766 }
767#ifdef VBOX_WITH_VIDEOHWACCEL
768 else
769 {
770 /* just calc the max number of formats */
771 uint32_t cFormats = RT_ELEMENTS(gVBoxFormatOpsBase);
772 uint32_t cSurfDescs = RT_ELEMENTS(gVBoxSurfDescsBase);
773 uint32_t cOverlayFormats = 0;
774 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
775 {
776 VBOXDISPVHWA_INFO *pVhwa = &pAdapter->aHeads[i].Vhwa;
777 if (pVhwa->Settings.fFlags & VBOXVHWA_F_ENABLED)
778 {
779 cOverlayFormats += pVhwa->Settings.cFormats;
780 }
781 }
782
783 cFormats += cOverlayFormats;
784 cSurfDescs += cOverlayFormats;
785
786 uint32_t cbFormatOps = cFormats * sizeof (FORMATOP);
787 cbFormatOps = (cbFormatOps + 7) & ~3;
788 /* ensure the surf descs are 8 byte alligned */
789 uint32_t offSurfDescs = (cbFormatOps + 7) & ~3;
790 uint32_t cbSurfDescs = cSurfDescs * sizeof (DDSURFACEDESC);
791 uint32_t cbBuf = offSurfDescs + cbSurfDescs;
792 uint8_t* pvBuf = (uint8_t*)RTMemAllocZ(cbBuf);
793 Assert(pvBuf);
794 if (pvBuf)
795 {
796 pAdapter->paFormstOps = (FORMATOP*)pvBuf;
797 memcpy (pAdapter->paFormstOps , gVBoxFormatOpsBase, sizeof (gVBoxFormatOpsBase));
798 pAdapter->cFormstOps = RT_ELEMENTS(gVBoxFormatOpsBase);
799
800 FORMATOP fo = {D3DDDIFMT_UNKNOWN, 0, 0, 0, 0};
801 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
802 {
803 VBOXDISPVHWA_INFO *pVhwa = &pAdapter->aHeads[i].Vhwa;
804 if (pVhwa->Settings.fFlags & VBOXVHWA_F_ENABLED)
805 {
806 for (uint32_t j = 0; j < pVhwa->Settings.cFormats; ++j)
807 {
808 fo.Format = pVhwa->Settings.aFormats[j];
809 fo.Operations = FORMATOP_OVERLAY;
810 int rc = vboxFormatOpsMerge(pAdapter->paFormstOps, &pAdapter->cFormstOps, cFormats, &fo);
811 AssertRC(rc);
812 }
813 }
814 }
815
816 pAdapter->paSurfDescs = (DDSURFACEDESC*)(pvBuf + offSurfDescs);
817 memcpy (pAdapter->paSurfDescs , gVBoxSurfDescsBase, sizeof (gVBoxSurfDescsBase));
818 pAdapter->cSurfDescs = RT_ELEMENTS(gVBoxSurfDescsBase);
819
820 DDSURFACEDESC sd;
821 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
822 {
823 VBOXDISPVHWA_INFO *pVhwa = &pAdapter->aHeads[i].Vhwa;
824 if (pVhwa->Settings.fFlags & VBOXVHWA_F_ENABLED)
825 {
826 for (uint32_t j = 0; j < pVhwa->Settings.cFormats; ++j)
827 {
828 uint32_t fourcc = vboxWddmFormatToFourcc(pVhwa->Settings.aFormats[j]);
829 if (fourcc)
830 {
831 vboxVhwaPopulateOverlayFourccSurfDesc(&sd, fourcc);
832 int rc = vboxSurfDescMerge(pAdapter->paSurfDescs, &pAdapter->cSurfDescs, cSurfDescs, &sd);
833 AssertRC(rc);
834 }
835 }
836 }
837 }
838 }
839 else
840 return VERR_OUT_OF_RESOURCES;
841 }
842#endif
843
844 return VINF_SUCCESS;
845}
846
847void vboxCapsFree(PVBOXWDDMDISP_ADAPTER pAdapter)
848{
849 if (pAdapter->paFormstOps)
850 RTMemFree(pAdapter->paFormstOps);
851}
852
853static PVBOXWDDMDISP_RESOURCE vboxResourceAlloc(UINT cAllocs)
854{
855 PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)RTMemAllocZ(RT_OFFSETOF(VBOXWDDMDISP_RESOURCE, aAllocations[cAllocs]));
856 Assert(pRc);
857 if (pRc)
858 {
859 pRc->cAllocations = cAllocs;
860 return pRc;
861 }
862 return NULL;
863}
864
865static void vboxWddmRectUnited(RECT *pR, const RECT *pR2Unite)
866{
867 pR->left = RT_MIN(pR->left, pR2Unite->left);
868 pR->top = RT_MIN(pR->top, pR2Unite->top);
869 pR->right = RT_MAX(pR->right, pR2Unite->right);
870 pR->bottom = RT_MAX(pR->bottom, pR2Unite->bottom);
871}
872
873static void vboxWddmLockUnlockMemSynch(PVBOXWDDMDISP_ALLOCATION pAlloc, D3DLOCKED_RECT *pLockInfo, RECT *pRect, bool bToLockInfo)
874{
875 Assert(pAlloc->SurfDesc.pitch);
876 Assert(pAlloc->pvMem);
877
878 if (!pRect)
879 {
880 if (pAlloc->SurfDesc.pitch == pLockInfo->Pitch)
881 {
882 if (bToLockInfo)
883 memcpy(pLockInfo->pBits, pAlloc->pvMem, pAlloc->SurfDesc.pitch * pAlloc->SurfDesc.height);
884 else
885 memcpy(pAlloc->pvMem, pLockInfo->pBits, pAlloc->SurfDesc.pitch * pAlloc->SurfDesc.height);
886 }
887 else
888 {
889 uint8_t *pvSrc, *pvDst;
890 uint32_t srcPitch, dstPitch;
891 if (bToLockInfo)
892 {
893 pvSrc = (uint8_t *)pAlloc->pvMem;
894 pvDst = (uint8_t *)pLockInfo->pBits;
895 srcPitch = pAlloc->SurfDesc.pitch;
896 dstPitch = pLockInfo->Pitch;
897 }
898 else
899 {
900 pvDst = (uint8_t *)pAlloc->pvMem;
901 pvSrc = (uint8_t *)pLockInfo->pBits;
902 dstPitch = pAlloc->SurfDesc.pitch;
903 srcPitch = (uint32_t)pLockInfo->Pitch;
904 }
905
906 uint32_t pitch = RT_MIN(srcPitch, dstPitch);
907 Assert(pitch);
908 for (UINT j = 0; j < pAlloc->SurfDesc.height; ++j)
909 {
910 memcpy(pvDst, pvSrc, pitch);
911 pvSrc += srcPitch;
912 pvDst += dstPitch;
913 }
914 }
915 }
916 else
917 {
918 uint8_t *pvSrc, *pvDst;
919 uint32_t srcPitch, dstPitch;
920 /* @todo: this is not entirely correct */
921 uint8_t * pvAllocMemStart = (uint8_t *)pAlloc->pvMem;
922 uint32_t cbPP = pAlloc->SurfDesc.pitch/pAlloc->SurfDesc.width;
923 pvAllocMemStart += pAlloc->SurfDesc.pitch * pRect->top + pRect->left * cbPP;
924
925 if (bToLockInfo)
926 {
927 pvSrc = (uint8_t *)pvAllocMemStart;
928 pvDst = (uint8_t *)pLockInfo->pBits;
929 srcPitch = pAlloc->SurfDesc.pitch;
930 dstPitch = pLockInfo->Pitch;
931 }
932 else
933 {
934 pvDst = (uint8_t *)pvAllocMemStart;
935 pvSrc = (uint8_t *)pLockInfo->pBits;
936 dstPitch = pAlloc->SurfDesc.pitch;
937 srcPitch = (uint32_t)pLockInfo->Pitch;
938 }
939
940 uint32_t cPixCopyLine = pRect->left - pRect->right;
941
942 if (cPixCopyLine == pAlloc->SurfDesc.width && srcPitch == dstPitch)
943 {
944 memcpy(pvDst, pvSrc, pAlloc->SurfDesc.pitch * (pRect->bottom - pRect->top));
945 }
946 else
947 {
948 uint32_t pitch = RT_MIN(srcPitch, dstPitch);
949 uint32_t cbCopyLine = cPixCopyLine * cbPP;
950 Assert(pitch);
951 for (int j = pRect->top; j < pRect->bottom; ++j)
952 {
953 memcpy(pvDst, pvSrc, cbCopyLine);
954 pvSrc += srcPitch;
955 pvDst += dstPitch;
956 }
957 }
958 }
959}
960
961static D3DFORMAT vboxDDI2D3DFormat(D3DDDIFORMAT format)
962{
963 /* @todo: check they are all equal */
964 return (D3DFORMAT)format;
965}
966
967D3DMULTISAMPLE_TYPE vboxDDI2D3DMultiSampleType(D3DDDIMULTISAMPLE_TYPE enmType)
968{
969 /* @todo: check they are all equal */
970 return (D3DMULTISAMPLE_TYPE)enmType;
971}
972
973D3DPOOL vboxDDI2D3DPool(D3DDDI_POOL enmPool)
974{
975 /* @todo: check they are all equal */
976 switch (enmPool)
977 {
978 case D3DDDIPOOL_SYSTEMMEM:
979 return D3DPOOL_SYSTEMMEM;
980 case D3DDDIPOOL_VIDEOMEMORY:
981 case D3DDDIPOOL_LOCALVIDMEM:
982 case D3DDDIPOOL_NONLOCALVIDMEM:
983 /* @todo: what would be propper here? */
984 return D3DPOOL_DEFAULT;
985 default:
986 AssertBreakpoint();
987 }
988 return D3DPOOL_DEFAULT;
989}
990
991D3DRENDERSTATETYPE vboxDDI2D3DRenderStateType(D3DDDIRENDERSTATETYPE enmType)
992{
993 /* @todo: @fixme: not entirely correct, need to check */
994 return (D3DRENDERSTATETYPE)enmType;
995}
996
997D3DTEXTURESTAGESTATETYPE vboxDDI2D3DTestureStageStateType(D3DDDITEXTURESTAGESTATETYPE enmType)
998{
999 /* @todo: @fixme: not entirely correct, need to check */
1000 return (D3DTEXTURESTAGESTATETYPE)enmType;
1001}
1002
1003DWORD vboxDDI2D3DUsage(D3DDDI_RESOURCEFLAGS fFlags)
1004{
1005 DWORD fUsage = 0;
1006 if (fFlags.Dynamic)
1007 fUsage |= D3DUSAGE_DYNAMIC;
1008 if (fFlags.AutogenMipmap)
1009 fUsage |= D3DUSAGE_AUTOGENMIPMAP;
1010 if (fFlags.DMap)
1011 fUsage |= D3DUSAGE_DMAP;
1012 if (fFlags.WriteOnly)
1013 fUsage |= D3DUSAGE_WRITEONLY;
1014 if (fFlags.NPatches)
1015 fUsage |= D3DUSAGE_NPATCHES;
1016 if (fFlags.Points)
1017 fUsage |= D3DUSAGE_POINTS;
1018 if (fFlags.RenderTarget)
1019 fUsage |= D3DUSAGE_RENDERTARGET;
1020 if (fFlags.RtPatches)
1021 fUsage |= D3DUSAGE_RTPATCHES;
1022 if (fFlags.TextApi)
1023 fUsage |= D3DUSAGE_TEXTAPI;
1024 if (fFlags.WriteOnly)
1025 fUsage |= D3DUSAGE_WRITEONLY;
1026 //below are wddm 1.1-specific
1027// if (fFlags.RestrictedContent)
1028// fUsage |= D3DUSAGE_RESTRICTED_CONTENT;
1029// if (fFlags.RestrictSharedAccess)
1030// fUsage |= D3DUSAGE_RESTRICT_SHARED_RESOURCE;
1031 return fUsage;
1032}
1033
1034DWORD vboxDDI2D3DLockFlags(D3DDDI_LOCKFLAGS fLockFlags)
1035{
1036 DWORD fFlags = 0;
1037 if (fLockFlags.Discard)
1038 fFlags |= D3DLOCK_DISCARD;
1039 if (fLockFlags.NoOverwrite)
1040 fFlags |= D3DLOCK_NOOVERWRITE;
1041 if (fLockFlags.ReadOnly)
1042 fFlags |= D3DLOCK_READONLY;
1043 if (fLockFlags.DoNotWait)
1044 fFlags |= D3DLOCK_DONOTWAIT;
1045 return fFlags;
1046}
1047
1048static void vboxResourcePopulateRcDesc(VBOXWDDM_RC_DESC *pDesc, D3DDDIARG_CREATERESOURCE* pResource)
1049{
1050 pDesc->fFlags = pResource->Flags;
1051 pDesc->enmFormat = pResource->Format;
1052 pDesc->enmPool = pResource->Pool;
1053 pDesc->enmMultisampleType = pResource->MultisampleType;
1054 pDesc->MultisampleQuality = pResource->MultisampleQuality;
1055 pDesc->MipLevels = pResource->MipLevels;
1056 pDesc->Fvf = pResource->Fvf;
1057 pDesc->VidPnSourceId = pResource->VidPnSourceId;
1058 pDesc->RefreshRate = pResource->RefreshRate;
1059 pDesc->enmRotation = pResource->Rotation;
1060}
1061
1062static void vboxResourceFree(PVBOXWDDMDISP_RESOURCE pRc)
1063{
1064 RTMemFree(pRc);
1065}
1066
1067/**
1068 * DLL entry point.
1069 */
1070BOOL WINAPI DllMain(HINSTANCE hInstance,
1071 DWORD dwReason,
1072 LPVOID lpReserved)
1073{
1074 switch (dwReason)
1075 {
1076 case DLL_PROCESS_ATTACH:
1077 {
1078 RTR3Init();
1079
1080 vboxVDbgPrint(("VBoxDispD3D: DLL loaded.\n"));
1081
1082// VbglR3Init();
1083 break;
1084 }
1085
1086 case DLL_PROCESS_DETACH:
1087 {
1088 vboxVDbgPrint(("VBoxDispD3D: DLL unloaded.\n"));
1089// VbglR3Term();
1090 /// @todo RTR3Term();
1091 break;
1092 }
1093
1094 default:
1095 break;
1096 }
1097 return TRUE;
1098}
1099
1100static HRESULT APIENTRY vboxWddmDispGetCaps (HANDLE hAdapter, CONST D3DDDIARG_GETCAPS* pData)
1101{
1102 vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p), caps type(%d)\n", hAdapter, pData->Type));
1103
1104 HRESULT hr = S_OK;
1105 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
1106
1107 switch (pData->Type)
1108 {
1109 case D3DDDICAPS_DDRAW:
1110 {
1111 Assert(!VBOXDISPMODE_IS_3D(pAdapter));
1112 Assert(pData->DataSize == sizeof (DDRAW_CAPS));
1113 if (pData->DataSize >= sizeof (DDRAW_CAPS))
1114 {
1115 memset(pData->pData, 0, sizeof (DDRAW_CAPS));
1116#ifdef VBOX_WITH_VIDEOHWACCEL
1117 if (vboxVhwaHasCKeying(pAdapter))
1118 {
1119 DDRAW_CAPS *pCaps = (DDRAW_CAPS*)pData->pData;
1120 pCaps->Caps |= DDRAW_CAPS_COLORKEY
1121 | DDRAW_CAPS2_DYNAMICTEXTURES
1122 | DDRAW_CAPS2_FLIPNOVSYNC
1123 ;
1124 }
1125#endif
1126 }
1127 else
1128 hr = E_INVALIDARG;
1129 break;
1130 }
1131 case D3DDDICAPS_DDRAW_MODE_SPECIFIC:
1132 {
1133 Assert(!VBOXDISPMODE_IS_3D(pAdapter));
1134 Assert(pData->DataSize == sizeof (DDRAW_MODE_SPECIFIC_CAPS));
1135 if (pData->DataSize >= sizeof (DDRAW_MODE_SPECIFIC_CAPS))
1136 {
1137 DDRAW_MODE_SPECIFIC_CAPS * pCaps = (DDRAW_MODE_SPECIFIC_CAPS*)pData->pData;
1138 memset(&pCaps->Caps /* do not cleanup the first "Head" field,
1139 zero starting with the one following "Head", i.e. Caps */,
1140 0, sizeof (DDRAW_MODE_SPECIFIC_CAPS) - RT_OFFSETOF(DDRAW_MODE_SPECIFIC_CAPS, Caps));
1141#ifdef VBOX_WITH_VIDEOHWACCEL
1142 VBOXVHWA_INFO *pSettings = &pAdapter->aHeads[pCaps->Head].Vhwa.Settings;
1143 if (pSettings->fFlags & VBOXVHWA_F_ENABLED)
1144 {
1145 pCaps->Caps |= MODE_CAPS_OVERLAY | MODE_CAPS_OVERLAYSTRETCH;
1146
1147 if (pSettings->fFlags & VBOXVHWA_F_CKEY_DST)
1148 {
1149 pCaps->CKeyCaps |= MODE_CKEYCAPS_DESTOVERLAY
1150 | MODE_CKEYCAPS_DESTOVERLAYYUV /* ?? */
1151 ;
1152 }
1153
1154 if (pSettings->fFlags & VBOXVHWA_F_CKEY_SRC)
1155 {
1156 pCaps->CKeyCaps |= MODE_CKEYCAPS_SRCOVERLAY
1157 | MODE_CKEYCAPS_SRCOVERLAYCLRSPACE /* ?? */
1158 | MODE_CKEYCAPS_SRCOVERLAYCLRSPACEYUV /* ?? */
1159 | MODE_CKEYCAPS_SRCOVERLAYYUV /* ?? */
1160 ;
1161 }
1162
1163 pCaps->FxCaps = MODE_FXCAPS_OVERLAYSHRINKX
1164 | MODE_FXCAPS_OVERLAYSHRINKY
1165 | MODE_FXCAPS_OVERLAYSTRETCHX
1166 | MODE_FXCAPS_OVERLAYSTRETCHY;
1167
1168
1169 pCaps->MaxVisibleOverlays = pSettings->cOverlaysSupported;
1170 pCaps->MinOverlayStretch = 1;
1171 pCaps->MaxOverlayStretch = 32000;
1172 }
1173#endif
1174 }
1175 else
1176 hr = E_INVALIDARG;
1177 break;
1178 }
1179 case D3DDDICAPS_GETFORMATCOUNT:
1180 *((uint32_t*)pData->pData) = pAdapter->cFormstOps;
1181 break;
1182 case D3DDDICAPS_GETFORMATDATA:
1183 Assert(pData->DataSize == pAdapter->cFormstOps * sizeof (FORMATOP));
1184 memcpy(pData->pData, pAdapter->paFormstOps, pAdapter->cFormstOps * sizeof (FORMATOP));
1185 break;
1186 case D3DDDICAPS_GETD3DQUERYCOUNT:
1187#if 0
1188 *((uint32_t*)pData->pData) = VBOX_QUERYTYPE_COUNT();
1189#else
1190 *((uint32_t*)pData->pData) = 0;
1191#endif
1192 break;
1193 case D3DDDICAPS_GETD3DQUERYDATA:
1194#if 0
1195 Assert(pData->DataSize == VBOX_QUERYTYPE_COUNT() * sizeof (D3DDDIQUERYTYPE));
1196 memcpy(pData->pData, gVBoxQueryTypes, VBOX_QUERYTYPE_COUNT() * sizeof (D3DDDIQUERYTYPE));
1197#else
1198 AssertBreakpoint();
1199 memset(pData->pData, 0, pData->DataSize);
1200#endif
1201 break;
1202 case D3DDDICAPS_GETD3D3CAPS:
1203 Assert(!VBOXDISPMODE_IS_3D(pAdapter));
1204 Assert(pData->DataSize >= sizeof (D3DHAL_GLOBALDRIVERDATA));
1205 if (pData->DataSize >= sizeof (D3DHAL_GLOBALDRIVERDATA))
1206 {
1207 D3DHAL_GLOBALDRIVERDATA *pCaps = (D3DHAL_GLOBALDRIVERDATA *)pData->pData;
1208 memset (pCaps, 0, sizeof (D3DHAL_GLOBALDRIVERDATA));
1209 pCaps->dwSize = sizeof (D3DHAL_GLOBALDRIVERDATA);
1210 pCaps->hwCaps.dwSize = sizeof (D3DDEVICEDESC_V1);
1211 pCaps->hwCaps.dwFlags = D3DDD_COLORMODEL
1212 | D3DDD_DEVCAPS
1213 | D3DDD_DEVICERENDERBITDEPTH;
1214
1215 pCaps->hwCaps.dcmColorModel = D3DCOLOR_RGB;
1216 pCaps->hwCaps.dwDevCaps = D3DDEVCAPS_CANRENDERAFTERFLIP
1217 | D3DDEVCAPS_DRAWPRIMTLVERTEX
1218 | D3DDEVCAPS_EXECUTESYSTEMMEMORY
1219 | D3DDEVCAPS_FLOATTLVERTEX
1220 | D3DDEVCAPS_HWRASTERIZATION
1221 | D3DDEVCAPS_HWTRANSFORMANDLIGHT
1222 | D3DDEVCAPS_TLVERTEXSYSTEMMEMORY
1223 | D3DDEVCAPS_TEXTUREVIDEOMEMORY;
1224 pCaps->hwCaps.dtcTransformCaps.dwSize = sizeof (D3DTRANSFORMCAPS);
1225 pCaps->hwCaps.dtcTransformCaps.dwCaps = 0;
1226 pCaps->hwCaps.bClipping = FALSE;
1227 pCaps->hwCaps.dlcLightingCaps.dwSize = sizeof (D3DLIGHTINGCAPS);
1228 pCaps->hwCaps.dlcLightingCaps.dwCaps = 0;
1229 pCaps->hwCaps.dlcLightingCaps.dwLightingModel = 0;
1230 pCaps->hwCaps.dlcLightingCaps.dwNumLights = 0;
1231 pCaps->hwCaps.dpcLineCaps.dwSize = sizeof (D3DPRIMCAPS);
1232 pCaps->hwCaps.dpcLineCaps.dwMiscCaps = 0;
1233 pCaps->hwCaps.dpcLineCaps.dwRasterCaps = 0;
1234 pCaps->hwCaps.dpcLineCaps.dwZCmpCaps = 0;
1235 pCaps->hwCaps.dpcLineCaps.dwSrcBlendCaps = 0;
1236 pCaps->hwCaps.dpcLineCaps.dwDestBlendCaps = 0;
1237 pCaps->hwCaps.dpcLineCaps.dwAlphaCmpCaps = 0;
1238 pCaps->hwCaps.dpcLineCaps.dwShadeCaps = 0;
1239 pCaps->hwCaps.dpcLineCaps.dwTextureCaps = 0;
1240 pCaps->hwCaps.dpcLineCaps.dwTextureFilterCaps = 0;
1241 pCaps->hwCaps.dpcLineCaps.dwTextureBlendCaps = 0;
1242 pCaps->hwCaps.dpcLineCaps.dwTextureAddressCaps = 0;
1243 pCaps->hwCaps.dpcLineCaps.dwStippleWidth = 0;
1244 pCaps->hwCaps.dpcLineCaps.dwStippleHeight = 0;
1245
1246 pCaps->hwCaps.dpcTriCaps.dwSize = sizeof (D3DPRIMCAPS);
1247 pCaps->hwCaps.dpcTriCaps.dwMiscCaps = 0;
1248 pCaps->hwCaps.dpcTriCaps.dwRasterCaps = 0;
1249 pCaps->hwCaps.dpcTriCaps.dwZCmpCaps = 0;
1250 pCaps->hwCaps.dpcTriCaps.dwSrcBlendCaps = 0;
1251 pCaps->hwCaps.dpcTriCaps.dwDestBlendCaps = 0;
1252 pCaps->hwCaps.dpcTriCaps.dwAlphaCmpCaps = 0;
1253 pCaps->hwCaps.dpcTriCaps.dwShadeCaps = 0;
1254 pCaps->hwCaps.dpcTriCaps.dwTextureCaps = 0;
1255 pCaps->hwCaps.dpcTriCaps.dwTextureFilterCaps = 0;
1256 pCaps->hwCaps.dpcTriCaps.dwTextureBlendCaps = 0;
1257 pCaps->hwCaps.dpcTriCaps.dwTextureAddressCaps = 0;
1258 pCaps->hwCaps.dpcTriCaps.dwStippleWidth = 0;
1259 pCaps->hwCaps.dpcTriCaps.dwStippleHeight = 0;
1260 pCaps->hwCaps.dwDeviceRenderBitDepth = 0;
1261 pCaps->hwCaps.dwDeviceZBufferBitDepth = DDBD_8 | DDBD_16 | DDBD_24 | DDBD_32;
1262 pCaps->hwCaps.dwMaxBufferSize = 0;
1263 pCaps->hwCaps.dwMaxVertexCount = 0;
1264
1265
1266 pCaps->dwNumVertices = 0;
1267 pCaps->dwNumClipVertices = 0;
1268 pCaps->dwNumTextureFormats = pAdapter->cSurfDescs;
1269 pCaps->lpTextureFormats = pAdapter->paSurfDescs;
1270 }
1271 else
1272 hr = E_INVALIDARG;
1273 break;
1274 case D3DDDICAPS_GETD3D7CAPS:
1275 Assert(!VBOXDISPMODE_IS_3D(pAdapter));
1276 Assert(pData->DataSize >= sizeof (D3DHAL_D3DEXTENDEDCAPS));
1277 if (pData->DataSize >= sizeof (D3DHAL_D3DEXTENDEDCAPS))
1278 memset(pData->pData, 0, sizeof (D3DHAL_D3DEXTENDEDCAPS));
1279 else
1280 hr = E_INVALIDARG;
1281 break;
1282 case D3DDDICAPS_GETD3D9CAPS:
1283 {
1284 Assert(pData->DataSize >= sizeof (D3DCAPS9));
1285// AssertBreakpoint();
1286 if (pData->DataSize >= sizeof (D3DCAPS9))
1287 {
1288 Assert(VBOXDISPMODE_IS_3D(pAdapter));
1289 if (VBOXDISPMODE_IS_3D(pAdapter))
1290 {
1291 D3DCAPS9* pCaps = (D3DCAPS9*)pData->pData;
1292 hr = pAdapter->pD3D9If->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, pCaps);
1293 Assert(hr == S_OK);
1294 if (hr == S_OK)
1295 {
1296 pCaps->Caps2 |= D3DCAPS2_CANSHARERESOURCE | 0x00080000 /*D3DCAPS2_CANRENDERWINDOWED*/;
1297 pCaps->DevCaps |= D3DDEVCAPS_FLOATTLVERTEX /* <- must be set according to the docs */
1298 /*| D3DDEVCAPS_HWVERTEXBUFFER | D3DDEVCAPS_HWINDEXBUFFER | D3DDEVCAPS_SUBVOLUMELOCK */;
1299 pCaps->PrimitiveMiscCaps |= D3DPMISCCAPS_INDEPENDENTWRITEMASKS
1300 | D3DPMISCCAPS_FOGINFVF
1301 | D3DPMISCCAPS_SEPARATEALPHABLEND | D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS;
1302 pCaps->RasterCaps |= D3DPRASTERCAPS_SUBPIXEL | D3DPRASTERCAPS_STIPPLE | D3DPRASTERCAPS_ZBIAS | D3DPRASTERCAPS_COLORPERSPECTIVE /* keep */;
1303 pCaps->TextureCaps |= D3DPTEXTURECAPS_TRANSPARENCY | D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE;
1304 pCaps->TextureAddressCaps |= D3DPTADDRESSCAPS_MIRRORONCE;
1305 pCaps->VolumeTextureAddressCaps |= D3DPTADDRESSCAPS_MIRRORONCE;
1306 pCaps->GuardBandLeft = -8192.;
1307 pCaps->GuardBandTop = -8192.;
1308 pCaps->GuardBandRight = 8192.;
1309 pCaps->GuardBandBottom = 8192.;
1310 pCaps->StencilCaps |= D3DSTENCILCAPS_TWOSIDED;
1311 pCaps->DeclTypes |= D3DDTCAPS_FLOAT16_2 | D3DDTCAPS_FLOAT16_4;
1312 pCaps->VS20Caps.DynamicFlowControlDepth = 24;
1313 pCaps->VS20Caps.NumTemps = D3DVS20_MAX_NUMTEMPS;
1314 pCaps->PS20Caps.DynamicFlowControlDepth = 24;
1315 pCaps->PS20Caps.NumTemps = D3DVS20_MAX_NUMTEMPS;
1316 pCaps->VertexTextureFilterCaps |= D3DPTFILTERCAPS_MINFPOINT | D3DPTFILTERCAPS_MAGFPOINT;
1317#if 1 /* workaround for wine not returning InstructionSlots correctly for shaders v3.0 */
1318 if ((pCaps->VertexShaderVersion & 0xff00) == 0x0300)
1319 {
1320 pCaps->MaxVertexShader30InstructionSlots = RT_MIN(32768, pCaps->MaxVertexShader30InstructionSlots);
1321 pCaps->MaxPixelShader30InstructionSlots = RT_MIN(32768, pCaps->MaxPixelShader30InstructionSlots);
1322 }
1323#endif
1324#ifdef DEBUG
1325 if ((pCaps->VertexShaderVersion & 0xff00) == 0x0300)
1326 {
1327 Assert(pCaps->MaxVertexShader30InstructionSlots >= 512);
1328 Assert(pCaps->MaxVertexShader30InstructionSlots <= 32768);
1329 Assert(pCaps->MaxPixelShader30InstructionSlots >= 512);
1330 Assert(pCaps->MaxPixelShader30InstructionSlots <= 32768);
1331 }
1332 else if ((pCaps->VertexShaderVersion & 0xff00) == 0x0200)
1333 {
1334 Assert(pCaps->MaxVertexShader30InstructionSlots == 0);
1335 Assert(pCaps->MaxPixelShader30InstructionSlots == 0);
1336 }
1337 else
1338 {
1339 AssertBreakpoint();
1340 }
1341#endif
1342 break;
1343 }
1344
1345 vboxVDbgPrintR((__FUNCTION__": GetDeviceCaps hr(%d)\n", hr));
1346 /* let's fall back to the 3D disabled case */
1347 hr = S_OK;
1348 }
1349
1350 memset(pData->pData, 0, sizeof (D3DCAPS9));
1351 }
1352 else
1353 hr = E_INVALIDARG;
1354 break;
1355 }
1356 case D3DDDICAPS_GETGAMMARAMPCAPS:
1357 *((uint32_t*)pData->pData) = 0;
1358 break;
1359 case D3DDDICAPS_GETMULTISAMPLEQUALITYLEVELS:
1360 case D3DDDICAPS_GETD3D5CAPS:
1361 case D3DDDICAPS_GETD3D6CAPS:
1362 case D3DDDICAPS_GETD3D8CAPS:
1363 case D3DDDICAPS_GETDECODEGUIDCOUNT:
1364 case D3DDDICAPS_GETDECODEGUIDS:
1365 case D3DDDICAPS_GETDECODERTFORMATCOUNT:
1366 case D3DDDICAPS_GETDECODERTFORMATS:
1367 case D3DDDICAPS_GETDECODECOMPRESSEDBUFFERINFOCOUNT:
1368 case D3DDDICAPS_GETDECODECOMPRESSEDBUFFERINFO:
1369 case D3DDDICAPS_GETDECODECONFIGURATIONCOUNT:
1370 case D3DDDICAPS_GETDECODECONFIGURATIONS:
1371 case D3DDDICAPS_GETVIDEOPROCESSORDEVICEGUIDCOUNT:
1372 case D3DDDICAPS_GETVIDEOPROCESSORDEVICEGUIDS:
1373 case D3DDDICAPS_GETVIDEOPROCESSORRTFORMATCOUNT:
1374 case D3DDDICAPS_GETVIDEOPROCESSORRTFORMATS:
1375 case D3DDDICAPS_GETVIDEOPROCESSORRTSUBSTREAMFORMATCOUNT:
1376 case D3DDDICAPS_GETVIDEOPROCESSORRTSUBSTREAMFORMATS:
1377 case D3DDDICAPS_GETVIDEOPROCESSORCAPS:
1378 case D3DDDICAPS_GETPROCAMPRANGE:
1379 case D3DDDICAPS_FILTERPROPERTYRANGE:
1380 case D3DDDICAPS_GETEXTENSIONGUIDCOUNT:
1381 case D3DDDICAPS_GETEXTENSIONGUIDS:
1382 case D3DDDICAPS_GETEXTENSIONCAPS:
1383 vboxVDbgPrint((__FUNCTION__": unimplemented caps type(%d)\n", pData->Type));
1384 AssertBreakpoint();
1385 if (pData->pData && pData->DataSize)
1386 memset(pData->pData, 0, pData->DataSize);
1387 break;
1388 default:
1389 vboxVDbgPrint((__FUNCTION__": unknown caps type(%d)\n", pData->Type));
1390 AssertBreakpoint();
1391 }
1392
1393 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p), caps type(%d)\n", hAdapter, pData->Type));
1394
1395 return S_OK;
1396}
1397
1398static HRESULT APIENTRY vboxWddmDDevSetRenderState(HANDLE hDevice, CONST D3DDDIARG_RENDERSTATE* pData)
1399{
1400 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1401 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1402 Assert(pDevice);
1403 Assert(pDevice->pDevice9If);
1404 HRESULT hr = pDevice->pDevice9If->SetRenderState(vboxDDI2D3DRenderStateType(pData->State), pData->Value);
1405 Assert(hr == S_OK);
1406 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1407 return hr;
1408}
1409
1410static HRESULT APIENTRY vboxWddmDDevUpdateWInfo(HANDLE hDevice, CONST D3DDDIARG_WINFO* pData)
1411{
1412 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1413 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1414 return S_OK;
1415}
1416
1417static HRESULT APIENTRY vboxWddmDDevValidateDevice(HANDLE hDevice, D3DDDIARG_VALIDATETEXTURESTAGESTATE* 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}
1424
1425static HRESULT APIENTRY vboxWddmDDevSetTextureStageState(HANDLE hDevice, CONST D3DDDIARG_TEXTURESTAGESTATE* pData)
1426{
1427 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1428 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1429 Assert(pDevice);
1430 Assert(pDevice->pDevice9If);
1431 HRESULT hr = pDevice->pDevice9If->SetTextureStageState(pData->Stage, vboxDDI2D3DTestureStageStateType(pData->State), pData->Value);
1432 Assert(hr == S_OK);
1433 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1434 return hr;
1435}
1436
1437static HRESULT APIENTRY vboxWddmDDevSetTexture(HANDLE hDevice, UINT Stage, HANDLE hTexture)
1438{
1439 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1440 AssertBreakpoint();
1441 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1442 return E_FAIL;
1443}
1444
1445static HRESULT APIENTRY vboxWddmDDevSetPixelShader(HANDLE hDevice, HANDLE hShaderHandle)
1446{
1447 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1448 AssertBreakpoint();
1449 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1450 return E_FAIL;
1451}
1452
1453static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONST* pData, CONST FLOAT* pRegisters)
1454{
1455 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1456 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1457 Assert(pDevice);
1458 Assert(pDevice->pDevice9If);
1459 HRESULT hr = pDevice->pDevice9If->SetPixelShaderConstantF(pData->Register, pRegisters, pData->Count);
1460 Assert(hr == S_OK);
1461 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1462 return hr;
1463}
1464
1465static HRESULT APIENTRY vboxWddmDDevSetStreamSourceUm(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEUM* pData, CONST VOID* pUMBuffer )
1466{
1467 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1468 AssertBreakpoint();
1469 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1470 return E_FAIL;
1471}
1472
1473static HRESULT APIENTRY vboxWddmDDevSetIndices(HANDLE hDevice, CONST D3DDDIARG_SETINDICES* pData)
1474{
1475 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1476 AssertBreakpoint();
1477 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1478 return E_FAIL;
1479}
1480
1481static HRESULT APIENTRY vboxWddmDDevSetIndicesUm(HANDLE hDevice, UINT IndexSize, CONST VOID* pUMBuffer)
1482{
1483 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1484 AssertBreakpoint();
1485 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1486 return E_FAIL;
1487}
1488
1489static HRESULT APIENTRY vboxWddmDDevDrawPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE* pData, CONST UINT* pFlagBuffer)
1490{
1491 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1492 AssertBreakpoint();
1493 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1494 return E_FAIL;
1495}
1496
1497static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE* pData)
1498{
1499 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1500 AssertBreakpoint();
1501 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1502 return E_FAIL;
1503}
1504
1505static HRESULT APIENTRY vboxWddmDDevDrawRectPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWRECTPATCH* pData, CONST D3DDDIRECTPATCH_INFO* pInfo, CONST FLOAT* pPatch)
1506{
1507 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1508 AssertBreakpoint();
1509 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1510 return E_FAIL;
1511}
1512
1513static HRESULT APIENTRY vboxWddmDDevDrawTriPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWTRIPATCH* pData, CONST D3DDDITRIPATCH_INFO* pInfo, CONST FLOAT* pPatch)
1514{
1515 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1516 AssertBreakpoint();
1517 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1518 return E_FAIL;
1519}
1520
1521static HRESULT APIENTRY vboxWddmDDevDrawPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE2* pData)
1522{
1523 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1524 AssertBreakpoint();
1525 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1526 return E_FAIL;
1527}
1528
1529static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE2* pData, UINT dwIndicesSize, CONST VOID* pIndexBuffer, CONST UINT* pFlagBuffer)
1530{
1531 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1532 AssertBreakpoint();
1533 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1534 return E_FAIL;
1535}
1536
1537static HRESULT APIENTRY vboxWddmDDevVolBlt(HANDLE hDevice, CONST D3DDDIARG_VOLUMEBLT* pData)
1538{
1539 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1540 AssertBreakpoint();
1541 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1542 return E_FAIL;
1543}
1544
1545static HRESULT APIENTRY vboxWddmDDevBufBlt(HANDLE hDevice, CONST D3DDDIARG_BUFFERBLT* pData)
1546{
1547 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1548 AssertBreakpoint();
1549 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1550 return E_FAIL;
1551}
1552
1553static HRESULT APIENTRY vboxWddmDDevTexBlt(HANDLE hDevice, CONST D3DDDIARG_TEXBLT* pData)
1554{
1555 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1556 AssertBreakpoint();
1557 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1558 return E_FAIL;
1559}
1560
1561static HRESULT APIENTRY vboxWddmDDevStateSet(HANDLE hDevice, D3DDDIARG_STATESET* pData)
1562{
1563 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1564 AssertBreakpoint();
1565 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1566 return E_FAIL;
1567}
1568static HRESULT APIENTRY vboxWddmDDevSetPriority(HANDLE hDevice, CONST D3DDDIARG_SETPRIORITY* pData)
1569{
1570 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1571 AssertBreakpoint();
1572 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1573 return E_FAIL;
1574}
1575AssertCompile(sizeof (RECT) == sizeof (D3DRECT));
1576AssertCompile(RT_OFFSETOF(RECT, left) == RT_OFFSETOF(D3DRECT, x1));
1577AssertCompile(RT_OFFSETOF(RECT, right) == RT_OFFSETOF(D3DRECT, x2));
1578AssertCompile(RT_OFFSETOF(RECT, top) == RT_OFFSETOF(D3DRECT, y1));
1579AssertCompile(RT_OFFSETOF(RECT, bottom) == RT_OFFSETOF(D3DRECT, y2));
1580
1581static HRESULT APIENTRY vboxWddmDDevClear(HANDLE hDevice, CONST D3DDDIARG_CLEAR* pData, UINT NumRect, CONST RECT* pRect)
1582{
1583 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1584 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1585 Assert(pDevice);
1586 Assert(pDevice->pDevice9If);
1587 HRESULT hr = pDevice->pDevice9If->Clear(NumRect, (D3DRECT*)pRect /* see AssertCompile above */,
1588 pData->Flags,
1589 pData->FillColor,
1590 pData->FillDepth,
1591 pData->FillStencil);
1592 Assert(hr == S_OK);
1593 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1594 return hr;
1595}
1596static HRESULT APIENTRY vboxWddmDDevUpdatePalette(HANDLE hDevice, CONST D3DDDIARG_UPDATEPALETTE* pData, CONST PALETTEENTRY* pPaletteData)
1597{
1598 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1599 AssertBreakpoint();
1600 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1601 return E_FAIL;
1602}
1603
1604static HRESULT APIENTRY vboxWddmDDevSetPalette(HANDLE hDevice, CONST D3DDDIARG_SETPALETTE* pData)
1605{
1606 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1607 AssertBreakpoint();
1608 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1609 return E_FAIL;
1610}
1611
1612static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONST* pData , CONST VOID* pRegisters)
1613{
1614 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1615 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1616 Assert(pDevice);
1617 Assert(pDevice->pDevice9If);
1618 HRESULT hr = pDevice->pDevice9If->SetVertexShaderConstantF(
1619 pData->Register,
1620 (CONST float*)pRegisters,
1621 pData->Count);
1622 Assert(hr == S_OK);
1623 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1624 return hr;
1625}
1626static HRESULT APIENTRY vboxWddmDDevMultiplyTransform(HANDLE hDevice, CONST D3DDDIARG_MULTIPLYTRANSFORM* pData)
1627{
1628 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1629 AssertBreakpoint();
1630 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1631 return E_FAIL;
1632}
1633static HRESULT APIENTRY vboxWddmDDevSetTransform(HANDLE hDevice, CONST D3DDDIARG_SETTRANSFORM* pData)
1634{
1635 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1636 AssertBreakpoint();
1637 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1638 return E_FAIL;
1639}
1640static HRESULT APIENTRY vboxWddmDDevSetViewport(HANDLE hDevice, CONST D3DDDIARG_VIEWPORTINFO* pData)
1641{
1642 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1643 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1644 Assert(pDevice);
1645 Assert(pDevice->pDevice9If);
1646 pDevice->ViewPort.X = pData->X;
1647 pDevice->ViewPort.Y = pData->Y;
1648 pDevice->ViewPort.Width = pData->Width;
1649 pDevice->ViewPort.Height = pData->Height;
1650 HRESULT hr = pDevice->pDevice9If->SetViewport(&pDevice->ViewPort);
1651 Assert(hr == S_OK);
1652 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1653 return hr;
1654}
1655static HRESULT APIENTRY vboxWddmDDevSetZRange(HANDLE hDevice, CONST D3DDDIARG_ZRANGE* pData)
1656{
1657 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1658 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1659 Assert(pDevice);
1660 Assert(pDevice->pDevice9If);
1661 pDevice->ViewPort.MinZ = pData->MinZ;
1662 pDevice->ViewPort.MaxZ = pData->MaxZ;
1663 HRESULT hr = pDevice->pDevice9If->SetViewport(&pDevice->ViewPort);
1664 Assert(hr == S_OK);
1665 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1666 return hr;
1667}
1668static HRESULT APIENTRY vboxWddmDDevSetMaterial(HANDLE hDevice, CONST D3DDDIARG_SETMATERIAL* pData)
1669{
1670 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1671 AssertBreakpoint();
1672 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1673 return E_FAIL;
1674}
1675static HRESULT APIENTRY vboxWddmDDevSetLight(HANDLE hDevice, CONST D3DDDIARG_SETLIGHT* pData, CONST D3DDDI_LIGHT* pLightProperties)
1676{
1677 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1678 AssertBreakpoint();
1679 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1680 return E_FAIL;
1681}
1682static HRESULT APIENTRY vboxWddmDDevCreateLight(HANDLE hDevice, CONST D3DDDIARG_CREATELIGHT* pData)
1683{
1684 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1685 AssertBreakpoint();
1686 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1687 return E_FAIL;
1688}
1689static HRESULT APIENTRY vboxWddmDDevDestroyLight(HANDLE hDevice, CONST D3DDDIARG_DESTROYLIGHT* pData)
1690{
1691 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1692 AssertBreakpoint();
1693 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1694 return E_FAIL;
1695}
1696static HRESULT APIENTRY vboxWddmDDevSetClipPlane(HANDLE hDevice, CONST D3DDDIARG_SETCLIPPLANE* pData)
1697{
1698 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1699 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1700 Assert(pDevice);
1701 Assert(pDevice->pDevice9If);
1702 HRESULT hr = pDevice->pDevice9If->SetClipPlane(pData->Index, pData->Plane);
1703 Assert(hr == S_OK);
1704 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1705 return hr;
1706}
1707
1708static HRESULT APIENTRY vboxWddmDDevGetInfo(HANDLE hDevice, UINT DevInfoID, VOID* pDevInfoStruct, UINT DevInfoSize)
1709{
1710 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1711 AssertBreakpoint();
1712 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1713 return E_NOTIMPL;
1714}
1715
1716static HRESULT APIENTRY vboxWddmDDevLock(HANDLE hDevice, D3DDDIARG_LOCK* pData)
1717{
1718 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1719 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1720 PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
1721 Assert(pData->SubResourceIndex < pRc->cAllocations);
1722 if (pData->SubResourceIndex >= pRc->cAllocations)
1723 return E_INVALIDARG;
1724
1725 HRESULT hr = S_OK;
1726
1727 if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
1728 {
1729 if (pRc->RcDesc.fFlags.Texture)
1730 {
1731 PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
1732 Assert(pData->SubResourceIndex < pRc->cAllocations);
1733 PVBOXWDDMDISP_ALLOCATION pLockAlloc = &pRc->aAllocations[pData->SubResourceIndex];
1734 IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pTexAlloc->pD3DIf;
1735 Assert(pD3DIfTex);
1736 RECT *pRect = NULL;
1737 if (pData->Flags.AreaValid)
1738 {
1739 pRect = &pData->Area;
1740 }
1741 else if (pData->Flags.RangeValid)
1742 {
1743 AssertBreakpoint();
1744 }
1745 else if (pData->Flags.BoxValid)
1746 {
1747 AssertBreakpoint();
1748 }
1749 /* else - we lock the entire texture, pRect == NULL */
1750
1751// Assert(!pLockAlloc->LockInfo.cLocks);
1752 if (!pLockAlloc->LockInfo.cLocks)
1753 {
1754 hr = pD3DIfTex->LockRect(pData->SubResourceIndex,
1755 &pLockAlloc->LockInfo.LockedRect,
1756 pRect,
1757 vboxDDI2D3DLockFlags(pData->Flags));
1758 Assert(hr == S_OK);
1759 if (hr == S_OK)
1760 {
1761
1762// Assert(pLockAlloc->LockInfo.fFlags.Value == 0);
1763 pLockAlloc->LockInfo.fFlags = pData->Flags;
1764 if (pRect)
1765 {
1766 pLockAlloc->LockInfo.Area = *pRect;
1767 Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 1);
1768// pLockAlloc->LockInfo.fFlags.AreaValid = 1;
1769 }
1770 else
1771 {
1772 Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 0);
1773// pLockAlloc->LockInfo.fFlags.AreaValid = 0;
1774 }
1775
1776 ++pLockAlloc->LockInfo.cLocks;
1777 }
1778 }
1779 else
1780 {
1781// Assert(pLockAlloc->LockInfo.fFlags.Value == pData->Flags.Value);
1782// if (pLockAlloc->LockInfo.fFlags.Value != pData->Flags.Value)
1783// {
1784// }
1785 Assert(pLockAlloc->LockInfo.fFlags.AreaValid == pData->Flags.AreaValid);
1786 if (pLockAlloc->LockInfo.fFlags.AreaValid && pData->Flags.AreaValid)
1787 {
1788 Assert(pLockAlloc->LockInfo.Area.left == pData->Area.left);
1789 Assert(pLockAlloc->LockInfo.Area.top == pData->Area.top);
1790 Assert(pLockAlloc->LockInfo.Area.right == pData->Area.right);
1791 Assert(pLockAlloc->LockInfo.Area.bottom == pData->Area.bottom);
1792 }
1793 Assert(pLockAlloc->LockInfo.LockedRect.pBits);
1794 }
1795
1796
1797 ++pLockAlloc->LockInfo.cLocks;
1798
1799 if (!pData->Flags.NotifyOnly)
1800 {
1801 pData->pSurfData = pLockAlloc->LockInfo.LockedRect.pBits;
1802 pData->Pitch = pLockAlloc->LockInfo.LockedRect.Pitch;
1803 pData->SlicePitch = 0;
1804 Assert(pLockAlloc->SurfDesc.slicePitch == 0);
1805 Assert(!pLockAlloc->pvMem);
1806 }
1807 else
1808 {
1809 Assert(pLockAlloc->pvMem);
1810 Assert(pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
1811 if (/* !pData->Flags.WriteOnly && */ !pData->Flags.Discard)
1812 vboxWddmLockUnlockMemSynch(pLockAlloc, &pLockAlloc->LockInfo.LockedRect, pRect, false /*bool bToLockInfo*/);
1813 }
1814 }
1815 else
1816 {
1817 AssertBreakpoint();
1818 }
1819 }
1820 else
1821 {
1822 PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
1823 D3DDDICB_LOCK LockData;
1824 LockData.hAllocation = pAlloc->hAllocation;
1825 LockData.PrivateDriverData = 0;
1826 LockData.NumPages = 0;
1827 LockData.pPages = NULL;
1828 LockData.pData = NULL; /* out */
1829 LockData.Flags.Value = 0;
1830 LockData.Flags.Discard = pData->Flags.Discard;
1831 LockData.Flags.DonotWait = pData->Flags.DoNotWait;
1832
1833
1834 hr = pDevice->RtCallbacks.pfnLockCb(hDevice, &LockData);
1835 Assert(hr == S_OK || (hr == D3DERR_WASSTILLDRAWING && pData->Flags.DoNotWait));
1836 if (hr == S_OK)
1837 {
1838 uintptr_t offset;
1839 if (pData->Flags.AreaValid)
1840 {
1841 offset = pAlloc->SurfDesc.pitch * pData->Area.top +
1842 ((pAlloc->SurfDesc.bpp * pData->Area.left) >> 3);
1843 }
1844 else if (pData->Flags.RangeValid)
1845 {
1846 offset = pData->Range.Offset;
1847 }
1848 else if (pData->Flags.BoxValid)
1849 {
1850 vboxVDbgPrintF((__FUNCTION__": Implement Box area"));
1851 AssertBreakpoint();
1852 }
1853 else
1854 {
1855 AssertBreakpoint();
1856 }
1857
1858 if (pData->Flags.Discard)
1859 {
1860 /* check if the surface was renamed */
1861 if (LockData.hAllocation)
1862 pAlloc->hAllocation = LockData.hAllocation;
1863 }
1864
1865 pData->pSurfData = ((uint8_t*)LockData.pData) + offset;
1866 pData->Pitch = pAlloc->SurfDesc.pitch;
1867 pData->SlicePitch = pAlloc->SurfDesc.slicePitch;
1868 }
1869 }
1870
1871 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(%d)\n", hDevice, hr));
1872 return hr;
1873}
1874static HRESULT APIENTRY vboxWddmDDevUnlock(HANDLE hDevice, CONST D3DDDIARG_UNLOCK* pData)
1875{
1876 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1877 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1878 PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
1879 HRESULT hr = S_OK;
1880
1881 Assert(pData->SubResourceIndex < pRc->cAllocations);
1882 if (pData->SubResourceIndex >= pRc->cAllocations)
1883 return E_INVALIDARG;
1884
1885 if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
1886 {
1887 if (pRc->RcDesc.fFlags.Texture)
1888 {
1889 Assert(pData->SubResourceIndex < pRc->cAllocations);
1890 PVBOXWDDMDISP_ALLOCATION pLockAlloc = &pRc->aAllocations[pData->SubResourceIndex];
1891
1892 --pLockAlloc->LockInfo.cLocks;
1893 if (!pLockAlloc->LockInfo.cLocks)
1894 {
1895 PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
1896 Assert(pLockAlloc->LockInfo.cLocks);
1897 IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pTexAlloc->pD3DIf;
1898 Assert(pD3DIfTex);
1899 /* this is a sysmem texture, update */
1900 if (pLockAlloc->pvMem && !pLockAlloc->LockInfo.fFlags.ReadOnly)
1901 {
1902 vboxWddmLockUnlockMemSynch(pLockAlloc, &pLockAlloc->LockInfo.LockedRect,
1903 pLockAlloc->LockInfo.fFlags.AreaValid ? &pLockAlloc->LockInfo.Area : NULL,
1904 true /*bool bToLockInfo*/);
1905 }
1906 hr = pD3DIfTex->UnlockRect(pData->SubResourceIndex);
1907 Assert(hr == S_OK);
1908 }
1909 else
1910 {
1911 Assert(pLockAlloc->LockInfo.cLocks < UINT32_MAX);
1912 }
1913 }
1914 else
1915 {
1916 AssertBreakpoint();
1917 }
1918 }
1919 else
1920 {
1921 struct
1922 {
1923 D3DDDICB_UNLOCK Unlock;
1924 D3DKMT_HANDLE hAllocation;
1925 } UnlockData;
1926
1927 UnlockData.Unlock.NumAllocations = 1;
1928 UnlockData.Unlock.phAllocations = &UnlockData.hAllocation;
1929 UnlockData.hAllocation = pRc->aAllocations[pData->SubResourceIndex].hAllocation;
1930
1931 hr = pDevice->RtCallbacks.pfnUnlockCb(hDevice, &UnlockData.Unlock);
1932 Assert(hr == S_OK);
1933 }
1934
1935 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1936 return hr;
1937}
1938static HRESULT APIENTRY vboxWddmDDevLockAsync(HANDLE hDevice, D3DDDIARG_LOCKASYNC* pData)
1939{
1940 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1941 AssertBreakpoint();
1942 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1943 return E_FAIL;
1944}
1945static HRESULT APIENTRY vboxWddmDDevUnlockAsync(HANDLE hDevice, CONST D3DDDIARG_UNLOCKASYNC* pData)
1946{
1947 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1948 AssertBreakpoint();
1949 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1950 return E_FAIL;
1951}
1952static HRESULT APIENTRY vboxWddmDDevRename(HANDLE hDevice, CONST D3DDDIARG_RENAME* pData)
1953{
1954 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1955 AssertBreakpoint();
1956 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1957 return E_FAIL;
1958}
1959
1960static HRESULT APIENTRY vboxWddmDDevCreateResource(HANDLE hDevice, D3DDDIARG_CREATERESOURCE* pResource)
1961{
1962 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1963 HRESULT hr = S_OK;
1964 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1965 Assert(pDevice);
1966 Assert(pResource);
1967 PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter;
1968
1969 if (VBOXDISPMODE_IS_3D(pAdapter))
1970 {
1971 PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(pResource->SurfCount);
1972 Assert(pRc);
1973 if (pRc)
1974 {
1975 pRc->hResource = pResource->hResource;
1976 pRc->pDevice = pDevice;
1977 pRc->fFlags = VBOXWDDM_RESOURCE_F_TYPE_GENERIC;
1978 vboxResourcePopulateRcDesc(&pRc->RcDesc, pResource);
1979 pRc->cAllocations = pResource->SurfCount;
1980 for (UINT i = 0; i < pResource->SurfCount; ++i)
1981 {
1982 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
1983 CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
1984 pAllocation->hAllocation = NULL;
1985 pAllocation->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC;
1986 pAllocation->pvMem = (void*)pSurf->pSysMem;
1987 pAllocation->SurfDesc.pitch = pSurf->SysMemPitch;
1988 pAllocation->SurfDesc.slicePitch = pSurf->SysMemSlicePitch;
1989 pAllocation->SurfDesc.depth = pSurf->Depth;
1990 pAllocation->SurfDesc.width = pSurf->Width;
1991 pAllocation->SurfDesc.height = pSurf->Height;
1992 pAllocation->SurfDesc.format = pResource->Format;
1993 }
1994
1995 if (pResource->Flags.RenderTarget)
1996 {
1997 HWND hWnd = NULL;
1998 Assert(pResource->SurfCount);
1999 Assert(!pDevice->pDevice9If);
2000 Assert(!pDevice->hWnd);
2001 hr = VBoxDispWndCreate(pAdapter, pResource->pSurfList[0].Width, pResource->pSurfList[0].Height, &hWnd);
2002 Assert(hr == S_OK);
2003 if (hr == S_OK)
2004 {
2005 DWORD fFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;
2006 if (pDevice->fFlags.AllowMultithreading)
2007 fFlags |= D3DCREATE_MULTITHREADED;
2008
2009 IDirect3DDevice9 *pDevice9If = NULL;
2010 D3DPRESENT_PARAMETERS params;
2011 memset(&params, 0, sizeof (params));
2012 // params.BackBufferWidth = 0;
2013 // params.BackBufferHeight = 0;
2014 params.BackBufferFormat = vboxDDI2D3DFormat(pResource->Format);
2015 Assert(pResource->SurfCount);
2016 params.BackBufferCount = pResource->SurfCount - 1;
2017 params.MultiSampleType = vboxDDI2D3DMultiSampleType(pResource->MultisampleType);
2018 if (pResource->Flags.DiscardRenderTarget)
2019 params.SwapEffect = D3DSWAPEFFECT_DISCARD;
2020 params.hDeviceWindow = hWnd;
2021 /* @todo: it seems there should be a way to detect this correctly since
2022 * our vboxWddmDDevSetDisplayMode will be called in case we are using full-screen */
2023 params.Windowed = TRUE;
2024 // params.EnableAutoDepthStencil = FALSE;
2025 // params.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
2026 // params.Flags;
2027 // params.FullScreen_RefreshRateInHz;
2028 // params.FullScreen_PresentationInterval;
2029 hr = pAdapter->pD3D9If->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, fFlags, &params, &pDevice9If);
2030 Assert(hr == S_OK);
2031 if (hr == S_OK)
2032 {
2033 pDevice->pDevice9If = pDevice9If;
2034 pDevice->hWnd = hWnd;
2035 for (UINT i = 0; i < pResource->SurfCount; ++i)
2036 {
2037 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2038
2039 IDirect3DSurface9* pD3D9Surf;
2040 hr = pDevice9If->CreateRenderTarget(pAllocation->SurfDesc.width,
2041 pAllocation->SurfDesc.height,
2042 vboxDDI2D3DFormat(pResource->Format),
2043 vboxDDI2D3DMultiSampleType(pResource->MultisampleType),
2044 pResource->MultisampleQuality,
2045 !pResource->Flags.NotLockable /* BOOL Lockable */,
2046 &pD3D9Surf,
2047 NULL /* HANDLE* pSharedHandle */
2048 );
2049 Assert(hr == S_OK);
2050 if (hr == S_OK)
2051 {
2052 Assert(pD3D9Surf);
2053 if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
2054 {
2055 Assert(pAllocation->pvMem);
2056 D3DLOCKED_RECT lockInfo;
2057 hr = pD3D9Surf->LockRect(&lockInfo, NULL, D3DLOCK_DISCARD);
2058 Assert(hr == S_OK);
2059 if (hr == S_OK)
2060 {
2061 vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
2062 HRESULT tmpHr = pD3D9Surf->UnlockRect();
2063 Assert(tmpHr == S_OK);
2064 }
2065 }
2066 else
2067 {
2068 Assert(!pAllocation->pvMem);
2069 }
2070 pAllocation->pD3DIf = pD3D9Surf;
2071 }
2072 else
2073 {
2074 for (UINT j = 0; j < i; ++j)
2075 {
2076 pRc->aAllocations[j].pD3DIf->Release();
2077 }
2078 break;
2079 }
2080 }
2081 }
2082
2083 if (hr != S_OK)
2084 {
2085 VBoxDispWndDestroy(pAdapter, hWnd);
2086 }
2087 }
2088 }
2089 else if (pResource->Flags.ZBuffer)
2090 {
2091 Assert(pDevice->pDevice9If);
2092 for (UINT i = 0; i < pResource->SurfCount; ++i)
2093 {
2094 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2095 IDirect3DSurface9 *pD3D9Surf;
2096 hr = pDevice->pDevice9If->CreateDepthStencilSurface(pAllocation->SurfDesc.width,
2097 pAllocation->SurfDesc.height,
2098 vboxDDI2D3DFormat(pResource->Format),
2099 vboxDDI2D3DMultiSampleType(pResource->MultisampleType),
2100 pResource->MultisampleQuality,
2101 TRUE /* @todo: BOOL Discard */,
2102 &pD3D9Surf,
2103 NULL /*HANDLE* pSharedHandle*/);
2104 Assert(hr == S_OK);
2105 if (hr == S_OK)
2106 {
2107 Assert(pD3D9Surf);
2108 if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
2109 {
2110 Assert(pAllocation->pvMem);
2111 D3DLOCKED_RECT lockInfo;
2112 hr = pD3D9Surf->LockRect(&lockInfo, NULL, D3DLOCK_DISCARD);
2113 Assert(hr == S_OK);
2114 if (hr == S_OK)
2115 {
2116 vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
2117 HRESULT tmpHr = pD3D9Surf->UnlockRect();
2118 Assert(tmpHr == S_OK);
2119 }
2120 }
2121 else
2122 {
2123 Assert(!pAllocation->pvMem);
2124 }
2125 pAllocation->pD3DIf = pD3D9Surf;
2126 }
2127 else
2128 {
2129 for (UINT j = 0; j < i; ++j)
2130 {
2131 pRc->aAllocations[j].pD3DIf->Release();
2132 }
2133 break;
2134 }
2135 }
2136 }
2137 else if (pResource->Flags.VertexBuffer)
2138 {
2139 Assert(pDevice->pDevice9If);
2140 for (UINT i = 0; i < pResource->SurfCount; ++i)
2141 {
2142 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2143 IDirect3DVertexBuffer9 *pD3D9VBuf;
2144 hr = pDevice->pDevice9If->CreateVertexBuffer(pAllocation->SurfDesc.width,
2145 vboxDDI2D3DUsage(pResource->Flags),
2146 pResource->Fvf,
2147 vboxDDI2D3DPool(pResource->Pool),
2148 &pD3D9VBuf,
2149 NULL /*HANDLE* pSharedHandle*/);
2150 Assert(hr == S_OK);
2151 if (hr == S_OK)
2152 {
2153 Assert(pD3D9VBuf);
2154 if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
2155 {
2156 Assert(pAllocation->pvMem);
2157 D3DLOCKED_RECT lockInfo;
2158 hr = pD3D9VBuf->Lock(0, pAllocation->SurfDesc.width, &lockInfo.pBits, D3DLOCK_DISCARD);
2159 Assert(hr == S_OK);
2160 if (hr == S_OK)
2161 {
2162 lockInfo.Pitch = pAllocation->SurfDesc.pitch;
2163 vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
2164 HRESULT tmpHr = pD3D9VBuf->Unlock();
2165 Assert(tmpHr == S_OK);
2166 }
2167 }
2168 else
2169 {
2170 Assert(!pAllocation->pvMem);
2171 }
2172 pAllocation->pD3DIf = pD3D9VBuf;
2173 }
2174 else
2175 {
2176 for (UINT j = 0; j < i; ++j)
2177 {
2178 pRc->aAllocations[j].pD3DIf->Release();
2179 }
2180 break;
2181 }
2182 }
2183 }
2184 else if (pResource->Flags.IndexBuffer)
2185 {
2186 Assert(pDevice->pDevice9If);
2187 for (UINT i = 0; i < pResource->SurfCount; ++i)
2188 {
2189 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2190 CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
2191 IDirect3DIndexBuffer9 *pD3D9IBuf;
2192 hr = pDevice->pDevice9If->CreateIndexBuffer(pSurf->Width,
2193 vboxDDI2D3DUsage(pResource->Flags),
2194 vboxDDI2D3DFormat(pResource->Format),
2195 vboxDDI2D3DPool(pResource->Pool),
2196 &pD3D9IBuf,
2197 NULL /*HANDLE* pSharedHandle*/
2198 );
2199 Assert(hr == S_OK);
2200 if (hr == S_OK)
2201 {
2202 Assert(pD3D9IBuf);
2203 if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
2204 {
2205 Assert(pAllocation->pvMem);
2206 D3DLOCKED_RECT lockInfo;
2207 hr = pD3D9IBuf->Lock(0, pAllocation->SurfDesc.width, &lockInfo.pBits, D3DLOCK_DISCARD);
2208 Assert(hr == S_OK);
2209 if (hr == S_OK)
2210 {
2211 lockInfo.Pitch = pAllocation->SurfDesc.pitch;
2212 vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
2213 HRESULT tmpHr = pD3D9IBuf->Unlock();
2214 Assert(tmpHr == S_OK);
2215 }
2216 }
2217 else
2218 {
2219 Assert(!pAllocation->pvMem);
2220 }
2221 pAllocation->pD3DIf = pD3D9IBuf;
2222 }
2223 else
2224 {
2225 for (UINT j = 0; j < i; ++j)
2226 {
2227 pRc->aAllocations[j].pD3DIf->Release();
2228 }
2229 break;
2230 }
2231 }
2232 }
2233 else if (pResource->Flags.Texture)
2234 {
2235 Assert(pDevice->pDevice9If);
2236#ifdef DEBUG
2237 {
2238 uint32_t tstW = pResource->pSurfList[0].Width;
2239 uint32_t tstH = pResource->pSurfList[0].Height;
2240 for (UINT i = 1; i < pResource->SurfCount; ++i)
2241 {
2242 tstW /= 2;
2243 tstH /= 2;
2244 CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
2245 Assert(pSurf->Width == tstW);
2246 Assert(pSurf->Height == tstH);
2247 }
2248 }
2249#endif
2250
2251 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0];
2252 CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[0];
2253 IDirect3DTexture9 *pD3DIfTex;
2254 hr = pDevice->pDevice9If->CreateTexture(pSurf->Width,
2255 pSurf->Height,
2256 pResource->SurfCount,
2257 vboxDDI2D3DUsage(pResource->Flags),
2258 vboxDDI2D3DFormat(pResource->Format),
2259 vboxDDI2D3DPool(pResource->Pool),
2260 &pD3DIfTex,
2261 NULL /* HANDLE* pSharedHandle */
2262 );
2263 Assert(hr == S_OK);
2264 if (hr == S_OK)
2265 {
2266 Assert(pD3DIfTex);
2267 if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
2268 {
2269 for (UINT i = 0; i < pResource->SurfCount; ++i)
2270 {
2271 D3DLOCKED_RECT lockInfo;
2272 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2273 Assert(pAllocation->pvMem);
2274 hr = pD3DIfTex->LockRect(i, &lockInfo, NULL, D3DLOCK_DISCARD);
2275 Assert(hr == S_OK);
2276 if (hr == S_OK)
2277 {
2278 vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
2279 HRESULT tmpHr = pD3DIfTex->UnlockRect(i);
2280 Assert(tmpHr == S_OK);
2281 }
2282 else
2283 {
2284 pD3DIfTex->Release();
2285 break;
2286 }
2287 }
2288 }
2289 pAllocation->pD3DIf = pD3DIfTex;
2290 }
2291#ifdef DEBUG
2292 else
2293 {
2294 for (UINT i = 0; i < pResource->SurfCount; ++i)
2295 {
2296 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2297 Assert(!pAllocation->pvMem);
2298 }
2299 }
2300#endif
2301 }
2302 else
2303 {
2304 Assert(pDevice->pDevice9If);
2305 Assert(0);
2306 }
2307
2308 if (hr == S_OK)
2309 pResource->hResource = pRc;
2310 else
2311 vboxResourceFree(pRc);
2312 }
2313 else
2314 {
2315 hr = E_OUTOFMEMORY;
2316 }
2317
2318 }
2319 else
2320 {
2321 /* allocate buffer for D3DDDICB_ALLOCATE + D3DDDI_ALLOCATIONINFO * numAllocs + PVBOXWDDM_RCINFO with aAllocInfos[numAllocs] */
2322 uint32_t cbBuf = sizeof (D3DDDICB_ALLOCATE);
2323 uint32_t offDdiAllocInfos = (cbBuf + 7) & ~3;
2324 uint32_t cbDdiAllocInfos = sizeof (D3DDDI_ALLOCATIONINFO) * pResource->SurfCount;
2325 cbBuf = offDdiAllocInfos + cbDdiAllocInfos;
2326 uint32_t offRcInfo = (cbBuf + 7) & ~3;
2327 uint32_t cbRcInfo = sizeof (VBOXWDDM_RCINFO);
2328 cbBuf = offRcInfo + cbRcInfo;
2329 uint32_t offAllocInfos = (cbBuf + 7) & ~3;
2330 uint32_t cbAllocInfos = sizeof (VBOXWDDM_ALLOCINFO) * pResource->SurfCount;
2331 cbBuf = offAllocInfos + cbAllocInfos;
2332 uint8_t *pvBuf = (uint8_t*)RTMemAllocZ(cbBuf);
2333 if (pvBuf)
2334 {
2335 D3DDDICB_ALLOCATE *pAllocate = (D3DDDICB_ALLOCATE*)pvBuf;
2336 D3DDDI_ALLOCATIONINFO* pDdiAllocInfos = (D3DDDI_ALLOCATIONINFO*)(pvBuf + offDdiAllocInfos);
2337 PVBOXWDDM_RCINFO pRcInfo = (PVBOXWDDM_RCINFO)(pvBuf + offRcInfo);
2338 PVBOXWDDM_ALLOCINFO pAllocInfos = (PVBOXWDDM_ALLOCINFO)(pvBuf + offAllocInfos);
2339 pAllocate->pPrivateDriverData = pRcInfo;
2340 pAllocate->PrivateDriverDataSize = cbRcInfo;
2341 pAllocate->hResource = pResource->hResource;
2342 pAllocate->hKMResource = NULL;
2343 pAllocate->NumAllocations = pResource->SurfCount;
2344 pAllocate->pAllocationInfo = pDdiAllocInfos;
2345
2346 pRcInfo->fFlags = VBOXWDDM_RESOURCE_F_TYPE_GENERIC;
2347 pRcInfo->RcDesc.fFlags = pResource->Flags;
2348 pRcInfo->RcDesc.enmFormat = pResource->Format;
2349 pRcInfo->RcDesc.enmPool = pResource->Pool;
2350 pRcInfo->RcDesc.enmMultisampleType = pResource->MultisampleType;
2351 pRcInfo->RcDesc.MultisampleQuality = pResource->MultisampleQuality;
2352 pRcInfo->RcDesc.MipLevels = pResource->MipLevels;
2353 pRcInfo->RcDesc.Fvf = pResource->Fvf;
2354 pRcInfo->RcDesc.VidPnSourceId = pResource->VidPnSourceId;
2355 pRcInfo->RcDesc.RefreshRate = pResource->RefreshRate;
2356 pRcInfo->RcDesc.enmRotation = pResource->Rotation;
2357 pRcInfo->cAllocInfos = pResource->SurfCount;
2358
2359 for (UINT i = 0; i < pResource->SurfCount; ++i)
2360 {
2361 PVBOXWDDM_ALLOCINFO pAllocInfo = &pAllocInfos[i];
2362 D3DDDI_ALLOCATIONINFO* pDdiAllocInfo = &pDdiAllocInfos[i];
2363 CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
2364 pDdiAllocInfo->hAllocation = NULL;
2365 pDdiAllocInfo->pSystemMem = pSurf->pSysMem;
2366 Assert((!!(pSurf->pSysMem)) == (pResource->Pool == D3DDDIPOOL_SYSTEMMEM));
2367 pDdiAllocInfo->pPrivateDriverData = pAllocInfo;
2368 pDdiAllocInfo->PrivateDriverDataSize = sizeof (VBOXWDDM_ALLOCINFO);
2369 pDdiAllocInfo->VidPnSourceId = pResource->VidPnSourceId;
2370 pDdiAllocInfo->Flags.Value = 0;
2371 if (pResource->Flags.Primary)
2372 pDdiAllocInfo->Flags.Primary = 1;
2373
2374 pAllocInfo->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC;
2375 pAllocInfo->SurfDesc.width = pSurf->Width;
2376 pAllocInfo->SurfDesc.height = pSurf->Height;
2377 pAllocInfo->SurfDesc.format = pResource->Format;
2378 pAllocInfo->SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pResource->Format);
2379
2380 if (pSurf->SysMemPitch)
2381 {
2382 pAllocInfo->SurfDesc.pitch = pSurf->SysMemPitch;
2383#ifdef DEBUG
2384 UINT tst = vboxWddmCalcPitch(pSurf->Width, pAllocInfo->SurfDesc.bpp);
2385 Assert(tst == pSurf->SysMemPitch);
2386#endif
2387 }
2388 else
2389 pAllocInfo->SurfDesc.pitch = vboxWddmCalcPitch(pSurf->Width, pAllocInfo->SurfDesc.bpp);
2390
2391 pAllocInfo->SurfDesc.cbSize = pAllocInfo->SurfDesc.pitch * pAllocInfo->SurfDesc.height;
2392 pAllocInfo->SurfDesc.depth = pSurf->Depth;
2393 pAllocInfo->SurfDesc.slicePitch = pSurf->SysMemSlicePitch;
2394 pAllocInfo->SurfDesc.VidPnSourceId = pResource->VidPnSourceId;
2395 pAllocInfo->SurfDesc.RefreshRate = pResource->RefreshRate;
2396 }
2397
2398 hr = pDevice->RtCallbacks.pfnAllocateCb(pDevice->hDevice, pAllocate);
2399 Assert(hr == S_OK);
2400 if (hr == S_OK)
2401 {
2402 Assert(pAllocate->hKMResource);
2403 PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(pResource->SurfCount);
2404 Assert(pRc);
2405 if (pRc)
2406 {
2407 pRc->hResource = pResource->hResource;
2408 pRc->hKMResource = pAllocate->hKMResource;
2409 pRc->pDevice = pDevice;
2410 pRc->fFlags = pRcInfo->fFlags;
2411 pRc->RcDesc = pRcInfo->RcDesc;
2412 pRc->cAllocations = pRcInfo->cAllocInfos;
2413 for (UINT i = 0; i < pRcInfo->cAllocInfos; ++i)
2414 {
2415 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2416 D3DDDI_ALLOCATIONINFO* pDdiAllocInfo = &pDdiAllocInfos[i];
2417 PVBOXWDDM_ALLOCINFO pAllocInfo = &pAllocInfos[i];
2418 CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
2419 pAllocation->hAllocation = pDdiAllocInfo->hAllocation;
2420 pAllocation->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC;
2421 pAllocation->pvMem = (void*)pSurf->pSysMem;
2422 pAllocation->SurfDesc = pAllocInfo->SurfDesc;
2423 }
2424
2425 pResource->hResource = pRc;
2426 // vboxResourceFree(pRc);
2427 }
2428 else
2429 {
2430 hr = E_OUTOFMEMORY;
2431 }
2432 }
2433
2434 RTMemFree(pvBuf);
2435 }
2436 else
2437 {
2438 hr = E_OUTOFMEMORY;
2439 }
2440 }
2441
2442 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2443 return hr;
2444}
2445
2446static HRESULT APIENTRY vboxWddmDDevDestroyResource(HANDLE hDevice, HANDLE hResource)
2447{
2448 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2449 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2450 PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter;
2451 PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)hResource;
2452
2453 HRESULT hr = S_OK;
2454
2455 Assert(pDevice);
2456 Assert(hResource);
2457
2458 if (VBOXDISPMODE_IS_3D(pAdapter))
2459 {
2460 if (pRc->RcDesc.fFlags.RenderTarget)
2461 {
2462 Assert(pDevice->hWnd);
2463 Assert(pDevice->pDevice9If);
2464 pDevice->pDevice9If->Release();
2465 HRESULT tmpHr = VBoxDispWndDestroy(pAdapter, pDevice->hWnd);
2466 Assert(tmpHr == S_OK);
2467 }
2468
2469 for (UINT i = 0; i < pRc->cAllocations; ++i)
2470 {
2471 PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];
2472 if (pAlloc->pD3DIf)
2473 pAlloc->pD3DIf->Release();
2474 }
2475 }
2476 else
2477 {
2478 if (!(pRc->fFlags & VBOXWDDM_RESOURCE_F_OPENNED))
2479 {
2480 D3DDDICB_DEALLOCATE Dealloc;
2481 Dealloc.hResource = pRc->hResource;
2482 Assert(pRc->hResource);
2483 /* according to the docs the below two are ignored in case we set the hResource */
2484 Dealloc.NumAllocations = 0;
2485 Dealloc.HandleList = NULL;
2486 hr = pDevice->RtCallbacks.pfnDeallocateCb(pDevice->hDevice, &Dealloc);
2487 Assert(hr == S_OK);
2488 }
2489 }
2490
2491 vboxResourceFree(pRc);
2492 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2493 return hr;
2494}
2495static HRESULT APIENTRY vboxWddmDDevSetDisplayMode(HANDLE hDevice, CONST D3DDDIARG_SETDISPLAYMODE* pData)
2496{
2497 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2498 AssertBreakpoint();
2499 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2500 return E_FAIL;
2501}
2502static HRESULT APIENTRY vboxWddmDDevPresent(HANDLE hDevice, CONST D3DDDIARG_PRESENT* pData)
2503{
2504 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2505 AssertBreakpoint();
2506 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2507 return E_FAIL;
2508}
2509static HRESULT APIENTRY vboxWddmDDevFlush(HANDLE hDevice)
2510{
2511 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2512 AssertBreakpoint();
2513 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2514 return E_FAIL;
2515}
2516static HRESULT APIENTRY vboxWddmDDevCreateVertexShaderDecl(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERDECL* pData, CONST D3DDDIVERTEXELEMENT* pVertexElements)
2517{
2518 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2519 AssertBreakpoint();
2520 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2521 return E_FAIL;
2522}
2523static HRESULT APIENTRY vboxWddmDDevSetVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
2524{
2525 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2526 AssertBreakpoint();
2527 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2528 return E_FAIL;
2529}
2530static HRESULT APIENTRY vboxWddmDDevDeleteVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
2531{
2532 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2533 AssertBreakpoint();
2534 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2535 return E_FAIL;
2536}
2537static HRESULT APIENTRY vboxWddmDDevCreateVertexShaderFunc(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERFUNC* pData, CONST UINT* pCode)
2538{
2539 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2540 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2541 Assert(pDevice);
2542 Assert(pDevice->pDevice9If);
2543 IDirect3DVertexShader9 *pShader;
2544 Assert(*((UINT*)((uint8_t*)pCode + pData->Size-4)) == 0x0000FFFF /* end token */);
2545 HRESULT hr = pDevice->pDevice9If->CreateVertexShader((const DWORD *)pCode, &pShader);
2546 Assert(hr == S_OK);
2547 if (hr == S_OK)
2548 {
2549 Assert(pShader);
2550 pData->ShaderHandle = pShader;
2551 }
2552 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2553 return hr;
2554}
2555static HRESULT APIENTRY vboxWddmDDevSetVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
2556{
2557 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2558 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2559 Assert(pDevice);
2560 Assert(pDevice->pDevice9If);
2561 IDirect3DVertexShader9 *pShader = (IDirect3DVertexShader9*)hShaderHandle;
2562 Assert(pShader);
2563 HRESULT hr = pDevice->pDevice9If->SetVertexShader(pShader);
2564 Assert(hr == S_OK);
2565 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2566 return hr;
2567}
2568static HRESULT APIENTRY vboxWddmDDevDeleteVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
2569{
2570 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2571 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2572 Assert(pDevice);
2573 Assert(pDevice->pDevice9If);
2574 IDirect3DVertexShader9 *pShader = (IDirect3DVertexShader9*)hShaderHandle;
2575 HRESULT hr = pShader->Release();
2576 Assert(hr == S_OK);
2577 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2578 return hr;
2579}
2580static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTI* pData, CONST INT* pRegisters)
2581{
2582 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2583 AssertBreakpoint();
2584 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2585 return E_FAIL;
2586}
2587static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTB* pData, CONST BOOL* pRegisters)
2588{
2589 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2590 AssertBreakpoint();
2591 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2592 return E_FAIL;
2593}
2594static HRESULT APIENTRY vboxWddmDDevSetScissorRect(HANDLE hDevice, CONST RECT* pRect)
2595{
2596 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2597 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2598 Assert(pDevice);
2599 Assert(pDevice->pDevice9If);
2600 HRESULT hr = pDevice->pDevice9If->SetScissorRect(pRect);
2601 Assert(hr == S_OK);
2602 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2603 return hr;
2604}
2605static HRESULT APIENTRY vboxWddmDDevSetStreamSource(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCE* pData)
2606{
2607 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2608 AssertBreakpoint();
2609 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2610 return E_FAIL;
2611}
2612static HRESULT APIENTRY vboxWddmDDevSetStreamSourceFreq(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEFREQ* pData)
2613{
2614 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2615 AssertBreakpoint();
2616 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2617 return E_FAIL;
2618}
2619static HRESULT APIENTRY vboxWddmDDevSetConvolutionKernelMono(HANDLE hDevice, CONST D3DDDIARG_SETCONVOLUTIONKERNELMONO* pData)
2620{
2621 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2622 AssertBreakpoint();
2623 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2624 return E_FAIL;
2625}
2626static HRESULT APIENTRY vboxWddmDDevComposeRects(HANDLE hDevice, CONST D3DDDIARG_COMPOSERECTS* pData)
2627{
2628 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2629 AssertBreakpoint();
2630 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2631 return E_FAIL;
2632}
2633static HRESULT APIENTRY vboxWddmDDevBlt(HANDLE hDevice, CONST D3DDDIARG_BLT* pData)
2634{
2635 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2636 AssertBreakpoint();
2637 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2638 return E_FAIL;
2639}
2640static HRESULT APIENTRY vboxWddmDDevColorFill(HANDLE hDevice, CONST D3DDDIARG_COLORFILL* pData)
2641{
2642 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2643 AssertBreakpoint();
2644 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2645 return E_FAIL;
2646}
2647static HRESULT APIENTRY vboxWddmDDevDepthFill(HANDLE hDevice, CONST D3DDDIARG_DEPTHFILL* pData)
2648{
2649 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2650 AssertBreakpoint();
2651 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2652 return E_FAIL;
2653}
2654static HRESULT APIENTRY vboxWddmDDevCreateQuery(HANDLE hDevice, D3DDDIARG_CREATEQUERY* pData)
2655{
2656 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2657 AssertBreakpoint();
2658 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2659 return E_FAIL;
2660}
2661static HRESULT APIENTRY vboxWddmDDevDestroyQuery(HANDLE hDevice, HANDLE hQuery)
2662{
2663 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2664 AssertBreakpoint();
2665 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2666 return E_FAIL;
2667}
2668static HRESULT APIENTRY vboxWddmDDevIssueQuery(HANDLE hDevice, CONST D3DDDIARG_ISSUEQUERY* pData)
2669{
2670 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2671 AssertBreakpoint();
2672 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2673 return E_FAIL;
2674}
2675static HRESULT APIENTRY vboxWddmDDevGetQueryData(HANDLE hDevice, CONST D3DDDIARG_GETQUERYDATA* pData)
2676{
2677 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2678 AssertBreakpoint();
2679 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2680 return E_FAIL;
2681}
2682static HRESULT APIENTRY vboxWddmDDevSetRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETRENDERTARGET* pData)
2683{
2684 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2685 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2686 Assert(pDevice);
2687 Assert(pDevice->pDevice9If);
2688 PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hRenderTarget;
2689 Assert(pRc);
2690 Assert(pData->SubResourceIndex < pRc->cAllocations);
2691 IDirect3DSurface9 *pD3D9Surf = (IDirect3DSurface9*)pRc->aAllocations[pData->SubResourceIndex].pD3DIf;
2692 Assert(pD3D9Surf);
2693 HRESULT hr = pDevice->pDevice9If->SetRenderTarget(pData->RenderTargetIndex, pD3D9Surf);
2694 Assert(hr == S_OK);
2695 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2696 return hr;
2697}
2698static HRESULT APIENTRY vboxWddmDDevSetDepthStencil(HANDLE hDevice, CONST D3DDDIARG_SETDEPTHSTENCIL* pData)
2699{
2700 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2701 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2702 Assert(pDevice);
2703 Assert(pDevice->pDevice9If);
2704 PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hZBuffer;
2705 Assert(pRc);
2706 Assert(pRc->cAllocations == 1);
2707 IDirect3DSurface9 *pD3D9Surf = (IDirect3DSurface9*)pRc->aAllocations[0].pD3DIf;
2708 Assert(pD3D9Surf);
2709 HRESULT hr = pDevice->pDevice9If->SetDepthStencilSurface(pD3D9Surf);
2710 Assert(hr == S_OK);
2711 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2712 return hr;
2713}
2714static HRESULT APIENTRY vboxWddmDDevGenerateMipSubLevels(HANDLE hDevice, CONST D3DDDIARG_GENERATEMIPSUBLEVELS* pData)
2715{
2716 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2717 AssertBreakpoint();
2718 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2719 return E_FAIL;
2720}
2721static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTI* pData, CONST INT* pRegisters)
2722{
2723 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2724 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2725 Assert(pDevice);
2726 Assert(pDevice->pDevice9If);
2727 HRESULT hr = pDevice->pDevice9If->SetPixelShaderConstantI(pData->Register, pRegisters, pData->Count);
2728 Assert(hr == S_OK);
2729 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2730 return hr;
2731}
2732static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTB* pData, CONST BOOL* pRegisters)
2733{
2734 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2735 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2736 Assert(pDevice);
2737 Assert(pDevice->pDevice9If);
2738 HRESULT hr = pDevice->pDevice9If->SetPixelShaderConstantB(pData->Register, pRegisters, pData->Count);
2739 Assert(hr == S_OK);
2740 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2741 return hr;
2742}
2743static HRESULT APIENTRY vboxWddmDDevCreatePixelShader(HANDLE hDevice, D3DDDIARG_CREATEPIXELSHADER* pData, CONST UINT* pCode)
2744{
2745 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2746 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2747 Assert(pDevice);
2748 Assert(pDevice->pDevice9If);
2749 IDirect3DPixelShader9 *pShader;
2750 Assert(*((UINT*)((uint8_t*)pCode + pData->CodeSize-4)) == 0x0000FFFF /* end token */);
2751 HRESULT hr = pDevice->pDevice9If->CreatePixelShader((const DWORD *)pCode, &pShader);
2752 Assert(hr == S_OK);
2753 if (hr == S_OK)
2754 {
2755 Assert(pShader);
2756 pData->ShaderHandle = pShader;
2757 }
2758 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2759 return hr;
2760}
2761static HRESULT APIENTRY vboxWddmDDevDeletePixelShader(HANDLE hDevice, HANDLE hShaderHandle)
2762{
2763 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2764 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2765 Assert(pDevice);
2766 Assert(pDevice->pDevice9If);
2767 IDirect3DPixelShader9 *pShader = (IDirect3DPixelShader9*)hShaderHandle;
2768 HRESULT hr = pShader->Release();
2769 Assert(hr == S_OK);
2770 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2771 return hr;
2772}
2773static HRESULT APIENTRY vboxWddmDDevCreateDecodeDevice(HANDLE hDevice, D3DDDIARG_CREATEDECODEDEVICE* pData)
2774{
2775 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2776 AssertBreakpoint();
2777 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2778 return E_FAIL;
2779}
2780static HRESULT APIENTRY vboxWddmDDevDestroyDecodeDevice(HANDLE hDevice, HANDLE hDecodeDevice)
2781{
2782 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2783 AssertBreakpoint();
2784 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2785 return E_FAIL;
2786}
2787static HRESULT APIENTRY vboxWddmDDevSetDecodeRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETDECODERENDERTARGET* pData)
2788{
2789 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2790 AssertBreakpoint();
2791 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2792 return E_FAIL;
2793}
2794static HRESULT APIENTRY vboxWddmDDevDecodeBeginFrame(HANDLE hDevice, D3DDDIARG_DECODEBEGINFRAME* pData)
2795{
2796 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2797 AssertBreakpoint();
2798 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2799 return E_FAIL;
2800}
2801static HRESULT APIENTRY vboxWddmDDevDecodeEndFrame(HANDLE hDevice, D3DDDIARG_DECODEENDFRAME* pData)
2802{
2803 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2804 AssertBreakpoint();
2805 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2806 return E_FAIL;
2807}
2808static HRESULT APIENTRY vboxWddmDDevDecodeExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXECUTE* pData)
2809{
2810 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2811 AssertBreakpoint();
2812 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2813 return E_FAIL;
2814}
2815static HRESULT APIENTRY vboxWddmDDevDecodeExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXTENSIONEXECUTE* pData)
2816{
2817 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2818 AssertBreakpoint();
2819 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2820 return E_FAIL;
2821}
2822static HRESULT APIENTRY vboxWddmDDevCreateVideoProcessDevice(HANDLE hDevice, D3DDDIARG_CREATEVIDEOPROCESSDEVICE* pData)
2823{
2824 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2825 AssertBreakpoint();
2826 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2827 return E_FAIL;
2828}
2829static HRESULT APIENTRY vboxWddmDDevDestroyVideoProcessDevice(HANDLE hDevice, HANDLE hVideoProcessor)
2830{
2831 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2832 AssertBreakpoint();
2833 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2834 return E_FAIL;
2835}
2836static HRESULT APIENTRY vboxWddmDDevVideoProcessBeginFrame(HANDLE hDevice, HANDLE hVideoProcess)
2837{
2838 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2839 AssertBreakpoint();
2840 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2841 return E_FAIL;
2842}
2843static HRESULT APIENTRY vboxWddmDDevVideoProcessEndFrame(HANDLE hDevice, D3DDDIARG_VIDEOPROCESSENDFRAME* pData)
2844{
2845 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2846 AssertBreakpoint();
2847 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2848 return E_FAIL;
2849}
2850static HRESULT APIENTRY vboxWddmDDevSetVideoProcessRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETVIDEOPROCESSRENDERTARGET* pData)
2851{
2852 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2853 AssertBreakpoint();
2854 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2855 return E_FAIL;
2856}
2857static HRESULT APIENTRY vboxWddmDDevVideoProcessBlt(HANDLE hDevice, CONST D3DDDIARG_VIDEOPROCESSBLT* pData)
2858{
2859 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2860 AssertBreakpoint();
2861 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2862 return E_FAIL;
2863}
2864static HRESULT APIENTRY vboxWddmDDevCreateExtensionDevice(HANDLE hDevice, D3DDDIARG_CREATEEXTENSIONDEVICE* pData)
2865{
2866 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2867 AssertBreakpoint();
2868 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2869 return E_FAIL;
2870}
2871static HRESULT APIENTRY vboxWddmDDevDestroyExtensionDevice(HANDLE hDevice, HANDLE hExtension)
2872{
2873 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2874 AssertBreakpoint();
2875 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2876 return E_FAIL;
2877}
2878static HRESULT APIENTRY vboxWddmDDevExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_EXTENSIONEXECUTE* pData)
2879{
2880 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2881 AssertBreakpoint();
2882 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2883 return E_FAIL;
2884}
2885static HRESULT APIENTRY vboxWddmDDevDestroyDevice(IN HANDLE hDevice)
2886{
2887 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2888
2889 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2890 if (pDevice->DefaultContext.ContextInfo.hContext)
2891 {
2892 D3DDDICB_DESTROYCONTEXT DestroyContext;
2893 DestroyContext.hContext = pDevice->DefaultContext.ContextInfo.hContext;
2894 HRESULT tmpHr = pDevice->RtCallbacks.pfnDestroyContextCb(pDevice->hDevice, &DestroyContext);
2895 Assert(tmpHr == S_OK);
2896 }
2897 RTMemFree(hDevice);
2898 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2899 return S_OK;
2900}
2901static HRESULT APIENTRY vboxWddmDDevCreateOverlay(HANDLE hDevice, D3DDDIARG_CREATEOVERLAY* pData)
2902{
2903 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2904 AssertBreakpoint();
2905 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2906 return E_FAIL;
2907}
2908static HRESULT APIENTRY vboxWddmDDevUpdateOverlay(HANDLE hDevice, CONST D3DDDIARG_UPDATEOVERLAY* pData)
2909{
2910 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2911 AssertBreakpoint();
2912 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2913 return E_FAIL;
2914}
2915static HRESULT APIENTRY vboxWddmDDevFlipOverlay(HANDLE hDevice, CONST D3DDDIARG_FLIPOVERLAY* pData)
2916{
2917 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2918 AssertBreakpoint();
2919 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2920 return E_FAIL;
2921}
2922static HRESULT APIENTRY vboxWddmDDevGetOverlayColorControls(HANDLE hDevice, D3DDDIARG_GETOVERLAYCOLORCONTROLS* pData)
2923{
2924 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2925 AssertBreakpoint();
2926 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2927 return E_FAIL;
2928}
2929static HRESULT APIENTRY vboxWddmDDevSetOverlayColorControls(HANDLE hDevice, CONST D3DDDIARG_SETOVERLAYCOLORCONTROLS* pData)
2930{
2931 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2932 AssertBreakpoint();
2933 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2934 return E_FAIL;
2935}
2936static HRESULT APIENTRY vboxWddmDDevDestroyOverlay(HANDLE hDevice, CONST D3DDDIARG_DESTROYOVERLAY* pData)
2937{
2938 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2939 AssertBreakpoint();
2940 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2941 return E_FAIL;
2942}
2943static HRESULT APIENTRY vboxWddmDDevQueryResourceResidency(HANDLE hDevice, CONST D3DDDIARG_QUERYRESOURCERESIDENCY* pData)
2944{
2945 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2946 AssertBreakpoint();
2947 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2948 return E_FAIL;
2949}
2950
2951static HRESULT vboxAllocationInit(PVBOXWDDMDISP_ALLOCATION pAlloc, D3DDDI_OPENALLOCATIONINFO *pInfo)
2952{
2953 HRESULT hr = S_OK;
2954 pAlloc->hAllocation = pInfo->hAllocation;
2955 Assert(pInfo->PrivateDriverDataSize == sizeof (VBOXWDDM_ALLOCINFO));
2956 Assert(pInfo->pPrivateDriverData);
2957 if (pInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO))
2958 {
2959 PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pInfo->pPrivateDriverData;
2960 pAlloc->enmType = pAllocInfo->enmType;
2961 Assert(pAllocInfo->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
2962 || VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE
2963 || VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE);
2964 pAlloc->pvMem = NULL;
2965 pAlloc->SurfDesc = pAllocInfo->SurfDesc;
2966 }
2967 else
2968 {
2969 vboxVDbgPrintR((__FUNCTION__": ERROR: PrivateDriverDataSize(%d) < (%d)\n", pInfo->PrivateDriverDataSize, sizeof (VBOXWDDM_ALLOCINFO)));
2970 hr = E_INVALIDARG;
2971 }
2972 return hr;
2973}
2974
2975static HRESULT APIENTRY vboxWddmDDevOpenResource(HANDLE hDevice, D3DDDIARG_OPENRESOURCE* pData)
2976{
2977 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2978 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2979 HRESULT hr = S_OK;
2980
2981 Assert(pDevice);
2982 Assert(pData->NumAllocations);
2983 PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(pData->NumAllocations);
2984 Assert(pRc);
2985 if (pRc)
2986 {
2987 pRc->hResource = pData->hResource;
2988 pRc->hKMResource = pData->hKMResource;
2989 pRc->pDevice = pDevice;
2990 pRc->RcDesc.enmRotation = pData->Rotation;
2991 pRc->fFlags = VBOXWDDM_RESOURCE_F_OPENNED;
2992 if (!pData->pPrivateDriverData || !pData->PrivateDriverDataSize)
2993 {
2994 /* this is a "standard" allocation resource */
2995
2996 /* both should be actually zero */
2997 Assert(!pData->pPrivateDriverData && !pData->PrivateDriverDataSize);
2998 pRc->RcDesc.enmPool = D3DDDIPOOL_LOCALVIDMEM;
2999 pRc->RcDesc.enmMultisampleType = D3DDDIMULTISAMPLE_NONE;
3000 pRc->RcDesc.MultisampleQuality = 0;
3001 pRc->RcDesc.MipLevels = 0;
3002 pRc->RcDesc.Fvf;
3003 pRc->RcDesc.fFlags.Value = 0;
3004
3005 Assert(pData->NumAllocations);
3006 D3DDDI_OPENALLOCATIONINFO* pDdiAllocInfo = &pData->pOpenAllocationInfo[0];
3007 Assert(pDdiAllocInfo->pPrivateDriverData);
3008 Assert(pDdiAllocInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO));
3009 if (pDdiAllocInfo->pPrivateDriverData && pDdiAllocInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO))
3010 {
3011 PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pDdiAllocInfo->pPrivateDriverData;
3012 switch(pAllocInfo->enmType)
3013 {
3014 case VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE:
3015 pRc->RcDesc.fFlags.Primary = 1;
3016 case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
3017 case VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE:
3018 pRc->RcDesc.enmFormat = pAllocInfo->SurfDesc.format;
3019 pRc->RcDesc.VidPnSourceId = pAllocInfo->SurfDesc.VidPnSourceId;
3020 pRc->RcDesc.RefreshRate = pAllocInfo->SurfDesc.RefreshRate;
3021 break;
3022 default:
3023 AssertBreakpoint();
3024 hr = E_INVALIDARG;
3025 }
3026 }
3027 else
3028 hr = E_INVALIDARG;
3029 }
3030 else
3031 {
3032 /* this is a "generic" resource whose creation is initiaded by the UMD */
3033 Assert(pData->PrivateDriverDataSize == sizeof (VBOXWDDM_RCINFO));
3034 if (pData->PrivateDriverDataSize >= sizeof (VBOXWDDM_RCINFO))
3035 {
3036 VBOXWDDM_RCINFO *pRcInfo = (VBOXWDDM_RCINFO*)pData->pPrivateDriverData;
3037 Assert(pRcInfo->fFlags == VBOXWDDM_RESOURCE_F_TYPE_GENERIC);
3038 Assert(pRcInfo->cAllocInfos == pData->NumAllocations);
3039 pRc->fFlags = pRcInfo->fFlags | VBOXWDDM_RESOURCE_F_OPENNED;
3040 pRc->RcDesc = pRcInfo->RcDesc;
3041 pRc->cAllocations = pData->NumAllocations;
3042 }
3043 else
3044 hr = E_INVALIDARG;
3045 }
3046
3047 if (hr == S_OK)
3048 {
3049 for (UINT i = 0; i < pData->NumAllocations; ++i)
3050 {
3051 hr = vboxAllocationInit(&pRc->aAllocations[i], &pData->pOpenAllocationInfo[i]);
3052 Assert(hr == S_OK);
3053 if (hr != S_OK)
3054 break;
3055 }
3056 }
3057
3058 if (hr == S_OK)
3059 pData->hResource = pRc;
3060 else
3061 vboxResourceFree(pRc);
3062 }
3063 else
3064 {
3065 vboxVDbgPrintR((__FUNCTION__": vboxResourceAlloc failed for hDevice(0x%p), NumAllocations(%d)\n", hDevice, pData->NumAllocations));
3066 hr = E_OUTOFMEMORY;
3067 }
3068
3069 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3070 return hr;
3071}
3072static HRESULT APIENTRY vboxWddmDDevGetCaptureAllocationHandle(HANDLE hDevice, D3DDDIARG_GETCAPTUREALLOCATIONHANDLE* pData)
3073{
3074 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3075 AssertBreakpoint();
3076 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3077 return E_FAIL;
3078}
3079
3080static HRESULT APIENTRY vboxWddmDDevCaptureToSysMem(HANDLE hDevice, CONST D3DDDIARG_CAPTURETOSYSMEM* pData)
3081{
3082 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3083 AssertBreakpoint();
3084 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3085 return E_FAIL;
3086}
3087
3088static HRESULT APIENTRY vboxWddmDispCreateDevice (IN HANDLE hAdapter, IN D3DDDIARG_CREATEDEVICE* pCreateData)
3089{
3090 HRESULT hr = S_OK;
3091 vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p), Interface(%d), Version(%d)\n", hAdapter, pCreateData->Interface, pCreateData->Version));
3092
3093// AssertBreakpoint();
3094
3095 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)RTMemAllocZ(sizeof (VBOXWDDMDISP_DEVICE));
3096 if (pDevice)
3097 {
3098 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
3099
3100 pDevice->hDevice = pCreateData->hDevice;
3101 pDevice->pAdapter = pAdapter;
3102 pDevice->u32IfVersion = pCreateData->Interface;
3103 pDevice->uRtVersion = pCreateData->Version;
3104 pDevice->RtCallbacks = *pCreateData->pCallbacks;
3105 pDevice->pvCmdBuffer = pCreateData->pCommandBuffer;
3106 pDevice->cbCmdBuffer = pCreateData->CommandBufferSize;
3107 pDevice->fFlags = pCreateData->Flags;
3108 /* Set Viewport to some default values */
3109 pDevice->ViewPort.X = 0;
3110 pDevice->ViewPort.Y = 0;
3111 pDevice->ViewPort.Width = 1;
3112 pDevice->ViewPort.Height = 1;
3113 pDevice->ViewPort.MinZ = 0.;
3114 pDevice->ViewPort.MaxZ = 1.;
3115
3116 Assert(!pCreateData->AllocationListSize);
3117 Assert(!pCreateData->PatchLocationListSize);
3118
3119 pCreateData->hDevice = pDevice;
3120
3121 pCreateData->pDeviceFuncs->pfnSetRenderState = vboxWddmDDevSetRenderState;
3122 pCreateData->pDeviceFuncs->pfnUpdateWInfo = vboxWddmDDevUpdateWInfo;
3123 pCreateData->pDeviceFuncs->pfnValidateDevice = vboxWddmDDevValidateDevice;
3124 pCreateData->pDeviceFuncs->pfnSetTextureStageState = vboxWddmDDevSetTextureStageState;
3125 pCreateData->pDeviceFuncs->pfnSetTexture = vboxWddmDDevSetTexture;
3126 pCreateData->pDeviceFuncs->pfnSetPixelShader = vboxWddmDDevSetPixelShader;
3127 pCreateData->pDeviceFuncs->pfnSetPixelShaderConst = vboxWddmDDevSetPixelShaderConst;
3128 pCreateData->pDeviceFuncs->pfnSetStreamSourceUm = vboxWddmDDevSetStreamSourceUm;
3129 pCreateData->pDeviceFuncs->pfnSetIndices = vboxWddmDDevSetIndices;
3130 pCreateData->pDeviceFuncs->pfnSetIndicesUm = vboxWddmDDevSetIndicesUm;
3131 pCreateData->pDeviceFuncs->pfnDrawPrimitive = vboxWddmDDevDrawPrimitive;
3132 pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive = vboxWddmDDevDrawIndexedPrimitive;
3133 pCreateData->pDeviceFuncs->pfnDrawRectPatch = vboxWddmDDevDrawRectPatch;
3134 pCreateData->pDeviceFuncs->pfnDrawTriPatch = vboxWddmDDevDrawTriPatch;
3135 pCreateData->pDeviceFuncs->pfnDrawPrimitive2 = vboxWddmDDevDrawPrimitive2;
3136 pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive2 = vboxWddmDDevDrawIndexedPrimitive2;
3137 pCreateData->pDeviceFuncs->pfnVolBlt = vboxWddmDDevVolBlt;
3138 pCreateData->pDeviceFuncs->pfnBufBlt = vboxWddmDDevBufBlt;
3139 pCreateData->pDeviceFuncs->pfnTexBlt = vboxWddmDDevTexBlt;
3140 pCreateData->pDeviceFuncs->pfnStateSet = vboxWddmDDevStateSet;
3141 pCreateData->pDeviceFuncs->pfnSetPriority = vboxWddmDDevSetPriority;
3142 pCreateData->pDeviceFuncs->pfnClear = vboxWddmDDevClear;
3143 pCreateData->pDeviceFuncs->pfnUpdatePalette = vboxWddmDDevUpdatePalette;
3144 pCreateData->pDeviceFuncs->pfnSetPalette = vboxWddmDDevSetPalette;
3145 pCreateData->pDeviceFuncs->pfnSetVertexShaderConst = vboxWddmDDevSetVertexShaderConst;
3146 pCreateData->pDeviceFuncs->pfnMultiplyTransform = vboxWddmDDevMultiplyTransform;
3147 pCreateData->pDeviceFuncs->pfnSetTransform = vboxWddmDDevSetTransform;
3148 pCreateData->pDeviceFuncs->pfnSetViewport = vboxWddmDDevSetViewport;
3149 pCreateData->pDeviceFuncs->pfnSetZRange = vboxWddmDDevSetZRange;
3150 pCreateData->pDeviceFuncs->pfnSetMaterial = vboxWddmDDevSetMaterial;
3151 pCreateData->pDeviceFuncs->pfnSetLight = vboxWddmDDevSetLight;
3152 pCreateData->pDeviceFuncs->pfnCreateLight = vboxWddmDDevCreateLight;
3153 pCreateData->pDeviceFuncs->pfnDestroyLight = vboxWddmDDevDestroyLight;
3154 pCreateData->pDeviceFuncs->pfnSetClipPlane = vboxWddmDDevSetClipPlane;
3155 pCreateData->pDeviceFuncs->pfnGetInfo = vboxWddmDDevGetInfo;
3156 pCreateData->pDeviceFuncs->pfnLock = vboxWddmDDevLock;
3157 pCreateData->pDeviceFuncs->pfnUnlock = vboxWddmDDevUnlock;
3158 pCreateData->pDeviceFuncs->pfnCreateResource = vboxWddmDDevCreateResource;
3159 pCreateData->pDeviceFuncs->pfnDestroyResource = vboxWddmDDevDestroyResource;
3160 pCreateData->pDeviceFuncs->pfnSetDisplayMode = vboxWddmDDevSetDisplayMode;
3161 pCreateData->pDeviceFuncs->pfnPresent = vboxWddmDDevPresent;
3162 pCreateData->pDeviceFuncs->pfnFlush = vboxWddmDDevFlush;
3163 pCreateData->pDeviceFuncs->pfnCreateVertexShaderFunc = vboxWddmDDevCreateVertexShaderFunc;
3164 pCreateData->pDeviceFuncs->pfnDeleteVertexShaderFunc = vboxWddmDDevDeleteVertexShaderFunc;
3165 pCreateData->pDeviceFuncs->pfnSetVertexShaderFunc = vboxWddmDDevSetVertexShaderFunc;
3166 pCreateData->pDeviceFuncs->pfnCreateVertexShaderDecl = vboxWddmDDevCreateVertexShaderDecl;
3167 pCreateData->pDeviceFuncs->pfnDeleteVertexShaderDecl = vboxWddmDDevDeleteVertexShaderDecl;
3168 pCreateData->pDeviceFuncs->pfnSetVertexShaderDecl = vboxWddmDDevSetVertexShaderDecl;
3169 pCreateData->pDeviceFuncs->pfnSetVertexShaderConstI = vboxWddmDDevSetVertexShaderConstI;
3170 pCreateData->pDeviceFuncs->pfnSetVertexShaderConstB = vboxWddmDDevSetVertexShaderConstB;
3171 pCreateData->pDeviceFuncs->pfnSetScissorRect = vboxWddmDDevSetScissorRect;
3172 pCreateData->pDeviceFuncs->pfnSetStreamSource = vboxWddmDDevSetStreamSource;
3173 pCreateData->pDeviceFuncs->pfnSetStreamSourceFreq = vboxWddmDDevSetStreamSourceFreq;
3174 pCreateData->pDeviceFuncs->pfnSetConvolutionKernelMono = vboxWddmDDevSetConvolutionKernelMono;
3175 pCreateData->pDeviceFuncs->pfnComposeRects = vboxWddmDDevComposeRects;
3176 pCreateData->pDeviceFuncs->pfnBlt = vboxWddmDDevBlt;
3177 pCreateData->pDeviceFuncs->pfnColorFill = vboxWddmDDevColorFill;
3178 pCreateData->pDeviceFuncs->pfnDepthFill = vboxWddmDDevDepthFill;
3179 pCreateData->pDeviceFuncs->pfnCreateQuery = vboxWddmDDevCreateQuery;
3180 pCreateData->pDeviceFuncs->pfnDestroyQuery = vboxWddmDDevDestroyQuery;
3181 pCreateData->pDeviceFuncs->pfnIssueQuery = vboxWddmDDevIssueQuery;
3182 pCreateData->pDeviceFuncs->pfnGetQueryData = vboxWddmDDevGetQueryData;
3183 pCreateData->pDeviceFuncs->pfnSetRenderTarget = vboxWddmDDevSetRenderTarget;
3184 pCreateData->pDeviceFuncs->pfnSetDepthStencil = vboxWddmDDevSetDepthStencil;
3185 pCreateData->pDeviceFuncs->pfnGenerateMipSubLevels = vboxWddmDDevGenerateMipSubLevels;
3186 pCreateData->pDeviceFuncs->pfnSetPixelShaderConstI = vboxWddmDDevSetPixelShaderConstI;
3187 pCreateData->pDeviceFuncs->pfnSetPixelShaderConstB = vboxWddmDDevSetPixelShaderConstB;
3188 pCreateData->pDeviceFuncs->pfnCreatePixelShader = vboxWddmDDevCreatePixelShader;
3189 pCreateData->pDeviceFuncs->pfnDeletePixelShader = vboxWddmDDevDeletePixelShader;
3190 pCreateData->pDeviceFuncs->pfnCreateDecodeDevice = vboxWddmDDevCreateDecodeDevice;
3191 pCreateData->pDeviceFuncs->pfnDestroyDecodeDevice = vboxWddmDDevDestroyDecodeDevice;
3192 pCreateData->pDeviceFuncs->pfnSetDecodeRenderTarget = vboxWddmDDevSetDecodeRenderTarget;
3193 pCreateData->pDeviceFuncs->pfnDecodeBeginFrame = vboxWddmDDevDecodeBeginFrame;
3194 pCreateData->pDeviceFuncs->pfnDecodeEndFrame = vboxWddmDDevDecodeEndFrame;
3195 pCreateData->pDeviceFuncs->pfnDecodeExecute = vboxWddmDDevDecodeExecute;
3196 pCreateData->pDeviceFuncs->pfnDecodeExtensionExecute = vboxWddmDDevDecodeExtensionExecute;
3197 pCreateData->pDeviceFuncs->pfnCreateVideoProcessDevice = vboxWddmDDevCreateVideoProcessDevice;
3198 pCreateData->pDeviceFuncs->pfnDestroyVideoProcessDevice = vboxWddmDDevDestroyVideoProcessDevice;
3199 pCreateData->pDeviceFuncs->pfnVideoProcessBeginFrame = vboxWddmDDevVideoProcessBeginFrame;
3200 pCreateData->pDeviceFuncs->pfnVideoProcessEndFrame = vboxWddmDDevVideoProcessEndFrame;
3201 pCreateData->pDeviceFuncs->pfnSetVideoProcessRenderTarget = vboxWddmDDevSetVideoProcessRenderTarget;
3202 pCreateData->pDeviceFuncs->pfnVideoProcessBlt = vboxWddmDDevVideoProcessBlt;
3203 pCreateData->pDeviceFuncs->pfnCreateExtensionDevice = vboxWddmDDevCreateExtensionDevice;
3204 pCreateData->pDeviceFuncs->pfnDestroyExtensionDevice = vboxWddmDDevDestroyExtensionDevice;
3205 pCreateData->pDeviceFuncs->pfnExtensionExecute = vboxWddmDDevExtensionExecute;
3206 pCreateData->pDeviceFuncs->pfnCreateOverlay = vboxWddmDDevCreateOverlay;
3207 pCreateData->pDeviceFuncs->pfnUpdateOverlay = vboxWddmDDevUpdateOverlay;
3208 pCreateData->pDeviceFuncs->pfnFlipOverlay = vboxWddmDDevFlipOverlay;
3209 pCreateData->pDeviceFuncs->pfnGetOverlayColorControls = vboxWddmDDevGetOverlayColorControls;
3210 pCreateData->pDeviceFuncs->pfnSetOverlayColorControls = vboxWddmDDevSetOverlayColorControls;
3211 pCreateData->pDeviceFuncs->pfnDestroyOverlay = vboxWddmDDevDestroyOverlay;
3212 pCreateData->pDeviceFuncs->pfnDestroyDevice = vboxWddmDDevDestroyDevice;
3213 pCreateData->pDeviceFuncs->pfnQueryResourceResidency = vboxWddmDDevQueryResourceResidency;
3214 pCreateData->pDeviceFuncs->pfnOpenResource = vboxWddmDDevOpenResource;
3215 pCreateData->pDeviceFuncs->pfnGetCaptureAllocationHandle = vboxWddmDDevGetCaptureAllocationHandle;
3216 pCreateData->pDeviceFuncs->pfnCaptureToSysMem = vboxWddmDDevCaptureToSysMem;
3217 pCreateData->pDeviceFuncs->pfnLockAsync = NULL; //vboxWddmDDevLockAsync;
3218 pCreateData->pDeviceFuncs->pfnUnlockAsync = NULL; //vboxWddmDDevUnlockAsync;
3219 pCreateData->pDeviceFuncs->pfnRename = NULL; //vboxWddmDDevRename;
3220
3221
3222 do
3223 {
3224 Assert(!pCreateData->AllocationListSize
3225 && !pCreateData->PatchLocationListSize);
3226 if (!pCreateData->AllocationListSize
3227 && !pCreateData->PatchLocationListSize)
3228 {
3229 pDevice->DefaultContext.ContextInfo.NodeOrdinal = 0;
3230 pDevice->DefaultContext.ContextInfo.EngineAffinity = 0;
3231 pDevice->DefaultContext.ContextInfo.Flags.Value = 0;
3232 pDevice->DefaultContext.ContextInfo.pPrivateDriverData = NULL;
3233 pDevice->DefaultContext.ContextInfo.PrivateDriverDataSize = 0;
3234 pDevice->DefaultContext.ContextInfo.hContext = 0;
3235 pDevice->DefaultContext.ContextInfo.pCommandBuffer = NULL;
3236 pDevice->DefaultContext.ContextInfo.CommandBufferSize = 0;
3237 pDevice->DefaultContext.ContextInfo.pAllocationList = NULL;
3238 pDevice->DefaultContext.ContextInfo.AllocationListSize = 0;
3239 pDevice->DefaultContext.ContextInfo.pPatchLocationList = NULL;
3240 pDevice->DefaultContext.ContextInfo.PatchLocationListSize = 0;
3241
3242 hr = pDevice->RtCallbacks.pfnCreateContextCb(pDevice->hDevice, &pDevice->DefaultContext.ContextInfo);
3243 Assert(hr == S_OK);
3244 if (hr == S_OK)
3245 {
3246 if (VBOXDISPMODE_IS_3D(pAdapter))
3247 {
3248 /* we postpone IDirect3DDevice device creation to CreateResource,
3249 * where resource render target gets created,
3250 * which is actually done as part of d3dx.dll Direct3DDevice creation */
3251 vboxVDbgPrint((__FUNCTION__": D3D Device Created\n"));
3252 break;
3253 }
3254 else
3255 {
3256 /* DDraw */
3257 vboxVDbgPrint((__FUNCTION__": DirectDraw Device Created\n"));
3258 break;
3259 }
3260
3261 D3DDDICB_DESTROYCONTEXT DestroyContext;
3262 DestroyContext.hContext = pDevice->DefaultContext.ContextInfo.hContext;
3263
3264 HRESULT tmpHr = pDevice->RtCallbacks.pfnDestroyContextCb(pDevice->hDevice, &DestroyContext);
3265 Assert(tmpHr == S_OK);
3266 }
3267 else
3268 vboxVDbgPrintR((__FUNCTION__": pfnCreateContextCb failed, hr(%d)\n", hr));
3269 }
3270 else
3271 {
3272 vboxVDbgPrintR((__FUNCTION__": Not implemented: PatchLocationListSize(%d), AllocationListSize(%d)\n",
3273 pCreateData->PatchLocationListSize, pCreateData->AllocationListSize));
3274 //pCreateData->pAllocationList = ??
3275 hr = E_FAIL;
3276 }
3277
3278 RTMemFree(pDevice);
3279 } while (0);
3280 }
3281 else
3282 {
3283 vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
3284 hr = E_OUTOFMEMORY;
3285 }
3286
3287 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
3288
3289 return hr;
3290}
3291
3292static HRESULT APIENTRY vboxWddmDispCloseAdapter (IN HANDLE hAdapter)
3293{
3294 vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
3295
3296// AssertBreakpoint();
3297
3298 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
3299 if (VBOXDISPMODE_IS_3D(pAdapter))
3300 {
3301 HRESULT hr = VBoxDispWorkerDestroy(&pAdapter->WndWorker);
3302 Assert(hr == S_OK);
3303 hr = pAdapter->pD3D9If->Release();
3304 Assert(hr == S_OK);
3305 VBoxDispD3DClose(&pAdapter->D3D);
3306 }
3307
3308 vboxCapsFree(pAdapter);
3309
3310 RTMemFree(pAdapter);
3311
3312 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
3313
3314 return S_OK;
3315}
3316
3317HRESULT APIENTRY OpenAdapter (__inout D3DDDIARG_OPENADAPTER* pOpenData)
3318{
3319 vboxVDbgPrint(("==> "__FUNCTION__"\n"));
3320
3321 VBOXWDDM_QI Query;
3322 D3DDDICB_QUERYADAPTERINFO DdiQuery;
3323 DdiQuery.PrivateDriverDataSize = sizeof(Query);
3324 DdiQuery.pPrivateDriverData = &Query;
3325 HRESULT hr = pOpenData->pAdapterCallbacks->pfnQueryAdapterInfoCb(pOpenData->hAdapter, &DdiQuery);
3326 Assert(hr == S_OK);
3327 if (hr != S_OK)
3328 {
3329 vboxVDbgPrintR((__FUNCTION__": pfnQueryAdapterInfoCb failed, hr (%d)\n", hr));
3330 return E_FAIL;
3331 }
3332
3333 /* check the miniport version match display version */
3334 if (Query.u32Version != VBOXVIDEOIF_VERSION)
3335 {
3336 vboxVDbgPrintR((__FUNCTION__": miniport version mismatch, expected (%d), but was (%d)\n",
3337 VBOXVIDEOIF_VERSION,
3338 Query.u32Version));
3339 return E_FAIL;
3340 }
3341
3342#ifdef VBOX_WITH_VIDEOHWACCEL
3343 Assert(Query.cInfos >= 1);
3344 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(RT_OFFSETOF(VBOXWDDMDISP_ADAPTER, aHeads[Query.cInfos]));
3345#else
3346 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(sizeof (VBOXWDDMDISP_ADAPTER));
3347#endif
3348 Assert(pAdapter);
3349 if (pAdapter)
3350 {
3351 pAdapter->hAdapter = pOpenData->hAdapter;
3352 pAdapter->uIfVersion = pOpenData->Interface;
3353 pAdapter->uRtVersion= pOpenData->Version;
3354 pAdapter->RtCallbacks = *pOpenData->pAdapterCallbacks;
3355
3356 pAdapter->cHeads = Query.cInfos;
3357
3358
3359 pOpenData->hAdapter = pAdapter;
3360 pOpenData->pAdapterFuncs->pfnGetCaps = vboxWddmDispGetCaps;
3361 pOpenData->pAdapterFuncs->pfnCreateDevice = vboxWddmDispCreateDevice;
3362 pOpenData->pAdapterFuncs->pfnCloseAdapter = vboxWddmDispCloseAdapter;
3363 pOpenData->DriverVersion = D3D_UMD_INTERFACE_VERSION;
3364 /*
3365 * here we detect whether we are called by the d3d or ddraw.
3366 * in the d3d case we init our d3d environment
3367 * in the ddraw case we init 2D acceleration
3368 * if interface version is > 7, this is D3D, treat it as so
3369 * otherwise treat it as ddraw
3370 * @todo: need a more clean way of doing this */
3371
3372 if (pAdapter->uIfVersion > 7)
3373 {
3374 do
3375 {
3376 /* try enable the 3D */
3377 hr = VBoxDispD3DOpen(&pAdapter->D3D);
3378 Assert(hr == S_OK);
3379 if (hr == S_OK)
3380 {
3381 hr = pAdapter->D3D.pfnDirect3DCreate9Ex(D3D_SDK_VERSION, &pAdapter->pD3D9If);
3382 Assert(hr == S_OK);
3383 if (hr == S_OK)
3384 {
3385 hr = VBoxDispWorkerCreate(&pAdapter->WndWorker);
3386 Assert(hr == S_OK);
3387 if (hr == S_OK)
3388 {
3389 vboxVDbgPrint((__FUNCTION__": SUCCESS 3D Enabled, pAdapter (0x%p)\n", pAdapter));
3390 break;
3391 }
3392 pAdapter->pD3D9If->Release();
3393 }
3394 else
3395 vboxVDbgPrintR((__FUNCTION__": pfnDirect3DCreate9Ex failed, hr (%d)\n", hr));
3396 VBoxDispD3DClose(&pAdapter->D3D);
3397 }
3398 else
3399 vboxVDbgPrintR((__FUNCTION__": VBoxDispD3DOpen failed, hr (%d)\n", hr));
3400 } while (0);
3401 }
3402#ifdef VBOX_WITH_VIDEOHWACCEL
3403 else
3404 {
3405 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
3406 {
3407 pAdapter->aHeads[i].Vhwa.Settings = Query.aInfos[i];
3408 }
3409 }
3410#endif
3411
3412 vboxCapsInit(pAdapter);
3413 hr = S_OK;
3414// RTMemFree(pAdapter);
3415 }
3416 else
3417 {
3418 vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
3419 hr = E_OUTOFMEMORY;
3420 }
3421
3422 vboxVDbgPrint(("<== "__FUNCTION__", hr (%d)\n", hr));
3423
3424 return hr;
3425}
3426
3427#ifdef VBOXWDDMDISP_DEBUG
3428VOID vboxVDbgDoPrint(LPCSTR szString, ...)
3429{
3430 char szBuffer[1024] = {0};
3431 va_list pArgList;
3432 va_start(pArgList, szString);
3433 _vsnprintf(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]), szString, pArgList);
3434 va_end(pArgList);
3435
3436 OutputDebugStringA(szBuffer);
3437}
3438#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