DisplayImpl.cpp@ 16684

Last change on this file since 16684 was 16199, checked in by vboxsync, 16 years ago
displayRefreshCallback: removed obsolete assertion (xTracker #3489).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 78.9 KB

Line
1	/* $Id: DisplayImpl.cpp 16199 2009-01-23 12:49:04Z vboxsync $ */
2
3	/** @file
4	*
5	* VirtualBox COM class implementation
6	*/
7
8	/*
9	* Copyright (C) 2006-2008 Sun Microsystems, Inc.
10	*
11	* This file is part of VirtualBox Open Source Edition (OSE), as
12	* available from http://www.virtualbox.org. This file is free software;
13	* you can redistribute it and/or modify it under the terms of the GNU
14	* General Public License (GPL) as published by the Free Software
15	* Foundation, in version 2 as it comes in the "COPYING" file of the
16	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18	*
19	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
20	* Clara, CA 95054 USA or visit http://www.sun.com if you need
21	* additional information or have any questions.
22	*/
23
24	#include "DisplayImpl.h"
25	#include "FramebufferImpl.h"
26	#include "ConsoleImpl.h"
27	#include "ConsoleVRDPServer.h"
28	#include "VMMDev.h"
29
30	#include "Logging.h"
31
32	#include <iprt/semaphore.h>
33	#include <iprt/thread.h>
34	#include <iprt/asm.h>
35
36	#include <VBox/pdmdrv.h>
37	#ifdef DEBUG /* for VM_ASSERT_EMT(). */
38	# include <VBox/vm.h>
39	#endif
40
41	/**
42	* Display driver instance data.
43	*/
44	typedef struct DRVMAINDISPLAY
45	{
46	/** Pointer to the display object. */
47	Display *pDisplay;
48	/** Pointer to the driver instance structure. */
49	PPDMDRVINS pDrvIns;
50	/** Pointer to the keyboard port interface of the driver/device above us. */
51	PPDMIDISPLAYPORT pUpPort;
52	/** Our display connector interface. */
53	PDMIDISPLAYCONNECTOR Connector;
54	} DRVMAINDISPLAY, *PDRVMAINDISPLAY;
55
56	/** Converts PDMIDISPLAYCONNECTOR pointer to a DRVMAINDISPLAY pointer. */
57	#define PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface) ( (PDRVMAINDISPLAY) ((uintptr_t)pInterface - RT_OFFSETOF(DRVMAINDISPLAY, Connector)) )
58
59	#ifdef DEBUG_sunlover
60	static STAMPROFILE StatDisplayRefresh;
61	static int stam = 0;
62	#endif /* DEBUG_sunlover */
63
64	// constructor / destructor
65	/////////////////////////////////////////////////////////////////////////////
66
67	DEFINE_EMPTY_CTOR_DTOR (Display)
68
69	HRESULT Display::FinalConstruct()
70	{
71	mpVbvaMemory = NULL;
72	mfVideoAccelEnabled = false;
73	mfVideoAccelVRDP = false;
74	mfu32SupportedOrders = 0;
75	mcVideoAccelVRDPRefs = 0;
76
77	mpPendingVbvaMemory = NULL;
78	mfPendingVideoAccelEnable = false;
79
80	mfMachineRunning = false;
81
82	mpu8VbvaPartial = NULL;
83	mcbVbvaPartial = 0;
84
85	mpDrv = NULL;
86	mpVMMDev = NULL;
87	mfVMMDevInited = false;
88	RTSemEventMultiCreate(&mUpdateSem);
89
90	mLastAddress = NULL;
91	mLastBytesPerLine = 0;
92	mLastBitsPerPixel = 0,
93	mLastWidth = 0;
94	mLastHeight = 0;
95
96	return S_OK;
97	}
98
99	void Display::FinalRelease()
100	{
101	uninit();
102	}
103
104	// public initializer/uninitializer for internal purposes only
105	/////////////////////////////////////////////////////////////////////////////
106
107	/**
108	* Initializes the display object.
109	*
110	* @returns COM result indicator
111	* @param parent handle of our parent object
112	* @param qemuConsoleData address of common console data structure
113	*/
114	HRESULT Display::init (Console *aParent)
115	{
116	LogFlowThisFunc (("aParent=%p\n", aParent));
117
118	ComAssertRet (aParent, E_INVALIDARG);
119
120	/* Enclose the state transition NotReady->InInit->Ready */
121	AutoInitSpan autoInitSpan (this);
122	AssertReturn (autoInitSpan.isOk(), E_FAIL);
123
124	unconst (mParent) = aParent;
125
126	/* reset the event sems */
127	RTSemEventMultiReset (mUpdateSem);
128
129	// by default, we have an internal framebuffer which is
130	// NULL, i.e. a black hole for no display output
131	mInternalFramebuffer = true;
132	mFramebufferOpened = false;
133	mSupportedAccelOps = 0;
134
135	ULONG ul;
136	mParent->machine()->COMGETTER(MonitorCount)(&ul);
137	mcMonitors = ul;
138
139	for (ul = 0; ul < mcMonitors; ul++)
140	{
141	maFramebuffers[ul].u32Offset = 0;
142	maFramebuffers[ul].u32MaxFramebufferSize = 0;
143	maFramebuffers[ul].u32InformationSize = 0;
144
145	maFramebuffers[ul].pFramebuffer = NULL;
146
147	maFramebuffers[ul].xOrigin = 0;
148	maFramebuffers[ul].yOrigin = 0;
149
150	maFramebuffers[ul].w = 0;
151	maFramebuffers[ul].h = 0;
152
153	maFramebuffers[ul].pHostEvents = NULL;
154
155	maFramebuffers[ul].u32ResizeStatus = ResizeStatus_Void;
156
157	maFramebuffers[ul].fDefaultFormat = false;
158
159	memset (&maFramebuffers[ul].dirtyRect, 0 , sizeof (maFramebuffers[ul].dirtyRect));
160	memset (&maFramebuffers[ul].pendingResize, 0 , sizeof (maFramebuffers[ul].pendingResize));
161	}
162
163	mParent->RegisterCallback (this);
164
165	/* Confirm a successful initialization */
166	autoInitSpan.setSucceeded();
167
168	return S_OK;
169	}
170
171	/**
172	* Uninitializes the instance and sets the ready flag to FALSE.
173	* Called either from FinalRelease() or by the parent when it gets destroyed.
174	*/
175	void Display::uninit()
176	{
177	LogFlowThisFunc (("\n"));
178
179	/* Enclose the state transition Ready->InUninit->NotReady */
180	AutoUninitSpan autoUninitSpan (this);
181	if (autoUninitSpan.uninitDone())
182	return;
183
184	ULONG ul;
185	for (ul = 0; ul < mcMonitors; ul++)
186	maFramebuffers[ul].pFramebuffer = NULL;
187
188	RTSemEventMultiDestroy (mUpdateSem);
189
190	if (mParent)
191	mParent->UnregisterCallback (this);
192
193	unconst (mParent).setNull();
194
195	if (mpDrv)
196	mpDrv->pDisplay = NULL;
197
198	mpDrv = NULL;
199	mpVMMDev = NULL;
200	mfVMMDevInited = true;
201	}
202
203	// IConsoleCallback method
204	STDMETHODIMP Display::OnStateChange(MachineState_T machineState)
205	{
206	if (machineState == MachineState_Running)
207	{
208	LogFlowFunc (("Machine is running.\n"));
209
210	mfMachineRunning = true;
211	}
212	else
213	mfMachineRunning = false;
214
215	return S_OK;
216	}
217
218	// public methods only for internal purposes
219	/////////////////////////////////////////////////////////////////////////////
220
221	/**
222	* @thread EMT
223	*/
224	static int callFramebufferResize (IFramebuffer *pFramebuffer, unsigned uScreenId,
225	ULONG pixelFormat, void *pvVRAM,
226	uint32_t bpp, uint32_t cbLine,
227	int w, int h)
228	{
229	Assert (pFramebuffer);
230
231	/* Call the framebuffer to try and set required pixelFormat. */
232	BOOL finished = TRUE;
233
234	pFramebuffer->RequestResize (uScreenId, pixelFormat, (BYTE *) pvVRAM,
235	bpp, cbLine, w, h, &finished);
236
237	if (!finished)
238	{
239	LogFlowFunc (("External framebuffer wants us to wait!\n"));
240	return VINF_VGA_RESIZE_IN_PROGRESS;
241	}
242
243	return VINF_SUCCESS;
244	}
245
246	/**
247	* Handles display resize event.
248	* Disables access to VGA device;
249	* calls the framebuffer RequestResize method;
250	* if framebuffer resizes synchronously,
251	* updates the display connector data and enables access to the VGA device.
252	*
253	* @param w New display width
254	* @param h New display height
255	*
256	* @thread EMT
257	*/
258	int Display::handleDisplayResize (unsigned uScreenId, uint32_t bpp, void *pvVRAM,
259	uint32_t cbLine, int w, int h)
260	{
261	LogRel (("Display::handleDisplayResize(): uScreenId = %d, pvVRAM=%p "
262	"w=%d h=%d bpp=%d cbLine=0x%X\n",
263	uScreenId, pvVRAM, w, h, bpp, cbLine));
264
265	/* If there is no framebuffer, this call is not interesting. */
266	if ( uScreenId >= mcMonitors
267	\|\| maFramebuffers[uScreenId].pFramebuffer.isNull())
268	{
269	return VINF_SUCCESS;
270	}
271
272	mLastAddress = pvVRAM;
273	mLastBytesPerLine = cbLine;
274	mLastBitsPerPixel = bpp,
275	mLastWidth = w;
276	mLastHeight = h;
277
278	ULONG pixelFormat;
279
280	switch (bpp)
281	{
282	case 32:
283	case 24:
284	case 16:
285	pixelFormat = FramebufferPixelFormat_FOURCC_RGB;
286	break;
287	default:
288	pixelFormat = FramebufferPixelFormat_Opaque;
289	bpp = cbLine = 0;
290	break;
291	}
292
293	/* Atomically set the resize status before calling the framebuffer. The new InProgress status will
294	* disable access to the VGA device by the EMT thread.
295	*/
296	bool f = ASMAtomicCmpXchgU32 (&maFramebuffers[uScreenId].u32ResizeStatus,
297	ResizeStatus_InProgress, ResizeStatus_Void);
298	if (!f)
299	{
300	/* This could be a result of the screenshot taking call Display::TakeScreenShot:
301	* if the framebuffer is processing the resize request and GUI calls the TakeScreenShot
302	* and the guest has reprogrammed the virtual VGA devices again so a new resize is required.
303	*
304	* Save the resize information and return the pending status code.
305	*
306	* Note: the resize information is only accessed on EMT so no serialization is required.
307	*/
308	LogRel (("Display::handleDisplayResize(): Warning: resize postponed.\n"));
309
310	maFramebuffers[uScreenId].pendingResize.fPending = true;
311	maFramebuffers[uScreenId].pendingResize.pixelFormat = pixelFormat;
312	maFramebuffers[uScreenId].pendingResize.pvVRAM = pvVRAM;
313	maFramebuffers[uScreenId].pendingResize.bpp = bpp;
314	maFramebuffers[uScreenId].pendingResize.cbLine = cbLine;
315	maFramebuffers[uScreenId].pendingResize.w = w;
316	maFramebuffers[uScreenId].pendingResize.h = h;
317
318	return VINF_VGA_RESIZE_IN_PROGRESS;
319	}
320
321	/* The framebuffer is locked in the state.
322	* The lock is kept, because the framebuffer is in undefined state.
323	*/
324	maFramebuffers[uScreenId].pFramebuffer->Lock();
325
326	int rc = callFramebufferResize (maFramebuffers[uScreenId].pFramebuffer, uScreenId,
327	pixelFormat, pvVRAM, bpp, cbLine, w, h);
328	if (rc == VINF_VGA_RESIZE_IN_PROGRESS)
329	{
330	/* Immediately return to the caller. ResizeCompleted will be called back by the
331	* GUI thread. The ResizeCompleted callback will change the resize status from
332	* InProgress to UpdateDisplayData. The latter status will be checked by the
333	* display timer callback on EMT and all required adjustments will be done there.
334	*/
335	return rc;
336	}
337
338	/* Set the status so the 'handleResizeCompleted' would work. */
339	f = ASMAtomicCmpXchgU32 (&maFramebuffers[uScreenId].u32ResizeStatus,
340	ResizeStatus_UpdateDisplayData, ResizeStatus_InProgress);
341	AssertRelease(f);NOREF(f);
342
343	AssertRelease(!maFramebuffers[uScreenId].pendingResize.fPending);
344
345	/* The method also unlocks the framebuffer. */
346	handleResizeCompletedEMT();
347
348	return VINF_SUCCESS;
349	}
350
351	/**
352	* Framebuffer has been resized.
353	* Read the new display data and unlock the framebuffer.
354	*
355	* @thread EMT
356	*/
357	void Display::handleResizeCompletedEMT (void)
358	{
359	LogFlowFunc(("\n"));
360
361	unsigned uScreenId;
362	for (uScreenId = 0; uScreenId < mcMonitors; uScreenId++)
363	{
364	DISPLAYFBINFO *pFBInfo = &maFramebuffers[uScreenId];
365
366	/* Try to into non resizing state. */
367	bool f = ASMAtomicCmpXchgU32 (&pFBInfo->u32ResizeStatus, ResizeStatus_Void, ResizeStatus_UpdateDisplayData);
368
369	if (f == false)
370	{
371	/* This is not the display that has completed resizing. */
372	continue;
373	}
374
375	/* Check whether a resize is pending for this framebuffer. */
376	if (pFBInfo->pendingResize.fPending)
377	{
378	/* Reset the condition, call the display resize with saved data and continue.
379	*
380	* Note: handleDisplayResize can call handleResizeCompletedEMT back,
381	* but infinite recursion is not possible, because when the handleResizeCompletedEMT
382	* is called, the pFBInfo->pendingResize.fPending is equal to false.
383	*/
384	pFBInfo->pendingResize.fPending = false;
385	handleDisplayResize (uScreenId, pFBInfo->pendingResize.bpp, pFBInfo->pendingResize.pvVRAM,
386	pFBInfo->pendingResize.cbLine, pFBInfo->pendingResize.w, pFBInfo->pendingResize.h);
387	continue;
388	}
389
390	if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN && !pFBInfo->pFramebuffer.isNull())
391	{
392	/* Primary framebuffer has completed the resize. Update the connector data for VGA device. */
393	updateDisplayData();
394
395	/* Check the framebuffer pixel format to setup the rendering in VGA device. */
396	BOOL usesGuestVRAM = FALSE;
397	pFBInfo->pFramebuffer->COMGETTER(UsesGuestVRAM) (&usesGuestVRAM);
398
399	pFBInfo->fDefaultFormat = (usesGuestVRAM == FALSE);
400
401	mpDrv->pUpPort->pfnSetRenderVRAM (mpDrv->pUpPort, pFBInfo->fDefaultFormat);
402	}
403
404	#ifdef DEBUG_sunlover
405	if (!stam)
406	{
407	/* protect mpVM */
408	Console::SafeVMPtr pVM (mParent);
409	AssertComRC (pVM.rc());
410
411	STAM_REG(pVM, &StatDisplayRefresh, STAMTYPE_PROFILE, "/PROF/Display/Refresh", STAMUNIT_TICKS_PER_CALL, "Time spent in EMT for display updates.");
412	stam = 1;
413	}
414	#endif /* DEBUG_sunlover */
415
416	/* Inform VRDP server about the change of display parameters. */
417	LogFlowFunc (("Calling VRDP\n"));
418	mParent->consoleVRDPServer()->SendResize();
419
420	if (!pFBInfo->pFramebuffer.isNull())
421	{
422	/* Unlock framebuffer after evrything is done. */
423	pFBInfo->pFramebuffer->Unlock();
424	}
425	}
426	}
427
428	static void checkCoordBounds (int px, int py, int pw, int ph, int cx, int cy)
429	{
430	/* Correct negative x and y coordinates. */
431	if (*px < 0)
432	{
433	px += pw; /* Compute xRight which is also the new width. */
434
435	pw = (px < 0)? 0: *px;
436
437	*px = 0;
438	}
439
440	if (*py < 0)
441	{
442	py += ph; /* Compute xBottom, which is also the new height. */
443
444	ph = (py < 0)? 0: *py;
445
446	*py = 0;
447	}
448
449	/* Also check if coords are greater than the display resolution. */
450	if (px + pw > cx)
451	{
452	pw = cx > px? cx - *px: 0;
453	}
454
455	if (py + ph > cy)
456	{
457	ph = cy > py? cy - *py: 0;
458	}
459	}
460
461	unsigned mapCoordsToScreen(DISPLAYFBINFO pInfos, unsigned cInfos, int px, int py, int pw, int *ph)
462	{
463	DISPLAYFBINFO *pInfo = pInfos;
464	unsigned uScreenId;
465	LogSunlover (("mapCoordsToScreen: %d,%d %dx%d\n", px, py, pw, ph));
466	for (uScreenId = 0; uScreenId < cInfos; uScreenId++, pInfo++)
467	{
468	LogSunlover ((" [%d] %d,%d %dx%d\n", uScreenId, pInfo->xOrigin, pInfo->yOrigin, pInfo->w, pInfo->h));
469	if ( (pInfo->xOrigin <= px && px < pInfo->xOrigin + (int)pInfo->w)
470	&& (pInfo->yOrigin <= py && py < pInfo->yOrigin + (int)pInfo->h))
471	{
472	/* The rectangle belongs to the screen. Correct coordinates. */
473	*px -= pInfo->xOrigin;
474	*py -= pInfo->yOrigin;
475	LogSunlover ((" -> %d,%d", px, py));
476	break;
477	}
478	}
479	if (uScreenId == cInfos)
480	{
481	/* Map to primary screen. */
482	uScreenId = 0;
483	}
484	LogSunlover ((" scr %d\n", uScreenId));
485	return uScreenId;
486	}
487
488
489	/**
490	* Handles display update event.
491	*
492	* @param x Update area x coordinate
493	* @param y Update area y coordinate
494	* @param w Update area width
495	* @param h Update area height
496	*
497	* @thread EMT
498	*/
499	void Display::handleDisplayUpdate (int x, int y, int w, int h)
500	{
501	#ifdef DEBUG_sunlover
502	LogFlowFunc (("%d,%d %dx%d (%d,%d)\n",
503	x, y, w, h, mpDrv->Connector.cx, mpDrv->Connector.cy));
504	#endif /* DEBUG_sunlover */
505
506	unsigned uScreenId = mapCoordsToScreen(maFramebuffers, mcMonitors, &x, &y, &w, &h);
507
508	#ifdef DEBUG_sunlover
509	LogFlowFunc (("%d,%d %dx%d (checked)\n", x, y, w, h));
510	#endif /* DEBUG_sunlover */
511
512	IFramebuffer *pFramebuffer = maFramebuffers[uScreenId].pFramebuffer;
513
514	// if there is no framebuffer, this call is not interesting
515	if (pFramebuffer == NULL)
516	return;
517
518	pFramebuffer->Lock();
519
520	/* special processing for the internal framebuffer */
521	if (mInternalFramebuffer)
522	{
523	pFramebuffer->Unlock();
524	} else
525	{
526	/* callback into the framebuffer to notify it */
527	BOOL finished = FALSE;
528
529	RTSemEventMultiReset(mUpdateSem);
530
531	checkCoordBounds (&x, &y, &w, &h, mpDrv->Connector.cx, mpDrv->Connector.cy);
532
533	if (w == 0 \|\| h == 0)
534	{
535	/* Nothing to be updated. */
536	finished = TRUE;
537	}
538	else
539	{
540	pFramebuffer->NotifyUpdate(x, y, w, h, &finished);
541	}
542
543	if (!finished)
544	{
545	/*
546	* the framebuffer needs more time to process
547	* the event so we have to halt the VM until it's done
548	*/
549	pFramebuffer->Unlock();
550	RTSemEventMultiWait(mUpdateSem, RT_INDEFINITE_WAIT);
551	} else
552	{
553	pFramebuffer->Unlock();
554	}
555
556	if (!mfVideoAccelEnabled)
557	{
558	/* When VBVA is enabled, the VRDP server is informed in the VideoAccelFlush.
559	* Inform the server here only if VBVA is disabled.
560	*/
561	if (maFramebuffers[uScreenId].u32ResizeStatus == ResizeStatus_Void)
562	{
563	mParent->consoleVRDPServer()->SendUpdateBitmap(uScreenId, x, y, w, h);
564	}
565	}
566	}
567	return;
568	}
569
570	typedef struct _VBVADIRTYREGION
571	{
572	/* Copies of object's pointers used by vbvaRgn functions. */
573	DISPLAYFBINFO *paFramebuffers;
574	unsigned cMonitors;
575	Display *pDisplay;
576	PPDMIDISPLAYPORT pPort;
577
578	} VBVADIRTYREGION;
579
580	static void vbvaRgnInit (VBVADIRTYREGION prgn, DISPLAYFBINFO paFramebuffers, unsigned cMonitors, Display *pd, PPDMIDISPLAYPORT pp)
581	{
582	prgn->paFramebuffers = paFramebuffers;
583	prgn->cMonitors = cMonitors;
584	prgn->pDisplay = pd;
585	prgn->pPort = pp;
586
587	unsigned uScreenId;
588	for (uScreenId = 0; uScreenId < cMonitors; uScreenId++)
589	{
590	DISPLAYFBINFO *pFBInfo = &prgn->paFramebuffers[uScreenId];
591
592	memset (&pFBInfo->dirtyRect, 0, sizeof (pFBInfo->dirtyRect));
593	}
594	}
595
596	static void vbvaRgnDirtyRect (VBVADIRTYREGION prgn, unsigned uScreenId, VBVACMDHDR phdr)
597	{
598	LogSunlover (("x = %d, y = %d, w = %d, h = %d\n",
599	phdr->x, phdr->y, phdr->w, phdr->h));
600
601	/*
602	* Here update rectangles are accumulated to form an update area.
603	* @todo
604	* Now the simpliest method is used which builds one rectangle that
605	* includes all update areas. A bit more advanced method can be
606	* employed here. The method should be fast however.
607	*/
608	if (phdr->w == 0 \|\| phdr->h == 0)
609	{
610	/* Empty rectangle. */
611	return;
612	}
613
614	int32_t xRight = phdr->x + phdr->w;
615	int32_t yBottom = phdr->y + phdr->h;
616
617	DISPLAYFBINFO *pFBInfo = &prgn->paFramebuffers[uScreenId];
618
619	if (pFBInfo->dirtyRect.xRight == 0)
620	{
621	/* This is the first rectangle to be added. */
622	pFBInfo->dirtyRect.xLeft = phdr->x;
623	pFBInfo->dirtyRect.yTop = phdr->y;
624	pFBInfo->dirtyRect.xRight = xRight;
625	pFBInfo->dirtyRect.yBottom = yBottom;
626	}
627	else
628	{
629	/* Adjust region coordinates. */
630	if (pFBInfo->dirtyRect.xLeft > phdr->x)
631	{
632	pFBInfo->dirtyRect.xLeft = phdr->x;
633	}
634
635	if (pFBInfo->dirtyRect.yTop > phdr->y)
636	{
637	pFBInfo->dirtyRect.yTop = phdr->y;
638	}
639
640	if (pFBInfo->dirtyRect.xRight < xRight)
641	{
642	pFBInfo->dirtyRect.xRight = xRight;
643	}
644
645	if (pFBInfo->dirtyRect.yBottom < yBottom)
646	{
647	pFBInfo->dirtyRect.yBottom = yBottom;
648	}
649	}
650
651	if (pFBInfo->fDefaultFormat)
652	{
653	//@todo pfnUpdateDisplayRect must take the vram offset parameter for the framebuffer
654	prgn->pPort->pfnUpdateDisplayRect (prgn->pPort, phdr->x, phdr->y, phdr->w, phdr->h);
655	prgn->pDisplay->handleDisplayUpdate (phdr->x, phdr->y, phdr->w, phdr->h);
656	}
657
658	return;
659	}
660
661	static void vbvaRgnUpdateFramebuffer (VBVADIRTYREGION *prgn, unsigned uScreenId)
662	{
663	DISPLAYFBINFO *pFBInfo = &prgn->paFramebuffers[uScreenId];
664
665	uint32_t w = pFBInfo->dirtyRect.xRight - pFBInfo->dirtyRect.xLeft;
666	uint32_t h = pFBInfo->dirtyRect.yBottom - pFBInfo->dirtyRect.yTop;
667
668	if (!pFBInfo->fDefaultFormat && pFBInfo->pFramebuffer && w != 0 && h != 0)
669	{
670	//@todo pfnUpdateDisplayRect must take the vram offset parameter for the framebuffer
671	prgn->pPort->pfnUpdateDisplayRect (prgn->pPort, pFBInfo->dirtyRect.xLeft, pFBInfo->dirtyRect.yTop, w, h);
672	prgn->pDisplay->handleDisplayUpdate (pFBInfo->dirtyRect.xLeft, pFBInfo->dirtyRect.yTop, w, h);
673	}
674	}
675
676	static void vbvaSetMemoryFlags (VBVAMEMORY *pVbvaMemory,
677	bool fVideoAccelEnabled,
678	bool fVideoAccelVRDP,
679	uint32_t fu32SupportedOrders,
680	DISPLAYFBINFO *paFBInfos,
681	unsigned cFBInfos)
682	{
683	if (pVbvaMemory)
684	{
685	/* This called only on changes in mode. So reset VRDP always. */
686	uint32_t fu32Flags = VBVA_F_MODE_VRDP_RESET;
687
688	if (fVideoAccelEnabled)
689	{
690	fu32Flags \|= VBVA_F_MODE_ENABLED;
691
692	if (fVideoAccelVRDP)
693	{
694	fu32Flags \|= VBVA_F_MODE_VRDP \| VBVA_F_MODE_VRDP_ORDER_MASK;
695
696	pVbvaMemory->fu32SupportedOrders = fu32SupportedOrders;
697	}
698	}
699
700	pVbvaMemory->fu32ModeFlags = fu32Flags;
701	}
702
703	unsigned uScreenId;
704	for (uScreenId = 0; uScreenId < cFBInfos; uScreenId++)
705	{
706	if (paFBInfos[uScreenId].pHostEvents)
707	{
708	paFBInfos[uScreenId].pHostEvents->fu32Events \|= VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET;
709	}
710	}
711	}
712
713	bool Display::VideoAccelAllowed (void)
714	{
715	return true;
716	}
717
718	/**
719	* @thread EMT
720	*/
721	int Display::VideoAccelEnable (bool fEnable, VBVAMEMORY *pVbvaMemory)
722	{
723	int rc = VINF_SUCCESS;
724
725	/* Called each time the guest wants to use acceleration,
726	* or when the VGA device disables acceleration,
727	* or when restoring the saved state with accel enabled.
728	*
729	* VGA device disables acceleration on each video mode change
730	* and on reset.
731	*
732	* Guest enabled acceleration at will. And it has to enable
733	* acceleration after a mode change.
734	*/
735	LogFlowFunc (("mfVideoAccelEnabled = %d, fEnable = %d, pVbvaMemory = %p\n",
736	mfVideoAccelEnabled, fEnable, pVbvaMemory));
737
738	/* Strictly check parameters. Callers must not pass anything in the case. */
739	Assert((fEnable && pVbvaMemory) \|\| (!fEnable && pVbvaMemory == NULL));
740
741	if (!VideoAccelAllowed ())
742	{
743	return VERR_NOT_SUPPORTED;
744	}
745
746	/*
747	* Verify that the VM is in running state. If it is not,
748	* then this must be postponed until it goes to running.
749	*/
750	if (!mfMachineRunning)
751	{
752	Assert (!mfVideoAccelEnabled);
753
754	LogFlowFunc (("Machine is not yet running.\n"));
755
756	if (fEnable)
757	{
758	mfPendingVideoAccelEnable = fEnable;
759	mpPendingVbvaMemory = pVbvaMemory;
760	}
761
762	return rc;
763	}
764
765	/* Check that current status is not being changed */
766	if (mfVideoAccelEnabled == fEnable)
767	{
768	return rc;
769	}
770
771	if (mfVideoAccelEnabled)
772	{
773	/* Process any pending orders and empty the VBVA ring buffer. */
774	VideoAccelFlush ();
775	}
776
777	if (!fEnable && mpVbvaMemory)
778	{
779	mpVbvaMemory->fu32ModeFlags &= ~VBVA_F_MODE_ENABLED;
780	}
781
782	/* Safety precaution. There is no more VBVA until everything is setup! */
783	mpVbvaMemory = NULL;
784	mfVideoAccelEnabled = false;
785
786	/* Update entire display. */
787	if (maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN].u32ResizeStatus == ResizeStatus_Void)
788	{
789	mpDrv->pUpPort->pfnUpdateDisplayAll(mpDrv->pUpPort);
790	}
791
792	/* Everything OK. VBVA status can be changed. */
793
794	/* Notify the VMMDev, which saves VBVA status in the saved state,
795	* and needs to know current status.
796	*/
797	PPDMIVMMDEVPORT pVMMDevPort = mParent->getVMMDev()->getVMMDevPort ();
798
799	if (pVMMDevPort)
800	{
801	pVMMDevPort->pfnVBVAChange (pVMMDevPort, fEnable);
802	}
803
804	if (fEnable)
805	{
806	mpVbvaMemory = pVbvaMemory;
807	mfVideoAccelEnabled = true;
808
809	/* Initialize the hardware memory. */
810	vbvaSetMemoryFlags (mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders, maFramebuffers, mcMonitors);
811	mpVbvaMemory->off32Data = 0;
812	mpVbvaMemory->off32Free = 0;
813
814	memset (mpVbvaMemory->aRecords, 0, sizeof (mpVbvaMemory->aRecords));
815	mpVbvaMemory->indexRecordFirst = 0;
816	mpVbvaMemory->indexRecordFree = 0;
817
818	LogRel(("VBVA: Enabled.\n"));
819	}
820	else
821	{
822	LogRel(("VBVA: Disabled.\n"));
823	}
824
825	LogFlowFunc (("VideoAccelEnable: rc = %Rrc.\n", rc));
826
827	return rc;
828	}
829
830	#ifdef VBOX_WITH_VRDP
831	/* Called always by one VRDP server thread. Can be thread-unsafe.
832	*/
833	void Display::VideoAccelVRDP (bool fEnable)
834	{
835	int c = fEnable?
836	ASMAtomicIncS32 (&mcVideoAccelVRDPRefs):
837	ASMAtomicDecS32 (&mcVideoAccelVRDPRefs);
838
839	Assert (c >= 0);
840
841	if (c == 0)
842	{
843	/* The last client has disconnected, and the accel can be
844	* disabled.
845	*/
846	Assert (fEnable == false);
847
848	mfVideoAccelVRDP = false;
849	mfu32SupportedOrders = 0;
850
851	vbvaSetMemoryFlags (mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders, maFramebuffers, mcMonitors);
852
853	LogRel(("VBVA: VRDP acceleration has been disabled.\n"));
854	}
855	else if ( c == 1
856	&& !mfVideoAccelVRDP)
857	{
858	/* The first client has connected. Enable the accel.
859	*/
860	Assert (fEnable == true);
861
862	mfVideoAccelVRDP = true;
863	/* Supporting all orders. */
864	mfu32SupportedOrders = ~0;
865
866	vbvaSetMemoryFlags (mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders, maFramebuffers, mcMonitors);
867
868	LogRel(("VBVA: VRDP acceleration has been requested.\n"));
869	}
870	else
871	{
872	/* A client is connected or disconnected but there is no change in the
873	* accel state. It remains enabled.
874	*/
875	Assert (mfVideoAccelVRDP == true);
876	}
877	}
878	#endif /* VBOX_WITH_VRDP */
879
880	static bool vbvaVerifyRingBuffer (VBVAMEMORY *pVbvaMemory)
881	{
882	return true;
883	}
884
885	static void vbvaFetchBytes (VBVAMEMORY pVbvaMemory, uint8_t pu8Dst, uint32_t cbDst)
886	{
887	if (cbDst >= VBVA_RING_BUFFER_SIZE)
888	{
889	AssertMsgFailed (("cbDst = 0x%08X, ring buffer size 0x%08X", cbDst, VBVA_RING_BUFFER_SIZE));
890	return;
891	}
892
893	uint32_t u32BytesTillBoundary = VBVA_RING_BUFFER_SIZE - pVbvaMemory->off32Data;
894	uint8_t *src = &pVbvaMemory->au8RingBuffer[pVbvaMemory->off32Data];
895	int32_t i32Diff = cbDst - u32BytesTillBoundary;
896
897	if (i32Diff <= 0)
898	{
899	/* Chunk will not cross buffer boundary. */
900	memcpy (pu8Dst, src, cbDst);
901	}
902	else
903	{
904	/* Chunk crosses buffer boundary. */
905	memcpy (pu8Dst, src, u32BytesTillBoundary);
906	memcpy (pu8Dst + u32BytesTillBoundary, &pVbvaMemory->au8RingBuffer[0], i32Diff);
907	}
908
909	/* Advance data offset. */
910	pVbvaMemory->off32Data = (pVbvaMemory->off32Data + cbDst) % VBVA_RING_BUFFER_SIZE;
911
912	return;
913	}
914
915
916	static bool vbvaPartialRead (uint8_t *ppu8, uint32_t pcb, uint32_t cbRecord, VBVAMEMORY *pVbvaMemory)
917	{
918	uint8_t *pu8New;
919
920	LogFlow(("MAIN::DisplayImpl::vbvaPartialRead: p = %p, cb = %d, cbRecord 0x%08X\n",
921	ppu8, pcb, cbRecord));
922
923	if (*ppu8)
924	{
925	Assert (*pcb);
926	pu8New = (uint8_t )RTMemRealloc (ppu8, cbRecord);
927	}
928	else
929	{
930	Assert (!*pcb);
931	pu8New = (uint8_t *)RTMemAlloc (cbRecord);
932	}
933
934	if (!pu8New)
935	{
936	/* Memory allocation failed, fail the function. */
937	Log(("MAIN::vbvaPartialRead: failed to (re)alocate memory for partial record!!! cbRecord 0x%08X\n",
938	cbRecord));
939
940	if (*ppu8)
941	{
942	RTMemFree (*ppu8);
943	}
944
945	*ppu8 = NULL;
946	*pcb = 0;
947
948	return false;
949	}
950
951	/* Fetch data from the ring buffer. */
952	vbvaFetchBytes (pVbvaMemory, pu8New + pcb, cbRecord - pcb);
953
954	*ppu8 = pu8New;
955	*pcb = cbRecord;
956
957	return true;
958	}
959
960	/* For contiguous chunks just return the address in the buffer.
961	* For crossing boundary - allocate a buffer from heap.
962	*/
963	bool Display::vbvaFetchCmd (VBVACMDHDR *ppHdr, uint32_t pcbCmd)
964	{
965	uint32_t indexRecordFirst = mpVbvaMemory->indexRecordFirst;
966	uint32_t indexRecordFree = mpVbvaMemory->indexRecordFree;
967
968	#ifdef DEBUG_sunlover
969	LogFlowFunc (("first = %d, free = %d\n",
970	indexRecordFirst, indexRecordFree));
971	#endif /* DEBUG_sunlover */
972
973	if (!vbvaVerifyRingBuffer (mpVbvaMemory))
974	{
975	return false;
976	}
977
978	if (indexRecordFirst == indexRecordFree)
979	{
980	/* No records to process. Return without assigning output variables. */
981	return true;
982	}
983
984	VBVARECORD *pRecord = &mpVbvaMemory->aRecords[indexRecordFirst];
985
986	#ifdef DEBUG_sunlover
987	LogFlowFunc (("cbRecord = 0x%08X\n", pRecord->cbRecord));
988	#endif /* DEBUG_sunlover */
989
990	uint32_t cbRecord = pRecord->cbRecord & ~VBVA_F_RECORD_PARTIAL;
991
992	if (mcbVbvaPartial)
993	{
994	/* There is a partial read in process. Continue with it. */
995
996	Assert (mpu8VbvaPartial);
997
998	LogFlowFunc (("continue partial record mcbVbvaPartial = %d cbRecord 0x%08X, first = %d, free = %d\n",
999	mcbVbvaPartial, pRecord->cbRecord, indexRecordFirst, indexRecordFree));
1000
1001	if (cbRecord > mcbVbvaPartial)
1002	{
1003	/* New data has been added to the record. */
1004	if (!vbvaPartialRead (&mpu8VbvaPartial, &mcbVbvaPartial, cbRecord, mpVbvaMemory))
1005	{
1006	return false;
1007	}
1008	}
1009
1010	if (!(pRecord->cbRecord & VBVA_F_RECORD_PARTIAL))
1011	{
1012	/* The record is completed by guest. Return it to the caller. */
1013	ppHdr = (VBVACMDHDR )mpu8VbvaPartial;
1014	*pcbCmd = mcbVbvaPartial;
1015
1016	mpu8VbvaPartial = NULL;
1017	mcbVbvaPartial = 0;
1018
1019	/* Advance the record index. */
1020	mpVbvaMemory->indexRecordFirst = (indexRecordFirst + 1) % VBVA_MAX_RECORDS;
1021
1022	#ifdef DEBUG_sunlover
1023	LogFlowFunc (("partial done ok, data = %d, free = %d\n",
1024	mpVbvaMemory->off32Data, mpVbvaMemory->off32Free));
1025	#endif /* DEBUG_sunlover */
1026	}
1027
1028	return true;
1029	}
1030
1031	/* A new record need to be processed. */
1032	if (pRecord->cbRecord & VBVA_F_RECORD_PARTIAL)
1033	{
1034	/* Current record is being written by guest. '=' is important here. */
1035	if (cbRecord >= VBVA_RING_BUFFER_SIZE - VBVA_RING_BUFFER_THRESHOLD)
1036	{
1037	/* Partial read must be started. */
1038	if (!vbvaPartialRead (&mpu8VbvaPartial, &mcbVbvaPartial, cbRecord, mpVbvaMemory))
1039	{
1040	return false;
1041	}
1042
1043	LogFlowFunc (("started partial record mcbVbvaPartial = 0x%08X cbRecord 0x%08X, first = %d, free = %d\n",
1044	mcbVbvaPartial, pRecord->cbRecord, indexRecordFirst, indexRecordFree));
1045	}
1046
1047	return true;
1048	}
1049
1050	/* Current record is complete. If it is not empty, process it. */
1051	if (cbRecord)
1052	{
1053	/* The size of largest contiguos chunk in the ring biffer. */
1054	uint32_t u32BytesTillBoundary = VBVA_RING_BUFFER_SIZE - mpVbvaMemory->off32Data;
1055
1056	/* The ring buffer pointer. */
1057	uint8_t *au8RingBuffer = &mpVbvaMemory->au8RingBuffer[0];
1058
1059	/* The pointer to data in the ring buffer. */
1060	uint8_t *src = &au8RingBuffer[mpVbvaMemory->off32Data];
1061
1062	/* Fetch or point the data. */
1063	if (u32BytesTillBoundary >= cbRecord)
1064	{
1065	/* The command does not cross buffer boundary. Return address in the buffer. */
1066	ppHdr = (VBVACMDHDR )src;
1067
1068	/* Advance data offset. */
1069	mpVbvaMemory->off32Data = (mpVbvaMemory->off32Data + cbRecord) % VBVA_RING_BUFFER_SIZE;
1070	}
1071	else
1072	{
1073	/* The command crosses buffer boundary. Rare case, so not optimized. */
1074	uint8_t dst = (uint8_t )RTMemAlloc (cbRecord);
1075
1076	if (!dst)
1077	{
1078	LogFlowFunc (("could not allocate %d bytes from heap!!!\n", cbRecord));
1079	mpVbvaMemory->off32Data = (mpVbvaMemory->off32Data + cbRecord) % VBVA_RING_BUFFER_SIZE;
1080	return false;
1081	}
1082
1083	vbvaFetchBytes (mpVbvaMemory, dst, cbRecord);
1084
1085	ppHdr = (VBVACMDHDR )dst;
1086
1087	#ifdef DEBUG_sunlover
1088	LogFlowFunc (("Allocated from heap %p\n", dst));
1089	#endif /* DEBUG_sunlover */
1090	}
1091	}
1092
1093	*pcbCmd = cbRecord;
1094
1095	/* Advance the record index. */
1096	mpVbvaMemory->indexRecordFirst = (indexRecordFirst + 1) % VBVA_MAX_RECORDS;
1097
1098	#ifdef DEBUG_sunlover
1099	LogFlowFunc (("done ok, data = %d, free = %d\n",
1100	mpVbvaMemory->off32Data, mpVbvaMemory->off32Free));
1101	#endif /* DEBUG_sunlover */
1102
1103	return true;
1104	}
1105
1106	void Display::vbvaReleaseCmd (VBVACMDHDR *pHdr, int32_t cbCmd)
1107	{
1108	uint8_t *au8RingBuffer = mpVbvaMemory->au8RingBuffer;
1109
1110	if ( (uint8_t *)pHdr >= au8RingBuffer
1111	&& (uint8_t *)pHdr < &au8RingBuffer[VBVA_RING_BUFFER_SIZE])
1112	{
1113	/* The pointer is inside ring buffer. Must be continuous chunk. */
1114	Assert (VBVA_RING_BUFFER_SIZE - ((uint8_t *)pHdr - au8RingBuffer) >= cbCmd);
1115
1116	/* Do nothing. */
1117
1118	Assert (!mpu8VbvaPartial && mcbVbvaPartial == 0);
1119	}
1120	else
1121	{
1122	/* The pointer is outside. It is then an allocated copy. */
1123
1124	#ifdef DEBUG_sunlover
1125	LogFlowFunc (("Free heap %p\n", pHdr));
1126	#endif /* DEBUG_sunlover */
1127
1128	if ((uint8_t *)pHdr == mpu8VbvaPartial)
1129	{
1130	mpu8VbvaPartial = NULL;
1131	mcbVbvaPartial = 0;
1132	}
1133	else
1134	{
1135	Assert (!mpu8VbvaPartial && mcbVbvaPartial == 0);
1136	}
1137
1138	RTMemFree (pHdr);
1139	}
1140
1141	return;
1142	}
1143
1144
1145	/**
1146	* Called regularly on the DisplayRefresh timer.
1147	* Also on behalf of guest, when the ring buffer is full.
1148	*
1149	* @thread EMT
1150	*/
1151	void Display::VideoAccelFlush (void)
1152	{
1153	#ifdef DEBUG_sunlover_2
1154	LogFlowFunc (("mfVideoAccelEnabled = %d\n", mfVideoAccelEnabled));
1155	#endif /* DEBUG_sunlover_2 */
1156
1157	if (!mfVideoAccelEnabled)
1158	{
1159	Log(("Display::VideoAccelFlush: called with disabled VBVA!!! Ignoring.\n"));
1160	return;
1161	}
1162
1163	/* Here VBVA is enabled and we have the accelerator memory pointer. */
1164	Assert(mpVbvaMemory);
1165
1166	#ifdef DEBUG_sunlover_2
1167	LogFlowFunc (("indexRecordFirst = %d, indexRecordFree = %d, off32Data = %d, off32Free = %d\n",
1168	mpVbvaMemory->indexRecordFirst, mpVbvaMemory->indexRecordFree, mpVbvaMemory->off32Data, mpVbvaMemory->off32Free));
1169	#endif /* DEBUG_sunlover_2 */
1170
1171	/* Quick check for "nothing to update" case. */
1172	if (mpVbvaMemory->indexRecordFirst == mpVbvaMemory->indexRecordFree)
1173	{
1174	return;
1175	}
1176
1177	/* Process the ring buffer */
1178	unsigned uScreenId;
1179	for (uScreenId = 0; uScreenId < mcMonitors; uScreenId++)
1180	{
1181	if (!maFramebuffers[uScreenId].pFramebuffer.isNull())
1182	{
1183	maFramebuffers[uScreenId].pFramebuffer->Lock ();
1184	}
1185	}
1186
1187	/* Initialize dirty rectangles accumulator. */
1188	VBVADIRTYREGION rgn;
1189	vbvaRgnInit (&rgn, maFramebuffers, mcMonitors, this, mpDrv->pUpPort);
1190
1191	for (;;)
1192	{
1193	VBVACMDHDR *phdr = NULL;
1194	uint32_t cbCmd = ~0;
1195
1196	/* Fetch the command data. */
1197	if (!vbvaFetchCmd (&phdr, &cbCmd))
1198	{
1199	Log(("Display::VideoAccelFlush: unable to fetch command. off32Data = %d, off32Free = %d. Disabling VBVA!!!\n",
1200	mpVbvaMemory->off32Data, mpVbvaMemory->off32Free));
1201
1202	/* Disable VBVA on those processing errors. */
1203	VideoAccelEnable (false, NULL);
1204
1205	break;
1206	}
1207
1208	if (cbCmd == uint32_t(~0))
1209	{
1210	/* No more commands yet in the queue. */
1211	break;
1212	}
1213
1214	if (cbCmd != 0)
1215	{
1216	#ifdef DEBUG_sunlover
1217	LogFlowFunc (("hdr: cbCmd = %d, x=%d, y=%d, w=%d, h=%d\n",
1218	cbCmd, phdr->x, phdr->y, phdr->w, phdr->h));
1219	#endif /* DEBUG_sunlover */
1220
1221	VBVACMDHDR hdrSaved = *phdr;
1222
1223	int x = phdr->x;
1224	int y = phdr->y;
1225	int w = phdr->w;
1226	int h = phdr->h;
1227
1228	uScreenId = mapCoordsToScreen(maFramebuffers, mcMonitors, &x, &y, &w, &h);
1229
1230	phdr->x = (int16_t)x;
1231	phdr->y = (int16_t)y;
1232	phdr->w = (uint16_t)w;
1233	phdr->h = (uint16_t)h;
1234
1235	DISPLAYFBINFO *pFBInfo = &maFramebuffers[uScreenId];
1236
1237	if (pFBInfo->u32ResizeStatus == ResizeStatus_Void)
1238	{
1239	/* Handle the command.
1240	*
1241	* Guest is responsible for updating the guest video memory.
1242	* The Windows guest does all drawing using Eng*.
1243	*
1244	* For local output, only dirty rectangle information is used
1245	* to update changed areas.
1246	*
1247	* Dirty rectangles are accumulated to exclude overlapping updates and
1248	* group small updates to a larger one.
1249	*/
1250
1251	/* Accumulate the update. */
1252	vbvaRgnDirtyRect (&rgn, uScreenId, phdr);
1253
1254	/* Forward the command to VRDP server. */
1255	mParent->consoleVRDPServer()->SendUpdate (uScreenId, phdr, cbCmd);
1256
1257	*phdr = hdrSaved;
1258	}
1259	}
1260
1261	vbvaReleaseCmd (phdr, cbCmd);
1262	}
1263
1264	for (uScreenId = 0; uScreenId < mcMonitors; uScreenId++)
1265	{
1266	if (!maFramebuffers[uScreenId].pFramebuffer.isNull())
1267	{
1268	maFramebuffers[uScreenId].pFramebuffer->Unlock ();
1269	}
1270
1271	if (maFramebuffers[uScreenId].u32ResizeStatus == ResizeStatus_Void)
1272	{
1273	/* Draw the framebuffer. */
1274	vbvaRgnUpdateFramebuffer (&rgn, uScreenId);
1275	}
1276	}
1277	}
1278
1279
1280	// IDisplay properties
1281	/////////////////////////////////////////////////////////////////////////////
1282
1283	/**
1284	* Returns the current display width in pixel
1285	*
1286	* @returns COM status code
1287	* @param width Address of result variable.
1288	*/
1289	STDMETHODIMP Display::COMGETTER(Width) (ULONG *width)
1290	{
1291	CheckComArgNotNull(width);
1292
1293	AutoCaller autoCaller (this);
1294	CheckComRCReturnRC (autoCaller.rc());
1295
1296	AutoWriteLock alock (this);
1297
1298	CHECK_CONSOLE_DRV (mpDrv);
1299
1300	*width = mpDrv->Connector.cx;
1301
1302	return S_OK;
1303	}
1304
1305	/**
1306	* Returns the current display height in pixel
1307	*
1308	* @returns COM status code
1309	* @param height Address of result variable.
1310	*/
1311	STDMETHODIMP Display::COMGETTER(Height) (ULONG *height)
1312	{
1313	CheckComArgNotNull(height);
1314
1315	AutoCaller autoCaller (this);
1316	CheckComRCReturnRC (autoCaller.rc());
1317
1318	AutoWriteLock alock (this);
1319
1320	CHECK_CONSOLE_DRV (mpDrv);
1321
1322	*height = mpDrv->Connector.cy;
1323
1324	return S_OK;
1325	}
1326
1327	/**
1328	* Returns the current display color depth in bits
1329	*
1330	* @returns COM status code
1331	* @param bitsPerPixel Address of result variable.
1332	*/
1333	STDMETHODIMP Display::COMGETTER(BitsPerPixel) (ULONG *bitsPerPixel)
1334	{
1335	if (!bitsPerPixel)
1336	return E_INVALIDARG;
1337
1338	AutoCaller autoCaller (this);
1339	CheckComRCReturnRC (autoCaller.rc());
1340
1341	AutoWriteLock alock (this);
1342
1343	CHECK_CONSOLE_DRV (mpDrv);
1344
1345	uint32_t cBits = 0;
1346	int rc = mpDrv->pUpPort->pfnQueryColorDepth(mpDrv->pUpPort, &cBits);
1347	AssertRC(rc);
1348	*bitsPerPixel = cBits;
1349
1350	return S_OK;
1351	}
1352
1353
1354	// IDisplay methods
1355	/////////////////////////////////////////////////////////////////////////////
1356
1357	STDMETHODIMP Display::SetupInternalFramebuffer (ULONG depth)
1358	{
1359	LogFlowFunc (("\n"));
1360
1361	AutoCaller autoCaller (this);
1362	CheckComRCReturnRC (autoCaller.rc());
1363
1364	AutoWriteLock alock (this);
1365
1366	/*
1367	* Create an internal framebuffer only if depth is not zero. Otherwise, we
1368	* reset back to the "black hole" state as it was at Display construction.
1369	*/
1370	ComPtr <IFramebuffer> frameBuf;
1371	if (depth)
1372	{
1373	ComObjPtr <InternalFramebuffer> internal;
1374	internal.createObject();
1375	internal->init (640, 480, depth);
1376	frameBuf = internal; // query interface
1377	}
1378
1379	Console::SafeVMPtrQuiet pVM (mParent);
1380	if (pVM.isOk())
1381	{
1382	/* Must leave the lock here because the changeFramebuffer will also obtain it. */
1383	alock.leave ();
1384
1385	/* send request to the EMT thread */
1386	PVMREQ pReq = NULL;
1387	int vrc = VMR3ReqCall (pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT,
1388	(PFNRT) changeFramebuffer, 4,
1389	this, static_cast <IFramebuffer *> (frameBuf),
1390	true /* aInternal */, VBOX_VIDEO_PRIMARY_SCREEN);
1391	if (RT_SUCCESS (vrc))
1392	vrc = pReq->iStatus;
1393	VMR3ReqFree (pReq);
1394
1395	alock.enter ();
1396
1397	ComAssertRCRet (vrc, E_FAIL);
1398	}
1399	else
1400	{
1401	/* No VM is created (VM is powered off), do a direct call */
1402	int vrc = changeFramebuffer (this, frameBuf, true /* aInternal */, VBOX_VIDEO_PRIMARY_SCREEN);
1403	ComAssertRCRet (vrc, E_FAIL);
1404	}
1405
1406	return S_OK;
1407	}
1408
1409	STDMETHODIMP Display::LockFramebuffer (BYTE **address)
1410	{
1411	CheckComArgOutPointerValid(address);
1412
1413	AutoCaller autoCaller (this);
1414	CheckComRCReturnRC (autoCaller.rc());
1415
1416	AutoWriteLock alock (this);
1417
1418	/* only allowed for internal framebuffers */
1419	if (mInternalFramebuffer && !mFramebufferOpened
1420	&& !maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN].pFramebuffer.isNull())
1421	{
1422	CHECK_CONSOLE_DRV (mpDrv);
1423
1424	maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN].pFramebuffer->Lock();
1425	mFramebufferOpened = true;
1426	*address = mpDrv->Connector.pu8Data;
1427	return S_OK;
1428	}
1429
1430	return setError (VBOX_E_NOT_SUPPORTED,
1431	tr ("Framebuffer locking is allowed only for the internal framebuffer"));
1432	}
1433
1434	STDMETHODIMP Display::UnlockFramebuffer()
1435	{
1436	AutoCaller autoCaller (this);
1437	CheckComRCReturnRC (autoCaller.rc());
1438
1439	AutoWriteLock alock (this);
1440
1441	if (mFramebufferOpened)
1442	{
1443	CHECK_CONSOLE_DRV (mpDrv);
1444
1445	maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN].pFramebuffer->Unlock();
1446	mFramebufferOpened = false;
1447	return S_OK;
1448	}
1449
1450	return setError (VBOX_E_NOT_SUPPORTED,
1451	tr ("Framebuffer locking is allowed only for the internal framebuffer"));
1452	}
1453
1454	STDMETHODIMP Display::RegisterExternalFramebuffer (IFramebuffer *frameBuf)
1455	{
1456	LogFlowFunc (("\n"));
1457
1458	CheckComArgNotNull(frameBuf);
1459
1460	AutoCaller autoCaller (this);
1461	CheckComRCReturnRC (autoCaller.rc());
1462
1463	AutoWriteLock alock (this);
1464
1465	Console::SafeVMPtrQuiet pVM (mParent);
1466	if (pVM.isOk())
1467	{
1468	/* Must leave the lock here because the changeFramebuffer will
1469	* also obtain it. */
1470	alock.leave ();
1471
1472	/* send request to the EMT thread */
1473	PVMREQ pReq = NULL;
1474	int vrc = VMR3ReqCall (pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT,
1475	(PFNRT) changeFramebuffer, 4, this, frameBuf, false /* aInternal */,
1476	VBOX_VIDEO_PRIMARY_SCREEN);
1477	if (RT_SUCCESS (vrc))
1478	vrc = pReq->iStatus;
1479	VMR3ReqFree (pReq);
1480
1481	alock.enter ();
1482
1483	ComAssertRCRet (vrc, E_FAIL);
1484	}
1485	else
1486	{
1487	/* No VM is created (VM is powered off), do a direct call */
1488	int vrc = changeFramebuffer (this, frameBuf, false /* aInternal */,
1489	VBOX_VIDEO_PRIMARY_SCREEN);
1490	ComAssertRCRet (vrc, E_FAIL);
1491	}
1492
1493	return S_OK;
1494	}
1495
1496	STDMETHODIMP Display::SetFramebuffer (ULONG aScreenId,
1497	IFramebuffer *aFramebuffer)
1498	{
1499	LogFlowFunc (("\n"));
1500
1501	CheckComArgOutPointerValid(aFramebuffer);
1502
1503	AutoCaller autoCaller (this);
1504	CheckComRCReturnRC (autoCaller.rc());
1505
1506	AutoWriteLock alock (this);
1507
1508	Console::SafeVMPtrQuiet pVM (mParent);
1509	if (pVM.isOk())
1510	{
1511	/* Must leave the lock here because the changeFramebuffer will
1512	* also obtain it. */
1513	alock.leave ();
1514
1515	/* send request to the EMT thread */
1516	PVMREQ pReq = NULL;
1517	int vrc = VMR3ReqCall (pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT,
1518	(PFNRT) changeFramebuffer, 4, this, aFramebuffer, false /* aInternal */,
1519	aScreenId);
1520	if (RT_SUCCESS (vrc))
1521	vrc = pReq->iStatus;
1522	VMR3ReqFree (pReq);
1523
1524	alock.enter ();
1525
1526	ComAssertRCRet (vrc, E_FAIL);
1527	}
1528	else
1529	{
1530	/* No VM is created (VM is powered off), do a direct call */
1531	int vrc = changeFramebuffer (this, aFramebuffer, false /* aInternal */,
1532	aScreenId);
1533	ComAssertRCRet (vrc, E_FAIL);
1534	}
1535
1536	return S_OK;
1537	}
1538
1539	STDMETHODIMP Display::GetFramebuffer (ULONG aScreenId,
1540	IFramebuffer *aFramebuffer, LONG aXOrigin, LONG *aYOrigin)
1541	{
1542	LogFlowFunc (("aScreenId = %d\n", aScreenId));
1543
1544	CheckComArgOutPointerValid(aFramebuffer);
1545
1546	AutoCaller autoCaller (this);
1547	CheckComRCReturnRC (autoCaller.rc());
1548
1549	AutoWriteLock alock (this);
1550
1551	/* @todo this should be actually done on EMT. */
1552	DISPLAYFBINFO *pFBInfo = &maFramebuffers[aScreenId];
1553
1554	*aFramebuffer = pFBInfo->pFramebuffer;
1555	if (*aFramebuffer)
1556	(*aFramebuffer)->AddRef ();
1557	if (aXOrigin)
1558	*aXOrigin = pFBInfo->xOrigin;
1559	if (aYOrigin)
1560	*aYOrigin = pFBInfo->yOrigin;
1561
1562	return S_OK;
1563	}
1564
1565	STDMETHODIMP Display::SetVideoModeHint(ULONG aWidth, ULONG aHeight,
1566	ULONG aBitsPerPixel, ULONG aDisplay)
1567	{
1568	AutoCaller autoCaller (this);
1569	CheckComRCReturnRC (autoCaller.rc());
1570
1571	AutoWriteLock alock (this);
1572
1573	CHECK_CONSOLE_DRV (mpDrv);
1574
1575	/*
1576	* Do some rough checks for valid input
1577	*/
1578	ULONG width = aWidth;
1579	if (!width)
1580	width = mpDrv->Connector.cx;
1581	ULONG height = aHeight;
1582	if (!height)
1583	height = mpDrv->Connector.cy;
1584	ULONG bpp = aBitsPerPixel;
1585	if (!bpp)
1586	{
1587	uint32_t cBits = 0;
1588	int rc = mpDrv->pUpPort->pfnQueryColorDepth(mpDrv->pUpPort, &cBits);
1589	AssertRC(rc);
1590	bpp = cBits;
1591	}
1592	ULONG cMonitors;
1593	mParent->machine()->COMGETTER(MonitorCount)(&cMonitors);
1594	if (cMonitors == 0 && aDisplay > 0)
1595	return E_INVALIDARG;
1596	if (aDisplay >= cMonitors)
1597	return E_INVALIDARG;
1598
1599	// sunlover 20070614: It is up to the guest to decide whether the hint is valid.
1600	// ULONG vramSize;
1601	// mParent->machine()->COMGETTER(VRAMSize)(&vramSize);
1602	// /* enough VRAM? */
1603	// if ((width * height * (bpp / 8)) > (vramSize * 1024 * 1024))
1604	// return setError(E_FAIL, tr("Not enough VRAM for the selected video mode"));
1605
1606	/* Have to leave the lock because the pfnRequestDisplayChange
1607	* will call EMT. */
1608	alock.leave ();
1609	if (mParent->getVMMDev())
1610	mParent->getVMMDev()->getVMMDevPort()->
1611	pfnRequestDisplayChange (mParent->getVMMDev()->getVMMDevPort(),
1612	aWidth, aHeight, aBitsPerPixel, aDisplay);
1613	return S_OK;
1614	}
1615
1616	STDMETHODIMP Display::SetSeamlessMode (BOOL enabled)
1617	{
1618	AutoCaller autoCaller (this);
1619	CheckComRCReturnRC (autoCaller.rc());
1620
1621	AutoWriteLock alock (this);
1622
1623	/* Have to leave the lock because the pfnRequestSeamlessChange will call EMT. */
1624	alock.leave ();
1625	if (mParent->getVMMDev())
1626	mParent->getVMMDev()->getVMMDevPort()->
1627	pfnRequestSeamlessChange (mParent->getVMMDev()->getVMMDevPort(),
1628	!!enabled);
1629	return S_OK;
1630	}
1631
1632	STDMETHODIMP Display::TakeScreenShot (BYTE *address, ULONG width, ULONG height)
1633	{
1634	/// @todo (r=dmik) this function may take too long to complete if the VM
1635	// is doing something like saving state right now. Which, in case if it
1636	// is called on the GUI thread, will make it unresponsive. We should
1637	// check the machine state here (by enclosing the check and VMRequCall
1638	// within the Console lock to make it atomic).
1639
1640	LogFlowFuncEnter();
1641	LogFlowFunc (("address=%p, width=%d, height=%d\n",
1642	address, width, height));
1643
1644	CheckComArgNotNull(address);
1645	CheckComArgExpr(width, width != 0);
1646	CheckComArgExpr(height, height != 0);
1647
1648	AutoCaller autoCaller (this);
1649	CheckComRCReturnRC (autoCaller.rc());
1650
1651	AutoWriteLock alock (this);
1652
1653	CHECK_CONSOLE_DRV (mpDrv);
1654
1655	Console::SafeVMPtr pVM (mParent);
1656	CheckComRCReturnRC (pVM.rc());
1657
1658	HRESULT rc = S_OK;
1659
1660	LogFlowFunc (("Sending SCREENSHOT request\n"));
1661
1662	/*
1663	* First try use the graphics device features for making a snapshot.
1664	* This does not support stretching, is an optional feature (returns
1665	* not supported).
1666	*
1667	* Note: It may cause a display resize. Watch out for deadlocks.
1668	*/
1669	int rcVBox = VERR_NOT_SUPPORTED;
1670	if ( mpDrv->Connector.cx == width
1671	&& mpDrv->Connector.cy == height)
1672	{
1673	PVMREQ pReq;
1674	size_t cbData = RT_ALIGN_Z(width, 4) * 4 * height;
1675	rcVBox = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT,
1676	(PFNRT)mpDrv->pUpPort->pfnSnapshot, 6, mpDrv->pUpPort,
1677	address, cbData, (uintptr_t)NULL, (uintptr_t)NULL, (uintptr_t)NULL);
1678	if (RT_SUCCESS(rcVBox))
1679	{
1680	rcVBox = pReq->iStatus;
1681	VMR3ReqFree(pReq);
1682	}
1683	}
1684
1685	/*
1686	* If the function returns not supported, or if stretching is requested,
1687	* we'll have to do all the work ourselves using the framebuffer data.
1688	*/
1689	if (rcVBox == VERR_NOT_SUPPORTED \|\| rcVBox == VERR_NOT_IMPLEMENTED)
1690	{
1691	/** @todo implement snapshot stretching & generic snapshot fallback. */
1692	rc = setError (E_NOTIMPL, tr ("This feature is not implemented"));
1693	}
1694	else if (RT_FAILURE(rcVBox))
1695	rc = setError (VBOX_E_IPRT_ERROR,
1696	tr ("Could not take a screenshot (%Rrc)"), rcVBox);
1697
1698	LogFlowFunc (("rc=%08X\n", rc));
1699	LogFlowFuncLeave();
1700	return rc;
1701	}
1702
1703	STDMETHODIMP Display::DrawToScreen (BYTE *address, ULONG x, ULONG y,
1704	ULONG width, ULONG height)
1705	{
1706	/// @todo (r=dmik) this function may take too long to complete if the VM
1707	// is doing something like saving state right now. Which, in case if it
1708	// is called on the GUI thread, will make it unresponsive. We should
1709	// check the machine state here (by enclosing the check and VMRequCall
1710	// within the Console lock to make it atomic).
1711
1712	LogFlowFuncEnter();
1713	LogFlowFunc (("address=%p, x=%d, y=%d, width=%d, height=%d\n",
1714	(void *)address, x, y, width, height));
1715
1716	CheckComArgNotNull(address);
1717	CheckComArgExpr(width, width != 0);
1718	CheckComArgExpr(height, height != 0);
1719
1720	AutoCaller autoCaller (this);
1721	CheckComRCReturnRC (autoCaller.rc());
1722
1723	AutoWriteLock alock (this);
1724
1725	CHECK_CONSOLE_DRV (mpDrv);
1726
1727	Console::SafeVMPtr pVM (mParent);
1728	CheckComRCReturnRC (pVM.rc());
1729
1730	/*
1731	* Again we're lazy and make the graphics device do all the
1732	* dirty conversion work.
1733	*/
1734	PVMREQ pReq;
1735	int rcVBox = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT,
1736	(PFNRT)mpDrv->pUpPort->pfnDisplayBlt, 6, mpDrv->pUpPort,
1737	address, x, y, width, height);
1738	if (RT_SUCCESS(rcVBox))
1739	{
1740	rcVBox = pReq->iStatus;
1741	VMR3ReqFree(pReq);
1742	}
1743
1744	/*
1745	* If the function returns not supported, we'll have to do all the
1746	* work ourselves using the framebuffer.
1747	*/
1748	HRESULT rc = S_OK;
1749	if (rcVBox == VERR_NOT_SUPPORTED \|\| rcVBox == VERR_NOT_IMPLEMENTED)
1750	{
1751	/** @todo implement generic fallback for screen blitting. */
1752	rc = E_NOTIMPL;
1753	}
1754	else if (RT_FAILURE(rcVBox))
1755	rc = setError (VBOX_E_IPRT_ERROR,
1756	tr ("Could not draw to the screen (%Rrc)"), rcVBox);
1757	//@todo
1758	// else
1759	// {
1760	// /* All ok. Redraw the screen. */
1761	// handleDisplayUpdate (x, y, width, height);
1762	// }
1763
1764	LogFlowFunc (("rc=%08X\n", rc));
1765	LogFlowFuncLeave();
1766	return rc;
1767	}
1768
1769	/**
1770	* Does a full invalidation of the VM display and instructs the VM
1771	* to update it immediately.
1772	*
1773	* @returns COM status code
1774	*/
1775	STDMETHODIMP Display::InvalidateAndUpdate()
1776	{
1777	LogFlowFuncEnter();
1778
1779	AutoCaller autoCaller (this);
1780	CheckComRCReturnRC (autoCaller.rc());
1781
1782	AutoWriteLock alock (this);
1783
1784	CHECK_CONSOLE_DRV (mpDrv);
1785
1786	Console::SafeVMPtr pVM (mParent);
1787	CheckComRCReturnRC (pVM.rc());
1788
1789	HRESULT rc = S_OK;
1790
1791	LogFlowFunc (("Sending DPYUPDATE request\n"));
1792
1793	/* Have to leave the lock when calling EMT. */
1794	alock.leave ();
1795
1796	/* pdm.h says that this has to be called from the EMT thread */
1797	PVMREQ pReq;
1798	int rcVBox = VMR3ReqCallVoid(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT,
1799	(PFNRT)mpDrv->pUpPort->pfnUpdateDisplayAll, 1, mpDrv->pUpPort);
1800	if (RT_SUCCESS(rcVBox))
1801	VMR3ReqFree(pReq);
1802
1803	alock.enter ();
1804
1805	if (RT_FAILURE(rcVBox))
1806	rc = setError (VBOX_E_IPRT_ERROR,
1807	tr ("Could not invalidate and update the screen (%Rrc)"), rcVBox);
1808
1809	LogFlowFunc (("rc=%08X\n", rc));
1810	LogFlowFuncLeave();
1811	return rc;
1812	}
1813
1814	/**
1815	* Notification that the framebuffer has completed the
1816	* asynchronous resize processing
1817	*
1818	* @returns COM status code
1819	*/
1820	STDMETHODIMP Display::ResizeCompleted(ULONG aScreenId)
1821	{
1822	LogFlowFunc (("\n"));
1823
1824	/// @todo (dmik) can we AutoWriteLock alock (this); here?
1825	// do it when we switch this class to VirtualBoxBase_NEXT.
1826	// This will require general code review and may add some details.
1827	// In particular, we may want to check whether EMT is really waiting for
1828	// this notification, etc. It might be also good to obey the caller to make
1829	// sure this method is not called from more than one thread at a time
1830	// (and therefore don't use Display lock at all here to save some
1831	// milliseconds).
1832	AutoCaller autoCaller (this);
1833	CheckComRCReturnRC (autoCaller.rc());
1834
1835	/* this is only valid for external framebuffers */
1836	if (mInternalFramebuffer)
1837	return setError (VBOX_E_NOT_SUPPORTED,
1838	tr ("Resize completed notification is valid only "
1839	"for external framebuffers"));
1840
1841	/* Set the flag indicating that the resize has completed and display
1842	* data need to be updated. */
1843	bool f = ASMAtomicCmpXchgU32 (&maFramebuffers[aScreenId].u32ResizeStatus,
1844	ResizeStatus_UpdateDisplayData, ResizeStatus_InProgress);
1845	AssertRelease(f);NOREF(f);
1846
1847	return S_OK;
1848	}
1849
1850	/**
1851	* Notification that the framebuffer has completed the
1852	* asynchronous update processing
1853	*
1854	* @returns COM status code
1855	*/
1856	STDMETHODIMP Display::UpdateCompleted()
1857	{
1858	LogFlowFunc (("\n"));
1859
1860	/// @todo (dmik) can we AutoWriteLock alock (this); here?
1861	// do it when we switch this class to VirtualBoxBase_NEXT.
1862	// Tthis will require general code review and may add some details.
1863	// In particular, we may want to check whether EMT is really waiting for
1864	// this notification, etc. It might be also good to obey the caller to make
1865	// sure this method is not called from more than one thread at a time
1866	// (and therefore don't use Display lock at all here to save some
1867	// milliseconds).
1868	AutoCaller autoCaller (this);
1869	CheckComRCReturnRC (autoCaller.rc());
1870
1871	/* this is only valid for external framebuffers */
1872	if (mInternalFramebuffer)
1873	return setError (VBOX_E_NOT_SUPPORTED,
1874	tr ("Resize completed notification is valid only "
1875	"for external framebuffers"));
1876
1877	maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN].pFramebuffer->Lock();
1878	/* signal our semaphore */
1879	RTSemEventMultiSignal(mUpdateSem);
1880	maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN].pFramebuffer->Unlock();
1881
1882	return S_OK;
1883	}
1884
1885	// private methods
1886	/////////////////////////////////////////////////////////////////////////////
1887
1888	/**
1889	* Helper to update the display information from the framebuffer.
1890	*
1891	* @param aCheckParams true to compare the parameters of the current framebuffer
1892	* and the new one and issue handleDisplayResize()
1893	* if they differ.
1894	* @thread EMT
1895	*/
1896	void Display::updateDisplayData (bool aCheckParams /* = false */)
1897	{
1898	/* the driver might not have been constructed yet */
1899	if (!mpDrv)
1900	return;
1901
1902	#if DEBUG
1903	/*
1904	* Sanity check. Note that this method may be called on EMT after Console
1905	* has started the power down procedure (but before our #drvDestruct() is
1906	* called, in which case pVM will aleady be NULL but mpDrv will not). Since
1907	* we don't really need pVM to proceed, we avoid this check in the release
1908	* build to save some ms (necessary to construct SafeVMPtrQuiet) in this
1909	* time-critical method.
1910	*/
1911	Console::SafeVMPtrQuiet pVM (mParent);
1912	if (pVM.isOk())
1913	VM_ASSERT_EMT (pVM.raw());
1914	#endif
1915
1916	/* The method is only relevant to the primary framebuffer. */
1917	IFramebuffer *pFramebuffer = maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN].pFramebuffer;
1918
1919	if (pFramebuffer)
1920	{
1921	HRESULT rc;
1922	BYTE *address = 0;
1923	rc = pFramebuffer->COMGETTER(Address) (&address);
1924	AssertComRC (rc);
1925	ULONG bytesPerLine = 0;
1926	rc = pFramebuffer->COMGETTER(BytesPerLine) (&bytesPerLine);
1927	AssertComRC (rc);
1928	ULONG bitsPerPixel = 0;
1929	rc = pFramebuffer->COMGETTER(BitsPerPixel) (&bitsPerPixel);
1930	AssertComRC (rc);
1931	ULONG width = 0;
1932	rc = pFramebuffer->COMGETTER(Width) (&width);
1933	AssertComRC (rc);
1934	ULONG height = 0;
1935	rc = pFramebuffer->COMGETTER(Height) (&height);
1936	AssertComRC (rc);
1937
1938	/*
1939	* Check current parameters with new ones and issue handleDisplayResize()
1940	* to let the new frame buffer adjust itself properly. Note that it will
1941	* result into a recursive updateDisplayData() call but with
1942	* aCheckOld = false.
1943	*/
1944	if (aCheckParams &&
1945	(mLastAddress != address \|\|
1946	mLastBytesPerLine != bytesPerLine \|\|
1947	mLastBitsPerPixel != bitsPerPixel \|\|
1948	mLastWidth != (int) width \|\|
1949	mLastHeight != (int) height))
1950	{
1951	handleDisplayResize (VBOX_VIDEO_PRIMARY_SCREEN, mLastBitsPerPixel,
1952	mLastAddress,
1953	mLastBytesPerLine,
1954	mLastWidth,
1955	mLastHeight);
1956	return;
1957	}
1958
1959	mpDrv->Connector.pu8Data = (uint8_t *) address;
1960	mpDrv->Connector.cbScanline = bytesPerLine;
1961	mpDrv->Connector.cBits = bitsPerPixel;
1962	mpDrv->Connector.cx = width;
1963	mpDrv->Connector.cy = height;
1964	}
1965	else
1966	{
1967	/* black hole */
1968	mpDrv->Connector.pu8Data = NULL;
1969	mpDrv->Connector.cbScanline = 0;
1970	mpDrv->Connector.cBits = 0;
1971	mpDrv->Connector.cx = 0;
1972	mpDrv->Connector.cy = 0;
1973	}
1974	}
1975
1976	/**
1977	* Changes the current frame buffer. Called on EMT to avoid both
1978	* race conditions and excessive locking.
1979	*
1980	* @note locks this object for writing
1981	* @thread EMT
1982	*/
1983	/* static */
1984	DECLCALLBACK(int) Display::changeFramebuffer (Display that, IFramebuffer aFB,
1985	bool aInternal, unsigned uScreenId)
1986	{
1987	LogFlowFunc (("uScreenId = %d\n", uScreenId));
1988
1989	AssertReturn (that, VERR_INVALID_PARAMETER);
1990	AssertReturn (aFB \|\| aInternal, VERR_INVALID_PARAMETER);
1991	AssertReturn (uScreenId < that->mcMonitors, VERR_INVALID_PARAMETER);
1992
1993	AutoCaller autoCaller (that);
1994	CheckComRCReturnRC (autoCaller.rc());
1995
1996	AutoWriteLock alock (that);
1997
1998	DISPLAYFBINFO *pDisplayFBInfo = &that->maFramebuffers[uScreenId];
1999	pDisplayFBInfo->pFramebuffer = aFB;
2000
2001	that->mInternalFramebuffer = aInternal;
2002	that->mSupportedAccelOps = 0;
2003
2004	/* determine which acceleration functions are supported by this framebuffer */
2005	if (aFB && !aInternal)
2006	{
2007	HRESULT rc;
2008	BOOL accelSupported = FALSE;
2009	rc = aFB->OperationSupported (
2010	FramebufferAccelerationOperation_SolidFillAcceleration, &accelSupported);
2011	AssertComRC (rc);
2012	if (accelSupported)
2013	that->mSupportedAccelOps \|=
2014	FramebufferAccelerationOperation_SolidFillAcceleration;
2015	accelSupported = FALSE;
2016	rc = aFB->OperationSupported (
2017	FramebufferAccelerationOperation_ScreenCopyAcceleration, &accelSupported);
2018	AssertComRC (rc);
2019	if (accelSupported)
2020	that->mSupportedAccelOps \|=
2021	FramebufferAccelerationOperation_ScreenCopyAcceleration;
2022	}
2023
2024	that->mParent->consoleVRDPServer()->SendResize ();
2025
2026	that->updateDisplayData (true /* aCheckParams */);
2027
2028	return VINF_SUCCESS;
2029	}
2030
2031	/**
2032	* Handle display resize event issued by the VGA device for the primary screen.
2033	*
2034	* @see PDMIDISPLAYCONNECTOR::pfnResize
2035	*/
2036	DECLCALLBACK(int) Display::displayResizeCallback(PPDMIDISPLAYCONNECTOR pInterface,
2037	uint32_t bpp, void *pvVRAM, uint32_t cbLine, uint32_t cx, uint32_t cy)
2038	{
2039	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
2040
2041	LogFlowFunc (("bpp %d, pvVRAM %p, cbLine %d, cx %d, cy %d\n",
2042	bpp, pvVRAM, cbLine, cx, cy));
2043
2044	return pDrv->pDisplay->handleDisplayResize(VBOX_VIDEO_PRIMARY_SCREEN, bpp, pvVRAM, cbLine, cx, cy);
2045	}
2046
2047	/**
2048	* Handle display update.
2049	*
2050	* @see PDMIDISPLAYCONNECTOR::pfnUpdateRect
2051	*/
2052	DECLCALLBACK(void) Display::displayUpdateCallback(PPDMIDISPLAYCONNECTOR pInterface,
2053	uint32_t x, uint32_t y, uint32_t cx, uint32_t cy)
2054	{
2055	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
2056
2057	#ifdef DEBUG_sunlover
2058	LogFlowFunc (("mfVideoAccelEnabled = %d, %d,%d %dx%d\n",
2059	pDrv->pDisplay->mfVideoAccelEnabled, x, y, cx, cy));
2060	#endif /* DEBUG_sunlover */
2061
2062	/* This call does update regardless of VBVA status.
2063	* But in VBVA mode this is called only as result of
2064	* pfnUpdateDisplayAll in the VGA device.
2065	*/
2066
2067	pDrv->pDisplay->handleDisplayUpdate(x, y, cx, cy);
2068	}
2069
2070	/**
2071	* Periodic display refresh callback.
2072	*
2073	* @see PDMIDISPLAYCONNECTOR::pfnRefresh
2074	*/
2075	DECLCALLBACK(void) Display::displayRefreshCallback(PPDMIDISPLAYCONNECTOR pInterface)
2076	{
2077	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
2078
2079	#ifdef DEBUG_sunlover
2080	STAM_PROFILE_START(&StatDisplayRefresh, a);
2081	#endif /* DEBUG_sunlover */
2082
2083	#ifdef DEBUG_sunlover_2
2084	LogFlowFunc (("pDrv->pDisplay->mfVideoAccelEnabled = %d\n",
2085	pDrv->pDisplay->mfVideoAccelEnabled));
2086	#endif /* DEBUG_sunlover_2 */
2087
2088	Display *pDisplay = pDrv->pDisplay;
2089
2090	unsigned uScreenId;
2091	for (uScreenId = 0; uScreenId < pDisplay->mcMonitors; uScreenId++)
2092	{
2093	DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[uScreenId];
2094
2095	/* Check the resize status. The status can be checked normally because
2096	* the status affects only the EMT.
2097	*/
2098	uint32_t u32ResizeStatus = pFBInfo->u32ResizeStatus;
2099
2100	if (u32ResizeStatus == ResizeStatus_UpdateDisplayData)
2101	{
2102	LogFlowFunc (("ResizeStatus_UpdateDisplayData %d\n", uScreenId));
2103	/* The framebuffer was resized and display data need to be updated. */
2104	pDisplay->handleResizeCompletedEMT ();
2105	if (pFBInfo->u32ResizeStatus != ResizeStatus_Void)
2106	{
2107	/* The resize status could be not Void here because a pending resize is issued. */
2108	continue;
2109	}
2110	/* Continue with normal processing because the status here is ResizeStatus_Void. */
2111	if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
2112	{
2113	/* Repaint the display because VM continued to run during the framebuffer resize. */
2114	if (!pFBInfo->pFramebuffer.isNull())
2115	pDrv->pUpPort->pfnUpdateDisplayAll(pDrv->pUpPort);
2116	}
2117	/* Ignore the refresh for the screen to replay the logic. */
2118	continue;
2119	}
2120	else if (u32ResizeStatus == ResizeStatus_InProgress)
2121	{
2122	/* The framebuffer is being resized. Do not call the VGA device back. Immediately return. */
2123	LogFlowFunc (("ResizeStatus_InProcess\n"));
2124	continue;
2125	}
2126
2127	if (pFBInfo->pFramebuffer.isNull())
2128	{
2129	/*
2130	* Do nothing in the "black hole" mode to avoid copying guest
2131	* video memory to the frame buffer
2132	*/
2133	}
2134	else
2135	{
2136	if (pDisplay->mfPendingVideoAccelEnable)
2137	{
2138	/* Acceleration was enabled while machine was not yet running
2139	* due to restoring from saved state. Update entire display and
2140	* actually enable acceleration.
2141	*/
2142	Assert(pDisplay->mpPendingVbvaMemory);
2143
2144	/* Acceleration can not be yet enabled.*/
2145	Assert(pDisplay->mpVbvaMemory == NULL);
2146	Assert(!pDisplay->mfVideoAccelEnabled);
2147
2148	if (pDisplay->mfMachineRunning)
2149	{
2150	pDisplay->VideoAccelEnable (pDisplay->mfPendingVideoAccelEnable,
2151	pDisplay->mpPendingVbvaMemory);
2152
2153	/* Reset the pending state. */
2154	pDisplay->mfPendingVideoAccelEnable = false;
2155	pDisplay->mpPendingVbvaMemory = NULL;
2156	}
2157	}
2158	else
2159	{
2160	Assert(pDisplay->mpPendingVbvaMemory == NULL);
2161
2162	if (pDisplay->mfVideoAccelEnabled)
2163	{
2164	Assert(pDisplay->mpVbvaMemory);
2165	pDisplay->VideoAccelFlush ();
2166	}
2167	else
2168	{
2169	Assert(pDrv->Connector.pu8Data);
2170	pDrv->pUpPort->pfnUpdateDisplay(pDrv->pUpPort);
2171	}
2172	}
2173	/* Inform the VRDP server that the current display update sequence is
2174	* completed. At this moment the framebuffer memory contains a definite
2175	* image, that is synchronized with the orders already sent to VRDP client.
2176	* The server can now process redraw requests from clients or initial
2177	* fullscreen updates for new clients.
2178	*/
2179	if (pFBInfo->u32ResizeStatus == ResizeStatus_Void)
2180	{
2181	Assert (pDisplay->mParent && pDisplay->mParent->consoleVRDPServer());
2182	pDisplay->mParent->consoleVRDPServer()->SendUpdate (uScreenId, NULL, 0);
2183	}
2184	}
2185	}
2186
2187	#ifdef DEBUG_sunlover
2188	STAM_PROFILE_STOP(&StatDisplayRefresh, a);
2189	#endif /* DEBUG_sunlover */
2190	#ifdef DEBUG_sunlover_2
2191	LogFlowFunc (("leave\n"));
2192	#endif /* DEBUG_sunlover_2 */
2193	}
2194
2195	/**
2196	* Reset notification
2197	*
2198	* @see PDMIDISPLAYCONNECTOR::pfnReset
2199	*/
2200	DECLCALLBACK(void) Display::displayResetCallback(PPDMIDISPLAYCONNECTOR pInterface)
2201	{
2202	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
2203
2204	LogFlowFunc (("\n"));
2205
2206	/* Disable VBVA mode. */
2207	pDrv->pDisplay->VideoAccelEnable (false, NULL);
2208	}
2209
2210	/**
2211	* LFBModeChange notification
2212	*
2213	* @see PDMIDISPLAYCONNECTOR::pfnLFBModeChange
2214	*/
2215	DECLCALLBACK(void) Display::displayLFBModeChangeCallback(PPDMIDISPLAYCONNECTOR pInterface, bool fEnabled)
2216	{
2217	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
2218
2219	LogFlowFunc (("fEnabled=%d\n", fEnabled));
2220
2221	NOREF(fEnabled);
2222
2223	/* Disable VBVA mode in any case. The guest driver reenables VBVA mode if necessary. */
2224	pDrv->pDisplay->VideoAccelEnable (false, NULL);
2225	}
2226
2227	/**
2228	* Adapter information change notification.
2229	*
2230	* @see PDMIDISPLAYCONNECTOR::pfnProcessAdapterData
2231	*/
2232	DECLCALLBACK(void) Display::displayProcessAdapterDataCallback(PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM, uint32_t u32VRAMSize)
2233	{
2234	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
2235
2236	if (pvVRAM == NULL)
2237	{
2238	unsigned i;
2239	for (i = 0; i < pDrv->pDisplay->mcMonitors; i++)
2240	{
2241	DISPLAYFBINFO *pFBInfo = &pDrv->pDisplay->maFramebuffers[i];
2242
2243	pFBInfo->u32Offset = 0;
2244	pFBInfo->u32MaxFramebufferSize = 0;
2245	pFBInfo->u32InformationSize = 0;
2246	}
2247	}
2248	else
2249	{
2250	uint8_t pu8 = (uint8_t )pvVRAM;
2251	pu8 += u32VRAMSize - VBOX_VIDEO_ADAPTER_INFORMATION_SIZE;
2252
2253	// @todo
2254	uint8_t *pu8End = pu8 + VBOX_VIDEO_ADAPTER_INFORMATION_SIZE;
2255
2256	VBOXVIDEOINFOHDR *pHdr;
2257
2258	for (;;)
2259	{
2260	pHdr = (VBOXVIDEOINFOHDR *)pu8;
2261	pu8 += sizeof (VBOXVIDEOINFOHDR);
2262
2263	if (pu8 >= pu8End)
2264	{
2265	LogRel(("VBoxVideo: Guest adapter information overflow!!!\n"));
2266	break;
2267	}
2268
2269	if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_DISPLAY)
2270	{
2271	if (pHdr->u16Length != sizeof (VBOXVIDEOINFODISPLAY))
2272	{
2273	LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "DISPLAY", pHdr->u16Length));
2274	break;
2275	}
2276
2277	VBOXVIDEOINFODISPLAY pDisplay = (VBOXVIDEOINFODISPLAY )pu8;
2278
2279	if (pDisplay->u32Index >= pDrv->pDisplay->mcMonitors)
2280	{
2281	LogRel(("VBoxVideo: Guest adapter information invalid display index %d!!!\n", pDisplay->u32Index));
2282	break;
2283	}
2284
2285	DISPLAYFBINFO *pFBInfo = &pDrv->pDisplay->maFramebuffers[pDisplay->u32Index];
2286
2287	pFBInfo->u32Offset = pDisplay->u32Offset;
2288	pFBInfo->u32MaxFramebufferSize = pDisplay->u32FramebufferSize;
2289	pFBInfo->u32InformationSize = pDisplay->u32InformationSize;
2290
2291	LogFlow(("VBOX_VIDEO_INFO_TYPE_DISPLAY: %d: at 0x%08X, size 0x%08X, info 0x%08X\n", pDisplay->u32Index, pDisplay->u32Offset, pDisplay->u32FramebufferSize, pDisplay->u32InformationSize));
2292	}
2293	else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_QUERY_CONF32)
2294	{
2295	if (pHdr->u16Length != sizeof (VBOXVIDEOINFOQUERYCONF32))
2296	{
2297	LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "CONF32", pHdr->u16Length));
2298	break;
2299	}
2300
2301	VBOXVIDEOINFOQUERYCONF32 pConf32 = (VBOXVIDEOINFOQUERYCONF32 )pu8;
2302
2303	switch (pConf32->u32Index)
2304	{
2305	case VBOX_VIDEO_QCI32_MONITOR_COUNT:
2306	{
2307	pConf32->u32Value = pDrv->pDisplay->mcMonitors;
2308	} break;
2309
2310	case VBOX_VIDEO_QCI32_OFFSCREEN_HEAP_SIZE:
2311	{
2312	/* @todo make configurable. */
2313	pConf32->u32Value = _1M;
2314	} break;
2315
2316	default:
2317	LogRel(("VBoxVideo: CONF32 %d not supported!!! Skipping.\n", pConf32->u32Index));
2318	}
2319	}
2320	else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_END)
2321	{
2322	if (pHdr->u16Length != 0)
2323	{
2324	LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "END", pHdr->u16Length));
2325	break;
2326	}
2327
2328	break;
2329	}
2330	else
2331	{
2332	LogRel(("Guest adapter information contains unsupported type %d. The block has been skipped.\n", pHdr->u8Type));
2333	}
2334
2335	pu8 += pHdr->u16Length;
2336	}
2337	}
2338	}
2339
2340	/**
2341	* Display information change notification.
2342	*
2343	* @see PDMIDISPLAYCONNECTOR::pfnProcessDisplayData
2344	*/
2345	DECLCALLBACK(void) Display::displayProcessDisplayDataCallback(PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM, unsigned uScreenId)
2346	{
2347	PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
2348
2349	if (uScreenId >= pDrv->pDisplay->mcMonitors)
2350	{
2351	LogRel(("VBoxVideo: Guest display information invalid display index %d!!!\n", uScreenId));
2352	return;
2353	}
2354
2355	/* Get the display information structure. */
2356	DISPLAYFBINFO *pFBInfo = &pDrv->pDisplay->maFramebuffers[uScreenId];
2357
2358	uint8_t pu8 = (uint8_t )pvVRAM;
2359	pu8 += pFBInfo->u32Offset + pFBInfo->u32MaxFramebufferSize;
2360
2361	// @todo
2362	uint8_t *pu8End = pu8 + pFBInfo->u32InformationSize;
2363
2364	VBOXVIDEOINFOHDR *pHdr;
2365
2366	for (;;)
2367	{
2368	pHdr = (VBOXVIDEOINFOHDR *)pu8;
2369	pu8 += sizeof (VBOXVIDEOINFOHDR);
2370
2371	if (pu8 >= pu8End)
2372	{
2373	LogRel(("VBoxVideo: Guest display information overflow!!!\n"));
2374	break;
2375	}
2376
2377	if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_SCREEN)
2378	{
2379	if (pHdr->u16Length != sizeof (VBOXVIDEOINFOSCREEN))
2380	{
2381	LogRel(("VBoxVideo: Guest display information %s invalid length %d!!!\n", "SCREEN", pHdr->u16Length));
2382	break;
2383	}
2384
2385	VBOXVIDEOINFOSCREEN pScreen = (VBOXVIDEOINFOSCREEN )pu8;
2386
2387	pFBInfo->xOrigin = pScreen->xOrigin;
2388	pFBInfo->yOrigin = pScreen->yOrigin;
2389
2390	pFBInfo->w = pScreen->u16Width;
2391	pFBInfo->h = pScreen->u16Height;
2392
2393	LogFlow(("VBOX_VIDEO_INFO_TYPE_SCREEN: (%p) %d: at %d,%d, linesize 0x%X, size %dx%d, bpp %d, flags 0x%02X\n",
2394	pHdr, uScreenId, pScreen->xOrigin, pScreen->yOrigin, pScreen->u32LineSize, pScreen->u16Width, pScreen->u16Height, pScreen->bitsPerPixel, pScreen->u8Flags));
2395
2396	if (uScreenId != VBOX_VIDEO_PRIMARY_SCREEN)
2397	{
2398	/* Primary screen resize is initiated by the VGA device. */
2399	pDrv->pDisplay->handleDisplayResize(uScreenId, pScreen->bitsPerPixel, (uint8_t *)pvVRAM + pFBInfo->u32Offset, pScreen->u32LineSize, pScreen->u16Width, pScreen->u16Height);
2400	}
2401	}
2402	else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_END)
2403	{
2404	if (pHdr->u16Length != 0)
2405	{
2406	LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "END", pHdr->u16Length));
2407	break;
2408	}
2409
2410	break;
2411	}
2412	else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_HOST_EVENTS)
2413	{
2414	if (pHdr->u16Length != sizeof (VBOXVIDEOINFOHOSTEVENTS))
2415	{
2416	LogRel(("VBoxVideo: Guest display information %s invalid length %d!!!\n", "HOST_EVENTS", pHdr->u16Length));
2417	break;
2418	}
2419
2420	VBOXVIDEOINFOHOSTEVENTS pHostEvents = (VBOXVIDEOINFOHOSTEVENTS )pu8;
2421
2422	pFBInfo->pHostEvents = pHostEvents;
2423
2424	LogFlow(("VBOX_VIDEO_INFO_TYPE_HOSTEVENTS: (%p)\n",
2425	pHostEvents));
2426	}
2427	else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_LINK)
2428	{
2429	if (pHdr->u16Length != sizeof (VBOXVIDEOINFOLINK))
2430	{
2431	LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "LINK", pHdr->u16Length));
2432	break;
2433	}
2434
2435	VBOXVIDEOINFOLINK pLink = (VBOXVIDEOINFOLINK )pu8;
2436	pu8 += pLink->i32Offset;
2437	}
2438	else
2439	{
2440	LogRel(("Guest display information contains unsupported type %d\n", pHdr->u8Type));
2441	}
2442
2443	pu8 += pHdr->u16Length;
2444	}
2445	}
2446
2447	/**
2448	* Queries an interface to the driver.
2449	*
2450	* @returns Pointer to interface.
2451	* @returns NULL if the interface was not supported by the driver.
2452	* @param pInterface Pointer to this interface structure.
2453	* @param enmInterface The requested interface identification.
2454	*/
2455	DECLCALLBACK(void *) Display::drvQueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
2456	{
2457	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
2458	PDRVMAINDISPLAY pDrv = PDMINS_2_DATA(pDrvIns, PDRVMAINDISPLAY);
2459	switch (enmInterface)
2460	{
2461	case PDMINTERFACE_BASE:
2462	return &pDrvIns->IBase;
2463	case PDMINTERFACE_DISPLAY_CONNECTOR:
2464	return &pDrv->Connector;
2465	default:
2466	return NULL;
2467	}
2468	}
2469
2470
2471	/**
2472	* Destruct a display driver instance.
2473	*
2474	* @returns VBox status.
2475	* @param pDrvIns The driver instance data.
2476	*/
2477	DECLCALLBACK(void) Display::drvDestruct(PPDMDRVINS pDrvIns)
2478	{
2479	PDRVMAINDISPLAY pData = PDMINS_2_DATA(pDrvIns, PDRVMAINDISPLAY);
2480	LogFlowFunc (("iInstance=%d\n", pDrvIns->iInstance));
2481	if (pData->pDisplay)
2482	{
2483	AutoWriteLock displayLock (pData->pDisplay);
2484	pData->pDisplay->mpDrv = NULL;
2485	pData->pDisplay->mpVMMDev = NULL;
2486	pData->pDisplay->mLastAddress = NULL;
2487	pData->pDisplay->mLastBytesPerLine = 0;
2488	pData->pDisplay->mLastBitsPerPixel = 0,
2489	pData->pDisplay->mLastWidth = 0;
2490	pData->pDisplay->mLastHeight = 0;
2491	}
2492	}
2493
2494
2495	/**
2496	* Construct a display driver instance.
2497	*
2498	* @returns VBox status.
2499	* @param pDrvIns The driver instance data.
2500	* If the registration structure is needed, pDrvIns->pDrvReg points to it.
2501	* @param pCfgHandle Configuration node handle for the driver. Use this to obtain the configuration
2502	* of the driver instance. It's also found in pDrvIns->pCfgHandle, but like
2503	* iInstance it's expected to be used a bit in this function.
2504	*/
2505	DECLCALLBACK(int) Display::drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
2506	{
2507	PDRVMAINDISPLAY pData = PDMINS_2_DATA(pDrvIns, PDRVMAINDISPLAY);
2508	LogFlowFunc (("iInstance=%d\n", pDrvIns->iInstance));
2509
2510	/*
2511	* Validate configuration.
2512	*/
2513	if (!CFGMR3AreValuesValid(pCfgHandle, "Object\0"))
2514	return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
2515	PPDMIBASE pBaseIgnore;
2516	int rc = pDrvIns->pDrvHlp->pfnAttach(pDrvIns, &pBaseIgnore);
2517	if (rc != VERR_PDM_NO_ATTACHED_DRIVER)
2518	{
2519	AssertMsgFailed(("Configuration error: Not possible to attach anything to this driver!\n"));
2520	return VERR_PDM_DRVINS_NO_ATTACH;
2521	}
2522
2523	/*
2524	* Init Interfaces.
2525	*/
2526	pDrvIns->IBase.pfnQueryInterface = Display::drvQueryInterface;
2527
2528	pData->Connector.pfnResize = Display::displayResizeCallback;
2529	pData->Connector.pfnUpdateRect = Display::displayUpdateCallback;
2530	pData->Connector.pfnRefresh = Display::displayRefreshCallback;
2531	pData->Connector.pfnReset = Display::displayResetCallback;
2532	pData->Connector.pfnLFBModeChange = Display::displayLFBModeChangeCallback;
2533	pData->Connector.pfnProcessAdapterData = Display::displayProcessAdapterDataCallback;
2534	pData->Connector.pfnProcessDisplayData = Display::displayProcessDisplayDataCallback;
2535
2536	/*
2537	* Get the IDisplayPort interface of the above driver/device.
2538	*/
2539	pData->pUpPort = (PPDMIDISPLAYPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_DISPLAY_PORT);
2540	if (!pData->pUpPort)
2541	{
2542	AssertMsgFailed(("Configuration error: No display port interface above!\n"));
2543	return VERR_PDM_MISSING_INTERFACE_ABOVE;
2544	}
2545
2546	/*
2547	* Get the Display object pointer and update the mpDrv member.
2548	*/
2549	void *pv;
2550	rc = CFGMR3QueryPtr(pCfgHandle, "Object", &pv);
2551	if (RT_FAILURE(rc))
2552	{
2553	AssertMsgFailed(("Configuration error: No/bad \"Object\" value! rc=%Rrc\n", rc));
2554	return rc;
2555	}
2556	pData->pDisplay = (Display )pv; /* @todo Check this cast! */
2557	pData->pDisplay->mpDrv = pData;
2558
2559	/*
2560	* Update our display information according to the framebuffer
2561	*/
2562	pData->pDisplay->updateDisplayData();
2563
2564	/*
2565	* Start periodic screen refreshes
2566	*/
2567	pData->pUpPort->pfnSetRefreshRate(pData->pUpPort, 20);
2568
2569	return VINF_SUCCESS;
2570	}
2571
2572
2573	/**
2574	* Display driver registration record.
2575	*/
2576	const PDMDRVREG Display::DrvReg =
2577	{
2578	/* u32Version */
2579	PDM_DRVREG_VERSION,
2580	/* szDriverName */
2581	"MainDisplay",
2582	/* pszDescription */
2583	"Main display driver (Main as in the API).",
2584	/* fFlags */
2585	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
2586	/* fClass. */
2587	PDM_DRVREG_CLASS_DISPLAY,
2588	/* cMaxInstances */
2589	~0,
2590	/* cbInstance */
2591	sizeof(DRVMAINDISPLAY),
2592	/* pfnConstruct */
2593	Display::drvConstruct,
2594	/* pfnDestruct */
2595	Display::drvDestruct,
2596	/* pfnIOCtl */
2597	NULL,
2598	/* pfnPowerOn */
2599	NULL,
2600	/* pfnReset */
2601	NULL,
2602	/* pfnSuspend */
2603	NULL,
2604	/* pfnResume */
2605	NULL,
2606	/* pfnDetach */
2607	NULL
2608	};
2609	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/DisplayImpl.cpp@ 16684

Download in other formats: