DisplayImpl.cpp@ 52312

最後變更在這個檔案從52312是 52312,由 vboxsync 提交於 11 年前
6219: New parameters related to file size / recording time limitation for VM Video Capture have been added (vcpmaxtime, vcpmaxsize and vcpoptions - special codec options in key=value format). EbmlWriter has been refactored. Removed some redundant code.
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Author Date Id Revision`
檔案大小: 169.0 KB

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

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

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

以其他格式下載: