Add Mohawk engine code. Part 1/3: main code.

svn-id: r46727

55 files changed, 26721 insertions, 0 deletions

diff --git a/engines/mohawk/bitmap.cpp b/engines/mohawk/bitmap.cpp
new file mode 100644
index 0000000000..6d4ab84930
--- /dev/null
+++ b/engines/mohawk/bitmap.cpp
@@ -0,0 +1,706 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "mohawk/bitmap.h"
+
+#include "common/debug.h"
+#include "common/util.h"
+#include "common/endian.h"
+#include "common/system.h"
+
+namespace Mohawk {
+
+#define PACK_COMPRESSION (_header.format & kPackMASK)
+#define DRAW_COMPRESSION (_header.format & kDrawMASK)
+	
+MohawkBitmap::MohawkBitmap() {
+}
+	
+MohawkBitmap::~MohawkBitmap() {
+}
+
+ImageData *MohawkBitmap::decodeImage(Common::SeekableReadStream *stream) {
+	_data = stream;
+	_header.colorTable.palette = NULL;
+	
+	// NOTE: Only the bottom 12 bits of width/height/bytesPerRow are
+	// considered valid and bytesPerRow has to be an even number.
+	_header.width = _data->readUint16BE() & 0x3FFF;
+	_header.height = _data->readUint16BE() & 0x3FFF;
+	_header.bytesPerRow = _data->readSint16BE() & 0x3FFE;
+	_header.format = _data->readUint16BE();
+
+	debug (2, "Decoding Mohawk Bitmap (%dx%d, %dbpp, %s Packing + %s Drawing)", _header.width, _header.height, getBitsPerPixel(), getPackName(), getDrawName());
+
+	if (getBitsPerPixel() != 8)
+		error ("Unhandled bpp %d", getBitsPerPixel());
+	
+	// Read in the palette if it's here.
+	if (_header.format & kBitmapHasCLUT || (PACK_COMPRESSION == kPackRiven && getBitsPerPixel() == 8)) {
+		_header.colorTable.tableSize = _data->readUint16BE();
+		_header.colorTable.rgbBits = _data->readByte();
+		_header.colorTable.colorCount = _data->readByte();
+		_header.colorTable.palette = (byte *)malloc(256 * 4);
+
+		for (uint16 i = 0; i < 256; i++) {
+			_header.colorTable.palette[i * 4 + 2] = _data->readByte();
+			_header.colorTable.palette[i * 4 + 1] = _data->readByte();
+			_header.colorTable.palette[i * 4] = _data->readByte();
+			_header.colorTable.palette[i * 4 + 3] = 0;
+		}
+	}
+
+	_surface = new Graphics::Surface();
+	_surface->create(_header.width, _header.height, getBitsPerPixel() >> 3);
+	
+	unpackImage();
+	drawImage();
+	delete _data;
+
+	return new ImageData(_surface, _header.colorTable.palette);
+}
+
+byte MohawkBitmap::getBitsPerPixel() {
+	switch (_header.format & kBitsPerPixelMask) {
+		case kBitsPerPixel1:
+			return 1;
+		case kBitsPerPixel4:
+			return 4;
+		case kBitsPerPixel8:
+			return 8;
+		case kBitsPerPixel16:
+			return 16;
+		case kBitsPerPixel24:
+			return 24;
+		default:
+			error ("Unknown bits per pixel");
+	}
+	
+	return 0;
+}
+
+struct CompressionInfo {
+	uint16 flag;
+	const char *name;
+	void (MohawkBitmap::*func)();
+};
+
+static const CompressionInfo packTable[] = {
+	{ kPackNone, "Raw", &MohawkBitmap::unpackRaw },
+	{ kPackLZ, "LZ", &MohawkBitmap::unpackLZ },
+	{ kPackLZ1, "LZ1", &MohawkBitmap::unpackLZ1 },
+	{ kPackRiven, "Riven", &MohawkBitmap::unpackRiven }
+};
+	
+const char *MohawkBitmap::getPackName() {
+	for (uint32 i = 0; i < ARRAYSIZE(packTable); i++)
+		if (PACK_COMPRESSION == packTable[i].flag)
+			return packTable[i].name;
+			
+	return "Unknown";
+}
+
+void MohawkBitmap::unpackImage() {
+	for (uint32 i = 0; i < ARRAYSIZE(packTable); i++)
+		if (PACK_COMPRESSION == packTable[i].flag) {
+			(this->*packTable[i].func)();
+			return;
+		}
+		
+	warning("Unknown Pack Compression");
+}
+
+static const CompressionInfo drawTable[] = {
+	{ kDrawRaw, "Raw", &MohawkBitmap::drawRaw },
+	{ kDrawRLE8, "RLE8", &MohawkBitmap::drawRLE8 },
+	{ kDrawRLE, "RLE", &MohawkBitmap::drawRLE }
+};
+
+const char *MohawkBitmap::getDrawName() {
+	for (uint32 i = 0; i < ARRAYSIZE(drawTable); i++)
+		if (DRAW_COMPRESSION == drawTable[i].flag)
+			return drawTable[i].name;
+			
+	return "Unknown";
+}
+
+void MohawkBitmap::drawImage() {
+	for (uint32 i = 0; i < ARRAYSIZE(drawTable); i++)
+		if (DRAW_COMPRESSION == drawTable[i].flag) {
+			(this->*drawTable[i].func)();
+			return;
+		}
+		
+	warning("Unknown Draw Compression");
+}
+
+//////////////////////////////////////////
+// Raw "Unpacker"
+//////////////////////////////////////////
+
+void MohawkBitmap::unpackRaw() {
+	// Do nothing :D
+}
+
+//////////////////////////////////////////
+// LZ Unpacker
+//////////////////////////////////////////
+
+#define LEN_BITS		6
+#define MIN_STRING		3									// lower limit for string length
+#define POS_BITS		(16 - LEN_BITS)
+#define MAX_STRING		((1 << LEN_BITS) + MIN_STRING - 1)	// upper limit for string length
+#define CBUFFERSIZE		(1 << POS_BITS)						// size of the circular buffer
+#define POS_MASK		(CBUFFERSIZE - 1)
+
+Common::SeekableReadStream *MohawkBitmap::decompressLZ(Common::SeekableReadStream *stream, uint32 uncompressedSize) {
+	uint16 flags = 0;
+	uint32 bytesOut = 0;
+	uint16 insertPos = 0;
+
+	// Expand the output buffer to at least the ring buffer size
+	uint32 outBufSize = MAX<int>(uncompressedSize, CBUFFERSIZE);
+
+	byte *outputData = (byte *)malloc(outBufSize);
+	byte *dst = outputData;
+	byte *buf = dst;
+
+	// Clear the buffer to all 0's
+	memset(outputData, 0, outBufSize);
+
+	while (stream->pos() < stream->size()) {
+		flags >>= 1;
+
+		if (!(flags & 0x100))
+			flags = stream->readByte() | 0xff00;
+
+		if (flags & 1) {
+			if (++bytesOut > uncompressedSize)
+				break;
+			*dst++ = stream->readByte();
+			if (++insertPos > POS_MASK) {
+				insertPos = 0;
+				buf += CBUFFERSIZE;
+			}
+		} else {
+			uint16 offLen = stream->readUint16BE();
+			uint16 stringLen = (offLen >> POS_BITS) + MIN_STRING;
+			uint16 stringPos = (offLen + MAX_STRING) & POS_MASK;
+
+			bytesOut += stringLen;
+			if (bytesOut > uncompressedSize)
+				stringLen -= bytesOut - uncompressedSize;
+
+			byte *strPtr = buf + stringPos;
+			if (stringPos > insertPos) {
+				if (bytesOut >= CBUFFERSIZE)
+					strPtr -= CBUFFERSIZE;
+				else if (stringPos + stringLen > POS_MASK) {
+					for (uint16 k = 0; k < stringLen; k++) {
+						*dst++ = *strPtr++;
+						if (++stringPos > POS_MASK) {
+							stringPos = 0;
+							strPtr = outputData;
+						}
+					}
+					insertPos = (insertPos + stringLen) & POS_MASK;
+					if (bytesOut >= uncompressedSize)
+						break;
+					continue;
+				}
+			}
+
+			insertPos += stringLen;
+
+			if (insertPos > POS_MASK) {
+				insertPos &= POS_MASK;
+				buf += CBUFFERSIZE;
+			}
+
+			for (uint16 k = 0; k < stringLen; k++)
+				*dst++ = *strPtr++;
+
+			if (bytesOut >= uncompressedSize)
+				break;
+		}
+	}
+
+	return new Common::MemoryReadStream(outputData, uncompressedSize, Common::DisposeAfterUse::YES);
+}
+
+void MohawkBitmap::unpackLZ() {
+	uint32 uncompressedSize = _data->readUint32BE();
+	/* uint32 compressedSize = */ _data->readUint32BE();
+	uint16 dictSize = _data->readUint16BE();
+	
+	// We only support the buffer size of 0x400
+	if (dictSize != CBUFFERSIZE)
+		error("Unsupported dictionary size of %04x", dictSize);
+	
+	// Now go and decompress the data
+	Common::SeekableReadStream *decompressedData = decompressLZ(_data, uncompressedSize);
+	delete _data;
+	_data = decompressedData;
+}
+
+//////////////////////////////////////////
+// LZ Unpacker
+//////////////////////////////////////////
+
+void MohawkBitmap::unpackLZ1() {
+	error("STUB: unpackLZ1()");
+}
+
+//////////////////////////////////////////
+// Riven Unpacker
+//////////////////////////////////////////
+
+void MohawkBitmap::unpackRiven() {
+	_data->readUint32BE(); // Unknown, the number is close to bytesPerRow * height. Could be bufSize. 
+	
+	byte *uncompressedData = (byte *)malloc(_header.bytesPerRow * _header.height);
+	byte *dst = uncompressedData;
+
+	while (!_data->eos() && dst < (uncompressedData + _header.bytesPerRow * _header.height)) {
+		byte cmd = _data->readByte();
+		debug (8, "Riven Pack Command %02x", cmd);
+
+		if (cmd == 0x00) {                       // End of stream
+			break;
+		} else if (cmd >= 0x01 && cmd <= 0x3f) { // Simple Pixel Duplet Output
+			for (byte i = 0; i < cmd; i++) {
+				*dst++ = _data->readByte();
+				*dst++ = _data->readByte();
+			}
+		} else if (cmd >= 0x40 && cmd <= 0x7f) { // Simple Repetition of last 2 pixels (cmd - 0x40) times
+			byte pixel[] = { *(dst - 2), *(dst - 1) };
+
+			for (byte i = 0; i < (cmd - 0x40); i++) {
+				*dst++ = pixel[0];
+				*dst++ = pixel[1];
+			}
+		} else if (cmd >= 0x80 && cmd <= 0xbf) { // Simple Repetition of last 4 pixels (cmd - 0x80) times
+			byte pixel[] = { *(dst - 4), *(dst - 3), *(dst - 2), *(dst - 1) };
+
+			for (byte i = 0; i < (cmd - 0x80); i++) {
+				*dst++ = pixel[0];
+				*dst++ = pixel[1];
+				*dst++ = pixel[2];
+				*dst++ = pixel[3];
+			}
+		} else {                                 // Subcommand Stream of (cmd - 0xc0) subcommands
+			handleRivenSubcommandStream(cmd - 0xc0, dst);
+		}
+	}
+
+	delete _data;
+	_data = new Common::MemoryReadStream(uncompressedData, _header.bytesPerRow * _header.height, Common::DisposeAfterUse::YES);
+}
+
+static byte getLastTwoBits(byte c) {
+	return (c & 0x03);
+}
+        
+static byte getLastThreeBits(byte c) {
+	return (c & 0x07);
+}
+
+static byte getLastFourBits(byte c) {
+	return (c & 0x0f);
+}
+
+#define B_BYTE()				\
+	*dst = _data->readByte();	\
+	dst++
+
+#define B_LASTDUPLET()			\
+	*dst = *(dst - 2);			\
+	dst++
+
+#define B_LASTDUPLET_PLUS_M()	\
+	*dst = *(dst - 2) + m;		\
+	dst++
+
+#define B_LASTDUPLET_MINUS_M()	\
+	*dst = *(dst - 2) - m;		\
+	dst++
+
+#define B_LASTDUPLET_PLUS(m)	\
+	*dst = *(dst - 2) + (m);	\
+	dst++
+
+#define B_LASTDUPLET_MINUS(m)	\
+	*dst = *(dst - 2) - (m);	\
+	dst++
+
+#define B_PIXEL_MINUS(m)		\
+	*dst = *(dst - (m));		\
+	dst++
+
+#define B_NDUPLETS(n)													\
+	uint16 m1 = ((getLastTwoBits(cmd) << 8) + _data->readByte());		\
+		for (uint16 j = 0; j < (n); j++) {								\
+			*dst = *(dst - m1);											\
+			dst++;														\
+		}																\
+		void dummyFuncToAllowTrailingSemicolon()
+
+
+
+void MohawkBitmap::handleRivenSubcommandStream(byte count, byte *&dst) {
+	for (byte i = 0; i < count; i++) {
+		byte cmd = _data->readByte();
+		uint16 m = getLastFourBits(cmd);
+		debug (9, "Riven Pack Subcommand %02x", cmd);
+
+		// Notes: p = value of the next byte, m = last four bits of the command
+
+		// Arithmetic operations
+		if (cmd >= 0x01 && cmd <= 0x0f) {
+			// Repeat duplet at relative position of -m duplets
+			B_PIXEL_MINUS(m * 2);
+			B_PIXEL_MINUS(m * 2);
+		} else if (cmd == 0x10) {
+			// Repeat last duplet, but set the value of the second pixel to p
+			B_LASTDUPLET();
+			B_BYTE();
+		} else if (cmd >= 0x11 && cmd <= 0x1f) {
+			// Repeat last duplet, but set the value of the second pixel to the value of the -m pixel
+			B_LASTDUPLET();
+			B_PIXEL_MINUS(m);
+		} else if (cmd >= 0x20 && cmd <= 0x2f) {
+			// Repeat last duplet, but add x to second pixel
+			B_LASTDUPLET();
+			B_LASTDUPLET_PLUS_M();
+		} else if (cmd >= 0x30 && cmd <= 0x3f) {
+			// Repeat last duplet, but subtract x from second pixel
+			B_LASTDUPLET();
+			B_LASTDUPLET_MINUS_M();
+		} else if (cmd == 0x40) {
+			// Repeat last duplet, but set the value of the first pixel to p
+			B_BYTE();
+			B_LASTDUPLET();
+		} else if (cmd >= 0x41 && cmd <= 0x4f) {
+			// Output pixel at relative position -m, then second pixel of last duplet
+			B_PIXEL_MINUS(m);
+			B_LASTDUPLET();
+		} else if (cmd == 0x50) {
+			// Output two absolute pixel values, p1 and p2
+			B_BYTE();           
+			B_BYTE();
+		} else if (cmd >= 0x51 && cmd <= 0x57) {
+			// Output pixel at relative position -m, then absolute pixel value p
+			// m is the last 3 bits of cmd here, not last 4
+			B_PIXEL_MINUS(getLastThreeBits(cmd));
+			B_BYTE();
+		} else if (cmd >= 0x59 && cmd <= 0x5f) {
+			// Output absolute pixel value p, then pixel at relative position -m
+			// m is the last 3 bits of cmd here, not last 4
+			B_BYTE();
+			B_PIXEL_MINUS(getLastThreeBits(cmd));
+		} else if (cmd >= 0x60 && cmd <= 0x6f) {
+			// Output absolute pixel value p, then (second pixel of last duplet) + x
+			B_BYTE();
+			B_LASTDUPLET_PLUS_M();
+		} else if (cmd >= 0x70 && cmd <= 0x7f) {
+			// Output absolute pixel value p, then (second pixel of last duplet) - x
+			B_BYTE();
+			B_LASTDUPLET_MINUS_M();
+		} else if (cmd >= 0x80 && cmd <= 0x8f) {
+			// Repeat last duplet adding x to the first pixel
+			B_LASTDUPLET_PLUS_M();
+			B_LASTDUPLET();
+		} else if (cmd >= 0x90 && cmd <= 0x9f) {
+			// Output (first pixel of last duplet) + x, then absolute pixel value p
+			B_LASTDUPLET_PLUS_M();
+			B_BYTE();
+		} else if (cmd == 0xa0) {
+			// Repeat last duplet, adding first 4 bits of the next byte
+			// to first pixel and last 4 bits to second
+			byte pattern = _data->readByte();
+			B_LASTDUPLET_PLUS(pattern >> 4);
+			B_LASTDUPLET_PLUS(getLastFourBits(pattern));
+		} else if (cmd == 0xb0) {
+			// Repeat last duplet, adding first 4 bits of the next byte
+			// to first pixel and subtracting last 4 bits from second
+			byte pattern = _data->readByte();
+			B_LASTDUPLET_PLUS(pattern >> 4);
+			B_LASTDUPLET_MINUS(getLastFourBits(pattern));
+		} else if (cmd >= 0xc0 && cmd <= 0xcf) {
+			// Repeat last duplet subtracting x from first pixel
+			B_LASTDUPLET_MINUS_M();
+			B_LASTDUPLET();
+		} else if (cmd >= 0xd0 && cmd <= 0xdf) {
+			// Output (first pixel of last duplet) - x, then absolute pixel value p
+			B_LASTDUPLET_MINUS_M();
+			B_BYTE();
+		} else if (cmd == 0xe0) {
+			// Repeat last duplet, subtracting first 4 bits of the next byte
+			// to first pixel and adding last 4 bits to second
+			byte pattern = _data->readByte();
+			B_LASTDUPLET_MINUS(pattern >> 4);
+			B_LASTDUPLET_PLUS(getLastFourBits(pattern));
+		} else if (cmd == 0xf0 || cmd == 0xff) {
+			// Repeat last duplet, subtracting first 4 bits from the next byte
+			// to first pixel and last 4 bits from second
+			byte pattern = _data->readByte();
+			B_LASTDUPLET_MINUS(pattern >> 4);
+			B_LASTDUPLET_MINUS(getLastFourBits(pattern));
+		
+		// Repeat operations
+		// Repeat n duplets from relative position -m (given in pixels, not duplets). 
+		// If r is 0, another byte follows and the last pixel is set to that value
+		} else if (cmd >= 0xa4 && cmd <= 0xa7) {
+			B_NDUPLETS(3);
+			B_BYTE();
+		} else if (cmd >= 0xa8 && cmd <= 0xab) {
+			B_NDUPLETS(4);
+		} else if (cmd >= 0xac && cmd <= 0xaf) {
+			B_NDUPLETS(5);
+			B_BYTE();
+		} else if (cmd >= 0xb4 && cmd <= 0xb7) {
+			B_NDUPLETS(6);
+		} else if (cmd >= 0xb8 && cmd <= 0xbb) {
+			B_NDUPLETS(7);
+			B_BYTE();
+		} else if (cmd >= 0xbc && cmd <= 0xbf) {
+			B_NDUPLETS(8);
+		} else if (cmd >= 0xe4 && cmd <= 0xe7) {
+			B_NDUPLETS(9);
+			B_BYTE();
+		} else if (cmd >= 0xe8 && cmd <= 0xeb) {
+			B_NDUPLETS(10); // 5 duplets
+		} else if (cmd >= 0xec && cmd <= 0xef) {
+			B_NDUPLETS(11);
+			B_BYTE();
+		} else if (cmd >= 0xf4 && cmd <= 0xf7) {
+			B_NDUPLETS(12);
+		} else if (cmd >= 0xf8 && cmd <= 0xfb) {
+			B_NDUPLETS(13);
+			B_BYTE();
+		} else if (cmd == 0xfc) {
+			byte b1 = _data->readByte();
+			byte b2 = _data->readByte();
+			uint16 m1 = ((getLastTwoBits(b1) << 8) + b2);
+
+			for (uint16 j = 0; j < ((b1 >> 3) + 1); j++) { // one less iteration
+				B_PIXEL_MINUS(m1);
+				B_PIXEL_MINUS(m1);
+			}
+
+			// last iteration
+			B_PIXEL_MINUS(m1);
+
+			if ((b1 & (1 << 2)) == 0) {
+				B_BYTE();
+			} else {
+				B_PIXEL_MINUS(m1);
+			}
+		} else
+			warning("Unknown Riven Pack Subcommand 0x%02x", cmd);
+	}
+}
+
+//////////////////////////////////////////
+// Raw Drawer
+//////////////////////////////////////////
+
+void MohawkBitmap::drawRaw() {
+	for (uint16 y = 0; y < _header.height; y++) {
+		_data->read((byte *)_surface->pixels + y * _header.width, _header.width);
+		_data->skip(_header.bytesPerRow - _header.width);
+	}
+}
+
+//////////////////////////////////////////
+// RLE8 Drawer
+//////////////////////////////////////////
+
+void MohawkBitmap::drawRLE8() {
+	// A very simple RLE8 scheme is used as a secondary compression on
+	// most images in non-Riven tBMP's.
+	
+	for (uint16 i = 0; i < _header.height; i++) {
+		uint16 rowByteCount = _data->readUint16BE();
+		int32 startPos = _data->pos();
+		byte *dst = (byte *)_surface->pixels + i * _header.width;
+		int16 remaining = _header.width;
+		
+		// HACK: It seems only the bottom 9 bits are valid for images
+		// TODO: Verify if this is still needed after the buffer clearing fix.
+		rowByteCount &= 0x1ff;
+		
+		while (remaining > 0) {
+			byte code = _data->readByte();
+			uint16 runLen = (code & 0x7F) + 1;
+			
+			if (runLen > remaining)
+				runLen = remaining;
+				
+			if (code & 0x80) {
+				byte val = _data->readByte();
+				for (uint16 j = 0; j < runLen; j++)
+					*dst++ = val;
+			} else {
+				for (uint16 j = 0; j < runLen; j++)
+					*dst++ = _data->readByte();
+			}
+			
+			remaining -= runLen;
+		}
+		
+		_data->seek(startPos + rowByteCount);
+	}
+}
+
+//////////////////////////////////////////
+// RLE Drawer
+//////////////////////////////////////////
+
+void MohawkBitmap::drawRLE() {
+	warning("STUB: drawRLE()");
+}
+
+//////////////////////////////////////////
+// Myst Bitmap Decoder
+//////////////////////////////////////////
+
+ImageData* MystBitmap::decodeImage(Common::SeekableReadStream* stream) {
+	uint32 uncompressedSize = stream->readUint32LE();
+	Common::SeekableReadStream* bmpStream = decompressLZ(stream, uncompressedSize);
+	delete stream;
+	
+	_header.type = bmpStream->readUint16BE();
+
+	if (_header.type != 'BM')
+		error("BMP header not detected");
+
+	_header.size = bmpStream->readUint32LE();
+	assert (_header.size > 0);
+	_header.res1 = bmpStream->readUint16LE();
+	_header.res2 = bmpStream->readUint16LE();
+	_header.imageOffset = bmpStream->readUint32LE();
+	
+	_info.size = bmpStream->readUint32LE();
+
+	if (_info.size != 40)
+		error("Only Windows v3 BMP's are supported");
+
+	_info.width = bmpStream->readUint32LE();
+	_info.height = bmpStream->readUint32LE();
+	_info.planes = bmpStream->readUint16LE();
+	_info.bitsPerPixel = bmpStream->readUint16LE();
+	_info.compression = bmpStream->readUint32LE();
+	_info.imageSize = bmpStream->readUint32LE();
+	_info.pixelsPerMeterX = bmpStream->readUint32LE();
+	_info.pixelsPerMeterY = bmpStream->readUint32LE();
+	_info.colorsUsed = bmpStream->readUint32LE();
+	_info.colorsImportant = bmpStream->readUint32LE();
+	
+	if (_info.compression != 0)
+		error("Unhandled BMP compression %d", _info.compression);
+	
+	if (_info.colorsUsed == 0)
+		_info.colorsUsed = 256;
+		
+	// TODO: Myst ME's Help.dat contains WDIB's with 24bpp color.
+	if (_info.bitsPerPixel != 8 && _info.bitsPerPixel != 24)
+		error("%dbpp Bitmaps not supported", _info.bitsPerPixel);
+		
+	byte *palData = NULL;
+	
+	if (_info.bitsPerPixel == 8) {
+		palData = (byte *)malloc(256 * 4);
+		for (uint16 i = 0; i < _info.colorsUsed; i++) {			
+			palData[i * 4 + 2] = bmpStream->readByte();
+			palData[i * 4 + 1] = bmpStream->readByte();
+			palData[i * 4] = bmpStream->readByte();			
+			palData[i * 4 + 3] = bmpStream->readByte();
+		}
+	}
+	
+	bmpStream->seek(_header.imageOffset);
+	
+	Graphics::Surface *surface = new Graphics::Surface();
+	int srcPitch = _info.width * (_info.bitsPerPixel >> 3);
+	const int extraDataLength = (srcPitch % 4) ? 4 - (srcPitch % 4) : 0;
+	
+	if (_info.bitsPerPixel == 8) {
+		surface->create(_info.width, _info.height, 1);
+		byte *dst = (byte *)surface->pixels;
+
+		for (uint32 i = 0; i < _info.height; i++) {
+			bmpStream->read(dst + (_info.height - i - 1) * _info.width, _info.width);
+			bmpStream->skip(extraDataLength);
+		}
+	} else {
+		Graphics::PixelFormat pixelFormat = g_system->getScreenFormat();
+		surface->create(_info.width, _info.height, pixelFormat.bytesPerPixel);
+		
+		byte *dst = (byte *)surface->pixels + (surface->h - 1) * surface->pitch;
+		
+		for (uint32 i = 0; i < _info.height; i++) {
+			for (uint32 j = 0; j < _info.width; j++) {
+				byte b = bmpStream->readByte();
+				byte g = bmpStream->readByte();
+				byte r = bmpStream->readByte();
+				
+				if (pixelFormat.bytesPerPixel == 2)
+					*((uint16 *)dst) = pixelFormat.RGBToColor(r, g, b);
+				else 
+					*((uint32 *)dst) = pixelFormat.RGBToColor(r, g, b);
+				
+				dst += pixelFormat.bytesPerPixel;
+			}
+			
+			bmpStream->skip(extraDataLength);
+			dst -= surface->pitch * 2;
+		}
+	}
+		
+	delete bmpStream;
+	
+	return new ImageData(surface, palData);
+}
+
+ImageData *OldMohawkBitmap::decodeImage(Common::SeekableReadStream *stream) {
+	Common::SeekableSubReadStreamEndian *endianStream = (Common::SeekableSubReadStreamEndian *)stream;
+
+	// The format part is just a guess at this point. Note that the width and height roles have been reversed!
+
+	_header.height = endianStream->readUint16() & 0x3FF;
+	_header.width = endianStream->readUint16() & 0x3FF;
+	_header.bytesPerRow = endianStream->readUint16() & 0x3FE;
+	_header.format = endianStream->readUint16();
+
+	debug(2, "Decoding Old Mohawk Bitmap (%dx%d, %04x Format)", _header.width, _header.height, _header.format);
+	
+	warning("Unhandled old Mohawk Bitmap decoding");
+
+	delete stream;
+	return new ImageData(NULL, NULL);
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/bitmap.h b/engines/mohawk/bitmap.h
new file mode 100644
index 0000000000..18c51bc478
--- /dev/null
+++ b/engines/mohawk/bitmap.h
@@ -0,0 +1,159 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#ifndef MOHAWK_BITMAP_H
+#define MOHAWK_BITMAP_H
+
+#include "mohawk/graphics.h"
+
+#include "common/scummsys.h"
+#include "common/stream.h"
+#include "graphics/surface.h"
+
+namespace Mohawk {
+
+class ImageData;
+
+enum BitmapFormat {
+	kBitsPerPixel1 = 0x0000,
+	kBitsPerPixel4 = 0x0001,
+	kBitsPerPixel8 = 0x0002,
+	kBitsPerPixel16 = 0x0003,
+	kBitsPerPixel24 = 0x0004,
+	kBitsPerPixelMask = 0x0007,
+	kBitmapHasCLUT = 0x0008,
+	kDrawMASK = 0x00f0,
+	kDrawRaw = 0x0000,
+	kDrawRLE8 = 0x0010,
+	kDrawMSRLE8 = 0x0020,
+	kDrawRLE = 0x0030,
+	kPackMASK = 0x0f00,
+	kPackNone = 0x0000,
+	kPackLZ = 0x0100,
+	kPackLZ1 = 0x0200,
+	kPackRiven = 0x0400,
+	kPackXDec = 0x0f00,
+	kFlagMASK = 0xf000,
+	kFlag16_80X86 = 0x1000, // 16 bit pixel data has been converted to 80X86 format
+	kFlag24_MAC = 0x1000 // 24 bit pixel data has been converted to MAC 32 bit format
+};
+
+struct BitmapHeader {
+	uint16 width;
+	uint16 height;
+	int16 bytesPerRow;
+	uint16 format;
+
+	struct ColorTable {
+		uint16 tableSize;
+		byte rgbBits;
+		byte colorCount;
+		byte* palette;   // In 8bpp only
+	} colorTable;
+};
+
+class MohawkBitmap {
+public:
+	MohawkBitmap();
+	virtual ~MohawkBitmap();
+
+	virtual ImageData *decodeImage(Common::SeekableReadStream *stream);
+
+	// Unpack Functions
+	void unpackRaw();
+	void unpackLZ();
+	void unpackLZ1();
+	void unpackRiven();
+
+	// Draw Functions
+	void drawRaw();
+	void drawRLE8();
+	void drawRLE();
+	
+protected:
+	BitmapHeader _header;
+	byte getBitsPerPixel();
+
+	// The actual LZ decoder
+	static Common::SeekableReadStream *decompressLZ(Common::SeekableReadStream *stream, uint32 uncompressedSize);
+
+private:
+	Common::SeekableReadStream *_data;
+	Graphics::Surface *_surface;
+
+	const char *getPackName();
+	void unpackImage();
+	const char *getDrawName();
+	void drawImage();
+
+	// Riven Decoding
+	void handleRivenSubcommandStream(byte count, byte *&dst);
+};
+
+// Myst uses a different image format than that of other Mohawk games.
+// It essentially uses a Windows bitmap with the LZ encoding from the
+// Mohawk Bitmap format.
+class MystBitmap : public MohawkBitmap {
+public:
+	MystBitmap() : MohawkBitmap() {}
+	~MystBitmap() {}
+
+	ImageData *decodeImage(Common::SeekableReadStream *stream);
+
+private:	
+	struct BitmapHeader {
+		uint16 type;
+		uint32 size;
+		uint16 res1;
+		uint16 res2;
+		uint32 imageOffset;
+	} _header;
+
+	struct InfoHeader {
+		uint32 size;
+		uint32 width;
+		uint32 height;
+		uint16 planes;
+		uint16 bitsPerPixel;
+		uint32 compression;
+		uint32 imageSize;
+		uint32 pixelsPerMeterX;
+		uint32 pixelsPerMeterY;
+		uint32 colorsUsed;
+		uint32 colorsImportant;
+	} _info;
+};
+
+class OldMohawkBitmap : public MohawkBitmap {
+public:
+	OldMohawkBitmap() : MohawkBitmap() {}
+	~OldMohawkBitmap() {}
+
+	ImageData *decodeImage(Common::SeekableReadStream *stream);
+};
+
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/console.cpp b/engines/mohawk/console.cpp
new file mode 100644
index 0000000000..f2020a5144
--- /dev/null
+++ b/engines/mohawk/console.cpp
@@ -0,0 +1,641 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "mohawk/console.h"
+#include "mohawk/myst.h"
+#include "mohawk/myst_scripts.h"
+#include "mohawk/graphics.h"
+#include "mohawk/riven.h"
+#include "mohawk/livingbooks.h"
+
+namespace Mohawk {
+
+MystConsole::MystConsole(MohawkEngine_Myst *vm) : GUI::Debugger(), _vm(vm) {
+	DCmd_Register("changeCard",			WRAP_METHOD(MystConsole, Cmd_ChangeCard));
+	DCmd_Register("curCard",			WRAP_METHOD(MystConsole, Cmd_CurCard));
+	DCmd_Register("var",				WRAP_METHOD(MystConsole, Cmd_Var));
+	DCmd_Register("curStack",			WRAP_METHOD(MystConsole, Cmd_CurStack));
+	DCmd_Register("changeStack",		WRAP_METHOD(MystConsole, Cmd_ChangeStack));
+	DCmd_Register("drawImage",			WRAP_METHOD(MystConsole, Cmd_DrawImage));
+	DCmd_Register("drawRect",			WRAP_METHOD(MystConsole, Cmd_DrawRect));
+	DCmd_Register("setResourceEnable",	WRAP_METHOD(MystConsole, Cmd_SetResourceEnable));
+	DCmd_Register("playSound",			WRAP_METHOD(MystConsole, Cmd_PlaySound));
+	DCmd_Register("stopSound",			WRAP_METHOD(MystConsole, Cmd_StopSound));
+	DCmd_Register("playMovie",			WRAP_METHOD(MystConsole, Cmd_PlayMovie));
+	DCmd_Register("disableInitOpcodes",	WRAP_METHOD(MystConsole, Cmd_DisableInitOpcodes));
+}
+
+MystConsole::~MystConsole() {
+}
+
+void MystConsole::preEnter() {
+	_vm->_sound->pauseSound();
+}
+
+void MystConsole::postEnter() {
+	_vm->_sound->resumeSound();
+}
+
+bool MystConsole::Cmd_ChangeCard(int argc, const char **argv) {
+	if (argc < 2) {
+		DebugPrintf("Usage: changeCard <card>\n");
+		return true;
+	}
+
+	_vm->_sound->stopSound();
+	_vm->changeToCard((uint16)atoi(argv[1]));
+
+	return false;
+}
+	
+bool MystConsole::Cmd_CurCard(int argc, const char **argv) {
+	DebugPrintf("Current Card: %d\n", _vm->getCurCard());
+	return true;
+}
+
+bool MystConsole::Cmd_Var(int argc, const char **argv) {
+	if (argc == 1) {
+		DebugPrintf("Usage: var <var> (<value>)\n");
+		return true;
+	}
+	
+	if (argc > 2)
+		_vm->_varStore->setVar((uint16)atoi(argv[1]), (uint32)atoi(argv[2]));
+
+	DebugPrintf("%d = %d\n", (uint16)atoi(argv[1]), _vm->_varStore->getVar((uint16)atoi(argv[1])));
+	
+	return true;
+}
+
+static const char *mystStackNames[12] = {
+	"Channelwood",
+	"Credits",
+	"Demo",
+	"D'ni",
+	"Intro",
+	"MakingOf",
+	"Mechanical",
+	"Myst",
+	"Selenitic",
+	"Slideshow",
+	"SneakPreview",
+	"Stoneship"
+};
+
+static const uint16 default_start_card[12] = {
+	3137,
+	10000,
+	2001, // TODO: Should be 2000?
+	5038,
+	2, // TODO: Should be 1?
+	1,
+	6122,
+	4134,
+	1282,
+	1000,
+	3000,
+	2029
+};
+
+bool MystConsole::Cmd_CurStack(int argc, const char **argv) {
+	DebugPrintf("Current Stack: %s\n", mystStackNames[_vm->getCurStack()]);
+	return true;
+}
+
+bool MystConsole::Cmd_ChangeStack(int argc, const char **argv) {
+	if (argc != 2 && argc != 3) {
+		DebugPrintf("Usage: changeStack <stack> [<card>]\n\n");
+		DebugPrintf("Stacks:\n=======\n");
+
+		for (byte i = 0; i < ARRAYSIZE(mystStackNames); i++)
+			DebugPrintf(" %s\n", mystStackNames[i]);
+
+		DebugPrintf("\n");
+		
+		return true;
+	}
+	
+	byte stackNum = 0;
+
+	for (byte i = 1; i <= ARRAYSIZE(mystStackNames); i++)
+		if (!scumm_stricmp(argv[1], mystStackNames[i - 1])) {
+			stackNum = i;
+			break;
+		}
+
+	if (!stackNum) {
+		DebugPrintf("\'%s\' is not a stack name!\n", argv[1]);
+		return true;
+	}
+	
+	// We need to stop any playing sound when we change the stack
+	// as the next card could continue playing it if it.
+	_vm->_sound->stopSound();
+
+	_vm->changeToStack(stackNum - 1);
+
+	if (argc == 3)
+		_vm->changeToCard((uint16)atoi(argv[2]));
+	else
+		_vm->changeToCard(default_start_card[stackNum - 1]);
+
+	return false;
+}
+
+bool MystConsole::Cmd_DrawImage(int argc, const char **argv) {
+	if (argc != 2 && argc != 6) {
+		DebugPrintf("Usage: drawImage <image> [<left> <top> <right> <bottom>]\n");
+		return true;
+	}
+
+	Common::Rect rect;
+
+	if (argc == 2)
+		rect = Common::Rect(0, 0, 544, 333);
+	else
+		rect = Common::Rect((uint16)atoi(argv[2]), (uint16)atoi(argv[3]), (uint16)atoi(argv[4]), (uint16)atoi(argv[5]));
+	
+	_vm->_gfx->copyImageToScreen((uint16)atoi(argv[1]), rect);
+	return false;
+}
+
+bool MystConsole::Cmd_DrawRect(int argc, const char **argv) {
+	if (argc < 5) {
+		DebugPrintf("Usage: drawRect <left> <top> <right> <bottom>\n");
+		return true;
+	}
+
+	_vm->_gfx->drawRect(Common::Rect((uint16)atoi(argv[1]), (uint16)atoi(argv[2]), (uint16)atoi(argv[3]), (uint16)atoi(argv[4])), true);
+	return false;
+}
+
+bool MystConsole::Cmd_SetResourceEnable(int argc, const char **argv) {
+	if (argc < 3) {
+		DebugPrintf("Usage: setResourceEnable <resource id> <bool>\n");
+		return true;
+	}
+
+	_vm->setResourceEnabled((uint16)atoi(argv[1]), atoi(argv[2]) == 1);
+	return true;
+}
+
+bool MystConsole::Cmd_PlaySound(int argc, const char **argv) {
+	if (argc == 1) {
+		DebugPrintf("Usage: playSound <value>\n");
+
+		return true;
+	}
+
+	_vm->_sound->stopSound();
+	_vm->_sound->playSound((uint16)atoi(argv[1]));
+
+	return false;
+}
+
+bool MystConsole::Cmd_StopSound(int argc, const char **argv) {
+	DebugPrintf("Stopping Sound\n");
+
+	_vm->_sound->stopSound();
+
+	return true;
+}
+
+bool MystConsole::Cmd_PlayMovie(int argc, const char **argv) {
+	if (argc < 2) {
+		DebugPrintf("Usage: playMovie <name> [<stack>] [<left> <top>]\n");
+		DebugPrintf("NOTE: The movie will play *once* in the background.\n");
+		return true;
+	}
+	
+	int8 stackNum = 0;
+
+	if (argc == 3 || argc > 4) {
+		for (byte i = 1; i <= ARRAYSIZE(mystStackNames); i++)
+			if (!scumm_stricmp(argv[2], mystStackNames[i - 1])) {
+				stackNum = i;
+				break;
+			}
+
+		if (!stackNum) {
+			DebugPrintf("\'%s\' is not a stack name!\n", argv[2]);
+			return true;
+		}
+	}
+
+	if (argc == 2)
+		_vm->_video->playBackgroundMovie(argv[1], 0, 0);
+	else if (argc == 3)
+		_vm->_video->playBackgroundMovie(_vm->wrapMovieFilename(argv[1], stackNum - 1), 0, 0);
+	else if (argc == 4)
+		_vm->_video->playBackgroundMovie(argv[1], atoi(argv[2]), atoi(argv[3]));
+	else
+		_vm->_video->playBackgroundMovie(_vm->wrapMovieFilename(argv[1], stackNum - 1), atoi(argv[3]), atoi(argv[4]));
+
+	return false;
+}
+
+bool MystConsole::Cmd_DisableInitOpcodes(int argc, const char **argv) {
+	if (argc != 1) {
+		DebugPrintf("Usage: disableInitOpcodes\n");
+
+		return true;
+	}
+
+	_vm->_scriptParser->disableInitOpcodes();
+
+	return true;
+}
+
+RivenConsole::RivenConsole(MohawkEngine_Riven *vm) : GUI::Debugger(), _vm(vm) {
+	DCmd_Register("changeCard",		WRAP_METHOD(RivenConsole, Cmd_ChangeCard));
+	DCmd_Register("curCard",		WRAP_METHOD(RivenConsole, Cmd_CurCard));
+	DCmd_Register("var",			WRAP_METHOD(RivenConsole, Cmd_Var));
+	DCmd_Register("playSound",		WRAP_METHOD(RivenConsole, Cmd_PlaySound));
+	DCmd_Register("playSLST",       WRAP_METHOD(RivenConsole, Cmd_PlaySLST));
+	DCmd_Register("stopSound",		WRAP_METHOD(RivenConsole, Cmd_StopSound));
+	DCmd_Register("curStack",		WRAP_METHOD(RivenConsole, Cmd_CurStack));
+	DCmd_Register("changeStack",	WRAP_METHOD(RivenConsole, Cmd_ChangeStack));
+	DCmd_Register("restart",		WRAP_METHOD(RivenConsole, Cmd_Restart));
+	DCmd_Register("hotspots",		WRAP_METHOD(RivenConsole, Cmd_Hotspots));
+	DCmd_Register("zipMode",		WRAP_METHOD(RivenConsole, Cmd_ZipMode));
+	DCmd_Register("dumpScript",     WRAP_METHOD(RivenConsole, Cmd_DumpScript));
+	DCmd_Register("listZipCards",   WRAP_METHOD(RivenConsole, Cmd_ListZipCards));
+	DCmd_Register("getRMAP",		WRAP_METHOD(RivenConsole, Cmd_GetRMAP));
+}
+
+RivenConsole::~RivenConsole() {
+}
+
+void RivenConsole::preEnter() {
+	_vm->_sound->pauseSound();
+	_vm->_sound->pauseSLST();
+}
+
+void RivenConsole::postEnter() {
+	_vm->_sound->resumeSound();
+	_vm->_sound->resumeSLST();
+}
+
+bool RivenConsole::Cmd_ChangeCard(int argc, const char **argv) {
+	if (argc < 2) {
+		DebugPrintf("Usage: changeCard <card>\n");
+		return true;
+	}
+
+	_vm->_sound->stopSound();
+	_vm->_sound->stopAllSLST();
+	_vm->changeToCard((uint16)atoi(argv[1]));
+
+	return false;
+}
+	
+bool RivenConsole::Cmd_CurCard(int argc, const char **argv) {
+	DebugPrintf("Current Card: %d\n", _vm->getCurCard());
+
+	return true;
+}
+	
+bool RivenConsole::Cmd_Var(int argc, const char **argv) {
+	if (argc == 1) {
+		DebugPrintf("Usage: var <var name> (<value>)\n");
+		return true;
+	}
+	
+	uint32 *globalVar = _vm->matchVarToString(argv[1]);
+	
+	if (!globalVar) {
+		DebugPrintf("Unknown variable \'%s\'\n", argv[1]);
+		return true;
+	}
+	
+	if (argc > 2)
+		*globalVar = (uint32)atoi(argv[2]);
+
+	DebugPrintf("%s = %d\n", argv[1], *globalVar);
+
+	return true;
+}
+
+bool RivenConsole::Cmd_PlaySound(int argc, const char **argv) {
+	if (argc < 2) {
+		DebugPrintf("Usage: playSound <value> (<use main sound file, default = true>)\n");
+		DebugPrintf("The main sound file is default, but you can use the word \'false\' to make it use the current stack file.\n");
+
+		return true;
+	}
+
+	_vm->_sound->stopSound();
+	_vm->_sound->stopAllSLST();
+	
+	bool mainSoundFile = (argc < 3) || (scumm_stricmp(argv[2], "false") != 0);
+	
+	_vm->_sound->playSound((uint16)atoi(argv[1]), mainSoundFile);
+
+	return false;
+}
+
+bool RivenConsole::Cmd_PlaySLST(int argc, const char **argv) {
+	if (argc < 2) {
+		DebugPrintf("Usage: playSLST <slst index> <card, default = current>\n");
+
+		return true;
+	}
+
+	_vm->_sound->stopSound();
+	_vm->_sound->stopAllSLST();
+	
+	uint16 card = _vm->getCurCard();
+	
+	if (argc == 3)
+		card = (uint16)atoi(argv[2]);
+	
+	_vm->_sound->playSLST((uint16)atoi(argv[1]), card);
+
+	return false;
+}
+
+bool RivenConsole::Cmd_StopSound(int argc, const char **argv) {
+	DebugPrintf("Stopping Sound\n");
+
+	_vm->_sound->stopSound();
+	_vm->_sound->stopAllSLST();
+
+	return true;
+}
+
+bool RivenConsole::Cmd_CurStack(int argc, const char **argv) {
+	DebugPrintf("Current Stack: %s\n", _vm->getStackName(_vm->getCurStack()).c_str());
+
+	return true;
+}
+
+bool RivenConsole::Cmd_ChangeStack(int argc, const char **argv) {
+	byte i;
+
+	if (argc < 3) {
+		DebugPrintf("Usage: changeStack <stack> <card>\n\n");
+		DebugPrintf("Stacks:\n=======\n");
+
+		for (i = 0; i <= tspit; i++)
+			DebugPrintf(" %s\n", _vm->getStackName(i).c_str());
+
+		DebugPrintf("\n");
+		
+		return true;
+	}
+	
+	byte stackNum = 0;
+
+	for (i = 1; i <= tspit + 1; i++)
+		if (!scumm_stricmp(argv[1], _vm->getStackName(i - 1).c_str())) {
+			stackNum = i;
+			break;
+		}
+
+	if (!stackNum) {
+		DebugPrintf("\'%s\' is not a stack name!\n", argv[1]);
+		return true;
+	}
+
+	_vm->changeToStack(stackNum - 1);
+	_vm->changeToCard((uint16)atoi(argv[2]));
+
+	return false;
+}
+
+bool RivenConsole::Cmd_Restart(int argc, const char **argv) {
+	_vm->initVars();
+	_vm->changeToStack(aspit);
+	_vm->changeToCard(1);
+
+	return false;
+}
+
+bool RivenConsole::Cmd_Hotspots(int argc, const char **argv) {
+	DebugPrintf("Current card (%d) has %d hotspots:\n", _vm->getCurCard(), _vm->getHotspotCount());
+
+	for (uint16 i = 0; i < _vm->getHotspotCount(); i++) {
+		DebugPrintf("Hotspot %d, index %d, BLST ID %d (", i, _vm->_hotspots[i].index, _vm->_hotspots[i].blstID);
+
+		if (_vm->_hotspots[i].enabled)
+			DebugPrintf("enabled)\n");
+		else
+			DebugPrintf("disabled)\n");
+			
+		DebugPrintf("    Name = %s\n", _vm->getHotspotName(i).c_str());
+	}	
+
+	return true;
+}
+
+bool RivenConsole::Cmd_ZipMode(int argc, const char **argv) {
+	uint32 *zipModeActive = _vm->matchVarToString("azip");
+	*zipModeActive = !(*zipModeActive);
+
+	DebugPrintf("Zip Mode is ");
+	DebugPrintf((*zipModeActive) ? "Enabled" : "Disabled");
+	DebugPrintf("\n");
+	return true;
+}
+
+bool RivenConsole::Cmd_DumpScript(int argc, const char **argv) {
+	if (argc < 4) {
+		DebugPrintf("Usage: dumpScript <stack> <CARD or HSPT> <card>\n");
+		return true;
+	}
+	
+	uint16 oldStack = _vm->getCurStack();
+	
+	byte newStack = 0;
+
+	for (byte i = 1; i <= tspit + 1; i++)
+		if (!scumm_stricmp(argv[1], _vm->getStackName(i - 1).c_str())) {
+			newStack = i;
+			break;
+		}
+
+	if (!newStack) {
+		DebugPrintf("\'%s\' is not a stack name!\n", argv[1]);
+		return true;
+	}
+	
+	newStack--;
+	_vm->changeToStack(newStack);
+	
+	// Load in Variable Names
+	Common::SeekableReadStream *nameStream = _vm->getRawData(ID_NAME, VariableNames);
+	Common::StringList varNames;
+	
+	uint16 namesCount = nameStream->readUint16BE();
+	uint16 *stringOffsets = new uint16[namesCount];
+	for (uint16 i = 0; i < namesCount; i++)
+		stringOffsets[i] = nameStream->readUint16BE();
+	nameStream->seek(namesCount * 2, SEEK_CUR);
+	int32 curNamesPos = nameStream->pos();
+	
+	for (uint32 i = 0; i < namesCount; i++) {
+		nameStream->seek(curNamesPos + stringOffsets[i]);
+			
+		Common::String name = Common::String::emptyString;
+		for (char c = nameStream->readByte(); c; c = nameStream->readByte())
+			name += c;
+		varNames.push_back(name);
+	}
+	delete nameStream;
+	
+	// Load in External Command Names
+	nameStream = _vm->getRawData(ID_NAME, ExternalCommandNames);
+	Common::StringList xNames;
+	
+	namesCount = nameStream->readUint16BE();
+	stringOffsets = new uint16[namesCount];
+	for (uint16 i = 0; i < namesCount; i++)
+		stringOffsets[i] = nameStream->readUint16BE();
+	nameStream->seek(namesCount * 2, SEEK_CUR);
+	curNamesPos = nameStream->pos();
+	
+	for (uint32 i = 0; i < namesCount; i++) {
+		nameStream->seek(curNamesPos + stringOffsets[i]);
+			
+		Common::String name = Common::String::emptyString;
+		for (char c = nameStream->readByte(); c; c = nameStream->readByte())
+			name += c;
+		xNames.push_back(name);
+	}
+	delete nameStream;
+	
+	// Get CARD/HSPT data and dump their scripts
+	if (!scumm_stricmp(argv[2], "CARD")) {
+		printf ("\n\nDumping scripts for %s\'s card %d!\n", argv[1], (uint16)atoi(argv[3]));
+		printf ("==================================\n\n");
+		Common::SeekableReadStream *cardStream = _vm->getRawData(MKID_BE('CARD'), (uint16)atoi(argv[3]));
+		cardStream->seek(4);
+		RivenScriptList scriptList = RivenScript::readScripts(_vm, cardStream);
+		for (uint32 i = 0; i < scriptList.size(); i++)
+			scriptList[i]->dumpScript(varNames, xNames, 0);
+		delete cardStream;
+	} else if (!scumm_stricmp(argv[2], "HSPT")) {
+		printf ("\n\nDumping scripts for %s\'s card %d hotspots!\n", argv[1], (uint16)atoi(argv[3]));
+		printf ("===========================================\n\n");
+		
+		Common::SeekableReadStream *hsptStream = _vm->getRawData(MKID_BE('HSPT'), (uint16)atoi(argv[3]));
+		
+		uint16 hotspotCount = hsptStream->readUint16BE();
+		
+		for (uint16 i = 0; i < hotspotCount; i++) {
+			printf ("Hotspot %d:\n", i);
+			hsptStream->seek(22, SEEK_CUR);	// Skip non-script related stuff
+			RivenScriptList scriptList = RivenScript::readScripts(_vm, hsptStream);
+			for (uint32 j = 0; j < scriptList.size(); j++)
+				scriptList[j]->dumpScript(varNames, xNames, 1);
+		}
+		
+		delete hsptStream;
+	} else {
+		DebugPrintf("%s doesn't have any scripts!\n", argv[2]);
+	}
+	
+	printf("\n\n");
+	
+	_vm->changeToStack(oldStack);
+	
+	DebugPrintf("Script dump complete.\n");
+	
+	return true;
+}
+
+bool RivenConsole::Cmd_ListZipCards(int argc, const char **argv) {
+	if (_vm->_zipModeData.size() == 0) {
+		DebugPrintf("No zip card data.\n");
+	} else {
+		DebugPrintf("Listing zip cards:\n");
+		for (uint32 i = 0; i < _vm->_zipModeData.size(); i++)
+			DebugPrintf("ID = %d, Name = %s\n", _vm->_zipModeData[i].id, _vm->_zipModeData[i].name.c_str());
+	}
+	
+	return true;
+}
+
+bool RivenConsole::Cmd_GetRMAP(int argc, const char **argv) {
+	Common::SeekableReadStream *rmapStream = _vm->getRawData(ID_RMAP, 1);
+	rmapStream->seek(_vm->getCurCard() * 4);
+	DebugPrintf("RMAP for %s %d = %08x\n", _vm->getStackName(_vm->getCurStack()).c_str(), _vm->getCurCard(), rmapStream->readUint32BE());
+	delete rmapStream;
+
+	return true;
+}
+
+LivingBooksConsole::LivingBooksConsole(MohawkEngine_LivingBooks *vm) : GUI::Debugger(), _vm(vm) {
+	DCmd_Register("playSound",			WRAP_METHOD(LivingBooksConsole, Cmd_PlaySound));
+	DCmd_Register("stopSound",			WRAP_METHOD(LivingBooksConsole, Cmd_StopSound));
+	DCmd_Register("drawImage",			WRAP_METHOD(LivingBooksConsole, Cmd_DrawImage));
+}
+
+LivingBooksConsole::~LivingBooksConsole() {
+}
+
+void LivingBooksConsole::preEnter() {
+	_vm->_sound->pauseSound();
+}
+
+void LivingBooksConsole::postEnter() {
+	_vm->_sound->resumeSound();
+}
+
+bool LivingBooksConsole::Cmd_PlaySound(int argc, const char **argv) {
+	if (argc == 1) {
+		DebugPrintf("Usage: playSound <value>\n");
+
+		return true;
+	}
+
+	_vm->_sound->stopSound();
+	_vm->_sound->playSound((uint16)atoi(argv[1]));
+
+	return false;
+}
+
+bool LivingBooksConsole::Cmd_StopSound(int argc, const char **argv) {
+	DebugPrintf("Stopping Sound\n");
+
+	_vm->_sound->stopSound();
+
+	return true;
+}
+
+bool LivingBooksConsole::Cmd_DrawImage(int argc, const char **argv) {
+	if (argc == 1) {
+		DebugPrintf("Usage: drawImage <value>\n");
+		return true;
+	}
+
+	if (_vm->getGameType() == GType_OLDLIVINGBOOKS)
+		DebugPrintf("This isn't supported in the old Living Books games (yet)!\n");
+
+	_vm->_gfx->copyImageToScreen((uint16)atoi(argv[1]));
+	return _vm->getGameType() != GType_OLDLIVINGBOOKS;
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/console.h b/engines/mohawk/console.h
new file mode 100644
index 0000000000..bd699bc8b7
--- /dev/null
+++ b/engines/mohawk/console.h
@@ -0,0 +1,111 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#ifndef MOHAWK_CONSOLE_H
+#define MOHAWK_CONSOLE_H
+
+#include "gui/debugger.h"
+
+namespace Mohawk {
+
+class MohawkEngine_Myst;
+class MohawkEngine_Riven;
+class MohawkEngine_LivingBooks;
+
+class MystConsole : public GUI::Debugger {
+public:
+	MystConsole(MohawkEngine_Myst *vm);
+	virtual ~MystConsole(void);
+	
+protected:
+	virtual void preEnter();
+	virtual void postEnter();
+	
+private:
+	MohawkEngine_Myst *_vm;
+	
+	bool Cmd_ChangeCard(int argc, const char **argv);
+	bool Cmd_CurCard(int argc, const char **argv);
+	bool Cmd_Var(int argc, const char **argv);
+	bool Cmd_DrawImage(int argc, const char **argv);
+	bool Cmd_DrawRect(int argc, const char **argv);
+	bool Cmd_SetResourceEnable(int argc, const char **argv);
+	bool Cmd_CurStack(int argc, const char **argv);
+	bool Cmd_ChangeStack(int argc, const char **argv);
+	bool Cmd_PlaySound(int argc, const char **argv);
+	bool Cmd_StopSound(int argc, const char **argv);
+	bool Cmd_PlayMovie(int argc, const char **argv);
+	bool Cmd_DisableInitOpcodes(int argc, const char **argv);
+};
+
+class RivenConsole : public GUI::Debugger {
+public:
+	RivenConsole(MohawkEngine_Riven *vm);
+	virtual ~RivenConsole(void);
+
+protected:
+	virtual void preEnter();
+	virtual void postEnter();
+
+private:
+	MohawkEngine_Riven *_vm;
+		
+	bool Cmd_ChangeCard(int argc, const char **argv);
+	bool Cmd_CurCard(int argc, const char **argv);
+	bool Cmd_Var(int argc, const char **argv);
+	bool Cmd_PlaySound(int argc, const char **argv);
+	bool Cmd_PlaySLST(int argc, const char **argv);
+	bool Cmd_StopSound(int argc, const char **argv);
+	bool Cmd_CurStack(int argc, const char **argv);
+	bool Cmd_ChangeStack(int argc, const char **argv);
+	bool Cmd_Restart(int argc, const char **argv);
+	bool Cmd_Hotspots(int argc, const char **argv);
+	bool Cmd_ZipMode(int argc, const char **argv);
+	bool Cmd_RunAllBlocks(int argc, const char **argv);
+	bool Cmd_DumpScript(int argc, const char **argv);
+	bool Cmd_ListZipCards(int argc, const char **argv);
+	bool Cmd_GetRMAP(int argc, const char **argv);
+};
+
+class LivingBooksConsole : public GUI::Debugger {
+public:
+	LivingBooksConsole(MohawkEngine_LivingBooks *vm);
+	virtual ~LivingBooksConsole(void);
+
+protected:
+	virtual void preEnter();
+	virtual void postEnter();
+
+private:
+	MohawkEngine_LivingBooks *_vm;
+
+	bool Cmd_PlaySound(int argc, const char **argv);
+	bool Cmd_StopSound(int argc, const char **argv);
+	bool Cmd_DrawImage(int argc, const char **argv);
+};
+
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/detection.cpp b/engines/mohawk/detection.cpp
new file mode 100644
index 0000000000..7e310c8760
--- /dev/null
+++ b/engines/mohawk/detection.cpp
@@ -0,0 +1,1042 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "base/plugins.h"
+
+#include "engines/advancedDetector.h"
+#include "common/config-manager.h"
+#include "common/file.h"
+#include "common/savefile.h"
+
+#include "mohawk/myst.h"
+#include "mohawk/riven.h"
+#include "mohawk/livingbooks.h"
+
+// Define this to enable detection of other Broderbund titles which use Mohawk (besides Myst/Riven)
+#define DETECT_BRODERBUND_TITLES
+
+namespace Mohawk {
+
+struct MohawkGameDescription {
+	ADGameDescription desc;
+
+	uint8 gameType;
+	uint32 features;
+	uint16 version;
+};
+
+const char* MohawkEngine::getGameId() const {
+	return _gameDescription->desc.gameid;
+}
+
+uint32 MohawkEngine::getFeatures() const {
+	return _gameDescription->features;
+}
+
+Common::Platform MohawkEngine::getPlatform() const {
+	return _gameDescription->desc.platform;
+}
+
+uint16 MohawkEngine::getVersion() const {
+	return _gameDescription->version;
+}
+
+uint8 MohawkEngine::getGameType() {
+	return _gameDescription->gameType;
+}
+
+Common::String MohawkEngine_LivingBooks::getBookInfoFileName() {
+	return _gameDescription->desc.filesDescriptions[0].fileName;
+}
+
+Common::Language MohawkEngine::getLanguage() {
+	return _gameDescription->desc.language;
+}
+
+bool MohawkEngine::hasFeature(EngineFeature f) const {
+	return
+		(f == kSupportsRTL);
+}
+
+bool MohawkEngine_Myst::hasFeature(EngineFeature f) const {
+	return 
+		MohawkEngine::hasFeature(f)
+		|| (f == kSupportsLoadingDuringRuntime)
+		|| (f == kSupportsSavingDuringRuntime);
+}
+
+bool MohawkEngine_Riven::hasFeature(EngineFeature f) const {
+	return 
+		MohawkEngine::hasFeature(f)
+		|| (f == kSupportsLoadingDuringRuntime)
+		|| (f == kSupportsSavingDuringRuntime);
+}
+
+} // End of Namespace Mohawk
+
+static const PlainGameDescriptor mohawkGames[] = {
+	{"mohawk", "Mohawk Game"},
+	{"myst", "Myst"},
+	{"MakingOfMyst", "The Making of Myst"},
+	{"riven", "Riven: The Sequel to Myst"},
+#ifdef DETECT_BRODERBUND_TITLES
+	{"zoombini", "Logical Journey of the Zoombinis Deluxe"},
+	{"csworld", "Where in the World is Carmen Sandiego?"},
+	{"csamtrak", "Where in America is Carmen Sandiego? (The Great Amtrak Train Adventure)"},
+	{"maggiess", "Maggie's Farmyard Adventure"},
+	{"jamesmath", "James Discovers/Explores Math"},
+	{"treehouse", "The Treehouse"},
+	{"greeneggs", "Green Eggs and Ham"},
+	{"1stdegree", "In the 1st Degree"},
+	{"csusa", "Where in the USA is Carmen Sandiego?"},
+	{"tortoise", "Aesop's Fables: The Tortoise and the Hare"},
+	{"arthur", "Arthur's Teacher Troubles"},
+	{"grandma", "Just Grandma and Me"},
+	{"ruff", "Ruff's Bone"},
+	{"newkid", "The New Kid on the Block"},
+	{"arthurrace", "Arthur's Reading Race"},
+#endif
+	{0, 0}
+};
+
+
+namespace Mohawk {
+
+static const MohawkGameDescription gameDescriptions[] = {
+	// Myst
+	// English Windows 3.11
+	// From clone2727
+	{
+		{
+			"myst",
+			"",
+			AD_ENTRY1("MYST.DAT", "ae3258c9c90128d274aa6a790b3ad181"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_MYST,
+		0,
+		0,
+	},
+	
+	// Myst Demo
+	// English Windows 3.11
+	// From CD-ROM Today July, 1994
+	{
+		{
+			"myst",
+			"Demo",
+			AD_ENTRY1("DEMO.DAT", "c39303dd53fb5c4e7f3c23231c606cd0"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_DEMO,
+			Common::GUIO_NONE
+		},
+		GType_MYST,
+		GF_DEMO,
+		0,
+	},
+
+	// Myst
+	// German Windows 3.11
+	// From clone2727
+	{
+		{
+			"myst",
+			"",
+			AD_ENTRY1("MYST.DAT", "4beb3366ed3f3b9bfb6e81a14a43bdcc"),
+			Common::DE_DEU,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_MYST,
+		0,
+		0,
+	},
+	
+	// Myst
+	// German Windows 3.11
+	// From LordHoto
+	{
+		{
+			"myst",
+			"",
+			AD_ENTRY1("MYST.DAT", "e0937cca1ab125e48e30dc3cd5046ddf"),
+			Common::DE_DEU,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_MYST,
+		0,
+		0,
+	},
+	
+	// Myst
+	// Spanish Windows ?
+	// From jvprat
+	{
+		{
+			"myst",
+			"",
+			AD_ENTRY1("MYST.DAT", "f7e7d7ca69934f1351b5acd4fe4d44c2"),
+			Common::ES_ESP,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_MYST,
+		0,
+		0,
+	},
+	
+	// Myst
+	// Japanese Windows 3.11
+	// From clone2727
+	{
+		{
+			"myst",
+			"",
+			AD_ENTRY1("MYST.DAT", "032c88e3b7e8db4ca475e7b7db9a66bb"),
+			Common::JA_JPN,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_MYST,
+		0,
+		0,
+	},
+
+	// Making of Myst
+	// English Windows 3.11
+	// From clone2727
+	{
+		{
+			"MakingOfMyst",
+			"",
+			AD_ENTRY1("MAKING.DAT", "f6387e8f0f7b8a3e42c95294315d6a0e"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_MAKINGOF,
+		0,
+		0,
+	},
+	
+	// Making of Myst
+	// Japanese Windows 3.11
+	// From clone2727
+	{
+		{
+			"MakingOfMyst",
+			"",
+			AD_ENTRY1("MAKING.DAT", "03ff62607e64419ab2b6ebf7b7bcdf63"),
+			Common::JA_JPN,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_MAKINGOF,
+		0,
+		0,
+	},
+
+	// Myst Masterpiece Edition
+	// English Windows
+	// From clone2727
+	{
+		{
+			"myst",
+			"Masterpiece Edition",
+			AD_ENTRY1("MYST.DAT", "c4cae9f143b5947262e6cb2397e1617e"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_MYST,
+		GF_ME|GF_10TH,
+		0,
+	},
+	
+	// Myst Masterpiece Edition
+	// English Windows
+	// From clone2727
+	{
+		{
+			"myst",
+			"Masterpiece Edition",
+			AD_ENTRY1("MYST.DAT", "c4cae9f143b5947262e6cb2397e1617e"),
+			Common::EN_ANY,
+			Common::kPlatformMacintosh,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_MYST,
+		GF_ME|GF_10TH,
+		0,
+	},
+	
+	// Myst Masterpiece Edition
+	// German Windows
+	// From DrMcCoy (Included in "Myst: Die Trilogie")
+	{
+		{
+			"myst",
+			"Masterpiece Edition",
+			AD_ENTRY1("MYST.DAT", "f88e0ace66dbca78eebdaaa1d3314ceb"),
+			Common::DE_DEU,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_MYST,
+		GF_ME,
+		0,
+	},
+
+	// Riven: The Sequel to Myst
+	// Version 1.0 (5CD)
+	// From clone2727
+	{
+		{
+			"riven",
+			"",
+			AD_ENTRY1("a_Data.MHK", "71145fdecbd68a0cfc292c2fbddf8e08"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_RIVEN,
+		0,
+		0,
+	},
+	
+	// Riven: The Sequel to Myst
+	// Version 1.03 (5CD)
+	// From ST
+	{
+		{
+			"riven",
+			"",
+			AD_ENTRY1("a_Data.MHK", "d8ccae34a0e3c709135a73f449b783be"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_RIVEN,
+		0,
+		0,
+	},
+
+	// Riven: The Sequel to Myst
+	// Version 1.? (5CD)
+	// From jvprat
+	{
+		{
+			"riven",
+			"",
+			AD_ENTRY1("a_Data.MHK", "249e8c995d191b03ee94c892c0eac775"),
+			Common::ES_ESP,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_RIVEN,
+		0,
+		0,
+	},
+
+	// Riven: The Sequel to Myst
+	// Version 1.? (DVD, From "Myst 10th Anniversary Edition")
+	// From Clone2727 
+	{
+		{
+			"riven",
+			"DVD",
+			AD_ENTRY1("a_Data.MHK", "08fcaa5d5a2a01d7a5a6960f497212fe"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_RIVEN,
+		GF_DVD|GF_10TH,
+		0,
+	},
+	
+	// Riven: The Sequel to Myst
+	// Version 1.0 (DVD, From "Myst: Die Trilogie")
+	// From DrMcCoy
+	{
+		{
+			"riven",
+			"",
+			AD_ENTRY1("a_Data.MHK", "a5fe1c91a6033eb6ee54b287578b74b9"),
+			Common::DE_DEU,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_RIVEN,
+		GF_DVD,
+		0,
+	},
+
+	// Riven: The Sequel to Myst
+	// Version ? (Demo, From "Prince of Persia Collector's Edition")
+	// From Clone2727
+	{
+		{
+			"riven",
+			"Demo",
+			AD_ENTRY1("a_Data.MHK", "bae6b03bd8d6eb350d35fd13f0e3139f"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_DEMO,
+			Common::GUIO_NONE
+		},
+		GType_RIVEN,
+		GF_DEMO,
+		0,
+	},
+	
+#ifdef DETECT_BRODERBUND_TITLES
+	{
+		{
+			"zoombini",
+			"",
+			AD_ENTRY1("ZOOMBINI.MHK", "98b758fec55104c096cfd129048be9a6"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_ZOOMBINI,
+		GF_HASMIDI,
+		0
+	},
+	
+	{
+		{
+			"csworld",
+			"v3.0",
+			AD_ENTRY1("C2K.MHK", "605fe88380848031bbd0ff84ade6fe40"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_CSWORLD,
+		0,
+		0
+	},
+	
+	{
+		{
+			"csworld",
+			"v3.5",
+			AD_ENTRY1("C2K.MHK", "d4857aeb0f5e2e0c4ac556aa74f38c23"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_CSWORLD,
+		0,
+		0
+	},
+	
+	{
+		{
+			"csamtrak",
+			"",
+			AD_ENTRY1("AMTRAK.MHK", "2f95301f0bb950d555bb7b0e3b1b7eb1"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_CSAMTRAK,
+		0,
+		0
+	},
+	
+	{
+		{
+			"maggiess",
+			"",
+			AD_ENTRY1("MAGGIESS.MHK", "08f75fc8c0390e68fdada5ddb35d0355"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_MAGGIESS,
+		0,
+		0
+	},
+	
+	{
+		{
+			"jamesmath",
+			"",
+			AD_ENTRY1("BRODER.MHK", "007299da8b2c6e8ec1cde9598c243024"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_JAMESMATH,
+		GF_HASMIDI,
+		0
+	},
+	
+	// This is in the NEWDATA folder, so I assume it's a newer version ;)
+	{
+		{
+			"jamesmath",
+			"",
+			AD_ENTRY1("BRODER.MHK", "53c000938a50dca92860fd9b546dd276"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_JAMESMATH,
+		GF_HASMIDI,
+		1
+	},
+
+	{
+		{
+			"treehouse",
+			"",
+			AD_ENTRY1("MAINROOM.MHK", "12f51894d7f838af639ea9bf1bc8f45b"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_TREEHOUSE,
+		GF_HASMIDI,
+		0
+	},
+	
+	{
+		{
+			"greeneggs",
+			"",
+			AD_ENTRY1("GREEN.LB", "5df8438138186f89e71299d7b4f88d06"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_NEWLIVINGBOOKS,
+		0,
+		0
+	},
+	
+	// 32-bit version of the previous entry
+	{
+		{
+			"greeneggs",
+			"",
+			AD_ENTRY1("GREEN32.LB", "5df8438138186f89e71299d7b4f88d06"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_NEWLIVINGBOOKS,
+		0,
+		0
+	},
+	
+	{
+		{
+			"1stdegree",
+			"",
+			AD_ENTRY1("AL236_1.MHK", "3ba145492a7b8b4dee0ef4222c5639c3"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_1STDEGREE,
+		GF_HASMIDI,
+		0
+	},
+	
+	{
+		{
+			"csusa",
+			"",
+			AD_ENTRY1("USAC2K.MHK", "b8c9d3a2586f62bce3a48b50d7a700e9"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_CSUSA,
+		0,
+		0
+	},
+
+	{
+		{
+			"tortoise",
+			"Demo v1.0",
+			AD_ENTRY1("TORTOISE.512", "75d9a2f8339e423604a0c6e8177600a6"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_DEMO,
+			Common::GUIO_NONE
+		},
+		GType_OLDLIVINGBOOKS,
+		GF_DEMO,
+		0
+	},
+	
+	{
+		{
+			"tortoise",
+			"Demo v1.1",
+			AD_ENTRY1("TORTOISE.512", "a38c99360e2bea3bfdec418469aef022"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_DEMO,
+			Common::GUIO_NONE
+		},
+		GType_OLDLIVINGBOOKS,
+		GF_DEMO,
+		0
+	},
+	
+	{
+		{
+			"arthur",
+			"",
+			AD_ENTRY1("PAGES.512", "1550a361454ec452fe7d2328aac2003c"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_OLDLIVINGBOOKS,
+		0,
+		0
+	},
+	
+	{
+		{
+			"arthur",
+			"Demo",
+			AD_ENTRY1("PAGES.512", "a4d68cef197af1416921ca5b2e0c1e31"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_DEMO,
+			Common::GUIO_NONE
+		},
+		GType_OLDLIVINGBOOKS,
+		GF_DEMO,
+		0
+	},
+	
+	{
+		{
+			"arthur",
+			"Demo",
+			AD_ENTRY1("Bookoutline", "7e2691611ff4c7b89c05221736628059"),
+			Common::EN_ANY,
+			Common::kPlatformMacintosh,
+			ADGF_DEMO,
+			Common::GUIO_NONE
+		},
+		GType_OLDLIVINGBOOKS,
+		GF_DEMO,
+		0
+	},
+	
+	{
+		{
+			"grandma",
+			"Demo v1.0",
+			AD_ENTRY1("PAGES.512", "95d9f4b035bf5d15c57a9189f231b0f8"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_DEMO,
+			Common::GUIO_NONE
+		},
+		GType_OLDLIVINGBOOKS,
+		GF_DEMO,
+		0
+	},
+	
+	{
+		{
+			"grandma",
+			"Demo v1.1",
+			AD_ENTRY1("GRANDMA.512", "72a4d5fb1b3f06b5f75425635d42ce2e"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_DEMO,
+			Common::GUIO_NONE
+		},
+		GType_OLDLIVINGBOOKS,
+		GF_DEMO,
+		0
+	},
+	
+	{
+		{
+			"grandma",
+			"Demo",
+			AD_ENTRY1("Bookoutline", "553c93891b9631d1e1d269599e1efa6c"),
+			Common::EN_ANY,
+			Common::kPlatformMacintosh,
+			ADGF_DEMO,
+			Common::GUIO_NONE
+		},
+		GType_OLDLIVINGBOOKS,
+		GF_DEMO,
+		0
+	},
+	
+	{
+		{
+			"ruff",
+			"Demo",
+			AD_ENTRY1("RUFF.512", "2ba1aa65177c816e156db648c398d362"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_DEMO,
+			Common::GUIO_NONE
+		},
+		GType_OLDLIVINGBOOKS,
+		GF_DEMO,
+		0
+	},
+	
+	{
+		{
+			"ruff",
+			"Demo",
+			AD_ENTRY1("Ruff's Bone Demo", "22553ac2ceb2a166bdf1def6ad348532"),
+			Common::EN_ANY,
+			Common::kPlatformMacintosh,
+			ADGF_DEMO,
+			Common::GUIO_NONE
+		},
+		GType_OLDLIVINGBOOKS,
+		GF_DEMO,
+		0
+	},
+	
+	{
+		{
+			"newkid",
+			"Demo v1.0",
+			AD_ENTRY1("NEWKID.512", "2b9d94763a50d514c04a3af488934f73"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_DEMO,
+			Common::GUIO_NONE
+		},
+		GType_OLDLIVINGBOOKS,
+		GF_DEMO,
+		0
+	},
+	
+	{
+		{
+			"newkid",
+			"Demo v1.1",
+			AD_ENTRY1("NEWKID.512", "41e975b7390c626f8d1058a34f9d9b2e"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_DEMO,
+			Common::GUIO_NONE
+		},
+		GType_OLDLIVINGBOOKS,
+		GF_DEMO,
+		0
+	},
+	
+	{
+		{
+			"arthurrace",
+			"",
+			AD_ENTRY1("RACE.LB", "1645f36bcb36e440d928e920aa48c373"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_NEWLIVINGBOOKS,
+		0,
+		0
+	},
+	
+	// 32-bit version of the previous entry
+	{
+		{
+			"arthurrace",
+			"",
+			AD_ENTRY1("RACE32.LB", "292a05bc48c1dd9583821a4181a02ef2"),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_NEWLIVINGBOOKS,
+		0,
+		0
+	},
+#endif
+
+	{ AD_TABLE_END_MARKER, 0, 0, 0 }
+};
+
+//////////////////////////////
+//Fallback detection
+//////////////////////////////
+
+static const MohawkGameDescription fallbackDescs[] = {
+	{
+		{
+			"myst",
+			"unknown",
+			AD_ENTRY1(0, 0),
+			Common::UNK_LANG,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_MYST,
+		0,
+		0
+	},
+
+	{
+		{
+			"MakingOfMyst",
+			"unknown",
+			AD_ENTRY1(0, 0),
+			Common::UNK_LANG,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_MAKINGOF,
+		0,
+		0
+	},
+
+	// The Masterpiece Edition of Myst has 24bit color, and thus is not supported by ScummVM
+	// Currently, its graphics are just bypassed.
+	{
+		{
+			"myst",
+			"unknown (Masterpiece Edition)",
+			AD_ENTRY1(0, 0),
+			Common::UNK_LANG,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_MYST,
+		GF_ME,
+		0
+	},
+
+	{
+		{
+			"riven",
+			"unknown",
+			AD_ENTRY1(0, 0),
+			Common::UNK_LANG,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_RIVEN,
+		0,
+		0
+	},
+
+	{
+		{
+			"riven",
+			"unknown (DVD)",
+			AD_ENTRY1(0, 0),
+			Common::UNK_LANG,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			Common::GUIO_NONE
+		},
+		GType_RIVEN,
+		GF_DVD,
+		0
+	}
+};
+
+static const ADFileBasedFallback fileBased[] = {
+	{ &fallbackDescs[0],  { "MYST.DAT", 0 } },
+	{ &fallbackDescs[1],  { "MAKING.DAT", 0 } },
+	{ &fallbackDescs[2],  { "MYST.DAT", "Help.dat", 0 } },	// Help system doesn't exist in original
+	{ &fallbackDescs[3],  { "a_Data.MHK", 0 } },
+	{ &fallbackDescs[4],  { "a_Data.MHK", "t_Data1.MHK" , 0 } },
+	{ 0, { 0 } }
+};
+
+} // End of namespace Mohawk
+
+static const ADParams detectionParams = {
+	// Pointer to ADGameDescription or its superset structure
+	(const byte *)Mohawk::gameDescriptions,
+	// Size of that superset structure
+	sizeof(Mohawk::MohawkGameDescription),
+	// Number of bytes to compute MD5 sum for
+	5000,
+	// List of all engine targets
+	mohawkGames,
+	// Structure for autoupgrading obsolete targets
+	0,
+	// Name of single gameid (optional)
+	"mohawk",
+	// List of files for file-based fallback detection (optional)
+	Mohawk::fileBased,
+	// Flags
+	0,
+	// Additional GUI options (for every game)
+	Common::GUIO_NONE
+};
+
+class MohawkMetaEngine : public AdvancedMetaEngine {
+public:
+	MohawkMetaEngine() : AdvancedMetaEngine(detectionParams) {}
+
+	virtual const char *getName() const {
+		return "Mohawk Engine";
+	}
+
+	virtual const char *getOriginalCopyright() const {
+		return "Myst and Riven (C) Cyan Worlds\nMohawk OS (C) Ubisoft";
+	}
+
+	virtual bool hasFeature(MetaEngineFeature f) const;
+	virtual bool createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const;
+	virtual SaveStateList listSaves(const char *target) const;
+	virtual int getMaximumSaveSlot() const { return 999; }
+	virtual void removeSaveState(const char *target, int slot) const;
+};
+
+bool MohawkMetaEngine::hasFeature(MetaEngineFeature f) const {
+	return 
+		(f == kSupportsListSaves)
+		|| (f == kSupportsLoadingDuringStartup)
+		|| (f == kSupportsDeleteSave);
+}
+
+SaveStateList MohawkMetaEngine::listSaves(const char *target) const {
+	Common::StringList filenames;
+	SaveStateList saveList;
+
+	// Loading games is only supported in Myst/Riven currently.
+	if (strstr(target, "myst")) {
+		filenames = g_system->getSavefileManager()->listSavefiles("*.mys");
+	
+		for (uint32 i = 0; i < filenames.size(); i++)
+			saveList.push_back(SaveStateDescriptor(i, filenames[i]));
+	} else if (strstr(target, "riven")) {
+		filenames = g_system->getSavefileManager()->listSavefiles("*.rvn");
+	
+		for (uint32 i = 0; i < filenames.size(); i++)
+			saveList.push_back(SaveStateDescriptor(i, filenames[i]));
+	} 
+			
+	return saveList;
+}
+
+void MohawkMetaEngine::removeSaveState(const char *target, int slot) const {
+	// Removing saved games is only supported in Myst/Riven currently.
+	if (strstr(target, "myst")) {
+		Common::StringList filenames = g_system->getSavefileManager()->listSavefiles("*.mys");
+		g_system->getSavefileManager()->removeSavefile(filenames[slot].c_str());
+	} else if (strstr(target, "riven")) {
+		Common::StringList filenames = g_system->getSavefileManager()->listSavefiles("*.rvn");
+		g_system->getSavefileManager()->removeSavefile(filenames[slot].c_str());
+	}
+}
+
+bool MohawkMetaEngine::createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const {
+	const Mohawk::MohawkGameDescription *gd = (const Mohawk::MohawkGameDescription *)desc;
+	
+	if (gd) {
+		switch (gd->gameType) {
+		case Mohawk::GType_MYST:
+		case Mohawk::GType_MAKINGOF:
+			*engine = new Mohawk::MohawkEngine_Myst(syst, gd);
+			break;
+		case Mohawk::GType_RIVEN:
+			*engine = new Mohawk::MohawkEngine_Riven(syst, gd);
+			break;
+		case Mohawk::GType_OLDLIVINGBOOKS:
+		case Mohawk::GType_NEWLIVINGBOOKS:
+			*engine = new Mohawk::MohawkEngine_LivingBooks(syst, gd);
+			break;
+		case Mohawk::GType_ZOOMBINI:
+		case Mohawk::GType_CSWORLD:
+		case Mohawk::GType_CSAMTRAK:
+		case Mohawk::GType_MAGGIESS:
+		case Mohawk::GType_JAMESMATH:
+		case Mohawk::GType_TREEHOUSE:
+		case Mohawk::GType_1STDEGREE:
+		case Mohawk::GType_CSUSA:
+			error ("Unsupported Mohawk Engine");
+			break;
+		default:
+			error ("Unknown Mohawk Engine");
+		}
+	}
+
+	return (gd != 0);
+}
+
+#if PLUGIN_ENABLED_DYNAMIC(MOHAWK)
+	REGISTER_PLUGIN_DYNAMIC(MOHAWK, PLUGIN_TYPE_ENGINE, MohawkMetaEngine);
+#else
+	REGISTER_PLUGIN_STATIC(MOHAWK, PLUGIN_TYPE_ENGINE, MohawkMetaEngine);
+#endif
diff --git a/engines/mohawk/dialogs.cpp b/engines/mohawk/dialogs.cpp
new file mode 100644
index 0000000000..8757a613fa
--- /dev/null
+++ b/engines/mohawk/dialogs.cpp
@@ -0,0 +1,148 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "mohawk/mohawk.h"
+#include "mohawk/myst.h"
+#include "mohawk/riven.h"
+#include "mohawk/dialogs.h"
+
+#include "gui/GuiManager.h"
+#include "common/savefile.h"
+
+namespace Mohawk {
+
+// This used to have GUI::Dialog("MohawkDummyDialog"), but that doesn't work with the gui branch merge :P (Sorry, Tanoku!)
+InfoDialog::InfoDialog(MohawkEngine *vm, Common::String message) : _vm(vm), GUI::Dialog(0, 0, 1, 1), _message(message) {
+	_backgroundType = GUI::ThemeEngine::kDialogBackgroundSpecial;
+	
+	_text = new GUI::StaticTextWidget(this, 4, 4, 10, 10, _message, Graphics::kTextAlignCenter);
+}
+
+void InfoDialog::setInfoText(Common::String message) {
+	_message = message;
+	_text->setLabel(_message);
+}
+
+void InfoDialog::reflowLayout() {
+	const int screenW = g_system->getOverlayWidth();
+	const int screenH = g_system->getOverlayHeight();
+	
+	int width = g_gui.getStringWidth(_message) + 16;
+	int height = g_gui.getFontHeight() + 8;
+	
+	_w = width;
+	_h = height;
+	_x = (screenW - width) / 2;
+	_y = (screenH - height) / 2;
+	
+	_text->setSize(_w - 8, _h);
+}
+
+PauseDialog::PauseDialog(MohawkEngine *vm, Common::String message) : InfoDialog(vm, message) {
+}
+
+void PauseDialog::handleKeyDown(Common::KeyState state) {
+	if (state.ascii == ' ')
+		close();
+	else
+		InfoDialog::handleKeyDown(state);
+}
+
+enum {
+	kCloseCmd = 'CLOS',
+	kZipCmd = 'ZIPM',
+	kTransCmd = 'TRAN',
+	kWaterCmd = 'WATR'
+};
+
+MystOptionsDialog::MystOptionsDialog(MohawkEngine_Myst* vm) : GUI::OptionsDialog("", 120, 120, 360, 200), _vm(vm) {	
+	_zipModeCheckbox = new GUI::CheckboxWidget(this, 15, 10, 300, 15, "Zip Mode Activated", kZipCmd, 'Z');
+	_transistionsCheckbox = new GUI::CheckboxWidget(this, 15, 30, 300, 15, "Transistions Enabled", kTransCmd, 'T');
+
+	new GUI::ButtonWidget(this, 95, 160, 120, 25, "OK", GUI::OptionsDialog::kOKCmd, 'O');
+	new GUI::ButtonWidget(this, 225, 160, 120, 25, "Cancel", kCloseCmd, 'C');
+}
+
+MystOptionsDialog::~MystOptionsDialog() {
+}
+
+void MystOptionsDialog::open() {
+	Dialog::open();
+
+	_zipModeCheckbox->setState(_vm->_zipMode);
+	_transistionsCheckbox->setState(_vm->_transitionsEnabled);
+}
+
+void MystOptionsDialog::handleCommand(GUI::CommandSender *sender, uint32 cmd, uint32 data) {
+	switch (cmd) {
+		case kZipCmd:
+			_vm->_zipMode = _zipModeCheckbox->getState();
+			break;
+		case kTransCmd:
+			_vm->_transitionsEnabled = _transistionsCheckbox->getState();
+			break;
+		case kCloseCmd:
+			close();
+			break;
+		default:
+			GUI::OptionsDialog::handleCommand(sender, cmd, data);
+	}
+}
+
+RivenOptionsDialog::RivenOptionsDialog(MohawkEngine_Riven* vm) : GUI::OptionsDialog("", 120, 120, 360, 200), _vm(vm) {	
+	_zipModeCheckbox = new GUI::CheckboxWidget(this, 15, 10, 300, 15, "Zip Mode Activated", kZipCmd, 'Z');
+	_waterEffectCheckbox = new GUI::CheckboxWidget(this, 15, 30, 300, 15, "Water Effect Enabled", kWaterCmd, 'W');
+
+	new GUI::ButtonWidget(this, 95, 160, 120, 25, "OK", GUI::OptionsDialog::kOKCmd, 'O');
+	new GUI::ButtonWidget(this, 225, 160, 120, 25, "Cancel", kCloseCmd, 'C');
+}
+
+RivenOptionsDialog::~RivenOptionsDialog() {
+}
+
+void RivenOptionsDialog::open() {
+	Dialog::open();
+
+	_zipModeCheckbox->setState(*_vm->matchVarToString("azip") != 0);
+	_waterEffectCheckbox->setState(*_vm->matchVarToString("waterenabled") != 0);
+}
+
+void RivenOptionsDialog::handleCommand(GUI::CommandSender *sender, uint32 cmd, uint32 data) {
+	switch (cmd) {
+		case kZipCmd:
+			*_vm->matchVarToString("azip") = _zipModeCheckbox->getState() ? 1 : 0;
+			break;
+		case kWaterCmd:
+			*_vm->matchVarToString("waterenabled") = _waterEffectCheckbox->getState() ? 1 : 0;
+			break;
+		case kCloseCmd:
+			close();
+			break;
+		default:
+			GUI::OptionsDialog::handleCommand(sender, cmd, data);
+	}
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/dialogs.h b/engines/mohawk/dialogs.h
new file mode 100644
index 0000000000..5b3aad2446
--- /dev/null
+++ b/engines/mohawk/dialogs.h
@@ -0,0 +1,100 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#ifndef MOHAWK_DIALOGS_H
+#define MOHAWK_DIALOGS_H
+
+#include "mohawk/mohawk.h"
+
+#include "common/events.h"
+#include "common/str.h"
+#include "gui/dialog.h"
+#include "gui/options.h"
+#include "gui/widget.h"
+#include "gui/ListWidget.h"
+
+namespace Mohawk {
+
+class MohawkEngine;
+
+class InfoDialog : public GUI::Dialog {
+protected:
+	MohawkEngine *_vm;
+	Common::String _message;
+	GUI::StaticTextWidget *_text;
+
+public:
+	InfoDialog(MohawkEngine *vm, Common::String message);
+	
+	void setInfoText(Common::String message);
+	
+	virtual void handleMouseDown(int x, int y, int button, int clickCount) {
+		setResult(0);
+		close();
+	}
+	
+	virtual void handleKeyDown(Common::KeyState state) {
+		setResult(state.ascii);
+		close();
+	}
+	
+	virtual void reflowLayout();
+};
+
+class PauseDialog : public InfoDialog {
+public:
+	PauseDialog(MohawkEngine* vm, Common::String message);
+	virtual void handleKeyDown(Common::KeyState state);
+};
+
+class MystOptionsDialog : public GUI::OptionsDialog {
+public:
+	MystOptionsDialog(MohawkEngine_Myst *vm);
+	~MystOptionsDialog();
+	void open();
+	
+	virtual void handleCommand(GUI::CommandSender*, uint32, uint32);
+private:
+	MohawkEngine_Myst *_vm;
+	GUI::CheckboxWidget *_zipModeCheckbox;
+	GUI::CheckboxWidget *_transistionsCheckbox;
+};
+
+class RivenOptionsDialog : public GUI::OptionsDialog {
+public:
+	RivenOptionsDialog(MohawkEngine_Riven *vm);
+	~RivenOptionsDialog();
+	void open();
+	
+	virtual void handleCommand(GUI::CommandSender*, uint32, uint32);
+private:
+	MohawkEngine_Riven *_vm;
+	GUI::CheckboxWidget *_zipModeCheckbox;
+	GUI::CheckboxWidget *_waterEffectCheckbox;
+};
+
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/file.cpp b/engines/mohawk/file.cpp
new file mode 100644
index 0000000000..bca9ef6008
--- /dev/null
+++ b/engines/mohawk/file.cpp
@@ -0,0 +1,317 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "mohawk/file.h"
+
+#include "common/util.h"
+
+namespace Mohawk {
+
+MohawkFile::MohawkFile() {
+	_mhk = NULL;
+	_curFile = Common::String::emptyString;
+	_types = NULL;
+	_fileTable = NULL;
+}
+
+void MohawkFile::open(Common::String filename) {
+	Common::File *file = new Common::File();
+	if (!file->open(filename.c_str()))
+		error ("Could not open file \'%s\'", filename.c_str());
+
+	_curFile = filename;
+	
+	open(file);
+}
+
+void MohawkFile::close() {
+	delete _mhk; _mhk = NULL;	
+	delete[] _types; _types = NULL;
+	delete[] _fileTable; _fileTable = NULL;
+	
+	_curFile = Common::String::emptyString;
+}
+
+void MohawkFile::open(Common::SeekableReadStream *stream) {
+	// Make sure no other file is open...
+	close();
+	_mhk = stream;
+
+	if (_mhk->readUint32BE() != ID_MHWK)
+		error ("Could not find tag \'MHWK\'");
+
+	_fileSize = _mhk->readUint32BE();
+
+	if (_mhk->readUint32BE() != ID_RSRC)
+		error ("Could not find tag \'RSRC\'");
+
+	_rsrc.size = _mhk->readUint32BE();
+	_rsrc.filesize = _mhk->readUint32BE();
+	_rsrc.abs_offset = _mhk->readUint32BE();
+	_rsrc.file_table_offset = _mhk->readUint16BE();
+	_rsrc.file_table_size = _mhk->readUint16BE();
+
+	debug (3, "Absolute Offset = %08x", _rsrc.abs_offset);
+
+	/////////////////////////////////
+	//Resource Dir
+	/////////////////////////////////		
+
+	// Type Table
+	_mhk->seek(_rsrc.abs_offset);
+	_typeTable.name_offset = _mhk->readUint16BE();
+	_typeTable.resource_types = _mhk->readUint16BE();
+
+	debug (0, "Name List Offset = %04x  Number of Resource Types = %04x", _typeTable.name_offset, _typeTable.resource_types);
+
+	_types = new Type[_typeTable.resource_types];
+
+	for (uint16 i = 0; i < _typeTable.resource_types; i++) {
+		_types[i].tag = _mhk->readUint32BE();
+		_types[i].resource_table_offset = _mhk->readUint16BE();
+		_types[i].name_table_offset = _mhk->readUint16BE();
+
+		// HACK: Zoombini's SND resource starts will a NULL.
+		if (_types[i].tag == ID_SND)
+			debug (3, "Type[%02d]: Tag = \'SND\' ResTable Offset = %04x  NameTable Offset = %04x", i, _types[i].resource_table_offset, _types[i].name_table_offset);
+		else
+			debug (3, "Type[%02d]: Tag = \'%s\' ResTable Offset = %04x  NameTable Offset = %04x", i, tag2str(_types[i].tag), _types[i].resource_table_offset, _types[i].name_table_offset);
+
+		//Resource Table
+		_mhk->seek(_rsrc.abs_offset + _types[i].resource_table_offset);
+		_types[i].resTable.resources = _mhk->readUint16BE();
+
+		debug (3, "Resources = %04x", _types[i].resTable.resources);
+
+		_types[i].resTable.entries = new Type::ResourceTable::Entries[_types[i].resTable.resources];
+                        
+		for (uint16 j = 0; j < _types[i].resTable.resources; j++) {
+			_types[i].resTable.entries[j].id = _mhk->readUint16BE();
+			_types[i].resTable.entries[j].index = _mhk->readUint16BE();
+
+			debug (4, "Entry[%02x]: ID = %04x (%d) Index = %04x", j, _types[i].resTable.entries[j].id, _types[i].resTable.entries[j].id, _types[i].resTable.entries[j].index); 
+		}
+
+		// Name Table
+		_mhk->seek(_rsrc.abs_offset + _types[i].name_table_offset);
+		_types[i].nameTable.num = _mhk->readUint16BE();
+
+		debug (3, "Names = %04x", _types[i].nameTable.num);
+
+		_types[i].nameTable.entries = new Type::NameTable::Entries[_types[i].nameTable.num];
+                        
+		for (uint16 j = 0; j < _types[i].nameTable.num; j++) {
+			_types[i].nameTable.entries[j].offset = _mhk->readUint16BE();
+			_types[i].nameTable.entries[j].index = _mhk->readUint16BE();
+
+			debug (4, "Entry[%02x]: Name List Offset = %04x  Index = %04x", j, _types[i].nameTable.entries[j].offset, _types[i].nameTable.entries[j].index);
+
+			// Name List
+			uint32 pos = _mhk->pos();
+			_mhk->seek(_rsrc.abs_offset + _typeTable.name_offset + _types[i].nameTable.entries[j].offset);
+			char c = (char)_mhk->readByte();
+			while (c != 0) {
+				_types[i].nameTable.entries[j].name += c;
+				c = (char)_mhk->readByte();
+			}
+
+			debug (3, "Name = \'%s\'", _types[i].nameTable.entries[j].name.c_str());
+
+			// Get back to next entry
+			_mhk->seek(pos);
+		}
+
+		// Return to next TypeTable entry
+		_mhk->seek(_rsrc.abs_offset + (i + 1) * 8 + 4);
+
+		debug (3, "\n");
+	}
+
+	_mhk->seek(_rsrc.abs_offset + _rsrc.file_table_offset);
+	_fileTableAmount = _mhk->readUint32BE();
+	_fileTable = new FileTable[_fileTableAmount];
+                
+	for (uint32 i = 0; i < _fileTableAmount; i++) {
+		_fileTable[i].offset = _mhk->readUint32BE();
+		_fileTable[i].dataSize = _mhk->readUint16BE();
+		_fileTable[i].dataSize += _mhk->readByte() << 16; // Get bits 15-24 of dataSize too
+		_fileTable[i].flags = _mhk->readByte();
+		_fileTable[i].unk = _mhk->readUint16BE();
+		
+		// Add in another 3 bits for file size from the flags.
+		// The flags are useless to us except for doing this ;)
+		_fileTable[i].dataSize += (_fileTable[i].flags & 7) << 24;
+
+		debug (4, "File[%02x]: Offset = %08x  DataSize = %07x  Flags = %02x  Unk = %04x", i, _fileTable[i].offset, _fileTable[i].dataSize, _fileTable[i].flags, _fileTable[i].unk);
+	}
+}
+
+bool MohawkFile::hasResource(uint32 tag, uint16 id) {
+	if (!_mhk)
+		return false;
+
+	int16 typeIndex = getTypeIndex(tag);
+
+	if (typeIndex < 0)
+		return false;
+
+	return (getIdIndex(typeIndex, id) >= 0);
+}
+
+Common::SeekableReadStream *MohawkFile::getRawData(uint32 tag, uint16 id) {
+	if (!_mhk)
+		error ("MohawkFile::getRawData - No File in Use");
+
+	int16 typeIndex = getTypeIndex(tag);
+
+	if (typeIndex < 0)
+		error ("Could not find a tag of \'%s\' in file \'%s\'", tag2str(tag), _curFile.c_str());
+
+	int16 idIndex = getIdIndex(typeIndex, id);
+
+	if (idIndex < 0)
+		error ("Could not find \'%s\' %04x in file \'%s\'", tag2str(tag), id, _curFile.c_str());
+
+	// Note: the fileTableIndex is based off 1, not 0. So, subtract 1
+	uint16 fileTableIndex = _types[typeIndex].resTable.entries[idIndex].index - 1;
+	
+	// WORKAROUND: tMOV resources pretty much ignore the size part of the file table,
+	// as the original just passed the full Mohawk file to QuickTime and the offset.
+	// We need to do this because of the way Mohawk is set up (this is much more "proper"
+	// than passing _mhk at the right offset). We may want to do that in the future, though.
+	if (_types[typeIndex].tag == ID_TMOV) {
+		if (fileTableIndex == _fileTableAmount)
+			return new Common::SeekableSubReadStream(_mhk, _fileTable[fileTableIndex].offset, _mhk->size());
+		else
+			return new Common::SeekableSubReadStream(_mhk, _fileTable[fileTableIndex].offset, _fileTable[fileTableIndex + 1].offset);
+	}
+	
+	return new Common::SeekableSubReadStream(_mhk, _fileTable[fileTableIndex].offset, _fileTable[fileTableIndex].offset + _fileTable[fileTableIndex].dataSize);
+}
+
+void OldMohawkFile::open(Common::SeekableReadStream *stream) {
+	close();
+	_mhk = stream;
+	
+	// This is for the "old" Mohawk resource format used in some older
+	// Living Books. It is very similar, just missing the MHWK tag and
+	// some other minor differences, especially with the file table
+	// being merged into the resource table.
+	
+	uint32 headerSize = _mhk->readUint32BE();
+	
+	// NOTE: There are differences besides endianness! (Subtle changes,
+	// but different).
+	
+	if (headerSize == 6) { // We're in Big Endian mode (Macintosh)
+		_mhk->readUint16BE(); // Resource Table Size
+		_typeTable.resource_types = _mhk->readUint16BE();
+		_types = new OldType[_typeTable.resource_types];
+		
+		debug (0, "Old Mohawk File (Macintosh): Number of Resource Types = %04x", _typeTable.resource_types);
+		
+		for (uint16 i = 0; i < _typeTable.resource_types; i++) {
+			_types[i].tag = _mhk->readUint32BE();
+			_types[i].resource_table_offset = (uint16)_mhk->readUint32BE() + 6;
+			_mhk->readUint32BE(); // Unknown (always 0?)
+			
+			debug (3, "Type[%02d]: Tag = \'%s\'  ResTable Offset = %04x", i, tag2str(_types[i].tag), _types[i].resource_table_offset);
+
+			uint32 oldPos = _mhk->pos();
+			
+			// Resource Table/File Table
+			_mhk->seek(_types[i].resource_table_offset);
+			_types[i].resTable.resources = _mhk->readUint16BE();
+			_types[i].resTable.entries = new OldType::ResourceTable::Entries[_types[i].resTable.resources];
+			
+			for (uint16 j = 0; j < _types[i].resTable.resources; j++) {
+				_types[i].resTable.entries[j].id = _mhk->readUint16BE();
+				_types[i].resTable.entries[j].offset = _mhk->readUint32BE();
+				_types[i].resTable.entries[j].size = _mhk->readByte() << 16;
+				_types[i].resTable.entries[j].size += _mhk->readUint16BE();
+				_mhk->skip(5); // Unknown (always 0?)
+				
+				debug (4, "Entry[%02x]: ID = %04x (%d)\tOffset = %08x, Size = %08x", j, _types[i].resTable.entries[j].id, _types[i].resTable.entries[j].id, _types[i].resTable.entries[j].offset, _types[i].resTable.entries[j].size);
+			}
+			
+			_mhk->seek(oldPos);
+			debug (3, "\n");
+		}
+	} else if (SWAP_BYTES_32(headerSize) == 6) { // We're in Little Endian mode (Windows)
+		_mhk->readUint16LE(); // Resource Table Size
+		_typeTable.resource_types = _mhk->readUint16LE();
+		_types = new OldType[_typeTable.resource_types];
+		
+		debug (0, "Old Mohawk File (Windows): Number of Resource Types = %04x", _typeTable.resource_types);
+		
+		for (uint16 i = 0; i < _typeTable.resource_types; i++) {
+			_types[i].tag = _mhk->readUint32LE();
+			_types[i].resource_table_offset = _mhk->readUint16LE() + 6;
+			_mhk->readUint16LE(); // Unknown (always 0?)
+			
+			debug (3, "Type[%02d]: Tag = \'%s\'  ResTable Offset = %04x", i, tag2str(_types[i].tag), _types[i].resource_table_offset);
+			
+			uint32 oldPos = _mhk->pos();
+			
+			// Resource Table/File Table
+			_mhk->seek(_types[i].resource_table_offset);
+			_types[i].resTable.resources = _mhk->readUint16LE();
+			_types[i].resTable.entries = new OldType::ResourceTable::Entries[_types[i].resTable.resources];
+			
+			for (uint16 j = 0; j < _types[i].resTable.resources; j++) {
+				_types[i].resTable.entries[j].id = _mhk->readUint16LE();
+				_types[i].resTable.entries[j].offset = _mhk->readUint32LE();
+				_types[i].resTable.entries[j].size = _mhk->readUint16LE();
+				_mhk->readUint32LE(); // Unknown (always 0?)
+				
+				debug (4, "Entry[%02x]: ID = %04x (%d)\tOffset = %08x, Size = %08x", j, _types[i].resTable.entries[j].id, _types[i].resTable.entries[j].id, _types[i].resTable.entries[j].offset, _types[i].resTable.entries[j].size); 
+			}
+			
+			_mhk->seek(oldPos);
+			debug (3, "\n");
+		}
+	} else
+		error("Could not determine type of Old Mohawk resource");
+
+}
+
+Common::SeekableReadStream *OldMohawkFile::getRawData(uint32 tag, uint16 id) {
+	if (!_mhk)
+		error ("OldMohawkFile::getRawData - No File in Use");
+
+	int16 typeIndex = getTypeIndex(tag);
+
+	if (typeIndex < 0)
+		error ("Could not find a tag of \'%s\' in file \'%s\'", tag2str(tag), _curFile.c_str());
+
+	int16 idIndex = getIdIndex(typeIndex, id);
+
+	if (idIndex < 0)
+		error ("Could not find \'%s\' %04x in file \'%s\'", tag2str(tag), id, _curFile.c_str());
+
+	return new Common::SeekableSubReadStream(_mhk, _types[typeIndex].resTable.entries[idIndex].offset, _types[typeIndex].resTable.entries[idIndex].offset + _types[typeIndex].resTable.entries[idIndex].size);
+}
+
+}	// End of namespace Mohawk
diff --git a/engines/mohawk/file.h b/engines/mohawk/file.h
new file mode 100644
index 0000000000..2a498d0e03
--- /dev/null
+++ b/engines/mohawk/file.h
@@ -0,0 +1,257 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "common/scummsys.h"
+#include "common/endian.h"
+#include "common/file.h"
+#include "common/str.h"
+
+#include "mohawk/sound.h"
+
+#ifndef MOHAWK_FILE_H
+#define MOHAWK_FILE_H
+
+namespace Mohawk {
+
+// Main FourCC's
+#define ID_MHWK MKID_BE('MHWK') // Main FourCC
+#define ID_RSRC MKID_BE('RSRC') // Resource Directory Tag
+
+// Myst Resource FourCC's
+#define ID_CLRC MKID_BE('CLRC') // Cursor Hotspots
+#define ID_EXIT MKID_BE('EXIT') // Card Exit Scripts
+#define ID_HINT MKID_BE('HINT') // Specifies Cursors in What Area
+#define ID_INIT MKID_BE('INIT') // Card Entrance Scripts
+#define ID_MSND MKID_BE('MSND') // Standard Mohawk Sound
+#define ID_RLST MKID_BE('RLST') // Resource List, Specifies HotSpots
+#define ID_RSFL MKID_BE('RSFL') // ??? (system.dat only)
+#define ID_VIEW MKID_BE('VIEW') // Card Details
+#define ID_WDIB MKID_BE('WDIB') // LZ-Compressed Windows Bitmap
+
+// Myst Masterpiece Edition Resource FourCC's (In addition to Myst FourCC's)
+#define ID_HELP MKID_BE('HELP') // Help Chunk
+#define ID_MJMP MKID_BE('MJMP') // MSND Jumps (To reduce MSND duplication)
+#define ID_PICT MKID_BE('PICT') // JPEG/PICT Image
+
+// Riven Resource FourCC's
+#define ID_BLST MKID_BE('BLST') // Card Hotspot Enabling Lists
+#define ID_CARD MKID_BE('CARD') // Card Scripts
+#define ID_FLST MKID_BE('FLST') // Card SFXE Lists
+#define ID_HSPT MKID_BE('HSPT') // Card Hotspots
+#define ID_MLST MKID_BE('MLST') // Card Movie Lists
+#define ID_NAME MKID_BE('NAME') // Object Names
+#define ID_PLST MKID_BE('PLST') // Card Picture Lists
+#define ID_RMAP MKID_BE('RMAP') // Card Code
+#define ID_SFXE MKID_BE('SFXE') // Water Effect Animations
+#define ID_SLST MKID_BE('SLST') // Card Ambient Sound Lists
+#define ID_TMOV MKID_BE('tMOV') // Game Movie
+
+// Riven Saved Game FourCC's
+#define ID_VARS MKID_BE('VARS') // Saved Game Variable Values
+#define ID_VERS MKID_BE('VERS') // Version Info
+#define ID_ZIPS MKID_BE('ZIPS') // Zip Mode Status
+
+// Zoombini Resource FourCC's
+#define ID_SND  MKID_BE('\0SND') // Standard Mohawk Sound
+#define ID_CURS MKID_BE('CURS') // Cursor?
+#define ID_SCRB MKID_BE('SCRB') // ???
+#define ID_SCRS MKID_BE('SCRS') // ???
+#define ID_NODE MKID_BE('NODE') // ???
+#define ID_PATH MKID_BE('PATH') // ???
+#define ID_SHPL MKID_BE('SHPL') // ???
+
+// Living Books Resource FourCC's
+#define ID_TCUR MKID_BE('tCUR') // Cursor
+#define ID_BITL MKID_BE('BITL') // ???
+#define ID_CTBL MKID_BE('CTBL') // Color Table?
+#define ID_SCRP MKID_BE('SCRP') // Script?
+#define ID_SPR  MKID_BE('SPR#') // Sprites?
+#define ID_VRSN MKID_BE('VRSN') // Version
+#define ID_ANI  MKID_BE('ANI ') // Animation?
+#define ID_SHP  MKID_BE('SHP#') // ???
+
+// JamesMath Resource FourCC's
+#define ID_TANM MKID_BE('tANM') // Animation?
+#define ID_TMFO MKID_BE('tMFO') // ???
+
+// Mohawk Wave Tags
+#define ID_WAVE MKID_BE('WAVE') // Game Sound (Third Tag)
+#define ID_ADPC MKID_BE('ADPC') // Game Sound Chunk
+#define ID_DATA MKID_BE('Data') // Game Sound Chunk
+#define ID_CUE  MKID_BE('Cue#') // Game Sound Chunk
+
+// Mohawk MIDI Tags
+#define ID_MIDI MKID_BE('MIDI') // Game Sound (Third Tag), instead of WAVE
+#define ID_PRG  MKID_BE('Prg#') // Midi Program?
+
+// Old Mohawk Resource FourCC's
+#define ID_WAV  MKID_BE('WAV ') // Old Sound Resource
+#define ID_BMAP MKID_BE('BMAP') // Standard Mohawk Bitmap
+
+// Common Resource FourCC's
+#define ID_TBMP MKID_BE('tBMP') // Standard Mohawk Bitmap
+#define ID_TWAV MKID_BE('tWAV') // Standard Mohawk Sound
+#define ID_TPAL MKID_BE('tPAL') // Standard Mohawk Palette
+#define ID_TCNT MKID_BE('tCNT') // ??? (CSWorld, CSAmtrak, JamesMath)
+#define ID_TSCR MKID_BE('tSCR') // Script? Screen? (CSWorld, CSAmtrak, Treehouse)
+#define ID_STRL MKID_BE('STRL') // String List (Zoombini, CSWorld, CSAmtrak)
+#define ID_TBMH MKID_BE('tBMH') // Standard Mohawk Bitmap
+#define ID_TMID MKID_BE('tMID') // Standard Mohawk MIDI
+#define ID_REGS MKID_BE('REGS') // ??? (Zoombini, Treehouse)
+#define ID_BYTS MKID_BE('BYTS') // Database Entry (CSWorld, CSAmtrak)
+#define ID_INTS MKID_BE('INTS') // ??? (CSWorld, CSAmtrak)
+#define ID_BBOX MKID_BE('BBOX') // Boxes? (CSWorld, CSAmtrak)
+#define ID_SYSX MKID_BE('SYSX') // MIDI Sysex
+
+struct FileTable {
+	uint32 offset;
+	uint32 dataSize; // Really 27 bits
+	byte flags; // Mostly useless except for the bottom 3 bits which are part of the size
+	uint16 unk; // Always 0
+};
+
+struct Type {
+	Type() { resTable.entries = NULL; nameTable.entries = NULL; }
+	~Type() { delete[] resTable.entries; delete[] nameTable.entries; }
+
+	//Type Table
+	uint32 tag;
+	uint16 resource_table_offset;
+	uint16 name_table_offset;
+		
+	struct ResourceTable {
+		uint16 resources;
+		struct Entries {
+			uint16 id;
+			uint16 index;
+		} *entries;
+	} resTable;
+		
+	struct NameTable {
+		uint16 num;
+		struct Entries {
+			uint16 offset;
+			uint16 index;
+			// Name List
+			Common::String name;
+		} *entries;
+	} nameTable;
+};
+
+struct TypeTable {
+	uint16 name_offset;
+	uint16 resource_types;
+};
+
+struct RSRC_Header {
+	uint32 size;
+	uint32 filesize;
+	uint32 abs_offset;
+	uint16 file_table_offset;
+	uint16 file_table_size;
+};
+
+class MohawkFile {
+public:
+	MohawkFile();
+	virtual ~MohawkFile() { close(); }
+	
+	void open(Common::String filename);
+	virtual void open(Common::SeekableReadStream *stream);
+	void close();
+	
+	bool hasResource(uint32 tag, uint16 id);
+	virtual Common::SeekableReadStream *getRawData(uint32 tag, uint16 id);
+
+protected:
+	Common::SeekableReadStream *_mhk;
+	TypeTable _typeTable;
+	Common::String _curFile;
+	
+private:
+	bool _hasData;
+	uint32 _fileSize;
+	RSRC_Header _rsrc;
+	Type *_types;
+	FileTable *_fileTable;
+	uint16 _nameTableAmount;
+	uint16 _resourceTableAmount;
+	uint16 _fileTableAmount;
+
+	virtual int16 getTypeIndex(uint32 tag) {
+		for (uint16 i = 0; i < _typeTable.resource_types; i++)
+			if (_types[i].tag == tag)
+				return i;
+		return -1;	// not found
+	}
+
+	virtual int16 getIdIndex(int16 typeIndex, uint16 id) {
+		for (uint16 i = 0; i < _types[typeIndex].resTable.resources; i++)
+			if (_types[typeIndex].resTable.entries[i].id == id)
+				return i;
+		return -1;	// not found
+	}
+};
+
+class OldMohawkFile : public MohawkFile {
+public:
+	OldMohawkFile() : MohawkFile() {}
+	~OldMohawkFile() {}
+	
+	void open(Common::SeekableReadStream *stream);
+	Common::SeekableReadStream *getRawData(uint32 tag, uint16 id);
+	
+private:
+	struct OldType {
+		uint32 tag;
+		uint16 resource_table_offset;
+		struct ResourceTable {
+			uint16 resources;
+			struct Entries {
+				uint16 id;
+				uint32 offset;
+				uint32 size;
+			} *entries;
+		} resTable;
+	} *_types;
+	
+	int16 getTypeIndex(uint32 tag) {
+		for (uint16 i = 0; i < _typeTable.resource_types; i++)
+			if (_types[i].tag == tag)
+				return i;
+		return -1;	// not found
+	}
+	
+	int16 getIdIndex(int16 typeIndex, uint16 id) {
+		for (uint16 i = 0; i < _types[typeIndex].resTable.resources; i++)
+			if (_types[typeIndex].resTable.entries[i].id == id)
+				return i;
+		return -1;	// not found
+	}
+};
+
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/graphics.cpp b/engines/mohawk/graphics.cpp
new file mode 100644
index 0000000000..ee9fe702de
--- /dev/null
+++ b/engines/mohawk/graphics.cpp
@@ -0,0 +1,739 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "mohawk/file.h"
+#include "mohawk/graphics.h"
+#include "mohawk/myst.h"
+#include "mohawk/riven.h"
+#include "mohawk/riven_cursors.h"
+
+#include "graphics/cursorman.h"
+#include "graphics/primitives.h"
+#include "gui/message.h"
+
+namespace Mohawk {
+
+Graphics::Surface *ImageData::getSurface() {
+	Graphics::PixelFormat pixelFormat = g_system->getScreenFormat();
+	Graphics::Surface *surface = new Graphics::Surface();
+	surface->create(_surface->w, _surface->h, pixelFormat.bytesPerPixel);
+	
+	if (_surface->bytesPerPixel == 1) {
+		assert(_palette);
+
+		for (uint16 i = 0; i < _surface->h; i++) {
+			for (uint16 j = 0; j < _surface->w; j++) {
+				byte palIndex = *((byte *)_surface->pixels + i * _surface->pitch + j);
+				byte r = _palette[palIndex * 4];
+				byte g = _palette[palIndex * 4 + 1];
+				byte b = _palette[palIndex * 4 + 2];
+				if (pixelFormat.bytesPerPixel == 2)
+					*((uint16 *)surface->getBasePtr(j, i)) = pixelFormat.RGBToColor(r, g, b);
+				else
+					*((uint32 *)surface->getBasePtr(j, i)) = pixelFormat.RGBToColor(r, g, b);
+			}
+		}
+	} else
+		memcpy(surface->pixels, _surface->pixels, _surface->w * _surface->h * _surface->bytesPerPixel);
+	
+	return surface;
+}
+
+MystGraphics::MystGraphics(MohawkEngine_Myst* vm) : _vm(vm) {
+	_bmpDecoder = new MystBitmap();
+	
+	// The original version of Myst could run in 8bpp color too.
+	// However, it dithered videos to 8bpp and they looked considerably
+	// worse (than they already did :P). So we're not even going to
+	// support 8bpp mode in Myst (Myst ME required >8bpp anyway).
+	initGraphics(544, 333, true, NULL); // What an odd screen size!
+	
+	_pixelFormat = _vm->_system->getScreenFormat();
+	
+	if (_pixelFormat.bytesPerPixel == 1)
+		error("Myst requires greater than 256 colors to run");
+	
+	if (_vm->getFeatures() & GF_ME) {		
+		_jpegDecoder = new MystJPEG();
+		_pictDecoder = new MystPICT(_jpegDecoder);
+	} else {
+		_jpegDecoder = NULL;
+		_pictDecoder = NULL;
+	}
+	
+	_pictureFile.entries = NULL;
+}
+
+MystGraphics::~MystGraphics() {
+	delete _bmpDecoder;
+	delete _jpegDecoder;
+	delete _pictDecoder;
+}
+
+static const char* picFileNames[] = {
+	"CHpics",
+	"",
+	"DUpics",
+	"INpics",
+	"MEpics",
+	"MYpics",
+	"SEpics",
+	"STpics",
+	""
+};
+
+void MystGraphics::loadExternalPictureFile(uint16 stack) {
+	if (_vm->getPlatform() != Common::kPlatformMacintosh)
+		return;
+		
+	if (_pictureFile.picFile.isOpen())
+		_pictureFile.picFile.close();
+	delete[] _pictureFile.entries;
+		
+	if (!scumm_stricmp(picFileNames[stack], ""))
+		return;
+	
+	if (!_pictureFile.picFile.open(picFileNames[stack]))
+		error ("Could not open external picture file \'%s\'", picFileNames[stack]);
+		
+	_pictureFile.pictureCount = _pictureFile.picFile.readUint32BE();
+	_pictureFile.entries = new PictureFile::PictureEntry[_pictureFile.pictureCount];
+	
+	for (uint32 i = 0; i < _pictureFile.pictureCount; i++) {
+		_pictureFile.entries[i].offset = _pictureFile.picFile.readUint32BE();
+		_pictureFile.entries[i].size = _pictureFile.picFile.readUint32BE();
+		_pictureFile.entries[i].id = _pictureFile.picFile.readUint16BE();
+		_pictureFile.entries[i].type = _pictureFile.picFile.readUint16BE();
+		_pictureFile.entries[i].width = _pictureFile.picFile.readUint16BE();
+		_pictureFile.entries[i].height = _pictureFile.picFile.readUint16BE();
+	}
+}
+
+void MystGraphics::copyImageSectionToScreen(uint16 image, Common::Rect src, Common::Rect dest) {
+	// Clip the destination rect to the screen
+	if (dest.right > _vm->_system->getWidth() || dest.bottom > _vm->_system->getHeight())
+		dest.debugPrint(4, "Clipping destination rect to the screen:");
+
+	dest.right = CLIP<int>(dest.right, 0, _vm->_system->getWidth());
+	dest.bottom = CLIP<int>(dest.bottom, 0, _vm->_system->getHeight());
+	
+	Graphics::Surface *surface = NULL;
+
+
+	// Myst ME uses JPEG/PICT images instead of compressed Windows Bitmaps for room images,
+	// though there are a few weird ones that use that format. For further nonsense with images,
+	// the Macintosh version stores images in external "picture files." We check them before
+	// going to check for a PICT resource.
+	if (_vm->getFeatures() & GF_ME && _vm->getPlatform() == Common::kPlatformMacintosh && _pictureFile.picFile.isOpen()) {
+		for (uint32 i = 0; i < _pictureFile.pictureCount; i++)
+			if (_pictureFile.entries[i].id == image) {
+				if (_pictureFile.entries[i].type == 0)
+					surface = _jpegDecoder->decodeImage(new Common::SeekableSubReadStream(&_pictureFile.picFile, _pictureFile.entries[i].offset, _pictureFile.entries[i].offset + _pictureFile.entries[i].size));
+				else if (_pictureFile.entries[i].type == 1)
+					surface = _pictDecoder->decodeImage(new Common::SeekableSubReadStream(&_pictureFile.picFile, _pictureFile.entries[i].offset, _pictureFile.entries[i].offset + _pictureFile.entries[i].size));
+				else
+					error ("Unknown Picture File type %d", _pictureFile.entries[i].type);
+				break;
+			}
+	}
+
+	// We're not using the external Mac files, so it's time to delve into the main Mohawk
+	// archives. However, we still don't know if it's a PICT or WDIB resource. If it's Myst
+	// ME it's most likely a PICT, and if it's original it's definitely a WDIB. However,
+	// Myst ME throws us another curve ball in that PICT resources can contain WDIB's instead
+	// of PICT's.
+	if (!surface) {
+		bool isPict = false;
+		Common::SeekableReadStream *dataStream = NULL;
+
+		if (_vm->getFeatures() & GF_ME && _vm->hasResource(ID_PICT, image)) {
+			// The PICT resource exists. However, it could still contain a MystBitmap
+			// instead of a PICT image...
+			dataStream = _vm->getRawData(ID_PICT, image);
+
+			// Here we detect whether it's really a PICT or a WDIB. Since a MystBitmap
+			// would be compressed, there's no way to detect for the BM without a hack.
+			// So, we search for the PICT version opcode for detection.
+			dataStream->seek(512 + 10); // 512 byte pict header
+			isPict = (dataStream->readUint32BE() == 0x001102FF);
+			dataStream->seek(0);
+		} else // No PICT, so the WDIB must exist. Let's go grab it.
+			dataStream = _vm->getRawData(ID_WDIB, image);
+
+		if (isPict)
+			surface = _pictDecoder->decodeImage(dataStream);
+		else {
+			ImageData *imageData = _bmpDecoder->decodeImage(dataStream);
+			surface = imageData->getSurface();
+			delete imageData;
+		}
+	}
+	
+	debug(3, "Image Blit:");
+	debug(3, "src.x: %d", src.left); 
+	debug(3, "src.y: %d", src.top);
+	debug(3, "dest.x: %d", dest.left);
+	debug(3, "dest.y: %d", dest.top);
+	debug(3, "width: %d", src.width());
+	debug(3, "height: %d", src.height());
+	
+	if (surface) {
+		uint16 width = MIN<int>(surface->w, dest.width());
+		uint16 height = MIN<int>(surface->h, dest.height());
+		_vm->_system->copyRectToScreen((byte *)surface->getBasePtr(src.left, src.top), surface->pitch, dest.left, dest.top, width, height);
+		surface->free();
+		delete surface;
+	}
+	
+	// FIXME: Remove this and update only at certain points
+	_vm->_system->updateScreen();
+}
+
+void MystGraphics::copyImageToScreen(uint16 image, Common::Rect dest) {
+	copyImageSectionToScreen(image, Common::Rect(0, 0, 544, 333), dest);
+}
+
+void MystGraphics::showCursor(void) {
+	CursorMan.showMouse(true);
+	_vm->_needsUpdate = true;
+}
+
+void MystGraphics::hideCursor(void) {
+	CursorMan.showMouse(false);
+	_vm->_needsUpdate = true;
+}
+
+void MystGraphics::changeCursor(uint16 cursor) {
+	// Both Myst and Myst ME use the "MystBitmap" format for cursor images.
+	ImageData *data = _bmpDecoder->decodeImage(_vm->getRawData(ID_WDIB, cursor));
+	Common::SeekableReadStream *clrcStream = _vm->getRawData(ID_CLRC, cursor);
+	uint16 hotspotX = clrcStream->readUint16LE();
+	uint16 hotspotY = clrcStream->readUint16LE();
+	delete clrcStream;
+
+	// Myst ME stores some cursors as 24bpp images instead of 8bpp
+	if (data->_surface->bytesPerPixel == 1) {
+		CursorMan.replaceCursor((byte *)data->_surface->pixels, data->_surface->w, data->_surface->h, hotspotX, hotspotY, 0);
+		CursorMan.replaceCursorPalette(data->_palette, 0, 256);
+	} else
+		CursorMan.replaceCursor((byte *)data->_surface->pixels, data->_surface->w, data->_surface->h, hotspotX, hotspotY, 0xFFFFFFFF, 1, &_pixelFormat);
+
+	_vm->_needsUpdate = true;
+}
+
+void MystGraphics::drawRect(Common::Rect rect, bool active) {
+	// Useful with debugging. Shows where hotspots are on the screen and whether or not they're active.
+	if (rect.left < 0 || rect.top < 0 || rect.right > 544 || rect.bottom > 333 || !rect.isValidRect() || rect.width() == 0 || rect.height() == 0)
+		return;
+
+	Graphics::Surface *screen = _vm->_system->lockScreen();
+
+	if (active)
+		screen->frameRect(rect, _pixelFormat.RGBToColor(0, 255, 0));
+	else
+		screen->frameRect(rect, _pixelFormat.RGBToColor(255, 0, 0));
+	
+	_vm->_system->unlockScreen();
+}
+
+RivenGraphics::RivenGraphics(MohawkEngine_Riven* vm) : _vm(vm) {
+	_bitmapDecoder = new MohawkBitmap();
+
+	// Give me the best you've got!
+	initGraphics(608, 436, true, NULL);
+	_pixelFormat = _vm->_system->getScreenFormat();
+	
+	if (_pixelFormat.bytesPerPixel == 1)
+		error("Riven requires greater than 256 colors to run");
+	
+	// The actual game graphics only take up the first 392 rows. The inventory
+	// occupies the rest of the screen and we don't use the buffer to hold that.
+	_mainScreen = new Graphics::Surface();
+	_mainScreen->create(608, 392, _pixelFormat.bytesPerPixel);
+	
+	_updatesEnabled = true;
+	_scheduledTransition = -1;	// no transition
+	_dirtyScreen = false;
+	_inventoryDrawn = false;
+}
+
+RivenGraphics::~RivenGraphics() {
+	_mainScreen->free();
+	delete _mainScreen;
+	delete _bitmapDecoder;
+}
+
+void RivenGraphics::copyImageToScreen(uint16 image, uint32 left, uint32 top, uint32 right, uint32 bottom) {
+	// First, decode the image and get the high color surface
+	ImageData *imageData = _bitmapDecoder->decodeImage(_vm->getRawData(ID_TBMP, image));
+	Graphics::Surface *surface = imageData->getSurface();
+	delete imageData;
+	
+	// Clip the width to fit on the screen. Fixes some images.
+	if (left + surface->w > 608)
+		surface->w = 608 - left;
+		
+	for (uint16 i = 0; i < surface->h; i++)
+		memcpy(_mainScreen->getBasePtr(left, i + top), surface->getBasePtr(0, i), surface->w * surface->bytesPerPixel);
+		
+	surface->free();
+	delete surface;
+	
+	_dirtyScreen = true;
+}
+
+void RivenGraphics::drawPLST(uint16 x) {
+	Common::SeekableReadStream* plst = _vm->getRawData(ID_PLST, _vm->getCurCard());
+	uint16 index, id, left, top, right, bottom;
+	uint16 recordCount = plst->readUint16BE();
+	
+	for (uint16 i = 0; i < recordCount; i++) {
+		index = plst->readUint16BE();
+		id = plst->readUint16BE();
+		left = plst->readUint16BE();
+		top = plst->readUint16BE();
+		right = plst->readUint16BE();
+		bottom = plst->readUint16BE();
+
+		// We are also checking here to make sure we haven't drawn the image yet on screen.
+		// This fixes problems with drawing PLST 1 twice and some other images twice. PLST
+		// 1 is sometimes not called by the scripts, so some cards don't appear if we don't
+		// draw PLST 1 each time. This "hack" is here to catch any PLST attempting to draw
+		// twice. There should never be a problem with doing it this way.
+		if (index == x && !(Common::find(_activatedPLSTs.begin(), _activatedPLSTs.end(), x) != _activatedPLSTs.end())) {
+			debug (0, "Drawing image %d", id);
+			copyImageToScreen(id, left, top, right, bottom);
+			_activatedPLSTs.push_back(x);
+			break;
+		}
+	}
+
+	delete plst;
+}
+
+void RivenGraphics::updateScreen() {
+	if (_updatesEnabled) {
+		_vm->runUpdateScreenScript();
+		
+		if (_dirtyScreen) {
+			_activatedPLSTs.clear();
+			
+			// Copy to screen if there's no transition. Otherwise transition. ;)
+			if (_scheduledTransition < 0)
+				_vm->_system->copyRectToScreen((byte *)_mainScreen->pixels, _mainScreen->pitch, 0, 0, _mainScreen->w, _mainScreen->h);
+			else
+				runScheduledTransition();
+			
+			// Finally, update the screen.
+			_vm->_system->updateScreen();
+			_dirtyScreen = false;
+		}
+	}
+}
+
+void RivenGraphics::scheduleWaterEffect(uint16 sfxeID) {
+	Common::SeekableReadStream *sfxeStream = _vm->getRawData(ID_SFXE, sfxeID);
+
+	if (sfxeStream->readUint16BE() != 'SL')
+		error ("Unknown sfxe tag");
+	
+	// Read in header info
+	SFXERecord sfxeRecord;
+	sfxeRecord.frameCount = sfxeStream->readUint16BE();
+	uint32 offsetTablePosition = sfxeStream->readUint32BE();
+	sfxeRecord.rect.left = sfxeStream->readUint16BE();
+	sfxeRecord.rect.top = sfxeStream->readUint16BE();
+	sfxeRecord.rect.right = sfxeStream->readUint16BE();
+	sfxeRecord.rect.bottom = sfxeStream->readUint16BE();
+	sfxeRecord.speed = sfxeStream->readUint16BE();
+	// Skip the rest of the fields...
+	
+	// Read in offsets
+	sfxeStream->seek(offsetTablePosition);
+	uint32 *frameOffsets = new uint32[sfxeRecord.frameCount];
+	for (uint16 i = 0; i < sfxeRecord.frameCount; i++)
+		frameOffsets[i] = sfxeStream->readUint32BE();
+	sfxeStream->seek(frameOffsets[0]);
+	
+	// Read in the scripts
+	for (uint16 i = 0; i < sfxeRecord.frameCount; i++) 
+		sfxeRecord.frameScripts.push_back(sfxeStream->readStream((i == sfxeRecord.frameCount - 1) ? sfxeStream->size() - frameOffsets[i] : frameOffsets[i + 1] - frameOffsets[i]));
+	
+	// Set it to the first frame
+	sfxeRecord.curFrame = 0;
+	sfxeRecord.lastFrameTime = 0;
+	
+	delete[] frameOffsets;
+	delete sfxeStream;
+	_waterEffects.push_back(sfxeRecord);
+}
+
+void RivenGraphics::clearWaterEffects() {
+	_waterEffects.clear();
+}
+
+bool RivenGraphics::runScheduledWaterEffects() {
+	// Don't run the effect if it's disabled
+	if (*_vm->matchVarToString("waterenabled") == 0)
+		return false;
+
+	Graphics::Surface *screen = NULL;
+		
+	for (uint16 i = 0; i < _waterEffects.size(); i++) {
+		if (_vm->_system->getMillis() > _waterEffects[i].lastFrameTime + 1000 / _waterEffects[i].speed) {
+			// Lock the screen!
+			if (!screen)
+				screen = _vm->_system->lockScreen();
+				
+			// Make sure the script is at the starting point
+			Common::SeekableReadStream *script = _waterEffects[i].frameScripts[_waterEffects[i].curFrame];
+			if (script->pos() != 0)
+				script->seek(0);
+				
+			// Run script
+			uint16 curRow = 0;
+			for (uint16 op = script->readUint16BE(); op != 4; op = script->readUint16BE()) {
+				if (op == 1) {        // Increment Row
+					curRow++;
+				} else if (op == 3) { // Copy Pixels
+					uint16 dstLeft = script->readUint16BE();
+					uint16 srcLeft = script->readUint16BE();
+					uint16 srcTop = script->readUint16BE();
+					uint16 rowWidth = script->readUint16BE();
+					memcpy ((byte *)screen->getBasePtr(dstLeft, curRow + _waterEffects[i].rect.top), (byte *)_mainScreen->getBasePtr(srcLeft, srcTop), rowWidth * _pixelFormat.bytesPerPixel);
+				} else if (op != 4) { // End of Script
+					error ("Unknown SFXE opcode %d", op);
+				}
+			}
+			
+			// Increment frame
+			_waterEffects[i].curFrame++;
+			if (_waterEffects[i].curFrame == _waterEffects[i].frameCount)
+				_waterEffects[i].curFrame = 0;
+				
+			// Set the new time
+			_waterEffects[i].lastFrameTime = _vm->_system->getMillis();
+		}
+	}
+	
+	// Unlock the screen if it has been locked and return true to update the screen
+	if (screen) {
+		_vm->_system->unlockScreen();
+		return true;
+	}
+	
+	return false;
+}
+
+void RivenGraphics::scheduleTransition(uint16 id, Common::Rect rect) {
+	_scheduledTransition = id;
+	_transitionRect = rect;
+}
+
+void RivenGraphics::runScheduledTransition() {
+	if (_scheduledTransition < 0) // No transition is scheduled
+		return;
+		
+	// TODO: There's a lot to be done here...
+	
+	// Note: Transitions 0-11 are actual transitions, but none are used in-game.
+	// There's no point in implementing them if they're not used. These extra
+	// transitions were found by hacking scripts.
+
+	switch (_scheduledTransition) {
+		case 12: // Pan Left
+			warning ("STUB: Pan left");
+			break;
+		case 13: // Pan Right
+			warning ("STUB: Pan right");
+			break;
+		case 14: // Pan Up
+			warning ("STUB: Pan up");
+			break;
+		case 15: // Pan Down
+			warning ("STUB: Pan down");
+			break;
+		case 16: // Dissolve
+		case 17: // Dissolve (tspit CARD 155)
+			warning ("STUB: Dissolve");
+			break;
+		default:
+			if (_scheduledTransition < 12)
+				error ("Found unused transition %d", _scheduledTransition);
+			else
+				error ("Found unknown transition %d", _scheduledTransition);
+	}
+	
+	// For now, just copy the image to screen without doing any transition.
+	_vm->_system->copyRectToScreen((byte *)_mainScreen->pixels, _mainScreen->pitch, 0, 0, _mainScreen->w, _mainScreen->h);
+	_vm->_system->updateScreen();
+
+	_scheduledTransition = -1; // Clear scheduled transition
+}
+
+// TODO: Marble Cursors/Palettes
+void RivenGraphics::changeCursor(uint16 num) {
+	// All of Riven's cursors are hardcoded. See riven_cursors.h for these definitions.
+
+	switch (num) {
+		case 1002:
+			// Zip Mode
+			CursorMan.replaceCursor(zipModeCursor, 16, 16, 8, 8, 0);
+			CursorMan.replaceCursorPalette(zipModeCursorPalette, 1, ARRAYSIZE(zipModeCursorPalette) / 4);
+			break;
+		case 2003:
+			// Hand Over Object
+			CursorMan.replaceCursor(objectHandCursor, 16, 16, 8, 8, 0);
+			CursorMan.replaceCursorPalette(handCursorPalette, 1, ARRAYSIZE(handCursorPalette) / 4);
+			break;
+		case 2004:
+			// Grabbing/Using Object
+			CursorMan.replaceCursor(grabbingHandCursor, 13, 13, 6, 6, 0);
+			CursorMan.replaceCursorPalette(handCursorPalette, 1, ARRAYSIZE(handCursorPalette) / 4);
+			break;
+		case 3000:
+			// Standard Hand
+			CursorMan.replaceCursor(standardHandCursor, 15, 16, 6, 0, 0);
+			CursorMan.replaceCursorPalette(handCursorPalette, 1, ARRAYSIZE(handCursorPalette) / 4);
+			break;
+		case 3001:
+			// Pointing Left
+			CursorMan.replaceCursor(pointingLeftCursor, 15, 13, 0, 3, 0);
+			CursorMan.replaceCursorPalette(handCursorPalette, 1, ARRAYSIZE(handCursorPalette) / 4);
+			break;
+		case 3002:
+			// Pointing Right
+			CursorMan.replaceCursor(pointingRightCursor, 15, 13, 14, 3, 0);
+			CursorMan.replaceCursorPalette(handCursorPalette, 1, ARRAYSIZE(handCursorPalette) / 4);
+			break;
+		case 3003:
+			// Pointing Down (Palm Up)
+			CursorMan.replaceCursor(pointingDownCursorPalmUp, 13, 16, 3, 15, 0);
+			CursorMan.replaceCursorPalette(handCursorPalette, 1, ARRAYSIZE(handCursorPalette) / 4);
+			break;
+		case 3004:
+			// Pointing Up (Palm Up)
+			CursorMan.replaceCursor(pointingUpCursorPalmUp, 13, 16, 3, 0, 0);
+			CursorMan.replaceCursorPalette(handCursorPalette, 1, ARRAYSIZE(handCursorPalette) / 4);
+			break;
+		case 3005:
+			// Pointing Left (Curved)
+			CursorMan.replaceCursor(pointingLeftCursorBent, 15, 13, 0, 5, 0);
+			CursorMan.replaceCursorPalette(handCursorPalette, 1, ARRAYSIZE(handCursorPalette) / 4);
+			break;
+		case 3006:
+			// Pointing Right (Curved)
+			CursorMan.replaceCursor(pointingRightCursorBent, 15, 13, 14, 5, 0);
+			CursorMan.replaceCursorPalette(handCursorPalette, 1, ARRAYSIZE(handCursorPalette) / 4);
+			break;
+		case 3007:
+			// Pointing Down (Palm Down)
+			CursorMan.replaceCursor(pointingDownCursorPalmDown, 15, 16, 7, 15, 0);
+			CursorMan.replaceCursorPalette(handCursorPalette, 1, ARRAYSIZE(handCursorPalette) / 4);
+			break;
+		case 4001:
+			// Red Marble
+			break;
+		case 4002:
+			// Orange Marble
+			break;
+		case 4003:
+			// Yellow Marble
+			break;
+		case 4004:
+			// Green Marble
+			break;
+		case 4005:
+			// Blue Marble
+			break;
+		case 4006:
+			// Purple Marble
+			break;
+		case 5000:
+			// Pellet
+			CursorMan.replaceCursor(pelletCursor, 8, 8, 4, 4, 0);
+			CursorMan.replaceCursorPalette(pelletCursorPalette, 1, ARRAYSIZE(pelletCursorPalette) / 4);
+			break;
+		case 9000:
+			// Hide Cursor
+			CursorMan.showMouse(false);
+			break;
+		default:
+			error ("Cursor %d does not exist!", num);
+	}
+	
+	if (num != 9000) // Show Cursor
+		CursorMan.showMouse(true);
+	
+	// Should help in cases where we need to hide the cursor immediately.
+	_vm->_system->updateScreen();
+}
+	
+void RivenGraphics::showInventory() {
+	// Don't redraw the inventory
+	if (_inventoryDrawn)
+		return;
+	
+	// Clear the inventory area
+	clearInventoryArea();
+	
+	// The demo doesn't have the inventory system and we don't want
+	// to show the inventory on setup screens or in other journals.
+	if (_vm->getFeatures() & GF_DEMO || _vm->getCurStack() == aspit)
+		return;
+		
+	// There are three books and three vars. However, there's only
+	// a possible two combinations. Either you have only Atrus'
+	// journal or you have all three books.
+	// bool hasAtrusBook = *_vm->matchVarToString("aatrusbook") != 0;
+	bool hasCathBook = *_vm->matchVarToString("acathbook") != 0;
+	// bool hasTrapBook = *_vm->matchVarToString("atrapbook") != 0;
+	
+	if (!hasCathBook) {
+		drawInventoryImage(101, atrusJournalRectSolo);
+	} else {
+		drawInventoryImage(101, atrusJournalRect);
+		drawInventoryImage(102, cathJournalRect);
+		drawInventoryImage(100, trapBookRect);
+	}
+	
+	_vm->_system->updateScreen();
+	_inventoryDrawn = true;
+}
+	
+void RivenGraphics::hideInventory() {
+	// Don't hide the inventory twice
+	if (!_inventoryDrawn)
+		return;
+		
+	// Clear the area
+	clearInventoryArea();
+	
+	_inventoryDrawn = false;
+}
+
+void RivenGraphics::clearInventoryArea() {
+	// Clear the inventory area
+	static const Common::Rect inventoryRect = Common::Rect(0, 392, 608, 436);
+
+	// Lock the screen
+	Graphics::Surface *screen = _vm->_system->lockScreen();
+
+	// Fill the inventory area with black
+	screen->fillRect(inventoryRect, _pixelFormat.RGBToColor(0, 0, 0));
+		
+	_vm->_system->unlockScreen();
+}
+
+void RivenGraphics::drawInventoryImage(uint16 id, Common::Rect rect) {
+	ImageData *imageData = _bitmapDecoder->decodeImage(_vm->getExtrasResource(ID_TBMP, id));
+	Graphics::Surface *surface = imageData->getSurface();
+	delete imageData;
+
+	_vm->_system->copyRectToScreen((byte *)surface->pixels, surface->pitch, rect.left, rect.top, surface->w, surface->h);
+
+	surface->free();
+	delete surface;
+}
+
+void RivenGraphics::drawRect(Common::Rect rect, bool active) {
+	// Useful with debugging. Shows where hotspots are on the screen and whether or not they're active.
+	Graphics::Surface *screen = _vm->_system->lockScreen();
+	
+	if (active)
+		screen->frameRect(rect, _pixelFormat.RGBToColor(0, 255, 0));
+	else
+		screen->frameRect(rect, _pixelFormat.RGBToColor(255, 0, 0));
+	
+	_vm->_system->unlockScreen();
+}
+
+LBGraphics::LBGraphics(MohawkEngine_LivingBooks *vm) : _vm(vm) {
+	_bmpDecoder = (_vm->getGameType() == GType_OLDLIVINGBOOKS) ? new OldMohawkBitmap() : new MohawkBitmap();
+	_palette = new byte[256 * 4];
+	memset(_palette, 0, 256 * 4);
+}
+
+LBGraphics::~LBGraphics() {
+	delete _bmpDecoder;
+	delete[] _palette;
+}
+
+void LBGraphics::copyImageToScreen(uint16 image, uint16 left, uint16 right) {
+	if (_vm->getGameType() == GType_OLDLIVINGBOOKS) {
+		// Drawing images in the old format isn't supported (yet)
+		ImageData *imageData = _bmpDecoder->decodeImage(_vm->wrapStreamEndian(ID_BMAP, image));
+		delete imageData;
+	} else {
+		ImageData *imageData = _bmpDecoder->decodeImage(_vm->getRawData(ID_TBMP, image));
+		imageData->_palette = _palette;
+		Graphics::Surface *surface = imageData->getSurface();
+		imageData->_palette = NULL; // Unset the palette so it doesn't get deleted
+		delete imageData;
+	
+		uint16 width = MIN<int>(surface->w, 640);
+		uint16 height = MIN<int>(surface->h, 480);
+		_vm->_system->copyRectToScreen((byte *)surface->pixels, surface->pitch, left, right, width, height);
+		surface->free();
+		delete surface;
+		
+		// FIXME: Remove this and update only at certain points
+		_vm->_system->updateScreen();
+	}
+}
+
+void LBGraphics::setPalette(uint16 id) {
+	// Old Living Books gamnes use the old CTBL-style palette format while newer
+	// games use the better tPAL format which can store partial palettes.
+
+	if (_vm->getGameType() == GType_OLDLIVINGBOOKS) {
+		Common::SeekableSubReadStreamEndian *ctblStream = _vm->wrapStreamEndian(ID_CTBL, id);
+		uint16 colorCount = ctblStream->readUint16();
+	
+		for (uint16 i = 0; i < colorCount; i++) {
+			_palette[i * 4] = ctblStream->readByte();
+			_palette[i * 4 + 1] = ctblStream->readByte();
+			_palette[i * 4 + 2] = ctblStream->readByte();
+			_palette[i * 4 + 3] = ctblStream->readByte();
+		}
+		
+		delete ctblStream;
+	} else {
+		Common::SeekableReadStream *tpalStream = _vm->getRawData(ID_TPAL, id);
+		uint16 colorStart = tpalStream->readUint16BE();
+		uint16 colorCount = tpalStream->readUint16BE();
+
+		for (uint16 i = colorStart; i < colorStart + colorCount; i++) {
+			_palette[i * 4] = tpalStream->readByte();
+			_palette[i * 4 + 1] = tpalStream->readByte();
+			_palette[i * 4 + 2] = tpalStream->readByte();
+			_palette[i * 4 + 3] = tpalStream->readByte();
+		}
+	
+		delete tpalStream;
+	}
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/graphics.h b/engines/mohawk/graphics.h
new file mode 100644
index 0000000000..be3a951148
--- /dev/null
+++ b/engines/mohawk/graphics.h
@@ -0,0 +1,202 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#ifndef MOHAWK_GRAPHICS_H
+#define MOHAWK_GRAPHICS_H
+
+#include "mohawk/bitmap.h"
+#include "mohawk/livingbooks.h"
+#include "mohawk/myst_jpeg.h"
+#include "mohawk/myst_pict.h"
+
+#include "common/file.h"
+
+namespace Mohawk {
+
+class MohawkEngine_Myst;
+class MohawkEngine_Riven;
+class MohawkBitmap;
+class MystBitmap;
+
+enum {
+	kRivenMainCursor = 3000,
+	kRivenPelletCursor = 5000
+};
+
+// 803-805 are animated, one large bmp which is in chunks
+// Other cursors (200, 300, 400, 500, 600, 700) are not the same in each stack
+enum {
+	kDefaultMystCursor = 100,				// The default hand
+	kWhitePageCursor = 800,					// Holding a white page
+	kRedPageCursor = 801,					// Holding a red page
+	kBluePageCursor = 802,					// Holding a blue page
+	// kDroppingWhitePageAnimCursor = 803,
+	// kDroppingRedPageAnimCursor = 804,
+	// kDroppingBluePageAnimCursor = 805,
+	kNewMatchCursor = 900,					// Match that has not yet been lit
+	kLitMatchCursor = 901,					// Match that's burning
+	kDeadMatchCursor = 902,					// Match that's been extinguished
+	kKeyCursor = 903, 						// Key in Lighthouse in Stoneship
+	kRotateClockwiseCursor = 904, 			// Rotate gear clockwise (boiler on Myst)
+	kRotateCounterClockwiseCursor = 905,	// Rotate gear counter clockwise (boiler on Myst)
+	kMystZipModeCursor = 999				// Zip Mode cursor
+};
+
+// A simple struct to hold necessary image info
+class ImageData {
+public:
+	ImageData() : _surface(0), _palette(0) {}
+	ImageData(Graphics::Surface *surface, byte *palette = NULL) : _surface(surface), _palette(palette) {}
+	~ImageData() {
+		if (_palette)
+			free(_palette);
+		if (_surface) {
+			_surface->free();
+			delete _surface;
+		}
+	}
+
+	// getSurface() will convert to the current screen format, if it's not already
+	// in that format. Makes it easy to support both 8bpp and 24bpp images.
+	Graphics::Surface *getSurface();
+
+	// These are still public in case the 8bpp surface needs to be accessed
+	Graphics::Surface *_surface;
+	byte *_palette;
+};
+
+class MystGraphics {
+public:
+	MystGraphics(MohawkEngine_Myst*);
+	~MystGraphics();
+	
+	void loadExternalPictureFile(uint16 stack);
+	void copyImageSectionToScreen(uint16 image, Common::Rect src, Common::Rect dest);
+	void copyImageToScreen(uint16 image, Common::Rect dest);
+	void showCursor(void);
+	void hideCursor(void);
+	void changeCursor(uint16);
+	
+	void drawRect(Common::Rect rect, bool active);
+private:
+	MohawkEngine_Myst *_vm;
+	MystBitmap *_bmpDecoder;
+	MystPICT *_pictDecoder;
+	MystJPEG *_jpegDecoder;
+	Graphics::PixelFormat _pixelFormat;
+	
+	struct PictureFile {
+		uint32 pictureCount;
+		struct PictureEntry {
+			uint32 offset;
+			uint32 size;
+			uint16 id;
+			uint16 type;
+			uint16 width;
+			uint16 height;
+			} *entries;
+
+		Common::File picFile;
+	} _pictureFile;
+};
+
+struct SFXERecord {
+	// Record values
+	uint16 frameCount;
+	Common::Rect rect;
+	uint16 speed;
+	Common::Array<Common::SeekableReadStream*> frameScripts;
+	
+	// Cur frame
+	uint16 curFrame;
+	uint32 lastFrameTime;
+};
+
+class RivenGraphics {
+public:
+	RivenGraphics(MohawkEngine_Riven *vm);
+	~RivenGraphics();
+	
+	void copyImageToScreen(uint16, uint32, uint32, uint32, uint32);
+	void updateScreen();
+	bool _updatesEnabled;
+	void changeCursor(uint16);
+	Common::Array<uint16> _activatedPLSTs;
+	void drawPLST(uint16 x);
+	void drawRect(Common::Rect rect, bool active);
+
+	// Water Effect
+	void scheduleWaterEffect(uint16);
+	void clearWaterEffects();
+	bool runScheduledWaterEffects();
+	
+	// Transitions
+	void scheduleTransition(uint16 id, Common::Rect rect = Common::Rect(0, 0, 608, 392));
+	void runScheduledTransition();
+	
+	// Inventory
+	void showInventory();
+	void hideInventory();
+
+private:
+	MohawkEngine_Riven *_vm;
+	MohawkBitmap *_bitmapDecoder;
+
+	// Water Effects
+	Common::Array<SFXERecord> _waterEffects;
+	
+	// Transitions
+	int16 _scheduledTransition;
+	Common::Rect _transitionRect;
+	
+	// Inventory
+	void clearInventoryArea();
+	void drawInventoryImage(uint16 id, Common::Rect rect);
+	bool _inventoryDrawn;
+	
+	// Screen Related
+	Graphics::Surface *_mainScreen;
+	bool _dirtyScreen;
+	Graphics::PixelFormat _pixelFormat;
+	byte findBlackIndex();
+};
+
+class LBGraphics {
+public:
+	LBGraphics(MohawkEngine_LivingBooks *vm);
+	~LBGraphics();
+
+	void copyImageToScreen(uint16 image, uint16 left = 0, uint16 top = 0);
+	void setPalette(uint16 id);
+
+private:
+	MohawkBitmap *_bmpDecoder;
+	MohawkEngine_LivingBooks *_vm;
+	byte *_palette;
+};
+
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/livingbooks.cpp b/engines/mohawk/livingbooks.cpp
new file mode 100644
index 0000000000..390a40cea9
--- /dev/null
+++ b/engines/mohawk/livingbooks.cpp
@@ -0,0 +1,324 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "mohawk/livingbooks.h"
+#include "mohawk/file.h"
+
+namespace Mohawk {
+
+MohawkEngine_LivingBooks::MohawkEngine_LivingBooks(OSystem *syst, const MohawkGameDescription *gamedesc) : MohawkEngine(syst, gamedesc) {
+	_needsUpdate = false;
+	_screenWidth = _screenHeight = 0;
+}
+
+MohawkEngine_LivingBooks::~MohawkEngine_LivingBooks() {
+	delete _console;
+	delete _gfx;
+	_bookInfoFile.clear();
+}
+
+Common::Error MohawkEngine_LivingBooks::run() {
+	MohawkEngine::run();
+
+	_console = new LivingBooksConsole(this);
+	_gfx = new LBGraphics(this);
+
+	// Load the book info from the detected file
+	loadBookInfo(getBookInfoFileName());
+
+	if (!_title.empty()) // Some games don't have the title stored
+		debug("Starting Living Books Title \'%s\'", _title.c_str());
+	if (!_copyright.empty())
+		debug("Copyright: %s", _copyright.c_str());
+
+	if (!_screenWidth || !_screenHeight)
+		error("Could not find xRes/yRes variables");
+
+	debug("Setting screen size to %dx%d", _screenWidth, _screenHeight);
+
+	// TODO: Eventually move this to a LivingBooksGraphics class or similar
+	initGraphics(_screenWidth, _screenHeight, true, NULL);
+
+	loadIntro();
+
+	debug(1, "Stack Version: %d", getResourceVersion());
+	
+	_gfx->setPalette(1000);
+	loadSHP(1000);
+	loadANI(1000);
+
+	// Code to Load Sounds For Debugging...
+	//for (byte i = 0; i < 30; i++)
+	//	_sound->playSound(1000+i);
+
+	Common::Event event;
+	while (!shouldQuit()) {
+		while (_eventMan->pollEvent(event)) {
+			switch (event.type) {
+				case Common::EVENT_MOUSEMOVE:
+					break;
+				case Common::EVENT_LBUTTONUP:
+					break;
+				case Common::EVENT_LBUTTONDOWN:
+					break;
+				case Common::EVENT_KEYDOWN:
+					switch (event.kbd.keycode) {
+						case Common::KEYCODE_d:
+							if (event.kbd.flags & Common::KBD_CTRL) {
+								_console->attach();
+								_console->onFrame();
+							}
+							break;
+						case Common::KEYCODE_SPACE:
+							pauseGame();
+							break;
+						default:
+							break;
+					}
+					break;
+				default:
+					break;
+			}
+		}
+
+		if (_needsUpdate) {
+			_system->updateScreen();
+			_needsUpdate = false;
+		}
+
+		// Cut down on CPU usage
+		_system->delayMillis(10);
+	}
+
+	return Common::kNoError;
+}
+
+void MohawkEngine_LivingBooks::loadBookInfo(Common::String filename) {
+	if (!_bookInfoFile.loadFromFile(filename))
+		error("Could not open %s as a config file", filename.c_str());
+
+	_title = getStringFromConfig("BookInfo", "title");
+	_copyright = getStringFromConfig("BookInfo", "copyright");
+
+	_numPages = getIntFromConfig("BookInfo", "nPages");
+	_numLanguages = getIntFromConfig("BookInfo", "nLanguages");
+	_screenWidth = getIntFromConfig("BookInfo", "xRes");
+	_screenHeight = getIntFromConfig("BookInfo", "yRes");
+	// nColors is here too, but it's always 256 anyway...
+	
+	// The later Living Books games add some more options:
+	//     - fNeedPalette                (always true?)
+	//     - fUse254ColorPalette         (always true?)
+	//     - nKBRequired                 (4096, RAM requirement?)
+	//     - fDebugWindow                (always 0?)
+}
+
+void MohawkEngine_LivingBooks::loadIntro() {
+	Common::String filename;
+
+	// We get to try for a few different names! Yay!
+	filename = getFileNameFromConfig("Intro", "Page1");
+
+	// Some store with .r, not sure why.
+	if (filename.empty())
+		filename = getFileNameFromConfig("Intro", "Page1.r");
+
+	if (!filename.empty() && Common::File::exists(filename)) {
+		MohawkFile *introFile = createMohawkFile();
+		introFile->open(filename);
+		_mhk.push_back(introFile);
+	}
+
+	filename = getFileNameFromConfig("Intro", "Page2");
+	
+	if (filename.empty())
+		filename = getFileNameFromConfig("Intro", "Page2.r");
+	
+	if (!filename.empty() && Common::File::exists(filename)) {
+		MohawkFile *coverFile = createMohawkFile();
+		coverFile->open(filename);
+		_mhk.push_back(coverFile);
+	}
+}
+
+// Only 1 VSRN resource per stack, Id 1000
+uint16 MohawkEngine_LivingBooks::getResourceVersion() {
+	Common::SeekableReadStream *versionStream = getRawData(ID_VRSN, 1000);
+
+	if (versionStream->size() != 2)
+		warning("Version Record size mismatch");
+
+	uint16 version = versionStream->readUint16BE();
+
+	delete versionStream;
+	return version;
+}
+
+// Multiple SHP# resource per stack.. Optional per Card?
+// This record appears to be a list structure of BMAP resource Ids..
+void MohawkEngine_LivingBooks::loadSHP(uint16 resourceId) {
+	Common::SeekableSubReadStreamEndian *shpStream = wrapStreamEndian(ID_SHP, resourceId);
+
+	if (shpStream->size() < 6)
+		warning("SHP Record size too short");
+
+	if (shpStream->readUint16() != 3)
+		warning("SHP Record u0 not 3");
+
+	if (shpStream->readUint16() != 0)
+		warning("SHP Record u1 not 0");
+
+	uint16 idCount = shpStream->readUint16();
+	debug(1, "SHP: idCount: %d", idCount);
+
+	if (shpStream->size() != (idCount * 2) + 6)
+		warning("SHP Record size mismatch");
+
+	uint16 *idValues = new uint16[idCount];
+	for (uint16 i = 0; i < idCount; i++) {
+		idValues[i] = shpStream->readUint16();
+		debug(1, "SHP: BMAP Resource Id %d: %d", i, idValues[i]);
+	}
+
+	delete[] idValues;
+	delete shpStream;
+}
+
+// Multiple ANI resource per stack.. Optional per Card?
+void MohawkEngine_LivingBooks::loadANI(uint16 resourceId) {
+	Common::SeekableSubReadStreamEndian *aniStream = wrapStreamEndian(ID_ANI, resourceId);
+
+	if (aniStream->size() != 30)
+		warning("ANI Record size mismatch");
+
+	if (aniStream->readUint16() != 1)
+		warning("ANI Record u0 not 0"); // Version?
+
+	uint16 u1 = aniStream->readUint16();
+	debug(1, "ANI u1: %d", u1);
+
+	uint16 u2 = aniStream->readUint16();
+	debug(1, "ANI u2: %d", u2);
+
+	Common::Rect u3;
+	u3.right = aniStream->readUint16();
+	u3.bottom = aniStream->readUint16();
+	u3.left = aniStream->readUint16();
+	u3.top = aniStream->readUint16();
+	debug(1, "ANI u3: (%d, %d), (%d, %d)", u3.left, u3.top, u3.right, u3.bottom);
+
+	Common::Rect u4;
+	u4.right = aniStream->readUint16();
+	u4.bottom = aniStream->readUint16();
+	u4.left = aniStream->readUint16();
+	u4.top = aniStream->readUint16();
+	debug(1, "ANI u4: (%d, %d), (%d, %d)", u4.left, u4.top, u4.right, u4.bottom);
+
+	// BMAP Id?
+	uint16 u4ResourceId = aniStream->readUint16();
+	debug(1, "ANI u4ResourceId: %d", u4ResourceId);
+
+	// Following 3 unknowns also resourceIds in Unused?
+	uint16 u5 = aniStream->readUint16();
+	debug(1, "ANI u5: %d", u5);
+	if (u5 != 0)
+		warning("ANI u5 non-zero");
+
+	uint16 u6 = aniStream->readUint16();
+	debug(1, "ANI u6: %d", u6);
+	if (u6 != 0)
+		warning("ANI u6 non-zero");
+
+	uint16 u7 = aniStream->readUint16();
+	debug(1, "ANI u7: %d", u7);
+	if (u7 != 0)
+		warning("ANI u7 non-zero");
+
+	delete aniStream;
+}
+
+Common::SeekableSubReadStreamEndian *MohawkEngine_LivingBooks::wrapStreamEndian(uint32 tag, uint16 id) {
+	Common::SeekableReadStream *dataStream = getRawData(tag, id);
+	return new Common::SeekableSubReadStreamEndian(dataStream, 0, dataStream->size(), isBigEndian(), Common::DisposeAfterUse::YES);
+}
+
+Common::String MohawkEngine_LivingBooks::getStringFromConfig(Common::String section, Common::String key) {
+	Common::String x = Common::String::emptyString;
+	_bookInfoFile.getKey(key, section, x);
+	return removeQuotesFromString(x);
+}
+
+int MohawkEngine_LivingBooks::getIntFromConfig(Common::String section, Common::String key) {
+	return atoi(getStringFromConfig(section, key).c_str());
+}
+
+Common::String MohawkEngine_LivingBooks::getFileNameFromConfig(Common::String section, Common::String key) {
+	Common::String x = getStringFromConfig(section, key);
+	return (getPlatform() == Common::kPlatformMacintosh) ? convertMacFileName(x) : convertWinFileName(x);
+}
+
+Common::String MohawkEngine_LivingBooks::removeQuotesFromString(Common::String string) {
+	// The last char isn't necessarily a quote, the line could have "fade" in it,
+	// most likely representing to fade to that page. Hopefully it really is that
+	// obvious :P
+
+	// Some versions wrap in quotations, some don't...
+	for (uint32 i = 0; i < string.size(); i++) {
+		if (string[i] == '\"') {
+			string.deleteChar(i);
+			i--;
+		}
+	}
+
+	return string;
+}
+
+Common::String MohawkEngine_LivingBooks::convertMacFileName(Common::String string) {
+	Common::String filename;
+
+	for (uint32 i = 1; i < string.size(); i++) { // First character should be ignored (another colon)
+		if (string[i] == ':')
+			filename += '/';
+		else
+			filename += string[i];
+	}
+
+	return filename;
+}
+
+Common::String MohawkEngine_LivingBooks::convertWinFileName(Common::String string) {
+	Common::String filename;
+
+	for (uint32 i = 0; i < string.size(); i++) {
+		if (string[i] == '\\')
+			filename += '/';
+		else
+			filename += string[i];
+	}
+
+	return filename;
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/livingbooks.h b/engines/mohawk/livingbooks.h
new file mode 100644
index 0000000000..3053045574
--- /dev/null
+++ b/engines/mohawk/livingbooks.h
@@ -0,0 +1,94 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#ifndef MOHAWK_LIVINGBOOKS_H
+#define MOHAWK_LIVINGBOOKS_H
+
+#include "mohawk/mohawk.h"
+#include "mohawk/console.h"
+#include "mohawk/graphics.h"
+
+#include "common/config-file.h"
+
+namespace Mohawk {
+
+enum {
+	kIntroPage = 0
+};
+
+class LBGraphics;
+
+class MohawkEngine_LivingBooks : public MohawkEngine {
+protected:
+	Common::Error run();
+
+public:
+	MohawkEngine_LivingBooks(OSystem *syst, const MohawkGameDescription *gamedesc);
+	virtual ~MohawkEngine_LivingBooks();
+
+	LBGraphics *_gfx;
+	bool _needsUpdate;
+
+	Common::SeekableSubReadStreamEndian *wrapStreamEndian(uint32 tag, uint16 id);
+	GUI::Debugger *getDebugger() { return _console; }
+
+private:
+	LivingBooksConsole *_console;
+	Common::ConfigFile _bookInfoFile;
+
+	uint16 _curPage;
+	Common::String getBookInfoFileName();
+	void loadBookInfo(Common::String filename);
+	void loadIntro();
+
+	uint16 getResourceVersion();
+	void loadSHP(uint16 resourceId);
+	void loadANI(uint16 resourceId);
+
+	uint16 _screenWidth;
+	uint16 _screenHeight;
+	uint16 _numLanguages;
+	uint16 _numPages;
+	Common::String _title;
+	Common::String _copyright;
+
+	// String Manipulation Functions
+	Common::String removeQuotesFromString(Common::String string);
+	Common::String convertMacFileName(Common::String string);
+	Common::String convertWinFileName(Common::String string);
+	
+	// Configuration File Functions
+	Common::String getStringFromConfig(Common::String section, Common::String key);
+	int getIntFromConfig(Common::String section, Common::String key);
+	Common::String getFileNameFromConfig(Common::String section, Common::String key);
+	
+	// Platform/Version functions
+	bool isBigEndian() { return getGameType() == GType_NEWLIVINGBOOKS || getPlatform() == Common::kPlatformMacintosh; }
+	MohawkFile *createMohawkFile() { return (getGameType() == GType_NEWLIVINGBOOKS) ? new MohawkFile() : new OldMohawkFile(); }
+};
+
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/module.mk b/engines/mohawk/module.mk
new file mode 100644
index 0000000000..72d9263a11
--- /dev/null
+++ b/engines/mohawk/module.mk
@@ -0,0 +1,39 @@
+MODULE := engines/mohawk
+
+MODULE_OBJS = \
+	bitmap.o \
+	console.o \
+	detection.o \
+	dialogs.o \
+	file.o \
+	graphics.o \
+	livingbooks.o \
+	mohawk.o \
+	myst.o \
+	myst_jpeg.o \
+	myst_pict.o \
+	myst_vars.o \
+	myst_saveload.o \
+	myst_scripts.o \
+	riven.o \
+	riven_external.o \
+	riven_saveload.o \
+	riven_scripts.o \
+	riven_vars.o \
+	sound.o \
+	video/cinepak.o \
+	video/qdm2.o \
+	video/qtrle.o \
+	video/qt_player.o \
+	video/rpza.o \
+	video/smc.o \
+	video/video.o
+
+
+# This module can be built as a plugin
+ifeq ($(ENABLE_MOHAWK), DYNAMIC_PLUGIN)
+PLUGIN := 1
+endif
+
+# Include common rules
+include $(srcdir)/rules.mk
diff --git a/engines/mohawk/mohawk.cpp b/engines/mohawk/mohawk.cpp
new file mode 100644
index 0000000000..16b542ac51
--- /dev/null
+++ b/engines/mohawk/mohawk.cpp
@@ -0,0 +1,100 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "common/scummsys.h"
+#include "common/config-manager.h"
+#include "common/file.h"
+#include "common/events.h"
+#include "common/keyboard.h"
+
+#include "base/plugins.h"
+#include "base/version.h"
+
+#include "mohawk/mohawk.h"
+
+namespace Mohawk {
+
+MohawkEngine::MohawkEngine(OSystem *syst, const MohawkGameDescription *gamedesc) : Engine(syst), _gameDescription(gamedesc) {
+	if (!_mixer->isReady())
+		error ("Sound initialization failed");
+
+	_mixer->setVolumeForSoundType(Audio::Mixer::kSFXSoundType, ConfMan.getInt("sfx_volume"));
+	_mixer->setVolumeForSoundType(Audio::Mixer::kMusicSoundType, ConfMan.getInt("music_volume"));
+}
+
+MohawkEngine::~MohawkEngine() {
+	delete _sound;
+	delete _video;
+	delete _pauseDialog;
+
+	for (uint32 i = 0; i < _mhk.size(); i++)
+		delete _mhk[i];
+	_mhk.clear();
+}
+
+Common::Error MohawkEngine::run() {
+	_sound = new Sound(this);
+	_video = new VideoManager(this);
+	_pauseDialog = new PauseDialog(this, "The game is paused. Press any key to continue.");
+
+	return Common::kNoError;
+}
+
+void MohawkEngine::pauseEngineIntern(bool pause) {
+	if (pause) {
+		_video->pauseVideos();
+		_sound->pauseSound();
+		_sound->pauseSLST();
+	} else {
+		_video->resumeVideos();
+		_sound->resumeSound();
+		_sound->resumeSLST();
+		_system->updateScreen();
+	}
+}
+
+void MohawkEngine::pauseGame() {
+	runDialog(*_pauseDialog);
+}
+
+Common::SeekableReadStream *MohawkEngine::getRawData(uint32 tag, uint16 id) {
+	for (uint32 i = 0; i < _mhk.size(); i++)
+		if (_mhk[i]->hasResource(tag, id))
+			return _mhk[i]->getRawData(tag, id);
+
+	error ("Could not find a \'%s\' resource with ID %04x", tag2str(tag), id);
+
+	return 0;
+}
+	
+bool MohawkEngine::hasResource(uint32 tag, uint16 id) {
+	for (uint32 i = 0; i < _mhk.size(); i++)
+		if (_mhk[i]->hasResource(tag, id))
+			return true;
+	
+	return false;
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/mohawk.h b/engines/mohawk/mohawk.h
new file mode 100644
index 0000000000..c71c525707
--- /dev/null
+++ b/engines/mohawk/mohawk.h
@@ -0,0 +1,113 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#ifndef MOHAWK_H
+#define MOHAWK_H
+
+#include "common/scummsys.h"
+#include "common/util.h"
+#include "common/system.h"
+#include "common/rect.h"
+#include "common/array.h"
+
+#include "engines/engine.h"
+
+#include "gui/dialog.h"
+
+#include "mohawk/console.h"
+#include "mohawk/dialogs.h"
+#include "mohawk/file.h"
+#include "mohawk/sound.h"
+#include "mohawk/video/video.h"
+
+namespace Mohawk {
+
+enum MohawkGameType {
+	GType_MYST,
+	GType_MAKINGOF,
+	GType_RIVEN,
+	GType_ZOOMBINI,
+	GType_CSWORLD,
+	GType_CSAMTRAK,
+	GType_MAGGIESS,
+	GType_JAMESMATH,
+	GType_TREEHOUSE,
+	GType_1STDEGREE,
+	GType_CSUSA,
+	GType_OLDLIVINGBOOKS,
+	GType_NEWLIVINGBOOKS
+};
+
+enum MohawkGameFeatures {
+	GF_ME =      (1 << 0),	// Myst Masterpiece Edition
+	GF_DVD =     (1 << 1),
+	GF_10TH =    (1 << 2),	// 10th Anniversary
+	GF_DEMO =    (1 << 3),
+	GF_HASMIDI = (1 << 4),
+	GF_HASBINK = (1 << 5)
+};
+
+struct MohawkGameDescription;
+class Sound;
+class PauseDialog;
+
+class MohawkEngine : public ::Engine {
+protected:
+	virtual Common::Error run();
+
+public:
+	MohawkEngine(OSystem *syst, const MohawkGameDescription *gamedesc);
+	virtual ~MohawkEngine();
+
+	// Detection related functions
+	const MohawkGameDescription *_gameDescription;
+	const char* getGameId() const;
+	uint32 getFeatures() const;
+	uint16 getVersion() const;
+	Common::Platform getPlatform() const;
+	uint8 getGameType();
+	Common::Language getLanguage();
+	
+	bool hasFeature(EngineFeature f) const;
+
+	Sound *_sound;
+	VideoManager *_video;
+
+	Common::SeekableReadStream *getRawData(uint32, uint16);
+	bool hasResource(uint32 tag, uint16 id);
+
+	void pauseGame();
+
+protected:
+	PauseDialog *_pauseDialog;
+	void pauseEngineIntern(bool);
+
+	// An array holding the main Mohawk archives require by the games
+	Common::Array<MohawkFile*> _mhk;
+};
+
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/myst.cpp b/engines/mohawk/myst.cpp
new file mode 100644
index 0000000000..6ae7d97479
--- /dev/null
+++ b/engines/mohawk/myst.cpp
@@ -0,0 +1,1540 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "common/config-manager.h"
+
+#include "mohawk/graphics.h"
+#include "mohawk/myst.h"
+#include "mohawk/myst_scripts.h"
+#include "mohawk/myst_saveload.h"
+
+namespace Mohawk {
+
+MohawkEngine_Myst::MohawkEngine_Myst(OSystem *syst, const MohawkGameDescription *gamedesc) : MohawkEngine(syst, gamedesc) {
+	Common::addDebugChannel(kDebugVariable, "Variable", "Track Variable Accesses");
+	Common::addDebugChannel(kDebugSaveLoad, "SaveLoad", "Track Save/Load Function");
+	Common::addDebugChannel(kDebugView, "View", "Track Card File (VIEW) Parsing");
+	Common::addDebugChannel(kDebugHint, "Hint", "Track Cursor Hints (HINT) Parsing");
+	Common::addDebugChannel(kDebugResource, "Resource", "Track Resource (RLST) Parsing");
+	Common::addDebugChannel(kDebugINIT, "Init", "Track Card Init Script (INIT) Parsing");
+	Common::addDebugChannel(kDebugEXIT, "Exit", "Track Card Exit Script (EXIT) Parsing");
+	Common::addDebugChannel(kDebugScript, "Script", "Track Script Execution");
+	Common::addDebugChannel(kDebugHelp, "Help", "Track Help File (HELP) Parsing");
+
+	_zipMode = false;
+	_transitionsEnabled = false;
+
+	// Engine tweaks
+	// Disabling this makes engine behaviour as per
+	// original, including bugs, missing bits etc. :)
+	_tweaksEnabled = true;
+
+	_currentCursor = _mainCursor = kDefaultMystCursor;
+	_showResourceRects = false;
+	_curCard = 0;
+	_needsUpdate = false;
+	_curResource = -1;
+	
+	_cursorHintCount = 0;
+	_cursorHints = NULL;
+	
+	_view.conditionalImageCount = 0;
+	_view.conditionalImages = NULL;
+	_view.soundList = NULL;
+	_view.soundListVolume = NULL;
+	_view.scriptResCount = 0;
+	_view.scriptResources = NULL;
+
+	_scriptParser->disableInitOpcodes();
+
+	if ((getFeatures() & GF_ME) && getPlatform() == Common::kPlatformMacintosh)
+		SearchMan.addSubDirectoryMatching(_gameDataDir, "CD Data");
+}
+
+MohawkEngine_Myst::~MohawkEngine_Myst() {
+	delete _gfx;
+	delete _console;
+	delete _scriptParser;
+	delete _varStore;
+	delete _saveLoad;
+	delete _loadDialog;
+	delete _optionsDialog;
+	delete[] _view.conditionalImages;
+	delete[] _view.scriptResources;
+	delete[] _cursorHints;
+	_resources.clear();
+}
+
+static const char *mystFiles[] = {
+	"channel.dat",
+	"credits.dat",
+	"demo.dat",
+	"dunny.dat",
+	"intro.dat",
+	"making.dat",
+	"mechan.dat",
+	"myst.dat",
+	"selen.dat",
+	"slides.dat",
+	"sneak.dat",
+	"stone.dat"
+};
+
+// Myst Hardcoded Movie Paths
+// Mechanical Stack Movie "sstairs" referenced in executable, but not used?
+
+// NOTE: cl1wg1.mov etc. found in the root directory in versions of Myst
+// Original are duplicates of those in /qtw/myst directory and thus not necessary.
+
+// The following movies are not referenced in RLST or hardcoded into the executables.
+// It is likely they are unused:
+// qtw/mech/lwrgear2.mov + lwrgears.mov:	I have no idea what these are; perhaps replaced by an animated image in-game?
+// qtw/myst/gar4wbf1.mov:	gar4wbf2.mov has two butterflies instead of one
+// qtw/myst/libelev.mov:	libup.mov is basically the same with sound
+
+Common::String MohawkEngine_Myst::wrapMovieFilename(Common::String movieName, uint16 stack) {
+	const char* prefix;
+	
+	switch (stack) {
+		case kIntroStack:
+			prefix = "intro/";
+			break;
+		case kChannelwoodStack:
+			// The Windmill videos like to hide in a different folder
+			if (movieName.contains("wmill"))
+				prefix = "channel2/";
+			else
+				prefix = "channel/";
+			break;
+		case kDniStack:
+			prefix = "dunny/";
+			break;
+		case kMechanicalStack:
+			prefix = "mech/";
+			break;
+		case kMystStack:
+			prefix = "myst/";
+			break;
+		case kSeleniticStack:
+			prefix = "selen/";
+			break;
+		case kStoneshipStack:
+			prefix = "stone/";
+			break;
+		default:
+			prefix = ""; // Masterpiece Edition Only Movies
+			break;
+	}
+
+	if ((getFeatures() & GF_ME) && getPlatform() == Common::kPlatformMacintosh)
+		return Common::String("CD Data/m/") + movieName + ".mov";
+
+	return Common::String("qtw/") + prefix + movieName + ".mov";
+}
+
+Common::Error MohawkEngine_Myst::run() {
+	MohawkEngine::run();
+
+	_gfx = new MystGraphics(this);
+	_console = new MystConsole(this);
+	_varStore = new MystVar(this);
+	_saveLoad = new MystSaveLoad(this, _saveFileMan);
+	_scriptParser = new MystScriptParser(this);
+	_loadDialog = new GUI::SaveLoadChooser("Load Game:", "Load");
+	_loadDialog->setSaveMode(false);
+	_optionsDialog = new MystOptionsDialog(this);
+
+	// Start us on the first stack.
+	if (getGameType() == GType_MAKINGOF)
+		changeToStack(kMakingOfStack);
+	else if (getFeatures() & GF_DEMO)
+		changeToStack(kDemoStack);
+	else
+		changeToStack(kIntroStack);
+
+	if (getGameType() == GType_MAKINGOF)
+		changeToCard(1);
+	else {
+		if ((getFeatures() & GF_ME) && getPlatform() == Common::kPlatformMacintosh) {
+			_video->playMovieCentered(wrapMovieFilename("mattel", kIntroStack));
+			_video->playMovieCentered(wrapMovieFilename("presto", kIntroStack));
+		} else
+			_video->playMovieCentered(wrapMovieFilename("broder", kIntroStack));
+
+		_video->playMovieCentered(wrapMovieFilename("cyanlogo", kIntroStack));
+
+		if (!(getFeatures() & GF_DEMO)) { // The demo doesn't have the intro video
+			if ((getFeatures() & GF_ME) && getPlatform() == Common::kPlatformMacintosh)
+				// intro.mov uses Sorenson, introc uses Cinepak. Otherwise, they're the same.
+				_video->playMovieCentered(wrapMovieFilename("introc", kIntroStack));
+			else
+				_video->playMovieCentered(wrapMovieFilename("intro", kIntroStack));
+		}
+
+		if (shouldQuit())
+			return Common::kNoError;
+
+		if (getFeatures() & GF_DEMO)
+			changeToCard(2001);
+		else {
+			// It should be card 1 for the full game eventually too, but it's not working
+			// there at the moment. Card 2 is the card with the book on the ground.
+			changeToCard(2);
+		}
+	}
+
+	// Load game from launcher/command line if requested
+	if (ConfMan.hasKey("save_slot") && !(getFeatures() & GF_DEMO)) {
+		uint32 gameToLoad = ConfMan.getInt("save_slot");
+		Common::StringList savedGamesList = _saveLoad->generateSaveGameList();
+		if (gameToLoad > savedGamesList.size())
+			error ("Could not find saved game");
+		_saveLoad->loadGame(savedGamesList[gameToLoad]);
+		// HACK: The save_slot variable is saved to the disk! We don't want this!
+		ConfMan.removeKey("save_slot", ConfMan.getActiveDomainName());
+		ConfMan.flushToDisk();
+	}
+
+	// Load Help System (Masterpiece Edition Only)
+	if (getFeatures() & GF_ME) {
+		MohawkFile *mhk = new MohawkFile();
+		mhk->open("help.dat");
+		_mhk.push_back(mhk);
+	}
+
+	// Test Load Function...
+	loadHelp(10000);
+
+	// Set the cursor
+	_gfx->changeCursor(_currentCursor);
+	_gfx->showCursor();
+
+	Common::Event event;
+	while (!shouldQuit()) {
+		// Update any background videos
+		_needsUpdate = _video->updateBackgroundMovies();
+		_scriptParser->runPersistentOpcodes();
+
+		// Run animations...
+		for (uint16 i = 0; i < _resources.size(); i++)
+			_resources[i]->handleAnimation();
+
+		while (_eventMan->pollEvent(event)) {
+			switch (event.type) {
+				case Common::EVENT_MOUSEMOVE:
+					_mousePos = event.mouse;
+					_needsUpdate = true;
+					checkCurrentResource();
+					break;
+				case Common::EVENT_LBUTTONUP:
+					if (_curResource >= 0) {
+						debug(2, "Sending mouse up event to resource %d\n", _curResource);
+						_resources[_curResource]->handleMouseUp();
+					}
+
+					for (uint16 i = 0; i < _resources.size(); i++)
+						if (_resources[i]->isEnabled())
+							_resources[i]->drawDataToScreen();
+					break;
+				case Common::EVENT_LBUTTONDOWN:
+					if (_curResource >= 0) {
+						debug(2, "Sending mouse up event to resource %d\n", _curResource);
+						_resources[_curResource]->handleMouseDown();
+					}
+					break;	
+				case Common::EVENT_KEYDOWN:
+					switch (event.kbd.keycode) {
+						case Common::KEYCODE_d:
+							if (event.kbd.flags & Common::KBD_CTRL) {
+								_console->attach();
+								_console->onFrame();
+							}
+							break;
+						case Common::KEYCODE_SPACE:
+							pauseGame();
+							break;
+						case Common::KEYCODE_F4:
+							_showResourceRects = !_showResourceRects;
+							if (_showResourceRects)
+								drawResourceRects();
+							break;
+						case Common::KEYCODE_F5:
+							runDialog(*_optionsDialog);
+							break;
+						default:
+							break;
+					}
+					break;
+				default:
+					break;
+			}
+		}
+
+		if (_needsUpdate) {
+			_system->updateScreen();
+			_needsUpdate = false;
+		}
+
+		// Cut down on CPU usage
+		_system->delayMillis(10);
+	}
+
+	return Common::kNoError;
+}
+
+void MohawkEngine_Myst::changeToStack(uint16 stack) {
+	debug(2, "changeToStack(%d)", stack);
+
+	_curStack = stack;
+
+	// If the array is empty, add a new one. Otherwise, delete the first
+	// entry which is the stack file (the second, if there, is the help file).
+	if (_mhk.empty())
+		_mhk.push_back(new MohawkFile());
+	else {
+		delete _mhk[0];
+		_mhk[0] = new MohawkFile();
+	}
+
+	_mhk[0]->open(mystFiles[_curStack]);
+
+	if (getPlatform() == Common::kPlatformMacintosh)
+		_gfx->loadExternalPictureFile(_curStack);
+	
+	_runExitScript = false;
+}
+
+void MohawkEngine_Myst::changeToCard(uint16 card) {
+	debug(2, "changeToCard(%d)", card);
+
+	_scriptParser->disableInitOpcodes();
+	
+	_video->stopVideos();
+
+	// Run exit script from last card (if present)
+	if (_runExitScript)
+		runExitScript();
+
+	_runExitScript = true;
+	
+	unloadCard();
+
+	_curCard = card;
+
+	// Load a bunch of stuff
+	loadCard();
+	loadResources();
+	loadCursorHints();
+
+	// Handle images
+	if (_view.conditionalImageCount != 0) {
+		for (uint16 i = 0; i < _view.conditionalImageCount; i++) {
+			if (_varStore->getVar(_view.conditionalImages[i].var) < _view.conditionalImages[i].numStates)
+				_gfx->copyImageToScreen(_view.conditionalImages[i].values[_varStore->getVar(_view.conditionalImages[i].var)], Common::Rect(0, 0, 544, 333));
+			else
+				warning("Conditional image %d variable %d: %d exceeds maximum state of %d", i, _view.conditionalImages[i].var, _varStore->getVar(_view.conditionalImages[i].var), _view.conditionalImages[i].numStates-1);
+		}
+	} else if (_view.mainImage != 0)
+		_gfx->copyImageToScreen(_view.mainImage, Common::Rect(0, 0, 544, 333));
+
+	// Handle sound
+	int16 soundAction = 0;
+	uint16 soundActionVolume = 0;
+
+	if (_view.sound == kMystSoundActionConditional) {
+		uint16 soundVarValue = _varStore->getVar(_view.soundVar);
+		if (soundVarValue >= _view.soundCount)
+			warning("Conditional sound variable outside range");
+		else {
+			soundAction = _view.soundList[soundVarValue];
+			soundActionVolume = _view.soundListVolume[soundVarValue];
+		}
+	} else {
+		soundAction = _view.sound;
+		soundActionVolume = _view.soundVolume;
+	}
+	
+	// NOTE: Mixer only has 8-bit channel volume granularity, 
+	// Myst uses 16-bit? Or is part of this balance?
+	soundActionVolume = (byte)(soundActionVolume / 255);
+	
+	if (soundAction == kMystSoundActionContinue)
+		debug(2, "Continuing with current sound");
+	else if (soundAction == kMystSoundActionChangeVolume) {
+		debug(2, "Continuing with current sound, changing volume");
+		// TODO: Implement Volume Control..
+	} else if (soundAction == kMystSoundActionStop) {
+		debug(2, "Stopping sound");
+		_sound->stopSound();
+	} else if (soundAction > 0) {
+		debug(2, "Playing new sound %d", soundAction);
+		_sound->stopSound();
+		// TODO: Need to keep sound handle and add function to change volume of
+		// looped running sound for kMystSoundActionChangeVolume type
+		_sound->playSound(soundAction, true, soundActionVolume);
+	} else {
+		error("Unknown sound action %d", soundAction);
+	}
+
+	// TODO: Handle Script Resources
+
+	// Run the entrance script (if present)
+	runInitScript();
+	
+	// Make sure we have the right cursor showing
+	_curResource = -1;
+	checkCurrentResource();
+
+	// Debug: Show resource rects
+	if (_showResourceRects)
+		drawResourceRects();
+}
+
+void MohawkEngine_Myst::drawResourceRects() {
+	for (uint16 i = 0; i < _resources.size(); i++) {
+		_resources[i]->getRect().debugPrint(0);
+		if (_resources[i]->getRect().isValidRect())
+			_gfx->drawRect(_resources[i]->getRect(), _resources[i]->isEnabled());
+	}
+
+	_system->updateScreen();
+}
+
+void MohawkEngine_Myst::checkCurrentResource() {
+	// See what resource we're over
+	bool foundResource = false;
+
+	for (uint16 i = 0; i < _resources.size(); i++)
+		if (_resources[i]->isEnabled() && _resources[i]->contains(_system->getEventManager()->getMousePos())) {
+			if (_curResource != i) {
+				if (_curResource != -1)
+					_resources[_curResource]->handleMouseLeave();
+				_resources[i]->handleMouseEnter();
+			}
+
+			_curResource = i;
+			foundResource = true;
+			break;
+		}
+
+	// Set the resource to none if we're not over any
+	if (!foundResource)
+		_curResource = -1;
+
+	checkCursorHints();
+}
+
+void MohawkEngine_Myst::loadCard() {
+	debugC(kDebugView, "Loading Card View:");
+
+	Common::SeekableReadStream *viewStream = getRawData(ID_VIEW, _curCard);
+
+	// Card Flags
+	_view.flags = viewStream->readUint16LE();
+	debugC(kDebugView, "Flags: 0x%04X", _view.flags);
+
+	// The Image Block (Reminiscent of Riven PLST resources)
+	_view.conditionalImageCount = viewStream->readUint16LE();
+	debugC(kDebugView, "Conditional Image Count: %d", _view.conditionalImageCount);
+	if (_view.conditionalImageCount != 0) {
+		_view.conditionalImages = new MystCondition[_view.conditionalImageCount];
+		for (uint16 i = 0; i < _view.conditionalImageCount; i++) {
+			debugC(kDebugView, "\tImage %d:", i);
+			_view.conditionalImages[i].var = viewStream->readUint16LE();
+			debugC(kDebugView, "\t\tVar: %d", _view.conditionalImages[i].var);
+			_view.conditionalImages[i].numStates = viewStream->readUint16LE();
+			debugC(kDebugView, "\t\tNumber of States: %d", _view.conditionalImages[i].numStates);
+			_view.conditionalImages[i].values = new uint16[_view.conditionalImages[i].numStates];
+			for (uint16 j = 0; j < _view.conditionalImages[i].numStates; j++) {
+				_view.conditionalImages[i].values[j] = viewStream->readUint16LE();
+				debugC(kDebugView, "\t\tState %d -> Value %d", j, _view.conditionalImages[i].values[j]);
+			}
+		}
+		_view.mainImage = 0;
+	} else {
+		_view.mainImage = viewStream->readUint16LE();
+		debugC(kDebugView, "Main Image: %d", _view.mainImage);
+	}
+
+	// The Sound Block (Reminiscent of Riven SLST resources)
+	_view.sound = viewStream->readSint16LE();
+	debugCN(kDebugView, "Sound Control: %d = ", _view.sound);
+	if (_view.sound > 0) {
+		debugC(kDebugView, "Play new Sound, change volume");
+		debugC(kDebugView, "\tSound: %d", _view.sound);
+		_view.soundVolume = viewStream->readUint16LE();
+		debugC(kDebugView, "\tVolume: %d", _view.soundVolume);
+	} else if (_view.sound == kMystSoundActionContinue)
+		debugC(kDebugView, "Continue current sound");
+	else if (_view.sound == kMystSoundActionChangeVolume) {
+		debugC(kDebugView, "Continue current sound, change volume");
+		_view.soundVolume = viewStream->readUint16LE();
+		debugC(kDebugView, "\tVolume: %d", _view.soundVolume);
+	} else if (_view.sound == kMystSoundActionStop) {
+		debugC(kDebugView, "Stop sound");
+	} else if (_view.sound == kMystSoundActionConditional) {
+		debugC(kDebugView, "Conditional sound list");
+		_view.soundVar = viewStream->readUint16LE();
+		debugC(kDebugView, "\tVar: %d", _view.soundVar);
+		_view.soundCount = viewStream->readUint16LE();
+		debugC(kDebugView, "\tCount: %d", _view.soundCount);
+		_view.soundList = new int16[_view.soundCount];
+		_view.soundListVolume = new uint16[_view.soundCount];
+
+		for (uint16 i = 0; i < _view.soundCount; i++) {
+			_view.soundList[i] = viewStream->readSint16LE();
+			debugC(kDebugView, "\t\tCondition %d: Action %d", i, _view.soundList[i]);
+			if (_view.soundList[i] == kMystSoundActionChangeVolume || _view.soundList[i] >= 0) {
+				_view.soundListVolume[i] = viewStream->readUint16LE();
+				debugC(kDebugView, "\t\tCondition %d: Volume %d", i, _view.soundListVolume[i]);
+			}
+		}
+	} else {
+		debugC(kDebugView, "Unknown");
+		warning("Unknown sound control value in card");
+	}
+
+	// Resources that scripts can call upon
+	_view.scriptResCount = viewStream->readUint16LE();
+	debugC(kDebugView, "Script Resource Count: %d", _view.scriptResCount);
+	if (_view.scriptResCount != 0) {
+		_view.scriptResources = new MystView::ScriptResource[_view.scriptResCount];
+		for (uint16 i = 0; i < _view.scriptResCount; i++) {
+			debugC(kDebugView, "\tResource %d:", i);
+			_view.scriptResources[i].type = viewStream->readUint16LE();
+			debugC(kDebugView, "\t\t Type: %d", _view.scriptResources[i].type);
+
+			switch (_view.scriptResources[i].type) {
+				case 1:
+					debugC(kDebugView, "\t\t\t\t= Image");
+					break;
+				case 2:
+					debugC(kDebugView, "\t\t\t\t= Sound");
+					break;
+				case 3:
+					debugC(kDebugView, "\t\t\t\t= Resource List");
+					break;
+				default:
+					debugC(kDebugView, "\t\t\t\t= Unknown");
+					break;
+			}
+
+			if (_view.scriptResources[i].type == 3) {
+				_view.scriptResources[i].var = viewStream->readUint16LE();
+				debugC(kDebugView, "\t\t Var: %d", _view.scriptResources[i].var);
+				_view.scriptResources[i].count = viewStream->readUint16LE();
+				debugC(kDebugView, "\t\t Resource List Count: %d", _view.scriptResources[i].count);
+				_view.scriptResources[i].u0 = viewStream->readUint16LE();
+				debugC(kDebugView, "\t\t u0: %d", _view.scriptResources[i].u0);
+				_view.scriptResources[i].resource_list = new int16[_view.scriptResources[i].count];
+
+				for (uint16 j = 0; j < _view.scriptResources[i].count; j++) {
+					_view.scriptResources[i].resource_list[j] = viewStream->readSint16LE();
+					debugC(kDebugView, "\t\t Resource List %d: %d", j, _view.scriptResources[i].resource_list[j]);
+				}
+			} else {
+				_view.scriptResources[i].resource_list = NULL;
+				_view.scriptResources[i].id = viewStream->readUint16LE();
+				debugC(kDebugView, "\t\t Id: %d", _view.scriptResources[i].id);
+			}
+		}
+	}
+
+	// Identifiers for other resources. 0 if non existent. There is always an RLST.
+	_view.rlst = viewStream->readUint16LE();
+	if (!_view.rlst)
+		error("RLST Index missing");
+
+	_view.hint = viewStream->readUint16LE();
+	_view.init = viewStream->readUint16LE();
+	_view.exit = viewStream->readUint16LE();
+
+	delete viewStream;
+}
+
+void MohawkEngine_Myst::unloadCard() {
+	for (uint16 i = 0; i < _view.conditionalImageCount; i++)
+		delete[] _view.conditionalImages[i].values;
+
+	delete[] _view.conditionalImages;
+	_view.conditionalImageCount = 0;
+	_view.conditionalImages = NULL;
+
+	delete[] _view.soundList;
+	_view.soundList = NULL;
+	delete[] _view.soundListVolume;
+	_view.soundListVolume = NULL;
+
+	for (uint16 i = 0; i < _view.scriptResCount; i++)
+		delete[] _view.scriptResources[i].resource_list;
+
+	delete[] _view.scriptResources;
+	_view.scriptResources = NULL;
+	_view.scriptResCount = 0;
+}
+
+void MohawkEngine_Myst::runInitScript() {
+	if (!_view.init) {
+		debugC(kDebugINIT, "No INIT Present");
+		return;
+	}
+
+	debugC(kDebugINIT, "Running INIT script");
+
+	Common::SeekableReadStream *initStream = getRawData(ID_INIT, _view.init);
+
+	uint16 scriptCount = initStream->readUint16LE();
+
+	debugC(kDebugINIT, "\tOpcode Count: %d", scriptCount);
+
+	MystScriptEntry *scripts = new MystScriptEntry[scriptCount];
+
+	for (uint16 i = 0; i < scriptCount; i++) {
+		// TODO: u0 is likely variable reference for boolean to
+		// determine whether or not to execute opcode
+		uint16 u0 = initStream->readUint16LE();
+		scripts[i].opcode = initStream->readUint16LE();
+		// If variable indicates not to execute opcode, rewrite to NOP
+		//if (!_varStore->getVar(u0))
+		//	scripts[i].opcode = 0xFFFF;
+		scripts[i].var = initStream->readUint16LE();
+		scripts[i].numValues = initStream->readUint16LE();
+		scripts[i].values = new uint16[scripts[i].numValues];
+
+		debugC(kDebugINIT, "\tu0: %d", u0);
+		debugC(kDebugINIT, "\tOpcode %d: %s", i, _scriptParser->getOpcodeDesc(scripts[i].opcode));
+		debugC(kDebugINIT, "\t\tUses Variable %d", scripts[i].var);
+		debugC(kDebugINIT, "\t\tHas %d Arguments:", scripts[i].numValues);
+
+		for (uint16 j = 0; j < scripts[i].numValues; j++) {
+			scripts[i].values[j] = initStream->readUint16LE();
+			debugC(kDebugINIT, "\t\tArgument %d: %d", j, scripts[i].values[j]);
+		}
+	}
+
+	delete initStream;
+
+	_scriptParser->runScript(scriptCount, scripts);
+
+	for (uint16 i = 0; i < scriptCount; i++)
+		delete[] scripts[i].values;
+	delete[] scripts;
+}
+
+void MohawkEngine_Myst::runExitScript() {
+	if (!_view.exit) {
+		debugC(kDebugEXIT, "No EXIT Present");
+		return;
+	}
+
+	debugC(kDebugEXIT, "Running EXIT script");
+
+	Common::SeekableReadStream *exitStream = getRawData(ID_EXIT, _view.exit);
+
+	uint16 scriptCount = exitStream->readUint16LE();
+
+	debugC(kDebugEXIT, "\tOpcode Count: %d", scriptCount);
+
+	MystScriptEntry *scripts = new MystScriptEntry[scriptCount];
+
+	for (uint16 i = 0; i < scriptCount; i++) {
+		// TODO: u0 is likely variable reference for boolean to
+		// to determine whether or not to execute opcode (i.e. door
+		// close noises only when door is open).
+		uint16 u0 = exitStream->readUint16LE();
+		scripts[i].opcode = exitStream->readUint16LE();
+		// If variable indicates not to execute opcode, rewrite to NOP
+		//if (!_varStore->getVar(u0))
+		//	scripts[i].opcode = 0xFFFF;
+		scripts[i].var = exitStream->readUint16LE();
+		scripts[i].numValues = exitStream->readUint16LE();
+		scripts[i].values = new uint16[scripts[i].numValues];
+
+		debugC(kDebugEXIT, "\tu0: %d", u0);
+		debugC(kDebugEXIT, "\tOpcode %d: %s", i, _scriptParser->getOpcodeDesc(scripts[i].opcode));
+		debugC(kDebugEXIT, "\t\tUses Variable %d", scripts[i].var);
+		debugC(kDebugEXIT, "\t\tHas %d Arguments:", scripts[i].numValues);
+
+		for (uint16 j = 0; j < scripts[i].numValues; j++) {
+			scripts[i].values[j] = exitStream->readUint16LE();
+			debugC(kDebugEXIT, "\t\tArgument %d: %d", j, scripts[i].values[j]);
+		}
+
+		uint16 u1 = exitStream->readUint16LE();
+		if (u1 != 1)
+			warning("Myst EXIT u1 not 1");
+	}
+
+	delete exitStream;
+
+	_scriptParser->runScript(scriptCount, scripts);
+	
+	for (uint16 i = 0; i < scriptCount; i++)
+		delete[] scripts[i].values;
+	delete[] scripts;
+}
+
+void MohawkEngine_Myst::loadHelp(uint16 id) {
+	// The original version did not have the help system
+	if (!(getFeatures() & GF_ME))
+		return;
+	
+	// TODO: Help File contains 5 cards i.e. VIEW, RLST, etc.
+	//       in addition to HELP resources.
+	//       These are Ids 9930 to 9934
+	//       Need to deal with loading and displaying these..
+	//       Current engine structure only supports display of
+	//       card from primary stack MHK
+
+	debugC(kDebugHelp, "Loading Help System Data");
+
+	Common::SeekableReadStream *helpStream = getRawData(ID_HELP, id);
+
+	uint16 count = helpStream->readUint16LE();
+	uint16 *u0 = new uint16[count];
+	Common::String helpText = Common::String::emptyString;
+	
+	debugC(kDebugHelp, "\tcount: %d", count);
+	
+	for (uint16 i = 0; i < count; i++) {
+		u0[i] = helpStream->readUint16LE();
+		debugC(kDebugHelp, "\tu0[%d]: %d", i, u0[i]);
+	}
+	
+	// TODO: Previous values i.e. u0[0] to u0[count - 2]
+	// appear to be resource ids in the help.dat file..
+	if (u0[count - 1] != count)
+		warning("loadHelp(): last u0 value is not equal to count");
+
+	do {
+		helpText += helpStream->readByte();
+	} while (helpText.lastChar() != 0);
+	helpText.deleteLastChar();
+
+	debugC(kDebugHelp, "\thelpText: \"%s\"", helpText.c_str());
+
+	delete[] u0;
+}
+
+void MohawkEngine_Myst::loadCursorHints() {
+	for (uint16 i = 0; i < _cursorHintCount; i++)
+		delete[] _cursorHints[i].variableHint.values;
+	_cursorHintCount = 0;
+	delete[] _cursorHints;
+	_cursorHints = NULL;
+
+	if (!_view.hint) {
+		debugC(kDebugHint, "No HINT Present");
+		return;
+	}
+
+	debugC(kDebugHint, "Loading Cursor Hints:");
+
+	Common::SeekableReadStream *hintStream = getRawData(ID_HINT, _curCard);
+	_cursorHintCount = hintStream->readUint16LE();
+	debugC(kDebugHint, "Cursor Hint Count: %d", _cursorHintCount);
+	_cursorHints = new MystCursorHint[_cursorHintCount];
+
+	for (uint16 i = 0; i < _cursorHintCount; i++) {
+		debugC(kDebugHint, "Cursor Hint %d:", i);
+		_cursorHints[i].id = hintStream->readUint16LE();
+		debugC(kDebugHint, "\tId: %d", _cursorHints[i].id);
+		_cursorHints[i].cursor = hintStream->readSint16LE();
+		debugC(kDebugHint, "\tCursor: %d", _cursorHints[i].cursor);
+
+		if (_cursorHints[i].cursor == -1) {
+			debugC(kDebugHint, "\tConditional Cursor Hints:");
+			_cursorHints[i].variableHint.var = hintStream->readUint16LE();
+			debugC(kDebugHint, "\tVar: %d", _cursorHints[i].variableHint.var);
+			_cursorHints[i].variableHint.numStates = hintStream->readUint16LE();
+			debugC(kDebugHint, "\tNumber of States: %d", _cursorHints[i].variableHint.numStates);
+			_cursorHints[i].variableHint.values = new uint16[_cursorHints[i].variableHint.numStates];
+			for (uint16 j = 0; j < _cursorHints[i].variableHint.numStates; j++) {
+				_cursorHints[i].variableHint.values[j] = hintStream->readUint16LE();
+				debugC(kDebugHint, "\t\t State %d: Cursor %d", j, _cursorHints[i].variableHint.values[j]);
+			}
+		} else {
+			_cursorHints[i].variableHint.var = 0;
+			_cursorHints[i].variableHint.numStates = 0;
+			_cursorHints[i].variableHint.values = NULL;
+		}
+	}
+
+	delete hintStream;
+}
+
+void MohawkEngine_Myst::setMainCursor(uint16 cursor) {
+	_currentCursor = _mainCursor = cursor;
+	_gfx->changeCursor(_currentCursor);
+}
+
+void MohawkEngine_Myst::checkCursorHints() {
+	if (!_view.hint)
+		return;
+
+	// Check all the cursor hints to see if we're in a hotspot that contains a hint.
+	for (uint16 i = 0; i < _cursorHintCount; i++)
+		if (_cursorHints[i].id == _curResource && _resources[_cursorHints[i].id]->isEnabled()) {
+			if (_cursorHints[i].cursor == -1) {
+				uint16 var_value = _varStore->getVar(_cursorHints[i].variableHint.var);
+
+				if (var_value >= _cursorHints[i].variableHint.numStates)
+					warning("Variable %d Out of Range in variable HINT Resource %d", _cursorHints[i].variableHint.var, i);
+				else {
+					_currentCursor = _cursorHints[i].variableHint.values[var_value];
+					if (_currentCursor == 0)
+						_currentCursor = _mainCursor;
+					_gfx->changeCursor(_currentCursor);
+				}
+			} else if (_currentCursor != _cursorHints[i].cursor) {
+				if (_cursorHints[i].cursor == 0)
+					_currentCursor = _mainCursor;
+				else
+					_currentCursor = _cursorHints[i].cursor;
+
+				_gfx->changeCursor(_currentCursor);
+			}
+			return;
+		}
+
+	if (_currentCursor != _mainCursor) {
+		_currentCursor = _mainCursor;
+		_gfx->changeCursor(_currentCursor);
+	}
+}
+
+void MohawkEngine_Myst::setResourceEnabled(uint16 resourceId, bool enable) {
+	if (resourceId < _resources.size()) {
+		_resources[resourceId]->setEnabled(enable);
+	} else
+		warning("Attempt to change unknown resource enable state");
+}
+
+static MystResource *loadResource(MohawkEngine_Myst *vm, Common::SeekableReadStream *rlstStream, MystResource *parent) {
+	uint16 type = rlstStream->readUint16LE();
+
+	debugC(kDebugResource, "\tType: %d", type);
+	debugC(kDebugResource, "\tSub_Record: %d", (parent == NULL) ? 0 : 1);
+
+	switch (type) {
+		case kMystForwardResource:
+		case kMystLeftResource:
+		case kMystRightResource:
+		case kMystDownResource:
+		case kMystUpResource:
+		case 14: // TODO: kMystBackwardResource?
+			return new MystResource(vm, rlstStream, parent);
+		case kMystActionResource:
+			return new MystResourceType5(vm, rlstStream, parent);
+		case kMystVideoResource:
+			return new MystResourceType6(vm, rlstStream, parent);
+		case kMystSwitchResource:
+			return new MystResourceType7(vm, rlstStream, parent);
+		case 8:
+			return new MystResourceType8(vm, rlstStream, parent);
+		case 10:
+			return new MystResourceType10(vm, rlstStream, parent);
+		case 11:
+			return new MystResourceType11(vm, rlstStream, parent);
+		case 12:
+			return new MystResourceType12(vm, rlstStream, parent);
+		case 13:
+			return new MystResourceType13(vm, rlstStream, parent);
+		default:
+			error ("Unknown/Unhandled MystResource type %d", type);
+	}
+}
+
+void MohawkEngine_Myst::loadResources() {
+	_resources.clear();
+
+	if (!_view.rlst) {
+		debugC(kDebugResource, "No RLST present");
+		return;
+	}
+
+	Common::SeekableReadStream *rlstStream = getRawData(ID_RLST, _view.rlst);
+	uint16 resourceCount = rlstStream->readUint16LE();
+	debugC(kDebugResource, "RLST Resource Count: %d", resourceCount);
+
+	for (uint16 i = 0; i < resourceCount; i++) {
+		debugC(kDebugResource, "Resource #%d:", i);
+		_resources.push_back(loadResource(this, rlstStream, NULL));
+	}
+	delete rlstStream;
+}
+
+MystResource::MystResource(MohawkEngine_Myst *vm, Common::SeekableReadStream *rlstStream, MystResource *parent) {
+	_vm = vm;
+	_parent = parent;
+	
+	if (parent == NULL) {
+		_flags = rlstStream->readUint16LE();
+		_rect.left = rlstStream->readSint16LE();
+		_rect.top = rlstStream->readSint16LE();
+
+		if (_rect.top == -1) {
+			warning("Invalid _rect.top of -1 found - clamping to 0");
+			_rect.top = 0;
+		}
+
+		_rect.right = rlstStream->readSint16LE();
+		_rect.bottom = rlstStream->readSint16LE();
+		_dest = rlstStream->readUint16LE();
+	} else {
+		_flags = parent->_flags;
+		_rect.left = parent->_rect.left;
+		_rect.top = parent->_rect.top;
+		_rect.right = parent->_rect.right;
+		_rect.bottom = parent->_rect.bottom;
+		_dest = parent->_dest;
+	}
+
+	debugC(kDebugResource, "\tflags: 0x%04X", _flags);
+	debugC(kDebugResource, "\tleft: %d", _rect.left);
+	debugC(kDebugResource, "\ttop: %d", _rect.top);
+	debugC(kDebugResource, "\tright: %d", _rect.right);
+	debugC(kDebugResource, "\tbottom: %d", _rect.bottom);
+	debugC(kDebugResource, "\tdest: %d", _dest);
+	
+	// Default Enable based on flags...
+	if (_vm->_zipMode)
+		_enabled = (_flags & kMystZipModeEnableFlag) != 0 ||
+		           (_flags & kMystHotspotEnableFlag) != 0 ||
+		           (_flags & kMystSubimageEnableFlag) != 0;
+	else
+		_enabled = (_flags & kMystZipModeEnableFlag) == 0 &&
+		           ((_flags & kMystHotspotEnableFlag) != 0 ||
+		            (_flags & kMystSubimageEnableFlag) != 0);
+}
+
+void MystResource::handleMouseUp() {
+	if (_dest != 0)
+		_vm->changeToCard(_dest);
+	else
+		warning("Movement type resource with null destination at position (%d, %d), (%d, %d)", _rect.left, _rect.top, _rect.right, _rect.bottom);
+}
+
+MystResourceType5::MystResourceType5(MohawkEngine_Myst *vm, Common::SeekableReadStream *rlstStream, MystResource *parent) : MystResource(vm, rlstStream, parent) {
+	debugC(kDebugResource, "\tResource Type 5 Script:");
+
+	_scriptCount = rlstStream->readUint16LE();
+
+	debugC(kDebugResource, "\tOpcode Count: %d", _scriptCount);
+
+	if (_scriptCount == 0)
+		return;
+
+	_scripts = new MystScriptEntry[_scriptCount];
+	for (uint16 i = 0; i < _scriptCount; i++) {
+		_scripts[i].opcode = rlstStream->readUint16LE();
+		_scripts[i].var = rlstStream->readUint16LE();
+		_scripts[i].numValues = rlstStream->readUint16LE();
+		_scripts[i].values = new uint16[_scripts[i].numValues];
+
+		debugC(kDebugResource, "\tOpcode %d: %s", i, _vm->_scriptParser->getOpcodeDesc(_scripts[i].opcode));
+		debugC(kDebugResource, "\t\tUses Variable %d", _scripts[i].var);
+		debugC(kDebugResource, "\t\tHas %d Arguments:", _scripts[i].numValues);
+
+		for (uint16 j = 0; j < _scripts[i].numValues; j++) {
+			_scripts[i].values[j] = rlstStream->readUint16LE();
+			debugC(kDebugResource, "\t\tArgument %d: %d", j, _scripts[i].values[j]);
+		}
+	}
+}
+
+void MystResourceType5::handleMouseUp() {
+	_vm->_scriptParser->runScript(_scriptCount, _scripts, this);
+}
+
+// In Myst/Making of Myst, the paths are hardcoded ala Windows style without extension. Convert them.
+Common::String MystResourceType6::convertMystVideoName(Common::String name) {
+	Common::String temp;
+
+	for (uint32 i = 1; i < name.size(); i++) {
+		if (name[i] == '\\')
+			temp += '/';
+		else
+			temp += name[i];
+	}
+
+	return temp + ".mov";
+}
+
+MystResourceType6::MystResourceType6(MohawkEngine_Myst *vm, Common::SeekableReadStream *rlstStream, MystResource *parent) : MystResourceType5(vm, rlstStream, parent) {
+	char c = 0;
+	
+	do {
+		c = rlstStream->readByte();
+		_videoFile += c;
+	} while (c);
+
+	rlstStream->skip(_videoFile.size() & 1);
+
+	// Trim method does not remove extra trailing nulls
+	while (_videoFile.size() != 0 && _videoFile.lastChar() == 0)
+		_videoFile.deleteLastChar();
+
+	_videoFile = convertMystVideoName(_videoFile);
+
+	// Position values require modulus 10000 to keep in sane range.
+	_left = rlstStream->readUint16LE() % 10000;
+	_top = rlstStream->readUint16LE() % 10000;
+	_loop = rlstStream->readUint16LE();
+	_u0 = rlstStream->readUint16LE();
+	_playBlocking = rlstStream->readUint16LE();
+	_playOnCardChange = rlstStream->readUint16LE();
+	_u3 = rlstStream->readUint16LE();
+
+	if (_u0 != 1)
+		warning("Type 6 _u0 != 1");
+	if (_u3 != 0)
+		warning("Type 6 _u3 != 0");
+
+	debugC(kDebugResource, "\tvideoFile: \"%s\"", _videoFile.c_str());
+	debugC(kDebugResource, "\tleft: %d", _left);
+	debugC(kDebugResource, "\ttop: %d", _top);
+	debugC(kDebugResource, "\tloop: %d", _loop);
+	debugC(kDebugResource, "\tu0: %d", _u0);
+	debugC(kDebugResource, "\tplayBlocking: %d", _playBlocking);
+	debugC(kDebugResource, "\tplayOnCardChange: %d", _playOnCardChange);
+	debugC(kDebugResource, "\tu3: %d", _u3);
+
+	_videoRunning = false;
+}
+
+void MystResourceType6::handleAnimation() {
+	// TODO: Implement Code to allow _playOnCardChange when set
+	//       and trigger by Opcode 9 when clear
+
+	if (!_videoRunning) {
+		// NOTE: The left and top coordinates are often incorrect and do not make sense.
+		// We use the rect coordinates here instead.
+
+		if (_playBlocking)
+			_vm->_video->playMovie(_videoFile, _rect.left, _rect.top);
+		else
+			_vm->_video->playBackgroundMovie(_videoFile, _rect.left, _rect.top, _loop);
+
+		_videoRunning = true;
+	}
+}
+
+MystResourceType7::MystResourceType7(MohawkEngine_Myst *vm, Common::SeekableReadStream *rlstStream, MystResource *parent) : MystResource(vm, rlstStream, parent) {
+	_var7 = rlstStream->readUint16LE();
+	_numSubResources = rlstStream->readUint16LE();
+	debugC(kDebugResource, "\tvar7: %d", _var7);
+	debugC(kDebugResource, "\tnumSubResources: %d", _numSubResources);
+
+	for (uint16 i = 0; i < _numSubResources; i++)
+		_subResources.push_back(loadResource(vm, rlstStream, this));
+}
+
+// TODO: All these functions to switch subresource are very similar.
+//       Find way to share code (function pointer pass?)
+void MystResourceType7::drawDataToScreen() {
+	if (_var7 == 0xFFFF) {
+		if (_numSubResources == 1)
+			_subResources[0]->drawDataToScreen();
+		else if (_numSubResources != 0)
+			warning("Type 7 Resource with _numSubResources of %d, but no control variable", _numSubResources);
+	} else {
+		uint16 varValue = _vm->_varStore->getVar(_var7);
+
+		if (_numSubResources == 1 && varValue != 0)
+			_subResources[0]->drawDataToScreen();
+		else if (_numSubResources != 0) {
+			if (varValue < _numSubResources)
+				_subResources[varValue]->drawDataToScreen();
+			else
+				warning("Type 7 Resource Var %d: %d exceeds number of sub resources %d", _var7, varValue, _numSubResources);
+		}
+	}
+}
+
+void MystResourceType7::handleAnimation() {
+	if (_var7 == 0xFFFF) {
+		if (_numSubResources == 1)
+			_subResources[0]->handleAnimation();
+		else if (_numSubResources != 0)
+			warning("Type 7 Resource with _numSubResources of %d, but no control variable", _numSubResources);
+	} else {
+		uint16 varValue = _vm->_varStore->getVar(_var7);
+
+		if (_numSubResources == 1 && varValue != 0)
+			_subResources[0]->handleAnimation();
+		else if (_numSubResources != 0) {
+			if (varValue < _numSubResources)
+				_subResources[varValue]->handleAnimation();
+			else
+				warning("Type 7 Resource Var %d: %d exceeds number of sub resources %d", _var7, varValue, _numSubResources);
+		}
+	}
+}
+
+void MystResourceType7::handleMouseUp() {
+	if (_var7 == 0xFFFF) {
+		if (_numSubResources == 1)
+			_subResources[0]->handleMouseUp();
+		else if (_numSubResources != 0)
+			warning("Type 7 Resource with _numSubResources of %d, but no control variable", _numSubResources);
+	} else {
+		uint16 varValue = _vm->_varStore->getVar(_var7);
+
+		if (_numSubResources == 1 && varValue != 0)
+			_subResources[0]->handleMouseUp();
+		else if (_numSubResources != 0) {
+			if (varValue < _numSubResources)
+				_subResources[varValue]->handleMouseUp();
+			else
+				warning("Type 7 Resource Var %d: %d exceeds number of sub resources %d", _var7, varValue, _numSubResources);
+		}
+	}
+}
+
+void MystResourceType7::handleMouseDown() {
+	if (_var7 == 0xFFFF) {
+		if (_numSubResources == 1)
+			_subResources[0]->handleMouseDown();
+		else if (_numSubResources != 0)
+			warning("Type 7 Resource with _numSubResources of %d, but no control variable", _numSubResources);
+	} else {
+		uint16 varValue = _vm->_varStore->getVar(_var7);
+
+		if (_numSubResources == 1 && varValue != 0)
+			_subResources[0]->handleMouseDown();
+		else if (_numSubResources != 0) {
+			if (varValue < _numSubResources)
+				_subResources[varValue]->handleMouseDown();
+			else
+				warning("Type 7 Resource Var %d: %d exceeds number of sub resources %d", _var7, varValue, _numSubResources);
+		}
+	}
+}
+
+void MystResourceType7::handleMouseEnter() {
+	if (_var7 == 0xFFFF) {
+		if (_numSubResources == 1)
+			_subResources[0]->handleMouseEnter();
+		else if (_numSubResources != 0)
+			warning("Type 7 Resource with _numSubResources of %d, but no control variable", _numSubResources);
+	} else {
+		uint16 varValue = _vm->_varStore->getVar(_var7);
+
+		if (_numSubResources == 1 && varValue != 0)
+			_subResources[0]->handleMouseEnter();
+		else if (_numSubResources != 0) {
+			if (varValue < _numSubResources)
+				_subResources[varValue]->handleMouseEnter();
+			else
+				warning("Type 7 Resource Var %d: %d exceeds number of sub resources %d", _var7, varValue, _numSubResources);
+		}
+	}
+}
+
+void MystResourceType7::handleMouseLeave() {
+	if (_var7 == 0xFFFF) {
+		if (_numSubResources == 1)
+			_subResources[0]->handleMouseLeave();
+		else if (_numSubResources != 0)
+			warning("Type 7 Resource with _numSubResources of %d, but no control variable", _numSubResources);
+	} else {
+		uint16 varValue = _vm->_varStore->getVar(_var7);
+
+		if (_numSubResources == 1 && varValue != 0)
+			_subResources[0]->handleMouseLeave();
+		else if (_numSubResources != 0) {
+			if (varValue < _numSubResources)
+				_subResources[varValue]->handleMouseLeave();
+			else
+				warning("Type 7 Resource Var %d: %d exceeds number of sub resources %d", _var7, varValue, _numSubResources);
+		}
+	}
+}
+
+MystResourceType8::MystResourceType8(MohawkEngine_Myst *vm, Common::SeekableReadStream *rlstStream, MystResource *parent) : MystResourceType7(vm, rlstStream, parent) {
+	_var8 = rlstStream->readUint16LE();
+	_numSubImages = rlstStream->readUint16LE();
+	debugC(kDebugResource, "\tvar8: %d", _var8);
+	debugC(kDebugResource, "\tnumSubImages: %d", _numSubImages);
+
+	_subImages = new MystResourceType8::SubImage[_numSubImages];
+	for (uint16 i = 0; i < _numSubImages; i++) {
+		debugC(kDebugResource, "\tSubimage %d:", i);
+
+		_subImages[i].wdib = rlstStream->readUint16LE();
+		_subImages[i].rect.left = rlstStream->readSint16LE();
+
+		if (_subImages[i].rect.left != -1) {
+			_subImages[i].rect.top = rlstStream->readSint16LE();
+			_subImages[i].rect.right = rlstStream->readSint16LE();
+			_subImages[i].rect.bottom = rlstStream->readSint16LE();
+		} else {
+			_subImages[i].rect.top = 0;
+			_subImages[i].rect.right = 0;
+			_subImages[i].rect.bottom = 0;
+		}
+
+		debugC(kDebugResource, "\twdib: %d", _subImages[i].wdib);
+		debugC(kDebugResource, "\tleft: %d", _subImages[i].rect.left);
+		debugC(kDebugResource, "\ttop: %d", _subImages[i].rect.top);
+		debugC(kDebugResource, "\tright: %d", _subImages[i].rect.right);
+		debugC(kDebugResource, "\tbottom: %d", _subImages[i].rect.bottom);
+	}
+}
+
+void MystResourceType8::drawDataToScreen() {
+	// Need to call overidden Type 7 function to ensure
+	// switch section is processed correctly.
+	MystResourceType7::drawDataToScreen();
+
+	bool drawSubImage = false;
+	int16 subImageId = 0;
+
+	if (_var8 == 0xFFFF) {
+		if (_numSubImages == 1) {
+			subImageId = 0;
+			drawSubImage = true;
+		} else if (_numSubImages != 0)
+			warning("Type 8 Resource with _numSubImages of %d, but no control variable", _numSubImages);
+	} else {
+		uint16 varValue = _vm->_varStore->getVar(_var8);
+
+		if (_numSubImages == 1 && varValue != 0) {
+			subImageId = 0;
+			drawSubImage = true;
+		} else if (_numSubImages != 0) {
+			if (varValue < _numSubImages) {
+				subImageId = varValue;
+				drawSubImage = true;
+			} else
+				warning("Type 8 Image Var %d: %d exceeds number of subImages %d", _var8, varValue, _numSubImages);
+		}
+	}
+
+	if (drawSubImage) {
+		uint16 imageToDraw = 0;
+
+		if (_subImages[subImageId].wdib == 0xFFFF) {
+			// TODO: Think the reason for problematic screen updates in some rects is that they
+			//       are these -1 cases.
+			// They need to be redrawn i.e. if the Myst marker switches are changed, but I don't think
+			// the rects are valid. This does not matter in the original engine as the screen update redraws
+			// the VIEW images, followed by the RLST resource images, and -1 for the WDIB is interpreted as
+			// "Do Not Draw Image" i.e so the VIEW image is shown through.. We need to fix screen update
+			// to do this same behaviour.
+			if (_vm->_view.conditionalImageCount == 0)
+				imageToDraw = _vm->_view.mainImage;
+			else {
+				for (uint16 i = 0; i < _vm->_view.conditionalImageCount; i++)
+					if (_vm->_varStore->getVar(_vm->_view.conditionalImages[i].var) < _vm->_view.conditionalImages[i].numStates)
+						imageToDraw = _vm->_view.conditionalImages[i].values[_vm->_varStore->getVar(_vm->_view.conditionalImages[i].var)];
+			}
+		} else
+			imageToDraw = _subImages[subImageId].wdib;
+
+		if (_subImages[subImageId].rect.left == -1)
+			_vm->_gfx->copyImageSectionToScreen(imageToDraw, _rect, _rect);
+			//vm->_gfx->copyImageToScreen(imageToDraw, Common::Rect(0, 0, 544, 333));
+		// TODO: Think this is the case when the image is full screen.. need to modify graphics to add functions for returning size of image.			
+		// This is not right either...
+		//else if (_rect.width() != _subImages[draw_subimage_id].rect.width() || _rect.height() != _subImages[draw_subimage_id].rect.height())
+		// HACK: Hardcode cases of this until general rule can be ascertained
+		//       These cases seem to have the source rect in the wdib with an vertical i.e. top+X, bottom+X where X is a constant, but could
+		//       be negative, translations, when in fact both the source and dest should be equal...
+		//else if ((vm->getCurStack() == kSeleniticStack   && vm->getCurCard() == 1155 && tmp == 1) || // X=
+		//        (vm->getCurStack() == kSeleniticStack   && vm->getCurCard() == 1225 && tmp == 1) || // X=
+		//        (vm->getCurStack() == kMystStack        && vm->getCurCard() == 4247 && tmp == 0) || // X=
+		//        (vm->getCurStack() == kChannelwoodStack && vm->getCurCard() == 3161 && tmp == 0))   // X=
+		//	vm->_gfx->copyImageSectionToScreen(imageToDraw, _rect, _rect);
+		//    // TODO: Small vertical movement remains on change. Suspect off by one error from these to real
+		//	//        solution.
+		else
+			_vm->_gfx->copyImageSectionToScreen(imageToDraw, _subImages[subImageId].rect, _rect);
+	}
+}
+
+uint16 MystResourceType8::getType8Var() {
+	return _var8;
+}
+
+// No MystResourceType9!
+
+MystResourceType10::MystResourceType10(MohawkEngine_Myst *vm, Common::SeekableReadStream *rlstStream, MystResource *parent) : MystResourceType8(vm, rlstStream, parent) {
+	_kind = rlstStream->readUint16LE();
+	// NOTE: l,r,t,b differs from standard l,t,r,b order
+	_rect10.left = rlstStream->readUint16LE();
+	_rect10.right = rlstStream->readUint16LE();
+	_rect10.top = rlstStream->readUint16LE();
+	_rect10.bottom = rlstStream->readUint16LE();
+	_u0 = rlstStream->readUint16LE();
+	_u1 = rlstStream->readUint16LE();
+	_mouseDownOpcode = rlstStream->readUint16LE();
+	_mouseDragOpcode = rlstStream->readUint16LE();
+	_mouseUpOpcode = rlstStream->readUint16LE();
+
+	// TODO: Need to work out meaning of kind...
+	debugC(kDebugResource, "\tkind: %d", _kind);
+	debugC(kDebugResource, "\trect10.left: %d", _rect10.left);
+	debugC(kDebugResource, "\trect10.right: %d", _rect10.right);
+	debugC(kDebugResource, "\trect10.top: %d", _rect10.top);
+	debugC(kDebugResource, "\trect10.bottom: %d", _rect10.bottom);
+	debugC(kDebugResource, "\tu0: %d", _u0);
+	debugC(kDebugResource, "\tu1: %d", _u1);
+	debugC(kDebugResource, "\t_mouseDownOpcode: %d", _mouseDownOpcode);
+	debugC(kDebugResource, "\t_mouseDragOpcode: %d", _mouseDragOpcode);
+	debugC(kDebugResource, "\t_mouseUpOpcode: %d", _mouseUpOpcode);
+
+	// TODO: Think that u0 and u1 are unused in Type 10
+	if (_u0)
+		warning("Type 10 u0 non-zero");
+	if (_u1)
+		warning("Type 10 u1 non-zero");
+
+	// TODO: Not sure about order of Mouse Down, Mouse Drag and Mouse Up
+	//       Or whether this is slightly different...
+	printf("Type 10 _mouseDownOpcode: %d\n", _mouseDownOpcode);
+	printf("Type 10 _mouseDragOpcode: %d\n", _mouseDragOpcode);
+	printf("Type 10 _mouseUpOpcode: %d\n", _mouseUpOpcode);
+
+	for (byte i = 0; i < 4; i++) {
+		debugC(kDebugResource, "\tList %d:", i);
+
+		_lists[i].listCount = rlstStream->readUint16LE();
+		debugC(kDebugResource, "\t%d values", _lists[i].listCount);
+
+		_lists[i].list = new uint16[_lists[i].listCount];
+		for (uint16 j = 0; j < _lists[i].listCount; j++) {
+			_lists[i].list[j] = rlstStream->readUint16LE();
+			debugC(kDebugResource, "\tValue %d: %d", j, _lists[i].list[j]);
+		}
+	}
+
+	warning("TODO: Card contains Type 10 Resource - Function not yet implemented");
+}
+
+void MystResourceType10::handleMouseUp() {
+	// TODO
+}
+
+MystResourceType11::MystResourceType11(MohawkEngine_Myst *vm, Common::SeekableReadStream *rlstStream, MystResource *parent) : MystResourceType8(vm, rlstStream, parent) {
+	_kind = rlstStream->readUint16LE();
+	// NOTE: l,r,t,b differs from standard l,t,r,b order
+	_rect11.left = rlstStream->readUint16LE();
+	_rect11.right = rlstStream->readUint16LE();
+	_rect11.top = rlstStream->readUint16LE();
+	_rect11.bottom = rlstStream->readUint16LE();
+	_u0 = rlstStream->readUint16LE();
+	_u1 = rlstStream->readUint16LE();
+	_mouseDownOpcode = rlstStream->readUint16LE();
+	_mouseDragOpcode = rlstStream->readUint16LE();
+	_mouseUpOpcode = rlstStream->readUint16LE();
+
+	debugC(kDebugResource, "\tkind: %d", _kind);
+	debugC(kDebugResource, "\trect11.left: %d", _rect11.left);
+	debugC(kDebugResource, "\trect11.right: %d", _rect11.right);
+	debugC(kDebugResource, "\trect11.top: %d", _rect11.top);
+	debugC(kDebugResource, "\trect11.bottom: %d", _rect11.bottom);
+	debugC(kDebugResource, "\tu0: %d", _u0);
+	debugC(kDebugResource, "\tu1: %d", _u1);
+	debugC(kDebugResource, "\t_mouseDownOpcode: %d", _mouseDownOpcode);
+	debugC(kDebugResource, "\t_mouseDragOpcode: %d", _mouseDragOpcode);
+	debugC(kDebugResource, "\t_mouseUpOpcode: %d", _mouseUpOpcode);
+
+	// TODO: Think that u0 and u1 are unused in Type 11
+	if (_u0)
+		warning("Type 11 u0 non-zero");
+	if (_u1)
+		warning("Type 11 u1 non-zero");
+
+	// TODO: Not sure about order of Mouse Down, Mouse Drag and Mouse Up
+	//       Or whether this is slightly different...
+	printf("Type 11 _mouseDownOpcode: %d\n", _mouseDownOpcode);
+	printf("Type 11 _mouseDragOpcode: %d\n", _mouseDragOpcode);
+	printf("Type 11 _mouseUpOpcode: %d\n", _mouseUpOpcode);
+
+	for (byte i = 0; i < 3; i++) {
+		debugC(kDebugResource, "\tList %d:", i);
+
+		_lists[i].listCount = rlstStream->readUint16LE();
+		debugC(kDebugResource, "\t%d values", _lists[i].listCount);
+
+		_lists[i].list = new uint16[_lists[i].listCount];
+		for (uint16 j = 0; j < _lists[i].listCount; j++) {
+			_lists[i].list[j] = rlstStream->readUint16LE();
+			debugC(kDebugResource, "\tValue %d: %d", j, _lists[i].list[j]);
+		}
+	}
+
+	warning("TODO: Card contains Type 11 Resource - Function not yet implemented");
+}
+
+void MystResourceType11::handleMouseUp() {
+	// TODO
+
+	// HACK: Myst Card 4059 (Fireplace Code Book) to usuable state
+	if (_mouseDownOpcode == 191) {
+		uint16 tmp = _vm->_varStore->getVar(0);
+		if (tmp > 0)
+			_vm->_varStore->setVar(0, tmp - 1);
+	} else if (_mouseDownOpcode == 190) {
+		_vm->_varStore->setVar(0, _vm->_varStore->getVar(0) + 1);
+	}
+}
+
+MystResourceType12::MystResourceType12(MohawkEngine_Myst *vm, Common::SeekableReadStream *rlstStream, MystResource *parent) : MystResourceType8(vm, rlstStream, parent) {
+	_kind = rlstStream->readUint16LE();
+	// NOTE: l,r,t,b differs from standard l,t,r,b order
+	_rect11.left = rlstStream->readUint16LE();
+	_rect11.right = rlstStream->readUint16LE();
+	_rect11.top = rlstStream->readUint16LE();
+	_rect11.bottom = rlstStream->readUint16LE();
+	_state0Frame = rlstStream->readUint16LE();
+	_state1Frame = rlstStream->readUint16LE();
+	_mouseDownOpcode = rlstStream->readUint16LE();
+	_mouseDragOpcode = rlstStream->readUint16LE();
+	_mouseUpOpcode = rlstStream->readUint16LE();
+
+	debugC(kDebugResource, "\tkind: %d", _kind);
+	debugC(kDebugResource, "\trect11.left: %d", _rect11.left);
+	debugC(kDebugResource, "\trect11.right: %d", _rect11.right);
+	debugC(kDebugResource, "\trect11.top: %d", _rect11.top);
+	debugC(kDebugResource, "\trect11.bottom: %d", _rect11.bottom);
+	debugC(kDebugResource, "\t_state0Frame: %d", _state0Frame);
+	debugC(kDebugResource, "\t_state1Frame: %d", _state1Frame);
+	debugC(kDebugResource, "\t_mouseDownOpcode: %d", _mouseDownOpcode);
+	debugC(kDebugResource, "\t_mouseDragOpcode: %d", _mouseDragOpcode);
+	debugC(kDebugResource, "\t_mouseUpOpcode: %d", _mouseUpOpcode);
+
+	// TODO: Think that u0 and u1 are animation frames to be
+	//       drawn for var == 0 and var == 1
+	printf("Type 12 _state0Frame: %d\n", _state0Frame);
+	printf("Type 12 _state1Frame: %d\n", _state1Frame);
+
+	// TODO: Not sure about order of Mouse Down, Mouse Drag and Mouse Up
+	//       Or whether this is slightly different...
+	printf("Type 12 _mouseDownOpcode: %d\n", _mouseDownOpcode);
+	printf("Type 12 _mouseDragOpcode: %d\n", _mouseDragOpcode);
+	printf("Type 12 _mouseUpOpcode: %d\n", _mouseUpOpcode);
+
+	for (byte i = 0; i < 3; i++) {
+		debugC(kDebugResource, "\tList %d:", i);
+
+		_lists[i].listCount = rlstStream->readUint16LE();
+		debugC(kDebugResource, "\t%d values", _lists[i].listCount);
+
+		_lists[i].list = new uint16[_lists[i].listCount];
+		for (uint16 j = 0; j < _lists[i].listCount; j++) {
+			_lists[i].list[j] = rlstStream->readUint16LE();
+			debugC(kDebugResource, "\tValue %d: %d", j, _lists[i].list[j]);
+		}
+	}
+
+	warning("TODO: Card contains Type 12, Type 11 section Resource - Function not yet implemented");
+
+	_numFrames = rlstStream->readUint16LE();
+	_firstFrame = rlstStream->readUint16LE();
+	uint16 frameWidth = rlstStream->readUint16LE();
+	uint16 frameHeight = rlstStream->readUint16LE();
+	_frameRect.left = rlstStream->readUint16LE();
+	_frameRect.top = rlstStream->readUint16LE();
+
+	_frameRect.right = _frameRect.left + frameWidth;
+	_frameRect.bottom = _frameRect.top + frameHeight;
+
+	debugC(kDebugResource, "\t_numFrames: %d", _numFrames);
+	debugC(kDebugResource, "\t_firstFrame: %d", _firstFrame);
+	debugC(kDebugResource, "\tframeWidth: %d", frameWidth);
+	debugC(kDebugResource, "\tframeHeight: %d", frameHeight);
+	debugC(kDebugResource, "\t_frameRect.left: %d", _frameRect.left);
+	debugC(kDebugResource, "\t_frameRect.top: %d", _frameRect.top);
+	debugC(kDebugResource, "\t_frameRect.right: %d", _frameRect.right);
+	debugC(kDebugResource, "\t_frameRect.bottom: %d", _frameRect.bottom);
+
+	_doAnimation = false;
+}
+
+void MystResourceType12::handleAnimation() {
+	// TODO: Probably not final version. Variable/Type 11 Controlled?
+	if (_doAnimation) {
+		_vm->_gfx->copyImageToScreen(_currentFrame++, _frameRect);
+		if ((_currentFrame - _firstFrame) >= _numFrames)
+			_doAnimation = false;
+	}
+}
+
+void MystResourceType12::handleMouseUp() {
+	// HACK/TODO: Trigger Animation on Mouse Click. Probably not final version. Variable/Type 11 Controlled?
+	_currentFrame = _firstFrame;
+	_doAnimation = true;
+}
+
+MystResourceType13::MystResourceType13(MohawkEngine_Myst *vm, Common::SeekableReadStream *rlstStream, MystResource *parent) : MystResource(vm, rlstStream, parent) {
+	_enterOpcode = rlstStream->readUint16LE();
+	_leaveOpcode = rlstStream->readUint16LE();
+
+	debugC(kDebugResource, "\t_enterOpcode: %d", _enterOpcode);
+	debugC(kDebugResource, "\t_leaveOpcode: %d", _leaveOpcode);
+}
+
+void MystResourceType13::handleMouseEnter() {
+	// Pass along the enter opcode (with no parameters) to the script parser
+	_vm->_scriptParser->runOpcode(_enterOpcode);
+}
+
+void MystResourceType13::handleMouseLeave() {
+	// Pass along the leave opcode (with no parameters) to the script parser
+	_vm->_scriptParser->runOpcode(_leaveOpcode);
+}
+
+void MystResourceType13::handleMouseUp() {
+	// Type 13 Resources do nothing on Mouse Clicks.
+	// This is required to override the inherited default 
+	// i.e. MystResource::handleMouseUp
+}
+
+void MohawkEngine_Myst::runLoadDialog() {
+	runDialog(*_loadDialog);
+}
+
+Common::Error MohawkEngine_Myst::loadGameState(int slot) {
+	if (_saveLoad->loadGame(_saveLoad->generateSaveGameList()[slot])) {
+		changeToStack(kIntroStack);
+		changeToCard(5);
+		return Common::kNoError;
+	} else
+		return Common::kUnknownError;
+}
+
+Common::Error MohawkEngine_Myst::saveGameState(int slot, const char *desc) {
+	Common::StringList saveList = _saveLoad->generateSaveGameList();
+
+	if ((uint)slot < saveList.size()) 
+		_saveLoad->deleteSave(saveList[slot]);
+	
+	return _saveLoad->saveGame(Common::String(desc)) ? Common::kNoError : Common::kUnknownError;
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/myst.h b/engines/mohawk/myst.h
new file mode 100644
index 0000000000..df2e7bb56d
--- /dev/null
+++ b/engines/mohawk/myst.h
@@ -0,0 +1,413 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#ifndef MOHAWK_MYST_H
+#define MOHAWK_MYST_H
+
+#include "mohawk/console.h"
+#include "mohawk/mohawk.h"
+#include "mohawk/myst_vars.h"
+
+#include "gui/saveload.h"
+
+namespace Mohawk {
+
+class MohawkEngine_Myst;
+class VideoManager;
+class MystGraphics;
+class MystScriptParser;
+class MystConsole;
+class MystSaveLoad;
+
+// Engine Debug Flags
+enum {
+	kDebugVariable = (1 << 0),
+	kDebugSaveLoad = (1 << 1),
+	kDebugView     = (1 << 2),
+	kDebugHint     = (1 << 3),
+	kDebugResource = (1 << 4),
+	kDebugINIT     = (1 << 5),
+	kDebugEXIT     = (1 << 6),
+	kDebugScript   = (1 << 7),
+	kDebugHelp     = (1 << 8)
+};
+
+// Myst Stacks
+enum {
+	kChannelwoodStack = 0,	// Channelwood Age
+	kCreditsStack,			// Credits
+	kDemoStack,				// Demo Main Menu
+	kDniStack,				// D'ni
+	kIntroStack,			// Intro
+	kMakingOfStack,			// Making Of Myst
+	kMechanicalStack,		// Mechanical Age
+	kMystStack,				// Myst Island
+	kSeleniticStack,		// Selenitic Age
+	kDemoSlidesStack,		// Demo Slideshow
+	kDemoPreviewStack,		// Demo Myst Library Preview
+	kStoneshipStack			// Stoneship Age
+};
+
+const uint16 kMasterpieceOnly = 0xFFFF;
+
+// Myst Resource Types
+// TODO: Other types and such
+enum {
+	kMystForwardResource = 0,
+	kMystLeftResource = 1,
+	kMystRightResource = 2,
+	kMystDownResource = 3,
+	kMystUpResource = 4,
+	kMystActionResource = 5,
+	kMystVideoResource = 6,
+	kMystSwitchResource = 7
+};
+
+// Myst Resource Flags
+// TODO: Figure out other flags
+enum {
+	kMystSubimageEnableFlag = (1 << 0),
+	kMystHotspotEnableFlag  = (1 << 1),
+	kMystUnknownFlag        = (1 << 2),
+	kMystZipModeEnableFlag  = (1 << 3)
+};
+
+struct MystCondition {
+	uint16 var;
+	uint16 numStates;
+	uint16 *values;
+};
+
+// View Sound Action Type
+enum {
+	kMystSoundActionConditional  = -4,
+	kMystSoundActionContinue     = -1,
+	kMystSoundActionChangeVolume = -2,
+	kMystSoundActionStop         = -3
+	// Other positive values are PlayNewSound of that id
+};
+
+struct MystView {
+	uint16 flags;
+
+	// Image Data
+	uint16 conditionalImageCount;
+	MystCondition *conditionalImages;
+	uint16 mainImage;
+
+	// Sound Data
+	int16 sound;
+	uint16 soundVolume;
+	uint16 soundVar;
+	uint16 soundCount;
+	int16 *soundList;
+	uint16 *soundListVolume;
+
+	// Script Resources
+	uint16 scriptResCount;
+	struct ScriptResource {
+		uint16 type;
+		uint16 id; // Not used by type 3
+		// TODO: Type 3 has more. Maybe use a union?
+		uint16 var; // Used by type 3 only
+		uint16 count; // Used by type 3 only
+		uint16 u0; // Used by type 3 only
+		int16 *resource_list; // Used by type 3 only
+	} *scriptResources;
+
+	// Resource ID's
+	uint16 rlst;
+	uint16 hint;
+	uint16 init;
+	uint16 exit;
+};
+
+struct MystScriptEntry {
+	uint16 opcode;
+	uint16 var;
+	uint16 numValues;
+	uint16 *values;
+};
+
+class MystResource {
+public:
+	MystResource(MohawkEngine_Myst *vm, Common::SeekableReadStream *rlstStream, MystResource *parent);
+	virtual ~MystResource() {}
+
+	MystResource *_parent;
+
+	bool contains(Common::Point point) { return _rect.contains(point); }
+	virtual void drawDataToScreen() {}
+	virtual void handleAnimation() {}
+	virtual Common::Rect getRect() { return _rect; }
+	bool isEnabled() { return _enabled; }
+	void setEnabled(bool enabled) { _enabled = enabled; }
+	uint16 getDest() { return _dest; }
+	virtual uint16 getType8Var() { return 0xFFFF; }
+	
+	// Mouse interface
+	virtual void handleMouseUp();
+	virtual void handleMouseDown() {}
+	virtual void handleMouseEnter() {}
+	virtual void handleMouseLeave() {}
+
+protected:
+	MohawkEngine_Myst *_vm;
+
+	uint16 _flags;
+	Common::Rect _rect;
+	uint16 _dest;
+	bool _enabled;
+};
+
+class MystResourceType5 : public MystResource {
+public:
+	MystResourceType5(MohawkEngine_Myst *vm, Common::SeekableReadStream *rlstStream, MystResource *parent);
+	void handleMouseUp();
+
+protected:
+	uint16 _scriptCount;
+	MystScriptEntry *_scripts;
+};
+
+class MystResourceType6 : public MystResourceType5 {
+public:
+	MystResourceType6(MohawkEngine_Myst *vm, Common::SeekableReadStream *rlstStream, MystResource *parent);
+	void handleAnimation();
+
+protected:
+	static Common::String convertMystVideoName(Common::String name);
+	Common::String _videoFile;
+	uint16 _left;
+	uint16 _top;
+	uint16 _loop;
+	uint16 _u0;
+	uint16 _playBlocking;
+	uint16 _playOnCardChange;
+	uint16 _u3;
+
+private:
+	bool _videoRunning;
+};
+
+struct MystResourceType7 : public MystResource {
+public:
+	MystResourceType7(MohawkEngine_Myst *vm, Common::SeekableReadStream *rlstStream, MystResource *parent);
+	virtual ~MystResourceType7() {}
+
+	virtual void drawDataToScreen();
+	virtual void handleAnimation();
+
+	virtual void handleMouseUp();
+	virtual void handleMouseDown();
+	virtual void handleMouseEnter();
+	virtual void handleMouseLeave();
+
+protected:
+	uint16 _var7;
+	uint16 _numSubResources;
+	Common::Array<MystResource*> _subResources;
+};
+
+class MystResourceType8 : public MystResourceType7 {
+public:
+	MystResourceType8(MohawkEngine_Myst *vm, Common::SeekableReadStream *rlstStream, MystResource *parent);
+	void drawDataToScreen();
+	uint16 getType8Var();
+
+protected:
+	uint16 _var8;
+	uint16 _numSubImages;
+	struct SubImage {
+		uint16 wdib;
+		Common::Rect rect;
+	} *_subImages;
+};
+
+// No MystResourceType9!
+
+class MystResourceType10 : public MystResourceType8 {
+public:
+	MystResourceType10(MohawkEngine_Myst *vm, Common::SeekableReadStream *rlstStream, MystResource *parent);
+	void handleMouseUp();
+
+protected:
+	uint16 _kind;
+	Common::Rect _rect10;
+	uint16 _u0;
+	uint16 _u1;
+	uint16 _mouseDownOpcode;
+	uint16 _mouseDragOpcode;
+	uint16 _mouseUpOpcode;
+	struct {
+		uint16 listCount;
+		uint16 *list;
+	} _lists[4];
+};
+
+class MystResourceType11 : public MystResourceType8 {
+public:
+	MystResourceType11(MohawkEngine_Myst *vm, Common::SeekableReadStream *rlstStream, MystResource *parent);
+	void handleMouseUp();
+
+protected:
+	uint16 _kind;
+	Common::Rect _rect11;
+	uint16 _u0;
+	uint16 _u1;
+	uint16 _mouseDownOpcode;
+	uint16 _mouseDragOpcode;
+	uint16 _mouseUpOpcode;
+	struct {
+		uint16 listCount;
+		uint16 *list;
+	} _lists[3];
+};
+
+class MystResourceType12 : public MystResourceType8 {
+public:
+	MystResourceType12(MohawkEngine_Myst *vm, Common::SeekableReadStream *rlstStream, MystResource *parent);
+	void handleAnimation();
+	void handleMouseUp();
+
+protected:
+	uint16 _kind;
+	Common::Rect _rect11;
+	uint16 _state0Frame;
+	uint16 _state1Frame;
+	uint16 _mouseDownOpcode;
+	uint16 _mouseDragOpcode;
+	uint16 _mouseUpOpcode;
+	struct {
+		uint16 listCount;
+		uint16 *list;
+	} _lists[3];
+
+	uint16 _numFrames;
+	uint16 _firstFrame;
+	Common::Rect _frameRect;
+
+private:
+	bool _doAnimation;
+	uint16 _currentFrame;
+};
+
+class MystResourceType13 : public MystResource {
+public:
+	MystResourceType13(MohawkEngine_Myst *vm, Common::SeekableReadStream *rlstStream, MystResource *parent);
+	void handleMouseUp();
+	void handleMouseEnter();
+	void handleMouseLeave();
+
+protected:
+	uint16 _enterOpcode;
+	uint16 _leaveOpcode;
+};
+
+struct MystCursorHint {
+	uint16 id;
+	int16 cursor;
+
+	MystCondition variableHint;
+};
+
+class MohawkEngine_Myst : public MohawkEngine {
+protected:
+	Common::Error run();
+
+public:
+	MohawkEngine_Myst(OSystem *syst, const MohawkGameDescription *gamedesc);
+	virtual ~MohawkEngine_Myst();
+
+	Common::String wrapMovieFilename(Common::String movieName, uint16 stack);
+
+	void reloadSaveList();
+	void runLoadDialog();
+	void runSaveDialog();
+
+	void changeToStack(uint16 stack);
+	void changeToCard(uint16 card);
+	uint16 getCurCard() { return _curCard; }
+	uint16 getCurStack() { return _curStack; }
+	void setMainCursor(uint16 cursor);
+
+	MystVar *_varStore;
+
+	bool _zipMode;
+	bool _transitionsEnabled;
+	bool _tweaksEnabled;
+	bool _needsUpdate;
+
+	MystView _view;
+	MystGraphics *_gfx;
+	MystSaveLoad *_saveLoad;
+	MystScriptParser *_scriptParser;
+
+	bool _showResourceRects;
+	void setResourceEnabled(uint16 resourceId, bool enable);
+
+	GUI::Debugger *getDebugger() { return _console; }
+	
+	bool canLoadGameStateCurrently() { return !(getFeatures() & GF_DEMO); }
+	bool canSaveGameStateCurrently() { return !(getFeatures() & GF_DEMO); }
+	Common::Error loadGameState(int slot);
+	Common::Error saveGameState(int slot, const char *desc);
+	bool hasFeature(EngineFeature f) const;
+
+private:
+	MystConsole *_console;
+	GUI::SaveLoadChooser *_loadDialog;
+	MystOptionsDialog *_optionsDialog;
+
+	uint16 _curStack;
+	uint16 _curCard;
+
+	bool _runExitScript;
+
+	void loadCard();
+	void unloadCard();
+	void runInitScript();
+	void runExitScript();
+
+	void loadHelp(uint16 id);
+
+	Common::Array<MystResource*> _resources;
+	void loadResources();
+	void drawResourceRects();
+	void checkCurrentResource();
+	int16 _curResource;
+
+	uint16 _cursorHintCount;
+	MystCursorHint *_cursorHints;
+	void loadCursorHints();
+	void checkCursorHints();
+	Common::Point _mousePos;
+	uint16 _currentCursor;
+	uint16 _mainCursor;	// Also defines the current page being held (white, blue, red, or none)
+};
+
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/myst_jpeg.cpp b/engines/mohawk/myst_jpeg.cpp
new file mode 100644
index 0000000000..c6d0a00ea3
--- /dev/null
+++ b/engines/mohawk/myst_jpeg.cpp
@@ -0,0 +1,66 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "common/system.h"
+#include "graphics/conversion.h" // For YUV2RGB
+
+#include "mohawk/myst_jpeg.h"
+
+namespace Mohawk {
+	
+MystJPEG::MystJPEG() {
+	_jpeg = new Graphics::JPEG();
+	_pixelFormat = g_system->getScreenFormat();
+	
+	// We're going to have to dither if we're running in 8bpp.
+	// We'll take RGBA8888 for best color performance in this case.
+	if (_pixelFormat.bytesPerPixel == 1)
+		_pixelFormat = Graphics::PixelFormat(4, 8, 8, 8, 8, 24, 16, 8, 0);
+}
+
+Graphics::Surface *MystJPEG::decodeImage(Common::SeekableReadStream* stream) {
+	_jpeg->read(stream);
+	Graphics::Surface *ySurface = _jpeg->getComponent(1);
+	Graphics::Surface *uSurface = _jpeg->getComponent(2);
+	Graphics::Surface *vSurface = _jpeg->getComponent(3);
+	
+	Graphics::Surface *finalSurface = new Graphics::Surface();
+	finalSurface->create(ySurface->w, ySurface->h, _pixelFormat.bytesPerPixel);
+	
+	for (uint16 i = 0; i < finalSurface->h; i++) {
+		for (uint16 j = 0; j < finalSurface->w; j++) {
+			byte r = 0, g = 0, b = 0;
+			Graphics::YUV2RGB(*((byte *)ySurface->getBasePtr(j, i)), *((byte *)uSurface->getBasePtr(j, i)), *((byte *)vSurface->getBasePtr(j, i)), r, g, b);
+			if (_pixelFormat.bytesPerPixel == 2)
+				*((uint16 *)finalSurface->getBasePtr(j, i)) = _pixelFormat.RGBToColor(r, g, b);
+			else
+				*((uint32 *)finalSurface->getBasePtr(j, i)) = _pixelFormat.RGBToColor(r, g, b);
+		}
+	}
+	
+	return finalSurface;
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/myst_jpeg.h b/engines/mohawk/myst_jpeg.h
new file mode 100644
index 0000000000..de235ced2c
--- /dev/null
+++ b/engines/mohawk/myst_jpeg.h
@@ -0,0 +1,54 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#ifndef MYST_JPEG_H
+#define MYST_JPEG_H
+
+#include "common/scummsys.h"
+#include "common/stream.h"
+
+#include "graphics/jpeg.h"
+#include "graphics/pixelformat.h"
+ 
+namespace Mohawk {
+
+// Myst JPEG Decoder
+// Basically a wrapper around JPEG which converts to RGB
+
+class MystJPEG {
+public:
+	MystJPEG();
+	~MystJPEG() { delete _jpeg; }
+	
+	Graphics::Surface *decodeImage(Common::SeekableReadStream *stream);
+	
+private:
+	Graphics::PixelFormat _pixelFormat;
+	Graphics::JPEG *_jpeg;
+};
+
+}
+
+#endif
diff --git a/engines/mohawk/myst_pict.cpp b/engines/mohawk/myst_pict.cpp
new file mode 100644
index 0000000000..117c5ec9cc
--- /dev/null
+++ b/engines/mohawk/myst_pict.cpp
@@ -0,0 +1,247 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "common/system.h"
+
+#include "mohawk/myst_pict.h"
+
+namespace Mohawk {
+	
+// The PICT code is based off of the QuickDraw specs:
+// http://developer.apple.com/documentation/mac/QuickDraw/QuickDraw-461.html
+
+MystPICT::MystPICT(MystJPEG *jpegDecoder) {
+	_jpegDecoder = jpegDecoder;
+	_pixelFormat = g_system->getScreenFormat();
+}
+
+Graphics::Surface *MystPICT::decodeImage(Common::SeekableReadStream *stream) {
+	// Skip initial 512 bytes (all 0's)
+	stream->seek(512, SEEK_CUR);
+
+	// Read in the first part of the header
+	/* uint16 fileSize = */ stream->readUint16BE();
+	
+	_imageRect.top = stream->readUint16BE();
+	_imageRect.left = stream->readUint16BE();
+	_imageRect.bottom = stream->readUint16BE();
+	_imageRect.right = stream->readUint16BE();
+	_imageRect.debugPrint(0, "PICT Rect:");
+	
+	Graphics::Surface *image = new Graphics::Surface();
+	image->create(_imageRect.width(), _imageRect.height(), _pixelFormat.bytesPerPixel);
+	
+	// NOTE: This is only a subset of the full PICT format.
+	//     - Only V2 Images Supported
+	//     - JPEG Chunks are Supported
+	//     - DirectBitsRect Chunks are Supported
+	for (uint32 opNum = 0; !stream->eos() && !stream->err() && stream->pos() < stream->size(); opNum++) {
+		uint16 opcode = stream->readUint16BE();
+		debug(2, "Found PICT opcode %04x", opcode);
+		
+		if (opNum == 0 && opcode != 0x0011)
+			error ("Cannot find PICT version opcode");
+		else if (opNum == 1 && opcode != 0x0C00)
+			error ("Cannot find PICT header opcode");
+		
+		if (opcode == 0x0001) {		   // Clip
+			// Ignore
+			uint16 clipSize = stream->readUint16BE();
+			stream->seek(clipSize - 2, SEEK_CUR);
+		} else if (opcode == 0x0007) { // PnSize
+			// Ignore
+			stream->readUint16BE();
+			stream->readUint16BE();
+		} else if (opcode == 0x0011) { // VersionOp
+			uint16 version = stream->readUint16BE();
+			if (version != 0x02FF)
+				error ("Unknown PICT version");
+		} else if (opcode == 0x001E) { // DefHilite
+			// Ignore, Contains no Data
+		} else if (opcode == 0x009A) { // DirectBitsRect
+			decodeDirectBitsRect(stream, image);
+		} else if (opcode == 0x00A1) { // LongComment
+			stream->readUint16BE();
+			uint16 dataSize = stream->readUint16BE();
+			stream->seek(dataSize, SEEK_CUR);
+		} else if (opcode == 0x00FF) { // OpEndPic
+			stream->readUint16BE();
+			break;
+		} else if (opcode == 0x0C00) { // HeaderOp
+			/* uint16 version = */ stream->readUint16BE();
+			stream->readUint16BE(); // Reserved
+			/* uint32 hRes = */ stream->readUint32BE();
+			/* uint32 vRes = */ stream->readUint32BE();
+			Common::Rect origResRect;
+			origResRect.top = stream->readUint16BE();
+			origResRect.left = stream->readUint16BE();
+			origResRect.bottom = stream->readUint16BE();
+			origResRect.right = stream->readUint16BE();
+			stream->readUint32BE(); // Reserved
+		} else if (opcode == 0x8200) { // CompressedQuickTime
+			decodeCompressedQuickTime(stream, image);
+			break;
+		} else {
+			error ("Unknown PICT opcode %04x", opcode);
+		}
+	}
+	
+	return image;
+}
+
+struct DirectBitsRectData {
+	// PixMap
+	struct {
+		uint32 baseAddr;
+		uint16 rowBytes;
+		Common::Rect bounds;
+		uint16 pmVersion;
+		uint16 packType;
+		uint32 packSize;
+		uint32 hRes;
+		uint32 vRes;
+		uint16 pixelType;
+		uint16 pixelSize;
+		uint16 cmpCount;
+		uint16 cmpSize;
+		uint32 planeBytes;
+		uint32 pmTable;
+		uint32 pmReserved;
+	} pixMap;
+	Common::Rect srcRect;
+	Common::Rect dstRect;
+	uint16 mode;
+};
+
+void MystPICT::decodeDirectBitsRect(Common::SeekableReadStream *stream, Graphics::Surface *image) {
+	static const Graphics::PixelFormat directBitsFormat = Graphics::PixelFormat(2, 5, 5, 5, 0, 10, 5, 0, 0);
+
+	Graphics::Surface buffer;
+	buffer.create(image->w, image->h, 2);
+
+	DirectBitsRectData directBitsData;
+	
+	directBitsData.pixMap.baseAddr = stream->readUint32BE();
+	directBitsData.pixMap.rowBytes = stream->readUint16BE();
+	directBitsData.pixMap.bounds.top = stream->readUint16BE();
+	directBitsData.pixMap.bounds.left = stream->readUint16BE();
+	directBitsData.pixMap.bounds.bottom = stream->readUint16BE();
+	directBitsData.pixMap.bounds.right = stream->readUint16BE();
+	directBitsData.pixMap.pmVersion = stream->readUint16BE();
+	directBitsData.pixMap.packType = stream->readUint16BE();
+	directBitsData.pixMap.packSize = stream->readUint32BE();
+	directBitsData.pixMap.hRes = stream->readUint32BE();
+	directBitsData.pixMap.vRes = stream->readUint32BE();
+	directBitsData.pixMap.pixelType = stream->readUint16BE();
+	directBitsData.pixMap.pixelSize = stream->readUint16BE();
+	directBitsData.pixMap.cmpCount = stream->readUint16BE();
+	directBitsData.pixMap.cmpSize = stream->readUint16BE();
+	directBitsData.pixMap.planeBytes = stream->readUint32BE();
+	directBitsData.pixMap.pmTable = stream->readUint32BE();
+	directBitsData.pixMap.pmReserved = stream->readUint32BE();
+	directBitsData.srcRect.top = stream->readUint16BE();
+	directBitsData.srcRect.left = stream->readUint16BE();
+	directBitsData.srcRect.bottom = stream->readUint16BE();
+	directBitsData.srcRect.right = stream->readUint16BE();
+	directBitsData.dstRect.top = stream->readUint16BE();
+	directBitsData.dstRect.left = stream->readUint16BE();
+	directBitsData.dstRect.bottom = stream->readUint16BE();
+	directBitsData.dstRect.right = stream->readUint16BE();
+	directBitsData.mode = stream->readUint16BE();
+	
+	if (directBitsData.pixMap.pixelSize != 16)
+		error("Unhandled directBitsRect bitsPerPixel %d", directBitsData.pixMap.pixelSize);
+	
+	// Read in amount of data per row
+	for (uint16 i = 0; i < directBitsData.pixMap.bounds.height(); i++) {
+		if (directBitsData.pixMap.packType == 1 || directBitsData.pixMap.rowBytes < 8) { // Unpacked, Pad-Byte
+			error("Pack Type = %d, Row Bytes = %d", directBitsData.pixMap.packType, directBitsData.pixMap.rowBytes);
+			// TODO
+		} else if (directBitsData.pixMap.packType == 2) { // Unpacked, No Pad-Byte
+			error("Pack Type = 2");
+			// TODO
+		} else if (directBitsData.pixMap.packType > 2) { // Packed
+			uint16 byteCount = (directBitsData.pixMap.rowBytes > 250) ? stream->readUint16BE() : stream->readByte();
+			decodeDirectBitsLine((byte *)buffer.getBasePtr(0, i), directBitsData.pixMap.rowBytes, stream->readStream(byteCount));
+		}
+	}
+	
+	// Convert from 16-bit to whatever surface we need
+	for (uint16 y = 0; y < buffer.h; y++) {
+		for (uint16 x = 0; x < buffer.w; x++) {
+			byte r = 0, g = 0, b = 0;
+			uint16 color = READ_BE_UINT16(buffer.getBasePtr(x, y));
+			directBitsFormat.colorToRGB(color, r, g, b);
+			*((uint16 *)image->getBasePtr(x, y)) = _pixelFormat.RGBToColor(r, g, b);
+		}
+	}
+}
+
+void MystPICT::decodeDirectBitsLine(byte *out, uint32 length, Common::SeekableReadStream *data) {
+	uint32 dataDecoded = 0;
+	while (data->pos() < data->size() && dataDecoded < length) {
+		byte op = data->readByte();
+		
+		if (op & 0x80) {
+			uint32 runSize = (op ^ 255) + 2;
+			byte value1 = data->readByte();
+			byte value2 = data->readByte();
+			for (uint32 i = 0; i < runSize; i++) {
+				*out++ = value1;
+				*out++ = value2;
+			}
+			dataDecoded += runSize * 2;
+		} else {
+			uint32 runSize = (op + 1) * 2;
+			for (uint32 i = 0; i < runSize; i++)
+				*out++ = data->readByte();
+			dataDecoded += runSize;
+		}
+	}
+	
+	if (length != dataDecoded)
+		warning("Mismatched DirectBits read");
+	delete data;
+}
+	
+// Compressed QuickTime details can be found here: 
+// http://developer.apple.com/documentation/QuickTime/Rm/CompressDecompress/ImageComprMgr/B-Chapter/2TheImageCompression.html
+// http://developer.apple.com/documentation/QuickTime/Rm/CompressDecompress/ImageComprMgr/F-Chapter/6WorkingwiththeImage.html
+// I'm just ignoring that because Myst ME uses none of that extra stuff. The offset is always the same.
+
+void MystPICT::decodeCompressedQuickTime(Common::SeekableReadStream *stream, Graphics::Surface *image) {
+	uint32 dataSize = stream->readUint32BE();
+	uint32 startPos = stream->pos();
+	
+	Graphics::Surface *jpegImage = _jpegDecoder->decodeImage(new Common::SeekableSubReadStream(stream, stream->pos() + 156, stream->pos() + dataSize));
+	stream->seek(startPos + dataSize);
+	
+	image->copyFrom(*jpegImage);
+	
+	jpegImage->free();
+	delete jpegImage;
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/myst_pict.h b/engines/mohawk/myst_pict.h
new file mode 100644
index 0000000000..2d763ca616
--- /dev/null
+++ b/engines/mohawk/myst_pict.h
@@ -0,0 +1,57 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#ifndef MYST_PICT_H
+#define MYST_PICT_H
+
+#include "common/rect.h"
+#include "common/scummsys.h"
+#include "common/stream.h"
+#include "graphics/pixelformat.h"
+#include "graphics/surface.h"
+
+#include "mohawk/myst_jpeg.h"
+
+namespace Mohawk {
+
+class MystPICT {
+public:
+	MystPICT(MystJPEG *jpegDecoder);
+	~MystPICT() {}
+	Graphics::Surface *decodeImage(Common::SeekableReadStream *stream);
+	
+private:
+	MystJPEG *_jpegDecoder;
+	Common::Rect _imageRect;
+	Graphics::PixelFormat _pixelFormat;
+
+	void decodeDirectBitsRect(Common::SeekableReadStream *stream, Graphics::Surface *image);
+	void decodeDirectBitsLine(byte *out, uint32 length, Common::SeekableReadStream *data);
+	void decodeCompressedQuickTime(Common::SeekableReadStream *stream, Graphics::Surface *image);
+};
+
+}
+
+#endif
diff --git a/engines/mohawk/myst_saveload.cpp b/engines/mohawk/myst_saveload.cpp
new file mode 100644
index 0000000000..2f94c9e2fe
--- /dev/null
+++ b/engines/mohawk/myst_saveload.cpp
@@ -0,0 +1,676 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "mohawk/myst.h"
+#include "mohawk/myst_saveload.h"
+
+#include "common/util.h"
+
+namespace Mohawk {
+
+MystSaveLoad::MystSaveLoad(MohawkEngine_Myst *vm, Common::SaveFileManager *saveFileMan) : _vm(vm), _saveFileMan(saveFileMan) {
+	_v = new MystVariables();
+	initMystVariables(_v);
+}
+
+MystSaveLoad::~MystSaveLoad() {
+	delete _v;
+}
+
+Common::StringList MystSaveLoad::generateSaveGameList() {
+	return _saveFileMan->listSavefiles("*.mys");
+}
+
+bool MystSaveLoad::loadGame(Common::String filename) {
+	if (_vm->getFeatures() & GF_DEMO) // Don't load games in the demo
+		return false;
+
+	Common::InSaveFile *loadFile;
+	if (!(loadFile = _saveFileMan->openForLoading(filename.c_str())))
+		return false;
+	debugC(kDebugSaveLoad, "Loading game from \'%s\'", filename.c_str());
+
+	// First, let's make sure we're using a saved game file from this version of Myst
+	// By checking length of file...
+	int32 size = loadFile->size();
+	if ((size == -1)
+	    || (size != 664 && (_vm->getFeatures() & GF_ME))
+	    || (size != 601 && !(_vm->getFeatures() & GF_ME))) {
+		warning ("Incompatible saved game version");
+        // FIXME - Add Support to load original game saves in ME and vice versa
+		delete loadFile;
+		return false;
+	}
+
+	// Now, we'll read in the variable values.
+	// Lots of checking code here so that save files with differing formats are flagged...
+	if ((_v->game_globals[0] = loadFile->readUint16LE()) != 2)
+		warning("Unexpected value at 0x%03X - Found %u Expected %u", loadFile->pos(), _v->game_globals[0], 2);
+
+	_v->game_globals[1] = loadFile->readUint16LE();
+	_v->game_globals[2] = loadFile->readUint16LE();
+
+	if ((_v->game_globals[3] = loadFile->readUint16LE()) != 1)
+		warning("Unexpected value at 0x%03X - Found %u Expected %u", loadFile->pos(), _v->game_globals[3], 1);
+
+	_v->game_globals[4] = loadFile->readUint16LE();
+	_v->game_globals[5] = loadFile->readUint16LE();
+	_v->game_globals[6] = loadFile->readUint16LE();
+	_v->game_globals[7] = loadFile->readUint16LE();
+
+	for (byte i = 0; i < 8; i++) {
+		if (_vm->getFeatures() & GF_ME) {
+			_v->myst_vars[i] = loadFile->readUint16LE();
+
+			if (loadFile->readUint16LE() != 0)
+				warning("Non-zero value at 0x%03X", loadFile->pos());
+		} else
+			_v->myst_vars[i] = loadFile->readByte();
+
+		if (_v->myst_vars[i] > 1)
+			warning("Non-Boolean value found at 0x%03X - Found %u", loadFile->pos(), _v->myst_vars[i]);
+	}
+
+	if ((_v->myst_vars[8] = loadFile->readUint16LE()) > 1)
+		warning("Non-Boolean value found at 0x%03X - Found %u", loadFile->pos(), _v->myst_vars[8]);
+
+	if ((_v->myst_vars[9] = loadFile->readUint16LE()) > 1)
+		warning("Non-Boolean value found at 0x%03X - Found %u", loadFile->pos(), _v->myst_vars[9]);
+
+	if ((_v->myst_vars[10] = loadFile->readUint16LE()) > 25)
+		warning("Value exceeds maximum of %u found at 0x%03X - Found %u", 25, loadFile->pos(), _v->myst_vars[10]);
+
+	if ((_v->myst_vars[11] = loadFile->readUint16LE()) > 11)
+		warning("Value exceeds maximum of %u found at 0x%03X - Found %u", 11, loadFile->pos(), _v->myst_vars[11]);
+
+	_v->myst_vars[12] = loadFile->readUint16LE();
+	// TODO: Add validation of valid set for Clock Tower Hour Hand
+
+	if ((_v->myst_vars[13] = loadFile->readUint16LE()) > 1)
+		warning("Non-Boolean value found at 0x%03X - Found %u", loadFile->pos(), _v->myst_vars[13]);
+
+	if ((_v->myst_vars[14] = loadFile->readUint16LE()) > 1)
+		warning("Non-Boolean value found at 0x%03X - Found %u", loadFile->pos(), _v->myst_vars[14]);
+
+	if ((_v->myst_vars[15] = loadFile->readUint16LE()) > 2)
+		warning("Value exceeds maximum of %u found at 0x%03X - Found %u", 2, loadFile->pos(), _v->myst_vars[15]);
+
+	_v->myst_vars[16] = loadFile->readUint16LE();
+	_v->myst_vars[17] = loadFile->readUint16LE();
+
+	if ((_v->myst_vars[18] = loadFile->readUint16LE()) > 1)
+		warning("Non-Boolean value found at 0x%03X - Found %u", loadFile->pos(), _v->myst_vars[18]);
+
+	_v->myst_vars[19] = loadFile->readUint16LE();
+
+	if ((_v->myst_vars[20] = loadFile->readUint16LE()) > 1)
+		warning("Non-Boolean value found at 0x%03X - Found %u", loadFile->pos(), _v->myst_vars[20]);
+
+	if ((_v->myst_vars[21] = loadFile->readUint16LE()) != 0)
+		warning("Non-zero value at 0x%03X - Found %u", loadFile->pos(), _v->myst_vars[21]);
+
+	if ((_v->myst_vars[22] = loadFile->readUint16LE()) != 0)
+		warning("Non-zero value at 0x%03X - Found %u", loadFile->pos(), _v->myst_vars[22]);
+
+	if ((_v->myst_vars[23] = loadFile->readUint16LE()) != 0)
+		warning("Non-zero value at 0x%03X - Found %u", loadFile->pos(), _v->myst_vars[23]);
+
+	if ((_v->myst_vars[24] = loadFile->readUint16LE()) != 0)
+		warning("Non-zero value at 0x%03X - Found %u", loadFile->pos(), _v->myst_vars[24]);
+
+	if ((_v->myst_vars[25] = loadFile->readUint16LE()) > 359)
+		warning("Value exceeds maximum of %u found at 0x%03X - Found %u", 359, loadFile->pos(), _v->myst_vars[25]);
+
+	_v->myst_vars[26] = loadFile->readUint16LE();
+
+	if ((_v->myst_vars[27] = loadFile->readUint16LE()) > 1)
+		warning("Non-Boolean value found at 0x%03X - Found %u", loadFile->pos(), _v->myst_vars[27]);
+
+	_v->myst_vars[28] = loadFile->readUint16LE();
+	if (_v->myst_vars[28] < 1 && _v->myst_vars[28] > 31)
+		warning("Out of Range value found at 0x%03X - Found %u", loadFile->pos(), _v->myst_vars[28]);
+
+	if ((_v->myst_vars[29] = loadFile->readUint16LE()) > 1)
+		warning("Non-Boolean value found at 0x%03X - Found %u", loadFile->pos(), _v->myst_vars[29]);
+
+	if ((_v->myst_vars[30] = loadFile->readUint16LE()) > 11)
+		warning("Value exceeds maximum of %u found at 0x%03X - Found %u", 11, loadFile->pos(), _v->myst_vars[30]);
+
+	if ((_v->myst_vars[31] = loadFile->readUint16LE()) > (24 * 60))
+		warning("Value exceeds maximum of %u found at 0x%03X - Found %u", (24 * 60), loadFile->pos(), _v->myst_vars[31]);
+
+	_v->myst_vars[32] = loadFile->readUint16LE();
+
+	_v->myst_vars[33] = loadFile->readUint16LE();
+	if (_v->myst_vars[33] < 1 && _v->myst_vars[33] > 31)
+		warning("Out of Range value found at 0x%03X - Found %u", loadFile->pos(), _v->myst_vars[33]);
+
+	if ((_v->myst_vars[34] = loadFile->readUint16LE()) > 11)
+		warning("Value exceeds maximum of %u found at 0x%03X - Found %u", 11, loadFile->pos(), _v->myst_vars[34]);
+
+	if ((_v->myst_vars[35] = loadFile->readUint16LE()) > (24 * 60))
+		warning("Value exceeds maximum of %u found at 0x%03X - Found %u", (24 * 60), loadFile->pos(), _v->myst_vars[35]);
+
+	_v->myst_vars[36] = loadFile->readUint16LE();
+
+	if ((_v->myst_vars[37] = loadFile->readUint16LE()) > 999)
+		warning("Value exceeds maximum of %u found at 0x%03X - Found %u", 999, loadFile->pos(), _v->myst_vars[37]);
+
+	if ((_v->myst_vars[38] = loadFile->readUint16LE()) > 12)
+		warning("Value exceeds maximum of %u found at 0x%03X - Found %u", 12, loadFile->pos(), _v->myst_vars[38]);
+
+	_v->myst_vars[39] = loadFile->readUint16LE();
+	_v->myst_vars[40] = loadFile->readUint16LE();
+
+	_v->myst_vars[41] = loadFile->readUint16LE();
+	_v->myst_vars[42] = loadFile->readUint16LE();
+	_v->myst_vars[43] = loadFile->readUint16LE();
+	_v->myst_vars[44] = loadFile->readUint16LE();
+	_v->myst_vars[45] = loadFile->readUint16LE();
+
+	_v->myst_vars[46] = loadFile->readUint16LE();
+	_v->myst_vars[47] = loadFile->readUint16LE();
+	_v->myst_vars[48] = loadFile->readUint16LE();
+	_v->myst_vars[49] = loadFile->readUint16LE();
+
+	for (byte i = 0; i < 4; i++) {
+		if (_vm->getFeatures() & GF_ME) {
+			_v->channelwood_vars[i] = loadFile->readUint16LE();
+
+			if (loadFile->readUint16LE() != 0)
+				warning("Non-zero value at 0x%03X", loadFile->pos());
+		} else
+			_v->channelwood_vars[i] = loadFile->readByte();
+
+		if (_v->channelwood_vars[i] > 1)
+			warning("Non-Boolean value found at 0x%03X - Found %u", loadFile->pos(), _v->channelwood_vars[i]);
+	}
+
+	_v->channelwood_vars[4] = loadFile->readUint16LE();
+
+	if ((_v->channelwood_vars[5] = loadFile->readUint16LE()) > 3)
+		warning("Value exceeds maximum of %u found at 0x%03X - Found %u", 3, loadFile->pos(), _v->channelwood_vars[5]);
+
+	if ((_v->channelwood_vars[6] = loadFile->readUint16LE()) > 1)
+		warning("Non-Boolean value found at 0x%03X - Found %u", loadFile->pos(), _v->channelwood_vars[6]);
+
+	if (_vm->getFeatures() & GF_ME) {
+		if (loadFile->readUint16LE() != 0)
+			warning("Non-zero value at 0x%03X", loadFile->pos());
+
+		if (loadFile->readUint16LE() != 0)
+			warning("Non-zero value at 0x%03X", loadFile->pos());
+	} else if (loadFile->readByte() != 0)
+		warning("Non-zero value at 0x%03X", loadFile->pos());
+
+	for (byte i = 0; i < 3; i++)
+		if ((_v->mech_vars[i] = loadFile->readUint16LE()) > 1)
+			warning("Non-Boolean value found at 0x%03X - Found %u", loadFile->pos(), _v->mech_vars[i]);
+
+	_v->mech_vars[3] = loadFile->readUint16LE();
+	for (byte i = 4; i < 8; i++)
+		if ((_v->mech_vars[i] = loadFile->readUint16LE()) > 9)
+			warning("Value exceeds maximum of %u found at 0x%03X - Found %u", 9, loadFile->pos(), _v->mech_vars[i]);
+
+	for (byte i = 0; i < 7; i++) {
+		if (_vm->getFeatures() & GF_ME) {
+			_v->selenitic_vars[i] = loadFile->readUint16LE();
+
+			if (loadFile->readUint16LE() != 0)
+				warning("Non-zero value at 0x%03X", loadFile->pos());
+		} else
+			_v->selenitic_vars[i] = loadFile->readByte();
+
+		if (_v->selenitic_vars[i] > 1)
+			warning("Non-Boolean value found at 0x%03X - Found %u", loadFile->pos(), _v->selenitic_vars[i]);
+	}
+
+	for(byte i = 7; i < 18; i++)
+		_v->selenitic_vars[i] = loadFile->readUint16LE();
+
+	for (byte i = 0; i < 3; i++) {
+		if (_vm->getFeatures() & GF_ME) {
+			_v->stoneship_vars[i] = loadFile->readUint16LE();
+		} else
+			_v->stoneship_vars[i] = loadFile->readByte();
+
+		if (_v->stoneship_vars[i] > 1)
+			warning("Non-Boolean value found at 0x%03X - Found %u", loadFile->pos(), _v->selenitic_vars[i]);
+	}
+	for (byte i = 3; i < 14; i++)
+		_v->stoneship_vars[i] = loadFile->readUint16LE();
+
+	for (byte i = 0; i < 1; i++)
+		_v->dunny_vars[i] = loadFile->readUint16LE();
+
+	// Reading unknown region...
+	// When Zero Value regions are included, these are 5 blocks of
+	// 41 uint16 values.
+
+	for (byte i = 0; i < 31; i++)
+		_v->unknown_myst[i] = loadFile->readUint16LE();
+
+	for (byte i = 0; i < 10; i++) {
+		if (loadFile->readUint16LE() != 0)
+			warning("Non-zero value at 0x%03X", loadFile->pos());
+	}
+
+	for (byte i = 0; i < 37; i++)
+		_v->unknown_channelwood[i] = loadFile->readUint16LE();
+
+	for (byte i = 0; i < 4; i++) {
+		if (loadFile->readUint16LE() != 0)
+			warning("Non-zero value at 0x%03X", loadFile->pos());
+	}
+
+	for (byte i = 0; i < 18; i++)
+		_v->unknown_mech[i] = loadFile->readUint16LE();
+
+	for (byte i = 0; i < 23; i++) {
+		if (loadFile->readUint16LE() != 0)
+			warning("Non-zero value at 0x%03X", loadFile->pos());
+	}
+
+	for (byte i = 0; i < 30; i++)
+		_v->unknown_selenitic[i] = loadFile->readUint16LE();
+
+	for (byte i = 0; i < 11; i++) {
+		if (loadFile->readUint16LE() != 0)
+			warning("Non-zero value at 0x%03X", loadFile->pos());
+	}
+
+	for (byte i = 0; i < 22; i++)
+		_v->unknown_stoneship[i] = loadFile->readUint16LE();
+
+	for (byte i = 0; i < 19; i++) {
+		if (loadFile->readUint16LE() != 0)
+			warning("Non-zero value at 0x%03X", loadFile->pos());
+	}
+
+	if (_vm->getFeatures() & GF_ME) {
+		if (loadFile->pos() != 664)
+			warning("Unexpected File Position 0x%03X At End of Load", loadFile->pos());
+	} else {
+		if (loadFile->pos() != 601)
+			warning("Unexpected File Position 0x%03X At End of Load", loadFile->pos());
+	}
+
+	delete loadFile;
+
+	debug_printMystVariables(_v);
+
+	return true;
+}
+
+bool MystSaveLoad::saveGame(Common::String filename) {
+	// Make sure we have the right extension
+	if (!filename.hasSuffix(".mys") && !filename.hasSuffix(".MYS"))
+		filename += ".mys";
+
+	Common::OutSaveFile *saveFile;
+	if (!(saveFile = _saveFileMan->openForSaving(filename.c_str())))
+		return false;
+	debugC(kDebugSaveLoad, "Saving game to \'%s\'", filename.c_str());
+
+	debug_printMystVariables(_v);
+
+	// Performs no validation of variable values - Assumes they are valid.
+	for (byte i = 0; i < 8; i++)
+		saveFile->writeUint16LE(_v->game_globals[i]);
+
+	for (byte i = 0; i < 8; i++) {
+		if (_vm->getFeatures() & GF_ME) {
+			saveFile->writeUint16LE(_v->myst_vars[i]);
+			saveFile->writeUint16LE(0);
+		} else
+			saveFile->writeByte(_v->myst_vars[i]);
+	}
+
+	for (byte i = 8; i < 50; i++)
+		saveFile->writeUint16LE(_v->myst_vars[i]);
+
+	for (byte i = 0; i < 4; i++) {
+		if (_vm->getFeatures() & GF_ME) {
+			saveFile->writeUint16LE(_v->channelwood_vars[i]);
+			saveFile->writeUint16LE(0);
+		} else
+			saveFile->writeByte(_v->channelwood_vars[i]);
+	}
+
+	for (byte i = 4; i < 7; i++)
+		saveFile->writeUint16LE(_v->channelwood_vars[i]);
+
+	if (_vm->getFeatures() & GF_ME) {
+		saveFile->writeUint16LE(0);
+		saveFile->writeUint16LE(0);
+	} else
+		saveFile->writeByte(0);
+
+	for (byte i = 0; i < 8; i++)
+		saveFile->writeUint16LE(_v->mech_vars[i]);
+
+	for (byte i = 0; i < 7; i++) {
+		if (_vm->getFeatures() & GF_ME) {
+			saveFile->writeUint16LE(_v->selenitic_vars[i]);
+			saveFile->writeUint16LE(0);
+		} else
+			saveFile->writeByte(_v->selenitic_vars[i]);
+	}
+
+	for(byte i = 7; i < 18; i++)
+		saveFile->writeUint16LE(_v->selenitic_vars[i]);
+
+	for (byte i = 0; i < 3; i++) {
+		if (_vm->getFeatures() & GF_ME) {
+			saveFile->writeUint16LE(_v->stoneship_vars[i]);
+		} else
+			saveFile->writeByte(_v->stoneship_vars[i]);
+	}
+	for (byte i = 3; i < 14; i++)
+		saveFile->writeUint16LE(_v->stoneship_vars[i]);
+
+	for (byte i = 0; i < 1; i++)
+		saveFile->writeUint16LE(_v->dunny_vars[i]);
+
+	for (byte i = 0; i < 31; i++)
+		saveFile->writeUint16LE(_v->unknown_myst[i]);
+
+	for (byte i = 0; i < 10; i++)
+		saveFile->writeUint16LE(0);
+
+	for (byte i = 0; i < 37; i++)
+		saveFile->writeUint16LE(_v->unknown_channelwood[i]);
+
+	for (byte i = 0; i < 4; i++)
+		saveFile->writeUint16LE(0);
+
+	for (byte i = 0; i < 18; i++)
+		saveFile->writeUint16LE(_v->unknown_mech[i]);
+
+	for (byte i = 0; i < 23; i++)
+		saveFile->writeUint16LE(0);
+
+	for (byte i = 0; i < 30; i++)
+		saveFile->writeUint16LE(_v->unknown_selenitic[i]);
+
+	for (byte i = 0; i < 11; i++)
+		saveFile->writeUint16LE(0);
+
+	for (byte i = 0; i < 22; i++)
+		saveFile->writeUint16LE(_v->unknown_stoneship[i]);
+
+	for (byte i = 0; i < 19; i++)
+		saveFile->writeUint16LE(0);
+
+	saveFile->finalize();
+
+	delete saveFile;
+
+	return true;
+}
+
+void MystSaveLoad::deleteSave(Common::String saveName) {
+	debugC(kDebugSaveLoad, "Deleting save file \'%s\'", saveName.c_str());
+	_saveFileMan->removeSavefile(saveName.c_str());
+}
+
+void MystSaveLoad::initMystVariables(MystVariables *_tv) {
+	uint8 i;
+
+	// Most of the variables are zero at game start.
+	for (i = 0; i < ARRAYSIZE(_tv->game_globals); i++)
+		_tv->game_globals[i] = 0;
+	for (i = 0; i < ARRAYSIZE(_tv->myst_vars); i++)
+		_tv->myst_vars[i] = 0;
+	for (i = 0; i < ARRAYSIZE(_tv->channelwood_vars); i++)
+		_tv->channelwood_vars[i] = 0;
+	for (i = 0; i < ARRAYSIZE(_tv->mech_vars); i++)
+		_tv->mech_vars[i] = 0;
+	for (i = 0; i < ARRAYSIZE(_tv->selenitic_vars); i++)
+		_tv->selenitic_vars[i] = 0;
+	for (i = 0; i < ARRAYSIZE(_tv->stoneship_vars); i++)
+		_tv->stoneship_vars[i] = 0;
+	for (i = 0; i < ARRAYSIZE(_tv->dunny_vars); i++)
+		_tv->dunny_vars[i] = 0;
+	for (i = 0; i < ARRAYSIZE(_tv->unknown_myst); i++)
+		_tv->unknown_myst[i] = 0;
+	for (i = 0; i < ARRAYSIZE(_tv->unknown_channelwood); i++)
+		_tv->unknown_channelwood[i] = 0;
+	for (i = 0; i < ARRAYSIZE(_tv->unknown_mech); i++)
+		_tv->unknown_mech[i] = 0;
+	for (i = 0; i < ARRAYSIZE(_tv->unknown_selenitic); i++)
+		_tv->unknown_selenitic[i] = 0;
+	for (i = 0; i < ARRAYSIZE(_tv->unknown_stoneship); i++)
+		_tv->unknown_stoneship[i] = 0;
+
+	// TODO: Not all these may be needed as some of the unknown opcodes
+	//        called by init scripts may set these up as per the others..
+
+	// Unknown - Fixed at 2
+	_tv->game_globals[0] = 2;
+	// Current Age / Stack - Start in Myst
+	_tv->game_globals[1] = 2;
+	// Unknown - Fixed at 1
+	_tv->game_globals[3] = 1;
+
+	// Library Bookcase Door - Default to Up
+	_tv->myst_vars[18] = 1;
+	// Dock Imager Numeric Selection - Default to 67
+	_tv->myst_vars[19] = 67;
+	// Dock Imager Active - Default to Active
+	_tv->myst_vars[20] = 1;
+	// Stellar Observatory Lights - Default to On
+	_tv->myst_vars[29] = 1;
+
+	// Lighthouse Trapdoor State - Default to Locked
+	_tv->stoneship_vars[4] = 2;
+	// Lighthouse Chest Water State - Default to Full
+	_tv->stoneship_vars[5] = 1;
+}
+
+static const char *game_globals_names[] = {
+	"Unknown - Fixed at 2",
+	"Current Age / Stack",
+	"Page Being Held",
+	"Unknown - Fixed at 1",
+	"Slide Transistions",
+	"Zip Mode",
+	"Red Pages in Book",
+	"Blue Pages in Book"
+};
+
+static const char *myst_vars_names[] = {
+	"Marker Switch Near Cabin",
+	"Marker Switch Near Clock Tower",
+	"Marker Switch on Dock",
+	"Marker Switch Near Ship Pool",
+	"Marker Switch Near Cogs",
+	"Marker Switch Near Generator Room",
+	"Marker Switch Near Stellar Observatory",
+	"Marker Switch Near Rocket Ship",
+	"Fireplace, Opened Green Book Before",
+	"Ship State",
+	"Cabin Gas Valve Position",
+	"Clock Tower Hour Hand Position",
+	"Clock Tower Minute Hand Position",
+	"Clock Tower Puzzle Solved / Cogs Open",
+	"Clock Tower Gear Bridge",
+	"Generator Breaker State",
+	"Generator Button State",
+	"Generator Voltage State",
+	"Library Bookcase Door",
+	"Dock Imager Numeric Selection",
+	"Dock Imager Active",
+	"Unknown #1 - Fixed at 0",
+	"Unknown #2 - Fixed at 0",
+	"Unknown #3 - Fixed at 0",
+	"Unknown #4 - Fixed at 0",
+	"Tower Rotation Angle",
+	"Boxes For Ship Float Puzzle",
+	"Tree Boiler Pilot Light Lit",
+	"Stellar Observatory Viewer, Control Setting Day",
+	"Stellar Observatory Lights",
+	"Stellar Observatory Viewer, Control Setting Month",
+	"Stellar Observatory Viewer, Control Setting Time",
+	"Stellar Observatory Viewer, Control Setting Year",
+	"Stellar Observatory Viewer, Target Day",
+	"Stellar Observatory Viewer, Target Month",
+	"Stellar Observatory Viewer, Target Time",
+	"Stellar Observatory Viewer, Target Year",
+ 	"Cabin Safe Combination",
+	"Channelwood Tree Position",
+	"Checksum? #1",
+	"Checksum? #2",
+	"Rocketship Music Puzzle Slider #1 Position",
+	"Rocketship Music Puzzle Slider #2 Position",
+	"Rocketship Music Puzzle Slider #3 Position",
+	"Rocketship Music Puzzle Slider #4 Position",
+	"Rocketship Music Puzzle Slider #5 Position",
+	"Unknown #5",
+	"Unknown #6",
+	"Unknown #7",
+	"Unknown #8"
+};
+
+static const char *channelwood_vars_names[] = {
+	"Water Pump Bridge State",
+	"Lower Walkway to Upper Walkway Elevator State",
+	"Lower Walkway to Upper Walkway Spiral Stair Lower Door State",
+	"Extendable Pipe State",
+	"Water Valve States",
+	"Achenar's Holoprojector Selection",
+	"Lower Walkway to Upper Walkway Spiral Stair Upper Door State"
+};
+
+static const char *mech_vars_names[] = {
+	"Achenar's Room Secret Panel State",
+	"Sirrus' Room Secret Panel State",
+	"Fortress Staircase State",
+	"Fortress Elevator Rotation",
+	"Code Lock Shape #1 (Left)",
+	"Code Lock Shape #2",
+	"Code Lock Shape #3",
+	"Code Lock Shape #4 (Right)"
+};
+
+static const char *selenitic_vars_names[] = {
+	"Sound Pickup At Water Pool",
+	"Sound Pickup At Volcanic Crack",
+	"Sound Pickup At Clock",
+	"Sound Pickup At Crystal Rocks",
+	"Sound Pickup At Windy Tunnel",
+	"Sound Receiver Doors",
+	"Windy Tunnel Lights",
+	"Sound Receiver Current Input",
+	"Sound Receiver Input #0 (Water Pool) Angle Value",
+	"Sound Receiver Input #1 (Volcanic Crack) Angle Value",
+	"Sound Receiver Input #2 (Clock) Angle Value",
+	"Sound Receiver Input #3 (Crystal Rocks) Angle Value",
+	"Sound Receiver Input #4 (Windy Tunnel) Angle Value",
+	"Sound Lock Slider #1 (Left) Position",
+	"Sound Lock Slider #2 Position",
+	"Sound Lock Slider #3 Position",
+	"Sound Lock Slider #4 Position",
+	"Sound Lock Slider #5 (Right) Position"
+};
+
+static const char *stoneship_vars_names[] = {
+	"Light State",
+	"Unknown #1",
+	"Unknown #2",
+	"Water Pump State",
+	"Lighthouse Trapdoor State",
+	"Lighthouse Chest Water State",
+	"Lighthouse Chest Valve State",
+	"Lighthouse Chest Open State",
+	"Lighthouse Trapdoor Key State",
+	"Lighthouse Generator Power Level(?)",
+	"Lighthouse Generator Power...?",
+	"Lighthouse Generator Power Good",
+	"Lighthouse Generator Power #1 ?",
+	"Lighthouse Generator Power #2?"
+};
+
+static const char *dunny_vars_names[] = {
+	"Outcome State"
+};
+
+void MystSaveLoad::debug_printMystVariables(MystVariables *_tv) {
+	uint8 i;
+
+	debugC(kDebugSaveLoad, "Printing Myst Variable State:");
+
+	debugC(kDebugSaveLoad, "  Game Globals:");
+	for (i = 0; i < ARRAYSIZE(_tv->game_globals); i++)
+		debugC(kDebugSaveLoad, "    %s: %u", game_globals_names[i], _tv->game_globals[i]);
+
+	debugC(kDebugSaveLoad, "  Myst Variables:");
+	for (i = 0; i < ARRAYSIZE(_tv->myst_vars); i++)
+		debugC(kDebugSaveLoad, "    %s: %u", myst_vars_names[i], _tv->myst_vars[i]);
+
+	debugC(kDebugSaveLoad, "  Channelwood Variables:");
+	for (i = 0; i < ARRAYSIZE(_tv->channelwood_vars); i++)
+		debugC(kDebugSaveLoad, "    %s: %u", channelwood_vars_names[i], _tv->channelwood_vars[i]);
+
+	debugC(kDebugSaveLoad, "  Mech Variables:");
+	for (i = 0; i < ARRAYSIZE(_tv->mech_vars); i++)
+		debugC(kDebugSaveLoad, "    %s: %u", mech_vars_names[i], _tv->mech_vars[i]);
+
+	debugC(kDebugSaveLoad, "  Selenitic Variables:");
+	for (i = 0; i < ARRAYSIZE(_tv->selenitic_vars); i++)
+		debugC(kDebugSaveLoad, "    %s: %u", selenitic_vars_names[i], _tv->selenitic_vars[i]);
+
+	debugC(kDebugSaveLoad, "  Stoneship Variables:");
+	for (i = 0; i < ARRAYSIZE(_tv->stoneship_vars); i++)
+		debugC(kDebugSaveLoad, "    %s: %u", stoneship_vars_names[i], _tv->stoneship_vars[i]);
+
+	debugC(kDebugSaveLoad, "  Dunny Variables:");
+	for (i = 0; i < ARRAYSIZE(_tv->dunny_vars); i++)
+		debugC(kDebugSaveLoad, "    %s: %u", dunny_vars_names[i], _tv->dunny_vars[i]);
+
+	debugC(kDebugSaveLoad, "  Other Variables:");
+
+	debugC(kDebugSaveLoad, "    Unknown Myst:");
+	for (i = 0; i < ARRAYSIZE(_tv->unknown_myst); i++)
+		debugC(kDebugSaveLoad, "    %u: 0x%04X - %u", i, _tv->unknown_myst[i], _tv->unknown_myst[i]);
+
+	debugC(kDebugSaveLoad, "    Unknown Channelwood:");
+	for (i = 0; i < ARRAYSIZE(_tv->unknown_channelwood); i++)
+		debugC(kDebugSaveLoad, "    %u: 0x%04X - %u", i, _tv->unknown_channelwood[i], _tv->unknown_channelwood[i]);
+
+	debugC(kDebugSaveLoad, "    Unknown Mech:");
+	for (i = 0; i < ARRAYSIZE(_tv->unknown_mech); i++)
+		debugC(kDebugSaveLoad, "    %u: 0x%04X - %u", i, _tv->unknown_mech[i], _tv->unknown_mech[i]);
+
+	debugC(kDebugSaveLoad, "    Unknown Selenitic:");
+	for (i = 0; i < ARRAYSIZE(_tv->unknown_selenitic); i++)
+		debugC(kDebugSaveLoad, "    %u: 0x%04X - %u", i, _tv->unknown_selenitic[i], _tv->unknown_selenitic[i]);
+
+	debugC(kDebugSaveLoad, "    Unknown Stoneship:");
+	for (i = 0; i < ARRAYSIZE(_tv->unknown_stoneship); i++)
+		debugC(kDebugSaveLoad, "    %u: 0x%04X - %u", i, _tv->unknown_stoneship[i], _tv->unknown_stoneship[i]);
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/myst_saveload.h b/engines/mohawk/myst_saveload.h
new file mode 100644
index 0000000000..0653be0a00
--- /dev/null
+++ b/engines/mohawk/myst_saveload.h
@@ -0,0 +1,212 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#ifndef MYST_SAVELOAD_H
+#define MYST_SAVELOAD_H
+
+#include "common/savefile.h"
+#include "common/file.h"
+#include "common/str.h"
+
+namespace Mohawk {
+
+// These are left as uint16 currently, rather than
+// being changed to bool etc. to save memory.
+// This is because the exact structure
+// is subject to change and the code to implement
+// opcodes to access them is simpler this way..
+struct MystVariables {
+	MystVariables() { memset(this, 0, sizeof(MystVariables)); }
+
+	/* 8 Game Global Variables :
+	   0 = Unknown - Fixed at 2
+	   1 = Current Age / Stack
+	   2 = Page Being Held
+	   3 = Unknown - Fixed at 1
+	   4 = Slide Transistions
+	   5 = Zip Mode
+	   6 = Red Pages in Book
+	   7 = Blue Pages in Book
+	*/
+	uint16 game_globals[8];
+
+	/* 50 Myst Specific Variables :
+	   0  = Marker Switch Near Cabin
+	   1  = Marker Switch Near Clock Tower
+	   2  = Marker Switch on Dock
+	   3  = Marker Switch Near Ship Pool
+	   4  = Marker Switch Near Cogs
+	   5  = Marker Switch Near Generator Room
+	   6  = Marker Switch Near Stellar Observatory
+	   7  = Marker Switch Near Rocket Ship
+	   8  = Fireplace, Opened Green Book Before
+	   9  = Ship State
+	   10 = Cabin Gas Valve Position
+	   11 = Clock Tower Hour Hand Position
+	   12 = Clock Tower Minute Hand Position
+	   13 = Clock Tower Puzzle Solved / Cogs Open
+	   14 = Clock Tower Gear Bridge
+	   15 = Generator Breaker State
+	   16 = Generator Button State
+	   17 = Generator Voltage State
+	   18 = Library Bookcase Door
+	   19 = Dock Imager Numeric Selection
+	   20 = Dock Imager Active
+	   21 = Unknown #1 - Fixed at 0
+	   22 = Unknown #2 - Fixed at 0
+	   23 = Unknown #3 - Fixed at 0
+	   24 = Unknown #4 - Fixed at 0
+	   25 = Tower Rotation Angle
+	   26 = Boxes For Ship Float Puzzle
+	   27 = Tree Boiler Pilot Light Lit
+	   28 = Stellar Observatory Viewer, Control Setting Day
+	   29 = Stellar Observatory Lights
+	   30 = Stellar Observatory Viewer, Control Setting Month
+	   31 = Stellar Observatory Viewer, Control Setting Time
+	   32 = Stellar Observatory Viewer, Control Setting Year
+	   33 = Stellar Observatory Viewer, Target Day
+	   34 = Stellar Observatory Viewer, Target Month
+	   35 = Stellar Observatory Viewer, Target Time
+	   36 = Stellar Observatory Viewer, Target Year
+ 	   37 = Cabin Safe Combination
+	   38 = Channelwood Tree Position
+	   39 = Checksum? #1
+	   40 = Checksum? #2
+	   41 = Rocketship Music Puzzle Slider #1 Position
+	   42 = Rocketship Music Puzzle Slider #2 Position
+	   43 = Rocketship Music Puzzle Slider #3 Position
+	   44 = Rocketship Music Puzzle Slider #4 Position
+	   45 = Rocketship Music Puzzle Slider #5 Position
+	   46 = Unknown #5
+	   47 = Unknown #6
+	   48 = Unknown #7
+	   49 = Unknown #8
+	*/
+	uint16 myst_vars[50];
+
+	/* 7 Channelwood Specific Variables :
+	    0 = Water Pump Bridge State
+	    1 = Lower Walkway to Upper Walkway Elevator State
+	    2 = Lower Walkway to Upper Walkway Spiral Stair Lower Door State
+	    3 = Extendable Pipe State
+	    4 = Water Valve States
+	    5 = Achenar's Holoprojector Selection
+	    6 = Lower Walkway to Upper Walkway Spiral Stair Upper Door State
+	*/
+	uint16 channelwood_vars[7];
+
+	/* 8 Mech Specific Variables :
+	    0 = Achenar's Room Secret Panel State
+	    1 = Sirrus' Room Secret Panel State
+	    2 = Fortress Staircase State
+	    3 = Fortress Elevator Rotation
+	    4 = Code Lock Shape #1 (Left)
+	    5 = Code Lock Shape #2
+	    6 = Code Lock Shape #3
+	    7 = Code Lock Shape #4 (Right)
+	*/
+	uint16 mech_vars[8];
+
+	/* 18 Selenitic Specific Variables :
+	    0 = Sound Pickup At Water Pool
+	    1 = Sound Pickup At Volcanic Crack
+	    2 = Sound Pickup At Clock
+	    3 = Sound Pickup At Crystal Rocks
+	    4 = Sound Pickup At Windy Tunnel
+	    5 = Sound Receiver Doors
+	    6 = Windy Tunnel Lights
+	    7 = Sound Receiver Current Input
+	    8 = Sound Receiver Input #0 (Water Pool) Angle Value
+	    9 = Sound Receiver Input #1 (Volcanic Crack) Angle Value
+	   10 = Sound Receiver Input #2 (Clock) Angle Value
+	   11 = Sound Receiver Input #3 (Crystal Rocks) Angle Value
+	   12 = Sound Receiver Input #4 (Windy Tunnel) Angle Value
+	   13 = Sound Lock Slider #1 (Left) Position
+	   14 = Sound Lock Slider #2 Position
+	   15 = Sound Lock Slider #3 Position
+	   16 = Sound Lock Slider #4 Position
+	   17 = Sound Lock Slider #5 (Right) Position
+	*/
+	uint16 selenitic_vars[18];
+
+	/* 14 Stoneship Specific Variables :
+	    0 = Light State
+	    1 = Unknown #1
+	    2 = Unknown #2
+	    3 = Water Pump State
+	    4 = Lighthouse Trapdoor State
+	    5 = Lighthouse Chest Water State
+	    6 = Lighthouse Chest Valve State
+	    7 = Lighthouse Chest Open State
+	    8 = Lighthouse Trapdoor Key State
+	    9 = Lighthouse Generator Power Level(?)
+	   10 = Lighthouse Generator Power...?
+	   11 = Lighthouse Generator Power Good
+	   12 = Lighthouse Generator Power #1 ?
+	   13 = Lighthouse Generator Power #2?
+	*/
+	uint16 stoneship_vars[14];
+
+	/* 1 Dunny Specific Variable :
+	    0 = Outcome State
+	*/
+	uint16 dunny_vars[1];
+
+    // The values in these regions seem to be lists of resource IDs
+    // which correspond to VIEW resources i.e. cards
+	uint16 unknown_myst[31];
+
+	uint16 unknown_channelwood[37];
+
+	uint16 unknown_mech[18];
+
+	uint16 unknown_selenitic[30];
+
+	uint16 unknown_stoneship[22];
+};
+
+class MohawkEngine_Myst;
+
+class MystSaveLoad {
+public:
+	MystSaveLoad(MohawkEngine_Myst*, Common::SaveFileManager*);
+	~MystSaveLoad();
+
+	Common::StringList generateSaveGameList();
+	bool loadGame(Common::String);
+	bool saveGame(Common::String);
+	void deleteSave(Common::String);
+
+	void initMystVariables(MystVariables *_tv);
+	void debug_printMystVariables(MystVariables *_tv);
+private:
+	MohawkEngine_Myst *_vm;
+	Common::SaveFileManager *_saveFileMan;
+	MystVariables *_v;
+};
+
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/myst_scripts.cpp b/engines/mohawk/myst_scripts.cpp
new file mode 100644
index 0000000000..7c61bfe3c4
--- /dev/null
+++ b/engines/mohawk/myst_scripts.cpp
@@ -0,0 +1,4864 @@
+/* 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$
+ * $Id$
+ *
+ */
+ 
+#include "mohawk/myst.h"
+#include "mohawk/graphics.h"
+#include "mohawk/myst_scripts.h"
+
+#include "gui/message.h"
+
+namespace Mohawk {
+
+const uint8 stack_map[8] = {
+	kSeleniticStack,
+	kStoneshipStack,
+	kMystStack,
+	kMechanicalStack,
+	kChannelwoodStack,
+	0x0f,
+	kDniStack,
+	kMystStack
+};
+
+const uint16 start_card[8] = {
+	1282,
+	2029,
+	4396,
+	6122,
+	3137,
+	0,
+	5038,
+	4134
+};
+
+// NOTE: Credits Start Card is 10000
+
+#define OPCODE(op, x) { op, &MystScriptParser::x, #x }
+
+MystScriptParser::MystScriptParser(MohawkEngine_Myst *vm) : _vm(vm) {
+	setupOpcodes();
+	_invokingResource = NULL;
+}
+	
+MystScriptParser::~MystScriptParser() {
+}
+	
+void MystScriptParser::setupOpcodes() {
+	// "invalid" opcodes do not exist or have not been observed
+	// "unknown" opcodes exist, but their meaning is unknown
+
+	static const MystOpcode myst_opcodes[] = {
+		// "Standard" Opcodes
+		OPCODE(0, toggleBoolean),
+		OPCODE(1, setVar),
+		OPCODE(2, altDest),
+		OPCODE(3, takePage),
+		OPCODE(4, opcode_4),
+		// TODO: Opcode 5 Not Present
+		OPCODE(6, opcode_6),
+		OPCODE(7, opcode_7),
+		OPCODE(8, opcode_8),
+		OPCODE(9, opcode_9),
+		// TODO: Opcode 10 to 11 Not Present
+		OPCODE(12, altDest),
+		OPCODE(13, altDest),
+		OPCODE(14, opcode_14),
+		OPCODE(15, dropPage),
+		OPCODE(16, opcode_16),
+		OPCODE(17, opcode_17),
+		OPCODE(18, opcode_18),
+		OPCODE(19, enableHotspots),
+		OPCODE(20, disableHotspots),
+		OPCODE(21, opcode_21),
+		OPCODE(22, opcode_22),
+		OPCODE(23, opcode_23),
+		OPCODE(24, playSound),
+		// TODO: Opcode 25 Not Present
+		OPCODE(26, opcode_26),
+		OPCODE(27, playSoundBlocking),
+		OPCODE(28, opcode_28),
+		OPCODE(29, opcode_29_33),
+		OPCODE(30, opcode_30),
+		OPCODE(31, opcode_31),
+		OPCODE(32, opcode_32),
+		OPCODE(33, opcode_29_33),
+		OPCODE(34, opcode_34),
+		OPCODE(35, opcode_35),
+		OPCODE(36, changeCursor),
+		OPCODE(37, hideCursor),
+		OPCODE(38, showCursor),
+		OPCODE(39, opcode_39),
+		OPCODE(40, changeStack),
+		OPCODE(41, opcode_41),
+		OPCODE(42, opcode_42),
+		OPCODE(43, opcode_43),
+		OPCODE(44, opcode_44),
+		// TODO: Opcode 45 Not Present
+		OPCODE(46, opcode_46),
+		// TODO: Opcodes 47 to 99 Not Present
+
+		// "Stack-Specific" Opcodes
+		OPCODE(100, opcode_100),
+		OPCODE(101, opcode_101),
+		OPCODE(102, opcode_102),
+		OPCODE(103, opcode_103),
+		OPCODE(104, opcode_104),
+		OPCODE(105, opcode_105),
+		OPCODE(106, opcode_106),
+		OPCODE(107, opcode_107),
+		OPCODE(108, opcode_108),
+		OPCODE(109, opcode_109),
+		OPCODE(110, opcode_110),
+		OPCODE(111, opcode_111),
+		OPCODE(112, opcode_112),
+		OPCODE(113, opcode_113),
+		OPCODE(114, opcode_114),
+		OPCODE(115, opcode_115),
+		OPCODE(116, opcode_116),
+		OPCODE(117, opcode_117),
+		OPCODE(118, opcode_118),
+		OPCODE(119, opcode_119),
+		OPCODE(120, opcode_120),
+		OPCODE(121, opcode_121),
+		OPCODE(122, opcode_122),
+		OPCODE(123, opcode_123),
+		OPCODE(124, opcode_124),
+		OPCODE(125, opcode_125),
+		OPCODE(126, opcode_126),
+		OPCODE(127, opcode_127),
+		OPCODE(128, opcode_128),
+		OPCODE(129, opcode_129),
+		OPCODE(130, opcode_130),
+		OPCODE(131, opcode_131),
+		OPCODE(132, opcode_132),
+		OPCODE(133, opcode_133),
+		// TODO: Opcodes 134 to 146 Not Present
+		OPCODE(147, opcode_147),
+		// TODO: Opcodes 148 to 163 Not Present
+		OPCODE(164, opcode_164),
+		// TODO: Opcodes 165 to 168 Not Present
+		OPCODE(169, opcode_169),
+		// TODO: Opcodes 170 to 181 Not Present
+		OPCODE(182, opcode_182),
+		OPCODE(183, opcode_183),
+		OPCODE(184, opcode_184),
+		OPCODE(185, opcode_185),
+		// TODO: Opcodes 186 to 195 Not Present
+		OPCODE(196, opcode_196), // Demo only
+		OPCODE(197, opcode_197), // Demo only
+		OPCODE(198, opcode_198),
+		OPCODE(199, opcode_199),
+		
+		// "Init" Opcodes
+		OPCODE(200, opcode_200),
+		OPCODE(201, opcode_201),
+		OPCODE(202, opcode_202),
+		OPCODE(203, opcode_203),
+		OPCODE(204, opcode_204),
+		OPCODE(205, opcode_205),
+		OPCODE(206, opcode_206),
+		OPCODE(207, opcode_207),
+		OPCODE(208, opcode_208),
+		OPCODE(209, opcode_209),
+		OPCODE(210, opcode_210),
+		OPCODE(211, opcode_211),
+		OPCODE(212, opcode_212),
+		OPCODE(213, opcode_213),
+		OPCODE(214, opcode_214),
+		OPCODE(215, opcode_215),
+		OPCODE(216, opcode_216),
+		OPCODE(217, opcode_217),
+		OPCODE(218, opcode_218),
+		OPCODE(219, opcode_219),
+		OPCODE(220, opcode_220),
+		OPCODE(221, opcode_221),
+		OPCODE(222, opcode_222),
+		// TODO: Opcodes 223 to 297 Not Present
+		OPCODE(298, opcode_298), // Demo only
+		OPCODE(299, opcode_299), // Demo only
+		
+		// "Exit" Opcodes
+		OPCODE(300, opcode_300),
+		OPCODE(301, opcode_301),
+		OPCODE(302, opcode_302),
+		OPCODE(303, opcode_303),
+		OPCODE(304, opcode_304),
+		OPCODE(305, opcode_305),
+		OPCODE(306, opcode_306),
+		OPCODE(307, opcode_307),
+		OPCODE(308, opcode_308),
+		OPCODE(309, opcode_309),
+		// TODO: Opcodes 310 to 311 Not Present
+		OPCODE(312, opcode_312),
+		// TODO: Opcodes 313 and greater Not Present
+
+		OPCODE(0xFFFF, NOP)
+	};
+	
+	_opcodes = myst_opcodes;
+	_opcodeCount = ARRAYSIZE(myst_opcodes);
+}
+
+void MystScriptParser::disableInitOpcodes() {
+	opcode_200_disable();
+	opcode_201_disable();
+	opcode_202_disable();
+	opcode_203_disable();
+	opcode_204_disable();
+	opcode_205_disable();
+	opcode_206_disable();
+	opcode_209_disable();
+	opcode_210_disable();
+	opcode_211_disable();
+	opcode_212_disable();
+}
+
+void MystScriptParser::runPersistentOpcodes() {
+	opcode_200_run();
+	opcode_201_run();
+	opcode_202_run();
+	opcode_203_run();
+	opcode_204_run();
+	opcode_205_run();
+	opcode_206_run();
+	opcode_209_run();
+	opcode_210_run();
+	opcode_211_run();
+	opcode_212_run();
+}
+
+void MystScriptParser::runScript(uint16 scriptCount, MystScriptEntry *scripts, MystResource *invokingResource) {
+	_invokingResource = invokingResource;
+
+	debugC(kDebugScript, "Script Count: %d", scriptCount);
+	for (uint16 i = 0; i < scriptCount; i++) {
+		debugC(kDebugScript, "\tOpcode %d: %d", i, scripts[i].opcode);
+		runOpcode(scripts[i].opcode, scripts[i].var, scripts[i].numValues, scripts[i].values);
+	}
+}
+
+void MystScriptParser::runOpcode(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	bool ranOpcode = false;
+		
+	for (uint16 i = 0; i < _opcodeCount; i++)
+		if (_opcodes[i].op == op) {
+			(this->*(_opcodes[i].proc)) (op, var, argc, argv);
+			ranOpcode = true;
+			break;
+		}
+		
+	if (!ranOpcode)
+		error ("Trying to run invalid opcode %d", op);
+}
+
+const char *MystScriptParser::getOpcodeDesc(uint16 op) {
+	for (uint16 i = 0; i < _opcodeCount; i++)
+		if (_opcodes[i].op == op)
+			return _opcodes[i].desc;
+
+	error("Unknown opcode %d", op);
+	return "";
+}
+
+// NOTE: Check to be used on Opcodes where var is thought 
+// not to be used. This emits a warning if var is nonzero.
+// It is possible that the opcode does use var 0 in this case,
+// but this will catch the majority of missed cases.
+void MystScriptParser::varUnusedCheck(uint16 op, uint16 var) {
+	if (var != 0)
+		warning("Opcode %d: Unused Var %d", op, var);
+}
+
+void MystScriptParser::unknown(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	// NOTE: printf used here instead of debug, so unknown opcodes are always reported...
+	printf("Unimplemented opcode 0x%02x (%d)\n", op, op);
+	printf("\tUses var %d\n", var);
+	printf("\tArg count = %d\n", argc);
+	if (argc)
+		printf("\tArgs: ");
+	for (uint16 i = 0; i < argc; i++) {
+		if (i == argc - 1)
+			printf("%d\n", argv[i]);
+		else
+			printf("%d, ", argv[i]);
+	}
+}
+
+void MystScriptParser::NOP(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	// NOTE: Don't check argc/argv here as they vary depending on NOP erased opcode
+	debugC(kDebugScript, "NOP");
+}
+
+void MystScriptParser::toggleBoolean(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	if (argc == 0) {
+		debugC(kDebugScript, "Opcode %d: toggleBoolean() var %d", op, var);
+		// HACK: This Mech Card seems to be a special case... Are there others,
+		// or a more general definition of this opcode?
+		if (_vm->getCurStack() == kMechanicalStack && _vm->getCurCard() == 6267)
+			_vm->_varStore->setVar(var, (_vm->_varStore->getVar(var) + 1) % 10);
+		else
+			_vm->_varStore->setVar(var, !_vm->_varStore->getVar(var));
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::setVar(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	if (argc == 1) {
+		debugC(kDebugScript, "Opcode %d: setVar var %d = %d", op, var, argv[0]);
+
+		_vm->_varStore->setVar(var, argv[0]);
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::altDest(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	if (argc == 1) {
+		// TODO: Work out any differences between opcode 2, 12 and 13..
+		debugC(kDebugScript, "Opcode %d: altDest var %d: %d", op, var, _vm->_varStore->getVar(var));
+
+		if (_vm->_varStore->getVar(var))
+			_vm->changeToCard(argv[0]);
+		else if (_invokingResource != NULL)
+			_vm->changeToCard(_invokingResource->getDest());
+		else
+			warning("Missing invokingResource in altDest call");
+	} else 
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::takePage(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	if (argc == 1) {
+		uint16 cursorId = argv[0];
+
+		debugC(kDebugScript, "Opcode %d: takePage Var %d CursorId %d", op, var, cursorId);
+
+		if (_vm->_varStore->getVar(var)) {
+			_vm->setMainCursor(cursorId);
+
+			_vm->_varStore->setVar(var, 0);
+
+			// Return pages that are already held
+			if (var == 102)
+				_vm->_varStore->setVar(103, 1);
+
+			if (var == 103)
+				_vm->_varStore->setVar(102, 1);
+		}
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_4(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	// Used on Exit Script of Mechanical Card 6044 (Fortress Rotation Simulator)
+
+	if (argc == 0 && _vm->getCurStack() == kSeleniticStack && _vm->getCurCard() == 1275) {
+		// TODO: Fixes Selenitic Card 1275, but not sure if this is correct for general case..
+		// as it breaks Selenitic Card 1257, though this may be due to screen update. Also,
+		// this may actually be a "Force Card Reload" or "VIEW conditional re-evaluation".. in
+		// the general case, rather than this image blit...
+		uint16 var_value = _vm->_varStore->getVar(var);
+		if (var_value < _vm->_view.scriptResCount) {
+			if (_vm->_view.scriptResources[var_value].type == 1) // TODO: Add Symbols for Types
+				_vm->_gfx->copyImageToScreen(_vm->_view.scriptResources[var_value].id, Common::Rect(0, 0, 544, 333));
+			else
+				warning("Opcode %d: Script Resource %d Type Not Image", op, var_value);
+		} else
+			warning("Opcode %d: var %d value %d outside Script Resource Range %d", op, var, var_value, _vm->_view.scriptResCount);
+	} else
+		unknown(op, var, argc, argv);
+}
+
+// TODO: Work out difference between Opcode 6, 7 & 8...
+
+void MystScriptParser::opcode_6(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc == 0) {
+		// Used for Selenitic Card 1286 Resource #0
+		// Used for Myst Card 4143 Resource #0 & #5
+		debugC(kDebugScript, "Opcode %d: Change To Dest of Invoking Resource", op);
+
+		if (_invokingResource != NULL)
+			_vm->changeToCard(_invokingResource->getDest());
+		else
+			warning("Opcode %d: Missing invokingResource", op);
+	} else 
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_7(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	if (argc == 0) {
+		// Used for Selenitic Card 1244 Resource #3 Var = 5 (Sound Receiver Doors)
+		// Used for Myst Card 4143 Resource #1 & #6
+		debugC(kDebugScript, "Opcode %d: Change To Dest of Invoking Resource", op);
+		debugC(kDebugScript, "\tVar: %d", var);
+		// TODO: Var used (if non-zero?) in some way to control function...
+
+		if (_invokingResource != NULL)
+			_vm->changeToCard(_invokingResource->getDest());
+		else
+			warning("Opcode %d: Missing invokingResource", op);
+	} else 
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_8(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	if (argc == 0) {
+		// Used for Selenitic Card 1244 Resource #2 Var = 5 (Sound Receiver Doors)
+		debugC(kDebugScript, "Opcode %d: Change To Dest of Invoking Resource", op);
+		debugC(kDebugScript, "\tVar: %d", var);
+		// TODO: Var used (if non-zero?) in some way to control function...
+
+		if (_invokingResource != NULL)
+			_vm->changeToCard(_invokingResource->getDest());
+		else
+			warning("Opcode %d: Missing invokingResource", op);
+	} else 
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_9(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc == 0 || argc == 1) {
+		debugC(kDebugScript, "Opcode %d: Trigger Type 6 Resource Movie..", op);
+		// TODO: Add Logic to do this...
+
+		// Used on Stoneship Card 2138 with 1 argument of 66535 as well as with
+		// no arguments. Seems logically consistent with play movie with optional
+		// start point or time direction control?
+
+		// This understanding of this opcode is based upon Stoneship Card 2197
+		// i.e. Sirrus' Desk, but since this is a single case, we should find
+		// more...
+		if (!((_vm->getCurStack() == kStoneshipStack && _vm->getCurCard() == 2197) ||
+		      (_vm->getCurStack() == kStoneshipStack && _vm->getCurCard() == 2138)))
+			warning("TODO: Opcode 9 on this card - Check function is consistent");			
+	} else 
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_14(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	if (argc == 1) {
+		debugC(kDebugScript, "Opcode %d: Unknown, 1 Argument: %d", op, argv[0]);
+		debugC(kDebugScript, "\tVar: %d", var);
+
+		// TODO: Function Unknown...
+		// Function looks like it changes the Var8 of the invoking resource to argument value..
+		// Most calls seem to have var = 0, but used in Myst Card 4500 (Execute Button)
+		// with Var 105..
+	} else 
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::dropPage(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	if (argc == 0) {
+		debugC(kDebugScript, "Opcode %d: dropPage", op);
+		debugC(kDebugScript, "\tvar: %d", var);
+
+		// TODO: Need to check where this is used
+		_vm->_varStore->setVar(var, 1);
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_16(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	// Used by Channelwood Card 3262 (In Elevator)
+	if (argc == 2) {
+		debugC(kDebugScript, "Opcode %d: Change Card? Conditional?", op);
+
+		uint16 cardId = argv[0];
+		uint16 u0 = argv[1];
+
+		debugC(kDebugScript, "\tcardId: %d", cardId);
+		debugC(kDebugScript, "\tu0: %d", u0);
+
+		// TODO: Finish Implementation... 
+		_vm->changeToCard(cardId);
+	} else
+		unknown(op, var, argc, argv);
+}
+
+// NOTE: Opcode 17 and 18 form a pair, where Opcode 17 jumps to a card,
+// but with the current cardId stored.
+// Opcode 18 then "pops" this stored CardId and returns to that card.
+
+// TODO: The purpose of the optional argv[1] on Opcode 17 and argv[0]
+// on Opcode 18 which are always 4, 5 or 6 is unknown.
+
+static uint16 opcode_17_18_cardId = 0;
+
+void MystScriptParser::opcode_17(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc == 2) {
+		debugC(kDebugScript, "Opcode %d: Jump to Card Id, Storing Current Card Id", op);
+
+		uint16 cardId = argv[0];
+		debugC(kDebugScript, "\tJump to CardId: %d", cardId);
+
+		uint16 u0 = argv[1]; // TODO
+		debugC(kDebugScript, "\tu0: %d", u0);
+
+		opcode_17_18_cardId = _vm->getCurCard();
+
+		debugC(kDebugScript, "\tCurrent CardId: %d", opcode_17_18_cardId);
+
+		_vm->changeToCard(cardId);
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_18(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc == 1) {
+		debugC(kDebugScript, "Opcode %d: Return To Stored Card Id", op);
+		debugC(kDebugScript, "\tCardId: %d", opcode_17_18_cardId);
+
+		uint16 u0 = argv[0];
+		debugC(kDebugScript, "\tu0: %d", u0);
+
+		_vm->changeToCard(opcode_17_18_cardId);
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::enableHotspots(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc > 0) {
+		debugC(kDebugScript, "Opcode %d: Enable Hotspots", op);
+
+		uint16 count = argv[0];
+
+		if (argc != count + 1)
+			unknown(op, var, argc, argv);
+		else {
+			for (uint16 i = 0; i < count; i++) {
+				debugC(kDebugScript, "Enable hotspot index %d", argv[i + 1]);
+				_vm->setResourceEnabled(argv[i + 1], true);
+			}
+		}
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::disableHotspots(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc > 0) {
+		debugC(kDebugScript, "Opcode %d: Disable Hotspots", op);
+
+		uint16 count = argv[0];
+
+		if (argc != count + 1)
+			unknown(op, var, argc, argv);
+		else {
+			for (uint16 i = 0; i < count; i++) {
+				debugC(kDebugScript, "Disable hotspot index %d", argv[i + 1]);
+				if (argv[i + 1] == 0xFFFF) {
+					if (_invokingResource != NULL)
+						_invokingResource->setEnabled(false);
+					else
+						warning("Unknown Resource in disableHotspots script Opcode");
+				} else
+					_vm->setResourceEnabled(argv[i + 1], false);
+			}
+		}
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_21(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc == 6) {
+		// Used in Channelwood Card 3318 (Sirrus' Room Drawer)
+		debugC(kDebugScript, "Opcode %d: Vertical Slide?", op);
+
+		Common::Rect rect1 = Common::Rect(argv[0], argv[1], argv[2], argv[3]);
+		uint16 u0 = argv[4];
+		uint16 u1 = argv[5];
+		
+		debugC(kDebugScript, "\trect1.left: %d", rect1.left);
+		debugC(kDebugScript, "\trect1.top: %d", rect1.top);
+		debugC(kDebugScript, "\trect1.right: %d", rect1.right);
+		debugC(kDebugScript, "\trect1.bottom: %d", rect1.bottom);
+		
+		debugC(kDebugScript, "\tu0: %d", u0);
+		debugC(kDebugScript, "\tu1: %d", u1);
+
+		// TODO: Complete Implementation...
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_22(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc == 0) {
+		if (_invokingResource != NULL)
+			_vm->changeToCard(_invokingResource->getDest());
+		else
+			warning("Missing invokingResource in opcode_22 call");
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_23(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc == 2 || argc == 4) {
+		debugC(kDebugScript, "Opcode %d: Change Resource Enable States", op);
+
+		// Used on Stoneship Card 2080 (Lit Ship Cabin Facing Myst Book Table)
+		// Called when Table is clicked to extrude book.
+
+		// Used on Mechanical Card 6159 (In Front of Staircase to Elevator Control)
+		// Called when Button Pressed.
+
+		for (byte i = 0; i < argc; i++) {
+			debugC(kDebugScript, "\tResource %d Enable set to %d", i, argv[i]);
+			switch (argv[i]) {
+				case 0:
+					_vm->setResourceEnabled(i, false);
+					break;
+				case 1:
+					_vm->setResourceEnabled(i, true);
+					break;
+				default:
+					warning("Opcode %d u%d non-boolean", op, i);
+					_vm->setResourceEnabled(i, true);
+					break;
+			}
+		}
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::playSound(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc == 1) {
+		uint16 soundId = argv[0];
+
+		debugC(kDebugScript, "Opcode %d: playSound", op);
+		debugC(kDebugScript, "\tsoundId: %d", soundId);
+
+		_vm->_sound->playSound(soundId);
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_26(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc == 0) {
+		debugC(kDebugScript, "Opcode %d: Unknown...", op);
+
+		// TODO: Work out function...
+		if (_vm->getCurStack() == kSeleniticStack && _vm->getCurCard() == 1245) {
+			debugC(kDebugScript, "TODO: Function Not Known... Used by Exit Hotspot Resource");
+		} else if (_vm->getCurStack() == kStoneshipStack && _vm->getCurCard() == 2226) {
+			debugC(kDebugScript, "TODO: Function Not Known... Used by Ship Cabin Door");
+		} else if (_vm->getCurStack() == kStoneshipStack && _vm->getCurCard() == 2294) {
+			debugC(kDebugScript, "TODO: Function Not Known... Used by Sirrus' Room Door");
+		} else if (_vm->getCurStack() == kMechanicalStack && _vm->getCurCard() == 6327) {
+			debugC(kDebugScript, "TODO: Function Not Known... Used by Elevator");
+		} else if (_vm->getCurStack() == kDniStack && _vm->getCurCard() == 5014) {
+			debugC(kDebugScript, "TODO: Function Not Known... Used by Atrus");
+		} else
+			unknown(op, var, argc, argv);
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::playSoundBlocking(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc == 1) {
+		uint16 soundId = argv[0];
+
+		debugC(kDebugScript, "Opcode %d: playSoundBlocking", op);
+		debugC(kDebugScript, "\tsoundId: %d", soundId);
+
+		Audio::SoundHandle *handle = _vm->_sound->playSound(soundId);
+
+		while (_vm->_mixer->isSoundHandleActive(*handle))
+			_vm->_system->delayMillis(10);
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_28(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	Common::Rect rect;
+
+	if (argc == 1 || argc == 4) {
+		debugC(kDebugScript, "Opcode %d: Restore VIEW Default Image in Region", op);
+
+		if (argc == 1) {
+			// Used in Stoneship Card 2111 (Compass Rose)
+			// Used in Mechanical Card 6267 (Code Lock)
+			if (argv[0] == 0xFFFF) {
+				rect = _invokingResource->getRect();
+			} else
+				unknown(op, var, argc, argv);
+		} else if (argc == 4) {
+			// Used in ... TODO: Fill in.
+			rect = Common::Rect(argv[0], argv[1], argv[2], argv[3]);
+		} else
+			warning("Opcode %d: argc Error", op);
+
+		debugC(kDebugScript, "\trect.left: %d", rect.left);
+		debugC(kDebugScript, "\trect.top: %d", rect.top);
+		debugC(kDebugScript, "\trect.right: %d", rect.right);
+		debugC(kDebugScript, "\trect.bottom: %d", rect.bottom);
+
+		// TODO: Need to fix VIEW logic so this doesn't need
+		//       calculation at this level.
+		uint16 imageToDraw;
+		if (_vm->_view.conditionalImageCount == 0)
+			imageToDraw = _vm->_view.mainImage;
+		else {
+			for (uint16 i = 0; i < _vm->_view.conditionalImageCount; i++)
+				if (_vm->_varStore->getVar(_vm->_view.conditionalImages[i].var) < _vm->_view.conditionalImages[i].numStates)
+					imageToDraw = _vm->_view.conditionalImages[i].values[_vm->_varStore->getVar(_vm->_view.conditionalImages[i].var)];
+		}
+		_vm->_gfx->copyImageSectionToScreen(imageToDraw, rect, rect);
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_29_33(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	// TODO: Opcode 29 called on Mechanical Card 6178 causes a engine
+	//       abort this is because imageId is 7158 (not valid), but the
+	//       script resource gives this as 7178 (valid)...
+
+	if (argc == 7) {
+		uint16 imageId = argv[0];
+
+		Common::Rect srcRect = Common::Rect(argv[1], argv[2], argv[3], argv[4]);
+
+		Common::Rect dstRect = Common::Rect(argv[5], argv[6], 544, 333);
+
+		if (dstRect.left == -1 || dstRect.top == -1) {
+			// Interpreted as full screen
+			dstRect.left = 0;
+			dstRect.top = 0;
+		}
+
+		dstRect.right = dstRect.left + srcRect.width();
+		dstRect.bottom = dstRect.top + srcRect.height();
+
+		debugC(kDebugScript, "Opcode %d: Blit Image", op);
+		debugC(kDebugScript, "\timageId: %d", imageId);
+		debugC(kDebugScript, "\tsrcRect.left: %d", srcRect.left);
+		debugC(kDebugScript, "\tsrcRect.top: %d", srcRect.top);
+		debugC(kDebugScript, "\tsrcRect.right: %d", srcRect.right);
+		debugC(kDebugScript, "\tsrcRect.bottom: %d", srcRect.bottom);
+		debugC(kDebugScript, "\tdstRect.left: %d", dstRect.left);
+		debugC(kDebugScript, "\tdstRect.top: %d", dstRect.top);
+		debugC(kDebugScript, "\tdstRect.right: %d", dstRect.right);
+		debugC(kDebugScript, "\tdstRect.bottom: %d", dstRect.bottom);
+
+		_vm->_gfx->copyImageSectionToScreen(imageId, srcRect, dstRect);
+	} else
+		unknown(op, var, argc, argv);
+}
+
+// TODO: Implement common engine function for read and processing of sound blocks
+//       for use by this opcode and VIEW sound block.
+// TODO: Though the playSound and PlaySoundBlocking opcodes play sounds immediately,
+//       this opcode changes the main background sound playing..
+//       Current behaviour here and with VIEW sound block is not right as demonstrated
+//       by Channelwood Card 3280 (Tank Valve) and water flow sound behaviour in pipe
+//       on cards leading from shed...
+void MystScriptParser::opcode_30(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	int16 *soundList = NULL;
+	uint16 *soundListVolume = NULL;
+
+	// Used on Stoneship Card 2080
+	// Used on Channelwood Card 3225 with argc = 8 i.e. Conditional Sound List
+	if (argc == 1 || argc == 2 || argc == 8) {
+		debugC(kDebugScript, "Opcode %d: Process Sound Block", op);
+		uint16 decodeIdx = 0;
+
+		int16 soundAction = argv[decodeIdx++];
+		uint16 soundVolume = 65535;
+		if (soundAction == kMystSoundActionChangeVolume || soundAction > 0) {
+			soundVolume = argv[decodeIdx++];
+		} else if (soundAction == kMystSoundActionConditional) {
+			debugC(kDebugScript, "Conditional sound list");
+			uint16 condVar = argv[decodeIdx++];
+			uint16 condVarValue = _vm->_varStore->getVar(condVar);
+			uint16 condCount = argv[decodeIdx++];
+
+			debugC(kDebugScript, "\tcondVar: %d = %d", condVar, condVarValue);
+			debugC(kDebugScript, "\tcondCount: %d", condCount);
+			
+			soundList = new int16[condCount];
+			soundListVolume = new uint16[condCount];
+
+			if (condVarValue >= condCount)
+				warning("Opcode %d: Conditional sound variable outside range",  op);
+			else {
+				for (uint16 i = 0; i < condCount; i++) {
+					soundList[i] = argv[decodeIdx++];
+					debugC(kDebugScript, "\t\tCondition %d: Action %d", i, soundList[i]);
+					if (soundAction == kMystSoundActionChangeVolume || soundAction > 0) {
+						soundListVolume[i] = argv[decodeIdx++];
+					} else
+						soundListVolume[i] = 65535;
+					debugC(kDebugScript, "\t\tCondition %d: Volume %d", i, soundListVolume[i]);
+				}
+
+				soundAction = soundList[condVarValue];
+				soundVolume = soundListVolume[condVarValue];
+			}
+		}
+
+		// NOTE: Mixer only has 8-bit channel volume granularity, 
+		// Myst uses 16-bit? Or is part of this balance?
+		soundVolume = (byte)(soundVolume / 255);
+
+		if (soundAction == kMystSoundActionContinue)
+			debugC(kDebugScript, "Continue current sound");
+		else if (soundAction == kMystSoundActionChangeVolume) {
+			debugC(kDebugScript, "Continue current sound, change volume");
+			debugC(kDebugScript, "\tVolume: %d", soundVolume);
+			// TODO: Implement Volume Control..
+		} else if (soundAction == kMystSoundActionStop) {
+			debugC(kDebugScript, "Stop sound");
+			_vm->_sound->stopSound();
+		} else if (soundAction > 0) {
+			debugC(kDebugScript, "Play new Sound, change volume");
+			debugC(kDebugScript, "\tSound: %d", soundAction);
+			debugC(kDebugScript, "\tVolume: %d", soundVolume);
+			_vm->_sound->stopSound();
+			// TODO: Need to keep sound handle and add function to change volume of
+			// looped running sound for kMystSoundActionChangeVolume type
+			_vm->_sound->playSound(soundAction, true, soundVolume);
+		} else {
+			debugC(kDebugScript, "Unknown");
+			warning("Unknown sound control value in opcode %d", op);
+		}
+	} else
+		unknown(op, var, argc, argv);
+
+	delete[] soundList;
+	soundList = NULL;
+	delete[] soundListVolume;
+	soundListVolume = NULL;
+}
+
+void MystScriptParser::opcode_31(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	// Used on Channelwood Card 3505 (Walkway from Sirrus' Room)
+	if (argc == 2) {
+		debugC(kDebugScript, "Opcode %d: Boolean Choice of Play Sound", op);
+
+		uint16 soundId0 = argv[0];
+		uint16 soundId1 = argv[1];
+
+		debugC(kDebugScript, "\tvar: %d", var);
+		debugC(kDebugScript, "\tsoundId0: %d", soundId0);
+		debugC(kDebugScript, "\tsoundId1: %d", soundId1);
+
+		if (_vm->_varStore->getVar(var)) {
+			if (soundId1)
+				_vm->_sound->playSound(soundId1);
+		} else {
+			if (soundId0)
+				_vm->_sound->playSound(soundId0);
+		}
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_32(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	// Used on Channelwood Card 3503 (Door to Sirrus' Room)
+	// Used on Myst Card 4188 (Door to Cabin)
+	// Used on Myst Card 4363 (Red Book Open)
+	// Used on Myst Card 4371 (Blue Book Open)
+	if (argc == 0) {
+		debugC(kDebugScript, "Opcode %d: Unknown...", op);
+		// TODO: Implement function...
+		// Set Resource 0 Enabled?
+		// or Trigger Movie?
+		// Set resource flag to Enabled?
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_34(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc == 2) {
+		debugC(kDebugScript, "Opcode %d: Change Card (with Delay?)", op);
+
+		uint16 cardId = argv[0];
+		uint16 u0 = argv[1];
+
+		debugC(kDebugScript, "\tTarget Card: %d", cardId);
+		debugC(kDebugScript, "\tu0: %d", u0); // TODO: Delay?
+
+		_vm->changeToCard(cardId);
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_35(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc == 3) {
+		debugC(kDebugScript, "Opcode %d: Draw Full Screen Image, Delay then Change Card", op);
+
+		uint16 imageId = argv[0];
+		uint16 cardId = argv[1];
+		uint16 delay = argv[2]; // TODO: Not sure about argv[2] being delay..
+
+		debugC(kDebugScript, "\timageId: %d", imageId);
+		debugC(kDebugScript, "\tcardId: %d", cardId);
+		debugC(kDebugScript, "\tdelay: %d", delay);
+
+		_vm->_gfx->copyImageToScreen(imageId, Common::Rect(0, 0, 544, 333));
+		_vm->_system->updateScreen();
+		_vm->_system->delayMillis(delay * 100);
+		_vm->changeToCard(cardId);	
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::changeCursor(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc == 1) {
+		debugC(kDebugScript, "Opcode %d: Change Cursor", op);
+		debugC(kDebugScript, "Cursor: %d", argv[0]);
+		
+		// TODO: Not sure if this needs to change mainCursor or similar...
+		_vm->_gfx->changeCursor(argv[0]);
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::hideCursor(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc == 0) {
+		debugC(kDebugScript, "Opcode %d: Hide Cursor", op);
+		_vm->_gfx->hideCursor();
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::showCursor(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc == 0) {
+		debugC(kDebugScript, "Opcode %d: Show Cursor", op);
+		_vm->_gfx->showCursor();
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_39(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc == 1) {
+		// Used on Mechanical Card 6327 (Elevator)
+		debugC(kDebugScript, "Opcode %d: Delay?", op);
+
+		uint16 time = argv[0];
+
+		debugC(kDebugScript, "\tTime: %d", time);
+
+		// TODO: Fill in Function...
+		// May actually be related to movie control.. not sure.
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::changeStack(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	Audio::SoundHandle *handle;
+	varUnusedCheck(op, var);
+
+	if (argc == 3) {
+		debugC(kDebugScript, "Opcode %d: changeStack", op);
+
+		uint16 targetStack = argv[0];
+		uint16 soundIdLinkSrc = argv[1];
+		uint16 soundIdLinkDst = argv[2];
+
+		debugC(kDebugScript, "\tTarget Stack: %d", targetStack);
+		debugC(kDebugScript, "\tSource Stack Link Sound: %d", soundIdLinkSrc);
+		debugC(kDebugScript, "\tDestination Stack Link Sound: %d", soundIdLinkDst);
+
+		_vm->_sound->stopSound();
+
+		if (_vm->getFeatures() & GF_DEMO) {
+
+			// The demo has linking sounds too for this, but it just sounds completely
+			// wrong as you're not actually linking when using this opcode. The sounds are only
+			// played for the full game linking.
+			if (!_vm->_tweaksEnabled) {
+				handle= _vm->_sound->playSound(soundIdLinkSrc);
+				while (_vm->_mixer->isSoundHandleActive(*handle))
+					_vm->_system->delayMillis(10);
+			}
+
+			// No need to have a table for just this data...
+			if (targetStack == 1) {
+				_vm->changeToStack(kDemoSlidesStack);
+				_vm->changeToCard(1000);
+			} else if (targetStack == 2) {
+				_vm->changeToStack(kDemoPreviewStack);
+				_vm->changeToCard(3000);
+			}
+
+			if (!_vm->_tweaksEnabled) {
+				handle = _vm->_sound->playSound(soundIdLinkDst);
+				while (_vm->_mixer->isSoundHandleActive(*handle))
+					_vm->_system->delayMillis(10);
+			}
+		} else {
+			handle = _vm->_sound->playSound(soundIdLinkSrc);
+			while (_vm->_mixer->isSoundHandleActive(*handle))
+				_vm->_system->delayMillis(10);
+
+			// TODO: Play Flyby Entry Movie on Masterpiece Edition..? Only on Myst to Age Link?
+			_vm->changeToStack(stack_map[targetStack]);
+			_vm->changeToCard(start_card[targetStack]);
+
+			handle = _vm->_sound->playSound(soundIdLinkDst);
+			while (_vm->_mixer->isSoundHandleActive(*handle))
+				_vm->_system->delayMillis(10);
+		}
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_41(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	// TODO: Will need to stop immediate screen update on
+	//       Opcode 29 etc. for this to work correctly..
+	//       Also, script processing will have to block U/I
+	//       events etc. for correct sequencing.
+
+	if (argc == 10 || argc == 16) {
+		uint16 cardId = argv[0];
+		uint16 soundId = argv[1];
+		uint16 u0 = argv[2];
+		uint16 u1 = argv[3];
+		Common::Rect region = Common::Rect(argv[4], argv[5], argv[6], argv[7]);
+		uint16 updateDirection = argv[8];
+		uint16 u2 = argv[9];
+
+		Common::Rect region2;
+		uint16 updateDirection2;
+		uint16 u3;
+		if (argc == 16) {
+			region2 = Common::Rect(argv[10], argv[11], argv[12], argv[13]);
+			updateDirection2 = argv[14];
+			u3 = argv[15];
+		}
+
+		debugC(kDebugScript, "Opcode %d: Change Card, Play Sound and Directional Update Screen Region", op);
+		debugC(kDebugScript, "\tCard Id: %d", cardId);
+		debugC(kDebugScript, "\tSound Id: %d", soundId);
+		debugC(kDebugScript, "\tu0: %d", u0);
+		debugC(kDebugScript, "\tu1: %d", u1);
+		debugC(kDebugScript, "\tregion.left: %d", region.left);
+		debugC(kDebugScript, "\tregion.top: %d", region.top);
+		debugC(kDebugScript, "\tregion.right: %d", region.right);
+		debugC(kDebugScript, "\tregion.bottom: %d", region.bottom);
+		debugCN(kDebugScript, "\tupdateDirection: %d = ", updateDirection);
+		
+		switch (updateDirection) {
+			case 0:
+				debugC(kDebugScript, "Left to Right");
+				break;
+			case 1:
+				debugC(kDebugScript, "Right to Left");
+				break;
+			case 5:
+				debugC(kDebugScript, "Top to Bottom");
+				break;
+			case 6:
+				debugC(kDebugScript, "Bottom to Top");
+				break;
+			default:
+				warning("Unknown Update Direction");
+				break;
+		}
+		
+		debugC(kDebugScript, "\tu2: %d", u2); // TODO: Speed / Delay of Update?
+
+		// 10 Argument version Used in:
+		// Selenitic Card 1243 (Sound Receiver Door)
+		// Myst Card 4317 (Generator Room Door)
+
+		if (argc == 16) {
+			// 16 Argument version Used in:
+			// Selenitic Card 1008 and 1010 (Mazerunner Door)
+
+			debugC(kDebugScript, "\tregion2.left: %d", region2.left);
+			debugC(kDebugScript, "\tregion2.top: %d", region2.top);
+			debugC(kDebugScript, "\tregion2.right: %d", region2.right);
+			debugC(kDebugScript, "\tregion2.bottom: %d", region2.bottom);
+			debugCN(kDebugScript, "\tupdateDirection2: %d = ", updateDirection2);
+			 
+			switch (updateDirection2) {
+				case 0:
+					debugC(kDebugScript, "Left to Right");
+					break;
+				case 1:
+					debugC(kDebugScript, "Right to Left");
+					break;
+				case 5:
+					debugC(kDebugScript, "Top to Bottom");
+					break;
+				case 6:
+					debugC(kDebugScript, "Bottom to Top");
+					break;
+				default:
+					warning("Unknown Update Direction");
+					break;
+			}
+			
+			debugC(kDebugScript, "\tu3: %d", u3); // TODO: Speed / Delay of Update?
+		}
+
+		_vm->changeToCard(cardId);
+		_vm->_sound->playSound(soundId);
+		// TODO: Complete Implementation
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_42(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	// TODO: Will need to stop immediate screen update on
+	//       Opcode 29 etc. for this to work correctly..
+	//       Also, script processing will have to block U/I
+	//       events etc. for correct sequencing.
+
+	if (argc == 9 || argc == 15) {
+		uint16 soundId = argv[0];
+		uint16 u0 = argv[1];
+		uint16 u1 = argv[2];
+		Common::Rect region = Common::Rect(argv[3], argv[4], argv[5], argv[6]);
+		uint16 updateDirection = argv[7];
+		uint16 u2 = argv[8];
+
+		Common::Rect region2;
+		uint16 updateDirection2;
+		uint16 u3;
+		if (argc == 15) {
+			region2 = Common::Rect(argv[9], argv[10], argv[11], argv[12]);
+			updateDirection2 = argv[13];
+			u3 = argv[14];
+		}
+
+		debugC(kDebugScript, "Opcode %d: Play Sound and Directional Update Screen Region", op);
+		debugC(kDebugScript, "\tsound: %d", soundId);
+		debugC(kDebugScript, "\tu0: %d", u0);
+		debugC(kDebugScript, "\tu1: %d", u1);
+		debugC(kDebugScript, "\tregion.left: %d", region.left);
+		debugC(kDebugScript, "\tregion.top: %d", region.top);
+		debugC(kDebugScript, "\tregion.right: %d", region.right);
+		debugC(kDebugScript, "\tregion.bottom: %d", region.bottom);
+		debugCN(kDebugScript, "\tupdateDirection: %d = ", updateDirection);
+		
+		switch (updateDirection) {
+			case 0:
+				debugC(kDebugScript, "Left to Right");
+				break;
+			case 1:
+				debugC(kDebugScript, "Right to Left");
+				break;
+			case 5:
+				debugC(kDebugScript, "Top to Bottom");
+				break;
+			case 6:
+				debugC(kDebugScript, "Bottom to Top");
+				break;
+			default:
+				warning("Unknown Update Direction");
+				break;
+		}
+		
+		debugC(kDebugScript, "\tu2: %d", u2); // TODO: Speed / Delay of Update?
+
+		// 9 Argument version Used in:
+		// Myst Card 4730 (Stellar Observatory Door)
+		// Myst Card 4184 (Cabin Door)
+
+		if (argc == 15) {
+			// 15 Argument version Used in:
+			// Channelwood Card 3492 (Achenar's Room Door)
+
+			debugC(kDebugScript, "\tregion2.left: %d", region2.left);
+			debugC(kDebugScript, "\tregion2.top: %d", region2.top);
+			debugC(kDebugScript, "\tregion2.right: %d", region2.right);
+			debugC(kDebugScript, "\tregion2.bottom: %d", region2.bottom);
+			debugCN(kDebugScript, "\tupdateDirection2: %d = ", updateDirection2);
+			
+			switch (updateDirection2) {
+				case 0:
+					debugC(kDebugScript, "Left to Right");
+					break;
+				case 1:
+					debugC(kDebugScript, "Right to Left");
+					break;
+				case 5:
+					debugC(kDebugScript, "Top to Bottom");
+					break;
+				case 6:
+					debugC(kDebugScript, "Bottom to Top");
+					break;
+				default:
+					warning("Unknown Update Direction");
+					break;
+			}
+			
+			debugC(kDebugScript, "\tu3: %d", u3); // TODO: Speed / Delay of Update?
+		}
+
+		_vm->_sound->playSound(soundId);
+		// TODO: Complete Implementation
+	} else
+		unknown(op, var, argc, argv);
+}
+
+// TODO: Are Opcode 43 and 44 enable / disable paired commands?
+
+void MystScriptParser::opcode_43(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc == 0) {
+		debugC(kDebugScript, "Opcode %d: Unknown Function", op);
+
+		// TODO: Function Unknown
+		// Used on Stoneship Card 2154 (Bottom of Lighthouse)
+		// Used on Stoneship Card 2138 (Lighthouse Floating Chest Closeup)
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_44(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc == 0) {
+		debugC(kDebugScript, "Opcode %d: Unknown Function", op);
+
+		// TODO: Function Unknown
+		// Used on Stoneship Card 2154 (Bottom of Lighthouse)
+		// Used on Stoneship Card 2138 (Lighthouse Floating Chest Closeup)
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_46(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	if (argc == 0) {
+		// Used on Selenitic Card 1191 (Maze Runner)
+		// Used on Mechanical Card 6267 (Code Lock)
+		// Used when Button is pushed...
+		debugC(kDebugScript, "Opcode %d: Conditional Code Jump?", op);
+		// TODO: Function Unknown - Fill in...
+		// Logic looks like this is some kind of Conditional Code
+		// Jump Point.
+		// The Logic for the Mechanical Code Lock Seems to be in this
+		// opcode with it being present twice delimiting the start
+		// of the incorrect code and correct code action blocks...
+		// Not sure how a general case can be made for this..
+	} else
+		unknown(op, var, argc, argv);
+}
+
+void MystScriptParser::opcode_100(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	// Hard coded SoundId valid only for Intro Stack.
+	// Other stacks use Opcode 40, which takes SoundId values as arguments.
+	const uint16 soundIdLinkSrc = 5;
+
+	switch (_vm->getCurStack()) {
+		case kIntroStack:
+			debugC(kDebugScript, "Opcode %d: ChangeStack", op);
+			debugC(kDebugScript, "\tvar: %d", var);
+
+			// TODO: Merge with changeStack (Opcode 40) Implementation? 
+			if (_vm->_varStore->getVar(var) == 5 || _vm->_varStore->getVar(var) > 7) {
+				// TODO: Dead Book i.e. Released Sirrus/Achenar
+			} else {
+				// Play Linking Sound, blocking...
+				_vm->_sound->stopSound();
+				Audio::SoundHandle *handle = _vm->_sound->playSound(soundIdLinkSrc);
+				while (_vm->_mixer->isSoundHandleActive(*handle))
+					_vm->_system->delayMillis(10);
+
+				// Play Flyby Entry Movie on Masterpiece Edition..
+				if ((_vm->getFeatures() & GF_ME)) {
+					switch (stack_map[_vm->_varStore->getVar(var)]) {
+						case kSeleniticStack:
+							_vm->_video->playMovieCentered(_vm->wrapMovieFilename("selenitic flyby", kMasterpieceOnly));
+							break;
+						case kStoneshipStack:
+							_vm->_video->playMovieCentered(_vm->wrapMovieFilename("stoneship flyby", kMasterpieceOnly));
+							break;
+						// Myst Flyby Movie not used in Original Masterpiece Edition Engine
+						case kMystStack:
+							if (_vm->_tweaksEnabled)
+								_vm->_video->playMovieCentered(_vm->wrapMovieFilename("myst flyby", kMasterpieceOnly));
+							break;
+						case kMechanicalStack:
+							_vm->_video->playMovieCentered(_vm->wrapMovieFilename("mech age flyby", kMasterpieceOnly));
+							break;
+						case kChannelwoodStack:
+							_vm->_video->playMovieCentered(_vm->wrapMovieFilename("channelwood flyby", kMasterpieceOnly));
+							break;
+						default:
+							break;
+					}
+				}
+
+				uint16 varValue = _vm->_varStore->getVar(var);
+				_vm->changeToStack(stack_map[varValue]);
+				_vm->changeToCard(start_card[varValue]);
+
+				// TODO: No soundIdLinkDst for Opcode 100 link? Check Original.
+			}
+			break;
+		case kStoneshipStack:
+			// Used for Cards 2185 (Water Pump)
+			varUnusedCheck(op, var);
+
+			if (argc == 0) {
+				debugC(kDebugScript, "Opcode %d: Unknown Function", op);
+
+				// TODO: Called when Water Pump Button is pressed? Animation?
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kDniStack:
+			// Used in Card 5022 (Rocks)
+			varUnusedCheck(op, var);
+
+			if (argc == 0) {
+				debugC(kDebugScript, "Opcode %d: Unknown Function", op);
+
+				// TODO: Fill in Logic.
+			} else
+				unknown(op, var, argc, argv);
+            break;
+		case kCreditsStack:
+		case kMakingOfStack:
+			_vm->_system->quit();
+			break;
+		case kDemoSlidesStack:
+			// TODO: Change to changeStack call?
+			_vm->changeToStack(kDemoStack);
+			_vm->changeToCard(2001);
+			break;
+		default:
+			unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_101(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	switch (_vm->getCurStack()) {
+		case kSeleniticStack:
+			varUnusedCheck(op, var);
+
+			if (argc == 0) {
+				// Used on Card 1191 (Maze Runner)
+				// Called when Red Warning Button is pushed
+
+				debugC(kDebugScript, "Opcode %d: Repeat Buzzer Sound?", op);
+
+				// TODO: Fill in logic...
+				// Repeat buzzer sound
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+		case kStoneshipStack:
+			varUnusedCheck(op, var);
+
+			if (argc == 6) {
+				// Used by Door Buttons to Brothers' Rooms
+				// Cards 2294, 2255
+				Common::Rect u0_rect = Common::Rect(argv[0], argv[1], argv[2], argv[3]);
+				uint16 u1 = argv[3];
+				uint16 u2 = argv[2];
+
+				debugC(kDebugScript, "Opcode %d: Unknown", op);
+				debugC(kDebugScript, "u0_rect.left: %d", u0_rect.left);
+				debugC(kDebugScript, "u0_rect.top: %d", u0_rect.top);
+				debugC(kDebugScript, "u0_rect.right: %d", u0_rect.right);
+				debugC(kDebugScript, "u0_rect.bottom: %d", u0_rect.bottom);
+				debugC(kDebugScript, "u1: %d", u1);
+				debugC(kDebugScript, "u2: %d", u2);
+
+				// TODO: Fill in logic...
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+		case kDemoPreviewStack:
+		case kMystStack:
+			debugC(kDebugScript, "Opcode %d: Decrement Variable", op);
+			if (argc == 0) {
+				debugC(kDebugScript, "\tvar: %d", var);
+				uint16 varValue = _vm->_varStore->getVar(var);
+				// Logic to prevent decrement to negative
+				if (varValue != 0)
+					_vm->_varStore->setVar(var, varValue - 1);
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+		case kChannelwoodStack:
+			varUnusedCheck(op, var);
+
+			if (argc == 1) {
+				debugC(kDebugScript, "Opcode %d: Play Pipe Movie and Sound", op);
+
+				uint16 soundId = argv[0];
+				debugC(kDebugScript, "\tsoundId: %d", soundId);
+
+				_vm->_sound->playSound(soundId);
+
+				// TODO: Get Movie Location from Invoking Resource Rect, rather than
+				//       hardcoded 267, 170 ?
+
+				// TODO: Need version of playMovie blocking which allows selection
+				//       of start and finish points.
+				if (!_vm->_varStore->getVar(6)) {
+					// Play Pipe Extending i.e. 0 to 1/2 way through file
+					_vm->_video->playMovie(_vm->wrapMovieFilename("pipebrid", kChannelwoodStack), 267, 170);
+				} else {
+					// Play Pipe Retracting i.e. 1/2 way to end of file
+					_vm->_video->playMovie(_vm->wrapMovieFilename("pipebrid", kChannelwoodStack), 267, 170);
+				}
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kDniStack:
+			// Used in Card 5014 (Atrus)
+			// Hotspot Resource Used to hand Page to Atrus...
+			varUnusedCheck(op, var);
+			// TODO: Fill in Logic.
+            break;
+		case kDemoStack:
+			varUnusedCheck(op, var);
+
+			// Used on Card 2000, 2002 and 2003
+			// Triggered by Click
+			if (argc == 0) {
+				// TODO: Fill in Logic.. Fade in?
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_102(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	switch (_vm->getCurStack()) {
+		case kStoneshipStack:
+			varUnusedCheck(op, var);
+
+			if (argc == 2) {
+				debugC(kDebugScript, "Opcode %d: Play Book Room Movie", op);
+
+				uint16 startTime = argv[0];
+				uint16 endTime = argv[1];
+
+				debugC(kDebugScript, "\tstartTime: %d", startTime);
+				debugC(kDebugScript, "\tendTime: %d", endTime);
+
+				printf("TODO: Opcode %d Movie Time Index %d to %d\n", op, startTime, endTime);
+				// TODO: Need version of playMovie blocking which allows selection
+				//       of start and finish points.
+				_vm->_video->playMovie(_vm->wrapMovieFilename("bkroom", kStoneshipStack), 159, 99);
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+		case kDemoPreviewStack:
+		case kMystStack:
+			if (argc == 0) {
+				debugC(kDebugScript, "Opcode %d: Increment Variable", op);
+				debugC(kDebugScript, "\tvar: %d", var);
+
+				// AFAIK no logic to put ceiling on increment at least in this opcode
+				_vm->_varStore->setVar(var, _vm->_varStore->getVar(var) + 1);
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+		case kChannelwoodStack:
+			varUnusedCheck(op, var);
+
+			if (argc == 2 || argc == 3) {
+				debugC(kDebugScript, "Opcode %d: Draw Full Screen Image, Optional Delay and Change Card", op);
+
+				uint16 imageId = argv[0];
+				uint16 cardId = argv[1];
+				uint16 delay = 0;
+				
+				if (argc == 3)
+					delay = argv[2]; // TODO: Not sure about purpose of this parameter...
+
+				debugC(kDebugScript, "\timageId: %d", imageId);
+				debugC(kDebugScript, "\tcardId: %d", cardId);
+				debugC(kDebugScript, "\tdelay: %d", delay);
+
+				_vm->_gfx->copyImageToScreen(imageId, Common::Rect(0, 0, 544, 333));
+				_vm->_system->delayMillis(delay / 100);
+				_vm->changeToCard(cardId);
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+		case kDemoStack:
+			varUnusedCheck(op, var);
+
+			// Used on Card 2002 and 2003
+			// Triggered by Click
+			if (argc == 0) {
+				// TODO: Fill in Logic.. Fade out?
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_103(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	switch (_vm->getCurStack()) {
+		case kStoneshipStack:
+			varUnusedCheck(op, var);
+
+			if (argc == 1) {
+				// Used on Card 2197 (Sirrus' Room Drawers)
+				debugC(kDebugScript, "Opcode %d: Unknown", op);
+
+				uint16 u0 = argv[0];
+
+				debugC(kDebugScript, "\tu0: %d", u0);
+				// TODO: Fill in Logic...
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+		case kDemoPreviewStack:
+		case kMystStack:
+			// Used on Myst Card 4162 (Fireplace Grid)
+			if (argc == 1) {
+				debugC(kDebugScript, "Opcode %d: Toggle Variable with Bitmask", op);
+
+				uint16 bitmask = argv[0];
+				uint16 varValue = _vm->_varStore->getVar(var);
+
+				debugC(kDebugScript, "\tvar: %d", var);
+				debugC(kDebugScript, "\tbitmask: 0x%02X", bitmask);
+
+				if (varValue & bitmask)
+					_vm->_varStore->setVar(var, varValue & ~bitmask);
+				else
+					_vm->_varStore->setVar(var, varValue | bitmask);
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_104(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	switch (_vm->getCurStack()) {
+		case kStoneshipStack:
+			varUnusedCheck(op, var);
+
+			// Used for Card 2004 (Achenar's Room Drawers)
+			// Used for Closeup of Torn Note?
+			if (argc == 1) {
+				debugC(kDebugScript, "Opcode %d: Unknown Function", op);
+				
+				uint16 u0 = argv[0];
+				debugC(kDebugScript, "\tu0: %d", u0);
+
+				// TODO: Fill in Function...
+				// Does u0 correspond to a resource Id? Enable? Disable?
+				// Similar to Opcode 111 (Stoneship Version).. But does this also
+				// draw closeup image of note / change to closeup card?
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+		case kMystStack:
+			varUnusedCheck(op, var);
+
+			// Used on Myst Card 4162 and 4166 (Fireplace Puzzle Rotation Movies)
+			if (argc == 1) {
+				debugC(kDebugScript, "Opcode %d: Play Fireplace Puzzle Rotation Movies", op);
+
+				uint16 movieNum = argv[0];
+				debugC(kDebugScript, "\tmovieNum: %d", movieNum);
+
+            	if (movieNum == 0)
+					_vm->_video->playMovie(_vm->wrapMovieFilename("fpin", kMystStack), 167, 5);
+				if (movieNum == 1)
+					_vm->_video->playMovie(_vm->wrapMovieFilename("fpout", kMystStack), 167, 5);
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+		case kMechanicalStack:
+			varUnusedCheck(op, var);
+
+			// Used on Mechanical Card 6043 (Weapons Rack with Snake Box)
+			if (argc == 0) {
+				debugC(kDebugScript, "Opcode %d: Trigger Playing Of Snake Movie", op);
+
+				// TODO: Trigger Type 6 To Play Snake Movie.. Resource #3 on card.
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+		case kChannelwoodStack:
+			varUnusedCheck(op, var);
+
+			// Used on Channelwood Card 3280
+			if (argc == 0) {
+				debugC(kDebugScript, "Opcode %d: Do Water Tank Valve Open Animation", op);
+				Common::Rect rect = _invokingResource->getRect();
+
+				// TODO: Need to load the image ids from Script Resources structure of VIEW
+				for (uint16 imageId = 3595; imageId <= 3601; imageId++) { 
+					_vm->_gfx->copyImageToScreen(imageId, rect);
+					_vm->_system->delayMillis(50);
+				}
+				
+				// TODO: Is 8 gotten from var7 of calling hotspot, rather than hardcoded?
+				_vm->_varStore->setVar(8, 1);
+				_vm->_varStore->setVar(19, 1);
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_105(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	switch (_vm->getCurStack()) {
+		case kSeleniticStack:
+			if (argc == 1) {
+				uint16 soundId = argv[0];
+
+				debugC(kDebugScript, "Opcode %d: Sound Receiver Water Button", op);
+				debugC(kDebugScript, "\tvar: %d", var);
+
+				// TODO: Complete Function including Var Change?
+				_vm->_sound->playSound(soundId);
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+		case kMystStack:
+			if (argc == 1) {
+				varUnusedCheck(op, var);
+
+				uint16 soundId = argv[0];
+				uint16 boxValue = 0;
+				Audio::SoundHandle *handle;
+
+				debugC(kDebugScript, "Opcode %d: Ship Puzzle Logic", op);
+				debugC(kDebugScript, "\tsoundId: %d", soundId);
+
+				// Logic for Myst Ship Box Puzzle Solution
+				for (byte i = 0; i < 8; i++)
+					boxValue |= _vm->_varStore->getVar(i + 26) ? (1 << i) : 0;
+
+				uint16 var10 = _vm->_varStore->getVar(10);
+
+				if (boxValue == 0x32 && var10 == 0) {
+					handle = _vm->_sound->playSound(soundId);
+
+					while (_vm->_mixer->isSoundHandleActive(*handle))
+						_vm->_system->delayMillis(10);
+
+					_vm->_varStore->setVar(10, 1);
+				} else if (boxValue != 0x32 && var10 == 1) {
+					handle = _vm->_sound->playSound(soundId);
+
+					while (_vm->_mixer->isSoundHandleActive(*handle))
+						_vm->_system->delayMillis(10);
+
+					_vm->_varStore->setVar(10, 0);
+				}
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+		case kMechanicalStack:
+			varUnusedCheck(op, var);
+
+			if (argc == 0) {
+				debugC(kDebugScript, "Opcode %d: Play Stairs Movement Movie", op);
+
+				if (_vm->_varStore->getVar(10)) {
+					// TODO: Play Movie from 0 to 1/2 way...
+					_vm->_video->playMovie(_vm->wrapMovieFilename("hhstairs", kMechanicalStack), 174, 222);
+				} else {
+					// TODO: Play Movie from 1/2 way to end...
+					_vm->_video->playMovie(_vm->wrapMovieFilename("hhstairs", kMechanicalStack), 174, 222);
+				}
+			}
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_106(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	switch (_vm->getCurStack()) {
+		case kSeleniticStack:
+			if (argc == 1) {
+				uint16 soundId = argv[0];
+
+				debugC(kDebugScript, "Opcode %d: Sound Receiver Volcanic Crack Button", op);
+				debugC(kDebugScript, "\tvar: %d", var);
+
+				// TODO: Complete Function including Var Change?
+				_vm->_sound->playSound(soundId);
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_107(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	switch (_vm->getCurStack()) {
+		case kSeleniticStack:
+			if (argc == 1) {
+				uint16 soundId = argv[0];
+
+				debugC(kDebugScript, "Opcode %d: Sound Receiver Clock Button", op);
+				debugC(kDebugScript, "\tvar: %d", var);
+
+				// TODO: Complete Function including Var Change?
+				_vm->_sound->playSound(soundId);
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_108(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	switch (_vm->getCurStack()) {
+		case kSeleniticStack:
+			if (argc == 1) {
+				uint16 soundId = argv[0];
+
+				debugC(kDebugScript, "Opcode %d: Sound Receiver Crystal Rocks Button", op);
+				debugC(kDebugScript, "\tvar: %d", var);
+
+				// TODO: Complete Function including Var Change?
+				_vm->_sound->playSound(soundId);
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_109(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	switch (_vm->getCurStack()) {
+		case kSeleniticStack:
+			if (argc == 1) {
+				uint16 soundId = argv[0];
+
+				debugC(kDebugScript, "Opcode %d: Sound Receiver Wind Button", op);
+				debugC(kDebugScript, "\tvar: %d", var);
+
+				// TODO: Complete Function including Var Change?
+				_vm->_sound->playSound(soundId);
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+		case kMystStack:
+			if (argc == 1) {
+				int16 signedValue = argv[0];
+
+				debugC(kDebugScript, "Opcode %d: Add Signed Value to Var", op);
+				debugC(kDebugScript, "\tVar: %d", var);
+				debugC(kDebugScript, "\tsignedValue: %d", signedValue);
+
+				_vm->_varStore->setVar(var, _vm->_varStore->getVar(var) + signedValue);
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_110(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kSeleniticStack:
+			if (argc == 15) {
+				// Used for Selenitic Maze Runner Exit Logic
+				uint16 CardIdEntry = argv[0];
+				uint16 CardIdExit = argv[1];
+				uint16 u0 = argv[2];
+				Common::Rect rect1 = Common::Rect(argv[3], argv[4], argv[5], argv[6]);
+				uint16 rect1UpdateDirection = argv[7];
+				uint16 u1 = argv[8];
+				Common::Rect rect2 = Common::Rect(argv[9], argv[10], argv[11], argv[12]);
+				uint16 rect2UpdateDirection = argv[13];
+				uint16 u2 = argv[14];
+
+				debugC(kDebugScript, "Opcode %d: Maze Runner Exit Logic and Door Open Animation", op);
+				debugC(kDebugScript, "\tExit Card: %d", CardIdEntry);
+				debugC(kDebugScript, "\tEntry Card: %d", CardIdExit);
+				debugC(kDebugScript, "\tu0 (Exit Var?): %d", u0);
+
+				debugC(kDebugScript, "\trect1.left: %d", rect1.left);
+				debugC(kDebugScript, "\trect1.top: %d", rect1.top);
+				debugC(kDebugScript, "\trect1.right: %d", rect1.right);
+				debugC(kDebugScript, "\trect1.bottom: %d", rect1.bottom);
+				debugC(kDebugScript, "\trect1 updateDirection: %d", rect1UpdateDirection);
+				debugC(kDebugScript, "\tu1: %d", u1);
+
+				debugC(kDebugScript, "\trect2.left: %d", rect2.left);
+				debugC(kDebugScript, "\trect2.top: %d", rect2.top);
+				debugC(kDebugScript, "\trect2.right: %d", rect2.right);
+				debugC(kDebugScript, "\trect2.bottom: %d", rect2.bottom);
+				debugC(kDebugScript, "\trect2 updateDirection: %d", rect2UpdateDirection);
+				debugC(kDebugScript, "\tu2: %d", u2);
+
+				// TODO: Finish Implementing Logic...
+				// HACK: Bypass Higher Logic for now...
+				_vm->changeToCard(argv[1]);
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_111(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kSeleniticStack:
+			if (argc == 0) {
+				// Used on Card 1245 (Sound Receiver)
+				// Used by Source Selection Buttons...
+
+				debugC(kDebugScript, "Opcode %d: Unknown", op);
+				// TODO: Fill in Function...
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+		case kStoneshipStack:
+			if (argc == 1) {
+				// Used for Card 2004 (Achenar's Room Drawers)
+				// Used by Drawers Hotspots...
+
+				debugC(kDebugScript, "Opcode %d: Unknown Function", op);
+				
+				uint16 u0 = argv[0];
+				debugC(kDebugScript, "\tu0: %d", u0);
+
+				// TODO: Fill in Function...
+				// Does u0 correspond to a resource Id? Enable? Disable?
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_112(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	switch (_vm->getCurStack()) {
+		case kStoneshipStack:
+			// Used for Card 2013 (Achenar's Rose-Skull Hologram)
+			if (argc == 3) {
+				debugC(kDebugScript, "Opcode %d: Rose-Skull Hologram Playback", op);
+				
+				uint16 varValue = _vm->_varStore->getVar(var);
+
+				debugC(kDebugScript, "\tVar: %d = %d", var, varValue);
+				
+				uint16 startPoint = argv[0];
+				uint16 endPoint = argv[1];
+				uint16 u0 = argv[2];
+
+				debugC(kDebugScript, "\tstartPoint: %d", startPoint);
+				debugC(kDebugScript, "\tendPoint: %d", endPoint);
+				debugC(kDebugScript, "\tu0: %d", u0);
+
+				// TODO: Fill in Function...
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_113(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used on Myst 4143 (Dock near Marker Switch)
+			if (argc == 9) {
+				uint16 soundId = argv[0];
+				
+				uint16 u0 = argv[1];
+				uint16 u1 = argv[2];
+
+				Common::Rect rect = Common::Rect(argv[3], argv[4], argv[5], argv[6]);
+
+				uint16 updateDirection = argv[7];
+				uint16 u2 = argv[8];
+				
+				debugC(kDebugScript, "Opcode %d: Vault Open Logic", op);
+				debugC(kDebugScript, "\tsoundId: %d", soundId);
+				debugC(kDebugScript, "\tu0: %d", u0);
+				debugC(kDebugScript, "\tu1: %d", u1);
+
+				debugC(kDebugScript, "\trect.left: %d", rect.left);
+				debugC(kDebugScript, "\trect.top: %d", rect.top);
+				debugC(kDebugScript, "\trect.right: %d", rect.right);
+				debugC(kDebugScript, "\trect.bottom: %d", rect.bottom);
+				debugC(kDebugScript, "\trect updateDirection: %d", updateDirection);
+				debugC(kDebugScript, "\tu2: %d", u2);
+
+				if ((_vm->_varStore->getVar(2) == 1) &&
+				   (_vm->_varStore->getVar(3) == 1) &&
+				   (_vm->_varStore->getVar(4) == 0) &&
+				   (_vm->_varStore->getVar(5) == 1) &&
+				   (_vm->_varStore->getVar(6) == 1) &&
+				   (_vm->_varStore->getVar(7) == 1) &&
+				   (_vm->_varStore->getVar(8) == 1) &&
+				   (_vm->_varStore->getVar(9) == 1)) {
+					// TODO: Implement correct function...
+					// Blit Image in Left to Right Vertical stripes i.e. transistion
+					// like door opening
+					_vm->_sound->playSound(soundId);
+					// TODO: Set 41 to 1 if page already present in hand.
+					_vm->_varStore->setVar(41, 2);
+				}
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_114(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used on Myst 4143 (Dock near Marker Switch)
+			if (argc == 9) {
+				uint16 soundId = argv[0];
+				
+				uint16 u0 = argv[1];
+				uint16 u1 = argv[2];
+
+				Common::Rect rect = Common::Rect(argv[3], argv[4], argv[5], argv[6]);
+
+				uint16 updateDirection = argv[7];
+				uint16 u2 = argv[8];
+				
+				debugC(kDebugScript, "Opcode %d: Vault Close Logic", op);
+				debugC(kDebugScript, "\tsoundId: %d", soundId);
+				debugC(kDebugScript, "\tu0: %d", u0);
+				debugC(kDebugScript, "\tu1: %d", u1);
+
+				debugC(kDebugScript, "\trect.left: %d", rect.left);
+				debugC(kDebugScript, "\trect.top: %d", rect.top);
+				debugC(kDebugScript, "\trect.right: %d", rect.right);
+				debugC(kDebugScript, "\trect.bottom: %d", rect.bottom);
+				debugC(kDebugScript, "\tupdateDirection: %d", updateDirection);
+				debugC(kDebugScript, "\tu2: %d", u2);
+
+				if ((_vm->_varStore->getVar(2) == 1) &&
+				   (_vm->_varStore->getVar(3) == 1) &&
+				   (_vm->_varStore->getVar(4) == 1) &&
+				   (_vm->_varStore->getVar(5) == 1) &&
+				   (_vm->_varStore->getVar(6) == 1) &&
+				   (_vm->_varStore->getVar(7) == 1) &&
+				   (_vm->_varStore->getVar(8) == 1) &&
+				   (_vm->_varStore->getVar(9) == 1)) {
+					// TODO: Implement correct function...
+					// Blit Image in Right to Left Vertical stripes i.e. transistion
+					// like door closing
+					_vm->_sound->playSound(soundId);
+					_vm->_varStore->setVar(41, 0);
+				}
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_115(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	switch (_vm->getCurStack()) {
+		case kSeleniticStack:
+			varUnusedCheck(op, var);
+
+			if (argc == 11) {
+				// Used for Selenitic Card 1147 (Musical Door Lock Button)
+				uint16 imageIdClose = argv[0]; // TODO: Sound Id?
+				uint16 imageIdOpen = argv[1]; // TODO: Sound Id?
+
+				uint16 cardIdOpen = argv[2];
+
+				uint16 u0 = argv[3];
+				uint16 u1 = argv[4];
+
+				Common::Rect rect = Common::Rect(argv[5], argv[6], argv[7], argv[8]);
+
+				uint16 updateDirection = argv[9];
+				uint16 u2 = argv[10];
+
+				debugC(kDebugScript, "Music Door Lock Logic...");
+				debugC(kDebugScript, "\timageId (Close): %d", imageIdClose);
+				debugC(kDebugScript, "\timageId (Open): %d", imageIdOpen);
+				debugC(kDebugScript, "\tcardId (Open): %d", cardIdOpen);
+				debugC(kDebugScript, "\tu0: %d", u0);
+				debugC(kDebugScript, "\tu1: %d", u1);
+
+				debugC(kDebugScript, "\trect.left: %d", rect.left);
+				debugC(kDebugScript, "\trect.top: %d", rect.top);
+				debugC(kDebugScript, "\trect.right: %d", rect.right);
+				debugC(kDebugScript, "\trect.bottom: %d", rect.bottom);
+				debugC(kDebugScript, "\trect updateDirection: %d", updateDirection);
+				debugC(kDebugScript, "\tu2: %d", u2);
+
+				// TODO: Fix Logic...
+				// HACK: Bypass Door Lock For Now
+				_vm->changeToCard(cardIdOpen);
+			} else
+				unknown(op, var, argc, argv);
+            break;
+		case kDemoPreviewStack:
+		case kMystStack:
+			if (argc == 3) {
+				uint16 cardIdLose = argv[0];
+				uint16 cardIdBookCover = argv[1];
+				uint16 soundIdAddPage = argv[2];
+
+				debugC(kDebugScript, "Opcode %d: Red and Blue Book/Page Interaction", op);
+				debugC(kDebugScript, "Var: %d", var);
+				debugC(kDebugScript, "Card Id (Lose): %d", cardIdLose);
+				debugC(kDebugScript, "Card Id (Book Cover): %d", cardIdBookCover);
+				debugC(kDebugScript, "SoundId (Add Page): %d", soundIdAddPage);
+
+				// TODO: if holding page for this book, play SoundIdAddPage
+				if (false) { // TODO: Should be access to mainCursor...
+					_vm->_sound->playSound(soundIdAddPage);
+					// TODO: Code for updating variables based on adding page
+				}
+
+				// TODO: Add Tweak to improve original logic by denying
+				//       lose until all red / blue pages collected, rather
+				//       than allowing shortcut based on 1 fireplace page?
+
+				// If holding last page for this book i.e. var 24/25
+				// Then trigger Trapped in Book Losing Ending
+				if ((var == 100 && !_vm->_varStore->getVar(25)) ||
+				   (var == 101 && !_vm->_varStore->getVar(24))) {
+					// TODO: Clear mainCursor back to nominal..
+					_vm->changeToCard(cardIdLose);
+				} else
+					_vm->changeToCard(cardIdBookCover);
+	
+				// TODO: Is this logic here?
+				//       i.e. If was holding page, wait then auto open and play book...
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+			varUnusedCheck(op, var);
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_116(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kStoneshipStack:
+			varUnusedCheck(op, var);
+
+			if (argc == 1) {
+				// Used on Card 2111 (Compass Rose)
+				// Called when Button Clicked.
+				uint16 correctButton = argv[0];
+
+				if (correctButton) {
+					// Correct Button -> Light On Logic
+					// TODO: Deal with if main power on?
+					_vm->_varStore->setVar(16, 1);
+					_vm->_varStore->setVar(30, 0);
+				} else {
+					// Wrong Button -> Power Failure Logic
+					// TODO: Fill in Alarm
+					_vm->_varStore->setVar(16, 0);
+					_vm->_varStore->setVar(30, 2);
+					_vm->_varStore->setVar(33, 0);
+				}
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kMystStack:
+			if (argc == 1) {
+				// Used on Card 4006 (Clock Tower Time Controls)
+				uint16 soundId = argv[0];
+
+				debugC(kDebugScript, "Opcode %d: Clock Tower Bridge Puzzle Execute Button", op);
+
+				uint16 bridgeState = _vm->_varStore->getVar(12);
+				uint16 currentTime = _vm->_varStore->getVar(43);
+
+				const uint16 correctTime = 32; // 2:40 i.e. From 12 Noon in 5 min increments
+
+				if (!bridgeState && currentTime == correctTime) {
+					_vm->_sound->playSound(soundId);
+
+					// TODO: Play only 1st half of movie i.e. gears rise up
+					_vm->_video->playMovie(_vm->wrapMovieFilename("gears", kMystStack), 305, 36);
+					
+					bridgeState = 1;
+					_vm->_varStore->setVar(12, bridgeState);
+				} else if (bridgeState && currentTime != correctTime) {
+					_vm->_sound->playSound(soundId);
+
+					// TODO: Play only 2nd half of movie i.e. gears sink down
+					_vm->_video->playMovie(_vm->wrapMovieFilename("gears", kMystStack), 305, 36);
+
+					bridgeState = 0;
+					_vm->_varStore->setVar(12, bridgeState);
+				}
+            } else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_117(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	switch (_vm->getCurStack()) {
+		case kStoneshipStack:
+			varUnusedCheck(op, var);
+
+			if (argc == 0) {
+				// Used on Card 2132 (Chest at Bottom of Lighthouse)
+				// Called when Valve Hotspot Clicked.
+				// TODO: Fill in Function to play right section of movie
+				//       based on valve state and water in chest..
+				_vm->_video->playMovie(_vm->wrapMovieFilename("ligspig", kStoneshipStack), 97, 267);
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kMystStack:
+			if (argc == 2) {
+				// Used by Myst Imager Control Button
+				uint16 varValue = _vm->_varStore->getVar(var);
+
+				if (varValue)
+					_vm->_sound->playSound(argv[1]);
+				else
+					_vm->_sound->playSound(argv[0]);
+
+				_vm->_varStore->setVar(var, !varValue);
+				// TODO: Change Var 45 "Dock Forechamber Imager Water Effect Enabled" here?
+            } else
+				unknown(op, var, argc, argv);
+			break;
+		case kChannelwoodStack:
+			varUnusedCheck(op, var);
+
+			if (argc == 1) {
+				// Used on Card 3012 (Temple Hologram Monitor)
+				uint16 button = argv[0]; // 0 to 3
+				_vm->_varStore->setVar(17, button);
+				switch (button) {
+					case 0:
+						_vm->_video->playMovie(_vm->wrapMovieFilename("monalgh", kChannelwoodStack), 227, 71);
+						break;
+					case 1:
+						_vm->_video->playMovie(_vm->wrapMovieFilename("monamth", kChannelwoodStack), 227, 71);
+						break;
+					case 2:
+						_vm->_video->playMovie(_vm->wrapMovieFilename("monasirs", kChannelwoodStack), 227, 71);
+						break;
+					case 3:
+						_vm->_video->playMovie(_vm->wrapMovieFilename("monsmsg", kChannelwoodStack), 227, 71);
+						break;
+					default:
+						warning("Opcode %d Control Variable Out of Range", op);
+						break;
+				}
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_118(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	switch (_vm->getCurStack()) {
+		case kStoneshipStack:
+			if (argc == 0) {
+				// Used on Card 2126 (Lighthouse Looking Along Plank)
+				// Called when Exit Resource is clicked
+
+				// TODO: Implement Function...
+				// If holding Key to Lamp Room Trapdoor, drop to bottom of
+				// Lighthouse...
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kMystStack:
+			varUnusedCheck(op, var);
+
+			if (argc == 5) {
+				// Used by Card 4709 (Myst Imager Control Panel Red Button)
+
+				debugC(kDebugScript, "Opcode %d: Imager Change Value", op);
+
+				uint16 soundIdBeepLo = argv[0];
+				uint16 soundIdBeepHi = argv[1];
+				uint16 soundIdBwapp = argv[2];
+				uint16 soundIdBeepTune = argv[3]; // 5 tones..
+				uint16 soundIdPanelSlam = argv[4];
+
+				debugC(kDebugScript, "\tsoundIdBeepLo: %d", soundIdBeepLo);
+				debugC(kDebugScript, "\tsoundIdBeepHi: %d", soundIdBeepHi);
+				debugC(kDebugScript, "\tsoundIdBwapp: %d", soundIdBwapp);
+				debugC(kDebugScript, "\tsoundIdBeepTune: %d", soundIdBeepTune);
+				debugC(kDebugScript, "\tsoundIdPanelSlam: %d", soundIdPanelSlam);
+
+				_vm->_sound->playSound(soundIdBeepLo);
+
+				// TODO: Complete Logic...
+            } else
+				unknown(op, var, argc, argv);
+			break;
+		case kChannelwoodStack:
+			varUnusedCheck(op, var);
+
+			if (argc == 0) {
+				// Used on Card 3318 (Sirrus' Room Nightstand Drawer)
+				// Triggered when clicked on drawer
+				// TODO: Implement function...
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_119(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kStoneshipStack:
+			if (argc == 0) {
+				// Used on Card 2143 (Lighthouse Trapdoor)
+				// Called when Lock Hotspot Clicked while holding key.
+				_vm->_video->playMovie(_vm->wrapMovieFilename("openloc", kStoneshipStack), 187, 72);
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kMystStack:
+			if (argc == 1) {
+				// Used on Card 4383 and 4451 (Tower Elevator)
+				switch (argv[0]) {
+					case 0:
+						_vm->_video->playMovie(_vm->wrapMovieFilename("libdown", kMystStack), 216, 78);
+						break;
+					case 1:
+						_vm->_video->playMovie(_vm->wrapMovieFilename("libup", kMystStack), 214, 75);
+						break;
+					default:
+						break;
+				}
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kChannelwoodStack:
+			if (argc == 0) {
+				// Used on Card 3333 (Temple Hologram)
+				// TODO: Not 100% sure about movie position...
+				switch (_vm->_varStore->getVar(17)) {
+					case 0:
+						_vm->_video->playMovie(_vm->wrapMovieFilename("holoalgh", kChannelwoodStack), 126, 74);
+						break;
+					case 1:
+						_vm->_video->playMovie(_vm->wrapMovieFilename("holoamth", kChannelwoodStack), 126, 74);
+						break;
+					case 2:
+						_vm->_video->playMovie(_vm->wrapMovieFilename("holoasir", kChannelwoodStack), 126, 74);
+						break;
+					case 3:
+						_vm->_video->playMovie(_vm->wrapMovieFilename("holosmsg", kChannelwoodStack), 126, 74);
+						break;
+					default:
+						warning("Opcode %d Control Variable Out of Range", op);
+						break;
+				}
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_120(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	MystResource *_top;
+
+	switch (_vm->getCurStack()) {
+		case kStoneshipStack:
+			if (argc == 1) {
+				// Used for Cards 2285, 2289, 2247, 2251 (Side Doors in Tunnels Down To Brothers Rooms)
+				uint16 movieId = argv[0];
+
+				debugC(kDebugScript, "Opcode %d: Play Side Door Movies", op);
+				debugC(kDebugScript, "\tmovieId: %d", movieId);
+
+				switch (movieId) {
+					case 0:
+						// Card 2251
+						_vm->_video->playMovie(_vm->wrapMovieFilename("tunaup", kStoneshipStack), 149, 161);
+						break;
+					case 1:
+						// Card 2247
+						_vm->_video->playMovie(_vm->wrapMovieFilename("tunadown", kStoneshipStack), 218, 150);
+						break;
+					case 2:
+						// Card 2289
+						_vm->_video->playMovie(_vm->wrapMovieFilename("tuncup", kStoneshipStack), 259, 161);
+						break;
+					case 3:
+						// Card 2285
+						_vm->_video->playMovie(_vm->wrapMovieFilename("tuncdown", kStoneshipStack), 166, 150);
+						break;
+					default:
+						warning("Opcode 120 MovieId Out Of Range");
+						break;
+				}
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kMystStack:
+			// Used for Card 4297 (Generator Puzzle Buttons)
+			debugC(kDebugScript, "Opcode %d: Toggle Var8 of Invoking Resource", op);
+			_top = _invokingResource;
+			
+			while(_top->_parent != NULL)
+				_top = _top->_parent;
+
+			if (argc == 0) {
+				uint16 var8 = _top->getType8Var();
+				if (var8 != 0xFFFF)
+					_vm->_varStore->setVar(var8, !_vm->_varStore->getVar(var8));
+				else
+					warning("Opcode 120: No invoking Resource Var 8 found!");
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+			unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_121(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used on Card 4100 (Cabin Safe Buttons)
+			// Correct Solution (724) -> Var 67=2, 68=7, 69=5 
+			// Jump to Card 4103 when solution correct and handle pulled...
+			if (argc == 0) {
+				uint16 varValue = _vm->_varStore->getVar(var);
+				if (varValue == 0)
+					varValue = 9;
+				else
+					varValue--;
+				_vm->_varStore->setVar(var, varValue);
+            } else
+				unknown(op, var, argc, argv);
+			break;
+		case kMechanicalStack:
+			varUnusedCheck(op, var);
+
+			if (argc == 2) {
+				uint16 startTime = argv[0];
+				uint16 endTime = argv[1];
+
+				printf("TODO: Opcode %d Movie Time Index %d to %d\n", op, startTime, endTime);
+				// TODO: Need version of playMovie blocking which allows selection
+				//       of start and finish points.
+				_vm->_video->playMovie(_vm->wrapMovieFilename("ewindow", kMechanicalStack), 253, 0);
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+			varUnusedCheck(op, var);
+
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_122(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kChannelwoodStack:
+			// Used on Channelwood Card 3280
+			if (argc == 0) {
+				debugC(kDebugScript, "Opcode %d: Do Water Tank Valve Close Animation", op);
+				Common::Rect rect = _invokingResource->getRect();
+
+				// TODO: Need to load the image ids from Script Resources structure of VIEW
+				for (uint16 imageId = 3601; imageId >= 3595; imageId--) {
+					_vm->_gfx->copyImageToScreen(imageId, rect);
+					_vm->_system->delayMillis(50);
+				}
+
+				// TODO: Is 8 gotten from var7 of calling hotspot, rather than hard-coded?
+				_vm->_varStore->setVar(8, 0);
+				_vm->_varStore->setVar(19, 0);
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+		case kMechanicalStack:
+			if (argc == 0) {
+				// Used on Card 6120 (Elevator)
+				// Called when Exit Midde Button Pressed
+
+				// TODO: hcelev? Movie of Elevator?
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_123(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMechanicalStack:
+			if (argc == 2) {
+				// Used on Card 6154
+				uint16 start_time = argv[0];
+				uint16 end_time = argv[1];
+
+				printf("TODO: Opcode %d Movie Time Index %d to %d\n", op, start_time, end_time);
+				// TODO: Need version of playMovie blocking which allows selection
+				//       of start and finish points.
+				// TODO: Not 100% sure about movie position
+				_vm->_video->playMovie(_vm->wrapMovieFilename("hcelev", kMechanicalStack), 205, 40);
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_124(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMechanicalStack:
+			if (argc == 0) {
+				// Used by Card 6156 (Fortress Rotation Controls)
+				// Called when Red Exit Button Pressed to raise Elevator
+
+				// TODO: Fill in Code...
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_125(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	switch (_vm->getCurStack()) {
+		case kStoneshipStack:
+			if (argc == 1) {
+				// Used on Card 2197 (Sirrus' Room Drawers)
+				debugC(kDebugScript, "Opcode %d: Unknown uses Var %d", op, var);
+
+				uint16 u0 = argv[0];
+
+				debugC(kDebugScript, "\tu0: %d", u0);
+				// TODO: Fill in Logic...
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+		case kMechanicalStack:
+			if (argc == 0) {
+				// Used on Card 6267 (Code Lock)
+				// Called by Red Execute Button...
+				debugC(kDebugScript, "Opcode %d: Code Lock Execute...", op);
+
+				// TODO: Fill in Logic For Code Lock...
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_126(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMechanicalStack:
+			if (argc == 0) {
+				// Used by Card 6120 (Fortress Elevator)
+				// Called when Red Exit Button Pressed to raise Elevator and
+				// exit is clicked...
+
+				// TODO: Fill in Code...
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_127(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kChannelwoodStack:
+			if (argc == 2) {
+				// Used by Card 3262 (Elevator)
+				debugC(kDebugScript, "Opcode %d: Unknown...", op);
+
+				uint16 u0 = argv[0];
+				uint16 u1 = argv[1];
+
+				debugC(kDebugScript, "\tu0: %d", u0);
+				debugC(kDebugScript, "\tu1: %d", u1);
+
+				// TODO: Fill in Code...
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kMechanicalStack:
+			if (argc == 0) {
+				// Used for Mech Card 6226 (3 Crystals)
+				_vm->_varStore->setVar(20, 1);
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_128(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMechanicalStack:
+			if (argc == 0) {
+				// Used for Mech Card 6226 (3 Crystals)
+				_vm->_varStore->setVar(20, 0);
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		default:
+			unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_129(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kChannelwoodStack:
+			if (argc == 1) {
+				// Used by Card 3262 (Elevator)
+				debugC(kDebugScript, "Opcode %d: Unknown...", op);
+
+				uint16 cardId = argv[0];
+
+				debugC(kDebugScript, "\tcardId: %d", cardId);
+
+				// TODO: Fill in Code...
+				_vm->changeToCard(cardId);
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kMechanicalStack:
+			if (argc == 0) {
+				// Used for Mech Card 6226 (3 Crystals)
+				_vm->_varStore->setVar(21, 1);
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_130(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMechanicalStack:
+			if (argc == 0) {
+				// Used for Mech Card 6226 (3 Crystals)
+				_vm->_varStore->setVar(21, 0);
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		default:
+			unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_131(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMechanicalStack:
+			if (argc == 0) {
+				// Used for Mech Card 6226 (3 Crystals)
+				_vm->_varStore->setVar(22, 1);
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		default:
+			unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_132(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMechanicalStack:
+			if (argc == 0) {
+				// Used for Mech Card 6226 (3 Crystals)
+				_vm->_varStore->setVar(22, 0);
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		default:
+			unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_133(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used on Card 4500 (Stellar Observatory Controls)
+			if (argc == 1) {
+				// Called by Telescope Slew Button
+				uint16 soundId = argv[0];
+
+				// TODO: Function to change variables controlling telescope view
+				//       etc.
+				
+				// TODO: Sound seems to be stuck looping?
+				_vm->_sound->playSound(soundId);
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_147(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			if (argc == 0) {
+				// TODO: Extra Logic to do this in INIT process watching cursor and var 98?
+				_vm->_varStore->setVar(98, 0);
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		default:
+			unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_164(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used on Card 4530 (Rocketship Music Slider Controls)
+			// TODO: Finish Implementation...
+			// Var 105 is used to set between 0 to 2 = No Function, Movie Playback and Linkable...
+			// This is called when Var 105 = 1 i.e. this plays back Movie...
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_169(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used on Card 4099 (In Cabin, Looking Out Door)
+			// TODO: Finish Implementation...
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_181(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			if (argc == 0) {
+				// TODO: Logic for lighting the match
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		default:
+			unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_182(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			if (argc == 0) {
+				// TODO: Logic for lighting the match
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		default:
+			unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_183(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			if (argc == 0) {
+				// Used for Myst Cards 4257, 4260, 4263, 4266, 4269, 4272, 4275 and 4278 (Ship Puzzle Boxes)
+				_vm->_varStore->setVar(105, 1);
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		default:
+			unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_184(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			if (argc == 0) {
+				// Used for Myst Cards 4257, 4260, 4263, 4266, 4269, 4272, 4275 and 4278 (Ship Puzzle Boxes)
+				_vm->_varStore->setVar(105, 0);
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		default:
+			unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_185(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			if (argc == 0) {
+				// Used for Myst Card 4098 (Cabin Boiler Pilot Light)
+				// TODO: Extra Logic to do this in INIT process watching cursor and var 98?
+				_vm->_varStore->setVar(98, 1);
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		default:
+			unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_196(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kDemoPreviewStack:
+			// Used on Card ...
+			// TODO: Finish Implementation...
+			// Voice Over and Card Advance?
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_197(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kDemoPreviewStack:
+			// Used on Card ...
+			// TODO: Finish Implementation...
+			// Voice Over and Card Advance?
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+// TODO: Merge with Opcode 42?
+void MystScriptParser::opcode_198(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kDemoPreviewStack:
+			if (argc == 0) {
+				// Nuh-uh! No leaving the library in the demo!
+				GUI::MessageDialog dialog("You can't leave the library in the demo.");
+				dialog.runModal();
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kMystStack:
+			// Used on Card 4143 (Dock near Marker Switch, facing Cogs)
+			if (argc == 9) {
+				uint16 soundId = argv[0];
+				uint16 u0 = argv[1];
+				uint16 u1 = argv[2];
+				Common::Rect rect = Common::Rect(argv[3], argv[4], argv[5], argv[6]);
+				uint16 updateDirection = argv[7];
+				uint16 u2 = argv[8];
+
+				debugC(kDebugScript, "Opcode %d: Close Dock Marker Switch Vault", op);
+				debugC(kDebugScript, "\tsoundId: %d", soundId);
+				debugC(kDebugScript, "\tu0: %d", u0);
+				debugC(kDebugScript, "\tu1: %d", u1);
+
+				debugC(kDebugScript, "\trect.left: %d", rect.left);
+				debugC(kDebugScript, "\trect.top: %d", rect.top);
+				debugC(kDebugScript, "\trect.right: %d", rect.right);
+				debugC(kDebugScript, "\trect.bottom: %d", rect.bottom);
+				debugC(kDebugScript, "\tupdateDirection: %d", updateDirection);
+				debugC(kDebugScript, "\tu2: %d", u2);
+
+				Audio::SoundHandle *handle;
+				if (_vm->_varStore->getVar(41) != 0) {
+					handle = _vm->_sound->playSound(soundId);
+
+					while (_vm->_mixer->isSoundHandleActive(*handle))
+						_vm->_system->delayMillis(10);
+					// TODO: Do Image Blit
+				}
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_199(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			if (argc == 0) {
+				debugC(kDebugScript, "Opcode %d: Myst Imager Control Execute Button Logic", op);
+				
+				uint16 numericSelection = (_vm->_varStore->getVar(36) + 1) % 10;
+				numericSelection += ((_vm->_varStore->getVar(35) + 1) % 10) * 10;
+
+				debugC(kDebugScript, "\tImager Selection: %d", numericSelection);
+
+				switch (numericSelection) {
+					case 40:
+						_vm->_varStore->setVar(51, 1); // Mountain
+						break;
+					case 67:
+						_vm->_varStore->setVar(51, 2); // Water
+						break;
+					case 47:
+						_vm->_varStore->setVar(51, 4); // Marker Switch
+						break;
+					case 8:
+						_vm->_varStore->setVar(51, 3); // Atrus
+						break;
+					default:
+						_vm->_varStore->setVar(51, 0); // Blank
+						break;
+				}
+
+				// TODO: Fill in Logic
+				//{  34, 2, "Dock Forechamber Imager State" }, // 0 to 2 = Off, Mountain, Water
+				//{ 310, 0, "Dock Forechamber Imager Control Temp Value?" }
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kDemoPreviewStack:
+			// Used on Card ...
+			// TODO: Finish Implementation...
+			// Voice Over and Card Advance?
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+// Selenitic Stack Movies For Maze Runner (Card 1191)
+static const char* kHCMovPathSelenitic[36] = {
+	"backa1",
+	"backe1",
+	"backf0",
+	"backf1",
+	"backl0",
+	"backl1",
+	"backo0",
+	"backo1",
+	"backp0",
+	"backp1",
+	"backr0",
+	"backr1",
+	"backs0",
+	"backs1",
+	"forwa1",
+	"forwe0",
+	"forwf0",
+	"forwf1",
+	"forwl0",
+	"forwl1",
+	"forwo0",
+	"forwo1",
+	"forwp0",
+	"forwp1",
+	"forwr0",
+	"forwr1",
+	"forws0",
+	"forws1",
+	"left00",
+	"left01",
+	"left10",
+	"left11",
+	"right00",
+	"right01",
+	"right10",
+	"right11"
+};
+
+static struct {
+	bool enabled;
+
+	uint16 var;
+	uint16 imageCount;
+	uint16 imageBaseId;
+	uint16 soundDecrement;
+	uint16 soundIncrement;
+
+	// Myst Demo slideshow variables
+	uint16 cardId;
+	uint32 lastCardTime;
+} g_opcode200Parameters;
+
+void MystScriptParser::opcode_200_run() {
+	static uint16 lastImageIndex = 0;
+	uint16 curImageIndex;
+	Common::Rect rect;
+
+	if (g_opcode200Parameters.enabled) {
+		switch (_vm->getCurStack()) {
+			case kSeleniticStack:
+				// Used on Card 1191 (Maze Runner)
+
+				// TODO: Implementation Movie Function..
+				if (false) {
+					_vm->_video->playMovie(_vm->wrapMovieFilename(kHCMovPathSelenitic[0], kSeleniticStack), 201, 26);
+				}
+				break;
+			case kStoneshipStack:
+				// Used for Card 2013 (Achenar's Rose-Skull Hologram)
+
+				// TODO: Implement Function...
+				break;
+			case kDemoPreviewStack:
+			case kMystStack:
+				curImageIndex = _vm->_varStore->getVar(g_opcode200Parameters.var);
+
+				if (curImageIndex >= g_opcode200Parameters.imageCount) {
+					curImageIndex = g_opcode200Parameters.imageCount - 1;
+					_vm->_varStore->setVar(g_opcode200Parameters.var, curImageIndex);
+				}
+
+				// HACK: Think these images are centered on screen (when smaller than full screen),
+				//       and since no _gfx call for image size, hack this to deal with this case for now...
+				if (_vm->getCurCard() == 4059)
+					rect = Common::Rect(157, 115, 544, 333);
+				else
+					rect = Common::Rect(0, 0, 544, 333);
+
+				_vm->_gfx->copyImageToScreen(g_opcode200Parameters.imageBaseId + curImageIndex, rect);
+
+				// TODO: Comparison with original engine shows that this simple solution
+				//       may not be the correct one and the choice of which sound
+				//       may be more complicated or even random..
+				if (curImageIndex < lastImageIndex && g_opcode200Parameters.soundDecrement != 0)
+					_vm->_sound->playSound(g_opcode200Parameters.soundDecrement);
+				else if (curImageIndex > lastImageIndex && g_opcode200Parameters.soundIncrement != 0)
+					_vm->_sound->playSound(g_opcode200Parameters.soundIncrement);
+
+				lastImageIndex = curImageIndex;
+				break;
+			case kCreditsStack:
+				curImageIndex = _vm->_varStore->getVar(g_opcode200Parameters.var);
+			
+				if (_vm->_system->getMillis() - g_opcode200Parameters.lastCardTime >= 7 * 1000) {
+					// After the 6th image has shown, it's time to quit
+					if (curImageIndex == 7)
+						_vm->_system->quit();
+
+					// Note: The modulus by 6 is because the 6th image is the one at imageBaseId
+					_vm->_gfx->copyImageToScreen(g_opcode200Parameters.imageBaseId + curImageIndex % 6, Common::Rect(0, 0, 544, 333));
+
+					_vm->_varStore->setVar(g_opcode200Parameters.var, curImageIndex + 1);
+					g_opcode200Parameters.lastCardTime = _vm->_system->getMillis();
+				}
+				break;
+			case kMechanicalStack:
+				// Used on Card 6238 (Sirrus' Throne) and Card 6027 (Achenar's Throne)
+				// g_opcode200Parameters.var == 0 for Achenar
+				// g_opcode200Parameters.var == 1 for Sirrus
+
+				// TODO: Fill in Function... 
+				// Variable indicates that this is related to Secret Panel State
+				break;
+			case kDemoStack:
+				// Used on Card 2000
+
+				// TODO: Fill in Function...
+				break;
+			case kDemoSlidesStack:
+				// Used on Cards...
+				if (_vm->_system->getMillis() - g_opcode200Parameters.lastCardTime >= 2 * 1000)
+					_vm->changeToCard(g_opcode200Parameters.cardId);
+				break;
+		}
+	}
+}
+
+void MystScriptParser::opcode_200_disable() {
+	g_opcode200Parameters.enabled = false;
+	g_opcode200Parameters.var = 0;
+	g_opcode200Parameters.imageCount = 0;
+	g_opcode200Parameters.imageBaseId = 0;
+	g_opcode200Parameters.soundDecrement = 0;
+	g_opcode200Parameters.soundIncrement = 0;
+}
+
+void MystScriptParser::opcode_200(uint16 op, uint16 var, uint16 argc, uint16 *argv) {	
+	switch (_vm->getCurStack()) {
+		case kIntroStack:
+			varUnusedCheck(op, var);
+
+            // TODO: Play Intro Movies..
+			// and then _vm->changeToCard(2);
+            unknown(op, var, argc, argv);
+            break;
+		case kSeleniticStack:
+			varUnusedCheck(op, var);
+
+			// Used for Card 1191 (Maze Runner)
+			if (argc == 0) {
+				g_opcode200Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kStoneshipStack:
+			varUnusedCheck(op, var);
+
+			// Used for Card 2013 (Achenar's Rose-Skull Hologram)
+			if (argc == 0) {
+				g_opcode200Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kDemoPreviewStack:
+		case kMystStack:
+			if (argc == 4) {
+				g_opcode200Parameters.var = var;
+				g_opcode200Parameters.imageCount = argv[0];
+				g_opcode200Parameters.imageBaseId = argv[1];
+				g_opcode200Parameters.soundDecrement = argv[2];
+				g_opcode200Parameters.soundIncrement = argv[3];
+				g_opcode200Parameters.enabled = true;
+
+				_vm->_varStore->setVar(var, 0);
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kMechanicalStack:
+			// Used on Card 6238 (Sirrus' Throne) and Card 6027 (Achenar's Throne)
+			if (argc == 0) {
+				g_opcode200Parameters.var = var;
+				g_opcode200Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kDniStack:
+			varUnusedCheck(op, var);
+			// Used on Card 5014
+
+			// TODO: Logic for Atrus Reactions and Movies
+			if (false) {
+				// Var 0 used for Atrus Gone (from across room) 0 = Present, 1 = Not Present
+				// Var 1 used for Myst Book Status 0 = Not Usuable
+				//                                 1 = Openable, but not linkable (Atrus Gone?)
+				//                                 2 = Linkable
+				// Var 2 used for Music Type 0 to 2..
+				// Var 106 used for Atrus Static Image State 0 = Initial State
+				//                                           1 = Holding Out Hand for Page
+				//                                           2 = Gone, Book Open
+				//                                           3 = Back #1
+				//                                           4 = Back #2
+				_vm->_video->playMovie(_vm->wrapMovieFilename("atr1nopg", kDniStack), 215, 77);
+				_vm->_video->playMovie(_vm->wrapMovieFilename("atr1page", kDniStack), 215, 77);
+				_vm->_video->playMovie(_vm->wrapMovieFilename("atrus2", kDniStack), 215, 77);
+				_vm->_video->playMovie(_vm->wrapMovieFilename("atrwrite", kDniStack), 215, 77);
+			}
+			break;
+		case kCreditsStack:
+			if (argc == 0) {
+				g_opcode200Parameters.var = var;
+				// TODO: Pass ImageCount, rather than hardcoded in run process?
+				g_opcode200Parameters.imageBaseId = _vm->getCurCard();
+				g_opcode200Parameters.lastCardTime = _vm->_system->getMillis();
+				g_opcode200Parameters.enabled = true;
+
+				_vm->_varStore->setVar(var, 1);				
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kDemoStack:
+			// Used on Card 2000
+			if (argc == 0) {
+				g_opcode200Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kDemoSlidesStack:
+			// Used on Cards...
+			if (argc == 1) {
+				g_opcode200Parameters.cardId = argv[0];
+				g_opcode200Parameters.lastCardTime = _vm->_system->getMillis();
+				g_opcode200Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+static struct {
+	uint16 u0;
+	uint16 u1;
+	uint16 u2;
+
+	uint16 lastVar105;
+	uint16 soundId;
+
+	bool enabled;
+} g_opcode201Parameters;
+
+void MystScriptParser::opcode_201_run() {
+	uint16 var105;
+
+	if (g_opcode201Parameters.enabled) {
+		switch (_vm->getCurStack()) {
+			case kSeleniticStack:
+				// Used for Card 1191 (Maze Runner)
+
+				// TODO: Fill in Function...
+				break;
+			case kStoneshipStack:
+				// Used for Card 2013 (Achenar's Rose-Skull Hologram)
+
+				// TODO: Fill in Function...
+				break;
+			case kMystStack:
+				var105 = _vm->_varStore->getVar(105);
+				if (var105 && !g_opcode201Parameters.lastVar105)
+					_vm->_sound->playSound(g_opcode201Parameters.soundId);
+				g_opcode201Parameters.lastVar105 = var105;
+				break;
+			case kMechanicalStack:
+				// Used for Card 6159 (Facing Corridor to Fortress Elevator)
+
+				// g_opcode201Parameters.u0
+				// g_opcode201Parameters.u1
+				// g_opcode201Parameters.u2
+
+				// TODO: Fill in Function...
+				break;
+			case kDemoStack:
+				// Used on Card 2001, 2002 and 2003
+
+				// TODO: Fill in Function...
+				break;
+		}
+	}
+}
+
+void MystScriptParser::opcode_201_disable() {
+	g_opcode201Parameters.enabled = false;
+	g_opcode201Parameters.soundId = 0;
+	g_opcode201Parameters.lastVar105 = 0;
+}
+
+void MystScriptParser::opcode_201(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kIntroStack:
+			_vm->_system->delayMillis(4 * 1000);
+            _vm->_gfx->copyImageToScreen(4, Common::Rect(0, 0, 544, 333));
+            break;
+		case kSeleniticStack:
+			// Used for Card 1191 (Maze Runner)
+
+			if (argc == 0) {
+				g_opcode201Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kStoneshipStack:
+			varUnusedCheck(op, var);
+
+			// Used for Card 2013 (Achenar's Rose-Skull Hologram)
+			if (argc == 0) {
+				g_opcode201Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kMystStack:
+			// Used for Cards 4257, 4260, 4263, 4266, 4269, 4272, 4275 and 4278 (Ship Puzzle Boxes)
+			if (argc == 1) {
+				g_opcode201Parameters.soundId = argv[0];
+				g_opcode201Parameters.lastVar105 = 0;
+				g_opcode201Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kMechanicalStack:
+			// Used for Card 6159 (Facing Corridor to Fortress Elevator)
+			if (argc == 3) {
+				g_opcode201Parameters.u0 = argv[0];
+				g_opcode201Parameters.u1 = argv[1];
+				g_opcode201Parameters.u2 = argv[2];
+
+				g_opcode201Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kChannelwoodStack:
+			// Used for Card 3247 (Elevator #1 Movement), 3161 (Bridge Movement), 3259 (Elevator #3 Movement) and 3252 (Elevator #2 Movement)
+			if (argc == 0) {
+				// TODO: Fill in Function. Video Playback? Rect from invoking hotspot resource...
+				if (false) {
+					// Card 3161
+					_vm->_video->playMovie(_vm->wrapMovieFilename("bridge", kChannelwoodStack), 292, 204);
+
+					// Card 3247
+					_vm->_video->playMovie(_vm->wrapMovieFilename("welev1dn", kChannelwoodStack), 214, 107);
+					_vm->_video->playMovie(_vm->wrapMovieFilename("welev1up", kChannelwoodStack), 214, 107);
+
+					// Card 3252
+					_vm->_video->playMovie(_vm->wrapMovieFilename("welev2dn", kChannelwoodStack), 215, 118);
+					_vm->_video->playMovie(_vm->wrapMovieFilename("welev2up", kChannelwoodStack), 215, 118);
+
+					// Card 3259
+					_vm->_video->playMovie(_vm->wrapMovieFilename("welev3dn", kChannelwoodStack), 213, 99);
+					_vm->_video->playMovie(_vm->wrapMovieFilename("welev3up", kChannelwoodStack), 213, 99);
+				}
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kDemoStack:
+			// Used on Card 2001, 2002 and 2003
+			if (argc == 0) {
+				g_opcode201Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+static struct {
+	bool enabled;
+	uint16 var;
+} g_opcode202Parameters;
+
+void MystScriptParser::opcode_202_run(void) {
+	if (g_opcode202Parameters.enabled) {
+		switch (_vm->getCurStack()) {
+			case kSeleniticStack:
+				// Used for Card 1191 (Maze Runner)
+
+				// TODO: Fill in function...
+				break;
+			case kDemoPreviewStack:
+			case kMystStack:
+				// Used for Card 4378 (Library Tower Rotation Map)
+				// TODO: Fill in.. Code for Tower Rotation Angle etc..
+				// Var 0, 3, 4, 5, 6, 7, 8, 9 used for Type 8 Image Display
+				// Type 11 Hotspot for control..
+				// Var 304 controls presence of Myst Library Image
+				break;
+			case kMechanicalStack:
+				// Used for Card 6220 (Sirrus' Mechanical Bird)
+				// TODO: Fill in Function
+				break;
+			case kChannelwoodStack:
+				// Used for Cards 3328, 3691, 3731, 3809, 3846 etc. (Water Valves)
+
+				// Code for Water Flow Logic
+				// Var 8 = "Water Tank Valve State"
+				// Controls
+				// Var 19 = "Water Flowing to First Water Valve"
+				// Code for this in Opcode 104 / 122
+
+				// Var 19 = "Water Flowing to First Water Valve"
+				// and
+				// Var 9 = "First Water Valve State"
+				// Controls
+				// Var 20 = "Water Flowing to Second (L) Water Valve"
+				// Var 3 = "Water Flowing (R) to Pump for Upper Walkway to Temple Elevator"
+				uint16 var9 = _vm->_varStore->getVar(9);
+				if (_vm->_varStore->getVar(19)) {
+					_vm->_varStore->setVar(20, !var9);
+					_vm->_varStore->setVar(3, var9);
+				} else {
+					// No water into Valve
+					_vm->_varStore->setVar(20, 0);
+					_vm->_varStore->setVar(3, 0);
+				}
+
+				// Var 20 = "Water Flowing to Second (L) Water Valve"
+				// and
+				// Var 10 = "Second (L) Water Valve State"
+				// Controls
+				// Var 24 = "Water Flowing to Third (L, L) Water Valve"
+				// Var 21 = "Water Flowing to Third (L, R) Water Valve"
+				uint16 var10 = _vm->_varStore->getVar(10);
+				if (_vm->_varStore->getVar(20)) {
+					_vm->_varStore->setVar(24, !var10);
+					_vm->_varStore->setVar(21, var10);
+				} else {
+					// No water into Valve
+					_vm->_varStore->setVar(24, 0);
+					_vm->_varStore->setVar(21, 0);
+				}
+
+				// Var 21 = "Water Flowing to Third (L, R) Water Valve"
+				// and
+				// Var 11 = "Third (L, R) Water Valve State"
+				// Controls
+				// Var 23 = "Water Flowing to Fourth (L, R, L) Water Valve"
+				// Var 22 = "Water Flowing to Fourth (L, R, R) Water Valve"
+				uint16 var11 = _vm->_varStore->getVar(11);
+				if (_vm->_varStore->getVar(21)) {
+					_vm->_varStore->setVar(23, !var11);
+					_vm->_varStore->setVar(22, var11);
+				} else {
+					// No water into Valve
+					_vm->_varStore->setVar(23, 0);
+					_vm->_varStore->setVar(22, 0);
+				}
+
+				// Var 24 = "Water Flowing to Third (L, L) Water Valve"
+				// and
+				// Var 14 = "Third (L, L) Water Valve State"
+				// Controls
+				// Var 29 = "Water Flowing to Pipe In Water (L, L, L)"
+				// Var 28 = "Water Flowing to Join and Pump Bridge (L, L, R)"
+				uint16 var14 = _vm->_varStore->getVar(14);
+				if (_vm->_varStore->getVar(24)) {
+					_vm->_varStore->setVar(29, !var14);
+					_vm->_varStore->setVar(28, var14);
+				} else {
+					// No water into Valve
+					_vm->_varStore->setVar(29, 0);
+					_vm->_varStore->setVar(28, 0);
+				}
+
+				// Var 22 = "Water Flowing to Fourth (L, R, R) Water Valve"
+				// and
+				// Var 12 = "Fourth (L, R, R) Water Valve State"
+				// Controls
+				// Var 25 = "Water Flowing to Pipe Bridge (L, R, R, L)"
+				// Var 15 = "Water Flowing (L, R, R, R) to Pump for Lower Walkway to Upper Walkway Elevator"
+				uint16 var12 = _vm->_varStore->getVar(12);
+				if (_vm->_varStore->getVar(22)) {
+					_vm->_varStore->setVar(25, !var12);
+					_vm->_varStore->setVar(15, var12);
+				} else {
+					// No water into Valve
+					_vm->_varStore->setVar(25, 0);
+					_vm->_varStore->setVar(15, 0);
+				}
+
+				// Var 23 = "Water Flowing to Fourth (L, R, L) Water Valve"
+				// and
+				// Var 13 = "Fourth (L, R, L) Water Valve State"
+				// Controls
+				// Var 27 = "Water Flowing to Join and Pump Bridge (L, R, L, L)"
+				// Var 26 = "Water Flowing to Pipe At Entry Point (L, R, L, R)"
+				uint16 var13 = _vm->_varStore->getVar(13);
+				if (_vm->_varStore->getVar(23)) {
+					_vm->_varStore->setVar(27, !var13);
+					_vm->_varStore->setVar(26, var13);
+				} else {
+					// No water into Valve
+					_vm->_varStore->setVar(27, 0);
+					_vm->_varStore->setVar(26, 0);
+				}
+
+				// TODO: Not sure that original had OR logic for water flow at Join...
+				// Var 27 = "Water Flowing to Join and Pump Bridge (L, R, L, L)"
+				// Or
+				// Var 28 = "Water Flowing to Join and Pump Bridge (L, L, R)"
+				// Controls
+				// Var 31 = "Water Flowing to Join (L, L, R)" // 0 to 2 = Stop Sound, Background, Background with Water Flow
+				// Var 7 = "Bridge Pump Running"
+				// TODO: Not sure about control of Var 31 which is tristate...
+				if (_vm->_varStore->getVar(27) || _vm->_varStore->getVar(28)) {
+					_vm->_varStore->setVar(31, 2); // Background with Water Flow
+					_vm->_varStore->setVar(7, 1);
+				} else {
+					// No water into Valve
+					_vm->_varStore->setVar(31, 1); // Background 
+					_vm->_varStore->setVar(7, 0);
+				}
+
+				// TODO: Code for this shouldn't be here...
+				//       Move to Opcodes called by Pipe Extension...
+				// Var 25 = "Water Flowing to Pipe Bridge (L, R, R, L)"
+				// and
+				// Var 6 = "Pipe Bridge Extended"
+				// Controls
+				// Var 32 = "Water Flowing (L, R, R, L, Pipe) State" }, // 0 to 2 = Stop Sound, Background, Background with Water Flow
+				// Var 4 = "Water Flowing (L, R, R, L, Pipe Extended) to Pump for Book Room Elevator"
+				// TODO: Not sure about control of Var 32 which is tristate...
+				if (_vm->_varStore->getVar(25) && _vm->_varStore->getVar(6)) {
+					_vm->_varStore->setVar(32, 2); // Background with Water Flow
+					_vm->_varStore->setVar(4, 1);
+				} else {
+					// No water into Valve
+					_vm->_varStore->setVar(32, 1); // Background 
+					_vm->_varStore->setVar(4, 0);
+				}
+				break;
+		}
+	}
+}
+
+void MystScriptParser::opcode_202_disable(void) {
+	g_opcode202Parameters.enabled = false;
+}
+
+void MystScriptParser::opcode_202(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	switch (_vm->getCurStack()) {
+		case kSeleniticStack:
+			varUnusedCheck(op, var);
+
+			// Used for Card 1191 (Maze Runner)
+			if (argc == 0) {
+				g_opcode202Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kStoneshipStack:
+			varUnusedCheck(op, var);
+
+			// Used for Card 2160 (Lighthouse Battery Pack Closeup)
+			// TODO: Implement Code...
+			// Not Sure of Purpose - Update of Light / Discharge?
+			unknown(op, var, argc, argv);
+			break;
+		case kDemoPreviewStack:
+		case kMystStack:
+			varUnusedCheck(op, var);
+
+			// Used for Card 4378 (Library Tower Rotation Map)
+			if (argc == 1) {
+				// TODO: Figure Out argv[0] purpose.. number of image resources?
+				g_opcode202Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kMechanicalStack:
+			// Used for Card 6220 (Sirrus' Mechanical Bird)
+			if (argc == 0) {
+				g_opcode202Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kChannelwoodStack:
+			// Used for Cards 3328, 3691, 3731, 3809, 3846 etc. (Water Valves)
+			if (argc == 0) {
+				g_opcode202Parameters.var = var;
+				g_opcode202Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+			varUnusedCheck(op, var);
+
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+static struct {
+	bool enabled;
+} g_opcode203Parameters;
+
+void MystScriptParser::opcode_203_run(void) {
+	if (g_opcode203Parameters.enabled) {
+		switch (_vm->getCurStack()) {
+			case kSeleniticStack:
+				// Used for Card 1245 (Sound Receiver)
+				// TODO: Fill in Logic to Change Viewer Display etc.?
+				break;
+			case kMystStack:
+				// Used for Card 4138 (Dock Forechamber Door)
+				// TODO: Fill in Logic..
+				break;
+			case kMechanicalStack:
+				// Used for Card 6043 (Weapons Rack with Snake Box)
+				// TODO: Fill in Logic for Snake Box...
+				break;
+			case kChannelwoodStack:
+				// Used for Card 3310 (Sirrus' Room Right Bed Drawer),
+				// Card 3307 (Sirrus' Room Left Bed Drawer)
+				// and Card 3318 (Sirrus' Room Nightstand Drawer)
+				// TODO: Fill in Logic...
+				break;
+		}
+	}
+}
+
+void MystScriptParser::opcode_203_disable(void) {
+	g_opcode203Parameters.enabled = false;
+}
+
+void MystScriptParser::opcode_203(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	uint16 imageIdDarkDoorOpen = 0;
+	uint16 imageIdDarkDoorClosed = 0;
+
+	switch (_vm->getCurStack()) {
+		case kSeleniticStack:
+			// Used for Card 1245 (Sound Receiver)
+			if (argc == 0) {
+				g_opcode203Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kStoneshipStack:
+			// Used for all/most Cards in Tunnels Down To Brothers Rooms
+
+			// TODO: Duplicate or similar function to Opcode 203?
+			if (argc == 2 || argc == 4) {
+				debugC(kDebugScript, "Opcode %d: %d Arguments", op, argc);
+
+				uint16 u0 = argv[0];
+				if (argc == 4) {
+					imageIdDarkDoorOpen = argv[1];
+					imageIdDarkDoorClosed = argv[2];
+				}
+				uint16 soundIdAlarm = argv[argc - 1];
+
+				debugC(kDebugScript, "\tu0: %d", u0);
+				if (argc == 4) {
+					debugC(kDebugScript, "\timageIdDarkDoorOpen: %d", imageIdDarkDoorOpen);
+					debugC(kDebugScript, "\tsoundIdDarkDoorClosed: %d", imageIdDarkDoorClosed);
+				}
+				debugC(kDebugScript, "\tsoundIdAlarm: %d", soundIdAlarm);
+
+				// TODO: Fill in Correct Function for Lights
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kMystStack:
+			// Used for Card 4138 (Dock Forechamber Door)
+			if (argc == 0) {
+				g_opcode203Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kMechanicalStack:
+			// Used for Card 6043 (Weapons Rack with Snake Box)
+			if (argc == 0) {
+				g_opcode203Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kChannelwoodStack:
+			// Used for Card 3310 (Sirrus' Room Right Bed Drawer),
+			// Card 3307 (Sirrus' Room Left Bed Drawer)
+			// and Card 3318 (Sirrus' Room Nightstand Drawer)
+			if (argc == 0) {
+				g_opcode203Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+static struct {
+	bool enabled;
+	uint16 soundId;
+} g_opcode204Parameters;
+
+void MystScriptParser::opcode_204_run(void) {
+	if (g_opcode204Parameters.enabled) {
+		switch (_vm->getCurStack()) {
+			case kSeleniticStack:
+				// Used for Card 1147 (Sound Code Lock)
+				// TODO: Fill in code for Sound Lock...
+				break;
+			case kMystStack:
+				// Used for Card 4134 and 4149 (Dock)
+				// TODO: Fill in..
+				break;
+			case kMechanicalStack:
+				// TODO: Fill in Logic.
+				// Var 12 holds Large Cog Position in range 0 to 5
+				// - For animation
+				// Var 11 holds C position in range 0 to 9
+				// - 4 for Correct Answer
+				// C Movement Sound
+				//_vm->_sound->playSound(g_opcode204Parameters.soundId);
+				break;
+		}
+	}
+}
+
+void MystScriptParser::opcode_204_disable(void) {
+	g_opcode204Parameters.enabled = false;
+}
+
+void MystScriptParser::opcode_204(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kSeleniticStack:
+			// Used for Card 1147 (Sound Code Lock)
+			if (argc == 0) {
+				g_opcode204Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kStoneshipStack:
+			// Used for Card 2160 (Lighthouse Battery Pack Closeup)
+			if (argc == 0) {
+				// TODO: Implement Code For Battery Meter Level
+				// Overwrite _vm->_resources[1]->_subImages[0].rect.bottom 1 to 80
+				// Add accessor functions for this...
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kMystStack:
+			// Used for Card 4134 and 4149 (Dock)
+			// TODO: Fill in logic.. Unsure of exact function to trigger and location on screen..
+			if (false) {
+				// Card 4134
+				_vm->_video->playMovie(_vm->wrapMovieFilename("birds1", kMystStack), 416, 0);
+				
+				// Card 4149
+				_vm->_video->playMovie(_vm->wrapMovieFilename("birds2", kMystStack), 433, 0);
+				
+				// Unsure...
+				_vm->_video->playMovie(_vm->wrapMovieFilename("birds3", kMystStack), 0, 0);
+			}
+			break;
+		case kMechanicalStack:
+			// Used for Card 6180 (Lower Elevator Puzzle)
+			if (argc == 1) {
+				g_opcode204Parameters.soundId = argv[0];
+				g_opcode204Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+static struct {
+	uint16 soundIdPosition[4];
+
+	bool enabled;
+} g_opcode205Parameters;
+
+void MystScriptParser::opcode_205_run(void) {
+	if (g_opcode205Parameters.enabled) {
+		switch (_vm->getCurStack()) {
+			case kSeleniticStack:
+				// Used for Card 1191 (Maze Runner)
+				// TODO: Fill in function...
+				break;
+			case kMystStack:
+				// Used for Card 4532 (Rocketship Piano)
+				// TODO: Fill in function...
+				break;
+			case kMechanicalStack:
+				// Used for Card 6156 (Fortress Rotation Controls)
+				// TODO: Fill in function...
+				// g_opcode205Parameters.soundIdPosition[4]
+				break;
+		}
+	}
+}
+
+void MystScriptParser::opcode_205_disable(void) {
+	g_opcode205Parameters.enabled = false;
+}
+
+void MystScriptParser::opcode_205(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	uint16 imageIdDoorOpen = 0;
+	uint16 imageIdDoorClosed = 0;
+
+	switch (_vm->getCurStack()) {
+		case kSeleniticStack:
+			// Used for Card 1191 (Maze Runner)
+
+			if (argc == 0) {
+				g_opcode205Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kStoneshipStack:
+			// Used on Cards 2322, 2285 (Tunnels Down To Brothers Rooms)
+
+			// TODO: Duplicate or similar function to Opcode 203?
+			if (argc == 2 || argc == 4) {
+				debugC(kDebugScript, "Opcode %d: %d Arguments", op, argc);
+
+				uint16 u0 = argv[0];
+				if (argc == 4) {
+					imageIdDoorOpen = argv[1];
+					imageIdDoorClosed = argv[2];
+				}
+				uint16 soundIdAlarm = argv[argc - 1];
+
+				debugC(kDebugScript, "\tu0: %d", u0);
+				if (argc == 4) {
+					debugC(kDebugScript, "\timageIdDoorOpen: %d", imageIdDoorOpen);
+					debugC(kDebugScript, "\tsoundIdDoorClosed: %d", imageIdDoorClosed);
+				}
+				debugC(kDebugScript, "\tsoundIdAlarm: %d", soundIdAlarm);
+
+				// TODO: Fill in Correct Function for Lights
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kMystStack:
+			// Used for Card 4532 (Rocketship Piano)
+
+			if (argc == 0) {
+				g_opcode205Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kMechanicalStack:
+			// Used for Card 6156 (Fortress Rotation Controls)
+
+			if (argc == 4) {
+				g_opcode205Parameters.soundIdPosition[0] = argv[0];
+				g_opcode205Parameters.soundIdPosition[1] = argv[1];
+				g_opcode205Parameters.soundIdPosition[2] = argv[2];
+				g_opcode205Parameters.soundIdPosition[3] = argv[3];
+
+				g_opcode205Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+static struct {
+	uint16 soundIdStart[2];
+	uint16 soundIdPosition[4];
+
+	bool enabled;
+} g_opcode206Parameters;
+
+void MystScriptParser::opcode_206_run(void) {
+	if (g_opcode206Parameters.enabled) {
+		switch (_vm->getCurStack()) {
+			case kSeleniticStack:
+				// Used for Card 1191 (Maze Runner)
+				// TODO: Fill in function...
+				break;
+			case kMechanicalStack:
+				// Used for Card 6044 (Fortress Rotation Simulator)
+
+				// g_opcode206Parameters.soundIdStart[2]
+				// g_opcode206Parameters.soundIdPosition[4]
+
+				// TODO: Fill in function...
+				break;
+		}
+	}
+}
+
+void MystScriptParser::opcode_206_disable(void) {
+	g_opcode206Parameters.enabled = false;
+}
+
+void MystScriptParser::opcode_206(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kSeleniticStack:
+			// Used for Card 1191 (Maze Runner)
+
+			if (argc == 0) {
+				g_opcode206Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kStoneshipStack:
+			// Used for Cards 2272 and 2234 (Facing Out of Door)
+			if (argc == 0) {
+				debugC(kDebugScript, "Opcode %d: Unknown, %d Arguments", op, argc);
+				// TODO: Function Unknown...
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kMystStack:
+			// Used for Card 4256 (Butterfly Movie Activation)
+			// TODO: Implement Logic...
+			break;
+		case kMechanicalStack:
+			// Used for Card 6044 (Fortress Rotation Simulator)
+			if (argc == 6) {
+				g_opcode206Parameters.soundIdStart[0] = argv[0];
+				g_opcode206Parameters.soundIdStart[1] = argv[1];
+				g_opcode206Parameters.soundIdPosition[0] = argv[2];
+				g_opcode206Parameters.soundIdPosition[1] = argv[3];
+				g_opcode206Parameters.soundIdPosition[2] = argv[4];
+				g_opcode206Parameters.soundIdPosition[3] = argv[5];
+
+				g_opcode206Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_207(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kStoneshipStack:
+			// Used for Card 2138 (Lighthouse Key/Chest Animation Logic)
+			// TODO: Fill in function
+			warning("TODO: Opcode 207 Lighthouse Key/Chest Animation Logic");
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_208(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	switch (_vm->getCurStack()) {
+		case kStoneshipStack:
+			varUnusedCheck(op, var);
+
+			// Used in Card 2218 (Telescope view)
+			if (argc == 3) {
+				debugC(kDebugScript, "Opcode %d: Telescope View", op);
+				uint16 imagePanorama = argv[0];
+				uint16 imageLighthouseOff = argv[1];
+				uint16 imageLighthouseOn = argv[2];
+
+				debugC(kDebugScript, "Image (Panorama): %d", imagePanorama);
+				debugC(kDebugScript, "Image (Lighthouse Off): %d", imageLighthouseOff);
+				debugC(kDebugScript, "Image (Lighthouse On): %d", imageLighthouseOn);
+
+				// TODO: Fill in Logic.
+			} else
+				unknown(op, var, argc, argv);
+            break;
+		case kMystStack:
+			if (argc == 0) {
+				debugC(kDebugScript, "Opcode %d: Imager Function", op);
+				debugC(kDebugScript, "Var: %d", var);
+
+				// TODO: Fill in Correct Function
+				if (false) {
+					_vm->_video->playMovie(_vm->wrapMovieFilename("vltmntn", kMystStack), 159, 97);
+				}
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+static struct {
+	uint16 u0[5];
+	uint16 u1[5];
+	uint16 stateVar;
+
+	uint16 soundId;
+
+	bool enabled;
+} g_opcode209Parameters;
+
+void MystScriptParser::opcode_209_run(void) {
+	static bool enabledLast;
+	
+	if (g_opcode209Parameters.enabled) {
+		switch (_vm->getCurStack()) {
+			case kStoneshipStack:
+				// Used for Card 2004 (Achenar's Room Drawers)
+
+				// TODO: Implement Function...
+				// Swap Open Drawers?
+				break;
+			case kDemoPreviewStack:
+			case kMystStack:
+				// Used for Card 4334 and 4348 (Myst Library Bookcase Door)
+				if (!enabledLast)
+					// TODO: If Variable changed...
+					_vm->_sound->playSound(g_opcode209Parameters.soundId);
+
+					// TODO: Code to trigger Type 6 to play movie...
+				break;
+			case kMechanicalStack:
+				// Used for Card 6044 (Fortress Rotation Simulator)
+
+				// TODO: Implement Function For Secret Panel State as
+				//       per Opcode 200 function (Mechanical)
+				break;
+			default:
+				break;
+		}
+	}
+
+	enabledLast = g_opcode209Parameters.enabled;
+}
+
+void MystScriptParser::opcode_209_disable(void) {
+	g_opcode209Parameters.enabled = false;
+}
+
+void MystScriptParser::opcode_209(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kStoneshipStack:
+			// Used for Card 2004 (Achenar's Room Drawers)
+			if (argc == 11) {
+				g_opcode209Parameters.u0[0] = argv[0];
+				g_opcode209Parameters.u0[1] = argv[1];
+				g_opcode209Parameters.u0[2] = argv[2];
+				g_opcode209Parameters.u0[3] = argv[3];
+				g_opcode209Parameters.u0[4] = argv[4];
+
+				g_opcode209Parameters.u1[0] = argv[5];
+				g_opcode209Parameters.u1[1] = argv[6];
+				g_opcode209Parameters.u1[2] = argv[7];
+				g_opcode209Parameters.u1[3] = argv[8];
+				g_opcode209Parameters.u1[4] = argv[9];
+
+				g_opcode209Parameters.stateVar = argv[10];
+
+				g_opcode209Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kDemoPreviewStack:
+		case kMystStack:
+			// Used for Card 4334 and 4348 (Myst Library Bookcase Door)
+			if (argc == 1) {
+				g_opcode209Parameters.soundId = argv[0];
+				g_opcode209Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kMechanicalStack:
+			// Used for Card 6044 (Fortress Rotation Simulator)
+			if (argc == 0) {
+				g_opcode209Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+static struct {
+	bool enabled;
+} g_opcode210Parameters;
+
+void MystScriptParser::opcode_210_run(void) {
+	if (g_opcode210Parameters.enabled) {
+		// Code for Generator Puzzle
+
+		// Var 52 to 61 Hold Button State for 10 generators
+		// Var 64, 65 - 2 8-Segments for Rocket Power Dial
+		// Var 62, 63 - 2 8-Segments for Power Dial
+		// Var 96, 97 - Needle for Power and Rocket Power Dials
+
+		// Var 44 Holds State for Rocketship
+		// 0 = No Power
+		// 1 = Insufficient Power
+		// 2 = Correct Power i.e. 59V
+
+		// Var 93 Holds Breaker nearest Generator State
+		// Var 94 Holds Breaker nearest Rocket Ship State
+		// 0 = Closed 1 = Open
+
+		const uint16 correctVoltage = 59;
+
+		// Correct Solution is 4, 7, 8, 9 i.e. 16 + 2 + 22 + 19 = 59
+		const uint16 genVoltages[10] = { 10, 7, 8, 16, 5, 1, 2, 22, 19, 9 };
+
+		uint16 powerVoltage = 0;
+		uint16 rocketPowerVoltage = 0;
+
+		// Calculate Power Voltage from Generator Contributions
+		for (byte i = 0; i < ARRAYSIZE(genVoltages); i++)
+			if (_vm->_varStore->getVar(52 + i))
+				powerVoltage += genVoltages[i];
+
+		// Logic for Var 49 - Generator Running Sound Control
+		if (powerVoltage == 0)
+			_vm->_varStore->setVar(49, 0);
+		else
+			_vm->_varStore->setVar(49, 1);
+
+		// TODO: Animation Code to Spin Up and Spin Down LED Dials?
+		// Code For Power Dial Var 62 and 63
+		_vm->_varStore->setVar(62, powerVoltage / 10);
+		_vm->_varStore->setVar(63, powerVoltage % 10);
+		// TODO: Var 96 - Power Needle Logic
+
+		// Code For Breaker Logic
+		if (_vm->_varStore->getVar(93) != 0 || _vm->_varStore->getVar(94) != 0)
+			rocketPowerVoltage = 0;
+		else {
+			if (powerVoltage <= correctVoltage)
+				rocketPowerVoltage = powerVoltage;
+			else {
+				// Blow Generator Room Breaker...
+				_vm->_varStore->setVar(93, 1);
+				// TODO: I think Logic For Blowing Other Breaker etc. 
+				// is done in process on Breaker Cards.
+
+				rocketPowerVoltage = 0;
+			}
+		}
+
+		// TODO: Animation Code to Spin Up and Spin Down LED Dials?
+		// Code For Rocket Power Dial
+		_vm->_varStore->setVar(64, rocketPowerVoltage / 10);
+		_vm->_varStore->setVar(65, rocketPowerVoltage % 10);
+		// TODO: Var 97 - Rocket Power Needle Logic
+
+		// Set Rocket Ship Power Based on Power Level
+		if (rocketPowerVoltage == 0)
+			_vm->_varStore->setVar(44, 0);
+		else if (rocketPowerVoltage < correctVoltage)
+			_vm->_varStore->setVar(44, 1);
+		else if (rocketPowerVoltage == correctVoltage)
+			_vm->_varStore->setVar(44, 2);
+		else // Should Not Happen Case
+			_vm->_varStore->setVar(44, 0);
+	}
+}
+
+void MystScriptParser::opcode_210_disable(void) {
+	g_opcode210Parameters.enabled = false;
+}
+
+void MystScriptParser::opcode_210(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kStoneshipStack:
+			varUnusedCheck(op, var);
+
+			// Used in Cards 2205 and 2207 (Cloud Orbs in Sirrus' Room)
+			if (argc == 2) {
+				uint16 soundId = argv[0];
+				uint16 soundIdStopping = argv[1];
+
+				// TODO: Work Out Function i.e. control Var etc.
+				if (false) {
+					_vm->_sound->playSound(soundId);
+					_vm->_sound->playSound(soundIdStopping);
+				}
+			} else
+				unknown(op, var, argc, argv);
+			break;
+		case kMystStack:
+			// Used for Card 4297 (Generator Puzzle)
+			if (argc == 2) {
+				// TODO: Work Out 2 parameters meaning... 16, 17
+				// Script Resources for Generator Spinup and Spindown Sounds?
+				g_opcode210Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+static struct {
+	bool enabled;
+} g_opcode211Parameters;
+
+void MystScriptParser::opcode_211_run(void) {
+	const uint16 imageBaseId = 4779;
+	const uint16 gridBaseLeft = 173;
+	const uint16 gridBaseTop = 168;
+
+	static uint16 lastGridState[6];
+	uint16 gridState[6];
+	uint16 image;
+
+	if (g_opcode211Parameters.enabled) {
+		// Grid uses Var 17 to 22 as bitfields (8 horizontal cells x 6 vertical)
+		for (byte i = 0; i < 6; i++) {
+			gridState[i] = _vm->_varStore->getVar(i + 17);
+
+			if (gridState[i] != lastGridState[i]) {
+				for (byte j = 0; j < 8; j++) {
+					// TODO: Animation Code
+					if ((gridState[i] >> (7 - j)) & 1)
+						image = 16;
+					else
+						image = 0;
+
+					_vm->_gfx->copyImageToScreen(imageBaseId + image, Common::Rect(gridBaseLeft + (j * 26), gridBaseTop + (i * 26), gridBaseLeft + ((j + 1) * 26), gridBaseTop + ((i + 1) * 26)));
+				}
+			}
+
+			lastGridState[i] = gridState[i];
+		}
+
+		// Var 23 contains boolean for whether pattern matches correct book pattern i.e. Pattern 158
+		if (gridState[0] == 0xc3 && gridState[1] == 0x6b && gridState[2] == 0xa3 &&
+		    gridState[3] == 0x93 && gridState[4] == 0xcc && gridState[5] == 0xfa)
+			_vm->_varStore->setVar(23, 1);
+		else
+			_vm->_varStore->setVar(23, 0);
+	}
+}
+
+void MystScriptParser::opcode_211_disable(void) {
+	g_opcode211Parameters.enabled = false;
+}
+
+void MystScriptParser::opcode_211(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kDemoPreviewStack:
+		case kMystStack:
+			// Used for Card 4059 (Fireplace Puzzle)
+			if (argc == 0) {
+				for (byte i = 0; i < 6; i++)
+					_vm->_varStore->setVar(i + 17, 0);
+
+				g_opcode211Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+static struct {
+	bool enabled;
+} g_opcode212Parameters;
+
+void MystScriptParser::opcode_212_run(void) {
+	if (g_opcode212Parameters.enabled) {
+		// TODO: Implement Correct Code for Myst Clock Tower Cog Puzzle
+		// Card 4113
+
+		if (false) {
+			// 3 videos to be played of Cog Movement
+			// TODO: Not 100% sure of movie positions.
+			_vm->_video->playMovie(_vm->wrapMovieFilename("cl1wg1", kMystStack), 220, 50);
+			_vm->_video->playMovie(_vm->wrapMovieFilename("cl1wg2", kMystStack), 220, 80);
+			_vm->_video->playMovie(_vm->wrapMovieFilename("cl1wg3", kMystStack), 220, 110);
+
+			// 1 video of weight descent
+			_vm->_video->playMovie(_vm->wrapMovieFilename("cl1wlfch", kMystStack), 123, 0);
+
+			// Video of Cog Open on Success
+			_vm->_video->playMovie(_vm->wrapMovieFilename("cl1wggat", kMystStack), 195, 225);
+			// Var 40 set on success
+			_vm->_varStore->setVar(40, 1);
+		}
+	}
+}
+
+void MystScriptParser::opcode_212_disable(void) {
+	g_opcode212Parameters.enabled = false;
+}
+
+void MystScriptParser::opcode_212(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used for Card 4113 (Clock Tower Cog Puzzle)
+			if (argc == 0) {
+				g_opcode212Parameters.enabled = true;
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_213(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used for Card 4524 (Dockside Facing Towards Ship)
+			if (argc == 0) {
+				// TODO: Implement Code...
+				// Code for Gull Videos?
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_214(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used for Card 4500 (Stellar Observatory)
+			if (argc == 5) {
+				debugC(kDebugScript, "Opcode %d: Unknown...", op);
+
+				uint16 u0 = argv[0];
+				uint16 u1 = argv[1];
+				uint16 u2 = argv[2];
+				uint16 u3 = argv[3];
+				uint16 u4 = argv[4];
+
+				debugC(kDebugScript, "\tu0: %d", u0);
+				debugC(kDebugScript, "\tu1: %d", u1);
+				debugC(kDebugScript, "\tu2: %d", u2);
+				debugC(kDebugScript, "\tu3: %d", u3);
+				debugC(kDebugScript, "\tu4: %d", u4);
+				// TODO: Complete Implementation...
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_215(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used for Card 4134 (Dock Facing Marker Switch)
+			// TODO: Fill in logic. Logic for Gull Videos?
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_216(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used for Card 4571 (Channelwood Tree)
+			if (argc == 0) {
+				// TODO: Fill in logic for Tree Position From Far...
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_217(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used for Card 4601 (Channelwood Tree)
+			if (argc == 2) {
+				// TODO: Fill in logic for Tree Position Close Up...
+				// 2 arguments: 4, 4
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_218(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used for Card 4097 (Cabin Boiler)
+			// TODO: Fill in logic
+			if (false) {
+				_vm->_video->playMovie(_vm->wrapMovieFilename("cabfirfr", kMystStack), 254, 244);
+				_vm->_video->playMovie(_vm->wrapMovieFilename("cabcgfar", kMystStack), 254, 138);
+			}
+
+			// Used for Card 4098 (Cabin Boiler)
+			// TODO: Fill in logic
+			if (false) {
+				_vm->_video->playMovie(_vm->wrapMovieFilename("cabfire", kMystStack), 240, 279);
+				_vm->_video->playMovie(_vm->wrapMovieFilename("cabingau", kMystStack), 243, 97);
+			}
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_219(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used for Card 4530 (Rocketship Music Puzzle)
+			if (argc == 5) {
+				debugC(kDebugScript, "Opcode %d: Unknown...", op);
+
+				uint16 u0 = argv[0];
+				uint16 u1 = argv[1];
+				uint16 u2 = argv[2];
+				uint16 u3 = argv[3];
+				uint16 u4 = argv[4];
+
+				debugC(kDebugScript, "\tu0: %d", u0);
+				debugC(kDebugScript, "\tu1: %d", u1);
+				debugC(kDebugScript, "\tu2: %d", u2);
+				debugC(kDebugScript, "\tu3: %d", u3);
+				debugC(kDebugScript, "\tu4: %d", u4);
+				// TODO: Fill in logic...
+			} else
+            	unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_220(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used for Card 4530 (Rocketship Music Puzzle Video)
+			// TODO: Fill in logic.
+			if (false) {
+				// loop?
+				_vm->_video->playMovie(_vm->wrapMovieFilename("selenbok", kMystStack), 224, 41);
+			}
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_221(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used for Card 4168 (Green Book Movies)
+			// Movie plays in resource #0 rect
+			// TODO: Not sure if subsection is looped...
+			if (!_vm->_varStore->getVar(302)) {
+				// HACK: Stop Wind Sounds.. Think this is a problem at library entrance.
+				_vm->_sound->stopSound();
+				_vm->_video->playBackgroundMovie(_vm->wrapMovieFilename("atrusbk1", kMystStack), 314, 76);
+				_vm->_varStore->setVar(302, 1);
+			} else {
+				// HACK: Stop Wind Sounds.. Think this is a problem at library entrance.
+				_vm->_sound->stopSound();
+				_vm->_video->playBackgroundMovie(_vm->wrapMovieFilename("atrusbk2", kMystStack), 314, 76);
+			}
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_222(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used for Card 4141 (Myst Dock Facing Sea)
+			if (argc == 0) {
+				// TODO: Logic for Gull Videos?
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_298(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kDemoPreviewStack:
+			// Used for Card 3000 (Closed Myst Book)
+			// TODO: Fill in logic.
+			// Start Voice Over... which controls book opening
+			_vm->_sound->playSound(3001);
+			
+			// then link to Myst - Trigger of Hotspot? then opcode 199/196/197 for voice over continue?
+			// TODO: Sync Voice and Actions to Original
+			// TODO: Flash Library Red
+			// TODO: Move to run process based delay to prevent
+			//       blocking...
+			_vm->_system->delayMillis(20 * 1000);
+			for (uint16 imageId = 3001; imageId <= 3012; imageId++) {
+				_vm->_gfx->copyImageToScreen(imageId, Common::Rect(0, 0, 544, 333));
+				_vm->_system->delayMillis(5 * 1000);
+			}
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_299(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kDemoPreviewStack:
+			// Used for Card 3002 (Myst Island Overview)
+			// TODO: Fill in logic.
+			// Zoom into Island?
+			// On this card is a Type 8 controlled by Var 0, which
+			// can change the Myst Library to Red..
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_300(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	switch (_vm->getCurStack()) {
+		case kIntroStack:
+			varUnusedCheck(op, var);
+			// TODO: StopSound?
+			unknown(op, var, argc, argv);
+            break;
+		case kDemoPreviewStack:
+		case kMystStack:
+			// Used in Card 4371 (Blue Book) Var = 101 
+			//     and Card 4363 (Red Book)  Var = 100
+			// TODO: Fill in Logic
+			debugC(kDebugScript, "Opcode %d: Book Exit Function...", op);
+			debugC(kDebugScript, "Var: %d", var);
+            break;
+		case kStoneshipStack:
+			// Used in Card 2218 (Telescope view)
+			varUnusedCheck(op, var);
+			// TODO: Fill in Logic. Clearing Variable for View?
+            break;
+		case kMechanicalStack:
+			// Used in Card 6156 (Fortress Elevator View)
+			varUnusedCheck(op, var);
+			// TODO: Fill in Logic. Clearing Variable for View?
+            break;
+		case kChannelwoodStack:
+			// Used in Card 3012 (Achenar's Holoprojector Control)
+			varUnusedCheck(op, var);
+			// TODO: Fill in Logic. Clearing Variable for View?
+            break;
+		case kDniStack:
+			// Used in Card 5014 (Atrus Writing)
+			varUnusedCheck(op, var);
+			// TODO: Fill in Logic.
+            break;
+		case kDemoStack:
+			// Used on Card 2000
+			varUnusedCheck(op, var);
+
+			// TODO: Fill in Function...
+			break;
+        default:
+			varUnusedCheck(op, var);
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_301(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	switch (_vm->getCurStack()) {
+		case kDemoPreviewStack:
+		case kMystStack:
+			// Used in Card 4080 (Fireplace Book) and Other Myst Library Books
+			// TODO: Fill in Logic. Clear Variable on Book exit.. or Copy from duplicate..
+			_vm->_varStore->setVar(0, 1);
+			break;
+        default:
+			varUnusedCheck(op, var);
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_302(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used in Card 4113 (Clock Tower Cog Puzzle)
+			// TODO: Fill in Logic
+			break;
+        default:
+			varUnusedCheck(op, var);
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_303(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used for Card 4141 (Myst Dock Facing Sea)
+			if (argc == 0) {
+				debugC(kDebugScript, "Opcode %d: Clear Dock Forechamber Door Variable", op);
+				_vm->_varStore->setVar(105, 0);
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_304(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used for Card 4601 (Channelwood Tree)
+			if (argc == 0) {
+				debugC(kDebugScript, "Opcode %d: Unknown...", op);
+				// TODO: Logic for clearing variable?
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_305(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used for Card 4601 (Channelwood Tree)
+			if (argc == 0) {
+				debugC(kDebugScript, "Opcode %d: Unknown...", op);
+				// TODO: Logic for clearing variable?
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_306(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used for Card 4098 (Cabin Boiler Puzzle)
+			if (argc == 0) {
+				debugC(kDebugScript, "Opcode %d: Unknown...", op);
+				// TODO: Logic for clearing variable?
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_307(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used for Card 4299 (Generator Room Controls)
+			if (argc == 0) {
+				debugC(kDebugScript, "Opcode %d: Unknown...", op);
+				// TODO: Logic for clearing variable?
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_308(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used for Card 4530 (Rocketship Music Sliders)
+			if (argc == 0) {
+				debugC(kDebugScript, "Opcode %d: Unknown...", op);
+				// TODO: Logic for clearing variable?
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_309(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used for Card 4168 (Green D'ni Book Open), Red Book Open and Blue Book Open
+			if (argc == 0) {
+				debugC(kDebugScript, "Opcode %d: Unknown...", op);
+				// TODO: Logic for clearing variable?
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+void MystScriptParser::opcode_312(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
+	varUnusedCheck(op, var);
+
+	switch (_vm->getCurStack()) {
+		case kMystStack:
+			// Used for Card 4698 (Dock Forechamber Imager)
+			if (argc == 0) {
+				debugC(kDebugScript, "Opcode %d: Unknown...", op);
+				// TODO: Logic for clearing variable?
+			} else
+				unknown(op, var, argc, argv);
+			break;
+        default:
+            unknown(op, var, argc, argv);
+			break;
+	}
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/myst_scripts.h b/engines/mohawk/myst_scripts.h
new file mode 100644
index 0000000000..39986a3db2
--- /dev/null
+++ b/engines/mohawk/myst_scripts.h
@@ -0,0 +1,226 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#ifndef MYST_SCRIPTS_H
+#define MYST_SCRIPTS_H
+
+#include "common/scummsys.h"
+#include "common/util.h"
+
+namespace Mohawk {
+
+#define DECLARE_OPCODE(x) void x(uint16 op, uint16 var, uint16 argc, uint16 *argv)
+
+class MohawkEngine_Myst;
+struct MystScriptEntry;
+
+class MystScriptParser {
+public:
+	MystScriptParser(MohawkEngine_Myst *vm);
+	~MystScriptParser();
+	
+	void runScript(uint16 scriptCount, MystScriptEntry *scripts, MystResource* invokingResource = NULL);
+	void runOpcode(uint16 op, uint16 var = 0, uint16 argc = 0, uint16 *argv = NULL);
+	const char *getOpcodeDesc(uint16 op);
+	
+	void disableInitOpcodes();
+	void runPersistentOpcodes();
+
+private:
+	MohawkEngine_Myst *_vm;
+	
+	typedef void (MystScriptParser::*OpcodeProcMyst)(uint16 op, uint16 var, uint16 argc, uint16* argv);
+	
+	struct MystOpcode {
+		uint16 op;
+		OpcodeProcMyst proc;
+		const char *desc;
+	};
+
+	const MystOpcode *_opcodes;
+	void setupOpcodes();
+	MystResource *_invokingResource;
+	uint16 _opcodeCount;
+
+	void varUnusedCheck(uint16 op, uint16 var);
+
+	void opcode_200_run();
+	void opcode_200_disable();
+	void opcode_201_run();
+	void opcode_201_disable();
+	void opcode_202_run();
+	void opcode_202_disable();
+	void opcode_203_run();
+	void opcode_203_disable();
+	void opcode_204_run();
+	void opcode_204_disable();
+	void opcode_205_run();
+	void opcode_205_disable();
+	void opcode_206_run();
+	void opcode_206_disable();
+	void opcode_209_run();
+	void opcode_209_disable();
+	void opcode_210_run();
+	void opcode_210_disable();
+	void opcode_211_run();
+	void opcode_211_disable();
+	void opcode_212_run();
+	void opcode_212_disable();
+
+	DECLARE_OPCODE(unknown);
+
+	DECLARE_OPCODE(toggleBoolean);
+	DECLARE_OPCODE(setVar);
+	DECLARE_OPCODE(altDest);
+	DECLARE_OPCODE(takePage);
+	DECLARE_OPCODE(opcode_4);
+	DECLARE_OPCODE(opcode_6);
+	DECLARE_OPCODE(opcode_7);
+	DECLARE_OPCODE(opcode_8);
+	DECLARE_OPCODE(opcode_9);
+	DECLARE_OPCODE(opcode_14);
+	DECLARE_OPCODE(dropPage);
+	DECLARE_OPCODE(opcode_16);
+	DECLARE_OPCODE(opcode_17);
+	DECLARE_OPCODE(opcode_18);
+	DECLARE_OPCODE(enableHotspots);
+	DECLARE_OPCODE(disableHotspots);
+	DECLARE_OPCODE(opcode_21);
+	DECLARE_OPCODE(opcode_22);
+	DECLARE_OPCODE(opcode_23);
+	DECLARE_OPCODE(playSound);
+	DECLARE_OPCODE(opcode_26);
+	DECLARE_OPCODE(playSoundBlocking);
+	DECLARE_OPCODE(opcode_28);
+	DECLARE_OPCODE(opcode_29_33);
+	DECLARE_OPCODE(opcode_30);
+	DECLARE_OPCODE(opcode_31);
+	DECLARE_OPCODE(opcode_32);
+	DECLARE_OPCODE(opcode_34);
+	DECLARE_OPCODE(opcode_35);
+	DECLARE_OPCODE(changeCursor);
+	DECLARE_OPCODE(hideCursor);
+	DECLARE_OPCODE(showCursor);
+	DECLARE_OPCODE(opcode_39);
+	DECLARE_OPCODE(changeStack);
+	DECLARE_OPCODE(opcode_41);
+	DECLARE_OPCODE(opcode_42);
+	DECLARE_OPCODE(opcode_43);
+	DECLARE_OPCODE(opcode_44);
+	DECLARE_OPCODE(opcode_46);
+
+	DECLARE_OPCODE(opcode_100);
+	DECLARE_OPCODE(opcode_101);
+	DECLARE_OPCODE(opcode_102);
+	DECLARE_OPCODE(opcode_103);
+	DECLARE_OPCODE(opcode_104);
+	DECLARE_OPCODE(opcode_105);
+	DECLARE_OPCODE(opcode_106);
+	DECLARE_OPCODE(opcode_107);
+	DECLARE_OPCODE(opcode_108);
+	DECLARE_OPCODE(opcode_109);
+	DECLARE_OPCODE(opcode_110);
+	DECLARE_OPCODE(opcode_111);
+	DECLARE_OPCODE(opcode_112);
+	DECLARE_OPCODE(opcode_113);
+	DECLARE_OPCODE(opcode_114);
+	DECLARE_OPCODE(opcode_115);
+	DECLARE_OPCODE(opcode_116);
+	DECLARE_OPCODE(opcode_117);
+	DECLARE_OPCODE(opcode_118);
+	DECLARE_OPCODE(opcode_119);
+	DECLARE_OPCODE(opcode_120);
+	DECLARE_OPCODE(opcode_121);
+	DECLARE_OPCODE(opcode_122);
+	DECLARE_OPCODE(opcode_123);
+	DECLARE_OPCODE(opcode_124);
+	DECLARE_OPCODE(opcode_125);
+	DECLARE_OPCODE(opcode_126);
+	DECLARE_OPCODE(opcode_127);
+	DECLARE_OPCODE(opcode_128);
+	DECLARE_OPCODE(opcode_129);
+	DECLARE_OPCODE(opcode_130);
+	DECLARE_OPCODE(opcode_131);
+	DECLARE_OPCODE(opcode_132);
+	DECLARE_OPCODE(opcode_133);
+	DECLARE_OPCODE(opcode_147);
+	DECLARE_OPCODE(opcode_164);
+	DECLARE_OPCODE(opcode_169);
+	DECLARE_OPCODE(opcode_181);
+	DECLARE_OPCODE(opcode_182);
+	DECLARE_OPCODE(opcode_183);
+	DECLARE_OPCODE(opcode_184);
+	DECLARE_OPCODE(opcode_185);
+	DECLARE_OPCODE(opcode_196);
+	DECLARE_OPCODE(opcode_197);
+	DECLARE_OPCODE(opcode_198);
+	DECLARE_OPCODE(opcode_199);
+
+    DECLARE_OPCODE(opcode_200);
+    DECLARE_OPCODE(opcode_201);
+    DECLARE_OPCODE(opcode_202);
+    DECLARE_OPCODE(opcode_203);
+    DECLARE_OPCODE(opcode_204);
+    DECLARE_OPCODE(opcode_205);
+    DECLARE_OPCODE(opcode_206);
+    DECLARE_OPCODE(opcode_207);
+    DECLARE_OPCODE(opcode_208);
+    DECLARE_OPCODE(opcode_209);
+    DECLARE_OPCODE(opcode_210);
+    DECLARE_OPCODE(opcode_211);
+    DECLARE_OPCODE(opcode_212);
+    DECLARE_OPCODE(opcode_213);
+    DECLARE_OPCODE(opcode_214);
+    DECLARE_OPCODE(opcode_215);
+    DECLARE_OPCODE(opcode_216);
+    DECLARE_OPCODE(opcode_217);
+    DECLARE_OPCODE(opcode_218);
+    DECLARE_OPCODE(opcode_219);
+    DECLARE_OPCODE(opcode_220);
+    DECLARE_OPCODE(opcode_221);
+    DECLARE_OPCODE(opcode_222);
+    DECLARE_OPCODE(opcode_298);
+    DECLARE_OPCODE(opcode_299);
+
+	DECLARE_OPCODE(opcode_300);
+	DECLARE_OPCODE(opcode_301);
+	DECLARE_OPCODE(opcode_302);
+	DECLARE_OPCODE(opcode_303);
+	DECLARE_OPCODE(opcode_304);
+	DECLARE_OPCODE(opcode_305);
+	DECLARE_OPCODE(opcode_306);
+	DECLARE_OPCODE(opcode_307);
+	DECLARE_OPCODE(opcode_308);
+	DECLARE_OPCODE(opcode_309);
+	DECLARE_OPCODE(opcode_312);
+
+	DECLARE_OPCODE(NOP);
+};
+
+}
+
+#undef DECLARE_OPCODE
+
+#endif
diff --git a/engines/mohawk/myst_vars.cpp b/engines/mohawk/myst_vars.cpp
new file mode 100644
index 0000000000..46951a4388
--- /dev/null
+++ b/engines/mohawk/myst_vars.cpp
@@ -0,0 +1,578 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "mohawk/myst.h"
+#include "mohawk/myst_vars.h"
+
+namespace Mohawk {
+
+// The Myst variable system is complex, and the structure is fairly
+// unknown. The idea of this class is to abstract the variable references
+// from the storage structure until the structure is clear enough that
+// the complexity of this abstraction can be removed.
+
+// The exact organization of local/global, persistent/non-persistent
+// age-specific mapping etc. is currently unknown.
+
+MystVarEntry introVars[] = {
+	{   0, 7, "Age To Link To" } // 0 to 7
+		// 0 = Selenitic
+		// 1 = Stoneship
+		// 2 = Myst (Library Ceiling)
+		// 3 = Mechanical
+		// 4 = Channelwood
+		// 5 = Myst (Start of Movie - Over Sea)
+		// 6 = D'ni
+		// 7 = Myst (End of Movie - On Dock)
+};
+
+MystVarEntry seleniticVars[] = {
+	{   0, 0, "Sound Pickup At Windy Tunnel" }, // 0 to 1 // TODO: Multiple Uses of Var 0?
+	{   1, 0, "Sound Pickup At Volcanic Crack" }, // 0 to 1 
+	{   2, 0, "Sound Pickup At Clock" }, // 0 to 1 
+	{   3, 0, "Sound Pickup At Water Pool" }, // 0 to 1 
+	{   4, 0, "Sound Pickup At Crystal Rocks" }, // 0 to 1 
+	{   5, 0, "Sound Receiver Doors" }, // 0 to 1 
+	{   6, 0, "Windy Tunnel Lights" }, // 0 to 1 
+	{   7, 0, "Maze Runner Porthole View" }, // 0 to 3
+	{   8, 0, "Sound Receiver Screen (Control Variable?)" },
+	{   9, 0, "Sound Receiver Water Pool Button Selected" },
+	{  10, 0, "Sound Receiver Volcanic Crack Button Selected" },
+	{  11, 0, "Sound Receiver Clock Button Selected" },
+	{  12, 0, "Sound Receiver Crystal Rocks Button Selected" },
+	{  13, 0, "Sound Receiver Windy Tunnel Button Selected" },
+	{  14, 0, "Sound Receiver LED Digit #0 (Left)" },
+	{  15, 0, "Sound Receiver LED Digit #1" },
+	{  16, 0, "Sound Receiver LED Digit #2" },
+	{  17, 0, "Sound Receiver LED Digit #3 (Right)" },
+	{  18, 0, "Sound Receiver Green Arrow - Right" },
+	{  19, 0, "Sound Receiver Green Arrow - Left" },
+	{  20, 0, "Sound Lock Slider #1 (Left) (Position?)" },
+	{  21, 0, "Sound Lock Slider #2 (Position?)" },
+	{  22, 0, "Sound Lock Slider #3 (Position?)" },
+	{  23, 0, "Sound Lock Slider #4 (Position?)" },
+	{  24, 0, "Sound Lock Slider #5 (Right) (Position?)" },
+	{  25, 0, "Maze Runner Compass Heading" }, // 0 to 8
+	{  26, 0, "Sound Receiver Sum Button Selected" },
+	{  27, 0, "Maze Runner Red Warning Light" },
+	{  28, 0, "Sound Lock Button State" },
+	{  29, 0, "Maze Runner Door Button State" },
+	{  30, 0, "Maze Runner Door State" },
+	{  31, 0, "Maze Runner Forward Button Lit" }, // 0 to 2
+	{  32, 0, "Maze Runner Left & Right Button Lit" }, // 0 to 2
+	{  33, 0, "Maze Runner Backtrack Button Lit" }, // 0 to 2
+	{ 102, 1, "Red Page in Age" }, // 0 to 1
+	{ 103, 1, "Blue Page in Age" } // 0 to 1
+};
+
+MystVarEntry stoneshipVars[] = {
+	{   0, 0, "Water Pump Button #3 (Right) / Lighthouse Water Drained" }, // 0 to 2 = Button Up & Unlit, Button Down & Lit, Button Up & Lit
+	{   1, 0, "Water Pump Button #2 / Tunnels To Brothers Rooms Drained" }, // 0 to 2 = Button Up & Unlit, Button Down & Lit, Button Up & Lit
+	{   2, 0, "Water Pump Button #1 (Left) / Ship Cabin Water Drained" }, // 0 to 2 = Button Up & Unlit, Button Down & Lit, Button Up & Lit
+	{   3, 0, "Lighthouse (Water or Chest Floating?)" }, // 0 to 1, Used by Far View
+	{   4, 0, "Lighthouse Water/Chest State" }, // 0 to 2 = Water, No Water, Water & Chest Floating
+	{   5, 2, "Lighthouse Trapdoor State" }, // 0 to 2 = Closed & Unlocked, Open, Closed & Locked
+	{   6, 0, "Lighthouse Chest Valve Position" }, // 0 to 1
+	{   7, 0, "Lighthouse Chest Unlocked" }, // 0 to 1
+	{   8, 0, "Lighthouse Chest Key Position?" }, // 0 to 2, 2 = Bottom of Lighthouse
+// Var 9 Unused
+	{  10, 1, "Lighthouse Chest Full Of Water" }, // 0 to 1
+	{  11, 3, "Lighthouse Key State" }, // 0 to 3 = Closed?, Open & No Key, Open & No Key, Open & Key
+	{  12, 0, "Lighthouse Trapdoor - Holding Key" }, // 0 to 1
+	{  13, 0, "State of Water in Tunnels to Brothers' Rooms" }, // 0 to 2 = Dark & Water, Dark & Drained, Lit & Water
+	{  14, 0, "Tunnels to Brothers' Rooms Lit" }, // 0 to 1
+	{  15, 0, "Side Door in Tunnels To Brother's Rooms Open" }, // 0 to 1
+	{  16, 0, "Underwater Light Lit" }, // 0 to 1
+	{  17, 0, "Sirrus' Room Drawer with Drugs Open" }, // 0 to 1
+	{  18, 0, "Brother Room Door Open" }, // 0 to 1, Used for Door Slam
+	{  19, 0, "Brother Room Door State" }, // 0 to 2 = Closed, Open & Dark, Open & Lit
+	{  20, 0, "Ship Cabin Myst Book Present" }, // 0 to 1
+	{  21, 0, "Brothers Rooms' Chest Of Drawers Drawer State" }, // 0 to 6 (Card 2197) or 0 to 7 (Card 2004)
+	{  22, 0, "Sirrus' Chest of Drawers Drawer #1 (Top) Open" }, // 0 to 1
+	{  23, 0, "Sirrus' Chest of Drawers Drawer #2 Open" }, // 0 to 1
+	{  24, 0, "Sirrus' Chest of Drawers Drawer #3 Open" }, // 0 to 1
+// Var 25 Unused - Replaced by Var 35.
+	{  26, 0, "Sirrus' Chest of Drawers Left Small Drawer Open" }, // 0 to 1
+	{  27, 0, "Sirrus' Chest of Drawers Right Small Drawer Open" }, // 0 to 1
+	{  28, 0, "Telescope View Position" }, // Range Unknown.. 0 to 360?
+	{  29, 0, "Achenar's Room Rose/Skull Hologram Button Lit" }, // 0 to 1
+	{  30, 2, "Light State in Tunnel to Compass Rose Room" }, // 0 to 2 = Lit & Underwater Light Lit, Lit, Dark
+	{  31, 0, "Lighthouse Lamp Room Battery Pack Indicator Light" }, // 0 to 1
+	{  32, 0, "Lighthouse Lamp Room Battery Pack Meter Level" }, // Range Unknown.. // Must be 1 to vertical size of image...
+	{  33, 0, "State of Side Door in Tunnels to Compass Rose Room (Power?)" }, // 0 to 2 = Closed (No Power), Closed (Power), Open
+	{  34, 1, "Achenar's Room Drawer with Torn Note Closed" }, // 0 to 1
+	{  35, 2, "Sirrus' Room Drawer #4 (Bottom) Open and Red Page State" }, // 0 to 2 = Open, Open with Page, Closed
+	{  36, 0, "Ship Cabin Door State" }, // 0 to 2 = Closed, Open & Dark, Open & Lit
+	{ 102, 1, "Red Page in Age" }, // 0 to 1
+	{ 103, 1, "Blue Page in Age" }, // 0 to 1
+	{ 105, 0, "Ship Cabin Door State" }
+};
+
+MystVarEntry mystVars[] = {
+	{   0, 1, "Myst Library Bookcase Closed / Library Exit Open" }, // 0 to 1 // TODO: Multiple Uses of Var 0?
+	{   1, 0, "Myst Library Bookcase Open / Library Exit Blocked" }, // 0 to 1
+	{   2, 0, "Marker Switch Near Cabin" }, // 0 to 1
+	{   3, 0, "Marker Switch Near Clock Tower" }, // 0 to 1
+	{   4, 0, "Marker Switch on Dock" }, // 0 to 1
+	{   5, 0, "Marker Switch Near Ship Pool" }, // 0 to 1
+	{   6, 0, "Marker Switch Near Cogs" }, // 0 to 1
+	{   7, 0, "Marker Switch Near Generator Room" }, // 0 to 1
+	{   8, 0, "Marker Switch Near Stellar Observatory" }, // 0 to 1
+	{   9, 0, "Marker Switch Near Rocket Ship" }, // 0 to 1
+	{  10, 0, "Ship Floating State" }, // 0 to 1
+	{  11, 0, "Cabin Door Open State" },
+	{  12, 0, "Clock Tower Gear Bridge" }, // 0 to 1
+	{  13, 0, "Tower Elevator Sound Control" }, // 0 to 1
+	{  14, 0, "Tower Solution (Key) Plaque" }, // 0 to 4
+		// 0 = None
+		// 1 = 59 V
+		// 2 = 2:40 2-2-1
+		// 3 = October  11, 1984 10:04 AM
+		//     January  17, 1207  5:46 AM
+		//     November 23, 9791  6:57 PM
+		// 4 = 7, 2, 4
+	{  15, 0, "Tower Window (Book) View" }, // 0 to 6
+		// 0 = Wall
+		// 1 = Rocketship
+		// 2 = Cogs Closed
+		// 3 = Ship Sunk
+		// 4 = Channelwood Tree
+		// 5 = Ship Floating
+		// 6 = Cogs Open
+	{  16, 0, "Tower Window (Book) View From Ladder Top" }, // 0 to 2
+		// 0 = Wall
+		// 1 = Sky
+		// 2 = Sky with Channelwood Tree
+	{  17, 0, "Fireplace Grid Row #1 (Top)" }, // Bitfield 0x00 to 0xFF
+	{  18, 0, "Fireplace Grid Row #2" }, // Bitfield 0x00 to 0xFF
+	{  19, 0, "Fireplace Grid Row #3" }, // Bitfield 0x00 to 0xFF
+	{  20, 0, "Fireplace Grid Row #4" }, // Bitfield 0x00 to 0xFF
+	{  21, 0, "Fireplace Grid Row #5" }, // Bitfield 0x00 to 0xFF
+	{  22, 0, "Fireplace Grid Row #6 (Bottom)" }, // Bitfield 0x00 to 0xFF
+	{  23, 0, "Fireplace Pattern Correct" }, // 0 to 1
+	{  24, 1, "Fireplace Blue Page Present" }, // 0 to 1
+	{  25, 1, "Fireplace Red Page Present" }, // 0 to 1
+	{  26, 0, "Ship Puzzle Box Image (Cross)" }, // 0 to 2
+	{  27, 0, "Ship Puzzle Box Image (Leaf)" }, // 0 to 2
+	{  28, 0, "Ship Puzzle Box Image (Arrow)" }, // 0 to 2
+	{  29, 0, "Ship Puzzle Box Image (Eye)" }, // 0 to 2
+	{  30, 0, "Ship Puzzle Box Image (Snake)" }, // 0 to 2
+	{  31, 0, "Ship Puzzle Box Image (Spider)" }, // 0 to 2
+	{  32, 0, "Ship Puzzle Box Image (Anchor)" }, // 0 to 2
+	{  33, 0, "Ship Puzzle Box Image (Ostrich)" }, // 0 to 2
+	{  34, 2, "Dock Forechamber Imager State" }, // 0 to 2 = Off, Mountain, Water
+	{  35, 5, "Dock Forechamber Imager Control Left Digit" }, // 0 to 9
+	{  36, 6, "Dock Forechamber Imager Control Right Digit" }, // 0 to 9
+	{  37, 0, "Clock Tower Control Wheels Position" }, // 0 to 8
+// Var 38 Unused
+// 39 = TODO: ?
+	{  40, 0, "Cog Close/Open State" },
+	{  41, 0, "Dock Marker Switch Vault State" }, // 0 to 2 = Closed, Open & Page Taken, Open & Page Present
+// Var 42 Unused
+	{  43, 0, "Clock Tower Time" }, // 0 to 143
+	{  44, 0, "Rocket Ship Power State" }, // 0 to 2 = None, Insufficient, Correct
+	{  45, 1, "Dock Forechamber Imager Water Effect Enabled" }, // 0 to 1
+	{  46, 0, "Number Of Pages in Red Book" }, // 0 to 6 = 0-5, Extra
+	{  47, 0, "Number Of Pages in Blue Book" }, // 0 to 6 = 0-5, Extra
+	{  48, 0, "Marker Switch on Dock - Duplicate of Var #4?" }, // 0 to 2
+	{  49, 0, "Generator Running" }, // Boolean used for Sound..
+// 50 = TODO: ?
+	{  51, 2, "Forechamber Imager Movie Control Variable" }, // 0 to 4 = Blank, No Function? / Mountain?, Water, Atrus, Marker Switch
+	{  52, 0, "Generator Switch #1" },
+	{  53, 0, "Generator Switch #2" },
+	{  54, 0, "Generator Switch #3" },
+	{  55, 0, "Generator Switch #4" },
+	{  56, 0, "Generator Switch #5" },
+	{  57, 0, "Generator Switch #6" },
+	{  58, 0, "Generator Switch #7" },
+	{  59, 0, "Generator Switch #8" },
+	{  60, 0, "Generator Switch #9" },
+	{  61, 0, "Generator Switch #10" },
+	{  62, 0, "Generator Power Dial Left LED Digit" }, // 0 to 9
+	{  63, 0, "Generator Power Dial Right LED Digit" }, // 0 to 9
+	{  64, 0, "Generator Power To Spaceship Dial Left LED Digit" }, // 0 to 9
+	{  65, 0, "Generator Power To Spaceship Dial Right LED Digit" }, // 0 to 9
+	{  66, 0, "Generator Room Lights On" }, // Boolean
+	{  67, 9, "Cabin Safe Lock Number #1 - Left" },
+	{  68, 9, "Cabin Safe Lock Number #2" },
+	{  69, 9, "Cabin Safe Lock Number #3 - Right" },
+	{  70, 0, "Cabin Safe Matchbox State" }, // 0 to 2
+	{  71, 1, "Stellar Observatory Lights" },
+	{  72, 0, "Channelwood Tree Position" }, // 0 to 12, 4 for Alcove
+	{  73, 9, "Stellar Observatory Telescope Control - Month" }, // 0 to 11, Not in order...
+		// 0 = OCT, 1 = NOV, 2 = DEC, 3 = JUL,  4 = AUG,  5 = SEP
+		// 6 = APR, 7 = MAY, 8 = JUN, 9 = JAN, 10 = FEB, 11 = MAR
+	{  74, 10, "Stellar Observatory Telescope Control - Day Digit #1 (Left)" }, // 0 to 10 = 0 to 9, Blank
+	{  75, 1, "Stellar Observatory Telescope Control - Day Digit #2 (Right)" }, // 0 to 10 = 0 to 9, Blank
+	{  76, 10, "Stellar Observatory Telescope Control - Year Digit #1 (Left)" }, // 0 to 10 = 0 to 9, Blank
+	{  77, 10, "Stellar Observatory Telescope Control - Year Digit #2" }, // 0 to 10 = 0 to 9, Blank
+	{  78, 10, "Stellar Observatory Telescope Control - Year Digit #3" }, // 0 to 10 = 0 to 9, Blank
+	{  79, 0, "Stellar Observatory Telescope Control - Year Digit #4 (Right)" }, // 0 to 10 = 0 to 9, Blank
+	{  80, 1, "Stellar Observatory Telescope Control - Hour Digit #1 (Left)" }, // 0 to 10 = 0 to 9, Blank
+	{  81, 2, "Stellar Observatory Telescope Control - Hour Digit #2 (Right)" }, // 0 to 10 = 0 to 9, Blank
+	{  82, 0, "Stellar Observatory Telescope Control - Minute Digit #1 (Left)" }, // 0 to 10 = 0 to 9, Blank
+	{  83, 0, "Stellar Observatory Telescope Control - Minute Digit #2 (Right)" }, // 0 to 10 = 0 to 9, Blank
+// 84 to 87 = TODO: ?
+	{  88, 0, "Stellar Observatory Telescope Control - AM/PM Indicator" }, // 0 = AM, 1 = PM
+	{  89, 0, "Stellar Observatory Telescope Control - Slider #1 (Left)" }, // 0 to 2 = Not Present, Dark, Lit
+	{  90, 0, "Stellar Observatory Telescope Control - Slider #2" }, // 0 to 2 = Not Present, Dark, Lit
+	{  91, 0, "Stellar Observatory Telescope Control - Slider #3" }, // 0 to 2 = Not Present, Dark, Lit
+	{  92, 0, "Stellar Observatory Telescope Control - Slider #4 (Right)" }, // 0 to 2 = Not Present, Dark, Lit
+	{  93, 0, "Breaker nearest Generator Room Blown" },
+	{  94, 0, "Breaker nearest Rocket Ship Blown" },
+// 95 = TODO: ?
+	{  96, 0, "Generator Power Dial Needle Position" }, // 0 to 24
+	{  97, 0, "Generator Power To Spaceship Dial Needle Position" }, // 0 to 24
+	{  98, 0, "Cabin Boiler Pilot Light Lit" },
+	{  99, 0, "Cabin Boiler Gas Valve Position" }, // 0 to 5
+	{ 100, 0, "Red Book Page State" }, // Bitfield
+	{ 101, 0, "Blue Book Page State" }, // Bitfield
+	{ 102, 1, "Red Page in Age" }, // 0 to 1
+	{ 103, 1, "Blue Page in Age" }, // 0 to 1
+// 104 = TODO: ?
+	{ 105, 0, "Clock Tower Door / Ship Box Temp Value" },
+	{ 106, 0, "Red / Blue Book State" }, // 0 to 4, 0-3 = Books Present 4 = Books Burnt
+	{ 300, 0, "Rocket Ship Music Puzzle Slider State" },  // 0 to 2 = Not Present, Dark, Lit
+	{ 301, 0, "Rocket Ship Piano Key Depressed" }, // 0 to 1
+	{ 302, 0, "Green Book Opened Before Flag" }, // 0 to 1
+	{ 303, 1, "Myst Library Bookcase Closed / Library Exit Open" },
+	{ 304, 0, "Myst Library Image Present on Tower Rotation Map" }, // 0 to 1
+	{ 305, 0, "Cabin Boiler Lit" },
+	{ 306, 0, "Cabin Boiler Steam Sound Control" }, // 0 to 27
+	{ 307, 0, "Cabin Boiler Needle Position i.e. Fully Pressurised" }, // 0 to 1
+	{ 308, 0, "Cabin Safe Handle Position / Matchbox Temp Value" },
+	{ 309, 0, "Red/Blue/Green Book Open" }, // 0 to 1
+	{ 310, 0, "Dock Forechamber Imager Control Temp Value?" }
+};
+
+MystVarEntry mechVars[] = {
+	{   0, 0, "Achenar's Room Secret Panel State" }, // TODO: Multiple Uses of Var 0?
+	{   1, 0, "Sirrus's Room Secret Panel State" },
+	{   2, 0, "Achenar's Secret Room Crate Lid Open and Blue Page Present" }, // 0 to 4
+		// 0 = Lid Closed, Blue Page Present
+		// 1 = Lid Closed, Blue Page Not Present
+		// 2 = Lid Open, Blue Page Not Present
+		// 3 = Lid Open, Blue Page Present
+	{   3, 0, "Achenar's Secret Room Crate Lid Open" }, // 0 to 1
+	{   4, 0, "Myst Book Staircase State" },
+	{   5, 0, "Fortress Telescope View" },
+	{   6, 0, "Large Cog Visible Through Distant Fortress Doorway" }, // 0 to 1
+	{   7, 0, "Fortress Elevator Door Rotated to Open" }, // 0 to 1
+// Var 8 Not Used
+// Var 9 Not Used
+	{  10, 0, "Fortress Staircase State" }, // 0 to 1
+	{  11, 0, "Fortress Elevator Rotation Control - Position Indicator" }, // 0 to 9, 4 = Red Open Position
+	{  12, 0, "Fortress Elevator Rotation Control - Top Cog Position" }, // 0 to 5
+	{  13, 0, "Fortress Elevator Vertical Position - View" }, // 0 to 2, Used for View Logic on change from Card 6150
+	{  14, 0, "Fortress Elevator Vertical Position - Button" }, // 0 to 2, Used for Button Logic on Card 6120
+	{  15, 0, "Code Lock State" }, // 0 to 2
+	{  16, 0, "Code Lock Shape #1 (Left)" },
+	{  17, 0, "Code Lock Shape #2" },
+	{  18, 0, "Code Lock Shape #3" },
+	{  19, 0, "Code Lock Shape #4 (Right)" },
+	{  20, 0, "Red Dodecahedron Lit" },
+	{  21, 0, "Green Dodecahedron Lit" },
+	{  22, 0, "Yellow Tetrahedron Lit" },
+	{  23, 0, "In Elevator" }, // 0 to 1
+	{ 102, 1, "Red Page in Age" }, // 0 to 1
+	{ 103, 1, "Blue Page in Age" } // 0 to 1
+};
+
+MystVarEntry channelwoodVars[] = {
+	{   0, 0, "Multiple Uses..." }, // TODO: Multiple Uses of Var 0?
+	{   1, 0, "Water Pump Bridge State" }, // 0 to 1
+	{   2, 0, "Lower Walkway to Upper Walkway Elevator State" }, // 0 to 1
+	{   3, 0, "Water Flowing (R) to Pump for Upper Walkway to Temple Elevator" }, // 0 to 1
+	{   4, 0, "Water Flowing (L, R, R, L, Pipe Extended) to Pump for Book Room Elevator" }, // 0 to 1
+	{   5, 0, "Lower Walkway to Upper Walkway Spiral Stair Lower Door Open" }, // 0 to 1
+	{   6, 0, "Pipe Bridge Extended" }, // 0 to 1
+	{   7, 0, "Bridge Pump Running" }, // 0 to 1
+	{   8, 0, "Water Tank Valve State" },  // 0 to 1 
+	{   9, 0, "First Water Valve State" },  // 0 to 1 
+	{  10, 0, "Second (L) Water Valve State" },  // 0 to 1
+	{  11, 0, "Third (L, R) Water Valve State" },  // 0 to 1
+	{  12, 0, "Fourth (L, R, R) Water Valve State" }, // 0 to 1
+	{  13, 0, "Fourth (L, R, L) Water Valve State" }, // 0 to 1
+	{  14, 0, "Third (L, L) Water Valve State" },  // 0 to 1
+	{  15, 0, "Water Flowing (L, R, R, R) to Pump for Lower Walkway to Upper Walkway Elevator" }, // 0 to 1
+	{  16, 0, "Lower Walkway to Upper Walkway Spiral Stair Upper Door Open" }, // 0 to 1
+	{  17, 0, "Achenar's Holoprojector Selection" }, // 0 to 3
+	{  18, 0, "Drawer in Sirrus' Room with Wine Bottles and Torn Note Open" }, // 0 to 1
+	{  19, 0, "Water Flowing to First Water Valve" }, // 0 to 1
+	{  20, 0, "Water Flowing to Second (L) Water Valve" }, // 0 to 1
+	{  21, 0, "Water Flowing to Third (L, R) Water Valve" }, // 0 to 1
+	{  22, 0, "Water Flowing to Fourth (L, R, R) Water Valve" }, // 0 to 1
+	{  23, 0, "Water Flowing to Fourth (L, R, L) Water Valve" }, // 0 to 1
+	{  24, 0, "Water Flowing to Third (L, L) Water Valve" }, // 0 to 1
+	{  25, 0, "Water Flowing to Pipe Bridge (L, R, R, L)" }, // 0 to 1
+	{  26, 0, "Water Flowing to Pipe At Entry Point (L, R, L, R)" }, // 0 to 1
+	{  27, 0, "Water Flowing to Join and Pump Bridge (L, R, L, L)" }, // 0 to 1
+	{  28, 0, "Water Flowing to Join and Pump Bridge (L, L, R)" }, // 0 to 1
+	{  29, 0, "Water Flowing to Pipe In Water (L, L, L)" }, // 0 to 1
+	{  30, 0, "Lower Walkway to Upper Walkway Elevator Door Open" }, // 0 to 1
+	{  31, 0, "Water Flowing to Join (L, L, R)" }, // 0 to 2 = Stop Sound, Background, Background with Water Flow
+	{  32, 0, "Water Flowing (L, R, R, L, Pipe) State" }, // 0 to 2 = Stop Sound, Background, Background with Water Flow
+	{  33, 0, "Lower Walkway to Upper Walkway Spiral Stair Upper Door State" }, // 0 to 2 = Closed, Open, Open but slams behind you.
+	{ 102, 1, "Red Page in Age" }, // 0 to 1
+	{ 103, 1, "Blue Page in Age" }, // 0 to 1
+	{ 105, 0, "Upper Walkway to Temple Elevator Door Open / Temple Iron Door Open" } // 0 to 1, used for slam sound
+};
+
+MystVarEntry dniVars[] = {
+	{   0, 0, "Atrus Gone" }, // 0 to 1 // TODO: Multiple Uses of Var 0?
+	{   1, 0, "Myst Book State" }, // 0 to 2 = Book Inactive, Book Unlinkable, Book Linkable
+	{   2, 0, "Sound Control" }, // 0 to 2 = Win Tune, Lose Tune, Stop Sound
+	{ 106, 0, "Atrus State Control" } // 0 to 4 = Atrus Writing, Atrus Holding Out Hand, Atrus Gone, Atrus #2, Atrus #2
+};
+
+MystVarEntry creditsVars[] = {
+	{   0, 0, "Image Control" }, // 0 to 6
+	{   1, 1, "Sound Control" } // 0 to 1 = Win Tune, Lose Tune
+};
+
+MystVar::MystVar(MohawkEngine_Myst *vm) {
+	_vm = vm;
+}
+
+MystVar::~MystVar() {
+}
+
+// Only for use by Save/Load, all other code should use getVar()
+uint16 MystVar::saveGetVar(uint16 stack, uint16 v) {
+	uint16 value = 0;
+	MystVarEntry unknownVar = { v, 0, "Unknown" };
+	const char *desc = NULL;
+	uint16 i;
+	
+	switch (stack) {
+		case kIntroStack:
+			for (i = 0; i < ARRAYSIZE(introVars); i++) {
+				if (introVars[i].refNum == v) {
+					value = introVars[i].storage;
+					desc = introVars[i].description;
+					break;
+				}
+			}
+			break;
+		case kSeleniticStack:
+			for (i = 0; i < ARRAYSIZE(seleniticVars); i++) {
+				if (seleniticVars[i].refNum == v) {
+					value = seleniticVars[i].storage;
+					desc = seleniticVars[i].description;
+					break;
+				}
+			}
+			break;
+		case kStoneshipStack:
+			for (i = 0; i < ARRAYSIZE(stoneshipVars); i++) {
+				if (stoneshipVars[i].refNum == v) {
+					value = stoneshipVars[i].storage;
+					desc = stoneshipVars[i].description;
+					break;
+				}
+			}
+			break;
+		case kDemoPreviewStack:
+		case kMystStack:
+			for (i = 0; i < ARRAYSIZE(mystVars); i++) {
+				if (mystVars[i].refNum == v) {
+					value = mystVars[i].storage;
+					desc = mystVars[i].description;
+					break;
+				}
+			}
+			break;
+		case kMechanicalStack:
+			for (i = 0; i < ARRAYSIZE(mechVars); i++) {
+				if (mechVars[i].refNum == v) {
+					value = mechVars[i].storage;
+					desc = mechVars[i].description;
+					break;
+				}
+			}
+			break;
+		case kChannelwoodStack:
+			for (i = 0; i < ARRAYSIZE(channelwoodVars); i++) {
+				if (channelwoodVars[i].refNum == v) {
+					value = channelwoodVars[i].storage;
+					desc = channelwoodVars[i].description;
+					break;
+				}
+			}
+			break;
+		case kDniStack:
+			for (i = 0; i < ARRAYSIZE(dniVars); i++) {
+				if (dniVars[i].refNum == v) {
+					value = dniVars[i].storage;
+					desc = dniVars[i].description;
+					break;
+				}
+			}
+			break;
+		case kCreditsStack:
+			for (i = 0; i < ARRAYSIZE(creditsVars); i++) {
+				if (creditsVars[i].refNum == v) {
+					value = creditsVars[i].storage;
+					desc = creditsVars[i].description;
+					break;
+				}
+			}
+			break;
+		default:
+			break;
+	}
+	
+	if (desc == NULL) {
+		for (i = 0; i < _unknown.size(); i++) {
+			if (_unknown[i].refNum == v) {
+				value = _unknown[i].storage;
+				desc = _unknown[i].description;
+				break;
+			}
+		}
+
+		if (desc == NULL) {
+			warning("MystVar::getVar(%d): Unknown variable reference", v);			
+			_unknown.push_back(unknownVar);
+			desc = _unknown.back().description;
+		}
+	}
+
+	debugC(kDebugVariable, "MystVar::getVar(%d = %s): %d", v, desc, value);
+	return value;
+}
+
+// Only for use by Save/Load, all other code should use setVar()
+void MystVar::loadSetVar(uint16 stack, uint16 v, uint16 value) {
+	const char *desc = NULL;
+	MystVarEntry unknownVar = { v, value, "Unknown" };
+	uint16 i;
+	
+	switch (stack) {
+		case kIntroStack:
+			for (i = 0; i < ARRAYSIZE(introVars); i++) {
+				if (introVars[i].refNum == v) {
+					introVars[i].storage = value;
+					desc = introVars[i].description;
+					break;
+				}
+			}
+			break;
+		case kSeleniticStack:
+			for (i = 0; i < ARRAYSIZE(seleniticVars); i++) {
+				if (seleniticVars[i].refNum == v) {
+					seleniticVars[i].storage = value;
+					desc = seleniticVars[i].description;
+					break;
+				}
+			}
+			break;
+		case kStoneshipStack:
+			for (i = 0; i < ARRAYSIZE(stoneshipVars); i++) {
+				if (stoneshipVars[i].refNum == v) {
+					stoneshipVars[i].storage = value;
+					desc = stoneshipVars[i].description;
+					break;
+				}
+			}
+			break;
+		case kDemoPreviewStack:
+		case kMystStack:
+			for (i = 0; i < ARRAYSIZE(mystVars); i++) {
+				if (mystVars[i].refNum == v) {
+					mystVars[i].storage = value;
+					desc = mystVars[i].description;
+					break;
+				}
+			}
+			break;
+		case kMechanicalStack:
+			for (i = 0; i < ARRAYSIZE(mechVars); i++) {
+				if (mechVars[i].refNum == v) {
+					mechVars[i].storage = value;
+					desc = mechVars[i].description;
+					break;
+				}
+			}
+			break;
+		case kChannelwoodStack:
+			for (i = 0; i < ARRAYSIZE(channelwoodVars); i++) {
+				if (channelwoodVars[i].refNum == v) {
+					channelwoodVars[i].storage = value;
+					desc = channelwoodVars[i].description;
+					break;
+				}
+			}
+			break;
+		case kDniStack:
+			for (i = 0; i < ARRAYSIZE(dniVars); i++) {
+				if (dniVars[i].refNum == v) {
+					dniVars[i].storage = value;
+					desc = dniVars[i].description;
+					break;
+				}
+			}
+			break;
+		case kCreditsStack:
+			for (i = 0; i < ARRAYSIZE(creditsVars); i++) {
+				if (creditsVars[i].refNum == v) {
+					creditsVars[i].storage = value;
+					desc = creditsVars[i].description;
+					break;
+				}
+			}
+			break;
+		default:
+			break;
+	}
+
+	if (desc == NULL) {
+		for (i = 0; i < _unknown.size(); i++) {
+			if (_unknown[i].refNum == v) {
+				_unknown[i].storage = value;
+				desc = _unknown[i].description;
+				break;
+			}
+		}
+
+		if (desc == NULL) {
+			warning("MystVar::setVar(%d): Unknown variable reference", v);
+			_unknown.push_back(unknownVar);
+			desc = _unknown.back().description;
+		}
+	}
+
+	debugC(kDebugVariable, "MystVar::setVar(%d = %s): %d", v, desc, value);
+}
+
+uint16 MystVar::getVar(uint16 v) {
+	return this->saveGetVar(_vm->getCurStack(), v);
+}
+
+void MystVar::setVar(uint16 v, uint16 value) {
+	this->loadSetVar(_vm->getCurStack(), v, value);
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/myst_vars.h b/engines/mohawk/myst_vars.h
new file mode 100644
index 0000000000..065d8df2cb
--- /dev/null
+++ b/engines/mohawk/myst_vars.h
@@ -0,0 +1,60 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "mohawk/myst.h"
+
+#ifndef MYST_VARS_H
+#define MYST_VARS_H
+
+namespace Mohawk {
+
+struct MystVarEntry {
+	uint16 refNum;
+	uint16 storage; // Used for Initial Value setting
+	const char *description;
+};
+
+class MystVar {
+public:
+	MystVar(MohawkEngine_Myst *vm);
+	~MystVar();
+
+	// Only for use by Save/Load
+	// All other code should use getVar() / setVar()
+	void loadSetVar(uint16 stack, uint16 v, uint16 value);
+	uint16 saveGetVar(uint16 stack, uint16 v);
+
+	uint16 getVar(uint16 v);
+	void setVar(uint16 v, uint16 value);
+
+private:
+	MohawkEngine_Myst *_vm;
+
+	Common::Array<MystVarEntry> _unknown;
+};
+
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/riven.cpp b/engines/mohawk/riven.cpp
new file mode 100644
index 0000000000..e2f581d75d
--- /dev/null
+++ b/engines/mohawk/riven.cpp
@@ -0,0 +1,586 @@
+/* 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$
+ * $Id$
+ *
+ */
+ 
+#include "common/config-manager.h"
+#include "common/events.h"
+#include "common/keyboard.h" 
+
+#include "mohawk/graphics.h"
+#include "mohawk/riven.h"
+#include "mohawk/riven_external.h"
+#include "mohawk/riven_saveload.h"
+
+namespace Mohawk {
+
+MohawkEngine_Riven::MohawkEngine_Riven(OSystem *syst, const MohawkGameDescription *gamedesc) : MohawkEngine(syst, gamedesc) {
+	_showHotspots = false;
+	_cardData.hasData = false;
+	_gameOver = false;
+	_activatedSLST = false;
+	_extrasFile = NULL;
+
+	// Attempt to let game run from the CD's
+	// NOTE: assets2 contains higher quality audio than assets1
+	SearchMan.addSubDirectoryMatching(_gameDataDir, "all");
+	SearchMan.addSubDirectoryMatching(_gameDataDir, "data");
+	SearchMan.addSubDirectoryMatching(_gameDataDir, "exe");
+	SearchMan.addSubDirectoryMatching(_gameDataDir, "assets2");
+}
+
+MohawkEngine_Riven::~MohawkEngine_Riven() {
+	delete _gfx;
+	delete _console;
+	delete _externalScriptHandler;
+	delete _extrasFile;
+	delete _saveLoad;
+	delete[] _vars;
+	delete _loadDialog;
+	delete _optionsDialog;
+	_cardData.scripts.clear();
+}
+
+Common::Error MohawkEngine_Riven::run() {
+	MohawkEngine::run();
+
+	_gfx = new RivenGraphics(this);
+	_console = new RivenConsole(this);
+	_saveLoad = new RivenSaveLoad(this, _saveFileMan);
+	_externalScriptHandler = new RivenExternal(this);
+	_loadDialog = new GUI::SaveLoadChooser("Load Game:", "Load");
+	_loadDialog->setSaveMode(false);
+	_optionsDialog = new RivenOptionsDialog(this);
+
+	initVars();
+
+	// Open extras.mhk for common images (non-existant in the demo)
+	if (!(getFeatures() & GF_DEMO)) {
+		_extrasFile = new MohawkFile();
+		_extrasFile->open("extras.mhk");
+	}
+
+	// Start at main cursor
+	_gfx->changeCursor(kRivenMainCursor);
+
+	// Load game from launcher/command line if requested
+	if (ConfMan.hasKey("save_slot") && !(getFeatures() & GF_DEMO)) {
+		uint32 gameToLoad = ConfMan.getInt("save_slot");
+		Common::StringList savedGamesList = _saveLoad->generateSaveGameList();
+		if (gameToLoad > savedGamesList.size())
+			error ("Could not find saved game");
+		_saveLoad->loadGame(savedGamesList[gameToLoad]);
+		// HACK: The save_slot variable is saved to the disk! We don't want this!
+		ConfMan.removeKey("save_slot", ConfMan.getActiveDomainName());
+		ConfMan.flushToDisk();
+	} else { // Otherwise, start us off at aspit's card 1
+        changeToStack(aspit);
+		changeToCard(1);
+	}
+
+	Common::Event event;
+	while (!_gameOver) {
+		bool needsUpdate = _gfx->runScheduledWaterEffects();
+
+		while (_eventMan->pollEvent(event)) {
+			switch (event.type) {
+				case Common::EVENT_MOUSEMOVE:
+					_mousePos = event.mouse;
+					checkHotspotChange();
+					
+					// Check to show the inventory
+					if (_mousePos.y >= 392)
+						_gfx->showInventory();
+					else
+						_gfx->hideInventory();
+					
+					needsUpdate = true;
+					break;
+				case Common::EVENT_LBUTTONDOWN:
+					if (_curHotspot >= 0) {
+						runHotspotScript(_curHotspot, kMouseDownScript);
+						//scheduleScript(_hotspots[_curHotspot].script, kMouseMovedPressedReleasedScript);
+					}
+					break;
+				case Common::EVENT_LBUTTONUP:
+					if (_curHotspot >= 0) {
+						runHotspotScript(_curHotspot, kMouseUpScript);
+						//scheduleScript(_hotspots[_curHotspot].script, kMouseMovedPressedReleasedScript);
+					} else
+						checkInventoryClick();
+					break;
+				case Common::EVENT_KEYDOWN:
+					switch (event.kbd.keycode) {
+						case Common::KEYCODE_d:
+							if (event.kbd.flags & Common::KBD_CTRL) {
+								_console->attach();
+								_console->onFrame();
+							}
+							break;
+						case Common::KEYCODE_SPACE:
+							pauseGame();
+							break;
+						case Common::KEYCODE_F4:
+							_showHotspots = !_showHotspots;
+							if (_showHotspots) {
+								for (uint16 i = 0; i < _hotspotCount; i++)
+									_gfx->drawRect(_hotspots[i].rect, _hotspots[i].enabled);
+								needsUpdate = true;
+							} else {
+								changeToCard();
+							}
+							break;
+						case Common::KEYCODE_F5:
+							runDialog(*_optionsDialog);
+							updateZipMode();
+							break;
+						case Common::KEYCODE_ESCAPE:
+							if (getFeatures() & GF_DEMO) {
+								if (_curStack != aspit)
+									changeToStack(aspit);
+								changeToCard(1);
+							}
+							break;
+						default:
+							break;
+					}
+					break;
+				default:
+					break;
+			}
+		}
+
+		if (_curHotspot >= 0) {
+			runHotspotScript(_curHotspot, kMouseInsideScript);
+			//scheduleScript(_hotspots[_curHotspot].script, kMouseMovedPressedReleasedScript);
+		}
+
+		if (shouldQuit()) {
+			if (_eventMan->shouldRTL() && (getFeatures() & GF_DEMO) && !(_curStack == aspit && _curCard == 12)) {
+				if (_curStack != aspit)
+					changeToStack(aspit);
+				changeToCard(12);
+				_eventMan->resetRTL();
+				continue;
+			}			
+			return Common::kNoError;
+		}
+
+		// Update the screen if we need to
+		if (needsUpdate)
+			_system->updateScreen();
+
+		// Cut down on CPU usage
+		_system->delayMillis(10);
+	}
+
+	return Common::kNoError;
+}
+
+// Stack/Card-Related Functions
+
+void MohawkEngine_Riven::changeToStack(uint16 n) {
+	// The endings are in reverse order because of the way the 1.02 patch works.
+	// The only "Data3" file is j_Data3.mhk from that patch. Patch files have higher
+	// priorities over the regular files and are therefore loaded and checked first.
+	static const char *endings[] = { "_Data3.mhk", "_Data2.mhk", "_Data1.mhk", "_Data.mhk" };
+
+	// Don't change stack to the current stack (if the files are loaded)
+	if (_curStack == n && !_mhk.empty())
+		return;
+		
+	_curStack = n;
+
+	// Clear the old stack files out
+	for (uint32 i = 0; i < _mhk.size(); i++)
+		delete _mhk[i];
+	_mhk.clear();
+
+	// Get the prefix character for the destination stack
+	char prefix = getStackName(_curStack)[0];
+	
+	// Load any file that fits the patterns
+	for (int i = 0; i < ARRAYSIZE(endings); i++) {
+		Common::String filename = Common::String(prefix) + endings[i];
+		if (Common::File::exists(filename)) {
+			MohawkFile *mhk = new MohawkFile();
+			mhk->open(filename);
+			_mhk.push_back(mhk);
+		}
+	}
+	
+	// Make sure we have loaded files
+	if (_mhk.empty())
+		error("Could not load stack %s", getStackName(_curStack).c_str());
+	
+	// Stop any currently playing sounds and load the new sound file too
+	_sound->stopAllSLST();
+	_sound->loadRivenSounds(_curStack);
+}
+
+// Riven uses some hacks to change stacks for linking books
+// Otherwise, script command 27 changes stacks
+struct RivenSpecialChange {
+	byte startStack;
+	uint32 startCardRMAP;
+	byte targetStack;
+	uint32 targetCardRMAP;
+} rivenSpecialChange[] = {
+	{ aspit,  0x1f04, ospit,  0x44ad },		// Trap Book
+	{ bspit, 0x1c0e7, ospit,  0x2e76 },		// Dome Linking Book
+	{ gspit, 0x111b1, ospit,  0x2e76 },		// Dome Linking Book
+	{ jspit, 0x28a18, rspit,   0xf94 },		// Tay Linking Book
+	{ jspit, 0x26228, ospit,  0x2e76 },		// Dome Linking Book
+	{ ospit,  0x5f0d, pspit,  0x3bf0 },		// Return from 233rd Age
+	{ ospit,  0x470a, jspit, 0x1508e },		// Return from 233rd Age
+	{ ospit,  0x5c52, gspit, 0x10bea },		// Return from 233rd Age
+	{ ospit,  0x5d68, bspit, 0x1adfd },		// Return from 233rd Age
+	{ ospit,  0x5e49, tspit,   0xe78 },		// Return from 233rd Age
+	{ pspit,  0x4108, ospit,  0x2e76 },		// Dome Linking Book
+	{ rspit,  0x32d8, jspit, 0x1c474 },		// Return from Tay
+	{ tspit, 0x21b69, ospit,  0x2e76 }		// Dome Linking Book
+};
+
+void MohawkEngine_Riven::changeToCard(uint16 n) {
+	bool refreshMode = (n == 0);
+
+	// While this could be run without harm, it doesn't need to be. This should add a speed boost.
+	if (!refreshMode) {
+		debug (1, "Changing to card %d", n);
+		_curCard = n;
+
+		if (!(getFeatures() & GF_DEMO)) {
+			for (byte i = 0; i < 13; i++)
+				if (_curStack == rivenSpecialChange[i].startStack && _curCard == matchRMAPToCard(rivenSpecialChange[i].startCardRMAP)) {
+					changeToStack(rivenSpecialChange[i].targetStack);
+					_curCard = matchRMAPToCard(rivenSpecialChange[i].targetCardRMAP);
+				}
+		}
+
+		if (_cardData.hasData)
+			runCardScript(kCardLeaveScript);
+
+		loadCard(_curCard);
+	}
+	
+	// We need to reload hotspots when refreshing, however
+	loadHotspots(_curCard);
+	
+	_gfx->_updatesEnabled = true;
+	_gfx->clearWaterEffects();
+	_gfx->_activatedPLSTs.clear();
+	_video->_mlstRecords.clear();
+	_gfx->drawPLST(1);
+	_activatedSLST = false;
+	
+	runCardScript(kCardLoadScript);
+	_gfx->updateScreen();
+	runCardScript(kCardOpenScript);
+	
+	// Activate the first sound list if none have been activated
+	if (!_activatedSLST)
+		_sound->playSLST(1, _curCard);
+	
+	if (_showHotspots) {
+		for (uint16 i = 0; i < _hotspotCount; i++)
+			_gfx->drawRect(_hotspots[i].rect, _hotspots[i].enabled);
+	}
+	
+	// Now we need to redraw the cursor if necessary and handle mouse over scripts
+	_curHotspot = -1;
+	checkHotspotChange();
+}
+
+void MohawkEngine_Riven::loadCard(uint16 id) {
+	// NOTE: Do not clear the card scripts because it may delete a currently running script!
+
+	Common::SeekableReadStream* inStream = getRawData(ID_CARD, id);
+
+	_cardData.name = inStream->readSint16BE();
+	_cardData.zipModePlace = inStream->readUint16BE();
+	_cardData.scripts = RivenScript::readScripts(this, inStream);
+	_cardData.hasData = true;
+
+	delete inStream;
+
+	if (_cardData.zipModePlace) {
+		Common::String cardName = getName(CardNames, _cardData.name);
+		if (cardName.empty())
+			return;
+		ZipMode zip;
+		zip.name = cardName;
+		zip.id = id;
+		if (!(Common::find(_zipModeData.begin(), _zipModeData.end(), zip) != _zipModeData.end()))
+			_zipModeData.push_back(zip);
+	}
+}
+
+void MohawkEngine_Riven::loadHotspots(uint16 id) {
+	// NOTE: Do not clear the hotspots because it may delete a currently running script!
+
+	Common::SeekableReadStream* inStream = getRawData(ID_HSPT, id);
+
+	_hotspotCount = inStream->readUint16BE();
+	_hotspots = new RivenHotspot[_hotspotCount];
+
+
+	for (uint16 i = 0; i < _hotspotCount; i++) {
+		_hotspots[i].enabled = true;
+
+		_hotspots[i].blstID = inStream->readUint16BE();
+		_hotspots[i].name_resource = inStream->readSint16BE();
+		
+		int16 left = inStream->readSint16BE();
+		int16 top = inStream->readSint16BE();
+		int16 right = inStream->readSint16BE();
+		int16 bottom = inStream->readSint16BE();
+		
+		// Riven has some weird hotspots, disable them here
+		if (left >= right || top >= bottom) {
+			left = top = right = bottom = 0;
+			_hotspots[i].enabled = 0;
+		}
+
+		_hotspots[i].rect = Common::Rect(left, top, right, bottom);
+		
+		_hotspots[i].u0 = inStream->readUint16BE();
+
+		if (_hotspots[i].u0 != 0)
+			warning("Hotspot %d u0 non-zero", i);
+
+		_hotspots[i].mouse_cursor = inStream->readUint16BE();
+		_hotspots[i].index = inStream->readUint16BE();
+		_hotspots[i].u1 = inStream->readSint16BE();
+
+		if (_hotspots[i].u1 != -1)
+			warning("Hotspot %d u1 not -1", i);
+
+		_hotspots[i].zipModeHotspot = inStream->readUint16BE();
+		
+		// Read in the scripts now
+		_hotspots[i].scripts = RivenScript::readScripts(this, inStream);
+	}
+
+	delete inStream;
+	updateZipMode();
+}
+
+void MohawkEngine_Riven::updateZipMode() {
+	// Check if a zip mode hotspot is enabled by checking the name/id against the ZIPS records.
+
+	for (uint32 i = 0; i < _hotspotCount; i++) {
+		if (_hotspots[i].zipModeHotspot) {
+			if (*matchVarToString("azip") != 0) {
+				// Check if a zip mode hotspot is enabled by checking the name/id against the ZIPS records.
+				Common::String hotspotName = getName(HotspotNames, _hotspots[i].name_resource);
+
+				bool foundMatch = false;
+
+				if (!hotspotName.empty())
+					for (uint16 j = 0; j < _zipModeData.size(); j++)
+						if (_zipModeData[j].name == hotspotName) {
+							foundMatch = true;
+							break;
+						}
+
+				_hotspots[i].enabled = foundMatch;
+			} else // Disable the hotspot if zip mode is disabled
+				_hotspots[i].enabled = false;
+		}
+	}
+}
+
+void MohawkEngine_Riven::checkHotspotChange() {
+	uint16 hotspotIndex = 0;
+	bool foundHotspot = false;
+	for (uint16 i = 0; i < _hotspotCount; i++)
+		if (_hotspots[i].enabled && _hotspots[i].rect.contains(_mousePos)) {
+			foundHotspot = true;
+			hotspotIndex = i;
+		}
+		
+	if (foundHotspot) {
+		if (_curHotspot != hotspotIndex) {
+			_curHotspot = hotspotIndex;
+			_gfx->changeCursor(_hotspots[_curHotspot].mouse_cursor);
+		}
+	} else {
+		_curHotspot = -1;
+		_gfx->changeCursor(kRivenMainCursor);
+	}
+}
+
+Common::String MohawkEngine_Riven::getHotspotName(uint16 hotspot) {
+	assert(hotspot < _hotspotCount);
+	
+	if (_hotspots[hotspot].name_resource < 0)
+		return Common::String::emptyString;
+
+	return getName(HotspotNames, _hotspots[hotspot].name_resource);
+}
+
+void MohawkEngine_Riven::checkInventoryClick() {
+	// Don't even bother. We're not in the inventory portion of the screen.
+	if (_mousePos.y < 392)
+		return;
+		
+	// No inventory in the demo or opening screens.
+	if (getFeatures() & GF_DEMO || _curStack == aspit)
+		return;
+		
+	// Set the return stack/card id's.
+	*matchVarToString("returnstackid") = _curStack;
+	*matchVarToString("returncardid") = _curCard;
+	
+	// See RivenGraphics::showInventory() for an explanation
+	// of why only this variable is used.
+	bool hasCathBook = *matchVarToString("acathbook") != 0;
+	
+	// Go to the book if a hotspot contains the mouse
+	if (!hasCathBook) {
+		if (atrusJournalRectSolo.contains(_mousePos)) {
+			_gfx->hideInventory();
+			changeToStack(aspit);
+			changeToCard(5);
+		}
+	} else {
+		if (atrusJournalRect.contains(_mousePos)) {
+			_gfx->hideInventory();
+			changeToStack(aspit);
+			changeToCard(5);
+		} else if (cathJournalRect.contains(_mousePos)) {
+			_gfx->hideInventory();
+			changeToStack(aspit);
+			changeToCard(6);
+		} else if (trapBookRect.contains(_mousePos)) {
+			_gfx->hideInventory();
+			changeToStack(aspit);
+			changeToCard(7);
+		}
+	}
+}
+
+Common::SeekableReadStream *MohawkEngine_Riven::getExtrasResource(uint32 tag, uint16 id) {
+	return _extrasFile->getRawData(tag, id);
+}
+
+Common::String MohawkEngine_Riven::getName(uint16 nameResource, uint16 nameID) {
+	Common::SeekableReadStream* nameStream = getRawData(ID_NAME, nameResource);
+	uint16 fieldCount = nameStream->readUint16BE();
+	uint16* stringOffsets = new uint16[fieldCount];
+	Common::String name = Common::String::emptyString;
+	char c;
+
+	if (nameID < fieldCount) {
+		for (uint16 i = 0; i < fieldCount; i++)
+			stringOffsets[i] = nameStream->readUint16BE();
+		for (uint16 i = 0; i < fieldCount; i++)
+			nameStream->readUint16BE();	// Skip unknown values
+	
+		nameStream->seek(stringOffsets[nameID], SEEK_CUR);
+		c = (char)nameStream->readByte();
+
+		while (c) {
+			name += c;
+			c = (char)nameStream->readByte();
+		}
+	}
+
+	delete nameStream;
+	delete [] stringOffsets;
+	return name;
+}
+
+uint16 MohawkEngine_Riven::matchRMAPToCard(uint32 rmapCode) {
+	uint16 index = 0;
+	Common::SeekableReadStream *rmapStream = getRawData(ID_RMAP, 1);
+
+	for (uint16 i = 1; rmapStream->pos() < rmapStream->size(); i++) {
+		uint32 code = rmapStream->readUint32BE();
+		if (code == rmapCode)
+			index = i;
+	}
+
+	delete rmapStream;
+
+	if (!index)
+		error ("Could not match RMAP code %08x", rmapCode);
+
+	return index - 1;
+}
+
+void MohawkEngine_Riven::runCardScript(uint16 scriptType) {
+	assert(_cardData.hasData);
+	for (uint16 i = 0; i < _cardData.scripts.size(); i++)
+		if (_cardData.scripts[i]->getScriptType() == scriptType) {
+			_cardData.scripts[i]->runScript();
+			break;
+		}
+}
+
+void MohawkEngine_Riven::runHotspotScript(uint16 hotspot, uint16 scriptType) {
+	assert(hotspot < _hotspotCount);
+	for (uint16 i = 0; i < _hotspots[hotspot].scripts.size(); i++)
+		if (_hotspots[hotspot].scripts[i]->getScriptType() == scriptType) {
+			_hotspots[hotspot].scripts[i]->runScript();
+			break;
+		}
+}
+
+void MohawkEngine_Riven::runLoadDialog() {
+	runDialog(*_loadDialog);
+}
+
+Common::Error MohawkEngine_Riven::loadGameState(int slot) {
+	return _saveLoad->loadGame(_saveLoad->generateSaveGameList()[slot]) ? Common::kNoError : Common::kUnknownError;
+}
+
+Common::Error MohawkEngine_Riven::saveGameState(int slot, const char *desc) {
+	Common::StringList saveList = _saveLoad->generateSaveGameList();
+
+	if ((uint)slot < saveList.size()) 
+		_saveLoad->deleteSave(saveList[slot]);
+	
+	return _saveLoad->saveGame(Common::String(desc)) ? Common::kNoError : Common::kUnknownError;
+}
+
+static const char *rivenStackNames[] = {
+	"aspit",
+	"bspit",
+	"gspit",
+	"jspit",
+	"ospit",
+	"pspit",
+	"rspit",
+	"tspit"
+};
+
+Common::String MohawkEngine_Riven::getStackName(uint16 stack) {
+	return Common::String(rivenStackNames[stack]);
+}
+
+bool ZipMode::operator== (const ZipMode &z) const {
+	return z.name == name && z.id == id;
+}
+
+}
diff --git a/engines/mohawk/riven.h b/engines/mohawk/riven.h
new file mode 100644
index 0000000000..d8ef5c281f
--- /dev/null
+++ b/engines/mohawk/riven.h
@@ -0,0 +1,180 @@
+/* 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$
+ * $Id$
+ *
+ */
+ 
+#ifndef MOHAWK_RIVEN_H
+#define MOHAWK_RIVEN_H
+
+#include "mohawk/mohawk.h"
+#include "mohawk/riven_scripts.h"
+
+#include "gui/saveload.h"
+
+namespace Mohawk {
+
+struct MohawkGameDescription;
+class MohawkFile;
+class RivenGraphics;
+class RivenExternal;
+class RivenConsole;
+class RivenSaveLoad;
+
+#define RIVEN_STACKS 8
+
+// Riven Stack Types
+enum {
+	aspit = 0,		// Main Menu, Books, Setup
+	bspit = 1,		// Book-Making Island
+	gspit = 2,		// Garden Island
+	jspit = 3,		// Jungle Island
+	ospit = 4,		// 233rd Age (Gehn's Office)
+	pspit = 5,		// Prison Island
+	rspit = 6,		// Rebel Age (Tay)
+	tspit = 7		// Temple Island
+};
+
+// NAME Resource ID's
+enum {
+	CardNames = 1,
+	HotspotNames = 2,
+	ExternalCommandNames = 3,
+	VariableNames = 4,
+	StackNames = 5
+};
+
+// Rects for the inventory object positions
+static const Common::Rect atrusJournalRectSolo = Common::Rect(295, 402, 313, 426);
+static const Common::Rect atrusJournalRect = Common::Rect(222, 402, 240, 426);
+static const Common::Rect cathJournalRect = Common::Rect(291, 408, 311, 419);
+static const Common::Rect trapBookRect = Common::Rect(363, 396, 386, 432);
+
+struct RivenHotspot {
+	uint16 blstID;
+	int16 name_resource;
+	Common::Rect rect;
+	uint16 u0;
+	uint16 mouse_cursor;
+	uint16 index;
+	int16 u1;
+	int16 zipModeHotspot;
+	RivenScriptList scripts;
+	
+	bool enabled;
+};
+
+struct Card {
+	int16 name;
+	uint16 zipModePlace;
+	bool hasData;
+	RivenScriptList scripts;
+};
+
+struct ZipMode {
+	Common::String name;
+	uint16 id;
+	bool operator== (const ZipMode& z) const;
+};
+ 
+class MohawkEngine_Riven : public MohawkEngine {
+protected:
+	Common::Error run();
+
+public:
+	MohawkEngine_Riven(OSystem *syst, const MohawkGameDescription *gamedesc);
+	virtual ~MohawkEngine_Riven();
+	
+	RivenGraphics *_gfx;
+	RivenExternal *_externalScriptHandler;
+
+	Card _cardData;
+	bool _gameOver;
+	
+	GUI::Debugger *getDebugger() { return _console; }
+	
+	bool canLoadGameStateCurrently() { return true; }
+	bool canSaveGameStateCurrently() { return true; }
+	Common::Error loadGameState(int slot);
+	Common::Error saveGameState(int slot, const char *desc);
+	bool hasFeature(EngineFeature f) const;
+
+private:
+	MohawkFile *_extrasFile; // We need a separate handle for the extra data
+	RivenConsole *_console;
+	RivenSaveLoad *_saveLoad;
+	GUI::SaveLoadChooser *_loadDialog;
+	RivenOptionsDialog *_optionsDialog;
+
+	// Stack/Card-related functions and variables
+	uint16 _curCard;
+	uint16 _curStack;
+	void loadCard(uint16);
+
+	// Hotspot related functions and variables
+	uint16 _hotspotCount;
+	void loadHotspots(uint16);
+	void checkHotspotChange();
+	void checkInventoryClick();
+	bool _showHotspots;
+	void updateZipMode();
+	
+	// Variables
+	uint32 *_vars;
+	uint32 _varCount;
+
+public:
+	Common::SeekableReadStream *getExtrasResource(uint32 tag, uint16 id);
+	bool _activatedSLST;
+	void runLoadDialog();
+	
+	void changeToCard(uint16 = 0);
+	void changeToStack(uint16);
+	Common::String getName(uint16 nameResource, uint16 nameID);
+	Common::String getStackName(uint16 stack);
+	void runCardScript(uint16 scriptType);
+	void runUpdateScreenScript() { runCardScript(kCardUpdateScript); }
+	uint16 getCurCard() { return _curCard; }
+	uint16 getCurStack() { return _curStack; }
+	uint16 matchRMAPToCard(uint32);
+
+	Common::Point _mousePos;
+	RivenHotspot *_hotspots;
+	int32 _curHotspot;
+	Common::Array<ZipMode> _zipModeData;
+	uint16 getHotspotCount() { return _hotspotCount; }
+	void runHotspotScript(uint16 hotspot, uint16 scriptType);
+	int32 getCurHotspot() { return _curHotspot; }
+	Common::String getHotspotName(uint16 hotspot);
+	
+	void initVars();
+	uint32 getVarCount() { return _varCount; }
+	uint32 getGlobalVar(uint32 index);
+	Common::String getGlobalVarName(uint32 index);
+	uint32 *getLocalVar(uint32 index);
+	uint32 *matchVarToString(Common::String varName);
+	uint32 *matchVarToString(const char *varName);
+};
+
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/riven_cursors.h b/engines/mohawk/riven_cursors.h
new file mode 100644
index 0000000000..4120aca41b
--- /dev/null
+++ b/engines/mohawk/riven_cursors.h
@@ -0,0 +1,404 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+namespace Mohawk {
+
+//////////////////////////////////////////////
+// Cursors and Cursor Palettes
+//////////////////////////////////////////////
+
+////////////////////////////////////////
+// Zip Mode Cursor (16x16):
+//    Shown when a zip mode spot is active
+//
+//    0 = Transparent
+//    1 = Black		(0x000000)
+//    2 = Yellow	(0xDCFF00)
+////////////////////////////////////////
+static const byte zipModeCursor[] = {
+	1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 1, 1, 0, 0, 1, 2, 1, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 1, 2, 1, 0, 1, 2, 1, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 1, 2, 1, 1, 2, 2, 1, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 1, 2, 2, 1, 2, 2, 2, 1, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 1, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 1, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 1, 2, 2, 2, 1, 2, 2, 1, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 1, 2, 2, 1, 1, 2, 1, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 1, 2, 1, 0, 1, 2, 1, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 1, 2, 1, 0, 0, 1, 1, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1
+};
+
+
+////////////////////////////////////////
+// Zip Mode Cursor Palette:
+//    Palette For The Zip Mode Cursor
+////////////////////////////////////////
+static const byte zipModeCursorPalette[] = {
+	0x00, 0x00, 0x00,	0x00,		// Black
+	0xDC, 0xFF, 0x00,	0x00,		// Yellow
+};
+
+
+////////////////////////////////////////
+// Hand Over Object Cursor (16x16):
+//    Shown when over a hotspot that's interactive
+//
+//    0 = Transparent
+//    1 = Black 		(0x000000)
+//    2 = Light Peach 	(0xEDCD96)
+//    3 = Brown			(0x8A672F)
+//    4 = Dark Peach	(0xE89A62)
+////////////////////////////////////////
+static const byte objectHandCursor[] = {
+	0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 1, 1, 0, 1, 2, 3, 1, 1, 1, 0, 0, 0, 0,
+	0, 0, 1, 2, 3, 1, 1, 2, 3, 1, 2, 3, 1, 0, 0, 0,
+	0, 0, 1, 2, 3, 1, 1, 4, 3, 1, 2, 3, 1, 0, 1, 0,
+	0, 0, 0, 1, 2, 3, 1, 2, 3, 1, 4, 3, 1, 1, 2, 1,
+	0, 0, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1,
+	0, 1, 1, 0, 1, 2, 2, 2, 2, 2, 2, 3, 1, 2, 3, 1,
+	1, 2, 2, 1, 1, 2, 2, 2, 4, 2, 4, 2, 2, 4, 2, 1,
+	1, 3, 4, 2, 1, 2, 4, 2, 2, 2, 2, 2, 4, 4, 1, 0,
+	0, 1, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 3, 1, 0,
+	0, 0, 1, 3, 2, 2, 2, 2, 2, 2, 2, 4, 4, 3, 1, 0,
+	0, 0, 1, 3, 2, 2, 2, 2, 2, 2, 2, 4, 3, 1, 0, 0,
+	0, 0, 0, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 1, 0, 0,
+	0, 0, 0, 0, 1, 2, 2, 2, 2, 2, 4, 3, 1, 0, 0, 0,
+	0, 0, 0, 0, 0, 1, 2, 2, 2, 2, 4, 3, 1, 0, 0, 0,
+	0, 0, 0, 0, 0, 1, 2, 2, 2, 2, 4, 3, 1, 0, 0, 0
+};
+
+
+////////////////////////////////////////
+// Grabbing Hand Cursor (13x13):
+//    Shown when interacting with an object
+//
+//    0 = Transparent
+//    1 = Black 		(0x000000)
+//    2 = Light Peach 	(0xEDCD96)
+//    3 = Brown			(0x8A672F)
+//    4 = Dark Peach	(0xE89A62)
+////////////////////////////////////////
+static const byte grabbingHandCursor[] = {
+	0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0,
+	0, 0, 1, 1, 1, 2, 3, 1, 1, 1, 0, 0, 0,
+	0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 1, 0,
+	0, 1, 2, 2, 2, 2, 2, 2, 2, 3, 1, 2, 1,
+	0, 1, 1, 2, 2, 2, 4, 2, 4, 2, 2, 4, 1,
+	1, 2, 1, 2, 4, 2, 2, 2, 2, 2, 4, 4, 1,
+	1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 3, 1,
+	1, 3, 2, 2, 2, 2, 2, 2, 2, 4, 4, 3, 1,
+	1, 3, 2, 2, 2, 2, 2, 2, 2, 4, 3, 1, 0,
+	0, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 1, 0,
+	0, 0, 1, 2, 2, 2, 2, 2, 4, 3, 1, 0, 0,
+	0, 0, 0, 1, 2, 2, 2, 2, 4, 3, 1, 0, 0,
+	0, 0, 0, 1, 2, 2, 2, 2, 4, 3, 1, 0, 0 
+};
+
+
+////////////////////////////////////////
+// Standard Hand Cursor (15x16):
+//    Standard Cursor
+//
+//    0 = Transparent
+//    1 = Black 		(0x000000)
+//    2 = Light Peach 	(0xEDCD96)
+//    3 = Brown			(0x8A672F)
+//    4 = Dark Peach	(0xE89A62)
+////////////////////////////////////////
+static const byte standardHandCursor[] = {
+	0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 1, 4, 4, 1, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 1, 2, 3, 1, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 1, 2, 4, 1, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 1, 2, 4, 1, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 1, 2, 4, 1, 0, 0, 0, 0, 0, 0,
+	0, 1, 1, 0, 0, 1, 2, 4, 1, 1, 1, 1, 1, 0, 0,
+	1, 4, 2, 1, 0, 1, 2, 4, 1, 4, 1, 4, 1, 1, 1,
+	0, 1, 3, 2, 1, 1, 2, 4, 1, 4, 1, 4, 1, 4, 1,
+	0, 0, 1, 4, 2, 1, 2, 2, 4, 2, 4, 2, 1, 4, 1,
+	0, 0, 1, 4, 2, 1, 2, 2, 2, 2, 2, 2, 2, 3, 1,
+	0, 0, 0, 1, 4, 2, 2, 2, 2, 2, 2, 2, 4, 3, 1,
+	0, 0, 0, 0, 1, 2, 2, 2, 2, 2, 2, 2, 4, 3, 1,
+	0, 0, 0, 0, 1, 2, 2, 2, 2, 2, 2, 2, 3, 1, 0,
+	0, 0, 0, 0, 0, 1, 2, 2, 2, 2, 2, 4, 3, 1, 0,
+	0, 0, 0, 0, 0, 1, 2, 2, 2, 2, 2, 4, 3, 1, 0
+};
+
+
+////////////////////////////////////////
+// Pointing Left Cursor (15x13):
+//    Cursor When Over A Hotspot That Allows You To Move Left
+//
+//    0 = Transparent
+//    1 = Black 		(0x000000)
+//    2 = Light Peach 	(0xEDCD96)
+//    3 = Brown			(0x8A672F)
+//    4 = Dark Peach	(0xE89A62)
+////////////////////////////////////////
+static const byte pointingLeftCursor[] = {
+	0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 1, 3, 2, 2, 2, 1, 1, 0, 0,
+	0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 3, 1, 1,
+	1, 4, 2, 2, 2, 2, 1, 2, 3, 2, 2, 2, 4, 4, 4,
+	1, 4, 4, 4, 4, 4, 1, 2, 1, 3, 4, 2, 2, 2, 2,
+	0, 1, 1, 1, 1, 1, 1, 2, 1, 3, 3, 4, 2, 2, 2,
+	0, 0, 0, 0, 0, 1, 1, 1, 1, 3, 3, 3, 4, 4, 2,
+	0, 0, 0, 0, 0, 1, 2, 2, 2, 4, 1, 3, 4, 2, 2,
+	0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 3, 4, 2, 2,
+	0, 0, 0, 0, 0, 1, 2, 2, 2, 2, 2, 1, 4, 2, 4,
+	0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 4, 4, 1,
+	0, 0, 0, 0, 0, 0, 1, 2, 2, 2, 2, 1, 1, 1, 0,
+	0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0 
+};
+
+
+////////////////////////////////////////
+// Pointing Right Cursor (15x13):
+//    Cursor When Over A Hotspot That Allows You To Move Right
+//
+//    0 = Transparent
+//    1 = Black 		(0x000000)
+//    2 = Light Peach 	(0xEDCD96)
+//    3 = Brown			(0x8A672F)
+//    4 = Dark Peach	(0xE89A62)
+////////////////////////////////////////
+static const byte pointingRightCursor[] = {
+	0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 1, 1, 2, 2, 2, 3, 1, 0, 0, 0, 0, 0, 0,
+	1, 1, 3, 4, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0,
+	4, 4, 4, 2, 2, 2, 3, 2, 1, 4, 4, 4, 4, 4, 1,
+	2, 2, 2, 2, 4, 3, 1, 2, 1, 2, 2, 2, 2, 4, 1,
+	2, 2, 2, 4, 3, 3, 1, 2, 1, 1, 1, 1, 1, 1, 0,
+	2, 4, 4, 3, 3, 3, 1, 1, 1, 1, 0, 0, 0, 0, 0,
+	2, 2, 4, 3, 1, 4, 2, 2, 2, 1, 0, 0, 0, 0, 0,
+	2, 2, 4, 3, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
+	4, 2, 4, 1, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0, 0,
+	1, 4, 4, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
+	0, 1, 1, 1, 2, 2, 2, 2, 1, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0
+};
+
+
+////////////////////////////////////////
+// Pointing Down Cursor (Palm Up)(13x16):
+//    Cursor When Over A Hotspot That Allows You To Move Down
+//
+//    0 = Transparent
+//    1 = Black 		(0x000000)
+//    2 = Light Peach 	(0xEDCD96)
+//    3 = Brown			(0x8A672F)
+//    4 = Dark Peach	(0xE89A62)
+////////////////////////////////////////
+static const byte pointingDownCursorPalmUp[] = {
+	0, 0, 1, 4, 2, 2, 2, 2, 2, 4, 1, 0, 0,
+	0, 0, 1, 4, 2, 2, 4, 2, 2, 2, 4, 1, 0,
+	0, 1, 3, 4, 2, 2, 4, 4, 4, 4, 4, 1, 0,
+	0, 1, 4, 2, 2, 4, 3, 3, 3, 1, 1, 1, 1,
+	1, 2, 2, 2, 4, 3, 3, 1, 1, 2, 1, 2, 1,
+	1, 2, 2, 2, 3, 3, 3, 4, 1, 2, 1, 2, 1,
+	1, 2, 2, 3, 1, 1, 1, 2, 1, 2, 1, 2, 1,
+	1, 3, 2, 2, 2, 2, 1, 2, 1, 2, 1, 2, 1,
+	0, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1,
+	0, 0, 1, 2, 4, 1, 1, 1, 1, 1, 1, 0, 0,
+	0, 0, 1, 2, 4, 1, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 1, 2, 4, 1, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 1, 2, 4, 1, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 1, 2, 4, 1, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 1, 4, 4, 1, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+
+////////////////////////////////////////
+// Pointing Up Cursor (Palm Up)(13x16):
+//    Cursor When Over A Hotspot That Allows You To Move Up
+//
+//    0 = Transparent
+//    1 = Black 		(0x000000)
+//    2 = Light Peach 	(0xEDCD96)
+//    3 = Brown			(0x8A672F)
+//    4 = Dark Peach	(0xE89A62)
+////////////////////////////////////////
+static const byte pointingUpCursorPalmUp[] = {
+	0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 1, 4, 4, 1, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 1, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 1, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 1, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 1, 0, 0,
+	0, 0, 1, 1, 1, 1, 1, 1, 2, 4, 1, 0, 0,
+	1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 0,
+	1, 2, 1, 2, 1, 2, 1, 2, 2, 2, 2, 3, 1,
+	1, 2, 1, 2, 1, 2, 1, 1, 1, 3, 2, 2, 1,
+	1, 2, 1, 2, 1, 4, 3, 3, 3, 2, 2, 2, 1,
+	1, 2, 1, 2, 1, 1, 3, 3, 4, 2, 2, 2, 1,
+	1, 1, 1, 1, 3, 3, 3, 4, 2, 2, 4, 1, 0,
+	0, 1, 4, 4, 4, 4, 4, 2, 2, 4, 3, 1, 0,
+	0, 1, 4, 2, 2, 2, 4, 2, 2, 4, 1, 0, 0,
+	0, 0, 1, 4, 2, 2, 2, 2, 2, 4, 1, 0, 0
+};
+
+
+////////////////////////////////////////
+// Pointing Left Cursor (Bent)(15x13):
+//    Cursor When Over A Hotspot That Allows You To Turn Left 180 Degrees
+//
+//    0 = Transparent
+//    1 = Black 		(0x000000)
+//    2 = Light Peach 	(0xEDCD96)
+//    3 = Brown			(0x8A672F)
+//    4 = Dark Peach	(0xE89A62)
+////////////////////////////////////////
+static const byte pointingLeftCursorBent[] = {
+	0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 1, 3, 2, 2, 2, 1, 1, 0, 0,
+	0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 3, 1, 1,
+	1, 3, 2, 4, 4, 2, 1, 2, 3, 3, 2, 2, 4, 4, 4,
+	1, 2, 4, 3, 3, 4, 1, 2, 1, 3, 4, 2, 2, 2, 2,
+	1, 4, 4, 1, 1, 1, 1, 2, 1, 1, 3, 4, 2, 2, 2,
+	1, 1, 1, 0, 0, 1, 1, 1, 1, 3, 3, 3, 4, 4, 2,
+	0, 0, 0, 0, 0, 1, 2, 2, 2, 4, 1, 3, 4, 3, 2,
+	0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 3, 4, 2, 2,
+	0, 0, 0, 0, 0, 1, 2, 2, 2, 2, 2, 1, 4, 2, 4,
+	0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 4, 4, 1,
+	0, 0, 0, 0, 0, 0, 1, 2, 2, 2, 2, 1, 1, 1, 0,
+	0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0
+};
+
+
+////////////////////////////////////////
+// Pointing Right Cursor (Bent)(15x13):
+//    Cursor When Over A Hotspot That Allows You To Turn Right 180 Degrees
+//
+//    0 = Transparent
+//    1 = Black 		(0x000000)
+//    2 = Light Peach 	(0xEDCD96)
+//    3 = Brown			(0x8A672F)
+//    4 = Dark Peach	(0xE89A62)
+////////////////////////////////////////
+static const byte pointingRightCursorBent[] = {
+	0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 1, 1, 2, 2, 2, 3, 1, 0, 0, 0, 0, 0, 0,
+	1, 1, 3, 4, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0,
+	4, 4, 4, 2, 2, 3, 3, 2, 1, 2, 4, 4, 2, 3, 1,
+	2, 2, 2, 2, 4, 3, 1, 2, 1, 4, 3, 3, 4, 2, 1,
+	2, 2, 2, 4, 3, 1, 1, 2, 1, 1, 1, 1, 4, 4, 1,
+	2, 4, 4, 3, 3, 3, 1, 1, 1, 1, 0, 0, 1, 1, 1,
+	2, 3, 4, 3, 1, 4, 2, 2, 2, 1, 0, 0, 0, 0, 0,
+	2, 2, 4, 3, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
+	4, 2, 4, 1, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0, 0,
+	1, 4, 4, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
+	0, 1, 1, 1, 2, 2, 2, 2, 1, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0
+};
+
+
+////////////////////////////////////////
+// Pointing Down Cursor (Palm Down)(15x16):
+//    Similar to Standard Cursor
+//
+//    0 = Transparent
+//    1 = Black 		(0x000000)
+//    2 = Light Peach 	(0xEDCD96)
+//    3 = Brown			(0x8A672F)
+//    4 = Dark Peach	(0xE89A62)
+////////////////////////////////////////
+static const byte pointingDownCursorPalmDown[] = {
+	0, 1, 3, 4, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0, 0,
+	0, 1, 3, 4, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0, 0,
+	0, 1, 3, 2, 2, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0,
+	1, 3, 4, 2, 2, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0,
+	1, 3, 4, 2, 2, 2, 2, 2, 2, 2, 4, 1, 0, 0, 0,
+	1, 3, 2, 3, 2, 2, 2, 2, 2, 1, 2, 4, 1, 0, 0,
+	1, 4, 1, 2, 2, 3, 2, 3, 2, 1, 2, 4, 1, 0, 0,
+	1, 4, 1, 4, 1, 4, 1, 4, 4, 1, 1, 2, 3, 1, 0,
+	0, 1, 1, 4, 1, 4, 1, 4, 2, 1, 0, 1, 2, 4, 1,
+	0, 0, 1, 1, 1, 1, 1, 4, 2, 1, 0, 0, 1, 1, 0,
+	0, 0, 0, 0, 0, 0, 1, 4, 4, 1, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 1, 4, 2, 1, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 1, 4, 2, 1, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 1, 3, 2, 1, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 1, 4, 4, 1, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0
+};
+
+////////////////////////////////////////
+// Hand Cursor Palette:
+//    Palette For All Hand Cursors
+////////////////////////////////////////
+static const byte handCursorPalette[] = {
+	0x00, 0x00, 0x00,	0x00,		// Black
+	0xED, 0xCD, 0x96,	0x00,		// Light Peach
+	0x8A, 0x67, 0x2F,	0x00,		// Brown
+	0xE8, 0x9A, 0x62,	0x00		// Dark Peach
+};
+
+
+////////////////////////////////////////
+// Pellet Cursor (8x8):
+//    Cursor When Using The Pellet In The Frog Trap
+//
+//    0 = Transparent
+//    1 = Light Olive Green 	(0x5D6730)
+//    2 = Maroon				(0x5E3333)
+//    3 = Light Gray			(0x555555)
+//    4 = Medium Gray			(0x444444)
+//    5 = Dark Gray				(0x333333)
+//    6 = Dark Green			(0x2D3300)
+//    7 = Darkest Gray			(0x222222)
+////////////////////////////////////////
+static const byte pelletCursor[] = {
+	0, 0, 1, 1, 2, 3, 0, 0,
+	0, 2, 1, 4, 1, 2, 5, 0,
+	4, 1, 4, 1, 2, 1, 5, 4,
+	4, 2, 1, 2, 1, 1, 2, 6,
+	6, 4, 2, 1, 4, 4, 1, 5,
+	5, 6, 5, 2, 1, 2, 4, 4,
+	0, 7, 5, 5, 4, 2, 5, 0,
+	0, 0, 5, 6, 6, 5, 0, 0
+};
+
+////////////////////////////////////////
+// Pellet Cursor Palette:
+//    Palette For The Pellet Cursor
+////////////////////////////////////////
+static const byte pelletCursorPalette[] = {
+	0x5D, 0x67, 0x30,	0x00,
+	0x5E, 0x33, 0x33,	0x00,
+	0x55, 0x55, 0x55,	0x00,
+	0x44, 0x44, 0x44,	0x00,
+	0x33, 0x33, 0x33,	0x00,
+	0x2D, 0x33, 0x00,	0x00,
+	0x22, 0x22, 0x22,	0x00
+};
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/riven_external.cpp b/engines/mohawk/riven_external.cpp
new file mode 100644
index 0000000000..647f3a35f6
--- /dev/null
+++ b/engines/mohawk/riven_external.cpp
@@ -0,0 +1,1467 @@
+/* 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$
+ * $Id$
+ *
+ */
+ 
+#include "mohawk/graphics.h"
+#include "mohawk/riven.h"
+#include "mohawk/riven_external.h"
+
+#include "common/EventRecorder.h"
+#include "gui/message.h"
+ 
+namespace Mohawk {
+
+RivenExternal::RivenExternal(MohawkEngine_Riven *vm) : _vm(vm) {
+	setupCommands();
+	_rnd = new Common::RandomSource();
+	g_eventRec.registerRandomSource(*_rnd, "riven");
+}
+
+RivenExternal::~RivenExternal() {
+	delete _rnd;
+	
+	for (uint32 i = 0; i < _externalCommands.size(); i++)
+		delete _externalCommands[i];
+	
+	_externalCommands.clear();
+}
+
+void RivenExternal::setupCommands() {
+	// aspit (Main Menu, Books, Setup) external commands
+	COMMAND(xastartupbtnhide);
+	COMMAND(xasetupcomplete);
+	COMMAND(xaatrusopenbook);
+	COMMAND(xaatrusbookback);
+	COMMAND(xaatrusbookprevpage);
+	COMMAND(xaatrusbooknextpage);
+	COMMAND(xacathopenbook);
+	COMMAND(xacathbookback);
+	COMMAND(xacathbookprevpage);
+	COMMAND(xacathbooknextpage);
+	COMMAND(xtrapbookback);
+	COMMAND(xatrapbookclose);
+	COMMAND(xatrapbookopen);
+	COMMAND(xarestoregame);
+	COMMAND(xadisablemenureturn);
+	COMMAND(xaenablemenureturn);
+	COMMAND(xalaunchbrowser);
+
+	// bspit (Bookmaking Island) external commands
+	COMMAND(xblabopenbook);
+	COMMAND(xblabbookprevpage);
+	COMMAND(xblabbooknextpage);
+	COMMAND(xsoundplug);
+	COMMAND(xbchangeboiler);
+	COMMAND(xbupdateboiler);
+	COMMAND(xbsettrap);
+	COMMAND(xbcheckcatch);
+	COMMAND(xbait);
+	COMMAND(xbfreeytram);
+	COMMAND(xbaitplate);
+	COMMAND(xbisland190_opencard);
+	COMMAND(xbisland190_resetsliders);
+	COMMAND(xbisland190_slidermd);
+	COMMAND(xbisland190_slidermw);
+	COMMAND(xbscpbtn);
+	COMMAND(xbisland_domecheck);
+	COMMAND(xvalvecontrol);
+	COMMAND(xbchipper);
+
+	// gspit (Garden Island) external commands
+	COMMAND(xgresetpins);
+	COMMAND(xgrotatepins);
+	COMMAND(xgpincontrols);
+	COMMAND(xgisland25_opencard);
+	COMMAND(xgisland25_resetsliders);
+	COMMAND(xgisland25_slidermd);
+	COMMAND(xgisland25_slidermw);
+	COMMAND(xgscpbtn);
+	COMMAND(xgisland1490_domecheck);
+	COMMAND(xgplateau3160_dopools);
+	COMMAND(xgwt200_scribetime);
+	COMMAND(xgwt900_scribe);
+	COMMAND(xgplaywhark);
+	COMMAND(xgrviewer);
+	COMMAND(xgwharksnd);
+	COMMAND(xglview_prisonoff);
+	COMMAND(xglview_villageoff);
+	COMMAND(xglviewer);
+	COMMAND(xglview_prisonon);
+	COMMAND(xglview_villageon);
+
+	// jspit (Jungle Island) external commands
+	COMMAND(xreseticons);
+	COMMAND(xicon);
+	COMMAND(xcheckicons);
+	COMMAND(xtoggleicon);
+	COMMAND(xjtunnel103_pictfix);
+	COMMAND(xjtunnel104_pictfix);
+	COMMAND(xjtunnel105_pictfix);
+	COMMAND(xjtunnel106_pictfix);
+	COMMAND(xvga1300_carriage);
+	COMMAND(xjdome25_resetsliders);
+	COMMAND(xjdome25_slidermd);
+	COMMAND(xjdome25_slidermw);
+	COMMAND(xjscpbtn);
+	COMMAND(xjisland3500_domecheck);
+	COMMAND(xhandlecontroldown);
+	COMMAND(xhandlecontrolmid);
+	COMMAND(xhandlecontrolup);
+	COMMAND(xjplaybeetle_550);
+	COMMAND(xjplaybeetle_600);
+	COMMAND(xjplaybeetle_950);
+	COMMAND(xjplaybeetle_1050);
+	COMMAND(xjplaybeetle_1450);
+	COMMAND(xjlagoon700_alert);
+	COMMAND(xjlagoon800_alert);
+	COMMAND(xjlagoon1500_alert);
+	COMMAND(xschool280_playwhark);
+	COMMAND(xjatboundary);
+
+	// ospit (Gehn's Office) external commands
+	COMMAND(xorollcredittime);
+	COMMAND(xbookclick);
+	COMMAND(xooffice30_closebook);
+	COMMAND(xobedroom5_closedrawer);
+	COMMAND(xogehnopenbook);
+	COMMAND(xogehnbookprevpage);
+	COMMAND(xogehnbooknextpage);
+	COMMAND(xgwatch);
+	
+	// pspit (Prison Island) external commands
+	COMMAND(xpisland990_elevcombo);
+	COMMAND(xpscpbtn);
+	COMMAND(xpisland290_domecheck);
+	COMMAND(xpisland25_opencard);
+	COMMAND(xpisland25_resetsliders);
+	COMMAND(xpisland25_slidermd);
+	COMMAND(xpisland25_slidermw);
+
+	// rspit (Rebel Age) external commands
+	COMMAND(xrshowinventory);
+	COMMAND(xrhideinventory);
+	COMMAND(xrcredittime);
+	COMMAND(xrwindowsetup);
+
+	// tspit (Temple Island) external commands
+	COMMAND(xtexterior300_telescopedown);
+	COMMAND(xtexterior300_telescopeup);
+	COMMAND(xtisland390_covercombo);
+	COMMAND(xtatrusgivesbooks);
+	COMMAND(xtchotakesbook);
+	COMMAND(xthideinventory);
+	COMMAND(xt7500_checkmarbles);
+	COMMAND(xt7600_setupmarbles);
+	COMMAND(xt7800_setup);
+	COMMAND(xdrawmarbles);
+	COMMAND(xtakeit);
+	COMMAND(xtscpbtn);
+	COMMAND(xtisland4990_domecheck);
+	COMMAND(xtisland5056_opencard);
+	COMMAND(xtisland5056_resetsliders);
+	COMMAND(xtisland5056_slidermd);
+	COMMAND(xtisland5056_slidermw);
+	COMMAND(xtatboundary);
+	
+	// Common external commands
+	COMMAND(xflies);
+}
+
+void RivenExternal::runCommand(uint16 argc, uint16 *argv) {
+	Common::String externalCommandName = _vm->getName(ExternalCommandNames, argv[0]);
+		
+	for (uint16 i = 0; i < _externalCommands.size(); i++)
+		if (externalCommandName == _externalCommands[i]->desc) {
+			debug(0, "Running Riven External Command \'%s\'", externalCommandName.c_str());
+			(this->*(_externalCommands[i]->proc)) (argv[1], argv[1] ? argv + 2 : NULL);
+			return;
+		}
+		
+	error("Unknown external command \'%s\'", externalCommandName.c_str());
+}
+
+void RivenExternal::runDemoBoundaryDialog() {
+	GUI::MessageDialog dialog("This demo does not allow you\n"
+							  "to visit that part of Riven.");
+	dialog.runModal();
+}
+
+void RivenExternal::runEndGame(uint16 video) {
+	_vm->_sound->stopAllSLST();
+	_vm->_video->playMovieBlocking(video);
+	
+	// TODO: Play until the last frame and then run the credits
+	_vm->_gameOver = true;
+}
+
+// ------------------------------------------------------------------------------------
+// aspit (Main Menu, Books, Setup) external commands
+// ------------------------------------------------------------------------------------
+
+void RivenExternal::xastartupbtnhide(uint16 argc, uint16 *argv) {
+	// The original game hides the start/setup buttons depending on an ini entry. It's safe to ignore this command.
+}
+
+void RivenExternal::xasetupcomplete(uint16 argc, uint16 *argv) {
+	// The original game sets an ini entry to disable the setup button and use the start button only. It's safe to ignore this part of the command.
+	_vm->_sound->stopSound();
+	_vm->changeToCard(1);
+}
+
+void RivenExternal::xaatrusopenbook(uint16 argc, uint16 *argv) {
+	// Get the variable
+	uint32 page = *_vm->matchVarToString("aatruspage");
+	
+	// Set hotspots depending on the page
+	if (page == 1) {
+		_vm->_hotspots[1].enabled = false;
+		_vm->_hotspots[2].enabled = false;
+		_vm->_hotspots[3].enabled = true;
+	} else {
+		_vm->_hotspots[1].enabled = true;
+		_vm->_hotspots[2].enabled = true;
+		_vm->_hotspots[3].enabled = false;
+	}
+	
+	// Draw the image of the page
+	_vm->_gfx->drawPLST(page);
+}
+
+void RivenExternal::xaatrusbookback(uint16 argc, uint16 *argv) {
+	// Return to where we were before entering the book
+	_vm->changeToStack(*_vm->matchVarToString("returnstackid"));
+	_vm->changeToCard(*_vm->matchVarToString("returncardid"));
+}
+
+void RivenExternal::xaatrusbookprevpage(uint16 argc, uint16 *argv) {
+	// Get the page variable
+	uint32 *page = _vm->matchVarToString("aatruspage");
+	
+	// Decrement the page if it's not the first page
+	if (*page == 1)
+		return;
+	(*page)--;
+	
+	// TODO: Play the page turning sound
+	
+	// Now update the screen :)
+	_vm->_gfx->updateScreen();
+}
+
+void RivenExternal::xaatrusbooknextpage(uint16 argc, uint16 *argv) {
+	// Get the page variable
+	uint32 *page = _vm->matchVarToString("aatruspage");
+	
+	// Increment the page if it's not the last page
+	if (((_vm->getFeatures() & GF_DEMO) && *page == 6) || *page == 10)
+		return;
+	(*page)++;
+	
+	// TODO: Play the page turning sound
+	
+	// Now update the screen :)
+	_vm->_gfx->updateScreen();
+}
+
+void RivenExternal::xacathopenbook(uint16 argc, uint16 *argv) {
+	// Get the variable
+	uint32 page = *_vm->matchVarToString("acathpage");
+
+	// Set hotspots depending on the page
+	if (page == 1) {
+		_vm->_hotspots[1].enabled = false;
+		_vm->_hotspots[2].enabled = false;
+		_vm->_hotspots[3].enabled = true;
+	} else {
+		_vm->_hotspots[1].enabled = true;
+		_vm->_hotspots[2].enabled = true;
+		_vm->_hotspots[3].enabled = false;
+	}
+	
+	// Draw the image of the page
+	_vm->_gfx->drawPLST(page);
+	
+	// Draw the white page edges
+	if (page > 1 && page < 5)
+		_vm->_gfx->drawPLST(50);
+	else if (page > 5)
+		_vm->_gfx->drawPLST(51);
+	
+	if (page == 28) {
+		// TODO: Draw telescope combination
+	}
+}
+
+void RivenExternal::xacathbookback(uint16 argc, uint16 *argv) {
+	// Return to where we were before entering the book
+	_vm->changeToStack(*_vm->matchVarToString("returnstackid"));
+	_vm->changeToCard(*_vm->matchVarToString("returncardid"));
+}
+
+void RivenExternal::xacathbookprevpage(uint16 argc, uint16 *argv) {
+	// Get the variable
+	uint32 *page = _vm->matchVarToString("acathpage");
+	
+	// Increment the page if it's not the first page
+	if (*page == 1)
+		return;
+	(*page)--;
+	
+	// TODO: Play the page turning sound
+
+	// Now update the screen :)
+	_vm->_gfx->updateScreen();
+}
+
+void RivenExternal::xacathbooknextpage(uint16 argc, uint16 *argv) {
+	// Get the variable
+	uint32 *page = _vm->matchVarToString("acathpage");
+	
+	// Increment the page if it's not the last page
+	if (*page == 49)
+		return;
+	(*page)++;
+	
+	// TODO: Play the page turning sound
+	
+	// Now update the screen :)
+	_vm->_gfx->updateScreen();
+}
+
+void RivenExternal::xtrapbookback(uint16 argc, uint16 *argv) {
+	// Return to where we were before entering the book
+	_vm->changeToStack(*_vm->matchVarToString("returnstackid"));
+	_vm->changeToCard(*_vm->matchVarToString("returncardid"));
+}
+
+void RivenExternal::xatrapbookclose(uint16 argc, uint16 *argv) {
+	// Close the trap book
+	_vm->_hotspots[1].enabled = false;
+	_vm->_hotspots[2].enabled = false;
+	_vm->_hotspots[3].enabled = false;
+	_vm->_hotspots[4].enabled = true;
+	_vm->_gfx->drawPLST(3);
+	_vm->_gfx->updateScreen();
+}
+
+void RivenExternal::xatrapbookopen(uint16 argc, uint16 *argv) {
+	// Open the trap book
+	_vm->_hotspots[1].enabled = true;
+	_vm->_hotspots[2].enabled = true;
+	_vm->_hotspots[3].enabled = true;
+	_vm->_hotspots[4].enabled = false;
+	_vm->_gfx->drawPLST(1);
+	// TODO: Play movie
+	_vm->_gfx->updateScreen();
+}
+
+void RivenExternal::xarestoregame(uint16 argc, uint16 *argv) {
+	// Launch the load game dialog
+	_vm->runLoadDialog();
+}
+
+void RivenExternal::xadisablemenureturn(uint16 argc, uint16 *argv) {
+	// Dummy function -- implemented in Mohawk::go
+}
+
+void RivenExternal::xaenablemenureturn(uint16 argc, uint16 *argv) {
+	// Dummy function -- implemented in Mohawk::go
+}
+
+void RivenExternal::xalaunchbrowser(uint16 argc, uint16 *argv) {
+	// Well, we can't launch a browser for obvious reasons ;)
+	GUI::MessageDialog dialog("At this point, the Riven Demo would\n"
+							  "open up a web browser to bring you to\n"
+							  "the Riven website. ScummVM cannot do\n"
+							  "that. Visit the site on your own.");
+	dialog.runModal();
+}
+
+// ------------------------------------------------------------------------------------
+// bspit (Bookmaking Island) external commands
+// ------------------------------------------------------------------------------------
+
+void RivenExternal::xblabopenbook(uint16 argc, uint16 *argv) {
+	// Get the variable
+	uint32 page = *_vm->matchVarToString("blabbook");
+
+	// Draw the image of the page based on the blabbook variable
+	_vm->_gfx->drawPLST(page);
+	
+	// TODO: Draw the dome combo
+	if (page == 14) {
+		warning ("Need to draw dome combo");
+	}
+}
+
+void RivenExternal::xblabbookprevpage(uint16 argc, uint16 *argv) {
+	// Get the page variable
+	uint32 *page = _vm->matchVarToString("blabbook");
+	
+	// Decrement the page if it's not the first page
+	if (*page == 1)
+		return;
+	(*page)--;
+	
+	// Now update the screen :)
+	_vm->_gfx->updateScreen();
+}
+
+void RivenExternal::xblabbooknextpage(uint16 argc, uint16 *argv) {
+	// Get the page variable
+	uint32 *page = _vm->matchVarToString("blabbook");
+	
+	// Increment the page if it's not the last page
+	if (*page == 22)
+		return;
+	(*page)++;
+	
+	// Now update the screen :)
+	_vm->_gfx->updateScreen();
+}
+
+void RivenExternal::xsoundplug(uint16 argc, uint16 *argv) {
+	uint32 heat = *_vm->matchVarToString("bheat");
+	uint32 boilerInactive = *_vm->matchVarToString("bcratergg");
+	
+	if (heat != 0)
+		_vm->_sound->playSLST(1, _vm->getCurCard());
+	else if (boilerInactive != 0)
+		_vm->_sound->playSLST(2, _vm->getCurCard());
+	else
+		_vm->_sound->playSLST(3, _vm->getCurCard());
+}
+
+void RivenExternal::xbchangeboiler(uint16 argc, uint16 *argv) {
+	uint32 heat = *_vm->matchVarToString("bheat");
+	uint32 water = *_vm->matchVarToString("bblrwtr");
+	uint32 platform = *_vm->matchVarToString("bblrgrt");
+
+	if (argv[0] == 1) {
+		if (water == 0) {
+			if (platform == 0)
+				_vm->_video->activateMLST(10, _vm->getCurCard());
+			else
+				_vm->_video->activateMLST(12, _vm->getCurCard());
+		} else if (heat == 0) {
+			if (platform == 0)
+				_vm->_video->activateMLST(19, _vm->getCurCard());
+			else
+				_vm->_video->activateMLST(22, _vm->getCurCard());
+		} else {
+			if (platform == 0)
+				_vm->_video->activateMLST(13, _vm->getCurCard());
+			else
+				_vm->_video->activateMLST(16, _vm->getCurCard());
+		}
+	} else if (argv[0] == 2 && water != 0) {
+		if (heat == 0) {
+			if (platform == 0)
+				_vm->_video->activateMLST(20, _vm->getCurCard());
+			else
+				_vm->_video->activateMLST(23, _vm->getCurCard());
+		} else {
+			if (platform == 0)
+				_vm->_video->activateMLST(18, _vm->getCurCard());
+			else
+				_vm->_video->activateMLST(15, _vm->getCurCard());
+		}
+	} else if (argv[0] == 3) {
+		if (platform == 0) {
+			if (water == 0) {
+				_vm->_video->activateMLST(11, _vm->getCurCard());	
+			} else {
+				if (heat == 0)
+					_vm->_video->activateMLST(17, _vm->getCurCard());
+				else
+					_vm->_video->activateMLST(24, _vm->getCurCard());
+			}
+		} else {
+			if (water == 0) {
+				_vm->_video->activateMLST(9, _vm->getCurCard());	
+			} else {
+				if (heat == 0)
+					_vm->_video->activateMLST(14, _vm->getCurCard());
+				else
+					_vm->_video->activateMLST(21, _vm->getCurCard());
+			}
+		}
+	}
+	
+	if (argc > 1)
+		_vm->_sound->playSLST(argv[1], _vm->getCurCard());
+	else if (argv[0] == 2)
+		_vm->_sound->playSLST(1, _vm->getCurCard());
+	
+	_vm->_video->playMovie(11);
+}
+
+void RivenExternal::xbupdateboiler(uint16 argc, uint16 *argv) {
+	uint32 heat = *_vm->matchVarToString("bheat");
+	uint32 platform = *_vm->matchVarToString("bblrgrt");
+	
+	if (heat) {
+		if (platform == 0) {
+			_vm->_video->activateMLST(7, _vm->getCurCard());
+			// TODO: Play video (non-blocking)
+		} else {
+			_vm->_video->activateMLST(8, _vm->getCurCard());
+			// TODO: Play video (non-blocking)
+		}
+	} else {
+		// TODO: Stop MLST's 7 and 8
+	}
+	
+	_vm->changeToCard();
+}
+
+void RivenExternal::xbsettrap(uint16 argc, uint16 *argv) {
+	// TODO: Set the Ytram trap
+}
+
+void RivenExternal::xbcheckcatch(uint16 argc, uint16 *argv) {
+	// TODO: Check if we've caught a Ytram
+}
+
+void RivenExternal::xbait(uint16 argc, uint16 *argv) {	
+	// Set the cursor to the pellet
+	_vm->_gfx->changeCursor(kRivenPelletCursor);
+	
+	// Loop until the player lets go (or quits)
+	Common::Event event;
+	bool mouseDown = true;
+	while (mouseDown) {
+		while (_vm->_system->getEventManager()->pollEvent(event)) {
+			if (event.type == Common::EVENT_LBUTTONUP)
+				mouseDown = false;
+			else if (event.type == Common::EVENT_MOUSEMOVE)
+				_vm->_system->updateScreen();
+			else if (event.type == Common::EVENT_QUIT || event.type == Common::EVENT_RTL)
+				return;
+		}
+		
+		_vm->_system->delayMillis(10); // Take it easy on the CPU
+	}
+	
+	// Set back the cursor
+	_vm->_gfx->changeCursor(kRivenMainCursor);
+	
+	// Set the bait if we put it on the plate
+	if (_vm->_hotspots[9].rect.contains(_vm->_system->getEventManager()->getMousePos())) {
+		*_vm->matchVarToString("bbait") = 1;
+		_vm->_gfx->drawPLST(4);
+		_vm->_gfx->updateScreen();
+		_vm->_hotspots[3].enabled = false; // Disable bait hotspot
+		_vm->_hotspots[9].enabled = true; // Enable baitplate hotspot
+	}
+}
+
+void RivenExternal::xbfreeytram(uint16 argc, uint16 *argv) {
+	// TODO: Play a random Ytram movie
+}
+
+void RivenExternal::xbaitplate(uint16 argc, uint16 *argv) {
+	// Remove the pellet from the plate and put it in your hand
+	_vm->_gfx->drawPLST(3);
+	_vm->_gfx->updateScreen();
+	_vm->_gfx->changeCursor(kRivenPelletCursor);
+	
+	// Loop until the player lets go (or quits)
+	Common::Event event;
+	bool mouseDown = true;
+	while (mouseDown) {
+		while (_vm->_system->getEventManager()->pollEvent(event)) {
+			if (event.type == Common::EVENT_LBUTTONUP)
+				mouseDown = false;
+			else if (event.type == Common::EVENT_MOUSEMOVE)
+				_vm->_system->updateScreen();
+			else if (event.type == Common::EVENT_QUIT || event.type == Common::EVENT_RTL)
+				return;
+		}
+		
+		_vm->_system->delayMillis(10); // Take it easy on the CPU
+	}
+	
+	// Set back the cursor
+	_vm->_gfx->changeCursor(kRivenMainCursor);
+	
+	// Set the bait if we put it on the plate, remove otherwise
+	if (_vm->_hotspots[9].rect.contains(_vm->_system->getEventManager()->getMousePos())) {
+		*_vm->matchVarToString("bbait") = 1;
+		_vm->_gfx->drawPLST(4);
+		_vm->_gfx->updateScreen();
+		_vm->_hotspots[3].enabled = false; // Disable bait hotspot
+		_vm->_hotspots[9].enabled = true; // Enable baitplate hotspot
+	} else {
+		*_vm->matchVarToString("bbait") = 0;
+		_vm->_hotspots[3].enabled = true; // Enable bait hotspot
+		_vm->_hotspots[9].enabled = false; // Disable baitplate hotspot
+	}
+}
+
+void RivenExternal::xbisland190_opencard(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xbisland190_resetsliders(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xbisland190_slidermd(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xbisland190_slidermw(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xbscpbtn(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xbisland_domecheck(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xvalvecontrol(uint16 argc, uint16 *argv) {
+	// Get the variable for the valve
+	uint32 *valve = _vm->matchVarToString("bvalve");
+	
+	Common::Event event;
+	int changeX = 0;
+	int changeY = 0;
+	
+	// Set the cursor to the closed position
+	_vm->_gfx->changeCursor(2004);
+	_vm->_system->updateScreen();
+	
+	for (;;) {
+		while (_vm->_system->getEventManager()->pollEvent(event)) {
+			switch (event.type) {
+				case Common::EVENT_MOUSEMOVE:
+					changeX = event.mouse.x - _vm->_mousePos.x;
+					changeY = _vm->_mousePos.y - event.mouse.y;
+					_vm->_system->updateScreen();
+					break;
+				case Common::EVENT_LBUTTONUP:
+					// FIXME: These values for changes in x/y could be tweaked.
+					if (*valve == 0 && changeY <= -10) {
+						*valve = 1;
+						// TODO: Play movie
+						_vm->changeToCard(); // Refresh
+					} else if (*valve == 1) {
+						if (changeX >= 0 && changeY >= 10) {
+							*valve = 0;
+							// TODO: Play movie
+							_vm->changeToCard(); // Refresh
+						} else if (changeX <= -10 && changeY <= 10) {
+							*valve = 2;
+							// TODO: Play movie
+							_vm->changeToCard(); // Refresh
+						}
+					} else if (*valve == 2 && changeX >= 10) {
+						*valve = 1;
+						// TODO: Play movie
+						_vm->changeToCard(); // Refresh
+					}
+					return;
+				default:
+					break;
+			}
+		}
+		_vm->_system->delayMillis(10);
+	}
+}
+
+void RivenExternal::xbchipper(uint16 argc, uint16 *argv) {
+	// Why is this an external command....?
+	if (*_vm->matchVarToString("bvalve") == 2)
+		_vm->_video->playMovieBlocking(2);
+}
+
+// ------------------------------------------------------------------------------------
+// gspit (Garden Island) external commands
+// ------------------------------------------------------------------------------------
+
+void RivenExternal::xgresetpins(uint16 argc, uint16 *argv) {
+	// TODO: Map related
+}
+
+void RivenExternal::xgrotatepins(uint16 argc, uint16 *argv) {
+	// TODO: Map related
+}
+
+void RivenExternal::xgpincontrols(uint16 argc, uint16 *argv) {
+	// TODO: Map related
+}
+
+void RivenExternal::xgisland25_opencard(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xgisland25_resetsliders(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xgisland25_slidermd(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xgisland25_slidermw(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xgscpbtn(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xgisland1490_domecheck(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xgplateau3160_dopools(uint16 argc, uint16 *argv) {
+	// TODO: "Bubble" map related
+}
+
+void RivenExternal::xgwt200_scribetime(uint16 argc, uint16 *argv) {
+	// Get the current time
+	*_vm->matchVarToString("gscribetime") = _vm->_system->getMillis();
+}
+
+void RivenExternal::xgwt900_scribe(uint16 argc, uint16 *argv) {
+	uint32 *scribeVar = _vm->matchVarToString("gscribe");
+
+	if (*scribeVar == 1 && _vm->_system->getMillis() > *_vm->matchVarToString("gscribetime") + 40000)
+		*scribeVar = 2;
+}
+
+void RivenExternal::xgplaywhark(uint16 argc, uint16 *argv) {
+	// TODO: Whark response to using the lights
+}
+
+void RivenExternal::xgrviewer(uint16 argc, uint16 *argv) {
+	// TODO: Image viewer related
+}
+
+void RivenExternal::xgwharksnd(uint16 argc, uint16 *argv) {
+	// TODO: Image viewer related
+}
+
+void RivenExternal::xglview_prisonoff(uint16 argc, uint16 *argv) {
+	// TODO: Image viewer related
+}
+
+void RivenExternal::xglview_villageoff(uint16 argc, uint16 *argv) {
+	// TODO: Image viewer related
+}
+
+void RivenExternal::xglviewer(uint16 argc, uint16 *argv) {
+	// TODO: Image viewer related
+}
+
+void RivenExternal::xglview_prisonon(uint16 argc, uint16 *argv) {
+	// TODO: Image viewer related
+}
+
+void RivenExternal::xglview_villageon(uint16 argc, uint16 *argv) {
+	// TODO: Image viewer related
+}
+
+// ------------------------------------------------------------------------------------
+// jspit (Jungle Island) external commands
+// ------------------------------------------------------------------------------------
+
+void RivenExternal::xreseticons(uint16 argc, uint16 *argv) {
+	// Reset the icons when going to Tay (rspit)
+	*_vm->matchVarToString("jicons") = 0;
+	*_vm->matchVarToString("jiconorder") = 0;
+	*_vm->matchVarToString("jrbook") = 0;
+}
+
+// Count up how many icons are pressed
+static byte countDepressedIcons(uint32 iconOrderVar) {
+	if (iconOrderVar >= (1 << 20))
+		return 5;
+	else if (iconOrderVar >= (1 << 15))
+		return 4;
+	else if (iconOrderVar >= (1 << 10))
+		return 3;
+	else if (iconOrderVar >= (1 << 5))
+		return 2;
+	else if (iconOrderVar >= (1 << 1))
+		return 1;
+	else
+		return 0; 
+}
+
+void RivenExternal::xicon(uint16 argc, uint16 *argv) {
+	// Set atemp as the status of whether or not the icon can be depressed.
+	if (*_vm->matchVarToString("jicons") & (1 << (argv[0] - 1))) {
+		// This icon is depressed. Allow depression only if the last depressed icon was this one.
+		if ((*_vm->matchVarToString("jiconorder") & 0x1f) == argv[0])
+			*_vm->matchVarToString("atemp") = 1;
+		else
+			*_vm->matchVarToString("atemp") = 2;
+	} else
+		*_vm->matchVarToString("atemp") = 0;
+}
+
+void RivenExternal::xcheckicons(uint16 argc, uint16 *argv) {
+	// Reset the icons if this is the sixth icon
+	uint32 *iconOrderVar = _vm->matchVarToString("jiconorder");
+	if (countDepressedIcons(*iconOrderVar) == 5) {
+		*iconOrderVar = 0;
+		*_vm->matchVarToString("jicons") = 0;
+		_vm->_sound->playSound(46, false);
+	}
+}
+
+void RivenExternal::xtoggleicon(uint16 argc, uint16 *argv) {
+	// Get the variables
+	uint32 *iconsDepressed = _vm->matchVarToString("jicons");
+	uint32 *iconOrderVar = _vm->matchVarToString("jiconorder");
+	
+	if (*iconsDepressed & (1 << (argv[0] - 1))) {
+		// The icon is depressed, now unpress it
+		*iconsDepressed &= ~(1 << (argv[0] - 1));
+		*iconOrderVar >>= 5;
+	} else {
+		// The icon is not depressed, now depress it
+		*iconsDepressed |= 1 << (argv[0] - 1);
+		*iconOrderVar = (*iconOrderVar << 5) + argv[0];
+	}
+	
+	// Check if the puzzle is complete now and assign 1 to jrbook if the puzzle is complete.
+	if (*iconOrderVar == *_vm->matchVarToString("jiconcorrectorder"))
+		*_vm->matchVarToString("jrbook") = 1;
+}
+
+void RivenExternal::xjtunnel103_pictfix(uint16 argc, uint16 *argv) {
+	// Get the jicons variable which contains which of the stones are depressed in the rebel tunnel puzzle
+	uint32 iconsDepressed = *_vm->matchVarToString("jicons");
+	
+	// Now, draw which icons are depressed based on the bits of the variable
+	if (iconsDepressed & (1 << 0))
+		_vm->_gfx->drawPLST(2);
+	if (iconsDepressed & (1 << 1))
+		_vm->_gfx->drawPLST(3);
+	if (iconsDepressed & (1 << 2))
+		_vm->_gfx->drawPLST(4);
+	if (iconsDepressed & (1 << 3))
+		_vm->_gfx->drawPLST(5);
+	if (iconsDepressed & (1 << 22))
+		_vm->_gfx->drawPLST(6);
+	if (iconsDepressed & (1 << 23))
+		_vm->_gfx->drawPLST(7);
+	if (iconsDepressed & (1 << 24))
+		_vm->_gfx->drawPLST(8);
+}
+
+void RivenExternal::xjtunnel104_pictfix(uint16 argc, uint16 *argv) {
+	// Get the jicons variable which contains which of the stones are depressed in the rebel tunnel puzzle
+	uint32 iconsDepressed = *_vm->matchVarToString("jicons");
+	
+	// Now, draw which icons are depressed based on the bits of the variable
+	if (iconsDepressed & (1 << 9))
+		_vm->_gfx->drawPLST(2);
+	if (iconsDepressed & (1 << 10))
+		_vm->_gfx->drawPLST(3);
+	if (iconsDepressed & (1 << 11))
+		_vm->_gfx->drawPLST(4);
+	if (iconsDepressed & (1 << 12))
+		_vm->_gfx->drawPLST(5);
+	if (iconsDepressed & (1 << 13))
+		_vm->_gfx->drawPLST(6);
+	if (iconsDepressed & (1 << 14))
+		_vm->_gfx->drawPLST(7);
+	if (iconsDepressed & (1 << 15))
+		_vm->_gfx->drawPLST(8);
+	if (iconsDepressed & (1 << 16))
+		_vm->_gfx->drawPLST(9);
+}
+
+void RivenExternal::xjtunnel105_pictfix(uint16 argc, uint16 *argv) {
+	// Get the jicons variable which contains which of the stones are depressed in the rebel tunnel puzzle
+	uint32 iconsDepressed = *_vm->matchVarToString("jicons");
+	
+	// Now, draw which icons are depressed based on the bits of the variable
+	if (iconsDepressed & (1 << 3))
+		_vm->_gfx->drawPLST(2);
+	if (iconsDepressed & (1 << 4))
+		_vm->_gfx->drawPLST(3);
+	if (iconsDepressed & (1 << 5))
+		_vm->_gfx->drawPLST(4);
+	if (iconsDepressed & (1 << 6))
+		_vm->_gfx->drawPLST(5);
+	if (iconsDepressed & (1 << 7))
+		_vm->_gfx->drawPLST(6);
+	if (iconsDepressed & (1 << 8))
+		_vm->_gfx->drawPLST(7);
+	if (iconsDepressed & (1 << 9))
+		_vm->_gfx->drawPLST(8);
+}
+
+void RivenExternal::xjtunnel106_pictfix(uint16 argc, uint16 *argv) {
+	// Get the jicons variable which contains which of the stones are depressed in the rebel tunnel puzzle
+	uint32 iconsDepressed = *_vm->matchVarToString("jicons");
+	
+	// Now, draw which icons are depressed based on the bits of the variable
+	if (iconsDepressed & (1 << 16))
+		_vm->_gfx->drawPLST(2);
+	if (iconsDepressed & (1 << 17))
+		_vm->_gfx->drawPLST(3);
+	if (iconsDepressed & (1 << 18))
+		_vm->_gfx->drawPLST(4);
+	if (iconsDepressed & (1 << 19))
+		_vm->_gfx->drawPLST(5);
+	if (iconsDepressed & (1 << 20))
+		_vm->_gfx->drawPLST(6);
+	if (iconsDepressed & (1 << 21))
+		_vm->_gfx->drawPLST(7);
+	if (iconsDepressed & (1 << 22))
+		_vm->_gfx->drawPLST(8);
+	if (iconsDepressed & (1 << 23))
+		_vm->_gfx->drawPLST(9);
+}
+
+void RivenExternal::xvga1300_carriage(uint16 argc, uint16 *argv) {
+	// TODO: This function is supposed to do a lot more, something like this (pseudocode):
+	
+	// Show level pull movie
+	// Set transition up
+	// Change to up card
+	// Show movie of carriage coming down
+	// Set transition down
+	// Change back to card 276
+	// Show movie of carriage coming down
+	// if jgallows == 0
+	//	Set up timer
+	// 	Enter new input loop
+	//	if you click within the time
+	//		move forward
+	//		set transition right
+	//		change to card right
+	//		show movie of ascending
+	//		change to card 263
+	//	else
+	//		show movie of carriage ascending only
+	// else
+	//	show movie of carriage ascending only
+	
+	
+	// For now, if the gallows base is closed, assume ascension and move to that card.
+	if (*_vm->matchVarToString("jgallows") == 0)
+		_vm->changeToCard(_vm->matchRMAPToCard(0x17167));
+}
+
+void RivenExternal::xjdome25_resetsliders(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xjdome25_slidermd(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xjdome25_slidermw(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xjscpbtn(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xjisland3500_domecheck(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+int RivenExternal::jspitElevatorLoop() {
+	Common::Event event;
+	int changeLevel = 0;
+	
+	_vm->_gfx->changeCursor(2004);
+	_vm->_system->updateScreen();
+	for (;;) {
+		while (_vm->_system->getEventManager()->pollEvent(event)) {
+			switch (event.type) {
+				case Common::EVENT_MOUSEMOVE:
+					if (event.mouse.y > (_vm->_mousePos.y + 10)) {
+						changeLevel = -1;
+					} else if (event.mouse.y < (_vm->_mousePos.y - 10)) {
+						changeLevel = 1;
+					} else {
+						changeLevel = 0;
+					}
+					_vm->_system->updateScreen();
+					break;
+				case Common::EVENT_LBUTTONUP:
+					_vm->_gfx->changeCursor(kRivenMainCursor);
+					_vm->_system->updateScreen();
+					return changeLevel;
+				default:
+					break;
+			}
+		}
+		_vm->_system->delayMillis(10);
+	}	
+}
+
+void RivenExternal::xhandlecontrolup(uint16 argc, uint16 *argv) {	
+	int changeLevel = jspitElevatorLoop();
+	
+	if (changeLevel == -1) {
+		// TODO: Run movie
+		_vm->changeToCard(_vm->matchRMAPToCard(0x1e374));
+	}
+}
+
+void RivenExternal::xhandlecontroldown(uint16 argc, uint16 *argv) {	
+	int changeLevel = jspitElevatorLoop();
+	
+	if (changeLevel == 1) {
+		// TODO: Run movie
+		_vm->changeToCard(_vm->matchRMAPToCard(0x1e374));
+	}
+}
+
+void RivenExternal::xhandlecontrolmid(uint16 argc, uint16 *argv) {
+	int changeLevel = jspitElevatorLoop();
+	
+	if (changeLevel == 1) {
+		// TODO: Run movie
+		_vm->changeToCard(_vm->matchRMAPToCard(0x1e597));
+	} else if (changeLevel == -1) {
+		// TODO: Run movie
+		_vm->changeToCard(_vm->matchRMAPToCard(0x1e29c));
+	}
+}
+
+void RivenExternal::xjplaybeetle_550(uint16 argc, uint16 *argv) {
+	// Play a beetle animation 25% of the time
+	*_vm->matchVarToString("jplaybeetle") = (_rnd->getRandomNumberRng(0, 3) == 0) ? 1 : 0;
+}
+
+void RivenExternal::xjplaybeetle_600(uint16 argc, uint16 *argv) {
+	// Play a beetle animation 25% of the time
+	*_vm->matchVarToString("jplaybeetle") = (_rnd->getRandomNumberRng(0, 3) == 0) ? 1 : 0;
+}
+
+void RivenExternal::xjplaybeetle_950(uint16 argc, uint16 *argv) {
+	// Play a beetle animation 25% of the time
+	*_vm->matchVarToString("jplaybeetle") = (_rnd->getRandomNumberRng(0, 3) == 0) ? 1 : 0;
+}
+
+void RivenExternal::xjplaybeetle_1050(uint16 argc, uint16 *argv) {
+	// Play a beetle animation 25% of the time
+	*_vm->matchVarToString("jplaybeetle") = (_rnd->getRandomNumberRng(0, 3) == 0) ? 1 : 0;
+}
+
+void RivenExternal::xjplaybeetle_1450(uint16 argc, uint16 *argv) {
+	// Play a beetle animation 25% of the time as long as the girl is not present
+	*_vm->matchVarToString("jplaybeetle") = (_rnd->getRandomNumberRng(0, 3) == 0 && *_vm->matchVarToString("jgirl") != 1) ? 1 : 0;
+}
+
+void RivenExternal::xjlagoon700_alert(uint16 argc, uint16 *argv) {
+	// TODO: Sunner related
+}
+
+void RivenExternal::xjlagoon800_alert(uint16 argc, uint16 *argv) {
+	// TODO: Sunner related
+}
+
+void RivenExternal::xjlagoon1500_alert(uint16 argc, uint16 *argv) {
+	// Have the sunners move a bit as you get closer ;)
+	uint32 *sunners = _vm->matchVarToString("jsunners");
+	if (*sunners == 0) {
+		_vm->_video->playMovieBlocking(3);
+	} else if (*sunners == 1) {
+		_vm->_video->playMovieBlocking(2);
+		*sunners = 2;
+	}
+}
+
+void RivenExternal::xschool280_playwhark(uint16 argc, uint16 *argv) {
+	// TODO: The "monstrous" whark puzzle that teaches the number system
+}
+
+void RivenExternal::xjatboundary(uint16 argc, uint16 *argv) {
+	runDemoBoundaryDialog();
+}
+
+// ------------------------------------------------------------------------------------
+// ospit (Gehn's Office) external commands
+// ------------------------------------------------------------------------------------
+
+void RivenExternal::xorollcredittime(uint16 argc, uint16 *argv) {
+	// WORKAROUND: The special change stuff only handles one destination and it would
+	// be messy to modify the way that currently works. If we use the trap book on Tay,
+	// we should be using the Tay end game sequences.
+	if (*_vm->matchVarToString("returnstackid") == rspit) {
+		_vm->changeToStack(rspit);
+		_vm->changeToCard(2);
+		return;
+	}
+
+	// You used the trap book... why? What were you thinking?
+	uint32 *gehnState = _vm->matchVarToString("agehn");
+	
+	if (*gehnState == 0)		// Gehn who?
+		runEndGame(1);
+	else if (*gehnState == 4)	// You freed him? Are you kidding me?
+		runEndGame(2);
+	else						// You already spoke with Gehn. What were you thinking?
+		runEndGame(3);
+}
+
+void RivenExternal::xbookclick(uint16 argc, uint16 *argv) {
+	// TODO: This fun external command is probably one of the most complex,
+	// up there with the marble puzzle ones. It involves so much... Basically,
+	// it's playing when Gehn holds the trap book up to you and you have to
+	// click on the book (hence the name of the function). Yeah, not fun.
+	// Lots of timing stuff needs to be done for a couple videos.
+}
+
+void RivenExternal::xooffice30_closebook(uint16 argc, uint16 *argv) {
+	// Close the blank linking book if it's open
+	uint32 *book = _vm->matchVarToString("odeskbook");
+	if (*book != 1)
+		return;
+
+	// Set the variable to be "closed"
+	*book = 0;
+
+	// Play the movie
+	_vm->_video->playMovieBlocking(1);
+
+	// Set the hotspots into their correct states
+	_vm->_hotspots[2].enabled = false;
+	_vm->_hotspots[5].enabled = false;
+	_vm->_hotspots[6].enabled = true;
+
+	// We now need to draw PLST 1 and refresh, but PLST 1 is
+	// drawn when refreshing anyway, so don't worry about that.
+	_vm->changeToCard();
+}
+
+void RivenExternal::xobedroom5_closedrawer(uint16 argc, uint16 *argv) {
+	// Close the drawer if open when clicking on the journal.
+	_vm->_video->playMovieBlocking(2);
+	*_vm->matchVarToString("ostanddrawer") = 0;
+}
+
+void RivenExternal::xogehnopenbook(uint16 argc, uint16 *argv) {
+	_vm->_gfx->drawPLST(*_vm->matchVarToString("ogehnpage"));
+}
+
+void RivenExternal::xogehnbookprevpage(uint16 argc, uint16 *argv) {
+	// Get the page variable
+	uint32 *page = _vm->matchVarToString("ogehnpage");
+	
+	// Decrement the page if it's not the first page
+	if (*page == 1)
+		return;
+	(*page)--;
+	
+	// TODO: Play the page turning sound
+	
+	// Now update the screen :)
+	_vm->_gfx->updateScreen();
+}
+
+void RivenExternal::xogehnbooknextpage(uint16 argc, uint16 *argv) {
+	// Get the page variable
+	uint32 *page = _vm->matchVarToString("ogehnpage");
+	
+	// Increment the page if it's not the last page
+	if (*page == 13)
+		return;
+	(*page)++;
+	
+	// TODO: Play the page turning sound
+	
+	// Now update the screen :)
+	_vm->_gfx->updateScreen();
+}
+
+void RivenExternal::xgwatch(uint16 argc, uint16 *argv) {
+	// TODO: Plays the prison combo on the watch
+}
+
+// ------------------------------------------------------------------------------------
+// pspit (Prison Island) external commands
+// ------------------------------------------------------------------------------------
+
+// Yeah, none of these are done yet :P
+
+void RivenExternal::xpisland990_elevcombo(uint16 argc, uint16 *argv) {
+	// TODO: Elevator combo check
+}
+
+void RivenExternal::xpscpbtn(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xpisland290_domecheck(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xpisland25_opencard(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xpisland25_resetsliders(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xpisland25_slidermd(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xpisland25_slidermw(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+// ------------------------------------------------------------------------------------
+// rspit (Rebel Age) external commands
+// ------------------------------------------------------------------------------------
+
+void RivenExternal::xrcredittime(uint16 argc, uint16 *argv) {
+	// Nice going, you used the trap book on Tay.
+	
+	// The game chooses what ending based on agehn for us,
+	// so we just have to play the video and credits.
+	// For the record, when agehn == 4, Gehn will thank you for
+	// showing him the rebel age and then leave you to die.
+	// Otherwise, the rebels burn the book. Epic fail either way.
+	runEndGame(1);
+}
+
+void RivenExternal::xrshowinventory(uint16 argc, uint16 *argv) {
+	// Give the trap book and Catherine's journal to the player
+	*_vm->matchVarToString("atrapbook") = 1;
+	*_vm->matchVarToString("acathbook") = 1;
+	_vm->_gfx->showInventory();
+}
+
+void RivenExternal::xrhideinventory(uint16 argc, uint16 *argv) {
+	_vm->_gfx->hideInventory();
+}
+
+void RivenExternal::xrwindowsetup(uint16 argc, uint16 *argv) {
+	// TODO: Randomizing what effect happens when you look out into the middle of Tay (useless! :P)
+}
+
+// ------------------------------------------------------------------------------------
+// tspit (Temple Island) external commands
+// ------------------------------------------------------------------------------------
+
+void RivenExternal::xtexterior300_telescopedown(uint16 argc, uint16 *argv) {
+	// First, show the button movie
+	_vm->_video->playMovieBlocking(3);
+
+	// Don't do anything else if the telescope power is off
+	if (*_vm->matchVarToString("ttelevalve") == 0)
+		return;
+
+	uint32 *telescopePos = _vm->matchVarToString("ttelescope");
+	uint32 *telescopeCover = _vm->matchVarToString("ttelecover");
+
+	if (*telescopePos == 1) {
+		// We're at the bottom, which means one of two things can happen...
+		if (*telescopeCover == 1 && *_vm->matchVarToString("ttelepin") == 1) {
+			// ...if the cover is open and the pin is up, the game is now over.
+			if (*_vm->matchVarToString("pcage") == 2) {
+				// The best ending: Catherine is free, Gehn is trapped, Atrus comes to rescue you.
+				// And now we fall back to Earth... all the way...
+				warning("xtexterior300_telescopedown: Good ending");
+				_vm->_video->activateMLST(8, _vm->getCurCard());
+				runEndGame(8);
+			} else if (*_vm->matchVarToString("agehn") == 4) {
+				// The ok ending: Catherine is still trapped, Gehn is trapped, Atrus comes to rescue you.
+				// Nice going! Catherine and the islanders are all dead now! Just go back to your home...
+				warning("xtexterior300_telescopedown: OK ending");
+				_vm->_video->activateMLST(9, _vm->getCurCard());
+				runEndGame(9);
+			} else if (*_vm->matchVarToString("atrapbook") == 1) {
+				// The bad ending: Catherine is trapped, Gehn is free, Atrus gets shot by Gehn,
+				// And then you get shot by Cho. Nice going! Catherine and the islanders are dead
+				// and you have just set Gehn free from Riven, not to mention you're dead.
+				warning("xtexterior300_telescopedown: Bad ending");
+				_vm->_video->activateMLST(10, _vm->getCurCard());
+				runEndGame(10);
+			} else {
+				// The impossible ending: You don't have Catherine's journal and yet you were somehow
+				// able to open the hatch on the telescope. The game provides an ending for those who
+				// cheat, load a saved game with the combo, or just guess the telescope combo. Atrus
+				// doesn't come and you just fall into the fissure.
+				warning("xtexterior300_telescopedown: Wtf ending");
+				_vm->_video->activateMLST(11, _vm->getCurCard());
+				runEndGame(11);
+			}
+		} else {
+			// ...the telescope can't move down anymore.
+			// TODO: Play sound
+		}
+	} else {
+		// We're not at the bottom, and we can move down again
+		
+		// TODO: Down movie, it involves playing a chunk of a movie
+		
+		// Now move the telescope down a position and refresh
+		*telescopePos -= 1;
+		_vm->changeToCard();
+	}
+}
+
+void RivenExternal::xtexterior300_telescopeup(uint16 argc, uint16 *argv) {
+	// First, show the button movie
+	_vm->_video->playMovieBlocking(3);
+
+	// Don't do anything else if the telescope power is off
+	if (*_vm->matchVarToString("ttelevalve") == 0)
+		return;
+
+	uint32 *telescopePos = _vm->matchVarToString("ttelescope");
+
+	// Check if we can't move up anymore
+	if (*telescopePos == 5) {
+		// TODO: Play sound
+		return;
+	}
+
+	// TODO: Up movie, it involves playing a chunk of a movie
+	
+	// Now move the telescope up a position and refresh
+	*telescopePos += 1;
+	_vm->changeToCard();
+}
+
+void RivenExternal::xtisland390_covercombo(uint16 argc, uint16 *argv) {
+	// Called when clicking the telescope cover buttons. button is the button number (1...5).
+	uint32 *pressedButtons = _vm->matchVarToString("tcovercombo");
+	
+	// We pressed a button! Yay! Add it to the queue.
+	*pressedButtons *= 10;
+	*pressedButtons += argv[0];
+	
+	if (*pressedButtons == *_vm->matchVarToString("tcorrectorder")) {
+		_vm->_hotspots[9].enabled = true;
+	} else {
+		_vm->_hotspots[9].enabled = false;
+		
+		// Set the buttons to the last one pressed if we've
+		// pressed more than 5 buttons.
+		if (*pressedButtons > 55555)
+			*pressedButtons = argv[0];
+	}
+}
+
+// Atrus' Journal and Trap Book are added to inventory
+void RivenExternal::xtatrusgivesbooks(uint16 argc, uint16 *argv) {
+	// Give the player Atrus' Journal and the Trap book
+	*_vm->matchVarToString("aatrusbook") = 1;
+	*_vm->matchVarToString("atrapbook") = 1;
+	
+	// Randomize the telescope combination
+	uint32 *teleCombo = _vm->matchVarToString("tcorrectorder");
+	for (byte i = 0; i < 5; i++) {
+		*teleCombo *= 10;
+		*teleCombo += _rnd->getRandomNumberRng(1, 5);
+	}
+	
+	// TODO: Randomize Dome Combination
+}
+
+// Trap Book is removed from inventory
+void RivenExternal::xtchotakesbook(uint16 argc, uint16 *argv) {
+	// And now Cho takes the trap book. Sure, this isn't strictly
+	// necessary to add and them remove the trap book... but it
+	// seems better to do this ;)
+	*_vm->matchVarToString("atrapbook") = 0;
+}
+
+void RivenExternal::xthideinventory(uint16 argc, uint16 *argv) {
+	_vm->_gfx->hideInventory();
+}
+
+void RivenExternal::xt7500_checkmarbles(uint16 argc, uint16 *argv) {
+	// TODO: Lots of stuff to do here, eventually we have to check each individual
+	// marble position and set apower based on that. The game handles the video playing
+	// so we don't have to. For the purposes of making the game progress further, we'll
+	// just turn the power on for now. 
+	*_vm->matchVarToString("apower") = 1;
+}
+
+void RivenExternal::xt7600_setupmarbles(uint16 argc, uint16 *argv) {
+	// TODO: Marble puzzle related
+}
+
+void RivenExternal::xt7800_setup(uint16 argc, uint16 *argv) {
+	// TODO: Marble puzzle related
+}
+
+void RivenExternal::xdrawmarbles(uint16 argc, uint16 *argv) {
+	// TODO: Marble puzzle related
+}
+
+void RivenExternal::xtakeit(uint16 argc, uint16 *argv) {
+	// TODO: Marble puzzle related
+}
+
+void RivenExternal::xtscpbtn(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xtisland4990_domecheck(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xtisland5056_opencard(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xtisland5056_resetsliders(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xtisland5056_slidermd(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xtisland5056_slidermw(uint16 argc, uint16 *argv) {
+	// TODO: Dome related
+}
+
+void RivenExternal::xtatboundary(uint16 argc, uint16 *argv) {
+	runDemoBoundaryDialog();
+}
+
+// ------------------------------------------------------------------------------------
+// Common external commands
+// ------------------------------------------------------------------------------------
+
+void RivenExternal::xflies(uint16 argc, uint16 *argv) {
+	// TODO: Activate the "flies" effect
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/riven_external.h b/engines/mohawk/riven_external.h
new file mode 100644
index 0000000000..b3b9025d74
--- /dev/null
+++ b/engines/mohawk/riven_external.h
@@ -0,0 +1,252 @@
+/* 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$
+ * $Id$
+ *
+ */
+ 
+#ifndef RIVEN_EXTERNAL_H
+#define RIVEN_EXTERNAL_H
+
+#include "mohawk/riven.h"
+
+namespace Mohawk {
+
+#define COMMAND(x) _externalCommands.push_back(new RivenExternalCmd(#x, &RivenExternal::x))
+
+class RivenExternal {
+public:
+	RivenExternal(MohawkEngine_Riven *vm);
+	~RivenExternal();
+	
+	void runCommand(uint16 argc, uint16 *argv);
+	
+private:
+	MohawkEngine_Riven *_vm;
+	Common::RandomSource *_rnd;
+
+	typedef void (RivenExternal::*ExternalCmd)(uint16 argc, uint16 *argv);
+
+	struct RivenExternalCmd {
+		RivenExternalCmd(const char *d, ExternalCmd p) : desc(d), proc(p) {}
+		const char *desc;
+		ExternalCmd proc;
+	};
+	
+	Common::Array<RivenExternalCmd*> _externalCommands;
+	void setupCommands();
+	
+	// Supplementary Functions
+	int jspitElevatorLoop();
+	void runDemoBoundaryDialog();
+	void runEndGame(uint16 video);
+
+	// -----------------------------------------------------
+	// aspit (Main Menu, Books, Setup) external commands
+	// Main Menu
+	void xastartupbtnhide(uint16 argc, uint16 *argv);
+	void xasetupcomplete(uint16 argc, uint16 *argv);
+	// Atrus' Journal
+	void xaatrusopenbook(uint16 argc, uint16 *argv);
+	void xaatrusbookback(uint16 argc, uint16 *argv);
+	void xaatrusbookprevpage(uint16 argc, uint16 *argv);
+	void xaatrusbooknextpage(uint16 argc, uint16 *argv);
+	// Catherine's Journal
+	void xacathopenbook(uint16 argc, uint16 *argv);
+	void xacathbookback(uint16 argc, uint16 *argv);
+	void xacathbookprevpage(uint16 argc, uint16 *argv);
+	void xacathbooknextpage(uint16 argc, uint16 *argv);
+	// Trap Book
+	void xtrapbookback(uint16 argc, uint16 *argv);
+	void xatrapbookclose(uint16 argc, uint16 *argv);
+	void xatrapbookopen(uint16 argc, uint16 *argv);	
+	// aspit DVD-specific commands
+	void xarestoregame(uint16 argc, uint16 *argv);
+	// aspit Demo-specific commands
+	void xadisablemenureturn(uint16 argc, uint16 *argv);
+	void xaenablemenureturn(uint16 argc, uint16 *argv);
+	void xalaunchbrowser(uint16 argc, uint16 *argv);
+
+	// -----------------------------------------------------
+	// bspit (Boiler Island) external commands
+	// Gehn's Lab Journal
+	void xblabopenbook(uint16 argc, uint16 *argv);
+	void xblabbooknextpage(uint16 argc, uint16 *argv);
+	void xblabbookprevpage(uint16 argc, uint16 *argv);
+	// Boiler Puzzle
+	void xsoundplug(uint16 argc, uint16 *argv);
+	void xbchangeboiler(uint16 argc, uint16 *argv);
+	void xbupdateboiler(uint16 argc, uint16 *argv);
+	// Frog Trap
+	void xbsettrap(uint16 argc, uint16 *argv);
+	void xbcheckcatch(uint16 argc, uint16 *argv);
+	void xbait(uint16 argc, uint16 *argv);
+	void xbfreeytram(uint16 argc, uint16 *argv);
+	void xbaitplate(uint16 argc, uint16 *argv);
+	// Dome
+	void xbisland190_opencard(uint16 argc, uint16 *argv);
+	void xbisland190_resetsliders(uint16 argc, uint16 *argv);	
+	void xbisland190_slidermd(uint16 argc, uint16 *argv);
+	void xbisland190_slidermw(uint16 argc, uint16 *argv);	
+	void xbscpbtn(uint16 argc, uint16 *argv);
+	void xbisland_domecheck(uint16 argc, uint16 *argv);	
+	// Water Control
+	void xvalvecontrol(uint16 argc, uint16 *argv);
+	// Run the Wood Chipper
+	void xbchipper(uint16 argc, uint16 *argv);	
+
+	// -----------------------------------------------------
+	// gspit (Garden Island) external commands
+	// Pins
+	void xgresetpins(uint16 argc, uint16 *argv);
+	void xgrotatepins(uint16 argc, uint16 *argv);
+	void xgpincontrols(uint16 argc, uint16 *argv);
+	// Dome
+	void xgisland25_opencard(uint16 argc, uint16 *argv);
+	void xgisland25_resetsliders(uint16 argc, uint16 *argv);
+	void xgisland25_slidermd(uint16 argc, uint16 *argv);
+	void xgisland25_slidermw(uint16 argc, uint16 *argv);
+	void xgscpbtn(uint16 argc, uint16 *argv);
+	void xgisland1490_domecheck(uint16 argc, uint16 *argv);
+	// Mapping
+	void xgplateau3160_dopools(uint16 argc, uint16 *argv);
+	// Scribe Taking the Tram
+	void xgwt200_scribetime(uint16 argc, uint16 *argv);
+	void xgwt900_scribe(uint16 argc, uint16 *argv);
+	// Periscope/Prison Viewer
+	void xgplaywhark(uint16 argc, uint16 *argv);
+	void xgrviewer(uint16 argc, uint16 *argv);
+	void xgwharksnd(uint16 argc, uint16 *argv);
+	void xglview_prisonoff(uint16 argc, uint16 *argv);
+	void xglview_villageoff(uint16 argc, uint16 *argv);
+	void xglviewer(uint16 argc, uint16 *argv);
+	void xglview_prisonon(uint16 argc, uint16 *argv);
+	void xglview_villageon(uint16 argc, uint16 *argv);
+
+	// -----------------------------------------------------
+	// jspit (Jungle Island) external commands
+	// Rebel Tunnel Puzzle
+	void xreseticons(uint16 argc, uint16 *argv);
+	void xicon(uint16 argc, uint16 *argv);
+	void xcheckicons(uint16 argc, uint16 *argv);
+	void xtoggleicon(uint16 argc, uint16 *argv);
+	void xjtunnel103_pictfix(uint16 argc, uint16 *argv);
+	void xjtunnel104_pictfix(uint16 argc, uint16 *argv);
+	void xjtunnel105_pictfix(uint16 argc, uint16 *argv);
+	void xjtunnel106_pictfix(uint16 argc, uint16 *argv);
+	// Lower the gallows carriage
+	void xvga1300_carriage(uint16 argc, uint16 *argv);
+	// Dome
+	void xjdome25_resetsliders(uint16 argc, uint16 *argv);
+	void xjdome25_slidermd(uint16 argc, uint16 *argv);
+	void xjdome25_slidermw(uint16 argc, uint16 *argv);
+	void xjscpbtn(uint16 argc, uint16 *argv);
+	void xjisland3500_domecheck(uint16 argc, uint16 *argv);
+	// Whark Elevator
+	void xhandlecontroldown(uint16 argc, uint16 *argv);
+	void xhandlecontrolmid(uint16 argc, uint16 *argv);
+	void xhandlecontrolup(uint16 argc, uint16 *argv);
+	// Beetle
+	void xjplaybeetle_550(uint16 argc, uint16 *argv);
+	void xjplaybeetle_600(uint16 argc, uint16 *argv);
+	void xjplaybeetle_950(uint16 argc, uint16 *argv);
+	void xjplaybeetle_1050(uint16 argc, uint16 *argv);
+	void xjplaybeetle_1450(uint16 argc, uint16 *argv);
+	// Creatures in the Lagoon
+	void xjlagoon700_alert(uint16 argc, uint16 *argv);
+	void xjlagoon800_alert(uint16 argc, uint16 *argv);
+	void xjlagoon1500_alert(uint16 argc, uint16 *argv);
+	// Play the Whark Game
+	void xschool280_playwhark(uint16 argc, uint16 *argv);
+	// jspit Demo-specific commands
+	void xjatboundary(uint16 argc, uint16 *argv);
+
+	// -----------------------------------------------------
+	// ospit (233rd Age / Gehn's Office) external commands
+	// Death!
+	void xorollcredittime(uint16 argc, uint16 *argv);
+	// Trap Book Puzzle
+	void xbookclick(uint16 argc, uint16 *argv); // Four params -- movie_sref, start_time, end_time, u0
+	// Blank Linking Book
+	void xooffice30_closebook(uint16 argc, uint16 *argv);
+	// Gehn's Journal
+    void xobedroom5_closedrawer(uint16 argc, uint16 *argv);
+    void xogehnopenbook(uint16 argc, uint16 *argv);
+    void xogehnbookprevpage(uint16 argc, uint16 *argv);
+    void xogehnbooknextpage(uint16 argc, uint16 *argv);
+	// Elevator Combination
+    void xgwatch(uint16 argc, uint16 *argv);
+
+	// -----------------------------------------------------
+	// pspit (Prison Island) external commands
+	// Prison Elevator
+	void xpisland990_elevcombo(uint16 argc, uint16 *argv);	// Param1: button
+	// Dome
+	void xpscpbtn(uint16 argc, uint16 *argv);	
+	void xpisland290_domecheck(uint16 argc, uint16 *argv);	
+	void xpisland25_opencard(uint16 argc, uint16 *argv);	
+	void xpisland25_resetsliders(uint16 argc, uint16 *argv);	
+	void xpisland25_slidermd(uint16 argc, uint16 *argv);	
+	void xpisland25_slidermw(uint16 argc, uint16 *argv);	
+
+	// -----------------------------------------------------
+	// rspit (Rebel Age / Tay) external commands
+	void xrcredittime(uint16 argc, uint16 *argv);
+	void xrshowinventory(uint16 argc, uint16 *argv);
+	void xrhideinventory(uint16 argc, uint16 *argv);
+	void xrwindowsetup(uint16 argc, uint16 *argv);
+
+	// -----------------------------------------------------
+	// tspit (Temple Island) external commands
+	// Telescope
+	void xtexterior300_telescopedown(uint16 argc, uint16 *argv);
+	void xtexterior300_telescopeup(uint16 argc, uint16 *argv);
+	// Called when clicking the telescope cover buttons. button is the button number (1...5).
+	void xtisland390_covercombo(uint16 argc, uint16 *argv);	// Param1: button
+	// Atrus' Journal and Trap Book are added to inventory
+	void xtatrusgivesbooks(uint16 argc, uint16 *argv);
+	// Trap Book is removed from inventory
+	void xtchotakesbook(uint16 argc, uint16 *argv);
+	void xthideinventory(uint16 argc, uint16 *argv);
+	// Marble Puzzle
+	void xt7500_checkmarbles(uint16 argc, uint16 *argv);
+	void xt7600_setupmarbles(uint16 argc, uint16 *argv);
+	void xt7800_setup(uint16 argc, uint16 *argv);
+	void xdrawmarbles(uint16 argc, uint16 *argv);
+	void xtakeit(uint16 argc, uint16 *argv);
+	// Dome
+	void xtscpbtn(uint16 argc, uint16 *argv);
+	void xtisland4990_domecheck(uint16 argc, uint16 *argv);
+	void xtisland5056_opencard(uint16 argc, uint16 *argv);
+	void xtisland5056_resetsliders(uint16 argc, uint16 *argv);
+	void xtisland5056_slidermd(uint16 argc, uint16 *argv);
+	void xtisland5056_slidermw(uint16 argc, uint16 *argv);
+	// tspit Demo-specific commands
+	void xtatboundary(uint16 argc, uint16 *argv);
+	
+	// -----------------------------------------------------
+	// Common external commands
+	void xflies(uint16 argc, uint16 *argv); // Start the "flies" realtime effect. u0 seems always 0, u1 is a small number (< 10).
+};
+	
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/riven_saveload.cpp b/engines/mohawk/riven_saveload.cpp
new file mode 100644
index 0000000000..c5cdcb6070
--- /dev/null
+++ b/engines/mohawk/riven_saveload.cpp
@@ -0,0 +1,390 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "mohawk/riven.h"
+#include "mohawk/riven_saveload.h"
+
+#include "common/util.h"
+
+namespace Mohawk {
+	
+RivenSaveLoad::RivenSaveLoad(MohawkEngine_Riven *vm, Common::SaveFileManager *saveFileMan) : _vm(vm), _saveFileMan(saveFileMan) {
+	_loadFile = new MohawkFile();
+}
+
+RivenSaveLoad::~RivenSaveLoad() {
+	delete _loadFile;
+}
+
+Common::StringList RivenSaveLoad::generateSaveGameList() {
+	return _saveFileMan->listSavefiles("*.rvn");
+}
+
+// Note: The stack numbers we use do not match up to what the original executable,
+// so, match them ;)
+static uint16 mapOldStackIDToNew(uint16 oldID) {
+	switch (oldID) {
+		case 1:
+			return ospit;
+		case 2:
+			return pspit;
+		case 3:
+			return rspit;
+		case 4:
+			return tspit;
+		case 5:
+			return bspit;
+		case 6:
+			return gspit;
+		case 7:
+			return jspit;
+		case 8:
+			return aspit;
+	}
+	error ("Unknown old stack ID %d", oldID);
+	return 0;
+}
+
+static uint16 mapNewStackIDToOld(uint16 newID) {
+	switch (newID) {
+		case aspit:
+			return 8;
+		case bspit:
+			return 5;
+		case gspit:
+			return 6;
+		case jspit:
+			return 7;
+		case ospit:
+			return 1;
+		case pspit:
+			return 2;
+		case rspit:
+			return 3;
+		case tspit:
+			return 4;
+	}
+	error ("Unknown new stack ID %d", newID);
+	return 0;
+}
+
+bool RivenSaveLoad::loadGame(Common::String filename) {
+	if (_vm->getFeatures() & GF_DEMO) // Don't load games in the demo
+		return false;
+
+	Common::InSaveFile *loadFile;
+	if (!(loadFile = _saveFileMan->openForLoading(filename.c_str())))
+		return false;
+	debug (0, "Loading game from \'%s\'", filename.c_str());
+
+	_loadFile->open(loadFile);
+
+	// First, let's make sure we're using a saved game file from this version of Riven by checking the VERS resource
+	Common::SeekableReadStream *vers = _loadFile->getRawData(ID_VERS, 1);
+	uint32 saveGameVersion = vers->readUint32BE();
+	delete vers;
+	if ((saveGameVersion == kCDSaveGameVersion && (_vm->getFeatures() & GF_DVD))
+		|| (saveGameVersion == kDVDSaveGameVersion && !(_vm->getFeatures() & GF_DVD))) {
+		warning ("Incompatible saved game versions. No support for this yet.");
+		delete _loadFile;
+		return false;
+	}
+
+	// Now, we'll read in the variable values.
+	Common::SeekableReadStream *vars = _loadFile->getRawData(ID_VARS, 1);
+	Common::Array<uint32> rawVariables;
+
+	while (!vars->eos()) {
+		vars->readUint32BE();	// Unknown (Stack?)
+		vars->readUint32BE();	// Unknown (0 or 1)
+		rawVariables.push_back(vars->readUint32BE());
+	}
+
+	delete vars;
+
+	// Next, we set the variables based on the name found by the index in the VARS resource.
+	// TODO: Merge with code in mohawk.cpp for loading names?
+	Common::SeekableReadStream *names = _loadFile->getRawData(ID_NAME, 1);
+
+	uint16 namesCount = names->readUint16BE();
+	uint16 *stringOffsets = new uint16[namesCount];
+	for (uint16 i = 0; i < namesCount; i++)
+		stringOffsets[i] = names->readUint16BE();
+	for (uint16 i = 0; i < namesCount; i++)
+		names->readUint16BE();	// Skip unknown values
+	uint32 curNamesPos = names->pos();
+
+	uint16 stackID = 0;
+	uint16 cardID = 0;
+		
+	for (uint32 i = 0; i < rawVariables.size() && i < namesCount && !names->eos(); i++) {
+		names->seek(curNamesPos);
+		names->seek(stringOffsets[i], SEEK_CUR);
+			
+		Common::String name = Common::String::emptyString;
+		char c = (char)names->readByte();
+
+		while (c) {
+			name += c;
+			c = (char)names->readByte();
+		}
+			
+		uint32 *var = _vm->matchVarToString(name);
+			
+		*var = rawVariables[i];
+				
+		if (!scumm_stricmp(name.c_str(), "CurrentStackID"))
+			stackID = mapOldStackIDToNew(rawVariables[i]);
+		else if (!scumm_stricmp(name.c_str(), "CurrentCardID"))
+			cardID = rawVariables[i];
+		else if (!scumm_stricmp(name.c_str(), "ReturnStackID"))
+			*var = mapOldStackIDToNew(rawVariables[i]);
+	}
+		
+	_vm->changeToStack(stackID);
+	_vm->changeToCard(cardID);
+
+	delete names;
+		
+	// Reset zip mode data
+	_vm->_zipModeData.clear();
+		
+	// Finally, we load in zip mode data.
+	Common::SeekableReadStream *zips = _loadFile->getRawData(ID_ZIPS, 1);
+	uint16 zipsRecordCount = zips->readUint16BE();
+	for (uint16 i = 0; i < zipsRecordCount; i++) {
+		ZipMode zip;
+		uint16 zipsNameLength = zips->readUint16BE();
+		for (uint16 j = 0; j < zipsNameLength; j++)
+			zip.name += zips->readByte();
+		zip.id = zips->readUint16BE();
+		_vm->_zipModeData.push_back(zip);
+	}
+	delete zips;
+		
+	delete _loadFile;
+	_loadFile = NULL;
+	return true;
+}
+	
+Common::MemoryWriteStreamDynamic *RivenSaveLoad::genVERSSection() {
+	Common::MemoryWriteStreamDynamic *stream = new Common::MemoryWriteStreamDynamic();
+	if (_vm->getFeatures() & GF_DVD)
+		stream->writeUint32BE(kDVDSaveGameVersion);
+	else
+		stream->writeUint32BE(kCDSaveGameVersion);
+	return stream;
+}
+	
+Common::MemoryWriteStreamDynamic *RivenSaveLoad::genVARSSection() {
+	Common::MemoryWriteStreamDynamic *stream = new Common::MemoryWriteStreamDynamic();
+		
+	for (uint32 i = 0; i < _vm->getVarCount(); i++) {
+		stream->writeUint32BE(0); // Unknown
+		stream->writeUint32BE(0); // Unknown
+		stream->writeUint32BE(_vm->getGlobalVar(i));
+	}
+
+	return stream;
+}
+	
+Common::MemoryWriteStreamDynamic *RivenSaveLoad::genNAMESection() {
+	Common::MemoryWriteStreamDynamic *stream = new Common::MemoryWriteStreamDynamic();
+		
+	stream->writeUint16BE((uint16)_vm->getVarCount());
+		
+	uint16 curPos = 0;
+	for (uint16 i = 0; i < _vm->getVarCount(); i++) {
+		stream->writeUint16BE(curPos);
+		curPos += _vm->getGlobalVarName(i).size() + 1;
+	}
+		
+	for (uint16 i = 0; i < _vm->getVarCount(); i++)
+		stream->writeUint16BE(i);
+			
+	for (uint16 i = 0; i < _vm->getVarCount(); i++) {
+		stream->write(_vm->getGlobalVarName(i).c_str(), _vm->getGlobalVarName(i).size());
+		stream->writeByte(0);
+	}
+		
+	return stream;
+}
+	
+Common::MemoryWriteStreamDynamic *RivenSaveLoad::genZIPSSection() {
+	Common::MemoryWriteStreamDynamic *stream = new Common::MemoryWriteStreamDynamic();
+		
+	stream->writeUint16BE(_vm->_zipModeData.size());
+		
+	for (uint16 i = 0; i < _vm->_zipModeData.size(); i++) {
+		stream->writeUint16BE(_vm->_zipModeData[i].name.size());
+		stream->write(_vm->_zipModeData[i].name.c_str(), _vm->_zipModeData[i].name.size());
+		stream->writeUint16BE(_vm->_zipModeData[i].id);
+	}
+		
+	return stream;
+}
+
+bool RivenSaveLoad::saveGame(Common::String filename) {
+	// Note, this code is still WIP. It works quite well for now.
+	
+	// Make sure we have the right extension
+	if (!filename.hasSuffix(".rvn") && !filename.hasSuffix(".RVN"))
+		filename += ".rvn";
+		
+	// Convert class variables to variable numbers
+	*_vm->matchVarToString("currentstackid") = mapNewStackIDToOld(_vm->getCurStack());
+	*_vm->matchVarToString("currentcardid") = _vm->getCurCard();
+	*_vm->matchVarToString("returnstackid") = mapNewStackIDToOld(*_vm->matchVarToString("returnstackid"));
+	
+	Common::OutSaveFile *saveFile;
+	if (!(saveFile = _saveFileMan->openForSaving(filename.c_str())))
+		return false;
+	debug (0, "Saving game to \'%s\'", filename.c_str());
+
+	Common::MemoryWriteStreamDynamic *versSection = genVERSSection();
+	Common::MemoryWriteStreamDynamic *nameSection = genNAMESection();
+	Common::MemoryWriteStreamDynamic *varsSection = genVARSSection();
+	Common::MemoryWriteStreamDynamic *zipsSection = genZIPSSection();
+
+	// Let's calculate the file size!
+	uint32 fileSize = 0;
+	fileSize += versSection->size();
+	fileSize += nameSection->size();
+	fileSize += varsSection->size();
+	fileSize += zipsSection->size();
+	fileSize += 16; // RSRC Header
+	fileSize += 4; // Type Table Header
+	fileSize += 4 * 8; // Type Table Entries
+	fileSize += 2; // Pseudo-Name entries
+		
+	// IFF Header
+	saveFile->writeUint32BE(ID_MHWK);
+	saveFile->writeUint32BE(fileSize);
+
+	// RSRC Header
+	saveFile->writeUint32BE(ID_RSRC);
+	saveFile->writeUint32BE(16); // Size of RSRC
+	saveFile->writeUint32BE(fileSize + 8); // Add on the 8 from the IFF header
+	saveFile->writeUint32BE(28); // IFF + RSRC
+	saveFile->writeUint16BE(62); // File Table Offset
+	saveFile->writeUint16BE(44); // 4 + 4 * 10
+	
+	//Type Table
+	saveFile->writeUint16BE(36); // After the Type Table Entries
+	saveFile->writeUint16BE(4); // 4 Type Table Entries
+
+	// Hardcode Entries
+	saveFile->writeUint32BE(ID_VERS);
+	saveFile->writeUint16BE(38);
+	saveFile->writeUint16BE(36);
+
+	saveFile->writeUint32BE(ID_NAME);
+	saveFile->writeUint16BE(44);
+	saveFile->writeUint16BE(36);
+
+	saveFile->writeUint32BE(ID_VARS);
+	saveFile->writeUint16BE(50);
+	saveFile->writeUint16BE(36);
+
+	saveFile->writeUint32BE(ID_ZIPS);
+	saveFile->writeUint16BE(56);
+	saveFile->writeUint16BE(36);
+
+	// Pseudo-Name Table/Name List
+	saveFile->writeUint16BE(0); // We don't need a name list
+
+	// VERS Section (Resource Table)
+	saveFile->writeUint16BE(1);
+	saveFile->writeUint16BE(1);
+	saveFile->writeUint16BE(1);
+
+	// NAME Section (Resource Table)
+	saveFile->writeUint16BE(1);
+	saveFile->writeUint16BE(1);
+	saveFile->writeUint16BE(2);
+
+	// VARS Section (Resource Table)
+	saveFile->writeUint16BE(1);
+	saveFile->writeUint16BE(1);
+	saveFile->writeUint16BE(3);
+
+	// ZIPS Section (Resource Table)
+	saveFile->writeUint16BE(1);
+	saveFile->writeUint16BE(1);
+	saveFile->writeUint16BE(4);
+
+	// File Table
+	saveFile->writeUint32BE(4);
+
+	// VERS Section (File Table)
+	saveFile->writeUint32BE(134);
+	saveFile->writeUint16BE(versSection->size() & 0xFFFF);
+	saveFile->writeByte((versSection->size() & 0xFF0000) >> 16);
+	saveFile->writeByte(0);
+	saveFile->writeUint16BE(0);
+
+	// NAME Section (File Table)
+	saveFile->writeUint32BE(134 + versSection->size());
+	saveFile->writeUint16BE(nameSection->size() & 0xFFFF);
+	saveFile->writeByte((nameSection->size() & 0xFF0000) >> 16);
+	saveFile->writeByte(0);
+	saveFile->writeUint16BE(0);
+
+	// VARS Section (File Table)
+	saveFile->writeUint32BE(134 + versSection->size() + nameSection->size());
+	saveFile->writeUint16BE(varsSection->size() & 0xFFFF);
+	saveFile->writeByte((varsSection->size() & 0xFF0000) >> 16);
+	saveFile->writeByte(0);
+	saveFile->writeUint16BE(0);
+
+	// ZIPS Section (File Table)
+	saveFile->writeUint32BE(134 + versSection->size() + nameSection->size() + varsSection->size());
+	saveFile->writeUint16BE(zipsSection->size() & 0xFFFF);
+	saveFile->writeByte((zipsSection->size() & 0xFF0000) >> 16);
+	saveFile->writeByte(0);
+	saveFile->writeUint16BE(0);
+
+	saveFile->write(versSection->getData(), versSection->size());
+	saveFile->write(nameSection->getData(), nameSection->size());
+	saveFile->write(varsSection->getData(), varsSection->size());
+	saveFile->write(zipsSection->getData(), zipsSection->size());
+
+	saveFile->finalize();
+
+	delete saveFile;
+	delete versSection;
+	delete nameSection;
+	delete varsSection;
+	delete zipsSection;
+
+	return true;
+}
+
+void RivenSaveLoad::deleteSave(Common::String saveName) {
+	debug (0, "Deleting save file \'%s\'", saveName.c_str());
+	_saveFileMan->removeSavefile(saveName.c_str());
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/riven_saveload.h b/engines/mohawk/riven_saveload.h
new file mode 100644
index 0000000000..b59baac9ba
--- /dev/null
+++ b/engines/mohawk/riven_saveload.h
@@ -0,0 +1,66 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#ifndef MOHAWK_SAVELOAD_H
+#define MOHAWK_SAVELOAD_H
+
+#include "common/savefile.h"
+#include "common/str.h"
+
+#include "mohawk/file.h"
+
+namespace Mohawk {
+
+class MohawkEngine_Riven;
+
+enum {
+	kCDSaveGameVersion = 0x00010000,
+	kDVDSaveGameVersion = 0x00010100
+};
+
+class RivenSaveLoad {
+public:
+	RivenSaveLoad(MohawkEngine_Riven*, Common::SaveFileManager*);
+	~RivenSaveLoad();
+
+	Common::StringList generateSaveGameList();
+	bool loadGame(Common::String);
+	bool saveGame(Common::String);
+	void deleteSave(Common::String);
+
+private:
+	MohawkEngine_Riven *_vm;
+	Common::SaveFileManager *_saveFileMan;
+	MohawkFile *_loadFile;
+		
+	Common::MemoryWriteStreamDynamic *genVERSSection();
+	Common::MemoryWriteStreamDynamic *genNAMESection();
+	Common::MemoryWriteStreamDynamic *genVARSSection();
+	Common::MemoryWriteStreamDynamic *genZIPSSection();
+};
+
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/riven_scripts.cpp b/engines/mohawk/riven_scripts.cpp
new file mode 100644
index 0000000000..e04b2a6e3d
--- /dev/null
+++ b/engines/mohawk/riven_scripts.cpp
@@ -0,0 +1,618 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "mohawk/graphics.h"
+#include "mohawk/riven.h"
+#include "mohawk/riven_external.h"
+#include "mohawk/riven_scripts.h"
+
+#include "common/stream.h"
+#include "graphics/cursorman.h"
+
+namespace Mohawk {
+
+RivenScript::RivenScript(MohawkEngine_Riven *vm, Common::SeekableReadStream *stream, uint16 scriptType)
+	: _vm(vm), _stream(stream), _scriptType(scriptType) {
+	setupOpcodes();
+}
+
+RivenScript::~RivenScript() {
+	delete _stream;
+}
+
+RivenScriptList RivenScript::readScripts(MohawkEngine_Riven *vm, Common::SeekableReadStream *stream) {
+	RivenScriptList scriptList;
+	
+	uint16 scriptCount = stream->readUint16BE();
+	for (uint16 i = 0; i < scriptCount; i++) {
+		uint16 scriptType = stream->readUint16BE();
+		uint32 scriptSize = calculateScriptSize(stream);
+		scriptList.push_back(Common::SharedPtr<RivenScript>(new RivenScript(vm, stream->readStream(scriptSize), scriptType)));
+	}
+	
+	return scriptList;
+}
+
+uint32 RivenScript::calculateCommandSize(Common::SeekableReadStream* script) {
+	uint16 command = script->readUint16BE();
+	uint32 commandSize = 2;
+	if (command == 8) {
+		if (script->readUint16BE() != 2)
+			warning ("if-then-else unknown value is not 2");
+		script->readUint16BE();								// variable to check against
+		uint16 logicBlockCount = script->readUint16BE();	// number of logic blocks
+		commandSize += 6;									// 2 + variable + logicBlocks
+		
+		for (uint16 i = 0; i < logicBlockCount; i++) {
+			script->readUint16BE(); // Block variable
+			uint16 logicBlockLength = script->readUint16BE();
+			commandSize += 4;
+			for (uint16 j = 0; j < logicBlockLength; j++)
+				commandSize += calculateCommandSize(script);
+		}
+	} else {
+		uint16 argCount = script->readUint16BE();
+		commandSize += 2;
+		for (uint16 i = 0; i < argCount; i++) {
+			script->readUint16BE();
+			commandSize += 2;
+		}
+	}
+	
+	return commandSize;
+}
+
+uint32 RivenScript::calculateScriptSize(Common::SeekableReadStream* script) {
+	uint32 oldPos = script->pos();
+	uint16 commandCount = script->readUint16BE();
+	uint16 scriptSize = 2; // 2 for command count
+	
+	for (uint16 i = 0; i < commandCount; i++)
+		scriptSize += calculateCommandSize(script);
+	
+	script->seek(oldPos);
+	return scriptSize;
+}
+
+#define OPCODE(x) { &RivenScript::x, #x }
+
+void RivenScript::setupOpcodes() {
+	static const RivenOpcode riven_opcodes[] = {
+		// 0x00 (0 decimal)
+		OPCODE(empty),
+		OPCODE(drawBitmap),
+		OPCODE(switchCard),
+		OPCODE(playScriptSLST),
+		// 0x04 (4 decimal)
+		OPCODE(playSound),
+		OPCODE(empty),						// Empty
+		OPCODE(empty),						// Complex animation (not used)
+		OPCODE(setVariable),
+		// 0x08 (8 decimal)
+		OPCODE(mohawkSwitch),
+		OPCODE(enableHotspot),
+		OPCODE(disableHotspot),
+		OPCODE(empty),						// Empty
+		// 0x0C (12 decimal)
+		OPCODE(clearSLST),
+		OPCODE(changeCursor),
+		OPCODE(delay),
+		OPCODE(empty),						// Empty
+		// 0x10 (16 decimal)
+		OPCODE(empty),						// Empty
+		OPCODE(runExternalCommand),
+		OPCODE(transition),
+		OPCODE(refreshCard),
+		// 0x14 (20 decimal)
+		OPCODE(disableScreenUpdate),
+		OPCODE(enableScreenUpdate),
+		OPCODE(empty),						// Empty
+		OPCODE(empty),						// Empty
+		// 0x18 (24 decimal)
+		OPCODE(incrementVariable),
+		OPCODE(empty),						// Empty
+		OPCODE(empty),						// Empty
+		OPCODE(changeStack),
+		// 0x1C (28 decimal)
+		OPCODE(disableMovie),
+		OPCODE(disableAllMovies),
+		OPCODE(empty),						// Set movie rate (not used)
+		OPCODE(enableMovie),
+		// 0x20 (32 decimal)
+		OPCODE(playMovie),
+		OPCODE(playMovieBg),
+		OPCODE(stopMovie),
+		OPCODE(empty),						// Start a water effect (not used)
+		// 0x24 (36 decimal)
+		OPCODE(unk_36),						// Unknown
+		OPCODE(fadeAmbientSounds),
+		OPCODE(complexPlayMovie),
+		OPCODE(activatePLST),
+		// 0x28 (40 decimal)
+		OPCODE(activateSLST),
+		OPCODE(activateMLSTAndPlay),
+		OPCODE(empty),						// Empty
+		OPCODE(activateBLST),
+		// 0x2C (44 decimal)
+		OPCODE(activateFLST),
+		OPCODE(zipMode),
+		OPCODE(activateMLST),
+		OPCODE(activateSLSTWithVolume)
+	};
+
+	_opcodes = riven_opcodes;
+}
+
+static void printTabs(byte tabs) {
+	for (byte i = 0; i < tabs; i++)
+		printf ("\t");
+}
+
+void RivenScript::dumpScript(Common::StringList varNames, Common::StringList xNames, byte tabs) {
+	if (_stream->pos() != 0)
+		_stream->seek(0);
+		
+	printTabs(tabs); printf ("Stream Type %d:\n", _scriptType);
+	dumpCommands(varNames, xNames, tabs + 1);
+}
+
+void RivenScript::dumpCommands(Common::StringList varNames, Common::StringList xNames, byte tabs) {
+	uint16 commandCount = _stream->readUint16BE();
+	
+	for (uint16 i = 0; i < commandCount; i++) {
+		uint16 command = _stream->readUint16BE();
+		
+		if (command == 8) { // "Switch" Statement
+			if (_stream->readUint16BE() != 2)
+				warning ("if-then-else unknown value is not 2");
+			uint16 var = _stream->readUint16BE();
+			printTabs(tabs); printf("switch (%s) {\n", varNames[var].c_str());
+			uint16 logicBlockCount = _stream->readUint16BE();
+			for (uint16 j = 0; j < logicBlockCount; j++) {
+				uint16 varCheck = _stream->readUint16BE();
+				printTabs(tabs + 1); 
+				if (varCheck == 0xFFFF)
+					printf("default:\n");
+				else
+					printf("case %d:\n", varCheck);
+				dumpCommands(varNames, xNames, tabs + 2);
+				printTabs(tabs + 2); printf("break;\n");
+			}
+			printTabs(tabs); printf("}\n");
+		} else if (command == 7) { // Use the variable name
+			_stream->readUint16BE(); // Skip the opcode var count
+			printTabs(tabs);
+			uint16 var = _stream->readUint16BE();
+			printf("%s = %d;\n", varNames[var].c_str(), _stream->readUint16BE());
+		} else if (command == 17) { // Use the external command name
+			_stream->readUint16BE(); // Skip the opcode var count
+			printTabs(tabs);
+			printf("%s(", xNames[_stream->readUint16BE()].c_str());
+			uint16 varCount = _stream->readUint16BE();
+			for (uint16 j = 0; j < varCount; j++) {
+				printf("%d", _stream->readUint16BE());
+				if (j != varCount - 1)
+					printf(", ");
+			}
+			printf (");\n");
+		} else if (command == 24) { // Use the variable name
+			_stream->readUint16BE(); // Skip the opcode var count
+			printTabs(tabs);
+			uint16 var = _stream->readUint16BE();
+			printf ("%s += %d;\n", varNames[var].c_str(), _stream->readUint16BE());
+		} else {
+			printTabs(tabs);
+			uint16 varCount = _stream->readUint16BE();
+			printf("%s(", _opcodes[command].desc);
+			for (uint16 j = 0; j < varCount; j++) {
+				printf("%d", _stream->readUint16BE());
+				if (j != varCount - 1)
+					printf(", ");
+			}
+			printf(");\n");
+		}
+	}
+}
+
+void RivenScript::runScript() {
+	if (_stream->pos() != 0)
+		_stream->seek(0);
+
+	processCommands(true);
+}
+
+void RivenScript::processCommands(bool runCommands) {
+	bool anotherBlockEvaluated = false;
+	bool runBlock = true;
+
+	uint16 commandCount = _stream->readUint16BE();
+
+	for (uint16 j = 0; j < commandCount && !_vm->shouldQuit() && _stream->pos() < _stream->size(); j++) {
+		uint16 command = _stream->readUint16BE();
+
+		if (command == 8) {
+			// Command 8 contains a conditional branch, similar to switch statements
+			if (_stream->readUint16BE() != 2)
+				warning("if-then-else unknown value is not 2");
+			uint16 var = _stream->readUint16BE();				// variable to check against
+			uint16 logicBlockCount = _stream->readUint16BE();	// number of logic blocks
+
+			for (uint16 k = 0; k < logicBlockCount; k++) {
+				uint16 checkValue = _stream->readUint16BE();	// variable for this logic block
+
+				// Run the following block if the block's variable is equal to the variable to check against
+				// Don't run it if the parent block is not executed
+				// And don't run it if another block has already evaluated to true (needed for the default case)
+				runBlock = (*_vm->getLocalVar(var) == checkValue || checkValue == 0xffff) && runCommands && !anotherBlockEvaluated;
+				processCommands(runBlock);
+				
+				if (runBlock)
+					anotherBlockEvaluated = true;
+			}
+
+			anotherBlockEvaluated = false;
+		} else {
+			uint16 argCount = _stream->readUint16BE();
+			uint16 *argValues = new uint16[argCount];
+
+			for (uint16 k = 0; k < argCount; k++)
+				argValues[k] = _stream->readUint16BE();
+
+			if (runCommands) {
+				debug (4, "Running opcode %04x, argument count %d", command, argCount);
+				(this->*(_opcodes[command].proc)) (command, argCount, argValues);
+			}
+
+			delete[] argValues;
+		}
+	}
+}
+
+////////////////////////////////
+// Opcodes
+////////////////////////////////
+
+// Command 1: draw tBMP resource (tbmp_id, left, top, right, bottom, u0, u1, u2, u3)
+void RivenScript::drawBitmap(uint16 op, uint16 argc, uint16 *argv) {
+	if (argc < 5) {
+		// Copy the image to the whole screen, ignoring the rest of the parameters
+		_vm->_gfx->copyImageToScreen(argv[0], 0, 0, 608, 392);
+	} else {
+		// Copy the image to a certain part of the screen
+		_vm->_gfx->copyImageToScreen(argv[0], argv[1], argv[2], argv[3], argv[4]);
+	}
+	
+	// Now, update the screen
+	_vm->_gfx->updateScreen();
+}
+
+// Command 2: go to card (card id)
+void RivenScript::switchCard(uint16 op, uint16 argc, uint16 *argv) {
+	_vm->changeToCard(argv[0]);
+}
+
+// Command 3: play an SLST from the script
+void RivenScript::playScriptSLST(uint16 op, uint16 argc, uint16 *argv) {
+	SLSTRecord slstRecord;
+	int offset = 0, j = 0;
+
+	slstRecord.index = 0;		// not set by the scripts, so we set it to 0
+	slstRecord.sound_count = argv[0];
+	slstRecord.sound_ids = new uint16[slstRecord.sound_count];
+
+	offset = slstRecord.sound_count;
+
+	for (j = 0; j < slstRecord.sound_count; j++)
+		slstRecord.sound_ids[j] = argv[offset++];
+	slstRecord.fade_flags = argv[offset++];
+	slstRecord.loop = argv[offset++];
+	slstRecord.global_volume = argv[offset++]; 
+	slstRecord.u0 = argv[offset++]; 
+	slstRecord.u1 = argv[offset++]; 
+
+	slstRecord.volumes = new uint16[slstRecord.sound_count];
+	slstRecord.balances = new int16[slstRecord.sound_count];
+	slstRecord.u2 = new uint16[slstRecord.sound_count];
+
+	for (j = 0; j < slstRecord.sound_count; j++)
+		slstRecord.volumes[j] = argv[offset++];
+
+	for (j = 0; j < slstRecord.sound_count; j++)
+		slstRecord.balances[j] = argv[offset++];	// negative = left, 0 = center, positive = right
+
+	for (j = 0; j < slstRecord.sound_count; j++)
+		slstRecord.u2[j] = argv[offset++];			// Unknown
+
+	// Play the requested sound list
+	_vm->_sound->playSLST(slstRecord);
+	_vm->_activatedSLST = true;
+}
+
+// Command 4: play local tWAV resource (twav_id, volume, u1)
+void RivenScript::playSound(uint16 op, uint16 argc, uint16 *argv) {
+	_vm->_sound->playSound(argv[0], false);
+}
+
+// Command 7: set variable value (variable, value)
+void RivenScript::setVariable(uint16 op, uint16 argc, uint16 *argv) {
+	debug(2, "Setting variable %d to %d", argv[0], argv[1]);
+	*_vm->getLocalVar(argv[0]) = argv[1];
+}
+
+// Command 8: conditional branch
+void RivenScript::mohawkSwitch(uint16 op, uint16 argc, uint16 *argv) {
+	// dummy function, this opcode does logic checking in processCommands()
+}
+
+// Command 9: enable hotspot (blst_id)
+void RivenScript::enableHotspot(uint16 op, uint16 argc, uint16 *argv) {
+	for (uint16 i = 0; i < _vm->getHotspotCount(); i++) {
+		if (_vm->_hotspots[i].blstID == argv[0]) {
+			debug(2, "Enabling hotspot with BLST ID %d", argv[0]);
+			_vm->_hotspots[i].enabled = true;
+		}
+	}
+}
+
+// Command 10: disable hotspot (blst_id)
+void RivenScript::disableHotspot(uint16 op, uint16 argc, uint16 *argv) {
+	for (uint16 i = 0; i < _vm->getHotspotCount(); i++) {
+		if (_vm->_hotspots[i].blstID == argv[0]) {
+			debug(2, "Disabling hotspot with BLST ID %d", argv[0]);
+			_vm->_hotspots[i].enabled = false;
+		}
+	}
+}
+
+// Command 12: clear slst records (flags)
+void RivenScript::clearSLST(uint16 op, uint16 argc, uint16 *argv) {
+	warning ("STUB: clearSLST: Fade Out = %s, Fade In = %s", ((argv[0] & 1) != 0) ? "Yes" : "No", ((argv[0] & 2) != 0) ? "Yes" : "No");
+	//_vm->_sound->clearAllSLST();
+}
+
+// Command 13: set mouse cursor (cursor_id)
+void RivenScript::changeCursor(uint16 op, uint16 argc, uint16 *argv) {
+	debug(2, "Change to cursor %d", argv[0]);
+	_vm->_gfx->changeCursor(argv[0]);
+}
+
+// Command 14: pause script execution (delay in ms, u1)
+void RivenScript::delay(uint16 op, uint16 argc, uint16 *argv) {
+	debug(2, "Delay %dms", argv[0]);
+	if (argv[0] > 0)
+		_vm->_system->delayMillis(argv[0]);
+}
+
+// Command 17: call external command
+void RivenScript::runExternalCommand(uint16 op, uint16 argc, uint16 *argv) {
+	_vm->_externalScriptHandler->runCommand(argc, argv);
+}
+
+// Command 18: transition
+// Note that this opcode has 1 or 5 parameters, depending on parameter 0
+// Parameter 0: transition type
+// Parameters 1-4: transition rectangle
+void RivenScript::transition(uint16 op, uint16 argc, uint16 *argv) {
+	if (argc == 1) {
+		_vm->_gfx->scheduleTransition(argv[0]);
+	} else {
+		_vm->_gfx->scheduleTransition(argv[0], Common::Rect(argv[1], argv[2], argv[3], argv[4]));
+	}
+}
+
+// Command 19: reload card
+void RivenScript::refreshCard(uint16 op, uint16 argc, uint16 *argv) {
+	debug(2, "Reloading card");
+	_vm->changeToCard();
+}
+
+// Command 20: disable screen update
+void RivenScript::disableScreenUpdate(uint16 op, uint16 argc, uint16 *argv) {
+	debug(2, "Screen update disabled");
+	_vm->_gfx->_updatesEnabled = false;
+}
+
+// Command 21: enable screen update
+void RivenScript::enableScreenUpdate(uint16 op, uint16 argc, uint16 *argv) {
+	debug(2, "Screen update enabled");
+	_vm->_gfx->_updatesEnabled = true;
+	_vm->_gfx->updateScreen();
+}
+
+// Command 24: increment variable (variable, value)
+void RivenScript::incrementVariable(uint16 op, uint16 argc, uint16 *argv) {
+	uint32 *localVar = _vm->getLocalVar(argv[0]);
+	*localVar += argv[1];
+	debug (2, "Incrementing variable %d by %d, variable now is equal to %d", argv[0], argv[1], *localVar);
+}
+
+// Command 27: go to stack (stack_name code_hi code_lo)
+void RivenScript::changeStack(uint16 op, uint16 argc, uint16 *argv) {
+	Common::String stackName = _vm->getName(StackNames, argv[0]);
+	int8 index = -1;
+	
+	for (byte i = 0; i < 8; i++)
+		if (!scumm_stricmp(_vm->getStackName(i).c_str(), stackName.c_str())) {
+			index = i;
+			break;
+		}
+
+	if (index == -1)
+		error ("\'%s\' is not a stack name!", stackName.c_str());
+	
+	_vm->changeToStack(index);
+	uint32 rmapCode = (argv[1] << 16) + argv[2];
+	uint16 cardID = _vm->matchRMAPToCard(rmapCode);
+	_vm->changeToCard(cardID);
+}
+
+// Command 28: disable a movie
+void RivenScript::disableMovie(uint16 op, uint16 argc, uint16 *argv) {
+	_vm->_video->disableMovie(argv[0]);
+}
+
+// Command 29: disable all movies
+void RivenScript::disableAllMovies(uint16 op, uint16 argc, uint16 *argv) {
+	_vm->_video->disableAllMovies();
+}
+
+// Command 31: enable a movie
+void RivenScript::enableMovie(uint16 op, uint16 argc, uint16 *argv) {
+	_vm->_video->enableMovie(argv[0]);
+}
+
+// Command 32: play foreground movie - blocking (movie_id)
+void RivenScript::playMovie(uint16 op, uint16 argc, uint16 *argv) {
+	CursorMan.showMouse(false); // Hide the cursor before playing the video
+	_vm->_video->enableMovie(argv[0]);
+	_vm->_video->playMovieBlocking(argv[0]);
+	CursorMan.showMouse(true); // Show the cursor again when we're done ;)
+}
+
+// Command 33: play background movie - nonblocking (movie_id)
+void RivenScript::playMovieBg(uint16 op, uint16 argc, uint16 *argv) {
+	_vm->_video->enableMovie(argv[0]);
+	_vm->_video->playMovie(argv[0]);
+}
+
+// Command 34: stop a movie
+void RivenScript::stopMovie(uint16 op, uint16 argc, uint16 *argv) {
+	_vm->_video->disableMovie(argv[0]);
+	_vm->_video->stopMovie(argv[0]);
+}
+
+// Command 36: unknown
+void RivenScript::unk_36(uint16 op, uint16 argc, uint16 *argv) {
+	debug(0, "unk_36: Ignoring");
+}
+
+// Command 37: fade ambient sounds
+void RivenScript::fadeAmbientSounds(uint16 op, uint16 argc, uint16 *argv) {
+	warning("STUB: fadeAmbientSounds()");	
+}
+
+// Command 38: Play a movie with extra parameters (movie id, delay high, delay low, record type, record id)
+void RivenScript::complexPlayMovie(uint16 op, uint16 argc, uint16 *argv) {
+	warning("STUB: complexPlayMovie");
+	printf ("\tMovie ID = %d\n", argv[0]);
+	printf ("\tDelay = %d\n", (argv[1] << 16) + argv[2]);
+	if (argv[3] == 0) {
+		printf ("\tDraw PLST %d\n", argv[4]);
+	} else if (argv[3] == 40) {
+		printf ("\tPlay SLST %d\n", argv[4]);
+	} else {
+		error ("Unknown complexPlayMovie record type %d", argv[3]);
+	}
+}
+
+// Command 39: activate PLST record (card picture lists)
+void RivenScript::activatePLST(uint16 op, uint16 argc, uint16 *argv) {
+	_vm->_gfx->drawPLST(argv[0]);
+	
+	// An update is automatically sent here as long as it's not a load or update script and updates are enabled.
+	if (_scriptType != kCardLoadScript && _scriptType != kCardUpdateScript)
+		_vm->_gfx->updateScreen();
+}
+
+// Command 40: activate SLST record (card ambient sound lists)
+void RivenScript::activateSLST(uint16 op, uint16 argc, uint16 *argv) {
+	// WORKAROUND: Disable the SLST that is played during Riven's intro.
+	// Riven X does this too (spoke this over with Jeff)
+	if (_vm->getCurStack() == tspit && _vm->getCurCard() == 155 && argv[0] == 2)
+		return;
+
+	_vm->_sound->playSLST(argv[0], _vm->getCurCard());
+	_vm->_activatedSLST = true;
+}
+
+// Command 41: activate MLST record and play
+void RivenScript::activateMLSTAndPlay(uint16 op, uint16 argc, uint16 *argv) {
+	_vm->_video->enableMovie(argv[0] - 1);
+	_vm->_video->activateMLST(argv[0], _vm->getCurCard());
+	// TODO: Play movie (blocking?)
+}
+
+// Command 43: activate BLST record (card hotspot enabling lists)
+void RivenScript::activateBLST(uint16 op, uint16 argc, uint16 *argv) {
+	Common::SeekableReadStream* blst = _vm->getRawData(ID_BLST, _vm->getCurCard());
+	uint16 recordCount = blst->readUint16BE();
+	
+	for (uint16 i = 0; i < recordCount; i++) {
+		uint16 index = blst->readUint16BE();	// record index
+		uint16 enabled = blst->readUint16BE();
+		uint16 hotspotID = blst->readUint16BE();
+		
+		if (argv[0] == index)
+			for (uint16 j = 0; j < _vm->getHotspotCount(); j++)
+				if (_vm->_hotspots[j].blstID == hotspotID)
+					_vm->_hotspots[j].enabled = (enabled == 1);
+	}
+	
+	delete blst;
+}
+
+// Command 44: activate FLST record (information on which SFXE resource this card should use)
+void RivenScript::activateFLST(uint16 op, uint16 argc, uint16 *argv) {
+	Common::SeekableReadStream* flst = _vm->getRawData(ID_FLST, _vm->getCurCard());
+	uint16 recordCount = flst->readUint16BE();
+	
+	for (uint16 i = 0; i < recordCount; i++) {
+		uint16 index = flst->readUint16BE();
+		uint16 sfxeID = flst->readUint16BE();
+		if(flst->readUint16BE() != 0)
+			warning("FLST u0 non-zero");
+		
+		if (index == argv[0]) {
+			_vm->_gfx->scheduleWaterEffect(sfxeID);
+			break;
+		}
+	}
+
+	delete flst;
+}
+
+// Command 45: do zip mode
+void RivenScript::zipMode(uint16 op, uint16 argc, uint16 *argv) {
+	// Check the ZIPS records to see if we have a match to the hotspot name
+	Common::String hotspotName = _vm->getHotspotName(_vm->getCurHotspot());
+	
+	for (uint16 i = 0; i < _vm->_zipModeData.size(); i++)
+		if (_vm->_zipModeData[i].name == hotspotName) {
+			_vm->changeToCard(_vm->_zipModeData[i].id);
+			return;
+		}
+}
+
+// Command 46: activate MLST record (movie lists)
+void RivenScript::activateMLST(uint16 op, uint16 argc, uint16 *argv) {
+	_vm->_video->activateMLST(argv[0], _vm->getCurCard());
+}
+
+// Command 47: activate SLST record with a volume argument
+void RivenScript::activateSLSTWithVolume(uint16 op, uint16 argc, uint16 *argv) {
+	warning("STUB: activateSLSTWithVolume()");
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/riven_scripts.h b/engines/mohawk/riven_scripts.h
new file mode 100644
index 0000000000..36fce259f0
--- /dev/null
+++ b/engines/mohawk/riven_scripts.h
@@ -0,0 +1,127 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#ifndef RIVEN_SCRIPTS_H
+#define RIVEN_SCRIPTS_H
+
+class MohawkEngine_Riven;
+
+#define DECLARE_OPCODE(x) void x(uint16 op, uint16 argc, uint16 *argv)
+
+namespace Mohawk {
+// Script Types
+enum {
+	kMouseDownScript = 0,
+	kMouseDownScriptAlt = 1,
+	kMouseUpScript = 2,
+	kMouseMovedPressedReleasedScript = 3,
+	kMouseInsideScript = 4,
+	kMouseLeaveScript = 5, // This is unconfirmed
+
+	kCardLoadScript = 6,
+	kCardLeaveScript = 7,
+	kCardOpenScript = 9,
+	kCardUpdateScript = 10
+};
+
+class RivenScript;
+typedef Common::Array<Common::SharedPtr<RivenScript> > RivenScriptList;
+
+class RivenScript {
+public:
+	RivenScript(MohawkEngine_Riven *vm, Common::SeekableReadStream *stream, uint16 scriptType);
+	~RivenScript();
+	
+	void runScript();
+	void dumpScript(Common::StringList varNames, Common::StringList xNames, byte tabs);
+	uint16 getScriptType() { return _scriptType; }
+	
+	// Read in an array of script objects from a stream
+	static RivenScriptList readScripts(MohawkEngine_Riven *vm, Common::SeekableReadStream *stream);
+	
+private:
+	typedef void (RivenScript::*OpcodeProcRiven)(uint16 op, uint16 argc, uint16 *argv);
+	struct RivenOpcode {
+		OpcodeProcRiven proc;
+		const char *desc;
+	};
+	const RivenOpcode* _opcodes;
+	void setupOpcodes();
+	
+	MohawkEngine_Riven *_vm;
+	Common::SeekableReadStream *_stream;
+	uint16 _scriptType;
+	
+	void dumpCommands(Common::StringList varNames, Common::StringList xNames, byte tabs);
+	void processCommands(bool runCommands);
+	
+	static uint32 calculateCommandSize(Common::SeekableReadStream* script);
+	static uint32 calculateScriptSize(Common::SeekableReadStream* script);
+	
+	DECLARE_OPCODE(empty) { warning ("Unknown Opcode %04x", op); }
+
+	//Opcodes
+	DECLARE_OPCODE(drawBitmap);
+	DECLARE_OPCODE(switchCard);
+	DECLARE_OPCODE(playScriptSLST);
+	DECLARE_OPCODE(playSound);
+	DECLARE_OPCODE(setVariable);
+	DECLARE_OPCODE(mohawkSwitch);
+	DECLARE_OPCODE(enableHotspot);
+	DECLARE_OPCODE(disableHotspot);
+	DECLARE_OPCODE(clearSLST);
+	DECLARE_OPCODE(changeCursor);
+	DECLARE_OPCODE(delay);
+	DECLARE_OPCODE(runExternalCommand);
+	DECLARE_OPCODE(transition);
+	DECLARE_OPCODE(refreshCard);
+	DECLARE_OPCODE(disableScreenUpdate);
+	DECLARE_OPCODE(enableScreenUpdate);
+	DECLARE_OPCODE(incrementVariable);
+	DECLARE_OPCODE(changeStack);
+	DECLARE_OPCODE(disableMovie);
+	DECLARE_OPCODE(disableAllMovies);
+	DECLARE_OPCODE(enableMovie);
+	DECLARE_OPCODE(playMovie);
+	DECLARE_OPCODE(playMovieBg);
+	DECLARE_OPCODE(stopMovie);
+	DECLARE_OPCODE(unk_36);
+	DECLARE_OPCODE(fadeAmbientSounds);
+	DECLARE_OPCODE(complexPlayMovie);
+	DECLARE_OPCODE(activatePLST);
+	DECLARE_OPCODE(activateSLST);
+	DECLARE_OPCODE(activateMLSTAndPlay);
+	DECLARE_OPCODE(activateBLST);
+	DECLARE_OPCODE(activateFLST);
+	DECLARE_OPCODE(zipMode);
+	DECLARE_OPCODE(activateMLST);
+	DECLARE_OPCODE(activateSLSTWithVolume);
+};
+
+} // End of namespace Mohawk
+
+#undef DECLARE_OPCODE
+
+#endif
diff --git a/engines/mohawk/riven_vars.cpp b/engines/mohawk/riven_vars.cpp
new file mode 100644
index 0000000000..263ace2b78
--- /dev/null
+++ b/engines/mohawk/riven_vars.cpp
@@ -0,0 +1,324 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "common/str.h"
+
+#include "mohawk/riven.h"
+
+namespace Mohawk {
+
+// The Riven variable system is complex. The scripts of each stack give a number, but the number has to be matched 
+// to a variable name defined in NAME resource 4.
+
+static const char *variableNames[] = {
+	// aspit
+	"aatrusbook",
+	"aatruspage",
+	"acathbook",
+	"acathpage",
+	"acathstate",
+	"adoit",
+	"adomecombo",
+	"agehn",
+	"ainventory",
+	"aova",
+	"apower",
+	"araw",
+	"atemp",
+	"atrap",
+	"atrapbook",
+	"auservolume",
+	"azip",
+	
+	// bspit
+	"bbacklock",
+	"bbait",
+	"bbigbridge",
+	"bbirds",
+	"bblrarm",
+	"bblrdoor",
+	"bblrgrt",
+	"bblrsw",
+	"bblrvalve",
+	"bblrwtr",
+	"bbook",
+	"bbrlever",
+	"bcavedoor",
+	"bcombo",
+	"bcpipegr",
+	"bcratergg",
+	"bdome",
+	"bdrwr",
+	"bfans",
+	"bfmdoor",
+	"bidvlv",
+	"blab",
+	"blabbackdr",
+	"blabbook",
+	"blabeye",
+	"blabfrontdr",
+	"blabpage",
+	"blever",
+	"bfrontlock",
+	"bheat",
+	"bmagcar",
+	"bpipdr",
+	"bprs",
+	"bstove",
+	"btrap",
+	"bvalve",
+	"bvise",
+	"bytram",
+	"bytramtime",
+	"bytrap",
+	"bytrapped",
+	
+	// gspit
+	"gbook",
+	"gcathtime",
+	"gcathstate",
+	"gcombo",
+	"gdome",
+	"gemagcar",
+	"gimagecurr",
+	"gimagemax",
+	"gimagerot",
+	"glkbtns",
+	"glkbridge",
+	"glkelev",
+	"glview",
+	"glviewmpos",
+	"glviewpos",
+	"gnmagrot",
+	"gnmagcar",
+	"gpinup",
+	"gpinpos",
+	"gpinsmpos",
+	"grview",
+	"grviewmpos",
+	"grviewpos",
+	"gscribe",
+	"gscribetime",
+	"gsubelev",
+	"gsubdr",
+	"gupmoov",
+	"gwhark",
+	"gwharktime",
+	
+	// jspit
+	"jwmagcar",
+	"jbeetle",
+	"jbeetlepool",
+	"jbook",
+	"jbridge1",
+	"jbridge2",
+	"jbridge3",
+	"jbridge4",
+	"jbridge5",
+	"jccb",
+	"jcombo",
+	"jcrg",
+	"jdome",
+	"jdrain",
+	"jgallows",
+	"jgate",
+	"jgirl",
+	"jiconcorrectorder",
+	"jiconorder",
+	"jicons",
+	"jladder",
+	"jleftpos",
+	"jpeek",
+	"jplaybeetle",
+	"jprebel",
+	"jprisondr",
+	"jprisonsecdr",
+	"jrbook",
+	"jrightpos",
+	"jsouthpathdr",
+	"jschooldr",
+	"jsub",
+	"jsubdir",
+	"jsubhatch",
+	"jsubsw",
+	"jsunners",
+	"jsunnertime",
+	"jthronedr",
+	"jtunneldr",
+	"jtunnellamps",
+	"jvillagepeople",
+	"jwarning",
+	"jwharkpos",
+	"jwharkram",
+	"jwmouth",
+	"jwmagcar",
+	"jymagcar",
+	
+	// ospit
+	"oambient",
+	"obutton",
+	"ocage",
+	"odeskbook",
+	"ogehnpage",
+	"omusicplayer",
+	"ostanddrawer",
+	"ostove",
+	
+	// pspit
+	"pbook",
+	"pcage",
+	"pcathcheck",
+	"pcathstate",
+	"pcathtime",
+	"pcombo",
+	"pcorrectorder",
+	"pdome",
+	"pelevcombo",
+	"pleftpos",
+	"prightpos",
+	"ptemp",
+	"pwharkpos",
+	
+	// rspit
+	"rrebel",
+	"rrebelview",
+	"rrichard",
+	"rvillagetime",
+	
+	// tspit
+	"tbars",
+	"tbeetle",
+	"tblue",
+	"tbook",
+	"tbookvalve",
+	"tcage",
+	"tcombo",
+	"tcorrectorder",
+	"tcovercombo",
+	"tdl",
+	"tdome",
+	"tdomeelev",
+	"tdomeelevbtn",
+	"tgatebrhandle",
+	"tgatebridge",
+	"tgatestate",
+	"tgreen",
+	"tgridoor",
+	"tgrodoor",
+	"tgrmdoor",
+	"tguard",
+	"timagedoor",
+	"tmagcar",
+	"torange",
+	"tred",
+	"tsecdoor",
+	"tsubbridge",
+	"ttelecover",
+	"ttelehandle",
+	"ttelepin",
+	"ttelescope",
+	"ttelevalve",
+	"ttemple",
+	"ttempledoor",
+	"ttunneldoor",
+	"tviewer",
+	"tviolet",
+	"twabrvalve",
+	"twaffle",
+	"tyellow",
+	
+	// Miscellaneous
+	"elevbtn1",
+	"elevbtn2",
+	"elevbtn3",
+	"domecheck",
+	"transitionsenabled",
+	"transitionmode",
+	"waterenabled",
+	"rivenambients",
+	"stackvarsinitialized",
+	"doingsetupscreens",
+	"all_book",
+	"playerhasbook",
+	"returnstackid",
+	"returncardid",
+	"newpos",
+	"themarble",
+	"currentstackid",
+	"currentcardid"
+};
+
+uint32 *MohawkEngine_Riven::getLocalVar(uint32 index) {
+	return matchVarToString(getName(VariableNames, index));
+}
+
+uint32 MohawkEngine_Riven::getGlobalVar(uint32 index) {
+	return _vars[index];
+}
+
+Common::String MohawkEngine_Riven::getGlobalVarName(uint32 index) {
+	return Common::String(variableNames[index]);
+}
+
+uint32 *MohawkEngine_Riven::matchVarToString(Common::String varName) {
+	return matchVarToString(varName.c_str());
+}
+
+uint32 *MohawkEngine_Riven::matchVarToString(const char *varName) {
+	for (uint32 i = 0; i < _varCount; i++)
+		if (!scumm_stricmp(varName, variableNames[i]))
+			return &_vars[i];
+	error ("Unknown variable: \'%s\'", varName);
+	return NULL;
+}
+
+void MohawkEngine_Riven::initVars() {
+	_varCount = ARRAYSIZE(variableNames);
+
+	_vars = new uint32[_varCount];
+	
+	// Temporary:
+	for (uint32 i = 0; i < _varCount; i++)
+		_vars[i] = 0;
+	
+	// Init Variables to their correct starting state.
+	*matchVarToString("ttelescope") = 5;
+	*matchVarToString("tgatestate") = 1;
+	*matchVarToString("jbridge1") = 1;
+	*matchVarToString("jbridge4") = 1;
+	*matchVarToString("jgallows") = 1;
+	*matchVarToString("jiconcorrectorder") = 12068577;
+	*matchVarToString("bblrvalve") = 1;
+	*matchVarToString("bblrwtr") = 1;
+	*matchVarToString("bfans") = 1;
+	*matchVarToString("bytrap") = 2;
+	*matchVarToString("aatruspage") = 1;
+	*matchVarToString("acathpage") = 1;
+	*matchVarToString("bheat") = 1;
+	*matchVarToString("waterenabled") = 1;
+	*matchVarToString("ogehnpage") = 1;
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/sound.cpp b/engines/mohawk/sound.cpp
new file mode 100644
index 0000000000..7426e07084
--- /dev/null
+++ b/engines/mohawk/sound.cpp
@@ -0,0 +1,530 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "mohawk/sound.h"
+
+#include "common/util.h"
+
+#include "sound/audiostream.h"
+#include "sound/mp3.h"
+#include "sound/wave.h"
+
+
+namespace Mohawk {
+
+Sound::Sound(MohawkEngine* vm) : _vm(vm) {
+	_rivenSoundFile = NULL;
+	_midiDriver = NULL;
+	_midiParser = NULL;
+	
+	for (uint32 i = 0; i < _handles.size(); i++) {
+		_handles[i].handle = Audio::SoundHandle();
+		_handles[i].type = kFreeHandle;
+	}
+	
+	initMidi();
+}
+
+Sound::~Sound() {
+	stopSound();
+	stopAllSLST();
+	delete _rivenSoundFile;
+	
+	if (_midiDriver) {
+		_midiDriver->close();
+		delete _midiDriver;
+	}
+	
+	if (_midiParser) {
+		_midiParser->unloadMusic();
+		delete _midiParser;
+	}
+}
+
+void Sound::loadRivenSounds(uint16 stack) {
+	static const char prefixes[] = { 'a', 'b', 'g', 'j', 'o', 'p', 'r', 't' };
+
+	if (!_rivenSoundFile)
+		_rivenSoundFile = new MohawkFile();
+	
+	_rivenSoundFile->open(Common::String(prefixes[stack]) + "_Sounds.mhk");
+}
+
+void Sound::initMidi() {
+	if (!(_vm->getFeatures() & GF_HASMIDI))
+		return;
+		
+	// Let's get our MIDI parser/driver
+	_midiParser = MidiParser::createParser_SMF();
+	_midiDriver = MidiDriver::createMidi(MidiDriver::detectMusicDriver(MDT_ADLIB|MDT_MIDI));
+	
+	// Set up everything!
+	_midiDriver->open();
+	_midiParser->setMidiDriver(_midiDriver);
+	_midiParser->setTimerRate(_midiDriver->getBaseTempo());
+}
+        
+Audio::SoundHandle *Sound::playSound(uint16 id, bool mainSoundFile, byte volume) {
+	debug (0, "Playing sound %d", id);
+	
+	SndHandle *handle = getHandle();
+	handle->type = kUsedHandle;
+	
+	Audio::AudioStream* audStream = NULL;
+
+	switch (_vm->getGameType()) {
+		case GType_MYST:
+			if (_vm->getFeatures() & GF_ME) {
+				// Myst ME is a bit more efficient with sound storage than Myst
+				// Myst has lots of sounds repeated. To overcome this, Myst ME
+				// has MJMP resources which provide a link to the actual MSND
+				// resource we're looking for. This saves a lot of space from
+				// repeated data.
+				if (_vm->hasResource(ID_MJMP, id)) {
+					Common::SeekableReadStream *mjmpStream = _vm->getRawData(ID_MJMP, id);
+					id = mjmpStream->readUint16LE();
+					delete mjmpStream;
+				}
+				
+				audStream = Audio::makeWAVStream(_vm->getRawData(ID_MSND, id), true);
+			} else
+				audStream = makeMohawkWaveStream(_vm->getRawData(ID_MSND, id));
+			break;
+		case GType_RIVEN:
+			if (mainSoundFile)
+				audStream = makeMohawkWaveStream(_rivenSoundFile->getRawData(ID_TWAV, id));
+			else
+				audStream = makeMohawkWaveStream(_vm->getRawData(ID_TWAV, id));
+			break;
+		case GType_ZOOMBINI:
+			audStream = makeMohawkWaveStream(_vm->getRawData(ID_SND, id));
+			break;
+		case GType_CSAMTRAK:
+			if (mainSoundFile)
+				audStream = makeMohawkWaveStream(_vm->getRawData(ID_TWAV, id));
+			else
+				audStream = getCSAmtrakMusic(id);
+			break;
+		case GType_OLDLIVINGBOOKS:
+			audStream = makeOldMohawkWaveStream(_vm->getRawData(ID_WAV, id));
+			break;
+		default:
+			audStream = makeMohawkWaveStream(_vm->getRawData(ID_TWAV, id));
+	}
+	
+	if (audStream) {
+		_vm->_mixer->playInputStream(Audio::Mixer::kPlainSoundType, &handle->handle, audStream, -1, volume);
+		return &handle->handle;
+	}
+	
+	return NULL;
+}
+
+void Sound::playMidi(uint16 id) {
+	uint32 idTag;
+	if (!(_vm->getFeatures() & GF_HASMIDI)) {
+		warning ("Attempting to play MIDI in a game without MIDI");
+		return;
+	}
+
+	assert(_midiDriver && _midiParser);
+	
+	_midiParser->unloadMusic();
+	Common::SeekableReadStream *midi = _vm->getRawData(ID_TMID, id);
+	
+	idTag = midi->readUint32BE();
+	assert(idTag == ID_MHWK);
+	midi->readUint32BE(); // Skip size
+	idTag = midi->readUint32BE();
+	assert(idTag == ID_MIDI);
+	
+	byte *midiData = (byte *)malloc(midi->size() - 12); // Enough to cover MThd/Prg#/MTrk
+	
+	// Read the MThd Data
+	midi->read(midiData, 14);
+	
+	// Skip the unknown Prg# section
+	idTag = midi->readUint32BE();
+	assert(idTag == ID_PRG);
+	midi->skip(midi->readUint32BE());
+	
+	// Read the MTrk Data
+	uint32 mtrkSize = midi->size() - midi->pos();
+	midi->read(midiData + 14, mtrkSize);
+	
+	delete midi;
+
+	// Now, play it :)
+	if (!_midiParser->loadMusic(midiData, 14 + mtrkSize))
+		error ("Could not play MIDI music from tMID %04x\n", id);
+		
+	_midiDriver->setTimerCallback(_midiParser, MidiParser::timerCallback);
+}
+
+void Sound::playSLST(uint16 index, uint16 card) {
+	Common::SeekableReadStream *slstStream = _vm->getRawData(ID_SLST, card);
+	SLSTRecord slstRecord;
+	uint16 recordCount = slstStream->readUint16BE();
+	
+	for (uint16 i = 0; i < recordCount; i++) {
+		slstRecord.index = slstStream->readUint16BE();
+		slstRecord.sound_count = slstStream->readUint16BE();
+		slstRecord.sound_ids = new uint16[slstRecord.sound_count];
+
+		for (uint16 j = 0; j < slstRecord.sound_count; j++)
+			slstRecord.sound_ids[j] = slstStream->readUint16BE();
+
+		slstRecord.fade_flags = slstStream->readUint16BE();
+		slstRecord.loop = slstStream->readUint16BE();
+		slstRecord.global_volume = slstStream->readUint16BE();
+		slstRecord.u0 = slstStream->readUint16BE();			// Unknown
+
+		if (slstRecord.u0 > 1)
+			warning("slstRecord.u0: %d non-boolean", slstRecord.u0);
+
+		slstRecord.u1 = slstStream->readUint16BE();			// Unknown
+
+		if (slstRecord.u1 != 0)
+			warning("slstRecord.u1: %d non-zero", slstRecord.u1);
+
+		slstRecord.volumes = new uint16[slstRecord.sound_count];
+		slstRecord.balances = new int16[slstRecord.sound_count];
+		slstRecord.u2 = new uint16[slstRecord.sound_count];
+
+		for (uint16 j = 0; j < slstRecord.sound_count; j++)
+			slstRecord.volumes[j] = slstStream->readUint16BE();
+
+		for (uint16 j = 0; j < slstRecord.sound_count; j++)
+			slstRecord.balances[j] = slstStream->readSint16BE();	// negative = left, 0 = center, positive = right
+
+		for (uint16 j = 0; j < slstRecord.sound_count; j++) {
+			slstRecord.u2[j] = slstStream->readUint16BE();		// Unknown
+
+			if (slstRecord.u2[j] != 255 && slstRecord.u2[j] != 256)
+				warning("slstRecord.u2[%d]: %d not 255 or 256", j, slstRecord.u2[j]);
+		}
+
+		if (slstRecord.index == index) {
+			playSLST(slstRecord);
+			delete slstStream;
+			return;
+		}
+		
+		delete[] slstRecord.sound_ids;
+		delete[] slstRecord.volumes;
+		delete[] slstRecord.balances;
+		delete[] slstRecord.u2;
+	}
+	
+	delete slstStream;
+	// No matching records, assume we need to stop all SLST's
+	stopAllSLST();
+}
+
+void Sound::playSLST(SLSTRecord slstRecord) {
+	// End old sounds
+	for (uint16 i = 0; i < _currentSLSTSounds.size(); i++) {
+		bool noLongerPlay = true;
+		for (uint16 j = 0; j < slstRecord.sound_count; j++)
+			if (_currentSLSTSounds[i].id == slstRecord.sound_ids[j])
+				noLongerPlay = false;
+		if (noLongerPlay)
+			stopSLSTSound(i, (slstRecord.fade_flags & 1) != 0);
+	}
+	
+	// Start new sounds
+	for (uint16 i = 0; i < slstRecord.sound_count; i++) {
+		bool alreadyPlaying = false;
+		for (uint16 j = 0; j < _currentSLSTSounds.size(); j++) {
+			if (_currentSLSTSounds[j].id == slstRecord.sound_ids[i])
+				alreadyPlaying = true;
+		}
+		if (!alreadyPlaying) {
+			playSLSTSound(slstRecord.sound_ids[i],
+						 (slstRecord.fade_flags & (1 << 1)) != 0,
+						 slstRecord.loop != 0,
+						 slstRecord.volumes[i],
+						 slstRecord.balances[i]);
+		}
+	}
+}
+
+void Sound::stopAllSLST() {
+	for (uint16 i = 0; i < _currentSLSTSounds.size(); i++)
+		_vm->_mixer->stopHandle(*_currentSLSTSounds[i].handle);
+	_currentSLSTSounds.clear();
+}
+
+static int8 convertBalance(int16 balance) {
+	return (int8)(balance >> 8);
+}
+
+void Sound::playSLSTSound(uint16 id, bool fade, bool loop, uint16 volume, int16 balance) {
+	// WORKAROUND: Some Riven SLST entries have a volume of 0, so we just ignore them.
+	if (volume == 0)
+		return;
+
+	SLSTSndHandle sndHandle;
+	sndHandle.handle = new Audio::SoundHandle();
+	sndHandle.id = id;
+	_currentSLSTSounds.push_back(sndHandle);
+	
+	Audio::AudioStream *audStream = makeMohawkWaveStream(_rivenSoundFile->getRawData(ID_TWAV, id), loop);
+	
+	// The max mixer volume is 255 and the max Riven volume is 256. Just change it to 255.
+	if (volume == 256)
+		volume = 255;
+	
+	// TODO: Handle fading, possibly just raise the volume of the channel in increments?
+	
+	_vm->_mixer->playInputStream(Audio::Mixer::kPlainSoundType, sndHandle.handle, audStream, -1, volume, convertBalance(balance));
+}
+
+void Sound::stopSLSTSound(uint16 index, bool fade) {
+	// TODO: Fade out, mixer needs to be extended to get volume on a handle	
+	_vm->_mixer->stopHandle(*_currentSLSTSounds[index].handle);
+	_currentSLSTSounds.remove_at(index);
+}
+
+void Sound::pauseSLST() {
+	for (uint16 i = 0; i < _currentSLSTSounds.size(); i++)
+		_vm->_mixer->pauseHandle(*_currentSLSTSounds[i].handle, true);
+}
+
+void Sound::resumeSLST() {
+	for (uint16 i = 0; i < _currentSLSTSounds.size(); i++)
+		_vm->_mixer->pauseHandle(*_currentSLSTSounds[i].handle, false);
+}
+
+Audio::AudioStream *Sound::getCSAmtrakMusic(uint16 id) {
+	char filename[18];
+	sprintf(filename, "MUSIC/MUSIC%02d.MHK", id);
+	MohawkFile *file = new MohawkFile();
+	file->open(filename);
+	Audio::AudioStream *audStream = makeMohawkWaveStream(file->getRawData(ID_TWAV, 2000 + id));
+	delete file;
+	return audStream;
+}
+
+Audio::AudioStream *Sound::makeMohawkWaveStream(Common::SeekableReadStream *stream, bool loop) {
+	bool foundData = false;
+	uint32 tag = 0;
+	ADPC_Chunk adpc;
+	Cue_Chunk cue;
+	Data_Chunk data_chunk;
+
+	if (stream->readUint32BE() == ID_MHWK) // MHWK tag again
+		debug(2, "Found Tag MHWK");
+	else
+		error ("Could not find tag \'MHWK\'");
+
+	stream->readUint32BE(); // Skip size
+
+	if (stream->readUint32BE() == ID_WAVE)
+		debug(2, "Found Tag WAVE");
+	else
+		error ("Could not find tag \'WAVE\'");
+
+	while (!foundData) {
+		tag = stream->readUint32BE();
+
+		switch (tag) {
+			case ID_ADPC:
+				debug(2, "Found Tag ADPC");
+				// Riven ADPCM Sound Only
+				// NOTE: This is completely useless for us. All of this
+				// is already in the ADPCM decoder in /sound.
+				adpc.size = stream->readUint32BE();
+				adpc.u0 = stream->readUint16BE();
+				adpc.channels = stream->readUint16BE();
+				adpc.u1 = stream->readUint32BE();
+
+				for (uint16 i = 0; i < adpc.channels; i++)
+					adpc.u2[i] = stream->readUint32BE();
+				if (adpc.u0 == 2) {
+					adpc.u3 = stream->readUint32BE();
+					for (uint16 i = 0; i < adpc.channels; i++)
+						adpc.u4[i] = stream->readUint32BE();
+				}
+				break;
+			case ID_CUE:
+				debug(2, "Found Tag Cue#");
+				// I have not tested this with Myst, but the one Riven test-case,
+				// pspit tWAV 3, has two cue points: "Beg Loop" and "End Loop".
+				// So, my guess is that a cue chunk just holds where to loop the
+				// sound. Some cue chunks even have no point count (such as
+				// Myst's intro.dat MSND 2. So, my theory is that a cue chunk
+				// always represents a loop, and if there is a point count, that
+				// represents the points from which to loop.
+				//
+				// This theory is probably not entirely true anymore. I've found
+				// that the values (which were previously unknown) in the DATA
+				// chunk are for looping. Since it was only used in Myst, it was
+				// always 10 0's, Tito just thought it was useless. I'm still not
+				// sure what purpose this has.
+		
+				cue.size = stream->readUint32BE();
+				cue.point_count = stream->readUint16BE();
+
+				if (cue.point_count == 0)
+					debug (2, "Cue# chunk found with no points!");
+				else
+					debug (2, "Cue# chunk found with %d point(s)!", cue.point_count);
+
+				for (uint16 i = 0; i < cue.point_count; i++) {
+					cue.cueList[i].position = stream->readUint32BE();
+					cue.cueList[i].length = stream->readByte();
+					for (byte j = 0; j < cue.cueList[i].length; j++)
+						cue.cueList[i].name += stream->readByte();
+					// Realign to uint16 boundaries...
+					if (!(cue.cueList[i].length & 1))
+						stream->readByte();
+					debug (3, "Cue# chunk point %d: %s", i, cue.cueList[i].name.c_str());
+				}
+				break;
+			case ID_DATA:
+				debug(2, "Found Tag DATA");
+				// We subtract 20 from the actual chunk size, which is the total size
+				// of the chunk's header
+				data_chunk.size = stream->readUint32BE() - 20;
+				data_chunk.sample_rate = stream->readUint16BE();
+				data_chunk.sample_count = stream->readUint32BE();
+				data_chunk.bitsPerSample = stream->readByte();
+				data_chunk.channels = stream->readByte();
+				data_chunk.encoding = stream->readUint16BE();
+				data_chunk.loop = stream->readUint16BE();
+				data_chunk.loopStart = stream->readUint32BE();
+				data_chunk.loopEnd = stream->readUint32BE();
+
+				data_chunk.audio_data = (byte *)malloc(data_chunk.size);
+				stream->read(data_chunk.audio_data, data_chunk.size);
+				foundData = true;
+				break;
+			default:
+				error ("Unknown tag found in 'tWAV' chunk -- \'%s\'", tag2str(tag));
+		}
+	}
+	
+	// makeMohawkWaveStream always takes control of the original stream
+	delete stream;
+
+	// The sound in Myst uses raw unsigned 8-bit data
+	// The sound in the CD version of Riven is encoded in Intel DVI ADPCM
+	// The sound in the DVD version of Riven is encoded in MPEG-2 Layer II or Intel DVI ADPCM
+	if (data_chunk.encoding == kCodecRaw) {
+		byte flags = Audio::Mixer::FLAG_UNSIGNED|Audio::Mixer::FLAG_AUTOFREE;
+		if (data_chunk.channels == 2)
+			flags |= Audio::Mixer::FLAG_STEREO;
+		if (data_chunk.loop == 0xFFFF || loop)
+			flags |= Audio::Mixer::FLAG_LOOP;
+		return Audio::makeLinearInputStream(data_chunk.audio_data, data_chunk.size, data_chunk.sample_rate, flags, data_chunk.loopStart, data_chunk.loopEnd);
+	} else if (data_chunk.encoding == kCodecADPCM) {
+		Common::MemoryReadStream *dataStream = new Common::MemoryReadStream(data_chunk.audio_data, data_chunk.size, Common::DisposeAfterUse::YES);
+		uint32 blockAlign = data_chunk.channels * data_chunk.bitsPerSample / 8;
+		return Audio::makeADPCMStream(dataStream, true, data_chunk.size, Audio::kADPCMIma, data_chunk.sample_rate, data_chunk.channels, blockAlign, !loop);
+	} else if (data_chunk.encoding == kCodecMPEG2) {
+#ifdef USE_MAD
+		Common::MemoryReadStream *dataStream = new Common::MemoryReadStream(data_chunk.audio_data, data_chunk.size, Common::DisposeAfterUse::YES);
+		return Audio::makeMP3Stream(dataStream, true, 0, 0, !loop);
+#else
+		warning ("MAD library not included - unable to play MP2 audio");
+#endif
+	} else {
+		error ("Unknown Mohawk WAVE encoding %d", data_chunk.encoding);
+	}
+
+	return NULL;
+}
+
+Audio::AudioStream *Sound::makeOldMohawkWaveStream(Common::SeekableReadStream *stream, bool loop) {
+	uint16 header = stream->readUint16BE();
+	uint16 rate = 0;
+	uint32 size = 0;
+	
+	if (header == 'Wv') { // Big Endian
+		rate = stream->readUint16BE();
+		stream->skip(10); // Loop chunk, like the newer format?
+		size = stream->readUint32BE();
+	} else if (header == 'vW') { // Little Endian
+		rate = stream->readUint16LE();
+		stream->skip(10); // Loop chunk, like the newer format?
+		size = stream->readUint32LE();
+	} else
+		error("Could not find Old Mohawk Sound header");
+		
+	assert(size);
+	byte *data = (byte *)malloc(size);
+	stream->read(data, size);
+	delete stream;
+	
+	byte flags = Audio::Mixer::FLAG_UNSIGNED|Audio::Mixer::FLAG_AUTOFREE;
+	
+	if (loop)
+		flags |= Audio::Mixer::FLAG_LOOP;
+	
+	return Audio::makeLinearInputStream(data, size, rate, flags, 0, 0);
+}
+
+SndHandle *Sound::getHandle() {
+	for (uint32 i = 0; i < _handles.size(); i++) {
+		if (_handles[i].type == kFreeHandle)
+			return &_handles[i];
+
+		if (!_vm->_mixer->isSoundHandleActive(_handles[i].handle)) {
+			_handles[i].type = kFreeHandle;
+			return &_handles[i];
+		}
+	}
+
+	// Let's add a new sound handle!
+	SndHandle handle;
+	handle.handle = Audio::SoundHandle();
+	handle.type = kFreeHandle;
+	_handles.push_back(handle);
+
+	return &_handles[_handles.size() - 1];
+}
+
+void Sound::stopSound() {
+	for (uint32 i = 0; i < _handles.size(); i++)
+		if (_handles[i].type == kUsedHandle) {
+			_vm->_mixer->stopHandle(_handles[i].handle);
+			_handles[i].type = kFreeHandle;
+		}
+}
+
+void Sound::pauseSound() {
+	for (uint32 i = 0; i < _handles.size(); i++)
+		if (_handles[i].type == kUsedHandle)
+			_vm->_mixer->pauseHandle(_handles[i].handle, true);
+}
+
+void Sound::resumeSound() {
+	for (uint32 i = 0; i < _handles.size(); i++)
+		if (_handles[i].type == kUsedHandle)
+			_vm->_mixer->pauseHandle(_handles[i].handle, false);
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/sound.h b/engines/mohawk/sound.h
new file mode 100644
index 0000000000..44c4409b0c
--- /dev/null
+++ b/engines/mohawk/sound.h
@@ -0,0 +1,157 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#ifndef MOHAWK_SOUND_H
+#define MOHAWK_SOUND_H
+
+#include "common/scummsys.h"
+#include "common/str.h"
+
+#include "sound/audiostream.h"
+#include "sound/adpcm.h"
+#include "sound/mididrv.h"
+#include "sound/midiparser.h"
+#include "sound/mixer.h"
+
+#include "mohawk/mohawk.h"
+#include "mohawk/file.h"
+
+namespace Mohawk {
+
+#define MAX_CHANNELS 2         // Can there be more than 2?
+#define CUE_MAX 256
+
+struct SLSTRecord {
+	uint16 index;
+	uint16 sound_count;
+	uint16* sound_ids;
+	uint16 fade_flags;
+	uint16 loop;
+	uint16 global_volume;
+	uint16 u0;
+	uint16 u1;
+	uint16* volumes;
+	int16* balances;
+	uint16* u2;
+};
+
+enum SndHandleType {
+	kFreeHandle,
+	kUsedHandle
+};
+
+struct SndHandle {
+	Audio::SoundHandle handle;
+	SndHandleType type;
+};
+
+struct SLSTSndHandle {
+	Audio::SoundHandle *handle;
+	uint16 id;
+};
+
+struct ADPC_Chunk {            // Appears to only exist if there isn't MPEG-2 Audio
+	uint32 size;
+	uint16 u0;                 // Unknown (2 when there's a Cue# Chunk, 1 when there's not)
+	uint16 channels;
+	uint32 u1;                 // Unknown (always 0)
+	uint32 u2[MAX_CHANNELS];   // Unknown (0x00400000 for both channels)
+
+	// If there is a Cue# chunk, there can be two more variables:
+	uint32 u3;
+	uint32 u4[MAX_CHANNELS];
+};
+
+struct Cue_Chunk {
+	uint32 size;
+	uint16 point_count;
+	struct {
+		uint32 position;
+		byte length;
+		Common::String name;
+	} cueList[CUE_MAX];
+};
+
+enum {
+	kCodecRaw = 0,
+	kCodecADPCM = 1,
+	kCodecMPEG2 = 2
+};
+
+struct Data_Chunk {
+	uint32 size;
+	uint16 sample_rate;
+	uint32 sample_count;
+	byte bitsPerSample;
+	byte channels;
+	uint16 encoding;
+	uint16 loop;
+	uint32 loopStart;
+	uint32 loopEnd;
+	byte* audio_data;
+};
+
+class MohawkEngine;
+
+class Sound {
+public:
+	Sound(MohawkEngine*);
+	~Sound();
+	
+	void loadRivenSounds(uint16 stack);
+	Audio::SoundHandle *playSound(uint16 id, bool mainSoundFile = true, byte volume = Audio::Mixer::kMaxChannelVolume);
+	void playMidi(uint16 id);
+	void stopSound();
+	void pauseSound();
+	void resumeSound();
+	void playSLST(uint16 index, uint16 card);
+	void playSLST(SLSTRecord slstRecord);
+	void pauseSLST();
+	void resumeSLST();
+	void stopAllSLST();
+                
+private:
+	MohawkEngine *_vm;
+	MohawkFile *_rivenSoundFile;
+	MidiDriver *_midiDriver;
+	MidiParser *_midiParser;
+
+	static Audio::AudioStream *getCSAmtrakMusic(uint16 id);
+	static Audio::AudioStream *makeMohawkWaveStream(Common::SeekableReadStream *stream, bool loop = false);
+	static Audio::AudioStream *makeOldMohawkWaveStream(Common::SeekableReadStream *stream, bool loop = false);
+	void initMidi();
+
+	Common::Array<SndHandle> _handles;
+	SndHandle *getHandle();
+	
+	// Riven specific
+	void playSLSTSound(uint16 index, bool fade, bool loop, uint16 volume, int16 balance);
+	void stopSLSTSound(uint16 id, bool fade);
+	Common::Array<SLSTSndHandle> _currentSLSTSounds;
+};
+
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/video/cinepak.cpp b/engines/mohawk/video/cinepak.cpp
new file mode 100644
index 0000000000..d5fa5fbcf6
--- /dev/null
+++ b/engines/mohawk/video/cinepak.cpp
@@ -0,0 +1,283 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "mohawk/video/cinepak.h"
+
+#include "common/system.h"
+#include "graphics/conversion.h" // For YUV2RGB
+
+// Code here partially based off of ffmpeg ;)
+
+namespace Mohawk {
+	
+#define PUT_PIXEL(offset, lum, u, v) \
+	Graphics::YUV2RGB(lum, u, v, r, g, b); \
+	if (_pixelFormat.bytesPerPixel == 2) \
+		*((uint16 *)_curFrame.surface->pixels + offset) = _pixelFormat.RGBToColor(r, g, b); \
+	else \
+		*((uint32 *)_curFrame.surface->pixels + offset) = _pixelFormat.RGBToColor(r, g, b)
+
+CinepakDecoder::CinepakDecoder() : Graphics::Codec() {
+	_curFrame.surface = NULL;
+	_curFrame.strips = NULL;
+	_y = 0;
+	_pixelFormat = g_system->getScreenFormat();
+	
+	// We're going to have to dither if we're running in 8bpp.
+	// We'll take RGBA8888 for best color performance in this case.
+	if (_pixelFormat.bytesPerPixel == 1)
+		_pixelFormat = Graphics::PixelFormat(4, 8, 8, 8, 8, 24, 16, 8, 0);
+}
+
+CinepakDecoder::~CinepakDecoder() {
+	if (_curFrame.surface)
+		_curFrame.surface->free();
+	delete[] _curFrame.strips;
+}
+
+Graphics::Surface *CinepakDecoder::decodeImage(Common::SeekableReadStream *stream) {
+	_curFrame.flags = stream->readByte();
+	_curFrame.length = (stream->readByte() << 16) + stream->readUint16BE();
+	_curFrame.width = stream->readUint16BE();
+	_curFrame.height = stream->readUint16BE();
+	_curFrame.stripCount = stream->readUint16BE();
+	
+	if (_curFrame.strips == NULL)
+		_curFrame.strips = new CinepakStrip[_curFrame.stripCount];
+	
+	debug (4, "Cinepak Frame: Width = %d, Height = %d, Strip Count = %d", _curFrame.width, _curFrame.height, _curFrame.stripCount);
+	
+#if 0
+	// Borrowed from FFMPEG. This should cut out the extra data Cinepak for Sega has (which is useless).
+	// The theory behind this is that this is here to confuse standard Cinepak decoders. But, we won't let that happen! ;)
+	if (_curFrame.length != (uint32)stream->size()) {
+		if (stream->readUint16BE() == 0xFE00)
+			stream->readUint32BE();
+	}
+#endif
+	
+	if (!_curFrame.surface) {
+		_curFrame.surface = new Graphics::Surface();
+		_curFrame.surface->create(_curFrame.width, _curFrame.height, _pixelFormat.bytesPerPixel);
+	}
+	
+	// Reset the y variable.
+	_y = 0;
+	
+	for (uint16 i = 0; i < _curFrame.stripCount; i++) {
+		if (i > 0 && !(_curFrame.flags & 1)) { // Use codebooks from last strip
+			for (uint16 j = 0; j < 256; j++) {
+				_curFrame.strips[i].v1_codebook[j] = _curFrame.strips[i - 1].v1_codebook[j];
+				_curFrame.strips[i].v4_codebook[j] = _curFrame.strips[i - 1].v4_codebook[j];
+			}
+		}
+	
+		_curFrame.strips[i].id = stream->readUint16BE();
+		_curFrame.strips[i].length = stream->readUint16BE() - 12; // Subtract the 12 byte header
+		_curFrame.strips[i].rect.top = _y; stream->readUint16BE(); // Ignore, substitute with our own.
+		_curFrame.strips[i].rect.left = 0; stream->readUint16BE(); // Ignore, substitute with our own
+		_curFrame.strips[i].rect.bottom = _y + stream->readUint16BE();
+		_curFrame.strips[i].rect.right = _curFrame.width; stream->readUint16BE(); // Ignore, substitute with our own
+		
+		//printf ("Left = %d, Top = %d, Right = %d, Bottom = %d\n", _curFrame.strips[i].rect.left, _curFrame.strips[i].rect.top, _curFrame.strips[i].rect.right, _curFrame.strips[i].rect.bottom);
+		
+		// Sanity check. Because Cinepak is based on 4x4 blocks, the width and height of each strip needs to be divisible by 4.
+		assert(!(_curFrame.strips[i].rect.width() % 4) && !(_curFrame.strips[i].rect.height() % 4));
+		
+		uint32 pos = stream->pos();
+		
+		while ((uint32)stream->pos() < (pos + _curFrame.strips[i].length) && !stream->eos()) {
+			byte chunkID = stream->readByte();
+			
+			if (stream->eos())
+				break;
+			
+			uint32 chunkSize = (stream->readByte() << 16) + stream->readUint16BE() - 4; // 24bit
+			int32 startPos = stream->pos();
+			
+			switch (chunkID) {
+				case 0x20:
+				case 0x21:
+				case 0x24:
+				case 0x25:
+					loadCodebook(stream, i, 4, chunkID, chunkSize);
+					break;
+				case 0x22:
+				case 0x23:
+				case 0x26:
+				case 0x27:
+					loadCodebook(stream, i, 1, chunkID, chunkSize);
+					break;
+				case 0x30:
+				case 0x31:
+				case 0x32:
+					decodeVectors(stream, i, chunkID, chunkSize);
+					break;
+				default:
+					warning("Unknown Cinepak chunk ID %02x", chunkID);
+					return _curFrame.surface;
+			}
+			
+			if (stream->pos() != startPos + (int32)chunkSize)
+				stream->seek(startPos + chunkSize);
+		}
+		
+		_y = _curFrame.strips[i].rect.bottom;
+	}
+	
+	return _curFrame.surface;
+}
+
+void CinepakDecoder::loadCodebook(Common::SeekableReadStream *stream, uint16 strip, byte codebookType, byte chunkID, uint32 chunkSize) {
+	CinepakCodebook *codebook = (codebookType == 1) ? _curFrame.strips[strip].v1_codebook : _curFrame.strips[strip].v4_codebook;
+
+	int32 startPos = stream->pos();
+    uint32 flag = 0, mask = 0;
+
+    for (uint16 i = 0; i < 256; i++) {
+        if ((chunkID & 0x01) && !(mask >>= 1)) {
+            if ((stream->pos() - startPos + 4) > (int32)chunkSize)
+                break;
+
+            flag  = stream->readUint32BE();
+            mask  = 0x80000000;
+        }
+
+        if (!(chunkID & 0x01) || (flag & mask)) {
+			byte n = (chunkID & 0x04) ? 4 : 6;
+            if ((stream->pos() - startPos + n) > (int32)chunkSize)
+                break;
+
+			for (byte j = 0; j < 4; j++)
+				codebook[i].y[j] = stream->readByte();
+				
+            if (n == 6) {
+                codebook[i].u  = stream->readByte() + 128;
+                codebook[i].v  = stream->readByte() + 128;
+            } else {
+				/* this codebook type indicates either greyscale or
+				* palettized video; if palettized, U & V components will
+				* not be used so it is safe to set them to 128 for the
+				* benefit of greyscale rendering in YUV420P */
+                codebook[i].u  = 128;
+                codebook[i].v  = 128;
+            }
+        }
+    }
+}
+
+void CinepakDecoder::decodeVectors(Common::SeekableReadStream *stream, uint16 strip, byte chunkID, uint32 chunkSize) {
+    uint32 flag = 0, mask = 0;
+    uint32 iy[4];
+	int32 startPos = stream->pos();
+	byte r = 0, g = 0, b = 0;
+
+    for (uint16 y = _curFrame.strips[strip].rect.top; y < _curFrame.strips[strip].rect.bottom; y += 4) {
+        iy[0] = _curFrame.strips[strip].rect.left + y * _curFrame.width;
+        iy[1] = iy[0] + _curFrame.width;
+        iy[2] = iy[1] + _curFrame.width;
+        iy[3] = iy[2] + _curFrame.width;
+
+        for (uint16 x = _curFrame.strips[strip].rect.left; x < _curFrame.strips[strip].rect.right; x += 4) {
+            if ((chunkID & 0x01) && !(mask >>= 1)) {
+                if ((stream->pos() - startPos + 4) > (int32)chunkSize)
+                    return;
+
+                flag  = stream->readUint32BE();
+                mask  = 0x80000000;
+            }
+
+            if (!(chunkID & 0x01) || (flag & mask)) {
+                if (!(chunkID & 0x02) && !(mask >>= 1)) {
+                    if ((stream->pos() - startPos + 4) > (int32)chunkSize)
+                        return;
+
+                    flag  = stream->readUint32BE();
+                    mask  = 0x80000000;
+                }
+
+                if ((chunkID & 0x02) || (~flag & mask)) {
+                    if ((stream->pos() - startPos + 1) > (int32)chunkSize)
+                        return;
+
+					// Get the codebook
+					CinepakCodebook codebook = _curFrame.strips[strip].v1_codebook[stream->readByte()];
+					
+					PUT_PIXEL(iy[0] + 0, codebook.y[0], codebook.u, codebook.v);
+					PUT_PIXEL(iy[0] + 1, codebook.y[0], codebook.u, codebook.v);
+					PUT_PIXEL(iy[1] + 0, codebook.y[0], codebook.u, codebook.v);
+					PUT_PIXEL(iy[1] + 1, codebook.y[0], codebook.u, codebook.v);
+					
+					PUT_PIXEL(iy[0] + 2, codebook.y[1], codebook.u, codebook.v);
+					PUT_PIXEL(iy[0] + 3, codebook.y[1], codebook.u, codebook.v);
+					PUT_PIXEL(iy[1] + 2, codebook.y[1], codebook.u, codebook.v);
+					PUT_PIXEL(iy[1] + 3, codebook.y[1], codebook.u, codebook.v);
+					
+					PUT_PIXEL(iy[2] + 0, codebook.y[2], codebook.u, codebook.v);
+					PUT_PIXEL(iy[2] + 1, codebook.y[2], codebook.u, codebook.v);
+					PUT_PIXEL(iy[3] + 0, codebook.y[2], codebook.u, codebook.v);
+					PUT_PIXEL(iy[3] + 1, codebook.y[2], codebook.u, codebook.v);
+
+					PUT_PIXEL(iy[2] + 2, codebook.y[3], codebook.u, codebook.v);
+					PUT_PIXEL(iy[2] + 3, codebook.y[3], codebook.u, codebook.v);
+					PUT_PIXEL(iy[3] + 2, codebook.y[3], codebook.u, codebook.v);
+					PUT_PIXEL(iy[3] + 3, codebook.y[3], codebook.u, codebook.v);
+                } else if (flag & mask) {
+                    if ((stream->pos() - startPos + 4) > (int32)chunkSize)
+                        return;
+
+                    CinepakCodebook codebook = _curFrame.strips[strip].v4_codebook[stream->readByte()];
+					PUT_PIXEL(iy[0] + 0, codebook.y[0], codebook.u, codebook.v);
+					PUT_PIXEL(iy[0] + 1, codebook.y[1], codebook.u, codebook.v);
+					PUT_PIXEL(iy[1] + 0, codebook.y[2], codebook.u, codebook.v);
+					PUT_PIXEL(iy[1] + 1, codebook.y[3], codebook.u, codebook.v);
+					
+                    codebook = _curFrame.strips[strip].v4_codebook[stream->readByte()];
+					PUT_PIXEL(iy[0] + 2, codebook.y[0], codebook.u, codebook.v);
+					PUT_PIXEL(iy[0] + 3, codebook.y[1], codebook.u, codebook.v);
+					PUT_PIXEL(iy[1] + 2, codebook.y[2], codebook.u, codebook.v);
+					PUT_PIXEL(iy[1] + 3, codebook.y[3], codebook.u, codebook.v);
+
+                    codebook = _curFrame.strips[strip].v4_codebook[stream->readByte()];
+					PUT_PIXEL(iy[2] + 0, codebook.y[0], codebook.u, codebook.v);
+					PUT_PIXEL(iy[2] + 1, codebook.y[1], codebook.u, codebook.v);
+					PUT_PIXEL(iy[3] + 0, codebook.y[2], codebook.u, codebook.v);
+					PUT_PIXEL(iy[3] + 1, codebook.y[3], codebook.u, codebook.v);
+
+                    codebook = _curFrame.strips[strip].v4_codebook[stream->readByte()];
+					PUT_PIXEL(iy[2] + 2, codebook.y[0], codebook.u, codebook.v);
+					PUT_PIXEL(iy[2] + 3, codebook.y[1], codebook.u, codebook.v);
+					PUT_PIXEL(iy[3] + 2, codebook.y[2], codebook.u, codebook.v);
+					PUT_PIXEL(iy[3] + 3, codebook.y[3], codebook.u, codebook.v);
+                }
+            }
+
+			for (byte i = 0; i < 4; i++)
+				iy[i] += 4;
+        }
+    }
+}
+
+}
diff --git a/engines/mohawk/video/cinepak.h b/engines/mohawk/video/cinepak.h
new file mode 100644
index 0000000000..a94d879bdb
--- /dev/null
+++ b/engines/mohawk/video/cinepak.h
@@ -0,0 +1,80 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#ifndef CINEPAK_H
+#define CINEPAK_H
+
+#include "common/scummsys.h"
+#include "common/stream.h"
+#include "common/rect.h"
+#include "graphics/surface.h"
+#include "graphics/pixelformat.h"
+
+#include "graphics/video/codecs/codec.h"
+
+namespace Mohawk {
+
+struct CinepakCodebook {
+	byte y[4];
+	byte u, v;
+};
+
+struct CinepakStrip {
+	uint16 id;
+	uint16 length;
+	Common::Rect rect;
+	CinepakCodebook v1_codebook[256], v4_codebook[256];
+};
+
+struct CinepakFrame {
+	byte flags;
+	uint32 length;
+	uint16 width;
+	uint16 height;
+	uint16 stripCount;
+	CinepakStrip *strips;
+	
+	Graphics::Surface *surface;
+};
+
+class CinepakDecoder : public Graphics::Codec {
+public:
+	CinepakDecoder();
+	~CinepakDecoder();
+
+	Graphics::Surface *decodeImage(Common::SeekableReadStream *stream);
+
+private:
+	CinepakFrame _curFrame;
+	int32 _y;
+	Graphics::PixelFormat _pixelFormat;
+	
+	void loadCodebook(Common::SeekableReadStream *stream, uint16 strip, byte codebookType, byte chunkID, uint32 chunkSize);
+	void decodeVectors(Common::SeekableReadStream *stream, uint16 strip, byte chunkID, uint32 chunkSize);
+};
+
+}
+
+#endif
diff --git a/engines/mohawk/video/qdm2.cpp b/engines/mohawk/video/qdm2.cpp
new file mode 100644
index 0000000000..23a09f05d1
--- /dev/null
+++ b/engines/mohawk/video/qdm2.cpp
@@ -0,0 +1,3064 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+// Based off ffmpeg's QDM2 decoder
+
+#include "mohawk/video/qdm2.h"
+#include "mohawk/video/qdm2data.h"
+
+#include "common/system.h"
+
+namespace Mohawk {
+
+// Fix compilation for non C99-compliant compilers, like MSVC
+#ifndef int64_t
+typedef signed long long int int64_t;
+#endif
+
+// Integer log2 function. This is much faster than invoking
+// double precision C99 log2 math functions or equivalent, since
+// this is only used to determine maximum number of bits needed
+// i.e. only non-fractional part is needed. Also, the double
+// version is incorrect for exact cases due to floating point
+// rounding errors.
+static inline int scummvm_log2(int n) {
+	int ret = -1;
+	while(n != 0) {
+		n /= 2;
+		ret++;
+	}
+	return ret;
+}
+
+#define QDM2_LIST_ADD(list, size, packet) \
+	do { \
+		if (size > 0) \
+			list[size - 1].next = &list[size]; \
+		list[size].packet = packet; \
+		list[size].next = NULL; \
+		size++; \
+	} while(0)
+
+// Result is 8, 16 or 30
+#define QDM2_SB_USED(subSampling) (((subSampling) >= 2) ? 30 : 8 << (subSampling))
+
+#define FIX_NOISE_IDX(noiseIdx) \
+	if ((noiseIdx) >= 3840) \
+		(noiseIdx) -= 3840 \
+
+#define SB_DITHERING_NOISE(sb, noiseIdx) (_noiseTable[(noiseIdx)++] * sb_noise_attenuation[(sb)])
+
+static inline void initGetBits(GetBitContext *s, const uint8 *buffer, int bitSize) {
+	int bufferSize = (bitSize + 7) >> 3;
+
+	debug(1, "void initGetBits(GetBitContext *s, const uint8 *buffer, int bitSize)");
+
+	if (bufferSize < 0 || bitSize < 0) {
+		bufferSize = bitSize = 0;
+		buffer = NULL;
+	}
+
+	s->buffer = buffer;
+	s->sizeInBits = bitSize;
+	s->bufferEnd = buffer + bufferSize;
+	s->index = 0;
+}
+
+static inline int getBitsCount(GetBitContext *s) {
+	debug(1, "int getBitsCount(GetBitContext *s)");
+	return s->index;
+}
+
+static inline unsigned int getBits1(GetBitContext *s) {
+	int index;
+	uint8 result;
+
+	debug(1, "unsigned int getBits1(GetBitContext *s)");
+
+	index = s->index;
+	result = s->buffer[index >> 3];
+
+	debug(1, "index : %d", index);
+
+	result >>= (index & 0x07);
+	result &= 1;
+	index++;
+	s->index = index;
+
+	return result;
+}
+
+static inline unsigned int getBits(GetBitContext *s, int n) {
+	int tmp, reCache, reIndex;
+
+	debug(1, "unsigned int getBits(GetBitContext *s, int n)");
+
+	reIndex = s->index;
+
+	debug(1, "reIndex : %d", reIndex);
+
+	reCache = READ_LE_UINT32((const uint8 *)s->buffer + (reIndex >> 3)) >> (reIndex & 0x07);
+
+	tmp = (reCache) & ((uint32)0xffffffff >> (32 - n));
+
+	s->index = reIndex + n;
+
+	return tmp;
+}
+
+static inline void skipBits(GetBitContext *s, int n) {
+	int reIndex, reCache;
+
+	debug(1, "void skipBits(GetBitContext *s, int n)");
+
+	reIndex = s->index;
+	reCache = 0;
+
+	debug(1, "reIndex : %d", reIndex);
+
+	reCache = READ_LE_UINT32((const uint8 *)s->buffer + (reIndex >> 3)) >> (reIndex & 0x07);
+	s->index = reIndex + n;
+}
+
+#define BITS_LEFT(length, gb) ((length) - getBitsCount((gb)))
+
+static int splitRadixPermutation(int i, int n, int inverse) {
+	if (n <= 2)
+		return i & 1;
+		
+	int m = n >> 1;
+	
+	if(!(i & m))
+		return splitRadixPermutation(i, m, inverse) * 2;
+
+	m >>= 1;
+
+	if (inverse == !(i & m))
+		return splitRadixPermutation(i, m, inverse) * 4 + 1;
+
+	return splitRadixPermutation(i, m, inverse) * 4 - 1;
+}
+
+// sin(2*pi*x/n) for 0<=x<n/4, followed by n/2<=x<3n/4
+float ff_sin_16[8];
+float ff_sin_32[16];
+float ff_sin_64[32];
+float ff_sin_128[64];
+float ff_sin_256[128];
+float ff_sin_512[256];
+float ff_sin_1024[512];
+float ff_sin_2048[1024];
+float ff_sin_4096[2048];
+float ff_sin_8192[4096];
+float ff_sin_16384[8192];
+float ff_sin_32768[16384];
+float ff_sin_65536[32768];
+
+float *ff_sin_tabs[] = {
+	NULL, NULL, NULL, NULL,
+	ff_sin_16, ff_sin_32, ff_sin_64, ff_sin_128, ff_sin_256, ff_sin_512, ff_sin_1024,
+	ff_sin_2048, ff_sin_4096, ff_sin_8192, ff_sin_16384, ff_sin_32768, ff_sin_65536,
+};
+
+// cos(2*pi*x/n) for 0<=x<=n/4, followed by its reverse
+float ff_cos_16[8];
+float ff_cos_32[16];
+float ff_cos_64[32];
+float ff_cos_128[64];
+float ff_cos_256[128];
+float ff_cos_512[256];
+float ff_cos_1024[512];
+float ff_cos_2048[1024];
+float ff_cos_4096[2048];
+float ff_cos_8192[4096];
+float ff_cos_16384[8192];
+float ff_cos_32768[16384];
+float ff_cos_65536[32768];
+
+float *ff_cos_tabs[] = {
+	NULL, NULL, NULL, NULL,
+	ff_cos_16, ff_cos_32, ff_cos_64, ff_cos_128, ff_cos_256, ff_cos_512, ff_cos_1024,
+	ff_cos_2048, ff_cos_4096, ff_cos_8192, ff_cos_16384, ff_cos_32768, ff_cos_65536,
+};
+
+void initCosineTables(int index) {
+	int m = 1 << index;
+	double freq = 2 * PI / m;
+	float *tab = ff_cos_tabs[index];
+
+	for (int i = 0; i <= m / 4; i++)
+		tab[i] = cos(i * freq);
+
+	for (int i = 1; i < m / 4; i++)
+		tab[m / 2 - i] = tab[i];
+}
+
+void fftPermute(FFTContext *s, FFTComplex *z) {
+	const uint16 *revtab = s->revtab;
+	int np = 1 << s->nbits;
+
+	if (s->tmpBuf) {
+		// TODO: handle split-radix permute in a more optimal way, probably in-place
+		for (int j = 0; j < np; j++)
+			s->tmpBuf[revtab[j]] = z[j];
+		memcpy(z, s->tmpBuf, np * sizeof(FFTComplex));
+		return;
+	}
+
+	// reverse
+	for (int j = 0; j < np; j++) {
+		int k = revtab[j];
+		if (k < j) {
+			FFTComplex tmp = z[k];
+			z[k] = z[j];
+			z[j] = tmp;
+		}
+	}
+}
+
+#define DECL_FFT(n,n2,n4) \
+static void fft##n(FFTComplex *z) { \
+	fft##n2(z); \
+	fft##n4(z + n4 * 2); \
+	fft##n4(z + n4 * 3); \
+	pass(z, ff_cos_##n, n4 / 2); \
+}
+
+#ifndef M_SQRT1_2
+#define M_SQRT1_2 7.0710678118654752440E-1
+#endif
+
+#define sqrthalf (float)M_SQRT1_2
+
+#define BF(x,y,a,b) { \
+	x = a - b; \
+	y = a + b; \
+}
+
+#define BUTTERFLIES(a0, a1, a2, a3) { \
+	BF(t3, t5, t5, t1); \
+	BF(a2.re, a0.re, a0.re, t5); \
+	BF(a3.im, a1.im, a1.im, t3); \
+	BF(t4, t6, t2, t6); \
+	BF(a3.re, a1.re, a1.re, t4); \
+	BF(a2.im, a0.im, a0.im, t6); \
+}
+
+// force loading all the inputs before storing any.
+// this is slightly slower for small data, but avoids store->load aliasing
+// for addresses separated by large powers of 2.
+#define BUTTERFLIES_BIG(a0, a1, a2, a3) { \
+	float r0 = a0.re, i0 = a0.im, r1 = a1.re, i1 = a1.im; \
+	BF(t3, t5, t5, t1); \
+	BF(a2.re, a0.re, r0, t5); \
+	BF(a3.im, a1.im, i1, t3); \
+	BF(t4, t6, t2, t6); \
+	BF(a3.re, a1.re, r1, t4); \
+	BF(a2.im, a0.im, i0, t6); \
+}
+
+#define TRANSFORM(a0, a1, a2, a3, wre, wim) { \
+	t1 = a2.re * wre + a2.im * wim; \
+	t2 = a2.im * wre - a2.re * wim; \
+	t5 = a3.re * wre - a3.im * wim; \
+	t6 = a3.im * wre + a3.re * wim; \
+	BUTTERFLIES(a0, a1, a2, a3) \
+}
+
+#define TRANSFORM_ZERO(a0, a1, a2, a3) { \
+	t1 = a2.re; \
+	t2 = a2.im; \
+	t5 = a3.re; \
+	t6 = a3.im; \
+	BUTTERFLIES(a0, a1, a2, a3) \
+}
+
+// z[0...8n-1], w[1...2n-1]
+#define PASS(name) \
+static void name(FFTComplex *z, const float *wre, unsigned int n) { \
+	float t1, t2, t3, t4, t5, t6; \
+	int o1 = 2 * n; \
+	int o2 = 4 * n; \
+	int o3 = 6 * n; \
+	const float *wim = wre + o1; \
+	n--; \
+	\
+	TRANSFORM_ZERO(z[0], z[o1], z[o2], z[o3]); \
+	TRANSFORM(z[1], z[o1 + 1], z[o2 + 1], z[o3 + 1], wre[1], wim[-1]); \
+	\
+	do { \
+		z += 2; \
+		wre += 2; \
+		wim -= 2; \
+		TRANSFORM(z[0], z[o1], z[o2], z[o3], wre[0], wim[0]); \
+		TRANSFORM(z[1], z[o1 + 1],z[o2 + 1], z[o3 + 1], wre[1], wim[-1]); \
+	} while(--n); \
+}
+
+PASS(pass)
+#undef BUTTERFLIES
+#define BUTTERFLIES BUTTERFLIES_BIG
+PASS(pass_big)
+
+static void fft4(FFTComplex *z) {
+	float t1, t2, t3, t4, t5, t6, t7, t8;
+
+	BF(t3, t1, z[0].re, z[1].re);
+	BF(t8, t6, z[3].re, z[2].re);
+	BF(z[2].re, z[0].re, t1, t6);
+	BF(t4, t2, z[0].im, z[1].im);
+	BF(t7, t5, z[2].im, z[3].im);
+	BF(z[3].im, z[1].im, t4, t8);
+	BF(z[3].re, z[1].re, t3, t7);
+	BF(z[2].im, z[0].im, t2, t5);
+}
+
+static void fft8(FFTComplex *z) {
+	float t1, t2, t3, t4, t5, t6, t7, t8;
+
+	fft4(z);
+
+	BF(t1, z[5].re, z[4].re, -z[5].re);
+	BF(t2, z[5].im, z[4].im, -z[5].im);
+	BF(t3, z[7].re, z[6].re, -z[7].re);
+	BF(t4, z[7].im, z[6].im, -z[7].im);
+	BF(t8, t1, t3, t1);
+	BF(t7, t2, t2, t4);
+	BF(z[4].re, z[0].re, z[0].re, t1);
+	BF(z[4].im, z[0].im, z[0].im, t2);
+	BF(z[6].re, z[2].re, z[2].re, t7);
+	BF(z[6].im, z[2].im, z[2].im, t8);
+
+	TRANSFORM(z[1], z[3], z[5], z[7], sqrthalf, sqrthalf);
+}
+
+#undef BF
+
+DECL_FFT(16,8,4)
+DECL_FFT(32,16,8)
+DECL_FFT(64,32,16)
+DECL_FFT(128,64,32)
+DECL_FFT(256,128,64)
+DECL_FFT(512,256,128)
+#define pass pass_big
+DECL_FFT(1024,512,256)
+DECL_FFT(2048,1024,512)
+DECL_FFT(4096,2048,1024)
+DECL_FFT(8192,4096,2048)
+DECL_FFT(16384,8192,4096)
+DECL_FFT(32768,16384,8192)
+DECL_FFT(65536,32768,16384)
+
+void fftCalc(FFTContext *s, FFTComplex *z) {
+	static void (* const fftDispatch[])(FFTComplex*) = {
+		fft4, fft8, fft16, fft32, fft64, fft128, fft256, fft512, fft1024,
+		fft2048, fft4096, fft8192, fft16384, fft32768, fft65536,
+	};
+
+	fftDispatch[s->nbits - 2](z);
+}
+
+// complex multiplication: p = a * b
+#define CMUL(pre, pim, are, aim, bre, bim) \
+{\
+	float _are = (are); \
+	float _aim = (aim); \
+	float _bre = (bre); \
+	float _bim = (bim); \
+	(pre) = _are * _bre - _aim * _bim; \
+	(pim) = _are * _bim + _aim * _bre; \
+}
+
+/**
+ * Compute the middle half of the inverse MDCT of size N = 2^nbits,
+ * thus excluding the parts that can be derived by symmetry
+ * @param output N/2 samples
+ * @param input N/2 samples
+ */
+void imdctHalfC(FFTContext *s, float *output, const float *input) {
+	const uint16 *revtab = s->revtab;
+	const float *tcos = s->tcos;
+	const float *tsin = s->tsin;
+	FFTComplex *z = (FFTComplex *)output;
+
+	int n = 1 << s->mdctBits;
+	int n2 = n >> 1;
+	int n4 = n >> 2;
+	int n8 = n >> 3;
+
+	// pre rotation
+	const float *in1 = input;
+	const float *in2 = input + n2 - 1;
+	for (int k = 0; k < n4; k++) {
+		int j = revtab[k];
+		CMUL(z[j].re, z[j].im, *in2, *in1, tcos[k], tsin[k]);
+		in1 += 2;
+		in2 -= 2;
+	}
+
+	fftCalc(s, z);
+
+	// post rotation + reordering
+	for (int k = 0; k < n8; k++) {
+		float r0, i0, r1, i1;
+		CMUL(r0, i1, z[n8 - k - 1].im, z[n8 - k - 1].re, tsin[n8 - k - 1], tcos[n8 - k - 1]);
+		CMUL(r1, i0, z[n8 + k].im, z[n8 + k].re, tsin[n8 + k], tcos[n8 + k]);
+		z[n8 - k - 1].re = r0;
+		z[n8 - k - 1].im = i0;
+		z[n8 + k].re = r1;
+		z[n8 + k].im = i1;
+	}
+}
+
+/**
+ * Compute inverse MDCT of size N = 2^nbits
+ * @param output N samples
+ * @param input N/2 samples
+ */
+void imdctCalcC(FFTContext *s, float *output, const float *input) {
+	int n = 1 << s->mdctBits;
+	int n2 = n >> 1;
+	int n4 = n >> 2;
+
+	imdctHalfC(s, output + n4, input);
+
+	for (int k = 0; k < n4; k++) {
+		output[k] = -output[n2 - k - 1];
+		output[n - k - 1] = output[n2 + k];
+	}
+}
+
+/**
+ * Compute MDCT of size N = 2^nbits
+ * @param input N samples
+ * @param out N/2 samples
+ */
+void mdctCalcC(FFTContext *s, float *out, const float *input) {
+	const uint16 *revtab = s->revtab;
+	const float *tcos = s->tcos;
+	const float *tsin = s->tsin;
+	FFTComplex *x = (FFTComplex *)out;
+
+	int n = 1 << s->mdctBits;
+	int n2 = n >> 1;
+	int n4 = n >> 2;
+	int n8 = n >> 3;
+	int n3 = 3 * n4;
+
+	// pre rotation
+	for (int i = 0; i < n8; i++) {
+		float re = -input[2 * i + 3 * n4] - input[n3 - 1 - 2 * i];
+		float im = -input[n4 + 2 * i] + input[n4 - 1 - 2 * i];
+		int j = revtab[i];
+		CMUL(x[j].re, x[j].im, re, im, -tcos[i], tsin[i]);
+
+		re = input[2 * i] - input[n2 - 1 - 2 * i];
+		im = -(input[n2 + 2 * i] + input[n - 1 - 2 * i]);
+		j = revtab[n8 + i];
+		CMUL(x[j].re, x[j].im, re, im, -tcos[n8 + i], tsin[n8 + i]);
+	}
+
+	fftCalc(s, x);
+
+	// post rotation
+	for (int i = 0; i < n8; i++) {
+		float r0, i0, r1, i1;
+		CMUL(i1, r0, x[n8 - i - 1].re, x[n8 - i - 1].im, -tsin[n8 - i - 1], -tcos[n8 - i - 1]);
+		CMUL(i0, r1, x[n8 + i].re, x[n8 + i].im, -tsin[n8 + i], -tcos[n8 + i]);
+		x[n8 - i - 1].re = r0;
+		x[n8 - i - 1].im = i0;
+		x[n8 + i].re = r1;
+		x[n8 + i].im = i1;
+	}
+}
+
+int fftInit(FFTContext *s, int nbits, int inverse) {
+	int i, j, m, n;
+	float alpha, c1, s1, s2;
+
+	if (nbits < 2 || nbits > 16)
+		goto fail;
+
+	s->nbits = nbits;
+	n = 1 << nbits;
+	s->tmpBuf = NULL;
+
+	s->exptab = (FFTComplex *)malloc((n / 2) * sizeof(FFTComplex));
+	if (!s->exptab)
+		goto fail;
+
+	s->revtab = (uint16 *)malloc(n * sizeof(uint16));
+	if (!s->revtab)
+		goto fail;
+	s->inverse = inverse;
+
+	s2 = inverse ? 1.0 : -1.0;
+
+	s->fftPermute = fftPermute;
+	s->fftCalc = fftCalc;
+	s->imdctCalc = imdctCalcC;
+	s->imdctHalf = imdctHalfC;
+	s->mdctCalc = mdctCalcC;
+	s->splitRadix = 1;
+
+	if (s->splitRadix) {
+		for (j = 4; j <= nbits; j++)
+			initCosineTables(j);
+
+		for (i = 0; i < n; i++)
+			s->revtab[-splitRadixPermutation(i, n, s->inverse) & (n - 1)] = i;
+
+		s->tmpBuf = (FFTComplex *)malloc(n * sizeof(FFTComplex));
+	} else {
+		for (i = 0; i < n / 2; i++) {
+			alpha = 2 * PI * (float)i / (float)n;
+			c1 = cos(alpha);
+			s1 = sin(alpha) * s2;
+			s->exptab[i].re = c1;
+			s->exptab[i].im = s1;
+		}
+
+		//int np = 1 << nbits;
+		//int nblocks = np >> 3;
+		//int np2 = np >> 1;
+
+		// compute bit reverse table
+		for (i = 0; i < n; i++) {
+			m = 0;
+			
+			for (j = 0; j < nbits; j++)
+				m |= ((i >> j) & 1) << (nbits - j - 1);
+			
+			s->revtab[i] = m;
+		}
+	}
+
+	return 0;
+
+ fail:
+	free(&s->revtab);
+	free(&s->exptab);
+	free(&s->tmpBuf);
+	return -1;
+}
+
+/**
+ * Sets up a real FFT.
+ * @param nbits           log2 of the length of the input array
+ * @param trans           the type of transform
+ */
+int rdftInit(RDFTContext *s, int nbits, RDFTransformType trans) {
+	int n = 1 << nbits;
+	const double theta = (trans == RDFT || trans == IRIDFT ? -1 : 1) * 2 * PI / n;
+
+	s->nbits = nbits;
+	s->inverse = trans == IRDFT || trans == IRIDFT;
+	s->signConvention = trans == RIDFT || trans == IRIDFT ? 1 : -1;
+
+	if (nbits < 4 || nbits > 16)
+		return -1;
+
+	if (fftInit(&s->fft, nbits - 1, trans == IRDFT || trans == RIDFT) < 0)
+		return -1;
+
+	initCosineTables(nbits);
+	s->tcos = ff_cos_tabs[nbits];
+	s->tsin = ff_sin_tabs[nbits] + (trans == RDFT || trans == IRIDFT) * (n >> 2);
+
+	for (int i = 0; i < n >> 2; i++)
+		s->tsin[i] = sin(i*theta);
+
+	return 0;
+}
+
+/** Map one real FFT into two parallel real even and odd FFTs. Then interleave
+ * the two real FFTs into one complex FFT. Unmangle the results.
+ * ref: http://www.engineeringproductivitytools.com/stuff/T0001/PT10.HTM
+ */
+void rdftCalc(RDFTContext *s, float *data) {
+	FFTComplex ev, od;
+
+	const int n = 1 << s->nbits;
+	const float k1 = 0.5;
+	const float k2 = 0.5 - s->inverse;
+	const float *tcos = s->tcos;
+	const float *tsin = s->tsin;
+
+	if (!s->inverse) {
+		fftPermute(&s->fft, (FFTComplex *)data);
+		fftCalc(&s->fft, (FFTComplex *)data);
+	}
+
+	// i=0 is a special case because of packing, the DC term is real, so we
+	// are going to throw the N/2 term (also real) in with it.
+	ev.re = data[0];
+	data[0] = ev.re + data[1];
+	data[1] = ev.re - data[1];
+	
+	int i;
+
+	for (i = 1; i < n >> 2; i++) {
+		int i1 = i * 2;
+		int i2 = n - i1;
+
+		// Separate even and odd FFTs
+		ev.re = k1 * (data[i1] + data[i2]);
+		od.im = -k2 * (data[i1] - data[i2]);
+		ev.im = k1 * (data[i1 + 1] - data[i2 + 1]);
+		od.re = k2 * (data[i1 + 1] + data[i2 + 1]);
+
+		// Apply twiddle factors to the odd FFT and add to the even FFT
+		data[i1] = ev.re + od.re * tcos[i] - od.im * tsin[i];
+		data[i1 + 1] = ev.im + od.im * tcos[i] + od.re * tsin[i];
+		data[i2] = ev.re - od.re * tcos[i] + od.im * tsin[i];
+		data[i2 + 1] = -ev.im + od.im * tcos[i] + od.re * tsin[i];
+	}
+
+	data[i * 2 + 1] = s->signConvention * data[i * 2 + 1];
+	if (s->inverse) {
+		data[0] *= k1;
+		data[1] *= k1;
+		fftPermute(&s->fft, (FFTComplex*)data);
+		fftCalc(&s->fft, (FFTComplex*)data);
+	}
+}
+
+// half mpeg encoding window (full precision)
+const int32 ff_mpa_enwindow[257] = {
+     0,    -1,    -1,    -1,    -1,    -1,    -1,    -2,
+    -2,    -2,    -2,    -3,    -3,    -4,    -4,    -5,
+    -5,    -6,    -7,    -7,    -8,    -9,   -10,   -11,
+   -13,   -14,   -16,   -17,   -19,   -21,   -24,   -26,
+   -29,   -31,   -35,   -38,   -41,   -45,   -49,   -53,
+   -58,   -63,   -68,   -73,   -79,   -85,   -91,   -97,
+  -104,  -111,  -117,  -125,  -132,  -139,  -147,  -154,
+  -161,  -169,  -176,  -183,  -190,  -196,  -202,  -208,
+   213,   218,   222,   225,   227,   228,   228,   227,
+   224,   221,   215,   208,   200,   189,   177,   163,
+   146,   127,   106,    83,    57,    29,    -2,   -36,
+   -72,  -111,  -153,  -197,  -244,  -294,  -347,  -401,
+  -459,  -519,  -581,  -645,  -711,  -779,  -848,  -919,
+  -991, -1064, -1137, -1210, -1283, -1356, -1428, -1498,
+ -1567, -1634, -1698, -1759, -1817, -1870, -1919, -1962,
+ -2001, -2032, -2057, -2075, -2085, -2087, -2080, -2063,
+  2037,  2000,  1952,  1893,  1822,  1739,  1644,  1535,
+  1414,  1280,  1131,   970,   794,   605,   402,   185,
+   -45,  -288,  -545,  -814, -1095, -1388, -1692, -2006,
+ -2330, -2663, -3004, -3351, -3705, -4063, -4425, -4788,
+ -5153, -5517, -5879, -6237, -6589, -6935, -7271, -7597,
+ -7910, -8209, -8491, -8755, -8998, -9219, -9416, -9585,
+ -9727, -9838, -9916, -9959, -9966, -9935, -9863, -9750,
+ -9592, -9389, -9139, -8840, -8492, -8092, -7640, -7134,
+  6574,  5959,  5288,  4561,  3776,  2935,  2037,  1082,
+    70,  -998, -2122, -3300, -4533, -5818, -7154, -8540,
+ -9975,-11455,-12980,-14548,-16155,-17799,-19478,-21189,
+-22929,-24694,-26482,-28289,-30112,-31947,-33791,-35640,
+-37489,-39336,-41176,-43006,-44821,-46617,-48390,-50137,
+-51853,-53534,-55178,-56778,-58333,-59838,-61289,-62684,
+-64019,-65290,-66494,-67629,-68692,-69679,-70590,-71420,
+-72169,-72835,-73415,-73908,-74313,-74630,-74856,-74992,
+ 75038
+};
+
+void ff_mpa_synth_init(int16 *window) {
+	int i;
+	int32 v;
+
+	// max = 18760, max sum over all 16 coefs : 44736
+	for(i = 0; i < 257; i++) {
+		v = ff_mpa_enwindow[i];
+		v = (v + 2) >> 2;
+		window[i] = v;
+
+		if ((i & 63) != 0)
+			v = -v;
+
+		if (i != 0)
+			window[512 - i] = v;
+	}
+}
+
+static inline uint16 round_sample(int *sum) {
+	int sum1;
+	sum1 = (*sum) >> 14;
+	*sum &= (1 << 14)-1;
+	if (sum1 < (-0x7fff - 1))
+		sum1 = (-0x7fff - 1);
+	if (sum1 > 0x7fff)
+		sum1 = 0x7fff;
+	return sum1;
+}
+
+static inline int MULH(int a, int b) {
+	return ((int64_t)(a) * (int64_t)(b))>>32;
+}
+
+// signed 16x16 -> 32 multiply add accumulate
+#define MACS(rt, ra, rb) rt += (ra) * (rb)
+
+#define MLSS(rt, ra, rb) ((rt) -= (ra) * (rb))
+
+#define SUM8(op, sum, w, p)\
+{\
+	op(sum, (w)[0 * 64], (p)[0 * 64]);\
+	op(sum, (w)[1 * 64], (p)[1 * 64]);\
+	op(sum, (w)[2 * 64], (p)[2 * 64]);\
+	op(sum, (w)[3 * 64], (p)[3 * 64]);\
+	op(sum, (w)[4 * 64], (p)[4 * 64]);\
+	op(sum, (w)[5 * 64], (p)[5 * 64]);\
+	op(sum, (w)[6 * 64], (p)[6 * 64]);\
+	op(sum, (w)[7 * 64], (p)[7 * 64]);\
+}
+
+#define SUM8P2(sum1, op1, sum2, op2, w1, w2, p) \
+{\
+	tmp_s = p[0 * 64];\
+	op1(sum1, (w1)[0 * 64], tmp_s);\
+	op2(sum2, (w2)[0 * 64], tmp_s);\
+	tmp_s = p[1 * 64];\
+	op1(sum1, (w1)[1 * 64], tmp_s);\
+	op2(sum2, (w2)[1 * 64], tmp_s);\
+	tmp_s = p[2 * 64];\
+	op1(sum1, (w1)[2 * 64], tmp_s);\
+	op2(sum2, (w2)[2 * 64], tmp_s);\
+	tmp_s = p[3 * 64];\
+	op1(sum1, (w1)[3 * 64], tmp_s);\
+	op2(sum2, (w2)[3 * 64], tmp_s);\
+	tmp_s = p[4 * 64];\
+	op1(sum1, (w1)[4 * 64], tmp_s);\
+	op2(sum2, (w2)[4 * 64], tmp_s);\
+	tmp_s = p[5 * 64];\
+	op1(sum1, (w1)[5 * 64], tmp_s);\
+	op2(sum2, (w2)[5 * 64], tmp_s);\
+	tmp_s = p[6 * 64];\
+	op1(sum1, (w1)[6 * 64], tmp_s);\
+	op2(sum2, (w2)[6 * 64], tmp_s);\
+	tmp_s = p[7 * 64];\
+	op1(sum1, (w1)[7 * 64], tmp_s);\
+	op2(sum2, (w2)[7 * 64], tmp_s);\
+}
+
+#define FIXHR(a) ((int)((a) * (1LL<<32) + 0.5))
+
+// tab[i][j] = 1.0 / (2.0 * cos(pi*(2*k+1) / 2^(6 - j)))
+
+// cos(i*pi/64)
+
+#define COS0_0  FIXHR(0.50060299823519630134/2)
+#define COS0_1  FIXHR(0.50547095989754365998/2)
+#define COS0_2  FIXHR(0.51544730992262454697/2)
+#define COS0_3  FIXHR(0.53104259108978417447/2)
+#define COS0_4  FIXHR(0.55310389603444452782/2)
+#define COS0_5  FIXHR(0.58293496820613387367/2)
+#define COS0_6  FIXHR(0.62250412303566481615/2)
+#define COS0_7  FIXHR(0.67480834145500574602/2)
+#define COS0_8  FIXHR(0.74453627100229844977/2)
+#define COS0_9  FIXHR(0.83934964541552703873/2)
+#define COS0_10 FIXHR(0.97256823786196069369/2)
+#define COS0_11 FIXHR(1.16943993343288495515/4)
+#define COS0_12 FIXHR(1.48416461631416627724/4)
+#define COS0_13 FIXHR(2.05778100995341155085/8)
+#define COS0_14 FIXHR(3.40760841846871878570/8)
+#define COS0_15 FIXHR(10.19000812354805681150/32)
+
+#define COS1_0 FIXHR(0.50241928618815570551/2)
+#define COS1_1 FIXHR(0.52249861493968888062/2)
+#define COS1_2 FIXHR(0.56694403481635770368/2)
+#define COS1_3 FIXHR(0.64682178335999012954/2)
+#define COS1_4 FIXHR(0.78815462345125022473/2)
+#define COS1_5 FIXHR(1.06067768599034747134/4)
+#define COS1_6 FIXHR(1.72244709823833392782/4)
+#define COS1_7 FIXHR(5.10114861868916385802/16)
+
+#define COS2_0 FIXHR(0.50979557910415916894/2)
+#define COS2_1 FIXHR(0.60134488693504528054/2)
+#define COS2_2 FIXHR(0.89997622313641570463/2)
+#define COS2_3 FIXHR(2.56291544774150617881/8)
+
+#define COS3_0 FIXHR(0.54119610014619698439/2)
+#define COS3_1 FIXHR(1.30656296487637652785/4)
+
+#define COS4_0 FIXHR(0.70710678118654752439/2)
+
+/* butterfly operator */
+#define BF(a, b, c, s)\
+{\
+	tmp0 = tab[a] + tab[b];\
+	tmp1 = tab[a] - tab[b];\
+	tab[a] = tmp0;\
+	tab[b] = MULH(tmp1<<(s), c);\
+}
+
+#define BF1(a, b, c, d)\
+{\
+	BF(a, b, COS4_0, 1);\
+	BF(c, d,-COS4_0, 1);\
+	tab[c] += tab[d];\
+}
+
+#define BF2(a, b, c, d)\
+{\
+	BF(a, b, COS4_0, 1);\
+	BF(c, d,-COS4_0, 1);\
+	tab[c] += tab[d];\
+	tab[a] += tab[c];\
+	tab[c] += tab[b];\
+	tab[b] += tab[d];\
+}
+
+#define ADD(a, b) tab[a] += tab[b]
+
+// DCT32 without 1/sqrt(2) coef zero scaling.
+static void dct32(int32 *out, int32 *tab) {
+	int tmp0, tmp1;
+
+	// pass 1
+	BF( 0, 31, COS0_0 , 1);
+	BF(15, 16, COS0_15, 5);
+	// pass 2
+	BF( 0, 15, COS1_0 , 1);
+	BF(16, 31,-COS1_0 , 1);
+	// pass 1
+	BF( 7, 24, COS0_7 , 1);
+	BF( 8, 23, COS0_8 , 1);
+	// pass 2 
+	BF( 7,  8, COS1_7 , 4);
+	BF(23, 24,-COS1_7 , 4);
+	// pass 3
+	BF( 0,  7, COS2_0 , 1);
+	BF( 8, 15,-COS2_0 , 1);
+	BF(16, 23, COS2_0 , 1);
+	BF(24, 31,-COS2_0 , 1);
+	// pass 1
+	BF( 3, 28, COS0_3 , 1);
+	BF(12, 19, COS0_12, 2);
+	// pass 2 
+	BF( 3, 12, COS1_3 , 1);
+	BF(19, 28,-COS1_3 , 1);
+	// pass 1
+	BF( 4, 27, COS0_4 , 1);
+	BF(11, 20, COS0_11, 2);
+	// pass 2
+	BF( 4, 11, COS1_4 , 1);
+	BF(20, 27,-COS1_4 , 1);
+	// pass 3
+	BF( 3,  4, COS2_3 , 3);
+	BF(11, 12,-COS2_3 , 3);
+	BF(19, 20, COS2_3 , 3);
+	BF(27, 28,-COS2_3 , 3);
+	// pass 4
+	BF( 0,  3, COS3_0 , 1);
+	BF( 4,  7,-COS3_0 , 1);
+	BF( 8, 11, COS3_0 , 1);
+	BF(12, 15,-COS3_0 , 1);
+	BF(16, 19, COS3_0 , 1);
+	BF(20, 23,-COS3_0 , 1);
+	BF(24, 27, COS3_0 , 1);
+	BF(28, 31,-COS3_0 , 1);
+
+	// pass 1
+	BF( 1, 30, COS0_1 , 1);
+	BF(14, 17, COS0_14, 3);
+	// pass 2
+	BF( 1, 14, COS1_1 , 1);
+	BF(17, 30,-COS1_1 , 1);
+	// pass 1
+	BF( 6, 25, COS0_6 , 1);
+	BF( 9, 22, COS0_9 , 1);
+	// pass 2
+	BF( 6,  9, COS1_6 , 2);
+	BF(22, 25,-COS1_6 , 2);
+	// pass 3
+	BF( 1,  6, COS2_1 , 1);
+	BF( 9, 14,-COS2_1 , 1);
+	BF(17, 22, COS2_1 , 1);
+	BF(25, 30,-COS2_1 , 1);
+
+	// pass 1
+	BF( 2, 29, COS0_2 , 1);
+	BF(13, 18, COS0_13, 3);
+	// pass 2
+	BF( 2, 13, COS1_2 , 1);
+	BF(18, 29,-COS1_2 , 1);
+	// pass 1
+	BF( 5, 26, COS0_5 , 1);
+	BF(10, 21, COS0_10, 1);
+	// pass 2
+	BF( 5, 10, COS1_5 , 2);
+	BF(21, 26,-COS1_5 , 2);
+	// pass 3
+	BF( 2,  5, COS2_2 , 1);
+	BF(10, 13,-COS2_2 , 1);
+	BF(18, 21, COS2_2 , 1);
+	BF(26, 29,-COS2_2 , 1);
+	// pass 4
+	BF( 1,  2, COS3_1 , 2);
+	BF( 5,  6,-COS3_1 , 2);
+	BF( 9, 10, COS3_1 , 2);
+	BF(13, 14,-COS3_1 , 2);
+	BF(17, 18, COS3_1 , 2);
+	BF(21, 22,-COS3_1 , 2);
+	BF(25, 26, COS3_1 , 2);
+	BF(29, 30,-COS3_1 , 2);
+
+	// pass 5
+	BF1( 0,  1,  2,  3);
+	BF2( 4,  5,  6,  7);
+	BF1( 8,  9, 10, 11);
+	BF2(12, 13, 14, 15);
+	BF1(16, 17, 18, 19);
+	BF2(20, 21, 22, 23);
+	BF1(24, 25, 26, 27);
+	BF2(28, 29, 30, 31);
+
+	// pass 6
+	ADD( 8, 12);
+	ADD(12, 10);
+	ADD(10, 14);
+	ADD(14,  9);
+	ADD( 9, 13);
+	ADD(13, 11);
+	ADD(11, 15);
+
+	out[ 0] = tab[0];
+	out[16] = tab[1];
+	out[ 8] = tab[2];
+	out[24] = tab[3];
+	out[ 4] = tab[4];
+	out[20] = tab[5];
+	out[12] = tab[6];
+	out[28] = tab[7];
+	out[ 2] = tab[8];
+	out[18] = tab[9];
+	out[10] = tab[10];
+	out[26] = tab[11];
+	out[ 6] = tab[12];
+	out[22] = tab[13];
+	out[14] = tab[14];
+	out[30] = tab[15];
+
+	ADD(24, 28);
+	ADD(28, 26);
+	ADD(26, 30);
+	ADD(30, 25);
+	ADD(25, 29);
+	ADD(29, 27);
+	ADD(27, 31);
+
+	out[ 1] = tab[16] + tab[24];
+	out[17] = tab[17] + tab[25];
+	out[ 9] = tab[18] + tab[26];
+	out[25] = tab[19] + tab[27];
+	out[ 5] = tab[20] + tab[28];
+	out[21] = tab[21] + tab[29];
+	out[13] = tab[22] + tab[30];
+	out[29] = tab[23] + tab[31];
+	out[ 3] = tab[24] + tab[20];
+	out[19] = tab[25] + tab[21];
+	out[11] = tab[26] + tab[22];
+	out[27] = tab[27] + tab[23];
+	out[ 7] = tab[28] + tab[18];
+	out[23] = tab[29] + tab[19];
+	out[15] = tab[30] + tab[17];
+	out[31] = tab[31];
+}
+
+// 32 sub band synthesis filter. Input: 32 sub band samples, Output:
+// 32 samples.
+// XXX: optimize by avoiding ring buffer usage
+void ff_mpa_synth_filter(int16 *synth_buf_ptr, int *synth_buf_offset,
+                         int16 *window, int *dither_state,
+                         int16 *samples, int incr,
+                         int32 sb_samples[32])
+{
+	int16 *synth_buf;
+	const int16 *w, *w2, *p;
+	int j, offset;
+	int16 *samples2;
+	int32 tmp[32];
+	int sum, sum2;
+	int tmp_s;
+
+	offset = *synth_buf_offset;
+	synth_buf = synth_buf_ptr + offset;
+
+	dct32(tmp, sb_samples);
+	for(j = 0; j < 32; j++) {
+		// NOTE: can cause a loss in precision if very high amplitude sound
+		if (tmp[j] < (-0x7fff - 1))
+			synth_buf[j] = (-0x7fff - 1);
+		else if (tmp[j] > 0x7fff)
+			synth_buf[j] = 0x7fff;
+		else
+			synth_buf[j] = tmp[j];
+	}
+
+	// copy to avoid wrap
+	memcpy(synth_buf + 512, synth_buf, 32 * sizeof(int16));
+
+	samples2 = samples + 31 * incr;
+	w = window;
+	w2 = window + 31;
+
+	sum = *dither_state;
+	p = synth_buf + 16;
+	SUM8(MACS, sum, w, p);
+	p = synth_buf + 48;
+	SUM8(MLSS, sum, w + 32, p);
+	*samples = round_sample(&sum);
+	samples += incr;
+	w++;
+
+	// we calculate two samples at the same time to avoid one memory
+	// access per two sample
+	for(j = 1; j < 16; j++) {
+		sum2 = 0;
+		p = synth_buf + 16 + j;
+		SUM8P2(sum, MACS, sum2, MLSS, w, w2, p);
+		p = synth_buf + 48 - j;
+		SUM8P2(sum, MLSS, sum2, MLSS, w + 32, w2 + 32, p);
+
+		*samples = round_sample(&sum);
+		samples += incr;
+		sum += sum2;
+		*samples2 = round_sample(&sum);
+		samples2 -= incr;
+		w++;
+		w2--;
+	}
+
+	p = synth_buf + 32;
+	SUM8(MLSS, sum, w + 32, p);
+	*samples = round_sample(&sum);
+	*dither_state= sum;
+
+	offset = (offset - 32) & 511;
+	*synth_buf_offset = offset;
+}
+
+/**
+ * parses a vlc code, faster then get_vlc()
+ * @param bits is the number of bits which will be read at once, must be
+ *             identical to nb_bits in init_vlc()
+ * @param max_depth is the number of times bits bits must be read to completely
+ *                  read the longest vlc code
+ *                  = (max_vlc_length + bits - 1) / bits
+ */
+static int getVlc2(GetBitContext *s, int16 (*table)[2], int bits, int maxDepth) {
+	int reIndex;
+	int reCache;
+	int index;
+	int code;
+	int n;
+
+	debug(1, "int getVlc2(GetBitContext *s, int16 (*table)[2], int bits, int maxDepth)");
+
+	reIndex = s->index;
+	reCache = READ_LE_UINT32(s->buffer + (reIndex >> 3)) >> (reIndex & 0x07);
+	index = reCache & (0xffffffff >> (32 - bits));
+	code = table[index][0];
+	n = table[index][1];
+
+	debug(1, "reIndex : %d", reIndex);
+	debug(1, "reCache : %d", reCache);
+	debug(1, "index : %d", index);
+	debug(1, "code : %d", code);
+	debug(1, "n : %d", n);
+
+	if (maxDepth > 1 && n < 0){
+		reIndex += bits;
+		reCache = READ_LE_UINT32(s->buffer + (reIndex >> 3)) >> (reIndex & 0x07);
+
+		int nbBits = -n;
+
+		index = (reCache & (0xffffffff >> (32 - nbBits))) + code;
+		code = table[index][0];
+		n = table[index][1];
+
+		if(maxDepth > 2 && n < 0) {
+			reIndex += nbBits;
+			reCache = READ_LE_UINT32(s->buffer + (reIndex >> 3)) >> (reIndex & 0x07);
+
+			nbBits = -n;
+
+			index = (reCache & (0xffffffff >> (32 - nbBits))) + code;
+			code = table[index][0];
+			n = table[index][1];
+		}
+	}
+
+	reCache >>= n;
+	s->index = reIndex + n;
+	return code;
+}
+
+static int allocTable(VLC *vlc, int size, int use_static) {
+	int index;
+	index = vlc->table_size;
+	vlc->table_size += size;
+	if (vlc->table_size > vlc->table_allocated) {
+		if(use_static)
+			error("QDM2 cant do anything, init_vlc() is used with too little memory");
+		vlc->table_allocated += (1 << vlc->bits);
+		vlc->table = (int16 (*)[2])realloc(vlc->table, sizeof(int16 *) * 2 * vlc->table_allocated);
+		if (!vlc->table)
+			return -1;
+	}
+	return index;
+}
+
+#define GET_DATA(v, table, i, wrap, size)\
+{\
+	const uint8 *ptr = (const uint8 *)table + i * wrap;\
+	switch(size) {\
+		case 1:\
+			v = *(const uint8 *)ptr;\
+			break;\
+		case 2:\
+			v = *(const uint16 *)ptr;\
+			break;\
+		default:\
+			v = *(const uint32 *)ptr;\
+			break;\
+	}\
+}
+
+static int build_table(VLC *vlc, int table_nb_bits,
+                       int nb_codes,
+                       const void *bits, int bits_wrap, int bits_size,
+                       const void *codes, int codes_wrap, int codes_size,
+                       const void *symbols, int symbols_wrap, int symbols_size,
+                       int code_prefix, int n_prefix, int flags)
+{
+	int i, j, k, n, table_size, table_index, nb, n1, index, code_prefix2, symbol;
+	uint32 code;
+	int16 (*table)[2];
+
+	table_size = 1 << table_nb_bits;
+	table_index = allocTable(vlc, table_size, flags & 4);
+	debug(2, "QDM2 new table index=%d size=%d code_prefix=%x n=%d", table_index, table_size, code_prefix, n_prefix);
+	if (table_index < 0)
+		return -1;
+	table = &vlc->table[table_index];
+
+	for(i = 0; i < table_size; i++) {
+		table[i][1] = 0; //bits
+		table[i][0] = -1; //codes
+	}
+
+	// first pass: map codes and compute auxillary table sizes
+	for(i = 0; i < nb_codes; i++) {
+		GET_DATA(n, bits, i, bits_wrap, bits_size);
+		GET_DATA(code, codes, i, codes_wrap, codes_size);
+		// we accept tables with holes
+		if (n <= 0)
+			continue;
+		if (!symbols)
+			symbol = i;
+		else
+			GET_DATA(symbol, symbols, i, symbols_wrap, symbols_size);
+		debug(2, "QDM2 i=%d n=%d code=0x%x", i, n, code);
+		// if code matches the prefix, it is in the table
+		n -= n_prefix;
+		if(flags & 2)
+			code_prefix2= code & (n_prefix>=32 ? 0xffffffff : (1 << n_prefix)-1);
+		else
+			code_prefix2= code >> n;
+		if (n > 0 && code_prefix2 == code_prefix) {
+			if (n <= table_nb_bits) {
+				// no need to add another table
+				j = (code << (table_nb_bits - n)) & (table_size - 1);
+				nb = 1 << (table_nb_bits - n);
+				for(k = 0; k < nb; k++) {
+					if(flags & 2)
+						j = (code >> n_prefix) + (k<<n);
+					debug(2, "QDM2 %4x: code=%d n=%d",j, i, n);
+					if (table[j][1] /*bits*/ != 0) {
+						error("QDM2 incorrect codes");
+						return -1;
+					}
+					table[j][1] = n; //bits
+					table[j][0] = symbol;
+					j++;
+				}
+			} else {
+				n -= table_nb_bits;
+				j = (code >> ((flags & 2) ? n_prefix : n)) & ((1 << table_nb_bits) - 1);
+				debug(2, "QDM2 %4x: n=%d (subtable)", j, n);
+				// compute table size
+				n1 = -table[j][1]; //bits
+				if (n > n1)
+					n1 = n;
+				table[j][1] = -n1; //bits
+			}
+		}
+	}
+
+	// second pass : fill auxillary tables recursively
+	for(i = 0;i < table_size; i++) {
+		n = table[i][1]; //bits
+		if (n < 0) {
+			n = -n;
+			if (n > table_nb_bits) {
+				n = table_nb_bits;
+				table[i][1] = -n; //bits
+			}
+			index = build_table(vlc, n, nb_codes,
+			                    bits, bits_wrap, bits_size,
+			                    codes, codes_wrap, codes_size,
+			                    symbols, symbols_wrap, symbols_size,
+			                    (flags & 2) ? (code_prefix | (i << n_prefix)) : ((code_prefix << table_nb_bits) | i),
+			                    n_prefix + table_nb_bits, flags);
+ 			if (index < 0)
+				return -1;
+			// note: realloc has been done, so reload tables
+			table = &vlc->table[table_index];
+			table[i][0] = index; //code
+		}
+	}
+	return table_index;
+}
+
+/* Build VLC decoding tables suitable for use with get_vlc().
+
+   'nb_bits' set thee decoding table size (2^nb_bits) entries. The
+   bigger it is, the faster is the decoding. But it should not be too
+   big to save memory and L1 cache. '9' is a good compromise.
+
+   'nb_codes' : number of vlcs codes
+
+   'bits' : table which gives the size (in bits) of each vlc code.
+
+   'codes' : table which gives the bit pattern of of each vlc code.
+
+   'symbols' : table which gives the values to be returned from get_vlc().
+
+   'xxx_wrap' : give the number of bytes between each entry of the
+   'bits' or 'codes' tables.
+
+   'xxx_size' : gives the number of bytes of each entry of the 'bits'
+   or 'codes' tables.
+
+   'wrap' and 'size' allows to use any memory configuration and types
+   (byte/word/long) to store the 'bits', 'codes', and 'symbols' tables.
+
+   'use_static' should be set to 1 for tables, which should be freed
+   with av_free_static(), 0 if free_vlc() will be used.
+*/
+void initVlcSparse(VLC *vlc, int nb_bits, int nb_codes,
+		const void *bits, int bits_wrap, int bits_size,
+		const void *codes, int codes_wrap, int codes_size,
+		const void *symbols, int symbols_wrap, int symbols_size) {
+	vlc->bits = nb_bits;
+
+	if(vlc->table_size && vlc->table_size == vlc->table_allocated) {
+		return;
+	} else if(vlc->table_size) {
+		error("called on a partially initialized table");
+	}
+
+	debug(2, "QDM2 build table nb_codes=%d", nb_codes);
+
+	if (build_table(vlc, nb_bits, nb_codes,
+	                bits, bits_wrap, bits_size,
+	                codes, codes_wrap, codes_size,
+	                symbols, symbols_wrap, symbols_size,
+	                0, 0, 4 | 2) < 0) {
+		free(&vlc->table);
+		return; // Error
+	}
+
+	if(vlc->table_size != vlc->table_allocated)
+		error("QDM2 needed %d had %d", vlc->table_size, vlc->table_allocated);
+}
+
+void QDM2Stream::softclipTableInit(void) {
+	uint16 i;
+	double dfl = SOFTCLIP_THRESHOLD - 32767;
+	float delta = 1.0 / -dfl;
+
+	for (i = 0; i < ARRAYSIZE(_softclipTable); i++)
+		_softclipTable[i] = SOFTCLIP_THRESHOLD - ((int)(sin((float)i * delta) * dfl) & 0x0000FFFF);
+}
+
+// random generated table
+void QDM2Stream::rndTableInit(void) {
+	uint16 i;
+	uint16 j;
+	uint32 ldw, hdw;
+	// TODO: Replace Code with uint64 less version...
+	int64_t tmp64_1;
+	int64_t random_seed = 0;
+	float delta = 1.0 / 16384.0;
+
+	for(i = 0; i < ARRAYSIZE(_noiseTable); i++) {
+		random_seed = random_seed * 214013 + 2531011;
+		_noiseTable[i] = (delta * (float)(((int32)random_seed >> 16) & 0x00007FFF)- 1.0) * 1.3;
+	}
+
+	for (i = 0; i < 256; i++) {
+		random_seed = 81;
+		ldw = i;
+		for (j = 0; j < 5; j++) {
+			_randomDequantIndex[i][j] = (uint8)((ldw / random_seed) & 0xFF);
+			ldw = (uint32)ldw % (uint32)random_seed;
+			tmp64_1 = (random_seed * 0x55555556);
+			hdw = (uint32)(tmp64_1 >> 32);
+			random_seed = (int64_t)(hdw + (ldw >> 31));
+		}
+	}
+
+	for (i = 0; i < 128; i++) {
+		random_seed = 25;
+		ldw = i;
+		for (j = 0; j < 3; j++) {
+			_randomDequantType24[i][j] = (uint8)((ldw / random_seed) & 0xFF);
+			ldw = (uint32)ldw % (uint32)random_seed;
+			tmp64_1 = (random_seed * 0x66666667);
+			hdw = (uint32)(tmp64_1 >> 33);
+			random_seed = hdw + (ldw >> 31);
+		}
+	}
+}
+
+void QDM2Stream::initNoiseSamples(void) {
+	uint16 i;
+	uint32 random_seed = 0;
+	float delta = 1.0 / 16384.0;
+
+	for (i = 0; i < ARRAYSIZE(_noiseSamples); i++) {
+		random_seed = random_seed * 214013 + 2531011;
+		_noiseSamples[i] = (delta * (float)((random_seed >> 16) & 0x00007fff) - 1.0);
+	}
+}
+
+static const uint16 qdm2_vlc_offs[18] = {
+	0, 260, 566, 598, 894, 1166, 1230, 1294, 1678, 1950, 2214, 2278, 2310, 2570, 2834, 3124, 3448, 3838
+};
+
+void QDM2Stream::initVlc(void) {
+	static int16 qdm2_table[3838][2];
+
+	if (!_vlcsInitialized) {
+		_vlcTabLevel.table = &qdm2_table[qdm2_vlc_offs[0]];
+		_vlcTabLevel.table_allocated = qdm2_vlc_offs[1] - qdm2_vlc_offs[0];
+		_vlcTabLevel.table_size = 0;
+		initVlcSparse(&_vlcTabLevel, 8, 24,
+			vlc_tab_level_huffbits, 1, 1,
+			vlc_tab_level_huffcodes, 2, 2, NULL, 0, 0);
+
+		_vlcTabDiff.table = &qdm2_table[qdm2_vlc_offs[1]];
+		_vlcTabDiff.table_allocated = qdm2_vlc_offs[2] - qdm2_vlc_offs[1];
+		_vlcTabDiff.table_size = 0;
+		initVlcSparse(&_vlcTabDiff, 8, 37,
+			vlc_tab_diff_huffbits, 1, 1,
+			vlc_tab_diff_huffcodes, 2, 2, NULL, 0, 0);
+
+		_vlcTabRun.table = &qdm2_table[qdm2_vlc_offs[2]];
+		_vlcTabRun.table_allocated = qdm2_vlc_offs[3] - qdm2_vlc_offs[2];
+		_vlcTabRun.table_size = 0;
+		initVlcSparse(&_vlcTabRun, 5, 6,
+			vlc_tab_run_huffbits, 1, 1,
+			vlc_tab_run_huffcodes, 1, 1, NULL, 0, 0);
+
+		_fftLevelExpAltVlc.table = &qdm2_table[qdm2_vlc_offs[3]];
+		_fftLevelExpAltVlc.table_allocated = qdm2_vlc_offs[4] - qdm2_vlc_offs[3];
+		_fftLevelExpAltVlc.table_size = 0;
+		initVlcSparse(&_fftLevelExpAltVlc, 8, 28,
+			fft_level_exp_alt_huffbits, 1, 1,
+			fft_level_exp_alt_huffcodes, 2, 2, NULL, 0, 0);
+
+		_fftLevelExpVlc.table = &qdm2_table[qdm2_vlc_offs[4]];
+		_fftLevelExpVlc.table_allocated = qdm2_vlc_offs[5] - qdm2_vlc_offs[4];
+		_fftLevelExpVlc.table_size = 0;
+		initVlcSparse(&_fftLevelExpVlc, 8, 20,
+			fft_level_exp_huffbits, 1, 1,
+			fft_level_exp_huffcodes, 2, 2, NULL, 0, 0);
+
+		_fftStereoExpVlc.table = &qdm2_table[qdm2_vlc_offs[5]];
+		_fftStereoExpVlc.table_allocated = qdm2_vlc_offs[6] - qdm2_vlc_offs[5];
+		_fftStereoExpVlc.table_size = 0;
+		initVlcSparse(&_fftStereoExpVlc, 6, 7,
+			fft_stereo_exp_huffbits, 1, 1,
+			fft_stereo_exp_huffcodes, 1, 1, NULL, 0, 0);
+
+		_fftStereoPhaseVlc.table = &qdm2_table[qdm2_vlc_offs[6]];
+		_fftStereoPhaseVlc.table_allocated = qdm2_vlc_offs[7] - qdm2_vlc_offs[6];
+		_fftStereoPhaseVlc.table_size = 0;
+		initVlcSparse(&_fftStereoPhaseVlc, 6, 9,
+			fft_stereo_phase_huffbits, 1, 1,
+			fft_stereo_phase_huffcodes, 1, 1, NULL, 0, 0);
+
+		_vlcTabToneLevelIdxHi1.table = &qdm2_table[qdm2_vlc_offs[7]];
+		_vlcTabToneLevelIdxHi1.table_allocated = qdm2_vlc_offs[8] - qdm2_vlc_offs[7];
+		_vlcTabToneLevelIdxHi1.table_size = 0;
+		initVlcSparse(&_vlcTabToneLevelIdxHi1, 8, 20,
+			vlc_tab_tone_level_idx_hi1_huffbits, 1, 1,
+			vlc_tab_tone_level_idx_hi1_huffcodes, 2, 2, NULL, 0, 0);
+
+		_vlcTabToneLevelIdxMid.table = &qdm2_table[qdm2_vlc_offs[8]];
+		_vlcTabToneLevelIdxMid.table_allocated = qdm2_vlc_offs[9] - qdm2_vlc_offs[8];
+		_vlcTabToneLevelIdxMid.table_size = 0;
+		initVlcSparse(&_vlcTabToneLevelIdxMid, 8, 24,
+			vlc_tab_tone_level_idx_mid_huffbits, 1, 1,
+			vlc_tab_tone_level_idx_mid_huffcodes, 2, 2, NULL, 0, 0);
+
+		_vlcTabToneLevelIdxHi2.table = &qdm2_table[qdm2_vlc_offs[9]];
+		_vlcTabToneLevelIdxHi2.table_allocated = qdm2_vlc_offs[10] - qdm2_vlc_offs[9];
+		_vlcTabToneLevelIdxHi2.table_size = 0;
+		initVlcSparse(&_vlcTabToneLevelIdxHi2, 8, 24,
+			vlc_tab_tone_level_idx_hi2_huffbits, 1, 1,
+			vlc_tab_tone_level_idx_hi2_huffcodes, 2, 2, NULL, 0, 0);
+
+		_vlcTabType30.table = &qdm2_table[qdm2_vlc_offs[10]];
+		_vlcTabType30.table_allocated = qdm2_vlc_offs[11] - qdm2_vlc_offs[10];
+		_vlcTabType30.table_size = 0;
+		initVlcSparse(&_vlcTabType30, 6, 9,
+			vlc_tab_type30_huffbits, 1, 1,
+			vlc_tab_type30_huffcodes, 1, 1, NULL, 0, 0);
+
+		_vlcTabType34.table = &qdm2_table[qdm2_vlc_offs[11]];
+		_vlcTabType34.table_allocated = qdm2_vlc_offs[12] - qdm2_vlc_offs[11];
+		_vlcTabType34.table_size = 0;
+		initVlcSparse(&_vlcTabType34, 5, 10,
+			vlc_tab_type34_huffbits, 1, 1,
+			vlc_tab_type34_huffcodes, 1, 1, NULL, 0, 0);
+
+		_vlcTabFftToneOffset[0].table = &qdm2_table[qdm2_vlc_offs[12]];
+		_vlcTabFftToneOffset[0].table_allocated = qdm2_vlc_offs[13] - qdm2_vlc_offs[12];
+		_vlcTabFftToneOffset[0].table_size = 0;
+		initVlcSparse(&_vlcTabFftToneOffset[0], 8, 23,
+			vlc_tab_fft_tone_offset_0_huffbits, 1, 1,
+			vlc_tab_fft_tone_offset_0_huffcodes, 2, 2, NULL, 0, 0);
+
+		_vlcTabFftToneOffset[1].table = &qdm2_table[qdm2_vlc_offs[13]];
+		_vlcTabFftToneOffset[1].table_allocated = qdm2_vlc_offs[14] - qdm2_vlc_offs[13];
+		_vlcTabFftToneOffset[1].table_size = 0;
+		initVlcSparse(&_vlcTabFftToneOffset[1], 8, 28,
+			vlc_tab_fft_tone_offset_1_huffbits, 1, 1,
+			vlc_tab_fft_tone_offset_1_huffcodes, 2, 2, NULL, 0, 0);
+
+		_vlcTabFftToneOffset[2].table = &qdm2_table[qdm2_vlc_offs[14]];
+		_vlcTabFftToneOffset[2].table_allocated = qdm2_vlc_offs[15] - qdm2_vlc_offs[14];
+		_vlcTabFftToneOffset[2].table_size = 0;
+		initVlcSparse(&_vlcTabFftToneOffset[2], 8, 32,
+			vlc_tab_fft_tone_offset_2_huffbits, 1, 1,
+			vlc_tab_fft_tone_offset_2_huffcodes, 2, 2, NULL, 0, 0);
+
+		_vlcTabFftToneOffset[3].table = &qdm2_table[qdm2_vlc_offs[15]];
+		_vlcTabFftToneOffset[3].table_allocated = qdm2_vlc_offs[16] - qdm2_vlc_offs[15];
+		_vlcTabFftToneOffset[3].table_size = 0;
+		initVlcSparse(&_vlcTabFftToneOffset[3], 8, 35,
+			vlc_tab_fft_tone_offset_3_huffbits, 1, 1,
+			vlc_tab_fft_tone_offset_3_huffcodes, 2, 2, NULL, 0, 0);
+
+		_vlcTabFftToneOffset[4].table = &qdm2_table[qdm2_vlc_offs[16]];
+		_vlcTabFftToneOffset[4].table_allocated = qdm2_vlc_offs[17] - qdm2_vlc_offs[16];
+		_vlcTabFftToneOffset[4].table_size = 0;
+		initVlcSparse(&_vlcTabFftToneOffset[4], 8, 38,
+			vlc_tab_fft_tone_offset_4_huffbits, 1, 1,
+			vlc_tab_fft_tone_offset_4_huffcodes, 2, 2, NULL, 0, 0);
+
+		_vlcsInitialized = true;
+	}
+}
+
+QDM2Stream::QDM2Stream(Common::SeekableReadStream *stream, Common::SeekableReadStream *extraData) {
+	uint32 tmp;
+	int32 tmp_s;
+	int tmp_val;
+	int i;
+
+	debug(1, "QDM2Stream::QDM2Stream() Call");
+
+	_stream = stream;
+	_compressedData = NULL;
+	_subPacket = 0;
+	memset(_quantizedCoeffs, 0, sizeof(_quantizedCoeffs));
+	memset(_fftLevelExp, 0, sizeof(_fftLevelExp));
+	_noiseIdx = 0;
+	memset(_fftCoefsMinIndex, 0, sizeof(_fftCoefsMinIndex));
+	memset(_fftCoefsMaxIndex, 0, sizeof(_fftCoefsMaxIndex));
+	_fftToneStart = 0;
+	_fftToneEnd = 0;
+	for(i = 0; i < ARRAYSIZE(_subPacketListA); i++) {
+		_subPacketListA[i].packet = NULL;
+		_subPacketListA[i].next = NULL;
+	}
+	_subPacketsB = 0;
+	for(i = 0; i < ARRAYSIZE(_subPacketListB); i++) {
+		_subPacketListB[i].packet = NULL;
+		_subPacketListB[i].next = NULL;
+	}
+	for(i = 0; i < ARRAYSIZE(_subPacketListC); i++) {
+		_subPacketListC[i].packet = NULL;
+		_subPacketListC[i].next = NULL;
+	}
+	for(i = 0; i < ARRAYSIZE(_subPacketListD); i++) {
+		_subPacketListD[i].packet = NULL;
+		_subPacketListD[i].next = NULL;
+	}
+	memset(_synthBuf, 0, sizeof(_synthBuf));
+	memset(_synthBufOffset, 0, sizeof(_synthBufOffset));
+	memset(_sbSamples, 0, sizeof(_sbSamples));
+	memset(_outputBuffer, 0, sizeof(_outputBuffer));
+	_vlcsInitialized = false;
+	_superblocktype_2_3 = 0;
+	_hasErrors = false;
+
+	// Rewind extraData stream from any previous calls...
+	extraData->seek(0, SEEK_SET);
+
+	tmp_s = extraData->readSint32BE();
+	debug(1, "QDM2Stream::QDM2Stream() extraSize: %d", tmp_s);
+	if ((extraData->size() - extraData->pos()) / 4 + 1 != tmp_s)
+		warning("QDM2Stream::QDM2Stream() extraSize mismatch - Expected %d", (extraData->size() - extraData->pos()) / 4 + 1);
+	if (tmp_s < 12)
+		error("QDM2Stream::QDM2Stream() Insufficient extraData");
+	
+	tmp = extraData->readUint32BE();
+	debug(1, "QDM2Stream::QDM2Stream() extraTag: %d", tmp);
+	if (tmp != MKID_BE('frma'))
+		warning("QDM2Stream::QDM2Stream() extraTag mismatch");
+	
+	tmp = extraData->readUint32BE();
+	debug(1, "QDM2Stream::QDM2Stream() extraType: %d", tmp);
+	if (tmp == MKID_BE('QDMC'))
+		warning("QDM2Stream::QDM2Stream() QDMC stream type not supported.");
+	else if (tmp != MKID_BE('QDM2'))
+		error("QDM2Stream::QDM2Stream() Unsupported stream type");
+
+	tmp_s = extraData->readSint32BE();
+	debug(1, "QDM2Stream::QDM2Stream() extraSize2: %d", tmp_s);
+	if ((extraData->size() - extraData->pos()) + 4 != tmp_s)
+		warning("QDM2Stream::QDM2Stream() extraSize2 mismatch - Expected %d", (extraData->size() - extraData->pos()) + 4);
+
+	tmp = extraData->readUint32BE();
+	debug(1, "QDM2Stream::QDM2Stream() extraTag2: %d", tmp);
+	if (tmp != MKID_BE('QDCA'))
+		warning("QDM2Stream::QDM2Stream() extraTag2 mismatch");
+
+	if (extraData->readUint32BE() != 1)
+		warning("QDM2Stream::QDM2Stream() u0 field not 1");
+
+	_channels = extraData->readUint32BE();
+	debug(1, "QDM2Stream::QDM2Stream() channels: %d", _channels);
+
+	_sampleRate = extraData->readUint32BE();
+	debug(1, "QDM2Stream::QDM2Stream() sampleRate: %d", _sampleRate);
+
+	_bitRate = extraData->readUint32BE();
+	debug(1, "QDM2Stream::QDM2Stream() bitRate: %d", _bitRate);
+
+	_blockSize = extraData->readUint32BE();
+	debug(1, "QDM2Stream::QDM2Stream() blockSize: %d", _blockSize);
+
+	_frameSize = extraData->readUint32BE();
+	debug(1, "QDM2Stream::QDM2Stream() frameSize: %d", _frameSize);
+
+	_packetSize = extraData->readUint32BE();
+	debug(1, "QDM2Stream::QDM2Stream() packetSize: %d", _packetSize);
+
+	if (extraData->size() - extraData->pos() != 0) {
+		tmp_s = extraData->readSint32BE();
+		debug(1, "QDM2Stream::QDM2Stream() extraSize3: %d", tmp_s);
+		if (extraData->size() + 4 != tmp_s)
+			warning("QDM2Stream::QDM2Stream() extraSize3 mismatch - Expected %d", extraData->size() + 4);
+
+		tmp = extraData->readUint32BE();
+		debug(1, "QDM2Stream::QDM2Stream() extraTag3: %d", tmp);
+		if (tmp != MKID_BE('QDCP'))
+			warning("QDM2Stream::QDM2Stream() extraTag3 mismatch");
+
+		if ((float)extraData->readUint32BE() != 1.0)
+			warning("QDM2Stream::QDM2Stream() uf0 field not 1.0");
+
+		if (extraData->readUint32BE() != 0)
+			warning("QDM2Stream::QDM2Stream() u1 field not 0");
+
+		if ((float)extraData->readUint32BE() != 1.0)
+			warning("QDM2Stream::QDM2Stream() uf1 field not 1.0");
+
+		if ((float)extraData->readUint32BE() != 1.0)
+			warning("QDM2Stream::QDM2Stream() uf2 field not 1.0");
+
+		if (extraData->readUint32BE() != 27)
+			warning("QDM2Stream::QDM2Stream() u2 field not 27");
+
+		if (extraData->readUint32BE() != 8)
+			warning("QDM2Stream::QDM2Stream() u3 field not 8");
+
+		if (extraData->readUint32BE() != 0)
+			warning("QDM2Stream::QDM2Stream() u4 field not 0");
+	}
+
+	_fftOrder = scummvm_log2(_frameSize) + 1;
+	_fftFrameSize = 2 * _frameSize; // complex has two floats
+
+	// something like max decodable tones
+	_groupOrder = scummvm_log2(_blockSize) + 1;
+	_sFrameSize = _blockSize / 16; // 16 iterations per super block
+
+	_subSampling = _fftOrder - 7;
+	_frequencyRange = 255 / (1 << (2 - _subSampling));
+
+	switch ((_subSampling * 2 + _channels - 1)) {
+		case 0:
+			tmp = 40;
+			break;
+		case 1:
+			tmp = 48;
+			break;
+		case 2:
+			tmp = 56;
+			break;
+		case 3:
+			tmp = 72;
+			break;
+		case 4:
+			tmp = 80;
+			break;
+		case 5:
+			tmp = 100;
+			break;
+		default:
+			tmp = _subSampling;
+			break;
+	}
+
+	tmp_val = 0;
+	if ((tmp * 1000) < _bitRate)  tmp_val = 1;
+	if ((tmp * 1440) < _bitRate)  tmp_val = 2;
+	if ((tmp * 1760) < _bitRate)  tmp_val = 3;
+	if ((tmp * 2240) < _bitRate)  tmp_val = 4;
+	_cmTableSelect = tmp_val;
+
+	if (_subSampling == 0)
+		tmp = 7999;
+	else
+		tmp = ((-(_subSampling -1)) & 8000) + 20000;
+
+	if (tmp < 8000)
+		_coeffPerSbSelect = 0;
+	else if (tmp <= 16000)
+		_coeffPerSbSelect = 1;
+	else
+		_coeffPerSbSelect = 2;
+
+	if (_fftOrder < 7 || _fftOrder > 9)
+		error("QDM2Stream::QDM2Stream() Unsupported fft_order: %d", _fftOrder);
+
+	rdftInit(&_rdftCtx, _fftOrder, IRDFT);
+
+	initVlc();
+	ff_mpa_synth_init(ff_mpa_synth_window);
+	softclipTableInit();
+	rndTableInit();
+	initNoiseSamples();
+
+	_compressedData = new uint8[_packetSize];
+}
+
+QDM2Stream::~QDM2Stream() {
+	delete[] _compressedData;
+	delete _stream;
+}
+
+static int qdm2_get_vlc(GetBitContext *gb, VLC *vlc, int flag, int depth) {
+	int value = getVlc2(gb, vlc->table, vlc->bits, depth);
+
+	// stage-2, 3 bits exponent escape sequence
+	if (value-- == 0)
+		value = getBits(gb, getBits (gb, 3) + 1);
+
+	// stage-3, optional
+	if (flag) {
+		int tmp = vlc_stage3_values[value];
+
+		if ((value & ~3) > 0)
+			tmp += getBits(gb, (value >> 2));
+		value = tmp;
+	}
+
+	return value;
+}
+
+static int qdm2_get_se_vlc(VLC *vlc, GetBitContext *gb, int depth)
+{
+	int value = qdm2_get_vlc(gb, vlc, 0, depth);
+
+	return (value & 1) ? ((value + 1) >> 1) : -(value >> 1);
+}
+
+/**
+ * QDM2 checksum
+ *
+ * @param data      pointer to data to be checksum'ed
+ * @param length    data length
+ * @param value     checksum value
+ *
+ * @return          0 if checksum is OK
+ */
+static uint16 qdm2_packet_checksum(const uint8 *data, int length, int value) {
+	int i;
+
+	for (i = 0; i < length; i++)
+		value -= data[i];
+
+	return (uint16)(value & 0xffff);
+}
+
+/**
+ * Fills a QDM2SubPacket structure with packet type, size, and data pointer.
+ *
+ * @param gb            bitreader context
+ * @param sub_packet    packet under analysis
+ */
+static void qdm2_decode_sub_packet_header(GetBitContext *gb, QDM2SubPacket *sub_packet)
+{
+	sub_packet->type = getBits (gb, 8);
+
+	if (sub_packet->type == 0) {
+		sub_packet->size = 0;
+		sub_packet->data = NULL;
+	} else {
+		sub_packet->size = getBits (gb, 8);
+
+		if (sub_packet->type & 0x80) {
+			sub_packet->size <<= 8;
+			sub_packet->size  |= getBits (gb, 8);
+			sub_packet->type  &= 0x7f;
+		}
+
+		if (sub_packet->type == 0x7f)
+			sub_packet->type |= (getBits (gb, 8) << 8);
+
+		sub_packet->data = &gb->buffer[getBitsCount(gb) / 8]; // FIXME: this depends on bitreader internal data
+	}
+
+	debug(1, "QDM2 Subpacket: type=%d size=%d start_offs=%x", sub_packet->type, sub_packet->size, getBitsCount(gb) / 8);
+}
+
+/**
+ * Return node pointer to first packet of requested type in list.
+ *
+ * @param list    list of subpackets to be scanned
+ * @param type    type of searched subpacket
+ * @return        node pointer for subpacket if found, else NULL
+ */
+static QDM2SubPNode* qdm2_search_subpacket_type_in_list(QDM2SubPNode *list, int type)
+{
+	while (list != NULL && list->packet != NULL) {
+		if (list->packet->type == type)
+			return list;
+		list = list->next;
+	}
+	return NULL;
+}
+
+/**
+ * Replaces 8 elements with their average value.
+ * Called by qdm2_decode_superblock before starting subblock decoding.
+ */
+void QDM2Stream::average_quantized_coeffs(void) {
+	int i, j, n, ch, sum;
+
+	n = coeff_per_sb_for_avg[_coeffPerSbSelect][QDM2_SB_USED(_subSampling) - 1] + 1;
+
+	for (ch = 0; ch < _channels; ch++) {
+		for (i = 0; i < n; i++) {
+			sum = 0;
+
+			for (j = 0; j < 8; j++)
+				sum += _quantizedCoeffs[ch][i][j];
+
+			sum /= 8;
+			if (sum > 0)
+				sum--;
+
+			for (j = 0; j < 8; j++)
+				_quantizedCoeffs[ch][i][j] = sum;
+		}
+	}
+}
+
+/**
+ * Build subband samples with noise weighted by q->tone_level.
+ * Called by synthfilt_build_sb_samples.
+ *
+ * @param sb    subband index
+ */
+void QDM2Stream::build_sb_samples_from_noise(int sb) {
+	int ch, j;
+
+	FIX_NOISE_IDX(_noiseIdx);
+
+	if (!_channels)
+		return;
+
+	for (ch = 0; ch < _channels; ch++) {
+		for (j = 0; j < 64; j++) {
+			_sbSamples[ch][j * 2][sb] = (int32)(SB_DITHERING_NOISE(sb, _noiseIdx) * _toneLevel[ch][sb][j] + .5);
+			_sbSamples[ch][j * 2 + 1][sb] = (int32)(SB_DITHERING_NOISE(sb, _noiseIdx) * _toneLevel[ch][sb][j] + .5);
+		}
+	}
+}
+
+/**
+ * Called while processing data from subpackets 11 and 12.
+ * Used after making changes to coding_method array.
+ *
+ * @param sb               subband index
+ * @param channels         number of channels
+ * @param coding_method    q->coding_method[0][0][0]
+ */
+void QDM2Stream::fix_coding_method_array(int sb, int channels, sb_int8_array coding_method)
+{
+	int j, k;
+	int ch;
+	int run, case_val;
+	int switchtable[23] = {0,5,1,5,5,5,5,5,2,5,5,5,5,5,5,5,3,5,5,5,5,5,4};
+
+	for (ch = 0; ch < channels; ch++) {
+		for (j = 0; j < 64; ) {
+			if((coding_method[ch][sb][j] - 8) > 22) {
+				run = 1;
+				case_val = 8;
+			} else {
+				switch (switchtable[coding_method[ch][sb][j]-8]) {
+					case 0: run = 10; case_val = 10; break;
+					case 1: run = 1; case_val = 16; break;
+					case 2: run = 5; case_val = 24; break;
+					case 3: run = 3; case_val = 30; break;
+					case 4: run = 1; case_val = 30; break;
+					case 5: run = 1; case_val = 8; break;
+					default: run = 1; case_val = 8; break;
+				}
+			}
+			for (k = 0; k < run; k++)
+				if (j + k < 128)
+					if (coding_method[ch][sb + (j + k) / 64][(j + k) % 64] > coding_method[ch][sb][j])
+						if (k > 0) {
+							warning("QDM2 Untested Code: not debugged, almost never used");
+							memset(&coding_method[ch][sb][j + k], case_val, k * sizeof(int8));
+							memset(&coding_method[ch][sb][j + k], case_val, 3 * sizeof(int8));
+						}
+			j += run;
+		}
+	}
+}
+
+/**
+ * Related to synthesis filter
+ * Called by process_subpacket_10
+ *
+ * @param flag    1 if called after getting data from subpacket 10, 0 if no subpacket 10
+ */
+void QDM2Stream::fill_tone_level_array(int flag) {
+	int i, sb, ch, sb_used;
+	int tmp, tab;
+
+	// This should never happen
+	if (_channels <= 0)
+		return;
+
+	for (ch = 0; ch < _channels; ch++) {
+		for (sb = 0; sb < 30; sb++) {
+			for (i = 0; i < 8; i++) {
+				if ((tab=coeff_per_sb_for_dequant[_coeffPerSbSelect][sb]) < (last_coeff[_coeffPerSbSelect] - 1))
+					tmp = _quantizedCoeffs[ch][tab + 1][i] * dequant_table[_coeffPerSbSelect][tab + 1][sb]+
+					      _quantizedCoeffs[ch][tab][i] * dequant_table[_coeffPerSbSelect][tab][sb];
+				else
+					tmp = _quantizedCoeffs[ch][tab][i] * dequant_table[_coeffPerSbSelect][tab][sb];
+				if(tmp < 0)
+					tmp += 0xff;
+				_toneLevelIdxBase[ch][sb][i] = (tmp / 256) & 0xff;
+			}
+		}
+	}
+
+	sb_used = QDM2_SB_USED(_subSampling);
+
+	if ((_superblocktype_2_3 != 0) && !flag) {
+		for (sb = 0; sb < sb_used; sb++) {
+			for (ch = 0; ch < _channels; ch++) {
+				for (i = 0; i < 64; i++) {
+					_toneLevelIdx[ch][sb][i] = _toneLevelIdxBase[ch][sb][i / 8];
+					if (_toneLevelIdx[ch][sb][i] < 0)
+						_toneLevel[ch][sb][i] = 0;
+					else
+						_toneLevel[ch][sb][i] = fft_tone_level_table[0][_toneLevelIdx[ch][sb][i] & 0x3f];
+				}
+			}
+		}
+	} else {
+		tab = _superblocktype_2_3 ? 0 : 1;
+		for (sb = 0; sb < sb_used; sb++) {
+			if ((sb >= 4) && (sb <= 23)) {
+				for (ch = 0; ch < _channels; ch++) {
+					for (i = 0; i < 64; i++) {
+						tmp = _toneLevelIdxBase[ch][sb][i / 8] -
+						      _toneLevelIdxHi1[ch][sb / 8][i / 8][i % 8] -
+						      _toneLevelIdxMid[ch][sb - 4][i / 8] -
+						      _toneLevelIdxHi2[ch][sb - 4];
+						_toneLevelIdx[ch][sb][i] = tmp & 0xff;
+						if ((tmp < 0) || (!_superblocktype_2_3 && !tmp))
+							_toneLevel[ch][sb][i] = 0;
+						else
+							_toneLevel[ch][sb][i] = fft_tone_level_table[tab][tmp & 0x3f];
+					}
+				}
+			} else {
+				if (sb > 4) {
+					for (ch = 0; ch < _channels; ch++) {
+						for (i = 0; i < 64; i++) {
+							tmp = _toneLevelIdxBase[ch][sb][i / 8] -
+							      _toneLevelIdxHi1[ch][2][i / 8][i % 8] -
+							      _toneLevelIdxHi2[ch][sb - 4];
+							_toneLevelIdx[ch][sb][i] = tmp & 0xff;
+							if ((tmp < 0) || (!_superblocktype_2_3 && !tmp))
+								_toneLevel[ch][sb][i] = 0;
+							else
+								_toneLevel[ch][sb][i] = fft_tone_level_table[tab][tmp & 0x3f];
+						}
+					}
+				} else {
+					for (ch = 0; ch < _channels; ch++) {
+						for (i = 0; i < 64; i++) {
+							tmp = _toneLevelIdx[ch][sb][i] = _toneLevelIdxBase[ch][sb][i / 8];
+							if ((tmp < 0) || (!_superblocktype_2_3 && !tmp))
+								_toneLevel[ch][sb][i] = 0;
+							else
+								_toneLevel[ch][sb][i] = fft_tone_level_table[tab][tmp & 0x3f];
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+/**
+ * Related to synthesis filter
+ * Called by process_subpacket_11
+ * c is built with data from subpacket 11
+ * Most of this function is used only if superblock_type_2_3 == 0, never seen it in samples
+ *
+ * @param tone_level_idx
+ * @param tone_level_idx_temp
+ * @param coding_method        q->coding_method[0][0][0]
+ * @param nb_channels          number of channels
+ * @param c                    coming from subpacket 11, passed as 8*c
+ * @param superblocktype_2_3   flag based on superblock packet type
+ * @param cm_table_select      q->cm_table_select
+ */
+void QDM2Stream::fill_coding_method_array(sb_int8_array tone_level_idx, sb_int8_array tone_level_idx_temp,
+                sb_int8_array coding_method, int nb_channels,
+                int c, int superblocktype_2_3, int cm_table_select) {
+	int ch, sb, j;
+	int tmp, acc, esp_40, comp;
+	int add1, add2, add3, add4;
+	// TODO : Remove multres 64 bit variable necessity...
+	int64_t multres;
+
+	// This should never happen
+	if (nb_channels <= 0)
+		return;
+	if (!superblocktype_2_3) {
+		warning("QDM2 This case is untested, no samples available");
+		for (ch = 0; ch < nb_channels; ch++)
+			for (sb = 0; sb < 30; sb++) {
+				for (j = 1; j < 63; j++) {  // The loop only iterates to 63 so the code doesn't overflow the buffer
+					add1 = tone_level_idx[ch][sb][j] - 10;
+					if (add1 < 0)
+						add1 = 0;
+					add2 = add3 = add4 = 0;
+					if (sb > 1) {
+						add2 = tone_level_idx[ch][sb - 2][j] + tone_level_idx_offset_table[sb][0] - 6;
+						if (add2 < 0)
+							add2 = 0;
+					}
+					if (sb > 0) {
+						add3 = tone_level_idx[ch][sb - 1][j] + tone_level_idx_offset_table[sb][1] - 6;
+						if (add3 < 0)
+							add3 = 0;
+					}
+					if (sb < 29) {
+						add4 = tone_level_idx[ch][sb + 1][j] + tone_level_idx_offset_table[sb][3] - 6;
+						if (add4 < 0)
+							add4 = 0;
+					}
+					tmp = tone_level_idx[ch][sb][j + 1] * 2 - add4 - add3 - add2 - add1;
+					if (tmp < 0)
+						tmp = 0;
+					tone_level_idx_temp[ch][sb][j + 1] = tmp & 0xff;
+				}
+				tone_level_idx_temp[ch][sb][0] = tone_level_idx_temp[ch][sb][1];
+			}
+			acc = 0;
+			for (ch = 0; ch < nb_channels; ch++)
+				for (sb = 0; sb < 30; sb++)
+					for (j = 0; j < 64; j++)
+						acc += tone_level_idx_temp[ch][sb][j];
+
+			multres = 0x66666667 * (acc * 10);
+			esp_40 = (multres >> 32) / 8 + ((multres & 0xffffffff) >> 31);
+			for (ch = 0;  ch < nb_channels; ch++)
+				for (sb = 0; sb < 30; sb++)
+					for (j = 0; j < 64; j++) {
+						comp = tone_level_idx_temp[ch][sb][j]* esp_40 * 10;
+						if (comp < 0)
+							comp += 0xff;
+						comp /= 256; // signed shift
+						switch(sb) {
+							case 0:
+								if (comp < 30)
+									comp = 30;
+								comp += 15;
+								break;
+							case 1:
+								if (comp < 24)
+									comp = 24;
+								comp += 10;
+								break;
+							case 2:
+							case 3:
+							case 4:
+								if (comp < 16)
+									comp = 16;
+						}
+						if (comp <= 5)
+							tmp = 0;
+						else if (comp <= 10)
+							tmp = 10;
+						else if (comp <= 16)
+							tmp = 16;
+						else if (comp <= 24)
+							tmp = -1;
+						else
+							tmp = 0;
+						coding_method[ch][sb][j] = ((tmp & 0xfffa) + 30 )& 0xff;
+					}
+			for (sb = 0; sb < 30; sb++)
+				fix_coding_method_array(sb, nb_channels, coding_method);
+			for (ch = 0; ch < nb_channels; ch++)
+				for (sb = 0; sb < 30; sb++)
+					for (j = 0; j < 64; j++)
+						if (sb >= 10) {
+							if (coding_method[ch][sb][j] < 10)
+								coding_method[ch][sb][j] = 10;
+						} else {
+							if (sb >= 2) {
+								if (coding_method[ch][sb][j] < 16)
+									coding_method[ch][sb][j] = 16;
+							} else {
+								if (coding_method[ch][sb][j] < 30)
+									coding_method[ch][sb][j] = 30;
+							}
+						}
+	} else { // superblocktype_2_3 != 0
+		for (ch = 0; ch < nb_channels; ch++)
+			for (sb = 0; sb < 30; sb++)
+				for (j = 0; j < 64; j++)
+					coding_method[ch][sb][j] = coding_method_table[cm_table_select][sb];
+	}
+}
+
+/**
+ *
+ * Called by process_subpacket_11 to process more data from subpacket 11 with sb 0-8
+ * Called by process_subpacket_12 to process data from subpacket 12 with sb 8-sb_used
+ *
+ * @param gb        bitreader context
+ * @param length    packet length in bits
+ * @param sb_min    lower subband processed (sb_min included)
+ * @param sb_max    higher subband processed (sb_max excluded)
+ */
+void QDM2Stream::synthfilt_build_sb_samples(GetBitContext *gb, int length, int sb_min, int sb_max) {
+	int sb, j, k, n, ch, run, channels;
+	int joined_stereo, zero_encoding, chs;
+	int type34_first;
+	float type34_div = 0;
+	float type34_predictor;
+	float samples[10], sign_bits[16];
+
+	if (length == 0) {
+		// If no data use noise
+		for (sb = sb_min; sb < sb_max; sb++)
+			build_sb_samples_from_noise(sb);
+
+		return;
+	}
+
+	for (sb = sb_min; sb < sb_max; sb++) {
+		FIX_NOISE_IDX(_noiseIdx);
+
+		channels = _channels;
+
+		if (_channels <= 1 || sb < 12)
+			joined_stereo = 0;
+		else if (sb >= 24)
+			joined_stereo = 1;
+		else
+			joined_stereo = (BITS_LEFT(length,gb) >= 1) ? getBits1 (gb) : 0;
+
+		if (joined_stereo) {
+			if (BITS_LEFT(length,gb) >= 16)
+				for (j = 0; j < 16; j++)
+					sign_bits[j] = getBits1(gb);
+
+			for (j = 0; j < 64; j++)
+				if (_codingMethod[1][sb][j] > _codingMethod[0][sb][j])
+					_codingMethod[0][sb][j] = _codingMethod[1][sb][j];
+
+			fix_coding_method_array(sb, _channels, _codingMethod);
+			channels = 1;
+		}
+
+		for (ch = 0; ch < channels; ch++) {
+			zero_encoding = (BITS_LEFT(length,gb) >= 1) ? getBits1(gb) : 0;
+			type34_predictor = 0.0;
+			type34_first = 1;
+
+			for (j = 0; j < 128; ) {
+				switch (_codingMethod[ch][sb][j / 2]) {
+					case 8:
+						if (BITS_LEFT(length,gb) >= 10) {
+							if (zero_encoding) {
+								for (k = 0; k < 5; k++) {
+								if ((j + 2 * k) >= 128)
+									break;
+									samples[2 * k] = getBits1(gb) ? dequant_1bit[joined_stereo][2 * getBits1(gb)] : 0;
+								}
+							} else {
+								n = getBits(gb, 8);
+								for (k = 0; k < 5; k++)
+									samples[2 * k] = dequant_1bit[joined_stereo][_randomDequantIndex[n][k]];
+							}
+							for (k = 0; k < 5; k++)
+								samples[2 * k + 1] = SB_DITHERING_NOISE(sb, _noiseIdx);
+						} else {
+							for (k = 0; k < 10; k++)
+								samples[k] = SB_DITHERING_NOISE(sb, _noiseIdx);
+						}
+						run = 10;
+						break;
+
+					case 10:
+						if (BITS_LEFT(length,gb) >= 1) {
+							double f = 0.81;
+
+							if (getBits1(gb))
+								f = -f;
+							f -= _noiseSamples[((sb + 1) * (j +5 * ch + 1)) & 127] * 9.0 / 40.0;
+							samples[0] = f;
+						} else {
+							samples[0] = SB_DITHERING_NOISE(sb, _noiseIdx);
+						}
+						run = 1;
+						break;
+
+					case 16:
+						if (BITS_LEFT(length,gb) >= 10) {
+							if (zero_encoding) {
+								for (k = 0; k < 5; k++) {
+									if ((j + k) >= 128)
+										break;
+									samples[k] = (getBits1(gb) == 0) ? 0 : dequant_1bit[joined_stereo][2 * getBits1(gb)];
+								}
+							} else {
+								n = getBits (gb, 8);
+								for (k = 0; k < 5; k++)
+									samples[k] = dequant_1bit[joined_stereo][_randomDequantIndex[n][k]];
+							}
+						} else {
+							for (k = 0; k < 5; k++)
+								samples[k] = SB_DITHERING_NOISE(sb, _noiseIdx);
+						}
+						run = 5;
+						break;
+
+					case 24:
+						if (BITS_LEFT(length,gb) >= 7) {
+							n = getBits(gb, 7);
+							for (k = 0; k < 3; k++)
+								samples[k] = (_randomDequantType24[n][k] - 2.0) * 0.5;
+						} else {
+							for (k = 0; k < 3; k++)
+								samples[k] = SB_DITHERING_NOISE(sb, _noiseIdx);
+						}
+						run = 3;
+						break;
+
+					case 30:
+						if (BITS_LEFT(length,gb) >= 4)
+							samples[0] = type30_dequant[qdm2_get_vlc(gb, &_vlcTabType30, 0, 1)];
+						else
+							samples[0] = SB_DITHERING_NOISE(sb, _noiseIdx);
+
+						run = 1;
+						break;
+
+					case 34:
+						if (BITS_LEFT(length,gb) >= 7) {
+							if (type34_first) {
+								type34_div = (float)(1 << getBits(gb, 2));
+								samples[0] = ((float)getBits(gb, 5) - 16.0) / 15.0;
+								type34_predictor = samples[0];
+								type34_first = 0;
+							} else {
+								samples[0] = type34_delta[qdm2_get_vlc(gb, &_vlcTabType34, 0, 1)] / type34_div + type34_predictor;
+								type34_predictor = samples[0];
+							}
+						} else {
+							samples[0] = SB_DITHERING_NOISE(sb, _noiseIdx);
+						}
+						run = 1;
+						break;
+
+					default:
+						samples[0] = SB_DITHERING_NOISE(sb, _noiseIdx);
+						run = 1;
+						break;
+				}
+
+				if (joined_stereo) {
+					float tmp[10][MPA_MAX_CHANNELS];
+
+					for (k = 0; k < run; k++) {
+						tmp[k][0] = samples[k];
+						tmp[k][1] = (sign_bits[(j + k) / 8]) ? -samples[k] : samples[k];
+					}
+					for (chs = 0; chs < _channels; chs++)
+						for (k = 0; k < run; k++)
+							if ((j + k) < 128)
+								_sbSamples[chs][j + k][sb] = (int32)(_toneLevel[chs][sb][((j + k)/2)] * tmp[k][chs] + .5);
+				} else {
+					for (k = 0; k < run; k++)
+						if ((j + k) < 128)
+							_sbSamples[ch][j + k][sb] = (int32)(_toneLevel[ch][sb][(j + k)/2] * samples[k] + .5);
+				}
+
+				j += run;
+			} // j loop
+		} // channel loop
+	} // subband loop
+}
+
+/**
+ * Init the first element of a channel in quantized_coeffs with data from packet 10 (quantized_coeffs[ch][0]).
+ * This is similar to process_subpacket_9, but for a single channel and for element [0]
+ * same VLC tables as process_subpacket_9 are used.
+ *
+ * @param quantized_coeffs    pointer to quantized_coeffs[ch][0]
+ * @param gb        bitreader context
+ * @param length    packet length in bits
+ */
+void QDM2Stream::init_quantized_coeffs_elem0(int8 *quantized_coeffs, GetBitContext *gb, int length) {
+	int i, k, run, level, diff;
+
+	if (BITS_LEFT(length,gb) < 16)
+		return;
+	level = qdm2_get_vlc(gb, &_vlcTabLevel, 0, 2);
+
+	quantized_coeffs[0] = level;
+
+	for (i = 0; i < 7; ) {
+		if (BITS_LEFT(length,gb) < 16)
+			break;
+		run = qdm2_get_vlc(gb, &_vlcTabRun, 0, 1) + 1;
+
+		if (BITS_LEFT(length,gb) < 16)
+			break;
+		diff = qdm2_get_se_vlc(&_vlcTabDiff, gb, 2);
+
+		for (k = 1; k <= run; k++)
+			quantized_coeffs[i + k] = (level + ((k * diff) / run));
+
+		level += diff;
+		i += run;
+	}
+}
+
+/**
+ * Related to synthesis filter, process data from packet 10
+ * Init part of quantized_coeffs via function init_quantized_coeffs_elem0
+ * Init tone_level_idx_hi1, tone_level_idx_hi2, tone_level_idx_mid with data from packet 10
+ *
+ * @param gb        bitreader context
+ * @param length    packet length in bits
+ */
+void QDM2Stream::init_tone_level_dequantization(GetBitContext *gb, int length) {
+	int sb, j, k, n, ch;
+
+	for (ch = 0; ch < _channels; ch++) {
+		init_quantized_coeffs_elem0(_quantizedCoeffs[ch][0], gb, length);
+
+		if (BITS_LEFT(length,gb) < 16) {
+			memset(_quantizedCoeffs[ch][0], 0, 8);
+			break;
+		}
+	}
+
+	n = _subSampling + 1;
+
+	for (sb = 0; sb < n; sb++)
+		for (ch = 0; ch < _channels; ch++)
+			for (j = 0; j < 8; j++) {
+				if (BITS_LEFT(length,gb) < 1)
+					break;
+				if (getBits1(gb)) {
+					for (k=0; k < 8; k++) {
+						if (BITS_LEFT(length,gb) < 16)
+							break;
+						_toneLevelIdxHi1[ch][sb][j][k] = qdm2_get_vlc(gb, &_vlcTabToneLevelIdxHi1, 0, 2);
+					}
+				} else {
+					for (k=0; k < 8; k++)
+						_toneLevelIdxHi1[ch][sb][j][k] = 0;
+				}
+			}
+
+	n = QDM2_SB_USED(_subSampling) - 4;
+
+	for (sb = 0; sb < n; sb++)
+		for (ch = 0; ch < _channels; ch++) {
+			if (BITS_LEFT(length,gb) < 16)
+				break;
+			_toneLevelIdxHi2[ch][sb] = qdm2_get_vlc(gb, &_vlcTabToneLevelIdxHi2, 0, 2);
+			if (sb > 19)
+				_toneLevelIdxHi2[ch][sb] -= 16;
+			else
+				for (j = 0; j < 8; j++)
+					_toneLevelIdxMid[ch][sb][j] = -16;
+		}
+
+	n = QDM2_SB_USED(_subSampling) - 5;
+
+	for (sb = 0; sb < n; sb++) {
+		for (ch = 0; ch < _channels; ch++) {
+			for (j = 0; j < 8; j++) {
+				if (BITS_LEFT(length,gb) < 16)
+					break;
+				_toneLevelIdxMid[ch][sb][j] = qdm2_get_vlc(gb, &_vlcTabToneLevelIdxMid, 0, 2) - 32;
+			}
+		}
+	}
+}
+
+/**
+ * Process subpacket 9, init quantized_coeffs with data from it
+ *
+ * @param node    pointer to node with packet
+ */
+void QDM2Stream::process_subpacket_9(QDM2SubPNode *node) {
+	GetBitContext gb;
+	int i, j, k, n, ch, run, level, diff;
+
+	initGetBits(&gb, node->packet->data, node->packet->size*8);
+
+	n = coeff_per_sb_for_avg[_coeffPerSbSelect][QDM2_SB_USED(_subSampling) - 1] + 1; // same as averagesomething function
+
+	for (i = 1; i < n; i++)
+		for (ch = 0; ch < _channels; ch++) {
+			level = qdm2_get_vlc(&gb, &_vlcTabLevel, 0, 2);
+			_quantizedCoeffs[ch][i][0] = level;
+
+			for (j = 0; j < (8 - 1); ) {
+				run = qdm2_get_vlc(&gb, &_vlcTabRun, 0, 1) + 1;
+				diff = qdm2_get_se_vlc(&_vlcTabDiff, &gb, 2);
+
+				for (k = 1; k <= run; k++)
+					_quantizedCoeffs[ch][i][j + k] = (level + ((k*diff) / run));
+
+				level += diff;
+				j += run;
+			}
+		}
+
+	for (ch = 0; ch < _channels; ch++)
+		for (i = 0; i < 8; i++)
+			_quantizedCoeffs[ch][0][i] = 0;
+}
+
+/**
+ * Process subpacket 10 if not null, else
+ *
+ * @param node      pointer to node with packet
+ * @param length    packet length in bits
+ */
+void QDM2Stream::process_subpacket_10(QDM2SubPNode *node, int length) {
+	GetBitContext gb;
+
+	initGetBits(&gb, ((node == NULL) ? _emptyBuffer : node->packet->data), ((node == NULL) ? 0 : node->packet->size*8));
+
+	if (length != 0) {
+		init_tone_level_dequantization(&gb, length);
+		fill_tone_level_array(1);
+	} else {
+		fill_tone_level_array(0);
+	}
+}
+
+/**
+ * Process subpacket 11
+ *
+ * @param node      pointer to node with packet
+ * @param length    packet length in bit
+ */
+void QDM2Stream::process_subpacket_11(QDM2SubPNode *node, int length) {
+	GetBitContext gb;
+
+	initGetBits(&gb, ((node == NULL) ? _emptyBuffer : node->packet->data), ((node == NULL) ? 0 : node->packet->size*8));
+	if (length >= 32) {
+		int c = getBits (&gb, 13);
+
+		if (c > 3)
+			fill_coding_method_array(_toneLevelIdx, _toneLevelIdxTemp, _codingMethod,
+			                         _channels, 8*c, _superblocktype_2_3, _cmTableSelect);
+	}
+
+	synthfilt_build_sb_samples(&gb, length, 0, 8);
+}
+
+/**
+ * Process subpacket 12
+ *
+ * @param node      pointer to node with packet
+ * @param length    packet length in bits
+ */
+void QDM2Stream::process_subpacket_12(QDM2SubPNode *node, int length) {
+	GetBitContext gb;
+
+	initGetBits(&gb, ((node == NULL) ? _emptyBuffer : node->packet->data), ((node == NULL) ? 0 : node->packet->size*8));
+	synthfilt_build_sb_samples(&gb, length, 8, QDM2_SB_USED(_subSampling));
+}
+
+/*
+ * Process new subpackets for synthesis filter
+ *
+ * @param list    list with synthesis filter packets (list D)
+ */
+void QDM2Stream::process_synthesis_subpackets(QDM2SubPNode *list) {
+	struct QDM2SubPNode *nodes[4];
+
+	nodes[0] = qdm2_search_subpacket_type_in_list(list, 9);
+	if (nodes[0] != NULL)
+		process_subpacket_9(nodes[0]);
+
+	nodes[1] = qdm2_search_subpacket_type_in_list(list, 10);
+	if (nodes[1] != NULL)
+		process_subpacket_10(nodes[1], nodes[1]->packet->size << 3);
+	else
+		process_subpacket_10(NULL, 0);
+
+	nodes[2] = qdm2_search_subpacket_type_in_list(list, 11);
+	if (nodes[0] != NULL && nodes[1] != NULL && nodes[2] != NULL)
+		process_subpacket_11(nodes[2], (nodes[2]->packet->size << 3));
+	else
+		process_subpacket_11(NULL, 0);
+
+	nodes[3] = qdm2_search_subpacket_type_in_list(list, 12);
+	if (nodes[0] != NULL && nodes[1] != NULL && nodes[3] != NULL)
+		process_subpacket_12(nodes[3], (nodes[3]->packet->size << 3));
+	else
+		process_subpacket_12(NULL, 0);
+}
+
+/*
+ * Decode superblock, fill packet lists.
+ *
+ */
+void QDM2Stream::qdm2_decode_super_block(void) {
+	GetBitContext gb;
+	struct QDM2SubPacket header, *packet;
+	int i, packet_bytes, sub_packet_size, subPacketsD;
+	unsigned int next_index = 0;
+
+	memset(_toneLevelIdxHi1, 0, sizeof(_toneLevelIdxHi1));
+	memset(_toneLevelIdxMid, 0, sizeof(_toneLevelIdxMid));
+	memset(_toneLevelIdxHi2, 0, sizeof(_toneLevelIdxHi2));
+
+	_subPacketsB = 0;
+	subPacketsD = 0;
+
+	average_quantized_coeffs(); // average elements in quantized_coeffs[max_ch][10][8]
+
+	initGetBits(&gb, _compressedData, _packetSize*8);
+	qdm2_decode_sub_packet_header(&gb, &header);
+
+	if (header.type < 2 || header.type >= 8) {
+		_hasErrors = true;
+		error("QDM2 : bad superblock type");
+		return;
+	}
+
+	_superblocktype_2_3 = (header.type == 2 || header.type == 3);
+	packet_bytes = (_packetSize - getBitsCount(&gb) / 8);
+
+	initGetBits(&gb, header.data, header.size*8);
+
+	if (header.type == 2 || header.type == 4 || header.type == 5) {
+		int csum = 257 * getBits(&gb, 8) + 2 * getBits(&gb, 8);
+
+		csum = qdm2_packet_checksum(_compressedData, _packetSize, csum);
+
+		if (csum != 0) {
+			_hasErrors = true;
+			error("QDM2 : bad packet checksum");
+			return;
+		}
+	}
+
+	_subPacketListB[0].packet = NULL;
+	_subPacketListD[0].packet = NULL;
+
+	for (i = 0; i < 6; i++)
+		if (--_fftLevelExp[i] < 0)
+			_fftLevelExp[i] = 0;
+
+	for (i = 0; packet_bytes > 0; i++) {
+		int j;
+
+		_subPacketListA[i].next = NULL;
+
+		if (i > 0) {
+			_subPacketListA[i - 1].next = &_subPacketListA[i];
+
+			// seek to next block
+			initGetBits(&gb, header.data, header.size*8);
+			skipBits(&gb, next_index*8);
+
+			if (next_index >= header.size)
+				break;
+		}
+
+		// decode subpacket
+		packet = &_subPackets[i];
+		qdm2_decode_sub_packet_header(&gb, packet);
+		next_index = packet->size + getBitsCount(&gb) / 8;
+		sub_packet_size = ((packet->size > 0xff) ? 1 : 0) + packet->size + 2;
+
+		if (packet->type == 0)
+			break;
+
+		if (sub_packet_size > packet_bytes) {
+			if (packet->type != 10 && packet->type != 11 && packet->type != 12)
+				break;
+			packet->size += packet_bytes - sub_packet_size;
+		}
+
+		packet_bytes -= sub_packet_size;
+
+		// add subpacket to 'all subpackets' list
+		_subPacketListA[i].packet = packet;
+
+		// add subpacket to related list
+		if (packet->type == 8) {
+			error("Unsupported packet type 8");
+			return;
+		} else if (packet->type >= 9 && packet->type <= 12) {
+			// packets for MPEG Audio like Synthesis Filter
+			QDM2_LIST_ADD(_subPacketListD, subPacketsD, packet);
+		} else if (packet->type == 13) {
+			for (j = 0; j < 6; j++)
+				_fftLevelExp[j] = getBits(&gb, 6);
+		} else if (packet->type == 14) {
+			for (j = 0; j < 6; j++)
+				_fftLevelExp[j] = qdm2_get_vlc(&gb, &_fftLevelExpVlc, 0, 2);
+		} else if (packet->type == 15) {
+			error("Unsupported packet type 15");
+			return;
+		} else if (packet->type >= 16 && packet->type < 48 && !fft_subpackets[packet->type - 16]) {
+			// packets for FFT
+			QDM2_LIST_ADD(_subPacketListB, _subPacketsB, packet);
+		}
+	} // Packet bytes loop
+
+// ****************************************************************
+	if (_subPacketListD[0].packet != NULL) {
+		process_synthesis_subpackets(_subPacketListD);
+		_doSynthFilter = 1;
+	} else if (_doSynthFilter) {
+		process_subpacket_10(NULL, 0);
+		process_subpacket_11(NULL, 0);
+		process_subpacket_12(NULL, 0);
+	}
+// ****************************************************************
+}
+
+void QDM2Stream::qdm2_fft_init_coefficient(int sub_packet, int offset, int duration, 
+                                           int channel, int exp, int phase) {
+	if (_fftCoefsMinIndex[duration] < 0)
+	    _fftCoefsMinIndex[duration] = _fftCoefsIndex;
+
+	_fftCoefs[_fftCoefsIndex].sub_packet = ((sub_packet >= 16) ? (sub_packet - 16) : sub_packet);
+	_fftCoefs[_fftCoefsIndex].channel = channel;
+	_fftCoefs[_fftCoefsIndex].offset = offset;
+	_fftCoefs[_fftCoefsIndex].exp = exp;
+	_fftCoefs[_fftCoefsIndex].phase = phase;
+	_fftCoefsIndex++;
+}
+
+void QDM2Stream::qdm2_fft_decode_tones(int duration, GetBitContext *gb, int b) {
+	debug(1, "QDM2Stream::qdm2_fft_decode_tones() duration: %d b:%d", duration, b);
+	int channel, stereo, phase, exp;
+	int local_int_4,  local_int_8,  stereo_phase,  local_int_10;
+	int local_int_14, stereo_exp, local_int_20, local_int_28;
+	int n, offset;
+
+	local_int_4 = 0;
+	local_int_28 = 0;
+	local_int_20 = 2;
+	local_int_8 = (4 - duration);
+	local_int_10 = 1 << (_groupOrder - duration - 1);
+	offset = 1;
+
+	while (1) {
+		if (_superblocktype_2_3) {
+			debug(1, "QDM2Stream::qdm2_fft_decode_tones() local_int_8: %d", local_int_8);
+			while ((n = qdm2_get_vlc(gb, &_vlcTabFftToneOffset[local_int_8], 1, 2)) < 2) {
+				debug(1, "QDM2Stream::qdm2_fft_decode_tones() local_int_8: %d", local_int_8);
+				offset = 1;
+				if (n == 0) {
+					local_int_4 += local_int_10;
+					local_int_28 += (1 << local_int_8);
+				} else {
+					local_int_4 += 8*local_int_10;
+					local_int_28 += (8 << local_int_8);
+				}
+			}
+			offset += (n - 2);
+		} else {
+			offset += qdm2_get_vlc(gb, &_vlcTabFftToneOffset[local_int_8], 1, 2);
+			while (offset >= (local_int_10 - 1)) {
+				offset += (1 - (local_int_10 - 1));
+				local_int_4  += local_int_10;
+				local_int_28 += (1 << local_int_8);
+			}
+		}
+
+		if (local_int_4 >= _blockSize)
+			return;
+
+		local_int_14 = (offset >> local_int_8);
+
+		if (_channels > 1) {
+			channel = getBits1(gb);
+			stereo = getBits1(gb);
+		} else {
+			channel = 0;
+			stereo = 0;
+		}
+
+		exp = qdm2_get_vlc(gb, (b ? &_fftLevelExpVlc : &_fftLevelExpAltVlc), 0, 2);
+		exp += _fftLevelExp[fft_level_index_table[local_int_14]];
+		exp = (exp < 0) ? 0 : exp;
+
+		phase = getBits(gb, 3);
+		stereo_exp = 0;
+		stereo_phase = 0;
+
+		if (stereo) {
+			stereo_exp = (exp - qdm2_get_vlc(gb, &_fftStereoExpVlc, 0, 1));
+			stereo_phase = (phase - qdm2_get_vlc(gb, &_fftStereoPhaseVlc, 0, 1));
+			if (stereo_phase < 0)
+				stereo_phase += 8;
+		}
+
+		if (_frequencyRange > (local_int_14 + 1)) {
+			int sub_packet = (local_int_20 + local_int_28);
+
+			qdm2_fft_init_coefficient(sub_packet, offset, duration, channel, exp, phase);
+			if (stereo)
+				qdm2_fft_init_coefficient(sub_packet, offset, duration, (1 - channel), stereo_exp, stereo_phase);
+		}
+
+		offset++;
+	}
+}
+
+void QDM2Stream::qdm2_decode_fft_packets(void) {
+	debug(1, "QDM2Stream::qdm2_decode_fft_packets()");
+	int i, j, min, max, value, type, unknown_flag;
+	GetBitContext gb;
+
+	if (_subPacketListB[0].packet == NULL)
+		return;
+
+	// reset minimum indexes for FFT coefficients
+	_fftCoefsIndex = 0;
+	for (i=0; i < 5; i++)
+		_fftCoefsMinIndex[i] = -1;
+
+	// process subpackets ordered by type, largest type first
+	for (i = 0, max = 256; i < _subPacketsB; i++) {
+		QDM2SubPacket *packet= NULL;
+
+		// find subpacket with largest type less than max
+		for (j = 0, min = 0; j < _subPacketsB; j++) {
+			value = _subPacketListB[j].packet->type;
+			if (value > min && value < max) {
+				min = value;
+				packet = _subPacketListB[j].packet;
+			}
+		}
+
+		max = min;
+
+		// check for errors (?)
+		if (!packet)
+			return;
+
+		if (i == 0 && (packet->type < 16 || packet->type >= 48 || fft_subpackets[packet->type - 16]))
+			return;
+
+		// decode FFT tones
+		debug(1, "QDM2Stream::qdm2_decode_fft_packets initGetBits() packet->size*8: %d", packet->size*8);
+		initGetBits(&gb, packet->data, packet->size*8);
+
+		if (packet->type >= 32 && packet->type < 48 && !fft_subpackets[packet->type - 16])
+			unknown_flag = 1;
+		else
+			unknown_flag = 0;
+
+		type = packet->type;
+
+		if ((type >= 17 && type < 24) || (type >= 33 && type < 40)) {
+			int duration = _subSampling + 5 - (type & 15);
+
+			if (duration >= 0 && duration < 4) { // TODO: Should be <= 4?
+				debug(1, "QDM2Stream::qdm2_decode_fft_packets qdm2_fft_decode_tones() #1");
+				qdm2_fft_decode_tones(duration, &gb, unknown_flag);
+			}
+		} else if (type == 31) {
+			for (j=0; j < 4; j++) {
+				debug(1, "QDM2Stream::qdm2_decode_fft_packets qdm2_fft_decode_tones() #2");
+				qdm2_fft_decode_tones(j, &gb, unknown_flag);
+			}
+		} else if (type == 46) {
+			for (j=0; j < 6; j++)
+				_fftLevelExp[j] = getBits(&gb, 6);
+			for (j=0; j < 4; j++) {
+				debug(1, "QDM2Stream::qdm2_decode_fft_packets qdm2_fft_decode_tones() #3");
+				qdm2_fft_decode_tones(j, &gb, unknown_flag);
+			}
+		}
+	} // Loop on B packets
+
+	// calculate maximum indexes for FFT coefficients
+	for (i = 0, j = -1; i < 5; i++)
+		if (_fftCoefsMinIndex[i] >= 0) {
+			if (j >= 0)
+				_fftCoefsMaxIndex[j] = _fftCoefsMinIndex[i];
+			j = i;
+		}
+	if (j >= 0)
+		_fftCoefsMaxIndex[j] = _fftCoefsIndex;
+}
+
+void QDM2Stream::qdm2_fft_generate_tone(FFTTone *tone)
+{
+	float level, f[6];
+	int i;
+	QDM2Complex c;
+	const double iscale = 2.0 * PI / 512.0;
+
+	tone->phase += tone->phase_shift;
+
+	// calculate current level (maximum amplitude) of tone
+	level = fft_tone_envelope_table[tone->duration][tone->time_index] * tone->level;
+	c.im = level * sin(tone->phase*iscale);
+	c.re = level * cos(tone->phase*iscale);
+
+	// generate FFT coefficients for tone
+	if (tone->duration >= 3 || tone->cutoff >= 3) {
+	    tone->complex[0].im += c.im;
+	    tone->complex[0].re += c.re;
+	    tone->complex[1].im -= c.im;
+	    tone->complex[1].re -= c.re;
+	} else {
+		f[1] = -tone->table[4];
+		f[0] =  tone->table[3] - tone->table[0];
+		f[2] =  1.0 - tone->table[2] - tone->table[3];
+		f[3] =  tone->table[1] + tone->table[4] - 1.0;
+		f[4] =  tone->table[0] - tone->table[1];
+		f[5] =  tone->table[2];
+		for (i = 0; i < 2; i++) {
+			tone->complex[fft_cutoff_index_table[tone->cutoff][i]].re += c.re * f[i];
+			tone->complex[fft_cutoff_index_table[tone->cutoff][i]].im += c.im *((tone->cutoff <= i) ? -f[i] : f[i]);
+		}
+		for (i = 0; i < 4; i++) {
+			tone->complex[i].re += c.re * f[i+2];
+			tone->complex[i].im += c.im * f[i+2];
+		}
+	}
+
+	// copy the tone if it has not yet died out
+	if (++tone->time_index < ((1 << (5 - tone->duration)) - 1)) {
+		memcpy(&_fftTones[_fftToneEnd], tone, sizeof(FFTTone));
+		_fftToneEnd = (_fftToneEnd + 1) % 1000;
+	}
+}
+
+void QDM2Stream::qdm2_fft_tone_synthesizer(uint8 sub_packet) {
+	int i, j, ch;
+	const double iscale = 0.25 * PI;
+
+	for (ch = 0; ch < _channels; ch++) {
+		memset(_fft.complex[ch], 0, _frameSize * sizeof(QDM2Complex));
+	}
+
+	// apply FFT tones with duration 4 (1 FFT period)
+	if (_fftCoefsMinIndex[4] >= 0)
+		for (i = _fftCoefsMinIndex[4]; i < _fftCoefsMaxIndex[4]; i++) {
+			float level;
+			QDM2Complex c;
+
+			if (_fftCoefs[i].sub_packet != sub_packet)
+				break;
+
+			ch = (_channels == 1) ? 0 : _fftCoefs[i].channel;
+			level = (_fftCoefs[i].exp < 0) ? 0.0 : fft_tone_level_table[_superblocktype_2_3 ? 0 : 1][_fftCoefs[i].exp & 63];
+
+			c.re = level * cos(_fftCoefs[i].phase * iscale);
+			c.im = level * sin(_fftCoefs[i].phase * iscale);
+			_fft.complex[ch][_fftCoefs[i].offset + 0].re += c.re;
+			_fft.complex[ch][_fftCoefs[i].offset + 0].im += c.im;
+			_fft.complex[ch][_fftCoefs[i].offset + 1].re -= c.re;
+			_fft.complex[ch][_fftCoefs[i].offset + 1].im -= c.im;
+		}
+
+	// generate existing FFT tones
+	for (i = _fftToneEnd; i != _fftToneStart; ) {
+		qdm2_fft_generate_tone(&_fftTones[_fftToneStart]);
+		_fftToneStart = (_fftToneStart + 1) % 1000;
+	}
+
+	// create and generate new FFT tones with duration 0 (long) to 3 (short)
+	for (i = 0; i < 4; i++)
+		if (_fftCoefsMinIndex[i] >= 0) {
+			for (j = _fftCoefsMinIndex[i]; j < _fftCoefsMaxIndex[i]; j++) {
+				int offset, four_i;
+				FFTTone tone;
+
+				if (_fftCoefs[j].sub_packet != sub_packet)
+					break;
+
+				four_i = (4 - i);
+				offset = _fftCoefs[j].offset >> four_i;
+				ch = (_channels == 1) ? 0 : _fftCoefs[j].channel;
+
+				if (offset < _frequencyRange) {
+					if (offset < 2)
+						tone.cutoff = offset;
+					else
+						tone.cutoff = (offset >= 60) ? 3 : 2;
+
+					tone.level = (_fftCoefs[j].exp < 0) ? 0.0 : fft_tone_level_table[_superblocktype_2_3 ? 0 : 1][_fftCoefs[j].exp & 63];
+					tone.complex = &_fft.complex[ch][offset];
+					tone.table = fft_tone_sample_table[i][_fftCoefs[j].offset - (offset << four_i)];
+					tone.phase = 64 * _fftCoefs[j].phase - (offset << 8) - 128;
+					tone.phase_shift = (2 * _fftCoefs[j].offset + 1) << (7 - four_i);
+					tone.duration = i;
+					tone.time_index = 0;
+
+					qdm2_fft_generate_tone(&tone);
+				}
+			}
+			_fftCoefsMinIndex[i] = j;
+		}
+}
+
+void QDM2Stream::qdm2_calculate_fft(int channel) {
+	debug(1, "QDM2Stream::qdm2_calculate_fft channel: %d", channel);
+	const float gain = (_channels == 1 && _channels == 2) ? 0.5f : 1.0f;
+	int i;
+
+	_fft.complex[channel][0].re *= 2.0f;
+	_fft.complex[channel][0].im = 0.0f;
+
+	//debug(1, "QDM2Stream::qdm2_calculate_fft _fft.complex[channel][0].re: %lf", _fft.complex[channel][0].re);
+	//debug(1, "QDM2Stream::qdm2_calculate_fft _fft.complex[channel][0].im: %lf", _fft.complex[channel][0].im);
+
+	rdftCalc(&_rdftCtx, (float *)_fft.complex[channel]);
+	
+	// add samples to output buffer
+	for (i = 0; i < ((_fftFrameSize + 15) & ~15); i++)
+		_outputBuffer[_channels * i + channel] += ((float *) _fft.complex[channel])[i] * gain;
+}
+
+/**
+ * @param index    subpacket number
+ */
+void QDM2Stream::qdm2_synthesis_filter(uint8 index)
+{
+	int16 samples[MPA_MAX_CHANNELS * MPA_FRAME_SIZE];
+	int i, k, ch, sb_used, sub_sampling, dither_state = 0;
+
+	// copy sb_samples
+	sb_used = QDM2_SB_USED(_subSampling);
+
+	for (ch = 0; ch < _channels; ch++)
+		for (i = 0; i < 8; i++)
+			for (k = sb_used; k < 32; k++)
+				_sbSamples[ch][(8 * index) + i][k] = 0;
+
+	for (ch = 0; ch < _channels; ch++) {
+		int16 *samples_ptr = samples + ch;
+
+		for (i = 0; i < 8; i++) {
+			ff_mpa_synth_filter(_synthBuf[ch], &(_synthBufOffset[ch]),
+			                    ff_mpa_synth_window, &dither_state,
+			                    samples_ptr, _channels,
+			                    _sbSamples[ch][(8 * index) + i]);
+			samples_ptr += 32 * _channels;
+		}
+	}
+
+	// add samples to output buffer
+	sub_sampling = (4 >> _subSampling);
+
+	for (ch = 0; ch < _channels; ch++)
+		for (i = 0; i < _sFrameSize; i++)
+			_outputBuffer[_channels * i + ch] += (float)(samples[_channels * sub_sampling * i + ch] >> (sizeof(int16)*8-16));
+}
+
+int QDM2Stream::qdm2_decodeFrame(Common::SeekableReadStream *in) {
+	debug(1, "QDM2Stream::qdm2_decodeFrame in->pos(): %d in->size(): %d", in->pos(), in->size());
+	int ch, i;
+	const int frame_size = (_sFrameSize * _channels);
+
+	// select input buffer
+	if(in->eos() || in->size() == in->pos()) {
+		debug(1, "QDM2Stream::qdm2_decodeFrame End of Input Stream");
+		return 0;
+	}
+	if((in->size() - in->pos()) < _packetSize) {
+		debug(1, "QDM2Stream::qdm2_decodeFrame Insufficient Packet Data in Input Stream Found: %d Need: %d", in->size() - in->pos(), _packetSize);
+		return 0;
+	}
+
+	for(i = 0; i < _packetSize; i++)
+		_compressedData[i] = in->readByte();
+	debug(1, "QDM2Stream::qdm2_decodeFrame constructed input data");
+
+	// copy old block, clear new block of output samples
+	memmove(_outputBuffer, &_outputBuffer[frame_size], frame_size * sizeof(float));
+	memset(&_outputBuffer[frame_size], 0, frame_size * sizeof(float));
+	debug(1, "QDM2Stream::qdm2_decodeFrame cleared outputBuffer");
+
+	// decode block of QDM2 compressed data
+	debug(1, "QDM2Stream::qdm2_decodeFrame decode block of QDM2 compressed data");
+	if (_subPacket == 0) {
+		_hasErrors = false; // reset it for a new super block
+		debug(1, "QDM2 : Superblock follows");
+		qdm2_decode_super_block();
+	}
+
+	// parse subpackets
+	debug(1, "QDM2Stream::qdm2_decodeFrame parse subpackets");
+	if (!_hasErrors) {
+		if (_subPacket == 2) {
+			debug(1, "QDM2Stream::qdm2_decodeFrame qdm2_decode_fft_packets()");
+			qdm2_decode_fft_packets();
+		}
+
+		debug(1, "QDM2Stream::qdm2_decodeFrame qdm2_fft_tone_synthesizer(%d)", _subPacket);
+		qdm2_fft_tone_synthesizer(_subPacket);
+	}
+
+	// sound synthesis stage 1 (FFT)
+	debug(1, "QDM2Stream::qdm2_decodeFrame sound synthesis stage 1 (FFT)");
+	for (ch = 0; ch < _channels; ch++) {
+		qdm2_calculate_fft(ch);
+
+		if (!_hasErrors && _subPacketListC[0].packet != NULL) {
+			error("QDM2 : has errors, and C list is not empty");
+			return 0;
+		}
+	}
+
+	// sound synthesis stage 2 (MPEG audio like synthesis filter)
+	debug(1, "QDM2Stream::qdm2_decodeFrame sound synthesis stage 2 (MPEG audio like synthesis filter)");
+	if (!_hasErrors && _doSynthFilter)
+		qdm2_synthesis_filter(_subPacket);
+
+	_subPacket = (_subPacket + 1) % 16;
+
+	if(_hasErrors)
+		warning("QDM2 Packet error...");
+
+	// clip and convert output float[] to 16bit signed samples
+	debug(1, "QDM2Stream::qdm2_decodeFrame clip and convert output float[] to 16bit signed samples");
+
+/*
+	debugN(1, "Input Data Packet:");
+	for(i = 0; i < _packetSize; i++) {
+		debugN(1, " %d", _compressedData[i]);
+	}
+	debugN(1, " Output Data Packet:");
+	for(i = 0; i < frame_size; i++) {
+		debugN(1, " %d", (int)_outputBuffer[i]);
+	}
+	debug(1, "");
+*/
+
+	for (i = 0; i < frame_size; i++) {
+		//debug(1, "QDM2Stream::qdm2_decodeFrame i: %d", i);
+		int value = (int)_outputBuffer[i];
+
+		if (value > SOFTCLIP_THRESHOLD)
+			value = (value >  HARDCLIP_THRESHOLD) ?  32767 :  _softclipTable[ value - SOFTCLIP_THRESHOLD];
+		else if (value < -SOFTCLIP_THRESHOLD)
+			value = (value < -HARDCLIP_THRESHOLD) ? -32767 : -_softclipTable[-value - SOFTCLIP_THRESHOLD];
+
+		_outputSamples.push_back(value);
+	}
+	return frame_size;
+}
+
+int QDM2Stream::readBuffer(int16 *buffer, const int numSamples) {
+	debug(1, "QDM2Stream::readBuffer numSamples: %d", numSamples);
+	int32 decodedSamples = _outputSamples.size();
+	int32 i;
+
+	//while((int)_outputSamples.size() < numSamples) {
+	while(!_stream->eos() && _stream->pos() != _stream->size()) {
+		i = qdm2_decodeFrame(_stream);
+		if(i == 0)
+			break; // Out Of Decode Frames...
+		decodedSamples += i;
+	}
+	if(decodedSamples > numSamples)
+		decodedSamples = numSamples;
+
+	for(i = 0; i < decodedSamples; i++)
+		buffer[i] = _outputSamples.remove_at(0);
+
+	return decodedSamples;
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/video/qdm2.h b/engines/mohawk/video/qdm2.h
new file mode 100644
index 0000000000..1a08064b0b
--- /dev/null
+++ b/engines/mohawk/video/qdm2.h
@@ -0,0 +1,288 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#ifndef MOHAWK_VIDEO_QDM2_H
+#define MOHAWK_VIDEO_QDM2_H
+
+#include "sound/audiostream.h"
+#include "common/stream.h"
+
+namespace Mohawk {
+
+enum {
+	SOFTCLIP_THRESHOLD = 27600,
+	HARDCLIP_THRESHOLD = 35716,
+	MPA_MAX_CHANNELS = 2,
+	MPA_FRAME_SIZE = 1152,
+	FF_INPUT_BUFFER_PADDING_SIZE = 8
+};
+
+typedef int8 sb_int8_array[2][30][64];
+
+/* bit input */
+/* buffer, buffer_end and size_in_bits must be present and used by every reader */
+struct GetBitContext {
+	const uint8 *buffer, *bufferEnd;
+	int index;
+	int sizeInBits;
+};
+
+struct QDM2SubPacket {
+	int type;
+	unsigned int size;
+	const uint8 *data; // pointer to subpacket data (points to input data buffer, it's not a private copy)
+};
+
+struct QDM2SubPNode {
+	QDM2SubPacket *packet;
+	struct QDM2SubPNode *next; // pointer to next packet in the list, NULL if leaf node
+};
+
+struct QDM2Complex {
+	float re;
+	float im;
+};
+
+struct FFTTone {
+	float level;
+	QDM2Complex *complex;
+	const float *table;
+	int phase;
+	int phase_shift;
+	int duration;
+	short time_index;
+	short cutoff;
+};
+
+struct FFTCoefficient {
+	int16 sub_packet;
+	uint8 channel;
+	int16 offset;
+	int16 exp;
+	uint8 phase;
+};
+
+struct VLC {
+	int32 bits;
+	int16 (*table)[2]; // code, bits
+	int32 table_size;
+	int32 table_allocated;
+};
+
+#include "common/pack-start.h"
+struct QDM2FFT {
+	QDM2Complex complex[MPA_MAX_CHANNELS][256];
+} PACKED_STRUCT;
+#include "common/pack-end.h"
+
+enum RDFTransformType {
+	RDFT,
+	IRDFT,
+	RIDFT,
+	IRIDFT
+};
+
+struct FFTComplex {
+	float re, im;
+};
+
+struct FFTContext {
+	int nbits;
+	int inverse;
+	uint16 *revtab;
+	FFTComplex *exptab;
+	FFTComplex *tmpBuf;
+	int mdctSize; // size of MDCT (i.e. number of input data * 2)
+	int mdctBits; // n = 2^nbits
+	// pre/post rotation tables
+	float *tcos;
+	float *tsin;
+	void (*fftPermute)(struct FFTContext *s, FFTComplex *z);
+	void (*fftCalc)(struct FFTContext *s, FFTComplex *z);
+	void (*imdctCalc)(struct FFTContext *s, float *output, const float *input);
+	void (*imdctHalf)(struct FFTContext *s, float *output, const float *input);
+	void (*mdctCalc)(struct FFTContext *s, float *output, const float *input);
+	int splitRadix;
+	int permutation;
+};
+
+enum {
+	FF_MDCT_PERM_NONE = 0,
+	FF_MDCT_PERM_INTERLEAVE = 1
+};
+
+struct RDFTContext {
+	int nbits;
+	int inverse;
+	int signConvention;
+
+	// pre/post rotation tables
+	float *tcos;
+	float *tsin;
+	FFTContext fft;
+};
+
+class QDM2Stream : public Audio::AudioStream {
+public:
+	QDM2Stream(Common::SeekableReadStream *stream, Common::SeekableReadStream *extraData);
+	~QDM2Stream();
+
+	bool isStereo() const { return _channels == 2; }
+	bool endOfData() const { return ((_stream->pos() == _stream->size()) && (_outputSamples.size() == 0)); }
+	int getRate() const { return _sampleRate; }
+	int readBuffer(int16 *buffer, const int numSamples);
+
+private:
+	Common::SeekableReadStream *_stream;
+
+	// Parameters from codec header, do not change during playback
+	uint8 _channels;
+	uint16 _sampleRate;
+	uint16 _bitRate;
+	uint16 _blockSize;  // Group
+	uint16 _frameSize;  // FFT
+	uint16 _packetSize; // Checksum
+
+	// Parameters built from header parameters, do not change during playback
+	int _groupOrder;       // order of frame group
+	int _fftOrder;         // order of FFT (actually fft order+1)
+	int _fftFrameSize;     // size of fft frame, in components (1 comples = re + im)
+	int _sFrameSize;        // size of data frame
+	int _frequencyRange;
+	int _subSampling;      // subsampling: 0=25%, 1=50%, 2=100% */
+	int _coeffPerSbSelect; // selector for "num. of coeffs. per subband" tables. Can be 0, 1, 2
+	int _cmTableSelect;    // selector for "coding method" tables. Can be 0, 1 (from init: 0-4)
+
+	// Packets and packet lists
+	QDM2SubPacket _subPackets[16];    // the packets themselves
+	QDM2SubPNode _subPacketListA[16]; // list of all packets
+	QDM2SubPNode _subPacketListB[16]; // FFT packets B are on list
+	int _subPacketsB;                 // number of packets on 'B' list
+	QDM2SubPNode _subPacketListC[16]; // packets with errors?
+	QDM2SubPNode _subPacketListD[16]; // DCT packets
+
+	// FFT and tones
+	FFTTone _fftTones[1000];
+	int _fftToneStart;
+	int _fftToneEnd;
+	FFTCoefficient _fftCoefs[1000];
+	int _fftCoefsIndex;
+	int _fftCoefsMinIndex[5];
+	int _fftCoefsMaxIndex[5];
+	int _fftLevelExp[6];
+	//RDFTContext _rdftCtx;
+	QDM2FFT _fft;
+
+	// I/O data
+	uint8 *_compressedData;
+	float _outputBuffer[1024];
+	Common::Array<int16> _outputSamples;
+
+	// Synthesis filter
+	int16 ff_mpa_synth_window[512];
+	int16 _synthBuf[MPA_MAX_CHANNELS][512*2];
+	int _synthBufOffset[MPA_MAX_CHANNELS];
+	int32 _sbSamples[MPA_MAX_CHANNELS][128][32];
+
+	// Mixed temporary data used in decoding
+	float _toneLevel[MPA_MAX_CHANNELS][30][64];
+	int8 _codingMethod[MPA_MAX_CHANNELS][30][64];
+	int8 _quantizedCoeffs[MPA_MAX_CHANNELS][10][8];
+	int8 _toneLevelIdxBase[MPA_MAX_CHANNELS][30][8];
+	int8 _toneLevelIdxHi1[MPA_MAX_CHANNELS][3][8][8];
+	int8 _toneLevelIdxMid[MPA_MAX_CHANNELS][26][8];
+	int8 _toneLevelIdxHi2[MPA_MAX_CHANNELS][26];
+	int8 _toneLevelIdx[MPA_MAX_CHANNELS][30][64];
+	int8 _toneLevelIdxTemp[MPA_MAX_CHANNELS][30][64];
+
+	// Flags
+	bool _hasErrors;         // packet has errors
+	int _superblocktype_2_3; // select fft tables and some algorithm based on superblock type
+	int _doSynthFilter;      // used to perform or skip synthesis filter
+
+	uint8 _subPacket; // 0 to 15
+	int _noiseIdx; // index for dithering noise table
+	
+	byte _emptyBuffer[FF_INPUT_BUFFER_PADDING_SIZE];
+
+	VLC _vlcTabLevel;
+	VLC _vlcTabDiff;
+	VLC _vlcTabRun;
+	VLC _fftLevelExpAltVlc;
+	VLC _fftLevelExpVlc;
+	VLC _fftStereoExpVlc;
+	VLC _fftStereoPhaseVlc;
+	VLC _vlcTabToneLevelIdxHi1;
+	VLC _vlcTabToneLevelIdxMid;
+	VLC _vlcTabToneLevelIdxHi2;
+	VLC _vlcTabType30;
+	VLC _vlcTabType34;
+	VLC _vlcTabFftToneOffset[5];
+	bool _vlcsInitialized;
+	void initVlc(void);
+
+	uint16 _softclipTable[HARDCLIP_THRESHOLD - SOFTCLIP_THRESHOLD + 1];
+	void softclipTableInit(void);
+
+	float _noiseTable[4096];
+	byte _randomDequantIndex[256][5];
+	byte _randomDequantType24[128][3];
+	void rndTableInit(void);
+
+	float _noiseSamples[128];
+	void initNoiseSamples(void);
+	
+	RDFTContext _rdftCtx;
+
+	void average_quantized_coeffs(void);
+	void build_sb_samples_from_noise(int sb);
+	void fix_coding_method_array(int sb, int channels, sb_int8_array coding_method);
+	void fill_tone_level_array(int flag);
+	void fill_coding_method_array(sb_int8_array tone_level_idx, sb_int8_array tone_level_idx_temp,
+	                              sb_int8_array coding_method, int nb_channels,
+	                              int c, int superblocktype_2_3, int cm_table_select);
+	void synthfilt_build_sb_samples(GetBitContext *gb, int length, int sb_min, int sb_max);
+	void init_quantized_coeffs_elem0(int8 *quantized_coeffs, GetBitContext *gb, int length);
+	void init_tone_level_dequantization(GetBitContext *gb, int length);
+	void process_subpacket_9(QDM2SubPNode *node);
+	void process_subpacket_10(QDM2SubPNode *node, int length);
+	void process_subpacket_11(QDM2SubPNode *node, int length);
+	void process_subpacket_12(QDM2SubPNode *node, int length);
+	void process_synthesis_subpackets(QDM2SubPNode *list);
+	void qdm2_decode_super_block(void);
+	void qdm2_fft_init_coefficient(int sub_packet, int offset, int duration, 
+	                               int channel, int exp, int phase);
+	void qdm2_fft_decode_tones(int duration, GetBitContext *gb, int b);
+	void qdm2_decode_fft_packets(void);
+	void qdm2_fft_generate_tone(FFTTone *tone);
+	void qdm2_fft_tone_synthesizer(uint8 sub_packet);
+	void qdm2_calculate_fft(int channel);
+	void qdm2_synthesis_filter(uint8 index);
+	int qdm2_decodeFrame(Common::SeekableReadStream *in);
+};
+
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/video/qdm2data.h b/engines/mohawk/video/qdm2data.h
new file mode 100644
index 0000000000..13fc13f3c1
--- /dev/null
+++ b/engines/mohawk/video/qdm2data.h
@@ -0,0 +1,531 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#ifndef MOHAWK_VIDEO_QDM2DATA_H
+#define MOHAWK_VIDEO_QDM2DATA_H
+
+#include "common/scummsys.h"
+
+namespace Mohawk {
+
+/// VLC TABLES
+
+// values in this table range from -1..23; adjust retrieved value by -1
+static const uint16 vlc_tab_level_huffcodes[24] = {
+    0x037c, 0x0004, 0x003c, 0x004c, 0x003a, 0x002c, 0x001c, 0x001a,
+    0x0024, 0x0014, 0x0001, 0x0002, 0x0000, 0x0003, 0x0007, 0x0005,
+    0x0006, 0x0008, 0x0009, 0x000a, 0x000c, 0x00fc, 0x007c, 0x017c
+};
+
+static const byte vlc_tab_level_huffbits[24] = {
+    10, 6, 7, 7, 6, 6, 6, 6, 6, 5, 4, 4, 4, 3, 3, 3, 3, 4, 4, 5, 7, 8, 9, 10
+};
+
+// values in this table range from -1..36; adjust retrieved value by -1
+static const uint16 vlc_tab_diff_huffcodes[37] = {
+    0x1c57, 0x0004, 0x0000, 0x0001, 0x0003, 0x0002, 0x000f, 0x000e,
+    0x0007, 0x0016, 0x0037, 0x0027, 0x0026, 0x0066, 0x0006, 0x0097,
+    0x0046, 0x01c6, 0x0017, 0x0786, 0x0086, 0x0257, 0x00d7, 0x0357,
+    0x00c6, 0x0386, 0x0186, 0x0000, 0x0157, 0x0c57, 0x0057, 0x0000,
+    0x0b86, 0x0000, 0x1457, 0x0000, 0x0457
+};
+
+static const byte vlc_tab_diff_huffbits[37] = {
+    13, 3, 3, 2, 3, 3, 4, 4, 6, 5, 6, 6, 7, 7, 8, 8,
+    8, 9, 8, 11, 9, 10, 8, 10, 9, 12, 10, 0, 10, 13, 11, 0,
+    12, 0, 13, 0, 13
+};
+
+// values in this table range from -1..5; adjust retrieved value by -1
+static const byte vlc_tab_run_huffcodes[6] = {
+    0x1f, 0x00, 0x01, 0x03, 0x07, 0x0f
+};
+
+static const byte vlc_tab_run_huffbits[6] = {
+    5, 1, 2, 3, 4, 5
+};
+
+// values in this table range from -1..19; adjust retrieved value by -1
+static const uint16 vlc_tab_tone_level_idx_hi1_huffcodes[20] = {
+    0x5714, 0x000c, 0x0002, 0x0001, 0x0000, 0x0004, 0x0034, 0x0054,
+    0x0094, 0x0014, 0x0114, 0x0214, 0x0314, 0x0614, 0x0e14, 0x0f14,
+    0x2714, 0x0714, 0x1714, 0x3714
+};
+
+static const byte vlc_tab_tone_level_idx_hi1_huffbits[20] = {
+    15, 4, 2, 1, 3, 5, 6, 7, 8, 10, 10, 11, 11, 12, 12, 12, 14, 14, 15, 14
+};
+
+// values in this table range from -1..23; adjust retrieved value by -1
+static const uint16 vlc_tab_tone_level_idx_mid_huffcodes[24] = {
+    0x0fea, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x03ea, 0x00ea, 0x002a, 0x001a,
+    0x0006, 0x0001, 0x0000, 0x0002, 0x000a, 0x006a, 0x01ea, 0x07ea
+};
+
+static const byte vlc_tab_tone_level_idx_mid_huffbits[24] = {
+    12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 9, 7, 5, 3, 1, 2, 4, 6, 8, 10, 12
+};
+
+// values in this table range from -1..23; adjust retrieved value by -1
+static const uint16 vlc_tab_tone_level_idx_hi2_huffcodes[24] = {
+    0x0664, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0064, 0x00e4,
+    0x00a4, 0x0068, 0x0004, 0x0008, 0x0014, 0x0018, 0x0000, 0x0001,
+    0x0002, 0x0003, 0x000c, 0x0028, 0x0024, 0x0164, 0x0000, 0x0264
+};
+
+static const byte vlc_tab_tone_level_idx_hi2_huffbits[24] = {
+    11, 0, 0, 0, 0, 0, 10, 8, 8, 7, 6, 6, 5, 5, 4, 2, 2, 2, 4, 7, 8, 9, 0, 11
+};
+
+// values in this table range from -1..8; adjust retrieved value by -1
+static const byte vlc_tab_type30_huffcodes[9] = {
+    0x3c, 0x06, 0x00, 0x01, 0x03, 0x02, 0x04, 0x0c, 0x1c
+};
+
+static const byte vlc_tab_type30_huffbits[9] = {
+    6, 3, 3, 2, 2, 3, 4, 5, 6
+};
+
+// values in this table range from -1..9; adjust retrieved value by -1
+static const byte vlc_tab_type34_huffcodes[10] = {
+    0x18, 0x00, 0x01, 0x04, 0x05, 0x07, 0x03, 0x02, 0x06, 0x08
+};
+
+static const byte vlc_tab_type34_huffbits[10] = {
+    5, 4, 3, 3, 3, 3, 3, 3, 3, 5
+};
+
+// values in this table range from -1..22; adjust retrieved value by -1
+static const uint16 vlc_tab_fft_tone_offset_0_huffcodes[23] = {
+    0x038e, 0x0001, 0x0000, 0x0022, 0x000a, 0x0006, 0x0012, 0x0002,
+    0x001e, 0x003e, 0x0056, 0x0016, 0x000e, 0x0032, 0x0072, 0x0042,
+    0x008e, 0x004e, 0x00f2, 0x002e, 0x0036, 0x00c2, 0x018e
+};
+
+static const byte vlc_tab_fft_tone_offset_0_huffbits[23] = {
+    10, 1, 2, 6, 4, 5, 6, 7, 6, 6, 7, 7, 8, 7, 8, 8, 9, 7, 8, 6, 6, 8, 10
+};
+
+// values in this table range from -1..27; adjust retrieved value by -1
+static const uint16 vlc_tab_fft_tone_offset_1_huffcodes[28] = {
+    0x07a4, 0x0001, 0x0020, 0x0012, 0x001c, 0x0008, 0x0006, 0x0010,
+    0x0000, 0x0014, 0x0004, 0x0032, 0x0070, 0x000c, 0x0002, 0x003a,
+    0x001a, 0x002c, 0x002a, 0x0022, 0x0024, 0x000a, 0x0064, 0x0030,
+    0x0062, 0x00a4, 0x01a4, 0x03a4
+};
+
+static const byte vlc_tab_fft_tone_offset_1_huffbits[28] = {
+    11, 1, 6, 6, 5, 4, 3, 6, 6, 5, 6, 6, 7, 6, 6, 6,
+    6, 6, 6, 7, 8, 6, 7, 7, 7, 9, 10, 11
+};
+
+// values in this table range from -1..31; adjust retrieved value by -1
+static const uint16 vlc_tab_fft_tone_offset_2_huffcodes[32] = {
+    0x1760, 0x0001, 0x0000, 0x0082, 0x000c, 0x0006, 0x0003, 0x0007,
+    0x0008, 0x0004, 0x0010, 0x0012, 0x0022, 0x001a, 0x0000, 0x0020,
+    0x000a, 0x0040, 0x004a, 0x006a, 0x002a, 0x0042, 0x0002, 0x0060,
+    0x00aa, 0x00e0, 0x00c2, 0x01c2, 0x0160, 0x0360, 0x0760, 0x0f60
+};
+
+static const byte vlc_tab_fft_tone_offset_2_huffbits[32] = {
+    13, 2, 0, 8, 4, 3, 3, 3, 4, 4, 5, 5, 6, 5, 7, 7,
+    7, 7, 7, 7, 8, 8, 8, 9, 8, 8, 9, 9, 10, 11, 13, 12
+};
+
+// values in this table range from -1..34; adjust retrieved value by -1
+static const uint16 vlc_tab_fft_tone_offset_3_huffcodes[35] = {
+    0x33ea, 0x0005, 0x0000, 0x000c, 0x0000, 0x0006, 0x0003, 0x0008,
+    0x0002, 0x0001, 0x0004, 0x0007, 0x001a, 0x000f, 0x001c, 0x002c,
+    0x000a, 0x001d, 0x002d, 0x002a, 0x000d, 0x004c, 0x008c, 0x006a,
+    0x00cd, 0x004d, 0x00ea, 0x020c, 0x030c, 0x010c, 0x01ea, 0x07ea,
+    0x0bea, 0x03ea, 0x13ea
+};
+
+static const byte vlc_tab_fft_tone_offset_3_huffbits[35] = {
+    14, 4, 0, 10, 4, 3, 3, 4, 4, 3, 4, 4, 5, 4, 5, 6,
+    6, 5, 6, 7, 7, 7, 8, 8, 8, 8, 9, 10, 10, 10, 10, 11,
+    12, 13, 14
+};
+
+// values in this table range from -1..37; adjust retrieved value by -1
+static const uint16 vlc_tab_fft_tone_offset_4_huffcodes[38] = {
+    0x5282, 0x0016, 0x0000, 0x0136, 0x0004, 0x0000, 0x0007, 0x000a,
+    0x000e, 0x0003, 0x0001, 0x000d, 0x0006, 0x0009, 0x0012, 0x0005,
+    0x0025, 0x0022, 0x0015, 0x0002, 0x0076, 0x0035, 0x0042, 0x00c2,
+    0x0182, 0x00b6, 0x0036, 0x03c2, 0x0482, 0x01c2, 0x0682, 0x0882,
+    0x0a82, 0x0082, 0x0282, 0x1282, 0x3282, 0x2282
+};
+
+static const byte vlc_tab_fft_tone_offset_4_huffbits[38] = {
+    15, 6, 0, 9, 3, 3, 3, 4, 4, 3, 4, 4, 5, 4, 5, 6,
+    6, 6, 6, 8, 7, 6, 8, 9, 9, 8, 9, 10, 11, 10, 11, 12,
+    12, 12, 14, 15, 14, 14
+};
+
+/// FFT TABLES
+
+// values in this table range from -1..27; adjust retrieved value by -1
+static const uint16 fft_level_exp_alt_huffcodes[28] = {
+    0x1ec6, 0x0006, 0x00c2, 0x0142, 0x0242, 0x0246, 0x00c6, 0x0046,
+    0x0042, 0x0146, 0x00a2, 0x0062, 0x0026, 0x0016, 0x000e, 0x0005,
+    0x0004, 0x0003, 0x0000, 0x0001, 0x000a, 0x0012, 0x0002, 0x0022,
+    0x01c6, 0x02c6, 0x06c6, 0x0ec6
+};
+
+static const byte fft_level_exp_alt_huffbits[28] = {
+    13, 7, 8, 9, 10, 10, 10, 10, 10, 9, 8, 7, 6, 5, 4, 3,
+    3, 2, 3, 3, 4, 5, 7, 8, 9, 11, 12, 13
+};
+
+// values in this table range from -1..19; adjust retrieved value by -1
+static const uint16 fft_level_exp_huffcodes[20] = {
+    0x0f24, 0x0001, 0x0002, 0x0000, 0x0006, 0x0005, 0x0007, 0x000c,
+    0x000b, 0x0014, 0x0013, 0x0004, 0x0003, 0x0023, 0x0064, 0x00a4,
+    0x0024, 0x0124, 0x0324, 0x0724
+};
+
+static const byte fft_level_exp_huffbits[20] = {
+    12, 3, 3, 3, 3, 3, 3, 4, 4, 5, 5, 6, 6, 6, 7, 8, 9, 10, 11, 12
+};
+
+// values in this table range from -1..6; adjust retrieved value by -1
+static const byte fft_stereo_exp_huffcodes[7] = {
+    0x3e, 0x01, 0x00, 0x02, 0x06, 0x0e, 0x1e
+};
+
+static const byte fft_stereo_exp_huffbits[7] = {
+    6, 1, 2, 3, 4, 5, 6
+};
+
+// values in this table range from -1..8; adjust retrieved value by -1
+static const byte fft_stereo_phase_huffcodes[9] = {
+    0x35, 0x02, 0x00, 0x01, 0x0d, 0x15, 0x05, 0x09, 0x03
+};
+
+static const byte fft_stereo_phase_huffbits[9] = {
+    6, 2, 2, 4, 4, 6, 5, 4, 2
+};
+
+static const int fft_cutoff_index_table[4][2] = {
+    { 1, 2 }, {-1, 0 }, {-1,-2 }, { 0, 0 }
+};
+
+static const int16 fft_level_index_table[256] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
+    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const byte last_coeff[3] = {
+    4, 7, 10
+};
+
+static const byte coeff_per_sb_for_avg[3][30] = {
+    { 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 },
+    { 0, 1, 2, 2, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6 },
+    { 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9 }
+};
+
+static const uint32 dequant_table[3][10][30] = {
+    { { 256, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 256, 256, 205, 154, 102, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 0, 51, 102, 154, 205, 256, 238, 219, 201, 183, 165, 146, 128, 110, 91, 73, 55, 37, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 0, 0, 0, 0, 0, 0, 18, 37, 55, 73, 91, 110, 128, 146, 165, 183, 201, 219, 238, 256, 228, 199, 171, 142, 114, 85, 57, 28 },
+      { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { 256, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 256, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 256, 171, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 0, 85, 171, 256, 171, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 0, 0, 0, 0, 85, 171, 256, 219, 183, 146, 110, 73, 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 0, 0, 0, 0, 0, 0, 0, 37, 73, 110, 146, 183, 219, 256, 228, 199, 171, 142, 114, 85, 57, 28, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 57, 85, 114, 142, 171, 199, 228, 256, 213, 171, 128, 85, 43 },
+      { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { 256, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 256, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 256, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 0, 256, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 0, 0, 256, 256, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 0, 0, 0, 0, 256, 171, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 0, 0, 0, 0, 0, 85, 171, 256, 192, 128, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 128, 192, 256, 205, 154, 102, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 51, 102, 154, 205, 256, 213, 171, 128, 85, 43, 0, 0, 0, 0, 0, 0 },
+      { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 43, 85, 128, 171, 213, 256, 213, 171, 128, 85, 43 } }
+};
+
+static const byte coeff_per_sb_for_dequant[3][30] = {
+    { 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3 },
+    { 0, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6 },
+    { 0, 1, 2, 3, 4, 4, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9 }
+};
+
+// first index is subband, 2nd index is 0, 1 or 3 (2 is unused)
+static const int8 tone_level_idx_offset_table[30][4] = {
+    { -50, -50,  0, -50 },
+    { -50, -50,  0, -50 },
+    { -50,  -9,  0, -19 },
+    { -16,  -6,  0, -12 },
+    { -11,  -4,  0,  -8 },
+    {  -8,  -3,  0,  -6 },
+    {  -7,  -3,  0,  -5 },
+    {  -6,  -2,  0,  -4 },
+    {  -5,  -2,  0,  -3 },
+    {  -4,  -1,  0,  -3 },
+    {  -4,  -1,  0,  -2 },
+    {  -3,  -1,  0,  -2 },
+    {  -3,  -1,  0,  -2 },
+    {  -3,  -1,  0,  -2 },
+    {  -2,  -1,  0,  -1 },
+    {  -2,  -1,  0,  -1 },
+    {  -2,  -1,  0,  -1 },
+    {  -2,   0,  0,  -1 },
+    {  -2,   0,  0,  -1 },
+    {  -1,   0,  0,  -1 },
+    {  -1,   0,  0,  -1 },
+    {  -1,   0,  0,  -1 },
+    {  -1,   0,  0,  -1 },
+    {  -1,   0,  0,  -1 },
+    {  -1,   0,  0,  -1 },
+    {  -1,   0,  0,  -1 },
+    {  -1,   0,  0,   0 },
+    {  -1,   0,  0,   0 },
+    {  -1,   0,  0,   0 },
+    {  -1,   0,  0,   0 }
+};
+
+/* all my samples have 1st index 0 or 1 */
+/* second index is subband, only indexes 0-29 seem to be used */
+static const int8 coding_method_table[5][30] = {
+    { 34, 30, 24, 24, 16, 16, 16, 16, 10, 10, 10, 10, 10, 10, 10,
+      10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10
+    },
+    { 34, 30, 24, 24, 16, 16, 16, 16, 10, 10, 10, 10, 10, 10, 10,
+      10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10
+    },
+    { 34, 30, 30, 30, 24, 24, 16, 16, 16, 16, 16, 16, 10, 10, 10,
+      10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10
+    },
+    { 34, 34, 30, 30, 24, 24, 24, 24, 16, 16, 16, 16, 16, 16, 16,
+      16, 16, 16, 16, 16, 16, 16, 10, 10, 10, 10, 10, 10, 10, 10
+    },
+    { 34, 34, 30, 30, 30, 30, 30, 30, 24, 24, 24, 24, 24, 24, 24,
+      24, 24, 24, 24, 24, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16
+    },
+};
+
+static const int vlc_stage3_values[60] = {
+        0,     1,     2,     3,     4,     6,     8,    10,    12,    16,    20,    24,
+       28,    36,    44,    52,    60,    76,    92,   108,   124,   156,   188,   220,
+      252,   316,   380,   444,   508,   636,   764,   892,  1020,  1276,  1532,  1788,
+     2044,  2556,  3068,  3580,  4092,  5116,  6140,  7164,  8188, 10236, 12284, 14332,
+    16380, 20476, 24572, 28668, 32764, 40956, 49148, 57340, 65532, 81916, 98300,114684
+};
+
+static const float fft_tone_sample_table[4][16][5] = {
+    { { .0100000000f,-.0037037037f,-.0020000000f,-.0069444444f,-.0018416207f },
+      { .0416666667f, .0000000000f, .0000000000f,-.0208333333f,-.0123456791f },
+      { .1250000000f, .0558035709f, .0330687836f,-.0164473690f,-.0097465888f },
+      { .1562500000f, .0625000000f, .0370370370f,-.0062500000f,-.0037037037f },
+      { .1996007860f, .0781250000f, .0462962948f, .0022727272f, .0013468013f },
+      { .2000000000f, .0625000000f, .0370370373f, .0208333333f, .0074074073f },
+      { .2127659619f, .0555555556f, .0329218097f, .0208333333f, .0123456791f },
+      { .2173913121f, .0473484844f, .0280583613f, .0347222239f, .0205761325f },
+      { .2173913121f, .0347222239f, .0205761325f, .0473484844f, .0280583613f },
+      { .2127659619f, .0208333333f, .0123456791f, .0555555556f, .0329218097f },
+      { .2000000000f, .0208333333f, .0074074073f, .0625000000f, .0370370370f },
+      { .1996007860f, .0022727272f, .0013468013f, .0781250000f, .0462962948f },
+      { .1562500000f,-.0062500000f,-.0037037037f, .0625000000f, .0370370370f },
+      { .1250000000f,-.0164473690f,-.0097465888f, .0558035709f, .0330687836f },
+      { .0416666667f,-.0208333333f,-.0123456791f, .0000000000f, .0000000000f },
+      { .0100000000f,-.0069444444f,-.0018416207f,-.0037037037f,-.0020000000f } },
+
+    { { .0050000000f,-.0200000000f, .0125000000f,-.3030303030f, .0020000000f },
+      { .1041666642f, .0400000000f,-.0250000000f, .0333333333f,-.0200000000f },
+      { .1250000000f, .0100000000f, .0142857144f,-.0500000007f,-.0200000000f },
+      { .1562500000f,-.0006250000f,-.00049382716f,-.000625000f,-.00049382716f },
+      { .1562500000f,-.0006250000f,-.00049382716f,-.000625000f,-.00049382716f },
+      { .1250000000f,-.0500000000f,-.0200000000f, .0100000000f, .0142857144f },
+      { .1041666667f, .0333333333f,-.0200000000f, .0400000000f,-.0250000000f },
+      { .0050000000f,-.3030303030f, .0020000001f,-.0200000000f, .0125000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f } },
+
+    { { .1428571492f, .1250000000f,-.0285714287f,-.0357142873f, .0208333333f },
+      { .1818181818f, .0588235296f, .0333333333f, .0212765951f, .0100000000f },
+      { .1818181818f, .0212765951f, .0100000000f, .0588235296f, .0333333333f },
+      { .1428571492f,-.0357142873f, .0208333333f, .1250000000f,-.0285714287f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f } },
+
+    { { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f },
+      { .0000000000f, .0000000000f, .0000000000f, .0000000000f, .0000000000f } }
+};
+
+static const float fft_tone_level_table[2][64] = { {
+// pow ~ (i > 46) ? 0 : (((((i & 1) ? 431 : 304) << (i >> 1))) / 1024.0);
+    0.17677669f, 0.42677650f, 0.60355347f, 0.85355347f,
+    1.20710683f, 1.68359375f, 2.37500000f, 3.36718750f,
+    4.75000000f, 6.73437500f, 9.50000000f, 13.4687500f,
+    19.0000000f, 26.9375000f, 38.0000000f, 53.8750000f,
+    76.0000000f, 107.750000f, 152.000000f, 215.500000f,
+    304.000000f, 431.000000f, 608.000000f, 862.000000f,
+    1216.00000f, 1724.00000f, 2432.00000f, 3448.00000f,
+    4864.00000f, 6896.00000f, 9728.00000f, 13792.0000f,
+    19456.0000f, 27584.0000f, 38912.0000f, 55168.0000f,
+    77824.0000f, 110336.000f, 155648.000f, 220672.000f,
+    311296.000f, 441344.000f, 622592.000f, 882688.000f,
+    1245184.00f, 1765376.00f, 2490368.00f, 0.00000000f,
+    0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f,
+    0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f,
+    0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f,
+    0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f,
+  }, {
+// pow = (i > 45) ? 0 : ((((i & 1) ? 431 : 304) << (i >> 1)) / 512.0);
+    0.59375000f, 0.84179688f, 1.18750000f, 1.68359375f,
+    2.37500000f, 3.36718750f, 4.75000000f, 6.73437500f,
+    9.50000000f, 13.4687500f, 19.0000000f, 26.9375000f,
+    38.0000000f, 53.8750000f, 76.0000000f, 107.750000f,
+    152.000000f, 215.500000f, 304.000000f, 431.000000f,
+    608.000000f, 862.000000f, 1216.00000f, 1724.00000f,
+    2432.00000f, 3448.00000f, 4864.00000f, 6896.00000f,
+    9728.00000f, 13792.0000f, 19456.0000f, 27584.0000f,
+    38912.0000f, 55168.0000f, 77824.0000f, 110336.000f,
+    155648.000f, 220672.000f, 311296.000f, 441344.000f,
+    622592.000f, 882688.000f, 1245184.00f, 1765376.00f,
+    2490368.00f, 3530752.00f, 0.00000000f, 0.00000000f,
+    0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f,
+    0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f,
+    0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f,
+    0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f
+} };
+
+static const float fft_tone_envelope_table[4][31] = {
+    { .009607375f, .038060248f, .084265202f, .146446645f, .222214907f, .308658302f,
+      .402454883f, .500000060f, .597545207f, .691341758f, .777785182f, .853553414f,
+      .915734828f, .961939812f, .990392685f, 1.00000000f, .990392625f, .961939752f,
+      .915734768f, .853553295f, .777785063f, .691341639f, .597545087f, .500000000f,
+      .402454853f, .308658272f, .222214878f, .146446615f, .084265172f, .038060218f,
+      .009607345f },
+    { .038060248f, .146446645f, .308658302f, .500000060f, .691341758f, .853553414f,
+      .961939812f, 1.00000000f, .961939752f, .853553295f, .691341639f, .500000000f,
+      .308658272f, .146446615f, .038060218f, .000000000f, .000000000f, .000000000f,
+      .000000000f, .000000000f, .000000000f, .000000000f, .000000000f, .000000000f,
+      .000000000f, .000000000f, .000000000f, .000000000f, .000000000f, .000000000f,
+      .000000000f },
+    { .146446645f, .500000060f, .853553414f, 1.00000000f, .853553295f, .500000000f,
+      .146446615f, .000000000f, .000000000f, .000000000f, .000000000f, .000000000f,
+      .000000000f, .000000000f, .000000000f, .000000000f, .000000000f, .000000000f,
+      .000000000f, .000000000f, .000000000f, .000000000f, .000000000f, .000000000f,
+      .000000000f, .000000000f, .000000000f, .000000000f, .000000000f, .000000000f,
+      .000000000f },
+    { .500000060f, 1.00000000f, .500000000f, .000000000f, .000000000f, .000000000f,
+      .000000000f, .000000000f, .000000000f, .000000000f, .000000000f, .000000000f,
+      .000000000f, .000000000f, .000000000f, .000000000f, .000000000f, .000000000f,
+      .000000000f, .000000000f, .000000000f, .000000000f, .000000000f, .000000000f,
+      .000000000f, .000000000f, .000000000f, .000000000f, .000000000f, .000000000f,
+      .000000000f }
+};
+
+static const float sb_noise_attenuation[32] = {
+    0.0f, 0.0f, 0.3f, 0.4f, 0.5f, 0.7f, 1.0f, 1.0f,
+    1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
+    1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
+    1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
+};
+
+static const byte fft_subpackets[32] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0
+};
+
+// first index is joined_stereo, second index is 0 or 2 (1 is unused)
+static const float dequant_1bit[2][3] = {
+    {-0.920000f, 0.000000f, 0.920000f },
+    {-0.890000f, 0.000000f, 0.890000f }
+};
+
+static const float type30_dequant[8] = {
+   -1.0f,-0.625f,-0.291666656732559f,0.0f,
+   0.25f,0.5f,0.75f,1.0f,
+};
+
+static const float type34_delta[10] = { // FIXME: covers 8 entries..
+    -1.0f,-0.60947573184967f,-0.333333343267441f,-0.138071194291115f,0.0f,
+    0.138071194291115f,0.333333343267441f,0.60947573184967f,1.0f,0.0f,
+};
+
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/video/qt_player.cpp b/engines/mohawk/video/qt_player.cpp
new file mode 100644
index 0000000000..9df5a3c930
--- /dev/null
+++ b/engines/mohawk/video/qt_player.cpp
@@ -0,0 +1,1097 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+//
+// Heavily based on ffmpeg code.
+//
+// Copyright (c) 2001 Fabrice Bellard.
+// First version by Francois Revol revol@free.fr
+// Seek function by Gael Chardon gael.dev@4now.net
+//
+
+#include "mohawk/video/qt_player.h"
+
+#include "common/endian.h"
+#include "common/util.h"
+#include "common/zlib.h"
+
+// Audio codecs
+#include "sound/adpcm.h"
+#include "mohawk/video/qdm2.h"
+
+namespace Mohawk {
+
+QTPlayer::QTPlayer() : Video() {
+	_audStream = NULL;
+}
+
+QTPlayer::~QTPlayer() {
+	closeFile();
+}
+
+uint16 QTPlayer::getWidth() {
+	if (_videoStreamIndex < 0)
+		return 0;
+	
+	return _streams[_videoStreamIndex]->width;
+}
+
+uint16 QTPlayer::getHeight() {
+	if (_videoStreamIndex < 0)
+		return 0;
+	
+	return _streams[_videoStreamIndex]->height;
+}
+
+uint32 QTPlayer::getFrameCount() {
+	if (_videoStreamIndex < 0)
+		return 0;
+	
+	return _streams[_videoStreamIndex]->nb_frames;
+}
+
+byte QTPlayer::getBitsPerPixel() {
+	if (_videoStreamIndex < 0)
+		return 0;
+	
+	return _streams[_videoStreamIndex]->bits_per_sample & 0x1F;
+}
+
+uint32 QTPlayer::getCodecTag() {
+	if (_videoStreamIndex < 0)
+		return 0;
+	
+	return _streams[_videoStreamIndex]->codec_tag;
+}
+
+ScaleMode QTPlayer::getScaleMode() {
+	if (_videoStreamIndex < 0)
+		return kScaleNormal;
+
+	return (ScaleMode)(_scaleMode * _streams[_videoStreamIndex]->scaleMode);
+}
+
+uint32 QTPlayer::getFrameDuration(uint32 frame) {
+	if (_videoStreamIndex < 0)
+		return 0;
+	
+	uint32 curFrameIndex = 0;
+	for (int32 i = 0; i < _streams[_videoStreamIndex]->stts_count; i++) {
+		curFrameIndex += _streams[_videoStreamIndex]->stts_data[i].count;
+		if (frame < curFrameIndex) {
+			// Ok, now we have what duration this frame has. Now, we have to convert the duration to 1/100 ms.
+			return _streams[_videoStreamIndex]->stts_data[i].duration * 1000 * 100 / _streams[_videoStreamIndex]->time_scale;
+		}
+	}
+	
+	// This should never occur
+	error ("Cannot find duration for frame %d", frame);
+	return 0;
+}
+
+bool QTPlayer::loadFile(Common::SeekableReadStream *stream) {
+	_fd = stream;
+	_foundMOOV = _foundMDAT = false;
+	_numStreams = 0;
+	_partial = 0;
+	_videoStreamIndex = _audioStreamIndex = -1;
+
+	initParseTable();
+
+	MOVatom atom = { 0, 0, 0xffffffff };
+
+	if (readDefault(atom) < 0 || (!_foundMOOV && !_foundMDAT)) 
+		return false;
+
+	debug(0, "on_parse_exit_offset=%d", _fd->pos());
+
+	// some cleanup : make sure we are on the mdat atom
+	if((uint32)_fd->pos() != _mdatOffset)
+		_fd->seek(_mdatOffset, SEEK_SET);
+
+	_next_chunk_offset = _mdatOffset; // initialise reading
+
+	for (uint32 i = 0; i < _numStreams;) {
+		if (_streams[i]->codec_type == CODEC_TYPE_MOV_OTHER) {// not audio, not video, delete
+			delete _streams[i];
+			for (uint32 j = i + 1; j < _numStreams; j++)
+				_streams[j - 1] = _streams[j];
+			_numStreams--;
+		} else
+			i++;
+	}
+
+	for (uint32 i = 0; i < _numStreams; i++) {
+		MOVStreamContext *sc = _streams[i];
+
+		if(!sc->time_rate)
+			sc->time_rate = 1;
+
+		if(!sc->time_scale)
+			sc->time_scale = _timeScale;
+
+		//av_set_pts_info(s->streams[i], 64, sc->time_rate, sc->time_scale);
+
+		sc->duration /= sc->time_rate;
+
+		sc->ffindex = i;
+		sc->is_ff_stream = 1;
+		
+		if (sc->codec_type == CODEC_TYPE_VIDEO && _videoStreamIndex < 0)
+			_videoStreamIndex = i;
+		else if (sc->codec_type == CODEC_TYPE_AUDIO && _audioStreamIndex < 0)
+			_audioStreamIndex = i;
+	}
+	
+	if (_audioStreamIndex >= 0 && checkAudioCodecSupport(_streams[_audioStreamIndex]->codec_tag)) {
+		_audStream = new QueuedAudioStream(_streams[_audioStreamIndex]->sample_rate, _streams[_audioStreamIndex]->channels);
+		_curAudioChunk = 0;
+	
+		// Make sure the bits per sample transfers to the sample size
+		if (_streams[_audioStreamIndex]->codec_tag == MKID_BE('raw ') || _streams[_audioStreamIndex]->codec_tag == MKID_BE('twos'))
+			_streams[_audioStreamIndex]->sample_size = (_streams[_audioStreamIndex]->bits_per_sample / 8) * _streams[_audioStreamIndex]->channels;
+	}
+	
+	return true;
+}
+
+void QTPlayer::initParseTable() {
+	static const ParseTable p[] = {
+		{ MKID_BE('dinf'), &QTPlayer::readDefault },
+		{ MKID_BE('dref'), &QTPlayer::readLeaf },
+		{ MKID_BE('edts'), &QTPlayer::readDefault },
+		{ MKID_BE('elst'), &QTPlayer::readELST },
+		{ MKID_BE('hdlr'), &QTPlayer::readHDLR },
+		{ MKID_BE('mdat'), &QTPlayer::readMDAT },
+		{ MKID_BE('mdhd'), &QTPlayer::readMDHD },
+		{ MKID_BE('mdia'), &QTPlayer::readDefault },
+		{ MKID_BE('minf'), &QTPlayer::readDefault },
+		{ MKID_BE('moov'), &QTPlayer::readMOOV },
+		{ MKID_BE('mvhd'), &QTPlayer::readMVHD },
+		{ MKID_BE('smhd'), &QTPlayer::readLeaf },
+		{ MKID_BE('stbl'), &QTPlayer::readDefault },
+		{ MKID_BE('stco'), &QTPlayer::readSTCO },
+		{ MKID_BE('stsc'), &QTPlayer::readSTSC },
+		{ MKID_BE('stsd'), &QTPlayer::readSTSD },
+		{ MKID_BE('stss'), &QTPlayer::readSTSS },
+		{ MKID_BE('stsz'), &QTPlayer::readSTSZ },
+		{ MKID_BE('stts'), &QTPlayer::readSTTS },
+		{ MKID_BE('tkhd'), &QTPlayer::readTKHD },
+		{ MKID_BE('trak'), &QTPlayer::readTRAK },
+		{ MKID_BE('udta'), &QTPlayer::readLeaf },
+		{ MKID_BE('vmhd'), &QTPlayer::readLeaf },
+		{ MKID_BE('cmov'), &QTPlayer::readCMOV },
+		{ MKID_BE('wave'), &QTPlayer::readWAVE },
+		{ 0, 0 }
+	};
+
+	_parseTable = p;
+}
+
+int QTPlayer::readDefault(MOVatom atom) {
+	uint32 total_size = 0;
+	MOVatom a;
+	int err = 0;
+
+	a.offset = atom.offset;
+
+	while(((total_size + 8) < atom.size) && !_fd->eos() && !err) {
+		a.size = atom.size;
+		a.type = 0;
+		
+		if (atom.size >= 8) {
+			a.size = _fd->readUint32BE();
+			a.type = _fd->readUint32BE();
+		}
+		
+		total_size += 8;
+		a.offset += 8;
+		debug(4, "type: %08x  %.4s  sz: %x %x %x", a.type, tag2str(a.type), a.size, atom.size, total_size);
+		
+		if (a.size == 1) { // 64 bit extended size
+			warning("64 bit extended size is not supported in QuickTime");
+			return -1;
+		}
+		
+		if (a.size == 0) {
+			a.size = atom.size - total_size;
+			if (a.size <= 8)
+				break;
+		}
+		
+		uint32 i = 0;
+		
+		for (; _parseTable[i].type != 0 && _parseTable[i].type != a.type; i++)
+			// empty;
+
+		if (a.size < 8)
+			break;
+
+		a.size -= 8;
+
+		if (_parseTable[i].type == 0) { // skip leaf atoms data
+			debug(0, ">>> Skipped [%s]", tag2str(a.type));
+
+			_fd->seek(a.size, SEEK_CUR);
+		} else {
+			uint32 start_pos = _fd->pos();
+			err = (this->*_parseTable[i].func)(a);
+			
+			uint32 left = a.size - _fd->pos() + start_pos;
+				
+			if (left > 0) // skip garbage at atom end
+				_fd->seek(left, SEEK_CUR);
+		}
+
+		a.offset += a.size;
+		total_size += a.size;
+	}
+
+	if (!err && total_size < atom.size)
+		_fd->seek(atom.size - total_size, SEEK_SET);
+
+	return err;
+}
+
+int QTPlayer::readLeaf(MOVatom atom) {
+	if (atom.size > 1)
+		_fd->seek(atom.size, SEEK_SET);
+
+	return 0;
+}
+
+int QTPlayer::readMOOV(MOVatom atom) {
+	if (readDefault(atom) < 0)
+		return -1;
+
+	// we parsed the 'moov' atom, we can terminate the parsing as soon as we find the 'mdat'
+	// so we don't parse the whole file if over a network
+	_foundMOOV = true;
+
+	if(_foundMDAT)
+		return 1; // found both, just go
+
+	return 0; // now go for mdat
+}
+
+int QTPlayer::readCMOV(MOVatom atom) {
+#ifdef USE_ZLIB
+	// Read in the dcom atom
+	_fd->readUint32BE();
+	if (_fd->readUint32BE() != MKID_BE('dcom'))
+		return -1;
+	if (_fd->readUint32BE() != MKID_BE('zlib')) {
+		warning("Unknown cmov compression type");
+		return -1;
+	}
+	
+	// Read in the cmvd atom
+	uint32 compressedSize = _fd->readUint32BE() - 12;
+	if (_fd->readUint32BE() != MKID_BE('cmvd'))
+		return -1;
+	uint32 uncompressedSize = _fd->readUint32BE();
+	
+	// Read in data
+	byte *compressedData = (byte *)malloc(compressedSize);
+	_fd->read(compressedData, compressedSize);
+	
+	// Create uncompressed stream
+	byte *uncompressedData = (byte *)malloc(uncompressedSize);
+	
+	// Uncompress the data
+	unsigned long dstLen = uncompressedSize;
+	if (!Common::uncompress(uncompressedData, &dstLen, compressedData, compressedSize)) {
+		warning ("Could not uncompress cmov chunk");
+		return -1;
+	}
+	
+	// Load data into a new MemoryReadStream and assign _fd to be that
+	Common::SeekableReadStream *oldStream = _fd;
+	_fd = new Common::MemoryReadStream(uncompressedData, uncompressedSize, Common::DisposeAfterUse::YES);
+	
+	// Read the contents of the uncompressed data
+	MOVatom a = { MKID_BE('moov'), 0, uncompressedSize };
+	int err = readDefault(a);
+	
+	// Assign the file handle back to the original handle
+	free(compressedData);
+	delete _fd;
+	_fd = oldStream;
+	
+	return err;
+#else
+	warning ("zlib not found, cannot read QuickTime cmov atom");
+	return -1;
+#endif
+}
+
+int QTPlayer::readMVHD(MOVatom atom) {
+	byte version = _fd->readByte(); // version
+	_fd->readByte(); _fd->readByte(); _fd->readByte(); // flags
+
+	if (version == 1) {
+		warning("QuickTime version 1");
+		_fd->readUint32BE(); _fd->readUint32BE();
+		_fd->readUint32BE(); _fd->readUint32BE();
+	} else {
+		_fd->readUint32BE(); // creation time
+		_fd->readUint32BE(); // modification time
+	}
+	
+	_timeScale = _fd->readUint32BE(); // time scale
+	debug(0, "time scale = %i\n", _timeScale);
+
+	// duration
+	_duration = (version == 1) ? (_fd->readUint32BE(), _fd->readUint32BE()) : _fd->readUint32BE();
+	_fd->readUint32BE(); // preferred scale
+
+	_fd->readUint16BE(); // preferred volume
+
+	_fd->seek(10, SEEK_CUR); // reserved
+
+	// We only need two values from the movie display matrix. Most of the values are just
+	// skipped. xMod and yMod are 16:16 fixed point numbers, the last part of the 3x3 matrix
+	// is 2:30.
+	uint32 xMod = _fd->readUint32BE();
+	_fd->skip(12);
+	uint32 yMod = _fd->readUint32BE();
+	_fd->skip(16);
+
+	if (xMod != yMod)
+		error("X and Y resolution modifiers differ");
+
+	if (xMod == 0x8000)
+		_scaleMode = kScaleHalf;
+	else if (xMod == 0x4000)
+		_scaleMode = kScaleQuarter;
+	else
+		_scaleMode = kScaleNormal;
+
+	debug(1, "readMVHD(): scaleMode = %d", (int)_scaleMode);
+
+	_fd->readUint32BE(); // preview time
+	_fd->readUint32BE(); // preview duration
+	_fd->readUint32BE(); // poster time
+	_fd->readUint32BE(); // selection time
+	_fd->readUint32BE(); // selection duration
+	_fd->readUint32BE(); // current time
+	_fd->readUint32BE(); // next track ID
+
+	return 0;
+}
+
+int QTPlayer::readTRAK(MOVatom atom) {
+	MOVStreamContext *sc = new MOVStreamContext();
+
+	if (!sc)
+		return -1;
+
+	sc->sample_to_chunk_index = -1;
+	sc->codec_type = CODEC_TYPE_MOV_OTHER;
+	sc->start_time = 0; // XXX: check
+	_streams[_numStreams++] = sc;
+
+	return readDefault(atom);
+}
+
+// this atom contains actual media data
+int QTPlayer::readMDAT(MOVatom atom) {
+	if (atom.size == 0) // wrong one (MP4)
+		return 0;
+
+	_foundMDAT = true;
+
+	_mdatOffset = atom.offset;
+	_mdatSize = atom.size;
+
+	if (_foundMOOV)
+		return 1; // found both, just go
+
+	_fd->seek(atom.size, SEEK_CUR);
+
+	return 0; // now go for moov
+}
+
+int QTPlayer::readTKHD(MOVatom atom) {
+	MOVStreamContext *st = _streams[_numStreams - 1];
+	byte version = _fd->readByte();
+
+	_fd->readByte(); _fd->readByte();
+	_fd->readByte(); // flags
+	//
+	//MOV_TRACK_ENABLED 0x0001
+	//MOV_TRACK_IN_MOVIE 0x0002
+	//MOV_TRACK_IN_PREVIEW 0x0004
+	//MOV_TRACK_IN_POSTER 0x0008
+	//
+
+	if (version == 1) {
+		_fd->readUint32BE(); _fd->readUint32BE();
+		_fd->readUint32BE(); _fd->readUint32BE();
+	} else {
+		_fd->readUint32BE(); // creation time
+		_fd->readUint32BE(); // modification time
+	}
+	
+	/* st->id = */_fd->readUint32BE(); // track id (NOT 0 !)
+	_fd->readUint32BE(); // reserved
+	//st->start_time = 0; // check
+	(version == 1) ? (_fd->readUint32BE(), _fd->readUint32BE()) : _fd->readUint32BE(); // highlevel (considering edits) duration in movie timebase
+	_fd->readUint32BE(); // reserved
+	_fd->readUint32BE(); // reserved
+
+	_fd->readUint16BE(); // layer
+	_fd->readUint16BE(); // alternate group
+	_fd->readUint16BE(); // volume
+	_fd->readUint16BE(); // reserved
+	
+	// We only need the two values from the displacement matrix for a track.
+	// See readMVHD() for more information.
+	uint32 xMod = _fd->readUint32BE();
+	_fd->skip(12);
+	uint32 yMod = _fd->readUint32BE();
+	_fd->skip(16);
+
+	if (xMod != yMod)
+		error("X and Y resolution modifiers differ");
+
+	if (xMod == 0x8000)
+		st->scaleMode = kScaleHalf;
+	else if (xMod == 0x4000)
+		st->scaleMode = kScaleQuarter;
+	else
+		st->scaleMode = kScaleNormal;
+
+	debug(1, "readTKHD(): scaleMode = %d", (int)_scaleMode);
+
+	// these are fixed-point, 16:16
+	// uint32 tkWidth = _fd->readUint32BE() >> 16; // track width
+	// uint32 tkHeight = _fd->readUint32BE() >> 16; // track height
+
+	return 0;
+}
+
+// edit list atom
+int QTPlayer::readELST(MOVatom atom) {
+	_fd->readByte(); // version
+	_fd->readByte(); _fd->readByte(); _fd->readByte(); // flags
+	uint32 editCount = _streams[_numStreams - 1]->edit_count = _fd->readUint32BE();	 // entries
+
+	for (uint32 i = 0; i < editCount; i++){
+		_fd->readUint32BE(); // Track duration
+		_fd->readUint32BE(); // Media time
+		_fd->readUint32BE(); // Media rate
+	}
+	
+	debug(0, "track[%i].edit_count = %i", _numStreams - 1, _streams[_numStreams - 1]->edit_count);
+	
+	if (editCount != 1)
+		warning("Multiple edit list entries. Things may go awry");
+
+	return 0;
+}
+
+int QTPlayer::readHDLR(MOVatom atom) {
+	MOVStreamContext *st = _streams[_numStreams - 1];
+
+	_fd->readByte(); // version
+	_fd->readByte(); _fd->readByte(); _fd->readByte(); // flags
+
+	// component type
+	uint32 ctype = _fd->readUint32LE();
+	uint32 type = _fd->readUint32BE(); // component subtype
+
+	debug(0, "ctype= %s (0x%08lx)", tag2str(ctype), (long)ctype);
+	debug(0, "stype= %s", tag2str(type));
+
+	if(ctype == MKID_BE('mhlr')) // MOV
+		debug(0, "MOV detected");
+	else if(ctype == 0) {
+		warning("MP4 streams are not supported");
+		return -1;
+	}
+
+	if (type == MKID_BE('vide'))
+		st->codec_type = CODEC_TYPE_VIDEO;
+	else if (type == MKID_BE('soun'))
+		st->codec_type = CODEC_TYPE_AUDIO;
+
+	_fd->readUint32BE(); // component  manufacture
+	_fd->readUint32BE(); // component flags
+	_fd->readUint32BE(); // component flags mask
+
+	if (atom.size <= 24)
+		return 0; // nothing left to read
+
+	// .mov: PASCAL string
+	byte len = _fd->readByte();
+	_fd->seek(len, SEEK_CUR);
+
+	_fd->seek(atom.size - (_fd->pos() - atom.offset), SEEK_CUR);
+
+	return 0;
+}
+
+int QTPlayer::readMDHD(MOVatom atom) {
+	MOVStreamContext *st = _streams[_numStreams - 1];
+	byte version = _fd->readByte();
+
+	if (version > 1)
+		return 1; // unsupported
+
+	_fd->readByte(); _fd->readByte();
+	_fd->readByte(); // flags
+
+	if (version == 1) {
+		_fd->readUint32BE(); _fd->readUint32BE();
+		_fd->readUint32BE(); _fd->readUint32BE();
+	} else {
+		_fd->readUint32BE(); // creation time
+		_fd->readUint32BE(); // modification time
+	}
+
+	st->time_scale = _fd->readUint32BE();
+	st->duration = (version == 1) ? (_fd->readUint32BE(), _fd->readUint32BE()) : _fd->readUint32BE(); // duration
+
+	_fd->readUint16BE(); // language
+	_fd->readUint16BE(); // quality
+
+	return 0;
+}
+
+int QTPlayer::readSTSD(MOVatom atom) {
+	MOVStreamContext *st = _streams[_numStreams - 1];
+
+	_fd->readByte(); // version
+	_fd->readByte(); _fd->readByte(); _fd->readByte(); // flags
+
+	uint32 entries = _fd->readUint32BE();
+
+	while (entries--) { //Parsing Sample description table
+		MOVatom a = { 0, 0, 0 };
+		uint32 start_pos = _fd->pos();
+		int size = _fd->readUint32BE(); // size
+		uint32 format = _fd->readUint32BE(); // data format
+
+		_fd->readUint32BE(); // reserved
+		_fd->readUint16BE(); // reserved
+		_fd->readUint16BE(); // index
+
+		debug(0, "size=%d 4CC= %s codec_type=%d", size, tag2str(format), st->codec_type);
+		st->codec_tag = format;
+
+		if (st->codec_type == CODEC_TYPE_VIDEO) {
+			debug(0, "Video Codec FourCC: \'%s\'", tag2str(format));
+				
+			_fd->readUint16BE(); // version
+			_fd->readUint16BE(); // revision level
+			_fd->readUint32BE(); // vendor
+			_fd->readUint32BE(); // temporal quality
+			_fd->readUint32BE(); // spacial quality
+
+			st->width = _fd->readUint16BE(); // width
+			st->height = _fd->readUint16BE(); // height
+
+			_fd->readUint32BE(); // horiz resolution
+			_fd->readUint32BE(); // vert resolution
+			_fd->readUint32BE(); // data size, always 0
+			uint16 frames_per_sample = _fd->readUint16BE(); // frames per samples
+
+			debug(0, "frames/samples = %d", frames_per_sample);
+
+			byte codec_name[32];
+			_fd->read(codec_name, 32); // codec name, pascal string (FIXME: true for mp4?)
+			if (codec_name[0] <= 31) {
+				memcpy(st->codec_name, &codec_name[1], codec_name[0]);
+				st->codec_name[codec_name[0]] = 0;
+			}
+
+			st->bits_per_sample = _fd->readUint16BE(); // depth
+			st->color_table_id = _fd->readUint16BE(); // colortable id
+
+//		  These are set in mov_read_stts and might already be set!
+//			st->codec->time_base.den	  = 25;
+//			st->codec->time_base.num = 1;
+
+
+			// figure out the palette situation
+			byte colorDepth = st->bits_per_sample & 0x1F;
+			bool colorGreyscale = (st->bits_per_sample & 0x20) != 0;
+
+			debug(0, "color depth: %d", colorDepth);
+
+			// if the depth is 2, 4, or 8 bpp, file is palettized
+			if (colorDepth == 2 || colorDepth == 4 || colorDepth == 8) {
+				if (colorGreyscale) {
+					debug(0, "Greyscale palette");
+
+					// compute the greyscale palette
+					uint16 colorCount = 1 << colorDepth;
+					int16 colorIndex = 255;
+					byte colorDec = 256 / (colorCount - 1);
+					for (byte j = 0; j < colorCount; j++) {
+						_palette[j * 4] = _palette[j * 4 + 1] = _palette[j * 4 + 2] = colorIndex;
+						colorIndex -= colorDec;
+						if (colorIndex < 0)
+							colorIndex = 0;
+					}
+				} else if (st->color_table_id & 0x08) {
+					// if flag bit 3 is set, use the default palette
+					//uint16 colorCount = 1 << colorDepth;
+
+					warning("Predefined palette! %dbpp", colorDepth);
+#if 0
+					byte *color_table;
+					byte  r, g, b;
+	
+					if (colorDepth == 2)
+						color_table = ff_qt_default_palette_4;
+					else if (colorDepth == 4)
+						color_table = ff_qt_default_palette_16;
+					else
+						color_table = ff_qt_default_palette_256;
+
+					for (byte j = 0; j < color_count; j++) {
+						r = color_table[j * 4 + 0];
+						g = color_table[j * 4 + 1];
+						b = color_table[j * 4 + 2];
+						_palette_control.palette[j] = (r << 16) | (g << 8) | (b);
+					}
+#endif
+
+				} else {
+					debug(0, "Palette from file");
+
+					// load the palette from the file
+					uint32 colorStart = _fd->readUint32BE();
+					/* uint16 colorCount = */ _fd->readUint16BE();
+					uint16 colorEnd = _fd->readUint16BE();
+					for (uint32 j = colorStart; j <= colorEnd; j++) {
+						// each R, G, or B component is 16 bits;
+						// only use the top 8 bits; skip alpha bytes
+						// up front
+						_fd->readByte();
+						_fd->readByte();
+						_palette[j * 4] = _fd->readByte();
+						_fd->readByte();
+						_palette[j * 4 + 1] = _fd->readByte();
+						_fd->readByte();
+						_palette[j * 4 + 2] = _fd->readByte();
+						_fd->readByte();
+					}
+				}
+				st->palettized = true;
+			} else
+				st->palettized = false;
+		} else if (st->codec_type == CODEC_TYPE_AUDIO) {
+			debug(0, "Audio Codec FourCC: \'%s\'", tag2str(format));
+			
+			st->stsd_version = _fd->readUint16BE();
+			_fd->readUint16BE(); // revision level
+			_fd->readUint32BE(); // vendor
+
+			st->channels = _fd->readUint16BE();			 // channel count
+			st->bits_per_sample = _fd->readUint16BE();	  // sample size
+			// do we need to force to 16 for AMR ?
+
+			// handle specific s8 codec
+			_fd->readUint16BE(); // compression id = 0
+			_fd->readUint16BE(); // packet size = 0
+
+			st->sample_rate = (_fd->readUint32BE() >> 16);
+
+			debug(0, "stsd version =%d", st->stsd_version);
+			if (st->stsd_version == 0) {
+				// Not used, except in special cases. See below.
+				st->samples_per_frame = st->bytes_per_frame = 0;
+			} else if (st->stsd_version == 1) {
+				// Read QT version 1 fields. In version 0 these dont exist.
+				st->samples_per_frame = _fd->readUint32BE();
+				debug(0, "stsd samples_per_frame =%d", st->samples_per_frame);
+				_fd->readUint32BE(); // bytes per packet
+				st->bytes_per_frame = _fd->readUint32BE();
+				debug(0, "stsd bytes_per_frame =%d", st->bytes_per_frame);
+				_fd->readUint32BE(); // bytes per sample
+			} else {
+				warning("Unsupported QuickTime STSD audio version %d", st->stsd_version);
+				return 1;
+			}
+			
+			// Version 0 videos (such as the Riven ones) don't have this set,
+			// but we need it later on. Add it in here.
+			if (format == MKID_BE('ima4')) {
+				st->samples_per_frame = 64;
+				st->bytes_per_frame = 34 * st->channels;
+			}
+		} else {
+			// other codec type, just skip (rtp, mp4s, tmcd ...)
+			_fd->seek(size - (_fd->pos() - start_pos), SEEK_CUR);
+		}
+		
+		// this will read extra atoms at the end (wave, alac, damr, avcC, SMI ...)
+		a.size = size - (_fd->pos() - start_pos);
+		if (a.size > 8)
+			readDefault(a);
+		else if (a.size > 0)
+			_fd->seek(a.size, SEEK_CUR);
+	}
+
+	if (st->codec_type == CODEC_TYPE_AUDIO && st->sample_rate == 0 && st->time_scale > 1)
+		st->sample_rate= st->time_scale;
+
+	return 0;
+}
+
+int QTPlayer::readSTSC(MOVatom atom) {
+	MOVStreamContext *st = _streams[_numStreams - 1];
+
+	_fd->readByte(); // version
+	_fd->readByte(); _fd->readByte(); _fd->readByte(); // flags
+
+	st->sample_to_chunk_sz = _fd->readUint32BE();
+
+	debug(0, "track[%i].stsc.entries = %i", _numStreams - 1, st->sample_to_chunk_sz);
+
+	st->sample_to_chunk = new MOVstsc[st->sample_to_chunk_sz];
+
+	if (!st->sample_to_chunk)
+		return -1;
+
+	for (uint32 i = 0; i < st->sample_to_chunk_sz; i++) {
+		st->sample_to_chunk[i].first = _fd->readUint32BE();
+		st->sample_to_chunk[i].count = _fd->readUint32BE();
+		st->sample_to_chunk[i].id = _fd->readUint32BE();
+		//printf ("Sample to Chunk[%d]: First = %d, Count = %d\n", i, st->sample_to_chunk[i].first, st->sample_to_chunk[i].count);
+	}
+	
+	return 0;
+}
+
+int QTPlayer::readSTSS(MOVatom atom) {
+	MOVStreamContext *st = _streams[_numStreams - 1];
+
+	_fd->readByte(); // version
+	_fd->readByte(); _fd->readByte(); _fd->readByte(); // flags
+
+	st->keyframe_count = _fd->readUint32BE();
+
+	debug(0, "keyframe_count = %d", st->keyframe_count);
+
+	st->keyframes = new uint32[st->keyframe_count];
+
+	if (!st->keyframes)
+		return -1;
+
+	for (uint32 i = 0; i < st->keyframe_count; i++) {
+		st->keyframes[i] = _fd->readUint32BE();
+		debug(6, "keyframes[%d] = %d", i, st->keyframes[i]);
+
+	}
+	return 0;
+}
+
+int QTPlayer::readSTSZ(MOVatom atom) {
+	MOVStreamContext *st = _streams[_numStreams - 1];
+
+	_fd->readByte(); // version
+	_fd->readByte(); _fd->readByte(); _fd->readByte(); // flags
+
+	st->sample_size = _fd->readUint32BE();
+	st->sample_count = _fd->readUint32BE();
+
+	debug(5, "sample_size = %d sample_count = %d", st->sample_size, st->sample_count);
+
+	if (st->sample_size)
+		return 0; // there isn't any table following
+
+	st->sample_sizes = new uint32[st->sample_count];
+
+	if (!st->sample_sizes)
+		return -1;
+
+	for(uint32 i = 0; i < st->sample_count; i++) {
+		st->sample_sizes[i] = _fd->readUint32BE();
+		debug(6, "sample_sizes[%d] = %d", i, st->sample_sizes[i]);
+	}
+	
+	return 0;
+}
+
+static uint32 ff_gcd(uint32 a, uint32 b) {
+	if(b) return ff_gcd(b, a%b);
+	else  return a;
+}
+
+int QTPlayer::readSTTS(MOVatom atom) {
+	MOVStreamContext *st = _streams[_numStreams - 1];
+	uint32 duration = 0;
+	uint32 total_sample_count = 0;
+
+	_fd->readByte(); // version
+	_fd->readByte(); _fd->readByte(); _fd->readByte(); // flags
+	
+	st->stts_count = _fd->readUint32BE();
+	st->stts_data = new MOVstts[st->stts_count];
+
+	debug(0, "track[%i].stts.entries = %i", _numStreams - 1, st->stts_count);
+
+	st->time_rate = 0;
+
+	for (int32 i = 0; i < st->stts_count; i++) {
+		int sample_duration;
+		int sample_count;
+
+		sample_count = _fd->readUint32BE();
+		sample_duration = _fd->readUint32BE();
+		st->stts_data[i].count = sample_count;
+		st->stts_data[i].duration = sample_duration;
+
+		st->time_rate = ff_gcd(st->time_rate, sample_duration);
+
+		debug(0, "sample_count=%d, sample_duration=%d", sample_count, sample_duration);
+
+		duration += sample_duration * sample_count;
+		total_sample_count += sample_count;
+	}
+
+	st->nb_frames = total_sample_count;
+
+	if (duration)
+		st->duration = duration;
+
+	return 0;
+}
+
+int QTPlayer::readSTCO(MOVatom atom) {
+	MOVStreamContext *st = _streams[_numStreams - 1];
+
+	_fd->readByte(); // version
+	_fd->readByte(); _fd->readByte(); _fd->readByte(); // flags
+
+	st->chunk_count = _fd->readUint32BE();
+	st->chunk_offsets = new uint32[st->chunk_count];
+	
+	if (!st->chunk_offsets)
+		return -1;
+
+	for (uint32 i = 0; i < st->chunk_count; i++) {
+		// WORKAROUND/HACK: The offsets in Riven videos (aka inside the Mohawk archives themselves)
+		// have offsets relative to the archive and not the video. This is quite nasty. We subtract
+		// the initial offset of the stream to get the correct value inside of the stream.
+		st->chunk_offsets[i] = _fd->readUint32BE() - _fd->getBeginOffset();
+	}
+
+	for (uint32 i = 0; i < _numStreams; i++) {
+		MOVStreamContext *sc2 = _streams[i];
+
+		if(sc2 && sc2->chunk_offsets){
+			uint32 first = sc2->chunk_offsets[0];
+			uint32 last = sc2->chunk_offsets[sc2->chunk_count - 1];
+
+			if(first >= st->chunk_offsets[st->chunk_count - 1] || last <= st->chunk_offsets[0])
+				_ni = 1;
+		}
+	}
+	
+	return 0;
+}
+
+int QTPlayer::readWAVE(MOVatom atom) {
+	if (_numStreams < 1)
+		return 0;
+
+	MOVStreamContext *st = _streams[_numStreams - 1];
+	
+	if (atom.size > (1 << 30))
+		return -1;
+
+	if (st->codec_tag == MKID_BE('QDM2')) // Read extradata for QDM2
+		st->extradata = _fd->readStream(atom.size - 8);
+	else if (atom.size > 8)
+		return readDefault(atom);
+	else
+		_fd->skip(atom.size);
+
+	return 0;
+}
+
+void QTPlayer::closeFile() {
+	for (uint32 i = 0; i < _numStreams; i++)
+		delete _streams[i];
+		
+	delete _fd;
+	
+	// The audio stream is deleted automatically
+	_audStream = NULL;
+}
+
+void QTPlayer::resetInternal() {
+	if (_audioStreamIndex >= 0) {
+		_curAudioChunk = 0;
+		_audStream = new QueuedAudioStream(_streams[_audioStreamIndex]->sample_rate, _streams[_audioStreamIndex]->channels);
+	}
+}
+
+Common::SeekableReadStream *QTPlayer::getNextFramePacket() {
+	if (_videoStreamIndex < 0)
+		return NULL;
+		
+	// First, we have to track down which chunk holds the sample and which sample in the chunk contains the frame we are looking for.
+	int32 totalSampleCount = 0;
+	int32 sampleInChunk = 0;
+	int32 actualChunk = -1;
+	
+	for (uint32 i = 0; i < _streams[_videoStreamIndex]->chunk_count; i++) {
+		int32 sampleToChunkIndex = -1;
+	
+		for (uint32 j = 0; j < _streams[_videoStreamIndex]->sample_to_chunk_sz; j++)
+			if (i >= _streams[_videoStreamIndex]->sample_to_chunk[j].first - 1)
+				sampleToChunkIndex = j;
+		
+		if (sampleToChunkIndex < 0)
+			error("This chunk (%d) is imaginary", sampleToChunkIndex);
+		
+		totalSampleCount += _streams[_videoStreamIndex]->sample_to_chunk[sampleToChunkIndex].count;
+		
+		if (totalSampleCount > getCurFrame()) {
+			actualChunk = i;
+			sampleInChunk = _streams[_videoStreamIndex]->sample_to_chunk[sampleToChunkIndex].count - totalSampleCount + getCurFrame();
+			break;
+		}
+	}
+	
+	if (actualChunk < 0) {
+		warning ("Could not find data for frame %d", getCurFrame());
+		return NULL;
+	}
+		
+	// Next seek to that frame
+	_fd->seek(_streams[_videoStreamIndex]->chunk_offsets[actualChunk]);
+
+	// Then, if the chunk holds more than one frame, seek to where the frame we want is located
+	for (int32 i = getCurFrame() - sampleInChunk; i < getCurFrame(); i++) {
+		if (_streams[_videoStreamIndex]->sample_size != 0)
+			_fd->skip(_streams[_videoStreamIndex]->sample_size);
+		else
+			_fd->skip(_streams[_videoStreamIndex]->sample_sizes[i]);
+	}
+
+	// Finally, read in the raw data for the frame
+	//printf ("Frame Data[%d]: Offset = %d, Size = %d\n", getCurFrame(), _fd->pos(), _streams[_videoStreamIndex]->sample_sizes[getCurFrame()]);
+	
+	if (_streams[_videoStreamIndex]->sample_size != 0)
+		return _fd->readStream(_streams[_videoStreamIndex]->sample_size);
+	
+	return _fd->readStream(_streams[_videoStreamIndex]->sample_sizes[getCurFrame()]);
+}
+
+bool QTPlayer::checkAudioCodecSupport(uint32 tag) {
+	// Check if the codec is a supported codec
+	if (tag == MKID_BE('twos') || tag == MKID_BE('raw ') || tag == MKID_BE('ima4') || tag == MKID_BE('QDM2'))
+		return true;
+
+	warning("Audio Codec Not Supported: \'%s\'", tag2str(tag));
+
+	return false;
+}
+
+Audio::AudioStream *QTPlayer::createAudioStream(Common::SeekableReadStream *stream) {
+	if (!stream || _audioStreamIndex < 0)
+		return NULL;
+		
+	if (_streams[_audioStreamIndex]->codec_tag == MKID_BE('twos') || _streams[_audioStreamIndex]->codec_tag == MKID_BE('raw ')) {
+		// Fortunately, most of the audio used in Myst videos is raw...
+		uint16 flags = Audio::Mixer::FLAG_AUTOFREE;
+		if (_streams[_audioStreamIndex]->codec_tag == MKID_BE('raw '))
+			flags |= Audio::Mixer::FLAG_UNSIGNED;
+		if (_streams[_audioStreamIndex]->channels == 2)
+			flags |= Audio::Mixer::FLAG_STEREO;
+		if (_streams[_audioStreamIndex]->bits_per_sample == 16)
+			flags |= Audio::Mixer::FLAG_16BITS;
+		uint32 dataSize = stream->size();
+		byte *data = (byte *)malloc(dataSize);
+		stream->read(data, dataSize);
+		delete stream;
+		return Audio::makeLinearInputStream(data, dataSize, _streams[_audioStreamIndex]->sample_rate, flags, 0, 0);
+	} else if (_streams[_audioStreamIndex]->codec_tag == MKID_BE('ima4')) {
+		// Riven uses this codec (as do some Myst ME videos)
+		return Audio::makeADPCMStream(stream, true, stream->size(), Audio::kADPCMApple, _streams[_audioStreamIndex]->sample_rate, _streams[_audioStreamIndex]->channels, 34);
+	} else if (_streams[_audioStreamIndex]->codec_tag == MKID_BE('QDM2')) {
+		// Several Myst ME videos use this codec
+		return new QDM2Stream(stream, _streams[_audioStreamIndex]->extradata);
+	}
+	
+	error("Unsupported audio codec");
+	
+	return NULL;
+}
+
+void QTPlayer::updateAudioBuffer() {
+	if (!_audStream)
+		return;
+
+	// Keep two streams in buffer so that when the first ends, it goes right into the next
+	for (; _audStream->streamsInQueue() < 2 && _curAudioChunk < _streams[_audioStreamIndex]->chunk_count; _curAudioChunk++) {
+		Common::MemoryWriteStreamDynamic *wStream = new Common::MemoryWriteStreamDynamic();
+		
+		_fd->seek(_streams[_audioStreamIndex]->chunk_offsets[_curAudioChunk]);
+		
+		// First, we have to get the sample count
+		uint32 sampleCount = 0;
+		for (uint32 j = 0; j < _streams[_audioStreamIndex]->sample_to_chunk_sz; j++)
+			if (_curAudioChunk >= (_streams[_audioStreamIndex]->sample_to_chunk[j].first - 1))
+				sampleCount = _streams[_audioStreamIndex]->sample_to_chunk[j].count;
+		assert(sampleCount);
+		
+		// Then calculate the right sizes
+		while (sampleCount > 0) {
+			uint32 samples = 0, size = 0;
+			
+			if (_streams[_audioStreamIndex]->samples_per_frame >= 160) {
+				samples = _streams[_audioStreamIndex]->samples_per_frame;
+				size = _streams[_audioStreamIndex]->bytes_per_frame;
+			} else if (_streams[_audioStreamIndex]->samples_per_frame > 1) {
+				samples = MIN<uint32>((1024 / _streams[_audioStreamIndex]->samples_per_frame) * _streams[_audioStreamIndex]->samples_per_frame, sampleCount);
+				size = (samples / _streams[_audioStreamIndex]->samples_per_frame) * _streams[_audioStreamIndex]->bytes_per_frame;
+			} else {
+				samples = MIN<uint32>(1024, sampleCount);
+				size = samples * _streams[_audioStreamIndex]->sample_size;
+			}
+			
+			// Now, we read in the data for this data and output it
+			byte *data = (byte *)malloc(size);
+			_fd->read(data, size);
+			wStream->write(data, size);
+			free(data);
+			sampleCount -= samples;
+		}
+	
+		// Now queue the buffer
+		_audStream->queueAudioStream(createAudioStream(new Common::MemoryReadStream(wStream->getData(), wStream->size(), Common::DisposeAfterUse::YES)));
+		delete wStream;
+	}
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/video/qt_player.h b/engines/mohawk/video/qt_player.h
new file mode 100644
index 0000000000..48c0ec357f
--- /dev/null
+++ b/engines/mohawk/video/qt_player.h
@@ -0,0 +1,246 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+//
+// Heavily based on ffmpeg code.
+//
+// Copyright (c) 2001 Fabrice Bellard.
+// First version by Francois Revol revol@free.fr
+// Seek function by Gael Chardon gael.dev@4now.net
+//
+
+#ifndef MOHAWK_QT_PLAYER_H
+#define MOHAWK_QT_PLAYER_H
+
+#include "common/scummsys.h"
+#include "common/file.h"
+
+#include "mohawk/video/video.h"
+
+namespace Common {
+	class File;
+}
+
+namespace Mohawk {
+
+class QTPlayer : public Video {
+public:
+	QTPlayer();
+	virtual ~QTPlayer();
+
+	/**
+	 * Returns the width of the video
+	 * @return the width of the video
+	 */
+	uint16 getWidth();
+
+	/**
+	 * Returns the height of the video
+	 * @return the height of the video
+	 */
+	uint16 getHeight();
+
+	/**
+	 * Returns the amount of frames in the video
+	 * @return the amount of frames in the video
+	 */
+	uint32 getFrameCount();
+	
+	/**
+	 * Returns the bits per pixel of the video
+	 * @return the bits per pixel of the video
+	 */
+	byte getBitsPerPixel();
+	
+	/**
+	 * Returns the codec tag of the video
+	 * @return the codec tag of the video
+	 */
+	uint32 getCodecTag();
+
+	/**
+	 * Load a QuickTime video file from a SeekableReadStream
+	 * @param stream	the stream to load
+	 */
+	bool loadFile(Common::SeekableReadStream* stream);
+	
+	/**
+	 * Get a packet of A/V data
+	 */
+	//VideoPacket getNextPacket();
+
+	/**
+	 * Close a QuickTime encoded video file
+	 */
+	void closeFile();
+	
+	ScaleMode getScaleMode();
+	byte *getPalette() { return _palette; }
+
+protected:
+	// This is the file handle from which data is read from. It can be the actual file handle or a decompressed stream.
+	Common::SeekableReadStream *_fd;
+
+	struct MOVatom {
+		uint32 type;
+		uint32 offset;
+		uint32 size;
+	};
+
+	struct ParseTable {
+		uint32 type;
+		int (QTPlayer::*func)(MOVatom atom);
+	};
+
+	struct MOVstts {
+		int count;
+		int duration;
+	};
+
+	struct MOVstsc {
+		uint32 first;
+		uint32 count;
+		uint32 id;
+	};
+
+	enum CodecType {
+		CODEC_TYPE_MOV_OTHER,
+		CODEC_TYPE_VIDEO,
+		CODEC_TYPE_AUDIO
+	};
+
+	struct MOVStreamContext {
+		MOVStreamContext() { memset(this, 0, sizeof(MOVStreamContext)); }
+		~MOVStreamContext() {
+			delete[] chunk_offsets;
+			delete[] stts_data;
+			delete[] ctts_data;
+			delete[] sample_to_chunk;
+			delete[] sample_sizes;
+			delete[] keyframes;
+			delete extradata;
+		}
+
+		int ffindex; /* the ffmpeg stream id */
+		int is_ff_stream; /* Is this stream presented to ffmpeg ? i.e. is this an audio or video stream ? */
+		uint32 next_chunk;
+		uint32 chunk_count;
+		uint32 *chunk_offsets;
+		int stts_count;
+		MOVstts *stts_data;
+		int ctts_count;
+		MOVstts *ctts_data;
+		int edit_count; /* number of 'edit' (elst atom) */
+		uint32 sample_to_chunk_sz;
+		MOVstsc *sample_to_chunk;
+		int32 sample_to_chunk_index;
+		int sample_to_time_index;
+		uint32 sample_to_time_sample;
+		uint32 sample_to_time_time;
+		int sample_to_ctime_index;
+		int sample_to_ctime_sample;
+		uint32 sample_size;
+		uint32 sample_count;
+		uint32 *sample_sizes;
+		uint32 keyframe_count;
+		uint32 *keyframes;
+		int32 time_scale;
+		int time_rate;
+		uint32 current_sample;
+		uint32 left_in_chunk; /* how many samples before next chunk */
+
+		uint16 width;
+		uint16 height;
+		int codec_type;
+		uint32 codec_tag;
+		char codec_name[32];
+		uint16 bits_per_sample;
+		uint16 color_table_id;
+		bool palettized;
+		Common::SeekableReadStream *extradata;
+
+		uint16 stsd_version;
+		uint16 channels;
+		uint16 sample_rate;
+		uint32 samples_per_frame;
+		uint32 bytes_per_frame;
+
+		uint32 nb_frames;
+		uint32 duration;
+		uint32 start_time;
+		ScaleMode scaleMode;
+	};
+
+	const ParseTable *_parseTable;
+	bool _foundMOOV;
+	bool _foundMDAT;
+	uint32 _timeScale;
+	uint32 _duration;
+	uint32 _mdatOffset;
+	uint32 _mdatSize;
+	uint32 _next_chunk_offset;
+	MOVStreamContext *_partial;
+	uint32 _numStreams;
+	int _ni;
+	ScaleMode _scaleMode;
+	MOVStreamContext *_streams[20];
+	byte _palette[256 * 4];
+
+	void initParseTable();
+	QueuedAudioStream *getAudioStream() { return _audStream; }
+	Audio::AudioStream *createAudioStream(Common::SeekableReadStream *stream);
+	bool checkAudioCodecSupport(uint32 tag);
+	void updateAudioBuffer();
+	Common::SeekableReadStream *getNextFramePacket();
+	void resetInternal();
+	uint32 getFrameDuration(uint32 frame);
+	int8 _videoStreamIndex;
+	int8 _audioStreamIndex;
+	uint _curAudioChunk;
+	QueuedAudioStream *_audStream;
+
+	int readDefault(MOVatom atom);
+	int readLeaf(MOVatom atom);
+	int readELST(MOVatom atom);
+	int readHDLR(MOVatom atom);
+	int readMDAT(MOVatom atom);
+	int readMDHD(MOVatom atom);
+	int readMOOV(MOVatom atom);
+	int readMVHD(MOVatom atom);
+	int readTKHD(MOVatom atom);
+	int readTRAK(MOVatom atom);
+	int readSTCO(MOVatom atom);
+	int readSTSC(MOVatom atom);
+	int readSTSD(MOVatom atom);
+	int readSTSS(MOVatom atom);
+	int readSTSZ(MOVatom atom);
+	int readSTTS(MOVatom atom);
+	int readCMOV(MOVatom atom);
+	int readWAVE(MOVatom atom);
+};
+
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/video/qtrle.cpp b/engines/mohawk/video/qtrle.cpp
new file mode 100644
index 0000000000..e03c2a8b7f
--- /dev/null
+++ b/engines/mohawk/video/qtrle.cpp
@@ -0,0 +1,420 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+// QuickTime RLE Decoder
+// Based off ffmpeg's QuickTime RLE decoder (written by Mike Melanson)
+ 
+#include "mohawk/video/qtrle.h"
+ 
+#include "common/scummsys.h"
+#include "common/stream.h"
+#include "common/system.h"
+#include "graphics/colormasks.h"
+#include "graphics/surface.h"
+ 
+namespace Mohawk {
+
+QTRLEDecoder::QTRLEDecoder(uint16 width, uint16 height, byte bitsPerPixel) : Graphics::Codec() {
+	_bitsPerPixel = bitsPerPixel;
+	_pixelFormat = g_system->getScreenFormat();
+
+	// We need to increase the surface size to a multiple of 4
+	uint16 wMod = width % 4;
+	if(wMod != 0)
+		width += 4 - wMod;
+
+	debug(2, "QTRLE corrected width: %d", width);
+
+	_surface = new Graphics::Surface();
+	_surface->create(width, height, _bitsPerPixel <= 8 ? 1 : _pixelFormat.bytesPerPixel);
+}
+
+#define CHECK_STREAM_PTR(n) \
+  if ((stream->pos() + n) > stream->size()) { \
+    warning ("Problem: stream out of bounds (%d >= %d)", stream->pos() + n, stream->size()); \
+    return; \
+  }
+
+#define CHECK_PIXEL_PTR(n) \
+  if ((int32)pixelPtr + n > _surface->w * _surface->h) { \
+    warning ("Problem: pixel ptr = %d, pixel limit = %d", pixelPtr + n, _surface->w * _surface->h); \
+    return; \
+  } \
+
+void QTRLEDecoder::decode1(Common::SeekableReadStream *stream, uint32 rowPtr, uint32 linesToChange) {
+    uint32 pixelPtr = 0;
+	byte *rgb = (byte *)_surface->pixels;
+
+	while (linesToChange) {
+		CHECK_STREAM_PTR(2);
+		byte skip = stream->readByte();
+		int8 rleCode = stream->readSByte();
+		
+        if (rleCode == 0)
+            break;
+			
+        if (skip & 0x80) {
+            linesToChange--;
+            rowPtr += _surface->w;
+            pixelPtr = rowPtr + 2 * (skip & 0x7f);
+        } else
+            pixelPtr += 2 * skip;
+
+        if (rleCode < 0) {
+            // decode the run length code 
+            rleCode = -rleCode;
+            // get the next 2 bytes from the stream, treat them as groups of 8 pixels, and output them rleCode times */
+            CHECK_STREAM_PTR(2);
+            byte pi0 = stream->readByte();
+			byte pi1 = stream->readByte();
+            CHECK_PIXEL_PTR(rleCode * 2);
+
+            while (rleCode--) {
+                rgb[pixelPtr++] = pi0;
+                rgb[pixelPtr++] = pi1;
+            }
+        } else {
+            // copy the same pixel directly to output 2 times
+            rleCode *= 2;
+            CHECK_STREAM_PTR(rleCode);
+            CHECK_PIXEL_PTR(rleCode);
+
+            while (rleCode--)
+                rgb[pixelPtr++] = stream->readByte();
+        }
+    }
+}
+
+void QTRLEDecoder::decode2_4(Common::SeekableReadStream *stream, uint32 rowPtr, uint32 linesToChange, byte bpp) {
+    uint32 pixelPtr = 0;
+    byte *rgb = (byte *)_surface->pixels;
+    byte numPixels = (bpp == 4) ? 8 : 16;
+
+    while (linesToChange--) {
+        CHECK_STREAM_PTR(2);
+        pixelPtr = rowPtr + (numPixels * (stream->readByte() - 1));
+
+		for (int8 rleCode = stream->readSByte(); rleCode != -1; rleCode = stream->readSByte()) {
+            if (rleCode == 0) {
+                // there's another skip code in the stream
+                CHECK_STREAM_PTR(1);
+                pixelPtr += (numPixels * (stream->readByte() - 1));
+            } else if (rleCode < 0) {
+                // decode the run length code
+                rleCode = -rleCode;
+				
+                // get the next 4 bytes from the stream, treat them as palette indices, and output them rleCode times */
+                CHECK_STREAM_PTR(4);
+				
+				byte pi[16]; // 16 palette indices
+				
+                for (int8 i = numPixels - 1; i >= 0; i--) {
+                    pi[numPixels - 1 - i] = (stream->readByte() >> ((i * bpp) & 0x07)) & ((1 << bpp) - 1);
+					
+					// FIXME: Is this right?
+					//stream_ptr += ((i & ((num_pixels>>2)-1)) == 0);
+					if ((i & ((numPixels >> 2) - 1)) == 0)
+						stream->readByte();
+                }
+				
+                CHECK_PIXEL_PTR(rleCode * numPixels);
+				
+                while (rleCode--)
+                    for (byte i = 0; i < numPixels; i++)
+                        rgb[pixelPtr++] = pi[i];
+            } else {
+                // copy the same pixel directly to output 4 times
+                rleCode *= 4;
+                CHECK_STREAM_PTR(rleCode);
+                CHECK_PIXEL_PTR(rleCode * (numPixels >> 2));
+				
+                while (rleCode--) {
+					byte temp = stream->readByte();
+                    if (bpp == 4) {
+                        rgb[pixelPtr++] = (temp >> 4) & 0x0f;
+                        rgb[pixelPtr++] = temp & 0x0f;
+                    } else {
+                        rgb[pixelPtr++] = (temp >> 6) & 0x03;
+                        rgb[pixelPtr++] = (temp >> 4) & 0x03;
+                        rgb[pixelPtr++] = (temp >> 2) & 0x03;
+                        rgb[pixelPtr++] = temp & 0x03;
+                    }
+                }
+            }
+        }
+		
+        rowPtr += _surface->w;
+    }
+}
+
+void QTRLEDecoder::decode8(Common::SeekableReadStream *stream, uint32 rowPtr, uint32 linesToChange) {
+    uint32 pixelPtr = 0;
+    byte *rgb = (byte *)_surface->pixels;
+
+    while (linesToChange--) {
+        CHECK_STREAM_PTR(2);
+        pixelPtr = rowPtr + 4 * (stream->readByte() - 1);
+
+        for (int8 rleCode = stream->readSByte(); rleCode != -1; rleCode = stream->readSByte()) {
+            if (rleCode == 0) {
+                // there's another skip code in the stream
+                CHECK_STREAM_PTR(1);
+                pixelPtr += 4 * (stream->readByte() - 1);
+            } else if (rleCode < 0) {
+                // decode the run length code
+                rleCode = -rleCode;
+				
+                // get the next 4 bytes from the stream, treat them as palette indices, and output them rleCode times
+                CHECK_STREAM_PTR(4);
+				
+				byte pi[4];  // 4 palette indexes
+				
+				for (byte i = 0; i < 4; i++)
+					pi[i] = stream->readByte();
+
+                CHECK_PIXEL_PTR(rleCode * 4);
+
+                while (rleCode--)
+					for (byte i = 0; i < 4; i++)
+						rgb[pixelPtr++] = pi[i];
+            } else {
+                // copy the same pixel directly to output 4 times
+                rleCode *= 4;
+                CHECK_STREAM_PTR(rleCode);
+                CHECK_PIXEL_PTR(rleCode);
+
+                while (rleCode--)
+                    rgb[pixelPtr++] = stream->readByte();
+            }
+        }
+		
+        rowPtr += _surface->w;
+    }
+}
+
+void QTRLEDecoder::decode16(Common::SeekableReadStream *stream, uint32 rowPtr, uint32 linesToChange) {
+    uint32 pixelPtr = 0;
+    OverlayColor *rgb = (OverlayColor *)_surface->pixels;
+
+    while (linesToChange--) {
+        CHECK_STREAM_PTR(2);
+        pixelPtr = rowPtr + stream->readByte() - 1;
+
+        for (int8 rleCode = stream->readSByte(); rleCode != -1; rleCode = stream->readSByte()) {
+            if (rleCode == 0) {
+                // there's another skip code in the stream
+                CHECK_STREAM_PTR(1);
+                pixelPtr += stream->readByte() - 1;
+            } else if (rleCode < 0) {
+                // decode the run length code
+                rleCode = -rleCode;
+                CHECK_STREAM_PTR(2);
+				
+                uint16 rgb16 = stream->readUint16BE();
+
+                CHECK_PIXEL_PTR(rleCode);
+
+                while (rleCode--) {
+					// Convert from RGB555 to the format specified by the Overlay
+					byte r = 0, g = 0, b = 0;
+					Graphics::colorToRGB<Graphics::ColorMasks<555> >(rgb16, r, g, b);
+					rgb[pixelPtr++] = _pixelFormat.RGBToColor(r, g, b);
+                }
+            } else {
+                CHECK_STREAM_PTR(rleCode * 2);
+                CHECK_PIXEL_PTR(rleCode);
+
+                // copy pixels directly to output
+                while (rleCode--) {
+                    uint16 rgb16 = stream->readUint16BE();
+					
+					// Convert from RGB555 to the format specified by the Overlay
+					byte r = 0, g = 0, b = 0;
+					Graphics::colorToRGB<Graphics::ColorMasks<555> >(rgb16, r, g, b);
+					rgb[pixelPtr++] = _pixelFormat.RGBToColor(r, g, b);
+                }
+            }
+        }
+		
+        rowPtr += _surface->w;
+    }
+}
+
+void QTRLEDecoder::decode24(Common::SeekableReadStream *stream, uint32 rowPtr, uint32 linesToChange) {
+    uint32 pixelPtr = 0;
+	OverlayColor *rgb = (OverlayColor *)_surface->pixels;
+
+    while (linesToChange--) {
+        CHECK_STREAM_PTR(2);
+        pixelPtr = rowPtr + stream->readByte() - 1;
+
+        for (int8 rleCode = stream->readSByte(); rleCode != -1; rleCode = stream->readSByte()) {
+            if (rleCode == 0) {
+                // there's another skip code in the stream
+                CHECK_STREAM_PTR(1);
+                pixelPtr += stream->readByte() - 1;
+            } else if (rleCode < 0) {
+                // decode the run length code
+                rleCode = -rleCode;
+				
+                CHECK_STREAM_PTR(3);
+				
+                byte r = stream->readByte();
+                byte g = stream->readByte();
+                byte b = stream->readByte();
+
+                CHECK_PIXEL_PTR(rleCode);
+
+                while (rleCode--) 
+					rgb[pixelPtr++] = _pixelFormat.RGBToColor(r, g, b);
+            } else {
+                CHECK_STREAM_PTR(rleCode * 3);
+                CHECK_PIXEL_PTR(rleCode);
+
+                // copy pixels directly to output
+                while (rleCode--) {
+					byte r = stream->readByte();
+					byte g = stream->readByte();
+					byte b = stream->readByte();
+					rgb[pixelPtr++] = _pixelFormat.RGBToColor(r, g, b);
+                }
+            }
+        }
+		
+        rowPtr += _surface->w;
+    }
+}
+
+void QTRLEDecoder::decode32(Common::SeekableReadStream *stream, uint32 rowPtr, uint32 linesToChange) {
+	uint32 pixelPtr = 0;
+	OverlayColor *rgb = (OverlayColor *)_surface->pixels;
+
+    while (linesToChange--) {
+        CHECK_STREAM_PTR(2);
+        pixelPtr = rowPtr + stream->readByte() - 1;
+
+        for (int8 rleCode = stream->readSByte(); rleCode != -1; rleCode = stream->readSByte()) {
+            if (rleCode == 0) {
+                // there's another skip code in the stream
+                CHECK_STREAM_PTR(1);
+                pixelPtr += stream->readByte() - 1;
+            } else if (rleCode < 0) {
+                // decode the run length code
+                rleCode = -rleCode;
+				
+                CHECK_STREAM_PTR(4);
+				
+                byte a = stream->readByte();
+                byte r = stream->readByte();
+                byte g = stream->readByte();
+                byte b = stream->readByte();
+
+                CHECK_PIXEL_PTR(rleCode);
+
+                while (rleCode--) 
+					rgb[pixelPtr++] = _pixelFormat.ARGBToColor(a, r, g, b);
+            } else {
+                CHECK_STREAM_PTR(rleCode * 4);
+                CHECK_PIXEL_PTR(rleCode);
+
+                // copy pixels directly to output
+                while (rleCode--) {
+                    byte a = stream->readByte();
+                    byte r = stream->readByte();
+                    byte g = stream->readByte();
+                    byte b = stream->readByte();
+                    rgb[pixelPtr++] = _pixelFormat.ARGBToColor(a, r, g, b);
+                }
+            }
+        }
+		
+        rowPtr += _surface->w;
+    }
+}
+
+Graphics::Surface *QTRLEDecoder::decodeImage(Common::SeekableReadStream *stream) {
+    uint16 start_line = 0;
+	uint16 height = _surface->h;
+
+    // check if this frame is even supposed to change
+    if (stream->size() < 8)
+        return _surface;
+
+    // start after the chunk size
+	stream->readUint32BE();
+
+    // fetch the header
+	uint16 header = stream->readUint16BE();
+
+    // if a header is present, fetch additional decoding parameters
+    if (header & 8) {
+        if(stream->size() < 14)
+            return _surface;
+        start_line = stream->readUint16BE();
+		stream->readUint16BE(); // Unknown
+        height = stream->readUint16BE();
+        stream->readUint16BE(); // Unknown
+    }
+	
+    uint32 row_ptr = _surface->w * start_line;
+
+    switch (_bitsPerPixel) {
+		case 1:
+		case 33:
+			decode1(stream, row_ptr, height);
+			break;
+		case 2:
+		case 34:
+			decode2_4(stream, row_ptr, height, 2);
+			break;
+		case 4:
+		case 36:
+			decode2_4(stream, row_ptr, height, 4);
+			break;
+		case 8:
+		case 40:
+			decode8(stream, row_ptr, height);
+			break;
+		case 16:
+			decode16(stream, row_ptr, height);
+			break;
+		case 24:
+			decode24(stream, row_ptr, height);
+			break;
+		case 32:
+			decode32(stream, row_ptr, height);
+			break;
+		default:
+			error ("Unsupported bits per pixel %d", _bitsPerPixel);
+    }
+
+    return _surface;
+}
+
+QTRLEDecoder::~QTRLEDecoder() {
+	_surface->free();
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/video/qtrle.h b/engines/mohawk/video/qtrle.h
new file mode 100644
index 0000000000..8bf6bac125
--- /dev/null
+++ b/engines/mohawk/video/qtrle.h
@@ -0,0 +1,57 @@
+/* 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$
+ * $Id$
+ *
+ */
+ 
+#ifndef MOHAWK_QTRLE_H
+#define MOHAWK_QTRLE_H
+
+#include "graphics/pixelformat.h"
+#include "graphics/video/codecs/codec.h"
+ 
+namespace Mohawk {
+ 
+class QTRLEDecoder : public Graphics::Codec {
+public:
+	QTRLEDecoder(uint16 width, uint16 height, byte bitsPerPixel);
+	~QTRLEDecoder();
+
+	Graphics::Surface *decodeImage(Common::SeekableReadStream *stream);
+
+private:
+	byte _bitsPerPixel;
+	
+	Graphics::Surface *_surface;
+	Graphics::PixelFormat _pixelFormat;
+	
+	void decode1(Common::SeekableReadStream *stream, uint32 rowPtr, uint32 linesToChange);
+	void decode2_4(Common::SeekableReadStream *stream, uint32 rowPtr, uint32 linesToChange, byte bpp);
+	void decode8(Common::SeekableReadStream *stream, uint32 rowPtr, uint32 linesToChange);
+	void decode16(Common::SeekableReadStream *stream, uint32 rowPtr, uint32 linesToChange);
+	void decode24(Common::SeekableReadStream *stream, uint32 rowPtr, uint32 linesToChange);
+	void decode32(Common::SeekableReadStream *stream, uint32 rowPtr, uint32 linesToChange);
+};
+
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/video/rpza.cpp b/engines/mohawk/video/rpza.cpp
new file mode 100644
index 0000000000..937a6066fb
--- /dev/null
+++ b/engines/mohawk/video/rpza.cpp
@@ -0,0 +1,208 @@
+/* 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$
+ * $Id$
+ *
+ */
+ 
+ // Based off ffmpeg's RPZA decoder
+
+#include "mohawk/video/rpza.h"
+
+#include "common/system.h"
+#include "graphics/colormasks.h"
+
+namespace Mohawk {
+
+RPZADecoder::RPZADecoder(uint16 width, uint16 height) : Graphics::Codec() {
+	_pixelFormat = g_system->getScreenFormat();
+
+	// We need to increase the surface size to a multiple of 4
+	uint16 wMod = width % 4;
+	if(wMod != 0)
+		width += 4 - wMod;
+
+	debug(2, "RPZA corrected width: %d", width);
+
+	_surface = new Graphics::Surface();
+	_surface->create(width, height, _pixelFormat.bytesPerPixel);	
+}
+
+#define ADVANCE_BLOCK() \
+    pixelPtr += 4; \
+    if (pixelPtr >= _surface->w) { \
+        pixelPtr = 0; \
+        rowPtr += _surface->w * 4; \
+    } \
+    totalBlocks--; \
+    if (totalBlocks < 0) \
+        error("block counter just went negative (this should not happen)") \
+
+// Convert from RGB555 to the format specified by the screen
+#define PUT_PIXEL(color) \
+	if ((int32)blockPtr < _surface->w * _surface->h) { \
+		byte r = 0, g = 0, b = 0; \
+		Graphics::colorToRGB<Graphics::ColorMasks<555> >(color, r, g, b); \
+		if (_pixelFormat.bytesPerPixel == 2) \
+			*((uint16 *)_surface->pixels + blockPtr) = _pixelFormat.RGBToColor(r, g, b); \
+		else \
+			*((uint32 *)_surface->pixels + blockPtr) = _pixelFormat.RGBToColor(r, g, b); \
+	} \
+	blockPtr++
+
+Graphics::Surface *RPZADecoder::decodeImage(Common::SeekableReadStream *stream) {
+    uint16 colorA = 0, colorB = 0;
+    uint16 color4[4];
+
+    uint32 rowPtr = 0;
+    uint32 pixelPtr = 0;
+    uint32 blockPtr = 0;
+	uint32 rowInc = _surface->w - 4;
+	uint16 ta;
+	uint16 tb;
+
+    // First byte is always 0xe1. Warn if it's different
+	byte firstByte = stream->readByte();
+    if (firstByte != 0xe1)
+        warning("First RPZA chunk byte is 0x%02x instead of 0xe1", firstByte);
+
+    // Get chunk size, ingnoring first byte
+    uint32 chunkSize = stream->readUint16BE() << 8;
+	chunkSize += stream->readByte();
+
+    // If length mismatch use size from MOV file and try to decode anyway
+    if (chunkSize != (uint32)stream->size()) {
+        warning("MOV chunk size != encoded chunk size; using MOV chunk size");
+		chunkSize = stream->size();
+	}
+
+    // Number of 4x4 blocks in frame
+    int32 totalBlocks = ((_surface->w + 3) / 4) * ((_surface->h + 3) / 4);
+
+    // Process chunk data
+    while ((uint32)stream->pos() < chunkSize) {
+        byte opcode = stream->readByte(); // Get opcode
+        byte numBlocks = (opcode & 0x1f) + 1; // Extract block counter from opcode
+
+        // If opcode MSbit is 0, we need more data to decide what to do
+        if ((opcode & 0x80) == 0) {
+            colorA = (opcode << 8) | stream->readByte();
+            opcode = 0;
+            if (stream->readByte() & 0x80) {
+                // Must behave as opcode 110xxxxx, using colorA computed
+                // above. Use fake opcode 0x20 to enter switch block at
+                // the right place
+                opcode = 0x20;
+                numBlocks = 1;
+            }
+			stream->seek(-1, SEEK_CUR);
+        }
+
+        switch (opcode & 0xe0) {
+        case 0x80: // Skip blocks
+            while (numBlocks--) {
+              ADVANCE_BLOCK();
+            }
+            break;
+        case 0xa0: // Fill blocks with one color
+            colorA = stream->readUint16BE();
+            while (numBlocks--) {
+                blockPtr = rowPtr + pixelPtr;
+                for (byte pixel_y = 0; pixel_y < 4; pixel_y++) {
+                    for (byte pixel_x = 0; pixel_x < 4; pixel_x++) {
+						PUT_PIXEL(colorA);
+                    }
+                    blockPtr += rowInc;
+                }
+                ADVANCE_BLOCK();
+            }
+            break;
+
+        // Fill blocks with 4 colors
+        case 0xc0:
+            colorA = stream->readUint16BE();
+        case 0x20:
+            colorB = stream->readUint16BE();
+
+            // Sort out the colors
+            color4[0] = colorB;
+            color4[1] = 0;
+            color4[2] = 0;
+            color4[3] = colorA;
+
+            // Red components
+            ta = (colorA >> 10) & 0x1F;
+            tb = (colorB >> 10) & 0x1F;
+            color4[1] |= ((11 * ta + 21 * tb) >> 5) << 10;
+            color4[2] |= ((21 * ta + 11 * tb) >> 5) << 10;
+
+            // Green components
+            ta = (colorA >> 5) & 0x1F;
+            tb = (colorB >> 5) & 0x1F;
+            color4[1] |= ((11 * ta + 21 * tb) >> 5) << 5;
+            color4[2] |= ((21 * ta + 11 * tb) >> 5) << 5;
+
+            // Blue components
+            ta = colorA & 0x1F;
+            tb = colorB & 0x1F;
+            color4[1] |= ((11 * ta + 21 * tb) >> 5);
+            color4[2] |= ((21 * ta + 11 * tb) >> 5);
+
+            while (numBlocks--) {
+                blockPtr = rowPtr + pixelPtr;
+                for (byte pixel_y = 0; pixel_y < 4; pixel_y++) {
+                    byte index = stream->readByte();
+                    for (byte pixel_x = 0; pixel_x < 4; pixel_x++){
+                        byte idx = (index >> (2 * (3 - pixel_x))) & 0x03;
+						PUT_PIXEL(color4[idx]);
+                    }
+                    blockPtr += rowInc;
+                }
+                ADVANCE_BLOCK();
+            }
+            break;
+
+        // Fill block with 16 colors
+        case 0x00:
+            blockPtr = rowPtr + pixelPtr;
+            for (byte pixel_y = 0; pixel_y < 4; pixel_y++) {
+                for (byte pixel_x = 0; pixel_x < 4; pixel_x++){
+                    // We already have color of upper left pixel
+                    if (pixel_y != 0 || pixel_x != 0)
+                        colorA = stream->readUint16BE();
+
+					PUT_PIXEL(colorA);
+                }
+                blockPtr += rowInc;
+            }
+            ADVANCE_BLOCK();
+            break;
+
+        // Unknown opcode
+        default:
+            error("Unknown opcode %02x in rpza chunk", opcode);
+        }
+	}
+	
+	return _surface;
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/video/rpza.h b/engines/mohawk/video/rpza.h
new file mode 100644
index 0000000000..bba744cc38
--- /dev/null
+++ b/engines/mohawk/video/rpza.h
@@ -0,0 +1,48 @@
+/* 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$
+ * $Id$
+ *
+ */
+ 
+#ifndef MOHAWK_RPZA_H
+#define MOHAWK_RPZA_H
+
+#include "graphics/pixelformat.h"
+#include "graphics/video/codecs/codec.h"
+ 
+namespace Mohawk {
+ 
+class RPZADecoder : public Graphics::Codec {
+public:
+	RPZADecoder(uint16 width, uint16 height);
+	~RPZADecoder() { delete _surface; }
+
+	Graphics::Surface *decodeImage(Common::SeekableReadStream *stream);
+
+private:	
+	Graphics::Surface *_surface;
+	Graphics::PixelFormat _pixelFormat;
+};
+
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/video/smc.cpp b/engines/mohawk/video/smc.cpp
new file mode 100644
index 0000000000..c646d5be21
--- /dev/null
+++ b/engines/mohawk/video/smc.cpp
@@ -0,0 +1,385 @@
+/* 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$
+ * $Id$
+ *
+ */
+ 
+// Based off ffmpeg's SMC decoder
+
+#include "mohawk/video/smc.h"
+
+namespace Mohawk {
+
+#define GET_BLOCK_COUNT() \
+  (opcode & 0x10) ? (1 + stream->readByte()) : 1 + (opcode & 0x0F);
+
+#define ADVANCE_BLOCK() \
+{ \
+    pixelPtr += 4; \
+    if (pixelPtr >= _surface->w) { \
+        pixelPtr = 0; \
+        rowPtr += _surface->w * 4; \
+    } \
+    totalBlocks--; \
+    if (totalBlocks < 0) { \
+        warning("block counter just went negative (this should not happen)"); \
+        return _surface; \
+    } \
+}
+
+SMCDecoder::SMCDecoder(uint16 width, uint16 height) {
+	_surface = new Graphics::Surface();
+	_surface->create(width, height, 1);
+}
+
+Graphics::Surface *SMCDecoder::decodeImage(Common::SeekableReadStream *stream) {
+    byte *pixels = (byte *)_surface->pixels;
+
+	uint32 numBlocks = 0;
+    uint32 colorFlags = 0;
+    uint32 colorFlagsA = 0;
+    uint32 colorFlagsB = 0;
+
+	const uint16 rowInc = _surface->w - 4;
+    int32 rowPtr = 0;
+    int32 pixelPtr = 0;
+    uint32 blockPtr = 0;
+    uint32 prevBlockPtr = 0;
+    uint32 prevBlockPtr1 = 0, prevBlockPtr2 = 0;
+    byte prevBlockFlag = false;
+    byte pixel = 0;
+
+    uint32 colorPairIndex = 0;
+    uint32 colorQuadIndex = 0;
+    uint32 colorOctetIndex = 0;
+	uint32 colorTableIndex = 0;  // indices to color pair, quad, or octet tables
+
+    int32 chunkSize = stream->readUint32BE() & 0x00FFFFFF;
+    if (chunkSize != stream->size())
+		warning("MOV chunk size != SMC chunk size (%d != %d); ignoring SMC chunk size", chunkSize, stream->size());
+
+    int32 totalBlocks = ((_surface->w + 3) / 4) * ((_surface->h + 3) / 4);
+
+    // traverse through the blocks
+    while (totalBlocks != 0) {
+        // sanity checks
+
+        // make sure stream ptr hasn't gone out of bounds
+        if (stream->pos() > stream->size()) {
+            warning("SMC decoder just went out of bounds (stream ptr = %d, chunk size = %d)", stream->pos(), stream->size());
+            return _surface;
+        }
+
+        // make sure the row pointer hasn't gone wild
+        if (rowPtr >= _surface->w * _surface->h) {
+            warning("SMC decoder just went out of bounds (row ptr = %d, size = %d)", rowPtr, _surface->w * _surface->h);
+            return _surface;
+        }
+
+        byte opcode = stream->readByte();
+
+        switch (opcode & 0xF0) {
+        // skip n blocks
+        case 0x00:
+        case 0x10:
+            numBlocks = GET_BLOCK_COUNT();
+            while (numBlocks--) {
+                ADVANCE_BLOCK();
+            }
+            break;
+
+        // repeat last block n times
+        case 0x20:
+        case 0x30:
+            numBlocks = GET_BLOCK_COUNT();
+
+            // sanity check
+            if (rowPtr == 0 && pixelPtr == 0) {
+                warning("encountered repeat block opcode (%02X) but no blocks rendered yet", opcode & 0xF0);
+                break;
+            }
+
+            // figure out where the previous block started
+            if (pixelPtr == 0)
+                prevBlockPtr1 = (rowPtr - _surface->w * 4) + _surface->w - 4;
+            else
+                prevBlockPtr1 = rowPtr + pixelPtr - 4;
+
+            while (numBlocks--) {
+                blockPtr = rowPtr + pixelPtr;
+                prevBlockPtr = prevBlockPtr1;
+                for (byte y = 0; y < 4; y++) {
+                    for (byte x = 0; x < 4; x++)
+                        pixels[blockPtr++] = pixels[prevBlockPtr++];
+                    blockPtr += rowInc;
+                    prevBlockPtr += rowInc;
+                }
+                ADVANCE_BLOCK();
+            }
+            break;
+
+        // repeat previous pair of blocks n times
+        case 0x40:
+        case 0x50:
+            numBlocks = GET_BLOCK_COUNT();
+            numBlocks *= 2;
+
+            // sanity check
+            if (rowPtr == 0 && pixelPtr < 2 * 4) {
+                warning("encountered repeat block opcode (%02X) but not enough blocks rendered yet", opcode & 0xF0);
+                break;
+            }
+
+            // figure out where the previous 2 blocks started
+            if (pixelPtr == 0)
+                prevBlockPtr1 = (rowPtr - _surface->w * 4) + _surface->w - 4 * 2;
+            else if (pixelPtr == 4)
+                prevBlockPtr1 = (rowPtr - _surface->w * 4) + rowInc;
+            else
+                prevBlockPtr1 = rowPtr + pixelPtr - 4 * 2;
+
+            if (pixelPtr == 0)
+                prevBlockPtr2 = (rowPtr - _surface->w * 4) + rowInc;
+            else
+                prevBlockPtr2 = rowPtr + pixelPtr - 4;
+
+            prevBlockFlag = 0;
+            while (numBlocks--) {
+                blockPtr = rowPtr + pixelPtr;
+
+                if (prevBlockFlag)
+                    prevBlockPtr = prevBlockPtr2;
+                else
+                    prevBlockPtr = prevBlockPtr1;
+
+                prevBlockFlag = !prevBlockFlag;
+
+                for (byte y = 0; y < 4; y++) {
+                    for (byte x = 0; x < 4; x++)
+                        pixels[blockPtr++] = pixels[prevBlockPtr++];
+
+                    blockPtr += rowInc;
+                    prevBlockPtr += rowInc;
+                }
+                ADVANCE_BLOCK();
+            }
+            break;
+
+        // 1-color block encoding
+        case 0x60:
+        case 0x70:
+            numBlocks = GET_BLOCK_COUNT();
+            pixel = stream->readByte();
+
+            while (numBlocks--) {
+                blockPtr = rowPtr + pixelPtr;
+                for (byte y = 0; y < 4; y++) {
+                    for (byte x = 0; x < 4; x++)
+                        pixels[blockPtr++] = pixel;
+
+                    blockPtr += rowInc;
+                }
+                ADVANCE_BLOCK();
+            }
+            break;
+
+        // 2-color block encoding
+        case 0x80:
+        case 0x90:
+            numBlocks = (opcode & 0x0F) + 1;
+
+            // figure out which color pair to use to paint the 2-color block
+            if ((opcode & 0xF0) == 0x80) {
+                // fetch the next 2 colors from bytestream and store in next
+                // available entry in the color pair table
+                for (byte i = 0; i < CPAIR; i++) {
+                    pixel = stream->readByte();
+                    colorTableIndex = CPAIR * colorPairIndex + i;
+                    _colorPairs[colorTableIndex] = pixel;
+                }
+
+                // this is the base index to use for this block
+                colorTableIndex = CPAIR * colorPairIndex;
+                colorPairIndex++;
+
+                // wraparound
+                if (colorPairIndex == COLORS_PER_TABLE)
+                    colorPairIndex = 0;
+            } else
+                colorTableIndex = CPAIR * stream->readByte();
+
+            while (numBlocks--) {
+                colorFlags = stream->readUint16BE();
+                uint16 flagMask = 0x8000;
+                blockPtr = rowPtr + pixelPtr;
+                for (byte y = 0; y < 4; y++) {
+                    for (byte x = 0; x < 4; x++) {
+                        if (colorFlags & flagMask)
+                            pixel = colorTableIndex + 1;
+                        else
+                            pixel = colorTableIndex;
+
+                        flagMask >>= 1;
+                        pixels[blockPtr++] = _colorPairs[pixel];
+                    }
+
+                    blockPtr += rowInc;
+                }
+                ADVANCE_BLOCK();
+            }
+            break;
+
+        // 4-color block encoding
+        case 0xA0:
+        case 0xB0:
+            numBlocks = (opcode & 0x0F) + 1;
+
+            // figure out which color quad to use to paint the 4-color block
+            if ((opcode & 0xF0) == 0xA0) {
+                // fetch the next 4 colors from bytestream and store in next
+                // available entry in the color quad table
+                for (byte i = 0; i < CQUAD; i++) {
+                    pixel = stream->readByte();
+                    colorTableIndex = CQUAD * colorQuadIndex + i;
+                    _colorQuads[colorTableIndex] = pixel;
+                }
+
+                // this is the base index to use for this block
+                colorTableIndex = CQUAD * colorQuadIndex;
+                colorQuadIndex++;
+
+                // wraparound
+                if (colorQuadIndex == COLORS_PER_TABLE)
+                    colorQuadIndex = 0;
+            } else
+                colorTableIndex = CQUAD * stream->readByte();
+
+            while (numBlocks--) {
+                colorFlags = stream->readUint32BE();
+
+                // flag mask actually acts as a bit shift count here
+                byte flagMask = 30;
+                blockPtr = rowPtr + pixelPtr;
+
+                for (byte y = 0; y < 4; y++) {
+                    for (byte x = 0; x < 4; x++) {
+                        pixel = colorTableIndex + ((colorFlags >> flagMask) & 0x03);
+                        flagMask -= 2;
+                        pixels[blockPtr++] = _colorQuads[pixel];
+                    }
+                    blockPtr += rowInc;
+                }
+                ADVANCE_BLOCK();
+            }
+            break;
+
+        // 8-color block encoding
+        case 0xC0:
+        case 0xD0:
+            numBlocks = (opcode & 0x0F) + 1;
+
+            // figure out which color octet to use to paint the 8-color block
+            if ((opcode & 0xF0) == 0xC0) {
+                // fetch the next 8 colors from bytestream and store in next
+                // available entry in the color octet table
+                for (byte i = 0; i < COCTET; i++) {
+                    pixel = stream->readByte();
+                    colorTableIndex = COCTET * colorOctetIndex + i;
+                    _colorOctets[colorTableIndex] = pixel;
+                }
+
+                // this is the base index to use for this block
+                colorTableIndex = COCTET * colorOctetIndex;
+                colorOctetIndex++;
+
+                // wraparound
+                if (colorOctetIndex == COLORS_PER_TABLE)
+                    colorOctetIndex = 0;
+            } else
+                colorTableIndex = COCTET * stream->readByte();
+
+            while (numBlocks--) {
+                /*
+                  For this input of 6 hex bytes:
+                    01 23 45 67 89 AB
+                  Mangle it to this output:
+                    flags_a = xx012456, flags_b = xx89A37B
+                */
+
+				// build the color flags
+				byte flagData[6];
+				stream->read(flagData, 6);
+                
+                colorFlagsA = ((READ_BE_UINT16(flagData) & 0xFFF0) << 8) | (READ_BE_UINT16(flagData + 2) >> 4);
+				colorFlagsB = ((READ_BE_UINT16(flagData + 4) & 0xFFF0) << 8) | ((flagData[1] & 0xF) << 8) |
+								((flagData[3] & 0xF) << 4) | (flagData[5] & 0xf);
+
+                colorFlags = colorFlagsA;
+                
+				// flag mask actually acts as a bit shift count here
+                byte flagMask = 21;
+                blockPtr = rowPtr + pixelPtr;
+                for (byte y = 0; y < 4; y++) {
+                    // reload flags at third row (iteration y == 2)
+                    if (y == 2) {
+                        colorFlags = colorFlagsB;
+                        flagMask = 21;
+                    }
+					
+                    for (byte x = 0; x < 4; x++) {
+                        pixel = colorTableIndex + ((colorFlags >> flagMask) & 0x07);
+                        flagMask -= 3;
+                        pixels[blockPtr++] = _colorOctets[pixel];
+                    }
+
+                    blockPtr += rowInc;
+                }
+                ADVANCE_BLOCK();
+            }
+            break;
+
+        // 16-color block encoding (every pixel is a different color) 
+        case 0xE0:
+            numBlocks = (opcode & 0x0F) + 1;
+
+            while (numBlocks--) {
+                blockPtr = rowPtr + pixelPtr;
+                for (byte y = 0; y < 4; y++) {
+                    for (byte x = 0; x < 4; x++)
+                        pixels[blockPtr++] = stream->readByte();
+
+                    blockPtr += rowInc;
+                }
+                ADVANCE_BLOCK();
+            }
+            break;
+
+        case 0xF0:
+            warning("0xF0 opcode seen in SMC chunk (contact the developers)");
+            break;
+        }
+    }
+	
+	return _surface;
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/video/smc.h b/engines/mohawk/video/smc.h
new file mode 100644
index 0000000000..73c11c167b
--- /dev/null
+++ b/engines/mohawk/video/smc.h
@@ -0,0 +1,58 @@
+/* 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$
+ * $Id$
+ *
+ */
+ 
+#ifndef MOHAWK_VIDEO_SMC_H
+#define MOHAWK_VIDEO_SMC_H
+
+#include "graphics/video/codecs/codec.h"
+ 
+namespace Mohawk {
+
+enum {
+	CPAIR = 2,
+	CQUAD = 4,
+	COCTET = 8,
+	COLORS_PER_TABLE = 256
+};
+ 
+class SMCDecoder : public Graphics::Codec {
+public:
+	SMCDecoder(uint16 width, uint16 height);
+	~SMCDecoder() { delete _surface; }
+
+	Graphics::Surface *decodeImage(Common::SeekableReadStream *stream);
+
+private:	
+	Graphics::Surface *_surface;
+
+	// SMC color tables
+	byte _colorPairs[COLORS_PER_TABLE * CPAIR];
+	byte _colorQuads[COLORS_PER_TABLE * CQUAD];
+	byte _colorOctets[COLORS_PER_TABLE * COCTET];
+};
+
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/video/video.cpp b/engines/mohawk/video/video.cpp
new file mode 100644
index 0000000000..1abebf75af
--- /dev/null
+++ b/engines/mohawk/video/video.cpp
@@ -0,0 +1,582 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#include "mohawk/file.h"
+#include "mohawk/video/video.h"
+#include "mohawk/video/qt_player.h"
+
+// Codecs
+#include "mohawk/video/cinepak.h"
+#include "mohawk/video/qtrle.h"
+#include "mohawk/video/rpza.h"
+#include "mohawk/video/smc.h"
+
+namespace Mohawk {
+
+////////////////////////////////////////////
+// QueuedAudioStream 
+////////////////////////////////////////////
+
+QueuedAudioStream::QueuedAudioStream(int rate, int channels, bool autofree) {
+	_rate = rate;
+	_channels = channels;
+	_autofree = autofree;
+	_finished = false;
+}
+
+QueuedAudioStream::~QueuedAudioStream() {
+	if (_autofree)
+		while (!_queue.empty())
+			delete _queue.pop();
+	_queue.clear();
+}
+
+void QueuedAudioStream::queueAudioStream(Audio::AudioStream *audStream) {
+	if (audStream->getRate() != getRate() && audStream->isStereo() && isStereo())
+		error("QueuedAudioStream::queueAudioStream: audStream has mismatched parameters");
+		
+	_queue.push(audStream);
+}
+
+int QueuedAudioStream::readBuffer(int16 *buffer, const int numSamples) {
+	int samplesDecoded = 0;
+
+	while (samplesDecoded < numSamples && !_queue.empty()) {
+		samplesDecoded += _queue.front()->readBuffer(buffer + samplesDecoded, numSamples - samplesDecoded);
+
+		if (_queue.front()->endOfData()) {
+			Audio::AudioStream *temp = _queue.pop();
+			if (_autofree)
+				delete temp;
+		}
+	}
+
+	return samplesDecoded;
+}
+
+////////////////////////////////////////////
+// Video 
+////////////////////////////////////////////
+
+Video::Video() {
+	_videoCodec = NULL;
+	_noCodecFound = false;
+	_curFrame = -1;
+	_lastFrameStart = _nextFrameStart = 0;
+	_audHandle = Audio::SoundHandle();
+}
+
+Video::~Video() {
+}
+
+void Video::stop() {
+	stopAudio();
+	
+	if (!_noCodecFound)
+		delete _videoCodec;
+	
+	closeFile();
+}
+
+void Video::reset() {
+	delete _videoCodec; _videoCodec = NULL;
+	_noCodecFound = false;
+	_curFrame = -1;
+	_lastFrameStart = _nextFrameStart = 0;
+
+	stopAudio();
+	resetInternal();
+	startAudio();
+}
+
+Graphics::Codec *Video::createCodec(uint32 codecTag, byte bitsPerPixel) {
+	if (codecTag == MKID_BE('cvid')) {
+		// Cinepak: As used by most Myst and all Riven videos as well as some Myst ME videos. "The Chief" videos also use this.
+		return new CinepakDecoder();
+	} else if (codecTag == MKID_BE('rpza')) {
+		// Apple Video ("Road Pizza"): Used by some Myst videos.
+		return new RPZADecoder(getWidth(), getHeight());
+	} else if (codecTag == MKID_BE('rle ')) {
+		// QuickTime RLE: Used by some Myst ME videos.
+		return new QTRLEDecoder(getWidth(), getHeight(), bitsPerPixel);
+	} else if (codecTag == MKID_BE('smc ')) {
+		// Apple SMC: Used by some Myst videos.
+		return new SMCDecoder(getWidth(), getHeight());
+	} else if (codecTag == MKID_BE('SVQ1')) {
+		// Sorenson Video 1: Used by some Myst ME videos.
+		warning ("Sorenson Video 1 not yet supported");
+	} else if (codecTag == MKID_BE('SVQ3')) {
+		// Sorenson Video 3: Used by some Myst ME videos.
+		warning ("Sorenson Video 3 not yet supported");
+	} else if (codecTag == MKID_BE('jpeg')) {
+		// Motion JPEG: Used by some Myst ME videos.
+		warning ("Motion JPEG not yet supported");
+	} else if (codecTag == MKID_BE('QkBk')) {
+		// CDToons: Used by most of the Broderbund games. This is an unknown format so far.
+		warning ("CDToons not yet supported");
+	} else {
+		warning ("Unsupported codec \'%s\'", tag2str(codecTag));
+	}
+	
+	return NULL;
+}
+
+void Video::startAudio() {
+	Audio::AudioStream *audStream = getAudioStream();
+	
+	if (!audStream) // No audio/audio not supported
+		return;
+	
+	g_system->getMixer()->playInputStream(Audio::Mixer::kPlainSoundType, &_audHandle, audStream);
+}
+
+void Video::pauseAudio() {
+	g_system->getMixer()->pauseHandle(_audHandle, true);
+}
+
+void Video::resumeAudio() {
+	g_system->getMixer()->pauseHandle(_audHandle, false);
+}
+
+void Video::stopAudio() {
+	g_system->getMixer()->stopHandle(_audHandle);
+}
+
+Graphics::Surface *Video::getNextFrame() {	
+	if (_noCodecFound || _curFrame >= (int32)getFrameCount() - 1)
+		return NULL;
+		
+	if (_nextFrameStart == 0)
+		_nextFrameStart = g_system->getMillis() * 100;
+		
+	_lastFrameStart = _nextFrameStart;
+	_curFrame++;
+	_nextFrameStart = getFrameDuration() + _lastFrameStart;
+	
+	Common::SeekableReadStream *frameData = getNextFramePacket();
+	
+	if (!_videoCodec) {
+		_videoCodec = createCodec(getCodecTag(), getBitsPerPixel());
+		// If we don't get it still, the codec is unsupported ;)
+		if (!_videoCodec) {
+			_noCodecFound = true;
+			return NULL;
+		}
+	}
+
+	if (frameData) {
+		Graphics::Surface *frame = _videoCodec->decodeImage(frameData);
+		delete frameData;
+		return frame;
+	}
+
+	return NULL;
+}
+
+bool Video::endOfVideo() {
+	QueuedAudioStream *audStream = getAudioStream();
+		
+	return (!audStream || audStream->endOfData()) && (_noCodecFound || _curFrame >= (int32)getFrameCount() - 1);
+}
+
+bool Video::needsUpdate() {
+	if (endOfVideo())
+		return false;
+
+	if (_curFrame == -1)
+		return true;
+
+	return (g_system->getMillis() * 100 - _lastFrameStart) >= getFrameDuration();
+}
+
+////////////////////////////////////////////
+// VideoManager 
+////////////////////////////////////////////
+	
+VideoManager::VideoManager(MohawkEngine* vm) : _vm(vm) {
+	if (_vm->getFeatures() & GF_HASBINK) {
+		warning ("This game uses bink video. Playback is disabled.");
+		_videoType = kBinkVideo;
+	} else {
+		_videoType = kQuickTimeVideo;
+	}
+	
+	_pauseStart = 0;
+}
+	
+VideoManager::~VideoManager() {
+	_mlstRecords.clear();
+	stopVideos();
+}
+
+void VideoManager::pauseVideos() {
+	for (uint16 i = 0; i < _videoStreams.size(); i++)
+		_videoStreams[i]->pauseAudio();
+	_pauseStart = _vm->_system->getMillis() * 100;
+}
+
+void VideoManager::resumeVideos() {
+	for (uint16 i = 0; i < _videoStreams.size(); i++) {
+		_videoStreams[i]->addPauseTime(_vm->_system->getMillis() * 100 - _pauseStart);
+		_videoStreams[i]->resumeAudio();
+	}
+	
+	_pauseStart = 0;
+}
+
+void VideoManager::stopVideos() {
+	for (uint16 i = 0; i < _videoStreams.size(); i++)
+		_videoStreams[i]->stop();
+	_videoStreams.clear();
+}
+
+void VideoManager::playMovie(Common::String filename, uint16 x, uint16 y, bool clearScreen) {
+	Common::File *file = new Common::File();
+	if (!file->open(filename))
+		return; // Return silently for now...
+
+	VideoEntry entry;
+	entry.video = createVideo();
+
+	if (!entry.video)
+		return;
+
+	entry->loadFile(file);
+
+	// Clear screen if requested
+	if (clearScreen) {
+		_vm->_system->fillScreen(_vm->_system->getScreenFormat().RGBToColor(0, 0, 0));
+		_vm->_system->updateScreen();
+	}
+
+	entry.x = x;
+	entry.y = y;
+	entry.loop = false;
+	playMovie(entry);
+}
+
+void VideoManager::playMovieCentered(Common::String filename, bool clearScreen) {
+	Common::File *file = new Common::File();
+	if (!file->open(filename))
+		return; // Return silently for now...
+
+	VideoEntry entry;
+	entry.video = createVideo();
+
+	if (!entry.video)
+		return;
+
+	entry->loadFile(file);
+
+	// Clear screen if requested
+	if (clearScreen) {
+		_vm->_system->fillScreen(_vm->_system->getScreenFormat().RGBToColor(0, 0, 0));
+		_vm->_system->updateScreen();
+	}
+
+	entry.x = (_vm->_system->getWidth() - entry->getWidth()) / 2;
+	entry.y = (_vm->_system->getHeight() - entry->getHeight()) / 2;
+	entry.loop = false;
+	playMovie(entry);
+}
+	
+void VideoManager::playMovie(VideoEntry videoEntry) {
+	// Add video to the list
+	_videoStreams.push_back(videoEntry);
+	
+	bool continuePlaying = true;
+	videoEntry->startAudio();
+	
+	while (!videoEntry->endOfVideo() && !_vm->shouldQuit() && continuePlaying) {
+		if (updateBackgroundMovies())
+			_vm->_system->updateScreen();
+		
+		Common::Event event;
+		while (_vm->_system->getEventManager()->pollEvent(event)) {
+			switch (event.type) {
+				case Common::EVENT_RTL:
+				case Common::EVENT_QUIT:
+					continuePlaying = false;
+					break;
+				case Common::EVENT_KEYDOWN:
+					switch (event.kbd.keycode) {
+						case Common::KEYCODE_SPACE:
+							_vm->pauseGame();
+							break;
+						case Common::KEYCODE_ESCAPE:
+							continuePlaying = false;
+							break;
+						default:
+							break;
+					}
+				default:
+					break;
+			}
+		}
+		
+		// Cut down on CPU usage
+		_vm->_system->delayMillis(10);
+	}
+	
+	videoEntry->stop();
+
+	_videoStreams.clear();
+}
+
+void VideoManager::playBackgroundMovie(Common::String filename, int16 x, int16 y, bool loop) {
+	Common::File *file = new Common::File();
+	if (!file->open(filename))
+		return; // Return silently for now...
+
+	VideoEntry entry;
+	entry.video = createVideo();
+	
+	if (!entry.video)
+		return;
+	
+	entry->loadFile(file);
+	
+	// Center x if requested
+	if (x < 0)
+		x = (_vm->_system->getWidth() - entry->getWidth()) / 2;
+	
+	// Center y if requested
+	if (y < 0)
+		y = (_vm->_system->getHeight() - entry->getHeight()) / 2;
+		
+	entry.x = x;
+	entry.y = y;
+	entry.loop = loop;
+	
+	entry->startAudio();
+	_videoStreams.push_back(entry);
+}
+
+bool VideoManager::updateBackgroundMovies() {
+	bool updateScreen = false;
+
+	for (uint32 i = 0; i < _videoStreams.size() && !_vm->shouldQuit(); i++) {
+		// Remove any videos that are over
+		if (_videoStreams[i]->endOfVideo()) {
+			if (_videoStreams[i].loop) {
+				_videoStreams[i]->reset();
+			} else {
+				delete _videoStreams[i].video;
+				_videoStreams.remove_at(i);
+				i--;
+				continue;
+			}
+		}
+
+		// Check if we need to draw a frame
+		if (_videoStreams[i]->needsUpdate()) {
+			Graphics::Surface *frame = _videoStreams[i]->getNextFrame();
+			bool deleteFrame = false;
+
+			if (frame) {			
+				// Convert from 8bpp to the current screen format if necessary
+				if (frame->bytesPerPixel == 1) {
+					Graphics::Surface *newFrame = new Graphics::Surface();
+					Graphics::PixelFormat pixelFormat = _vm->_system->getScreenFormat();
+					byte *palette = _videoStreams[i]->getPalette();
+					assert(palette);
+					
+					newFrame->create(frame->w, frame->h, pixelFormat.bytesPerPixel);
+					
+					for (uint16 j = 0; j < frame->h; j++) {
+						for (uint16 k = 0; k < frame->w; k++) {
+							byte palIndex = *((byte *)frame->getBasePtr(k, j));
+							byte r = palette[palIndex * 4];
+							byte g = palette[palIndex * 4 + 1];
+							byte b = palette[palIndex * 4 + 2];
+							if (pixelFormat.bytesPerPixel == 2)
+								*((uint16 *)newFrame->getBasePtr(k, j)) = pixelFormat.RGBToColor(r, g, b);
+							else
+								*((uint32 *)newFrame->getBasePtr(k, j)) = pixelFormat.RGBToColor(r, g, b);
+						}
+					}
+					
+					frame = newFrame;
+					deleteFrame = true;
+				}
+
+				// Check if we're drawing at a 2x or 4x resolution (because of 
+				// evil QuickTime scaling it first).
+				if (_videoStreams[i]->getScaleMode() == kScaleHalf || _videoStreams[i]->getScaleMode() == kScaleQuarter) {
+					byte scaleFactor = (_videoStreams[i]->getScaleMode() == kScaleHalf) ? 2 : 4;
+
+					Graphics::Surface scaledSurf;
+					scaledSurf.create(_videoStreams[i]->getWidth() / scaleFactor, _videoStreams[i]->getHeight() / scaleFactor, frame->bytesPerPixel);
+
+					for (uint32 j = 0; j < scaledSurf.h; j++)
+						for (uint32 k = 0; k < scaledSurf.w; k++)
+							memcpy(scaledSurf.getBasePtr(k, j), frame->getBasePtr(k * scaleFactor, j * scaleFactor), frame->bytesPerPixel);
+
+					_vm->_system->copyRectToScreen((byte*)scaledSurf.pixels, scaledSurf.pitch, _videoStreams[i].x, _videoStreams[i].y, scaledSurf.w, scaledSurf.h);
+					scaledSurf.free();
+				} else {
+					// Clip the width/height to make sure we stay on the screen (Myst does this a few times)
+					uint16 width = MIN<int32>(_videoStreams[i]->getWidth(), _vm->_system->getWidth() - _videoStreams[i].x);
+					uint16 height = MIN<int32>(_videoStreams[i]->getHeight(), _vm->_system->getHeight() - _videoStreams[i].y);
+					_vm->_system->copyRectToScreen((byte*)frame->pixels, frame->pitch, _videoStreams[i].x, _videoStreams[i].y, width, height);
+				}
+
+				// We've drawn something to the screen, make sure we update it
+				updateScreen = true;
+				
+				// Delete the frame if we're using the buffer from the 8bpp conversion
+				if (deleteFrame) {
+					frame->free();
+					delete frame;
+				}
+			}
+		}
+
+		// Update the audio buffer too
+		_videoStreams[i]->updateAudioBuffer();
+	}
+
+	// Return true if we need to update the screen
+	return updateScreen;
+}
+
+void VideoManager::activateMLST(uint16 mlstId, uint16 card) {
+	Common::SeekableReadStream *mlstStream = _vm->getRawData(ID_MLST, card);
+	uint16 recordCount = mlstStream->readUint16BE();
+
+	for (uint16 i = 0; i < recordCount; i++) {
+		MLSTRecord mlstRecord;
+		mlstRecord.index = mlstStream->readUint16BE();
+		mlstRecord.movieID = mlstStream->readUint16BE();
+		mlstRecord.code = mlstStream->readUint16BE();
+		mlstRecord.left = mlstStream->readUint16BE();
+		mlstRecord.top = mlstStream->readUint16BE();
+
+		for (byte j = 0; j < 2; j++)
+			if (mlstStream->readUint16BE() != 0)
+				warning("u0[%d] in MLST non-zero", j);
+
+		if (mlstStream->readUint16BE() != 0xFFFF)
+			warning("u0[2] in MLST not 0xFFFF");
+		
+		mlstRecord.loop = mlstStream->readUint16BE();
+		mlstRecord.volume = mlstStream->readUint16BE();
+		mlstRecord.u1 = mlstStream->readUint16BE();
+
+		if (mlstRecord.u1 != 1)
+			warning("mlstRecord.u1 not 1");
+
+		// Enable the record by default
+		mlstRecord.enabled = true;
+
+		if (mlstRecord.index == mlstId) {
+			_mlstRecords.push_back(mlstRecord);
+			break;
+		}
+	}
+	
+	delete mlstStream;
+}
+
+void VideoManager::playMovie(uint16 id) {
+	for (uint16 i = 0; i < _mlstRecords.size(); i++)
+		if (_mlstRecords[i].code == id) {
+			warning("STUB: Play tMOV %d (non-blocking) at (%d, %d)", _mlstRecords[i].movieID, _mlstRecords[i].left, _mlstRecords[i].top);
+			return; // TODO: This will do a lot of things wrong if enabled right now ;)
+			VideoEntry entry;
+			entry.video = new QTPlayer();
+			entry->loadFile(_vm->getRawData(ID_TMOV, _mlstRecords[i].movieID));
+			entry.x = _mlstRecords[i].left;
+			entry.y = _mlstRecords[i].top;
+			entry.id = _mlstRecords[i].movieID;
+			entry.loop = _mlstRecords[i].loop != 0;
+			_videoStreams.push_back(entry);
+			return;
+		}
+}
+
+void VideoManager::playMovieBlocking(uint16 id) {
+	// NOTE/TODO: playMovieBlocking can be called after playMovie, essentially
+	// making it just a playMovieBlocking. It basically nullifies the first call.
+
+	for (uint16 i = 0; i < _mlstRecords.size(); i++)
+		if (_mlstRecords[i].code == id) {
+			warning("STUB: Play tMOV %d (blocking) at (%d, %d)", _mlstRecords[i].movieID, _mlstRecords[i].left, _mlstRecords[i].top);
+			
+			// TODO: See if a non-blocking movie has been activated with the same id,
+			// and if so, block input until that movie is finished.
+			
+			VideoEntry entry;
+			entry.video = new QTPlayer();
+			entry->loadFile(_vm->getRawData(ID_TMOV, _mlstRecords[i].movieID));
+			entry.x = _mlstRecords[i].left;
+			entry.y = _mlstRecords[i].top;
+			entry.id = _mlstRecords[i].movieID;
+			entry.loop = false;
+			playMovie(entry);
+			return;
+		}
+}
+
+void VideoManager::stopMovie(uint16 id) {
+	for (uint16 i = 0; i < _mlstRecords.size(); i++)
+		if (_mlstRecords[i].code == id) {
+			warning("STUB: Stop tMOV %d", _mlstRecords[i].movieID);
+			return;
+		}
+}
+
+void VideoManager::enableMovie(uint16 id) {
+	debug(2, "Enabling movie %d", id);
+	for (uint16 i = 0; i < _mlstRecords.size(); i++)
+		if (_mlstRecords[i].code == id) {
+			_mlstRecords[i].enabled = true;
+			return;
+		}
+}
+
+void VideoManager::disableMovie(uint16 id) {
+	debug(2, "Disabling movie %d", id);
+	for (uint16 i = 0; i < _mlstRecords.size(); i++)
+		if (_mlstRecords[i].code == id) {
+			_mlstRecords[i].enabled = false;
+			return;
+		}
+}
+
+void VideoManager::disableAllMovies() {
+	debug(2, "Disabling all movies");
+	for (uint16 i = 0; i < _mlstRecords.size(); i++)
+		_mlstRecords[i].enabled = false;
+}
+
+Video *VideoManager::createVideo() {
+	if (_videoType == kBinkVideo || _vm->shouldQuit())
+		return NULL;
+
+	return new QTPlayer();
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/video/video.h b/engines/mohawk/video/video.h
new file mode 100644
index 0000000000..666873b9a6
--- /dev/null
+++ b/engines/mohawk/video/video.h
@@ -0,0 +1,188 @@
+/* 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$
+ * $Id$
+ *
+ */
+
+#ifndef MOHAWK_VIDEO_H
+#define MOHAWK_VIDEO_H
+
+#include "common/queue.h"
+#include "sound/audiostream.h"
+#include "sound/mixer.h"
+#include "graphics/pixelformat.h"
+#include "graphics/video/codecs/codec.h"
+
+namespace Mohawk {
+
+class MohawkEngine;
+
+struct MLSTRecord {
+	uint16 index;
+	uint16 movieID;
+	uint16 code;
+	uint16 left;
+	uint16 top;
+	uint16 u0[3];
+	uint16 loop;
+	uint16 volume;
+	uint16 u1;
+
+	bool enabled;
+};
+
+class QueuedAudioStream : public Audio::AudioStream {
+public:
+	QueuedAudioStream(int rate, int channels, bool autofree = true);
+	~QueuedAudioStream();
+
+	int readBuffer(int16 *buffer, const int numSamples);
+	bool isStereo() const { return _channels == 2; }
+	int getRate() const { return _rate; }
+	bool endOfData() const { return _queue.empty(); }
+	bool endOfStream() const { return _finished; }
+
+	void queueAudioStream(Audio::AudioStream *audStream);
+	void finish() { _finished = true; }
+
+	uint32 streamsInQueue() { return _queue.size(); }
+
+private:
+	bool _autofree;
+	bool _finished;
+	int _rate;
+	int _channels;
+
+	Common::Queue<Audio::AudioStream*> _queue;
+};
+
+enum ScaleMode {
+	kScaleNormal = 1,
+	kScaleHalf = 2,
+	kScaleQuarter = 4
+};
+
+class Video {
+public:
+	Video();
+	virtual ~Video();
+
+	virtual bool loadFile(Common::SeekableReadStream *stream) = 0;
+	virtual void closeFile() = 0;
+	void stop();
+	void reset();
+
+	Graphics::Surface *getNextFrame();
+	virtual uint16 getWidth() = 0;
+	virtual uint16 getHeight() = 0;
+	virtual uint32 getFrameCount() = 0;
+
+	virtual void updateAudioBuffer() {}
+	void startAudio();
+	void stopAudio();
+	void pauseAudio();
+	void resumeAudio();
+
+	int32 getCurFrame() { return _curFrame; }
+	void addPauseTime(uint32 p) { _lastFrameStart += p; _nextFrameStart += p; }
+	bool needsUpdate();
+	bool endOfVideo();
+
+	virtual byte getBitsPerPixel() = 0;
+	virtual byte *getPalette() { return NULL; }
+	virtual uint32 getCodecTag() = 0;
+	virtual ScaleMode getScaleMode() { return kScaleNormal; }
+
+private:
+	Graphics::Codec *_videoCodec;
+	bool _noCodecFound;
+	Graphics::Codec *createCodec(uint32 codecTag, byte bitsPerPixel);
+	int32 _curFrame;
+	uint32 _lastFrameStart, _nextFrameStart; // In 1/100 ms
+	Audio::SoundHandle _audHandle;
+
+	uint32 getFrameDuration() { return getFrameDuration(_curFrame); }
+
+protected:
+	virtual Common::SeekableReadStream *getNextFramePacket() = 0;
+	virtual uint32 getFrameDuration(uint32 frame) = 0;
+	virtual QueuedAudioStream *getAudioStream() = 0;
+	virtual void resetInternal() {}
+};
+
+struct VideoEntry {
+	Video *video;
+	uint16 x;
+	uint16 y;
+	bool loop;
+	Common::String filename;
+	uint16 id; // Riven only
+
+	Video *operator->() const { assert(video); return video; }
+};
+
+enum VideoType {
+	kQuickTimeVideo,
+	kBinkVideo
+};
+
+class VideoManager {
+public:
+	VideoManager(MohawkEngine *vm);
+	~VideoManager();
+
+	// Generic movie functions
+	void playMovie(Common::String filename, uint16 x = 0, uint16 y = 0, bool clearScreen = false);
+	void playMovieCentered(Common::String filename, bool clearScreen = true);
+	void playBackgroundMovie(Common::String filename, int16 x = -1, int16 y = -1, bool loop = false);
+	bool updateBackgroundMovies();
+	void pauseVideos();
+	void resumeVideos();
+	void stopVideos();
+
+	// Riven-related functions
+	void activateMLST(uint16 mlstId, uint16 card);
+	void enableMovie(uint16 id);
+	void disableMovie(uint16 id);
+	void disableAllMovies();
+	void playMovie(uint16 id);
+	void stopMovie(uint16 id);
+	void playMovieBlocking(uint16 id);
+
+	// Riven-related variables
+	Common::Array<MLSTRecord> _mlstRecords;
+
+private:
+	MohawkEngine *_vm;
+
+	void playMovie(VideoEntry videoEntry);
+	Video *createVideo();
+
+	// Keep tabs on any videos playing
+	VideoType _videoType;
+	Common::Array<VideoEntry> _videoStreams;
+	uint32 _pauseStart;
+};
+
+} // End of namespace Mohawk
+
+#endif