VirtualBox

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

Last change on this file since 70335 was 70075, checked in by vboxsync, 7 years ago

Devices/Graphics, Main, FE/Qt: add plumbing for sending cursor position events.
bugref:9038: FE/Qt: better handle mouse cursor when toggling integration
The Linux and X11 graphics driver sends notification when the guest cursor
position changes. This could be used by the front-end to switch back to
pointer capturing without requiring that the guest draw the cursor, which
often results in artifacts. This change adds the necessary plumbing between
the graphics device and the user interface.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 26.6 KB
Line 
1/* $Id: DisplayImpl.h 70075 2017-12-12 09:54:21Z vboxsync $ */
2/** @file
3 * VirtualBox COM class implementation
4 */
5
6/*
7 * Copyright (C) 2006-2017 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 ____H_DISPLAYIMPL
19#define ____H_DISPLAYIMPL
20
21#include "SchemaDefs.h"
22
23#include <iprt/semaphore.h>
24#include <VBox/vmm/pdmdrv.h>
25#include <VBox/VMMDev.h>
26#include <VBoxVideo.h>
27#include <VBox/vmm/pdmifs.h>
28#include "DisplayWrap.h"
29
30#ifdef VBOX_WITH_CROGL
31# include <VBox/HostServices/VBoxCrOpenGLSvc.h>
32#endif
33
34#ifdef VBOX_WITH_VIDEOREC
35# include "../src-client/VideoRec.h"
36struct VIDEORECCONTEXT;
37#endif
38
39#include "DisplaySourceBitmapWrap.h"
40
41
42class Console;
43
44typedef struct _DISPLAYFBINFO
45{
46 /* The following 3 fields (u32Offset, u32MaxFramebufferSize and u32InformationSize)
47 * are not used by the current HGSMI. They are needed for backward compatibility with
48 * pre-HGSMI additions.
49 */
50 uint32_t u32Offset;
51 uint32_t u32MaxFramebufferSize;
52 uint32_t u32InformationSize;
53
54 ComPtr<IFramebuffer> pFramebuffer;
55 com::Guid framebufferId;
56 ComPtr<IDisplaySourceBitmap> pSourceBitmap;
57 bool fDisabled;
58
59 uint32_t u32Caps;
60
61 struct
62 {
63 ComPtr<IDisplaySourceBitmap> pSourceBitmap;
64 uint8_t *pu8Address;
65 uint32_t cbLine;
66 } updateImage;
67
68 LONG xOrigin;
69 LONG yOrigin;
70
71 ULONG w;
72 ULONG h;
73
74 uint16_t u16BitsPerPixel;
75 uint8_t *pu8FramebufferVRAM;
76 uint32_t u32LineSize;
77
78 uint16_t flags;
79
80 VBOXVIDEOINFOHOSTEVENTS *pHostEvents;
81
82 /** The framebuffer has default format and must be updates immediately. */
83 bool fDefaultFormat;
84
85#ifdef VBOX_WITH_HGSMI
86 bool fVBVAEnabled;
87 bool fVBVAForceResize;
88 bool fRenderThreadMode;
89 PVBVAHOSTFLAGS pVBVAHostFlags;
90#endif /* VBOX_WITH_HGSMI */
91
92#ifdef VBOX_WITH_CROGL
93 struct
94 {
95 bool fPending;
96 ULONG x;
97 ULONG y;
98 ULONG width;
99 ULONG height;
100 } pendingViewportInfo;
101#endif /* VBOX_WITH_CROGL */
102
103#ifdef VBOX_WITH_VIDEOREC
104 struct
105 {
106 ComPtr<IDisplaySourceBitmap> pSourceBitmap;
107 } videoRec;
108#endif /* VBOX_WITH_VIDEOREC */
109} DISPLAYFBINFO;
110
111/* The legacy VBVA (VideoAccel) data.
112 *
113 * Backward compatibility with the guest additions 3.x or older.
114 */
115typedef struct VIDEOACCEL
116{
117 VBVAMEMORY *pVbvaMemory;
118 bool fVideoAccelEnabled;
119
120 uint8_t *pu8VbvaPartial;
121 uint32_t cbVbvaPartial;
122
123 /* Old guest additions (3.x and older) use both VMMDev and DevVGA refresh timer
124 * to process the VBVABUFFER memory. Therefore the legacy VBVA (VideoAccel) host
125 * code can be executed concurrently by VGA refresh timer and the guest VMMDev
126 * request in SMP VMs. The semaphore serialized this.
127 */
128 RTSEMXROADS hXRoadsVideoAccel;
129
130} VIDEOACCEL;
131
132class DisplayMouseInterface
133{
134public:
135 virtual HRESULT i_getScreenResolution(ULONG cScreen, ULONG *pcx,
136 ULONG *pcy, ULONG *pcBPP, LONG *pXOrigin, LONG *pYOrigin) = 0;
137 virtual void i_getFramebufferDimensions(int32_t *px1, int32_t *py1,
138 int32_t *px2, int32_t *py2) = 0;
139 virtual HRESULT i_reportHostCursorCapabilities(uint32_t fCapabilitiesAdded, uint32_t fCapabilitiesRemoved) = 0;
140 virtual HRESULT i_reportHostCursorPosition(int32_t x, int32_t y) = 0;
141 virtual bool i_isInputMappingSet(void) = 0;
142};
143
144class VMMDev;
145
146class ATL_NO_VTABLE Display :
147 public DisplayWrap,
148 public DisplayMouseInterface
149{
150public:
151
152 DECLARE_EMPTY_CTOR_DTOR(Display)
153
154 HRESULT FinalConstruct();
155 void FinalRelease();
156
157 // public initializer/uninitializer for internal purposes only
158 HRESULT init(Console *aParent);
159 void uninit();
160 int i_registerSSM(PUVM pUVM);
161
162 // public methods only for internal purposes
163 int i_handleDisplayResize(unsigned uScreenId, uint32_t bpp, void *pvVRAM,
164 uint32_t cbLine, uint32_t w, uint32_t h, uint16_t flags,
165 int32_t xOrigin, int32_t yOrigin, bool fVGAResize);
166 void i_handleDisplayUpdate(unsigned uScreenId, int x, int y, int w, int h);
167 void i_handleUpdateVMMDevSupportsGraphics(bool fSupportsGraphics);
168 void i_handleUpdateGuestVBVACapabilities(uint32_t fNewCapabilities);
169 void i_handleUpdateVBVAInputMapping(int32_t xOrigin, int32_t yOrigin, uint32_t cx, uint32_t cy);
170#ifdef VBOX_WITH_VIDEOHWACCEL
171 int i_handleVHWACommandProcess(PVBOXVHWACMD pCommand);
172#endif
173#ifdef VBOX_WITH_CRHGSMI
174 void i_handleCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam);
175 void i_handleCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam);
176 void i_handleCrHgsmiCommandProcess(PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd);
177 void i_handleCrHgsmiControlProcess(PVBOXVDMACMD_CHROMIUM_CTL pCtl, uint32_t cbCtl);
178#endif
179#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
180 int i_handleCrHgcmCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd,
181 PFNCRCTLCOMPLETION pfnCompletion,
182 void *pvCompletion);
183 void i_handleCrVRecScreenshotPerform(uint32_t uScreen,
184 uint32_t x, uint32_t y, uint32_t uPixelFormat, uint32_t uBitsPerPixel,
185 uint32_t uBytesPerLine, uint32_t uGuestWidth, uint32_t uGuestHeight,
186 uint8_t *pu8BufferAddress, uint64_t u64TimeStamp);
187 /** @todo r=bird: u64TimeStamp - using the 'u64' prefix add nothing.
188 * However, using one of the prefixes indicating the timestamp unit
189 * would be very valuable! */
190 bool i_handleCrVRecScreenshotBegin(uint32_t uScreen, uint64_t u64TimeStamp);
191 void i_handleCrVRecScreenshotEnd(uint32_t uScreen, uint64_t u64TimeStamp);
192 void i_handleVRecCompletion();
193#endif
194
195 int i_notifyCroglResize(PCVBVAINFOVIEW pView, PCVBVAINFOSCREEN pScreen, void *pvVRAM);
196
197 int i_saveVisibleRegion(uint32_t cRect, PRTRECT pRect);
198 int i_handleSetVisibleRegion(uint32_t cRect, PRTRECT pRect);
199 int i_handleQueryVisibleRegion(uint32_t *pcRects, PRTRECT paRects);
200
201 void i_VideoAccelVRDP(bool fEnable);
202
203 /* Legacy video acceleration requests coming from the VGA refresh timer. */
204 int VideoAccelEnableVGA(bool fEnable, VBVAMEMORY *pVbvaMemory);
205
206 /* Legacy video acceleration requests coming from VMMDev. */
207 int VideoAccelEnableVMMDev(bool fEnable, VBVAMEMORY *pVbvaMemory);
208 void VideoAccelFlushVMMDev(void);
209
210#ifdef VBOX_WITH_VIDEOREC
211 PVIDEORECCFG i_videoRecGetConfig(void) { return &mVideoRecCfg; }
212 VIDEORECFEATURES i_videoRecGetEnabled(void);
213 bool i_videoRecStarted(void);
214# ifdef VBOX_WITH_AUDIO_VIDEOREC
215 int i_videoRecConfigureAudioDriver(const Utf8Str& strAdapter, unsigned uInstance, unsigned uLUN, bool fAttach);
216# endif
217 static DECLCALLBACK(int) i_videoRecConfigure(Display *pThis, PVIDEORECCFG pCfg, bool fAttachDetach, unsigned *puLUN);
218 int i_videoRecSendAudio(const void *pvData, size_t cbData, uint64_t uDurationMs);
219 int i_videoRecStart(void);
220 void i_videoRecStop(void);
221 void i_videoRecScreenChanged(unsigned uScreenId);
222#endif
223
224 void i_notifyPowerDown(void);
225
226 // DisplayMouseInterface methods
227 virtual HRESULT i_getScreenResolution(ULONG cScreen, ULONG *pcx,
228 ULONG *pcy, ULONG *pcBPP, LONG *pXOrigin, LONG *pYOrigin)
229 {
230 return getScreenResolution(cScreen, pcx, pcy, pcBPP, pXOrigin, pYOrigin, NULL);
231 }
232 virtual void i_getFramebufferDimensions(int32_t *px1, int32_t *py1,
233 int32_t *px2, int32_t *py2);
234 virtual HRESULT i_reportHostCursorCapabilities(uint32_t fCapabilitiesAdded, uint32_t fCapabilitiesRemoved);
235 virtual HRESULT i_reportHostCursorPosition(int32_t x, int32_t y);
236 virtual bool i_isInputMappingSet(void)
237 {
238 return cxInputMapping != 0 && cyInputMapping != 0;
239 }
240
241 static const PDMDRVREG DrvReg;
242
243private:
244 // Wrapped IDisplay properties
245 virtual HRESULT getGuestScreenLayout(std::vector<ComPtr<IGuestScreenInfo> > &aGuestScreenLayout);
246
247 // Wrapped IDisplay methods
248 virtual HRESULT getScreenResolution(ULONG aScreenId,
249 ULONG *aWidth,
250 ULONG *aHeight,
251 ULONG *aBitsPerPixel,
252 LONG *aXOrigin,
253 LONG *aYOrigin,
254 GuestMonitorStatus_T *aGuestMonitorStatus);
255 virtual HRESULT attachFramebuffer(ULONG aScreenId,
256 const ComPtr<IFramebuffer> &aFramebuffer,
257 com::Guid &aId);
258 virtual HRESULT detachFramebuffer(ULONG aScreenId,
259 const com::Guid &aId);
260 virtual HRESULT queryFramebuffer(ULONG aScreenId,
261 ComPtr<IFramebuffer> &aFramebuffer);
262 virtual HRESULT setVideoModeHint(ULONG aDisplay,
263 BOOL aEnabled,
264 BOOL aChangeOrigin,
265 LONG aOriginX,
266 LONG aOriginY,
267 ULONG aWidth,
268 ULONG aHeight,
269 ULONG aBitsPerPixel);
270 virtual HRESULT setSeamlessMode(BOOL aEnabled);
271 virtual HRESULT takeScreenShot(ULONG aScreenId,
272 BYTE *aAddress,
273 ULONG aWidth,
274 ULONG aHeight,
275 BitmapFormat_T aBitmapFormat);
276 virtual HRESULT takeScreenShotToArray(ULONG aScreenId,
277 ULONG aWidth,
278 ULONG aHeight,
279 BitmapFormat_T aBitmapFormat,
280 std::vector<BYTE> &aScreenData);
281 virtual HRESULT drawToScreen(ULONG aScreenId,
282 BYTE *aAddress,
283 ULONG aX,
284 ULONG aY,
285 ULONG aWidth,
286 ULONG aHeight);
287 virtual HRESULT invalidateAndUpdate();
288 virtual HRESULT invalidateAndUpdateScreen(ULONG aScreenId);
289 virtual HRESULT completeVHWACommand(BYTE *aCommand);
290 virtual HRESULT viewportChanged(ULONG aScreenId,
291 ULONG aX,
292 ULONG aY,
293 ULONG aWidth,
294 ULONG aHeight);
295 virtual HRESULT querySourceBitmap(ULONG aScreenId,
296 ComPtr<IDisplaySourceBitmap> &aDisplaySourceBitmap);
297 virtual HRESULT notifyScaleFactorChange(ULONG aScreenId,
298 ULONG aScaleFactorWMultiplied,
299 ULONG aScaleFactorHMultiplied);
300 virtual HRESULT notifyHiDPIOutputPolicyChange(BOOL fUnscaledHiDPI);
301 virtual HRESULT setScreenLayout(ScreenLayoutMode_T aScreenLayoutMode,
302 const std::vector<ComPtr<IGuestScreenInfo> > &aGuestScreenInfo);
303 virtual HRESULT detachScreens(const std::vector<LONG> &aScreenIds);
304
305 // Wrapped IEventListener properties
306
307 // Wrapped IEventListener methods
308 virtual HRESULT handleEvent(const ComPtr<IEvent> &aEvent);
309
310 // other internal methods
311 HRESULT takeScreenShotWorker(ULONG aScreenId,
312 BYTE *aAddress,
313 ULONG aWidth,
314 ULONG aHeight,
315 BitmapFormat_T aBitmapFormat,
316 ULONG *pcbOut);
317 int processVBVAResize(PCVBVAINFOVIEW pView, PCVBVAINFOSCREEN pScreen, void *pvVRAM, bool fResetInputMapping);
318
319#ifdef VBOX_WITH_CRHGSMI
320 void i_setupCrHgsmiData(void);
321 void i_destructCrHgsmiData(void);
322#endif
323
324#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
325 int i_crViewportNotify(ULONG aScreenId, ULONG x, ULONG y, ULONG width, ULONG height);
326#endif
327
328 static DECLCALLBACK(void*) i_drvQueryInterface(PPDMIBASE pInterface, const char *pszIID);
329 static DECLCALLBACK(int) i_drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
330 static DECLCALLBACK(void) i_drvDestruct(PPDMDRVINS pDrvIns);
331 static DECLCALLBACK(int) i_displayResizeCallback(PPDMIDISPLAYCONNECTOR pInterface, uint32_t bpp, void *pvVRAM,
332 uint32_t cbLine, uint32_t cx, uint32_t cy);
333 static DECLCALLBACK(void) i_displayUpdateCallback(PPDMIDISPLAYCONNECTOR pInterface,
334 uint32_t x, uint32_t y, uint32_t cx, uint32_t cy);
335 static DECLCALLBACK(void) i_displayRefreshCallback(PPDMIDISPLAYCONNECTOR pInterface);
336 static DECLCALLBACK(void) i_displayResetCallback(PPDMIDISPLAYCONNECTOR pInterface);
337 static DECLCALLBACK(void) i_displayLFBModeChangeCallback(PPDMIDISPLAYCONNECTOR pInterface, bool fEnabled);
338 static DECLCALLBACK(void) i_displayProcessAdapterDataCallback(PPDMIDISPLAYCONNECTOR pInterface,
339 void *pvVRAM, uint32_t u32VRAMSize);
340 static DECLCALLBACK(void) i_displayProcessDisplayDataCallback(PPDMIDISPLAYCONNECTOR pInterface,
341 void *pvVRAM, unsigned uScreenId);
342
343#ifdef VBOX_WITH_VIDEOHWACCEL
344 static DECLCALLBACK(int) i_displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand);
345#endif
346
347#ifdef VBOX_WITH_CRHGSMI
348 static DECLCALLBACK(void) i_displayCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface,
349 PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd);
350 static DECLCALLBACK(void) i_displayCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCtl,
351 uint32_t cbCtl);
352
353 static DECLCALLBACK(void) i_displayCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
354 void *pvContext);
355 static DECLCALLBACK(void) i_displayCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
356 void *pvContext);
357#endif
358#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
359 static DECLCALLBACK(int) i_displayCrHgcmCtlSubmit(PPDMIDISPLAYCONNECTOR pInterface,
360 struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd,
361 PFNCRCTLCOMPLETION pfnCompletion,
362 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 PVBVAHOSTFLAGS 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 PCVBVACMDHDR 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, bool fData, 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 int32_t volatile mcVideoAccelVRDPRefs;
439
440 /** Accelerate3DEnabled = true && GraphicsControllerType == VBoxVGA. */
441 bool mfIsCr3DEnabled;
442
443#ifdef VBOX_WITH_CROGL
444 bool mfCrOglDataHidden;
445#endif
446
447#ifdef VBOX_WITH_CRHGSMI
448 /* for fast host hgcm calls */
449 HGCMCVSHANDLE mhCrOglSvc;
450 RTCRITSECTRW mCrOglLock;
451#endif
452#ifdef VBOX_WITH_CROGL
453 CR_MAIN_INTERFACE mCrOglCallbacks;
454 volatile uint32_t mfCrOglVideoRecState;
455 CRVBOXHGCMTAKESCREENSHOT mCrOglScreenshotData;
456 VBOXCRCMDCTL_HGCM mCrOglScreenshotCtl;
457#endif
458
459 /* The legacy VBVA data and methods. */
460 VIDEOACCEL mVideoAccelLegacy;
461
462 int i_VideoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory, PPDMIDISPLAYPORT pUpPort);
463 void i_VideoAccelFlush(PPDMIDISPLAYPORT pUpPort);
464 bool i_VideoAccelAllowed(void);
465
466 int i_videoAccelRefreshProcess(PPDMIDISPLAYPORT pUpPort);
467 int i_videoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory, PPDMIDISPLAYPORT pUpPort);
468 int i_videoAccelFlush(PPDMIDISPLAYPORT pUpPort);
469
470 /* Legacy pre-HGSMI handlers. */
471 void processAdapterData(void *pvVRAM, uint32_t u32VRAMSize);
472 void processDisplayData(void *pvVRAM, unsigned uScreenId);
473
474 /** Serializes access to mVideoAccelLegacy and mfVideoAccelVRDP, etc between VRDP and Display. */
475 RTCRITSECT mVideoAccelLock;
476
477#ifdef VBOX_WITH_VIDEOREC
478 /* Serializes access to video recording source bitmaps. */
479 RTCRITSECT mVideoRecLock;
480 /** The current video recording configuration being used. */
481 VIDEORECCFG mVideoRecCfg;
482 /** The video recording context. */
483 VIDEORECCONTEXT *mpVideoRecCtx;
484 /** Array which defines which screens are being enabled for recording. */
485 bool maVideoRecEnabled[SchemaDefs::MaxGuestMonitors];
486#endif
487
488public:
489
490 static int i_displayTakeScreenshotEMT(Display *pDisplay, ULONG aScreenId, uint8_t **ppbData, size_t *pcbData,
491 uint32_t *pcx, uint32_t *pcy, bool *pfMemFree);
492#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
493 static BOOL i_displayCheckTakeScreenshotCrOgl(Display *pDisplay, ULONG aScreenId, uint8_t *pbData,
494 uint32_t u32Width, uint32_t u32Height);
495 int i_crCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, PFNCRCTLCOMPLETION pfnCompletion, void *pvCompletion);
496 int i_crCtlSubmitSync(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd);
497 /* copies the given command and submits it asynchronously,
498 * i.e. the pCmd data may be discarded right after the call returns */
499 int i_crCtlSubmitAsyncCmdCopy(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd);
500 /* performs synchronous request processing if 3D backend has something to display
501 * this is primarily to work-around 3d<->main thread deadlocks on OSX
502 * in case of async completion, the command is coppied to the allocated buffer,
503 * freeded on command completion
504 * can be used for "notification" commands, when client is not interested in command result,
505 * that must synchronize with 3D backend only when some 3D data is displayed.
506 * The routine does NOT provide any info on whether command is processed asynchronously or not */
507 int i_crCtlSubmitSyncIfHasDataForScreen(uint32_t u32ScreenID, struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd);
508#endif
509
510private:
511 static int i_InvalidateAndUpdateEMT(Display *pDisplay, unsigned uId, bool fUpdateAll);
512 static int i_drawToScreenEMT(Display *pDisplay, ULONG aScreenId, BYTE *address, ULONG x, ULONG y, ULONG width, ULONG height);
513
514 void i_updateGuestGraphicsFacility(void);
515
516#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
517 int i_crOglWindowsShow(bool fShow);
518#endif
519
520#ifdef VBOX_WITH_HGSMI
521 volatile uint32_t mu32UpdateVBVAFlags;
522#endif
523
524private:
525 DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(Display); /* Shuts up MSC warning C4625. */
526};
527
528/* The legacy VBVA helpers. */
529int videoAccelConstruct(VIDEOACCEL *pVideoAccel);
530void videoAccelDestroy(VIDEOACCEL *pVideoAccel);
531void i_vbvaSetMemoryFlags(VBVAMEMORY *pVbvaMemory,
532 bool fVideoAccelEnabled,
533 bool fVideoAccelVRDP,
534 uint32_t fu32SupportedOrders,
535 DISPLAYFBINFO *paFBInfos,
536 unsigned cFBInfos);
537int videoAccelEnterVGA(VIDEOACCEL *pVideoAccel);
538void videoAccelLeaveVGA(VIDEOACCEL *pVideoAccel);
539int videoAccelEnterVMMDev(VIDEOACCEL *pVideoAccel);
540void videoAccelLeaveVMMDev(VIDEOACCEL *pVideoAccel);
541
542
543/* helper function, code in DisplayResampleImage.cpp */
544void BitmapScale32(uint8_t *dst, int dstW, int dstH,
545 const uint8_t *src, int iDeltaLine, int srcW, int srcH);
546
547/* helper function, code in DisplayPNGUtul.cpp */
548int DisplayMakePNG(uint8_t *pbData, uint32_t cx, uint32_t cy,
549 uint8_t **ppu8PNG, uint32_t *pcbPNG, uint32_t *pcxPNG, uint32_t *pcyPNG,
550 uint8_t fLimitSize);
551
552class ATL_NO_VTABLE DisplaySourceBitmap:
553 public DisplaySourceBitmapWrap
554{
555public:
556
557 DECLARE_EMPTY_CTOR_DTOR(DisplaySourceBitmap)
558
559 HRESULT FinalConstruct();
560 void FinalRelease();
561
562 /* Public initializer/uninitializer for internal purposes only. */
563 HRESULT init(ComObjPtr<Display> pDisplay, unsigned uScreenId, DISPLAYFBINFO *pFBInfo);
564 void uninit();
565
566 bool i_usesVRAM(void) { return m.pu8Allocated == NULL; }
567
568private:
569 // wrapped IDisplaySourceBitmap properties
570 virtual HRESULT getScreenId(ULONG *aScreenId);
571
572 // wrapped IDisplaySourceBitmap methods
573 virtual HRESULT queryBitmapInfo(BYTE **aAddress,
574 ULONG *aWidth,
575 ULONG *aHeight,
576 ULONG *aBitsPerPixel,
577 ULONG *aBytesPerLine,
578 BitmapFormat_T *aBitmapFormat);
579
580 int initSourceBitmap(unsigned aScreenId, DISPLAYFBINFO *pFBInfo);
581
582 struct Data
583 {
584 ComObjPtr<Display> pDisplay;
585 unsigned uScreenId;
586 DISPLAYFBINFO *pFBInfo;
587
588 uint8_t *pu8Allocated;
589
590 uint8_t *pu8Address;
591 ULONG ulWidth;
592 ULONG ulHeight;
593 ULONG ulBitsPerPixel;
594 ULONG ulBytesPerLine;
595 BitmapFormat_T bitmapFormat;
596 };
597
598 Data m;
599};
600
601#endif // !____H_DISPLAYIMPL
602/* 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