VirtualBox

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

Last change on this file since 54854 was 54828, checked in by vboxsync, 10 years ago

Main,Frontends: use BitmapFormat in API.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 24.3 KB
Line 
1/* $Id: DisplayImpl.h 54828 2015-03-18 11:43:37Z vboxsync $ */
2/** @file
3 * VirtualBox COM class implementation
4 */
5
6/*
7 * Copyright (C) 2006-2015 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 <VBox/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#include "DisplaySourceBitmapWrap.h"
35
36class Console;
37struct VIDEORECCONTEXT;
38
39typedef struct _DISPLAYFBINFO
40{
41 /* The following 3 fields (u32Offset, u32MaxFramebufferSize and u32InformationSize)
42 * are not used by the current HGSMI. They are needed for backward compatibility with
43 * pre-HGSMI additions.
44 */
45 uint32_t u32Offset;
46 uint32_t u32MaxFramebufferSize;
47 uint32_t u32InformationSize;
48
49 ComPtr<IFramebuffer> pFramebuffer;
50 ComPtr<IDisplaySourceBitmap> pSourceBitmap;
51 bool fDisabled;
52
53 uint32_t u32Caps;
54
55 struct
56 {
57 ComPtr<IDisplaySourceBitmap> pSourceBitmap;
58 uint8_t *pu8Address;
59 uint32_t cbLine;
60 } updateImage;
61
62 LONG xOrigin;
63 LONG yOrigin;
64
65 ULONG w;
66 ULONG h;
67
68 uint16_t u16BitsPerPixel;
69 uint8_t *pu8FramebufferVRAM;
70 uint32_t u32LineSize;
71
72 uint16_t flags;
73
74 VBOXVIDEOINFOHOSTEVENTS *pHostEvents;
75
76 /** The framebuffer has default format and must be updates immediately. */
77 bool fDefaultFormat;
78
79#ifdef VBOX_WITH_HGSMI
80 bool fVBVAEnabled;
81 bool fVBVAForceResize;
82 bool fRenderThreadMode;
83 PVBVAHOSTFLAGS pVBVAHostFlags;
84#endif /* VBOX_WITH_HGSMI */
85
86#ifdef VBOX_WITH_CROGL
87 struct
88 {
89 bool fPending;
90 ULONG x;
91 ULONG y;
92 ULONG width;
93 ULONG height;
94 } pendingViewportInfo;
95#endif /* VBOX_WITH_CROGL */
96} DISPLAYFBINFO;
97
98/* The legacy VBVA (VideoAccel) data.
99 *
100 * Backward compatibility with the guest additions 3.x or older.
101 */
102typedef struct VIDEOACCEL
103{
104 VBVAMEMORY *pVbvaMemory;
105 bool fVideoAccelEnabled;
106
107 uint8_t *pu8VbvaPartial;
108 uint32_t cbVbvaPartial;
109
110 /* Old guest additions (3.x and older) use both VMMDev and DevVGA refresh timer
111 * to process the VBVABUFFER memory. Therefore the legacy VBVA (VideoAccel) host
112 * code can be executed concurrently by VGA refresh timer and the guest VMMDev
113 * request in SMP VMs. The semaphore serialized this.
114 */
115 RTSEMXROADS hXRoadsVideoAccel;
116
117} VIDEOACCEL;
118
119class DisplayMouseInterface
120{
121public:
122 virtual HRESULT i_getScreenResolution(ULONG cScreen, ULONG *pcx,
123 ULONG *pcy, ULONG *pcBPP, LONG *pXOrigin, LONG *pYOrigin) = 0;
124 virtual void i_getFramebufferDimensions(int32_t *px1, int32_t *py1,
125 int32_t *px2, int32_t *py2) = 0;
126 virtual HRESULT i_reportHostCursorCapabilities(uint32_t fCapabilitiesAdded, uint32_t fCapabilitiesRemoved) = 0;
127 virtual HRESULT i_reportHostCursorPosition(int32_t x, int32_t y) = 0;
128 virtual bool i_isInputMappingSet(void) = 0;
129};
130
131class VMMDev;
132
133class ATL_NO_VTABLE Display :
134 public DisplayWrap,
135 public DisplayMouseInterface
136{
137public:
138
139 DECLARE_EMPTY_CTOR_DTOR(Display)
140
141 HRESULT FinalConstruct();
142 void FinalRelease();
143
144 // public initializer/uninitializer for internal purposes only
145 HRESULT init(Console *aParent);
146 void uninit();
147 int i_registerSSM(PUVM pUVM);
148
149 // public methods only for internal purposes
150 int i_handleDisplayResize(unsigned uScreenId, uint32_t bpp, void *pvVRAM, uint32_t cbLine,
151 uint32_t w, uint32_t h, uint16_t flags);
152 void i_handleDisplayUpdate(unsigned uScreenId, int x, int y, int w, int h);
153 void i_handleUpdateVMMDevSupportsGraphics(bool fSupportsGraphics);
154 void i_handleUpdateGuestVBVACapabilities(uint32_t fNewCapabilities);
155 void i_handleUpdateVBVAInputMapping(int32_t xOrigin, int32_t yOrigin, uint32_t cx, uint32_t cy);
156#ifdef VBOX_WITH_VIDEOHWACCEL
157 int i_handleVHWACommandProcess(PVBOXVHWACMD pCommand);
158#endif
159#ifdef VBOX_WITH_CRHGSMI
160 void i_handleCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam);
161 void i_handleCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam);
162 void i_handleCrHgsmiCommandProcess(PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd);
163 void i_handleCrHgsmiControlProcess(PVBOXVDMACMD_CHROMIUM_CTL pCtl, uint32_t cbCtl);
164#endif
165#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
166 int i_handleCrHgcmCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd,
167 PFNCRCTLCOMPLETION pfnCompletion,
168 void *pvCompletion);
169 void i_handleCrVRecScreenshotPerform(uint32_t uScreen,
170 uint32_t x, uint32_t y, uint32_t uPixelFormat, uint32_t uBitsPerPixel,
171 uint32_t uBytesPerLine, uint32_t uGuestWidth, uint32_t uGuestHeight,
172 uint8_t *pu8BufferAddress, uint64_t u64TimeStamp);
173 bool i_handleCrVRecScreenshotBegin(uint32_t uScreen, uint64_t u64TimeStamp);
174 void i_handleCrVRecScreenshotEnd(uint32_t uScreen, uint64_t u64TimeStamp);
175 void i_handleVRecCompletion();
176#endif
177
178 int i_notifyCroglResize(const PVBVAINFOVIEW pView, const PVBVAINFOSCREEN pScreen, void *pvVRAM);
179
180 int i_handleSetVisibleRegion(uint32_t cRect, PRTRECT pRect);
181 int i_handleQueryVisibleRegion(uint32_t *pcRect, PRTRECT pRect);
182
183 void i_VideoAccelVRDP(bool fEnable);
184
185 /* Legacy video acceleration requests coming from the VGA refresh timer. */
186 int VideoAccelEnableVGA(bool fEnable, VBVAMEMORY *pVbvaMemory);
187
188 /* Legacy video acceleration requests coming from VMMDev. */
189 int VideoAccelEnableVMMDev(bool fEnable, VBVAMEMORY *pVbvaMemory);
190 void VideoAccelFlushVMMDev(void);
191
192 int i_VideoCaptureStart();
193 void i_VideoCaptureStop();
194 int i_VideoCaptureEnableScreens(ComSafeArrayIn(BOOL, aScreens));
195
196 void i_notifyPowerDown(void);
197
198 // DisplayMouseInterface methods
199 virtual HRESULT i_getScreenResolution(ULONG cScreen, ULONG *pcx,
200 ULONG *pcy, ULONG *pcBPP, LONG *pXOrigin, LONG *pYOrigin)
201 {
202 return getScreenResolution(cScreen, pcx, pcy, pcBPP, pXOrigin, pYOrigin, NULL);
203 }
204 virtual void i_getFramebufferDimensions(int32_t *px1, int32_t *py1,
205 int32_t *px2, int32_t *py2);
206 virtual HRESULT i_reportHostCursorCapabilities(uint32_t fCapabilitiesAdded, uint32_t fCapabilitiesRemoved);
207 virtual HRESULT i_reportHostCursorPosition(int32_t x, int32_t y);
208 virtual bool i_isInputMappingSet(void)
209 {
210 return cxInputMapping != 0 && cyInputMapping != 0;
211 }
212
213 static const PDMDRVREG DrvReg;
214
215private:
216 // Wrapped IDisplay properties
217
218 // Wrapped IDisplay methods
219 virtual HRESULT getScreenResolution(ULONG aScreenId,
220 ULONG *aWidth,
221 ULONG *aHeight,
222 ULONG *aBitsPerPixel,
223 LONG *aXOrigin,
224 LONG *aYOrigin,
225 GuestMonitorStatus_T *aGuestMonitorStatus);
226 virtual HRESULT attachFramebuffer(ULONG aScreenId,
227 const ComPtr<IFramebuffer> &aFramebuffer);
228 virtual HRESULT detachFramebuffer(ULONG aScreenId);
229 virtual HRESULT queryFramebuffer(ULONG aScreenId,
230 ComPtr<IFramebuffer> &aFramebuffer);
231 virtual HRESULT setVideoModeHint(ULONG aDisplay,
232 BOOL aEnabled,
233 BOOL aChangeOrigin,
234 LONG aOriginX,
235 LONG aOriginY,
236 ULONG aWidth,
237 ULONG aHeight,
238 ULONG aBitsPerPixel);
239 virtual HRESULT setSeamlessMode(BOOL aEnabled);
240 virtual HRESULT takeScreenShot(ULONG aScreenId,
241 BYTE *aAddress,
242 ULONG aWidth,
243 ULONG aHeight,
244 BitmapFormat_T aBitmapFormat);
245 virtual HRESULT takeScreenShotToArray(ULONG aScreenId,
246 ULONG aWidth,
247 ULONG aHeight,
248 BitmapFormat_T aBitmapFormat,
249 std::vector<BYTE> &aScreenData);
250 virtual HRESULT drawToScreen(ULONG aScreenId,
251 BYTE *aAddress,
252 ULONG aX,
253 ULONG aY,
254 ULONG aWidth,
255 ULONG aHeight);
256 virtual HRESULT invalidateAndUpdate();
257 virtual HRESULT invalidateAndUpdateScreen(ULONG aScreenId);
258 virtual HRESULT completeVHWACommand(BYTE *aCommand);
259 virtual HRESULT viewportChanged(ULONG aScreenId,
260 ULONG aX,
261 ULONG aY,
262 ULONG aWidth,
263 ULONG aHeight);
264 virtual HRESULT querySourceBitmap(ULONG aScreenId,
265 ComPtr<IDisplaySourceBitmap> &aDisplaySourceBitmap);
266 virtual HRESULT notifyScaleFactorChange(ULONG aScreenId,
267 ULONG aScaleFactorWMultiplied,
268 ULONG aScaleFactorHMultiplied);
269 virtual HRESULT notifyHiDPIOutputPolicyChange(BOOL fUnscaledHiDPI);
270
271 // Wrapped IEventListener properties
272
273 // Wrapped IEventListener methods
274 virtual HRESULT handleEvent(const ComPtr<IEvent> &aEvent);
275
276 // other internal methods
277 HRESULT takeScreenShotWorker(ULONG aScreenId,
278 BYTE *aAddress,
279 ULONG aWidth,
280 ULONG aHeight,
281 BitmapFormat_T aBitmapFormat,
282 ULONG *pcbOut);
283
284#ifdef VBOX_WITH_CRHGSMI
285 void i_setupCrHgsmiData(void);
286 void i_destructCrHgsmiData(void);
287#endif
288
289#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
290 int i_crViewportNotify(ULONG aScreenId, ULONG x, ULONG y, ULONG width, ULONG height);
291#endif
292
293 static DECLCALLBACK(void*) i_drvQueryInterface(PPDMIBASE pInterface, const char *pszIID);
294 static DECLCALLBACK(int) i_drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
295 static DECLCALLBACK(void) i_drvDestruct(PPDMDRVINS pDrvIns);
296 static DECLCALLBACK(int) i_displayResizeCallback(PPDMIDISPLAYCONNECTOR pInterface, uint32_t bpp, void *pvVRAM,
297 uint32_t cbLine, uint32_t cx, uint32_t cy);
298 static DECLCALLBACK(void) i_displayUpdateCallback(PPDMIDISPLAYCONNECTOR pInterface,
299 uint32_t x, uint32_t y, uint32_t cx, uint32_t cy);
300 static DECLCALLBACK(void) i_displayRefreshCallback(PPDMIDISPLAYCONNECTOR pInterface);
301 static DECLCALLBACK(void) i_displayResetCallback(PPDMIDISPLAYCONNECTOR pInterface);
302 static DECLCALLBACK(void) i_displayLFBModeChangeCallback(PPDMIDISPLAYCONNECTOR pInterface, bool fEnabled);
303 static DECLCALLBACK(void) i_displayProcessAdapterDataCallback(PPDMIDISPLAYCONNECTOR pInterface,
304 void *pvVRAM, uint32_t u32VRAMSize);
305 static DECLCALLBACK(void) i_displayProcessDisplayDataCallback(PPDMIDISPLAYCONNECTOR pInterface,
306 void *pvVRAM, unsigned uScreenId);
307
308#ifdef VBOX_WITH_VIDEOHWACCEL
309 static DECLCALLBACK(int) i_displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand);
310#endif
311
312#ifdef VBOX_WITH_CRHGSMI
313 static DECLCALLBACK(void) i_displayCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface,
314 PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd);
315 static DECLCALLBACK(void) i_displayCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCtl,
316 uint32_t cbCtl);
317
318 static DECLCALLBACK(void) i_displayCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
319 void *pvContext);
320 static DECLCALLBACK(void) i_displayCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
321 void *pvContext);
322#endif
323#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
324 static DECLCALLBACK(int) i_displayCrHgcmCtlSubmit(PPDMIDISPLAYCONNECTOR pInterface,
325 struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd,
326 PFNCRCTLCOMPLETION pfnCompletion,
327 void *pvCompletion);
328 static DECLCALLBACK(void) i_displayCrHgcmCtlSubmitCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
329 void *pvContext);
330#endif
331#ifdef VBOX_WITH_HGSMI
332 static DECLCALLBACK(int) i_displayVBVAEnable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId,
333 PVBVAHOSTFLAGS pHostFlags, bool fRenderThreadMode);
334 static DECLCALLBACK(void) i_displayVBVADisable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId);
335 static DECLCALLBACK(void) i_displayVBVAUpdateBegin(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId);
336 static DECLCALLBACK(void) i_displayVBVAUpdateProcess(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId,
337 const PVBVACMDHDR pCmd, size_t cbCmd);
338 static DECLCALLBACK(void) i_displayVBVAUpdateEnd(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, int32_t x, int32_t y,
339 uint32_t cx, uint32_t cy);
340 static DECLCALLBACK(int) i_displayVBVAResize(PPDMIDISPLAYCONNECTOR pInterface, const PVBVAINFOVIEW pView,
341 const PVBVAINFOSCREEN pScreen, void *pvVRAM);
342 static DECLCALLBACK(int) i_displayVBVAMousePointerShape(PPDMIDISPLAYCONNECTOR pInterface, bool fVisible, bool fAlpha,
343 uint32_t xHot, uint32_t yHot, uint32_t cx, uint32_t cy,
344 const void *pvShape);
345 static DECLCALLBACK(void) i_displayVBVAGuestCapabilityUpdate(PPDMIDISPLAYCONNECTOR pInterface, uint32_t fCapabilities);
346
347 static DECLCALLBACK(void) i_displayVBVAInputMappingUpdate(PPDMIDISPLAYCONNECTOR pInterface, int32_t xOrigin, int32_t yOrigin,
348 uint32_t cx, uint32_t cy);
349#endif
350
351#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
352 static DECLCALLBACK(void) i_displayCrVRecScreenshotPerform(void *pvCtx, uint32_t uScreen,
353 uint32_t x, uint32_t y,
354 uint32_t uBitsPerPixel, uint32_t uBytesPerLine,
355 uint32_t uGuestWidth, uint32_t uGuestHeight,
356 uint8_t *pu8BufferAddress, uint64_t u64TimeStamp);
357 static DECLCALLBACK(bool) i_displayCrVRecScreenshotBegin(void *pvCtx, uint32_t uScreen, uint64_t u64TimeStamp);
358 static DECLCALLBACK(void) i_displayCrVRecScreenshotEnd(void *pvCtx, uint32_t uScreen, uint64_t u64TimeStamp);
359
360 static DECLCALLBACK(void) i_displayVRecCompletion(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, int rc, void *pvCompletion);
361#endif
362 static DECLCALLBACK(void) i_displayCrCmdFree(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, int rc, void *pvCompletion);
363
364 static DECLCALLBACK(void) i_displaySSMSaveScreenshot(PSSMHANDLE pSSM, void *pvUser);
365 static DECLCALLBACK(int) i_displaySSMLoadScreenshot(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass);
366 static DECLCALLBACK(void) i_displaySSMSave(PSSMHANDLE pSSM, void *pvUser);
367 static DECLCALLBACK(int) i_displaySSMLoad(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass);
368
369 Console * const mParent;
370 /** Pointer to the associated display driver. */
371 struct DRVMAINDISPLAY *mpDrv;
372 /** Pointer to the device instance for the VMM Device. */
373 PPDMDEVINS mpVMMDev;
374 /** Set after the first attempt to find the VMM Device. */
375 bool mfVMMDevInited;
376
377 unsigned mcMonitors;
378 /** Input mapping rectangle top left X relative to the first screen. */
379 int32_t xInputMappingOrigin;
380 /** Input mapping rectangle top left Y relative to the first screen. */
381 int32_t yInputMappingOrigin;
382 uint32_t cxInputMapping; /**< Input mapping rectangle width. */
383 uint32_t cyInputMapping; /**< Input mapping rectangle height. */
384 DISPLAYFBINFO maFramebuffers[SchemaDefs::MaxGuestMonitors];
385 /** Does the VMM device have the "supports graphics" capability set?
386 * Does not go into the saved state as it is refreshed on restore. */
387 bool mfVMMDevSupportsGraphics;
388 /** Mirror of the current guest VBVA capabilities. */
389 uint32_t mfGuestVBVACapabilities;
390 /** Mirror of the current host cursor capabilities. */
391 uint32_t mfHostCursorCapabilities;
392
393 bool mfSourceBitmapEnabled;
394 bool volatile fVGAResizing;
395
396 bool mfVideoAccelVRDP;
397 uint32_t mfu32SupportedOrders;
398 int32_t volatile mcVideoAccelVRDPRefs;
399
400 /** Accelerate3DEnabled = true && GraphicsControllerType == VBoxVGA. */
401 bool mfIsCr3DEnabled;
402
403#ifdef VBOX_WITH_CROGL
404 bool mfCrOglDataHidden;
405#endif
406
407#ifdef VBOX_WITH_CRHGSMI
408 /* for fast host hgcm calls */
409 HGCMCVSHANDLE mhCrOglSvc;
410 RTCRITSECTRW mCrOglLock;
411#endif
412#ifdef VBOX_WITH_CROGL
413 CR_MAIN_INTERFACE mCrOglCallbacks;
414 volatile uint32_t mfCrOglVideoRecState;
415 CRVBOXHGCMTAKESCREENSHOT mCrOglScreenshotData;
416 VBOXCRCMDCTL_HGCM mCrOglScreenshotCtl;
417#endif
418
419 /* The legacy VBVA data and methods. */
420 VIDEOACCEL mVideoAccelLegacy;
421
422 int i_VideoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory, PPDMIDISPLAYPORT pUpPort);
423 void i_VideoAccelFlush(PPDMIDISPLAYPORT pUpPort);
424 bool i_VideoAccelAllowed(void);
425
426 int i_videoAccelRefreshProcess(PPDMIDISPLAYPORT pUpPort);
427 int i_videoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory, PPDMIDISPLAYPORT pUpPort);
428 int i_videoAccelFlush(PPDMIDISPLAYPORT pUpPort);
429
430 /* Legacy pre-HGSMI handlers. */
431 void processAdapterData(void *pvVRAM, uint32_t u32VRAMSize);
432 void processDisplayData(void *pvVRAM, unsigned uScreenId);
433
434 /* Serializes access to mVideoAccelLegacy and mfVideoAccelVRDP, etc between VRDP and Display. */
435 RTCRITSECT mVideoAccelLock;
436
437public:
438
439 static int i_displayTakeScreenshotEMT(Display *pDisplay, ULONG aScreenId, uint8_t **ppu8Data, size_t *pcbData,
440 uint32_t *pu32Width, uint32_t *pu32Height);
441
442#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
443 static BOOL i_displayCheckTakeScreenshotCrOgl(Display *pDisplay, ULONG aScreenId, uint8_t *pu8Data,
444 uint32_t u32Width, uint32_t u32Height);
445 int i_crCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, PFNCRCTLCOMPLETION pfnCompletion, void *pvCompletion);
446 int i_crCtlSubmitSync(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd);
447 /* copies the given command and submits it asynchronously,
448 * i.e. the pCmd data may be discarded right after the call returns */
449 int i_crCtlSubmitAsyncCmdCopy(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd);
450 /* performs synchronous request processing if 3D backend has something to display
451 * this is primarily to work-around 3d<->main thread deadlocks on OSX
452 * in case of async completion, the command is coppied to the allocated buffer,
453 * freeded on command completion
454 * can be used for "notification" commands, when client is not interested in command result,
455 * that must synchronize with 3D backend only when some 3D data is displayed.
456 * The routine does NOT provide any info on whether command is processed asynchronously or not */
457 int i_crCtlSubmitSyncIfHasDataForScreen(uint32_t u32ScreenID, struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd);
458#endif
459
460private:
461 static int i_InvalidateAndUpdateEMT(Display *pDisplay, unsigned uId, bool fUpdateAll);
462 static int i_drawToScreenEMT(Display *pDisplay, ULONG aScreenId, BYTE *address, ULONG x, ULONG y, ULONG width, ULONG height);
463
464 void i_updateGuestGraphicsFacility(void);
465
466#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
467 int i_crOglWindowsShow(bool fShow);
468#endif
469
470#ifdef VBOX_WITH_HGSMI
471 volatile uint32_t mu32UpdateVBVAFlags;
472#endif
473
474#ifdef VBOX_WITH_VPX
475 VIDEORECCONTEXT *mpVideoRecCtx;
476 bool maVideoRecEnabled[SchemaDefs::MaxGuestMonitors];
477#endif
478};
479
480/* The legacy VBVA helpers. */
481int videoAccelConstruct(VIDEOACCEL *pVideoAccel);
482void videoAccelDestroy(VIDEOACCEL *pVideoAccel);
483void i_vbvaSetMemoryFlags(VBVAMEMORY *pVbvaMemory,
484 bool fVideoAccelEnabled,
485 bool fVideoAccelVRDP,
486 uint32_t fu32SupportedOrders,
487 DISPLAYFBINFO *paFBInfos,
488 unsigned cFBInfos);
489int videoAccelEnterVGA(VIDEOACCEL *pVideoAccel);
490void videoAccelLeaveVGA(VIDEOACCEL *pVideoAccel);
491int videoAccelEnterVMMDev(VIDEOACCEL *pVideoAccel);
492void videoAccelLeaveVMMDev(VIDEOACCEL *pVideoAccel);
493
494
495/* helper function, code in DisplayResampleImage.cpp */
496void gdImageCopyResampled(uint8_t *dst, uint8_t *src,
497 int dstX, int dstY, int srcX, int srcY,
498 int dstW, int dstH, int srcW, int srcH);
499
500void BitmapScale32(uint8_t *dst, int dstW, int dstH,
501 const uint8_t *src, int iDeltaLine, int srcW, int srcH);
502
503/* helper function, code in DisplayPNGUtul.cpp */
504int DisplayMakePNG(uint8_t *pu8Data, uint32_t cx, uint32_t cy,
505 uint8_t **ppu8PNG, uint32_t *pcbPNG, uint32_t *pcxPNG, uint32_t *pcyPNG,
506 uint8_t fLimitSize);
507
508class ATL_NO_VTABLE DisplaySourceBitmap:
509 public DisplaySourceBitmapWrap
510{
511public:
512
513 DECLARE_EMPTY_CTOR_DTOR(DisplaySourceBitmap)
514
515 HRESULT FinalConstruct();
516 void FinalRelease();
517
518 /* Public initializer/uninitializer for internal purposes only. */
519 HRESULT init(ComObjPtr<Display> pDisplay, unsigned uScreenId, DISPLAYFBINFO *pFBInfo);
520 void uninit();
521
522 bool i_usesVRAM(void) { return m.pu8Allocated == NULL; }
523
524private:
525 // wrapped IDisplaySourceBitmap properties
526 virtual HRESULT getScreenId(ULONG *aScreenId);
527
528 // wrapped IDisplaySourceBitmap methods
529 virtual HRESULT queryBitmapInfo(BYTE **aAddress,
530 ULONG *aWidth,
531 ULONG *aHeight,
532 ULONG *aBitsPerPixel,
533 ULONG *aBytesPerLine,
534 BitmapFormat_T *aBitmapFormat);
535
536 int initSourceBitmap(unsigned aScreenId, DISPLAYFBINFO *pFBInfo);
537
538 struct Data
539 {
540 ComObjPtr<Display> pDisplay;
541 unsigned uScreenId;
542 DISPLAYFBINFO *pFBInfo;
543
544 uint8_t *pu8Allocated;
545
546 uint8_t *pu8Address;
547 ULONG ulWidth;
548 ULONG ulHeight;
549 ULONG ulBitsPerPixel;
550 ULONG ulBytesPerLine;
551 BitmapFormat_T bitmapFormat;
552 };
553
554 Data m;
555};
556
557#endif // ____H_DISPLAYIMPL
558/* 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