VBoxDispD3D.cpp@ 30623

Last change on this file since 30623 was 30623, checked in by vboxsync, 15 years ago
dwwm/3d: render target & create device fix
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 203.5 KB

Line
1	/** @file
2	*
3	* VBoxVideo Display D3D User mode dll
4	*
5	* Copyright (C) 2010 Oracle Corporation
6	*
7	* This file is part of VirtualBox Open Source Edition (OSE), as
8	* available from http://www.virtualbox.org. This file is free software;
9	* you can redistribute it and/or modify it under the terms of the GNU
10	* General Public License (GPL) as published by the Free Software
11	* Foundation, in version 2 as it comes in the "COPYING" file of the
12	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
13	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
14	*/
15	#include <iprt/initterm.h>
16	#include <iprt/log.h>
17	#include <iprt/mem.h>
18
19	#include <VBox/Log.h>
20
21	#include <VBox/VBoxGuestLib.h>
22
23	#include "VBoxDispD3DCmn.h"
24	#include "VBoxDispD3D.h"
25
26	#ifdef VBOXDISPMP_TEST
27	HRESULT vboxDispMpTstStart();
28	HRESULT vboxDispMpTstStop();
29	#endif
30
31	#ifdef VBOXWDDMDISP_DEBUG
32	# include <stdio.h>
33	#endif
34
35	#define VBOXWDDMDISP_WITH_TMPWORKAROUND 1
36
37	#define VBOXWDDMOVERLAY_TEST
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 vboxWddmLockUnlockMemSynch(PVBOXWDDMDISP_ALLOCATION pAlloc, D3DLOCKED_RECT pLockInfo, RECT pRect, bool bToLockInfo)
868	{
869	Assert(pAlloc->SurfDesc.pitch);
870	Assert(pAlloc->pvMem);
871
872	if (!pRect)
873	{
874	if (pAlloc->SurfDesc.pitch == pLockInfo->Pitch)
875	{
876	if (bToLockInfo)
877	memcpy(pLockInfo->pBits, pAlloc->pvMem, pAlloc->SurfDesc.pitch * pAlloc->SurfDesc.height);
878	else
879	memcpy(pAlloc->pvMem, pLockInfo->pBits, pAlloc->SurfDesc.pitch * pAlloc->SurfDesc.height);
880	}
881	else
882	{
883	uint8_t pvSrc, pvDst;
884	uint32_t srcPitch, dstPitch;
885	if (bToLockInfo)
886	{
887	pvSrc = (uint8_t *)pAlloc->pvMem;
888	pvDst = (uint8_t *)pLockInfo->pBits;
889	srcPitch = pAlloc->SurfDesc.pitch;
890	dstPitch = pLockInfo->Pitch;
891	}
892	else
893	{
894	pvDst = (uint8_t *)pAlloc->pvMem;
895	pvSrc = (uint8_t *)pLockInfo->pBits;
896	dstPitch = pAlloc->SurfDesc.pitch;
897	srcPitch = (uint32_t)pLockInfo->Pitch;
898	}
899
900	uint32_t pitch = RT_MIN(srcPitch, dstPitch);
901	Assert(pitch);
902	for (UINT j = 0; j < pAlloc->SurfDesc.height; ++j)
903	{
904	memcpy(pvDst, pvSrc, pitch);
905	pvSrc += srcPitch;
906	pvDst += dstPitch;
907	}
908	}
909	}
910	else
911	{
912	uint8_t pvSrc, pvDst;
913	uint32_t srcPitch, dstPitch;
914	/* @todo: this is not entirely correct */
915	uint8_t * pvAllocMemStart = (uint8_t *)pAlloc->pvMem;
916	uint32_t cbPP = pAlloc->SurfDesc.pitch/pAlloc->SurfDesc.width;
917	pvAllocMemStart += pAlloc->SurfDesc.pitch * pRect->top + pRect->left * cbPP;
918
919	if (bToLockInfo)
920	{
921	pvSrc = (uint8_t *)pvAllocMemStart;
922	pvDst = (uint8_t *)pLockInfo->pBits;
923	srcPitch = pAlloc->SurfDesc.pitch;
924	dstPitch = pLockInfo->Pitch;
925	}
926	else
927	{
928	pvDst = (uint8_t *)pvAllocMemStart;
929	pvSrc = (uint8_t *)pLockInfo->pBits;
930	dstPitch = pAlloc->SurfDesc.pitch;
931	srcPitch = (uint32_t)pLockInfo->Pitch;
932	}
933
934	uint32_t cPixCopyLine = pRect->right - pRect->left;
935
936	if (cPixCopyLine == pAlloc->SurfDesc.width && srcPitch == dstPitch)
937	{
938	memcpy(pvDst, pvSrc, pAlloc->SurfDesc.pitch * (pRect->bottom - pRect->top));
939	}
940	else
941	{
942	uint32_t pitch = RT_MIN(srcPitch, dstPitch);
943	uint32_t cbCopyLine = cPixCopyLine * cbPP;
944	Assert(pitch);
945	for (int j = pRect->top; j < pRect->bottom; ++j)
946	{
947	memcpy(pvDst, pvSrc, cbCopyLine);
948	pvSrc += srcPitch;
949	pvDst += dstPitch;
950	}
951	}
952	}
953	}
954
955	#if 0
956	static HRESULT vboxWddmRectBltPerform(uint8_t pvDstSurf, const uint8_t pvSrcSurf,
957	RECT pDstRect, RECT pSrcRect,
958	uint32_t DstPitch, uint32_t SrcPitch, uint32_t bpp,
959	RECT pDstCopyRect, RECT pSrcCopyRect)
960	{
961	uint32_t DstCopyWidth = pDstCopyRect->left - pDstCopyRect->right;
962	uint32_t DstCopyHeight = pDstCopyRect->bottom - pDstCopyRect->top;
963	uint32_t SrcCopyWidth = pSrcCopyRect->left - pSrcCopyRect->right;
964	uint32_t SrcCopyHeight = pSrcCopyRect->bottom - pSrcCopyRect->top;
965	uint32_t srcBpp = bpp;
966	uint32_t dstBpp = bpp;
967	/* we do not support stretching */
968	Assert(DstCopyWidth == SrcCopyWidth);
969	Assert(DstCopyHeight == SrcCopyWidth);
970	if (DstCopyWidth != SrcCopyWidth)
971	return E_FAIL;
972	if (DstCopyHeight != SrcCopyWidth)
973	return E_FAIL;
974
975	uint32_t DstWidth = pDstRect->left - pDstRect->right;
976	uint32_t DstHeight = pDstRect->bottom - pDstRect->top;
977	uint32_t SrcWidth = pSrcRect->left - pSrcRect->right;
978	uint32_t SrcHeight = pSrcRect->bottom - pSrcRect->top;
979
980	if (DstWidth == DstCopyWidth
981	&& SrcWidth == SrcCopyWidth
982	&& SrcWidth == DstWidth)
983	{
984	Assert(!pDstCopyRect->left);
985	Assert(!pSrcCopyRect->left);
986	uint32_t cbOff = DstPitch * pDstCopyRect->top;
987	uint32_t cbSize = DstPitch * DstCopyHeight;
988	memcpy(pvDstSurf + cbOff, pvSrcSurf + cbOff, cbSize);
989	}
990	else
991	{
992	uint32_t offDstLineStart = pDstCopyRect->left * dstBpp >> 3;
993	uint32_t offDstLineEnd = ((pDstCopyRect->left * dstBpp + 7) >> 3) + ((dstBpp * DstCopyWidth + 7) >> 3);
994	uint32_t cbDstLine = offDstLineEnd - offDstLineStart;
995	uint32_t offDstStart = DstPitch * pDstCopyRect->top + offDstLineStart;
996	Assert(cbDstLine <= DstPitch);
997	uint32_t cbDstSkip = DstPitch;
998	uint8_t * pvDstStart = pvDstSurf + offDstStart;
999
1000	uint32_t offSrcLineStart = pSrcCopyRect->left * srcBpp >> 3;
1001	uint32_t offSrcLineEnd = ((pSrcCopyRect->left * srcBpp + 7) >> 3) + ((srcBpp * SrcCopyWidth + 7) >> 3);
1002	uint32_t cbSrcLine = offSrcLineEnd - offSrcLineStart;
1003	uint32_t offSrcStart = SrcPitch * pSrcCopyRect->top + offSrcLineStart;
1004	Assert(cbSrcLine <= SrcPitch);
1005	uint32_t cbSrcSkip = SrcPitch;
1006	const uint8_t * pvSrcStart = pvSrcSurf + offSrcStart;
1007
1008	Assert(cbDstLine == cbSrcLine);
1009
1010	for (uint32_t i = 0; ; ++i)
1011	{
1012	memcpy (pvDstStart, pvSrcStart, cbDstLine);
1013	if (i == DstCopyHeight)
1014	break;
1015	pvDstStart += cbDstSkip;
1016	pvSrcStart += cbSrcSkip;
1017	}
1018	}
1019	return S_OK;
1020	}
1021	#endif
1022
1023	static HRESULT vboxWddmRectBltPerform(uint8_t pvDstSurf, const uint8_t pvSrcSurf,
1024	const RECT pDstRect, const RECT pSrcRect,
1025	uint32_t DstPitch, uint32_t SrcPitch, uint32_t bpp)
1026	{
1027	uint32_t DstWidth = pDstRect->left - pDstRect->right;
1028	uint32_t DstHeight = pDstRect->bottom - pDstRect->top;
1029	uint32_t SrcWidth = pSrcRect->left - pSrcRect->right;
1030	uint32_t SrcHeight = pSrcRect->bottom - pSrcRect->top;
1031	uint32_t srcBpp = bpp;
1032	uint32_t dstBpp = bpp;
1033	/* we do not support stretching */
1034	Assert(DstWidth == SrcWidth);
1035	Assert(DstHeight == SrcWidth);
1036	if (DstWidth != SrcWidth)
1037	return E_FAIL;
1038	if (DstHeight != SrcWidth)
1039	return E_FAIL;
1040
1041	if (DstPitch == SrcPitch
1042	&& ((DstWidth * bpp)/8) == DstPitch)
1043	{
1044	Assert(!pDstRect->left);
1045	Assert(!pSrcRect->left);
1046	uint32_t cbOff = DstPitch * pDstRect->top;
1047	uint32_t cbSize = DstPitch * DstHeight;
1048	memcpy(pvDstSurf + cbOff, pvSrcSurf + cbOff, cbSize);
1049	}
1050	else
1051	{
1052
1053	uint32_t cbDstLine = (((DstWidth * dstBpp) + 7) >> 3);
1054	for (uint32_t i = 0; ; ++i)
1055	{
1056	memcpy (pvDstSurf, pvSrcSurf, cbDstLine);
1057	if (i == DstHeight)
1058	break;
1059	pvDstSurf += DstPitch;
1060	pvSrcSurf += SrcPitch;
1061	}
1062	}
1063	return S_OK;
1064	}
1065
1066	static D3DFORMAT vboxDDI2D3DFormat(D3DDDIFORMAT format)
1067	{
1068	/* @todo: check they are all equal */
1069	return (D3DFORMAT)format;
1070	}
1071
1072	D3DMULTISAMPLE_TYPE vboxDDI2D3DMultiSampleType(D3DDDIMULTISAMPLE_TYPE enmType)
1073	{
1074	/* @todo: check they are all equal */
1075	return (D3DMULTISAMPLE_TYPE)enmType;
1076	}
1077
1078	D3DPOOL vboxDDI2D3DPool(D3DDDI_POOL enmPool)
1079	{
1080	/* @todo: check they are all equal */
1081	switch (enmPool)
1082	{
1083	case D3DDDIPOOL_SYSTEMMEM:
1084	return D3DPOOL_SYSTEMMEM;
1085	case D3DDDIPOOL_VIDEOMEMORY:
1086	case D3DDDIPOOL_LOCALVIDMEM:
1087	case D3DDDIPOOL_NONLOCALVIDMEM:
1088	/* @todo: what would be propper here? */
1089	return D3DPOOL_DEFAULT;
1090	default:
1091	AssertBreakpoint();
1092	}
1093	return D3DPOOL_DEFAULT;
1094	}
1095
1096	D3DRENDERSTATETYPE vboxDDI2D3DRenderStateType(D3DDDIRENDERSTATETYPE enmType)
1097	{
1098	/* @todo: @fixme: not entirely correct, need to check */
1099	return (D3DRENDERSTATETYPE)enmType;
1100	}
1101
1102	VBOXWDDMDISP_TSS_LOOKUP vboxDDI2D3DTestureStageStateType(D3DDDITEXTURESTAGESTATETYPE enmType)
1103	{
1104	static const VBOXWDDMDISP_TSS_LOOKUP lookup[] =
1105	{
1106	{FALSE, D3DTSS_FORCE_DWORD}, /* 0, D3DDDITSS_TEXTUREMAP */
1107	{FALSE, D3DTSS_COLOROP}, /* 1, D3DDDITSS_COLOROP */
1108	{FALSE, D3DTSS_COLORARG1}, /* 2, D3DDDITSS_COLORARG1 */
1109	{FALSE, D3DTSS_COLORARG2}, /* 3, D3DDDITSS_COLORARG2 */
1110	{FALSE, D3DTSS_ALPHAOP}, /* 4, D3DDDITSS_ALPHAOP */
1111	{FALSE, D3DTSS_ALPHAARG1}, /* 5, D3DDDITSS_ALPHAARG1 */
1112	{FALSE, D3DTSS_ALPHAARG2}, /* 6, D3DDDITSS_ALPHAARG2 */
1113	{FALSE, D3DTSS_BUMPENVMAT00}, /* 7, D3DDDITSS_BUMPENVMAT00 */
1114	{FALSE, D3DTSS_BUMPENVMAT01}, /* 8, D3DDDITSS_BUMPENVMAT01 */
1115	{FALSE, D3DTSS_BUMPENVMAT10}, /* 9, D3DDDITSS_BUMPENVMAT10 */
1116	{FALSE, D3DTSS_BUMPENVMAT11}, /* 10, D3DDDITSS_BUMPENVMAT11 */
1117	{FALSE, D3DTSS_TEXCOORDINDEX}, /* 11, D3DDDITSS_TEXCOORDINDEX */
1118	{FALSE, D3DTSS_FORCE_DWORD}, /* 12, unused */
1119	{TRUE, D3DSAMP_ADDRESSU}, /* 13, D3DDDITSS_ADDRESSU */
1120	{TRUE, D3DSAMP_ADDRESSV}, /* 14, D3DDDITSS_ADDRESSV */
1121	{TRUE, D3DSAMP_BORDERCOLOR}, /* 15, D3DDDITSS_BORDERCOLOR */
1122	{TRUE, D3DSAMP_MAGFILTER}, /* 16, D3DDDITSS_MAGFILTER */
1123	{TRUE, D3DSAMP_MINFILTER}, /* 17, D3DDDITSS_MINFILTER */
1124	{TRUE, D3DSAMP_MIPFILTER}, /* 18, D3DDDITSS_MIPFILTER */
1125	{TRUE, D3DSAMP_MIPMAPLODBIAS}, /* 19, D3DDDITSS_MIPMAPLODBIAS */
1126	{TRUE, D3DSAMP_MAXMIPLEVEL}, /* 20, D3DDDITSS_MAXMIPLEVEL */
1127	{TRUE, D3DSAMP_MAXANISOTROPY}, /* 21, D3DDDITSS_MAXANISOTROPY */
1128	{FALSE, D3DTSS_BUMPENVLSCALE}, /* 22, D3DDDITSS_BUMPENVLSCALE */
1129	{FALSE, D3DTSS_BUMPENVLOFFSET}, /* 23, D3DDDITSS_BUMPENVLOFFSET */
1130	{FALSE, D3DTSS_TEXTURETRANSFORMFLAGS}, /* 24, D3DDDITSS_TEXTURETRANSFORMFLAGS */
1131	{TRUE, D3DSAMP_ADDRESSW}, /* 25, D3DDDITSS_ADDRESSW */
1132	{FALSE, D3DTSS_COLORARG0}, /* 26, D3DDDITSS_COLORARG0 */
1133	{FALSE, D3DTSS_ALPHAARG0}, /* 27, D3DDDITSS_ALPHAARG0 */
1134	{FALSE, D3DTSS_RESULTARG}, /* 28, D3DDDITSS_RESULTARG */
1135	{FALSE, D3DTSS_FORCE_DWORD}, /* 29, D3DDDITSS_SRGBTEXTURE */
1136	{FALSE, D3DTSS_FORCE_DWORD}, /* 30, D3DDDITSS_ELEMENTINDEX */
1137	{FALSE, D3DTSS_FORCE_DWORD}, /* 31, D3DDDITSS_DMAPOFFSET */
1138	{FALSE, D3DTSS_CONSTANT}, /* 32, D3DDDITSS_CONSTANT */
1139	{FALSE, D3DTSS_FORCE_DWORD}, /* 33, D3DDDITSS_DISABLETEXTURECOLORKEY */
1140	{FALSE, D3DTSS_FORCE_DWORD}, /* 34, D3DDDITSS_TEXTURECOLORKEYVAL */
1141	};
1142
1143	return lookup[enmType];
1144	}
1145
1146	DWORD vboxDDI2D3DUsage(D3DDDI_RESOURCEFLAGS fFlags)
1147	{
1148	DWORD fUsage = 0;
1149	if (fFlags.Dynamic)
1150	fUsage \|= D3DUSAGE_DYNAMIC;
1151	if (fFlags.AutogenMipmap)
1152	fUsage \|= D3DUSAGE_AUTOGENMIPMAP;
1153	if (fFlags.DMap)
1154	fUsage \|= D3DUSAGE_DMAP;
1155	if (fFlags.WriteOnly)
1156	fUsage \|= D3DUSAGE_WRITEONLY;
1157	if (fFlags.NPatches)
1158	fUsage \|= D3DUSAGE_NPATCHES;
1159	if (fFlags.Points)
1160	fUsage \|= D3DUSAGE_POINTS;
1161	if (fFlags.RenderTarget)
1162	fUsage \|= D3DUSAGE_RENDERTARGET;
1163	if (fFlags.RtPatches)
1164	fUsage \|= D3DUSAGE_RTPATCHES;
1165	if (fFlags.TextApi)
1166	fUsage \|= D3DUSAGE_TEXTAPI;
1167	if (fFlags.WriteOnly)
1168	fUsage \|= D3DUSAGE_WRITEONLY;
1169	//below are wddm 1.1-specific
1170	// if (fFlags.RestrictedContent)
1171	// fUsage \|= D3DUSAGE_RESTRICTED_CONTENT;
1172	// if (fFlags.RestrictSharedAccess)
1173	// fUsage \|= D3DUSAGE_RESTRICT_SHARED_RESOURCE;
1174	return fUsage;
1175	}
1176
1177	DWORD vboxDDI2D3DLockFlags(D3DDDI_LOCKFLAGS fLockFlags)
1178	{
1179	DWORD fFlags = 0;
1180	if (fLockFlags.Discard)
1181	fFlags \|= D3DLOCK_DISCARD;
1182	if (fLockFlags.NoOverwrite)
1183	fFlags \|= D3DLOCK_NOOVERWRITE;
1184	if (fLockFlags.ReadOnly)
1185	fFlags \|= D3DLOCK_READONLY;
1186	if (fLockFlags.DoNotWait)
1187	fFlags \|= D3DLOCK_DONOTWAIT;
1188	return fFlags;
1189	}
1190
1191	D3DTEXTUREFILTERTYPE vboxDDI2D3DBltFlags(D3DDDI_BLTFLAGS fFlags)
1192	{
1193	if (fFlags.Point)
1194	{
1195	/* no flags other than [Begin\|Continue\|End]PresentToDwm are set */
1196	Assert((fFlags.Value & (~(0x00000100 \| 0x00000200 \| 0x00000400))) == 1);
1197	return D3DTEXF_POINT;
1198	}
1199	if (fFlags.Linear)
1200	{
1201	/* no flags other than [Begin\|Continue\|End]PresentToDwm are set */
1202	Assert((fFlags.Value & (~(0x00000100 \| 0x00000200 \| 0x00000400))) == 2);
1203	return D3DTEXF_LINEAR;
1204	}
1205	/* no flags other than [Begin\|Continue\|End]PresentToDwm are set */
1206	Assert((fFlags.Value & (~(0x00000100 \| 0x00000200 \| 0x00000400))) == 0);
1207	return D3DTEXF_NONE;
1208	}
1209
1210	static void vboxResourceFree(PVBOXWDDMDISP_RESOURCE pRc)
1211	{
1212	RTMemFree(pRc);
1213	}
1214
1215	/**
1216	* DLL entry point.
1217	*/
1218	BOOL WINAPI DllMain(HINSTANCE hInstance,
1219	DWORD dwReason,
1220	LPVOID lpReserved)
1221	{
1222	BOOL bOk = TRUE;
1223
1224	switch (dwReason)
1225	{
1226	case DLL_PROCESS_ATTACH:
1227	{
1228	RTR3Init();
1229
1230	HRESULT hr = vboxDispCmInit();
1231	Assert(hr == S_OK);
1232	#ifdef VBOXDISPMP_TEST
1233	if (hr == S_OK)
1234	{
1235	hr = vboxDispMpTstStart();
1236	Assert(hr == S_OK);
1237	}
1238	#endif
1239	if (hr == S_OK)
1240	vboxVDbgPrint(("VBoxDispD3D: DLL loaded.\n"));
1241	else
1242	bOk = FALSE;
1243
1244	// VbglR3Init();
1245	break;
1246	}
1247
1248	case DLL_PROCESS_DETACH:
1249	{
1250	HRESULT hr;
1251	#ifdef VBOXDISPMP_TEST
1252	hr = vboxDispMpTstStop();
1253	Assert(hr == S_OK);
1254	if (hr == S_OK)
1255	#endif
1256	{
1257	hr = vboxDispCmTerm();
1258	Assert(hr == S_OK);
1259	if (hr == S_OK)
1260	vboxVDbgPrint(("VBoxDispD3D: DLL unloaded.\n"));
1261	else
1262	bOk = FALSE;
1263	}
1264	// VbglR3Term();
1265	/// @todo RTR3Term();
1266	break;
1267	}
1268
1269	default:
1270	break;
1271	}
1272	return bOk;
1273	}
1274
1275	static HRESULT APIENTRY vboxWddmDispGetCaps (HANDLE hAdapter, CONST D3DDDIARG_GETCAPS* pData)
1276	{
1277	vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p), caps type(%d)\n", hAdapter, pData->Type));
1278
1279	HRESULT hr = S_OK;
1280	PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
1281
1282	switch (pData->Type)
1283	{
1284	case D3DDDICAPS_DDRAW:
1285	{
1286	Assert(!VBOXDISPMODE_IS_3D(pAdapter));
1287	Assert(pData->DataSize == sizeof (DDRAW_CAPS));
1288	if (pData->DataSize >= sizeof (DDRAW_CAPS))
1289	{
1290	memset(pData->pData, 0, sizeof (DDRAW_CAPS));
1291	#ifdef VBOX_WITH_VIDEOHWACCEL
1292	if (vboxVhwaHasCKeying(pAdapter))
1293	{
1294	DDRAW_CAPS pCaps = (DDRAW_CAPS)pData->pData;
1295	pCaps->Caps \|= DDRAW_CAPS_COLORKEY;
1296	// pCaps->Caps2 \|= DDRAW_CAPS2_FLIPNOVSYNC;
1297	}
1298	#endif
1299	}
1300	else
1301	hr = E_INVALIDARG;
1302	break;
1303	}
1304	case D3DDDICAPS_DDRAW_MODE_SPECIFIC:
1305	{
1306	Assert(!VBOXDISPMODE_IS_3D(pAdapter));
1307	Assert(pData->DataSize == sizeof (DDRAW_MODE_SPECIFIC_CAPS));
1308	if (pData->DataSize >= sizeof (DDRAW_MODE_SPECIFIC_CAPS))
1309	{
1310	DDRAW_MODE_SPECIFIC_CAPS * pCaps = (DDRAW_MODE_SPECIFIC_CAPS*)pData->pData;
1311	memset(&pCaps->Caps /* do not cleanup the first "Head" field,
1312	zero starting with the one following "Head", i.e. Caps */,
1313	0, sizeof (DDRAW_MODE_SPECIFIC_CAPS) - RT_OFFSETOF(DDRAW_MODE_SPECIFIC_CAPS, Caps));
1314	#ifdef VBOX_WITH_VIDEOHWACCEL
1315	VBOXVHWA_INFO *pSettings = &pAdapter->aHeads[pCaps->Head].Vhwa.Settings;
1316	if (pSettings->fFlags & VBOXVHWA_F_ENABLED)
1317	{
1318	pCaps->Caps \|= MODE_CAPS_OVERLAY \| MODE_CAPS_OVERLAYSTRETCH;
1319
1320	if (pSettings->fFlags & VBOXVHWA_F_CKEY_DST)
1321	{
1322	pCaps->CKeyCaps \|= MODE_CKEYCAPS_DESTOVERLAY
1323	\| MODE_CKEYCAPS_DESTOVERLAYYUV /* ?? */
1324	;
1325	}
1326
1327	if (pSettings->fFlags & VBOXVHWA_F_CKEY_SRC)
1328	{
1329	pCaps->CKeyCaps \|= MODE_CKEYCAPS_SRCOVERLAY
1330	\| MODE_CKEYCAPS_SRCOVERLAYCLRSPACE /* ?? */
1331	\| MODE_CKEYCAPS_SRCOVERLAYCLRSPACEYUV /* ?? */
1332	\| MODE_CKEYCAPS_SRCOVERLAYYUV /* ?? */
1333	;
1334	}
1335
1336	pCaps->FxCaps = MODE_FXCAPS_OVERLAYSHRINKX
1337	\| MODE_FXCAPS_OVERLAYSHRINKY
1338	\| MODE_FXCAPS_OVERLAYSTRETCHX
1339	\| MODE_FXCAPS_OVERLAYSTRETCHY;
1340
1341
1342	pCaps->MaxVisibleOverlays = pSettings->cOverlaysSupported;
1343	pCaps->MinOverlayStretch = 1;
1344	pCaps->MaxOverlayStretch = 32000;
1345	}
1346	#endif
1347	}
1348	else
1349	hr = E_INVALIDARG;
1350	break;
1351	}
1352	case D3DDDICAPS_GETFORMATCOUNT:
1353	((uint32_t)pData->pData) = pAdapter->cFormstOps;
1354	break;
1355	case D3DDDICAPS_GETFORMATDATA:
1356	Assert(pData->DataSize == pAdapter->cFormstOps * sizeof (FORMATOP));
1357	memcpy(pData->pData, pAdapter->paFormstOps, pAdapter->cFormstOps * sizeof (FORMATOP));
1358	break;
1359	case D3DDDICAPS_GETD3DQUERYCOUNT:
1360	#if 0
1361	((uint32_t)pData->pData) = VBOX_QUERYTYPE_COUNT();
1362	#else
1363	((uint32_t)pData->pData) = 0;
1364	#endif
1365	break;
1366	case D3DDDICAPS_GETD3DQUERYDATA:
1367	#if 0
1368	Assert(pData->DataSize == VBOX_QUERYTYPE_COUNT() * sizeof (D3DDDIQUERYTYPE));
1369	memcpy(pData->pData, gVBoxQueryTypes, VBOX_QUERYTYPE_COUNT() * sizeof (D3DDDIQUERYTYPE));
1370	#else
1371	AssertBreakpoint();
1372	memset(pData->pData, 0, pData->DataSize);
1373	#endif
1374	break;
1375	case D3DDDICAPS_GETD3D3CAPS:
1376	Assert(!VBOXDISPMODE_IS_3D(pAdapter));
1377	Assert(pData->DataSize == sizeof (D3DHAL_GLOBALDRIVERDATA));
1378	if (pData->DataSize >= sizeof (D3DHAL_GLOBALDRIVERDATA))
1379	{
1380	D3DHAL_GLOBALDRIVERDATA pCaps = (D3DHAL_GLOBALDRIVERDATA )pData->pData;
1381	memset (pCaps, 0, sizeof (D3DHAL_GLOBALDRIVERDATA));
1382	pCaps->dwSize = sizeof (D3DHAL_GLOBALDRIVERDATA);
1383	pCaps->hwCaps.dwSize = sizeof (D3DDEVICEDESC_V1);
1384	pCaps->hwCaps.dwFlags = D3DDD_COLORMODEL
1385	\| D3DDD_DEVCAPS
1386	\| D3DDD_DEVICERENDERBITDEPTH;
1387
1388	pCaps->hwCaps.dcmColorModel = D3DCOLOR_RGB;
1389	pCaps->hwCaps.dwDevCaps = D3DDEVCAPS_CANRENDERAFTERFLIP
1390	// \| D3DDEVCAPS_DRAWPRIMTLVERTEX
1391	\| D3DDEVCAPS_EXECUTESYSTEMMEMORY
1392	\| D3DDEVCAPS_EXECUTEVIDEOMEMORY
1393	// \| D3DDEVCAPS_FLOATTLVERTEX
1394	\| D3DDEVCAPS_HWRASTERIZATION
1395	// \| D3DDEVCAPS_HWTRANSFORMANDLIGHT
1396	// \| D3DDEVCAPS_TLVERTEXSYSTEMMEMORY
1397	// \| D3DDEVCAPS_TEXTUREVIDEOMEMORY
1398	;
1399	pCaps->hwCaps.dtcTransformCaps.dwSize = sizeof (D3DTRANSFORMCAPS);
1400	pCaps->hwCaps.dtcTransformCaps.dwCaps = 0;
1401	pCaps->hwCaps.bClipping = FALSE;
1402	pCaps->hwCaps.dlcLightingCaps.dwSize = sizeof (D3DLIGHTINGCAPS);
1403	pCaps->hwCaps.dlcLightingCaps.dwCaps = 0;
1404	pCaps->hwCaps.dlcLightingCaps.dwLightingModel = 0;
1405	pCaps->hwCaps.dlcLightingCaps.dwNumLights = 0;
1406	pCaps->hwCaps.dpcLineCaps.dwSize = sizeof (D3DPRIMCAPS);
1407	pCaps->hwCaps.dpcLineCaps.dwMiscCaps = 0;
1408	pCaps->hwCaps.dpcLineCaps.dwRasterCaps = 0;
1409	pCaps->hwCaps.dpcLineCaps.dwZCmpCaps = 0;
1410	pCaps->hwCaps.dpcLineCaps.dwSrcBlendCaps = 0;
1411	pCaps->hwCaps.dpcLineCaps.dwDestBlendCaps = 0;
1412	pCaps->hwCaps.dpcLineCaps.dwAlphaCmpCaps = 0;
1413	pCaps->hwCaps.dpcLineCaps.dwShadeCaps = 0;
1414	pCaps->hwCaps.dpcLineCaps.dwTextureCaps = 0;
1415	pCaps->hwCaps.dpcLineCaps.dwTextureFilterCaps = 0;
1416	pCaps->hwCaps.dpcLineCaps.dwTextureBlendCaps = 0;
1417	pCaps->hwCaps.dpcLineCaps.dwTextureAddressCaps = 0;
1418	pCaps->hwCaps.dpcLineCaps.dwStippleWidth = 0;
1419	pCaps->hwCaps.dpcLineCaps.dwStippleHeight = 0;
1420
1421	pCaps->hwCaps.dpcTriCaps.dwSize = sizeof (D3DPRIMCAPS);
1422	pCaps->hwCaps.dpcTriCaps.dwMiscCaps = 0;
1423	pCaps->hwCaps.dpcTriCaps.dwRasterCaps = 0;
1424	pCaps->hwCaps.dpcTriCaps.dwZCmpCaps = 0;
1425	pCaps->hwCaps.dpcTriCaps.dwSrcBlendCaps = 0;
1426	pCaps->hwCaps.dpcTriCaps.dwDestBlendCaps = 0;
1427	pCaps->hwCaps.dpcTriCaps.dwAlphaCmpCaps = 0;
1428	pCaps->hwCaps.dpcTriCaps.dwShadeCaps = 0;
1429	pCaps->hwCaps.dpcTriCaps.dwTextureCaps = 0;
1430	pCaps->hwCaps.dpcTriCaps.dwTextureFilterCaps = 0;
1431	pCaps->hwCaps.dpcTriCaps.dwTextureBlendCaps = 0;
1432	pCaps->hwCaps.dpcTriCaps.dwTextureAddressCaps = 0;
1433	pCaps->hwCaps.dpcTriCaps.dwStippleWidth = 0;
1434	pCaps->hwCaps.dpcTriCaps.dwStippleHeight = 0;
1435	pCaps->hwCaps.dwDeviceRenderBitDepth = DDBD_8 \| DDBD_16 \| DDBD_24 \| DDBD_32;
1436	pCaps->hwCaps.dwDeviceZBufferBitDepth = 0;
1437	pCaps->hwCaps.dwMaxBufferSize = 0;
1438	pCaps->hwCaps.dwMaxVertexCount = 0;
1439
1440
1441	pCaps->dwNumVertices = 0;
1442	pCaps->dwNumClipVertices = 0;
1443	pCaps->dwNumTextureFormats = 0;//pAdapter->cSurfDescs;
1444	pCaps->lpTextureFormats = NULL;//pAdapter->paSurfDescs;
1445	}
1446	else
1447	hr = E_INVALIDARG;
1448	break;
1449	case D3DDDICAPS_GETD3D7CAPS:
1450	Assert(!VBOXDISPMODE_IS_3D(pAdapter));
1451	Assert(pData->DataSize == sizeof (D3DHAL_D3DEXTENDEDCAPS));
1452	if (pData->DataSize >= sizeof (D3DHAL_D3DEXTENDEDCAPS))
1453	{
1454	memset(pData->pData, 0, sizeof (D3DHAL_D3DEXTENDEDCAPS));
1455	D3DHAL_D3DEXTENDEDCAPS pCaps = (D3DHAL_D3DEXTENDEDCAPS)pData->pData;
1456	pCaps->dwSize = sizeof (D3DHAL_D3DEXTENDEDCAPS);
1457	}
1458	else
1459	hr = E_INVALIDARG;
1460	break;
1461	case D3DDDICAPS_GETD3D9CAPS:
1462	{
1463	Assert(pData->DataSize >= sizeof (D3DCAPS9));
1464	// AssertBreakpoint();
1465	if (pData->DataSize >= sizeof (D3DCAPS9))
1466	{
1467	Assert(VBOXDISPMODE_IS_3D(pAdapter));
1468	if (VBOXDISPMODE_IS_3D(pAdapter))
1469	{
1470	D3DCAPS9* pCaps = (D3DCAPS9*)pData->pData;
1471	hr = pAdapter->pD3D9If->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, pCaps);
1472	Assert(hr == S_OK);
1473	if (hr == S_OK)
1474	{
1475	pCaps->Caps2 \|= D3DCAPS2_CANSHARERESOURCE \| 0x00080000 /D3DCAPS2_CANRENDERWINDOWED/;
1476	pCaps->DevCaps \|= D3DDEVCAPS_FLOATTLVERTEX /* <- must be set according to the docs */
1477	/\| D3DDEVCAPS_HWVERTEXBUFFER \| D3DDEVCAPS_HWINDEXBUFFER \| D3DDEVCAPS_SUBVOLUMELOCK /;
1478	pCaps->PrimitiveMiscCaps \|= D3DPMISCCAPS_INDEPENDENTWRITEMASKS
1479	\| D3DPMISCCAPS_FOGINFVF
1480	\| D3DPMISCCAPS_SEPARATEALPHABLEND \| D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS;
1481	pCaps->RasterCaps \|= D3DPRASTERCAPS_SUBPIXEL \| D3DPRASTERCAPS_STIPPLE \| D3DPRASTERCAPS_ZBIAS \| D3DPRASTERCAPS_COLORPERSPECTIVE /* keep */;
1482	pCaps->TextureCaps \|= D3DPTEXTURECAPS_TRANSPARENCY \| D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE;
1483	pCaps->TextureAddressCaps \|= D3DPTADDRESSCAPS_MIRRORONCE;
1484	pCaps->VolumeTextureAddressCaps \|= D3DPTADDRESSCAPS_MIRRORONCE;
1485	pCaps->GuardBandLeft = -8192.;
1486	pCaps->GuardBandTop = -8192.;
1487	pCaps->GuardBandRight = 8192.;
1488	pCaps->GuardBandBottom = 8192.;
1489	pCaps->StencilCaps \|= D3DSTENCILCAPS_TWOSIDED;
1490	pCaps->DeclTypes \|= D3DDTCAPS_FLOAT16_2 \| D3DDTCAPS_FLOAT16_4;
1491	pCaps->VS20Caps.DynamicFlowControlDepth = 24;
1492	pCaps->VS20Caps.NumTemps = D3DVS20_MAX_NUMTEMPS;
1493	pCaps->PS20Caps.DynamicFlowControlDepth = 24;
1494	pCaps->PS20Caps.NumTemps = D3DVS20_MAX_NUMTEMPS;
1495	pCaps->VertexTextureFilterCaps \|= D3DPTFILTERCAPS_MINFPOINT \| D3DPTFILTERCAPS_MAGFPOINT;
1496	#if 1 /* workaround for wine not returning InstructionSlots correctly for shaders v3.0 */
1497	if ((pCaps->VertexShaderVersion & 0xff00) == 0x0300)
1498	{
1499	pCaps->MaxVertexShader30InstructionSlots = RT_MIN(32768, pCaps->MaxVertexShader30InstructionSlots);
1500	pCaps->MaxPixelShader30InstructionSlots = RT_MIN(32768, pCaps->MaxPixelShader30InstructionSlots);
1501	}
1502	#endif
1503	#ifdef DEBUG
1504	if ((pCaps->VertexShaderVersion & 0xff00) == 0x0300)
1505	{
1506	Assert(pCaps->MaxVertexShader30InstructionSlots >= 512);
1507	Assert(pCaps->MaxVertexShader30InstructionSlots <= 32768);
1508	Assert(pCaps->MaxPixelShader30InstructionSlots >= 512);
1509	Assert(pCaps->MaxPixelShader30InstructionSlots <= 32768);
1510	}
1511	else if ((pCaps->VertexShaderVersion & 0xff00) == 0x0200)
1512	{
1513	Assert(pCaps->MaxVertexShader30InstructionSlots == 0);
1514	Assert(pCaps->MaxPixelShader30InstructionSlots == 0);
1515	}
1516	else
1517	{
1518	AssertBreakpoint();
1519	}
1520	#endif
1521	break;
1522	}
1523
1524	vboxVDbgPrintR((__FUNCTION__": GetDeviceCaps hr(%d)\n", hr));
1525	/* let's fall back to the 3D disabled case */
1526	hr = S_OK;
1527	}
1528
1529	memset(pData->pData, 0, sizeof (D3DCAPS9));
1530	}
1531	else
1532	hr = E_INVALIDARG;
1533	break;
1534	}
1535	case D3DDDICAPS_GETGAMMARAMPCAPS:
1536	((uint32_t)pData->pData) = 0;
1537	break;
1538	case D3DDDICAPS_GETVIDEOPROCESSORCAPS:
1539	case D3DDDICAPS_GETEXTENSIONGUIDCOUNT:
1540	case D3DDDICAPS_GETDECODEGUIDCOUNT:
1541	case D3DDDICAPS_GETVIDEOPROCESSORDEVICEGUIDCOUNT:
1542	if (pData->pData && pData->DataSize)
1543	memset(pData->pData, 0, pData->DataSize);
1544	break;
1545	case D3DDDICAPS_GETMULTISAMPLEQUALITYLEVELS:
1546	case D3DDDICAPS_GETD3D5CAPS:
1547	case D3DDDICAPS_GETD3D6CAPS:
1548	case D3DDDICAPS_GETD3D8CAPS:
1549	case D3DDDICAPS_GETDECODEGUIDS:
1550	case D3DDDICAPS_GETDECODERTFORMATCOUNT:
1551	case D3DDDICAPS_GETDECODERTFORMATS:
1552	case D3DDDICAPS_GETDECODECOMPRESSEDBUFFERINFOCOUNT:
1553	case D3DDDICAPS_GETDECODECOMPRESSEDBUFFERINFO:
1554	case D3DDDICAPS_GETDECODECONFIGURATIONCOUNT:
1555	case D3DDDICAPS_GETDECODECONFIGURATIONS:
1556	case D3DDDICAPS_GETVIDEOPROCESSORDEVICEGUIDS:
1557	case D3DDDICAPS_GETVIDEOPROCESSORRTFORMATCOUNT:
1558	case D3DDDICAPS_GETVIDEOPROCESSORRTFORMATS:
1559	case D3DDDICAPS_GETVIDEOPROCESSORRTSUBSTREAMFORMATCOUNT:
1560	case D3DDDICAPS_GETVIDEOPROCESSORRTSUBSTREAMFORMATS:
1561	case D3DDDICAPS_GETPROCAMPRANGE:
1562	case D3DDDICAPS_FILTERPROPERTYRANGE:
1563	case D3DDDICAPS_GETEXTENSIONGUIDS:
1564	case D3DDDICAPS_GETEXTENSIONCAPS:
1565	vboxVDbgPrint((__FUNCTION__": unimplemented caps type(%d)\n", pData->Type));
1566	AssertBreakpoint();
1567	if (pData->pData && pData->DataSize)
1568	memset(pData->pData, 0, pData->DataSize);
1569	break;
1570	default:
1571	vboxVDbgPrint((__FUNCTION__": unknown caps type(%d)\n", pData->Type));
1572	AssertBreakpoint();
1573	}
1574
1575	vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p), caps type(%d)\n", hAdapter, pData->Type));
1576
1577	return S_OK;
1578	}
1579
1580	static HRESULT APIENTRY vboxWddmDDevSetRenderState(HANDLE hDevice, CONST D3DDDIARG_RENDERSTATE* pData)
1581	{
1582	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1583	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1584	Assert(pDevice);
1585	Assert(pDevice->pDevice9If);
1586	HRESULT hr = pDevice->pDevice9If->SetRenderState(vboxDDI2D3DRenderStateType(pData->State), pData->Value);
1587	Assert(hr == S_OK);
1588	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1589	return hr;
1590	}
1591
1592	static HRESULT APIENTRY vboxWddmDDevUpdateWInfo(HANDLE hDevice, CONST D3DDDIARG_WINFO* pData)
1593	{
1594	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1595	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1596	return S_OK;
1597	}
1598
1599	static HRESULT APIENTRY vboxWddmDDevValidateDevice(HANDLE hDevice, D3DDDIARG_VALIDATETEXTURESTAGESTATE* pData)
1600	{
1601	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1602	AssertBreakpoint();
1603	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1604	return E_FAIL;
1605	}
1606
1607	static HRESULT APIENTRY vboxWddmDDevSetTextureStageState(HANDLE hDevice, CONST D3DDDIARG_TEXTURESTAGESTATE* pData)
1608	{
1609	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1610	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1611	Assert(pDevice);
1612	Assert(pDevice->pDevice9If);
1613
1614	VBOXWDDMDISP_TSS_LOOKUP lookup = vboxDDI2D3DTestureStageStateType(pData->State);
1615	HRESULT hr;
1616
1617	if (!lookup.bSamplerState)
1618	{
1619	hr = pDevice->pDevice9If->SetTextureStageState(pData->Stage, D3DTEXTURESTAGESTATETYPE(lookup.dType), pData->Value);
1620	}
1621	else
1622	{
1623	hr = pDevice->pDevice9If->SetSamplerState(pData->Stage, D3DSAMPLERSTATETYPE(lookup.dType), pData->Value);
1624	}
1625
1626	Assert(hr == S_OK);
1627	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1628	return hr;
1629	}
1630
1631	static HRESULT APIENTRY vboxWddmDDevSetTexture(HANDLE hDevice, UINT Stage, HANDLE hTexture)
1632	{
1633	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1634	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1635	Assert(pDevice);
1636	Assert(pDevice->pDevice9If);
1637	PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)hTexture;
1638	// Assert(pRc);
1639	IDirect3DTexture9 *pD3DIfTex;
1640	if (pRc)
1641	{
1642	Assert(pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE);
1643	pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf;
1644	}
1645	else
1646	pD3DIfTex = NULL;
1647
1648	// Assert(pD3DIfTex);
1649	HRESULT hr = pDevice->pDevice9If->SetTexture(Stage, pD3DIfTex);
1650	Assert(hr == S_OK);
1651	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1652	return hr;
1653	}
1654
1655	static HRESULT APIENTRY vboxWddmDDevSetPixelShader(HANDLE hDevice, HANDLE hShaderHandle)
1656	{
1657	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1658	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1659	Assert(pDevice);
1660	Assert(pDevice->pDevice9If);
1661	IDirect3DPixelShader9 pShader = (IDirect3DPixelShader9)hShaderHandle;
1662	Assert(pShader);
1663	HRESULT hr = pDevice->pDevice9If->SetPixelShader(pShader);
1664	Assert(hr == S_OK);
1665	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1666	return hr;
1667	}
1668
1669	static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONST* pData, CONST FLOAT* pRegisters)
1670	{
1671	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1672	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1673	Assert(pDevice);
1674	Assert(pDevice->pDevice9If);
1675	HRESULT hr = pDevice->pDevice9If->SetPixelShaderConstantF(pData->Register, pRegisters, pData->Count);
1676	Assert(hr == S_OK);
1677	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1678	return hr;
1679	}
1680
1681	static HRESULT APIENTRY vboxWddmDDevSetStreamSourceUm(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEUM* pData, CONST VOID* pUMBuffer )
1682	{
1683	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1684	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1685	Assert(pDevice);
1686	Assert(pDevice->pDevice9If);
1687	HRESULT hr = S_OK;
1688	// IDirect3DVertexBuffer9 *pStreamData;
1689	// UINT cbOffset;
1690	// UINT cbStride;
1691	// hr = pDevice->pDevice9If->GetStreamSource(pData->Stream, &pStreamData, &cbOffset, &cbStride);
1692	// Assert(hr == S_OK);
1693	// if (hr == S_OK)
1694	// {
1695	// if (pStreamData)
1696	// {
1697	// AssertBreakpoint();
1698	// /* @todo: impl! */
1699	// }
1700	// else
1701	// {
1702	Assert(pData->Stream < RT_ELEMENTS(pDevice->aStreamSourceUm));
1703	PVBOXWDDMDISP_STREAMSOURCEUM pStrSrcUm = &pDevice->aStreamSourceUm[pData->Stream];
1704	pStrSrcUm->pvBuffer = pUMBuffer;
1705	pStrSrcUm->cbStride = pData->Stride;
1706	// }
1707	// }
1708	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1709	return hr;
1710	}
1711
1712	static HRESULT APIENTRY vboxWddmDDevSetIndices(HANDLE hDevice, CONST D3DDDIARG_SETINDICES* pData)
1713	{
1714	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1715	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1716	Assert(pDevice);
1717	Assert(pDevice->pDevice9If);
1718	PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hIndexBuffer;
1719	PVBOXWDDMDISP_ALLOCATION pAlloc = NULL;
1720	IDirect3DIndexBuffer9 *pIndexBuffer = NULL;
1721	if (pRc)
1722	{
1723	Assert(pRc->cAllocations == 1);
1724	pAlloc = &pRc->aAllocations[0];
1725	Assert(pAlloc->pD3DIf);
1726	pIndexBuffer = (IDirect3DIndexBuffer9*)pAlloc->pD3DIf;
1727	}
1728	HRESULT hr = pDevice->pDevice9If->SetIndices(pIndexBuffer);
1729	Assert(hr == S_OK);
1730	if (hr == S_OK)
1731	{
1732	pDevice->pIndicesAlloc = pAlloc;
1733	pDevice->IndiciesInfo.uiStride = pData->Stride;
1734	}
1735	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1736	return hr;
1737	}
1738
1739	static HRESULT APIENTRY vboxWddmDDevSetIndicesUm(HANDLE hDevice, UINT IndexSize, CONST VOID* pUMBuffer)
1740	{
1741	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1742	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1743	Assert(pDevice);
1744	Assert(pDevice->pDevice9If);
1745	HRESULT hr = S_OK;
1746	pDevice->IndiciesUm.pvBuffer = pUMBuffer;
1747	pDevice->IndiciesUm.cbSize = IndexSize;
1748	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1749	return hr;
1750	}
1751
1752	static HRESULT APIENTRY vboxWddmDDevDrawPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE* pData, CONST UINT* pFlagBuffer)
1753	{
1754	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
1755	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
1756	Assert(pDevice);
1757	Assert(pDevice->pDevice9If);
1758	Assert(!pFlagBuffer);
1759	HRESULT hr = S_OK;
1760
1761	if (!pDevice->cStreamSources)
1762	{
1763	if (pDevice->aStreamSourceUm[0].pvBuffer)
1764	{
1765	#ifdef DEBUG
1766	for (UINT i = 1; i < RT_ELEMENTS(pDevice->aStreamSourceUm); ++i)
1767	{
1768	Assert(!pDevice->aStreamSourceUm[i].pvBuffer);
1769	}
1770	#endif
1771	hr = pDevice->pDevice9If->DrawPrimitiveUP(pData->PrimitiveType,
1772	pData->PrimitiveCount,
1773	((uint8_t)pDevice->aStreamSourceUm[0].pvBuffer) + pData->VStart pDevice->aStreamSourceUm[0].cbStride,
1774	pDevice->aStreamSourceUm[0].cbStride);
1775	Assert(hr == S_OK);
1776	}
1777	else
1778	{
1779	/* todo: impl */
1780	AssertBreakpoint();
1781	}
1782	}
1783	else
1784	{
1785	hr = pDevice->pDevice9If->DrawPrimitive(pData->PrimitiveType,
1786	pData->VStart,
1787	pData->PrimitiveCount);
1788	Assert(hr == S_OK);
1789	#if 0
1790	IDirect3DVertexDeclaration9* pDecl;
1791	hr = pDevice->pDevice9If->GetVertexDeclaration(&pDecl);
1792	Assert(hr == S_OK);
1793	if (hr == S_OK)
1794	{
1795	Assert(pDecl);
1796	D3DVERTEXELEMENT9 aDecls9[MAXD3DDECLLENGTH];
1797	UINT cDecls9 = 0;
1798	hr = pDecl->GetDeclaration(aDecls9, &cDecls9);
1799	Assert(hr == S_OK);
1800	if (hr == S_OK)
1801	{
1802	Assert(cDecls9);
1803	for (UINT i = 0; i < cDecls9 - 1 /* the last one is D3DDECL_END */; ++i)
1804	{
1805	D3DVERTEXELEMENT9 *pDecl9 = &aDecls9[i];
1806	Assert(pDecl9->Stream < RT_ELEMENTS(pDevice->aStreamSourceUm) \|\| pDecl9->Stream == 0xff);
1807	if (pDecl9->Stream != 0xff)
1808	{
1809	PVBOXWDDMDISP_STREAMSOURCEUM pStrSrc = &pDevice->aStreamSourceUm[pDecl9->Stream];
1810	if (pStrSrc->pvBuffer)
1811	{
1812	WORD iStream = pDecl9->Stream;
1813	D3DVERTEXELEMENT9 *pLastCDecl9 = pDecl9;
1814	for (UINT j = i+1; j < cDecls9 - 1 /* the last one is D3DDECL_END */; ++j)
1815	{
1816	pDecl9 = &aDecls9[j];
1817	if (iStream == pDecl9->Stream)
1818	{
1819	pDecl9->Stream = 0xff; /* mark as done */
1820	Assert(pDecl9->Offset != pLastCDecl9->Offset);
1821	if (pDecl9->Offset > pLastCDecl9->Offset)
1822	pLastCDecl9 = pDecl9;
1823	}
1824	}
1825	/* vertex size is MAX(all Offset's) + sizeof (data_type with MAX offset) + stride*/
1826	UINT cbVertex = pLastCDecl9->Offset + pStrSrc->cbStride;
1827	UINT cbType;
1828	switch (pLastCDecl9->Type)
1829	{
1830	case D3DDECLTYPE_FLOAT1:
1831	cbType = sizeof (float);
1832	break;
1833	case D3DDECLTYPE_FLOAT2:
1834	cbType = sizeof (float) * 2;
1835	break;
1836	case D3DDECLTYPE_FLOAT3:
1837	cbType = sizeof (float) * 3;
1838	break;
1839	case D3DDECLTYPE_FLOAT4:
1840	cbType = sizeof (float) * 4;
1841	break;
1842	case D3DDECLTYPE_D3DCOLOR:
1843	cbType = 4;
1844	break;
1845	case D3DDECLTYPE_UBYTE4:
1846	cbType = 4;
1847	break;
1848	case D3DDECLTYPE_SHORT2:
1849	cbType = sizeof (short) * 2;
1850	break;
1851	case D3DDECLTYPE_SHORT4:
1852	cbType = sizeof (short) * 4;
1853	break;
1854	case D3DDECLTYPE_UBYTE4N:
1855	cbType = 4;
1856	break;
1857	case D3DDECLTYPE_SHORT2N:
1858	cbType = sizeof (short) * 2;
1859	break;
1860	case D3DDECLTYPE_SHORT4N:
1861	cbType = sizeof (short) * 4;
1862	break;
1863	case D3DDECLTYPE_USHORT2N:
1864	cbType = sizeof (short) * 2;
1865	break;
1866	case D3DDECLTYPE_USHORT4N:
1867	cbType = sizeof (short) * 4;
1868	break;
1869	case D3DDECLTYPE_UDEC3:
1870	cbType = sizeof (signed) * 3;
1871	break;
1872	case D3DDECLTYPE_DEC3N:
1873	cbType = sizeof (unsigned) * 3;
1874	break;
1875	case D3DDECLTYPE_FLOAT16_2:
1876	cbType = 2 * 2;
1877	break;
1878	case D3DDECLTYPE_FLOAT16_4:
1879	cbType = 2 * 4;
1880	break;
1881	default:
1882	AssertBreakpoint();
1883	cbType = 1;
1884	}
1885	cbVertex += cbType;
1886
1887	UINT cVertexes;
1888	switch (pData->PrimitiveType)
1889	{
1890	case D3DPT_POINTLIST:
1891	cVertexes = pData->PrimitiveCount;
1892	break;
1893	case D3DPT_LINELIST:
1894	cVertexes = pData->PrimitiveCount * 2;
1895	break;
1896	case D3DPT_LINESTRIP:
1897	cVertexes = pData->PrimitiveCount + 1;
1898	break;
1899	case D3DPT_TRIANGLELIST:
1900	cVertexes = pData->PrimitiveCount * 3;
1901	break;
1902	case D3DPT_TRIANGLESTRIP:
1903	cVertexes = pData->PrimitiveCount + 2;
1904	break;
1905	case D3DPT_TRIANGLEFAN:
1906	cVertexes = pData->PrimitiveCount + 2;
1907	break;
1908	default:
1909	AssertBreakpoint();
1910	cVertexes = pData->PrimitiveCount;
1911	}
1912	UINT cbVertexes = cVertexes * cbVertex;
1913	IDirect3DVertexBuffer9 pCurVb = NULL, pVb = NULL;
1914	UINT cbOffset;
1915	UINT cbStride;
1916	hr = pDevice->pDevice9If->GetStreamSource(iStream, &pCurVb, &cbOffset, &cbStride);
1917	Assert(hr == S_OK);
1918	if (hr == S_OK)
1919	{
1920	if (pCurVb)
1921	{
1922	if (cbStride == pStrSrc->cbStride)
1923	{
1924	/* ensure our data feets in the buffer */
1925	D3DVERTEXBUFFER_DESC Desc;
1926	hr = pCurVb->GetDesc(&Desc);
1927	Assert(hr == S_OK);
1928	if (hr == S_OK)
1929	{
1930	if (Desc.Size >= cbVertexes)
1931	pVb = pCurVb;
1932	}
1933	}
1934	}
1935	}
1936	else
1937	{
1938	pCurVb = NULL;
1939	}
1940
1941	if (!pVb)
1942	{
1943	hr = pDevice->pDevice9If->CreateVertexBuffer(cbVertexes,
1944	0, /* DWORD Usage */
1945	0, /* DWORD FVF */
1946	D3DPOOL_DEFAULT, /* D3DPOOL Pool */
1947	&pVb,
1948	NULL /HANDLE pSharedHandle*/);
1949	Assert(hr == S_OK);
1950	if (hr == S_OK)
1951	{
1952	hr = pDevice->pDevice9If->SetStreamSource(iStream, pVb, 0, pStrSrc->cbStride);
1953	Assert(hr == S_OK);
1954	if (hr == S_OK)
1955	{
1956	if (pCurVb)
1957	pCurVb->Release();
1958	}
1959	else
1960	{
1961	pVb->Release();
1962	pVb = NULL;
1963	}
1964	}
1965	}
1966
1967	if (pVb)
1968	{
1969	Assert(hr == S_OK);
1970	VOID *pvData;
1971	hr = pVb->Lock(0, /* UINT OffsetToLock */
1972	cbVertexes,
1973	&pvData,
1974	D3DLOCK_DISCARD);
1975	Assert(hr == S_OK);
1976	if (hr == S_OK)
1977	{
1978	memcpy (pvData, ((uint8_t)pStrSrc->pvBuffer) + pData->VStart cbVertex, cbVertexes);
1979	HRESULT tmpHr = pVb->Unlock();
1980	Assert(tmpHr == S_OK);
1981	}
1982	}
1983	}
1984	}
1985	}
1986	}
1987	if (hr == S_OK)
1988	{
1989	hr = pDevice->pDevice9If->DrawPrimitive(pData->PrimitiveType,
1990	0 /* <- since we use our owne StreamSource buffer which has data at the very beginning*/,
1991	pData->PrimitiveCount);
1992	Assert(hr == S_OK);
1993	}
1994	}
1995	#endif
1996	}
1997	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
1998	return hr;
1999	}
2000
2001	static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE* pData)
2002	{
2003	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2004	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2005	Assert(pDevice);
2006	Assert(pDevice->pDevice9If);
2007	HRESULT hr = pDevice->pDevice9If->DrawIndexedPrimitive(
2008	pData->PrimitiveType,
2009	pData->BaseVertexIndex,
2010	pData->MinIndex,
2011	pData->NumVertices,
2012	pData->StartIndex,
2013	pData->PrimitiveCount);
2014	Assert(hr == S_OK);
2015
2016	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2017	return hr;
2018	}
2019
2020	static HRESULT APIENTRY vboxWddmDDevDrawRectPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWRECTPATCH* pData, CONST D3DDDIRECTPATCH_INFO* pInfo, CONST FLOAT* pPatch)
2021	{
2022	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2023	AssertBreakpoint();
2024	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2025	return E_FAIL;
2026	}
2027
2028	static HRESULT APIENTRY vboxWddmDDevDrawTriPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWTRIPATCH* pData, CONST D3DDDITRIPATCH_INFO* pInfo, CONST FLOAT* pPatch)
2029	{
2030	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2031	AssertBreakpoint();
2032	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2033	return E_FAIL;
2034	}
2035
2036	static HRESULT APIENTRY vboxWddmDDevDrawPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE2* pData)
2037	{
2038	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2039	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2040	Assert(pDevice);
2041	Assert(pDevice->pDevice9If);
2042	HRESULT hr;
2043
2044	#if 0
2045	int stream;
2046	for (stream=0; stream<VBOXWDDMDISP_MAX_VERTEX_STREAMS; ++stream)
2047	{
2048	if (pDevice->aStreamSource[stream] && pDevice->aStreamSource[stream]->LockInfo.cLocks)
2049	{
2050	VBOXWDDMDISP_LOCKINFO *pLock = &pDevice->aStreamSource[stream]->LockInfo;
2051	if (pLock->fFlags.MightDrawFromLocked && (pLock->fFlags.Discard \|\| pLock->fFlags.NoOverwrite))
2052	{
2053	IDirect3DVertexBuffer9 pD3D9VBuf = (IDirect3DVertexBuffer9)pDevice->aStreamSource[stream]->pD3DIf;
2054	Assert(pLock->fFlags.RangeValid);
2055	pD3D9VBuf->Lock(pLock->Range.Offset, pLock->Range.Size,
2056	&pLock->LockedRect.pBits,
2057	vboxDDI2D3DLockFlags(pLock->fFlags));
2058	RECT r;
2059	r.top = 0;
2060	r.left = pLock->Range.Offset;
2061	r.bottom = 1;
2062	r.right = pLock->Range.Offset + pLock->Range.Size;
2063
2064	vboxWddmLockUnlockMemSynch(pDevice->aStreamSource[stream], &pLock->LockedRect, &r, true /bool bToLockInfo/);
2065
2066	pD3D9VBuf->Unlock();
2067	}
2068	}
2069	}
2070
2071	hr = pDevice->pDevice9If->DrawPrimitive(pData->PrimitiveType, pData->FirstVertexOffset, pData->PrimitiveCount);
2072	#else
2073	int stream;
2074	for (stream=0; stream<VBOXWDDMDISP_MAX_VERTEX_STREAMS; ++stream)
2075	{
2076	if (pDevice->aStreamSource[stream])
2077	{
2078	Assert(stream==0); /only stream 0 should be accessed here/
2079	Assert(pDevice->StreamSourceInfo[stream].uiStride!=0);
2080	VBOXWDDMDISP_LOCKINFO *pLock = &pDevice->aStreamSource[stream]->LockInfo;
2081
2082	if (pDevice->aStreamSource[stream]->LockInfo.cLocks)
2083	{
2084	Assert(pLock->fFlags.MightDrawFromLocked && (pLock->fFlags.Discard \|\| pLock->fFlags.NoOverwrite));
2085	hr = pDevice->pDevice9If->DrawPrimitiveUP(pData->PrimitiveType, pData->PrimitiveCount,
2086	(void*)((uintptr_t)pDevice->aStreamSource[stream]->pvMem+pDevice->StreamSourceInfo[stream].uiOffset+pData->FirstVertexOffset),
2087	pDevice->StreamSourceInfo[stream].uiStride);
2088	Assert(hr == S_OK);
2089	hr = pDevice->pDevice9If->SetStreamSource(stream, (IDirect3DVertexBuffer9*)pDevice->aStreamSource[stream]->pD3DIf, pDevice->StreamSourceInfo[stream].uiOffset, pDevice->StreamSourceInfo[stream].uiStride);
2090	}
2091	else
2092	{
2093	hr = pDevice->pDevice9If->DrawPrimitive(pData->PrimitiveType, pData->FirstVertexOffset/pDevice->StreamSourceInfo[stream].uiStride, pData->PrimitiveCount);
2094	}
2095	}
2096	}
2097	#endif
2098
2099	Assert(hr == S_OK);
2100	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2101	return hr;
2102	}
2103
2104	static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE2* pData, UINT dwIndicesSize, CONST VOID* pIndexBuffer, CONST UINT* pFlagBuffer)
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
2112	static HRESULT APIENTRY vboxWddmDDevVolBlt(HANDLE hDevice, CONST D3DDDIARG_VOLUMEBLT* pData)
2113	{
2114	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2115	AssertBreakpoint();
2116	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2117	return E_FAIL;
2118	}
2119
2120	static HRESULT APIENTRY vboxWddmDDevBufBlt(HANDLE hDevice, CONST D3DDDIARG_BUFFERBLT* pData)
2121	{
2122	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2123	AssertBreakpoint();
2124	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2125	return E_FAIL;
2126	}
2127
2128	static HRESULT APIENTRY vboxWddmDDevTexBlt(HANDLE hDevice, CONST D3DDDIARG_TEXBLT* pData)
2129	{
2130	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2131	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2132	Assert(pDevice);
2133	Assert(pDevice->pDevice9If);
2134	PVBOXWDDMDISP_RESOURCE pDstRc = (PVBOXWDDMDISP_RESOURCE)pData->hDstResource;
2135	PVBOXWDDMDISP_RESOURCE pSrcRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
2136	IDirect3DTexture9 pD3DIfSrcTex = (IDirect3DTexture9)pSrcRc->aAllocations[0].pD3DIf;
2137	IDirect3DTexture9 pD3DIfDstTex = (IDirect3DTexture9)pDstRc->aAllocations[0].pD3DIf;
2138	Assert(pD3DIfSrcTex);
2139	Assert(pD3DIfDstTex);
2140	HRESULT hr = S_OK;
2141
2142	if (pSrcRc->aAllocations[0].SurfDesc.width == pDstRc->aAllocations[0].SurfDesc.width
2143	&& pSrcRc->aAllocations[0].SurfDesc.height == pDstRc->aAllocations[0].SurfDesc.height
2144	&& pSrcRc->RcDesc.enmFormat == pDstRc->RcDesc.enmFormat)
2145	{
2146	/* first check if we can do IDirect3DDevice9::UpdateTexture */
2147	if (pData->DstPoint.x == 0 && pData->DstPoint.y == 0
2148	&& pData->SrcRect.left == 0 && pData->SrcRect.top == 0
2149	&& pData->SrcRect.right - pData->SrcRect.left == pSrcRc->aAllocations[0].SurfDesc.width
2150	&& pData->SrcRect.bottom - pData->SrcRect.top == pSrcRc->aAllocations[0].SurfDesc.height)
2151	{
2152	hr = pDevice->pDevice9If->UpdateTexture(pD3DIfSrcTex, pD3DIfDstTex);
2153	Assert(hr == S_OK);
2154	}
2155	else
2156	{
2157	AssertBreakpoint();
2158	/* @todo: impl */
2159	}
2160	}
2161	else
2162	{
2163	AssertBreakpoint();
2164	/* @todo: impl */
2165	}
2166
2167	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2168	return hr;
2169	}
2170
2171	static HRESULT APIENTRY vboxWddmDDevStateSet(HANDLE hDevice, D3DDDIARG_STATESET* pData)
2172	{
2173	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2174	AssertBreakpoint();
2175	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2176	return E_FAIL;
2177	}
2178	static HRESULT APIENTRY vboxWddmDDevSetPriority(HANDLE hDevice, CONST D3DDDIARG_SETPRIORITY* pData)
2179	{
2180	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2181	AssertBreakpoint();
2182	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2183	return E_FAIL;
2184	}
2185	AssertCompile(sizeof (RECT) == sizeof (D3DRECT));
2186	AssertCompile(RT_SIZEOFMEMB(RECT, left) == RT_SIZEOFMEMB(D3DRECT, x1));
2187	AssertCompile(RT_SIZEOFMEMB(RECT, right) == RT_SIZEOFMEMB(D3DRECT, x2));
2188	AssertCompile(RT_SIZEOFMEMB(RECT, top) == RT_SIZEOFMEMB(D3DRECT, y1));
2189	AssertCompile(RT_SIZEOFMEMB(RECT, bottom) == RT_SIZEOFMEMB(D3DRECT, y2));
2190	AssertCompile(RT_OFFSETOF(RECT, left) == RT_OFFSETOF(D3DRECT, x1));
2191	AssertCompile(RT_OFFSETOF(RECT, right) == RT_OFFSETOF(D3DRECT, x2));
2192	AssertCompile(RT_OFFSETOF(RECT, top) == RT_OFFSETOF(D3DRECT, y1));
2193	AssertCompile(RT_OFFSETOF(RECT, bottom) == RT_OFFSETOF(D3DRECT, y2));
2194
2195	static HRESULT APIENTRY vboxWddmDDevClear(HANDLE hDevice, CONST D3DDDIARG_CLEAR* pData, UINT NumRect, CONST RECT* pRect)
2196	{
2197	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2198	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2199	Assert(pDevice);
2200	Assert(pDevice->pDevice9If);
2201	HRESULT hr = pDevice->pDevice9If->Clear(NumRect, (D3DRECT)pRect / see AssertCompile above */,
2202	pData->Flags,
2203	pData->FillColor,
2204	pData->FillDepth,
2205	pData->FillStencil);
2206	Assert(hr == S_OK);
2207	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2208	return hr;
2209	}
2210	static HRESULT APIENTRY vboxWddmDDevUpdatePalette(HANDLE hDevice, CONST D3DDDIARG_UPDATEPALETTE* pData, CONST PALETTEENTRY* pPaletteData)
2211	{
2212	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2213	AssertBreakpoint();
2214	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2215	return E_FAIL;
2216	}
2217
2218	static HRESULT APIENTRY vboxWddmDDevSetPalette(HANDLE hDevice, CONST D3DDDIARG_SETPALETTE* pData)
2219	{
2220	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2221	AssertBreakpoint();
2222	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2223	return E_FAIL;
2224	}
2225
2226	static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONST* pData , CONST VOID* pRegisters)
2227	{
2228	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2229	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2230	Assert(pDevice);
2231	Assert(pDevice->pDevice9If);
2232	HRESULT hr = pDevice->pDevice9If->SetVertexShaderConstantF(
2233	pData->Register,
2234	(CONST float*)pRegisters,
2235	pData->Count);
2236	Assert(hr == S_OK);
2237	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2238	return hr;
2239	}
2240	static HRESULT APIENTRY vboxWddmDDevMultiplyTransform(HANDLE hDevice, CONST D3DDDIARG_MULTIPLYTRANSFORM* pData)
2241	{
2242	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2243	AssertBreakpoint();
2244	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2245	return E_FAIL;
2246	}
2247	static HRESULT APIENTRY vboxWddmDDevSetTransform(HANDLE hDevice, CONST D3DDDIARG_SETTRANSFORM* pData)
2248	{
2249	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2250	AssertBreakpoint();
2251	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2252	return E_FAIL;
2253	}
2254	static HRESULT APIENTRY vboxWddmDDevSetViewport(HANDLE hDevice, CONST D3DDDIARG_VIEWPORTINFO* pData)
2255	{
2256	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2257	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2258	Assert(pDevice);
2259	Assert(pDevice->pDevice9If);
2260	pDevice->ViewPort.X = pData->X;
2261	pDevice->ViewPort.Y = pData->Y;
2262	pDevice->ViewPort.Width = pData->Width;
2263	pDevice->ViewPort.Height = pData->Height;
2264	HRESULT hr = pDevice->pDevice9If->SetViewport(&pDevice->ViewPort);
2265	Assert(hr == S_OK);
2266	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2267	return hr;
2268	}
2269	static HRESULT APIENTRY vboxWddmDDevSetZRange(HANDLE hDevice, CONST D3DDDIARG_ZRANGE* pData)
2270	{
2271	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2272	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2273	Assert(pDevice);
2274	Assert(pDevice->pDevice9If);
2275	pDevice->ViewPort.MinZ = pData->MinZ;
2276	pDevice->ViewPort.MaxZ = pData->MaxZ;
2277	HRESULT hr = pDevice->pDevice9If->SetViewport(&pDevice->ViewPort);
2278	Assert(hr == S_OK);
2279	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2280	return hr;
2281	}
2282	static HRESULT APIENTRY vboxWddmDDevSetMaterial(HANDLE hDevice, CONST D3DDDIARG_SETMATERIAL* pData)
2283	{
2284	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2285	AssertBreakpoint();
2286	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2287	return E_FAIL;
2288	}
2289	static HRESULT APIENTRY vboxWddmDDevSetLight(HANDLE hDevice, CONST D3DDDIARG_SETLIGHT* pData, CONST D3DDDI_LIGHT* pLightProperties)
2290	{
2291	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2292	AssertBreakpoint();
2293	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2294	return E_FAIL;
2295	}
2296	static HRESULT APIENTRY vboxWddmDDevCreateLight(HANDLE hDevice, CONST D3DDDIARG_CREATELIGHT* pData)
2297	{
2298	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2299	AssertBreakpoint();
2300	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2301	return E_FAIL;
2302	}
2303	static HRESULT APIENTRY vboxWddmDDevDestroyLight(HANDLE hDevice, CONST D3DDDIARG_DESTROYLIGHT* pData)
2304	{
2305	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2306	AssertBreakpoint();
2307	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2308	return E_FAIL;
2309	}
2310	static HRESULT APIENTRY vboxWddmDDevSetClipPlane(HANDLE hDevice, CONST D3DDDIARG_SETCLIPPLANE* pData)
2311	{
2312	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2313	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2314	Assert(pDevice);
2315	Assert(pDevice->pDevice9If);
2316	HRESULT hr = pDevice->pDevice9If->SetClipPlane(pData->Index, pData->Plane);
2317	Assert(hr == S_OK);
2318	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
2319	return hr;
2320	}
2321
2322	static HRESULT APIENTRY vboxWddmDDevGetInfo(HANDLE hDevice, UINT DevInfoID, VOID* pDevInfoStruct, UINT DevInfoSize)
2323	{
2324	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2325	AssertBreakpoint();
2326	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2327	return E_NOTIMPL;
2328	}
2329
2330	static HRESULT APIENTRY vboxWddmDDevLock(HANDLE hDevice, D3DDDIARG_LOCK* pData)
2331	{
2332	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2333	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2334	PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
2335	Assert(pData->SubResourceIndex < pRc->cAllocations);
2336	if (pData->SubResourceIndex >= pRc->cAllocations)
2337	return E_INVALIDARG;
2338
2339	HRESULT hr = S_OK;
2340
2341	if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
2342	{
2343	if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE)
2344	{
2345	PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
2346	Assert(pData->SubResourceIndex < pRc->cAllocations);
2347	PVBOXWDDMDISP_ALLOCATION pLockAlloc = &pRc->aAllocations[pData->SubResourceIndex];
2348	IDirect3DTexture9 pD3DIfTex = (IDirect3DTexture9)pTexAlloc->pD3DIf;
2349	Assert(pD3DIfTex);
2350	RECT *pRect = NULL;
2351	bool bNeedResynch = false;
2352	Assert(!pData->Flags.RangeValid);
2353	Assert(!pData->Flags.BoxValid);
2354	if (pData->Flags.AreaValid)
2355	{
2356	pRect = &pData->Area;
2357	}
2358
2359	/* else - we lock the entire texture, pRect == NULL */
2360
2361	// Assert(!pLockAlloc->LockInfo.cLocks);
2362	if (!pLockAlloc->LockInfo.cLocks)
2363	{
2364	hr = pD3DIfTex->LockRect(pData->SubResourceIndex,
2365	&pLockAlloc->LockInfo.LockedRect,
2366	pRect,
2367	vboxDDI2D3DLockFlags(pData->Flags));
2368	Assert(hr == S_OK);
2369	if (hr == S_OK)
2370	{
2371
2372	// Assert(pLockAlloc->LockInfo.fFlags.Value == 0);
2373	pLockAlloc->LockInfo.fFlags = pData->Flags;
2374	if (pRect)
2375	{
2376	pLockAlloc->LockInfo.Area = *pRect;
2377	Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 1);
2378	// pLockAlloc->LockInfo.fFlags.AreaValid = 1;
2379	}
2380	else
2381	{
2382	Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 0);
2383	// pLockAlloc->LockInfo.fFlags.AreaValid = 0;
2384	}
2385
2386	bNeedResynch = !pData->Flags.Discard;
2387	}
2388	}
2389	else
2390	{
2391	// Assert(pLockAlloc->LockInfo.fFlags.Value == pData->Flags.Value);
2392	// if (pLockAlloc->LockInfo.fFlags.Value != pData->Flags.Value)
2393	// {
2394	// }
2395	Assert(pLockAlloc->LockInfo.fFlags.AreaValid == pData->Flags.AreaValid);
2396	if (pLockAlloc->LockInfo.fFlags.AreaValid && pData->Flags.AreaValid)
2397	{
2398	Assert(pLockAlloc->LockInfo.Area.left == pData->Area.left);
2399	Assert(pLockAlloc->LockInfo.Area.top == pData->Area.top);
2400	Assert(pLockAlloc->LockInfo.Area.right == pData->Area.right);
2401	Assert(pLockAlloc->LockInfo.Area.bottom == pData->Area.bottom);
2402	}
2403	Assert(pLockAlloc->LockInfo.LockedRect.pBits);
2404
2405	bNeedResynch = pLockAlloc->LockInfo.fFlags.Discard && !pData->Flags.Discard;
2406
2407	Assert(!bNeedResynch);
2408
2409	if (/*(pLockAlloc->LockInfo.fFlags.Discard && !pData->Flags.Discard)
2410	\|\| */
2411	(pLockAlloc->LockInfo.fFlags.ReadOnly && !pData->Flags.ReadOnly))
2412	{
2413	hr = pD3DIfTex->UnlockRect(pData->SubResourceIndex);
2414	Assert(hr == S_OK);
2415	if (hr == S_OK)
2416	{
2417	hr = pD3DIfTex->LockRect(pData->SubResourceIndex,
2418	&pLockAlloc->LockInfo.LockedRect,
2419	pRect,
2420	vboxDDI2D3DLockFlags(pData->Flags));
2421	Assert(hr == S_OK);
2422	pLockAlloc->LockInfo.fFlags.ReadOnly = 0;
2423	}
2424	}
2425	}
2426
2427	if (hr == S_OK)
2428	{
2429	++pLockAlloc->LockInfo.cLocks;
2430
2431	if (!pData->Flags.NotifyOnly)
2432	{
2433	pData->pSurfData = pLockAlloc->LockInfo.LockedRect.pBits;
2434	pData->Pitch = pLockAlloc->LockInfo.LockedRect.Pitch;
2435	pData->SlicePitch = 0;
2436	Assert(pLockAlloc->SurfDesc.slicePitch == 0);
2437	Assert(!pLockAlloc->pvMem);
2438	}
2439	else
2440	{
2441	Assert(pLockAlloc->pvMem);
2442	Assert(pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
2443
2444	if (bNeedResynch)
2445	vboxWddmLockUnlockMemSynch(pLockAlloc, &pLockAlloc->LockInfo.LockedRect, pRect, false /bool bToLockInfo/);
2446	}
2447	}
2448	}
2449	else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VERTEXBUFFER)
2450	{
2451	Assert(pData->SubResourceIndex < pRc->cAllocations);
2452	PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
2453	IDirect3DVertexBuffer9 pD3D9VBuf = (IDirect3DVertexBuffer9)pAlloc->pD3DIf;
2454	BOOL bLocked = false;
2455	Assert(pD3D9VBuf);
2456	Assert(!pData->Flags.AreaValid);
2457	Assert(!pData->Flags.BoxValid);
2458	D3DDDIRANGE *pRange = NULL;
2459	if (pData->Flags.RangeValid)
2460	{
2461	pRange = &pData->Range;
2462	}
2463
2464	/* else - we lock the entire vertex buffer, pRect == NULL */
2465
2466	Assert(!pAlloc->LockInfo.cLocks);
2467	if (!pAlloc->LockInfo.cLocks)
2468	{
2469	if (!pData->Flags.MightDrawFromLocked \|\| (!pData->Flags.Discard && !pData->Flags.NoOverwrite))
2470	{
2471	hr = pD3D9VBuf->Lock(pRange ? pRange->Offset : 0,
2472	pRange ? pRange->Size : 0,
2473	&pAlloc->LockInfo.LockedRect.pBits,
2474	vboxDDI2D3DLockFlags(pData->Flags));
2475	bLocked = true;
2476	}
2477
2478	Assert(hr == S_OK);
2479	if (hr == S_OK)
2480	{
2481	pAlloc->LockInfo.LockedRect.Pitch = pAlloc->SurfDesc.width;
2482	// Assert(pLockAlloc->LockInfo.fFlags.Value == 0);
2483	pAlloc->LockInfo.fFlags = pData->Flags;
2484	if (pRange)
2485	{
2486	pAlloc->LockInfo.Range = *pRange;
2487	Assert(pAlloc->LockInfo.fFlags.RangeValid == 1);
2488	// pAlloc->LockInfo.fFlags.RangeValid = 1;
2489	}
2490	else
2491	{
2492	Assert(pAlloc->LockInfo.fFlags.RangeValid == 0);
2493	// pAlloc->LockInfo.fFlags.RangeValid = 0;
2494	}
2495	}
2496	}
2497	else
2498	{
2499	// Assert(pAlloc->LockInfo.fFlags.Value == pData->Flags.Value);
2500	// if (pAlloc->LockInfo.fFlags.Value != pData->Flags.Value)
2501	// {
2502	// }
2503	Assert(pAlloc->LockInfo.fFlags.RangeValid == pData->Flags.RangeValid);
2504	if (pAlloc->LockInfo.fFlags.RangeValid && pData->Flags.RangeValid)
2505	{
2506	Assert(pAlloc->LockInfo.Range.Offset == pData->Range.Offset);
2507	Assert(pAlloc->LockInfo.Range.Size == pData->Range.Size);
2508	}
2509	Assert(pAlloc->LockInfo.LockedRect.pBits);
2510	}
2511
2512	if (hr == S_OK)
2513	{
2514	++pAlloc->LockInfo.cLocks;
2515
2516	if (!pData->Flags.NotifyOnly)
2517	{
2518	pData->pSurfData = pAlloc->LockInfo.LockedRect.pBits;
2519	pData->Pitch = pAlloc->LockInfo.LockedRect.Pitch;
2520	pData->SlicePitch = 0;
2521	Assert(pAlloc->SurfDesc.slicePitch == 0);
2522	Assert(!pAlloc->pvMem);
2523	}
2524	else
2525	{
2526	Assert(pAlloc->pvMem);
2527	Assert(pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
2528	if (bLocked && !pData->Flags.Discard)
2529	{
2530	RECT r, *pr;
2531	if (pRange)
2532	{
2533	r.top = 0;
2534	r.left = pRange->Offset;
2535	r.bottom = 1;
2536	r.right = pRange->Offset + pRange->Size;
2537	pr = &r;
2538	}
2539	else
2540	pr = NULL;
2541	vboxWddmLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect, pr, false /bool bToLockInfo/);
2542	}
2543	}
2544	}
2545	}
2546	else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_INDEXBUFFER)
2547	{
2548	Assert(pData->SubResourceIndex < pRc->cAllocations);
2549	PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
2550	IDirect3DIndexBuffer9 pD3D9IBuf = (IDirect3DIndexBuffer9)pAlloc->pD3DIf;
2551	BOOL bLocked = false;
2552	Assert(pD3D9IBuf);
2553	Assert(!pData->Flags.AreaValid);
2554	Assert(!pData->Flags.BoxValid);
2555	D3DDDIRANGE *pRange = NULL;
2556	if (pData->Flags.RangeValid)
2557	{
2558	pRange = &pData->Range;
2559	}
2560
2561	/* else - we lock the entire vertex buffer, pRect == NULL */
2562
2563	Assert(!pAlloc->LockInfo.cLocks);
2564	if (!pAlloc->LockInfo.cLocks)
2565	{
2566	if (!pData->Flags.MightDrawFromLocked \|\| (!pData->Flags.Discard && !pData->Flags.NoOverwrite))
2567	{
2568	hr = pD3D9IBuf->Lock(pRange ? pRange->Offset : 0,
2569	pRange ? pRange->Size : 0,
2570	&pAlloc->LockInfo.LockedRect.pBits,
2571	vboxDDI2D3DLockFlags(pData->Flags));
2572	bLocked = true;
2573	}
2574
2575	Assert(hr == S_OK);
2576	if (hr == S_OK)
2577	{
2578	pAlloc->LockInfo.LockedRect.Pitch = pAlloc->SurfDesc.width;
2579	// Assert(pLockAlloc->LockInfo.fFlags.Value == 0);
2580	pAlloc->LockInfo.fFlags = pData->Flags;
2581	if (pRange)
2582	{
2583	pAlloc->LockInfo.Range = *pRange;
2584	Assert(pAlloc->LockInfo.fFlags.RangeValid == 1);
2585	// pAlloc->LockInfo.fFlags.RangeValid = 1;
2586	}
2587	else
2588	{
2589	Assert(pAlloc->LockInfo.fFlags.RangeValid == 0);
2590	// pAlloc->LockInfo.fFlags.RangeValid = 0;
2591	}
2592	}
2593	}
2594	else
2595	{
2596	// Assert(pAlloc->LockInfo.fFlags.Value == pData->Flags.Value);
2597	// if (pAlloc->LockInfo.fFlags.Value != pData->Flags.Value)
2598	// {
2599	// }
2600	Assert(pAlloc->LockInfo.fFlags.RangeValid == pData->Flags.RangeValid);
2601	if (pAlloc->LockInfo.fFlags.RangeValid && pData->Flags.RangeValid)
2602	{
2603	Assert(pAlloc->LockInfo.Range.Offset == pData->Range.Offset);
2604	Assert(pAlloc->LockInfo.Range.Size == pData->Range.Size);
2605	}
2606	Assert(pAlloc->LockInfo.LockedRect.pBits);
2607	}
2608
2609	if (hr == S_OK)
2610	{
2611	++pAlloc->LockInfo.cLocks;
2612
2613	if (!pData->Flags.NotifyOnly)
2614	{
2615	pData->pSurfData = pAlloc->LockInfo.LockedRect.pBits;
2616	pData->Pitch = pAlloc->LockInfo.LockedRect.Pitch;
2617	pData->SlicePitch = 0;
2618	Assert(pAlloc->SurfDesc.slicePitch == 0);
2619	Assert(!pAlloc->pvMem);
2620	}
2621	else
2622	{
2623	Assert(pAlloc->pvMem);
2624	Assert(pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
2625	if (bLocked && !pData->Flags.Discard)
2626	{
2627	RECT r, *pr;
2628	if (pRange)
2629	{
2630	r.top = 0;
2631	r.left = pRange->Offset;
2632	r.bottom = 1;
2633	r.right = pRange->Offset + pRange->Size;
2634	pr = &r;
2635	}
2636	else
2637	pr = NULL;
2638	vboxWddmLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect, pr, false /bool bToLockInfo/);
2639	}
2640	}
2641	}
2642	}
2643	else
2644	{
2645	AssertBreakpoint();
2646	}
2647	}
2648	else
2649	{
2650	PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
2651	D3DDDICB_LOCK LockData;
2652	LockData.hAllocation = pAlloc->hAllocation;
2653	LockData.PrivateDriverData = 0;
2654	LockData.NumPages = 0;
2655	LockData.pPages = NULL;
2656	LockData.pData = NULL; /* out */
2657	LockData.Flags.Value = 0;
2658	LockData.Flags.Discard = pData->Flags.Discard;
2659	LockData.Flags.DonotWait = pData->Flags.DoNotWait;
2660
2661
2662	hr = pDevice->RtCallbacks.pfnLockCb(pDevice->hDevice, &LockData);
2663	Assert(hr == S_OK \|\| (hr == D3DERR_WASSTILLDRAWING && pData->Flags.DoNotWait));
2664	if (hr == S_OK)
2665	{
2666	Assert(!pAlloc->LockInfo.cLocks);
2667
2668	uintptr_t offset;
2669	if (pData->Flags.AreaValid)
2670	{
2671	offset = pAlloc->SurfDesc.pitch * pData->Area.top +
2672	((pAlloc->SurfDesc.bpp * pData->Area.left) >> 3);
2673	}
2674	else if (pData->Flags.RangeValid)
2675	{
2676	offset = pData->Range.Offset;
2677	}
2678	else if (pData->Flags.BoxValid)
2679	{
2680	vboxVDbgPrintF((__FUNCTION__": Implement Box area"));
2681	AssertBreakpoint();
2682	}
2683	else
2684	{
2685	offset = 0;
2686	}
2687
2688	if (!pData->Flags.ReadOnly)
2689	{
2690	if (pData->Flags.AreaValid)
2691	vboxWddmDirtyRegionAddRect(&pAlloc->DirtyRegion, &pData->Area);
2692	else
2693	{
2694	Assert(!pData->Flags.RangeValid);
2695	Assert(!pData->Flags.BoxValid);
2696	vboxWddmDirtyRegionAddRect(&pAlloc->DirtyRegion, NULL); /* <- NULL means the entire surface */
2697	}
2698	}
2699
2700	if (pData->Flags.Discard)
2701	{
2702	/* check if the surface was renamed */
2703	if (LockData.hAllocation)
2704	pAlloc->hAllocation = LockData.hAllocation;
2705	}
2706
2707	pData->pSurfData = ((uint8_t*)LockData.pData) + offset;
2708	pData->Pitch = pAlloc->SurfDesc.pitch;
2709	pData->SlicePitch = pAlloc->SurfDesc.slicePitch;
2710
2711	Assert(hr == S_OK);
2712	++pAlloc->LockInfo.cLocks;
2713	}
2714	}
2715
2716	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(%d)\n", hDevice, hr));
2717	return hr;
2718	}
2719	static HRESULT APIENTRY vboxWddmDDevUnlock(HANDLE hDevice, CONST D3DDDIARG_UNLOCK* pData)
2720	{
2721	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2722	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2723	PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
2724	HRESULT hr = S_OK;
2725
2726	Assert(pData->SubResourceIndex < pRc->cAllocations);
2727	if (pData->SubResourceIndex >= pRc->cAllocations)
2728	return E_INVALIDARG;
2729
2730	if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
2731	{
2732	if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE)
2733	{
2734	Assert(pData->SubResourceIndex < pRc->cAllocations);
2735	PVBOXWDDMDISP_ALLOCATION pLockAlloc = &pRc->aAllocations[pData->SubResourceIndex];
2736
2737	--pLockAlloc->LockInfo.cLocks;
2738	Assert(pLockAlloc->LockInfo.cLocks < UINT32_MAX);
2739	// pLockAlloc->LockInfo.cLocks = 0;
2740	if (!pLockAlloc->LockInfo.cLocks)
2741	{
2742	PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
2743	// Assert(!pLockAlloc->LockInfo.cLocks);
2744	IDirect3DTexture9 pD3DIfTex = (IDirect3DTexture9)pTexAlloc->pD3DIf;
2745	Assert(pD3DIfTex);
2746	/* this is a sysmem texture, update */
2747	if (pLockAlloc->pvMem && !pLockAlloc->LockInfo.fFlags.ReadOnly)
2748	{
2749	vboxWddmLockUnlockMemSynch(pLockAlloc, &pLockAlloc->LockInfo.LockedRect,
2750	pLockAlloc->LockInfo.fFlags.AreaValid ? &pLockAlloc->LockInfo.Area : NULL,
2751	true /bool bToLockInfo/);
2752	}
2753	hr = pD3DIfTex->UnlockRect(pData->SubResourceIndex);
2754	Assert(hr == S_OK);
2755	}
2756	else
2757	{
2758	Assert(pLockAlloc->LockInfo.cLocks < UINT32_MAX);
2759	}
2760	}
2761	else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VERTEXBUFFER)
2762	{
2763	Assert(pData->SubResourceIndex < pRc->cAllocations);
2764	PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
2765
2766	--pAlloc->LockInfo.cLocks;
2767	Assert(pAlloc->LockInfo.cLocks < UINT32_MAX);
2768	if (!pAlloc->LockInfo.cLocks
2769	&& (!pAlloc->LockInfo.fFlags.MightDrawFromLocked
2770	\|\| (!pAlloc->LockInfo.fFlags.Discard && !pAlloc->LockInfo.fFlags.NoOverwrite)))
2771	{
2772	// Assert(!pAlloc->LockInfo.cLocks);
2773	IDirect3DVertexBuffer9 pD3D9VBuf = (IDirect3DVertexBuffer9)pAlloc->pD3DIf;
2774	Assert(pD3D9VBuf);
2775	/* this is a sysmem texture, update */
2776	if (pAlloc->pvMem && !pAlloc->LockInfo.fFlags.ReadOnly)
2777	{
2778	RECT r, *pr;
2779	if (pAlloc->LockInfo.fFlags.RangeValid)
2780	{
2781	r.top = 0;
2782	r.left = pAlloc->LockInfo.Range.Offset;
2783	r.bottom = 1;
2784	r.right = pAlloc->LockInfo.Range.Offset + pAlloc->LockInfo.Range.Size;
2785	pr = &r;
2786	}
2787	else
2788	pr = NULL;
2789	vboxWddmLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect,
2790	pr,
2791	true /bool bToLockInfo/);
2792	}
2793	hr = pD3D9VBuf->Unlock();
2794	Assert(hr == S_OK);
2795	}
2796	else
2797	{
2798	Assert(pAlloc->LockInfo.cLocks < UINT32_MAX);
2799	}
2800	}
2801	else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_INDEXBUFFER)
2802	{
2803	Assert(pData->SubResourceIndex < pRc->cAllocations);
2804	PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
2805
2806	--pAlloc->LockInfo.cLocks;
2807	Assert(pAlloc->LockInfo.cLocks < UINT32_MAX);
2808	if (!pAlloc->LockInfo.cLocks
2809	&& (!pAlloc->LockInfo.fFlags.MightDrawFromLocked
2810	\|\| (!pAlloc->LockInfo.fFlags.Discard && !pAlloc->LockInfo.fFlags.NoOverwrite)))
2811	{
2812	// Assert(!pAlloc->LockInfo.cLocks);
2813	IDirect3DIndexBuffer9 pD3D9IBuf = (IDirect3DIndexBuffer9)pAlloc->pD3DIf;
2814	Assert(pD3D9IBuf);
2815	/* this is a sysmem texture, update */
2816	if (pAlloc->pvMem && !pAlloc->LockInfo.fFlags.ReadOnly)
2817	{
2818	RECT r, *pr;
2819	if (pAlloc->LockInfo.fFlags.RangeValid)
2820	{
2821	r.top = 0;
2822	r.left = pAlloc->LockInfo.Range.Offset;
2823	r.bottom = 1;
2824	r.right = pAlloc->LockInfo.Range.Offset + pAlloc->LockInfo.Range.Size;
2825	pr = &r;
2826	}
2827	else
2828	pr = NULL;
2829	vboxWddmLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect,
2830	pr,
2831	true /bool bToLockInfo/);
2832	}
2833	hr = pD3D9IBuf->Unlock();
2834	Assert(hr == S_OK);
2835	}
2836	else
2837	{
2838	Assert(pAlloc->LockInfo.cLocks < UINT32_MAX);
2839	}
2840	}
2841	else
2842	{
2843	AssertBreakpoint();
2844	}
2845	}
2846	else
2847	{
2848	struct
2849	{
2850	D3DDDICB_UNLOCK Unlock;
2851	D3DKMT_HANDLE hAllocation;
2852	} UnlockData;
2853
2854	PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
2855
2856	UnlockData.Unlock.NumAllocations = 1;
2857	UnlockData.Unlock.phAllocations = &UnlockData.hAllocation;
2858	UnlockData.hAllocation = pAlloc->hAllocation;
2859
2860	hr = pDevice->RtCallbacks.pfnUnlockCb(pDevice->hDevice, &UnlockData.Unlock);
2861	Assert(hr == S_OK);
2862	if (hr == S_OK)
2863	{
2864	Assert(pAlloc->LockInfo.cLocks);
2865	--pAlloc->LockInfo.cLocks;
2866	Assert(pAlloc->LockInfo.cLocks < UINT32_MAX);
2867	}
2868	}
2869
2870	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2871	return hr;
2872	}
2873	static HRESULT APIENTRY vboxWddmDDevLockAsync(HANDLE hDevice, D3DDDIARG_LOCKASYNC* pData)
2874	{
2875	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2876	AssertBreakpoint();
2877	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2878	return E_FAIL;
2879	}
2880	static HRESULT APIENTRY vboxWddmDDevUnlockAsync(HANDLE hDevice, CONST D3DDDIARG_UNLOCKASYNC* pData)
2881	{
2882	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2883	AssertBreakpoint();
2884	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2885	return E_FAIL;
2886	}
2887	static HRESULT APIENTRY vboxWddmDDevRename(HANDLE hDevice, CONST D3DDDIARG_RENAME* pData)
2888	{
2889	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2890	AssertBreakpoint();
2891	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2892	return E_FAIL;
2893	}
2894
2895	static void vboxWddmRequestAllocFree(D3DDDICB_ALLOCATE* pAlloc)
2896	{
2897	RTMemFree(pAlloc);
2898	}
2899
2900	static D3DDDICB_ALLOCATE* vboxWddmRequestAllocAlloc(D3DDDIARG_CREATERESOURCE* pResource)
2901	{
2902	/* allocate buffer for D3DDDICB_ALLOCATE + D3DDDI_ALLOCATIONINFO * numAllocs + PVBOXWDDM_RCINFO with aAllocInfos[numAllocs] */
2903	uint32_t cbBuf = sizeof (D3DDDICB_ALLOCATE);
2904	uint32_t offDdiAllocInfos = (cbBuf + 7) & ~3;
2905	uint32_t cbDdiAllocInfos = sizeof (D3DDDI_ALLOCATIONINFO) * pResource->SurfCount;
2906	cbBuf = offDdiAllocInfos + cbDdiAllocInfos;
2907	uint32_t offRcInfo = (cbBuf + 7) & ~3;
2908	uint32_t cbRcInfo = sizeof (VBOXWDDM_RCINFO);
2909	cbBuf = offRcInfo + cbRcInfo;
2910	uint32_t offAllocInfos = (cbBuf + 7) & ~3;
2911	uint32_t cbAllocInfos = sizeof (VBOXWDDM_ALLOCINFO) * pResource->SurfCount;
2912	cbBuf = offAllocInfos + cbAllocInfos;
2913	uint8_t pvBuf = (uint8_t)RTMemAllocZ(cbBuf);
2914	Assert(pvBuf);
2915	if (pvBuf)
2916	{
2917	D3DDDICB_ALLOCATE* pAlloc = (D3DDDICB_ALLOCATE*)pvBuf;
2918	pAlloc->NumAllocations = pResource->SurfCount;
2919	pAlloc->pAllocationInfo = (D3DDDI_ALLOCATIONINFO*)(pvBuf + offDdiAllocInfos);
2920	PVBOXWDDM_RCINFO pRcInfo = (PVBOXWDDM_RCINFO)(pvBuf + offRcInfo);
2921	pAlloc->PrivateDriverDataSize = cbRcInfo;
2922	pAlloc->pPrivateDriverData = pRcInfo;
2923	pAlloc->hResource = pResource->hResource;
2924	PVBOXWDDM_ALLOCINFO pAllocInfos = (PVBOXWDDM_ALLOCINFO)(pvBuf + offAllocInfos);
2925	for (UINT i = 0; i < pResource->SurfCount; ++i)
2926	{
2927	D3DDDI_ALLOCATIONINFO* pDdiAllocInfo = &pAlloc->pAllocationInfo[i];
2928	PVBOXWDDM_ALLOCINFO pAllocInfo = &pAllocInfos[i];
2929	pDdiAllocInfo->pPrivateDriverData = pAllocInfo;
2930	pDdiAllocInfo->PrivateDriverDataSize = sizeof (VBOXWDDM_ALLOCINFO);
2931	}
2932	return pAlloc;
2933	}
2934	return NULL;
2935	}
2936
2937	static HRESULT vboxWddmSurfSynchMem(PVBOXWDDMDISP_RESOURCE pRc, PVBOXWDDMDISP_ALLOCATION pAllocation)
2938	{
2939	HRESULT hr = S_OK;
2940	Assert(pAllocation->enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE);
2941	if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM)
2942	{
2943	Assert(pAllocation->pvMem);
2944	D3DLOCKED_RECT lockInfo;
2945	IDirect3DSurface9 pD3D9Surf = (IDirect3DSurface9)pAllocation->pD3DIf;
2946	hr = pD3D9Surf->LockRect(&lockInfo, NULL, D3DLOCK_DISCARD);
2947	Assert(hr == S_OK);
2948	if (hr == S_OK)
2949	{
2950	vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /bool bToLockInfo/);
2951	HRESULT tmpHr = pD3D9Surf->UnlockRect();
2952	Assert(tmpHr == S_OK);
2953	}
2954	}
2955	else
2956	{
2957	Assert(!pAllocation->pvMem);
2958	}
2959	return hr;
2960	}
2961
2962	static HRESULT APIENTRY vboxWddmDDevCreateResource(HANDLE hDevice, D3DDDIARG_CREATERESOURCE* pResource)
2963	{
2964	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
2965	HRESULT hr = S_OK;
2966	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2967	Assert(pDevice);
2968	Assert(pResource);
2969	PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter;
2970
2971	PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(pResource->SurfCount);
2972	Assert(pRc);
2973	if (pRc)
2974	{
2975	bool bIssueCreateResource = false;
2976
2977	pRc->hResource = pResource->hResource;
2978	pRc->hKMResource = NULL;
2979	pRc->pDevice = pDevice;
2980	pRc->fFlags = VBOXWDDM_RESOURCE_F_TYPE_GENERIC;
2981	pRc->RcDesc.fFlags = pResource->Flags;
2982	pRc->RcDesc.enmFormat = pResource->Format;
2983	pRc->RcDesc.enmPool = pResource->Pool;
2984	pRc->RcDesc.enmMultisampleType = pResource->MultisampleType;
2985	pRc->RcDesc.MultisampleQuality = pResource->MultisampleQuality;
2986	pRc->RcDesc.MipLevels = pResource->MipLevels;
2987	pRc->RcDesc.Fvf = pResource->Fvf;
2988	pRc->RcDesc.VidPnSourceId = pResource->VidPnSourceId;
2989	pRc->RcDesc.RefreshRate = pResource->RefreshRate;
2990	pRc->RcDesc.enmRotation = pResource->Rotation;
2991	pRc->cAllocations = pResource->SurfCount;
2992	for (UINT i = 0; i < pResource->SurfCount; ++i)
2993	{
2994	PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
2995	CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
2996	pAllocation->hAllocation = NULL;
2997	pAllocation->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC;
2998	pAllocation->pvMem = (void*)pSurf->pSysMem;
2999	pAllocation->SurfDesc.pitch = pSurf->SysMemPitch;
3000	pAllocation->SurfDesc.slicePitch = pSurf->SysMemSlicePitch;
3001	pAllocation->SurfDesc.depth = pSurf->Depth;
3002	pAllocation->SurfDesc.width = pSurf->Width;
3003	pAllocation->SurfDesc.height = pSurf->Height;
3004	pAllocation->SurfDesc.format = pResource->Format;
3005	}
3006
3007	if (VBOXDISPMODE_IS_3D(pAdapter))
3008	{
3009	if (pResource->Flags.SharedResource)
3010	{
3011	AssertBreakpoint(); /* <-- need to test that */
3012	bIssueCreateResource = true;
3013	}
3014
3015	if (pResource->Flags.ZBuffer)
3016	{
3017	Assert(pDevice->pDevice9If);
3018	for (UINT i = 0; i < pResource->SurfCount; ++i)
3019	{
3020	PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
3021	IDirect3DSurface9 *pD3D9Surf;
3022	hr = pDevice->pDevice9If->CreateDepthStencilSurface(pAllocation->SurfDesc.width,
3023	pAllocation->SurfDesc.height,
3024	vboxDDI2D3DFormat(pResource->Format),
3025	vboxDDI2D3DMultiSampleType(pResource->MultisampleType),
3026	pResource->MultisampleQuality,
3027	TRUE /* @todo: BOOL Discard */,
3028	&pD3D9Surf,
3029	NULL /HANDLE pSharedHandle*/);
3030	Assert(hr == S_OK);
3031	if (hr == S_OK)
3032	{
3033	Assert(pD3D9Surf);
3034	pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE;
3035	pAllocation->pD3DIf = pD3D9Surf;
3036	hr = vboxWddmSurfSynchMem(pRc, pAllocation);
3037	Assert(hr == S_OK);
3038	}
3039	else
3040	{
3041	for (UINT j = 0; j < i; ++j)
3042	{
3043	pRc->aAllocations[j].pD3DIf->Release();
3044	}
3045	break;
3046	}
3047	}
3048	}
3049	else if (pResource->Flags.VertexBuffer)
3050	{
3051	Assert(pDevice->pDevice9If);
3052	for (UINT i = 0; i < pResource->SurfCount; ++i)
3053	{
3054	PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
3055	IDirect3DVertexBuffer9 *pD3D9VBuf;
3056	hr = pDevice->pDevice9If->CreateVertexBuffer(pAllocation->SurfDesc.width,
3057	vboxDDI2D3DUsage(pResource->Flags),
3058	pResource->Fvf,
3059	vboxDDI2D3DPool(pResource->Pool),
3060	&pD3D9VBuf,
3061	NULL /HANDLE pSharedHandle*/);
3062	Assert(hr == S_OK);
3063	if (hr == S_OK)
3064	{
3065	Assert(pD3D9VBuf);
3066	pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_VERTEXBUFFER;
3067	pAllocation->pD3DIf = pD3D9VBuf;
3068	if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
3069	{
3070	Assert(pAllocation->pvMem);
3071	D3DLOCKED_RECT lockInfo;
3072	hr = pD3D9VBuf->Lock(0, pAllocation->SurfDesc.width, &lockInfo.pBits, D3DLOCK_DISCARD);
3073	Assert(hr == S_OK);
3074	if (hr == S_OK)
3075	{
3076	lockInfo.Pitch = pAllocation->SurfDesc.pitch;
3077	vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /bool bToLockInfo/);
3078	HRESULT tmpHr = pD3D9VBuf->Unlock();
3079	Assert(tmpHr == S_OK);
3080	}
3081	}
3082	else
3083	{
3084	Assert(!pAllocation->pvMem);
3085	}
3086	}
3087	else
3088	{
3089	for (UINT j = 0; j < i; ++j)
3090	{
3091	pRc->aAllocations[j].pD3DIf->Release();
3092	}
3093	break;
3094	}
3095	}
3096	}
3097	else if (pResource->Flags.IndexBuffer)
3098	{
3099	Assert(pDevice->pDevice9If);
3100	for (UINT i = 0; i < pResource->SurfCount; ++i)
3101	{
3102	PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
3103	CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
3104	IDirect3DIndexBuffer9 *pD3D9IBuf;
3105	hr = pDevice->pDevice9If->CreateIndexBuffer(pSurf->Width,
3106	vboxDDI2D3DUsage(pResource->Flags),
3107	vboxDDI2D3DFormat(pResource->Format),
3108	vboxDDI2D3DPool(pResource->Pool),
3109	&pD3D9IBuf,
3110	NULL /HANDLE pSharedHandle*/
3111	);
3112	Assert(hr == S_OK);
3113	if (hr == S_OK)
3114	{
3115	Assert(pD3D9IBuf);
3116	pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_INDEXBUFFER;
3117	pAllocation->pD3DIf = pD3D9IBuf;
3118	if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
3119	{
3120	Assert(pAllocation->pvMem);
3121	D3DLOCKED_RECT lockInfo;
3122	hr = pD3D9IBuf->Lock(0, pAllocation->SurfDesc.width, &lockInfo.pBits, D3DLOCK_DISCARD);
3123	Assert(hr == S_OK);
3124	if (hr == S_OK)
3125	{
3126	lockInfo.Pitch = pAllocation->SurfDesc.pitch;
3127	vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /bool bToLockInfo/);
3128	HRESULT tmpHr = pD3D9IBuf->Unlock();
3129	Assert(tmpHr == S_OK);
3130	}
3131	}
3132	else
3133	{
3134	Assert(!pAllocation->pvMem);
3135	}
3136	}
3137	else
3138	{
3139	for (UINT j = 0; j < i; ++j)
3140	{
3141	pRc->aAllocations[j].pD3DIf->Release();
3142	}
3143	break;
3144	}
3145	}
3146	}
3147	else if (pResource->Flags.Texture \|\| pResource->Flags.Value == 0)
3148	{
3149	Assert(pDevice->pDevice9If);
3150	#ifdef DEBUG
3151	{
3152	uint32_t tstW = pResource->pSurfList[0].Width;
3153	uint32_t tstH = pResource->pSurfList[0].Height;
3154	for (UINT i = 1; i < pResource->SurfCount; ++i)
3155	{
3156	tstW /= 2;
3157	tstH /= 2;
3158	CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
3159	Assert(pSurf->Width == tstW);
3160	Assert(pSurf->Height == tstH);
3161	}
3162	}
3163	#endif
3164
3165	if (pResource->Flags.RenderTarget)
3166	bIssueCreateResource = true;
3167
3168	PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0];
3169	CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[0];
3170	IDirect3DTexture9 *pD3DIfTex;
3171	hr = pDevice->pDevice9If->CreateTexture(pSurf->Width,
3172	pSurf->Height,
3173	pResource->SurfCount,
3174	vboxDDI2D3DUsage(pResource->Flags),
3175	vboxDDI2D3DFormat(pResource->Format),
3176	vboxDDI2D3DPool(pResource->Pool),
3177	&pD3DIfTex,
3178	NULL /* HANDLE* pSharedHandle */
3179	);
3180	Assert(hr == S_OK);
3181	if (hr == S_OK)
3182	{
3183	Assert(pD3DIfTex);
3184	pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_TEXTURE;
3185	pAllocation->pD3DIf = pD3DIfTex;
3186	if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
3187	{
3188	for (UINT i = 0; i < pResource->SurfCount; ++i)
3189	{
3190	D3DLOCKED_RECT lockInfo;
3191	PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
3192	Assert(pAllocation->pvMem);
3193	hr = pD3DIfTex->LockRect(i, &lockInfo, NULL, D3DLOCK_DISCARD);
3194	Assert(hr == S_OK);
3195	if (hr == S_OK)
3196	{
3197	vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /bool bToLockInfo/);
3198	HRESULT tmpHr = pD3DIfTex->UnlockRect(i);
3199	Assert(tmpHr == S_OK);
3200	}
3201	else
3202	{
3203	pD3DIfTex->Release();
3204	break;
3205	}
3206	}
3207	}
3208	}
3209	#ifdef DEBUG
3210	else
3211	{
3212	for (UINT i = 0; i < pResource->SurfCount; ++i)
3213	{
3214	PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
3215	Assert(!pAllocation->pvMem);
3216	}
3217	}
3218	#endif
3219	}
3220	else if (pResource->Flags.RenderTarget)
3221	{
3222	HWND hWnd = NULL;
3223	bIssueCreateResource = true;
3224	Assert(pResource->SurfCount);
3225	if (!pDevice->pDevice9If)
3226	{
3227	Assert(!pDevice->hWnd);
3228	hr = VBoxDispWndCreate(pAdapter, pResource->pSurfList[0].Width, pResource->pSurfList[0].Height, &hWnd);
3229	Assert(hr == S_OK);
3230	if (hr == S_OK)
3231	{
3232	DWORD fFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;
3233	if (pDevice->fFlags.AllowMultithreading)
3234	fFlags \|= D3DCREATE_MULTITHREADED;
3235
3236	IDirect3DDevice9 *pDevice9If = NULL;
3237	D3DPRESENT_PARAMETERS params;
3238	memset(&params, 0, sizeof (params));
3239	// params.BackBufferWidth = 0;
3240	// params.BackBufferHeight = 0;
3241	params.BackBufferFormat = vboxDDI2D3DFormat(pResource->Format);
3242	Assert(pResource->SurfCount);
3243	params.BackBufferCount = pResource->SurfCount - 1;
3244	params.MultiSampleType = vboxDDI2D3DMultiSampleType(pResource->MultisampleType);
3245	if (pResource->Flags.DiscardRenderTarget)
3246	params.SwapEffect = D3DSWAPEFFECT_DISCARD;
3247	params.hDeviceWindow = hWnd;
3248	/* @todo: it seems there should be a way to detect this correctly since
3249	* our vboxWddmDDevSetDisplayMode will be called in case we are using full-screen */
3250	params.Windowed = TRUE;
3251	// params.EnableAutoDepthStencil = FALSE;
3252	// params.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
3253	// params.Flags;
3254	// params.FullScreen_RefreshRateInHz;
3255	// params.FullScreen_PresentationInterval;
3256	hr = pAdapter->pD3D9If->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, fFlags, &params, &pDevice9If);
3257	Assert(hr == S_OK);
3258	if (hr == S_OK)
3259	{
3260	pDevice->pDevice9If = pDevice9If;
3261	pDevice->hWnd = hWnd;
3262	pDevice->pRenderTargetRc = pRc;
3263
3264	IDirect3DSurface9* pD3D9Surf;
3265	hr = pDevice->pDevice9If->GetRenderTarget(0, &pD3D9Surf);
3266	Assert(hr == S_OK);
3267	if (hr == S_OK)
3268	{
3269	PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0];
3270	pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE;
3271	pAllocation->pD3DIf = pD3D9Surf;
3272	hr = vboxWddmSurfSynchMem(pRc, pAllocation);
3273	Assert(hr == S_OK);
3274	if (hr == S_OK)
3275	{
3276	for (UINT i = 1; i < pResource->SurfCount; ++i)
3277	{
3278	PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
3279	hr = pDevice->pDevice9If->GetBackBuffer(0 /UINT iSwapChain/,
3280	i-1, D3DBACKBUFFER_TYPE_MONO, &pD3D9Surf);
3281	Assert(hr == S_OK);
3282	if (hr == S_OK)
3283	{
3284	Assert(pD3D9Surf);
3285	pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE;
3286	pAllocation->pD3DIf = pD3D9Surf;
3287	hr = vboxWddmSurfSynchMem(pRc, pAllocation);
3288	Assert(hr == S_OK);
3289	if (hr == S_OK)
3290	{
3291	continue;
3292	}
3293
3294	/* Failure branch */
3295	pD3D9Surf->Release();
3296	}
3297
3298	for (UINT j = 1; j < i; ++j)
3299	{
3300	pRc->aAllocations[j].pD3DIf->Release();
3301	}
3302	}
3303	}
3304
3305	if (hr != S_OK)
3306	pRc->aAllocations[0].pD3DIf->Release();
3307	}
3308
3309	if (hr != S_OK)
3310	pDevice9If->Release();
3311	}
3312
3313	if (hr != S_OK)
3314	{
3315	HRESULT tmpHr = VBoxDispWndDestroy(pAdapter, pDevice->hWnd);
3316	Assert(tmpHr == S_OK);
3317	}
3318	}
3319	}
3320	else
3321	{
3322	Assert(pDevice->hWnd);
3323	Assert(pDevice->pDevice9If);
3324	for (UINT i = 0; i < pResource->SurfCount; ++i)
3325	{
3326	PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
3327
3328	IDirect3DSurface9* pD3D9Surf;
3329	hr = pDevice->pDevice9If->CreateRenderTarget(pAllocation->SurfDesc.width,
3330	pAllocation->SurfDesc.height,
3331	vboxDDI2D3DFormat(pResource->Format),
3332	vboxDDI2D3DMultiSampleType(pResource->MultisampleType),
3333	pResource->MultisampleQuality,
3334	!pResource->Flags.NotLockable /* BOOL Lockable */,
3335	&pD3D9Surf,
3336	NULL /* HANDLE* pSharedHandle */
3337	);
3338	Assert(hr == S_OK);
3339	if (hr == S_OK)
3340	{
3341	Assert(pD3D9Surf);
3342	pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE;
3343	pAllocation->pD3DIf = pD3D9Surf;
3344	hr = vboxWddmSurfSynchMem(pRc, pAllocation);
3345	Assert(hr == S_OK);
3346	if (hr == S_OK)
3347	continue;
3348
3349	/* fail branch */
3350	pD3D9Surf->Release();
3351	}
3352
3353	for (UINT j = 0; j < i; ++j)
3354	{
3355	pRc->aAllocations[j].pD3DIf->Release();
3356	}
3357	break;
3358	}
3359	}
3360	}
3361	else
3362	{
3363	Assert(pDevice->pDevice9If);
3364	Assert(0);
3365	}
3366	}
3367	else
3368	bIssueCreateResource = true;
3369
3370
3371	if (hr == S_OK && bIssueCreateResource)
3372	{
3373	D3DDDICB_ALLOCATE *pDdiAllocate = vboxWddmRequestAllocAlloc(pResource);
3374	Assert(pDdiAllocate);
3375	if (pDdiAllocate)
3376	{
3377	Assert(pDdiAllocate->pPrivateDriverData);
3378	Assert(pDdiAllocate->PrivateDriverDataSize == sizeof (VBOXWDDM_RCINFO));
3379	PVBOXWDDM_RCINFO pRcInfo = (PVBOXWDDM_RCINFO)pDdiAllocate->pPrivateDriverData;
3380	pRcInfo->fFlags = VBOXWDDM_RESOURCE_F_TYPE_GENERIC;
3381	pRcInfo->RcDesc = pRc->RcDesc;
3382	pRcInfo->cAllocInfos = pResource->SurfCount;
3383
3384	for (UINT i = 0; i < pResource->SurfCount; ++i)
3385	{
3386	D3DDDI_ALLOCATIONINFO *pDdiAllocI = &pDdiAllocate->pAllocationInfo[i];
3387	Assert(pDdiAllocI->pPrivateDriverData);
3388	Assert(pDdiAllocI->PrivateDriverDataSize == sizeof (VBOXWDDM_ALLOCINFO));
3389	PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pDdiAllocI->pPrivateDriverData;
3390	CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
3391	pDdiAllocI->hAllocation = NULL;
3392	pDdiAllocI->pSystemMem = pSurf->pSysMem;
3393	Assert((!!(pSurf->pSysMem)) == (pResource->Pool == D3DDDIPOOL_SYSTEMMEM));
3394	pDdiAllocI->VidPnSourceId = pResource->VidPnSourceId;
3395	pDdiAllocI->Flags.Value = 0;
3396	if (pResource->Flags.Primary)
3397	{
3398	Assert(pResource->Flags.RenderTarget);
3399	pDdiAllocI->Flags.Primary = 1;
3400	}
3401
3402	pAllocInfo->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC;
3403	pAllocInfo->fFlags = pResource->Flags;
3404	pAllocInfo->SurfDesc.width = pSurf->Width;
3405	pAllocInfo->SurfDesc.height = pSurf->Height;
3406	pAllocInfo->SurfDesc.format = pResource->Format;
3407	if (!vboxWddmFormatToFourcc(pResource->Format))
3408	pAllocInfo->SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pResource->Format);
3409	else
3410	pAllocInfo->SurfDesc.bpp = 0;
3411
3412	if (pSurf->SysMemPitch)
3413	{
3414	pAllocInfo->SurfDesc.pitch = pSurf->SysMemPitch;
3415	#ifdef DEBUG
3416	UINT tst = vboxWddmCalcPitch(pSurf->Width, pAllocInfo->SurfDesc.bpp);
3417	Assert(tst == pSurf->SysMemPitch);
3418	#endif
3419	}
3420	else
3421	pAllocInfo->SurfDesc.pitch = vboxWddmCalcPitch(pSurf->Width, pAllocInfo->SurfDesc.bpp);
3422
3423	pAllocInfo->SurfDesc.cbSize = pAllocInfo->SurfDesc.pitch * pAllocInfo->SurfDesc.height;
3424	pAllocInfo->SurfDesc.depth = pSurf->Depth;
3425	pAllocInfo->SurfDesc.slicePitch = pSurf->SysMemSlicePitch;
3426	pAllocInfo->SurfDesc.VidPnSourceId = pResource->VidPnSourceId;
3427	pAllocInfo->SurfDesc.RefreshRate = pResource->RefreshRate;
3428	}
3429
3430	hr = pDevice->RtCallbacks.pfnAllocateCb(pDevice->hDevice, pDdiAllocate);
3431	Assert(hr == S_OK);
3432	Assert(pDdiAllocate->hKMResource);
3433	if (hr == S_OK)
3434	{
3435	pRc->hKMResource = pDdiAllocate->hKMResource;
3436
3437	for (UINT i = 0; i < pResource->SurfCount; ++i)
3438	{
3439	PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
3440	D3DDDI_ALLOCATIONINFO *pDdiAllocI = &pDdiAllocate->pAllocationInfo[i];
3441	PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pDdiAllocI->pPrivateDriverData;
3442	CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
3443	pAllocation->hAllocation = pDdiAllocI->hAllocation;
3444	pAllocation->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC;
3445	pAllocation->pvMem = (void*)pSurf->pSysMem;
3446	pAllocation->SurfDesc = pAllocInfo->SurfDesc;
3447	}
3448	}
3449
3450	vboxWddmRequestAllocFree(pDdiAllocate);
3451	}
3452	else
3453	{
3454	hr = E_OUTOFMEMORY;
3455	}
3456
3457	if (hr == S_OK)
3458	pResource->hResource = pRc;
3459	else
3460	vboxResourceFree(pRc);
3461	}
3462
3463	if (hr == S_OK)
3464	pResource->hResource = pRc;
3465	else
3466	vboxResourceFree(pRc);
3467	}
3468	else
3469	{
3470	hr = E_OUTOFMEMORY;
3471	}
3472
3473
3474	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3475	return hr;
3476	}
3477
3478	static HRESULT APIENTRY vboxWddmDDevDestroyResource(HANDLE hDevice, HANDLE hResource)
3479	{
3480	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3481	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3482	PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter;
3483	PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)hResource;
3484
3485	HRESULT hr = S_OK;
3486
3487	Assert(pDevice);
3488	Assert(hResource);
3489
3490	if (VBOXDISPMODE_IS_3D(pAdapter))
3491	{
3492	if (pRc->RcDesc.fFlags.RenderTarget)
3493	{
3494	Assert(pDevice->hWnd);
3495	Assert(pDevice->pDevice9If);
3496	}
3497
3498	for (UINT i = 0; i < pRc->cAllocations; ++i)
3499	{
3500	PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];
3501	if (pAlloc->pD3DIf)
3502	pAlloc->pD3DIf->Release();
3503	}
3504	}
3505
3506	Assert(pRc->hResource);
3507	Assert(pRc->hKMResource \|\| VBOXDISPMODE_IS_3D(pAdapter));
3508	if (pRc->hKMResource)
3509	{
3510	if (!(pRc->fFlags & VBOXWDDM_RESOURCE_F_OPENNED))
3511	{
3512	D3DDDICB_DEALLOCATE Dealloc;
3513	Dealloc.hResource = pRc->hResource;
3514	/* according to the docs the below two are ignored in case we set the hResource */
3515	Dealloc.NumAllocations = 0;
3516	Dealloc.HandleList = NULL;
3517	hr = pDevice->RtCallbacks.pfnDeallocateCb(pDevice->hDevice, &Dealloc);
3518	Assert(hr == S_OK);
3519	// for (UINT j = 0; j < pRc->cAllocations; ++j)
3520	// {
3521	// D3DDDICB_DEALLOCATE Dealloc;
3522	// Dealloc.hResource = NULL;
3523	// Dealloc.NumAllocations = 1;
3524	// Dealloc.HandleList = &pRc->aAllocations[j].hAllocation;
3525	// HRESULT tmpHr = pDevice->RtCallbacks.pfnDeallocateCb(pDevice->hDevice, &Dealloc);
3526	// Assert(tmpHr = S_OK);
3527	// }
3528	}
3529	}
3530
3531	vboxResourceFree(pRc);
3532	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3533	return hr;
3534	}
3535	static HRESULT APIENTRY vboxWddmDDevSetDisplayMode(HANDLE hDevice, CONST D3DDDIARG_SETDISPLAYMODE* pData)
3536	{
3537	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3538	HRESULT hr = S_OK;
3539	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3540	Assert(pDevice);
3541	Assert(VBOXDISPMODE_IS_3D(pDevice->pAdapter));
3542	PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
3543	Assert(pRc);
3544	Assert(pRc->cAllocations > pData->SubResourceIndex);
3545	PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
3546	Assert(pRc->RcDesc.fFlags.RenderTarget);
3547	Assert(pAlloc->enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE);
3548	Assert(pAlloc->hAllocation);
3549	D3DDDICB_SETDISPLAYMODE DdiDm = {0};
3550	DdiDm.hPrimaryAllocation = pAlloc->hAllocation;
3551	// DdiDm.PrivateDriverFormatAttribute = 0;
3552	Assert(pDevice->pRenderTargetRc == pRc);
3553
3554	#if 0
3555	IDirect3DSurface9 pD3DIfSurf = (IDirect3DSurface9)pAlloc->pD3DIf;
3556	hr = pDevice->pDevice9If->SetRenderTarget(0, pD3DIfSurf);
3557	Assert(hr == S_OK);
3558	if (hr == S_OK)
3559	#endif
3560	{
3561	hr = pDevice->RtCallbacks.pfnSetDisplayModeCb(pDevice->hDevice, &DdiDm);
3562	Assert(hr == S_OK);
3563	}
3564
3565	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3566	return hr;
3567	}
3568	static HRESULT APIENTRY vboxWddmDDevPresent(HANDLE hDevice, CONST D3DDDIARG_PRESENT* pData)
3569	{
3570	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3571	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3572	Assert(pDevice);
3573	HRESULT hr = S_OK;
3574	if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
3575	{
3576	Assert(pDevice->pDevice9If);
3577	#if 1
3578	hr = pDevice->pDevice9If->Present(NULL, /* CONST RECT * pSourceRect */
3579	NULL, /* CONST RECT * pDestRect */
3580	NULL, /* HWND hDestWindowOverride */
3581	NULL /CONST RGNDATA pDirtyRegion */
3582	);
3583	Assert(hr == S_OK);
3584	#endif
3585	}
3586	#if 0
3587	else
3588	#endif
3589	{
3590	D3DDDICB_PRESENT DdiPresent = {0};
3591	if (pData->hSrcResource)
3592	{
3593	PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
3594	Assert(pRc->hKMResource);
3595	Assert(pRc->cAllocations > pData->SrcSubResourceIndex);
3596	PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SrcSubResourceIndex];
3597	Assert(pAlloc->hAllocation);
3598	DdiPresent.hSrcAllocation = pAlloc->hAllocation;
3599	}
3600	if (pData->hDstResource)
3601	{
3602	PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hDstResource;
3603	Assert(pRc->hKMResource);
3604	Assert(pRc->cAllocations > pData->DstSubResourceIndex);
3605	PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->DstSubResourceIndex];
3606	Assert(pAlloc->hAllocation);
3607	DdiPresent.hDstAllocation = pAlloc->hAllocation;
3608	}
3609	DdiPresent.hContext = pDevice->DefaultContext.ContextInfo.hContext;
3610	// DdiPresent.BroadcastContextCount;
3611	// DdiPresent.BroadcastContext[D3DDDI_MAX_BROADCAST_CONTEXT];
3612
3613	hr = pDevice->RtCallbacks.pfnPresentCb(pDevice->hDevice, &DdiPresent);
3614	Assert(hr == S_OK);
3615	}
3616	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3617	return hr;
3618	}
3619	static HRESULT APIENTRY vboxWddmDDevFlush(HANDLE hDevice)
3620	{
3621	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3622	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3623	Assert(pDevice);
3624	HRESULT hr = S_OK;
3625	if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
3626	{
3627	Assert(pDevice->pDevice9If);
3628	#if 0
3629	hr = pDevice->pDevice9If->Present(NULL, /* CONST RECT * pSourceRect */
3630	NULL, /* CONST RECT * pDestRect */
3631	NULL, /* HWND hDestWindowOverride */
3632	NULL /CONST RGNDATA pDirtyRegion */
3633	);
3634	Assert(hr == S_OK);
3635	#endif
3636	}
3637	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3638	return hr;
3639	}
3640
3641	AssertCompile(sizeof (D3DDDIVERTEXELEMENT) == sizeof (D3DVERTEXELEMENT9));
3642	AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Stream) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Stream));
3643	AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Offset) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Offset));
3644	AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Type) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Type));
3645	AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Method) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Method));
3646	AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Usage) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Usage));
3647	AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, UsageIndex) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, UsageIndex));
3648
3649	AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Stream) == RT_OFFSETOF(D3DVERTEXELEMENT9, Stream));
3650	AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Offset) == RT_OFFSETOF(D3DVERTEXELEMENT9, Offset));
3651	AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Type) == RT_OFFSETOF(D3DVERTEXELEMENT9, Type));
3652	AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Method) == RT_OFFSETOF(D3DVERTEXELEMENT9, Method));
3653	AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Usage) == RT_OFFSETOF(D3DVERTEXELEMENT9, Usage));
3654	AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, UsageIndex) == RT_OFFSETOF(D3DVERTEXELEMENT9, UsageIndex));
3655
3656	static HRESULT APIENTRY vboxWddmDDevCreateVertexShaderDecl(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERDECL* pData, CONST D3DDDIVERTEXELEMENT* pVertexElements)
3657	{
3658	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3659	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3660	Assert(pDevice);
3661	Assert(pDevice->pDevice9If);
3662	IDirect3DVertexDeclaration9 *pDecl;
3663	static D3DVERTEXELEMENT9 DeclEnd = D3DDECL_END();
3664	Assert(!memcmp(&DeclEnd, &pVertexElements[pData->NumVertexElements], sizeof (DeclEnd)));
3665	HRESULT hr = pDevice->pDevice9If->CreateVertexDeclaration(
3666	(CONST D3DVERTEXELEMENT9*)pVertexElements,
3667	&pDecl
3668	);
3669	Assert(hr == S_OK);
3670	if (hr == S_OK)
3671	{
3672	Assert(pDecl);
3673	pData->ShaderHandle = pDecl;
3674	}
3675	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3676	return hr;
3677	}
3678	static HRESULT APIENTRY vboxWddmDDevSetVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
3679	{
3680	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3681	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3682	Assert(pDevice);
3683	Assert(pDevice->pDevice9If);
3684	IDirect3DVertexDeclaration9 pDecl = (IDirect3DVertexDeclaration9)hShaderHandle;
3685	Assert(pDecl);
3686	HRESULT hr = pDevice->pDevice9If->SetVertexDeclaration(pDecl);
3687	Assert(hr == S_OK);
3688	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3689	return hr;
3690	}
3691	static HRESULT APIENTRY vboxWddmDDevDeleteVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
3692	{
3693	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3694	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3695	Assert(pDevice);
3696	Assert(pDevice->pDevice9If);
3697	IDirect3DVertexDeclaration9 pDecl = (IDirect3DVertexDeclaration9)hShaderHandle;
3698	HRESULT hr = S_OK;
3699	pDecl->Release();
3700	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3701	return hr;
3702	}
3703	static HRESULT APIENTRY vboxWddmDDevCreateVertexShaderFunc(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERFUNC* pData, CONST UINT* pCode)
3704	{
3705	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3706	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3707	Assert(pDevice);
3708	Assert(pDevice->pDevice9If);
3709	IDirect3DVertexShader9 *pShader;
3710	Assert(((UINT)((uint8_t)pCode + pData->Size-4)) == 0x0000FFFF / end token */);
3711	HRESULT hr = pDevice->pDevice9If->CreateVertexShader((const DWORD *)pCode, &pShader);
3712	Assert(hr == S_OK);
3713	if (hr == S_OK)
3714	{
3715	Assert(pShader);
3716	pData->ShaderHandle = pShader;
3717	}
3718	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3719	return hr;
3720	}
3721	static HRESULT APIENTRY vboxWddmDDevSetVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
3722	{
3723	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3724	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3725	Assert(pDevice);
3726	Assert(pDevice->pDevice9If);
3727	IDirect3DVertexShader9 pShader = (IDirect3DVertexShader9)hShaderHandle;
3728	Assert(pShader);
3729	HRESULT hr = pDevice->pDevice9If->SetVertexShader(pShader);
3730	Assert(hr == S_OK);
3731	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3732	return hr;
3733	}
3734	static HRESULT APIENTRY vboxWddmDDevDeleteVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
3735	{
3736	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3737	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3738	Assert(pDevice);
3739	Assert(pDevice->pDevice9If);
3740	IDirect3DVertexShader9 pShader = (IDirect3DVertexShader9)hShaderHandle;
3741	HRESULT hr = S_OK;
3742	pShader->Release();
3743	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3744	return hr;
3745	}
3746	static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTI* pData, CONST INT* pRegisters)
3747	{
3748	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3749	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3750	Assert(pDevice);
3751	Assert(pDevice->pDevice9If);
3752	HRESULT hr = pDevice->pDevice9If->SetVertexShaderConstantI(pData->Register, pRegisters, pData->Count);
3753	Assert(hr == S_OK);
3754	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3755	return hr;
3756	}
3757	static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTB* pData, CONST BOOL* pRegisters)
3758	{
3759	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3760	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3761	Assert(pDevice);
3762	Assert(pDevice->pDevice9If);
3763	HRESULT hr = pDevice->pDevice9If->SetVertexShaderConstantB(pData->Register, pRegisters, pData->Count);
3764	Assert(hr == S_OK);
3765	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3766	return hr;
3767	}
3768	static HRESULT APIENTRY vboxWddmDDevSetScissorRect(HANDLE hDevice, CONST RECT* pRect)
3769	{
3770	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3771	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3772	Assert(pDevice);
3773	Assert(pDevice->pDevice9If);
3774	HRESULT hr = pDevice->pDevice9If->SetScissorRect(pRect);
3775	Assert(hr == S_OK);
3776	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3777	return hr;
3778	}
3779	static HRESULT APIENTRY vboxWddmDDevSetStreamSource(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCE* pData)
3780	{
3781	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3782	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3783	Assert(pDevice);
3784	Assert(pDevice->pDevice9If);
3785	PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hVertexBuffer;
3786	PVBOXWDDMDISP_ALLOCATION pAlloc = NULL;
3787	IDirect3DVertexBuffer9 *pStreamData = NULL;
3788	if (pRc)
3789	{
3790	Assert(pRc->cAllocations == 1);
3791	pAlloc = &pRc->aAllocations[0];
3792	Assert(pAlloc->pD3DIf);
3793	pStreamData = (IDirect3DVertexBuffer9*)pAlloc->pD3DIf;
3794	}
3795	HRESULT hr = pDevice->pDevice9If->SetStreamSource(pData->Stream, pStreamData, pData->Offset, pData->Stride);
3796	Assert(hr == S_OK);
3797	Assert(pData->Stream<VBOXWDDMDISP_MAX_VERTEX_STREAMS);
3798	if (hr == S_OK)
3799	{
3800	if (pDevice->aStreamSource[pData->Stream] && !pAlloc)
3801	{
3802	--pDevice->cStreamSources;
3803	Assert(pDevice->cStreamSources < UINT32_MAX/2);
3804	}
3805	else if (!pDevice->aStreamSource[pData->Stream] && pAlloc)
3806	{
3807	++pDevice->cStreamSources;
3808	Assert(pDevice->cStreamSources <= RT_ELEMENTS(pDevice->aStreamSource));
3809	}
3810	pDevice->aStreamSource[pData->Stream] = pAlloc;
3811	pDevice->StreamSourceInfo[pData->Stream].uiOffset = pData->Offset;
3812	pDevice->StreamSourceInfo[pData->Stream].uiStride = pData->Stride;
3813	}
3814	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
3815	return hr;
3816	}
3817	static HRESULT APIENTRY vboxWddmDDevSetStreamSourceFreq(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEFREQ* pData)
3818	{
3819	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3820	AssertBreakpoint();
3821	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3822	return E_FAIL;
3823	}
3824	static HRESULT APIENTRY vboxWddmDDevSetConvolutionKernelMono(HANDLE hDevice, CONST D3DDDIARG_SETCONVOLUTIONKERNELMONO* pData)
3825	{
3826	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3827	AssertBreakpoint();
3828	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3829	return E_FAIL;
3830	}
3831	static HRESULT APIENTRY vboxWddmDDevComposeRects(HANDLE hDevice, CONST D3DDDIARG_COMPOSERECTS* pData)
3832	{
3833	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3834	AssertBreakpoint();
3835	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3836	return E_FAIL;
3837	}
3838	static HRESULT vboxWddmLockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc,
3839	D3DLOCKED_RECT * pLockedRect,
3840	CONST RECT *pRect,
3841	DWORD fLockFlags)
3842	{
3843	HRESULT hr = E_FAIL;
3844	Assert(!pRc->aAllocations[iAlloc].LockInfo.cLocks);
3845	Assert(pRc->cAllocations > iAlloc);
3846	switch (pRc->aAllocations[0].enmD3DIfType)
3847	{
3848	case VBOXDISP_D3DIFTYPE_SURFACE:
3849	{
3850	IDirect3DSurface9 pD3DIfSurf = (IDirect3DSurface9)pRc->aAllocations[iAlloc].pD3DIf;
3851	Assert(pD3DIfSurf);
3852	hr = pD3DIfSurf->LockRect(pLockedRect, pRect, fLockFlags);
3853	Assert(hr == S_OK);
3854	break;
3855	}
3856	case VBOXDISP_D3DIFTYPE_TEXTURE:
3857	{
3858	IDirect3DTexture9 pD3DIfTex = (IDirect3DTexture9)pRc->aAllocations[0].pD3DIf;
3859	Assert(pD3DIfTex);
3860	hr = pD3DIfTex->LockRect(iAlloc, pLockedRect, pRect, fLockFlags);
3861	Assert(hr == S_OK);
3862	break;
3863	}
3864	default:
3865	AssertBreakpoint();
3866	break;
3867	}
3868	return hr;
3869	}
3870	static HRESULT vboxWddmUnlockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc)
3871	{
3872	HRESULT hr = S_OK;
3873	Assert(pRc->cAllocations > iAlloc);
3874	switch (pRc->aAllocations[0].enmD3DIfType)
3875	{
3876	case VBOXDISP_D3DIFTYPE_SURFACE:
3877	{
3878	IDirect3DSurface9 pD3DIfSurf = (IDirect3DSurface9)pRc->aAllocations[iAlloc].pD3DIf;
3879	Assert(pD3DIfSurf);
3880	hr = pD3DIfSurf->UnlockRect();
3881	Assert(hr == S_OK);
3882	break;
3883	}
3884	case VBOXDISP_D3DIFTYPE_TEXTURE:
3885	{
3886	IDirect3DTexture9 pD3DIfTex = (IDirect3DTexture9)pRc->aAllocations[0].pD3DIf;
3887	Assert(pD3DIfTex);
3888	hr = pD3DIfTex->UnlockRect(iAlloc);
3889	Assert(hr == S_OK);
3890	break;
3891	}
3892	default:
3893	AssertBreakpoint();
3894	hr = E_FAIL;
3895	break;
3896	}
3897	return hr;
3898	}
3899
3900	/* on success increments the surface ref counter,
3901	* i.e. one must call pSurf->Release() once the surface is not needed*/
3902	static HRESULT vboxWddmSurfGet(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc, IDirect3DSurface9 **ppSurf)
3903	{
3904	HRESULT hr = S_OK;
3905	Assert(pRc->cAllocations > iAlloc);
3906	switch (pRc->aAllocations[0].enmD3DIfType)
3907	{
3908	case VBOXDISP_D3DIFTYPE_SURFACE:
3909	{
3910	IDirect3DSurface9 pD3DIfSurf = (IDirect3DSurface9)pRc->aAllocations[iAlloc].pD3DIf;
3911	Assert(pD3DIfSurf);
3912	pD3DIfSurf->AddRef();
3913	*ppSurf = pD3DIfSurf;
3914	break;
3915	}
3916	case VBOXDISP_D3DIFTYPE_TEXTURE:
3917	{
3918	IDirect3DTexture9 pD3DIfTex = (IDirect3DTexture9)pRc->aAllocations[0].pD3DIf;
3919	IDirect3DSurface9 *pSurfaceLevel;
3920	Assert(pD3DIfTex);
3921	hr = pD3DIfTex->GetSurfaceLevel(iAlloc, &pSurfaceLevel);
3922	Assert(hr == S_OK);
3923	if (hr == S_OK)
3924	{
3925	*ppSurf = pSurfaceLevel;
3926	}
3927	break;
3928	}
3929	default:
3930	AssertBreakpoint();
3931	hr = E_FAIL;
3932	break;
3933	}
3934	return hr;
3935	}
3936
3937	static HRESULT APIENTRY vboxWddmDDevBlt(HANDLE hDevice, CONST D3DDDIARG_BLT* pData)
3938	{
3939	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
3940	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
3941	Assert(pDevice);
3942	Assert(pDevice->pDevice9If);
3943	PVBOXWDDMDISP_RESOURCE pDstRc = (PVBOXWDDMDISP_RESOURCE)pData->hDstResource;
3944	PVBOXWDDMDISP_RESOURCE pSrcRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
3945	Assert(pDstRc->cAllocations > pData->DstSubResourceIndex);
3946	Assert(pSrcRc->cAllocations > pData->SrcSubResourceIndex);
3947	HRESULT hr = S_OK;
3948	/* try StretchRect */
3949	IDirect3DSurface9 *pSrcSurfIf = NULL;
3950	IDirect3DSurface9 *pDstSurfIf = NULL;
3951	hr = vboxWddmSurfGet(pSrcRc, pData->SrcSubResourceIndex, &pSrcSurfIf);
3952	Assert(hr == S_OK);
3953	if (hr == S_OK)
3954	{
3955	Assert(pSrcSurfIf);
3956	hr = vboxWddmSurfGet(pDstRc, pData->DstSubResourceIndex, &pDstSurfIf);
3957	Assert(hr == S_OK);
3958	if (hr == S_OK)
3959	{
3960	Assert(pDstSurfIf);
3961	/* we support only Point & Linear, we ignore [Begin\|Continue\|End]PresentToDwm */
3962	Assert((pData->Flags.Value & (~(0x00000100 \| 0x00000200 \| 0x00000400 \| 0x00000001 \| 0x00000002))) == 0);
3963	hr = pDevice->pDevice9If->StretchRect(pSrcSurfIf,
3964	&pData->SrcRect,
3965	pDstSurfIf,
3966	&pData->DstRect,
3967	vboxDDI2D3DBltFlags(pData->Flags));
3968	Assert(hr == S_OK);
3969	pDstSurfIf->Release();
3970	}
3971	pSrcSurfIf->Release();
3972	}
3973
3974	if (hr != S_OK)
3975	{
3976	/* todo: fallback to memcpy or whatever ? */
3977	AssertBreakpoint();
3978	}
3979
3980
3981	#if 0
3982	if ((use pAlloc->enmD3DIfType instead!!! pDstRc->RcDesc.fFlags.Texture \|\| pDstRc->RcDesc.fFlags.Value == 0)
3983	&& (pSrcRc->RcDesc.fFlags.Texture \|\| pSrcRc->RcDesc.fFlags.Value == 0))
3984	{
3985	IDirect3DTexture9 pD3DIfSrcTex = (IDirect3DTexture9)pSrcAlloc->pD3DIf;
3986	IDirect3DTexture9 pD3DIfDstTex = (IDirect3DTexture9)pDstAlloc->pD3DIf;
3987	Assert(pD3DIfSrcTex);
3988	Assert(pD3DIfDstTex);
3989
3990	if (pSrcRc->RcDesc.enmFormat == pDstRc->RcDesc.enmFormat)
3991	{
3992	if (pSrcRc->aAllocations[0].SurfDesc.width == pDstRc->aAllocations[0].SurfDesc.width
3993	&& pSrcRc->aAllocations[0].SurfDesc.height == pDstRc->aAllocations[0].SurfDesc.height
3994	&& pData->DstRect.left == 0 && pData->DstRect.top == 0
3995	&& pData->SrcRect.left == 0 && pData->SrcRect.top == 0
3996	&& pData->SrcRect.right - pData->SrcRect.left == pSrcRc->aAllocations[0].SurfDesc.width
3997	&& pData->SrcRect.bottom - pData->SrcRect.top == pSrcRc->aAllocations[0].SurfDesc.height
3998	&& pData->DstRect.right - pData->DstRect.left == pDstRc->aAllocations[0].SurfDesc.width
3999	&& pData->DstRect.bottom - pData->DstRect.top == pDstRc->aAllocations[0].SurfDesc.height
4000	)
4001	{
4002	hr = pDevice->pDevice9If->UpdateTexture(pD3DIfSrcTex, pD3DIfDstTex);
4003	Assert(hr == S_OK);
4004	}
4005	else if (pData->SrcRect.right - pData->SrcRect.left == pData->DstRect.right - pData->DstRect.left
4006	&& pData->SrcRect.bottom - pData->SrcRect.top == pData->DstRect.bottom - pData->DstRect.top)
4007	{
4008	Assert(pDstAlloc->SurfDesc.bpp);
4009	Assert(pSrcAlloc->SurfDesc.bpp);
4010	Assert(pSrcAlloc->SurfDesc.bpp == pDstAlloc->SurfDesc.bpp);
4011	D3DLOCKED_RECT DstRect, SrcRect;
4012	Assert(!pSrcAlloc->LockInfo.cLocks);
4013	Assert(!pDstAlloc->LockInfo.cLocks);
4014	hr = pD3DIfDstTex->LockRect(pData->DstSubResourceIndex, &DstRect, &pData->DstRect, D3DLOCK_DISCARD);
4015	Assert(hr == S_OK);
4016	if (hr == S_OK)
4017	{
4018	hr = pD3DIfSrcTex->LockRect(pData->SrcSubResourceIndex, &SrcRect, &pData->SrcRect, D3DLOCK_READONLY);
4019	Assert(hr == S_OK);
4020	if (hr == S_OK)
4021	{
4022	hr = vboxWddmRectBltPerform((uint8_t )DstRect.pBits, (uint8_t )SrcRect.pBits,
4023	&pData->DstRect, &pData->SrcRect,
4024	DstRect.Pitch, SrcRect.Pitch, pDstAlloc->SurfDesc.bpp);
4025	Assert(hr == S_OK);
4026
4027	pD3DIfSrcTex->UnlockRect(pData->SrcSubResourceIndex);
4028	}
4029	pD3DIfDstTex->UnlockRect(pData->DstSubResourceIndex);
4030	}
4031	}
4032	else
4033	{
4034
4035	AssertBreakpoint();
4036	/* @todo: impl */
4037	}
4038	}
4039	else
4040	{
4041	AssertBreakpoint();
4042	/* @todo: impl */
4043	}
4044	}
4045	else
4046	{
4047	if (pData->SrcRect.right - pData->SrcRect.left == pData->DstRect.right - pData->DstRect.left
4048	&& pData->SrcRect.bottom - pData->SrcRect.top == pData->DstRect.bottom - pData->DstRect.top)
4049	{
4050	Assert(pDstAlloc->SurfDesc.bpp);
4051	Assert(pSrcAlloc->SurfDesc.bpp);
4052	Assert(pSrcAlloc->SurfDesc.bpp == pDstAlloc->SurfDesc.bpp);
4053
4054	D3DLOCKED_RECT DstRect, SrcRect;
4055	hr = vboxWddmLockRect(pDstAlloc, pData->DstSubResourceIndex, pDstRc->RcDesc.fFlags,
4056	&DstRect, &pData->DstRect, D3DLOCK_DISCARD);
4057	Assert(hr == S_OK);
4058	if (hr == S_OK)
4059	{
4060	hr = vboxWddmLockRect(pSrcAlloc, pData->SrcSubResourceIndex, pSrcRc->RcDesc.fFlags,
4061	&SrcRect, &pData->SrcRect, D3DLOCK_READONLY);
4062	Assert(hr == S_OK);
4063	if (hr == S_OK)
4064	{
4065	hr = vboxWddmRectBltPerform((uint8_t )DstRect.pBits, (uint8_t )SrcRect.pBits,
4066	&pData->DstRect, &pData->SrcRect,
4067	DstRect.Pitch, SrcRect.Pitch, pDstAlloc->SurfDesc.bpp);
4068	Assert(hr == S_OK);
4069
4070	HRESULT tmpHr = vboxWddmUnlockRect(pSrcAlloc, pData->SrcSubResourceIndex, pSrcRc->RcDesc.fFlags);
4071	Assert(tmpHr == S_OK);
4072	}
4073	HRESULT tmpHr = vboxWddmUnlockRect(pDstAlloc, pData->DstSubResourceIndex, pDstRc->RcDesc.fFlags);
4074	Assert(tmpHr == S_OK);
4075	}
4076	}
4077	else
4078	{
4079	AssertBreakpoint();
4080	/* @todo: impl */
4081	}
4082	}
4083	#endif
4084
4085	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
4086	return hr;
4087	}
4088	static HRESULT APIENTRY vboxWddmDDevColorFill(HANDLE hDevice, CONST D3DDDIARG_COLORFILL* pData)
4089	{
4090	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4091	AssertBreakpoint();
4092	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4093	return E_FAIL;
4094	}
4095	static HRESULT APIENTRY vboxWddmDDevDepthFill(HANDLE hDevice, CONST D3DDDIARG_DEPTHFILL* pData)
4096	{
4097	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4098	AssertBreakpoint();
4099	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4100	return E_FAIL;
4101	}
4102	static HRESULT APIENTRY vboxWddmDDevCreateQuery(HANDLE hDevice, D3DDDIARG_CREATEQUERY* pData)
4103	{
4104	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4105	AssertBreakpoint();
4106	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4107	return E_FAIL;
4108	}
4109	static HRESULT APIENTRY vboxWddmDDevDestroyQuery(HANDLE hDevice, HANDLE hQuery)
4110	{
4111	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4112	AssertBreakpoint();
4113	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4114	return E_FAIL;
4115	}
4116	static HRESULT APIENTRY vboxWddmDDevIssueQuery(HANDLE hDevice, CONST D3DDDIARG_ISSUEQUERY* pData)
4117	{
4118	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4119	AssertBreakpoint();
4120	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4121	return E_FAIL;
4122	}
4123	static HRESULT APIENTRY vboxWddmDDevGetQueryData(HANDLE hDevice, CONST D3DDDIARG_GETQUERYDATA* pData)
4124	{
4125	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4126	AssertBreakpoint();
4127	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4128	return E_FAIL;
4129	}
4130	static HRESULT APIENTRY vboxWddmDDevSetRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETRENDERTARGET* pData)
4131	{
4132	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4133	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
4134	Assert(pDevice);
4135	Assert(pDevice->pDevice9If);
4136	PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hRenderTarget;
4137	Assert(pRc);
4138	Assert(pData->SubResourceIndex < pRc->cAllocations);
4139	HRESULT hr = S_OK;
4140	IDirect3DSurface9 *pD3D9Surf;
4141	hr = vboxWddmSurfGet(pRc, pData->SubResourceIndex, &pD3D9Surf);
4142	Assert(hr == S_OK);
4143	if (hr == S_OK)
4144	{
4145	Assert(pD3D9Surf);
4146	hr = pDevice->pDevice9If->SetRenderTarget(pData->RenderTargetIndex, pD3D9Surf);
4147	Assert(hr == S_OK);
4148	pD3D9Surf->Release();
4149	}
4150	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
4151	return hr;
4152	}
4153	static HRESULT APIENTRY vboxWddmDDevSetDepthStencil(HANDLE hDevice, CONST D3DDDIARG_SETDEPTHSTENCIL* pData)
4154	{
4155	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4156	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
4157	Assert(pDevice);
4158	Assert(pDevice->pDevice9If);
4159	PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hZBuffer;
4160	IDirect3DSurface9 *pD3D9Surf = NULL;
4161	if (pRc)
4162	{
4163	Assert(pRc->cAllocations == 1);
4164	pD3D9Surf = (IDirect3DSurface9*)pRc->aAllocations[0].pD3DIf;
4165	Assert(pD3D9Surf);
4166	}
4167	HRESULT hr = pDevice->pDevice9If->SetDepthStencilSurface(pD3D9Surf);
4168	Assert(hr == S_OK);
4169	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
4170	return hr;
4171	}
4172	static HRESULT APIENTRY vboxWddmDDevGenerateMipSubLevels(HANDLE hDevice, CONST D3DDDIARG_GENERATEMIPSUBLEVELS* pData)
4173	{
4174	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4175	AssertBreakpoint();
4176	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4177	return E_FAIL;
4178	}
4179	static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTI* pData, CONST INT* pRegisters)
4180	{
4181	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4182	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
4183	Assert(pDevice);
4184	Assert(pDevice->pDevice9If);
4185	HRESULT hr = pDevice->pDevice9If->SetPixelShaderConstantI(pData->Register, pRegisters, pData->Count);
4186	Assert(hr == S_OK);
4187	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
4188	return hr;
4189	}
4190	static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTB* pData, CONST BOOL* pRegisters)
4191	{
4192	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4193	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
4194	Assert(pDevice);
4195	Assert(pDevice->pDevice9If);
4196	HRESULT hr = pDevice->pDevice9If->SetPixelShaderConstantB(pData->Register, pRegisters, pData->Count);
4197	Assert(hr == S_OK);
4198	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
4199	return hr;
4200	}
4201	static HRESULT APIENTRY vboxWddmDDevCreatePixelShader(HANDLE hDevice, D3DDDIARG_CREATEPIXELSHADER* pData, CONST UINT* pCode)
4202	{
4203	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4204	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
4205	Assert(pDevice);
4206	Assert(pDevice->pDevice9If);
4207	IDirect3DPixelShader9 *pShader;
4208	Assert(((UINT)((uint8_t)pCode + pData->CodeSize-4)) == 0x0000FFFF / end token */);
4209	HRESULT hr = pDevice->pDevice9If->CreatePixelShader((const DWORD *)pCode, &pShader);
4210	Assert(hr == S_OK);
4211	if (hr == S_OK)
4212	{
4213	Assert(pShader);
4214	pData->ShaderHandle = pShader;
4215	}
4216	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
4217	return hr;
4218	}
4219	static HRESULT APIENTRY vboxWddmDDevDeletePixelShader(HANDLE hDevice, HANDLE hShaderHandle)
4220	{
4221	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4222	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
4223	Assert(pDevice);
4224	Assert(pDevice->pDevice9If);
4225	IDirect3DPixelShader9 pShader = (IDirect3DPixelShader9)hShaderHandle;
4226	HRESULT hr = S_OK;
4227	pShader->Release();
4228	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
4229	return hr;
4230	}
4231	static HRESULT APIENTRY vboxWddmDDevCreateDecodeDevice(HANDLE hDevice, D3DDDIARG_CREATEDECODEDEVICE* pData)
4232	{
4233	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4234	AssertBreakpoint();
4235	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4236	return E_FAIL;
4237	}
4238	static HRESULT APIENTRY vboxWddmDDevDestroyDecodeDevice(HANDLE hDevice, HANDLE hDecodeDevice)
4239	{
4240	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4241	AssertBreakpoint();
4242	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4243	return E_FAIL;
4244	}
4245	static HRESULT APIENTRY vboxWddmDDevSetDecodeRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETDECODERENDERTARGET* pData)
4246	{
4247	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4248	AssertBreakpoint();
4249	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4250	return E_FAIL;
4251	}
4252	static HRESULT APIENTRY vboxWddmDDevDecodeBeginFrame(HANDLE hDevice, D3DDDIARG_DECODEBEGINFRAME* pData)
4253	{
4254	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4255	AssertBreakpoint();
4256	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4257	return E_FAIL;
4258	}
4259	static HRESULT APIENTRY vboxWddmDDevDecodeEndFrame(HANDLE hDevice, D3DDDIARG_DECODEENDFRAME* pData)
4260	{
4261	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4262	AssertBreakpoint();
4263	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4264	return E_FAIL;
4265	}
4266	static HRESULT APIENTRY vboxWddmDDevDecodeExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXECUTE* pData)
4267	{
4268	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4269	AssertBreakpoint();
4270	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4271	return E_FAIL;
4272	}
4273	static HRESULT APIENTRY vboxWddmDDevDecodeExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXTENSIONEXECUTE* pData)
4274	{
4275	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4276	AssertBreakpoint();
4277	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4278	return E_FAIL;
4279	}
4280	static HRESULT APIENTRY vboxWddmDDevCreateVideoProcessDevice(HANDLE hDevice, D3DDDIARG_CREATEVIDEOPROCESSDEVICE* pData)
4281	{
4282	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4283	AssertBreakpoint();
4284	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4285	return E_FAIL;
4286	}
4287	static HRESULT APIENTRY vboxWddmDDevDestroyVideoProcessDevice(HANDLE hDevice, HANDLE hVideoProcessor)
4288	{
4289	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4290	AssertBreakpoint();
4291	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4292	return E_FAIL;
4293	}
4294	static HRESULT APIENTRY vboxWddmDDevVideoProcessBeginFrame(HANDLE hDevice, HANDLE hVideoProcess)
4295	{
4296	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4297	AssertBreakpoint();
4298	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4299	return E_FAIL;
4300	}
4301	static HRESULT APIENTRY vboxWddmDDevVideoProcessEndFrame(HANDLE hDevice, D3DDDIARG_VIDEOPROCESSENDFRAME* pData)
4302	{
4303	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4304	AssertBreakpoint();
4305	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4306	return E_FAIL;
4307	}
4308	static HRESULT APIENTRY vboxWddmDDevSetVideoProcessRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETVIDEOPROCESSRENDERTARGET* pData)
4309	{
4310	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4311	AssertBreakpoint();
4312	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4313	return E_FAIL;
4314	}
4315	static HRESULT APIENTRY vboxWddmDDevVideoProcessBlt(HANDLE hDevice, CONST D3DDDIARG_VIDEOPROCESSBLT* pData)
4316	{
4317	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4318	AssertBreakpoint();
4319	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4320	return E_FAIL;
4321	}
4322	static HRESULT APIENTRY vboxWddmDDevCreateExtensionDevice(HANDLE hDevice, D3DDDIARG_CREATEEXTENSIONDEVICE* pData)
4323	{
4324	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4325	AssertBreakpoint();
4326	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4327	return E_FAIL;
4328	}
4329	static HRESULT APIENTRY vboxWddmDDevDestroyExtensionDevice(HANDLE hDevice, HANDLE hExtension)
4330	{
4331	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4332	AssertBreakpoint();
4333	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4334	return E_FAIL;
4335	}
4336	static HRESULT APIENTRY vboxWddmDDevExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_EXTENSIONEXECUTE* pData)
4337	{
4338	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4339	AssertBreakpoint();
4340	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4341	return E_FAIL;
4342	}
4343	static HRESULT APIENTRY vboxWddmDDevDestroyDevice(IN HANDLE hDevice)
4344	{
4345	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4346
4347	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
4348	PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter;
4349	if (pDevice->pDevice9If)
4350	{
4351	pDevice->pDevice9If->Release();
4352	Assert(pDevice->hWnd);
4353	HRESULT tmpHr = VBoxDispWndDestroy(pAdapter, pDevice->hWnd);
4354	Assert(tmpHr == S_OK);
4355	}
4356	HRESULT hr = vboxDispCmCtxDestroy(pDevice, &pDevice->DefaultContext);
4357	Assert(hr == S_OK);
4358	if (hr == S_OK)
4359	RTMemFree(pDevice);
4360	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4361	return hr;
4362	}
4363
4364	AssertCompile(sizeof (RECT) == sizeof (D3DDDIRECT));
4365	AssertCompile(RT_SIZEOFMEMB(RECT, left) == RT_SIZEOFMEMB(D3DDDIRECT, left));
4366	AssertCompile(RT_SIZEOFMEMB(RECT, right) == RT_SIZEOFMEMB(D3DDDIRECT, right));
4367	AssertCompile(RT_SIZEOFMEMB(RECT, top) == RT_SIZEOFMEMB(D3DDDIRECT, top));
4368	AssertCompile(RT_SIZEOFMEMB(RECT, bottom) == RT_SIZEOFMEMB(D3DDDIRECT, bottom));
4369	AssertCompile(RT_OFFSETOF(RECT, left) == RT_OFFSETOF(D3DDDIRECT, left));
4370	AssertCompile(RT_OFFSETOF(RECT, right) == RT_OFFSETOF(D3DDDIRECT, right));
4371	AssertCompile(RT_OFFSETOF(RECT, top) == RT_OFFSETOF(D3DDDIRECT, top));
4372	AssertCompile(RT_OFFSETOF(RECT, bottom) == RT_OFFSETOF(D3DDDIRECT, bottom));
4373
4374	static HRESULT APIENTRY vboxWddmDDevCreateOverlay(HANDLE hDevice, D3DDDIARG_CREATEOVERLAY* pData)
4375	{
4376	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4377	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
4378	PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->OverlayInfo.hResource;
4379	Assert(pRc);
4380	Assert(pRc->cAllocations > pData->OverlayInfo.SubResourceIndex);
4381	PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->OverlayInfo.SubResourceIndex];
4382	HRESULT hr = S_OK;
4383	PVBOXWDDMDISP_OVERLAY pOverlay = (PVBOXWDDMDISP_OVERLAY)RTMemAllocZ(sizeof (VBOXWDDMDISP_OVERLAY));
4384	Assert(pOverlay);
4385	if (pOverlay)
4386	{
4387	VBOXWDDM_OVERLAY_INFO OurInfo;
4388	OurInfo.OverlayDesc.DstColorKeyLow = pData->OverlayInfo.DstColorKeyLow;
4389	OurInfo.OverlayDesc.DstColorKeyHigh = pData->OverlayInfo.DstColorKeyHigh;
4390	OurInfo.OverlayDesc.SrcColorKeyLow = pData->OverlayInfo.SrcColorKeyLow;
4391	OurInfo.OverlayDesc.SrcColorKeyHigh = pData->OverlayInfo.SrcColorKeyHigh;
4392	OurInfo.OverlayDesc.fFlags = pData->OverlayInfo.Flags.Value;
4393	vboxWddmDirtyRegionClear(&OurInfo.DirtyRegion);
4394	Assert(!pAlloc->LockInfo.cLocks);
4395	vboxWddmDirtyRegionUnite(&OurInfo.DirtyRegion, &pAlloc->DirtyRegion);
4396	D3DDDICB_CREATEOVERLAY OverInfo;
4397	OverInfo.VidPnSourceId = pData->VidPnSourceId;
4398	OverInfo.OverlayInfo.hAllocation = pAlloc->hAllocation;
4399	Assert(pAlloc->hAllocation);
4400	OverInfo.OverlayInfo.DstRect = (D3DDDIRECT)((void*)&pData->OverlayInfo.DstRect);
4401	OverInfo.OverlayInfo.SrcRect = (D3DDDIRECT)((void*)&pData->OverlayInfo.SrcRect);
4402	OverInfo.OverlayInfo.pPrivateDriverData = &OurInfo;
4403	OverInfo.OverlayInfo.PrivateDriverDataSize = sizeof (OurInfo);
4404	OverInfo.hKernelOverlay = NULL; /* <-- out */
4405	#ifndef VBOXWDDMOVERLAY_TEST
4406	hr = pDevice->RtCallbacks.pfnCreateOverlayCb(pDevice->hDevice, &OverInfo);
4407	Assert(hr == S_OK);
4408	if (hr == S_OK)
4409	{
4410	Assert(OverInfo.hKernelOverlay);
4411	pOverlay->hOverlay = OverInfo.hKernelOverlay;
4412	pOverlay->VidPnSourceId = pData->VidPnSourceId;
4413
4414	Assert(!pAlloc->LockInfo.cLocks);
4415	if (!pAlloc->LockInfo.cLocks)
4416	{
4417	/* we have reported the dirty rect, may clear it if no locks are pending currently */
4418	vboxWddmDirtyRegionClear(&pAlloc->DirtyRegion);
4419	}
4420
4421	pData->hOverlay = pOverlay;
4422	}
4423	else
4424	{
4425	RTMemFree(pOverlay);
4426	}
4427	#else
4428	pData->hOverlay = pOverlay;
4429	#endif
4430	}
4431	else
4432	hr = E_OUTOFMEMORY;
4433
4434	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4435	return hr;
4436	}
4437	static HRESULT APIENTRY vboxWddmDDevUpdateOverlay(HANDLE hDevice, CONST D3DDDIARG_UPDATEOVERLAY* pData)
4438	{
4439	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4440	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
4441	PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->OverlayInfo.hResource;
4442	Assert(pRc);
4443	Assert(pRc->cAllocations > pData->OverlayInfo.SubResourceIndex);
4444	PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->OverlayInfo.SubResourceIndex];
4445	HRESULT hr = S_OK;
4446	PVBOXWDDMDISP_OVERLAY pOverlay = (PVBOXWDDMDISP_OVERLAY)pData->hOverlay;
4447	VBOXWDDM_OVERLAY_INFO OurInfo;
4448	OurInfo.OverlayDesc.DstColorKeyLow = pData->OverlayInfo.DstColorKeyLow;
4449	OurInfo.OverlayDesc.DstColorKeyHigh = pData->OverlayInfo.DstColorKeyHigh;
4450	OurInfo.OverlayDesc.SrcColorKeyLow = pData->OverlayInfo.SrcColorKeyLow;
4451	OurInfo.OverlayDesc.SrcColorKeyHigh = pData->OverlayInfo.SrcColorKeyHigh;
4452	OurInfo.OverlayDesc.fFlags = pData->OverlayInfo.Flags.Value;
4453	vboxWddmDirtyRegionClear(&OurInfo.DirtyRegion);
4454	Assert(!pAlloc->LockInfo.cLocks);
4455	vboxWddmDirtyRegionUnite(&OurInfo.DirtyRegion, &pAlloc->DirtyRegion);
4456	D3DDDICB_UPDATEOVERLAY OverInfo;
4457	OverInfo.hKernelOverlay = pOverlay->hOverlay;
4458	OverInfo.OverlayInfo.hAllocation = pAlloc->hAllocation;
4459	OverInfo.OverlayInfo.DstRect = (D3DDDIRECT)((void*)&pData->OverlayInfo.DstRect);
4460	OverInfo.OverlayInfo.SrcRect = (D3DDDIRECT)((void*)&pData->OverlayInfo.SrcRect);
4461	OverInfo.OverlayInfo.pPrivateDriverData = &OurInfo;
4462	OverInfo.OverlayInfo.PrivateDriverDataSize = sizeof (OurInfo);
4463	#ifndef VBOXWDDMOVERLAY_TEST
4464	hr = pDevice->RtCallbacks.pfnUpdateOverlayCb(pDevice->hDevice, &OverInfo);
4465	Assert(hr == S_OK);
4466	if (hr == S_OK)
4467	#endif
4468	{
4469	Assert(!pAlloc->LockInfo.cLocks);
4470	if (!pAlloc->LockInfo.cLocks)
4471	{
4472	/* we have reported the dirty rect, may clear it if no locks are pending currently */
4473	vboxWddmDirtyRegionClear(&pAlloc->DirtyRegion);
4474	}
4475	}
4476
4477	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4478	return hr;
4479	}
4480	static HRESULT APIENTRY vboxWddmDDevFlipOverlay(HANDLE hDevice, CONST D3DDDIARG_FLIPOVERLAY* pData)
4481	{
4482	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4483	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
4484	PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hSource;
4485	Assert(pRc);
4486	Assert(pRc->cAllocations > pData->SourceIndex);
4487	PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SourceIndex];
4488	HRESULT hr = S_OK;
4489	PVBOXWDDMDISP_OVERLAY pOverlay = (PVBOXWDDMDISP_OVERLAY)pData->hOverlay;
4490	VBOXWDDM_OVERLAYFLIP_INFO OurInfo;
4491	vboxWddmDirtyRegionClear(&OurInfo.DirtyRegion);
4492	Assert(!pAlloc->LockInfo.cLocks);
4493	vboxWddmDirtyRegionUnite(&OurInfo.DirtyRegion, &pAlloc->DirtyRegion);
4494	D3DDDICB_FLIPOVERLAY OverInfo;
4495	OverInfo.hKernelOverlay = pOverlay->hOverlay;
4496	OverInfo.hSource = pAlloc->hAllocation;
4497	OverInfo.pPrivateDriverData = &OurInfo;
4498	OverInfo.PrivateDriverDataSize = sizeof (OurInfo);
4499	#ifndef VBOXWDDMOVERLAY_TEST
4500	hr = pDevice->RtCallbacks.pfnFlipOverlayCb(pDevice->hDevice, &OverInfo);
4501	Assert(hr == S_OK);
4502	if (hr == S_OK)
4503	#endif
4504	{
4505	Assert(!pAlloc->LockInfo.cLocks);
4506	if (!pAlloc->LockInfo.cLocks)
4507	{
4508	/* we have reported the dirty rect, may clear it if no locks are pending currently */
4509	vboxWddmDirtyRegionClear(&pAlloc->DirtyRegion);
4510	}
4511	}
4512
4513	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4514	return hr;
4515	}
4516	static HRESULT APIENTRY vboxWddmDDevGetOverlayColorControls(HANDLE hDevice, D3DDDIARG_GETOVERLAYCOLORCONTROLS* pData)
4517	{
4518	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4519	AssertBreakpoint();
4520	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4521	return E_FAIL;
4522	}
4523	static HRESULT APIENTRY vboxWddmDDevSetOverlayColorControls(HANDLE hDevice, CONST D3DDDIARG_SETOVERLAYCOLORCONTROLS* pData)
4524	{
4525	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4526	AssertBreakpoint();
4527	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4528	return E_FAIL;
4529	}
4530	static HRESULT APIENTRY vboxWddmDDevDestroyOverlay(HANDLE hDevice, CONST D3DDDIARG_DESTROYOVERLAY* pData)
4531	{
4532	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4533	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
4534	PVBOXWDDMDISP_OVERLAY pOverlay = (PVBOXWDDMDISP_OVERLAY)pData->hOverlay;
4535	D3DDDICB_DESTROYOVERLAY OverInfo;
4536	OverInfo.hKernelOverlay = pOverlay->hOverlay;
4537	#ifndef VBOXWDDMOVERLAY_TEST
4538	HRESULT hr = pDevice->RtCallbacks.pfnDestroyOverlayCb(pDevice->hDevice, &OverInfo);
4539	Assert(hr == S_OK);
4540	if (hr == S_OK)
4541	#else
4542	HRESULT hr = S_OK;
4543	#endif
4544	{
4545	RTMemFree(pOverlay);
4546	}
4547
4548	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4549	return hr;
4550	}
4551	static HRESULT APIENTRY vboxWddmDDevQueryResourceResidency(HANDLE hDevice, CONST D3DDDIARG_QUERYRESOURCERESIDENCY* pData)
4552	{
4553	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4554	AssertBreakpoint();
4555	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4556	return E_FAIL;
4557	}
4558
4559	static HRESULT vboxAllocationInit(PVBOXWDDMDISP_ALLOCATION pAlloc, D3DDDI_OPENALLOCATIONINFO *pInfo)
4560	{
4561	HRESULT hr = S_OK;
4562	pAlloc->hAllocation = pInfo->hAllocation;
4563	Assert(pInfo->PrivateDriverDataSize == sizeof (VBOXWDDM_ALLOCINFO));
4564	Assert(pInfo->pPrivateDriverData);
4565	if (pInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO))
4566	{
4567	PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pInfo->pPrivateDriverData;
4568	pAlloc->enmType = pAllocInfo->enmType;
4569	Assert(pAllocInfo->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
4570	\|\| VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE
4571	\|\| VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE);
4572	pAlloc->pvMem = NULL;
4573	pAlloc->SurfDesc = pAllocInfo->SurfDesc;
4574	}
4575	else
4576	{
4577	vboxVDbgPrintR((__FUNCTION__": ERROR: PrivateDriverDataSize(%d) < (%d)\n", pInfo->PrivateDriverDataSize, sizeof (VBOXWDDM_ALLOCINFO)));
4578	hr = E_INVALIDARG;
4579	}
4580	return hr;
4581	}
4582
4583	static HRESULT APIENTRY vboxWddmDDevOpenResource(HANDLE hDevice, D3DDDIARG_OPENRESOURCE* pData)
4584	{
4585	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4586	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
4587	HRESULT hr = S_OK;
4588
4589	Assert(pDevice);
4590	Assert(pData->NumAllocations);
4591	PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(pData->NumAllocations);
4592	Assert(pRc);
4593	if (pRc)
4594	{
4595	pRc->hResource = pData->hResource;
4596	pRc->hKMResource = pData->hKMResource;
4597	pRc->pDevice = pDevice;
4598	pRc->RcDesc.enmRotation = pData->Rotation;
4599	pRc->fFlags = VBOXWDDM_RESOURCE_F_OPENNED;
4600	if (!pData->pPrivateDriverData \|\| !pData->PrivateDriverDataSize)
4601	{
4602	/* this is a "standard" allocation resource */
4603
4604	/* both should be actually zero */
4605	Assert(!pData->pPrivateDriverData && !pData->PrivateDriverDataSize);
4606	pRc->RcDesc.enmPool = D3DDDIPOOL_LOCALVIDMEM;
4607	pRc->RcDesc.enmMultisampleType = D3DDDIMULTISAMPLE_NONE;
4608	pRc->RcDesc.MultisampleQuality = 0;
4609	pRc->RcDesc.MipLevels = 0;
4610	pRc->RcDesc.Fvf;
4611	pRc->RcDesc.fFlags.Value = 0;
4612
4613	Assert(pData->NumAllocations);
4614	D3DDDI_OPENALLOCATIONINFO* pDdiAllocInfo = &pData->pOpenAllocationInfo[0];
4615	Assert(pDdiAllocInfo->pPrivateDriverData);
4616	Assert(pDdiAllocInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO));
4617	if (pDdiAllocInfo->pPrivateDriverData && pDdiAllocInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO))
4618	{
4619	PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pDdiAllocInfo->pPrivateDriverData;
4620	switch(pAllocInfo->enmType)
4621	{
4622	case VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE:
4623	pRc->RcDesc.fFlags.Primary = 1;
4624	case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
4625	case VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE:
4626	pRc->RcDesc.enmFormat = pAllocInfo->SurfDesc.format;
4627	pRc->RcDesc.VidPnSourceId = pAllocInfo->SurfDesc.VidPnSourceId;
4628	pRc->RcDesc.RefreshRate = pAllocInfo->SurfDesc.RefreshRate;
4629	break;
4630	default:
4631	AssertBreakpoint();
4632	hr = E_INVALIDARG;
4633	}
4634	}
4635	else
4636	hr = E_INVALIDARG;
4637	}
4638	else
4639	{
4640	AssertBreakpoint(); /* <-- need to test that */
4641
4642	/* this is a "generic" resource whose creation is initiaded by the UMD */
4643	Assert(pData->PrivateDriverDataSize == sizeof (VBOXWDDM_RCINFO));
4644	if (pData->PrivateDriverDataSize >= sizeof (VBOXWDDM_RCINFO))
4645	{
4646	VBOXWDDM_RCINFO pRcInfo = (VBOXWDDM_RCINFO)pData->pPrivateDriverData;
4647	Assert(pRcInfo->fFlags == VBOXWDDM_RESOURCE_F_TYPE_GENERIC);
4648	Assert(pRcInfo->cAllocInfos == pData->NumAllocations);
4649	pRc->fFlags = pRcInfo->fFlags \| VBOXWDDM_RESOURCE_F_OPENNED;
4650	pRc->RcDesc = pRcInfo->RcDesc;
4651	pRc->cAllocations = pData->NumAllocations;
4652	}
4653	else
4654	hr = E_INVALIDARG;
4655	}
4656
4657	if (hr == S_OK)
4658	{
4659	for (UINT i = 0; i < pData->NumAllocations; ++i)
4660	{
4661	hr = vboxAllocationInit(&pRc->aAllocations[i], &pData->pOpenAllocationInfo[i]);
4662	Assert(hr == S_OK);
4663	if (hr != S_OK)
4664	break;
4665	}
4666	}
4667
4668	if (hr == S_OK)
4669	pData->hResource = pRc;
4670	else
4671	vboxResourceFree(pRc);
4672	}
4673	else
4674	{
4675	vboxVDbgPrintR((__FUNCTION__": vboxResourceAlloc failed for hDevice(0x%p), NumAllocations(%d)\n", hDevice, pData->NumAllocations));
4676	hr = E_OUTOFMEMORY;
4677	}
4678
4679	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4680	return hr;
4681	}
4682	static HRESULT APIENTRY vboxWddmDDevGetCaptureAllocationHandle(HANDLE hDevice, D3DDDIARG_GETCAPTUREALLOCATIONHANDLE* pData)
4683	{
4684	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4685	AssertBreakpoint();
4686	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4687	return E_FAIL;
4688	}
4689
4690	static HRESULT APIENTRY vboxWddmDDevCaptureToSysMem(HANDLE hDevice, CONST D3DDDIARG_CAPTURETOSYSMEM* pData)
4691	{
4692	vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4693	AssertBreakpoint();
4694	vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
4695	return E_FAIL;
4696	}
4697
4698	static HRESULT APIENTRY vboxWddmDispCreateDevice (IN HANDLE hAdapter, IN D3DDDIARG_CREATEDEVICE* pCreateData)
4699	{
4700	HRESULT hr = S_OK;
4701	vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p), Interface(%d), Version(%d)\n", hAdapter, pCreateData->Interface, pCreateData->Version));
4702
4703	// AssertBreakpoint();
4704
4705	PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)RTMemAllocZ(sizeof (VBOXWDDMDISP_DEVICE));
4706	if (pDevice)
4707	{
4708	PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
4709
4710	pDevice->hDevice = pCreateData->hDevice;
4711	pDevice->pAdapter = pAdapter;
4712	pDevice->u32IfVersion = pCreateData->Interface;
4713	pDevice->uRtVersion = pCreateData->Version;
4714	pDevice->RtCallbacks = *pCreateData->pCallbacks;
4715	pDevice->pvCmdBuffer = pCreateData->pCommandBuffer;
4716	pDevice->cbCmdBuffer = pCreateData->CommandBufferSize;
4717	pDevice->fFlags = pCreateData->Flags;
4718	/* Set Viewport to some default values */
4719	pDevice->ViewPort.X = 0;
4720	pDevice->ViewPort.Y = 0;
4721	pDevice->ViewPort.Width = 1;
4722	pDevice->ViewPort.Height = 1;
4723	pDevice->ViewPort.MinZ = 0.;
4724	pDevice->ViewPort.MaxZ = 1.;
4725
4726	Assert(!pCreateData->AllocationListSize);
4727	Assert(!pCreateData->PatchLocationListSize);
4728
4729	pCreateData->hDevice = pDevice;
4730
4731	pCreateData->pDeviceFuncs->pfnSetRenderState = vboxWddmDDevSetRenderState;
4732	pCreateData->pDeviceFuncs->pfnUpdateWInfo = vboxWddmDDevUpdateWInfo;
4733	pCreateData->pDeviceFuncs->pfnValidateDevice = vboxWddmDDevValidateDevice;
4734	pCreateData->pDeviceFuncs->pfnSetTextureStageState = vboxWddmDDevSetTextureStageState;
4735	pCreateData->pDeviceFuncs->pfnSetTexture = vboxWddmDDevSetTexture;
4736	pCreateData->pDeviceFuncs->pfnSetPixelShader = vboxWddmDDevSetPixelShader;
4737	pCreateData->pDeviceFuncs->pfnSetPixelShaderConst = vboxWddmDDevSetPixelShaderConst;
4738	pCreateData->pDeviceFuncs->pfnSetStreamSourceUm = vboxWddmDDevSetStreamSourceUm;
4739	pCreateData->pDeviceFuncs->pfnSetIndices = vboxWddmDDevSetIndices;
4740	pCreateData->pDeviceFuncs->pfnSetIndicesUm = vboxWddmDDevSetIndicesUm;
4741	pCreateData->pDeviceFuncs->pfnDrawPrimitive = vboxWddmDDevDrawPrimitive;
4742	pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive = vboxWddmDDevDrawIndexedPrimitive;
4743	pCreateData->pDeviceFuncs->pfnDrawRectPatch = vboxWddmDDevDrawRectPatch;
4744	pCreateData->pDeviceFuncs->pfnDrawTriPatch = vboxWddmDDevDrawTriPatch;
4745	pCreateData->pDeviceFuncs->pfnDrawPrimitive2 = vboxWddmDDevDrawPrimitive2;
4746	pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive2 = vboxWddmDDevDrawIndexedPrimitive2;
4747	pCreateData->pDeviceFuncs->pfnVolBlt = vboxWddmDDevVolBlt;
4748	pCreateData->pDeviceFuncs->pfnBufBlt = vboxWddmDDevBufBlt;
4749	pCreateData->pDeviceFuncs->pfnTexBlt = vboxWddmDDevTexBlt;
4750	pCreateData->pDeviceFuncs->pfnStateSet = vboxWddmDDevStateSet;
4751	pCreateData->pDeviceFuncs->pfnSetPriority = vboxWddmDDevSetPriority;
4752	pCreateData->pDeviceFuncs->pfnClear = vboxWddmDDevClear;
4753	pCreateData->pDeviceFuncs->pfnUpdatePalette = vboxWddmDDevUpdatePalette;
4754	pCreateData->pDeviceFuncs->pfnSetPalette = vboxWddmDDevSetPalette;
4755	pCreateData->pDeviceFuncs->pfnSetVertexShaderConst = vboxWddmDDevSetVertexShaderConst;
4756	pCreateData->pDeviceFuncs->pfnMultiplyTransform = vboxWddmDDevMultiplyTransform;
4757	pCreateData->pDeviceFuncs->pfnSetTransform = vboxWddmDDevSetTransform;
4758	pCreateData->pDeviceFuncs->pfnSetViewport = vboxWddmDDevSetViewport;
4759	pCreateData->pDeviceFuncs->pfnSetZRange = vboxWddmDDevSetZRange;
4760	pCreateData->pDeviceFuncs->pfnSetMaterial = vboxWddmDDevSetMaterial;
4761	pCreateData->pDeviceFuncs->pfnSetLight = vboxWddmDDevSetLight;
4762	pCreateData->pDeviceFuncs->pfnCreateLight = vboxWddmDDevCreateLight;
4763	pCreateData->pDeviceFuncs->pfnDestroyLight = vboxWddmDDevDestroyLight;
4764	pCreateData->pDeviceFuncs->pfnSetClipPlane = vboxWddmDDevSetClipPlane;
4765	pCreateData->pDeviceFuncs->pfnGetInfo = vboxWddmDDevGetInfo;
4766	pCreateData->pDeviceFuncs->pfnLock = vboxWddmDDevLock;
4767	pCreateData->pDeviceFuncs->pfnUnlock = vboxWddmDDevUnlock;
4768	pCreateData->pDeviceFuncs->pfnCreateResource = vboxWddmDDevCreateResource;
4769	pCreateData->pDeviceFuncs->pfnDestroyResource = vboxWddmDDevDestroyResource;
4770	pCreateData->pDeviceFuncs->pfnSetDisplayMode = vboxWddmDDevSetDisplayMode;
4771	pCreateData->pDeviceFuncs->pfnPresent = vboxWddmDDevPresent;
4772	pCreateData->pDeviceFuncs->pfnFlush = vboxWddmDDevFlush;
4773	pCreateData->pDeviceFuncs->pfnCreateVertexShaderFunc = vboxWddmDDevCreateVertexShaderFunc;
4774	pCreateData->pDeviceFuncs->pfnDeleteVertexShaderFunc = vboxWddmDDevDeleteVertexShaderFunc;
4775	pCreateData->pDeviceFuncs->pfnSetVertexShaderFunc = vboxWddmDDevSetVertexShaderFunc;
4776	pCreateData->pDeviceFuncs->pfnCreateVertexShaderDecl = vboxWddmDDevCreateVertexShaderDecl;
4777	pCreateData->pDeviceFuncs->pfnDeleteVertexShaderDecl = vboxWddmDDevDeleteVertexShaderDecl;
4778	pCreateData->pDeviceFuncs->pfnSetVertexShaderDecl = vboxWddmDDevSetVertexShaderDecl;
4779	pCreateData->pDeviceFuncs->pfnSetVertexShaderConstI = vboxWddmDDevSetVertexShaderConstI;
4780	pCreateData->pDeviceFuncs->pfnSetVertexShaderConstB = vboxWddmDDevSetVertexShaderConstB;
4781	pCreateData->pDeviceFuncs->pfnSetScissorRect = vboxWddmDDevSetScissorRect;
4782	pCreateData->pDeviceFuncs->pfnSetStreamSource = vboxWddmDDevSetStreamSource;
4783	pCreateData->pDeviceFuncs->pfnSetStreamSourceFreq = vboxWddmDDevSetStreamSourceFreq;
4784	pCreateData->pDeviceFuncs->pfnSetConvolutionKernelMono = vboxWddmDDevSetConvolutionKernelMono;
4785	pCreateData->pDeviceFuncs->pfnComposeRects = vboxWddmDDevComposeRects;
4786	pCreateData->pDeviceFuncs->pfnBlt = vboxWddmDDevBlt;
4787	pCreateData->pDeviceFuncs->pfnColorFill = vboxWddmDDevColorFill;
4788	pCreateData->pDeviceFuncs->pfnDepthFill = vboxWddmDDevDepthFill;
4789	pCreateData->pDeviceFuncs->pfnCreateQuery = vboxWddmDDevCreateQuery;
4790	pCreateData->pDeviceFuncs->pfnDestroyQuery = vboxWddmDDevDestroyQuery;
4791	pCreateData->pDeviceFuncs->pfnIssueQuery = vboxWddmDDevIssueQuery;
4792	pCreateData->pDeviceFuncs->pfnGetQueryData = vboxWddmDDevGetQueryData;
4793	pCreateData->pDeviceFuncs->pfnSetRenderTarget = vboxWddmDDevSetRenderTarget;
4794	pCreateData->pDeviceFuncs->pfnSetDepthStencil = vboxWddmDDevSetDepthStencil;
4795	pCreateData->pDeviceFuncs->pfnGenerateMipSubLevels = vboxWddmDDevGenerateMipSubLevels;
4796	pCreateData->pDeviceFuncs->pfnSetPixelShaderConstI = vboxWddmDDevSetPixelShaderConstI;
4797	pCreateData->pDeviceFuncs->pfnSetPixelShaderConstB = vboxWddmDDevSetPixelShaderConstB;
4798	pCreateData->pDeviceFuncs->pfnCreatePixelShader = vboxWddmDDevCreatePixelShader;
4799	pCreateData->pDeviceFuncs->pfnDeletePixelShader = vboxWddmDDevDeletePixelShader;
4800	pCreateData->pDeviceFuncs->pfnCreateDecodeDevice = vboxWddmDDevCreateDecodeDevice;
4801	pCreateData->pDeviceFuncs->pfnDestroyDecodeDevice = vboxWddmDDevDestroyDecodeDevice;
4802	pCreateData->pDeviceFuncs->pfnSetDecodeRenderTarget = vboxWddmDDevSetDecodeRenderTarget;
4803	pCreateData->pDeviceFuncs->pfnDecodeBeginFrame = vboxWddmDDevDecodeBeginFrame;
4804	pCreateData->pDeviceFuncs->pfnDecodeEndFrame = vboxWddmDDevDecodeEndFrame;
4805	pCreateData->pDeviceFuncs->pfnDecodeExecute = vboxWddmDDevDecodeExecute;
4806	pCreateData->pDeviceFuncs->pfnDecodeExtensionExecute = vboxWddmDDevDecodeExtensionExecute;
4807	pCreateData->pDeviceFuncs->pfnCreateVideoProcessDevice = vboxWddmDDevCreateVideoProcessDevice;
4808	pCreateData->pDeviceFuncs->pfnDestroyVideoProcessDevice = vboxWddmDDevDestroyVideoProcessDevice;
4809	pCreateData->pDeviceFuncs->pfnVideoProcessBeginFrame = vboxWddmDDevVideoProcessBeginFrame;
4810	pCreateData->pDeviceFuncs->pfnVideoProcessEndFrame = vboxWddmDDevVideoProcessEndFrame;
4811	pCreateData->pDeviceFuncs->pfnSetVideoProcessRenderTarget = vboxWddmDDevSetVideoProcessRenderTarget;
4812	pCreateData->pDeviceFuncs->pfnVideoProcessBlt = vboxWddmDDevVideoProcessBlt;
4813	pCreateData->pDeviceFuncs->pfnCreateExtensionDevice = vboxWddmDDevCreateExtensionDevice;
4814	pCreateData->pDeviceFuncs->pfnDestroyExtensionDevice = vboxWddmDDevDestroyExtensionDevice;
4815	pCreateData->pDeviceFuncs->pfnExtensionExecute = vboxWddmDDevExtensionExecute;
4816	pCreateData->pDeviceFuncs->pfnCreateOverlay = vboxWddmDDevCreateOverlay;
4817	pCreateData->pDeviceFuncs->pfnUpdateOverlay = vboxWddmDDevUpdateOverlay;
4818	pCreateData->pDeviceFuncs->pfnFlipOverlay = vboxWddmDDevFlipOverlay;
4819	pCreateData->pDeviceFuncs->pfnGetOverlayColorControls = vboxWddmDDevGetOverlayColorControls;
4820	pCreateData->pDeviceFuncs->pfnSetOverlayColorControls = vboxWddmDDevSetOverlayColorControls;
4821	pCreateData->pDeviceFuncs->pfnDestroyOverlay = vboxWddmDDevDestroyOverlay;
4822	pCreateData->pDeviceFuncs->pfnDestroyDevice = vboxWddmDDevDestroyDevice;
4823	pCreateData->pDeviceFuncs->pfnQueryResourceResidency = vboxWddmDDevQueryResourceResidency;
4824	pCreateData->pDeviceFuncs->pfnOpenResource = vboxWddmDDevOpenResource;
4825	pCreateData->pDeviceFuncs->pfnGetCaptureAllocationHandle = vboxWddmDDevGetCaptureAllocationHandle;
4826	pCreateData->pDeviceFuncs->pfnCaptureToSysMem = vboxWddmDDevCaptureToSysMem;
4827	pCreateData->pDeviceFuncs->pfnLockAsync = NULL; //vboxWddmDDevLockAsync;
4828	pCreateData->pDeviceFuncs->pfnUnlockAsync = NULL; //vboxWddmDDevUnlockAsync;
4829	pCreateData->pDeviceFuncs->pfnRename = NULL; //vboxWddmDDevRename;
4830
4831
4832	do
4833	{
4834	Assert(!pCreateData->AllocationListSize
4835	&& !pCreateData->PatchLocationListSize);
4836	if (!pCreateData->AllocationListSize
4837	&& !pCreateData->PatchLocationListSize)
4838	{
4839	hr = vboxDispCmCtxCreate(pDevice, &pDevice->DefaultContext);
4840	Assert(hr == S_OK);
4841	if (hr == S_OK)
4842	break;
4843	}
4844	else
4845	{
4846	vboxVDbgPrintR((__FUNCTION__": Not implemented: PatchLocationListSize(%d), AllocationListSize(%d)\n",
4847	pCreateData->PatchLocationListSize, pCreateData->AllocationListSize));
4848	//pCreateData->pAllocationList = ??
4849	hr = E_FAIL;
4850	}
4851
4852	RTMemFree(pDevice);
4853	} while (0);
4854	}
4855	else
4856	{
4857	vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
4858	hr = E_OUTOFMEMORY;
4859	}
4860
4861	vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
4862
4863	return hr;
4864	}
4865
4866	static HRESULT APIENTRY vboxWddmDispCloseAdapter (IN HANDLE hAdapter)
4867	{
4868	vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
4869
4870	// AssertBreakpoint();
4871
4872	PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
4873	if (VBOXDISPMODE_IS_3D(pAdapter))
4874	{
4875	HRESULT hr = VBoxDispWorkerDestroy(&pAdapter->WndWorker);
4876	Assert(hr == S_OK);
4877	pAdapter->pD3D9If->Release();
4878	VBoxDispD3DClose(&pAdapter->D3D);
4879	}
4880
4881	vboxCapsFree(pAdapter);
4882
4883	RTMemFree(pAdapter);
4884
4885	vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
4886
4887	return S_OK;
4888	}
4889
4890	HRESULT APIENTRY OpenAdapter (__inout D3DDDIARG_OPENADAPTER* pOpenData)
4891	{
4892	vboxVDbgPrint(("==> "__FUNCTION__"\n"));
4893
4894	VBOXWDDM_QI Query;
4895	D3DDDICB_QUERYADAPTERINFO DdiQuery;
4896	DdiQuery.PrivateDriverDataSize = sizeof(Query);
4897	DdiQuery.pPrivateDriverData = &Query;
4898	HRESULT hr = pOpenData->pAdapterCallbacks->pfnQueryAdapterInfoCb(pOpenData->hAdapter, &DdiQuery);
4899	Assert(hr == S_OK);
4900	if (hr != S_OK)
4901	{
4902	vboxVDbgPrintR((__FUNCTION__": pfnQueryAdapterInfoCb failed, hr (%d)\n", hr));
4903	return E_FAIL;
4904	}
4905
4906	/* check the miniport version match display version */
4907	if (Query.u32Version != VBOXVIDEOIF_VERSION)
4908	{
4909	vboxVDbgPrintR((__FUNCTION__": miniport version mismatch, expected (%d), but was (%d)\n",
4910	VBOXVIDEOIF_VERSION,
4911	Query.u32Version));
4912	return E_FAIL;
4913	}
4914
4915	#ifdef VBOX_WITH_VIDEOHWACCEL
4916	Assert(Query.cInfos >= 1);
4917	PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(RT_OFFSETOF(VBOXWDDMDISP_ADAPTER, aHeads[Query.cInfos]));
4918	#else
4919	PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(sizeof (VBOXWDDMDISP_ADAPTER));
4920	#endif
4921	Assert(pAdapter);
4922	if (pAdapter)
4923	{
4924	pAdapter->hAdapter = pOpenData->hAdapter;
4925	pAdapter->uIfVersion = pOpenData->Interface;
4926	pAdapter->uRtVersion= pOpenData->Version;
4927	pAdapter->RtCallbacks = *pOpenData->pAdapterCallbacks;
4928
4929	pAdapter->cHeads = Query.cInfos;
4930
4931
4932	pOpenData->hAdapter = pAdapter;
4933	pOpenData->pAdapterFuncs->pfnGetCaps = vboxWddmDispGetCaps;
4934	pOpenData->pAdapterFuncs->pfnCreateDevice = vboxWddmDispCreateDevice;
4935	pOpenData->pAdapterFuncs->pfnCloseAdapter = vboxWddmDispCloseAdapter;
4936	pOpenData->DriverVersion = D3D_UMD_INTERFACE_VERSION;
4937	/*
4938	* here we detect whether we are called by the d3d or ddraw.
4939	* in the d3d case we init our d3d environment
4940	* in the ddraw case we init 2D acceleration
4941	* if interface version is > 7, this is D3D, treat it as so
4942	* otherwise treat it as ddraw
4943	* @todo: need a more clean way of doing this */
4944
4945	if (pAdapter->uIfVersion > 7)
4946	{
4947	do
4948	{
4949	/* try enable the 3D */
4950	hr = VBoxDispD3DOpen(&pAdapter->D3D);
4951	Assert(hr == S_OK);
4952	if (hr == S_OK)
4953	{
4954	hr = pAdapter->D3D.pfnDirect3DCreate9Ex(D3D_SDK_VERSION, &pAdapter->pD3D9If);
4955	Assert(hr == S_OK);
4956	if (hr == S_OK)
4957	{
4958	hr = VBoxDispWorkerCreate(&pAdapter->WndWorker);
4959	Assert(hr == S_OK);
4960	if (hr == S_OK)
4961	{
4962	vboxVDbgPrint((__FUNCTION__": SUCCESS 3D Enabled, pAdapter (0x%p)\n", pAdapter));
4963	break;
4964	}
4965	pAdapter->pD3D9If->Release();
4966	}
4967	else
4968	vboxVDbgPrintR((__FUNCTION__": pfnDirect3DCreate9Ex failed, hr (%d)\n", hr));
4969	VBoxDispD3DClose(&pAdapter->D3D);
4970	}
4971	else
4972	vboxVDbgPrintR((__FUNCTION__": VBoxDispD3DOpen failed, hr (%d)\n", hr));
4973	} while (0);
4974	}
4975	#ifdef VBOX_WITH_VIDEOHWACCEL
4976	else
4977	{
4978	for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
4979	{
4980	pAdapter->aHeads[i].Vhwa.Settings = Query.aInfos[i];
4981	}
4982	}
4983	#endif
4984
4985	vboxCapsInit(pAdapter);
4986	hr = S_OK;
4987	// RTMemFree(pAdapter);
4988	}
4989	else
4990	{
4991	vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
4992	hr = E_OUTOFMEMORY;
4993	}
4994
4995	vboxVDbgPrint(("<== "__FUNCTION__", hr (%d)\n", hr));
4996
4997	return hr;
4998	}
4999
5000	#ifdef VBOXWDDMDISP_DEBUG
5001	VOID vboxVDbgDoPrint(LPCSTR szString, ...)
5002	{
5003	char szBuffer[1024] = {0};
5004	va_list pArgList;
5005	va_start(pArgList, szString);
5006	_vsnprintf(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]), szString, pArgList);
5007	va_end(pArgList);
5008
5009	OutputDebugStringA(szBuffer);
5010	}
5011	#endif

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

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

Download in other formats: