VirtualBox

About
Screenshots
Downloads
Documentation
End-user docs
Technical docs
Contribute
Community

Browse Source

Context Navigation

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

Last change on this file since 73003 was 73003, checked in by vboxsync, 6 years ago
Main: Use setErrorBoth when we've got a VBox status code handy. (The COM status codes aren't too specfic and this may help us decode error messages and provide an alternative to strstr for API clients. setErrorBoth isn't new, btw.)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 168.3 KB

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

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

Download in other formats:

© 2023 Oracle
Contact – Privacy policy – Terms of Use