VirtualBox

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

Last change on this file since 52232 was 52200, checked in by vboxsync, 11 years ago

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