VirtualBox

source: vbox/trunk/include/VBox/VBoxVideo.h@ 63942

Last change on this file since 63942 was 63824, checked in by vboxsync, 8 years ago

VBoxVideo.h: comment for VBVA_SCREEN_F_BLANK

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 63.7 KB
Line 
1/** @file
2 * VirtualBox Video interface.
3 */
4
5/*
6 * Copyright (C) 2006-2016 Oracle Corporation
7 *
8 * This file is part of VirtualBox Open Source Edition (OSE), as
9 * available from http://www.virtualbox.org. This file is free software;
10 * you can redistribute it and/or modify it under the terms of the GNU
11 * General Public License (GPL) as published by the Free Software
12 * Foundation, in version 2 as it comes in the "COPYING" file of the
13 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15 *
16 * The contents of this file may alternatively be used under the terms
17 * of the Common Development and Distribution License Version 1.0
18 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
19 * VirtualBox OSE distribution, in which case the provisions of the
20 * CDDL are applicable instead of those of the GPL.
21 *
22 * You may elect to license modified versions of this file under the
23 * terms and conditions of either the GPL or the CDDL or both.
24 */
25
26#ifndef ___VBox_VBoxVideo_h
27#define ___VBox_VBoxVideo_h
28
29#include <VBox/VMMDev.h>
30#include <VBox/Hardware/VBoxVideoVBE.h>
31
32#include <iprt/cdefs.h>
33#include <iprt/types.h>
34
35/*
36 * The last 4096 bytes of the guest VRAM contains the generic info for all
37 * DualView chunks: sizes and offsets of chunks. This is filled by miniport.
38 *
39 * Last 4096 bytes of each chunk contain chunk specific data: framebuffer info,
40 * etc. This is used exclusively by the corresponding instance of a display driver.
41 *
42 * The VRAM layout:
43 * Last 4096 bytes - Adapter information area.
44 * 4096 bytes aligned miniport heap (value specified in the config rouded up).
45 * Slack - what left after dividing the VRAM.
46 * 4096 bytes aligned framebuffers:
47 * last 4096 bytes of each framebuffer is the display information area.
48 *
49 * The Virtual Graphics Adapter information in the guest VRAM is stored by the
50 * guest video driver using structures prepended by VBOXVIDEOINFOHDR.
51 *
52 * When the guest driver writes dword 0 to the VBE_DISPI_INDEX_VBOX_VIDEO
53 * the host starts to process the info. The first element at the start of
54 * the 4096 bytes region should be normally be a LINK that points to
55 * actual information chain. That way the guest driver can have some
56 * fixed layout of the information memory block and just rewrite
57 * the link to point to relevant memory chain.
58 *
59 * The processing stops at the END element.
60 *
61 * The host can access the memory only when the port IO is processed.
62 * All data that will be needed later must be copied from these 4096 bytes.
63 * But other VRAM can be used by host until the mode is disabled.
64 *
65 * The guest driver writes dword 0xffffffff to the VBE_DISPI_INDEX_VBOX_VIDEO
66 * to disable the mode.
67 *
68 * VBE_DISPI_INDEX_VBOX_VIDEO is used to read the configuration information
69 * from the host and issue commands to the host.
70 *
71 * The guest writes the VBE_DISPI_INDEX_VBOX_VIDEO index register, the the
72 * following operations with the VBE data register can be performed:
73 *
74 * Operation Result
75 * write 16 bit value NOP
76 * read 16 bit value count of monitors
77 * write 32 bit value sets the vbox command value and the command processed by the host
78 * read 32 bit value result of the last vbox command is returned
79 */
80
81#define VBOX_VIDEO_PRIMARY_SCREEN 0
82#define VBOX_VIDEO_NO_SCREEN ~0
83
84/* The size of the information. */
85/*
86 * The minimum HGSMI heap size is PAGE_SIZE (4096 bytes) and is a restriction of the
87 * runtime heapsimple API. Use minimum 2 pages here, because the info area also may
88 * contain other data (for example HGSMIHOSTFLAGS structure).
89 */
90#ifndef VBOX_XPDM_MINIPORT
91# define VBVA_ADAPTER_INFORMATION_SIZE (64*_1K)
92#else
93#define VBVA_ADAPTER_INFORMATION_SIZE (16*_1K)
94#define VBVA_DISPLAY_INFORMATION_SIZE (64*_1K)
95#endif
96#define VBVA_MIN_BUFFER_SIZE (64*_1K)
97
98
99/* The value for port IO to let the adapter to interpret the adapter memory. */
100#define VBOX_VIDEO_DISABLE_ADAPTER_MEMORY 0xFFFFFFFF
101
102/* The value for port IO to let the adapter to interpret the adapter memory. */
103#define VBOX_VIDEO_INTERPRET_ADAPTER_MEMORY 0x00000000
104
105/* The value for port IO to let the adapter to interpret the display memory.
106 * The display number is encoded in low 16 bits.
107 */
108#define VBOX_VIDEO_INTERPRET_DISPLAY_MEMORY_BASE 0x00010000
109
110
111/* The end of the information. */
112#define VBOX_VIDEO_INFO_TYPE_END 0
113/* Instructs the host to fetch the next VBOXVIDEOINFOHDR at the given offset of VRAM. */
114#define VBOX_VIDEO_INFO_TYPE_LINK 1
115/* Information about a display memory position. */
116#define VBOX_VIDEO_INFO_TYPE_DISPLAY 2
117/* Information about a screen. */
118#define VBOX_VIDEO_INFO_TYPE_SCREEN 3
119/* Information about host notifications for the driver. */
120#define VBOX_VIDEO_INFO_TYPE_HOST_EVENTS 4
121/* Information about non-volatile guest VRAM heap. */
122#define VBOX_VIDEO_INFO_TYPE_NV_HEAP 5
123/* VBVA enable/disable. */
124#define VBOX_VIDEO_INFO_TYPE_VBVA_STATUS 6
125/* VBVA flush. */
126#define VBOX_VIDEO_INFO_TYPE_VBVA_FLUSH 7
127/* Query configuration value. */
128#define VBOX_VIDEO_INFO_TYPE_QUERY_CONF32 8
129
130
131#pragma pack(1)
132typedef struct VBOXVIDEOINFOHDR
133{
134 uint8_t u8Type;
135 uint8_t u8Reserved;
136 uint16_t u16Length;
137} VBOXVIDEOINFOHDR;
138
139
140typedef struct VBOXVIDEOINFOLINK
141{
142 /* Relative offset in VRAM */
143 int32_t i32Offset;
144} VBOXVIDEOINFOLINK;
145
146
147/* Resides in adapter info memory. Describes a display VRAM chunk. */
148typedef struct VBOXVIDEOINFODISPLAY
149{
150 /* Index of the framebuffer assigned by guest. */
151 uint32_t u32Index;
152
153 /* Absolute offset in VRAM of the framebuffer to be displayed on the monitor. */
154 uint32_t u32Offset;
155
156 /* The size of the memory that can be used for the screen. */
157 uint32_t u32FramebufferSize;
158
159 /* The size of the memory that is used for the Display information.
160 * The information is at u32Offset + u32FramebufferSize
161 */
162 uint32_t u32InformationSize;
163
164} VBOXVIDEOINFODISPLAY;
165
166
167/* Resides in display info area, describes the current video mode. */
168#define VBOX_VIDEO_INFO_SCREEN_F_NONE 0x00
169#define VBOX_VIDEO_INFO_SCREEN_F_ACTIVE 0x01
170
171typedef struct VBOXVIDEOINFOSCREEN
172{
173 /* Physical X origin relative to the primary screen. */
174 int32_t xOrigin;
175
176 /* Physical Y origin relative to the primary screen. */
177 int32_t yOrigin;
178
179 /* The scan line size in bytes. */
180 uint32_t u32LineSize;
181
182 /* Width of the screen. */
183 uint16_t u16Width;
184
185 /* Height of the screen. */
186 uint16_t u16Height;
187
188 /* Color depth. */
189 uint8_t bitsPerPixel;
190
191 /* VBOX_VIDEO_INFO_SCREEN_F_* */
192 uint8_t u8Flags;
193} VBOXVIDEOINFOSCREEN;
194
195/* The guest initializes the structure to 0. The positions of the structure in the
196 * display info area must not be changed, host will update the structure. Guest checks
197 * the events and modifies the structure as a response to host.
198 */
199#define VBOX_VIDEO_INFO_HOST_EVENTS_F_NONE 0x00000000
200#define VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET 0x00000080
201
202typedef struct VBOXVIDEOINFOHOSTEVENTS
203{
204 /* Host events. */
205 uint32_t fu32Events;
206} VBOXVIDEOINFOHOSTEVENTS;
207
208/* Resides in adapter info memory. Describes the non-volatile VRAM heap. */
209typedef struct VBOXVIDEOINFONVHEAP
210{
211 /* Absolute offset in VRAM of the start of the heap. */
212 uint32_t u32HeapOffset;
213
214 /* The size of the heap. */
215 uint32_t u32HeapSize;
216
217} VBOXVIDEOINFONVHEAP;
218
219/* Display information area. */
220typedef struct VBOXVIDEOINFOVBVASTATUS
221{
222 /* Absolute offset in VRAM of the start of the VBVA QUEUE. 0 to disable VBVA. */
223 uint32_t u32QueueOffset;
224
225 /* The size of the VBVA QUEUE. 0 to disable VBVA. */
226 uint32_t u32QueueSize;
227
228} VBOXVIDEOINFOVBVASTATUS;
229
230typedef struct VBOXVIDEOINFOVBVAFLUSH
231{
232 uint32_t u32DataStart;
233
234 uint32_t u32DataEnd;
235
236} VBOXVIDEOINFOVBVAFLUSH;
237
238#define VBOX_VIDEO_QCI32_MONITOR_COUNT 0
239#define VBOX_VIDEO_QCI32_OFFSCREEN_HEAP_SIZE 1
240
241typedef struct VBOXVIDEOINFOQUERYCONF32
242{
243 uint32_t u32Index;
244
245 uint32_t u32Value;
246
247} VBOXVIDEOINFOQUERYCONF32;
248#pragma pack()
249
250#ifdef VBOX_WITH_VIDEOHWACCEL
251#pragma pack(1)
252
253#define VBOXVHWA_VERSION_MAJ 0
254#define VBOXVHWA_VERSION_MIN 0
255#define VBOXVHWA_VERSION_BLD 6
256#define VBOXVHWA_VERSION_RSV 0
257
258typedef enum
259{
260 VBOXVHWACMD_TYPE_SURF_CANCREATE = 1,
261 VBOXVHWACMD_TYPE_SURF_CREATE,
262 VBOXVHWACMD_TYPE_SURF_DESTROY,
263 VBOXVHWACMD_TYPE_SURF_LOCK,
264 VBOXVHWACMD_TYPE_SURF_UNLOCK,
265 VBOXVHWACMD_TYPE_SURF_BLT,
266 VBOXVHWACMD_TYPE_SURF_FLIP,
267 VBOXVHWACMD_TYPE_SURF_OVERLAY_UPDATE,
268 VBOXVHWACMD_TYPE_SURF_OVERLAY_SETPOSITION,
269 VBOXVHWACMD_TYPE_SURF_COLORKEY_SET,
270 VBOXVHWACMD_TYPE_QUERY_INFO1,
271 VBOXVHWACMD_TYPE_QUERY_INFO2,
272 VBOXVHWACMD_TYPE_ENABLE,
273 VBOXVHWACMD_TYPE_DISABLE,
274 VBOXVHWACMD_TYPE_HH_CONSTRUCT,
275 VBOXVHWACMD_TYPE_HH_RESET
276#ifdef VBOX_WITH_WDDM
277 , VBOXVHWACMD_TYPE_SURF_GETINFO
278 , VBOXVHWACMD_TYPE_SURF_COLORFILL
279#endif
280 , VBOXVHWACMD_TYPE_HH_DISABLE
281 , VBOXVHWACMD_TYPE_HH_ENABLE
282 , VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEBEGIN
283 , VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND
284 , VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEPERFORM
285 , VBOXVHWACMD_TYPE_HH_SAVESTATE_LOADPERFORM
286} VBOXVHWACMD_TYPE;
287
288/* the command processing was asynch, set by the host to indicate asynch command completion
289 * must not be cleared once set, the command completion is performed by issuing a host->guest completion command
290 * while keeping this flag unchanged */
291#define VBOXVHWACMD_FLAG_HG_ASYNCH 0x00010000
292/* asynch completion is performed by issuing the event */
293#define VBOXVHWACMD_FLAG_GH_ASYNCH_EVENT 0x00000001
294/* issue interrupt on asynch completion */
295#define VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ 0x00000002
296/* guest does not do any op on completion of this command, the host may copy the command and indicate that it does not need the command anymore
297 * by setting the VBOXVHWACMD_FLAG_HG_ASYNCH_RETURNED flag */
298#define VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION 0x00000004
299/* the host has copied the VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION command and returned it to the guest */
300#define VBOXVHWACMD_FLAG_HG_ASYNCH_RETURNED 0x00020000
301/* this is the host->host cmd, i.e. a configuration command posted by the host to the framebuffer */
302#define VBOXVHWACMD_FLAG_HH_CMD 0x10000000
303
304typedef struct VBOXVHWACMD
305{
306 VBOXVHWACMD_TYPE enmCmd; /* command type */
307 volatile int32_t rc; /* command result */
308 int32_t iDisplay; /* display index */
309 volatile int32_t Flags; /* ored VBOXVHWACMD_FLAG_xxx values */
310 uint64_t GuestVBVAReserved1; /* field internally used by the guest VBVA cmd handling, must NOT be modified by clients */
311 uint64_t GuestVBVAReserved2; /* field internally used by the guest VBVA cmd handling, must NOT be modified by clients */
312 volatile uint32_t cRefs;
313 int32_t Reserved;
314 union
315 {
316 struct VBOXVHWACMD *pNext;
317 uint32_t offNext;
318 uint64_t Data; /* the body is 64-bit aligned */
319 } u;
320 char body[1];
321} VBOXVHWACMD;
322
323#define VBOXVHWACMD_HEADSIZE() (RT_OFFSETOF(VBOXVHWACMD, body))
324#define VBOXVHWACMD_SIZE_FROMBODYSIZE(_s) (VBOXVHWACMD_HEADSIZE() + (_s))
325#define VBOXVHWACMD_SIZE(_tCmd) (VBOXVHWACMD_SIZE_FROMBODYSIZE(sizeof(_tCmd)))
326typedef unsigned int VBOXVHWACMD_LENGTH;
327typedef uint64_t VBOXVHWA_SURFHANDLE;
328#define VBOXVHWA_SURFHANDLE_INVALID 0ULL
329#define VBOXVHWACMD_BODY(_p, _t) ((_t*)(_p)->body)
330#define VBOXVHWACMD_HEAD(_pb) ((VBOXVHWACMD*)((uint8_t *)(_pb) - RT_OFFSETOF(VBOXVHWACMD, body)))
331
332typedef struct VBOXVHWA_RECTL
333{
334 int32_t left;
335 int32_t top;
336 int32_t right;
337 int32_t bottom;
338} VBOXVHWA_RECTL;
339
340typedef struct VBOXVHWA_COLORKEY
341{
342 uint32_t low;
343 uint32_t high;
344} VBOXVHWA_COLORKEY;
345
346typedef struct VBOXVHWA_PIXELFORMAT
347{
348 uint32_t flags;
349 uint32_t fourCC;
350 union
351 {
352 uint32_t rgbBitCount;
353 uint32_t yuvBitCount;
354 } c;
355
356 union
357 {
358 uint32_t rgbRBitMask;
359 uint32_t yuvYBitMask;
360 } m1;
361
362 union
363 {
364 uint32_t rgbGBitMask;
365 uint32_t yuvUBitMask;
366 } m2;
367
368 union
369 {
370 uint32_t rgbBBitMask;
371 uint32_t yuvVBitMask;
372 } m3;
373
374 union
375 {
376 uint32_t rgbABitMask;
377 } m4;
378
379 uint32_t Reserved;
380} VBOXVHWA_PIXELFORMAT;
381
382typedef struct VBOXVHWA_SURFACEDESC
383{
384 uint32_t flags;
385 uint32_t height;
386 uint32_t width;
387 uint32_t pitch;
388 uint32_t sizeX;
389 uint32_t sizeY;
390 uint32_t cBackBuffers;
391 uint32_t Reserved;
392 VBOXVHWA_COLORKEY DstOverlayCK;
393 VBOXVHWA_COLORKEY DstBltCK;
394 VBOXVHWA_COLORKEY SrcOverlayCK;
395 VBOXVHWA_COLORKEY SrcBltCK;
396 VBOXVHWA_PIXELFORMAT PixelFormat;
397 uint32_t surfCaps;
398 uint32_t Reserved2;
399 VBOXVHWA_SURFHANDLE hSurf;
400 uint64_t offSurface;
401} VBOXVHWA_SURFACEDESC;
402
403typedef struct VBOXVHWA_BLTFX
404{
405 uint32_t flags;
406 uint32_t rop;
407 uint32_t rotationOp;
408 uint32_t rotation;
409 uint32_t fillColor;
410 uint32_t Reserved;
411 VBOXVHWA_COLORKEY DstCK;
412 VBOXVHWA_COLORKEY SrcCK;
413} VBOXVHWA_BLTFX;
414
415typedef struct VBOXVHWA_OVERLAYFX
416{
417 uint32_t flags;
418 uint32_t Reserved1;
419 uint32_t fxFlags;
420 uint32_t Reserved2;
421 VBOXVHWA_COLORKEY DstCK;
422 VBOXVHWA_COLORKEY SrcCK;
423} VBOXVHWA_OVERLAYFX;
424
425#define VBOXVHWA_CAPS_BLT 0x00000040
426#define VBOXVHWA_CAPS_BLTCOLORFILL 0x04000000
427#define VBOXVHWA_CAPS_BLTFOURCC 0x00000100
428#define VBOXVHWA_CAPS_BLTSTRETCH 0x00000200
429#define VBOXVHWA_CAPS_BLTQUEUE 0x00000080
430
431#define VBOXVHWA_CAPS_OVERLAY 0x00000800
432#define VBOXVHWA_CAPS_OVERLAYFOURCC 0x00002000
433#define VBOXVHWA_CAPS_OVERLAYSTRETCH 0x00004000
434#define VBOXVHWA_CAPS_OVERLAYCANTCLIP 0x00001000
435
436#define VBOXVHWA_CAPS_COLORKEY 0x00400000
437#define VBOXVHWA_CAPS_COLORKEYHWASSIST 0x01000000
438
439#define VBOXVHWA_SCAPS_BACKBUFFER 0x00000004
440#define VBOXVHWA_SCAPS_COMPLEX 0x00000008
441#define VBOXVHWA_SCAPS_FLIP 0x00000010
442#define VBOXVHWA_SCAPS_FRONTBUFFER 0x00000020
443#define VBOXVHWA_SCAPS_OFFSCREENPLAIN 0x00000040
444#define VBOXVHWA_SCAPS_OVERLAY 0x00000080
445#define VBOXVHWA_SCAPS_PRIMARYSURFACE 0x00000200
446#define VBOXVHWA_SCAPS_SYSTEMMEMORY 0x00000800
447#define VBOXVHWA_SCAPS_VIDEOMEMORY 0x00004000
448#define VBOXVHWA_SCAPS_VISIBLE 0x00008000
449#define VBOXVHWA_SCAPS_LOCALVIDMEM 0x10000000
450
451#define VBOXVHWA_PF_PALETTEINDEXED8 0x00000020
452#define VBOXVHWA_PF_RGB 0x00000040
453#define VBOXVHWA_PF_RGBTOYUV 0x00000100
454#define VBOXVHWA_PF_YUV 0x00000200
455#define VBOXVHWA_PF_FOURCC 0x00000004
456
457#define VBOXVHWA_LOCK_DISCARDCONTENTS 0x00002000
458
459#define VBOXVHWA_CFG_ENABLED 0x00000001
460
461#define VBOXVHWA_SD_BACKBUFFERCOUNT 0x00000020
462#define VBOXVHWA_SD_CAPS 0x00000001
463#define VBOXVHWA_SD_CKDESTBLT 0x00004000
464#define VBOXVHWA_SD_CKDESTOVERLAY 0x00002000
465#define VBOXVHWA_SD_CKSRCBLT 0x00010000
466#define VBOXVHWA_SD_CKSRCOVERLAY 0x00008000
467#define VBOXVHWA_SD_HEIGHT 0x00000002
468#define VBOXVHWA_SD_PITCH 0x00000008
469#define VBOXVHWA_SD_PIXELFORMAT 0x00001000
470/*#define VBOXVHWA_SD_REFRESHRATE 0x00040000*/
471#define VBOXVHWA_SD_WIDTH 0x00000004
472
473#define VBOXVHWA_CKEYCAPS_DESTBLT 0x00000001
474#define VBOXVHWA_CKEYCAPS_DESTBLTCLRSPACE 0x00000002
475#define VBOXVHWA_CKEYCAPS_DESTBLTCLRSPACEYUV 0x00000004
476#define VBOXVHWA_CKEYCAPS_DESTBLTYUV 0x00000008
477#define VBOXVHWA_CKEYCAPS_DESTOVERLAY 0x00000010
478#define VBOXVHWA_CKEYCAPS_DESTOVERLAYCLRSPACE 0x00000020
479#define VBOXVHWA_CKEYCAPS_DESTOVERLAYCLRSPACEYUV 0x00000040
480#define VBOXVHWA_CKEYCAPS_DESTOVERLAYONEACTIVE 0x00000080
481#define VBOXVHWA_CKEYCAPS_DESTOVERLAYYUV 0x00000100
482#define VBOXVHWA_CKEYCAPS_SRCBLT 0x00000200
483#define VBOXVHWA_CKEYCAPS_SRCBLTCLRSPACE 0x00000400
484#define VBOXVHWA_CKEYCAPS_SRCBLTCLRSPACEYUV 0x00000800
485#define VBOXVHWA_CKEYCAPS_SRCBLTYUV 0x00001000
486#define VBOXVHWA_CKEYCAPS_SRCOVERLAY 0x00002000
487#define VBOXVHWA_CKEYCAPS_SRCOVERLAYCLRSPACE 0x00004000
488#define VBOXVHWA_CKEYCAPS_SRCOVERLAYCLRSPACEYUV 0x00008000
489#define VBOXVHWA_CKEYCAPS_SRCOVERLAYONEACTIVE 0x00010000
490#define VBOXVHWA_CKEYCAPS_SRCOVERLAYYUV 0x00020000
491#define VBOXVHWA_CKEYCAPS_NOCOSTOVERLAY 0x00040000
492
493#define VBOXVHWA_BLT_COLORFILL 0x00000400
494#define VBOXVHWA_BLT_DDFX 0x00000800
495#define VBOXVHWA_BLT_EXTENDED_FLAGS 0x40000000
496#define VBOXVHWA_BLT_EXTENDED_LINEAR_CONTENT 0x00000004
497#define VBOXVHWA_BLT_EXTENDED_PRESENTATION_STRETCHFACTOR 0x00000010
498#define VBOXVHWA_BLT_KEYDESTOVERRIDE 0x00004000
499#define VBOXVHWA_BLT_KEYSRCOVERRIDE 0x00010000
500#define VBOXVHWA_BLT_LAST_PRESENTATION 0x20000000
501#define VBOXVHWA_BLT_PRESENTATION 0x10000000
502#define VBOXVHWA_BLT_ROP 0x00020000
503
504
505#define VBOXVHWA_OVER_DDFX 0x00080000
506#define VBOXVHWA_OVER_HIDE 0x00000200
507#define VBOXVHWA_OVER_KEYDEST 0x00000400
508#define VBOXVHWA_OVER_KEYDESTOVERRIDE 0x00000800
509#define VBOXVHWA_OVER_KEYSRC 0x00001000
510#define VBOXVHWA_OVER_KEYSRCOVERRIDE 0x00002000
511#define VBOXVHWA_OVER_SHOW 0x00004000
512
513#define VBOXVHWA_CKEY_COLORSPACE 0x00000001
514#define VBOXVHWA_CKEY_DESTBLT 0x00000002
515#define VBOXVHWA_CKEY_DESTOVERLAY 0x00000004
516#define VBOXVHWA_CKEY_SRCBLT 0x00000008
517#define VBOXVHWA_CKEY_SRCOVERLAY 0x00000010
518
519#define VBOXVHWA_BLT_ARITHSTRETCHY 0x00000001
520#define VBOXVHWA_BLT_MIRRORLEFTRIGHT 0x00000002
521#define VBOXVHWA_BLT_MIRRORUPDOWN 0x00000004
522
523#define VBOXVHWA_OVERFX_ARITHSTRETCHY 0x00000001
524#define VBOXVHWA_OVERFX_MIRRORLEFTRIGHT 0x00000002
525#define VBOXVHWA_OVERFX_MIRRORUPDOWN 0x00000004
526
527#define VBOXVHWA_CAPS2_CANRENDERWINDOWED 0x00080000
528#define VBOXVHWA_CAPS2_WIDESURFACES 0x00001000
529#define VBOXVHWA_CAPS2_COPYFOURCC 0x00008000
530/*#define VBOXVHWA_CAPS2_FLIPINTERVAL 0x00200000*/
531/*#define VBOXVHWA_CAPS2_FLIPNOVSYNC 0x00400000*/
532
533
534#define VBOXVHWA_OFFSET64_VOID (UINT64_MAX)
535
536typedef struct VBOXVHWA_VERSION
537{
538 uint32_t maj;
539 uint32_t min;
540 uint32_t bld;
541 uint32_t reserved;
542} VBOXVHWA_VERSION;
543
544#define VBOXVHWA_VERSION_INIT(_pv) do { \
545 (_pv)->maj = VBOXVHWA_VERSION_MAJ; \
546 (_pv)->min = VBOXVHWA_VERSION_MIN; \
547 (_pv)->bld = VBOXVHWA_VERSION_BLD; \
548 (_pv)->reserved = VBOXVHWA_VERSION_RSV; \
549 } while(0)
550
551typedef struct VBOXVHWACMD_QUERYINFO1
552{
553 union
554 {
555 struct
556 {
557 VBOXVHWA_VERSION guestVersion;
558 } in;
559
560 struct
561 {
562 uint32_t cfgFlags;
563 uint32_t caps;
564
565 uint32_t caps2;
566 uint32_t colorKeyCaps;
567
568 uint32_t stretchCaps;
569 uint32_t surfaceCaps;
570
571 uint32_t numOverlays;
572 uint32_t curOverlays;
573
574 uint32_t numFourCC;
575 uint32_t reserved;
576 } out;
577 } u;
578} VBOXVHWACMD_QUERYINFO1;
579
580typedef struct VBOXVHWACMD_QUERYINFO2
581{
582 uint32_t numFourCC;
583 uint32_t FourCC[1];
584} VBOXVHWACMD_QUERYINFO2;
585
586#define VBOXVHWAINFO2_SIZE(_cFourCC) RT_OFFSETOF(VBOXVHWACMD_QUERYINFO2, FourCC[_cFourCC])
587
588typedef struct VBOXVHWACMD_SURF_CANCREATE
589{
590 VBOXVHWA_SURFACEDESC SurfInfo;
591 union
592 {
593 struct
594 {
595 uint32_t bIsDifferentPixelFormat;
596 uint32_t Reserved;
597 } in;
598
599 struct
600 {
601 int32_t ErrInfo;
602 } out;
603 } u;
604} VBOXVHWACMD_SURF_CANCREATE;
605
606typedef struct VBOXVHWACMD_SURF_CREATE
607{
608 VBOXVHWA_SURFACEDESC SurfInfo;
609} VBOXVHWACMD_SURF_CREATE;
610
611#ifdef VBOX_WITH_WDDM
612typedef struct VBOXVHWACMD_SURF_GETINFO
613{
614 VBOXVHWA_SURFACEDESC SurfInfo;
615} VBOXVHWACMD_SURF_GETINFO;
616#endif
617
618typedef struct VBOXVHWACMD_SURF_DESTROY
619{
620 union
621 {
622 struct
623 {
624 VBOXVHWA_SURFHANDLE hSurf;
625 } in;
626 } u;
627} VBOXVHWACMD_SURF_DESTROY;
628
629typedef struct VBOXVHWACMD_SURF_LOCK
630{
631 union
632 {
633 struct
634 {
635 VBOXVHWA_SURFHANDLE hSurf;
636 uint64_t offSurface;
637 uint32_t flags;
638 uint32_t rectValid;
639 VBOXVHWA_RECTL rect;
640 } in;
641 } u;
642} VBOXVHWACMD_SURF_LOCK;
643
644typedef struct VBOXVHWACMD_SURF_UNLOCK
645{
646 union
647 {
648 struct
649 {
650 VBOXVHWA_SURFHANDLE hSurf;
651 uint32_t xUpdatedMemValid;
652 uint32_t reserved;
653 VBOXVHWA_RECTL xUpdatedMemRect;
654 } in;
655 } u;
656} VBOXVHWACMD_SURF_UNLOCK;
657
658typedef struct VBOXVHWACMD_SURF_BLT
659{
660 uint64_t DstGuestSurfInfo;
661 uint64_t SrcGuestSurfInfo;
662 union
663 {
664 struct
665 {
666 VBOXVHWA_SURFHANDLE hDstSurf;
667 uint64_t offDstSurface;
668 VBOXVHWA_RECTL dstRect;
669 VBOXVHWA_SURFHANDLE hSrcSurf;
670 uint64_t offSrcSurface;
671 VBOXVHWA_RECTL srcRect;
672 uint32_t flags;
673 uint32_t xUpdatedSrcMemValid;
674 VBOXVHWA_BLTFX desc;
675 VBOXVHWA_RECTL xUpdatedSrcMemRect;
676 } in;
677 } u;
678} VBOXVHWACMD_SURF_BLT;
679
680#ifdef VBOX_WITH_WDDM
681typedef struct VBOXVHWACMD_SURF_COLORFILL
682{
683 union
684 {
685 struct
686 {
687 VBOXVHWA_SURFHANDLE hSurf;
688 uint64_t offSurface;
689 uint32_t u32Reserved;
690 uint32_t cRects;
691 VBOXVHWA_RECTL aRects[1];
692 } in;
693 } u;
694} VBOXVHWACMD_SURF_COLORFILL;
695#endif
696
697typedef struct VBOXVHWACMD_SURF_FLIP
698{
699 uint64_t TargGuestSurfInfo;
700 uint64_t CurrGuestSurfInfo;
701 union
702 {
703 struct
704 {
705 VBOXVHWA_SURFHANDLE hTargSurf;
706 uint64_t offTargSurface;
707 VBOXVHWA_SURFHANDLE hCurrSurf;
708 uint64_t offCurrSurface;
709 uint32_t flags;
710 uint32_t xUpdatedTargMemValid;
711 VBOXVHWA_RECTL xUpdatedTargMemRect;
712 } in;
713 } u;
714} VBOXVHWACMD_SURF_FLIP;
715
716typedef struct VBOXVHWACMD_SURF_COLORKEY_SET
717{
718 union
719 {
720 struct
721 {
722 VBOXVHWA_SURFHANDLE hSurf;
723 uint64_t offSurface;
724 VBOXVHWA_COLORKEY CKey;
725 uint32_t flags;
726 uint32_t reserved;
727 } in;
728 } u;
729} VBOXVHWACMD_SURF_COLORKEY_SET;
730
731#define VBOXVHWACMD_SURF_OVERLAY_UPDATE_F_SRCMEMRECT 0x00000001
732#define VBOXVHWACMD_SURF_OVERLAY_UPDATE_F_DSTMEMRECT 0x00000002
733
734typedef struct VBOXVHWACMD_SURF_OVERLAY_UPDATE
735{
736 union
737 {
738 struct
739 {
740 VBOXVHWA_SURFHANDLE hDstSurf;
741 uint64_t offDstSurface;
742 VBOXVHWA_RECTL dstRect;
743 VBOXVHWA_SURFHANDLE hSrcSurf;
744 uint64_t offSrcSurface;
745 VBOXVHWA_RECTL srcRect;
746 uint32_t flags;
747 uint32_t xFlags;
748 VBOXVHWA_OVERLAYFX desc;
749 VBOXVHWA_RECTL xUpdatedSrcMemRect;
750 VBOXVHWA_RECTL xUpdatedDstMemRect;
751 } in;
752 } u;
753}VBOXVHWACMD_SURF_OVERLAY_UPDATE;
754
755typedef struct VBOXVHWACMD_SURF_OVERLAY_SETPOSITION
756{
757 union
758 {
759 struct
760 {
761 VBOXVHWA_SURFHANDLE hDstSurf;
762 uint64_t offDstSurface;
763 VBOXVHWA_SURFHANDLE hSrcSurf;
764 uint64_t offSrcSurface;
765 uint32_t xPos;
766 uint32_t yPos;
767 uint32_t flags;
768 uint32_t reserved;
769 } in;
770 } u;
771} VBOXVHWACMD_SURF_OVERLAY_SETPOSITION;
772
773typedef struct VBOXVHWACMD_HH_CONSTRUCT
774{
775 void *pVM;
776 /* VRAM info for the backend to be able to properly translate VRAM offsets */
777 void *pvVRAM;
778 uint32_t cbVRAM;
779} VBOXVHWACMD_HH_CONSTRUCT;
780
781typedef struct VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM
782{
783 struct SSMHANDLE * pSSM;
784} VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM;
785
786typedef struct VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM
787{
788 struct SSMHANDLE * pSSM;
789} VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM;
790
791typedef DECLCALLBACK(void) FNVBOXVHWA_HH_CALLBACK(void*);
792typedef FNVBOXVHWA_HH_CALLBACK *PFNVBOXVHWA_HH_CALLBACK;
793
794#define VBOXVHWA_HH_CALLBACK_SET(_pCmd, _pfn, _parg) \
795 do { \
796 (_pCmd)->GuestVBVAReserved1 = (uint64_t)(uintptr_t)(_pfn); \
797 (_pCmd)->GuestVBVAReserved2 = (uint64_t)(uintptr_t)(_parg); \
798 }while(0)
799
800#define VBOXVHWA_HH_CALLBACK_GET(_pCmd) ((PFNVBOXVHWA_HH_CALLBACK)(_pCmd)->GuestVBVAReserved1)
801#define VBOXVHWA_HH_CALLBACK_GET_ARG(_pCmd) ((void*)(_pCmd)->GuestVBVAReserved2)
802
803#pragma pack()
804#endif /* #ifdef VBOX_WITH_VIDEOHWACCEL */
805
806/* All structures are without alignment. */
807#pragma pack(1)
808
809typedef struct VBVAHOSTFLAGS
810{
811 uint32_t u32HostEvents;
812 uint32_t u32SupportedOrders;
813} VBVAHOSTFLAGS;
814
815typedef struct VBVABUFFER
816{
817 VBVAHOSTFLAGS hostFlags;
818
819 /* The offset where the data start in the buffer. */
820 uint32_t off32Data;
821 /* The offset where next data must be placed in the buffer. */
822 uint32_t off32Free;
823
824 /* The queue of record descriptions. */
825 VBVARECORD aRecords[VBVA_MAX_RECORDS];
826 uint32_t indexRecordFirst;
827 uint32_t indexRecordFree;
828
829 /* Space to leave free in the buffer when large partial records are transferred. */
830 uint32_t cbPartialWriteThreshold;
831
832 uint32_t cbData;
833 uint8_t au8Data[1]; /* variable size for the rest of the VBVABUFFER area in VRAM. */
834} VBVABUFFER;
835
836#define VBVA_MAX_RECORD_SIZE (128*_1M)
837
838/* guest->host commands */
839#define VBVA_QUERY_CONF32 1
840#define VBVA_SET_CONF32 2
841#define VBVA_INFO_VIEW 3
842#define VBVA_INFO_HEAP 4
843#define VBVA_FLUSH 5
844#define VBVA_INFO_SCREEN 6
845#define VBVA_ENABLE 7
846#define VBVA_MOUSE_POINTER_SHAPE 8
847#ifdef VBOX_WITH_VIDEOHWACCEL
848# define VBVA_VHWA_CMD 9
849#endif /* # ifdef VBOX_WITH_VIDEOHWACCEL */
850#ifdef VBOX_WITH_VDMA
851# define VBVA_VDMA_CTL 10 /* setup G<->H DMA channel info */
852# define VBVA_VDMA_CMD 11 /* G->H DMA command */
853#endif
854#define VBVA_INFO_CAPS 12 /* informs host about HGSMI caps. see VBVACAPS below */
855#define VBVA_SCANLINE_CFG 13 /* configures scanline, see VBVASCANLINECFG below */
856#define VBVA_SCANLINE_INFO 14 /* requests scanline info, see VBVASCANLINEINFO below */
857#define VBVA_CMDVBVA_SUBMIT 16 /* inform host about VBVA Command submission */
858#define VBVA_CMDVBVA_FLUSH 17 /* inform host about VBVA Command submission */
859#define VBVA_CMDVBVA_CTL 18 /* G->H DMA command */
860#define VBVA_QUERY_MODE_HINTS 19 /* Query most recent mode hints sent. */
861/** Report the guest virtual desktop position and size for mapping host and
862 * guest pointer positions. */
863#define VBVA_REPORT_INPUT_MAPPING 20
864/** Report the guest cursor position and query the host position. */
865#define VBVA_CURSOR_POSITION 21
866
867/* host->guest commands */
868#define VBVAHG_EVENT 1
869#define VBVAHG_DISPLAY_CUSTOM 2
870#ifdef VBOX_WITH_VDMA
871#define VBVAHG_SHGSMI_COMPLETION 3
872#endif
873
874#ifdef VBOX_WITH_VIDEOHWACCEL
875#define VBVAHG_DCUSTOM_VHWA_CMDCOMPLETE 1
876#pragma pack(1)
877typedef struct VBVAHOSTCMDVHWACMDCOMPLETE
878{
879 uint32_t offCmd;
880}VBVAHOSTCMDVHWACMDCOMPLETE;
881#pragma pack()
882#endif /* # ifdef VBOX_WITH_VIDEOHWACCEL */
883
884#pragma pack(1)
885typedef enum
886{
887 VBVAHOSTCMD_OP_EVENT = 1,
888 VBVAHOSTCMD_OP_CUSTOM
889}VBVAHOSTCMD_OP_TYPE;
890
891typedef struct VBVAHOSTCMDEVENT
892{
893 uint64_t pEvent;
894}VBVAHOSTCMDEVENT;
895
896
897typedef struct VBVAHOSTCMD
898{
899 /* destination ID if >=0 specifies display index, otherwize the command is directed to the miniport */
900 int32_t iDstID;
901 int32_t customOpCode;
902 union
903 {
904 struct VBVAHOSTCMD *pNext;
905 uint32_t offNext;
906 uint64_t Data; /* the body is 64-bit aligned */
907 } u;
908 char body[1];
909}VBVAHOSTCMD;
910
911#define VBVAHOSTCMD_SIZE(_size) (sizeof(VBVAHOSTCMD) + (_size))
912#define VBVAHOSTCMD_BODY(_pCmd, _tBody) ((_tBody*)(_pCmd)->body)
913#define VBVAHOSTCMD_HDR(_pBody) ((VBVAHOSTCMD*)(((uint8_t*)_pBody) - RT_OFFSETOF(VBVAHOSTCMD, body)))
914#define VBVAHOSTCMD_HDRSIZE (RT_OFFSETOF(VBVAHOSTCMD, body))
915
916#pragma pack()
917
918/* VBVACONF32::u32Index */
919#define VBOX_VBVA_CONF32_MONITOR_COUNT 0
920#define VBOX_VBVA_CONF32_HOST_HEAP_SIZE 1
921/** Returns VINF_SUCCESS if the host can report mode hints via VBVA.
922 * Set value to VERR_NOT_SUPPORTED before calling. */
923#define VBOX_VBVA_CONF32_MODE_HINT_REPORTING 2
924/** Returns VINF_SUCCESS if the host can report guest cursor enabled status via
925 * VBVA. Set value to VERR_NOT_SUPPORTED before calling. */
926#define VBOX_VBVA_CONF32_GUEST_CURSOR_REPORTING 3
927/** Returns the currently available host cursor capabilities. Available if
928 * VBVACONF32::VBOX_VBVA_CONF32_GUEST_CURSOR_REPORTING returns success.
929 * @see VMMDevReqMouseStatus::mouseFeatures. */
930#define VBOX_VBVA_CONF32_CURSOR_CAPABILITIES 4
931/** Returns the supported flags in VBVAINFOSCREEN::u8Flags. */
932#define VBOX_VBVA_CONF32_SCREEN_FLAGS 5
933/** Returns the max size of VBVA record. */
934#define VBOX_VBVA_CONF32_MAX_RECORD_SIZE 6
935
936typedef struct VBVACONF32
937{
938 uint32_t u32Index;
939 uint32_t u32Value;
940} VBVACONF32;
941
942typedef struct VBVAINFOVIEW
943{
944 /* Index of the screen, assigned by the guest. */
945 uint32_t u32ViewIndex;
946
947 /* The screen offset in VRAM, the framebuffer starts here. */
948 uint32_t u32ViewOffset;
949
950 /* The size of the VRAM memory that can be used for the view. */
951 uint32_t u32ViewSize;
952
953 /* The recommended maximum size of the VRAM memory for the screen. */
954 uint32_t u32MaxScreenSize;
955} VBVAINFOVIEW;
956
957typedef struct VBVAINFOHEAP
958{
959 /* Absolute offset in VRAM of the start of the heap. */
960 uint32_t u32HeapOffset;
961
962 /* The size of the heap. */
963 uint32_t u32HeapSize;
964
965} VBVAINFOHEAP;
966
967typedef struct VBVAFLUSH
968{
969 uint32_t u32Reserved;
970
971} VBVAFLUSH;
972
973typedef struct VBVACMDVBVASUBMIT
974{
975 uint32_t u32Reserved;
976} VBVACMDVBVASUBMIT;
977
978/* flush is requested because due to guest command buffer overflow */
979#define VBVACMDVBVAFLUSH_F_GUEST_BUFFER_OVERFLOW 1
980
981typedef struct VBVACMDVBVAFLUSH
982{
983 uint32_t u32Flags;
984} VBVACMDVBVAFLUSH;
985
986
987/* VBVAINFOSCREEN::u8Flags */
988#define VBVA_SCREEN_F_NONE 0x0000
989#define VBVA_SCREEN_F_ACTIVE 0x0001
990/** The virtual monitor has been disabled by the guest and should be removed
991 * by the host and ignored for purposes of pointer position calculation. */
992#define VBVA_SCREEN_F_DISABLED 0x0002
993/** The virtual monitor has been blanked by the guest and should be blacked
994 * out by the host using width, height, etc values from the VBVAINFOSCREEN request. */
995#define VBVA_SCREEN_F_BLANK 0x0004
996/** The virtual monitor has been blanked by the guest and should be blacked
997 * out by the host using the previous mode values for width. height, etc. */
998#define VBVA_SCREEN_F_BLANK2 0x0008
999
1000typedef struct VBVAINFOSCREEN
1001{
1002 /* Which view contains the screen. */
1003 uint32_t u32ViewIndex;
1004
1005 /* Physical X origin relative to the primary screen. */
1006 int32_t i32OriginX;
1007
1008 /* Physical Y origin relative to the primary screen. */
1009 int32_t i32OriginY;
1010
1011 /* Offset of visible framebuffer relative to the framebuffer start. */
1012 uint32_t u32StartOffset;
1013
1014 /* The scan line size in bytes. */
1015 uint32_t u32LineSize;
1016
1017 /* Width of the screen. */
1018 uint32_t u32Width;
1019
1020 /* Height of the screen. */
1021 uint32_t u32Height;
1022
1023 /* Color depth. */
1024 uint16_t u16BitsPerPixel;
1025
1026 /* VBVA_SCREEN_F_* */
1027 uint16_t u16Flags;
1028} VBVAINFOSCREEN;
1029
1030
1031/* VBVAENABLE::u32Flags */
1032#define VBVA_F_NONE 0x00000000
1033#define VBVA_F_ENABLE 0x00000001
1034#define VBVA_F_DISABLE 0x00000002
1035/* extended VBVA to be used with WDDM */
1036#define VBVA_F_EXTENDED 0x00000004
1037/* vbva offset is absolute VRAM offset */
1038#define VBVA_F_ABSOFFSET 0x00000008
1039
1040typedef struct VBVAENABLE
1041{
1042 uint32_t u32Flags;
1043 uint32_t u32Offset;
1044 int32_t i32Result;
1045} VBVAENABLE;
1046
1047typedef struct VBVAENABLE_EX
1048{
1049 VBVAENABLE Base;
1050 uint32_t u32ScreenId;
1051} VBVAENABLE_EX;
1052
1053
1054typedef struct VBVAMOUSEPOINTERSHAPE
1055{
1056 /* The host result. */
1057 int32_t i32Result;
1058
1059 /* VBOX_MOUSE_POINTER_* bit flags. */
1060 uint32_t fu32Flags;
1061
1062 /* X coordinate of the hot spot. */
1063 uint32_t u32HotX;
1064
1065 /* Y coordinate of the hot spot. */
1066 uint32_t u32HotY;
1067
1068 /* Width of the pointer in pixels. */
1069 uint32_t u32Width;
1070
1071 /* Height of the pointer in scanlines. */
1072 uint32_t u32Height;
1073
1074 /* Pointer data.
1075 *
1076 ****
1077 * The data consists of 1 bpp AND mask followed by 32 bpp XOR (color) mask.
1078 *
1079 * For pointers without alpha channel the XOR mask pixels are 32 bit values: (lsb)BGR0(msb).
1080 * For pointers with alpha channel the XOR mask consists of (lsb)BGRA(msb) 32 bit values.
1081 *
1082 * Guest driver must create the AND mask for pointers with alpha channel, so if host does not
1083 * support alpha, the pointer could be displayed as a normal color pointer. The AND mask can
1084 * be constructed from alpha values. For example alpha value >= 0xf0 means bit 0 in the AND mask.
1085 *
1086 * The AND mask is 1 bpp bitmap with byte aligned scanlines. Size of AND mask,
1087 * therefore, is cbAnd = (width + 7) / 8 * height. The padding bits at the
1088 * end of any scanline are undefined.
1089 *
1090 * The XOR mask follows the AND mask on the next 4 bytes aligned offset:
1091 * uint8_t *pXor = pAnd + (cbAnd + 3) & ~3
1092 * Bytes in the gap between the AND and the XOR mask are undefined.
1093 * XOR mask scanlines have no gap between them and size of XOR mask is:
1094 * cXor = width * 4 * height.
1095 ****
1096 *
1097 * Preallocate 4 bytes for accessing actual data as p->au8Data.
1098 */
1099 uint8_t au8Data[4];
1100
1101} VBVAMOUSEPOINTERSHAPE;
1102
1103/* the guest driver can handle asynch guest cmd completion by reading the command offset from io port */
1104#define VBVACAPS_COMPLETEGCMD_BY_IOREAD 0x00000001
1105/* the guest driver can handle video adapter IRQs */
1106#define VBVACAPS_IRQ 0x00000002
1107/** The guest can read video mode hints sent via VBVA. */
1108#define VBVACAPS_VIDEO_MODE_HINTS 0x00000004
1109/** The guest can switch to a software cursor on demand. */
1110#define VBVACAPS_DISABLE_CURSOR_INTEGRATION 0x00000008
1111/** The guest does not depend on host handling the VBE registers. */
1112#define VBVACAPS_USE_VBVA_ONLY 0x00000010
1113typedef struct VBVACAPS
1114{
1115 int32_t rc;
1116 uint32_t fCaps;
1117} VBVACAPS;
1118
1119/* makes graphics device generate IRQ on VSYNC */
1120#define VBVASCANLINECFG_ENABLE_VSYNC_IRQ 0x00000001
1121/* guest driver may request the current scanline */
1122#define VBVASCANLINECFG_ENABLE_SCANLINE_INFO 0x00000002
1123/* request the current refresh period, returned in u32RefreshPeriodMs */
1124#define VBVASCANLINECFG_QUERY_REFRESH_PERIOD 0x00000004
1125/* set new refresh period specified in u32RefreshPeriodMs.
1126 * if used with VBVASCANLINECFG_QUERY_REFRESH_PERIOD,
1127 * u32RefreshPeriodMs is set to the previous refresh period on return */
1128#define VBVASCANLINECFG_SET_REFRESH_PERIOD 0x00000008
1129
1130typedef struct VBVASCANLINECFG
1131{
1132 int32_t rc;
1133 uint32_t fFlags;
1134 uint32_t u32RefreshPeriodMs;
1135 uint32_t u32Reserved;
1136} VBVASCANLINECFG;
1137
1138typedef struct VBVASCANLINEINFO
1139{
1140 int32_t rc;
1141 uint32_t u32ScreenId;
1142 uint32_t u32InVBlank;
1143 uint32_t u32ScanLine;
1144} VBVASCANLINEINFO;
1145
1146/** Query the most recent mode hints received from the host. */
1147typedef struct VBVAQUERYMODEHINTS
1148{
1149 /** The maximum number of screens to return hints for. */
1150 uint16_t cHintsQueried;
1151 /** The size of the mode hint structures directly following this one. */
1152 uint16_t cbHintStructureGuest;
1153 /** The return code for the operation. Initialise to VERR_NOT_SUPPORTED. */
1154 int32_t rc;
1155} VBVAQUERYMODEHINTS;
1156
1157/** Structure in which a mode hint is returned. The guest allocates an array
1158 * of these immediately after the VBVAQUERYMODEHINTS structure. To accomodate
1159 * future extensions, the VBVAQUERYMODEHINTS structure specifies the size of
1160 * the VBVAMODEHINT structures allocated by the guest, and the host only fills
1161 * out structure elements which fit into that size. The host should fill any
1162 * unused members (e.g. dx, dy) or structure space on the end with ~0. The
1163 * whole structure can legally be set to ~0 to skip a screen. */
1164typedef struct VBVAMODEHINT
1165{
1166 uint32_t magic;
1167 uint32_t cx;
1168 uint32_t cy;
1169 uint32_t cBPP; /* Which has never been used... */
1170 uint32_t cDisplay;
1171 uint32_t dx; /**< X offset into the virtual frame-buffer. */
1172 uint32_t dy; /**< Y offset into the virtual frame-buffer. */
1173 uint32_t fEnabled; /* Not fFlags. Add new members for new flags. */
1174} VBVAMODEHINT;
1175
1176#define VBVAMODEHINT_MAGIC UINT32_C(0x0801add9)
1177
1178/** Report the rectangle relative to which absolute pointer events should be
1179 * expressed. This information remains valid until the next VBVA resize event
1180 * for any screen, at which time it is reset to the bounding rectangle of all
1181 * virtual screens and must be re-set.
1182 * @see VBVA_REPORT_INPUT_MAPPING. */
1183typedef struct VBVAREPORTINPUTMAPPING
1184{
1185 int32_t x; /**< Upper left X co-ordinate relative to the first screen. */
1186 int32_t y; /**< Upper left Y co-ordinate relative to the first screen. */
1187 uint32_t cx; /**< Rectangle width. */
1188 uint32_t cy; /**< Rectangle height. */
1189} VBVAREPORTINPUTMAPPING;
1190
1191/** Report the guest cursor position and query the host one. The host may wish
1192 * to use the guest information to re-position its own cursor (though this is
1193 * currently unlikely).
1194 * @see VBVA_CURSOR_POSITION */
1195typedef struct VBVACURSORPOSITION
1196{
1197 uint32_t fReportPosition; /**< Are we reporting a position? */
1198 uint32_t x; /**< Guest cursor X position */
1199 uint32_t y; /**< Guest cursor Y position */
1200} VBVACURSORPOSITION;
1201
1202#pragma pack()
1203
1204typedef uint64_t VBOXVIDEOOFFSET;
1205
1206#define VBOXVIDEOOFFSET_VOID ((VBOXVIDEOOFFSET)~0)
1207
1208#pragma pack(1)
1209
1210/*
1211 * VBOXSHGSMI made on top HGSMI and allows receiving notifications
1212 * about G->H command completion
1213 */
1214/* SHGSMI command header */
1215typedef struct VBOXSHGSMIHEADER
1216{
1217 uint64_t pvNext; /*<- completion processing queue */
1218 uint32_t fFlags; /*<- see VBOXSHGSMI_FLAG_XXX Flags */
1219 uint32_t cRefs; /*<- command referece count */
1220 uint64_t u64Info1; /*<- contents depends on the fFlags value */
1221 uint64_t u64Info2; /*<- contents depends on the fFlags value */
1222} VBOXSHGSMIHEADER, *PVBOXSHGSMIHEADER;
1223
1224typedef enum
1225{
1226 VBOXVDMACMD_TYPE_UNDEFINED = 0,
1227 VBOXVDMACMD_TYPE_DMA_PRESENT_BLT = 1,
1228 VBOXVDMACMD_TYPE_DMA_BPB_TRANSFER,
1229 VBOXVDMACMD_TYPE_DMA_BPB_FILL,
1230 VBOXVDMACMD_TYPE_DMA_PRESENT_SHADOW2PRIMARY,
1231 VBOXVDMACMD_TYPE_DMA_PRESENT_CLRFILL,
1232 VBOXVDMACMD_TYPE_DMA_PRESENT_FLIP,
1233 VBOXVDMACMD_TYPE_DMA_NOP,
1234 VBOXVDMACMD_TYPE_CHROMIUM_CMD, /* chromium cmd */
1235 VBOXVDMACMD_TYPE_DMA_BPB_TRANSFER_VRAMSYS,
1236 VBOXVDMACMD_TYPE_CHILD_STATUS_IRQ /* make the device notify child (monitor) state change IRQ */
1237} VBOXVDMACMD_TYPE;
1238
1239#pragma pack()
1240
1241/* the command processing was asynch, set by the host to indicate asynch command completion
1242 * must not be cleared once set, the command completion is performed by issuing a host->guest completion command
1243 * while keeping this flag unchanged */
1244#define VBOXSHGSMI_FLAG_HG_ASYNCH 0x00010000
1245#if 0
1246/* if set - asynch completion is performed by issuing the event,
1247 * if cleared - asynch completion is performed by calling a callback */
1248#define VBOXSHGSMI_FLAG_GH_ASYNCH_EVENT 0x00000001
1249#endif
1250/* issue interrupt on asynch completion, used for critical G->H commands,
1251 * i.e. for completion of which guest is waiting. */
1252#define VBOXSHGSMI_FLAG_GH_ASYNCH_IRQ 0x00000002
1253/* guest does not do any op on completion of this command,
1254 * the host may copy the command and indicate that it does not need the command anymore
1255 * by not setting VBOXSHGSMI_FLAG_HG_ASYNCH */
1256#define VBOXSHGSMI_FLAG_GH_ASYNCH_NOCOMPLETION 0x00000004
1257/* guest requires the command to be processed asynchronously,
1258 * not setting VBOXSHGSMI_FLAG_HG_ASYNCH by the host in this case is treated as command failure */
1259#define VBOXSHGSMI_FLAG_GH_ASYNCH_FORCE 0x00000008
1260/* force IRQ on cmd completion */
1261#define VBOXSHGSMI_FLAG_GH_ASYNCH_IRQ_FORCE 0x00000010
1262/* an IRQ-level callback is associated with the command */
1263#define VBOXSHGSMI_FLAG_GH_ASYNCH_CALLBACK_IRQ 0x00000020
1264/* guest expects this command to be completed synchronously */
1265#define VBOXSHGSMI_FLAG_GH_SYNCH 0x00000040
1266
1267
1268DECLINLINE(uint8_t *) VBoxSHGSMIBufferData (const VBOXSHGSMIHEADER* pHeader)
1269{
1270 return (uint8_t *)pHeader + sizeof (VBOXSHGSMIHEADER);
1271}
1272
1273#define VBoxSHGSMIBufferHeaderSize() (sizeof (VBOXSHGSMIHEADER))
1274
1275DECLINLINE(PVBOXSHGSMIHEADER) VBoxSHGSMIBufferHeader (const void *pvData)
1276{
1277 return (PVBOXSHGSMIHEADER)((uint8_t *)pvData - sizeof (VBOXSHGSMIHEADER));
1278}
1279
1280#ifdef VBOX_WITH_VDMA
1281# pragma pack(1)
1282
1283/* VDMA - Video DMA */
1284
1285/* VDMA Control API */
1286/* VBOXVDMA_CTL::u32Flags */
1287typedef enum
1288{
1289 VBOXVDMA_CTL_TYPE_NONE = 0,
1290 VBOXVDMA_CTL_TYPE_ENABLE,
1291 VBOXVDMA_CTL_TYPE_DISABLE,
1292 VBOXVDMA_CTL_TYPE_FLUSH,
1293 VBOXVDMA_CTL_TYPE_WATCHDOG
1294} VBOXVDMA_CTL_TYPE;
1295
1296typedef struct VBOXVDMA_CTL
1297{
1298 VBOXVDMA_CTL_TYPE enmCtl;
1299 uint32_t u32Offset;
1300 int32_t i32Result;
1301} VBOXVDMA_CTL, *PVBOXVDMA_CTL;
1302
1303typedef struct VBOXVDMA_RECTL
1304{
1305 int16_t left;
1306 int16_t top;
1307 uint16_t width;
1308 uint16_t height;
1309} VBOXVDMA_RECTL, *PVBOXVDMA_RECTL;
1310
1311typedef enum
1312{
1313 VBOXVDMA_PIXEL_FORMAT_UNKNOWN = 0,
1314 VBOXVDMA_PIXEL_FORMAT_R8G8B8 = 20,
1315 VBOXVDMA_PIXEL_FORMAT_A8R8G8B8 = 21,
1316 VBOXVDMA_PIXEL_FORMAT_X8R8G8B8 = 22,
1317 VBOXVDMA_PIXEL_FORMAT_R5G6B5 = 23,
1318 VBOXVDMA_PIXEL_FORMAT_X1R5G5B5 = 24,
1319 VBOXVDMA_PIXEL_FORMAT_A1R5G5B5 = 25,
1320 VBOXVDMA_PIXEL_FORMAT_A4R4G4B4 = 26,
1321 VBOXVDMA_PIXEL_FORMAT_R3G3B2 = 27,
1322 VBOXVDMA_PIXEL_FORMAT_A8 = 28,
1323 VBOXVDMA_PIXEL_FORMAT_A8R3G3B2 = 29,
1324 VBOXVDMA_PIXEL_FORMAT_X4R4G4B4 = 30,
1325 VBOXVDMA_PIXEL_FORMAT_A2B10G10R10 = 31,
1326 VBOXVDMA_PIXEL_FORMAT_A8B8G8R8 = 32,
1327 VBOXVDMA_PIXEL_FORMAT_X8B8G8R8 = 33,
1328 VBOXVDMA_PIXEL_FORMAT_G16R16 = 34,
1329 VBOXVDMA_PIXEL_FORMAT_A2R10G10B10 = 35,
1330 VBOXVDMA_PIXEL_FORMAT_A16B16G16R16 = 36,
1331 VBOXVDMA_PIXEL_FORMAT_A8P8 = 40,
1332 VBOXVDMA_PIXEL_FORMAT_P8 = 41,
1333 VBOXVDMA_PIXEL_FORMAT_L8 = 50,
1334 VBOXVDMA_PIXEL_FORMAT_A8L8 = 51,
1335 VBOXVDMA_PIXEL_FORMAT_A4L4 = 52,
1336 VBOXVDMA_PIXEL_FORMAT_V8U8 = 60,
1337 VBOXVDMA_PIXEL_FORMAT_L6V5U5 = 61,
1338 VBOXVDMA_PIXEL_FORMAT_X8L8V8U8 = 62,
1339 VBOXVDMA_PIXEL_FORMAT_Q8W8V8U8 = 63,
1340 VBOXVDMA_PIXEL_FORMAT_V16U16 = 64,
1341 VBOXVDMA_PIXEL_FORMAT_W11V11U10 = 65,
1342 VBOXVDMA_PIXEL_FORMAT_A2W10V10U10 = 67
1343} VBOXVDMA_PIXEL_FORMAT;
1344
1345typedef struct VBOXVDMA_SURF_DESC
1346{
1347 uint32_t width;
1348 uint32_t height;
1349 VBOXVDMA_PIXEL_FORMAT format;
1350 uint32_t bpp;
1351 uint32_t pitch;
1352 uint32_t fFlags;
1353} VBOXVDMA_SURF_DESC, *PVBOXVDMA_SURF_DESC;
1354
1355/*typedef uint64_t VBOXVDMAPHADDRESS;*/
1356typedef uint64_t VBOXVDMASURFHANDLE;
1357
1358/* region specified as a rectangle, otherwize it is a size of memory pointed to by phys address */
1359#define VBOXVDMAOPERAND_FLAGS_RECTL 0x1
1360/* Surface handle is valid */
1361#define VBOXVDMAOPERAND_FLAGS_PRIMARY 0x2
1362/* address is offset in VRAM */
1363#define VBOXVDMAOPERAND_FLAGS_VRAMOFFSET 0x4
1364
1365
1366/* VBOXVDMACBUF_DR::phBuf specifies offset in VRAM */
1367#define VBOXVDMACBUF_FLAG_BUF_VRAM_OFFSET 0x00000001
1368/* command buffer follows the VBOXVDMACBUF_DR in VRAM, VBOXVDMACBUF_DR::phBuf is ignored */
1369#define VBOXVDMACBUF_FLAG_BUF_FOLLOWS_DR 0x00000002
1370
1371/*
1372 * We can not submit the DMA command via VRAM since we do not have control over
1373 * DMA command buffer [de]allocation, i.e. we only control the buffer contents.
1374 * In other words the system may call one of our callbacks to fill a command buffer
1375 * with the necessary commands and then discard the buffer w/o any notification.
1376 *
1377 * We have only DMA command buffer physical address at submission time.
1378 *
1379 * so the only way is to */
1380typedef struct VBOXVDMACBUF_DR
1381{
1382 uint16_t fFlags;
1383 uint16_t cbBuf;
1384 /* RT_SUCCESS() - on success
1385 * VERR_INTERRUPTED - on preemption
1386 * VERR_xxx - on error */
1387 int32_t rc;
1388 union
1389 {
1390 uint64_t phBuf;
1391 VBOXVIDEOOFFSET offVramBuf;
1392 } Location;
1393 uint64_t aGuestData[7];
1394} VBOXVDMACBUF_DR, *PVBOXVDMACBUF_DR;
1395
1396#define VBOXVDMACBUF_DR_TAIL(_pCmd, _t) ( (_t*)(((uint8_t*)(_pCmd)) + sizeof (VBOXVDMACBUF_DR)) )
1397#define VBOXVDMACBUF_DR_FROM_TAIL(_pCmd) ( (VBOXVDMACBUF_DR*)(((uint8_t*)(_pCmd)) - sizeof (VBOXVDMACBUF_DR)) )
1398
1399typedef struct VBOXVDMACMD
1400{
1401 VBOXVDMACMD_TYPE enmType;
1402 uint32_t u32CmdSpecific;
1403} VBOXVDMACMD, *PVBOXVDMACMD;
1404
1405#define VBOXVDMACMD_HEADER_SIZE() sizeof (VBOXVDMACMD)
1406#define VBOXVDMACMD_SIZE_FROMBODYSIZE(_s) (VBOXVDMACMD_HEADER_SIZE() + (_s))
1407#define VBOXVDMACMD_SIZE(_t) (VBOXVDMACMD_SIZE_FROMBODYSIZE(sizeof (_t)))
1408#define VBOXVDMACMD_BODY(_pCmd, _t) ( (_t*)(((uint8_t*)(_pCmd)) + VBOXVDMACMD_HEADER_SIZE()) )
1409#define VBOXVDMACMD_BODY_SIZE(_s) ( (_s) - VBOXVDMACMD_HEADER_SIZE() )
1410#define VBOXVDMACMD_FROM_BODY(_pCmd) ( (VBOXVDMACMD*)(((uint8_t*)(_pCmd)) - VBOXVDMACMD_HEADER_SIZE()) )
1411#define VBOXVDMACMD_BODY_FIELD_OFFSET(_ot, _t, _f) ( (_ot)(uintptr_t)( VBOXVDMACMD_BODY(0, uint8_t) + RT_OFFSETOF(_t, _f) ) )
1412
1413typedef struct VBOXVDMACMD_DMA_PRESENT_BLT
1414{
1415 VBOXVIDEOOFFSET offSrc;
1416 VBOXVIDEOOFFSET offDst;
1417 VBOXVDMA_SURF_DESC srcDesc;
1418 VBOXVDMA_SURF_DESC dstDesc;
1419 VBOXVDMA_RECTL srcRectl;
1420 VBOXVDMA_RECTL dstRectl;
1421 uint32_t u32Reserved;
1422 uint32_t cDstSubRects;
1423 VBOXVDMA_RECTL aDstSubRects[1];
1424} VBOXVDMACMD_DMA_PRESENT_BLT, *PVBOXVDMACMD_DMA_PRESENT_BLT;
1425
1426typedef struct VBOXVDMACMD_DMA_PRESENT_SHADOW2PRIMARY
1427{
1428 VBOXVDMA_RECTL Rect;
1429} VBOXVDMACMD_DMA_PRESENT_SHADOW2PRIMARY, *PVBOXVDMACMD_DMA_PRESENT_SHADOW2PRIMARY;
1430
1431
1432#define VBOXVDMACMD_DMA_BPB_TRANSFER_F_SRC_VRAMOFFSET 0x00000001
1433#define VBOXVDMACMD_DMA_BPB_TRANSFER_F_DST_VRAMOFFSET 0x00000002
1434
1435typedef struct VBOXVDMACMD_DMA_BPB_TRANSFER
1436{
1437 uint32_t cbTransferSize;
1438 uint32_t fFlags;
1439 union
1440 {
1441 uint64_t phBuf;
1442 VBOXVIDEOOFFSET offVramBuf;
1443 } Src;
1444 union
1445 {
1446 uint64_t phBuf;
1447 VBOXVIDEOOFFSET offVramBuf;
1448 } Dst;
1449} VBOXVDMACMD_DMA_BPB_TRANSFER, *PVBOXVDMACMD_DMA_BPB_TRANSFER;
1450
1451#define VBOXVDMACMD_SYSMEMEL_F_PAGELIST 0x00000001
1452
1453typedef struct VBOXVDMACMD_SYSMEMEL
1454{
1455 uint32_t cPages;
1456 uint32_t fFlags;
1457 uint64_t phBuf[1];
1458} VBOXVDMACMD_SYSMEMEL, *PVBOXVDMACMD_SYSMEMEL;
1459
1460#define VBOXVDMACMD_SYSMEMEL_NEXT(_pEl) (((_pEl)->fFlags & VBOXVDMACMD_SYSMEMEL_F_PAGELIST) ? \
1461 ((PVBOXVDMACMD_SYSMEMEL)(((uint8_t*)(_pEl))+RT_OFFSETOF(VBOXVDMACMD_SYSMEMEL, phBuf[(_pEl)->cPages]))) \
1462 : \
1463 ((_pEl)+1)
1464
1465#define VBOXVDMACMD_DMA_BPB_TRANSFER_VRAMSYS_SYS2VRAM 0x00000001
1466
1467typedef struct VBOXVDMACMD_DMA_BPB_TRANSFER_VRAMSYS
1468{
1469 uint32_t cTransferPages;
1470 uint32_t fFlags;
1471 VBOXVIDEOOFFSET offVramBuf;
1472 VBOXVDMACMD_SYSMEMEL FirstEl;
1473} VBOXVDMACMD_DMA_BPB_TRANSFER_VRAMSYS, *PVBOXVDMACMD_DMA_BPB_TRANSFER_VRAMSYS;
1474
1475typedef struct VBOXVDMACMD_DMA_BPB_FILL
1476{
1477 VBOXVIDEOOFFSET offSurf;
1478 uint32_t cbFillSize;
1479 uint32_t u32FillPattern;
1480} VBOXVDMACMD_DMA_BPB_FILL, *PVBOXVDMACMD_DMA_BPB_FILL;
1481
1482#define VBOXVDMA_CHILD_STATUS_F_CONNECTED 0x01
1483#define VBOXVDMA_CHILD_STATUS_F_DISCONNECTED 0x02
1484#define VBOXVDMA_CHILD_STATUS_F_ROTATED 0x04
1485
1486typedef struct VBOXVDMA_CHILD_STATUS
1487{
1488 uint32_t iChild;
1489 uint8_t fFlags;
1490 uint8_t u8RotationAngle;
1491 uint16_t u16Reserved;
1492} VBOXVDMA_CHILD_STATUS, *PVBOXVDMA_CHILD_STATUS;
1493
1494/* apply the aInfos are applied to all targets, the iTarget is ignored */
1495#define VBOXVDMACMD_CHILD_STATUS_IRQ_F_APPLY_TO_ALL 0x00000001
1496
1497typedef struct VBOXVDMACMD_CHILD_STATUS_IRQ
1498{
1499 uint32_t cInfos;
1500 uint32_t fFlags;
1501 VBOXVDMA_CHILD_STATUS aInfos[1];
1502} VBOXVDMACMD_CHILD_STATUS_IRQ, *PVBOXVDMACMD_CHILD_STATUS_IRQ;
1503
1504# pragma pack()
1505#endif /* #ifdef VBOX_WITH_VDMA */
1506
1507#pragma pack(1)
1508typedef struct VBOXVDMACMD_CHROMIUM_BUFFER
1509{
1510 VBOXVIDEOOFFSET offBuffer;
1511 uint32_t cbBuffer;
1512 uint32_t u32GuestData;
1513 uint64_t u64GuestData;
1514} VBOXVDMACMD_CHROMIUM_BUFFER, *PVBOXVDMACMD_CHROMIUM_BUFFER;
1515
1516typedef struct VBOXVDMACMD_CHROMIUM_CMD
1517{
1518 uint32_t cBuffers;
1519 uint32_t u32Reserved;
1520 VBOXVDMACMD_CHROMIUM_BUFFER aBuffers[1];
1521} VBOXVDMACMD_CHROMIUM_CMD, *PVBOXVDMACMD_CHROMIUM_CMD;
1522
1523typedef enum
1524{
1525 VBOXVDMACMD_CHROMIUM_CTL_TYPE_UNKNOWN = 0,
1526 VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP,
1527 VBOXVDMACMD_CHROMIUM_CTL_TYPE_SAVESTATE_BEGIN,
1528 VBOXVDMACMD_CHROMIUM_CTL_TYPE_SAVESTATE_END,
1529 VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP_MAINCB,
1530 VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRCONNECT,
1531 VBOXVDMACMD_CHROMIUM_CTL_TYPE_SIZEHACK = 0x7fffffff
1532} VBOXVDMACMD_CHROMIUM_CTL_TYPE;
1533
1534typedef struct VBOXVDMACMD_CHROMIUM_CTL
1535{
1536 VBOXVDMACMD_CHROMIUM_CTL_TYPE enmType;
1537 uint32_t cbCmd;
1538} VBOXVDMACMD_CHROMIUM_CTL, *PVBOXVDMACMD_CHROMIUM_CTL;
1539
1540
1541typedef struct PDMIDISPLAYVBVACALLBACKS *HCRHGSMICMDCOMPLETION;
1542typedef DECLCALLBACK(int) FNCRHGSMICMDCOMPLETION(HCRHGSMICMDCOMPLETION hCompletion, PVBOXVDMACMD_CHROMIUM_CMD pCmd, int rc);
1543typedef FNCRHGSMICMDCOMPLETION *PFNCRHGSMICMDCOMPLETION;
1544
1545/* tells whether 3D backend has some 3D overlay data displayed */
1546typedef DECLCALLBACK(bool) FNCROGLHASDATA(void);
1547typedef FNCROGLHASDATA *PFNCROGLHASDATA;
1548
1549/* same as PFNCROGLHASDATA, but for specific screen */
1550typedef DECLCALLBACK(bool) FNCROGLHASDATAFORSCREEN(uint32_t i32ScreenID);
1551typedef FNCROGLHASDATAFORSCREEN *PFNCROGLHASDATAFORSCREEN;
1552
1553/* callbacks chrogl gives to main */
1554typedef struct CR_MAIN_INTERFACE
1555{
1556 PFNCROGLHASDATA pfnHasData;
1557 PFNCROGLHASDATAFORSCREEN pfnHasDataForScreen;
1558} CR_MAIN_INTERFACE;
1559
1560typedef struct VBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP_MAINCB
1561{
1562 VBOXVDMACMD_CHROMIUM_CTL Hdr;
1563 /*in*/
1564 HCRHGSMICMDCOMPLETION hCompletion;
1565 PFNCRHGSMICMDCOMPLETION pfnCompletion;
1566 /*out*/
1567 CR_MAIN_INTERFACE MainInterface;
1568} VBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP_MAINCB, *PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP_MAINCB;
1569
1570typedef struct VBOXCRCON_SERVER *HVBOXCRCON_SERVER;
1571typedef struct PDMIDISPLAYVBVACALLBACKS* HVBOXCRCON_CLIENT;
1572
1573typedef struct VBOXCRCON_3DRGN_CLIENT* HVBOXCRCON_3DRGN_CLIENT;
1574typedef struct VBOXCRCON_3DRGN_ASYNCCLIENT* HVBOXCRCON_3DRGN_ASYNCCLIENT;
1575
1576/* server callbacks */
1577/* submit chromium cmd */
1578typedef DECLCALLBACK(int) FNVBOXCRCON_SVR_CRCMD(HVBOXCRCON_SERVER hServer, PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd);
1579typedef FNVBOXCRCON_SVR_CRCMD *PFNVBOXCRCON_SVR_CRCMD;
1580
1581/* submit chromium control cmd */
1582typedef DECLCALLBACK(int) FNVBOXCRCON_SVR_CRCTL(HVBOXCRCON_SERVER hServer, PVBOXVDMACMD_CHROMIUM_CTL pCtl, uint32_t cbCmd);
1583typedef FNVBOXCRCON_SVR_CRCTL *PFNVBOXCRCON_SVR_CRCTL;
1584
1585/* request 3D data.
1586 * The protocol is the following:
1587 * 1. if there is no 3D data displayed on screen, returns VINF_EOF immediately w/o calling any PFNVBOXCRCON_3DRGN_XXX callbacks
1588 * 2. otherwise calls PFNVBOXCRCON_3DRGN_ONSUBMIT, submits the "regions get" request to the CrOpenGL server to process it asynchronously and returns VINF_SUCCESS
1589 * 2.a on "regions get" request processing calls PFNVBOXCRCON_3DRGN_BEGIN,
1590 * 2.b then PFNVBOXCRCON_3DRGN_REPORT zero or more times for each 3D region,
1591 * 2.c and then PFNVBOXCRCON_3DRGN_END
1592 * 3. returns VERR_XXX code on failure
1593 * */
1594typedef DECLCALLBACK(int) FNVBOXCRCON_SVR_3DRGN_GET(HVBOXCRCON_SERVER hServer, HVBOXCRCON_3DRGN_CLIENT hRgnClient, uint32_t idScreen);
1595typedef FNVBOXCRCON_SVR_3DRGN_GET *PFNVBOXCRCON_SVR_3DRGN_GET;
1596
1597/* 3D Regions Client callbacks */
1598/* called from the PFNVBOXCRCON_SVR_3DRGN_GET callback in case server has 3D data and is going to process the request asynchronously,
1599 * see comments for PFNVBOXCRCON_SVR_3DRGN_GET above */
1600typedef DECLCALLBACK(int) FNVBOXCRCON_3DRGN_ONSUBMIT(HVBOXCRCON_3DRGN_CLIENT hRgnClient, uint32_t idScreen, HVBOXCRCON_3DRGN_ASYNCCLIENT *phRgnAsyncClient);
1601typedef FNVBOXCRCON_3DRGN_ONSUBMIT *PFNVBOXCRCON_3DRGN_ONSUBMIT;
1602
1603/* called from the "regions get" command processing thread, to indicate that the "regions get" is started.
1604 * see comments for PFNVBOXCRCON_SVR_3DRGN_GET above */
1605typedef DECLCALLBACK(int) FNVBOXCRCON_3DRGN_BEGIN(HVBOXCRCON_3DRGN_ASYNCCLIENT hRgnAsyncClient, uint32_t idScreen);
1606typedef FNVBOXCRCON_3DRGN_BEGIN *PFNVBOXCRCON_3DRGN_BEGIN;
1607
1608/* called from the "regions get" command processing thread, to report a 3D region.
1609 * see comments for PFNVBOXCRCON_SVR_3DRGN_GET above */
1610typedef DECLCALLBACK(int) FNVBOXCRCON_3DRGN_REPORT(HVBOXCRCON_3DRGN_ASYNCCLIENT hRgnAsyncClient, uint32_t idScreen, void *pvData, uint32_t cbStride, const RTRECT *pRect);
1611typedef FNVBOXCRCON_3DRGN_REPORT *PFNVBOXCRCON_3DRGN_REPORT;
1612
1613/* called from the "regions get" command processing thread, to indicate that the "regions get" is completed.
1614 * see comments for PFNVBOXCRCON_SVR_3DRGN_GET above */
1615typedef DECLCALLBACK(int) FNVBOXCRCON_3DRGN_END(HVBOXCRCON_3DRGN_ASYNCCLIENT hRgnAsyncClient, uint32_t idScreen);
1616typedef FNVBOXCRCON_3DRGN_END *PFNVBOXCRCON_3DRGN_END;
1617
1618
1619/* client callbacks */
1620/* complete chromium cmd */
1621typedef DECLCALLBACK(int) FNVBOXCRCON_CLT_CRCTL_COMPLETE(HVBOXCRCON_CLIENT hClient, PVBOXVDMACMD_CHROMIUM_CTL pCtl, int rc);
1622typedef FNVBOXCRCON_CLT_CRCTL_COMPLETE *PFNVBOXCRCON_CLT_CRCTL_COMPLETE;
1623
1624/* complete chromium control cmd */
1625typedef DECLCALLBACK(int) FNVBOXCRCON_CLT_CRCMD_COMPLETE(HVBOXCRCON_CLIENT hClient, PVBOXVDMACMD_CHROMIUM_CMD pCmd, int rc);
1626typedef FNVBOXCRCON_CLT_CRCMD_COMPLETE *PFNVBOXCRCON_CLT_CRCMD_COMPLETE;
1627
1628typedef struct VBOXCRCON_SERVER_CALLBACKS
1629{
1630 HVBOXCRCON_SERVER hServer;
1631 PFNVBOXCRCON_SVR_CRCMD pfnCrCmd;
1632 PFNVBOXCRCON_SVR_CRCTL pfnCrCtl;
1633 PFNVBOXCRCON_SVR_3DRGN_GET pfn3DRgnGet;
1634} VBOXCRCON_SERVER_CALLBACKS, *PVBOXCRCON_SERVER_CALLBACKS;
1635
1636typedef struct VBOXCRCON_CLIENT_CALLBACKS
1637{
1638 HVBOXCRCON_CLIENT hClient;
1639 PFNVBOXCRCON_CLT_CRCMD_COMPLETE pfnCrCmdComplete;
1640 PFNVBOXCRCON_CLT_CRCTL_COMPLETE pfnCrCtlComplete;
1641 PFNVBOXCRCON_3DRGN_ONSUBMIT pfn3DRgnOnSubmit;
1642 PFNVBOXCRCON_3DRGN_BEGIN pfn3DRgnBegin;
1643 PFNVBOXCRCON_3DRGN_REPORT pfn3DRgnReport;
1644 PFNVBOXCRCON_3DRGN_END pfn3DRgnEnd;
1645} VBOXCRCON_CLIENT_CALLBACKS, *PVBOXCRCON_CLIENT_CALLBACKS;
1646
1647/* issued by Main to establish connection between Main and CrOpenGL service */
1648typedef struct VBOXVDMACMD_CHROMIUM_CTL_CRCONNECT
1649{
1650 VBOXVDMACMD_CHROMIUM_CTL Hdr;
1651 /*input (filled by Client) :*/
1652 /*class VMMDev*/void *pVMMDev;
1653 VBOXCRCON_CLIENT_CALLBACKS ClientCallbacks;
1654 /*output (filled by Server) :*/
1655 VBOXCRCON_SERVER_CALLBACKS ServerCallbacks;
1656} VBOXVDMACMD_CHROMIUM_CTL_CRCONNECT, *PVBOXVDMACMD_CHROMIUM_CTL_CRCONNECT;
1657
1658/* ring command buffer dr */
1659#define VBOXCMDVBVA_STATE_SUBMITTED 1
1660#define VBOXCMDVBVA_STATE_CANCELLED 2
1661#define VBOXCMDVBVA_STATE_IN_PROGRESS 3
1662/* the "completed" state is signalled via the ring buffer values */
1663
1664/* CrHgsmi command */
1665#define VBOXCMDVBVA_OPTYPE_CRCMD 1
1666/* blit command that does blitting of allocations identified by VRAM offset or host id
1667 * for VRAM-offset ones the size and format are same as primary */
1668#define VBOXCMDVBVA_OPTYPE_BLT 2
1669/* flip */
1670#define VBOXCMDVBVA_OPTYPE_FLIP 3
1671/* ColorFill */
1672#define VBOXCMDVBVA_OPTYPE_CLRFILL 4
1673/* allocation paging transfer request */
1674#define VBOXCMDVBVA_OPTYPE_PAGING_TRANSFER 5
1675/* allocation paging fill request */
1676#define VBOXCMDVBVA_OPTYPE_PAGING_FILL 6
1677/* same as VBOXCMDVBVA_OPTYPE_NOP, but contains VBOXCMDVBVA_HDR data */
1678#define VBOXCMDVBVA_OPTYPE_NOPCMD 7
1679/* actual command is stored in guest system memory */
1680#define VBOXCMDVBVA_OPTYPE_SYSMEMCMD 8
1681/* complex command - i.e. can contain multiple commands
1682 * i.e. the VBOXCMDVBVA_OPTYPE_COMPLEXCMD VBOXCMDVBVA_HDR is followed
1683 * by one or more VBOXCMDVBVA_HDR commands.
1684 * Each command's size is specified in it's VBOXCMDVBVA_HDR's u32FenceID field */
1685#define VBOXCMDVBVA_OPTYPE_COMPLEXCMD 9
1686
1687/* nop - is a one-bit command. The buffer size to skip is determined by VBVA buffer size */
1688#define VBOXCMDVBVA_OPTYPE_NOP 0x80
1689
1690/* u8Flags flags */
1691/* transfer from RAM to Allocation */
1692#define VBOXCMDVBVA_OPF_PAGING_TRANSFER_IN 0x80
1693
1694#define VBOXCMDVBVA_OPF_BLT_TYPE_SAMEDIM_A8R8G8B8 0
1695#define VBOXCMDVBVA_OPF_BLT_TYPE_GENERIC_A8R8G8B8 1
1696#define VBOXCMDVBVA_OPF_BLT_TYPE_OFFPRIMSZFMT_OR_ID 2
1697
1698#define VBOXCMDVBVA_OPF_BLT_TYPE_MASK 3
1699
1700
1701#define VBOXCMDVBVA_OPF_CLRFILL_TYPE_GENERIC_A8R8G8B8 0
1702
1703#define VBOXCMDVBVA_OPF_CLRFILL_TYPE_MASK 1
1704
1705
1706/* blit direction is from first operand to second */
1707#define VBOXCMDVBVA_OPF_BLT_DIR_IN_2 0x10
1708/* operand 1 contains host id */
1709#define VBOXCMDVBVA_OPF_OPERAND1_ISID 0x20
1710/* operand 2 contains host id */
1711#define VBOXCMDVBVA_OPF_OPERAND2_ISID 0x40
1712/* primary hint id is src */
1713#define VBOXCMDVBVA_OPF_PRIMARY_HINT_SRC 0x80
1714
1715/* trying to make the header as small as possible,
1716 * we'd have pretty few op codes actually, so 8bit is quite enough,
1717 * we will be able to extend it in any way. */
1718typedef struct VBOXCMDVBVA_HDR
1719{
1720 /* one VBOXCMDVBVA_OPTYPE_XXX, except NOP, see comments above */
1721 uint8_t u8OpCode;
1722 /* command-specific
1723 * VBOXCMDVBVA_OPTYPE_CRCMD - must be null
1724 * VBOXCMDVBVA_OPTYPE_BLT - OR-ed VBOXCMDVBVA_OPF_ALLOC_XXX flags
1725 * VBOXCMDVBVA_OPTYPE_PAGING_TRANSFER - must be null
1726 * VBOXCMDVBVA_OPTYPE_PAGING_FILL - must be null
1727 * VBOXCMDVBVA_OPTYPE_NOPCMD - must be null
1728 * VBOXCMDVBVA_OPTYPE_NOP - not applicable (as the entire VBOXCMDVBVA_HDR is not valid) */
1729 uint8_t u8Flags;
1730 /* one of VBOXCMDVBVA_STATE_XXX*/
1731 volatile uint8_t u8State;
1732 union
1733 {
1734 /* result, 0 on success, otherwise contains the failure code TBD */
1735 int8_t i8Result;
1736 uint8_t u8PrimaryID;
1737 } u;
1738 union
1739 {
1740 /* complex command (VBOXCMDVBVA_OPTYPE_COMPLEXCMD) element data */
1741 struct
1742 {
1743 /* command length */
1744 uint16_t u16CbCmdHost;
1745 /* guest-specific data, host expects it to be NULL */
1746 uint16_t u16CbCmdGuest;
1747 } complexCmdEl;
1748 /* DXGK DDI fence ID */
1749 uint32_t u32FenceID;
1750 } u2;
1751} VBOXCMDVBVA_HDR;
1752
1753typedef uint32_t VBOXCMDVBVAOFFSET;
1754typedef uint64_t VBOXCMDVBVAPHADDR;
1755typedef uint32_t VBOXCMDVBVAPAGEIDX;
1756
1757typedef struct VBOXCMDVBVA_CRCMD_BUFFER
1758{
1759 uint32_t cbBuffer;
1760 VBOXCMDVBVAOFFSET offBuffer;
1761} VBOXCMDVBVA_CRCMD_BUFFER;
1762
1763typedef struct VBOXCMDVBVA_CRCMD_CMD
1764{
1765 uint32_t cBuffers;
1766 VBOXCMDVBVA_CRCMD_BUFFER aBuffers[1];
1767} VBOXCMDVBVA_CRCMD_CMD;
1768
1769typedef struct VBOXCMDVBVA_CRCMD
1770{
1771 VBOXCMDVBVA_HDR Hdr;
1772 VBOXCMDVBVA_CRCMD_CMD Cmd;
1773} VBOXCMDVBVA_CRCMD;
1774
1775typedef struct VBOXCMDVBVA_ALLOCINFO
1776{
1777 union
1778 {
1779 VBOXCMDVBVAOFFSET offVRAM;
1780 uint32_t id;
1781 } u;
1782} VBOXCMDVBVA_ALLOCINFO;
1783
1784typedef struct VBOXCMDVBVA_ALLOCDESC
1785{
1786 VBOXCMDVBVA_ALLOCINFO Info;
1787 uint16_t u16Width;
1788 uint16_t u16Height;
1789} VBOXCMDVBVA_ALLOCDESC;
1790
1791typedef struct VBOXCMDVBVA_RECT
1792{
1793 /** Coordinates of affected rectangle. */
1794 int16_t xLeft;
1795 int16_t yTop;
1796 int16_t xRight;
1797 int16_t yBottom;
1798} VBOXCMDVBVA_RECT;
1799
1800typedef struct VBOXCMDVBVA_POINT
1801{
1802 int16_t x;
1803 int16_t y;
1804} VBOXCMDVBVA_POINT;
1805
1806typedef struct VBOXCMDVBVA_BLT_HDR
1807{
1808 VBOXCMDVBVA_HDR Hdr;
1809 VBOXCMDVBVA_POINT Pos;
1810} VBOXCMDVBVA_BLT_HDR;
1811
1812typedef struct VBOXCMDVBVA_BLT_PRIMARY
1813{
1814 VBOXCMDVBVA_BLT_HDR Hdr;
1815 VBOXCMDVBVA_ALLOCINFO alloc;
1816 /* the rects count is determined from the command size */
1817 VBOXCMDVBVA_RECT aRects[1];
1818} VBOXCMDVBVA_BLT_PRIMARY;
1819
1820typedef struct VBOXCMDVBVA_BLT_PRIMARY_GENERIC_A8R8G8B8
1821{
1822 VBOXCMDVBVA_BLT_HDR Hdr;
1823 VBOXCMDVBVA_ALLOCDESC alloc;
1824 /* the rects count is determined from the command size */
1825 VBOXCMDVBVA_RECT aRects[1];
1826} VBOXCMDVBVA_BLT_PRIMARY_GENERIC_A8R8G8B8;
1827
1828typedef struct VBOXCMDVBVA_BLT_OFFPRIMSZFMT_OR_ID
1829{
1830 VBOXCMDVBVA_BLT_HDR Hdr;
1831 VBOXCMDVBVA_ALLOCINFO alloc;
1832 uint32_t id;
1833 /* the rects count is determined from the command size */
1834 VBOXCMDVBVA_RECT aRects[1];
1835} VBOXCMDVBVA_BLT_OFFPRIMSZFMT_OR_ID;
1836
1837typedef struct VBOXCMDVBVA_BLT_SAMEDIM_A8R8G8B8
1838{
1839 VBOXCMDVBVA_BLT_HDR Hdr;
1840 VBOXCMDVBVA_ALLOCDESC alloc1;
1841 VBOXCMDVBVA_ALLOCINFO info2;
1842 /* the rects count is determined from the command size */
1843 VBOXCMDVBVA_RECT aRects[1];
1844} VBOXCMDVBVA_BLT_SAMEDIM_A8R8G8B8;
1845
1846typedef struct VBOXCMDVBVA_BLT_GENERIC_A8R8G8B8
1847{
1848 VBOXCMDVBVA_BLT_HDR Hdr;
1849 VBOXCMDVBVA_ALLOCDESC alloc1;
1850 VBOXCMDVBVA_ALLOCDESC alloc2;
1851 /* the rects count is determined from the command size */
1852 VBOXCMDVBVA_RECT aRects[1];
1853} VBOXCMDVBVA_BLT_GENERIC_A8R8G8B8;
1854
1855#define VBOXCMDVBVA_SIZEOF_BLTSTRUCT_MAX (sizeof (VBOXCMDVBVA_BLT_GENERIC_A8R8G8B8))
1856
1857typedef struct VBOXCMDVBVA_FLIP
1858{
1859 VBOXCMDVBVA_HDR Hdr;
1860 VBOXCMDVBVA_ALLOCINFO src;
1861 VBOXCMDVBVA_RECT aRects[1];
1862} VBOXCMDVBVA_FLIP;
1863
1864#define VBOXCMDVBVA_SIZEOF_FLIPSTRUCT_MIN (RT_OFFSETOF(VBOXCMDVBVA_FLIP, aRects))
1865
1866typedef struct VBOXCMDVBVA_CLRFILL_HDR
1867{
1868 VBOXCMDVBVA_HDR Hdr;
1869 uint32_t u32Color;
1870} VBOXCMDVBVA_CLRFILL_HDR;
1871
1872typedef struct VBOXCMDVBVA_CLRFILL_PRIMARY
1873{
1874 VBOXCMDVBVA_CLRFILL_HDR Hdr;
1875 VBOXCMDVBVA_RECT aRects[1];
1876} VBOXCMDVBVA_CLRFILL_PRIMARY;
1877
1878typedef struct VBOXCMDVBVA_CLRFILL_GENERIC_A8R8G8B8
1879{
1880 VBOXCMDVBVA_CLRFILL_HDR Hdr;
1881 VBOXCMDVBVA_ALLOCDESC dst;
1882 VBOXCMDVBVA_RECT aRects[1];
1883} VBOXCMDVBVA_CLRFILL_GENERIC_A8R8G8B8;
1884
1885#define VBOXCMDVBVA_SIZEOF_CLRFILLSTRUCT_MAX (sizeof (VBOXCMDVBVA_CLRFILL_GENERIC_A8R8G8B8))
1886
1887#if 0
1888#define VBOXCMDVBVA_SYSMEMEL_CPAGES_MAX 0x1000
1889
1890typedef struct VBOXCMDVBVA_SYSMEMEL
1891{
1892 uint32_t cPagesAfterFirst : 12;
1893 uint32_t iPage1 : 20;
1894 uint32_t iPage2;
1895} VBOXCMDVBVA_SYSMEMEL;
1896#endif
1897
1898typedef struct VBOXCMDVBVA_PAGING_TRANSFER_DATA
1899{
1900 /* for now can only contain offVRAM.
1901 * paging transfer can NOT be initiated for allocations having host 3D object (hostID) associated */
1902 VBOXCMDVBVA_ALLOCINFO Alloc;
1903 VBOXCMDVBVAPAGEIDX aPageNumbers[1];
1904} VBOXCMDVBVA_PAGING_TRANSFER_DATA;
1905
1906typedef struct VBOXCMDVBVA_PAGING_TRANSFER
1907{
1908 VBOXCMDVBVA_HDR Hdr;
1909 VBOXCMDVBVA_PAGING_TRANSFER_DATA Data;
1910} VBOXCMDVBVA_PAGING_TRANSFER;
1911
1912typedef struct VBOXCMDVBVA_PAGING_FILL
1913{
1914 VBOXCMDVBVA_HDR Hdr;
1915 uint32_t u32CbFill;
1916 uint32_t u32Pattern;
1917 /* paging transfer can NOT be initiated for allocations having host 3D object (hostID) associated */
1918 VBOXCMDVBVAOFFSET offVRAM;
1919} VBOXCMDVBVA_PAGING_FILL;
1920
1921typedef struct VBOXCMDVBVA_SYSMEMCMD
1922{
1923 VBOXCMDVBVA_HDR Hdr;
1924 VBOXCMDVBVAPHADDR phCmd;
1925} VBOXCMDVBVA_SYSMEMCMD;
1926
1927#define VBOXCMDVBVACTL_TYPE_ENABLE 1
1928#define VBOXCMDVBVACTL_TYPE_3DCTL 2
1929#define VBOXCMDVBVACTL_TYPE_RESIZE 3
1930
1931typedef struct VBOXCMDVBVA_CTL
1932{
1933 uint32_t u32Type;
1934 int32_t i32Result;
1935} VBOXCMDVBVA_CTL;
1936
1937typedef struct VBOXCMDVBVA_CTL_ENABLE
1938{
1939 VBOXCMDVBVA_CTL Hdr;
1940 VBVAENABLE Enable;
1941} VBOXCMDVBVA_CTL_ENABLE;
1942
1943#define VBOXCMDVBVA_SCREENMAP_SIZE(_elType) ((VBOX_VIDEO_MAX_SCREENS + sizeof (_elType) - 1) / sizeof (_elType))
1944#define VBOXCMDVBVA_SCREENMAP_DECL(_elType, _name) _elType _name[VBOXCMDVBVA_SCREENMAP_SIZE(_elType)]
1945
1946typedef struct VBOXCMDVBVA_RESIZE_ENTRY
1947{
1948 VBVAINFOSCREEN Screen;
1949 VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aTargetMap);
1950} VBOXCMDVBVA_RESIZE_ENTRY;
1951
1952typedef struct VBOXCMDVBVA_RESIZE
1953{
1954 VBOXCMDVBVA_RESIZE_ENTRY aEntries[1];
1955} VBOXCMDVBVA_RESIZE;
1956
1957typedef struct VBOXCMDVBVA_CTL_RESIZE
1958{
1959 VBOXCMDVBVA_CTL Hdr;
1960 VBOXCMDVBVA_RESIZE Resize;
1961} VBOXCMDVBVA_CTL_RESIZE;
1962
1963#define VBOXCMDVBVA3DCTL_TYPE_CONNECT 1
1964#define VBOXCMDVBVA3DCTL_TYPE_DISCONNECT 2
1965#define VBOXCMDVBVA3DCTL_TYPE_CMD 3
1966
1967typedef struct VBOXCMDVBVA_3DCTL
1968{
1969 uint32_t u32Type;
1970 uint32_t u32CmdClientId;
1971} VBOXCMDVBVA_3DCTL;
1972
1973typedef struct VBOXCMDVBVA_3DCTL_CONNECT
1974{
1975 VBOXCMDVBVA_3DCTL Hdr;
1976 uint32_t u32MajorVersion;
1977 uint32_t u32MinorVersion;
1978 uint64_t u64Pid;
1979} VBOXCMDVBVA_3DCTL_CONNECT;
1980
1981typedef struct VBOXCMDVBVA_3DCTL_CMD
1982{
1983 VBOXCMDVBVA_3DCTL Hdr;
1984 VBOXCMDVBVA_HDR Cmd;
1985} VBOXCMDVBVA_3DCTL_CMD;
1986
1987typedef struct VBOXCMDVBVA_CTL_3DCTL_CMD
1988{
1989 VBOXCMDVBVA_CTL Hdr;
1990 VBOXCMDVBVA_3DCTL_CMD Cmd;
1991} VBOXCMDVBVA_CTL_3DCTL_CMD;
1992
1993typedef struct VBOXCMDVBVA_CTL_3DCTL_CONNECT
1994{
1995 VBOXCMDVBVA_CTL Hdr;
1996 VBOXCMDVBVA_3DCTL_CONNECT Connect;
1997} VBOXCMDVBVA_CTL_3DCTL_CONNECT;
1998
1999typedef struct VBOXCMDVBVA_CTL_3DCTL
2000{
2001 VBOXCMDVBVA_CTL Hdr;
2002 VBOXCMDVBVA_3DCTL Ctl;
2003} VBOXCMDVBVA_CTL_3DCTL;
2004
2005#pragma pack()
2006
2007
2008#ifdef VBOXVDMA_WITH_VBVA
2009# pragma pack(1)
2010
2011typedef struct VBOXVDMAVBVACMD
2012{
2013 HGSMIOFFSET offCmd;
2014} VBOXVDMAVBVACMD;
2015
2016#pragma pack()
2017#endif
2018
2019#endif
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