VirtualBox

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

Last change on this file since 68859 was 68633, checked in by vboxsync, 7 years ago

Reduce number of VBoxGuest.h includes.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 24.6 KB
Line 
1/* $Id: VBoxMPIf.h 68633 2017-09-05 11:56:00Z 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-2016 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 ___VBoxMPIf_h___
26#define ___VBoxMPIf_h___
27
28#include <VBoxVideo.h>
29#include "../../../../include/VBoxDisplay.h"
30#include "../VBoxVideoTools.h"
31#include <VBoxUhgsmi.h>
32#include <VBox/VBoxGuestCoreTypes.h> /* for VBGLIOCHGCMCALL */
33
34/* One would increase this whenever definitions in this file are changed */
35#define VBOXVIDEOIF_VERSION 20
36
37#define VBOXWDDM_NODE_ID_SYSTEM 0
38#define VBOXWDDM_NODE_ID_3D (VBOXWDDM_NODE_ID_SYSTEM)
39#define VBOXWDDM_NODE_ID_3D_KMT (VBOXWDDM_NODE_ID_3D)
40#define VBOXWDDM_NODE_ID_2D_VIDEO (VBOXWDDM_NODE_ID_3D_KMT + 1)
41#define VBOXWDDM_NUM_NODES (VBOXWDDM_NODE_ID_2D_VIDEO + 1)
42
43#define VBOXWDDM_ENGINE_ID_SYSTEM 0
44#if (VBOXWDDM_NODE_ID_3D == VBOXWDDM_NODE_ID_SYSTEM)
45# define VBOXWDDM_ENGINE_ID_3D (VBOXWDDM_ENGINE_ID_SYSTEM + 1)
46#else
47# define VBOXWDDM_ENGINE_ID_3D 0
48#endif
49#if (VBOXWDDM_NODE_ID_3D_KMT == VBOXWDDM_NODE_ID_3D)
50# define VBOXWDDM_ENGINE_ID_3D_KMT VBOXWDDM_ENGINE_ID_3D
51#else
52# define VBOXWDDM_ENGINE_ID_3D_KMT 0
53#endif
54#if (VBOXWDDM_NODE_ID_2D_VIDEO == VBOXWDDM_NODE_ID_3D)
55# define VBOXWDDM_ENGINE_ID_2D_VIDEO VBOXWDDM_ENGINE_ID_3D
56#else
57# define VBOXWDDM_ENGINE_ID_2D_VIDEO 0
58#endif
59
60
61/* create allocation func */
62typedef enum
63{
64 VBOXWDDM_ALLOC_TYPE_UNEFINED = 0,
65 VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE,
66 VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE,
67 VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE,
68 /* this one is win 7-specific and hence unused for now */
69 VBOXWDDM_ALLOC_TYPE_STD_GDISURFACE
70 /* custom allocation types requested from user-mode d3d module will go here */
71 , VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC
72 , VBOXWDDM_ALLOC_TYPE_UMD_HGSMI_BUFFER
73} VBOXWDDM_ALLOC_TYPE;
74
75/* usage */
76typedef enum
77{
78 VBOXWDDM_ALLOCUSAGE_TYPE_UNEFINED = 0,
79 /* set for the allocation being primary */
80 VBOXWDDM_ALLOCUSAGE_TYPE_PRIMARY,
81} VBOXWDDM_ALLOCUSAGE_TYPE;
82
83typedef struct VBOXWDDM_SURFACE_DESC
84{
85 UINT width;
86 UINT height;
87 D3DDDIFORMAT format;
88 UINT bpp;
89 UINT pitch;
90 UINT depth;
91 UINT slicePitch;
92 UINT d3dWidth;
93 UINT cbSize;
94 D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
95 D3DDDI_RATIONAL RefreshRate;
96} VBOXWDDM_SURFACE_DESC, *PVBOXWDDM_SURFACE_DESC;
97
98typedef struct VBOXWDDM_ALLOCINFO
99{
100 VBOXWDDM_ALLOC_TYPE enmType;
101 union
102 {
103 struct
104 {
105 D3DDDI_RESOURCEFLAGS fFlags;
106 /* id used to identify the allocation on the host */
107 uint32_t hostID;
108 uint64_t hSharedHandle;
109 VBOXWDDM_SURFACE_DESC SurfDesc;
110 };
111
112 struct
113 {
114 uint32_t cbBuffer;
115 VBOXUHGSMI_BUFFER_TYPE_FLAGS fUhgsmiType;
116 };
117 };
118} VBOXWDDM_ALLOCINFO, *PVBOXWDDM_ALLOCINFO;
119
120typedef struct VBOXWDDM_RC_DESC
121{
122 D3DDDI_RESOURCEFLAGS fFlags;
123 D3DDDIFORMAT enmFormat;
124 D3DDDI_POOL enmPool;
125 D3DDDIMULTISAMPLE_TYPE enmMultisampleType;
126 UINT MultisampleQuality;
127 UINT MipLevels;
128 UINT Fvf;
129 D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
130 D3DDDI_RATIONAL RefreshRate;
131 D3DDDI_ROTATION enmRotation;
132} VBOXWDDM_RC_DESC, *PVBOXWDDM_RC_DESC;
133
134typedef struct VBOXWDDMDISP_RESOURCE_FLAGS
135{
136 union
137 {
138 struct
139 {
140 UINT Opened : 1; /* this resource is OpenResource'd rather than CreateResource'd */
141 UINT Generic : 1; /* identifies this is a resource created with CreateResource, the VBOXWDDMDISP_RESOURCE::fRcFlags is valid */
142 UINT KmResource : 1; /* this resource has underlying km resource */
143 UINT Reserved : 29; /* reserved */
144 };
145 UINT Value;
146 };
147} VBOXWDDMDISP_RESOURCE_FLAGS, *PVBOXWDDMDISP_RESOURCE_FLAGS;
148
149typedef struct VBOXWDDM_RCINFO
150{
151 VBOXWDDMDISP_RESOURCE_FLAGS fFlags;
152 VBOXWDDM_RC_DESC RcDesc;
153 uint32_t cAllocInfos;
154// VBOXWDDM_ALLOCINFO aAllocInfos[1];
155} VBOXWDDM_RCINFO, *PVBOXWDDM_RCINFO;
156
157typedef struct VBOXWDDM_DMA_PRIVATEDATA_FLAFS
158{
159 union
160 {
161 struct
162 {
163 UINT bCmdInDmaBuffer : 1;
164 UINT bReserved : 31;
165 };
166 uint32_t Value;
167 };
168} VBOXWDDM_DMA_PRIVATEDATA_FLAFS, *PVBOXWDDM_DMA_PRIVATEDATA_FLAFS;
169
170typedef struct VBOXWDDM_DMA_PRIVATEDATA_BASEHDR
171{
172 VBOXVDMACMD_TYPE enmCmd;
173 union
174 {
175 VBOXWDDM_DMA_PRIVATEDATA_FLAFS fFlags;
176 uint32_t u32CmdReserved;
177 };
178} VBOXWDDM_DMA_PRIVATEDATA_BASEHDR, *PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR;
179
180typedef struct VBOXWDDM_UHGSMI_BUFFER_UI_SUBMIT_INFO
181{
182 uint32_t offData;
183 uint32_t cbData;
184} VBOXWDDM_UHGSMI_BUFFER_UI_SUBMIT_INFO, *PVBOXWDDM_UHGSMI_BUFFER_UI_SUBMIT_INFO;
185
186typedef struct VBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD
187{
188 VBOXWDDM_DMA_PRIVATEDATA_BASEHDR Base;
189 VBOXWDDM_UHGSMI_BUFFER_UI_SUBMIT_INFO aBufInfos[1];
190} VBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD, *PVBOXWDDM_DMA_PRIVATEDATA_UM_CHROMIUM_CMD;
191
192
193#define VBOXVHWA_F_ENABLED 0x00000001
194#define VBOXVHWA_F_CKEY_DST 0x00000002
195#define VBOXVHWA_F_CKEY_SRC 0x00000004
196
197#define VBOXVHWA_MAX_FORMATS 8
198
199typedef struct VBOXVHWA_INFO
200{
201 uint32_t fFlags;
202 uint32_t cOverlaysSupported;
203 uint32_t cFormats;
204 D3DDDIFORMAT aFormats[VBOXVHWA_MAX_FORMATS];
205} VBOXVHWA_INFO;
206
207#define VBOXWDDM_OVERLAY_F_CKEY_DST 0x00000001
208#define VBOXWDDM_OVERLAY_F_CKEY_DSTRANGE 0x00000002
209#define VBOXWDDM_OVERLAY_F_CKEY_SRC 0x00000004
210#define VBOXWDDM_OVERLAY_F_CKEY_SRCRANGE 0x00000008
211#define VBOXWDDM_OVERLAY_F_BOB 0x00000010
212#define VBOXWDDM_OVERLAY_F_INTERLEAVED 0x00000020
213#define VBOXWDDM_OVERLAY_F_MIRROR_LR 0x00000040
214#define VBOXWDDM_OVERLAY_F_MIRROR_UD 0x00000080
215#define VBOXWDDM_OVERLAY_F_DEINTERLACED 0x00000100
216
217typedef struct VBOXWDDM_OVERLAY_DESC
218{
219 uint32_t fFlags;
220 UINT DstColorKeyLow;
221 UINT DstColorKeyHigh;
222 UINT SrcColorKeyLow;
223 UINT SrcColorKeyHigh;
224} VBOXWDDM_OVERLAY_DESC, *PVBOXWDDM_OVERLAY_DESC;
225
226typedef struct VBOXWDDM_OVERLAY_INFO
227{
228 VBOXWDDM_OVERLAY_DESC OverlayDesc;
229 VBOXWDDM_DIRTYREGION DirtyRegion; /* <- the dirty region of the overlay surface */
230} VBOXWDDM_OVERLAY_INFO, *PVBOXWDDM_OVERLAY_INFO;
231
232typedef struct VBOXWDDM_OVERLAYFLIP_INFO
233{
234 VBOXWDDM_DIRTYREGION DirtyRegion; /* <- the dirty region of the overlay surface */
235} VBOXWDDM_OVERLAYFLIP_INFO, *PVBOXWDDM_OVERLAYFLIP_INFO;
236
237
238typedef enum
239{
240 VBOXWDDM_CONTEXT_TYPE_UNDEFINED = 0,
241 /* system-created context (for GDI rendering) */
242 VBOXWDDM_CONTEXT_TYPE_SYSTEM,
243 /* context created by the D3D User-mode driver when crogl IS available */
244 VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D,
245 /* context created by the D3D User-mode driver when crogl is NOT available or for ddraw overlay acceleration */
246 VBOXWDDM_CONTEXT_TYPE_CUSTOM_2D,
247 /* contexts created by the cromium HGSMI transport for HGSMI commands submission */
248 VBOXWDDM_CONTEXT_TYPE_CUSTOM_UHGSMI_3D,
249 VBOXWDDM_CONTEXT_TYPE_CUSTOM_UHGSMI_GL,
250 /* context created by the kernel->user communication mechanism for visible rects reporting, etc. */
251 VBOXWDDM_CONTEXT_TYPE_CUSTOM_SESSION,
252 /* context created by VBoxTray to handle resize operations */
253 VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_RESIZE,
254 /* context created by VBoxTray to handle seamless operations */
255 VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_SEAMLESS
256} VBOXWDDM_CONTEXT_TYPE;
257
258typedef struct VBOXWDDM_CREATECONTEXT_INFO
259{
260 /* interface version, i.e. 9 for d3d9, 8 for d3d8, etc. */
261 uint32_t u32IfVersion;
262 /* true if d3d false if ddraw */
263 VBOXWDDM_CONTEXT_TYPE enmType;
264 uint32_t crVersionMajor;
265 uint32_t crVersionMinor;
266 /* we use uint64_t instead of HANDLE to ensure structure def is the same for both 32-bit and 64-bit
267 * since x64 kernel driver can be called by 32-bit UMD */
268 uint64_t hUmEvent;
269 /* info to be passed to UMD notification to identify the context */
270 uint64_t u64UmInfo;
271} VBOXWDDM_CREATECONTEXT_INFO, *PVBOXWDDM_CREATECONTEXT_INFO;
272
273typedef uint64_t VBOXDISP_UMHANDLE;
274typedef uint32_t VBOXDISP_KMHANDLE;
275
276typedef struct VBOXWDDM_RECTS_FLAFS
277{
278 union
279 {
280 struct
281 {
282 /* used only in conjunction with bSetVisibleRects.
283 * if set - VBOXWDDM_RECTS_INFO::aRects[0] contains view rectangle */
284 UINT bSetViewRect : 1;
285 /* adds visible regions */
286 UINT bAddVisibleRects : 1;
287 /* adds hidden regions */
288 UINT bAddHiddenRects : 1;
289 /* hide entire window */
290 UINT bHide : 1;
291 /* reserved */
292 UINT Reserved : 28;
293 };
294 uint32_t Value;
295 };
296} VBOXWDDM_RECTS_FLAFS, *PVBOXWDDM_RECTS_FLAFS;
297
298typedef struct VBOXWDDM_RECTS_INFO
299{
300 uint32_t cRects;
301 RECT aRects[1];
302} VBOXWDDM_RECTS_INFO, *PVBOXWDDM_RECTS_INFO;
303
304#define VBOXWDDM_RECTS_INFO_SIZE4CRECTS(_cRects) (RT_OFFSETOF(VBOXWDDM_RECTS_INFO, aRects[(_cRects)]))
305#define VBOXWDDM_RECTS_INFO_SIZE(_pRects) (VBOXVIDEOCM_CMD_RECTS_SIZE4CRECTS((_pRects)->cRects))
306
307typedef enum
308{
309 /* command to be post to user mode */
310 VBOXVIDEOCM_CMD_TYPE_UM = 0,
311 /* control command processed in kernel mode */
312 VBOXVIDEOCM_CMD_TYPE_CTL_KM,
313 VBOXVIDEOCM_CMD_DUMMY_32BIT = 0x7fffffff
314} VBOXVIDEOCM_CMD_TYPE;
315
316typedef struct VBOXVIDEOCM_CMD_HDR
317{
318 uint64_t u64UmData;
319 uint32_t cbCmd;
320 VBOXVIDEOCM_CMD_TYPE enmType;
321}VBOXVIDEOCM_CMD_HDR, *PVBOXVIDEOCM_CMD_HDR;
322
323AssertCompile((sizeof (VBOXVIDEOCM_CMD_HDR) & 7) == 0);
324
325typedef struct VBOXVIDEOCM_CMD_RECTS
326{
327 VBOXWDDM_RECTS_FLAFS fFlags;
328 VBOXWDDM_RECTS_INFO RectsInfo;
329} VBOXVIDEOCM_CMD_RECTS, *PVBOXVIDEOCM_CMD_RECTS;
330
331typedef struct VBOXVIDEOCM_CMD_RECTS_INTERNAL
332{
333 union
334 {
335 VBOXDISP_UMHANDLE hSwapchainUm;
336 uint64_t hWnd;
337 uint64_t u64Value;
338 };
339 VBOXVIDEOCM_CMD_RECTS Cmd;
340} VBOXVIDEOCM_CMD_RECTS_INTERNAL, *PVBOXVIDEOCM_CMD_RECTS_INTERNAL;
341
342typedef struct VBOXVIDEOCM_CMD_RECTS_HDR
343{
344 VBOXVIDEOCM_CMD_HDR Hdr;
345 VBOXVIDEOCM_CMD_RECTS_INTERNAL Data;
346} VBOXVIDEOCM_CMD_RECTS_HDR, *PVBOXVIDEOCM_CMD_RECTS_HDR;
347
348#define VBOXVIDEOCM_CMD_RECTS_INTERNAL_SIZE4CRECTS(_cRects) (RT_OFFSETOF(VBOXVIDEOCM_CMD_RECTS_INTERNAL, Cmd.RectsInfo.aRects[(_cRects)]))
349#define VBOXVIDEOCM_CMD_RECTS_INTERNAL_SIZE(_pCmd) (VBOXVIDEOCM_CMD_RECTS_INTERNAL_SIZE4CRECTS((_pCmd)->cRects))
350
351typedef struct VBOXWDDM_GETVBOXVIDEOCMCMD_HDR
352{
353 uint32_t cbCmdsReturned;
354 uint32_t cbRemainingCmds;
355 uint32_t cbRemainingFirstCmd;
356 uint32_t u32Reserved;
357} VBOXWDDM_GETVBOXVIDEOCMCMD_HDR, *PVBOXWDDM_GETVBOXVIDEOCMCMD_HDR;
358
359typedef struct VBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD
360{
361 VBOXDISPIFESCAPE EscapeHdr;
362 VBOXWDDM_GETVBOXVIDEOCMCMD_HDR Hdr;
363} VBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD, *PVBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD;
364
365AssertCompile((sizeof (VBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD) & 7) == 0);
366AssertCompile(RT_OFFSETOF(VBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD, EscapeHdr) == 0);
367
368typedef struct VBOXDISPIFESCAPE_DBGPRINT
369{
370 VBOXDISPIFESCAPE EscapeHdr;
371 /* null-terminated string to DbgPrint including \0 */
372 char aStringBuf[1];
373} VBOXDISPIFESCAPE_DBGPRINT, *PVBOXDISPIFESCAPE_DBGPRINT;
374AssertCompile(RT_OFFSETOF(VBOXDISPIFESCAPE_DBGPRINT, EscapeHdr) == 0);
375
376typedef enum
377{
378 VBOXDISPIFESCAPE_DBGDUMPBUF_TYPE_UNDEFINED = 0,
379 VBOXDISPIFESCAPE_DBGDUMPBUF_TYPE_D3DCAPS9 = 1,
380 VBOXDISPIFESCAPE_DBGDUMPBUF_TYPE_DUMMY32BIT = 0x7fffffff
381} VBOXDISPIFESCAPE_DBGDUMPBUF_TYPE;
382
383typedef struct VBOXDISPIFESCAPE_DBGDUMPBUF_FLAGS
384{
385 union
386 {
387 struct
388 {
389 UINT WoW64 : 1;
390 UINT Reserved : 31; /* reserved */
391 };
392 UINT Value;
393 };
394} VBOXDISPIFESCAPE_DBGDUMPBUF_FLAGS, *PVBOXDISPIFESCAPE_DBGDUMPBUF_FLAGS;
395
396typedef struct VBOXDISPIFESCAPE_DBGDUMPBUF
397{
398 VBOXDISPIFESCAPE EscapeHdr;
399 VBOXDISPIFESCAPE_DBGDUMPBUF_TYPE enmType;
400 VBOXDISPIFESCAPE_DBGDUMPBUF_FLAGS Flags;
401 char aBuf[1];
402} VBOXDISPIFESCAPE_DBGDUMPBUF, *PVBOXDISPIFESCAPE_DBGDUMPBUF;
403AssertCompile(RT_OFFSETOF(VBOXDISPIFESCAPE_DBGDUMPBUF, EscapeHdr) == 0);
404
405typedef struct VBOXSCREENLAYOUT_ELEMENT
406{
407 D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
408 POINT pos;
409} VBOXSCREENLAYOUT_ELEMENT, *PVBOXSCREENLAYOUT_ELEMENT;
410
411typedef struct VBOXSCREENLAYOUT
412{
413 uint32_t cScreens;
414 VBOXSCREENLAYOUT_ELEMENT aScreens[1];
415} VBOXSCREENLAYOUT, *PVBOXSCREENLAYOUT;
416
417typedef struct VBOXDISPIFESCAPE_SCREENLAYOUT
418{
419 VBOXDISPIFESCAPE EscapeHdr;
420 VBOXSCREENLAYOUT ScreenLayout;
421} VBOXDISPIFESCAPE_SCREENLAYOUT, *PVBOXDISPIFESCAPE_SCREENLAYOUT;
422
423typedef struct VBOXSWAPCHAININFO
424{
425 VBOXDISP_KMHANDLE hSwapchainKm; /* in, NULL if new is being created */
426 VBOXDISP_UMHANDLE hSwapchainUm; /* in, UMD private data */
427 int32_t winHostID;
428 RECT Rect;
429 UINT u32Reserved;
430 UINT cAllocs;
431 D3DKMT_HANDLE ahAllocs[1];
432}VBOXSWAPCHAININFO, *PVBOXSWAPCHAININFO;
433typedef struct VBOXDISPIFESCAPE_SWAPCHAININFO
434{
435 VBOXDISPIFESCAPE EscapeHdr;
436 VBOXSWAPCHAININFO SwapchainInfo;
437} VBOXDISPIFESCAPE_SWAPCHAININFO, *PVBOXDISPIFESCAPE_SWAPCHAININFO;
438
439typedef struct VBOXVIDEOCM_UM_ALLOC
440{
441 VBOXDISP_KMHANDLE hAlloc;
442 uint32_t cbData;
443 uint64_t pvData;
444 uint64_t hSynch;
445 VBOXUHGSMI_BUFFER_TYPE_FLAGS fUhgsmiType;
446} VBOXVIDEOCM_UM_ALLOC, *PVBOXVIDEOCM_UM_ALLOC;
447
448typedef struct VBOXDISPIFESCAPE_UHGSMI_ALLOCATE
449{
450 VBOXDISPIFESCAPE EscapeHdr;
451 VBOXVIDEOCM_UM_ALLOC Alloc;
452} VBOXDISPIFESCAPE_UHGSMI_ALLOCATE, *PVBOXDISPIFESCAPE_UHGSMI_ALLOCATE;
453
454typedef struct VBOXDISPIFESCAPE_UHGSMI_DEALLOCATE
455{
456 VBOXDISPIFESCAPE EscapeHdr;
457 VBOXDISP_KMHANDLE hAlloc;
458} VBOXDISPIFESCAPE_UHGSMI_DEALLOCATE, *PVBOXDISPIFESCAPE_UHGSMI_DEALLOCATE;
459
460typedef struct VBOXWDDM_UHGSMI_BUFFER_UI_INFO_ESCAPE
461{
462 VBOXDISP_KMHANDLE hAlloc;
463 VBOXWDDM_UHGSMI_BUFFER_UI_SUBMIT_INFO Info;
464} VBOXWDDM_UHGSMI_BUFFER_UI_INFO_ESCAPE, *PVBOXWDDM_UHGSMI_BUFFER_UI_INFO_ESCAPE;
465
466typedef struct VBOXDISPIFESCAPE_UHGSMI_SUBMIT
467{
468 VBOXDISPIFESCAPE EscapeHdr;
469 VBOXWDDM_UHGSMI_BUFFER_UI_INFO_ESCAPE aBuffers[1];
470} VBOXDISPIFESCAPE_UHGSMI_SUBMIT, *PVBOXDISPIFESCAPE_UHGSMI_SUBMIT;
471
472typedef struct VBOXDISPIFESCAPE_SHRC_REF
473{
474 VBOXDISPIFESCAPE EscapeHdr;
475 uint64_t hAlloc;
476} VBOXDISPIFESCAPE_SHRC_REF, *PVBOXDISPIFESCAPE_SHRC_REF;
477
478typedef struct VBOXDISPIFESCAPE_SETALLOCHOSTID
479{
480 VBOXDISPIFESCAPE EscapeHdr;
481 int32_t rc;
482 uint32_t hostID;
483 uint64_t hAlloc;
484
485} VBOXDISPIFESCAPE_SETALLOCHOSTID, *PVBOXDISPIFESCAPE_SETALLOCHOSTID;
486
487typedef struct VBOXDISPIFESCAPE_CRHGSMICTLCON_CALL
488{
489 VBOXDISPIFESCAPE EscapeHdr;
490 VBGLIOCHGCMCALL CallInfo;
491} VBOXDISPIFESCAPE_CRHGSMICTLCON_CALL, *PVBOXDISPIFESCAPE_CRHGSMICTLCON_CALL;
492
493/* query info func */
494typedef struct VBOXWDDM_QI
495{
496 uint32_t u32Version;
497 uint32_t u32VBox3DCaps;
498 uint32_t cInfos;
499 VBOXVHWA_INFO aInfos[VBOX_VIDEO_MAX_SCREENS];
500} VBOXWDDM_QI;
501
502/** Convert a given FourCC code to a D3DDDIFORMAT enum. */
503#define VBOXWDDM_D3DDDIFORMAT_FROM_FOURCC(_a, _b, _c, _d) \
504 ((D3DDDIFORMAT)MAKEFOURCC(_a, _b, _c, _d))
505
506/* submit cmd func */
507DECLINLINE(D3DDDIFORMAT) vboxWddmFmtNoAlphaFormat(D3DDDIFORMAT enmFormat)
508{
509 switch (enmFormat)
510 {
511 case D3DDDIFMT_A8R8G8B8:
512 return D3DDDIFMT_X8R8G8B8;
513 case D3DDDIFMT_A1R5G5B5:
514 return D3DDDIFMT_X1R5G5B5;
515 case D3DDDIFMT_A4R4G4B4:
516 return D3DDDIFMT_X4R4G4B4;
517 case D3DDDIFMT_A8B8G8R8:
518 return D3DDDIFMT_X8B8G8R8;
519 default:
520 return enmFormat;
521 }
522}
523
524/* tooling */
525DECLINLINE(UINT) vboxWddmCalcBitsPerPixel(D3DDDIFORMAT enmFormat)
526{
527#ifdef _MSC_VER
528# pragma warning(push)
529# pragma warning(disable:4063) /* VBOXWDDM_D3DDDIFORMAT_FROM_FOURCC('Y', 'V', '1', '2'): isn't part of the enum */
530#endif
531 switch (enmFormat)
532 {
533 case D3DDDIFMT_R8G8B8:
534 return 24;
535 case D3DDDIFMT_A8R8G8B8:
536 case D3DDDIFMT_X8R8G8B8:
537 return 32;
538 case D3DDDIFMT_R5G6B5:
539 case D3DDDIFMT_X1R5G5B5:
540 case D3DDDIFMT_A1R5G5B5:
541 case D3DDDIFMT_A4R4G4B4:
542 return 16;
543 case D3DDDIFMT_R3G3B2:
544 case D3DDDIFMT_A8:
545 return 8;
546 case D3DDDIFMT_A8R3G3B2:
547 case D3DDDIFMT_X4R4G4B4:
548 return 16;
549 case D3DDDIFMT_A2B10G10R10:
550 case D3DDDIFMT_A8B8G8R8:
551 case D3DDDIFMT_X8B8G8R8:
552 case D3DDDIFMT_G16R16:
553 case D3DDDIFMT_A2R10G10B10:
554 return 32;
555 case D3DDDIFMT_A16B16G16R16:
556 case D3DDDIFMT_A16B16G16R16F:
557 return 64;
558 case D3DDDIFMT_A32B32G32R32F:
559 return 128;
560 case D3DDDIFMT_A8P8:
561 return 16;
562 case D3DDDIFMT_P8:
563 case D3DDDIFMT_L8:
564 return 8;
565 case D3DDDIFMT_L16:
566 case D3DDDIFMT_A8L8:
567 return 16;
568 case D3DDDIFMT_A4L4:
569 return 8;
570 case D3DDDIFMT_V8U8:
571 case D3DDDIFMT_L6V5U5:
572 return 16;
573 case D3DDDIFMT_X8L8V8U8:
574 case D3DDDIFMT_Q8W8V8U8:
575 case D3DDDIFMT_V16U16:
576 case D3DDDIFMT_W11V11U10:
577 case D3DDDIFMT_A2W10V10U10:
578 return 32;
579 case D3DDDIFMT_D16_LOCKABLE:
580 case D3DDDIFMT_D16:
581 case D3DDDIFMT_D15S1:
582 return 16;
583 case D3DDDIFMT_D32:
584 case D3DDDIFMT_D24S8:
585 case D3DDDIFMT_D24X8:
586 case D3DDDIFMT_D24X4S4:
587 case D3DDDIFMT_D24FS8:
588 case D3DDDIFMT_D32_LOCKABLE:
589 case D3DDDIFMT_D32F_LOCKABLE:
590 return 32;
591 case D3DDDIFMT_S8_LOCKABLE:
592 return 8;
593 case D3DDDIFMT_DXT1:
594 return 4;
595 case D3DDDIFMT_DXT2:
596 case D3DDDIFMT_DXT3:
597 case D3DDDIFMT_DXT4:
598 case D3DDDIFMT_DXT5:
599 case D3DDDIFMT_VERTEXDATA:
600 case D3DDDIFMT_INDEX16: /* <- yes, dx runtime treats it as such */
601 return 8;
602 case D3DDDIFMT_INDEX32:
603 return 8;
604 case D3DDDIFMT_R32F:
605 return 32;
606 case D3DDDIFMT_R16F:
607 return 16;
608 case D3DDDIFMT_YUY2: /* 4 bytes per 2 pixels. */
609 case VBOXWDDM_D3DDDIFORMAT_FROM_FOURCC('Y', 'V', '1', '2'):
610 return 16;
611 default:
612 AssertBreakpoint();
613 return 0;
614 }
615#ifdef _MSC_VER
616# pragma warning(pop)
617#endif
618}
619
620DECLINLINE(uint32_t) vboxWddmFormatToFourcc(D3DDDIFORMAT enmFormat)
621{
622 uint32_t uFormat = (uint32_t)enmFormat;
623 /* assume that in case both four bytes are non-zero, this is a fourcc */
624 if ((uFormat & 0xff000000)
625 && (uFormat & 0x00ff0000)
626 && (uFormat & 0x0000ff00)
627 && (uFormat & 0x000000ff)
628 )
629 return uFormat;
630 return 0;
631}
632
633#define VBOXWDDM_ROUNDBOUND(_v, _b) (((_v) + ((_b) - 1)) & ~((_b) - 1))
634
635DECLINLINE(UINT) vboxWddmCalcOffXru(UINT w, D3DDDIFORMAT enmFormat)
636{
637 switch (enmFormat)
638 {
639 /* pitch for the DXT* (aka compressed) formats is the size in bytes of blocks that fill in an image width
640 * i.e. each block decompressed into 4 x 4 pixels, so we have ((Width + 3) / 4) blocks for Width.
641 * then each block has 64 bits (8 bytes) for DXT1 and 64+64 bits (16 bytes) for DXT2-DXT5, so.. : */
642 case D3DDDIFMT_DXT1:
643 {
644 UINT Pitch = (w + 3) / 4; /* <- pitch size in blocks */
645 Pitch *= 8; /* <- pitch size in bytes */
646 return Pitch;
647 }
648 case D3DDDIFMT_DXT2:
649 case D3DDDIFMT_DXT3:
650 case D3DDDIFMT_DXT4:
651 case D3DDDIFMT_DXT5:
652 {
653 UINT Pitch = (w + 3) / 4; /* <- pitch size in blocks */
654 Pitch *= 8; /* <- pitch size in bytes */
655 return Pitch;
656 }
657 default:
658 {
659 /* the default is just to calculate the pitch from bpp */
660 UINT bpp = vboxWddmCalcBitsPerPixel(enmFormat);
661 UINT Pitch = bpp * w;
662 /* pitch is now in bits, translate in bytes */
663 return VBOXWDDM_ROUNDBOUND(Pitch, 8) >> 3;
664 }
665 }
666}
667
668DECLINLINE(UINT) vboxWddmCalcOffXrd(UINT w, D3DDDIFORMAT enmFormat)
669{
670 switch (enmFormat)
671 {
672 /* pitch for the DXT* (aka compressed) formats is the size in bytes of blocks that fill in an image width
673 * i.e. each block decompressed into 4 x 4 pixels, so we have ((Width + 3) / 4) blocks for Width.
674 * then each block has 64 bits (8 bytes) for DXT1 and 64+64 bits (16 bytes) for DXT2-DXT5, so.. : */
675 case D3DDDIFMT_DXT1:
676 {
677 UINT Pitch = w / 4; /* <- pitch size in blocks */
678 Pitch *= 8; /* <- pitch size in bytes */
679 return Pitch;
680 }
681 case D3DDDIFMT_DXT2:
682 case D3DDDIFMT_DXT3:
683 case D3DDDIFMT_DXT4:
684 case D3DDDIFMT_DXT5:
685 {
686 UINT Pitch = w / 4; /* <- pitch size in blocks */
687 Pitch *= 16; /* <- pitch size in bytes */
688 return Pitch;
689 }
690 default:
691 {
692 /* the default is just to calculate the pitch from bpp */
693 UINT bpp = vboxWddmCalcBitsPerPixel(enmFormat);
694 UINT Pitch = bpp * w;
695 /* pitch is now in bits, translate in bytes */
696 return Pitch >> 3;
697 }
698 }
699}
700
701DECLINLINE(UINT) vboxWddmCalcHightPacking(D3DDDIFORMAT enmFormat)
702{
703 switch (enmFormat)
704 {
705 /* for the DXT* (aka compressed) formats each block is decompressed into 4 x 4 pixels,
706 * so packing is 4
707 */
708 case D3DDDIFMT_DXT1:
709 case D3DDDIFMT_DXT2:
710 case D3DDDIFMT_DXT3:
711 case D3DDDIFMT_DXT4:
712 case D3DDDIFMT_DXT5:
713 return 4;
714 default:
715 return 1;
716 }
717}
718
719DECLINLINE(UINT) vboxWddmCalcOffYru(UINT height, D3DDDIFORMAT enmFormat)
720{
721 UINT packing = vboxWddmCalcHightPacking(enmFormat);
722 /* round it up */
723 return (height + packing - 1) / packing;
724}
725
726DECLINLINE(UINT) vboxWddmCalcOffYrd(UINT height, D3DDDIFORMAT enmFormat)
727{
728 UINT packing = vboxWddmCalcHightPacking(enmFormat);
729 /* round it up */
730 return height / packing;
731}
732
733DECLINLINE(UINT) vboxWddmCalcPitch(UINT w, D3DDDIFORMAT enmFormat)
734{
735 return vboxWddmCalcOffXru(w, enmFormat);
736}
737
738DECLINLINE(UINT) vboxWddmCalcWidthForPitch(UINT Pitch, D3DDDIFORMAT enmFormat)
739{
740 switch (enmFormat)
741 {
742 /* pitch for the DXT* (aka compressed) formats is the size in bytes of blocks that fill in an image width
743 * i.e. each block decompressed into 4 x 4 pixels, so we have ((Width + 3) / 4) blocks for Width.
744 * then each block has 64 bits (8 bytes) for DXT1 and 64+64 bits (16 bytes) for DXT2-DXT5, so.. : */
745 case D3DDDIFMT_DXT1:
746 {
747 return (Pitch / 8) * 4;
748 }
749 case D3DDDIFMT_DXT2:
750 case D3DDDIFMT_DXT3:
751 case D3DDDIFMT_DXT4:
752 case D3DDDIFMT_DXT5:
753 {
754 return (Pitch / 16) * 4;;
755 }
756 default:
757 {
758 /* the default is just to calculate it from bpp */
759 UINT bpp = vboxWddmCalcBitsPerPixel(enmFormat);
760 return (Pitch << 3) / bpp;
761 }
762 }
763}
764
765DECLINLINE(UINT) vboxWddmCalcNumRows(UINT top, UINT bottom, D3DDDIFORMAT enmFormat)
766{
767 Assert(bottom > top);
768 top = top ? vboxWddmCalcOffYrd(top, enmFormat) : 0; /* <- just to optimize it a bit */
769 bottom = vboxWddmCalcOffYru(bottom, enmFormat);
770 return bottom - top;
771}
772
773DECLINLINE(UINT) vboxWddmCalcRowSize(UINT left, UINT right, D3DDDIFORMAT enmFormat)
774{
775 Assert(right > left);
776 left = left ? vboxWddmCalcOffXrd(left, enmFormat) : 0; /* <- just to optimize it a bit */
777 right = vboxWddmCalcOffXru(right, enmFormat);
778 return right - left;
779}
780
781DECLINLINE(UINT) vboxWddmCalcSize(UINT pitch, UINT height, D3DDDIFORMAT enmFormat)
782{
783 UINT cRows = vboxWddmCalcNumRows(0, height, enmFormat);
784 return pitch * cRows;
785}
786
787DECLINLINE(UINT) vboxWddmCalcOffXYrd(UINT x, UINT y, UINT pitch, D3DDDIFORMAT enmFormat)
788{
789 UINT offY = 0;
790 if (y)
791 offY = vboxWddmCalcSize(pitch, y, enmFormat);
792
793 return offY + vboxWddmCalcOffXrd(x, enmFormat);
794}
795
796#define VBOXWDDM_ARRAY_MAXELEMENTSU32(_t) ((uint32_t)((UINT32_MAX) / sizeof (_t)))
797#define VBOXWDDM_TRAILARRAY_MAXELEMENTSU32(_t, _af) ((uint32_t)(((~(0UL)) - (uint32_t)RT_OFFSETOF(_t, _af[0])) / RT_SIZEOFMEMB(_t, _af[0])))
798
799#endif /* #ifndef ___VBoxMPIf_h___ */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette