DisplayImpl.cpp@ 52309

Last change on this file since 52309 was 52309, checked in by vboxsync, 10 years ago
DisplayImpl: do not wait for InvalidateAndUpdateEMT completion, because it blocks the GUI if the request takes a long time to complete.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 168.0 KB

Line
1	/* $Id: DisplayImpl.cpp 52309 2014-08-07 07:17:50Z vboxsync $ */
2	/** @file
3	* VirtualBox COM class implementation
4	*/
5
6	/*
7	* Copyright (C) 2006-2014 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	#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	RTTIMESPEC ts;
2918	RTTimeNow(&ts);
2919	RTTIME time;
2920	RTTimeExplode(&time, &ts);
2921	for (unsigned uScreen = 0; uScreen < mcMonitors; uScreen++)
2922	{
2923	char *pszAbsPath = RTPathAbsDup(com::Utf8Str(strFile).c_str());
2924	char *pszSuff = RTPathSuffix(pszAbsPath);
2925	if (pszSuff)
2926	pszSuff = RTStrDup(pszSuff);
2927	RTPathStripSuffix(pszAbsPath);
2928	if (!pszAbsPath)
2929	rc = VERR_INVALID_PARAMETER;
2930	if (!pszSuff)
2931	pszSuff = RTStrDup(".webm");
2932	char *pszName = NULL;
2933	if (RT_SUCCESS(rc))
2934	{
2935	if (mcMonitors > 1)
2936	rc = RTStrAPrintf(&pszName, "%s-%u%s", pszAbsPath, uScreen+1, pszSuff);
2937	else
2938	rc = RTStrAPrintf(&pszName, "%s%s", pszAbsPath, pszSuff);
2939	}
2940	if (RT_SUCCESS(rc))
2941	{
2942	rc = VideoRecStrmInit(mpVideoRecCtx, uScreen,
2943	pszName, ulWidth, ulHeight, ulRate, ulFPS);
2944	if (rc == VERR_ALREADY_EXISTS)
2945	{
2946	RTStrFree(pszName);
2947	pszName = NULL;
2948
2949	if (mcMonitors > 1)
2950	rc = RTStrAPrintf(&pszName, "%s-%04d-%02u-%02uT%02u-%02u-%02u-%09uZ-%u%s",
2951	pszAbsPath, time.i32Year, time.u8Month, time.u8MonthDay,
2952	time.u8Hour, time.u8Minute, time.u8Second, time.u32Nanosecond,
2953	uScreen+1, pszSuff);
2954	else
2955	rc = RTStrAPrintf(&pszName, "%s-%04d-%02u-%02uT%02u-%02u-%02u-%09uZ%s",
2956	pszAbsPath, time.i32Year, time.u8Month, time.u8MonthDay,
2957	time.u8Hour, time.u8Minute, time.u8Second, time.u32Nanosecond,
2958	pszSuff);
2959	if (RT_SUCCESS(rc))
2960	rc = VideoRecStrmInit(mpVideoRecCtx, uScreen,
2961	pszName, ulWidth, ulHeight, ulRate, ulFPS);
2962	}
2963	}
2964
2965	if (RT_SUCCESS(rc))
2966	LogRel(("WebM/VP8 video recording screen #%u with %ux%u @ %u kbps, %u fps to '%s' enabled.\n",
2967	uScreen, ulWidth, ulHeight, ulRate, ulFPS, pszName));
2968	else
2969	LogRel(("Failed to initialize video recording context #%u (%Rrc)!\n", uScreen, rc));
2970	RTStrFree(pszName);
2971	RTStrFree(pszSuff);
2972	RTStrFree(pszAbsPath);
2973	}
2974	return rc;
2975	#else
2976	return VERR_NOT_IMPLEMENTED;
2977	#endif
2978	}
2979
2980	/**
2981	* Stop video capturing. Does nothing if video capturing is not active.
2982	*/
2983	void Display::i_VideoCaptureStop()
2984	{
2985	#ifdef VBOX_WITH_VPX
2986	if (VideoRecIsEnabled(mpVideoRecCtx))
2987	LogRel(("WebM/VP8 video recording stopped.\n"));
2988	VideoRecContextClose(mpVideoRecCtx);
2989	mpVideoRecCtx = NULL;
2990	#endif
2991	}
2992
2993	int Display::i_drawToScreenEMT(Display pDisplay, ULONG aScreenId, BYTE address,
2994	ULONG x, ULONG y, ULONG width, ULONG height)
2995	{
2996	int rc = VINF_SUCCESS;
2997
2998	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[aScreenId];
2999
3000	if (aScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
3001	{
3002	Assert(!pDisplay->i_vbvaLockIsOwner());
3003	rc = pDisplay->mpDrv->pUpPort->pfnDisplayBlt(pDisplay->mpDrv->pUpPort, address, x, y, width, height);
3004	}
3005	else if (aScreenId < pDisplay->mcMonitors)
3006	{
3007	/* Copy the bitmap to the guest VRAM. */
3008	const uint8_t *pu8Src = address;
3009	int32_t xSrc = 0;
3010	int32_t ySrc = 0;
3011	uint32_t u32SrcWidth = width;
3012	uint32_t u32SrcHeight = height;
3013	uint32_t u32SrcLineSize = width * 4;
3014	uint32_t u32SrcBitsPerPixel = 32;
3015
3016	uint8_t *pu8Dst = pFBInfo->pu8FramebufferVRAM;
3017	int32_t xDst = x;
3018	int32_t yDst = y;
3019	uint32_t u32DstWidth = pFBInfo->w;
3020	uint32_t u32DstHeight = pFBInfo->h;
3021	uint32_t u32DstLineSize = pFBInfo->u32LineSize;
3022	uint32_t u32DstBitsPerPixel = pFBInfo->u16BitsPerPixel;
3023
3024	Assert(!pDisplay->i_vbvaLockIsOwner());
3025	rc = pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
3026	width, height,
3027	pu8Src,
3028	xSrc, ySrc,
3029	u32SrcWidth, u32SrcHeight,
3030	u32SrcLineSize, u32SrcBitsPerPixel,
3031	pu8Dst,
3032	xDst, yDst,
3033	u32DstWidth, u32DstHeight,
3034	u32DstLineSize, u32DstBitsPerPixel);
3035	if (RT_SUCCESS(rc))
3036	{
3037	if (!pFBInfo->pSourceBitmap.isNull())
3038	{
3039	/* Update the changed screen area. When source bitmap uses VRAM directly, just notify
3040	* frontend to update. And for default format, render the guest VRAM to the source bitmap.
3041	*/
3042	if ( pFBInfo->fDefaultFormat
3043	&& !pFBInfo->fDisabled)
3044	{
3045	BYTE *pAddress = NULL;
3046	ULONG ulWidth = 0;
3047	ULONG ulHeight = 0;
3048	ULONG ulBitsPerPixel = 0;
3049	ULONG ulBytesPerLine = 0;
3050	ULONG ulPixelFormat = 0;
3051
3052	HRESULT hrc = pFBInfo->pSourceBitmap->QueryBitmapInfo(&pAddress,
3053	&ulWidth,
3054	&ulHeight,
3055	&ulBitsPerPixel,
3056	&ulBytesPerLine,
3057	&ulPixelFormat);
3058	if (SUCCEEDED(hrc))
3059	{
3060	pu8Src = pFBInfo->pu8FramebufferVRAM;
3061	xSrc = x;
3062	ySrc = y;
3063	u32SrcWidth = pFBInfo->w;
3064	u32SrcHeight = pFBInfo->h;
3065	u32SrcLineSize = pFBInfo->u32LineSize;
3066	u32SrcBitsPerPixel = pFBInfo->u16BitsPerPixel;
3067
3068	/* Default format is 32 bpp. */
3069	pu8Dst = pAddress;
3070	xDst = xSrc;
3071	yDst = ySrc;
3072	u32DstWidth = u32SrcWidth;
3073	u32DstHeight = u32SrcHeight;
3074	u32DstLineSize = u32DstWidth * 4;
3075	u32DstBitsPerPixel = 32;
3076
3077	Assert(!pDisplay->i_vbvaLockIsOwner());
3078	pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
3079	width, height,
3080	pu8Src,
3081	xSrc, ySrc,
3082	u32SrcWidth, u32SrcHeight,
3083	u32SrcLineSize, u32SrcBitsPerPixel,
3084	pu8Dst,
3085	xDst, yDst,
3086	u32DstWidth, u32DstHeight,
3087	u32DstLineSize, u32DstBitsPerPixel);
3088	}
3089	}
3090	}
3091
3092	pDisplay->i_handleDisplayUpdate(aScreenId, x, y, width, height);
3093	}
3094	}
3095	else
3096	{
3097	rc = VERR_INVALID_PARAMETER;
3098	}
3099
3100	if (RT_SUCCESS(rc))
3101	pDisplay->mParent->i_consoleVRDPServer()->SendUpdateBitmap(aScreenId, x, y, width, height);
3102
3103	return rc;
3104	}
3105
3106	HRESULT Display::drawToScreen(ULONG aScreenId, BYTE *aAddress, ULONG aX, ULONG aY, ULONG aWidth, ULONG aHeight)
3107	{
3108	/// @todo (r=dmik) this function may take too long to complete if the VM
3109	// is doing something like saving state right now. Which, in case if it
3110	// is called on the GUI thread, will make it unresponsive. We should
3111	// check the machine state here (by enclosing the check and VMRequCall
3112	// within the Console lock to make it atomic).
3113
3114	LogRelFlowFunc(("aAddress=%p, x=%d, y=%d, width=%d, height=%d\n",
3115	(void *)aAddress, aX, aY, aWidth, aHeight));
3116
3117	CheckComArgExpr(aWidth, aWidth != 0);
3118	CheckComArgExpr(aHeight, aHeight != 0);
3119
3120	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3121
3122	CHECK_CONSOLE_DRV(mpDrv);
3123
3124	Console::SafeVMPtr ptrVM(mParent);
3125	if (!ptrVM.isOk())
3126	return ptrVM.rc();
3127
3128	/* Release lock because the call scheduled on EMT may also try to take it. */
3129	alock.release();
3130
3131	/*
3132	* Again we're lazy and make the graphics device do all the
3133	* dirty conversion work.
3134	*/
3135	int rcVBox = VMR3ReqCallWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_drawToScreenEMT, 7,
3136	this, aScreenId, aAddress, aX, aY, aWidth, aHeight);
3137
3138	/*
3139	* If the function returns not supported, we'll have to do all the
3140	* work ourselves using the framebuffer.
3141	*/
3142	HRESULT rc = S_OK;
3143	if (rcVBox == VERR_NOT_SUPPORTED \|\| rcVBox == VERR_NOT_IMPLEMENTED)
3144	{
3145	/** @todo implement generic fallback for screen blitting. */
3146	rc = E_NOTIMPL;
3147	}
3148	else if (RT_FAILURE(rcVBox))
3149	rc = setError(VBOX_E_IPRT_ERROR,
3150	tr("Could not draw to the screen (%Rrc)"), rcVBox);
3151	//@todo
3152	// else
3153	// {
3154	// /* All ok. Redraw the screen. */
3155	// handleDisplayUpdate (x, y, width, height);
3156	// }
3157
3158	LogRelFlowFunc(("rc=%Rhrc\n", rc));
3159	return rc;
3160	}
3161
3162	int Display::i_InvalidateAndUpdateEMT(Display *pDisplay, unsigned uId, bool fUpdateAll)
3163	{
3164	LogRelFlowFunc(("uId=%d, fUpdateAll %d\n", uId, fUpdateAll));
3165
3166	unsigned uScreenId;
3167	for (uScreenId = (fUpdateAll ? 0 : uId); uScreenId < pDisplay->mcMonitors; uScreenId++)
3168	{
3169	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[uScreenId];
3170
3171	if ( !pFBInfo->fVBVAEnabled
3172	&& uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
3173	{
3174	Assert(!pDisplay->i_vbvaLockIsOwner());
3175	pDisplay->mpDrv->pUpPort->pfnUpdateDisplayAll(pDisplay->mpDrv->pUpPort, /* fFailOnResize = */ true);
3176	}
3177	else
3178	{
3179	if (!pFBInfo->fDisabled)
3180	{
3181	/* Render complete VRAM screen to the framebuffer.
3182	* When framebuffer uses VRAM directly, just notify it to update.
3183	*/
3184	if (pFBInfo->fDefaultFormat && !pFBInfo->pSourceBitmap.isNull())
3185	{
3186	BYTE *pAddress = NULL;
3187	ULONG ulWidth = 0;
3188	ULONG ulHeight = 0;
3189	ULONG ulBitsPerPixel = 0;
3190	ULONG ulBytesPerLine = 0;
3191	ULONG ulPixelFormat = 0;
3192
3193	HRESULT hrc = pFBInfo->pSourceBitmap->QueryBitmapInfo(&pAddress,
3194	&ulWidth,
3195	&ulHeight,
3196	&ulBitsPerPixel,
3197	&ulBytesPerLine,
3198	&ulPixelFormat);
3199	if (SUCCEEDED(hrc))
3200	{
3201	uint32_t width = pFBInfo->w;
3202	uint32_t height = pFBInfo->h;
3203
3204	const uint8_t *pu8Src = pFBInfo->pu8FramebufferVRAM;
3205	int32_t xSrc = 0;
3206	int32_t ySrc = 0;
3207	uint32_t u32SrcWidth = pFBInfo->w;
3208	uint32_t u32SrcHeight = pFBInfo->h;
3209	uint32_t u32SrcLineSize = pFBInfo->u32LineSize;
3210	uint32_t u32SrcBitsPerPixel = pFBInfo->u16BitsPerPixel;
3211
3212	/* Default format is 32 bpp. */
3213	uint8_t *pu8Dst = pAddress;
3214	int32_t xDst = xSrc;
3215	int32_t yDst = ySrc;
3216	uint32_t u32DstWidth = u32SrcWidth;
3217	uint32_t u32DstHeight = u32SrcHeight;
3218	uint32_t u32DstLineSize = u32DstWidth * 4;
3219	uint32_t u32DstBitsPerPixel = 32;
3220
3221	/* if uWidth != pFBInfo->w and uHeight != pFBInfo->h
3222	* implies resize of Framebuffer is in progress and
3223	* copyrect should not be called.
3224	*/
3225	if (ulWidth == pFBInfo->w && ulHeight == pFBInfo->h)
3226	{
3227	Assert(!pDisplay->i_vbvaLockIsOwner());
3228	pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
3229	width, height,
3230	pu8Src,
3231	xSrc, ySrc,
3232	u32SrcWidth, u32SrcHeight,
3233	u32SrcLineSize, u32SrcBitsPerPixel,
3234	pu8Dst,
3235	xDst, yDst,
3236	u32DstWidth, u32DstHeight,
3237	u32DstLineSize, u32DstBitsPerPixel);
3238	}
3239	}
3240	}
3241
3242	pDisplay->i_handleDisplayUpdate(uScreenId, 0, 0, pFBInfo->w, pFBInfo->h);
3243	}
3244	}
3245	if (!fUpdateAll)
3246	break;
3247	}
3248	LogRelFlowFunc(("done\n"));
3249	return VINF_SUCCESS;
3250	}
3251
3252	/**
3253	* Does a full invalidation of the VM display and instructs the VM
3254	* to update it immediately.
3255	*
3256	* @returns COM status code
3257	*/
3258
3259	HRESULT Display::invalidateAndUpdate()
3260	{
3261	LogRelFlowFunc(("\n"));
3262
3263	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3264
3265	CHECK_CONSOLE_DRV(mpDrv);
3266
3267	Console::SafeVMPtr ptrVM(mParent);
3268	if (!ptrVM.isOk())
3269	return ptrVM.rc();
3270
3271	HRESULT rc = S_OK;
3272
3273	LogRelFlowFunc(("Sending DPYUPDATE request\n"));
3274
3275	/* Have to release the lock when calling EMT. */
3276	alock.release();
3277
3278	int rcVBox = VMR3ReqCallNoWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_InvalidateAndUpdateEMT,
3279	3, this, 0, true);
3280	alock.acquire();
3281
3282	if (RT_FAILURE(rcVBox))
3283	rc = setError(VBOX_E_IPRT_ERROR,
3284	tr("Could not invalidate and update the screen (%Rrc)"), rcVBox);
3285
3286	LogRelFlowFunc(("rc=%Rhrc\n", rc));
3287	return rc;
3288	}
3289
3290	HRESULT Display::invalidateAndUpdateScreen(ULONG aScreenId)
3291	{
3292	LogRelFlowFunc(("\n"));
3293
3294	HRESULT rc = S_OK;
3295
3296	Console::SafeVMPtr ptrVM(mParent);
3297	if (!ptrVM.isOk())
3298	return ptrVM.rc();
3299
3300	int rcVBox = VMR3ReqCallNoWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_InvalidateAndUpdateEMT,
3301	3, this, aScreenId, false);
3302	if (RT_FAILURE(rcVBox))
3303	rc = setError(VBOX_E_IPRT_ERROR,
3304	tr("Could not invalidate and update the screen %d (%Rrc)"), aScreenId, rcVBox);
3305
3306	LogRelFlowFunc(("rc=%Rhrc\n", rc));
3307	return rc;
3308	}
3309
3310	HRESULT Display::completeVHWACommand(BYTE *aCommand)
3311	{
3312	#ifdef VBOX_WITH_VIDEOHWACCEL
3313	mpDrv->pVBVACallbacks->pfnVHWACommandCompleteAsync(mpDrv->pVBVACallbacks, (PVBOXVHWACMD)aCommand);
3314	return S_OK;
3315	#else
3316	return E_NOTIMPL;
3317	#endif
3318	}
3319
3320	HRESULT Display::viewportChanged(ULONG aScreenId, ULONG aX, ULONG aY, ULONG aWidth, ULONG aHeight)
3321	{
3322	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
3323
3324	if (mcMonitors <= aScreenId)
3325	{
3326	AssertMsgFailed(("invalid screen id\n"));
3327	return E_INVALIDARG;
3328	}
3329
3330	BOOL is3denabled;
3331	mParent->i_machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
3332
3333	if (is3denabled)
3334	{
3335	int rc = i_crViewportNotify(aScreenId, aX, aY, aWidth, aHeight);
3336	if (RT_FAILURE(rc))
3337	{
3338	DISPLAYFBINFO *pFb = &maFramebuffers[aScreenId];
3339	pFb->pendingViewportInfo.fPending = true;
3340	pFb->pendingViewportInfo.x = aX;
3341	pFb->pendingViewportInfo.y = aY;
3342	pFb->pendingViewportInfo.width = aWidth;
3343	pFb->pendingViewportInfo.height = aHeight;
3344	}
3345	}
3346	#endif /* VBOX_WITH_CROGL && VBOX_WITH_HGCM */
3347	return S_OK;
3348	}
3349
3350	HRESULT Display::querySourceBitmap(ULONG aScreenId,
3351	ComPtr<IDisplaySourceBitmap> &aDisplaySourceBitmap)
3352	{
3353	LogRelFlowFunc(("aScreenId = %d\n", aScreenId));
3354
3355	Console::SafeVMPtr ptrVM(mParent);
3356	if (!ptrVM.isOk())
3357	return ptrVM.rc();
3358
3359	bool fSetRenderVRAM = false;
3360	bool fInvalidate = false;
3361
3362	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3363
3364	if (aScreenId >= mcMonitors)
3365	return setError(E_INVALIDARG, tr("QuerySourceBitmap: Invalid screen %d (total %d)"),
3366	aScreenId, mcMonitors);
3367
3368	if (!mfSourceBitmapEnabled)
3369	{
3370	aDisplaySourceBitmap = NULL;
3371	return E_FAIL;
3372	}
3373
3374	HRESULT hr = S_OK;
3375
3376	DISPLAYFBINFO *pFBInfo = &maFramebuffers[aScreenId];
3377	if (pFBInfo->pSourceBitmap.isNull())
3378	{
3379	/* Create a new object. */
3380	ComObjPtr<DisplaySourceBitmap> obj;
3381	hr = obj.createObject();
3382	if (SUCCEEDED(hr))
3383	hr = obj->init(this, aScreenId, pFBInfo);
3384
3385	if (SUCCEEDED(hr))
3386	{
3387	bool fDefaultFormat = !obj->i_usesVRAM();
3388
3389	if (aScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
3390	{
3391	/* Start buffer updates. */
3392	BYTE *pAddress = NULL;
3393	ULONG ulWidth = 0;
3394	ULONG ulHeight = 0;
3395	ULONG ulBitsPerPixel = 0;
3396	ULONG ulBytesPerLine = 0;
3397	ULONG ulPixelFormat = 0;
3398
3399	obj->QueryBitmapInfo(&pAddress,
3400	&ulWidth,
3401	&ulHeight,
3402	&ulBitsPerPixel,
3403	&ulBytesPerLine,
3404	&ulPixelFormat);
3405
3406	mpDrv->IConnector.pu8Data = pAddress;
3407	mpDrv->IConnector.cbScanline = ulBytesPerLine;
3408	mpDrv->IConnector.cBits = ulBitsPerPixel;
3409	mpDrv->IConnector.cx = ulWidth;
3410	mpDrv->IConnector.cy = ulHeight;
3411
3412	fSetRenderVRAM = fDefaultFormat;
3413	}
3414
3415	/* Make sure that the bitmap contains the latest image. */
3416	fInvalidate = fDefaultFormat;
3417
3418	pFBInfo->pSourceBitmap = obj;
3419	pFBInfo->fDefaultFormat = fDefaultFormat;
3420	}
3421	}
3422
3423	if (SUCCEEDED(hr))
3424	{
3425	pFBInfo->pSourceBitmap.queryInterfaceTo(aDisplaySourceBitmap.asOutParam());
3426	}
3427
3428	/* Leave the IDisplay lock because the VGA device must not be called under it. */
3429	alock.release();
3430
3431	if (SUCCEEDED(hr))
3432	{
3433	if (fSetRenderVRAM)
3434	{
3435	Assert(!i_vbvaLockIsOwner());
3436	mpDrv->pUpPort->pfnSetRenderVRAM(mpDrv->pUpPort, true);
3437	}
3438
3439	if (fInvalidate)
3440	VMR3ReqCallWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_InvalidateAndUpdateEMT,
3441	3, this, aScreenId, false);
3442	}
3443
3444	LogRelFlowFunc(("%Rhrc\n", hr));
3445	return hr;
3446	}
3447
3448	HRESULT Display::setFramebufferUpdateMode(ULONG aScreenId, FramebufferUpdateMode_T aFramebufferUpdateMode)
3449	{
3450	LogRelFlowFunc(("aScreenId %d, aFramebufferUpdateMode %d\n", aScreenId, aFramebufferUpdateMode));
3451
3452	HRESULT hr = S_OK;
3453
3454	/* Prepare without taking a lock. API has it's own locking. */
3455	ComPtr<IDisplaySourceBitmap> pSourceBitmap;
3456	if (aFramebufferUpdateMode == FramebufferUpdateMode_NotifyUpdateImage)
3457	{
3458	/* A source bitmap will be needed. */
3459	hr = QuerySourceBitmap(aScreenId, pSourceBitmap.asOutParam());
3460	}
3461
3462	if (FAILED(hr))
3463	return hr;
3464
3465	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3466
3467	if (aScreenId >= mcMonitors)
3468	return setError(E_INVALIDARG, tr("SetFramebufferUpdateMode: Invalid screen %d (total %d)"),
3469	aScreenId, mcMonitors);
3470
3471	DISPLAYFBINFO *pFBInfo = &maFramebuffers[aScreenId];
3472
3473	/* Reset the update mode. */
3474	pFBInfo->updateImage.pSourceBitmap.setNull();
3475	pFBInfo->updateImage.pu8Address = NULL;
3476	pFBInfo->updateImage.cbLine = 0;
3477
3478	if (aFramebufferUpdateMode == FramebufferUpdateMode_NotifyUpdateImage)
3479	{
3480	BYTE *pAddress = NULL;
3481	ULONG ulWidth = 0;
3482	ULONG ulHeight = 0;
3483	ULONG ulBitsPerPixel = 0;
3484	ULONG ulBytesPerLine = 0;
3485	ULONG ulPixelFormat = 0;
3486
3487	hr = pSourceBitmap->QueryBitmapInfo(&pAddress,
3488	&ulWidth,
3489	&ulHeight,
3490	&ulBitsPerPixel,
3491	&ulBytesPerLine,
3492	&ulPixelFormat);
3493	if (SUCCEEDED(hr))
3494	{
3495	pFBInfo->updateImage.pSourceBitmap = pSourceBitmap;
3496	pFBInfo->updateImage.pu8Address = pAddress;
3497	pFBInfo->updateImage.cbLine = ulBytesPerLine;
3498	}
3499	}
3500
3501	pFBInfo->enmFramebufferUpdateMode = aFramebufferUpdateMode;
3502
3503	return S_OK;
3504	}
3505
3506	// wrapped IEventListener method
3507	HRESULT Display::handleEvent(const ComPtr<IEvent> &aEvent)
3508	{
3509	VBoxEventType_T aType = VBoxEventType_Invalid;
3510
3511	aEvent->COMGETTER(Type)(&aType);
3512	switch (aType)
3513	{
3514	case VBoxEventType_OnStateChanged:
3515	{
3516	ComPtr<IStateChangedEvent> scev = aEvent;
3517	Assert(scev);
3518	MachineState_T machineState;
3519	scev->COMGETTER(State)(&machineState);
3520	if ( machineState == MachineState_Running
3521	\|\| machineState == MachineState_Teleporting
3522	\|\| machineState == MachineState_LiveSnapshotting
3523	\|\| machineState == MachineState_DeletingSnapshotOnline
3524	)
3525	{
3526	LogRelFlowFunc(("Machine is running.\n"));
3527
3528	mfMachineRunning = true;
3529
3530	#ifdef VBOX_WITH_CROGL
3531	i_crOglWindowsShow(true);
3532	#endif
3533	}
3534	else
3535	{
3536	mfMachineRunning = false;
3537
3538	#ifdef VBOX_WITH_CROGL
3539	if (machineState == MachineState_Paused)
3540	i_crOglWindowsShow(false);
3541	#endif
3542	}
3543	break;
3544	}
3545	default:
3546	AssertFailed();
3547	}
3548
3549	return S_OK;
3550	}
3551
3552
3553	// private methods
3554	/////////////////////////////////////////////////////////////////////////////
3555
3556	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
3557	int Display::i_crViewportNotify(ULONG aScreenId, ULONG x, ULONG y, ULONG width, ULONG height)
3558	{
3559	VMMDev *pVMMDev = mParent->i_getVMMDev();
3560	if (!pVMMDev)
3561	return VERR_INVALID_STATE;
3562
3563	size_t cbData = RT_UOFFSETOF(VBOXCRCMDCTL_HGCM, aParms[5]);
3564	VBOXCRCMDCTL_HGCM pData = (VBOXCRCMDCTL_HGCM)alloca(cbData);
3565
3566	pData->Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
3567	pData->Hdr.u32Function = SHCRGL_HOST_FN_VIEWPORT_CHANGED;
3568
3569	pData->aParms[0].type = VBOX_HGCM_SVC_PARM_32BIT;
3570	pData->aParms[0].u.uint32 = aScreenId;
3571
3572	pData->aParms[1].type = VBOX_HGCM_SVC_PARM_32BIT;
3573	pData->aParms[1].u.uint32 = x;
3574
3575	pData->aParms[2].type = VBOX_HGCM_SVC_PARM_32BIT;
3576	pData->aParms[2].u.uint32 = y;
3577
3578	pData->aParms[3].type = VBOX_HGCM_SVC_PARM_32BIT;
3579	pData->aParms[3].u.uint32 = width;
3580
3581	pData->aParms[4].type = VBOX_HGCM_SVC_PARM_32BIT;
3582	pData->aParms[4].u.uint32 = height;
3583
3584	return i_crCtlSubmitSyncIfHasDataForScreen(aScreenId, &pData->Hdr, (uint32_t)cbData);
3585	}
3586	#endif
3587
3588	#ifdef VBOX_WITH_CRHGSMI
3589	void Display::i_setupCrHgsmiData(void)
3590	{
3591	VMMDev *pVMMDev = mParent->i_getVMMDev();
3592	Assert(pVMMDev);
3593	int rc = RTCritSectRwEnterExcl(&mCrOglLock);
3594	AssertRC(rc);
3595
3596	if (pVMMDev)
3597	rc = pVMMDev->hgcmHostSvcHandleCreate("VBoxSharedCrOpenGL", &mhCrOglSvc);
3598	else
3599	rc = VERR_GENERAL_FAILURE;
3600
3601	if (RT_SUCCESS(rc))
3602	{
3603	Assert(mhCrOglSvc);
3604	/* setup command completion callback */
3605	VBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP_MAINCB Completion;
3606	Completion.Hdr.enmType = VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP_MAINCB;
3607	Completion.Hdr.cbCmd = sizeof(Completion);
3608	Completion.hCompletion = mpDrv->pVBVACallbacks;
3609	Completion.pfnCompletion = mpDrv->pVBVACallbacks->pfnCrHgsmiCommandCompleteAsync;
3610
3611	VBOXHGCMSVCPARM parm;
3612	parm.type = VBOX_HGCM_SVC_PARM_PTR;
3613	parm.u.pointer.addr = &Completion;
3614	parm.u.pointer.size = 0;
3615
3616	rc = pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_CRHGSMI_CTL, 1, &parm);
3617	if (RT_SUCCESS(rc))
3618	mCrOglCallbacks = Completion.MainInterface;
3619	else
3620	AssertMsgFailed(("VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP_COMPLETION failed rc %d", rc));
3621	}
3622
3623	if (RT_FAILURE(rc))
3624	mhCrOglSvc = NULL;
3625
3626	RTCritSectRwLeaveExcl(&mCrOglLock);
3627	}
3628
3629	void Display::i_destructCrHgsmiData(void)
3630	{
3631	int rc = RTCritSectRwEnterExcl(&mCrOglLock);
3632	AssertRC(rc);
3633	mhCrOglSvc = NULL;
3634	RTCritSectRwLeaveExcl(&mCrOglLock);
3635	}
3636	#endif
3637
3638	/**
3639	* Handle display resize event issued by the VGA device for the primary screen.
3640	*
3641	* @see PDMIDISPLAYCONNECTOR::pfnResize
3642	*/
3643	DECLCALLBACK(int) Display::i_displayResizeCallback(PPDMIDISPLAYCONNECTOR pInterface,
3644	uint32_t bpp, void *pvVRAM, uint32_t cbLine, uint32_t cx, uint32_t cy)
3645	{
3646	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3647	Display *pThis = pDrv->pDisplay;
3648
3649	LogRelFlowFunc(("bpp %d, pvVRAM %p, cbLine %d, cx %d, cy %d\n",
3650	bpp, pvVRAM, cbLine, cx, cy));
3651
3652	bool f = ASMAtomicCmpXchgBool(&pThis->fVGAResizing, true, false);
3653	if (!f)
3654	{
3655	/* This is a result of recursive call when the source bitmap is being updated
3656	* during a VGA resize. Tell the VGA device to ignore the call.
3657	*
3658	* @todo It is a workaround, actually pfnUpdateDisplayAll must
3659	* fail on resize.
3660	*/
3661	LogRel(("displayResizeCallback: already processing\n"));
3662	return VINF_VGA_RESIZE_IN_PROGRESS;
3663	}
3664
3665	int rc = pThis->i_handleDisplayResize(VBOX_VIDEO_PRIMARY_SCREEN, bpp, pvVRAM, cbLine, cx, cy, VBVA_SCREEN_F_ACTIVE);
3666
3667	/* Restore the flag. */
3668	f = ASMAtomicCmpXchgBool(&pThis->fVGAResizing, false, true);
3669	AssertRelease(f);
3670
3671	return rc;
3672	}
3673
3674	/**
3675	* Handle display update.
3676	*
3677	* @see PDMIDISPLAYCONNECTOR::pfnUpdateRect
3678	*/
3679	DECLCALLBACK(void) Display::i_displayUpdateCallback(PPDMIDISPLAYCONNECTOR pInterface,
3680	uint32_t x, uint32_t y, uint32_t cx, uint32_t cy)
3681	{
3682	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3683
3684	#ifdef DEBUG_sunlover
3685	LogFlowFunc(("mfVideoAccelEnabled = %d, %d,%d %dx%d\n",
3686	pDrv->pDisplay->mfVideoAccelEnabled, x, y, cx, cy));
3687	#endif /* DEBUG_sunlover */
3688
3689	/* This call does update regardless of VBVA status.
3690	* But in VBVA mode this is called only as result of
3691	* pfnUpdateDisplayAll in the VGA device.
3692	*/
3693
3694	pDrv->pDisplay->i_handleDisplayUpdate(VBOX_VIDEO_PRIMARY_SCREEN, x, y, cx, cy);
3695	}
3696
3697	/**
3698	* Periodic display refresh callback.
3699	*
3700	* @see PDMIDISPLAYCONNECTOR::pfnRefresh
3701	* @thread EMT
3702	*/
3703	DECLCALLBACK(void) Display::i_displayRefreshCallback(PPDMIDISPLAYCONNECTOR pInterface)
3704	{
3705	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3706
3707	#ifdef DEBUG_sunlover_2
3708	LogFlowFunc(("pDrv->pDisplay->mfVideoAccelEnabled = %d\n",
3709	pDrv->pDisplay->mfVideoAccelEnabled));
3710	#endif /* DEBUG_sunlover_2 */
3711
3712	Display *pDisplay = pDrv->pDisplay;
3713	unsigned uScreenId;
3714
3715	int rc = pDisplay->i_videoAccelRefreshProcess();
3716	if (rc != VINF_TRY_AGAIN) /* Means 'do nothing' here. */
3717	{
3718	if (rc == VWRN_INVALID_STATE)
3719	{
3720	/* No VBVA do a display update. */
3721	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN];
3722	Assert(!pDisplay->i_vbvaLockIsOwner());
3723	pDrv->pUpPort->pfnUpdateDisplay(pDrv->pUpPort);
3724	}
3725
3726	/* Inform the VRDP server that the current display update sequence is
3727	* completed. At this moment the framebuffer memory contains a definite
3728	* image, that is synchronized with the orders already sent to VRDP client.
3729	* The server can now process redraw requests from clients or initial
3730	* fullscreen updates for new clients.
3731	*/
3732	for (uScreenId = 0; uScreenId < pDisplay->mcMonitors; uScreenId++)
3733	{
3734	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[uScreenId];
3735
3736	Assert(pDisplay->mParent && pDisplay->mParent->i_consoleVRDPServer());
3737	pDisplay->mParent->i_consoleVRDPServer()->SendUpdate(uScreenId, NULL, 0);
3738	}
3739	}
3740
3741	#ifdef VBOX_WITH_VPX
3742	if (VideoRecIsEnabled(pDisplay->mpVideoRecCtx))
3743	{
3744	do {
3745	# if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
3746	BOOL is3denabled;
3747	pDisplay->mParent->i_machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
3748	if (is3denabled)
3749	{
3750	if (ASMAtomicCmpXchgU32(&pDisplay->mfCrOglVideoRecState, CRVREC_STATE_SUBMITTED, CRVREC_STATE_IDLE))
3751	{
3752	if (pDisplay->mCrOglCallbacks.pfnHasData())
3753	{
3754	/* submit */
3755	VBOXCRCMDCTL_HGCM *pData = &pDisplay->mCrOglScreenshotCtl;
3756
3757	pData->Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
3758	pData->Hdr.u32Function = SHCRGL_HOST_FN_TAKE_SCREENSHOT;
3759
3760	pData->aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
3761	pData->aParms[0].u.pointer.addr = &pDisplay->mCrOglScreenshotData;
3762	pData->aParms[0].u.pointer.size = sizeof(pDisplay->mCrOglScreenshotData);
3763	rc = pDisplay->i_crCtlSubmit(&pData->Hdr, sizeof(*pData), NULL, NULL);
3764	if (!RT_SUCCESS(rc))
3765	AssertMsgFailed(("crCtlSubmit failed rc %d\n", rc));
3766	}
3767
3768	/* no 3D data available, or error has occured,
3769	* go the straight way */
3770	ASMAtomicWriteU32(&pDisplay->mfCrOglVideoRecState, CRVREC_STATE_IDLE);
3771	}
3772	else
3773	{
3774	/* record request is still in progress, don't do anything */
3775	break;
3776	}
3777	}
3778	# endif /* VBOX_WITH_HGCM && VBOX_WITH_CROGL */
3779
3780	uint64_t u64Now = RTTimeProgramMilliTS();
3781	for (uScreenId = 0; uScreenId < pDisplay->mcMonitors; uScreenId++)
3782	{
3783	if (!pDisplay->maVideoRecEnabled[uScreenId])
3784	continue;
3785
3786	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[uScreenId];
3787
3788	if ( !pFBInfo->pFramebuffer.isNull()
3789	&& !pFBInfo->fDisabled)
3790	{
3791	rc = VERR_NOT_SUPPORTED;
3792	if ( pFBInfo->fVBVAEnabled
3793	&& pFBInfo->pu8FramebufferVRAM)
3794	{
3795	rc = VideoRecCopyToIntBuf(pDisplay->mpVideoRecCtx, uScreenId, 0, 0,
3796	BitmapFormat_BGR,
3797	pFBInfo->u16BitsPerPixel,
3798	pFBInfo->u32LineSize, pFBInfo->w, pFBInfo->h,
3799	pFBInfo->pu8FramebufferVRAM, u64Now);
3800	}
3801	else if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN && pDrv->IConnector.pu8Data)
3802	{
3803	rc = VideoRecCopyToIntBuf(pDisplay->mpVideoRecCtx, uScreenId, 0, 0,
3804	BitmapFormat_BGR,
3805	pDrv->IConnector.cBits,
3806	pDrv->IConnector.cbScanline, pDrv->IConnector.cx,
3807	pDrv->IConnector.cy, pDrv->IConnector.pu8Data, u64Now);
3808	}
3809	if (rc == VINF_TRY_AGAIN)
3810	break;
3811	}
3812	}
3813	} while (0);
3814	}
3815	#endif /* VBOX_WITH_VPX */
3816
3817	#ifdef DEBUG_sunlover_2
3818	LogFlowFunc(("leave\n"));
3819	#endif /* DEBUG_sunlover_2 */
3820	}
3821
3822	/**
3823	* Reset notification
3824	*
3825	* @see PDMIDISPLAYCONNECTOR::pfnReset
3826	*/
3827	DECLCALLBACK(void) Display::i_displayResetCallback(PPDMIDISPLAYCONNECTOR pInterface)
3828	{
3829	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3830
3831	LogRelFlowFunc(("\n"));
3832
3833	/* Disable VBVA mode. */
3834	pDrv->pDisplay->i_VideoAccelEnable(false, NULL);
3835	}
3836
3837	/**
3838	* LFBModeChange notification
3839	*
3840	* @see PDMIDISPLAYCONNECTOR::pfnLFBModeChange
3841	*/
3842	DECLCALLBACK(void) Display::i_displayLFBModeChangeCallback(PPDMIDISPLAYCONNECTOR pInterface, bool fEnabled)
3843	{
3844	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3845
3846	LogRelFlowFunc(("fEnabled=%d\n", fEnabled));
3847
3848	NOREF(fEnabled);
3849
3850	/* Disable VBVA mode in any case. The guest driver reenables VBVA mode if necessary. */
3851	/* The LFBModeChange function is called under DevVGA lock. Postpone disabling VBVA, do it in the refresh timer. */
3852	ASMAtomicWriteU32(&pDrv->pDisplay->mfu32PendingVideoAccelDisable, true);
3853	}
3854
3855	/**
3856	* Adapter information change notification.
3857	*
3858	* @see PDMIDISPLAYCONNECTOR::pfnProcessAdapterData
3859	*/
3860	DECLCALLBACK(void) Display::i_displayProcessAdapterDataCallback(PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM,
3861	uint32_t u32VRAMSize)
3862	{
3863	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3864
3865	if (pvVRAM == NULL)
3866	{
3867	unsigned i;
3868	for (i = 0; i < pDrv->pDisplay->mcMonitors; i++)
3869	{
3870	DISPLAYFBINFO *pFBInfo = &pDrv->pDisplay->maFramebuffers[i];
3871
3872	pFBInfo->u32Offset = 0;
3873	pFBInfo->u32MaxFramebufferSize = 0;
3874	pFBInfo->u32InformationSize = 0;
3875	}
3876	}
3877	#ifndef VBOX_WITH_HGSMI
3878	else
3879	{
3880	uint8_t pu8 = (uint8_t )pvVRAM;
3881	pu8 += u32VRAMSize - VBOX_VIDEO_ADAPTER_INFORMATION_SIZE;
3882
3883	// @todo
3884	uint8_t *pu8End = pu8 + VBOX_VIDEO_ADAPTER_INFORMATION_SIZE;
3885
3886	VBOXVIDEOINFOHDR *pHdr;
3887
3888	for (;;)
3889	{
3890	pHdr = (VBOXVIDEOINFOHDR *)pu8;
3891	pu8 += sizeof(VBOXVIDEOINFOHDR);
3892
3893	if (pu8 >= pu8End)
3894	{
3895	LogRel(("VBoxVideo: Guest adapter information overflow!!!\n"));
3896	break;
3897	}
3898
3899	if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_DISPLAY)
3900	{
3901	if (pHdr->u16Length != sizeof(VBOXVIDEOINFODISPLAY))
3902	{
3903	LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "DISPLAY", pHdr->u16Length));
3904	break;
3905	}
3906
3907	VBOXVIDEOINFODISPLAY pDisplay = (VBOXVIDEOINFODISPLAY )pu8;
3908
3909	if (pDisplay->u32Index >= pDrv->pDisplay->mcMonitors)
3910	{
3911	LogRel(("VBoxVideo: Guest adapter information invalid display index %d!!!\n", pDisplay->u32Index));
3912	break;
3913	}
3914
3915	DISPLAYFBINFO *pFBInfo = &pDrv->pDisplay->maFramebuffers[pDisplay->u32Index];
3916
3917	pFBInfo->u32Offset = pDisplay->u32Offset;
3918	pFBInfo->u32MaxFramebufferSize = pDisplay->u32FramebufferSize;
3919	pFBInfo->u32InformationSize = pDisplay->u32InformationSize;
3920
3921	LogRelFlow(("VBOX_VIDEO_INFO_TYPE_DISPLAY: %d: at 0x%08X, size 0x%08X, info 0x%08X\n", pDisplay->u32Index,
3922	pDisplay->u32Offset, pDisplay->u32FramebufferSize, pDisplay->u32InformationSize));
3923	}
3924	else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_QUERY_CONF32)
3925	{
3926	if (pHdr->u16Length != sizeof(VBOXVIDEOINFOQUERYCONF32))
3927	{
3928	LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "CONF32", pHdr->u16Length));
3929	break;
3930	}
3931
3932	VBOXVIDEOINFOQUERYCONF32 pConf32 = (VBOXVIDEOINFOQUERYCONF32 )pu8;
3933
3934	switch (pConf32->u32Index)
3935	{
3936	case VBOX_VIDEO_QCI32_MONITOR_COUNT:
3937	{
3938	pConf32->u32Value = pDrv->pDisplay->mcMonitors;
3939	} break;
3940
3941	case VBOX_VIDEO_QCI32_OFFSCREEN_HEAP_SIZE:
3942	{
3943	/* @todo make configurable. */
3944	pConf32->u32Value = _1M;
3945	} break;
3946
3947	default:
3948	LogRel(("VBoxVideo: CONF32 %d not supported!!! Skipping.\n", pConf32->u32Index));
3949	}
3950	}
3951	else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_END)
3952	{
3953	if (pHdr->u16Length != 0)
3954	{
3955	LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "END", pHdr->u16Length));
3956	break;
3957	}
3958
3959	break;
3960	}
3961	else if (pHdr->u8Type != VBOX_VIDEO_INFO_TYPE_NV_HEAP)
3962	{
3963	/** @todo why is Additions/WINNT/Graphics/Miniport/VBoxVideo. cpp pushing this to us? */
3964	LogRel(("Guest adapter information contains unsupported type %d. The block has been skipped.\n", pHdr->u8Type));
3965	}
3966
3967	pu8 += pHdr->u16Length;
3968	}
3969	}
3970	#endif /* !VBOX_WITH_HGSMI */
3971	}
3972
3973	/**
3974	* Display information change notification.
3975	*
3976	* @see PDMIDISPLAYCONNECTOR::pfnProcessDisplayData
3977	*/
3978	DECLCALLBACK(void) Display::i_displayProcessDisplayDataCallback(PPDMIDISPLAYCONNECTOR pInterface,
3979	void *pvVRAM, unsigned uScreenId)
3980	{
3981	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3982
3983	if (uScreenId >= pDrv->pDisplay->mcMonitors)
3984	{
3985	LogRel(("VBoxVideo: Guest display information invalid display index %d!!!\n", uScreenId));
3986	return;
3987	}
3988
3989	/* Get the display information structure. */
3990	DISPLAYFBINFO *pFBInfo = &pDrv->pDisplay->maFramebuffers[uScreenId];
3991
3992	uint8_t pu8 = (uint8_t )pvVRAM;
3993	pu8 += pFBInfo->u32Offset + pFBInfo->u32MaxFramebufferSize;
3994
3995	// @todo
3996	uint8_t *pu8End = pu8 + pFBInfo->u32InformationSize;
3997
3998	VBOXVIDEOINFOHDR *pHdr;
3999
4000	for (;;)
4001	{
4002	pHdr = (VBOXVIDEOINFOHDR *)pu8;
4003	pu8 += sizeof(VBOXVIDEOINFOHDR);
4004
4005	if (pu8 >= pu8End)
4006	{
4007	LogRel(("VBoxVideo: Guest display information overflow!!!\n"));
4008	break;
4009	}
4010
4011	if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_SCREEN)
4012	{
4013	if (pHdr->u16Length != sizeof(VBOXVIDEOINFOSCREEN))
4014	{
4015	LogRel(("VBoxVideo: Guest display information %s invalid length %d!!!\n", "SCREEN", pHdr->u16Length));
4016	break;
4017	}
4018
4019	VBOXVIDEOINFOSCREEN pScreen = (VBOXVIDEOINFOSCREEN )pu8;
4020
4021	pFBInfo->xOrigin = pScreen->xOrigin;
4022	pFBInfo->yOrigin = pScreen->yOrigin;
4023
4024	pFBInfo->w = pScreen->u16Width;
4025	pFBInfo->h = pScreen->u16Height;
4026
4027	LogRelFlow(("VBOX_VIDEO_INFO_TYPE_SCREEN: (%p) %d: at %d,%d, linesize 0x%X, size %dx%d, bpp %d, flags 0x%02X\n",
4028	pHdr, uScreenId, pScreen->xOrigin, pScreen->yOrigin, pScreen->u32LineSize, pScreen->u16Width,
4029	pScreen->u16Height, pScreen->bitsPerPixel, pScreen->u8Flags));
4030
4031	if (uScreenId != VBOX_VIDEO_PRIMARY_SCREEN)
4032	{
4033	/* Primary screen resize is eeeeeeeee by the VGA device. */
4034	if (pFBInfo->fDisabled)
4035	{
4036	pFBInfo->fDisabled = false;
4037	fireGuestMonitorChangedEvent(pDrv->pDisplay->mParent->i_getEventSource(),
4038	GuestMonitorChangedEventType_Enabled,
4039	uScreenId,
4040	pFBInfo->xOrigin, pFBInfo->yOrigin,
4041	pFBInfo->w, pFBInfo->h);
4042	}
4043
4044	pDrv->pDisplay->i_handleDisplayResize(uScreenId, pScreen->bitsPerPixel,
4045	(uint8_t *)pvVRAM + pFBInfo->u32Offset,
4046	pScreen->u32LineSize,
4047	pScreen->u16Width, pScreen->u16Height,
4048	VBVA_SCREEN_F_ACTIVE);
4049	}
4050	}
4051	else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_END)
4052	{
4053	if (pHdr->u16Length != 0)
4054	{
4055	LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "END", pHdr->u16Length));
4056	break;
4057	}
4058
4059	break;
4060	}
4061	else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_HOST_EVENTS)
4062	{
4063	if (pHdr->u16Length != sizeof(VBOXVIDEOINFOHOSTEVENTS))
4064	{
4065	LogRel(("VBoxVideo: Guest display information %s invalid length %d!!!\n", "HOST_EVENTS", pHdr->u16Length));
4066	break;
4067	}
4068
4069	VBOXVIDEOINFOHOSTEVENTS pHostEvents = (VBOXVIDEOINFOHOSTEVENTS )pu8;
4070
4071	pFBInfo->pHostEvents = pHostEvents;
4072
4073	LogFlow(("VBOX_VIDEO_INFO_TYPE_HOSTEVENTS: (%p)\n",
4074	pHostEvents));
4075	}
4076	else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_LINK)
4077	{
4078	if (pHdr->u16Length != sizeof(VBOXVIDEOINFOLINK))
4079	{
4080	LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "LINK", pHdr->u16Length));
4081	break;
4082	}
4083
4084	VBOXVIDEOINFOLINK pLink = (VBOXVIDEOINFOLINK )pu8;
4085	pu8 += pLink->i32Offset;
4086	}
4087	else
4088	{
4089	LogRel(("Guest display information contains unsupported type %d\n", pHdr->u8Type));
4090	}
4091
4092	pu8 += pHdr->u16Length;
4093	}
4094	}
4095
4096	#ifdef VBOX_WITH_VIDEOHWACCEL
4097
4098	#ifndef S_FALSE
4099	# define S_FALSE ((HRESULT)1L)
4100	#endif
4101
4102	int Display::i_handleVHWACommandProcess(PVBOXVHWACMD pCommand)
4103	{
4104	unsigned id = (unsigned)pCommand->iDisplay;
4105	int rc = VINF_SUCCESS;
4106	if (id >= mcMonitors)
4107	return VERR_INVALID_PARAMETER;
4108
4109	ComPtr<IFramebuffer> pFramebuffer;
4110	AutoReadLock arlock(this COMMA_LOCKVAL_SRC_POS);
4111	pFramebuffer = maFramebuffers[id].pFramebuffer;
4112	arlock.release();
4113
4114	if (pFramebuffer == NULL)
4115	return VERR_NOT_IMPLEMENTED; /* Implementation is not available. */
4116
4117	HRESULT hr = pFramebuffer->ProcessVHWACommand((BYTE*)pCommand);
4118	if (hr == S_FALSE)
4119	return VINF_SUCCESS;
4120	else if (SUCCEEDED(hr))
4121	return VINF_CALLBACK_RETURN;
4122	else if (hr == E_ACCESSDENIED)
4123	return VERR_INVALID_STATE; /* notify we can not handle request atm */
4124	else if (hr == E_NOTIMPL)
4125	return VERR_NOT_IMPLEMENTED;
4126	return VERR_GENERAL_FAILURE;
4127	}
4128
4129	DECLCALLBACK(int) Display::i_displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand)
4130	{
4131	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
4132
4133	return pDrv->pDisplay->i_handleVHWACommandProcess(pCommand);
4134	}
4135	#endif
4136
4137	#ifdef VBOX_WITH_CRHGSMI
4138	void Display::i_handleCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam)
4139	{
4140	mpDrv->pVBVACallbacks->pfnCrHgsmiCommandCompleteAsync(mpDrv->pVBVACallbacks,
4141	(PVBOXVDMACMD_CHROMIUM_CMD)pParam->u.pointer.addr, result);
4142	}
4143
4144	void Display::i_handleCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam)
4145	{
4146	PVBOXVDMACMD_CHROMIUM_CTL pCtl = (PVBOXVDMACMD_CHROMIUM_CTL)pParam->u.pointer.addr;
4147	mpDrv->pVBVACallbacks->pfnCrHgsmiControlCompleteAsync(mpDrv->pVBVACallbacks, pCtl, result);
4148	}
4149
4150	void Display::i_handleCrHgsmiCommandProcess(PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd)
4151	{
4152	int rc = VERR_NOT_SUPPORTED;
4153	VBOXHGCMSVCPARM parm;
4154	parm.type = VBOX_HGCM_SVC_PARM_PTR;
4155	parm.u.pointer.addr = pCmd;
4156	parm.u.pointer.size = cbCmd;
4157
4158	if (mhCrOglSvc)
4159	{
4160	VMMDev *pVMMDev = mParent->i_getVMMDev();
4161	if (pVMMDev)
4162	{
4163	/* no completion callback is specified with this call,
4164	* the CrOgl code will complete the CrHgsmi command once it processes it */
4165	rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_CRHGSMI_CMD, &parm, NULL, NULL);
4166	AssertRC(rc);
4167	if (RT_SUCCESS(rc))
4168	return;
4169	}
4170	else
4171	rc = VERR_INVALID_STATE;
4172	}
4173
4174	/* we are here because something went wrong with command processing, complete it */
4175	i_handleCrHgsmiCommandCompletion(rc, SHCRGL_HOST_FN_CRHGSMI_CMD, &parm);
4176	}
4177
4178	void Display::i_handleCrHgsmiControlProcess(PVBOXVDMACMD_CHROMIUM_CTL pCtl, uint32_t cbCtl)
4179	{
4180	int rc = VERR_NOT_SUPPORTED;
4181	VBOXHGCMSVCPARM parm;
4182	parm.type = VBOX_HGCM_SVC_PARM_PTR;
4183	parm.u.pointer.addr = pCtl;
4184	parm.u.pointer.size = cbCtl;
4185
4186	if (mhCrOglSvc)
4187	{
4188	VMMDev *pVMMDev = mParent->i_getVMMDev();
4189	if (pVMMDev)
4190	{
4191	bool fCheckPendingViewport = (pCtl->enmType == VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP);
4192	rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_CRHGSMI_CTL, &parm,
4193	Display::i_displayCrHgsmiControlCompletion, this);
4194	AssertRC(rc);
4195	if (RT_SUCCESS(rc))
4196	{
4197	if (fCheckPendingViewport)
4198	{
4199	ULONG ul;
4200	for (ul = 0; ul < mcMonitors; ul++)
4201	{
4202	DISPLAYFBINFO *pFb = &maFramebuffers[ul];
4203	if (!pFb->pendingViewportInfo.fPending)
4204	continue;
4205
4206	rc = i_crViewportNotify(ul, pFb->pendingViewportInfo.x, pFb->pendingViewportInfo.y,
4207	pFb->pendingViewportInfo.width, pFb->pendingViewportInfo.height);
4208	if (RT_SUCCESS(rc))
4209	pFb->pendingViewportInfo.fPending = false;
4210	else
4211	{
4212	AssertMsgFailed(("crViewportNotify failed %d\n", rc));
4213	rc = VINF_SUCCESS;
4214	}
4215	}
4216	}
4217	return;
4218	}
4219	}
4220	else
4221	rc = VERR_INVALID_STATE;
4222	}
4223
4224	/* we are here because something went wrong with command processing, complete it */
4225	i_handleCrHgsmiControlCompletion(rc, SHCRGL_HOST_FN_CRHGSMI_CTL, &parm);
4226	}
4227
4228	DECLCALLBACK(void) Display::i_displayCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd,
4229	uint32_t cbCmd)
4230	{
4231	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
4232
4233	pDrv->pDisplay->i_handleCrHgsmiCommandProcess(pCmd, cbCmd);
4234	}
4235
4236	DECLCALLBACK(void) Display::i_displayCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCmd,
4237	uint32_t cbCmd)
4238	{
4239	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
4240
4241	pDrv->pDisplay->i_handleCrHgsmiControlProcess(pCmd, cbCmd);
4242	}
4243
4244	DECLCALLBACK(void) Display::i_displayCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
4245	void *pvContext)
4246	{
4247	AssertMsgFailed(("not expected!"));
4248	Display pDisplay = (Display )pvContext;
4249	pDisplay->i_handleCrHgsmiCommandCompletion(result, u32Function, pParam);
4250	}
4251
4252	DECLCALLBACK(void) Display::i_displayCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
4253	void *pvContext)
4254	{
4255	Display pDisplay = (Display )pvContext;
4256	pDisplay->i_handleCrHgsmiControlCompletion(result, u32Function, pParam);
4257
4258	}
4259	#endif
4260
4261	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
4262	DECLCALLBACK(void) Display::i_displayCrHgcmCtlSubmitCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
4263	void *pvContext)
4264	{
4265	VBOXCRCMDCTL pCmd = (VBOXCRCMDCTL)pParam->u.pointer.addr;
4266	if (pCmd->u.pfnInternal)
4267	((PFNCRCTLCOMPLETION)pCmd->u.pfnInternal)(pCmd, pParam->u.pointer.size, result, pvContext);
4268	}
4269
4270	int Display::i_handleCrHgcmCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd,
4271	PFNCRCTLCOMPLETION pfnCompletion,
4272	void *pvCompletion)
4273	{
4274	VMMDev *pVMMDev = mParent ? mParent->i_getVMMDev() : NULL;
4275	if (!pVMMDev)
4276	{
4277	AssertMsgFailed(("no vmmdev\n"));
4278	return VERR_INVALID_STATE;
4279	}
4280
4281	Assert(mhCrOglSvc);
4282	VBOXHGCMSVCPARM parm;
4283	parm.type = VBOX_HGCM_SVC_PARM_PTR;
4284	parm.u.pointer.addr = pCmd;
4285	parm.u.pointer.size = cbCmd;
4286
4287	pCmd->u.pfnInternal = (void(*)())pfnCompletion;
4288	int rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_CTL, &parm, i_displayCrHgcmCtlSubmitCompletion,
4289	pvCompletion);
4290	if (!RT_SUCCESS(rc))
4291	AssertMsgFailed(("hgcmHostFastCallAsync failed rc %d\n", rc));
4292
4293	return rc;
4294	}
4295
4296	DECLCALLBACK(int) Display::i_displayCrHgcmCtlSubmit(PPDMIDISPLAYCONNECTOR pInterface,
4297	struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd,
4298	PFNCRCTLCOMPLETION pfnCompletion,
4299	void *pvCompletion)
4300	{
4301	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
4302	Display *pThis = pDrv->pDisplay;
4303	return pThis->i_handleCrHgcmCtlSubmit(pCmd, cbCmd, pfnCompletion, pvCompletion);
4304	}
4305
4306	int Display::i_crCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, PFNCRCTLCOMPLETION pfnCompletion, void *pvCompletion)
4307	{
4308	int rc = RTCritSectRwEnterShared(&mCrOglLock);
4309	if (RT_SUCCESS(rc))
4310	{
4311	if (mhCrOglSvc)
4312	rc = mpDrv->pVBVACallbacks->pfnCrCtlSubmit(mpDrv->pVBVACallbacks, pCmd, cbCmd, pfnCompletion, pvCompletion);
4313	else
4314	rc = VERR_NOT_SUPPORTED;
4315
4316	RTCritSectRwLeaveShared(&mCrOglLock);
4317	}
4318	return rc;
4319	}
4320
4321	int Display::i_crCtlSubmitSync(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd)
4322	{
4323	int rc = RTCritSectRwEnterShared(&mCrOglLock);
4324	if (RT_SUCCESS(rc))
4325	{
4326	if (mhCrOglSvc)
4327	rc = mpDrv->pVBVACallbacks->pfnCrCtlSubmitSync(mpDrv->pVBVACallbacks, pCmd, cbCmd);
4328	else
4329	rc = VERR_NOT_SUPPORTED;
4330
4331	RTCritSectRwLeaveShared(&mCrOglLock);
4332	}
4333	return rc;
4334	}
4335
4336	int Display::i_crCtlSubmitAsyncCmdCopy(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd)
4337	{
4338	VBOXCRCMDCTL* pCmdCopy = (VBOXCRCMDCTL*)RTMemAlloc(cbCmd);
4339	if (!pCmdCopy)
4340	{
4341	LogRel(("RTMemAlloc failed\n"));
4342	return VERR_NO_MEMORY;
4343	}
4344
4345	memcpy(pCmdCopy, pCmd, cbCmd);
4346
4347	int rc = i_crCtlSubmit(pCmdCopy, cbCmd, i_displayCrCmdFree, pCmdCopy);
4348	if (RT_FAILURE(rc))
4349	{
4350	LogRel(("crCtlSubmit failed %d\n", rc));
4351	RTMemFree(pCmdCopy);
4352	return rc;
4353	}
4354
4355	return VINF_SUCCESS;
4356	}
4357
4358	int Display::i_crCtlSubmitSyncIfHasDataForScreen(uint32_t u32ScreenID, struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd)
4359	{
4360	int rc = RTCritSectRwEnterShared(&mCrOglLock);
4361	AssertRCReturn(rc, rc);
4362
4363	if (mCrOglCallbacks.pfnHasDataForScreen && mCrOglCallbacks.pfnHasDataForScreen(u32ScreenID))
4364	rc = i_crCtlSubmitSync(pCmd, cbCmd);
4365	else
4366	rc = i_crCtlSubmitAsyncCmdCopy(pCmd, cbCmd);
4367
4368	RTCritSectRwLeaveShared(&mCrOglLock);
4369
4370	return rc;
4371	}
4372
4373	bool Display::i_handleCrVRecScreenshotBegin(uint32_t uScreen, uint64_t u64TimeStamp)
4374	{
4375	# if VBOX_WITH_VPX
4376	return VideoRecIsReady(mpVideoRecCtx, uScreen, u64TimeStamp);
4377	# else
4378	return false;
4379	# endif
4380	}
4381
4382	void Display::i_handleCrVRecScreenshotEnd(uint32_t uScreen, uint64_t u64TimeStamp)
4383	{
4384	}
4385
4386	void Display::i_handleCrVRecScreenshotPerform(uint32_t uScreen,
4387	uint32_t x, uint32_t y, uint32_t uPixelFormat,
4388	uint32_t uBitsPerPixel, uint32_t uBytesPerLine,
4389	uint32_t uGuestWidth, uint32_t uGuestHeight,
4390	uint8_t *pu8BufferAddress, uint64_t u64TimeStamp)
4391	{
4392	Assert(mfCrOglVideoRecState == CRVREC_STATE_SUBMITTED);
4393	# if VBOX_WITH_VPX
4394	int rc = VideoRecCopyToIntBuf(mpVideoRecCtx, uScreen, x, y,
4395	uPixelFormat,
4396	uBitsPerPixel, uBytesPerLine,
4397	uGuestWidth, uGuestHeight,
4398	pu8BufferAddress, u64TimeStamp);
4399	Assert(rc == VINF_SUCCESS /* \|\| rc == VERR_TRY_AGAIN \|\| rc == VINF_TRY_AGAIN*/);
4400	# endif
4401	}
4402
4403	void Display::i_handleVRecCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext)
4404	{
4405	Assert(mfCrOglVideoRecState == CRVREC_STATE_SUBMITTED);
4406	ASMAtomicWriteU32(&mfCrOglVideoRecState, CRVREC_STATE_IDLE);
4407	}
4408
4409	DECLCALLBACK(void) Display::i_displayCrVRecScreenshotPerform(void *pvCtx, uint32_t uScreen,
4410	uint32_t x, uint32_t y,
4411	uint32_t uBitsPerPixel, uint32_t uBytesPerLine,
4412	uint32_t uGuestWidth, uint32_t uGuestHeight,
4413	uint8_t *pu8BufferAddress, uint64_t u64TimeStamp)
4414	{
4415	Display pDisplay = (Display )pvCtx;
4416	pDisplay->i_handleCrVRecScreenshotPerform(uScreen,
4417	x, y, BitmapFormat_BGR, uBitsPerPixel,
4418	uBytesPerLine, uGuestWidth, uGuestHeight,
4419	pu8BufferAddress, u64TimeStamp);
4420	}
4421
4422	DECLCALLBACK(bool) Display::i_displayCrVRecScreenshotBegin(void *pvCtx, uint32_t uScreen, uint64_t u64TimeStamp)
4423	{
4424	Display pDisplay = (Display )pvCtx;
4425	return pDisplay->i_handleCrVRecScreenshotBegin(uScreen, u64TimeStamp);
4426	}
4427
4428	DECLCALLBACK(void) Display::i_displayCrVRecScreenshotEnd(void *pvCtx, uint32_t uScreen, uint64_t u64TimeStamp)
4429	{
4430	Display pDisplay = (Display )pvCtx;
4431	pDisplay->i_handleCrVRecScreenshotEnd(uScreen, u64TimeStamp);
4432	}
4433
4434	DECLCALLBACK(void) Display::i_displayVRecCompletion(int32_t result, uint32_t u32Function,
4435	PVBOXHGCMSVCPARM pParam, void *pvContext)
4436	{
4437	Display pDisplay = (Display )pvContext;
4438	pDisplay->i_handleVRecCompletion(result, u32Function, pParam, pvContext);
4439	}
4440
4441	#endif
4442
4443
4444	#ifdef VBOX_WITH_HGSMI
4445	DECLCALLBACK(int) Display::i_displayVBVAEnable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, PVBVAHOSTFLAGS pHostFlags,
4446	bool fRenderThreadMode)
4447	{
4448	LogRelFlowFunc(("uScreenId %d\n", uScreenId));
4449
4450	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
4451	Display *pThis = pDrv->pDisplay;
4452
4453	if (pThis->maFramebuffers[uScreenId].fVBVAEnabled && pThis->maFramebuffers[uScreenId].fRenderThreadMode != fRenderThreadMode)
4454	{
4455	LogRel(("enabling different vbva mode"));
4456	#ifdef DEBUG_misha
4457	AssertMsgFailed(("enabling different vbva mode"));
4458	#endif
4459	return VERR_INVALID_STATE;
4460	}
4461
4462	pThis->maFramebuffers[uScreenId].fVBVAEnabled = true;
4463	pThis->maFramebuffers[uScreenId].pVBVAHostFlags = pHostFlags;
4464	pThis->maFramebuffers[uScreenId].fRenderThreadMode = fRenderThreadMode;
4465	pThis->maFramebuffers[uScreenId].fVBVAForceResize = true;
4466
4467	vbvaSetMemoryFlagsHGSMI(uScreenId, pThis->mfu32SupportedOrders, pThis->mfVideoAccelVRDP, &pThis->maFramebuffers[uScreenId]);
4468
4469	return VINF_SUCCESS;
4470	}
4471
4472	DECLCALLBACK(void) Display::i_displayVBVADisable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId)
4473	{
4474	LogRelFlowFunc(("uScreenId %d\n", uScreenId));
4475
4476	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
4477	Display *pThis = pDrv->pDisplay;
4478
4479	DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[uScreenId];
4480
4481	bool fRenderThreadMode = pFBInfo->fRenderThreadMode;
4482
4483	if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
4484	{
4485	/* Make sure that the primary screen is visible now.
4486	* The guest can't use VBVA anymore, so only only the VGA device output works.
4487	*/
4488	if (pFBInfo->fDisabled)
4489	{
4490	pFBInfo->fDisabled = false;
4491	fireGuestMonitorChangedEvent(pThis->mParent->i_getEventSource(),
4492	GuestMonitorChangedEventType_Enabled,
4493	uScreenId,
4494	pFBInfo->xOrigin, pFBInfo->yOrigin,
4495	pFBInfo->w, pFBInfo->h);
4496	}
4497	}
4498
4499	pFBInfo->fVBVAEnabled = false;
4500	pFBInfo->fVBVAForceResize = false;
4501	pFBInfo->fRenderThreadMode = false;
4502
4503	vbvaSetMemoryFlagsHGSMI(uScreenId, 0, false, pFBInfo);
4504
4505	pFBInfo->pVBVAHostFlags = NULL;
4506
4507	if (!fRenderThreadMode && uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
4508	{
4509	/* Force full screen update, because VGA device must take control, do resize, etc. */
4510	Assert(!pThis->i_vbvaLockIsOwner());
4511	pThis->mpDrv->pUpPort->pfnUpdateDisplayAll(pThis->mpDrv->pUpPort, /* fFailOnResize = */ false);
4512	}
4513	}
4514
4515	DECLCALLBACK(void) Display::i_displayVBVAUpdateBegin(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId)
4516	{
4517	LogFlowFunc(("uScreenId %d\n", uScreenId));
4518
4519	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
4520	Display *pThis = pDrv->pDisplay;
4521	DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[uScreenId];
4522
4523	if (ASMAtomicReadU32(&pThis->mu32UpdateVBVAFlags) > 0)
4524	{
4525	vbvaSetMemoryFlagsAllHGSMI(pThis->mfu32SupportedOrders, pThis->mfVideoAccelVRDP, pThis->maFramebuffers,
4526	pThis->mcMonitors);
4527	ASMAtomicDecU32(&pThis->mu32UpdateVBVAFlags);
4528	}
4529	}
4530
4531	DECLCALLBACK(void) Display::i_displayVBVAUpdateProcess(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId,
4532	const PVBVACMDHDR pCmd, size_t cbCmd)
4533	{
4534	LogFlowFunc(("uScreenId %d pCmd %p cbCmd %d, @%d,%d %dx%d\n", uScreenId, pCmd, cbCmd, pCmd->x, pCmd->y, pCmd->w, pCmd->h));
4535
4536	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
4537	Display *pThis = pDrv->pDisplay;
4538	DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[uScreenId];
4539
4540	if (pFBInfo->fDefaultFormat)
4541	{
4542	/* Make sure that framebuffer contains the same image as the guest VRAM. */
4543	if ( uScreenId == VBOX_VIDEO_PRIMARY_SCREEN
4544	&& !pFBInfo->fDisabled)
4545	{
4546	Assert(!pThis->i_vbvaLockIsOwner());
4547	pDrv->pUpPort->pfnUpdateDisplayRect(pDrv->pUpPort, pCmd->x, pCmd->y, pCmd->w, pCmd->h);
4548	}
4549	else if ( !pFBInfo->pSourceBitmap.isNull()
4550	&& !pFBInfo->fDisabled)
4551	{
4552	/* Render VRAM content to the framebuffer. */
4553	BYTE *pAddress = NULL;
4554	ULONG ulWidth = 0;
4555	ULONG ulHeight = 0;
4556	ULONG ulBitsPerPixel = 0;
4557	ULONG ulBytesPerLine = 0;
4558	ULONG ulPixelFormat = 0;
4559
4560	HRESULT hrc = pFBInfo->pSourceBitmap->QueryBitmapInfo(&pAddress,
4561	&ulWidth,
4562	&ulHeight,
4563	&ulBitsPerPixel,
4564	&ulBytesPerLine,
4565	&ulPixelFormat);
4566	if (SUCCEEDED(hrc))
4567	{
4568	uint32_t width = pCmd->w;
4569	uint32_t height = pCmd->h;
4570
4571	const uint8_t *pu8Src = pFBInfo->pu8FramebufferVRAM;
4572	int32_t xSrc = pCmd->x - pFBInfo->xOrigin;
4573	int32_t ySrc = pCmd->y - pFBInfo->yOrigin;
4574	uint32_t u32SrcWidth = pFBInfo->w;
4575	uint32_t u32SrcHeight = pFBInfo->h;
4576	uint32_t u32SrcLineSize = pFBInfo->u32LineSize;
4577	uint32_t u32SrcBitsPerPixel = pFBInfo->u16BitsPerPixel;
4578
4579	uint8_t *pu8Dst = pAddress;
4580	int32_t xDst = xSrc;
4581	int32_t yDst = ySrc;
4582	uint32_t u32DstWidth = u32SrcWidth;
4583	uint32_t u32DstHeight = u32SrcHeight;
4584	uint32_t u32DstLineSize = u32DstWidth * 4;
4585	uint32_t u32DstBitsPerPixel = 32;
4586
4587	Assert(!pThis->i_vbvaLockIsOwner());
4588	pDrv->pUpPort->pfnCopyRect(pDrv->pUpPort,
4589	width, height,
4590	pu8Src,
4591	xSrc, ySrc,
4592	u32SrcWidth, u32SrcHeight,
4593	u32SrcLineSize, u32SrcBitsPerPixel,
4594	pu8Dst,
4595	xDst, yDst,
4596	u32DstWidth, u32DstHeight,
4597	u32DstLineSize, u32DstBitsPerPixel);
4598	}
4599	}
4600	}
4601
4602	VBVACMDHDR hdrSaved = *pCmd;
4603
4604	VBVACMDHDR pHdrUnconst = (VBVACMDHDR )pCmd;
4605
4606	pHdrUnconst->x -= (int16_t)pFBInfo->xOrigin;
4607	pHdrUnconst->y -= (int16_t)pFBInfo->yOrigin;
4608
4609	/* @todo new SendUpdate entry which can get a separate cmd header or coords. */
4610	pThis->mParent->i_consoleVRDPServer()->SendUpdate(uScreenId, pCmd, (uint32_t)cbCmd);
4611
4612	*pHdrUnconst = hdrSaved;
4613	}
4614
4615	DECLCALLBACK(void) Display::i_displayVBVAUpdateEnd(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, int32_t x, int32_t y,
4616	uint32_t cx, uint32_t cy)
4617	{
4618	LogFlowFunc(("uScreenId %d %d,%d %dx%d\n", uScreenId, x, y, cx, cy));
4619
4620	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
4621	Display *pThis = pDrv->pDisplay;
4622	DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[uScreenId];
4623
4624	/* @todo handleFramebufferUpdate (uScreenId,
4625	* x - pThis->maFramebuffers[uScreenId].xOrigin,
4626	* y - pThis->maFramebuffers[uScreenId].yOrigin,
4627	* cx, cy);
4628	*/
4629	pThis->i_handleDisplayUpdate(uScreenId, x - pFBInfo->xOrigin, y - pFBInfo->yOrigin, cx, cy);
4630	}
4631
4632	#ifdef DEBUG_sunlover
4633	static void logVBVAResize(const PVBVAINFOVIEW pView, const PVBVAINFOSCREEN pScreen, const DISPLAYFBINFO *pFBInfo)
4634	{
4635	LogRel(("displayVBVAResize: [%d] %s\n"
4636	" pView->u32ViewIndex %d\n"
4637	" pView->u32ViewOffset 0x%08X\n"
4638	" pView->u32ViewSize 0x%08X\n"
4639	" pView->u32MaxScreenSize 0x%08X\n"
4640	" pScreen->i32OriginX %d\n"
4641	" pScreen->i32OriginY %d\n"
4642	" pScreen->u32StartOffset 0x%08X\n"
4643	" pScreen->u32LineSize 0x%08X\n"
4644	" pScreen->u32Width %d\n"
4645	" pScreen->u32Height %d\n"
4646	" pScreen->u16BitsPerPixel %d\n"
4647	" pScreen->u16Flags 0x%04X\n"
4648	" pFBInfo->u32Offset 0x%08X\n"
4649	" pFBInfo->u32MaxFramebufferSize 0x%08X\n"
4650	" pFBInfo->u32InformationSize 0x%08X\n"
4651	" pFBInfo->fDisabled %d\n"
4652	" xOrigin, yOrigin, w, h: %d,%d %dx%d\n"
4653	" pFBInfo->u16BitsPerPixel %d\n"
4654	" pFBInfo->pu8FramebufferVRAM %p\n"
4655	" pFBInfo->u32LineSize 0x%08X\n"
4656	" pFBInfo->flags 0x%04X\n"
4657	" pFBInfo->pHostEvents %p\n"
4658	" pFBInfo->fDefaultFormat %d\n"
4659	" dirtyRect %d-%d %d-%d\n"
4660	" pFBInfo->fVBVAEnabled %d\n"
4661	" pFBInfo->fVBVAForceResize %d\n"
4662	" pFBInfo->pVBVAHostFlags %p\n"
4663	"",
4664	pScreen->u32ViewIndex,
4665	(pScreen->u16Flags & VBVA_SCREEN_F_DISABLED)? "DISABLED": "ENABLED",
4666	pView->u32ViewIndex,
4667	pView->u32ViewOffset,
4668	pView->u32ViewSize,
4669	pView->u32MaxScreenSize,
4670	pScreen->i32OriginX,
4671	pScreen->i32OriginY,
4672	pScreen->u32StartOffset,
4673	pScreen->u32LineSize,
4674	pScreen->u32Width,
4675	pScreen->u32Height,
4676	pScreen->u16BitsPerPixel,
4677	pScreen->u16Flags,
4678	pFBInfo->u32Offset,
4679	pFBInfo->u32MaxFramebufferSize,
4680	pFBInfo->u32InformationSize,
4681	pFBInfo->fDisabled,
4682	pFBInfo->xOrigin,
4683	pFBInfo->yOrigin,
4684	pFBInfo->w,
4685	pFBInfo->h,
4686	pFBInfo->u16BitsPerPixel,
4687	pFBInfo->pu8FramebufferVRAM,
4688	pFBInfo->u32LineSize,
4689	pFBInfo->flags,
4690	pFBInfo->pHostEvents,
4691	pFBInfo->fDefaultFormat,
4692	pFBInfo->dirtyRect.xLeft,
4693	pFBInfo->dirtyRect.xRight,
4694	pFBInfo->dirtyRect.yTop,
4695	pFBInfo->dirtyRect.yBottom,
4696	pFBInfo->fVBVAEnabled,
4697	pFBInfo->fVBVAForceResize,
4698	pFBInfo->pVBVAHostFlags
4699	));
4700	}
4701	#endif /* DEBUG_sunlover */
4702
4703	DECLCALLBACK(int) Display::i_displayVBVAResize(PPDMIDISPLAYCONNECTOR pInterface, const PVBVAINFOVIEW pView,
4704	const PVBVAINFOSCREEN pScreen, void *pvVRAM)
4705	{
4706	LogRelFlowFunc(("pScreen %p, pvVRAM %p\n", pScreen, pvVRAM));
4707
4708	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
4709	Display *pThis = pDrv->pDisplay;
4710
4711	DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[pScreen->u32ViewIndex];
4712
4713	if (pScreen->u16Flags & VBVA_SCREEN_F_DISABLED)
4714	{
4715	pThis->i_notifyCroglResize(pView, pScreen, pvVRAM);
4716
4717	pFBInfo->fDisabled = true;
4718	pFBInfo->flags = pScreen->u16Flags;
4719
4720	/* Ask the framebuffer to resize using a default format. The framebuffer will be black.
4721	* So if the frontend does not support GuestMonitorChangedEventType_Disabled event,
4722	* the VM window will be black. */
4723	uint32_t u32Width = pFBInfo->w ? pFBInfo->w : 640;
4724	uint32_t u32Height = pFBInfo->h ? pFBInfo->h : 480;
4725	pThis->i_handleDisplayResize(pScreen->u32ViewIndex, 0, (uint8_t *)NULL, 0,
4726	u32Width, u32Height, pScreen->u16Flags);
4727
4728	fireGuestMonitorChangedEvent(pThis->mParent->i_getEventSource(),
4729	GuestMonitorChangedEventType_Disabled,
4730	pScreen->u32ViewIndex,
4731	0, 0, 0, 0);
4732	return VINF_SUCCESS;
4733	}
4734
4735	/* If display was disabled or there is no framebuffer, a resize will be required,
4736	* because the framebuffer was/will be changed.
4737	*/
4738	bool fResize = pFBInfo->fDisabled \|\| pFBInfo->pFramebuffer.isNull();
4739
4740	if (pFBInfo->fVBVAForceResize)
4741	{
4742	/* VBVA was just enabled. Do the resize. */
4743	fResize = true;
4744	pFBInfo->fVBVAForceResize = false;
4745	}
4746
4747	/* Check if this is a real resize or a notification about the screen origin.
4748	* The guest uses this VBVAResize call for both.
4749	*/
4750	fResize = fResize
4751	\|\| pFBInfo->u16BitsPerPixel != pScreen->u16BitsPerPixel
4752	\|\| pFBInfo->pu8FramebufferVRAM != (uint8_t *)pvVRAM + pScreen->u32StartOffset
4753	\|\| pFBInfo->u32LineSize != pScreen->u32LineSize
4754	\|\| pFBInfo->w != pScreen->u32Width
4755	\|\| pFBInfo->h != pScreen->u32Height;
4756
4757	bool fNewOrigin = pFBInfo->xOrigin != pScreen->i32OriginX
4758	\|\| pFBInfo->yOrigin != pScreen->i32OriginY;
4759
4760	if (fNewOrigin \|\| fResize)
4761	pThis->i_notifyCroglResize(pView, pScreen, pvVRAM);
4762
4763	if (pFBInfo->fDisabled)
4764	{
4765	pFBInfo->fDisabled = false;
4766	fireGuestMonitorChangedEvent(pThis->mParent->i_getEventSource(),
4767	GuestMonitorChangedEventType_Enabled,
4768	pScreen->u32ViewIndex,
4769	pScreen->i32OriginX, pScreen->i32OriginY,
4770	pScreen->u32Width, pScreen->u32Height);
4771	/* Continue to update pFBInfo. */
4772	}
4773
4774	pFBInfo->u32Offset = pView->u32ViewOffset; /* Not used in HGSMI. */
4775	pFBInfo->u32MaxFramebufferSize = pView->u32MaxScreenSize; /* Not used in HGSMI. */
4776	pFBInfo->u32InformationSize = 0; /* Not used in HGSMI. */
4777
4778	pFBInfo->xOrigin = pScreen->i32OriginX;
4779	pFBInfo->yOrigin = pScreen->i32OriginY;
4780
4781	pFBInfo->w = pScreen->u32Width;
4782	pFBInfo->h = pScreen->u32Height;
4783
4784	pFBInfo->u16BitsPerPixel = pScreen->u16BitsPerPixel;
4785	pFBInfo->pu8FramebufferVRAM = (uint8_t *)pvVRAM + pScreen->u32StartOffset;
4786	pFBInfo->u32LineSize = pScreen->u32LineSize;
4787
4788	pFBInfo->flags = pScreen->u16Flags;
4789
4790	if (fNewOrigin)
4791	{
4792	fireGuestMonitorChangedEvent(pThis->mParent->i_getEventSource(),
4793	GuestMonitorChangedEventType_NewOrigin,
4794	pScreen->u32ViewIndex,
4795	pScreen->i32OriginX, pScreen->i32OriginY,
4796	0, 0);
4797	}
4798
4799	if (!fResize)
4800	{
4801	/* No parameters of the framebuffer have actually changed. */
4802	if (fNewOrigin)
4803	{
4804	/* VRDP server still need this notification. */
4805	LogRelFlowFunc(("Calling VRDP\n"));
4806	pThis->mParent->i_consoleVRDPServer()->SendResize();
4807	}
4808	return VINF_SUCCESS;
4809	}
4810
4811	/* Do a regular resize. */
4812	return pThis->i_handleDisplayResize(pScreen->u32ViewIndex, pScreen->u16BitsPerPixel,
4813	(uint8_t *)pvVRAM + pScreen->u32StartOffset,
4814	pScreen->u32LineSize, pScreen->u32Width, pScreen->u32Height, pScreen->u16Flags);
4815	}
4816
4817	DECLCALLBACK(int) Display::i_displayVBVAMousePointerShape(PPDMIDISPLAYCONNECTOR pInterface, bool fVisible, bool fAlpha,
4818	uint32_t xHot, uint32_t yHot,
4819	uint32_t cx, uint32_t cy,
4820	const void *pvShape)
4821	{
4822	LogFlowFunc(("\n"));
4823
4824	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
4825	Display *pThis = pDrv->pDisplay;
4826
4827	size_t cbShapeSize = 0;
4828
4829	if (pvShape)
4830	{
4831	cbShapeSize = (cx + 7) / 8 * cy; /* size of the AND mask */
4832	cbShapeSize = ((cbShapeSize + 3) & ~3) + cx * 4 * cy; /* + gap + size of the XOR mask */
4833	}
4834	com::SafeArray<BYTE> shapeData(cbShapeSize);
4835
4836	if (pvShape)
4837	::memcpy(shapeData.raw(), pvShape, cbShapeSize);
4838
4839	/* Tell the console about it */
4840	pDrv->pDisplay->mParent->i_onMousePointerShapeChange(fVisible, fAlpha,
4841	xHot, yHot, cx, cy, ComSafeArrayAsInParam(shapeData));
4842
4843	return VINF_SUCCESS;
4844	}
4845	#endif /* VBOX_WITH_HGSMI */
4846
4847	/**
4848	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
4849	*/
4850	DECLCALLBACK(void ) Display::i_drvQueryInterface(PPDMIBASE pInterface, const char pszIID)
4851	{
4852	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
4853	PDRVMAINDISPLAY pDrv = PDMINS_2_DATA(pDrvIns, PDRVMAINDISPLAY);
4854	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
4855	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIDISPLAYCONNECTOR, &pDrv->IConnector);
4856	return NULL;
4857	}
4858
4859
4860	/**
4861	* Destruct a display driver instance.
4862	*
4863	* @returns VBox status.
4864	* @param pDrvIns The driver instance data.
4865	*/
4866	DECLCALLBACK(void) Display::i_drvDestruct(PPDMDRVINS pDrvIns)
4867	{
4868	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
4869	PDRVMAINDISPLAY pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINDISPLAY);
4870	LogRelFlowFunc(("iInstance=%d\n", pDrvIns->iInstance));
4871
4872	if (pThis->pDisplay)
4873	Assert(!pThis->pDisplay->i_vbvaLockIsOwner());
4874
4875	pThis->pUpPort->pfnSetRenderVRAM(pThis->pUpPort, false);
4876
4877	pThis->IConnector.pu8Data = NULL;
4878	pThis->IConnector.cbScanline = 0;
4879	pThis->IConnector.cBits = 32;
4880	pThis->IConnector.cx = 0;
4881	pThis->IConnector.cy = 0;
4882
4883	if (pThis->pDisplay)
4884	{
4885	AutoWriteLock displayLock(pThis->pDisplay COMMA_LOCKVAL_SRC_POS);
4886	#ifdef VBOX_WITH_VPX
4887	pThis->pDisplay->i_VideoCaptureStop();
4888	#endif
4889	#ifdef VBOX_WITH_CRHGSMI
4890	pThis->pDisplay->i_destructCrHgsmiData();
4891	#endif
4892	pThis->pDisplay->mpDrv = NULL;
4893	pThis->pDisplay->mpVMMDev = NULL;
4894	}
4895	}
4896
4897
4898	/**
4899	* Construct a display driver instance.
4900	*
4901	* @copydoc FNPDMDRVCONSTRUCT
4902	*/
4903	DECLCALLBACK(int) Display::i_drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
4904	{
4905	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
4906	PDRVMAINDISPLAY pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINDISPLAY);
4907	LogRelFlowFunc(("iInstance=%d\n", pDrvIns->iInstance));
4908
4909	/*
4910	* Validate configuration.
4911	*/
4912	if (!CFGMR3AreValuesValid(pCfg, "Object\0"))
4913	return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
4914	AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
4915	("Configuration error: Not possible to attach anything to this driver!\n"),
4916	VERR_PDM_DRVINS_NO_ATTACH);
4917
4918	/*
4919	* Init Interfaces.
4920	*/
4921	pDrvIns->IBase.pfnQueryInterface = Display::i_drvQueryInterface;
4922
4923	pThis->IConnector.pfnResize = Display::i_displayResizeCallback;
4924	pThis->IConnector.pfnUpdateRect = Display::i_displayUpdateCallback;
4925	pThis->IConnector.pfnRefresh = Display::i_displayRefreshCallback;
4926	pThis->IConnector.pfnReset = Display::i_displayResetCallback;
4927	pThis->IConnector.pfnLFBModeChange = Display::i_displayLFBModeChangeCallback;
4928	pThis->IConnector.pfnProcessAdapterData = Display::i_displayProcessAdapterDataCallback;
4929	pThis->IConnector.pfnProcessDisplayData = Display::i_displayProcessDisplayDataCallback;
4930	#ifdef VBOX_WITH_VIDEOHWACCEL
4931	pThis->IConnector.pfnVHWACommandProcess = Display::i_displayVHWACommandProcess;
4932	#endif
4933	#ifdef VBOX_WITH_CRHGSMI
4934	pThis->IConnector.pfnCrHgsmiCommandProcess = Display::i_displayCrHgsmiCommandProcess;
4935	pThis->IConnector.pfnCrHgsmiControlProcess = Display::i_displayCrHgsmiControlProcess;
4936	#endif
4937	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
4938	pThis->IConnector.pfnCrHgcmCtlSubmit = Display::i_displayCrHgcmCtlSubmit;
4939	#endif
4940	#ifdef VBOX_WITH_HGSMI
4941	pThis->IConnector.pfnVBVAEnable = Display::i_displayVBVAEnable;
4942	pThis->IConnector.pfnVBVADisable = Display::i_displayVBVADisable;
4943	pThis->IConnector.pfnVBVAUpdateBegin = Display::i_displayVBVAUpdateBegin;
4944	pThis->IConnector.pfnVBVAUpdateProcess = Display::i_displayVBVAUpdateProcess;
4945	pThis->IConnector.pfnVBVAUpdateEnd = Display::i_displayVBVAUpdateEnd;
4946	pThis->IConnector.pfnVBVAResize = Display::i_displayVBVAResize;
4947	pThis->IConnector.pfnVBVAMousePointerShape = Display::i_displayVBVAMousePointerShape;
4948	#endif
4949
4950	/*
4951	* Get the IDisplayPort interface of the above driver/device.
4952	*/
4953	pThis->pUpPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIDISPLAYPORT);
4954	if (!pThis->pUpPort)
4955	{
4956	AssertMsgFailed(("Configuration error: No display port interface above!\n"));
4957	return VERR_PDM_MISSING_INTERFACE_ABOVE;
4958	}
4959	#if defined(VBOX_WITH_VIDEOHWACCEL) \|\| defined(VBOX_WITH_CRHGSMI)
4960	pThis->pVBVACallbacks = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIDISPLAYVBVACALLBACKS);
4961	if (!pThis->pVBVACallbacks)
4962	{
4963	AssertMsgFailed(("Configuration error: No VBVA callback interface above!\n"));
4964	return VERR_PDM_MISSING_INTERFACE_ABOVE;
4965	}
4966	#endif
4967	/*
4968	* Get the Display object pointer and update the mpDrv member.
4969	*/
4970	void *pv;
4971	int rc = CFGMR3QueryPtr(pCfg, "Object", &pv);
4972	if (RT_FAILURE(rc))
4973	{
4974	AssertMsgFailed(("Configuration error: No/bad \"Object\" value! rc=%Rrc\n", rc));
4975	return rc;
4976	}
4977	Display pDisplay = (Display )pv; /** @todo Check this cast! */
4978	pThis->pDisplay = pDisplay;
4979	pThis->pDisplay->mpDrv = pThis;
4980
4981	/* Disable VRAM to a buffer copy initially. */
4982	Assert(!pDisplay->i_vbvaLockIsOwner());
4983	pThis->pUpPort->pfnSetRenderVRAM(pThis->pUpPort, false);
4984	pThis->IConnector.cBits = 32; /* DevVGA does nothing otherwise. */
4985
4986	/*
4987	* Start periodic screen refreshes
4988	*/
4989	Assert(!pDisplay->i_vbvaLockIsOwner());
4990	pThis->pUpPort->pfnSetRefreshRate(pThis->pUpPort, 20);
4991
4992	#ifdef VBOX_WITH_CRHGSMI
4993	pDisplay->i_setupCrHgsmiData();
4994	#endif
4995
4996	#ifdef VBOX_WITH_VPX
4997	ComPtr<IMachine> pMachine = pDisplay->mParent->i_machine();
4998	BOOL fEnabled = false;
4999	HRESULT hrc = pMachine->COMGETTER(VideoCaptureEnabled)(&fEnabled);
5000	AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
5001	if (fEnabled)
5002	{
5003	rc = pDisplay->i_VideoCaptureStart();
5004	fireVideoCaptureChangedEvent(pDisplay->mParent->i_getEventSource());
5005	}
5006	#endif
5007
5008	return rc;
5009	}
5010
5011
5012	/**
5013	* Display driver registration record.
5014	*/
5015	const PDMDRVREG Display::DrvReg =
5016	{
5017	/* u32Version */
5018	PDM_DRVREG_VERSION,
5019	/* szName */
5020	"MainDisplay",
5021	/* szRCMod */
5022	"",
5023	/* szR0Mod */
5024	"",
5025	/* pszDescription */
5026	"Main display driver (Main as in the API).",
5027	/* fFlags */
5028	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
5029	/* fClass. */
5030	PDM_DRVREG_CLASS_DISPLAY,
5031	/* cMaxInstances */
5032	~0U,
5033	/* cbInstance */
5034	sizeof(DRVMAINDISPLAY),
5035	/* pfnConstruct */
5036	Display::i_drvConstruct,
5037	/* pfnDestruct */
5038	Display::i_drvDestruct,
5039	/* pfnRelocate */
5040	NULL,
5041	/* pfnIOCtl */
5042	NULL,
5043	/* pfnPowerOn */
5044	NULL,
5045	/* pfnReset */
5046	NULL,
5047	/* pfnSuspend */
5048	NULL,
5049	/* pfnResume */
5050	NULL,
5051	/* pfnAttach */
5052	NULL,
5053	/* pfnDetach */
5054	NULL,
5055	/* pfnPowerOff */
5056	NULL,
5057	/* pfnSoftReset */
5058	NULL,
5059	/* u32EndVersion */
5060	PDM_DRVREG_VERSION
5061	};
5062
5063	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

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

Download in other formats: