DisplayImpl.cpp@ 61847

Last change on this file since 61847 was 61740, checked in by vboxsync, 9 years ago
Main/Display: when taking a screenshot of a blanked/disabled screen, return all black pixels (and there is no need to get the screen content, which might be garbage)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 150.2 KB

Line
1	/* $Id: DisplayImpl.cpp 61740 2016-06-17 10:19:23Z vboxsync $ */
2	/** @file
3	* VirtualBox COM class implementation
4	*/
5
6	/*
7	* Copyright (C) 2006-2016 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	#include "DisplayImpl.h"
19	#include "DisplayUtils.h"
20	#include "ConsoleImpl.h"
21	#include "ConsoleVRDPServer.h"
22	#include "GuestImpl.h"
23	#include "VMMDev.h"
24
25	#include "AutoCaller.h"
26	#include "Logging.h"
27
28	/* generated header */
29	#include "VBoxEvents.h"
30
31	#include <iprt/semaphore.h>
32	#include <iprt/thread.h>
33	#include <iprt/asm.h>
34	#include <iprt/time.h>
35	#include <iprt/cpp/utils.h>
36	#include <iprt/alloca.h>
37
38	#include <VBox/vmm/pdmdrv.h>
39	#if defined(DEBUG) \|\| defined(VBOX_STRICT) /* for VM_ASSERT_EMT(). */
40	# include <VBox/vmm/vm.h>
41	#endif
42
43	#ifdef VBOX_WITH_VIDEOHWACCEL
44	# include <VBox/VBoxVideo.h>
45	#endif
46
47	#if defined(VBOX_WITH_CROGL) \|\| defined(VBOX_WITH_CRHGSMI)
48	# include <VBox/HostServices/VBoxCrOpenGLSvc.h>
49	#endif
50
51	#include <VBox/com/array.h>
52
53	#ifdef VBOX_WITH_VPX
54	# include <iprt/path.h>
55	# include "VideoRec.h"
56	#endif
57
58	#ifdef VBOX_WITH_CROGL
59	typedef enum
60	{
61	CRVREC_STATE_IDLE,
62	CRVREC_STATE_SUBMITTED
63	} CRVREC_STATE;
64	#endif
65
66	/**
67	* Display driver instance data.
68	*
69	* @implements PDMIDISPLAYCONNECTOR
70	*/
71	typedef struct DRVMAINDISPLAY
72	{
73	/** Pointer to the display object. */
74	Display *pDisplay;
75	/** Pointer to the driver instance structure. */
76	PPDMDRVINS pDrvIns;
77	/** Pointer to the keyboard port interface of the driver/device above us. */
78	PPDMIDISPLAYPORT pUpPort;
79	/** Our display connector interface. */
80	PDMIDISPLAYCONNECTOR IConnector;
81	#if defined(VBOX_WITH_VIDEOHWACCEL) \|\| defined(VBOX_WITH_CRHGSMI)
82	/** VBVA callbacks */
83	PPDMIDISPLAYVBVACALLBACKS pVBVACallbacks;
84	#endif
85	} DRVMAINDISPLAY, *PDRVMAINDISPLAY;
86
87	/** Converts PDMIDISPLAYCONNECTOR pointer to a DRVMAINDISPLAY pointer. */
88	#define PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface) RT_FROM_MEMBER(pInterface, DRVMAINDISPLAY, IConnector)
89
90	// constructor / destructor
91	/////////////////////////////////////////////////////////////////////////////
92
93	Display::Display()
94	: mParent(NULL), mfIsCr3DEnabled(false)
95	{
96	}
97
98	Display::~Display()
99	{
100	}
101
102
103	HRESULT Display::FinalConstruct()
104	{
105	int rc = videoAccelConstruct(&mVideoAccelLegacy);
106	AssertRC(rc);
107
108	mfVideoAccelVRDP = false;
109	mfu32SupportedOrders = 0;
110	mcVideoAccelVRDPRefs = 0;
111
112	mfSeamlessEnabled = false;
113	mpRectVisibleRegion = NULL;
114	mcRectVisibleRegion = 0;
115
116	#ifdef VBOX_WITH_CROGL
117	mfCrOglDataHidden = false;
118	#endif
119
120	mpDrv = NULL;
121	mpVMMDev = NULL;
122	mfVMMDevInited = false;
123
124	rc = RTCritSectInit(&mVideoAccelLock);
125	AssertRC(rc);
126
127	#ifdef VBOX_WITH_HGSMI
128	mu32UpdateVBVAFlags = 0;
129	mfVMMDevSupportsGraphics = false;
130	mfGuestVBVACapabilities = 0;
131	mfHostCursorCapabilities = 0;
132	#endif
133	#ifdef VBOX_WITH_VPX
134	mpVideoRecCtx = NULL;
135	for (unsigned i = 0; i < RT_ELEMENTS(maVideoRecEnabled); i++)
136	maVideoRecEnabled[i] = true;
137	#endif
138
139	#ifdef VBOX_WITH_CRHGSMI
140	mhCrOglSvc = NULL;
141	rc = RTCritSectRwInit(&mCrOglLock);
142	AssertRC(rc);
143	#endif
144	#ifdef VBOX_WITH_CROGL
145	RT_ZERO(mCrOglCallbacks);
146	RT_ZERO(mCrOglScreenshotData);
147	mfCrOglVideoRecState = CRVREC_STATE_IDLE;
148	mCrOglScreenshotData.u32Screen = CRSCREEN_ALL;
149	mCrOglScreenshotData.pvContext = this;
150	mCrOglScreenshotData.pfnScreenshotBegin = i_displayCrVRecScreenshotBegin;
151	mCrOglScreenshotData.pfnScreenshotPerform = i_displayCrVRecScreenshotPerform;
152	mCrOglScreenshotData.pfnScreenshotEnd = i_displayCrVRecScreenshotEnd;
153	#endif
154
155	return BaseFinalConstruct();
156	}
157
158	void Display::FinalRelease()
159	{
160	uninit();
161
162	videoAccelDestroy(&mVideoAccelLegacy);
163	i_saveVisibleRegion(0, NULL);
164
165	if (RTCritSectIsInitialized(&mVideoAccelLock))
166	{
167	RTCritSectDelete(&mVideoAccelLock);
168	RT_ZERO(mVideoAccelLock);
169	}
170
171	#ifdef VBOX_WITH_CRHGSMI
172	if (RTCritSectRwIsInitialized(&mCrOglLock))
173	{
174	RTCritSectRwDelete(&mCrOglLock);
175	RT_ZERO(mCrOglLock);
176	}
177	#endif
178	BaseFinalRelease();
179	}
180
181	// public initializer/uninitializer for internal purposes only
182	/////////////////////////////////////////////////////////////////////////////
183
184	#define kMaxSizeThumbnail 64
185
186	/**
187	* Save thumbnail and screenshot of the guest screen.
188	*/
189	static int displayMakeThumbnail(uint8_t *pbData, uint32_t cx, uint32_t cy,
190	uint8_t *ppu8Thumbnail, uint32_t pcbThumbnail, uint32_t pcxThumbnail, uint32_t pcyThumbnail)
191	{
192	int rc = VINF_SUCCESS;
193
194	uint8_t *pu8Thumbnail = NULL;
195	uint32_t cbThumbnail = 0;
196	uint32_t cxThumbnail = 0;
197	uint32_t cyThumbnail = 0;
198
199	if (cx > cy)
200	{
201	cxThumbnail = kMaxSizeThumbnail;
202	cyThumbnail = (kMaxSizeThumbnail * cy) / cx;
203	}
204	else
205	{
206	cyThumbnail = kMaxSizeThumbnail;
207	cxThumbnail = (kMaxSizeThumbnail * cx) / cy;
208	}
209
210	LogRelFlowFunc(("%dx%d -> %dx%d\n", cx, cy, cxThumbnail, cyThumbnail));
211
212	cbThumbnail = cxThumbnail * 4 * cyThumbnail;
213	pu8Thumbnail = (uint8_t *)RTMemAlloc(cbThumbnail);
214
215	if (pu8Thumbnail)
216	{
217	uint8_t *dst = pu8Thumbnail;
218	uint8_t *src = pbData;
219	int dstW = cxThumbnail;
220	int dstH = cyThumbnail;
221	int srcW = cx;
222	int srcH = cy;
223	int iDeltaLine = cx * 4;
224
225	BitmapScale32(dst,
226	dstW, dstH,
227	src,
228	iDeltaLine,
229	srcW, srcH);
230
231	*ppu8Thumbnail = pu8Thumbnail;
232	*pcbThumbnail = cbThumbnail;
233	*pcxThumbnail = cxThumbnail;
234	*pcyThumbnail = cyThumbnail;
235	}
236	else
237	{
238	rc = VERR_NO_MEMORY;
239	}
240
241	return rc;
242	}
243
244	#ifdef VBOX_WITH_CROGL
245	typedef struct
246	{
247	CRVBOXHGCMTAKESCREENSHOT Base;
248
249	/* 32bpp small RGB image. */
250	uint8_t *pu8Thumbnail;
251	uint32_t cbThumbnail;
252	uint32_t cxThumbnail;
253	uint32_t cyThumbnail;
254
255	/* PNG screenshot. */
256	uint8_t *pu8PNG;
257	uint32_t cbPNG;
258	uint32_t cxPNG;
259	uint32_t cyPNG;
260	} VBOX_DISPLAY_SAVESCREENSHOT_DATA;
261
262	static DECLCALLBACK(void) displaySaveScreenshotReport(void *pvCtx, uint32_t uScreen,
263	uint32_t x, uint32_t y, uint32_t uBitsPerPixel,
264	uint32_t uBytesPerLine, uint32_t uGuestWidth, uint32_t uGuestHeight,
265	uint8_t *pu8BufferAddress, uint64_t u64TimeStamp)
266	{
267	VBOX_DISPLAY_SAVESCREENSHOT_DATA pData = (VBOX_DISPLAY_SAVESCREENSHOT_DATA)pvCtx;
268	displayMakeThumbnail(pu8BufferAddress, uGuestWidth, uGuestHeight, &pData->pu8Thumbnail,
269	&pData->cbThumbnail, &pData->cxThumbnail, &pData->cyThumbnail);
270	int rc = DisplayMakePNG(pu8BufferAddress, uGuestWidth, uGuestHeight, &pData->pu8PNG,
271	&pData->cbPNG, &pData->cxPNG, &pData->cyPNG, 1);
272	if (RT_FAILURE(rc))
273	{
274	AssertMsgFailed(("DisplayMakePNG failed (rc=%Rrc)\n", rc));
275	if (pData->pu8PNG)
276	{
277	RTMemFree(pData->pu8PNG);
278	pData->pu8PNG = NULL;
279	}
280	pData->cbPNG = 0;
281	pData->cxPNG = 0;
282	pData->cyPNG = 0;
283	}
284	}
285	#endif
286
287	DECLCALLBACK(void) Display::i_displaySSMSaveScreenshot(PSSMHANDLE pSSM, void *pvUser)
288	{
289	Display that = static_cast<Display>(pvUser);
290
291	/* 32bpp small RGB image. */
292	uint8_t *pu8Thumbnail = NULL;
293	uint32_t cbThumbnail = 0;
294	uint32_t cxThumbnail = 0;
295	uint32_t cyThumbnail = 0;
296
297	/* PNG screenshot. */
298	uint8_t *pu8PNG = NULL;
299	uint32_t cbPNG = 0;
300	uint32_t cxPNG = 0;
301	uint32_t cyPNG = 0;
302
303	Console::SafeVMPtr ptrVM(that->mParent);
304	if (ptrVM.isOk())
305	{
306	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
307	BOOL f3DSnapshot = FALSE;
308	if ( that->mfIsCr3DEnabled
309	&& that->mCrOglCallbacks.pfnHasData
310	&& that->mCrOglCallbacks.pfnHasData())
311	{
312	VMMDev *pVMMDev = that->mParent->i_getVMMDev();
313	if (pVMMDev)
314	{
315	VBOX_DISPLAY_SAVESCREENSHOT_DATA *pScreenshot;
316	pScreenshot = (VBOX_DISPLAY_SAVESCREENSHOT_DATA)RTMemAllocZ(sizeof(pScreenshot));
317	if (pScreenshot)
318	{
319	/* screen id or CRSCREEN_ALL to specify all enabled */
320	pScreenshot->Base.u32Screen = 0;
321	pScreenshot->Base.u32Width = 0;
322	pScreenshot->Base.u32Height = 0;
323	pScreenshot->Base.u32Pitch = 0;
324	pScreenshot->Base.pvBuffer = NULL;
325	pScreenshot->Base.pvContext = pScreenshot;
326	pScreenshot->Base.pfnScreenshotBegin = NULL;
327	pScreenshot->Base.pfnScreenshotPerform = displaySaveScreenshotReport;
328	pScreenshot->Base.pfnScreenshotEnd = NULL;
329
330	VBOXCRCMDCTL_HGCM data;
331	data.Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
332	data.Hdr.u32Function = SHCRGL_HOST_FN_TAKE_SCREENSHOT;
333
334	data.aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
335	data.aParms[0].u.pointer.addr = &pScreenshot->Base;
336	data.aParms[0].u.pointer.size = sizeof(pScreenshot->Base);
337
338	int rc = that->i_crCtlSubmitSync(&data.Hdr, sizeof(data));
339	if (RT_SUCCESS(rc))
340	{
341	if (pScreenshot->pu8PNG)
342	{
343	pu8Thumbnail = pScreenshot->pu8Thumbnail;
344	cbThumbnail = pScreenshot->cbThumbnail;
345	cxThumbnail = pScreenshot->cxThumbnail;
346	cyThumbnail = pScreenshot->cyThumbnail;
347
348	/* PNG screenshot. */
349	pu8PNG = pScreenshot->pu8PNG;
350	cbPNG = pScreenshot->cbPNG;
351	cxPNG = pScreenshot->cxPNG;
352	cyPNG = pScreenshot->cyPNG;
353	f3DSnapshot = TRUE;
354	}
355	else
356	AssertMsgFailed(("no png\n"));
357	}
358	else
359	AssertMsgFailed(("SHCRGL_HOST_FN_TAKE_SCREENSHOT failed (rc=%Rrc)\n", rc));
360
361
362	RTMemFree(pScreenshot);
363	}
364	}
365	}
366
367	if (!f3DSnapshot)
368	#endif
369	{
370	/* Query RGB bitmap. */
371	/* SSM code is executed on EMT(0), therefore no need to use VMR3ReqCallWait. */
372	uint8_t *pbData = NULL;
373	size_t cbData = 0;
374	uint32_t cx = 0;
375	uint32_t cy = 0;
376	bool fFreeMem = false;
377	int rc = Display::i_displayTakeScreenshotEMT(that, VBOX_VIDEO_PRIMARY_SCREEN, &pbData, &cbData, &cx, &cy, &fFreeMem);
378
379	/*
380	* It is possible that success is returned but everything is 0 or NULL.
381	* (no display attached if a VM is running with VBoxHeadless on OSE for example)
382	*/
383	if (RT_SUCCESS(rc) && pbData)
384	{
385	Assert(cx && cy);
386
387	/* Prepare a small thumbnail and a PNG screenshot. */
388	displayMakeThumbnail(pbData, cx, cy, &pu8Thumbnail, &cbThumbnail, &cxThumbnail, &cyThumbnail);
389	rc = DisplayMakePNG(pbData, cx, cy, &pu8PNG, &cbPNG, &cxPNG, &cyPNG, 1);
390	if (RT_FAILURE(rc))
391	{
392	if (pu8PNG)
393	{
394	RTMemFree(pu8PNG);
395	pu8PNG = NULL;
396	}
397	cbPNG = 0;
398	cxPNG = 0;
399	cyPNG = 0;
400	}
401
402	if (fFreeMem)
403	RTMemFree(pbData);
404	else
405	that->mpDrv->pUpPort->pfnFreeScreenshot(that->mpDrv->pUpPort, pbData);
406	}
407	}
408	}
409	else
410	{
411	LogFunc(("Failed to get VM pointer 0x%x\n", ptrVM.rc()));
412	}
413
414	/* Regardless of rc, save what is available:
415	* Data format:
416	* uint32_t cBlocks;
417	* [blocks]
418	*
419	* Each block is:
420	* uint32_t cbBlock; if 0 - no 'block data'.
421	* uint32_t typeOfBlock; 0 - 32bpp RGB bitmap, 1 - PNG, ignored if 'cbBlock' is 0.
422	* [block data]
423	*
424	* Block data for bitmap and PNG:
425	* uint32_t cx;
426	* uint32_t cy;
427	* [image data]
428	*/
429	SSMR3PutU32(pSSM, 2); /* Write thumbnail and PNG screenshot. */
430
431	/* First block. */
432	SSMR3PutU32(pSSM, cbThumbnail + 2 * sizeof(uint32_t));
433	SSMR3PutU32(pSSM, 0); /* Block type: thumbnail. */
434
435	if (cbThumbnail)
436	{
437	SSMR3PutU32(pSSM, cxThumbnail);
438	SSMR3PutU32(pSSM, cyThumbnail);
439	SSMR3PutMem(pSSM, pu8Thumbnail, cbThumbnail);
440	}
441
442	/* Second block. */
443	SSMR3PutU32(pSSM, cbPNG + 2 * sizeof(uint32_t));
444	SSMR3PutU32(pSSM, 1); /* Block type: png. */
445
446	if (cbPNG)
447	{
448	SSMR3PutU32(pSSM, cxPNG);
449	SSMR3PutU32(pSSM, cyPNG);
450	SSMR3PutMem(pSSM, pu8PNG, cbPNG);
451	}
452
453	RTMemFree(pu8PNG);
454	RTMemFree(pu8Thumbnail);
455	}
456
457	DECLCALLBACK(int)
458	Display::i_displaySSMLoadScreenshot(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass)
459	{
460	Display that = static_cast<Display>(pvUser);
461
462	if (uVersion != sSSMDisplayScreenshotVer)
463	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
464	Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
465
466	/* Skip data. */
467	uint32_t cBlocks;
468	int rc = SSMR3GetU32(pSSM, &cBlocks);
469	AssertRCReturn(rc, rc);
470
471	for (uint32_t i = 0; i < cBlocks; i++)
472	{
473	uint32_t cbBlock;
474	rc = SSMR3GetU32(pSSM, &cbBlock);
475	AssertRCBreak(rc);
476
477	uint32_t typeOfBlock;
478	rc = SSMR3GetU32(pSSM, &typeOfBlock);
479	AssertRCBreak(rc);
480
481	LogRelFlowFunc(("[%d] type %d, size %d bytes\n", i, typeOfBlock, cbBlock));
482
483	/* Note: displaySSMSaveScreenshot writes size of a block = 8 and
484	* do not write any data if the image size was 0.
485	* @todo Fix and increase saved state version.
486	*/
487	if (cbBlock > 2 * sizeof(uint32_t))
488	{
489	rc = SSMR3Skip(pSSM, cbBlock);
490	AssertRCBreak(rc);
491	}
492	}
493
494	return rc;
495	}
496
497	/**
498	* Save/Load some important guest state
499	*/
500	DECLCALLBACK(void)
501	Display::i_displaySSMSave(PSSMHANDLE pSSM, void *pvUser)
502	{
503	Display that = static_cast<Display>(pvUser);
504
505	SSMR3PutU32(pSSM, that->mcMonitors);
506	for (unsigned i = 0; i < that->mcMonitors; i++)
507	{
508	SSMR3PutU32(pSSM, that->maFramebuffers[i].u32Offset);
509	SSMR3PutU32(pSSM, that->maFramebuffers[i].u32MaxFramebufferSize);
510	SSMR3PutU32(pSSM, that->maFramebuffers[i].u32InformationSize);
511	SSMR3PutU32(pSSM, that->maFramebuffers[i].w);
512	SSMR3PutU32(pSSM, that->maFramebuffers[i].h);
513	SSMR3PutS32(pSSM, that->maFramebuffers[i].xOrigin);
514	SSMR3PutS32(pSSM, that->maFramebuffers[i].yOrigin);
515	SSMR3PutU32(pSSM, that->maFramebuffers[i].flags);
516	}
517	SSMR3PutS32(pSSM, that->xInputMappingOrigin);
518	SSMR3PutS32(pSSM, that->yInputMappingOrigin);
519	SSMR3PutU32(pSSM, that->cxInputMapping);
520	SSMR3PutU32(pSSM, that->cyInputMapping);
521	SSMR3PutU32(pSSM, that->mfGuestVBVACapabilities);
522	SSMR3PutU32(pSSM, that->mfHostCursorCapabilities);
523	}
524
525	DECLCALLBACK(int)
526	Display::i_displaySSMLoad(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass)
527	{
528	Display that = static_cast<Display>(pvUser);
529
530	if ( uVersion != sSSMDisplayVer
531	&& uVersion != sSSMDisplayVer2
532	&& uVersion != sSSMDisplayVer3
533	&& uVersion != sSSMDisplayVer4
534	&& uVersion != sSSMDisplayVer5)
535	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
536	Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
537
538	uint32_t cMonitors;
539	int rc = SSMR3GetU32(pSSM, &cMonitors);
540	if (cMonitors != that->mcMonitors)
541	return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Number of monitors changed (%d->%d)!"), cMonitors, that->mcMonitors);
542
543	for (uint32_t i = 0; i < cMonitors; i++)
544	{
545	SSMR3GetU32(pSSM, &that->maFramebuffers[i].u32Offset);
546	SSMR3GetU32(pSSM, &that->maFramebuffers[i].u32MaxFramebufferSize);
547	SSMR3GetU32(pSSM, &that->maFramebuffers[i].u32InformationSize);
548	if ( uVersion == sSSMDisplayVer2
549	\|\| uVersion == sSSMDisplayVer3
550	\|\| uVersion == sSSMDisplayVer4
551	\|\| uVersion == sSSMDisplayVer5)
552	{
553	uint32_t w;
554	uint32_t h;
555	SSMR3GetU32(pSSM, &w);
556	SSMR3GetU32(pSSM, &h);
557	that->maFramebuffers[i].w = w;
558	that->maFramebuffers[i].h = h;
559	}
560	if ( uVersion == sSSMDisplayVer3
561	\|\| uVersion == sSSMDisplayVer4
562	\|\| uVersion == sSSMDisplayVer5)
563	{
564	int32_t xOrigin;
565	int32_t yOrigin;
566	uint32_t flags;
567	SSMR3GetS32(pSSM, &xOrigin);
568	SSMR3GetS32(pSSM, &yOrigin);
569	SSMR3GetU32(pSSM, &flags);
570	that->maFramebuffers[i].xOrigin = xOrigin;
571	that->maFramebuffers[i].yOrigin = yOrigin;
572	that->maFramebuffers[i].flags = (uint16_t)flags;
573	that->maFramebuffers[i].fDisabled = (that->maFramebuffers[i].flags & VBVA_SCREEN_F_DISABLED) != 0;
574	}
575	}
576	if ( uVersion == sSSMDisplayVer4
577	\|\| uVersion == sSSMDisplayVer5)
578	{
579	SSMR3GetS32(pSSM, &that->xInputMappingOrigin);
580	SSMR3GetS32(pSSM, &that->yInputMappingOrigin);
581	SSMR3GetU32(pSSM, &that->cxInputMapping);
582	SSMR3GetU32(pSSM, &that->cyInputMapping);
583	}
584	if (uVersion == sSSMDisplayVer5)
585	{
586	SSMR3GetU32(pSSM, &that->mfGuestVBVACapabilities);
587	SSMR3GetU32(pSSM, &that->mfHostCursorCapabilities);
588	}
589
590	return VINF_SUCCESS;
591	}
592
593	/**
594	* Initializes the display object.
595	*
596	* @returns COM result indicator
597	* @param parent handle of our parent object
598	* @param qemuConsoleData address of common console data structure
599	*/
600	HRESULT Display::init(Console *aParent)
601	{
602	ComAssertRet(aParent, E_INVALIDARG);
603	/* Enclose the state transition NotReady->InInit->Ready */
604	AutoInitSpan autoInitSpan(this);
605	AssertReturn(autoInitSpan.isOk(), E_FAIL);
606
607	unconst(mParent) = aParent;
608
609	mfSourceBitmapEnabled = true;
610	fVGAResizing = false;
611
612	ULONG ul;
613	mParent->i_machine()->COMGETTER(MonitorCount)(&ul);
614	mcMonitors = ul;
615	xInputMappingOrigin = 0;
616	yInputMappingOrigin = 0;
617	cxInputMapping = 0;
618	cyInputMapping = 0;
619
620	for (ul = 0; ul < mcMonitors; ul++)
621	{
622	maFramebuffers[ul].u32Offset = 0;
623	maFramebuffers[ul].u32MaxFramebufferSize = 0;
624	maFramebuffers[ul].u32InformationSize = 0;
625
626	maFramebuffers[ul].pFramebuffer = NULL;
627	/* All secondary monitors are disabled at startup. */
628	maFramebuffers[ul].fDisabled = ul > 0;
629
630	maFramebuffers[ul].u32Caps = 0;
631
632	maFramebuffers[ul].updateImage.pu8Address = NULL;
633	maFramebuffers[ul].updateImage.cbLine = 0;
634
635	maFramebuffers[ul].xOrigin = 0;
636	maFramebuffers[ul].yOrigin = 0;
637
638	maFramebuffers[ul].w = 0;
639	maFramebuffers[ul].h = 0;
640
641	maFramebuffers[ul].flags = maFramebuffers[ul].fDisabled? VBVA_SCREEN_F_DISABLED: 0;
642
643	maFramebuffers[ul].u16BitsPerPixel = 0;
644	maFramebuffers[ul].pu8FramebufferVRAM = NULL;
645	maFramebuffers[ul].u32LineSize = 0;
646
647	maFramebuffers[ul].pHostEvents = NULL;
648
649	maFramebuffers[ul].fDefaultFormat = false;
650
651	#ifdef VBOX_WITH_HGSMI
652	maFramebuffers[ul].fVBVAEnabled = false;
653	maFramebuffers[ul].fVBVAForceResize = false;
654	maFramebuffers[ul].fRenderThreadMode = false;
655	maFramebuffers[ul].pVBVAHostFlags = NULL;
656	#endif /* VBOX_WITH_HGSMI */
657	#ifdef VBOX_WITH_CROGL
658	RT_ZERO(maFramebuffers[ul].pendingViewportInfo);
659	#endif
660	}
661
662	{
663	// register listener for state change events
664	ComPtr<IEventSource> es;
665	mParent->COMGETTER(EventSource)(es.asOutParam());
666	com::SafeArray<VBoxEventType_T> eventTypes;
667	eventTypes.push_back(VBoxEventType_OnStateChanged);
668	es->RegisterListener(this, ComSafeArrayAsInParam(eventTypes), true);
669	}
670
671	/* Cache the 3D settings. */
672	BOOL fIs3DEnabled = FALSE;
673	mParent->i_machine()->COMGETTER(Accelerate3DEnabled)(&fIs3DEnabled);
674	GraphicsControllerType_T enmGpuType = (GraphicsControllerType_T)GraphicsControllerType_VBoxVGA;
675	mParent->i_machine()->COMGETTER(GraphicsControllerType)(&enmGpuType);
676	mfIsCr3DEnabled = fIs3DEnabled && enmGpuType == GraphicsControllerType_VBoxVGA;
677
678	/* Confirm a successful initialization */
679	autoInitSpan.setSucceeded();
680
681	return S_OK;
682	}
683
684	/**
685	* Uninitializes the instance and sets the ready flag to FALSE.
686	* Called either from FinalRelease() or by the parent when it gets destroyed.
687	*/
688	void Display::uninit()
689	{
690	LogRelFlowFunc(("this=%p\n", this));
691
692	/* Enclose the state transition Ready->InUninit->NotReady */
693	AutoUninitSpan autoUninitSpan(this);
694	if (autoUninitSpan.uninitDone())
695	return;
696
697	unsigned uScreenId;
698	for (uScreenId = 0; uScreenId < mcMonitors; uScreenId++)
699	{
700	maFramebuffers[uScreenId].pSourceBitmap.setNull();
701	maFramebuffers[uScreenId].updateImage.pSourceBitmap.setNull();
702	maFramebuffers[uScreenId].updateImage.pu8Address = NULL;
703	maFramebuffers[uScreenId].updateImage.cbLine = 0;
704	maFramebuffers[uScreenId].pFramebuffer.setNull();
705	}
706
707	if (mParent)
708	{
709	ComPtr<IEventSource> es;
710	mParent->COMGETTER(EventSource)(es.asOutParam());
711	es->UnregisterListener(this);
712	}
713
714	unconst(mParent) = NULL;
715
716	if (mpDrv)
717	mpDrv->pDisplay = NULL;
718
719	mpDrv = NULL;
720	mpVMMDev = NULL;
721	mfVMMDevInited = true;
722	}
723
724	/**
725	* Register the SSM methods. Called by the power up thread to be able to
726	* pass pVM
727	*/
728	int Display::i_registerSSM(PUVM pUVM)
729	{
730	/* Version 2 adds width and height of the framebuffer; version 3 adds
731	* the framebuffer offset in the virtual desktop and the framebuffer flags;
732	* version 4 adds guest to host input event mapping and version 5 adds
733	* guest VBVA and host cursor capabilities.
734	*/
735	int rc = SSMR3RegisterExternal(pUVM, "DisplayData", 0, sSSMDisplayVer5,
736	mcMonitors * sizeof(uint32_t) * 8 + sizeof(uint32_t),
737	NULL, NULL, NULL,
738	NULL, i_displaySSMSave, NULL,
739	NULL, i_displaySSMLoad, NULL, this);
740	AssertRCReturn(rc, rc);
741
742	/*
743	* Register loaders for old saved states where iInstance was
744	* 3 * sizeof(uint32_t *) due to a code mistake.
745	*/
746	rc = SSMR3RegisterExternal(pUVM, "DisplayData", 12 /uInstance/, sSSMDisplayVer, 0 /cbGuess/,
747	NULL, NULL, NULL,
748	NULL, NULL, NULL,
749	NULL, i_displaySSMLoad, NULL, this);
750	AssertRCReturn(rc, rc);
751
752	rc = SSMR3RegisterExternal(pUVM, "DisplayData", 24 /uInstance/, sSSMDisplayVer, 0 /cbGuess/,
753	NULL, NULL, NULL,
754	NULL, NULL, NULL,
755	NULL, i_displaySSMLoad, NULL, this);
756	AssertRCReturn(rc, rc);
757
758	/* uInstance is an arbitrary value greater than 1024. Such a value will ensure a quick seek in saved state file. */
759	rc = SSMR3RegisterExternal(pUVM, "DisplayScreenshot", 1100 /uInstance/, sSSMDisplayScreenshotVer, 0 /cbGuess/,
760	NULL, NULL, NULL,
761	NULL, i_displaySSMSaveScreenshot, NULL,
762	NULL, i_displaySSMLoadScreenshot, NULL, this);
763
764	AssertRCReturn(rc, rc);
765
766	return VINF_SUCCESS;
767	}
768
769	DECLCALLBACK(void) Display::i_displayCrCmdFree(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, int rc, void *pvCompletion)
770	{
771	Assert(pvCompletion);
772	RTMemFree(pvCompletion);
773	}
774
775	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
776	int Display::i_crOglWindowsShow(bool fShow)
777	{
778	if (!mfCrOglDataHidden == !!fShow)
779	return VINF_SUCCESS;
780
781	if (!mhCrOglSvc)
782	{
783	/* No 3D or the VMSVGA3d kind. */
784	Assert(!mfIsCr3DEnabled);
785	return VERR_INVALID_STATE;
786	}
787
788	VMMDev *pVMMDev = mParent->i_getVMMDev();
789	if (!pVMMDev)
790	{
791	AssertMsgFailed(("no vmmdev\n"));
792	return VERR_INVALID_STATE;
793	}
794
795	VBOXCRCMDCTL_HGCM pData = (VBOXCRCMDCTL_HGCM)RTMemAlloc(sizeof(VBOXCRCMDCTL_HGCM));
796	if (!pData)
797	{
798	AssertMsgFailed(("RTMemAlloc failed\n"));
799	return VERR_NO_MEMORY;
800	}
801
802	pData->Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
803	pData->Hdr.u32Function = SHCRGL_HOST_FN_WINDOWS_SHOW;
804
805	pData->aParms[0].type = VBOX_HGCM_SVC_PARM_32BIT;
806	pData->aParms[0].u.uint32 = (uint32_t)fShow;
807
808	int rc = i_crCtlSubmit(&pData->Hdr, sizeof(*pData), i_displayCrCmdFree, pData);
809	if (RT_SUCCESS(rc))
810	mfCrOglDataHidden = !fShow;
811	else
812	{
813	AssertMsgFailed(("crCtlSubmit failed (rc=%Rrc)\n", rc));
814	RTMemFree(pData);
815	}
816
817	return rc;
818	}
819	#endif
820
821
822	// public methods only for internal purposes
823	/////////////////////////////////////////////////////////////////////////////
824
825	int Display::i_notifyCroglResize(const PVBVAINFOVIEW pView, const PVBVAINFOSCREEN pScreen, void *pvVRAM)
826	{
827	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
828	if (maFramebuffers[pScreen->u32ViewIndex].fRenderThreadMode)
829	return VINF_SUCCESS; /* nop it */
830
831	if (mfIsCr3DEnabled)
832	{
833	int rc = VERR_INVALID_STATE;
834	if (mhCrOglSvc)
835	{
836	VMMDev *pVMMDev = mParent->i_getVMMDev();
837	if (pVMMDev)
838	{
839	VBOXCRCMDCTL_HGCM *pCtl;
840	pCtl = (VBOXCRCMDCTL_HGCM*)RTMemAlloc(sizeof(CRVBOXHGCMDEVRESIZE) + sizeof(VBOXCRCMDCTL_HGCM));
841	if (pCtl)
842	{
843	CRVBOXHGCMDEVRESIZE pData = (CRVBOXHGCMDEVRESIZE)(pCtl+1);
844	pData->Screen = *pScreen;
845	pData->pvVRAM = pvVRAM;
846
847	pCtl->Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
848	pCtl->Hdr.u32Function = SHCRGL_HOST_FN_DEV_RESIZE;
849	pCtl->aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
850	pCtl->aParms[0].u.pointer.addr = pData;
851	pCtl->aParms[0].u.pointer.size = sizeof(*pData);
852
853	rc = i_crCtlSubmit(&pCtl->Hdr, sizeof(*pCtl), i_displayCrCmdFree, pCtl);
854	if (RT_FAILURE(rc))
855	{
856	AssertMsgFailed(("crCtlSubmit failed (rc=%Rrc)\n", rc));
857	RTMemFree(pCtl);
858	}
859	}
860	else
861	rc = VERR_NO_MEMORY;
862	}
863	}
864
865	return rc;
866	}
867	#endif /* #if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL) */
868	return VINF_SUCCESS;
869	}
870
871	/**
872	* Handles display resize event.
873	*
874	* @param w New display width
875	* @param h New display height
876	*
877	* @thread EMT
878	*/
879	int Display::i_handleDisplayResize(unsigned uScreenId, uint32_t bpp, void *pvVRAM,
880	uint32_t cbLine, uint32_t w, uint32_t h, uint16_t flags)
881	{
882	LogRel(("Display::handleDisplayResize: uScreenId=%d pvVRAM=%p w=%d h=%d bpp=%d cbLine=0x%X flags=0x%X\n", uScreenId,
883	pvVRAM, w, h, bpp, cbLine, flags));
884
885	if (uScreenId >= mcMonitors)
886	return VINF_SUCCESS;
887
888	DISPLAYFBINFO *pFBInfo = &maFramebuffers[uScreenId];
889
890	/* Reset the update mode. */
891	pFBInfo->updateImage.pSourceBitmap.setNull();
892	pFBInfo->updateImage.pu8Address = NULL;
893	pFBInfo->updateImage.cbLine = 0;
894
895	if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
896	{
897	pFBInfo->w = w;
898	pFBInfo->h = h;
899
900	pFBInfo->u16BitsPerPixel = (uint16_t)bpp;
901	pFBInfo->pu8FramebufferVRAM = (uint8_t *)pvVRAM;
902	pFBInfo->u32LineSize = cbLine;
903	pFBInfo->flags = flags;
904	}
905
906	/* Guest screen image will be invalid during resize, make sure that it is not updated. */
907	if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
908	{
909	mpDrv->pUpPort->pfnSetRenderVRAM(mpDrv->pUpPort, false);
910
911	mpDrv->IConnector.pbData = NULL;
912	mpDrv->IConnector.cbScanline = 0;
913	mpDrv->IConnector.cBits = 32; /* DevVGA does not work with cBits == 0. */
914	mpDrv->IConnector.cx = 0;
915	mpDrv->IConnector.cy = 0;
916	}
917
918	maFramebuffers[uScreenId].pSourceBitmap.setNull();
919
920	if (!maFramebuffers[uScreenId].pFramebuffer.isNull())
921	{
922	HRESULT hr = maFramebuffers[uScreenId].pFramebuffer->NotifyChange(uScreenId, 0, 0, w, h); /* @todo origin */
923	LogFunc(("NotifyChange hr %08X\n", hr));
924	NOREF(hr);
925	}
926
927	bool fUpdateImage = RT_BOOL(pFBInfo->u32Caps & FramebufferCapabilities_UpdateImage);
928	if (fUpdateImage && !pFBInfo->pFramebuffer.isNull())
929	{
930	ComPtr<IDisplaySourceBitmap> pSourceBitmap;
931	HRESULT hr = QuerySourceBitmap(uScreenId, pSourceBitmap.asOutParam());
932	if (SUCCEEDED(hr))
933	{
934	BYTE *pAddress = NULL;
935	ULONG ulWidth = 0;
936	ULONG ulHeight = 0;
937	ULONG ulBitsPerPixel = 0;
938	ULONG ulBytesPerLine = 0;
939	BitmapFormat_T bitmapFormat = BitmapFormat_Opaque;
940
941	hr = pSourceBitmap->QueryBitmapInfo(&pAddress,
942	&ulWidth,
943	&ulHeight,
944	&ulBitsPerPixel,
945	&ulBytesPerLine,
946	&bitmapFormat);
947	if (SUCCEEDED(hr))
948	{
949	pFBInfo->updateImage.pSourceBitmap = pSourceBitmap;
950	pFBInfo->updateImage.pu8Address = pAddress;
951	pFBInfo->updateImage.cbLine = ulBytesPerLine;
952	}
953	}
954	}
955
956	/* Inform the VRDP server about the change of display parameters. */
957	LogRelFlowFunc(("Calling VRDP\n"));
958	mParent->i_consoleVRDPServer()->SendResize();
959
960	/* And re-send the seamless rectangles if necessary. */
961	if (mfSeamlessEnabled)
962	i_handleSetVisibleRegion(mcRectVisibleRegion, mpRectVisibleRegion);
963
964	LogRelFlowFunc(("[%d]: default format %d\n", uScreenId, pFBInfo->fDefaultFormat));
965
966	return VINF_SUCCESS;
967	}
968
969	static void i_checkCoordBounds(int px, int py, int pw, int ph, int cx, int cy)
970	{
971	/* Correct negative x and y coordinates. */
972	if (*px < 0)
973	{
974	px += pw; /* Compute xRight which is also the new width. */
975
976	pw = (px < 0)? 0: *px;
977
978	*px = 0;
979	}
980
981	if (*py < 0)
982	{
983	py += ph; /* Compute xBottom, which is also the new height. */
984
985	ph = (py < 0)? 0: *py;
986
987	*py = 0;
988	}
989
990	/* Also check if coords are greater than the display resolution. */
991	if (px + pw > cx)
992	{
993	pw = cx > px? cx - *px: 0;
994	}
995
996	if (py + ph > cy)
997	{
998	ph = cy > py? cy - *py: 0;
999	}
1000	}
1001
1002	void Display::i_handleDisplayUpdate(unsigned uScreenId, int x, int y, int w, int h)
1003	{
1004	/*
1005	* Always runs under either VBVA lock or, for HGSMI, DevVGA lock.
1006	* Safe to use VBVA vars and take the framebuffer lock.
1007	*/
1008
1009	#ifdef DEBUG_sunlover
1010	LogFlowFunc(("[%d] %d,%d %dx%d\n",
1011	uScreenId, x, y, w, h));
1012	#endif /* DEBUG_sunlover */
1013
1014	/* No updates for a disabled guest screen. */
1015	if (maFramebuffers[uScreenId].fDisabled)
1016	return;
1017
1018	/* No updates for a blank guest screen. */
1019	/** @note Disabled for now, as the GUI does not update the picture when we
1020	* first blank. */
1021	/* if (maFramebuffers[uScreenId].flags & VBVA_SCREEN_F_BLANK)
1022	return; */
1023
1024	i_checkCoordBounds(&x, &y, &w, &h, maFramebuffers[uScreenId].w,
1025	maFramebuffers[uScreenId].h);
1026
1027	IFramebuffer *pFramebuffer = maFramebuffers[uScreenId].pFramebuffer;
1028	if (pFramebuffer != NULL)
1029	{
1030	if (w != 0 && h != 0)
1031	{
1032	bool fUpdateImage = RT_BOOL(maFramebuffers[uScreenId].u32Caps & FramebufferCapabilities_UpdateImage);
1033	if (RT_LIKELY(!fUpdateImage))
1034	{
1035	pFramebuffer->NotifyUpdate(x, y, w, h);
1036	}
1037	else
1038	{
1039	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1040
1041	DISPLAYFBINFO *pFBInfo = &maFramebuffers[uScreenId];
1042
1043	if (!pFBInfo->updateImage.pSourceBitmap.isNull())
1044	{
1045	Assert(pFBInfo->updateImage.pu8Address);
1046
1047	size_t cbData = w * h * 4;
1048	com::SafeArray<BYTE> image(cbData);
1049
1050	uint8_t *pu8Dst = image.raw();
1051	const uint8_t pu8Src = pFBInfo->updateImage.pu8Address + pFBInfo->updateImage.cbLine y + x * 4;
1052
1053	int i;
1054	for (i = y; i < y + h; ++i)
1055	{
1056	memcpy(pu8Dst, pu8Src, w * 4);
1057	pu8Dst += w * 4;
1058	pu8Src += pFBInfo->updateImage.cbLine;
1059	}
1060
1061	pFramebuffer->NotifyUpdateImage(x, y, w, h, ComSafeArrayAsInParam(image));
1062	}
1063	}
1064	}
1065	}
1066
1067	#ifndef VBOX_WITH_HGSMI
1068	if (!mVideoAccelLegacy.fVideoAccelEnabled)
1069	{
1070	#else
1071	if (!mVideoAccelLegacy.fVideoAccelEnabled && !maFramebuffers[uScreenId].fVBVAEnabled)
1072	{
1073	#endif /* VBOX_WITH_HGSMI */
1074	/* When VBVA is enabled, the VRDP server is informed
1075	* either in VideoAccelFlush or displayVBVAUpdateProcess.
1076	* Inform the server here only if VBVA is disabled.
1077	*/
1078	mParent->i_consoleVRDPServer()->SendUpdateBitmap(uScreenId, x, y, w, h);
1079	}
1080	}
1081
1082	void Display::i_updateGuestGraphicsFacility(void)
1083	{
1084	Guest* pGuest = mParent->i_getGuest();
1085	AssertPtrReturnVoid(pGuest);
1086	/* The following is from GuestImpl.cpp. */
1087	/** @todo A nit: The timestamp is wrong on saved state restore. Would be better
1088	* to move the graphics and seamless capability -> facility translation to
1089	* VMMDev so this could be saved. */
1090	RTTIMESPEC TimeSpecTS;
1091	RTTimeNow(&TimeSpecTS);
1092
1093	if ( mfVMMDevSupportsGraphics
1094	\|\| (mfGuestVBVACapabilities & VBVACAPS_VIDEO_MODE_HINTS) != 0)
1095	pGuest->i_setAdditionsStatus(VBoxGuestFacilityType_Graphics,
1096	VBoxGuestFacilityStatus_Active,
1097	0 /fFlags/, &TimeSpecTS);
1098	else
1099	pGuest->i_setAdditionsStatus(VBoxGuestFacilityType_Graphics,
1100	VBoxGuestFacilityStatus_Inactive,
1101	0 /fFlags/, &TimeSpecTS);
1102	}
1103
1104	void Display::i_handleUpdateVMMDevSupportsGraphics(bool fSupportsGraphics)
1105	{
1106	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1107	if (mfVMMDevSupportsGraphics == fSupportsGraphics)
1108	return;
1109	mfVMMDevSupportsGraphics = fSupportsGraphics;
1110	i_updateGuestGraphicsFacility();
1111	/* The VMMDev interface notifies the console. */
1112	}
1113
1114	void Display::i_handleUpdateGuestVBVACapabilities(uint32_t fNewCapabilities)
1115	{
1116	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1117	bool fNotify = (fNewCapabilities & VBVACAPS_VIDEO_MODE_HINTS) != (mfGuestVBVACapabilities & VBVACAPS_VIDEO_MODE_HINTS);
1118
1119	mfGuestVBVACapabilities = fNewCapabilities;
1120	if (!fNotify)
1121	return;
1122	i_updateGuestGraphicsFacility();
1123	/* Tell the console about it */
1124	mParent->i_onAdditionsStateChange();
1125	}
1126
1127	void Display::i_handleUpdateVBVAInputMapping(int32_t xOrigin, int32_t yOrigin, uint32_t cx, uint32_t cy)
1128	{
1129	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1130
1131	xInputMappingOrigin = xOrigin;
1132	yInputMappingOrigin = yOrigin;
1133	cxInputMapping = cx;
1134	cyInputMapping = cy;
1135
1136	/* Re-send the seamless rectangles if necessary. */
1137	if (mfSeamlessEnabled)
1138	i_handleSetVisibleRegion(mcRectVisibleRegion, mpRectVisibleRegion);
1139	}
1140
1141	/**
1142	* Returns the upper left and lower right corners of the virtual framebuffer.
1143	* The lower right is "exclusive" (i.e. first pixel beyond the framebuffer),
1144	* and the origin is (0, 0), not (1, 1) like the GUI returns.
1145	*/
1146	void Display::i_getFramebufferDimensions(int32_t px1, int32_t py1,
1147	int32_t px2, int32_t py2)
1148	{
1149	int32_t x1 = 0, y1 = 0, x2 = 0, y2 = 0;
1150	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1151
1152	AssertPtrReturnVoid(px1);
1153	AssertPtrReturnVoid(py1);
1154	AssertPtrReturnVoid(px2);
1155	AssertPtrReturnVoid(py2);
1156	LogRelFlowFunc(("\n"));
1157
1158	if (!mpDrv)
1159	return;
1160	/* If VBVA is not in use then this flag will not be set and this
1161	* will still work as it should. */
1162	if (!maFramebuffers[0].fDisabled)
1163	{
1164	x1 = (int32_t)maFramebuffers[0].xOrigin;
1165	y1 = (int32_t)maFramebuffers[0].yOrigin;
1166	x2 = (int32_t)maFramebuffers[0].w + (int32_t)maFramebuffers[0].xOrigin;
1167	y2 = (int32_t)maFramebuffers[0].h + (int32_t)maFramebuffers[0].yOrigin;
1168	}
1169	if (cxInputMapping && cyInputMapping)
1170	{
1171	x1 = xInputMappingOrigin;
1172	y1 = yInputMappingOrigin;
1173	x2 = xInputMappingOrigin + cxInputMapping;
1174	y2 = yInputMappingOrigin + cyInputMapping;
1175	}
1176	else
1177	for (unsigned i = 1; i < mcMonitors; ++i)
1178	{
1179	if (!maFramebuffers[i].fDisabled)
1180	{
1181	x1 = RT_MIN(x1, maFramebuffers[i].xOrigin);
1182	y1 = RT_MIN(y1, maFramebuffers[i].yOrigin);
1183	x2 = RT_MAX(x2, maFramebuffers[i].xOrigin + (int32_t)maFramebuffers[i].w);
1184	y2 = RT_MAX(y2, maFramebuffers[i].yOrigin + (int32_t)maFramebuffers[i].h);
1185	}
1186	}
1187	*px1 = x1;
1188	*py1 = y1;
1189	*px2 = x2;
1190	*py2 = y2;
1191	}
1192
1193	HRESULT Display::i_reportHostCursorCapabilities(uint32_t fCapabilitiesAdded, uint32_t fCapabilitiesRemoved)
1194	{
1195	/* Do we need this to access mParent? I presume that the safe VM pointer
1196	* ensures that mpDrv will remain valid. */
1197	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1198	uint32_t fHostCursorCapabilities = (mfHostCursorCapabilities \| fCapabilitiesAdded)
1199	& ~fCapabilitiesRemoved;
1200
1201	Console::SafeVMPtr ptrVM(mParent);
1202	if (!ptrVM.isOk())
1203	return ptrVM.rc();
1204	if (mfHostCursorCapabilities == fHostCursorCapabilities)
1205	return S_OK;
1206	CHECK_CONSOLE_DRV(mpDrv);
1207	alock.release(); /* Release before calling up for lock order reasons. */
1208	mpDrv->pUpPort->pfnReportHostCursorCapabilities(mpDrv->pUpPort, fCapabilitiesAdded, fCapabilitiesRemoved);
1209	mfHostCursorCapabilities = fHostCursorCapabilities;
1210	return S_OK;
1211	}
1212
1213	HRESULT Display::i_reportHostCursorPosition(int32_t x, int32_t y)
1214	{
1215	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1216	uint32_t xAdj = (uint32_t)RT_MAX(x - xInputMappingOrigin, 0);
1217	uint32_t yAdj = (uint32_t)RT_MAX(y - yInputMappingOrigin, 0);
1218	xAdj = RT_MIN(xAdj, cxInputMapping);
1219	yAdj = RT_MIN(yAdj, cyInputMapping);
1220
1221	Console::SafeVMPtr ptrVM(mParent);
1222	if (!ptrVM.isOk())
1223	return ptrVM.rc();
1224	CHECK_CONSOLE_DRV(mpDrv);
1225	alock.release(); /* Release before calling up for lock order reasons. */
1226	mpDrv->pUpPort->pfnReportHostCursorPosition(mpDrv->pUpPort, xAdj, yAdj);
1227	return S_OK;
1228	}
1229
1230	static bool displayIntersectRect(RTRECT *prectResult,
1231	const RTRECT *prect1,
1232	const RTRECT *prect2)
1233	{
1234	/* Initialize result to an empty record. */
1235	memset(prectResult, 0, sizeof(RTRECT));
1236
1237	int xLeftResult = RT_MAX(prect1->xLeft, prect2->xLeft);
1238	int xRightResult = RT_MIN(prect1->xRight, prect2->xRight);
1239
1240	if (xLeftResult < xRightResult)
1241	{
1242	/* There is intersection by X. */
1243
1244	int yTopResult = RT_MAX(prect1->yTop, prect2->yTop);
1245	int yBottomResult = RT_MIN(prect1->yBottom, prect2->yBottom);
1246
1247	if (yTopResult < yBottomResult)
1248	{
1249	/* There is intersection by Y. */
1250
1251	prectResult->xLeft = xLeftResult;
1252	prectResult->yTop = yTopResult;
1253	prectResult->xRight = xRightResult;
1254	prectResult->yBottom = yBottomResult;
1255
1256	return true;
1257	}
1258	}
1259
1260	return false;
1261	}
1262
1263	int Display::i_saveVisibleRegion(uint32_t cRect, PRTRECT pRect)
1264	{
1265	RTRECT *pRectVisibleRegion = NULL;
1266
1267	if (pRect == mpRectVisibleRegion)
1268	return VINF_SUCCESS;
1269	if (cRect != 0)
1270	{
1271	pRectVisibleRegion = (RTRECT )RTMemAlloc(cRect sizeof(RTRECT));
1272	if (!pRectVisibleRegion)
1273	{
1274	return VERR_NO_MEMORY;
1275	}
1276	memcpy(pRectVisibleRegion, pRect, cRect * sizeof(RTRECT));
1277	}
1278	if (mpRectVisibleRegion)
1279	RTMemFree(mpRectVisibleRegion);
1280	mcRectVisibleRegion = cRect;
1281	mpRectVisibleRegion = pRectVisibleRegion;
1282	return VINF_SUCCESS;
1283	}
1284
1285	int Display::i_handleSetVisibleRegion(uint32_t cRect, PRTRECT pRect)
1286	{
1287	RTRECT pVisibleRegion = (RTRECT )RTMemTmpAlloc( RT_MAX(cRect, 1)
1288	* sizeof(RTRECT));
1289	LogRel2(("%s: cRect=%u\n", __PRETTY_FUNCTION__, cRect));
1290	if (!pVisibleRegion)
1291	{
1292	return VERR_NO_TMP_MEMORY;
1293	}
1294	int rc = i_saveVisibleRegion(cRect, pRect);
1295	if (RT_FAILURE(rc))
1296	{
1297	RTMemTmpFree(pVisibleRegion);
1298	return rc;
1299	}
1300
1301	unsigned uScreenId;
1302	for (uScreenId = 0; uScreenId < mcMonitors; uScreenId++)
1303	{
1304	DISPLAYFBINFO *pFBInfo = &maFramebuffers[uScreenId];
1305
1306	if ( !pFBInfo->pFramebuffer.isNull()
1307	&& RT_BOOL(pFBInfo->u32Caps & FramebufferCapabilities_VisibleRegion))
1308	{
1309	/* Prepare a new array of rectangles which intersect with the framebuffer.
1310	*/
1311	RTRECT rectFramebuffer;
1312	rectFramebuffer.xLeft = pFBInfo->xOrigin - xInputMappingOrigin;
1313	rectFramebuffer.yTop = pFBInfo->yOrigin - yInputMappingOrigin;
1314	rectFramebuffer.xRight = rectFramebuffer.xLeft + pFBInfo->w;
1315	rectFramebuffer.yBottom = rectFramebuffer.yTop + pFBInfo->h;
1316
1317	uint32_t cRectVisibleRegion = 0;
1318
1319	uint32_t i;
1320	for (i = 0; i < cRect; i++)
1321	{
1322	if (displayIntersectRect(&pVisibleRegion[cRectVisibleRegion], &pRect[i], &rectFramebuffer))
1323	{
1324	pVisibleRegion[cRectVisibleRegion].xLeft -= rectFramebuffer.xLeft;
1325	pVisibleRegion[cRectVisibleRegion].yTop -= rectFramebuffer.yTop;
1326	pVisibleRegion[cRectVisibleRegion].xRight -= rectFramebuffer.xLeft;
1327	pVisibleRegion[cRectVisibleRegion].yBottom -= rectFramebuffer.yTop;
1328
1329	cRectVisibleRegion++;
1330	}
1331	}
1332	pFBInfo->pFramebuffer->SetVisibleRegion((BYTE *)pVisibleRegion, cRectVisibleRegion);
1333	}
1334	}
1335
1336	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
1337	VMMDev *vmmDev = mParent->i_getVMMDev();
1338	if (mfIsCr3DEnabled && vmmDev)
1339	{
1340	if (mhCrOglSvc)
1341	{
1342	VBOXCRCMDCTL_HGCM *pCtl;
1343	pCtl = (VBOXCRCMDCTL_HGCM)RTMemAlloc(RT_MAX(cRect, 1) sizeof(RTRECT) + sizeof(VBOXCRCMDCTL_HGCM));
1344	if (pCtl)
1345	{
1346	RTRECT pRectsCopy = (RTRECT)(pCtl+1);
1347	memcpy(pRectsCopy, pRect, cRect * sizeof(RTRECT));
1348
1349	pCtl->Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
1350	pCtl->Hdr.u32Function = SHCRGL_HOST_FN_SET_VISIBLE_REGION;
1351
1352	pCtl->aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
1353	pCtl->aParms[0].u.pointer.addr = pRectsCopy;
1354	pCtl->aParms[0].u.pointer.size = cRect * sizeof(RTRECT);
1355
1356	rc = i_crCtlSubmit(&pCtl->Hdr, sizeof(*pCtl), i_displayCrCmdFree, pCtl);
1357	if (!RT_SUCCESS(rc))
1358	{
1359	AssertMsgFailed(("crCtlSubmit failed (rc=%Rrc)\n", rc));
1360	RTMemFree(pCtl);
1361	}
1362	}
1363	else
1364	AssertMsgFailed(("failed to allocate rects memory\n"));
1365	}
1366	else
1367	AssertMsgFailed(("mhCrOglSvc is NULL\n"));
1368	}
1369	#endif
1370
1371	RTMemTmpFree(pVisibleRegion);
1372
1373	return VINF_SUCCESS;
1374	}
1375
1376	int Display::i_handleQueryVisibleRegion(uint32_t *pcRect, PRTRECT pRect)
1377	{
1378	// @todo Currently not used by the guest and is not implemented in framebuffers. Remove?
1379	return VERR_NOT_SUPPORTED;
1380	}
1381
1382	#ifdef VBOX_WITH_HGSMI
1383	static void vbvaSetMemoryFlagsHGSMI(unsigned uScreenId,
1384	uint32_t fu32SupportedOrders,
1385	bool fVideoAccelVRDP,
1386	DISPLAYFBINFO *pFBInfo)
1387	{
1388	LogRelFlowFunc(("HGSMI[%d]: %p\n", uScreenId, pFBInfo->pVBVAHostFlags));
1389
1390	if (pFBInfo->pVBVAHostFlags)
1391	{
1392	uint32_t fu32HostEvents = VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET;
1393
1394	if (pFBInfo->fVBVAEnabled)
1395	{
1396	fu32HostEvents \|= VBVA_F_MODE_ENABLED;
1397
1398	if (fVideoAccelVRDP)
1399	{
1400	fu32HostEvents \|= VBVA_F_MODE_VRDP;
1401	}
1402	}
1403
1404	ASMAtomicWriteU32(&pFBInfo->pVBVAHostFlags->u32HostEvents, fu32HostEvents);
1405	ASMAtomicWriteU32(&pFBInfo->pVBVAHostFlags->u32SupportedOrders, fu32SupportedOrders);
1406
1407	LogRelFlowFunc((" fu32HostEvents = 0x%08X, fu32SupportedOrders = 0x%08X\n", fu32HostEvents, fu32SupportedOrders));
1408	}
1409	}
1410
1411	static void vbvaSetMemoryFlagsAllHGSMI(uint32_t fu32SupportedOrders,
1412	bool fVideoAccelVRDP,
1413	DISPLAYFBINFO *paFBInfos,
1414	unsigned cFBInfos)
1415	{
1416	unsigned uScreenId;
1417
1418	for (uScreenId = 0; uScreenId < cFBInfos; uScreenId++)
1419	{
1420	vbvaSetMemoryFlagsHGSMI(uScreenId, fu32SupportedOrders, fVideoAccelVRDP, &paFBInfos[uScreenId]);
1421	}
1422	}
1423	#endif /* VBOX_WITH_HGSMI */
1424
1425	int Display::VideoAccelEnableVMMDev(bool fEnable, VBVAMEMORY *pVbvaMemory)
1426	{
1427	LogFlowFunc(("%d %p\n", fEnable, pVbvaMemory));
1428	int rc = videoAccelEnterVMMDev(&mVideoAccelLegacy);
1429	if (RT_SUCCESS(rc))
1430	{
1431	rc = i_VideoAccelEnable(fEnable, pVbvaMemory, mpDrv->pUpPort);
1432	videoAccelLeaveVMMDev(&mVideoAccelLegacy);
1433	}
1434	LogFlowFunc(("leave %Rrc\n", rc));
1435	return rc;
1436	}
1437
1438	int Display::VideoAccelEnableVGA(bool fEnable, VBVAMEMORY *pVbvaMemory)
1439	{
1440	LogFlowFunc(("%d %p\n", fEnable, pVbvaMemory));
1441	int rc = videoAccelEnterVGA(&mVideoAccelLegacy);
1442	if (RT_SUCCESS(rc))
1443	{
1444	rc = i_VideoAccelEnable(fEnable, pVbvaMemory, mpDrv->pUpPort);
1445	videoAccelLeaveVGA(&mVideoAccelLegacy);
1446	}
1447	LogFlowFunc(("leave %Rrc\n", rc));
1448	return rc;
1449	}
1450
1451	void Display::VideoAccelFlushVMMDev(void)
1452	{
1453	LogFlowFunc(("enter\n"));
1454	int rc = videoAccelEnterVMMDev(&mVideoAccelLegacy);
1455	if (RT_SUCCESS(rc))
1456	{
1457	i_VideoAccelFlush(mpDrv->pUpPort);
1458	videoAccelLeaveVMMDev(&mVideoAccelLegacy);
1459	}
1460	LogFlowFunc(("leave\n"));
1461	}
1462
1463	/* Called always by one VRDP server thread. Can be thread-unsafe.
1464	*/
1465	void Display::i_VideoAccelVRDP(bool fEnable)
1466	{
1467	LogRelFlowFunc(("fEnable = %d\n", fEnable));
1468
1469	VIDEOACCEL *pVideoAccel = &mVideoAccelLegacy;
1470
1471	int c = fEnable?
1472	ASMAtomicIncS32(&mcVideoAccelVRDPRefs):
1473	ASMAtomicDecS32(&mcVideoAccelVRDPRefs);
1474
1475	Assert (c >= 0);
1476
1477	/* This can run concurrently with Display videoaccel state change. */
1478	RTCritSectEnter(&mVideoAccelLock);
1479
1480	if (c == 0)
1481	{
1482	/* The last client has disconnected, and the accel can be
1483	* disabled.
1484	*/
1485	Assert(fEnable == false);
1486
1487	mfVideoAccelVRDP = false;
1488	mfu32SupportedOrders = 0;
1489
1490	i_vbvaSetMemoryFlags(pVideoAccel->pVbvaMemory, pVideoAccel->fVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders,
1491	maFramebuffers, mcMonitors);
1492	#ifdef VBOX_WITH_HGSMI
1493	/* Here is VRDP-IN thread. Process the request in vbvaUpdateBegin under DevVGA lock on an EMT. */
1494	ASMAtomicIncU32(&mu32UpdateVBVAFlags);
1495	#endif /* VBOX_WITH_HGSMI */
1496
1497	LogRel(("VBVA: VRDP acceleration has been disabled.\n"));
1498	}
1499	else if ( c == 1
1500	&& !mfVideoAccelVRDP)
1501	{
1502	/* The first client has connected. Enable the accel.
1503	*/
1504	Assert(fEnable == true);
1505
1506	mfVideoAccelVRDP = true;
1507	/* Supporting all orders. */
1508	mfu32SupportedOrders = ~0;
1509
1510	i_vbvaSetMemoryFlags(pVideoAccel->pVbvaMemory, pVideoAccel->fVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders,
1511	maFramebuffers, mcMonitors);
1512	#ifdef VBOX_WITH_HGSMI
1513	/* Here is VRDP-IN thread. Process the request in vbvaUpdateBegin under DevVGA lock on an EMT. */
1514	ASMAtomicIncU32(&mu32UpdateVBVAFlags);
1515	#endif /* VBOX_WITH_HGSMI */
1516
1517	LogRel(("VBVA: VRDP acceleration has been requested.\n"));
1518	}
1519	else
1520	{
1521	/* A client is connected or disconnected but there is no change in the
1522	* accel state. It remains enabled.
1523	*/
1524	Assert(mfVideoAccelVRDP == true);
1525	}
1526
1527	RTCritSectLeave(&mVideoAccelLock);
1528	}
1529
1530	void Display::i_notifyPowerDown(void)
1531	{
1532	LogRelFlowFunc(("\n"));
1533
1534	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1535
1536	/* Source bitmaps are not available anymore. */
1537	mfSourceBitmapEnabled = false;
1538
1539	alock.release();
1540
1541	/* Resize all displays to tell framebuffers to forget current source bitmap. */
1542	unsigned uScreenId = mcMonitors;
1543	while (uScreenId > 0)
1544	{
1545	--uScreenId;
1546
1547	DISPLAYFBINFO *pFBInfo = &maFramebuffers[uScreenId];
1548	if (!pFBInfo->fDisabled)
1549	{
1550	i_handleDisplayResize(uScreenId, 32,
1551	pFBInfo->pu8FramebufferVRAM,
1552	pFBInfo->u32LineSize,
1553	pFBInfo->w,
1554	pFBInfo->h,
1555	pFBInfo->flags);
1556	}
1557	}
1558	}
1559
1560	// Wrapped IDisplay methods
1561	/////////////////////////////////////////////////////////////////////////////
1562	HRESULT Display::getScreenResolution(ULONG aScreenId, ULONG aWidth, ULONG aHeight, ULONG *aBitsPerPixel,
1563	LONG aXOrigin, LONG aYOrigin, GuestMonitorStatus_T *aGuestMonitorStatus)
1564	{
1565	LogRelFlowFunc(("aScreenId=%RU32\n", aScreenId));
1566
1567	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1568
1569	if (aScreenId >= mcMonitors)
1570	return E_INVALIDARG;
1571
1572	DISPLAYFBINFO *pFBInfo = &maFramebuffers[aScreenId];
1573
1574	GuestMonitorStatus_T guestMonitorStatus = GuestMonitorStatus_Enabled;
1575	if (pFBInfo->flags & VBVA_SCREEN_F_DISABLED)
1576	guestMonitorStatus = GuestMonitorStatus_Disabled;
1577
1578	if (aWidth)
1579	*aWidth = pFBInfo->w;
1580	if (aHeight)
1581	*aHeight = pFBInfo->h;
1582	if (aBitsPerPixel)
1583	*aBitsPerPixel = pFBInfo->u16BitsPerPixel;
1584	if (aXOrigin)
1585	*aXOrigin = pFBInfo->xOrigin;
1586	if (aYOrigin)
1587	*aYOrigin = pFBInfo->yOrigin;
1588	if (aGuestMonitorStatus)
1589	*aGuestMonitorStatus = guestMonitorStatus;
1590
1591	return S_OK;
1592	}
1593
1594
1595	HRESULT Display::attachFramebuffer(ULONG aScreenId, const ComPtr<IFramebuffer> &aFramebuffer, com::Guid &aId)
1596	{
1597	LogRelFlowFunc(("aScreenId = %d\n", aScreenId));
1598
1599	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1600
1601	if (aScreenId >= mcMonitors)
1602	return setError(E_INVALIDARG, tr("AttachFramebuffer: Invalid screen %d (total %d)"),
1603	aScreenId, mcMonitors);
1604
1605	DISPLAYFBINFO *pFBInfo = &maFramebuffers[aScreenId];
1606	if (!pFBInfo->pFramebuffer.isNull())
1607	return setError(E_FAIL, tr("AttachFramebuffer: Framebuffer already attached to %d"),
1608	aScreenId);
1609
1610	pFBInfo->pFramebuffer = aFramebuffer;
1611	pFBInfo->framebufferId.create();
1612	aId = pFBInfo->framebufferId;
1613
1614	SafeArray<FramebufferCapabilities_T> caps;
1615	pFBInfo->pFramebuffer->COMGETTER(Capabilities)(ComSafeArrayAsOutParam(caps));
1616	pFBInfo->u32Caps = 0;
1617	size_t i;
1618	for (i = 0; i < caps.size(); ++i)
1619	pFBInfo->u32Caps \|= caps[i];
1620
1621	alock.release();
1622
1623	/* The driver might not have been constructed yet */
1624	if (mpDrv)
1625	{
1626	/* Setup the new framebuffer. */
1627	i_handleDisplayResize(aScreenId, pFBInfo->u16BitsPerPixel,
1628	pFBInfo->pu8FramebufferVRAM,
1629	pFBInfo->u32LineSize,
1630	pFBInfo->w,
1631	pFBInfo->h,
1632	pFBInfo->flags);
1633	}
1634
1635	Console::SafeVMPtrQuiet ptrVM(mParent);
1636	if (ptrVM.isOk())
1637	{
1638	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
1639	if (mfIsCr3DEnabled)
1640	{
1641	VBOXCRCMDCTL_HGCM data;
1642	RT_ZERO(data);
1643	data.Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
1644	data.Hdr.u32Function = SHCRGL_HOST_FN_SCREEN_CHANGED;
1645
1646	data.aParms[0].type = VBOX_HGCM_SVC_PARM_32BIT;
1647	data.aParms[0].u.uint32 = aScreenId;
1648
1649	int vrc = i_crCtlSubmitSync(&data.Hdr, sizeof(data));
1650	AssertRC(vrc);
1651	}
1652	#endif /* defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL) */
1653
1654	VMR3ReqCallNoWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_InvalidateAndUpdateEMT,
1655	3, this, aScreenId, false);
1656	}
1657
1658	LogRelFlowFunc(("Attached to %d %RTuuid\n", aScreenId, aId.raw()));
1659	return S_OK;
1660	}
1661
1662	HRESULT Display::detachFramebuffer(ULONG aScreenId, const com::Guid &aId)
1663	{
1664	LogRelFlowFunc(("aScreenId = %d %RTuuid\n", aScreenId, aId.raw()));
1665
1666	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1667
1668	if (aScreenId >= mcMonitors)
1669	return setError(E_INVALIDARG, tr("DetachFramebuffer: Invalid screen %d (total %d)"),
1670	aScreenId, mcMonitors);
1671
1672	DISPLAYFBINFO *pFBInfo = &maFramebuffers[aScreenId];
1673
1674	if (pFBInfo->framebufferId != aId)
1675	{
1676	LogRelFlowFunc(("Invalid framebuffer aScreenId = %d, attached %p\n", aScreenId, pFBInfo->framebufferId.raw()));
1677	return setError(E_FAIL, tr("DetachFramebuffer: Invalid framebuffer object"));
1678	}
1679
1680	pFBInfo->pFramebuffer.setNull();
1681	pFBInfo->framebufferId.clear();
1682
1683	alock.release();
1684
1685	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
1686	Console::SafeVMPtrQuiet ptrVM(mParent);
1687	if (ptrVM.isOk())
1688	{
1689	if (mfIsCr3DEnabled)
1690	{
1691	VBOXCRCMDCTL_HGCM data;
1692	RT_ZERO(data);
1693	data.Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
1694	data.Hdr.u32Function = SHCRGL_HOST_FN_SCREEN_CHANGED;
1695
1696	data.aParms[0].type = VBOX_HGCM_SVC_PARM_32BIT;
1697	data.aParms[0].u.uint32 = aScreenId;
1698
1699	int vrc = i_crCtlSubmitSync(&data.Hdr, sizeof(data));
1700	AssertRC(vrc);
1701	}
1702	}
1703	#endif /* defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL) */
1704
1705	return S_OK;
1706	}
1707
1708	HRESULT Display::queryFramebuffer(ULONG aScreenId, ComPtr<IFramebuffer> &aFramebuffer)
1709	{
1710	LogRelFlowFunc(("aScreenId = %d\n", aScreenId));
1711
1712	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1713
1714	if (aScreenId >= mcMonitors)
1715	return setError(E_INVALIDARG, tr("QueryFramebuffer: Invalid screen %d (total %d)"),
1716	aScreenId, mcMonitors);
1717
1718	DISPLAYFBINFO *pFBInfo = &maFramebuffers[aScreenId];
1719
1720	pFBInfo->pFramebuffer.queryInterfaceTo(aFramebuffer.asOutParam());
1721
1722	return S_OK;
1723	}
1724
1725	HRESULT Display::setVideoModeHint(ULONG aDisplay, BOOL aEnabled,
1726	BOOL aChangeOrigin, LONG aOriginX, LONG aOriginY,
1727	ULONG aWidth, ULONG aHeight, ULONG aBitsPerPixel)
1728	{
1729	if (aWidth == 0 \|\| aHeight == 0 \|\| aBitsPerPixel == 0)
1730	{
1731	/* Some of parameters must not change. Query current mode. */
1732	ULONG ulWidth = 0;
1733	ULONG ulHeight = 0;
1734	ULONG ulBitsPerPixel = 0;
1735	HRESULT hr = getScreenResolution(aDisplay, &ulWidth, &ulHeight, &ulBitsPerPixel, NULL, NULL, NULL);
1736	if (FAILED(hr))
1737	return hr;
1738
1739	/* Assign current values to not changing parameters. */
1740	if (aWidth == 0)
1741	aWidth = ulWidth;
1742	if (aHeight == 0)
1743	aHeight = ulHeight;
1744	if (aBitsPerPixel == 0)
1745	aBitsPerPixel = ulBitsPerPixel;
1746	}
1747
1748	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1749
1750	if (aDisplay >= mcMonitors)
1751	return E_INVALIDARG;
1752
1753	CHECK_CONSOLE_DRV(mpDrv);
1754
1755	/*
1756	* It is up to the guest to decide whether the hint is
1757	* valid. Therefore don't do any VRAM sanity checks here.
1758	*/
1759
1760	/* Have to release the lock because the pfnRequestDisplayChange
1761	* will call EMT. */
1762	alock.release();
1763
1764	/* We always send the hint to the graphics card in case the guest enables
1765	* support later. For now we notify exactly when support is enabled. */
1766	mpDrv->pUpPort->pfnSendModeHint(mpDrv->pUpPort, aWidth, aHeight,
1767	aBitsPerPixel, aDisplay,
1768	aChangeOrigin ? aOriginX : ~0,
1769	aChangeOrigin ? aOriginY : ~0,
1770	RT_BOOL(aEnabled),
1771	mfGuestVBVACapabilities
1772	& VBVACAPS_VIDEO_MODE_HINTS);
1773	if ( mfGuestVBVACapabilities & VBVACAPS_VIDEO_MODE_HINTS
1774	&& !(mfGuestVBVACapabilities & VBVACAPS_IRQ))
1775	{
1776	mParent->i_sendACPIMonitorHotPlugEvent();
1777	}
1778
1779	/* We currently never suppress the VMMDev hint if the guest has requested
1780	* it. Specifically the video graphics driver may not be responsible for
1781	* screen positioning in the guest virtual desktop, and the component
1782	* responsible may want to get the hint from VMMDev. */
1783	VMMDev *pVMMDev = mParent->i_getVMMDev();
1784	if (pVMMDev)
1785	{
1786	PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
1787	if (pVMMDevPort)
1788	pVMMDevPort->pfnRequestDisplayChange(pVMMDevPort, aWidth, aHeight, aBitsPerPixel,
1789	aDisplay, aOriginX, aOriginY,
1790	RT_BOOL(aEnabled), RT_BOOL(aChangeOrigin));
1791	}
1792	return S_OK;
1793	}
1794
1795	HRESULT Display::setSeamlessMode(BOOL enabled)
1796	{
1797	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1798
1799	/* Have to release the lock because the pfnRequestSeamlessChange will call EMT. */
1800	alock.release();
1801
1802	VMMDev *pVMMDev = mParent->i_getVMMDev();
1803	if (pVMMDev)
1804	{
1805	PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
1806	if (pVMMDevPort)
1807	pVMMDevPort->pfnRequestSeamlessChange(pVMMDevPort, !!enabled);
1808	}
1809	mfSeamlessEnabled = RT_BOOL(enabled);
1810
1811	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
1812	if (!enabled)
1813	{
1814	VMMDev *vmmDev = mParent->i_getVMMDev();
1815	if (mfIsCr3DEnabled && vmmDev)
1816	{
1817	VBOXCRCMDCTL_HGCM pData = (VBOXCRCMDCTL_HGCM)RTMemAlloc(sizeof(VBOXCRCMDCTL_HGCM));
1818	if (!pData)
1819	{
1820	AssertMsgFailed(("RTMemAlloc failed\n"));
1821	return VERR_NO_MEMORY;
1822	}
1823
1824	pData->Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
1825	pData->Hdr.u32Function = SHCRGL_HOST_FN_SET_VISIBLE_REGION;
1826
1827	pData->aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
1828	pData->aParms[0].u.pointer.addr = NULL;
1829	pData->aParms[0].u.pointer.size = 0; /* <- means null rects, NULL pRects address and 0 rects means "disable" */
1830
1831	int rc = i_crCtlSubmit(&pData->Hdr, sizeof(*pData), i_displayCrCmdFree, pData);
1832	if (!RT_SUCCESS(rc))
1833	{
1834	AssertMsgFailed(("crCtlSubmit failed (rc=%Rrc)\n", rc));
1835	RTMemFree(pData);
1836	}
1837	}
1838	}
1839	#endif
1840	return S_OK;
1841	}
1842
1843	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
1844	BOOL Display::i_displayCheckTakeScreenshotCrOgl(Display pDisplay, ULONG aScreenId, uint8_t pbData,
1845	uint32_t u32Width, uint32_t u32Height)
1846	{
1847	if ( pDisplay->mfIsCr3DEnabled
1848	&& pDisplay->mCrOglCallbacks.pfnHasData
1849	&& pDisplay->mCrOglCallbacks.pfnHasData())
1850	{
1851	VMMDev *pVMMDev = pDisplay->mParent->i_getVMMDev();
1852	if (pVMMDev)
1853	{
1854	CRVBOXHGCMTAKESCREENSHOT pScreenshot = (CRVBOXHGCMTAKESCREENSHOT )RTMemAlloc(sizeof(*pScreenshot));
1855	if (pScreenshot)
1856	{
1857	/* screen id or CRSCREEN_ALL to specify all enabled */
1858	pScreenshot->u32Screen = aScreenId;
1859	pScreenshot->u32Width = u32Width;
1860	pScreenshot->u32Height = u32Height;
1861	pScreenshot->u32Pitch = u32Width * 4;
1862	pScreenshot->pvBuffer = pbData;
1863	pScreenshot->pvContext = NULL;
1864	pScreenshot->pfnScreenshotBegin = NULL;
1865	pScreenshot->pfnScreenshotPerform = NULL;
1866	pScreenshot->pfnScreenshotEnd = NULL;
1867
1868	VBOXCRCMDCTL_HGCM data;
1869	data.Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
1870	data.Hdr.u32Function = SHCRGL_HOST_FN_TAKE_SCREENSHOT;
1871
1872	data.aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
1873	data.aParms[0].u.pointer.addr = pScreenshot;
1874	data.aParms[0].u.pointer.size = sizeof(*pScreenshot);
1875
1876	int rc = pDisplay->i_crCtlSubmitSync(&data.Hdr, sizeof(data));
1877
1878	RTMemFree(pScreenshot);
1879
1880	if (RT_SUCCESS(rc))
1881	return TRUE;
1882	AssertMsgFailed(("failed to get screenshot data from crOgl (rc=%Rrc)\n", rc));
1883	/* fall back to the non-3d mechanism */
1884	}
1885	}
1886	}
1887	return FALSE;
1888	}
1889	#endif
1890
1891	/* static */
1892	int Display::i_displayTakeScreenshotEMT(Display pDisplay, ULONG aScreenId, uint8_t ppbData, size_t pcbData,
1893	uint32_t pcx, uint32_t pcy, bool *pfMemFree)
1894	{
1895	int rc;
1896	if ( aScreenId == VBOX_VIDEO_PRIMARY_SCREEN
1897	&& pDisplay->maFramebuffers[aScreenId].fVBVAEnabled == false) /* A non-VBVA mode. */
1898	{
1899	rc = pDisplay->mpDrv->pUpPort->pfnTakeScreenshot(pDisplay->mpDrv->pUpPort, ppbData, pcbData, pcx, pcy);
1900	*pfMemFree = false;
1901	}
1902	else if (aScreenId < pDisplay->mcMonitors)
1903	{
1904	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[aScreenId];
1905
1906	uint32_t width = pFBInfo->w;
1907	uint32_t height = pFBInfo->h;
1908
1909	/* Allocate 32 bit per pixel bitmap. */
1910	size_t cbRequired = width * 4 * height;
1911
1912	if (cbRequired)
1913	{
1914	uint8_t pbDst = (uint8_t )RTMemAlloc(cbRequired);
1915	if (pbDst != NULL)
1916	{
1917	if (pFBInfo->flags & VBVA_SCREEN_F_ACTIVE)
1918	{
1919	/* Copy guest VRAM to the allocated 32bpp buffer. */
1920	const uint8_t *pu8Src = pFBInfo->pu8FramebufferVRAM;
1921	int32_t xSrc = 0;
1922	int32_t ySrc = 0;
1923	uint32_t u32SrcWidth = width;
1924	uint32_t u32SrcHeight = height;
1925	uint32_t u32SrcLineSize = pFBInfo->u32LineSize;
1926	uint32_t u32SrcBitsPerPixel = pFBInfo->u16BitsPerPixel;
1927
1928	int32_t xDst = 0;
1929	int32_t yDst = 0;
1930	uint32_t u32DstWidth = u32SrcWidth;
1931	uint32_t u32DstHeight = u32SrcHeight;
1932	uint32_t u32DstLineSize = u32DstWidth * 4;
1933	uint32_t u32DstBitsPerPixel = 32;
1934
1935	rc = pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
1936	width, height,
1937	pu8Src,
1938	xSrc, ySrc,
1939	u32SrcWidth, u32SrcHeight,
1940	u32SrcLineSize, u32SrcBitsPerPixel,
1941	pbDst,
1942	xDst, yDst,
1943	u32DstWidth, u32DstHeight,
1944	u32DstLineSize, u32DstBitsPerPixel);
1945	}
1946	else
1947	{
1948	memset(pbDst, 0, cbRequired);
1949	rc = VINF_SUCCESS;
1950	}
1951	if (RT_SUCCESS(rc))
1952	{
1953	*ppbData = pbDst;
1954	*pcbData = cbRequired;
1955	*pcx = width;
1956	*pcy = height;
1957	*pfMemFree = true;
1958	}
1959	else
1960	{
1961	RTMemFree(pbDst);
1962
1963	/* CopyRect can fail if VBVA was paused in VGA device, retry using the generic method. */
1964	if ( rc == VERR_INVALID_STATE
1965	&& aScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
1966	{
1967	rc = pDisplay->mpDrv->pUpPort->pfnTakeScreenshot(pDisplay->mpDrv->pUpPort, ppbData, pcbData, pcx, pcy);
1968	*pfMemFree = false;
1969	}
1970	}
1971	}
1972	else
1973	rc = VERR_NO_MEMORY;
1974	}
1975	else
1976	{
1977	/* No image. */
1978	*ppbData = NULL;
1979	*pcbData = 0;
1980	*pcx = 0;
1981	*pcy = 0;
1982	*pfMemFree = true;
1983	rc = VINF_SUCCESS;
1984	}
1985	}
1986	else
1987	rc = VERR_INVALID_PARAMETER;
1988	return rc;
1989	}
1990
1991	static int i_displayTakeScreenshot(PUVM pUVM, Display pDisplay, struct DRVMAINDISPLAY pDrv, ULONG aScreenId,
1992	BYTE *address, ULONG width, ULONG height)
1993	{
1994	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
1995	/*
1996	* CrOgl screenshot hook/hack.
1997	*/
1998	if (Display::i_displayCheckTakeScreenshotCrOgl(pDisplay, aScreenId, (uint8_t *)address, width, height))
1999	return VINF_SUCCESS;
2000	#endif
2001
2002	uint8_t *pbData = NULL;
2003	size_t cbData = 0;
2004	uint32_t cx = 0;
2005	uint32_t cy = 0;
2006	bool fFreeMem = false;
2007	int vrc = VINF_SUCCESS;
2008
2009	int cRetries = 5;
2010	while (cRetries-- > 0)
2011	{
2012	/* Note! Not sure if the priority call is such a good idea here, but
2013	it would be nice to have an accurate screenshot for the bug
2014	report if the VM deadlocks. */
2015	vrc = VMR3ReqPriorityCallWaitU(pUVM, VMCPUID_ANY, (PFNRT)Display::i_displayTakeScreenshotEMT, 7,
2016	pDisplay, aScreenId, &pbData, &cbData, &cx, &cy, &fFreeMem);
2017	if (vrc != VERR_TRY_AGAIN)
2018	{
2019	break;
2020	}
2021
2022	RTThreadSleep(10);
2023	}
2024
2025	if (RT_SUCCESS(vrc) && pbData)
2026	{
2027	if (cx == width && cy == height)
2028	{
2029	/* No scaling required. */
2030	memcpy(address, pbData, cbData);
2031	}
2032	else
2033	{
2034	/* Scale. */
2035	LogRelFlowFunc(("SCALE: %dx%d -> %dx%d\n", cx, cy, width, height));
2036
2037	uint8_t *dst = address;
2038	uint8_t *src = pbData;
2039	int dstW = width;
2040	int dstH = height;
2041	int srcW = cx;
2042	int srcH = cy;
2043	int iDeltaLine = cx * 4;
2044
2045	BitmapScale32(dst,
2046	dstW, dstH,
2047	src,
2048	iDeltaLine,
2049	srcW, srcH);
2050	}
2051
2052	if (fFreeMem)
2053	RTMemFree(pbData);
2054	else
2055	{
2056	/* This can be called from any thread. */
2057	pDrv->pUpPort->pfnFreeScreenshot(pDrv->pUpPort, pbData);
2058	}
2059	}
2060
2061	return vrc;
2062	}
2063
2064	HRESULT Display::takeScreenShotWorker(ULONG aScreenId,
2065	BYTE *aAddress,
2066	ULONG aWidth,
2067	ULONG aHeight,
2068	BitmapFormat_T aBitmapFormat,
2069	ULONG *pcbOut)
2070	{
2071	HRESULT rc = S_OK;
2072
2073	/* Do not allow too small and too large screenshots. This also filters out negative
2074	* values passed as either 'aWidth' or 'aHeight'.
2075	*/
2076	CheckComArgExpr(aWidth, aWidth != 0 && aWidth <= 32767);
2077	CheckComArgExpr(aHeight, aHeight != 0 && aHeight <= 32767);
2078
2079	if ( aBitmapFormat != BitmapFormat_BGR0
2080	&& aBitmapFormat != BitmapFormat_BGRA
2081	&& aBitmapFormat != BitmapFormat_RGBA
2082	&& aBitmapFormat != BitmapFormat_PNG)
2083	{
2084	return setError(E_NOTIMPL,
2085	tr("Unsupported screenshot format 0x%08X"), aBitmapFormat);
2086	}
2087
2088	Console::SafeVMPtr ptrVM(mParent);
2089	if (!ptrVM.isOk())
2090	return ptrVM.rc();
2091
2092	int vrc = i_displayTakeScreenshot(ptrVM.rawUVM(), this, mpDrv, aScreenId, aAddress, aWidth, aHeight);
2093
2094	if (RT_SUCCESS(vrc))
2095	{
2096	const size_t cbData = aWidth * 4 * aHeight;
2097
2098	/* Most of uncompressed formats. */
2099	*pcbOut = (ULONG)cbData;
2100
2101	if (aBitmapFormat == BitmapFormat_BGR0)
2102	{
2103	/* Do nothing. */
2104	}
2105	else if (aBitmapFormat == BitmapFormat_BGRA)
2106	{
2107	uint32_t pu32 = (uint32_t )aAddress;
2108	size_t cPixels = aWidth * aHeight;
2109	while (cPixels--)
2110	{
2111	*pu32++ \|= UINT32_C(0xFF000000);
2112	}
2113	}
2114	else if (aBitmapFormat == BitmapFormat_RGBA)
2115	{
2116	uint8_t *pu8 = aAddress;
2117	size_t cPixels = aWidth * aHeight;
2118	while (cPixels--)
2119	{
2120	uint8_t u8 = pu8[0];
2121	pu8[0] = pu8[2];
2122	pu8[2] = u8;
2123	pu8[3] = 0xFF;
2124
2125	pu8 += 4;
2126	}
2127	}
2128	else if (aBitmapFormat == BitmapFormat_PNG)
2129	{
2130	uint8_t *pu8PNG = NULL;
2131	uint32_t cbPNG = 0;
2132	uint32_t cxPNG = 0;
2133	uint32_t cyPNG = 0;
2134
2135	vrc = DisplayMakePNG(aAddress, aWidth, aHeight, &pu8PNG, &cbPNG, &cxPNG, &cyPNG, 0);
2136	if (RT_SUCCESS(vrc))
2137	{
2138	if (cbPNG <= cbData)
2139	{
2140	memcpy(aAddress, pu8PNG, cbPNG);
2141	*pcbOut = cbPNG;
2142	}
2143	else
2144	{
2145	rc = setError(E_FAIL,
2146	tr("PNG is larger than 32bpp bitmap"));
2147	}
2148	}
2149	else
2150	{
2151	rc = setError(VBOX_E_IPRT_ERROR,
2152	tr("Could not convert screenshot to PNG (%Rrc)"), vrc);
2153	}
2154	RTMemFree(pu8PNG);
2155	}
2156	}
2157	else if (vrc == VERR_TRY_AGAIN)
2158	rc = setError(E_UNEXPECTED,
2159	tr("Screenshot is not available at this time"));
2160	else if (RT_FAILURE(vrc))
2161	rc = setError(VBOX_E_IPRT_ERROR,
2162	tr("Could not take a screenshot (%Rrc)"), vrc);
2163
2164	return rc;
2165	}
2166
2167	HRESULT Display::takeScreenShot(ULONG aScreenId,
2168	BYTE *aAddress,
2169	ULONG aWidth,
2170	ULONG aHeight,
2171	BitmapFormat_T aBitmapFormat)
2172	{
2173	HRESULT rc = S_OK;
2174
2175	LogRelFlowFunc(("[%d] address=%p, width=%d, height=%d, format 0x%08X\n",
2176	aScreenId, aAddress, aWidth, aHeight, aBitmapFormat));
2177
2178	ULONG cbOut = 0;
2179	rc = takeScreenShotWorker(aScreenId, aAddress, aWidth, aHeight, aBitmapFormat, &cbOut);
2180	NOREF(cbOut);
2181
2182	LogRelFlowFunc(("%Rhrc\n", rc));
2183	return rc;
2184	}
2185
2186	HRESULT Display::takeScreenShotToArray(ULONG aScreenId,
2187	ULONG aWidth,
2188	ULONG aHeight,
2189	BitmapFormat_T aBitmapFormat,
2190	std::vector<BYTE> &aScreenData)
2191	{
2192	HRESULT rc = S_OK;
2193
2194	LogRelFlowFunc(("[%d] width=%d, height=%d, format 0x%08X\n",
2195	aScreenId, aWidth, aHeight, aBitmapFormat));
2196
2197	/* Do not allow too small and too large screenshots. This also filters out negative
2198	* values passed as either 'aWidth' or 'aHeight'.
2199	*/
2200	CheckComArgExpr(aWidth, aWidth != 0 && aWidth <= 32767);
2201	CheckComArgExpr(aHeight, aHeight != 0 && aHeight <= 32767);
2202
2203	const size_t cbData = aWidth * 4 * aHeight;
2204	aScreenData.resize(cbData);
2205
2206	ULONG cbOut = 0;
2207	rc = takeScreenShotWorker(aScreenId, &aScreenData.front(), aWidth, aHeight, aBitmapFormat, &cbOut);
2208	if (FAILED(rc))
2209	cbOut = 0;
2210
2211	aScreenData.resize(cbOut);
2212
2213	LogRelFlowFunc(("%Rhrc\n", rc));
2214	return rc;
2215	}
2216
2217
2218	int Display::i_VideoCaptureEnableScreens(ComSafeArrayIn(BOOL, aScreens))
2219	{
2220	#ifdef VBOX_WITH_VPX
2221	com::SafeArray<BOOL> Screens(ComSafeArrayInArg(aScreens));
2222	for (unsigned i = 0; i < Screens.size(); i++)
2223	maVideoRecEnabled[i] = RT_BOOL(Screens[i]);
2224	return VINF_SUCCESS;
2225	#else
2226	return VERR_NOT_IMPLEMENTED;
2227	#endif
2228	}
2229
2230	/**
2231	* Start video capturing. Does nothing if capturing is already active.
2232	*/
2233	int Display::i_VideoCaptureStart()
2234	{
2235	#ifdef VBOX_WITH_VPX
2236	if (VideoRecIsEnabled(mpVideoRecCtx))
2237	return VINF_SUCCESS;
2238
2239	int rc = VideoRecContextCreate(&mpVideoRecCtx, mcMonitors);
2240	if (RT_FAILURE(rc))
2241	{
2242	LogFlow(("Failed to create video recording context (%Rrc)!\n", rc));
2243	return rc;
2244	}
2245	ComPtr<IMachine> pMachine = mParent->i_machine();
2246	com::SafeArray<BOOL> screens;
2247	HRESULT hrc = pMachine->COMGETTER(VideoCaptureScreens)(ComSafeArrayAsOutParam(screens));
2248	AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
2249	for (unsigned i = 0; i < RT_ELEMENTS(maVideoRecEnabled); i++)
2250	maVideoRecEnabled[i] = i < screens.size() && screens[i];
2251	ULONG ulWidth;
2252	hrc = pMachine->COMGETTER(VideoCaptureWidth)(&ulWidth);
2253	AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
2254	ULONG ulHeight;
2255	hrc = pMachine->COMGETTER(VideoCaptureHeight)(&ulHeight);
2256	AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
2257	ULONG ulRate;
2258	hrc = pMachine->COMGETTER(VideoCaptureRate)(&ulRate);
2259	AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
2260	ULONG ulFPS;
2261	hrc = pMachine->COMGETTER(VideoCaptureFPS)(&ulFPS);
2262	AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
2263	BSTR strFile;
2264	hrc = pMachine->COMGETTER(VideoCaptureFile)(&strFile);
2265	AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
2266	ULONG ulMaxTime;
2267	hrc = pMachine->COMGETTER(VideoCaptureMaxTime)(&ulMaxTime);
2268	AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
2269	ULONG ulMaxSize;
2270	hrc = pMachine->COMGETTER(VideoCaptureMaxFileSize)(&ulMaxSize);
2271	AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
2272	BSTR strOptions;
2273	hrc = pMachine->COMGETTER(VideoCaptureOptions)(&strOptions);
2274	AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
2275
2276	RTTIMESPEC ts;
2277	RTTimeNow(&ts);
2278	RTTIME time;
2279	RTTimeExplode(&time, &ts);
2280	for (unsigned uScreen = 0; uScreen < mcMonitors; uScreen++)
2281	{
2282	char *pszAbsPath = RTPathAbsDup(com::Utf8Str(strFile).c_str());
2283	char *pszSuff = RTPathSuffix(pszAbsPath);
2284	if (pszSuff)
2285	pszSuff = RTStrDup(pszSuff);
2286	RTPathStripSuffix(pszAbsPath);
2287	if (!pszAbsPath)
2288	rc = VERR_INVALID_PARAMETER;
2289	if (!pszSuff)
2290	pszSuff = RTStrDup(".webm");
2291	char *pszName = NULL;
2292	if (RT_SUCCESS(rc))
2293	{
2294	if (mcMonitors > 1)
2295	rc = RTStrAPrintf(&pszName, "%s-%u%s", pszAbsPath, uScreen+1, pszSuff);
2296	else
2297	rc = RTStrAPrintf(&pszName, "%s%s", pszAbsPath, pszSuff);
2298	}
2299	if (RT_SUCCESS(rc))
2300	{
2301	rc = VideoRecStrmInit(mpVideoRecCtx, uScreen,
2302	pszName, ulWidth, ulHeight,
2303	ulRate, ulFPS, ulMaxTime,
2304	ulMaxSize, com::Utf8Str(strOptions).c_str());
2305	if (rc == VERR_ALREADY_EXISTS)
2306	{
2307	RTStrFree(pszName);
2308	pszName = NULL;
2309
2310	if (mcMonitors > 1)
2311	rc = RTStrAPrintf(&pszName, "%s-%04d-%02u-%02uT%02u-%02u-%02u-%09uZ-%u%s",
2312	pszAbsPath, time.i32Year, time.u8Month, time.u8MonthDay,
2313	time.u8Hour, time.u8Minute, time.u8Second, time.u32Nanosecond,
2314	uScreen+1, pszSuff);
2315	else
2316	rc = RTStrAPrintf(&pszName, "%s-%04d-%02u-%02uT%02u-%02u-%02u-%09uZ%s",
2317	pszAbsPath, time.i32Year, time.u8Month, time.u8MonthDay,
2318	time.u8Hour, time.u8Minute, time.u8Second, time.u32Nanosecond,
2319	pszSuff);
2320	if (RT_SUCCESS(rc))
2321	rc = VideoRecStrmInit(mpVideoRecCtx, uScreen,
2322	pszName, ulWidth, ulHeight, ulRate,
2323	ulFPS, ulMaxTime,
2324	ulMaxSize, com::Utf8Str(strOptions).c_str());
2325	}
2326	}
2327
2328	if (RT_SUCCESS(rc))
2329	{
2330	LogRel(("Display::VideoCaptureStart: WebM/VP8 video recording screen #%u with %ux%u @ %u kbps, %u fps to '%s' "
2331	"enabled\n", uScreen, ulWidth, ulHeight, ulRate, ulFPS, pszName));
2332	}
2333	else
2334	LogRel(("Display::VideoCaptureStart: Failed to initialize video recording context #%u (%Rrc)!\n", uScreen, rc));
2335	RTStrFree(pszName);
2336	RTStrFree(pszSuff);
2337	RTStrFree(pszAbsPath);
2338	}
2339	return rc;
2340	#else
2341	return VERR_NOT_IMPLEMENTED;
2342	#endif
2343	}
2344
2345	/**
2346	* Stop video capturing. Does nothing if video capturing is not active.
2347	*/
2348	void Display::i_VideoCaptureStop()
2349	{
2350	#ifdef VBOX_WITH_VPX
2351	if (VideoRecIsEnabled(mpVideoRecCtx))
2352	LogRel(("Display::VideoCaptureStop: WebM/VP8 video recording stopped\n"));
2353	VideoRecContextClose(mpVideoRecCtx);
2354	mpVideoRecCtx = NULL;
2355	#endif
2356	}
2357
2358	int Display::i_drawToScreenEMT(Display pDisplay, ULONG aScreenId, BYTE address,
2359	ULONG x, ULONG y, ULONG width, ULONG height)
2360	{
2361	int rc = VINF_SUCCESS;
2362
2363	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[aScreenId];
2364
2365	if (aScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
2366	{
2367	rc = pDisplay->mpDrv->pUpPort->pfnDisplayBlt(pDisplay->mpDrv->pUpPort, address, x, y, width, height);
2368	}
2369	else if (aScreenId < pDisplay->mcMonitors)
2370	{
2371	/* Copy the bitmap to the guest VRAM. */
2372	const uint8_t *pu8Src = address;
2373	int32_t xSrc = 0;
2374	int32_t ySrc = 0;
2375	uint32_t u32SrcWidth = width;
2376	uint32_t u32SrcHeight = height;
2377	uint32_t u32SrcLineSize = width * 4;
2378	uint32_t u32SrcBitsPerPixel = 32;
2379
2380	uint8_t *pu8Dst = pFBInfo->pu8FramebufferVRAM;
2381	int32_t xDst = x;
2382	int32_t yDst = y;
2383	uint32_t u32DstWidth = pFBInfo->w;
2384	uint32_t u32DstHeight = pFBInfo->h;
2385	uint32_t u32DstLineSize = pFBInfo->u32LineSize;
2386	uint32_t u32DstBitsPerPixel = pFBInfo->u16BitsPerPixel;
2387
2388	rc = pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
2389	width, height,
2390	pu8Src,
2391	xSrc, ySrc,
2392	u32SrcWidth, u32SrcHeight,
2393	u32SrcLineSize, u32SrcBitsPerPixel,
2394	pu8Dst,
2395	xDst, yDst,
2396	u32DstWidth, u32DstHeight,
2397	u32DstLineSize, u32DstBitsPerPixel);
2398	if (RT_SUCCESS(rc))
2399	{
2400	if (!pFBInfo->pSourceBitmap.isNull())
2401	{
2402	/* Update the changed screen area. When source bitmap uses VRAM directly, just notify
2403	* frontend to update. And for default format, render the guest VRAM to the source bitmap.
2404	*/
2405	if ( pFBInfo->fDefaultFormat
2406	&& !pFBInfo->fDisabled)
2407	{
2408	BYTE *pAddress = NULL;
2409	ULONG ulWidth = 0;
2410	ULONG ulHeight = 0;
2411	ULONG ulBitsPerPixel = 0;
2412	ULONG ulBytesPerLine = 0;
2413	BitmapFormat_T bitmapFormat = BitmapFormat_Opaque;
2414
2415	HRESULT hrc = pFBInfo->pSourceBitmap->QueryBitmapInfo(&pAddress,
2416	&ulWidth,
2417	&ulHeight,
2418	&ulBitsPerPixel,
2419	&ulBytesPerLine,
2420	&bitmapFormat);
2421	if (SUCCEEDED(hrc))
2422	{
2423	pu8Src = pFBInfo->pu8FramebufferVRAM;
2424	xSrc = x;
2425	ySrc = y;
2426	u32SrcWidth = pFBInfo->w;
2427	u32SrcHeight = pFBInfo->h;
2428	u32SrcLineSize = pFBInfo->u32LineSize;
2429	u32SrcBitsPerPixel = pFBInfo->u16BitsPerPixel;
2430
2431	/* Default format is 32 bpp. */
2432	pu8Dst = pAddress;
2433	xDst = xSrc;
2434	yDst = ySrc;
2435	u32DstWidth = u32SrcWidth;
2436	u32DstHeight = u32SrcHeight;
2437	u32DstLineSize = u32DstWidth * 4;
2438	u32DstBitsPerPixel = 32;
2439
2440	pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
2441	width, height,
2442	pu8Src,
2443	xSrc, ySrc,
2444	u32SrcWidth, u32SrcHeight,
2445	u32SrcLineSize, u32SrcBitsPerPixel,
2446	pu8Dst,
2447	xDst, yDst,
2448	u32DstWidth, u32DstHeight,
2449	u32DstLineSize, u32DstBitsPerPixel);
2450	}
2451	}
2452	}
2453
2454	pDisplay->i_handleDisplayUpdate(aScreenId, x, y, width, height);
2455	}
2456	}
2457	else
2458	{
2459	rc = VERR_INVALID_PARAMETER;
2460	}
2461
2462	if (RT_SUCCESS(rc))
2463	pDisplay->mParent->i_consoleVRDPServer()->SendUpdateBitmap(aScreenId, x, y, width, height);
2464
2465	return rc;
2466	}
2467
2468	HRESULT Display::drawToScreen(ULONG aScreenId, BYTE *aAddress, ULONG aX, ULONG aY, ULONG aWidth, ULONG aHeight)
2469	{
2470	/// @todo (r=dmik) this function may take too long to complete if the VM
2471	// is doing something like saving state right now. Which, in case if it
2472	// is called on the GUI thread, will make it unresponsive. We should
2473	// check the machine state here (by enclosing the check and VMRequCall
2474	// within the Console lock to make it atomic).
2475
2476	LogRelFlowFunc(("aAddress=%p, x=%d, y=%d, width=%d, height=%d\n",
2477	(void *)aAddress, aX, aY, aWidth, aHeight));
2478
2479	CheckComArgExpr(aWidth, aWidth != 0);
2480	CheckComArgExpr(aHeight, aHeight != 0);
2481
2482	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2483
2484	CHECK_CONSOLE_DRV(mpDrv);
2485
2486	Console::SafeVMPtr ptrVM(mParent);
2487	if (!ptrVM.isOk())
2488	return ptrVM.rc();
2489
2490	/* Release lock because the call scheduled on EMT may also try to take it. */
2491	alock.release();
2492
2493	/*
2494	* Again we're lazy and make the graphics device do all the
2495	* dirty conversion work.
2496	*/
2497	int rcVBox = VMR3ReqCallWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_drawToScreenEMT, 7,
2498	this, aScreenId, aAddress, aX, aY, aWidth, aHeight);
2499
2500	/*
2501	* If the function returns not supported, we'll have to do all the
2502	* work ourselves using the framebuffer.
2503	*/
2504	HRESULT rc = S_OK;
2505	if (rcVBox == VERR_NOT_SUPPORTED \|\| rcVBox == VERR_NOT_IMPLEMENTED)
2506	{
2507	/** @todo implement generic fallback for screen blitting. */
2508	rc = E_NOTIMPL;
2509	}
2510	else if (RT_FAILURE(rcVBox))
2511	rc = setError(VBOX_E_IPRT_ERROR,
2512	tr("Could not draw to the screen (%Rrc)"), rcVBox);
2513	//@todo
2514	// else
2515	// {
2516	// /* All ok. Redraw the screen. */
2517	// handleDisplayUpdate(x, y, width, height);
2518	// }
2519
2520	LogRelFlowFunc(("rc=%Rhrc\n", rc));
2521	return rc;
2522	}
2523
2524	int Display::i_InvalidateAndUpdateEMT(Display *pDisplay, unsigned uId, bool fUpdateAll)
2525	{
2526	LogRelFlowFunc(("uId=%d, fUpdateAll %d\n", uId, fUpdateAll));
2527
2528	unsigned uScreenId;
2529	for (uScreenId = (fUpdateAll ? 0 : uId); uScreenId < pDisplay->mcMonitors; uScreenId++)
2530	{
2531	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[uScreenId];
2532
2533	if ( !pFBInfo->fVBVAEnabled
2534	&& uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
2535	{
2536	pDisplay->mpDrv->pUpPort->pfnUpdateDisplayAll(pDisplay->mpDrv->pUpPort, /* fFailOnResize = */ true);
2537	}
2538	else
2539	{
2540	if (!pFBInfo->fDisabled)
2541	{
2542	/* Render complete VRAM screen to the framebuffer.
2543	* When framebuffer uses VRAM directly, just notify it to update.
2544	*/
2545	if (pFBInfo->fDefaultFormat && !pFBInfo->pSourceBitmap.isNull())
2546	{
2547	BYTE *pAddress = NULL;
2548	ULONG ulWidth = 0;
2549	ULONG ulHeight = 0;
2550	ULONG ulBitsPerPixel = 0;
2551	ULONG ulBytesPerLine = 0;
2552	BitmapFormat_T bitmapFormat = BitmapFormat_Opaque;
2553
2554	HRESULT hrc = pFBInfo->pSourceBitmap->QueryBitmapInfo(&pAddress,
2555	&ulWidth,
2556	&ulHeight,
2557	&ulBitsPerPixel,
2558	&ulBytesPerLine,
2559	&bitmapFormat);
2560	if (SUCCEEDED(hrc))
2561	{
2562	uint32_t width = pFBInfo->w;
2563	uint32_t height = pFBInfo->h;
2564
2565	const uint8_t *pu8Src = pFBInfo->pu8FramebufferVRAM;
2566	int32_t xSrc = 0;
2567	int32_t ySrc = 0;
2568	uint32_t u32SrcWidth = pFBInfo->w;
2569	uint32_t u32SrcHeight = pFBInfo->h;
2570	uint32_t u32SrcLineSize = pFBInfo->u32LineSize;
2571	uint32_t u32SrcBitsPerPixel = pFBInfo->u16BitsPerPixel;
2572
2573	/* Default format is 32 bpp. */
2574	uint8_t *pu8Dst = pAddress;
2575	int32_t xDst = xSrc;
2576	int32_t yDst = ySrc;
2577	uint32_t u32DstWidth = u32SrcWidth;
2578	uint32_t u32DstHeight = u32SrcHeight;
2579	uint32_t u32DstLineSize = u32DstWidth * 4;
2580	uint32_t u32DstBitsPerPixel = 32;
2581
2582	/* if uWidth != pFBInfo->w and uHeight != pFBInfo->h
2583	* implies resize of Framebuffer is in progress and
2584	* copyrect should not be called.
2585	*/
2586	if (ulWidth == pFBInfo->w && ulHeight == pFBInfo->h)
2587	{
2588	pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
2589	width, height,
2590	pu8Src,
2591	xSrc, ySrc,
2592	u32SrcWidth, u32SrcHeight,
2593	u32SrcLineSize, u32SrcBitsPerPixel,
2594	pu8Dst,
2595	xDst, yDst,
2596	u32DstWidth, u32DstHeight,
2597	u32DstLineSize, u32DstBitsPerPixel);
2598	}
2599	}
2600	}
2601
2602	pDisplay->i_handleDisplayUpdate(uScreenId, 0, 0, pFBInfo->w, pFBInfo->h);
2603	}
2604	}
2605	if (!fUpdateAll)
2606	break;
2607	}
2608	LogRelFlowFunc(("done\n"));
2609	return VINF_SUCCESS;
2610	}
2611
2612	/**
2613	* Does a full invalidation of the VM display and instructs the VM
2614	* to update it immediately.
2615	*
2616	* @returns COM status code
2617	*/
2618
2619	HRESULT Display::invalidateAndUpdate()
2620	{
2621	LogRelFlowFunc(("\n"));
2622
2623	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2624
2625	CHECK_CONSOLE_DRV(mpDrv);
2626
2627	Console::SafeVMPtr ptrVM(mParent);
2628	if (!ptrVM.isOk())
2629	return ptrVM.rc();
2630
2631	HRESULT rc = S_OK;
2632
2633	LogRelFlowFunc(("Sending DPYUPDATE request\n"));
2634
2635	/* Have to release the lock when calling EMT. */
2636	alock.release();
2637
2638	int rcVBox = VMR3ReqCallNoWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_InvalidateAndUpdateEMT,
2639	3, this, 0, true);
2640	alock.acquire();
2641
2642	if (RT_FAILURE(rcVBox))
2643	rc = setError(VBOX_E_IPRT_ERROR,
2644	tr("Could not invalidate and update the screen (%Rrc)"), rcVBox);
2645
2646	LogRelFlowFunc(("rc=%Rhrc\n", rc));
2647	return rc;
2648	}
2649
2650	HRESULT Display::invalidateAndUpdateScreen(ULONG aScreenId)
2651	{
2652	LogRelFlowFunc(("\n"));
2653
2654	HRESULT rc = S_OK;
2655
2656	Console::SafeVMPtr ptrVM(mParent);
2657	if (!ptrVM.isOk())
2658	return ptrVM.rc();
2659
2660	int rcVBox = VMR3ReqCallNoWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_InvalidateAndUpdateEMT,
2661	3, this, aScreenId, false);
2662	if (RT_FAILURE(rcVBox))
2663	rc = setError(VBOX_E_IPRT_ERROR,
2664	tr("Could not invalidate and update the screen %d (%Rrc)"), aScreenId, rcVBox);
2665
2666	LogRelFlowFunc(("rc=%Rhrc\n", rc));
2667	return rc;
2668	}
2669
2670	HRESULT Display::completeVHWACommand(BYTE *aCommand)
2671	{
2672	#ifdef VBOX_WITH_VIDEOHWACCEL
2673	mpDrv->pVBVACallbacks->pfnVHWACommandCompleteAsync(mpDrv->pVBVACallbacks, (PVBOXVHWACMD)aCommand);
2674	return S_OK;
2675	#else
2676	return E_NOTIMPL;
2677	#endif
2678	}
2679
2680	HRESULT Display::viewportChanged(ULONG aScreenId, ULONG aX, ULONG aY, ULONG aWidth, ULONG aHeight)
2681	{
2682	AssertMsgReturn(aScreenId < mcMonitors, ("aScreendId=%d mcMonitors=%d\n", aScreenId, mcMonitors), E_INVALIDARG);
2683
2684	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
2685	if (mfIsCr3DEnabled)
2686	{
2687	int rc = i_crViewportNotify(aScreenId, aX, aY, aWidth, aHeight);
2688	if (RT_FAILURE(rc))
2689	{
2690	DISPLAYFBINFO *pFb = &maFramebuffers[aScreenId];
2691	pFb->pendingViewportInfo.fPending = true;
2692	pFb->pendingViewportInfo.x = aX;
2693	pFb->pendingViewportInfo.y = aY;
2694	pFb->pendingViewportInfo.width = aWidth;
2695	pFb->pendingViewportInfo.height = aHeight;
2696	}
2697	}
2698	#endif /* VBOX_WITH_CROGL && VBOX_WITH_HGCM */
2699
2700	/* The driver might not have been constructed yet */
2701	if (mpDrv && mpDrv->pUpPort->pfnSetViewport)
2702	mpDrv->pUpPort->pfnSetViewport(mpDrv->pUpPort, aScreenId, aX, aY, aWidth, aHeight);
2703
2704	return S_OK;
2705	}
2706
2707	HRESULT Display::querySourceBitmap(ULONG aScreenId,
2708	ComPtr<IDisplaySourceBitmap> &aDisplaySourceBitmap)
2709	{
2710	LogRelFlowFunc(("aScreenId = %d\n", aScreenId));
2711
2712	Console::SafeVMPtr ptrVM(mParent);
2713	if (!ptrVM.isOk())
2714	return ptrVM.rc();
2715
2716	bool fSetRenderVRAM = false;
2717	bool fInvalidate = false;
2718
2719	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2720
2721	if (aScreenId >= mcMonitors)
2722	return setError(E_INVALIDARG, tr("QuerySourceBitmap: Invalid screen %d (total %d)"),
2723	aScreenId, mcMonitors);
2724
2725	if (!mfSourceBitmapEnabled)
2726	{
2727	aDisplaySourceBitmap = NULL;
2728	return E_FAIL;
2729	}
2730
2731	DISPLAYFBINFO *pFBInfo = &maFramebuffers[aScreenId];
2732
2733	/* No source bitmap for a blank guest screen. */
2734	if (pFBInfo->flags & VBVA_SCREEN_F_BLANK)
2735	{
2736	aDisplaySourceBitmap = NULL;
2737	return E_FAIL;
2738	}
2739
2740	HRESULT hr = S_OK;
2741
2742	if (pFBInfo->pSourceBitmap.isNull())
2743	{
2744	/* Create a new object. */
2745	ComObjPtr<DisplaySourceBitmap> obj;
2746	hr = obj.createObject();
2747	if (SUCCEEDED(hr))
2748	hr = obj->init(this, aScreenId, pFBInfo);
2749
2750	if (SUCCEEDED(hr))
2751	{
2752	bool fDefaultFormat = !obj->i_usesVRAM();
2753
2754	if (aScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
2755	{
2756	/* Start buffer updates. */
2757	BYTE *pAddress = NULL;
2758	ULONG ulWidth = 0;
2759	ULONG ulHeight = 0;
2760	ULONG ulBitsPerPixel = 0;
2761	ULONG ulBytesPerLine = 0;
2762	BitmapFormat_T bitmapFormat = BitmapFormat_Opaque;
2763
2764	obj->QueryBitmapInfo(&pAddress,
2765	&ulWidth,
2766	&ulHeight,
2767	&ulBitsPerPixel,
2768	&ulBytesPerLine,
2769	&bitmapFormat);
2770
2771	mpDrv->IConnector.pbData = pAddress;
2772	mpDrv->IConnector.cbScanline = ulBytesPerLine;
2773	mpDrv->IConnector.cBits = ulBitsPerPixel;
2774	mpDrv->IConnector.cx = ulWidth;
2775	mpDrv->IConnector.cy = ulHeight;
2776
2777	fSetRenderVRAM = fDefaultFormat;
2778	}
2779
2780	/* Make sure that the bitmap contains the latest image. */
2781	fInvalidate = fDefaultFormat;
2782
2783	pFBInfo->pSourceBitmap = obj;
2784	pFBInfo->fDefaultFormat = fDefaultFormat;
2785	}
2786	}
2787
2788	if (SUCCEEDED(hr))
2789	{
2790	pFBInfo->pSourceBitmap.queryInterfaceTo(aDisplaySourceBitmap.asOutParam());
2791	}
2792
2793	/* Leave the IDisplay lock because the VGA device must not be called under it. */
2794	alock.release();
2795
2796	if (SUCCEEDED(hr))
2797	{
2798	if (fSetRenderVRAM)
2799	{
2800	mpDrv->pUpPort->pfnSetRenderVRAM(mpDrv->pUpPort, true);
2801	}
2802
2803	if (fInvalidate)
2804	VMR3ReqCallWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_InvalidateAndUpdateEMT,
2805	3, this, aScreenId, false);
2806	}
2807
2808	LogRelFlowFunc(("%Rhrc\n", hr));
2809	return hr;
2810	}
2811
2812	HRESULT Display::getGuestScreenLayout(std::vector<ComPtr<IGuestScreenInfo> > &aGuestScreenLayout)
2813	{
2814	NOREF(aGuestScreenLayout);
2815	return E_NOTIMPL;
2816	}
2817
2818	HRESULT Display::setScreenLayout(ScreenLayoutMode_T aScreenLayoutMode,
2819	const std::vector<ComPtr<IGuestScreenInfo> > &aGuestScreenInfo)
2820	{
2821	NOREF(aScreenLayoutMode);
2822	NOREF(aGuestScreenInfo);
2823	return E_NOTIMPL;
2824	}
2825
2826	// wrapped IEventListener method
2827	HRESULT Display::handleEvent(const ComPtr<IEvent> &aEvent)
2828	{
2829	VBoxEventType_T aType = VBoxEventType_Invalid;
2830
2831	aEvent->COMGETTER(Type)(&aType);
2832	switch (aType)
2833	{
2834	case VBoxEventType_OnStateChanged:
2835	{
2836	ComPtr<IStateChangedEvent> scev = aEvent;
2837	Assert(scev);
2838	MachineState_T machineState;
2839	scev->COMGETTER(State)(&machineState);
2840	if ( machineState == MachineState_Running
2841	\|\| machineState == MachineState_Teleporting
2842	\|\| machineState == MachineState_LiveSnapshotting
2843	\|\| machineState == MachineState_DeletingSnapshotOnline
2844	)
2845	{
2846	LogRelFlowFunc(("Machine is running.\n"));
2847
2848	#ifdef VBOX_WITH_CROGL
2849	i_crOglWindowsShow(true);
2850	#endif
2851	}
2852	else
2853	{
2854	#ifdef VBOX_WITH_CROGL
2855	if (machineState == MachineState_Paused)
2856	i_crOglWindowsShow(false);
2857	#endif
2858	}
2859	break;
2860	}
2861	default:
2862	AssertFailed();
2863	}
2864
2865	return S_OK;
2866	}
2867
2868
2869	// private methods
2870	/////////////////////////////////////////////////////////////////////////////
2871
2872	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
2873	int Display::i_crViewportNotify(ULONG aScreenId, ULONG x, ULONG y, ULONG width, ULONG height)
2874	{
2875	VMMDev *pVMMDev = mParent->i_getVMMDev();
2876	if (!pVMMDev)
2877	return VERR_INVALID_STATE;
2878
2879	size_t cbData = RT_UOFFSETOF(VBOXCRCMDCTL_HGCM, aParms[5]);
2880	VBOXCRCMDCTL_HGCM pData = (VBOXCRCMDCTL_HGCM )alloca(cbData);
2881
2882	pData->Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
2883	pData->Hdr.u32Function = SHCRGL_HOST_FN_VIEWPORT_CHANGED;
2884
2885	pData->aParms[0].type = VBOX_HGCM_SVC_PARM_32BIT;
2886	pData->aParms[0].u.uint32 = aScreenId;
2887
2888	pData->aParms[1].type = VBOX_HGCM_SVC_PARM_32BIT;
2889	pData->aParms[1].u.uint32 = x;
2890
2891	pData->aParms[2].type = VBOX_HGCM_SVC_PARM_32BIT;
2892	pData->aParms[2].u.uint32 = y;
2893
2894	pData->aParms[3].type = VBOX_HGCM_SVC_PARM_32BIT;
2895	pData->aParms[3].u.uint32 = width;
2896
2897	pData->aParms[4].type = VBOX_HGCM_SVC_PARM_32BIT;
2898	pData->aParms[4].u.uint32 = height;
2899
2900	return i_crCtlSubmitSyncIfHasDataForScreen(aScreenId, &pData->Hdr, (uint32_t)cbData);
2901	}
2902	#endif
2903
2904	#ifdef VBOX_WITH_CRHGSMI
2905	void Display::i_setupCrHgsmiData(void)
2906	{
2907	VMMDev *pVMMDev = mParent->i_getVMMDev();
2908	Assert(pVMMDev);
2909	int rc = RTCritSectRwEnterExcl(&mCrOglLock);
2910	AssertRC(rc);
2911
2912	if (pVMMDev)
2913	rc = pVMMDev->hgcmHostSvcHandleCreate("VBoxSharedCrOpenGL", &mhCrOglSvc);
2914	else
2915	rc = VERR_GENERAL_FAILURE;
2916
2917	if (RT_SUCCESS(rc))
2918	{
2919	Assert(mhCrOglSvc);
2920	/* setup command completion callback */
2921	VBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP_MAINCB Completion;
2922	Completion.Hdr.enmType = VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP_MAINCB;
2923	Completion.Hdr.cbCmd = sizeof(Completion);
2924	Completion.hCompletion = mpDrv->pVBVACallbacks;
2925	Completion.pfnCompletion = mpDrv->pVBVACallbacks->pfnCrHgsmiCommandCompleteAsync;
2926
2927	VBOXHGCMSVCPARM parm;
2928	parm.type = VBOX_HGCM_SVC_PARM_PTR;
2929	parm.u.pointer.addr = &Completion;
2930	parm.u.pointer.size = 0;
2931
2932	rc = pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_CRHGSMI_CTL, 1, &parm);
2933	if (RT_SUCCESS(rc))
2934	mCrOglCallbacks = Completion.MainInterface;
2935	else
2936	AssertMsgFailed(("VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP_COMPLETION failed (rc=%Rrc)\n", rc));
2937	}
2938
2939	if (RT_FAILURE(rc))
2940	mhCrOglSvc = NULL;
2941
2942	RTCritSectRwLeaveExcl(&mCrOglLock);
2943	}
2944
2945	void Display::i_destructCrHgsmiData(void)
2946	{
2947	int rc = RTCritSectRwEnterExcl(&mCrOglLock);
2948	AssertRC(rc);
2949	mhCrOglSvc = NULL;
2950	RTCritSectRwLeaveExcl(&mCrOglLock);
2951	}
2952	#endif /* VBOX_WITH_CRHGSMI */
2953
2954	/**
2955	* Handle display resize event issued by the VGA device for the primary screen.
2956	*
2957	* @see PDMIDISPLAYCONNECTOR::pfnResize
2958	*/
2959	DECLCALLBACK(int) Display::i_displayResizeCallback(PPDMIDISPLAYCONNECTOR pInterface,
2960	uint32_t bpp, void *pvVRAM, uint32_t cbLine, uint32_t cx, uint32_t cy)
2961	{
2962	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
2963	Display *pThis = pDrv->pDisplay;
2964
2965	LogRelFlowFunc(("bpp %d, pvVRAM %p, cbLine %d, cx %d, cy %d\n",
2966	bpp, pvVRAM, cbLine, cx, cy));
2967
2968	bool f = ASMAtomicCmpXchgBool(&pThis->fVGAResizing, true, false);
2969	if (!f)
2970	{
2971	/* This is a result of recursive call when the source bitmap is being updated
2972	* during a VGA resize. Tell the VGA device to ignore the call.
2973	*
2974	* @todo It is a workaround, actually pfnUpdateDisplayAll must
2975	* fail on resize.
2976	*/
2977	LogRel(("displayResizeCallback: already processing\n"));
2978	return VINF_VGA_RESIZE_IN_PROGRESS;
2979	}
2980
2981	int rc = pThis->i_handleDisplayResize(VBOX_VIDEO_PRIMARY_SCREEN, bpp, pvVRAM, cbLine, cx, cy, VBVA_SCREEN_F_ACTIVE);
2982
2983	/* Restore the flag. */
2984	f = ASMAtomicCmpXchgBool(&pThis->fVGAResizing, false, true);
2985	AssertRelease(f);
2986
2987	return rc;
2988	}
2989
2990	/**
2991	* Handle display update.
2992	*
2993	* @see PDMIDISPLAYCONNECTOR::pfnUpdateRect
2994	*/
2995	DECLCALLBACK(void) Display::i_displayUpdateCallback(PPDMIDISPLAYCONNECTOR pInterface,
2996	uint32_t x, uint32_t y, uint32_t cx, uint32_t cy)
2997	{
2998	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
2999
3000	#ifdef DEBUG_sunlover
3001	LogFlowFunc(("fVideoAccelEnabled = %d, %d,%d %dx%d\n",
3002	pDrv->pDisplay->mVideoAccelLegacy.fVideoAccelEnabled, x, y, cx, cy));
3003	#endif /* DEBUG_sunlover */
3004
3005	/* This call does update regardless of VBVA status.
3006	* But in VBVA mode this is called only as result of
3007	* pfnUpdateDisplayAll in the VGA device.
3008	*/
3009
3010	pDrv->pDisplay->i_handleDisplayUpdate(VBOX_VIDEO_PRIMARY_SCREEN, x, y, cx, cy);
3011	}
3012
3013	/**
3014	* Periodic display refresh callback.
3015	*
3016	* @see PDMIDISPLAYCONNECTOR::pfnRefresh
3017	* @thread EMT
3018	*/
3019	/static/ DECLCALLBACK(void) Display::i_displayRefreshCallback(PPDMIDISPLAYCONNECTOR pInterface)
3020	{
3021	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3022
3023	#ifdef DEBUG_sunlover_2
3024	LogFlowFunc(("pDrv->pDisplay->mfVideoAccelEnabled = %d\n",
3025	pDrv->pDisplay->mfVideoAccelEnabled));
3026	#endif /* DEBUG_sunlover_2 */
3027
3028	Display *pDisplay = pDrv->pDisplay;
3029	unsigned uScreenId;
3030
3031	int rc = pDisplay->i_videoAccelRefreshProcess(pDrv->pUpPort);
3032	if (rc != VINF_TRY_AGAIN) /* Means 'do nothing' here. */
3033	{
3034	if (rc == VWRN_INVALID_STATE)
3035	{
3036	/* No VBVA do a display update. */
3037	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN];
3038	pDrv->pUpPort->pfnUpdateDisplay(pDrv->pUpPort);
3039	}
3040
3041	/* Inform the VRDP server that the current display update sequence is
3042	* completed. At this moment the framebuffer memory contains a definite
3043	* image, that is synchronized with the orders already sent to VRDP client.
3044	* The server can now process redraw requests from clients or initial
3045	* fullscreen updates for new clients.
3046	*/
3047	for (uScreenId = 0; uScreenId < pDisplay->mcMonitors; uScreenId++)
3048	{
3049	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[uScreenId];
3050
3051	Assert(pDisplay->mParent && pDisplay->mParent->i_consoleVRDPServer());
3052	pDisplay->mParent->i_consoleVRDPServer()->SendUpdate(uScreenId, NULL, 0);
3053	}
3054	}
3055
3056	#ifdef VBOX_WITH_VPX
3057	if (VideoRecIsEnabled(pDisplay->mpVideoRecCtx))
3058	{
3059	do {
3060	# if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
3061	if (pDisplay->mfIsCr3DEnabled)
3062	{
3063	if (ASMAtomicCmpXchgU32(&pDisplay->mfCrOglVideoRecState, CRVREC_STATE_SUBMITTED, CRVREC_STATE_IDLE))
3064	{
3065	if ( pDisplay->mCrOglCallbacks.pfnHasData
3066	&& pDisplay->mCrOglCallbacks.pfnHasData())
3067	{
3068	/* submit */
3069	VBOXCRCMDCTL_HGCM *pData = &pDisplay->mCrOglScreenshotCtl;
3070
3071	pData->Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
3072	pData->Hdr.u32Function = SHCRGL_HOST_FN_TAKE_SCREENSHOT;
3073
3074	pData->aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
3075	pData->aParms[0].u.pointer.addr = &pDisplay->mCrOglScreenshotData;
3076	pData->aParms[0].u.pointer.size = sizeof(pDisplay->mCrOglScreenshotData);
3077	rc = pDisplay->i_crCtlSubmit(&pData->Hdr, sizeof(*pData), Display::i_displayVRecCompletion, pDisplay);
3078	if (RT_SUCCESS(rc))
3079	break;
3080	AssertMsgFailed(("crCtlSubmit failed (rc=%Rrc)\n", rc));
3081	}
3082
3083	/* no 3D data available, or error has occured,
3084	* go the straight way */
3085	ASMAtomicWriteU32(&pDisplay->mfCrOglVideoRecState, CRVREC_STATE_IDLE);
3086	}
3087	else
3088	{
3089	/* record request is still in progress, don't do anything */
3090	break;
3091	}
3092	}
3093	# endif /* VBOX_WITH_HGCM && VBOX_WITH_CROGL */
3094
3095	uint64_t u64Now = RTTimeProgramMilliTS();
3096	for (uScreenId = 0; uScreenId < pDisplay->mcMonitors; uScreenId++)
3097	{
3098	if (!pDisplay->maVideoRecEnabled[uScreenId])
3099	continue;
3100
3101	if (VideoRecIsFull(pDisplay->mpVideoRecCtx, uScreenId, u64Now))
3102	{
3103	pDisplay->i_VideoCaptureStop();
3104	pDisplay->mParent->i_machine()->COMSETTER(VideoCaptureEnabled)(false);
3105	break;
3106	}
3107
3108	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[uScreenId];
3109
3110	if ( !pFBInfo->pFramebuffer.isNull()
3111	&& !pFBInfo->fDisabled)
3112	{
3113	rc = VERR_NOT_SUPPORTED;
3114	if ( pFBInfo->fVBVAEnabled
3115	&& pFBInfo->pu8FramebufferVRAM)
3116	{
3117	rc = VideoRecCopyToIntBuf(pDisplay->mpVideoRecCtx, uScreenId, 0, 0,
3118	BitmapFormat_BGR,
3119	pFBInfo->u16BitsPerPixel,
3120	pFBInfo->u32LineSize, pFBInfo->w, pFBInfo->h,
3121	pFBInfo->pu8FramebufferVRAM, u64Now);
3122	}
3123	else if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN && pDrv->IConnector.pbData)
3124	{
3125	rc = VideoRecCopyToIntBuf(pDisplay->mpVideoRecCtx, uScreenId, 0, 0,
3126	BitmapFormat_BGR,
3127	pDrv->IConnector.cBits,
3128	pDrv->IConnector.cbScanline, pDrv->IConnector.cx,
3129	pDrv->IConnector.cy, pDrv->IConnector.pbData, u64Now);
3130	}
3131	if (rc == VINF_TRY_AGAIN)
3132	break;
3133	}
3134	}
3135	} while (0);
3136	}
3137	#endif /* VBOX_WITH_VPX */
3138
3139	#ifdef DEBUG_sunlover_2
3140	LogFlowFunc(("leave\n"));
3141	#endif /* DEBUG_sunlover_2 */
3142	}
3143
3144	/**
3145	* Reset notification
3146	*
3147	* @see PDMIDISPLAYCONNECTOR::pfnReset
3148	*/
3149	DECLCALLBACK(void) Display::i_displayResetCallback(PPDMIDISPLAYCONNECTOR pInterface)
3150	{
3151	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3152
3153	LogRelFlowFunc(("\n"));
3154
3155	/* Disable VBVA mode. */
3156	pDrv->pDisplay->VideoAccelEnableVGA(false, NULL);
3157	}
3158
3159	/**
3160	* LFBModeChange notification
3161	*
3162	* @see PDMIDISPLAYCONNECTOR::pfnLFBModeChange
3163	*/
3164	DECLCALLBACK(void) Display::i_displayLFBModeChangeCallback(PPDMIDISPLAYCONNECTOR pInterface, bool fEnabled)
3165	{
3166	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3167
3168	LogRelFlowFunc(("fEnabled=%d\n", fEnabled));
3169
3170	NOREF(fEnabled);
3171
3172	/* Disable VBVA mode in any case. The guest driver reenables VBVA mode if necessary. */
3173	pDrv->pDisplay->VideoAccelEnableVGA(false, NULL);
3174	}
3175
3176	/**
3177	* Adapter information change notification.
3178	*
3179	* @see PDMIDISPLAYCONNECTOR::pfnProcessAdapterData
3180	*/
3181	DECLCALLBACK(void) Display::i_displayProcessAdapterDataCallback(PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM,
3182	uint32_t u32VRAMSize)
3183	{
3184	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3185	pDrv->pDisplay->processAdapterData(pvVRAM, u32VRAMSize);
3186	}
3187
3188	/**
3189	* Display information change notification.
3190	*
3191	* @see PDMIDISPLAYCONNECTOR::pfnProcessDisplayData
3192	*/
3193	DECLCALLBACK(void) Display::i_displayProcessDisplayDataCallback(PPDMIDISPLAYCONNECTOR pInterface,
3194	void *pvVRAM, unsigned uScreenId)
3195	{
3196	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3197	pDrv->pDisplay->processDisplayData(pvVRAM, uScreenId);
3198	}
3199
3200	#ifdef VBOX_WITH_VIDEOHWACCEL
3201
3202	#ifndef S_FALSE
3203	# define S_FALSE ((HRESULT)1L)
3204	#endif
3205
3206	int Display::i_handleVHWACommandProcess(PVBOXVHWACMD pCommand)
3207	{
3208	unsigned id = (unsigned)pCommand->iDisplay;
3209	int rc = VINF_SUCCESS;
3210	if (id >= mcMonitors)
3211	return VERR_INVALID_PARAMETER;
3212
3213	ComPtr<IFramebuffer> pFramebuffer;
3214	AutoReadLock arlock(this COMMA_LOCKVAL_SRC_POS);
3215	pFramebuffer = maFramebuffers[id].pFramebuffer;
3216	bool fVHWASupported = RT_BOOL(maFramebuffers[id].u32Caps & FramebufferCapabilities_VHWA);
3217	arlock.release();
3218
3219	if (pFramebuffer == NULL \|\| !fVHWASupported)
3220	return VERR_NOT_IMPLEMENTED; /* Implementation is not available. */
3221
3222	HRESULT hr = pFramebuffer->ProcessVHWACommand((BYTE*)pCommand);
3223	if (hr == S_FALSE)
3224	return VINF_SUCCESS;
3225	else if (SUCCEEDED(hr))
3226	return VINF_CALLBACK_RETURN;
3227	else if (hr == E_ACCESSDENIED)
3228	return VERR_INVALID_STATE; /* notify we can not handle request atm */
3229	else if (hr == E_NOTIMPL)
3230	return VERR_NOT_IMPLEMENTED;
3231	return VERR_GENERAL_FAILURE;
3232	}
3233
3234	DECLCALLBACK(int) Display::i_displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand)
3235	{
3236	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3237
3238	return pDrv->pDisplay->i_handleVHWACommandProcess(pCommand);
3239	}
3240	#endif
3241
3242	#ifdef VBOX_WITH_CRHGSMI
3243	void Display::i_handleCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam)
3244	{
3245	mpDrv->pVBVACallbacks->pfnCrHgsmiCommandCompleteAsync(mpDrv->pVBVACallbacks,
3246	(PVBOXVDMACMD_CHROMIUM_CMD)pParam->u.pointer.addr, result);
3247	}
3248
3249	void Display::i_handleCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam)
3250	{
3251	PVBOXVDMACMD_CHROMIUM_CTL pCtl = (PVBOXVDMACMD_CHROMIUM_CTL)pParam->u.pointer.addr;
3252	mpDrv->pVBVACallbacks->pfnCrHgsmiControlCompleteAsync(mpDrv->pVBVACallbacks, pCtl, result);
3253	}
3254
3255	void Display::i_handleCrHgsmiCommandProcess(PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd)
3256	{
3257	int rc = VERR_NOT_SUPPORTED;
3258	VBOXHGCMSVCPARM parm;
3259	parm.type = VBOX_HGCM_SVC_PARM_PTR;
3260	parm.u.pointer.addr = pCmd;
3261	parm.u.pointer.size = cbCmd;
3262
3263	if (mhCrOglSvc)
3264	{
3265	VMMDev *pVMMDev = mParent->i_getVMMDev();
3266	if (pVMMDev)
3267	{
3268	/* no completion callback is specified with this call,
3269	* the CrOgl code will complete the CrHgsmi command once it processes it */
3270	rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_CRHGSMI_CMD, &parm, NULL, NULL);
3271	AssertRC(rc);
3272	if (RT_SUCCESS(rc))
3273	return;
3274	}
3275	else
3276	rc = VERR_INVALID_STATE;
3277	}
3278
3279	/* we are here because something went wrong with command processing, complete it */
3280	i_handleCrHgsmiCommandCompletion(rc, SHCRGL_HOST_FN_CRHGSMI_CMD, &parm);
3281	}
3282
3283	void Display::i_handleCrHgsmiControlProcess(PVBOXVDMACMD_CHROMIUM_CTL pCtl, uint32_t cbCtl)
3284	{
3285	int rc = VERR_NOT_SUPPORTED;
3286	VBOXHGCMSVCPARM parm;
3287	parm.type = VBOX_HGCM_SVC_PARM_PTR;
3288	parm.u.pointer.addr = pCtl;
3289	parm.u.pointer.size = cbCtl;
3290
3291	if (mhCrOglSvc)
3292	{
3293	VMMDev *pVMMDev = mParent->i_getVMMDev();
3294	if (pVMMDev)
3295	{
3296	bool fCheckPendingViewport = (pCtl->enmType == VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP);
3297	rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_CRHGSMI_CTL, &parm,
3298	Display::i_displayCrHgsmiControlCompletion, this);
3299	AssertRC(rc);
3300	if (RT_SUCCESS(rc))
3301	{
3302	if (fCheckPendingViewport)
3303	{
3304	ULONG ul;
3305	for (ul = 0; ul < mcMonitors; ul++)
3306	{
3307	DISPLAYFBINFO *pFb = &maFramebuffers[ul];
3308	if (!pFb->pendingViewportInfo.fPending)
3309	continue;
3310
3311	rc = i_crViewportNotify(ul, pFb->pendingViewportInfo.x, pFb->pendingViewportInfo.y,
3312	pFb->pendingViewportInfo.width, pFb->pendingViewportInfo.height);
3313	if (RT_SUCCESS(rc))
3314	pFb->pendingViewportInfo.fPending = false;
3315	else
3316	{
3317	AssertMsgFailed(("crViewportNotify failed (rc=%Rrc)\n", rc));
3318	rc = VINF_SUCCESS;
3319	}
3320	}
3321	}
3322	return;
3323	}
3324	}
3325	else
3326	rc = VERR_INVALID_STATE;
3327	}
3328
3329	/* we are here because something went wrong with command processing, complete it */
3330	i_handleCrHgsmiControlCompletion(rc, SHCRGL_HOST_FN_CRHGSMI_CTL, &parm);
3331	}
3332
3333	DECLCALLBACK(void) Display::i_displayCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd,
3334	uint32_t cbCmd)
3335	{
3336	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3337
3338	pDrv->pDisplay->i_handleCrHgsmiCommandProcess(pCmd, cbCmd);
3339	}
3340
3341	DECLCALLBACK(void) Display::i_displayCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCmd,
3342	uint32_t cbCmd)
3343	{
3344	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3345
3346	pDrv->pDisplay->i_handleCrHgsmiControlProcess(pCmd, cbCmd);
3347	}
3348
3349	DECLCALLBACK(void) Display::i_displayCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
3350	void *pvContext)
3351	{
3352	AssertMsgFailed(("not expected!\n"));
3353	Display pDisplay = (Display )pvContext;
3354	pDisplay->i_handleCrHgsmiCommandCompletion(result, u32Function, pParam);
3355	}
3356
3357	DECLCALLBACK(void) Display::i_displayCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
3358	void *pvContext)
3359	{
3360	Display pDisplay = (Display )pvContext;
3361	pDisplay->i_handleCrHgsmiControlCompletion(result, u32Function, pParam);
3362
3363	}
3364	#endif
3365
3366	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
3367	DECLCALLBACK(void) Display::i_displayCrHgcmCtlSubmitCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
3368	void *pvContext)
3369	{
3370	VBOXCRCMDCTL pCmd = (VBOXCRCMDCTL)pParam->u.pointer.addr;
3371	if (pCmd->u.pfnInternal)
3372	((PFNCRCTLCOMPLETION)pCmd->u.pfnInternal)(pCmd, pParam->u.pointer.size, result, pvContext);
3373	}
3374
3375	int Display::i_handleCrHgcmCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd,
3376	PFNCRCTLCOMPLETION pfnCompletion,
3377	void *pvCompletion)
3378	{
3379	VMMDev *pVMMDev = mParent ? mParent->i_getVMMDev() : NULL;
3380	if (!pVMMDev)
3381	{
3382	AssertMsgFailed(("no vmmdev\n"));
3383	return VERR_INVALID_STATE;
3384	}
3385
3386	Assert(mhCrOglSvc);
3387	VBOXHGCMSVCPARM parm;
3388	parm.type = VBOX_HGCM_SVC_PARM_PTR;
3389	parm.u.pointer.addr = pCmd;
3390	parm.u.pointer.size = cbCmd;
3391
3392	pCmd->u.pfnInternal = (void(*)())pfnCompletion;
3393	int rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_CTL, &parm, i_displayCrHgcmCtlSubmitCompletion,
3394	pvCompletion);
3395	if (!RT_SUCCESS(rc))
3396	AssertMsgFailed(("hgcmHostFastCallAsync failed (rc=%Rrc)\n", rc));
3397
3398	return rc;
3399	}
3400
3401	DECLCALLBACK(int) Display::i_displayCrHgcmCtlSubmit(PPDMIDISPLAYCONNECTOR pInterface,
3402	struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd,
3403	PFNCRCTLCOMPLETION pfnCompletion,
3404	void *pvCompletion)
3405	{
3406	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3407	Display *pThis = pDrv->pDisplay;
3408	return pThis->i_handleCrHgcmCtlSubmit(pCmd, cbCmd, pfnCompletion, pvCompletion);
3409	}
3410
3411	int Display::i_crCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, PFNCRCTLCOMPLETION pfnCompletion, void *pvCompletion)
3412	{
3413	int rc = RTCritSectRwEnterShared(&mCrOglLock);
3414	if (RT_SUCCESS(rc))
3415	{
3416	if (mhCrOglSvc)
3417	rc = mpDrv->pVBVACallbacks->pfnCrCtlSubmit(mpDrv->pVBVACallbacks, pCmd, cbCmd, pfnCompletion, pvCompletion);
3418	else
3419	rc = VERR_NOT_SUPPORTED;
3420
3421	RTCritSectRwLeaveShared(&mCrOglLock);
3422	}
3423	return rc;
3424	}
3425
3426	int Display::i_crCtlSubmitSync(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd)
3427	{
3428	int rc = RTCritSectRwEnterShared(&mCrOglLock);
3429	if (RT_SUCCESS(rc))
3430	{
3431	if (mhCrOglSvc)
3432	rc = mpDrv->pVBVACallbacks->pfnCrCtlSubmitSync(mpDrv->pVBVACallbacks, pCmd, cbCmd);
3433	else
3434	rc = VERR_NOT_SUPPORTED;
3435
3436	RTCritSectRwLeaveShared(&mCrOglLock);
3437	}
3438	return rc;
3439	}
3440
3441	int Display::i_crCtlSubmitAsyncCmdCopy(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd)
3442	{
3443	VBOXCRCMDCTL* pCmdCopy = (VBOXCRCMDCTL*)RTMemAlloc(cbCmd);
3444	if (!pCmdCopy)
3445	{
3446	LogRel(("RTMemAlloc failed\n"));
3447	return VERR_NO_MEMORY;
3448	}
3449
3450	memcpy(pCmdCopy, pCmd, cbCmd);
3451
3452	int rc = i_crCtlSubmit(pCmdCopy, cbCmd, i_displayCrCmdFree, pCmdCopy);
3453	if (RT_FAILURE(rc))
3454	{
3455	LogRel(("crCtlSubmit failed (rc=%Rrc)\n", rc));
3456	RTMemFree(pCmdCopy);
3457	return rc;
3458	}
3459
3460	return VINF_SUCCESS;
3461	}
3462
3463	int Display::i_crCtlSubmitSyncIfHasDataForScreen(uint32_t u32ScreenID, struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd)
3464	{
3465	int rc = RTCritSectRwEnterShared(&mCrOglLock);
3466	AssertRCReturn(rc, rc);
3467
3468	if ( mCrOglCallbacks.pfnHasDataForScreen
3469	&& mCrOglCallbacks.pfnHasDataForScreen(u32ScreenID))
3470	rc = i_crCtlSubmitSync(pCmd, cbCmd);
3471	else
3472	rc = i_crCtlSubmitAsyncCmdCopy(pCmd, cbCmd);
3473
3474	RTCritSectRwLeaveShared(&mCrOglLock);
3475
3476	return rc;
3477	}
3478
3479	bool Display::i_handleCrVRecScreenshotBegin(uint32_t uScreen, uint64_t u64TimeStamp)
3480	{
3481	# if VBOX_WITH_VPX
3482	return VideoRecIsReady(mpVideoRecCtx, uScreen, u64TimeStamp);
3483	# else
3484	return false;
3485	# endif
3486	}
3487
3488	void Display::i_handleCrVRecScreenshotEnd(uint32_t uScreen, uint64_t u64TimeStamp)
3489	{
3490	}
3491
3492	void Display::i_handleCrVRecScreenshotPerform(uint32_t uScreen,
3493	uint32_t x, uint32_t y, uint32_t uPixelFormat,
3494	uint32_t uBitsPerPixel, uint32_t uBytesPerLine,
3495	uint32_t uGuestWidth, uint32_t uGuestHeight,
3496	uint8_t *pu8BufferAddress, uint64_t u64TimeStamp)
3497	{
3498	Assert(mfCrOglVideoRecState == CRVREC_STATE_SUBMITTED);
3499	# if VBOX_WITH_VPX
3500	int rc = VideoRecCopyToIntBuf(mpVideoRecCtx, uScreen, x, y,
3501	uPixelFormat,
3502	uBitsPerPixel, uBytesPerLine,
3503	uGuestWidth, uGuestHeight,
3504	pu8BufferAddress, u64TimeStamp);
3505	Assert(rc == VINF_SUCCESS /* \|\| rc == VERR_TRY_AGAIN \|\| rc == VINF_TRY_AGAIN*/);
3506	# endif
3507	}
3508
3509	void Display::i_handleVRecCompletion()
3510	{
3511	Assert(mfCrOglVideoRecState == CRVREC_STATE_SUBMITTED);
3512	ASMAtomicWriteU32(&mfCrOglVideoRecState, CRVREC_STATE_IDLE);
3513	}
3514
3515	#endif /* VBOX_WITH_HGCM && VBOX_WITH_CROGL */
3516
3517	HRESULT Display::notifyScaleFactorChange(ULONG aScreenId, ULONG aScaleFactorWMultiplied, ULONG aScaleFactorHMultiplied)
3518	{
3519	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
3520	HRESULT hr = E_UNEXPECTED;
3521
3522	if (aScreenId >= mcMonitors)
3523	return E_INVALIDARG;
3524
3525	/* 3D acceleration enabled in VM config. */
3526	if (mfIsCr3DEnabled)
3527	{
3528	/* VBoxSharedCrOpenGL HGCM host service is running. */
3529	if (mhCrOglSvc)
3530	{
3531	VMMDev *pVMMDev = mParent->i_getVMMDev();
3532	if (pVMMDev)
3533	{
3534	VBOXCRCMDCTL_HGCM *pCtl;
3535	pCtl = (VBOXCRCMDCTL_HGCM *)RTMemAlloc(sizeof(CRVBOXHGCMSETSCALEFACTOR) + sizeof(VBOXCRCMDCTL_HGCM));
3536	if (pCtl)
3537	{
3538	CRVBOXHGCMSETSCALEFACTOR pData = (CRVBOXHGCMSETSCALEFACTOR )(pCtl + 1);
3539	int rc;
3540
3541	pData->u32Screen = aScreenId;
3542	pData->u32ScaleFactorWMultiplied = aScaleFactorWMultiplied;
3543	pData->u32ScaleFactorHMultiplied = aScaleFactorHMultiplied;
3544
3545	pCtl->Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
3546	pCtl->Hdr.u32Function = SHCRGL_HOST_FN_SET_SCALE_FACTOR;
3547	pCtl->aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
3548	pCtl->aParms[0].u.pointer.addr = pData;
3549	pCtl->aParms[0].u.pointer.size = sizeof(*pData);
3550
3551	rc = i_crCtlSubmitSync(&pCtl->Hdr, sizeof(*pCtl));
3552	if (RT_FAILURE(rc))
3553	AssertMsgFailed(("crCtlSubmitSync failed (rc=%Rrc)\n", rc));
3554	else
3555	hr = S_OK;
3556
3557	RTMemFree(pCtl);
3558	}
3559	else
3560	{
3561	LogRel(("Running out of memory on attempt to set OpenGL content scale factor. Ignored.\n"));
3562	hr = E_OUTOFMEMORY;
3563	}
3564	}
3565	else
3566	LogRel(("Internal error occurred on attempt to set OpenGL content scale factor. Ignored.\n"));
3567	}
3568	else
3569	LogRel(("Attempt to specify OpenGL content scale factor while corresponding HGCM host service not yet runing. Ignored.\n"));
3570	}
3571	else
3572	# if 0 /** @todo Thank you so very much from anyone using VMSVGA3d! */
3573	AssertMsgFailed(("Attempt to specify OpenGL content scale factor while 3D acceleration is disabled in VM config. Ignored.\n"));
3574	# else
3575	{
3576	hr = S_OK;
3577	/* Need an interface like this here (and the #ifdefs needs adjusting):
3578	PPDMIDISPLAYPORT pUpPort = mpDrv ? mpDrv->pUpPort : NULL;
3579	if (pUpPort && pUpPort->pfnSetScaleFactor)
3580	pUpPort->pfnSetScaleFactor(pUpPort, aScreeId, aScaleFactorWMultiplied, aScaleFactorHMultiplied); */
3581	}
3582	# endif
3583
3584	return hr;
3585	#else
3586	AssertMsgFailed(("Attempt to specify OpenGL content scale factor while corresponding functionality is disabled."));
3587	return E_UNEXPECTED;
3588	#endif /* VBOX_WITH_HGCM && VBOX_WITH_CROGL */
3589	}
3590
3591	HRESULT Display::notifyHiDPIOutputPolicyChange(BOOL fUnscaledHiDPI)
3592	{
3593	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
3594	HRESULT hr = E_UNEXPECTED;
3595
3596	/* 3D acceleration enabled in VM config. */
3597	if (mfIsCr3DEnabled)
3598	{
3599	/* VBoxSharedCrOpenGL HGCM host service is running. */
3600	if (mhCrOglSvc)
3601	{
3602	VMMDev *pVMMDev = mParent->i_getVMMDev();
3603	if (pVMMDev)
3604	{
3605	VBOXCRCMDCTL_HGCM *pCtl;
3606	pCtl = (VBOXCRCMDCTL_HGCM *)RTMemAlloc(sizeof(CRVBOXHGCMSETUNSCALEDHIDPIOUTPUT) + sizeof(VBOXCRCMDCTL_HGCM));
3607	if (pCtl)
3608	{
3609	CRVBOXHGCMSETUNSCALEDHIDPIOUTPUT pData = (CRVBOXHGCMSETUNSCALEDHIDPIOUTPUT )(pCtl + 1);
3610	int rc;
3611
3612	pData->fUnscaledHiDPI = RT_BOOL(fUnscaledHiDPI);
3613
3614	pCtl->Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
3615	pCtl->Hdr.u32Function = SHCRGL_HOST_FN_SET_UNSCALED_HIDPI;
3616	pCtl->aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
3617	pCtl->aParms[0].u.pointer.addr = pData;
3618	pCtl->aParms[0].u.pointer.size = sizeof(*pData);
3619
3620	rc = i_crCtlSubmitSync(&pCtl->Hdr, sizeof(*pCtl));
3621	if (RT_FAILURE(rc))
3622	AssertMsgFailed(("crCtlSubmitSync failed (rc=%Rrc)\n", rc));
3623	else
3624	hr = S_OK;
3625
3626	RTMemFree(pCtl);
3627	}
3628	else
3629	{
3630	LogRel(("Running out of memory on attempt to notify OpenGL about HiDPI output scaling policy change. Ignored.\n"));
3631	hr = E_OUTOFMEMORY;
3632	}
3633	}
3634	else
3635	LogRel(("Internal error occurred on attempt to notify OpenGL about HiDPI output scaling policy change. Ignored.\n"));
3636	}
3637	else
3638	LogRel(("Attempt to notify OpenGL about HiDPI output scaling policy change while corresponding HGCM host service not yet runing. Ignored.\n"));
3639	}
3640	else
3641	{
3642	hr = S_OK;
3643	/* Need an interface like this here (and the #ifdefs needs adjusting):
3644	PPDMIDISPLAYPORT pUpPort = mpDrv ? mpDrv->pUpPort : NULL;
3645	if (pUpPort && pUpPort->pfnSetScaleFactor)
3646	pUpPort->pfnSetScaleFactor(pUpPort, aScreeId, aScaleFactorWMultiplied, aScaleFactorHMultiplied); */
3647	}
3648
3649	return hr;
3650	#else
3651	AssertMsgFailed(("Attempt to notify OpenGL about HiDPI output scaling policy change while corresponding functionality is disabled."));
3652	return E_UNEXPECTED;
3653	#endif /* VBOX_WITH_HGCM && VBOX_WITH_CROGL */
3654	}
3655
3656	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
3657	DECLCALLBACK(void) Display::i_displayCrVRecScreenshotPerform(void *pvCtx, uint32_t uScreen,
3658	uint32_t x, uint32_t y,
3659	uint32_t uBitsPerPixel, uint32_t uBytesPerLine,
3660	uint32_t uGuestWidth, uint32_t uGuestHeight,
3661	uint8_t *pu8BufferAddress, uint64_t u64TimeStamp)
3662	{
3663	Display pDisplay = (Display )pvCtx;
3664	pDisplay->i_handleCrVRecScreenshotPerform(uScreen,
3665	x, y, BitmapFormat_BGR, uBitsPerPixel,
3666	uBytesPerLine, uGuestWidth, uGuestHeight,
3667	pu8BufferAddress, u64TimeStamp);
3668	}
3669
3670	DECLCALLBACK(bool) Display::i_displayCrVRecScreenshotBegin(void *pvCtx, uint32_t uScreen, uint64_t u64TimeStamp)
3671	{
3672	Display pDisplay = (Display )pvCtx;
3673	return pDisplay->i_handleCrVRecScreenshotBegin(uScreen, u64TimeStamp);
3674	}
3675
3676	DECLCALLBACK(void) Display::i_displayCrVRecScreenshotEnd(void *pvCtx, uint32_t uScreen, uint64_t u64TimeStamp)
3677	{
3678	Display pDisplay = (Display )pvCtx;
3679	pDisplay->i_handleCrVRecScreenshotEnd(uScreen, u64TimeStamp);
3680	}
3681
3682	DECLCALLBACK(void) Display::i_displayVRecCompletion(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, int rc, void *pvCompletion)
3683	{
3684	Display pDisplay = (Display )pvCompletion;
3685	pDisplay->i_handleVRecCompletion();
3686	}
3687
3688	#endif
3689
3690
3691	#ifdef VBOX_WITH_HGSMI
3692	DECLCALLBACK(int) Display::i_displayVBVAEnable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, PVBVAHOSTFLAGS pHostFlags,
3693	bool fRenderThreadMode)
3694	{
3695	LogRelFlowFunc(("uScreenId %d\n", uScreenId));
3696
3697	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3698	Display *pThis = pDrv->pDisplay;
3699
3700	if (pThis->maFramebuffers[uScreenId].fVBVAEnabled && pThis->maFramebuffers[uScreenId].fRenderThreadMode != fRenderThreadMode)
3701	{
3702	LogRel(("Enabling different vbva mode\n"));
3703	#ifdef DEBUG_misha
3704	AssertMsgFailed(("enabling different vbva mode\n"));
3705	#endif
3706	return VERR_INVALID_STATE;
3707	}
3708
3709	pThis->maFramebuffers[uScreenId].fVBVAEnabled = true;
3710	pThis->maFramebuffers[uScreenId].pVBVAHostFlags = pHostFlags;
3711	pThis->maFramebuffers[uScreenId].fRenderThreadMode = fRenderThreadMode;
3712	pThis->maFramebuffers[uScreenId].fVBVAForceResize = true;
3713
3714	vbvaSetMemoryFlagsHGSMI(uScreenId, pThis->mfu32SupportedOrders, pThis->mfVideoAccelVRDP, &pThis->maFramebuffers[uScreenId]);
3715
3716	return VINF_SUCCESS;
3717	}
3718
3719	DECLCALLBACK(void) Display::i_displayVBVADisable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId)
3720	{
3721	LogRelFlowFunc(("uScreenId %d\n", uScreenId));
3722
3723	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3724	Display *pThis = pDrv->pDisplay;
3725
3726	DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[uScreenId];
3727
3728	bool fRenderThreadMode = pFBInfo->fRenderThreadMode;
3729
3730	if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
3731	{
3732	/* Make sure that the primary screen is visible now.
3733	* The guest can't use VBVA anymore, so only only the VGA device output works.
3734	*/
3735	if (pFBInfo->fDisabled)
3736	{
3737	pFBInfo->fDisabled = false;
3738	fireGuestMonitorChangedEvent(pThis->mParent->i_getEventSource(),
3739	GuestMonitorChangedEventType_Enabled,
3740	uScreenId,
3741	pFBInfo->xOrigin, pFBInfo->yOrigin,
3742	pFBInfo->w, pFBInfo->h);
3743	}
3744	}
3745
3746	pFBInfo->fVBVAEnabled = false;
3747	pFBInfo->fVBVAForceResize = false;
3748	pFBInfo->fRenderThreadMode = false;
3749
3750	vbvaSetMemoryFlagsHGSMI(uScreenId, 0, false, pFBInfo);
3751
3752	pFBInfo->pVBVAHostFlags = NULL;
3753
3754	if (!fRenderThreadMode && uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
3755	{
3756	/* Force full screen update, because VGA device must take control, do resize, etc. */
3757	pThis->mpDrv->pUpPort->pfnUpdateDisplayAll(pThis->mpDrv->pUpPort, /* fFailOnResize = */ false);
3758	}
3759	}
3760
3761	DECLCALLBACK(void) Display::i_displayVBVAUpdateBegin(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId)
3762	{
3763	LogFlowFunc(("uScreenId %d\n", uScreenId));
3764
3765	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3766	Display *pThis = pDrv->pDisplay;
3767	DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[uScreenId];
3768
3769	if (ASMAtomicReadU32(&pThis->mu32UpdateVBVAFlags) > 0)
3770	{
3771	vbvaSetMemoryFlagsAllHGSMI(pThis->mfu32SupportedOrders, pThis->mfVideoAccelVRDP, pThis->maFramebuffers,
3772	pThis->mcMonitors);
3773	ASMAtomicDecU32(&pThis->mu32UpdateVBVAFlags);
3774	}
3775	}
3776
3777	DECLCALLBACK(void) Display::i_displayVBVAUpdateProcess(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId,
3778	const PVBVACMDHDR pCmd, size_t cbCmd)
3779	{
3780	LogFlowFunc(("uScreenId %d pCmd %p cbCmd %d, @%d,%d %dx%d\n", uScreenId, pCmd, cbCmd, pCmd->x, pCmd->y, pCmd->w, pCmd->h));
3781
3782	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3783	Display *pThis = pDrv->pDisplay;
3784	DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[uScreenId];
3785
3786	if (pFBInfo->fDefaultFormat)
3787	{
3788	/* Make sure that framebuffer contains the same image as the guest VRAM. */
3789	if ( uScreenId == VBOX_VIDEO_PRIMARY_SCREEN
3790	&& !pFBInfo->fDisabled)
3791	{
3792	pDrv->pUpPort->pfnUpdateDisplayRect(pDrv->pUpPort, pCmd->x, pCmd->y, pCmd->w, pCmd->h);
3793	}
3794	else if ( !pFBInfo->pSourceBitmap.isNull()
3795	&& !pFBInfo->fDisabled)
3796	{
3797	/* Render VRAM content to the framebuffer. */
3798	BYTE *pAddress = NULL;
3799	ULONG ulWidth = 0;
3800	ULONG ulHeight = 0;
3801	ULONG ulBitsPerPixel = 0;
3802	ULONG ulBytesPerLine = 0;
3803	BitmapFormat_T bitmapFormat = BitmapFormat_Opaque;
3804
3805	HRESULT hrc = pFBInfo->pSourceBitmap->QueryBitmapInfo(&pAddress,
3806	&ulWidth,
3807	&ulHeight,
3808	&ulBitsPerPixel,
3809	&ulBytesPerLine,
3810	&bitmapFormat);
3811	if (SUCCEEDED(hrc))
3812	{
3813	uint32_t width = pCmd->w;
3814	uint32_t height = pCmd->h;
3815
3816	const uint8_t *pu8Src = pFBInfo->pu8FramebufferVRAM;
3817	int32_t xSrc = pCmd->x - pFBInfo->xOrigin;
3818	int32_t ySrc = pCmd->y - pFBInfo->yOrigin;
3819	uint32_t u32SrcWidth = pFBInfo->w;
3820	uint32_t u32SrcHeight = pFBInfo->h;
3821	uint32_t u32SrcLineSize = pFBInfo->u32LineSize;
3822	uint32_t u32SrcBitsPerPixel = pFBInfo->u16BitsPerPixel;
3823
3824	uint8_t *pu8Dst = pAddress;
3825	int32_t xDst = xSrc;
3826	int32_t yDst = ySrc;
3827	uint32_t u32DstWidth = u32SrcWidth;
3828	uint32_t u32DstHeight = u32SrcHeight;
3829	uint32_t u32DstLineSize = u32DstWidth * 4;
3830	uint32_t u32DstBitsPerPixel = 32;
3831
3832	pDrv->pUpPort->pfnCopyRect(pDrv->pUpPort,
3833	width, height,
3834	pu8Src,
3835	xSrc, ySrc,
3836	u32SrcWidth, u32SrcHeight,
3837	u32SrcLineSize, u32SrcBitsPerPixel,
3838	pu8Dst,
3839	xDst, yDst,
3840	u32DstWidth, u32DstHeight,
3841	u32DstLineSize, u32DstBitsPerPixel);
3842	}
3843	}
3844	}
3845
3846	VBVACMDHDR hdrSaved = *pCmd;
3847
3848	VBVACMDHDR pHdrUnconst = (VBVACMDHDR )pCmd;
3849
3850	pHdrUnconst->x -= (int16_t)pFBInfo->xOrigin;
3851	pHdrUnconst->y -= (int16_t)pFBInfo->yOrigin;
3852
3853	/* @todo new SendUpdate entry which can get a separate cmd header or coords. */
3854	pThis->mParent->i_consoleVRDPServer()->SendUpdate(uScreenId, pCmd, (uint32_t)cbCmd);
3855
3856	*pHdrUnconst = hdrSaved;
3857	}
3858
3859	DECLCALLBACK(void) Display::i_displayVBVAUpdateEnd(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, int32_t x, int32_t y,
3860	uint32_t cx, uint32_t cy)
3861	{
3862	LogFlowFunc(("uScreenId %d %d,%d %dx%d\n", uScreenId, x, y, cx, cy));
3863
3864	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3865	Display *pThis = pDrv->pDisplay;
3866	DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[uScreenId];
3867
3868	/* @todo handleFramebufferUpdate (uScreenId,
3869	* x - pThis->maFramebuffers[uScreenId].xOrigin,
3870	* y - pThis->maFramebuffers[uScreenId].yOrigin,
3871	* cx, cy);
3872	*/
3873	pThis->i_handleDisplayUpdate(uScreenId, x - pFBInfo->xOrigin, y - pFBInfo->yOrigin, cx, cy);
3874	}
3875
3876	#ifdef DEBUG_sunlover
3877	static void logVBVAResize(const PVBVAINFOVIEW pView, const PVBVAINFOSCREEN pScreen, const DISPLAYFBINFO *pFBInfo)
3878	{
3879	LogRel(("displayVBVAResize: [%d] %s\n"
3880	" pView->u32ViewIndex %d\n"
3881	" pView->u32ViewOffset 0x%08X\n"
3882	" pView->u32ViewSize 0x%08X\n"
3883	" pView->u32MaxScreenSize 0x%08X\n"
3884	" pScreen->i32OriginX %d\n"
3885	" pScreen->i32OriginY %d\n"
3886	" pScreen->u32StartOffset 0x%08X\n"
3887	" pScreen->u32LineSize 0x%08X\n"
3888	" pScreen->u32Width %d\n"
3889	" pScreen->u32Height %d\n"
3890	" pScreen->u16BitsPerPixel %d\n"
3891	" pScreen->u16Flags 0x%04X\n"
3892	" pFBInfo->u32Offset 0x%08X\n"
3893	" pFBInfo->u32MaxFramebufferSize 0x%08X\n"
3894	" pFBInfo->u32InformationSize 0x%08X\n"
3895	" pFBInfo->fDisabled %d\n"
3896	" xOrigin, yOrigin, w, h: %d,%d %dx%d\n"
3897	" pFBInfo->u16BitsPerPixel %d\n"
3898	" pFBInfo->pu8FramebufferVRAM %p\n"
3899	" pFBInfo->u32LineSize 0x%08X\n"
3900	" pFBInfo->flags 0x%04X\n"
3901	" pFBInfo->pHostEvents %p\n"
3902	" pFBInfo->fDefaultFormat %d\n"
3903	" pFBInfo->fVBVAEnabled %d\n"
3904	" pFBInfo->fVBVAForceResize %d\n"
3905	" pFBInfo->pVBVAHostFlags %p\n"
3906	"",
3907	pScreen->u32ViewIndex,
3908	(pScreen->u16Flags & VBVA_SCREEN_F_DISABLED)? "DISABLED": "ENABLED",
3909	pView->u32ViewIndex,
3910	pView->u32ViewOffset,
3911	pView->u32ViewSize,
3912	pView->u32MaxScreenSize,
3913	pScreen->i32OriginX,
3914	pScreen->i32OriginY,
3915	pScreen->u32StartOffset,
3916	pScreen->u32LineSize,
3917	pScreen->u32Width,
3918	pScreen->u32Height,
3919	pScreen->u16BitsPerPixel,
3920	pScreen->u16Flags,
3921	pFBInfo->u32Offset,
3922	pFBInfo->u32MaxFramebufferSize,
3923	pFBInfo->u32InformationSize,
3924	pFBInfo->fDisabled,
3925	pFBInfo->xOrigin,
3926	pFBInfo->yOrigin,
3927	pFBInfo->w,
3928	pFBInfo->h,
3929	pFBInfo->u16BitsPerPixel,
3930	pFBInfo->pu8FramebufferVRAM,
3931	pFBInfo->u32LineSize,
3932	pFBInfo->flags,
3933	pFBInfo->pHostEvents,
3934	pFBInfo->fDefaultFormat,
3935	pFBInfo->fVBVAEnabled,
3936	pFBInfo->fVBVAForceResize,
3937	pFBInfo->pVBVAHostFlags
3938	));
3939	}
3940	#endif /* DEBUG_sunlover */
3941
3942	DECLCALLBACK(int) Display::i_displayVBVAResize(PPDMIDISPLAYCONNECTOR pInterface, const PVBVAINFOVIEW pView,
3943	const PVBVAINFOSCREEN pScreen, void *pvVRAM, bool fResetInputMapping)
3944	{
3945	LogRelFlowFunc(("pScreen %p, pvVRAM %p\n", pScreen, pvVRAM));
3946
3947	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3948	Display *pThis = pDrv->pDisplay;
3949
3950	DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[pScreen->u32ViewIndex];
3951
3952	if (pScreen->u16Flags & VBVA_SCREEN_F_DISABLED)
3953	{
3954	pThis->i_notifyCroglResize(pView, pScreen, pvVRAM);
3955
3956	pFBInfo->fDisabled = true;
3957	pFBInfo->flags = pScreen->u16Flags;
3958
3959	/* Ask the framebuffer to resize using a default format. The framebuffer will be black.
3960	* So if the frontend does not support GuestMonitorChangedEventType_Disabled event,
3961	* the VM window will be black. */
3962	uint32_t u32Width = pFBInfo->w ? pFBInfo->w : 640;
3963	uint32_t u32Height = pFBInfo->h ? pFBInfo->h : 480;
3964	pThis->i_handleDisplayResize(pScreen->u32ViewIndex, 0, (uint8_t *)NULL, 0,
3965	u32Width, u32Height, pScreen->u16Flags);
3966
3967	fireGuestMonitorChangedEvent(pThis->mParent->i_getEventSource(),
3968	GuestMonitorChangedEventType_Disabled,
3969	pScreen->u32ViewIndex,
3970	0, 0, 0, 0);
3971	return VINF_SUCCESS;
3972	}
3973
3974	/* If display was disabled or there is no framebuffer, a resize will be required,
3975	* because the framebuffer was/will be changed.
3976	*/
3977	bool fResize = pFBInfo->fDisabled \|\| pFBInfo->pFramebuffer.isNull();
3978
3979	if (pFBInfo->fVBVAForceResize)
3980	{
3981	/* VBVA was just enabled. Do the resize. */
3982	fResize = true;
3983	pFBInfo->fVBVAForceResize = false;
3984	}
3985
3986	/* If the screen if blanked, then do a resize request to make sure that the framebuffer
3987	* switches to the default format.
3988	*/
3989	fResize = fResize \|\| RT_BOOL((pScreen->u16Flags ^ pFBInfo->flags) & VBVA_SCREEN_F_BLANK);
3990
3991	/* Check if this is a real resize or a notification about the screen origin.
3992	* The guest uses this VBVAResize call for both.
3993	*/
3994	fResize = fResize
3995	\|\| pFBInfo->u16BitsPerPixel != pScreen->u16BitsPerPixel
3996	\|\| pFBInfo->pu8FramebufferVRAM != (uint8_t *)pvVRAM + pScreen->u32StartOffset
3997	\|\| pFBInfo->u32LineSize != pScreen->u32LineSize
3998	\|\| pFBInfo->w != pScreen->u32Width
3999	\|\| pFBInfo->h != pScreen->u32Height;
4000
4001	bool fNewOrigin = pFBInfo->xOrigin != pScreen->i32OriginX
4002	\|\| pFBInfo->yOrigin != pScreen->i32OriginY;
4003
4004	if (fNewOrigin \|\| fResize)
4005	pThis->i_notifyCroglResize(pView, pScreen, pvVRAM);
4006
4007	if (pFBInfo->fDisabled)
4008	{
4009	pFBInfo->fDisabled = false;
4010	fireGuestMonitorChangedEvent(pThis->mParent->i_getEventSource(),
4011	GuestMonitorChangedEventType_Enabled,
4012	pScreen->u32ViewIndex,
4013	pScreen->i32OriginX, pScreen->i32OriginY,
4014	pScreen->u32Width, pScreen->u32Height);
4015	/* Continue to update pFBInfo. */
4016	}
4017
4018	pFBInfo->u32Offset = pView->u32ViewOffset; /* Not used in HGSMI. */
4019	pFBInfo->u32MaxFramebufferSize = pView->u32MaxScreenSize; /* Not used in HGSMI. */
4020	pFBInfo->u32InformationSize = 0; /* Not used in HGSMI. */
4021
4022	pFBInfo->xOrigin = pScreen->i32OriginX;
4023	pFBInfo->yOrigin = pScreen->i32OriginY;
4024
4025	pFBInfo->w = pScreen->u32Width;
4026	pFBInfo->h = pScreen->u32Height;
4027
4028	pFBInfo->u16BitsPerPixel = pScreen->u16BitsPerPixel;
4029	pFBInfo->pu8FramebufferVRAM = (uint8_t *)pvVRAM + pScreen->u32StartOffset;
4030	pFBInfo->u32LineSize = pScreen->u32LineSize;
4031
4032	pFBInfo->flags = pScreen->u16Flags;
4033
4034	if (fResetInputMapping)
4035	{
4036	pThis->xInputMappingOrigin = 0;
4037	pThis->yInputMappingOrigin = 0;
4038	pThis->cxInputMapping = 0;
4039	pThis->cyInputMapping = 0;
4040	}
4041
4042	if (fNewOrigin)
4043	{
4044	fireGuestMonitorChangedEvent(pThis->mParent->i_getEventSource(),
4045	GuestMonitorChangedEventType_NewOrigin,
4046	pScreen->u32ViewIndex,
4047	pScreen->i32OriginX, pScreen->i32OriginY,
4048	0, 0);
4049	}
4050
4051	if (!fResize)
4052	{
4053	/* No parameters of the framebuffer have actually changed. */
4054	if (fNewOrigin)
4055	{
4056	/* VRDP server still need this notification. */
4057	LogRelFlowFunc(("Calling VRDP\n"));
4058	pThis->mParent->i_consoleVRDPServer()->SendResize();
4059	}
4060	return VINF_SUCCESS;
4061	}
4062
4063	/* Do a regular resize. */
4064	return pThis->i_handleDisplayResize(pScreen->u32ViewIndex, pScreen->u16BitsPerPixel,
4065	(uint8_t *)pvVRAM + pScreen->u32StartOffset,
4066	pScreen->u32LineSize, pScreen->u32Width, pScreen->u32Height, pScreen->u16Flags);
4067	}
4068
4069	DECLCALLBACK(int) Display::i_displayVBVAMousePointerShape(PPDMIDISPLAYCONNECTOR pInterface, bool fVisible, bool fAlpha,
4070	uint32_t xHot, uint32_t yHot,
4071	uint32_t cx, uint32_t cy,
4072	const void *pvShape)
4073	{
4074	LogFlowFunc(("\n"));
4075
4076	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
4077	Display *pThis = pDrv->pDisplay;
4078
4079	uint32_t cbShape = 0;
4080	if (pvShape)
4081	{
4082	cbShape = (cx + 7) / 8 * cy; /* size of the AND mask */
4083	cbShape = ((cbShape + 3) & ~3) + cx * 4 * cy; /* + gap + size of the XOR mask */
4084	}
4085
4086	/* Tell the console about it */
4087	pDrv->pDisplay->mParent->i_onMousePointerShapeChange(fVisible, fAlpha,
4088	xHot, yHot, cx, cy, (uint8_t *)pvShape, cbShape);
4089
4090	return VINF_SUCCESS;
4091	}
4092
4093	DECLCALLBACK(void) Display::i_displayVBVAGuestCapabilityUpdate(PPDMIDISPLAYCONNECTOR pInterface, uint32_t fCapabilities)
4094	{
4095	LogFlowFunc(("\n"));
4096
4097	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
4098	Display *pThis = pDrv->pDisplay;
4099
4100	pThis->i_handleUpdateGuestVBVACapabilities(fCapabilities);
4101	}
4102
4103	DECLCALLBACK(void) Display::i_displayVBVAInputMappingUpdate(PPDMIDISPLAYCONNECTOR pInterface, int32_t xOrigin, int32_t yOrigin,
4104	uint32_t cx, uint32_t cy)
4105	{
4106	LogFlowFunc(("\n"));
4107
4108	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
4109	Display *pThis = pDrv->pDisplay;
4110
4111	pThis->i_handleUpdateVBVAInputMapping(xOrigin, yOrigin, cx, cy);
4112	}
4113
4114	#endif /* VBOX_WITH_HGSMI */
4115
4116	/**
4117	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
4118	*/
4119	DECLCALLBACK(void ) Display::i_drvQueryInterface(PPDMIBASE pInterface, const char pszIID)
4120	{
4121	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
4122	PDRVMAINDISPLAY pDrv = PDMINS_2_DATA(pDrvIns, PDRVMAINDISPLAY);
4123	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
4124	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIDISPLAYCONNECTOR, &pDrv->IConnector);
4125	return NULL;
4126	}
4127
4128
4129	/**
4130	* Destruct a display driver instance.
4131	*
4132	* @returns VBox status code.
4133	* @param pDrvIns The driver instance data.
4134	*/
4135	DECLCALLBACK(void) Display::i_drvDestruct(PPDMDRVINS pDrvIns)
4136	{
4137	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
4138	PDRVMAINDISPLAY pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINDISPLAY);
4139	LogRelFlowFunc(("iInstance=%d\n", pDrvIns->iInstance));
4140
4141	pThis->pUpPort->pfnSetRenderVRAM(pThis->pUpPort, false);
4142
4143	pThis->IConnector.pbData = NULL;
4144	pThis->IConnector.cbScanline = 0;
4145	pThis->IConnector.cBits = 32;
4146	pThis->IConnector.cx = 0;
4147	pThis->IConnector.cy = 0;
4148
4149	if (pThis->pDisplay)
4150	{
4151	AutoWriteLock displayLock(pThis->pDisplay COMMA_LOCKVAL_SRC_POS);
4152	#ifdef VBOX_WITH_VPX
4153	pThis->pDisplay->i_VideoCaptureStop();
4154	#endif
4155	#ifdef VBOX_WITH_CRHGSMI
4156	pThis->pDisplay->i_destructCrHgsmiData();
4157	#endif
4158	pThis->pDisplay->mpDrv = NULL;
4159	pThis->pDisplay->mpVMMDev = NULL;
4160	}
4161	}
4162
4163
4164	/**
4165	* Construct a display driver instance.
4166	*
4167	* @copydoc FNPDMDRVCONSTRUCT
4168	*/
4169	DECLCALLBACK(int) Display::i_drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
4170	{
4171	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
4172	PDRVMAINDISPLAY pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINDISPLAY);
4173	LogRelFlowFunc(("iInstance=%d\n", pDrvIns->iInstance));
4174
4175	/*
4176	* Validate configuration.
4177	*/
4178	if (!CFGMR3AreValuesValid(pCfg, "Object\0"))
4179	return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
4180	AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
4181	("Configuration error: Not possible to attach anything to this driver!\n"),
4182	VERR_PDM_DRVINS_NO_ATTACH);
4183
4184	/*
4185	* Init Interfaces.
4186	*/
4187	pDrvIns->IBase.pfnQueryInterface = Display::i_drvQueryInterface;
4188
4189	pThis->IConnector.pfnResize = Display::i_displayResizeCallback;
4190	pThis->IConnector.pfnUpdateRect = Display::i_displayUpdateCallback;
4191	pThis->IConnector.pfnRefresh = Display::i_displayRefreshCallback;
4192	pThis->IConnector.pfnReset = Display::i_displayResetCallback;
4193	pThis->IConnector.pfnLFBModeChange = Display::i_displayLFBModeChangeCallback;
4194	pThis->IConnector.pfnProcessAdapterData = Display::i_displayProcessAdapterDataCallback;
4195	pThis->IConnector.pfnProcessDisplayData = Display::i_displayProcessDisplayDataCallback;
4196	#ifdef VBOX_WITH_VIDEOHWACCEL
4197	pThis->IConnector.pfnVHWACommandProcess = Display::i_displayVHWACommandProcess;
4198	#endif
4199	#ifdef VBOX_WITH_CRHGSMI
4200	pThis->IConnector.pfnCrHgsmiCommandProcess = Display::i_displayCrHgsmiCommandProcess;
4201	pThis->IConnector.pfnCrHgsmiControlProcess = Display::i_displayCrHgsmiControlProcess;
4202	#endif
4203	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
4204	pThis->IConnector.pfnCrHgcmCtlSubmit = Display::i_displayCrHgcmCtlSubmit;
4205	#endif
4206	#ifdef VBOX_WITH_HGSMI
4207	pThis->IConnector.pfnVBVAEnable = Display::i_displayVBVAEnable;
4208	pThis->IConnector.pfnVBVADisable = Display::i_displayVBVADisable;
4209	pThis->IConnector.pfnVBVAUpdateBegin = Display::i_displayVBVAUpdateBegin;
4210	pThis->IConnector.pfnVBVAUpdateProcess = Display::i_displayVBVAUpdateProcess;
4211	pThis->IConnector.pfnVBVAUpdateEnd = Display::i_displayVBVAUpdateEnd;
4212	pThis->IConnector.pfnVBVAResize = Display::i_displayVBVAResize;
4213	pThis->IConnector.pfnVBVAMousePointerShape = Display::i_displayVBVAMousePointerShape;
4214	pThis->IConnector.pfnVBVAGuestCapabilityUpdate = Display::i_displayVBVAGuestCapabilityUpdate;
4215	pThis->IConnector.pfnVBVAInputMappingUpdate = Display::i_displayVBVAInputMappingUpdate;
4216	#endif
4217
4218	/*
4219	* Get the IDisplayPort interface of the above driver/device.
4220	*/
4221	pThis->pUpPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIDISPLAYPORT);
4222	if (!pThis->pUpPort)
4223	{
4224	AssertMsgFailed(("Configuration error: No display port interface above!\n"));
4225	return VERR_PDM_MISSING_INTERFACE_ABOVE;
4226	}
4227	#if defined(VBOX_WITH_VIDEOHWACCEL) \|\| defined(VBOX_WITH_CRHGSMI)
4228	pThis->pVBVACallbacks = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIDISPLAYVBVACALLBACKS);
4229	if (!pThis->pVBVACallbacks)
4230	{
4231	AssertMsgFailed(("Configuration error: No VBVA callback interface above!\n"));
4232	return VERR_PDM_MISSING_INTERFACE_ABOVE;
4233	}
4234	#endif
4235	/*
4236	* Get the Display object pointer and update the mpDrv member.
4237	*/
4238	void *pv;
4239	int rc = CFGMR3QueryPtr(pCfg, "Object", &pv);
4240	if (RT_FAILURE(rc))
4241	{
4242	AssertMsgFailed(("Configuration error: No/bad \"Object\" value! rc=%Rrc\n", rc));
4243	return rc;
4244	}
4245	Display pDisplay = (Display )pv; /** @todo Check this cast! */
4246	pThis->pDisplay = pDisplay;
4247	pThis->pDisplay->mpDrv = pThis;
4248
4249	/* Disable VRAM to a buffer copy initially. */
4250	pThis->pUpPort->pfnSetRenderVRAM(pThis->pUpPort, false);
4251	pThis->IConnector.cBits = 32; /* DevVGA does nothing otherwise. */
4252
4253	/*
4254	* Start periodic screen refreshes
4255	*/
4256	pThis->pUpPort->pfnSetRefreshRate(pThis->pUpPort, 20);
4257
4258	#ifdef VBOX_WITH_CRHGSMI
4259	pDisplay->i_setupCrHgsmiData();
4260	#endif
4261
4262	#ifdef VBOX_WITH_VPX
4263	ComPtr<IMachine> pMachine = pDisplay->mParent->i_machine();
4264	BOOL fEnabled = false;
4265	HRESULT hrc = pMachine->COMGETTER(VideoCaptureEnabled)(&fEnabled);
4266	AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
4267	if (fEnabled)
4268	{
4269	rc = pDisplay->i_VideoCaptureStart();
4270	fireVideoCaptureChangedEvent(pDisplay->mParent->i_getEventSource());
4271	}
4272	#endif
4273
4274	return rc;
4275	}
4276
4277
4278	/**
4279	* Display driver registration record.
4280	*/
4281	const PDMDRVREG Display::DrvReg =
4282	{
4283	/* u32Version */
4284	PDM_DRVREG_VERSION,
4285	/* szName */
4286	"MainDisplay",
4287	/* szRCMod */
4288	"",
4289	/* szR0Mod */
4290	"",
4291	/* pszDescription */
4292	"Main display driver (Main as in the API).",
4293	/* fFlags */
4294	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
4295	/* fClass. */
4296	PDM_DRVREG_CLASS_DISPLAY,
4297	/* cMaxInstances */
4298	~0U,
4299	/* cbInstance */
4300	sizeof(DRVMAINDISPLAY),
4301	/* pfnConstruct */
4302	Display::i_drvConstruct,
4303	/* pfnDestruct */
4304	Display::i_drvDestruct,
4305	/* pfnRelocate */
4306	NULL,
4307	/* pfnIOCtl */
4308	NULL,
4309	/* pfnPowerOn */
4310	NULL,
4311	/* pfnReset */
4312	NULL,
4313	/* pfnSuspend */
4314	NULL,
4315	/* pfnResume */
4316	NULL,
4317	/* pfnAttach */
4318	NULL,
4319	/* pfnDetach */
4320	NULL,
4321	/* pfnPowerOff */
4322	NULL,
4323	/* pfnSoftReset */
4324	NULL,
4325	/* u32EndVersion */
4326	PDM_DRVREG_VERSION
4327	};
4328
4329	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/src-client/DisplayImpl.cpp@ 61847

Download in other formats: