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.2 by gbeauche, 2004-06-23T22:37:33Z vs.
Revision 1.6 by gbeauche, 2004-06-24T22:38:42Z

#	Line 35 | Line 35
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	+	*  - Move generic Native QuickDraw acceleration routines to gfxaccel.cpp
41		*/
42
43		#include "sysdeps.h"
#	Line 43 | Line 46
46		#include <SDL_mutex.h>
47		#include <SDL_thread.h>
48		#include <errno.h>
49	+	#include <vector>
50
51		#include "cpu_emulation.h"
52		#include "main.h"
#	Line 51 | Line 55
55		#include "prefs.h"
56		#include "user_strings.h"
57		#include "video.h"
58	+	#include "video_defs.h"
59		#include "video_blit.h"
60
61		#define DEBUG 0
#	Line 58 | Line 63
63
64
65		// Supported video modes
66	<	static vector<video_mode> VideoModes;
66	>	using std::vector;
67	>	static vector<VIDEO_MODE> VideoModes;
68
69		// Display types
70	+	#ifdef SHEEPSHAVER
71		enum {
72	<	DISPLAY_WINDOW, // windowed display
73	<	DISPLAY_SCREEN  // fullscreen display
72	>	DISPLAY_WINDOW = DIS_WINDOW,                                    // windowed display
73	>	DISPLAY_SCREEN = DIS_SCREEN                                             // fullscreen display
74		};
75	+	extern int display_type;                                                        // See enum above
76	+	#else
77	+	enum {
78	+	DISPLAY_WINDOW,                                                                 // windowed display
79	+	DISPLAY_SCREEN                                                                  // fullscreen display
80	+	};
81	+	static int display_type = DISPLAY_WINDOW;                       // See enum above
82	+	#endif
83
84		// Constants
85		const char KEYCODE_FILE_NAME[] = DATADIR "/keycodes";
#	Line 75 | Line 90 | static int32 frame_skip;                                                       // Prefs
90		static int16 mouse_wheel_mode;
91		static int16 mouse_wheel_lines;
92
78	–	static int display_type = DISPLAY_WINDOW;                       // See enum above
93		static uint8 *the_buffer = NULL;                                        // Mac frame buffer (where MacOS draws into)
94		static uint8 *the_buffer_copy = NULL;                           // Copy of Mac frame buffer (for refreshed modes)
95		static uint32 the_buffer_size;                                          // Size of allocated the_buffer
#	Line 103 | Line 117 | static int keycode_table[256];                                         // X
117
118		// SDL variables
119		static int screen_depth;                                                        // Depth of current screen
120	+	static SDL_Cursor *sdl_cursor;                                          // Copy of Mac cursor
121	+	static volatile bool cursor_changed = false;            // Flag: cursor changed, redraw_func must update the cursor
122		static SDL_Color sdl_palette[256];                                      // Color palette to be used as CLUT and gamma table
123		static bool sdl_palette_changed = false;                        // Flag: Palette changed, redraw thread must set new colors
124		static const int sdl_eventmask = SDL_MOUSEBUTTONDOWNMASK | SDL_MOUSEBUTTONUPMASK | SDL_MOUSEMOTIONMASK | SDL_KEYUPMASK | SDL_KEYDOWNMASK | SDL_VIDEOEXPOSEMASK | SDL_QUITMASK;
#	Line 130 | Line 146 | extern void SysMountFirstFloppy(void);
146
147
148		/*
149	+	*  SheepShaver glue
150	+	*/
151	+
152	+	#ifdef SHEEPSHAVER
153	+	// Color depth modes type
154	+	typedef int video_depth;
155	+
156	+	// 1, 2, 4 and 8 bit depths use a color palette
157	+	static inline bool IsDirectMode(VIDEO_MODE const & mode)
158	+	{
159	+	return IsDirectMode(mode.viAppleMode);
160	+	}
161	+
162	+	// Abstract base class representing one (possibly virtual) monitor
163	+	// ("monitor" = rectangular display with a contiguous frame buffer)
164	+	class monitor_desc {
165	+	public:
166	+	monitor_desc(const vector<VIDEO_MODE> &available_modes, video_depth default_depth, uint32 default_id) {}
167	+	virtual ~monitor_desc() {}
168	+
169	+	// Get current Mac frame buffer base address
170	+	uint32 get_mac_frame_base(void) const {return screen_base;}
171	+
172	+	// Set Mac frame buffer base address (called from switch_to_mode())
173	+	void set_mac_frame_base(uint32 base) {screen_base = base;}
174	+
175	+	// Get current video mode
176	+	const VIDEO_MODE &get_current_mode(void) const {return VModes[cur_mode];}
177	+
178	+	// Called by the video driver to switch the video mode on this display
179	+	// (must call set_mac_frame_base())
180	+	virtual void switch_to_current_mode(void) = 0;
181	+
182	+	// Called by the video driver to set the color palette (in indexed modes)
183	+	// or the gamma table (in direct modes)
184	+	virtual void set_palette(uint8 *pal, int num) = 0;
185	+	};
186	+
187	+	// Vector of pointers to available monitor descriptions, filled by VideoInit()
188	+	static vector<monitor_desc *> VideoMonitors;
189	+
190	+	// Find Apple mode matching best specified dimensions
191	+	static int find_apple_resolution(int xsize, int ysize)
192	+	{
193	+	int apple_id;
194	+	if (xsize < 800)
195	+	apple_id = APPLE_640x480;
196	+	else if (xsize < 1024)
197	+	apple_id = APPLE_800x600;
198	+	else if (xsize < 1152)
199	+	apple_id = APPLE_1024x768;
200	+	else if (xsize < 1280) {
201	+	if (ysize < 900)
202	+	apple_id = APPLE_1152x768;
203	+	else
204	+	apple_id = APPLE_1152x900;
205	+	}
206	+	else if (xsize < 1600)
207	+	apple_id = APPLE_1280x1024;
208	+	else
209	+	apple_id = APPLE_1600x1200;
210	+	return apple_id;
211	+	}
212	+
213	+	// Set parameters to specified Apple mode
214	+	static void set_apple_resolution(int apple_id, int &xsize, int &ysize)
215	+	{
216	+	switch (apple_id) {
217	+	case APPLE_640x480:
218	+	xsize = 640;
219	+	ysize = 480;
220	+	break;
221	+	case APPLE_800x600:
222	+	xsize = 800;
223	+	ysize = 600;
224	+	break;
225	+	case APPLE_1024x768:
226	+	xsize = 1024;
227	+	ysize = 768;
228	+	break;
229	+	case APPLE_1152x768:
230	+	xsize = 1152;
231	+	ysize = 768;
232	+	break;
233	+	case APPLE_1152x900:
234	+	xsize = 1152;
235	+	ysize = 900;
236	+	break;
237	+	case APPLE_1280x1024:
238	+	xsize = 1280;
239	+	ysize = 1024;
240	+	break;
241	+	case APPLE_1600x1200:
242	+	xsize = 1600;
243	+	ysize = 1200;
244	+	break;
245	+	default:
246	+	abort();
247	+	}
248	+	}
249	+
250	+	// Match Apple mode matching best specified dimensions
251	+	static int match_apple_resolution(int &xsize, int &ysize)
252	+	{
253	+	int apple_id = find_apple_resolution(xsize, ysize);
254	+	set_apple_resolution(apple_id, xsize, ysize);
255	+	return apple_id;
256	+	}
257	+
258	+	// Display error alert
259	+	static void ErrorAlert(int error)
260	+	{
261	+	ErrorAlert(GetString(error));
262	+	}
263	+	#endif
264	+
265	+
266	+	/*
267		*  monitor_desc subclass for SDL display
268		*/
269
270		class SDL_monitor_desc : public monitor_desc {
271		public:
272	<	SDL_monitor_desc(const vector<video_mode> &available_modes, video_depth default_depth, uint32 default_id) : monitor_desc(available_modes, default_depth, default_id) {}
272	>	SDL_monitor_desc(const vector<VIDEO_MODE> &available_modes, video_depth default_depth, uint32 default_id) : monitor_desc(available_modes, default_depth, default_id) {}
273		~SDL_monitor_desc() {}
274
275		virtual void switch_to_current_mode(void);
#	Line 150 | Line 284 | public:
284		*  Utility functions
285		*/
286
287	+	// Find palette size for given color depth
288	+	static int palette_size(int mode)
289	+	{
290	+	switch (mode) {
291	+	case VIDEO_DEPTH_1BIT: return 2;
292	+	case VIDEO_DEPTH_2BIT: return 4;
293	+	case VIDEO_DEPTH_4BIT: return 16;
294	+	case VIDEO_DEPTH_8BIT: return 256;
295	+	case VIDEO_DEPTH_16BIT: return 32;
296	+	case VIDEO_DEPTH_32BIT: return 256;
297	+	default: return 0;
298	+	}
299	+	}
300	+
301	+	// Return bytes per pixel for requested depth
302	+	static inline int bytes_per_pixel(int depth)
303	+	{
304	+	int bpp;
305	+	switch (depth) {
306	+	case 8:
307	+	bpp = 1;
308	+	break;
309	+	case 15: case 16:
310	+	bpp = 2;
311	+	break;
312	+	case 24: case 32:
313	+	bpp = 4;
314	+	break;
315	+	default:
316	+	abort();
317	+	}
318	+	return bpp;
319	+	}
320	+
321		// Map video_mode depth ID to numerical depth value
322		static int sdl_depth_of_video_depth(int video_depth)
323		{
324		int depth = -1;
325		switch (video_depth) {
326	<	case VDEPTH_1BIT:
326	>	case VIDEO_DEPTH_1BIT:
327		depth = 1;
328		break;
329	<	case VDEPTH_2BIT:
329	>	case VIDEO_DEPTH_2BIT:
330		depth = 2;
331		break;
332	<	case VDEPTH_4BIT:
332	>	case VIDEO_DEPTH_4BIT:
333		depth = 4;
334		break;
335	<	case VDEPTH_8BIT:
335	>	case VIDEO_DEPTH_8BIT:
336		depth = 8;
337		break;
338	<	case VDEPTH_16BIT:
338	>	case VIDEO_DEPTH_16BIT:
339		depth = 16;
340		break;
341	<	case VDEPTH_32BIT:
341	>	case VIDEO_DEPTH_32BIT:
342		depth = 32;
343		break;
344		default:
#	Line 179 | Line 347 | static int sdl_depth_of_video_depth(int
347		return depth;
348		}
349
350	+	// Check wether specified mode is available
351	+	static bool has_mode(int type, int width, int height)
352	+	{
353	+	// FIXME: no fullscreen support yet
354	+	if (type == DISPLAY_SCREEN)
355	+	return false;
356	+
357	+	#ifdef SHEEPSHAVER
358	+	// Filter out Classic resolutiosn
359	+	if (width == 512 && height == 384)
360	+	return false;
361	+
362	+	// Read window modes prefs
363	+	static uint32 window_modes = 0;
364	+	static uint32 screen_modes = 0;
365	+	if (window_modes == 0 || screen_modes == 0) {
366	+	window_modes = PrefsFindInt32("windowmodes");
367	+	screen_modes = PrefsFindInt32("screenmodes");
368	+	if (window_modes == 0 || screen_modes == 0)
369	+	window_modes |= 3;                      // Allow at least 640x480 and 800x600 window modes
370	+	}
371	+
372	+	if (type == DISPLAY_WINDOW) {
373	+	int apple_mask, apple_id = find_apple_resolution(width, height);
374	+	switch (apple_id) {
375	+	case APPLE_640x480:             apple_mask = 0x01; break;
376	+	case APPLE_800x600:             apple_mask = 0x02; break;
377	+	case APPLE_1024x768:    apple_mask = 0x04; break;
378	+	case APPLE_1152x768:    apple_mask = 0x40; break;
379	+	case APPLE_1152x900:    apple_mask = 0x08; break;
380	+	case APPLE_1280x1024:   apple_mask = 0x10; break;
381	+	case APPLE_1600x1200:   apple_mask = 0x20; break;
382	+	default:                                apple_mask = 0x00; break;
383	+	}
384	+	return (window_modes & apple_mask);
385	+	}
386	+	#else
387	+	return true;
388	+	#endif
389	+	return false;
390	+	}
391	+
392		// Add mode to list of supported modes
393	<	static void add_mode(uint32 width, uint32 height, uint32 resolution_id, uint32 bytes_per_row, video_depth depth)
393	>	static void add_mode(int type, int width, int height, int resolution_id, int bytes_per_row, int depth)
394		{
395	<	video_mode mode;
396	<	mode.x = width;
397	<	mode.y = height;
398	<	mode.resolution_id = resolution_id;
399	<	mode.bytes_per_row = bytes_per_row;
400	<	mode.depth = depth;
395	>	// Filter out unsupported modes
396	>	if (!has_mode(type, width, height))
397	>	return;
398	>
399	>	// Fill in VideoMode entry
400	>	VIDEO_MODE mode;
401	>	#ifdef SHEEPSHAVER
402	>	// Recalculate dimensions to fit Apple modes
403	>	resolution_id = match_apple_resolution(width, height);
404	>	mode.viType = type;
405	>	#endif
406	>	VIDEO_MODE_X = width;
407	>	VIDEO_MODE_Y = height;
408	>	VIDEO_MODE_RESOLUTION = resolution_id;
409	>	VIDEO_MODE_ROW_BYTES = bytes_per_row;
410	>	VIDEO_MODE_DEPTH = depth;
411		VideoModes.push_back(mode);
412		}
413
414		// Add standard list of windowed modes for given color depth
415	<	static void add_window_modes(video_depth depth)
415	>	static void add_window_modes(int depth)
416		{
417	<	add_mode(512, 384, 0x80, TrivialBytesPerRow(512, depth), depth);
418	<	add_mode(640, 480, 0x81, TrivialBytesPerRow(640, depth), depth);
419	<	add_mode(800, 600, 0x82, TrivialBytesPerRow(800, depth), depth);
420	<	add_mode(1024, 768, 0x83, TrivialBytesPerRow(1024, depth), depth);
421	<	add_mode(1152, 870, 0x84, TrivialBytesPerRow(1152, depth), depth);
422	<	add_mode(1280, 1024, 0x85, TrivialBytesPerRow(1280, depth), depth);
423	<	add_mode(1600, 1200, 0x86, TrivialBytesPerRow(1600, depth), depth);
417	>	video_depth vdepth = (video_depth)depth;
418	>	add_mode(DISPLAY_WINDOW, 512, 384, 0x80, TrivialBytesPerRow(512, vdepth), depth);
419	>	add_mode(DISPLAY_WINDOW, 640, 480, 0x81, TrivialBytesPerRow(640, vdepth), depth);
420	>	add_mode(DISPLAY_WINDOW, 800, 600, 0x82, TrivialBytesPerRow(800, vdepth), depth);
421	>	add_mode(DISPLAY_WINDOW, 1024, 768, 0x83, TrivialBytesPerRow(1024, vdepth), depth);
422	>	add_mode(DISPLAY_WINDOW, 1152, 870, 0x84, TrivialBytesPerRow(1152, vdepth), depth);
423	>	add_mode(DISPLAY_WINDOW, 1280, 1024, 0x85, TrivialBytesPerRow(1280, vdepth), depth);
424	>	add_mode(DISPLAY_WINDOW, 1600, 1200, 0x86, TrivialBytesPerRow(1600, vdepth), depth);
425		}
426
427		// Set Mac frame layout and base address (uses the_buffer/MacFrameBaseMac)
428	<	static void set_mac_frame_buffer(SDL_monitor_desc &monitor, video_depth depth, bool native_byte_order)
428	>	static void set_mac_frame_buffer(SDL_monitor_desc &monitor, int depth, bool native_byte_order)
429		{
430		#if !REAL_ADDRESSING && !DIRECT_ADDRESSING
431		int layout = FLAYOUT_DIRECT;
432	<	if (depth == VDEPTH_16BIT)
432	>	if (depth == VIDEO_DEPTH_16BIT)
433		layout = (screen_depth == 15) ? FLAYOUT_HOST_555 : FLAYOUT_HOST_565;
434	<	else if (depth == VDEPTH_32BIT)
434	>	else if (depth == VIDEO_DEPTH_32BIT)
435		layout = (screen_depth == 24) ? FLAYOUT_HOST_888 : FLAYOUT_DIRECT;
436		if (native_byte_order)
437		MacFrameLayout = layout;
#	Line 219 | Line 440 | static void set_mac_frame_buffer(SDL_mon
440		monitor.set_mac_frame_base(MacFrameBaseMac);
441
442		// Set variables used by UAE memory banking
443	<	const video_mode &mode = monitor.get_current_mode();
443	>	const VIDEO_MODE &mode = monitor.get_current_mode();
444		MacFrameBaseHost = the_buffer;
445	<	MacFrameSize = mode.bytes_per_row * mode.y;
445	>	MacFrameSize = VIDEO_MODE_ROW_BYTES * VIDEO_MODE_Y;
446		InitFrameBufferMapping();
447		#else
448		monitor.set_mac_frame_base(Host2MacAddr(the_buffer));
#	Line 270 | Line 491 | public:
491
492		public:
493		SDL_monitor_desc &monitor; // Associated video monitor
494	<	const video_mode &mode;    // Video mode handled by the driver
494	>	const VIDEO_MODE &mode;    // Video mode handled by the driver
495
496		bool init_ok;   // Initialization succeeded (we can't use exceptions because of -fomit-frame-pointer)
497		SDL_Surface *s; // The surface we draw into
#	Line 358 | Line 579 | driver_base::~driver_base()
579		// Palette has changed
580		void driver_base::update_palette(void)
581		{
582	<	const video_mode &mode = monitor.get_current_mode();
582	>	const VIDEO_MODE &mode = monitor.get_current_mode();
583
584	<	if (mode.depth <= VDEPTH_8BIT)
584	>	if (VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT)
585		SDL_SetPalette(s, SDL_PHYSPAL, sdl_palette, 0, 256);
586		}
587
#	Line 383 | Line 604 | void driver_base::restore_mouse_accel(vo
604		driver_window::driver_window(SDL_monitor_desc &m)
605		: driver_base(m), mouse_grabbed(false)
606		{
607	<	int width = mode.x, height = mode.y;
607	>	int width = VIDEO_MODE_X, height = VIDEO_MODE_Y;
608		int aligned_width = (width + 15) & ~15;
609		int aligned_height = (height + 15) & ~15;
610
#	Line 391 | Line 612 | driver_window::driver_window(SDL_monitor
612		ADBSetRelMouseMode(mouse_grabbed);
613
614		// Create surface
615	<	int depth = (mode.depth <= VDEPTH_8BIT ? 8 : screen_depth);
615	>	int depth = (VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT ? 8 : screen_depth);
616		if ((s = SDL_SetVideoMode(width, height, depth, SDL_HWSURFACE)) == NULL)
617		return;
618
#	Line 411 | Line 632 | driver_window::driver_window(SDL_monitor
632		D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy));
633		#endif
634
635	<	// Set window name/class
636	<	set_window_name(STR_WINDOW_TITLE);
637	<
635	>	#ifdef SHEEPSHAVER
636	>	// Create cursor
637	>	if ((sdl_cursor = SDL_CreateCursor(MacCursor + 4, MacCursor + 36, 16, 16, 0, 0)) != NULL) {
638	>	SDL_SetCursor(sdl_cursor);
639	>	cursor_changed = false;
640	>	}
641	>	#else
642		// Hide cursor
643		SDL_ShowCursor(0);
644	+	#endif
645	+
646	+	// Set window name/class
647	+	set_window_name(STR_WINDOW_TITLE);
648
649		// Init blitting routines
650		SDL_PixelFormat *f = s->format;
#	Line 424 | Line 653 | driver_window::driver_window(SDL_monitor
653		visualFormat.Rmask = f->Rmask;
654		visualFormat.Gmask = f->Gmask;
655		visualFormat.Bmask = f->Bmask;
656	<	Screen_blitter_init(visualFormat, true, sdl_depth_of_video_depth(mode.depth));
656	>	Screen_blitter_init(visualFormat, true, sdl_depth_of_video_depth(VIDEO_MODE_DEPTH));
657
658		// Load gray ramp to 8->16/32 expand map
659		if (!IsDirectMode(mode))
#	Line 432 | Line 661 | driver_window::driver_window(SDL_monitor
661		ExpandMap[i] = SDL_MapRGB(f, i, i, i);
662
663		// Set frame buffer base
664	<	set_mac_frame_buffer(monitor, mode.depth, true);
664	>	set_mac_frame_buffer(monitor, VIDEO_MODE_DEPTH, true);
665
666		// Everything went well
667		init_ok = true;
#	Line 574 | Line 803 | static void keycode_init(void)
803		bool SDL_monitor_desc::video_open(void)
804		{
805		D(bug("video_open()\n"));
806	<	const video_mode &mode = get_current_mode();
806	>	const VIDEO_MODE &mode = get_current_mode();
807	>	#if DEBUG
808	>	D(bug("Current video mode:\n"));
809	>	D(bug(" %dx%d (ID %02x), %d bpp\n", VIDEO_MODE_X, VIDEO_MODE_Y, VIDEO_MODE_RESOLUTION, 1 << (VIDEO_MODE_DEPTH & 0x0f)));
810	>	#endif
811
812		// Create display driver object of requested type
813		switch (display_type) {
#	Line 608 | Line 841 | bool SDL_monitor_desc::video_open(void)
841
842		// Start redraw/input thread
843		redraw_thread_cancel = false;
844	<	redraw_thread_active = (SDL_CreateThread(redraw_func, NULL) != NULL);
844	>	redraw_thread_active = ((redraw_thread = SDL_CreateThread(redraw_func, NULL)) != NULL);
845		if (!redraw_thread_active) {
846		printf("FATAL: cannot create redraw thread\n");
847		return false;
#	Line 616 | Line 849 | bool SDL_monitor_desc::video_open(void)
849		return true;
850		}
851
852	+	#ifdef SHEEPSHAVER
853	+	bool VideoInit(void)
854	+	{
855	+	const bool classic = false;
856	+	#else
857		bool VideoInit(bool classic)
858		{
859	+	#endif
860		classic_mode = classic;
861
862		#ifdef ENABLE_VOSF
#	Line 641 | Line 880 | bool VideoInit(bool classic)
880		mouse_wheel_lines = PrefsFindInt32("mousewheellines");
881
882		// Get screen mode from preferences
883	<	const char *mode_str;
883	>	const char *mode_str = NULL;
884	>	#ifndef SHEEPSHAVER
885		if (classic_mode)
886		mode_str = "win/512/342";
887		else
888		mode_str = PrefsFindString("screen");
889	+	#endif
890
891		// Determine display type and default dimensions
892	<	int default_width = 512, default_height = 384;
892	>	int default_width, default_height;
893	>	if (classic) {
894	>	default_width = 512;
895	>	default_height = 384;
896	>	}
897	>	else {
898	>	default_width = 640;
899	>	default_height = 480;
900	>	}
901		display_type = DISPLAY_WINDOW;
902		if (mode_str) {
903		if (sscanf(mode_str, "win/%d/%d", &default_width, &default_height) == 2)
904		display_type = DISPLAY_WINDOW;
905		}
906		int max_width = 640, max_height = 480;
907	<	if (display_type == DISPLAY_SCREEN) {
908	<	SDL_Rect **modes = SDL_ListModes(NULL, SDL_FULLSCREEN | SDL_HWSURFACE);
909	<	if (modes && modes != (SDL_Rect **)-1) {
910	<	max_width = modes[0]->w;
911	<	max_height = modes[0]->h;
912	<	}
907	>	SDL_Rect **modes = SDL_ListModes(NULL, SDL_FULLSCREEN | SDL_HWSURFACE);
908	>	if (modes && modes != (SDL_Rect **)-1) {
909	>	max_width = modes[0]->w;
910	>	max_height = modes[0]->h;
911	>	if (default_width > max_width)
912	>	default_width = max_width;
913	>	if (default_height > max_height)
914	>	default_height = max_height;
915		}
916		if (default_width <= 0)
917		default_width = max_width;
#	Line 669 | Line 920 | bool VideoInit(bool classic)
920
921		// Mac screen depth follows X depth
922		screen_depth = SDL_GetVideoInfo()->vfmt->BitsPerPixel;
923	<	video_depth default_depth;
923	>	int default_depth;
924		switch (screen_depth) {
925		case 8:
926	<	default_depth = VDEPTH_8BIT;
926	>	default_depth = VIDEO_DEPTH_8BIT;
927		break;
928		case 15: case 16:
929	<	default_depth = VDEPTH_16BIT;
929	>	default_depth = VIDEO_DEPTH_16BIT;
930		break;
931		case 24: case 32:
932	<	default_depth = VDEPTH_32BIT;
932	>	default_depth = VIDEO_DEPTH_32BIT;
933		break;
934		default:
935	<	default_depth =  VDEPTH_1BIT;
935	>	default_depth =  VIDEO_DEPTH_1BIT;
936		break;
937		}
938
939		// Construct list of supported modes
940		if (display_type == DISPLAY_WINDOW) {
941		if (classic)
942	<	add_mode(512, 342, 0x80, 64, VDEPTH_1BIT);
942	>	add_mode(display_type, 512, 342, 0x80, 64, VIDEO_DEPTH_1BIT);
943		else {
944	<	for (int d = VDEPTH_1BIT; d <= default_depth; d++) {
945	<	int bpp = (d <= VDEPTH_8BIT ? 8 : sdl_depth_of_video_depth(d));
944	>	for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++) {
945	>	int bpp = (d <= VIDEO_DEPTH_8BIT ? 8 : sdl_depth_of_video_depth(d));
946		if (SDL_VideoModeOK(max_width, max_height, bpp, SDL_HWSURFACE))
947		add_window_modes(video_depth(d));
948		}
949		}
950		} else
951	<	add_mode(default_width, default_height, 0x80, TrivialBytesPerRow(default_width, default_depth), default_depth);
951	>	add_mode(display_type, default_width, default_height, 0x80, TrivialBytesPerRow(default_width, (video_depth)default_depth), default_depth);
952		if (VideoModes.empty()) {
953		ErrorAlert(STR_NO_XVISUAL_ERR);
954		return false;
#	Line 705 | Line 956 | bool VideoInit(bool classic)
956
957		// Find requested default mode with specified dimensions
958		uint32 default_id;
959	<	std::vector<video_mode>::const_iterator i, end = VideoModes.end();
959	>	std::vector<VIDEO_MODE>::const_iterator i, end = VideoModes.end();
960		for (i = VideoModes.begin(); i != end; ++i) {
961	<	if (i->x == default_width && i->y == default_height && i->depth == default_depth) {
962	<	default_id = i->resolution_id;
961	>	const VIDEO_MODE & mode = (*i);
962	>	if (VIDEO_MODE_X == default_width && VIDEO_MODE_Y == default_height && VIDEO_MODE_DEPTH == default_depth) {
963	>	default_id = VIDEO_MODE_RESOLUTION;
964	>	#ifdef SHEEPSHAVER
965	>	std::vector<VIDEO_MODE>::const_iterator begin = VideoModes.begin();
966	>	cur_mode = distance(begin, i);
967	>	#endif
968		break;
969		}
970		}
971		if (i == end) { // not found, use first available mode
972	<	default_depth = VideoModes[0].depth;
973	<	default_id = VideoModes[0].resolution_id;
972	>	const VIDEO_MODE & mode = VideoModes[0];
973	>	default_depth = VIDEO_MODE_DEPTH;
974	>	default_id = VIDEO_MODE_RESOLUTION;
975	>	#ifdef SHEEPSHAVER
976	>	cur_mode = 0;
977	>	#endif
978		}
979
980	+	#ifdef SHEEPSHAVER
981	+	for (int i = 0; i < VideoModes.size(); i++)
982	+	VModes[i] = VideoModes[i];
983	+	VideoInfo *p = &VModes[VideoModes.size()];
984	+	p->viType = DIS_INVALID;        // End marker
985	+	p->viRowBytes = 0;
986	+	p->viXsize = p->viYsize = 0;
987	+	p->viAppleMode = 0;
988	+	p->viAppleID = 0;
989	+	#endif
990	+
991		#if DEBUG
992		D(bug("Available video modes:\n"));
993		for (i = VideoModes.begin(); i != end; ++i) {
994	<	int bits = 1 << i->depth;
994	>	const VIDEO_MODE & mode = (*i);
995	>	int bits = 1 << VIDEO_MODE_DEPTH;
996		if (bits == 16)
997		bits = 15;
998		else if (bits == 32)
999		bits = 24;
1000	<	D(bug(" %dx%d (ID %02x), %d colors\n", i->x, i->y, i->resolution_id, 1 << bits));
1000	>	D(bug(" %dx%d (ID %02x), %d colors\n", VIDEO_MODE_X, VIDEO_MODE_Y, VIDEO_MODE_RESOLUTION, 1 << bits));
1001		}
1002		#endif
1003
1004		// Create SDL_monitor_desc for this (the only) display
1005	<	SDL_monitor_desc *monitor = new SDL_monitor_desc(VideoModes, default_depth, default_id);
1005	>	SDL_monitor_desc *monitor = new SDL_monitor_desc(VideoModes, (video_depth)default_depth, default_id);
1006		VideoMonitors.push_back(monitor);
1007
1008		// Open display
#	Line 750 | Line 1022 | void SDL_monitor_desc::video_close(void)
1022		// Stop redraw thread
1023		if (redraw_thread_active) {
1024		redraw_thread_cancel = true;
1025	<	//              SDL_WaitThread(redraw_thread, NULL); doesn't work
754	<	while (redraw_thread_cancel);
1025	>	SDL_WaitThread(redraw_thread, NULL);
1026		}
1027		redraw_thread_active = false;
1028
#	Line 801 | Line 1072 | void VideoQuitFullScreen(void)
1072		*  Mac VBL interrupt
1073		*/
1074
1075	+	/*
1076	+	*  Execute video VBL routine
1077	+	*/
1078	+
1079	+	#ifdef SHEEPSHAVER
1080	+	void VideoVBL(void)
1081	+	{
1082	+	// Emergency quit requested? Then quit
1083	+	if (emerg_quit)
1084	+	QuitEmulator();
1085	+
1086	+	// Temporarily give up frame buffer lock (this is the point where
1087	+	// we are suspended when the user presses Ctrl-Tab)
1088	+	UNLOCK_FRAME_BUFFER;
1089	+	LOCK_FRAME_BUFFER;
1090	+
1091	+	// Execute video VBL
1092	+	if (private_data != NULL && private_data->interruptsEnabled)
1093	+	VSLDoInterruptService(private_data->vslServiceID);
1094	+	}
1095	+	#else
1096		void VideoInterrupt(void)
1097		{
1098		// We must fill in the events queue in the same thread that did call SDL_SetVideoMode()
#	Line 815 | Line 1107 | void VideoInterrupt(void)
1107		UNLOCK_FRAME_BUFFER;
1108		LOCK_FRAME_BUFFER;
1109		}
1110	+	#endif
1111
1112
1113		/*
1114		*  Set palette
1115		*/
1116
1117	+	#ifdef SHEEPSHAVER
1118	+	void video_set_palette(void)
1119	+	{
1120	+	monitor_desc * monitor = VideoMonitors[0];
1121	+	int n_colors = palette_size(monitor->get_current_mode().viAppleMode);
1122	+	uint8 pal[256 * 3];
1123	+	for (int c = 0; c < n_colors; c++) {
1124	+	pal[c*3 + 0] = mac_pal[c].red;
1125	+	pal[c*3 + 1] = mac_pal[c].green;
1126	+	pal[c*3 + 2] = mac_pal[c].blue;
1127	+	}
1128	+	monitor->set_palette(pal, n_colors);
1129	+	}
1130	+	#endif
1131	+
1132		void SDL_monitor_desc::set_palette(uint8 *pal, int num_in)
1133		{
1134	<	const video_mode &mode = get_current_mode();
1134	>	const VIDEO_MODE &mode = get_current_mode();
1135
1136		// FIXME: how can we handle the gamma ramp?
1137	<	if (mode.depth > VDEPTH_8BIT)
1137	>	if (VIDEO_MODE_DEPTH > VIDEO_DEPTH_8BIT)
1138		return;
1139
1140		LOCK_PALETTE;
#	Line 855 | Line 1163 | void SDL_monitor_desc::set_palette(uint8
1163		LOCK_VOSF;
1164		PFLAG_SET_ALL;
1165		UNLOCK_VOSF;
1166	<	memset(the_buffer_copy, 0, mode.bytes_per_row * mode.y);
1166	>	memset(the_buffer_copy, 0, VIDEO_MODE_ROW_BYTES * VIDEO_MODE_Y);
1167		#endif
1168		}
1169
#	Line 870 | Line 1178 | void SDL_monitor_desc::set_palette(uint8
1178		*  Switch video mode
1179		*/
1180
1181	+	#ifdef SHEEPSHAVER
1182	+	int16 video_mode_change(VidLocals *csSave, uint32 ParamPtr)
1183	+	{
1184	+	/* return if no mode change */
1185	+	if ((csSave->saveData == ReadMacInt32(ParamPtr + csData)) &&
1186	+	(csSave->saveMode == ReadMacInt16(ParamPtr + csMode))) return noErr;
1187	+
1188	+	/* first find video mode in table */
1189	+	for (int i=0; VModes[i].viType != DIS_INVALID; i++) {
1190	+	if ((ReadMacInt16(ParamPtr + csMode) == VModes[i].viAppleMode) &&
1191	+	(ReadMacInt32(ParamPtr + csData) == VModes[i].viAppleID)) {
1192	+	csSave->saveMode = ReadMacInt16(ParamPtr + csMode);
1193	+	csSave->saveData = ReadMacInt32(ParamPtr + csData);
1194	+	csSave->savePage = ReadMacInt16(ParamPtr + csPage);
1195	+
1196	+	// Disable interrupts
1197	+	DisableInterrupt();
1198	+
1199	+	cur_mode = i;
1200	+	monitor_desc *monitor = VideoMonitors[0];
1201	+	monitor->switch_to_current_mode();
1202	+
1203	+	WriteMacInt32(ParamPtr + csBaseAddr, screen_base);
1204	+	csSave->saveBaseAddr=screen_base;
1205	+	csSave->saveData=VModes[cur_mode].viAppleID;/* First mode ... */
1206	+	csSave->saveMode=VModes[cur_mode].viAppleMode;
1207	+
1208	+	// Enable interrupts
1209	+	EnableInterrupt();
1210	+	return noErr;
1211	+	}
1212	+	}
1213	+	return paramErr;
1214	+	}
1215	+	#endif
1216	+
1217		void SDL_monitor_desc::switch_to_current_mode(void)
1218		{
1219		// Close and reopen display
#	Line 884 | Line 1228 | void SDL_monitor_desc::switch_to_current
1228
1229
1230		/*
1231	+	*  Can we set the MacOS cursor image into the window?
1232	+	*/
1233	+
1234	+	#ifdef SHEEPSHAVER
1235	+	bool video_can_change_cursor(void)
1236	+	{
1237	+	return (display_type == DISPLAY_WINDOW);
1238	+	}
1239	+	#endif
1240	+
1241	+
1242	+	/*
1243	+	*  Set cursor image for window
1244	+	*/
1245	+
1246	+	#ifdef SHEEPSHAVER
1247	+	void video_set_cursor(void)
1248	+	{
1249	+	cursor_changed = true;
1250	+	}
1251	+	#endif
1252	+
1253	+
1254	+	/*
1255	+	*  Install graphics acceleration
1256	+	*/
1257	+
1258	+	#ifdef SHEEPSHAVER
1259	+	// Rectangle inversion
1260	+	template< int bpp >
1261	+	static inline void do_invrect(uint8 *dest, uint32 length)
1262	+	{
1263	+	#define INVERT_1(PTR, OFS) ((uint8  *)(PTR))[OFS] = ~((uint8  *)(PTR))[OFS]
1264	+	#define INVERT_2(PTR, OFS) ((uint16 *)(PTR))[OFS] = ~((uint16 *)(PTR))[OFS]
1265	+	#define INVERT_4(PTR, OFS) ((uint32 *)(PTR))[OFS] = ~((uint32 *)(PTR))[OFS]
1266	+	#define INVERT_8(PTR, OFS) ((uint64 *)(PTR))[OFS] = ~((uint64 *)(PTR))[OFS]
1267	+
1268	+	#ifndef UNALIGNED_PROFITABLE
1269	+	// Align on 16-bit boundaries
1270	+	if (bpp < 16 && (((uintptr)dest) & 1)) {
1271	+	INVERT_1(dest, 0);
1272	+	dest += 1; length -= 1;
1273	+	}
1274	+
1275	+	// Align on 32-bit boundaries
1276	+	if (bpp < 32 && (((uintptr)dest) & 2)) {
1277	+	INVERT_2(dest, 0);
1278	+	dest += 2; length -= 2;
1279	+	}
1280	+	#endif
1281	+
1282	+	// Invert 8-byte words
1283	+	if (length >= 8) {
1284	+	const int r = (length / 8) % 8;
1285	+	dest += r * 8;
1286	+
1287	+	int n = ((length / 8) + 7) / 8;
1288	+	switch (r) {
1289	+	case 0: do {
1290	+	dest += 64;
1291	+	INVERT_8(dest, -8);
1292	+	case 7: INVERT_8(dest, -7);
1293	+	case 6: INVERT_8(dest, -6);
1294	+	case 5: INVERT_8(dest, -5);
1295	+	case 4: INVERT_8(dest, -4);
1296	+	case 3: INVERT_8(dest, -3);
1297	+	case 2: INVERT_8(dest, -2);
1298	+	case 1: INVERT_8(dest, -1);
1299	+	} while (--n > 0);
1300	+	}
1301	+	}
1302	+
1303	+	// 32-bit cell to invert?
1304	+	if (length & 4) {
1305	+	INVERT_4(dest, 0);
1306	+	if (bpp <= 16)
1307	+	dest += 4;
1308	+	}
1309	+
1310	+	// 16-bit cell to invert?
1311	+	if (bpp <= 16 && (length & 2)) {
1312	+	INVERT_2(dest, 0);
1313	+	if (bpp <= 8)
1314	+	dest += 2;
1315	+	}
1316	+
1317	+	// 8-bit cell to invert?
1318	+	if (bpp <= 8 && (length & 1))
1319	+	INVERT_1(dest, 0);
1320	+
1321	+	#undef INVERT_1
1322	+	#undef INVERT_2
1323	+	#undef INVERT_4
1324	+	#undef INVERT_8
1325	+	}
1326	+
1327	+	void NQD_invrect(uint32 p)
1328	+	{
1329	+	D(bug("accl_invrect %08x\n", p));
1330	+
1331	+	// Get inversion parameters
1332	+	int16 dest_X = (int16)ReadMacInt16(p + acclDestRect + 2) - (int16)ReadMacInt16(p + acclDestBoundsRect + 2);
1333	+	int16 dest_Y = (int16)ReadMacInt16(p + acclDestRect + 0) - (int16)ReadMacInt16(p + acclDestBoundsRect + 0);
1334	+	int16 width  = (int16)ReadMacInt16(p + acclDestRect + 6) - (int16)ReadMacInt16(p + acclDestRect + 2);
1335	+	int16 height = (int16)ReadMacInt16(p + acclDestRect + 4) - (int16)ReadMacInt16(p + acclDestRect + 0);
1336	+	D(bug(" dest X %d, dest Y %d\n", dest_X, dest_Y));
1337	+	D(bug(" width %d, height %d, bytes_per_row %d\n", width, height, (int32)ReadMacInt32(p + acclDestRowBytes)));
1338	+
1339	+	//!!?? pen_mode == 14
1340	+
1341	+	// And perform the inversion
1342	+	const int bpp = bytes_per_pixel(ReadMacInt32(p + acclDestPixelSize));
1343	+	const int dest_row_bytes = (int32)ReadMacInt32(p + acclDestRowBytes);
1344	+	uint8 *dest = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + (dest_Y * dest_row_bytes) + (dest_X * bpp));
1345	+	width *= bpp;
1346	+	switch (bpp) {
1347	+	case 1:
1348	+	for (int i = 0; i < height; i++) {
1349	+	do_invrect<8>(dest, width);
1350	+	dest += dest_row_bytes;
1351	+	}
1352	+	break;
1353	+	case 2:
1354	+	for (int i = 0; i < height; i++) {
1355	+	do_invrect<16>(dest, width);
1356	+	dest += dest_row_bytes;
1357	+	}
1358	+	break;
1359	+	case 4:
1360	+	for (int i = 0; i < height; i++) {
1361	+	do_invrect<32>(dest, width);
1362	+	dest += dest_row_bytes;
1363	+	}
1364	+	break;
1365	+	}
1366	+	}
1367	+
1368	+	// Rectangle filling
1369	+	template< int bpp >
1370	+	static inline void do_fillrect(uint8 *dest, uint32 color, uint32 length)
1371	+	{
1372	+	#define FILL_1(PTR, OFS, VAL) ((uint8  *)(PTR))[OFS] = (VAL)
1373	+	#define FILL_2(PTR, OFS, VAL) ((uint16 *)(PTR))[OFS] = (VAL)
1374	+	#define FILL_4(PTR, OFS, VAL) ((uint32 *)(PTR))[OFS] = (VAL)
1375	+	#define FILL_8(PTR, OFS, VAL) ((uint64 *)(PTR))[OFS] = (VAL)
1376	+
1377	+	#ifndef UNALIGNED_PROFITABLE
1378	+	// Align on 16-bit boundaries
1379	+	if (bpp < 16 && (((uintptr)dest) & 1)) {
1380	+	FILL_1(dest, 0, color);
1381	+	dest += 1; length -= 1;
1382	+	}
1383	+
1384	+	// Align on 32-bit boundaries
1385	+	if (bpp < 32 && (((uintptr)dest) & 2)) {
1386	+	FILL_2(dest, 0, color);
1387	+	dest += 2; length -= 2;
1388	+	}
1389	+	#endif
1390	+
1391	+	// Fill 8-byte words
1392	+	if (length >= 8) {
1393	+	const uint64 c = (((uint64)color) << 32) | color;
1394	+	const int r = (length / 8) % 8;
1395	+	dest += r * 8;
1396	+
1397	+	int n = ((length / 8) + 7) / 8;
1398	+	switch (r) {
1399	+	case 0: do {
1400	+	dest += 64;
1401	+	FILL_8(dest, -8, c);
1402	+	case 7: FILL_8(dest, -7, c);
1403	+	case 6: FILL_8(dest, -6, c);
1404	+	case 5: FILL_8(dest, -5, c);
1405	+	case 4: FILL_8(dest, -4, c);
1406	+	case 3: FILL_8(dest, -3, c);
1407	+	case 2: FILL_8(dest, -2, c);
1408	+	case 1: FILL_8(dest, -1, c);
1409	+	} while (--n > 0);
1410	+	}
1411	+	}
1412	+
1413	+	// 32-bit cell to fill?
1414	+	if (length & 4) {
1415	+	FILL_4(dest, 0, color);
1416	+	if (bpp <= 16)
1417	+	dest += 4;
1418	+	}
1419	+
1420	+	// 16-bit cell to fill?
1421	+	if (bpp <= 16 && (length & 2)) {
1422	+	FILL_2(dest, 0, color);
1423	+	if (bpp <= 8)
1424	+	dest += 2;
1425	+	}
1426	+
1427	+	// 8-bit cell to fill?
1428	+	if (bpp <= 8 && (length & 1))
1429	+	FILL_1(dest, 0, color);
1430	+
1431	+	#undef FILL_1
1432	+	#undef FILL_2
1433	+	#undef FILL_4
1434	+	#undef FILL_8
1435	+	}
1436	+
1437	+	void NQD_fillrect(uint32 p)
1438	+	{
1439	+	D(bug("accl_fillrect %08x\n", p));
1440	+
1441	+	// Get filling parameters
1442	+	int16 dest_X = (int16)ReadMacInt16(p + acclDestRect + 2) - (int16)ReadMacInt16(p + acclDestBoundsRect + 2);
1443	+	int16 dest_Y = (int16)ReadMacInt16(p + acclDestRect + 0) - (int16)ReadMacInt16(p + acclDestBoundsRect + 0);
1444	+	int16 width  = (int16)ReadMacInt16(p + acclDestRect + 6) - (int16)ReadMacInt16(p + acclDestRect + 2);
1445	+	int16 height = (int16)ReadMacInt16(p + acclDestRect + 4) - (int16)ReadMacInt16(p + acclDestRect + 0);
1446	+	uint32 color = htonl(ReadMacInt32(p + acclPenMode) == 8 ? ReadMacInt32(p + acclForePen) : ReadMacInt32(p + acclBackPen));
1447	+	D(bug(" dest X %d, dest Y %d\n", dest_X, dest_Y));
1448	+	D(bug(" width %d, height %d\n", width, height));
1449	+	D(bug(" bytes_per_row %d color %08x\n", (int32)ReadMacInt32(p + acclDestRowBytes), color));
1450	+
1451	+	// And perform the fill
1452	+	const int bpp = bytes_per_pixel(ReadMacInt32(p + acclDestPixelSize));
1453	+	const int dest_row_bytes = (int32)ReadMacInt32(p + acclDestRowBytes);
1454	+	uint8 *dest = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + (dest_Y * dest_row_bytes) + (dest_X * bpp));
1455	+	width *= bpp;
1456	+	switch (bpp) {
1457	+	case 1:
1458	+	for (int i = 0; i < height; i++) {
1459	+	memset(dest, color, width);
1460	+	dest += dest_row_bytes;
1461	+	}
1462	+	break;
1463	+	case 2:
1464	+	for (int i = 0; i < height; i++) {
1465	+	do_fillrect<16>(dest, color, width);
1466	+	dest += dest_row_bytes;
1467	+	}
1468	+	break;
1469	+	case 4:
1470	+	for (int i = 0; i < height; i++) {
1471	+	do_fillrect<32>(dest, color, width);
1472	+	dest += dest_row_bytes;
1473	+	}
1474	+	break;
1475	+	}
1476	+	}
1477	+
1478	+	bool NQD_fillrect_hook(uint32 p)
1479	+	{
1480	+	D(bug("accl_fillrect_hook %08x\n", p));
1481	+
1482	+	// Check if we can accelerate this fillrect
1483	+	if (ReadMacInt32(p + 0x284) != 0 && ReadMacInt32(p + acclDestPixelSize) >= 8) {
1484	+	const int transfer_mode = ReadMacInt32(p + acclTransferMode);
1485	+	if (transfer_mode == 8) {
1486	+	// Fill
1487	+	WriteMacInt32(p + acclDrawProc, NativeTVECT(NATIVE_FILLRECT));
1488	+	return true;
1489	+	}
1490	+	else if (transfer_mode == 10) {
1491	+	// Invert
1492	+	WriteMacInt32(p + acclDrawProc, NativeTVECT(NATIVE_INVRECT));
1493	+	return true;
1494	+	}
1495	+	}
1496	+	return false;
1497	+	}
1498	+
1499	+	// Rectangle blitting
1500	+	// TODO: optimize for VOSF and target pixmap == screen
1501	+	void NQD_bitblt(uint32 p)
1502	+	{
1503	+	D(bug("accl_bitblt %08x\n", p));
1504	+
1505	+	// Get blitting parameters
1506	+	int16 src_X  = (int16)ReadMacInt16(p + acclSrcRect + 2) - (int16)ReadMacInt16(p + acclSrcBoundsRect + 2);
1507	+	int16 src_Y  = (int16)ReadMacInt16(p + acclSrcRect + 0) - (int16)ReadMacInt16(p + acclSrcBoundsRect + 0);
1508	+	int16 dest_X = (int16)ReadMacInt16(p + acclDestRect + 2) - (int16)ReadMacInt16(p + acclDestBoundsRect + 2);
1509	+	int16 dest_Y = (int16)ReadMacInt16(p + acclDestRect + 0) - (int16)ReadMacInt16(p + acclDestBoundsRect + 0);
1510	+	int16 width  = (int16)ReadMacInt16(p + acclDestRect + 6) - (int16)ReadMacInt16(p + acclDestRect + 2);
1511	+	int16 height = (int16)ReadMacInt16(p + acclDestRect + 4) - (int16)ReadMacInt16(p + acclDestRect + 0);
1512	+	D(bug(" src addr %08x, dest addr %08x\n", ReadMacInt32(p + acclSrcBaseAddr), ReadMacInt32(p + acclDestBaseAddr)));
1513	+	D(bug(" src X %d, src Y %d, dest X %d, dest Y %d\n", src_X, src_Y, dest_X, dest_Y));
1514	+	D(bug(" width %d, height %d\n", width, height));
1515	+
1516	+	// And perform the blit
1517	+	const int bpp = bytes_per_pixel(ReadMacInt32(p + acclSrcPixelSize));
1518	+	width *= bpp;
1519	+	if ((int32)ReadMacInt32(p + acclSrcRowBytes) > 0) {
1520	+	const int src_row_bytes = (int32)ReadMacInt32(p + acclSrcRowBytes);
1521	+	const int dst_row_bytes = (int32)ReadMacInt32(p + acclDestRowBytes);
1522	+	uint8 *src = Mac2HostAddr(ReadMacInt32(p + acclSrcBaseAddr) + (src_Y * src_row_bytes) + (src_X * bpp));
1523	+	uint8 *dst = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + (dest_Y * dst_row_bytes) + (dest_X * bpp));
1524	+	for (int i = 0; i < height; i++) {
1525	+	memmove(dst, src, width);
1526	+	src += src_row_bytes;
1527	+	dst += dst_row_bytes;
1528	+	}
1529	+	}
1530	+	else {
1531	+	const int src_row_bytes = -(int32)ReadMacInt32(p + acclSrcRowBytes);
1532	+	const int dst_row_bytes = -(int32)ReadMacInt32(p + acclDestRowBytes);
1533	+	uint8 *src = Mac2HostAddr(ReadMacInt32(p + acclSrcBaseAddr) + ((src_Y + height - 1) * src_row_bytes) + (src_X * bpp));
1534	+	uint8 *dst = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + ((dest_Y + height - 1) * dst_row_bytes) + (dest_X * bpp));
1535	+	for (int i = height - 1; i >= 0; i--) {
1536	+	memmove(dst, src, width);
1537	+	src -= src_row_bytes;
1538	+	dst -= dst_row_bytes;
1539	+	}
1540	+	}
1541	+	}
1542	+
1543	+	/*
1544	+	BitBlt transfer modes:
1545	+	0 : srcCopy
1546	+	1 : srcOr
1547	+	2 : srcXor
1548	+	3 : srcBic
1549	+	4 : notSrcCopy
1550	+	5 : notSrcOr
1551	+	6 : notSrcXor
1552	+	7 : notSrcBic
1553	+	32 : blend
1554	+	33 : addPin
1555	+	34 : addOver
1556	+	35 : subPin
1557	+	36 : transparent
1558	+	37 : adMax
1559	+	38 : subOver
1560	+	39 : adMin
1561	+	50 : hilite
1562	+	*/
1563	+
1564	+	bool NQD_bitblt_hook(uint32 p)
1565	+	{
1566	+	D(bug("accl_draw_hook %08x\n", p));
1567	+
1568	+	// Check if we can accelerate this bitblt
1569	+	if (ReadMacInt32(p + 0x018) + ReadMacInt32(p + 0x128) == 0 &&
1570	+	ReadMacInt32(p + 0x130) == 0 &&
1571	+	ReadMacInt32(p + acclSrcPixelSize) >= 8 &&
1572	+	ReadMacInt32(p + acclSrcPixelSize) == ReadMacInt32(p + acclDestPixelSize) &&
1573	+	(ReadMacInt32(p + acclSrcRowBytes) ^ ReadMacInt32(p + acclDestRowBytes)) >= 0 && // same sign?
1574	+	ReadMacInt32(p + acclTransferMode) == 0 &&                                                                               // srcCopy?
1575	+	ReadMacInt32(p + 0x15c) > 0) {
1576	+
1577	+	// Yes, set function pointer
1578	+	WriteMacInt32(p + acclDrawProc, NativeTVECT(NATIVE_BITBLT));
1579	+	return true;
1580	+	}
1581	+	return false;
1582	+	}
1583	+
1584	+	// Wait for graphics operation to finish
1585	+	bool NQD_sync_hook(uint32 arg)
1586	+	{
1587	+	D(bug("accl_sync_hook %08x\n", arg));
1588	+	return true;
1589	+	}
1590	+
1591	+	void VideoInstallAccel(void)
1592	+	{
1593	+	// Install acceleration hooks
1594	+	if (PrefsFindBool("gfxaccel")) {
1595	+	D(bug("Video: Installing acceleration hooks\n"));
1596	+	uint32 base;
1597	+
1598	+	SheepVar bitblt_hook_info(sizeof(accl_hook_info));
1599	+	base = bitblt_hook_info.addr();
1600	+	WriteMacInt32(base + 0, NativeTVECT(NATIVE_BITBLT_HOOK));
1601	+	WriteMacInt32(base + 4, NativeTVECT(NATIVE_SYNC_HOOK));
1602	+	WriteMacInt32(base + 8, ACCL_BITBLT);
1603	+	NQDMisc(6, bitblt_hook_info.ptr());
1604	+
1605	+	SheepVar fillrect_hook_info(sizeof(accl_hook_info));
1606	+	base = fillrect_hook_info.addr();
1607	+	WriteMacInt32(base + 0, NativeTVECT(NATIVE_FILLRECT_HOOK));
1608	+	WriteMacInt32(base + 4, NativeTVECT(NATIVE_SYNC_HOOK));
1609	+	WriteMacInt32(base + 8, ACCL_FILLRECT);
1610	+	NQDMisc(6, fillrect_hook_info.ptr());
1611	+	}
1612	+	}
1613	+	#endif
1614	+
1615	+
1616	+	/*
1617		*  Translate key event to Mac keycode, returns -1 if no keycode was found
1618		*  and -2 if the key was recognized as a hotkey
1619		*/
#	Line 1116 | Line 1846 | static void handle_events(void)
1846		// Hidden parts exposed, force complete refresh of window
1847		case SDL_VIDEOEXPOSE:
1848		if (display_type == DISPLAY_WINDOW) {
1849	<	const video_mode &mode = VideoMonitors[0]->get_current_mode();
1849	>	const VIDEO_MODE &mode = VideoMonitors[0]->get_current_mode();
1850		#ifdef ENABLE_VOSF
1851		if (use_vosf) {                 // VOSF refresh
1852		LOCK_VOSF;
1853		PFLAG_SET_ALL;
1854		UNLOCK_VOSF;
1855	<	memset(the_buffer_copy, 0, mode.bytes_per_row * mode.y);
1855	>	memset(the_buffer_copy, 0, VIDEO_MODE_ROW_BYTES * VIDEO_MODE_Y);
1856		}
1857		else
1858		#endif
1859	<	memset(the_buffer_copy, 0, mode.bytes_per_row * mode.y);
1859	>	memset(the_buffer_copy, 0, VIDEO_MODE_ROW_BYTES * VIDEO_MODE_Y);
1860		}
1861		break;
1862
#	Line 1150 | Line 1880 | static void update_display_static(driver
1880		{
1881		// Incremental update code
1882		int wide = 0, high = 0, x1, x2, y1, y2, i, j;
1883	<	const video_mode &mode = drv->mode;
1884	<	int bytes_per_row = mode.bytes_per_row;
1883	>	const VIDEO_MODE &mode = drv->mode;
1884	>	int bytes_per_row = VIDEO_MODE_ROW_BYTES;
1885		uint8 *p, *p2;
1886
1887		// Check for first line from top and first line from bottom that have changed
1888		y1 = 0;
1889	<	for (j=0; j<mode.y; j++) {
1889	>	for (j=0; j<VIDEO_MODE_Y; j++) {
1890		if (memcmp(&the_buffer[j * bytes_per_row], &the_buffer_copy[j * bytes_per_row], bytes_per_row)) {
1891		y1 = j;
1892		break;
1893		}
1894		}
1895		y2 = y1 - 1;
1896	<	for (j=mode.y-1; j>=y1; j--) {
1896	>	for (j=VIDEO_MODE_Y-1; j>=y1; j--) {
1897		if (memcmp(&the_buffer[j * bytes_per_row], &the_buffer_copy[j * bytes_per_row], bytes_per_row)) {
1898		y2 = j;
1899		break;
#	Line 1173 | Line 1903 | static void update_display_static(driver
1903
1904		// Check for first column from left and first column from right that have changed
1905		if (high) {
1906	<	if (mode.depth < VDEPTH_8BIT) {
1906	>	if (VIDEO_MODE_DEPTH < VIDEO_DEPTH_8BIT) {
1907		const int src_bytes_per_row = bytes_per_row;
1908		const int dst_bytes_per_row = drv->s->pitch;
1909	<	const int pixels_per_byte = mode.x / src_bytes_per_row;
1909	>	const int pixels_per_byte = VIDEO_MODE_X / src_bytes_per_row;
1910
1911	<	x1 = mode.x / pixels_per_byte;
1911	>	x1 = VIDEO_MODE_X / pixels_per_byte;
1912		for (j = y1; j <= y2; j++) {
1913		p = &the_buffer[j * bytes_per_row];
1914		p2 = &the_buffer_copy[j * bytes_per_row];
#	Line 1196 | Line 1926 | static void update_display_static(driver
1926		p2 = &the_buffer_copy[j * bytes_per_row];
1927		p += bytes_per_row;
1928		p2 += bytes_per_row;
1929	<	for (i = (mode.x / pixels_per_byte); i > x2; i--) {
1929	>	for (i = (VIDEO_MODE_X / pixels_per_byte); i > x2; i--) {
1930		p--; p2--;
1931		if (*p != *p2) {
1932		x2 = i;
#	Line 1234 | Line 1964 | static void update_display_static(driver
1964		}
1965
1966		} else {
1967	<	const int bytes_per_pixel = mode.bytes_per_row / mode.x;
1967	>	const int bytes_per_pixel = VIDEO_MODE_ROW_BYTES / VIDEO_MODE_X;
1968
1969	<	x1 = mode.x;
1969	>	x1 = VIDEO_MODE_X;
1970		for (j=y1; j<=y2; j++) {
1971		p = &the_buffer[j * bytes_per_row];
1972		p2 = &the_buffer_copy[j * bytes_per_row];
#	Line 1254 | Line 1984 | static void update_display_static(driver
1984		p2 = &the_buffer_copy[j * bytes_per_row];
1985		p += bytes_per_row;
1986		p2 += bytes_per_row;
1987	<	for (i=mode.x*bytes_per_pixel; i>x2*bytes_per_pixel; i--) {
1987	>	for (i=VIDEO_MODE_X*bytes_per_pixel; i>x2*bytes_per_pixel; i--) {
1988		p--;
1989		p2--;
1990		if (*p != *p2) {
#	Line 1414 | Line 2144 | static void VideoRefreshInit(void)
2144		}
2145		}
2146
2147	+	const int VIDEO_REFRESH_HZ = 60;
2148	+	const int VIDEO_REFRESH_DELAY = 1000000 / VIDEO_REFRESH_HZ;
2149	+
2150		static int redraw_func(void *arg)
2151		{
2152		uint64 start = GetTicks_usec();
2153		int64 ticks = 0;
2154	+	uint64 next = GetTicks_usec() + VIDEO_REFRESH_DELAY;
2155
2156		while (!redraw_thread_cancel) {
2157
2158		// Wait
2159	<	Delay_usec(16667);
2159	>	next += VIDEO_REFRESH_DELAY;
2160	>	int64 delay = next - GetTicks_usec();
2161	>	if (delay > 0)
2162	>	Delay_usec(delay);
2163	>	else if (delay < -VIDEO_REFRESH_DELAY)
2164	>	next = GetTicks_usec();
2165	>	ticks++;
2166
2167		// Handle SDL events
2168		handle_events();
2169
2170		// Refresh display
2171		video_refresh();
2172	<	ticks++;
2172	>
2173	>	#ifdef SHEEPSHAVER
2174	>	// Set new cursor image if it was changed
2175	>	if (cursor_changed && sdl_cursor) {
2176	>	cursor_changed = false;
2177	>	SDL_FreeCursor(sdl_cursor);
2178	>	sdl_cursor = SDL_CreateCursor(MacCursor + 4, MacCursor + 36, 16, 16, MacCursor[2], MacCursor[3]);
2179	>	if (sdl_cursor)
2180	>	SDL_SetCursor(sdl_cursor);
2181	>	}
2182	>	#endif
2183
2184		// Set new palette if it was changed
2185		handle_palette_changes();
#	Line 1437 | Line 2187 | static int redraw_func(void *arg)
2187
2188		uint64 end = GetTicks_usec();
2189		D(bug("%lld refreshes in %lld usec = %f refreshes/sec\n", ticks, end - start, ticks * 1000000.0 / (end - start)));
1440	–	redraw_thread_cancel = false;
2190		return 0;
2191		}

Diff Legend

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