added samsung tv backend

svn-id: r45775

7 files changed, 3394 insertions, 0 deletions

diff --git a/backends/platform/samsungtv/events.cpp b/backends/platform/samsungtv/events.cpp
new file mode 100644
index 0000000000..9d67272dce
--- /dev/null
+++ b/backends/platform/samsungtv/events.cpp
@@ -0,0 +1,358 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/sdl/events.cpp $
+ * $Id: events.cpp 43636 2009-08-22 12:35:49Z sev $
+ *
+ */
+
+#include "backends/platform/samsungtv/sdl.h"
+#include "common/util.h"
+#include "common/events.h"
+
+#if defined(SAMSUNGTV)
+
+static int mapKey(SDLKey key, SDLMod mod, Uint16 unicode) {
+	if (key >= SDLK_F1 && key <= SDLK_F9) {
+		return key - SDLK_F1 + Common::ASCII_F1;
+	} 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_SamsungTV::fillMouseEvent(Common::Event &event, int x, int y) {
+	event.mouse.x = x;
+	event.mouse.y = y;
+
+	// Update the "keyboard mouse" coords
+	_km.x = x;
+	_km.y = y;
+
+	// Adjust for the screen scaling
+	if (!_overlayVisible) {
+		event.mouse.x /= _videoMode.scaleFactor;
+		event.mouse.y /= _videoMode.scaleFactor;
+		if (_videoMode.aspectRatioCorrection)
+			event.mouse.y = aspect2Real(event.mouse.y);
+	}
+}
+
+void OSystem_SDL_SamsungTV::handleKbdMouse() {
+	uint32 curTime = getMillis();
+	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;
+			}
+
+			setMousePos(_km.x, _km.y);
+		}
+	}
+}
+
+static byte SDLModToOSystemKeyFlags(SDLMod mod) {
+	byte b = 0;
+
+	if (mod & KMOD_SHIFT)
+		b |= Common::KBD_SHIFT;
+	if (mod & KMOD_ALT)
+		b |= Common::KBD_ALT;
+	if (mod & KMOD_CTRL)
+		b |= Common::KBD_CTRL;
+
+	return b;
+}
+
+bool OSystem_SDL_SamsungTV::pollEvent(Common::Event &event) {
+	SDL_Event ev;
+	byte b = 0;
+
+	handleKbdMouse();
+
+	// If the screen mode changed, send an Common::EVENT_SCREEN_CHANGED
+	if (_modeChanged) {
+		_modeChanged = false;
+		event.type = Common::EVENT_SCREEN_CHANGED;
+		return true;
+	}
+
+	while (SDL_PollEvent(&ev)) {
+		preprocessEvents(&ev);
+
+		switch (ev.type) {
+		case SDL_KEYDOWN:{
+			if (ev.key.keysym.sym == SDLK_UP) {
+				_km.y_vel = -1;
+				_km.y_down_count = 1;
+				event.type = Common::EVENT_MOUSEMOVE;
+				fillMouseEvent(event, _km.x, _km.y);
+				return true;
+			} else if (ev.key.keysym.sym == SDLK_DOWN) {
+				_km.y_vel = 1;
+				_km.y_down_count = 1;
+				event.type = Common::EVENT_MOUSEMOVE;
+				fillMouseEvent(event, _km.x, _km.y);
+				return true;
+			} else if (ev.key.keysym.sym == SDLK_LEFT) {
+				_km.x_vel = -1;
+				_km.x_down_count = 1;
+				event.type = Common::EVENT_MOUSEMOVE;
+				fillMouseEvent(event, _km.x, _km.y);
+				return true;
+			} else if (ev.key.keysym.sym == SDLK_RIGHT) {
+				_km.x_vel = 1;
+				_km.x_down_count = 1;
+				event.type = Common::EVENT_MOUSEMOVE;
+				fillMouseEvent(event, _km.x, _km.y);
+				return true;
+			} else if (ev.key.keysym.sym == SDLK_z) {
+				event.type = Common::EVENT_LBUTTONDOWN;
+				fillMouseEvent(event, _km.x, _km.y);
+				return true;
+			} else if (ev.key.keysym.sym == SDLK_HOME) {
+				event.type = Common::EVENT_RBUTTONDOWN;
+				fillMouseEvent(event, _km.x, _km.y);
+				return true;
+			} else if (ev.key.keysym.sym == SDLK_F4) {
+				event.type = Common::EVENT_KEYDOWN;
+				event.kbd.keycode = Common::KEYCODE_SPACE;
+				event.kbd.ascii = ' ';
+				return true;
+			}
+
+			b = event.kbd.flags = SDLModToOSystemKeyFlags(SDL_GetModState());
+
+			// Alt-S: Create a screenshot
+			if (b == Common::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 (saveScreenshot(filename))
+					printf("Saved '%s'\n", filename);
+				else
+					printf("Could not save screenshot!\n");
+				break;
+			}
+
+			// On other unices, Control-Q quits
+			if ((ev.key.keysym.mod & KMOD_CTRL) && ev.key.keysym.sym == 'q') {
+				event.type = Common::EVENT_QUIT;
+				return true;
+			}
+
+			if ((ev.key.keysym.mod & KMOD_CTRL) && ev.key.keysym.sym == 'u') {
+				event.type = Common::EVENT_MUTE;
+				return true;
+			}
+
+			// Ctrl-Alt-<key> will change the GFX mode
+			if ((b & (Common::KBD_CTRL|Common::KBD_ALT)) == (Common::KBD_CTRL|Common::KBD_ALT)) {
+
+				handleScalerHotkeys(ev.key);
+				break;
+			}
+			const bool event_complete = remapKey(ev, event);
+
+			if (event_complete)
+				return true;
+
+			event.type = Common::EVENT_KEYDOWN;
+			event.kbd.keycode = (Common::KeyCode)ev.key.keysym.sym;
+			event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
+
+			return true;
+			}
+		case SDL_KEYUP:
+			{
+			if (ev.key.keysym.sym == SDLK_UP || ev.key.keysym.sym == SDLK_DOWN || ev.key.keysym.sym == SDLK_LEFT || ev.key.keysym.sym == SDLK_RIGHT) {
+				_km.x_vel = 0;
+				_km.x_down_count = 0;
+				_km.y_vel = 0;
+				_km.y_down_count = 0;
+				event.type = Common::EVENT_MOUSEMOVE;
+				fillMouseEvent(event, _km.x, _km.y);
+				return true;
+			} else if (ev.key.keysym.sym == SDLK_z) {
+				event.type = Common::EVENT_LBUTTONUP;
+				fillMouseEvent(event, _km.x, _km.y);
+				return true;
+			} else if (ev.key.keysym.sym == SDLK_HOME) {
+				event.type = Common::EVENT_RBUTTONUP;
+				fillMouseEvent(event, _km.x, _km.y);
+				return true;
+			} else if (ev.key.keysym.sym == SDLK_F4) {
+				event.type = Common::EVENT_KEYUP;
+				event.kbd.keycode = Common::KEYCODE_SPACE;
+				event.kbd.ascii = ' ';
+				return true;
+			}
+
+			const bool event_complete = remapKey(ev,event);
+
+			if (event_complete)
+				return true;
+
+			event.type = Common::EVENT_KEYUP;
+			event.kbd.keycode = (Common::KeyCode)ev.key.keysym.sym;
+			event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
+			b = event.kbd.flags = SDLModToOSystemKeyFlags(SDL_GetModState());
+
+			// Ctrl-Alt-<key> will change the GFX mode
+			if ((b & (Common::KBD_CTRL|Common::KBD_ALT)) == (Common::KBD_CTRL|Common::KBD_ALT)) {
+				// Swallow these key up events
+				break;
+			}
+
+			return true;
+			}
+		case SDL_MOUSEMOTION:
+			event.type = Common::EVENT_MOUSEMOVE;
+			fillMouseEvent(event, ev.motion.x, ev.motion.y);
+
+			setMousePos(event.mouse.x, event.mouse.y);
+			return true;
+
+		case SDL_MOUSEBUTTONDOWN:
+			if (ev.button.button == SDL_BUTTON_LEFT)
+				event.type = Common::EVENT_LBUTTONDOWN;
+			else if (ev.button.button == SDL_BUTTON_RIGHT)
+				event.type = Common::EVENT_RBUTTONDOWN;
+#if defined(SDL_BUTTON_WHEELUP) && defined(SDL_BUTTON_WHEELDOWN)
+			else if (ev.button.button == SDL_BUTTON_WHEELUP)
+				event.type = Common::EVENT_WHEELUP;
+			else if (ev.button.button == SDL_BUTTON_WHEELDOWN)
+				event.type = Common::EVENT_WHEELDOWN;
+#endif
+#if defined(SDL_BUTTON_MIDDLE)
+			else if (ev.button.button == SDL_BUTTON_MIDDLE)
+				event.type = Common::EVENT_MBUTTONDOWN;
+#endif
+			else
+				break;
+
+			fillMouseEvent(event, ev.button.x, ev.button.y);
+
+			return true;
+
+		case SDL_MOUSEBUTTONUP:
+			if (ev.button.button == SDL_BUTTON_LEFT)
+				event.type = Common::EVENT_LBUTTONUP;
+			else if (ev.button.button == SDL_BUTTON_RIGHT)
+				event.type = Common::EVENT_RBUTTONUP;
+#if defined(SDL_BUTTON_MIDDLE)
+			else if (ev.button.button == SDL_BUTTON_MIDDLE)
+				event.type = Common::EVENT_MBUTTONUP;
+#endif
+			else
+				break;
+			fillMouseEvent(event, ev.button.x, ev.button.y);
+
+			return true;
+
+		case SDL_VIDEOEXPOSE:
+			_forceFull = true;
+			break;
+
+		case SDL_QUIT:
+			event.type = Common::EVENT_QUIT;
+			return true;
+		}
+	}
+	return false;
+}
+
+bool OSystem_SDL_SamsungTV::remapKey(SDL_Event &ev, Common::Event &event) {
+	return false;
+}
+
+#endif
diff --git a/backends/platform/samsungtv/graphics.cpp b/backends/platform/samsungtv/graphics.cpp
new file mode 100644
index 0000000000..6ea7c8400e
--- /dev/null
+++ b/backends/platform/samsungtv/graphics.cpp
@@ -0,0 +1,1831 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/sdl/graphics.cpp $
+ * $Id: graphics.cpp 44495 2009-09-30 16:16:53Z fingolfin $
+ *
+ */
+
+#include "backends/platform/samsungtv/sdl.h"
+#include "common/mutex.h"
+#include "common/util.h"
+#include "common/list.h"
+#include "graphics/font.h"
+#include "graphics/fontman.h"
+#include "graphics/scaler.h"
+#include "graphics/surface.h"
+
+#if defined(SAMSUNGTV)
+
+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},
+	{"tv2x", "TV2x", GFX_TV2X},
+	{"dotmatrix", "DotMatrix", GFX_DOTMATRIX},
+	{0, 0, 0}
+};
+
+// Table of relative scalers magnitudes
+// [definedScale - 1][scaleFactor - 1]
+static ScalerProc *scalersMagn[3][3] = {
+#ifndef DISABLE_SCALERS
+	{ Normal1x, AdvMame2x, AdvMame3x },
+	{ Normal1x, Normal1x, Normal1o5x },
+	{ Normal1x, Normal1x, Normal1x }
+#else // remove dependencies on other scalers
+	{ Normal1x, Normal1x, Normal1x },
+	{ Normal1x, Normal1x, Normal1x },
+	{ Normal1x, Normal1x, Normal1x }
+#endif
+};
+
+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 }
+	};
+
+#ifndef DISABLE_SCALERS
+static int cursorStretch200To240(uint8 *buf, uint32 pitch, int width, int height, int srcX, int srcY, int origSrcY);
+#endif
+
+const OSystem::GraphicsMode *OSystem_SDL_SamsungTV::getSupportedGraphicsModes() const {
+	return s_supportedGraphicsModes;
+}
+
+int OSystem_SDL_SamsungTV::getDefaultGraphicsMode() const {
+	return GFX_2XSAI;
+}
+
+void OSystem_SDL_SamsungTV::beginGFXTransaction(void) {
+	assert(_transactionMode == kTransactionNone);
+
+	_transactionMode = kTransactionActive;
+
+	_transactionDetails.sizeChanged = false;
+
+	_transactionDetails.needHotswap = false;
+	_transactionDetails.needUpdatescreen = false;
+
+	_transactionDetails.normal1xScaler = false;
+	_transactionDetails.formatChanged = false;
+
+	_oldVideoMode = _videoMode;
+}
+
+OSystem::TransactionError OSystem_SDL_SamsungTV::endGFXTransaction(void) {
+	int errors = kTransactionSuccess;
+
+	assert(_transactionMode != kTransactionNone);
+
+	if (_transactionMode == kTransactionRollback) {
+		if (_videoMode.fullscreen != _oldVideoMode.fullscreen) {
+			errors |= kTransactionFullscreenFailed;
+
+			_videoMode.fullscreen = _oldVideoMode.fullscreen;
+		} else if (_videoMode.aspectRatioCorrection != _oldVideoMode.aspectRatioCorrection) {
+			errors |= kTransactionAspectRatioFailed;
+
+			_videoMode.aspectRatioCorrection = _oldVideoMode.aspectRatioCorrection;
+		} else if (_videoMode.mode != _oldVideoMode.mode) {
+			errors |= kTransactionModeSwitchFailed;
+
+			_videoMode.mode = _oldVideoMode.mode;
+			_videoMode.scaleFactor = _oldVideoMode.scaleFactor;
+		} else if (_videoMode.format != _oldVideoMode.format) {
+			errors |= kTransactionFormatNotSupported;
+
+			_videoMode.format = _oldVideoMode.format;
+			_screenFormat = _videoMode.format;
+		} else if (_videoMode.screenWidth != _oldVideoMode.screenWidth || _videoMode.screenHeight != _oldVideoMode.screenHeight) {
+			errors |= kTransactionSizeChangeFailed;
+
+			_videoMode.screenWidth = _oldVideoMode.screenWidth;
+			_videoMode.screenHeight = _oldVideoMode.screenHeight;
+			_videoMode.overlayWidth = _oldVideoMode.overlayWidth;
+			_videoMode.overlayHeight = _oldVideoMode.overlayHeight;
+		}
+
+		if (_videoMode.fullscreen == _oldVideoMode.fullscreen &&
+			_videoMode.aspectRatioCorrection == _oldVideoMode.aspectRatioCorrection &&
+			_videoMode.mode == _oldVideoMode.mode &&
+			_videoMode.screenWidth == _oldVideoMode.screenWidth &&
+		   	_videoMode.screenHeight == _oldVideoMode.screenHeight) {
+
+			// Our new video mode would now be exactly the same as the
+			// old one. Since we still can not assume SDL_SetVideoMode
+			// to be working fine, we need to invalidate the old video
+			// mode, so loadGFXMode would error out properly.
+			_oldVideoMode.setup = false;
+		}
+	}
+
+	if (_transactionDetails.sizeChanged || _transactionDetails.formatChanged) {
+		unloadGFXMode();
+		if (!loadGFXMode()) {
+			if (_oldVideoMode.setup) {
+				_transactionMode = kTransactionRollback;
+				errors |= endGFXTransaction();
+			}
+		} else {
+			setGraphicsModeIntern();
+			clearOverlay();
+
+			_videoMode.setup = true;
+			_modeChanged = true;
+			// OSystem_SDL::pollEvent used to update the screen change count,
+			// but actually it gives problems when a video mode was changed
+			// but OSystem_SDL::pollEvent was not called. This for example
+			// caused a crash under certain circumstances when doing an RTL.
+			// To fix this issue we update the screen change count right here.
+			_screenChangeCount++;
+		}
+	} else if (_transactionDetails.needHotswap) {
+		setGraphicsModeIntern();
+		if (!hotswapGFXMode()) {
+			if (_oldVideoMode.setup) {
+				_transactionMode = kTransactionRollback;
+				errors |= endGFXTransaction();
+			}
+		} else {
+			_videoMode.setup = true;
+			_modeChanged = true;
+			// OSystem_SDL::pollEvent used to update the screen change count,
+			// but actually it gives problems when a video mode was changed
+			// but OSystem_SDL::pollEvent was not called. This for example
+			// caused a crash under certain circumstances when doing an RTL.
+			// To fix this issue we update the screen change count right here.
+			_screenChangeCount++;
+
+			if (_transactionDetails.needUpdatescreen)
+				internUpdateScreen();
+		}
+	} else if (_transactionDetails.needUpdatescreen) {
+		setGraphicsModeIntern();
+		internUpdateScreen();
+	} 
+
+	_transactionMode = kTransactionNone;
+	return (TransactionError)errors;
+}
+
+Common::List<Graphics::PixelFormat> OSystem_SDL_SamsungTV::getSupportedFormats() {
+	static Common::List<Graphics::PixelFormat>list;
+	list.push_back(Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0));
+	list.push_back(Graphics::PixelFormat::createFormatCLUT8());
+	return list;
+}
+
+bool OSystem_SDL_SamsungTV::setGraphicsMode(int mode) {
+	Common::StackLock lock(_graphicsMutex);
+
+	assert(_transactionMode == kTransactionActive);
+
+	if (_oldVideoMode.setup && _oldVideoMode.mode == mode)
+		return true;
+
+	int newScaleFactor = 1;
+
+	switch (mode) {
+	case GFX_NORMAL:
+		newScaleFactor = 1;
+		break;
+#ifndef DISABLE_SCALERS
+	case GFX_DOUBLESIZE:
+		newScaleFactor = 2;
+		break;
+	case GFX_TRIPLESIZE:
+		newScaleFactor = 3;
+		break;
+	case GFX_2XSAI:
+		newScaleFactor = 2;
+		break;
+	case GFX_SUPER2XSAI:
+		newScaleFactor = 2;
+		break;
+	case GFX_SUPEREAGLE:
+		newScaleFactor = 2;
+		break;
+	case GFX_ADVMAME2X:
+		newScaleFactor = 2;
+		break;
+	case GFX_ADVMAME3X:
+		newScaleFactor = 3;
+		break;
+	case GFX_TV2X:
+		newScaleFactor = 2;
+		break;
+	case GFX_DOTMATRIX:
+		newScaleFactor = 2;
+		break;
+#endif // DISABLE_SCALERS
+
+	default:
+		warning("unknown gfx mode %d", mode);
+		return false;
+	}
+
+	_transactionDetails.normal1xScaler = (mode == GFX_NORMAL);
+	if (_oldVideoMode.setup && _oldVideoMode.scaleFactor != newScaleFactor)
+		_transactionDetails.needHotswap = true;
+
+	_transactionDetails.needUpdatescreen = true;
+
+	_videoMode.mode = mode;
+	_videoMode.scaleFactor = newScaleFactor;
+
+	return true;
+}
+
+void OSystem_SDL_SamsungTV::setGraphicsModeIntern() {
+	Common::StackLock lock(_graphicsMutex);
+	ScalerProc *newScalerProc = 0;
+
+	switch (_videoMode.mode) {
+	case GFX_NORMAL:
+		newScalerProc = Normal1x;
+		break;
+#ifndef DISABLE_SCALERS
+	case GFX_DOUBLESIZE:
+		newScalerProc = Normal2x;
+		break;
+	case GFX_TRIPLESIZE:
+		newScalerProc = Normal3x;
+		break;
+	case GFX_2XSAI:
+		newScalerProc = _2xSaI;
+		break;
+	case GFX_SUPER2XSAI:
+		newScalerProc = Super2xSaI;
+		break;
+	case GFX_SUPEREAGLE:
+		newScalerProc = SuperEagle;
+		break;
+	case GFX_ADVMAME2X:
+		newScalerProc = AdvMame2x;
+		break;
+	case GFX_ADVMAME3X:
+		newScalerProc = AdvMame3x;
+		break;
+	case GFX_TV2X:
+		newScalerProc = TV2x;
+		break;
+	case GFX_DOTMATRIX:
+		newScalerProc = DotMatrix;
+		break;
+#endif // DISABLE_SCALERS
+
+	default:
+		error("Unknown gfx mode %d", _videoMode.mode);
+	}
+
+	_scalerProc = newScalerProc;
+
+	if (_videoMode.mode != GFX_NORMAL) {
+		for (int i = 0; i < ARRAYSIZE(s_gfxModeSwitchTable); i++) {
+			if (s_gfxModeSwitchTable[i][1] == _videoMode.mode || s_gfxModeSwitchTable[i][2] == _videoMode.mode) {
+				_scalerType = i;
+				break;
+			}
+		}
+	}
+
+	if (!_screen || !_hwscreen || !_prehwscreen)
+		return;
+
+	// Blit everything to the screen
+	_forceFull = true;
+
+	// Even if the old and new scale factors are the same, we may have a
+	// different scaler for the cursor now.
+	blitCursor();
+}
+
+int OSystem_SDL_SamsungTV::getGraphicsMode() const {
+	assert (_transactionMode == kTransactionNone);
+	return _videoMode.mode;
+}
+
+void OSystem_SDL_SamsungTV::initSize(uint w, uint h, const Graphics::PixelFormat *format) {
+	assert(_transactionMode == kTransactionActive);
+
+	//avoid redundant format changes
+	Graphics::PixelFormat newFormat;
+	if (!format)
+		newFormat = Graphics::PixelFormat::createFormatCLUT8();
+	else
+		newFormat = *format;
+
+	assert(newFormat.bytesPerPixel > 0);
+
+	if (newFormat != _videoMode.format)
+	{
+		_videoMode.format = newFormat;
+		_transactionDetails.formatChanged = true;
+		_screenFormat = newFormat;
+	}
+
+	// Avoid redundant res changes
+	if ((int)w == _videoMode.screenWidth && (int)h == _videoMode.screenHeight)
+		return;
+
+	_videoMode.screenWidth = w;
+	_videoMode.screenHeight = h;
+
+	_cksumNum = (w * h / (8 * 8));
+
+	_transactionDetails.sizeChanged = true;
+
+	free(_dirtyChecksums);
+	_dirtyChecksums = (uint32 *)calloc(_cksumNum * 2, sizeof(uint32));
+}
+
+
+static void fixupResolutionForAspectRatio(AspectRatio desiredAspectRatio, int &width, int &height) {
+	assert(&width != &height);
+
+	if (desiredAspectRatio.isAuto())
+		return;
+	
+	int kw = desiredAspectRatio.kw();
+	int kh = desiredAspectRatio.kh();
+
+	const int w = width;
+	const int h = height;
+
+	SDL_Rect const* const*availableModes = SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_SWSURFACE); //TODO : Maybe specify a pixel format
+	assert(availableModes);
+
+	const SDL_Rect *bestMode = NULL;
+	uint bestMetric = (uint)-1; // Metric is wasted space
+	while (const SDL_Rect *mode = *availableModes++) {
+		if (mode->w < w)
+			continue;
+		if (mode->h < h)
+			continue;
+		if (mode->h * kw != mode->w * kh)
+			continue;
+		//printf("%d %d\n", mode->w, mode->h);
+
+		uint metric = mode->w * mode->h - w * h;
+		if (metric > bestMetric)
+			continue;
+
+		bestMetric = metric;
+		bestMode = mode;
+	}
+
+	if (!bestMode) {
+		warning("Unable to enforce the desired aspect ratio!");
+		return;
+	}
+	//printf("%d %d\n", bestMode->w, bestMode->h);
+	width = bestMode->w;
+	height = bestMode->h;
+}
+
+bool OSystem_SDL_SamsungTV::loadGFXMode() {
+	assert(_inited);
+	_forceFull = true;
+
+	_videoMode.overlayWidth = _videoMode.screenWidth * _videoMode.scaleFactor;
+	_videoMode.overlayHeight = _videoMode.screenHeight * _videoMode.scaleFactor;
+
+	if (_videoMode.screenHeight != 200 && _videoMode.screenHeight != 400)
+		_videoMode.aspectRatioCorrection = false;
+
+	if (_videoMode.aspectRatioCorrection)
+		_videoMode.overlayHeight = real2Aspect(_videoMode.overlayHeight);
+
+	_videoMode.hardwareWidth = _videoMode.screenWidth * _videoMode.scaleFactor;
+	_videoMode.hardwareHeight = effectiveScreenHeight();
+
+	_screen = SDL_CreateRGBSurface(SDL_SWSURFACE, _videoMode.screenWidth, _videoMode.screenHeight, 
+						_screenFormat.bytesPerPixel << 3, 
+						((1 << _screenFormat.rBits()) - 1) << _screenFormat.rShift ,
+						((1 << _screenFormat.gBits()) - 1) << _screenFormat.gShift ,
+						((1 << _screenFormat.bBits()) - 1) << _screenFormat.bShift ,
+						((1 << _screenFormat.aBits()) - 1) << _screenFormat.aShift );
+	if (_screen == NULL)
+		error("allocating _screen failed");
+
+	//
+	// Create the surface that contains the scaled graphics in 16 bit mode
+	//
+
+	if (_videoMode.fullscreen) {
+		fixupResolutionForAspectRatio(_videoMode.desiredAspectRatio, _videoMode.hardwareWidth, _videoMode.hardwareHeight);
+	}
+
+	_hwscreen = SDL_SetVideoMode(_videoMode.hardwareWidth, _videoMode.hardwareHeight, 32, SDL_FULLSCREEN | SDL_HWSURFACE);
+
+	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.
+
+		if (!_oldVideoMode.setup) {
+			warning("SDL_SetVideoMode says we can't switch to that mode (%s)", SDL_GetError());
+			quit();
+		} else {
+			return false;
+		}
+	}
+
+	_prehwscreen = SDL_CreateRGBSurface(SDL_SWSURFACE, _videoMode.hardwareWidth, _videoMode.hardwareHeight,
+						16,
+						0x0000f800,
+						0x000007e0,
+						0x0000001f,
+						0x00000000);
+	if (_prehwscreen == NULL)
+		error("allocating _prehwscreen failed");
+
+	//
+	// Create the surface used for the graphics in 16 bit before scaling, and also the overlay
+	//
+
+	// Need some extra bytes around when using 2xSaI
+	_tmpscreen = SDL_CreateRGBSurface(SDL_SWSURFACE, _videoMode.screenWidth + 3, _videoMode.screenHeight + 3,
+						16,
+						0x0000f800,
+						0x000007e0,
+						0x0000001f,
+						0x00000000);
+
+	if (_tmpscreen == NULL)
+		error("allocating _tmpscreen failed");
+
+	_overlayscreen = SDL_CreateRGBSurface(SDL_SWSURFACE, _videoMode.overlayWidth, _videoMode.overlayHeight,
+						16,
+						0x0000f800,
+						0x000007e0,
+						0x0000001f,
+						0x00000000);
+
+	if (_overlayscreen == NULL)
+		error("allocating _overlayscreen failed");
+
+	_overlayFormat.bytesPerPixel = _overlayscreen->format->BytesPerPixel;
+
+	_overlayFormat.rLoss = _overlayscreen->format->Rloss;
+	_overlayFormat.gLoss = _overlayscreen->format->Gloss;
+	_overlayFormat.bLoss = _overlayscreen->format->Bloss;
+	_overlayFormat.aLoss = _overlayscreen->format->Aloss;
+
+	_overlayFormat.rShift = _overlayscreen->format->Rshift;
+	_overlayFormat.gShift = _overlayscreen->format->Gshift;
+	_overlayFormat.bShift = _overlayscreen->format->Bshift;
+	_overlayFormat.aShift = _overlayscreen->format->Ashift;
+
+	_tmpscreen2 = SDL_CreateRGBSurface(SDL_SWSURFACE, _videoMode.overlayWidth + 3, _videoMode.overlayHeight + 3,
+						16,
+						0x0000f800,
+						0x000007e0,
+						0x0000001f,
+						0x00000000);
+
+	if (_tmpscreen2 == NULL)
+		error("allocating _tmpscreen2 failed");
+
+#ifdef USE_OSD
+	_osdSurface = SDL_CreateRGBSurface(SDL_HWSURFACE | SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA,
+						_hwscreen->w,
+						_hwscreen->h,
+						32,
+						_hwscreen->format->Rmask,
+						_hwscreen->format->Gmask,
+						_hwscreen->format->Bmask,
+						_hwscreen->format->Amask);
+	if (_osdSurface == NULL)
+		error("allocating _osdSurface failed");
+	SDL_SetColorKey(_osdSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, kOSDColorKey);
+#endif
+
+	// keyboard cursor control, some other better place for it?
+	_km.x_max = _videoMode.screenWidth * _videoMode.scaleFactor - 1;
+	_km.y_max = effectiveScreenHeight() - 1;
+	_km.delay_time = 25;
+	_km.last_time = 0;
+
+	InitScalers(565);
+
+	return true;
+}
+
+void OSystem_SDL_SamsungTV::unloadGFXMode() {
+	if (_screen) {
+		SDL_FreeSurface(_screen);
+		_screen = NULL;
+	}
+
+	if (_hwscreen) {
+		SDL_FreeSurface(_hwscreen);
+		_hwscreen = NULL;
+	}
+
+	if (_prehwscreen) {
+		SDL_FreeSurface(_prehwscreen);
+		_prehwscreen = NULL;
+	}
+
+	if (_tmpscreen) {
+		SDL_FreeSurface(_tmpscreen);
+		_tmpscreen = NULL;
+	}
+
+	if (_tmpscreen2) {
+		SDL_FreeSurface(_tmpscreen2);
+		_tmpscreen2 = NULL;
+	}
+
+	if (_overlayscreen) {
+		SDL_FreeSurface(_overlayscreen);
+		_overlayscreen = NULL;
+	}
+
+#ifdef USE_OSD
+	if (_osdSurface) {
+		SDL_FreeSurface(_osdSurface);
+		_osdSurface = NULL;
+	}
+#endif
+	DestroyScalers();
+}
+
+bool OSystem_SDL_SamsungTV::hotswapGFXMode() {
+	if (!_screen)
+		return false;
+
+	// Keep around the old _screen & _overlayscreen so we can restore the screen data
+	// after the mode switch.
+	SDL_Surface *old_screen = _screen;
+	_screen = NULL;
+	SDL_Surface *old_overlayscreen = _overlayscreen;
+	_overlayscreen = NULL;
+
+	// Release the HW screen surface
+	SDL_FreeSurface(_hwscreen); _hwscreen = NULL;
+
+	SDL_FreeSurface(_prehwscreen); _prehwscreen = NULL;
+
+	SDL_FreeSurface(_tmpscreen); _tmpscreen = NULL;
+	SDL_FreeSurface(_tmpscreen2); _tmpscreen2 = NULL;
+
+#ifdef USE_OSD
+	// Release the OSD surface
+	SDL_FreeSurface(_osdSurface); _osdSurface = NULL;
+#endif
+
+	// Setup the new GFX mode
+	if (!loadGFXMode()) {
+		unloadGFXMode();
+
+		_screen = old_screen;
+		_overlayscreen = old_overlayscreen;
+
+		return false;
+	}
+
+	// reset palette
+	SDL_SetColors(_screen, _currentPalette, 0, 256);
+
+	// Restore old screen content
+	SDL_BlitSurface(old_screen, NULL, _screen, NULL);
+	SDL_BlitSurface(old_overlayscreen, NULL, _overlayscreen, NULL);
+
+	// Free the old surfaces
+	SDL_FreeSurface(old_screen);
+	SDL_FreeSurface(old_overlayscreen);
+
+	// Update cursor to new scale
+	blitCursor();
+
+	// Blit everything to the screen
+	internUpdateScreen();
+
+	return true;
+}
+
+void OSystem_SDL_SamsungTV::updateScreen() {
+	assert (_transactionMode == kTransactionNone);
+
+	Common::StackLock lock(_graphicsMutex);	// Lock the mutex until this function ends
+
+	internUpdateScreen();
+}
+
+void OSystem_SDL_SamsungTV::internUpdateScreen() {
+	SDL_Surface *srcSurf, *origSurf;
+	int height, width;
+	ScalerProc *scalerProc;
+	int scale1;
+
+	// If the shake position changed, fill the dirty area with blackness
+	if (_currentShakePos != _newShakePos) {
+		SDL_Rect blackrect = {0, 0, _videoMode.screenWidth * _videoMode.scaleFactor, _newShakePos * _videoMode.scaleFactor};
+
+		if (_videoMode.aspectRatioCorrection && !_overlayVisible)
+			blackrect.h = real2Aspect(blackrect.h - 1) + 1;
+
+		SDL_FillRect(_prehwscreen, &blackrect, 0);
+
+		_currentShakePos = _newShakePos;
+
+		_forceFull = true;
+	}
+
+	// Check whether the palette was changed in the meantime and update the
+	// screen surface accordingly.
+	if (_screen && _paletteDirtyEnd != 0) {
+		SDL_SetColors(_screen, _currentPalette + _paletteDirtyStart,
+			_paletteDirtyStart,
+			_paletteDirtyEnd - _paletteDirtyStart);
+
+		_paletteDirtyEnd = 0;
+
+		_forceFull = true;
+	}
+
+#ifdef USE_OSD
+	// OSD visible (i.e. non-transparent)?
+	if (_osdAlpha != SDL_ALPHA_TRANSPARENT) {
+		// Updated alpha value
+		const int diff = SDL_GetTicks() - _osdFadeStartTime;
+		if (diff > 0) {
+			if (diff >= kOSDFadeOutDuration) {
+				// Back to full transparency
+				_osdAlpha = SDL_ALPHA_TRANSPARENT;
+			} else {
+				// Do a linear fade out...
+				const int startAlpha = SDL_ALPHA_TRANSPARENT + kOSDInitialAlpha * (SDL_ALPHA_OPAQUE - SDL_ALPHA_TRANSPARENT) / 100;
+				_osdAlpha = startAlpha + diff * (SDL_ALPHA_TRANSPARENT - startAlpha) / kOSDFadeOutDuration;
+			}
+			SDL_SetAlpha(_osdSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, _osdAlpha);
+			_forceFull = true;
+		}
+	}
+#endif
+
+	if (!_overlayVisible) {
+		origSurf = _screen;
+		srcSurf = _tmpscreen;
+		width = _videoMode.screenWidth;
+		height = _videoMode.screenHeight;
+		scalerProc = _scalerProc;
+		scale1 = _videoMode.scaleFactor;
+	} else {
+		origSurf = _overlayscreen;
+		srcSurf = _tmpscreen2;
+		width = _videoMode.overlayWidth;
+		height = _videoMode.overlayHeight;
+		scalerProc = Normal1x;
+
+		scale1 = 1;
+	}
+
+	// Add the area covered by the mouse cursor to the list of dirty rects if
+	// we have to redraw the mouse.
+	if (_mouseNeedsRedraw)
+		undrawMouse();
+
+	// Force a full redraw if requested
+	if (_forceFull) {
+		_numDirtyRects = 1;
+		_dirtyRectList[0].x = 0;
+		_dirtyRectList[0].y = 0;
+		_dirtyRectList[0].w = width;
+		_dirtyRectList[0].h = height;
+	}
+
+	// Only draw anything if necessary
+	if (_numDirtyRects > 0 || _mouseNeedsRedraw) {
+		SDL_Rect *r;
+		SDL_Rect dst;
+		uint32 srcPitch, dstPitch;
+		SDL_Rect *lastRect = _dirtyRectList + _numDirtyRects;
+
+		for (r = _dirtyRectList; r != lastRect; ++r) {
+			dst = *r;
+			dst.x++;	// Shift rect by one since 2xSai needs to access the data around
+			dst.y++;	// any pixel to scale it, and we want to avoid mem access crashes.
+
+			if (SDL_BlitSurface(origSurf, r, srcSurf, &dst) != 0)
+				error("SDL_BlitSurface failed: %s", SDL_GetError());
+		}
+
+		SDL_LockSurface(srcSurf);
+		SDL_LockSurface(_prehwscreen);
+
+		srcPitch = srcSurf->pitch;
+		dstPitch = _prehwscreen->pitch;
+
+		for (r = _dirtyRectList; r != lastRect; ++r) {
+			register int dst_y = r->y + _currentShakePos;
+			register int dst_h = 0;
+			register int orig_dst_y = 0;
+			register int rx1 = r->x * scale1;
+
+			if (dst_y < height) {
+				dst_h = r->h;
+				if (dst_h > height - dst_y)
+					dst_h = height - dst_y;
+
+				orig_dst_y = dst_y;
+				dst_y = dst_y * scale1;
+
+				if (_videoMode.aspectRatioCorrection && !_overlayVisible)
+					dst_y = real2Aspect(dst_y);
+
+				assert(scalerProc != NULL);
+				scalerProc((byte *)srcSurf->pixels + (r->x * 2 + 2) + (r->y + 1) * srcPitch, srcPitch,
+						   (byte *)_prehwscreen->pixels + rx1 * 2 + dst_y * dstPitch, dstPitch, r->w, dst_h);
+			}
+
+			r->x = rx1;
+			r->y = dst_y;
+			r->w = r->w * scale1;
+			r->h = dst_h * scale1;
+
+#ifndef DISABLE_SCALERS
+			if (_videoMode.aspectRatioCorrection && orig_dst_y < height && !_overlayVisible)
+				r->h = stretch200To240((uint8 *)_prehwscreen->pixels, dstPitch, r->w, r->h, r->x, r->y, orig_dst_y * scale1);
+#endif
+		}
+		SDL_UnlockSurface(srcSurf);
+		SDL_UnlockSurface(_prehwscreen);
+
+		// Readjust the dirty rect list in case we are doing a full update.
+		// This is necessary if shaking is active.
+		if (_forceFull) {
+			_dirtyRectList[0].y = 0;
+			_dirtyRectList[0].h = effectiveScreenHeight();
+		}
+
+		drawMouse();
+
+#ifdef USE_OSD
+		if (_osdAlpha != SDL_ALPHA_TRANSPARENT) {
+			SDL_BlitSurface(_osdSurface, 0, _prehwscreen, 0);
+		}
+#endif
+		// Finally, blit all our changes to the screen
+		SDL_UpdateRects(_prehwscreen, _numDirtyRects, _dirtyRectList);
+	}
+
+	SDL_BlitSurface(_prehwscreen, 0, _hwscreen, 0);
+	SDL_UpdateRect(_hwscreen, 0, 0, _hwscreen->w, _hwscreen->h);
+
+	_numDirtyRects = 0;
+	_forceFull = false;
+	_mouseNeedsRedraw = false;
+}
+
+bool OSystem_SDL_SamsungTV::saveScreenshot(const char *filename) {
+	assert(_hwscreen != NULL);
+
+	Common::StackLock lock(_graphicsMutex);	// Lock the mutex until this function ends
+	return SDL_SaveBMP(_hwscreen, filename) == 0;
+}
+
+void OSystem_SDL_SamsungTV::setFullscreenMode(bool enable) {
+	Common::StackLock lock(_graphicsMutex);
+
+	if (_oldVideoMode.setup && _oldVideoMode.fullscreen == enable)
+		return;
+
+	if (_transactionMode == kTransactionActive) {
+		_videoMode.fullscreen = enable;
+		_transactionDetails.needHotswap = true;
+	}
+}
+
+void OSystem_SDL_SamsungTV::setAspectRatioCorrection(bool enable) {
+	Common::StackLock lock(_graphicsMutex);
+
+	if (_oldVideoMode.setup && _oldVideoMode.aspectRatioCorrection == enable)
+		return;
+
+	if (_transactionMode == kTransactionActive) {
+		_videoMode.aspectRatioCorrection = enable;
+		_transactionDetails.needHotswap = true;
+	}
+}
+
+void OSystem_SDL_SamsungTV::copyRectToScreen(const byte *src, int pitch, int x, int y, int w, int h) {
+	assert (_transactionMode == kTransactionNone);
+	assert(src);
+
+	if (_screen == NULL) {
+		warning("OSystem_SDL::copyRectToScreen: _screen == NULL");
+		return;
+	}
+
+	Common::StackLock lock(_graphicsMutex);	// Lock the mutex until this function ends
+
+	assert(x >= 0 && x < _videoMode.screenWidth);
+	assert(y >= 0 && y < _videoMode.screenHeight);
+	assert(h > 0 && y + h <= _videoMode.screenHeight);
+	assert(w > 0 && x + w <= _videoMode.screenWidth);
+
+	if (IS_ALIGNED(src, 4) && pitch == _videoMode.screenWidth && x == 0 && y == 0 &&
+			w == _videoMode.screenWidth && h == _videoMode.screenHeight && _modeFlags & 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. */
+		addDirtyRgnAuto(src);
+	} else {
+		_cksumValid = false;
+		addDirtyRect(x, y, w, h);
+	}
+
+	// Try to lock the screen surface
+	if (SDL_LockSurface(_screen) == -1)
+		error("SDL_LockSurface failed: %s", SDL_GetError());
+
+	byte *dst = (byte *)_screen->pixels + y * _videoMode.screenWidth * _screenFormat.bytesPerPixel + x * _screenFormat.bytesPerPixel;
+	if (_videoMode.screenWidth == w && pitch == w * _screenFormat.bytesPerPixel) {
+		memcpy(dst, src, h*w*_screenFormat.bytesPerPixel);
+	} else {
+		do {
+			memcpy(dst, src, w * _screenFormat.bytesPerPixel);
+			src += pitch;
+			dst += _videoMode.screenWidth * _screenFormat.bytesPerPixel;
+		} while (--h);
+	}
+
+	// Unlock the screen surface
+	SDL_UnlockSurface(_screen);
+}
+
+Graphics::Surface *OSystem_SDL_SamsungTV::lockScreen() {
+	assert (_transactionMode == kTransactionNone);
+
+	// Lock the graphics mutex
+	lockMutex(_graphicsMutex);
+
+	// paranoia check
+	assert(!_screenIsLocked);
+	_screenIsLocked = true;
+
+	// Try to lock the screen surface
+	if (SDL_LockSurface(_screen) == -1)
+		error("SDL_LockSurface failed: %s", SDL_GetError());
+
+	_framebuffer.pixels = _screen->pixels;
+	_framebuffer.w = _screen->w;
+	_framebuffer.h = _screen->h;
+	_framebuffer.pitch = _screen->pitch;
+	_framebuffer.bytesPerPixel = _screenFormat.bytesPerPixel;
+
+	return &_framebuffer;
+}
+
+void OSystem_SDL_SamsungTV::unlockScreen() {
+	assert (_transactionMode == kTransactionNone);
+
+	// paranoia check
+	assert(_screenIsLocked);
+	_screenIsLocked = false;
+
+	// Unlock the screen surface
+	SDL_UnlockSurface(_screen);
+
+	// Trigger a full screen update
+	_forceFull = true;
+
+	// Finally unlock the graphics mutex
+	unlockMutex(_graphicsMutex);
+}
+
+void OSystem_SDL_SamsungTV::addDirtyRect(int x, int y, int w, int h, bool realCoordinates) {
+	if (_forceFull)
+		return;
+
+	if (_numDirtyRects == NUM_DIRTY_RECT) {
+		_forceFull = true;
+		return;
+	}
+
+	int height, width;
+
+	if (!_overlayVisible && !realCoordinates) {
+		width = _videoMode.screenWidth;
+		height = _videoMode.screenHeight;
+	} else {
+		width = _videoMode.overlayWidth;
+		height = _videoMode.overlayHeight;
+	}
+
+	// Extend the dirty region by 1 pixel for scalers
+	// that "smear" the screen, e.g. 2xSAI
+	if (!realCoordinates) {
+		x--;
+		y--;
+		w+=2;
+		h+=2;
+	}
+
+	// clip
+	if (x < 0) {
+		w += x;
+		x = 0;
+	}
+
+	if (y < 0) {
+		h += y;
+		y=0;
+	}
+
+	if (w > width - x) {
+		w = width - x;
+	}
+
+	if (h > height - y) {
+		h = height - y;
+	}
+
+#ifndef DISABLE_SCALERS
+	if (_videoMode.aspectRatioCorrection && !_overlayVisible && !realCoordinates) {
+		makeRectStretchable(x, y, w, h);
+	}
+#endif
+
+	if (w == width && h == height) {
+		_forceFull = true;
+		return;
+	}
+
+	if (w > 0 && h > 0) {
+		SDL_Rect *r = &_dirtyRectList[_numDirtyRects++];
+
+		r->x = x;
+		r->y = y;
+		r->w = w;
+		r->h = h;
+	}
+}
+
+
+void OSystem_SDL_SamsungTV::makeChecksums(const byte *buf) {
+	assert(buf);
+	uint32 *sums = _dirtyChecksums;
+	uint x,y;
+	const uint last_x = (uint)_videoMode.screenWidth / 8;
+	const uint last_y = (uint)_videoMode.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 += _videoMode.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 += _videoMode.screenWidth;
+			}
+
+			s1 %= BASE;
+			s2 %= BASE;
+
+			/* output the checksum for this block */
+			*sums++ =  (s2 << 16) + s1;
+	}
+}
+
+void OSystem_SDL_SamsungTV::addDirtyRgnAuto(const byte *buf) {
+	assert(buf);
+	assert(IS_ALIGNED(buf, 4));
+
+	/* generate a table of the checksums */
+	makeChecksums(buf);
+
+	if (!_cksumValid) {
+		_forceFull = true;
+		_cksumValid = 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 = _dirtyChecksums;
+
+		for (y = 0; y != _videoMode.screenHeight / 8; y++) {
+			for (x = 0; x != _videoMode.screenWidth / 8; x++, ck++) {
+				if (ck[0] != ck[_cksumNum]) {
+					/* 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 + _cksumNum] = ck[w];
+						w++;
+					} while (x + w != _videoMode.screenWidth / 8 && ck[w] != ck[w + _cksumNum]);
+
+					addDirtyRect(x * 8, y * 8, w * 8, 8);
+
+					if (_forceFull)
+						goto get_out;
+				}
+			}
+		}
+	} else {
+		get_out:;
+		/* Copy old checksums to new */
+		memcpy(_dirtyChecksums + _cksumNum, _dirtyChecksums, _cksumNum * sizeof(uint32));
+	}
+}
+
+int16 OSystem_SDL_SamsungTV::getHeight() {
+	return _videoMode.screenHeight;
+}
+
+int16 OSystem_SDL_SamsungTV::getWidth() {
+	return _videoMode.screenWidth;
+}
+
+void OSystem_SDL_SamsungTV::setPalette(const byte *colors, uint start, uint num) {
+	assert(colors);
+
+	if (_screenFormat.bytesPerPixel > 1)
+		return; //not using a paletted pixel format
+
+	// Setting the palette before _screen is created is allowed - for now -
+	// since we don't actually set the palette until the screen is updated.
+	// But it could indicate a programming error, so let's warn about it.
+
+	if (!_screen)
+		warning("OSystem_SDL::setPalette: _screen == NULL");
+
+	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;
+
+	// Some games blink cursors with palette
+	if (_cursorPaletteDisabled)
+		blitCursor();
+}
+
+void OSystem_SDL_SamsungTV::grabPalette(byte *colors, uint start, uint num) {
+	assert(colors);
+	const SDL_Color *base = _currentPalette + start;
+
+	for (uint i = 0; i < num; ++i) {
+		colors[i * 4] = base[i].r;
+		colors[i * 4 + 1] = base[i].g;
+		colors[i * 4 + 2] = base[i].b;
+		colors[i * 4 + 3] = 0xFF;
+	}
+}
+
+void OSystem_SDL_SamsungTV::setCursorPalette(const byte *colors, uint start, uint num) {
+	assert(colors);
+	const byte *b = colors;
+	uint i;
+	SDL_Color *base = _cursorPalette + start;
+	for (i = 0; i < num; i++) {
+		base[i].r = b[0];
+		base[i].g = b[1];
+		base[i].b = b[2];
+		b += 4;
+	}
+
+	_cursorPaletteDisabled = false;
+	blitCursor();
+}
+
+
+void OSystem_SDL_SamsungTV::setShakePos(int shake_pos) {
+	assert (_transactionMode == kTransactionNone);
+
+	_newShakePos = shake_pos;
+}
+
+
+#pragma mark -
+#pragma mark --- Overlays ---
+#pragma mark -
+
+void OSystem_SDL_SamsungTV::showOverlay() {
+	assert (_transactionMode == kTransactionNone);
+
+	int x, y;
+
+	if (_overlayVisible)
+		return;
+
+	_overlayVisible = true;
+
+	// Since resolution could change, put mouse to adjusted position
+	// Fixes bug #1349059
+	x = _mouseCurState.x * _videoMode.scaleFactor;
+	if (_videoMode.aspectRatioCorrection)
+		y = real2Aspect(_mouseCurState.y) * _videoMode.scaleFactor;
+	else
+		y = _mouseCurState.y * _videoMode.scaleFactor;
+
+	warpMouse(x, y);
+
+	clearOverlay();
+}
+
+void OSystem_SDL_SamsungTV::hideOverlay() {
+	assert (_transactionMode == kTransactionNone);
+
+	if (!_overlayVisible)
+		return;
+
+	int x, y;
+
+	_overlayVisible = false;
+
+	// Since resolution could change, put mouse to adjusted position
+	// Fixes bug #1349059
+	x = _mouseCurState.x / _videoMode.scaleFactor;
+	y = _mouseCurState.y / _videoMode.scaleFactor;
+	if (_videoMode.aspectRatioCorrection)
+		y = aspect2Real(y);
+
+	warpMouse(x, y);
+
+	clearOverlay();
+
+	_forceFull = true;
+}
+
+void OSystem_SDL_SamsungTV::clearOverlay() {
+	//assert (_transactionMode == kTransactionNone);
+	Common::StackLock lock(_graphicsMutex);	// Lock the mutex until this function ends
+
+	if (!_overlayVisible)
+		return;
+
+	// 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 = _videoMode.screenWidth;
+	src.h = dst.h = _videoMode.screenHeight;
+	if (SDL_BlitSurface(_screen, &src, _tmpscreen, &dst) != 0)
+		error("SDL_BlitSurface failed: %s", SDL_GetError());
+
+	SDL_LockSurface(_tmpscreen);
+	SDL_LockSurface(_overlayscreen);
+	
+	_scalerProc((byte *)(_tmpscreen->pixels) + _tmpscreen->pitch + 2, _tmpscreen->pitch,
+	(byte *)_overlayscreen->pixels, _overlayscreen->pitch, _videoMode.screenWidth, _videoMode.screenHeight);
+
+#ifndef DISABLE_SCALERS
+	if (_videoMode.aspectRatioCorrection)
+		stretch200To240((uint8 *)_overlayscreen->pixels, _overlayscreen->pitch,
+						_videoMode.overlayWidth, _videoMode.screenHeight * _videoMode.scaleFactor, 0, 0, 0);
+#endif
+	SDL_UnlockSurface(_tmpscreen);
+	SDL_UnlockSurface(_overlayscreen);
+
+	_forceFull = true;
+}
+
+void OSystem_SDL_SamsungTV::grabOverlay(OverlayColor *buf, int pitch) {
+	assert (_transactionMode == kTransactionNone);
+
+	if (_overlayscreen == NULL)
+		return;
+
+	if (SDL_LockSurface(_overlayscreen) == -1)
+		error("SDL_LockSurface failed: %s", SDL_GetError());
+
+	byte *src = (byte *)_overlayscreen->pixels;
+	int h = _videoMode.overlayHeight;
+	do {
+		memcpy(buf, src, _videoMode.overlayWidth * 2);
+		src += _overlayscreen->pitch;
+		buf += pitch;
+	} while (--h);
+
+	SDL_UnlockSurface(_overlayscreen);
+}
+
+void OSystem_SDL_SamsungTV::copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h) {
+	assert (_transactionMode == kTransactionNone);
+
+	if (_overlayscreen == 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 > _videoMode.overlayWidth - x) {
+		w = _videoMode.overlayWidth - x;
+	}
+
+	if (h > _videoMode.overlayHeight - y) {
+		h = _videoMode.overlayHeight - y;
+	}
+
+	if (w <= 0 || h <= 0)
+		return;
+
+	// Mark the modified region as dirty
+	_cksumValid = false;
+	addDirtyRect(x, y, w, h);
+
+	if (SDL_LockSurface(_overlayscreen) == -1)
+		error("SDL_LockSurface failed: %s", SDL_GetError());
+
+	byte *dst = (byte *)_overlayscreen->pixels + y * _overlayscreen->pitch + x * 2;
+	do {
+		memcpy(dst, buf, w * 2);
+		dst += _overlayscreen->pitch;
+		buf += pitch;
+	} while (--h);
+
+	SDL_UnlockSurface(_overlayscreen);
+}
+
+
+#pragma mark -
+#pragma mark --- Mouse ---
+#pragma mark -
+
+bool OSystem_SDL_SamsungTV::showMouse(bool visible) {
+	if (_mouseVisible == visible)
+		return visible;
+
+	bool last = _mouseVisible;
+	_mouseVisible = visible;
+	_mouseNeedsRedraw = true;
+
+	return last;
+}
+
+void OSystem_SDL_SamsungTV::setMousePos(int x, int y) {
+	if (x != _mouseCurState.x || y != _mouseCurState.y) {
+		_mouseNeedsRedraw = true;
+		_mouseCurState.x = x;
+		_mouseCurState.y = y;
+	}
+}
+
+void OSystem_SDL_SamsungTV::warpMouse(int x, int y) {
+	int y1 = y;
+
+	if (_videoMode.aspectRatioCorrection && !_overlayVisible)
+		y1 = real2Aspect(y);
+
+	if (_mouseCurState.x != x || _mouseCurState.y != y)
+		setMousePos(x, y);
+}
+
+void OSystem_SDL_SamsungTV::setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, uint32 keycolor, int cursorTargetScale, const Graphics::PixelFormat *format) {
+	if (!format)
+		_cursorFormat = Graphics::PixelFormat::createFormatCLUT8();
+	else if (format->bytesPerPixel <= _screenFormat.bytesPerPixel)
+		_cursorFormat = *format;
+	keycolor &= (1 << (_cursorFormat.bytesPerPixel << 3)) - 1;
+
+	if (w == 0 || h == 0)
+		return;
+
+	_mouseCurState.hotX = hotspot_x;
+	_mouseCurState.hotY = hotspot_y;
+
+	_mouseKeyColor = keycolor;
+
+	_cursorTargetScale = cursorTargetScale;
+
+	if (_mouseCurState.w != (int)w || _mouseCurState.h != (int)h) {
+		_mouseCurState.w = w;
+		_mouseCurState.h = h;
+
+		if (_mouseOrigSurface)
+			SDL_FreeSurface(_mouseOrigSurface);
+
+		// Allocate bigger surface because AdvMame2x adds black pixel at [0,0]
+		_mouseOrigSurface = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA,
+						_mouseCurState.w + 2,
+						_mouseCurState.h + 2,
+						16,
+						0x0000f800,
+						0x000007e0,
+						0x0000001f,
+						0x00000000);
+
+		if (_mouseOrigSurface == NULL)
+			error("allocating _mouseOrigSurface failed");
+		SDL_SetColorKey(_mouseOrigSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, kMouseColorKey);
+	}
+
+	free(_mouseData);
+	_mouseData = (byte *)malloc(w * h * _cursorFormat.bytesPerPixel);
+	memcpy(_mouseData, buf, w * h * _cursorFormat.bytesPerPixel);
+
+	blitCursor();
+}
+
+void OSystem_SDL_SamsungTV::blitCursor() {
+	byte *dstPtr;
+	const byte *srcPtr = _mouseData;
+	uint32 color;
+	int w, h, i, j;
+
+	if (!_mouseOrigSurface || !_mouseData)
+		return;
+
+	_mouseNeedsRedraw = true;
+
+	w = _mouseCurState.w;
+	h = _mouseCurState.h;
+
+	SDL_LockSurface(_mouseOrigSurface);
+
+	// Make whole surface transparent
+	for (i = 0; i < h + 2; i++) {
+		dstPtr = (byte *)_mouseOrigSurface->pixels + _mouseOrigSurface->pitch * i;
+		for (j = 0; j < w + 2; j++) {
+			*(uint16 *)dstPtr = kMouseColorKey;
+			dstPtr += 2;
+		}
+	}
+
+	// Draw from [1,1] since AdvMame2x adds artefact at 0,0
+	dstPtr = (byte *)_mouseOrigSurface->pixels + _mouseOrigSurface->pitch + 2;
+
+	SDL_Color *palette;
+
+	if (_cursorPaletteDisabled)
+		palette = _currentPalette;
+	else
+		palette = _cursorPalette;
+
+	for (i = 0; i < h; i++) {
+		for (j = 0; j < w; j++) {
+			if (_cursorFormat.bytesPerPixel > 1) {
+				if (_cursorFormat.bytesPerPixel == 2)
+					color = *(uint16 *)srcPtr;
+				else
+					color = *(uint32 *)srcPtr;
+				if (color != _mouseKeyColor) {	// transparent, don't draw
+					uint8 r, g, b;
+					_cursorFormat.colorToRGB(color, r, g, b);
+					*(uint16 *)dstPtr = SDL_MapRGB(_mouseOrigSurface->format,
+						r, g, b);
+				}
+				dstPtr += 2;
+				srcPtr += _cursorFormat.bytesPerPixel;
+			} else {
+				color = *srcPtr;
+				if (color != _mouseKeyColor) {	// transparent, don't draw
+					*(uint16 *)dstPtr = SDL_MapRGB(_mouseOrigSurface->format,
+						palette[color].r, palette[color].g, palette[color].b);
+				}
+				dstPtr += 2;
+				srcPtr++;
+			}
+		}
+		dstPtr += _mouseOrigSurface->pitch - w * 2;
+	}
+
+	int rW, rH;
+
+	if (_cursorTargetScale >= _videoMode.scaleFactor) {
+		// The cursor target scale is greater or equal to the scale at
+		// which the rest of the screen is drawn. We do not downscale
+		// the cursor image, we draw it at its original size. It will
+		// appear too large on screen.
+
+		rW = w;
+		rH = h;
+		_mouseCurState.rHotX = _mouseCurState.hotX;
+		_mouseCurState.rHotY = _mouseCurState.hotY;
+
+		// The virtual dimensions may be larger than the original.
+
+		_mouseCurState.vW = w * _cursorTargetScale / _videoMode.scaleFactor;
+		_mouseCurState.vH = h * _cursorTargetScale / _videoMode.scaleFactor;
+		_mouseCurState.vHotX = _mouseCurState.hotX * _cursorTargetScale /
+			_videoMode.scaleFactor;
+		_mouseCurState.vHotY = _mouseCurState.hotY * _cursorTargetScale /
+			_videoMode.scaleFactor;
+	} else {
+		// The cursor target scale is smaller than the scale at which
+		// the rest of the screen is drawn. We scale up the cursor
+		// image to make it appear correct.
+
+		rW = w * _videoMode.scaleFactor / _cursorTargetScale;
+		rH = h * _videoMode.scaleFactor / _cursorTargetScale;
+		_mouseCurState.rHotX = _mouseCurState.hotX * _videoMode.scaleFactor /
+			_cursorTargetScale;
+		_mouseCurState.rHotY = _mouseCurState.hotY * _videoMode.scaleFactor /
+			_cursorTargetScale;
+
+		// The virtual dimensions will be the same as the original.
+
+		_mouseCurState.vW = w;
+		_mouseCurState.vH = h;
+		_mouseCurState.vHotX = _mouseCurState.hotX;
+		_mouseCurState.vHotY = _mouseCurState.hotY;
+	}
+
+#ifndef DISABLE_SCALERS
+	int rH1 = rH; // store original to pass to aspect-correction function later
+#endif
+
+	if (_videoMode.aspectRatioCorrection && _cursorTargetScale == 1) {
+		rH = real2Aspect(rH - 1) + 1;
+		_mouseCurState.rHotY = real2Aspect(_mouseCurState.rHotY);
+	}
+
+	if (_mouseCurState.rW != rW || _mouseCurState.rH != rH) {
+		_mouseCurState.rW = rW;
+		_mouseCurState.rH = rH;
+
+		if (_mouseSurface)
+			SDL_FreeSurface(_mouseSurface);
+
+		_mouseSurface = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA,
+						_mouseCurState.rW,
+						_mouseCurState.rH,
+						16,
+						0x0000f800,
+						0x000007e0,
+						0x0000001f,
+						0x00000000);
+
+		if (_mouseSurface == NULL)
+			error("allocating _mouseSurface failed");
+
+		SDL_SetColorKey(_mouseSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, kMouseColorKey);
+	}
+
+	SDL_LockSurface(_mouseSurface);
+
+	ScalerProc *scalerProc;
+
+	// If possible, use the same scaler for the cursor as for the rest of
+	// the game. This only works well with the non-blurring scalers so we
+	// actually only use the 1x, 1.5x, 2x and AdvMame scalers.
+
+	if (_cursorTargetScale == 1 && (_videoMode.mode == GFX_DOUBLESIZE || _videoMode.mode == GFX_TRIPLESIZE))
+		scalerProc = _scalerProc;
+	else
+		scalerProc = scalersMagn[_cursorTargetScale - 1][_videoMode.scaleFactor - 1];
+
+	scalerProc((byte *)_mouseOrigSurface->pixels + _mouseOrigSurface->pitch + 2,
+		_mouseOrigSurface->pitch, (byte *)_mouseSurface->pixels, _mouseSurface->pitch,
+		_mouseCurState.w, _mouseCurState.h);
+
+#ifndef DISABLE_SCALERS
+	if (_videoMode.aspectRatioCorrection && _cursorTargetScale == 1)
+		cursorStretch200To240((uint8 *)_mouseSurface->pixels, _mouseSurface->pitch, rW, rH1, 0, 0, 0);
+#endif
+
+	SDL_UnlockSurface(_mouseSurface);
+	SDL_UnlockSurface(_mouseOrigSurface);
+}
+
+#ifndef DISABLE_SCALERS
+// Basically it is kVeryFastAndUglyAspectMode of stretch200To240 from
+// common/scale/aspect.cpp
+static int cursorStretch200To240(uint8 *buf, uint32 pitch, int width, int height, int srcX, int srcY, int origSrcY) {
+	int maxDstY = real2Aspect(origSrcY + height - 1);
+	int y;
+	const uint8 *startSrcPtr = buf + srcX * 2 + (srcY - origSrcY) * pitch;
+	uint8 *dstPtr = buf + srcX * 2 + maxDstY * pitch;
+
+	for (y = maxDstY; y >= srcY; y--) {
+		const uint8 *srcPtr = startSrcPtr + aspect2Real(y) * pitch;
+
+		if (srcPtr == dstPtr)
+			break;
+		memcpy(dstPtr, srcPtr, width * 2);
+		dstPtr -= pitch;
+	}
+
+	return 1 + maxDstY - srcY;
+}
+#endif
+
+void OSystem_SDL_SamsungTV::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_SamsungTV::undrawMouse() {
+	const int x = _mouseBackup.x;
+	const int y = _mouseBackup.y;
+
+	// When we switch bigger overlay off mouse jumps. Argh!
+	// This is intended to prevent undrawing offscreen mouse
+	if (!_overlayVisible && (x >= _videoMode.screenWidth || y >= _videoMode.screenHeight))
+		return;
+
+	if (_mouseBackup.w != 0 && _mouseBackup.h != 0)
+		addDirtyRect(x, y, _mouseBackup.w, _mouseBackup.h);
+}
+
+void OSystem_SDL_SamsungTV::drawMouse() {
+	if (!_mouseVisible || !_mouseSurface) {
+		_mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0;
+		return;
+	}
+
+	SDL_Rect dst;
+	int scale;
+	int width, height;
+	int hotX, hotY;
+
+	dst.x = _mouseCurState.x;
+	dst.y = _mouseCurState.y;
+
+	if (!_overlayVisible) {
+		scale = _videoMode.scaleFactor;
+		width = _videoMode.screenWidth;
+		height = _videoMode.screenHeight;
+		dst.w = _mouseCurState.vW;
+		dst.h = _mouseCurState.vH;
+		hotX = _mouseCurState.vHotX;
+		hotY = _mouseCurState.vHotY;
+	} else {
+		scale = 1;
+		width = _videoMode.overlayWidth;
+		height = _videoMode.overlayHeight;
+		dst.w = _mouseCurState.rW;
+		dst.h = _mouseCurState.rH;
+		hotX = _mouseCurState.rHotX;
+		hotY = _mouseCurState.rHotY;
+	}
+
+	// The mouse is undrawn using virtual coordinates, i.e. they may be
+	// scaled and aspect-ratio corrected.
+
+	_mouseBackup.x = dst.x - hotX;
+	_mouseBackup.y = dst.y - hotY;
+	_mouseBackup.w = dst.w;
+	_mouseBackup.h = dst.h;
+
+	// We draw the pre-scaled cursor image, so now we need to adjust for
+	// scaling, shake position and aspect ratio correction manually.
+
+	if (!_overlayVisible) {
+		dst.y += _currentShakePos;
+	}
+
+	if (_videoMode.aspectRatioCorrection && !_overlayVisible)
+		dst.y = real2Aspect(dst.y);
+
+	dst.x = scale * dst.x - _mouseCurState.rHotX;
+	dst.y = scale * dst.y - _mouseCurState.rHotY;
+	dst.w = _mouseCurState.rW;
+	dst.h = _mouseCurState.rH;
+
+	// Note that SDL_BlitSurface() and addDirtyRect() will both perform any
+	// clipping necessary
+
+	if (SDL_BlitSurface(_mouseSurface, NULL, _prehwscreen, &dst) != 0)
+		error("SDL_BlitSurface failed: %s", SDL_GetError());
+
+	// The screen will be updated using real surface coordinates, i.e.
+	// they will not be scaled or aspect-ratio corrected.
+
+	addDirtyRect(dst.x, dst.y, dst.w, dst.h, true);
+}
+
+#pragma mark -
+#pragma mark --- On Screen Display ---
+#pragma mark -
+
+#ifdef USE_OSD
+void OSystem_SDL_SamsungTV::displayMessageOnOSD(const char *msg) {
+	assert (_transactionMode == kTransactionNone);
+	assert(msg);
+
+	Common::StackLock lock(_graphicsMutex);	// Lock the mutex until this function ends
+
+	uint i;
+
+	// Lock the OSD surface for drawing
+	if (SDL_LockSurface(_osdSurface))
+		error("displayMessageOnOSD: SDL_LockSurface failed: %s", SDL_GetError());
+
+	Graphics::Surface dst;
+	dst.pixels = _osdSurface->pixels;
+	dst.w = _osdSurface->w;
+	dst.h = _osdSurface->h;
+	dst.pitch = _osdSurface->pitch;
+	dst.bytesPerPixel = _osdSurface->format->BytesPerPixel;
+
+	// The font we are going to use:
+	const Graphics::Font *font = FontMan.getFontByUsage(Graphics::FontManager::kOSDFont);
+
+	// Clear everything with the "transparent" color, i.e. the colorkey
+	SDL_FillRect(_osdSurface, 0, kOSDColorKey);
+
+	// Split the message into separate lines.
+	Common::StringList lines;
+	const char *ptr;
+	for (ptr = msg; *ptr; ++ptr) {
+		if (*ptr == '\n') {
+			lines.push_back(Common::String(msg, ptr - msg));
+			msg = ptr + 1;
+		}
+	}
+	lines.push_back(Common::String(msg, ptr - msg));
+
+	// Determine a rect which would contain the message string (clipped to the
+	// screen dimensions).
+	const int vOffset = 6;
+	const int lineSpacing = 1;
+	const int lineHeight = font->getFontHeight() + 2 * lineSpacing;
+	int width = 0;
+	int height = lineHeight * lines.size() + 2 * vOffset;
+	for (i = 0; i < lines.size(); i++) {
+		width = MAX(width, font->getStringWidth(lines[i]) + 14);
+	}
+
+	// Clip the rect
+	if (width > dst.w)
+		width = dst.w;
+	if (height > dst.h)
+		height = dst.h;
+
+	// Draw a dark gray rect
+	// TODO: Rounded corners ? Border?
+	SDL_Rect osdRect;
+	osdRect.x = (dst.w - width) / 2;
+	osdRect.y = (dst.h - height) / 2;
+	osdRect.w = width;
+	osdRect.h = height;
+	SDL_FillRect(_osdSurface, &osdRect, SDL_MapRGB(_osdSurface->format, 64, 64, 64));
+
+	// Render the message, centered, and in white
+	for (i = 0; i < lines.size(); i++) {
+		font->drawString(&dst, lines[i],
+							osdRect.x, osdRect.y + i * lineHeight + vOffset + lineSpacing, osdRect.w,
+							SDL_MapRGB(_osdSurface->format, 255, 255, 255),
+							Graphics::kTextAlignCenter);
+	}
+
+	// Finished drawing, so unlock the OSD surface again
+	SDL_UnlockSurface(_osdSurface);
+
+	// Init the OSD display parameters, and the fade out
+	_osdAlpha = SDL_ALPHA_TRANSPARENT +  kOSDInitialAlpha * (SDL_ALPHA_OPAQUE - SDL_ALPHA_TRANSPARENT) / 100;
+	_osdFadeStartTime = SDL_GetTicks() + kOSDFadeOutDelay;
+	SDL_SetAlpha(_osdSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, _osdAlpha);
+
+	// Ensure a full redraw takes place next time the screen is updated
+	_forceFull = true;
+}
+#endif
+
+
+#pragma mark -
+#pragma mark --- Misc ---
+#pragma mark -
+
+void OSystem_SDL_SamsungTV::handleScalerHotkeys(const SDL_KeyboardEvent &key) {
+	// Ctrl-Alt-a toggles aspect ratio correction
+	if (key.keysym.sym == 'a') {
+		beginGFXTransaction();
+			setFeatureState(kFeatureAspectRatioCorrection, !_videoMode.aspectRatioCorrection);
+		endGFXTransaction();
+#ifdef USE_OSD
+		char buffer[128];
+		if (_videoMode.aspectRatioCorrection)
+			sprintf(buffer, "Enabled aspect ratio correction\n%d x %d -> %d x %d",
+				_videoMode.screenWidth, _videoMode.screenHeight,
+				_hwscreen->w, _hwscreen->h
+				);
+		else
+			sprintf(buffer, "Disabled aspect ratio correction\n%d x %d -> %d x %d",
+				_videoMode.screenWidth, _videoMode.screenHeight,
+				_hwscreen->w, _hwscreen->h
+				);
+		displayMessageOnOSD(buffer);
+#endif
+		internUpdateScreen();
+		return;
+	}
+
+	int newMode = -1;
+	int factor = _videoMode.scaleFactor - 1;
+
+	// Increase/decrease the scale factor
+	if (key.keysym.sym == SDLK_EQUALS || key.keysym.sym == SDLK_PLUS || key.keysym.sym == SDLK_MINUS ||
+		key.keysym.sym == SDLK_KP_PLUS || key.keysym.sym == SDLK_KP_MINUS) {
+		factor += (key.keysym.sym == SDLK_MINUS || key.keysym.sym == SDLK_KP_MINUS) ? -1 : +1;
+		if (0 <= factor && factor <= 3) {
+			newMode = s_gfxModeSwitchTable[_scalerType][factor];
+		}
+	}
+
+	const bool isNormalNumber = (SDLK_1 <= key.keysym.sym && key.keysym.sym <= SDLK_9);
+	const bool isKeypadNumber = (SDLK_KP1 <= key.keysym.sym && key.keysym.sym <= SDLK_KP9);
+	if (isNormalNumber || isKeypadNumber) {
+		_scalerType = key.keysym.sym - (isNormalNumber ? SDLK_1 : SDLK_KP1);
+		if (_scalerType >= ARRAYSIZE(s_gfxModeSwitchTable))
+			return;
+
+		while (s_gfxModeSwitchTable[_scalerType][factor] < 0) {
+			assert(factor > 0);
+			factor--;
+		}
+		newMode = s_gfxModeSwitchTable[_scalerType][factor];
+	}
+
+	if (newMode >= 0) {
+		beginGFXTransaction();
+			setGraphicsMode(newMode);
+		endGFXTransaction();
+#ifdef USE_OSD
+		if (_osdSurface) {
+			const char *newScalerName = 0;
+			const GraphicsMode *g = getSupportedGraphicsModes();
+			while (g->name) {
+				if (g->id == _videoMode.mode) {
+					newScalerName = g->description;
+					break;
+				}
+				g++;
+			}
+			if (newScalerName) {
+				char buffer[128];
+				sprintf(buffer, "Active graphics filter: %s\n%d x %d -> %d x %d",
+					newScalerName,
+					_videoMode.screenWidth, _videoMode.screenHeight,
+					_hwscreen->w, _hwscreen->h
+					);
+				displayMessageOnOSD(buffer);
+			}
+		}
+#endif
+		internUpdateScreen();
+	}
+
+}
+
+#endif
diff --git a/backends/platform/samsungtv/hardwarekeys.cpp b/backends/platform/samsungtv/hardwarekeys.cpp
new file mode 100644
index 0000000000..336a4f0c08
--- /dev/null
+++ b/backends/platform/samsungtv/hardwarekeys.cpp
@@ -0,0 +1,237 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/sdl/hardwarekeys.cpp $
+ * $Id: hardwarekeys.cpp 40516 2009-05-12 23:31:02Z fingolfin $
+ *
+ */
+
+#include "backends/platform/samsungtv/sdl.h"
+#include "backends/keymapper/keymapper.h"
+#include "common/keyboard.h"
+
+#if defined(SAMSUNGTV)
+
+#ifdef ENABLE_KEYMAPPER
+
+using namespace Common;
+
+struct Key {
+	const char *hwId;
+	KeyCode keycode;
+	uint16 ascii;
+	const char *desc;
+	KeyType preferredAction;
+	bool shiftable;
+};
+
+static const Key keys[] = {
+	{"BACKSPACE", KEYCODE_BACKSPACE, ASCII_BACKSPACE, "Backspace", kActionKeyType, false},
+	{"TAB", KEYCODE_TAB, ASCII_TAB, "Tab", kActionKeyType, false},
+	{"CLEAR", KEYCODE_CLEAR, 0, "Clear", kActionKeyType, false},
+	{"RETURN", KEYCODE_RETURN, ASCII_RETURN, "Return", kActionKeyType, false},
+	{"PAUSE", KEYCODE_PAUSE, 0, "Pause", kActionKeyType, false},
+	{"ESCAPE", KEYCODE_ESCAPE, ASCII_ESCAPE, "Esc", kStartKeyType, false},
+	{"SPACE", KEYCODE_SPACE, ASCII_SPACE, "Space", kActionKeyType, false},
+	{"EXCLAIM", KEYCODE_EXCLAIM, '!', "!", kActionKeyType, false},
+	{"QUOTEDBL", KEYCODE_QUOTEDBL, '"', "\"", kActionKeyType, false},
+	{"HASH", KEYCODE_HASH, '#', "#", kActionKeyType, false},
+	{"DOLLAR", KEYCODE_DOLLAR, '$', "$", kActionKeyType, false},
+	{"AMPERSAND", KEYCODE_AMPERSAND, '&', "&", kActionKeyType, false},
+	{"QUOTE", KEYCODE_QUOTE, '\'', "'", kActionKeyType, false},
+	{"LEFTPAREN", KEYCODE_LEFTPAREN, '(', "(", kActionKeyType, false},
+	{"RIGHTPAREN", KEYCODE_RIGHTPAREN, ')', ")", kActionKeyType, false},
+	{"ASTERISK", KEYCODE_ASTERISK, '*', "*", kActionKeyType, false},
+	{"PLUS", KEYCODE_PLUS, '+', "+", kActionKeyType, false},
+	{"COMMA", KEYCODE_COMMA, ',', ",", kActionKeyType, false},
+	{"MINUS", KEYCODE_MINUS, '-', "-", kActionKeyType, false},
+	{"PERIOD", KEYCODE_PERIOD, '.', ".", kActionKeyType, false},
+	{"SLASH", KEYCODE_SLASH, '/', "/", kActionKeyType, false},
+	{"0", KEYCODE_0, '0', "0", kActionKeyType, false},
+	{"1", KEYCODE_1, '1', "1", kActionKeyType, false},
+	{"2", KEYCODE_2, '2', "2", kActionKeyType, false},
+	{"3", KEYCODE_3, '3', "3", kActionKeyType, false},
+	{"4", KEYCODE_4, '4', "4", kActionKeyType, false},
+	{"5", KEYCODE_5, '5', "5", kActionKeyType, false},
+	{"6", KEYCODE_6, '6', "6", kActionKeyType, false},
+	{"7", KEYCODE_7, '7', "7", kActionKeyType, false},
+	{"8", KEYCODE_8, '8', "8", kActionKeyType, false},
+	{"9", KEYCODE_9, '9', "9", kActionKeyType, false},
+	{"COLON", KEYCODE_COLON, ':', ":", kActionKeyType, false},
+	{"SEMICOLON", KEYCODE_SEMICOLON, ';', ";", kActionKeyType, false},
+	{"LESS", KEYCODE_LESS, '<', "<", kActionKeyType, false},
+	{"EQUALS", KEYCODE_EQUALS, '=', "=", kActionKeyType, false},
+	{"GREATER", KEYCODE_GREATER, '>', ">", kActionKeyType, false},
+	{"QUESTION", KEYCODE_QUESTION, '?', "?", kActionKeyType, false},
+	{"AT", KEYCODE_AT, '@', "@", kActionKeyType, false},
+
+	{"LEFTBRACKET", KEYCODE_LEFTBRACKET, '[', "[", kActionKeyType, false},
+	{"BACKSLASH", KEYCODE_BACKSLASH, '\\', "\\", kActionKeyType, false},
+	{"RIGHTBRACKET", KEYCODE_RIGHTBRACKET, ']', "]", kActionKeyType, false},
+	{"CARET", KEYCODE_CARET, '^', "^", kActionKeyType, false},
+	{"UNDERSCORE", KEYCODE_UNDERSCORE, '_', "_", kActionKeyType, false},
+	{"BACKQUOTE", KEYCODE_BACKQUOTE, '`', "`", kActionKeyType, false},
+	{"a", KEYCODE_a, 'a', "a", kActionKeyType, true},
+	{"b", KEYCODE_b, 'b', "b", kActionKeyType, true},
+	{"c", KEYCODE_c, 'c', "c", kActionKeyType, true},
+	{"d", KEYCODE_d, 'd', "d", kActionKeyType, true},
+	{"e", KEYCODE_e, 'e', "e", kActionKeyType, true},
+	{"f", KEYCODE_f, 'f', "f", kActionKeyType, true},
+	{"g", KEYCODE_g, 'g', "g", kActionKeyType, true},
+	{"h", KEYCODE_h, 'h', "h", kActionKeyType, true},
+	{"i", KEYCODE_i, 'i', "i", kActionKeyType, true},
+	{"j", KEYCODE_j, 'j', "j", kActionKeyType, true},
+	{"k", KEYCODE_k, 'k', "k", kActionKeyType, true},
+	{"l", KEYCODE_l, 'l', "l", kActionKeyType, true},
+	{"m", KEYCODE_m, 'm', "m", kActionKeyType, true},
+	{"n", KEYCODE_n, 'n', "n", kActionKeyType, true},
+	{"o", KEYCODE_o, 'o', "o", kActionKeyType, true},
+	{"p", KEYCODE_p, 'p', "p", kActionKeyType, true},
+	{"q", KEYCODE_q, 'q', "q", kActionKeyType, true},
+	{"r", KEYCODE_r, 'r', "r", kActionKeyType, true},
+	{"s", KEYCODE_s, 's', "s", kActionKeyType, true},
+	{"t", KEYCODE_t, 't', "t", kActionKeyType, true},
+	{"u", KEYCODE_u, 'u', "u", kActionKeyType, true},
+	{"v", KEYCODE_v, 'v', "v", kActionKeyType, true},
+	{"w", KEYCODE_w, 'w', "w", kActionKeyType, true},
+	{"x", KEYCODE_x, 'x', "x", kActionKeyType, true},
+	{"y", KEYCODE_y, 'y', "y", kActionKeyType, true},
+	{"z", KEYCODE_z, 'z', "z", kActionKeyType, true},
+	{"DELETE", KEYCODE_DELETE, 0, "Del", kActionKeyType, false},
+
+	// Numeric keypad
+	{"KP0", KEYCODE_KP0, 0, "KP0", kActionKeyType, false},
+	{"KP1", KEYCODE_KP1, 0, "KP1", kActionKeyType, false},
+	{"KP2", KEYCODE_KP2, 0, "KP2", kActionKeyType, false},
+	{"KP3", KEYCODE_KP3, 0, "KP3", kActionKeyType, false},
+	{"KP4", KEYCODE_KP4, 0, "KP4", kActionKeyType, false},
+	{"KP5", KEYCODE_KP5, 0, "KP5", kActionKeyType, false},
+	{"KP6", KEYCODE_KP6, 0, "KP6", kActionKeyType, false},
+	{"KP7", KEYCODE_KP7, 0, "KP7", kActionKeyType, false},
+	{"KP8", KEYCODE_KP8, 0, "KP8", kActionKeyType, false},
+	{"KP9", KEYCODE_KP9, 0, "KP9", kActionKeyType, false},
+	{"KP_PERIOD", KEYCODE_KP_PERIOD, 0, "KP.", kActionKeyType, false},
+	{"KP_DIVIDE", KEYCODE_KP_DIVIDE, 0, "KP/", kActionKeyType, false},
+	{"KP_MULTIPLY", KEYCODE_KP_MULTIPLY, 0, "KP*", kActionKeyType, false},
+	{"KP_MINUS", KEYCODE_KP_MINUS, 0, "KP-", kActionKeyType, false},
+	{"KP_PLUS", KEYCODE_KP_PLUS, 0, "KP+", kActionKeyType, false},
+	{"KP_ENTER", KEYCODE_KP_ENTER, 0, "KP Enter", kActionKeyType, false},
+	{"KP_EQUALS", KEYCODE_KP_EQUALS, 0, "KP=", kActionKeyType, false},
+
+	// Arrows + Home/End pad
+	{"UP", KEYCODE_UP, 0, "Up", kDirUpKeyType, false},
+	{"DOWN", KEYCODE_DOWN, 0, "Down", kDirDownKeyType, false},
+	{"RIGHT", KEYCODE_RIGHT, 0, "Right", kDirRightKeyType, false},
+	{"LEFT", KEYCODE_LEFT, 0, "Left", kDirLeftKeyType, false},
+	{"INSERT", KEYCODE_INSERT, 0, "Insert", kActionKeyType, false},
+	{"HOME", KEYCODE_HOME, 0, "Home", kActionKeyType, false},
+	{"END", KEYCODE_END, 0, "End", kActionKeyType, false},
+	{"PAGEUP", KEYCODE_PAGEUP, 0, "PgUp", kActionKeyType, false},
+	{"PAGEDOWN", KEYCODE_PAGEDOWN, 0, "PgDn", kActionKeyType, false},
+
+	// Function keys
+	{"F1", KEYCODE_F1, ASCII_F1, "F1", kActionKeyType, false},
+	{"F2", KEYCODE_F2, ASCII_F2, "F2", kActionKeyType, false},
+	{"F3", KEYCODE_F3, ASCII_F3, "F3", kActionKeyType, false},
+	{"F4", KEYCODE_F4, ASCII_F4, "F4", kActionKeyType, false},
+	{"F5", KEYCODE_F5, ASCII_F5, "F5", kActionKeyType, false},
+	{"F6", KEYCODE_F6, ASCII_F6, "F6", kActionKeyType, false},
+	{"F7", KEYCODE_F7, ASCII_F7, "F7", kActionKeyType, false},
+	{"F8", KEYCODE_F8, ASCII_F8, "F8", kActionKeyType, false},
+	{"F9", KEYCODE_F9, ASCII_F9, "F9", kActionKeyType, false},
+	{"F10", KEYCODE_F10, ASCII_F10, "F10", kActionKeyType, false},
+	{"F11", KEYCODE_F11, ASCII_F11, "F11", kActionKeyType, false},
+	{"F12", KEYCODE_F12, ASCII_F12, "F12", kActionKeyType, false},
+	{"F13", KEYCODE_F13, 0, "F13", kActionKeyType, false},
+	{"F14", KEYCODE_F14, 0, "F14", kActionKeyType, false},
+	{"F15", KEYCODE_F15, 0, "F15", kActionKeyType, false},
+
+	// Miscellaneous function keys
+	{"HELP", KEYCODE_HELP, 0, "Help", kActionKeyType, false},
+	{"PRINT", KEYCODE_PRINT, 0, "Print", kActionKeyType, false},
+	{"SYSREQ", KEYCODE_SYSREQ, 0, "SysRq", kActionKeyType, false},
+	{"BREAK", KEYCODE_BREAK, 0, "Break", kActionKeyType, false},
+	{"MENU", KEYCODE_MENU, 0, "Menu", kActionKeyType, false},
+		// Power Macintosh power key
+	{"POWER", KEYCODE_POWER, 0, "Power", kActionKeyType, false},
+		// Some european keyboards
+	{"EURO", KEYCODE_EURO, 0, "Euro", kActionKeyType, false},
+		// Atari keyboard has Undo
+	{"UNDO", KEYCODE_UNDO, 0, "Undo", kActionKeyType, false},
+	{0, KEYCODE_INVALID, 0, 0, kGenericKeyType, false}
+};
+
+struct Mod {
+	byte flag;
+	const char *id;
+	const char *desc;
+	bool shiftable;
+};
+
+static const Mod modifiers[] = {
+	{ 0, "", "", false },
+	{ KBD_CTRL, "C+", "Ctrl+", false },
+	{ KBD_ALT, "A+", "Alt+", false },
+	{ KBD_SHIFT, "", "", true },
+	{ KBD_CTRL | KBD_ALT, "C+A+", "Ctrl+Alt+", false },
+	{ KBD_SHIFT | KBD_CTRL, "S+C+", "Shift+Ctrl+", true },
+	{ KBD_SHIFT | KBD_CTRL | KBD_ALT, "C+A+", "Ctrl+Alt+", true },
+	{ 0, 0, 0, false }
+};
+#endif
+
+
+Common::HardwareKeySet *OSystem_SDL_SamsungTV::getHardwareKeySet() {
+#ifdef ENABLE_KEYMAPPER
+	HardwareKeySet *keySet = new HardwareKeySet();
+	const Key *key;
+	const Mod *mod;
+	char fullKeyId[50];
+	char fullKeyDesc[100];
+	uint16 ascii;
+
+	for (mod = modifiers; mod->id; mod++) {
+		for (key = keys; key->hwId; key++) {
+			ascii = key->ascii;
+
+			if (mod->shiftable && key->shiftable) {
+				snprintf(fullKeyId, 50, "%s%c", mod->id, toupper(key->hwId[0]));
+				snprintf(fullKeyDesc, 100, "%s%c", mod->desc, toupper(key->desc[0]));
+				ascii = toupper(key->ascii);
+			} else if (mod->shiftable) {
+				snprintf(fullKeyId, 50, "S+%s%s", mod->id, key->hwId);
+				snprintf(fullKeyDesc, 100, "Shift+%s%s", mod->desc, key->desc);
+			} else {
+				snprintf(fullKeyId, 50, "%s%s", mod->id, key->hwId);
+				snprintf(fullKeyDesc, 100, "%s%s", mod->desc, key->desc);
+			}
+
+			keySet->addHardwareKey(new HardwareKey(fullKeyId, KeyState(key->keycode, ascii, mod->flag), fullKeyDesc, key->preferredAction ));
+		}
+	}
+
+	return keySet;
+
+#else
+	return 0;
+#endif
+}
+
+#endif
diff --git a/backends/platform/samsungtv/main.cpp b/backends/platform/samsungtv/main.cpp
new file mode 100644
index 0000000000..9bcec2ac48
--- /dev/null
+++ b/backends/platform/samsungtv/main.cpp
@@ -0,0 +1,91 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/sdl/main.cpp $
+ * $Id: main.cpp 43636 2009-08-22 12:35:49Z sev $
+ *
+ */
+
+#include "backends/platform/samsungtv/sdl.h"
+#include "backends/plugins/sdl/sdl-provider.h"
+#include "base/main.h"
+
+#if defined(SAMSUNGTV)
+
+#include <unistd.h>
+
+extern "C" int Game_Main(char *path, char *) {
+	chdir(path);
+
+	//
+	// Set up redirects for stdout/stderr under Windows and Symbian.
+	// Code copied from SDL_main.
+	//
+/*
+	// Symbian does not like any output to the console through any *print* function
+	char STDOUT_FILE[256], STDERR_FILE[256]; // shhh, don't tell anybody :)
+	strcpy(STDOUT_FILE, "/dtv/usb/sda1/");
+	strcpy(STDERR_FILE, "/dtv/usb/sda1/");
+	strcat(STDOUT_FILE, "scummvm.stdout.txt");
+	strcat(STDERR_FILE, "scummvm.stderr.txt");
+*/
+	/* Flush the output in case anything is queued */
+/*	fclose(stdout);
+	fclose(stderr);
+*/
+	/* Redirect standard input and standard output */
+//	FILE *newfp = freopen(STDOUT_FILE, "w", stdout);
+//	if (newfp == NULL) {	/* This happens on NT */
+/*#if !defined(stdout)
+		stdout = fopen(STDOUT_FILE, "w");
+#else
+		newfp = fopen(STDOUT_FILE, "w");
+		if (newfp) {
+			*stdout = *newfp;
+		}
+#endif
+	}
+	newfp = freopen(STDERR_FILE, "w", stderr);
+	if (newfp == NULL) {*/	/* This happens on NT */
+/*#if !defined(stderr)
+		stderr = fopen(STDERR_FILE, "w");
+#else
+		newfp = fopen(STDERR_FILE, "w");
+		if (newfp) {
+			*stderr = *newfp;
+		}
+#endif
+	}
+	setbuf(stderr, NULL);*/			/* No buffering */
+
+	g_system = new OSystem_SDL_SamsungTV();
+	assert(g_system);
+
+#ifdef DYNAMIC_MODULES
+	PluginManager::instance().addPluginProvider(new SDLPluginProvider());
+#endif
+
+	// Invoke the actual ScummVM main entry point:
+	int res = scummvm_main(0, 0);
+	g_system->quit();	// TODO: Consider removing / replacing this!
+	return res;
+}
+
+#endif
diff --git a/backends/platform/samsungtv/module.mk b/backends/platform/samsungtv/module.mk
new file mode 100644
index 0000000000..4bfe5bcb08
--- /dev/null
+++ b/backends/platform/samsungtv/module.mk
@@ -0,0 +1,14 @@
+MODULE := backends/platform/samsungtv
+
+MODULE_OBJS := \
+	events.o \
+	graphics.o \
+	hardwarekeys.o \
+	main.o \
+	sdl.o
+
+MODULE_DIRS += \
+	backends/platform/samsungtv/
+
+# We don't use the rules.mk here on purpose
+OBJS := $(addprefix $(MODULE)/, $(MODULE_OBJS)) $(OBJS)
diff --git a/backends/platform/samsungtv/sdl.cpp b/backends/platform/samsungtv/sdl.cpp
new file mode 100644
index 0000000000..c60f4c6edc
--- /dev/null
+++ b/backends/platform/samsungtv/sdl.cpp
@@ -0,0 +1,427 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/sdl/sdl.cpp $
+ * $Id: sdl.cpp 44793 2009-10-08 19:41:38Z fingolfin $
+ *
+ */
+
+#include "backends/platform/samsungtv/sdl.h"
+#include "common/archive.h"
+#include "common/config-manager.h"
+#include "common/debug.h"
+#include "common/EventRecorder.h"
+#include "common/util.h"
+
+#include "backends/saves/posix/posix-saves.h"
+#include "backends/timer/default/default-timer.h"
+#include "sound/mixer_intern.h"
+
+#include <time.h>	// for getTimeAndDate()
+
+#define SAMPLES_PER_SEC 22050
+
+/*
+ * Include header files needed for the getFilesystemFactory() method.
+ */
+#include "backends/fs/posix/posix-fs-factory.h"
+
+#if defined(SAMSUNGTV)
+
+#define DEFAULT_CONFIG_FILE "/dtv/usb/sda1/.scummvmrc"
+
+static Uint32 timer_handler(Uint32 interval, void *param) {
+	((DefaultTimerManager *)param)->handler();
+	return interval;
+}
+
+AspectRatio::AspectRatio(int w, int h) {
+	// TODO : Validation and so on...
+	// Currently, we just ensure the program don't instantiate non-supported aspect ratios
+	_kw = w;
+	_kh = h;
+}
+
+static const size_t AR_COUNT = 4;
+static const char*       desiredAspectRatioAsStrings[AR_COUNT] = {            "auto",            "4/3",            "16/9",            "16/10" };
+static const AspectRatio desiredAspectRatios[AR_COUNT]         = { AspectRatio(0, 0), AspectRatio(4,3), AspectRatio(16,9), AspectRatio(16,10) };
+static AspectRatio getDesiredAspectRatio() {
+	//TODO : We could parse an arbitrary string, if we code enough proper validation
+	Common::String desiredAspectRatio = ConfMan.get("desired_screen_aspect_ratio");
+
+	for (size_t i = 0; i < AR_COUNT; i++) {
+		assert(desiredAspectRatioAsStrings[i] != NULL);
+
+		if (!scumm_stricmp(desiredAspectRatio.c_str(), desiredAspectRatioAsStrings[i])) {
+			return desiredAspectRatios[i];
+		}
+	}
+	// TODO : Report a warning
+	return AspectRatio(0, 0);
+}
+
+void OSystem_SDL_SamsungTV::initBackend() {
+	assert(!_inited);
+
+	uint32 sdlFlags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
+
+	if (ConfMan.hasKey("disable_sdl_parachute"))
+		sdlFlags |= SDL_INIT_NOPARACHUTE;
+
+	if (SDL_Init(sdlFlags) == -1) {
+		error("Could not initialize SDL: %s", SDL_GetError());
+	}
+
+	_graphicsMutex = createMutex();
+
+	// Enable unicode support if possible
+	SDL_EnableUNICODE(1);
+
+	memset(&_oldVideoMode, 0, sizeof(_oldVideoMode));
+	memset(&_videoMode, 0, sizeof(_videoMode));
+	memset(&_transactionDetails, 0, sizeof(_transactionDetails));
+
+	_cksumValid = false;
+	_videoMode.mode = GFX_2XSAI;
+	_videoMode.scaleFactor = 2;
+	_videoMode.aspectRatioCorrection = ConfMan.getBool("aspect_ratio");
+	_videoMode.desiredAspectRatio = getDesiredAspectRatio();
+	_scalerProc = _2xSaI;
+	_scalerType = 0;
+	_modeFlags = 0;
+	_videoMode.fullscreen = true;
+
+
+	// Create the savefile manager, if none exists yet (we check for this to
+	// allow subclasses to provide their own).
+	if (_savefile == NULL) {
+	    _savefile = new POSIXSaveFileManager();
+	}
+
+	// Create and hook up the mixer, if none exists yet (we check for this to
+	// allow subclasses to provide their own).
+	if (_mixer == NULL) {
+		setupMixer();
+	}
+
+	// Create and hook up the timer manager, if none exists yet (we check for
+	// this to allow subclasses to provide their own).
+	if (_timer == NULL) {
+		// Note: We could implement a custom SDLTimerManager by using
+		// SDL_AddTimer. That might yield better timer resolution, but it would
+		// also change the semantics of a timer: Right now, ScummVM timers
+		// *never* run in parallel, due to the way they are implemented. If we
+		// switched to SDL_AddTimer, each timer might run in a separate thread.
+		// However, not all our code is prepared for that, so we can't just
+		// switch. Still, it's a potential future change to keep in mind.
+		_timer = new DefaultTimerManager();
+		_timerID = SDL_AddTimer(10, &timer_handler, _timer);
+	}
+
+	// Invoke parent implementation of this method
+	OSystem::initBackend();
+
+	_inited = true;
+}
+
+OSystem_SDL_SamsungTV::OSystem_SDL_SamsungTV()
+	:
+#ifdef USE_OSD
+	_osdSurface(0), _osdAlpha(SDL_ALPHA_TRANSPARENT), _osdFadeStartTime(0),
+#endif
+	_hwscreen(0), _prehwscreen(0), _screen(0), _tmpscreen(0),
+	_screenFormat(Graphics::PixelFormat::createFormatCLUT8()),
+	_cursorFormat(Graphics::PixelFormat::createFormatCLUT8()),
+	_overlayVisible(false),
+	_overlayscreen(0), _tmpscreen2(0),
+	_samplesPerSec(0),
+	_scalerProc(0), _modeChanged(false), _screenChangeCount(0), _dirtyChecksums(0),
+	_mouseVisible(false), _mouseNeedsRedraw(false), _mouseData(0), _mouseSurface(0),
+	_mouseOrigSurface(0), _cursorTargetScale(1), _cursorPaletteDisabled(true),
+	_currentShakePos(0), _newShakePos(0),
+	_paletteDirtyStart(0), _paletteDirtyEnd(0),
+	_fsFactory(0),
+	_savefile(0),
+	_mixer(0),
+	_timer(0),
+	_screenIsLocked(false),
+	_graphicsMutex(0), _transactionMode(kTransactionNone) {
+
+	// allocate palette storage
+	_currentPalette = (SDL_Color *)calloc(sizeof(SDL_Color), 256);
+	_cursorPalette = (SDL_Color *)calloc(sizeof(SDL_Color), 256);
+
+	_mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0;
+
+	// reset mouse state
+	memset(&_km, 0, sizeof(_km));
+	memset(&_mouseCurState, 0, sizeof(_mouseCurState));
+
+	_inited = false;
+
+	_fsFactory = new POSIXFilesystemFactory();
+}
+
+OSystem_SDL_SamsungTV::~OSystem_SDL_SamsungTV() {
+	SDL_RemoveTimer(_timerID);
+	closeMixer();
+
+	free(_dirtyChecksums);
+	free(_currentPalette);
+	free(_cursorPalette);
+	free(_mouseData);
+
+	delete _savefile;
+	delete _timer;
+}
+
+uint32 OSystem_SDL_SamsungTV::getMillis() {
+	uint32 millis = SDL_GetTicks();
+	g_eventRec.processMillis(millis);
+	return millis;
+}
+
+void OSystem_SDL_SamsungTV::delayMillis(uint msecs) {
+	SDL_Delay(msecs);
+}
+
+void OSystem_SDL_SamsungTV::getTimeAndDate(TimeDate &td) const {
+	time_t curTime = time(0);
+	struct tm t = *localtime(&curTime);
+	td.tm_sec = t.tm_sec;
+	td.tm_min = t.tm_min;
+	td.tm_hour = t.tm_hour;
+	td.tm_mday = t.tm_mday;
+	td.tm_mon = t.tm_mon;
+	td.tm_year = t.tm_year;
+}
+
+Common::TimerManager *OSystem_SDL_SamsungTV::getTimerManager() {
+	assert(_timer);
+	return _timer;
+}
+
+Common::SaveFileManager *OSystem_SDL_SamsungTV::getSavefileManager() {
+	assert(_savefile);
+	return _savefile;
+}
+
+FilesystemFactory *OSystem_SDL_SamsungTV::getFilesystemFactory() {
+	assert(_fsFactory);
+	return _fsFactory;
+}
+
+void OSystem_SDL_SamsungTV::addSysArchivesToSearchSet(Common::SearchSet &s, int priority) {
+	// Add the global DATA_PATH to the directory search list
+	// FIXME: We use depth = 4 for now, to match the old code. May want to change that
+	Common::FSNode dataNode(".");
+	if (dataNode.exists() && dataNode.isDirectory()) {
+		s.add(DATA_PATH, new Common::FSDirectory(dataNode, 4), priority);
+	}
+}
+
+
+static Common::String getDefaultConfigFileName() {
+	char configFile[MAXPATHLEN];
+	strcpy(configFile, DEFAULT_CONFIG_FILE);
+	return configFile;
+}
+
+Common::SeekableReadStream *OSystem_SDL_SamsungTV::createConfigReadStream() {
+	Common::FSNode file(getDefaultConfigFileName());
+	return file.createReadStream();
+}
+
+Common::WriteStream *OSystem_SDL_SamsungTV::createConfigWriteStream() {
+	Common::FSNode file(getDefaultConfigFileName());
+	return file.createWriteStream();
+}
+
+void OSystem_SDL_SamsungTV::setWindowCaption(const char *caption) {
+}
+
+bool OSystem_SDL_SamsungTV::hasFeature(Feature f) {
+	return
+		(f == kFeatureAutoComputeDirtyRects) ||
+		(f == kFeatureCursorHasPalette);
+}
+
+void OSystem_SDL_SamsungTV::setFeatureState(Feature f, bool enable) {
+	switch (f) {
+	case kFeatureAspectRatioCorrection:
+		setAspectRatioCorrection(enable);
+		break;
+	case kFeatureAutoComputeDirtyRects:
+		if (enable)
+			_modeFlags |= DF_WANT_RECT_OPTIM;
+		else
+			_modeFlags &= ~DF_WANT_RECT_OPTIM;
+		break;
+	default:
+		break;
+	}
+}
+
+bool OSystem_SDL_SamsungTV::getFeatureState(Feature f) {
+	assert (_transactionMode == kTransactionNone);
+
+	switch (f) {
+	case kFeatureAspectRatioCorrection:
+		return _videoMode.aspectRatioCorrection;
+	case kFeatureAutoComputeDirtyRects:
+		return _modeFlags & DF_WANT_RECT_OPTIM;
+	default:
+		return false;
+	}
+}
+
+void OSystem_SDL_SamsungTV::quit() {
+	unloadGFXMode();
+	deleteMutex(_graphicsMutex);
+
+	SDL_RemoveTimer(_timerID);
+	closeMixer();
+
+	free(_dirtyChecksums);
+	free(_currentPalette);
+	free(_cursorPalette);
+	free(_mouseData);
+
+	delete _timer;
+
+	SDL_Quit();
+
+	// Even Manager requires save manager for storing
+	// recorded events
+	delete getEventManager();
+	delete _savefile;
+}
+
+void OSystem_SDL_SamsungTV::setupIcon() {
+}
+
+OSystem::MutexRef OSystem_SDL_SamsungTV::createMutex(void) {
+	return (MutexRef)SDL_CreateMutex();
+}
+
+void OSystem_SDL_SamsungTV::lockMutex(MutexRef mutex) {
+	SDL_mutexP((SDL_mutex *) mutex);
+}
+
+void OSystem_SDL_SamsungTV::unlockMutex(MutexRef mutex) {
+	SDL_mutexV((SDL_mutex *) mutex);
+}
+
+void OSystem_SDL_SamsungTV::deleteMutex(MutexRef mutex) {
+	SDL_DestroyMutex((SDL_mutex *) mutex);
+}
+
+void OSystem_SDL_SamsungTV::mixCallback(void *sys, byte *samples, int len) {
+	OSystem_SDL_SamsungTV *this_ = (OSystem_SDL_SamsungTV *)sys;
+	assert(this_);
+	assert(this_->_mixer);
+
+	this_->_mixer->mixCallback(samples, len);
+}
+
+void OSystem_SDL_SamsungTV::setupMixer() {
+	SDL_AudioSpec desired;
+
+	// Determine the desired output sampling frequency.
+	_samplesPerSec = 0;
+	if (ConfMan.hasKey("output_rate"))
+		_samplesPerSec = ConfMan.getInt("output_rate");
+	if (_samplesPerSec <= 0)
+		_samplesPerSec = SAMPLES_PER_SEC;
+
+	// Determine the sample buffer size. We want it to store enough data for
+	// about 1/16th of a second. Note that it must be a power of two.
+	// So e.g. at 22050 Hz, we request a sample buffer size of 2048.
+	int samples = 8192;
+	while (16 * samples >= _samplesPerSec) {
+		samples >>= 1;
+	}
+
+	memset(&desired, 0, sizeof(desired));
+	desired.freq = _samplesPerSec;
+	desired.format = AUDIO_S16SYS;
+	desired.channels = 2;
+	desired.samples = (uint16)samples;
+	desired.callback = mixCallback;
+	desired.userdata = this;
+
+	// Create the mixer instance
+	assert(!_mixer);
+	_mixer = new Audio::MixerImpl(this);
+	assert(_mixer);
+
+	if (SDL_OpenAudio(&desired, &_obtainedRate) != 0) {
+		warning("Could not open audio device: %s", SDL_GetError());
+		_samplesPerSec = 0;
+		_mixer->setReady(false);
+	} else {
+		// Note: This should be the obtained output rate, but it seems that at
+		// least on some platforms SDL will lie and claim it did get the rate
+		// even if it didn't. Probably only happens for "weird" rates, though.
+		_samplesPerSec = _obtainedRate.freq;
+		debug(1, "Output sample rate: %d Hz", _samplesPerSec);
+
+		// Tell the mixer that we are ready and start the sound processing
+		_mixer->setOutputRate(_samplesPerSec);
+		_mixer->setReady(true);
+
+		// start the sound system
+		SDL_PauseAudio(0);
+	}
+}
+
+void OSystem_SDL_SamsungTV::closeMixer() {
+	if (_mixer)
+		_mixer->setReady(false);
+
+	SDL_CloseAudio();
+
+	delete _mixer;
+	_mixer = 0;
+}
+
+Audio::Mixer *OSystem_SDL_SamsungTV::getMixer() {
+	assert(_mixer);
+	return _mixer;
+}
+
+bool OSystem_SDL_SamsungTV::openCD(int drive) {
+	return false;
+}
+
+void OSystem_SDL_SamsungTV::stopCD() {
+}
+
+void OSystem_SDL_SamsungTV::playCD(int track, int num_loops, int start_frame, int duration) {
+}
+
+bool OSystem_SDL_SamsungTV::pollCD() {
+	return false;
+}
+
+void OSystem_SDL_SamsungTV::updateCD() {
+}
+
+#endif
diff --git a/backends/platform/samsungtv/sdl.h b/backends/platform/samsungtv/sdl.h
new file mode 100644
index 0000000000..3b81bba7f5
--- /dev/null
+++ b/backends/platform/samsungtv/sdl.h
@@ -0,0 +1,436 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/sdl/sdl.h $
+ * $Id: sdl.h 44793 2009-10-08 19:41:38Z fingolfin $
+ *
+ */
+
+#ifndef SDL_COMMON_H
+#define SDL_SAMSUNGTV_COMMON_H
+
+#include <SDL.h>
+
+#include "backends/base-backend.h"
+#include "graphics/scaler.h"
+
+#if defined(SAMSUNGTV)
+
+namespace Audio {
+	class MixerImpl;
+}
+
+#define USE_OSD	1
+
+enum {
+	GFX_NORMAL = 0,
+	GFX_DOUBLESIZE = 1,
+	GFX_TRIPLESIZE = 2,
+	GFX_2XSAI = 3,
+	GFX_SUPER2XSAI = 4,
+	GFX_SUPEREAGLE = 5,
+	GFX_ADVMAME2X = 6,
+	GFX_ADVMAME3X = 7,
+	GFX_HQ2X = 8,
+	GFX_HQ3X = 9,
+	GFX_TV2X = 10,
+	GFX_DOTMATRIX = 11
+};
+
+class AspectRatio {
+	int _kw, _kh;
+public:
+	AspectRatio() { _kw = _kh = 0; }
+	AspectRatio(int w, int h);
+ 
+	bool isAuto() const { return (_kw | _kh) == 0; }
+	
+	int kw() const { return _kw; }
+	int kh() const { return _kh; }
+};
+
+
+class OSystem_SDL_SamsungTV : public BaseBackend {
+public:
+	OSystem_SDL_SamsungTV();
+	virtual ~OSystem_SDL_SamsungTV();
+
+	virtual void initBackend();
+
+	void beginGFXTransaction();
+	TransactionError endGFXTransaction();
+
+#ifdef USE_RGB_COLOR
+	// Game screen
+	virtual Graphics::PixelFormat getScreenFormat() const { return _screenFormat; }
+
+	// Highest supported
+	virtual Common::List<Graphics::PixelFormat> getSupportedFormats();
+#endif
+
+	// Set the size and format of the video bitmap.
+	// Typically, 320x200 CLUT8
+	virtual void initSize(uint w, uint h, const Graphics::PixelFormat *format); // overloaded by CE backend
+
+	virtual int getScreenChangeID() const { return _screenChangeCount; }
+
+	// Set colors of the palette
+	void setPalette(const byte *colors, uint start, uint num);
+
+	// Get colors of the palette
+	void grabPalette(byte *colors, uint start, uint num);
+
+	// Draw a bitmap to screen.
+	// The screen will not be updated to reflect the new bitmap
+	virtual void copyRectToScreen(const byte *src, int pitch, int x, int y, int w, int h); // overloaded by CE backend (FIXME)
+
+	virtual Graphics::Surface *lockScreen();
+	virtual void unlockScreen();
+
+	// Update the dirty areas of the screen
+	void updateScreen();
+
+	// Either show or hide the mouse cursor
+	bool showMouse(bool visible);
+
+	// Warp the mouse cursor. Where set_mouse_pos() only informs the
+	// backend of the mouse cursor's current position, this function
+	// actually moves the cursor to the specified position.
+	virtual void warpMouse(int x, int y); // overloaded by CE backend (FIXME)
+
+	// Set the bitmap that's used when drawing the cursor.
+	virtual void setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, uint32 keycolor, int cursorTargetScale, const Graphics::PixelFormat *format); // overloaded by CE backend (FIXME)
+
+	// Set colors of cursor palette
+	void setCursorPalette(const byte *colors, uint start, uint num);
+
+	// Disables or enables cursor palette
+	void disableCursorPalette(bool disable) {
+		_cursorPaletteDisabled = disable;
+		blitCursor();
+	}
+
+	// Shaking is used in SCUMM. Set current shake position.
+	void setShakePos(int shake_pos);
+
+	// Get the number of milliseconds since the program was started.
+	uint32 getMillis();
+
+	// Delay for a specified amount of milliseconds
+	void delayMillis(uint msecs);
+
+	// Get the next event.
+	// Returns true if an event was retrieved.
+	virtual bool pollEvent(Common::Event &event); // overloaded by CE backend
+
+	// Define all hardware keys for keymapper
+	virtual Common::HardwareKeySet *getHardwareKeySet();
+
+	// Set function that generates samples
+	virtual void setupMixer();
+	static void mixCallback(void *s, byte *samples, int len);
+
+	virtual void closeMixer();
+
+	virtual Audio::Mixer *getMixer();
+
+	// Poll CD status
+	// Returns true if cd audio is playing
+	bool pollCD();
+
+	// Play CD audio track
+	void playCD(int track, int num_loops, int start_frame, int duration);
+
+	// Stop CD audio track
+	void stopCD();
+
+	// Update CD audio status
+	void updateCD();
+
+	// Quit
+	virtual void quit(); // overloaded by CE backend
+
+	virtual void getTimeAndDate(TimeDate &t) const;
+	virtual Common::TimerManager *getTimerManager();
+
+	// Mutex handling
+	MutexRef createMutex();
+	void lockMutex(MutexRef mutex);
+	void unlockMutex(MutexRef mutex);
+	void deleteMutex(MutexRef mutex);
+
+	// Overlay
+	virtual Graphics::PixelFormat getOverlayFormat() const { return _overlayFormat; }
+
+	virtual void showOverlay();
+	virtual void hideOverlay();
+	virtual void clearOverlay();
+	virtual void grabOverlay(OverlayColor *buf, int pitch);
+	virtual void copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h);
+	virtual int16 getHeight();
+	virtual int16 getWidth();
+	virtual int16 getOverlayHeight()  { return _videoMode.overlayHeight; }
+	virtual int16 getOverlayWidth()   { return _videoMode.overlayWidth; }
+
+	virtual const GraphicsMode *getSupportedGraphicsModes() const;
+	virtual int getDefaultGraphicsMode() const;
+	virtual bool setGraphicsMode(int mode);
+	virtual int getGraphicsMode() const;
+
+	virtual void setWindowCaption(const char *caption);
+	virtual bool openCD(int drive);
+
+	virtual bool hasFeature(Feature f);
+	virtual void setFeatureState(Feature f, bool enable);
+	virtual bool getFeatureState(Feature f);
+	virtual void preprocessEvents(SDL_Event *event) {};
+
+#ifdef USE_OSD
+	void displayMessageOnOSD(const char *msg);
+#endif
+
+	virtual Common::SaveFileManager *getSavefileManager();
+	virtual FilesystemFactory *getFilesystemFactory();
+	virtual void addSysArchivesToSearchSet(Common::SearchSet &s, int priority = 0);
+
+	virtual Common::SeekableReadStream *createConfigReadStream();
+	virtual Common::WriteStream *createConfigWriteStream();
+
+protected:
+	bool _inited;
+	SDL_AudioSpec _obtainedRate;
+
+#ifdef USE_OSD
+	SDL_Surface *_osdSurface;
+	Uint8 _osdAlpha;			// Transparency level of the OSD
+	uint32 _osdFadeStartTime;	// When to start the fade out
+	enum {
+		kOSDFadeOutDelay = 2 * 1000,	// Delay before the OSD is faded out (in milliseconds)
+		kOSDFadeOutDuration = 500,		// Duration of the OSD fade out (in milliseconds)
+		kOSDColorKey = 1,
+		kOSDInitialAlpha = 80			// Initial alpha level, in percent
+	};
+#endif
+
+	// hardware screen
+	SDL_Surface *_hwscreen, *_prehwscreen;
+
+	// unseen game screen
+	SDL_Surface *_screen;
+#ifdef USE_RGB_COLOR
+	Graphics::PixelFormat _screenFormat;
+	Graphics::PixelFormat _cursorFormat;
+#endif
+
+	// temporary screen (for scalers)
+	SDL_Surface *_tmpscreen;
+	SDL_Surface *_tmpscreen2;
+
+	// overlay
+	SDL_Surface *_overlayscreen;
+	bool _overlayVisible;
+	Graphics::PixelFormat _overlayFormat;
+
+	// Audio
+	int _samplesPerSec;
+
+	enum {
+		DF_WANT_RECT_OPTIM			= 1 << 0
+	};
+
+	enum {
+		kTransactionNone = 0,
+		kTransactionActive = 1,
+		kTransactionRollback = 2
+	};
+
+	struct TransactionDetails {
+		bool sizeChanged;
+		bool needHotswap;
+		bool needUpdatescreen;
+		bool normal1xScaler;
+#ifdef USE_RGB_COLOR
+		bool formatChanged;
+#endif
+	};
+	TransactionDetails _transactionDetails;
+
+	struct VideoState {
+		bool setup;
+
+		bool fullscreen;
+		bool aspectRatioCorrection;
+		AspectRatio desiredAspectRatio;
+
+		int mode;
+		int scaleFactor;
+
+		int screenWidth, screenHeight;
+		int overlayWidth, overlayHeight;
+		int hardwareWidth, hardwareHeight;
+#ifdef USE_RGB_COLOR
+		Graphics::PixelFormat format;
+#endif
+	};
+	VideoState _videoMode, _oldVideoMode;
+
+	virtual void setGraphicsModeIntern(); // overloaded by CE backend
+
+	/** Force full redraw on next updateScreen */
+	bool _forceFull;
+	ScalerProc *_scalerProc;
+	int _scalerType;
+	int _transactionMode;
+
+	bool _screenIsLocked;
+	Graphics::Surface _framebuffer;
+
+	/** Current video mode flags (see DF_* constants) */
+	uint32 _modeFlags;
+	bool _modeChanged;
+	int _screenChangeCount;
+
+	enum {
+		NUM_DIRTY_RECT = 100,
+		MAX_SCALING = 3
+	};
+
+	// Dirty rect management
+	SDL_Rect _dirtyRectList[NUM_DIRTY_RECT];
+	int _numDirtyRects;
+	uint32 *_dirtyChecksums;
+	bool _cksumValid;
+	int _cksumNum;
+
+	// Keyboard mouse emulation.  Disabled by fingolfin 2004-12-18.
+	// I am keeping the rest of the code in for now, since the joystick
+	// code (or rather, "hack") uses it, too.
+	struct KbdMouse {
+		int16 x, y, x_vel, y_vel, x_max, y_max, x_down_count, y_down_count;
+		uint32 last_time, delay_time, x_down_time, y_down_time;
+	};
+
+	struct MousePos {
+		// The mouse position, using either virtual (game) or real
+		// (overlay) coordinates.
+		int16 x, y;
+
+		// The size and hotspot of the original cursor image.
+		int16 w, h;
+		int16 hotX, hotY;
+
+		// The size and hotspot of the pre-scaled cursor image, in real
+		// coordinates.
+		int16 rW, rH;
+		int16 rHotX, rHotY;
+
+		// The size and hotspot of the pre-scaled cursor image, in game
+		// coordinates.
+		int16 vW, vH;
+		int16 vHotX, vHotY;
+
+		MousePos() : x(0), y(0), w(0), h(0), hotX(0), hotY(0),
+		             rW(0), rH(0), rHotX(0), rHotY(0), vW(0), vH(0),
+		             vHotX(0), vHotY(0)
+			{ }
+	};
+
+	// mouse
+	KbdMouse _km;
+	bool _mouseVisible;
+	bool _mouseNeedsRedraw;
+	byte *_mouseData;
+	SDL_Rect _mouseBackup;
+	MousePos _mouseCurState;
+	byte _mouseKeyColor;
+	int _cursorTargetScale;
+	bool _cursorPaletteDisabled;
+	SDL_Surface *_mouseOrigSurface;
+	SDL_Surface *_mouseSurface;
+	enum {
+		kMouseColorKey = 1
+	};
+
+	// Shake mode
+	int _currentShakePos;
+	int _newShakePos;
+
+	// Palette data
+	SDL_Color *_currentPalette;
+	uint _paletteDirtyStart, _paletteDirtyEnd;
+
+	// Cursor palette data
+	SDL_Color *_cursorPalette;
+
+	/**
+	 * Mutex which prevents multiple threads from interfering with each other
+	 * when accessing the screen.
+	 */
+	MutexRef _graphicsMutex;
+
+	FilesystemFactory *_fsFactory;
+	Common::SaveFileManager *_savefile;
+	Audio::MixerImpl *_mixer;
+
+	SDL_TimerID _timerID;
+	Common::TimerManager *_timer;
+
+protected:
+	void addDirtyRgnAuto(const byte *buf);
+	void makeChecksums(const byte *buf);
+
+	virtual void addDirtyRect(int x, int y, int w, int h, bool realCoordinates = false); // overloaded by CE backend
+
+	virtual void drawMouse(); // overloaded by CE backend
+	virtual void undrawMouse(); // overloaded by CE backend (FIXME)
+	virtual void blitCursor(); // overloaded by CE backend (FIXME)
+
+	/** Set the position of the virtual mouse cursor. */
+	void setMousePos(int x, int y);
+	virtual void fillMouseEvent(Common::Event &event, int x, int y); // overloaded by CE backend
+	void toggleMouseGrab();
+
+	virtual void internUpdateScreen(); // overloaded by CE backend
+
+	virtual bool loadGFXMode(); // overloaded by CE backend
+	virtual void unloadGFXMode(); // overloaded by CE backend
+	virtual bool hotswapGFXMode(); // overloaded by CE backend
+
+	void setFullscreenMode(bool enable);
+	void setAspectRatioCorrection(bool enable);
+
+	virtual bool saveScreenshot(const char *filename); // overloaded by CE backend
+
+	int effectiveScreenHeight() const {
+		return (_videoMode.aspectRatioCorrection ? real2Aspect(_videoMode.screenHeight) : _videoMode.screenHeight)
+			* _videoMode.scaleFactor;
+	}
+
+	void setupIcon();
+	void handleKbdMouse();
+
+	virtual bool remapKey(SDL_Event &ev, Common::Event &event);
+
+	void handleScalerHotkeys(const SDL_KeyboardEvent &key);
+};
+
+#endif
+
+#endif