DisplayImpl.cpp@ 52251

Last change on this file since 52251 was 52237, checked in by vboxsync, 11 years ago
Main/DisplayImpl: don't attempt to free this command buffer as the buffer is static
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 168.0 KB

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

Download in other formats: