VirtualBox

source: vbox/trunk/src/VBox/Main/include/DisplayImpl.h@ 77370

Last change on this file since 77370 was 77370, checked in by vboxsync, 6 years ago

Device/Graphics, pdm, Main, Front-ends: infrastructure for host software cursor.
bugref:9376: Complete hardware cursor implementation in VMSVGA.
This change provides the infrastructure for letting front-ends report to the
graphics device that they are able to render a pointer cursor at any location,
not just where the host cursor is, and for the device to ask them to do this.
It also provides mediation in Main/Display between multiple front-ends and the
device, and tells the guest that we can always render the cursor. In a
follow-up change the device is expected to add support for rendering the
cursor itself into the frame-buffer image it provides to the front-end if not
all attached front-ends are capable of rendering it.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 28.2 KB
Line 
1/* $Id: DisplayImpl.h 77370 2019-02-20 08:04:38Z vboxsync $ */
2/** @file
3 * VirtualBox COM class implementation
4 */
5
6/*
7 * Copyright (C) 2006-2019 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#ifndef MAIN_INCLUDED_DisplayImpl_h
19#define MAIN_INCLUDED_DisplayImpl_h
20#ifndef RT_WITHOUT_PRAGMA_ONCE
21# pragma once
22#endif
23
24#include "SchemaDefs.h"
25
26#include <iprt/semaphore.h>
27#include <VBox/vmm/pdmdrv.h>
28#include <VBoxVideo.h>
29#include <VBox/vmm/pdmifs.h>
30#include "DisplayWrap.h"
31
32#ifdef VBOX_WITH_CROGL
33# include <VBox/HostServices/VBoxCrOpenGLSvc.h>
34#endif
35
36#include "DisplaySourceBitmapWrap.h"
37#include "GuestScreenInfoWrap.h"
38
39
40class Console;
41
42typedef struct _DISPLAYFBINFO
43{
44 /* The following 3 fields (u32Offset, u32MaxFramebufferSize and u32InformationSize)
45 * are not used by the current HGSMI. They are needed for backward compatibility with
46 * pre-HGSMI additions.
47 */
48 uint32_t u32Offset;
49 uint32_t u32MaxFramebufferSize;
50 uint32_t u32InformationSize;
51
52 ComPtr<IFramebuffer> pFramebuffer;
53 com::Guid framebufferId;
54 ComPtr<IDisplaySourceBitmap> pSourceBitmap;
55 bool fDisabled;
56
57 uint32_t u32Caps;
58
59 struct
60 {
61 ComPtr<IDisplaySourceBitmap> pSourceBitmap;
62 uint8_t *pu8Address;
63 uint32_t cbLine;
64 } updateImage;
65
66 LONG xOrigin;
67 LONG yOrigin;
68
69 ULONG w;
70 ULONG h;
71
72 uint16_t u16BitsPerPixel;
73 uint8_t *pu8FramebufferVRAM;
74 uint32_t u32LineSize;
75
76 uint16_t flags;
77
78 VBOXVIDEOINFOHOSTEVENTS *pHostEvents;
79
80 /** The framebuffer has default format and must be updates immediately. */
81 bool fDefaultFormat;
82
83#ifdef VBOX_WITH_HGSMI
84 bool fVBVAEnabled;
85 bool fVBVAForceResize;
86 bool fRenderThreadMode;
87 VBVAHOSTFLAGS RT_UNTRUSTED_VOLATILE_GUEST *pVBVAHostFlags;
88#endif /* VBOX_WITH_HGSMI */
89
90#ifdef VBOX_WITH_CROGL
91 struct
92 {
93 bool fPending;
94 ULONG x;
95 ULONG y;
96 ULONG width;
97 ULONG height;
98 } pendingViewportInfo;
99#endif /* VBOX_WITH_CROGL */
100
101#ifdef VBOX_WITH_RECORDING
102 struct
103 {
104 ComPtr<IDisplaySourceBitmap> pSourceBitmap;
105 } Recording;
106#endif /* VBOX_WITH_RECORDING */
107} DISPLAYFBINFO;
108
109/* The legacy VBVA (VideoAccel) data.
110 *
111 * Backward compatibility with the guest additions 3.x or older.
112 */
113typedef struct VIDEOACCEL
114{
115 VBVAMEMORY *pVbvaMemory;
116 bool fVideoAccelEnabled;
117
118 uint8_t *pu8VbvaPartial;
119 uint32_t cbVbvaPartial;
120
121 /* Old guest additions (3.x and older) use both VMMDev and DevVGA refresh timer
122 * to process the VBVABUFFER memory. Therefore the legacy VBVA (VideoAccel) host
123 * code can be executed concurrently by VGA refresh timer and the guest VMMDev
124 * request in SMP VMs. The semaphore serialized this.
125 */
126 RTSEMXROADS hXRoadsVideoAccel;
127
128} VIDEOACCEL;
129
130class DisplayMouseInterface
131{
132public:
133 virtual HRESULT i_getScreenResolution(ULONG cScreen, ULONG *pcx,
134 ULONG *pcy, ULONG *pcBPP, LONG *pXOrigin, LONG *pYOrigin) = 0;
135 virtual void i_getFramebufferDimensions(int32_t *px1, int32_t *py1,
136 int32_t *px2, int32_t *py2) = 0;
137 virtual HRESULT i_reportHostCursorCapabilities(uint32_t fCapabilitiesAdded, uint32_t fCapabilitiesRemoved) = 0;
138 virtual HRESULT i_reportHostCursorPosition(int32_t x, int32_t y) = 0;
139 virtual bool i_isInputMappingSet(void) = 0;
140};
141
142class VMMDev;
143
144class ATL_NO_VTABLE Display :
145 public DisplayWrap,
146 public DisplayMouseInterface
147{
148public:
149
150 DECLARE_EMPTY_CTOR_DTOR(Display)
151
152 HRESULT FinalConstruct();
153 void FinalRelease();
154
155 // public initializer/uninitializer for internal purposes only
156 HRESULT init(Console *aParent);
157 void uninit();
158 int i_registerSSM(PUVM pUVM);
159
160 // public methods only for internal purposes
161 int i_handleDisplayResize(unsigned uScreenId, uint32_t bpp, void *pvVRAM,
162 uint32_t cbLine, uint32_t w, uint32_t h, uint16_t flags,
163 int32_t xOrigin, int32_t yOrigin, bool fVGAResize);
164 void i_handleDisplayUpdate(unsigned uScreenId, int x, int y, int w, int h);
165 void i_handleUpdateVMMDevSupportsGraphics(bool fSupportsGraphics);
166 void i_handleUpdateGuestVBVACapabilities(uint32_t fNewCapabilities);
167 void i_handleUpdateVBVAInputMapping(int32_t xOrigin, int32_t yOrigin, uint32_t cx, uint32_t cy);
168#ifdef VBOX_WITH_VIDEOHWACCEL
169 int i_handleVHWACommandProcess(int enmCmd, bool fGuestCmd, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand);
170#endif
171#ifdef VBOX_WITH_CRHGSMI
172 void i_handleCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam);
173 void i_handleCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam);
174 void i_handleCrHgsmiCommandProcess(VBOXVDMACMD_CHROMIUM_CMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd, uint32_t cbCmd);
175 void i_handleCrHgsmiControlProcess(VBOXVDMACMD_CHROMIUM_CTL RT_UNTRUSTED_VOLATILE_GUEST *pCtl, uint32_t cbCtl);
176#endif
177#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
178 int i_handleCrHgcmCtlSubmit(struct VBOXCRCMDCTL RT_UNTRUSTED_VOLATILE_GUEST *pCmd, uint32_t cbCmd,
179 PFNCRCTLCOMPLETION pfnCompletion, void *pvCompletion);
180 void i_handleCrVRecScreenshotPerform(uint32_t uScreen,
181 uint32_t x, uint32_t y, uint32_t uPixelFormat, uint32_t uBitsPerPixel,
182 uint32_t uBytesPerLine, uint32_t uGuestWidth, uint32_t uGuestHeight,
183 uint8_t *pu8BufferAddress, uint64_t uTimestampMs);
184 bool i_handleCrVRecScreenshotBegin(uint32_t uScreen, uint64_t uTimestampMs);
185 void i_handleCrVRecScreenshotEnd(uint32_t uScreen, uint64_t uTimestampMs);
186 void i_handleVRecCompletion();
187#endif
188
189 int i_notifyCroglResize(PCVBVAINFOVIEW pView, PCVBVAINFOSCREEN pScreen, void *pvVRAM);
190
191 int i_saveVisibleRegion(uint32_t cRect, PRTRECT pRect);
192 int i_handleSetVisibleRegion(uint32_t cRect, PRTRECT pRect);
193 int i_handleQueryVisibleRegion(uint32_t *pcRects, PRTRECT paRects);
194
195 void i_VRDPConnectionEvent(bool fConnect);
196 void i_VideoAccelVRDP(bool fEnable, int c);
197
198 /* Legacy video acceleration requests coming from the VGA refresh timer. */
199 int VideoAccelEnableVGA(bool fEnable, VBVAMEMORY *pVbvaMemory);
200
201 /* Legacy video acceleration requests coming from VMMDev. */
202 int VideoAccelEnableVMMDev(bool fEnable, VBVAMEMORY *pVbvaMemory);
203 void VideoAccelFlushVMMDev(void);
204
205 void i_UpdateDeviceCursorCapabilities(void);
206
207#ifdef VBOX_WITH_RECORDING
208 int i_recordingInvalidate(void);
209 void i_recordingScreenChanged(unsigned uScreenId);
210#endif
211
212 void i_notifyPowerDown(void);
213
214 // DisplayMouseInterface methods
215 virtual HRESULT i_getScreenResolution(ULONG cScreen, ULONG *pcx,
216 ULONG *pcy, ULONG *pcBPP, LONG *pXOrigin, LONG *pYOrigin)
217 {
218 return getScreenResolution(cScreen, pcx, pcy, pcBPP, pXOrigin, pYOrigin, NULL);
219 }
220 virtual void i_getFramebufferDimensions(int32_t *px1, int32_t *py1,
221 int32_t *px2, int32_t *py2);
222 virtual HRESULT i_reportHostCursorCapabilities(uint32_t fCapabilitiesAdded, uint32_t fCapabilitiesRemoved);
223 virtual HRESULT i_reportHostCursorPosition(int32_t x, int32_t y);
224 virtual bool i_isInputMappingSet(void)
225 {
226 return cxInputMapping != 0 && cyInputMapping != 0;
227 }
228
229 static const PDMDRVREG DrvReg;
230
231private:
232 // Wrapped IDisplay properties
233 virtual HRESULT getGuestScreenLayout(std::vector<ComPtr<IGuestScreenInfo> > &aGuestScreenLayout);
234
235 // Wrapped IDisplay methods
236 virtual HRESULT getScreenResolution(ULONG aScreenId,
237 ULONG *aWidth,
238 ULONG *aHeight,
239 ULONG *aBitsPerPixel,
240 LONG *aXOrigin,
241 LONG *aYOrigin,
242 GuestMonitorStatus_T *aGuestMonitorStatus);
243 virtual HRESULT attachFramebuffer(ULONG aScreenId,
244 const ComPtr<IFramebuffer> &aFramebuffer,
245 com::Guid &aId);
246 virtual HRESULT detachFramebuffer(ULONG aScreenId,
247 const com::Guid &aId);
248 virtual HRESULT queryFramebuffer(ULONG aScreenId,
249 ComPtr<IFramebuffer> &aFramebuffer);
250 virtual HRESULT setVideoModeHint(ULONG aDisplay,
251 BOOL aEnabled,
252 BOOL aChangeOrigin,
253 LONG aOriginX,
254 LONG aOriginY,
255 ULONG aWidth,
256 ULONG aHeight,
257 ULONG aBitsPerPixel);
258 virtual HRESULT setSeamlessMode(BOOL aEnabled);
259 virtual HRESULT takeScreenShot(ULONG aScreenId,
260 BYTE *aAddress,
261 ULONG aWidth,
262 ULONG aHeight,
263 BitmapFormat_T aBitmapFormat);
264 virtual HRESULT takeScreenShotToArray(ULONG aScreenId,
265 ULONG aWidth,
266 ULONG aHeight,
267 BitmapFormat_T aBitmapFormat,
268 std::vector<BYTE> &aScreenData);
269 virtual HRESULT drawToScreen(ULONG aScreenId,
270 BYTE *aAddress,
271 ULONG aX,
272 ULONG aY,
273 ULONG aWidth,
274 ULONG aHeight);
275 virtual HRESULT invalidateAndUpdate();
276 virtual HRESULT invalidateAndUpdateScreen(ULONG aScreenId);
277 virtual HRESULT completeVHWACommand(BYTE *aCommand);
278 virtual HRESULT viewportChanged(ULONG aScreenId,
279 ULONG aX,
280 ULONG aY,
281 ULONG aWidth,
282 ULONG aHeight);
283 virtual HRESULT querySourceBitmap(ULONG aScreenId,
284 ComPtr<IDisplaySourceBitmap> &aDisplaySourceBitmap);
285 virtual HRESULT notifyScaleFactorChange(ULONG aScreenId,
286 ULONG aScaleFactorWMultiplied,
287 ULONG aScaleFactorHMultiplied);
288 virtual HRESULT notifyHiDPIOutputPolicyChange(BOOL fUnscaledHiDPI);
289 virtual HRESULT setScreenLayout(ScreenLayoutMode_T aScreenLayoutMode,
290 const std::vector<ComPtr<IGuestScreenInfo> > &aGuestScreenInfo);
291 virtual HRESULT detachScreens(const std::vector<LONG> &aScreenIds);
292 virtual HRESULT createGuestScreenInfo(ULONG aDisplay,
293 GuestMonitorStatus_T aStatus,
294 BOOL aPrimary,
295 BOOL aChangeOrigin,
296 LONG aOriginX,
297 LONG aOriginY,
298 ULONG aWidth,
299 ULONG aHeight,
300 ULONG aBitsPerPixel,
301 ComPtr<IGuestScreenInfo> &aGuestScreenInfo);
302
303 // Wrapped IEventListener properties
304
305 // Wrapped IEventListener methods
306 virtual HRESULT handleEvent(const ComPtr<IEvent> &aEvent);
307
308 // other internal methods
309 HRESULT takeScreenShotWorker(ULONG aScreenId,
310 BYTE *aAddress,
311 ULONG aWidth,
312 ULONG aHeight,
313 BitmapFormat_T aBitmapFormat,
314 ULONG *pcbOut);
315 int processVBVAResize(PCVBVAINFOVIEW pView, PCVBVAINFOSCREEN pScreen, void *pvVRAM, bool fResetInputMapping);
316
317#ifdef VBOX_WITH_CRHGSMI
318 void i_setupCrHgsmiData(void);
319 void i_destructCrHgsmiData(void);
320#endif
321
322#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
323 int i_crViewportNotify(ULONG aScreenId, ULONG x, ULONG y, ULONG width, ULONG height);
324#endif
325
326 static DECLCALLBACK(void*) i_drvQueryInterface(PPDMIBASE pInterface, const char *pszIID);
327 static DECLCALLBACK(int) i_drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
328 static DECLCALLBACK(void) i_drvDestruct(PPDMDRVINS pDrvIns);
329 static DECLCALLBACK(void) i_drvPowerOff(PPDMDRVINS pDrvIns);
330 static DECLCALLBACK(int) i_displayResizeCallback(PPDMIDISPLAYCONNECTOR pInterface, uint32_t bpp, void *pvVRAM,
331 uint32_t cbLine, uint32_t cx, uint32_t cy);
332 static DECLCALLBACK(void) i_displayUpdateCallback(PPDMIDISPLAYCONNECTOR pInterface,
333 uint32_t x, uint32_t y, uint32_t cx, uint32_t cy);
334 static DECLCALLBACK(void) i_displayRefreshCallback(PPDMIDISPLAYCONNECTOR pInterface);
335 static DECLCALLBACK(void) i_displayResetCallback(PPDMIDISPLAYCONNECTOR pInterface);
336 static DECLCALLBACK(void) i_displayLFBModeChangeCallback(PPDMIDISPLAYCONNECTOR pInterface, bool fEnabled);
337 static DECLCALLBACK(void) i_displayProcessAdapterDataCallback(PPDMIDISPLAYCONNECTOR pInterface,
338 void *pvVRAM, uint32_t u32VRAMSize);
339 static DECLCALLBACK(void) i_displayProcessDisplayDataCallback(PPDMIDISPLAYCONNECTOR pInterface,
340 void *pvVRAM, unsigned uScreenId);
341
342#ifdef VBOX_WITH_VIDEOHWACCEL
343 static DECLCALLBACK(int) i_displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, int enmCmd, bool fGuestCmd,
344 VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand);
345#endif
346
347#ifdef VBOX_WITH_CRHGSMI
348 static DECLCALLBACK(void) i_displayCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface,
349 VBOXVDMACMD_CHROMIUM_CMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd,
350 uint32_t cbCmd);
351 static DECLCALLBACK(void) i_displayCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface,
352 VBOXVDMACMD_CHROMIUM_CTL RT_UNTRUSTED_VOLATILE_GUEST *pCtl,
353 uint32_t cbCtl);
354
355 static DECLCALLBACK(void) i_displayCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
356 void *pvContext);
357 static DECLCALLBACK(void) i_displayCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
358 void *pvContext);
359#endif
360#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
361 static DECLCALLBACK(int) i_displayCrHgcmCtlSubmit(PPDMIDISPLAYCONNECTOR pInterface, struct VBOXCRCMDCTL *pCmd, uint32_t cbCmd,
362 PFNCRCTLCOMPLETION pfnCompletion, void *pvCompletion);
363 static DECLCALLBACK(void) i_displayCrHgcmCtlSubmitCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
364 void *pvContext);
365#endif
366#ifdef VBOX_WITH_HGSMI
367 static DECLCALLBACK(int) i_displayVBVAEnable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId,
368 VBVAHOSTFLAGS RT_UNTRUSTED_VOLATILE_GUEST *pHostFlags, bool fRenderThreadMode);
369 static DECLCALLBACK(void) i_displayVBVADisable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId);
370 static DECLCALLBACK(void) i_displayVBVAUpdateBegin(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId);
371 static DECLCALLBACK(void) i_displayVBVAUpdateProcess(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId,
372 struct VBVACMDHDR const RT_UNTRUSTED_VOLATILE_GUEST *pCmd, size_t cbCmd);
373 static DECLCALLBACK(void) i_displayVBVAUpdateEnd(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, int32_t x, int32_t y,
374 uint32_t cx, uint32_t cy);
375 static DECLCALLBACK(int) i_displayVBVAResize(PPDMIDISPLAYCONNECTOR pInterface, PCVBVAINFOVIEW pView,
376 PCVBVAINFOSCREEN pScreen, void *pvVRAM,
377 bool fResetInputMapping);
378 static DECLCALLBACK(int) i_displayVBVAMousePointerShape(PPDMIDISPLAYCONNECTOR pInterface, bool fVisible, bool fAlpha,
379 uint32_t xHot, uint32_t yHot, uint32_t cx, uint32_t cy,
380 const void *pvShape);
381 static DECLCALLBACK(void) i_displayVBVAGuestCapabilityUpdate(PPDMIDISPLAYCONNECTOR pInterface, uint32_t fCapabilities);
382
383 static DECLCALLBACK(void) i_displayVBVAInputMappingUpdate(PPDMIDISPLAYCONNECTOR pInterface, int32_t xOrigin, int32_t yOrigin,
384 uint32_t cx, uint32_t cy);
385 static DECLCALLBACK(void) i_displayVBVAReportCursorPosition(PPDMIDISPLAYCONNECTOR pInterface, uint32_t fFlags, uint32_t uScreen, uint32_t x, uint32_t y);
386#endif
387
388#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
389 static DECLCALLBACK(void) i_displayCrVRecScreenshotPerform(void *pvCtx, uint32_t uScreen,
390 uint32_t x, uint32_t y,
391 uint32_t uBitsPerPixel, uint32_t uBytesPerLine,
392 uint32_t uGuestWidth, uint32_t uGuestHeight,
393 uint8_t *pu8BufferAddress, uint64_t u64TimeStamp);
394 static DECLCALLBACK(bool) i_displayCrVRecScreenshotBegin(void *pvCtx, uint32_t uScreen, uint64_t u64TimeStamp);
395 static DECLCALLBACK(void) i_displayCrVRecScreenshotEnd(void *pvCtx, uint32_t uScreen, uint64_t u64TimeStamp);
396
397 static DECLCALLBACK(void) i_displayVRecCompletion(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, int rc, void *pvCompletion);
398#endif
399 static DECLCALLBACK(void) i_displayCrCmdFree(struct VBOXCRCMDCTL *pCmd, uint32_t cbCmd, int rc, void *pvCompletion);
400
401 static DECLCALLBACK(void) i_displaySSMSaveScreenshot(PSSMHANDLE pSSM, void *pvUser);
402 static DECLCALLBACK(int) i_displaySSMLoadScreenshot(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass);
403 static DECLCALLBACK(void) i_displaySSMSave(PSSMHANDLE pSSM, void *pvUser);
404 static DECLCALLBACK(int) i_displaySSMLoad(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass);
405
406 Console * const mParent;
407 /** Pointer to the associated display driver. */
408 struct DRVMAINDISPLAY *mpDrv;
409
410 unsigned mcMonitors;
411 /** Input mapping rectangle top left X relative to the first screen. */
412 int32_t xInputMappingOrigin;
413 /** Input mapping rectangle top left Y relative to the first screen. */
414 int32_t yInputMappingOrigin;
415 uint32_t cxInputMapping; /**< Input mapping rectangle width. */
416 uint32_t cyInputMapping; /**< Input mapping rectangle height. */
417 DISPLAYFBINFO maFramebuffers[SchemaDefs::MaxGuestMonitors];
418 /** Does the VMM device have the "supports graphics" capability set?
419 * Does not go into the saved state as it is refreshed on restore. */
420 bool mfVMMDevSupportsGraphics;
421 /** Mirror of the current guest VBVA capabilities. */
422 uint32_t mfGuestVBVACapabilities;
423 /** Mirror of the current host cursor capabilities. */
424 uint32_t mfHostCursorCapabilities;
425
426 bool mfSourceBitmapEnabled;
427 bool volatile fVGAResizing;
428
429 /** Are we in seamless mode? Not saved, as we exit seamless on saving. */
430 bool mfSeamlessEnabled;
431 /** Last set seamless visible region, number of rectangles. */
432 uint32_t mcRectVisibleRegion;
433 /** Last set seamless visible region, data. Freed on final clean-up. */
434 PRTRECT mpRectVisibleRegion;
435
436 bool mfVideoAccelVRDP;
437 uint32_t mfu32SupportedOrders;
438 /** Number of currently connected VRDP clients. */
439 int32_t volatile mcVRDPRefs;
440
441 /** Accelerate3DEnabled = true && GraphicsControllerType == VBoxVGA. */
442 bool mfIsCr3DEnabled;
443
444#ifdef VBOX_WITH_CROGL
445 bool mfCrOglDataHidden;
446#endif
447
448#ifdef VBOX_WITH_CRHGSMI
449 /* for fast host hgcm calls */
450 HGCMCVSHANDLE mhCrOglSvc;
451 RTCRITSECTRW mCrOglLock;
452#endif
453#ifdef VBOX_WITH_CROGL
454 CR_MAIN_INTERFACE mCrOglCallbacks;
455 volatile uint32_t mfCrOglVideoRecState;
456 CRVBOXHGCMTAKESCREENSHOT mCrOglScreenshotData;
457 VBOXCRCMDCTL_HGCM mCrOglScreenshotCtl;
458#endif
459
460 /* The legacy VBVA data and methods. */
461 VIDEOACCEL mVideoAccelLegacy;
462
463 int i_VideoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory, PPDMIDISPLAYPORT pUpPort);
464 void i_VideoAccelFlush(PPDMIDISPLAYPORT pUpPort);
465 bool i_VideoAccelAllowed(void);
466
467 int i_videoAccelRefreshProcess(PPDMIDISPLAYPORT pUpPort);
468 int i_videoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory, PPDMIDISPLAYPORT pUpPort);
469 int i_videoAccelFlush(PPDMIDISPLAYPORT pUpPort);
470
471 /* Legacy pre-HGSMI handlers. */
472 void processAdapterData(void *pvVRAM, uint32_t u32VRAMSize);
473 void processDisplayData(void *pvVRAM, unsigned uScreenId);
474
475 /** Serializes access to mVideoAccelLegacy and mfVideoAccelVRDP, etc between VRDP and Display. */
476 RTCRITSECT mVideoAccelLock;
477
478#ifdef VBOX_WITH_RECORDING
479 /* Serializes access to video recording source bitmaps. */
480 RTCRITSECT mVideoRecLock;
481 /** Array which defines which screens are being enabled for recording. */
482 bool maRecordingEnabled[SchemaDefs::MaxGuestMonitors];
483#endif
484
485public:
486
487 static int i_displayTakeScreenshotEMT(Display *pDisplay, ULONG aScreenId, uint8_t **ppbData, size_t *pcbData,
488 uint32_t *pcx, uint32_t *pcy, bool *pfMemFree);
489#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
490 static BOOL i_displayCheckTakeScreenshotCrOgl(Display *pDisplay, ULONG aScreenId, uint8_t *pbData,
491 uint32_t u32Width, uint32_t u32Height);
492 int i_crCtlSubmit(struct VBOXCRCMDCTL *pCmd, uint32_t cbCmd, PFNCRCTLCOMPLETION pfnCompletion, void *pvCompletion);
493 int i_crCtlSubmitSync(struct VBOXCRCMDCTL *pCmd, uint32_t cbCmd);
494 /* copies the given command and submits it asynchronously,
495 * i.e. the pCmd data may be discarded right after the call returns */
496 int i_crCtlSubmitAsyncCmdCopy(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd);
497 /* performs synchronous request processing if 3D backend has something to display
498 * this is primarily to work-around 3d<->main thread deadlocks on OSX
499 * in case of async completion, the command is coppied to the allocated buffer,
500 * freeded on command completion
501 * can be used for "notification" commands, when client is not interested in command result,
502 * that must synchronize with 3D backend only when some 3D data is displayed.
503 * The routine does NOT provide any info on whether command is processed asynchronously or not */
504 int i_crCtlSubmitSyncIfHasDataForScreen(uint32_t u32ScreenID, struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd);
505#endif
506
507private:
508 static int i_InvalidateAndUpdateEMT(Display *pDisplay, unsigned uId, bool fUpdateAll);
509 static int i_drawToScreenEMT(Display *pDisplay, ULONG aScreenId, BYTE *address, ULONG x, ULONG y, ULONG width, ULONG height);
510
511 void i_updateGuestGraphicsFacility(void);
512
513#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
514 int i_crOglWindowsShow(bool fShow);
515#endif
516
517#ifdef VBOX_WITH_HGSMI
518 volatile uint32_t mu32UpdateVBVAFlags;
519#endif
520
521private:
522 DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(Display); /* Shuts up MSC warning C4625. */
523};
524
525/* The legacy VBVA helpers. */
526int videoAccelConstruct(VIDEOACCEL *pVideoAccel);
527void videoAccelDestroy(VIDEOACCEL *pVideoAccel);
528void i_vbvaSetMemoryFlags(VBVAMEMORY *pVbvaMemory,
529 bool fVideoAccelEnabled,
530 bool fVideoAccelVRDP,
531 uint32_t fu32SupportedOrders,
532 DISPLAYFBINFO *paFBInfos,
533 unsigned cFBInfos);
534int videoAccelEnterVGA(VIDEOACCEL *pVideoAccel);
535void videoAccelLeaveVGA(VIDEOACCEL *pVideoAccel);
536int videoAccelEnterVMMDev(VIDEOACCEL *pVideoAccel);
537void videoAccelLeaveVMMDev(VIDEOACCEL *pVideoAccel);
538
539
540/* helper function, code in DisplayResampleImage.cpp */
541void BitmapScale32(uint8_t *dst, int dstW, int dstH,
542 const uint8_t *src, int iDeltaLine, int srcW, int srcH);
543
544/* helper function, code in DisplayPNGUtul.cpp */
545int DisplayMakePNG(uint8_t *pbData, uint32_t cx, uint32_t cy,
546 uint8_t **ppu8PNG, uint32_t *pcbPNG, uint32_t *pcxPNG, uint32_t *pcyPNG,
547 uint8_t fLimitSize);
548
549class ATL_NO_VTABLE DisplaySourceBitmap:
550 public DisplaySourceBitmapWrap
551{
552public:
553
554 DECLARE_EMPTY_CTOR_DTOR(DisplaySourceBitmap)
555
556 HRESULT FinalConstruct();
557 void FinalRelease();
558
559 /* Public initializer/uninitializer for internal purposes only. */
560 HRESULT init(ComObjPtr<Display> pDisplay, unsigned uScreenId, DISPLAYFBINFO *pFBInfo);
561 void uninit();
562
563 bool i_usesVRAM(void) { return m.pu8Allocated == NULL; }
564
565private:
566 // wrapped IDisplaySourceBitmap properties
567 virtual HRESULT getScreenId(ULONG *aScreenId);
568
569 // wrapped IDisplaySourceBitmap methods
570 virtual HRESULT queryBitmapInfo(BYTE **aAddress,
571 ULONG *aWidth,
572 ULONG *aHeight,
573 ULONG *aBitsPerPixel,
574 ULONG *aBytesPerLine,
575 BitmapFormat_T *aBitmapFormat);
576
577 int initSourceBitmap(unsigned aScreenId, DISPLAYFBINFO *pFBInfo);
578
579 struct Data
580 {
581 ComObjPtr<Display> pDisplay;
582 unsigned uScreenId;
583 DISPLAYFBINFO *pFBInfo;
584
585 uint8_t *pu8Allocated;
586
587 uint8_t *pu8Address;
588 ULONG ulWidth;
589 ULONG ulHeight;
590 ULONG ulBitsPerPixel;
591 ULONG ulBytesPerLine;
592 BitmapFormat_T bitmapFormat;
593 };
594
595 Data m;
596};
597
598class ATL_NO_VTABLE GuestScreenInfo:
599 public GuestScreenInfoWrap
600{
601public:
602
603 DECLARE_EMPTY_CTOR_DTOR(GuestScreenInfo)
604
605 HRESULT FinalConstruct();
606 void FinalRelease();
607
608 /* Public initializer/uninitializer for internal purposes only. */
609 HRESULT init(ULONG aDisplay,
610 GuestMonitorStatus_T aGuestMonitorStatus,
611 BOOL aPrimary,
612 BOOL aChangeOrigin,
613 LONG aOriginX,
614 LONG aOriginY,
615 ULONG aWidth,
616 ULONG aHeight,
617 ULONG aBitsPerPixel);
618 void uninit();
619
620private:
621 // wrapped IGuestScreenInfo properties
622 virtual HRESULT getScreenId(ULONG *aScreenId);
623 virtual HRESULT getGuestMonitorStatus(GuestMonitorStatus_T *aGuestMonitorStatus);
624 virtual HRESULT getPrimary(BOOL *aPrimary);
625 virtual HRESULT getOrigin(BOOL *aOrigin);
626 virtual HRESULT getOriginX(LONG *aOriginX);
627 virtual HRESULT getOriginY(LONG *aOriginY);
628 virtual HRESULT getWidth(ULONG *aWidth);
629 virtual HRESULT getHeight(ULONG *aHeight);
630 virtual HRESULT getBitsPerPixel(ULONG *aBitsPerPixel);
631 virtual HRESULT getExtendedInfo(com::Utf8Str &aExtendedInfo);
632
633 ULONG mScreenId;
634 GuestMonitorStatus_T mGuestMonitorStatus;
635 BOOL mPrimary;
636 BOOL mOrigin;
637 LONG mOriginX;
638 LONG mOriginY;
639 ULONG mWidth;
640 ULONG mHeight;
641 ULONG mBitsPerPixel;
642};
643
644#endif /* !MAIN_INCLUDED_DisplayImpl_h */
645/* vi: set tabstop=4 shiftwidth=4 expandtab: */
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