DisplayImpl.h@ 94173

Last change on this file since 94173 was 93444, checked in by vboxsync, 3 years ago
VMM,Main,HostServices: Use a function table for accessing the VBoxVMM.dll/so/dylib functionality, and load it dynamically when the Console object is initialized. Also converted a few drivers in Main to use device helpers to get config values and such. bugref:10074
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 23.2 KB

Line
1	/* $Id: DisplayImpl.h 93444 2022-01-26 18:01:15Z vboxsync $ */
2	/** @file
3	* VirtualBox COM class implementation
4	*/
5
6	/*
7	* Copyright (C) 2006-2022 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 <VBox/VMMDev.h> /* For struct VMMDevDisplayDef - why is it in that file? */
31	#include "DisplayWrap.h"
32
33	#include "DisplaySourceBitmapWrap.h"
34	#include "GuestScreenInfoWrap.h"
35
36
37	class Console;
38
39	typedef 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	com::Guid framebufferId;
51	ComPtr<IDisplaySourceBitmap> pSourceBitmap;
52	bool fDisabled;
53
54	uint32_t u32Caps;
55
56	struct
57	{
58	ComPtr<IDisplaySourceBitmap> pSourceBitmap;
59	uint8_t *pu8Address;
60	uint32_t cbLine;
61	} updateImage;
62
63	LONG xOrigin;
64	LONG yOrigin;
65
66	ULONG w;
67	ULONG h;
68
69	uint16_t u16BitsPerPixel;
70	uint8_t *pu8FramebufferVRAM;
71	uint32_t u32LineSize;
72
73	uint16_t flags;
74
75	VBOXVIDEOINFOHOSTEVENTS *pHostEvents;
76
77	/** The framebuffer has default format and must be updates immediately. */
78	bool fDefaultFormat;
79
80	#ifdef VBOX_WITH_HGSMI
81	bool fVBVAEnabled;
82	bool fVBVAForceResize;
83	VBVAHOSTFLAGS RT_UNTRUSTED_VOLATILE_GUEST *pVBVAHostFlags;
84	#endif /* VBOX_WITH_HGSMI */
85
86	#ifdef VBOX_WITH_RECORDING
87	struct
88	{
89	ComPtr<IDisplaySourceBitmap> pSourceBitmap;
90	} Recording;
91	#endif /* VBOX_WITH_RECORDING */
92
93	/** Description of the currently plugged monitor with preferred mode,
94	* a.k.a the last mode hint sent. */
95	struct VMMDevDisplayDef monitorDesc;
96	} DISPLAYFBINFO;
97
98	/* The legacy VBVA (VideoAccel) data.
99	*
100	* Backward compatibility with the Guest Additions 3.x or older.
101	*/
102	typedef 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
119	class DisplayMouseInterface
120	{
121	public:
122	virtual ~DisplayMouseInterface() { }
123	virtual HRESULT i_getScreenResolution(ULONG cScreen, ULONG *pcx,
124	ULONG pcy, ULONG pcBPP, LONG pXOrigin, LONG pYOrigin) = 0;
125	virtual void i_getFramebufferDimensions(int32_t px1, int32_t py1,
126	int32_t px2, int32_t py2) = 0;
127	virtual HRESULT i_reportHostCursorCapabilities(uint32_t fCapabilitiesAdded, uint32_t fCapabilitiesRemoved) = 0;
128	virtual HRESULT i_reportHostCursorPosition(int32_t x, int32_t y, bool fOutOfRange) = 0;
129	virtual bool i_isInputMappingSet(void) = 0;
130	};
131
132	class VMMDev;
133
134	class ATL_NO_VTABLE Display :
135	public DisplayWrap,
136	public DisplayMouseInterface
137	{
138	public:
139
140	DECLARE_COMMON_CLASS_METHODS(Display)
141
142	HRESULT FinalConstruct();
143	void FinalRelease();
144
145	// public initializer/uninitializer for internal purposes only
146	HRESULT init(Console *aParent);
147	void uninit();
148	int i_registerSSM(PUVM pUVM);
149
150	// public methods only for internal purposes
151	unsigned i_getMonitorCount() { return mcMonitors; }
152	int i_handleDisplayResize(unsigned uScreenId, uint32_t bpp, void *pvVRAM,
153	uint32_t cbLine, uint32_t w, uint32_t h, uint16_t flags,
154	int32_t xOrigin, int32_t yOrigin, bool fVGAResize);
155	void i_handleDisplayUpdate(unsigned uScreenId, int x, int y, int w, int h);
156	void i_handleUpdateVMMDevSupportsGraphics(bool fSupportsGraphics);
157	void i_handleUpdateGuestVBVACapabilities(uint32_t fNewCapabilities);
158	void i_handleUpdateVBVAInputMapping(int32_t xOrigin, int32_t yOrigin, uint32_t cx, uint32_t cy);
159	#ifdef VBOX_WITH_VIDEOHWACCEL
160	int i_handleVHWACommandProcess(int enmCmd, bool fGuestCmd, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand);
161	#endif
162	int i_handle3DNotifyProcess(VBOX3DNOTIFY *p3DNotify);
163
164	int i_saveVisibleRegion(uint32_t cRect, PRTRECT pRect);
165	int i_handleSetVisibleRegion(uint32_t cRect, PRTRECT pRect);
166	int i_handleUpdateMonitorPositions(uint32_t cPositions, PCRTPOINT paPositions);
167	int i_handleQueryVisibleRegion(uint32_t *pcRects, PRTRECT paRects);
168
169	void i_VRDPConnectionEvent(bool fConnect);
170	void i_VideoAccelVRDP(bool fEnable, int c);
171
172	/* Legacy video acceleration requests coming from the VGA refresh timer. */
173	int VideoAccelEnableVGA(bool fEnable, VBVAMEMORY *pVbvaMemory);
174
175	/* Legacy video acceleration requests coming from VMMDev. */
176	int VideoAccelEnableVMMDev(bool fEnable, VBVAMEMORY *pVbvaMemory);
177	void VideoAccelFlushVMMDev(void);
178
179	void i_UpdateDeviceCursorCapabilities(void);
180
181	#ifdef VBOX_WITH_RECORDING
182	int i_recordingInvalidate(void);
183	void i_recordingScreenChanged(unsigned uScreenId);
184	#endif
185
186	void i_notifyPowerDown(void);
187
188	// DisplayMouseInterface methods
189	virtual HRESULT i_getScreenResolution(ULONG cScreen, ULONG *pcx,
190	ULONG pcy, ULONG pcBPP, LONG pXOrigin, LONG pYOrigin)
191	{
192	return getScreenResolution(cScreen, pcx, pcy, pcBPP, pXOrigin, pYOrigin, NULL);
193	}
194	virtual void i_getFramebufferDimensions(int32_t px1, int32_t py1,
195	int32_t px2, int32_t py2);
196	virtual HRESULT i_reportHostCursorCapabilities(uint32_t fCapabilitiesAdded, uint32_t fCapabilitiesRemoved);
197	virtual HRESULT i_reportHostCursorPosition(int32_t x, int32_t y, bool fOutOfRange);
198	virtual bool i_isInputMappingSet(void)
199	{
200	return cxInputMapping != 0 && cyInputMapping != 0;
201	}
202
203	static const PDMDRVREG DrvReg;
204
205	private:
206	// Wrapped IDisplay properties
207	virtual HRESULT getGuestScreenLayout(std::vector<ComPtr<IGuestScreenInfo> > &aGuestScreenLayout);
208
209	// Wrapped IDisplay methods
210	virtual HRESULT getScreenResolution(ULONG aScreenId,
211	ULONG *aWidth,
212	ULONG *aHeight,
213	ULONG *aBitsPerPixel,
214	LONG *aXOrigin,
215	LONG *aYOrigin,
216	GuestMonitorStatus_T *aGuestMonitorStatus);
217	virtual HRESULT attachFramebuffer(ULONG aScreenId,
218	const ComPtr<IFramebuffer> &aFramebuffer,
219	com::Guid &aId);
220	virtual HRESULT detachFramebuffer(ULONG aScreenId,
221	const com::Guid &aId);
222	virtual HRESULT queryFramebuffer(ULONG aScreenId,
223	ComPtr<IFramebuffer> &aFramebuffer);
224	virtual HRESULT setVideoModeHint(ULONG aDisplay,
225	BOOL aEnabled,
226	BOOL aChangeOrigin,
227	LONG aOriginX,
228	LONG aOriginY,
229	ULONG aWidth,
230	ULONG aHeight,
231	ULONG aBitsPerPixel,
232	BOOL aNotify);
233	virtual HRESULT getVideoModeHint(ULONG aDisplay,
234	BOOL *aEnabled,
235	BOOL *aChangeOrigin,
236	LONG *aOriginX,
237	LONG *aOriginY,
238	ULONG *aWidth,
239	ULONG *aHeight,
240	ULONG *aBitsPerPixel);
241	virtual HRESULT setSeamlessMode(BOOL aEnabled);
242	virtual HRESULT takeScreenShot(ULONG aScreenId,
243	BYTE *aAddress,
244	ULONG aWidth,
245	ULONG aHeight,
246	BitmapFormat_T aBitmapFormat);
247	virtual HRESULT takeScreenShotToArray(ULONG aScreenId,
248	ULONG aWidth,
249	ULONG aHeight,
250	BitmapFormat_T aBitmapFormat,
251	std::vector<BYTE> &aScreenData);
252	virtual HRESULT drawToScreen(ULONG aScreenId,
253	BYTE *aAddress,
254	ULONG aX,
255	ULONG aY,
256	ULONG aWidth,
257	ULONG aHeight);
258	virtual HRESULT invalidateAndUpdate();
259	virtual HRESULT invalidateAndUpdateScreen(ULONG aScreenId);
260	virtual HRESULT completeVHWACommand(BYTE *aCommand);
261	virtual HRESULT viewportChanged(ULONG aScreenId,
262	ULONG aX,
263	ULONG aY,
264	ULONG aWidth,
265	ULONG aHeight);
266	virtual HRESULT querySourceBitmap(ULONG aScreenId,
267	ComPtr<IDisplaySourceBitmap> &aDisplaySourceBitmap);
268	virtual HRESULT notifyScaleFactorChange(ULONG aScreenId,
269	ULONG aScaleFactorWMultiplied,
270	ULONG aScaleFactorHMultiplied);
271	virtual HRESULT notifyHiDPIOutputPolicyChange(BOOL fUnscaledHiDPI);
272	virtual HRESULT setScreenLayout(ScreenLayoutMode_T aScreenLayoutMode,
273	const std::vector<ComPtr<IGuestScreenInfo> > &aGuestScreenInfo);
274	virtual HRESULT detachScreens(const std::vector<LONG> &aScreenIds);
275	virtual HRESULT createGuestScreenInfo(ULONG aDisplay,
276	GuestMonitorStatus_T aStatus,
277	BOOL aPrimary,
278	BOOL aChangeOrigin,
279	LONG aOriginX,
280	LONG aOriginY,
281	ULONG aWidth,
282	ULONG aHeight,
283	ULONG aBitsPerPixel,
284	ComPtr<IGuestScreenInfo> &aGuestScreenInfo);
285
286	// Wrapped IEventListener properties
287
288	// Wrapped IEventListener methods
289	virtual HRESULT handleEvent(const ComPtr<IEvent> &aEvent);
290
291	// other internal methods
292	HRESULT takeScreenShotWorker(ULONG aScreenId,
293	BYTE *aAddress,
294	ULONG aWidth,
295	ULONG aHeight,
296	BitmapFormat_T aBitmapFormat,
297	ULONG *pcbOut);
298	int processVBVAResize(PCVBVAINFOVIEW pView, PCVBVAINFOSCREEN pScreen, void *pvVRAM, bool fResetInputMapping);
299
300	static DECLCALLBACK(void) i_drvQueryInterface(PPDMIBASE pInterface, const char pszIID);
301	static DECLCALLBACK(int) i_drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
302	static DECLCALLBACK(void) i_drvDestruct(PPDMDRVINS pDrvIns);
303	static DECLCALLBACK(void) i_drvPowerOff(PPDMDRVINS pDrvIns);
304	static DECLCALLBACK(int) i_displayResizeCallback(PPDMIDISPLAYCONNECTOR pInterface, uint32_t bpp, void *pvVRAM,
305	uint32_t cbLine, uint32_t cx, uint32_t cy);
306	static DECLCALLBACK(void) i_displayUpdateCallback(PPDMIDISPLAYCONNECTOR pInterface,
307	uint32_t x, uint32_t y, uint32_t cx, uint32_t cy);
308	static DECLCALLBACK(void) i_displayRefreshCallback(PPDMIDISPLAYCONNECTOR pInterface);
309	static DECLCALLBACK(void) i_displayResetCallback(PPDMIDISPLAYCONNECTOR pInterface);
310	static DECLCALLBACK(void) i_displayLFBModeChangeCallback(PPDMIDISPLAYCONNECTOR pInterface, bool fEnabled);
311	static DECLCALLBACK(void) i_displayProcessAdapterDataCallback(PPDMIDISPLAYCONNECTOR pInterface,
312	void *pvVRAM, uint32_t u32VRAMSize);
313	static DECLCALLBACK(void) i_displayProcessDisplayDataCallback(PPDMIDISPLAYCONNECTOR pInterface,
314	void *pvVRAM, unsigned uScreenId);
315
316	#ifdef VBOX_WITH_VIDEOHWACCEL
317	static DECLCALLBACK(int) i_displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, int enmCmd, bool fGuestCmd,
318	VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand);
319	#endif
320	static DECLCALLBACK(int) i_display3DNotifyProcess(PPDMIDISPLAYCONNECTOR pInterface,
321	VBOX3DNOTIFY *p3DNotify);
322
323	#ifdef VBOX_WITH_HGSMI
324	static DECLCALLBACK(int) i_displayVBVAEnable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId,
325	VBVAHOSTFLAGS RT_UNTRUSTED_VOLATILE_GUEST *pHostFlags);
326	static DECLCALLBACK(void) i_displayVBVADisable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId);
327	static DECLCALLBACK(void) i_displayVBVAUpdateBegin(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId);
328	static DECLCALLBACK(void) i_displayVBVAUpdateProcess(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId,
329	struct VBVACMDHDR const RT_UNTRUSTED_VOLATILE_GUEST *pCmd, size_t cbCmd);
330	static DECLCALLBACK(void) i_displayVBVAUpdateEnd(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, int32_t x, int32_t y,
331	uint32_t cx, uint32_t cy);
332	static DECLCALLBACK(int) i_displayVBVAResize(PPDMIDISPLAYCONNECTOR pInterface, PCVBVAINFOVIEW pView,
333	PCVBVAINFOSCREEN pScreen, void *pvVRAM,
334	bool fResetInputMapping);
335	static DECLCALLBACK(int) i_displayVBVAMousePointerShape(PPDMIDISPLAYCONNECTOR pInterface, bool fVisible, bool fAlpha,
336	uint32_t xHot, uint32_t yHot, uint32_t cx, uint32_t cy,
337	const void *pvShape);
338	static DECLCALLBACK(void) i_displayVBVAGuestCapabilityUpdate(PPDMIDISPLAYCONNECTOR pInterface, uint32_t fCapabilities);
339
340	static DECLCALLBACK(void) i_displayVBVAInputMappingUpdate(PPDMIDISPLAYCONNECTOR pInterface, int32_t xOrigin, int32_t yOrigin,
341	uint32_t cx, uint32_t cy);
342	static DECLCALLBACK(void) i_displayVBVAReportCursorPosition(PPDMIDISPLAYCONNECTOR pInterface, uint32_t fFlags, uint32_t uScreen, uint32_t x, uint32_t y);
343	#endif
344
345	static DECLCALLBACK(int) i_displaySSMSaveScreenshot(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser);
346	static DECLCALLBACK(int) i_displaySSMLoadScreenshot(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser,
347	uint32_t uVersion, uint32_t uPass);
348	static DECLCALLBACK(int) i_displaySSMSave(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser);
349	static DECLCALLBACK(int) i_displaySSMLoad(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser,
350	uint32_t uVersion, uint32_t uPass);
351
352	Console * const mParent;
353	/** Pointer to the associated display driver. */
354	struct DRVMAINDISPLAY *mpDrv;
355
356	unsigned mcMonitors;
357	/** Input mapping rectangle top left X relative to the first screen. */
358	int32_t xInputMappingOrigin;
359	/** Input mapping rectangle top left Y relative to the first screen. */
360	int32_t yInputMappingOrigin;
361	uint32_t cxInputMapping; /*< Input mapping rectangle width. /
362	uint32_t cyInputMapping; /*< Input mapping rectangle height. /
363	DISPLAYFBINFO maFramebuffers[SchemaDefs::MaxGuestMonitors];
364	/** Does the VMM device have the "supports graphics" capability set?
365	* Does not go into the saved state as it is refreshed on restore. */
366	bool mfVMMDevSupportsGraphics;
367	/** Mirror of the current guest VBVA capabilities. */
368	uint32_t mfGuestVBVACapabilities;
369	/** Mirror of the current host cursor capabilities. */
370	uint32_t mfHostCursorCapabilities;
371
372	bool mfSourceBitmapEnabled;
373	bool volatile fVGAResizing;
374
375	/** Are we in seamless mode? Not saved, as we exit seamless on saving. */
376	bool mfSeamlessEnabled;
377	/** Last set seamless visible region, number of rectangles. */
378	uint32_t mcRectVisibleRegion;
379	/** Last set seamless visible region, data. Freed on final clean-up. */
380	PRTRECT mpRectVisibleRegion;
381
382	bool mfVideoAccelVRDP;
383	uint32_t mfu32SupportedOrders;
384	/** Number of currently connected VRDP clients. */
385	int32_t volatile mcVRDPRefs;
386
387	/* The legacy VBVA data and methods. */
388	VIDEOACCEL mVideoAccelLegacy;
389
390	int i_VideoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory, PPDMIDISPLAYPORT pUpPort);
391	void i_VideoAccelFlush(PPDMIDISPLAYPORT pUpPort);
392	bool i_VideoAccelAllowed(void);
393
394	int i_videoAccelRefreshProcess(PPDMIDISPLAYPORT pUpPort);
395	int i_videoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory, PPDMIDISPLAYPORT pUpPort);
396	int i_videoAccelFlush(PPDMIDISPLAYPORT pUpPort);
397
398	/* Legacy pre-HGSMI handlers. */
399	void processAdapterData(void *pvVRAM, uint32_t u32VRAMSize);
400	void processDisplayData(void *pvVRAM, unsigned uScreenId);
401
402	/** Serializes access to mVideoAccelLegacy and mfVideoAccelVRDP, etc between VRDP and Display. */
403	RTCRITSECT mVideoAccelLock;
404
405	#ifdef VBOX_WITH_RECORDING
406	/* Serializes access to video recording source bitmaps. */
407	RTCRITSECT mVideoRecLock;
408	/** Array which defines which screens are being enabled for recording. */
409	bool maRecordingEnabled[SchemaDefs::MaxGuestMonitors];
410	#endif
411
412	public:
413
414	static DECLCALLBACK(int) i_displayTakeScreenshotEMT(Display pDisplay, ULONG aScreenId, uint8_t ppbData, size_t pcbData,
415	uint32_t pcx, uint32_t pcy, bool *pfMemFree);
416
417	private:
418	static DECLCALLBACK(int) i_InvalidateAndUpdateEMT(Display *pDisplay, unsigned uId, bool fUpdateAll);
419	static DECLCALLBACK(int) i_drawToScreenEMT(Display pDisplay, ULONG aScreenId, BYTE address, ULONG x, ULONG y,
420	ULONG width, ULONG height);
421
422	void i_updateGuestGraphicsFacility(void);
423
424	#ifdef VBOX_WITH_HGSMI
425	volatile uint32_t mu32UpdateVBVAFlags;
426	#endif
427
428	private:
429	DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(Display); /* Shuts up MSC warning C4625. */
430	};
431
432	/* The legacy VBVA helpers. */
433	int videoAccelConstruct(VIDEOACCEL *pVideoAccel);
434	void videoAccelDestroy(VIDEOACCEL *pVideoAccel);
435	void i_vbvaSetMemoryFlags(VBVAMEMORY *pVbvaMemory,
436	bool fVideoAccelEnabled,
437	bool fVideoAccelVRDP,
438	uint32_t fu32SupportedOrders,
439	DISPLAYFBINFO *paFBInfos,
440	unsigned cFBInfos);
441	int videoAccelEnterVGA(VIDEOACCEL *pVideoAccel);
442	void videoAccelLeaveVGA(VIDEOACCEL *pVideoAccel);
443	int videoAccelEnterVMMDev(VIDEOACCEL *pVideoAccel);
444	void videoAccelLeaveVMMDev(VIDEOACCEL *pVideoAccel);
445
446
447	/* helper function, code in DisplayResampleImage.cpp */
448	void BitmapScale32(uint8_t *dst, int dstW, int dstH,
449	const uint8_t *src, int iDeltaLine, int srcW, int srcH);
450
451	/* helper function, code in DisplayPNGUtul.cpp */
452	int DisplayMakePNG(uint8_t *pbData, uint32_t cx, uint32_t cy,
453	uint8_t *ppu8PNG, uint32_t pcbPNG, uint32_t pcxPNG, uint32_t pcyPNG,
454	uint8_t fLimitSize);
455
456	class ATL_NO_VTABLE DisplaySourceBitmap:
457	public DisplaySourceBitmapWrap
458	{
459	public:
460
461	DECLARE_COMMON_CLASS_METHODS(DisplaySourceBitmap)
462
463	HRESULT FinalConstruct();
464	void FinalRelease();
465
466	/* Public initializer/uninitializer for internal purposes only. */
467	HRESULT init(ComObjPtr<Display> pDisplay, unsigned uScreenId, DISPLAYFBINFO *pFBInfo);
468	void uninit();
469
470	bool i_usesVRAM(void) { return m.pu8Allocated == NULL; }
471
472	private:
473	// wrapped IDisplaySourceBitmap properties
474	virtual HRESULT getScreenId(ULONG *aScreenId);
475
476	// wrapped IDisplaySourceBitmap methods
477	virtual HRESULT queryBitmapInfo(BYTE **aAddress,
478	ULONG *aWidth,
479	ULONG *aHeight,
480	ULONG *aBitsPerPixel,
481	ULONG *aBytesPerLine,
482	BitmapFormat_T *aBitmapFormat);
483
484	int initSourceBitmap(unsigned aScreenId, DISPLAYFBINFO *pFBInfo);
485
486	struct Data
487	{
488	ComObjPtr<Display> pDisplay;
489	unsigned uScreenId;
490	DISPLAYFBINFO *pFBInfo;
491
492	uint8_t *pu8Allocated;
493
494	uint8_t *pu8Address;
495	ULONG ulWidth;
496	ULONG ulHeight;
497	ULONG ulBitsPerPixel;
498	ULONG ulBytesPerLine;
499	BitmapFormat_T bitmapFormat;
500	};
501
502	Data m;
503	};
504
505	class ATL_NO_VTABLE GuestScreenInfo:
506	public GuestScreenInfoWrap
507	{
508	public:
509
510	DECLARE_COMMON_CLASS_METHODS(GuestScreenInfo)
511
512	HRESULT FinalConstruct();
513	void FinalRelease();
514
515	/* Public initializer/uninitializer for internal purposes only. */
516	HRESULT init(ULONG aDisplay,
517	GuestMonitorStatus_T aGuestMonitorStatus,
518	BOOL aPrimary,
519	BOOL aChangeOrigin,
520	LONG aOriginX,
521	LONG aOriginY,
522	ULONG aWidth,
523	ULONG aHeight,
524	ULONG aBitsPerPixel);
525	void uninit();
526
527	private:
528	// wrapped IGuestScreenInfo properties
529	virtual HRESULT getScreenId(ULONG *aScreenId);
530	virtual HRESULT getGuestMonitorStatus(GuestMonitorStatus_T *aGuestMonitorStatus);
531	virtual HRESULT getPrimary(BOOL *aPrimary);
532	virtual HRESULT getOrigin(BOOL *aOrigin);
533	virtual HRESULT getOriginX(LONG *aOriginX);
534	virtual HRESULT getOriginY(LONG *aOriginY);
535	virtual HRESULT getWidth(ULONG *aWidth);
536	virtual HRESULT getHeight(ULONG *aHeight);
537	virtual HRESULT getBitsPerPixel(ULONG *aBitsPerPixel);
538	virtual HRESULT getExtendedInfo(com::Utf8Str &aExtendedInfo);
539
540	ULONG mScreenId;
541	GuestMonitorStatus_T mGuestMonitorStatus;
542	BOOL mPrimary;
543	BOOL mOrigin;
544	LONG mOriginX;
545	LONG mOriginY;
546	ULONG mWidth;
547	ULONG mHeight;
548	ULONG mBitsPerPixel;
549	};
550
551	#endif /* !MAIN_INCLUDED_DisplayImpl_h */
552	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: