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.27 by gbeauche, 2006-05-14T08:32:05Z vs.
Revision 1.43 by asvitkine, 2011-12-29T07:38:34Z

#	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 60 | Line 63
63		#include "video_blit.h"
64		#include "vm_alloc.h"
65
66	+	#if (defined(__APPLE__) && defined(__MACH__))
67	+	#include "utils_macosx.h"
68	+	#endif
69	+
70		#define DEBUG 0
71		#include "debug.h"
72
66	–
73		// Supported video modes
74		using std::vector;
75		static vector<VIDEO_MODE> VideoModes;
#	Line 133 | Line 139 | static SDL_Cursor *sdl_cursor;                                         // C
139		static volatile bool cursor_changed = false;            // Flag: cursor changed, redraw_func must update the cursor
140		static SDL_Color sdl_palette[256];                                      // Color palette to be used as CLUT and gamma table
141		static bool sdl_palette_changed = false;                        // Flag: Palette changed, redraw thread must set new colors
142	<	static const int sdl_eventmask = SDL_MOUSEBUTTONDOWNMASK | SDL_MOUSEBUTTONUPMASK | SDL_MOUSEMOTIONMASK | SDL_KEYUPMASK | SDL_KEYDOWNMASK | SDL_VIDEOEXPOSEMASK | SDL_QUITMASK;
142	>	static const int sdl_eventmask = SDL_MOUSEEVENTMASK | SDL_KEYEVENTMASK | SDL_VIDEOEXPOSEMASK | SDL_QUITMASK | SDL_ACTIVEEVENTMASK;
143
144		// Mutex to protect SDL events
145		static SDL_mutex *sdl_events_lock = NULL;
#	Line 194 | Line 200 | extern void SysMountFirstFloppy(void);
200
201		static void *vm_acquire_framebuffer(uint32 size)
202		{
203	<	return vm_acquire(size);
203	>	// always try to reallocate framebuffer at the same address
204	>	static void *fb = VM_MAP_FAILED;
205	>	if (fb != VM_MAP_FAILED) {
206	>	if (vm_acquire_fixed(fb, size) < 0) {
207	>	#ifndef SHEEPSHAVER
208	>	printf("FATAL: Could not reallocate framebuffer at previous address\n");
209	>	#endif
210	>	fb = VM_MAP_FAILED;
211	>	}
212	>	}
213	>	if (fb == VM_MAP_FAILED)
214	>	fb = vm_acquire(size, VM_MAP_DEFAULT | VM_MAP_32BIT);
215	>	return fb;
216		}
217
218		static inline void vm_release_framebuffer(void *fb, uint32 size)
#	Line 610 | Line 628 | public:
628		class driver_window;
629		static void update_display_window_vosf(driver_window *drv);
630		static void update_display_dynamic(int ticker, driver_window *drv);
631	<	static void update_display_static(driver_window *drv);
631	>	static void update_display_static(driver_base *drv);
632
633		class driver_window : public driver_base {
634		friend void update_display_window_vosf(driver_window *drv);
635		friend void update_display_dynamic(int ticker, driver_window *drv);
636	<	friend void update_display_static(driver_window *drv);
636	>	friend void update_display_static(driver_base *drv);
637
638		public:
639		driver_window(SDL_monitor_desc &monitor);
#	Line 716 | Line 734 | void driver_base::restore_mouse_accel(vo
734		*  Windowed display driver
735		*/
736
737	+	static bool SDL_display_opened = false;
738	+
739		// Open display
740		driver_window::driver_window(SDL_monitor_desc &m)
741		: driver_base(m), mouse_grabbed(false)
#	Line 727 | Line 747 | driver_window::driver_window(SDL_monitor
747		// Set absolute mouse mode
748		ADBSetRelMouseMode(mouse_grabbed);
749
750	+	// This is ugly:
751	+	// If we're switching resolutions (ie, not setting it for the first time),
752	+	// there's a bug in SDL where the SDL_Surface created will not be properly
753	+	// setup. The solution is to SDL_QuitSubSystem(SDL_INIT_VIDEO) before calling
754	+	// SDL_SetVideoMode for the second time (SDL_SetVideoMode will call SDL_Init()
755	+	// and all will be well). Without this, the video becomes corrupted (at least
756	+	// on Mac OS X), after the resolution switch.
757	+	if (SDL_display_opened)
758	+	SDL_QuitSubSystem(SDL_INIT_VIDEO);
759	+
760		// Create surface
761		int depth = sdl_depth_of_video_depth(VIDEO_MODE_DEPTH);
762		if ((s = SDL_SetVideoMode(width, height, depth, SDL_HWSURFACE)) == NULL)
763		return;
764
765	+	SDL_display_opened = true;
766	+
767		#ifdef ENABLE_VOSF
768		use_vosf = true;
769		// Allocate memory for frame buffer (SIZE is extended to page-boundary)
#	Line 1209 | Line 1241 | bool VideoInit(bool classic)
1241		continue;
1242		if (w == 512 && h == 384)
1243		continue;
1212	–	#ifdef ENABLE_VOSF
1244		for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++)
1245		add_mode(display_type, w, h, video_modes[i].resolution_id, TrivialBytesPerRow(w, (video_depth)d), d);
1215	–	#else
1216	–	add_mode(display_type, w, h, video_modes[i].resolution_id, TrivialBytesPerRow(w, (video_depth)default_depth), default_depth);
1217	–	#endif
1246		}
1247		}
1248
#	Line 1514 | Line 1542 | void SDL_monitor_desc::switch_to_current
1542		#ifdef SHEEPSHAVER
1543		bool video_can_change_cursor(void)
1544		{
1545	<	return (display_type == DISPLAY_WINDOW);
1545	>	static char driver[] = "Quartz?";
1546	>	static int quartzok = -1;
1547	>
1548	>	if (display_type != DISPLAY_WINDOW)
1549	>	return false;
1550	>
1551	>	if (quartzok < 0) {
1552	>	if (SDL_VideoDriverName(driver, sizeof driver) == NULL || strncmp(driver, "Quartz", sizeof driver))
1553	>	quartzok = true;
1554	>	else {
1555	>	// Quartz driver bug prevents cursor changing in SDL 1.2.11 and later
1556	>	const SDL_version *vp = SDL_Linked_Version();
1557	>	quartzok = SDL_VERSIONNUM(vp->major, vp->minor, vp->patch) <= SDL_VERSIONNUM(1, 2, 10);
1558	>	}
1559	>	}
1560	>
1561	>	return quartzok;
1562		}
1563		#endif
1564
#	Line 1725 | Line 1769 | static void handle_events(void)
1769		// Mouse button
1770		case SDL_MOUSEBUTTONDOWN: {
1771		unsigned int button = event.button.button;
1772	<	if (button < 4)
1773	<	ADBMouseDown(button - 1);
1772	>	if (button == SDL_BUTTON_LEFT)
1773	>	ADBMouseDown(0);
1774	>	else if (button == SDL_BUTTON_RIGHT)
1775	>	ADBMouseDown(1);
1776	>	else if (button == SDL_BUTTON_MIDDLE)
1777	>	ADBMouseDown(2);
1778		else if (button < 6) {  // Wheel mouse
1779		if (mouse_wheel_mode == 0) {
1780		int key = (button == 5) ? 0x79 : 0x74;  // Page up/down
#	Line 1744 | Line 1792 | static void handle_events(void)
1792		}
1793		case SDL_MOUSEBUTTONUP: {
1794		unsigned int button = event.button.button;
1795	<	if (button < 4)
1796	<	ADBMouseUp(button - 1);
1795	>	if (button == SDL_BUTTON_LEFT)
1796	>	ADBMouseUp(0);
1797	>	else if (button == SDL_BUTTON_RIGHT)
1798	>	ADBMouseUp(1);
1799	>	else if (button == SDL_BUTTON_MIDDLE)
1800	>	ADBMouseUp(2);
1801		break;
1802		}
1803
#	Line 1829 | Line 1881 | static void handle_events(void)
1881		ADBKeyDown(0x7f);       // Power key
1882		ADBKeyUp(0x7f);
1883		break;
1884	+
1885	+	// Application activate/deactivate; consume the event but otherwise ignore it
1886	+	case SDL_ACTIVEEVENT:
1887	+	break;
1888		}
1889		}
1890		}
#	Line 1840 | Line 1896 | static void handle_events(void)
1896		*/
1897
1898		// Static display update (fixed frame rate, but incremental)
1899	<	static void update_display_static(driver_window *drv)
1899	>	static void update_display_static(driver_base *drv)
1900		{
1901		// Incremental update code
1902		int wide = 0, high = 0, x1, x2, y1, y2, i, j;
#	Line 1929 | Line 1985 | static void update_display_static(driver
1985
1986		} else {
1987		const int bytes_per_pixel = VIDEO_MODE_ROW_BYTES / VIDEO_MODE_X;
1988	+	const int dst_bytes_per_row = drv->s->pitch;
1989
1990		x1 = VIDEO_MODE_X;
1991		for (j=y1; j<=y2; j++) {
#	Line 1969 | Line 2026 | static void update_display_static(driver
2026		// Blit to screen surface
2027		for (j=y1; j<=y2; j++) {
2028		i = j * bytes_per_row + x1 * bytes_per_pixel;
2029	+	int dst_i = j * dst_bytes_per_row + x1 * bytes_per_pixel;
2030		memcpy(the_buffer_copy + i, the_buffer + i, bytes_per_pixel * wide);
2031	<	Screen_blit((uint8 *)drv->s->pixels + i, the_buffer + i, bytes_per_pixel * wide);
2031	>	Screen_blit((uint8 *)drv->s->pixels + dst_i, the_buffer + i, bytes_per_pixel * wide);
2032		}
2033
2034		// Unlock surface, if required
#	Line 1986 | Line 2044 | static void update_display_static(driver
2044
2045		// Static display update (fixed frame rate, bounding boxes based)
2046		// XXX use NQD bounding boxes to help detect dirty areas?
2047	<	static void update_display_static_bbox(driver_window *drv)
2047	>	static void update_display_static_bbox(driver_base *drv)
2048		{
2049		const VIDEO_MODE &mode = drv->mode;
2050
#	Line 2004 | Line 2062 | static void update_display_static_bbox(d
2062		// Update the surface from Mac screen
2063		const int bytes_per_row = VIDEO_MODE_ROW_BYTES;
2064		const int bytes_per_pixel = bytes_per_row / VIDEO_MODE_X;
2065	+	const int dst_bytes_per_row = drv->s->pitch;
2066		int x, y;
2067		for (y = 0; y < VIDEO_MODE_Y; y += N_PIXELS) {
2068		int h = N_PIXELS;
#	Line 2018 | Line 2077 | static void update_display_static_bbox(d
2077		bool dirty = false;
2078		for (int j = y; j < (y + h); j++) {
2079		const int yb = j * bytes_per_row;
2080	+	const int dst_yb = j * dst_bytes_per_row;
2081		if (memcmp(&the_buffer[yb + xb], &the_buffer_copy[yb + xb], xs) != 0) {
2082		memcpy(&the_buffer_copy[yb + xb], &the_buffer[yb + xb], xs);
2083	<	Screen_blit((uint8 *)drv->s->pixels + yb + xb, the_buffer + yb + xb, xs);
2083	>	Screen_blit((uint8 *)drv->s->pixels + dst_yb + xb, the_buffer + yb + xb, xs);
2084		dirty = true;
2085		}
2086		}
#	Line 2084 | Line 2144 | static inline void handle_palette_change
2144		UNLOCK_PALETTE;
2145		}
2146
2147	+	static void video_refresh_window_static(void);
2148	+
2149		static void video_refresh_dga(void)
2150		{
2151		// Quit DGA mode if requested
2152		possibly_quit_dga_mode();
2153	+	video_refresh_window_static();
2154		}
2155
2156		#ifdef ENABLE_VOSF
#	Line 2139 | Line 2202 | static void video_refresh_window_static(
2202		tick_counter = 0;
2203		const VIDEO_MODE &mode = drv->mode;
2204		if ((int)VIDEO_MODE_DEPTH >= VIDEO_DEPTH_8BIT)
2205	<	update_display_static_bbox(static_cast<driver_window *>(drv));
2205	>	update_display_static_bbox(drv);
2206		else
2207	<	update_display_static(static_cast<driver_window *>(drv));
2207	>	update_display_static(drv);
2208		}
2209		}
2210
#	Line 2177 | Line 2240 | static inline void do_video_refresh(void
2240		handle_events();
2241
2242		// Update display
2243	+	#if (defined(__APPLE__) && defined(__MACH__))
2244	+	// SDL expects an auto-release pool to be present.
2245	+	NSAutoReleasePool_wrap(video_refresh);
2246	+	#else
2247		video_refresh();
2248	+	#endif
2249
2250		#ifdef SHEEPSHAVER
2251		// Set new cursor image if it was changed
#	Line 2186 | Line 2254 | static inline void do_video_refresh(void
2254		LOCK_EVENTS;
2255		SDL_FreeCursor(sdl_cursor);
2256		sdl_cursor = SDL_CreateCursor(MacCursor + 4, MacCursor + 36, 16, 16, MacCursor[2], MacCursor[3]);
2257	<	if (sdl_cursor)
2257	>	if (sdl_cursor) {
2258	>	SDL_ShowCursor(private_data == NULL || private_data->cursorVisible);
2259		SDL_SetCursor(sdl_cursor);
2260	+	#ifdef WIN32
2261	+	// XXX Windows apparently needs an extra mouse event to
2262	+	// make the new cursor image visible
2263	+	int visible = SDL_ShowCursor(-1);
2264	+	if (visible) {
2265	+	int x, y;
2266	+	SDL_GetMouseState(&x, &y);
2267	+	SDL_WarpMouse(x, y);
2268	+	}
2269	+	#endif
2270	+	}
2271		UNLOCK_EVENTS;
2272		}
2273		#endif
#	Line 2255 | Line 2335 | static int redraw_func(void *arg)
2335		#ifdef SHEEPSHAVER
2336		void video_set_dirty_area(int x, int y, int w, int h)
2337		{
2338	+	#ifdef ENABLE_VOSF
2339		const VIDEO_MODE &mode = drv->mode;
2340		const int screen_width = VIDEO_MODE_X;
2341		const int screen_height = VIDEO_MODE_Y;
2342		const int bytes_per_row = VIDEO_MODE_ROW_BYTES;
2343
2263	–	#ifdef ENABLE_VOSF
2344		if (use_vosf) {
2345		vosf_set_dirty_area(x, y, w, h, screen_width, screen_height, bytes_per_row);
2346		return;

Diff Legend

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