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.11 by gbeauche, 2004-07-02T06:08:01Z vs.
Revision 1.18 by gbeauche, 2005-03-20T23:43:17Z

#	Line 1 | Line 1
1		/*
2		*  video_sdl.cpp - Video/graphics emulation, SDL specific stuff
3		*
4	<	*  Basilisk II (C) 1997-2004 Christian Bauer
4	>	*  Basilisk II (C) 1997-2005 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 56 | Line 56
56		#include "video.h"
57		#include "video_defs.h"
58		#include "video_blit.h"
59	+	#include "vm_alloc.h"
60
61		#define DEBUG 0
62		#include "debug.h"
#	Line 81 | Line 82 | static int display_type = DISPLAY_WINDOW
82		#endif
83
84		// Constants
85	+	#ifdef WIN32
86	+	const char KEYCODE_FILE_NAME[] = "BasiliskII_keycodes";
87	+	#else
88		const char KEYCODE_FILE_NAME[] = DATADIR "/keycodes";
89	+	#endif
90
91
92		// Global variables
#	Line 96 | Line 101 | static uint32 the_buffer_size;                                         // S
101		static bool redraw_thread_active = false;                       // Flag: Redraw thread installed
102		static volatile bool redraw_thread_cancel;                      // Flag: Cancel Redraw thread
103		static SDL_Thread *redraw_thread = NULL;                        // Redraw thread
104	+	static volatile bool thread_stop_req = false;
105	+	static volatile bool thread_stop_ack = false;           // Acknowledge for thread_stop_req
106
107		#ifdef ENABLE_VOSF
108		static bool use_vosf = false;                                           // Flag: VOSF enabled
#	Line 145 | Line 152 | extern void SysMountFirstFloppy(void);
152
153
154		/*
155	+	*  Framebuffer allocation routines
156	+	*/
157	+
158	+	static void *vm_acquire_framebuffer(uint32 size)
159	+	{
160	+	#ifdef SHEEPSHAVER
161	+	#ifdef DIRECT_ADDRESSING_HACK
162	+	const uint32 FRAME_BUFFER_BASE = 0x61000000;
163	+	uint8 *fb = Mac2HostAddr(FRAME_BUFFER_BASE);
164	+	if (vm_acquire_fixed(fb, size) < 0)
165	+	fb = VM_MAP_FAILED;
166	+	return fb;
167	+	#endif
168	+	#endif
169	+	return vm_acquire(size);
170	+	}
171	+
172	+	static inline void vm_release_framebuffer(void *fb, uint32 size)
173	+	{
174	+	vm_release(fb, size);
175	+	}
176	+
177	+
178	+	/*
179		*  SheepShaver glue
180		*/
181
#	Line 324 | Line 355 | static inline int bytes_per_pixel(int de
355		}
356
357		// Map video_mode depth ID to numerical depth value
358	<	static int sdl_depth_of_video_depth(int video_depth)
358	>	static int mac_depth_of_video_depth(int video_depth)
359		{
360		int depth = -1;
361		switch (video_depth) {
#	Line 352 | Line 383 | static int sdl_depth_of_video_depth(int
383		return depth;
384		}
385
386	+	// Map video_mode depth ID to SDL screen depth
387	+	static int sdl_depth_of_video_depth(int video_depth)
388	+	{
389	+	return (video_depth <= VIDEO_DEPTH_8BIT) ? 8 : mac_depth_of_video_depth(video_depth);
390	+	}
391	+
392		// Check wether specified mode is available
393		static bool has_mode(int type, int width, int height)
394		{
#	Line 548 | Line 585 | driver_base::~driver_base()
585		if (s)
586		SDL_FreeSurface(s);
587
588	+	// the_buffer shall always be mapped through vm_acquire_framebuffer()
589	+	if (the_buffer != VM_MAP_FAILED) {
590	+	D(bug(" releasing the_buffer at %p (%d bytes)\n", the_buffer, the_buffer_size));
591	+	vm_release_framebuffer(the_buffer, the_buffer_size);
592	+	the_buffer = NULL;
593	+	}
594	+
595		// Free frame buffer(s)
596		if (!use_vosf) {
553	–	if (the_buffer) {
554	–	free(the_buffer);
555	–	the_buffer = NULL;
556	–	}
597		if (the_buffer_copy) {
598		free(the_buffer_copy);
599		the_buffer_copy = NULL;
#	Line 561 | Line 601 | driver_base::~driver_base()
601		}
602		#ifdef ENABLE_VOSF
603		else {
564	–	// the_buffer shall always be mapped through vm_acquire() so that we can vm_protect() it at will
565	–	if (the_buffer != VM_MAP_FAILED) {
566	–	D(bug(" releasing the_buffer at %p (%d bytes)\n", the_buffer, the_buffer_size));
567	–	vm_release(the_buffer, the_buffer_size);
568	–	the_buffer = NULL;
569	–	}
604		if (the_host_buffer) {
605		D(bug(" freeing the_host_buffer at %p\n", the_host_buffer));
606		free(the_host_buffer);
#	Line 577 | Line 611 | driver_base::~driver_base()
611		free(the_buffer_copy);
612		the_buffer_copy = NULL;
613		}
614	+
615	+	// Deinitialize VOSF
616	+	video_vosf_exit();
617		}
618		#endif
619		}
#	Line 617 | Line 654 | driver_window::driver_window(SDL_monitor
654		ADBSetRelMouseMode(mouse_grabbed);
655
656		// Create surface
657	<	int depth = ((int)VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT ? 8 : screen_depth);
657	>	int depth = sdl_depth_of_video_depth(VIDEO_MODE_DEPTH);
658		if ((s = SDL_SetVideoMode(width, height, depth, SDL_HWSURFACE)) == NULL)
659		return;
660
#	Line 626 | Line 663 | driver_window::driver_window(SDL_monitor
663		// Allocate memory for frame buffer (SIZE is extended to page-boundary)
664		the_host_buffer = (uint8 *)s->pixels;
665		the_buffer_size = page_extend((aligned_height + 2) * s->pitch);
666	<	the_buffer = (uint8 *)vm_acquire(the_buffer_size);
666	>	the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
667		the_buffer_copy = (uint8 *)malloc(the_buffer_size);
668		D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer));
669
#	Line 650 | Line 687 | driver_window::driver_window(SDL_monitor
687		// Allocate memory for frame buffer
688		the_buffer_size = (aligned_height + 2) * s->pitch;
689		the_buffer_copy = (uint8 *)calloc(1, the_buffer_size);
690	<	the_buffer = (uint8 *)calloc(1, the_buffer_size);
690	>	the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
691		D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy));
692		}
693
#	Line 675 | Line 712 | driver_window::driver_window(SDL_monitor
712		visualFormat.Rmask = f->Rmask;
713		visualFormat.Gmask = f->Gmask;
714		visualFormat.Bmask = f->Bmask;
715	<	Screen_blitter_init(visualFormat, true, sdl_depth_of_video_depth(VIDEO_MODE_DEPTH));
715	>	Screen_blitter_init(visualFormat, true, mac_depth_of_video_depth(VIDEO_MODE_DEPTH));
716
717		// Load gray ramp to 8->16/32 expand map
718		if (!IsDirectMode(mode))
#	Line 773 | Line 810 | static void keycode_init(void)
810		SDL_VideoDriverName(video_driver, sizeof(video_driver));
811		bool video_driver_found = false;
812		char line[256];
813	+	int n_keys = 0;
814		while (fgets(line, sizeof(line) - 1, f)) {
815		// Read line
816		int len = strlen(line);
#	Line 785 | Line 823 | static void keycode_init(void)
823		continue;
824
825		if (video_driver_found) {
826	<	// Skip aliases
826	>	// Skip aliases as long as we have read keycodes yet
827	>	// Otherwise, it's another mapping and we have to stop
828		static const char sdl_str[] = "sdl";
829	<	if (strncmp(line, sdl_str, sizeof(sdl_str) - 1) == 0)
829	>	if (strncmp(line, sdl_str, sizeof(sdl_str) - 1) == 0 && n_keys == 0)
830		continue;
831
832		// Read keycode
833		int x_code, mac_code;
834		if (sscanf(line, "%d %d", &x_code, &mac_code) == 2)
835	<	keycode_table[x_code & 0xff] = mac_code;
835	>	keycode_table[x_code & 0xff] = mac_code, n_keys++;
836		else
837		break;
838		} else {
#	Line 818 | Line 857 | static void keycode_init(void)
857		WarningAlert(str);
858		return;
859		}
860	+
861	+	D(bug("Using SDL/%s keycodes table, %d key mappings\n", video_driver, n_keys));
862		}
863		}
864
#	Line 918 | Line 959 | bool VideoInit(bool classic)
959		int max_width = 640, max_height = 480;
960		SDL_Rect **modes = SDL_ListModes(NULL, SDL_FULLSCREEN | SDL_HWSURFACE);
961		if (modes && modes != (SDL_Rect **)-1) {
962	<	max_width = modes[0]->w;
963	<	max_height = modes[0]->h;
962	>	// It turns out that on some implementations, and contrary to the documentation,
963	>	// the returned list is not sorted from largest to smallest (e.g. Windows)
964	>	for (int i = 0; modes[i] != NULL; i++) {
965	>	const int w = modes[i]->w;
966	>	const int h = modes[i]->h;
967	>	if (w > max_width && h > max_height) {
968	>	max_width = w;
969	>	max_height = h;
970	>	}
971	>	}
972		if (default_width > max_width)
973		default_width = max_width;
974		if (default_height > max_height)
#	Line 954 | Line 1003 | bool VideoInit(bool classic)
1003		add_mode(display_type, 512, 342, 0x80, 64, VIDEO_DEPTH_1BIT);
1004		else {
1005		for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++) {
1006	<	int bpp = (d <= VIDEO_DEPTH_8BIT ? 8 : sdl_depth_of_video_depth(d));
1006	>	int bpp = sdl_depth_of_video_depth(d);
1007		if (SDL_VideoModeOK(max_width, max_height, bpp, SDL_HWSURFACE))
1008		add_window_modes(video_depth(d));
1009		}
#	Line 1042 | Line 1091 | void SDL_monitor_desc::video_close(void)
1091		UNLOCK_FRAME_BUFFER;
1092		D(bug(" frame buffer unlocked\n"));
1093
1045	–	#ifdef ENABLE_VOSF
1046	–	if (use_vosf) {
1047	–	// Deinitialize VOSF
1048	–	video_vosf_exit();
1049	–	}
1050	–	#endif
1051	–
1094		// Close display
1095		delete drv;
1096		drv = NULL;
#	Line 1207 | Line 1249 | int16 video_mode_change(VidLocals *csSav
1249		csSave->saveData = ReadMacInt32(ParamPtr + csData);
1250		csSave->savePage = ReadMacInt16(ParamPtr + csPage);
1251
1252	<	// Disable interrupts
1252	>	// Disable interrupts and pause redraw thread
1253		DisableInterrupt();
1254	+	thread_stop_ack = false;
1255	+	thread_stop_req = true;
1256	+	while (!thread_stop_ack) ;
1257
1258		cur_mode = i;
1259		monitor_desc *monitor = VideoMonitors[0];
#	Line 1219 | Line 1264 | int16 video_mode_change(VidLocals *csSav
1264		csSave->saveData=VModes[cur_mode].viAppleID;/* First mode ... */
1265		csSave->saveMode=VModes[cur_mode].viAppleMode;
1266
1267	<	// Enable interrupts
1267	>	// Enable interrupts and resume redraw thread
1268	>	thread_stop_req = false;
1269		EnableInterrupt();
1270		return noErr;
1271		}
#	Line 1335 | Line 1381 | static int kc_decode(SDL_keysym const &
1381
1382		case SDLK_1: case SDLK_EXCLAIM: return 0x12;
1383		case SDLK_2: case SDLK_AT: return 0x13;
1384	<	//      case SDLK_3: case SDLK_numbersign: return 0x14;
1384	>	case SDLK_3: case SDLK_HASH: return 0x14;
1385		case SDLK_4: case SDLK_DOLLAR: return 0x15;
1386	<	//      case SDLK_5: case SDLK_percent: return 0x17;
1386	>	case SDLK_5: return 0x17;
1387		case SDLK_6: return 0x16;
1388		case SDLK_7: return 0x1a;
1389		case SDLK_8: return 0x1c;
1390		case SDLK_9: return 0x19;
1391		case SDLK_0: return 0x1d;
1392
1393	<	//      case SDLK_BACKQUOTE: case SDLK_asciitilde: return 0x0a;
1393	>	case SDLK_BACKQUOTE: return 0x0a;
1394		case SDLK_MINUS: case SDLK_UNDERSCORE: return 0x1b;
1395		case SDLK_EQUALS: case SDLK_PLUS: return 0x18;
1396	<	//      case SDLK_bracketleft: case SDLK_braceleft: return 0x21;
1397	<	//      case SDLK_bracketright: case SDLK_braceright: return 0x1e;
1398	<	//      case SDLK_BACKSLASH: case SDLK_bar: return 0x2a;
1396	>	case SDLK_LEFTBRACKET: return 0x21;
1397	>	case SDLK_RIGHTBRACKET: return 0x1e;
1398	>	case SDLK_BACKSLASH: return 0x2a;
1399		case SDLK_SEMICOLON: case SDLK_COLON: return 0x29;
1400	<	//      case SDLK_apostrophe: case SDLK_QUOTEDBL: return 0x27;
1400	>	case SDLK_QUOTE: case SDLK_QUOTEDBL: return 0x27;
1401		case SDLK_COMMA: case SDLK_LESS: return 0x2b;
1402		case SDLK_PERIOD: case SDLK_GREATER: return 0x2f;
1403		case SDLK_SLASH: case SDLK_QUESTION: return 0x2c;
#	Line 1860 | Line 1906 | static int redraw_func(void *arg)
1906		next = GetTicks_usec();
1907		ticks++;
1908
1909	+	#ifdef SHEEPSHAVER
1910	+	// Pause if requested (during video mode switches)
1911	+	if (thread_stop_req) {
1912	+	thread_stop_ack = true;
1913	+	continue;
1914	+	}
1915	+	#endif
1916	+
1917		// Handle SDL events
1918		handle_events();
1919

Diff Legend

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