VBoxDispD3D.cpp@ 30096

Last change on this file since 30096 was 30096, checked in by vboxsync, 15 years ago
wddm/3d: texture lock/unlock + bugfixes
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 132.2 KB

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

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

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

Download in other formats: