merged OSystem_SDL and OSystem_SDL_Common; split SDL backend into multiple source files

svn-id: r13092

7 files changed, 1992 insertions, 1981 deletions

diff --git a/backends/sdl/build.rules b/backends/sdl/build.rules
index 0a043db918..81cfd25e93 100644
--- a/backends/sdl/build.rules
+++ b/backends/sdl/build.rules
@@ -3,10 +3,7 @@ MODULES  += backends/sdl
 DEFINES  += -DUNIX
 INCLUDES += `sdl-config --cflags`
 LIBS     += `sdl-config --libs`
-OBJS	 += backends/sdl/sdl-common.o 
-
-# The normal (non OpenGL-accelerated) SDL backend
-OBJS	 += backends/sdl/sdl.o 
+OBJS	 += backends/sdl/events.o backends/sdl/graphics.o backends/sdl/sdl.o 
 
 # Uncomment this in addition to the above if you compile on Mac OS X
 # DEFINES += -DMACOSX
diff --git a/backends/sdl/events.cpp b/backends/sdl/events.cpp
new file mode 100644
index 0000000000..20506a52ee
--- /dev/null
+++ b/backends/sdl/events.cpp
@@ -0,0 +1,573 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001  Ludvig Strigeus
+ * Copyright (C) 2001-2004 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include "backends/sdl/sdl-common.h"
+#include "common/util.h"
+
+// FIXME move joystick defines out and replace with confile file options
+// we should really allow users to map any key to a joystick button
+#define JOY_DEADZONE 3200
+#define JOY_ANALOG
+// #define JOY_INVERT_Y
+#define JOY_XAXIS 0
+#define JOY_YAXIS 1
+// buttons
+#define JOY_BUT_LMOUSE 0
+#define JOY_BUT_RMOUSE 2
+#define JOY_BUT_ESCAPE 3
+#define JOY_BUT_PERIOD 1
+#define JOY_BUT_SPACE 4
+#define JOY_BUT_F5 5
+
+
+static const int s_gfxModeSwitchTable[][4] = {
+		{ GFX_NORMAL, GFX_DOUBLESIZE, GFX_TRIPLESIZE, -1 },
+		{ GFX_NORMAL, GFX_ADVMAME2X, GFX_ADVMAME3X, -1 },
+		{ GFX_NORMAL, GFX_HQ2X, GFX_HQ3X, -1 },
+		{ GFX_NORMAL, GFX_2XSAI, -1, -1 },
+		{ GFX_NORMAL, GFX_SUPER2XSAI, -1, -1 },
+		{ GFX_NORMAL, GFX_SUPEREAGLE, -1, -1 },
+		{ GFX_NORMAL, GFX_TV2X, -1, -1 },
+		{ GFX_NORMAL, GFX_DOTMATRIX, -1, -1 }
+	};
+
+
+
+static int mapKey(SDLKey key, SDLMod mod, Uint16 unicode)
+{
+	if (key >= SDLK_F1 && key <= SDLK_F9) {
+		return key - SDLK_F1 + 315;
+	} else if (key >= SDLK_KP0 && key <= SDLK_KP9) {
+		return key - SDLK_KP0 + '0';
+	} else if (key >= SDLK_UP && key <= SDLK_PAGEDOWN) {
+		return key;
+	} else if (unicode) {
+		return unicode;
+	} else if (key >= 'a' && key <= 'z' && mod & KMOD_SHIFT) {
+		return key & ~0x20;
+	} else if (key >= SDLK_NUMLOCK && key <= SDLK_EURO) {
+		return 0;
+	}
+	return key;
+}
+
+void OSystem_SDL::fillMouseEvent(Event &event, int x, int y) {
+	event.mouse.x = x;
+	event.mouse.y = y;
+	
+	// Update the "keyboard mouse" coords
+	km.x = event.mouse.x;
+	km.y = event.mouse.y;
+
+	// Adjust for the screen scaling
+	event.mouse.x /= _scaleFactor;
+	event.mouse.y /= _scaleFactor;
+
+	// Optionally perform aspect ratio adjusting
+	if (_adjustAspectRatio)
+		event.mouse.y = aspect2Real(event.mouse.y);
+}
+
+void OSystem_SDL::kbd_mouse() {
+	uint32 curTime = get_msecs();
+	if (curTime >= km.last_time + km.delay_time) {
+		km.last_time = curTime;
+		if (km.x_down_count == 1) {
+			km.x_down_time = curTime;
+			km.x_down_count = 2;
+		}
+		if (km.y_down_count == 1) {
+			km.y_down_time = curTime;
+			km.y_down_count = 2;
+		}
+
+		if (km.x_vel || km.y_vel) {
+			if (km.x_down_count) {
+				if (curTime > km.x_down_time + km.delay_time * 12) {
+					if (km.x_vel > 0)
+						km.x_vel++;
+					else
+						km.x_vel--;
+				} else if (curTime > km.x_down_time + km.delay_time * 8) {
+					if (km.x_vel > 0)
+						km.x_vel = 5;
+					else
+						km.x_vel = -5;
+				}
+			}
+			if (km.y_down_count) {
+				if (curTime > km.y_down_time + km.delay_time * 12) {
+					if (km.y_vel > 0)
+						km.y_vel++;
+					else
+						km.y_vel--;
+				} else if (curTime > km.y_down_time + km.delay_time * 8) {
+					if (km.y_vel > 0)
+						km.y_vel = 5;
+					else
+						km.y_vel = -5;
+				}
+			}
+
+			km.x += km.x_vel;
+			km.y += km.y_vel;
+
+			if (km.x < 0) {
+				km.x = 0;
+				km.x_vel = -1;
+				km.x_down_count = 1;
+			} else if (km.x > km.x_max) {
+				km.x = km.x_max;
+				km.x_vel = 1;
+				km.x_down_count = 1;
+			}
+
+			if (km.y < 0) {
+				km.y = 0;
+				km.y_vel = -1;
+				km.y_down_count = 1;
+			} else if (km.y > km.y_max) {
+				km.y = km.y_max;
+				km.y_vel = 1;
+				km.y_down_count = 1;
+			}
+
+			SDL_WarpMouse(km.x, km.y);
+		}
+	}
+}
+
+bool OSystem_SDL::poll_event(Event *event) {
+	SDL_Event ev;
+	int axis;
+	byte b = 0;
+	
+	kbd_mouse();
+	
+	// If the screen mode changed, send an EVENT_SCREEN_CHANGED
+	if (_modeChanged) {
+		_modeChanged = false;
+		event->event_code = EVENT_SCREEN_CHANGED;
+		return true;
+	}
+
+	while(SDL_PollEvent(&ev)) {
+		switch(ev.type) {
+		case SDL_KEYDOWN:
+#ifdef LINUPY
+			// Yopy has no ALT key, steal the SHIFT key 
+			// (which isn't used much anyway)
+			if (ev.key.keysym.mod & KMOD_SHIFT)
+				b |= KBD_ALT;
+			if (ev.key.keysym.mod & KMOD_CTRL)
+				b |= KBD_CTRL;
+#else
+			if (ev.key.keysym.mod & KMOD_SHIFT)
+				b |= KBD_SHIFT;
+			if (ev.key.keysym.mod & KMOD_CTRL)
+				b |= KBD_CTRL;
+			if (ev.key.keysym.mod & KMOD_ALT)
+				b |= KBD_ALT;
+#endif
+			event->kbd.flags = b;
+
+			// Alt-Return toggles full screen mode				
+			if (b == KBD_ALT && ev.key.keysym.sym == SDLK_RETURN) {
+				setFeatureState(kFeatureFullscreenMode, !_full_screen);
+				break;
+			}
+
+			// Alt-S: Create a screenshot
+			if (b == KBD_ALT && ev.key.keysym.sym == 's') {
+				char filename[20];
+
+				for (int n = 0;; n++) {
+					SDL_RWops *file;
+
+					sprintf(filename, "scummvm%05d.bmp", n);
+					file = SDL_RWFromFile(filename, "r");
+					if (!file)
+						break;
+					SDL_RWclose(file);
+				}
+				if (save_screenshot(filename))
+					printf("Saved '%s'\n", filename);
+				else
+					printf("Could not save screenshot!\n");
+				break;
+			}
+
+			// Ctrl-m toggles mouse capture
+			if (b == KBD_CTRL && ev.key.keysym.sym == 'm') {
+				toggleMouseGrab();
+				break;
+			}
+
+#ifdef MACOSX
+			// On Macintosh', Cmd-Q quits
+			if ((ev.key.keysym.mod & KMOD_META) && ev.key.keysym.sym == 'q') {
+				event->event_code = EVENT_QUIT;
+				return true;
+			}
+#else
+			// Ctrl-z and Alt-X quit
+			if ((b == KBD_CTRL && ev.key.keysym.sym == 'z') || (b == KBD_ALT && ev.key.keysym.sym == 'x')) {
+				event->event_code = EVENT_QUIT;
+				return true;
+			}
+#endif
+
+			// Ctrl-Alt-<key> will change the GFX mode
+			if ((b & (KBD_CTRL|KBD_ALT)) == (KBD_CTRL|KBD_ALT)) {
+				// FIXME EVIL HACK: This shouldn't be a static int, rather it
+				// should be a member variable. Furthermore, it shouldn't be
+				// set in this code, rather it should be set by load_gfx_mode().
+				// But for now this quick&dirty hack works.
+				static int _scalerType = 0;
+				if (_mode != GFX_NORMAL) {
+					// Try to figure out which gfx mode "group" we are in
+					// This is just a temporary hack until the proper solution
+					// (i.e. code in load_gfx_mode()) is in effect.
+					for (int i = 0; i < ARRAYSIZE(s_gfxModeSwitchTable); i++) {
+						if (s_gfxModeSwitchTable[i][1] == _mode || s_gfxModeSwitchTable[i][2] == _mode) {
+							_scalerType = i;
+							break;
+						}
+					}
+				}
+				
+				int factor = _scaleFactor - 1;
+
+				// Ctrl-Alt-a toggles aspect ratio correction
+				if (ev.key.keysym.sym == 'a') {
+					setFeatureState(kFeatureAspectRatioCorrection, !_adjustAspectRatio);
+					break;
+				}
+
+				// Increase/decrease the scale factor
+				// TODO: Shall we 'wrap around' here?
+				if (ev.key.keysym.sym == '=' || ev.key.keysym.sym == '+' || ev.key.keysym.sym == '-') {
+					factor += (ev.key.keysym.sym == '-' ? -1 : +1);
+					if (0 <= factor && factor < 4 && s_gfxModeSwitchTable[_scalerType][factor] >= 0) {
+						setGraphicsMode(s_gfxModeSwitchTable[_scalerType][factor]);
+					}
+					break;
+				}
+				
+				if ('1' <= ev.key.keysym.sym && ev.key.keysym.sym <= '9') {
+					_scalerType = ev.key.keysym.sym - '1';
+					if (_scalerType >= ARRAYSIZE(s_gfxModeSwitchTable))
+						break;
+					
+					while (s_gfxModeSwitchTable[_scalerType][factor] < 0) {
+						assert(factor > 0);
+						factor--;
+					}
+					setGraphicsMode(s_gfxModeSwitchTable[_scalerType][factor]);
+					break;
+				}
+			}
+
+#ifdef LINUPY
+			// On Yopy map the End button to quit
+			if ((ev.key.keysym.sym==293)) {
+				event->event_code = EVENT_QUIT;
+				return true;
+			}
+			// Map menu key to f5 (scumm menu)
+			if (ev.key.keysym.sym==306) {
+				event->event_code = EVENT_KEYDOWN;
+				event->kbd.keycode = SDLK_F5;
+				event->kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
+				return true;
+			}
+			// Map action key to action
+			if (ev.key.keysym.sym==291) {
+				event->event_code = EVENT_KEYDOWN;
+				event->kbd.keycode = SDLK_TAB;
+				event->kbd.ascii = mapKey(SDLK_TAB, ev.key.keysym.mod, 0);
+				return true;
+			}
+			// Map OK key to skip cinematic
+			if (ev.key.keysym.sym==292) {
+				event->event_code = EVENT_KEYDOWN;
+				event->kbd.keycode = SDLK_ESCAPE;
+				event->kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0);
+				return true;
+			}
+#endif
+
+#ifdef QTOPIA
+			// quit on fn+backspace on zaurus
+			if (ev.key.keysym.sym == 127) {
+				event->event_code = EVENT_QUIT;
+				return true;
+			}
+
+			// map menu key (f11) to f5 (scumm menu)
+			if (ev.key.keysym.sym == SDLK_F11) {
+				event->event_code = EVENT_KEYDOWN;
+				event->kbd.keycode = SDLK_F5;
+				event->kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
+			}
+			// map center (space) to tab (default action )
+			// I wanted to map the calendar button but the calendar comes up
+			//
+			else if (ev.key.keysym.sym == SDLK_SPACE) {
+				event->event_code = EVENT_KEYDOWN;
+				event->kbd.keycode = SDLK_TAB;
+				event->kbd.ascii = mapKey(SDLK_TAB, ev.key.keysym.mod, 0);
+			}
+			// since we stole space (pause) above we'll rebind it to the tab key on the keyboard
+			else if (ev.key.keysym.sym == SDLK_TAB) {
+				event->event_code = EVENT_KEYDOWN;
+				event->kbd.keycode = SDLK_SPACE;
+				event->kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0);
+			} else {
+			// let the events fall through if we didn't change them, this may not be the best way to
+			// set it up, but i'm not sure how sdl would like it if we let if fall through then redid it though.
+			// and yes i have an huge terminal size so i dont wrap soon enough.
+				event->event_code = EVENT_KEYDOWN;
+				event->kbd.keycode = ev.key.keysym.sym;
+				event->kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
+			}
+#else
+			event->event_code = EVENT_KEYDOWN;
+			event->kbd.keycode = ev.key.keysym.sym;
+			event->kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
+#endif
+			
+			switch(ev.key.keysym.sym) {
+			case SDLK_LEFT:
+				km.x_vel = -1;
+				km.x_down_count = 1;
+				break;
+			case SDLK_RIGHT:
+				km.x_vel =  1;
+				km.x_down_count = 1;
+				break;
+			case SDLK_UP:
+				km.y_vel = -1;
+				km.y_down_count = 1;
+				break;
+			case SDLK_DOWN:
+				km.y_vel =  1;
+				km.y_down_count = 1;
+				break;
+			default:
+				break;
+			}
+
+			return true;
+	
+		case SDL_KEYUP:
+			event->event_code = EVENT_KEYUP;
+			event->kbd.keycode = ev.key.keysym.sym;
+			event->kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
+
+			switch(ev.key.keysym.sym) {
+			case SDLK_LEFT:
+				if (km.x_vel < 0) {
+					km.x_vel = 0;
+					km.x_down_count = 0;
+				}
+				break;
+			case SDLK_RIGHT:
+				if (km.x_vel > 0) {
+					km.x_vel = 0;
+					km.x_down_count = 0;
+				}
+				break;
+			case SDLK_UP:
+				if (km.y_vel < 0) {
+					km.y_vel = 0;
+					km.y_down_count = 0;
+				}
+				break;
+			case SDLK_DOWN:
+				if (km.y_vel > 0) {
+					km.y_vel = 0;
+					km.y_down_count = 0;
+				}
+				break;
+			default:
+				break;
+			}
+			return true;
+
+		case SDL_MOUSEMOTION:
+			event->event_code = EVENT_MOUSEMOVE;
+			fillMouseEvent(*event, ev.motion.x, ev.motion.y);
+			
+			set_mouse_pos(event->mouse.x, event->mouse.y);
+			return true;
+
+		case SDL_MOUSEBUTTONDOWN:
+			if (ev.button.button == SDL_BUTTON_LEFT)
+				event->event_code = EVENT_LBUTTONDOWN;
+			else if (ev.button.button == SDL_BUTTON_RIGHT)
+				event->event_code = EVENT_RBUTTONDOWN;
+#if defined(SDL_BUTTON_WHEELUP) && defined(SDL_BUTTON_WHEELDOWN)
+			else if (ev.button.button == SDL_BUTTON_WHEELUP)
+				event->event_code = EVENT_WHEELUP;
+			else if (ev.button.button == SDL_BUTTON_WHEELDOWN)
+				event->event_code = EVENT_WHEELDOWN;
+#endif
+			else
+				break;
+
+			fillMouseEvent(*event, ev.button.x, ev.button.y);
+
+			return true;
+
+		case SDL_MOUSEBUTTONUP:
+			if (ev.button.button == SDL_BUTTON_LEFT)
+				event->event_code = EVENT_LBUTTONUP;
+			else if (ev.button.button == SDL_BUTTON_RIGHT)
+				event->event_code = EVENT_RBUTTONUP;
+			else
+				break;
+			fillMouseEvent(*event, ev.button.x, ev.button.y);
+
+			return true;
+
+		case SDL_JOYBUTTONDOWN:
+			if (ev.jbutton.button == JOY_BUT_LMOUSE) {
+				event->event_code = EVENT_LBUTTONDOWN;
+			} else if (ev.jbutton.button == JOY_BUT_RMOUSE) {
+				event->event_code = EVENT_RBUTTONDOWN;
+			} else {
+				event->event_code = EVENT_KEYDOWN;
+				switch (ev.jbutton.button) {
+					case JOY_BUT_ESCAPE:
+						event->kbd.keycode = SDLK_ESCAPE;
+						event->kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0);
+						break;
+					case JOY_BUT_PERIOD:
+						event->kbd.keycode = SDLK_PERIOD;
+						event->kbd.ascii = mapKey(SDLK_PERIOD, ev.key.keysym.mod, 0);
+						break;
+					case JOY_BUT_SPACE:
+						event->kbd.keycode = SDLK_SPACE;
+						event->kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0);
+						break;
+					case JOY_BUT_F5:
+						event->kbd.keycode = SDLK_F5;
+						event->kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
+						break; 
+				}
+			}
+			return true;
+
+		case SDL_JOYBUTTONUP:
+			if (ev.jbutton.button == JOY_BUT_LMOUSE) {
+				event->event_code = EVENT_LBUTTONUP;
+			} else if (ev.jbutton.button == JOY_BUT_RMOUSE) {
+				event->event_code = EVENT_RBUTTONUP;
+			} else {
+				event->event_code = EVENT_KEYUP;
+				switch (ev.jbutton.button) {
+					case JOY_BUT_ESCAPE:
+						event->kbd.keycode = SDLK_ESCAPE;
+						event->kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0);
+						break;
+					case JOY_BUT_PERIOD:
+						event->kbd.keycode = SDLK_PERIOD;
+						event->kbd.ascii = mapKey(SDLK_PERIOD, ev.key.keysym.mod, 0);
+						break;
+					case JOY_BUT_SPACE:
+						event->kbd.keycode = SDLK_SPACE;
+						event->kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0);
+						break;
+					case JOY_BUT_F5:
+						event->kbd.keycode = SDLK_F5;
+						event->kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
+						break;
+				} 
+			}
+			return true;
+
+		case SDL_JOYAXISMOTION:
+			axis = ev.jaxis.value;
+			if ( axis > JOY_DEADZONE) {
+				axis -= JOY_DEADZONE;
+				event->event_code = EVENT_MOUSEMOVE;
+			} else if ( axis < -JOY_DEADZONE ) {
+				axis += JOY_DEADZONE;
+				event->event_code = EVENT_MOUSEMOVE;
+			} else
+				axis = 0;
+
+			if ( ev.jaxis.axis == JOY_XAXIS) { 
+#ifdef JOY_ANALOG
+				km.x_vel = axis/2000;
+				km.x_down_count = 0;
+#else
+				if (axis != 0) {
+					km.x_vel = (axis > 0) ? 1:-1;
+					km.x_down_count = 1;
+				} else {
+					km.x_vel = 0;
+					km.x_down_count = 0;
+				}
+#endif
+
+			} else if (ev.jaxis.axis == JOY_YAXIS) { 
+#ifndef JOY_INVERT_Y
+				axis = -axis;
+#endif
+#ifdef JOY_ANALOG
+				km.y_vel = -axis / 2000;
+				km.y_down_count = 0;
+#else
+				if (axis != 0) {
+					km.y_vel = (-axis > 0) ? 1: -1;
+					km.y_down_count = 1;
+				} else {
+					km.y_vel = 0;
+					km.y_down_count = 0;
+				}
+#endif
+			}
+			event->mouse.x = km.x;
+			event->mouse.y = km.y;
+			event->mouse.x /= _scaleFactor;
+			event->mouse.y /= _scaleFactor;
+
+			if (_adjustAspectRatio)
+				event->mouse.y = aspect2Real(event->mouse.y);
+
+			return true;
+
+		case SDL_VIDEOEXPOSE:
+			_forceFull = true;
+			break;
+
+		case SDL_QUIT:
+			event->event_code = EVENT_QUIT;
+			return true;
+		}
+	}
+	return false;
+}
+
+
diff --git a/backends/sdl/graphics.cpp b/backends/sdl/graphics.cpp
new file mode 100644
index 0000000000..87e80f2f01
--- /dev/null
+++ b/backends/sdl/graphics.cpp
@@ -0,0 +1,1118 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001  Ludvig Strigeus
+ * Copyright (C) 2001-2004 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include "backends/sdl/sdl-common.h"
+#include "common/scaler.h"
+#include "common/util.h"
+
+static const OSystem::GraphicsMode s_supportedGraphicsModes[] = {
+	{"1x", "Normal (no scaling)", GFX_NORMAL},
+	{"2x", "2x", GFX_DOUBLESIZE},
+	{"3x", "3x", GFX_TRIPLESIZE},
+	{"2xsai", "2xSAI", GFX_2XSAI},
+	{"super2xsai", "Super2xSAI", GFX_SUPER2XSAI},
+	{"supereagle", "SuperEagle", GFX_SUPEREAGLE},
+	{"advmame2x", "AdvMAME2x", GFX_ADVMAME2X},
+	{"advmame3x", "AdvMAME3x", GFX_ADVMAME3X},
+	{"hq2x", "HQ2x", GFX_HQ2X},
+	{"hq3x", "HQ3x", GFX_HQ3X},
+	{"tv2x", "TV2x", GFX_TV2X},
+	{"dotmatrix", "DotMatrix", GFX_DOTMATRIX},
+	{0, 0, 0}
+};
+
+const OSystem::GraphicsMode *OSystem_SDL::getSupportedGraphicsModes() const {
+	return s_supportedGraphicsModes;
+}
+
+bool OSystem_SDL::setGraphicsMode(int mode) {
+	Common::StackLock lock(_graphicsMutex, this);
+
+	int newScaleFactor = 1;
+	ScalerProc *newScalerProc;
+
+	switch(mode) {
+	case GFX_NORMAL:
+		newScaleFactor = 1;
+		newScalerProc = Normal1x;
+		break;
+	case GFX_DOUBLESIZE:
+		newScaleFactor = 2;
+		newScalerProc = Normal2x;
+		break;
+	case GFX_TRIPLESIZE:
+		newScaleFactor = 3;
+		newScalerProc = Normal3x;
+		break;
+
+	case GFX_2XSAI:
+		newScaleFactor = 2;
+		newScalerProc = _2xSaI;
+		break;
+	case GFX_SUPER2XSAI:
+		newScaleFactor = 2;
+		newScalerProc = Super2xSaI;
+		break;
+	case GFX_SUPEREAGLE:
+		newScaleFactor = 2;
+		newScalerProc = SuperEagle;
+		break;
+	case GFX_ADVMAME2X:
+		newScaleFactor = 2;
+		newScalerProc = AdvMame2x;
+		break;
+	case GFX_ADVMAME3X:
+		newScaleFactor = 3;
+		newScalerProc = AdvMame3x;
+		break;
+	case GFX_HQ2X:
+		newScaleFactor = 2;
+		newScalerProc = HQ2x;
+		break;
+	case GFX_HQ3X:
+		newScaleFactor = 3;
+		newScalerProc = HQ3x;
+		break;
+	case GFX_TV2X:
+		newScaleFactor = 2;
+		newScalerProc = TV2x;
+		break;
+	case GFX_DOTMATRIX:
+		newScaleFactor = 2;
+		newScalerProc = DotMatrix;
+		break;
+
+	default:
+		warning("unknown gfx mode %d", mode);
+		return false;
+	}
+
+	_mode = mode;
+
+	if (newScaleFactor != _scaleFactor) {
+		hotswap_gfx_mode();
+	} else {
+		_scaler_proc = newScalerProc;
+		_forceFull = true;
+
+		// Blit everything to the screen
+		internUpdateScreen();
+	
+		// Make sure that an EVENT_SCREEN_CHANGED gets sent later
+		_modeChanged = true;
+	}
+
+	return true;
+}
+
+int OSystem_SDL::getGraphicsMode() const {
+	return _mode;
+}
+
+void OSystem_SDL::initSize(uint w, uint h) {
+	// Avoid redundant res changes
+	if ((int)w == _screenWidth && (int)h == _screenHeight)
+		return;
+
+	_screenWidth = w;
+	_screenHeight = h;
+
+	if (h != 200)
+		_adjustAspectRatio = false;
+
+	CKSUM_NUM = (_screenWidth * _screenHeight / (8 * 8));
+
+	free(_dirty_checksums);
+	_dirty_checksums = (uint32 *)calloc(CKSUM_NUM * 2, sizeof(uint32));
+
+	unload_gfx_mode();
+	load_gfx_mode();
+}
+
+void OSystem_SDL::load_gfx_mode() {
+	_forceFull = true;
+	_mode_flags |= DF_UPDATE_EXPAND_1_PIXEL;
+
+	_tmpscreen = NULL;
+	_tmpScreenWidth = (_screenWidth + 3);
+	
+	switch(_mode) {
+	case GFX_NORMAL:
+		_scaleFactor = 1;
+		_scaler_proc = Normal1x;
+		break;
+	case GFX_DOUBLESIZE:
+		_scaleFactor = 2;
+		_scaler_proc = Normal2x;
+		break;
+	case GFX_TRIPLESIZE:
+		_scaleFactor = 3;
+		_scaler_proc = Normal3x;
+		break;
+
+	case GFX_2XSAI:
+		_scaleFactor = 2;
+		_scaler_proc = _2xSaI;
+		break;
+	case GFX_SUPER2XSAI:
+		_scaleFactor = 2;
+		_scaler_proc = Super2xSaI;
+		break;
+	case GFX_SUPEREAGLE:
+		_scaleFactor = 2;
+		_scaler_proc = SuperEagle;
+		break;
+	case GFX_ADVMAME2X:
+		_scaleFactor = 2;
+		_scaler_proc = AdvMame2x;
+		break;
+	case GFX_ADVMAME3X:
+		_scaleFactor = 3;
+		_scaler_proc = AdvMame3x;
+		break;
+	case GFX_HQ2X:
+		_scaleFactor = 2;
+		_scaler_proc = HQ2x;
+		break;
+	case GFX_HQ3X:
+		_scaleFactor = 3;
+		_scaler_proc = HQ3x;
+		break;
+	case GFX_TV2X:
+		_scaleFactor = 2;
+		_scaler_proc = TV2x;
+		break;
+	case GFX_DOTMATRIX:
+		_scaleFactor = 2;
+		_scaler_proc = DotMatrix;
+		break;
+
+	default:
+		error("unknown gfx mode %d", _mode);
+	}
+
+	//
+	// Create the surface that contains the 8 bit game data
+	//
+	_screen = SDL_CreateRGBSurface(SDL_SWSURFACE, _screenWidth, _screenHeight, 8, 0, 0, 0, 0);
+	if (_screen == NULL)
+		error("_screen failed");
+
+	//
+	// Create the surface that contains the scaled graphics in 16 bit mode
+	//
+
+	_hwscreen = SDL_SetVideoMode(_screenWidth * _scaleFactor, (_adjustAspectRatio ? 240 : _screenHeight) * _scaleFactor, 16, 
+		_full_screen ? (SDL_FULLSCREEN|SDL_SWSURFACE) : SDL_SWSURFACE
+	);
+	if (_hwscreen == NULL) {
+		// DON'T use error(), as this tries to bring up the debug
+		// console, which WON'T WORK now that _hwscreen is hosed.
+
+		// FIXME: We should be able to continue the game without
+		// shutting down or bringing up the debug console, but at
+		// this point we've already screwed up all our member vars.
+		// We need to find a way to call SDL_SetVideoMode *before*
+		// that happens and revert to all the old settings if we
+		// can't pull off the switch to the new settings.
+		//
+		// Fingolfin says: the "easy" way to do that is not to modify
+		// the member vars before we are sure everything is fine. Think
+		// of "transactions, commit, rollback" style... we use local vars
+		// in place of the member vars, do everything etc. etc.. In case
+		// of a failure, rollback is trivial. Only if everything worked fine
+		// do we "commit" the changed values to the member vars.
+		warning("SDL_SetVideoMode says we can't switch to that mode");
+		quit();
+	}
+
+	//
+	// Create the surface used for the graphics in 16 bit before scaling, and also the overlay
+	//
+
+	// Distinguish 555 and 565 mode
+	if (_hwscreen->format->Rmask == 0x7C00)
+		InitScalers(555);
+	else
+		InitScalers(565);
+	
+	// Need some extra bytes around when using 2xSaI
+	uint16 *tmp_screen = (uint16 *)calloc(_tmpScreenWidth * (_screenHeight + 3), sizeof(uint16));
+	_tmpscreen = SDL_CreateRGBSurfaceFrom(tmp_screen,
+						_tmpScreenWidth, _screenHeight + 3, 16, _tmpScreenWidth * 2,
+						_hwscreen->format->Rmask,
+						_hwscreen->format->Gmask,
+						_hwscreen->format->Bmask,
+						_hwscreen->format->Amask);
+
+	if (_tmpscreen == NULL)
+		error("_tmpscreen failed");
+
+	// keyboard cursor control, some other better place for it?
+	km.x_max = _screenWidth * _scaleFactor - 1;
+	km.y_max = (_adjustAspectRatio ? 240 : _screenHeight) * _scaleFactor - 1;
+	km.delay_time = 25;
+	km.last_time = 0;
+}
+
+void OSystem_SDL::unload_gfx_mode() {
+	if (_screen) {
+		SDL_FreeSurface(_screen);
+		_screen = NULL; 
+	}
+
+	if (_hwscreen) {
+		SDL_FreeSurface(_hwscreen); 
+		_hwscreen = NULL;
+	}
+
+	if (_tmpscreen) {
+		free(_tmpscreen->pixels);
+		SDL_FreeSurface(_tmpscreen);
+		_tmpscreen = NULL;
+	}
+}
+
+void OSystem_SDL::hotswap_gfx_mode() {
+	if (!_screen)
+		return;
+
+	// Keep around the old _screen & _tmpscreen so we can restore the screen data
+	// after the mode switch.
+	SDL_Surface *old_screen = _screen;
+	SDL_Surface *old_tmpscreen = _tmpscreen;
+
+	// Release the HW screen surface
+	SDL_FreeSurface(_hwscreen); 
+
+	// Setup the new GFX mode
+	load_gfx_mode();
+
+	// reset palette
+	SDL_SetColors(_screen, _currentPalette, 0, 256);
+
+	// Restore old screen content
+	SDL_BlitSurface(old_screen, NULL, _screen, NULL);
+	SDL_BlitSurface(old_tmpscreen, NULL, _tmpscreen, NULL);
+	
+	// Free the old surfaces
+	SDL_FreeSurface(old_screen);
+	free(old_tmpscreen->pixels);
+	SDL_FreeSurface(old_tmpscreen);
+
+	// Blit everything to the screen
+	internUpdateScreen();
+	
+	// Make sure that an EVENT_SCREEN_CHANGED gets sent later
+	_modeChanged = true;
+}
+
+void OSystem_SDL::updateScreen() {
+	Common::StackLock lock(_graphicsMutex, this);	// Lock the mutex until this function ends
+
+	internUpdateScreen();
+}
+
+void OSystem_SDL::internUpdateScreen() {
+	assert(_hwscreen != NULL);
+
+	// If the shake position changed, fill the dirty area with blackness
+	if (_currentShakePos != _newShakePos) {
+		SDL_Rect blackrect = {0, 0, _screenWidth * _scaleFactor, _newShakePos * _scaleFactor};
+
+		if (_adjustAspectRatio)
+			blackrect.h = real2Aspect(blackrect.h - 1) + 1;
+
+		SDL_FillRect(_hwscreen, &blackrect, 0);
+
+		_currentShakePos = _newShakePos;
+
+		_forceFull = true;
+	}
+
+	// Make sure the mouse is drawn, if it should be drawn.
+	draw_mouse();
+	
+	// Check whether the palette was changed in the meantime and update the
+	// screen surface accordingly. 
+	if (_paletteDirtyEnd != 0) {
+		SDL_SetColors(_screen, _currentPalette + _paletteDirtyStart, 
+			_paletteDirtyStart,
+			_paletteDirtyEnd - _paletteDirtyStart);
+		
+		_paletteDirtyEnd = 0;
+
+		_forceFull = true;
+	}
+
+	// Force a full redraw if requested
+	if (_forceFull) {
+		_num_dirty_rects = 1;
+
+		_dirty_rect_list[0].x = 0;
+		_dirty_rect_list[0].y = 0;
+		_dirty_rect_list[0].w = _screenWidth;
+		_dirty_rect_list[0].h = _screenHeight;
+	}
+
+	// Only draw anything if necessary
+	if (_num_dirty_rects > 0) {
+
+		SDL_Rect *r; 
+		SDL_Rect dst;
+		uint32 srcPitch, dstPitch;
+		SDL_Rect *last_rect = _dirty_rect_list + _num_dirty_rects;
+
+		if (_scaler_proc == Normal1x && !_adjustAspectRatio) {
+			SDL_Surface *target = _overlayVisible ? _tmpscreen : _screen;
+			for (r = _dirty_rect_list; r != last_rect; ++r) {
+				dst = *r;
+				
+				if (_overlayVisible) {
+					// FIXME: I don't understand why this is necessary...
+					dst.x--;
+					dst.y--;
+				}
+				dst.y += _currentShakePos;
+				if (SDL_BlitSurface(target, r, _hwscreen, &dst) != 0)
+					error("SDL_BlitSurface failed: %s", SDL_GetError());
+			}
+		} else {
+			if (!_overlayVisible) {
+				for (r = _dirty_rect_list; r != last_rect; ++r) {
+					dst = *r;
+					dst.x++;	// Shift rect by one since 2xSai needs to acces the data around
+					dst.y++;	// any pixel to scale it, and we want to avoid mem access crashes.
+					if (SDL_BlitSurface(_screen, r, _tmpscreen, &dst) != 0)
+						error("SDL_BlitSurface failed: %s", SDL_GetError());
+				}
+			}
+
+			SDL_LockSurface(_tmpscreen);
+			SDL_LockSurface(_hwscreen);
+
+			srcPitch = _tmpscreen->pitch;
+			dstPitch = _hwscreen->pitch;
+
+			for (r = _dirty_rect_list; r != last_rect; ++r) {
+				register int dst_y = r->y + _currentShakePos;
+				register int dst_h = 0;
+				register int orig_dst_y = 0;
+
+				if (dst_y < _screenHeight) {
+					dst_h = r->h;
+					if (dst_h > _screenHeight - dst_y)
+						dst_h = _screenHeight - dst_y;
+
+					dst_y *= _scaleFactor;
+
+					if (_adjustAspectRatio) {
+						orig_dst_y = dst_y;
+						dst_y = real2Aspect(dst_y);
+					}
+
+					_scaler_proc((byte *)_tmpscreen->pixels + (r->x * 2 + 2) + (r->y + 1) * srcPitch, srcPitch,
+						(byte *)_hwscreen->pixels + r->x * 2 * _scaleFactor + dst_y * dstPitch, dstPitch, r->w, dst_h);
+				}
+
+				r->x *= _scaleFactor;
+				r->y = dst_y;
+				r->w *= _scaleFactor;
+				r->h = dst_h * _scaleFactor;
+
+				if (_adjustAspectRatio && orig_dst_y / _scaleFactor < _screenHeight)
+					r->h = stretch200To240((uint8 *) _hwscreen->pixels, dstPitch, r->w, r->h, r->x, r->y, orig_dst_y);
+			}
+			SDL_UnlockSurface(_tmpscreen);
+			SDL_UnlockSurface(_hwscreen);
+		}
+
+		// Readjust the dirty rect list in case we are doing a full update.
+		// This is necessary if shaking is active.
+		if (_forceFull) {
+			_dirty_rect_list[0].y = 0;
+			_dirty_rect_list[0].h = (_adjustAspectRatio ? 240 : _screenHeight) * _scaleFactor;
+		}
+
+		// Finally, blit all our changes to the screen
+		SDL_UpdateRects(_hwscreen, _num_dirty_rects, _dirty_rect_list);
+	}
+
+	_num_dirty_rects = 0;
+	_forceFull = false;
+}
+
+bool OSystem_SDL::save_screenshot(const char *filename) {
+	assert(_hwscreen != NULL);
+
+	Common::StackLock lock(_graphicsMutex, this);	// Lock the mutex until this function ends
+	SDL_SaveBMP(_hwscreen, filename);
+	return true;
+}
+
+void OSystem_SDL::setFullscreenMode(bool enable) {
+	if (_full_screen != enable) {
+		assert(_hwscreen != 0);
+		_full_screen ^= true;
+
+		if (_mouseDrawn)
+			undraw_mouse();
+	
+#if defined(MACOSX) && !SDL_VERSION_ATLEAST(1, 2, 6)
+		// On OS X, SDL_WM_ToggleFullScreen is currently not implemented. Worse,
+		// before SDL 1.2.6 it always returned -1 (which would indicate a
+		// successful switch). So we simply don't call it at all and use
+		// hotswap_gfx_mode() directly to switch to fullscreen mode.
+		hotswap_gfx_mode();
+#else
+		if (!SDL_WM_ToggleFullScreen(_hwscreen)) {
+			// if ToggleFullScreen fails, achieve the same effect with hotswap gfx mode
+			hotswap_gfx_mode();
+		} else {
+			// Make sure that an EVENT_SCREEN_CHANGED gets sent later
+			_modeChanged = true;
+		}
+#endif
+	}
+}
+
+void OSystem_SDL::copy_rect(const byte *src, int pitch, int x, int y, int w, int h) {
+	if (_screen == NULL)
+		return;
+
+	Common::StackLock lock(_graphicsMutex, this);	// Lock the mutex until this function ends
+	
+	if (((long)src & 3) == 0 && pitch == _screenWidth && x==0 && y==0 &&
+			w==_screenWidth && h==_screenHeight && _mode_flags&DF_WANT_RECT_OPTIM) {
+		/* Special, optimized case for full screen updates.
+		 * It tries to determine what areas were actually changed,
+		 * and just updates those, on the actual display. */
+		add_dirty_rgn_auto(src);
+	} else {
+		/* Clip the coordinates */
+		if (x < 0) {
+			w += x;
+			src -= x;
+			x = 0;
+		}
+
+		if (y < 0) {
+			h += y;
+			src -= y * pitch;
+			y = 0;
+		}
+
+		if (w > _screenWidth - x) {
+			w = _screenWidth - x;
+		}
+
+		if (h > _screenHeight - y) {
+			h = _screenHeight - y;
+		}
+
+		if (w <= 0 || h <= 0)
+			return;
+
+		cksum_valid = false;
+		add_dirty_rect(x, y, w, h);
+	}
+
+	/* FIXME: undraw mouse only if the draw rect intersects with the mouse rect */
+	if (_mouseDrawn)
+		undraw_mouse();
+
+	// Try to lock the screen surface
+	if (SDL_LockSurface(_screen) == -1)
+		error("SDL_LockSurface failed: %s", SDL_GetError());
+
+	byte *dst = (byte *)_screen->pixels + y * _screenWidth + x;
+
+	if (_screenWidth==pitch && pitch == w) {
+		memcpy(dst, src, h*w);
+	} else {
+		do {
+			memcpy(dst, src, w);
+			src += pitch;
+			dst += _screenWidth;
+		} while (--h);
+	}
+
+	// Unlock the screen surface
+	SDL_UnlockSurface(_screen);
+}
+
+
+void OSystem_SDL::add_dirty_rect(int x, int y, int w, int h) {
+	if (_forceFull)
+		return;
+
+	if (_num_dirty_rects == NUM_DIRTY_RECT)
+		_forceFull = true;
+	else {
+		SDL_Rect *r = &_dirty_rect_list[_num_dirty_rects++];
+		// Extend the dirty region by 1 pixel for scalers
+		// that "smear" the screen, e.g. 2xSAI
+		if (_mode_flags & DF_UPDATE_EXPAND_1_PIXEL) {
+			x--;
+			y--;
+			w+=2;
+			h+=2;
+		}
+
+		// clip
+		if (x < 0) {
+			w += x; x = 0;
+		}
+
+		if (y < 0) {
+			h += y;
+			y=0;
+		}
+
+		if (w > _screenWidth - x) {
+			w = _screenWidth - x;
+		}
+
+		if (h > _screenHeight - y) {
+			h = _screenHeight - y;
+		}
+
+		if (_adjustAspectRatio)
+			makeRectStretchable(x, y, w, h);
+	
+		r->x = x;
+		r->y = y;
+		r->w = w;
+		r->h = h;
+	}
+}
+
+
+void OSystem_SDL::mk_checksums(const byte *buf) {
+	uint32 *sums = _dirty_checksums;
+	uint x,y;
+	const uint last_x = (uint)_screenWidth / 8;
+	const uint last_y = (uint)_screenHeight / 8;
+
+	const uint BASE = 65521; /* largest prime smaller than 65536 */
+
+	/* the 8x8 blocks in buf are enumerated starting in the top left corner and
+	 * reading each line at a time from left to right */
+	for(y = 0; y != last_y; y++, buf += _screenWidth * (8 - 1))
+		for(x = 0; x != last_x; x++, buf += 8) {
+			// Adler32 checksum algorithm (from RFC1950, used by gzip and zlib).
+			// This computes the Adler32 checksum of a 8x8 pixel block. Note
+			// that we can do the modulo operation (which is the slowest part)
+			// of the algorithm) at the end, instead of doing each iteration,
+			// since we only have 64 iterations in total - and thus s1 and
+			// s2 can't overflow anyway.
+			uint32 s1 = 1;
+			uint32 s2 = 0;
+			const byte *ptr = buf;
+			for (int subY = 0; subY < 8; subY++) {
+				for (int subX = 0; subX < 8; subX++) {
+					s1 += ptr[subX];
+					s2 += s1;
+				}
+				ptr += _screenWidth;
+			}
+
+			s1 %= BASE;
+			s2 %= BASE;
+
+			/* output the checksum for this block */
+			*sums++ =  (s2 << 16) + s1;
+	}
+}
+
+void OSystem_SDL::add_dirty_rgn_auto(const byte *buf) {
+	assert(((long)buf & 3) == 0);
+
+	/* generate a table of the checksums */
+	mk_checksums(buf);
+
+	if (!cksum_valid) {
+		_forceFull = true;
+		cksum_valid = true;
+	}
+
+	/* go through the checksum list, compare it with the previous checksums,
+		 and add all dirty rectangles to a list. try to combine small rectangles
+		 into bigger ones in a simple way */
+	if (!_forceFull) {
+		int x,y,w;
+		uint32 *ck = _dirty_checksums;
+
+		for(y = 0; y!=_screenHeight / 8; y++) {
+			for(x = 0; x!=_screenWidth / 8; x++, ck++) {
+				if (ck[0] != ck[CKSUM_NUM]) {
+					/* found a dirty 8x8 block, now go as far to the right as possible,
+						 and at the same time, unmark the dirty status by setting old to new. */
+					w=0;
+					do {
+						ck[w + CKSUM_NUM] = ck[w];
+						w++;
+					} while (x + w != _screenWidth / 8 && ck[w] != ck[w + CKSUM_NUM]);
+
+					add_dirty_rect(x * 8, y * 8, w * 8, 8);
+
+					if (_forceFull)
+						goto get_out;
+				}
+			}
+		}
+	} else {
+		get_out:;
+		/* Copy old checksums to new */
+		memcpy(_dirty_checksums + CKSUM_NUM, _dirty_checksums, CKSUM_NUM * sizeof(uint32));
+	}
+}
+
+int16 OSystem_SDL::get_height() {
+	return _screenHeight;
+}
+
+int16 OSystem_SDL::get_width() {
+	return _screenWidth;
+}
+
+void OSystem_SDL::setPalette(const byte *colors, uint start, uint num) {
+	const byte *b = colors;
+	uint i;
+	SDL_Color *base = _currentPalette + start;
+	for (i = 0; i < num; i++) {
+		base[i].r = b[0];
+		base[i].g = b[1];
+		base[i].b = b[2];
+		b += 4;
+	}
+
+	if (start < _paletteDirtyStart)
+		_paletteDirtyStart = start;
+
+	if (start + num > _paletteDirtyEnd)
+		_paletteDirtyEnd = start + num;
+}
+
+void OSystem_SDL::move_screen(int dx, int dy, int height) {
+
+	// Short circuit check - do we have to do anything anyway?
+	if ((dx == 0 && dy == 0) || height <= 0)
+		return;
+
+	Common::StackLock lock(_graphicsMutex, this);	// Lock the mutex until this function ends
+
+	byte *src, *dst;
+	int x, y;
+
+	// We'll have to do a full screen redraw anyway, so set the flag.
+	_forceFull = true;
+
+	// Hide the mouse
+	if (_mouseDrawn)
+		undraw_mouse();
+
+	// Try to lock the screen surface
+	if (SDL_LockSurface(_screen) == -1)
+		error("SDL_LockSurface failed: %s", SDL_GetError());
+
+	// vertical movement
+	if (dy > 0) {
+		// move down - copy from bottom to top
+		dst = (byte *)_screen->pixels + (height - 1) * _screenWidth;
+		src = dst - dy * _screenWidth;
+		for (y = dy; y < height; y++) {
+			memcpy(dst, src, _screenWidth);
+			src -= _screenWidth;
+			dst -= _screenWidth;
+		}
+	} else if (dy < 0) {
+		// move up - copy from top to bottom
+		dst = (byte *)_screen->pixels;
+		src = dst - dy * _screenWidth;
+		for (y = -dy; y < height; y++) {
+			memcpy(dst, src, _screenWidth);
+			src += _screenWidth;
+			dst += _screenWidth;
+		}
+	}
+
+	// horizontal movement
+	if (dx > 0) {
+		// move right - copy from right to left
+		dst = (byte *)_screen->pixels + (_screenWidth - 1);
+		src = dst - dx;
+		for (y = 0; y < height; y++) {
+			for (x = dx; x < _screenWidth; x++) {
+				*dst-- = *src--;
+			}
+			src += _screenWidth + (_screenWidth - dx);
+			dst += _screenWidth + (_screenWidth - dx);
+		}
+	} else if (dx < 0)  {
+		// move left - copy from left to right
+		dst = (byte *)_screen->pixels;
+		src = dst - dx;
+		for (y = 0; y < height; y++) {
+			for (x = -dx; x < _screenWidth; x++) {
+				*dst++ = *src++;
+			}
+			src += _screenWidth - (_screenWidth + dx);
+			dst += _screenWidth - (_screenWidth + dx);
+		}
+	}
+
+	// Unlock the screen surface
+	SDL_UnlockSurface(_screen);
+}
+
+void OSystem_SDL::set_shake_pos(int shake_pos) {
+	_newShakePos = shake_pos;
+}
+
+
+#pragma mark -
+#pragma mark --- Overlays ---
+#pragma mark -
+
+void OSystem_SDL::show_overlay() {
+	// hide the mouse
+	undraw_mouse();
+
+	_overlayVisible = true;
+	clear_overlay();
+}
+
+void OSystem_SDL::hide_overlay() {
+	// hide the mouse
+	undraw_mouse();
+
+	_overlayVisible = false;
+	_forceFull = true;
+}
+
+void OSystem_SDL::clear_overlay() {
+	if (!_overlayVisible)
+		return;
+	
+	Common::StackLock lock(_graphicsMutex, this);	// Lock the mutex until this function ends
+	
+	// hide the mouse
+	undraw_mouse();
+
+	// Clear the overlay by making the game screen "look through" everywhere.
+	SDL_Rect src, dst;
+	src.x = src.y = 0;
+	dst.x = dst.y = 1;
+	src.w = dst.w = _screenWidth;
+	src.h = dst.h = _screenHeight;
+	if (SDL_BlitSurface(_screen, &src, _tmpscreen, &dst) != 0)
+		error("SDL_BlitSurface failed: %s", SDL_GetError());
+
+	_forceFull = true;
+}
+
+void OSystem_SDL::grab_overlay(int16 *buf, int pitch) {
+	if (!_overlayVisible)
+		return;
+
+	if (_tmpscreen == NULL)
+		return;
+
+	// hide the mouse
+	undraw_mouse();
+
+	if (SDL_LockSurface(_tmpscreen) == -1)
+		error("SDL_LockSurface failed: %s", SDL_GetError());
+
+	int16 *src = (int16 *)_tmpscreen->pixels + _tmpScreenWidth + 1;
+	int h = _screenHeight;
+	do {
+		memcpy(buf, src, _screenWidth*2);
+		src += _tmpScreenWidth;
+		buf += pitch;
+	} while (--h);
+
+	SDL_UnlockSurface(_tmpscreen);
+}
+
+void OSystem_SDL::copy_rect_overlay(const int16 *buf, int pitch, int x, int y, int w, int h) {
+	if (!_overlayVisible)
+		return;
+
+	if (_tmpscreen == NULL)
+		return;
+
+	// Clip the coordinates
+	if (x < 0) {
+		w += x;
+		buf -= x;
+		x = 0;
+	}
+
+	if (y < 0) {
+		h += y; buf -= y * pitch;
+		y = 0;
+	}
+
+	if (w > _screenWidth - x) {
+		w = _screenWidth - x;
+	}
+
+	if (h > _screenHeight-y) {
+		h = _screenHeight - y;
+	}
+
+	if (w <= 0 || h <= 0)
+		return;
+
+	// Mark the modified region as dirty
+	cksum_valid = false;
+	add_dirty_rect(x, y, w, h);
+
+	/* FIXME: undraw mouse only if the draw rect intersects with the mouse rect */
+	undraw_mouse();
+
+	if (SDL_LockSurface(_tmpscreen) == -1)
+		error("SDL_LockSurface failed: %s", SDL_GetError());
+
+	int16 *dst = (int16 *)_tmpscreen->pixels + (y + 1) * _tmpScreenWidth + (x + 1);
+	do {
+		memcpy(dst, buf, w * 2);
+		dst += _tmpScreenWidth;
+		buf += pitch;
+	} while (--h);
+
+	SDL_UnlockSurface(_tmpscreen);
+}
+
+int16 OSystem_SDL::RGBToColor(uint8 r, uint8 g, uint8 b) {
+	return SDL_MapRGB(_tmpscreen->format, r, g, b);
+}
+
+void OSystem_SDL::colorToRGB(int16 color, uint8 &r, uint8 &g, uint8 &b) {
+	SDL_GetRGB(color, _tmpscreen->format, &r, &g, &b);
+}
+
+
+#pragma mark -
+#pragma mark --- Mouse ---
+#pragma mark -
+
+bool OSystem_SDL::show_mouse(bool visible) {
+	if (_mouseVisible == visible)
+		return visible;
+	
+	bool last = _mouseVisible;
+	_mouseVisible = visible;
+
+	if (visible)
+		draw_mouse();
+	else
+		undraw_mouse();
+
+	return last;
+}
+
+void OSystem_SDL::set_mouse_pos(int x, int y) {
+	if (x != _mouseCurState.x || y != _mouseCurState.y) {
+		_mouseCurState.x = x;
+		_mouseCurState.y = y;
+		undraw_mouse();
+		updateScreen();
+	}
+}
+
+void OSystem_SDL::warp_mouse(int x, int y) {
+	if (_mouseCurState.x != x || _mouseCurState.y != y) {
+		SDL_WarpMouse(x * _scaleFactor, y * _scaleFactor);
+
+		// SDL_WarpMouse() generates a mouse movement event, so
+		// set_mouse_pos() would be called eventually. However, the
+		// cannon script in CoMI calls this function twice each time
+		// the cannon is reloaded. Unless we update the mouse position
+		// immediately the second call is ignored, causing the cannon
+		// to change its aim.
+
+		set_mouse_pos(x, y);
+	}
+}
+	
+void OSystem_SDL::set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y) {
+	assert(w <= MAX_MOUSE_W);
+	assert(h <= MAX_MOUSE_H);
+	_mouseCurState.w = w;
+	_mouseCurState.h = h;
+
+	_mouseHotspotX = hotspot_x;
+	_mouseHotspotY = hotspot_y;
+
+	_mouseData = buf;
+
+	undraw_mouse();
+}
+
+void OSystem_SDL::toggleMouseGrab() {
+	if (SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_OFF)
+		SDL_WM_GrabInput(SDL_GRAB_ON);
+	else
+		SDL_WM_GrabInput(SDL_GRAB_OFF);
+}
+
+void OSystem_SDL::draw_mouse() {
+	if (_mouseDrawn || !_mouseVisible)
+		return;
+
+	int x = _mouseCurState.x - _mouseHotspotX;
+	int y = _mouseCurState.y - _mouseHotspotY;
+	int w = _mouseCurState.w;
+	int h = _mouseCurState.h;
+	byte color;
+	const byte *src = _mouseData;		// Image representing the mouse
+
+	// clip the mouse rect, and addjust the src pointer accordingly
+	if (x < 0) {
+		w += x;
+		src -= x;
+		x = 0;
+	}
+	if (y < 0) {
+		h += y;
+		src -= y * _mouseCurState.w;
+		y = 0;
+	}
+
+	if (w > _screenWidth - x)
+		w = _screenWidth - x;
+	if (h > _screenHeight - y)
+		h = _screenHeight - y;
+
+	// Quick check to see if anything has to be drawn at all
+	if (w <= 0 || h <= 0)
+		return;
+
+	// Store the bounding box so that undraw mouse can restore the area the
+	// mouse currently covers to its original content.
+	_mouseOldState.x = x;
+	_mouseOldState.y = y;
+	_mouseOldState.w = w;
+	_mouseOldState.h = h;
+
+	// Draw the mouse cursor; backup the covered area in "bak"
+	if (SDL_LockSurface(_overlayVisible ? _tmpscreen : _screen) == -1)
+		error("SDL_LockSurface failed: %s", SDL_GetError());
+
+	// Mark as dirty
+	add_dirty_rect(x, y, w, h);
+
+	if (!_overlayVisible) {
+		byte *bak = _mouseBackup;		// Surface used to backup the area obscured by the mouse
+		byte *dst;					// Surface we are drawing into
+	
+		dst = (byte *)_screen->pixels + y * _screenWidth + x;
+		while (h > 0) {
+			int width = w;
+			while (width > 0) {
+				*bak++ = *dst;
+				color = *src++;
+				if (color != 0xFF)	// 0xFF = transparent, don't draw
+					*dst = color;
+				dst++;
+				width--;
+			}
+			src += _mouseCurState.w - w;
+			bak += MAX_MOUSE_W - w;
+			dst += _screenWidth - w;
+			h--;
+		}
+	
+	} else {
+		uint16 *bak = (uint16 *)_mouseBackup;	// Surface used to backup the area obscured by the mouse
+		uint16 *dst;					// Surface we are drawing into
+	
+		dst = (uint16 *)_tmpscreen->pixels + (y + 1) * _tmpScreenWidth + (x + 1);
+		while (h > 0) {
+			int width = w;
+			while (width > 0) {
+				*bak++ = *dst;
+				color = *src++;
+				if (color != 0xFF)	// 0xFF = transparent, don't draw
+					*dst = RGBToColor(_currentPalette[color].r, _currentPalette[color].g, _currentPalette[color].b);
+				dst++;
+				width--;
+			}
+			src += _mouseCurState.w - w;
+			bak += MAX_MOUSE_W - w;
+			dst += _tmpScreenWidth - w;
+			h--;
+		}
+	}
+
+	SDL_UnlockSurface(_overlayVisible ? _tmpscreen : _screen);
+
+	// Finally, set the flag to indicate the mouse has been drawn
+	_mouseDrawn = true;
+}
+
+void OSystem_SDL::undraw_mouse() {
+	if (!_mouseDrawn)
+		return;
+	_mouseDrawn = false;
+
+	if (SDL_LockSurface(_overlayVisible ? _tmpscreen : _screen) == -1)
+		error("SDL_LockSurface failed: %s", SDL_GetError());
+
+	const int old_mouse_x = _mouseOldState.x;
+	const int old_mouse_y = _mouseOldState.y;
+	const int old_mouse_w = _mouseOldState.w;
+	const int old_mouse_h = _mouseOldState.h;
+	int x, y;
+
+	if (!_overlayVisible) {
+		byte *dst, *bak = _mouseBackup;
+
+		// No need to do clipping here, since draw_mouse() did that already
+		dst = (byte *)_screen->pixels + old_mouse_y * _screenWidth + old_mouse_x;
+		for (y = 0; y < old_mouse_h; ++y, bak += MAX_MOUSE_W, dst += _screenWidth) {
+			for (x = 0; x < old_mouse_w; ++x) {
+				dst[x] = bak[x];
+			}
+		}
+	
+	} else {
+
+		uint16 *dst, *bak = (uint16 *)_mouseBackup;
+	
+		// No need to do clipping here, since draw_mouse() did that already
+		dst = (uint16 *)_tmpscreen->pixels + (old_mouse_y + 1) * _tmpScreenWidth + (old_mouse_x + 1);
+		for (y = 0; y < old_mouse_h; ++y, bak += MAX_MOUSE_W, dst += _tmpScreenWidth) {
+			for (x = 0; x < old_mouse_w; ++x) {
+				dst[x] = bak[x];
+			}
+		}
+	}
+
+	add_dirty_rect(old_mouse_x, old_mouse_y, old_mouse_w, old_mouse_h);
+
+	SDL_UnlockSurface(_overlayVisible ? _tmpscreen : _screen);
+}
+
diff --git a/backends/sdl/module.mk b/backends/sdl/module.mk
index aa92b2035d..c2d84218fe 100644
--- a/backends/sdl/module.mk
+++ b/backends/sdl/module.mk
@@ -1,8 +1,9 @@
 MODULE := backends/sdl
 
 MODULE_OBJS := \
-	backends/sdl/sdl.o \
-	backends/sdl/sdl-common.o
+	backends/sdl/events.o \
+	backends/sdl/graphics.o \
+	backends/sdl/sdl.o
 
 MODULE_DIRS += \
 	backend/sdl
diff --git a/backends/sdl/sdl-common.cpp b/backends/sdl/sdl-common.cpp
deleted file mode 100644
index 3fc8e7c2ec..0000000000
--- a/backends/sdl/sdl-common.cpp
+++ /dev/null
@@ -1,1649 +0,0 @@
-/* ScummVM - Scumm Interpreter
- * Copyright (C) 2001-2004 The ScummVM project
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
-
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
-
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
- *
- * $Header$
- *
- */
-
-#include "backends/sdl/sdl-common.h"
-#include "sound/mididrv.h"
-#include "common/config-manager.h"
-#include "common/scaler.h"
-#include "common/util.h"
-
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
-
-#include "scummvm.xpm"
-
-
-// FIXME move joystick defines out and replace with confile file options
-// we should really allow users to map any key to a joystick button
-#define JOY_DEADZONE 3200
-#define JOY_ANALOG
-// #define JOY_INVERT_Y
-#define JOY_XAXIS 0
-#define JOY_YAXIS 1
-// buttons
-#define JOY_BUT_LMOUSE 0
-#define JOY_BUT_RMOUSE 2
-#define JOY_BUT_ESCAPE 3
-#define JOY_BUT_PERIOD 1
-#define JOY_BUT_SPACE 4
-#define JOY_BUT_F5 5
-
-static const OSystem::GraphicsMode s_supportedGraphicsModes[] = {
-	{"1x", "Normal (no scaling)", GFX_NORMAL},
-	{"2x", "2x", GFX_DOUBLESIZE},
-	{"3x", "3x", GFX_TRIPLESIZE},
-	{"2xsai", "2xSAI", GFX_2XSAI},
-	{"super2xsai", "Super2xSAI", GFX_SUPER2XSAI},
-	{"supereagle", "SuperEagle", GFX_SUPEREAGLE},
-	{"advmame2x", "AdvMAME2x", GFX_ADVMAME2X},
-	{"advmame3x", "AdvMAME3x", GFX_ADVMAME3X},
-	{"hq2x", "HQ2x", GFX_HQ2X},
-	{"hq3x", "HQ3x", GFX_HQ3X},
-	{"tv2x", "TV2x", GFX_TV2X},
-	{"dotmatrix", "DotMatrix", GFX_DOTMATRIX},
-	{0, 0, 0}
-};
-
-static const int s_gfxModeSwitchTable[][4] = {
-		{ GFX_NORMAL, GFX_DOUBLESIZE, GFX_TRIPLESIZE, -1 },
-		{ GFX_NORMAL, GFX_ADVMAME2X, GFX_ADVMAME3X, -1 },
-		{ GFX_NORMAL, GFX_HQ2X, GFX_HQ3X, -1 },
-		{ GFX_NORMAL, GFX_2XSAI, -1, -1 },
-		{ GFX_NORMAL, GFX_SUPER2XSAI, -1, -1 },
-		{ GFX_NORMAL, GFX_SUPEREAGLE, -1, -1 },
-		{ GFX_NORMAL, GFX_TV2X, -1, -1 },
-		{ GFX_NORMAL, GFX_DOTMATRIX, -1, -1 }
-	};
-
-
-OSystem *OSystem_SDL_create() {
-	return OSystem_SDL_Common::create();
-}
-
-OSystem *OSystem_SDL_Common::create() {
-	OSystem_SDL_Common *syst = OSystem_SDL_Common::create_intern();
-
-	syst->init_intern();
-
-	return syst;
-}
-
-void OSystem_SDL_Common::init_intern() {
-
-	int joystick_num = ConfMan.getInt("joystick_num");
-	uint32 sdlFlags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
-
-	if (joystick_num > -1)
-		sdlFlags |= SDL_INIT_JOYSTICK;
-
-	if (SDL_Init(sdlFlags) == -1) {
-		error("Could not initialize SDL: %s", SDL_GetError());
-	}
-
-	_graphicsMutex = createMutex();
-
-	SDL_ShowCursor(SDL_DISABLE);
-	
-	// Enable unicode support if possible
-	SDL_EnableUNICODE(1); 
-
-	cksum_valid = false;
-	_mode = GFX_DOUBLESIZE;
-	_full_screen = ConfMan.getBool("fullscreen");
-	_adjustAspectRatio = ConfMan.getBool("aspect_ratio");
-	_mode_flags = 0;
-
-
-#ifndef MACOSX		// Don't set icon on OS X, as we use a nicer external icon there
-	// Setup the icon
-	setup_icon();
-#endif
-
-	// enable joystick
-	if (joystick_num > -1 && SDL_NumJoysticks() > 0) {
-		printf("Using joystick: %s\n", SDL_JoystickName(0));
-		init_joystick(joystick_num);
-	}
-}
-
-void OSystem_SDL_Common::set_timer(TimerProc callback, int timer) {
-	SDL_SetTimer(timer, (SDL_TimerCallback) callback);
-}
-
-OSystem_SDL_Common::OSystem_SDL_Common()
-	: _screen(0), _screenWidth(0), _screenHeight(0),
-	_tmpscreen(0), _tmpScreenWidth(0), _overlayVisible(false),
-	_cdrom(0), _scaler_proc(0), _modeChanged(false), _dirty_checksums(0),
-	_mouseVisible(false), _mouseDrawn(false), _mouseData(0),
-	_mouseHotspotX(0), _mouseHotspotY(0),
-	_currentShakePos(0), _newShakePos(0),
-	_paletteDirtyStart(0), _paletteDirtyEnd(0),
-	_graphicsMutex(0) {
-
-	// allocate palette storage
-	_currentPalette = (SDL_Color *)calloc(sizeof(SDL_Color), 256);
-
-	// allocate the dirty rect storage
-	_mouseBackup = (byte *)malloc(MAX_MOUSE_W * MAX_MOUSE_H * MAX_SCALING * 2);
-
-	// reset mouse state
-	memset(&km, 0, sizeof(km));
-}
-
-OSystem_SDL_Common::~OSystem_SDL_Common() {
-//	unload_gfx_mode();
-
-	if (_dirty_checksums)
-		free(_dirty_checksums);
-	free(_currentPalette);
-	free(_mouseBackup);
-	deleteMutex(_graphicsMutex);
-
-	SDL_ShowCursor(SDL_ENABLE);
-	SDL_Quit();
-}
-
-void OSystem_SDL_Common::initSize(uint w, uint h) {
-	// Avoid redundant res changes
-	if ((int)w == _screenWidth && (int)h == _screenHeight)
-		return;
-
-	_screenWidth = w;
-	_screenHeight = h;
-
-	if (h != 200)
-		_adjustAspectRatio = false;
-
-	CKSUM_NUM = (_screenWidth * _screenHeight / (8 * 8));
-	if (_dirty_checksums)
-		free(_dirty_checksums);
-	_dirty_checksums = (uint32 *)calloc(CKSUM_NUM * 2, sizeof(uint32));
-
-	unload_gfx_mode();
-	load_gfx_mode();
-}
-
-void OSystem_SDL_Common::copy_rect(const byte *src, int pitch, int x, int y, int w, int h) {
-	if (_screen == NULL)
-		return;
-
-	Common::StackLock lock(_graphicsMutex, this);	// Lock the mutex until this function ends
-	
-	if (((long)src & 3) == 0 && pitch == _screenWidth && x==0 && y==0 &&
-			w==_screenWidth && h==_screenHeight && _mode_flags&DF_WANT_RECT_OPTIM) {
-		/* Special, optimized case for full screen updates.
-		 * It tries to determine what areas were actually changed,
-		 * and just updates those, on the actual display. */
-		add_dirty_rgn_auto(src);
-	} else {
-		/* Clip the coordinates */
-		if (x < 0) {
-			w += x;
-			src -= x;
-			x = 0;
-		}
-
-		if (y < 0) {
-			h += y;
-			src -= y * pitch;
-			y = 0;
-		}
-
-		if (w > _screenWidth - x) {
-			w = _screenWidth - x;
-		}
-
-		if (h > _screenHeight - y) {
-			h = _screenHeight - y;
-		}
-
-		if (w <= 0 || h <= 0)
-			return;
-
-		cksum_valid = false;
-		add_dirty_rect(x, y, w, h);
-	}
-
-	/* FIXME: undraw mouse only if the draw rect intersects with the mouse rect */
-	if (_mouseDrawn)
-		undraw_mouse();
-
-	// Try to lock the screen surface
-	if (SDL_LockSurface(_screen) == -1)
-		error("SDL_LockSurface failed: %s", SDL_GetError());
-
-	byte *dst = (byte *)_screen->pixels + y * _screenWidth + x;
-
-	if (_screenWidth==pitch && pitch == w) {
-		memcpy(dst, src, h*w);
-	} else {
-		do {
-			memcpy(dst, src, w);
-			src += pitch;
-			dst += _screenWidth;
-		} while (--h);
-	}
-
-	// Unlock the screen surface
-	SDL_UnlockSurface(_screen);
-}
-
-
-void OSystem_SDL_Common::move_screen(int dx, int dy, int height) {
-
-	// Short circuit check - do we have to do anything anyway?
-	if ((dx == 0 && dy == 0) || height <= 0)
-		return;
-
-	Common::StackLock lock(_graphicsMutex, this);	// Lock the mutex until this function ends
-
-	byte *src, *dst;
-	int x, y;
-
-	// We'll have to do a full screen redraw anyway, so set the flag.
-	_forceFull = true;
-
-	// Hide the mouse
-	if (_mouseDrawn)
-		undraw_mouse();
-
-	// Try to lock the screen surface
-	if (SDL_LockSurface(_screen) == -1)
-		error("SDL_LockSurface failed: %s", SDL_GetError());
-
-	// vertical movement
-	if (dy > 0) {
-		// move down - copy from bottom to top
-		dst = (byte *)_screen->pixels + (height - 1) * _screenWidth;
-		src = dst - dy * _screenWidth;
-		for (y = dy; y < height; y++) {
-			memcpy(dst, src, _screenWidth);
-			src -= _screenWidth;
-			dst -= _screenWidth;
-		}
-	} else if (dy < 0) {
-		// move up - copy from top to bottom
-		dst = (byte *)_screen->pixels;
-		src = dst - dy * _screenWidth;
-		for (y = -dy; y < height; y++) {
-			memcpy(dst, src, _screenWidth);
-			src += _screenWidth;
-			dst += _screenWidth;
-		}
-	}
-
-	// horizontal movement
-	if (dx > 0) {
-		// move right - copy from right to left
-		dst = (byte *)_screen->pixels + (_screenWidth - 1);
-		src = dst - dx;
-		for (y = 0; y < height; y++) {
-			for (x = dx; x < _screenWidth; x++) {
-				*dst-- = *src--;
-			}
-			src += _screenWidth + (_screenWidth - dx);
-			dst += _screenWidth + (_screenWidth - dx);
-		}
-	} else if (dx < 0)  {
-		// move left - copy from left to right
-		dst = (byte *)_screen->pixels;
-		src = dst - dx;
-		for (y = 0; y < height; y++) {
-			for (x = -dx; x < _screenWidth; x++) {
-				*dst++ = *src++;
-			}
-			src += _screenWidth - (_screenWidth + dx);
-			dst += _screenWidth - (_screenWidth + dx);
-		}
-	}
-
-	// Unlock the screen surface
-	SDL_UnlockSurface(_screen);
-}
-
-void OSystem_SDL_Common::add_dirty_rect(int x, int y, int w, int h) {
-	if (_forceFull)
-		return;
-
-	if (_num_dirty_rects == NUM_DIRTY_RECT)
-		_forceFull = true;
-	else {
-		SDL_Rect *r = &_dirty_rect_list[_num_dirty_rects++];
-		// Extend the dirty region by 1 pixel for scalers
-		// that "smear" the screen, e.g. 2xSAI
-		if (_mode_flags & DF_UPDATE_EXPAND_1_PIXEL) {
-			x--;
-			y--;
-			w+=2;
-			h+=2;
-		}
-
-		// clip
-		if (x < 0) {
-			w += x; x = 0;
-		}
-
-		if (y < 0) {
-			h += y;
-			y=0;
-		}
-
-		if (w > _screenWidth - x) {
-			w = _screenWidth - x;
-		}
-
-		if (h > _screenHeight - y) {
-			h = _screenHeight - y;
-		}
-
-		if (_adjustAspectRatio)
-			makeRectStretchable(x, y, w, h);
-	
-		r->x = x;
-		r->y = y;
-		r->w = w;
-		r->h = h;
-	}
-}
-
-
-void OSystem_SDL_Common::mk_checksums(const byte *buf) {
-	uint32 *sums = _dirty_checksums;
-	uint x,y;
-	const uint last_x = (uint)_screenWidth / 8;
-	const uint last_y = (uint)_screenHeight / 8;
-
-	const uint BASE = 65521; /* largest prime smaller than 65536 */
-
-	/* the 8x8 blocks in buf are enumerated starting in the top left corner and
-	 * reading each line at a time from left to right */
-	for(y = 0; y != last_y; y++, buf += _screenWidth * (8 - 1))
-		for(x = 0; x != last_x; x++, buf += 8) {
-			// Adler32 checksum algorithm (from RFC1950, used by gzip and zlib).
-			// This computes the Adler32 checksum of a 8x8 pixel block. Note
-			// that we can do the modulo operation (which is the slowest part)
-			// of the algorithm) at the end, instead of doing each iteration,
-			// since we only have 64 iterations in total - and thus s1 and
-			// s2 can't overflow anyway.
-			uint32 s1 = 1;
-			uint32 s2 = 0;
-			const byte *ptr = buf;
-			for (int subY = 0; subY < 8; subY++) {
-				for (int subX = 0; subX < 8; subX++) {
-					s1 += ptr[subX];
-					s2 += s1;
-				}
-				ptr += _screenWidth;
-			}
-
-			s1 %= BASE;
-			s2 %= BASE;
-
-			/* output the checksum for this block */
-			*sums++ =  (s2 << 16) + s1;
-	}
-}
-
-void OSystem_SDL_Common::add_dirty_rgn_auto(const byte *buf) {
-	assert(((long)buf & 3) == 0);
-
-	/* generate a table of the checksums */
-	mk_checksums(buf);
-
-	if (!cksum_valid) {
-		_forceFull = true;
-		cksum_valid = true;
-	}
-
-	/* go through the checksum list, compare it with the previous checksums,
-		 and add all dirty rectangles to a list. try to combine small rectangles
-		 into bigger ones in a simple way */
-	if (!_forceFull) {
-		int x,y,w;
-		uint32 *ck = _dirty_checksums;
-
-		for(y = 0; y!=_screenHeight / 8; y++) {
-			for(x = 0; x!=_screenWidth / 8; x++, ck++) {
-				if (ck[0] != ck[CKSUM_NUM]) {
-					/* found a dirty 8x8 block, now go as far to the right as possible,
-						 and at the same time, unmark the dirty status by setting old to new. */
-					w=0;
-					do {
-						ck[w + CKSUM_NUM] = ck[w];
-						w++;
-					} while (x + w != _screenWidth / 8 && ck[w] != ck[w + CKSUM_NUM]);
-
-					add_dirty_rect(x * 8, y * 8, w * 8, 8);
-
-					if (_forceFull)
-						goto get_out;
-				}
-			}
-		}
-	} else {
-		get_out:;
-		/* Copy old checksums to new */
-		memcpy(_dirty_checksums + CKSUM_NUM, _dirty_checksums, CKSUM_NUM * sizeof(uint32));
-	}
-}
-
-void OSystem_SDL_Common::kbd_mouse() {
-	uint32 curTime = get_msecs();
-	if (curTime >= km.last_time + km.delay_time) {
-		km.last_time = curTime;
-		if (km.x_down_count == 1) {
-			km.x_down_time = curTime;
-			km.x_down_count = 2;
-		}
-		if (km.y_down_count == 1) {
-			km.y_down_time = curTime;
-			km.y_down_count = 2;
-		}
-
-		if (km.x_vel || km.y_vel) {
-			if (km.x_down_count) {
-				if (curTime > km.x_down_time + km.delay_time * 12) {
-					if (km.x_vel > 0)
-						km.x_vel++;
-					else
-						km.x_vel--;
-				} else if (curTime > km.x_down_time + km.delay_time * 8) {
-					if (km.x_vel > 0)
-						km.x_vel = 5;
-					else
-						km.x_vel = -5;
-				}
-			}
-			if (km.y_down_count) {
-				if (curTime > km.y_down_time + km.delay_time * 12) {
-					if (km.y_vel > 0)
-						km.y_vel++;
-					else
-						km.y_vel--;
-				} else if (curTime > km.y_down_time + km.delay_time * 8) {
-					if (km.y_vel > 0)
-						km.y_vel = 5;
-					else
-						km.y_vel = -5;
-				}
-			}
-
-			km.x += km.x_vel;
-			km.y += km.y_vel;
-
-			if (km.x < 0) {
-				km.x = 0;
-				km.x_vel = -1;
-				km.x_down_count = 1;
-			} else if (km.x > km.x_max) {
-				km.x = km.x_max;
-				km.x_vel = 1;
-				km.x_down_count = 1;
-			}
-
-			if (km.y < 0) {
-				km.y = 0;
-				km.y_vel = -1;
-				km.y_down_count = 1;
-			} else if (km.y > km.y_max) {
-				km.y = km.y_max;
-				km.y_vel = 1;
-				km.y_down_count = 1;
-			}
-
-			SDL_WarpMouse(km.x, km.y);
-		}
-	}
-}
-
-bool OSystem_SDL_Common::show_mouse(bool visible) {
-	if (_mouseVisible == visible)
-		return visible;
-	
-	bool last = _mouseVisible;
-	_mouseVisible = visible;
-
-	if (visible)
-		draw_mouse();
-	else
-		undraw_mouse();
-
-	return last;
-}
-
-void OSystem_SDL_Common::set_mouse_pos(int x, int y) {
-	if (x != _mouseCurState.x || y != _mouseCurState.y) {
-		_mouseCurState.x = x;
-		_mouseCurState.y = y;
-		undraw_mouse();
-		updateScreen();
-	}
-}
-
-void OSystem_SDL_Common::warp_mouse(int x, int y) {
-	if (_mouseCurState.x != x || _mouseCurState.y != y) {
-		SDL_WarpMouse(x * _scaleFactor, y * _scaleFactor);
-
-		// SDL_WarpMouse() generates a mouse movement event, so
-		// set_mouse_pos() would be called eventually. However, the
-		// cannon script in CoMI calls this function twice each time
-		// the cannon is reloaded. Unless we update the mouse position
-		// immediately the second call is ignored, causing the cannon
-		// to change its aim.
-
-		set_mouse_pos(x, y);
-	}
-}
-	
-void OSystem_SDL_Common::set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y) {
-	assert(w <= MAX_MOUSE_W);
-	assert(h <= MAX_MOUSE_H);
-	_mouseCurState.w = w;
-	_mouseCurState.h = h;
-
-	_mouseHotspotX = hotspot_x;
-	_mouseHotspotY = hotspot_y;
-
-	_mouseData = buf;
-
-	undraw_mouse();
-}
-
-void OSystem_SDL_Common::set_shake_pos(int shake_pos) {
-	_newShakePos = shake_pos;
-}
-
-uint32 OSystem_SDL_Common::get_msecs() {
-	return SDL_GetTicks();	
-}
-
-void OSystem_SDL_Common::delay_msecs(uint msecs) {
-	SDL_Delay(msecs);
-}
-
-static int mapKey(SDLKey key, SDLMod mod, Uint16 unicode)
-{
-	if (key >= SDLK_F1 && key <= SDLK_F9) {
-		return key - SDLK_F1 + 315;
-	} else if (key >= SDLK_KP0 && key <= SDLK_KP9) {
-		return key - SDLK_KP0 + '0';
-	} else if (key >= SDLK_UP && key <= SDLK_PAGEDOWN) {
-		return key;
-	} else if (unicode) {
-		return unicode;
-	} else if (key >= 'a' && key <= 'z' && mod & KMOD_SHIFT) {
-		return key & ~0x20;
-	} else if (key >= SDLK_NUMLOCK && key <= SDLK_EURO) {
-		return 0;
-	}
-	return key;
-}
-
-void OSystem_SDL_Common::fillMouseEvent(Event &event, int x, int y) {
-	event.mouse.x = x;
-	event.mouse.y = y;
-	
-	// Update the "keyboard mouse" coords
-	km.x = event.mouse.x;
-	km.y = event.mouse.y;
-
-	// Adjust for the screen scaling
-	event.mouse.x /= _scaleFactor;
-	event.mouse.y /= _scaleFactor;
-
-	// Optionally perform aspect ratio adjusting
-	if (_adjustAspectRatio)
-		event.mouse.y = aspect2Real(event.mouse.y);
-}
-
-bool OSystem_SDL_Common::poll_event(Event *event) {
-	SDL_Event ev;
-	int axis;
-	byte b = 0;
-	
-	kbd_mouse();
-	
-	// If the screen mode changed, send an EVENT_SCREEN_CHANGED
-	if (_modeChanged) {
-		_modeChanged = false;
-		event->event_code = EVENT_SCREEN_CHANGED;
-		return true;
-	}
-
-	while(SDL_PollEvent(&ev)) {
-		switch(ev.type) {
-		case SDL_KEYDOWN:
-#ifdef LINUPY
-			// Yopy has no ALT key, steal the SHIFT key 
-			// (which isn't used much anyway)
-			if (ev.key.keysym.mod & KMOD_SHIFT)
-				b |= KBD_ALT;
-			if (ev.key.keysym.mod & KMOD_CTRL)
-				b |= KBD_CTRL;
-#else
-			if (ev.key.keysym.mod & KMOD_SHIFT)
-				b |= KBD_SHIFT;
-			if (ev.key.keysym.mod & KMOD_CTRL)
-				b |= KBD_CTRL;
-			if (ev.key.keysym.mod & KMOD_ALT)
-				b |= KBD_ALT;
-#endif
-			event->kbd.flags = b;
-
-			// Alt-Return toggles full screen mode				
-			if (b == KBD_ALT && ev.key.keysym.sym == SDLK_RETURN) {
-				setFeatureState(kFeatureFullscreenMode, !_full_screen);
-				break;
-			}
-
-			if (b == KBD_ALT && ev.key.keysym.sym == 's') {
-				char filename[20];
-
-				for (int n = 0;; n++) {
-					SDL_RWops *file;
-
-					sprintf(filename, "scummvm%05d.bmp", n);
-					file = SDL_RWFromFile(filename, "r");
-					if (!file)
-						break;
-					SDL_RWclose(file);
-				}
-				if (save_screenshot(filename))
-					printf("Saved '%s'\n", filename);
-				else
-					printf("Could not save screenshot!\n");
-				break;
-			}
-
-#ifdef MACOSX
-			// On Macintosh', Cmd-Q quits
-			if ((ev.key.keysym.mod & KMOD_META) && ev.key.keysym.sym == 'q') {
-				event->event_code = EVENT_QUIT;
-				return true;
-			}
-#else
-			// Ctrl-m toggles mouse capture
-			if (b == KBD_CTRL && ev.key.keysym.sym == 'm') {
-				toggleMouseGrab();
-				break;
-			}
-
-			// Ctrl-z and Alt-X quit
-			if ((b == KBD_CTRL && ev.key.keysym.sym == 'z') || (b == KBD_ALT && ev.key.keysym.sym == 'x')) {
-				event->event_code = EVENT_QUIT;
-				return true;
-			}
-#endif
-
-			// Ctrl-Alt-<key> will change the GFX mode
-			if ((b & (KBD_CTRL|KBD_ALT)) == (KBD_CTRL|KBD_ALT)) {
-				// FIXME EVIL HACK: This shouldn't be a static int, rather it
-				// should be a member variable. Furthermore, it shouldn't be
-				// set in this code, rather it should be set by load_gfx_mode().
-				// But for now this quick&dirty hack works.
-				static int _scalerType = 0;
-				if (_mode != GFX_NORMAL) {
-					// Try to figure out which gfx mode "group" we are in
-					// This is just a temporary hack until the proper solution
-					// (i.e. code in load_gfx_mode()) is in effect.
-					for (int i = 0; i < ARRAYSIZE(s_gfxModeSwitchTable); i++) {
-						if (s_gfxModeSwitchTable[i][1] == _mode || s_gfxModeSwitchTable[i][2] == _mode) {
-							_scalerType = i;
-							break;
-						}
-					}
-				}
-				
-				int factor = _scaleFactor - 1;
-
-				// Ctrl-Alt-a toggles aspect ratio correction
-				if (ev.key.keysym.sym == 'a') {
-					setFeatureState(kFeatureAspectRatioCorrection, !_adjustAspectRatio);
-					break;
-				}
-
-				// Increase/decrease the scale factor
-				// TODO: Shall we 'wrap around' here?
-				if (ev.key.keysym.sym == '=' || ev.key.keysym.sym == '+' || ev.key.keysym.sym == '-') {
-					factor += (ev.key.keysym.sym == '-' ? -1 : +1);
-					if (0 <= factor && factor < 4 && s_gfxModeSwitchTable[_scalerType][factor] >= 0) {
-						setGraphicsMode(s_gfxModeSwitchTable[_scalerType][factor]);
-					}
-					break;
-				}
-				
-				if ('1' <= ev.key.keysym.sym && ev.key.keysym.sym <= '9') {
-					_scalerType = ev.key.keysym.sym - '1';
-					if (_scalerType >= ARRAYSIZE(s_gfxModeSwitchTable))
-						break;
-					
-					while (s_gfxModeSwitchTable[_scalerType][factor] < 0) {
-						assert(factor > 0);
-						factor--;
-					}
-					setGraphicsMode(s_gfxModeSwitchTable[_scalerType][factor]);
-					break;
-				}
-			}
-
-#ifdef LINUPY
-			// On Yopy map the End button to quit
-			if ((ev.key.keysym.sym==293)) {
-				event->event_code = EVENT_QUIT;
-				return true;
-			}
-			// Map menu key to f5 (scumm menu)
-			if (ev.key.keysym.sym==306) {
-				event->event_code = EVENT_KEYDOWN;
-				event->kbd.keycode = SDLK_F5;
-				event->kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
-				return true;
-			}
-			// Map action key to action
-			if (ev.key.keysym.sym==291) {
-				event->event_code = EVENT_KEYDOWN;
-				event->kbd.keycode = SDLK_TAB;
-				event->kbd.ascii = mapKey(SDLK_TAB, ev.key.keysym.mod, 0);
-				return true;
-			}
-			// Map OK key to skip cinematic
-			if (ev.key.keysym.sym==292) {
-				event->event_code = EVENT_KEYDOWN;
-				event->kbd.keycode = SDLK_ESCAPE;
-				event->kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0);
-				return true;
-			}
-#endif
-
-#ifdef QTOPIA
-			// quit on fn+backspace on zaurus
-			if (ev.key.keysym.sym == 127) {
-				event->event_code = EVENT_QUIT;
-				return true;
-			}
-
-			// map menu key (f11) to f5 (scumm menu)
-			if (ev.key.keysym.sym == SDLK_F11) {
-				event->event_code = EVENT_KEYDOWN;
-				event->kbd.keycode = SDLK_F5;
-				event->kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
-			}
-			// map center (space) to tab (default action )
-			// I wanted to map the calendar button but the calendar comes up
-			//
-			else if (ev.key.keysym.sym == SDLK_SPACE) {
-				event->event_code = EVENT_KEYDOWN;
-				event->kbd.keycode = SDLK_TAB;
-				event->kbd.ascii = mapKey(SDLK_TAB, ev.key.keysym.mod, 0);
-			}
-			// since we stole space (pause) above we'll rebind it to the tab key on the keyboard
-			else if (ev.key.keysym.sym == SDLK_TAB) {
-				event->event_code = EVENT_KEYDOWN;
-				event->kbd.keycode = SDLK_SPACE;
-				event->kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0);
-			} else {
-			// let the events fall through if we didn't change them, this may not be the best way to
-			// set it up, but i'm not sure how sdl would like it if we let if fall through then redid it though.
-			// and yes i have an huge terminal size so i dont wrap soon enough.
-				event->event_code = EVENT_KEYDOWN;
-				event->kbd.keycode = ev.key.keysym.sym;
-				event->kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
-			}
-#else
-			event->event_code = EVENT_KEYDOWN;
-			event->kbd.keycode = ev.key.keysym.sym;
-			event->kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
-#endif
-			
-			switch(ev.key.keysym.sym) {
-			case SDLK_LEFT:
-				km.x_vel = -1;
-				km.x_down_count = 1;
-				break;
-			case SDLK_RIGHT:
-				km.x_vel =  1;
-				km.x_down_count = 1;
-				break;
-			case SDLK_UP:
-				km.y_vel = -1;
-				km.y_down_count = 1;
-				break;
-			case SDLK_DOWN:
-				km.y_vel =  1;
-				km.y_down_count = 1;
-				break;
-			default:
-				break;
-			}
-
-			return true;
-	
-		case SDL_KEYUP:
-			event->event_code = EVENT_KEYUP;
-			event->kbd.keycode = ev.key.keysym.sym;
-			event->kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
-
-			switch(ev.key.keysym.sym) {
-			case SDLK_LEFT:
-				if (km.x_vel < 0) {
-					km.x_vel = 0;
-					km.x_down_count = 0;
-				}
-				break;
-			case SDLK_RIGHT:
-				if (km.x_vel > 0) {
-					km.x_vel = 0;
-					km.x_down_count = 0;
-				}
-				break;
-			case SDLK_UP:
-				if (km.y_vel < 0) {
-					km.y_vel = 0;
-					km.y_down_count = 0;
-				}
-				break;
-			case SDLK_DOWN:
-				if (km.y_vel > 0) {
-					km.y_vel = 0;
-					km.y_down_count = 0;
-				}
-				break;
-			default:
-				break;
-			}
-			return true;
-
-		case SDL_MOUSEMOTION:
-			event->event_code = EVENT_MOUSEMOVE;
-			fillMouseEvent(*event, ev.motion.x, ev.motion.y);
-			
-			set_mouse_pos(event->mouse.x, event->mouse.y);
-			return true;
-
-		case SDL_MOUSEBUTTONDOWN:
-			if (ev.button.button == SDL_BUTTON_LEFT)
-				event->event_code = EVENT_LBUTTONDOWN;
-			else if (ev.button.button == SDL_BUTTON_RIGHT)
-				event->event_code = EVENT_RBUTTONDOWN;
-#if defined(SDL_BUTTON_WHEELUP) && defined(SDL_BUTTON_WHEELDOWN)
-			else if (ev.button.button == SDL_BUTTON_WHEELUP)
-				event->event_code = EVENT_WHEELUP;
-			else if (ev.button.button == SDL_BUTTON_WHEELDOWN)
-				event->event_code = EVENT_WHEELDOWN;
-#endif
-			else
-				break;
-
-			fillMouseEvent(*event, ev.button.x, ev.button.y);
-
-			return true;
-
-		case SDL_MOUSEBUTTONUP:
-			if (ev.button.button == SDL_BUTTON_LEFT)
-				event->event_code = EVENT_LBUTTONUP;
-			else if (ev.button.button == SDL_BUTTON_RIGHT)
-				event->event_code = EVENT_RBUTTONUP;
-			else
-				break;
-			fillMouseEvent(*event, ev.button.x, ev.button.y);
-
-			return true;
-
-		case SDL_JOYBUTTONDOWN:
-			if (ev.jbutton.button == JOY_BUT_LMOUSE) {
-				event->event_code = EVENT_LBUTTONDOWN;
-			} else if (ev.jbutton.button == JOY_BUT_RMOUSE) {
-				event->event_code = EVENT_RBUTTONDOWN;
-			} else {
-				event->event_code = EVENT_KEYDOWN;
-				switch (ev.jbutton.button) {
-					case JOY_BUT_ESCAPE:
-						event->kbd.keycode = SDLK_ESCAPE;
-						event->kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0);
-						break;
-					case JOY_BUT_PERIOD:
-						event->kbd.keycode = SDLK_PERIOD;
-						event->kbd.ascii = mapKey(SDLK_PERIOD, ev.key.keysym.mod, 0);
-						break;
-					case JOY_BUT_SPACE:
-						event->kbd.keycode = SDLK_SPACE;
-						event->kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0);
-						break;
-					case JOY_BUT_F5:
-						event->kbd.keycode = SDLK_F5;
-						event->kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
-						break; 
-				}
-			}
-			return true;
-
-		case SDL_JOYBUTTONUP:
-			if (ev.jbutton.button == JOY_BUT_LMOUSE) {
-				event->event_code = EVENT_LBUTTONUP;
-			} else if (ev.jbutton.button == JOY_BUT_RMOUSE) {
-				event->event_code = EVENT_RBUTTONUP;
-			} else {
-				event->event_code = EVENT_KEYUP;
-				switch (ev.jbutton.button) {
-					case JOY_BUT_ESCAPE:
-						event->kbd.keycode = SDLK_ESCAPE;
-						event->kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0);
-						break;
-					case JOY_BUT_PERIOD:
-						event->kbd.keycode = SDLK_PERIOD;
-						event->kbd.ascii = mapKey(SDLK_PERIOD, ev.key.keysym.mod, 0);
-						break;
-					case JOY_BUT_SPACE:
-						event->kbd.keycode = SDLK_SPACE;
-						event->kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0);
-						break;
-					case JOY_BUT_F5:
-						event->kbd.keycode = SDLK_F5;
-						event->kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
-						break;
-				} 
-			}
-			return true;
-
-		case SDL_JOYAXISMOTION:
-			axis = ev.jaxis.value;
-			if ( axis > JOY_DEADZONE) {
-				axis -= JOY_DEADZONE;
-				event->event_code = EVENT_MOUSEMOVE;
-			} else if ( axis < -JOY_DEADZONE ) {
-				axis += JOY_DEADZONE;
-				event->event_code = EVENT_MOUSEMOVE;
-			} else
-				axis = 0;
-
-			if ( ev.jaxis.axis == JOY_XAXIS) { 
-#ifdef JOY_ANALOG
-				km.x_vel = axis/2000;
-				km.x_down_count = 0;
-#else
-				if (axis != 0) {
-					km.x_vel = (axis > 0) ? 1:-1;
-					km.x_down_count = 1;
-				} else {
-					km.x_vel = 0;
-					km.x_down_count = 0;
-				}
-#endif
-
-			} else if (ev.jaxis.axis == JOY_YAXIS) { 
-#ifndef JOY_INVERT_Y
-				axis = -axis;
-#endif
-#ifdef JOY_ANALOG
-				km.y_vel = -axis / 2000;
-				km.y_down_count = 0;
-#else
-				if (axis != 0) {
-					km.y_vel = (-axis > 0) ? 1: -1;
-					km.y_down_count = 1;
-				} else {
-					km.y_vel = 0;
-					km.y_down_count = 0;
-				}
-#endif
-			}
-			event->mouse.x = km.x;
-			event->mouse.y = km.y;
-			event->mouse.x /= _scaleFactor;
-			event->mouse.y /= _scaleFactor;
-
-			if (_adjustAspectRatio)
-				event->mouse.y = aspect2Real(event->mouse.y);
-
-			return true;
-
-		case SDL_VIDEOEXPOSE:
-			_forceFull = true;
-			break;
-
-		case SDL_QUIT:
-			event->event_code = EVENT_QUIT;
-			return true;
-		}
-	}
-	return false;
-}
-
-bool OSystem_SDL_Common::setSoundCallback(SoundProc proc, void *param) {
-	SDL_AudioSpec desired;
-
-	memset(&desired, 0, sizeof(desired));
-
-	desired.freq = SAMPLES_PER_SEC;
-	desired.format = AUDIO_S16SYS;
-	desired.channels = 2;
-	desired.samples = 2048;
-	desired.callback = proc;
-	desired.userdata = param;
-	if (SDL_OpenAudio(&desired, NULL) != 0) {
-		return false;
-	}
-	SDL_PauseAudio(0);
-	return true;
-}
-
-void OSystem_SDL_Common::clearSoundCallback() {
-	SDL_CloseAudio();
-}
-
-int OSystem_SDL_Common::getOutputSampleRate() const {
-	return SAMPLES_PER_SEC;
-}
-
-const OSystem::GraphicsMode *OSystem_SDL_Common::getSupportedGraphicsModes() const {
-	return s_supportedGraphicsModes;
-}
-
-void OSystem_SDL_Common::updateScreen() {
-	Common::StackLock lock(_graphicsMutex, this);	// Lock the mutex until this function ends
-
-	internUpdateScreen();
-}
-
-bool OSystem_SDL_Common::setGraphicsMode(int mode) {
-	Common::StackLock lock(_graphicsMutex, this);
-
-	int newScaleFactor = 1;
-	ScalerProc *newScalerProc;
-
-	switch(mode) {
-	case GFX_NORMAL:
-		newScaleFactor = 1;
-		newScalerProc = Normal1x;
-		break;
-	case GFX_DOUBLESIZE:
-		newScaleFactor = 2;
-		newScalerProc = Normal2x;
-		break;
-	case GFX_TRIPLESIZE:
-		newScaleFactor = 3;
-		newScalerProc = Normal3x;
-		break;
-
-	case GFX_2XSAI:
-		newScaleFactor = 2;
-		newScalerProc = _2xSaI;
-		break;
-	case GFX_SUPER2XSAI:
-		newScaleFactor = 2;
-		newScalerProc = Super2xSaI;
-		break;
-	case GFX_SUPEREAGLE:
-		newScaleFactor = 2;
-		newScalerProc = SuperEagle;
-		break;
-	case GFX_ADVMAME2X:
-		newScaleFactor = 2;
-		newScalerProc = AdvMame2x;
-		break;
-	case GFX_ADVMAME3X:
-		newScaleFactor = 3;
-		newScalerProc = AdvMame3x;
-		break;
-	case GFX_HQ2X:
-		newScaleFactor = 2;
-		newScalerProc = HQ2x;
-		break;
-	case GFX_HQ3X:
-		newScaleFactor = 3;
-		newScalerProc = HQ3x;
-		break;
-	case GFX_TV2X:
-		newScaleFactor = 2;
-		newScalerProc = TV2x;
-		break;
-	case GFX_DOTMATRIX:
-		newScaleFactor = 2;
-		newScalerProc = DotMatrix;
-		break;
-
-	default:
-		warning("unknown gfx mode %d", mode);
-		return false;
-	}
-
-	_mode = mode;
-
-	if (newScaleFactor != _scaleFactor) {
-		hotswap_gfx_mode();
-	} else {
-		_scaler_proc = newScalerProc;
-		_forceFull = true;
-
-		// Blit everything to the screen
-		internUpdateScreen();
-	
-		// Make sure that an EVENT_SCREEN_CHANGED gets sent later
-		_modeChanged = true;
-	}
-
-	return true;
-}
-
-int OSystem_SDL_Common::getGraphicsMode() const {
-	return _mode;
-}
-
-
-void OSystem_SDL_Common::setWindowCaption(const char *caption) {
-	SDL_WM_SetCaption(caption, caption);
-}
-
-bool OSystem_SDL_Common::hasFeature(Feature f) {
-	return
-		(f == kFeatureFullscreenMode) ||
-		(f == kFeatureAspectRatioCorrection) ||
-		(f == kFeatureAutoComputeDirtyRects);
-}
-
-void OSystem_SDL_Common::setFeatureState(Feature f, bool enable) {
-	Common::StackLock lock(_graphicsMutex, this);
-
-	switch (f) {
-	case kFeatureFullscreenMode:
-		setFullscreenMode(enable);
-		break;
-	case kFeatureAspectRatioCorrection:
-		if (_screenHeight == 200 && _adjustAspectRatio != enable) {
-			//assert(_hwscreen != 0);
-			_adjustAspectRatio ^= true;
-			hotswap_gfx_mode();
-		}
-		break;
-	case kFeatureAutoComputeDirtyRects:
-		if (enable)
-			_mode_flags |= DF_WANT_RECT_OPTIM;		
-		else
-			_mode_flags &= ~DF_WANT_RECT_OPTIM;		
-		break;
-	default:
-		break;
-	}
-}
-
-bool OSystem_SDL_Common::getFeatureState(Feature f) {
-	switch (f) {
-	case kFeatureFullscreenMode:
-		return _full_screen;
-	case kFeatureAspectRatioCorrection:
-		return _adjustAspectRatio;
-	case kFeatureAutoComputeDirtyRects:
-		return _mode_flags & DF_WANT_RECT_OPTIM;
-	default:
-		return false;
-	}
-}
-
-void OSystem_SDL_Common::toggleMouseGrab() {
-	if (SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_OFF)
-		SDL_WM_GrabInput(SDL_GRAB_ON);
-	else
-		SDL_WM_GrabInput(SDL_GRAB_OFF);
-}
-
-void OSystem_SDL_Common::quit() {
-	if(_cdrom) {
-		SDL_CDStop(_cdrom);
-		SDL_CDClose(_cdrom);
-	}
-	unload_gfx_mode();
-
-	SDL_ShowCursor(SDL_ENABLE);
-	SDL_Quit();
-
-	exit(0);
-}
-
-void OSystem_SDL_Common::draw_mouse() {
-	if (_mouseDrawn || !_mouseVisible)
-		return;
-
-	int x = _mouseCurState.x - _mouseHotspotX;
-	int y = _mouseCurState.y - _mouseHotspotY;
-	int w = _mouseCurState.w;
-	int h = _mouseCurState.h;
-	byte color;
-	const byte *src = _mouseData;		// Image representing the mouse
-
-	// clip the mouse rect, and addjust the src pointer accordingly
-	if (x < 0) {
-		w += x;
-		src -= x;
-		x = 0;
-	}
-	if (y < 0) {
-		h += y;
-		src -= y * _mouseCurState.w;
-		y = 0;
-	}
-
-	if (w > _screenWidth - x)
-		w = _screenWidth - x;
-	if (h > _screenHeight - y)
-		h = _screenHeight - y;
-
-	// Quick check to see if anything has to be drawn at all
-	if (w <= 0 || h <= 0)
-		return;
-
-	// Store the bounding box so that undraw mouse can restore the area the
-	// mouse currently covers to its original content.
-	_mouseOldState.x = x;
-	_mouseOldState.y = y;
-	_mouseOldState.w = w;
-	_mouseOldState.h = h;
-
-	// Draw the mouse cursor; backup the covered area in "bak"
-	if (SDL_LockSurface(_overlayVisible ? _tmpscreen : _screen) == -1)
-		error("SDL_LockSurface failed: %s", SDL_GetError());
-
-	// Mark as dirty
-	add_dirty_rect(x, y, w, h);
-
-	if (!_overlayVisible) {
-		byte *bak = _mouseBackup;		// Surface used to backup the area obscured by the mouse
-		byte *dst;					// Surface we are drawing into
-	
-		dst = (byte *)_screen->pixels + y * _screenWidth + x;
-		while (h > 0) {
-			int width = w;
-			while (width > 0) {
-				*bak++ = *dst;
-				color = *src++;
-				if (color != 0xFF)	// 0xFF = transparent, don't draw
-					*dst = color;
-				dst++;
-				width--;
-			}
-			src += _mouseCurState.w - w;
-			bak += MAX_MOUSE_W - w;
-			dst += _screenWidth - w;
-			h--;
-		}
-	
-	} else {
-		uint16 *bak = (uint16 *)_mouseBackup;	// Surface used to backup the area obscured by the mouse
-		uint16 *dst;					// Surface we are drawing into
-	
-		dst = (uint16 *)_tmpscreen->pixels + (y + 1) * _tmpScreenWidth + (x + 1);
-		while (h > 0) {
-			int width = w;
-			while (width > 0) {
-				*bak++ = *dst;
-				color = *src++;
-				if (color != 0xFF)	// 0xFF = transparent, don't draw
-					*dst = RGBToColor(_currentPalette[color].r, _currentPalette[color].g, _currentPalette[color].b);
-				dst++;
-				width--;
-			}
-			src += _mouseCurState.w - w;
-			bak += MAX_MOUSE_W - w;
-			dst += _tmpScreenWidth - w;
-			h--;
-		}
-	}
-
-	SDL_UnlockSurface(_overlayVisible ? _tmpscreen : _screen);
-
-	// Finally, set the flag to indicate the mouse has been drawn
-	_mouseDrawn = true;
-}
-
-void OSystem_SDL_Common::undraw_mouse() {
-	if (!_mouseDrawn)
-		return;
-	_mouseDrawn = false;
-
-	if (SDL_LockSurface(_overlayVisible ? _tmpscreen : _screen) == -1)
-		error("SDL_LockSurface failed: %s", SDL_GetError());
-
-	const int old_mouse_x = _mouseOldState.x;
-	const int old_mouse_y = _mouseOldState.y;
-	const int old_mouse_w = _mouseOldState.w;
-	const int old_mouse_h = _mouseOldState.h;
-	int x, y;
-
-	if (!_overlayVisible) {
-		byte *dst, *bak = _mouseBackup;
-
-		// No need to do clipping here, since draw_mouse() did that already
-		dst = (byte *)_screen->pixels + old_mouse_y * _screenWidth + old_mouse_x;
-		for (y = 0; y < old_mouse_h; ++y, bak += MAX_MOUSE_W, dst += _screenWidth) {
-			for (x = 0; x < old_mouse_w; ++x) {
-				dst[x] = bak[x];
-			}
-		}
-	
-	} else {
-
-		uint16 *dst, *bak = (uint16 *)_mouseBackup;
-	
-		// No need to do clipping here, since draw_mouse() did that already
-		dst = (uint16 *)_tmpscreen->pixels + (old_mouse_y + 1) * _tmpScreenWidth + (old_mouse_x + 1);
-		for (y = 0; y < old_mouse_h; ++y, bak += MAX_MOUSE_W, dst += _tmpScreenWidth) {
-			for (x = 0; x < old_mouse_w; ++x) {
-				dst[x] = bak[x];
-			}
-		}
-	}
-
-	add_dirty_rect(old_mouse_x, old_mouse_y, old_mouse_w, old_mouse_h);
-
-	SDL_UnlockSurface(_overlayVisible ? _tmpscreen : _screen);
-}
-
-bool OSystem_SDL_Common::openCD(int drive) {
-	if (SDL_InitSubSystem(SDL_INIT_CDROM) == -1)
-		_cdrom = NULL;
-	else {
-		_cdrom = SDL_CDOpen(drive);
-		// Did it open? Check if _cdrom is NULL
-		if (!_cdrom) {
-			warning("Couldn't open drive: %s", SDL_GetError());
-		} else {
-			cd_num_loops = 0;
-			cd_stop_time = 0;
-			cd_end_time = 0;
-		}
-	}
-	
-	return (_cdrom != NULL);
-}
-
-void OSystem_SDL_Common::stop_cdrom() {	/* Stop CD Audio in 1/10th of a second */
-	cd_stop_time = SDL_GetTicks() + 100;
-	cd_num_loops = 0;
-}
-
-void OSystem_SDL_Common::play_cdrom(int track, int num_loops, int start_frame, int duration) {
-	if (!num_loops && !start_frame)
-		return;
-
-	if (!_cdrom)
-		return;
-	
-	if (duration > 0)
-		duration += 5;
-
-	cd_track = track;
-	cd_num_loops = num_loops;
-	cd_start_frame = start_frame;
-
-	SDL_CDStatus(_cdrom);
-	if (start_frame == 0 && duration == 0)
-		SDL_CDPlayTracks(_cdrom, track, 0, 1, 0);
-	else
-		SDL_CDPlayTracks(_cdrom, track, start_frame, 0, duration);
-	cd_duration = duration;
-	cd_stop_time = 0;
-	cd_end_time = SDL_GetTicks() + _cdrom->track[track].length * 1000 / CD_FPS;
-}
-
-bool OSystem_SDL_Common::poll_cdrom() {
-	if (!_cdrom)
-		return false;
-
-	return (cd_num_loops != 0 && (SDL_GetTicks() < cd_end_time || SDL_CDStatus(_cdrom) != CD_STOPPED));
-}
-
-void OSystem_SDL_Common::update_cdrom() {
-	if (!_cdrom)
-		return;
-
-	if (cd_stop_time != 0 && SDL_GetTicks() >= cd_stop_time) {
-		SDL_CDStop(_cdrom);
-		cd_num_loops = 0;
-		cd_stop_time = 0;
-		return;
-	}
-
-	if (cd_num_loops == 0 || SDL_GetTicks() < cd_end_time)
-		return;
-
-	if (cd_num_loops != 1 && SDL_CDStatus(_cdrom) != CD_STOPPED) {
-		// Wait another second for it to be done
-		cd_end_time += 1000;
-		return;
-	}
-
-	if (cd_num_loops > 0)
-		cd_num_loops--;
-
-	if (cd_num_loops != 0) {
-		if (cd_start_frame == 0 && cd_duration == 0)
-			SDL_CDPlayTracks(_cdrom, cd_track, 0, 1, 0);
-		else
-			SDL_CDPlayTracks(_cdrom, cd_track, cd_start_frame, 0, cd_duration);
-		cd_end_time = SDL_GetTicks() + _cdrom->track[cd_track].length * 1000 / CD_FPS;
-	}
-}
-
-void OSystem_SDL_Common::setup_icon() {
-	int w, h, ncols, nbytes, i;
-	unsigned int rgba[256], icon[32 * 32];
-	unsigned char mask[32][4];
-
-	sscanf(scummvm_icon[0], "%d %d %d %d", &w, &h, &ncols, &nbytes);
-	if ((w != 32) || (h != 32) || (ncols > 255) || (nbytes > 1)) {
-		warning("Could not load the icon (%d %d %d %d)", w, h, ncols, nbytes);
-		return;
-	}
-	for (i = 0; i < ncols; i++) {
-		unsigned char code;
-		char color[32];
-		unsigned int col;
-		sscanf(scummvm_icon[1 + i], "%c c %s", &code, color);
-		if (!strcmp(color, "None"))
-			col = 0x00000000;
-		else if (!strcmp(color, "black"))
-			col = 0xFF000000;
-		else if (color[0] == '#') {
-			sscanf(color + 1, "%06x", &col);
-			col |= 0xFF000000;
-		} else {
-			warning("Could not load the icon (%d %s - %s) ", code, color, scummvm_icon[1 + i]);
-			return;
-		}
-		
-		rgba[code] = col;
-	}
-	memset(mask, 0, sizeof(mask));
-	for (h = 0; h < 32; h++) {
-		const char *line = scummvm_icon[1 + ncols + h];
-		for (w = 0; w < 32; w++) {
-			icon[w + 32 * h] = rgba[(int)line[w]];
-			if (rgba[(int)line[w]] & 0xFF000000) {
-				mask[h][w >> 3] |= 1 << (7 - (w & 0x07));
-			}
-		}
-	}
-
-	SDL_Surface *sdl_surf = SDL_CreateRGBSurfaceFrom(icon, 32, 32, 32, 32 * 4, 0xFF0000, 0x00FF00, 0x0000FF, 0xFF000000);
-	SDL_WM_SetIcon(sdl_surf, (unsigned char *) mask);
-	SDL_FreeSurface(sdl_surf);
-}
-
-OSystem::MutexRef OSystem_SDL_Common::createMutex(void) {
-	return (MutexRef) SDL_CreateMutex();
-}
-
-void OSystem_SDL_Common::lockMutex(MutexRef mutex) {
-	SDL_mutexP((SDL_mutex *) mutex);
-}
-
-void OSystem_SDL_Common::unlockMutex(MutexRef mutex) {
-	SDL_mutexV((SDL_mutex *) mutex);
-}
-
-void OSystem_SDL_Common::deleteMutex(MutexRef mutex) {
-	SDL_DestroyMutex((SDL_mutex *) mutex);
-}
-
-void OSystem_SDL_Common::show_overlay() {
-	// hide the mouse
-	undraw_mouse();
-
-	_overlayVisible = true;
-	clear_overlay();
-}
-
-void OSystem_SDL_Common::hide_overlay() {
-	// hide the mouse
-	undraw_mouse();
-
-	_overlayVisible = false;
-	_forceFull = true;
-}
-
-void OSystem_SDL_Common::clear_overlay() {
-	if (!_overlayVisible)
-		return;
-	
-	Common::StackLock lock(_graphicsMutex, this);	// Lock the mutex until this function ends
-	
-	// hide the mouse
-	undraw_mouse();
-
-	// Clear the overlay by making the game screen "look through" everywhere.
-	SDL_Rect src, dst;
-	src.x = src.y = 0;
-	dst.x = dst.y = 1;
-	src.w = dst.w = _screenWidth;
-	src.h = dst.h = _screenHeight;
-	if (SDL_BlitSurface(_screen, &src, _tmpscreen, &dst) != 0)
-		error("SDL_BlitSurface failed: %s", SDL_GetError());
-
-	_forceFull = true;
-}
-
-int16 OSystem_SDL_Common::get_height() {
-	return _screenHeight;
-}
-
-int16 OSystem_SDL_Common::get_width() {
-	return _screenWidth;
-}
-
-void OSystem_SDL_Common::grab_overlay(int16 *buf, int pitch) {
-	if (!_overlayVisible)
-		return;
-
-	if (_tmpscreen == NULL)
-		return;
-
-	// hide the mouse
-	undraw_mouse();
-
-	if (SDL_LockSurface(_tmpscreen) == -1)
-		error("SDL_LockSurface failed: %s", SDL_GetError());
-
-	int16 *src = (int16 *)_tmpscreen->pixels + _tmpScreenWidth + 1;
-	int h = _screenHeight;
-	do {
-		memcpy(buf, src, _screenWidth*2);
-		src += _tmpScreenWidth;
-		buf += pitch;
-	} while (--h);
-
-	SDL_UnlockSurface(_tmpscreen);
-}
-
-void OSystem_SDL_Common::copy_rect_overlay(const int16 *buf, int pitch, int x, int y, int w, int h) {
-	if (!_overlayVisible)
-		return;
-
-	if (_tmpscreen == NULL)
-		return;
-
-	// Clip the coordinates
-	if (x < 0) {
-		w += x;
-		buf -= x;
-		x = 0;
-	}
-
-	if (y < 0) {
-		h += y; buf -= y * pitch;
-		y = 0;
-	}
-
-	if (w > _screenWidth - x) {
-		w = _screenWidth - x;
-	}
-
-	if (h > _screenHeight-y) {
-		h = _screenHeight - y;
-	}
-
-	if (w <= 0 || h <= 0)
-		return;
-
-	// Mark the modified region as dirty
-	cksum_valid = false;
-	add_dirty_rect(x, y, w, h);
-
-	/* FIXME: undraw mouse only if the draw rect intersects with the mouse rect */
-	undraw_mouse();
-
-	if (SDL_LockSurface(_tmpscreen) == -1)
-		error("SDL_LockSurface failed: %s", SDL_GetError());
-
-	int16 *dst = (int16 *)_tmpscreen->pixels + (y + 1) * _tmpScreenWidth + (x + 1);
-	do {
-		memcpy(dst, buf, w * 2);
-		dst += _tmpScreenWidth;
-		buf += pitch;
-	} while (--h);
-
-	SDL_UnlockSurface(_tmpscreen);
-}
-
-void OSystem_SDL_Common::setPalette(const byte *colors, uint start, uint num) {
-	const byte *b = colors;
-	uint i;
-	SDL_Color *base = _currentPalette + start;
-	for (i = 0; i < num; i++) {
-		base[i].r = b[0];
-		base[i].g = b[1];
-		base[i].b = b[2];
-		b += 4;
-	}
-
-	if (start < _paletteDirtyStart)
-		_paletteDirtyStart = start;
-
-	if (start + num > _paletteDirtyEnd)
-		_paletteDirtyEnd = start + num;
-}
-
-int16 OSystem_SDL_Common::RGBToColor(uint8 r, uint8 g, uint8 b) {
-	return SDL_MapRGB(_tmpscreen->format, r, g, b);
-}
-
-void OSystem_SDL_Common::colorToRGB(int16 color, uint8 &r, uint8 &g, uint8 &b) {
-	SDL_GetRGB(color, _tmpscreen->format, &r, &g, &b);
-}
diff --git a/backends/sdl/sdl-common.h b/backends/sdl/sdl-common.h
index d007bf91ce..f84b701148 100644
--- a/backends/sdl/sdl-common.h
+++ b/backends/sdl/sdl-common.h
@@ -1,4 +1,5 @@
 /* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001  Ludvig Strigeus
  * Copyright (C) 2001-2004 The ScummVM project
  *
  * This program is free software; you can redistribute it and/or
@@ -30,8 +31,11 @@
 
 #include <SDL.h>
 
-class OSystem_SDL_Common : public OSystem {
+class OSystem_SDL : public OSystem {
 public:
+	OSystem_SDL();
+	virtual ~OSystem_SDL();
+
 	// Set the size of the video bitmap.
 	// Typically, 320x200
 	void initSize(uint w, uint h);
@@ -129,17 +133,12 @@ public:
 	virtual void setFeatureState(Feature f, bool enable);
 	virtual bool getFeatureState(Feature f);
 
-
-	static OSystem *create();
-
 protected:
-	OSystem_SDL_Common();
-	virtual ~OSystem_SDL_Common();
-
-	static OSystem_SDL_Common *create_intern();
-
 	void init_intern();
 
+	// hardware screen
+	SDL_Surface *_hwscreen;
+
 	// unseen game screen
 	SDL_Surface *_screen;
 	int _screenWidth, _screenHeight;
@@ -227,27 +226,27 @@ protected:
 	void add_dirty_rgn_auto(const byte *buf);
 	void mk_checksums(const byte *buf);
 
-	virtual void add_dirty_rect(int x, int y, int w, int h);
+	void add_dirty_rect(int x, int y, int w, int h);
 
-	virtual void draw_mouse();
-	virtual void undraw_mouse();
+	void draw_mouse();
+	void undraw_mouse();
 	/** Set the position of the virtual mouse cursor. */
 	void set_mouse_pos(int x, int y);
 	void fillMouseEvent(Event &event, int x, int y);
 	void toggleMouseGrab();
 
 
-	virtual void internUpdateScreen() = 0;
+	void internUpdateScreen();
 
-	virtual void load_gfx_mode() = 0;
-	virtual void unload_gfx_mode() = 0;
-	virtual void hotswap_gfx_mode() = 0;
+	void load_gfx_mode();
+	void unload_gfx_mode();
+	void hotswap_gfx_mode();
 	
-	virtual void setFullscreenMode(bool enable) = 0;
+	void setFullscreenMode(bool enable);
 
-	virtual bool save_screenshot(const char *filename) = 0;
+	bool save_screenshot(const char *filename);
 	
-	virtual int effectiveScreenHeight() { return (_adjustAspectRatio ? 240 : _screenHeight) * _scaleFactor; }
+	int effectiveScreenHeight() { return (_adjustAspectRatio ? 240 : _screenHeight) * _scaleFactor; }
 
 	void setup_icon();
 	void kbd_mouse();
diff --git a/backends/sdl/sdl.cpp b/backends/sdl/sdl.cpp
index 1afba41d50..2560388ed3 100644
--- a/backends/sdl/sdl.cpp
+++ b/backends/sdl/sdl.cpp
@@ -20,373 +20,345 @@
  *
  */
 
-#include "sdl-common.h"
+#include "backends/sdl/sdl-common.h"
+#include "common/config-manager.h"
 #include "common/util.h"
 
-class OSystem_SDL : public OSystem_SDL_Common {
-public:
-	OSystem_SDL();
-
-	// Update the dirty areas of the screen
-	void internUpdateScreen();
+#if defined(HAVE_CONFIG_H)
+#include "config.h"
+#endif
 
-protected:
-	SDL_Surface *_hwscreen;    // hardware screen
+#include "scummvm.xpm"
 
-	virtual void load_gfx_mode();
-	virtual void unload_gfx_mode();
-	virtual bool save_screenshot(const char *filename);
-	virtual void hotswap_gfx_mode();
-	
-	virtual void setFullscreenMode(bool enable);
-};
 
-OSystem_SDL_Common *OSystem_SDL_Common::create_intern() {
+OSystem *OSystem_SDL_create() {
 	return new OSystem_SDL();
 }
 
-OSystem_SDL::OSystem_SDL()
-	 : _hwscreen(0)
-{
-}
+void OSystem_SDL::init_intern() {
 
-void OSystem_SDL::load_gfx_mode() {
-	_forceFull = true;
-	_mode_flags |= DF_UPDATE_EXPAND_1_PIXEL;
+	int joystick_num = ConfMan.getInt("joystick_num");
+	uint32 sdlFlags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
 
-	_tmpscreen = NULL;
-	_tmpScreenWidth = (_screenWidth + 3);
-	
-	switch(_mode) {
-	case GFX_NORMAL:
-		_scaleFactor = 1;
-		_scaler_proc = Normal1x;
-		break;
-	case GFX_DOUBLESIZE:
-		_scaleFactor = 2;
-		_scaler_proc = Normal2x;
-		break;
-	case GFX_TRIPLESIZE:
-		_scaleFactor = 3;
-		_scaler_proc = Normal3x;
-		break;
+	if (joystick_num > -1)
+		sdlFlags |= SDL_INIT_JOYSTICK;
 
-	case GFX_2XSAI:
-		_scaleFactor = 2;
-		_scaler_proc = _2xSaI;
-		break;
-	case GFX_SUPER2XSAI:
-		_scaleFactor = 2;
-		_scaler_proc = Super2xSaI;
-		break;
-	case GFX_SUPEREAGLE:
-		_scaleFactor = 2;
-		_scaler_proc = SuperEagle;
-		break;
-	case GFX_ADVMAME2X:
-		_scaleFactor = 2;
-		_scaler_proc = AdvMame2x;
-		break;
-	case GFX_ADVMAME3X:
-		_scaleFactor = 3;
-		_scaler_proc = AdvMame3x;
-		break;
-	case GFX_HQ2X:
-		_scaleFactor = 2;
-		_scaler_proc = HQ2x;
-		break;
-	case GFX_HQ3X:
-		_scaleFactor = 3;
-		_scaler_proc = HQ3x;
-		break;
-	case GFX_TV2X:
-		_scaleFactor = 2;
-		_scaler_proc = TV2x;
-		break;
-	case GFX_DOTMATRIX:
-		_scaleFactor = 2;
-		_scaler_proc = DotMatrix;
-		break;
-
-	default:
-		error("unknown gfx mode %d", _mode);
+	if (SDL_Init(sdlFlags) == -1) {
+		error("Could not initialize SDL: %s", SDL_GetError());
 	}
 
-	//
-	// Create the surface that contains the 8 bit game data
-	//
-	_screen = SDL_CreateRGBSurface(SDL_SWSURFACE, _screenWidth, _screenHeight, 8, 0, 0, 0, 0);
-	if (_screen == NULL)
-		error("_screen failed");
-
-	//
-	// Create the surface that contains the scaled graphics in 16 bit mode
-	//
-
-	_hwscreen = SDL_SetVideoMode(_screenWidth * _scaleFactor, (_adjustAspectRatio ? 240 : _screenHeight) * _scaleFactor, 16, 
-		_full_screen ? (SDL_FULLSCREEN|SDL_SWSURFACE) : SDL_SWSURFACE
-	);
-	if (_hwscreen == NULL) {
-		// DON'T use error(), as this tries to bring up the debug
-		// console, which WON'T WORK now that _hwscreen is hosed.
-
-		// FIXME: We should be able to continue the game without
-		// shutting down or bringing up the debug console, but at
-		// this point we've already screwed up all our member vars.
-		// We need to find a way to call SDL_SetVideoMode *before*
-		// that happens and revert to all the old settings if we
-		// can't pull off the switch to the new settings.
-		//
-		// Fingolfin says: the "easy" way to do that is not to modify
-		// the member vars before we are sure everything is fine. Think
-		// of "transactions, commit, rollback" style... we use local vars
-		// in place of the member vars, do everything etc. etc.. In case
-		// of a failure, rollback is trivial. Only if everything worked fine
-		// do we "commit" the changed values to the member vars.
-		warning("SDL_SetVideoMode says we can't switch to that mode");
-		quit();
-	}
+	_graphicsMutex = createMutex();
 
-	//
-	// Create the surface used for the graphics in 16 bit before scaling, and also the overlay
-	//
-
-	// Distinguish 555 and 565 mode
-	if (_hwscreen->format->Rmask == 0x7C00)
-		InitScalers(555);
-	else
-		InitScalers(565);
+	SDL_ShowCursor(SDL_DISABLE);
 	
-	// Need some extra bytes around when using 2xSaI
-	uint16 *tmp_screen = (uint16 *)calloc(_tmpScreenWidth * (_screenHeight + 3), sizeof(uint16));
-	_tmpscreen = SDL_CreateRGBSurfaceFrom(tmp_screen,
-						_tmpScreenWidth, _screenHeight + 3, 16, _tmpScreenWidth * 2,
-						_hwscreen->format->Rmask,
-						_hwscreen->format->Gmask,
-						_hwscreen->format->Bmask,
-						_hwscreen->format->Amask);
-
-	if (_tmpscreen == NULL)
-		error("_tmpscreen failed");
-
-	// keyboard cursor control, some other better place for it?
-	km.x_max = _screenWidth * _scaleFactor - 1;
-	km.y_max = (_adjustAspectRatio ? 240 : _screenHeight) * _scaleFactor - 1;
-	km.delay_time = 25;
-	km.last_time = 0;
-}
+	// Enable unicode support if possible
+	SDL_EnableUNICODE(1); 
 
-void OSystem_SDL::unload_gfx_mode() {
-	if (_screen) {
-		SDL_FreeSurface(_screen);
-		_screen = NULL; 
-	}
+	cksum_valid = false;
+	_mode = GFX_DOUBLESIZE;
+	_full_screen = ConfMan.getBool("fullscreen");
+	_adjustAspectRatio = ConfMan.getBool("aspect_ratio");
+	_mode_flags = 0;
 
-	if (_hwscreen) {
-		SDL_FreeSurface(_hwscreen); 
-		_hwscreen = NULL;
-	}
 
-	if (_tmpscreen) {
-		free(_tmpscreen->pixels);
-		SDL_FreeSurface(_tmpscreen);
-		_tmpscreen = NULL;
+#ifndef MACOSX		// Don't set icon on OS X, as we use a nicer external icon there
+	// Setup the icon
+	setup_icon();
+#endif
+
+	// enable joystick
+	if (joystick_num > -1 && SDL_NumJoysticks() > 0) {
+		printf("Using joystick: %s\n", SDL_JoystickName(0));
+		init_joystick(joystick_num);
 	}
 }
 
-void OSystem_SDL::hotswap_gfx_mode() {
-	if (!_screen)
-		return;
+OSystem_SDL::OSystem_SDL()
+	: _hwscreen(0), _screen(0), _screenWidth(0), _screenHeight(0),
+	_tmpscreen(0), _tmpScreenWidth(0), _overlayVisible(false),
+	_cdrom(0), _scaler_proc(0), _modeChanged(false), _dirty_checksums(0),
+	_mouseVisible(false), _mouseDrawn(false), _mouseData(0),
+	_mouseHotspotX(0), _mouseHotspotY(0),
+	_currentShakePos(0), _newShakePos(0),
+	_paletteDirtyStart(0), _paletteDirtyEnd(0),
+	_graphicsMutex(0) {
+
+	// allocate palette storage
+	_currentPalette = (SDL_Color *)calloc(sizeof(SDL_Color), 256);
+
+	// allocate the dirty rect storage
+	_mouseBackup = (byte *)malloc(MAX_MOUSE_W * MAX_MOUSE_H * MAX_SCALING * 2);
+
+	// reset mouse state
+	memset(&km, 0, sizeof(km));
+	
+	init_intern();
+}
 
-	// Keep around the old _screen & _tmpscreen so we can restore the screen data
-	// after the mode switch.
-	SDL_Surface *old_screen = _screen;
-	SDL_Surface *old_tmpscreen = _tmpscreen;
+OSystem_SDL::~OSystem_SDL() {
+//	unload_gfx_mode();
 
-	// Release the HW screen surface
-	SDL_FreeSurface(_hwscreen); 
+	if (_dirty_checksums)
+		free(_dirty_checksums);
+	free(_currentPalette);
+	free(_mouseBackup);
+	deleteMutex(_graphicsMutex);
 
-	// Setup the new GFX mode
-	load_gfx_mode();
+	SDL_ShowCursor(SDL_ENABLE);
+	SDL_Quit();
+}
 
-	// reset palette
-	SDL_SetColors(_screen, _currentPalette, 0, 256);
+uint32 OSystem_SDL::get_msecs() {
+	return SDL_GetTicks();	
+}
 
-	// Restore old screen content
-	SDL_BlitSurface(old_screen, NULL, _screen, NULL);
-	SDL_BlitSurface(old_tmpscreen, NULL, _tmpscreen, NULL);
-	
-	// Free the old surfaces
-	SDL_FreeSurface(old_screen);
-	free(old_tmpscreen->pixels);
-	SDL_FreeSurface(old_tmpscreen);
+void OSystem_SDL::delay_msecs(uint msecs) {
+	SDL_Delay(msecs);
+}
 
-	// Blit everything to the screen
-	internUpdateScreen();
-	
-	// Make sure that an EVENT_SCREEN_CHANGED gets sent later
-	_modeChanged = true;
+void OSystem_SDL::set_timer(TimerProc callback, int timer) {
+	SDL_SetTimer(timer, (SDL_TimerCallback) callback);
 }
 
-void OSystem_SDL::internUpdateScreen() {
-	assert(_hwscreen != NULL);
+void OSystem_SDL::setWindowCaption(const char *caption) {
+	SDL_WM_SetCaption(caption, caption);
+}
 
-	// If the shake position changed, fill the dirty area with blackness
-	if (_currentShakePos != _newShakePos) {
-		SDL_Rect blackrect = {0, 0, _screenWidth * _scaleFactor, _newShakePos * _scaleFactor};
+bool OSystem_SDL::hasFeature(Feature f) {
+	return
+		(f == kFeatureFullscreenMode) ||
+		(f == kFeatureAspectRatioCorrection) ||
+		(f == kFeatureAutoComputeDirtyRects);
+}
 
-		if (_adjustAspectRatio)
-			blackrect.h = real2Aspect(blackrect.h - 1) + 1;
+void OSystem_SDL::setFeatureState(Feature f, bool enable) {
+	Common::StackLock lock(_graphicsMutex, this);
 
-		SDL_FillRect(_hwscreen, &blackrect, 0);
+	switch (f) {
+	case kFeatureFullscreenMode:
+		setFullscreenMode(enable);
+		break;
+	case kFeatureAspectRatioCorrection:
+		if (_screenHeight == 200 && _adjustAspectRatio != enable) {
+			//assert(_hwscreen != 0);
+			_adjustAspectRatio ^= true;
+			hotswap_gfx_mode();
+		}
+		break;
+	case kFeatureAutoComputeDirtyRects:
+		if (enable)
+			_mode_flags |= DF_WANT_RECT_OPTIM;		
+		else
+			_mode_flags &= ~DF_WANT_RECT_OPTIM;		
+		break;
+	default:
+		break;
+	}
+}
 
-		_currentShakePos = _newShakePos;
+bool OSystem_SDL::getFeatureState(Feature f) {
+	switch (f) {
+	case kFeatureFullscreenMode:
+		return _full_screen;
+	case kFeatureAspectRatioCorrection:
+		return _adjustAspectRatio;
+	case kFeatureAutoComputeDirtyRects:
+		return _mode_flags & DF_WANT_RECT_OPTIM;
+	default:
+		return false;
+	}
+}
 
-		_forceFull = true;
+void OSystem_SDL::quit() {
+	if(_cdrom) {
+		SDL_CDStop(_cdrom);
+		SDL_CDClose(_cdrom);
 	}
+	unload_gfx_mode();
 
-	// Make sure the mouse is drawn, if it should be drawn.
-	draw_mouse();
-	
-	// Check whether the palette was changed in the meantime and update the
-	// screen surface accordingly. 
-	if (_paletteDirtyEnd != 0) {
-		SDL_SetColors(_screen, _currentPalette + _paletteDirtyStart, 
-			_paletteDirtyStart,
-			_paletteDirtyEnd - _paletteDirtyStart);
-		
-		_paletteDirtyEnd = 0;
+	SDL_ShowCursor(SDL_ENABLE);
+	SDL_Quit();
 
-		_forceFull = true;
-	}
+	exit(0);
+}
 
-	// Force a full redraw if requested
-	if (_forceFull) {
-		_num_dirty_rects = 1;
+void OSystem_SDL::setup_icon() {
+	int w, h, ncols, nbytes, i;
+	unsigned int rgba[256], icon[32 * 32];
+	unsigned char mask[32][4];
 
-		_dirty_rect_list[0].x = 0;
-		_dirty_rect_list[0].y = 0;
-		_dirty_rect_list[0].w = _screenWidth;
-		_dirty_rect_list[0].h = _screenHeight;
+	sscanf(scummvm_icon[0], "%d %d %d %d", &w, &h, &ncols, &nbytes);
+	if ((w != 32) || (h != 32) || (ncols > 255) || (nbytes > 1)) {
+		warning("Could not load the icon (%d %d %d %d)", w, h, ncols, nbytes);
+		return;
 	}
-
-	// Only draw anything if necessary
-	if (_num_dirty_rects > 0) {
-
-		SDL_Rect *r; 
-		SDL_Rect dst;
-		uint32 srcPitch, dstPitch;
-		SDL_Rect *last_rect = _dirty_rect_list + _num_dirty_rects;
-
-		if (_scaler_proc == Normal1x && !_adjustAspectRatio) {
-			SDL_Surface *target = _overlayVisible ? _tmpscreen : _screen;
-			for (r = _dirty_rect_list; r != last_rect; ++r) {
-				dst = *r;
-				
-				if (_overlayVisible) {
-					// FIXME: I don't understand why this is necessary...
-					dst.x--;
-					dst.y--;
-				}
-				dst.y += _currentShakePos;
-				if (SDL_BlitSurface(target, r, _hwscreen, &dst) != 0)
-					error("SDL_BlitSurface failed: %s", SDL_GetError());
-			}
+	for (i = 0; i < ncols; i++) {
+		unsigned char code;
+		char color[32];
+		unsigned int col;
+		sscanf(scummvm_icon[1 + i], "%c c %s", &code, color);
+		if (!strcmp(color, "None"))
+			col = 0x00000000;
+		else if (!strcmp(color, "black"))
+			col = 0xFF000000;
+		else if (color[0] == '#') {
+			sscanf(color + 1, "%06x", &col);
+			col |= 0xFF000000;
 		} else {
-			if (!_overlayVisible) {
-				for (r = _dirty_rect_list; r != last_rect; ++r) {
-					dst = *r;
-					dst.x++;	// Shift rect by one since 2xSai needs to acces the data around
-					dst.y++;	// any pixel to scale it, and we want to avoid mem access crashes.
-					if (SDL_BlitSurface(_screen, r, _tmpscreen, &dst) != 0)
-						error("SDL_BlitSurface failed: %s", SDL_GetError());
-				}
+			warning("Could not load the icon (%d %s - %s) ", code, color, scummvm_icon[1 + i]);
+			return;
+		}
+		
+		rgba[code] = col;
+	}
+	memset(mask, 0, sizeof(mask));
+	for (h = 0; h < 32; h++) {
+		const char *line = scummvm_icon[1 + ncols + h];
+		for (w = 0; w < 32; w++) {
+			icon[w + 32 * h] = rgba[(int)line[w]];
+			if (rgba[(int)line[w]] & 0xFF000000) {
+				mask[h][w >> 3] |= 1 << (7 - (w & 0x07));
 			}
+		}
+	}
 
-			SDL_LockSurface(_tmpscreen);
-			SDL_LockSurface(_hwscreen);
+	SDL_Surface *sdl_surf = SDL_CreateRGBSurfaceFrom(icon, 32, 32, 32, 32 * 4, 0xFF0000, 0x00FF00, 0x0000FF, 0xFF000000);
+	SDL_WM_SetIcon(sdl_surf, (unsigned char *) mask);
+	SDL_FreeSurface(sdl_surf);
+}
 
-			srcPitch = _tmpscreen->pitch;
-			dstPitch = _hwscreen->pitch;
+OSystem::MutexRef OSystem_SDL::createMutex(void) {
+	return (MutexRef) SDL_CreateMutex();
+}
 
-			for (r = _dirty_rect_list; r != last_rect; ++r) {
-				register int dst_y = r->y + _currentShakePos;
-				register int dst_h = 0;
-				register int orig_dst_y = 0;
+void OSystem_SDL::lockMutex(MutexRef mutex) {
+	SDL_mutexP((SDL_mutex *) mutex);
+}
 
-				if (dst_y < _screenHeight) {
-					dst_h = r->h;
-					if (dst_h > _screenHeight - dst_y)
-						dst_h = _screenHeight - dst_y;
+void OSystem_SDL::unlockMutex(MutexRef mutex) {
+	SDL_mutexV((SDL_mutex *) mutex);
+}
 
-					dst_y *= _scaleFactor;
+void OSystem_SDL::deleteMutex(MutexRef mutex) {
+	SDL_DestroyMutex((SDL_mutex *) mutex);
+}
 
-					if (_adjustAspectRatio) {
-						orig_dst_y = dst_y;
-						dst_y = real2Aspect(dst_y);
-					}
+#pragma mark -
+#pragma mark --- Audio ---
+#pragma mark -
 
-					_scaler_proc((byte *)_tmpscreen->pixels + (r->x * 2 + 2) + (r->y + 1) * srcPitch, srcPitch,
-						(byte *)_hwscreen->pixels + r->x * 2 * _scaleFactor + dst_y * dstPitch, dstPitch, r->w, dst_h);
-				}
+bool OSystem_SDL::setSoundCallback(SoundProc proc, void *param) {
+	SDL_AudioSpec desired;
 
-				r->x *= _scaleFactor;
-				r->y = dst_y;
-				r->w *= _scaleFactor;
-				r->h = dst_h * _scaleFactor;
+	memset(&desired, 0, sizeof(desired));
 
-				if (_adjustAspectRatio && orig_dst_y / _scaleFactor < _screenHeight)
-					r->h = stretch200To240((uint8 *) _hwscreen->pixels, dstPitch, r->w, r->h, r->x, r->y, orig_dst_y);
-			}
-			SDL_UnlockSurface(_tmpscreen);
-			SDL_UnlockSurface(_hwscreen);
-		}
+	desired.freq = SAMPLES_PER_SEC;
+	desired.format = AUDIO_S16SYS;
+	desired.channels = 2;
+	desired.samples = 2048;
+	desired.callback = proc;
+	desired.userdata = param;
+	if (SDL_OpenAudio(&desired, NULL) != 0) {
+		return false;
+	}
+	SDL_PauseAudio(0);
+	return true;
+}
 
-		// Readjust the dirty rect list in case we are doing a full update.
-		// This is necessary if shaking is active.
-		if (_forceFull) {
-			_dirty_rect_list[0].y = 0;
-			_dirty_rect_list[0].h = (_adjustAspectRatio ? 240 : _screenHeight) * _scaleFactor;
-		}
+void OSystem_SDL::clearSoundCallback() {
+	SDL_CloseAudio();
+}
+
+int OSystem_SDL::getOutputSampleRate() const {
+	return SAMPLES_PER_SEC;
+}
 
-		// Finally, blit all our changes to the screen
-		SDL_UpdateRects(_hwscreen, _num_dirty_rects, _dirty_rect_list);
+#pragma mark -
+#pragma mark --- CD Audio ---
+#pragma mark -
+
+bool OSystem_SDL::openCD(int drive) {
+	if (SDL_InitSubSystem(SDL_INIT_CDROM) == -1)
+		_cdrom = NULL;
+	else {
+		_cdrom = SDL_CDOpen(drive);
+		// Did it open? Check if _cdrom is NULL
+		if (!_cdrom) {
+			warning("Couldn't open drive: %s", SDL_GetError());
+		} else {
+			cd_num_loops = 0;
+			cd_stop_time = 0;
+			cd_end_time = 0;
+		}
 	}
+	
+	return (_cdrom != NULL);
+}
 
-	_num_dirty_rects = 0;
-	_forceFull = false;
+void OSystem_SDL::stop_cdrom() {	/* Stop CD Audio in 1/10th of a second */
+	cd_stop_time = SDL_GetTicks() + 100;
+	cd_num_loops = 0;
 }
 
-bool OSystem_SDL::save_screenshot(const char *filename) {
-	assert(_hwscreen != NULL);
+void OSystem_SDL::play_cdrom(int track, int num_loops, int start_frame, int duration) {
+	if (!num_loops && !start_frame)
+		return;
 
-	Common::StackLock lock(_graphicsMutex, this);	// Lock the mutex until this function ends
-	SDL_SaveBMP(_hwscreen, filename);
-	return true;
+	if (!_cdrom)
+		return;
+	
+	if (duration > 0)
+		duration += 5;
+
+	cd_track = track;
+	cd_num_loops = num_loops;
+	cd_start_frame = start_frame;
+
+	SDL_CDStatus(_cdrom);
+	if (start_frame == 0 && duration == 0)
+		SDL_CDPlayTracks(_cdrom, track, 0, 1, 0);
+	else
+		SDL_CDPlayTracks(_cdrom, track, start_frame, 0, duration);
+	cd_duration = duration;
+	cd_stop_time = 0;
+	cd_end_time = SDL_GetTicks() + _cdrom->track[track].length * 1000 / CD_FPS;
 }
 
-void OSystem_SDL::setFullscreenMode(bool enable) {
-	if (_full_screen != enable) {
-		assert(_hwscreen != 0);
-		_full_screen ^= true;
+bool OSystem_SDL::poll_cdrom() {
+	if (!_cdrom)
+		return false;
 
-		if (_mouseDrawn)
-			undraw_mouse();
-	
-#if defined(MACOSX) && !SDL_VERSION_ATLEAST(1, 2, 6)
-		// On OS X, SDL_WM_ToggleFullScreen is currently not implemented. Worse,
-		// before SDL 1.2.6 it always returned -1 (which would indicate a
-		// successful switch). So we simply don't call it at all and use
-		// hotswap_gfx_mode() directly to switch to fullscreen mode.
-		hotswap_gfx_mode();
-#else
-		if (!SDL_WM_ToggleFullScreen(_hwscreen)) {
-			// if ToggleFullScreen fails, achieve the same effect with hotswap gfx mode
-			hotswap_gfx_mode();
-		} else {
-			// Make sure that an EVENT_SCREEN_CHANGED gets sent later
-			_modeChanged = true;
-		}
-#endif
+	return (cd_num_loops != 0 && (SDL_GetTicks() < cd_end_time || SDL_CDStatus(_cdrom) != CD_STOPPED));
+}
+
+void OSystem_SDL::update_cdrom() {
+	if (!_cdrom)
+		return;
+
+	if (cd_stop_time != 0 && SDL_GetTicks() >= cd_stop_time) {
+		SDL_CDStop(_cdrom);
+		cd_num_loops = 0;
+		cd_stop_time = 0;
+		return;
+	}
+
+	if (cd_num_loops == 0 || SDL_GetTicks() < cd_end_time)
+		return;
+
+	if (cd_num_loops != 1 && SDL_CDStatus(_cdrom) != CD_STOPPED) {
+		// Wait another second for it to be done
+		cd_end_time += 1000;
+		return;
+	}
+
+	if (cd_num_loops > 0)
+		cd_num_loops--;
+
+	if (cd_num_loops != 0) {
+		if (cd_start_frame == 0 && cd_duration == 0)
+			SDL_CDPlayTracks(_cdrom, cd_track, 0, 1, 0);
+		else
+			SDL_CDPlayTracks(_cdrom, cd_track, cd_start_frame, 0, cd_duration);
+		cd_end_time = SDL_GetTicks() + _cdrom->track[cd_track].length * 1000 / CD_FPS;
 	}
 }