DisplayImpl.cpp@ 108641

Last change on this file since 108641 was 108641, checked in by vboxsync, 2 weeks ago
Removed 2D video acceleration (aka VHWA / VBOX_WITH_VIDEOHWACCEL). bugref:10756
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 138.2 KB

Line
1	/* $Id: DisplayImpl.cpp 108641 2025-03-20 12:48:42Z vboxsync $ */
2	/** @file
3	* VirtualBox COM class implementation
4	*/
5
6	/*
7	* Copyright (C) 2006-2024 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28	#define LOG_GROUP LOG_GROUP_MAIN_DISPLAY
29	#include "LoggingNew.h"
30
31	#include "DisplayImpl.h"
32	#include "DisplayUtils.h"
33	#include "ConsoleImpl.h"
34	#include "ConsoleVRDPServer.h"
35	#include "GuestImpl.h"
36	#include "MouseImpl.h"
37	#include "VMMDev.h"
38
39	#include "AutoCaller.h"
40
41	/* generated header */
42	#include "VBoxEvents.h"
43
44	#include <iprt/semaphore.h>
45	#include <iprt/thread.h>
46	#include <iprt/asm.h>
47	#include <iprt/time.h>
48	#include <iprt/cpp/utils.h>
49	#include <iprt/alloca.h>
50
51	#include <VBox/vmm/vmmr3vtable.h>
52	#include <VBox/vmm/pdmdrv.h>
53
54	#include <VBoxVideo3D.h>
55
56	#include <VBox/com/array.h>
57
58	#ifdef VBOX_WITH_RECORDING
59	# include <iprt/path.h>
60	# include "Recording.h"
61	# include "RecordingUtils.h"
62
63	# include <VBox/vmm/pdmapi.h>
64	# include <VBox/vmm/pdmaudioifs.h>
65	#endif
66
67	/**
68	* Display driver instance data.
69	*
70	* @implements PDMIDISPLAYCONNECTOR
71	*/
72	typedef struct DRVMAINDISPLAY
73	{
74	/** Pointer to the display object. */
75	Display *pDisplay;
76	/** Pointer to the driver instance structure. */
77	PPDMDRVINS pDrvIns;
78	/** Pointer to the display port interface of the driver/device above us. */
79	PPDMIDISPLAYPORT pUpPort;
80	/** Our display connector interface. */
81	PDMIDISPLAYCONNECTOR IConnector;
82	} DRVMAINDISPLAY, *PDRVMAINDISPLAY;
83
84	/** Converts PDMIDISPLAYCONNECTOR pointer to a DRVMAINDISPLAY pointer. */
85	#define PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface) RT_FROM_MEMBER(pInterface, DRVMAINDISPLAY, IConnector)
86
87	// constructor / destructor
88	/////////////////////////////////////////////////////////////////////////////
89
90	Display::Display()
91	: mParent(NULL)
92	{
93	}
94
95	Display::~Display()
96	{
97	}
98
99
100	HRESULT Display::FinalConstruct()
101	{
102	int vrc = videoAccelConstruct(&mVideoAccelLegacy);
103	AssertRC(vrc);
104
105	mfVideoAccelVRDP = false;
106	mfu32SupportedOrders = 0;
107	mcVRDPRefs = 0;
108
109	mfSeamlessEnabled = false;
110	mpRectVisibleRegion = NULL;
111	mcRectVisibleRegion = 0;
112
113	mpDrv = NULL;
114
115	vrc = RTCritSectInit(&mVideoAccelLock);
116	AssertRC(vrc);
117
118	#ifdef VBOX_WITH_HGSMI
119	mu32UpdateVBVAFlags = 0;
120	mfVMMDevSupportsGraphics = false;
121	mfGuestVBVACapabilities = 0;
122	mfHostCursorCapabilities = 0;
123	#endif
124
125	return BaseFinalConstruct();
126	}
127
128	void Display::FinalRelease()
129	{
130	uninit();
131
132	videoAccelDestroy(&mVideoAccelLegacy);
133	i_saveVisibleRegion(0, NULL);
134
135	if (RTCritSectIsInitialized(&mVideoAccelLock))
136	{
137	RTCritSectDelete(&mVideoAccelLock);
138	RT_ZERO(mVideoAccelLock);
139	}
140
141	BaseFinalRelease();
142	}
143
144	// public initializer/uninitializer for internal purposes only
145	/////////////////////////////////////////////////////////////////////////////
146
147	#define kMaxSizeThumbnail 64
148
149	/**
150	* Save thumbnail and screenshot of the guest screen.
151	*/
152	static int displayMakeThumbnail(uint8_t *pbData, uint32_t cx, uint32_t cy,
153	uint8_t *ppu8Thumbnail, uint32_t pcbThumbnail, uint32_t pcxThumbnail, uint32_t pcyThumbnail)
154	{
155	int vrc = VINF_SUCCESS;
156
157	uint8_t *pu8Thumbnail = NULL;
158	uint32_t cbThumbnail = 0;
159	uint32_t cxThumbnail = 0;
160	uint32_t cyThumbnail = 0;
161
162	if (cx > cy)
163	{
164	cxThumbnail = kMaxSizeThumbnail;
165	cyThumbnail = (kMaxSizeThumbnail * cy) / cx;
166	}
167	else
168	{
169	cyThumbnail = kMaxSizeThumbnail;
170	cxThumbnail = (kMaxSizeThumbnail * cx) / cy;
171	}
172
173	LogRelFlowFunc(("%dx%d -> %dx%d\n", cx, cy, cxThumbnail, cyThumbnail));
174
175	cbThumbnail = cxThumbnail * 4 * cyThumbnail;
176	pu8Thumbnail = (uint8_t *)RTMemAlloc(cbThumbnail);
177
178	if (pu8Thumbnail)
179	{
180	uint8_t *dst = pu8Thumbnail;
181	uint8_t *src = pbData;
182	int dstW = cxThumbnail;
183	int dstH = cyThumbnail;
184	int srcW = cx;
185	int srcH = cy;
186	int iDeltaLine = cx * 4;
187
188	BitmapScale32(dst,
189	dstW, dstH,
190	src,
191	iDeltaLine,
192	srcW, srcH);
193
194	*ppu8Thumbnail = pu8Thumbnail;
195	*pcbThumbnail = cbThumbnail;
196	*pcxThumbnail = cxThumbnail;
197	*pcyThumbnail = cyThumbnail;
198	}
199	else
200	{
201	vrc = VERR_NO_MEMORY;
202	}
203
204	return vrc;
205	}
206
207	/**
208	* @callback_method_impl{FNSSMEXTSAVEEXEC}
209	*/
210	DECLCALLBACK(int) Display::i_displaySSMSaveScreenshot(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser)
211	{
212	Display * const pThat = static_cast<Display *>(pvUser);
213	AssertPtrReturn(pThat, VERR_INVALID_POINTER);
214
215	/* 32bpp small RGB image. */
216	uint8_t *pu8Thumbnail = NULL;
217	uint32_t cbThumbnail = 0;
218	uint32_t cxThumbnail = 0;
219	uint32_t cyThumbnail = 0;
220
221	/* PNG screenshot. */
222	uint8_t *pu8PNG = NULL;
223	uint32_t cbPNG = 0;
224	uint32_t cxPNG = 0;
225	uint32_t cyPNG = 0;
226
227	Console::SafeVMPtr ptrVM(pThat->mParent);
228	if (ptrVM.isOk())
229	{
230	/* Query RGB bitmap. */
231	/* SSM code is executed on EMT(0), therefore no need to use VMR3ReqCallWait. */
232	uint8_t *pbData = NULL;
233	size_t cbData = 0;
234	uint32_t cx = 0;
235	uint32_t cy = 0;
236	bool fFreeMem = false;
237	int vrc = Display::i_displayTakeScreenshotEMT(pThat, VBOX_VIDEO_PRIMARY_SCREEN, &pbData, &cbData, &cx, &cy, &fFreeMem);
238
239	/*
240	* It is possible that success is returned but everything is 0 or NULL.
241	* (no display attached if a VM is running with VBoxHeadless on OSE for example)
242	*/
243	if (RT_SUCCESS(vrc) && pbData)
244	{
245	Assert(cx && cy);
246
247	/* Prepare a small thumbnail and a PNG screenshot. */
248	displayMakeThumbnail(pbData, cx, cy, &pu8Thumbnail, &cbThumbnail, &cxThumbnail, &cyThumbnail);
249	vrc = DisplayMakePNG(pbData, cx, cy, &pu8PNG, &cbPNG, &cxPNG, &cyPNG, 1);
250	if (RT_FAILURE(vrc))
251	{
252	if (pu8PNG)
253	{
254	RTMemFree(pu8PNG);
255	pu8PNG = NULL;
256	}
257	cbPNG = 0;
258	cxPNG = 0;
259	cyPNG = 0;
260	}
261
262	if (fFreeMem)
263	RTMemFree(pbData);
264	else
265	pThat->mpDrv->pUpPort->pfnFreeScreenshot(pThat->mpDrv->pUpPort, pbData);
266	}
267	}
268	else
269	{
270	LogFunc(("Failed to get VM pointer 0x%x\n", ptrVM.hrc()));
271	}
272
273	/* Regardless of vrc, save what is available:
274	* Data format:
275	* uint32_t cBlocks;
276	* [blocks]
277	*
278	* Each block is:
279	* uint32_t cbBlock; if 0 - no 'block data'.
280	* uint32_t typeOfBlock; 0 - 32bpp RGB bitmap, 1 - PNG, ignored if 'cbBlock' is 0.
281	* [block data]
282	*
283	* Block data for bitmap and PNG:
284	* uint32_t cx;
285	* uint32_t cy;
286	* [image data]
287	*/
288	pVMM->pfnSSMR3PutU32(pSSM, 2); /* Write thumbnail and PNG screenshot. */
289
290	/* First block. */
291	pVMM->pfnSSMR3PutU32(pSSM, (uint32_t)(cbThumbnail + 2 * sizeof(uint32_t)));
292	pVMM->pfnSSMR3PutU32(pSSM, 0); /* Block type: thumbnail. */
293
294	if (cbThumbnail)
295	{
296	pVMM->pfnSSMR3PutU32(pSSM, cxThumbnail);
297	pVMM->pfnSSMR3PutU32(pSSM, cyThumbnail);
298	pVMM->pfnSSMR3PutMem(pSSM, pu8Thumbnail, cbThumbnail);
299	}
300
301	/* Second block. */
302	pVMM->pfnSSMR3PutU32(pSSM, (uint32_t)(cbPNG + 2 * sizeof(uint32_t)));
303	pVMM->pfnSSMR3PutU32(pSSM, 1); /* Block type: png. */
304
305	if (cbPNG)
306	{
307	pVMM->pfnSSMR3PutU32(pSSM, cxPNG);
308	pVMM->pfnSSMR3PutU32(pSSM, cyPNG);
309	pVMM->pfnSSMR3PutMem(pSSM, pu8PNG, cbPNG);
310	}
311
312	RTMemFree(pu8PNG);
313	RTMemFree(pu8Thumbnail);
314
315	return VINF_SUCCESS;
316	}
317
318	/**
319	* @callback_method_impl{FNSSMEXTLOADEXEC}
320	*/
321	DECLCALLBACK(int)
322	Display::i_displaySSMLoadScreenshot(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser, uint32_t uVersion, uint32_t uPass)
323	{
324	Display * const pThat = static_cast<Display *>(pvUser);
325	AssertPtrReturn(pThat, VERR_INVALID_POINTER);
326	Assert(uPass == SSM_PASS_FINAL); RT_NOREF_PV(uPass);
327
328	if (uVersion != sSSMDisplayScreenshotVer)
329	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
330
331	/* Skip data. */
332	uint32_t cBlocks;
333	int vrc = pVMM->pfnSSMR3GetU32(pSSM, &cBlocks);
334	AssertRCReturn(vrc, vrc);
335
336	for (uint32_t i = 0; i < cBlocks; i++)
337	{
338	uint32_t cbBlock;
339	vrc = pVMM->pfnSSMR3GetU32(pSSM, &cbBlock);
340	AssertRCReturn(vrc, vrc);
341
342	uint32_t typeOfBlock;
343	vrc = pVMM->pfnSSMR3GetU32(pSSM, &typeOfBlock);
344	AssertRCReturn(vrc, vrc);
345
346	LogRelFlowFunc(("[%d] type %d, size %d bytes\n", i, typeOfBlock, cbBlock));
347
348	/* Note: displaySSMSaveScreenshot writes size of a block = 8 and
349	* do not write any data if the image size was 0.
350	*/
351	/** @todo Fix and increase saved state version. */
352	if (cbBlock > 2 * sizeof(uint32_t))
353	{
354	vrc = pVMM->pfnSSMR3Skip(pSSM, cbBlock);
355	AssertRCReturn(vrc, vrc);
356	}
357	}
358
359	return vrc;
360	}
361
362	/**
363	* @callback_method_impl{FNSSMEXTSAVEEXEC, Save some important guest state}
364	*/
365	/static/ DECLCALLBACK(int)
366	Display::i_displaySSMSave(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser)
367	{
368	Display * const pThat = static_cast<Display *>(pvUser);
369	AssertPtrReturn(pThat, VERR_INVALID_POINTER);
370
371	pVMM->pfnSSMR3PutU32(pSSM, pThat->mcMonitors);
372	for (unsigned i = 0; i < pThat->mcMonitors; i++)
373	{
374	pVMM->pfnSSMR3PutU32(pSSM, pThat->maFramebuffers[i].u32Offset);
375	pVMM->pfnSSMR3PutU32(pSSM, pThat->maFramebuffers[i].u32MaxFramebufferSize);
376	pVMM->pfnSSMR3PutU32(pSSM, pThat->maFramebuffers[i].u32InformationSize);
377	pVMM->pfnSSMR3PutU32(pSSM, pThat->maFramebuffers[i].w);
378	pVMM->pfnSSMR3PutU32(pSSM, pThat->maFramebuffers[i].h);
379	pVMM->pfnSSMR3PutS32(pSSM, pThat->maFramebuffers[i].xOrigin);
380	pVMM->pfnSSMR3PutS32(pSSM, pThat->maFramebuffers[i].yOrigin);
381	pVMM->pfnSSMR3PutU32(pSSM, pThat->maFramebuffers[i].flags);
382	}
383	pVMM->pfnSSMR3PutS32(pSSM, pThat->xInputMappingOrigin);
384	pVMM->pfnSSMR3PutS32(pSSM, pThat->yInputMappingOrigin);
385	pVMM->pfnSSMR3PutU32(pSSM, pThat->cxInputMapping);
386	pVMM->pfnSSMR3PutU32(pSSM, pThat->cyInputMapping);
387	pVMM->pfnSSMR3PutU32(pSSM, pThat->mfGuestVBVACapabilities);
388	return pVMM->pfnSSMR3PutU32(pSSM, pThat->mfHostCursorCapabilities);
389	}
390
391	/**
392	* @callback_method_impl{FNSSMEXTLOADEXEC, Load some important guest state}
393	*/
394	/static/ DECLCALLBACK(int)
395	Display::i_displaySSMLoad(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser, uint32_t uVersion, uint32_t uPass)
396	{
397	Display * const pThat = static_cast<Display *>(pvUser);
398	AssertPtrReturn(pThat, VERR_INVALID_POINTER);
399
400	if ( uVersion != sSSMDisplayVer
401	&& uVersion != sSSMDisplayVer2
402	&& uVersion != sSSMDisplayVer3
403	&& uVersion != sSSMDisplayVer4
404	&& uVersion != sSSMDisplayVer5)
405	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
406	Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
407
408	uint32_t cMonitors;
409	int vrc = pVMM->pfnSSMR3GetU32(pSSM, &cMonitors);
410	AssertRCReturn(vrc, vrc);
411	if (cMonitors != pThat->mcMonitors)
412	return pVMM->pfnSSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Number of monitors changed (%d->%d)!"), cMonitors, pThat->mcMonitors);
413
414	for (uint32_t i = 0; i < cMonitors; i++)
415	{
416	pVMM->pfnSSMR3GetU32(pSSM, &pThat->maFramebuffers[i].u32Offset);
417	pVMM->pfnSSMR3GetU32(pSSM, &pThat->maFramebuffers[i].u32MaxFramebufferSize);
418	pVMM->pfnSSMR3GetU32(pSSM, &pThat->maFramebuffers[i].u32InformationSize);
419	if ( uVersion == sSSMDisplayVer2
420	\|\| uVersion == sSSMDisplayVer3
421	\|\| uVersion == sSSMDisplayVer4
422	\|\| uVersion == sSSMDisplayVer5)
423	{
424	uint32_t w;
425	uint32_t h;
426	pVMM->pfnSSMR3GetU32(pSSM, &w);
427	vrc = pVMM->pfnSSMR3GetU32(pSSM, &h);
428	AssertRCReturn(vrc, vrc);
429	pThat->maFramebuffers[i].w = w;
430	pThat->maFramebuffers[i].h = h;
431	}
432	if ( uVersion == sSSMDisplayVer3
433	\|\| uVersion == sSSMDisplayVer4
434	\|\| uVersion == sSSMDisplayVer5)
435	{
436	int32_t xOrigin;
437	int32_t yOrigin;
438	uint32_t flags;
439	pVMM->pfnSSMR3GetS32(pSSM, &xOrigin);
440	pVMM->pfnSSMR3GetS32(pSSM, &yOrigin);
441	vrc = pVMM->pfnSSMR3GetU32(pSSM, &flags);
442	AssertRCReturn(vrc, vrc);
443	pThat->maFramebuffers[i].xOrigin = xOrigin;
444	pThat->maFramebuffers[i].yOrigin = yOrigin;
445	pThat->maFramebuffers[i].flags = (uint16_t)flags;
446	pThat->maFramebuffers[i].fDisabled = (pThat->maFramebuffers[i].flags & VBVA_SCREEN_F_DISABLED) != 0;
447	}
448	}
449	if ( uVersion == sSSMDisplayVer4
450	\|\| uVersion == sSSMDisplayVer5)
451	{
452	pVMM->pfnSSMR3GetS32(pSSM, &pThat->xInputMappingOrigin);
453	pVMM->pfnSSMR3GetS32(pSSM, &pThat->yInputMappingOrigin);
454	pVMM->pfnSSMR3GetU32(pSSM, &pThat->cxInputMapping);
455	pVMM->pfnSSMR3GetU32(pSSM, &pThat->cyInputMapping);
456	}
457	if (uVersion == sSSMDisplayVer5)
458	{
459	pVMM->pfnSSMR3GetU32(pSSM, &pThat->mfGuestVBVACapabilities);
460	pVMM->pfnSSMR3GetU32(pSSM, &pThat->mfHostCursorCapabilities);
461	}
462
463	return VINF_SUCCESS;
464	}
465
466	/**
467	* Initializes the display object.
468	*
469	* @returns COM result indicator
470	* @param aParent handle of our parent object
471	*/
472	HRESULT Display::init(Console *aParent)
473	{
474	ComAssertRet(aParent, E_INVALIDARG);
475	/* Enclose the state transition NotReady->InInit->Ready */
476	AutoInitSpan autoInitSpan(this);
477	AssertReturn(autoInitSpan.isOk(), E_FAIL);
478
479	unconst(mParent) = aParent;
480
481	mfSourceBitmapEnabled = true;
482	fVGAResizing = false;
483
484	ComPtr<IGraphicsAdapter> pGraphicsAdapter;
485	HRESULT hrc = mParent->i_machine()->COMGETTER(GraphicsAdapter)(pGraphicsAdapter.asOutParam());
486	AssertComRCReturnRC(hrc);
487	AssertReturn(!pGraphicsAdapter.isNull(), E_FAIL);
488
489	ULONG ul;
490	pGraphicsAdapter->COMGETTER(MonitorCount)(&ul);
491	mcMonitors = ul;
492	xInputMappingOrigin = 0;
493	yInputMappingOrigin = 0;
494	cxInputMapping = 0;
495	cyInputMapping = 0;
496
497	for (ul = 0; ul < mcMonitors; ul++)
498	{
499	maFramebuffers[ul].u32Offset = 0;
500	maFramebuffers[ul].u32MaxFramebufferSize = 0;
501	maFramebuffers[ul].u32InformationSize = 0;
502
503	maFramebuffers[ul].pFramebuffer = NULL;
504	/* All secondary monitors are disabled at startup. */
505	maFramebuffers[ul].fDisabled = ul > 0;
506
507	maFramebuffers[ul].u32Caps = 0;
508
509	maFramebuffers[ul].updateImage.pu8Address = NULL;
510	maFramebuffers[ul].updateImage.cbLine = 0;
511
512	maFramebuffers[ul].xOrigin = 0;
513	maFramebuffers[ul].yOrigin = 0;
514
515	maFramebuffers[ul].w = 0;
516	maFramebuffers[ul].h = 0;
517
518	maFramebuffers[ul].flags = maFramebuffers[ul].fDisabled? VBVA_SCREEN_F_DISABLED: 0;
519
520	maFramebuffers[ul].u16BitsPerPixel = 0;
521	maFramebuffers[ul].pu8FramebufferVRAM = NULL;
522	maFramebuffers[ul].u32LineSize = 0;
523
524	maFramebuffers[ul].pHostEvents = NULL;
525
526	maFramebuffers[ul].fDefaultFormat = false;
527
528	#ifdef VBOX_WITH_HGSMI
529	maFramebuffers[ul].fVBVAEnabled = false;
530	maFramebuffers[ul].fVBVAForceResize = false;
531	maFramebuffers[ul].pVBVAHostFlags = NULL;
532	#endif /* VBOX_WITH_HGSMI */
533	}
534
535	{
536	// register listener for state change events
537	ComPtr<IEventSource> es;
538	mParent->COMGETTER(EventSource)(es.asOutParam());
539	com::SafeArray<VBoxEventType_T> eventTypes;
540	eventTypes.push_back(VBoxEventType_OnStateChanged);
541	es->RegisterListener(this, ComSafeArrayAsInParam(eventTypes), true);
542	}
543
544	#ifdef VBOX_WITH_RECORDING
545	unconst(Recording.pCtx) = mParent->i_recordingGetContext();
546	#endif
547
548	/* Confirm a successful initialization */
549	autoInitSpan.setSucceeded();
550
551	return S_OK;
552	}
553
554	/**
555	* Uninitializes the instance and sets the ready flag to FALSE.
556	* Called either from FinalRelease() or by the parent when it gets destroyed.
557	*/
558	void Display::uninit()
559	{
560	LogRelFlowFunc(("this=%p\n", this));
561
562	/* Enclose the state transition Ready->InUninit->NotReady */
563	AutoUninitSpan autoUninitSpan(this);
564	if (autoUninitSpan.uninitDone())
565	return;
566
567	unsigned uScreenId;
568	for (uScreenId = 0; uScreenId < mcMonitors; uScreenId++)
569	{
570	maFramebuffers[uScreenId].pSourceBitmap.setNull();
571	maFramebuffers[uScreenId].updateImage.pSourceBitmap.setNull();
572	maFramebuffers[uScreenId].updateImage.pu8Address = NULL;
573	maFramebuffers[uScreenId].updateImage.cbLine = 0;
574	maFramebuffers[uScreenId].pFramebuffer.setNull();
575	}
576
577	if (mParent)
578	{
579	ComPtr<IEventSource> es;
580	mParent->COMGETTER(EventSource)(es.asOutParam());
581	es->UnregisterListener(this);
582	}
583
584	unconst(mParent) = NULL;
585
586	if (mpDrv)
587	mpDrv->pDisplay = NULL;
588
589	mpDrv = NULL;
590	}
591
592	/**
593	* Register the SSM methods. Called by the power up thread to be able to
594	* pass pVM
595	*/
596	int Display::i_registerSSM(PUVM pUVM)
597	{
598	PCVMMR3VTABLE const pVMM = mParent->i_getVMMVTable();
599	AssertPtrReturn(pVMM, VERR_INTERNAL_ERROR_3);
600
601	/* Version 2 adds width and height of the framebuffer; version 3 adds
602	* the framebuffer offset in the virtual desktop and the framebuffer flags;
603	* version 4 adds guest to host input event mapping and version 5 adds
604	* guest VBVA and host cursor capabilities.
605	*/
606	int vrc = pVMM->pfnSSMR3RegisterExternal(pUVM, "DisplayData", 0, sSSMDisplayVer5,
607	mcMonitors * sizeof(uint32_t) * 8 + sizeof(uint32_t),
608	NULL, NULL, NULL,
609	NULL, i_displaySSMSave, NULL,
610	NULL, i_displaySSMLoad, NULL, this);
611	AssertRCReturn(vrc, vrc);
612
613	/*
614	* Register loaders for old saved states where iInstance was
615	* 3 * sizeof(uint32_t *) due to a code mistake.
616	*/
617	vrc = pVMM->pfnSSMR3RegisterExternal(pUVM, "DisplayData", 12 /uInstance/, sSSMDisplayVer, 0 /cbGuess/,
618	NULL, NULL, NULL,
619	NULL, NULL, NULL,
620	NULL, i_displaySSMLoad, NULL, this);
621	AssertRCReturn(vrc, vrc);
622
623	vrc = pVMM->pfnSSMR3RegisterExternal(pUVM, "DisplayData", 24 /uInstance/, sSSMDisplayVer, 0 /cbGuess/,
624	NULL, NULL, NULL,
625	NULL, NULL, NULL,
626	NULL, i_displaySSMLoad, NULL, this);
627	AssertRCReturn(vrc, vrc);
628
629	/* uInstance is an arbitrary value greater than 1024. Such a value will ensure a quick seek in saved state file. */
630	vrc = pVMM->pfnSSMR3RegisterExternal(pUVM, "DisplayScreenshot", 1100 /uInstance/, sSSMDisplayScreenshotVer, 0 /cbGuess/,
631	NULL, NULL, NULL,
632	NULL, i_displaySSMSaveScreenshot, NULL,
633	NULL, i_displaySSMLoadScreenshot, NULL, this);
634
635	AssertRCReturn(vrc, vrc);
636
637	return VINF_SUCCESS;
638	}
639
640	// public methods only for internal purposes
641	/////////////////////////////////////////////////////////////////////////////
642
643	/**
644	* Handles display resize event.
645	*
646	* @param uScreenId Screen ID
647	* @param bpp New bits per pixel.
648	* @param pvVRAM VRAM pointer.
649	* @param cbLine New bytes per line.
650	* @param w New display width.
651	* @param h New display height.
652	* @param flags Flags of the new video mode.
653	* @param xOrigin New display origin X.
654	* @param yOrigin New display origin Y.
655	* @param fVGAResize Whether the resize is originated from the VGA device (DevVGA).
656	*/
657	int Display::i_handleDisplayResize(unsigned uScreenId, uint32_t bpp, void *pvVRAM,
658	uint32_t cbLine, uint32_t w, uint32_t h, uint16_t flags,
659	int32_t xOrigin, int32_t yOrigin, bool fVGAResize)
660	{
661	LogRel2(("Display::i_handleDisplayResize: uScreenId=%d pvVRAM=%p w=%d h=%d bpp=%d cbLine=0x%X flags=0x%X\n", uScreenId,
662	pvVRAM, w, h, bpp, cbLine, flags));
663
664	/* Caller must not hold the object lock. */
665	AssertReturn(!isWriteLockOnCurrentThread(), VERR_INVALID_STATE);
666
667	/* Note: the old code checked if the video mode was actually changed and
668	* did not invalidate the source bitmap if the mode did not change.
669	* The new code always invalidates the source bitmap, i.e. it will
670	* notify the frontend even if nothing actually changed.
671	*
672	* Implementing the filtering is possible but might lead to pfnSetRenderVRAM races
673	* between this method and QuerySourceBitmap. Such races can be avoided by implementing
674	* the @todo below.
675	*/
676
677	/* Make sure that the VGA device does not access the source bitmap. */
678	if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN && mpDrv)
679	{
680	/// @todo It is probably more convenient to implement
681	// mpDrv->pUpPort->pfnSetOutputBitmap(pvVRAM, cbScanline, cBits, cx, cy, bool fSet);
682	// and remove IConnector.pbData, cbScanline, cBits, cx, cy.
683	// fSet = false disables rendering and VGA can check
684	// if it is already rendering to a different bitmap, avoiding
685	// enable/disable rendering races.
686	mpDrv->pUpPort->pfnSetRenderVRAM(mpDrv->pUpPort, false);
687
688	mpDrv->IConnector.pbData = NULL;
689	mpDrv->IConnector.cbScanline = 0;
690	mpDrv->IConnector.cBits = 32; /* DevVGA does not work with cBits == 0. */
691	mpDrv->IConnector.cx = 0;
692	mpDrv->IConnector.cy = 0;
693	}
694
695	/* Update maFramebuffers[uScreenId] under lock. */
696	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
697
698	if (uScreenId >= mcMonitors)
699	{
700	LogRel(("Display::i_handleDisplayResize: mcMonitors=%u < uScreenId=%u (pvVRAM=%p w=%u h=%u bpp=%d cbLine=0x%X flags=0x%X)\n",
701	mcMonitors, uScreenId, pvVRAM, w, h, bpp, cbLine, flags));
702	return VINF_SUCCESS;
703	}
704
705	DISPLAYFBINFO *pFBInfo = &maFramebuffers[uScreenId];
706
707	/* Whether the monitor position has changed.
708	* A resize initiated by the VGA device does not change the monitor position.
709	*/
710	const bool fNewOrigin = !fVGAResize
711	&& ( pFBInfo->xOrigin != xOrigin
712	\|\| pFBInfo->yOrigin != yOrigin);
713
714	/* The event for disabled->enabled transition.
715	* VGA resizes also come when the guest uses VBVA mode. They do not affect pFBInfo->fDisabled.
716	* The primary screen is re-enabled when the guest leaves the VBVA mode in i_displayVBVADisable.
717	*/
718	const bool fGuestMonitorChangedEvent = !fVGAResize
719	&& (pFBInfo->fDisabled != RT_BOOL(flags & VBVA_SCREEN_F_DISABLED));
720
721	/* Reset the update mode. */
722	pFBInfo->updateImage.pSourceBitmap.setNull();
723	pFBInfo->updateImage.pu8Address = NULL;
724	pFBInfo->updateImage.cbLine = 0;
725
726	/* Release the current source bitmap. */
727	pFBInfo->pSourceBitmap.setNull();
728
729	/* VGA blanking is signaled as w=0, h=0, bpp=0 and cbLine=0, and it's
730	* best to keep the old resolution, as otherwise the window size would
731	* change before the new resolution is known. */
732	const bool fVGABlank = fVGAResize && uScreenId == VBOX_VIDEO_PRIMARY_SCREEN
733	&& w == 0 && h == 0 && bpp == 0 && cbLine == 0;
734	if (fVGABlank)
735	{
736	w = pFBInfo->w;
737	h = pFBInfo->h;
738	}
739
740	/* Log changes. */
741	if ( pFBInfo->w != w
742	\|\| pFBInfo->h != h
743	\|\| pFBInfo->u32LineSize != cbLine
744	/\|\| pFBInfo->pu8FramebufferVRAM != (uint8_t )pvVRAM - too noisy */
745	\|\| ( !fVGAResize
746	&& ( pFBInfo->xOrigin != xOrigin
747	\|\| pFBInfo->yOrigin != yOrigin
748	\|\| pFBInfo->flags != flags)))
749	LogRel(("Display::i_handleDisplayResize: uScreenId=%d pvVRAM=%p w=%d h=%d bpp=%d cbLine=0x%X flags=0x%X origin=%d,%d\n",
750	uScreenId, pvVRAM, w, h, bpp, cbLine, flags, xOrigin, yOrigin));
751
752	/* Update the video mode information. */
753	pFBInfo->w = w;
754	pFBInfo->h = h;
755	pFBInfo->u16BitsPerPixel = (uint16_t)bpp;
756	pFBInfo->pu8FramebufferVRAM = (uint8_t *)pvVRAM;
757	pFBInfo->u32LineSize = cbLine;
758	if (!fVGAResize)
759	{
760	/* Fields which are not used in not VBVA modes and not affected by a VGA resize. */
761	pFBInfo->flags = flags;
762	pFBInfo->xOrigin = xOrigin;
763	pFBInfo->yOrigin = yOrigin;
764	pFBInfo->fDisabled = RT_BOOL(flags & VBVA_SCREEN_F_DISABLED);
765	pFBInfo->fVBVAForceResize = false;
766	}
767	else
768	{
769	pFBInfo->flags = VBVA_SCREEN_F_ACTIVE;
770	if (fVGABlank)
771	pFBInfo->flags \|= VBVA_SCREEN_F_BLANK;
772	pFBInfo->fDisabled = false;
773	}
774
775	/* Prepare local vars for the notification code below. */
776	ComPtr<IFramebuffer> pFramebuffer = pFBInfo->pFramebuffer;
777	const bool fDisabled = pFBInfo->fDisabled;
778
779	alock.release(); /* Release lock before recording code gets involved below. */
780
781	#ifdef VBOX_WITH_RECORDING
782	/* Recording needs to be called before releasing the display's lock below. */
783	i_recordingScreenChanged(uScreenId, pFBInfo);
784	#endif
785
786	if (!pFramebuffer.isNull())
787	{
788	HRESULT hrc = pFramebuffer->NotifyChange(uScreenId, 0, 0, w, h); /** @todo origin */
789	LogFunc(("NotifyChange hr %08X\n", hrc));
790	RT_NOREF(hrc);
791	}
792
793	if (fGuestMonitorChangedEvent)
794	{
795	if (fDisabled)
796	::FireGuestMonitorChangedEvent(mParent->i_getEventSource(),
797	GuestMonitorChangedEventType_Disabled, uScreenId, 0, 0, 0, 0);
798	else
799	::FireGuestMonitorChangedEvent(mParent->i_getEventSource(),
800	GuestMonitorChangedEventType_Enabled, uScreenId, xOrigin, yOrigin, w, h);
801	}
802
803	if (fNewOrigin)
804	::FireGuestMonitorChangedEvent(mParent->i_getEventSource(),
805	GuestMonitorChangedEventType_NewOrigin, uScreenId, xOrigin, yOrigin, 0, 0);
806
807	/* Inform the VRDP server about the change of display parameters. */
808	LogRelFlowFunc(("Calling VRDP\n"));
809	mParent->i_consoleVRDPServer()->SendResize();
810
811	/* And re-send the seamless rectangles if necessary. */
812	if (mfSeamlessEnabled)
813	i_handleSetVisibleRegion(mcRectVisibleRegion, mpRectVisibleRegion);
814
815	LogRelFlowFunc(("[%d]: default format %d\n", uScreenId, pFBInfo->fDefaultFormat));
816
817	LogFlowFuncLeave();
818	return VINF_SUCCESS;
819	}
820
821	static void i_checkCoordBounds(int px, int py, int pw, int ph, int cx, int cy)
822	{
823	/* Correct negative x and y coordinates. */
824	if (*px < 0)
825	{
826	px += pw; /* Compute xRight which is also the new width. */
827
828	pw = (px < 0)? 0: *px;
829
830	*px = 0;
831	}
832
833	if (*py < 0)
834	{
835	py += ph; /* Compute xBottom, which is also the new height. */
836
837	ph = (py < 0)? 0: *py;
838
839	*py = 0;
840	}
841
842	/* Also check if coords are greater than the display resolution. */
843	if (px + pw > cx)
844	{
845	pw = cx > px? cx - *px: 0;
846	}
847
848	if (py + ph > cy)
849	{
850	ph = cy > py? cy - *py: 0;
851	}
852	}
853
854	void Display::i_handleDisplayUpdate(unsigned uScreenId, int x, int y, int w, int h)
855	{
856	/*
857	* Always runs under either VBVA lock or, for HGSMI, DevVGA lock.
858	* Safe to use VBVA vars and take the framebuffer lock.
859	*/
860
861	#ifdef DEBUG_sunlover
862	LogFlowFunc(("[%d] %d,%d %dx%d\n",
863	uScreenId, x, y, w, h));
864	#endif /* DEBUG_sunlover */
865
866	/* No updates for a disabled guest screen. */
867	if (maFramebuffers[uScreenId].fDisabled)
868	return;
869
870	/* No updates for a blank guest screen. */
871	/** @note Disabled for now, as the GUI does not update the picture when we
872	* first blank. */
873	/* if (maFramebuffers[uScreenId].flags & VBVA_SCREEN_F_BLANK)
874	return; */
875
876	DISPLAYFBINFO *pFBInfo = &maFramebuffers[uScreenId];
877	AutoReadLock alockr(this COMMA_LOCKVAL_SRC_POS);
878
879	ComPtr<IFramebuffer> pFramebuffer = pFBInfo->pFramebuffer;
880	ComPtr<IDisplaySourceBitmap> pSourceBitmap = pFBInfo->updateImage.pSourceBitmap;
881
882	alockr.release();
883
884	if (RT_LIKELY(!pFramebuffer.isNull()))
885	{
886	if (RT_LIKELY(!RT_BOOL(pFBInfo->u32Caps & FramebufferCapabilities_UpdateImage)))
887	{
888	i_checkCoordBounds(&x, &y, &w, &h, pFBInfo->w, pFBInfo->h);
889
890	if (w != 0 && h != 0)
891	{
892	pFramebuffer->NotifyUpdate(x, y, w, h);
893
894	#ifdef VBOX_WITH_RECORDING
895	i_recordingScreenUpdate(uScreenId, x, y, w, h);
896	#endif
897	}
898	}
899	else
900	{
901	if (RT_LIKELY(!pSourceBitmap.isNull()))
902	{ /* likely */ }
903	else
904	{
905	/* Create a source bitmap if UpdateImage mode is used. */
906	HRESULT hr = QuerySourceBitmap(uScreenId, pSourceBitmap.asOutParam());
907	if (SUCCEEDED(hr))
908	{
909	BYTE *pAddress = NULL;
910	ULONG ulWidth = 0;
911	ULONG ulHeight = 0;
912	ULONG ulBitsPerPixel = 0;
913	ULONG ulBytesPerLine = 0;
914	BitmapFormat_T bitmapFormat = BitmapFormat_Opaque;
915
916	hr = pSourceBitmap->QueryBitmapInfo(&pAddress,
917	&ulWidth,
918	&ulHeight,
919	&ulBitsPerPixel,
920	&ulBytesPerLine,
921	&bitmapFormat);
922	if (SUCCEEDED(hr))
923	{
924	AutoWriteLock alockw(this COMMA_LOCKVAL_SRC_POS);
925
926	if (pFBInfo->updateImage.pSourceBitmap.isNull())
927	{
928	pFBInfo->updateImage.pSourceBitmap = pSourceBitmap;
929	pFBInfo->updateImage.pu8Address = pAddress;
930	pFBInfo->updateImage.cbLine = ulBytesPerLine;
931	}
932
933	pSourceBitmap = pFBInfo->updateImage.pSourceBitmap;
934
935	alockw.release();
936	}
937	}
938	}
939
940	if (RT_LIKELY(!pSourceBitmap.isNull()))
941	{
942	BYTE *pbAddress = NULL;
943	ULONG ulWidth = 0;
944	ULONG ulHeight = 0;
945	ULONG ulBitsPerPixel = 0;
946	ULONG ulBytesPerLine = 0;
947	BitmapFormat_T bitmapFormat = BitmapFormat_Opaque;
948
949	HRESULT hr = pSourceBitmap->QueryBitmapInfo(&pbAddress,
950	&ulWidth,
951	&ulHeight,
952	&ulBitsPerPixel,
953	&ulBytesPerLine,
954	&bitmapFormat);
955	if (SUCCEEDED(hr))
956	{
957	/* Make sure that the requested update is within the source bitmap dimensions. */
958	i_checkCoordBounds(&x, &y, &w, &h, ulWidth, ulHeight);
959
960	if ( w != 0
961	&& h != 0)
962	{
963	unsigned const uBytesPerPixel = ulBitsPerPixel / 8;
964
965	const size_t cbData = w * h * uBytesPerPixel;
966	com::SafeArray<BYTE> image(cbData);
967
968	uint8_t *pu8Dst = image.raw();
969	const uint8_t pu8Src = pbAddress + ulBytesPerLine y + x * uBytesPerPixel;
970
971	for (int i = 0; i < h; ++i)
972	{
973	memcpy(pu8Dst, pu8Src, w * uBytesPerPixel);
974	pu8Dst += w * uBytesPerPixel;
975	pu8Src += ulBytesPerLine;
976	}
977
978	pFramebuffer->NotifyUpdateImage(x, y, w, h, ComSafeArrayAsInParam(image));
979
980	#ifdef VBOX_WITH_RECORDING
981	i_recordingScreenUpdate(uScreenId,
982	image.raw(), ulBytesPerLine * h,
983	x, y, w, h, ulBytesPerLine);
984	#endif
985	}
986	}
987	}
988	}
989	}
990
991	#ifndef VBOX_WITH_HGSMI
992	if (!mVideoAccelLegacy.fVideoAccelEnabled)
993	#else
994	if (!mVideoAccelLegacy.fVideoAccelEnabled && !maFramebuffers[uScreenId].fVBVAEnabled)
995	#endif
996	{
997	/* When VBVA is enabled, the VRDP server is informed
998	* either in VideoAccelFlush or displayVBVAUpdateProcess.
999	* Inform the server here only if VBVA is disabled.
1000	*/
1001	mParent->i_consoleVRDPServer()->SendUpdateBitmap(uScreenId, x, y, w, h);
1002	}
1003	}
1004
1005	void Display::i_updateGuestGraphicsFacility(void)
1006	{
1007	Guest* pGuest = mParent->i_getGuest();
1008	AssertPtrReturnVoid(pGuest);
1009	/* The following is from GuestImpl.cpp. */
1010	/** @todo A nit: The timestamp is wrong on saved state restore. Would be better
1011	* to move the graphics and seamless capability -> facility translation to
1012	* VMMDev so this could be saved. */
1013	RTTIMESPEC TimeSpecTS;
1014	RTTimeNow(&TimeSpecTS);
1015
1016	if ( mfVMMDevSupportsGraphics
1017	\|\| (mfGuestVBVACapabilities & VBVACAPS_VIDEO_MODE_HINTS) != 0)
1018	pGuest->i_setAdditionsStatus(VBoxGuestFacilityType_Graphics,
1019	VBoxGuestFacilityStatus_Active,
1020	0 /fFlags/, &TimeSpecTS);
1021	else
1022	pGuest->i_setAdditionsStatus(VBoxGuestFacilityType_Graphics,
1023	VBoxGuestFacilityStatus_Inactive,
1024	0 /fFlags/, &TimeSpecTS);
1025	}
1026
1027	void Display::i_handleUpdateVMMDevSupportsGraphics(bool fSupportsGraphics)
1028	{
1029	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1030	if (mfVMMDevSupportsGraphics == fSupportsGraphics)
1031	return;
1032	mfVMMDevSupportsGraphics = fSupportsGraphics;
1033	i_updateGuestGraphicsFacility();
1034	/* The VMMDev interface notifies the console. */
1035	}
1036
1037	void Display::i_handleUpdateGuestVBVACapabilities(uint32_t fNewCapabilities)
1038	{
1039	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1040	bool fNotify = (fNewCapabilities & VBVACAPS_VIDEO_MODE_HINTS) != (mfGuestVBVACapabilities & VBVACAPS_VIDEO_MODE_HINTS);
1041
1042	mfGuestVBVACapabilities = fNewCapabilities;
1043	if (!fNotify)
1044	return;
1045	i_updateGuestGraphicsFacility();
1046	/* Tell the console about it */
1047	mParent->i_onAdditionsStateChange();
1048	}
1049
1050	void Display::i_handleUpdateVBVAInputMapping(int32_t xOrigin, int32_t yOrigin, uint32_t cx, uint32_t cy)
1051	{
1052	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1053
1054	xInputMappingOrigin = xOrigin;
1055	yInputMappingOrigin = yOrigin;
1056	cxInputMapping = cx;
1057	cyInputMapping = cy;
1058
1059	/* Re-send the seamless rectangles if necessary. */
1060	if (mfSeamlessEnabled)
1061	i_handleSetVisibleRegion(mcRectVisibleRegion, mpRectVisibleRegion);
1062	}
1063
1064	/**
1065	* Returns the upper left and lower right corners of the virtual framebuffer.
1066	* The lower right is "exclusive" (i.e. first pixel beyond the framebuffer),
1067	* and the origin is (0, 0), not (1, 1) like the GUI returns.
1068	*/
1069	void Display::i_getFramebufferDimensions(int32_t px1, int32_t py1,
1070	int32_t px2, int32_t py2)
1071	{
1072	int32_t x1 = 0, y1 = 0, x2 = 0, y2 = 0;
1073	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1074
1075	AssertPtrReturnVoid(px1);
1076	AssertPtrReturnVoid(py1);
1077	AssertPtrReturnVoid(px2);
1078	AssertPtrReturnVoid(py2);
1079	LogRelFlowFunc(("\n"));
1080
1081	if (!mpDrv)
1082	return;
1083
1084	if (maFramebuffers[0].fVBVAEnabled && cxInputMapping && cyInputMapping)
1085	{
1086	/* Guest uses VBVA with explicit mouse mapping dimensions. */
1087	x1 = xInputMappingOrigin;
1088	y1 = yInputMappingOrigin;
1089	x2 = xInputMappingOrigin + cxInputMapping;
1090	y2 = yInputMappingOrigin + cyInputMapping;
1091	}
1092	else
1093	{
1094	/* If VBVA is not in use then this flag will not be set and this
1095	* will still work as it should. */
1096	if (!maFramebuffers[0].fDisabled)
1097	{
1098	x1 = (int32_t)maFramebuffers[0].xOrigin;
1099	y1 = (int32_t)maFramebuffers[0].yOrigin;
1100	x2 = (int32_t)maFramebuffers[0].w + (int32_t)maFramebuffers[0].xOrigin;
1101	y2 = (int32_t)maFramebuffers[0].h + (int32_t)maFramebuffers[0].yOrigin;
1102	}
1103
1104	for (unsigned i = 1; i < mcMonitors; ++i)
1105	{
1106	if (!maFramebuffers[i].fDisabled)
1107	{
1108	x1 = RT_MIN(x1, maFramebuffers[i].xOrigin);
1109	y1 = RT_MIN(y1, maFramebuffers[i].yOrigin);
1110	x2 = RT_MAX(x2, maFramebuffers[i].xOrigin + (int32_t)maFramebuffers[i].w);
1111	y2 = RT_MAX(y2, maFramebuffers[i].yOrigin + (int32_t)maFramebuffers[i].h);
1112	}
1113	}
1114	}
1115
1116	*px1 = x1;
1117	*py1 = y1;
1118	*px2 = x2;
1119	*py2 = y2;
1120	}
1121
1122	/** Updates the device's view of the host cursor handling capabilities.
1123	* Calls into mpDrv->pUpPort. */
1124	void Display::i_updateDeviceCursorCapabilities(void)
1125	{
1126	bool fRenderCursor = true;
1127	bool fMoveCursor = mcVRDPRefs == 0;
1128	#ifdef VBOX_WITH_RECORDING
1129	RecordingContext *pCtx = Recording.pCtx;
1130	if ( pCtx->IsStarted()
1131	&& pCtx->IsFeatureEnabled(RecordingFeature_Video))
1132	fRenderCursor = fMoveCursor = false;
1133	else
1134	#endif /* VBOX_WITH_RECORDING */
1135	{
1136	for (unsigned uScreenId = 0; uScreenId < mcMonitors; uScreenId++)
1137	{
1138	DISPLAYFBINFO *pFBInfo = &maFramebuffers[uScreenId];
1139	if (!(pFBInfo->u32Caps & FramebufferCapabilities_RenderCursor))
1140	fRenderCursor = false;
1141	if (!(pFBInfo->u32Caps & FramebufferCapabilities_MoveCursor))
1142	fMoveCursor = false;
1143	}
1144	}
1145
1146	if (mpDrv)
1147	mpDrv->pUpPort->pfnReportHostCursorCapabilities(mpDrv->pUpPort, fRenderCursor, fMoveCursor);
1148	}
1149
1150	HRESULT Display::i_reportHostCursorCapabilities(uint32_t fCapabilitiesAdded, uint32_t fCapabilitiesRemoved)
1151	{
1152	/* Do we need this to access mParent? I presume that the safe VM pointer
1153	* ensures that mpDrv will remain valid. */
1154	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1155	uint32_t fHostCursorCapabilities = (mfHostCursorCapabilities \| fCapabilitiesAdded)
1156	& ~fCapabilitiesRemoved;
1157
1158	Console::SafeVMPtr ptrVM(mParent);
1159	if (!ptrVM.isOk())
1160	return ptrVM.hrc();
1161	if (mfHostCursorCapabilities == fHostCursorCapabilities)
1162	return S_OK;
1163	CHECK_CONSOLE_DRV(mpDrv);
1164	alock.release(); /* Release before calling up for lock order reasons. */
1165	mfHostCursorCapabilities = fHostCursorCapabilities;
1166	i_updateDeviceCursorCapabilities();
1167	return S_OK;
1168	}
1169
1170	HRESULT Display::i_reportHostCursorPosition(int32_t x, int32_t y, bool fOutOfRange)
1171	{
1172	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1173	uint32_t xAdj = (uint32_t)RT_MAX(x - xInputMappingOrigin, 0);
1174	uint32_t yAdj = (uint32_t)RT_MAX(y - yInputMappingOrigin, 0);
1175	xAdj = RT_MIN(xAdj, cxInputMapping);
1176	yAdj = RT_MIN(yAdj, cyInputMapping);
1177
1178	Console::SafeVMPtr ptrVM(mParent);
1179	if (!ptrVM.isOk())
1180	return ptrVM.hrc();
1181	CHECK_CONSOLE_DRV(mpDrv);
1182	alock.release(); /* Release before calling up for lock order reasons. */
1183	if (fOutOfRange)
1184	mpDrv->pUpPort->pfnReportHostCursorPosition(mpDrv->pUpPort, 0, 0, true);
1185	else
1186	mpDrv->pUpPort->pfnReportHostCursorPosition(mpDrv->pUpPort, xAdj, yAdj, false);
1187	return S_OK;
1188	}
1189
1190	static bool displayIntersectRect(RTRECT *prectResult,
1191	const RTRECT *prect1,
1192	const RTRECT *prect2)
1193	{
1194	/* Initialize result to an empty record. */
1195	memset(prectResult, 0, sizeof(RTRECT));
1196
1197	int xLeftResult = RT_MAX(prect1->xLeft, prect2->xLeft);
1198	int xRightResult = RT_MIN(prect1->xRight, prect2->xRight);
1199
1200	if (xLeftResult < xRightResult)
1201	{
1202	/* There is intersection by X. */
1203
1204	int yTopResult = RT_MAX(prect1->yTop, prect2->yTop);
1205	int yBottomResult = RT_MIN(prect1->yBottom, prect2->yBottom);
1206
1207	if (yTopResult < yBottomResult)
1208	{
1209	/* There is intersection by Y. */
1210
1211	prectResult->xLeft = xLeftResult;
1212	prectResult->yTop = yTopResult;
1213	prectResult->xRight = xRightResult;
1214	prectResult->yBottom = yBottomResult;
1215
1216	return true;
1217	}
1218	}
1219
1220	return false;
1221	}
1222
1223	int Display::i_saveVisibleRegion(uint32_t cRect, PRTRECT pRect)
1224	{
1225	RTRECT *pRectVisibleRegion = NULL;
1226
1227	if (pRect == mpRectVisibleRegion)
1228	return VINF_SUCCESS;
1229	if (cRect != 0)
1230	{
1231	pRectVisibleRegion = (RTRECT )RTMemAlloc(cRect sizeof(RTRECT));
1232	if (!pRectVisibleRegion)
1233	{
1234	return VERR_NO_MEMORY;
1235	}
1236	memcpy(pRectVisibleRegion, pRect, cRect * sizeof(RTRECT));
1237	}
1238	if (mpRectVisibleRegion)
1239	RTMemFree(mpRectVisibleRegion);
1240	mcRectVisibleRegion = cRect;
1241	mpRectVisibleRegion = pRectVisibleRegion;
1242	return VINF_SUCCESS;
1243	}
1244
1245	int Display::i_handleSetVisibleRegion(uint32_t cRect, PRTRECT pRect)
1246	{
1247	RTRECT pVisibleRegion = (RTRECT )RTMemTmpAlloc( RT_MAX(cRect, 1)
1248	* sizeof(RTRECT));
1249	LogRel2(("%s: cRect=%u\n", __PRETTY_FUNCTION__, cRect));
1250	if (!pVisibleRegion)
1251	{
1252	return VERR_NO_TMP_MEMORY;
1253	}
1254	int vrc = i_saveVisibleRegion(cRect, pRect);
1255	if (RT_FAILURE(vrc))
1256	{
1257	RTMemTmpFree(pVisibleRegion);
1258	return vrc;
1259	}
1260
1261	unsigned uScreenId;
1262	for (uScreenId = 0; uScreenId < mcMonitors; uScreenId++)
1263	{
1264	DISPLAYFBINFO *pFBInfo = &maFramebuffers[uScreenId];
1265
1266	if ( !pFBInfo->pFramebuffer.isNull()
1267	&& RT_BOOL(pFBInfo->u32Caps & FramebufferCapabilities_VisibleRegion))
1268	{
1269	/* Prepare a new array of rectangles which intersect with the framebuffer.
1270	*/
1271	RTRECT rectFramebuffer;
1272	rectFramebuffer.xLeft = pFBInfo->xOrigin - xInputMappingOrigin;
1273	rectFramebuffer.yTop = pFBInfo->yOrigin - yInputMappingOrigin;
1274	rectFramebuffer.xRight = rectFramebuffer.xLeft + pFBInfo->w;
1275	rectFramebuffer.yBottom = rectFramebuffer.yTop + pFBInfo->h;
1276
1277	uint32_t cRectVisibleRegion = 0;
1278
1279	uint32_t i;
1280	for (i = 0; i < cRect; i++)
1281	{
1282	if (displayIntersectRect(&pVisibleRegion[cRectVisibleRegion], &pRect[i], &rectFramebuffer))
1283	{
1284	pVisibleRegion[cRectVisibleRegion].xLeft -= rectFramebuffer.xLeft;
1285	pVisibleRegion[cRectVisibleRegion].yTop -= rectFramebuffer.yTop;
1286	pVisibleRegion[cRectVisibleRegion].xRight -= rectFramebuffer.xLeft;
1287	pVisibleRegion[cRectVisibleRegion].yBottom -= rectFramebuffer.yTop;
1288
1289	cRectVisibleRegion++;
1290	}
1291	}
1292	pFBInfo->pFramebuffer->SetVisibleRegion((BYTE *)pVisibleRegion, cRectVisibleRegion);
1293	}
1294	}
1295
1296	RTMemTmpFree(pVisibleRegion);
1297
1298	return VINF_SUCCESS;
1299	}
1300
1301	int Display::i_handleUpdateMonitorPositions(uint32_t cPositions, PCRTPOINT paPositions)
1302	{
1303	AssertMsgReturn(paPositions, ("Empty monitor position array\n"), E_INVALIDARG);
1304	for (unsigned i = 0; i < cPositions; ++i)
1305	LogRel2(("Display::i_handleUpdateMonitorPositions: uScreenId=%d xOrigin=%d yOrigin=%dX\n",
1306	i, paPositions[i].x, paPositions[i].y));
1307
1308	if (mpDrv && mpDrv->pUpPort->pfnReportMonitorPositions)
1309	mpDrv->pUpPort->pfnReportMonitorPositions(mpDrv->pUpPort, cPositions, paPositions);
1310	return VINF_SUCCESS;
1311	}
1312
1313	int Display::i_handleQueryVisibleRegion(uint32_t *pcRects, PRTRECT paRects)
1314	{
1315	/// @todo Currently not used by the guest and is not implemented in
1316	/// framebuffers. Remove?
1317	RT_NOREF(pcRects, paRects);
1318	return VERR_NOT_SUPPORTED;
1319	}
1320
1321	#ifdef VBOX_WITH_HGSMI
1322	static void vbvaSetMemoryFlagsHGSMI(unsigned uScreenId,
1323	uint32_t fu32SupportedOrders,
1324	bool fVideoAccelVRDP,
1325	DISPLAYFBINFO *pFBInfo)
1326	{
1327	LogRelFlowFunc(("HGSMI[%d]: %p\n", uScreenId, pFBInfo->pVBVAHostFlags));
1328
1329	if (pFBInfo->pVBVAHostFlags)
1330	{
1331	uint32_t fu32HostEvents = VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET;
1332
1333	if (pFBInfo->fVBVAEnabled)
1334	{
1335	fu32HostEvents \|= VBVA_F_MODE_ENABLED;
1336
1337	if (fVideoAccelVRDP)
1338	{
1339	fu32HostEvents \|= VBVA_F_MODE_VRDP;
1340	}
1341	}
1342
1343	ASMAtomicWriteU32(&pFBInfo->pVBVAHostFlags->u32HostEvents, fu32HostEvents);
1344	ASMAtomicWriteU32(&pFBInfo->pVBVAHostFlags->u32SupportedOrders, fu32SupportedOrders);
1345
1346	LogRelFlowFunc((" fu32HostEvents = 0x%08X, fu32SupportedOrders = 0x%08X\n", fu32HostEvents, fu32SupportedOrders));
1347	}
1348	}
1349
1350	static void vbvaSetMemoryFlagsAllHGSMI(uint32_t fu32SupportedOrders,
1351	bool fVideoAccelVRDP,
1352	DISPLAYFBINFO *paFBInfos,
1353	unsigned cFBInfos)
1354	{
1355	unsigned uScreenId;
1356
1357	for (uScreenId = 0; uScreenId < cFBInfos; uScreenId++)
1358	{
1359	vbvaSetMemoryFlagsHGSMI(uScreenId, fu32SupportedOrders, fVideoAccelVRDP, &paFBInfos[uScreenId]);
1360	}
1361	}
1362	#endif /* VBOX_WITH_HGSMI */
1363
1364	int Display::VideoAccelEnableVMMDev(bool fEnable, VBVAMEMORY *pVbvaMemory)
1365	{
1366	LogFlowFunc(("%d %p\n", fEnable, pVbvaMemory));
1367	int vrc = videoAccelEnterVMMDev(&mVideoAccelLegacy);
1368	if (RT_SUCCESS(vrc))
1369	{
1370	vrc = i_VideoAccelEnable(fEnable, pVbvaMemory, mpDrv->pUpPort);
1371	videoAccelLeaveVMMDev(&mVideoAccelLegacy);
1372	}
1373	LogFlowFunc(("leave %Rrc\n", vrc));
1374	return vrc;
1375	}
1376
1377	int Display::VideoAccelEnableVGA(bool fEnable, VBVAMEMORY *pVbvaMemory)
1378	{
1379	LogFlowFunc(("%d %p\n", fEnable, pVbvaMemory));
1380	int vrc = videoAccelEnterVGA(&mVideoAccelLegacy);
1381	if (RT_SUCCESS(vrc))
1382	{
1383	vrc = i_VideoAccelEnable(fEnable, pVbvaMemory, mpDrv->pUpPort);
1384	videoAccelLeaveVGA(&mVideoAccelLegacy);
1385	}
1386	LogFlowFunc(("leave %Rrc\n", vrc));
1387	return vrc;
1388	}
1389
1390	void Display::VideoAccelFlushVMMDev(void)
1391	{
1392	LogFlowFunc(("enter\n"));
1393	int vrc = videoAccelEnterVMMDev(&mVideoAccelLegacy);
1394	if (RT_SUCCESS(vrc))
1395	{
1396	i_VideoAccelFlush(mpDrv->pUpPort);
1397	videoAccelLeaveVMMDev(&mVideoAccelLegacy);
1398	}
1399	LogFlowFunc(("leave\n"));
1400	}
1401
1402	/* Called always by one VRDP server thread. Can be thread-unsafe.
1403	*/
1404	void Display::i_VRDPConnectionEvent(bool fConnect)
1405	{
1406	LogRelFlowFunc(("fConnect = %d\n", fConnect));
1407
1408	int c = fConnect?
1409	ASMAtomicIncS32(&mcVRDPRefs):
1410	ASMAtomicDecS32(&mcVRDPRefs);
1411
1412	i_VideoAccelVRDP(fConnect, c);
1413	i_updateDeviceCursorCapabilities();
1414	}
1415
1416
1417	void Display::i_VideoAccelVRDP(bool fEnable, int c)
1418	{
1419	VIDEOACCEL *pVideoAccel = &mVideoAccelLegacy;
1420
1421	Assert (c >= 0);
1422	RT_NOREF(fEnable);
1423
1424	/* This can run concurrently with Display videoaccel state change. */
1425	RTCritSectEnter(&mVideoAccelLock);
1426
1427	if (c == 0)
1428	{
1429	/* The last client has disconnected, and the accel can be
1430	* disabled.
1431	*/
1432	Assert(fEnable == false);
1433
1434	mfVideoAccelVRDP = false;
1435	mfu32SupportedOrders = 0;
1436
1437	i_vbvaSetMemoryFlags(pVideoAccel->pVbvaMemory, pVideoAccel->fVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders,
1438	maFramebuffers, mcMonitors);
1439	#ifdef VBOX_WITH_HGSMI
1440	/* Here is VRDP-IN thread. Process the request in vbvaUpdateBegin under DevVGA lock on an EMT. */
1441	ASMAtomicIncU32(&mu32UpdateVBVAFlags);
1442	#endif /* VBOX_WITH_HGSMI */
1443
1444	LogRel(("VBVA: VRDP acceleration has been disabled.\n"));
1445	}
1446	else if ( c == 1
1447	&& !mfVideoAccelVRDP)
1448	{
1449	/* The first client has connected. Enable the accel.
1450	*/
1451	Assert(fEnable == true);
1452
1453	mfVideoAccelVRDP = true;
1454	/* Supporting all orders. */
1455	mfu32SupportedOrders = UINT32_MAX;
1456
1457	i_vbvaSetMemoryFlags(pVideoAccel->pVbvaMemory, pVideoAccel->fVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders,
1458	maFramebuffers, mcMonitors);
1459	#ifdef VBOX_WITH_HGSMI
1460	/* Here is VRDP-IN thread. Process the request in vbvaUpdateBegin under DevVGA lock on an EMT. */
1461	ASMAtomicIncU32(&mu32UpdateVBVAFlags);
1462	#endif /* VBOX_WITH_HGSMI */
1463
1464	LogRel(("VBVA: VRDP acceleration has been requested.\n"));
1465	}
1466	else
1467	{
1468	/* A client is connected or disconnected but there is no change in the
1469	* accel state. It remains enabled.
1470	*/
1471	Assert(mfVideoAccelVRDP == true);
1472	}
1473
1474	RTCritSectLeave(&mVideoAccelLock);
1475	}
1476
1477	void Display::i_notifyPowerDown(void)
1478	{
1479	LogRelFlowFunc(("\n"));
1480
1481	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1482
1483	/* Source bitmaps are not available anymore. */
1484	mfSourceBitmapEnabled = false;
1485
1486	alock.release();
1487
1488	/* Resize all displays to tell framebuffers to forget current source bitmap. */
1489	unsigned uScreenId = mcMonitors;
1490	while (uScreenId > 0)
1491	{
1492	--uScreenId;
1493
1494	DISPLAYFBINFO *pFBInfo = &maFramebuffers[uScreenId];
1495	if (!pFBInfo->fDisabled)
1496	{
1497	i_handleDisplayResize(uScreenId, 32,
1498	pFBInfo->pu8FramebufferVRAM,
1499	pFBInfo->u32LineSize,
1500	pFBInfo->w,
1501	pFBInfo->h,
1502	pFBInfo->flags,
1503	pFBInfo->xOrigin,
1504	pFBInfo->yOrigin,
1505	false);
1506	}
1507	}
1508	}
1509
1510	// Wrapped IDisplay methods
1511	/////////////////////////////////////////////////////////////////////////////
1512	HRESULT Display::getScreenResolution(ULONG aScreenId, ULONG aWidth, ULONG aHeight, ULONG *aBitsPerPixel,
1513	LONG aXOrigin, LONG aYOrigin, GuestMonitorStatus_T *aGuestMonitorStatus)
1514	{
1515	LogRelFlowFunc(("aScreenId=%RU32\n", aScreenId));
1516
1517	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1518
1519	if (aScreenId >= mcMonitors)
1520	return E_INVALIDARG;
1521
1522	DISPLAYFBINFO *pFBInfo = &maFramebuffers[aScreenId];
1523
1524	GuestMonitorStatus_T guestMonitorStatus = GuestMonitorStatus_Enabled;
1525
1526	if (pFBInfo->flags & VBVA_SCREEN_F_DISABLED)
1527	guestMonitorStatus = GuestMonitorStatus_Disabled;
1528	else if (pFBInfo->flags & (VBVA_SCREEN_F_BLANK \| VBVA_SCREEN_F_BLANK2))
1529	guestMonitorStatus = GuestMonitorStatus_Blank;
1530
1531	if (aWidth)
1532	*aWidth = pFBInfo->w;
1533	if (aHeight)
1534	*aHeight = pFBInfo->h;
1535	if (aBitsPerPixel)
1536	*aBitsPerPixel = pFBInfo->u16BitsPerPixel;
1537	if (aXOrigin)
1538	*aXOrigin = pFBInfo->xOrigin;
1539	if (aYOrigin)
1540	*aYOrigin = pFBInfo->yOrigin;
1541	if (aGuestMonitorStatus)
1542	*aGuestMonitorStatus = guestMonitorStatus;
1543
1544	return S_OK;
1545	}
1546
1547
1548	HRESULT Display::attachFramebuffer(ULONG aScreenId, const ComPtr<IFramebuffer> &aFramebuffer, com::Guid &aId)
1549	{
1550	LogRelFlowFunc(("aScreenId = %d\n", aScreenId));
1551
1552	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1553
1554	if (aScreenId >= mcMonitors)
1555	return setError(E_INVALIDARG, tr("AttachFramebuffer: Invalid screen %d (total %d)"),
1556	aScreenId, mcMonitors);
1557
1558	DISPLAYFBINFO *pFBInfo = &maFramebuffers[aScreenId];
1559	if (!pFBInfo->pFramebuffer.isNull())
1560	return setError(E_FAIL, tr("AttachFramebuffer: Framebuffer already attached to %d"),
1561	aScreenId);
1562
1563	pFBInfo->pFramebuffer = aFramebuffer;
1564	pFBInfo->framebufferId.create();
1565	aId = pFBInfo->framebufferId;
1566
1567	SafeArray<FramebufferCapabilities_T> caps;
1568	pFBInfo->pFramebuffer->COMGETTER(Capabilities)(ComSafeArrayAsOutParam(caps));
1569	pFBInfo->u32Caps = 0;
1570	size_t i;
1571	for (i = 0; i < caps.size(); ++i)
1572	pFBInfo->u32Caps \|= caps[i];
1573
1574	alock.release();
1575
1576	/* The driver might not have been constructed yet */
1577	if (mpDrv)
1578	{
1579	/* Inform the framebuffer about the actual screen size. */
1580	HRESULT hr = aFramebuffer->NotifyChange(aScreenId, 0, 0, pFBInfo->w, pFBInfo->h); /** @todo origin */
1581	LogFunc(("NotifyChange hr %08X\n", hr)); NOREF(hr);
1582
1583	/* Re-send the seamless rectangles if necessary. */
1584	if (mfSeamlessEnabled)
1585	i_handleSetVisibleRegion(mcRectVisibleRegion, mpRectVisibleRegion);
1586	}
1587
1588	Console::SafeVMPtrQuiet ptrVM(mParent);
1589	if (ptrVM.isOk()) /** @todo r=andy This apparently never is true at this point? */
1590	ptrVM.vtable()->pfnVMR3ReqCallNoWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_InvalidateAndUpdateEMT, 3,
1591	this, aScreenId, false);
1592
1593	LogRelFlowFunc(("Attached to %d %RTuuid\n", aScreenId, aId.raw()));
1594	return S_OK;
1595	}
1596
1597	HRESULT Display::detachFramebuffer(ULONG aScreenId, const com::Guid &aId)
1598	{
1599	LogRelFlowFunc(("aScreenId = %d %RTuuid\n", aScreenId, aId.raw()));
1600
1601	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1602
1603	if (aScreenId >= mcMonitors)
1604	return setError(E_INVALIDARG, tr("DetachFramebuffer: Invalid screen %d (total %d)"),
1605	aScreenId, mcMonitors);
1606
1607	DISPLAYFBINFO *pFBInfo = &maFramebuffers[aScreenId];
1608
1609	if (pFBInfo->framebufferId != aId)
1610	{
1611	LogRelFlowFunc(("Invalid framebuffer aScreenId = %d, attached %p\n", aScreenId, pFBInfo->framebufferId.raw()));
1612	return setError(E_FAIL, tr("DetachFramebuffer: Invalid framebuffer object"));
1613	}
1614
1615	pFBInfo->pFramebuffer.setNull();
1616	pFBInfo->framebufferId.clear();
1617
1618	alock.release();
1619	return S_OK;
1620	}
1621
1622	HRESULT Display::queryFramebuffer(ULONG aScreenId, ComPtr<IFramebuffer> &aFramebuffer)
1623	{
1624	LogRelFlowFunc(("aScreenId = %d\n", aScreenId));
1625
1626	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1627
1628	if (aScreenId >= mcMonitors)
1629	return setError(E_INVALIDARG, tr("QueryFramebuffer: Invalid screen %d (total %d)"),
1630	aScreenId, mcMonitors);
1631
1632	DISPLAYFBINFO *pFBInfo = &maFramebuffers[aScreenId];
1633
1634	pFBInfo->pFramebuffer.queryInterfaceTo(aFramebuffer.asOutParam());
1635
1636	return S_OK;
1637	}
1638
1639	HRESULT Display::setVideoModeHint(ULONG aDisplay, BOOL aEnabled,
1640	BOOL aChangeOrigin, LONG aOriginX, LONG aOriginY,
1641	ULONG aWidth, ULONG aHeight, ULONG aBitsPerPixel,
1642	BOOL aNotify)
1643	{
1644	if (aWidth == 0 \|\| aHeight == 0 \|\| aBitsPerPixel == 0)
1645	{
1646	/* Some of parameters must not change. Query current mode. */
1647	ULONG ulWidth = 0;
1648	ULONG ulHeight = 0;
1649	ULONG ulBitsPerPixel = 0;
1650	HRESULT hr = getScreenResolution(aDisplay, &ulWidth, &ulHeight, &ulBitsPerPixel, NULL, NULL, NULL);
1651	if (FAILED(hr))
1652	return hr;
1653
1654	/* Assign current values to not changing parameters. */
1655	if (aWidth == 0)
1656	aWidth = ulWidth;
1657	if (aHeight == 0)
1658	aHeight = ulHeight;
1659	if (aBitsPerPixel == 0)
1660	aBitsPerPixel = ulBitsPerPixel;
1661	}
1662
1663	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1664
1665	if (aDisplay >= mcMonitors)
1666	return E_INVALIDARG;
1667
1668	VMMDevDisplayDef d;
1669	d.idDisplay = aDisplay;
1670	d.xOrigin = aOriginX;
1671	d.yOrigin = aOriginY;
1672	d.cx = aWidth;
1673	d.cy = aHeight;
1674	d.cBitsPerPixel = aBitsPerPixel;
1675	d.fDisplayFlags = VMMDEV_DISPLAY_CX \| VMMDEV_DISPLAY_CY \| VMMDEV_DISPLAY_BPP;
1676	if (!aEnabled)
1677	d.fDisplayFlags \|= VMMDEV_DISPLAY_DISABLED;
1678	if (aChangeOrigin)
1679	d.fDisplayFlags \|= VMMDEV_DISPLAY_ORIGIN;
1680	if (aDisplay == 0)
1681	d.fDisplayFlags \|= VMMDEV_DISPLAY_PRIMARY;
1682
1683	/* Remember the monitor information. */
1684	maFramebuffers[aDisplay].monitorDesc = d;
1685
1686	CHECK_CONSOLE_DRV(mpDrv);
1687
1688	/*
1689	* It is up to the guest to decide whether the hint is
1690	* valid. Therefore don't do any VRAM sanity checks here.
1691	*/
1692
1693	/* Have to release the lock because the pfnRequestDisplayChange
1694	* will call EMT. */
1695	alock.release();
1696
1697	/* We always send the hint to the graphics card in case the guest enables
1698	* support later. For now we notify exactly when support is enabled. */
1699	mpDrv->pUpPort->pfnSendModeHint(mpDrv->pUpPort, aWidth, aHeight,
1700	aBitsPerPixel, aDisplay,
1701	aChangeOrigin ? aOriginX : ~0,
1702	aChangeOrigin ? aOriginY : ~0,
1703	RT_BOOL(aEnabled),
1704	(mfGuestVBVACapabilities & VBVACAPS_VIDEO_MODE_HINTS)
1705	&& aNotify);
1706	if ( mfGuestVBVACapabilities & VBVACAPS_VIDEO_MODE_HINTS
1707	&& !(mfGuestVBVACapabilities & VBVACAPS_IRQ)
1708	&& aNotify)
1709	mParent->i_sendACPIMonitorHotPlugEvent();
1710
1711	/* We currently never suppress the VMMDev hint if the guest has requested
1712	* it. Specifically the video graphics driver may not be responsible for
1713	* screen positioning in the guest virtual desktop, and the component
1714	* responsible may want to get the hint from VMMDev. */
1715	VMMDev *pVMMDev = mParent->i_getVMMDev();
1716	if (pVMMDev)
1717	{
1718	PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
1719	if (pVMMDevPort)
1720	pVMMDevPort->pfnRequestDisplayChange(pVMMDevPort, 1, &d, false, RT_BOOL(aNotify));
1721	}
1722	/* Notify listeners. */
1723	::FireGuestMonitorInfoChangedEvent(mParent->i_getEventSource(), aDisplay);
1724	return S_OK;
1725	}
1726
1727	HRESULT Display::getVideoModeHint(ULONG cDisplay, BOOL *pfEnabled,
1728	BOOL pfChangeOrigin, LONG pxOrigin, LONG *pyOrigin,
1729	ULONG pcx, ULONG pcy, ULONG *pcBitsPerPixel)
1730	{
1731	if (cDisplay >= mcMonitors)
1732	return E_INVALIDARG;
1733
1734	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1735	if (pfEnabled)
1736	*pfEnabled = !( maFramebuffers[cDisplay].monitorDesc.fDisplayFlags
1737	& VMMDEV_DISPLAY_DISABLED);
1738	if (pfChangeOrigin)
1739	*pfChangeOrigin = RT_BOOL( maFramebuffers[cDisplay].monitorDesc.fDisplayFlags
1740	& VMMDEV_DISPLAY_ORIGIN);
1741	if (pxOrigin)
1742	*pxOrigin = maFramebuffers[cDisplay].monitorDesc.xOrigin;
1743	if (pyOrigin)
1744	*pyOrigin = maFramebuffers[cDisplay].monitorDesc.yOrigin;
1745	if (pcx)
1746	*pcx = maFramebuffers[cDisplay].monitorDesc.cx;
1747	if (pcy)
1748	*pcy = maFramebuffers[cDisplay].monitorDesc.cy;
1749	if (pcBitsPerPixel)
1750	*pcBitsPerPixel = maFramebuffers[cDisplay].monitorDesc.cBitsPerPixel;
1751	return S_OK;
1752	}
1753
1754	HRESULT Display::setSeamlessMode(BOOL enabled)
1755	{
1756	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1757
1758	/* Have to release the lock because the pfnRequestSeamlessChange will call EMT. */
1759	alock.release();
1760
1761	VMMDev *pVMMDev = mParent->i_getVMMDev();
1762	if (pVMMDev)
1763	{
1764	PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
1765	if (pVMMDevPort)
1766	pVMMDevPort->pfnRequestSeamlessChange(pVMMDevPort, !!enabled);
1767	}
1768	mfSeamlessEnabled = RT_BOOL(enabled);
1769	return S_OK;
1770	}
1771
1772	/static/ DECLCALLBACK(int)
1773	Display::i_displayTakeScreenshotEMT(Display pDisplay, ULONG aScreenId, uint8_t ppbData, size_t pcbData,
1774	uint32_t pcx, uint32_t pcy, bool *pfMemFree)
1775	{
1776	int vrc;
1777	if ( aScreenId == VBOX_VIDEO_PRIMARY_SCREEN
1778	&& pDisplay->maFramebuffers[aScreenId].fVBVAEnabled == false) /* A non-VBVA mode. */
1779	{
1780	if (pDisplay->mpDrv)
1781	{
1782	vrc = pDisplay->mpDrv->pUpPort->pfnTakeScreenshot(pDisplay->mpDrv->pUpPort, ppbData, pcbData, pcx, pcy);
1783	*pfMemFree = false;
1784	}
1785	else
1786	{
1787	/* No image. */
1788	*ppbData = NULL;
1789	*pcbData = 0;
1790	*pcx = 0;
1791	*pcy = 0;
1792	*pfMemFree = true;
1793	vrc = VINF_SUCCESS;
1794	}
1795	}
1796	else if (aScreenId < pDisplay->mcMonitors)
1797	{
1798	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[aScreenId];
1799
1800	uint32_t width = pFBInfo->w;
1801	uint32_t height = pFBInfo->h;
1802
1803	/* Allocate 32 bit per pixel bitmap. */
1804	size_t cbRequired = width * 4 * height;
1805
1806	if (cbRequired)
1807	{
1808	uint8_t pbDst = (uint8_t )RTMemAlloc(cbRequired);
1809	if (pbDst != NULL)
1810	{
1811	if (pFBInfo->flags & VBVA_SCREEN_F_ACTIVE)
1812	{
1813	/* Copy guest VRAM to the allocated 32bpp buffer. */
1814	const uint8_t *pu8Src = pFBInfo->pu8FramebufferVRAM;
1815	int32_t xSrc = 0;
1816	int32_t ySrc = 0;
1817	uint32_t u32SrcWidth = width;
1818	uint32_t u32SrcHeight = height;
1819	uint32_t u32SrcLineSize = pFBInfo->u32LineSize;
1820	uint32_t u32SrcBitsPerPixel = pFBInfo->u16BitsPerPixel;
1821
1822	int32_t xDst = 0;
1823	int32_t yDst = 0;
1824	uint32_t u32DstWidth = u32SrcWidth;
1825	uint32_t u32DstHeight = u32SrcHeight;
1826	uint32_t u32DstLineSize = u32DstWidth * 4;
1827	uint32_t u32DstBitsPerPixel = 32;
1828
1829	vrc = pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
1830	width, height,
1831	pu8Src,
1832	xSrc, ySrc,
1833	u32SrcWidth, u32SrcHeight,
1834	u32SrcLineSize, u32SrcBitsPerPixel,
1835	pbDst,
1836	xDst, yDst,
1837	u32DstWidth, u32DstHeight,
1838	u32DstLineSize, u32DstBitsPerPixel);
1839	}
1840	else
1841	{
1842	memset(pbDst, 0, cbRequired);
1843	vrc = VINF_SUCCESS;
1844	}
1845	if (RT_SUCCESS(vrc))
1846	{
1847	*ppbData = pbDst;
1848	*pcbData = cbRequired;
1849	*pcx = width;
1850	*pcy = height;
1851	*pfMemFree = true;
1852	}
1853	else
1854	{
1855	RTMemFree(pbDst);
1856
1857	/* CopyRect can fail if VBVA was paused in VGA device, retry using the generic method. */
1858	if ( vrc == VERR_INVALID_STATE
1859	&& aScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
1860	{
1861	vrc = pDisplay->mpDrv->pUpPort->pfnTakeScreenshot(pDisplay->mpDrv->pUpPort, ppbData, pcbData, pcx, pcy);
1862	*pfMemFree = false;
1863	}
1864	}
1865	}
1866	else
1867	vrc = VERR_NO_MEMORY;
1868	}
1869	else
1870	{
1871	/* No image. */
1872	*ppbData = NULL;
1873	*pcbData = 0;
1874	*pcx = 0;
1875	*pcy = 0;
1876	*pfMemFree = true;
1877	vrc = VINF_SUCCESS;
1878	}
1879	}
1880	else
1881	vrc = VERR_INVALID_PARAMETER;
1882	return vrc;
1883	}
1884
1885	static int i_displayTakeScreenshot(PUVM pUVM, PCVMMR3VTABLE pVMM, Display pDisplay, struct DRVMAINDISPLAY pDrv,
1886	ULONG aScreenId, BYTE *address, ULONG width, ULONG height)
1887	{
1888	uint8_t *pbData = NULL;
1889	size_t cbData = 0;
1890	uint32_t cx = 0;
1891	uint32_t cy = 0;
1892	bool fFreeMem = false;
1893	int vrc = VINF_SUCCESS;
1894
1895	int cRetries = 5;
1896	while (cRetries-- > 0)
1897	{
1898	/* Note! Not sure if the priority call is such a good idea here, but
1899	it would be nice to have an accurate screenshot for the bug
1900	report if the VM deadlocks. */
1901	vrc = pVMM->pfnVMR3ReqPriorityCallWaitU(pUVM, VMCPUID_ANY, (PFNRT)Display::i_displayTakeScreenshotEMT, 7,
1902	pDisplay, aScreenId, &pbData, &cbData, &cx, &cy, &fFreeMem);
1903	if (vrc != VERR_TRY_AGAIN)
1904	{
1905	break;
1906	}
1907
1908	RTThreadSleep(10);
1909	}
1910
1911	if (RT_SUCCESS(vrc) && pbData)
1912	{
1913	if (cx == width && cy == height)
1914	{
1915	/* No scaling required. */
1916	memcpy(address, pbData, cbData);
1917	}
1918	else
1919	{
1920	/* Scale. */
1921	LogRelFlowFunc(("SCALE: %dx%d -> %dx%d\n", cx, cy, width, height));
1922
1923	uint8_t *dst = address;
1924	uint8_t *src = pbData;
1925	int dstW = width;
1926	int dstH = height;
1927	int srcW = cx;
1928	int srcH = cy;
1929	int iDeltaLine = cx * 4;
1930
1931	BitmapScale32(dst,
1932	dstW, dstH,
1933	src,
1934	iDeltaLine,
1935	srcW, srcH);
1936	}
1937
1938	if (fFreeMem)
1939	RTMemFree(pbData);
1940	else
1941	{
1942	/* This can be called from any thread. */
1943	pDrv->pUpPort->pfnFreeScreenshot(pDrv->pUpPort, pbData);
1944	}
1945	}
1946
1947	return vrc;
1948	}
1949
1950	HRESULT Display::takeScreenShotWorker(ULONG aScreenId,
1951	BYTE *aAddress,
1952	ULONG aWidth,
1953	ULONG aHeight,
1954	BitmapFormat_T aBitmapFormat,
1955	ULONG *pcbOut)
1956	{
1957	HRESULT hrc = S_OK;
1958
1959	/* Do not allow too small and too large screenshots. This also filters out negative
1960	* values passed as either 'aWidth' or 'aHeight'.
1961	*/
1962	CheckComArgExpr(aWidth, aWidth != 0 && aWidth <= 32767);
1963	CheckComArgExpr(aHeight, aHeight != 0 && aHeight <= 32767);
1964
1965	if ( aBitmapFormat != BitmapFormat_BGR0
1966	&& aBitmapFormat != BitmapFormat_BGRA
1967	&& aBitmapFormat != BitmapFormat_RGBA
1968	&& aBitmapFormat != BitmapFormat_PNG)
1969	{
1970	return setError(E_NOTIMPL,
1971	tr("Unsupported screenshot format 0x%08X"), aBitmapFormat);
1972	}
1973
1974	Console::SafeVMPtr ptrVM(mParent);
1975	if (!ptrVM.isOk())
1976	return ptrVM.hrc();
1977
1978	int vrc = i_displayTakeScreenshot(ptrVM.rawUVM(), ptrVM.vtable(), this, mpDrv, aScreenId, aAddress, aWidth, aHeight);
1979	if (RT_SUCCESS(vrc))
1980	{
1981	const size_t cbData = aWidth * 4 * aHeight;
1982
1983	/* Most of uncompressed formats. */
1984	*pcbOut = (ULONG)cbData;
1985
1986	if (aBitmapFormat == BitmapFormat_BGR0)
1987	{
1988	/* Do nothing. */
1989	}
1990	else if (aBitmapFormat == BitmapFormat_BGRA)
1991	{
1992	uint32_t pu32 = (uint32_t )aAddress;
1993	size_t cPixels = aWidth * aHeight;
1994	while (cPixels--)
1995	*pu32++ \|= UINT32_C(0xFF000000);
1996	}
1997	else if (aBitmapFormat == BitmapFormat_RGBA)
1998	{
1999	uint8_t *pu8 = aAddress;
2000	size_t cPixels = aWidth * aHeight;
2001	while (cPixels--)
2002	{
2003	uint8_t u8 = pu8[0];
2004	pu8[0] = pu8[2];
2005	pu8[2] = u8;
2006	pu8[3] = 0xFF;
2007
2008	pu8 += 4;
2009	}
2010	}
2011	else if (aBitmapFormat == BitmapFormat_PNG)
2012	{
2013	uint8_t *pu8PNG = NULL;
2014	uint32_t cbPNG = 0;
2015	uint32_t cxPNG = 0;
2016	uint32_t cyPNG = 0;
2017
2018	vrc = DisplayMakePNG(aAddress, aWidth, aHeight, &pu8PNG, &cbPNG, &cxPNG, &cyPNG, 0);
2019	if (RT_SUCCESS(vrc))
2020	{
2021	if (cbPNG <= cbData)
2022	{
2023	memcpy(aAddress, pu8PNG, cbPNG);
2024	*pcbOut = cbPNG;
2025	}
2026	else
2027	hrc = setError(E_FAIL, tr("PNG is larger than 32bpp bitmap"));
2028	}
2029	else
2030	hrc = setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("Could not convert screenshot to PNG (%Rrc)"), vrc);
2031	RTMemFree(pu8PNG);
2032	}
2033	}
2034	else if (vrc == VERR_NOT_SUPPORTED) /* zero screen size (or too large screen size for vram) */
2035	hrc = setErrorBothNoLog(VBOX_E_NOT_SUPPORTED, vrc, tr("Screenshot is not possible at this time, invalid size"));
2036	else if (vrc == VERR_TRY_AGAIN) /* resizing while taking screenshot */
2037	hrc = setErrorBoth(E_UNEXPECTED, vrc, tr("Screenshot is not possible at this time"));
2038	else if (RT_FAILURE(vrc))
2039	hrc = setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("Could not take a screenshot (%Rrc)"), vrc);
2040
2041	return hrc;
2042	}
2043
2044	HRESULT Display::takeScreenShot(ULONG aScreenId,
2045	BYTE *aAddress,
2046	ULONG aWidth,
2047	ULONG aHeight,
2048	BitmapFormat_T aBitmapFormat)
2049	{
2050	LogRelFlowFunc(("[%d] address=%p, width=%d, height=%d, format 0x%08X\n",
2051	aScreenId, aAddress, aWidth, aHeight, aBitmapFormat));
2052
2053	ULONG cbOut = 0;
2054	HRESULT hrc = takeScreenShotWorker(aScreenId, aAddress, aWidth, aHeight, aBitmapFormat, &cbOut);
2055	NOREF(cbOut);
2056
2057	LogRelFlowFunc(("%Rhrc\n", hrc));
2058	return hrc;
2059	}
2060
2061	HRESULT Display::takeScreenShotToArray(ULONG aScreenId,
2062	ULONG aWidth,
2063	ULONG aHeight,
2064	BitmapFormat_T aBitmapFormat,
2065	std::vector<BYTE> &aScreenData)
2066	{
2067	LogRelFlowFunc(("[%d] width=%d, height=%d, format 0x%08X\n",
2068	aScreenId, aWidth, aHeight, aBitmapFormat));
2069
2070	/* Do not allow too small and too large screenshots. This also filters out negative
2071	* values passed as either 'aWidth' or 'aHeight'.
2072	*/
2073	CheckComArgExpr(aWidth, aWidth != 0 && aWidth <= 32767);
2074	CheckComArgExpr(aHeight, aHeight != 0 && aHeight <= 32767);
2075
2076	const size_t cbData = aWidth * 4 * aHeight;
2077	aScreenData.resize(cbData);
2078
2079	ULONG cbOut = 0;
2080	HRESULT hrc = takeScreenShotWorker(aScreenId, &aScreenData.front(), aWidth, aHeight, aBitmapFormat, &cbOut);
2081	if (FAILED(hrc))
2082	cbOut = 0;
2083
2084	aScreenData.resize(cbOut);
2085
2086	LogRelFlowFunc(("%Rhrc\n", hrc));
2087	return hrc;
2088	}
2089
2090	#ifdef VBOX_WITH_RECORDING
2091	/**
2092	* Starts video (+ audio) recording.
2093	*
2094	* @returns VBox status code.
2095	*/
2096	int Display::i_recordingStart(void)
2097	{
2098	#ifdef VBOX_WITH_STATISTICS
2099	Console::SafeVMPtrQuiet ptrVM(mParent);
2100	if (ptrVM.isOk())
2101	{
2102	ptrVM.vtable()->pfnSTAMR3RegisterFU(ptrVM.rawUVM(), &Stats.profileDisplayRefreshCallback,
2103	STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL,
2104	"Profiling display refresh.", "/Main/Display/ProfRefresh");
2105	ptrVM.vtable()->pfnSTAMR3RegisterFU(ptrVM.rawUVM(), &Stats.Recording.profileRecording,
2106	STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL,
2107	"Profiling recording time for all monitors.", "/Main/Display/ProfRecording");
2108
2109	for (unsigned i = 0; i < mcMonitors; i++)
2110	ptrVM.vtable()->pfnSTAMR3RegisterFU(ptrVM.rawUVM(), &Stats.Monitor[i].Recording.profileRecording,
2111	STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL,
2112	"Profiling recording time for this monitor.", "/Main/Display/Monitor%RU32/ProfRecording", i);
2113	}
2114	#endif
2115
2116	return i_recordingInvalidate();
2117	}
2118
2119	/**
2120	* Stops video (+ audio) recording.
2121	*
2122	* @returns VBox status code.
2123	*/
2124	int Display::i_recordingStop(void)
2125	{
2126	#ifdef VBOX_WITH_STATISTICS
2127	Console::SafeVMPtrQuiet ptrVM(mParent);
2128	if (ptrVM.isOk())
2129	{
2130	ptrVM.vtable()->pfnSTAMR3DeregisterF(ptrVM.rawUVM(), "/Main/Display/ProfRefresh");
2131	ptrVM.vtable()->pfnSTAMR3DeregisterF(ptrVM.rawUVM(), "/Main/Display/ProfRecording");
2132
2133	for (unsigned i = 0; i < mcMonitors; i++)
2134	ptrVM.vtable()->pfnSTAMR3DeregisterF(ptrVM.rawUVM(), "/Main/Display/Monitor%RU32/ProfRecording", i);
2135	}
2136	#endif
2137
2138	return i_recordingInvalidate();
2139	}
2140
2141	/**
2142	* Invalidates the recording configuration.
2143	*
2144	* @returns VBox status code.
2145	*
2146	* @note Takes the display's write lock.
2147	*/
2148	int Display::i_recordingInvalidate(void)
2149	{
2150	LogFlowFuncEnter();
2151
2152	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2153
2154	/*
2155	* Invalidate screens.
2156	*/
2157	for (unsigned uScreen = 0; uScreen < mcMonitors; uScreen++)
2158	{
2159	DISPLAYFBINFO const *pFBInfo = &maFramebuffers[uScreen];
2160	/* ignore rc */ i_recordingScreenChanged(uScreen, pFBInfo);
2161	}
2162
2163	return VINF_SUCCESS;
2164	}
2165
2166	/**
2167	* Called when the recording state of a screen got changed.
2168	*
2169	* @returns VBox status code.
2170	* @param uScreenId ID of screen for which the recording state got changed.
2171	* @param pFBInfo Frame buffer information to use.
2172	*/
2173	int Display::i_recordingScreenChanged(unsigned uScreenId, const DISPLAYFBINFO *pFBInfo)
2174	{
2175	RecordingContext *pCtx = Recording.pCtx;
2176
2177	Log2Func(("uScreenId=%u\n", uScreenId));
2178
2179	if (uScreenId == 0xFFFFFFFF /* SVGA_ID_INVALID -- The old register interface is single screen only */)
2180	uScreenId = VBOX_VIDEO_PRIMARY_SCREEN;
2181
2182	if (!pCtx->IsFeatureEnabled(uScreenId, RecordingFeature_Video))
2183	{
2184	/* Skip recording this screen. */
2185	return VINF_SUCCESS;
2186	}
2187
2188	AssertReturn(uScreenId < mcMonitors, VERR_INVALID_PARAMETER);
2189
2190	RT_NOREF(pFBInfo);
2191
2192	/* We have to go the official way of querying the source bitmap, as this function creates it if it does not exist yet. */
2193	ComPtr<IDisplaySourceBitmap> sourceBitmap;
2194	HRESULT hrc = querySourceBitmap(uScreenId, sourceBitmap);
2195	if (FAILED(hrc)) /* Blank, skip. */
2196	return VINF_SUCCESS;
2197
2198	BYTE *pbAddress;
2199	ULONG ulWidth;
2200	ULONG ulHeight;
2201	ULONG ulBitsPerPixel;
2202	ULONG ulBytesPerLine;
2203	BitmapFormat_T bitmapFormat = BitmapFormat_Opaque;
2204	hrc = sourceBitmap->QueryBitmapInfo(&pbAddress,
2205	&ulWidth,
2206	&ulHeight,
2207	&ulBitsPerPixel,
2208	&ulBytesPerLine,
2209	&bitmapFormat);
2210	AssertComRC(hrc);
2211
2212	Log2Func(("pbAddress=%p, ulWidth=%RU32, ulHeight=%RU32, ulBitsPerPixel=%RU32\n",
2213	pbAddress, ulWidth, ulHeight, ulBitsPerPixel));
2214
2215	Assert(ulWidth);
2216	Assert(ulHeight);
2217	Assert(ulBitsPerPixel);
2218	Assert(ulBytesPerLine);
2219
2220	if (!pbAddress)
2221	{
2222	AssertFailed();
2223	return VINF_SUCCESS;
2224	}
2225
2226	i_updateDeviceCursorCapabilities();
2227
2228	RECORDINGSURFACEINFO ScreenInfo;
2229	ScreenInfo.uWidth = ulWidth;
2230	ScreenInfo.uHeight = ulHeight;
2231	ScreenInfo.uBPP = ulBitsPerPixel;
2232	ScreenInfo.enmPixelFmt = RECORDINGPIXELFMT_BRGA32; /** @todo Does this apply everywhere? */
2233
2234	uint64_t const tsNowMs = pCtx->GetCurrentPTS();
2235
2236	int vrc = pCtx->SendScreenChange(uScreenId, &ScreenInfo, tsNowMs);
2237	if (RT_SUCCESS(vrc))
2238	{
2239	/* Make sure that we get the latest mouse pointer shape required for recording. */
2240	MousePointerData pointerData;
2241	mParent->i_getMouse()->i_getPointerShape(pointerData);
2242	mParent->i_recordingCursorShapeChange(pointerData.fVisible, pointerData.fAlpha,
2243	pointerData.hotX, pointerData.hotY,
2244	pointerData.width, pointerData.height,
2245	pointerData.pu8Shape, pointerData.cbShape);
2246	/* Send the full screen update. */
2247	vrc = i_recordingScreenUpdate(uScreenId, pbAddress, ulHeight * ulBytesPerLine,
2248	0, 0, ulWidth, ulHeight, ulBytesPerLine);
2249	}
2250
2251	return vrc;
2252	}
2253
2254	/**
2255	* Sends a screen update to the recording facility.
2256	*
2257	* @returns VBox status code.
2258	* @param uScreenId ID of screen.
2259	* @param pauFramebuffer Pointer to start of framebuffer.
2260	* @param cbFramebuffer Size (in bytes) of \a pauFramebuffer.
2261	* @param x Absolute X starting position (in pixel) within current framebuffer.
2262	* @param y Absolute Y starting position (in pixel) within current framebuffer.
2263	* @param w Width (in pixel) of the changed area.
2264	* @param h Height (in pixel) of the changed area.
2265	* @param uBytesPerLine Bytes per line of current framebuffer.
2266	*/
2267	int Display::i_recordingScreenUpdate(unsigned uScreenId, uint8_t *pauFramebuffer, size_t cbFramebuffer,
2268	uint32_t x, uint32_t y, uint32_t w, uint32_t h, uint32_t uBytesPerLine)
2269	{
2270	RT_NOREF(cbFramebuffer);
2271
2272	RecordingContext *pCtx = Recording.pCtx;
2273
2274	Log2Func(("uScreenId=%u, pauFramebuffer=%p, cbFramebuffer=%zu, x=%RU32, y=%RU32, w=%RU32, h=%RU32, uBytesPerLine=%RU32\n",
2275	uScreenId, pauFramebuffer, cbFramebuffer, x, y, w, h, uBytesPerLine));
2276
2277	if (uScreenId == 0xFFFFFFFF /* SVGA_ID_INVALID -- The old register interface is single screen only */)
2278	uScreenId = VBOX_VIDEO_PRIMARY_SCREEN;
2279
2280	if ( !pCtx->IsFeatureEnabled(uScreenId, RecordingFeature_Video)
2281	\|\| !pauFramebuffer)
2282	return VINF_SUCCESS;
2283
2284	#ifdef VBOX_STRICT /* Skipped in release build for speed reasons. */
2285	AssertReturn (cbFramebuffer, VERR_INVALID_PARAMETER);
2286	AssertReturn (uBytesPerLine, VERR_INVALID_PARAMETER);
2287	AssertReturn (w, VERR_INVALID_PARAMETER);
2288	AssertReturn (h, VERR_INVALID_PARAMETER);
2289	#endif
2290
2291	uint64_t const tsNowMs = pCtx->GetCurrentPTS();
2292
2293	STAM_PROFILE_START(&Stats.Monitor[uScreenId].Recording.profileRecording, a);
2294
2295	uint8_t const uBytesPerPixel = 4;
2296	size_t const offFrame = (y * uBytesPerLine) + (x * uBytesPerPixel);
2297	size_t const cbFrame = w * h * uBytesPerPixel;
2298
2299	RECORDINGVIDEOFRAME Frame =
2300	{
2301	{ w, h, 32 /* BPP */, RECORDINGPIXELFMT_BRGA32, uBytesPerLine },
2302	pauFramebuffer + offFrame, cbFrame,
2303	{ x, y }
2304	};
2305
2306	#if 0
2307	RecordingUtilsDbgDumpImageData(pauFramebuffer + offFrame, cbFramebuffer,
2308	"/tmp/recording", "display-screen-update", w, h, uBytesPerLine, 32 /* BPP */);
2309	#endif
2310
2311	int vrc = pCtx->SendVideoFrame(uScreenId, &Frame, tsNowMs);
2312
2313	STAM_PROFILE_STOP(&Stats.Monitor[uScreenId].Recording.profileRecording, a);
2314
2315	return vrc;
2316	}
2317
2318	/**
2319	* Sends a screen upate to the recording facility using the current framebuffer.
2320	*
2321	* @returns VBox status code.
2322	* @param uScreenId ID of screen.
2323	* @param x Absolute X starting position (in pixel) within current framebuffer.
2324	* @param y Absolute Y starting position (in pixel) within current framebuffer.
2325	* @param w Width (in pixel) of the changed area.
2326	* @param h Height (in pixel) of the changed area.
2327	*/
2328	int Display::i_recordingScreenUpdate(unsigned uScreenId, uint32_t x, uint32_t y, uint32_t w, uint32_t h)
2329	{
2330	RecordingContext *pCtx = Recording.pCtx;
2331
2332	if (!pCtx->IsFeatureEnabled(uScreenId, RecordingFeature_Video))
2333	return VINF_SUCCESS;
2334
2335	BYTE *pbAddress;
2336	ULONG ulWidth;
2337	ULONG ulHeight;
2338	ULONG ulBitsPerPixel;
2339	ULONG ulBytesPerLine;
2340
2341	if ( uScreenId == VBOX_VIDEO_PRIMARY_SCREEN /* Take a shortcut for the primary screen. */
2342	&& mpDrv)
2343	{
2344	pbAddress = mpDrv->IConnector.pbData;
2345	ulWidth = mpDrv->IConnector.cx;
2346	ulHeight = mpDrv->IConnector.cy;
2347	ulBitsPerPixel = mpDrv->IConnector.cBits;
2348	ulBytesPerLine = mpDrv->IConnector.cbScanline;
2349	}
2350	else
2351	{
2352	BitmapFormat_T bitmapFormat = BitmapFormat_Opaque;
2353	maFramebuffers[uScreenId].pSourceBitmap->QueryBitmapInfo(&pbAddress,
2354	&ulWidth,
2355	&ulHeight,
2356	&ulBitsPerPixel,
2357	&ulBytesPerLine,
2358	&bitmapFormat);
2359	}
2360
2361	Log2Func(("uScreenId=%u, pbAddress=%p, ulWidth=%RU32, ulHeight=%RU32, ulBitsPerPixel=%RU32\n",
2362	uScreenId, pbAddress, ulWidth, ulHeight, ulBitsPerPixel));
2363
2364	return i_recordingScreenUpdate(uScreenId,
2365	pbAddress, ulHeight * ulBytesPerLine,
2366	x, y, w, h, ulBytesPerLine);
2367	}
2368
2369	/**
2370	* Called when the mouse cursor position has changed within the guest.
2371	*
2372	* @returns VBox status code.
2373	* @param uScreenId ID of screen.
2374	* @param fFlags Position flags. Not used yet.
2375	* @param x X position of the mouse cursor (within guest).
2376	* @param y Y position of the mouse cursor (within guest).
2377	*
2378	* @note Requires Guest Additions installed + mouse integration enabled.
2379	*/
2380	int Display::i_recordingCursorPositionChange(unsigned uScreenId, uint32_t fFlags, int32_t x, int32_t y)
2381	{
2382	RT_NOREF(fFlags);
2383
2384	RecordingContext *pCtx = Recording.pCtx;
2385
2386	Log2Func(("uScreenId=%u, fFlags=%#x, x=%RI32, y=%RI32\n", uScreenId, fFlags, x, y));
2387
2388	if (uScreenId == 0xFFFFFFFF /* SVGA_ID_INVALID -- The old register interface is single screen only */)
2389	uScreenId = VBOX_VIDEO_PRIMARY_SCREEN;
2390
2391	if (!pCtx->IsFeatureEnabled(uScreenId, RecordingFeature_Video))
2392	return VINF_SUCCESS;
2393
2394	return pCtx->SendCursorPositionChange(uScreenId, x, y, pCtx->GetCurrentPTS());
2395	}
2396	#endif /* VBOX_WITH_RECORDING */
2397
2398	/static/ DECLCALLBACK(int)
2399	Display::i_drawToScreenEMT(Display pDisplay, ULONG aScreenId, BYTE address, ULONG x, ULONG y, ULONG width, ULONG height)
2400	{
2401	int vrc = VINF_SUCCESS;
2402
2403	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[aScreenId];
2404
2405	if (aScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
2406	{
2407	vrc = pDisplay->mpDrv->pUpPort->pfnDisplayBlt(pDisplay->mpDrv->pUpPort, address, x, y, width, height);
2408	}
2409	else if (aScreenId < pDisplay->mcMonitors)
2410	{
2411	/* Copy the bitmap to the guest VRAM. */
2412	const uint8_t *pu8Src = address;
2413	int32_t xSrc = 0;
2414	int32_t ySrc = 0;
2415	uint32_t u32SrcWidth = width;
2416	uint32_t u32SrcHeight = height;
2417	uint32_t u32SrcLineSize = width * 4;
2418	uint32_t u32SrcBitsPerPixel = 32;
2419
2420	uint8_t *pu8Dst = pFBInfo->pu8FramebufferVRAM;
2421	int32_t xDst = x;
2422	int32_t yDst = y;
2423	uint32_t u32DstWidth = pFBInfo->w;
2424	uint32_t u32DstHeight = pFBInfo->h;
2425	uint32_t u32DstLineSize = pFBInfo->u32LineSize;
2426	uint32_t u32DstBitsPerPixel = pFBInfo->u16BitsPerPixel;
2427
2428	vrc = pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
2429	width, height,
2430	pu8Src,
2431	xSrc, ySrc,
2432	u32SrcWidth, u32SrcHeight,
2433	u32SrcLineSize, u32SrcBitsPerPixel,
2434	pu8Dst,
2435	xDst, yDst,
2436	u32DstWidth, u32DstHeight,
2437	u32DstLineSize, u32DstBitsPerPixel);
2438	if (RT_SUCCESS(vrc))
2439	{
2440	if (!pFBInfo->pSourceBitmap.isNull())
2441	{
2442	/* Update the changed screen area. When source bitmap uses VRAM directly, just notify
2443	* frontend to update. And for default format, render the guest VRAM to the source bitmap.
2444	*/
2445	if ( pFBInfo->fDefaultFormat
2446	&& !pFBInfo->fDisabled)
2447	{
2448	BYTE *pAddress = NULL;
2449	ULONG ulWidth = 0;
2450	ULONG ulHeight = 0;
2451	ULONG ulBitsPerPixel = 0;
2452	ULONG ulBytesPerLine = 0;
2453	BitmapFormat_T bitmapFormat = BitmapFormat_Opaque;
2454
2455	HRESULT hrc = pFBInfo->pSourceBitmap->QueryBitmapInfo(&pAddress,
2456	&ulWidth,
2457	&ulHeight,
2458	&ulBitsPerPixel,
2459	&ulBytesPerLine,
2460	&bitmapFormat);
2461	if (SUCCEEDED(hrc))
2462	{
2463	pu8Src = pFBInfo->pu8FramebufferVRAM;
2464	xSrc = x;
2465	ySrc = y;
2466	u32SrcWidth = pFBInfo->w;
2467	u32SrcHeight = pFBInfo->h;
2468	u32SrcLineSize = pFBInfo->u32LineSize;
2469	u32SrcBitsPerPixel = pFBInfo->u16BitsPerPixel;
2470
2471	/* Default format is 32 bpp. */
2472	pu8Dst = pAddress;
2473	xDst = xSrc;
2474	yDst = ySrc;
2475	u32DstWidth = u32SrcWidth;
2476	u32DstHeight = u32SrcHeight;
2477	u32DstLineSize = u32DstWidth * 4;
2478	u32DstBitsPerPixel = 32;
2479
2480	pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
2481	width, height,
2482	pu8Src,
2483	xSrc, ySrc,
2484	u32SrcWidth, u32SrcHeight,
2485	u32SrcLineSize, u32SrcBitsPerPixel,
2486	pu8Dst,
2487	xDst, yDst,
2488	u32DstWidth, u32DstHeight,
2489	u32DstLineSize, u32DstBitsPerPixel);
2490	}
2491	}
2492	}
2493
2494	pDisplay->i_handleDisplayUpdate(aScreenId, x, y, width, height);
2495	}
2496	}
2497	else
2498	{
2499	vrc = VERR_INVALID_PARAMETER;
2500	}
2501
2502	if (RT_SUCCESS(vrc))
2503	pDisplay->mParent->i_consoleVRDPServer()->SendUpdateBitmap(aScreenId, x, y, width, height);
2504
2505	return vrc;
2506	}
2507
2508	HRESULT Display::drawToScreen(ULONG aScreenId, BYTE *aAddress, ULONG aX, ULONG aY, ULONG aWidth, ULONG aHeight)
2509	{
2510	/// @todo (r=dmik) this function may take too long to complete if the VM
2511	// is doing something like saving state right now. Which, in case if it
2512	// is called on the GUI thread, will make it unresponsive. We should
2513	// check the machine state here (by enclosing the check and VMRequCall
2514	// within the Console lock to make it atomic).
2515
2516	LogRelFlowFunc(("aAddress=%p, x=%d, y=%d, width=%d, height=%d\n",
2517	(void *)aAddress, aX, aY, aWidth, aHeight));
2518
2519	CheckComArgExpr(aWidth, aWidth != 0);
2520	CheckComArgExpr(aHeight, aHeight != 0);
2521
2522	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2523
2524	CHECK_CONSOLE_DRV(mpDrv);
2525
2526	Console::SafeVMPtr ptrVM(mParent);
2527	if (!ptrVM.isOk())
2528	return ptrVM.hrc();
2529
2530	/* Release lock because the call scheduled on EMT may also try to take it. */
2531	alock.release();
2532
2533	/*
2534	* Again we're lazy and make the graphics device do all the
2535	* dirty conversion work.
2536	*/
2537	int vrc = ptrVM.vtable()->pfnVMR3ReqCallWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_drawToScreenEMT, 7,
2538	this, aScreenId, aAddress, aX, aY, aWidth, aHeight);
2539
2540	/*
2541	* If the function returns not supported, we'll have to do all the
2542	* work ourselves using the framebuffer.
2543	*/
2544	HRESULT hrc = S_OK;
2545	if (vrc == VERR_NOT_SUPPORTED \|\| vrc == VERR_NOT_IMPLEMENTED)
2546	{
2547	/** @todo implement generic fallback for screen blitting. */
2548	hrc = E_NOTIMPL;
2549	}
2550	else if (RT_FAILURE(vrc))
2551	hrc = setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("Could not draw to the screen (%Rrc)"), vrc);
2552	/// @todo
2553	// else
2554	// {
2555	// /* All ok. Redraw the screen. */
2556	// handleDisplayUpdate(x, y, width, height);
2557	// }
2558
2559	LogRelFlowFunc(("hrc=%Rhrc\n", hrc));
2560	return hrc;
2561	}
2562
2563	/** @todo r=bird: cannot quite see why this would be required to run on an
2564	* EMT any more. It's not an issue in the COM methods, but for the
2565	* VGA device interface it is an issue, see querySourceBitmap. */
2566	/static/ DECLCALLBACK(int) Display::i_InvalidateAndUpdateEMT(Display *pDisplay, unsigned uId, bool fUpdateAll)
2567	{
2568	LogRelFlowFunc(("uId=%d, fUpdateAll %d\n", uId, fUpdateAll));
2569
2570	unsigned uScreenId;
2571	for (uScreenId = (fUpdateAll ? 0 : uId); uScreenId < pDisplay->mcMonitors; uScreenId++)
2572	{
2573	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[uScreenId];
2574
2575	if ( !pFBInfo->fVBVAEnabled
2576	&& uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
2577	pDisplay->mpDrv->pUpPort->pfnUpdateDisplayAll(pDisplay->mpDrv->pUpPort, /* fFailOnResize = */ true);
2578	else
2579	{
2580	if (!pFBInfo->fDisabled)
2581	{
2582	/* Render complete VRAM screen to the framebuffer.
2583	* When framebuffer uses VRAM directly, just notify it to update.
2584	*/
2585	if (pFBInfo->fDefaultFormat && !pFBInfo->pSourceBitmap.isNull())
2586	{
2587	BYTE *pAddress = NULL;
2588	ULONG ulWidth = 0;
2589	ULONG ulHeight = 0;
2590	ULONG ulBitsPerPixel = 0;
2591	ULONG ulBytesPerLine = 0;
2592	BitmapFormat_T bitmapFormat = BitmapFormat_Opaque;
2593
2594	HRESULT hrc = pFBInfo->pSourceBitmap->QueryBitmapInfo(&pAddress,
2595	&ulWidth,
2596	&ulHeight,
2597	&ulBitsPerPixel,
2598	&ulBytesPerLine,
2599	&bitmapFormat);
2600	if (SUCCEEDED(hrc))
2601	{
2602	uint32_t width = pFBInfo->w;
2603	uint32_t height = pFBInfo->h;
2604
2605	const uint8_t *pu8Src = pFBInfo->pu8FramebufferVRAM;
2606	int32_t xSrc = 0;
2607	int32_t ySrc = 0;
2608	uint32_t u32SrcWidth = pFBInfo->w;
2609	uint32_t u32SrcHeight = pFBInfo->h;
2610	uint32_t u32SrcLineSize = pFBInfo->u32LineSize;
2611	uint32_t u32SrcBitsPerPixel = pFBInfo->u16BitsPerPixel;
2612
2613	/* Default format is 32 bpp. */
2614	uint8_t *pu8Dst = pAddress;
2615	int32_t xDst = xSrc;
2616	int32_t yDst = ySrc;
2617	uint32_t u32DstWidth = u32SrcWidth;
2618	uint32_t u32DstHeight = u32SrcHeight;
2619	uint32_t u32DstLineSize = u32DstWidth * 4;
2620	uint32_t u32DstBitsPerPixel = 32;
2621
2622	/* if uWidth != pFBInfo->w and uHeight != pFBInfo->h
2623	* implies resize of Framebuffer is in progress and
2624	* copyrect should not be called.
2625	*/
2626	if (ulWidth == pFBInfo->w && ulHeight == pFBInfo->h)
2627	pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
2628	width, height,
2629	pu8Src,
2630	xSrc, ySrc,
2631	u32SrcWidth, u32SrcHeight,
2632	u32SrcLineSize, u32SrcBitsPerPixel,
2633	pu8Dst,
2634	xDst, yDst,
2635	u32DstWidth, u32DstHeight,
2636	u32DstLineSize, u32DstBitsPerPixel);
2637	}
2638	}
2639
2640	pDisplay->i_handleDisplayUpdate(uScreenId, 0, 0, pFBInfo->w, pFBInfo->h);
2641	}
2642	}
2643	if (!fUpdateAll)
2644	break;
2645	}
2646	LogRelFlowFunc(("done\n"));
2647	return VINF_SUCCESS;
2648	}
2649
2650	/**
2651	* Does a full invalidation of the VM display and instructs the VM
2652	* to update it immediately.
2653	*
2654	* @returns COM status code
2655	*/
2656
2657	HRESULT Display::invalidateAndUpdate()
2658	{
2659	LogRelFlowFunc(("\n"));
2660
2661	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2662
2663	CHECK_CONSOLE_DRV(mpDrv);
2664
2665	Console::SafeVMPtr ptrVM(mParent);
2666	HRESULT hrc = ptrVM.hrc();
2667	if (SUCCEEDED(hrc))
2668	{
2669	LogRelFlowFunc(("Sending DPYUPDATE request\n"));
2670
2671	/* Have to release the lock when calling EMT. */
2672	alock.release();
2673
2674	int vrc = ptrVM.vtable()->pfnVMR3ReqCallNoWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_InvalidateAndUpdateEMT, 3,
2675	this, 0, true);
2676	alock.acquire();
2677
2678	if (RT_FAILURE(vrc))
2679	hrc = setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("Could not invalidate and update the screen (%Rrc)"), vrc);
2680	}
2681
2682	LogRelFlowFunc(("hrc=%Rhrc\n", hrc));
2683	return hrc;
2684	}
2685
2686	HRESULT Display::invalidateAndUpdateScreen(ULONG aScreenId)
2687	{
2688	LogRelFlowFunc(("\n"));
2689
2690	Console::SafeVMPtr ptrVM(mParent);
2691	HRESULT hrc = ptrVM.hrc();
2692	if (SUCCEEDED(hrc))
2693	{
2694	int vrc = ptrVM.vtable()->pfnVMR3ReqCallNoWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_InvalidateAndUpdateEMT, 3,
2695	this, aScreenId, false);
2696	if (RT_FAILURE(vrc))
2697	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not invalidate and update the screen %d (%Rrc)"), aScreenId, vrc);
2698	}
2699
2700	LogRelFlowFunc(("hrc=%Rhrc\n", hrc));
2701	return hrc;
2702	}
2703
2704	HRESULT Display::viewportChanged(ULONG aScreenId, ULONG aX, ULONG aY, ULONG aWidth, ULONG aHeight)
2705	{
2706	AssertMsgReturn(aScreenId < mcMonitors, ("aScreendId=%d mcMonitors=%d\n", aScreenId, mcMonitors), E_INVALIDARG);
2707
2708	/* The driver might not have been constructed yet */
2709	if (mpDrv && mpDrv->pUpPort->pfnSetViewport)
2710	mpDrv->pUpPort->pfnSetViewport(mpDrv->pUpPort, aScreenId, aX, aY, aWidth, aHeight);
2711
2712	return S_OK;
2713	}
2714
2715	HRESULT Display::querySourceBitmap(ULONG aScreenId,
2716	ComPtr<IDisplaySourceBitmap> &aDisplaySourceBitmap)
2717	{
2718	LogRelFlowFunc(("aScreenId = %d\n", aScreenId));
2719
2720	Console::SafeVMPtr ptrVM(mParent);
2721	if (!ptrVM.isOk())
2722	return ptrVM.hrc();
2723
2724	CHECK_CONSOLE_DRV(mpDrv);
2725
2726	bool fSetRenderVRAM = false;
2727	bool fInvalidate = false;
2728
2729	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2730
2731	if (aScreenId >= mcMonitors)
2732	return setError(E_INVALIDARG, tr("QuerySourceBitmap: Invalid screen %d (total %d)"), aScreenId, mcMonitors);
2733
2734	if (!mfSourceBitmapEnabled)
2735	{
2736	aDisplaySourceBitmap = NULL;
2737	return E_FAIL;
2738	}
2739
2740	DISPLAYFBINFO *pFBInfo = &maFramebuffers[aScreenId];
2741
2742	/* No source bitmap for a blank guest screen. */
2743	if (pFBInfo->flags & VBVA_SCREEN_F_BLANK)
2744	{
2745	aDisplaySourceBitmap = NULL;
2746	return E_FAIL;
2747	}
2748
2749	HRESULT hr = S_OK;
2750
2751	if (pFBInfo->pSourceBitmap.isNull())
2752	{
2753	/* Create a new object. */
2754	ComObjPtr<DisplaySourceBitmap> obj;
2755	hr = obj.createObject();
2756	if (SUCCEEDED(hr))
2757	hr = obj->init(this, aScreenId, pFBInfo);
2758
2759	if (SUCCEEDED(hr))
2760	{
2761	pFBInfo->pSourceBitmap = obj;
2762	pFBInfo->fDefaultFormat = !obj->i_usesVRAM();
2763
2764	if (aScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
2765	{
2766	/* Start buffer updates. */
2767	BYTE *pAddress = NULL;
2768	ULONG ulWidth = 0;
2769	ULONG ulHeight = 0;
2770	ULONG ulBitsPerPixel = 0;
2771	ULONG ulBytesPerLine = 0;
2772	BitmapFormat_T bitmapFormat = BitmapFormat_Opaque;
2773
2774	pFBInfo->pSourceBitmap->QueryBitmapInfo(&pAddress,
2775	&ulWidth,
2776	&ulHeight,
2777	&ulBitsPerPixel,
2778	&ulBytesPerLine,
2779	&bitmapFormat);
2780
2781	mpDrv->IConnector.pbData = pAddress;
2782	mpDrv->IConnector.cbScanline = ulBytesPerLine;
2783	mpDrv->IConnector.cBits = ulBitsPerPixel;
2784	mpDrv->IConnector.cx = ulWidth;
2785	mpDrv->IConnector.cy = ulHeight;
2786
2787	fSetRenderVRAM = pFBInfo->fDefaultFormat;
2788	}
2789
2790	/* Make sure that the bitmap contains the latest image. */
2791	fInvalidate = pFBInfo->fDefaultFormat;
2792	}
2793	}
2794
2795	if (SUCCEEDED(hr))
2796	{
2797	pFBInfo->pSourceBitmap.queryInterfaceTo(aDisplaySourceBitmap.asOutParam());
2798	}
2799
2800	/* Leave the IDisplay lock because the VGA device must not be called under it. */
2801	alock.release();
2802
2803	if (SUCCEEDED(hr))
2804	{
2805	if (fSetRenderVRAM)
2806	mpDrv->pUpPort->pfnSetRenderVRAM(mpDrv->pUpPort, true);
2807
2808	if (fInvalidate)
2809	#if 1 /* bird: Cannot see why this needs to run on an EMT. It deadlocks now with timer callback moving to non-EMT worker threads. */
2810	Display::i_InvalidateAndUpdateEMT(this, aScreenId, false /fUpdateAll/);
2811	#else
2812	VMR3ReqCallWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_InvalidateAndUpdateEMT,
2813	3, this, aScreenId, false);
2814	#endif
2815	}
2816
2817	LogRelFlowFunc(("%Rhrc\n", hr));
2818	return hr;
2819	}
2820
2821	HRESULT Display::getGuestScreenLayout(std::vector<ComPtr<IGuestScreenInfo> > &aGuestScreenLayout)
2822	{
2823	NOREF(aGuestScreenLayout);
2824	return E_NOTIMPL;
2825	}
2826
2827	HRESULT Display::setScreenLayout(ScreenLayoutMode_T aScreenLayoutMode,
2828	const std::vector<ComPtr<IGuestScreenInfo> > &aGuestScreenInfo)
2829	{
2830	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2831
2832	if (aGuestScreenInfo.size() != mcMonitors)
2833	return E_INVALIDARG;
2834
2835	CHECK_CONSOLE_DRV(mpDrv);
2836
2837	/*
2838	* It is up to the guest to decide whether the hint is
2839	* valid. Therefore don't do any VRAM sanity checks here.
2840	*/
2841
2842	/* Have to release the lock because the pfnRequestDisplayChange
2843	* will call EMT. */
2844	alock.release();
2845
2846	VMMDev *pVMMDev = mParent->i_getVMMDev();
2847	if (pVMMDev)
2848	{
2849	PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
2850	if (pVMMDevPort)
2851	{
2852	uint32_t const cDisplays = (uint32_t)aGuestScreenInfo.size();
2853
2854	size_t const cbAlloc = cDisplays * sizeof(VMMDevDisplayDef);
2855	VMMDevDisplayDef paDisplayDefs = (VMMDevDisplayDef )RTMemAlloc(cbAlloc);
2856	if (paDisplayDefs)
2857	{
2858	for (uint32_t i = 0; i < cDisplays; ++i)
2859	{
2860	VMMDevDisplayDef *p = &paDisplayDefs[i];
2861	ComPtr<IGuestScreenInfo> pScreenInfo = aGuestScreenInfo[i];
2862
2863	ULONG screenId = 0;
2864	GuestMonitorStatus_T guestMonitorStatus = GuestMonitorStatus_Enabled;
2865	BOOL origin = FALSE;
2866	BOOL primary = FALSE;
2867	LONG originX = 0;
2868	LONG originY = 0;
2869	ULONG width = 0;
2870	ULONG height = 0;
2871	ULONG bitsPerPixel = 0;
2872
2873	pScreenInfo->COMGETTER(ScreenId) (&screenId);
2874	pScreenInfo->COMGETTER(GuestMonitorStatus)(&guestMonitorStatus);
2875	pScreenInfo->COMGETTER(Primary) (&primary);
2876	pScreenInfo->COMGETTER(Origin) (&origin);
2877	pScreenInfo->COMGETTER(OriginX) (&originX);
2878	pScreenInfo->COMGETTER(OriginY) (&originY);
2879	pScreenInfo->COMGETTER(Width) (&width);
2880	pScreenInfo->COMGETTER(Height) (&height);
2881	pScreenInfo->COMGETTER(BitsPerPixel)(&bitsPerPixel);
2882
2883	LogFlowFunc(("%d %d,%d %dx%d\n", screenId, originX, originY, width, height));
2884
2885	p->idDisplay = screenId;
2886	p->xOrigin = originX;
2887	p->yOrigin = originY;
2888	p->cx = width;
2889	p->cy = height;
2890	p->cBitsPerPixel = bitsPerPixel;
2891	p->fDisplayFlags = VMMDEV_DISPLAY_CX \| VMMDEV_DISPLAY_CY \| VMMDEV_DISPLAY_BPP;
2892	if (guestMonitorStatus == GuestMonitorStatus_Disabled)
2893	p->fDisplayFlags \|= VMMDEV_DISPLAY_DISABLED;
2894	if (origin)
2895	p->fDisplayFlags \|= VMMDEV_DISPLAY_ORIGIN;
2896	if (primary)
2897	p->fDisplayFlags \|= VMMDEV_DISPLAY_PRIMARY;
2898	}
2899
2900	bool const fForce = aScreenLayoutMode == ScreenLayoutMode_Reset
2901	\|\| aScreenLayoutMode == ScreenLayoutMode_Apply;
2902	bool const fNotify = aScreenLayoutMode != ScreenLayoutMode_Silent;
2903	pVMMDevPort->pfnRequestDisplayChange(pVMMDevPort, cDisplays, paDisplayDefs, fForce, fNotify);
2904
2905	RTMemFree(paDisplayDefs);
2906	}
2907	}
2908	}
2909	return S_OK;
2910	}
2911
2912	HRESULT Display::detachScreens(const std::vector<LONG> &aScreenIds)
2913	{
2914	NOREF(aScreenIds);
2915	return E_NOTIMPL;
2916	}
2917
2918	HRESULT Display::createGuestScreenInfo(ULONG aDisplay,
2919	GuestMonitorStatus_T aStatus,
2920	BOOL aPrimary,
2921	BOOL aChangeOrigin,
2922	LONG aOriginX,
2923	LONG aOriginY,
2924	ULONG aWidth,
2925	ULONG aHeight,
2926	ULONG aBitsPerPixel,
2927	ComPtr<IGuestScreenInfo> &aGuestScreenInfo)
2928	{
2929	/* Create a new object. */
2930	ComObjPtr<GuestScreenInfo> obj;
2931	HRESULT hr = obj.createObject();
2932	if (SUCCEEDED(hr))
2933	hr = obj->init(aDisplay, aStatus, aPrimary, aChangeOrigin, aOriginX, aOriginY,
2934	aWidth, aHeight, aBitsPerPixel);
2935	if (SUCCEEDED(hr))
2936	obj.queryInterfaceTo(aGuestScreenInfo.asOutParam());
2937
2938	return hr;
2939	}
2940
2941
2942	/*
2943	* GuestScreenInfo implementation.
2944	*/
2945	DEFINE_EMPTY_CTOR_DTOR(GuestScreenInfo)
2946
2947	HRESULT GuestScreenInfo::FinalConstruct()
2948	{
2949	return BaseFinalConstruct();
2950	}
2951
2952	void GuestScreenInfo::FinalRelease()
2953	{
2954	uninit();
2955
2956	BaseFinalRelease();
2957	}
2958
2959	HRESULT GuestScreenInfo::init(ULONG aDisplay,
2960	GuestMonitorStatus_T aGuestMonitorStatus,
2961	BOOL aPrimary,
2962	BOOL aChangeOrigin,
2963	LONG aOriginX,
2964	LONG aOriginY,
2965	ULONG aWidth,
2966	ULONG aHeight,
2967	ULONG aBitsPerPixel)
2968	{
2969	LogFlowThisFunc(("[%u]\n", aDisplay));
2970
2971	/* Enclose the state transition NotReady->InInit->Ready */
2972	AutoInitSpan autoInitSpan(this);
2973	AssertReturn(autoInitSpan.isOk(), E_FAIL);
2974
2975	mScreenId = aDisplay;
2976	mGuestMonitorStatus = aGuestMonitorStatus;
2977	mPrimary = aPrimary;
2978	mOrigin = aChangeOrigin;
2979	mOriginX = aOriginX;
2980	mOriginY = aOriginY;
2981	mWidth = aWidth;
2982	mHeight = aHeight;
2983	mBitsPerPixel = aBitsPerPixel;
2984
2985	/* Confirm a successful initialization */
2986	autoInitSpan.setSucceeded();
2987
2988	return S_OK;
2989	}
2990
2991	void GuestScreenInfo::uninit()
2992	{
2993	/* Enclose the state transition Ready->InUninit->NotReady */
2994	AutoUninitSpan autoUninitSpan(this);
2995	if (autoUninitSpan.uninitDone())
2996	return;
2997
2998	LogFlowThisFunc(("[%u]\n", mScreenId));
2999	}
3000
3001	HRESULT GuestScreenInfo::getScreenId(ULONG *aScreenId)
3002	{
3003	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3004	*aScreenId = mScreenId;
3005	return S_OK;
3006	}
3007
3008	HRESULT GuestScreenInfo::getGuestMonitorStatus(GuestMonitorStatus_T *aGuestMonitorStatus)
3009	{
3010	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3011	*aGuestMonitorStatus = mGuestMonitorStatus;
3012	return S_OK;
3013	}
3014
3015	HRESULT GuestScreenInfo::getPrimary(BOOL *aPrimary)
3016	{
3017	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3018	*aPrimary = mPrimary;
3019	return S_OK;
3020	}
3021
3022	HRESULT GuestScreenInfo::getOrigin(BOOL *aOrigin)
3023	{
3024	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3025	*aOrigin = mOrigin;
3026	return S_OK;
3027	}
3028
3029	HRESULT GuestScreenInfo::getOriginX(LONG *aOriginX)
3030	{
3031	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3032	*aOriginX = mOriginX;
3033	return S_OK;
3034	}
3035
3036	HRESULT GuestScreenInfo::getOriginY(LONG *aOriginY)
3037	{
3038	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3039	*aOriginY = mOriginY;
3040	return S_OK;
3041	}
3042
3043	HRESULT GuestScreenInfo::getWidth(ULONG *aWidth)
3044	{
3045	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3046	*aWidth = mWidth;
3047	return S_OK;
3048	}
3049
3050	HRESULT GuestScreenInfo::getHeight(ULONG *aHeight)
3051	{
3052	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3053	*aHeight = mHeight;
3054	return S_OK;
3055	}
3056
3057	HRESULT GuestScreenInfo::getBitsPerPixel(ULONG *aBitsPerPixel)
3058	{
3059	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3060	*aBitsPerPixel = mBitsPerPixel;
3061	return S_OK;
3062	}
3063
3064	HRESULT GuestScreenInfo::getExtendedInfo(com::Utf8Str &aExtendedInfo)
3065	{
3066	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3067	aExtendedInfo = com::Utf8Str();
3068	return S_OK;
3069	}
3070
3071	// wrapped IEventListener method
3072	HRESULT Display::handleEvent(const ComPtr<IEvent> &aEvent)
3073	{
3074	VBoxEventType_T aType = VBoxEventType_Invalid;
3075
3076	aEvent->COMGETTER(Type)(&aType);
3077	switch (aType)
3078	{
3079	case VBoxEventType_OnStateChanged:
3080	{
3081	ComPtr<IStateChangedEvent> scev = aEvent;
3082	Assert(scev);
3083	MachineState_T machineState;
3084	scev->COMGETTER(State)(&machineState);
3085	if ( machineState == MachineState_Running
3086	\|\| machineState == MachineState_Teleporting
3087	\|\| machineState == MachineState_LiveSnapshotting
3088	\|\| machineState == MachineState_DeletingSnapshotOnline
3089	)
3090	{
3091	LogRelFlowFunc(("Machine is running.\n"));
3092
3093	}
3094	break;
3095	}
3096	default:
3097	AssertFailed();
3098	}
3099
3100	return S_OK;
3101	}
3102
3103
3104	// private methods
3105	/////////////////////////////////////////////////////////////////////////////
3106
3107	/**
3108	* Handle display resize event issued by the VGA device for the primary screen.
3109	*
3110	* @see PDMIDISPLAYCONNECTOR::pfnResize
3111	*/
3112	DECLCALLBACK(int) Display::i_displayResizeCallback(PPDMIDISPLAYCONNECTOR pInterface,
3113	uint32_t bpp, void *pvVRAM, uint32_t cbLine, uint32_t cx, uint32_t cy)
3114	{
3115	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3116	Display *pThis = pDrv->pDisplay;
3117
3118	LogRelFlowFunc(("bpp %d, pvVRAM %p, cbLine %d, cx %d, cy %d\n",
3119	bpp, pvVRAM, cbLine, cx, cy));
3120
3121	bool f = ASMAtomicCmpXchgBool(&pThis->fVGAResizing, true, false);
3122	if (!f)
3123	{
3124	/* This is a result of recursive call when the source bitmap is being updated
3125	* during a VGA resize. Tell the VGA device to ignore the call.
3126	*
3127	* @todo It is a workaround, actually pfnUpdateDisplayAll must
3128	* fail on resize.
3129	*/
3130	LogRel(("displayResizeCallback: already processing\n"));
3131	return VINF_VGA_RESIZE_IN_PROGRESS;
3132	}
3133
3134	int vrc = pThis->i_handleDisplayResize(VBOX_VIDEO_PRIMARY_SCREEN, bpp, pvVRAM, cbLine, cx, cy, 0, 0, 0, true);
3135
3136	/* Restore the flag. */
3137	f = ASMAtomicCmpXchgBool(&pThis->fVGAResizing, false, true);
3138	AssertRelease(f);
3139
3140	return vrc;
3141	}
3142
3143	/**
3144	* Handle display update.
3145	*
3146	* @see PDMIDISPLAYCONNECTOR::pfnUpdateRect
3147	*/
3148	DECLCALLBACK(void) Display::i_displayUpdateCallback(PPDMIDISPLAYCONNECTOR pInterface,
3149	uint32_t x, uint32_t y, uint32_t cx, uint32_t cy)
3150	{
3151	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3152
3153	#ifdef DEBUG_sunlover
3154	LogFlowFunc(("fVideoAccelEnabled = %d, %d,%d %dx%d\n",
3155	pDrv->pDisplay->mVideoAccelLegacy.fVideoAccelEnabled, x, y, cx, cy));
3156	#endif /* DEBUG_sunlover */
3157
3158	/* This call does update regardless of VBVA status.
3159	* But in VBVA mode this is called only as result of
3160	* pfnUpdateDisplayAll in the VGA device.
3161	*/
3162
3163	pDrv->pDisplay->i_handleDisplayUpdate(VBOX_VIDEO_PRIMARY_SCREEN, x, y, cx, cy);
3164	}
3165
3166	/**
3167	* Periodic display refresh callback.
3168	*
3169	* @see PDMIDISPLAYCONNECTOR::pfnRefresh
3170	* @thread EMT
3171	*/
3172	/static/ DECLCALLBACK(void) Display::i_displayRefreshCallback(PPDMIDISPLAYCONNECTOR pInterface)
3173	{
3174	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3175
3176	STAM_PROFILE_START(&pDisplay->Stats.profileDisplayRefreshCallback, a);
3177
3178	Display *pDisplay = pDrv->pDisplay;
3179	unsigned uScreenId;
3180
3181	int vrc = pDisplay->i_videoAccelRefreshProcess(pDrv->pUpPort);
3182	if (vrc != VINF_TRY_AGAIN) /* Means 'do nothing' here. */
3183	{
3184	if (vrc == VWRN_INVALID_STATE)
3185	{
3186	/* No VBVA do a display update. */
3187	pDrv->pUpPort->pfnUpdateDisplay(pDrv->pUpPort);
3188	}
3189
3190	/* Inform the VRDP server that the current display update sequence is
3191	* completed. At this moment the framebuffer memory contains a definite
3192	* image, that is synchronized with the orders already sent to VRDP client.
3193	* The server can now process redraw requests from clients or initial
3194	* fullscreen updates for new clients.
3195	*/
3196	for (uScreenId = 0; uScreenId < pDisplay->mcMonitors; uScreenId++)
3197	{
3198	Assert(pDisplay->mParent && pDisplay->mParent->i_consoleVRDPServer());
3199	pDisplay->mParent->i_consoleVRDPServer()->SendUpdate(uScreenId, NULL, 0);
3200	}
3201	}
3202
3203	STAM_PROFILE_STOP(&pDisplay->Stats.profileDisplayRefreshCallback, a);
3204	}
3205
3206	/**
3207	* Reset notification
3208	*
3209	* @see PDMIDISPLAYCONNECTOR::pfnReset
3210	*/
3211	DECLCALLBACK(void) Display::i_displayResetCallback(PPDMIDISPLAYCONNECTOR pInterface)
3212	{
3213	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3214
3215	LogRelFlowFunc(("\n"));
3216
3217	/* Disable VBVA mode. */
3218	pDrv->pDisplay->VideoAccelEnableVGA(false, NULL);
3219	}
3220
3221	/**
3222	* LFBModeChange notification
3223	*
3224	* @see PDMIDISPLAYCONNECTOR::pfnLFBModeChange
3225	*/
3226	DECLCALLBACK(void) Display::i_displayLFBModeChangeCallback(PPDMIDISPLAYCONNECTOR pInterface, bool fEnabled)
3227	{
3228	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3229
3230	LogRelFlowFunc(("fEnabled=%d\n", fEnabled));
3231
3232	NOREF(fEnabled);
3233
3234	/* Disable VBVA mode in any case. The guest driver reenables VBVA mode if necessary. */
3235	pDrv->pDisplay->VideoAccelEnableVGA(false, NULL);
3236	}
3237
3238	/**
3239	* Adapter information change notification.
3240	*
3241	* @see PDMIDISPLAYCONNECTOR::pfnProcessAdapterData
3242	*/
3243	DECLCALLBACK(void) Display::i_displayProcessAdapterDataCallback(PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM,
3244	uint32_t u32VRAMSize)
3245	{
3246	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3247	pDrv->pDisplay->processAdapterData(pvVRAM, u32VRAMSize);
3248	}
3249
3250	/**
3251	* Display information change notification.
3252	*
3253	* @see PDMIDISPLAYCONNECTOR::pfnProcessDisplayData
3254	*/
3255	DECLCALLBACK(void) Display::i_displayProcessDisplayDataCallback(PPDMIDISPLAYCONNECTOR pInterface,
3256	void *pvVRAM, unsigned uScreenId)
3257	{
3258	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3259	pDrv->pDisplay->processDisplayData(pvVRAM, uScreenId);
3260	}
3261
3262	int Display::i_handle3DNotifyProcess(VBOX3DNOTIFY *p3DNotify)
3263	{
3264	unsigned const id = (unsigned)p3DNotify->iDisplay;
3265	if (id >= mcMonitors)
3266	return VERR_INVALID_PARAMETER;
3267
3268	ComPtr<IFramebuffer> pFramebuffer;
3269	AutoReadLock arlock(this COMMA_LOCKVAL_SRC_POS);
3270	pFramebuffer = maFramebuffers[id].pFramebuffer;
3271	arlock.release();
3272
3273	int vrc = VINF_SUCCESS;
3274
3275	if (!pFramebuffer.isNull())
3276	{
3277	if (p3DNotify->enmNotification == VBOX3D_NOTIFY_TYPE_HW_OVERLAY_GET_ID)
3278	{
3279	LONG64 winId = 0;
3280	HRESULT hrc = pFramebuffer->COMGETTER(WinId)(&winId);
3281	if (SUCCEEDED(hrc))
3282	{
3283	(uint64_t )&p3DNotify->au8Data[0] = winId;
3284	}
3285	else
3286	vrc = VERR_NOT_SUPPORTED;
3287	}
3288	else
3289	{
3290	com::SafeArray<BYTE> data;
3291	data.initFrom((BYTE *)&p3DNotify->au8Data[0], p3DNotify->cbData);
3292
3293	HRESULT hrc = pFramebuffer->Notify3DEvent((ULONG)p3DNotify->enmNotification, ComSafeArrayAsInParam(data));
3294	if (FAILED(hrc))
3295	vrc = VERR_NOT_SUPPORTED;
3296	}
3297	}
3298	else
3299	vrc = VERR_NOT_IMPLEMENTED;
3300
3301	return vrc;
3302	}
3303
3304	DECLCALLBACK(int) Display::i_display3DNotifyProcess(PPDMIDISPLAYCONNECTOR pInterface,
3305	VBOX3DNOTIFY *p3DNotify)
3306	{
3307	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3308	return pDrv->pDisplay->i_handle3DNotifyProcess(p3DNotify);
3309	}
3310
3311	HRESULT Display::notifyScaleFactorChange(ULONG aScreenId, ULONG aScaleFactorWMultiplied, ULONG aScaleFactorHMultiplied)
3312	{
3313	RT_NOREF(aScreenId, aScaleFactorWMultiplied, aScaleFactorHMultiplied);
3314	# if 0 /** @todo Thank you so very much from anyone using VMSVGA3d! */
3315	AssertMsgFailed(("Attempt to specify OpenGL content scale factor while 3D acceleration is disabled in VM config. Ignored.\n"));
3316	# else
3317	/* Need an interface like this here (and the #ifdefs needs adjusting):
3318	PPDMIDISPLAYPORT pUpPort = mpDrv ? mpDrv->pUpPort : NULL;
3319	if (pUpPort && pUpPort->pfnSetScaleFactor)
3320	pUpPort->pfnSetScaleFactor(pUpPort, aScreeId, aScaleFactorWMultiplied, aScaleFactorHMultiplied); */
3321	# endif
3322	return S_OK;
3323	}
3324
3325	HRESULT Display::notifyHiDPIOutputPolicyChange(BOOL fUnscaledHiDPI)
3326	{
3327	RT_NOREF(fUnscaledHiDPI);
3328
3329	/* Need an interface like this here (and the #ifdefs needs adjusting):
3330	PPDMIDISPLAYPORT pUpPort = mpDrv ? mpDrv->pUpPort : NULL;
3331	if (pUpPort && pUpPort->pfnSetScaleFactor)
3332	pUpPort->pfnSetScaleFactor(pUpPort, aScreeId, aScaleFactorWMultiplied, aScaleFactorHMultiplied); */
3333
3334	return S_OK;
3335	}
3336
3337	#ifdef VBOX_WITH_HGSMI
3338	/**
3339	* @interface_method_impl{PDMIDISPLAYCONNECTOR,pfnVBVAEnable}
3340	*/
3341	DECLCALLBACK(int) Display::i_displayVBVAEnable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId,
3342	VBVAHOSTFLAGS RT_UNTRUSTED_VOLATILE_GUEST *pHostFlags)
3343	{
3344	LogRelFlowFunc(("uScreenId %d\n", uScreenId));
3345
3346	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3347	Display *pThis = pDrv->pDisplay;
3348	AssertReturn(uScreenId < pThis->mcMonitors, VERR_INVALID_PARAMETER);
3349
3350	if (pThis->maFramebuffers[uScreenId].fVBVAEnabled)
3351	{
3352	LogRel(("Enabling different vbva mode\n"));
3353	#ifdef DEBUG_misha
3354	AssertMsgFailed(("enabling different vbva mode\n"));
3355	#endif
3356	return VERR_INVALID_STATE;
3357	}
3358
3359	pThis->maFramebuffers[uScreenId].fVBVAEnabled = true;
3360	pThis->maFramebuffers[uScreenId].pVBVAHostFlags = pHostFlags;
3361	pThis->maFramebuffers[uScreenId].fVBVAForceResize = true;
3362
3363	vbvaSetMemoryFlagsHGSMI(uScreenId, pThis->mfu32SupportedOrders, pThis->mfVideoAccelVRDP, &pThis->maFramebuffers[uScreenId]);
3364
3365	return VINF_SUCCESS;
3366	}
3367
3368	/**
3369	* @interface_method_impl{PDMIDISPLAYCONNECTOR,pfnVBVADisable}
3370	*/
3371	DECLCALLBACK(void) Display::i_displayVBVADisable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId)
3372	{
3373	LogRelFlowFunc(("uScreenId %d\n", uScreenId));
3374
3375	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3376	Display *pThis = pDrv->pDisplay;
3377	AssertReturnVoid(uScreenId < pThis->mcMonitors);
3378
3379	DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[uScreenId];
3380
3381	if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
3382	{
3383	/* Make sure that the primary screen is visible now.
3384	* The guest can't use VBVA anymore, so only only the VGA device output works.
3385	*/
3386	pFBInfo->flags = 0;
3387	if (pFBInfo->fDisabled)
3388	{
3389	pFBInfo->fDisabled = false;
3390	::FireGuestMonitorChangedEvent(pThis->mParent->i_getEventSource(), GuestMonitorChangedEventType_Enabled, uScreenId,
3391	pFBInfo->xOrigin, pFBInfo->yOrigin, pFBInfo->w, pFBInfo->h);
3392	}
3393	}
3394
3395	pFBInfo->fVBVAEnabled = false;
3396	pFBInfo->fVBVAForceResize = false;
3397
3398	vbvaSetMemoryFlagsHGSMI(uScreenId, 0, false, pFBInfo);
3399
3400	pFBInfo->pVBVAHostFlags = NULL;
3401
3402	if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
3403	{
3404	/* Force full screen update, because VGA device must take control, do resize, etc. */
3405	pThis->mpDrv->pUpPort->pfnUpdateDisplayAll(pThis->mpDrv->pUpPort, /* fFailOnResize = */ false);
3406	}
3407	}
3408
3409	DECLCALLBACK(void) Display::i_displayVBVAUpdateBegin(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId)
3410	{
3411	RT_NOREF(uScreenId);
3412	LogFlowFunc(("uScreenId %d\n", uScreenId));
3413
3414	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3415	Display *pThis = pDrv->pDisplay;
3416
3417	if (ASMAtomicReadU32(&pThis->mu32UpdateVBVAFlags) > 0)
3418	{
3419	vbvaSetMemoryFlagsAllHGSMI(pThis->mfu32SupportedOrders, pThis->mfVideoAccelVRDP, pThis->maFramebuffers,
3420	pThis->mcMonitors);
3421	ASMAtomicDecU32(&pThis->mu32UpdateVBVAFlags);
3422	}
3423	}
3424
3425	/**
3426	* @interface_method_impl{PDMIDISPLAYCONNECTOR,pfnVBVAUpdateProcess}
3427	*/
3428	DECLCALLBACK(void) Display::i_displayVBVAUpdateProcess(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId,
3429	struct VBVACMDHDR const RT_UNTRUSTED_VOLATILE_GUEST *pCmd, size_t cbCmd)
3430	{
3431	LogFlowFunc(("uScreenId %d pCmd %p cbCmd %d, @%d,%d %dx%d\n", uScreenId, pCmd, cbCmd, pCmd->x, pCmd->y, pCmd->w, pCmd->h));
3432	VBVACMDHDR hdrSaved;
3433	RT_COPY_VOLATILE(hdrSaved, *pCmd);
3434	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
3435
3436	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3437	Display *pThis = pDrv->pDisplay;
3438	DISPLAYFBINFO *pFBInfo;
3439	AssertReturnVoid(uScreenId < pThis->mcMonitors);
3440
3441	pFBInfo = &pThis->maFramebuffers[uScreenId];
3442
3443	if (pFBInfo->fDefaultFormat)
3444	{
3445	/* Make sure that framebuffer contains the same image as the guest VRAM. */
3446	if ( uScreenId == VBOX_VIDEO_PRIMARY_SCREEN
3447	&& !pFBInfo->fDisabled)
3448	{
3449	pDrv->pUpPort->pfnUpdateDisplayRect(pDrv->pUpPort, hdrSaved.x, hdrSaved.y, hdrSaved.w, hdrSaved.h);
3450	}
3451	else if ( !pFBInfo->pSourceBitmap.isNull()
3452	&& !pFBInfo->fDisabled)
3453	{
3454	/* Render VRAM content to the framebuffer. */
3455	BYTE *pAddress = NULL;
3456	ULONG ulWidth = 0;
3457	ULONG ulHeight = 0;
3458	ULONG ulBitsPerPixel = 0;
3459	ULONG ulBytesPerLine = 0;
3460	BitmapFormat_T bitmapFormat = BitmapFormat_Opaque;
3461
3462	HRESULT hrc = pFBInfo->pSourceBitmap->QueryBitmapInfo(&pAddress,
3463	&ulWidth,
3464	&ulHeight,
3465	&ulBitsPerPixel,
3466	&ulBytesPerLine,
3467	&bitmapFormat);
3468	if (SUCCEEDED(hrc))
3469	{
3470	uint32_t width = hdrSaved.w;
3471	uint32_t height = hdrSaved.h;
3472
3473	const uint8_t *pu8Src = pFBInfo->pu8FramebufferVRAM;
3474	int32_t xSrc = hdrSaved.x - pFBInfo->xOrigin;
3475	int32_t ySrc = hdrSaved.y - pFBInfo->yOrigin;
3476	uint32_t u32SrcWidth = pFBInfo->w;
3477	uint32_t u32SrcHeight = pFBInfo->h;
3478	uint32_t u32SrcLineSize = pFBInfo->u32LineSize;
3479	uint32_t u32SrcBitsPerPixel = pFBInfo->u16BitsPerPixel;
3480
3481	uint8_t *pu8Dst = pAddress;
3482	int32_t xDst = xSrc;
3483	int32_t yDst = ySrc;
3484	uint32_t u32DstWidth = u32SrcWidth;
3485	uint32_t u32DstHeight = u32SrcHeight;
3486	uint32_t u32DstLineSize = u32DstWidth * 4;
3487	uint32_t u32DstBitsPerPixel = 32;
3488
3489	pDrv->pUpPort->pfnCopyRect(pDrv->pUpPort,
3490	width, height,
3491	pu8Src,
3492	xSrc, ySrc,
3493	u32SrcWidth, u32SrcHeight,
3494	u32SrcLineSize, u32SrcBitsPerPixel,
3495	pu8Dst,
3496	xDst, yDst,
3497	u32DstWidth, u32DstHeight,
3498	u32DstLineSize, u32DstBitsPerPixel);
3499	}
3500	}
3501	}
3502
3503	/*
3504	* Here is your classic 'temporary' solution.
3505	*/
3506	/** @todo New SendUpdate entry which can get a separate cmd header or coords. */
3507	VBVACMDHDR pHdrUnconst = (VBVACMDHDR )pCmd;
3508
3509	pHdrUnconst->x -= (int16_t)pFBInfo->xOrigin;
3510	pHdrUnconst->y -= (int16_t)pFBInfo->yOrigin;
3511
3512	pThis->mParent->i_consoleVRDPServer()->SendUpdate(uScreenId, pHdrUnconst, (uint32_t)cbCmd);
3513
3514	*pHdrUnconst = hdrSaved;
3515	}
3516
3517	DECLCALLBACK(void) Display::i_displayVBVAUpdateEnd(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, int32_t x, int32_t y,
3518	uint32_t cx, uint32_t cy)
3519	{
3520	LogFlowFunc(("uScreenId %d %d,%d %dx%d\n", uScreenId, x, y, cx, cy));
3521
3522	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3523	Display *pThis = pDrv->pDisplay;
3524	DISPLAYFBINFO *pFBInfo;
3525	AssertReturnVoid(uScreenId < pThis->mcMonitors);
3526
3527	pFBInfo = &pThis->maFramebuffers[uScreenId];
3528
3529	/** @todo handleFramebufferUpdate (uScreenId,
3530	* x - pThis->maFramebuffers[uScreenId].xOrigin,
3531	* y - pThis->maFramebuffers[uScreenId].yOrigin,
3532	* cx, cy);
3533	*/
3534	pThis->i_handleDisplayUpdate(uScreenId, x - pFBInfo->xOrigin, y - pFBInfo->yOrigin, cx, cy);
3535	}
3536
3537	#ifdef DEBUG_sunlover
3538	static void logVBVAResize(PCVBVAINFOVIEW pView, PCVBVAINFOSCREEN pScreen, const DISPLAYFBINFO *pFBInfo)
3539	{
3540	LogRel(("displayVBVAResize: [%d] %s\n"
3541	" pView->u32ViewIndex %d\n"
3542	" pView->u32ViewOffset 0x%08X\n"
3543	" pView->u32ViewSize 0x%08X\n"
3544	" pView->u32MaxScreenSize 0x%08X\n"
3545	" pScreen->i32OriginX %d\n"
3546	" pScreen->i32OriginY %d\n"
3547	" pScreen->u32StartOffset 0x%08X\n"
3548	" pScreen->u32LineSize 0x%08X\n"
3549	" pScreen->u32Width %d\n"
3550	" pScreen->u32Height %d\n"
3551	" pScreen->u16BitsPerPixel %d\n"
3552	" pScreen->u16Flags 0x%04X\n"
3553	" pFBInfo->u32Offset 0x%08X\n"
3554	" pFBInfo->u32MaxFramebufferSize 0x%08X\n"
3555	" pFBInfo->u32InformationSize 0x%08X\n"
3556	" pFBInfo->fDisabled %d\n"
3557	" xOrigin, yOrigin, w, h: %d,%d %dx%d\n"
3558	" pFBInfo->u16BitsPerPixel %d\n"
3559	" pFBInfo->pu8FramebufferVRAM %p\n"
3560	" pFBInfo->u32LineSize 0x%08X\n"
3561	" pFBInfo->flags 0x%04X\n"
3562	" pFBInfo->pHostEvents %p\n"
3563	" pFBInfo->fDefaultFormat %d\n"
3564	" pFBInfo->fVBVAEnabled %d\n"
3565	" pFBInfo->fVBVAForceResize %d\n"
3566	" pFBInfo->pVBVAHostFlags %p\n"
3567	"",
3568	pScreen->u32ViewIndex,
3569	(pScreen->u16Flags & VBVA_SCREEN_F_DISABLED)? "DISABLED": "ENABLED",
3570	pView->u32ViewIndex,
3571	pView->u32ViewOffset,
3572	pView->u32ViewSize,
3573	pView->u32MaxScreenSize,
3574	pScreen->i32OriginX,
3575	pScreen->i32OriginY,
3576	pScreen->u32StartOffset,
3577	pScreen->u32LineSize,
3578	pScreen->u32Width,
3579	pScreen->u32Height,
3580	pScreen->u16BitsPerPixel,
3581	pScreen->u16Flags,
3582	pFBInfo->u32Offset,
3583	pFBInfo->u32MaxFramebufferSize,
3584	pFBInfo->u32InformationSize,
3585	pFBInfo->fDisabled,
3586	pFBInfo->xOrigin,
3587	pFBInfo->yOrigin,
3588	pFBInfo->w,
3589	pFBInfo->h,
3590	pFBInfo->u16BitsPerPixel,
3591	pFBInfo->pu8FramebufferVRAM,
3592	pFBInfo->u32LineSize,
3593	pFBInfo->flags,
3594	pFBInfo->pHostEvents,
3595	pFBInfo->fDefaultFormat,
3596	pFBInfo->fVBVAEnabled,
3597	pFBInfo->fVBVAForceResize,
3598	pFBInfo->pVBVAHostFlags
3599	));
3600	}
3601	#endif /* DEBUG_sunlover */
3602
3603	DECLCALLBACK(int) Display::i_displayVBVAResize(PPDMIDISPLAYCONNECTOR pInterface, PCVBVAINFOVIEW pView,
3604	PCVBVAINFOSCREEN pScreen, void *pvVRAM, bool fResetInputMapping)
3605	{
3606	LogRelFlowFunc(("pScreen %p, pvVRAM %p\n", pScreen, pvVRAM));
3607
3608	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3609	Display *pThis = pDrv->pDisplay;
3610
3611	return pThis->processVBVAResize(pView, pScreen, pvVRAM, fResetInputMapping);
3612	}
3613
3614	int Display::processVBVAResize(PCVBVAINFOVIEW pView, PCVBVAINFOSCREEN pScreen, void *pvVRAM, bool fResetInputMapping)
3615	{
3616	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3617
3618	RT_NOREF(pView);
3619
3620	DISPLAYFBINFO *pFBInfo = &maFramebuffers[pScreen->u32ViewIndex];
3621
3622	#ifdef DEBUG_sunlover
3623	logVBVAResize(pView, pScreen, pFBInfo);
3624	#endif
3625
3626	if (pScreen->u16Flags & VBVA_SCREEN_F_DISABLED)
3627	{
3628	/* Ask the framebuffer to resize using a default format. The framebuffer will be black.
3629	* So if the frontend does not support GuestMonitorChangedEventType_Disabled event,
3630	* the VM window will be black. */
3631	uint32_t u32Width = pFBInfo->w ? pFBInfo->w : 640;
3632	uint32_t u32Height = pFBInfo->h ? pFBInfo->h : 480;
3633	int32_t xOrigin = pFBInfo->xOrigin;
3634	int32_t yOrigin = pFBInfo->yOrigin;
3635
3636	alock.release();
3637
3638	i_handleDisplayResize(pScreen->u32ViewIndex, 0, (uint8_t *)NULL, 0,
3639	u32Width, u32Height, pScreen->u16Flags, xOrigin, yOrigin, false);
3640
3641	return VINF_SUCCESS;
3642	}
3643
3644	VBVAINFOSCREEN screenInfo;
3645	RT_ZERO(screenInfo);
3646
3647	if (pScreen->u16Flags & VBVA_SCREEN_F_BLANK2)
3648	{
3649	/* Init a local VBVAINFOSCREEN structure, which will be used instead of
3650	* the original pScreen. Set VBVA_SCREEN_F_BLANK, which will force
3651	* the code below to choose the "blanking" branches.
3652	*/
3653	screenInfo.u32ViewIndex = pScreen->u32ViewIndex;
3654	screenInfo.i32OriginX = pFBInfo->xOrigin;
3655	screenInfo.i32OriginY = pFBInfo->yOrigin;
3656	screenInfo.u32StartOffset = 0; /* Irrelevant */
3657	screenInfo.u32LineSize = pFBInfo->u32LineSize;
3658	screenInfo.u32Width = pFBInfo->w;
3659	screenInfo.u32Height = pFBInfo->h;
3660	screenInfo.u16BitsPerPixel = pFBInfo->u16BitsPerPixel;
3661	screenInfo.u16Flags = pScreen->u16Flags \| VBVA_SCREEN_F_BLANK;
3662
3663	pScreen = &screenInfo;
3664	}
3665
3666	if (fResetInputMapping)
3667	{
3668	/// @todo Rename to m* and verify whether some kind of lock is required.
3669	xInputMappingOrigin = 0;
3670	yInputMappingOrigin = 0;
3671	cxInputMapping = 0;
3672	cyInputMapping = 0;
3673	}
3674
3675	alock.release();
3676
3677	return i_handleDisplayResize(pScreen->u32ViewIndex, pScreen->u16BitsPerPixel,
3678	(uint8_t *)pvVRAM + pScreen->u32StartOffset,
3679	pScreen->u32LineSize, pScreen->u32Width, pScreen->u32Height, pScreen->u16Flags,
3680	pScreen->i32OriginX, pScreen->i32OriginY, false);
3681	}
3682
3683	DECLCALLBACK(int) Display::i_displayVBVAMousePointerShape(PPDMIDISPLAYCONNECTOR pInterface, bool fVisible, bool fAlpha,
3684	uint32_t xHot, uint32_t yHot,
3685	uint32_t cx, uint32_t cy,
3686	const void *pvShape)
3687	{
3688	LogFlowFunc(("\n"));
3689	LogRel2(("%s: fVisible=%RTbool\n", __PRETTY_FUNCTION__, fVisible));
3690
3691	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3692
3693	uint32_t cbShape = 0;
3694	if (pvShape)
3695	{
3696	cbShape = (cx + 7) / 8 * cy; /* size of the AND mask */
3697	cbShape = ((cbShape + 3) & ~3) + cx * 4 * cy; /* + gap + size of the XOR mask */
3698	}
3699
3700	/* Tell the console about it */
3701	pDrv->pDisplay->mParent->i_onMousePointerShapeChange(fVisible, fAlpha,
3702	xHot, yHot, cx, cy, (uint8_t *)pvShape, cbShape);
3703
3704	return VINF_SUCCESS;
3705	}
3706
3707	DECLCALLBACK(void) Display::i_displayVBVAGuestCapabilityUpdate(PPDMIDISPLAYCONNECTOR pInterface, uint32_t fCapabilities)
3708	{
3709	LogFlowFunc(("\n"));
3710
3711	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3712	Display *pThis = pDrv->pDisplay;
3713
3714	pThis->i_handleUpdateGuestVBVACapabilities(fCapabilities);
3715	}
3716
3717	DECLCALLBACK(void) Display::i_displayVBVAInputMappingUpdate(PPDMIDISPLAYCONNECTOR pInterface, int32_t xOrigin, int32_t yOrigin,
3718	uint32_t cx, uint32_t cy)
3719	{
3720	LogFlowFunc(("\n"));
3721
3722	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3723	Display *pThis = pDrv->pDisplay;
3724
3725	pThis->i_handleUpdateVBVAInputMapping(xOrigin, yOrigin, cx, cy);
3726	}
3727
3728	DECLCALLBACK(void) Display::i_displayVBVAReportCursorPosition(PPDMIDISPLAYCONNECTOR pInterface, uint32_t fFlags, uint32_t aScreenId, uint32_t x, uint32_t y)
3729	{
3730	LogFlowFunc(("\n"));
3731	LogRel2(("%s: fFlags=%RU32, aScreenId=%RU32, x=%RU32, y=%RU32\n",
3732	__PRETTY_FUNCTION__, fFlags, aScreenId, x, y));
3733
3734	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3735	Display *pThis = pDrv->pDisplay;
3736
3737	if (fFlags & VBVA_CURSOR_SCREEN_RELATIVE)
3738	{
3739	AssertReturnVoid(aScreenId < pThis->mcMonitors);
3740
3741	x += pThis->maFramebuffers[aScreenId].xOrigin;
3742	y += pThis->maFramebuffers[aScreenId].yOrigin;
3743	}
3744	::FireCursorPositionChangedEvent(pThis->mParent->i_getEventSource(), RT_BOOL(fFlags & VBVA_CURSOR_VALID_DATA), x, y);
3745
3746	# ifdef VBOX_WITH_RECORDING
3747	pThis->i_recordingCursorPositionChange(aScreenId, fFlags, x, y);
3748	# endif
3749	}
3750
3751	#endif /* VBOX_WITH_HGSMI */
3752
3753	/**
3754	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
3755	*/
3756	DECLCALLBACK(void ) Display::i_drvQueryInterface(PPDMIBASE pInterface, const char pszIID)
3757	{
3758	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
3759	PDRVMAINDISPLAY pDrv = PDMINS_2_DATA(pDrvIns, PDRVMAINDISPLAY);
3760	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
3761	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIDISPLAYCONNECTOR, &pDrv->IConnector);
3762	return NULL;
3763	}
3764
3765
3766	/**
3767	* @interface_method_impl{PDMDRVREG,pfnPowerOff,
3768	* Tries to ensure no client calls gets to HGCM or the VGA device from here on.}
3769	*/
3770	DECLCALLBACK(void) Display::i_drvPowerOff(PPDMDRVINS pDrvIns)
3771	{
3772	PDRVMAINDISPLAY pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINDISPLAY);
3773	LogRelFlowFunc(("iInstance=%d\n", pDrvIns->iInstance));
3774
3775	/*
3776	* Do much of the work that i_drvDestruct does.
3777	*/
3778	if (pThis->pUpPort)
3779	pThis->pUpPort->pfnSetRenderVRAM(pThis->pUpPort, false);
3780
3781	pThis->IConnector.pbData = NULL;
3782	pThis->IConnector.cbScanline = 0;
3783	pThis->IConnector.cBits = 32;
3784	pThis->IConnector.cx = 0;
3785	pThis->IConnector.cy = 0;
3786
3787	if (pThis->pDisplay)
3788	{
3789	AutoWriteLock displayLock(pThis->pDisplay COMMA_LOCKVAL_SRC_POS);
3790	#ifdef VBOX_WITH_RECORDING
3791	pThis->pDisplay->mParent->i_recordingStop();
3792	#endif
3793	}
3794	}
3795
3796
3797	/**
3798	* Destruct a display driver instance.
3799	*
3800	* @param pDrvIns The driver instance data.
3801	*/
3802	DECLCALLBACK(void) Display::i_drvDestruct(PPDMDRVINS pDrvIns)
3803	{
3804	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
3805	PDRVMAINDISPLAY pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINDISPLAY);
3806	LogRelFlowFunc(("iInstance=%d\n", pDrvIns->iInstance));
3807
3808	/*
3809	* We repeat much of what i_drvPowerOff does in case it wasn't called.
3810	* In addition we sever the connection between us and the display.
3811	*/
3812	if (pThis->pUpPort)
3813	pThis->pUpPort->pfnSetRenderVRAM(pThis->pUpPort, false);
3814
3815	pThis->IConnector.pbData = NULL;
3816	pThis->IConnector.cbScanline = 0;
3817	pThis->IConnector.cBits = 32;
3818	pThis->IConnector.cx = 0;
3819	pThis->IConnector.cy = 0;
3820
3821	if (pThis->pDisplay)
3822	{
3823	AutoWriteLock displayLock(pThis->pDisplay COMMA_LOCKVAL_SRC_POS);
3824	#ifdef VBOX_WITH_RECORDING
3825	pThis->pDisplay->mParent->i_recordingStop();
3826	#endif
3827	pThis->pDisplay->mpDrv = NULL;
3828	pThis->pDisplay = NULL;
3829	}
3830	}
3831
3832
3833	/**
3834	* Construct a display driver instance.
3835	*
3836	* @copydoc FNPDMDRVCONSTRUCT
3837	*/
3838	DECLCALLBACK(int) Display::i_drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
3839	{
3840	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
3841	RT_NOREF(fFlags, pCfg);
3842	PDRVMAINDISPLAY pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINDISPLAY);
3843	LogRelFlowFunc(("iInstance=%d\n", pDrvIns->iInstance));
3844
3845	/*
3846	* Validate configuration.
3847	*/
3848	PDMDRV_VALIDATE_CONFIG_RETURN(pDrvIns, "", "");
3849	AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
3850	("Configuration error: Not possible to attach anything to this driver!\n"),
3851	VERR_PDM_DRVINS_NO_ATTACH);
3852
3853	/*
3854	* Init Interfaces.
3855	*/
3856	pDrvIns->IBase.pfnQueryInterface = Display::i_drvQueryInterface;
3857
3858	pThis->IConnector.pfnResize = Display::i_displayResizeCallback;
3859	pThis->IConnector.pfnUpdateRect = Display::i_displayUpdateCallback;
3860	pThis->IConnector.pfnRefresh = Display::i_displayRefreshCallback;
3861	pThis->IConnector.pfnReset = Display::i_displayResetCallback;
3862	pThis->IConnector.pfnLFBModeChange = Display::i_displayLFBModeChangeCallback;
3863	pThis->IConnector.pfnProcessAdapterData = Display::i_displayProcessAdapterDataCallback;
3864	pThis->IConnector.pfnProcessDisplayData = Display::i_displayProcessDisplayDataCallback;
3865	#ifdef VBOX_WITH_HGSMI
3866	pThis->IConnector.pfnVBVAEnable = Display::i_displayVBVAEnable;
3867	pThis->IConnector.pfnVBVADisable = Display::i_displayVBVADisable;
3868	pThis->IConnector.pfnVBVAUpdateBegin = Display::i_displayVBVAUpdateBegin;
3869	pThis->IConnector.pfnVBVAUpdateProcess = Display::i_displayVBVAUpdateProcess;
3870	pThis->IConnector.pfnVBVAUpdateEnd = Display::i_displayVBVAUpdateEnd;
3871	pThis->IConnector.pfnVBVAResize = Display::i_displayVBVAResize;
3872	pThis->IConnector.pfnVBVAMousePointerShape = Display::i_displayVBVAMousePointerShape;
3873	pThis->IConnector.pfnVBVAGuestCapabilityUpdate = Display::i_displayVBVAGuestCapabilityUpdate;
3874	pThis->IConnector.pfnVBVAInputMappingUpdate = Display::i_displayVBVAInputMappingUpdate;
3875	pThis->IConnector.pfnVBVAReportCursorPosition = Display::i_displayVBVAReportCursorPosition;
3876	#endif
3877	pThis->IConnector.pfn3DNotifyProcess = Display::i_display3DNotifyProcess;
3878
3879	/*
3880	* Get the IDisplayPort interface of the above driver/device.
3881	*/
3882	pThis->pUpPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIDISPLAYPORT);
3883	if (!pThis->pUpPort)
3884	{
3885	AssertMsgFailed(("Configuration error: No display port interface above!\n"));
3886	return VERR_PDM_MISSING_INTERFACE_ABOVE;
3887	}
3888
3889	/*
3890	* Get the Display object pointer and update the mpDrv member.
3891	*/
3892	com::Guid uuid(COM_IIDOF(IDisplay));
3893	IDisplay pIDisplay = (IDisplay )PDMDrvHlpQueryGenericUserObject(pDrvIns, uuid.raw());
3894	if (!pIDisplay)
3895	{
3896	AssertMsgFailed(("Configuration error: No/bad Keyboard object!\n"));
3897	return VERR_NOT_FOUND;
3898	}
3899	pThis->pDisplay = static_cast<Display *>(pIDisplay);
3900	pThis->pDisplay->mpDrv = pThis;
3901
3902	/* Disable VRAM to a buffer copy initially. */
3903	pThis->pUpPort->pfnSetRenderVRAM(pThis->pUpPort, false);
3904	pThis->IConnector.cBits = 32; /* DevVGA does nothing otherwise. */
3905
3906	/*
3907	* Start periodic screen refreshes
3908	*/
3909	pThis->pUpPort->pfnSetRefreshRate(pThis->pUpPort, 20);
3910
3911	return VINF_SUCCESS;
3912	}
3913
3914
3915	/**
3916	* Display driver registration record.
3917	*/
3918	const PDMDRVREG Display::DrvReg =
3919	{
3920	/* u32Version */
3921	PDM_DRVREG_VERSION,
3922	/* szName */
3923	"MainDisplay",
3924	/* szRCMod */
3925	"",
3926	/* szR0Mod */
3927	"",
3928	/* pszDescription */
3929	"Main display driver (Main as in the API).",
3930	/* fFlags */
3931	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
3932	/* fClass. */
3933	PDM_DRVREG_CLASS_DISPLAY,
3934	/* cMaxInstances */
3935	~0U,
3936	/* cbInstance */
3937	sizeof(DRVMAINDISPLAY),
3938	/* pfnConstruct */
3939	Display::i_drvConstruct,
3940	/* pfnDestruct */
3941	Display::i_drvDestruct,
3942	/* pfnRelocate */
3943	NULL,
3944	/* pfnIOCtl */
3945	NULL,
3946	/* pfnPowerOn */
3947	NULL,
3948	/* pfnReset */
3949	NULL,
3950	/* pfnSuspend */
3951	NULL,
3952	/* pfnResume */
3953	NULL,
3954	/* pfnAttach */
3955	NULL,
3956	/* pfnDetach */
3957	NULL,
3958	/* pfnPowerOff */
3959	Display::i_drvPowerOff,
3960	/* pfnSoftReset */
3961	NULL,
3962	/* u32EndVersion */
3963	PDM_DRVREG_VERSION
3964	};
3965
3966	/* 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@ 108641

Download in other formats: