VirtualBox

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

Last change on this file since 69500 was 68975, checked in by vboxsync, 7 years ago

VideoRec: Renaming (be more consistent): video capture vs. video recording.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 26.5 KB
Line 
1/* $Id: DisplayImpl.h 68975 2017-10-04 11:51:39Z 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);
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#endif
386
387#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
388 static DECLCALLBACK(void) i_displayCrVRecScreenshotPerform(void *pvCtx, uint32_t uScreen,
389 uint32_t x, uint32_t y,
390 uint32_t uBitsPerPixel, uint32_t uBytesPerLine,
391 uint32_t uGuestWidth, uint32_t uGuestHeight,
392 uint8_t *pu8BufferAddress, uint64_t u64TimeStamp);
393 static DECLCALLBACK(bool) i_displayCrVRecScreenshotBegin(void *pvCtx, uint32_t uScreen, uint64_t u64TimeStamp);
394 static DECLCALLBACK(void) i_displayCrVRecScreenshotEnd(void *pvCtx, uint32_t uScreen, uint64_t u64TimeStamp);
395
396 static DECLCALLBACK(void) i_displayVRecCompletion(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, int rc, void *pvCompletion);
397#endif
398 static DECLCALLBACK(void) i_displayCrCmdFree(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, int rc, void *pvCompletion);
399
400 static DECLCALLBACK(void) i_displaySSMSaveScreenshot(PSSMHANDLE pSSM, void *pvUser);
401 static DECLCALLBACK(int) i_displaySSMLoadScreenshot(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass);
402 static DECLCALLBACK(void) i_displaySSMSave(PSSMHANDLE pSSM, void *pvUser);
403 static DECLCALLBACK(int) i_displaySSMLoad(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass);
404
405 Console * const mParent;
406 /** Pointer to the associated display driver. */
407 struct DRVMAINDISPLAY *mpDrv;
408
409 unsigned mcMonitors;
410 /** Input mapping rectangle top left X relative to the first screen. */
411 int32_t xInputMappingOrigin;
412 /** Input mapping rectangle top left Y relative to the first screen. */
413 int32_t yInputMappingOrigin;
414 uint32_t cxInputMapping; /**< Input mapping rectangle width. */
415 uint32_t cyInputMapping; /**< Input mapping rectangle height. */
416 DISPLAYFBINFO maFramebuffers[SchemaDefs::MaxGuestMonitors];
417 /** Does the VMM device have the "supports graphics" capability set?
418 * Does not go into the saved state as it is refreshed on restore. */
419 bool mfVMMDevSupportsGraphics;
420 /** Mirror of the current guest VBVA capabilities. */
421 uint32_t mfGuestVBVACapabilities;
422 /** Mirror of the current host cursor capabilities. */
423 uint32_t mfHostCursorCapabilities;
424
425 bool mfSourceBitmapEnabled;
426 bool volatile fVGAResizing;
427
428 /** Are we in seamless mode? Not saved, as we exit seamless on saving. */
429 bool mfSeamlessEnabled;
430 /** Last set seamless visible region, number of rectangles. */
431 uint32_t mcRectVisibleRegion;
432 /** Last set seamless visible region, data. Freed on final clean-up. */
433 PRTRECT mpRectVisibleRegion;
434
435 bool mfVideoAccelVRDP;
436 uint32_t mfu32SupportedOrders;
437 int32_t volatile mcVideoAccelVRDPRefs;
438
439 /** Accelerate3DEnabled = true && GraphicsControllerType == VBoxVGA. */
440 bool mfIsCr3DEnabled;
441
442#ifdef VBOX_WITH_CROGL
443 bool mfCrOglDataHidden;
444#endif
445
446#ifdef VBOX_WITH_CRHGSMI
447 /* for fast host hgcm calls */
448 HGCMCVSHANDLE mhCrOglSvc;
449 RTCRITSECTRW mCrOglLock;
450#endif
451#ifdef VBOX_WITH_CROGL
452 CR_MAIN_INTERFACE mCrOglCallbacks;
453 volatile uint32_t mfCrOglVideoRecState;
454 CRVBOXHGCMTAKESCREENSHOT mCrOglScreenshotData;
455 VBOXCRCMDCTL_HGCM mCrOglScreenshotCtl;
456#endif
457
458 /* The legacy VBVA data and methods. */
459 VIDEOACCEL mVideoAccelLegacy;
460
461 int i_VideoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory, PPDMIDISPLAYPORT pUpPort);
462 void i_VideoAccelFlush(PPDMIDISPLAYPORT pUpPort);
463 bool i_VideoAccelAllowed(void);
464
465 int i_videoAccelRefreshProcess(PPDMIDISPLAYPORT pUpPort);
466 int i_videoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory, PPDMIDISPLAYPORT pUpPort);
467 int i_videoAccelFlush(PPDMIDISPLAYPORT pUpPort);
468
469 /* Legacy pre-HGSMI handlers. */
470 void processAdapterData(void *pvVRAM, uint32_t u32VRAMSize);
471 void processDisplayData(void *pvVRAM, unsigned uScreenId);
472
473 /** Serializes access to mVideoAccelLegacy and mfVideoAccelVRDP, etc between VRDP and Display. */
474 RTCRITSECT mVideoAccelLock;
475
476#ifdef VBOX_WITH_VIDEOREC
477 /* Serializes access to video recording source bitmaps. */
478 RTCRITSECT mVideoRecLock;
479 /** The current video recording configuration being used. */
480 VIDEORECCFG mVideoRecCfg;
481 /** The video recording context. */
482 VIDEORECCONTEXT *mpVideoRecCtx;
483 /** Array which defines which screens are being enabled for recording. */
484 bool maVideoRecEnabled[SchemaDefs::MaxGuestMonitors];
485#endif
486
487public:
488
489 static int i_displayTakeScreenshotEMT(Display *pDisplay, ULONG aScreenId, uint8_t **ppbData, size_t *pcbData,
490 uint32_t *pcx, uint32_t *pcy, bool *pfMemFree);
491#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
492 static BOOL i_displayCheckTakeScreenshotCrOgl(Display *pDisplay, ULONG aScreenId, uint8_t *pbData,
493 uint32_t u32Width, uint32_t u32Height);
494 int i_crCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, PFNCRCTLCOMPLETION pfnCompletion, void *pvCompletion);
495 int i_crCtlSubmitSync(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd);
496 /* copies the given command and submits it asynchronously,
497 * i.e. the pCmd data may be discarded right after the call returns */
498 int i_crCtlSubmitAsyncCmdCopy(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd);
499 /* performs synchronous request processing if 3D backend has something to display
500 * this is primarily to work-around 3d<->main thread deadlocks on OSX
501 * in case of async completion, the command is coppied to the allocated buffer,
502 * freeded on command completion
503 * can be used for "notification" commands, when client is not interested in command result,
504 * that must synchronize with 3D backend only when some 3D data is displayed.
505 * The routine does NOT provide any info on whether command is processed asynchronously or not */
506 int i_crCtlSubmitSyncIfHasDataForScreen(uint32_t u32ScreenID, struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd);
507#endif
508
509private:
510 static int i_InvalidateAndUpdateEMT(Display *pDisplay, unsigned uId, bool fUpdateAll);
511 static int i_drawToScreenEMT(Display *pDisplay, ULONG aScreenId, BYTE *address, ULONG x, ULONG y, ULONG width, ULONG height);
512
513 void i_updateGuestGraphicsFacility(void);
514
515#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
516 int i_crOglWindowsShow(bool fShow);
517#endif
518
519#ifdef VBOX_WITH_HGSMI
520 volatile uint32_t mu32UpdateVBVAFlags;
521#endif
522
523private:
524 DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(Display); /* Shuts up MSC warning C4625. */
525};
526
527/* The legacy VBVA helpers. */
528int videoAccelConstruct(VIDEOACCEL *pVideoAccel);
529void videoAccelDestroy(VIDEOACCEL *pVideoAccel);
530void i_vbvaSetMemoryFlags(VBVAMEMORY *pVbvaMemory,
531 bool fVideoAccelEnabled,
532 bool fVideoAccelVRDP,
533 uint32_t fu32SupportedOrders,
534 DISPLAYFBINFO *paFBInfos,
535 unsigned cFBInfos);
536int videoAccelEnterVGA(VIDEOACCEL *pVideoAccel);
537void videoAccelLeaveVGA(VIDEOACCEL *pVideoAccel);
538int videoAccelEnterVMMDev(VIDEOACCEL *pVideoAccel);
539void videoAccelLeaveVMMDev(VIDEOACCEL *pVideoAccel);
540
541
542/* helper function, code in DisplayResampleImage.cpp */
543void BitmapScale32(uint8_t *dst, int dstW, int dstH,
544 const uint8_t *src, int iDeltaLine, int srcW, int srcH);
545
546/* helper function, code in DisplayPNGUtul.cpp */
547int DisplayMakePNG(uint8_t *pbData, uint32_t cx, uint32_t cy,
548 uint8_t **ppu8PNG, uint32_t *pcbPNG, uint32_t *pcxPNG, uint32_t *pcyPNG,
549 uint8_t fLimitSize);
550
551class ATL_NO_VTABLE DisplaySourceBitmap:
552 public DisplaySourceBitmapWrap
553{
554public:
555
556 DECLARE_EMPTY_CTOR_DTOR(DisplaySourceBitmap)
557
558 HRESULT FinalConstruct();
559 void FinalRelease();
560
561 /* Public initializer/uninitializer for internal purposes only. */
562 HRESULT init(ComObjPtr<Display> pDisplay, unsigned uScreenId, DISPLAYFBINFO *pFBInfo);
563 void uninit();
564
565 bool i_usesVRAM(void) { return m.pu8Allocated == NULL; }
566
567private:
568 // wrapped IDisplaySourceBitmap properties
569 virtual HRESULT getScreenId(ULONG *aScreenId);
570
571 // wrapped IDisplaySourceBitmap methods
572 virtual HRESULT queryBitmapInfo(BYTE **aAddress,
573 ULONG *aWidth,
574 ULONG *aHeight,
575 ULONG *aBitsPerPixel,
576 ULONG *aBytesPerLine,
577 BitmapFormat_T *aBitmapFormat);
578
579 int initSourceBitmap(unsigned aScreenId, DISPLAYFBINFO *pFBInfo);
580
581 struct Data
582 {
583 ComObjPtr<Display> pDisplay;
584 unsigned uScreenId;
585 DISPLAYFBINFO *pFBInfo;
586
587 uint8_t *pu8Allocated;
588
589 uint8_t *pu8Address;
590 ULONG ulWidth;
591 ULONG ulHeight;
592 ULONG ulBitsPerPixel;
593 ULONG ulBytesPerLine;
594 BitmapFormat_T bitmapFormat;
595 };
596
597 Data m;
598};
599
600#endif // !____H_DISPLAYIMPL
601/* 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