VBoxMPIf.h@ 94990

Last change on this file since 94990 was 94990, checked in by vboxsync, 3 years ago
WDDM: D3D10DDI_QUERY_EVENT; SetPredication. bugref:9845
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 35.3 KB

Line
1	/* $Id: VBoxMPIf.h 94990 2022-05-12 12:07:56Z vboxsync $ */
2	/** @file
3	* VBox WDDM Miniport driver.
4	*
5	* Contains base definitions of constants & structures used to control & perform
6	* rendering, such as DMA commands types, allocation types, escape codes, etc.
7	* used by both miniport & display drivers.
8	*
9	* The latter uses these and only these defs to communicate with the former
10	* by posting appropriate requests via D3D RT Krnl Svc accessing callbacks.
11	*/
12
13	/*
14	* Copyright (C) 2011-2022 Oracle Corporation
15	*
16	* This file is part of VirtualBox Open Source Edition (OSE), as
17	* available from http://www.virtualbox.org. This file is free software;
18	* you can redistribute it and/or modify it under the terms of the GNU
19	* General Public License (GPL) as published by the Free Software
20	* Foundation, in version 2 as it comes in the "COPYING" file of the
21	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
22	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
23	*/
24
25	#ifndef GA_INCLUDED_SRC_WINNT_Graphics_Video_common_wddm_VBoxMPIf_h
26	#define GA_INCLUDED_SRC_WINNT_Graphics_Video_common_wddm_VBoxMPIf_h
27	#ifndef RT_WITHOUT_PRAGMA_ONCE
28	# pragma once
29	#endif
30
31	#include <VBoxVideo.h>
32	#include "../../../../include/VBoxDisplay.h"
33	#include "../VBoxVideoTools.h"
34	#include <VBoxUhgsmi.h>
35	#include <VBox/VBoxGuestCoreTypes.h> /* for VBGLIOCHGCMCALL */
36
37	/* One would increase this whenever definitions in this file are changed */
38	#define VBOXVIDEOIF_VERSION 22
39
40	/** @todo VBOXVIDEO_HWTYPE probably needs to be in VBoxVideo.h */
41	typedef enum VBOXVIDEO_HWTYPE
42	{
43	VBOXVIDEO_HWTYPE_VBOX = 0,
44	VBOXVIDEO_HWTYPE_VMSVGA = 1,
45	VBOXVIDEO_HWTYPE_32BIT = 0x7fffffff
46	} VBOXVIDEO_HWTYPE;
47	AssertCompileSize(VBOXVIDEO_HWTYPE, 4);
48
49	#define VBOXWDDM_NODE_ID_SYSTEM 0
50	#define VBOXWDDM_NODE_ID_3D (VBOXWDDM_NODE_ID_SYSTEM)
51	#define VBOXWDDM_NODE_ID_3D_KMT (VBOXWDDM_NODE_ID_3D)
52	#define VBOXWDDM_NODE_ID_2D_VIDEO (VBOXWDDM_NODE_ID_3D_KMT + 1)
53	#define VBOXWDDM_NUM_NODES (VBOXWDDM_NODE_ID_2D_VIDEO + 1)
54
55	#define VBOXWDDM_ENGINE_ID_SYSTEM 0
56	#if (VBOXWDDM_NODE_ID_3D == VBOXWDDM_NODE_ID_SYSTEM)
57	# define VBOXWDDM_ENGINE_ID_3D (VBOXWDDM_ENGINE_ID_SYSTEM + 1)
58	#else
59	# define VBOXWDDM_ENGINE_ID_3D 0
60	#endif
61	#if (VBOXWDDM_NODE_ID_3D_KMT == VBOXWDDM_NODE_ID_3D)
62	# define VBOXWDDM_ENGINE_ID_3D_KMT VBOXWDDM_ENGINE_ID_3D
63	#else
64	# define VBOXWDDM_ENGINE_ID_3D_KMT 0
65	#endif
66	#if (VBOXWDDM_NODE_ID_2D_VIDEO == VBOXWDDM_NODE_ID_3D)
67	# define VBOXWDDM_ENGINE_ID_2D_VIDEO VBOXWDDM_ENGINE_ID_3D
68	#else
69	# define VBOXWDDM_ENGINE_ID_2D_VIDEO 0
70	#endif
71
72
73	#ifdef VBOX_WITH_VMSVGA3D_DX
74	/*
75	* Structures for the new D3D user mode driver.
76	*/
77	#pragma pack(1) /* VMSVGA structures are '__packed'. */
78	#include <svga3d_reg.h>
79	#pragma pack()
80	#include <dxgiddi.h>
81
82	/* D3DDDI_ALLOCATIONINFO::pPrivateDriverData */
83	typedef enum VBOXDXALLOCATIONTYPE
84	{
85	VBOXDXALLOCATIONTYPE_UNKNOWN = 0,
86	VBOXDXALLOCATIONTYPE_SURFACE = 1,
87	VBOXDXALLOCATIONTYPE_SHADERS = 2,
88	VBOXDXALLOCATIONTYPE_CO = 3,
89	VBOXDXALLOCATIONTYPE_MAX,
90	VBOXDXALLOCATIONTYPE_32BIT = 0xFFFFFFFF
91	} VBOXDXALLOCATIONTYPE;
92
93	/* Information for DxgkDdiCreateAllocation and for SVGA3dCmdDefine[GB]Surface. */
94	typedef struct VBOXDXALLOCATIONDESC
95	{
96	VBOXDXALLOCATIONTYPE enmAllocationType;
97	uint32_t cbAllocation;
98	struct
99	{
100	SVGA3dSurfaceAllFlags surfaceFlags;
101	SVGA3dSurfaceFormat format;
102	uint32 numMipLevels;
103	uint32 multisampleCount;
104	SVGA3dMSPattern multisamplePattern;
105	SVGA3dMSQualityLevel qualityLevel;
106	SVGA3dTextureFilter autogenFilter;
107	SVGA3dSize size;
108	uint32 arraySize;
109	uint32 bufferByteStride;
110	} surfaceInfo;
111	bool fPrimary : 1;
112	DXGI_DDI_PRIMARY_DESC PrimaryDesc;
113	D3DDDIFORMAT enmDDIFormat;
114	struct
115	{
116	/* These will be needed by OpenResource */
117	UINT BindFlags;
118	UINT MapFlags;
119	UINT MiscFlags;
120	DXGI_FORMAT Format;
121	UINT DecoderBufferType; /* D3D11_1DDI_VIDEO_DECODER_BUFFER_TYPE */
122	} resourceInfo;
123	} VBOXDXALLOCATIONDESC, *PVBOXDXALLOCATIONDESC;
124	#endif /* VBOX_WITH_VMSVGA3D_DX */
125
126	/* create allocation func */
127	typedef enum
128	{
129	VBOXWDDM_ALLOC_TYPE_UNEFINED = 0,
130	VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE,
131	VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE,
132	VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE,
133	/* this one is win 7-specific and hence unused for now */
134	VBOXWDDM_ALLOC_TYPE_STD_GDISURFACE
135	/* custom allocation types requested from user-mode d3d module will go here */
136	, VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC
137	, VBOXWDDM_ALLOC_TYPE_UMD_HGSMI_BUFFER
138	#ifdef VBOX_WITH_VMSVGA3D_DX
139	, VBOXWDDM_ALLOC_TYPE_D3D /* Direct3D UMD driver allocation. Actual type is a VBOXDXALLOCATIONTYPE value. */
140	#endif /* VBOX_WITH_VMSVGA3D_DX */
141	} VBOXWDDM_ALLOC_TYPE;
142
143	/* usage */
144	typedef enum
145	{
146	VBOXWDDM_ALLOCUSAGE_TYPE_UNEFINED = 0,
147	/* set for the allocation being primary */
148	VBOXWDDM_ALLOCUSAGE_TYPE_PRIMARY,
149	} VBOXWDDM_ALLOCUSAGE_TYPE;
150
151	typedef struct VBOXWDDM_SURFACE_DESC
152	{
153	UINT width;
154	UINT height;
155	D3DDDIFORMAT format;
156	UINT bpp;
157	UINT pitch;
158	UINT depth;
159	UINT slicePitch;
160	UINT d3dWidth;
161	UINT cbSize;
162	D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
163	D3DDDI_RATIONAL RefreshRate;
164	} VBOXWDDM_SURFACE_DESC, *PVBOXWDDM_SURFACE_DESC;
165
166	typedef struct VBOXWDDM_ALLOCINFO
167	{
168	VBOXWDDM_ALLOC_TYPE enmType;
169	union
170	{
171	struct
172	{
173	D3DDDI_RESOURCEFLAGS fFlags;
174	/* id used to identify the allocation on the host */
175	uint32_t hostID;
176	uint64_t hSharedHandle;
177	VBOXWDDM_SURFACE_DESC SurfDesc;
178	};
179
180	struct
181	{
182	uint32_t cbBuffer;
183	VBOXUHGSMI_BUFFER_TYPE_FLAGS fUhgsmiType;
184	};
185	};
186	} VBOXWDDM_ALLOCINFO, *PVBOXWDDM_ALLOCINFO;
187
188	#ifdef VBOX_WITH_VMSVGA3D_DX
189	AssertCompile(sizeof(VBOXDXALLOCATIONDESC) != sizeof(VBOXWDDM_ALLOCINFO));
190	#endif
191
192	typedef struct VBOXWDDM_RC_DESC
193	{
194	D3DDDI_RESOURCEFLAGS fFlags;
195	D3DDDIFORMAT enmFormat;
196	D3DDDI_POOL enmPool;
197	D3DDDIMULTISAMPLE_TYPE enmMultisampleType;
198	UINT MultisampleQuality;
199	UINT MipLevels;
200	UINT Fvf;
201	D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
202	D3DDDI_RATIONAL RefreshRate;
203	D3DDDI_ROTATION enmRotation;
204	} VBOXWDDM_RC_DESC, *PVBOXWDDM_RC_DESC;
205
206	typedef struct VBOXWDDMDISP_RESOURCE_FLAGS
207	{
208	union
209	{
210	struct
211	{
212	UINT Opened : 1; /* this resource is OpenResource'd rather than CreateResource'd */
213	UINT Generic : 1; /* identifies this is a resource created with CreateResource, the VBOXWDDMDISP_RESOURCE::fRcFlags is valid */
214	UINT KmResource : 1; /* this resource has underlying km resource */
215	UINT Reserved : 29; /* reserved */
216	};
217	UINT Value;
218	};
219	} VBOXWDDMDISP_RESOURCE_FLAGS, *PVBOXWDDMDISP_RESOURCE_FLAGS;
220
221	typedef struct VBOXWDDM_RCINFO
222	{
223	VBOXWDDMDISP_RESOURCE_FLAGS fFlags;
224	VBOXWDDM_RC_DESC RcDesc;
225	uint32_t cAllocInfos;
226	// VBOXWDDM_ALLOCINFO aAllocInfos[1];
227	} VBOXWDDM_RCINFO, *PVBOXWDDM_RCINFO;
228
229	typedef struct VBOXWDDM_DMA_PRIVATEDATA_FLAFS
230	{
231	union
232	{
233	struct
234	{
235	UINT bCmdInDmaBuffer : 1;
236	UINT bReserved : 31;
237	};
238	uint32_t Value;
239	};
240	} VBOXWDDM_DMA_PRIVATEDATA_FLAFS, *PVBOXWDDM_DMA_PRIVATEDATA_FLAFS;
241
242	typedef struct VBOXWDDM_DMA_PRIVATEDATA_BASEHDR
243	{
244	VBOXVDMACMD_TYPE enmCmd;
245	union
246	{
247	VBOXWDDM_DMA_PRIVATEDATA_FLAFS fFlags;
248	uint32_t u32CmdReserved;
249	};
250	} VBOXWDDM_DMA_PRIVATEDATA_BASEHDR, *PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR;
251
252	typedef struct VBOXWDDM_UHGSMI_BUFFER_UI_SUBMIT_INFO
253	{
254	uint32_t offData;
255	uint32_t cbData;
256	} VBOXWDDM_UHGSMI_BUFFER_UI_SUBMIT_INFO, *PVBOXWDDM_UHGSMI_BUFFER_UI_SUBMIT_INFO;
257
258	typedef struct VBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD
259	{
260	VBOXWDDM_DMA_PRIVATEDATA_BASEHDR Base;
261	VBOXWDDM_UHGSMI_BUFFER_UI_SUBMIT_INFO aBufInfos[1];
262	} VBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD, *PVBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD;
263
264
265	#define VBOXVHWA_F_ENABLED 0x00000001
266	#define VBOXVHWA_F_CKEY_DST 0x00000002
267	#define VBOXVHWA_F_CKEY_SRC 0x00000004
268
269	#define VBOXVHWA_MAX_FORMATS 8
270
271	typedef struct VBOXVHWA_INFO
272	{
273	uint32_t fFlags;
274	uint32_t cOverlaysSupported;
275	uint32_t cFormats;
276	D3DDDIFORMAT aFormats[VBOXVHWA_MAX_FORMATS];
277	} VBOXVHWA_INFO;
278
279	#define VBOXWDDM_OVERLAY_F_CKEY_DST 0x00000001
280	#define VBOXWDDM_OVERLAY_F_CKEY_DSTRANGE 0x00000002
281	#define VBOXWDDM_OVERLAY_F_CKEY_SRC 0x00000004
282	#define VBOXWDDM_OVERLAY_F_CKEY_SRCRANGE 0x00000008
283	#define VBOXWDDM_OVERLAY_F_BOB 0x00000010
284	#define VBOXWDDM_OVERLAY_F_INTERLEAVED 0x00000020
285	#define VBOXWDDM_OVERLAY_F_MIRROR_LR 0x00000040
286	#define VBOXWDDM_OVERLAY_F_MIRROR_UD 0x00000080
287	#define VBOXWDDM_OVERLAY_F_DEINTERLACED 0x00000100
288
289	typedef struct VBOXWDDM_OVERLAY_DESC
290	{
291	uint32_t fFlags;
292	UINT DstColorKeyLow;
293	UINT DstColorKeyHigh;
294	UINT SrcColorKeyLow;
295	UINT SrcColorKeyHigh;
296	} VBOXWDDM_OVERLAY_DESC, *PVBOXWDDM_OVERLAY_DESC;
297
298	typedef struct VBOXWDDM_OVERLAY_INFO
299	{
300	VBOXWDDM_OVERLAY_DESC OverlayDesc;
301	VBOXWDDM_DIRTYREGION DirtyRegion; /* <- the dirty region of the overlay surface */
302	} VBOXWDDM_OVERLAY_INFO, *PVBOXWDDM_OVERLAY_INFO;
303
304	typedef struct VBOXWDDM_OVERLAYFLIP_INFO
305	{
306	VBOXWDDM_DIRTYREGION DirtyRegion; /* <- the dirty region of the overlay surface */
307	} VBOXWDDM_OVERLAYFLIP_INFO, *PVBOXWDDM_OVERLAYFLIP_INFO;
308
309
310	typedef enum
311	{
312	VBOXWDDM_CONTEXT_TYPE_UNDEFINED = 0,
313	/* system-created context (for GDI rendering) */
314	VBOXWDDM_CONTEXT_TYPE_SYSTEM,
315	/* context created by the D3D User-mode driver when crogl IS available */
316	obsolete_VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D,
317	/* context created by the D3D User-mode driver when crogl is NOT available or for ddraw overlay acceleration */
318	obsolete_VBOXWDDM_CONTEXT_TYPE_CUSTOM_2D,
319	/* contexts created by the cromium HGSMI transport for HGSMI commands submission */
320	obsolete_VBOXWDDM_CONTEXT_TYPE_CUSTOM_UHGSMI_3D,
321	obsolete_VBOXWDDM_CONTEXT_TYPE_CUSTOM_UHGSMI_GL,
322	/* context created by the kernel->user communication mechanism for visible rects reporting, etc. */
323	VBOXWDDM_CONTEXT_TYPE_CUSTOM_SESSION,
324	/* context created by VBoxTray to handle resize operations */
325	VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_RESIZE,
326	/* context created by VBoxTray to handle seamless operations */
327	VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_SEAMLESS,
328	/* Gallium driver context. */
329	VBOXWDDM_CONTEXT_TYPE_GA_3D,
330	/* Direct3D UMD context for VMSVGA device. */
331	VBOXWDDM_CONTEXT_TYPE_VMSVGA_D3D,
332	} VBOXWDDM_CONTEXT_TYPE;
333
334	typedef struct VBOXWDDM_CREATECONTEXT_INFO
335	{
336	/* interface version, i.e. 9 for d3d9, 8 for d3d8, etc. */
337	uint32_t u32IfVersion;
338	/* What kind of context to create. */
339	VBOXWDDM_CONTEXT_TYPE enmType;
340	union
341	{
342	struct
343	{
344	uint32_t crVersionMajor;
345	uint32_t crVersionMinor;
346	/* we use uint64_t instead of HANDLE to ensure structure def is the same for both 32-bit and 64-bit
347	* since x64 kernel driver can be called by 32-bit UMD */
348	uint64_t hUmEvent;
349	/* info to be passed to UMD notification to identify the context */
350	uint64_t u64UmInfo;
351	} vbox;
352	#ifdef VBOX_WITH_VMSVGA
353	struct
354	{
355	/* VBOXWDDM_F_GA_CONTEXT_* */
356	uint32_t u32Flags;
357	} vmsvga;
358	#endif
359	} u;
360	} VBOXWDDM_CREATECONTEXT_INFO, *PVBOXWDDM_CREATECONTEXT_INFO;
361
362	typedef uint64_t VBOXDISP_UMHANDLE;
363	typedef uint32_t VBOXDISP_KMHANDLE;
364
365	typedef struct VBOXWDDM_RECTS_FLAFS
366	{
367	union
368	{
369	struct
370	{
371	/* used only in conjunction with bSetVisibleRects.
372	* if set - VBOXWDDM_RECTS_INFO::aRects[0] contains view rectangle */
373	UINT bSetViewRect : 1;
374	/* adds visible regions */
375	UINT bAddVisibleRects : 1;
376	/* adds hidden regions */
377	UINT bAddHiddenRects : 1;
378	/* hide entire window */
379	UINT bHide : 1;
380	/* reserved */
381	UINT Reserved : 28;
382	};
383	uint32_t Value;
384	};
385	} VBOXWDDM_RECTS_FLAFS, *PVBOXWDDM_RECTS_FLAFS;
386
387	typedef struct VBOXWDDM_RECTS_INFO
388	{
389	uint32_t cRects;
390	RECT aRects[1];
391	} VBOXWDDM_RECTS_INFO, *PVBOXWDDM_RECTS_INFO;
392
393	#define VBOXWDDM_RECTS_INFO_SIZE4CRECTS(_cRects) (RT_UOFFSETOF_DYN(VBOXWDDM_RECTS_INFO, aRects[(_cRects)]))
394	#define VBOXWDDM_RECTS_INFO_SIZE(_pRects) (VBOXVIDEOCM_CMD_RECTS_SIZE4CRECTS((_pRects)->cRects))
395
396	typedef enum
397	{
398	/* command to be post to user mode */
399	VBOXVIDEOCM_CMD_TYPE_UM = 0,
400	/* control command processed in kernel mode */
401	VBOXVIDEOCM_CMD_TYPE_CTL_KM,
402	VBOXVIDEOCM_CMD_DUMMY_32BIT = 0x7fffffff
403	} VBOXVIDEOCM_CMD_TYPE;
404
405	typedef struct VBOXVIDEOCM_CMD_HDR
406	{
407	uint64_t u64UmData;
408	uint32_t cbCmd;
409	VBOXVIDEOCM_CMD_TYPE enmType;
410	}VBOXVIDEOCM_CMD_HDR, *PVBOXVIDEOCM_CMD_HDR;
411
412	AssertCompile((sizeof (VBOXVIDEOCM_CMD_HDR) & 7) == 0);
413
414	typedef struct VBOXVIDEOCM_CMD_RECTS
415	{
416	VBOXWDDM_RECTS_FLAFS fFlags;
417	VBOXWDDM_RECTS_INFO RectsInfo;
418	} VBOXVIDEOCM_CMD_RECTS, *PVBOXVIDEOCM_CMD_RECTS;
419
420	typedef struct VBOXWDDM_GETVBOXVIDEOCMCMD_HDR
421	{
422	uint32_t cbCmdsReturned;
423	uint32_t cbRemainingCmds;
424	uint32_t cbRemainingFirstCmd;
425	uint32_t u32Reserved;
426	} VBOXWDDM_GETVBOXVIDEOCMCMD_HDR, *PVBOXWDDM_GETVBOXVIDEOCMCMD_HDR;
427
428	typedef struct VBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD
429	{
430	VBOXDISPIFESCAPE EscapeHdr;
431	VBOXWDDM_GETVBOXVIDEOCMCMD_HDR Hdr;
432	} VBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD, *PVBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD;
433
434	AssertCompile((sizeof (VBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD) & 7) == 0);
435	AssertCompile(RT_OFFSETOF(VBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD, EscapeHdr) == 0);
436
437	typedef struct VBOXDISPIFESCAPE_DBGPRINT
438	{
439	VBOXDISPIFESCAPE EscapeHdr;
440	/* null-terminated string to DbgPrint including \0 */
441	char aStringBuf[1];
442	} VBOXDISPIFESCAPE_DBGPRINT, *PVBOXDISPIFESCAPE_DBGPRINT;
443	AssertCompile(RT_OFFSETOF(VBOXDISPIFESCAPE_DBGPRINT, EscapeHdr) == 0);
444
445	typedef enum
446	{
447	VBOXDISPIFESCAPE_DBGDUMPBUF_TYPE_UNDEFINED = 0,
448	VBOXDISPIFESCAPE_DBGDUMPBUF_TYPE_D3DCAPS9 = 1,
449	VBOXDISPIFESCAPE_DBGDUMPBUF_TYPE_DUMMY32BIT = 0x7fffffff
450	} VBOXDISPIFESCAPE_DBGDUMPBUF_TYPE;
451
452	typedef struct VBOXDISPIFESCAPE_DBGDUMPBUF_FLAGS
453	{
454	union
455	{
456	struct
457	{
458	UINT WoW64 : 1;
459	UINT Reserved : 31; /* reserved */
460	};
461	UINT Value;
462	};
463	} VBOXDISPIFESCAPE_DBGDUMPBUF_FLAGS, *PVBOXDISPIFESCAPE_DBGDUMPBUF_FLAGS;
464
465	typedef struct VBOXDISPIFESCAPE_DBGDUMPBUF
466	{
467	VBOXDISPIFESCAPE EscapeHdr;
468	VBOXDISPIFESCAPE_DBGDUMPBUF_TYPE enmType;
469	VBOXDISPIFESCAPE_DBGDUMPBUF_FLAGS Flags;
470	char aBuf[1];
471	} VBOXDISPIFESCAPE_DBGDUMPBUF, *PVBOXDISPIFESCAPE_DBGDUMPBUF;
472	AssertCompile(RT_OFFSETOF(VBOXDISPIFESCAPE_DBGDUMPBUF, EscapeHdr) == 0);
473
474	typedef struct VBOXVIDEOCM_UM_ALLOC
475	{
476	VBOXDISP_KMHANDLE hAlloc;
477	uint32_t cbData;
478	uint64_t pvData;
479	uint64_t hSynch;
480	VBOXUHGSMI_BUFFER_TYPE_FLAGS fUhgsmiType;
481	} VBOXVIDEOCM_UM_ALLOC, *PVBOXVIDEOCM_UM_ALLOC;
482
483	typedef struct VBOXDISPIFESCAPE_SETALLOCHOSTID
484	{
485	VBOXDISPIFESCAPE EscapeHdr;
486	int32_t rc;
487	uint32_t hostID;
488	uint64_t hAlloc;
489
490	} VBOXDISPIFESCAPE_SETALLOCHOSTID, *PVBOXDISPIFESCAPE_SETALLOCHOSTID;
491
492	#ifdef VBOX_WITH_VMSVGA
493
494	#define VBOXWDDM_F_GA_CONTEXT_EXTENDED 0x00000001
495	#define VBOXWDDM_F_GA_CONTEXT_VGPU10 0x00000002
496
497	#define VBOXESC_GAGETCID 0xA0000002
498	#define VBOXESC_GAREGION 0xA0000003
499	#define VBOXESC_GAPRESENT 0xA0000004
500	#define VBOXESC_GASURFACEDEFINE 0xA0000005
501	#define VBOXESC_GASURFACEDESTROY 0xA0000006
502	#define VBOXESC_GASHAREDSID 0xA0000008
503	#define VBOXESC_GAFENCECREATE 0xA0000020
504	#define VBOXESC_GAFENCEQUERY 0xA0000021
505	#define VBOXESC_GAFENCEWAIT 0xA0000022
506	#define VBOXESC_GAFENCEUNREF 0xA0000023
507
508	/* Get Gallium context id (cid) of the WDDM context. */
509	typedef struct VBOXDISPIFESCAPE_GAGETCID
510	{
511	VBOXDISPIFESCAPE EscapeHdr;
512	uint32_t u32Cid;
513	} VBOXDISPIFESCAPE_GAGETCID;
514
515	/* Create or delete a Guest Memory Region (GMR). */
516	#define GA_REGION_CMD_CREATE 0
517	#define GA_REGION_CMD_DESTROY 1
518	typedef struct VBOXDISPIFESCAPE_GAREGION
519	{
520	VBOXDISPIFESCAPE EscapeHdr;
521	uint32_t u32Command;
522	uint32_t u32GmrId;
523	uint32_t u32NumPages;
524	uint32_t u32Reserved;
525	uint64_t u64UserAddress;
526	} VBOXDISPIFESCAPE_GAREGION;
527
528	/* Debug helper. Present the specified surface by copying to the guest screen VRAM. */
529	typedef struct VBOXDISPIFESCAPE_GAPRESENT
530	{
531	VBOXDISPIFESCAPE EscapeHdr;
532	uint32_t u32Sid;
533	uint32_t u32Width;
534	uint32_t u32Height;
535	} VBOXDISPIFESCAPE_GAPRESENT;
536
537	/* Create a host surface. */
538	typedef struct VBOXDISPIFESCAPE_GASURFACEDEFINE
539	{
540	VBOXDISPIFESCAPE EscapeHdr;
541	uint32_t u32Sid; /* Returned surface id. */
542	uint32_t cbReq; /* Size of data after cSizes field. */
543	uint32_t cSizes; /* Number of GASURFSIZE structures. */
544	/* GASURFCREATE */
545	/* GASURFSIZE[cSizes] */
546	} VBOXDISPIFESCAPE_GASURFACEDEFINE;
547
548	/* Delete a host surface. */
549	typedef struct VBOXDISPIFESCAPE_GASURFACEDESTROY
550	{
551	VBOXDISPIFESCAPE EscapeHdr;
552	uint32_t u32Sid;
553	} VBOXDISPIFESCAPE_GASURFACEDESTROY;
554
555	/* Inform the miniport that 'u32Sid' actually maps to 'u32SharedSid'.
556	* If 'u32SharedSid' is ~0, then remove the mapping.
557	*/
558	typedef struct VBOXDISPIFESCAPE_GASHAREDSID
559	{
560	VBOXDISPIFESCAPE EscapeHdr;
561	uint32_t u32Sid;
562	uint32_t u32SharedSid;
563	} VBOXDISPIFESCAPE_GASHAREDSID;
564
565	/* Create a user mode fence object. */
566	typedef struct VBOXDISPIFESCAPE_GAFENCECREATE
567	{
568	VBOXDISPIFESCAPE EscapeHdr;
569
570	/* IN: The miniport's handle of the fence.
571	* Assigned by the miniport. Not DXGK fence id!
572	*/
573	uint32_t u32FenceHandle;
574	} VBOXDISPIFESCAPE_GAFENCECREATE;
575
576	/* Query a user mode fence object state. */
577	#define GA_FENCE_STATUS_NULL 0 /* Fence not found */
578	#define GA_FENCE_STATUS_IDLE 1
579	#define GA_FENCE_STATUS_SUBMITTED 2
580	#define GA_FENCE_STATUS_SIGNALED 3
581	typedef struct VBOXDISPIFESCAPE_GAFENCEQUERY
582	{
583	VBOXDISPIFESCAPE EscapeHdr;
584
585	/* IN: The miniport's handle of the fence.
586	* Assigned by the miniport. Not DXGK fence id!
587	*/
588	uint32_t u32FenceHandle;
589
590	/* OUT: The miniport's sequence number associated with the command buffer.
591	*/
592	uint32_t u32SubmittedSeqNo;
593
594	/* OUT: The miniport's sequence number associated with the last command buffer completed on host.
595	*/
596	uint32_t u32ProcessedSeqNo;
597
598	/* OUT: GA_FENCE_STATUS_. /
599	uint32_t u32FenceStatus;
600	} VBOXDISPIFESCAPE_GAFENCEQUERY;
601
602	/* Wait on a user mode fence object. */
603	typedef struct VBOXDISPIFESCAPE_GAFENCEWAIT
604	{
605	VBOXDISPIFESCAPE EscapeHdr;
606
607	/* IN: The miniport's handle of the fence.
608	* Assigned by the miniport. Not DXGK fence id!
609	*/
610	uint32_t u32FenceHandle;
611
612	/* IN: Timeout in microseconds.
613	*/
614	uint32_t u32TimeoutUS;
615	} VBOXDISPIFESCAPE_GAFENCEWAIT;
616
617	/* Delete a user mode fence object. */
618	typedef struct VBOXDISPIFESCAPE_GAFENCEUNREF
619	{
620	VBOXDISPIFESCAPE EscapeHdr;
621
622	/* IN: The miniport's handle of the fence.
623	* Assigned by the miniport. Not DXGK fence id!
624	*/
625	uint32_t u32FenceHandle;
626	} VBOXDISPIFESCAPE_GAFENCEUNREF;
627
628	#include <VBoxGaHWInfo.h>
629	#endif
630
631	#define VBOXWDDM_QAI_CAP_3D 0x00000001 /* 3D is enabled in the VM settings. */
632	#define VBOXWDDM_QAI_CAP_DXVA 0x00000002 /* DXVA is not disabled in the guest registry. */
633	#define VBOXWDDM_QAI_CAP_DXVAHD 0x00000004 /* DXVA-HD is not disabled in the guest registry. */
634	#define VBOXWDDM_QAI_CAP_WIN7 0x00000008 /* User mode driver can report D3D_UMD_INTERFACE_VERSION_WIN7. */
635
636	/* D3DDDICB_QUERYADAPTERINFO::pPrivateDriverData */
637	typedef struct VBOXWDDM_QAI
638	{
639	uint32_t u32Version; /* VBOXVIDEOIF_VERSION */
640	uint32_t u32Reserved; /* Must be 0. */
641	VBOXVIDEO_HWTYPE enmHwType; /* Hardware type. Determines what kind of data is returned. */
642	uint32_t u32AdapterCaps; /* VBOXWDDM_QAI_CAP_* */
643	uint32_t cInfos; /* Number of initialized elements in aInfos (equal to number of guest
644	* displays). 0 if VBOX_WITH_VIDEOHWACCEL is not defined. */
645	VBOXVHWA_INFO aInfos[VBOX_VIDEO_MAX_SCREENS]; /* cInfos elements are initialized. */
646	union
647	{
648	struct
649	{
650	/* VBOXVIDEO_HWTYPE_VBOX */
651	uint32_t u32VBox3DCaps; /* CR_VBOX_CAP_* */
652	} vbox;
653	#if defined(VBOX_WITH_VMSVGA)
654	struct
655	{
656	/* VBOXVIDEO_HWTYPE_VMSVGA */
657	VBOXGAHWINFO HWInfo;
658	} vmsvga;
659	#endif
660	} u;
661	} VBOXWDDM_QAI;
662
663	/** Convert a given FourCC code to a D3DDDIFORMAT enum. */
664	#define VBOXWDDM_D3DDDIFORMAT_FROM_FOURCC(_a, _b, _c, _d) \
665	((D3DDDIFORMAT)MAKEFOURCC(_a, _b, _c, _d))
666
667	/* submit cmd func */
668	DECLINLINE(D3DDDIFORMAT) vboxWddmFmtNoAlphaFormat(D3DDDIFORMAT enmFormat)
669	{
670	switch (enmFormat)
671	{
672	case D3DDDIFMT_A8R8G8B8:
673	return D3DDDIFMT_X8R8G8B8;
674	case D3DDDIFMT_A1R5G5B5:
675	return D3DDDIFMT_X1R5G5B5;
676	case D3DDDIFMT_A4R4G4B4:
677	return D3DDDIFMT_X4R4G4B4;
678	case D3DDDIFMT_A8B8G8R8:
679	return D3DDDIFMT_X8B8G8R8;
680	default:
681	return enmFormat;
682	}
683	}
684
685	/* tooling */
686	DECLINLINE(UINT) vboxWddmCalcBitsPerPixel(D3DDDIFORMAT enmFormat)
687	{
688	#ifdef _MSC_VER
689	# pragma warning(push)
690	# pragma warning(disable:4063) /* VBOXWDDM_D3DDDIFORMAT_FROM_FOURCC('Y', 'V', '1', '2'): isn't part of the enum */
691	#endif
692	switch (enmFormat)
693	{
694	case D3DDDIFMT_R8G8B8:
695	return 24;
696	case D3DDDIFMT_A8R8G8B8:
697	case D3DDDIFMT_X8R8G8B8:
698	return 32;
699	case D3DDDIFMT_R5G6B5:
700	case D3DDDIFMT_X1R5G5B5:
701	case D3DDDIFMT_A1R5G5B5:
702	case D3DDDIFMT_A4R4G4B4:
703	return 16;
704	case D3DDDIFMT_R3G3B2:
705	case D3DDDIFMT_A8:
706	return 8;
707	case D3DDDIFMT_A8R3G3B2:
708	case D3DDDIFMT_X4R4G4B4:
709	return 16;
710	case D3DDDIFMT_A2B10G10R10:
711	case D3DDDIFMT_A8B8G8R8:
712	case D3DDDIFMT_X8B8G8R8:
713	case D3DDDIFMT_G16R16:
714	case D3DDDIFMT_A2R10G10B10:
715	return 32;
716	case D3DDDIFMT_A16B16G16R16:
717	case D3DDDIFMT_A16B16G16R16F:
718	return 64;
719	case D3DDDIFMT_A32B32G32R32F:
720	return 128;
721	case D3DDDIFMT_A8P8:
722	return 16;
723	case D3DDDIFMT_P8:
724	case D3DDDIFMT_L8:
725	return 8;
726	case D3DDDIFMT_L16:
727	case D3DDDIFMT_A8L8:
728	return 16;
729	case D3DDDIFMT_A4L4:
730	return 8;
731	case D3DDDIFMT_V8U8:
732	case D3DDDIFMT_L6V5U5:
733	return 16;
734	case D3DDDIFMT_X8L8V8U8:
735	case D3DDDIFMT_Q8W8V8U8:
736	case D3DDDIFMT_V16U16:
737	case D3DDDIFMT_W11V11U10:
738	case D3DDDIFMT_A2W10V10U10:
739	return 32;
740	case D3DDDIFMT_D16_LOCKABLE:
741	case D3DDDIFMT_D16:
742	case D3DDDIFMT_D15S1:
743	return 16;
744	case D3DDDIFMT_D32:
745	case D3DDDIFMT_D24S8:
746	case D3DDDIFMT_D24X8:
747	case D3DDDIFMT_D24X4S4:
748	case D3DDDIFMT_D24FS8:
749	case D3DDDIFMT_D32_LOCKABLE:
750	case D3DDDIFMT_D32F_LOCKABLE:
751	return 32;
752	case D3DDDIFMT_S8_LOCKABLE:
753	return 8;
754	case D3DDDIFMT_DXT1:
755	return 4;
756	case D3DDDIFMT_DXT2:
757	case D3DDDIFMT_DXT3:
758	case D3DDDIFMT_DXT4:
759	case D3DDDIFMT_DXT5:
760	case D3DDDIFMT_VERTEXDATA:
761	case D3DDDIFMT_INDEX16: /* <- yes, dx runtime treats it as such */
762	return 8;
763	case D3DDDIFMT_INDEX32:
764	return 8;
765	case D3DDDIFMT_R32F:
766	return 32;
767	case D3DDDIFMT_G32R32F:
768	return 64;
769	case D3DDDIFMT_R16F:
770	return 16;
771	case D3DDDIFMT_G16R16F:
772	return 32;
773	case D3DDDIFMT_YUY2: /* 4 bytes per 2 pixels. */
774	case VBOXWDDM_D3DDDIFORMAT_FROM_FOURCC('Y', 'V', '1', '2'):
775	return 16;
776	default:
777	AssertBreakpoint();
778	return 0;
779	}
780	#ifdef _MSC_VER
781	# pragma warning(pop)
782	#endif
783	}
784
785	DECLINLINE(uint32_t) vboxWddmFormatToFourcc(D3DDDIFORMAT enmFormat)
786	{
787	uint32_t uFormat = (uint32_t)enmFormat;
788	/* assume that in case both four bytes are non-zero, this is a fourcc */
789	if ((uFormat & 0xff000000)
790	&& (uFormat & 0x00ff0000)
791	&& (uFormat & 0x0000ff00)
792	&& (uFormat & 0x000000ff)
793	)
794	return uFormat;
795	return 0;
796	}
797
798	#define VBOXWDDM_ROUNDBOUND(_v, _b) (((_v) + ((_b) - 1)) & ~((_b) - 1))
799
800	DECLINLINE(UINT) vboxWddmCalcOffXru(UINT w, D3DDDIFORMAT enmFormat)
801	{
802	switch (enmFormat)
803	{
804	/* pitch for the DXT* (aka compressed) formats is the size in bytes of blocks that fill in an image width
805	* i.e. each block decompressed into 4 x 4 pixels, so we have ((Width + 3) / 4) blocks for Width.
806	* then each block has 64 bits (8 bytes) for DXT1 and 64+64 bits (16 bytes) for DXT2-DXT5, so.. : */
807	case D3DDDIFMT_DXT1:
808	{
809	UINT Pitch = (w + 3) / 4; /* <- pitch size in blocks */
810	Pitch = 8; / <- pitch size in bytes */
811	return Pitch;
812	}
813	case D3DDDIFMT_DXT2:
814	case D3DDDIFMT_DXT3:
815	case D3DDDIFMT_DXT4:
816	case D3DDDIFMT_DXT5:
817	{
818	UINT Pitch = (w + 3) / 4; /* <- pitch size in blocks */
819	Pitch = 16; / <- pitch size in bytes */
820	return Pitch;
821	}
822	default:
823	{
824	/* the default is just to calculate the pitch from bpp */
825	UINT bpp = vboxWddmCalcBitsPerPixel(enmFormat);
826	UINT Pitch = bpp * w;
827	/* pitch is now in bits, translate in bytes */
828	return VBOXWDDM_ROUNDBOUND(Pitch, 8) >> 3;
829	}
830	}
831	}
832
833	DECLINLINE(UINT) vboxWddmCalcOffXrd(UINT w, D3DDDIFORMAT enmFormat)
834	{
835	switch (enmFormat)
836	{
837	/* pitch for the DXT* (aka compressed) formats is the size in bytes of blocks that fill in an image width
838	* i.e. each block decompressed into 4 x 4 pixels, so we have ((Width + 3) / 4) blocks for Width.
839	* then each block has 64 bits (8 bytes) for DXT1 and 64+64 bits (16 bytes) for DXT2-DXT5, so.. : */
840	case D3DDDIFMT_DXT1:
841	{
842	UINT Pitch = w / 4; /* <- pitch size in blocks */
843	Pitch = 8; / <- pitch size in bytes */
844	return Pitch;
845	}
846	case D3DDDIFMT_DXT2:
847	case D3DDDIFMT_DXT3:
848	case D3DDDIFMT_DXT4:
849	case D3DDDIFMT_DXT5:
850	{
851	UINT Pitch = w / 4; /* <- pitch size in blocks */
852	Pitch = 16; / <- pitch size in bytes */
853	return Pitch;
854	}
855	default:
856	{
857	/* the default is just to calculate the pitch from bpp */
858	UINT bpp = vboxWddmCalcBitsPerPixel(enmFormat);
859	UINT Pitch = bpp * w;
860	/* pitch is now in bits, translate in bytes */
861	return Pitch >> 3;
862	}
863	}
864	}
865
866	DECLINLINE(UINT) vboxWddmCalcHightPacking(D3DDDIFORMAT enmFormat)
867	{
868	switch (enmFormat)
869	{
870	/* for the DXT* (aka compressed) formats each block is decompressed into 4 x 4 pixels,
871	* so packing is 4
872	*/
873	case D3DDDIFMT_DXT1:
874	case D3DDDIFMT_DXT2:
875	case D3DDDIFMT_DXT3:
876	case D3DDDIFMT_DXT4:
877	case D3DDDIFMT_DXT5:
878	return 4;
879	default:
880	return 1;
881	}
882	}
883
884	DECLINLINE(UINT) vboxWddmCalcOffYru(UINT height, D3DDDIFORMAT enmFormat)
885	{
886	UINT packing = vboxWddmCalcHightPacking(enmFormat);
887	/* round it up */
888	return (height + packing - 1) / packing;
889	}
890
891	DECLINLINE(UINT) vboxWddmCalcOffYrd(UINT height, D3DDDIFORMAT enmFormat)
892	{
893	UINT packing = vboxWddmCalcHightPacking(enmFormat);
894	/* round it up */
895	return height / packing;
896	}
897
898	DECLINLINE(UINT) vboxWddmCalcPitch(UINT w, D3DDDIFORMAT enmFormat)
899	{
900	return vboxWddmCalcOffXru(w, enmFormat);
901	}
902
903	DECLINLINE(UINT) vboxWddmCalcWidthForPitch(UINT Pitch, D3DDDIFORMAT enmFormat)
904	{
905	switch (enmFormat)
906	{
907	/* pitch for the DXT* (aka compressed) formats is the size in bytes of blocks that fill in an image width
908	* i.e. each block decompressed into 4 x 4 pixels, so we have ((Width + 3) / 4) blocks for Width.
909	* then each block has 64 bits (8 bytes) for DXT1 and 64+64 bits (16 bytes) for DXT2-DXT5, so.. : */
910	case D3DDDIFMT_DXT1:
911	{
912	return (Pitch / 8) * 4;
913	}
914	case D3DDDIFMT_DXT2:
915	case D3DDDIFMT_DXT3:
916	case D3DDDIFMT_DXT4:
917	case D3DDDIFMT_DXT5:
918	{
919	return (Pitch / 16) * 4;;
920	}
921	default:
922	{
923	/* the default is just to calculate it from bpp */
924	UINT bpp = vboxWddmCalcBitsPerPixel(enmFormat);
925	return (Pitch << 3) / bpp;
926	}
927	}
928	}
929
930	DECLINLINE(UINT) vboxWddmCalcNumRows(UINT top, UINT bottom, D3DDDIFORMAT enmFormat)
931	{
932	Assert(bottom > top);
933	top = top ? vboxWddmCalcOffYrd(top, enmFormat) : 0; /* <- just to optimize it a bit */
934	bottom = vboxWddmCalcOffYru(bottom, enmFormat);
935	return bottom - top;
936	}
937
938	DECLINLINE(UINT) vboxWddmCalcRowSize(UINT left, UINT right, D3DDDIFORMAT enmFormat)
939	{
940	Assert(right > left);
941	left = left ? vboxWddmCalcOffXrd(left, enmFormat) : 0; /* <- just to optimize it a bit */
942	right = vboxWddmCalcOffXru(right, enmFormat);
943	return right - left;
944	}
945
946	DECLINLINE(UINT) vboxWddmCalcSize(UINT pitch, UINT height, D3DDDIFORMAT enmFormat)
947	{
948	UINT cRows = vboxWddmCalcNumRows(0, height, enmFormat);
949	return pitch * cRows;
950	}
951
952	DECLINLINE(UINT) vboxWddmCalcOffXYrd(UINT x, UINT y, UINT pitch, D3DDDIFORMAT enmFormat)
953	{
954	UINT offY = 0;
955	if (y)
956	offY = vboxWddmCalcSize(pitch, y, enmFormat);
957
958	return offY + vboxWddmCalcOffXrd(x, enmFormat);
959	}
960
961	#if defined(VBOX_WITH_VMSVGA3D_DX)
962	#include <dxgiformat.h>
963	DECLINLINE(UINT) vboxWddmCalcBitsPerPixelDXGI(DXGI_FORMAT enmFormat)
964	{
965	switch (enmFormat)
966	{
967	case DXGI_FORMAT_UNKNOWN:
968	return 8;
969	case DXGI_FORMAT_R32G32B32A32_TYPELESS:
970	case DXGI_FORMAT_R32G32B32A32_FLOAT:
971	case DXGI_FORMAT_R32G32B32A32_UINT:
972	case DXGI_FORMAT_R32G32B32A32_SINT:
973	return 128;
974	case DXGI_FORMAT_R32G32B32_TYPELESS:
975	case DXGI_FORMAT_R32G32B32_FLOAT:
976	case DXGI_FORMAT_R32G32B32_UINT:
977	case DXGI_FORMAT_R32G32B32_SINT:
978	return 96;
979	case DXGI_FORMAT_R16G16B16A16_TYPELESS:
980	case DXGI_FORMAT_R16G16B16A16_FLOAT:
981	case DXGI_FORMAT_R16G16B16A16_UNORM:
982	case DXGI_FORMAT_R16G16B16A16_UINT:
983	case DXGI_FORMAT_R16G16B16A16_SNORM:
984	case DXGI_FORMAT_R16G16B16A16_SINT:
985	case DXGI_FORMAT_R32G32_TYPELESS:
986	case DXGI_FORMAT_R32G32_FLOAT:
987	case DXGI_FORMAT_R32G32_UINT:
988	case DXGI_FORMAT_R32G32_SINT:
989	return 64;
990	case DXGI_FORMAT_R32G8X24_TYPELESS:
991	case DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
992	case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS:
993	case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT:
994	return 64;
995	case DXGI_FORMAT_R10G10B10A2_TYPELESS:
996	case DXGI_FORMAT_R10G10B10A2_UNORM:
997	case DXGI_FORMAT_R10G10B10A2_UINT:
998	return 32;
999	case DXGI_FORMAT_R11G11B10_FLOAT:
1000	return 32;
1001	case DXGI_FORMAT_R8G8B8A8_TYPELESS:
1002	case DXGI_FORMAT_R8G8B8A8_UNORM:
1003	case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
1004	case DXGI_FORMAT_R8G8B8A8_UINT:
1005	case DXGI_FORMAT_R8G8B8A8_SNORM:
1006	case DXGI_FORMAT_R8G8B8A8_SINT:
1007	return 32;
1008	case DXGI_FORMAT_R16G16_TYPELESS:
1009	case DXGI_FORMAT_R16G16_FLOAT:
1010	case DXGI_FORMAT_R16G16_UNORM:
1011	case DXGI_FORMAT_R16G16_UINT:
1012	case DXGI_FORMAT_R16G16_SNORM:
1013	case DXGI_FORMAT_R16G16_SINT:
1014	return 32;
1015	case DXGI_FORMAT_R32_TYPELESS:
1016	case DXGI_FORMAT_D32_FLOAT:
1017	case DXGI_FORMAT_R32_FLOAT:
1018	case DXGI_FORMAT_R32_UINT:
1019	case DXGI_FORMAT_R32_SINT:
1020	case DXGI_FORMAT_R24G8_TYPELESS:
1021	case DXGI_FORMAT_D24_UNORM_S8_UINT:
1022	case DXGI_FORMAT_R24_UNORM_X8_TYPELESS:
1023	case DXGI_FORMAT_X24_TYPELESS_G8_UINT:
1024	return 32;
1025	case DXGI_FORMAT_R8G8_TYPELESS:
1026	case DXGI_FORMAT_R8G8_UNORM:
1027	case DXGI_FORMAT_R8G8_UINT:
1028	case DXGI_FORMAT_R8G8_SNORM:
1029	case DXGI_FORMAT_R8G8_SINT:
1030	case DXGI_FORMAT_R16_TYPELESS:
1031	case DXGI_FORMAT_R16_FLOAT:
1032	case DXGI_FORMAT_D16_UNORM:
1033	case DXGI_FORMAT_R16_UNORM:
1034	case DXGI_FORMAT_R16_UINT:
1035	case DXGI_FORMAT_R16_SNORM:
1036	case DXGI_FORMAT_R16_SINT:
1037	return 16;
1038	case DXGI_FORMAT_R8_TYPELESS:
1039	case DXGI_FORMAT_R8_UNORM:
1040	case DXGI_FORMAT_R8_UINT:
1041	case DXGI_FORMAT_R8_SNORM:
1042	case DXGI_FORMAT_R8_SINT:
1043	case DXGI_FORMAT_A8_UNORM:
1044	return 8;
1045	case DXGI_FORMAT_R1_UNORM:
1046	return 1;
1047	case DXGI_FORMAT_R9G9B9E5_SHAREDEXP:
1048	case DXGI_FORMAT_R8G8_B8G8_UNORM:
1049	case DXGI_FORMAT_G8R8_G8B8_UNORM:
1050	return 32;
1051	case DXGI_FORMAT_BC1_TYPELESS:
1052	case DXGI_FORMAT_BC1_UNORM:
1053	case DXGI_FORMAT_BC1_UNORM_SRGB:
1054	return 4;
1055	case DXGI_FORMAT_BC2_TYPELESS:
1056	case DXGI_FORMAT_BC2_UNORM:
1057	case DXGI_FORMAT_BC2_UNORM_SRGB:
1058	case DXGI_FORMAT_BC3_TYPELESS:
1059	case DXGI_FORMAT_BC3_UNORM:
1060	case DXGI_FORMAT_BC3_UNORM_SRGB:
1061	return 8;
1062	case DXGI_FORMAT_BC4_TYPELESS:
1063	case DXGI_FORMAT_BC4_UNORM:
1064	case DXGI_FORMAT_BC4_SNORM:
1065	return 4;
1066	case DXGI_FORMAT_BC5_TYPELESS:
1067	case DXGI_FORMAT_BC5_UNORM:
1068	case DXGI_FORMAT_BC5_SNORM:
1069	return 8;
1070	case DXGI_FORMAT_B5G6R5_UNORM:
1071	case DXGI_FORMAT_B5G5R5A1_UNORM:
1072	return 16;
1073	case DXGI_FORMAT_B8G8R8A8_UNORM:
1074	case DXGI_FORMAT_B8G8R8X8_UNORM:
1075	case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM:
1076	case DXGI_FORMAT_B8G8R8A8_TYPELESS:
1077	case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
1078	case DXGI_FORMAT_B8G8R8X8_TYPELESS:
1079	case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
1080	return 32;
1081	case DXGI_FORMAT_BC6H_TYPELESS:
1082	case DXGI_FORMAT_BC6H_UF16:
1083	case DXGI_FORMAT_BC6H_SF16:
1084	case DXGI_FORMAT_BC7_TYPELESS:
1085	case DXGI_FORMAT_BC7_UNORM:
1086	case DXGI_FORMAT_BC7_UNORM_SRGB:
1087	return 8;
1088	case DXGI_FORMAT_AYUV:
1089	case DXGI_FORMAT_Y410:
1090	return 32;
1091	case DXGI_FORMAT_Y416:
1092	return 64;
1093	case DXGI_FORMAT_NV12:
1094	return 12;
1095	case DXGI_FORMAT_P010:
1096	case DXGI_FORMAT_P016:
1097	return 24;
1098	case DXGI_FORMAT_420_OPAQUE:
1099	return 12;
1100	case DXGI_FORMAT_YUY2:
1101	return 32;
1102	case DXGI_FORMAT_Y210:
1103	case DXGI_FORMAT_Y216:
1104	return 64;
1105	case DXGI_FORMAT_NV11:
1106	return 12;
1107	case DXGI_FORMAT_AI44:
1108	case DXGI_FORMAT_IA44:
1109	case DXGI_FORMAT_P8:
1110	return 8;
1111	case DXGI_FORMAT_A8P8:
1112	case DXGI_FORMAT_B4G4R4A4_UNORM:
1113	case DXGI_FORMAT_P208:
1114	case DXGI_FORMAT_V208:
1115	return 16;
1116	case DXGI_FORMAT_V408:
1117	return 24;
1118	default:
1119	AssertBreakpoint();
1120	return 0;
1121	}
1122	}
1123	#endif /* VBOX_WITH_VMSVGA3D_DX */
1124
1125	#define VBOXWDDM_ARRAY_MAXELEMENTSU32(_t) ((uint32_t)((UINT32_MAX) / sizeof (_t)))
1126	#define VBOXWDDM_TRAILARRAY_MAXELEMENTSU32(_t, _af) ((uint32_t)(((~(0UL)) - (uint32_t)RT_OFFSETOF(_t, _af[0])) / RT_SIZEOFMEMB(_t, _af[0])))
1127
1128	#endif /* !GA_INCLUDED_SRC_WINNT_Graphics_Video_common_wddm_VBoxMPIf_h */

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

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Video/common/wddm/VBoxMPIf.h@ 94990

Download in other formats: