VBoxDispD3D.cpp@ 30120

Last change on this file since 30120 was 30120, 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: 142.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	AssertBreakpoint();
1483	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1484	return E_FAIL;
1485	}
1486
1487	static HRESULT APIENTRY vboxWddmDDevSetIndices(HANDLE hDevice, CONST D3DDDIARG_SETINDICES* pData)
1488	{
1489	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1490	AssertBreakpoint();
1491	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1492	return E_FAIL;
1493	}
1494
1495	static HRESULT APIENTRY vboxWddmDDevSetIndicesUm(HANDLE hDevice, UINT IndexSize, CONST VOID* pUMBuffer)
1496	{
1497	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1498	AssertBreakpoint();
1499	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1500	return E_FAIL;
1501	}
1502
1503	static HRESULT APIENTRY vboxWddmDDevDrawPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE* pData, CONST UINT* pFlagBuffer)
1504	{
1505	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1506	AssertBreakpoint();
1507	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1508	return E_FAIL;
1509	}
1510
1511	static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE* pData)
1512	{
1513	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1514	AssertBreakpoint();
1515	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1516	return E_FAIL;
1517	}
1518
1519	static HRESULT APIENTRY vboxWddmDDevDrawRectPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWRECTPATCH* pData, CONST D3DDDIRECTPATCH_INFO* pInfo, CONST FLOAT* pPatch)
1520	{
1521	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1522	AssertBreakpoint();
1523	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1524	return E_FAIL;
1525	}
1526
1527	static HRESULT APIENTRY vboxWddmDDevDrawTriPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWTRIPATCH* pData, CONST D3DDDITRIPATCH_INFO* pInfo, CONST FLOAT* pPatch)
1528	{
1529	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1530	AssertBreakpoint();
1531	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1532	return E_FAIL;
1533	}
1534
1535	static HRESULT APIENTRY vboxWddmDDevDrawPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE2* pData)
1536	{
1537	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1538	AssertBreakpoint();
1539	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1540	return E_FAIL;
1541	}
1542
1543	static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE2* pData, UINT dwIndicesSize, CONST VOID* pIndexBuffer, CONST UINT* pFlagBuffer)
1544	{
1545	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1546	AssertBreakpoint();
1547	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1548	return E_FAIL;
1549	}
1550
1551	static HRESULT APIENTRY vboxWddmDDevVolBlt(HANDLE hDevice, CONST D3DDDIARG_VOLUMEBLT* pData)
1552	{
1553	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1554	AssertBreakpoint();
1555	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1556	return E_FAIL;
1557	}
1558
1559	static HRESULT APIENTRY vboxWddmDDevBufBlt(HANDLE hDevice, CONST D3DDDIARG_BUFFERBLT* pData)
1560	{
1561	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1562	AssertBreakpoint();
1563	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1564	return E_FAIL;
1565	}
1566
1567	static HRESULT APIENTRY vboxWddmDDevTexBlt(HANDLE hDevice, CONST D3DDDIARG_TEXBLT* pData)
1568	{
1569	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1570	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1571	Assert(pDevice);
1572	Assert(pDevice->pDevice9If);
1573	PVBOXWDDMDISP_RESOURCE pDstRc = (PVBOXWDDMDISP_RESOURCE)pData->hDstResource;
1574	PVBOXWDDMDISP_RESOURCE pSrcRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
1575	IDirect3DTexture9 pD3DIfSrcTex = (IDirect3DTexture9)pSrcRc->aAllocations[0].pD3DIf;
1576	IDirect3DTexture9 pD3DIfDstTex = (IDirect3DTexture9)pDstRc->aAllocations[0].pD3DIf;
1577	Assert(pD3DIfSrcTex);
1578	Assert(pD3DIfDstTex);
1579	HRESULT hr = S_OK;
1580
1581	if (pSrcRc->aAllocations[0].SurfDesc.width == pDstRc->aAllocations[0].SurfDesc.width
1582	&& pSrcRc->aAllocations[0].SurfDesc.height == pDstRc->aAllocations[0].SurfDesc.height
1583	&& pSrcRc->RcDesc.enmFormat == pDstRc->RcDesc.enmFormat)
1584	{
1585	/* first check if we can do IDirect3DDevice9::UpdateTexture */
1586	if (pData->DstPoint.x == 0 && pData->DstPoint.y == 0
1587	&& pData->SrcRect.left == 0 && pData->SrcRect.top == 0
1588	&& pData->SrcRect.right - pData->SrcRect.left == pSrcRc->aAllocations[0].SurfDesc.width
1589	&& pData->SrcRect.bottom - pData->SrcRect.top == pSrcRc->aAllocations[0].SurfDesc.height)
1590	{
1591	hr = pDevice->pDevice9If->UpdateTexture(pD3DIfSrcTex, pD3DIfDstTex);
1592	Assert(hr == S_OK);
1593	}
1594	else
1595	{
1596	AssertBreakpoint();
1597	/* @todo: impl */
1598	}
1599	}
1600	else
1601	{
1602	AssertBreakpoint();
1603	/* @todo: impl */
1604	}
1605
1606	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1607	return hr;
1608	}
1609
1610	static HRESULT APIENTRY vboxWddmDDevStateSet(HANDLE hDevice, D3DDDIARG_STATESET* pData)
1611	{
1612	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1613	AssertBreakpoint();
1614	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1615	return E_FAIL;
1616	}
1617	static HRESULT APIENTRY vboxWddmDDevSetPriority(HANDLE hDevice, CONST D3DDDIARG_SETPRIORITY* pData)
1618	{
1619	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1620	AssertBreakpoint();
1621	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1622	return E_FAIL;
1623	}
1624	AssertCompile(sizeof (RECT) == sizeof (D3DRECT));
1625	AssertCompile(RT_SIZEOFMEMB(RECT, left) == RT_SIZEOFMEMB(D3DRECT, x1));
1626	AssertCompile(RT_SIZEOFMEMB(RECT, right) == RT_SIZEOFMEMB(D3DRECT, x2));
1627	AssertCompile(RT_SIZEOFMEMB(RECT, top) == RT_SIZEOFMEMB(D3DRECT, y1));
1628	AssertCompile(RT_SIZEOFMEMB(RECT, bottom) == RT_SIZEOFMEMB(D3DRECT, y2));
1629	AssertCompile(RT_OFFSETOF(RECT, left) == RT_OFFSETOF(D3DRECT, x1));
1630	AssertCompile(RT_OFFSETOF(RECT, right) == RT_OFFSETOF(D3DRECT, x2));
1631	AssertCompile(RT_OFFSETOF(RECT, top) == RT_OFFSETOF(D3DRECT, y1));
1632	AssertCompile(RT_OFFSETOF(RECT, bottom) == RT_OFFSETOF(D3DRECT, y2));
1633
1634	static HRESULT APIENTRY vboxWddmDDevClear(HANDLE hDevice, CONST D3DDDIARG_CLEAR* pData, UINT NumRect, CONST RECT* pRect)
1635	{
1636	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1637	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1638	Assert(pDevice);
1639	Assert(pDevice->pDevice9If);
1640	HRESULT hr = pDevice->pDevice9If->Clear(NumRect, (D3DRECT)pRect / see AssertCompile above */,
1641	pData->Flags,
1642	pData->FillColor,
1643	pData->FillDepth,
1644	pData->FillStencil);
1645	Assert(hr == S_OK);
1646	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1647	return hr;
1648	}
1649	static HRESULT APIENTRY vboxWddmDDevUpdatePalette(HANDLE hDevice, CONST D3DDDIARG_UPDATEPALETTE* pData, CONST PALETTEENTRY* pPaletteData)
1650	{
1651	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1652	AssertBreakpoint();
1653	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1654	return E_FAIL;
1655	}
1656
1657	static HRESULT APIENTRY vboxWddmDDevSetPalette(HANDLE hDevice, CONST D3DDDIARG_SETPALETTE* pData)
1658	{
1659	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1660	AssertBreakpoint();
1661	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1662	return E_FAIL;
1663	}
1664
1665	static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONST* pData , CONST VOID* pRegisters)
1666	{
1667	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1668	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1669	Assert(pDevice);
1670	Assert(pDevice->pDevice9If);
1671	HRESULT hr = pDevice->pDevice9If->SetVertexShaderConstantF(
1672	pData->Register,
1673	(CONST float*)pRegisters,
1674	pData->Count);
1675	Assert(hr == S_OK);
1676	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1677	return hr;
1678	}
1679	static HRESULT APIENTRY vboxWddmDDevMultiplyTransform(HANDLE hDevice, CONST D3DDDIARG_MULTIPLYTRANSFORM* pData)
1680	{
1681	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1682	AssertBreakpoint();
1683	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1684	return E_FAIL;
1685	}
1686	static HRESULT APIENTRY vboxWddmDDevSetTransform(HANDLE hDevice, CONST D3DDDIARG_SETTRANSFORM* pData)
1687	{
1688	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1689	AssertBreakpoint();
1690	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1691	return E_FAIL;
1692	}
1693	static HRESULT APIENTRY vboxWddmDDevSetViewport(HANDLE hDevice, CONST D3DDDIARG_VIEWPORTINFO* pData)
1694	{
1695	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1696	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1697	Assert(pDevice);
1698	Assert(pDevice->pDevice9If);
1699	pDevice->ViewPort.X = pData->X;
1700	pDevice->ViewPort.Y = pData->Y;
1701	pDevice->ViewPort.Width = pData->Width;
1702	pDevice->ViewPort.Height = pData->Height;
1703	HRESULT hr = pDevice->pDevice9If->SetViewport(&pDevice->ViewPort);
1704	Assert(hr == S_OK);
1705	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1706	return hr;
1707	}
1708	static HRESULT APIENTRY vboxWddmDDevSetZRange(HANDLE hDevice, CONST D3DDDIARG_ZRANGE* pData)
1709	{
1710	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1711	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1712	Assert(pDevice);
1713	Assert(pDevice->pDevice9If);
1714	pDevice->ViewPort.MinZ = pData->MinZ;
1715	pDevice->ViewPort.MaxZ = pData->MaxZ;
1716	HRESULT hr = pDevice->pDevice9If->SetViewport(&pDevice->ViewPort);
1717	Assert(hr == S_OK);
1718	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1719	return hr;
1720	}
1721	static HRESULT APIENTRY vboxWddmDDevSetMaterial(HANDLE hDevice, CONST D3DDDIARG_SETMATERIAL* pData)
1722	{
1723	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1724	AssertBreakpoint();
1725	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1726	return E_FAIL;
1727	}
1728	static HRESULT APIENTRY vboxWddmDDevSetLight(HANDLE hDevice, CONST D3DDDIARG_SETLIGHT* pData, CONST D3DDDI_LIGHT* pLightProperties)
1729	{
1730	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1731	AssertBreakpoint();
1732	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1733	return E_FAIL;
1734	}
1735	static HRESULT APIENTRY vboxWddmDDevCreateLight(HANDLE hDevice, CONST D3DDDIARG_CREATELIGHT* pData)
1736	{
1737	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1738	AssertBreakpoint();
1739	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1740	return E_FAIL;
1741	}
1742	static HRESULT APIENTRY vboxWddmDDevDestroyLight(HANDLE hDevice, CONST D3DDDIARG_DESTROYLIGHT* 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	static HRESULT APIENTRY vboxWddmDDevSetClipPlane(HANDLE hDevice, CONST D3DDDIARG_SETCLIPPLANE* pData)
1750	{
1751	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1752	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1753	Assert(pDevice);
1754	Assert(pDevice->pDevice9If);
1755	HRESULT hr = pDevice->pDevice9If->SetClipPlane(pData->Index, pData->Plane);
1756	Assert(hr == S_OK);
1757	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1758	return hr;
1759	}
1760
1761	static HRESULT APIENTRY vboxWddmDDevGetInfo(HANDLE hDevice, UINT DevInfoID, VOID* pDevInfoStruct, UINT DevInfoSize)
1762	{
1763	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1764	AssertBreakpoint();
1765	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1766	return E_NOTIMPL;
1767	}
1768
1769	static HRESULT APIENTRY vboxWddmDDevLock(HANDLE hDevice, D3DDDIARG_LOCK* pData)
1770	{
1771	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1772	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1773	PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
1774	Assert(pData->SubResourceIndex < pRc->cAllocations);
1775	if (pData->SubResourceIndex >= pRc->cAllocations)
1776	return E_INVALIDARG;
1777
1778	HRESULT hr = S_OK;
1779
1780	if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
1781	{
1782	if (pRc->RcDesc.fFlags.Texture)
1783	{
1784	PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
1785	Assert(pData->SubResourceIndex < pRc->cAllocations);
1786	PVBOXWDDMDISP_ALLOCATION pLockAlloc = &pRc->aAllocations[pData->SubResourceIndex];
1787	IDirect3DTexture9 pD3DIfTex = (IDirect3DTexture9)pTexAlloc->pD3DIf;
1788	Assert(pD3DIfTex);
1789	RECT *pRect = NULL;
1790	if (pData->Flags.AreaValid)
1791	{
1792	pRect = &pData->Area;
1793	}
1794	else if (pData->Flags.RangeValid)
1795	{
1796	AssertBreakpoint();
1797	}
1798	else if (pData->Flags.BoxValid)
1799	{
1800	AssertBreakpoint();
1801	}
1802	/* else - we lock the entire texture, pRect == NULL */
1803
1804	// Assert(!pLockAlloc->LockInfo.cLocks);
1805	if (!pLockAlloc->LockInfo.cLocks)
1806	{
1807	hr = pD3DIfTex->LockRect(pData->SubResourceIndex,
1808	&pLockAlloc->LockInfo.LockedRect,
1809	pRect,
1810	vboxDDI2D3DLockFlags(pData->Flags));
1811	Assert(hr == S_OK);
1812	if (hr == S_OK)
1813	{
1814
1815	// Assert(pLockAlloc->LockInfo.fFlags.Value == 0);
1816	pLockAlloc->LockInfo.fFlags = pData->Flags;
1817	if (pRect)
1818	{
1819	pLockAlloc->LockInfo.Area = *pRect;
1820	Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 1);
1821	// pLockAlloc->LockInfo.fFlags.AreaValid = 1;
1822	}
1823	else
1824	{
1825	Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 0);
1826	// pLockAlloc->LockInfo.fFlags.AreaValid = 0;
1827	}
1828
1829	++pLockAlloc->LockInfo.cLocks;
1830	}
1831	}
1832	else
1833	{
1834	// Assert(pLockAlloc->LockInfo.fFlags.Value == pData->Flags.Value);
1835	// if (pLockAlloc->LockInfo.fFlags.Value != pData->Flags.Value)
1836	// {
1837	// }
1838	Assert(pLockAlloc->LockInfo.fFlags.AreaValid == pData->Flags.AreaValid);
1839	if (pLockAlloc->LockInfo.fFlags.AreaValid && pData->Flags.AreaValid)
1840	{
1841	Assert(pLockAlloc->LockInfo.Area.left == pData->Area.left);
1842	Assert(pLockAlloc->LockInfo.Area.top == pData->Area.top);
1843	Assert(pLockAlloc->LockInfo.Area.right == pData->Area.right);
1844	Assert(pLockAlloc->LockInfo.Area.bottom == pData->Area.bottom);
1845	}
1846	Assert(pLockAlloc->LockInfo.LockedRect.pBits);
1847	}
1848
1849
1850	++pLockAlloc->LockInfo.cLocks;
1851
1852	if (!pData->Flags.NotifyOnly)
1853	{
1854	pData->pSurfData = pLockAlloc->LockInfo.LockedRect.pBits;
1855	pData->Pitch = pLockAlloc->LockInfo.LockedRect.Pitch;
1856	pData->SlicePitch = 0;
1857	Assert(pLockAlloc->SurfDesc.slicePitch == 0);
1858	Assert(!pLockAlloc->pvMem);
1859	}
1860	else
1861	{
1862	Assert(pLockAlloc->pvMem);
1863	Assert(pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
1864	if (/* !pData->Flags.WriteOnly && */ !pData->Flags.Discard)
1865	vboxWddmLockUnlockMemSynch(pLockAlloc, &pLockAlloc->LockInfo.LockedRect, pRect, false /bool bToLockInfo/);
1866	}
1867	}
1868	else
1869	{
1870	AssertBreakpoint();
1871	}
1872	}
1873	else
1874	{
1875	PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
1876	D3DDDICB_LOCK LockData;
1877	LockData.hAllocation = pAlloc->hAllocation;
1878	LockData.PrivateDriverData = 0;
1879	LockData.NumPages = 0;
1880	LockData.pPages = NULL;
1881	LockData.pData = NULL; /* out */
1882	LockData.Flags.Value = 0;
1883	LockData.Flags.Discard = pData->Flags.Discard;
1884	LockData.Flags.DonotWait = pData->Flags.DoNotWait;
1885
1886
1887	hr = pDevice->RtCallbacks.pfnLockCb(hDevice, &LockData);
1888	Assert(hr == S_OK \|\| (hr == D3DERR_WASSTILLDRAWING && pData->Flags.DoNotWait));
1889	if (hr == S_OK)
1890	{
1891	uintptr_t offset;
1892	if (pData->Flags.AreaValid)
1893	{
1894	offset = pAlloc->SurfDesc.pitch * pData->Area.top +
1895	((pAlloc->SurfDesc.bpp * pData->Area.left) >> 3);
1896	}
1897	else if (pData->Flags.RangeValid)
1898	{
1899	offset = pData->Range.Offset;
1900	}
1901	else if (pData->Flags.BoxValid)
1902	{
1903	vboxVDbgPrintF((__FUNCTION__": Implement Box area"));
1904	AssertBreakpoint();
1905	}
1906	else
1907	{
1908	AssertBreakpoint();
1909	}
1910
1911	if (pData->Flags.Discard)
1912	{
1913	/* check if the surface was renamed */
1914	if (LockData.hAllocation)
1915	pAlloc->hAllocation = LockData.hAllocation;
1916	}
1917
1918	pData->pSurfData = ((uint8_t*)LockData.pData) + offset;
1919	pData->Pitch = pAlloc->SurfDesc.pitch;
1920	pData->SlicePitch = pAlloc->SurfDesc.slicePitch;
1921	}
1922	}
1923
1924	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(%d)\n", hDevice, hr));
1925	return hr;
1926	}
1927	static HRESULT APIENTRY vboxWddmDDevUnlock(HANDLE hDevice, CONST D3DDDIARG_UNLOCK* pData)
1928	{
1929	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1930	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1931	PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
1932	HRESULT hr = S_OK;
1933
1934	Assert(pData->SubResourceIndex < pRc->cAllocations);
1935	if (pData->SubResourceIndex >= pRc->cAllocations)
1936	return E_INVALIDARG;
1937
1938	if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
1939	{
1940	if (pRc->RcDesc.fFlags.Texture)
1941	{
1942	Assert(pData->SubResourceIndex < pRc->cAllocations);
1943	PVBOXWDDMDISP_ALLOCATION pLockAlloc = &pRc->aAllocations[pData->SubResourceIndex];
1944
1945	--pLockAlloc->LockInfo.cLocks;
1946	if (!pLockAlloc->LockInfo.cLocks)
1947	{
1948	PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
1949	Assert(pLockAlloc->LockInfo.cLocks);
1950	IDirect3DTexture9 pD3DIfTex = (IDirect3DTexture9)pTexAlloc->pD3DIf;
1951	Assert(pD3DIfTex);
1952	/* this is a sysmem texture, update */
1953	if (pLockAlloc->pvMem && !pLockAlloc->LockInfo.fFlags.ReadOnly)
1954	{
1955	vboxWddmLockUnlockMemSynch(pLockAlloc, &pLockAlloc->LockInfo.LockedRect,
1956	pLockAlloc->LockInfo.fFlags.AreaValid ? &pLockAlloc->LockInfo.Area : NULL,
1957	true /bool bToLockInfo/);
1958	}
1959	hr = pD3DIfTex->UnlockRect(pData->SubResourceIndex);
1960	Assert(hr == S_OK);
1961	}
1962	else
1963	{
1964	Assert(pLockAlloc->LockInfo.cLocks < UINT32_MAX);
1965	}
1966	}
1967	else
1968	{
1969	AssertBreakpoint();
1970	}
1971	}
1972	else
1973	{
1974	struct
1975	{
1976	D3DDDICB_UNLOCK Unlock;
1977	D3DKMT_HANDLE hAllocation;
1978	} UnlockData;
1979
1980	UnlockData.Unlock.NumAllocations = 1;
1981	UnlockData.Unlock.phAllocations = &UnlockData.hAllocation;
1982	UnlockData.hAllocation = pRc->aAllocations[pData->SubResourceIndex].hAllocation;
1983
1984	hr = pDevice->RtCallbacks.pfnUnlockCb(hDevice, &UnlockData.Unlock);
1985	Assert(hr == S_OK);
1986	}
1987
1988	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1989	return hr;
1990	}
1991	static HRESULT APIENTRY vboxWddmDDevLockAsync(HANDLE hDevice, D3DDDIARG_LOCKASYNC* pData)
1992	{
1993	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1994	AssertBreakpoint();
1995	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1996	return E_FAIL;
1997	}
1998	static HRESULT APIENTRY vboxWddmDDevUnlockAsync(HANDLE hDevice, CONST D3DDDIARG_UNLOCKASYNC* pData)
1999	{
2000	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2001	AssertBreakpoint();
2002	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2003	return E_FAIL;
2004	}
2005	static HRESULT APIENTRY vboxWddmDDevRename(HANDLE hDevice, CONST D3DDDIARG_RENAME* pData)
2006	{
2007	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2008	AssertBreakpoint();
2009	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2010	return E_FAIL;
2011	}
2012
2013	static HRESULT APIENTRY vboxWddmDDevCreateResource(HANDLE hDevice, D3DDDIARG_CREATERESOURCE* pResource)
2014	{
2015	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2016	HRESULT hr = S_OK;
2017	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2018	Assert(pDevice);
2019	Assert(pResource);
2020	PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter;
2021
2022	if (VBOXDISPMODE_IS_3D(pAdapter))
2023	{
2024	PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(pResource->SurfCount);
2025	Assert(pRc);
2026	if (pRc)
2027	{
2028	pRc->hResource = pResource->hResource;
2029	pRc->pDevice = pDevice;
2030	pRc->fFlags = VBOXWDDM_RESOURCE_F_TYPE_GENERIC;
2031	vboxResourcePopulateRcDesc(&pRc->RcDesc, pResource);
2032	pRc->cAllocations = pResource->SurfCount;
2033	for (UINT i = 0; i < pResource->SurfCount; ++i)
2034	{
2035	PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2036	CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
2037	pAllocation->hAllocation = NULL;
2038	pAllocation->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC;
2039	pAllocation->pvMem = (void*)pSurf->pSysMem;
2040	pAllocation->SurfDesc.pitch = pSurf->SysMemPitch;
2041	pAllocation->SurfDesc.slicePitch = pSurf->SysMemSlicePitch;
2042	pAllocation->SurfDesc.depth = pSurf->Depth;
2043	pAllocation->SurfDesc.width = pSurf->Width;
2044	pAllocation->SurfDesc.height = pSurf->Height;
2045	pAllocation->SurfDesc.format = pResource->Format;
2046	}
2047
2048	if (pResource->Flags.RenderTarget)
2049	{
2050	HWND hWnd = NULL;
2051	Assert(pResource->SurfCount);
2052	Assert(!pDevice->pDevice9If);
2053	Assert(!pDevice->hWnd);
2054	hr = VBoxDispWndCreate(pAdapter, pResource->pSurfList[0].Width, pResource->pSurfList[0].Height, &hWnd);
2055	Assert(hr == S_OK);
2056	if (hr == S_OK)
2057	{
2058	DWORD fFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;
2059	if (pDevice->fFlags.AllowMultithreading)
2060	fFlags \|= D3DCREATE_MULTITHREADED;
2061
2062	IDirect3DDevice9 *pDevice9If = NULL;
2063	D3DPRESENT_PARAMETERS params;
2064	memset(&params, 0, sizeof (params));
2065	// params.BackBufferWidth = 0;
2066	// params.BackBufferHeight = 0;
2067	params.BackBufferFormat = vboxDDI2D3DFormat(pResource->Format);
2068	Assert(pResource->SurfCount);
2069	params.BackBufferCount = pResource->SurfCount - 1;
2070	params.MultiSampleType = vboxDDI2D3DMultiSampleType(pResource->MultisampleType);
2071	if (pResource->Flags.DiscardRenderTarget)
2072	params.SwapEffect = D3DSWAPEFFECT_DISCARD;
2073	params.hDeviceWindow = hWnd;
2074	/* @todo: it seems there should be a way to detect this correctly since
2075	* our vboxWddmDDevSetDisplayMode will be called in case we are using full-screen */
2076	params.Windowed = TRUE;
2077	// params.EnableAutoDepthStencil = FALSE;
2078	// params.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
2079	// params.Flags;
2080	// params.FullScreen_RefreshRateInHz;
2081	// params.FullScreen_PresentationInterval;
2082	hr = pAdapter->pD3D9If->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, fFlags, &params, &pDevice9If);
2083	Assert(hr == S_OK);
2084	if (hr == S_OK)
2085	{
2086	pDevice->pDevice9If = pDevice9If;
2087	pDevice->hWnd = hWnd;
2088	for (UINT i = 0; i < pResource->SurfCount; ++i)
2089	{
2090	PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2091
2092	IDirect3DSurface9* pD3D9Surf;
2093	hr = pDevice9If->CreateRenderTarget(pAllocation->SurfDesc.width,
2094	pAllocation->SurfDesc.height,
2095	vboxDDI2D3DFormat(pResource->Format),
2096	vboxDDI2D3DMultiSampleType(pResource->MultisampleType),
2097	pResource->MultisampleQuality,
2098	!pResource->Flags.NotLockable /* BOOL Lockable */,
2099	&pD3D9Surf,
2100	NULL /* HANDLE* pSharedHandle */
2101	);
2102	Assert(hr == S_OK);
2103	if (hr == S_OK)
2104	{
2105	Assert(pD3D9Surf);
2106	if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
2107	{
2108	Assert(pAllocation->pvMem);
2109	D3DLOCKED_RECT lockInfo;
2110	hr = pD3D9Surf->LockRect(&lockInfo, NULL, D3DLOCK_DISCARD);
2111	Assert(hr == S_OK);
2112	if (hr == S_OK)
2113	{
2114	vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /bool bToLockInfo/);
2115	HRESULT tmpHr = pD3D9Surf->UnlockRect();
2116	Assert(tmpHr == S_OK);
2117	}
2118	}
2119	else
2120	{
2121	Assert(!pAllocation->pvMem);
2122	}
2123	pAllocation->pD3DIf = pD3D9Surf;
2124	}
2125	else
2126	{
2127	for (UINT j = 0; j < i; ++j)
2128	{
2129	pRc->aAllocations[j].pD3DIf->Release();
2130	}
2131	break;
2132	}
2133	}
2134	}
2135
2136	if (hr != S_OK)
2137	{
2138	VBoxDispWndDestroy(pAdapter, hWnd);
2139	}
2140	}
2141	}
2142	else if (pResource->Flags.ZBuffer)
2143	{
2144	Assert(pDevice->pDevice9If);
2145	for (UINT i = 0; i < pResource->SurfCount; ++i)
2146	{
2147	PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2148	IDirect3DSurface9 *pD3D9Surf;
2149	hr = pDevice->pDevice9If->CreateDepthStencilSurface(pAllocation->SurfDesc.width,
2150	pAllocation->SurfDesc.height,
2151	vboxDDI2D3DFormat(pResource->Format),
2152	vboxDDI2D3DMultiSampleType(pResource->MultisampleType),
2153	pResource->MultisampleQuality,
2154	TRUE /* @todo: BOOL Discard */,
2155	&pD3D9Surf,
2156	NULL /HANDLE pSharedHandle*/);
2157	Assert(hr == S_OK);
2158	if (hr == S_OK)
2159	{
2160	Assert(pD3D9Surf);
2161	if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
2162	{
2163	Assert(pAllocation->pvMem);
2164	D3DLOCKED_RECT lockInfo;
2165	hr = pD3D9Surf->LockRect(&lockInfo, NULL, D3DLOCK_DISCARD);
2166	Assert(hr == S_OK);
2167	if (hr == S_OK)
2168	{
2169	vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /bool bToLockInfo/);
2170	HRESULT tmpHr = pD3D9Surf->UnlockRect();
2171	Assert(tmpHr == S_OK);
2172	}
2173	}
2174	else
2175	{
2176	Assert(!pAllocation->pvMem);
2177	}
2178	pAllocation->pD3DIf = pD3D9Surf;
2179	}
2180	else
2181	{
2182	for (UINT j = 0; j < i; ++j)
2183	{
2184	pRc->aAllocations[j].pD3DIf->Release();
2185	}
2186	break;
2187	}
2188	}
2189	}
2190	else if (pResource->Flags.VertexBuffer)
2191	{
2192	Assert(pDevice->pDevice9If);
2193	for (UINT i = 0; i < pResource->SurfCount; ++i)
2194	{
2195	PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2196	IDirect3DVertexBuffer9 *pD3D9VBuf;
2197	hr = pDevice->pDevice9If->CreateVertexBuffer(pAllocation->SurfDesc.width,
2198	vboxDDI2D3DUsage(pResource->Flags),
2199	pResource->Fvf,
2200	vboxDDI2D3DPool(pResource->Pool),
2201	&pD3D9VBuf,
2202	NULL /HANDLE pSharedHandle*/);
2203	Assert(hr == S_OK);
2204	if (hr == S_OK)
2205	{
2206	Assert(pD3D9VBuf);
2207	if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
2208	{
2209	Assert(pAllocation->pvMem);
2210	D3DLOCKED_RECT lockInfo;
2211	hr = pD3D9VBuf->Lock(0, pAllocation->SurfDesc.width, &lockInfo.pBits, D3DLOCK_DISCARD);
2212	Assert(hr == S_OK);
2213	if (hr == S_OK)
2214	{
2215	lockInfo.Pitch = pAllocation->SurfDesc.pitch;
2216	vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /bool bToLockInfo/);
2217	HRESULT tmpHr = pD3D9VBuf->Unlock();
2218	Assert(tmpHr == S_OK);
2219	}
2220	}
2221	else
2222	{
2223	Assert(!pAllocation->pvMem);
2224	}
2225	pAllocation->pD3DIf = pD3D9VBuf;
2226	}
2227	else
2228	{
2229	for (UINT j = 0; j < i; ++j)
2230	{
2231	pRc->aAllocations[j].pD3DIf->Release();
2232	}
2233	break;
2234	}
2235	}
2236	}
2237	else if (pResource->Flags.IndexBuffer)
2238	{
2239	Assert(pDevice->pDevice9If);
2240	for (UINT i = 0; i < pResource->SurfCount; ++i)
2241	{
2242	PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2243	CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
2244	IDirect3DIndexBuffer9 *pD3D9IBuf;
2245	hr = pDevice->pDevice9If->CreateIndexBuffer(pSurf->Width,
2246	vboxDDI2D3DUsage(pResource->Flags),
2247	vboxDDI2D3DFormat(pResource->Format),
2248	vboxDDI2D3DPool(pResource->Pool),
2249	&pD3D9IBuf,
2250	NULL /HANDLE pSharedHandle*/
2251	);
2252	Assert(hr == S_OK);
2253	if (hr == S_OK)
2254	{
2255	Assert(pD3D9IBuf);
2256	if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
2257	{
2258	Assert(pAllocation->pvMem);
2259	D3DLOCKED_RECT lockInfo;
2260	hr = pD3D9IBuf->Lock(0, pAllocation->SurfDesc.width, &lockInfo.pBits, D3DLOCK_DISCARD);
2261	Assert(hr == S_OK);
2262	if (hr == S_OK)
2263	{
2264	lockInfo.Pitch = pAllocation->SurfDesc.pitch;
2265	vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /bool bToLockInfo/);
2266	HRESULT tmpHr = pD3D9IBuf->Unlock();
2267	Assert(tmpHr == S_OK);
2268	}
2269	}
2270	else
2271	{
2272	Assert(!pAllocation->pvMem);
2273	}
2274	pAllocation->pD3DIf = pD3D9IBuf;
2275	}
2276	else
2277	{
2278	for (UINT j = 0; j < i; ++j)
2279	{
2280	pRc->aAllocations[j].pD3DIf->Release();
2281	}
2282	break;
2283	}
2284	}
2285	}
2286	else if (pResource->Flags.Texture)
2287	{
2288	Assert(pDevice->pDevice9If);
2289	#ifdef DEBUG
2290	{
2291	uint32_t tstW = pResource->pSurfList[0].Width;
2292	uint32_t tstH = pResource->pSurfList[0].Height;
2293	for (UINT i = 1; i < pResource->SurfCount; ++i)
2294	{
2295	tstW /= 2;
2296	tstH /= 2;
2297	CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
2298	Assert(pSurf->Width == tstW);
2299	Assert(pSurf->Height == tstH);
2300	}
2301	}
2302	#endif
2303
2304	PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0];
2305	CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[0];
2306	IDirect3DTexture9 *pD3DIfTex;
2307	hr = pDevice->pDevice9If->CreateTexture(pSurf->Width,
2308	pSurf->Height,
2309	pResource->SurfCount,
2310	vboxDDI2D3DUsage(pResource->Flags),
2311	vboxDDI2D3DFormat(pResource->Format),
2312	vboxDDI2D3DPool(pResource->Pool),
2313	&pD3DIfTex,
2314	NULL /* HANDLE* pSharedHandle */
2315	);
2316	Assert(hr == S_OK);
2317	if (hr == S_OK)
2318	{
2319	Assert(pD3DIfTex);
2320	if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
2321	{
2322	for (UINT i = 0; i < pResource->SurfCount; ++i)
2323	{
2324	D3DLOCKED_RECT lockInfo;
2325	PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2326	Assert(pAllocation->pvMem);
2327	hr = pD3DIfTex->LockRect(i, &lockInfo, NULL, D3DLOCK_DISCARD);
2328	Assert(hr == S_OK);
2329	if (hr == S_OK)
2330	{
2331	vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /bool bToLockInfo/);
2332	HRESULT tmpHr = pD3DIfTex->UnlockRect(i);
2333	Assert(tmpHr == S_OK);
2334	}
2335	else
2336	{
2337	pD3DIfTex->Release();
2338	break;
2339	}
2340	}
2341	}
2342	pAllocation->pD3DIf = pD3DIfTex;
2343	}
2344	#ifdef DEBUG
2345	else
2346	{
2347	for (UINT i = 0; i < pResource->SurfCount; ++i)
2348	{
2349	PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2350	Assert(!pAllocation->pvMem);
2351	}
2352	}
2353	#endif
2354	}
2355	else
2356	{
2357	Assert(pDevice->pDevice9If);
2358	Assert(0);
2359	}
2360
2361	if (hr == S_OK)
2362	pResource->hResource = pRc;
2363	else
2364	vboxResourceFree(pRc);
2365	}
2366	else
2367	{
2368	hr = E_OUTOFMEMORY;
2369	}
2370
2371	}
2372	else
2373	{
2374	/* allocate buffer for D3DDDICB_ALLOCATE + D3DDDI_ALLOCATIONINFO * numAllocs + PVBOXWDDM_RCINFO with aAllocInfos[numAllocs] */
2375	uint32_t cbBuf = sizeof (D3DDDICB_ALLOCATE);
2376	uint32_t offDdiAllocInfos = (cbBuf + 7) & ~3;
2377	uint32_t cbDdiAllocInfos = sizeof (D3DDDI_ALLOCATIONINFO) * pResource->SurfCount;
2378	cbBuf = offDdiAllocInfos + cbDdiAllocInfos;
2379	uint32_t offRcInfo = (cbBuf + 7) & ~3;
2380	uint32_t cbRcInfo = sizeof (VBOXWDDM_RCINFO);
2381	cbBuf = offRcInfo + cbRcInfo;
2382	uint32_t offAllocInfos = (cbBuf + 7) & ~3;
2383	uint32_t cbAllocInfos = sizeof (VBOXWDDM_ALLOCINFO) * pResource->SurfCount;
2384	cbBuf = offAllocInfos + cbAllocInfos;
2385	uint8_t pvBuf = (uint8_t)RTMemAllocZ(cbBuf);
2386	if (pvBuf)
2387	{
2388	D3DDDICB_ALLOCATE pAllocate = (D3DDDICB_ALLOCATE)pvBuf;
2389	D3DDDI_ALLOCATIONINFO* pDdiAllocInfos = (D3DDDI_ALLOCATIONINFO*)(pvBuf + offDdiAllocInfos);
2390	PVBOXWDDM_RCINFO pRcInfo = (PVBOXWDDM_RCINFO)(pvBuf + offRcInfo);
2391	PVBOXWDDM_ALLOCINFO pAllocInfos = (PVBOXWDDM_ALLOCINFO)(pvBuf + offAllocInfos);
2392	pAllocate->pPrivateDriverData = pRcInfo;
2393	pAllocate->PrivateDriverDataSize = cbRcInfo;
2394	pAllocate->hResource = pResource->hResource;
2395	pAllocate->hKMResource = NULL;
2396	pAllocate->NumAllocations = pResource->SurfCount;
2397	pAllocate->pAllocationInfo = pDdiAllocInfos;
2398
2399	pRcInfo->fFlags = VBOXWDDM_RESOURCE_F_TYPE_GENERIC;
2400	pRcInfo->RcDesc.fFlags = pResource->Flags;
2401	pRcInfo->RcDesc.enmFormat = pResource->Format;
2402	pRcInfo->RcDesc.enmPool = pResource->Pool;
2403	pRcInfo->RcDesc.enmMultisampleType = pResource->MultisampleType;
2404	pRcInfo->RcDesc.MultisampleQuality = pResource->MultisampleQuality;
2405	pRcInfo->RcDesc.MipLevels = pResource->MipLevels;
2406	pRcInfo->RcDesc.Fvf = pResource->Fvf;
2407	pRcInfo->RcDesc.VidPnSourceId = pResource->VidPnSourceId;
2408	pRcInfo->RcDesc.RefreshRate = pResource->RefreshRate;
2409	pRcInfo->RcDesc.enmRotation = pResource->Rotation;
2410	pRcInfo->cAllocInfos = pResource->SurfCount;
2411
2412	for (UINT i = 0; i < pResource->SurfCount; ++i)
2413	{
2414	PVBOXWDDM_ALLOCINFO pAllocInfo = &pAllocInfos[i];
2415	D3DDDI_ALLOCATIONINFO* pDdiAllocInfo = &pDdiAllocInfos[i];
2416	CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
2417	pDdiAllocInfo->hAllocation = NULL;
2418	pDdiAllocInfo->pSystemMem = pSurf->pSysMem;
2419	Assert((!!(pSurf->pSysMem)) == (pResource->Pool == D3DDDIPOOL_SYSTEMMEM));
2420	pDdiAllocInfo->pPrivateDriverData = pAllocInfo;
2421	pDdiAllocInfo->PrivateDriverDataSize = sizeof (VBOXWDDM_ALLOCINFO);
2422	pDdiAllocInfo->VidPnSourceId = pResource->VidPnSourceId;
2423	pDdiAllocInfo->Flags.Value = 0;
2424	if (pResource->Flags.Primary)
2425	pDdiAllocInfo->Flags.Primary = 1;
2426
2427	pAllocInfo->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC;
2428	pAllocInfo->SurfDesc.width = pSurf->Width;
2429	pAllocInfo->SurfDesc.height = pSurf->Height;
2430	pAllocInfo->SurfDesc.format = pResource->Format;
2431	pAllocInfo->SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pResource->Format);
2432
2433	if (pSurf->SysMemPitch)
2434	{
2435	pAllocInfo->SurfDesc.pitch = pSurf->SysMemPitch;
2436	#ifdef DEBUG
2437	UINT tst = vboxWddmCalcPitch(pSurf->Width, pAllocInfo->SurfDesc.bpp);
2438	Assert(tst == pSurf->SysMemPitch);
2439	#endif
2440	}
2441	else
2442	pAllocInfo->SurfDesc.pitch = vboxWddmCalcPitch(pSurf->Width, pAllocInfo->SurfDesc.bpp);
2443
2444	pAllocInfo->SurfDesc.cbSize = pAllocInfo->SurfDesc.pitch * pAllocInfo->SurfDesc.height;
2445	pAllocInfo->SurfDesc.depth = pSurf->Depth;
2446	pAllocInfo->SurfDesc.slicePitch = pSurf->SysMemSlicePitch;
2447	pAllocInfo->SurfDesc.VidPnSourceId = pResource->VidPnSourceId;
2448	pAllocInfo->SurfDesc.RefreshRate = pResource->RefreshRate;
2449	}
2450
2451	hr = pDevice->RtCallbacks.pfnAllocateCb(pDevice->hDevice, pAllocate);
2452	Assert(hr == S_OK);
2453	if (hr == S_OK)
2454	{
2455	Assert(pAllocate->hKMResource);
2456	PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(pResource->SurfCount);
2457	Assert(pRc);
2458	if (pRc)
2459	{
2460	pRc->hResource = pResource->hResource;
2461	pRc->hKMResource = pAllocate->hKMResource;
2462	pRc->pDevice = pDevice;
2463	pRc->fFlags = pRcInfo->fFlags;
2464	pRc->RcDesc = pRcInfo->RcDesc;
2465	pRc->cAllocations = pRcInfo->cAllocInfos;
2466	for (UINT i = 0; i < pRcInfo->cAllocInfos; ++i)
2467	{
2468	PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2469	D3DDDI_ALLOCATIONINFO* pDdiAllocInfo = &pDdiAllocInfos[i];
2470	PVBOXWDDM_ALLOCINFO pAllocInfo = &pAllocInfos[i];
2471	CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
2472	pAllocation->hAllocation = pDdiAllocInfo->hAllocation;
2473	pAllocation->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC;
2474	pAllocation->pvMem = (void*)pSurf->pSysMem;
2475	pAllocation->SurfDesc = pAllocInfo->SurfDesc;
2476	}
2477
2478	pResource->hResource = pRc;
2479	// vboxResourceFree(pRc);
2480	}
2481	else
2482	{
2483	hr = E_OUTOFMEMORY;
2484	}
2485	}
2486
2487	RTMemFree(pvBuf);
2488	}
2489	else
2490	{
2491	hr = E_OUTOFMEMORY;
2492	}
2493	}
2494
2495	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2496	return hr;
2497	}
2498
2499	static HRESULT APIENTRY vboxWddmDDevDestroyResource(HANDLE hDevice, HANDLE hResource)
2500	{
2501	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2502	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2503	PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter;
2504	PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)hResource;
2505
2506	HRESULT hr = S_OK;
2507
2508	Assert(pDevice);
2509	Assert(hResource);
2510
2511	if (VBOXDISPMODE_IS_3D(pAdapter))
2512	{
2513	if (pRc->RcDesc.fFlags.RenderTarget)
2514	{
2515	Assert(pDevice->hWnd);
2516	Assert(pDevice->pDevice9If);
2517	pDevice->pDevice9If->Release();
2518	HRESULT tmpHr = VBoxDispWndDestroy(pAdapter, pDevice->hWnd);
2519	Assert(tmpHr == S_OK);
2520	}
2521
2522	for (UINT i = 0; i < pRc->cAllocations; ++i)
2523	{
2524	PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];
2525	if (pAlloc->pD3DIf)
2526	pAlloc->pD3DIf->Release();
2527	}
2528	}
2529	else
2530	{
2531	if (!(pRc->fFlags & VBOXWDDM_RESOURCE_F_OPENNED))
2532	{
2533	D3DDDICB_DEALLOCATE Dealloc;
2534	Dealloc.hResource = pRc->hResource;
2535	Assert(pRc->hResource);
2536	/* according to the docs the below two are ignored in case we set the hResource */
2537	Dealloc.NumAllocations = 0;
2538	Dealloc.HandleList = NULL;
2539	hr = pDevice->RtCallbacks.pfnDeallocateCb(pDevice->hDevice, &Dealloc);
2540	Assert(hr == S_OK);
2541	}
2542	}
2543
2544	vboxResourceFree(pRc);
2545	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2546	return hr;
2547	}
2548	static HRESULT APIENTRY vboxWddmDDevSetDisplayMode(HANDLE hDevice, CONST D3DDDIARG_SETDISPLAYMODE* pData)
2549	{
2550	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2551	AssertBreakpoint();
2552	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2553	return E_FAIL;
2554	}
2555	static HRESULT APIENTRY vboxWddmDDevPresent(HANDLE hDevice, CONST D3DDDIARG_PRESENT* pData)
2556	{
2557	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2558	AssertBreakpoint();
2559	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2560	return E_FAIL;
2561	}
2562	static HRESULT APIENTRY vboxWddmDDevFlush(HANDLE hDevice)
2563	{
2564	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2565	AssertBreakpoint();
2566	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2567	return E_FAIL;
2568	}
2569
2570	AssertCompile(sizeof (D3DDDIVERTEXELEMENT) == sizeof (D3DVERTEXELEMENT9));
2571	AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Stream) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Stream));
2572	AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Offset) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Offset));
2573	AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Type) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Type));
2574	AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Method) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Method));
2575	AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Usage) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Usage));
2576	AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, UsageIndex) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, UsageIndex));
2577
2578	AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Stream) == RT_OFFSETOF(D3DVERTEXELEMENT9, Stream));
2579	AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Offset) == RT_OFFSETOF(D3DVERTEXELEMENT9, Offset));
2580	AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Type) == RT_OFFSETOF(D3DVERTEXELEMENT9, Type));
2581	AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Method) == RT_OFFSETOF(D3DVERTEXELEMENT9, Method));
2582	AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Usage) == RT_OFFSETOF(D3DVERTEXELEMENT9, Usage));
2583	AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, UsageIndex) == RT_OFFSETOF(D3DVERTEXELEMENT9, UsageIndex));
2584
2585	static HRESULT APIENTRY vboxWddmDDevCreateVertexShaderDecl(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERDECL* pData, CONST D3DDDIVERTEXELEMENT* pVertexElements)
2586	{
2587	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2588	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2589	Assert(pDevice);
2590	Assert(pDevice->pDevice9If);
2591	IDirect3DVertexDeclaration9 *pDecl;
2592	static D3DVERTEXELEMENT9 DeclEnd = D3DDECL_END();
2593	Assert(!memcmp(&DeclEnd, &pVertexElements[pData->NumVertexElements], sizeof (DeclEnd)));
2594	HRESULT hr = pDevice->pDevice9If->CreateVertexDeclaration(
2595	(CONST D3DVERTEXELEMENT9*)pVertexElements,
2596	&pDecl
2597	);
2598	Assert(hr == S_OK);
2599	if (hr == S_OK)
2600	{
2601	Assert(pDecl);
2602	pData->ShaderHandle = pDecl;
2603	}
2604	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2605	return hr;
2606	}
2607	static HRESULT APIENTRY vboxWddmDDevSetVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
2608	{
2609	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2610	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2611	Assert(pDevice);
2612	Assert(pDevice->pDevice9If);
2613	IDirect3DVertexDeclaration9 pDecl = (IDirect3DVertexDeclaration9)hShaderHandle;
2614	Assert(pDecl);
2615	HRESULT hr = pDevice->pDevice9If->SetVertexDeclaration(pDecl);
2616	Assert(hr == S_OK);
2617	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2618	return hr;
2619	}
2620	static HRESULT APIENTRY vboxWddmDDevDeleteVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
2621	{
2622	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2623	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2624	Assert(pDevice);
2625	Assert(pDevice->pDevice9If);
2626	IDirect3DVertexDeclaration9 pDecl = (IDirect3DVertexDeclaration9)hShaderHandle;
2627	HRESULT hr = pDecl->Release();
2628	Assert(hr == S_OK);
2629	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2630	return hr;
2631	}
2632	static HRESULT APIENTRY vboxWddmDDevCreateVertexShaderFunc(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERFUNC* pData, CONST UINT* pCode)
2633	{
2634	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2635	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2636	Assert(pDevice);
2637	Assert(pDevice->pDevice9If);
2638	IDirect3DVertexShader9 *pShader;
2639	Assert(((UINT)((uint8_t)pCode + pData->Size-4)) == 0x0000FFFF / end token */);
2640	HRESULT hr = pDevice->pDevice9If->CreateVertexShader((const DWORD *)pCode, &pShader);
2641	Assert(hr == S_OK);
2642	if (hr == S_OK)
2643	{
2644	Assert(pShader);
2645	pData->ShaderHandle = pShader;
2646	}
2647	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2648	return hr;
2649	}
2650	static HRESULT APIENTRY vboxWddmDDevSetVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
2651	{
2652	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2653	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2654	Assert(pDevice);
2655	Assert(pDevice->pDevice9If);
2656	IDirect3DVertexShader9 pShader = (IDirect3DVertexShader9)hShaderHandle;
2657	Assert(pShader);
2658	HRESULT hr = pDevice->pDevice9If->SetVertexShader(pShader);
2659	Assert(hr == S_OK);
2660	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2661	return hr;
2662	}
2663	static HRESULT APIENTRY vboxWddmDDevDeleteVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
2664	{
2665	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2666	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2667	Assert(pDevice);
2668	Assert(pDevice->pDevice9If);
2669	IDirect3DVertexShader9 pShader = (IDirect3DVertexShader9)hShaderHandle;
2670	HRESULT hr = pShader->Release();
2671	Assert(hr == S_OK);
2672	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2673	return hr;
2674	}
2675	static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTI* pData, CONST INT* pRegisters)
2676	{
2677	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2678	AssertBreakpoint();
2679	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2680	return E_FAIL;
2681	}
2682	static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTB* pData, CONST BOOL* pRegisters)
2683	{
2684	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2685	AssertBreakpoint();
2686	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2687	return E_FAIL;
2688	}
2689	static HRESULT APIENTRY vboxWddmDDevSetScissorRect(HANDLE hDevice, CONST RECT* pRect)
2690	{
2691	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2692	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2693	Assert(pDevice);
2694	Assert(pDevice->pDevice9If);
2695	HRESULT hr = pDevice->pDevice9If->SetScissorRect(pRect);
2696	Assert(hr == S_OK);
2697	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2698	return hr;
2699	}
2700	static HRESULT APIENTRY vboxWddmDDevSetStreamSource(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCE* pData)
2701	{
2702	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2703	AssertBreakpoint();
2704	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2705	return E_FAIL;
2706	}
2707	static HRESULT APIENTRY vboxWddmDDevSetStreamSourceFreq(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEFREQ* pData)
2708	{
2709	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2710	AssertBreakpoint();
2711	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2712	return E_FAIL;
2713	}
2714	static HRESULT APIENTRY vboxWddmDDevSetConvolutionKernelMono(HANDLE hDevice, CONST D3DDDIARG_SETCONVOLUTIONKERNELMONO* pData)
2715	{
2716	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2717	AssertBreakpoint();
2718	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2719	return E_FAIL;
2720	}
2721	static HRESULT APIENTRY vboxWddmDDevComposeRects(HANDLE hDevice, CONST D3DDDIARG_COMPOSERECTS* pData)
2722	{
2723	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2724	AssertBreakpoint();
2725	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2726	return E_FAIL;
2727	}
2728	static HRESULT APIENTRY vboxWddmDDevBlt(HANDLE hDevice, CONST D3DDDIARG_BLT* pData)
2729	{
2730	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2731	AssertBreakpoint();
2732	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2733	return E_FAIL;
2734	}
2735	static HRESULT APIENTRY vboxWddmDDevColorFill(HANDLE hDevice, CONST D3DDDIARG_COLORFILL* pData)
2736	{
2737	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2738	AssertBreakpoint();
2739	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2740	return E_FAIL;
2741	}
2742	static HRESULT APIENTRY vboxWddmDDevDepthFill(HANDLE hDevice, CONST D3DDDIARG_DEPTHFILL* pData)
2743	{
2744	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2745	AssertBreakpoint();
2746	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2747	return E_FAIL;
2748	}
2749	static HRESULT APIENTRY vboxWddmDDevCreateQuery(HANDLE hDevice, D3DDDIARG_CREATEQUERY* pData)
2750	{
2751	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2752	AssertBreakpoint();
2753	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2754	return E_FAIL;
2755	}
2756	static HRESULT APIENTRY vboxWddmDDevDestroyQuery(HANDLE hDevice, HANDLE hQuery)
2757	{
2758	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2759	AssertBreakpoint();
2760	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2761	return E_FAIL;
2762	}
2763	static HRESULT APIENTRY vboxWddmDDevIssueQuery(HANDLE hDevice, CONST D3DDDIARG_ISSUEQUERY* pData)
2764	{
2765	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2766	AssertBreakpoint();
2767	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2768	return E_FAIL;
2769	}
2770	static HRESULT APIENTRY vboxWddmDDevGetQueryData(HANDLE hDevice, CONST D3DDDIARG_GETQUERYDATA* pData)
2771	{
2772	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2773	AssertBreakpoint();
2774	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2775	return E_FAIL;
2776	}
2777	static HRESULT APIENTRY vboxWddmDDevSetRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETRENDERTARGET* pData)
2778	{
2779	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2780	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2781	Assert(pDevice);
2782	Assert(pDevice->pDevice9If);
2783	PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hRenderTarget;
2784	Assert(pRc);
2785	Assert(pData->SubResourceIndex < pRc->cAllocations);
2786	IDirect3DSurface9 pD3D9Surf = (IDirect3DSurface9)pRc->aAllocations[pData->SubResourceIndex].pD3DIf;
2787	Assert(pD3D9Surf);
2788	HRESULT hr = pDevice->pDevice9If->SetRenderTarget(pData->RenderTargetIndex, pD3D9Surf);
2789	Assert(hr == S_OK);
2790	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2791	return hr;
2792	}
2793	static HRESULT APIENTRY vboxWddmDDevSetDepthStencil(HANDLE hDevice, CONST D3DDDIARG_SETDEPTHSTENCIL* pData)
2794	{
2795	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2796	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2797	Assert(pDevice);
2798	Assert(pDevice->pDevice9If);
2799	PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hZBuffer;
2800	Assert(pRc);
2801	Assert(pRc->cAllocations == 1);
2802	IDirect3DSurface9 pD3D9Surf = (IDirect3DSurface9)pRc->aAllocations[0].pD3DIf;
2803	Assert(pD3D9Surf);
2804	HRESULT hr = pDevice->pDevice9If->SetDepthStencilSurface(pD3D9Surf);
2805	Assert(hr == S_OK);
2806	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2807	return hr;
2808	}
2809	static HRESULT APIENTRY vboxWddmDDevGenerateMipSubLevels(HANDLE hDevice, CONST D3DDDIARG_GENERATEMIPSUBLEVELS* pData)
2810	{
2811	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2812	AssertBreakpoint();
2813	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2814	return E_FAIL;
2815	}
2816	static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTI* pData, CONST INT* pRegisters)
2817	{
2818	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2819	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2820	Assert(pDevice);
2821	Assert(pDevice->pDevice9If);
2822	HRESULT hr = pDevice->pDevice9If->SetPixelShaderConstantI(pData->Register, pRegisters, pData->Count);
2823	Assert(hr == S_OK);
2824	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2825	return hr;
2826	}
2827	static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTB* pData, CONST BOOL* pRegisters)
2828	{
2829	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2830	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2831	Assert(pDevice);
2832	Assert(pDevice->pDevice9If);
2833	HRESULT hr = pDevice->pDevice9If->SetPixelShaderConstantB(pData->Register, pRegisters, pData->Count);
2834	Assert(hr == S_OK);
2835	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2836	return hr;
2837	}
2838	static HRESULT APIENTRY vboxWddmDDevCreatePixelShader(HANDLE hDevice, D3DDDIARG_CREATEPIXELSHADER* pData, CONST UINT* pCode)
2839	{
2840	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2841	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2842	Assert(pDevice);
2843	Assert(pDevice->pDevice9If);
2844	IDirect3DPixelShader9 *pShader;
2845	Assert(((UINT)((uint8_t)pCode + pData->CodeSize-4)) == 0x0000FFFF / end token */);
2846	HRESULT hr = pDevice->pDevice9If->CreatePixelShader((const DWORD *)pCode, &pShader);
2847	Assert(hr == S_OK);
2848	if (hr == S_OK)
2849	{
2850	Assert(pShader);
2851	pData->ShaderHandle = pShader;
2852	}
2853	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2854	return hr;
2855	}
2856	static HRESULT APIENTRY vboxWddmDDevDeletePixelShader(HANDLE hDevice, HANDLE hShaderHandle)
2857	{
2858	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2859	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2860	Assert(pDevice);
2861	Assert(pDevice->pDevice9If);
2862	IDirect3DPixelShader9 pShader = (IDirect3DPixelShader9)hShaderHandle;
2863	HRESULT hr = pShader->Release();
2864	Assert(hr == S_OK);
2865	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2866	return hr;
2867	}
2868	static HRESULT APIENTRY vboxWddmDDevCreateDecodeDevice(HANDLE hDevice, D3DDDIARG_CREATEDECODEDEVICE* pData)
2869	{
2870	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2871	AssertBreakpoint();
2872	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2873	return E_FAIL;
2874	}
2875	static HRESULT APIENTRY vboxWddmDDevDestroyDecodeDevice(HANDLE hDevice, HANDLE hDecodeDevice)
2876	{
2877	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2878	AssertBreakpoint();
2879	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2880	return E_FAIL;
2881	}
2882	static HRESULT APIENTRY vboxWddmDDevSetDecodeRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETDECODERENDERTARGET* pData)
2883	{
2884	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2885	AssertBreakpoint();
2886	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2887	return E_FAIL;
2888	}
2889	static HRESULT APIENTRY vboxWddmDDevDecodeBeginFrame(HANDLE hDevice, D3DDDIARG_DECODEBEGINFRAME* pData)
2890	{
2891	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2892	AssertBreakpoint();
2893	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2894	return E_FAIL;
2895	}
2896	static HRESULT APIENTRY vboxWddmDDevDecodeEndFrame(HANDLE hDevice, D3DDDIARG_DECODEENDFRAME* pData)
2897	{
2898	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2899	AssertBreakpoint();
2900	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2901	return E_FAIL;
2902	}
2903	static HRESULT APIENTRY vboxWddmDDevDecodeExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXECUTE* pData)
2904	{
2905	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2906	AssertBreakpoint();
2907	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2908	return E_FAIL;
2909	}
2910	static HRESULT APIENTRY vboxWddmDDevDecodeExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXTENSIONEXECUTE* pData)
2911	{
2912	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2913	AssertBreakpoint();
2914	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2915	return E_FAIL;
2916	}
2917	static HRESULT APIENTRY vboxWddmDDevCreateVideoProcessDevice(HANDLE hDevice, D3DDDIARG_CREATEVIDEOPROCESSDEVICE* pData)
2918	{
2919	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2920	AssertBreakpoint();
2921	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2922	return E_FAIL;
2923	}
2924	static HRESULT APIENTRY vboxWddmDDevDestroyVideoProcessDevice(HANDLE hDevice, HANDLE hVideoProcessor)
2925	{
2926	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2927	AssertBreakpoint();
2928	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2929	return E_FAIL;
2930	}
2931	static HRESULT APIENTRY vboxWddmDDevVideoProcessBeginFrame(HANDLE hDevice, HANDLE hVideoProcess)
2932	{
2933	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2934	AssertBreakpoint();
2935	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2936	return E_FAIL;
2937	}
2938	static HRESULT APIENTRY vboxWddmDDevVideoProcessEndFrame(HANDLE hDevice, D3DDDIARG_VIDEOPROCESSENDFRAME* pData)
2939	{
2940	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2941	AssertBreakpoint();
2942	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2943	return E_FAIL;
2944	}
2945	static HRESULT APIENTRY vboxWddmDDevSetVideoProcessRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETVIDEOPROCESSRENDERTARGET* pData)
2946	{
2947	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2948	AssertBreakpoint();
2949	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2950	return E_FAIL;
2951	}
2952	static HRESULT APIENTRY vboxWddmDDevVideoProcessBlt(HANDLE hDevice, CONST D3DDDIARG_VIDEOPROCESSBLT* pData)
2953	{
2954	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2955	AssertBreakpoint();
2956	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2957	return E_FAIL;
2958	}
2959	static HRESULT APIENTRY vboxWddmDDevCreateExtensionDevice(HANDLE hDevice, D3DDDIARG_CREATEEXTENSIONDEVICE* pData)
2960	{
2961	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2962	AssertBreakpoint();
2963	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2964	return E_FAIL;
2965	}
2966	static HRESULT APIENTRY vboxWddmDDevDestroyExtensionDevice(HANDLE hDevice, HANDLE hExtension)
2967	{
2968	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2969	AssertBreakpoint();
2970	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2971	return E_FAIL;
2972	}
2973	static HRESULT APIENTRY vboxWddmDDevExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_EXTENSIONEXECUTE* pData)
2974	{
2975	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2976	AssertBreakpoint();
2977	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2978	return E_FAIL;
2979	}
2980	static HRESULT APIENTRY vboxWddmDDevDestroyDevice(IN HANDLE hDevice)
2981	{
2982	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2983
2984	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2985	if (pDevice->DefaultContext.ContextInfo.hContext)
2986	{
2987	D3DDDICB_DESTROYCONTEXT DestroyContext;
2988	DestroyContext.hContext = pDevice->DefaultContext.ContextInfo.hContext;
2989	HRESULT tmpHr = pDevice->RtCallbacks.pfnDestroyContextCb(pDevice->hDevice, &DestroyContext);
2990	Assert(tmpHr == S_OK);
2991	}
2992	RTMemFree(hDevice);
2993	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2994	return S_OK;
2995	}
2996	static HRESULT APIENTRY vboxWddmDDevCreateOverlay(HANDLE hDevice, D3DDDIARG_CREATEOVERLAY* 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 vboxWddmDDevUpdateOverlay(HANDLE hDevice, CONST D3DDDIARG_UPDATEOVERLAY* pData)
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 vboxWddmDDevFlipOverlay(HANDLE hDevice, CONST D3DDDIARG_FLIPOVERLAY* 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 vboxWddmDDevGetOverlayColorControls(HANDLE hDevice, D3DDDIARG_GETOVERLAYCOLORCONTROLS* 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 vboxWddmDDevSetOverlayColorControls(HANDLE hDevice, CONST D3DDDIARG_SETOVERLAYCOLORCONTROLS* pData)
3025	{
3026	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3027	AssertBreakpoint();
3028	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3029	return E_FAIL;
3030	}
3031	static HRESULT APIENTRY vboxWddmDDevDestroyOverlay(HANDLE hDevice, CONST D3DDDIARG_DESTROYOVERLAY* pData)
3032	{
3033	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3034	AssertBreakpoint();
3035	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3036	return E_FAIL;
3037	}
3038	static HRESULT APIENTRY vboxWddmDDevQueryResourceResidency(HANDLE hDevice, CONST D3DDDIARG_QUERYRESOURCERESIDENCY* pData)
3039	{
3040	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3041	AssertBreakpoint();
3042	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3043	return E_FAIL;
3044	}
3045
3046	static HRESULT vboxAllocationInit(PVBOXWDDMDISP_ALLOCATION pAlloc, D3DDDI_OPENALLOCATIONINFO *pInfo)
3047	{
3048	HRESULT hr = S_OK;
3049	pAlloc->hAllocation = pInfo->hAllocation;
3050	Assert(pInfo->PrivateDriverDataSize == sizeof (VBOXWDDM_ALLOCINFO));
3051	Assert(pInfo->pPrivateDriverData);
3052	if (pInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO))
3053	{
3054	PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pInfo->pPrivateDriverData;
3055	pAlloc->enmType = pAllocInfo->enmType;
3056	Assert(pAllocInfo->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
3057	\|\| VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE
3058	\|\| VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE);
3059	pAlloc->pvMem = NULL;
3060	pAlloc->SurfDesc = pAllocInfo->SurfDesc;
3061	}
3062	else
3063	{
3064	vboxVDbgPrintR((__FUNCTION__": ERROR: PrivateDriverDataSize(%d) < (%d)\n", pInfo->PrivateDriverDataSize, sizeof (VBOXWDDM_ALLOCINFO)));
3065	hr = E_INVALIDARG;
3066	}
3067	return hr;
3068	}
3069
3070	static HRESULT APIENTRY vboxWddmDDevOpenResource(HANDLE hDevice, D3DDDIARG_OPENRESOURCE* pData)
3071	{
3072	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3073	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3074	HRESULT hr = S_OK;
3075
3076	Assert(pDevice);
3077	Assert(pData->NumAllocations);
3078	PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(pData->NumAllocations);
3079	Assert(pRc);
3080	if (pRc)
3081	{
3082	pRc->hResource = pData->hResource;
3083	pRc->hKMResource = pData->hKMResource;
3084	pRc->pDevice = pDevice;
3085	pRc->RcDesc.enmRotation = pData->Rotation;
3086	pRc->fFlags = VBOXWDDM_RESOURCE_F_OPENNED;
3087	if (!pData->pPrivateDriverData \|\| !pData->PrivateDriverDataSize)
3088	{
3089	/* this is a "standard" allocation resource */
3090
3091	/* both should be actually zero */
3092	Assert(!pData->pPrivateDriverData && !pData->PrivateDriverDataSize);
3093	pRc->RcDesc.enmPool = D3DDDIPOOL_LOCALVIDMEM;
3094	pRc->RcDesc.enmMultisampleType = D3DDDIMULTISAMPLE_NONE;
3095	pRc->RcDesc.MultisampleQuality = 0;
3096	pRc->RcDesc.MipLevels = 0;
3097	pRc->RcDesc.Fvf;
3098	pRc->RcDesc.fFlags.Value = 0;
3099
3100	Assert(pData->NumAllocations);
3101	D3DDDI_OPENALLOCATIONINFO* pDdiAllocInfo = &pData->pOpenAllocationInfo[0];
3102	Assert(pDdiAllocInfo->pPrivateDriverData);
3103	Assert(pDdiAllocInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO));
3104	if (pDdiAllocInfo->pPrivateDriverData && pDdiAllocInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO))
3105	{
3106	PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pDdiAllocInfo->pPrivateDriverData;
3107	switch(pAllocInfo->enmType)
3108	{
3109	case VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE:
3110	pRc->RcDesc.fFlags.Primary = 1;
3111	case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
3112	case VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE:
3113	pRc->RcDesc.enmFormat = pAllocInfo->SurfDesc.format;
3114	pRc->RcDesc.VidPnSourceId = pAllocInfo->SurfDesc.VidPnSourceId;
3115	pRc->RcDesc.RefreshRate = pAllocInfo->SurfDesc.RefreshRate;
3116	break;
3117	default:
3118	AssertBreakpoint();
3119	hr = E_INVALIDARG;
3120	}
3121	}
3122	else
3123	hr = E_INVALIDARG;
3124	}
3125	else
3126	{
3127	/* this is a "generic" resource whose creation is initiaded by the UMD */
3128	Assert(pData->PrivateDriverDataSize == sizeof (VBOXWDDM_RCINFO));
3129	if (pData->PrivateDriverDataSize >= sizeof (VBOXWDDM_RCINFO))
3130	{
3131	VBOXWDDM_RCINFO pRcInfo = (VBOXWDDM_RCINFO)pData->pPrivateDriverData;
3132	Assert(pRcInfo->fFlags == VBOXWDDM_RESOURCE_F_TYPE_GENERIC);
3133	Assert(pRcInfo->cAllocInfos == pData->NumAllocations);
3134	pRc->fFlags = pRcInfo->fFlags \| VBOXWDDM_RESOURCE_F_OPENNED;
3135	pRc->RcDesc = pRcInfo->RcDesc;
3136	pRc->cAllocations = pData->NumAllocations;
3137	}
3138	else
3139	hr = E_INVALIDARG;
3140	}
3141
3142	if (hr == S_OK)
3143	{
3144	for (UINT i = 0; i < pData->NumAllocations; ++i)
3145	{
3146	hr = vboxAllocationInit(&pRc->aAllocations[i], &pData->pOpenAllocationInfo[i]);
3147	Assert(hr == S_OK);
3148	if (hr != S_OK)
3149	break;
3150	}
3151	}
3152
3153	if (hr == S_OK)
3154	pData->hResource = pRc;
3155	else
3156	vboxResourceFree(pRc);
3157	}
3158	else
3159	{
3160	vboxVDbgPrintR((__FUNCTION__": vboxResourceAlloc failed for hDevice(0x%p), NumAllocations(%d)\n", hDevice, pData->NumAllocations));
3161	hr = E_OUTOFMEMORY;
3162	}
3163
3164	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3165	return hr;
3166	}
3167	static HRESULT APIENTRY vboxWddmDDevGetCaptureAllocationHandle(HANDLE hDevice, D3DDDIARG_GETCAPTUREALLOCATIONHANDLE* pData)
3168	{
3169	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3170	AssertBreakpoint();
3171	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3172	return E_FAIL;
3173	}
3174
3175	static HRESULT APIENTRY vboxWddmDDevCaptureToSysMem(HANDLE hDevice, CONST D3DDDIARG_CAPTURETOSYSMEM* pData)
3176	{
3177	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3178	AssertBreakpoint();
3179	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3180	return E_FAIL;
3181	}
3182
3183	static HRESULT APIENTRY vboxWddmDispCreateDevice (IN HANDLE hAdapter, IN D3DDDIARG_CREATEDEVICE* pCreateData)
3184	{
3185	HRESULT hr = S_OK;
3186	vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p), Interface(%d), Version(%d)\n", hAdapter, pCreateData->Interface, pCreateData->Version));
3187
3188	// AssertBreakpoint();
3189
3190	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)RTMemAllocZ(sizeof (VBOXWDDMDISP_DEVICE));
3191	if (pDevice)
3192	{
3193	PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
3194
3195	pDevice->hDevice = pCreateData->hDevice;
3196	pDevice->pAdapter = pAdapter;
3197	pDevice->u32IfVersion = pCreateData->Interface;
3198	pDevice->uRtVersion = pCreateData->Version;
3199	pDevice->RtCallbacks = *pCreateData->pCallbacks;
3200	pDevice->pvCmdBuffer = pCreateData->pCommandBuffer;
3201	pDevice->cbCmdBuffer = pCreateData->CommandBufferSize;
3202	pDevice->fFlags = pCreateData->Flags;
3203	/* Set Viewport to some default values */
3204	pDevice->ViewPort.X = 0;
3205	pDevice->ViewPort.Y = 0;
3206	pDevice->ViewPort.Width = 1;
3207	pDevice->ViewPort.Height = 1;
3208	pDevice->ViewPort.MinZ = 0.;
3209	pDevice->ViewPort.MaxZ = 1.;
3210
3211	Assert(!pCreateData->AllocationListSize);
3212	Assert(!pCreateData->PatchLocationListSize);
3213
3214	pCreateData->hDevice = pDevice;
3215
3216	pCreateData->pDeviceFuncs->pfnSetRenderState = vboxWddmDDevSetRenderState;
3217	pCreateData->pDeviceFuncs->pfnUpdateWInfo = vboxWddmDDevUpdateWInfo;
3218	pCreateData->pDeviceFuncs->pfnValidateDevice = vboxWddmDDevValidateDevice;
3219	pCreateData->pDeviceFuncs->pfnSetTextureStageState = vboxWddmDDevSetTextureStageState;
3220	pCreateData->pDeviceFuncs->pfnSetTexture = vboxWddmDDevSetTexture;
3221	pCreateData->pDeviceFuncs->pfnSetPixelShader = vboxWddmDDevSetPixelShader;
3222	pCreateData->pDeviceFuncs->pfnSetPixelShaderConst = vboxWddmDDevSetPixelShaderConst;
3223	pCreateData->pDeviceFuncs->pfnSetStreamSourceUm = vboxWddmDDevSetStreamSourceUm;
3224	pCreateData->pDeviceFuncs->pfnSetIndices = vboxWddmDDevSetIndices;
3225	pCreateData->pDeviceFuncs->pfnSetIndicesUm = vboxWddmDDevSetIndicesUm;
3226	pCreateData->pDeviceFuncs->pfnDrawPrimitive = vboxWddmDDevDrawPrimitive;
3227	pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive = vboxWddmDDevDrawIndexedPrimitive;
3228	pCreateData->pDeviceFuncs->pfnDrawRectPatch = vboxWddmDDevDrawRectPatch;
3229	pCreateData->pDeviceFuncs->pfnDrawTriPatch = vboxWddmDDevDrawTriPatch;
3230	pCreateData->pDeviceFuncs->pfnDrawPrimitive2 = vboxWddmDDevDrawPrimitive2;
3231	pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive2 = vboxWddmDDevDrawIndexedPrimitive2;
3232	pCreateData->pDeviceFuncs->pfnVolBlt = vboxWddmDDevVolBlt;
3233	pCreateData->pDeviceFuncs->pfnBufBlt = vboxWddmDDevBufBlt;
3234	pCreateData->pDeviceFuncs->pfnTexBlt = vboxWddmDDevTexBlt;
3235	pCreateData->pDeviceFuncs->pfnStateSet = vboxWddmDDevStateSet;
3236	pCreateData->pDeviceFuncs->pfnSetPriority = vboxWddmDDevSetPriority;
3237	pCreateData->pDeviceFuncs->pfnClear = vboxWddmDDevClear;
3238	pCreateData->pDeviceFuncs->pfnUpdatePalette = vboxWddmDDevUpdatePalette;
3239	pCreateData->pDeviceFuncs->pfnSetPalette = vboxWddmDDevSetPalette;
3240	pCreateData->pDeviceFuncs->pfnSetVertexShaderConst = vboxWddmDDevSetVertexShaderConst;
3241	pCreateData->pDeviceFuncs->pfnMultiplyTransform = vboxWddmDDevMultiplyTransform;
3242	pCreateData->pDeviceFuncs->pfnSetTransform = vboxWddmDDevSetTransform;
3243	pCreateData->pDeviceFuncs->pfnSetViewport = vboxWddmDDevSetViewport;
3244	pCreateData->pDeviceFuncs->pfnSetZRange = vboxWddmDDevSetZRange;
3245	pCreateData->pDeviceFuncs->pfnSetMaterial = vboxWddmDDevSetMaterial;
3246	pCreateData->pDeviceFuncs->pfnSetLight = vboxWddmDDevSetLight;
3247	pCreateData->pDeviceFuncs->pfnCreateLight = vboxWddmDDevCreateLight;
3248	pCreateData->pDeviceFuncs->pfnDestroyLight = vboxWddmDDevDestroyLight;
3249	pCreateData->pDeviceFuncs->pfnSetClipPlane = vboxWddmDDevSetClipPlane;
3250	pCreateData->pDeviceFuncs->pfnGetInfo = vboxWddmDDevGetInfo;
3251	pCreateData->pDeviceFuncs->pfnLock = vboxWddmDDevLock;
3252	pCreateData->pDeviceFuncs->pfnUnlock = vboxWddmDDevUnlock;
3253	pCreateData->pDeviceFuncs->pfnCreateResource = vboxWddmDDevCreateResource;
3254	pCreateData->pDeviceFuncs->pfnDestroyResource = vboxWddmDDevDestroyResource;
3255	pCreateData->pDeviceFuncs->pfnSetDisplayMode = vboxWddmDDevSetDisplayMode;
3256	pCreateData->pDeviceFuncs->pfnPresent = vboxWddmDDevPresent;
3257	pCreateData->pDeviceFuncs->pfnFlush = vboxWddmDDevFlush;
3258	pCreateData->pDeviceFuncs->pfnCreateVertexShaderFunc = vboxWddmDDevCreateVertexShaderFunc;
3259	pCreateData->pDeviceFuncs->pfnDeleteVertexShaderFunc = vboxWddmDDevDeleteVertexShaderFunc;
3260	pCreateData->pDeviceFuncs->pfnSetVertexShaderFunc = vboxWddmDDevSetVertexShaderFunc;
3261	pCreateData->pDeviceFuncs->pfnCreateVertexShaderDecl = vboxWddmDDevCreateVertexShaderDecl;
3262	pCreateData->pDeviceFuncs->pfnDeleteVertexShaderDecl = vboxWddmDDevDeleteVertexShaderDecl;
3263	pCreateData->pDeviceFuncs->pfnSetVertexShaderDecl = vboxWddmDDevSetVertexShaderDecl;
3264	pCreateData->pDeviceFuncs->pfnSetVertexShaderConstI = vboxWddmDDevSetVertexShaderConstI;
3265	pCreateData->pDeviceFuncs->pfnSetVertexShaderConstB = vboxWddmDDevSetVertexShaderConstB;
3266	pCreateData->pDeviceFuncs->pfnSetScissorRect = vboxWddmDDevSetScissorRect;
3267	pCreateData->pDeviceFuncs->pfnSetStreamSource = vboxWddmDDevSetStreamSource;
3268	pCreateData->pDeviceFuncs->pfnSetStreamSourceFreq = vboxWddmDDevSetStreamSourceFreq;
3269	pCreateData->pDeviceFuncs->pfnSetConvolutionKernelMono = vboxWddmDDevSetConvolutionKernelMono;
3270	pCreateData->pDeviceFuncs->pfnComposeRects = vboxWddmDDevComposeRects;
3271	pCreateData->pDeviceFuncs->pfnBlt = vboxWddmDDevBlt;
3272	pCreateData->pDeviceFuncs->pfnColorFill = vboxWddmDDevColorFill;
3273	pCreateData->pDeviceFuncs->pfnDepthFill = vboxWddmDDevDepthFill;
3274	pCreateData->pDeviceFuncs->pfnCreateQuery = vboxWddmDDevCreateQuery;
3275	pCreateData->pDeviceFuncs->pfnDestroyQuery = vboxWddmDDevDestroyQuery;
3276	pCreateData->pDeviceFuncs->pfnIssueQuery = vboxWddmDDevIssueQuery;
3277	pCreateData->pDeviceFuncs->pfnGetQueryData = vboxWddmDDevGetQueryData;
3278	pCreateData->pDeviceFuncs->pfnSetRenderTarget = vboxWddmDDevSetRenderTarget;
3279	pCreateData->pDeviceFuncs->pfnSetDepthStencil = vboxWddmDDevSetDepthStencil;
3280	pCreateData->pDeviceFuncs->pfnGenerateMipSubLevels = vboxWddmDDevGenerateMipSubLevels;
3281	pCreateData->pDeviceFuncs->pfnSetPixelShaderConstI = vboxWddmDDevSetPixelShaderConstI;
3282	pCreateData->pDeviceFuncs->pfnSetPixelShaderConstB = vboxWddmDDevSetPixelShaderConstB;
3283	pCreateData->pDeviceFuncs->pfnCreatePixelShader = vboxWddmDDevCreatePixelShader;
3284	pCreateData->pDeviceFuncs->pfnDeletePixelShader = vboxWddmDDevDeletePixelShader;
3285	pCreateData->pDeviceFuncs->pfnCreateDecodeDevice = vboxWddmDDevCreateDecodeDevice;
3286	pCreateData->pDeviceFuncs->pfnDestroyDecodeDevice = vboxWddmDDevDestroyDecodeDevice;
3287	pCreateData->pDeviceFuncs->pfnSetDecodeRenderTarget = vboxWddmDDevSetDecodeRenderTarget;
3288	pCreateData->pDeviceFuncs->pfnDecodeBeginFrame = vboxWddmDDevDecodeBeginFrame;
3289	pCreateData->pDeviceFuncs->pfnDecodeEndFrame = vboxWddmDDevDecodeEndFrame;
3290	pCreateData->pDeviceFuncs->pfnDecodeExecute = vboxWddmDDevDecodeExecute;
3291	pCreateData->pDeviceFuncs->pfnDecodeExtensionExecute = vboxWddmDDevDecodeExtensionExecute;
3292	pCreateData->pDeviceFuncs->pfnCreateVideoProcessDevice = vboxWddmDDevCreateVideoProcessDevice;
3293	pCreateData->pDeviceFuncs->pfnDestroyVideoProcessDevice = vboxWddmDDevDestroyVideoProcessDevice;
3294	pCreateData->pDeviceFuncs->pfnVideoProcessBeginFrame = vboxWddmDDevVideoProcessBeginFrame;
3295	pCreateData->pDeviceFuncs->pfnVideoProcessEndFrame = vboxWddmDDevVideoProcessEndFrame;
3296	pCreateData->pDeviceFuncs->pfnSetVideoProcessRenderTarget = vboxWddmDDevSetVideoProcessRenderTarget;
3297	pCreateData->pDeviceFuncs->pfnVideoProcessBlt = vboxWddmDDevVideoProcessBlt;
3298	pCreateData->pDeviceFuncs->pfnCreateExtensionDevice = vboxWddmDDevCreateExtensionDevice;
3299	pCreateData->pDeviceFuncs->pfnDestroyExtensionDevice = vboxWddmDDevDestroyExtensionDevice;
3300	pCreateData->pDeviceFuncs->pfnExtensionExecute = vboxWddmDDevExtensionExecute;
3301	pCreateData->pDeviceFuncs->pfnCreateOverlay = vboxWddmDDevCreateOverlay;
3302	pCreateData->pDeviceFuncs->pfnUpdateOverlay = vboxWddmDDevUpdateOverlay;
3303	pCreateData->pDeviceFuncs->pfnFlipOverlay = vboxWddmDDevFlipOverlay;
3304	pCreateData->pDeviceFuncs->pfnGetOverlayColorControls = vboxWddmDDevGetOverlayColorControls;
3305	pCreateData->pDeviceFuncs->pfnSetOverlayColorControls = vboxWddmDDevSetOverlayColorControls;
3306	pCreateData->pDeviceFuncs->pfnDestroyOverlay = vboxWddmDDevDestroyOverlay;
3307	pCreateData->pDeviceFuncs->pfnDestroyDevice = vboxWddmDDevDestroyDevice;
3308	pCreateData->pDeviceFuncs->pfnQueryResourceResidency = vboxWddmDDevQueryResourceResidency;
3309	pCreateData->pDeviceFuncs->pfnOpenResource = vboxWddmDDevOpenResource;
3310	pCreateData->pDeviceFuncs->pfnGetCaptureAllocationHandle = vboxWddmDDevGetCaptureAllocationHandle;
3311	pCreateData->pDeviceFuncs->pfnCaptureToSysMem = vboxWddmDDevCaptureToSysMem;
3312	pCreateData->pDeviceFuncs->pfnLockAsync = NULL; //vboxWddmDDevLockAsync;
3313	pCreateData->pDeviceFuncs->pfnUnlockAsync = NULL; //vboxWddmDDevUnlockAsync;
3314	pCreateData->pDeviceFuncs->pfnRename = NULL; //vboxWddmDDevRename;
3315
3316
3317	do
3318	{
3319	Assert(!pCreateData->AllocationListSize
3320	&& !pCreateData->PatchLocationListSize);
3321	if (!pCreateData->AllocationListSize
3322	&& !pCreateData->PatchLocationListSize)
3323	{
3324	pDevice->DefaultContext.ContextInfo.NodeOrdinal = 0;
3325	pDevice->DefaultContext.ContextInfo.EngineAffinity = 0;
3326	pDevice->DefaultContext.ContextInfo.Flags.Value = 0;
3327	pDevice->DefaultContext.ContextInfo.pPrivateDriverData = NULL;
3328	pDevice->DefaultContext.ContextInfo.PrivateDriverDataSize = 0;
3329	pDevice->DefaultContext.ContextInfo.hContext = 0;
3330	pDevice->DefaultContext.ContextInfo.pCommandBuffer = NULL;
3331	pDevice->DefaultContext.ContextInfo.CommandBufferSize = 0;
3332	pDevice->DefaultContext.ContextInfo.pAllocationList = NULL;
3333	pDevice->DefaultContext.ContextInfo.AllocationListSize = 0;
3334	pDevice->DefaultContext.ContextInfo.pPatchLocationList = NULL;
3335	pDevice->DefaultContext.ContextInfo.PatchLocationListSize = 0;
3336
3337	hr = pDevice->RtCallbacks.pfnCreateContextCb(pDevice->hDevice, &pDevice->DefaultContext.ContextInfo);
3338	Assert(hr == S_OK);
3339	if (hr == S_OK)
3340	{
3341	if (VBOXDISPMODE_IS_3D(pAdapter))
3342	{
3343	/* we postpone IDirect3DDevice device creation to CreateResource,
3344	* where resource render target gets created,
3345	* which is actually done as part of d3dx.dll Direct3DDevice creation */
3346	vboxVDbgPrint((__FUNCTION__": D3D Device Created\n"));
3347	break;
3348	}
3349	else
3350	{
3351	/* DDraw */
3352	vboxVDbgPrint((__FUNCTION__": DirectDraw Device Created\n"));
3353	break;
3354	}
3355
3356	D3DDDICB_DESTROYCONTEXT DestroyContext;
3357	DestroyContext.hContext = pDevice->DefaultContext.ContextInfo.hContext;
3358
3359	HRESULT tmpHr = pDevice->RtCallbacks.pfnDestroyContextCb(pDevice->hDevice, &DestroyContext);
3360	Assert(tmpHr == S_OK);
3361	}
3362	else
3363	vboxVDbgPrintR((__FUNCTION__": pfnCreateContextCb failed, hr(%d)\n", hr));
3364	}
3365	else
3366	{
3367	vboxVDbgPrintR((__FUNCTION__": Not implemented: PatchLocationListSize(%d), AllocationListSize(%d)\n",
3368	pCreateData->PatchLocationListSize, pCreateData->AllocationListSize));
3369	//pCreateData->pAllocationList = ??
3370	hr = E_FAIL;
3371	}
3372
3373	RTMemFree(pDevice);
3374	} while (0);
3375	}
3376	else
3377	{
3378	vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
3379	hr = E_OUTOFMEMORY;
3380	}
3381
3382	vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
3383
3384	return hr;
3385	}
3386
3387	static HRESULT APIENTRY vboxWddmDispCloseAdapter (IN HANDLE hAdapter)
3388	{
3389	vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
3390
3391	// AssertBreakpoint();
3392
3393	PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
3394	if (VBOXDISPMODE_IS_3D(pAdapter))
3395	{
3396	HRESULT hr = VBoxDispWorkerDestroy(&pAdapter->WndWorker);
3397	Assert(hr == S_OK);
3398	hr = pAdapter->pD3D9If->Release();
3399	Assert(hr == S_OK);
3400	VBoxDispD3DClose(&pAdapter->D3D);
3401	}
3402
3403	vboxCapsFree(pAdapter);
3404
3405	RTMemFree(pAdapter);
3406
3407	vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
3408
3409	return S_OK;
3410	}
3411
3412	HRESULT APIENTRY OpenAdapter (__inout D3DDDIARG_OPENADAPTER* pOpenData)
3413	{
3414	vboxVDbgPrint(("==> "__FUNCTION__"\n"));
3415
3416	VBOXWDDM_QI Query;
3417	D3DDDICB_QUERYADAPTERINFO DdiQuery;
3418	DdiQuery.PrivateDriverDataSize = sizeof(Query);
3419	DdiQuery.pPrivateDriverData = &Query;
3420	HRESULT hr = pOpenData->pAdapterCallbacks->pfnQueryAdapterInfoCb(pOpenData->hAdapter, &DdiQuery);
3421	Assert(hr == S_OK);
3422	if (hr != S_OK)
3423	{
3424	vboxVDbgPrintR((__FUNCTION__": pfnQueryAdapterInfoCb failed, hr (%d)\n", hr));
3425	return E_FAIL;
3426	}
3427
3428	/* check the miniport version match display version */
3429	if (Query.u32Version != VBOXVIDEOIF_VERSION)
3430	{
3431	vboxVDbgPrintR((__FUNCTION__": miniport version mismatch, expected (%d), but was (%d)\n",
3432	VBOXVIDEOIF_VERSION,
3433	Query.u32Version));
3434	return E_FAIL;
3435	}
3436
3437	#ifdef VBOX_WITH_VIDEOHWACCEL
3438	Assert(Query.cInfos >= 1);
3439	PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(RT_OFFSETOF(VBOXWDDMDISP_ADAPTER, aHeads[Query.cInfos]));
3440	#else
3441	PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(sizeof (VBOXWDDMDISP_ADAPTER));
3442	#endif
3443	Assert(pAdapter);
3444	if (pAdapter)
3445	{
3446	pAdapter->hAdapter = pOpenData->hAdapter;
3447	pAdapter->uIfVersion = pOpenData->Interface;
3448	pAdapter->uRtVersion= pOpenData->Version;
3449	pAdapter->RtCallbacks = *pOpenData->pAdapterCallbacks;
3450
3451	pAdapter->cHeads = Query.cInfos;
3452
3453
3454	pOpenData->hAdapter = pAdapter;
3455	pOpenData->pAdapterFuncs->pfnGetCaps = vboxWddmDispGetCaps;
3456	pOpenData->pAdapterFuncs->pfnCreateDevice = vboxWddmDispCreateDevice;
3457	pOpenData->pAdapterFuncs->pfnCloseAdapter = vboxWddmDispCloseAdapter;
3458	pOpenData->DriverVersion = D3D_UMD_INTERFACE_VERSION;
3459	/*
3460	* here we detect whether we are called by the d3d or ddraw.
3461	* in the d3d case we init our d3d environment
3462	* in the ddraw case we init 2D acceleration
3463	* if interface version is > 7, this is D3D, treat it as so
3464	* otherwise treat it as ddraw
3465	* @todo: need a more clean way of doing this */
3466
3467	if (pAdapter->uIfVersion > 7)
3468	{
3469	do
3470	{
3471	/* try enable the 3D */
3472	hr = VBoxDispD3DOpen(&pAdapter->D3D);
3473	Assert(hr == S_OK);
3474	if (hr == S_OK)
3475	{
3476	hr = pAdapter->D3D.pfnDirect3DCreate9Ex(D3D_SDK_VERSION, &pAdapter->pD3D9If);
3477	Assert(hr == S_OK);
3478	if (hr == S_OK)
3479	{
3480	hr = VBoxDispWorkerCreate(&pAdapter->WndWorker);
3481	Assert(hr == S_OK);
3482	if (hr == S_OK)
3483	{
3484	vboxVDbgPrint((__FUNCTION__": SUCCESS 3D Enabled, pAdapter (0x%p)\n", pAdapter));
3485	break;
3486	}
3487	pAdapter->pD3D9If->Release();
3488	}
3489	else
3490	vboxVDbgPrintR((__FUNCTION__": pfnDirect3DCreate9Ex failed, hr (%d)\n", hr));
3491	VBoxDispD3DClose(&pAdapter->D3D);
3492	}
3493	else
3494	vboxVDbgPrintR((__FUNCTION__": VBoxDispD3DOpen failed, hr (%d)\n", hr));
3495	} while (0);
3496	}
3497	#ifdef VBOX_WITH_VIDEOHWACCEL
3498	else
3499	{
3500	for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
3501	{
3502	pAdapter->aHeads[i].Vhwa.Settings = Query.aInfos[i];
3503	}
3504	}
3505	#endif
3506
3507	vboxCapsInit(pAdapter);
3508	hr = S_OK;
3509	// RTMemFree(pAdapter);
3510	}
3511	else
3512	{
3513	vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
3514	hr = E_OUTOFMEMORY;
3515	}
3516
3517	vboxVDbgPrint(("<== "__FUNCTION__", hr (%d)\n", hr));
3518
3519	return hr;
3520	}
3521
3522	#ifdef VBOXWDDMDISP_DEBUG
3523	VOID vboxVDbgDoPrint(LPCSTR szString, ...)
3524	{
3525	char szBuffer[1024] = {0};
3526	va_list pArgList;
3527	va_start(pArgList, szString);
3528	_vsnprintf(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]), szString, pArgList);
3529	va_end(pArgList);
3530
3531	OutputDebugStringA(szBuffer);
3532	}
3533	#endif

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

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

Download in other formats: