VBoxDispD3D.cpp@ 30133

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: