DisplayImpl.cpp@ 37187

Last change on this file since 37187 was 37175, checked in by vboxsync, 14 years ago
Devices and Main/seamless: allow for the possibility that nothing is visible on the guest screen
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 131.7 KB

Line
1	/* $Id: DisplayImpl.cpp 37175 2011-05-21 20:51:24Z vboxsync $ */
2	/** @file
3	* VirtualBox COM class implementation
4	*/
5
6	/*
7	* Copyright (C) 2006-2010 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/cpp/utils.h>
34
35	#include <VBox/vmm/pdmdrv.h>
36	#ifdef DEBUG /* for VM_ASSERT_EMT(). */
37	# include <VBox/vmm/vm.h>
38	#endif
39
40	#ifdef VBOX_WITH_VIDEOHWACCEL
41	# include <VBox/VBoxVideo.h>
42	#endif
43
44	#if defined(VBOX_WITH_CROGL) \|\| defined(VBOX_WITH_CRHGSMI)
45	# include <VBox/HostServices/VBoxCrOpenGLSvc.h>
46	#endif
47
48	#include <VBox/com/array.h>
49
50	/**
51	* Display driver instance data.
52	*
53	* @implements PDMIDISPLAYCONNECTOR
54	*/
55	typedef struct DRVMAINDISPLAY
56	{
57	/** Pointer to the display object. */
58	Display *pDisplay;
59	/** Pointer to the driver instance structure. */
60	PPDMDRVINS pDrvIns;
61	/** Pointer to the keyboard port interface of the driver/device above us. */
62	PPDMIDISPLAYPORT pUpPort;
63	/** Our display connector interface. */
64	PDMIDISPLAYCONNECTOR IConnector;
65	#if defined(VBOX_WITH_VIDEOHWACCEL) \|\| defined(VBOX_WITH_CRHGSMI)
66	/** VBVA callbacks */
67	PPDMIDISPLAYVBVACALLBACKS pVBVACallbacks;
68	#endif
69	} DRVMAINDISPLAY, *PDRVMAINDISPLAY;
70
71	/** Converts PDMIDISPLAYCONNECTOR pointer to a DRVMAINDISPLAY pointer. */
72	#define PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface) RT_FROM_MEMBER(pInterface, DRVMAINDISPLAY, IConnector)
73
74	#ifdef DEBUG_sunlover
75	static STAMPROFILE StatDisplayRefresh;
76	static int stam = 0;
77	#endif /* DEBUG_sunlover */
78
79	// constructor / destructor
80	/////////////////////////////////////////////////////////////////////////////
81
82	Display::Display()
83	: mParent(NULL)
84	{
85	}
86
87	Display::~Display()
88	{
89	}
90
91
92	HRESULT Display::FinalConstruct()
93	{
94	mpVbvaMemory = NULL;
95	mfVideoAccelEnabled = false;
96	mfVideoAccelVRDP = false;
97	mfu32SupportedOrders = 0;
98	mcVideoAccelVRDPRefs = 0;
99
100	mpPendingVbvaMemory = NULL;
101	mfPendingVideoAccelEnable = false;
102
103	mfMachineRunning = false;
104
105	mpu8VbvaPartial = NULL;
106	mcbVbvaPartial = 0;
107
108	mpDrv = NULL;
109	mpVMMDev = NULL;
110	mfVMMDevInited = false;
111
112	mLastAddress = NULL;
113	mLastBytesPerLine = 0;
114	mLastBitsPerPixel = 0,
115	mLastWidth = 0;
116	mLastHeight = 0;
117
118	int rc = RTCritSectInit(&mVBVALock);
119	AssertRC(rc);
120	mfu32PendingVideoAccelDisable = false;
121
122	#ifdef VBOX_WITH_HGSMI
123	mu32UpdateVBVAFlags = 0;
124	#endif
125
126	return BaseFinalConstruct();
127	}
128
129	void Display::FinalRelease()
130	{
131	uninit();
132
133	if (RTCritSectIsInitialized (&mVBVALock))
134	{
135	RTCritSectDelete (&mVBVALock);
136	memset (&mVBVALock, 0, sizeof (mVBVALock));
137	}
138	BaseFinalRelease();
139	}
140
141	// public initializer/uninitializer for internal purposes only
142	/////////////////////////////////////////////////////////////////////////////
143
144	#define kMaxSizeThumbnail 64
145
146	/**
147	* Save thumbnail and screenshot of the guest screen.
148	*/
149	static int displayMakeThumbnail(uint8_t *pu8Data, uint32_t cx, uint32_t cy,
150	uint8_t *ppu8Thumbnail, uint32_t pcbThumbnail, uint32_t pcxThumbnail, uint32_t pcyThumbnail)
151	{
152	int rc = VINF_SUCCESS;
153
154	uint8_t *pu8Thumbnail = NULL;
155	uint32_t cbThumbnail = 0;
156	uint32_t cxThumbnail = 0;
157	uint32_t cyThumbnail = 0;
158
159	if (cx > cy)
160	{
161	cxThumbnail = kMaxSizeThumbnail;
162	cyThumbnail = (kMaxSizeThumbnail * cy) / cx;
163	}
164	else
165	{
166	cyThumbnail = kMaxSizeThumbnail;
167	cxThumbnail = (kMaxSizeThumbnail * cx) / cy;
168	}
169
170	LogFlowFunc(("%dx%d -> %dx%d\n", cx, cy, cxThumbnail, cyThumbnail));
171
172	cbThumbnail = cxThumbnail * 4 * cyThumbnail;
173	pu8Thumbnail = (uint8_t *)RTMemAlloc(cbThumbnail);
174
175	if (pu8Thumbnail)
176	{
177	uint8_t *dst = pu8Thumbnail;
178	uint8_t *src = pu8Data;
179	int dstW = cxThumbnail;
180	int dstH = cyThumbnail;
181	int srcW = cx;
182	int srcH = cy;
183	int iDeltaLine = cx * 4;
184
185	BitmapScale32 (dst,
186	dstW, dstH,
187	src,
188	iDeltaLine,
189	srcW, srcH);
190
191	*ppu8Thumbnail = pu8Thumbnail;
192	*pcbThumbnail = cbThumbnail;
193	*pcxThumbnail = cxThumbnail;
194	*pcyThumbnail = cyThumbnail;
195	}
196	else
197	{
198	rc = VERR_NO_MEMORY;
199	}
200
201	return rc;
202	}
203
204	DECLCALLBACK(void)
205	Display::displaySSMSaveScreenshot(PSSMHANDLE pSSM, void *pvUser)
206	{
207	Display that = static_cast<Display>(pvUser);
208
209	/* 32bpp small RGB image. */
210	uint8_t *pu8Thumbnail = NULL;
211	uint32_t cbThumbnail = 0;
212	uint32_t cxThumbnail = 0;
213	uint32_t cyThumbnail = 0;
214
215	/* PNG screenshot. */
216	uint8_t *pu8PNG = NULL;
217	uint32_t cbPNG = 0;
218	uint32_t cxPNG = 0;
219	uint32_t cyPNG = 0;
220
221	Console::SafeVMPtr pVM (that->mParent);
222	if (SUCCEEDED(pVM.rc()))
223	{
224	/* Query RGB bitmap. */
225	uint8_t *pu8Data = NULL;
226	size_t cbData = 0;
227	uint32_t cx = 0;
228	uint32_t cy = 0;
229
230	/* SSM code is executed on EMT(0), therefore no need to use VMR3ReqCallWait. */
231	int rc = Display::displayTakeScreenshotEMT(that, VBOX_VIDEO_PRIMARY_SCREEN, &pu8Data, &cbData, &cx, &cy);
232
233	/*
234	* It is possible that success is returned but everything is 0 or NULL.
235	* (no display attached if a VM is running with VBoxHeadless on OSE for example)
236	*/
237	if (RT_SUCCESS(rc) && pu8Data)
238	{
239	Assert(cx && cy);
240
241	/* Prepare a small thumbnail and a PNG screenshot. */
242	displayMakeThumbnail(pu8Data, cx, cy, &pu8Thumbnail, &cbThumbnail, &cxThumbnail, &cyThumbnail);
243	DisplayMakePNG(pu8Data, cx, cy, &pu8PNG, &cbPNG, &cxPNG, &cyPNG, 1);
244
245	/* This can be called from any thread. */
246	that->mpDrv->pUpPort->pfnFreeScreenshot (that->mpDrv->pUpPort, pu8Data);
247	}
248	}
249	else
250	{
251	LogFunc(("Failed to get VM pointer 0x%x\n", pVM.rc()));
252	}
253
254	/* Regardless of rc, save what is available:
255	* Data format:
256	* uint32_t cBlocks;
257	* [blocks]
258	*
259	* Each block is:
260	* uint32_t cbBlock; if 0 - no 'block data'.
261	* uint32_t typeOfBlock; 0 - 32bpp RGB bitmap, 1 - PNG, ignored if 'cbBlock' is 0.
262	* [block data]
263	*
264	* Block data for bitmap and PNG:
265	* uint32_t cx;
266	* uint32_t cy;
267	* [image data]
268	*/
269	SSMR3PutU32(pSSM, 2); /* Write thumbnail and PNG screenshot. */
270
271	/* First block. */
272	SSMR3PutU32(pSSM, cbThumbnail + 2 * sizeof (uint32_t));
273	SSMR3PutU32(pSSM, 0); /* Block type: thumbnail. */
274
275	if (cbThumbnail)
276	{
277	SSMR3PutU32(pSSM, cxThumbnail);
278	SSMR3PutU32(pSSM, cyThumbnail);
279	SSMR3PutMem(pSSM, pu8Thumbnail, cbThumbnail);
280	}
281
282	/* Second block. */
283	SSMR3PutU32(pSSM, cbPNG + 2 * sizeof (uint32_t));
284	SSMR3PutU32(pSSM, 1); /* Block type: png. */
285
286	if (cbPNG)
287	{
288	SSMR3PutU32(pSSM, cxPNG);
289	SSMR3PutU32(pSSM, cyPNG);
290	SSMR3PutMem(pSSM, pu8PNG, cbPNG);
291	}
292
293	RTMemFree(pu8PNG);
294	RTMemFree(pu8Thumbnail);
295	}
296
297	DECLCALLBACK(int)
298	Display::displaySSMLoadScreenshot(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass)
299	{
300	Display that = static_cast<Display>(pvUser);
301
302	if (uVersion != sSSMDisplayScreenshotVer)
303	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
304	Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
305
306	/* Skip data. */
307	uint32_t cBlocks;
308	int rc = SSMR3GetU32(pSSM, &cBlocks);
309	AssertRCReturn(rc, rc);
310
311	for (uint32_t i = 0; i < cBlocks; i++)
312	{
313	uint32_t cbBlock;
314	rc = SSMR3GetU32(pSSM, &cbBlock);
315	AssertRCBreak(rc);
316
317	uint32_t typeOfBlock;
318	rc = SSMR3GetU32(pSSM, &typeOfBlock);
319	AssertRCBreak(rc);
320
321	LogFlowFunc(("[%d] type %d, size %d bytes\n", i, typeOfBlock, cbBlock));
322
323	/* Note: displaySSMSaveScreenshot writes size of a block = 8 and
324	* do not write any data if the image size was 0.
325	* @todo Fix and increase saved state version.
326	*/
327	if (cbBlock > 2 * sizeof (uint32_t))
328	{
329	rc = SSMR3Skip(pSSM, cbBlock);
330	AssertRCBreak(rc);
331	}
332	}
333
334	return rc;
335	}
336
337	/**
338	* Save/Load some important guest state
339	*/
340	DECLCALLBACK(void)
341	Display::displaySSMSave(PSSMHANDLE pSSM, void *pvUser)
342	{
343	Display that = static_cast<Display>(pvUser);
344
345	SSMR3PutU32(pSSM, that->mcMonitors);
346	for (unsigned i = 0; i < that->mcMonitors; i++)
347	{
348	SSMR3PutU32(pSSM, that->maFramebuffers[i].u32Offset);
349	SSMR3PutU32(pSSM, that->maFramebuffers[i].u32MaxFramebufferSize);
350	SSMR3PutU32(pSSM, that->maFramebuffers[i].u32InformationSize);
351	SSMR3PutU32(pSSM, that->maFramebuffers[i].w);
352	SSMR3PutU32(pSSM, that->maFramebuffers[i].h);
353	SSMR3PutS32(pSSM, that->maFramebuffers[i].xOrigin);
354	SSMR3PutS32(pSSM, that->maFramebuffers[i].yOrigin);
355	SSMR3PutU32(pSSM, that->maFramebuffers[i].flags);
356	}
357	}
358
359	DECLCALLBACK(int)
360	Display::displaySSMLoad(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass)
361	{
362	Display that = static_cast<Display>(pvUser);
363
364	if (!( uVersion == sSSMDisplayVer
365	\|\| uVersion == sSSMDisplayVer2
366	\|\| uVersion == sSSMDisplayVer3))
367	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
368	Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
369
370	uint32_t cMonitors;
371	int rc = SSMR3GetU32(pSSM, &cMonitors);
372	if (cMonitors != that->mcMonitors)
373	return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Number of monitors changed (%d->%d)!"), cMonitors, that->mcMonitors);
374
375	for (uint32_t i = 0; i < cMonitors; i++)
376	{
377	SSMR3GetU32(pSSM, &that->maFramebuffers[i].u32Offset);
378	SSMR3GetU32(pSSM, &that->maFramebuffers[i].u32MaxFramebufferSize);
379	SSMR3GetU32(pSSM, &that->maFramebuffers[i].u32InformationSize);
380	if ( uVersion == sSSMDisplayVer2
381	\|\| uVersion == sSSMDisplayVer3)
382	{
383	uint32_t w;
384	uint32_t h;
385	SSMR3GetU32(pSSM, &w);
386	SSMR3GetU32(pSSM, &h);
387	that->maFramebuffers[i].w = w;
388	that->maFramebuffers[i].h = h;
389	}
390	if (uVersion == sSSMDisplayVer3)
391	{
392	int32_t xOrigin;
393	int32_t yOrigin;
394	uint32_t flags;
395	SSMR3GetS32(pSSM, &xOrigin);
396	SSMR3GetS32(pSSM, &yOrigin);
397	SSMR3GetU32(pSSM, &flags);
398	that->maFramebuffers[i].xOrigin = xOrigin;
399	that->maFramebuffers[i].yOrigin = yOrigin;
400	that->maFramebuffers[i].flags = (uint16_t)flags;
401	}
402	}
403
404	return VINF_SUCCESS;
405	}
406
407	/**
408	* Initializes the display object.
409	*
410	* @returns COM result indicator
411	* @param parent handle of our parent object
412	* @param qemuConsoleData address of common console data structure
413	*/
414	HRESULT Display::init (Console *aParent)
415	{
416	LogFlowThisFunc(("aParent=%p\n", aParent));
417
418	ComAssertRet(aParent, E_INVALIDARG);
419
420	/* Enclose the state transition NotReady->InInit->Ready */
421	AutoInitSpan autoInitSpan(this);
422	AssertReturn(autoInitSpan.isOk(), E_FAIL);
423
424	unconst(mParent) = aParent;
425
426	// by default, we have an internal framebuffer which is
427	// NULL, i.e. a black hole for no display output
428	mFramebufferOpened = false;
429
430	ULONG ul;
431	mParent->machine()->COMGETTER(MonitorCount)(&ul);
432	mcMonitors = ul;
433
434	for (ul = 0; ul < mcMonitors; ul++)
435	{
436	maFramebuffers[ul].u32Offset = 0;
437	maFramebuffers[ul].u32MaxFramebufferSize = 0;
438	maFramebuffers[ul].u32InformationSize = 0;
439
440	maFramebuffers[ul].pFramebuffer = NULL;
441	maFramebuffers[ul].fDisabled = false;
442
443	maFramebuffers[ul].xOrigin = 0;
444	maFramebuffers[ul].yOrigin = 0;
445
446	maFramebuffers[ul].w = 0;
447	maFramebuffers[ul].h = 0;
448
449	maFramebuffers[ul].flags = 0;
450
451	maFramebuffers[ul].u16BitsPerPixel = 0;
452	maFramebuffers[ul].pu8FramebufferVRAM = NULL;
453	maFramebuffers[ul].u32LineSize = 0;
454
455	maFramebuffers[ul].pHostEvents = NULL;
456
457	maFramebuffers[ul].u32ResizeStatus = ResizeStatus_Void;
458
459	maFramebuffers[ul].fDefaultFormat = false;
460
461	memset (&maFramebuffers[ul].dirtyRect, 0 , sizeof (maFramebuffers[ul].dirtyRect));
462	memset (&maFramebuffers[ul].pendingResize, 0 , sizeof (maFramebuffers[ul].pendingResize));
463	#ifdef VBOX_WITH_HGSMI
464	maFramebuffers[ul].fVBVAEnabled = false;
465	maFramebuffers[ul].cVBVASkipUpdate = 0;
466	memset (&maFramebuffers[ul].vbvaSkippedRect, 0, sizeof (maFramebuffers[ul].vbvaSkippedRect));
467	maFramebuffers[ul].pVBVAHostFlags = NULL;
468	#endif /* VBOX_WITH_HGSMI */
469	}
470
471	{
472	// register listener for state change events
473	ComPtr<IEventSource> es;
474	mParent->COMGETTER(EventSource)(es.asOutParam());
475	com::SafeArray <VBoxEventType_T> eventTypes;
476	eventTypes.push_back(VBoxEventType_OnStateChanged);
477	es->RegisterListener(this, ComSafeArrayAsInParam(eventTypes), true);
478	}
479
480	/* Confirm a successful initialization */
481	autoInitSpan.setSucceeded();
482
483	return S_OK;
484	}
485
486	/**
487	* Uninitializes the instance and sets the ready flag to FALSE.
488	* Called either from FinalRelease() or by the parent when it gets destroyed.
489	*/
490	void Display::uninit()
491	{
492	LogFlowThisFunc(("\n"));
493
494	/* Enclose the state transition Ready->InUninit->NotReady */
495	AutoUninitSpan autoUninitSpan(this);
496	if (autoUninitSpan.uninitDone())
497	return;
498
499	ULONG ul;
500	for (ul = 0; ul < mcMonitors; ul++)
501	maFramebuffers[ul].pFramebuffer = NULL;
502
503	if (mParent)
504	{
505	ComPtr<IEventSource> es;
506	mParent->COMGETTER(EventSource)(es.asOutParam());
507	es->UnregisterListener(this);
508	}
509
510	unconst(mParent) = NULL;
511
512	if (mpDrv)
513	mpDrv->pDisplay = NULL;
514
515	mpDrv = NULL;
516	mpVMMDev = NULL;
517	mfVMMDevInited = true;
518	}
519
520	/**
521	* Register the SSM methods. Called by the power up thread to be able to
522	* pass pVM
523	*/
524	int Display::registerSSM(PVM pVM)
525	{
526	/* Version 2 adds width and height of the framebuffer; version 3 adds
527	* the framebuffer offset in the virtual desktop and the framebuffer flags.
528	*/
529	int rc = SSMR3RegisterExternal(pVM, "DisplayData", 0, sSSMDisplayVer3,
530	mcMonitors * sizeof(uint32_t) * 8 + sizeof(uint32_t),
531	NULL, NULL, NULL,
532	NULL, displaySSMSave, NULL,
533	NULL, displaySSMLoad, NULL, this);
534	AssertRCReturn(rc, rc);
535
536	/*
537	* Register loaders for old saved states where iInstance was
538	* 3 * sizeof(uint32_t *) due to a code mistake.
539	*/
540	rc = SSMR3RegisterExternal(pVM, "DisplayData", 12 /uInstance/, sSSMDisplayVer, 0 /cbGuess/,
541	NULL, NULL, NULL,
542	NULL, NULL, NULL,
543	NULL, displaySSMLoad, NULL, this);
544	AssertRCReturn(rc, rc);
545
546	rc = SSMR3RegisterExternal(pVM, "DisplayData", 24 /uInstance/, sSSMDisplayVer, 0 /cbGuess/,
547	NULL, NULL, NULL,
548	NULL, NULL, NULL,
549	NULL, displaySSMLoad, NULL, this);
550	AssertRCReturn(rc, rc);
551
552	/* uInstance is an arbitrary value greater than 1024. Such a value will ensure a quick seek in saved state file. */
553	rc = SSMR3RegisterExternal(pVM, "DisplayScreenshot", 1100 /uInstance/, sSSMDisplayScreenshotVer, 0 /cbGuess/,
554	NULL, NULL, NULL,
555	NULL, displaySSMSaveScreenshot, NULL,
556	NULL, displaySSMLoadScreenshot, NULL, this);
557
558	AssertRCReturn(rc, rc);
559
560	return VINF_SUCCESS;
561	}
562
563	// IEventListener method
564	STDMETHODIMP Display::HandleEvent(IEvent * aEvent)
565	{
566	VBoxEventType_T aType = VBoxEventType_Invalid;
567
568	aEvent->COMGETTER(Type)(&aType);
569	switch (aType)
570	{
571	case VBoxEventType_OnStateChanged:
572	{
573	ComPtr<IStateChangedEvent> scev = aEvent;
574	Assert(scev);
575	MachineState_T machineState;
576	scev->COMGETTER(State)(&machineState);
577	if ( machineState == MachineState_Running
578	\|\| machineState == MachineState_Teleporting
579	\|\| machineState == MachineState_LiveSnapshotting
580	)
581	{
582	LogFlowFunc(("Machine is running.\n"));
583
584	mfMachineRunning = true;
585	}
586	else
587	mfMachineRunning = false;
588	break;
589	}
590	default:
591	AssertFailed();
592	}
593
594	return S_OK;
595	}
596
597	// public methods only for internal purposes
598	/////////////////////////////////////////////////////////////////////////////
599
600	/**
601	* @thread EMT
602	*/
603	static int callFramebufferResize (IFramebuffer *pFramebuffer, unsigned uScreenId,
604	ULONG pixelFormat, void *pvVRAM,
605	uint32_t bpp, uint32_t cbLine,
606	int w, int h)
607	{
608	Assert (pFramebuffer);
609
610	/* Call the framebuffer to try and set required pixelFormat. */
611	BOOL finished = TRUE;
612
613	pFramebuffer->RequestResize (uScreenId, pixelFormat, (BYTE *) pvVRAM,
614	bpp, cbLine, w, h, &finished);
615
616	if (!finished)
617	{
618	LogFlowFunc (("External framebuffer wants us to wait!\n"));
619	return VINF_VGA_RESIZE_IN_PROGRESS;
620	}
621
622	return VINF_SUCCESS;
623	}
624
625	/**
626	* Handles display resize event.
627	* Disables access to VGA device;
628	* calls the framebuffer RequestResize method;
629	* if framebuffer resizes synchronously,
630	* updates the display connector data and enables access to the VGA device.
631	*
632	* @param w New display width
633	* @param h New display height
634	*
635	* @thread EMT
636	*/
637	int Display::handleDisplayResize (unsigned uScreenId, uint32_t bpp, void *pvVRAM,
638	uint32_t cbLine, int w, int h, uint16_t flags)
639	{
640	LogRel (("Display::handleDisplayResize(): uScreenId = %d, pvVRAM=%p "
641	"w=%d h=%d bpp=%d cbLine=0x%X, flags=0x%X\n",
642	uScreenId, pvVRAM, w, h, bpp, cbLine, flags));
643
644	/* If there is no framebuffer, this call is not interesting. */
645	if ( uScreenId >= mcMonitors
646	\|\| maFramebuffers[uScreenId].pFramebuffer.isNull())
647	{
648	return VINF_SUCCESS;
649	}
650
651	mLastAddress = pvVRAM;
652	mLastBytesPerLine = cbLine;
653	mLastBitsPerPixel = bpp,
654	mLastWidth = w;
655	mLastHeight = h;
656	mLastFlags = flags;
657
658	ULONG pixelFormat;
659
660	switch (bpp)
661	{
662	case 32:
663	case 24:
664	case 16:
665	pixelFormat = FramebufferPixelFormat_FOURCC_RGB;
666	break;
667	default:
668	pixelFormat = FramebufferPixelFormat_Opaque;
669	bpp = cbLine = 0;
670	break;
671	}
672
673	/* Atomically set the resize status before calling the framebuffer. The new InProgress status will
674	* disable access to the VGA device by the EMT thread.
675	*/
676	bool f = ASMAtomicCmpXchgU32 (&maFramebuffers[uScreenId].u32ResizeStatus,
677	ResizeStatus_InProgress, ResizeStatus_Void);
678	if (!f)
679	{
680	/* This could be a result of the screenshot taking call Display::TakeScreenShot:
681	* if the framebuffer is processing the resize request and GUI calls the TakeScreenShot
682	* and the guest has reprogrammed the virtual VGA devices again so a new resize is required.
683	*
684	* Save the resize information and return the pending status code.
685	*
686	* Note: the resize information is only accessed on EMT so no serialization is required.
687	*/
688	LogRel (("Display::handleDisplayResize(): Warning: resize postponed.\n"));
689
690	maFramebuffers[uScreenId].pendingResize.fPending = true;
691	maFramebuffers[uScreenId].pendingResize.pixelFormat = pixelFormat;
692	maFramebuffers[uScreenId].pendingResize.pvVRAM = pvVRAM;
693	maFramebuffers[uScreenId].pendingResize.bpp = bpp;
694	maFramebuffers[uScreenId].pendingResize.cbLine = cbLine;
695	maFramebuffers[uScreenId].pendingResize.w = w;
696	maFramebuffers[uScreenId].pendingResize.h = h;
697	maFramebuffers[uScreenId].pendingResize.flags = flags;
698
699	return VINF_VGA_RESIZE_IN_PROGRESS;
700	}
701
702	int rc = callFramebufferResize (maFramebuffers[uScreenId].pFramebuffer, uScreenId,
703	pixelFormat, pvVRAM, bpp, cbLine, w, h);
704	if (rc == VINF_VGA_RESIZE_IN_PROGRESS)
705	{
706	/* Immediately return to the caller. ResizeCompleted will be called back by the
707	* GUI thread. The ResizeCompleted callback will change the resize status from
708	* InProgress to UpdateDisplayData. The latter status will be checked by the
709	* display timer callback on EMT and all required adjustments will be done there.
710	*/
711	return rc;
712	}
713
714	/* Set the status so the 'handleResizeCompleted' would work. */
715	f = ASMAtomicCmpXchgU32 (&maFramebuffers[uScreenId].u32ResizeStatus,
716	ResizeStatus_UpdateDisplayData, ResizeStatus_InProgress);
717	AssertRelease(f);NOREF(f);
718
719	AssertRelease(!maFramebuffers[uScreenId].pendingResize.fPending);
720
721	/* The method also unlocks the framebuffer. */
722	handleResizeCompletedEMT();
723
724	return VINF_SUCCESS;
725	}
726
727	/**
728	* Framebuffer has been resized.
729	* Read the new display data and unlock the framebuffer.
730	*
731	* @thread EMT
732	*/
733	void Display::handleResizeCompletedEMT (void)
734	{
735	LogFlowFunc(("\n"));
736
737	unsigned uScreenId;
738	for (uScreenId = 0; uScreenId < mcMonitors; uScreenId++)
739	{
740	DISPLAYFBINFO *pFBInfo = &maFramebuffers[uScreenId];
741
742	/* Try to into non resizing state. */
743	bool f = ASMAtomicCmpXchgU32 (&pFBInfo->u32ResizeStatus, ResizeStatus_Void, ResizeStatus_UpdateDisplayData);
744
745	if (f == false)
746	{
747	/* This is not the display that has completed resizing. */
748	continue;
749	}
750
751	/* Check whether a resize is pending for this framebuffer. */
752	if (pFBInfo->pendingResize.fPending)
753	{
754	/* Reset the condition, call the display resize with saved data and continue.
755	*
756	* Note: handleDisplayResize can call handleResizeCompletedEMT back,
757	* but infinite recursion is not possible, because when the handleResizeCompletedEMT
758	* is called, the pFBInfo->pendingResize.fPending is equal to false.
759	*/
760	pFBInfo->pendingResize.fPending = false;
761	handleDisplayResize (uScreenId, pFBInfo->pendingResize.bpp, pFBInfo->pendingResize.pvVRAM,
762	pFBInfo->pendingResize.cbLine, pFBInfo->pendingResize.w, pFBInfo->pendingResize.h, pFBInfo->pendingResize.flags);
763	continue;
764	}
765
766	/* @todo Merge these two 'if's within one 'if (!pFBInfo->pFramebuffer.isNull())' */
767	if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN && !pFBInfo->pFramebuffer.isNull())
768	{
769	/* Primary framebuffer has completed the resize. Update the connector data for VGA device. */
770	updateDisplayData();
771
772	/* Check the framebuffer pixel format to setup the rendering in VGA device. */
773	BOOL usesGuestVRAM = FALSE;
774	pFBInfo->pFramebuffer->COMGETTER(UsesGuestVRAM) (&usesGuestVRAM);
775
776	pFBInfo->fDefaultFormat = (usesGuestVRAM == FALSE);
777
778	/* If the primary framebuffer is disabled, tell the VGA device to not to copy
779	* pixels from VRAM to the framebuffer.
780	*/
781	if (pFBInfo->fDisabled)
782	mpDrv->pUpPort->pfnSetRenderVRAM (mpDrv->pUpPort, false);
783	else
784	mpDrv->pUpPort->pfnSetRenderVRAM (mpDrv->pUpPort,
785	pFBInfo->fDefaultFormat);
786
787	/* If the screen resize was because of disabling, tell framebuffer to repaint.
788	* The framebuffer if now in default format so it will not use guest VRAM
789	* and will show usually black image which is there after framebuffer resize.
790	*/
791	if (pFBInfo->fDisabled)
792	pFBInfo->pFramebuffer->NotifyUpdate(0, 0, mpDrv->IConnector.cx, mpDrv->IConnector.cy);
793	}
794	else if (!pFBInfo->pFramebuffer.isNull())
795	{
796	BOOL usesGuestVRAM = FALSE;
797	pFBInfo->pFramebuffer->COMGETTER(UsesGuestVRAM) (&usesGuestVRAM);
798
799	pFBInfo->fDefaultFormat = (usesGuestVRAM == FALSE);
800
801	/* If the screen resize was because of disabling, tell framebuffer to repaint.
802	* The framebuffer if now in default format so it will not use guest VRAM
803	* and will show usually black image which is there after framebuffer resize.
804	*/
805	if (pFBInfo->fDisabled)
806	pFBInfo->pFramebuffer->NotifyUpdate(0, 0, pFBInfo->w, pFBInfo->h);
807	}
808	LogFlow(("[%d]: default format %d\n", uScreenId, pFBInfo->fDefaultFormat));
809
810	#ifdef DEBUG_sunlover
811	if (!stam)
812	{
813	/* protect mpVM */
814	Console::SafeVMPtr pVM (mParent);
815	AssertComRC (pVM.rc());
816
817	STAM_REG(pVM, &StatDisplayRefresh, STAMTYPE_PROFILE, "/PROF/Display/Refresh", STAMUNIT_TICKS_PER_CALL, "Time spent in EMT for display updates.");
818	stam = 1;
819	}
820	#endif /* DEBUG_sunlover */
821
822	/* Inform VRDP server about the change of display parameters. */
823	LogFlowFunc (("Calling VRDP\n"));
824	mParent->consoleVRDPServer()->SendResize();
825
826	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
827	{
828	BOOL is3denabled;
829	mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
830
831	if (is3denabled)
832	{
833	VBOXHGCMSVCPARM parm;
834
835	parm.type = VBOX_HGCM_SVC_PARM_32BIT;
836	parm.u.uint32 = uScreenId;
837
838	VMMDev *pVMMDev = mParent->getVMMDev();
839	if (pVMMDev)
840	pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SCREEN_CHANGED, SHCRGL_CPARMS_SCREEN_CHANGED, &parm);
841	}
842	}
843	#endif /* VBOX_WITH_CROGL */
844	}
845	}
846
847	static void checkCoordBounds (int px, int py, int pw, int ph, int cx, int cy)
848	{
849	/* Correct negative x and y coordinates. */
850	if (*px < 0)
851	{
852	px += pw; /* Compute xRight which is also the new width. */
853
854	pw = (px < 0)? 0: *px;
855
856	*px = 0;
857	}
858
859	if (*py < 0)
860	{
861	py += ph; /* Compute xBottom, which is also the new height. */
862
863	ph = (py < 0)? 0: *py;
864
865	*py = 0;
866	}
867
868	/* Also check if coords are greater than the display resolution. */
869	if (px + pw > cx)
870	{
871	pw = cx > px? cx - *px: 0;
872	}
873
874	if (py + ph > cy)
875	{
876	ph = cy > py? cy - *py: 0;
877	}
878	}
879
880	unsigned mapCoordsToScreen(DISPLAYFBINFO pInfos, unsigned cInfos, int px, int py, int pw, int *ph)
881	{
882	DISPLAYFBINFO *pInfo = pInfos;
883	unsigned uScreenId;
884	LogSunlover (("mapCoordsToScreen: %d,%d %dx%d\n", px, py, pw, ph));
885	for (uScreenId = 0; uScreenId < cInfos; uScreenId++, pInfo++)
886	{
887	LogSunlover ((" [%d] %d,%d %dx%d\n", uScreenId, pInfo->xOrigin, pInfo->yOrigin, pInfo->w, pInfo->h));
888	if ( (pInfo->xOrigin <= px && px < pInfo->xOrigin + (int)pInfo->w)
889	&& (pInfo->yOrigin <= py && py < pInfo->yOrigin + (int)pInfo->h))
890	{
891	/* The rectangle belongs to the screen. Correct coordinates. */
892	*px -= pInfo->xOrigin;
893	*py -= pInfo->yOrigin;
894	LogSunlover ((" -> %d,%d", px, py));
895	break;
896	}
897	}
898	if (uScreenId == cInfos)
899	{
900	/* Map to primary screen. */
901	uScreenId = 0;
902	}
903	LogSunlover ((" scr %d\n", uScreenId));
904	return uScreenId;
905	}
906
907
908	/**
909	* Handles display update event.
910	*
911	* @param x Update area x coordinate
912	* @param y Update area y coordinate
913	* @param w Update area width
914	* @param h Update area height
915	*
916	* @thread EMT
917	*/
918	void Display::handleDisplayUpdateLegacy (int x, int y, int w, int h)
919	{
920	unsigned uScreenId = mapCoordsToScreen(maFramebuffers, mcMonitors, &x, &y, &w, &h);
921
922	#ifdef DEBUG_sunlover
923	LogFlowFunc (("%d,%d %dx%d (checked)\n", x, y, w, h));
924	#endif /* DEBUG_sunlover */
925
926	handleDisplayUpdate (uScreenId, x, y, w, h);
927	}
928
929	void Display::handleDisplayUpdate (unsigned uScreenId, int x, int y, int w, int h)
930	{
931	/*
932	* Always runs under either VBVA lock or, for HGSMI, DevVGA lock.
933	* Safe to use VBVA vars and take the framebuffer lock.
934	*/
935
936	#ifdef DEBUG_sunlover
937	LogFlowFunc (("[%d] %d,%d %dx%d (%d,%d)\n",
938	uScreenId, x, y, w, h, mpDrv->IConnector.cx, mpDrv->IConnector.cy));
939	#endif /* DEBUG_sunlover */
940
941	IFramebuffer *pFramebuffer = maFramebuffers[uScreenId].pFramebuffer;
942
943	// if there is no framebuffer, this call is not interesting
944	if ( pFramebuffer == NULL
945	\|\| maFramebuffers[uScreenId].fDisabled)
946	return;
947
948	pFramebuffer->Lock();
949
950	if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
951	checkCoordBounds (&x, &y, &w, &h, mpDrv->IConnector.cx, mpDrv->IConnector.cy);
952	else
953	checkCoordBounds (&x, &y, &w, &h, maFramebuffers[uScreenId].w,
954	maFramebuffers[uScreenId].h);
955
956	if (w != 0 && h != 0)
957	pFramebuffer->NotifyUpdate(x, y, w, h);
958
959	pFramebuffer->Unlock();
960
961	#ifndef VBOX_WITH_HGSMI
962	if (!mfVideoAccelEnabled)
963	{
964	#else
965	if (!mfVideoAccelEnabled && !maFramebuffers[uScreenId].fVBVAEnabled)
966	{
967	#endif /* VBOX_WITH_HGSMI */
968	/* When VBVA is enabled, the VRDP server is informed in the VideoAccelFlush.
969	* Inform the server here only if VBVA is disabled.
970	*/
971	if (maFramebuffers[uScreenId].u32ResizeStatus == ResizeStatus_Void)
972	mParent->consoleVRDPServer()->SendUpdateBitmap(uScreenId, x, y, w, h);
973	}
974	}
975
976	void Display::getFramebufferDimensions(int32_t px1, int32_t py1,
977	int32_t px2, int32_t py2)
978	{
979	int32_t x1 = 0, y1 = 0, x2 = 0, y2 = 0;
980	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
981
982	AssertPtrReturnVoid(px1);
983	AssertPtrReturnVoid(py1);
984	AssertPtrReturnVoid(px2);
985	AssertPtrReturnVoid(py2);
986	LogFlowFunc(("\n"));
987
988	if (!mpDrv)
989	return;
990	/* If VBVA is not in use then this flag will not be set and this
991	* will still work as it should. */
992	if (!(maFramebuffers[0].fDisabled))
993	{
994	x2 = mpDrv->IConnector.cx + (int32_t)maFramebuffers[0].xOrigin;
995	y2 = mpDrv->IConnector.cy + (int32_t)maFramebuffers[0].yOrigin;
996	}
997	for (unsigned i = 1; i < mcMonitors; ++i)
998	{
999	if (!(maFramebuffers[i].fDisabled))
1000	{
1001	x1 = RT_MIN(x1, maFramebuffers[i].xOrigin);
1002	y1 = RT_MIN(y1, maFramebuffers[i].yOrigin);
1003	x2 = RT_MAX(x2, maFramebuffers[i].xOrigin
1004	+ (int32_t)maFramebuffers[i].w);
1005	y2 = RT_MAX(y2, maFramebuffers[i].yOrigin
1006	+ (int32_t)maFramebuffers[i].h);
1007	}
1008	}
1009	*px1 = x1;
1010	*py1 = y1;
1011	*px2 = x2;
1012	*py2 = y2;
1013	}
1014
1015	static bool displayIntersectRect(RTRECT *prectResult,
1016	const RTRECT *prect1,
1017	const RTRECT *prect2)
1018	{
1019	/* Initialize result to an empty record. */
1020	memset (prectResult, 0, sizeof (RTRECT));
1021
1022	int xLeftResult = RT_MAX(prect1->xLeft, prect2->xLeft);
1023	int xRightResult = RT_MIN(prect1->xRight, prect2->xRight);
1024
1025	if (xLeftResult < xRightResult)
1026	{
1027	/* There is intersection by X. */
1028
1029	int yTopResult = RT_MAX(prect1->yTop, prect2->yTop);
1030	int yBottomResult = RT_MIN(prect1->yBottom, prect2->yBottom);
1031
1032	if (yTopResult < yBottomResult)
1033	{
1034	/* There is intersection by Y. */
1035
1036	prectResult->xLeft = xLeftResult;
1037	prectResult->yTop = yTopResult;
1038	prectResult->xRight = xRightResult;
1039	prectResult->yBottom = yBottomResult;
1040
1041	return true;
1042	}
1043	}
1044
1045	return false;
1046	}
1047
1048	int Display::handleSetVisibleRegion(uint32_t cRect, PRTRECT pRect)
1049	{
1050	RTRECT pVisibleRegion = (RTRECT )RTMemTmpAlloc( RT_MAX(cRect, 1)
1051	* sizeof (RTRECT));
1052	if (!pVisibleRegion)
1053	{
1054	return VERR_NO_TMP_MEMORY;
1055	}
1056
1057	unsigned uScreenId;
1058	for (uScreenId = 0; uScreenId < mcMonitors; uScreenId++)
1059	{
1060	DISPLAYFBINFO *pFBInfo = &maFramebuffers[uScreenId];
1061
1062	if (!pFBInfo->pFramebuffer.isNull())
1063	{
1064	/* Prepare a new array of rectangles which intersect with the framebuffer.
1065	*/
1066	RTRECT rectFramebuffer;
1067	if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
1068	{
1069	rectFramebuffer.xLeft = 0;
1070	rectFramebuffer.yTop = 0;
1071	if (mpDrv)
1072	{
1073	rectFramebuffer.xRight = mpDrv->IConnector.cx;
1074	rectFramebuffer.yBottom = mpDrv->IConnector.cy;
1075	}
1076	else
1077	{
1078	rectFramebuffer.xRight = 0;
1079	rectFramebuffer.yBottom = 0;
1080	}
1081	}
1082	else
1083	{
1084	rectFramebuffer.xLeft = pFBInfo->xOrigin;
1085	rectFramebuffer.yTop = pFBInfo->yOrigin;
1086	rectFramebuffer.xRight = pFBInfo->xOrigin + pFBInfo->w;
1087	rectFramebuffer.yBottom = pFBInfo->yOrigin + pFBInfo->h;
1088	}
1089
1090	uint32_t cRectVisibleRegion = 0;
1091
1092	uint32_t i;
1093	for (i = 0; i < cRect; i++)
1094	{
1095	if (displayIntersectRect(&pVisibleRegion[cRectVisibleRegion], &pRect[i], &rectFramebuffer))
1096	{
1097	pVisibleRegion[cRectVisibleRegion].xLeft -= pFBInfo->xOrigin;
1098	pVisibleRegion[cRectVisibleRegion].yTop -= pFBInfo->yOrigin;
1099	pVisibleRegion[cRectVisibleRegion].xRight -= pFBInfo->xOrigin;
1100	pVisibleRegion[cRectVisibleRegion].yBottom -= pFBInfo->yOrigin;
1101
1102	cRectVisibleRegion++;
1103	}
1104	}
1105
1106	pFBInfo->pFramebuffer->SetVisibleRegion((BYTE *)pVisibleRegion, cRectVisibleRegion);
1107	}
1108	}
1109
1110	#if defined(RT_OS_DARWIN) && defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
1111	// @todo fix for multimonitor
1112	BOOL is3denabled = FALSE;
1113
1114	mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
1115
1116	VMMDev *vmmDev = mParent->getVMMDev();
1117	if (is3denabled && vmmDev)
1118	{
1119	VBOXHGCMSVCPARM parms[2];
1120
1121	parms[0].type = VBOX_HGCM_SVC_PARM_PTR;
1122	parms[0].u.pointer.addr = pRect;
1123	parms[0].u.pointer.size = 0; /* We don't actually care. */
1124	parms[1].type = VBOX_HGCM_SVC_PARM_32BIT;
1125	parms[1].u.uint32 = cRect;
1126
1127	vmmDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SET_VISIBLE_REGION, 2, &parms[0]);
1128	}
1129	#endif
1130
1131	RTMemTmpFree(pVisibleRegion);
1132
1133	return VINF_SUCCESS;
1134	}
1135
1136	int Display::handleQueryVisibleRegion(uint32_t *pcRect, PRTRECT pRect)
1137	{
1138	// @todo Currently not used by the guest and is not implemented in framebuffers. Remove?
1139	return VERR_NOT_SUPPORTED;
1140	}
1141
1142	typedef struct _VBVADIRTYREGION
1143	{
1144	/* Copies of object's pointers used by vbvaRgn functions. */
1145	DISPLAYFBINFO *paFramebuffers;
1146	unsigned cMonitors;
1147	Display *pDisplay;
1148	PPDMIDISPLAYPORT pPort;
1149
1150	} VBVADIRTYREGION;
1151
1152	static void vbvaRgnInit (VBVADIRTYREGION prgn, DISPLAYFBINFO paFramebuffers, unsigned cMonitors, Display *pd, PPDMIDISPLAYPORT pp)
1153	{
1154	prgn->paFramebuffers = paFramebuffers;
1155	prgn->cMonitors = cMonitors;
1156	prgn->pDisplay = pd;
1157	prgn->pPort = pp;
1158
1159	unsigned uScreenId;
1160	for (uScreenId = 0; uScreenId < cMonitors; uScreenId++)
1161	{
1162	DISPLAYFBINFO *pFBInfo = &prgn->paFramebuffers[uScreenId];
1163
1164	memset (&pFBInfo->dirtyRect, 0, sizeof (pFBInfo->dirtyRect));
1165	}
1166	}
1167
1168	static void vbvaRgnDirtyRect (VBVADIRTYREGION prgn, unsigned uScreenId, VBVACMDHDR phdr)
1169	{
1170	LogSunlover (("x = %d, y = %d, w = %d, h = %d\n",
1171	phdr->x, phdr->y, phdr->w, phdr->h));
1172
1173	/*
1174	* Here update rectangles are accumulated to form an update area.
1175	* @todo
1176	* Now the simplest method is used which builds one rectangle that
1177	* includes all update areas. A bit more advanced method can be
1178	* employed here. The method should be fast however.
1179	*/
1180	if (phdr->w == 0 \|\| phdr->h == 0)
1181	{
1182	/* Empty rectangle. */
1183	return;
1184	}
1185
1186	int32_t xRight = phdr->x + phdr->w;
1187	int32_t yBottom = phdr->y + phdr->h;
1188
1189	DISPLAYFBINFO *pFBInfo = &prgn->paFramebuffers[uScreenId];
1190
1191	if (pFBInfo->dirtyRect.xRight == 0)
1192	{
1193	/* This is the first rectangle to be added. */
1194	pFBInfo->dirtyRect.xLeft = phdr->x;
1195	pFBInfo->dirtyRect.yTop = phdr->y;
1196	pFBInfo->dirtyRect.xRight = xRight;
1197	pFBInfo->dirtyRect.yBottom = yBottom;
1198	}
1199	else
1200	{
1201	/* Adjust region coordinates. */
1202	if (pFBInfo->dirtyRect.xLeft > phdr->x)
1203	{
1204	pFBInfo->dirtyRect.xLeft = phdr->x;
1205	}
1206
1207	if (pFBInfo->dirtyRect.yTop > phdr->y)
1208	{
1209	pFBInfo->dirtyRect.yTop = phdr->y;
1210	}
1211
1212	if (pFBInfo->dirtyRect.xRight < xRight)
1213	{
1214	pFBInfo->dirtyRect.xRight = xRight;
1215	}
1216
1217	if (pFBInfo->dirtyRect.yBottom < yBottom)
1218	{
1219	pFBInfo->dirtyRect.yBottom = yBottom;
1220	}
1221	}
1222
1223	if (pFBInfo->fDefaultFormat)
1224	{
1225	//@todo pfnUpdateDisplayRect must take the vram offset parameter for the framebuffer
1226	prgn->pPort->pfnUpdateDisplayRect (prgn->pPort, phdr->x, phdr->y, phdr->w, phdr->h);
1227	prgn->pDisplay->handleDisplayUpdateLegacy (phdr->x + pFBInfo->xOrigin,
1228	phdr->y + pFBInfo->yOrigin, phdr->w, phdr->h);
1229	}
1230
1231	return;
1232	}
1233
1234	static void vbvaRgnUpdateFramebuffer (VBVADIRTYREGION *prgn, unsigned uScreenId)
1235	{
1236	DISPLAYFBINFO *pFBInfo = &prgn->paFramebuffers[uScreenId];
1237
1238	uint32_t w = pFBInfo->dirtyRect.xRight - pFBInfo->dirtyRect.xLeft;
1239	uint32_t h = pFBInfo->dirtyRect.yBottom - pFBInfo->dirtyRect.yTop;
1240
1241	if (!pFBInfo->fDefaultFormat && pFBInfo->pFramebuffer && w != 0 && h != 0)
1242	{
1243	//@todo pfnUpdateDisplayRect must take the vram offset parameter for the framebuffer
1244	prgn->pPort->pfnUpdateDisplayRect (prgn->pPort, pFBInfo->dirtyRect.xLeft, pFBInfo->dirtyRect.yTop, w, h);
1245	prgn->pDisplay->handleDisplayUpdateLegacy (pFBInfo->dirtyRect.xLeft + pFBInfo->xOrigin,
1246	pFBInfo->dirtyRect.yTop + pFBInfo->yOrigin, w, h);
1247	}
1248	}
1249
1250	static void vbvaSetMemoryFlags (VBVAMEMORY *pVbvaMemory,
1251	bool fVideoAccelEnabled,
1252	bool fVideoAccelVRDP,
1253	uint32_t fu32SupportedOrders,
1254	DISPLAYFBINFO *paFBInfos,
1255	unsigned cFBInfos)
1256	{
1257	if (pVbvaMemory)
1258	{
1259	/* This called only on changes in mode. So reset VRDP always. */
1260	uint32_t fu32Flags = VBVA_F_MODE_VRDP_RESET;
1261
1262	if (fVideoAccelEnabled)
1263	{
1264	fu32Flags \|= VBVA_F_MODE_ENABLED;
1265
1266	if (fVideoAccelVRDP)
1267	{
1268	fu32Flags \|= VBVA_F_MODE_VRDP \| VBVA_F_MODE_VRDP_ORDER_MASK;
1269
1270	pVbvaMemory->fu32SupportedOrders = fu32SupportedOrders;
1271	}
1272	}
1273
1274	pVbvaMemory->fu32ModeFlags = fu32Flags;
1275	}
1276
1277	unsigned uScreenId;
1278	for (uScreenId = 0; uScreenId < cFBInfos; uScreenId++)
1279	{
1280	if (paFBInfos[uScreenId].pHostEvents)
1281	{
1282	paFBInfos[uScreenId].pHostEvents->fu32Events \|= VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET;
1283	}
1284	}
1285	}
1286
1287	#ifdef VBOX_WITH_HGSMI
1288	static void vbvaSetMemoryFlagsHGSMI (unsigned uScreenId,
1289	uint32_t fu32SupportedOrders,
1290	bool fVideoAccelVRDP,
1291	DISPLAYFBINFO *pFBInfo)
1292	{
1293	LogFlowFunc(("HGSMI[%d]: %p\n", uScreenId, pFBInfo->pVBVAHostFlags));
1294
1295	if (pFBInfo->pVBVAHostFlags)
1296	{
1297	uint32_t fu32HostEvents = VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET;
1298
1299	if (pFBInfo->fVBVAEnabled)
1300	{
1301	fu32HostEvents \|= VBVA_F_MODE_ENABLED;
1302
1303	if (fVideoAccelVRDP)
1304	{
1305	fu32HostEvents \|= VBVA_F_MODE_VRDP;
1306	}
1307	}
1308
1309	ASMAtomicWriteU32(&pFBInfo->pVBVAHostFlags->u32HostEvents, fu32HostEvents);
1310	ASMAtomicWriteU32(&pFBInfo->pVBVAHostFlags->u32SupportedOrders, fu32SupportedOrders);
1311
1312	LogFlowFunc((" fu32HostEvents = 0x%08X, fu32SupportedOrders = 0x%08X\n", fu32HostEvents, fu32SupportedOrders));
1313	}
1314	}
1315
1316	static void vbvaSetMemoryFlagsAllHGSMI (uint32_t fu32SupportedOrders,
1317	bool fVideoAccelVRDP,
1318	DISPLAYFBINFO *paFBInfos,
1319	unsigned cFBInfos)
1320	{
1321	unsigned uScreenId;
1322
1323	for (uScreenId = 0; uScreenId < cFBInfos; uScreenId++)
1324	{
1325	vbvaSetMemoryFlagsHGSMI(uScreenId, fu32SupportedOrders, fVideoAccelVRDP, &paFBInfos[uScreenId]);
1326	}
1327	}
1328	#endif /* VBOX_WITH_HGSMI */
1329
1330	bool Display::VideoAccelAllowed (void)
1331	{
1332	return true;
1333	}
1334
1335	int Display::vbvaLock(void)
1336	{
1337	return RTCritSectEnter(&mVBVALock);
1338	}
1339
1340	void Display::vbvaUnlock(void)
1341	{
1342	RTCritSectLeave(&mVBVALock);
1343	}
1344
1345	/**
1346	* @thread EMT
1347	*/
1348	int Display::VideoAccelEnable (bool fEnable, VBVAMEMORY *pVbvaMemory)
1349	{
1350	int rc;
1351	vbvaLock();
1352	rc = videoAccelEnable (fEnable, pVbvaMemory);
1353	vbvaUnlock();
1354	return rc;
1355	}
1356
1357	int Display::videoAccelEnable (bool fEnable, VBVAMEMORY *pVbvaMemory)
1358	{
1359	int rc = VINF_SUCCESS;
1360
1361	/* Called each time the guest wants to use acceleration,
1362	* or when the VGA device disables acceleration,
1363	* or when restoring the saved state with accel enabled.
1364	*
1365	* VGA device disables acceleration on each video mode change
1366	* and on reset.
1367	*
1368	* Guest enabled acceleration at will. And it has to enable
1369	* acceleration after a mode change.
1370	*/
1371	LogFlowFunc (("mfVideoAccelEnabled = %d, fEnable = %d, pVbvaMemory = %p\n",
1372	mfVideoAccelEnabled, fEnable, pVbvaMemory));
1373
1374	/* Strictly check parameters. Callers must not pass anything in the case. */
1375	Assert((fEnable && pVbvaMemory) \|\| (!fEnable && pVbvaMemory == NULL));
1376
1377	if (!VideoAccelAllowed ())
1378	return VERR_NOT_SUPPORTED;
1379
1380	/*
1381	* Verify that the VM is in running state. If it is not,
1382	* then this must be postponed until it goes to running.
1383	*/
1384	if (!mfMachineRunning)
1385	{
1386	Assert (!mfVideoAccelEnabled);
1387
1388	LogFlowFunc (("Machine is not yet running.\n"));
1389
1390	if (fEnable)
1391	{
1392	mfPendingVideoAccelEnable = fEnable;
1393	mpPendingVbvaMemory = pVbvaMemory;
1394	}
1395
1396	return rc;
1397	}
1398
1399	/* Check that current status is not being changed */
1400	if (mfVideoAccelEnabled == fEnable)
1401	return rc;
1402
1403	if (mfVideoAccelEnabled)
1404	{
1405	/* Process any pending orders and empty the VBVA ring buffer. */
1406	videoAccelFlush ();
1407	}
1408
1409	if (!fEnable && mpVbvaMemory)
1410	mpVbvaMemory->fu32ModeFlags &= ~VBVA_F_MODE_ENABLED;
1411
1412	/* Safety precaution. There is no more VBVA until everything is setup! */
1413	mpVbvaMemory = NULL;
1414	mfVideoAccelEnabled = false;
1415
1416	/* Update entire display. */
1417	if (maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN].u32ResizeStatus == ResizeStatus_Void)
1418	mpDrv->pUpPort->pfnUpdateDisplayAll(mpDrv->pUpPort);
1419
1420	/* Everything OK. VBVA status can be changed. */
1421
1422	/* Notify the VMMDev, which saves VBVA status in the saved state,
1423	* and needs to know current status.
1424	*/
1425	VMMDev *pVMMDev = mParent->getVMMDev();
1426	if (pVMMDev)
1427	{
1428	PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
1429	if (pVMMDevPort)
1430	pVMMDevPort->pfnVBVAChange(pVMMDevPort, fEnable);
1431	}
1432
1433	if (fEnable)
1434	{
1435	mpVbvaMemory = pVbvaMemory;
1436	mfVideoAccelEnabled = true;
1437
1438	/* Initialize the hardware memory. */
1439	vbvaSetMemoryFlags(mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders, maFramebuffers, mcMonitors);
1440	mpVbvaMemory->off32Data = 0;
1441	mpVbvaMemory->off32Free = 0;
1442
1443	memset(mpVbvaMemory->aRecords, 0, sizeof (mpVbvaMemory->aRecords));
1444	mpVbvaMemory->indexRecordFirst = 0;
1445	mpVbvaMemory->indexRecordFree = 0;
1446
1447	mfu32PendingVideoAccelDisable = false;
1448
1449	LogRel(("VBVA: Enabled.\n"));
1450	}
1451	else
1452	{
1453	LogRel(("VBVA: Disabled.\n"));
1454	}
1455
1456	LogFlowFunc (("VideoAccelEnable: rc = %Rrc.\n", rc));
1457
1458	return rc;
1459	}
1460
1461	/* Called always by one VRDP server thread. Can be thread-unsafe.
1462	*/
1463	void Display::VideoAccelVRDP (bool fEnable)
1464	{
1465	LogFlowFunc(("fEnable = %d\n", fEnable));
1466
1467	vbvaLock();
1468
1469	int c = fEnable?
1470	ASMAtomicIncS32 (&mcVideoAccelVRDPRefs):
1471	ASMAtomicDecS32 (&mcVideoAccelVRDPRefs);
1472
1473	Assert (c >= 0);
1474
1475	if (c == 0)
1476	{
1477	/* The last client has disconnected, and the accel can be
1478	* disabled.
1479	*/
1480	Assert (fEnable == false);
1481
1482	mfVideoAccelVRDP = false;
1483	mfu32SupportedOrders = 0;
1484
1485	vbvaSetMemoryFlags (mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders, maFramebuffers, mcMonitors);
1486	#ifdef VBOX_WITH_HGSMI
1487	/* Here is VRDP-IN thread. Process the request in vbvaUpdateBegin under DevVGA lock on an EMT. */
1488	ASMAtomicIncU32(&mu32UpdateVBVAFlags);
1489	#endif /* VBOX_WITH_HGSMI */
1490
1491	LogRel(("VBVA: VRDP acceleration has been disabled.\n"));
1492	}
1493	else if ( c == 1
1494	&& !mfVideoAccelVRDP)
1495	{
1496	/* The first client has connected. Enable the accel.
1497	*/
1498	Assert (fEnable == true);
1499
1500	mfVideoAccelVRDP = true;
1501	/* Supporting all orders. */
1502	mfu32SupportedOrders = ~0;
1503
1504	vbvaSetMemoryFlags (mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders, maFramebuffers, mcMonitors);
1505	#ifdef VBOX_WITH_HGSMI
1506	/* Here is VRDP-IN thread. Process the request in vbvaUpdateBegin under DevVGA lock on an EMT. */
1507	ASMAtomicIncU32(&mu32UpdateVBVAFlags);
1508	#endif /* VBOX_WITH_HGSMI */
1509
1510	LogRel(("VBVA: VRDP acceleration has been requested.\n"));
1511	}
1512	else
1513	{
1514	/* A client is connected or disconnected but there is no change in the
1515	* accel state. It remains enabled.
1516	*/
1517	Assert (mfVideoAccelVRDP == true);
1518	}
1519	vbvaUnlock();
1520	}
1521
1522	static bool vbvaVerifyRingBuffer (VBVAMEMORY *pVbvaMemory)
1523	{
1524	return true;
1525	}
1526
1527	static void vbvaFetchBytes (VBVAMEMORY pVbvaMemory, uint8_t pu8Dst, uint32_t cbDst)
1528	{
1529	if (cbDst >= VBVA_RING_BUFFER_SIZE)
1530	{
1531	AssertMsgFailed (("cbDst = 0x%08X, ring buffer size 0x%08X", cbDst, VBVA_RING_BUFFER_SIZE));
1532	return;
1533	}
1534
1535	uint32_t u32BytesTillBoundary = VBVA_RING_BUFFER_SIZE - pVbvaMemory->off32Data;
1536	uint8_t *src = &pVbvaMemory->au8RingBuffer[pVbvaMemory->off32Data];
1537	int32_t i32Diff = cbDst - u32BytesTillBoundary;
1538
1539	if (i32Diff <= 0)
1540	{
1541	/* Chunk will not cross buffer boundary. */
1542	memcpy (pu8Dst, src, cbDst);
1543	}
1544	else
1545	{
1546	/* Chunk crosses buffer boundary. */
1547	memcpy (pu8Dst, src, u32BytesTillBoundary);
1548	memcpy (pu8Dst + u32BytesTillBoundary, &pVbvaMemory->au8RingBuffer[0], i32Diff);
1549	}
1550
1551	/* Advance data offset. */
1552	pVbvaMemory->off32Data = (pVbvaMemory->off32Data + cbDst) % VBVA_RING_BUFFER_SIZE;
1553
1554	return;
1555	}
1556
1557
1558	static bool vbvaPartialRead (uint8_t *ppu8, uint32_t pcb, uint32_t cbRecord, VBVAMEMORY *pVbvaMemory)
1559	{
1560	uint8_t *pu8New;
1561
1562	LogFlow(("MAIN::DisplayImpl::vbvaPartialRead: p = %p, cb = %d, cbRecord 0x%08X\n",
1563	ppu8, pcb, cbRecord));
1564
1565	if (*ppu8)
1566	{
1567	Assert (*pcb);
1568	pu8New = (uint8_t )RTMemRealloc (ppu8, cbRecord);
1569	}
1570	else
1571	{
1572	Assert (!*pcb);
1573	pu8New = (uint8_t *)RTMemAlloc (cbRecord);
1574	}
1575
1576	if (!pu8New)
1577	{
1578	/* Memory allocation failed, fail the function. */
1579	Log(("MAIN::vbvaPartialRead: failed to (re)alocate memory for partial record!!! cbRecord 0x%08X\n",
1580	cbRecord));
1581
1582	if (*ppu8)
1583	{
1584	RTMemFree (*ppu8);
1585	}
1586
1587	*ppu8 = NULL;
1588	*pcb = 0;
1589
1590	return false;
1591	}
1592
1593	/* Fetch data from the ring buffer. */
1594	vbvaFetchBytes (pVbvaMemory, pu8New + pcb, cbRecord - pcb);
1595
1596	*ppu8 = pu8New;
1597	*pcb = cbRecord;
1598
1599	return true;
1600	}
1601
1602	/* For contiguous chunks just return the address in the buffer.
1603	* For crossing boundary - allocate a buffer from heap.
1604	*/
1605	bool Display::vbvaFetchCmd (VBVACMDHDR *ppHdr, uint32_t pcbCmd)
1606	{
1607	uint32_t indexRecordFirst = mpVbvaMemory->indexRecordFirst;
1608	uint32_t indexRecordFree = mpVbvaMemory->indexRecordFree;
1609
1610	#ifdef DEBUG_sunlover
1611	LogFlowFunc (("first = %d, free = %d\n",
1612	indexRecordFirst, indexRecordFree));
1613	#endif /* DEBUG_sunlover */
1614
1615	if (!vbvaVerifyRingBuffer (mpVbvaMemory))
1616	{
1617	return false;
1618	}
1619
1620	if (indexRecordFirst == indexRecordFree)
1621	{
1622	/* No records to process. Return without assigning output variables. */
1623	return true;
1624	}
1625
1626	VBVARECORD *pRecord = &mpVbvaMemory->aRecords[indexRecordFirst];
1627
1628	#ifdef DEBUG_sunlover
1629	LogFlowFunc (("cbRecord = 0x%08X\n", pRecord->cbRecord));
1630	#endif /* DEBUG_sunlover */
1631
1632	uint32_t cbRecord = pRecord->cbRecord & ~VBVA_F_RECORD_PARTIAL;
1633
1634	if (mcbVbvaPartial)
1635	{
1636	/* There is a partial read in process. Continue with it. */
1637
1638	Assert (mpu8VbvaPartial);
1639
1640	LogFlowFunc (("continue partial record mcbVbvaPartial = %d cbRecord 0x%08X, first = %d, free = %d\n",
1641	mcbVbvaPartial, pRecord->cbRecord, indexRecordFirst, indexRecordFree));
1642
1643	if (cbRecord > mcbVbvaPartial)
1644	{
1645	/* New data has been added to the record. */
1646	if (!vbvaPartialRead (&mpu8VbvaPartial, &mcbVbvaPartial, cbRecord, mpVbvaMemory))
1647	{
1648	return false;
1649	}
1650	}
1651
1652	if (!(pRecord->cbRecord & VBVA_F_RECORD_PARTIAL))
1653	{
1654	/* The record is completed by guest. Return it to the caller. */
1655	ppHdr = (VBVACMDHDR )mpu8VbvaPartial;
1656	*pcbCmd = mcbVbvaPartial;
1657
1658	mpu8VbvaPartial = NULL;
1659	mcbVbvaPartial = 0;
1660
1661	/* Advance the record index. */
1662	mpVbvaMemory->indexRecordFirst = (indexRecordFirst + 1) % VBVA_MAX_RECORDS;
1663
1664	#ifdef DEBUG_sunlover
1665	LogFlowFunc (("partial done ok, data = %d, free = %d\n",
1666	mpVbvaMemory->off32Data, mpVbvaMemory->off32Free));
1667	#endif /* DEBUG_sunlover */
1668	}
1669
1670	return true;
1671	}
1672
1673	/* A new record need to be processed. */
1674	if (pRecord->cbRecord & VBVA_F_RECORD_PARTIAL)
1675	{
1676	/* Current record is being written by guest. '=' is important here. */
1677	if (cbRecord >= VBVA_RING_BUFFER_SIZE - VBVA_RING_BUFFER_THRESHOLD)
1678	{
1679	/* Partial read must be started. */
1680	if (!vbvaPartialRead (&mpu8VbvaPartial, &mcbVbvaPartial, cbRecord, mpVbvaMemory))
1681	{
1682	return false;
1683	}
1684
1685	LogFlowFunc (("started partial record mcbVbvaPartial = 0x%08X cbRecord 0x%08X, first = %d, free = %d\n",
1686	mcbVbvaPartial, pRecord->cbRecord, indexRecordFirst, indexRecordFree));
1687	}
1688
1689	return true;
1690	}
1691
1692	/* Current record is complete. If it is not empty, process it. */
1693	if (cbRecord)
1694	{
1695	/* The size of largest contiguous chunk in the ring biffer. */
1696	uint32_t u32BytesTillBoundary = VBVA_RING_BUFFER_SIZE - mpVbvaMemory->off32Data;
1697
1698	/* The ring buffer pointer. */
1699	uint8_t *au8RingBuffer = &mpVbvaMemory->au8RingBuffer[0];
1700
1701	/* The pointer to data in the ring buffer. */
1702	uint8_t *src = &au8RingBuffer[mpVbvaMemory->off32Data];
1703
1704	/* Fetch or point the data. */
1705	if (u32BytesTillBoundary >= cbRecord)
1706	{
1707	/* The command does not cross buffer boundary. Return address in the buffer. */
1708	ppHdr = (VBVACMDHDR )src;
1709
1710	/* Advance data offset. */
1711	mpVbvaMemory->off32Data = (mpVbvaMemory->off32Data + cbRecord) % VBVA_RING_BUFFER_SIZE;
1712	}
1713	else
1714	{
1715	/* The command crosses buffer boundary. Rare case, so not optimized. */
1716	uint8_t dst = (uint8_t )RTMemAlloc (cbRecord);
1717
1718	if (!dst)
1719	{
1720	LogFlowFunc (("could not allocate %d bytes from heap!!!\n", cbRecord));
1721	mpVbvaMemory->off32Data = (mpVbvaMemory->off32Data + cbRecord) % VBVA_RING_BUFFER_SIZE;
1722	return false;
1723	}
1724
1725	vbvaFetchBytes (mpVbvaMemory, dst, cbRecord);
1726
1727	ppHdr = (VBVACMDHDR )dst;
1728
1729	#ifdef DEBUG_sunlover
1730	LogFlowFunc (("Allocated from heap %p\n", dst));
1731	#endif /* DEBUG_sunlover */
1732	}
1733	}
1734
1735	*pcbCmd = cbRecord;
1736
1737	/* Advance the record index. */
1738	mpVbvaMemory->indexRecordFirst = (indexRecordFirst + 1) % VBVA_MAX_RECORDS;
1739
1740	#ifdef DEBUG_sunlover
1741	LogFlowFunc (("done ok, data = %d, free = %d\n",
1742	mpVbvaMemory->off32Data, mpVbvaMemory->off32Free));
1743	#endif /* DEBUG_sunlover */
1744
1745	return true;
1746	}
1747
1748	void Display::vbvaReleaseCmd (VBVACMDHDR *pHdr, int32_t cbCmd)
1749	{
1750	uint8_t *au8RingBuffer = mpVbvaMemory->au8RingBuffer;
1751
1752	if ( (uint8_t *)pHdr >= au8RingBuffer
1753	&& (uint8_t *)pHdr < &au8RingBuffer[VBVA_RING_BUFFER_SIZE])
1754	{
1755	/* The pointer is inside ring buffer. Must be continuous chunk. */
1756	Assert (VBVA_RING_BUFFER_SIZE - ((uint8_t *)pHdr - au8RingBuffer) >= cbCmd);
1757
1758	/* Do nothing. */
1759
1760	Assert (!mpu8VbvaPartial && mcbVbvaPartial == 0);
1761	}
1762	else
1763	{
1764	/* The pointer is outside. It is then an allocated copy. */
1765
1766	#ifdef DEBUG_sunlover
1767	LogFlowFunc (("Free heap %p\n", pHdr));
1768	#endif /* DEBUG_sunlover */
1769
1770	if ((uint8_t *)pHdr == mpu8VbvaPartial)
1771	{
1772	mpu8VbvaPartial = NULL;
1773	mcbVbvaPartial = 0;
1774	}
1775	else
1776	{
1777	Assert (!mpu8VbvaPartial && mcbVbvaPartial == 0);
1778	}
1779
1780	RTMemFree (pHdr);
1781	}
1782
1783	return;
1784	}
1785
1786
1787	/**
1788	* Called regularly on the DisplayRefresh timer.
1789	* Also on behalf of guest, when the ring buffer is full.
1790	*
1791	* @thread EMT
1792	*/
1793	void Display::VideoAccelFlush (void)
1794	{
1795	vbvaLock();
1796	videoAccelFlush();
1797	vbvaUnlock();
1798	}
1799
1800	/* Under VBVA lock. DevVGA is not taken. */
1801	void Display::videoAccelFlush (void)
1802	{
1803	#ifdef DEBUG_sunlover_2
1804	LogFlowFunc (("mfVideoAccelEnabled = %d\n", mfVideoAccelEnabled));
1805	#endif /* DEBUG_sunlover_2 */
1806
1807	if (!mfVideoAccelEnabled)
1808	{
1809	Log(("Display::VideoAccelFlush: called with disabled VBVA!!! Ignoring.\n"));
1810	return;
1811	}
1812
1813	/* Here VBVA is enabled and we have the accelerator memory pointer. */
1814	Assert(mpVbvaMemory);
1815
1816	#ifdef DEBUG_sunlover_2
1817	LogFlowFunc (("indexRecordFirst = %d, indexRecordFree = %d, off32Data = %d, off32Free = %d\n",
1818	mpVbvaMemory->indexRecordFirst, mpVbvaMemory->indexRecordFree, mpVbvaMemory->off32Data, mpVbvaMemory->off32Free));
1819	#endif /* DEBUG_sunlover_2 */
1820
1821	/* Quick check for "nothing to update" case. */
1822	if (mpVbvaMemory->indexRecordFirst == mpVbvaMemory->indexRecordFree)
1823	{
1824	return;
1825	}
1826
1827	/* Process the ring buffer */
1828	unsigned uScreenId;
1829
1830	/* Initialize dirty rectangles accumulator. */
1831	VBVADIRTYREGION rgn;
1832	vbvaRgnInit (&rgn, maFramebuffers, mcMonitors, this, mpDrv->pUpPort);
1833
1834	for (;;)
1835	{
1836	VBVACMDHDR *phdr = NULL;
1837	uint32_t cbCmd = ~0;
1838
1839	/* Fetch the command data. */
1840	if (!vbvaFetchCmd (&phdr, &cbCmd))
1841	{
1842	Log(("Display::VideoAccelFlush: unable to fetch command. off32Data = %d, off32Free = %d. Disabling VBVA!!!\n",
1843	mpVbvaMemory->off32Data, mpVbvaMemory->off32Free));
1844
1845	/* Disable VBVA on those processing errors. */
1846	videoAccelEnable (false, NULL);
1847
1848	break;
1849	}
1850
1851	if (cbCmd == uint32_t(~0))
1852	{
1853	/* No more commands yet in the queue. */
1854	break;
1855	}
1856
1857	if (cbCmd != 0)
1858	{
1859	#ifdef DEBUG_sunlover
1860	LogFlowFunc (("hdr: cbCmd = %d, x=%d, y=%d, w=%d, h=%d\n",
1861	cbCmd, phdr->x, phdr->y, phdr->w, phdr->h));
1862	#endif /* DEBUG_sunlover */
1863
1864	VBVACMDHDR hdrSaved = *phdr;
1865
1866	int x = phdr->x;
1867	int y = phdr->y;
1868	int w = phdr->w;
1869	int h = phdr->h;
1870
1871	uScreenId = mapCoordsToScreen(maFramebuffers, mcMonitors, &x, &y, &w, &h);
1872
1873	phdr->x = (int16_t)x;
1874	phdr->y = (int16_t)y;
1875	phdr->w = (uint16_t)w;
1876	phdr->h = (uint16_t)h;
1877
1878	DISPLAYFBINFO *pFBInfo = &maFramebuffers[uScreenId];
1879
1880	if (pFBInfo->u32ResizeStatus == ResizeStatus_Void)
1881	{
1882	/* Handle the command.
1883	*
1884	* Guest is responsible for updating the guest video memory.
1885	* The Windows guest does all drawing using Eng*.
1886	*
1887	* For local output, only dirty rectangle information is used
1888	* to update changed areas.
1889	*
1890	* Dirty rectangles are accumulated to exclude overlapping updates and
1891	* group small updates to a larger one.
1892	*/
1893
1894	/* Accumulate the update. */
1895	vbvaRgnDirtyRect (&rgn, uScreenId, phdr);
1896
1897	/* Forward the command to VRDP server. */
1898	mParent->consoleVRDPServer()->SendUpdate (uScreenId, phdr, cbCmd);
1899
1900	*phdr = hdrSaved;
1901	}
1902	}
1903
1904	vbvaReleaseCmd (phdr, cbCmd);
1905	}
1906
1907	for (uScreenId = 0; uScreenId < mcMonitors; uScreenId++)
1908	{
1909	if (maFramebuffers[uScreenId].u32ResizeStatus == ResizeStatus_Void)
1910	{
1911	/* Draw the framebuffer. */
1912	vbvaRgnUpdateFramebuffer (&rgn, uScreenId);
1913	}
1914	}
1915	}
1916
1917	int Display::videoAccelRefreshProcess(void)
1918	{
1919	int rc = VWRN_INVALID_STATE; /* Default is to do a display update in VGA device. */
1920
1921	vbvaLock();
1922
1923	if (ASMAtomicCmpXchgU32(&mfu32PendingVideoAccelDisable, false, true))
1924	{
1925	videoAccelEnable (false, NULL);
1926	}
1927	else if (mfPendingVideoAccelEnable)
1928	{
1929	/* Acceleration was enabled while machine was not yet running
1930	* due to restoring from saved state. Update entire display and
1931	* actually enable acceleration.
1932	*/
1933	Assert(mpPendingVbvaMemory);
1934
1935	/* Acceleration can not be yet enabled.*/
1936	Assert(mpVbvaMemory == NULL);
1937	Assert(!mfVideoAccelEnabled);
1938
1939	if (mfMachineRunning)
1940	{
1941	videoAccelEnable (mfPendingVideoAccelEnable,
1942	mpPendingVbvaMemory);
1943
1944	/* Reset the pending state. */
1945	mfPendingVideoAccelEnable = false;
1946	mpPendingVbvaMemory = NULL;
1947	}
1948
1949	rc = VINF_TRY_AGAIN;
1950	}
1951	else
1952	{
1953	Assert(mpPendingVbvaMemory == NULL);
1954
1955	if (mfVideoAccelEnabled)
1956	{
1957	Assert(mpVbvaMemory);
1958	videoAccelFlush ();
1959
1960	rc = VINF_SUCCESS; /* VBVA processed, no need to a display update. */
1961	}
1962	}
1963
1964	vbvaUnlock();
1965
1966	return rc;
1967	}
1968
1969
1970	// IDisplay methods
1971	/////////////////////////////////////////////////////////////////////////////
1972	STDMETHODIMP Display::GetScreenResolution (ULONG aScreenId,
1973	ULONG aWidth, ULONG aHeight, ULONG *aBitsPerPixel)
1974	{
1975	LogFlowFunc (("aScreenId = %d\n", aScreenId));
1976
1977	AutoCaller autoCaller(this);
1978	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1979
1980	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1981
1982	uint32_t u32Width = 0;
1983	uint32_t u32Height = 0;
1984	uint32_t u32BitsPerPixel = 0;
1985
1986	if (aScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
1987	{
1988	CHECK_CONSOLE_DRV (mpDrv);
1989
1990	u32Width = mpDrv->IConnector.cx;
1991	u32Height = mpDrv->IConnector.cy;
1992	int rc = mpDrv->pUpPort->pfnQueryColorDepth(mpDrv->pUpPort, &u32BitsPerPixel);
1993	AssertRC(rc);
1994	}
1995	else if (aScreenId < mcMonitors)
1996	{
1997	DISPLAYFBINFO *pFBInfo = &maFramebuffers[aScreenId];
1998	u32Width = pFBInfo->w;
1999	u32Height = pFBInfo->h;
2000	u32BitsPerPixel = pFBInfo->u16BitsPerPixel;
2001	}
2002	else
2003	{
2004	return E_INVALIDARG;
2005	}
2006
2007	if (aWidth)
2008	*aWidth = u32Width;
2009	if (aHeight)
2010	*aHeight = u32Height;
2011	if (aBitsPerPixel)
2012	*aBitsPerPixel = u32BitsPerPixel;
2013
2014	return S_OK;
2015	}
2016
2017	STDMETHODIMP Display::SetFramebuffer (ULONG aScreenId,
2018	IFramebuffer *aFramebuffer)
2019	{
2020	LogFlowFunc (("\n"));
2021
2022	if (aFramebuffer != NULL)
2023	CheckComArgOutPointerValid(aFramebuffer);
2024
2025	AutoCaller autoCaller(this);
2026	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2027
2028	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2029
2030	Console::SafeVMPtrQuiet pVM (mParent);
2031	if (pVM.isOk())
2032	{
2033	/* Must leave the lock here because the changeFramebuffer will
2034	* also obtain it. */
2035	alock.leave ();
2036
2037	/* send request to the EMT thread */
2038	int vrc = VMR3ReqCallWait (pVM, VMCPUID_ANY,
2039	(PFNRT) changeFramebuffer, 3, this, aFramebuffer, aScreenId);
2040
2041	alock.enter ();
2042
2043	ComAssertRCRet (vrc, E_FAIL);
2044
2045	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
2046	{
2047	BOOL is3denabled;
2048	mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
2049
2050	if (is3denabled)
2051	{
2052	VBOXHGCMSVCPARM parm;
2053
2054	parm.type = VBOX_HGCM_SVC_PARM_32BIT;
2055	parm.u.uint32 = aScreenId;
2056
2057	VMMDev *pVMMDev = mParent->getVMMDev();
2058
2059	alock.leave ();
2060
2061	if (pVMMDev)
2062	vrc = pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SCREEN_CHANGED, SHCRGL_CPARMS_SCREEN_CHANGED, &parm);
2063	/ComAssertRCRet (vrc, E_FAIL);/
2064
2065	alock.enter ();
2066	}
2067	}
2068	#endif /* VBOX_WITH_CROGL */
2069	}
2070	else
2071	{
2072	/* No VM is created (VM is powered off), do a direct call */
2073	int vrc = changeFramebuffer (this, aFramebuffer, aScreenId);
2074	ComAssertRCRet (vrc, E_FAIL);
2075	}
2076
2077	return S_OK;
2078	}
2079
2080	STDMETHODIMP Display::GetFramebuffer (ULONG aScreenId,
2081	IFramebuffer *aFramebuffer, LONG aXOrigin, LONG *aYOrigin)
2082	{
2083	LogFlowFunc (("aScreenId = %d\n", aScreenId));
2084
2085	CheckComArgOutPointerValid(aFramebuffer);
2086
2087	AutoCaller autoCaller(this);
2088	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2089
2090	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2091
2092	if (aScreenId != 0 && aScreenId >= mcMonitors)
2093	return E_INVALIDARG;
2094
2095	/* @todo this should be actually done on EMT. */
2096	DISPLAYFBINFO *pFBInfo = &maFramebuffers[aScreenId];
2097
2098	*aFramebuffer = pFBInfo->pFramebuffer;
2099	if (*aFramebuffer)
2100	(*aFramebuffer)->AddRef ();
2101	if (aXOrigin)
2102	*aXOrigin = pFBInfo->xOrigin;
2103	if (aYOrigin)
2104	*aYOrigin = pFBInfo->yOrigin;
2105
2106	return S_OK;
2107	}
2108
2109	STDMETHODIMP Display::SetVideoModeHint(ULONG aWidth, ULONG aHeight,
2110	ULONG aBitsPerPixel, ULONG aDisplay)
2111	{
2112	AutoCaller autoCaller(this);
2113	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2114
2115	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2116
2117	CHECK_CONSOLE_DRV (mpDrv);
2118
2119	/*
2120	* Do some rough checks for valid input
2121	*/
2122	ULONG width = aWidth;
2123	if (!width)
2124	width = mpDrv->IConnector.cx;
2125	ULONG height = aHeight;
2126	if (!height)
2127	height = mpDrv->IConnector.cy;
2128	ULONG bpp = aBitsPerPixel;
2129	if (!bpp)
2130	{
2131	uint32_t cBits = 0;
2132	int rc = mpDrv->pUpPort->pfnQueryColorDepth(mpDrv->pUpPort, &cBits);
2133	AssertRC(rc);
2134	bpp = cBits;
2135	}
2136	ULONG cMonitors;
2137	mParent->machine()->COMGETTER(MonitorCount)(&cMonitors);
2138	if (cMonitors == 0 && aDisplay > 0)
2139	return E_INVALIDARG;
2140	if (aDisplay >= cMonitors)
2141	return E_INVALIDARG;
2142
2143	// sunlover 20070614: It is up to the guest to decide whether the hint is valid.
2144	// ULONG vramSize;
2145	// mParent->machine()->COMGETTER(VRAMSize)(&vramSize);
2146	// /* enough VRAM? */
2147	// if ((width * height * (bpp / 8)) > (vramSize * 1024 * 1024))
2148	// return setError(E_FAIL, tr("Not enough VRAM for the selected video mode"));
2149
2150	/* Have to leave the lock because the pfnRequestDisplayChange
2151	* will call EMT. */
2152	alock.leave ();
2153
2154	VMMDev *pVMMDev = mParent->getVMMDev();
2155	if (pVMMDev)
2156	{
2157	PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
2158	if (pVMMDevPort)
2159	pVMMDevPort->pfnRequestDisplayChange(pVMMDevPort, aWidth, aHeight, aBitsPerPixel, aDisplay);
2160	}
2161	return S_OK;
2162	}
2163
2164	STDMETHODIMP Display::SetSeamlessMode (BOOL enabled)
2165	{
2166	AutoCaller autoCaller(this);
2167	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2168
2169	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2170
2171	/* Have to leave the lock because the pfnRequestSeamlessChange will call EMT. */
2172	alock.leave ();
2173
2174	VMMDev *pVMMDev = mParent->getVMMDev();
2175	if (pVMMDev)
2176	{
2177	PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
2178	if (pVMMDevPort)
2179	pVMMDevPort->pfnRequestSeamlessChange(pVMMDevPort, !!enabled);
2180	}
2181	return S_OK;
2182	}
2183
2184	int Display::displayTakeScreenshotEMT(Display pDisplay, ULONG aScreenId, uint8_t ppu8Data, size_t pcbData, uint32_t pu32Width, uint32_t pu32Height)
2185	{
2186	int rc;
2187	pDisplay->vbvaLock();
2188	if (aScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
2189	{
2190	rc = pDisplay->mpDrv->pUpPort->pfnTakeScreenshot(pDisplay->mpDrv->pUpPort, ppu8Data, pcbData, pu32Width, pu32Height);
2191	}
2192	else if (aScreenId < pDisplay->mcMonitors)
2193	{
2194	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[aScreenId];
2195
2196	uint32_t width = pFBInfo->w;
2197	uint32_t height = pFBInfo->h;
2198
2199	/* Allocate 32 bit per pixel bitmap. */
2200	size_t cbRequired = width * 4 * height;
2201
2202	if (cbRequired)
2203	{
2204	uint8_t pu8Data = (uint8_t )RTMemAlloc(cbRequired);
2205
2206	if (pu8Data == NULL)
2207	{
2208	rc = VERR_NO_MEMORY;
2209	}
2210	else
2211	{
2212	/* Copy guest VRAM to the allocated 32bpp buffer. */
2213	const uint8_t *pu8Src = pFBInfo->pu8FramebufferVRAM;
2214	int32_t xSrc = 0;
2215	int32_t ySrc = 0;
2216	uint32_t u32SrcWidth = width;
2217	uint32_t u32SrcHeight = height;
2218	uint32_t u32SrcLineSize = pFBInfo->u32LineSize;
2219	uint32_t u32SrcBitsPerPixel = pFBInfo->u16BitsPerPixel;
2220
2221	uint8_t *pu8Dst = pu8Data;
2222	int32_t xDst = 0;
2223	int32_t yDst = 0;
2224	uint32_t u32DstWidth = u32SrcWidth;
2225	uint32_t u32DstHeight = u32SrcHeight;
2226	uint32_t u32DstLineSize = u32DstWidth * 4;
2227	uint32_t u32DstBitsPerPixel = 32;
2228
2229	rc = pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
2230	width, height,
2231	pu8Src,
2232	xSrc, ySrc,
2233	u32SrcWidth, u32SrcHeight,
2234	u32SrcLineSize, u32SrcBitsPerPixel,
2235	pu8Dst,
2236	xDst, yDst,
2237	u32DstWidth, u32DstHeight,
2238	u32DstLineSize, u32DstBitsPerPixel);
2239	if (RT_SUCCESS(rc))
2240	{
2241	*ppu8Data = pu8Data;
2242	*pcbData = cbRequired;
2243	*pu32Width = width;
2244	*pu32Height = height;
2245	}
2246	else
2247	{
2248	RTMemFree(pu8Data);
2249	}
2250	}
2251	}
2252	else
2253	{
2254	/* No image. */
2255	*ppu8Data = NULL;
2256	*pcbData = 0;
2257	*pu32Width = 0;
2258	*pu32Height = 0;
2259	rc = VINF_SUCCESS;
2260	}
2261	}
2262	else
2263	{
2264	rc = VERR_INVALID_PARAMETER;
2265	}
2266	pDisplay->vbvaUnlock();
2267	return rc;
2268	}
2269
2270	static int displayTakeScreenshot(PVM pVM, Display pDisplay, struct DRVMAINDISPLAY pDrv, ULONG aScreenId, BYTE *address, ULONG width, ULONG height)
2271	{
2272	uint8_t *pu8Data = NULL;
2273	size_t cbData = 0;
2274	uint32_t cx = 0;
2275	uint32_t cy = 0;
2276	int vrc = VINF_SUCCESS;
2277
2278	int cRetries = 5;
2279
2280	while (cRetries-- > 0)
2281	{
2282	vrc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)Display::displayTakeScreenshotEMT, 6,
2283	pDisplay, aScreenId, &pu8Data, &cbData, &cx, &cy);
2284	if (vrc != VERR_TRY_AGAIN)
2285	{
2286	break;
2287	}
2288
2289	RTThreadSleep(10);
2290	}
2291
2292	if (RT_SUCCESS(vrc) && pu8Data)
2293	{
2294	if (cx == width && cy == height)
2295	{
2296	/* No scaling required. */
2297	memcpy(address, pu8Data, cbData);
2298	}
2299	else
2300	{
2301	/* Scale. */
2302	LogFlowFunc(("SCALE: %dx%d -> %dx%d\n", cx, cy, width, height));
2303
2304	uint8_t *dst = address;
2305	uint8_t *src = pu8Data;
2306	int dstW = width;
2307	int dstH = height;
2308	int srcW = cx;
2309	int srcH = cy;
2310	int iDeltaLine = cx * 4;
2311
2312	BitmapScale32 (dst,
2313	dstW, dstH,
2314	src,
2315	iDeltaLine,
2316	srcW, srcH);
2317	}
2318
2319	if (aScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
2320	{
2321	/* This can be called from any thread. */
2322	pDrv->pUpPort->pfnFreeScreenshot (pDrv->pUpPort, pu8Data);
2323	}
2324	else
2325	{
2326	RTMemFree(pu8Data);
2327	}
2328	}
2329
2330	return vrc;
2331	}
2332
2333	STDMETHODIMP Display::TakeScreenShot (ULONG aScreenId, BYTE *address, ULONG width, ULONG height)
2334	{
2335	/// @todo (r=dmik) this function may take too long to complete if the VM
2336	// is doing something like saving state right now. Which, in case if it
2337	// is called on the GUI thread, will make it unresponsive. We should
2338	// check the machine state here (by enclosing the check and VMRequCall
2339	// within the Console lock to make it atomic).
2340
2341	LogFlowFuncEnter();
2342	LogFlowFunc (("address=%p, width=%d, height=%d\n",
2343	address, width, height));
2344
2345	CheckComArgNotNull(address);
2346	CheckComArgExpr(width, width != 0);
2347	CheckComArgExpr(height, height != 0);
2348
2349	/* Do not allow too large screenshots. This also filters out negative
2350	* values passed as either 'width' or 'height'.
2351	*/
2352	CheckComArgExpr(width, width <= 32767);
2353	CheckComArgExpr(height, height <= 32767);
2354
2355	AutoCaller autoCaller(this);
2356	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2357
2358	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2359
2360	CHECK_CONSOLE_DRV (mpDrv);
2361
2362	Console::SafeVMPtr pVM(mParent);
2363	if (FAILED(pVM.rc())) return pVM.rc();
2364
2365	HRESULT rc = S_OK;
2366
2367	LogFlowFunc (("Sending SCREENSHOT request\n"));
2368
2369	/* Leave lock because other thread (EMT) is called and it may initiate a resize
2370	* which also needs lock.
2371	*
2372	* This method does not need the lock anymore.
2373	*/
2374	alock.leave();
2375
2376	int vrc = displayTakeScreenshot(pVM, this, mpDrv, aScreenId, address, width, height);
2377
2378	if (vrc == VERR_NOT_IMPLEMENTED)
2379	rc = setError(E_NOTIMPL,
2380	tr("This feature is not implemented"));
2381	else if (vrc == VERR_TRY_AGAIN)
2382	rc = setError(E_UNEXPECTED,
2383	tr("This feature is not available at this time"));
2384	else if (RT_FAILURE(vrc))
2385	rc = setError(VBOX_E_IPRT_ERROR,
2386	tr("Could not take a screenshot (%Rrc)"), vrc);
2387
2388	LogFlowFunc (("rc=%08X\n", rc));
2389	LogFlowFuncLeave();
2390	return rc;
2391	}
2392
2393	STDMETHODIMP Display::TakeScreenShotToArray (ULONG aScreenId, ULONG width, ULONG height,
2394	ComSafeArrayOut(BYTE, aScreenData))
2395	{
2396	LogFlowFuncEnter();
2397	LogFlowFunc (("width=%d, height=%d\n",
2398	width, height));
2399
2400	CheckComArgOutSafeArrayPointerValid(aScreenData);
2401	CheckComArgExpr(width, width != 0);
2402	CheckComArgExpr(height, height != 0);
2403
2404	/* Do not allow too large screenshots. This also filters out negative
2405	* values passed as either 'width' or 'height'.
2406	*/
2407	CheckComArgExpr(width, width <= 32767);
2408	CheckComArgExpr(height, height <= 32767);
2409
2410	AutoCaller autoCaller(this);
2411	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2412
2413	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2414
2415	CHECK_CONSOLE_DRV (mpDrv);
2416
2417	Console::SafeVMPtr pVM(mParent);
2418	if (FAILED(pVM.rc())) return pVM.rc();
2419
2420	HRESULT rc = S_OK;
2421
2422	LogFlowFunc (("Sending SCREENSHOT request\n"));
2423
2424	/* Leave lock because other thread (EMT) is called and it may initiate a resize
2425	* which also needs lock.
2426	*
2427	* This method does not need the lock anymore.
2428	*/
2429	alock.leave();
2430
2431	size_t cbData = width * 4 * height;
2432	uint8_t pu8Data = (uint8_t )RTMemAlloc(cbData);
2433
2434	if (!pu8Data)
2435	return E_OUTOFMEMORY;
2436
2437	int vrc = displayTakeScreenshot(pVM, this, mpDrv, aScreenId, pu8Data, width, height);
2438
2439	if (RT_SUCCESS(vrc))
2440	{
2441	/* Convert pixels to format expected by the API caller: [0] R, [1] G, [2] B, [3] A. */
2442	uint8_t *pu8 = pu8Data;
2443	unsigned cPixels = width * height;
2444	while (cPixels)
2445	{
2446	uint8_t u8 = pu8[0];
2447	pu8[0] = pu8[2];
2448	pu8[2] = u8;
2449	pu8[3] = 0xff;
2450	cPixels--;
2451	pu8 += 4;
2452	}
2453
2454	com::SafeArray<BYTE> screenData (cbData);
2455	screenData.initFrom(pu8Data, cbData);
2456	screenData.detachTo(ComSafeArrayOutArg(aScreenData));
2457	}
2458	else if (vrc == VERR_NOT_IMPLEMENTED)
2459	rc = setError(E_NOTIMPL,
2460	tr("This feature is not implemented"));
2461	else
2462	rc = setError(VBOX_E_IPRT_ERROR,
2463	tr("Could not take a screenshot (%Rrc)"), vrc);
2464
2465	RTMemFree(pu8Data);
2466
2467	LogFlowFunc (("rc=%08X\n", rc));
2468	LogFlowFuncLeave();
2469	return rc;
2470	}
2471
2472	STDMETHODIMP Display::TakeScreenShotPNGToArray (ULONG aScreenId, ULONG width, ULONG height,
2473	ComSafeArrayOut(BYTE, aScreenData))
2474	{
2475	LogFlowFuncEnter();
2476	LogFlowFunc (("width=%d, height=%d\n",
2477	width, height));
2478
2479	CheckComArgOutSafeArrayPointerValid(aScreenData);
2480	CheckComArgExpr(width, width != 0);
2481	CheckComArgExpr(height, height != 0);
2482
2483	/* Do not allow too large screenshots. This also filters out negative
2484	* values passed as either 'width' or 'height'.
2485	*/
2486	CheckComArgExpr(width, width <= 32767);
2487	CheckComArgExpr(height, height <= 32767);
2488
2489	AutoCaller autoCaller(this);
2490	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2491
2492	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2493
2494	CHECK_CONSOLE_DRV (mpDrv);
2495
2496	Console::SafeVMPtr pVM(mParent);
2497	if (FAILED(pVM.rc())) return pVM.rc();
2498
2499	HRESULT rc = S_OK;
2500
2501	LogFlowFunc (("Sending SCREENSHOT request\n"));
2502
2503	/* Leave lock because other thread (EMT) is called and it may initiate a resize
2504	* which also needs lock.
2505	*
2506	* This method does not need the lock anymore.
2507	*/
2508	alock.leave();
2509
2510	size_t cbData = width * 4 * height;
2511	uint8_t pu8Data = (uint8_t )RTMemAlloc(cbData);
2512
2513	if (!pu8Data)
2514	return E_OUTOFMEMORY;
2515
2516	int vrc = displayTakeScreenshot(pVM, this, mpDrv, aScreenId, pu8Data, width, height);
2517
2518	if (RT_SUCCESS(vrc))
2519	{
2520	uint8_t *pu8PNG = NULL;
2521	uint32_t cbPNG = 0;
2522	uint32_t cxPNG = 0;
2523	uint32_t cyPNG = 0;
2524
2525	DisplayMakePNG(pu8Data, width, height, &pu8PNG, &cbPNG, &cxPNG, &cyPNG, 0);
2526
2527	com::SafeArray<BYTE> screenData (cbPNG);
2528	screenData.initFrom(pu8PNG, cbPNG);
2529	RTMemFree(pu8PNG);
2530
2531	screenData.detachTo(ComSafeArrayOutArg(aScreenData));
2532	}
2533	else if (vrc == VERR_NOT_IMPLEMENTED)
2534	rc = setError(E_NOTIMPL,
2535	tr("This feature is not implemented"));
2536	else
2537	rc = setError(VBOX_E_IPRT_ERROR,
2538	tr("Could not take a screenshot (%Rrc)"), vrc);
2539
2540	RTMemFree(pu8Data);
2541
2542	LogFlowFunc (("rc=%08X\n", rc));
2543	LogFlowFuncLeave();
2544	return rc;
2545	}
2546
2547
2548	int Display::drawToScreenEMT(Display pDisplay, ULONG aScreenId, BYTE address, ULONG x, ULONG y, ULONG width, ULONG height)
2549	{
2550	int rc = VINF_SUCCESS;
2551	pDisplay->vbvaLock();
2552
2553	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[aScreenId];
2554
2555	if (aScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
2556	{
2557	if (pFBInfo->u32ResizeStatus == ResizeStatus_Void)
2558	{
2559	rc = pDisplay->mpDrv->pUpPort->pfnDisplayBlt(pDisplay->mpDrv->pUpPort, address, x, y, width, height);
2560	}
2561	}
2562	else if (aScreenId < pDisplay->mcMonitors)
2563	{
2564	/* Copy the bitmap to the guest VRAM. */
2565	const uint8_t *pu8Src = address;
2566	int32_t xSrc = 0;
2567	int32_t ySrc = 0;
2568	uint32_t u32SrcWidth = width;
2569	uint32_t u32SrcHeight = height;
2570	uint32_t u32SrcLineSize = width * 4;
2571	uint32_t u32SrcBitsPerPixel = 32;
2572
2573	uint8_t *pu8Dst = pFBInfo->pu8FramebufferVRAM;
2574	int32_t xDst = x;
2575	int32_t yDst = y;
2576	uint32_t u32DstWidth = pFBInfo->w;
2577	uint32_t u32DstHeight = pFBInfo->h;
2578	uint32_t u32DstLineSize = pFBInfo->u32LineSize;
2579	uint32_t u32DstBitsPerPixel = pFBInfo->u16BitsPerPixel;
2580
2581	rc = pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
2582	width, height,
2583	pu8Src,
2584	xSrc, ySrc,
2585	u32SrcWidth, u32SrcHeight,
2586	u32SrcLineSize, u32SrcBitsPerPixel,
2587	pu8Dst,
2588	xDst, yDst,
2589	u32DstWidth, u32DstHeight,
2590	u32DstLineSize, u32DstBitsPerPixel);
2591	if (RT_SUCCESS(rc))
2592	{
2593	if (!pFBInfo->pFramebuffer.isNull())
2594	{
2595	/* Update the changed screen area. When framebuffer uses VRAM directly, just notify
2596	* it to update. And for default format, render the guest VRAM to framebuffer.
2597	*/
2598	if ( pFBInfo->fDefaultFormat
2599	&& !(pFBInfo->fDisabled))
2600	{
2601	address = NULL;
2602	HRESULT hrc = pFBInfo->pFramebuffer->COMGETTER(Address) (&address);
2603	if (SUCCEEDED(hrc) && address != NULL)
2604	{
2605	pu8Src = pFBInfo->pu8FramebufferVRAM;
2606	xSrc = x;
2607	ySrc = y;
2608	u32SrcWidth = pFBInfo->w;
2609	u32SrcHeight = pFBInfo->h;
2610	u32SrcLineSize = pFBInfo->u32LineSize;
2611	u32SrcBitsPerPixel = pFBInfo->u16BitsPerPixel;
2612
2613	/* Default format is 32 bpp. */
2614	pu8Dst = address;
2615	xDst = xSrc;
2616	yDst = ySrc;
2617	u32DstWidth = u32SrcWidth;
2618	u32DstHeight = u32SrcHeight;
2619	u32DstLineSize = u32DstWidth * 4;
2620	u32DstBitsPerPixel = 32;
2621
2622	pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
2623	width, height,
2624	pu8Src,
2625	xSrc, ySrc,
2626	u32SrcWidth, u32SrcHeight,
2627	u32SrcLineSize, u32SrcBitsPerPixel,
2628	pu8Dst,
2629	xDst, yDst,
2630	u32DstWidth, u32DstHeight,
2631	u32DstLineSize, u32DstBitsPerPixel);
2632	}
2633	}
2634
2635	pDisplay->handleDisplayUpdate(aScreenId, x, y, width, height);
2636	}
2637	}
2638	}
2639	else
2640	{
2641	rc = VERR_INVALID_PARAMETER;
2642	}
2643	pDisplay->vbvaUnlock();
2644	return rc;
2645	}
2646
2647	STDMETHODIMP Display::DrawToScreen (ULONG aScreenId, BYTE *address, ULONG x, ULONG y,
2648	ULONG width, ULONG height)
2649	{
2650	/// @todo (r=dmik) this function may take too long to complete if the VM
2651	// is doing something like saving state right now. Which, in case if it
2652	// is called on the GUI thread, will make it unresponsive. We should
2653	// check the machine state here (by enclosing the check and VMRequCall
2654	// within the Console lock to make it atomic).
2655
2656	LogFlowFuncEnter();
2657	LogFlowFunc (("address=%p, x=%d, y=%d, width=%d, height=%d\n",
2658	(void *)address, x, y, width, height));
2659
2660	CheckComArgNotNull(address);
2661	CheckComArgExpr(width, width != 0);
2662	CheckComArgExpr(height, height != 0);
2663
2664	AutoCaller autoCaller(this);
2665	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2666
2667	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2668
2669	CHECK_CONSOLE_DRV (mpDrv);
2670
2671	Console::SafeVMPtr pVM(mParent);
2672	if (FAILED(pVM.rc())) return pVM.rc();
2673
2674	/* Leave lock because the call scheduled on EMT may also try to take it. */
2675	alock.leave();
2676
2677	/*
2678	* Again we're lazy and make the graphics device do all the
2679	* dirty conversion work.
2680	*/
2681	int rcVBox = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)Display::drawToScreenEMT, 7,
2682	this, aScreenId, address, x, y, width, height);
2683
2684	/*
2685	* If the function returns not supported, we'll have to do all the
2686	* work ourselves using the framebuffer.
2687	*/
2688	HRESULT rc = S_OK;
2689	if (rcVBox == VERR_NOT_SUPPORTED \|\| rcVBox == VERR_NOT_IMPLEMENTED)
2690	{
2691	/** @todo implement generic fallback for screen blitting. */
2692	rc = E_NOTIMPL;
2693	}
2694	else if (RT_FAILURE(rcVBox))
2695	rc = setError(VBOX_E_IPRT_ERROR,
2696	tr("Could not draw to the screen (%Rrc)"), rcVBox);
2697	//@todo
2698	// else
2699	// {
2700	// /* All ok. Redraw the screen. */
2701	// handleDisplayUpdate (x, y, width, height);
2702	// }
2703
2704	LogFlowFunc (("rc=%08X\n", rc));
2705	LogFlowFuncLeave();
2706	return rc;
2707	}
2708
2709	void Display::InvalidateAndUpdateEMT(Display *pDisplay)
2710	{
2711	pDisplay->vbvaLock();
2712	unsigned uScreenId;
2713	for (uScreenId = 0; uScreenId < pDisplay->mcMonitors; uScreenId++)
2714	{
2715	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[uScreenId];
2716
2717	if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN && !pFBInfo->pFramebuffer.isNull())
2718	{
2719	pDisplay->mpDrv->pUpPort->pfnUpdateDisplayAll(pDisplay->mpDrv->pUpPort);
2720	}
2721	else
2722	{
2723	if ( !pFBInfo->pFramebuffer.isNull()
2724	&& !(pFBInfo->fDisabled))
2725	{
2726	/* Render complete VRAM screen to the framebuffer.
2727	* When framebuffer uses VRAM directly, just notify it to update.
2728	*/
2729	if (pFBInfo->fDefaultFormat)
2730	{
2731	BYTE *address = NULL;
2732	HRESULT hrc = pFBInfo->pFramebuffer->COMGETTER(Address) (&address);
2733	if (SUCCEEDED(hrc) && address != NULL)
2734	{
2735	uint32_t width = pFBInfo->w;
2736	uint32_t height = pFBInfo->h;
2737
2738	const uint8_t *pu8Src = pFBInfo->pu8FramebufferVRAM;
2739	int32_t xSrc = 0;
2740	int32_t ySrc = 0;
2741	uint32_t u32SrcWidth = pFBInfo->w;
2742	uint32_t u32SrcHeight = pFBInfo->h;
2743	uint32_t u32SrcLineSize = pFBInfo->u32LineSize;
2744	uint32_t u32SrcBitsPerPixel = pFBInfo->u16BitsPerPixel;
2745
2746	/* Default format is 32 bpp. */
2747	uint8_t *pu8Dst = address;
2748	int32_t xDst = xSrc;
2749	int32_t yDst = ySrc;
2750	uint32_t u32DstWidth = u32SrcWidth;
2751	uint32_t u32DstHeight = u32SrcHeight;
2752	uint32_t u32DstLineSize = u32DstWidth * 4;
2753	uint32_t u32DstBitsPerPixel = 32;
2754
2755	pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
2756	width, height,
2757	pu8Src,
2758	xSrc, ySrc,
2759	u32SrcWidth, u32SrcHeight,
2760	u32SrcLineSize, u32SrcBitsPerPixel,
2761	pu8Dst,
2762	xDst, yDst,
2763	u32DstWidth, u32DstHeight,
2764	u32DstLineSize, u32DstBitsPerPixel);
2765	}
2766	}
2767
2768	pDisplay->handleDisplayUpdate (uScreenId, 0, 0, pFBInfo->w, pFBInfo->h);
2769	}
2770	}
2771	}
2772	pDisplay->vbvaUnlock();
2773	}
2774
2775	/**
2776	* Does a full invalidation of the VM display and instructs the VM
2777	* to update it immediately.
2778	*
2779	* @returns COM status code
2780	*/
2781	STDMETHODIMP Display::InvalidateAndUpdate()
2782	{
2783	LogFlowFuncEnter();
2784
2785	AutoCaller autoCaller(this);
2786	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2787
2788	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2789
2790	CHECK_CONSOLE_DRV (mpDrv);
2791
2792	Console::SafeVMPtr pVM(mParent);
2793	if (FAILED(pVM.rc())) return pVM.rc();
2794
2795	HRESULT rc = S_OK;
2796
2797	LogFlowFunc (("Sending DPYUPDATE request\n"));
2798
2799	/* Have to leave the lock when calling EMT. */
2800	alock.leave ();
2801
2802	/* pdm.h says that this has to be called from the EMT thread */
2803	int rcVBox = VMR3ReqCallVoidWait(pVM, VMCPUID_ANY, (PFNRT)Display::InvalidateAndUpdateEMT,
2804	1, this);
2805	alock.enter ();
2806
2807	if (RT_FAILURE(rcVBox))
2808	rc = setError(VBOX_E_IPRT_ERROR,
2809	tr("Could not invalidate and update the screen (%Rrc)"), rcVBox);
2810
2811	LogFlowFunc (("rc=%08X\n", rc));
2812	LogFlowFuncLeave();
2813	return rc;
2814	}
2815
2816	/**
2817	* Notification that the framebuffer has completed the
2818	* asynchronous resize processing
2819	*
2820	* @returns COM status code
2821	*/
2822	STDMETHODIMP Display::ResizeCompleted(ULONG aScreenId)
2823	{
2824	LogFlowFunc (("\n"));
2825
2826	/// @todo (dmik) can we AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); here?
2827	// This will require general code review and may add some details.
2828	// In particular, we may want to check whether EMT is really waiting for
2829	// this notification, etc. It might be also good to obey the caller to make
2830	// sure this method is not called from more than one thread at a time
2831	// (and therefore don't use Display lock at all here to save some
2832	// milliseconds).
2833	AutoCaller autoCaller(this);
2834	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2835
2836	/* this is only valid for external framebuffers */
2837	if (maFramebuffers[aScreenId].pFramebuffer == NULL)
2838	return setError(VBOX_E_NOT_SUPPORTED,
2839	tr("Resize completed notification is valid only for external framebuffers"));
2840
2841	/* Set the flag indicating that the resize has completed and display
2842	* data need to be updated. */
2843	bool f = ASMAtomicCmpXchgU32 (&maFramebuffers[aScreenId].u32ResizeStatus,
2844	ResizeStatus_UpdateDisplayData, ResizeStatus_InProgress);
2845	AssertRelease(f);NOREF(f);
2846
2847	return S_OK;
2848	}
2849
2850	STDMETHODIMP Display::CompleteVHWACommand(BYTE *pCommand)
2851	{
2852	#ifdef VBOX_WITH_VIDEOHWACCEL
2853	mpDrv->pVBVACallbacks->pfnVHWACommandCompleteAsynch(mpDrv->pVBVACallbacks, (PVBOXVHWACMD)pCommand);
2854	return S_OK;
2855	#else
2856	return E_NOTIMPL;
2857	#endif
2858	}
2859
2860	// private methods
2861	/////////////////////////////////////////////////////////////////////////////
2862
2863	/**
2864	* Helper to update the display information from the framebuffer.
2865	*
2866	* @thread EMT
2867	*/
2868	void Display::updateDisplayData(void)
2869	{
2870	LogFlowFunc (("\n"));
2871
2872	/* the driver might not have been constructed yet */
2873	if (!mpDrv)
2874	return;
2875
2876	#if DEBUG
2877	/*
2878	* Sanity check. Note that this method may be called on EMT after Console
2879	* has started the power down procedure (but before our #drvDestruct() is
2880	* called, in which case pVM will already be NULL but mpDrv will not). Since
2881	* we don't really need pVM to proceed, we avoid this check in the release
2882	* build to save some ms (necessary to construct SafeVMPtrQuiet) in this
2883	* time-critical method.
2884	*/
2885	Console::SafeVMPtrQuiet pVM (mParent);
2886	if (pVM.isOk())
2887	VM_ASSERT_EMT (pVM.raw());
2888	#endif
2889
2890	/* The method is only relevant to the primary framebuffer. */
2891	IFramebuffer *pFramebuffer = maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN].pFramebuffer;
2892
2893	if (pFramebuffer)
2894	{
2895	HRESULT rc;
2896	BYTE *address = 0;
2897	rc = pFramebuffer->COMGETTER(Address) (&address);
2898	AssertComRC (rc);
2899	ULONG bytesPerLine = 0;
2900	rc = pFramebuffer->COMGETTER(BytesPerLine) (&bytesPerLine);
2901	AssertComRC (rc);
2902	ULONG bitsPerPixel = 0;
2903	rc = pFramebuffer->COMGETTER(BitsPerPixel) (&bitsPerPixel);
2904	AssertComRC (rc);
2905	ULONG width = 0;
2906	rc = pFramebuffer->COMGETTER(Width) (&width);
2907	AssertComRC (rc);
2908	ULONG height = 0;
2909	rc = pFramebuffer->COMGETTER(Height) (&height);
2910	AssertComRC (rc);
2911
2912	mpDrv->IConnector.pu8Data = (uint8_t *) address;
2913	mpDrv->IConnector.cbScanline = bytesPerLine;
2914	mpDrv->IConnector.cBits = bitsPerPixel;
2915	mpDrv->IConnector.cx = width;
2916	mpDrv->IConnector.cy = height;
2917	}
2918	else
2919	{
2920	/* black hole */
2921	mpDrv->IConnector.pu8Data = NULL;
2922	mpDrv->IConnector.cbScanline = 0;
2923	mpDrv->IConnector.cBits = 0;
2924	mpDrv->IConnector.cx = 0;
2925	mpDrv->IConnector.cy = 0;
2926	}
2927	LogFlowFunc (("leave\n"));
2928	}
2929
2930	#ifdef VBOX_WITH_CRHGSMI
2931	void Display::setupCrHgsmiData(void)
2932	{
2933	VMMDev *pVMMDev = mParent->getVMMDev();
2934	Assert(pVMMDev);
2935	int rc = VERR_GENERAL_FAILURE;
2936	if (pVMMDev)
2937	rc = pVMMDev->hgcmHostSvcHandleCreate("VBoxSharedCrOpenGL", &mhCrOglSvc);
2938
2939	if (RT_SUCCESS(rc))
2940	{
2941	Assert(mhCrOglSvc);
2942	}
2943	else
2944	{
2945	mhCrOglSvc = NULL;
2946	}
2947	}
2948
2949	void Display::destructCrHgsmiData(void)
2950	{
2951	mhCrOglSvc = NULL;
2952	}
2953	#endif
2954
2955	/**
2956	* Changes the current frame buffer. Called on EMT to avoid both
2957	* race conditions and excessive locking.
2958	*
2959	* @note locks this object for writing
2960	* @thread EMT
2961	*/
2962	/* static */
2963	DECLCALLBACK(int) Display::changeFramebuffer (Display that, IFramebuffer aFB,
2964	unsigned uScreenId)
2965	{
2966	LogFlowFunc (("uScreenId = %d\n", uScreenId));
2967
2968	AssertReturn(that, VERR_INVALID_PARAMETER);
2969	AssertReturn(uScreenId < that->mcMonitors, VERR_INVALID_PARAMETER);
2970
2971	AutoCaller autoCaller(that);
2972	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2973
2974	AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
2975
2976	DISPLAYFBINFO *pDisplayFBInfo = &that->maFramebuffers[uScreenId];
2977	pDisplayFBInfo->pFramebuffer = aFB;
2978
2979	that->mParent->consoleVRDPServer()->SendResize ();
2980
2981	/* The driver might not have been constructed yet */
2982	if (that->mpDrv)
2983	{
2984	/* Setup the new framebuffer, the resize will lead to an updateDisplayData call. */
2985	DISPLAYFBINFO *pFBInfo = &that->maFramebuffers[uScreenId];
2986
2987	if (pFBInfo->fVBVAEnabled && pFBInfo->pu8FramebufferVRAM)
2988	{
2989	/* This display in VBVA mode. Resize it to the last guest resolution,
2990	* if it has been reported.
2991	*/
2992	that->handleDisplayResize(uScreenId, pFBInfo->u16BitsPerPixel,
2993	pFBInfo->pu8FramebufferVRAM,
2994	pFBInfo->u32LineSize,
2995	pFBInfo->w,
2996	pFBInfo->h,
2997	pFBInfo->flags);
2998	}
2999	else if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
3000	{
3001	/* VGA device mode, only for the primary screen. */
3002	that->handleDisplayResize(VBOX_VIDEO_PRIMARY_SCREEN, that->mLastBitsPerPixel,
3003	that->mLastAddress,
3004	that->mLastBytesPerLine,
3005	that->mLastWidth,
3006	that->mLastHeight,
3007	that->mLastFlags);
3008	}
3009	}
3010
3011	LogFlowFunc (("leave\n"));
3012	return VINF_SUCCESS;
3013	}
3014
3015	/**
3016	* Handle display resize event issued by the VGA device for the primary screen.
3017	*
3018	* @see PDMIDISPLAYCONNECTOR::pfnResize
3019	*/
3020	DECLCALLBACK(int) Display::displayResizeCallback(PPDMIDISPLAYCONNECTOR pInterface,
3021	uint32_t bpp, void *pvVRAM, uint32_t cbLine, uint32_t cx, uint32_t cy)
3022	{
3023	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3024
3025	LogFlowFunc (("bpp %d, pvVRAM %p, cbLine %d, cx %d, cy %d\n",
3026	bpp, pvVRAM, cbLine, cx, cy));
3027
3028	return pDrv->pDisplay->handleDisplayResize(VBOX_VIDEO_PRIMARY_SCREEN, bpp, pvVRAM, cbLine, cx, cy, VBVA_SCREEN_F_ACTIVE);
3029	}
3030
3031	/**
3032	* Handle display update.
3033	*
3034	* @see PDMIDISPLAYCONNECTOR::pfnUpdateRect
3035	*/
3036	DECLCALLBACK(void) Display::displayUpdateCallback(PPDMIDISPLAYCONNECTOR pInterface,
3037	uint32_t x, uint32_t y, uint32_t cx, uint32_t cy)
3038	{
3039	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3040
3041	#ifdef DEBUG_sunlover
3042	LogFlowFunc (("mfVideoAccelEnabled = %d, %d,%d %dx%d\n",
3043	pDrv->pDisplay->mfVideoAccelEnabled, x, y, cx, cy));
3044	#endif /* DEBUG_sunlover */
3045
3046	/* This call does update regardless of VBVA status.
3047	* But in VBVA mode this is called only as result of
3048	* pfnUpdateDisplayAll in the VGA device.
3049	*/
3050
3051	pDrv->pDisplay->handleDisplayUpdate(VBOX_VIDEO_PRIMARY_SCREEN, x, y, cx, cy);
3052	}
3053
3054	/**
3055	* Periodic display refresh callback.
3056	*
3057	* @see PDMIDISPLAYCONNECTOR::pfnRefresh
3058	*/
3059	DECLCALLBACK(void) Display::displayRefreshCallback(PPDMIDISPLAYCONNECTOR pInterface)
3060	{
3061	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3062
3063	#ifdef DEBUG_sunlover
3064	STAM_PROFILE_START(&StatDisplayRefresh, a);
3065	#endif /* DEBUG_sunlover */
3066
3067	#ifdef DEBUG_sunlover_2
3068	LogFlowFunc (("pDrv->pDisplay->mfVideoAccelEnabled = %d\n",
3069	pDrv->pDisplay->mfVideoAccelEnabled));
3070	#endif /* DEBUG_sunlover_2 */
3071
3072	Display *pDisplay = pDrv->pDisplay;
3073	bool fNoUpdate = false; /* Do not update the display if any of the framebuffers is being resized. */
3074	unsigned uScreenId;
3075
3076	for (uScreenId = 0; uScreenId < pDisplay->mcMonitors; uScreenId++)
3077	{
3078	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[uScreenId];
3079
3080	/* Check the resize status. The status can be checked normally because
3081	* the status affects only the EMT.
3082	*/
3083	uint32_t u32ResizeStatus = pFBInfo->u32ResizeStatus;
3084
3085	if (u32ResizeStatus == ResizeStatus_UpdateDisplayData)
3086	{
3087	LogFlowFunc (("ResizeStatus_UpdateDisplayData %d\n", uScreenId));
3088	fNoUpdate = true; /* Always set it here, because pfnUpdateDisplayAll can cause a new resize. */
3089	/* The framebuffer was resized and display data need to be updated. */
3090	pDisplay->handleResizeCompletedEMT ();
3091	if (pFBInfo->u32ResizeStatus != ResizeStatus_Void)
3092	{
3093	/* The resize status could be not Void here because a pending resize is issued. */
3094	continue;
3095	}
3096	/* Continue with normal processing because the status here is ResizeStatus_Void.
3097	* Repaint all displays because VM continued to run during the framebuffer resize.
3098	*/
3099	pDisplay->InvalidateAndUpdateEMT(pDisplay);
3100	}
3101	else if (u32ResizeStatus == ResizeStatus_InProgress)
3102	{
3103	/* The framebuffer is being resized. Do not call the VGA device back. Immediately return. */
3104	LogFlowFunc (("ResizeStatus_InProcess\n"));
3105	fNoUpdate = true;
3106	continue;
3107	}
3108	}
3109
3110	if (!fNoUpdate)
3111	{
3112	int rc = pDisplay->videoAccelRefreshProcess();
3113
3114	if (rc != VINF_TRY_AGAIN) /* Means 'do nothing' here. */
3115	{
3116	if (rc == VWRN_INVALID_STATE)
3117	{
3118	/* No VBVA do a display update. */
3119	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN];
3120	if (!pFBInfo->pFramebuffer.isNull() && pFBInfo->u32ResizeStatus == ResizeStatus_Void)
3121	{
3122	Assert(pDrv->IConnector.pu8Data);
3123	pDisplay->vbvaLock();
3124	pDrv->pUpPort->pfnUpdateDisplay(pDrv->pUpPort);
3125	pDisplay->vbvaUnlock();
3126	}
3127	}
3128
3129	/* Inform the VRDP server that the current display update sequence is
3130	* completed. At this moment the framebuffer memory contains a definite
3131	* image, that is synchronized with the orders already sent to VRDP client.
3132	* The server can now process redraw requests from clients or initial
3133	* fullscreen updates for new clients.
3134	*/
3135	for (uScreenId = 0; uScreenId < pDisplay->mcMonitors; uScreenId++)
3136	{
3137	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[uScreenId];
3138
3139	if (!pFBInfo->pFramebuffer.isNull() && pFBInfo->u32ResizeStatus == ResizeStatus_Void)
3140	{
3141	Assert (pDisplay->mParent && pDisplay->mParent->consoleVRDPServer());
3142	pDisplay->mParent->consoleVRDPServer()->SendUpdate (uScreenId, NULL, 0);
3143	}
3144	}
3145	}
3146	}
3147
3148	#ifdef DEBUG_sunlover
3149	STAM_PROFILE_STOP(&StatDisplayRefresh, a);
3150	#endif /* DEBUG_sunlover */
3151	#ifdef DEBUG_sunlover_2
3152	LogFlowFunc (("leave\n"));
3153	#endif /* DEBUG_sunlover_2 */
3154	}
3155
3156	/**
3157	* Reset notification
3158	*
3159	* @see PDMIDISPLAYCONNECTOR::pfnReset
3160	*/
3161	DECLCALLBACK(void) Display::displayResetCallback(PPDMIDISPLAYCONNECTOR pInterface)
3162	{
3163	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3164
3165	LogFlowFunc (("\n"));
3166
3167	/* Disable VBVA mode. */
3168	pDrv->pDisplay->VideoAccelEnable (false, NULL);
3169	}
3170
3171	/**
3172	* LFBModeChange notification
3173	*
3174	* @see PDMIDISPLAYCONNECTOR::pfnLFBModeChange
3175	*/
3176	DECLCALLBACK(void) Display::displayLFBModeChangeCallback(PPDMIDISPLAYCONNECTOR pInterface, bool fEnabled)
3177	{
3178	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3179
3180	LogFlowFunc (("fEnabled=%d\n", fEnabled));
3181
3182	NOREF(fEnabled);
3183
3184	/* Disable VBVA mode in any case. The guest driver reenables VBVA mode if necessary. */
3185	/* The LFBModeChange function is called under DevVGA lock. Postpone disabling VBVA, do it in the refresh timer. */
3186	ASMAtomicWriteU32(&pDrv->pDisplay->mfu32PendingVideoAccelDisable, true);
3187	}
3188
3189	/**
3190	* Adapter information change notification.
3191	*
3192	* @see PDMIDISPLAYCONNECTOR::pfnProcessAdapterData
3193	*/
3194	DECLCALLBACK(void) Display::displayProcessAdapterDataCallback(PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM, uint32_t u32VRAMSize)
3195	{
3196	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3197
3198	if (pvVRAM == NULL)
3199	{
3200	unsigned i;
3201	for (i = 0; i < pDrv->pDisplay->mcMonitors; i++)
3202	{
3203	DISPLAYFBINFO *pFBInfo = &pDrv->pDisplay->maFramebuffers[i];
3204
3205	pFBInfo->u32Offset = 0;
3206	pFBInfo->u32MaxFramebufferSize = 0;
3207	pFBInfo->u32InformationSize = 0;
3208	}
3209	}
3210	#ifndef VBOX_WITH_HGSMI
3211	else
3212	{
3213	uint8_t pu8 = (uint8_t )pvVRAM;
3214	pu8 += u32VRAMSize - VBOX_VIDEO_ADAPTER_INFORMATION_SIZE;
3215
3216	// @todo
3217	uint8_t *pu8End = pu8 + VBOX_VIDEO_ADAPTER_INFORMATION_SIZE;
3218
3219	VBOXVIDEOINFOHDR *pHdr;
3220
3221	for (;;)
3222	{
3223	pHdr = (VBOXVIDEOINFOHDR *)pu8;
3224	pu8 += sizeof (VBOXVIDEOINFOHDR);
3225
3226	if (pu8 >= pu8End)
3227	{
3228	LogRel(("VBoxVideo: Guest adapter information overflow!!!\n"));
3229	break;
3230	}
3231
3232	if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_DISPLAY)
3233	{
3234	if (pHdr->u16Length != sizeof (VBOXVIDEOINFODISPLAY))
3235	{
3236	LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "DISPLAY", pHdr->u16Length));
3237	break;
3238	}
3239
3240	VBOXVIDEOINFODISPLAY pDisplay = (VBOXVIDEOINFODISPLAY )pu8;
3241
3242	if (pDisplay->u32Index >= pDrv->pDisplay->mcMonitors)
3243	{
3244	LogRel(("VBoxVideo: Guest adapter information invalid display index %d!!!\n", pDisplay->u32Index));
3245	break;
3246	}
3247
3248	DISPLAYFBINFO *pFBInfo = &pDrv->pDisplay->maFramebuffers[pDisplay->u32Index];
3249
3250	pFBInfo->u32Offset = pDisplay->u32Offset;
3251	pFBInfo->u32MaxFramebufferSize = pDisplay->u32FramebufferSize;
3252	pFBInfo->u32InformationSize = pDisplay->u32InformationSize;
3253
3254	LogFlow(("VBOX_VIDEO_INFO_TYPE_DISPLAY: %d: at 0x%08X, size 0x%08X, info 0x%08X\n", pDisplay->u32Index, pDisplay->u32Offset, pDisplay->u32FramebufferSize, pDisplay->u32InformationSize));
3255	}
3256	else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_QUERY_CONF32)
3257	{
3258	if (pHdr->u16Length != sizeof (VBOXVIDEOINFOQUERYCONF32))
3259	{
3260	LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "CONF32", pHdr->u16Length));
3261	break;
3262	}
3263
3264	VBOXVIDEOINFOQUERYCONF32 pConf32 = (VBOXVIDEOINFOQUERYCONF32 )pu8;
3265
3266	switch (pConf32->u32Index)
3267	{
3268	case VBOX_VIDEO_QCI32_MONITOR_COUNT:
3269	{
3270	pConf32->u32Value = pDrv->pDisplay->mcMonitors;
3271	} break;
3272
3273	case VBOX_VIDEO_QCI32_OFFSCREEN_HEAP_SIZE:
3274	{
3275	/* @todo make configurable. */
3276	pConf32->u32Value = _1M;
3277	} break;
3278
3279	default:
3280	LogRel(("VBoxVideo: CONF32 %d not supported!!! Skipping.\n", pConf32->u32Index));
3281	}
3282	}
3283	else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_END)
3284	{
3285	if (pHdr->u16Length != 0)
3286	{
3287	LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "END", pHdr->u16Length));
3288	break;
3289	}
3290
3291	break;
3292	}
3293	else if (pHdr->u8Type != VBOX_VIDEO_INFO_TYPE_NV_HEAP) /** @todo why is Additions/WINNT/Graphics/Miniport/VBoxVideo.cpp pushing this to us? */
3294	{
3295	LogRel(("Guest adapter information contains unsupported type %d. The block has been skipped.\n", pHdr->u8Type));
3296	}
3297
3298	pu8 += pHdr->u16Length;
3299	}
3300	}
3301	#endif /* !VBOX_WITH_HGSMI */
3302	}
3303
3304	/**
3305	* Display information change notification.
3306	*
3307	* @see PDMIDISPLAYCONNECTOR::pfnProcessDisplayData
3308	*/
3309	DECLCALLBACK(void) Display::displayProcessDisplayDataCallback(PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM, unsigned uScreenId)
3310	{
3311	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3312
3313	if (uScreenId >= pDrv->pDisplay->mcMonitors)
3314	{
3315	LogRel(("VBoxVideo: Guest display information invalid display index %d!!!\n", uScreenId));
3316	return;
3317	}
3318
3319	/* Get the display information structure. */
3320	DISPLAYFBINFO *pFBInfo = &pDrv->pDisplay->maFramebuffers[uScreenId];
3321
3322	uint8_t pu8 = (uint8_t )pvVRAM;
3323	pu8 += pFBInfo->u32Offset + pFBInfo->u32MaxFramebufferSize;
3324
3325	// @todo
3326	uint8_t *pu8End = pu8 + pFBInfo->u32InformationSize;
3327
3328	VBOXVIDEOINFOHDR *pHdr;
3329
3330	for (;;)
3331	{
3332	pHdr = (VBOXVIDEOINFOHDR *)pu8;
3333	pu8 += sizeof (VBOXVIDEOINFOHDR);
3334
3335	if (pu8 >= pu8End)
3336	{
3337	LogRel(("VBoxVideo: Guest display information overflow!!!\n"));
3338	break;
3339	}
3340
3341	if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_SCREEN)
3342	{
3343	if (pHdr->u16Length != sizeof (VBOXVIDEOINFOSCREEN))
3344	{
3345	LogRel(("VBoxVideo: Guest display information %s invalid length %d!!!\n", "SCREEN", pHdr->u16Length));
3346	break;
3347	}
3348
3349	VBOXVIDEOINFOSCREEN pScreen = (VBOXVIDEOINFOSCREEN )pu8;
3350
3351	pFBInfo->xOrigin = pScreen->xOrigin;
3352	pFBInfo->yOrigin = pScreen->yOrigin;
3353
3354	pFBInfo->w = pScreen->u16Width;
3355	pFBInfo->h = pScreen->u16Height;
3356
3357	LogFlow(("VBOX_VIDEO_INFO_TYPE_SCREEN: (%p) %d: at %d,%d, linesize 0x%X, size %dx%d, bpp %d, flags 0x%02X\n",
3358	pHdr, uScreenId, pScreen->xOrigin, pScreen->yOrigin, pScreen->u32LineSize, pScreen->u16Width, pScreen->u16Height, pScreen->bitsPerPixel, pScreen->u8Flags));
3359
3360	if (uScreenId != VBOX_VIDEO_PRIMARY_SCREEN)
3361	{
3362	/* Primary screen resize is initiated by the VGA device. */
3363	pDrv->pDisplay->handleDisplayResize(uScreenId, pScreen->bitsPerPixel, (uint8_t *)pvVRAM + pFBInfo->u32Offset, pScreen->u32LineSize, pScreen->u16Width, pScreen->u16Height, VBVA_SCREEN_F_ACTIVE);
3364	}
3365	}
3366	else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_END)
3367	{
3368	if (pHdr->u16Length != 0)
3369	{
3370	LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "END", pHdr->u16Length));
3371	break;
3372	}
3373
3374	break;
3375	}
3376	else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_HOST_EVENTS)
3377	{
3378	if (pHdr->u16Length != sizeof (VBOXVIDEOINFOHOSTEVENTS))
3379	{
3380	LogRel(("VBoxVideo: Guest display information %s invalid length %d!!!\n", "HOST_EVENTS", pHdr->u16Length));
3381	break;
3382	}
3383
3384	VBOXVIDEOINFOHOSTEVENTS pHostEvents = (VBOXVIDEOINFOHOSTEVENTS )pu8;
3385
3386	pFBInfo->pHostEvents = pHostEvents;
3387
3388	LogFlow(("VBOX_VIDEO_INFO_TYPE_HOSTEVENTS: (%p)\n",
3389	pHostEvents));
3390	}
3391	else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_LINK)
3392	{
3393	if (pHdr->u16Length != sizeof (VBOXVIDEOINFOLINK))
3394	{
3395	LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "LINK", pHdr->u16Length));
3396	break;
3397	}
3398
3399	VBOXVIDEOINFOLINK pLink = (VBOXVIDEOINFOLINK )pu8;
3400	pu8 += pLink->i32Offset;
3401	}
3402	else
3403	{
3404	LogRel(("Guest display information contains unsupported type %d\n", pHdr->u8Type));
3405	}
3406
3407	pu8 += pHdr->u16Length;
3408	}
3409	}
3410
3411	#ifdef VBOX_WITH_VIDEOHWACCEL
3412
3413	void Display::handleVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand)
3414	{
3415	unsigned id = (unsigned)pCommand->iDisplay;
3416	int rc = VINF_SUCCESS;
3417	if (id < mcMonitors)
3418	{
3419	IFramebuffer *pFramebuffer = maFramebuffers[id].pFramebuffer;
3420	#ifdef DEBUG_misha
3421	Assert (pFramebuffer);
3422	#endif
3423
3424	if (pFramebuffer != NULL)
3425	{
3426	HRESULT hr = pFramebuffer->ProcessVHWACommand((BYTE*)pCommand);
3427	if (FAILED(hr))
3428	{
3429	rc = (hr == E_NOTIMPL) ? VERR_NOT_IMPLEMENTED : VERR_GENERAL_FAILURE;
3430	}
3431	}
3432	else
3433	{
3434	rc = VERR_NOT_IMPLEMENTED;
3435	}
3436	}
3437	else
3438	{
3439	rc = VERR_INVALID_PARAMETER;
3440	}
3441
3442	if (RT_FAILURE(rc))
3443	{
3444	/* tell the guest the command is complete */
3445	pCommand->Flags &= (~VBOXVHWACMD_FLAG_HG_ASYNCH);
3446	pCommand->rc = rc;
3447	}
3448	}
3449
3450	DECLCALLBACK(void) Display::displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand)
3451	{
3452	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3453
3454	pDrv->pDisplay->handleVHWACommandProcess(pInterface, pCommand);
3455	}
3456	#endif
3457
3458	#ifdef VBOX_WITH_CRHGSMI
3459	void Display::handleCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam)
3460	{
3461	mpDrv->pVBVACallbacks->pfnCrHgsmiCommandCompleteAsync(mpDrv->pVBVACallbacks, (PVBOXVDMACMD_CHROMIUM_CMD)pParam->u.pointer.addr, result);
3462	}
3463
3464	void Display::handleCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam)
3465	{
3466	mpDrv->pVBVACallbacks->pfnCrHgsmiControlCompleteAsync(mpDrv->pVBVACallbacks, (PVBOXVDMACMD_CHROMIUM_CTL)pParam->u.pointer.addr, result);
3467	}
3468
3469	void Display::handleCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd)
3470	{
3471	int rc = VERR_INVALID_FUNCTION;
3472	VBOXHGCMSVCPARM parm;
3473	parm.type = VBOX_HGCM_SVC_PARM_PTR;
3474	parm.u.pointer.addr = pCmd;
3475	parm.u.pointer.size = 0;
3476
3477	if (mhCrOglSvc)
3478	{
3479	VMMDev *pVMMDev = mParent->getVMMDev();
3480	if (pVMMDev)
3481	{
3482	rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_CRHGSMI_CMD, &parm, Display::displayCrHgsmiCommandCompletion, this);
3483	AssertRC(rc);
3484	if (RT_SUCCESS(rc))
3485	return;
3486	}
3487	else
3488	rc = VERR_INVALID_STATE;
3489	}
3490
3491	/* we are here because something went wrong with command processing, complete it */
3492	handleCrHgsmiCommandCompletion(rc, SHCRGL_HOST_FN_CRHGSMI_CMD, &parm);
3493	}
3494
3495	void Display::handleCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCtl)
3496	{
3497	int rc = VERR_INVALID_FUNCTION;
3498	VBOXHGCMSVCPARM parm;
3499	parm.type = VBOX_HGCM_SVC_PARM_PTR;
3500	parm.u.pointer.addr = pCtl;
3501	parm.u.pointer.size = 0;
3502
3503	if (mhCrOglSvc)
3504	{
3505	VMMDev *pVMMDev = mParent->getVMMDev();
3506	if (pVMMDev)
3507	{
3508	rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_CRHGSMI_CTL, &parm, Display::displayCrHgsmiControlCompletion, this);
3509	AssertRC(rc);
3510	if (RT_SUCCESS(rc))
3511	return;
3512	}
3513	else
3514	rc = VERR_INVALID_STATE;
3515	}
3516
3517	/* we are here because something went wrong with command processing, complete it */
3518	handleCrHgsmiControlCompletion(rc, SHCRGL_HOST_FN_CRHGSMI_CTL, &parm);
3519	}
3520
3521	DECLCALLBACK(void) Display::displayCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd)
3522	{
3523	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3524
3525	pDrv->pDisplay->handleCrHgsmiCommandProcess(pInterface, pCmd);
3526	}
3527
3528	DECLCALLBACK(void) Display::displayCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCmd)
3529	{
3530	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3531
3532	pDrv->pDisplay->handleCrHgsmiControlProcess(pInterface, pCmd);
3533	}
3534
3535	DECLCALLBACK(void) Display::displayCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext)
3536	{
3537	Display pDisplay = (Display )pvContext;
3538	pDisplay->handleCrHgsmiCommandCompletion(result, u32Function, pParam);
3539	}
3540
3541	DECLCALLBACK(void) Display::displayCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext)
3542	{
3543	Display pDisplay = (Display )pvContext;
3544	pDisplay->handleCrHgsmiControlCompletion(result, u32Function, pParam);
3545	}
3546	#endif
3547
3548
3549	#ifdef VBOX_WITH_HGSMI
3550	DECLCALLBACK(int) Display::displayVBVAEnable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, PVBVAHOSTFLAGS pHostFlags)
3551	{
3552	LogFlowFunc(("uScreenId %d\n", uScreenId));
3553
3554	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3555	Display *pThis = pDrv->pDisplay;
3556
3557	pThis->maFramebuffers[uScreenId].fVBVAEnabled = true;
3558	pThis->maFramebuffers[uScreenId].pVBVAHostFlags = pHostFlags;
3559
3560	vbvaSetMemoryFlagsHGSMI(uScreenId, pThis->mfu32SupportedOrders, pThis->mfVideoAccelVRDP, &pThis->maFramebuffers[uScreenId]);
3561
3562	return VINF_SUCCESS;
3563	}
3564
3565	DECLCALLBACK(void) Display::displayVBVADisable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId)
3566	{
3567	LogFlowFunc(("uScreenId %d\n", uScreenId));
3568
3569	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3570	Display *pThis = pDrv->pDisplay;
3571
3572	DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[uScreenId];
3573
3574	pFBInfo->fVBVAEnabled = false;
3575
3576	vbvaSetMemoryFlagsHGSMI(uScreenId, 0, false, pFBInfo);
3577
3578	pFBInfo->pVBVAHostFlags = NULL;
3579
3580	pFBInfo->u32Offset = 0; /* Not used in HGSMI. */
3581	pFBInfo->u32MaxFramebufferSize = 0; /* Not used in HGSMI. */
3582	pFBInfo->u32InformationSize = 0; /* Not used in HGSMI. */
3583
3584	pFBInfo->xOrigin = 0;
3585	pFBInfo->yOrigin = 0;
3586
3587	pFBInfo->w = 0;
3588	pFBInfo->h = 0;
3589
3590	pFBInfo->u16BitsPerPixel = 0;
3591	pFBInfo->pu8FramebufferVRAM = NULL;
3592	pFBInfo->u32LineSize = 0;
3593	}
3594
3595	DECLCALLBACK(void) Display::displayVBVAUpdateBegin(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId)
3596	{
3597	LogFlowFunc(("uScreenId %d\n", uScreenId));
3598
3599	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3600	Display *pThis = pDrv->pDisplay;
3601	DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[uScreenId];
3602
3603	if (ASMAtomicReadU32(&pThis->mu32UpdateVBVAFlags) > 0)
3604	{
3605	vbvaSetMemoryFlagsAllHGSMI(pThis->mfu32SupportedOrders, pThis->mfVideoAccelVRDP, pThis->maFramebuffers, pThis->mcMonitors);
3606	ASMAtomicDecU32(&pThis->mu32UpdateVBVAFlags);
3607	}
3608
3609	if (RT_LIKELY(pFBInfo->u32ResizeStatus == ResizeStatus_Void))
3610	{
3611	if (RT_UNLIKELY(pFBInfo->cVBVASkipUpdate != 0))
3612	{
3613	/* Some updates were skipped. Note: displayVBVAUpdate* callbacks are called
3614	* under display device lock, so thread safe.
3615	*/
3616	pFBInfo->cVBVASkipUpdate = 0;
3617	pThis->handleDisplayUpdate(uScreenId, pFBInfo->vbvaSkippedRect.xLeft - pFBInfo->xOrigin,
3618	pFBInfo->vbvaSkippedRect.yTop - pFBInfo->yOrigin,
3619	pFBInfo->vbvaSkippedRect.xRight - pFBInfo->vbvaSkippedRect.xLeft,
3620	pFBInfo->vbvaSkippedRect.yBottom - pFBInfo->vbvaSkippedRect.yTop);
3621	}
3622	}
3623	else
3624	{
3625	/* The framebuffer is being resized. */
3626	pFBInfo->cVBVASkipUpdate++;
3627	}
3628	}
3629
3630	DECLCALLBACK(void) Display::displayVBVAUpdateProcess(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, const PVBVACMDHDR pCmd, size_t cbCmd)
3631	{
3632	LogFlowFunc(("uScreenId %d pCmd %p cbCmd %d, @%d,%d %dx%d\n", uScreenId, pCmd, cbCmd, pCmd->x, pCmd->y, pCmd->w, pCmd->h));
3633
3634	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3635	Display *pThis = pDrv->pDisplay;
3636	DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[uScreenId];
3637
3638	if (RT_LIKELY(pFBInfo->cVBVASkipUpdate == 0))
3639	{
3640	if (pFBInfo->fDefaultFormat)
3641	{
3642	/* Make sure that framebuffer contains the same image as the guest VRAM. */
3643	if ( uScreenId == VBOX_VIDEO_PRIMARY_SCREEN
3644	&& !pFBInfo->pFramebuffer.isNull()
3645	&& !pFBInfo->fDisabled)
3646	{
3647	pDrv->pUpPort->pfnUpdateDisplayRect (pDrv->pUpPort, pCmd->x, pCmd->y, pCmd->w, pCmd->h);
3648	}
3649	else if ( !pFBInfo->pFramebuffer.isNull()
3650	&& !(pFBInfo->fDisabled))
3651	{
3652	/* Render VRAM content to the framebuffer. */
3653	BYTE *address = NULL;
3654	HRESULT hrc = pFBInfo->pFramebuffer->COMGETTER(Address) (&address);
3655	if (SUCCEEDED(hrc) && address != NULL)
3656	{
3657	uint32_t width = pCmd->w;
3658	uint32_t height = pCmd->h;
3659
3660	const uint8_t *pu8Src = pFBInfo->pu8FramebufferVRAM;
3661	int32_t xSrc = pCmd->x - pFBInfo->xOrigin;
3662	int32_t ySrc = pCmd->y - pFBInfo->yOrigin;
3663	uint32_t u32SrcWidth = pFBInfo->w;
3664	uint32_t u32SrcHeight = pFBInfo->h;
3665	uint32_t u32SrcLineSize = pFBInfo->u32LineSize;
3666	uint32_t u32SrcBitsPerPixel = pFBInfo->u16BitsPerPixel;
3667
3668	uint8_t *pu8Dst = address;
3669	int32_t xDst = xSrc;
3670	int32_t yDst = ySrc;
3671	uint32_t u32DstWidth = u32SrcWidth;
3672	uint32_t u32DstHeight = u32SrcHeight;
3673	uint32_t u32DstLineSize = u32DstWidth * 4;
3674	uint32_t u32DstBitsPerPixel = 32;
3675
3676	pDrv->pUpPort->pfnCopyRect(pDrv->pUpPort,
3677	width, height,
3678	pu8Src,
3679	xSrc, ySrc,
3680	u32SrcWidth, u32SrcHeight,
3681	u32SrcLineSize, u32SrcBitsPerPixel,
3682	pu8Dst,
3683	xDst, yDst,
3684	u32DstWidth, u32DstHeight,
3685	u32DstLineSize, u32DstBitsPerPixel);
3686	}
3687	}
3688	}
3689
3690	VBVACMDHDR hdrSaved = *pCmd;
3691
3692	VBVACMDHDR pHdrUnconst = (VBVACMDHDR )pCmd;
3693
3694	pHdrUnconst->x -= (int16_t)pFBInfo->xOrigin;
3695	pHdrUnconst->y -= (int16_t)pFBInfo->yOrigin;
3696
3697	/* @todo new SendUpdate entry which can get a separate cmd header or coords. */
3698	pThis->mParent->consoleVRDPServer()->SendUpdate (uScreenId, pCmd, cbCmd);
3699
3700	*pHdrUnconst = hdrSaved;
3701	}
3702	}
3703
3704	DECLCALLBACK(void) Display::displayVBVAUpdateEnd(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, int32_t x, int32_t y, uint32_t cx, uint32_t cy)
3705	{
3706	LogFlowFunc(("uScreenId %d %d,%d %dx%d\n", uScreenId, x, y, cx, cy));
3707
3708	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3709	Display *pThis = pDrv->pDisplay;
3710	DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[uScreenId];
3711
3712	/* @todo handleFramebufferUpdate (uScreenId,
3713	* x - pThis->maFramebuffers[uScreenId].xOrigin,
3714	* y - pThis->maFramebuffers[uScreenId].yOrigin,
3715	* cx, cy);
3716	*/
3717	if (RT_LIKELY(pFBInfo->cVBVASkipUpdate == 0))
3718	{
3719	pThis->handleDisplayUpdate(uScreenId, x - pFBInfo->xOrigin, y - pFBInfo->yOrigin, cx, cy);
3720	}
3721	else
3722	{
3723	/* Save the updated rectangle. */
3724	int32_t xRight = x + cx;
3725	int32_t yBottom = y + cy;
3726
3727	if (pFBInfo->cVBVASkipUpdate == 1)
3728	{
3729	pFBInfo->vbvaSkippedRect.xLeft = x;
3730	pFBInfo->vbvaSkippedRect.yTop = y;
3731	pFBInfo->vbvaSkippedRect.xRight = xRight;
3732	pFBInfo->vbvaSkippedRect.yBottom = yBottom;
3733	}
3734	else
3735	{
3736	if (pFBInfo->vbvaSkippedRect.xLeft > x)
3737	{
3738	pFBInfo->vbvaSkippedRect.xLeft = x;
3739	}
3740	if (pFBInfo->vbvaSkippedRect.yTop > y)
3741	{
3742	pFBInfo->vbvaSkippedRect.yTop = y;
3743	}
3744	if (pFBInfo->vbvaSkippedRect.xRight < xRight)
3745	{
3746	pFBInfo->vbvaSkippedRect.xRight = xRight;
3747	}
3748	if (pFBInfo->vbvaSkippedRect.yBottom < yBottom)
3749	{
3750	pFBInfo->vbvaSkippedRect.yBottom = yBottom;
3751	}
3752	}
3753	}
3754	}
3755
3756	DECLCALLBACK(int) Display::displayVBVAResize(PPDMIDISPLAYCONNECTOR pInterface, const PVBVAINFOVIEW pView, const PVBVAINFOSCREEN pScreen, void *pvVRAM)
3757	{
3758	LogFlowFunc(("pScreen %p, pvVRAM %p\n", pScreen, pvVRAM));
3759
3760	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3761	Display *pThis = pDrv->pDisplay;
3762
3763	DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[pScreen->u32ViewIndex];
3764
3765	if (pScreen->u16Flags & VBVA_SCREEN_F_DISABLED)
3766	{
3767	pFBInfo->fDisabled = true;
3768	pFBInfo->flags = pScreen->u16Flags;
3769
3770	/* Temporary: ask framebuffer to resize using a default format. The framebuffer will be black. */
3771	pThis->handleDisplayResize(pScreen->u32ViewIndex, 0,
3772	(uint8_t *)NULL,
3773	pScreen->u32LineSize, pScreen->u32Width,
3774	pScreen->u32Height, pScreen->u16Flags);
3775
3776	fireGuestMonitorChangedEvent(pThis->mParent->getEventSource(),
3777	GuestMonitorChangedEventType_Disabled,
3778	pScreen->u32ViewIndex,
3779	0, 0, 0, 0);
3780	return VINF_SUCCESS;
3781	}
3782
3783	bool fResize = pFBInfo->fDisabled; /* If display was disabled, do a resize, because the framebuffer was changed. */
3784
3785	if (pFBInfo->fDisabled)
3786	{
3787	pFBInfo->fDisabled = false;
3788	fireGuestMonitorChangedEvent(pThis->mParent->getEventSource(),
3789	GuestMonitorChangedEventType_Enabled,
3790	pScreen->u32ViewIndex,
3791	pScreen->i32OriginX, pScreen->i32OriginY,
3792	pScreen->u32Width, pScreen->u32Height);
3793	if (pFBInfo->pFramebuffer.isNull())
3794	{
3795	/* @todo If no framebuffer, remember the resize parameters to issue a requestResize later. */
3796	return VINF_SUCCESS;
3797	}
3798	/* If the framebuffer already set for the screen, do a regular resize. */
3799	}
3800
3801	/* Check if this is a real resize or a notification about the screen origin.
3802	* The guest uses this VBVAResize call for both.
3803	*/
3804	fResize = fResize
3805	\|\| pFBInfo->u16BitsPerPixel != pScreen->u16BitsPerPixel
3806	\|\| pFBInfo->pu8FramebufferVRAM != (uint8_t *)pvVRAM + pScreen->u32StartOffset
3807	\|\| pFBInfo->u32LineSize != pScreen->u32LineSize
3808	\|\| pFBInfo->w != pScreen->u32Width
3809	\|\| pFBInfo->h != pScreen->u32Height;
3810
3811	bool fNewOrigin = pFBInfo->xOrigin != pScreen->i32OriginX
3812	\|\| pFBInfo->yOrigin != pScreen->i32OriginY;
3813
3814	pFBInfo->u32Offset = pView->u32ViewOffset; /* Not used in HGSMI. */
3815	pFBInfo->u32MaxFramebufferSize = pView->u32MaxScreenSize; /* Not used in HGSMI. */
3816	pFBInfo->u32InformationSize = 0; /* Not used in HGSMI. */
3817
3818	pFBInfo->xOrigin = pScreen->i32OriginX;
3819	pFBInfo->yOrigin = pScreen->i32OriginY;
3820
3821	pFBInfo->w = pScreen->u32Width;
3822	pFBInfo->h = pScreen->u32Height;
3823
3824	pFBInfo->u16BitsPerPixel = pScreen->u16BitsPerPixel;
3825	pFBInfo->pu8FramebufferVRAM = (uint8_t *)pvVRAM + pScreen->u32StartOffset;
3826	pFBInfo->u32LineSize = pScreen->u32LineSize;
3827
3828	pFBInfo->flags = pScreen->u16Flags;
3829
3830	if (fNewOrigin)
3831	{
3832	fireGuestMonitorChangedEvent(pThis->mParent->getEventSource(),
3833	GuestMonitorChangedEventType_NewOrigin,
3834	pScreen->u32ViewIndex,
3835	pScreen->i32OriginX, pScreen->i32OriginY,
3836	0, 0);
3837	}
3838
3839	#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
3840	if (fNewOrigin && !fResize)
3841	{
3842	BOOL is3denabled;
3843	pThis->mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
3844
3845	if (is3denabled)
3846	{
3847	VBOXHGCMSVCPARM parm;
3848
3849	parm.type = VBOX_HGCM_SVC_PARM_32BIT;
3850	parm.u.uint32 = pScreen->u32ViewIndex;
3851
3852	VMMDev *pVMMDev = pThis->mParent->getVMMDev();
3853
3854	if (pVMMDev)
3855	pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SCREEN_CHANGED, SHCRGL_CPARMS_SCREEN_CHANGED, &parm);
3856	}
3857	}
3858	#endif /* VBOX_WITH_CROGL */
3859
3860	if (!fResize)
3861	{
3862	/* No parameters of the framebuffer have actually changed. */
3863	if (fNewOrigin)
3864	{
3865	/* VRDP server still need this notification. */
3866	LogFlowFunc (("Calling VRDP\n"));
3867	pThis->mParent->consoleVRDPServer()->SendResize();
3868	}
3869	return VINF_SUCCESS;
3870	}
3871
3872	return pThis->handleDisplayResize(pScreen->u32ViewIndex, pScreen->u16BitsPerPixel,
3873	(uint8_t *)pvVRAM + pScreen->u32StartOffset,
3874	pScreen->u32LineSize, pScreen->u32Width, pScreen->u32Height, pScreen->u16Flags);
3875	}
3876
3877	DECLCALLBACK(int) Display::displayVBVAMousePointerShape(PPDMIDISPLAYCONNECTOR pInterface, bool fVisible, bool fAlpha,
3878	uint32_t xHot, uint32_t yHot,
3879	uint32_t cx, uint32_t cy,
3880	const void *pvShape)
3881	{
3882	LogFlowFunc(("\n"));
3883
3884	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3885	Display *pThis = pDrv->pDisplay;
3886
3887	size_t cbShapeSize = 0;
3888
3889	if (pvShape)
3890	{
3891	cbShapeSize = (cx + 7) / 8 * cy; /* size of the AND mask */
3892	cbShapeSize = ((cbShapeSize + 3) & ~3) + cx * 4 * cy; /* + gap + size of the XOR mask */
3893	}
3894	com::SafeArray<BYTE> shapeData(cbShapeSize);
3895
3896	if (pvShape)
3897	::memcpy(shapeData.raw(), pvShape, cbShapeSize);
3898
3899	/* Tell the console about it */
3900	pDrv->pDisplay->mParent->onMousePointerShapeChange(fVisible, fAlpha,
3901	xHot, yHot, cx, cy, ComSafeArrayAsInParam(shapeData));
3902
3903	return VINF_SUCCESS;
3904	}
3905	#endif /* VBOX_WITH_HGSMI */
3906
3907	/**
3908	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
3909	*/
3910	DECLCALLBACK(void ) Display::drvQueryInterface(PPDMIBASE pInterface, const char pszIID)
3911	{
3912	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
3913	PDRVMAINDISPLAY pDrv = PDMINS_2_DATA(pDrvIns, PDRVMAINDISPLAY);
3914	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
3915	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIDISPLAYCONNECTOR, &pDrv->IConnector);
3916	return NULL;
3917	}
3918
3919
3920	/**
3921	* Destruct a display driver instance.
3922	*
3923	* @returns VBox status.
3924	* @param pDrvIns The driver instance data.
3925	*/
3926	DECLCALLBACK(void) Display::drvDestruct(PPDMDRVINS pDrvIns)
3927	{
3928	PDRVMAINDISPLAY pData = PDMINS_2_DATA(pDrvIns, PDRVMAINDISPLAY);
3929	LogFlowFunc (("iInstance=%d\n", pDrvIns->iInstance));
3930	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
3931
3932	if (pData->pDisplay)
3933	{
3934	AutoWriteLock displayLock(pData->pDisplay COMMA_LOCKVAL_SRC_POS);
3935	#ifdef VBOX_WITH_CRHGSMI
3936	pData->pDisplay->destructCrHgsmiData();
3937	#endif
3938	pData->pDisplay->mpDrv = NULL;
3939	pData->pDisplay->mpVMMDev = NULL;
3940	pData->pDisplay->mLastAddress = NULL;
3941	pData->pDisplay->mLastBytesPerLine = 0;
3942	pData->pDisplay->mLastBitsPerPixel = 0,
3943	pData->pDisplay->mLastWidth = 0;
3944	pData->pDisplay->mLastHeight = 0;
3945	}
3946	}
3947
3948
3949	/**
3950	* Construct a display driver instance.
3951	*
3952	* @copydoc FNPDMDRVCONSTRUCT
3953	*/
3954	DECLCALLBACK(int) Display::drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
3955	{
3956	PDRVMAINDISPLAY pData = PDMINS_2_DATA(pDrvIns, PDRVMAINDISPLAY);
3957	LogFlowFunc (("iInstance=%d\n", pDrvIns->iInstance));
3958	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
3959
3960	/*
3961	* Validate configuration.
3962	*/
3963	if (!CFGMR3AreValuesValid(pCfg, "Object\0"))
3964	return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
3965	AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
3966	("Configuration error: Not possible to attach anything to this driver!\n"),
3967	VERR_PDM_DRVINS_NO_ATTACH);
3968
3969	/*
3970	* Init Interfaces.
3971	*/
3972	pDrvIns->IBase.pfnQueryInterface = Display::drvQueryInterface;
3973
3974	pData->IConnector.pfnResize = Display::displayResizeCallback;
3975	pData->IConnector.pfnUpdateRect = Display::displayUpdateCallback;
3976	pData->IConnector.pfnRefresh = Display::displayRefreshCallback;
3977	pData->IConnector.pfnReset = Display::displayResetCallback;
3978	pData->IConnector.pfnLFBModeChange = Display::displayLFBModeChangeCallback;
3979	pData->IConnector.pfnProcessAdapterData = Display::displayProcessAdapterDataCallback;
3980	pData->IConnector.pfnProcessDisplayData = Display::displayProcessDisplayDataCallback;
3981	#ifdef VBOX_WITH_VIDEOHWACCEL
3982	pData->IConnector.pfnVHWACommandProcess = Display::displayVHWACommandProcess;
3983	#endif
3984	#ifdef VBOX_WITH_CRHGSMI
3985	pData->IConnector.pfnCrHgsmiCommandProcess = Display::displayCrHgsmiCommandProcess;
3986	pData->IConnector.pfnCrHgsmiControlProcess = Display::displayCrHgsmiControlProcess;
3987	#endif
3988	#ifdef VBOX_WITH_HGSMI
3989	pData->IConnector.pfnVBVAEnable = Display::displayVBVAEnable;
3990	pData->IConnector.pfnVBVADisable = Display::displayVBVADisable;
3991	pData->IConnector.pfnVBVAUpdateBegin = Display::displayVBVAUpdateBegin;
3992	pData->IConnector.pfnVBVAUpdateProcess = Display::displayVBVAUpdateProcess;
3993	pData->IConnector.pfnVBVAUpdateEnd = Display::displayVBVAUpdateEnd;
3994	pData->IConnector.pfnVBVAResize = Display::displayVBVAResize;
3995	pData->IConnector.pfnVBVAMousePointerShape = Display::displayVBVAMousePointerShape;
3996	#endif
3997
3998
3999	/*
4000	* Get the IDisplayPort interface of the above driver/device.
4001	*/
4002	pData->pUpPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIDISPLAYPORT);
4003	if (!pData->pUpPort)
4004	{
4005	AssertMsgFailed(("Configuration error: No display port interface above!\n"));
4006	return VERR_PDM_MISSING_INTERFACE_ABOVE;
4007	}
4008	#if defined(VBOX_WITH_VIDEOHWACCEL) \|\| defined(VBOX_WITH_CRHGSMI)
4009	pData->pVBVACallbacks = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIDISPLAYVBVACALLBACKS);
4010	if (!pData->pVBVACallbacks)
4011	{
4012	AssertMsgFailed(("Configuration error: No VBVA callback interface above!\n"));
4013	return VERR_PDM_MISSING_INTERFACE_ABOVE;
4014	}
4015	#endif
4016	/*
4017	* Get the Display object pointer and update the mpDrv member.
4018	*/
4019	void *pv;
4020	int rc = CFGMR3QueryPtr(pCfg, "Object", &pv);
4021	if (RT_FAILURE(rc))
4022	{
4023	AssertMsgFailed(("Configuration error: No/bad \"Object\" value! rc=%Rrc\n", rc));
4024	return rc;
4025	}
4026	pData->pDisplay = (Display )pv; /* @todo Check this cast! */
4027	pData->pDisplay->mpDrv = pData;
4028
4029	/*
4030	* Update our display information according to the framebuffer
4031	*/
4032	pData->pDisplay->updateDisplayData();
4033
4034	/*
4035	* Start periodic screen refreshes
4036	*/
4037	pData->pUpPort->pfnSetRefreshRate(pData->pUpPort, 20);
4038
4039	#ifdef VBOX_WITH_CRHGSMI
4040	pData->pDisplay->setupCrHgsmiData();
4041	#endif
4042
4043	return VINF_SUCCESS;
4044	}
4045
4046
4047	/**
4048	* Display driver registration record.
4049	*/
4050	const PDMDRVREG Display::DrvReg =
4051	{
4052	/* u32Version */
4053	PDM_DRVREG_VERSION,
4054	/* szName */
4055	"MainDisplay",
4056	/* szRCMod */
4057	"",
4058	/* szR0Mod */
4059	"",
4060	/* pszDescription */
4061	"Main display driver (Main as in the API).",
4062	/* fFlags */
4063	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
4064	/* fClass. */
4065	PDM_DRVREG_CLASS_DISPLAY,
4066	/* cMaxInstances */
4067	~0,
4068	/* cbInstance */
4069	sizeof(DRVMAINDISPLAY),
4070	/* pfnConstruct */
4071	Display::drvConstruct,
4072	/* pfnDestruct */
4073	Display::drvDestruct,
4074	/* pfnRelocate */
4075	NULL,
4076	/* pfnIOCtl */
4077	NULL,
4078	/* pfnPowerOn */
4079	NULL,
4080	/* pfnReset */
4081	NULL,
4082	/* pfnSuspend */
4083	NULL,
4084	/* pfnResume */
4085	NULL,
4086	/* pfnAttach */
4087	NULL,
4088	/* pfnDetach */
4089	NULL,
4090	/* pfnPowerOff */
4091	NULL,
4092	/* pfnSoftReset */
4093	NULL,
4094	/* u32EndVersion */
4095	PDM_DRVREG_VERSION
4096	};
4097	/* 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@ 37187

Download in other formats: