DisplayImplLegacy.cpp

Last change on this file was 106061, checked in by vboxsync, 2 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 31.0 KB

Line
1	/* $Id: DisplayImplLegacy.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* VirtualBox IDisplay implementation, helpers for legacy GAs.
4	*
5	* Methods and helpers to support old Guest Additions 3.x or older.
6	* This is not used by the current Guest Additions.
7	*/
8
9	/*
10	* Copyright (C) 2006-2024 Oracle and/or its affiliates.
11	*
12	* This file is part of VirtualBox base platform packages, as
13	* available from https://www.virtualbox.org.
14	*
15	* This program is free software; you can redistribute it and/or
16	* modify it under the terms of the GNU General Public License
17	* as published by the Free Software Foundation, in version 3 of the
18	* License.
19	*
20	* This program is distributed in the hope that it will be useful, but
21	* WITHOUT ANY WARRANTY; without even the implied warranty of
22	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23	* General Public License for more details.
24	*
25	* You should have received a copy of the GNU General Public License
26	* along with this program; if not, see <https://www.gnu.org/licenses>.
27	*
28	* SPDX-License-Identifier: GPL-3.0-only
29	*/
30
31	#define LOG_GROUP LOG_GROUP_MAIN_DISPLAY
32	#include "LoggingNew.h"
33
34	#include "DisplayImpl.h"
35	#include "ConsoleImpl.h"
36	#include "ConsoleVRDPServer.h"
37	#include "VMMDev.h"
38	#include <VBox/VMMDev.h>
39
40	/* generated header */
41	#include "VBoxEvents.h"
42
43
44	int videoAccelConstruct(VIDEOACCEL *pVideoAccel)
45	{
46	pVideoAccel->pVbvaMemory = NULL;
47	pVideoAccel->fVideoAccelEnabled = false;
48
49	pVideoAccel->pu8VbvaPartial = NULL;
50	pVideoAccel->cbVbvaPartial = 0;
51
52	pVideoAccel->hXRoadsVideoAccel = NIL_RTSEMXROADS;
53	int vrc = RTSemXRoadsCreate(&pVideoAccel->hXRoadsVideoAccel);
54	AssertRC(vrc);
55
56	return vrc;
57	}
58
59	void videoAccelDestroy(VIDEOACCEL *pVideoAccel)
60	{
61	RTSemXRoadsDestroy(pVideoAccel->hXRoadsVideoAccel);
62	RT_ZERO(*pVideoAccel);
63	}
64
65	static unsigned mapCoordsToScreen(DISPLAYFBINFO pInfos, unsigned cInfos, int px, int py, int pw, int *ph)
66	{
67	RT_NOREF(pw, ph);
68
69	DISPLAYFBINFO *pInfo = pInfos;
70	unsigned uScreenId;
71	Log9(("mapCoordsToScreen: %d,%d %dx%d\n", px, py, pw, ph));
72	for (uScreenId = 0; uScreenId < cInfos; uScreenId++, pInfo++)
73	{
74	Log9((" [%d] %d,%d %dx%d\n", uScreenId, pInfo->xOrigin, pInfo->yOrigin, pInfo->w, pInfo->h));
75	if ( (pInfo->xOrigin <= px && px < pInfo->xOrigin + (int)pInfo->w)
76	&& (pInfo->yOrigin <= py && py < pInfo->yOrigin + (int)pInfo->h))
77	{
78	/* The rectangle belongs to the screen. Correct coordinates. */
79	*px -= pInfo->xOrigin;
80	*py -= pInfo->yOrigin;
81	Log9((" -> %d,%d", px, py));
82	break;
83	}
84	}
85	if (uScreenId == cInfos)
86	{
87	/* Map to primary screen. */
88	uScreenId = 0;
89	}
90	Log9((" scr %d\n", uScreenId));
91	return uScreenId;
92	}
93
94
95	typedef struct _VBVADIRTYREGION
96	{
97	/* Copies of object's pointers used by vbvaRgn functions. */
98	DISPLAYFBINFO *paFramebuffers;
99	unsigned cMonitors;
100	Display *pDisplay;
101	PPDMIDISPLAYPORT pPort;
102
103	/* The rectangle that includes all dirty rectangles. */
104	RTRECT aDirtyRects[SchemaDefs::MaxGuestMonitors];
105
106	} VBVADIRTYREGION;
107
108	static void vbvaRgnInit(VBVADIRTYREGION prgn, DISPLAYFBINFO paFramebuffers, unsigned cMonitors,
109	Display *pd, PPDMIDISPLAYPORT pp)
110	{
111	prgn->paFramebuffers = paFramebuffers;
112	prgn->cMonitors = cMonitors;
113	prgn->pDisplay = pd;
114	prgn->pPort = pp;
115
116	RT_ZERO(prgn->aDirtyRects);
117	}
118
119	static void vbvaRgnDirtyRect(VBVADIRTYREGION prgn, unsigned uScreenId, VBVACMDHDR phdr)
120	{
121	Log9(("x = %d, y = %d, w = %d, h = %d\n", phdr->x, phdr->y, phdr->w, phdr->h));
122
123	/*
124	* Here update rectangles are accumulated to form an update area.
125	*/
126	/** @todo
127	* Now the simplest method is used which builds one rectangle that
128	* includes all update areas. A bit more advanced method can be
129	* employed here. The method should be fast however.
130	*/
131	if (phdr->w == 0 \|\| phdr->h == 0)
132	{
133	/* Empty rectangle. */
134	return;
135	}
136
137	int32_t xRight = phdr->x + phdr->w;
138	int32_t yBottom = phdr->y + phdr->h;
139
140	RTRECT *pDirtyRect = &prgn->aDirtyRects[uScreenId];
141	DISPLAYFBINFO *pFBInfo = &prgn->paFramebuffers[uScreenId];
142
143	if (pDirtyRect->xRight == 0)
144	{
145	/* This is the first rectangle to be added. */
146	pDirtyRect->xLeft = phdr->x;
147	pDirtyRect->yTop = phdr->y;
148	pDirtyRect->xRight = xRight;
149	pDirtyRect->yBottom = yBottom;
150	}
151	else
152	{
153	/* Adjust region coordinates. */
154	if (pDirtyRect->xLeft > phdr->x)
155	{
156	pDirtyRect->xLeft = phdr->x;
157	}
158
159	if (pDirtyRect->yTop > phdr->y)
160	{
161	pDirtyRect->yTop = phdr->y;
162	}
163
164	if (pDirtyRect->xRight < xRight)
165	{
166	pDirtyRect->xRight = xRight;
167	}
168
169	if (pDirtyRect->yBottom < yBottom)
170	{
171	pDirtyRect->yBottom = yBottom;
172	}
173	}
174
175	if (pFBInfo->fDefaultFormat)
176	{
177	/// @todo pfnUpdateDisplayRect must take the vram offset parameter for the framebuffer
178	prgn->pPort->pfnUpdateDisplayRect(prgn->pPort, phdr->x, phdr->y, phdr->w, phdr->h);
179	prgn->pDisplay->i_handleDisplayUpdate(uScreenId, phdr->x, phdr->y, phdr->w, phdr->h);
180	}
181
182	return;
183	}
184
185	static void vbvaRgnUpdateFramebuffer(VBVADIRTYREGION *prgn, unsigned uScreenId)
186	{
187	RTRECT *pDirtyRect = &prgn->aDirtyRects[uScreenId];
188	DISPLAYFBINFO *pFBInfo = &prgn->paFramebuffers[uScreenId];
189
190	uint32_t w = pDirtyRect->xRight - pDirtyRect->xLeft;
191	uint32_t h = pDirtyRect->yBottom - pDirtyRect->yTop;
192
193	if (!pFBInfo->fDefaultFormat && w != 0 && h != 0)
194	{
195	/// @todo pfnUpdateDisplayRect must take the vram offset parameter for the framebuffer
196	prgn->pPort->pfnUpdateDisplayRect(prgn->pPort, pDirtyRect->xLeft, pDirtyRect->yTop, w, h);
197	prgn->pDisplay->i_handleDisplayUpdate(uScreenId, pDirtyRect->xLeft, pDirtyRect->yTop, w, h);
198	}
199	}
200
201	void i_vbvaSetMemoryFlags(VBVAMEMORY *pVbvaMemory,
202	bool fVideoAccelEnabled,
203	bool fVideoAccelVRDP,
204	uint32_t fu32SupportedOrders,
205	DISPLAYFBINFO *paFBInfos,
206	unsigned cFBInfos)
207	{
208	if (pVbvaMemory)
209	{
210	/* This called only on changes in mode. So reset VRDP always. */
211	uint32_t fu32Flags = VBVA_F_MODE_VRDP_RESET;
212
213	if (fVideoAccelEnabled)
214	{
215	fu32Flags \|= VBVA_F_MODE_ENABLED;
216
217	if (fVideoAccelVRDP)
218	{
219	fu32Flags \|= VBVA_F_MODE_VRDP \| VBVA_F_MODE_VRDP_ORDER_MASK;
220
221	pVbvaMemory->fu32SupportedOrders = fu32SupportedOrders;
222	}
223	}
224
225	pVbvaMemory->fu32ModeFlags = fu32Flags;
226	}
227
228	unsigned uScreenId;
229	for (uScreenId = 0; uScreenId < cFBInfos; uScreenId++)
230	{
231	if (paFBInfos[uScreenId].pHostEvents)
232	{
233	paFBInfos[uScreenId].pHostEvents->fu32Events \|= VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET;
234	}
235	}
236	}
237
238	bool Display::i_VideoAccelAllowed(void)
239	{
240	return true;
241	}
242
243	int videoAccelEnterVGA(VIDEOACCEL *pVideoAccel)
244	{
245	return RTSemXRoadsNSEnter(pVideoAccel->hXRoadsVideoAccel);
246	}
247
248	void videoAccelLeaveVGA(VIDEOACCEL *pVideoAccel)
249	{
250	RTSemXRoadsNSLeave(pVideoAccel->hXRoadsVideoAccel);
251	}
252
253	int videoAccelEnterVMMDev(VIDEOACCEL *pVideoAccel)
254	{
255	return RTSemXRoadsEWEnter(pVideoAccel->hXRoadsVideoAccel);
256	}
257
258	void videoAccelLeaveVMMDev(VIDEOACCEL *pVideoAccel)
259	{
260	RTSemXRoadsEWLeave(pVideoAccel->hXRoadsVideoAccel);
261	}
262
263	/**
264	* @thread EMT
265	*/
266	int Display::i_VideoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory, PPDMIDISPLAYPORT pUpPort)
267	{
268	LogRelFlowFunc(("fEnable = %d\n", fEnable));
269
270	int vrc = i_videoAccelEnable(fEnable, pVbvaMemory, pUpPort);
271
272	LogRelFlowFunc(("%Rrc.\n", vrc));
273	return vrc;
274	}
275
276	int Display::i_videoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory, PPDMIDISPLAYPORT pUpPort)
277	{
278	VIDEOACCEL *pVideoAccel = &mVideoAccelLegacy;
279
280	/* Called each time the guest wants to use acceleration,
281	* or when the VGA device disables acceleration,
282	* or when restoring the saved state with accel enabled.
283	*
284	* VGA device disables acceleration on each video mode change
285	* and on reset.
286	*
287	* Guest enabled acceleration at will. And it has to enable
288	* acceleration after a mode change.
289	*/
290	LogRelFlowFunc(("mfVideoAccelEnabled = %d, fEnable = %d, pVbvaMemory = %p\n",
291	pVideoAccel->fVideoAccelEnabled, fEnable, pVbvaMemory));
292
293	/* Strictly check parameters. Callers must not pass anything in the case. */
294	Assert((fEnable && pVbvaMemory) \|\| (!fEnable && pVbvaMemory == NULL));
295
296	if (!i_VideoAccelAllowed ())
297	return VERR_NOT_SUPPORTED;
298
299	/* Check that current status is not being changed */
300	if (pVideoAccel->fVideoAccelEnabled == fEnable)
301	return VINF_SUCCESS;
302
303	if (pVideoAccel->fVideoAccelEnabled)
304	{
305	/* Process any pending orders and empty the VBVA ring buffer. */
306	i_videoAccelFlush (pUpPort);
307	}
308
309	if (!fEnable && pVideoAccel->pVbvaMemory)
310	pVideoAccel->pVbvaMemory->fu32ModeFlags &= ~VBVA_F_MODE_ENABLED;
311
312	if (fEnable)
313	{
314	/* Process any pending VGA device changes, resize. */
315	pUpPort->pfnUpdateDisplayAll(pUpPort, /* fFailOnResize = */ false);
316	}
317
318	/* Protect the videoaccel state transition. */
319	RTCritSectEnter(&mVideoAccelLock);
320
321	if (fEnable)
322	{
323	/* Initialize the hardware memory. */
324	i_vbvaSetMemoryFlags(pVbvaMemory, true, mfVideoAccelVRDP,
325	mfu32SupportedOrders, maFramebuffers, mcMonitors);
326	pVbvaMemory->off32Data = 0;
327	pVbvaMemory->off32Free = 0;
328
329	memset(pVbvaMemory->aRecords, 0, sizeof(pVbvaMemory->aRecords));
330	pVbvaMemory->indexRecordFirst = 0;
331	pVbvaMemory->indexRecordFree = 0;
332
333	pVideoAccel->pVbvaMemory = pVbvaMemory;
334	pVideoAccel->fVideoAccelEnabled = true;
335
336	LogRel(("VBVA: Enabled.\n"));
337	}
338	else
339	{
340	pVideoAccel->pVbvaMemory = NULL;
341	pVideoAccel->fVideoAccelEnabled = false;
342
343	LogRel(("VBVA: Disabled.\n"));
344	}
345
346	RTCritSectLeave(&mVideoAccelLock);
347
348	if (!fEnable)
349	{
350	pUpPort->pfnUpdateDisplayAll(pUpPort, /* fFailOnResize = */ false);
351	}
352
353	/* Notify the VMMDev, which saves VBVA status in the saved state,
354	* and needs to know current status.
355	*/
356	VMMDev *pVMMDev = mParent->i_getVMMDev();
357	if (pVMMDev)
358	{
359	PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
360	if (pVMMDevPort)
361	pVMMDevPort->pfnVBVAChange(pVMMDevPort, fEnable);
362	}
363
364	LogRelFlowFunc(("VINF_SUCCESS.\n"));
365	return VINF_SUCCESS;
366	}
367
368	static bool i_vbvaVerifyRingBuffer(VBVAMEMORY *pVbvaMemory)
369	{
370	RT_NOREF(pVbvaMemory);
371	return true;
372	}
373
374	static void i_vbvaFetchBytes(VBVAMEMORY pVbvaMemory, uint8_t pu8Dst, uint32_t cbDst)
375	{
376	if (cbDst >= VBVA_RING_BUFFER_SIZE)
377	{
378	AssertMsgFailed(("cbDst = 0x%08X, ring buffer size 0x%08X\n", cbDst, VBVA_RING_BUFFER_SIZE));
379	return;
380	}
381
382	uint32_t u32BytesTillBoundary = VBVA_RING_BUFFER_SIZE - pVbvaMemory->off32Data;
383	uint8_t *src = &pVbvaMemory->au8RingBuffer[pVbvaMemory->off32Data];
384	int32_t i32Diff = cbDst - u32BytesTillBoundary;
385
386	if (i32Diff <= 0)
387	{
388	/* Chunk will not cross buffer boundary. */
389	memcpy (pu8Dst, src, cbDst);
390	}
391	else
392	{
393	/* Chunk crosses buffer boundary. */
394	memcpy(pu8Dst, src, u32BytesTillBoundary);
395	memcpy(pu8Dst + u32BytesTillBoundary, &pVbvaMemory->au8RingBuffer[0], i32Diff);
396	}
397
398	/* Advance data offset. */
399	pVbvaMemory->off32Data = (pVbvaMemory->off32Data + cbDst) % VBVA_RING_BUFFER_SIZE;
400
401	return;
402	}
403
404
405	static bool i_vbvaPartialRead(uint8_t *ppu8, uint32_t pcb, uint32_t cbRecord, VBVAMEMORY *pVbvaMemory)
406	{
407	uint8_t *pu8New;
408
409	LogFlow(("MAIN::DisplayImpl::vbvaPartialRead: p = %p, cb = %d, cbRecord 0x%08X\n",
410	ppu8, pcb, cbRecord));
411
412	if (*ppu8)
413	{
414	Assert (*pcb);
415	pu8New = (uint8_t )RTMemRealloc(ppu8, cbRecord);
416	}
417	else
418	{
419	Assert (!*pcb);
420	pu8New = (uint8_t *)RTMemAlloc(cbRecord);
421	}
422
423	if (!pu8New)
424	{
425	/* Memory allocation failed, fail the function. */
426	Log(("MAIN::vbvaPartialRead: failed to (re)alocate memory for partial record!!! cbRecord 0x%08X\n",
427	cbRecord));
428
429	if (*ppu8)
430	{
431	RTMemFree(*ppu8);
432	}
433
434	*ppu8 = NULL;
435	*pcb = 0;
436
437	return false;
438	}
439
440	/* Fetch data from the ring buffer. */
441	i_vbvaFetchBytes(pVbvaMemory, pu8New + pcb, cbRecord - pcb);
442
443	*ppu8 = pu8New;
444	*pcb = cbRecord;
445
446	return true;
447	}
448
449	/* For contiguous chunks just return the address in the buffer.
450	* For crossing boundary - allocate a buffer from heap.
451	*/
452	static bool i_vbvaFetchCmd(VIDEOACCEL pVideoAccel, VBVACMDHDR ppHdr, uint32_t pcbCmd)
453	{
454	VBVAMEMORY *pVbvaMemory = pVideoAccel->pVbvaMemory;
455
456	uint32_t indexRecordFirst = pVbvaMemory->indexRecordFirst;
457	uint32_t indexRecordFree = pVbvaMemory->indexRecordFree;
458
459	#ifdef DEBUG_sunlover
460	LogFlowFunc(("first = %d, free = %d\n",
461	indexRecordFirst, indexRecordFree));
462	#endif /* DEBUG_sunlover */
463
464	if (!i_vbvaVerifyRingBuffer(pVbvaMemory))
465	{
466	return false;
467	}
468
469	if (indexRecordFirst == indexRecordFree)
470	{
471	/* No records to process. Return without assigning output variables. */
472	return true;
473	}
474
475	uint32_t cbRecordCurrent = ASMAtomicReadU32(&pVbvaMemory->aRecords[indexRecordFirst].cbRecord);
476
477	#ifdef DEBUG_sunlover
478	LogFlowFunc(("cbRecord = 0x%08X\n", cbRecordCurrent));
479	#endif /* DEBUG_sunlover */
480
481	uint32_t cbRecord = cbRecordCurrent & ~VBVA_F_RECORD_PARTIAL;
482
483	if (pVideoAccel->cbVbvaPartial)
484	{
485	/* There is a partial read in process. Continue with it. */
486
487	Assert(pVideoAccel->pu8VbvaPartial);
488
489	LogFlowFunc(("continue partial record cbVbvaPartial = %d cbRecord 0x%08X, first = %d, free = %d\n",
490	pVideoAccel->cbVbvaPartial, cbRecordCurrent, indexRecordFirst, indexRecordFree));
491
492	if (cbRecord > pVideoAccel->cbVbvaPartial)
493	{
494	/* New data has been added to the record. */
495	if (!i_vbvaPartialRead(&pVideoAccel->pu8VbvaPartial, &pVideoAccel->cbVbvaPartial, cbRecord, pVbvaMemory))
496	{
497	return false;
498	}
499	}
500
501	if (!(cbRecordCurrent & VBVA_F_RECORD_PARTIAL))
502	{
503	/* The record is completed by guest. Return it to the caller. */
504	ppHdr = (VBVACMDHDR )pVideoAccel->pu8VbvaPartial;
505	*pcbCmd = pVideoAccel->cbVbvaPartial;
506
507	pVideoAccel->pu8VbvaPartial = NULL;
508	pVideoAccel->cbVbvaPartial = 0;
509
510	/* Advance the record index. */
511	pVbvaMemory->indexRecordFirst = (indexRecordFirst + 1) % VBVA_MAX_RECORDS;
512
513	#ifdef DEBUG_sunlover
514	LogFlowFunc(("partial done ok, data = %d, free = %d\n",
515	pVbvaMemory->off32Data, pVbvaMemory->off32Free));
516	#endif /* DEBUG_sunlover */
517	}
518
519	return true;
520	}
521
522	/* A new record need to be processed. */
523	if (cbRecordCurrent & VBVA_F_RECORD_PARTIAL)
524	{
525	/* Current record is being written by guest. '=' is important here. */
526	if (cbRecord >= VBVA_RING_BUFFER_SIZE - VBVA_RING_BUFFER_THRESHOLD)
527	{
528	/* Partial read must be started. */
529	if (!i_vbvaPartialRead(&pVideoAccel->pu8VbvaPartial, &pVideoAccel->cbVbvaPartial, cbRecord, pVbvaMemory))
530	{
531	return false;
532	}
533
534	LogFlowFunc(("started partial record cbVbvaPartial = 0x%08X cbRecord 0x%08X, first = %d, free = %d\n",
535	pVideoAccel->cbVbvaPartial, cbRecordCurrent, indexRecordFirst, indexRecordFree));
536	}
537
538	return true;
539	}
540
541	/* Current record is complete. If it is not empty, process it. */
542	if (cbRecord)
543	{
544	/* The size of largest contiguous chunk in the ring biffer. */
545	uint32_t u32BytesTillBoundary = VBVA_RING_BUFFER_SIZE - pVbvaMemory->off32Data;
546
547	/* The ring buffer pointer. */
548	uint8_t *au8RingBuffer = &pVbvaMemory->au8RingBuffer[0];
549
550	/* The pointer to data in the ring buffer. */
551	uint8_t *src = &au8RingBuffer[pVbvaMemory->off32Data];
552
553	/* Fetch or point the data. */
554	if (u32BytesTillBoundary >= cbRecord)
555	{
556	/* The command does not cross buffer boundary. Return address in the buffer. */
557	ppHdr = (VBVACMDHDR )src;
558
559	/* Advance data offset. */
560	pVbvaMemory->off32Data = (pVbvaMemory->off32Data + cbRecord) % VBVA_RING_BUFFER_SIZE;
561	}
562	else
563	{
564	/* The command crosses buffer boundary. Rare case, so not optimized. */
565	uint8_t dst = (uint8_t )RTMemAlloc(cbRecord);
566
567	if (!dst)
568	{
569	LogRelFlowFunc(("could not allocate %d bytes from heap!!!\n", cbRecord));
570	pVbvaMemory->off32Data = (pVbvaMemory->off32Data + cbRecord) % VBVA_RING_BUFFER_SIZE;
571	return false;
572	}
573
574	i_vbvaFetchBytes(pVbvaMemory, dst, cbRecord);
575
576	ppHdr = (VBVACMDHDR )dst;
577
578	#ifdef DEBUG_sunlover
579	LogFlowFunc(("Allocated from heap %p\n", dst));
580	#endif /* DEBUG_sunlover */
581	}
582	}
583
584	*pcbCmd = cbRecord;
585
586	/* Advance the record index. */
587	pVbvaMemory->indexRecordFirst = (indexRecordFirst + 1) % VBVA_MAX_RECORDS;
588
589	#ifdef DEBUG_sunlover
590	LogFlowFunc(("done ok, data = %d, free = %d\n",
591	pVbvaMemory->off32Data, pVbvaMemory->off32Free));
592	#endif /* DEBUG_sunlover */
593
594	return true;
595	}
596
597	static void i_vbvaReleaseCmd(VIDEOACCEL pVideoAccel, VBVACMDHDR pHdr, int32_t cbCmd)
598	{
599	RT_NOREF(cbCmd);
600	uint8_t *au8RingBuffer = pVideoAccel->pVbvaMemory->au8RingBuffer;
601
602	if ( (uint8_t *)pHdr >= au8RingBuffer
603	&& (uint8_t *)pHdr < &au8RingBuffer[VBVA_RING_BUFFER_SIZE])
604	{
605	/* The pointer is inside ring buffer. Must be continuous chunk. */
606	Assert(VBVA_RING_BUFFER_SIZE - ((uint8_t *)pHdr - au8RingBuffer) >= cbCmd);
607
608	/* Do nothing. */
609
610	Assert(!pVideoAccel->pu8VbvaPartial && pVideoAccel->cbVbvaPartial == 0);
611	}
612	else
613	{
614	/* The pointer is outside. It is then an allocated copy. */
615
616	#ifdef DEBUG_sunlover
617	LogFlowFunc(("Free heap %p\n", pHdr));
618	#endif /* DEBUG_sunlover */
619
620	if ((uint8_t *)pHdr == pVideoAccel->pu8VbvaPartial)
621	{
622	pVideoAccel->pu8VbvaPartial = NULL;
623	pVideoAccel->cbVbvaPartial = 0;
624	}
625	else
626	{
627	Assert(!pVideoAccel->pu8VbvaPartial && pVideoAccel->cbVbvaPartial == 0);
628	}
629
630	RTMemFree(pHdr);
631	}
632
633	return;
634	}
635
636
637	/**
638	* Called regularly on the DisplayRefresh timer.
639	* Also on behalf of guest, when the ring buffer is full.
640	*
641	* @thread EMT
642	*/
643	void Display::i_VideoAccelFlush(PPDMIDISPLAYPORT pUpPort)
644	{
645	int vrc = i_videoAccelFlush(pUpPort);
646	if (RT_FAILURE(vrc))
647	{
648	/* Disable on errors. */
649	i_videoAccelEnable(false, NULL, pUpPort);
650	}
651	}
652
653	int Display::i_videoAccelFlush(PPDMIDISPLAYPORT pUpPort)
654	{
655	VIDEOACCEL *pVideoAccel = &mVideoAccelLegacy;
656	VBVAMEMORY *pVbvaMemory = pVideoAccel->pVbvaMemory;
657
658	#ifdef DEBUG_sunlover_2
659	LogFlowFunc(("fVideoAccelEnabled = %d\n", pVideoAccel->fVideoAccelEnabled));
660	#endif /* DEBUG_sunlover_2 */
661
662	if (!pVideoAccel->fVideoAccelEnabled)
663	{
664	Log(("Display::VideoAccelFlush: called with disabled VBVA!!! Ignoring.\n"));
665	return VINF_SUCCESS;
666	}
667
668	/* Here VBVA is enabled and we have the accelerator memory pointer. */
669	Assert(pVbvaMemory);
670
671	#ifdef DEBUG_sunlover_2
672	LogFlowFunc(("indexRecordFirst = %d, indexRecordFree = %d, off32Data = %d, off32Free = %d\n",
673	pVbvaMemory->indexRecordFirst, pVbvaMemory->indexRecordFree,
674	pVbvaMemory->off32Data, pVbvaMemory->off32Free));
675	#endif /* DEBUG_sunlover_2 */
676
677	/* Quick check for "nothing to update" case. */
678	if (pVbvaMemory->indexRecordFirst == pVbvaMemory->indexRecordFree)
679	{
680	return VINF_SUCCESS;
681	}
682
683	/* Process the ring buffer */
684	unsigned uScreenId;
685
686	/* Initialize dirty rectangles accumulator. */
687	VBVADIRTYREGION rgn;
688	vbvaRgnInit(&rgn, maFramebuffers, mcMonitors, this, pUpPort);
689
690	for (;;)
691	{
692	VBVACMDHDR *phdr = NULL;
693	uint32_t cbCmd = UINT32_MAX;
694
695	/* Fetch the command data. */
696	if (!i_vbvaFetchCmd(pVideoAccel, &phdr, &cbCmd))
697	{
698	Log(("Display::VideoAccelFlush: unable to fetch command. off32Data = %d, off32Free = %d. Disabling VBVA!!!\n",
699	pVbvaMemory->off32Data, pVbvaMemory->off32Free));
700	return VERR_INVALID_STATE;
701	}
702
703	if (cbCmd == uint32_t(~0))
704	{
705	/* No more commands yet in the queue. */
706	#ifdef DEBUG_sunlover
707	LogFlowFunc(("no command\n"));
708	#endif /* DEBUG_sunlover */
709	break;
710	}
711
712	if (cbCmd != 0)
713	{
714	#ifdef DEBUG_sunlover
715	LogFlowFunc(("hdr: cbCmd = %d, x=%d, y=%d, w=%d, h=%d\n",
716	cbCmd, phdr->x, phdr->y, phdr->w, phdr->h));
717	#endif /* DEBUG_sunlover */
718
719	VBVACMDHDR hdrSaved = *phdr;
720
721	int x = phdr->x;
722	int y = phdr->y;
723	int w = phdr->w;
724	int h = phdr->h;
725
726	uScreenId = mapCoordsToScreen(maFramebuffers, mcMonitors, &x, &y, &w, &h);
727
728	phdr->x = (int16_t)x;
729	phdr->y = (int16_t)y;
730	phdr->w = (uint16_t)w;
731	phdr->h = (uint16_t)h;
732
733	/* Handle the command.
734	*
735	* Guest is responsible for updating the guest video memory.
736	* The Windows guest does all drawing using Eng*.
737	*
738	* For local output, only dirty rectangle information is used
739	* to update changed areas.
740	*
741	* Dirty rectangles are accumulated to exclude overlapping updates and
742	* group small updates to a larger one.
743	*/
744
745	/* Accumulate the update. */
746	vbvaRgnDirtyRect(&rgn, uScreenId, phdr);
747
748	/* Forward the command to VRDP server. */
749	mParent->i_consoleVRDPServer()->SendUpdate(uScreenId, phdr, cbCmd);
750
751	*phdr = hdrSaved;
752	}
753
754	i_vbvaReleaseCmd(pVideoAccel, phdr, cbCmd);
755	}
756
757	for (uScreenId = 0; uScreenId < mcMonitors; uScreenId++)
758	{
759	/* Draw the framebuffer. */
760	vbvaRgnUpdateFramebuffer(&rgn, uScreenId);
761	}
762	return VINF_SUCCESS;
763	}
764
765	int Display::i_videoAccelRefreshProcess(PPDMIDISPLAYPORT pUpPort)
766	{
767	int vrc = VWRN_INVALID_STATE; /* Default is to do a display update in VGA device. */
768
769	VIDEOACCEL *pVideoAccel = &mVideoAccelLegacy;
770
771	videoAccelEnterVGA(pVideoAccel);
772
773	if (pVideoAccel->fVideoAccelEnabled)
774	{
775	Assert(pVideoAccel->pVbvaMemory);
776	vrc = i_videoAccelFlush(pUpPort);
777	if (RT_FAILURE(vrc))
778	{
779	/* Disable on errors. */
780	i_videoAccelEnable(false, NULL, pUpPort);
781	vrc = VWRN_INVALID_STATE; /* Do a display update in VGA device. */
782	}
783	else
784	{
785	vrc = VINF_SUCCESS;
786	}
787	}
788
789	videoAccelLeaveVGA(pVideoAccel);
790
791	return vrc;
792	}
793
794	void Display::processAdapterData(void *pvVRAM, uint32_t u32VRAMSize)
795	{
796	RT_NOREF(u32VRAMSize);
797	if (pvVRAM == NULL)
798	{
799	unsigned i;
800	for (i = 0; i < mcMonitors; i++)
801	{
802	DISPLAYFBINFO *pFBInfo = &maFramebuffers[i];
803
804	pFBInfo->u32Offset = 0;
805	pFBInfo->u32MaxFramebufferSize = 0;
806	pFBInfo->u32InformationSize = 0;
807	}
808	}
809	#ifndef VBOX_WITH_HGSMI
810	else
811	{
812	uint8_t pu8 = (uint8_t )pvVRAM;
813	pu8 += u32VRAMSize - VBOX_VIDEO_ADAPTER_INFORMATION_SIZE;
814
815	/// @todo
816	uint8_t *pu8End = pu8 + VBOX_VIDEO_ADAPTER_INFORMATION_SIZE;
817
818	VBOXVIDEOINFOHDR *pHdr;
819
820	for (;;)
821	{
822	pHdr = (VBOXVIDEOINFOHDR *)pu8;
823	pu8 += sizeof(VBOXVIDEOINFOHDR);
824
825	if (pu8 >= pu8End)
826	{
827	LogRel(("VBoxVideo: Guest adapter information overflow!!!\n"));
828	break;
829	}
830
831	if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_DISPLAY)
832	{
833	if (pHdr->u16Length != sizeof(VBOXVIDEOINFODISPLAY))
834	{
835	LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "DISPLAY", pHdr->u16Length));
836	break;
837	}
838
839	VBOXVIDEOINFODISPLAY pDisplay = (VBOXVIDEOINFODISPLAY )pu8;
840
841	if (pDisplay->u32Index >= mcMonitors)
842	{
843	LogRel(("VBoxVideo: Guest adapter information invalid display index %d!!!\n", pDisplay->u32Index));
844	break;
845	}
846
847	DISPLAYFBINFO *pFBInfo = &maFramebuffers[pDisplay->u32Index];
848
849	pFBInfo->u32Offset = pDisplay->u32Offset;
850	pFBInfo->u32MaxFramebufferSize = pDisplay->u32FramebufferSize;
851	pFBInfo->u32InformationSize = pDisplay->u32InformationSize;
852
853	LogRelFlow(("VBOX_VIDEO_INFO_TYPE_DISPLAY: %d: at 0x%08X, size 0x%08X, info 0x%08X\n", pDisplay->u32Index,
854	pDisplay->u32Offset, pDisplay->u32FramebufferSize, pDisplay->u32InformationSize));
855	}
856	else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_QUERY_CONF32)
857	{
858	if (pHdr->u16Length != sizeof(VBOXVIDEOINFOQUERYCONF32))
859	{
860	LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "CONF32", pHdr->u16Length));
861	break;
862	}
863
864	VBOXVIDEOINFOQUERYCONF32 pConf32 = (VBOXVIDEOINFOQUERYCONF32 )pu8;
865
866	switch (pConf32->u32Index)
867	{
868	case VBOX_VIDEO_QCI32_MONITOR_COUNT:
869	{
870	pConf32->u32Value = mcMonitors;
871	} break;
872
873	case VBOX_VIDEO_QCI32_OFFSCREEN_HEAP_SIZE:
874	{
875	/** @todo make configurable. */
876	pConf32->u32Value = _1M;
877	} break;
878
879	default:
880	LogRel(("VBoxVideo: CONF32 %d not supported!!! Skipping.\n", pConf32->u32Index));
881	}
882	}
883	else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_END)
884	{
885	if (pHdr->u16Length != 0)
886	{
887	LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "END", pHdr->u16Length));
888	break;
889	}
890
891	break;
892	}
893	else if (pHdr->u8Type != VBOX_VIDEO_INFO_TYPE_NV_HEAP)
894	{
895	/** @todo why is Additions/WINNT/Graphics/Miniport/VBoxVideo. cpp pushing this to us? */
896	LogRel(("Guest adapter information contains unsupported type %d. The block has been skipped.\n", pHdr->u8Type));
897	}
898
899	pu8 += pHdr->u16Length;
900	}
901	}
902	#endif /* !VBOX_WITH_HGSMI */
903	}
904
905	void Display::processDisplayData(void *pvVRAM, unsigned uScreenId)
906	{
907	if (uScreenId >= mcMonitors)
908	{
909	LogRel(("VBoxVideo: Guest display information invalid display index %d!!!\n", uScreenId));
910	return;
911	}
912
913	/* Get the display information structure. */
914	DISPLAYFBINFO *pFBInfo = &maFramebuffers[uScreenId];
915
916	uint8_t pu8 = (uint8_t )pvVRAM;
917	pu8 += pFBInfo->u32Offset + pFBInfo->u32MaxFramebufferSize;
918
919	/// @todo
920	uint8_t *pu8End = pu8 + pFBInfo->u32InformationSize;
921
922	VBOXVIDEOINFOHDR *pHdr;
923
924	for (;;)
925	{
926	pHdr = (VBOXVIDEOINFOHDR *)pu8;
927	pu8 += sizeof(VBOXVIDEOINFOHDR);
928
929	if (pu8 >= pu8End)
930	{
931	LogRel(("VBoxVideo: Guest display information overflow!!!\n"));
932	break;
933	}
934
935	if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_SCREEN)
936	{
937	if (pHdr->u16Length != sizeof(VBOXVIDEOINFOSCREEN))
938	{
939	LogRel(("VBoxVideo: Guest display information %s invalid length %d!!!\n", "SCREEN", pHdr->u16Length));
940	break;
941	}
942
943	VBOXVIDEOINFOSCREEN pScreen = (VBOXVIDEOINFOSCREEN )pu8;
944
945	pFBInfo->xOrigin = pScreen->xOrigin;
946	pFBInfo->yOrigin = pScreen->yOrigin;
947
948	pFBInfo->w = pScreen->u16Width;
949	pFBInfo->h = pScreen->u16Height;
950
951	LogRelFlow(("VBOX_VIDEO_INFO_TYPE_SCREEN: (%p) %d: at %d,%d, linesize 0x%X, size %dx%d, bpp %d, flags 0x%02X\n",
952	pHdr, uScreenId, pScreen->xOrigin, pScreen->yOrigin, pScreen->u32LineSize, pScreen->u16Width,
953	pScreen->u16Height, pScreen->bitsPerPixel, pScreen->u8Flags));
954
955	if (uScreenId != VBOX_VIDEO_PRIMARY_SCREEN)
956	{
957	/* Primary screen resize is eeeeeeeee by the VGA device. */
958	if (pFBInfo->fDisabled)
959	{
960	pFBInfo->fDisabled = false;
961	::FireGuestMonitorChangedEvent(mParent->i_getEventSource(), GuestMonitorChangedEventType_Enabled, uScreenId,
962	pFBInfo->xOrigin, pFBInfo->yOrigin, pFBInfo->w, pFBInfo->h);
963	}
964
965	i_handleDisplayResize(uScreenId, pScreen->bitsPerPixel,
966	(uint8_t *)pvVRAM + pFBInfo->u32Offset,
967	pScreen->u32LineSize,
968	pScreen->u16Width, pScreen->u16Height,
969	VBVA_SCREEN_F_ACTIVE,
970	pScreen->xOrigin, pScreen->yOrigin, false);
971	}
972	}
973	else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_END)
974	{
975	if (pHdr->u16Length != 0)
976	{
977	LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "END", pHdr->u16Length));
978	break;
979	}
980
981	break;
982	}
983	else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_HOST_EVENTS)
984	{
985	if (pHdr->u16Length != sizeof(VBOXVIDEOINFOHOSTEVENTS))
986	{
987	LogRel(("VBoxVideo: Guest display information %s invalid length %d!!!\n", "HOST_EVENTS", pHdr->u16Length));
988	break;
989	}
990
991	VBOXVIDEOINFOHOSTEVENTS pHostEvents = (VBOXVIDEOINFOHOSTEVENTS )pu8;
992
993	pFBInfo->pHostEvents = pHostEvents;
994
995	LogFlow(("VBOX_VIDEO_INFO_TYPE_HOSTEVENTS: (%p)\n",
996	pHostEvents));
997	}
998	else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_LINK)
999	{
1000	if (pHdr->u16Length != sizeof(VBOXVIDEOINFOLINK))
1001	{
1002	LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "LINK", pHdr->u16Length));
1003	break;
1004	}
1005
1006	VBOXVIDEOINFOLINK pLink = (VBOXVIDEOINFOLINK )pu8;
1007	pu8 += pLink->i32Offset;
1008	}
1009	else
1010	{
1011	LogRel(("Guest display information contains unsupported type %d\n", pHdr->u8Type));
1012	}
1013
1014	pu8 += pHdr->u16Length;
1015	}
1016	}
1017
1018	/* 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/DisplayImplLegacy.cpp

Download in other formats: