ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/cebix/BasiliskII/src/SDL/video_sdl.cpp

Comparing BasiliskII/src/SDL/video_sdl.cpp (file contents):
Revision 1.24 by gbeauche, 2006-05-09T21:41:02Z vs.
Revision 1.36 by asvitkine, 2008-06-25T02:52:52Z

#	Line 1 | Line 1
1		/*
2		*  video_sdl.cpp - Video/graphics emulation, SDL specific stuff
3		*
4	<	*  Basilisk II (C) 1997-2005 Christian Bauer
4	>	*  Basilisk II (C) 1997-2008 Christian Bauer
5		*
6		*  This program is free software; you can redistribute it and/or modify
7		*  it under the terms of the GNU General Public License as published by
#	Line 27 | Line 27
27		*      Ctrl-F5 = grab mouse (in windowed mode)
28		*
29		*  FIXMEs and TODOs:
30	+	*  - Windows requires an extra mouse event to update the actual cursor image?
31		*  - Ctr-Tab for suspend/resume but how? SDL does not support that for non-Linux
32		*  - Ctrl-Fn doesn't generate SDL_KEYDOWN events (SDL bug?)
33		*  - Mouse acceleration, there is no API in SDL yet for that
34		*  - Force relative mode in Grab mode even if SDL provides absolute coordinates?
34	–	*  - Fullscreen mode
35		*  - Gamma tables support is likely to be broken here
36		*  - Events processing is bound to the general emulation thread as SDL requires
37		*    to PumpEvents() within the same thread as the one that called SetVideoMode().
38		*    Besides, there can't seem to be a way to call SetVideoMode() from a child thread.
39	–	*  - Refresh performance is still slow. Use SDL_CreateRGBSurface()?
39		*  - Backport hw cursor acceleration to Basilisk II?
40		*  - Factor out code
41		*/
#	Line 49 | Line 48
48		#include <errno.h>
49		#include <vector>
50
51	+	#ifdef WIN32
52	+	#include <malloc.h> /* alloca() */
53	+	#endif
54	+
55		#include "cpu_emulation.h"
56		#include "main.h"
57		#include "adb.h"
#	Line 133 | Line 136 | static SDL_Cursor *sdl_cursor;                                         // C
136		static volatile bool cursor_changed = false;            // Flag: cursor changed, redraw_func must update the cursor
137		static SDL_Color sdl_palette[256];                                      // Color palette to be used as CLUT and gamma table
138		static bool sdl_palette_changed = false;                        // Flag: Palette changed, redraw thread must set new colors
139	<	static const int sdl_eventmask = SDL_MOUSEBUTTONDOWNMASK | SDL_MOUSEBUTTONUPMASK | SDL_MOUSEMOTIONMASK | SDL_KEYUPMASK | SDL_KEYDOWNMASK | SDL_VIDEOEXPOSEMASK | SDL_QUITMASK;
139	>	static const int sdl_eventmask = SDL_MOUSEEVENTMASK | SDL_KEYEVENTMASK | SDL_VIDEOEXPOSEMASK | SDL_QUITMASK | SDL_ACTIVEEVENTMASK;
140
141		// Mutex to protect SDL events
142		static SDL_mutex *sdl_events_lock = NULL;
#	Line 194 | Line 197 | extern void SysMountFirstFloppy(void);
197
198		static void *vm_acquire_framebuffer(uint32 size)
199		{
200	<	return vm_acquire(size);
200	>	// always try to reallocate framebuffer at the same address
201	>	static void *fb = VM_MAP_FAILED;
202	>	if (fb != VM_MAP_FAILED) {
203	>	if (vm_acquire_fixed(fb, size) < 0) {
204	>	#ifndef SHEEPSHAVER
205	>	printf("FATAL: Could not reallocate framebuffer at previous address\n");
206	>	#endif
207	>	fb = VM_MAP_FAILED;
208	>	}
209	>	}
210	>	if (fb == VM_MAP_FAILED)
211	>	fb = vm_acquire(size, VM_MAP_DEFAULT | VM_MAP_32BIT);
212	>	return fb;
213		}
214
215		static inline void vm_release_framebuffer(void *fb, uint32 size)
#	Line 716 | Line 731 | void driver_base::restore_mouse_accel(vo
731		*  Windowed display driver
732		*/
733
734	+	static bool SDL_display_opened = false;
735	+
736		// Open display
737		driver_window::driver_window(SDL_monitor_desc &m)
738		: driver_base(m), mouse_grabbed(false)
#	Line 727 | Line 744 | driver_window::driver_window(SDL_monitor
744		// Set absolute mouse mode
745		ADBSetRelMouseMode(mouse_grabbed);
746
747	+	// This is ugly:
748	+	// If we're switching resolutions (ie, not setting it for the first time),
749	+	// there's a bug in SDL where the SDL_Surface created will not be properly
750	+	// setup. The solution is to SDL_QuitSubSystem(SDL_INIT_VIDEO) before calling
751	+	// SDL_SetVideoMode for the second time (SDL_SetVideoMode will call SDL_Init()
752	+	// and all will be well). Without this, the video becomes corrupted (at least
753	+	// on Mac OS X), after the resolution switch.
754	+	if (SDL_display_opened)
755	+	SDL_QuitSubSystem(SDL_INIT_VIDEO);
756	+
757		// Create surface
758		int depth = sdl_depth_of_video_depth(VIDEO_MODE_DEPTH);
759		if ((s = SDL_SetVideoMode(width, height, depth, SDL_HWSURFACE)) == NULL)
760		return;
761
762	+	SDL_display_opened = true;
763	+
764		#ifdef ENABLE_VOSF
765		use_vosf = true;
766		// Allocate memory for frame buffer (SIZE is extended to page-boundary)
#	Line 1514 | Line 1543 | void SDL_monitor_desc::switch_to_current
1543		#ifdef SHEEPSHAVER
1544		bool video_can_change_cursor(void)
1545		{
1546	<	return (display_type == DISPLAY_WINDOW);
1546	>	static char driver[] = "Quartz?";
1547	>	static int quartzok = -1;
1548	>
1549	>	if (display_type != DISPLAY_WINDOW)
1550	>	return false;
1551	>
1552	>	if (quartzok < 0) {
1553	>	if (SDL_VideoDriverName(driver, sizeof driver) == NULL || strncmp(driver, "Quartz", sizeof driver))
1554	>	quartzok = true;
1555	>	else {
1556	>	// Quartz driver bug prevents cursor changing in SDL 1.2.11 and later
1557	>	const SDL_version *vp = SDL_Linked_Version();
1558	>	quartzok = SDL_VERSIONNUM(vp->major, vp->minor, vp->patch) <= SDL_VERSIONNUM(1, 2, 10);
1559	>	}
1560	>	}
1561	>
1562	>	return quartzok;
1563		}
1564		#endif
1565
#	Line 1829 | Line 1874 | static void handle_events(void)
1874		ADBKeyDown(0x7f);       // Power key
1875		ADBKeyUp(0x7f);
1876		break;
1877	+
1878	+	// Application activate/deactivate; consume the event but otherwise ignore it
1879	+	case SDL_ACTIVEEVENT:
1880	+	break;
1881		}
1882		}
1883		}
#	Line 1984 | Line 2033 | static void update_display_static(driver
2033		}
2034		}
2035
2036	+	// Static display update (fixed frame rate, bounding boxes based)
2037	+	// XXX use NQD bounding boxes to help detect dirty areas?
2038	+	static void update_display_static_bbox(driver_window *drv)
2039	+	{
2040	+	const VIDEO_MODE &mode = drv->mode;
2041	+
2042	+	// Allocate bounding boxes for SDL_UpdateRects()
2043	+	const int N_PIXELS = 64;
2044	+	const int n_x_boxes = (VIDEO_MODE_X + N_PIXELS - 1) / N_PIXELS;
2045	+	const int n_y_boxes = (VIDEO_MODE_Y + N_PIXELS - 1) / N_PIXELS;
2046	+	SDL_Rect *boxes = (SDL_Rect *)alloca(sizeof(SDL_Rect) * n_x_boxes * n_y_boxes);
2047	+	int nr_boxes = 0;
2048	+
2049	+	// Lock surface, if required
2050	+	if (SDL_MUSTLOCK(drv->s))
2051	+	SDL_LockSurface(drv->s);
2052	+
2053	+	// Update the surface from Mac screen
2054	+	const int bytes_per_row = VIDEO_MODE_ROW_BYTES;
2055	+	const int bytes_per_pixel = bytes_per_row / VIDEO_MODE_X;
2056	+	int x, y;
2057	+	for (y = 0; y < VIDEO_MODE_Y; y += N_PIXELS) {
2058	+	int h = N_PIXELS;
2059	+	if (h > VIDEO_MODE_Y - y)
2060	+	h = VIDEO_MODE_Y - y;
2061	+	for (x = 0; x < VIDEO_MODE_X; x += N_PIXELS) {
2062	+	int w = N_PIXELS;
2063	+	if (w > VIDEO_MODE_X - x)
2064	+	w = VIDEO_MODE_X - x;
2065	+	const int xs = w * bytes_per_pixel;
2066	+	const int xb = x * bytes_per_pixel;
2067	+	bool dirty = false;
2068	+	for (int j = y; j < (y + h); j++) {
2069	+	const int yb = j * bytes_per_row;
2070	+	if (memcmp(&the_buffer[yb + xb], &the_buffer_copy[yb + xb], xs) != 0) {
2071	+	memcpy(&the_buffer_copy[yb + xb], &the_buffer[yb + xb], xs);
2072	+	Screen_blit((uint8 *)drv->s->pixels + yb + xb, the_buffer + yb + xb, xs);
2073	+	dirty = true;
2074	+	}
2075	+	}
2076	+	if (dirty) {
2077	+	boxes[nr_boxes].x = x;
2078	+	boxes[nr_boxes].y = y;
2079	+	boxes[nr_boxes].w = w;
2080	+	boxes[nr_boxes].h = h;
2081	+	nr_boxes++;
2082	+	}
2083	+	}
2084	+	}
2085	+
2086	+	// Unlock surface, if required
2087	+	if (SDL_MUSTLOCK(drv->s))
2088	+	SDL_UnlockSurface(drv->s);
2089	+
2090	+	// Refresh display
2091	+	if (nr_boxes)
2092	+	SDL_UpdateRects(drv->s, nr_boxes, boxes);
2093	+	}
2094	+
2095
2096		// We suggest the compiler to inline the next two functions so that it
2097		// may specialise the code according to the current screen depth and
#	Line 2078 | Line 2186 | static void video_refresh_window_static(
2186		static int tick_counter = 0;
2187		if (++tick_counter >= frame_skip) {
2188		tick_counter = 0;
2189	<	update_display_static(static_cast<driver_window *>(drv));
2189	>	const VIDEO_MODE &mode = drv->mode;
2190	>	if ((int)VIDEO_MODE_DEPTH >= VIDEO_DEPTH_8BIT)
2191	>	update_display_static_bbox(static_cast<driver_window *>(drv));
2192	>	else
2193	>	update_display_static(static_cast<driver_window *>(drv));
2194		}
2195		}
2196
#	Line 2123 | Line 2235 | static inline void do_video_refresh(void
2235		LOCK_EVENTS;
2236		SDL_FreeCursor(sdl_cursor);
2237		sdl_cursor = SDL_CreateCursor(MacCursor + 4, MacCursor + 36, 16, 16, MacCursor[2], MacCursor[3]);
2238	<	if (sdl_cursor)
2238	>	if (sdl_cursor) {
2239	>	SDL_ShowCursor(private_data == NULL || private_data->cursorVisible);
2240		SDL_SetCursor(sdl_cursor);
2241	+	#ifdef WIN32
2242	+	// XXX Windows apparently needs an extra mouse event to
2243	+	// make the new cursor image visible
2244	+	int visible = SDL_ShowCursor(-1);
2245	+	if (visible) {
2246	+	int x, y;
2247	+	SDL_GetMouseState(&x, &y);
2248	+	SDL_WarpMouse(x, y);
2249	+	}
2250	+	#endif
2251	+	}
2252		UNLOCK_EVENTS;
2253		}
2254		#endif
#	Line 2183 | Line 2307 | static int redraw_func(void *arg)
2307		return 0;
2308		}
2309		#endif
2310	+
2311	+
2312	+	/*
2313	+	*  Record dirty area from NQD
2314	+	*/
2315	+
2316	+	#ifdef SHEEPSHAVER
2317	+	void video_set_dirty_area(int x, int y, int w, int h)
2318	+	{
2319	+	const VIDEO_MODE &mode = drv->mode;
2320	+	const int screen_width = VIDEO_MODE_X;
2321	+	const int screen_height = VIDEO_MODE_Y;
2322	+	const int bytes_per_row = VIDEO_MODE_ROW_BYTES;
2323	+
2324	+	#ifdef ENABLE_VOSF
2325	+	if (use_vosf) {
2326	+	vosf_set_dirty_area(x, y, w, h, screen_width, screen_height, bytes_per_row);
2327	+	return;
2328	+	}
2329	+	#endif
2330	+
2331	+	// XXX handle dirty bounding boxes for non-VOSF modes
2332	+	}
2333	+	#endif

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines