VBoxDispD3D.cpp@ 30214

Last change on this file since 30214 was 30214, checked in by vboxsync, 15 years ago
wddm/2d: bugfixing
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 169.2 KB

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

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

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

Download in other formats: