Framebuffer.cpp@ 98302

Last change on this file since 98302 was 98302, checked in by vboxsync, 2 years ago
FE/SDL. bugref:9449. Removing secure label related code.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 27.3 KB

Line
1	/* $Id: Framebuffer.cpp 98302 2023-01-25 09:07:43Z vboxsync $ */
2	/** @file
3	* VBoxSDL - Implementation of VBoxSDLFB (SDL framebuffer) class
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28	#include <VBox/com/com.h>
29	#include <VBox/com/array.h>
30	#include <VBox/com/string.h>
31	#include <VBox/com/Guid.h>
32	#include <VBox/com/ErrorInfo.h>
33	#include <VBox/com/VirtualBox.h>
34
35	#include <iprt/stream.h>
36	#include <iprt/env.h>
37
38	#ifdef RT_OS_OS2
39	# undef RT_MAX
40	// from <iprt/cdefs.h>
41	# define RT_MAX(Value1, Value2) ((Value1) >= (Value2) ? (Value1) : (Value2))
42	#endif
43
44	using namespace com;
45
46	#define LOG_GROUP LOG_GROUP_GUI
47	#include <VBox/err.h>
48	#include <VBox/log.h>
49
50	#include "VBoxSDL.h"
51	#include "Framebuffer.h"
52	#include "Ico64x01.h"
53
54	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_LINUX)
55	# ifdef _MSC_VER
56	# pragma warning(push)
57	# pragma warning(disable: 4121) /* warning C4121: 'SDL_SysWMmsg' : alignment of a member was sensitive to packing*/
58	# endif
59	# include <SDL_syswm.h> /* for SDL_GetWMInfo() */
60	# ifdef _MSC_VER
61	# pragma warning(pop)
62	# endif
63	#endif
64
65	#if defined(VBOX_WITH_XPCOM)
66	NS_IMPL_THREADSAFE_ISUPPORTS1_CI(VBoxSDLFB, IFramebuffer)
67	NS_DECL_CLASSINFO(VBoxSDLFB)
68	NS_IMPL_THREADSAFE_ISUPPORTS2_CI(VBoxSDLFBOverlay, IFramebufferOverlay, IFramebuffer)
69	NS_DECL_CLASSINFO(VBoxSDLFBOverlay)
70	#endif
71
72	static bool gfSdlInitialized = false; /*< if SDL was initialized /
73	static SDL_Surface gWMIcon = NULL; /< the application icon /
74	static RTNATIVETHREAD gSdlNativeThread = NIL_RTNATIVETHREAD; /*< the SDL thread /
75
76	//
77	// Constructor / destructor
78	//
79
80	VBoxSDLFB::VBoxSDLFB()
81	{
82	}
83
84	HRESULT VBoxSDLFB::FinalConstruct()
85	{
86	return 0;
87	}
88
89	void VBoxSDLFB::FinalRelease()
90	{
91	return;
92	}
93
94	/**
95	* SDL framebuffer constructor. It is called from the main
96	* (i.e. SDL) thread. Therefore it is safe to use SDL calls
97	* here.
98	* @param fFullscreen flag whether we start in fullscreen mode
99	* @param fResizable flag whether the SDL window should be resizable
100	* @param fShowSDLConfig flag whether we print out SDL settings
101	* @param fKeepHostRes flag whether we switch the host screen resolution
102	* when switching to fullscreen or not
103	* @param iFixedWidth fixed SDL width (-1 means not set)
104	* @param iFixedHeight fixed SDL height (-1 means not set)
105	*/
106	HRESULT VBoxSDLFB::init(uint32_t uScreenId,
107	bool fFullscreen, bool fResizable, bool fShowSDLConfig,
108	bool fKeepHostRes, uint32_t u32FixedWidth,
109	uint32_t u32FixedHeight, uint32_t u32FixedBPP,
110	bool fUpdateImage)
111	{
112	LogFlow(("VBoxSDLFB::VBoxSDLFB\n"));
113
114	mScreenId = uScreenId;
115	mfUpdateImage = fUpdateImage;
116	#ifdef VBOX_WITH_SDL2
117	mpWindow = NULL;
118	mpTexture = NULL;
119	mpRenderer = NULL;
120	#endif
121	mSurfVRAM = NULL;
122	mfInitialized = false;
123	mfFullscreen = fFullscreen;
124	mfKeepHostRes = fKeepHostRes;
125	mTopOffset = 0;
126	mfResizable = fResizable;
127	mfShowSDLConfig = fShowSDLConfig;
128	mFixedSDLWidth = u32FixedWidth;
129	mFixedSDLHeight = u32FixedHeight;
130	mFixedSDLBPP = u32FixedBPP;
131	mCenterXOffset = 0;
132	mCenterYOffset = 0;
133	/* Start with standard screen dimensions. */
134	mGuestXRes = 640;
135	mGuestYRes = 480;
136	mPtrVRAM = NULL;
137	mBitsPerPixel = 0;
138	mBytesPerLine = 0;
139	mfSameSizeRequested = false;
140	mfUpdates = false;
141
142	int rc = RTCritSectInit(&mUpdateLock);
143	AssertMsg(rc == VINF_SUCCESS, ("Error from RTCritSectInit!\n"));
144
145	resizeGuest();
146	mfInitialized = true;
147	#ifdef RT_OS_WINDOWS
148	HRESULT hr = CoCreateFreeThreadedMarshaler(this, m_pUnkMarshaler.asOutParam());
149	Log(("CoCreateFreeThreadedMarshaler hr %08X\n", hr)); NOREF(hr);
150	#endif
151
152	#ifdef VBOX_WITH_SDL2
153	rc = SDL_GetRendererInfo(mpRenderer, &mRenderInfo);
154	if (RT_SUCCESS(rc))
155	{
156	if (fShowSDLConfig)
157	RTPrintf("Render info:\n"
158	" Name: %s\n"
159	" Render flags: 0x%x\n"
160	" SDL video driver: %s\n",
161	mRenderInfo.name,
162	mRenderInfo.flags,
163	RTEnvGet("SDL_VIDEODRIVER"));
164	}
165	#endif
166
167	return rc;
168	}
169
170	VBoxSDLFB::~VBoxSDLFB()
171	{
172	LogFlow(("VBoxSDLFB::~VBoxSDLFB\n"));
173	if (mSurfVRAM)
174	{
175	SDL_FreeSurface(mSurfVRAM);
176	mSurfVRAM = NULL;
177	}
178	RTCritSectDelete(&mUpdateLock);
179	}
180
181	/* static */
182	bool VBoxSDLFB::init(bool fShowSDLConfig)
183	{
184	LogFlow(("VBoxSDLFB::init\n"));
185
186	/* memorize the thread that inited us, that's the SDL thread */
187	gSdlNativeThread = RTThreadNativeSelf();
188
189	#ifdef RT_OS_WINDOWS
190	/* default to DirectX if nothing else set */
191	if (!RTEnvExist("SDL_VIDEODRIVER"))
192	{
193	# ifndef VBOX_WITH_SDL2
194	/* Always select the windib driver by default, as the directx one is known to be broken on newer Windows OSes. */
195	RTEnvSet("SDL_VIDEODRIVER", "windib");
196	# else
197	RTEnvSet("SDL_VIDEODRIVER", "directx");
198	# endif
199	}
200	#endif
201	#ifdef VBOXSDL_WITH_X11
202	/* On some X servers the mouse is stuck inside the bottom right corner.
203	* See http://wiki.clug.org.za/wiki/QEMU_mouse_not_working */
204	RTEnvSet("SDL_VIDEO_X11_DGAMOUSE", "0");
205	#endif
206
207	int rc = SDL_InitSubSystem(SDL_INIT_VIDEO \| SDL_INIT_TIMER \| SDL_INIT_NOPARACHUTE);
208	if (rc != 0)
209	{
210	RTPrintf("SDL Error: '%s'\n", SDL_GetError());
211	return false;
212	}
213	gfSdlInitialized = true;
214
215	#ifdef VBOX_WITH_SDL2
216	RT_NOREF(fShowSDLConfig);
217	#endif /* !VBOX_WITH_SDL2 */
218
219	return true;
220	}
221
222	/**
223	* Terminate SDL
224	*
225	* @remarks must be called from the SDL thread!
226	*/
227	void VBoxSDLFB::uninit()
228	{
229	if (gfSdlInitialized)
230	{
231	AssertMsg(gSdlNativeThread == RTThreadNativeSelf(), ("Wrong thread! SDL is not threadsafe!\n"));
232	SDL_QuitSubSystem(SDL_INIT_VIDEO);
233	}
234	}
235
236	/**
237	* Returns the current framebuffer width in pixels.
238	*
239	* @returns COM status code
240	* @param width Address of result buffer.
241	*/
242	STDMETHODIMP VBoxSDLFB::COMGETTER(Width)(ULONG *width)
243	{
244	LogFlow(("VBoxSDLFB::GetWidth\n"));
245	if (!width)
246	return E_INVALIDARG;
247	*width = mGuestXRes;
248	return S_OK;
249	}
250
251	/**
252	* Returns the current framebuffer height in pixels.
253	*
254	* @returns COM status code
255	* @param height Address of result buffer.
256	*/
257	STDMETHODIMP VBoxSDLFB::COMGETTER(Height)(ULONG *height)
258	{
259	LogFlow(("VBoxSDLFB::GetHeight\n"));
260	if (!height)
261	return E_INVALIDARG;
262	*height = mGuestYRes;
263	return S_OK;
264	}
265
266	/**
267	* Return the current framebuffer color depth.
268	*
269	* @returns COM status code
270	* @param bitsPerPixel Address of result variable
271	*/
272	STDMETHODIMP VBoxSDLFB::COMGETTER(BitsPerPixel)(ULONG *bitsPerPixel)
273	{
274	LogFlow(("VBoxSDLFB::GetBitsPerPixel\n"));
275	if (!bitsPerPixel)
276	return E_INVALIDARG;
277	/* get the information directly from the surface in use */
278	Assert(mSurfVRAM);
279	*bitsPerPixel = (ULONG)(mSurfVRAM ? mSurfVRAM->format->BitsPerPixel : 0);
280	return S_OK;
281	}
282
283	/**
284	* Return the current framebuffer line size in bytes.
285	*
286	* @returns COM status code.
287	* @param lineSize Address of result variable.
288	*/
289	STDMETHODIMP VBoxSDLFB::COMGETTER(BytesPerLine)(ULONG *bytesPerLine)
290	{
291	LogFlow(("VBoxSDLFB::GetBytesPerLine\n"));
292	if (!bytesPerLine)
293	return E_INVALIDARG;
294	/* get the information directly from the surface */
295	Assert(mSurfVRAM);
296	*bytesPerLine = (ULONG)(mSurfVRAM ? mSurfVRAM->pitch : 0);
297	return S_OK;
298	}
299
300	STDMETHODIMP VBoxSDLFB::COMGETTER(PixelFormat) (BitmapFormat_T *pixelFormat)
301	{
302	if (!pixelFormat)
303	return E_POINTER;
304	*pixelFormat = BitmapFormat_BGR;
305	return S_OK;
306	}
307
308	/**
309	* Returns by how many pixels the guest should shrink its
310	* video mode height values.
311	*
312	* @returns COM status code.
313	* @param heightReduction Address of result variable.
314	*/
315	STDMETHODIMP VBoxSDLFB::COMGETTER(HeightReduction)(ULONG *heightReduction)
316	{
317	if (!heightReduction)
318	return E_POINTER;
319	*heightReduction = 0;
320	return S_OK;
321	}
322
323	/**
324	* Returns a pointer to an alpha-blended overlay used for displaying status
325	* icons above the framebuffer.
326	*
327	* @returns COM status code.
328	* @param aOverlay The overlay framebuffer.
329	*/
330	STDMETHODIMP VBoxSDLFB::COMGETTER(Overlay)(IFramebufferOverlay **aOverlay)
331	{
332	if (!aOverlay)
333	return E_POINTER;
334	/* Not yet implemented */
335	*aOverlay = 0;
336	return S_OK;
337	}
338
339	/**
340	* Returns handle of window where framebuffer context is being drawn
341	*
342	* @returns COM status code.
343	* @param winId Handle of associated window.
344	*/
345	STDMETHODIMP VBoxSDLFB::COMGETTER(WinId)(LONG64 *winId)
346	{
347	if (!winId)
348	return E_POINTER;
349	#ifdef RT_OS_DARWIN
350	if (mWinId == NULL) /* (In case it failed the first time.) */
351	mWinId = (intptr_t)VBoxSDLGetDarwinWindowId();
352	#endif
353	*winId = mWinId;
354	return S_OK;
355	}
356
357	STDMETHODIMP VBoxSDLFB::COMGETTER(Capabilities)(ComSafeArrayOut(FramebufferCapabilities_T, aCapabilities))
358	{
359	if (ComSafeArrayOutIsNull(aCapabilities))
360	return E_POINTER;
361
362	com::SafeArray<FramebufferCapabilities_T> caps;
363
364	if (mfUpdateImage)
365	{
366	caps.resize(2);
367	caps[0] = FramebufferCapabilities_UpdateImage;
368	caps[1] = FramebufferCapabilities_RenderCursor;
369	}
370	else
371	{
372	caps.resize(1);
373	caps[0] = FramebufferCapabilities_RenderCursor;
374	}
375
376	caps.detachTo(ComSafeArrayOutArg(aCapabilities));
377	return S_OK;
378	}
379
380	/**
381	* Notify framebuffer of an update.
382	*
383	* @returns COM status code
384	* @param x Update region upper left corner x value.
385	* @param y Update region upper left corner y value.
386	* @param w Update region width in pixels.
387	* @param h Update region height in pixels.
388	* @param finished Address of output flag whether the update
389	* could be fully processed in this call (which
390	* has to return immediately) or VBox should wait
391	* for a call to the update complete API before
392	* continuing with display updates.
393	*/
394	STDMETHODIMP VBoxSDLFB::NotifyUpdate(ULONG x, ULONG y,
395	ULONG w, ULONG h)
396	{
397	/*
398	* The input values are in guest screen coordinates.
399	*/
400	LogFlow(("VBoxSDLFB::NotifyUpdate: x = %d, y = %d, w = %d, h = %d\n",
401	x, y, w, h));
402
403	#ifdef VBOXSDL_WITH_X11
404	/*
405	* SDL does not allow us to make this call from any other thread than
406	* the main SDL thread (which initialized the video mode). So we have
407	* to send an event to the main SDL thread and process it there. For
408	* sake of simplicity, we encode all information in the event parameters.
409	*/
410	SDL_Event event;
411	event.type = SDL_USEREVENT;
412	event.user.code = mScreenId;
413	event.user.type = SDL_USER_EVENT_UPDATERECT;
414	// 16 bit is enough for coordinates
415	event.user.data1 = (void*)(uintptr_t)(x << 16 \| y);
416	event.user.data2 = (void*)(uintptr_t)(w << 16 \| h);
417	PushNotifyUpdateEvent(&event);
418	#else /* !VBOXSDL_WITH_X11 */
419	update(x, y, w, h, true /* fGuestRelative */);
420	#endif /* !VBOXSDL_WITH_X11 */
421
422	return S_OK;
423	}
424
425	STDMETHODIMP VBoxSDLFB::NotifyUpdateImage(ULONG aX,
426	ULONG aY,
427	ULONG aWidth,
428	ULONG aHeight,
429	ComSafeArrayIn(BYTE, aImage))
430	{
431	LogFlow(("NotifyUpdateImage: %d,%d %dx%d\n", aX, aY, aWidth, aHeight));
432
433	com::SafeArray<BYTE> image(ComSafeArrayInArg(aImage));
434
435	/* Copy to mSurfVRAM. */
436	SDL_Rect srcRect;
437	SDL_Rect dstRect;
438	srcRect.x = 0;
439	srcRect.y = 0;
440	srcRect.w = (uint16_t)aWidth;
441	srcRect.h = (uint16_t)aHeight;
442	dstRect.x = (int16_t)aX;
443	dstRect.y = (int16_t)aY;
444	dstRect.w = (uint16_t)aWidth;
445	dstRect.h = (uint16_t)aHeight;
446
447	const uint32_t Rmask = 0x00FF0000, Gmask = 0x0000FF00, Bmask = 0x000000FF, Amask = 0;
448	SDL_Surface surfSrc = SDL_CreateRGBSurfaceFrom(image.raw(), aWidth, aHeight, 32, aWidth 4,
449	Rmask, Gmask, Bmask, Amask);
450	if (surfSrc)
451	{
452	RTCritSectEnter(&mUpdateLock);
453	if (mfUpdates)
454	SDL_BlitSurface(surfSrc, &srcRect, mSurfVRAM, &dstRect);
455	RTCritSectLeave(&mUpdateLock);
456
457	SDL_FreeSurface(surfSrc);
458	}
459
460	return NotifyUpdate(aX, aY, aWidth, aHeight);
461	}
462
463	extern ComPtr<IDisplay> gpDisplay;
464
465	STDMETHODIMP VBoxSDLFB::NotifyChange(ULONG aScreenId,
466	ULONG aXOrigin,
467	ULONG aYOrigin,
468	ULONG aWidth,
469	ULONG aHeight)
470	{
471	LogRel(("NotifyChange: %d %d,%d %dx%d\n",
472	aScreenId, aXOrigin, aYOrigin, aWidth, aHeight));
473
474	ComPtr<IDisplaySourceBitmap> pSourceBitmap;
475	if (!mfUpdateImage)
476	gpDisplay->QuerySourceBitmap(aScreenId, pSourceBitmap.asOutParam());
477
478	RTCritSectEnter(&mUpdateLock);
479
480	/* Disable screen updates. */
481	mfUpdates = false;
482
483	if (mfUpdateImage)
484	{
485	mGuestXRes = aWidth;
486	mGuestYRes = aHeight;
487	mPtrVRAM = NULL;
488	mBitsPerPixel = 0;
489	mBytesPerLine = 0;
490	}
491	else
492	{
493	/* Save the new bitmap. */
494	mpPendingSourceBitmap = pSourceBitmap;
495	}
496
497	RTCritSectLeave(&mUpdateLock);
498
499	SDL_Event event;
500	event.type = SDL_USEREVENT;
501	event.user.type = SDL_USER_EVENT_NOTIFYCHANGE;
502	event.user.code = mScreenId;
503
504	PushSDLEventForSure(&event);
505
506	RTThreadYield();
507
508	return S_OK;
509	}
510
511	/**
512	* Returns whether we like the given video mode.
513	*
514	* @returns COM status code
515	* @param width video mode width in pixels
516	* @param height video mode height in pixels
517	* @param bpp video mode bit depth in bits per pixel
518	* @param supported pointer to result variable
519	*/
520	STDMETHODIMP VBoxSDLFB::VideoModeSupported(ULONG width, ULONG height, ULONG bpp, BOOL *supported)
521	{
522	RT_NOREF(bpp);
523
524	if (!supported)
525	return E_POINTER;
526
527	/* are constraints set? */
528	if ( ( (mMaxScreenWidth != ~(uint32_t)0)
529	&& (width > mMaxScreenWidth))
530	\|\| ( (mMaxScreenHeight != ~(uint32_t)0)
531	&& (height > mMaxScreenHeight)))
532	{
533	/* nope, we don't want that (but still don't freak out if it is set) */
534	#ifdef DEBUG
535	RTPrintf("VBoxSDL::VideoModeSupported: we refused mode %dx%dx%d\n", width, height, bpp);
536	#endif
537	*supported = false;
538	}
539	else
540	{
541	/* anything will do */
542	*supported = true;
543	}
544	return S_OK;
545	}
546
547	STDMETHODIMP VBoxSDLFB::GetVisibleRegion(BYTE *aRectangles, ULONG aCount,
548	ULONG *aCountCopied)
549	{
550	PRTRECT rects = (PRTRECT)aRectangles;
551
552	if (!rects)
553	return E_POINTER;
554
555	/// @todo
556
557	NOREF(aCount);
558	NOREF(aCountCopied);
559
560	return S_OK;
561	}
562
563	STDMETHODIMP VBoxSDLFB::SetVisibleRegion(BYTE *aRectangles, ULONG aCount)
564	{
565	PRTRECT rects = (PRTRECT)aRectangles;
566
567	if (!rects)
568	return E_POINTER;
569
570	/// @todo
571
572	NOREF(aCount);
573
574	return S_OK;
575	}
576
577	STDMETHODIMP VBoxSDLFB::ProcessVHWACommand(BYTE *pCommand, LONG enmCmd, BOOL fGuestCmd)
578	{
579	RT_NOREF(pCommand, enmCmd, fGuestCmd);
580	return E_NOTIMPL;
581	}
582
583	STDMETHODIMP VBoxSDLFB::Notify3DEvent(ULONG uType, ComSafeArrayIn(BYTE, aData))
584	{
585	RT_NOREF(uType); ComSafeArrayNoRef(aData);
586	return E_NOTIMPL;
587	}
588
589	//
590	// Internal public methods
591	//
592
593	/* This method runs on the main SDL thread. */
594	void VBoxSDLFB::notifyChange(ULONG aScreenId)
595	{
596	/* Disable screen updates. */
597	RTCritSectEnter(&mUpdateLock);
598
599	if (!mfUpdateImage && mpPendingSourceBitmap.isNull())
600	{
601	/* Do nothing. Change event already processed. */
602	RTCritSectLeave(&mUpdateLock);
603	return;
604	}
605
606	/* Release the current bitmap and keep the pending one. */
607	mpSourceBitmap = mpPendingSourceBitmap;
608	mpPendingSourceBitmap.setNull();
609
610	RTCritSectLeave(&mUpdateLock);
611
612	if (mpSourceBitmap.isNull())
613	{
614	mPtrVRAM = NULL;
615	mBitsPerPixel = 32;
616	mBytesPerLine = mGuestXRes * 4;
617	}
618	else
619	{
620	BYTE *pAddress = NULL;
621	ULONG ulWidth = 0;
622	ULONG ulHeight = 0;
623	ULONG ulBitsPerPixel = 0;
624	ULONG ulBytesPerLine = 0;
625	BitmapFormat_T bitmapFormat = BitmapFormat_Opaque;
626
627	mpSourceBitmap->QueryBitmapInfo(&pAddress,
628	&ulWidth,
629	&ulHeight,
630	&ulBitsPerPixel,
631	&ulBytesPerLine,
632	&bitmapFormat);
633
634	if ( mGuestXRes == ulWidth
635	&& mGuestYRes == ulHeight
636	&& mBitsPerPixel == ulBitsPerPixel
637	&& mBytesPerLine == ulBytesPerLine
638	&& mPtrVRAM == pAddress
639	)
640	{
641	mfSameSizeRequested = true;
642	}
643	else
644	{
645	mfSameSizeRequested = false;
646	}
647
648	mGuestXRes = ulWidth;
649	mGuestYRes = ulHeight;
650	mPtrVRAM = pAddress;
651	mBitsPerPixel = ulBitsPerPixel;
652	mBytesPerLine = ulBytesPerLine;
653	}
654
655	resizeGuest();
656
657	gpDisplay->InvalidateAndUpdateScreen(aScreenId);
658	}
659
660	/**
661	* Method that does the actual resize of the guest framebuffer and
662	* then changes the SDL framebuffer setup.
663	*/
664	void VBoxSDLFB::resizeGuest()
665	{
666	LogFlowFunc (("mGuestXRes: %d, mGuestYRes: %d\n", mGuestXRes, mGuestYRes));
667	AssertMsg(gSdlNativeThread == RTThreadNativeSelf(),
668	("Wrong thread! SDL is not threadsafe!\n"));
669
670	RTCritSectEnter(&mUpdateLock);
671
672	const uint32_t Rmask = 0x00FF0000, Gmask = 0x0000FF00, Bmask = 0x000000FF, Amask = 0;
673
674	/* first free the current surface */
675	if (mSurfVRAM)
676	{
677	SDL_FreeSurface(mSurfVRAM);
678	mSurfVRAM = NULL;
679	}
680
681	if (mPtrVRAM)
682	{
683	/* Create a source surface from the source bitmap. */
684	mSurfVRAM = SDL_CreateRGBSurfaceFrom(mPtrVRAM, mGuestXRes, mGuestYRes, mBitsPerPixel,
685	mBytesPerLine, Rmask, Gmask, Bmask, Amask);
686	LogFlow(("VBoxSDL:: using the source bitmap\n"));
687	}
688	else
689	{
690	mSurfVRAM = SDL_CreateRGBSurface(SDL_SWSURFACE, mGuestXRes, mGuestYRes, 32,
691	Rmask, Gmask, Bmask, Amask);
692	LogFlow(("VBoxSDL:: using SDL_SWSURFACE\n"));
693	}
694	LogFlow(("VBoxSDL:: created VRAM surface %p\n", mSurfVRAM));
695
696	if (mfSameSizeRequested)
697	{
698	mfSameSizeRequested = false;
699	LogFlow(("VBoxSDL:: the same resolution requested, skipping the resize.\n"));
700	}
701	else
702	{
703	/* now adjust the SDL resolution */
704	resizeSDL();
705	}
706
707	/* Enable screen updates. */
708	mfUpdates = true;
709
710	RTCritSectLeave(&mUpdateLock);
711
712	repaint();
713	}
714
715	/**
716	* Sets SDL video mode. This is independent from guest video
717	* mode changes.
718	*
719	* @remarks Must be called from the SDL thread!
720	*/
721	void VBoxSDLFB::resizeSDL(void)
722	{
723	LogFlow(("VBoxSDL:resizeSDL\n"));
724
725	#ifdef VBOX_WITH_SDL2
726	const int cDisplays = SDL_GetNumVideoDisplays();
727	if (cDisplays > 0)
728	{
729	for (int d = 0; d < cDisplays; d++)
730	{
731	const int cDisplayModes = SDL_GetNumDisplayModes(d);
732	for (int m = 0; m < cDisplayModes; m++)
733	{
734	SDL_DisplayMode mode = { SDL_PIXELFORMAT_UNKNOWN, 0, 0, 0, 0 };
735	if (SDL_GetDisplayMode(d, m, &mode) != 0)
736	{
737	RTPrintf("Display #%d, mode %d:\t\t%i bpp\t%i x %i",
738	SDL_BITSPERPIXEL(mode.format), mode.w, mode.h);
739	}
740
741	if (m == 0)
742	{
743	/*
744	* according to the SDL documentation, the API guarantees that
745	* the modes are sorted from larger to smaller, so we just
746	* take the first entry as the maximum.
747	*/
748	mMaxScreenWidth = mode.w;
749	mMaxScreenHeight = mode.h;
750	}
751
752	/* Keep going. */
753	}
754	}
755	}
756	else
757	AssertFailed(); /** @todo */
758	#endif /* VBOX_WITH_SDL2 */
759
760	uint32_t newWidth;
761	uint32_t newHeight;
762
763	/* reset the centering offsets */
764	mCenterXOffset = 0;
765	mCenterYOffset = 0;
766
767	/* we either have a fixed SDL resolution or we take the guest's */
768	if (mFixedSDLWidth != ~(uint32_t)0)
769	{
770	newWidth = mFixedSDLWidth;
771	newHeight = mFixedSDLHeight;
772	}
773	else
774	{
775	newWidth = RT_MIN(mGuestXRes, mMaxScreenWidth);
776	newHeight = RT_MIN(mGuestYRes, mMaxScreenHeight);
777	}
778
779	/* we don't have any extra space by default */
780	mTopOffset = 0;
781
782	#ifdef VBOX_WITH_SDL2
783	int sdlWindowFlags = SDL_WINDOW_SHOWN;
784	if (mfResizable)
785	sdlWindowFlags \|= SDL_WINDOW_RESIZABLE;
786	if (!mpWindow)
787	{
788	SDL_DisplayMode desktop_mode;
789	int x = 40 + mScreenId * 20;
790	int y = 40 + mScreenId * 15;
791
792	SDL_GetDesktopDisplayMode(mScreenId, &desktop_mode);
793	/* create new window */
794
795	char szTitle[64];
796	RTStrPrintf(szTitle, sizeof(szTitle), "SDL window %d", mScreenId);
797	mpWindow = SDL_CreateWindow(szTitle, x, y,
798	newWidth, newHeight, sdlWindowFlags);
799	mpRenderer = SDL_CreateRenderer(mpWindow, -1, 0 /* SDL_RendererFlags */);
800	if (mpRenderer)
801	{
802	SDL_GetRendererInfo(mpRenderer, &mRenderInfo);
803
804	mpTexture = SDL_CreateTexture(mpRenderer, desktop_mode.format,
805	SDL_TEXTUREACCESS_STREAMING, newWidth, newHeight);
806	if (!mpTexture)
807	AssertReleaseFailed();
808	}
809	else
810	AssertReleaseFailed();
811
812	if (12320 == g_cbIco64x01)
813	{
814	gWMIcon = SDL_CreateRGBSurface(0 /* Flags, must be 0 */, 64, 64, 24, 0xff, 0xff00, 0xff0000, 0);
815	/** @todo make it as simple as possible. No PNM interpreter here... */
816	if (gWMIcon)
817	{
818	memcpy(gWMIcon->pixels, g_abIco64x01+32, g_cbIco64x01-32);
819	SDL_SetWindowIcon(mpWindow, gWMIcon);
820	}
821	}
822	}
823	else
824	{
825	int w, h;
826	uint32_t format;
827	int access;
828
829	/* resize current window */
830	SDL_GetWindowSize(mpWindow, &w, &h);
831
832	if (w != (int)newWidth \|\| h != (int)newHeight)
833	SDL_SetWindowSize(mpWindow, newWidth, newHeight);
834
835	SDL_QueryTexture(mpTexture, &format, &access, &w, &h);
836	SDL_DestroyTexture(mpTexture);
837	mpTexture = SDL_CreateTexture(mpRenderer, format, access, newWidth, newHeight);
838	if (!mpTexture)
839	AssertReleaseFailed();
840	}
841	#endif /* VBOX_WITH_SDL2 */
842	}
843
844	/**
845	* Update specified framebuffer area. The coordinates can either be
846	* relative to the guest framebuffer or relative to the screen.
847	*
848	* @remarks Must be called from the SDL thread on Linux!
849	* @param x left column
850	* @param y top row
851	* @param w width in pixels
852	* @param h height in pixels
853	* @param fGuestRelative flag whether the above values are guest relative or screen relative;
854	*/
855	void VBoxSDLFB::update(int x, int y, int w, int h, bool fGuestRelative)
856	{
857	#ifdef VBOXSDL_WITH_X11
858	AssertMsg(gSdlNativeThread == RTThreadNativeSelf(), ("Wrong thread! SDL is not threadsafe!\n"));
859	#endif
860	RTCritSectEnter(&mUpdateLock);
861	Log(("Updates %d, %d,%d %dx%d\n", mfUpdates, x, y, w, h));
862	// printf("Updates %d, %d,%d %dx%d\n", mfUpdates, x, y, w, h);
863	if (!mfUpdates)
864	{
865	RTCritSectLeave(&mUpdateLock);
866	return;
867	}
868
869	Assert(mSurfVRAM);
870	if (!mSurfVRAM)
871	{
872	RTCritSectLeave(&mUpdateLock);
873	return;
874	}
875
876	/* the source and destination rectangles */
877	SDL_Rect srcRect;
878	SDL_Rect dstRect;
879
880	/* this is how many pixels we have to cut off from the height for this specific blit */
881	int yCutoffGuest = 0;
882	/**
883	* If we get a SDL window relative update, we
884	* just perform a full screen update to keep things simple.
885	*
886	* @todo improve
887	*/
888	if (!fGuestRelative)
889	{
890	x = 0;
891	w = mGuestXRes;
892	y = 0;
893	h = mGuestYRes;
894	}
895
896	srcRect.x = x;
897	srcRect.y = y + yCutoffGuest;
898	srcRect.w = w;
899	srcRect.h = RT_MAX(0, h - yCutoffGuest);
900
901	/*
902	* Destination rectangle is just offset by the label height.
903	* There are two cases though: label height is added to the
904	* guest resolution (mTopOffset == mLabelHeight; yCutoffGuest == 0)
905	* or the label cuts off a portion of the guest screen (mTopOffset == 0;
906	* yCutoffGuest >= 0)
907	*/
908	dstRect.x = x + mCenterXOffset;
909	dstRect.y = y + yCutoffGuest + mTopOffset + mCenterYOffset;
910	dstRect.w = w;
911	dstRect.h = RT_MAX(0, h - yCutoffGuest);
912
913
914	/* hardware surfaces don't need update notifications */
915	#if defined(VBOX_WITH_SDL2)
916	SDL_Texture *pNewTexture = SDL_CreateTextureFromSurface(mpRenderer, mSurfVRAM);
917	/** @todo Do we need to update the dirty rect for the texture for SDL2 here as well? */
918	// SDL_RenderClear(mpRenderer);
919	//SDL_UpdateTexture(mpTexture, &dstRect, mSurfVRAM->pixels, mSurfVRAM->pitch);
920	// SDL_RenderCopy(mpRenderer, mpTexture, NULL, NULL);
921	SDL_RenderCopy(mpRenderer, pNewTexture, &srcRect, &dstRect);
922	SDL_RenderPresent(mpRenderer);
923	SDL_DestroyTexture(pNewTexture);
924	#endif
925	RTCritSectLeave(&mUpdateLock);
926	}
927
928	/**
929	* Repaint the whole framebuffer
930	*
931	* @remarks Must be called from the SDL thread!
932	*/
933	void VBoxSDLFB::repaint()
934	{
935	AssertMsg(gSdlNativeThread == RTThreadNativeSelf(), ("Wrong thread! SDL is not threadsafe!\n"));
936	LogFlow(("VBoxSDLFB::repaint\n"));
937	int w, h;
938	uint32_t format;
939	int access;
940	SDL_QueryTexture(mpTexture, &format, &access, &w, &h);
941	update(0, 0, w, h, false /* fGuestRelative */);
942	}
943
944	/**
945	* Toggle fullscreen mode
946	*
947	* @remarks Must be called from the SDL thread!
948	*/
949	void VBoxSDLFB::setFullscreen(bool fFullscreen)
950	{
951	AssertMsg(gSdlNativeThread == RTThreadNativeSelf(), ("Wrong thread! SDL is not threadsafe!\n"));
952	LogFlow(("VBoxSDLFB::SetFullscreen: fullscreen: %d\n", fFullscreen));
953	mfFullscreen = fFullscreen;
954	/* only change the SDL resolution, do not touch the guest framebuffer */
955	resizeSDL();
956	repaint();
957	}
958
959	/**
960	* Return the geometry of the host. This isn't very well tested but it seems
961	* to work at least on Linux hosts.
962	*/
963	void VBoxSDLFB::getFullscreenGeometry(uint32_t width, uint32_t height)
964	{
965	#ifdef VBOX_WITH_SDL2
966	SDL_DisplayMode dm;
967	int rc = SDL_GetDesktopDisplayMode(0, &dm); /** @BUGBUG Handle multi monitor setups! */
968	if (rc == 0)
969	{
970	*width = dm.w;
971	*height = dm.w;
972	}
973	#endif
974	}
975
976	#ifdef VBOX_WITH_SDL2
977	int VBoxSDLFB::setWindowTitle(const char *pcszTitle)
978	{
979	SDL_SetWindowTitle(mpWindow, pcszTitle);
980
981	return VINF_SUCCESS;
982	}
983	#endif

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

source: vbox/trunk/src/VBox/Frontends/VBoxSDL/Framebuffer.cpp@ 98302

Download in other formats: