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.31 by asvitkine, 2007-01-22T00:32:25Z vs.
Revision 1.44 by asvitkine, 2011-12-30T15:11:08Z

#	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 63 | 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
69	–
73		// Supported video modes
74		using std::vector;
75		static vector<VIDEO_MODE> VideoModes;
#	Line 136 | 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 197 | 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 613 | 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 719 | Line 734 | void driver_base::restore_mouse_accel(vo
734		*  Windowed display driver
735		*/
736
737	<	static int SDL_display_opened = FALSE;
737	>	static bool SDL_display_opened = false;
738
739		// Open display
740		driver_window::driver_window(SDL_monitor_desc &m)
#	Line 735 | Line 750 | driver_window::driver_window(SDL_monitor
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_Quit() before calling SDL_SetVideoMode for
754	<	// the second time (SDL_SetVideoMode will call SDL_Init() and all will be
755	<	// well). Without this, the video becomes corrupted (at least on Mac OS X),
756	<	// after the resolution switch (for the second and subsequent times).
757	<	// EDIT: Ack, this breaks audio!
758	<	//      if (SDL_display_opened)
744	<	//              SDL_Quit();
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;
765	>	SDL_display_opened = true;
766
767		#ifdef ENABLE_VOSF
768		use_vosf = true;
#	Line 1227 | Line 1241 | bool VideoInit(bool classic)
1241		continue;
1242		if (w == 512 && h == 384)
1243		continue;
1230	–	#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);
1233	–	#else
1234	–	add_mode(display_type, w, h, video_modes[i].resolution_id, TrivialBytesPerRow(w, (video_depth)default_depth), default_depth);
1235	–	#endif
1246		}
1247		}
1248
#	Line 1532 | 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 to 1.2.14.
1556	>	const SDL_version *vp = SDL_Linked_Version();
1557	>	int version = SDL_VERSIONNUM(vp->major, vp->minor, vp->patch);
1558	>	quartzok = (version <= SDL_VERSIONNUM(1, 2, 10) || version >= SDL_VERSIONNUM(1, 2, 15));
1559	>	}
1560	>	}
1561	>
1562	>	return quartzok;
1563		}
1564		#endif
1565
#	Line 1743 | Line 1770 | static void handle_events(void)
1770		// Mouse button
1771		case SDL_MOUSEBUTTONDOWN: {
1772		unsigned int button = event.button.button;
1773	<	if (button < 4)
1774	<	ADBMouseDown(button - 1);
1773	>	if (button == SDL_BUTTON_LEFT)
1774	>	ADBMouseDown(0);
1775	>	else if (button == SDL_BUTTON_RIGHT)
1776	>	ADBMouseDown(1);
1777	>	else if (button == SDL_BUTTON_MIDDLE)
1778	>	ADBMouseDown(2);
1779		else if (button < 6) {  // Wheel mouse
1780		if (mouse_wheel_mode == 0) {
1781		int key = (button == 5) ? 0x79 : 0x74;  // Page up/down
#	Line 1762 | Line 1793 | static void handle_events(void)
1793		}
1794		case SDL_MOUSEBUTTONUP: {
1795		unsigned int button = event.button.button;
1796	<	if (button < 4)
1797	<	ADBMouseUp(button - 1);
1796	>	if (button == SDL_BUTTON_LEFT)
1797	>	ADBMouseUp(0);
1798	>	else if (button == SDL_BUTTON_RIGHT)
1799	>	ADBMouseUp(1);
1800	>	else if (button == SDL_BUTTON_MIDDLE)
1801	>	ADBMouseUp(2);
1802		break;
1803		}
1804
#	Line 1847 | Line 1882 | static void handle_events(void)
1882		ADBKeyDown(0x7f);       // Power key
1883		ADBKeyUp(0x7f);
1884		break;
1885	+
1886	+	// Application activate/deactivate; consume the event but otherwise ignore it
1887	+	case SDL_ACTIVEEVENT:
1888	+	break;
1889		}
1890		}
1891		}
#	Line 1858 | Line 1897 | static void handle_events(void)
1897		*/
1898
1899		// Static display update (fixed frame rate, but incremental)
1900	<	static void update_display_static(driver_window *drv)
1900	>	static void update_display_static(driver_base *drv)
1901		{
1902		// Incremental update code
1903		int wide = 0, high = 0, x1, x2, y1, y2, i, j;
#	Line 1947 | Line 1986 | static void update_display_static(driver
1986
1987		} else {
1988		const int bytes_per_pixel = VIDEO_MODE_ROW_BYTES / VIDEO_MODE_X;
1989	+	const int dst_bytes_per_row = drv->s->pitch;
1990
1991		x1 = VIDEO_MODE_X;
1992		for (j=y1; j<=y2; j++) {
#	Line 1987 | Line 2027 | static void update_display_static(driver
2027		// Blit to screen surface
2028		for (j=y1; j<=y2; j++) {
2029		i = j * bytes_per_row + x1 * bytes_per_pixel;
2030	+	int dst_i = j * dst_bytes_per_row + x1 * bytes_per_pixel;
2031		memcpy(the_buffer_copy + i, the_buffer + i, bytes_per_pixel * wide);
2032	<	Screen_blit((uint8 *)drv->s->pixels + i, the_buffer + i, bytes_per_pixel * wide);
2032	>	Screen_blit((uint8 *)drv->s->pixels + dst_i, the_buffer + i, bytes_per_pixel * wide);
2033		}
2034
2035		// Unlock surface, if required
#	Line 2004 | Line 2045 | static void update_display_static(driver
2045
2046		// Static display update (fixed frame rate, bounding boxes based)
2047		// XXX use NQD bounding boxes to help detect dirty areas?
2048	<	static void update_display_static_bbox(driver_window *drv)
2048	>	static void update_display_static_bbox(driver_base *drv)
2049		{
2050		const VIDEO_MODE &mode = drv->mode;
2051
#	Line 2022 | Line 2063 | static void update_display_static_bbox(d
2063		// Update the surface from Mac screen
2064		const int bytes_per_row = VIDEO_MODE_ROW_BYTES;
2065		const int bytes_per_pixel = bytes_per_row / VIDEO_MODE_X;
2066	+	const int dst_bytes_per_row = drv->s->pitch;
2067		int x, y;
2068		for (y = 0; y < VIDEO_MODE_Y; y += N_PIXELS) {
2069		int h = N_PIXELS;
#	Line 2036 | Line 2078 | static void update_display_static_bbox(d
2078		bool dirty = false;
2079		for (int j = y; j < (y + h); j++) {
2080		const int yb = j * bytes_per_row;
2081	+	const int dst_yb = j * dst_bytes_per_row;
2082		if (memcmp(&the_buffer[yb + xb], &the_buffer_copy[yb + xb], xs) != 0) {
2083		memcpy(&the_buffer_copy[yb + xb], &the_buffer[yb + xb], xs);
2084	<	Screen_blit((uint8 *)drv->s->pixels + yb + xb, the_buffer + yb + xb, xs);
2084	>	Screen_blit((uint8 *)drv->s->pixels + dst_yb + xb, the_buffer + yb + xb, xs);
2085		dirty = true;
2086		}
2087		}
#	Line 2102 | Line 2145 | static inline void handle_palette_change
2145		UNLOCK_PALETTE;
2146		}
2147
2148	+	static void video_refresh_window_static(void);
2149	+
2150		static void video_refresh_dga(void)
2151		{
2152		// Quit DGA mode if requested
2153		possibly_quit_dga_mode();
2154	+	video_refresh_window_static();
2155		}
2156
2157		#ifdef ENABLE_VOSF
#	Line 2157 | Line 2203 | static void video_refresh_window_static(
2203		tick_counter = 0;
2204		const VIDEO_MODE &mode = drv->mode;
2205		if ((int)VIDEO_MODE_DEPTH >= VIDEO_DEPTH_8BIT)
2206	<	update_display_static_bbox(static_cast<driver_window *>(drv));
2206	>	update_display_static_bbox(drv);
2207		else
2208	<	update_display_static(static_cast<driver_window *>(drv));
2208	>	update_display_static(drv);
2209		}
2210		}
2211
#	Line 2195 | Line 2241 | static inline void do_video_refresh(void
2241		handle_events();
2242
2243		// Update display
2244	+	#if (defined(__APPLE__) && defined(__MACH__))
2245	+	// SDL expects an auto-release pool to be present.
2246	+	NSAutoReleasePool_wrap(video_refresh);
2247	+	#else
2248		video_refresh();
2249	+	#endif
2250
2251		#ifdef SHEEPSHAVER
2252		// Set new cursor image if it was changed
#	Line 2205 | Line 2256 | static inline void do_video_refresh(void
2256		SDL_FreeCursor(sdl_cursor);
2257		sdl_cursor = SDL_CreateCursor(MacCursor + 4, MacCursor + 36, 16, 16, MacCursor[2], MacCursor[3]);
2258		if (sdl_cursor) {
2259	+	SDL_ShowCursor(private_data == NULL || private_data->cursorVisible);
2260		SDL_SetCursor(sdl_cursor);
2261		#ifdef WIN32
2262		// XXX Windows apparently needs an extra mouse event to
#	Line 2284 | Line 2336 | static int redraw_func(void *arg)
2336		#ifdef SHEEPSHAVER
2337		void video_set_dirty_area(int x, int y, int w, int h)
2338		{
2339	+	#ifdef ENABLE_VOSF
2340		const VIDEO_MODE &mode = drv->mode;
2341		const int screen_width = VIDEO_MODE_X;
2342		const int screen_height = VIDEO_MODE_Y;
2343		const int bytes_per_row = VIDEO_MODE_ROW_BYTES;
2344
2292	–	#ifdef ENABLE_VOSF
2345		if (use_vosf) {
2346		vosf_set_dirty_area(x, y, w, h, screen_width, screen_height, bytes_per_row);
2347		return;

Diff Legend

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