VirtualBox

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

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

wddm/2d: overlay create/update in UMD
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 174.5 KB
Line 
1/** @file
2 *
3 * VBoxVideo Display D3D User mode dll
4 *
5 * Copyright (C) 2010 Oracle Corporation
6 *
7 * This file is part of VirtualBox Open Source Edition (OSE), as
8 * available from http://www.virtualbox.org. This file is free software;
9 * you can redistribute it and/or modify it under the terms of the GNU
10 * General Public License (GPL) as published by the Free Software
11 * Foundation, in version 2 as it comes in the "COPYING" file of the
12 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
13 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
14 */
15#include <windows.h>
16#include <d3d9types.h>
17//#include <d3dtypes.h>
18#include <D3dumddi.h>
19#include <d3dhal.h>
20
21
22#include <iprt/initterm.h>
23#include <iprt/log.h>
24#include <iprt/mem.h>
25
26#include <VBox/Log.h>
27
28#include <VBox/VBoxGuestLib.h>
29
30#include "VBoxDispD3D.h"
31#include "VBoxDispD3DCmn.h"
32
33#ifdef VBOXWDDMDISP_DEBUG
34# include <stdio.h>
35#endif
36
37#define VBOXWDDMDISP_WITH_TMPWORKAROUND 1
38
39static FORMATOP gVBoxFormatOps3D[] = {
40 {D3DDDIFMT_A8R8G8B8,
41 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
42 FORMATOP_SAME_FORMAT_RENDERTARGET|
43 FORMATOP_SAME_FORMAT_UP_TO_ALPHA_RENDERTARGET|
44 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
45 FORMATOP_MEMBEROFGROUP_ARGB|
46 FORMATOP_SRGBWRITE|FORMATOP_VERTEXTEXTURE, 0, 0, 0},
47
48 {D3DDDIFMT_X8R8G8B8,
49 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
50 FORMATOP_SAME_FORMAT_RENDERTARGET|
51 FORMATOP_DISPLAYMODE|FORMATOP_3DACCELERATION|
52 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
53 FORMATOP_MEMBEROFGROUP_ARGB|
54 FORMATOP_SRGBWRITE|FORMATOP_VERTEXTEXTURE, 0, 0, 0},
55
56 {D3DDDIFMT_A2R10G10B10,
57 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
58 FORMATOP_SAME_FORMAT_RENDERTARGET|
59 0|
60 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|
61 FORMATOP_MEMBEROFGROUP_ARGB|
62 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
63
64 {D3DDDIFMT_X1R5G5B5,
65 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
66 FORMATOP_SAME_FORMAT_RENDERTARGET|
67 0|
68 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|
69 FORMATOP_MEMBEROFGROUP_ARGB|
70 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
71
72 {D3DDDIFMT_A1R5G5B5,
73 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
74 FORMATOP_SAME_FORMAT_RENDERTARGET|
75 FORMATOP_SAME_FORMAT_UP_TO_ALPHA_RENDERTARGET|
76 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|
77 FORMATOP_MEMBEROFGROUP_ARGB|
78 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
79
80 {D3DDDIFMT_A4R4G4B4,
81 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
82 FORMATOP_SAME_FORMAT_RENDERTARGET|
83 FORMATOP_SAME_FORMAT_UP_TO_ALPHA_RENDERTARGET|
84 FORMATOP_OFFSCREENPLAIN|
85 0|
86 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
87
88 {D3DDDIFMT_R5G6B5,
89 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
90 FORMATOP_SAME_FORMAT_RENDERTARGET|
91 FORMATOP_DISPLAYMODE|FORMATOP_3DACCELERATION|
92 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|
93 FORMATOP_MEMBEROFGROUP_ARGB|
94 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
95
96 {D3DDDIFMT_L16,
97 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
98 0|
99 0|
100 FORMATOP_OFFSCREENPLAIN|
101 0|
102 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
103
104 {D3DDDIFMT_A8L8,
105 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
106 0|
107 0|
108 FORMATOP_OFFSCREENPLAIN|
109 0|
110 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
111
112 {D3DDDIFMT_A8,
113 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
114 0|
115 0|
116 FORMATOP_OFFSCREENPLAIN|
117 0|
118 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
119
120 {D3DDDIFMT_L8,
121 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
122 0|
123 0|
124 FORMATOP_OFFSCREENPLAIN|
125 0|
126 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
127
128 {D3DDDIFMT_D16, FORMATOP_TEXTURE|FORMATOP_ZSTENCIL|FORMATOP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH, 0, 0, 0},
129 {D3DDDIFMT_D24S8, FORMATOP_TEXTURE|FORMATOP_ZSTENCIL|FORMATOP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH, 0, 0, 0},
130 {D3DDDIFMT_D24X8, FORMATOP_TEXTURE|FORMATOP_ZSTENCIL|FORMATOP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH, 0, 0, 0},
131 {D3DDDIFMT_D16_LOCKABLE, FORMATOP_ZSTENCIL|FORMATOP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH, 0, 0, 0},
132 {D3DDDIFMT_X8D24, FORMATOP_TEXTURE|FORMATOP_ZSTENCIL|FORMATOP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH, 0, 0, 0},
133 {D3DDDIFMT_D32F_LOCKABLE, FORMATOP_TEXTURE|FORMATOP_ZSTENCIL|FORMATOP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH, 0, 0, 0},
134 {D3DDDIFMT_S8D24, FORMATOP_TEXTURE|FORMATOP_ZSTENCIL|FORMATOP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH, 0, 0, 0},
135
136 {D3DDDIFMT_DXT1,
137 FORMATOP_TEXTURE|FORMATOP_CUBETEXTURE|
138 0|
139 0|
140 FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
141 0|
142 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
143
144 {D3DDDIFMT_DXT2,
145 FORMATOP_TEXTURE|FORMATOP_CUBETEXTURE|
146 0|
147 0|
148 FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
149 0|
150 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
151
152 {D3DDDIFMT_DXT3,
153 FORMATOP_TEXTURE|FORMATOP_CUBETEXTURE|
154 0|
155 0|
156 FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
157 0|
158 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
159
160 {D3DDDIFMT_DXT4,
161 FORMATOP_TEXTURE|FORMATOP_CUBETEXTURE|
162 0|
163 0|
164 FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
165 0|
166 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
167
168 {D3DDDIFMT_DXT5,
169 FORMATOP_TEXTURE|FORMATOP_CUBETEXTURE|
170 0|
171 0|
172 FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
173 0|
174 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
175
176 {D3DDDIFMT_X8L8V8U8,
177 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
178 0|
179 0|
180 0|
181 FORMATOP_BUMPMAP|
182 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
183
184 {D3DDDIFMT_A2W10V10U10,
185 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
186 0|
187 0|
188 0|
189 FORMATOP_BUMPMAP|
190 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
191
192 {D3DDDIFMT_V8U8,
193 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
194 0|
195 0|
196 0|
197 FORMATOP_BUMPMAP|
198 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
199
200 {D3DDDIFMT_Q8W8V8U8,
201 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
202 0|
203 0|
204 FORMATOP_OFFSCREENPLAIN|
205 FORMATOP_BUMPMAP|
206 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
207
208 {D3DDDIFMT_CxV8U8, FORMATOP_NOFILTER|FORMATOP_NOALPHABLEND|FORMATOP_NOTEXCOORDWRAPNORMIP, 0, 0, 0},
209
210 {D3DDDIFMT_R16F,
211 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
212 FORMATOP_SAME_FORMAT_RENDERTARGET|
213 0|
214 FORMATOP_OFFSCREENPLAIN|
215 0|
216 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
217
218 {D3DDDIFMT_R32F,
219 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
220 FORMATOP_SAME_FORMAT_RENDERTARGET|
221 0|
222 FORMATOP_OFFSCREENPLAIN|
223 0|
224 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
225
226 {D3DDDIFMT_G16R16F,
227 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
228 FORMATOP_SAME_FORMAT_RENDERTARGET|
229 0|
230 FORMATOP_OFFSCREENPLAIN|
231 0|
232 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
233
234 {D3DDDIFMT_G32R32F,
235 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
236 FORMATOP_SAME_FORMAT_RENDERTARGET|
237 0|
238 FORMATOP_OFFSCREENPLAIN|
239 0|
240 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
241
242 {D3DDDIFMT_A16B16G16R16F,
243 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
244 FORMATOP_SAME_FORMAT_RENDERTARGET|
245 0|
246 FORMATOP_OFFSCREENPLAIN|
247 0|
248 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
249
250 {D3DDDIFMT_A32B32G32R32F,
251 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
252 FORMATOP_SAME_FORMAT_RENDERTARGET|
253 0|
254 FORMATOP_OFFSCREENPLAIN|
255 0|
256 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
257
258 {D3DDDIFMT_G16R16,
259 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
260 FORMATOP_SAME_FORMAT_RENDERTARGET|
261 0|
262 FORMATOP_OFFSCREENPLAIN|
263 0|
264 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
265
266 {D3DDDIFMT_A16B16G16R16,
267 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
268 FORMATOP_SAME_FORMAT_RENDERTARGET|
269 0|
270 FORMATOP_OFFSCREENPLAIN|
271 0|
272 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
273
274 {D3DDDIFMT_V16U16,
275 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
276 0|
277 0|
278 0|
279 FORMATOP_BUMPMAP|
280 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
281
282 {D3DDDIFMT_P8, FORMATOP_DISPLAYMODE|FORMATOP_3DACCELERATION|FORMATOP_OFFSCREENPLAIN, 0, 0, 0},
283
284 {D3DDDIFMT_UYVY,
285 0|
286 0|
287 0|
288 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|
289 FORMATOP_NOFILTER|
290 FORMATOP_NOALPHABLEND|
291 FORMATOP_NOTEXCOORDWRAPNORMIP, 0, 0, 0},
292
293 {D3DDDIFMT_YUY2,
294 0|
295 0|
296 0|
297 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|
298 FORMATOP_NOFILTER|
299 FORMATOP_NOALPHABLEND|
300 FORMATOP_NOTEXCOORDWRAPNORMIP, 0, 0, 0},
301
302 {D3DDDIFMT_Q16W16V16U16,
303 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
304 FORMATOP_SAME_FORMAT_RENDERTARGET|
305 0|
306 FORMATOP_OFFSCREENPLAIN|
307 FORMATOP_BUMPMAP|FORMATOP_DMAP|
308 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
309
310 {D3DDDIFMT_X8B8G8R8,
311 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
312 FORMATOP_SAME_FORMAT_RENDERTARGET|
313 FORMATOP_SAME_FORMAT_UP_TO_ALPHA_RENDERTARGET|
314 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|FORMATOP_SRGBREAD|
315 FORMATOP_DMAP|FORMATOP_MEMBEROFGROUP_ARGB|
316 FORMATOP_SRGBWRITE|FORMATOP_AUTOGENMIPMAP|FORMATOP_VERTEXTEXTURE|
317 FORMATOP_OVERLAY, 0, 0, 0},
318
319 {D3DDDIFMT_BINARYBUFFER, FORMATOP_OFFSCREENPLAIN, 0, 0, 0},
320
321 {D3DDDIFMT_A4L4,
322 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|
323 0|
324 0|
325 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|
326 FORMATOP_DMAP|
327 FORMATOP_VERTEXTEXTURE, 0, 0, 0},
328
329 {D3DDDIFMT_A2B10G10R10,
330 FORMATOP_TEXTURE|FORMATOP_VOLUMETEXTURE|FORMATOP_CUBETEXTURE|FORMATOP_OFFSCREEN_RENDERTARGET|
331 FORMATOP_SAME_FORMAT_RENDERTARGET|
332 0|
333 FORMATOP_CONVERT_TO_ARGB|FORMATOP_OFFSCREENPLAIN|
334 FORMATOP_DMAP|FORMATOP_MEMBEROFGROUP_ARGB|
335 FORMATOP_AUTOGENMIPMAP|FORMATOP_VERTEXTEXTURE, 0, 0, 0},
336};
337
338static FORMATOP gVBoxFormatOpsBase[] = {
339 {D3DDDIFMT_X8R8G8B8, FORMATOP_DISPLAYMODE, 0, 0, 0},
340
341 {D3DDDIFMT_R8G8B8, FORMATOP_DISPLAYMODE, 0, 0, 0},
342
343 {D3DDDIFMT_R5G6B5, FORMATOP_DISPLAYMODE, 0, 0, 0},
344
345 {D3DDDIFMT_P8, FORMATOP_DISPLAYMODE, 0, 0, 0},
346};
347
348static DDSURFACEDESC gVBoxSurfDescsBase[] = {
349 {
350 sizeof (DDSURFACEDESC), /* DWORD dwSize; */
351 DDSD_CAPS | DDSD_PIXELFORMAT, /* DWORD dwFlags; */
352 0, /* DWORD dwHeight; */
353 0, /* DWORD dwWidth; */
354 {
355 0, /* Union */
356 /* LONG lPitch; */
357 /* DWORD dwLinearSize; */
358 },
359 0, /* DWORD dwBackBufferCount; */
360 {
361 0, /* Union */
362 /* DWORD dwMipMapCount; */
363 /* DWORD dwZBufferBitDepth; */
364 /* DWORD dwRefreshRate; */
365 },
366 0, /* DWORD dwAlphaBitDepth; */
367 0, /* DWORD dwReserved; */
368 NULL, /* LPVOID lpSurface; */
369 {
370 0, /* DWORD dwColorSpaceLowValue; */
371 0, /* DWORD dwColorSpaceHighValue; */
372 }, /* DDCOLORKEY ddckCKDestOverlay; */
373 {
374 0, /* DWORD dwColorSpaceLowValue; */
375 0, /* DWORD dwColorSpaceHighValue; */
376 }, /* DDCOLORKEY ddckCKDestBlt; */
377 {
378 0, /* DWORD dwColorSpaceLowValue; */
379 0, /* DWORD dwColorSpaceHighValue; */
380 }, /* DDCOLORKEY ddckCKSrcOverlay; */
381 {
382 0, /* DWORD dwColorSpaceLowValue; */
383 0, /* DWORD dwColorSpaceHighValue; */
384 }, /* DDCOLORKEY ddckCKSrcBlt; */
385 {
386 sizeof (DDPIXELFORMAT), /* DWORD dwSize; */
387 DDPF_RGB, /* DWORD dwFlags; */
388 0, /* DWORD dwFourCC; */
389 {
390 32, /* union */
391 /* DWORD dwRGBBitCount; */
392 /* DWORD dwYUVBitCount; */
393 /* DWORD dwZBufferBitDepth; */
394 /* DWORD dwAlphaBitDepth; */
395 /* DWORD dwLuminanceBitCount; */
396 /* DWORD dwBumpBitCount; */
397 },
398 {
399 0xff0000, /* union */
400 /* DWORD dwRBitMask; */
401 /* DWORD dwYBitMask; */
402 /* DWORD dwStencilBitDepth; */
403 /* DWORD dwLuminanceBitMask; */
404 /* DWORD dwBumpDuBitMask; */
405 },
406 {
407 0xff00,
408 /* DWORD dwGBitMask; */
409 /* DWORD dwUBitMask; */
410 /* DWORD dwZBitMask; */
411 /* DWORD dwBumpDvBitMask; */
412 },
413 {
414 0xff,
415 /* DWORD dwBBitMask; */
416 /* DWORD dwVBitMask; */
417 /* DWORD dwStencilBitMask; */
418 /* DWORD dwBumpLuminanceBitMask; */
419 },
420 {
421 0,
422 /* DWORD dwRGBAlphaBitMask; */
423 /* DWORD dwYUVAlphaBitMask; */
424 /* DWORD dwLuminanceAlphaBitMask; */
425 /* DWORD dwRGBZBitMask; */
426 /* DWORD dwYUVZBitMask; */
427 },
428 }, /* DDPIXELFORMAT ddpfPixelFormat; */
429 {
430 DDSCAPS_BACKBUFFER
431 | DDSCAPS_COMPLEX
432 | DDSCAPS_FLIP
433 | DDSCAPS_FRONTBUFFER
434 | DDSCAPS_LOCALVIDMEM
435 | DDSCAPS_PRIMARYSURFACE
436 | DDSCAPS_VIDEOMEMORY
437 | DDSCAPS_VISIBLE /* DWORD dwCaps; */
438 } /* DDSCAPS ddsCaps; */
439 },
440 {
441 sizeof (DDSURFACEDESC), /* DWORD dwSize; */
442 DDSD_CAPS | DDSD_PIXELFORMAT, /* DWORD dwFlags; */
443 0, /* DWORD dwHeight; */
444 0, /* DWORD dwWidth; */
445 {
446 0, /* Union */
447 /* LONG lPitch; */
448 /* DWORD dwLinearSize; */
449 },
450 0, /* DWORD dwBackBufferCount; */
451 {
452 0, /* Union */
453 /* DWORD dwMipMapCount; */
454 /* DWORD dwZBufferBitDepth; */
455 /* DWORD dwRefreshRate; */
456 },
457 0, /* DWORD dwAlphaBitDepth; */
458 0, /* DWORD dwReserved; */
459 NULL, /* LPVOID lpSurface; */
460 {
461 0, /* DWORD dwColorSpaceLowValue; */
462 0, /* DWORD dwColorSpaceHighValue; */
463 }, /* DDCOLORKEY ddckCKDestOverlay; */
464 {
465 0, /* DWORD dwColorSpaceLowValue; */
466 0, /* DWORD dwColorSpaceHighValue; */
467 }, /* DDCOLORKEY ddckCKDestBlt; */
468 {
469 0, /* DWORD dwColorSpaceLowValue; */
470 0, /* DWORD dwColorSpaceHighValue; */
471 }, /* DDCOLORKEY ddckCKSrcOverlay; */
472 {
473 0, /* DWORD dwColorSpaceLowValue; */
474 0, /* DWORD dwColorSpaceHighValue; */
475 }, /* DDCOLORKEY ddckCKSrcBlt; */
476 {
477 sizeof (DDPIXELFORMAT), /* DWORD dwSize; */
478 DDPF_RGB, /* DWORD dwFlags; */
479 0, /* DWORD dwFourCC; */
480 {
481 24, /* union */
482 /* DWORD dwRGBBitCount; */
483 /* DWORD dwYUVBitCount; */
484 /* DWORD dwZBufferBitDepth; */
485 /* DWORD dwAlphaBitDepth; */
486 /* DWORD dwLuminanceBitCount; */
487 /* DWORD dwBumpBitCount; */
488 },
489 {
490 0xff0000, /* union */
491 /* DWORD dwRBitMask; */
492 /* DWORD dwYBitMask; */
493 /* DWORD dwStencilBitDepth; */
494 /* DWORD dwLuminanceBitMask; */
495 /* DWORD dwBumpDuBitMask; */
496 },
497 {
498 0xff00,
499 /* DWORD dwGBitMask; */
500 /* DWORD dwUBitMask; */
501 /* DWORD dwZBitMask; */
502 /* DWORD dwBumpDvBitMask; */
503 },
504 {
505 0xff,
506 /* DWORD dwBBitMask; */
507 /* DWORD dwVBitMask; */
508 /* DWORD dwStencilBitMask; */
509 /* DWORD dwBumpLuminanceBitMask; */
510 },
511 {
512 0,
513 /* DWORD dwRGBAlphaBitMask; */
514 /* DWORD dwYUVAlphaBitMask; */
515 /* DWORD dwLuminanceAlphaBitMask; */
516 /* DWORD dwRGBZBitMask; */
517 /* DWORD dwYUVZBitMask; */
518 },
519 }, /* DDPIXELFORMAT ddpfPixelFormat; */
520 {
521 DDSCAPS_BACKBUFFER
522 | DDSCAPS_COMPLEX
523 | DDSCAPS_FLIP
524 | DDSCAPS_FRONTBUFFER
525 | DDSCAPS_LOCALVIDMEM
526 | DDSCAPS_PRIMARYSURFACE
527 | DDSCAPS_VIDEOMEMORY
528 | DDSCAPS_VISIBLE /* DWORD dwCaps; */
529 } /* DDSCAPS ddsCaps; */
530 },
531 {
532 sizeof (DDSURFACEDESC), /* DWORD dwSize; */
533 DDSD_CAPS | DDSD_PIXELFORMAT, /* DWORD dwFlags; */
534 0, /* DWORD dwHeight; */
535 0, /* DWORD dwWidth; */
536 {
537 0, /* Union */
538 /* LONG lPitch; */
539 /* DWORD dwLinearSize; */
540 },
541 0, /* DWORD dwBackBufferCount; */
542 {
543 0, /* Union */
544 /* DWORD dwMipMapCount; */
545 /* DWORD dwZBufferBitDepth; */
546 /* DWORD dwRefreshRate; */
547 },
548 0, /* DWORD dwAlphaBitDepth; */
549 0, /* DWORD dwReserved; */
550 NULL, /* LPVOID lpSurface; */
551 {
552 0, /* DWORD dwColorSpaceLowValue; */
553 0, /* DWORD dwColorSpaceHighValue; */
554 }, /* DDCOLORKEY ddckCKDestOverlay; */
555 {
556 0, /* DWORD dwColorSpaceLowValue; */
557 0, /* DWORD dwColorSpaceHighValue; */
558 }, /* DDCOLORKEY ddckCKDestBlt; */
559 {
560 0, /* DWORD dwColorSpaceLowValue; */
561 0, /* DWORD dwColorSpaceHighValue; */
562 }, /* DDCOLORKEY ddckCKSrcOverlay; */
563 {
564 0, /* DWORD dwColorSpaceLowValue; */
565 0, /* DWORD dwColorSpaceHighValue; */
566 }, /* DDCOLORKEY ddckCKSrcBlt; */
567 {
568 sizeof (DDPIXELFORMAT), /* DWORD dwSize; */
569 DDPF_RGB, /* DWORD dwFlags; */
570 0, /* DWORD dwFourCC; */
571 {
572 16, /* union */
573 /* DWORD dwRGBBitCount; */
574 /* DWORD dwYUVBitCount; */
575 /* DWORD dwZBufferBitDepth; */
576 /* DWORD dwAlphaBitDepth; */
577 /* DWORD dwLuminanceBitCount; */
578 /* DWORD dwBumpBitCount; */
579 },
580 {
581 0xf800, /* union */
582 /* DWORD dwRBitMask; */
583 /* DWORD dwYBitMask; */
584 /* DWORD dwStencilBitDepth; */
585 /* DWORD dwLuminanceBitMask; */
586 /* DWORD dwBumpDuBitMask; */
587 },
588 {
589 0x7e0,
590 /* DWORD dwGBitMask; */
591 /* DWORD dwUBitMask; */
592 /* DWORD dwZBitMask; */
593 /* DWORD dwBumpDvBitMask; */
594 },
595 {
596 0x1f,
597 /* DWORD dwBBitMask; */
598 /* DWORD dwVBitMask; */
599 /* DWORD dwStencilBitMask; */
600 /* DWORD dwBumpLuminanceBitMask; */
601 },
602 {
603 0,
604 /* DWORD dwRGBAlphaBitMask; */
605 /* DWORD dwYUVAlphaBitMask; */
606 /* DWORD dwLuminanceAlphaBitMask; */
607 /* DWORD dwRGBZBitMask; */
608 /* DWORD dwYUVZBitMask; */
609 },
610 }, /* DDPIXELFORMAT ddpfPixelFormat; */
611 {
612 DDSCAPS_BACKBUFFER
613 | DDSCAPS_COMPLEX
614 | DDSCAPS_FLIP
615 | DDSCAPS_FRONTBUFFER
616 | DDSCAPS_LOCALVIDMEM
617 | DDSCAPS_PRIMARYSURFACE
618 | DDSCAPS_VIDEOMEMORY
619 | DDSCAPS_VISIBLE /* DWORD dwCaps; */
620 } /* DDSCAPS ddsCaps; */
621 },
622};
623
624static D3DDDIQUERYTYPE gVBoxQueryTypes[] = {
625 D3DDDIQUERYTYPE_EVENT,
626 D3DDDIQUERYTYPE_OCCLUSION
627};
628
629#define VBOX_QUERYTYPE_COUNT() RT_ELEMENTS(gVBoxQueryTypes)
630
631#ifdef VBOX_WITH_VIDEOHWACCEL
632
633static bool vboxVhwaIsEnabled(PVBOXWDDMDISP_ADAPTER pAdapter)
634{
635 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
636 {
637 if (pAdapter->aHeads[i].Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED)
638 return true;
639 }
640 return false;
641}
642
643static bool vboxVhwaHasCKeying(PVBOXWDDMDISP_ADAPTER pAdapter)
644{
645 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
646 {
647 VBOXVHWA_INFO* pSettings = &pAdapter->aHeads[i].Vhwa.Settings;
648 if ((pSettings->fFlags & VBOXVHWA_F_ENABLED)
649 && ((pSettings->fFlags & VBOXVHWA_F_CKEY_DST)
650 || (pSettings->fFlags & VBOXVHWA_F_CKEY_SRC))
651 )
652 return true;
653 }
654 return false;
655}
656
657static void vboxVhwaPopulateOverlayFourccSurfDesc(DDSURFACEDESC *pDesc, uint32_t fourcc)
658{
659 memset(pDesc, 0, sizeof (DDSURFACEDESC));
660
661 pDesc->dwSize = sizeof (DDSURFACEDESC);
662 pDesc->dwFlags = DDSD_CAPS | DDSD_PIXELFORMAT;
663 pDesc->ddpfPixelFormat.dwSize = sizeof (DDPIXELFORMAT);
664 pDesc->ddpfPixelFormat.dwFlags = DDPF_FOURCC;
665 pDesc->ddpfPixelFormat.dwFourCC = fourcc;
666 pDesc->ddsCaps.dwCaps = DDSCAPS_BACKBUFFER
667 | DDSCAPS_COMPLEX
668 | DDSCAPS_FLIP
669 | DDSCAPS_FRONTBUFFER
670 | DDSCAPS_LOCALVIDMEM
671 | DDSCAPS_OVERLAY
672 | DDSCAPS_VIDEOMEMORY
673 | DDSCAPS_VISIBLE;
674}
675
676#endif
677
678static bool vboxPixFormatMatch(DDPIXELFORMAT *pFormat1, DDPIXELFORMAT *pFormat2)
679{
680 return !memcmp(pFormat1, pFormat2, sizeof (DDPIXELFORMAT));
681}
682
683int vboxSurfDescMerge(DDSURFACEDESC *paDescs, uint32_t *pcDescs, uint32_t cMaxDescs, DDSURFACEDESC *pDesc)
684{
685 uint32_t cDescs = *pcDescs;
686
687 Assert(cMaxDescs >= cDescs);
688 Assert(pDesc->dwFlags == (DDSD_CAPS | DDSD_PIXELFORMAT));
689 if (pDesc->dwFlags != (DDSD_CAPS | DDSD_PIXELFORMAT))
690 return VERR_INVALID_PARAMETER;
691
692 for (uint32_t i = 0; i < cDescs; ++i)
693 {
694 DDSURFACEDESC *pCur = &paDescs[i];
695 if (vboxPixFormatMatch(&pCur->ddpfPixelFormat, &pDesc->ddpfPixelFormat))
696 {
697 if (pDesc->dwFlags & DDSD_CAPS)
698 {
699 pCur->dwFlags |= DDSD_CAPS;
700 pCur->ddsCaps.dwCaps |= pDesc->ddsCaps.dwCaps;
701 }
702 return VINF_SUCCESS;
703 }
704 }
705
706 if (cMaxDescs > cDescs)
707 {
708 paDescs[cDescs] = *pDesc;
709 ++cDescs;
710 *pcDescs = cDescs;
711 return VINF_SUCCESS;
712 }
713 return VERR_BUFFER_OVERFLOW;
714}
715
716int vboxFormatOpsMerge(FORMATOP *paOps, uint32_t *pcOps, uint32_t cMaxOps, FORMATOP *pOp)
717{
718 uint32_t cOps = *pcOps;
719
720 Assert(cMaxOps >= cOps);
721
722 for (uint32_t i = 0; i < cOps; ++i)
723 {
724 FORMATOP *pCur = &paOps[i];
725 if (pCur->Format == pOp->Format)
726 {
727 pCur->Operations |= pOp->Operations;
728 Assert(pCur->FlipMsTypes == pOp->FlipMsTypes);
729 Assert(pCur->BltMsTypes == pOp->BltMsTypes);
730 Assert(pCur->PrivateFormatBitCount == pOp->PrivateFormatBitCount);
731 return VINF_SUCCESS;
732 }
733 }
734
735 if (cMaxOps > cOps)
736 {
737 paOps[cOps] = *pOp;
738 ++cOps;
739 *pcOps = cOps;
740 return VINF_SUCCESS;
741 }
742 return VERR_BUFFER_OVERFLOW;
743}
744
745int vboxCapsInit(PVBOXWDDMDISP_ADAPTER pAdapter)
746{
747 pAdapter->cFormstOps = 0;
748 pAdapter->paFormstOps = NULL;
749 pAdapter->cSurfDescs = 0;
750 pAdapter->paSurfDescs = NULL;
751
752 if (pAdapter->uIfVersion > 7)
753 {
754 if (pAdapter->pD3D9If)
755 {
756 pAdapter->paFormstOps = (FORMATOP*)RTMemAllocZ(sizeof (gVBoxFormatOps3D));
757 Assert(pAdapter->paFormstOps);
758 if (pAdapter->paFormstOps)
759 {
760 memcpy (pAdapter->paFormstOps , gVBoxFormatOps3D, sizeof (gVBoxFormatOps3D));
761 pAdapter->cFormstOps = RT_ELEMENTS(gVBoxFormatOps3D);
762 }
763 else
764 return VERR_OUT_OF_RESOURCES;
765
766 /* @todo: do we need surface caps here ? */
767 }
768 }
769#ifdef VBOX_WITH_VIDEOHWACCEL
770 else
771 {
772 /* just calc the max number of formats */
773 uint32_t cFormats = RT_ELEMENTS(gVBoxFormatOpsBase);
774 uint32_t cSurfDescs = RT_ELEMENTS(gVBoxSurfDescsBase);
775 uint32_t cOverlayFormats = 0;
776 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
777 {
778 VBOXDISPVHWA_INFO *pVhwa = &pAdapter->aHeads[i].Vhwa;
779 if (pVhwa->Settings.fFlags & VBOXVHWA_F_ENABLED)
780 {
781 cOverlayFormats += pVhwa->Settings.cFormats;
782 }
783 }
784
785 cFormats += cOverlayFormats;
786 cSurfDescs += cOverlayFormats;
787
788 uint32_t cbFormatOps = cFormats * sizeof (FORMATOP);
789 cbFormatOps = (cbFormatOps + 7) & ~3;
790 /* ensure the surf descs are 8 byte alligned */
791 uint32_t offSurfDescs = (cbFormatOps + 7) & ~3;
792 uint32_t cbSurfDescs = cSurfDescs * sizeof (DDSURFACEDESC);
793 uint32_t cbBuf = offSurfDescs + cbSurfDescs;
794 uint8_t* pvBuf = (uint8_t*)RTMemAllocZ(cbBuf);
795 Assert(pvBuf);
796 if (pvBuf)
797 {
798 pAdapter->paFormstOps = (FORMATOP*)pvBuf;
799 memcpy (pAdapter->paFormstOps , gVBoxFormatOpsBase, sizeof (gVBoxFormatOpsBase));
800 pAdapter->cFormstOps = RT_ELEMENTS(gVBoxFormatOpsBase);
801
802 FORMATOP fo = {D3DDDIFMT_UNKNOWN, 0, 0, 0, 0};
803 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
804 {
805 VBOXDISPVHWA_INFO *pVhwa = &pAdapter->aHeads[i].Vhwa;
806 if (pVhwa->Settings.fFlags & VBOXVHWA_F_ENABLED)
807 {
808 for (uint32_t j = 0; j < pVhwa->Settings.cFormats; ++j)
809 {
810 fo.Format = pVhwa->Settings.aFormats[j];
811 fo.Operations = FORMATOP_OVERLAY;
812 int rc = vboxFormatOpsMerge(pAdapter->paFormstOps, &pAdapter->cFormstOps, cFormats, &fo);
813 AssertRC(rc);
814 }
815 }
816 }
817
818 pAdapter->paSurfDescs = (DDSURFACEDESC*)(pvBuf + offSurfDescs);
819 memcpy (pAdapter->paSurfDescs , gVBoxSurfDescsBase, sizeof (gVBoxSurfDescsBase));
820 pAdapter->cSurfDescs = RT_ELEMENTS(gVBoxSurfDescsBase);
821
822 DDSURFACEDESC sd;
823 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
824 {
825 VBOXDISPVHWA_INFO *pVhwa = &pAdapter->aHeads[i].Vhwa;
826 if (pVhwa->Settings.fFlags & VBOXVHWA_F_ENABLED)
827 {
828 for (uint32_t j = 0; j < pVhwa->Settings.cFormats; ++j)
829 {
830 uint32_t fourcc = vboxWddmFormatToFourcc(pVhwa->Settings.aFormats[j]);
831 if (fourcc)
832 {
833 vboxVhwaPopulateOverlayFourccSurfDesc(&sd, fourcc);
834 int rc = vboxSurfDescMerge(pAdapter->paSurfDescs, &pAdapter->cSurfDescs, cSurfDescs, &sd);
835 AssertRC(rc);
836 }
837 }
838 }
839 }
840 }
841 else
842 return VERR_OUT_OF_RESOURCES;
843 }
844#endif
845
846 return VINF_SUCCESS;
847}
848
849void vboxCapsFree(PVBOXWDDMDISP_ADAPTER pAdapter)
850{
851 if (pAdapter->paFormstOps)
852 RTMemFree(pAdapter->paFormstOps);
853}
854
855static PVBOXWDDMDISP_RESOURCE vboxResourceAlloc(UINT cAllocs)
856{
857 PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)RTMemAllocZ(RT_OFFSETOF(VBOXWDDMDISP_RESOURCE, aAllocations[cAllocs]));
858 Assert(pRc);
859 if (pRc)
860 {
861 pRc->cAllocations = cAllocs;
862 return pRc;
863 }
864 return NULL;
865}
866
867static void vboxWddmLockUnlockMemSynch(PVBOXWDDMDISP_ALLOCATION pAlloc, D3DLOCKED_RECT *pLockInfo, RECT *pRect, bool bToLockInfo)
868{
869 Assert(pAlloc->SurfDesc.pitch);
870 Assert(pAlloc->pvMem);
871
872 if (!pRect)
873 {
874 if (pAlloc->SurfDesc.pitch == pLockInfo->Pitch)
875 {
876 if (bToLockInfo)
877 memcpy(pLockInfo->pBits, pAlloc->pvMem, pAlloc->SurfDesc.pitch * pAlloc->SurfDesc.height);
878 else
879 memcpy(pAlloc->pvMem, pLockInfo->pBits, pAlloc->SurfDesc.pitch * pAlloc->SurfDesc.height);
880 }
881 else
882 {
883 uint8_t *pvSrc, *pvDst;
884 uint32_t srcPitch, dstPitch;
885 if (bToLockInfo)
886 {
887 pvSrc = (uint8_t *)pAlloc->pvMem;
888 pvDst = (uint8_t *)pLockInfo->pBits;
889 srcPitch = pAlloc->SurfDesc.pitch;
890 dstPitch = pLockInfo->Pitch;
891 }
892 else
893 {
894 pvDst = (uint8_t *)pAlloc->pvMem;
895 pvSrc = (uint8_t *)pLockInfo->pBits;
896 dstPitch = pAlloc->SurfDesc.pitch;
897 srcPitch = (uint32_t)pLockInfo->Pitch;
898 }
899
900 uint32_t pitch = RT_MIN(srcPitch, dstPitch);
901 Assert(pitch);
902 for (UINT j = 0; j < pAlloc->SurfDesc.height; ++j)
903 {
904 memcpy(pvDst, pvSrc, pitch);
905 pvSrc += srcPitch;
906 pvDst += dstPitch;
907 }
908 }
909 }
910 else
911 {
912 uint8_t *pvSrc, *pvDst;
913 uint32_t srcPitch, dstPitch;
914 /* @todo: this is not entirely correct */
915 uint8_t * pvAllocMemStart = (uint8_t *)pAlloc->pvMem;
916 uint32_t cbPP = pAlloc->SurfDesc.pitch/pAlloc->SurfDesc.width;
917 pvAllocMemStart += pAlloc->SurfDesc.pitch * pRect->top + pRect->left * cbPP;
918
919 if (bToLockInfo)
920 {
921 pvSrc = (uint8_t *)pvAllocMemStart;
922 pvDst = (uint8_t *)pLockInfo->pBits;
923 srcPitch = pAlloc->SurfDesc.pitch;
924 dstPitch = pLockInfo->Pitch;
925 }
926 else
927 {
928 pvDst = (uint8_t *)pvAllocMemStart;
929 pvSrc = (uint8_t *)pLockInfo->pBits;
930 dstPitch = pAlloc->SurfDesc.pitch;
931 srcPitch = (uint32_t)pLockInfo->Pitch;
932 }
933
934 uint32_t cPixCopyLine = pRect->right - pRect->left;
935
936 if (cPixCopyLine == pAlloc->SurfDesc.width && srcPitch == dstPitch)
937 {
938 memcpy(pvDst, pvSrc, pAlloc->SurfDesc.pitch * (pRect->bottom - pRect->top));
939 }
940 else
941 {
942 uint32_t pitch = RT_MIN(srcPitch, dstPitch);
943 uint32_t cbCopyLine = cPixCopyLine * cbPP;
944 Assert(pitch);
945 for (int j = pRect->top; j < pRect->bottom; ++j)
946 {
947 memcpy(pvDst, pvSrc, cbCopyLine);
948 pvSrc += srcPitch;
949 pvDst += dstPitch;
950 }
951 }
952 }
953}
954
955static D3DFORMAT vboxDDI2D3DFormat(D3DDDIFORMAT format)
956{
957 /* @todo: check they are all equal */
958 return (D3DFORMAT)format;
959}
960
961D3DMULTISAMPLE_TYPE vboxDDI2D3DMultiSampleType(D3DDDIMULTISAMPLE_TYPE enmType)
962{
963 /* @todo: check they are all equal */
964 return (D3DMULTISAMPLE_TYPE)enmType;
965}
966
967D3DPOOL vboxDDI2D3DPool(D3DDDI_POOL enmPool)
968{
969 /* @todo: check they are all equal */
970 switch (enmPool)
971 {
972 case D3DDDIPOOL_SYSTEMMEM:
973 return D3DPOOL_SYSTEMMEM;
974 case D3DDDIPOOL_VIDEOMEMORY:
975 case D3DDDIPOOL_LOCALVIDMEM:
976 case D3DDDIPOOL_NONLOCALVIDMEM:
977 /* @todo: what would be propper here? */
978 return D3DPOOL_DEFAULT;
979 default:
980 AssertBreakpoint();
981 }
982 return D3DPOOL_DEFAULT;
983}
984
985D3DRENDERSTATETYPE vboxDDI2D3DRenderStateType(D3DDDIRENDERSTATETYPE enmType)
986{
987 /* @todo: @fixme: not entirely correct, need to check */
988 return (D3DRENDERSTATETYPE)enmType;
989}
990
991VBOXWDDMDISP_TSS_LOOKUP vboxDDI2D3DTestureStageStateType(D3DDDITEXTURESTAGESTATETYPE enmType)
992{
993 static const VBOXWDDMDISP_TSS_LOOKUP lookup[] =
994 {
995 {FALSE, D3DTSS_FORCE_DWORD}, /* 0, D3DDDITSS_TEXTUREMAP */
996 {FALSE, D3DTSS_COLOROP}, /* 1, D3DDDITSS_COLOROP */
997 {FALSE, D3DTSS_COLORARG1}, /* 2, D3DDDITSS_COLORARG1 */
998 {FALSE, D3DTSS_COLORARG2}, /* 3, D3DDDITSS_COLORARG2 */
999 {FALSE, D3DTSS_ALPHAOP}, /* 4, D3DDDITSS_ALPHAOP */
1000 {FALSE, D3DTSS_ALPHAARG1}, /* 5, D3DDDITSS_ALPHAARG1 */
1001 {FALSE, D3DTSS_ALPHAARG2}, /* 6, D3DDDITSS_ALPHAARG2 */
1002 {FALSE, D3DTSS_BUMPENVMAT00}, /* 7, D3DDDITSS_BUMPENVMAT00 */
1003 {FALSE, D3DTSS_BUMPENVMAT01}, /* 8, D3DDDITSS_BUMPENVMAT01 */
1004 {FALSE, D3DTSS_BUMPENVMAT10}, /* 9, D3DDDITSS_BUMPENVMAT10 */
1005 {FALSE, D3DTSS_BUMPENVMAT11}, /* 10, D3DDDITSS_BUMPENVMAT11 */
1006 {FALSE, D3DTSS_TEXCOORDINDEX}, /* 11, D3DDDITSS_TEXCOORDINDEX */
1007 {FALSE, D3DTSS_FORCE_DWORD}, /* 12, unused */
1008 {TRUE, D3DSAMP_ADDRESSU}, /* 13, D3DDDITSS_ADDRESSU */
1009 {TRUE, D3DSAMP_ADDRESSV}, /* 14, D3DDDITSS_ADDRESSV */
1010 {TRUE, D3DSAMP_BORDERCOLOR}, /* 15, D3DDDITSS_BORDERCOLOR */
1011 {TRUE, D3DSAMP_MAGFILTER}, /* 16, D3DDDITSS_MAGFILTER */
1012 {TRUE, D3DSAMP_MINFILTER}, /* 17, D3DDDITSS_MINFILTER */
1013 {TRUE, D3DSAMP_MIPFILTER}, /* 18, D3DDDITSS_MIPFILTER */
1014 {TRUE, D3DSAMP_MIPMAPLODBIAS}, /* 19, D3DDDITSS_MIPMAPLODBIAS */
1015 {TRUE, D3DSAMP_MAXMIPLEVEL}, /* 20, D3DDDITSS_MAXMIPLEVEL */
1016 {TRUE, D3DSAMP_MAXANISOTROPY}, /* 21, D3DDDITSS_MAXANISOTROPY */
1017 {FALSE, D3DTSS_BUMPENVLSCALE}, /* 22, D3DDDITSS_BUMPENVLSCALE */
1018 {FALSE, D3DTSS_BUMPENVLOFFSET}, /* 23, D3DDDITSS_BUMPENVLOFFSET */
1019 {FALSE, D3DTSS_TEXTURETRANSFORMFLAGS}, /* 24, D3DDDITSS_TEXTURETRANSFORMFLAGS */
1020 {TRUE, D3DSAMP_ADDRESSW}, /* 25, D3DDDITSS_ADDRESSW */
1021 {FALSE, D3DTSS_COLORARG0}, /* 26, D3DDDITSS_COLORARG0 */
1022 {FALSE, D3DTSS_ALPHAARG0}, /* 27, D3DDDITSS_ALPHAARG0 */
1023 {FALSE, D3DTSS_RESULTARG}, /* 28, D3DDDITSS_RESULTARG */
1024 {FALSE, D3DTSS_FORCE_DWORD}, /* 29, D3DDDITSS_SRGBTEXTURE */
1025 {FALSE, D3DTSS_FORCE_DWORD}, /* 30, D3DDDITSS_ELEMENTINDEX */
1026 {FALSE, D3DTSS_FORCE_DWORD}, /* 31, D3DDDITSS_DMAPOFFSET */
1027 {FALSE, D3DTSS_CONSTANT}, /* 32, D3DDDITSS_CONSTANT */
1028 {FALSE, D3DTSS_FORCE_DWORD}, /* 33, D3DDDITSS_DISABLETEXTURECOLORKEY */
1029 {FALSE, D3DTSS_FORCE_DWORD}, /* 34, D3DDDITSS_TEXTURECOLORKEYVAL */
1030 };
1031
1032 return lookup[enmType];
1033}
1034
1035DWORD vboxDDI2D3DUsage(D3DDDI_RESOURCEFLAGS fFlags)
1036{
1037 DWORD fUsage = 0;
1038 if (fFlags.Dynamic)
1039 fUsage |= D3DUSAGE_DYNAMIC;
1040 if (fFlags.AutogenMipmap)
1041 fUsage |= D3DUSAGE_AUTOGENMIPMAP;
1042 if (fFlags.DMap)
1043 fUsage |= D3DUSAGE_DMAP;
1044 if (fFlags.WriteOnly)
1045 fUsage |= D3DUSAGE_WRITEONLY;
1046 if (fFlags.NPatches)
1047 fUsage |= D3DUSAGE_NPATCHES;
1048 if (fFlags.Points)
1049 fUsage |= D3DUSAGE_POINTS;
1050 if (fFlags.RenderTarget)
1051 fUsage |= D3DUSAGE_RENDERTARGET;
1052 if (fFlags.RtPatches)
1053 fUsage |= D3DUSAGE_RTPATCHES;
1054 if (fFlags.TextApi)
1055 fUsage |= D3DUSAGE_TEXTAPI;
1056 if (fFlags.WriteOnly)
1057 fUsage |= D3DUSAGE_WRITEONLY;
1058 //below are wddm 1.1-specific
1059// if (fFlags.RestrictedContent)
1060// fUsage |= D3DUSAGE_RESTRICTED_CONTENT;
1061// if (fFlags.RestrictSharedAccess)
1062// fUsage |= D3DUSAGE_RESTRICT_SHARED_RESOURCE;
1063 return fUsage;
1064}
1065
1066DWORD vboxDDI2D3DLockFlags(D3DDDI_LOCKFLAGS fLockFlags)
1067{
1068 DWORD fFlags = 0;
1069 if (fLockFlags.Discard)
1070 fFlags |= D3DLOCK_DISCARD;
1071 if (fLockFlags.NoOverwrite)
1072 fFlags |= D3DLOCK_NOOVERWRITE;
1073 if (fLockFlags.ReadOnly)
1074 fFlags |= D3DLOCK_READONLY;
1075 if (fLockFlags.DoNotWait)
1076 fFlags |= D3DLOCK_DONOTWAIT;
1077 return fFlags;
1078}
1079
1080static void vboxResourcePopulateRcDesc(VBOXWDDM_RC_DESC *pDesc, D3DDDIARG_CREATERESOURCE* pResource)
1081{
1082 pDesc->fFlags = pResource->Flags;
1083 pDesc->enmFormat = pResource->Format;
1084 pDesc->enmPool = pResource->Pool;
1085 pDesc->enmMultisampleType = pResource->MultisampleType;
1086 pDesc->MultisampleQuality = pResource->MultisampleQuality;
1087 pDesc->MipLevels = pResource->MipLevels;
1088 pDesc->Fvf = pResource->Fvf;
1089 pDesc->VidPnSourceId = pResource->VidPnSourceId;
1090 pDesc->RefreshRate = pResource->RefreshRate;
1091 pDesc->enmRotation = pResource->Rotation;
1092}
1093
1094static void vboxResourceFree(PVBOXWDDMDISP_RESOURCE pRc)
1095{
1096 RTMemFree(pRc);
1097}
1098
1099/**
1100 * DLL entry point.
1101 */
1102BOOL WINAPI DllMain(HINSTANCE hInstance,
1103 DWORD dwReason,
1104 LPVOID lpReserved)
1105{
1106 switch (dwReason)
1107 {
1108 case DLL_PROCESS_ATTACH:
1109 {
1110 RTR3Init();
1111
1112 vboxVDbgPrint(("VBoxDispD3D: DLL loaded.\n"));
1113
1114// VbglR3Init();
1115 break;
1116 }
1117
1118 case DLL_PROCESS_DETACH:
1119 {
1120 vboxVDbgPrint(("VBoxDispD3D: DLL unloaded.\n"));
1121// VbglR3Term();
1122 /// @todo RTR3Term();
1123 break;
1124 }
1125
1126 default:
1127 break;
1128 }
1129 return TRUE;
1130}
1131
1132static HRESULT APIENTRY vboxWddmDispGetCaps (HANDLE hAdapter, CONST D3DDDIARG_GETCAPS* pData)
1133{
1134 vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p), caps type(%d)\n", hAdapter, pData->Type));
1135
1136 HRESULT hr = S_OK;
1137 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
1138
1139 switch (pData->Type)
1140 {
1141 case D3DDDICAPS_DDRAW:
1142 {
1143 Assert(!VBOXDISPMODE_IS_3D(pAdapter));
1144 Assert(pData->DataSize == sizeof (DDRAW_CAPS));
1145 if (pData->DataSize >= sizeof (DDRAW_CAPS))
1146 {
1147 memset(pData->pData, 0, sizeof (DDRAW_CAPS));
1148#ifdef VBOX_WITH_VIDEOHWACCEL
1149 if (vboxVhwaHasCKeying(pAdapter))
1150 {
1151 DDRAW_CAPS *pCaps = (DDRAW_CAPS*)pData->pData;
1152 pCaps->Caps |= DDRAW_CAPS_COLORKEY;
1153 pCaps->Caps2 |= DDRAW_CAPS2_FLIPNOVSYNC;
1154 }
1155#endif
1156 }
1157 else
1158 hr = E_INVALIDARG;
1159 break;
1160 }
1161 case D3DDDICAPS_DDRAW_MODE_SPECIFIC:
1162 {
1163 Assert(!VBOXDISPMODE_IS_3D(pAdapter));
1164 Assert(pData->DataSize == sizeof (DDRAW_MODE_SPECIFIC_CAPS));
1165 if (pData->DataSize >= sizeof (DDRAW_MODE_SPECIFIC_CAPS))
1166 {
1167 DDRAW_MODE_SPECIFIC_CAPS * pCaps = (DDRAW_MODE_SPECIFIC_CAPS*)pData->pData;
1168 memset(&pCaps->Caps /* do not cleanup the first "Head" field,
1169 zero starting with the one following "Head", i.e. Caps */,
1170 0, sizeof (DDRAW_MODE_SPECIFIC_CAPS) - RT_OFFSETOF(DDRAW_MODE_SPECIFIC_CAPS, Caps));
1171#ifdef VBOX_WITH_VIDEOHWACCEL
1172 VBOXVHWA_INFO *pSettings = &pAdapter->aHeads[pCaps->Head].Vhwa.Settings;
1173 if (pSettings->fFlags & VBOXVHWA_F_ENABLED)
1174 {
1175 pCaps->Caps |= MODE_CAPS_OVERLAY | MODE_CAPS_OVERLAYSTRETCH;
1176
1177 if (pSettings->fFlags & VBOXVHWA_F_CKEY_DST)
1178 {
1179 pCaps->CKeyCaps |= MODE_CKEYCAPS_DESTOVERLAY
1180 | MODE_CKEYCAPS_DESTOVERLAYYUV /* ?? */
1181 ;
1182 }
1183
1184 if (pSettings->fFlags & VBOXVHWA_F_CKEY_SRC)
1185 {
1186 pCaps->CKeyCaps |= MODE_CKEYCAPS_SRCOVERLAY
1187 | MODE_CKEYCAPS_SRCOVERLAYCLRSPACE /* ?? */
1188 | MODE_CKEYCAPS_SRCOVERLAYCLRSPACEYUV /* ?? */
1189 | MODE_CKEYCAPS_SRCOVERLAYYUV /* ?? */
1190 ;
1191 }
1192
1193 pCaps->FxCaps = MODE_FXCAPS_OVERLAYSHRINKX
1194 | MODE_FXCAPS_OVERLAYSHRINKY
1195 | MODE_FXCAPS_OVERLAYSTRETCHX
1196 | MODE_FXCAPS_OVERLAYSTRETCHY;
1197
1198
1199 pCaps->MaxVisibleOverlays = pSettings->cOverlaysSupported;
1200 pCaps->MinOverlayStretch = 1;
1201 pCaps->MaxOverlayStretch = 32000;
1202 }
1203#endif
1204 }
1205 else
1206 hr = E_INVALIDARG;
1207 break;
1208 }
1209 case D3DDDICAPS_GETFORMATCOUNT:
1210 *((uint32_t*)pData->pData) = pAdapter->cFormstOps;
1211 break;
1212 case D3DDDICAPS_GETFORMATDATA:
1213 Assert(pData->DataSize == pAdapter->cFormstOps * sizeof (FORMATOP));
1214 memcpy(pData->pData, pAdapter->paFormstOps, pAdapter->cFormstOps * sizeof (FORMATOP));
1215 break;
1216 case D3DDDICAPS_GETD3DQUERYCOUNT:
1217#if 0
1218 *((uint32_t*)pData->pData) = VBOX_QUERYTYPE_COUNT();
1219#else
1220 *((uint32_t*)pData->pData) = 0;
1221#endif
1222 break;
1223 case D3DDDICAPS_GETD3DQUERYDATA:
1224#if 0
1225 Assert(pData->DataSize == VBOX_QUERYTYPE_COUNT() * sizeof (D3DDDIQUERYTYPE));
1226 memcpy(pData->pData, gVBoxQueryTypes, VBOX_QUERYTYPE_COUNT() * sizeof (D3DDDIQUERYTYPE));
1227#else
1228 AssertBreakpoint();
1229 memset(pData->pData, 0, pData->DataSize);
1230#endif
1231 break;
1232 case D3DDDICAPS_GETD3D3CAPS:
1233 Assert(!VBOXDISPMODE_IS_3D(pAdapter));
1234 Assert(pData->DataSize == sizeof (D3DHAL_GLOBALDRIVERDATA));
1235 if (pData->DataSize >= sizeof (D3DHAL_GLOBALDRIVERDATA))
1236 {
1237 D3DHAL_GLOBALDRIVERDATA *pCaps = (D3DHAL_GLOBALDRIVERDATA *)pData->pData;
1238 memset (pCaps, 0, sizeof (D3DHAL_GLOBALDRIVERDATA));
1239 pCaps->dwSize = sizeof (D3DHAL_GLOBALDRIVERDATA);
1240 pCaps->hwCaps.dwSize = sizeof (D3DDEVICEDESC_V1);
1241 pCaps->hwCaps.dwFlags = D3DDD_COLORMODEL
1242 | D3DDD_DEVCAPS
1243 | D3DDD_DEVICERENDERBITDEPTH;
1244
1245 pCaps->hwCaps.dcmColorModel = D3DCOLOR_RGB;
1246 pCaps->hwCaps.dwDevCaps = D3DDEVCAPS_CANRENDERAFTERFLIP
1247// | D3DDEVCAPS_DRAWPRIMTLVERTEX
1248 | D3DDEVCAPS_EXECUTESYSTEMMEMORY
1249 | D3DDEVCAPS_EXECUTEVIDEOMEMORY
1250// | D3DDEVCAPS_FLOATTLVERTEX
1251 | D3DDEVCAPS_HWRASTERIZATION
1252// | D3DDEVCAPS_HWTRANSFORMANDLIGHT
1253// | D3DDEVCAPS_TLVERTEXSYSTEMMEMORY
1254// | D3DDEVCAPS_TEXTUREVIDEOMEMORY
1255 ;
1256 pCaps->hwCaps.dtcTransformCaps.dwSize = sizeof (D3DTRANSFORMCAPS);
1257 pCaps->hwCaps.dtcTransformCaps.dwCaps = 0;
1258 pCaps->hwCaps.bClipping = FALSE;
1259 pCaps->hwCaps.dlcLightingCaps.dwSize = sizeof (D3DLIGHTINGCAPS);
1260 pCaps->hwCaps.dlcLightingCaps.dwCaps = 0;
1261 pCaps->hwCaps.dlcLightingCaps.dwLightingModel = 0;
1262 pCaps->hwCaps.dlcLightingCaps.dwNumLights = 0;
1263 pCaps->hwCaps.dpcLineCaps.dwSize = sizeof (D3DPRIMCAPS);
1264 pCaps->hwCaps.dpcLineCaps.dwMiscCaps = 0;
1265 pCaps->hwCaps.dpcLineCaps.dwRasterCaps = 0;
1266 pCaps->hwCaps.dpcLineCaps.dwZCmpCaps = 0;
1267 pCaps->hwCaps.dpcLineCaps.dwSrcBlendCaps = 0;
1268 pCaps->hwCaps.dpcLineCaps.dwDestBlendCaps = 0;
1269 pCaps->hwCaps.dpcLineCaps.dwAlphaCmpCaps = 0;
1270 pCaps->hwCaps.dpcLineCaps.dwShadeCaps = 0;
1271 pCaps->hwCaps.dpcLineCaps.dwTextureCaps = 0;
1272 pCaps->hwCaps.dpcLineCaps.dwTextureFilterCaps = 0;
1273 pCaps->hwCaps.dpcLineCaps.dwTextureBlendCaps = 0;
1274 pCaps->hwCaps.dpcLineCaps.dwTextureAddressCaps = 0;
1275 pCaps->hwCaps.dpcLineCaps.dwStippleWidth = 0;
1276 pCaps->hwCaps.dpcLineCaps.dwStippleHeight = 0;
1277
1278 pCaps->hwCaps.dpcTriCaps.dwSize = sizeof (D3DPRIMCAPS);
1279 pCaps->hwCaps.dpcTriCaps.dwMiscCaps = 0;
1280 pCaps->hwCaps.dpcTriCaps.dwRasterCaps = 0;
1281 pCaps->hwCaps.dpcTriCaps.dwZCmpCaps = 0;
1282 pCaps->hwCaps.dpcTriCaps.dwSrcBlendCaps = 0;
1283 pCaps->hwCaps.dpcTriCaps.dwDestBlendCaps = 0;
1284 pCaps->hwCaps.dpcTriCaps.dwAlphaCmpCaps = 0;
1285 pCaps->hwCaps.dpcTriCaps.dwShadeCaps = 0;
1286 pCaps->hwCaps.dpcTriCaps.dwTextureCaps = 0;
1287 pCaps->hwCaps.dpcTriCaps.dwTextureFilterCaps = 0;
1288 pCaps->hwCaps.dpcTriCaps.dwTextureBlendCaps = 0;
1289 pCaps->hwCaps.dpcTriCaps.dwTextureAddressCaps = 0;
1290 pCaps->hwCaps.dpcTriCaps.dwStippleWidth = 0;
1291 pCaps->hwCaps.dpcTriCaps.dwStippleHeight = 0;
1292 pCaps->hwCaps.dwDeviceRenderBitDepth = DDBD_8 | DDBD_16 | DDBD_24 | DDBD_32;
1293 pCaps->hwCaps.dwDeviceZBufferBitDepth = 0;
1294 pCaps->hwCaps.dwMaxBufferSize = 0;
1295 pCaps->hwCaps.dwMaxVertexCount = 0;
1296
1297
1298 pCaps->dwNumVertices = 0;
1299 pCaps->dwNumClipVertices = 0;
1300 pCaps->dwNumTextureFormats = 0;//pAdapter->cSurfDescs;
1301 pCaps->lpTextureFormats = NULL;//pAdapter->paSurfDescs;
1302 }
1303 else
1304 hr = E_INVALIDARG;
1305 break;
1306 case D3DDDICAPS_GETD3D7CAPS:
1307 Assert(!VBOXDISPMODE_IS_3D(pAdapter));
1308 Assert(pData->DataSize == sizeof (D3DHAL_D3DEXTENDEDCAPS));
1309 if (pData->DataSize >= sizeof (D3DHAL_D3DEXTENDEDCAPS))
1310 {
1311 memset(pData->pData, 0, sizeof (D3DHAL_D3DEXTENDEDCAPS));
1312 D3DHAL_D3DEXTENDEDCAPS *pCaps = (D3DHAL_D3DEXTENDEDCAPS*)pData->pData;
1313 pCaps->dwSize = sizeof (D3DHAL_D3DEXTENDEDCAPS);
1314 }
1315 else
1316 hr = E_INVALIDARG;
1317 break;
1318 case D3DDDICAPS_GETD3D9CAPS:
1319 {
1320 Assert(pData->DataSize >= sizeof (D3DCAPS9));
1321// AssertBreakpoint();
1322 if (pData->DataSize >= sizeof (D3DCAPS9))
1323 {
1324 Assert(VBOXDISPMODE_IS_3D(pAdapter));
1325 if (VBOXDISPMODE_IS_3D(pAdapter))
1326 {
1327 D3DCAPS9* pCaps = (D3DCAPS9*)pData->pData;
1328 hr = pAdapter->pD3D9If->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, pCaps);
1329 Assert(hr == S_OK);
1330 if (hr == S_OK)
1331 {
1332 pCaps->Caps2 |= D3DCAPS2_CANSHARERESOURCE | 0x00080000 /*D3DCAPS2_CANRENDERWINDOWED*/;
1333 pCaps->DevCaps |= D3DDEVCAPS_FLOATTLVERTEX /* <- must be set according to the docs */
1334 /*| D3DDEVCAPS_HWVERTEXBUFFER | D3DDEVCAPS_HWINDEXBUFFER | D3DDEVCAPS_SUBVOLUMELOCK */;
1335 pCaps->PrimitiveMiscCaps |= D3DPMISCCAPS_INDEPENDENTWRITEMASKS
1336 | D3DPMISCCAPS_FOGINFVF
1337 | D3DPMISCCAPS_SEPARATEALPHABLEND | D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS;
1338 pCaps->RasterCaps |= D3DPRASTERCAPS_SUBPIXEL | D3DPRASTERCAPS_STIPPLE | D3DPRASTERCAPS_ZBIAS | D3DPRASTERCAPS_COLORPERSPECTIVE /* keep */;
1339 pCaps->TextureCaps |= D3DPTEXTURECAPS_TRANSPARENCY | D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE;
1340 pCaps->TextureAddressCaps |= D3DPTADDRESSCAPS_MIRRORONCE;
1341 pCaps->VolumeTextureAddressCaps |= D3DPTADDRESSCAPS_MIRRORONCE;
1342 pCaps->GuardBandLeft = -8192.;
1343 pCaps->GuardBandTop = -8192.;
1344 pCaps->GuardBandRight = 8192.;
1345 pCaps->GuardBandBottom = 8192.;
1346 pCaps->StencilCaps |= D3DSTENCILCAPS_TWOSIDED;
1347 pCaps->DeclTypes |= D3DDTCAPS_FLOAT16_2 | D3DDTCAPS_FLOAT16_4;
1348 pCaps->VS20Caps.DynamicFlowControlDepth = 24;
1349 pCaps->VS20Caps.NumTemps = D3DVS20_MAX_NUMTEMPS;
1350 pCaps->PS20Caps.DynamicFlowControlDepth = 24;
1351 pCaps->PS20Caps.NumTemps = D3DVS20_MAX_NUMTEMPS;
1352 pCaps->VertexTextureFilterCaps |= D3DPTFILTERCAPS_MINFPOINT | D3DPTFILTERCAPS_MAGFPOINT;
1353#if 1 /* workaround for wine not returning InstructionSlots correctly for shaders v3.0 */
1354 if ((pCaps->VertexShaderVersion & 0xff00) == 0x0300)
1355 {
1356 pCaps->MaxVertexShader30InstructionSlots = RT_MIN(32768, pCaps->MaxVertexShader30InstructionSlots);
1357 pCaps->MaxPixelShader30InstructionSlots = RT_MIN(32768, pCaps->MaxPixelShader30InstructionSlots);
1358 }
1359#endif
1360#ifdef DEBUG
1361 if ((pCaps->VertexShaderVersion & 0xff00) == 0x0300)
1362 {
1363 Assert(pCaps->MaxVertexShader30InstructionSlots >= 512);
1364 Assert(pCaps->MaxVertexShader30InstructionSlots <= 32768);
1365 Assert(pCaps->MaxPixelShader30InstructionSlots >= 512);
1366 Assert(pCaps->MaxPixelShader30InstructionSlots <= 32768);
1367 }
1368 else if ((pCaps->VertexShaderVersion & 0xff00) == 0x0200)
1369 {
1370 Assert(pCaps->MaxVertexShader30InstructionSlots == 0);
1371 Assert(pCaps->MaxPixelShader30InstructionSlots == 0);
1372 }
1373 else
1374 {
1375 AssertBreakpoint();
1376 }
1377#endif
1378 break;
1379 }
1380
1381 vboxVDbgPrintR((__FUNCTION__": GetDeviceCaps hr(%d)\n", hr));
1382 /* let's fall back to the 3D disabled case */
1383 hr = S_OK;
1384 }
1385
1386 memset(pData->pData, 0, sizeof (D3DCAPS9));
1387 }
1388 else
1389 hr = E_INVALIDARG;
1390 break;
1391 }
1392 case D3DDDICAPS_GETGAMMARAMPCAPS:
1393 *((uint32_t*)pData->pData) = 0;
1394 break;
1395 case D3DDDICAPS_GETVIDEOPROCESSORCAPS:
1396 case D3DDDICAPS_GETEXTENSIONGUIDCOUNT:
1397 case D3DDDICAPS_GETDECODEGUIDCOUNT:
1398 case D3DDDICAPS_GETVIDEOPROCESSORDEVICEGUIDCOUNT:
1399 if (pData->pData && pData->DataSize)
1400 memset(pData->pData, 0, pData->DataSize);
1401 break;
1402 case D3DDDICAPS_GETMULTISAMPLEQUALITYLEVELS:
1403 case D3DDDICAPS_GETD3D5CAPS:
1404 case D3DDDICAPS_GETD3D6CAPS:
1405 case D3DDDICAPS_GETD3D8CAPS:
1406 case D3DDDICAPS_GETDECODEGUIDS:
1407 case D3DDDICAPS_GETDECODERTFORMATCOUNT:
1408 case D3DDDICAPS_GETDECODERTFORMATS:
1409 case D3DDDICAPS_GETDECODECOMPRESSEDBUFFERINFOCOUNT:
1410 case D3DDDICAPS_GETDECODECOMPRESSEDBUFFERINFO:
1411 case D3DDDICAPS_GETDECODECONFIGURATIONCOUNT:
1412 case D3DDDICAPS_GETDECODECONFIGURATIONS:
1413 case D3DDDICAPS_GETVIDEOPROCESSORDEVICEGUIDS:
1414 case D3DDDICAPS_GETVIDEOPROCESSORRTFORMATCOUNT:
1415 case D3DDDICAPS_GETVIDEOPROCESSORRTFORMATS:
1416 case D3DDDICAPS_GETVIDEOPROCESSORRTSUBSTREAMFORMATCOUNT:
1417 case D3DDDICAPS_GETVIDEOPROCESSORRTSUBSTREAMFORMATS:
1418 case D3DDDICAPS_GETPROCAMPRANGE:
1419 case D3DDDICAPS_FILTERPROPERTYRANGE:
1420 case D3DDDICAPS_GETEXTENSIONGUIDS:
1421 case D3DDDICAPS_GETEXTENSIONCAPS:
1422 vboxVDbgPrint((__FUNCTION__": unimplemented caps type(%d)\n", pData->Type));
1423 AssertBreakpoint();
1424 if (pData->pData && pData->DataSize)
1425 memset(pData->pData, 0, pData->DataSize);
1426 break;
1427 default:
1428 vboxVDbgPrint((__FUNCTION__": unknown caps type(%d)\n", pData->Type));
1429 AssertBreakpoint();
1430 }
1431
1432 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p), caps type(%d)\n", hAdapter, pData->Type));
1433
1434 return S_OK;
1435}
1436
1437static HRESULT APIENTRY vboxWddmDDevSetRenderState(HANDLE hDevice, CONST D3DDDIARG_RENDERSTATE* pData)
1438{
1439 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1440 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1441 Assert(pDevice);
1442 Assert(pDevice->pDevice9If);
1443 HRESULT hr = pDevice->pDevice9If->SetRenderState(vboxDDI2D3DRenderStateType(pData->State), pData->Value);
1444 Assert(hr == S_OK);
1445 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1446 return hr;
1447}
1448
1449static HRESULT APIENTRY vboxWddmDDevUpdateWInfo(HANDLE hDevice, CONST D3DDDIARG_WINFO* pData)
1450{
1451 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1452 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1453 return S_OK;
1454}
1455
1456static HRESULT APIENTRY vboxWddmDDevValidateDevice(HANDLE hDevice, D3DDDIARG_VALIDATETEXTURESTAGESTATE* pData)
1457{
1458 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1459 AssertBreakpoint();
1460 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1461 return E_FAIL;
1462}
1463
1464static HRESULT APIENTRY vboxWddmDDevSetTextureStageState(HANDLE hDevice, CONST D3DDDIARG_TEXTURESTAGESTATE* pData)
1465{
1466 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1467 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1468 Assert(pDevice);
1469 Assert(pDevice->pDevice9If);
1470
1471 VBOXWDDMDISP_TSS_LOOKUP lookup = vboxDDI2D3DTestureStageStateType(pData->State);
1472 HRESULT hr;
1473
1474 if (!lookup.bSamplerState)
1475 {
1476 hr = pDevice->pDevice9If->SetTextureStageState(pData->Stage, D3DTEXTURESTAGESTATETYPE(lookup.dType), pData->Value);
1477 }
1478 else
1479 {
1480 hr = pDevice->pDevice9If->SetSamplerState(pData->Stage, D3DSAMPLERSTATETYPE(lookup.dType), pData->Value);
1481 }
1482
1483 Assert(hr == S_OK);
1484 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1485 return hr;
1486}
1487
1488static HRESULT APIENTRY vboxWddmDDevSetTexture(HANDLE hDevice, UINT Stage, HANDLE hTexture)
1489{
1490 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1491 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1492 Assert(pDevice);
1493 Assert(pDevice->pDevice9If);
1494 PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)hTexture;
1495// Assert(pRc);
1496 IDirect3DTexture9 *pD3DIfTex = pRc ? (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf : NULL;
1497// Assert(pD3DIfTex);
1498 HRESULT hr = pDevice->pDevice9If->SetTexture(Stage, pD3DIfTex);
1499 Assert(hr == S_OK);
1500 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1501 return hr;
1502}
1503
1504static HRESULT APIENTRY vboxWddmDDevSetPixelShader(HANDLE hDevice, HANDLE hShaderHandle)
1505{
1506 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1507 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1508 Assert(pDevice);
1509 Assert(pDevice->pDevice9If);
1510 IDirect3DPixelShader9 *pShader = (IDirect3DPixelShader9*)hShaderHandle;
1511 Assert(pShader);
1512 HRESULT hr = pDevice->pDevice9If->SetPixelShader(pShader);
1513 Assert(hr == S_OK);
1514 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1515 return hr;
1516}
1517
1518static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONST* pData, CONST FLOAT* pRegisters)
1519{
1520 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1521 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1522 Assert(pDevice);
1523 Assert(pDevice->pDevice9If);
1524 HRESULT hr = pDevice->pDevice9If->SetPixelShaderConstantF(pData->Register, pRegisters, pData->Count);
1525 Assert(hr == S_OK);
1526 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1527 return hr;
1528}
1529
1530static HRESULT APIENTRY vboxWddmDDevSetStreamSourceUm(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEUM* pData, CONST VOID* pUMBuffer )
1531{
1532 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1533 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1534 Assert(pDevice);
1535 Assert(pDevice->pDevice9If);
1536 HRESULT hr = S_OK;
1537// IDirect3DVertexBuffer9 *pStreamData;
1538// UINT cbOffset;
1539// UINT cbStride;
1540// hr = pDevice->pDevice9If->GetStreamSource(pData->Stream, &pStreamData, &cbOffset, &cbStride);
1541// Assert(hr == S_OK);
1542// if (hr == S_OK)
1543// {
1544// if (pStreamData)
1545// {
1546// AssertBreakpoint();
1547// /* @todo: impl! */
1548// }
1549// else
1550// {
1551 Assert(pData->Stream < RT_ELEMENTS(pDevice->aStreamSourceUm));
1552 PVBOXWDDMDISP_STREAMSOURCEUM pStrSrcUm = &pDevice->aStreamSourceUm[pData->Stream];
1553 pStrSrcUm->pvBuffer = pUMBuffer;
1554 pStrSrcUm->cbStride = pData->Stride;
1555// }
1556// }
1557 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1558 return hr;
1559}
1560
1561static HRESULT APIENTRY vboxWddmDDevSetIndices(HANDLE hDevice, CONST D3DDDIARG_SETINDICES* 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}
1568
1569static HRESULT APIENTRY vboxWddmDDevSetIndicesUm(HANDLE hDevice, UINT IndexSize, CONST VOID* pUMBuffer)
1570{
1571 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1572 AssertBreakpoint();
1573 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1574 return E_FAIL;
1575}
1576
1577static HRESULT APIENTRY vboxWddmDDevDrawPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE* pData, CONST UINT* pFlagBuffer)
1578{
1579 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1580 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1581 Assert(pDevice);
1582 Assert(pDevice->pDevice9If);
1583 Assert(!pFlagBuffer);
1584 HRESULT hr = S_OK;
1585
1586 if (!pDevice->cStreamSources)
1587 {
1588 Assert(pDevice->aStreamSourceUm[0].pvBuffer);
1589#ifdef DEBUG
1590 for (UINT i = 1; i < RT_ELEMENTS(pDevice->aStreamSourceUm); ++i)
1591 {
1592 Assert(!pDevice->aStreamSourceUm[i].pvBuffer);
1593 }
1594#endif
1595 hr = pDevice->pDevice9If->DrawPrimitiveUP(pData->PrimitiveType,
1596 pData->PrimitiveCount,
1597 ((uint8_t*)pDevice->aStreamSourceUm[0].pvBuffer) + pData->VStart * pDevice->aStreamSourceUm[0].cbStride,
1598 pDevice->aStreamSourceUm[0].cbStride);
1599 Assert(hr == S_OK);
1600 }
1601 else
1602 {
1603 AssertBreakpoint();
1604 hr = pDevice->pDevice9If->DrawPrimitive(pData->PrimitiveType,
1605 pData->VStart,
1606 pData->PrimitiveCount);
1607#if 0
1608 IDirect3DVertexDeclaration9* pDecl;
1609 hr = pDevice->pDevice9If->GetVertexDeclaration(&pDecl);
1610 Assert(hr == S_OK);
1611 if (hr == S_OK)
1612 {
1613 Assert(pDecl);
1614 D3DVERTEXELEMENT9 aDecls9[MAXD3DDECLLENGTH];
1615 UINT cDecls9 = 0;
1616 hr = pDecl->GetDeclaration(aDecls9, &cDecls9);
1617 Assert(hr == S_OK);
1618 if (hr == S_OK)
1619 {
1620 Assert(cDecls9);
1621 for (UINT i = 0; i < cDecls9 - 1 /* the last one is D3DDECL_END */; ++i)
1622 {
1623 D3DVERTEXELEMENT9 *pDecl9 = &aDecls9[i];
1624 Assert(pDecl9->Stream < RT_ELEMENTS(pDevice->aStreamSourceUm) || pDecl9->Stream == 0xff);
1625 if (pDecl9->Stream != 0xff)
1626 {
1627 PVBOXWDDMDISP_STREAMSOURCEUM pStrSrc = &pDevice->aStreamSourceUm[pDecl9->Stream];
1628 if (pStrSrc->pvBuffer)
1629 {
1630 WORD iStream = pDecl9->Stream;
1631 D3DVERTEXELEMENT9 *pLastCDecl9 = pDecl9;
1632 for (UINT j = i+1; j < cDecls9 - 1 /* the last one is D3DDECL_END */; ++j)
1633 {
1634 pDecl9 = &aDecls9[j];
1635 if (iStream == pDecl9->Stream)
1636 {
1637 pDecl9->Stream = 0xff; /* mark as done */
1638 Assert(pDecl9->Offset != pLastCDecl9->Offset);
1639 if (pDecl9->Offset > pLastCDecl9->Offset)
1640 pLastCDecl9 = pDecl9;
1641 }
1642 }
1643 /* vertex size is MAX(all Offset's) + sizeof (data_type with MAX offset) + stride*/
1644 UINT cbVertex = pLastCDecl9->Offset + pStrSrc->cbStride;
1645 UINT cbType;
1646 switch (pLastCDecl9->Type)
1647 {
1648 case D3DDECLTYPE_FLOAT1:
1649 cbType = sizeof (float);
1650 break;
1651 case D3DDECLTYPE_FLOAT2:
1652 cbType = sizeof (float) * 2;
1653 break;
1654 case D3DDECLTYPE_FLOAT3:
1655 cbType = sizeof (float) * 3;
1656 break;
1657 case D3DDECLTYPE_FLOAT4:
1658 cbType = sizeof (float) * 4;
1659 break;
1660 case D3DDECLTYPE_D3DCOLOR:
1661 cbType = 4;
1662 break;
1663 case D3DDECLTYPE_UBYTE4:
1664 cbType = 4;
1665 break;
1666 case D3DDECLTYPE_SHORT2:
1667 cbType = sizeof (short) * 2;
1668 break;
1669 case D3DDECLTYPE_SHORT4:
1670 cbType = sizeof (short) * 4;
1671 break;
1672 case D3DDECLTYPE_UBYTE4N:
1673 cbType = 4;
1674 break;
1675 case D3DDECLTYPE_SHORT2N:
1676 cbType = sizeof (short) * 2;
1677 break;
1678 case D3DDECLTYPE_SHORT4N:
1679 cbType = sizeof (short) * 4;
1680 break;
1681 case D3DDECLTYPE_USHORT2N:
1682 cbType = sizeof (short) * 2;
1683 break;
1684 case D3DDECLTYPE_USHORT4N:
1685 cbType = sizeof (short) * 4;
1686 break;
1687 case D3DDECLTYPE_UDEC3:
1688 cbType = sizeof (signed) * 3;
1689 break;
1690 case D3DDECLTYPE_DEC3N:
1691 cbType = sizeof (unsigned) * 3;
1692 break;
1693 case D3DDECLTYPE_FLOAT16_2:
1694 cbType = 2 * 2;
1695 break;
1696 case D3DDECLTYPE_FLOAT16_4:
1697 cbType = 2 * 4;
1698 break;
1699 default:
1700 AssertBreakpoint();
1701 cbType = 1;
1702 }
1703 cbVertex += cbType;
1704
1705 UINT cVertexes;
1706 switch (pData->PrimitiveType)
1707 {
1708 case D3DPT_POINTLIST:
1709 cVertexes = pData->PrimitiveCount;
1710 break;
1711 case D3DPT_LINELIST:
1712 cVertexes = pData->PrimitiveCount * 2;
1713 break;
1714 case D3DPT_LINESTRIP:
1715 cVertexes = pData->PrimitiveCount + 1;
1716 break;
1717 case D3DPT_TRIANGLELIST:
1718 cVertexes = pData->PrimitiveCount * 3;
1719 break;
1720 case D3DPT_TRIANGLESTRIP:
1721 cVertexes = pData->PrimitiveCount + 2;
1722 break;
1723 case D3DPT_TRIANGLEFAN:
1724 cVertexes = pData->PrimitiveCount + 2;
1725 break;
1726 default:
1727 AssertBreakpoint();
1728 cVertexes = pData->PrimitiveCount;
1729 }
1730 UINT cbVertexes = cVertexes * cbVertex;
1731 IDirect3DVertexBuffer9 *pCurVb = NULL, *pVb = NULL;
1732 UINT cbOffset;
1733 UINT cbStride;
1734 hr = pDevice->pDevice9If->GetStreamSource(iStream, &pCurVb, &cbOffset, &cbStride);
1735 Assert(hr == S_OK);
1736 if (hr == S_OK)
1737 {
1738 if (pCurVb)
1739 {
1740 if (cbStride == pStrSrc->cbStride)
1741 {
1742 /* ensure our data feets in the buffer */
1743 D3DVERTEXBUFFER_DESC Desc;
1744 hr = pCurVb->GetDesc(&Desc);
1745 Assert(hr == S_OK);
1746 if (hr == S_OK)
1747 {
1748 if (Desc.Size >= cbVertexes)
1749 pVb = pCurVb;
1750 }
1751 }
1752 }
1753 }
1754 else
1755 {
1756 pCurVb = NULL;
1757 }
1758
1759 if (!pVb)
1760 {
1761 hr = pDevice->pDevice9If->CreateVertexBuffer(cbVertexes,
1762 0, /* DWORD Usage */
1763 0, /* DWORD FVF */
1764 D3DPOOL_DEFAULT, /* D3DPOOL Pool */
1765 &pVb,
1766 NULL /*HANDLE* pSharedHandle*/);
1767 Assert(hr == S_OK);
1768 if (hr == S_OK)
1769 {
1770 hr = pDevice->pDevice9If->SetStreamSource(iStream, pVb, 0, pStrSrc->cbStride);
1771 Assert(hr == S_OK);
1772 if (hr == S_OK)
1773 {
1774 if (pCurVb)
1775 pCurVb->Release();
1776 }
1777 else
1778 {
1779 pVb->Release();
1780 pVb = NULL;
1781 }
1782 }
1783 }
1784
1785 if (pVb)
1786 {
1787 Assert(hr == S_OK);
1788 VOID *pvData;
1789 hr = pVb->Lock(0, /* UINT OffsetToLock */
1790 cbVertexes,
1791 &pvData,
1792 D3DLOCK_DISCARD);
1793 Assert(hr == S_OK);
1794 if (hr == S_OK)
1795 {
1796 memcpy (pvData, ((uint8_t*)pStrSrc->pvBuffer) + pData->VStart * cbVertex, cbVertexes);
1797 HRESULT tmpHr = pVb->Unlock();
1798 Assert(tmpHr == S_OK);
1799 }
1800 }
1801 }
1802 }
1803 }
1804 }
1805 if (hr == S_OK)
1806 {
1807 hr = pDevice->pDevice9If->DrawPrimitive(pData->PrimitiveType,
1808 0 /* <- since we use our owne StreamSource buffer which has data at the very beginning*/,
1809 pData->PrimitiveCount);
1810 Assert(hr == S_OK);
1811 }
1812 }
1813#endif
1814 }
1815 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1816 return hr;
1817}
1818
1819static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE* pData)
1820{
1821 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1822 AssertBreakpoint();
1823 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1824 return E_FAIL;
1825}
1826
1827static HRESULT APIENTRY vboxWddmDDevDrawRectPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWRECTPATCH* pData, CONST D3DDDIRECTPATCH_INFO* pInfo, CONST FLOAT* pPatch)
1828{
1829 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1830 AssertBreakpoint();
1831 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1832 return E_FAIL;
1833}
1834
1835static HRESULT APIENTRY vboxWddmDDevDrawTriPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWTRIPATCH* pData, CONST D3DDDITRIPATCH_INFO* pInfo, CONST FLOAT* pPatch)
1836{
1837 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1838 AssertBreakpoint();
1839 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1840 return E_FAIL;
1841}
1842
1843static HRESULT APIENTRY vboxWddmDDevDrawPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE2* pData)
1844{
1845 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1846 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1847 Assert(pDevice);
1848 Assert(pDevice->pDevice9If);
1849 HRESULT hr;
1850
1851#if 0
1852 int stream;
1853 for (stream=0; stream<VBOXWDDMDISP_MAX_VERTEX_STREAMS; ++stream)
1854 {
1855 if (pDevice->aStreamSource[stream] && pDevice->aStreamSource[stream]->LockInfo.cLocks)
1856 {
1857 VBOXWDDMDISP_LOCKINFO *pLock = &pDevice->aStreamSource[stream]->LockInfo;
1858 if (pLock->fFlags.MightDrawFromLocked && (pLock->fFlags.Discard || pLock->fFlags.NoOverwrite))
1859 {
1860 IDirect3DVertexBuffer9 *pD3D9VBuf = (IDirect3DVertexBuffer9*)pDevice->aStreamSource[stream]->pD3DIf;
1861 Assert(pLock->fFlags.RangeValid);
1862 pD3D9VBuf->Lock(pLock->Range.Offset, pLock->Range.Size,
1863 &pLock->LockedRect.pBits,
1864 vboxDDI2D3DLockFlags(pLock->fFlags));
1865 RECT r;
1866 r.top = 0;
1867 r.left = pLock->Range.Offset;
1868 r.bottom = 1;
1869 r.right = pLock->Range.Offset + pLock->Range.Size;
1870
1871 vboxWddmLockUnlockMemSynch(pDevice->aStreamSource[stream], &pLock->LockedRect, &r, true /*bool bToLockInfo*/);
1872
1873 pD3D9VBuf->Unlock();
1874 }
1875 }
1876 }
1877
1878 hr = pDevice->pDevice9If->DrawPrimitive(pData->PrimitiveType, pData->FirstVertexOffset, pData->PrimitiveCount);
1879#else
1880 int stream;
1881 for (stream=0; stream<VBOXWDDMDISP_MAX_VERTEX_STREAMS; ++stream)
1882 {
1883 if (pDevice->aStreamSource[stream])
1884 {
1885 Assert(stream==0); /*only stream 0 should be accessed here*/
1886 Assert(pDevice->StreamSourceInfo[stream].uiStride!=0);
1887 VBOXWDDMDISP_LOCKINFO *pLock = &pDevice->aStreamSource[stream]->LockInfo;
1888
1889 if (pDevice->aStreamSource[stream]->LockInfo.cLocks)
1890 {
1891 Assert(pLock->fFlags.MightDrawFromLocked && (pLock->fFlags.Discard || pLock->fFlags.NoOverwrite));
1892 hr = pDevice->pDevice9If->DrawPrimitiveUP(pData->PrimitiveType, pData->PrimitiveCount,
1893 (void*)((uintptr_t)pDevice->aStreamSource[stream]->pvMem+pDevice->StreamSourceInfo[stream].uiOffset+pData->FirstVertexOffset),
1894 pDevice->StreamSourceInfo[stream].uiStride);
1895 Assert(hr == S_OK);
1896 hr = pDevice->pDevice9If->SetStreamSource(stream, (IDirect3DVertexBuffer9*)pDevice->aStreamSource[stream]->pD3DIf, pDevice->StreamSourceInfo[stream].uiOffset, pDevice->StreamSourceInfo[stream].uiStride);
1897 }
1898 else
1899 {
1900 hr = pDevice->pDevice9If->DrawPrimitive(pData->PrimitiveType, pData->FirstVertexOffset/pDevice->StreamSourceInfo[stream].uiStride, pData->PrimitiveCount);
1901 }
1902 }
1903 }
1904#endif
1905
1906 Assert(hr == S_OK);
1907 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1908 return hr;
1909}
1910
1911static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE2* pData, UINT dwIndicesSize, CONST VOID* pIndexBuffer, CONST UINT* pFlagBuffer)
1912{
1913 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1914 AssertBreakpoint();
1915 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1916 return E_FAIL;
1917}
1918
1919static HRESULT APIENTRY vboxWddmDDevVolBlt(HANDLE hDevice, CONST D3DDDIARG_VOLUMEBLT* pData)
1920{
1921 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1922 AssertBreakpoint();
1923 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1924 return E_FAIL;
1925}
1926
1927static HRESULT APIENTRY vboxWddmDDevBufBlt(HANDLE hDevice, CONST D3DDDIARG_BUFFERBLT* pData)
1928{
1929 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1930 AssertBreakpoint();
1931 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1932 return E_FAIL;
1933}
1934
1935static HRESULT APIENTRY vboxWddmDDevTexBlt(HANDLE hDevice, CONST D3DDDIARG_TEXBLT* pData)
1936{
1937 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1938 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1939 Assert(pDevice);
1940 Assert(pDevice->pDevice9If);
1941 PVBOXWDDMDISP_RESOURCE pDstRc = (PVBOXWDDMDISP_RESOURCE)pData->hDstResource;
1942 PVBOXWDDMDISP_RESOURCE pSrcRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
1943 IDirect3DTexture9 *pD3DIfSrcTex = (IDirect3DTexture9*)pSrcRc->aAllocations[0].pD3DIf;
1944 IDirect3DTexture9 *pD3DIfDstTex = (IDirect3DTexture9*)pDstRc->aAllocations[0].pD3DIf;
1945 Assert(pD3DIfSrcTex);
1946 Assert(pD3DIfDstTex);
1947 HRESULT hr = S_OK;
1948
1949 if (pSrcRc->aAllocations[0].SurfDesc.width == pDstRc->aAllocations[0].SurfDesc.width
1950 && pSrcRc->aAllocations[0].SurfDesc.height == pDstRc->aAllocations[0].SurfDesc.height
1951 && pSrcRc->RcDesc.enmFormat == pDstRc->RcDesc.enmFormat)
1952 {
1953 /* first check if we can do IDirect3DDevice9::UpdateTexture */
1954 if (pData->DstPoint.x == 0 && pData->DstPoint.y == 0
1955 && pData->SrcRect.left == 0 && pData->SrcRect.top == 0
1956 && pData->SrcRect.right - pData->SrcRect.left == pSrcRc->aAllocations[0].SurfDesc.width
1957 && pData->SrcRect.bottom - pData->SrcRect.top == pSrcRc->aAllocations[0].SurfDesc.height)
1958 {
1959 hr = pDevice->pDevice9If->UpdateTexture(pD3DIfSrcTex, pD3DIfDstTex);
1960 Assert(hr == S_OK);
1961 }
1962 else
1963 {
1964 AssertBreakpoint();
1965 /* @todo: impl */
1966 }
1967 }
1968 else
1969 {
1970 AssertBreakpoint();
1971 /* @todo: impl */
1972 }
1973
1974 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1975 return hr;
1976}
1977
1978static HRESULT APIENTRY vboxWddmDDevStateSet(HANDLE hDevice, D3DDDIARG_STATESET* pData)
1979{
1980 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1981 AssertBreakpoint();
1982 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1983 return E_FAIL;
1984}
1985static HRESULT APIENTRY vboxWddmDDevSetPriority(HANDLE hDevice, CONST D3DDDIARG_SETPRIORITY* pData)
1986{
1987 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1988 AssertBreakpoint();
1989 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1990 return E_FAIL;
1991}
1992AssertCompile(sizeof (RECT) == sizeof (D3DRECT));
1993AssertCompile(RT_SIZEOFMEMB(RECT, left) == RT_SIZEOFMEMB(D3DRECT, x1));
1994AssertCompile(RT_SIZEOFMEMB(RECT, right) == RT_SIZEOFMEMB(D3DRECT, x2));
1995AssertCompile(RT_SIZEOFMEMB(RECT, top) == RT_SIZEOFMEMB(D3DRECT, y1));
1996AssertCompile(RT_SIZEOFMEMB(RECT, bottom) == RT_SIZEOFMEMB(D3DRECT, y2));
1997AssertCompile(RT_OFFSETOF(RECT, left) == RT_OFFSETOF(D3DRECT, x1));
1998AssertCompile(RT_OFFSETOF(RECT, right) == RT_OFFSETOF(D3DRECT, x2));
1999AssertCompile(RT_OFFSETOF(RECT, top) == RT_OFFSETOF(D3DRECT, y1));
2000AssertCompile(RT_OFFSETOF(RECT, bottom) == RT_OFFSETOF(D3DRECT, y2));
2001
2002static HRESULT APIENTRY vboxWddmDDevClear(HANDLE hDevice, CONST D3DDDIARG_CLEAR* pData, UINT NumRect, CONST RECT* pRect)
2003{
2004 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2005 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2006 Assert(pDevice);
2007 Assert(pDevice->pDevice9If);
2008 HRESULT hr = pDevice->pDevice9If->Clear(NumRect, (D3DRECT*)pRect /* see AssertCompile above */,
2009 pData->Flags,
2010 pData->FillColor,
2011 pData->FillDepth,
2012 pData->FillStencil);
2013 Assert(hr == S_OK);
2014 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2015 return hr;
2016}
2017static HRESULT APIENTRY vboxWddmDDevUpdatePalette(HANDLE hDevice, CONST D3DDDIARG_UPDATEPALETTE* pData, CONST PALETTEENTRY* pPaletteData)
2018{
2019 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2020 AssertBreakpoint();
2021 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2022 return E_FAIL;
2023}
2024
2025static HRESULT APIENTRY vboxWddmDDevSetPalette(HANDLE hDevice, CONST D3DDDIARG_SETPALETTE* pData)
2026{
2027 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2028 AssertBreakpoint();
2029 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2030 return E_FAIL;
2031}
2032
2033static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONST* pData , CONST VOID* pRegisters)
2034{
2035 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2036 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2037 Assert(pDevice);
2038 Assert(pDevice->pDevice9If);
2039 HRESULT hr = pDevice->pDevice9If->SetVertexShaderConstantF(
2040 pData->Register,
2041 (CONST float*)pRegisters,
2042 pData->Count);
2043 Assert(hr == S_OK);
2044 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2045 return hr;
2046}
2047static HRESULT APIENTRY vboxWddmDDevMultiplyTransform(HANDLE hDevice, CONST D3DDDIARG_MULTIPLYTRANSFORM* pData)
2048{
2049 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2050 AssertBreakpoint();
2051 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2052 return E_FAIL;
2053}
2054static HRESULT APIENTRY vboxWddmDDevSetTransform(HANDLE hDevice, CONST D3DDDIARG_SETTRANSFORM* pData)
2055{
2056 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2057 AssertBreakpoint();
2058 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2059 return E_FAIL;
2060}
2061static HRESULT APIENTRY vboxWddmDDevSetViewport(HANDLE hDevice, CONST D3DDDIARG_VIEWPORTINFO* pData)
2062{
2063 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2064 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2065 Assert(pDevice);
2066 Assert(pDevice->pDevice9If);
2067 pDevice->ViewPort.X = pData->X;
2068 pDevice->ViewPort.Y = pData->Y;
2069 pDevice->ViewPort.Width = pData->Width;
2070 pDevice->ViewPort.Height = pData->Height;
2071 HRESULT hr = pDevice->pDevice9If->SetViewport(&pDevice->ViewPort);
2072 Assert(hr == S_OK);
2073 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2074 return hr;
2075}
2076static HRESULT APIENTRY vboxWddmDDevSetZRange(HANDLE hDevice, CONST D3DDDIARG_ZRANGE* pData)
2077{
2078 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2079 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2080 Assert(pDevice);
2081 Assert(pDevice->pDevice9If);
2082 pDevice->ViewPort.MinZ = pData->MinZ;
2083 pDevice->ViewPort.MaxZ = pData->MaxZ;
2084 HRESULT hr = pDevice->pDevice9If->SetViewport(&pDevice->ViewPort);
2085 Assert(hr == S_OK);
2086 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2087 return hr;
2088}
2089static HRESULT APIENTRY vboxWddmDDevSetMaterial(HANDLE hDevice, CONST D3DDDIARG_SETMATERIAL* pData)
2090{
2091 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2092 AssertBreakpoint();
2093 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2094 return E_FAIL;
2095}
2096static HRESULT APIENTRY vboxWddmDDevSetLight(HANDLE hDevice, CONST D3DDDIARG_SETLIGHT* pData, CONST D3DDDI_LIGHT* pLightProperties)
2097{
2098 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2099 AssertBreakpoint();
2100 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2101 return E_FAIL;
2102}
2103static HRESULT APIENTRY vboxWddmDDevCreateLight(HANDLE hDevice, CONST D3DDDIARG_CREATELIGHT* pData)
2104{
2105 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2106 AssertBreakpoint();
2107 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2108 return E_FAIL;
2109}
2110static HRESULT APIENTRY vboxWddmDDevDestroyLight(HANDLE hDevice, CONST D3DDDIARG_DESTROYLIGHT* pData)
2111{
2112 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2113 AssertBreakpoint();
2114 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2115 return E_FAIL;
2116}
2117static HRESULT APIENTRY vboxWddmDDevSetClipPlane(HANDLE hDevice, CONST D3DDDIARG_SETCLIPPLANE* pData)
2118{
2119 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2120 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2121 Assert(pDevice);
2122 Assert(pDevice->pDevice9If);
2123 HRESULT hr = pDevice->pDevice9If->SetClipPlane(pData->Index, pData->Plane);
2124 Assert(hr == S_OK);
2125 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2126 return hr;
2127}
2128
2129static HRESULT APIENTRY vboxWddmDDevGetInfo(HANDLE hDevice, UINT DevInfoID, VOID* pDevInfoStruct, UINT DevInfoSize)
2130{
2131 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2132 AssertBreakpoint();
2133 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2134 return E_NOTIMPL;
2135}
2136
2137static HRESULT APIENTRY vboxWddmDDevLock(HANDLE hDevice, D3DDDIARG_LOCK* pData)
2138{
2139 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2140 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2141 PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
2142 Assert(pData->SubResourceIndex < pRc->cAllocations);
2143 if (pData->SubResourceIndex >= pRc->cAllocations)
2144 return E_INVALIDARG;
2145
2146 HRESULT hr = S_OK;
2147
2148 if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
2149 {
2150 if (pRc->RcDesc.fFlags.Texture)
2151 {
2152 PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
2153 Assert(pData->SubResourceIndex < pRc->cAllocations);
2154 PVBOXWDDMDISP_ALLOCATION pLockAlloc = &pRc->aAllocations[pData->SubResourceIndex];
2155 IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pTexAlloc->pD3DIf;
2156 Assert(pD3DIfTex);
2157 RECT *pRect = NULL;
2158 bool bNeedResynch = false;
2159 Assert(!pData->Flags.RangeValid);
2160 Assert(!pData->Flags.BoxValid);
2161 if (pData->Flags.AreaValid)
2162 {
2163 pRect = &pData->Area;
2164 }
2165
2166 /* else - we lock the entire texture, pRect == NULL */
2167
2168// Assert(!pLockAlloc->LockInfo.cLocks);
2169 if (!pLockAlloc->LockInfo.cLocks)
2170 {
2171 hr = pD3DIfTex->LockRect(pData->SubResourceIndex,
2172 &pLockAlloc->LockInfo.LockedRect,
2173 pRect,
2174 vboxDDI2D3DLockFlags(pData->Flags));
2175 Assert(hr == S_OK);
2176 if (hr == S_OK)
2177 {
2178
2179// Assert(pLockAlloc->LockInfo.fFlags.Value == 0);
2180 pLockAlloc->LockInfo.fFlags = pData->Flags;
2181 if (pRect)
2182 {
2183 pLockAlloc->LockInfo.Area = *pRect;
2184 Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 1);
2185// pLockAlloc->LockInfo.fFlags.AreaValid = 1;
2186 }
2187 else
2188 {
2189 Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 0);
2190// pLockAlloc->LockInfo.fFlags.AreaValid = 0;
2191 }
2192
2193 bNeedResynch = !pData->Flags.Discard;
2194 }
2195 }
2196 else
2197 {
2198// Assert(pLockAlloc->LockInfo.fFlags.Value == pData->Flags.Value);
2199// if (pLockAlloc->LockInfo.fFlags.Value != pData->Flags.Value)
2200// {
2201// }
2202 Assert(pLockAlloc->LockInfo.fFlags.AreaValid == pData->Flags.AreaValid);
2203 if (pLockAlloc->LockInfo.fFlags.AreaValid && pData->Flags.AreaValid)
2204 {
2205 Assert(pLockAlloc->LockInfo.Area.left == pData->Area.left);
2206 Assert(pLockAlloc->LockInfo.Area.top == pData->Area.top);
2207 Assert(pLockAlloc->LockInfo.Area.right == pData->Area.right);
2208 Assert(pLockAlloc->LockInfo.Area.bottom == pData->Area.bottom);
2209 }
2210 Assert(pLockAlloc->LockInfo.LockedRect.pBits);
2211
2212 bNeedResynch = pLockAlloc->LockInfo.fFlags.Discard && !pData->Flags.Discard;
2213
2214 Assert(!bNeedResynch);
2215
2216 if (/*(pLockAlloc->LockInfo.fFlags.Discard && !pData->Flags.Discard)
2217 || */
2218 (pLockAlloc->LockInfo.fFlags.ReadOnly && !pData->Flags.ReadOnly))
2219 {
2220 hr = pD3DIfTex->UnlockRect(pData->SubResourceIndex);
2221 Assert(hr == S_OK);
2222 if (hr == S_OK)
2223 {
2224 hr = pD3DIfTex->LockRect(pData->SubResourceIndex,
2225 &pLockAlloc->LockInfo.LockedRect,
2226 pRect,
2227 vboxDDI2D3DLockFlags(pData->Flags));
2228 Assert(hr == S_OK);
2229 pLockAlloc->LockInfo.fFlags.ReadOnly = 0;
2230 }
2231 }
2232 }
2233
2234 if (hr == S_OK)
2235 {
2236 ++pLockAlloc->LockInfo.cLocks;
2237
2238 if (!pData->Flags.NotifyOnly)
2239 {
2240 pData->pSurfData = pLockAlloc->LockInfo.LockedRect.pBits;
2241 pData->Pitch = pLockAlloc->LockInfo.LockedRect.Pitch;
2242 pData->SlicePitch = 0;
2243 Assert(pLockAlloc->SurfDesc.slicePitch == 0);
2244 Assert(!pLockAlloc->pvMem);
2245 }
2246 else
2247 {
2248 Assert(pLockAlloc->pvMem);
2249 Assert(pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
2250
2251 if (bNeedResynch)
2252 vboxWddmLockUnlockMemSynch(pLockAlloc, &pLockAlloc->LockInfo.LockedRect, pRect, false /*bool bToLockInfo*/);
2253 }
2254 }
2255 }
2256 else if (pRc->RcDesc.fFlags.VertexBuffer)
2257 {
2258 Assert(pData->SubResourceIndex < pRc->cAllocations);
2259 PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
2260 IDirect3DVertexBuffer9 *pD3D9VBuf = (IDirect3DVertexBuffer9*)pAlloc->pD3DIf;
2261 BOOL bLocked = false;
2262 Assert(pD3D9VBuf);
2263 Assert(!pData->Flags.AreaValid);
2264 Assert(!pData->Flags.BoxValid);
2265 D3DDDIRANGE *pRange = NULL;
2266 if (pData->Flags.RangeValid)
2267 {
2268 pRange = &pData->Range;
2269 }
2270
2271 /* else - we lock the entire vertex buffer, pRect == NULL */
2272
2273 Assert(!pAlloc->LockInfo.cLocks);
2274 if (!pAlloc->LockInfo.cLocks)
2275 {
2276 if (!pData->Flags.MightDrawFromLocked || (!pData->Flags.Discard && !pData->Flags.NoOverwrite))
2277 {
2278 hr = pD3D9VBuf->Lock(pRange ? pRange->Offset : 0,
2279 pRange ? pRange->Size : 0,
2280 &pAlloc->LockInfo.LockedRect.pBits,
2281 vboxDDI2D3DLockFlags(pData->Flags));
2282 bLocked = true;
2283 }
2284
2285 Assert(hr == S_OK);
2286 if (hr == S_OK)
2287 {
2288 pAlloc->LockInfo.LockedRect.Pitch = pAlloc->SurfDesc.width;
2289// Assert(pLockAlloc->LockInfo.fFlags.Value == 0);
2290 pAlloc->LockInfo.fFlags = pData->Flags;
2291 if (pRange)
2292 {
2293 pAlloc->LockInfo.Range = *pRange;
2294 Assert(pAlloc->LockInfo.fFlags.RangeValid == 1);
2295// pAlloc->LockInfo.fFlags.RangeValid = 1;
2296 }
2297 else
2298 {
2299 Assert(pAlloc->LockInfo.fFlags.RangeValid == 0);
2300// pAlloc->LockInfo.fFlags.RangeValid = 0;
2301 }
2302 }
2303 }
2304 else
2305 {
2306// Assert(pAlloc->LockInfo.fFlags.Value == pData->Flags.Value);
2307// if (pAlloc->LockInfo.fFlags.Value != pData->Flags.Value)
2308// {
2309// }
2310 Assert(pAlloc->LockInfo.fFlags.RangeValid == pData->Flags.RangeValid);
2311 if (pAlloc->LockInfo.fFlags.RangeValid && pData->Flags.RangeValid)
2312 {
2313 Assert(pAlloc->LockInfo.Range.Offset == pData->Range.Offset);
2314 Assert(pAlloc->LockInfo.Range.Size == pData->Range.Size);
2315 }
2316 Assert(pAlloc->LockInfo.LockedRect.pBits);
2317 }
2318
2319 if (hr == S_OK)
2320 {
2321 ++pAlloc->LockInfo.cLocks;
2322
2323 if (!pData->Flags.NotifyOnly)
2324 {
2325 pData->pSurfData = pAlloc->LockInfo.LockedRect.pBits;
2326 pData->Pitch = pAlloc->LockInfo.LockedRect.Pitch;
2327 pData->SlicePitch = 0;
2328 Assert(pAlloc->SurfDesc.slicePitch == 0);
2329 Assert(!pAlloc->pvMem);
2330 }
2331 else
2332 {
2333 Assert(pAlloc->pvMem);
2334 Assert(pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
2335 if (bLocked && !pData->Flags.Discard)
2336 {
2337 RECT r, *pr;
2338 if (pRange)
2339 {
2340 r.top = 0;
2341 r.left = pRange->Offset;
2342 r.bottom = 1;
2343 r.right = pRange->Offset + pRange->Size;
2344 pr = &r;
2345 }
2346 else
2347 pr = NULL;
2348 vboxWddmLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect, pr, false /*bool bToLockInfo*/);
2349 }
2350 }
2351 }
2352 }
2353 else
2354 {
2355 AssertBreakpoint();
2356 }
2357 }
2358 else
2359 {
2360 PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
2361 D3DDDICB_LOCK LockData;
2362 LockData.hAllocation = pAlloc->hAllocation;
2363 LockData.PrivateDriverData = 0;
2364 LockData.NumPages = 0;
2365 LockData.pPages = NULL;
2366 LockData.pData = NULL; /* out */
2367 LockData.Flags.Value = 0;
2368 LockData.Flags.Discard = pData->Flags.Discard;
2369 LockData.Flags.DonotWait = pData->Flags.DoNotWait;
2370
2371
2372 hr = pDevice->RtCallbacks.pfnLockCb(pDevice->hDevice, &LockData);
2373 Assert(hr == S_OK || (hr == D3DERR_WASSTILLDRAWING && pData->Flags.DoNotWait));
2374 if (hr == S_OK)
2375 {
2376 Assert(!pAlloc->LockInfo.cLocks);
2377
2378 uintptr_t offset;
2379 if (pData->Flags.AreaValid)
2380 {
2381 offset = pAlloc->SurfDesc.pitch * pData->Area.top +
2382 ((pAlloc->SurfDesc.bpp * pData->Area.left) >> 3);
2383 }
2384 else if (pData->Flags.RangeValid)
2385 {
2386 offset = pData->Range.Offset;
2387 }
2388 else if (pData->Flags.BoxValid)
2389 {
2390 vboxVDbgPrintF((__FUNCTION__": Implement Box area"));
2391 AssertBreakpoint();
2392 }
2393 else
2394 {
2395 offset = 0;
2396 }
2397
2398 if (!pData->Flags.ReadOnly)
2399 {
2400 if (pData->Flags.AreaValid)
2401 vboxWddmDirtyRegionAddRect(&pAlloc->DirtyRegion, &pData->Area);
2402 else
2403 {
2404 Assert(!pData->Flags.RangeValid);
2405 Assert(!pData->Flags.BoxValid);
2406 vboxWddmDirtyRegionAddRect(&pAlloc->DirtyRegion, NULL); /* <- NULL means the entire surface */
2407 }
2408 }
2409
2410 if (pData->Flags.Discard)
2411 {
2412 /* check if the surface was renamed */
2413 if (LockData.hAllocation)
2414 pAlloc->hAllocation = LockData.hAllocation;
2415 }
2416
2417 pData->pSurfData = ((uint8_t*)LockData.pData) + offset;
2418 pData->Pitch = pAlloc->SurfDesc.pitch;
2419 pData->SlicePitch = pAlloc->SurfDesc.slicePitch;
2420
2421 Assert(hr == S_OK);
2422 ++pAlloc->LockInfo.cLocks;
2423 }
2424 }
2425
2426 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(%d)\n", hDevice, hr));
2427 return hr;
2428}
2429static HRESULT APIENTRY vboxWddmDDevUnlock(HANDLE hDevice, CONST D3DDDIARG_UNLOCK* pData)
2430{
2431 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2432 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2433 PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
2434 HRESULT hr = S_OK;
2435
2436 Assert(pData->SubResourceIndex < pRc->cAllocations);
2437 if (pData->SubResourceIndex >= pRc->cAllocations)
2438 return E_INVALIDARG;
2439
2440 if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
2441 {
2442 if (pRc->RcDesc.fFlags.Texture)
2443 {
2444 Assert(pData->SubResourceIndex < pRc->cAllocations);
2445 PVBOXWDDMDISP_ALLOCATION pLockAlloc = &pRc->aAllocations[pData->SubResourceIndex];
2446
2447 --pLockAlloc->LockInfo.cLocks;
2448 Assert(pLockAlloc->LockInfo.cLocks < UINT32_MAX);
2449// pLockAlloc->LockInfo.cLocks = 0;
2450 if (!pLockAlloc->LockInfo.cLocks)
2451 {
2452 PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
2453// Assert(!pLockAlloc->LockInfo.cLocks);
2454 IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pTexAlloc->pD3DIf;
2455 Assert(pD3DIfTex);
2456 /* this is a sysmem texture, update */
2457 if (pLockAlloc->pvMem && !pLockAlloc->LockInfo.fFlags.ReadOnly)
2458 {
2459 vboxWddmLockUnlockMemSynch(pLockAlloc, &pLockAlloc->LockInfo.LockedRect,
2460 pLockAlloc->LockInfo.fFlags.AreaValid ? &pLockAlloc->LockInfo.Area : NULL,
2461 true /*bool bToLockInfo*/);
2462 }
2463 hr = pD3DIfTex->UnlockRect(pData->SubResourceIndex);
2464 Assert(hr == S_OK);
2465 }
2466 else
2467 {
2468 Assert(pLockAlloc->LockInfo.cLocks < UINT32_MAX);
2469 }
2470 }
2471 else if (pRc->RcDesc.fFlags.VertexBuffer)
2472 {
2473 Assert(pData->SubResourceIndex < pRc->cAllocations);
2474 PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
2475
2476 --pAlloc->LockInfo.cLocks;
2477 Assert(pAlloc->LockInfo.cLocks < UINT32_MAX);
2478 if (!pAlloc->LockInfo.cLocks
2479 && (!pAlloc->LockInfo.fFlags.MightDrawFromLocked
2480 || (!pAlloc->LockInfo.fFlags.Discard && !pAlloc->LockInfo.fFlags.NoOverwrite)))
2481 {
2482// Assert(!pAlloc->LockInfo.cLocks);
2483 IDirect3DVertexBuffer9 *pD3D9VBuf = (IDirect3DVertexBuffer9*)pAlloc->pD3DIf;
2484 Assert(pD3D9VBuf);
2485 /* this is a sysmem texture, update */
2486 if (pAlloc->pvMem && !pAlloc->LockInfo.fFlags.ReadOnly)
2487 {
2488 RECT r, *pr;
2489 if (pAlloc->LockInfo.fFlags.RangeValid)
2490 {
2491 r.top = 0;
2492 r.left = pAlloc->LockInfo.Range.Offset;
2493 r.bottom = 1;
2494 r.right = pAlloc->LockInfo.Range.Offset + pAlloc->LockInfo.Range.Size;
2495 pr = &r;
2496 }
2497 else
2498 pr = NULL;
2499 vboxWddmLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect,
2500 pr,
2501 true /*bool bToLockInfo*/);
2502 }
2503 hr = pD3D9VBuf->Unlock();
2504 Assert(hr == S_OK);
2505 }
2506 else
2507 {
2508 Assert(pAlloc->LockInfo.cLocks < UINT32_MAX);
2509 }
2510 }
2511 else
2512 {
2513 AssertBreakpoint();
2514 }
2515 }
2516 else
2517 {
2518 struct
2519 {
2520 D3DDDICB_UNLOCK Unlock;
2521 D3DKMT_HANDLE hAllocation;
2522 } UnlockData;
2523
2524 PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
2525
2526 UnlockData.Unlock.NumAllocations = 1;
2527 UnlockData.Unlock.phAllocations = &UnlockData.hAllocation;
2528 UnlockData.hAllocation = pAlloc->hAllocation;
2529
2530 hr = pDevice->RtCallbacks.pfnUnlockCb(pDevice->hDevice, &UnlockData.Unlock);
2531 Assert(hr == S_OK);
2532 if (hr == S_OK)
2533 {
2534 Assert(pAlloc->LockInfo.cLocks);
2535 --pAlloc->LockInfo.cLocks;
2536 Assert(pAlloc->LockInfo.cLocks < UINT32_MAX);
2537 }
2538 }
2539
2540 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2541 return hr;
2542}
2543static HRESULT APIENTRY vboxWddmDDevLockAsync(HANDLE hDevice, D3DDDIARG_LOCKASYNC* pData)
2544{
2545 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2546 AssertBreakpoint();
2547 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2548 return E_FAIL;
2549}
2550static HRESULT APIENTRY vboxWddmDDevUnlockAsync(HANDLE hDevice, CONST D3DDDIARG_UNLOCKASYNC* pData)
2551{
2552 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2553 AssertBreakpoint();
2554 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2555 return E_FAIL;
2556}
2557static HRESULT APIENTRY vboxWddmDDevRename(HANDLE hDevice, CONST D3DDDIARG_RENAME* pData)
2558{
2559 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2560 AssertBreakpoint();
2561 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2562 return E_FAIL;
2563}
2564
2565static HRESULT APIENTRY vboxWddmDDevCreateResource(HANDLE hDevice, D3DDDIARG_CREATERESOURCE* pResource)
2566{
2567 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2568 HRESULT hr = S_OK;
2569 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2570 Assert(pDevice);
2571 Assert(pResource);
2572 PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter;
2573
2574 if (VBOXDISPMODE_IS_3D(pAdapter))
2575 {
2576 PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(pResource->SurfCount);
2577 Assert(pRc);
2578 if (pRc)
2579 {
2580 pRc->hResource = pResource->hResource;
2581 pRc->pDevice = pDevice;
2582 pRc->fFlags = VBOXWDDM_RESOURCE_F_TYPE_GENERIC;
2583 vboxResourcePopulateRcDesc(&pRc->RcDesc, pResource);
2584 pRc->cAllocations = pResource->SurfCount;
2585 for (UINT i = 0; i < pResource->SurfCount; ++i)
2586 {
2587 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2588 CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
2589 pAllocation->hAllocation = NULL;
2590 pAllocation->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC;
2591 pAllocation->pvMem = (void*)pSurf->pSysMem;
2592 pAllocation->SurfDesc.pitch = pSurf->SysMemPitch;
2593 pAllocation->SurfDesc.slicePitch = pSurf->SysMemSlicePitch;
2594 pAllocation->SurfDesc.depth = pSurf->Depth;
2595 pAllocation->SurfDesc.width = pSurf->Width;
2596 pAllocation->SurfDesc.height = pSurf->Height;
2597 pAllocation->SurfDesc.format = pResource->Format;
2598 }
2599
2600 if (pResource->Flags.RenderTarget)
2601 {
2602 HWND hWnd = NULL;
2603 Assert(pResource->SurfCount);
2604 Assert(!pDevice->pDevice9If);
2605 Assert(!pDevice->hWnd);
2606 hr = VBoxDispWndCreate(pAdapter, pResource->pSurfList[0].Width, pResource->pSurfList[0].Height, &hWnd);
2607 Assert(hr == S_OK);
2608 if (hr == S_OK)
2609 {
2610 DWORD fFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;
2611 if (pDevice->fFlags.AllowMultithreading)
2612 fFlags |= D3DCREATE_MULTITHREADED;
2613
2614 IDirect3DDevice9 *pDevice9If = NULL;
2615 D3DPRESENT_PARAMETERS params;
2616 memset(&params, 0, sizeof (params));
2617 // params.BackBufferWidth = 0;
2618 // params.BackBufferHeight = 0;
2619 params.BackBufferFormat = vboxDDI2D3DFormat(pResource->Format);
2620 Assert(pResource->SurfCount);
2621 params.BackBufferCount = pResource->SurfCount - 1;
2622 params.MultiSampleType = vboxDDI2D3DMultiSampleType(pResource->MultisampleType);
2623 if (pResource->Flags.DiscardRenderTarget)
2624 params.SwapEffect = D3DSWAPEFFECT_DISCARD;
2625 params.hDeviceWindow = hWnd;
2626 /* @todo: it seems there should be a way to detect this correctly since
2627 * our vboxWddmDDevSetDisplayMode will be called in case we are using full-screen */
2628 params.Windowed = TRUE;
2629 // params.EnableAutoDepthStencil = FALSE;
2630 // params.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
2631 // params.Flags;
2632 // params.FullScreen_RefreshRateInHz;
2633 // params.FullScreen_PresentationInterval;
2634 hr = pAdapter->pD3D9If->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, fFlags, &params, &pDevice9If);
2635 Assert(hr == S_OK);
2636 if (hr == S_OK)
2637 {
2638 pDevice->pDevice9If = pDevice9If;
2639 pDevice->hWnd = hWnd;
2640 for (UINT i = 0; i < pResource->SurfCount; ++i)
2641 {
2642 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2643
2644 IDirect3DSurface9* pD3D9Surf;
2645 hr = pDevice9If->CreateRenderTarget(pAllocation->SurfDesc.width,
2646 pAllocation->SurfDesc.height,
2647 vboxDDI2D3DFormat(pResource->Format),
2648 vboxDDI2D3DMultiSampleType(pResource->MultisampleType),
2649 pResource->MultisampleQuality,
2650 !pResource->Flags.NotLockable /* BOOL Lockable */,
2651 &pD3D9Surf,
2652 NULL /* HANDLE* pSharedHandle */
2653 );
2654 Assert(hr == S_OK);
2655 if (hr == S_OK)
2656 {
2657 Assert(pD3D9Surf);
2658 if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
2659 {
2660 Assert(pAllocation->pvMem);
2661 D3DLOCKED_RECT lockInfo;
2662 hr = pD3D9Surf->LockRect(&lockInfo, NULL, D3DLOCK_DISCARD);
2663 Assert(hr == S_OK);
2664 if (hr == S_OK)
2665 {
2666 vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
2667 HRESULT tmpHr = pD3D9Surf->UnlockRect();
2668 Assert(tmpHr == S_OK);
2669 }
2670 }
2671 else
2672 {
2673 Assert(!pAllocation->pvMem);
2674 }
2675 pAllocation->pD3DIf = pD3D9Surf;
2676 }
2677 else
2678 {
2679 for (UINT j = 0; j < i; ++j)
2680 {
2681 pRc->aAllocations[j].pD3DIf->Release();
2682 }
2683 break;
2684 }
2685 }
2686 }
2687
2688 if (hr != S_OK)
2689 {
2690 VBoxDispWndDestroy(pAdapter, hWnd);
2691 }
2692 }
2693 }
2694 else if (pResource->Flags.ZBuffer)
2695 {
2696 Assert(pDevice->pDevice9If);
2697 for (UINT i = 0; i < pResource->SurfCount; ++i)
2698 {
2699 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2700 IDirect3DSurface9 *pD3D9Surf;
2701 hr = pDevice->pDevice9If->CreateDepthStencilSurface(pAllocation->SurfDesc.width,
2702 pAllocation->SurfDesc.height,
2703 vboxDDI2D3DFormat(pResource->Format),
2704 vboxDDI2D3DMultiSampleType(pResource->MultisampleType),
2705 pResource->MultisampleQuality,
2706 TRUE /* @todo: BOOL Discard */,
2707 &pD3D9Surf,
2708 NULL /*HANDLE* pSharedHandle*/);
2709 Assert(hr == S_OK);
2710 if (hr == S_OK)
2711 {
2712 Assert(pD3D9Surf);
2713 if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
2714 {
2715 Assert(pAllocation->pvMem);
2716 D3DLOCKED_RECT lockInfo;
2717 hr = pD3D9Surf->LockRect(&lockInfo, NULL, D3DLOCK_DISCARD);
2718 Assert(hr == S_OK);
2719 if (hr == S_OK)
2720 {
2721 vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
2722 HRESULT tmpHr = pD3D9Surf->UnlockRect();
2723 Assert(tmpHr == S_OK);
2724 }
2725 }
2726 else
2727 {
2728 Assert(!pAllocation->pvMem);
2729 }
2730 pAllocation->pD3DIf = pD3D9Surf;
2731 }
2732 else
2733 {
2734 for (UINT j = 0; j < i; ++j)
2735 {
2736 pRc->aAllocations[j].pD3DIf->Release();
2737 }
2738 break;
2739 }
2740 }
2741 }
2742 else if (pResource->Flags.VertexBuffer)
2743 {
2744 Assert(pDevice->pDevice9If);
2745 for (UINT i = 0; i < pResource->SurfCount; ++i)
2746 {
2747 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2748 IDirect3DVertexBuffer9 *pD3D9VBuf;
2749 hr = pDevice->pDevice9If->CreateVertexBuffer(pAllocation->SurfDesc.width,
2750 vboxDDI2D3DUsage(pResource->Flags),
2751 pResource->Fvf,
2752 vboxDDI2D3DPool(pResource->Pool),
2753 &pD3D9VBuf,
2754 NULL /*HANDLE* pSharedHandle*/);
2755 Assert(hr == S_OK);
2756 if (hr == S_OK)
2757 {
2758 Assert(pD3D9VBuf);
2759 if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
2760 {
2761 Assert(pAllocation->pvMem);
2762 D3DLOCKED_RECT lockInfo;
2763 hr = pD3D9VBuf->Lock(0, pAllocation->SurfDesc.width, &lockInfo.pBits, D3DLOCK_DISCARD);
2764 Assert(hr == S_OK);
2765 if (hr == S_OK)
2766 {
2767 lockInfo.Pitch = pAllocation->SurfDesc.pitch;
2768 vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
2769 HRESULT tmpHr = pD3D9VBuf->Unlock();
2770 Assert(tmpHr == S_OK);
2771 }
2772 }
2773 else
2774 {
2775 Assert(!pAllocation->pvMem);
2776 }
2777 pAllocation->pD3DIf = pD3D9VBuf;
2778 }
2779 else
2780 {
2781 for (UINT j = 0; j < i; ++j)
2782 {
2783 pRc->aAllocations[j].pD3DIf->Release();
2784 }
2785 break;
2786 }
2787 }
2788 }
2789 else if (pResource->Flags.IndexBuffer)
2790 {
2791 Assert(pDevice->pDevice9If);
2792 for (UINT i = 0; i < pResource->SurfCount; ++i)
2793 {
2794 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2795 CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
2796 IDirect3DIndexBuffer9 *pD3D9IBuf;
2797 hr = pDevice->pDevice9If->CreateIndexBuffer(pSurf->Width,
2798 vboxDDI2D3DUsage(pResource->Flags),
2799 vboxDDI2D3DFormat(pResource->Format),
2800 vboxDDI2D3DPool(pResource->Pool),
2801 &pD3D9IBuf,
2802 NULL /*HANDLE* pSharedHandle*/
2803 );
2804 Assert(hr == S_OK);
2805 if (hr == S_OK)
2806 {
2807 Assert(pD3D9IBuf);
2808 if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
2809 {
2810 Assert(pAllocation->pvMem);
2811 D3DLOCKED_RECT lockInfo;
2812 hr = pD3D9IBuf->Lock(0, pAllocation->SurfDesc.width, &lockInfo.pBits, D3DLOCK_DISCARD);
2813 Assert(hr == S_OK);
2814 if (hr == S_OK)
2815 {
2816 lockInfo.Pitch = pAllocation->SurfDesc.pitch;
2817 vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
2818 HRESULT tmpHr = pD3D9IBuf->Unlock();
2819 Assert(tmpHr == S_OK);
2820 }
2821 }
2822 else
2823 {
2824 Assert(!pAllocation->pvMem);
2825 }
2826 pAllocation->pD3DIf = pD3D9IBuf;
2827 }
2828 else
2829 {
2830 for (UINT j = 0; j < i; ++j)
2831 {
2832 pRc->aAllocations[j].pD3DIf->Release();
2833 }
2834 break;
2835 }
2836 }
2837 }
2838 else if (pResource->Flags.Texture)
2839 {
2840 Assert(pDevice->pDevice9If);
2841#ifdef DEBUG
2842 {
2843 uint32_t tstW = pResource->pSurfList[0].Width;
2844 uint32_t tstH = pResource->pSurfList[0].Height;
2845 for (UINT i = 1; i < pResource->SurfCount; ++i)
2846 {
2847 tstW /= 2;
2848 tstH /= 2;
2849 CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
2850 Assert(pSurf->Width == tstW);
2851 Assert(pSurf->Height == tstH);
2852 }
2853 }
2854#endif
2855
2856 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0];
2857 CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[0];
2858 IDirect3DTexture9 *pD3DIfTex;
2859 hr = pDevice->pDevice9If->CreateTexture(pSurf->Width,
2860 pSurf->Height,
2861 pResource->SurfCount,
2862 vboxDDI2D3DUsage(pResource->Flags),
2863 vboxDDI2D3DFormat(pResource->Format),
2864 vboxDDI2D3DPool(pResource->Pool),
2865 &pD3DIfTex,
2866 NULL /* HANDLE* pSharedHandle */
2867 );
2868 Assert(hr == S_OK);
2869 if (hr == S_OK)
2870 {
2871 Assert(pD3DIfTex);
2872 if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
2873 {
2874 for (UINT i = 0; i < pResource->SurfCount; ++i)
2875 {
2876 D3DLOCKED_RECT lockInfo;
2877 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2878 Assert(pAllocation->pvMem);
2879 hr = pD3DIfTex->LockRect(i, &lockInfo, NULL, D3DLOCK_DISCARD);
2880 Assert(hr == S_OK);
2881 if (hr == S_OK)
2882 {
2883 vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
2884 HRESULT tmpHr = pD3DIfTex->UnlockRect(i);
2885 Assert(tmpHr == S_OK);
2886 }
2887 else
2888 {
2889 pD3DIfTex->Release();
2890 break;
2891 }
2892 }
2893 }
2894 pAllocation->pD3DIf = pD3DIfTex;
2895 }
2896#ifdef DEBUG
2897 else
2898 {
2899 for (UINT i = 0; i < pResource->SurfCount; ++i)
2900 {
2901 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2902 Assert(!pAllocation->pvMem);
2903 }
2904 }
2905#endif
2906 }
2907 else
2908 {
2909 Assert(pDevice->pDevice9If);
2910 Assert(0);
2911 }
2912
2913 if (hr == S_OK)
2914 pResource->hResource = pRc;
2915 else
2916 vboxResourceFree(pRc);
2917 }
2918 else
2919 {
2920 hr = E_OUTOFMEMORY;
2921 }
2922
2923 }
2924 else
2925 {
2926 /* allocate buffer for D3DDDICB_ALLOCATE + D3DDDI_ALLOCATIONINFO * numAllocs + PVBOXWDDM_RCINFO with aAllocInfos[numAllocs] */
2927 uint32_t cbBuf = sizeof (D3DDDICB_ALLOCATE);
2928 uint32_t offDdiAllocInfos = (cbBuf + 7) & ~3;
2929 uint32_t cbDdiAllocInfos = sizeof (D3DDDI_ALLOCATIONINFO) * pResource->SurfCount;
2930 cbBuf = offDdiAllocInfos + cbDdiAllocInfos;
2931 uint32_t offRcInfo = (cbBuf + 7) & ~3;
2932 uint32_t cbRcInfo = sizeof (VBOXWDDM_RCINFO);
2933 cbBuf = offRcInfo + cbRcInfo;
2934 uint32_t offAllocInfos = (cbBuf + 7) & ~3;
2935 uint32_t cbAllocInfos = sizeof (VBOXWDDM_ALLOCINFO) * pResource->SurfCount;
2936 cbBuf = offAllocInfos + cbAllocInfos;
2937 uint8_t *pvBuf = (uint8_t*)RTMemAllocZ(cbBuf);
2938 if (pvBuf)
2939 {
2940 D3DDDICB_ALLOCATE *pAllocate = (D3DDDICB_ALLOCATE*)pvBuf;
2941 D3DDDI_ALLOCATIONINFO* pDdiAllocInfos = (D3DDDI_ALLOCATIONINFO*)(pvBuf + offDdiAllocInfos);
2942 PVBOXWDDM_RCINFO pRcInfo = (PVBOXWDDM_RCINFO)(pvBuf + offRcInfo);
2943 PVBOXWDDM_ALLOCINFO pAllocInfos = (PVBOXWDDM_ALLOCINFO)(pvBuf + offAllocInfos);
2944 pAllocate->pPrivateDriverData = pRcInfo;
2945 pAllocate->PrivateDriverDataSize = cbRcInfo;
2946 pAllocate->hResource = pResource->hResource;
2947 pAllocate->hKMResource = NULL;
2948 pAllocate->NumAllocations = pResource->SurfCount;
2949 pAllocate->pAllocationInfo = pDdiAllocInfos;
2950
2951 pRcInfo->fFlags = VBOXWDDM_RESOURCE_F_TYPE_GENERIC;
2952 pRcInfo->RcDesc.fFlags = pResource->Flags;
2953 pRcInfo->RcDesc.enmFormat = pResource->Format;
2954 pRcInfo->RcDesc.enmPool = pResource->Pool;
2955 pRcInfo->RcDesc.enmMultisampleType = pResource->MultisampleType;
2956 pRcInfo->RcDesc.MultisampleQuality = pResource->MultisampleQuality;
2957 pRcInfo->RcDesc.MipLevels = pResource->MipLevels;
2958 pRcInfo->RcDesc.Fvf = pResource->Fvf;
2959 pRcInfo->RcDesc.VidPnSourceId = pResource->VidPnSourceId;
2960 pRcInfo->RcDesc.RefreshRate = pResource->RefreshRate;
2961 pRcInfo->RcDesc.enmRotation = pResource->Rotation;
2962 pRcInfo->cAllocInfos = pResource->SurfCount;
2963
2964 for (UINT i = 0; i < pResource->SurfCount; ++i)
2965 {
2966 PVBOXWDDM_ALLOCINFO pAllocInfo = &pAllocInfos[i];
2967 D3DDDI_ALLOCATIONINFO* pDdiAllocInfo = &pDdiAllocInfos[i];
2968 CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
2969 pDdiAllocInfo->hAllocation = NULL;
2970 pDdiAllocInfo->pSystemMem = pSurf->pSysMem;
2971 Assert((!!(pSurf->pSysMem)) == (pResource->Pool == D3DDDIPOOL_SYSTEMMEM));
2972 pDdiAllocInfo->pPrivateDriverData = pAllocInfo;
2973 pDdiAllocInfo->PrivateDriverDataSize = sizeof (VBOXWDDM_ALLOCINFO);
2974 pDdiAllocInfo->VidPnSourceId = pResource->VidPnSourceId;
2975 pDdiAllocInfo->Flags.Value = 0;
2976 if (pResource->Flags.Primary)
2977 pDdiAllocInfo->Flags.Primary = 1;
2978
2979 pAllocInfo->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC;
2980 pAllocInfo->SurfDesc.width = pSurf->Width;
2981 pAllocInfo->SurfDesc.height = pSurf->Height;
2982 pAllocInfo->SurfDesc.format = pResource->Format;
2983 pAllocInfo->SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pResource->Format);
2984
2985 if (pSurf->SysMemPitch)
2986 {
2987 pAllocInfo->SurfDesc.pitch = pSurf->SysMemPitch;
2988#ifdef DEBUG
2989 UINT tst = vboxWddmCalcPitch(pSurf->Width, pAllocInfo->SurfDesc.bpp);
2990 Assert(tst == pSurf->SysMemPitch);
2991#endif
2992 }
2993 else
2994 pAllocInfo->SurfDesc.pitch = vboxWddmCalcPitch(pSurf->Width, pAllocInfo->SurfDesc.bpp);
2995
2996 pAllocInfo->SurfDesc.cbSize = pAllocInfo->SurfDesc.pitch * pAllocInfo->SurfDesc.height;
2997 pAllocInfo->SurfDesc.depth = pSurf->Depth;
2998 pAllocInfo->SurfDesc.slicePitch = pSurf->SysMemSlicePitch;
2999 pAllocInfo->SurfDesc.VidPnSourceId = pResource->VidPnSourceId;
3000 pAllocInfo->SurfDesc.RefreshRate = pResource->RefreshRate;
3001 }
3002
3003 hr = pDevice->RtCallbacks.pfnAllocateCb(pDevice->hDevice, pAllocate);
3004 Assert(hr == S_OK);
3005 if (hr == S_OK)
3006 {
3007 Assert(pAllocate->hKMResource);
3008 PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(pResource->SurfCount);
3009 Assert(pRc);
3010 if (pRc)
3011 {
3012 pRc->hResource = pResource->hResource;
3013 pRc->hKMResource = pAllocate->hKMResource;
3014 pRc->pDevice = pDevice;
3015 pRc->fFlags = pRcInfo->fFlags;
3016 pRc->RcDesc = pRcInfo->RcDesc;
3017 pRc->cAllocations = pRcInfo->cAllocInfos;
3018 for (UINT i = 0; i < pRcInfo->cAllocInfos; ++i)
3019 {
3020 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
3021 D3DDDI_ALLOCATIONINFO* pDdiAllocInfo = &pDdiAllocInfos[i];
3022 PVBOXWDDM_ALLOCINFO pAllocInfo = &pAllocInfos[i];
3023 CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
3024 pAllocation->hAllocation = pDdiAllocInfo->hAllocation;
3025 pAllocation->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC;
3026 pAllocation->pvMem = (void*)pSurf->pSysMem;
3027 pAllocation->SurfDesc = pAllocInfo->SurfDesc;
3028 }
3029
3030 pResource->hResource = pRc;
3031 // vboxResourceFree(pRc);
3032 }
3033 else
3034 {
3035 hr = E_OUTOFMEMORY;
3036 }
3037 }
3038
3039 RTMemFree(pvBuf);
3040 }
3041 else
3042 {
3043 hr = E_OUTOFMEMORY;
3044 }
3045 }
3046
3047 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3048 return hr;
3049}
3050
3051static HRESULT APIENTRY vboxWddmDDevDestroyResource(HANDLE hDevice, HANDLE hResource)
3052{
3053 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3054 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3055 PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter;
3056 PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)hResource;
3057
3058 HRESULT hr = S_OK;
3059
3060 Assert(pDevice);
3061 Assert(hResource);
3062
3063 if (VBOXDISPMODE_IS_3D(pAdapter))
3064 {
3065 if (pRc->RcDesc.fFlags.RenderTarget)
3066 {
3067 Assert(pDevice->hWnd);
3068 Assert(pDevice->pDevice9If);
3069 pDevice->pDevice9If->Release();
3070 HRESULT tmpHr = VBoxDispWndDestroy(pAdapter, pDevice->hWnd);
3071 Assert(tmpHr == S_OK);
3072 }
3073
3074 for (UINT i = 0; i < pRc->cAllocations; ++i)
3075 {
3076 PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];
3077 if (pAlloc->pD3DIf)
3078 pAlloc->pD3DIf->Release();
3079 }
3080 }
3081 else
3082 {
3083 if (!(pRc->fFlags & VBOXWDDM_RESOURCE_F_OPENNED))
3084 {
3085 D3DDDICB_DEALLOCATE Dealloc;
3086 Dealloc.hResource = pRc->hResource;
3087 Assert(pRc->hResource);
3088 /* according to the docs the below two are ignored in case we set the hResource */
3089 Dealloc.NumAllocations = 0;
3090 Dealloc.HandleList = NULL;
3091 hr = pDevice->RtCallbacks.pfnDeallocateCb(pDevice->hDevice, &Dealloc);
3092 Assert(hr == S_OK);
3093 }
3094 }
3095
3096 vboxResourceFree(pRc);
3097 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3098 return hr;
3099}
3100static HRESULT APIENTRY vboxWddmDDevSetDisplayMode(HANDLE hDevice, CONST D3DDDIARG_SETDISPLAYMODE* pData)
3101{
3102 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3103 AssertBreakpoint();
3104 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3105 return E_FAIL;
3106}
3107static HRESULT APIENTRY vboxWddmDDevPresent(HANDLE hDevice, CONST D3DDDIARG_PRESENT* pData)
3108{
3109 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3110 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3111 Assert(pDevice);
3112 Assert(pDevice->pDevice9If);
3113#if 0
3114 HRESULT hr = pDevice->pDevice9If->Present(NULL, /* CONST RECT * pSourceRect */
3115 NULL, /* CONST RECT * pDestRect */
3116 NULL, /* HWND hDestWindowOverride */
3117 NULL /*CONST RGNDATA * pDirtyRegion */
3118 );
3119 Assert(hr == S_OK);
3120#else
3121 HRESULT hr = S_OK;
3122#endif
3123 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3124 return hr;
3125}
3126static HRESULT APIENTRY vboxWddmDDevFlush(HANDLE hDevice)
3127{
3128 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3129 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3130 Assert(pDevice);
3131 HRESULT hr = S_OK;
3132 if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
3133 {
3134 Assert(pDevice->pDevice9If);
3135 hr = pDevice->pDevice9If->Present(NULL, /* CONST RECT * pSourceRect */
3136 NULL, /* CONST RECT * pDestRect */
3137 NULL, /* HWND hDestWindowOverride */
3138 NULL /*CONST RGNDATA * pDirtyRegion */
3139 );
3140 Assert(hr == S_OK);
3141 }
3142 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3143 return hr;
3144}
3145
3146AssertCompile(sizeof (D3DDDIVERTEXELEMENT) == sizeof (D3DVERTEXELEMENT9));
3147AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Stream) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Stream));
3148AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Offset) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Offset));
3149AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Type) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Type));
3150AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Method) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Method));
3151AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Usage) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Usage));
3152AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, UsageIndex) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, UsageIndex));
3153
3154AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Stream) == RT_OFFSETOF(D3DVERTEXELEMENT9, Stream));
3155AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Offset) == RT_OFFSETOF(D3DVERTEXELEMENT9, Offset));
3156AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Type) == RT_OFFSETOF(D3DVERTEXELEMENT9, Type));
3157AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Method) == RT_OFFSETOF(D3DVERTEXELEMENT9, Method));
3158AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Usage) == RT_OFFSETOF(D3DVERTEXELEMENT9, Usage));
3159AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, UsageIndex) == RT_OFFSETOF(D3DVERTEXELEMENT9, UsageIndex));
3160
3161static HRESULT APIENTRY vboxWddmDDevCreateVertexShaderDecl(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERDECL* pData, CONST D3DDDIVERTEXELEMENT* pVertexElements)
3162{
3163 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3164 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3165 Assert(pDevice);
3166 Assert(pDevice->pDevice9If);
3167 IDirect3DVertexDeclaration9 *pDecl;
3168 static D3DVERTEXELEMENT9 DeclEnd = D3DDECL_END();
3169 Assert(!memcmp(&DeclEnd, &pVertexElements[pData->NumVertexElements], sizeof (DeclEnd)));
3170 HRESULT hr = pDevice->pDevice9If->CreateVertexDeclaration(
3171 (CONST D3DVERTEXELEMENT9*)pVertexElements,
3172 &pDecl
3173 );
3174 Assert(hr == S_OK);
3175 if (hr == S_OK)
3176 {
3177 Assert(pDecl);
3178 pData->ShaderHandle = pDecl;
3179 }
3180 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3181 return hr;
3182}
3183static HRESULT APIENTRY vboxWddmDDevSetVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
3184{
3185 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3186 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3187 Assert(pDevice);
3188 Assert(pDevice->pDevice9If);
3189 IDirect3DVertexDeclaration9 *pDecl = (IDirect3DVertexDeclaration9*)hShaderHandle;
3190 Assert(pDecl);
3191 HRESULT hr = pDevice->pDevice9If->SetVertexDeclaration(pDecl);
3192 Assert(hr == S_OK);
3193 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3194 return hr;
3195}
3196static HRESULT APIENTRY vboxWddmDDevDeleteVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
3197{
3198 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3199 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3200 Assert(pDevice);
3201 Assert(pDevice->pDevice9If);
3202 IDirect3DVertexDeclaration9 *pDecl = (IDirect3DVertexDeclaration9*)hShaderHandle;
3203 HRESULT hr = pDecl->Release();
3204 Assert(hr == S_OK);
3205 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3206 return hr;
3207}
3208static HRESULT APIENTRY vboxWddmDDevCreateVertexShaderFunc(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERFUNC* pData, CONST UINT* pCode)
3209{
3210 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3211 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3212 Assert(pDevice);
3213 Assert(pDevice->pDevice9If);
3214 IDirect3DVertexShader9 *pShader;
3215 Assert(*((UINT*)((uint8_t*)pCode + pData->Size-4)) == 0x0000FFFF /* end token */);
3216 HRESULT hr = pDevice->pDevice9If->CreateVertexShader((const DWORD *)pCode, &pShader);
3217 Assert(hr == S_OK);
3218 if (hr == S_OK)
3219 {
3220 Assert(pShader);
3221 pData->ShaderHandle = pShader;
3222 }
3223 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3224 return hr;
3225}
3226static HRESULT APIENTRY vboxWddmDDevSetVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
3227{
3228 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3229 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3230 Assert(pDevice);
3231 Assert(pDevice->pDevice9If);
3232 IDirect3DVertexShader9 *pShader = (IDirect3DVertexShader9*)hShaderHandle;
3233 Assert(pShader);
3234 HRESULT hr = pDevice->pDevice9If->SetVertexShader(pShader);
3235 Assert(hr == S_OK);
3236 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3237 return hr;
3238}
3239static HRESULT APIENTRY vboxWddmDDevDeleteVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
3240{
3241 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3242 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3243 Assert(pDevice);
3244 Assert(pDevice->pDevice9If);
3245 IDirect3DVertexShader9 *pShader = (IDirect3DVertexShader9*)hShaderHandle;
3246 HRESULT hr = pShader->Release();
3247 Assert(hr == S_OK);
3248 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3249 return hr;
3250}
3251static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTI* pData, CONST INT* pRegisters)
3252{
3253 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3254 AssertBreakpoint();
3255 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3256 return E_FAIL;
3257}
3258static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTB* pData, CONST BOOL* pRegisters)
3259{
3260 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3261 AssertBreakpoint();
3262 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3263 return E_FAIL;
3264}
3265static HRESULT APIENTRY vboxWddmDDevSetScissorRect(HANDLE hDevice, CONST RECT* pRect)
3266{
3267 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3268 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3269 Assert(pDevice);
3270 Assert(pDevice->pDevice9If);
3271 HRESULT hr = pDevice->pDevice9If->SetScissorRect(pRect);
3272 Assert(hr == S_OK);
3273 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3274 return hr;
3275}
3276static HRESULT APIENTRY vboxWddmDDevSetStreamSource(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCE* pData)
3277{
3278 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3279 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3280 Assert(pDevice);
3281 Assert(pDevice->pDevice9If);
3282 PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hVertexBuffer;
3283 Assert(pRc);
3284 Assert(pRc->cAllocations == 1);
3285 PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[0];
3286 Assert(pAlloc->pD3DIf);
3287 IDirect3DVertexBuffer9 *pStreamData = (IDirect3DVertexBuffer9*)pAlloc->pD3DIf;
3288 HRESULT hr = pDevice->pDevice9If->SetStreamSource(pData->Stream, pStreamData, pData->Offset, pData->Stride);
3289 Assert(pData->Stream<VBOXWDDMDISP_MAX_VERTEX_STREAMS);
3290 pDevice->aStreamSource[pData->Stream] = pAlloc;
3291 pDevice->StreamSourceInfo[pData->Stream].uiOffset = pData->Offset;
3292 pDevice->StreamSourceInfo[pData->Stream].uiStride = pData->Stride;
3293 Assert(hr == S_OK);
3294 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3295 return hr;
3296}
3297static HRESULT APIENTRY vboxWddmDDevSetStreamSourceFreq(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEFREQ* pData)
3298{
3299 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3300 AssertBreakpoint();
3301 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3302 return E_FAIL;
3303}
3304static HRESULT APIENTRY vboxWddmDDevSetConvolutionKernelMono(HANDLE hDevice, CONST D3DDDIARG_SETCONVOLUTIONKERNELMONO* pData)
3305{
3306 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3307 AssertBreakpoint();
3308 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3309 return E_FAIL;
3310}
3311static HRESULT APIENTRY vboxWddmDDevComposeRects(HANDLE hDevice, CONST D3DDDIARG_COMPOSERECTS* pData)
3312{
3313 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3314 AssertBreakpoint();
3315 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3316 return E_FAIL;
3317}
3318static HRESULT APIENTRY vboxWddmDDevBlt(HANDLE hDevice, CONST D3DDDIARG_BLT* pData)
3319{
3320 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3321 AssertBreakpoint();
3322 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3323 return E_FAIL;
3324}
3325static HRESULT APIENTRY vboxWddmDDevColorFill(HANDLE hDevice, CONST D3DDDIARG_COLORFILL* pData)
3326{
3327 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3328 AssertBreakpoint();
3329 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3330 return E_FAIL;
3331}
3332static HRESULT APIENTRY vboxWddmDDevDepthFill(HANDLE hDevice, CONST D3DDDIARG_DEPTHFILL* pData)
3333{
3334 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3335 AssertBreakpoint();
3336 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3337 return E_FAIL;
3338}
3339static HRESULT APIENTRY vboxWddmDDevCreateQuery(HANDLE hDevice, D3DDDIARG_CREATEQUERY* pData)
3340{
3341 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3342 AssertBreakpoint();
3343 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3344 return E_FAIL;
3345}
3346static HRESULT APIENTRY vboxWddmDDevDestroyQuery(HANDLE hDevice, HANDLE hQuery)
3347{
3348 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3349 AssertBreakpoint();
3350 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3351 return E_FAIL;
3352}
3353static HRESULT APIENTRY vboxWddmDDevIssueQuery(HANDLE hDevice, CONST D3DDDIARG_ISSUEQUERY* pData)
3354{
3355 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3356 AssertBreakpoint();
3357 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3358 return E_FAIL;
3359}
3360static HRESULT APIENTRY vboxWddmDDevGetQueryData(HANDLE hDevice, CONST D3DDDIARG_GETQUERYDATA* pData)
3361{
3362 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3363 AssertBreakpoint();
3364 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3365 return E_FAIL;
3366}
3367static HRESULT APIENTRY vboxWddmDDevSetRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETRENDERTARGET* pData)
3368{
3369 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3370 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3371 Assert(pDevice);
3372 Assert(pDevice->pDevice9If);
3373 PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hRenderTarget;
3374 Assert(pRc);
3375 Assert(pData->SubResourceIndex < pRc->cAllocations);
3376 IDirect3DSurface9 *pD3D9Surf = (IDirect3DSurface9*)pRc->aAllocations[pData->SubResourceIndex].pD3DIf;
3377 Assert(pD3D9Surf);
3378 HRESULT hr = pDevice->pDevice9If->SetRenderTarget(pData->RenderTargetIndex, pD3D9Surf);
3379 Assert(hr == S_OK);
3380 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3381 return hr;
3382}
3383static HRESULT APIENTRY vboxWddmDDevSetDepthStencil(HANDLE hDevice, CONST D3DDDIARG_SETDEPTHSTENCIL* pData)
3384{
3385 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3386 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3387 Assert(pDevice);
3388 Assert(pDevice->pDevice9If);
3389 PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hZBuffer;
3390 Assert(pRc);
3391 Assert(pRc->cAllocations == 1);
3392 IDirect3DSurface9 *pD3D9Surf = (IDirect3DSurface9*)pRc->aAllocations[0].pD3DIf;
3393 Assert(pD3D9Surf);
3394 HRESULT hr = pDevice->pDevice9If->SetDepthStencilSurface(pD3D9Surf);
3395 Assert(hr == S_OK);
3396 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3397 return hr;
3398}
3399static HRESULT APIENTRY vboxWddmDDevGenerateMipSubLevels(HANDLE hDevice, CONST D3DDDIARG_GENERATEMIPSUBLEVELS* pData)
3400{
3401 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3402 AssertBreakpoint();
3403 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3404 return E_FAIL;
3405}
3406static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTI* pData, CONST INT* pRegisters)
3407{
3408 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3409 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3410 Assert(pDevice);
3411 Assert(pDevice->pDevice9If);
3412 HRESULT hr = pDevice->pDevice9If->SetPixelShaderConstantI(pData->Register, pRegisters, pData->Count);
3413 Assert(hr == S_OK);
3414 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3415 return hr;
3416}
3417static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTB* pData, CONST BOOL* pRegisters)
3418{
3419 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3420 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3421 Assert(pDevice);
3422 Assert(pDevice->pDevice9If);
3423 HRESULT hr = pDevice->pDevice9If->SetPixelShaderConstantB(pData->Register, pRegisters, pData->Count);
3424 Assert(hr == S_OK);
3425 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3426 return hr;
3427}
3428static HRESULT APIENTRY vboxWddmDDevCreatePixelShader(HANDLE hDevice, D3DDDIARG_CREATEPIXELSHADER* pData, CONST UINT* pCode)
3429{
3430 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3431 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3432 Assert(pDevice);
3433 Assert(pDevice->pDevice9If);
3434 IDirect3DPixelShader9 *pShader;
3435 Assert(*((UINT*)((uint8_t*)pCode + pData->CodeSize-4)) == 0x0000FFFF /* end token */);
3436 HRESULT hr = pDevice->pDevice9If->CreatePixelShader((const DWORD *)pCode, &pShader);
3437 Assert(hr == S_OK);
3438 if (hr == S_OK)
3439 {
3440 Assert(pShader);
3441 pData->ShaderHandle = pShader;
3442 }
3443 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3444 return hr;
3445}
3446static HRESULT APIENTRY vboxWddmDDevDeletePixelShader(HANDLE hDevice, HANDLE hShaderHandle)
3447{
3448 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3449 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3450 Assert(pDevice);
3451 Assert(pDevice->pDevice9If);
3452 IDirect3DPixelShader9 *pShader = (IDirect3DPixelShader9*)hShaderHandle;
3453 HRESULT hr = pShader->Release();
3454 Assert(hr == S_OK);
3455 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3456 return hr;
3457}
3458static HRESULT APIENTRY vboxWddmDDevCreateDecodeDevice(HANDLE hDevice, D3DDDIARG_CREATEDECODEDEVICE* pData)
3459{
3460 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3461 AssertBreakpoint();
3462 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3463 return E_FAIL;
3464}
3465static HRESULT APIENTRY vboxWddmDDevDestroyDecodeDevice(HANDLE hDevice, HANDLE hDecodeDevice)
3466{
3467 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3468 AssertBreakpoint();
3469 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3470 return E_FAIL;
3471}
3472static HRESULT APIENTRY vboxWddmDDevSetDecodeRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETDECODERENDERTARGET* pData)
3473{
3474 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3475 AssertBreakpoint();
3476 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3477 return E_FAIL;
3478}
3479static HRESULT APIENTRY vboxWddmDDevDecodeBeginFrame(HANDLE hDevice, D3DDDIARG_DECODEBEGINFRAME* pData)
3480{
3481 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3482 AssertBreakpoint();
3483 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3484 return E_FAIL;
3485}
3486static HRESULT APIENTRY vboxWddmDDevDecodeEndFrame(HANDLE hDevice, D3DDDIARG_DECODEENDFRAME* pData)
3487{
3488 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3489 AssertBreakpoint();
3490 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3491 return E_FAIL;
3492}
3493static HRESULT APIENTRY vboxWddmDDevDecodeExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXECUTE* pData)
3494{
3495 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3496 AssertBreakpoint();
3497 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3498 return E_FAIL;
3499}
3500static HRESULT APIENTRY vboxWddmDDevDecodeExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXTENSIONEXECUTE* pData)
3501{
3502 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3503 AssertBreakpoint();
3504 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3505 return E_FAIL;
3506}
3507static HRESULT APIENTRY vboxWddmDDevCreateVideoProcessDevice(HANDLE hDevice, D3DDDIARG_CREATEVIDEOPROCESSDEVICE* pData)
3508{
3509 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3510 AssertBreakpoint();
3511 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3512 return E_FAIL;
3513}
3514static HRESULT APIENTRY vboxWddmDDevDestroyVideoProcessDevice(HANDLE hDevice, HANDLE hVideoProcessor)
3515{
3516 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3517 AssertBreakpoint();
3518 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3519 return E_FAIL;
3520}
3521static HRESULT APIENTRY vboxWddmDDevVideoProcessBeginFrame(HANDLE hDevice, HANDLE hVideoProcess)
3522{
3523 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3524 AssertBreakpoint();
3525 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3526 return E_FAIL;
3527}
3528static HRESULT APIENTRY vboxWddmDDevVideoProcessEndFrame(HANDLE hDevice, D3DDDIARG_VIDEOPROCESSENDFRAME* pData)
3529{
3530 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3531 AssertBreakpoint();
3532 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3533 return E_FAIL;
3534}
3535static HRESULT APIENTRY vboxWddmDDevSetVideoProcessRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETVIDEOPROCESSRENDERTARGET* pData)
3536{
3537 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3538 AssertBreakpoint();
3539 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3540 return E_FAIL;
3541}
3542static HRESULT APIENTRY vboxWddmDDevVideoProcessBlt(HANDLE hDevice, CONST D3DDDIARG_VIDEOPROCESSBLT* pData)
3543{
3544 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3545 AssertBreakpoint();
3546 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3547 return E_FAIL;
3548}
3549static HRESULT APIENTRY vboxWddmDDevCreateExtensionDevice(HANDLE hDevice, D3DDDIARG_CREATEEXTENSIONDEVICE* pData)
3550{
3551 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3552 AssertBreakpoint();
3553 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3554 return E_FAIL;
3555}
3556static HRESULT APIENTRY vboxWddmDDevDestroyExtensionDevice(HANDLE hDevice, HANDLE hExtension)
3557{
3558 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3559 AssertBreakpoint();
3560 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3561 return E_FAIL;
3562}
3563static HRESULT APIENTRY vboxWddmDDevExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_EXTENSIONEXECUTE* pData)
3564{
3565 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3566 AssertBreakpoint();
3567 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3568 return E_FAIL;
3569}
3570static HRESULT APIENTRY vboxWddmDDevDestroyDevice(IN HANDLE hDevice)
3571{
3572 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3573
3574 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3575 if (pDevice->DefaultContext.ContextInfo.hContext)
3576 {
3577 D3DDDICB_DESTROYCONTEXT DestroyContext;
3578 DestroyContext.hContext = pDevice->DefaultContext.ContextInfo.hContext;
3579 HRESULT tmpHr = pDevice->RtCallbacks.pfnDestroyContextCb(pDevice->hDevice, &DestroyContext);
3580 Assert(tmpHr == S_OK);
3581 }
3582 RTMemFree(hDevice);
3583 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3584 return S_OK;
3585}
3586
3587AssertCompile(sizeof (RECT) == sizeof (D3DDDIRECT));
3588AssertCompile(RT_SIZEOFMEMB(RECT, left) == RT_SIZEOFMEMB(D3DDDIRECT, left));
3589AssertCompile(RT_SIZEOFMEMB(RECT, right) == RT_SIZEOFMEMB(D3DDDIRECT, right));
3590AssertCompile(RT_SIZEOFMEMB(RECT, top) == RT_SIZEOFMEMB(D3DDDIRECT, top));
3591AssertCompile(RT_SIZEOFMEMB(RECT, bottom) == RT_SIZEOFMEMB(D3DDDIRECT, bottom));
3592AssertCompile(RT_OFFSETOF(RECT, left) == RT_OFFSETOF(D3DDDIRECT, left));
3593AssertCompile(RT_OFFSETOF(RECT, right) == RT_OFFSETOF(D3DDDIRECT, right));
3594AssertCompile(RT_OFFSETOF(RECT, top) == RT_OFFSETOF(D3DDDIRECT, top));
3595AssertCompile(RT_OFFSETOF(RECT, bottom) == RT_OFFSETOF(D3DDDIRECT, bottom));
3596
3597static HRESULT APIENTRY vboxWddmDDevCreateOverlay(HANDLE hDevice, D3DDDIARG_CREATEOVERLAY* pData)
3598{
3599 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3600 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3601 PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->OverlayInfo.hResource;
3602 Assert(pRc);
3603 Assert(pRc->cAllocations > pData->OverlayInfo.SubResourceIndex);
3604 PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->OverlayInfo.SubResourceIndex];
3605 HRESULT hr = S_OK;
3606 PVBOXWDDMDISP_OVERLAY pOverlay = (PVBOXWDDMDISP_OVERLAY)RTMemAllocZ(sizeof (VBOXWDDMDISP_OVERLAY));
3607 Assert(pOverlay);
3608 if (pOverlay)
3609 {
3610 VBOXWDDM_OVERLAY_INFO OurInfo;
3611 OurInfo.OverlayDesc.DstColorKeyLow = pData->OverlayInfo.DstColorKeyLow;
3612 OurInfo.OverlayDesc.DstColorKeyHigh = pData->OverlayInfo.DstColorKeyHigh;
3613 OurInfo.OverlayDesc.SrcColorKeyLow = pData->OverlayInfo.SrcColorKeyLow;
3614 OurInfo.OverlayDesc.SrcColorKeyHigh = pData->OverlayInfo.SrcColorKeyHigh;
3615 OurInfo.OverlayDesc.fFlags = pData->OverlayInfo.Flags.Value;
3616 vboxWddmDirtyRegionClear(&OurInfo.DirtyRegion);
3617 Assert(!pAlloc->LockInfo.cLocks);
3618 vboxWddmDirtyRegionUnite(&OurInfo.DirtyRegion, &pAlloc->DirtyRegion);
3619 D3DDDICB_CREATEOVERLAY OverInfo;
3620 OverInfo.VidPnSourceId = pData->VidPnSourceId;
3621 OverInfo.OverlayInfo.hAllocation = pAlloc->hAllocation;
3622 OverInfo.OverlayInfo.DstRect = *(D3DDDIRECT*)((void*)&pData->OverlayInfo.DstRect);
3623 OverInfo.OverlayInfo.SrcRect = *(D3DDDIRECT*)((void*)&pData->OverlayInfo.SrcRect);
3624 OverInfo.OverlayInfo.pPrivateDriverData = &OurInfo;
3625 OverInfo.OverlayInfo.PrivateDriverDataSize = sizeof (OurInfo);
3626 OverInfo.hKernelOverlay = NULL; /* <-- out */
3627 hr = pDevice->RtCallbacks.pfnCreateOverlayCb(pDevice->hDevice, &OverInfo);
3628 Assert(hr == S_OK);
3629 if (hr == S_OK)
3630 {
3631 Assert(OverInfo.hKernelOverlay);
3632 pOverlay->hOverlay = OverInfo.hKernelOverlay;
3633 pOverlay->VidPnSourceId = pData->VidPnSourceId;
3634
3635 Assert(!pAlloc->LockInfo.cLocks);
3636 if (!pAlloc->LockInfo.cLocks)
3637 {
3638 /* we have reported the dirty rect, may clear it if no locks are pending currently */
3639 vboxWddmDirtyRegionClear(&pAlloc->DirtyRegion);
3640 }
3641
3642 pData->hOverlay = pOverlay;
3643 }
3644 else
3645 {
3646 RTMemFree(pOverlay);
3647 }
3648 }
3649 else
3650 hr = E_OUTOFMEMORY;
3651
3652 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3653 return hr;
3654}
3655static HRESULT APIENTRY vboxWddmDDevUpdateOverlay(HANDLE hDevice, CONST D3DDDIARG_UPDATEOVERLAY* pData)
3656{
3657 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3658 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3659 PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->OverlayInfo.hResource;
3660 Assert(pRc);
3661 Assert(pRc->cAllocations > pData->OverlayInfo.SubResourceIndex);
3662 PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->OverlayInfo.SubResourceIndex];
3663 HRESULT hr = S_OK;
3664 PVBOXWDDMDISP_OVERLAY pOverlay = (PVBOXWDDMDISP_OVERLAY)pData->hOverlay;
3665 VBOXWDDM_OVERLAY_INFO OurInfo;
3666 OurInfo.OverlayDesc.DstColorKeyLow = pData->OverlayInfo.DstColorKeyLow;
3667 OurInfo.OverlayDesc.DstColorKeyHigh = pData->OverlayInfo.DstColorKeyHigh;
3668 OurInfo.OverlayDesc.SrcColorKeyLow = pData->OverlayInfo.SrcColorKeyLow;
3669 OurInfo.OverlayDesc.SrcColorKeyHigh = pData->OverlayInfo.SrcColorKeyHigh;
3670 OurInfo.OverlayDesc.fFlags = pData->OverlayInfo.Flags.Value;
3671 vboxWddmDirtyRegionClear(&OurInfo.DirtyRegion);
3672 Assert(!pAlloc->LockInfo.cLocks);
3673 vboxWddmDirtyRegionUnite(&OurInfo.DirtyRegion, &pAlloc->DirtyRegion);
3674 D3DDDICB_UPDATEOVERLAY OverInfo;
3675 OverInfo.hKernelOverlay = pOverlay->hOverlay;
3676 OverInfo.OverlayInfo.hAllocation = pAlloc->hAllocation;
3677 OverInfo.OverlayInfo.DstRect = *(D3DDDIRECT*)((void*)&pData->OverlayInfo.DstRect);
3678 OverInfo.OverlayInfo.SrcRect = *(D3DDDIRECT*)((void*)&pData->OverlayInfo.SrcRect);
3679 OverInfo.OverlayInfo.pPrivateDriverData = &OurInfo;
3680 OverInfo.OverlayInfo.PrivateDriverDataSize = sizeof (OurInfo);
3681 hr = pDevice->RtCallbacks.pfnUpdateOverlayCb(pDevice->hDevice, &OverInfo);
3682 Assert(hr == S_OK);
3683 if (hr == S_OK)
3684 {
3685 Assert(!pAlloc->LockInfo.cLocks);
3686 if (!pAlloc->LockInfo.cLocks)
3687 {
3688 /* we have reported the dirty rect, may clear it if no locks are pending currently */
3689 vboxWddmDirtyRegionClear(&pAlloc->DirtyRegion);
3690 }
3691 }
3692
3693 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3694 return hr;
3695}
3696static HRESULT APIENTRY vboxWddmDDevFlipOverlay(HANDLE hDevice, CONST D3DDDIARG_FLIPOVERLAY* pData)
3697{
3698 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3699 AssertBreakpoint();
3700 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3701 return E_FAIL;
3702}
3703static HRESULT APIENTRY vboxWddmDDevGetOverlayColorControls(HANDLE hDevice, D3DDDIARG_GETOVERLAYCOLORCONTROLS* pData)
3704{
3705 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3706 AssertBreakpoint();
3707 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3708 return E_FAIL;
3709}
3710static HRESULT APIENTRY vboxWddmDDevSetOverlayColorControls(HANDLE hDevice, CONST D3DDDIARG_SETOVERLAYCOLORCONTROLS* pData)
3711{
3712 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3713 AssertBreakpoint();
3714 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3715 return E_FAIL;
3716}
3717static HRESULT APIENTRY vboxWddmDDevDestroyOverlay(HANDLE hDevice, CONST D3DDDIARG_DESTROYOVERLAY* pData)
3718{
3719 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3720 AssertBreakpoint();
3721 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3722 return E_FAIL;
3723}
3724static HRESULT APIENTRY vboxWddmDDevQueryResourceResidency(HANDLE hDevice, CONST D3DDDIARG_QUERYRESOURCERESIDENCY* pData)
3725{
3726 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3727 AssertBreakpoint();
3728 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3729 return E_FAIL;
3730}
3731
3732static HRESULT vboxAllocationInit(PVBOXWDDMDISP_ALLOCATION pAlloc, D3DDDI_OPENALLOCATIONINFO *pInfo)
3733{
3734 HRESULT hr = S_OK;
3735 pAlloc->hAllocation = pInfo->hAllocation;
3736 Assert(pInfo->PrivateDriverDataSize == sizeof (VBOXWDDM_ALLOCINFO));
3737 Assert(pInfo->pPrivateDriverData);
3738 if (pInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO))
3739 {
3740 PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pInfo->pPrivateDriverData;
3741 pAlloc->enmType = pAllocInfo->enmType;
3742 Assert(pAllocInfo->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
3743 || VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE
3744 || VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE);
3745 pAlloc->pvMem = NULL;
3746 pAlloc->SurfDesc = pAllocInfo->SurfDesc;
3747 }
3748 else
3749 {
3750 vboxVDbgPrintR((__FUNCTION__": ERROR: PrivateDriverDataSize(%d) < (%d)\n", pInfo->PrivateDriverDataSize, sizeof (VBOXWDDM_ALLOCINFO)));
3751 hr = E_INVALIDARG;
3752 }
3753 return hr;
3754}
3755
3756static HRESULT APIENTRY vboxWddmDDevOpenResource(HANDLE hDevice, D3DDDIARG_OPENRESOURCE* pData)
3757{
3758 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3759 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3760 HRESULT hr = S_OK;
3761
3762 Assert(pDevice);
3763 Assert(pData->NumAllocations);
3764 PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(pData->NumAllocations);
3765 Assert(pRc);
3766 if (pRc)
3767 {
3768 pRc->hResource = pData->hResource;
3769 pRc->hKMResource = pData->hKMResource;
3770 pRc->pDevice = pDevice;
3771 pRc->RcDesc.enmRotation = pData->Rotation;
3772 pRc->fFlags = VBOXWDDM_RESOURCE_F_OPENNED;
3773 if (!pData->pPrivateDriverData || !pData->PrivateDriverDataSize)
3774 {
3775 /* this is a "standard" allocation resource */
3776
3777 /* both should be actually zero */
3778 Assert(!pData->pPrivateDriverData && !pData->PrivateDriverDataSize);
3779 pRc->RcDesc.enmPool = D3DDDIPOOL_LOCALVIDMEM;
3780 pRc->RcDesc.enmMultisampleType = D3DDDIMULTISAMPLE_NONE;
3781 pRc->RcDesc.MultisampleQuality = 0;
3782 pRc->RcDesc.MipLevels = 0;
3783 pRc->RcDesc.Fvf;
3784 pRc->RcDesc.fFlags.Value = 0;
3785
3786 Assert(pData->NumAllocations);
3787 D3DDDI_OPENALLOCATIONINFO* pDdiAllocInfo = &pData->pOpenAllocationInfo[0];
3788 Assert(pDdiAllocInfo->pPrivateDriverData);
3789 Assert(pDdiAllocInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO));
3790 if (pDdiAllocInfo->pPrivateDriverData && pDdiAllocInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO))
3791 {
3792 PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pDdiAllocInfo->pPrivateDriverData;
3793 switch(pAllocInfo->enmType)
3794 {
3795 case VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE:
3796 pRc->RcDesc.fFlags.Primary = 1;
3797 case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
3798 case VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE:
3799 pRc->RcDesc.enmFormat = pAllocInfo->SurfDesc.format;
3800 pRc->RcDesc.VidPnSourceId = pAllocInfo->SurfDesc.VidPnSourceId;
3801 pRc->RcDesc.RefreshRate = pAllocInfo->SurfDesc.RefreshRate;
3802 break;
3803 default:
3804 AssertBreakpoint();
3805 hr = E_INVALIDARG;
3806 }
3807 }
3808 else
3809 hr = E_INVALIDARG;
3810 }
3811 else
3812 {
3813 /* this is a "generic" resource whose creation is initiaded by the UMD */
3814 Assert(pData->PrivateDriverDataSize == sizeof (VBOXWDDM_RCINFO));
3815 if (pData->PrivateDriverDataSize >= sizeof (VBOXWDDM_RCINFO))
3816 {
3817 VBOXWDDM_RCINFO *pRcInfo = (VBOXWDDM_RCINFO*)pData->pPrivateDriverData;
3818 Assert(pRcInfo->fFlags == VBOXWDDM_RESOURCE_F_TYPE_GENERIC);
3819 Assert(pRcInfo->cAllocInfos == pData->NumAllocations);
3820 pRc->fFlags = pRcInfo->fFlags | VBOXWDDM_RESOURCE_F_OPENNED;
3821 pRc->RcDesc = pRcInfo->RcDesc;
3822 pRc->cAllocations = pData->NumAllocations;
3823 }
3824 else
3825 hr = E_INVALIDARG;
3826 }
3827
3828 if (hr == S_OK)
3829 {
3830 for (UINT i = 0; i < pData->NumAllocations; ++i)
3831 {
3832 hr = vboxAllocationInit(&pRc->aAllocations[i], &pData->pOpenAllocationInfo[i]);
3833 Assert(hr == S_OK);
3834 if (hr != S_OK)
3835 break;
3836 }
3837 }
3838
3839 if (hr == S_OK)
3840 pData->hResource = pRc;
3841 else
3842 vboxResourceFree(pRc);
3843 }
3844 else
3845 {
3846 vboxVDbgPrintR((__FUNCTION__": vboxResourceAlloc failed for hDevice(0x%p), NumAllocations(%d)\n", hDevice, pData->NumAllocations));
3847 hr = E_OUTOFMEMORY;
3848 }
3849
3850 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3851 return hr;
3852}
3853static HRESULT APIENTRY vboxWddmDDevGetCaptureAllocationHandle(HANDLE hDevice, D3DDDIARG_GETCAPTUREALLOCATIONHANDLE* pData)
3854{
3855 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3856 AssertBreakpoint();
3857 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3858 return E_FAIL;
3859}
3860
3861static HRESULT APIENTRY vboxWddmDDevCaptureToSysMem(HANDLE hDevice, CONST D3DDDIARG_CAPTURETOSYSMEM* pData)
3862{
3863 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3864 AssertBreakpoint();
3865 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3866 return E_FAIL;
3867}
3868
3869static HRESULT APIENTRY vboxWddmDispCreateDevice (IN HANDLE hAdapter, IN D3DDDIARG_CREATEDEVICE* pCreateData)
3870{
3871 HRESULT hr = S_OK;
3872 vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p), Interface(%d), Version(%d)\n", hAdapter, pCreateData->Interface, pCreateData->Version));
3873
3874// AssertBreakpoint();
3875
3876 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)RTMemAllocZ(sizeof (VBOXWDDMDISP_DEVICE));
3877 if (pDevice)
3878 {
3879 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
3880
3881 pDevice->hDevice = pCreateData->hDevice;
3882 pDevice->pAdapter = pAdapter;
3883 pDevice->u32IfVersion = pCreateData->Interface;
3884 pDevice->uRtVersion = pCreateData->Version;
3885 pDevice->RtCallbacks = *pCreateData->pCallbacks;
3886 pDevice->pvCmdBuffer = pCreateData->pCommandBuffer;
3887 pDevice->cbCmdBuffer = pCreateData->CommandBufferSize;
3888 pDevice->fFlags = pCreateData->Flags;
3889 /* Set Viewport to some default values */
3890 pDevice->ViewPort.X = 0;
3891 pDevice->ViewPort.Y = 0;
3892 pDevice->ViewPort.Width = 1;
3893 pDevice->ViewPort.Height = 1;
3894 pDevice->ViewPort.MinZ = 0.;
3895 pDevice->ViewPort.MaxZ = 1.;
3896
3897 Assert(!pCreateData->AllocationListSize);
3898 Assert(!pCreateData->PatchLocationListSize);
3899
3900 pCreateData->hDevice = pDevice;
3901
3902 pCreateData->pDeviceFuncs->pfnSetRenderState = vboxWddmDDevSetRenderState;
3903 pCreateData->pDeviceFuncs->pfnUpdateWInfo = vboxWddmDDevUpdateWInfo;
3904 pCreateData->pDeviceFuncs->pfnValidateDevice = vboxWddmDDevValidateDevice;
3905 pCreateData->pDeviceFuncs->pfnSetTextureStageState = vboxWddmDDevSetTextureStageState;
3906 pCreateData->pDeviceFuncs->pfnSetTexture = vboxWddmDDevSetTexture;
3907 pCreateData->pDeviceFuncs->pfnSetPixelShader = vboxWddmDDevSetPixelShader;
3908 pCreateData->pDeviceFuncs->pfnSetPixelShaderConst = vboxWddmDDevSetPixelShaderConst;
3909 pCreateData->pDeviceFuncs->pfnSetStreamSourceUm = vboxWddmDDevSetStreamSourceUm;
3910 pCreateData->pDeviceFuncs->pfnSetIndices = vboxWddmDDevSetIndices;
3911 pCreateData->pDeviceFuncs->pfnSetIndicesUm = vboxWddmDDevSetIndicesUm;
3912 pCreateData->pDeviceFuncs->pfnDrawPrimitive = vboxWddmDDevDrawPrimitive;
3913 pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive = vboxWddmDDevDrawIndexedPrimitive;
3914 pCreateData->pDeviceFuncs->pfnDrawRectPatch = vboxWddmDDevDrawRectPatch;
3915 pCreateData->pDeviceFuncs->pfnDrawTriPatch = vboxWddmDDevDrawTriPatch;
3916 pCreateData->pDeviceFuncs->pfnDrawPrimitive2 = vboxWddmDDevDrawPrimitive2;
3917 pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive2 = vboxWddmDDevDrawIndexedPrimitive2;
3918 pCreateData->pDeviceFuncs->pfnVolBlt = vboxWddmDDevVolBlt;
3919 pCreateData->pDeviceFuncs->pfnBufBlt = vboxWddmDDevBufBlt;
3920 pCreateData->pDeviceFuncs->pfnTexBlt = vboxWddmDDevTexBlt;
3921 pCreateData->pDeviceFuncs->pfnStateSet = vboxWddmDDevStateSet;
3922 pCreateData->pDeviceFuncs->pfnSetPriority = vboxWddmDDevSetPriority;
3923 pCreateData->pDeviceFuncs->pfnClear = vboxWddmDDevClear;
3924 pCreateData->pDeviceFuncs->pfnUpdatePalette = vboxWddmDDevUpdatePalette;
3925 pCreateData->pDeviceFuncs->pfnSetPalette = vboxWddmDDevSetPalette;
3926 pCreateData->pDeviceFuncs->pfnSetVertexShaderConst = vboxWddmDDevSetVertexShaderConst;
3927 pCreateData->pDeviceFuncs->pfnMultiplyTransform = vboxWddmDDevMultiplyTransform;
3928 pCreateData->pDeviceFuncs->pfnSetTransform = vboxWddmDDevSetTransform;
3929 pCreateData->pDeviceFuncs->pfnSetViewport = vboxWddmDDevSetViewport;
3930 pCreateData->pDeviceFuncs->pfnSetZRange = vboxWddmDDevSetZRange;
3931 pCreateData->pDeviceFuncs->pfnSetMaterial = vboxWddmDDevSetMaterial;
3932 pCreateData->pDeviceFuncs->pfnSetLight = vboxWddmDDevSetLight;
3933 pCreateData->pDeviceFuncs->pfnCreateLight = vboxWddmDDevCreateLight;
3934 pCreateData->pDeviceFuncs->pfnDestroyLight = vboxWddmDDevDestroyLight;
3935 pCreateData->pDeviceFuncs->pfnSetClipPlane = vboxWddmDDevSetClipPlane;
3936 pCreateData->pDeviceFuncs->pfnGetInfo = vboxWddmDDevGetInfo;
3937 pCreateData->pDeviceFuncs->pfnLock = vboxWddmDDevLock;
3938 pCreateData->pDeviceFuncs->pfnUnlock = vboxWddmDDevUnlock;
3939 pCreateData->pDeviceFuncs->pfnCreateResource = vboxWddmDDevCreateResource;
3940 pCreateData->pDeviceFuncs->pfnDestroyResource = vboxWddmDDevDestroyResource;
3941 pCreateData->pDeviceFuncs->pfnSetDisplayMode = vboxWddmDDevSetDisplayMode;
3942 pCreateData->pDeviceFuncs->pfnPresent = vboxWddmDDevPresent;
3943 pCreateData->pDeviceFuncs->pfnFlush = vboxWddmDDevFlush;
3944 pCreateData->pDeviceFuncs->pfnCreateVertexShaderFunc = vboxWddmDDevCreateVertexShaderFunc;
3945 pCreateData->pDeviceFuncs->pfnDeleteVertexShaderFunc = vboxWddmDDevDeleteVertexShaderFunc;
3946 pCreateData->pDeviceFuncs->pfnSetVertexShaderFunc = vboxWddmDDevSetVertexShaderFunc;
3947 pCreateData->pDeviceFuncs->pfnCreateVertexShaderDecl = vboxWddmDDevCreateVertexShaderDecl;
3948 pCreateData->pDeviceFuncs->pfnDeleteVertexShaderDecl = vboxWddmDDevDeleteVertexShaderDecl;
3949 pCreateData->pDeviceFuncs->pfnSetVertexShaderDecl = vboxWddmDDevSetVertexShaderDecl;
3950 pCreateData->pDeviceFuncs->pfnSetVertexShaderConstI = vboxWddmDDevSetVertexShaderConstI;
3951 pCreateData->pDeviceFuncs->pfnSetVertexShaderConstB = vboxWddmDDevSetVertexShaderConstB;
3952 pCreateData->pDeviceFuncs->pfnSetScissorRect = vboxWddmDDevSetScissorRect;
3953 pCreateData->pDeviceFuncs->pfnSetStreamSource = vboxWddmDDevSetStreamSource;
3954 pCreateData->pDeviceFuncs->pfnSetStreamSourceFreq = vboxWddmDDevSetStreamSourceFreq;
3955 pCreateData->pDeviceFuncs->pfnSetConvolutionKernelMono = vboxWddmDDevSetConvolutionKernelMono;
3956 pCreateData->pDeviceFuncs->pfnComposeRects = vboxWddmDDevComposeRects;
3957 pCreateData->pDeviceFuncs->pfnBlt = vboxWddmDDevBlt;
3958 pCreateData->pDeviceFuncs->pfnColorFill = vboxWddmDDevColorFill;
3959 pCreateData->pDeviceFuncs->pfnDepthFill = vboxWddmDDevDepthFill;
3960 pCreateData->pDeviceFuncs->pfnCreateQuery = vboxWddmDDevCreateQuery;
3961 pCreateData->pDeviceFuncs->pfnDestroyQuery = vboxWddmDDevDestroyQuery;
3962 pCreateData->pDeviceFuncs->pfnIssueQuery = vboxWddmDDevIssueQuery;
3963 pCreateData->pDeviceFuncs->pfnGetQueryData = vboxWddmDDevGetQueryData;
3964 pCreateData->pDeviceFuncs->pfnSetRenderTarget = vboxWddmDDevSetRenderTarget;
3965 pCreateData->pDeviceFuncs->pfnSetDepthStencil = vboxWddmDDevSetDepthStencil;
3966 pCreateData->pDeviceFuncs->pfnGenerateMipSubLevels = vboxWddmDDevGenerateMipSubLevels;
3967 pCreateData->pDeviceFuncs->pfnSetPixelShaderConstI = vboxWddmDDevSetPixelShaderConstI;
3968 pCreateData->pDeviceFuncs->pfnSetPixelShaderConstB = vboxWddmDDevSetPixelShaderConstB;
3969 pCreateData->pDeviceFuncs->pfnCreatePixelShader = vboxWddmDDevCreatePixelShader;
3970 pCreateData->pDeviceFuncs->pfnDeletePixelShader = vboxWddmDDevDeletePixelShader;
3971 pCreateData->pDeviceFuncs->pfnCreateDecodeDevice = vboxWddmDDevCreateDecodeDevice;
3972 pCreateData->pDeviceFuncs->pfnDestroyDecodeDevice = vboxWddmDDevDestroyDecodeDevice;
3973 pCreateData->pDeviceFuncs->pfnSetDecodeRenderTarget = vboxWddmDDevSetDecodeRenderTarget;
3974 pCreateData->pDeviceFuncs->pfnDecodeBeginFrame = vboxWddmDDevDecodeBeginFrame;
3975 pCreateData->pDeviceFuncs->pfnDecodeEndFrame = vboxWddmDDevDecodeEndFrame;
3976 pCreateData->pDeviceFuncs->pfnDecodeExecute = vboxWddmDDevDecodeExecute;
3977 pCreateData->pDeviceFuncs->pfnDecodeExtensionExecute = vboxWddmDDevDecodeExtensionExecute;
3978 pCreateData->pDeviceFuncs->pfnCreateVideoProcessDevice = vboxWddmDDevCreateVideoProcessDevice;
3979 pCreateData->pDeviceFuncs->pfnDestroyVideoProcessDevice = vboxWddmDDevDestroyVideoProcessDevice;
3980 pCreateData->pDeviceFuncs->pfnVideoProcessBeginFrame = vboxWddmDDevVideoProcessBeginFrame;
3981 pCreateData->pDeviceFuncs->pfnVideoProcessEndFrame = vboxWddmDDevVideoProcessEndFrame;
3982 pCreateData->pDeviceFuncs->pfnSetVideoProcessRenderTarget = vboxWddmDDevSetVideoProcessRenderTarget;
3983 pCreateData->pDeviceFuncs->pfnVideoProcessBlt = vboxWddmDDevVideoProcessBlt;
3984 pCreateData->pDeviceFuncs->pfnCreateExtensionDevice = vboxWddmDDevCreateExtensionDevice;
3985 pCreateData->pDeviceFuncs->pfnDestroyExtensionDevice = vboxWddmDDevDestroyExtensionDevice;
3986 pCreateData->pDeviceFuncs->pfnExtensionExecute = vboxWddmDDevExtensionExecute;
3987 pCreateData->pDeviceFuncs->pfnCreateOverlay = vboxWddmDDevCreateOverlay;
3988 pCreateData->pDeviceFuncs->pfnUpdateOverlay = vboxWddmDDevUpdateOverlay;
3989 pCreateData->pDeviceFuncs->pfnFlipOverlay = vboxWddmDDevFlipOverlay;
3990 pCreateData->pDeviceFuncs->pfnGetOverlayColorControls = vboxWddmDDevGetOverlayColorControls;
3991 pCreateData->pDeviceFuncs->pfnSetOverlayColorControls = vboxWddmDDevSetOverlayColorControls;
3992 pCreateData->pDeviceFuncs->pfnDestroyOverlay = vboxWddmDDevDestroyOverlay;
3993 pCreateData->pDeviceFuncs->pfnDestroyDevice = vboxWddmDDevDestroyDevice;
3994 pCreateData->pDeviceFuncs->pfnQueryResourceResidency = vboxWddmDDevQueryResourceResidency;
3995 pCreateData->pDeviceFuncs->pfnOpenResource = vboxWddmDDevOpenResource;
3996 pCreateData->pDeviceFuncs->pfnGetCaptureAllocationHandle = vboxWddmDDevGetCaptureAllocationHandle;
3997 pCreateData->pDeviceFuncs->pfnCaptureToSysMem = vboxWddmDDevCaptureToSysMem;
3998 pCreateData->pDeviceFuncs->pfnLockAsync = NULL; //vboxWddmDDevLockAsync;
3999 pCreateData->pDeviceFuncs->pfnUnlockAsync = NULL; //vboxWddmDDevUnlockAsync;
4000 pCreateData->pDeviceFuncs->pfnRename = NULL; //vboxWddmDDevRename;
4001
4002
4003 do
4004 {
4005 Assert(!pCreateData->AllocationListSize
4006 && !pCreateData->PatchLocationListSize);
4007 if (!pCreateData->AllocationListSize
4008 && !pCreateData->PatchLocationListSize)
4009 {
4010 pDevice->DefaultContext.ContextInfo.NodeOrdinal = 0;
4011 pDevice->DefaultContext.ContextInfo.EngineAffinity = 0;
4012 pDevice->DefaultContext.ContextInfo.Flags.Value = 0;
4013 pDevice->DefaultContext.ContextInfo.pPrivateDriverData = NULL;
4014 pDevice->DefaultContext.ContextInfo.PrivateDriverDataSize = 0;
4015 pDevice->DefaultContext.ContextInfo.hContext = 0;
4016 pDevice->DefaultContext.ContextInfo.pCommandBuffer = NULL;
4017 pDevice->DefaultContext.ContextInfo.CommandBufferSize = 0;
4018 pDevice->DefaultContext.ContextInfo.pAllocationList = NULL;
4019 pDevice->DefaultContext.ContextInfo.AllocationListSize = 0;
4020 pDevice->DefaultContext.ContextInfo.pPatchLocationList = NULL;
4021 pDevice->DefaultContext.ContextInfo.PatchLocationListSize = 0;
4022
4023 hr = pDevice->RtCallbacks.pfnCreateContextCb(pDevice->hDevice, &pDevice->DefaultContext.ContextInfo);
4024 Assert(hr == S_OK);
4025 if (hr == S_OK)
4026 {
4027 if (VBOXDISPMODE_IS_3D(pAdapter))
4028 {
4029 /* we postpone IDirect3DDevice device creation to CreateResource,
4030 * where resource render target gets created,
4031 * which is actually done as part of d3dx.dll Direct3DDevice creation */
4032 vboxVDbgPrint((__FUNCTION__": D3D Device Created\n"));
4033 break;
4034 }
4035 else
4036 {
4037 /* DDraw */
4038 vboxVDbgPrint((__FUNCTION__": DirectDraw Device Created\n"));
4039 break;
4040 }
4041
4042 D3DDDICB_DESTROYCONTEXT DestroyContext;
4043 DestroyContext.hContext = pDevice->DefaultContext.ContextInfo.hContext;
4044
4045 HRESULT tmpHr = pDevice->RtCallbacks.pfnDestroyContextCb(pDevice->hDevice, &DestroyContext);
4046 Assert(tmpHr == S_OK);
4047 }
4048 else
4049 vboxVDbgPrintR((__FUNCTION__": pfnCreateContextCb failed, hr(%d)\n", hr));
4050 }
4051 else
4052 {
4053 vboxVDbgPrintR((__FUNCTION__": Not implemented: PatchLocationListSize(%d), AllocationListSize(%d)\n",
4054 pCreateData->PatchLocationListSize, pCreateData->AllocationListSize));
4055 //pCreateData->pAllocationList = ??
4056 hr = E_FAIL;
4057 }
4058
4059 RTMemFree(pDevice);
4060 } while (0);
4061 }
4062 else
4063 {
4064 vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
4065 hr = E_OUTOFMEMORY;
4066 }
4067
4068 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
4069
4070 return hr;
4071}
4072
4073static HRESULT APIENTRY vboxWddmDispCloseAdapter (IN HANDLE hAdapter)
4074{
4075 vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
4076
4077// AssertBreakpoint();
4078
4079 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
4080 if (VBOXDISPMODE_IS_3D(pAdapter))
4081 {
4082 HRESULT hr = VBoxDispWorkerDestroy(&pAdapter->WndWorker);
4083 Assert(hr == S_OK);
4084 hr = pAdapter->pD3D9If->Release();
4085 Assert(hr == S_OK);
4086 VBoxDispD3DClose(&pAdapter->D3D);
4087 }
4088
4089 vboxCapsFree(pAdapter);
4090
4091 RTMemFree(pAdapter);
4092
4093 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
4094
4095 return S_OK;
4096}
4097
4098HRESULT APIENTRY OpenAdapter (__inout D3DDDIARG_OPENADAPTER* pOpenData)
4099{
4100 vboxVDbgPrint(("==> "__FUNCTION__"\n"));
4101
4102 VBOXWDDM_QI Query;
4103 D3DDDICB_QUERYADAPTERINFO DdiQuery;
4104 DdiQuery.PrivateDriverDataSize = sizeof(Query);
4105 DdiQuery.pPrivateDriverData = &Query;
4106 HRESULT hr = pOpenData->pAdapterCallbacks->pfnQueryAdapterInfoCb(pOpenData->hAdapter, &DdiQuery);
4107 Assert(hr == S_OK);
4108 if (hr != S_OK)
4109 {
4110 vboxVDbgPrintR((__FUNCTION__": pfnQueryAdapterInfoCb failed, hr (%d)\n", hr));
4111 return E_FAIL;
4112 }
4113
4114 /* check the miniport version match display version */
4115 if (Query.u32Version != VBOXVIDEOIF_VERSION)
4116 {
4117 vboxVDbgPrintR((__FUNCTION__": miniport version mismatch, expected (%d), but was (%d)\n",
4118 VBOXVIDEOIF_VERSION,
4119 Query.u32Version));
4120 return E_FAIL;
4121 }
4122
4123#ifdef VBOX_WITH_VIDEOHWACCEL
4124 Assert(Query.cInfos >= 1);
4125 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(RT_OFFSETOF(VBOXWDDMDISP_ADAPTER, aHeads[Query.cInfos]));
4126#else
4127 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(sizeof (VBOXWDDMDISP_ADAPTER));
4128#endif
4129 Assert(pAdapter);
4130 if (pAdapter)
4131 {
4132 pAdapter->hAdapter = pOpenData->hAdapter;
4133 pAdapter->uIfVersion = pOpenData->Interface;
4134 pAdapter->uRtVersion= pOpenData->Version;
4135 pAdapter->RtCallbacks = *pOpenData->pAdapterCallbacks;
4136
4137 pAdapter->cHeads = Query.cInfos;
4138
4139
4140 pOpenData->hAdapter = pAdapter;
4141 pOpenData->pAdapterFuncs->pfnGetCaps = vboxWddmDispGetCaps;
4142 pOpenData->pAdapterFuncs->pfnCreateDevice = vboxWddmDispCreateDevice;
4143 pOpenData->pAdapterFuncs->pfnCloseAdapter = vboxWddmDispCloseAdapter;
4144 pOpenData->DriverVersion = D3D_UMD_INTERFACE_VERSION;
4145 /*
4146 * here we detect whether we are called by the d3d or ddraw.
4147 * in the d3d case we init our d3d environment
4148 * in the ddraw case we init 2D acceleration
4149 * if interface version is > 7, this is D3D, treat it as so
4150 * otherwise treat it as ddraw
4151 * @todo: need a more clean way of doing this */
4152
4153 if (pAdapter->uIfVersion > 7)
4154 {
4155 do
4156 {
4157 /* try enable the 3D */
4158 hr = VBoxDispD3DOpen(&pAdapter->D3D);
4159 Assert(hr == S_OK);
4160 if (hr == S_OK)
4161 {
4162 hr = pAdapter->D3D.pfnDirect3DCreate9Ex(D3D_SDK_VERSION, &pAdapter->pD3D9If);
4163 Assert(hr == S_OK);
4164 if (hr == S_OK)
4165 {
4166 hr = VBoxDispWorkerCreate(&pAdapter->WndWorker);
4167 Assert(hr == S_OK);
4168 if (hr == S_OK)
4169 {
4170 vboxVDbgPrint((__FUNCTION__": SUCCESS 3D Enabled, pAdapter (0x%p)\n", pAdapter));
4171 break;
4172 }
4173 pAdapter->pD3D9If->Release();
4174 }
4175 else
4176 vboxVDbgPrintR((__FUNCTION__": pfnDirect3DCreate9Ex failed, hr (%d)\n", hr));
4177 VBoxDispD3DClose(&pAdapter->D3D);
4178 }
4179 else
4180 vboxVDbgPrintR((__FUNCTION__": VBoxDispD3DOpen failed, hr (%d)\n", hr));
4181 } while (0);
4182 }
4183#ifdef VBOX_WITH_VIDEOHWACCEL
4184 else
4185 {
4186 for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
4187 {
4188 pAdapter->aHeads[i].Vhwa.Settings = Query.aInfos[i];
4189 }
4190 }
4191#endif
4192
4193 vboxCapsInit(pAdapter);
4194 hr = S_OK;
4195// RTMemFree(pAdapter);
4196 }
4197 else
4198 {
4199 vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
4200 hr = E_OUTOFMEMORY;
4201 }
4202
4203 vboxVDbgPrint(("<== "__FUNCTION__", hr (%d)\n", hr));
4204
4205 return hr;
4206}
4207
4208#ifdef VBOXWDDMDISP_DEBUG
4209VOID vboxVDbgDoPrint(LPCSTR szString, ...)
4210{
4211 char szBuffer[1024] = {0};
4212 va_list pArgList;
4213 va_start(pArgList, szString);
4214 _vsnprintf(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]), szString, pArgList);
4215 va_end(pArgList);
4216
4217 OutputDebugStringA(szBuffer);
4218}
4219#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