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.1 by gbeauche, 2004-06-23T13:47:20Z vs.
Revision 1.11 by gbeauche, 2004-07-02T06:08:01Z

#	Line 32 | Line 32
32		*  - Force relative mode in Grab mode even if SDL provides absolute coordinates?
33		*  - Fullscreen mode
34		*  - Gamma tables support is likely to be broken here
35	+	*  - Events processing is bound to the general emulation thread as SDL requires
36	+	*    to PumpEvents() within the same thread as the one that called SetVideoMode().
37	+	*    Besides, there can't seem to be a way to call SetVideoMode() from a child thread.
38	+	*  - Refresh performance is still slow. Use SDL_CreateRGBSurface()?
39	+	*  - Backport hw cursor acceleration to Basilisk II?
40		*/
41
42		#include "sysdeps.h"
#	Line 40 | Line 45
45		#include <SDL_mutex.h>
46		#include <SDL_thread.h>
47		#include <errno.h>
48	+	#include <vector>
49
50		#include "cpu_emulation.h"
51		#include "main.h"
#	Line 48 | Line 54
54		#include "prefs.h"
55		#include "user_strings.h"
56		#include "video.h"
57	+	#include "video_defs.h"
58		#include "video_blit.h"
59
60		#define DEBUG 0
#	Line 55 | Line 62
62
63
64		// Supported video modes
65	<	static vector<video_mode> VideoModes;
65	>	using std::vector;
66	>	static vector<VIDEO_MODE> VideoModes;
67
68		// Display types
69	+	#ifdef SHEEPSHAVER
70		enum {
71	<	DISPLAY_WINDOW, // windowed display
72	<	DISPLAY_SCREEN  // fullscreen display
71	>	DISPLAY_WINDOW = DIS_WINDOW,                                    // windowed display
72	>	DISPLAY_SCREEN = DIS_SCREEN                                             // fullscreen display
73		};
74	+	extern int display_type;                                                        // See enum above
75	+	#else
76	+	enum {
77	+	DISPLAY_WINDOW,                                                                 // windowed display
78	+	DISPLAY_SCREEN                                                                  // fullscreen display
79	+	};
80	+	static int display_type = DISPLAY_WINDOW;                       // See enum above
81	+	#endif
82
83		// Constants
84		const char KEYCODE_FILE_NAME[] = DATADIR "/keycodes";
#	Line 72 | Line 89 | static int32 frame_skip;                                                       // Prefs
89		static int16 mouse_wheel_mode;
90		static int16 mouse_wheel_lines;
91
75	–	static int display_type = DISPLAY_WINDOW;                       // See enum above
92		static uint8 *the_buffer = NULL;                                        // Mac frame buffer (where MacOS draws into)
93		static uint8 *the_buffer_copy = NULL;                           // Copy of Mac frame buffer (for refreshed modes)
94		static uint32 the_buffer_size;                                          // Size of allocated the_buffer
#	Line 82 | Line 98 | static volatile bool redraw_thread_cance
98		static SDL_Thread *redraw_thread = NULL;                        // Redraw thread
99
100		#ifdef ENABLE_VOSF
101	<	static bool use_vosf = true;                                            // Flag: VOSF enabled
101	>	static bool use_vosf = false;                                           // Flag: VOSF enabled
102		#else
103		static const bool use_vosf = false;                                     // VOSF not possible
104		#endif
#	Line 100 | Line 116 | static int keycode_table[256];                                         // X
116
117		// SDL variables
118		static int screen_depth;                                                        // Depth of current screen
119	+	static SDL_Cursor *sdl_cursor;                                          // Copy of Mac cursor
120	+	static volatile bool cursor_changed = false;            // Flag: cursor changed, redraw_func must update the cursor
121		static SDL_Color sdl_palette[256];                                      // Color palette to be used as CLUT and gamma table
122		static bool sdl_palette_changed = false;                        // Flag: Palette changed, redraw thread must set new colors
123	+	static const int sdl_eventmask = SDL_MOUSEBUTTONDOWNMASK | SDL_MOUSEBUTTONUPMASK | SDL_MOUSEMOTIONMASK | SDL_KEYUPMASK | SDL_KEYDOWNMASK | SDL_VIDEOEXPOSEMASK | SDL_QUITMASK;
124
125		// Mutex to protect palette
126		static SDL_mutex *sdl_palette_lock = NULL;
#	Line 126 | Line 145 | extern void SysMountFirstFloppy(void);
145
146
147		/*
148	+	*  SheepShaver glue
149	+	*/
150	+
151	+	#ifdef SHEEPSHAVER
152	+	// Color depth modes type
153	+	typedef int video_depth;
154	+
155	+	// 1, 2, 4 and 8 bit depths use a color palette
156	+	static inline bool IsDirectMode(VIDEO_MODE const & mode)
157	+	{
158	+	return IsDirectMode(mode.viAppleMode);
159	+	}
160	+
161	+	// Abstract base class representing one (possibly virtual) monitor
162	+	// ("monitor" = rectangular display with a contiguous frame buffer)
163	+	class monitor_desc {
164	+	public:
165	+	monitor_desc(const vector<VIDEO_MODE> &available_modes, video_depth default_depth, uint32 default_id) {}
166	+	virtual ~monitor_desc() {}
167	+
168	+	// Get current Mac frame buffer base address
169	+	uint32 get_mac_frame_base(void) const {return screen_base;}
170	+
171	+	// Set Mac frame buffer base address (called from switch_to_mode())
172	+	void set_mac_frame_base(uint32 base) {screen_base = base;}
173	+
174	+	// Get current video mode
175	+	const VIDEO_MODE &get_current_mode(void) const {return VModes[cur_mode];}
176	+
177	+	// Called by the video driver to switch the video mode on this display
178	+	// (must call set_mac_frame_base())
179	+	virtual void switch_to_current_mode(void) = 0;
180	+
181	+	// Called by the video driver to set the color palette (in indexed modes)
182	+	// or the gamma table (in direct modes)
183	+	virtual void set_palette(uint8 *pal, int num) = 0;
184	+	};
185	+
186	+	// Vector of pointers to available monitor descriptions, filled by VideoInit()
187	+	static vector<monitor_desc *> VideoMonitors;
188	+
189	+	// Find Apple mode matching best specified dimensions
190	+	static int find_apple_resolution(int xsize, int ysize)
191	+	{
192	+	int apple_id;
193	+	if (xsize < 800)
194	+	apple_id = APPLE_640x480;
195	+	else if (xsize < 1024)
196	+	apple_id = APPLE_800x600;
197	+	else if (xsize < 1152)
198	+	apple_id = APPLE_1024x768;
199	+	else if (xsize < 1280) {
200	+	if (ysize < 900)
201	+	apple_id = APPLE_1152x768;
202	+	else
203	+	apple_id = APPLE_1152x900;
204	+	}
205	+	else if (xsize < 1600)
206	+	apple_id = APPLE_1280x1024;
207	+	else
208	+	apple_id = APPLE_1600x1200;
209	+	return apple_id;
210	+	}
211	+
212	+	// Set parameters to specified Apple mode
213	+	static void set_apple_resolution(int apple_id, int &xsize, int &ysize)
214	+	{
215	+	switch (apple_id) {
216	+	case APPLE_640x480:
217	+	xsize = 640;
218	+	ysize = 480;
219	+	break;
220	+	case APPLE_800x600:
221	+	xsize = 800;
222	+	ysize = 600;
223	+	break;
224	+	case APPLE_1024x768:
225	+	xsize = 1024;
226	+	ysize = 768;
227	+	break;
228	+	case APPLE_1152x768:
229	+	xsize = 1152;
230	+	ysize = 768;
231	+	break;
232	+	case APPLE_1152x900:
233	+	xsize = 1152;
234	+	ysize = 900;
235	+	break;
236	+	case APPLE_1280x1024:
237	+	xsize = 1280;
238	+	ysize = 1024;
239	+	break;
240	+	case APPLE_1600x1200:
241	+	xsize = 1600;
242	+	ysize = 1200;
243	+	break;
244	+	default:
245	+	abort();
246	+	}
247	+	}
248	+
249	+	// Match Apple mode matching best specified dimensions
250	+	static int match_apple_resolution(int &xsize, int &ysize)
251	+	{
252	+	int apple_id = find_apple_resolution(xsize, ysize);
253	+	set_apple_resolution(apple_id, xsize, ysize);
254	+	return apple_id;
255	+	}
256	+
257	+	// Display error alert
258	+	static void ErrorAlert(int error)
259	+	{
260	+	ErrorAlert(GetString(error));
261	+	}
262	+
263	+	// Display warning alert
264	+	static void WarningAlert(int warning)
265	+	{
266	+	WarningAlert(GetString(warning));
267	+	}
268	+	#endif
269	+
270	+
271	+	/*
272		*  monitor_desc subclass for SDL display
273		*/
274
275		class SDL_monitor_desc : public monitor_desc {
276		public:
277	<	SDL_monitor_desc(const vector<video_mode> &available_modes, video_depth default_depth, uint32 default_id) : monitor_desc(available_modes, default_depth, default_id) {}
277	>	SDL_monitor_desc(const vector<VIDEO_MODE> &available_modes, video_depth default_depth, uint32 default_id) : monitor_desc(available_modes, default_depth, default_id) {}
278		~SDL_monitor_desc() {}
279
280		virtual void switch_to_current_mode(void);
#	Line 146 | Line 289 | public:
289		*  Utility functions
290		*/
291
292	+	// Find palette size for given color depth
293	+	static int palette_size(int mode)
294	+	{
295	+	switch (mode) {
296	+	case VIDEO_DEPTH_1BIT: return 2;
297	+	case VIDEO_DEPTH_2BIT: return 4;
298	+	case VIDEO_DEPTH_4BIT: return 16;
299	+	case VIDEO_DEPTH_8BIT: return 256;
300	+	case VIDEO_DEPTH_16BIT: return 32;
301	+	case VIDEO_DEPTH_32BIT: return 256;
302	+	default: return 0;
303	+	}
304	+	}
305	+
306	+	// Return bytes per pixel for requested depth
307	+	static inline int bytes_per_pixel(int depth)
308	+	{
309	+	int bpp;
310	+	switch (depth) {
311	+	case 8:
312	+	bpp = 1;
313	+	break;
314	+	case 15: case 16:
315	+	bpp = 2;
316	+	break;
317	+	case 24: case 32:
318	+	bpp = 4;
319	+	break;
320	+	default:
321	+	abort();
322	+	}
323	+	return bpp;
324	+	}
325	+
326		// Map video_mode depth ID to numerical depth value
327		static int sdl_depth_of_video_depth(int video_depth)
328		{
329		int depth = -1;
330		switch (video_depth) {
331	<	case VDEPTH_1BIT:
331	>	case VIDEO_DEPTH_1BIT:
332		depth = 1;
333		break;
334	<	case VDEPTH_2BIT:
334	>	case VIDEO_DEPTH_2BIT:
335		depth = 2;
336		break;
337	<	case VDEPTH_4BIT:
337	>	case VIDEO_DEPTH_4BIT:
338		depth = 4;
339		break;
340	<	case VDEPTH_8BIT:
340	>	case VIDEO_DEPTH_8BIT:
341		depth = 8;
342		break;
343	<	case VDEPTH_16BIT:
343	>	case VIDEO_DEPTH_16BIT:
344		depth = 16;
345		break;
346	<	case VDEPTH_32BIT:
346	>	case VIDEO_DEPTH_32BIT:
347		depth = 32;
348		break;
349		default:
#	Line 175 | Line 352 | static int sdl_depth_of_video_depth(int
352		return depth;
353		}
354
355	+	// Check wether specified mode is available
356	+	static bool has_mode(int type, int width, int height)
357	+	{
358	+	// FIXME: no fullscreen support yet
359	+	if (type == DISPLAY_SCREEN)
360	+	return false;
361	+
362	+	#ifdef SHEEPSHAVER
363	+	// Filter out Classic resolutiosn
364	+	if (width == 512 && height == 384)
365	+	return false;
366	+
367	+	// Read window modes prefs
368	+	static uint32 window_modes = 0;
369	+	static uint32 screen_modes = 0;
370	+	if (window_modes == 0 || screen_modes == 0) {
371	+	window_modes = PrefsFindInt32("windowmodes");
372	+	screen_modes = PrefsFindInt32("screenmodes");
373	+	if (window_modes == 0 || screen_modes == 0)
374	+	window_modes |= 3;                      // Allow at least 640x480 and 800x600 window modes
375	+	}
376	+
377	+	if (type == DISPLAY_WINDOW) {
378	+	int apple_mask, apple_id = find_apple_resolution(width, height);
379	+	switch (apple_id) {
380	+	case APPLE_640x480:             apple_mask = 0x01; break;
381	+	case APPLE_800x600:             apple_mask = 0x02; break;
382	+	case APPLE_1024x768:    apple_mask = 0x04; break;
383	+	case APPLE_1152x768:    apple_mask = 0x40; break;
384	+	case APPLE_1152x900:    apple_mask = 0x08; break;
385	+	case APPLE_1280x1024:   apple_mask = 0x10; break;
386	+	case APPLE_1600x1200:   apple_mask = 0x20; break;
387	+	default:                                apple_mask = 0x00; break;
388	+	}
389	+	return (window_modes & apple_mask);
390	+	}
391	+	#else
392	+	return true;
393	+	#endif
394	+	return false;
395	+	}
396	+
397		// Add mode to list of supported modes
398	<	static void add_mode(uint32 width, uint32 height, uint32 resolution_id, uint32 bytes_per_row, video_depth depth)
398	>	static void add_mode(int type, int width, int height, int resolution_id, int bytes_per_row, int depth)
399		{
400	<	video_mode mode;
401	<	mode.x = width;
402	<	mode.y = height;
403	<	mode.resolution_id = resolution_id;
404	<	mode.bytes_per_row = bytes_per_row;
405	<	mode.depth = depth;
400	>	// Filter out unsupported modes
401	>	if (!has_mode(type, width, height))
402	>	return;
403	>
404	>	// Fill in VideoMode entry
405	>	VIDEO_MODE mode;
406	>	#ifdef SHEEPSHAVER
407	>	// Recalculate dimensions to fit Apple modes
408	>	resolution_id = match_apple_resolution(width, height);
409	>	mode.viType = type;
410	>	#endif
411	>	VIDEO_MODE_X = width;
412	>	VIDEO_MODE_Y = height;
413	>	VIDEO_MODE_RESOLUTION = resolution_id;
414	>	VIDEO_MODE_ROW_BYTES = bytes_per_row;
415	>	VIDEO_MODE_DEPTH = (video_depth)depth;
416		VideoModes.push_back(mode);
417		}
418
419		// Add standard list of windowed modes for given color depth
420	<	static void add_window_modes(video_depth depth)
420	>	static void add_window_modes(int depth)
421		{
422	<	add_mode(512, 384, 0x80, TrivialBytesPerRow(512, depth), depth);
423	<	add_mode(640, 480, 0x81, TrivialBytesPerRow(640, depth), depth);
424	<	add_mode(800, 600, 0x82, TrivialBytesPerRow(800, depth), depth);
425	<	add_mode(1024, 768, 0x83, TrivialBytesPerRow(1024, depth), depth);
426	<	add_mode(1152, 870, 0x84, TrivialBytesPerRow(1152, depth), depth);
427	<	add_mode(1280, 1024, 0x85, TrivialBytesPerRow(1280, depth), depth);
428	<	add_mode(1600, 1200, 0x86, TrivialBytesPerRow(1600, depth), depth);
422	>	video_depth vdepth = (video_depth)depth;
423	>	add_mode(DISPLAY_WINDOW, 512, 384, 0x80, TrivialBytesPerRow(512, vdepth), depth);
424	>	add_mode(DISPLAY_WINDOW, 640, 480, 0x81, TrivialBytesPerRow(640, vdepth), depth);
425	>	add_mode(DISPLAY_WINDOW, 800, 600, 0x82, TrivialBytesPerRow(800, vdepth), depth);
426	>	add_mode(DISPLAY_WINDOW, 1024, 768, 0x83, TrivialBytesPerRow(1024, vdepth), depth);
427	>	add_mode(DISPLAY_WINDOW, 1152, 870, 0x84, TrivialBytesPerRow(1152, vdepth), depth);
428	>	add_mode(DISPLAY_WINDOW, 1280, 1024, 0x85, TrivialBytesPerRow(1280, vdepth), depth);
429	>	add_mode(DISPLAY_WINDOW, 1600, 1200, 0x86, TrivialBytesPerRow(1600, vdepth), depth);
430		}
431
432		// Set Mac frame layout and base address (uses the_buffer/MacFrameBaseMac)
433	<	static void set_mac_frame_buffer(SDL_monitor_desc &monitor, video_depth depth, bool native_byte_order)
433	>	static void set_mac_frame_buffer(SDL_monitor_desc &monitor, int depth, bool native_byte_order)
434		{
435		#if !REAL_ADDRESSING && !DIRECT_ADDRESSING
436		int layout = FLAYOUT_DIRECT;
437	<	if (depth == VDEPTH_16BIT)
437	>	if (depth == VIDEO_DEPTH_16BIT)
438		layout = (screen_depth == 15) ? FLAYOUT_HOST_555 : FLAYOUT_HOST_565;
439	<	else if (depth == VDEPTH_32BIT)
439	>	else if (depth == VIDEO_DEPTH_32BIT)
440		layout = (screen_depth == 24) ? FLAYOUT_HOST_888 : FLAYOUT_DIRECT;
441		if (native_byte_order)
442		MacFrameLayout = layout;
#	Line 215 | Line 445 | static void set_mac_frame_buffer(SDL_mon
445		monitor.set_mac_frame_base(MacFrameBaseMac);
446
447		// Set variables used by UAE memory banking
448	<	const video_mode &mode = monitor.get_current_mode();
448	>	const VIDEO_MODE &mode = monitor.get_current_mode();
449		MacFrameBaseHost = the_buffer;
450	<	MacFrameSize = mode.bytes_per_row * mode.y;
450	>	MacFrameSize = VIDEO_MODE_ROW_BYTES * VIDEO_MODE_Y;
451		InitFrameBufferMapping();
452		#else
453		monitor.set_mac_frame_base(Host2MacAddr(the_buffer));
#	Line 266 | Line 496 | public:
496
497		public:
498		SDL_monitor_desc &monitor; // Associated video monitor
499	<	const video_mode &mode;    // Video mode handled by the driver
499	>	const VIDEO_MODE &mode;    // Video mode handled by the driver
500
501		bool init_ok;   // Initialization succeeded (we can't use exceptions because of -fomit-frame-pointer)
502		SDL_Surface *s; // The surface we draw into
#	Line 354 | Line 584 | driver_base::~driver_base()
584		// Palette has changed
585		void driver_base::update_palette(void)
586		{
587	<	const video_mode &mode = monitor.get_current_mode();
587	>	const VIDEO_MODE &mode = monitor.get_current_mode();
588
589	<	if (mode.depth <= VDEPTH_8BIT)
589	>	if ((int)VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT)
590		SDL_SetPalette(s, SDL_PHYSPAL, sdl_palette, 0, 256);
591		}
592
#	Line 379 | Line 609 | void driver_base::restore_mouse_accel(vo
609		driver_window::driver_window(SDL_monitor_desc &m)
610		: driver_base(m), mouse_grabbed(false)
611		{
612	<	int width = mode.x, height = mode.y;
612	>	int width = VIDEO_MODE_X, height = VIDEO_MODE_Y;
613		int aligned_width = (width + 15) & ~15;
614		int aligned_height = (height + 15) & ~15;
615
#	Line 387 | Line 617 | driver_window::driver_window(SDL_monitor
617		ADBSetRelMouseMode(mouse_grabbed);
618
619		// Create surface
620	<	int depth = (mode.depth <= VDEPTH_8BIT ? 8 : screen_depth);
620	>	int depth = ((int)VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT ? 8 : screen_depth);
621		if ((s = SDL_SetVideoMode(width, height, depth, SDL_HWSURFACE)) == NULL)
622		return;
623
#	Line 399 | Line 629 | driver_window::driver_window(SDL_monitor
629		the_buffer = (uint8 *)vm_acquire(the_buffer_size);
630		the_buffer_copy = (uint8 *)malloc(the_buffer_size);
631		D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer));
632	+
633	+	// Check whether we can initialize the VOSF subsystem and it's profitable
634	+	if (!video_vosf_init(m)) {
635	+	WarningAlert(STR_VOSF_INIT_ERR);
636	+	use_vosf = false;
637	+	}
638	+	else if (!video_vosf_profitable()) {
639	+	video_vosf_exit();
640	+	printf("VOSF acceleration is not profitable on this platform, disabling it\n");
641	+	use_vosf = false;
642	+	}
643	+	if (!use_vosf) {
644	+	free(the_buffer_copy);
645	+	vm_release(the_buffer, the_buffer_size);
646	+	the_host_buffer = NULL;
647	+	}
648	+	#endif
649	+	if (!use_vosf) {
650	+	// Allocate memory for frame buffer
651	+	the_buffer_size = (aligned_height + 2) * s->pitch;
652	+	the_buffer_copy = (uint8 *)calloc(1, the_buffer_size);
653	+	the_buffer = (uint8 *)calloc(1, the_buffer_size);
654	+	D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy));
655	+	}
656	+
657	+	#ifdef SHEEPSHAVER
658	+	// Create cursor
659	+	if ((sdl_cursor = SDL_CreateCursor(MacCursor + 4, MacCursor + 36, 16, 16, 0, 0)) != NULL) {
660	+	SDL_SetCursor(sdl_cursor);
661	+	cursor_changed = false;
662	+	}
663		#else
664	<	// Allocate memory for frame buffer
665	<	the_buffer_size = (aligned_height + 2) * s->pitch;
405	<	the_buffer_copy = (uint8 *)calloc(1, the_buffer_size);
406	<	the_buffer = (uint8 *)calloc(1, the_buffer_size);
407	<	D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy));
664	>	// Hide cursor
665	>	SDL_ShowCursor(0);
666		#endif
667
668		// Set window name/class
669		set_window_name(STR_WINDOW_TITLE);
670
413	–	// Hide cursor
414	–	SDL_ShowCursor(0);
415	–
671		// Init blitting routines
672		SDL_PixelFormat *f = s->format;
673		VisualFormat visualFormat;
#	Line 420 | Line 675 | driver_window::driver_window(SDL_monitor
675		visualFormat.Rmask = f->Rmask;
676		visualFormat.Gmask = f->Gmask;
677		visualFormat.Bmask = f->Bmask;
678	<	Screen_blitter_init(visualFormat, true, sdl_depth_of_video_depth(mode.depth));
678	>	Screen_blitter_init(visualFormat, true, sdl_depth_of_video_depth(VIDEO_MODE_DEPTH));
679
680		// Load gray ramp to 8->16/32 expand map
681		if (!IsDirectMode(mode))
#	Line 428 | Line 683 | driver_window::driver_window(SDL_monitor
683		ExpandMap[i] = SDL_MapRGB(f, i, i, i);
684
685		// Set frame buffer base
686	<	set_mac_frame_buffer(monitor, mode.depth, true);
686	>	set_mac_frame_buffer(monitor, VIDEO_MODE_DEPTH, true);
687
688		// Everything went well
689		init_ok = true;
#	Line 531 | Line 786 | static void keycode_init(void)
786
787		if (video_driver_found) {
788		// Skip aliases
789	<	static const char alias_str[] = "alias";
790	<	if (strncmp(line, alias_str, sizeof(alias_str) - 1) == 0)
789	>	static const char sdl_str[] = "sdl";
790	>	if (strncmp(line, sdl_str, sizeof(sdl_str) - 1) == 0)
791		continue;
792
793		// Read keycode
#	Line 543 | Line 798 | static void keycode_init(void)
798		break;
799		} else {
800		// Search for SDL video driver string
801	<	static const char alias_sdl_str[] = "alias SDL";
802	<	if (strncmp(line, alias_sdl_str, sizeof(alias_sdl_str) - 1) == 0) {
803	<	char *p = line + sizeof(alias_sdl_str);
801	>	static const char sdl_str[] = "sdl";
802	>	if (strncmp(line, sdl_str, sizeof(sdl_str) - 1) == 0) {
803	>	char *p = line + sizeof(sdl_str);
804		if (strstr(video_driver, p) == video_driver)
805		video_driver_found = true;
806		}
#	Line 570 | Line 825 | static void keycode_init(void)
825		bool SDL_monitor_desc::video_open(void)
826		{
827		D(bug("video_open()\n"));
828	<	const video_mode &mode = get_current_mode();
828	>	const VIDEO_MODE &mode = get_current_mode();
829	>	#if DEBUG
830	>	D(bug("Current video mode:\n"));
831	>	D(bug(" %dx%d (ID %02x), %d bpp\n", VIDEO_MODE_X, VIDEO_MODE_Y, VIDEO_MODE_RESOLUTION, 1 << (VIDEO_MODE_DEPTH & 0x0f)));
832	>	#endif
833
834		// Create display driver object of requested type
835		switch (display_type) {
#	Line 586 | Line 845 | bool SDL_monitor_desc::video_open(void)
845		return false;
846		}
847
589	–	#ifdef ENABLE_VOSF
590	–	if (use_vosf) {
591	–	// Initialize the VOSF system
592	–	if (!video_vosf_init(*this)) {
593	–	ErrorAlert(STR_VOSF_INIT_ERR);
594	–	return false;
595	–	}
596	–	}
597	–	#endif
598	–
848		// Initialize VideoRefresh function
849		VideoRefreshInit();
850
#	Line 604 | Line 853 | bool SDL_monitor_desc::video_open(void)
853
854		// Start redraw/input thread
855		redraw_thread_cancel = false;
856	<	redraw_thread_active = (SDL_CreateThread(redraw_func, NULL) != NULL);
856	>	redraw_thread_active = ((redraw_thread = SDL_CreateThread(redraw_func, NULL)) != NULL);
857		if (!redraw_thread_active) {
858		printf("FATAL: cannot create redraw thread\n");
859		return false;
#	Line 612 | Line 861 | bool SDL_monitor_desc::video_open(void)
861		return true;
862		}
863
864	+	#ifdef SHEEPSHAVER
865	+	bool VideoInit(void)
866	+	{
867	+	const bool classic = false;
868	+	#else
869		bool VideoInit(bool classic)
870		{
871	+	#endif
872		classic_mode = classic;
873
874		#ifdef ENABLE_VOSF
#	Line 637 | Line 892 | bool VideoInit(bool classic)
892		mouse_wheel_lines = PrefsFindInt32("mousewheellines");
893
894		// Get screen mode from preferences
895	<	const char *mode_str;
895	>	const char *mode_str = NULL;
896	>	#ifndef SHEEPSHAVER
897		if (classic_mode)
898		mode_str = "win/512/342";
899		else
900		mode_str = PrefsFindString("screen");
901	+	#endif
902
903		// Determine display type and default dimensions
904	<	int default_width = 512, default_height = 384;
904	>	int default_width, default_height;
905	>	if (classic) {
906	>	default_width = 512;
907	>	default_height = 384;
908	>	}
909	>	else {
910	>	default_width = 640;
911	>	default_height = 480;
912	>	}
913		display_type = DISPLAY_WINDOW;
914		if (mode_str) {
915		if (sscanf(mode_str, "win/%d/%d", &default_width, &default_height) == 2)
916		display_type = DISPLAY_WINDOW;
917		}
918		int max_width = 640, max_height = 480;
919	<	if (display_type == DISPLAY_SCREEN) {
920	<	SDL_Rect **modes = SDL_ListModes(NULL, SDL_FULLSCREEN | SDL_HWSURFACE);
921	<	if (modes && modes != (SDL_Rect **)-1) {
922	<	max_width = modes[0]->w;
923	<	max_height = modes[0]->h;
924	<	}
919	>	SDL_Rect **modes = SDL_ListModes(NULL, SDL_FULLSCREEN | SDL_HWSURFACE);
920	>	if (modes && modes != (SDL_Rect **)-1) {
921	>	max_width = modes[0]->w;
922	>	max_height = modes[0]->h;
923	>	if (default_width > max_width)
924	>	default_width = max_width;
925	>	if (default_height > max_height)
926	>	default_height = max_height;
927		}
928		if (default_width <= 0)
929		default_width = max_width;
#	Line 665 | Line 932 | bool VideoInit(bool classic)
932
933		// Mac screen depth follows X depth
934		screen_depth = SDL_GetVideoInfo()->vfmt->BitsPerPixel;
935	<	video_depth default_depth;
935	>	int default_depth;
936		switch (screen_depth) {
937		case 8:
938	<	default_depth = VDEPTH_8BIT;
938	>	default_depth = VIDEO_DEPTH_8BIT;
939		break;
940		case 15: case 16:
941	<	default_depth = VDEPTH_16BIT;
941	>	default_depth = VIDEO_DEPTH_16BIT;
942		break;
943		case 24: case 32:
944	<	default_depth = VDEPTH_32BIT;
944	>	default_depth = VIDEO_DEPTH_32BIT;
945		break;
946		default:
947	<	default_depth =  VDEPTH_1BIT;
947	>	default_depth =  VIDEO_DEPTH_1BIT;
948		break;
949		}
950
951		// Construct list of supported modes
952		if (display_type == DISPLAY_WINDOW) {
953		if (classic)
954	<	add_mode(512, 342, 0x80, 64, VDEPTH_1BIT);
954	>	add_mode(display_type, 512, 342, 0x80, 64, VIDEO_DEPTH_1BIT);
955		else {
956	<	for (int d = VDEPTH_1BIT; d <= default_depth; d++) {
957	<	int bpp = (d <= VDEPTH_8BIT ? 8 : sdl_depth_of_video_depth(d));
956	>	for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++) {
957	>	int bpp = (d <= VIDEO_DEPTH_8BIT ? 8 : sdl_depth_of_video_depth(d));
958		if (SDL_VideoModeOK(max_width, max_height, bpp, SDL_HWSURFACE))
959		add_window_modes(video_depth(d));
960		}
961		}
962		} else
963	<	add_mode(default_width, default_height, 0x80, TrivialBytesPerRow(default_width, default_depth), default_depth);
963	>	add_mode(display_type, default_width, default_height, 0x80, TrivialBytesPerRow(default_width, (video_depth)default_depth), default_depth);
964		if (VideoModes.empty()) {
965		ErrorAlert(STR_NO_XVISUAL_ERR);
966		return false;
#	Line 701 | Line 968 | bool VideoInit(bool classic)
968
969		// Find requested default mode with specified dimensions
970		uint32 default_id;
971	<	std::vector<video_mode>::const_iterator i, end = VideoModes.end();
971	>	std::vector<VIDEO_MODE>::const_iterator i, end = VideoModes.end();
972		for (i = VideoModes.begin(); i != end; ++i) {
973	<	if (i->x == default_width && i->y == default_height && i->depth == default_depth) {
974	<	default_id = i->resolution_id;
973	>	const VIDEO_MODE & mode = (*i);
974	>	if (VIDEO_MODE_X == default_width && VIDEO_MODE_Y == default_height && VIDEO_MODE_DEPTH == default_depth) {
975	>	default_id = VIDEO_MODE_RESOLUTION;
976	>	#ifdef SHEEPSHAVER
977	>	std::vector<VIDEO_MODE>::const_iterator begin = VideoModes.begin();
978	>	cur_mode = distance(begin, i);
979	>	#endif
980		break;
981		}
982		}
983		if (i == end) { // not found, use first available mode
984	<	default_depth = VideoModes[0].depth;
985	<	default_id = VideoModes[0].resolution_id;
984	>	const VIDEO_MODE & mode = VideoModes[0];
985	>	default_depth = VIDEO_MODE_DEPTH;
986	>	default_id = VIDEO_MODE_RESOLUTION;
987	>	#ifdef SHEEPSHAVER
988	>	cur_mode = 0;
989	>	#endif
990		}
991
992	+	#ifdef SHEEPSHAVER
993	+	for (int i = 0; i < VideoModes.size(); i++)
994	+	VModes[i] = VideoModes[i];
995	+	VideoInfo *p = &VModes[VideoModes.size()];
996	+	p->viType = DIS_INVALID;        // End marker
997	+	p->viRowBytes = 0;
998	+	p->viXsize = p->viYsize = 0;
999	+	p->viAppleMode = 0;
1000	+	p->viAppleID = 0;
1001	+	#endif
1002	+
1003		#if DEBUG
1004		D(bug("Available video modes:\n"));
1005		for (i = VideoModes.begin(); i != end; ++i) {
1006	<	int bits = 1 << i->depth;
1006	>	const VIDEO_MODE & mode = (*i);
1007	>	int bits = 1 << VIDEO_MODE_DEPTH;
1008		if (bits == 16)
1009		bits = 15;
1010		else if (bits == 32)
1011		bits = 24;
1012	<	D(bug(" %dx%d (ID %02x), %d colors\n", i->x, i->y, i->resolution_id, 1 << bits));
1012	>	D(bug(" %dx%d (ID %02x), %d colors\n", VIDEO_MODE_X, VIDEO_MODE_Y, VIDEO_MODE_RESOLUTION, 1 << bits));
1013		}
1014		#endif
1015
1016		// Create SDL_monitor_desc for this (the only) display
1017	<	SDL_monitor_desc *monitor = new SDL_monitor_desc(VideoModes, default_depth, default_id);
1017	>	SDL_monitor_desc *monitor = new SDL_monitor_desc(VideoModes, (video_depth)default_depth, default_id);
1018		VideoMonitors.push_back(monitor);
1019
1020		// Open display
#	Line 746 | Line 1034 | void SDL_monitor_desc::video_close(void)
1034		// Stop redraw thread
1035		if (redraw_thread_active) {
1036		redraw_thread_cancel = true;
1037	<	//              SDL_WaitThread(redraw_thread, NULL); doesn't work
750	<	while (redraw_thread_cancel);
1037	>	SDL_WaitThread(redraw_thread, NULL);
1038		}
1039		redraw_thread_active = false;
1040
#	Line 797 | Line 1084 | void VideoQuitFullScreen(void)
1084		*  Mac VBL interrupt
1085		*/
1086
1087	+	/*
1088	+	*  Execute video VBL routine
1089	+	*/
1090	+
1091	+	#ifdef SHEEPSHAVER
1092	+	void VideoVBL(void)
1093	+	{
1094	+	// Emergency quit requested? Then quit
1095	+	if (emerg_quit)
1096	+	QuitEmulator();
1097	+
1098	+	// Temporarily give up frame buffer lock (this is the point where
1099	+	// we are suspended when the user presses Ctrl-Tab)
1100	+	UNLOCK_FRAME_BUFFER;
1101	+	LOCK_FRAME_BUFFER;
1102	+
1103	+	// Execute video VBL
1104	+	if (private_data != NULL && private_data->interruptsEnabled)
1105	+	VSLDoInterruptService(private_data->vslServiceID);
1106	+	}
1107	+	#else
1108		void VideoInterrupt(void)
1109		{
1110	+	// We must fill in the events queue in the same thread that did call SDL_SetVideoMode()
1111	+	SDL_PumpEvents();
1112	+
1113		// Emergency quit requested? Then quit
1114		if (emerg_quit)
1115		QuitEmulator();
#	Line 808 | Line 1119 | void VideoInterrupt(void)
1119		UNLOCK_FRAME_BUFFER;
1120		LOCK_FRAME_BUFFER;
1121		}
1122	+	#endif
1123
1124
1125		/*
1126		*  Set palette
1127		*/
1128
1129	+	#ifdef SHEEPSHAVER
1130	+	void video_set_palette(void)
1131	+	{
1132	+	monitor_desc * monitor = VideoMonitors[0];
1133	+	int n_colors = palette_size(monitor->get_current_mode().viAppleMode);
1134	+	uint8 pal[256 * 3];
1135	+	for (int c = 0; c < n_colors; c++) {
1136	+	pal[c*3 + 0] = mac_pal[c].red;
1137	+	pal[c*3 + 1] = mac_pal[c].green;
1138	+	pal[c*3 + 2] = mac_pal[c].blue;
1139	+	}
1140	+	monitor->set_palette(pal, n_colors);
1141	+	}
1142	+	#endif
1143	+
1144		void SDL_monitor_desc::set_palette(uint8 *pal, int num_in)
1145		{
1146	<	const video_mode &mode = get_current_mode();
1146	>	const VIDEO_MODE &mode = get_current_mode();
1147
1148		// FIXME: how can we handle the gamma ramp?
1149	<	if (mode.depth > VDEPTH_8BIT)
1149	>	if ((int)VIDEO_MODE_DEPTH > VIDEO_DEPTH_8BIT)
1150		return;
1151
1152		LOCK_PALETTE;
#	Line 844 | Line 1171 | void SDL_monitor_desc::set_palette(uint8
1171		}
1172
1173		#ifdef ENABLE_VOSF
1174	<	// We have to redraw everything because the interpretation of pixel values changed
1175	<	LOCK_VOSF;
1176	<	PFLAG_SET_ALL;
1177	<	UNLOCK_VOSF;
1178	<	memset(the_buffer_copy, 0, mode.bytes_per_row * mode.y);
1174	>	if (use_vosf) {
1175	>	// We have to redraw everything because the interpretation of pixel values changed
1176	>	LOCK_VOSF;
1177	>	PFLAG_SET_ALL;
1178	>	UNLOCK_VOSF;
1179	>	memset(the_buffer_copy, 0, VIDEO_MODE_ROW_BYTES * VIDEO_MODE_Y);
1180	>	}
1181		#endif
1182		}
1183
#	Line 863 | Line 1192 | void SDL_monitor_desc::set_palette(uint8
1192		*  Switch video mode
1193		*/
1194
1195	+	#ifdef SHEEPSHAVER
1196	+	int16 video_mode_change(VidLocals *csSave, uint32 ParamPtr)
1197	+	{
1198	+	/* return if no mode change */
1199	+	if ((csSave->saveData == ReadMacInt32(ParamPtr + csData)) &&
1200	+	(csSave->saveMode == ReadMacInt16(ParamPtr + csMode))) return noErr;
1201	+
1202	+	/* first find video mode in table */
1203	+	for (int i=0; VModes[i].viType != DIS_INVALID; i++) {
1204	+	if ((ReadMacInt16(ParamPtr + csMode) == VModes[i].viAppleMode) &&
1205	+	(ReadMacInt32(ParamPtr + csData) == VModes[i].viAppleID)) {
1206	+	csSave->saveMode = ReadMacInt16(ParamPtr + csMode);
1207	+	csSave->saveData = ReadMacInt32(ParamPtr + csData);
1208	+	csSave->savePage = ReadMacInt16(ParamPtr + csPage);
1209	+
1210	+	// Disable interrupts
1211	+	DisableInterrupt();
1212	+
1213	+	cur_mode = i;
1214	+	monitor_desc *monitor = VideoMonitors[0];
1215	+	monitor->switch_to_current_mode();
1216	+
1217	+	WriteMacInt32(ParamPtr + csBaseAddr, screen_base);
1218	+	csSave->saveBaseAddr=screen_base;
1219	+	csSave->saveData=VModes[cur_mode].viAppleID;/* First mode ... */
1220	+	csSave->saveMode=VModes[cur_mode].viAppleMode;
1221	+
1222	+	// Enable interrupts
1223	+	EnableInterrupt();
1224	+	return noErr;
1225	+	}
1226	+	}
1227	+	return paramErr;
1228	+	}
1229	+	#endif
1230	+
1231		void SDL_monitor_desc::switch_to_current_mode(void)
1232		{
1233		// Close and reopen display
#	Line 877 | Line 1242 | void SDL_monitor_desc::switch_to_current
1242
1243
1244		/*
1245	<	*  Translate key event to Mac keycode, returns -1 if no keycode was found
1246	<	*  and -2 if the key was recognized as a hotkey
1245	>	*  Can we set the MacOS cursor image into the window?
1246	>	*/
1247	>
1248	>	#ifdef SHEEPSHAVER
1249	>	bool video_can_change_cursor(void)
1250	>	{
1251	>	return (display_type == DISPLAY_WINDOW);
1252	>	}
1253	>	#endif
1254	>
1255	>
1256	>	/*
1257	>	*  Set cursor image for window
1258	>	*/
1259	>
1260	>	#ifdef SHEEPSHAVER
1261	>	void video_set_cursor(void)
1262	>	{
1263	>	cursor_changed = true;
1264	>	}
1265	>	#endif
1266	>
1267	>
1268	>	/*
1269	>	*  Keyboard-related utilify functions
1270		*/
1271
1272	+	static bool is_modifier_key(SDL_KeyboardEvent const & e)
1273	+	{
1274	+	switch (e.keysym.sym) {
1275	+	case SDLK_NUMLOCK:
1276	+	case SDLK_CAPSLOCK:
1277	+	case SDLK_SCROLLOCK:
1278	+	case SDLK_RSHIFT:
1279	+	case SDLK_LSHIFT:
1280	+	case SDLK_RCTRL:
1281	+	case SDLK_LCTRL:
1282	+	case SDLK_RALT:
1283	+	case SDLK_LALT:
1284	+	case SDLK_RMETA:
1285	+	case SDLK_LMETA:
1286	+	case SDLK_LSUPER:
1287	+	case SDLK_RSUPER:
1288	+	case SDLK_MODE:
1289	+	case SDLK_COMPOSE:
1290	+	return true;
1291	+	}
1292	+	return false;
1293	+	}
1294	+
1295		static bool is_ctrl_down(SDL_keysym const & ks)
1296		{
1297		return ctrl_down || (ks.mod & KMOD_CTRL);
1298		}
1299
1300	+
1301	+	/*
1302	+	*  Translate key event to Mac keycode, returns -1 if no keycode was found
1303	+	*  and -2 if the key was recognized as a hotkey
1304	+	*/
1305	+
1306		static int kc_decode(SDL_keysym const & ks, bool key_down)
1307		{
1308		switch (ks.sym) {
#	Line 955 | Line 1372 | static int kc_decode(SDL_keysym const &
1372		case SDLK_RCTRL: return 0x36;
1373		case SDLK_LSHIFT: return 0x38;
1374		case SDLK_RSHIFT: return 0x38;
1375	+	#if (defined(__APPLE__) && defined(__MACH__))
1376	+	case SDLK_LALT: return 0x3a;
1377	+	case SDLK_RALT: return 0x3a;
1378	+	case SDLK_LMETA: return 0x37;
1379	+	case SDLK_RMETA: return 0x37;
1380	+	#else
1381		case SDLK_LALT: return 0x37;
1382		case SDLK_RALT: return 0x37;
1383		case SDLK_LMETA: return 0x3a;
1384		case SDLK_RMETA: return 0x3a;
1385	+	#endif
1386		case SDLK_MENU: return 0x32;
1387		case SDLK_CAPSLOCK: return 0x39;
1388		case SDLK_NUMLOCK: return 0x47;
#	Line 1021 | Line 1445 | static int event2keycode(SDL_KeyboardEve
1445
1446		static void handle_events(void)
1447		{
1448	<	SDL_Event event;
1449	<	while (SDL_PollEvent(&event)) {
1450	<	switch (event.type) {
1448	>	SDL_Event events[10];
1449	>	const int n_max_events = sizeof(events) / sizeof(events[0]);
1450	>	int n_events;
1451	>
1452	>	while ((n_events = SDL_PeepEvents(events, n_max_events, SDL_GETEVENT, sdl_eventmask)) > 0) {
1453	>	for (int i = 0; i < n_events; i++) {
1454	>	SDL_Event const & event = events[i];
1455	>	switch (event.type) {
1456
1457		// Mouse button
1458		case SDL_MOUSEBUTTONDOWN: {
#	Line 1060 | Line 1489 | static void handle_events(void)
1489		// Keyboard
1490		case SDL_KEYDOWN: {
1491		int code = -1;
1492	<	if (use_keycodes) {
1492	>	if (use_keycodes && !is_modifier_key(event.key)) {
1493		if (event2keycode(event.key, true) != -2)       // This is called to process the hotkeys
1494		code = keycode_table[event.key.keysym.scancode & 0xff];
1495		} else
#	Line 1088 | Line 1517 | static void handle_events(void)
1517		}
1518		case SDL_KEYUP: {
1519		int code = -1;
1520	<	if (use_keycodes) {
1520	>	if (use_keycodes && !is_modifier_key(event.key)) {
1521		if (event2keycode(event.key, false) != -2)      // This is called to process the hotkeys
1522		code = keycode_table[event.key.keysym.scancode & 0xff];
1523		} else
1524		code = event2keycode(event.key, false);
1525	<	if (code >= 0 && code != 0x39) {        // Don't propagate Caps Lock releases
1526	<	ADBKeyUp(code);
1525	>	if (code >= 0) {
1526	>	if (code == 0x39) {     // Caps Lock released
1527	>	if (caps_on) {
1528	>	ADBKeyUp(code);
1529	>	caps_on = false;
1530	>	} else {
1531	>	ADBKeyDown(code);
1532	>	caps_on = true;
1533	>	}
1534	>	} else
1535	>	ADBKeyUp(code);
1536		if (code == 0x36)
1537		ctrl_down = false;
1538		}
#	Line 1104 | Line 1542 | static void handle_events(void)
1542		// Hidden parts exposed, force complete refresh of window
1543		case SDL_VIDEOEXPOSE:
1544		if (display_type == DISPLAY_WINDOW) {
1545	<	const video_mode &mode = VideoMonitors[0]->get_current_mode();
1545	>	const VIDEO_MODE &mode = VideoMonitors[0]->get_current_mode();
1546		#ifdef ENABLE_VOSF
1547		if (use_vosf) {                 // VOSF refresh
1548		LOCK_VOSF;
1549		PFLAG_SET_ALL;
1550		UNLOCK_VOSF;
1551	<	memset(the_buffer_copy, 0, mode.bytes_per_row * mode.y);
1551	>	memset(the_buffer_copy, 0, VIDEO_MODE_ROW_BYTES * VIDEO_MODE_Y);
1552		}
1553		else
1554		#endif
1555	<	memset(the_buffer_copy, 0, mode.bytes_per_row * mode.y);
1555	>	memset(the_buffer_copy, 0, VIDEO_MODE_ROW_BYTES * VIDEO_MODE_Y);
1556		}
1557		break;
1558
#	Line 1123 | Line 1561 | static void handle_events(void)
1561		ADBKeyDown(0x7f);       // Power key
1562		ADBKeyUp(0x7f);
1563		break;
1564	+	}
1565		}
1566		}
1567		}
#	Line 1137 | Line 1576 | static void update_display_static(driver
1576		{
1577		// Incremental update code
1578		int wide = 0, high = 0, x1, x2, y1, y2, i, j;
1579	<	const video_mode &mode = drv->mode;
1580	<	int bytes_per_row = mode.bytes_per_row;
1579	>	const VIDEO_MODE &mode = drv->mode;
1580	>	int bytes_per_row = VIDEO_MODE_ROW_BYTES;
1581		uint8 *p, *p2;
1582
1583		// Check for first line from top and first line from bottom that have changed
1584		y1 = 0;
1585	<	for (j=0; j<mode.y; j++) {
1585	>	for (j=0; j<VIDEO_MODE_Y; j++) {
1586		if (memcmp(&the_buffer[j * bytes_per_row], &the_buffer_copy[j * bytes_per_row], bytes_per_row)) {
1587		y1 = j;
1588		break;
1589		}
1590		}
1591		y2 = y1 - 1;
1592	<	for (j=mode.y-1; j>=y1; j--) {
1592	>	for (j=VIDEO_MODE_Y-1; j>=y1; j--) {
1593		if (memcmp(&the_buffer[j * bytes_per_row], &the_buffer_copy[j * bytes_per_row], bytes_per_row)) {
1594		y2 = j;
1595		break;
#	Line 1160 | Line 1599 | static void update_display_static(driver
1599
1600		// Check for first column from left and first column from right that have changed
1601		if (high) {
1602	<	if (mode.depth < VDEPTH_8BIT) {
1602	>	if ((int)VIDEO_MODE_DEPTH < VIDEO_DEPTH_8BIT) {
1603		const int src_bytes_per_row = bytes_per_row;
1604		const int dst_bytes_per_row = drv->s->pitch;
1605	<	const int pixels_per_byte = mode.x / src_bytes_per_row;
1605	>	const int pixels_per_byte = VIDEO_MODE_X / src_bytes_per_row;
1606
1607	<	x1 = mode.x / pixels_per_byte;
1607	>	x1 = VIDEO_MODE_X / pixels_per_byte;
1608		for (j = y1; j <= y2; j++) {
1609		p = &the_buffer[j * bytes_per_row];
1610		p2 = &the_buffer_copy[j * bytes_per_row];
#	Line 1183 | Line 1622 | static void update_display_static(driver
1622		p2 = &the_buffer_copy[j * bytes_per_row];
1623		p += bytes_per_row;
1624		p2 += bytes_per_row;
1625	<	for (i = (mode.x / pixels_per_byte); i > x2; i--) {
1625	>	for (i = (VIDEO_MODE_X / pixels_per_byte); i > x2; i--) {
1626		p--; p2--;
1627		if (*p != *p2) {
1628		x2 = i;
#	Line 1221 | Line 1660 | static void update_display_static(driver
1660		}
1661
1662		} else {
1663	<	const int bytes_per_pixel = mode.bytes_per_row / mode.x;
1663	>	const int bytes_per_pixel = VIDEO_MODE_ROW_BYTES / VIDEO_MODE_X;
1664
1665	<	x1 = mode.x;
1665	>	x1 = VIDEO_MODE_X;
1666		for (j=y1; j<=y2; j++) {
1667		p = &the_buffer[j * bytes_per_row];
1668		p2 = &the_buffer_copy[j * bytes_per_row];
#	Line 1241 | Line 1680 | static void update_display_static(driver
1680		p2 = &the_buffer_copy[j * bytes_per_row];
1681		p += bytes_per_row;
1682		p2 += bytes_per_row;
1683	<	for (i=mode.x*bytes_per_pixel; i>x2*bytes_per_pixel; i--) {
1683	>	for (i=VIDEO_MODE_X*bytes_per_pixel; i>x2*bytes_per_pixel; i--) {
1684		p--;
1685		p2--;
1686		if (*p != *p2) {
#	Line 1401 | Line 1840 | static void VideoRefreshInit(void)
1840		}
1841		}
1842
1843	+	const int VIDEO_REFRESH_HZ = 60;
1844	+	const int VIDEO_REFRESH_DELAY = 1000000 / VIDEO_REFRESH_HZ;
1845	+
1846		static int redraw_func(void *arg)
1847		{
1848		uint64 start = GetTicks_usec();
1849		int64 ticks = 0;
1850	+	uint64 next = GetTicks_usec() + VIDEO_REFRESH_DELAY;
1851
1852		while (!redraw_thread_cancel) {
1853
1854		// Wait
1855	<	Delay_usec(16667);
1855	>	next += VIDEO_REFRESH_DELAY;
1856	>	int64 delay = next - GetTicks_usec();
1857	>	if (delay > 0)
1858	>	Delay_usec(delay);
1859	>	else if (delay < -VIDEO_REFRESH_DELAY)
1860	>	next = GetTicks_usec();
1861	>	ticks++;
1862
1863		// Handle SDL events
1864		handle_events();
1865
1866		// Refresh display
1867		video_refresh();
1868	<	ticks++;
1868	>
1869	>	#ifdef SHEEPSHAVER
1870	>	// Set new cursor image if it was changed
1871	>	if (cursor_changed && sdl_cursor) {
1872	>	cursor_changed = false;
1873	>	SDL_FreeCursor(sdl_cursor);
1874	>	sdl_cursor = SDL_CreateCursor(MacCursor + 4, MacCursor + 36, 16, 16, MacCursor[2], MacCursor[3]);
1875	>	if (sdl_cursor)
1876	>	SDL_SetCursor(sdl_cursor);
1877	>	}
1878	>	#endif
1879
1880		// Set new palette if it was changed
1881		handle_palette_changes();
#	Line 1424 | Line 1883 | static int redraw_func(void *arg)
1883
1884		uint64 end = GetTicks_usec();
1885		D(bug("%lld refreshes in %lld usec = %f refreshes/sec\n", ticks, end - start, ticks * 1000000.0 / (end - start)));
1427	–	redraw_thread_cancel = false;
1886		return 0;
1887		}

Diff Legend

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