From 2f31b05651baf87ea07bc00cced798955a5fa6be Mon Sep 17 00:00:00 2001
From: Matthew Hoops
Date: Sun, 23 May 2010 18:33:55 +0000
Subject: Move Mohawk's QuickTime code to graphics/ (and QDM2 to sound,
 disabled when Mohawk is not enabled) so SCI can use the code.

svn-id: r49165
---
 engines/mohawk/console.cpp         |    2 +-
 engines/mohawk/graphics.cpp        |   10 +-
 engines/mohawk/graphics.h          |    8 +-
 engines/mohawk/jpeg.cpp            |   87 -
 engines/mohawk/jpeg.h              |   59 -
 engines/mohawk/module.mk           |    9 +-
 engines/mohawk/mohawk.cpp          |    2 +-
 engines/mohawk/myst.cpp            |    2 +-
 engines/mohawk/myst_pict.cpp       |    5 +-
 engines/mohawk/myst_pict.h         |    6 +-
 engines/mohawk/myst_scripts.cpp    |    2 +-
 engines/mohawk/riven.cpp           |    2 +-
 engines/mohawk/riven_external.cpp  |    2 +-
 engines/mohawk/riven_scripts.cpp   |    2 +-
 engines/mohawk/video.cpp           |  377 +++++
 engines/mohawk/video.h             |  109 ++
 engines/mohawk/video/cinepak.cpp   |  286 ----
 engines/mohawk/video/cinepak.h     |   81 -
 engines/mohawk/video/qdm2.cpp      | 3063 ------------------------------------
 engines/mohawk/video/qdm2.h        |  289 ----
 engines/mohawk/video/qdm2data.h    |  531 -------
 engines/mohawk/video/qt_player.cpp | 1272 ---------------
 engines/mohawk/video/qt_player.h   |  282 ----
 engines/mohawk/video/qtrle.cpp     |  420 -----
 engines/mohawk/video/qtrle.h       |   58 -
 engines/mohawk/video/rpza.cpp      |  208 ---
 engines/mohawk/video/rpza.h        |   49 -
 engines/mohawk/video/smc.cpp       |  385 -----
 engines/mohawk/video/smc.h         |   59 -
 engines/mohawk/video/video.cpp     |  377 -----
 engines/mohawk/video/video.h       |  107 --
 31 files changed, 507 insertions(+), 7644 deletions(-)
 delete mode 100644 engines/mohawk/jpeg.cpp
 delete mode 100644 engines/mohawk/jpeg.h
 create mode 100644 engines/mohawk/video.cpp
 create mode 100644 engines/mohawk/video.h
 delete mode 100644 engines/mohawk/video/cinepak.cpp
 delete mode 100644 engines/mohawk/video/cinepak.h
 delete mode 100644 engines/mohawk/video/qdm2.cpp
 delete mode 100644 engines/mohawk/video/qdm2.h
 delete mode 100644 engines/mohawk/video/qdm2data.h
 delete mode 100644 engines/mohawk/video/qt_player.cpp
 delete mode 100644 engines/mohawk/video/qt_player.h
 delete mode 100644 engines/mohawk/video/qtrle.cpp
 delete mode 100644 engines/mohawk/video/qtrle.h
 delete mode 100644 engines/mohawk/video/rpza.cpp
 delete mode 100644 engines/mohawk/video/rpza.h
 delete mode 100644 engines/mohawk/video/smc.cpp
 delete mode 100644 engines/mohawk/video/smc.h
 delete mode 100644 engines/mohawk/video/video.cpp
 delete mode 100644 engines/mohawk/video/video.h

(limited to 'engines/mohawk')

diff --git a/engines/mohawk/console.cpp b/engines/mohawk/console.cpp
index 389665db39..149b6b6eba 100644
--- a/engines/mohawk/console.cpp
+++ b/engines/mohawk/console.cpp
@@ -30,7 +30,7 @@
 #include "mohawk/riven.h"
 #include "mohawk/livingbooks.h"
 #include "mohawk/sound.h"
-#include "mohawk/video/video.h"
+#include "mohawk/video.h"
 
 namespace Mohawk {
 
diff --git a/engines/mohawk/graphics.cpp b/engines/mohawk/graphics.cpp
index 35691c36aa..1b220c861b 100644
--- a/engines/mohawk/graphics.cpp
+++ b/engines/mohawk/graphics.cpp
@@ -78,8 +78,7 @@ MystGraphics::MystGraphics(MohawkEngine_Myst* vm) : _vm(vm) {
 		error("Myst requires greater than 256 colors to run");
 
 	if (_vm->getFeatures() & GF_ME) {
-		// We want to delete our own JPEG surfaces, so don't free after use.
-		_jpegDecoder = new JPEGDecoder(false);
+		_jpegDecoder = new Graphics::JPEGDecoder();
 		_pictDecoder = new MystPICT(_jpegDecoder);
 	} else {
 		_jpegDecoder = NULL;
@@ -152,9 +151,10 @@ void MystGraphics::copyImageSectionToScreen(uint16 image, Common::Rect src, Comm
 	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)
+				if (_pictureFile.entries[i].type == 0) {
+					Graphics::Surface *jpegSurface = _jpegDecoder->decodeImage(new Common::SeekableSubReadStream(&_pictureFile.picFile, _pictureFile.entries[i].offset, _pictureFile.entries[i].offset + _pictureFile.entries[i].size));
+					surface->copyFrom(*jpegSurface);
+				} 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);
diff --git a/engines/mohawk/graphics.h b/engines/mohawk/graphics.h
index 8d28e1ff4b..23b1ace347 100644
--- a/engines/mohawk/graphics.h
+++ b/engines/mohawk/graphics.h
@@ -27,11 +27,11 @@
 #define MOHAWK_GRAPHICS_H
 
 #include "mohawk/bitmap.h"
-#include "mohawk/jpeg.h"
 #include "mohawk/livingbooks.h"
 #include "mohawk/myst_pict.h"
 
 #include "common/file.h"
+#include "graphics/video/codecs/mjpeg.h"
 
 namespace Mohawk {
 
@@ -96,8 +96,8 @@ public:
 	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 showCursor();
+	void hideCursor();
 	void changeCursor(uint16);
 
 	void drawRect(Common::Rect rect, bool active);
@@ -105,7 +105,7 @@ private:
 	MohawkEngine_Myst *_vm;
 	MystBitmap *_bmpDecoder;
 	MystPICT *_pictDecoder;
-	JPEGDecoder *_jpegDecoder;
+	Graphics::JPEGDecoder *_jpegDecoder;
 	Graphics::PixelFormat _pixelFormat;
 
 	struct PictureFile {
diff --git a/engines/mohawk/jpeg.cpp b/engines/mohawk/jpeg.cpp
deleted file mode 100644
index 07ec54dfea..0000000000
--- a/engines/mohawk/jpeg.cpp
+++ /dev/null
@@ -1,87 +0,0 @@
-/* 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/jpeg.h"
-
-namespace Mohawk {
-
-JPEGDecoder::JPEGDecoder(bool freeSurfaceAfterUse) : Graphics::Codec(), _freeSurfaceAfterUse(freeSurfaceAfterUse) {
-	_jpeg = new Graphics::JPEG();
-	_pixelFormat = g_system->getScreenFormat();
-	_surface = NULL;
-}
-
-JPEGDecoder::~JPEGDecoder() {
-	delete _jpeg;
-
-	if (_surface) {
-		_surface->free();
-		delete _surface;
-	}
-}
-
-Graphics::Surface *JPEGDecoder::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 *destSurface = NULL;
-
-	// If we should free the surface after use, use the internal _surface storage
-	// (this should be used when using as a Codec, as the Codecs should free their
-	// surfaces when deleting the Codec object). Otherwise, create a new Surface
-	// as the destination.
-	if (_freeSurfaceAfterUse) {
-		if (!_surface) {
-			_surface = new Graphics::Surface();
-			_surface->create(ySurface->w, ySurface->h, _pixelFormat.bytesPerPixel);
-		}
-		destSurface = _surface;
-	} else {
-		destSurface = new Graphics::Surface();
-		destSurface->create(ySurface->w, ySurface->h, _pixelFormat.bytesPerPixel);
-	}
-
-	assert(destSurface);
-
-	for (uint16 i = 0; i < destSurface->h; i++) {
-		for (uint16 j = 0; j < destSurface->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 *)destSurface->getBasePtr(j, i)) = _pixelFormat.RGBToColor(r, g, b);
-			else
-				*((uint32 *)destSurface->getBasePtr(j, i)) = _pixelFormat.RGBToColor(r, g, b);
-		}
-	}
-
-	return destSurface;
-}
-
-} // End of namespace Mohawk
diff --git a/engines/mohawk/jpeg.h b/engines/mohawk/jpeg.h
deleted file mode 100644
index ec87b1e7af..0000000000
--- a/engines/mohawk/jpeg.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/* 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_JPEG_H
-#define MOHAWK_JPEG_H
-
-#include "common/scummsys.h"
-#include "common/stream.h"
-
-#include "graphics/video/codecs/codec.h"
-#include "graphics/jpeg.h"
-#include "graphics/pixelformat.h"
-
-namespace Mohawk {
-
-// Mohawk's JPEG Decoder
-// Basically a wrapper around JPEG which converts to RGB and also functions
-// as a Codec.
-
-class JPEGDecoder : public Graphics::Codec {
-public:
-	JPEGDecoder(bool freeSurfaceAfterUse);
-	~JPEGDecoder();
-
-	Graphics::Surface *decodeImage(Common::SeekableReadStream *stream);
-	Graphics::PixelFormat getPixelFormat() const { return _pixelFormat; }
-
-private:
-	Graphics::PixelFormat _pixelFormat;
-	Graphics::JPEG *_jpeg;
-	Graphics::Surface *_surface;
-	bool _freeSurfaceAfterUse;
-};
-
-} // End of namespace Mohawk
-
-#endif
diff --git a/engines/mohawk/module.mk b/engines/mohawk/module.mk
index b224a8b143..8c23cdfa87 100644
--- a/engines/mohawk/module.mk
+++ b/engines/mohawk/module.mk
@@ -6,7 +6,6 @@ MODULE_OBJS = \
 	detection.o \
 	dialogs.o \
 	graphics.o \
-	jpeg.o \
 	livingbooks.o \
 	mohawk.o \
 	myst.o \
@@ -22,13 +21,7 @@ MODULE_OBJS = \
 	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
+	video.o
 
 
 # This module can be built as a plugin
diff --git a/engines/mohawk/mohawk.cpp b/engines/mohawk/mohawk.cpp
index 5bde6bbeec..6b4d8bb2d2 100644
--- a/engines/mohawk/mohawk.cpp
+++ b/engines/mohawk/mohawk.cpp
@@ -35,7 +35,7 @@
 #include "mohawk/mohawk.h"
 #include "mohawk/dialogs.h"
 #include "mohawk/sound.h"
-#include "mohawk/video/video.h"
+#include "mohawk/video.h"
 
 #include "sound/mixer.h"
 
diff --git a/engines/mohawk/myst.cpp b/engines/mohawk/myst.cpp
index d1ef3b2137..9ff301c129 100644
--- a/engines/mohawk/myst.cpp
+++ b/engines/mohawk/myst.cpp
@@ -33,7 +33,7 @@
 #include "mohawk/dialogs.h"
 #include "mohawk/resource.h"
 #include "mohawk/resource_cache.h"
-#include "mohawk/video/video.h"
+#include "mohawk/video.h"
 
 namespace Mohawk {
 
diff --git a/engines/mohawk/myst_pict.cpp b/engines/mohawk/myst_pict.cpp
index 794ec9b87f..2dfed65d2b 100644
--- a/engines/mohawk/myst_pict.cpp
+++ b/engines/mohawk/myst_pict.cpp
@@ -32,7 +32,7 @@ namespace Mohawk {
 // The PICT code is based off of the QuickDraw specs:
 // http://developer.apple.com/documentation/mac/QuickDraw/QuickDraw-461.html
 
-MystPICT::MystPICT(JPEGDecoder *jpegDecoder) {
+MystPICT::MystPICT(Graphics::JPEGDecoder *jpegDecoder) {
 	_jpegDecoder = jpegDecoder;
 	_pixelFormat = g_system->getScreenFormat();
 }
@@ -264,9 +264,6 @@ void MystPICT::decodeCompressedQuickTime(Common::SeekableReadStream *stream, Gra
 	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
index 0684e3352a..90c06deee0 100644
--- a/engines/mohawk/myst_pict.h
+++ b/engines/mohawk/myst_pict.h
@@ -32,18 +32,18 @@
 #include "graphics/pixelformat.h"
 #include "graphics/surface.h"
 
-#include "mohawk/jpeg.h"
+#include "graphics/video/codecs/mjpeg.h"
 
 namespace Mohawk {
 
 class MystPICT {
 public:
-	MystPICT(JPEGDecoder *jpegDecoder);
+	MystPICT(Graphics::JPEGDecoder *jpegDecoder);
 	~MystPICT() {}
 	Graphics::Surface *decodeImage(Common::SeekableReadStream *stream);
 
 private:
-	JPEGDecoder *_jpegDecoder;
+	Graphics::JPEGDecoder *_jpegDecoder;
 	Common::Rect _imageRect;
 	Graphics::PixelFormat _pixelFormat;
 
diff --git a/engines/mohawk/myst_scripts.cpp b/engines/mohawk/myst_scripts.cpp
index a453bb0985..2f6d178da8 100644
--- a/engines/mohawk/myst_scripts.cpp
+++ b/engines/mohawk/myst_scripts.cpp
@@ -27,7 +27,7 @@
 #include "mohawk/graphics.h"
 #include "mohawk/myst_scripts.h"
 #include "mohawk/sound.h"
-#include "mohawk/video/video.h"
+#include "mohawk/video.h"
 
 #include "gui/message.h"
 
diff --git a/engines/mohawk/riven.cpp b/engines/mohawk/riven.cpp
index 0412144034..744b3f2d2c 100644
--- a/engines/mohawk/riven.cpp
+++ b/engines/mohawk/riven.cpp
@@ -33,7 +33,7 @@
 #include "mohawk/riven_external.h"
 #include "mohawk/riven_saveload.h"
 #include "mohawk/dialogs.h"
-#include "mohawk/video/video.h"
+#include "mohawk/video.h"
 
 namespace Mohawk {
 
diff --git a/engines/mohawk/riven_external.cpp b/engines/mohawk/riven_external.cpp
index 99afacc5ce..8b1ff45a66 100644
--- a/engines/mohawk/riven_external.cpp
+++ b/engines/mohawk/riven_external.cpp
@@ -27,7 +27,7 @@
 #include "mohawk/riven.h"
 #include "mohawk/riven_external.h"
 #include "mohawk/sound.h"
-#include "mohawk/video/video.h"
+#include "mohawk/video.h"
 
 #include "gui/message.h"
 #include "common/events.h"
diff --git a/engines/mohawk/riven_scripts.cpp b/engines/mohawk/riven_scripts.cpp
index e809ad9642..fa6f336542 100644
--- a/engines/mohawk/riven_scripts.cpp
+++ b/engines/mohawk/riven_scripts.cpp
@@ -28,7 +28,7 @@
 #include "mohawk/riven_external.h"
 #include "mohawk/riven_scripts.h"
 #include "mohawk/sound.h"
-#include "mohawk/video/video.h"
+#include "mohawk/video.h"
 
 #include "common/stream.h"
 #include "graphics/cursorman.h"
diff --git a/engines/mohawk/video.cpp b/engines/mohawk/video.cpp
new file mode 100644
index 0000000000..adca805763
--- /dev/null
+++ b/engines/mohawk/video.cpp
@@ -0,0 +1,377 @@
+/* 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/resource.h"
+#include "mohawk/video.h"
+
+#include "common/events.h"
+#include "graphics/video/qt_decoder.h"
+
+namespace Mohawk {
+
+VideoManager::VideoManager(MohawkEngine* vm) : _vm(vm) {
+}
+
+VideoManager::~VideoManager() {
+	_mlstRecords.clear();
+	stopVideos();
+}
+
+void VideoManager::pauseVideos() {
+	for (uint16 i = 0; i < _videoStreams.size(); i++)
+		_videoStreams[i]->pauseVideo(true);
+}
+
+void VideoManager::resumeVideos() {
+	for (uint16 i = 0; i < _videoStreams.size(); i++)
+		_videoStreams[i]->pauseVideo(false);
+}
+
+void VideoManager::stopVideos() {
+	for (uint16 i = 0; i < _videoStreams.size(); i++)
+		delete _videoStreams[i].video;
+	_videoStreams.clear();
+}
+
+void VideoManager::playMovie(Common::String filename, uint16 x, uint16 y, bool clearScreen) {
+	VideoHandle videoHandle = createVideoHandle(filename, x, y, false);
+	if (videoHandle == NULL_VID_HANDLE)
+		return;
+
+	// Clear screen if requested
+	if (clearScreen) {
+		_vm->_system->fillScreen(_vm->_system->getScreenFormat().RGBToColor(0, 0, 0));
+		_vm->_system->updateScreen();
+	}
+
+	waitUntilMovieEnds(videoHandle);
+}
+
+void VideoManager::playMovieCentered(Common::String filename, bool clearScreen) {
+	VideoHandle videoHandle = createVideoHandle(filename, 0, 0, false);
+	if (videoHandle == NULL_VID_HANDLE)
+		return;
+
+	// Clear screen if requested
+	if (clearScreen) {
+		_vm->_system->fillScreen(_vm->_system->getScreenFormat().RGBToColor(0, 0, 0));
+		_vm->_system->updateScreen();
+	}
+
+	_videoStreams[videoHandle].x = (_vm->_system->getWidth() - _videoStreams[videoHandle]->getWidth()) / 2;
+	_videoStreams[videoHandle].y = (_vm->_system->getHeight() - _videoStreams[videoHandle]->getHeight()) / 2;
+
+	waitUntilMovieEnds(videoHandle);
+}
+
+void VideoManager::waitUntilMovieEnds(VideoHandle videoHandle) {
+	bool continuePlaying = true;
+
+	while (!_videoStreams[videoHandle]->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);
+	}
+
+	_videoStreams[videoHandle]->close();
+	_videoStreams.clear();
+}
+
+void VideoManager::playBackgroundMovie(Common::String filename, int16 x, int16 y, bool loop) {
+	VideoHandle videoHandle = createVideoHandle(filename, x, y, loop);
+	if (videoHandle == NULL_VID_HANDLE)
+		return;
+
+	// Center x if requested
+	if (x < 0)
+		_videoStreams[videoHandle].x = (_vm->_system->getWidth() - _videoStreams[videoHandle]->getWidth()) / 2;
+
+	// Center y if requested
+	if (y < 0)
+		_videoStreams[videoHandle].y = (_vm->_system->getHeight() - _videoStreams[videoHandle]->getHeight()) / 2;
+}
+
+bool VideoManager::updateBackgroundMovies() {
+	bool updateScreen = false;
+
+	for (uint32 i = 0; i < _videoStreams.size() && !_vm->shouldQuit(); i++) {
+		// Skip deleted videos
+		if (!_videoStreams[i].video)
+			continue;
+
+		// Remove any videos that are over
+		if (_videoStreams[i]->endOfVideo()) {
+			if (_videoStreams[i].loop) {
+				_videoStreams[i]->rewind();
+			} else {
+				delete _videoStreams[i].video;
+				memset(&_videoStreams[i], 0, sizeof(VideoEntry));
+				_videoStreams[i].video = NULL;
+				continue;
+			}
+		}
+
+		// Check if we need to draw a frame
+		if (_videoStreams[i]->needsUpdate()) {
+			Graphics::Surface *frame = _videoStreams[i]->decodeNextFrame();
+			bool deleteFrame = false;
+
+			if (frame && _videoStreams[i].enabled) {
+				// 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 * 3];
+							byte g = palette[palIndex * 3 + 1];
+							byte b = palette[palIndex * 3 + 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;
+				}
+
+				// 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");
+
+		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) {
+			debug(1, "Play tMOV %d (non-blocking) at (%d, %d) %s", _mlstRecords[i].movieID, _mlstRecords[i].left, _mlstRecords[i].top, _mlstRecords[i].loop != 0 ? "looping" : "non-looping");
+			createVideoHandle(_mlstRecords[i].movieID, _mlstRecords[i].left, _mlstRecords[i].top, _mlstRecords[i].loop != 0);
+			return;
+		}
+}
+
+void VideoManager::playMovieBlocking(uint16 id) {
+	for (uint16 i = 0; i < _mlstRecords.size(); i++)
+		if (_mlstRecords[i].code == id) {
+			debug(1, "Play tMOV %d (blocking) at (%d, %d)", _mlstRecords[i].movieID, _mlstRecords[i].left, _mlstRecords[i].top);
+			VideoHandle videoHandle = createVideoHandle(_mlstRecords[i].movieID, _mlstRecords[i].left, _mlstRecords[i].top, false);
+			waitUntilMovieEnds(videoHandle);
+			return;
+		}
+}
+
+void VideoManager::stopMovie(uint16 id) {
+	debug(2, "Stopping movie %d", id);
+	for (uint16 i = 0; i < _mlstRecords.size(); i++)
+		if (_mlstRecords[i].code == id)
+			for (uint16 j = 0; j < _videoStreams.size(); j++)
+				if (_mlstRecords[i].movieID == _videoStreams[j].id) {
+					delete _videoStreams[i].video;
+					memset(&_videoStreams[i].video, 0, sizeof(VideoEntry));
+					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)
+			for (uint16 j = 0; j < _videoStreams.size(); j++)
+				if (_mlstRecords[i].movieID == _videoStreams[j].id) {
+					_videoStreams[j].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)
+			for (uint16 j = 0; j < _videoStreams.size(); j++)
+				if (_mlstRecords[i].movieID == _videoStreams[j].id) {
+					_videoStreams[j].enabled = false;
+					return;
+				}
+}
+
+void VideoManager::disableAllMovies() {
+	debug(2, "Disabling all movies");
+	for (uint16 i = 0; i < _videoStreams.size(); i++)
+		_videoStreams[i].enabled = false;
+}
+
+VideoHandle VideoManager::createVideoHandle(uint16 id, uint16 x, uint16 y, bool loop) {
+	// First, check to see if that video is already playing
+	for (uint32 i = 0; i < _videoStreams.size(); i++)
+		if (_videoStreams[i].id == id)
+			return i;
+
+	// Otherwise, create a new entry
+	VideoEntry entry;
+	entry.video = new Graphics::QuickTimeDecoder();
+	entry.x = x;
+	entry.y = y;
+	entry.filename = "";
+	entry.id = id;
+	entry.loop = loop;
+	entry.enabled = true;
+	entry->setChunkBeginOffset(_vm->getResourceOffset(ID_TMOV, id));
+	entry->load(*_vm->getRawData(ID_TMOV, id));
+
+	// Search for any deleted videos so we can take a formerly used slot
+	for (uint32 i = 0; i < _videoStreams.size(); i++)
+		if (!_videoStreams[i].video) {
+			_videoStreams[i] = entry;
+			return i;
+		}
+
+	// Otherwise, just add it to the list
+	_videoStreams.push_back(entry);
+	return _videoStreams.size() - 1;
+}
+
+VideoHandle VideoManager::createVideoHandle(Common::String filename, uint16 x, uint16 y, bool loop) {
+	// First, check to see if that video is already playing
+	for (uint32 i = 0; i < _videoStreams.size(); i++)
+		if (_videoStreams[i].filename == filename)
+			return i;
+
+	// Otherwise, create a new entry
+	VideoEntry entry;
+	entry.video = new Graphics::QuickTimeDecoder();
+	entry.x = x;
+	entry.y = y;
+	entry.filename = filename;
+	entry.id = 0;
+	entry.loop = loop;
+	entry.enabled = true;
+	
+	Common::File *file = new Common::File();
+	if (!file->open(filename)) {
+		delete file;
+		return NULL_VID_HANDLE;
+	}
+	
+	entry->load(*file);
+	
+	// Search for any deleted videos so we can take a formerly used slot
+	for (uint32 i = 0; i < _videoStreams.size(); i++)
+		if (!_videoStreams[i].video) {
+			_videoStreams[i] = entry;
+			return i;
+		}
+			
+	// Otherwise, just add it to the list
+	_videoStreams.push_back(entry);
+	return _videoStreams.size() - 1;
+}
+
+} // End of namespace Mohawk
diff --git a/engines/mohawk/video.h b/engines/mohawk/video.h
new file mode 100644
index 0000000000..8cfe1527fb
--- /dev/null
+++ b/engines/mohawk/video.h
@@ -0,0 +1,109 @@
+/* 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 "graphics/pixelformat.h"
+
+namespace Graphics {
+	class QuickTimeDecoder;
+}
+
+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;
+};
+
+struct VideoEntry {
+	Graphics::QuickTimeDecoder *video;
+	uint16 x;
+	uint16 y;
+	bool loop;
+	Common::String filename;
+	uint16 id; // Riven only
+	bool enabled;
+
+	Graphics::QuickTimeDecoder *operator->() const { assert(video); return video; }
+};
+
+typedef int32 VideoHandle;
+
+enum {
+	NULL_VID_HANDLE = -1
+};
+
+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 waitUntilMovieEnds(VideoHandle videoHandle);
+
+	// Keep tabs on any videos playing
+	Common::Array<VideoEntry> _videoStreams;
+
+	VideoHandle createVideoHandle(uint16 id, uint16 x, uint16 y, bool loop);
+	VideoHandle createVideoHandle(Common::String filename, uint16 x, uint16 y, bool loop);
+};
+
+} // End of namespace Mohawk
+
+#endif
diff --git a/engines/mohawk/video/cinepak.cpp b/engines/mohawk/video/cinepak.cpp
deleted file mode 100644
index 2ffe6869ae..0000000000
--- a/engines/mohawk/video/cinepak.cpp
+++ /dev/null
@@ -1,286 +0,0 @@
-/* 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::CPYUV2RGB(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;
-
-			// Chunk Size is 24-bit, ignore the first 4 bytes
-			uint32 chunkSize = stream->readByte() << 16;
-			chunkSize += stream->readUint16BE() - 4;
-
-			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;
-		}
-	}
-}
-
-} // End of namespace Mohawk
diff --git a/engines/mohawk/video/cinepak.h b/engines/mohawk/video/cinepak.h
deleted file mode 100644
index 3f4cbba17c..0000000000
--- a/engines/mohawk/video/cinepak.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/* 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);
-	Graphics::PixelFormat getPixelFormat() const { return _pixelFormat; }
-
-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
deleted file mode 100644
index b91440f00d..0000000000
--- a/engines/mohawk/video/qdm2.cpp
+++ /dev/null
@@ -1,3063 +0,0 @@
-/* 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;
-	}
-
-	in->read(_compressedData, _packetSize);
-	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
deleted file mode 100644
index ffa5f77030..0000000000
--- a/engines/mohawk/video/qdm2.h
+++ /dev/null
@@ -1,289 +0,0 @@
-/* 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/array.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
deleted file mode 100644
index f1c18db41c..0000000000
--- a/engines/mohawk/video/qdm2data.h
+++ /dev/null
@@ -1,531 +0,0 @@
-/* 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
deleted file mode 100644
index 0ed05bb84d..0000000000
--- a/engines/mohawk/video/qt_player.cpp
+++ /dev/null
@@ -1,1272 +0,0 @@
-/* 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/debug.h"
-#include "common/endian.h"
-#include "common/util.h"
-#include "common/zlib.h"
-
-// Audio codecs
-#include "sound/decoders/adpcm.h"
-#include "sound/decoders/raw.h"
-#include "mohawk/video/qdm2.h"
-
-// Video codecs
-#include "mohawk/jpeg.h"
-#include "mohawk/video/cinepak.h"
-#include "mohawk/video/qtrle.h"
-#include "mohawk/video/rpza.h"
-#include "mohawk/video/smc.h"
-
-namespace Mohawk {
-
-////////////////////////////////////////////
-// QTPlayer
-////////////////////////////////////////////
-
-QTPlayer::QTPlayer() : Graphics::VideoDecoder() {
-	_audStream = NULL;
-	_beginOffset = 0;
-	_videoCodec = NULL;
-	_curFrame = -1;
-	_startTime = _nextFrameStartTime = 0;
-	_audHandle = Audio::SoundHandle();
-	_numStreams = 0;
-	_fd = 0;
-	_scaledSurface = 0;
-	_dirtyPalette = false;
-}
-
-QTPlayer::~QTPlayer() {
-	close();
-}
-
-uint16 QTPlayer::getWidth() const {
-	if (_videoStreamIndex < 0)
-		return 0;
-
-	return _streams[_videoStreamIndex]->width / getScaleMode();
-}
-
-uint16 QTPlayer::getHeight() const {
-	if (_videoStreamIndex < 0)
-		return 0;
-
-	return _streams[_videoStreamIndex]->height / getScaleMode();
-}
-
-uint32 QTPlayer::getFrameCount() const {
-	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() const {
-	if (_videoStreamIndex < 0)
-		return kScaleNormal;
-
-	return (ScaleMode)(_scaleMode * _streams[_videoStreamIndex]->scaleMode);
-}
-
-uint32 QTPlayer::getFrameDuration() {
-	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 ((uint32)_curFrame < curFrameIndex) {
-			// Ok, now we have what duration this frame has.
-			return _streams[_videoStreamIndex]->stts_data[i].duration;
-		}
-	}
-
-	// This should never occur
-	error ("Cannot find duration for frame %d", _curFrame);
-	return 0;
-}
-
-Graphics::PixelFormat QTPlayer::getPixelFormat() const {
-	if (!_videoCodec)
-		return Graphics::PixelFormat::createFormatCLUT8();
-
-	return _videoCodec->getPixelFormat();
-}
-
-void QTPlayer::rewind() {
-	delete _videoCodec; _videoCodec = NULL;
-	_curFrame = -1;
-	_startTime = _nextFrameStartTime = 0;
-
-	// Restart the audio too
-	stopAudio();
-	if (_audioStreamIndex >= 0) {
-		_curAudioChunk = 0;
-		_audStream = Audio::makeQueuingAudioStream(_streams[_audioStreamIndex]->sample_rate, _streams[_audioStreamIndex]->channels == 2);
-	}
-	startAudio();
-}
-
-Graphics::Codec *QTPlayer::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 10th Anniversary videos.
-		return new JPEGDecoder(true);
-	} 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 QTPlayer::startAudio() {
-	if (_audStream) // No audio/audio not supported
-		g_system->getMixer()->playStream(Audio::Mixer::kPlainSoundType, &_audHandle, _audStream);
-}
-
-void QTPlayer::stopAudio() {
-	if (_audStream) {
-		g_system->getMixer()->stopHandle(_audHandle);
-		_audStream = NULL; // the mixer automatically frees the stream
-	}
-}
-
-void QTPlayer::pauseVideoIntern(bool pause) {
-	if (_audStream)
-		g_system->getMixer()->pauseHandle(_audHandle, pause);		
-}
-
-Graphics::Surface *QTPlayer::decodeNextFrame() {
-	if (!_videoCodec || _curFrame >= (int32)getFrameCount() - 1)
-		return NULL;
-
-	if (_startTime == 0)
-		_startTime = g_system->getMillis();
-
-	_curFrame++;
-	_nextFrameStartTime += getFrameDuration();
-
-	Common::SeekableReadStream *frameData = getNextFramePacket();
-
-	if (frameData) {
-		Graphics::Surface *frame = _videoCodec->decodeImage(frameData);
-		delete frameData;
-		return scaleSurface(frame);
-	}
-
-	return NULL;
-}
-
-Graphics::Surface *QTPlayer::scaleSurface(Graphics::Surface *frame) {
-	if (getScaleMode() == kScaleNormal)
-		return frame;
-
-	assert(_scaledSurface);
-
-	for (uint32 j = 0; j < _scaledSurface->h; j++)
-		for (uint32 k = 0; k < _scaledSurface->w; k++)
-			memcpy(_scaledSurface->getBasePtr(k, j), frame->getBasePtr(k * getScaleMode(), j * getScaleMode()), frame->bytesPerPixel);
-
-	return _scaledSurface;
-}
-
-bool QTPlayer::endOfVideo() const {
-	return (!_audStream || _audStream->endOfData()) && (!_videoCodec || _curFrame >= (int32)getFrameCount() - 1);
-}
-
-bool QTPlayer::needsUpdate() const {
-	return !endOfVideo() && getTimeToNextFrame() == 0;
-}
-
-uint32 QTPlayer::getElapsedTime() const {
-	if (_audStream)
-		return g_system->getMixer()->getSoundElapsedTime(_audHandle);
-
-	return g_system->getMillis() - _startTime;
-}
-
-uint32 QTPlayer::getTimeToNextFrame() const {
-	if (endOfVideo() || _curFrame < 0)
-		return 0;
-
-	// Convert from the Sega FILM base to 1000
-	uint32 nextFrameStartTime = _nextFrameStartTime * 1000 / _streams[_videoStreamIndex]->time_scale;
-	uint32 elapsedTime = getElapsedTime();
-
-	if (nextFrameStartTime <= elapsedTime)
-		return 0;
-
-	return nextFrameStartTime - elapsedTime;
-}
-
-bool QTPlayer::load(Common::SeekableReadStream &stream) {
-	_fd = &stream;
-	_foundMOOV = _foundMDAT = false;
-	_numStreams = 0;
-	_partial = 0;
-	_videoStreamIndex = _audioStreamIndex = -1;
-	_startTime = 0;
-
-	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 = Audio::makeQueuingAudioStream(_streams[_audioStreamIndex]->sample_rate, _streams[_audioStreamIndex]->channels == 2);
-		_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;
-
-		startAudio();
-	}
-
-	if (_videoStreamIndex >= 0) {
-		_videoCodec = createCodec(getCodecTag(), getBitsPerPixel());
-
-		if (getScaleMode() != kScaleNormal) {
-			// We have to initialize the scaled surface
-			_scaledSurface = new Graphics::Surface();
-			_scaledSurface->create(getWidth(), getHeight(), getPixelFormat().bytesPerPixel);
-		}
-	}
-
-	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, 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) {
-				_dirtyPalette = true;
-
-				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 * 3] = _palette[j * 3 + 1] = _palette[j * 3 + 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 * 3] = _fd->readByte();
-						_fd->readByte();
-						_palette[j * 3 + 1] = _fd->readByte();
-						_fd->readByte();
-						_palette[j * 3 + 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 (ones 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() - _beginOffset;
-	}
-
-	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::close() {
-	stopAudio();
-
-	delete _videoCodec; _videoCodec = 0;
-
-	for (uint32 i = 0; i < _numStreams; i++)
-		delete _streams[i];
-
-	delete _fd;
-
-	if (_scaledSurface) {
-		_scaledSurface->free();
-		delete _scaledSurface;
-		_scaledSurface = 0;
-	}
-
-	// The audio stream is deleted automatically
-	_audStream = NULL;
-
-	Graphics::VideoDecoder::reset();
-}
-
-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 = 0;
-		if (_streams[_audioStreamIndex]->codec_tag == MKID_BE('raw '))
-			flags |= Audio::FLAG_UNSIGNED;
-		if (_streams[_audioStreamIndex]->channels == 2)
-			flags |= Audio::FLAG_STEREO;
-		if (_streams[_audioStreamIndex]->bits_per_sample == 16)
-			flags |= Audio::FLAG_16BITS;
-		uint32 dataSize = stream->size();
-		byte *data = (byte *)malloc(dataSize);
-		stream->read(data, dataSize);
-		delete stream;
-		return Audio::makeRawStream(data, dataSize, _streams[_audioStreamIndex]->sample_rate, flags);
-	} else if (_streams[_audioStreamIndex]->codec_tag == MKID_BE('ima4')) {
-		// Riven uses this codec (as do some Myst ME videos)
-		return Audio::makeADPCMStream(stream, DisposeAfterUse::YES, 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->numQueuedStreams() < 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(), DisposeAfterUse::YES)));
-		delete wStream;
-	}
-}
-
-} // End of namespace Mohawk
diff --git a/engines/mohawk/video/qt_player.h b/engines/mohawk/video/qt_player.h
deleted file mode 100644
index 6657d3edba..0000000000
--- a/engines/mohawk/video/qt_player.h
+++ /dev/null
@@ -1,282 +0,0 @@
-/* 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/queue.h"
-
-#include "graphics/video/video_decoder.h"
-#include "graphics/video/codecs/codec.h"
-
-#include "sound/audiostream.h"
-#include "sound/mixer.h"
-
-namespace Common {
-	class File;
-}
-
-namespace Mohawk {
-
-enum ScaleMode {
-	kScaleNormal = 1,
-	kScaleHalf = 2,
-	kScaleQuarter = 4
-};
-
-class QTPlayer : public Graphics::RewindableVideoDecoder {
-public:
-	QTPlayer();
-	virtual ~QTPlayer();
-
-	/**
-	 * Returns the width of the video
-	 * @return the width of the video
-	 */
-	uint16 getWidth() const;
-
-	/**
-	 * Returns the height of the video
-	 * @return the height of the video
-	 */
-	uint16 getHeight() const;
-
-	/**
-	 * Returns the amount of frames in the video
-	 * @return the amount of frames in the video
-	 */
-	uint32 getFrameCount() const;
-
-	/**
-	 * Load a QuickTime video file from a SeekableReadStream
-	 * @param stream	the stream to load
-	 */
-	bool load(Common::SeekableReadStream &stream);
-
-	/**
-	 * Close a QuickTime encoded video file
-	 */
-	void close();
-
-	/**
-	 * Returns the palette of the video
-	 * @return the palette of the video
-	 */
-	byte *getPalette() { _dirtyPalette = false; return _palette; }
-	bool hasDirtyPalette() const { return _dirtyPalette; }
-
-	/**
-	 * Set the beginning offset of the video so we can modify the offsets in the stco
-	 * atom of videos inside the Mohawk archives
-	 * @param the beginning offset of the video
-	 */
-	void setChunkBeginOffset(uint32 offset) { _beginOffset = offset; }
-
-	bool isVideoLoaded() const { return _fd != 0; }
-	Graphics::Surface *decodeNextFrame();
-	bool needsUpdate() const;
-	bool endOfVideo() const;
-	uint32 getElapsedTime() const;
-	uint32 getTimeToNextFrame() const;
-	Graphics::PixelFormat getPixelFormat() const;
-
-	// RewindableVideoDecoder API
-	void rewind();
-
-	// TODO: This audio function need to be removed from the public and/or added to
-	// the VideoDecoder API directly. I plan on replacing this function with something
-	// that can figure out how much audio is needed instead of constantly keeping two
-	// chunks in memory.
-	void updateAudioBuffer();
-
-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 * 3];
-	bool _dirtyPalette;
-	uint32 _beginOffset;
-
-	void initParseTable();
-	Audio::AudioStream *createAudioStream(Common::SeekableReadStream *stream);
-	bool checkAudioCodecSupport(uint32 tag);
-	Common::SeekableReadStream *getNextFramePacket();
-	uint32 getFrameDuration();
-	uint32 getCodecTag();
-	byte getBitsPerPixel();
-
-	Audio::QueuingAudioStream *_audStream;
-	void startAudio();
-	void stopAudio();
-	int8 _audioStreamIndex;
-	uint _curAudioChunk;
-	Audio::SoundHandle _audHandle;
-
-	Graphics::Codec *createCodec(uint32 codecTag, byte bitsPerPixel);
-	Graphics::Codec *_videoCodec;
-	uint32 _nextFrameStartTime;
-	int8 _videoStreamIndex;
-
-	Graphics::Surface *_scaledSurface;
-	Graphics::Surface *scaleSurface(Graphics::Surface *frame);
-	ScaleMode getScaleMode() const;
-
-	void pauseVideoIntern(bool pause);
-
-	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
deleted file mode 100644
index c06dbefcb3..0000000000
--- a/engines/mohawk/video/qtrle.cpp
+++ /dev/null
@@ -1,420 +0,0 @@
-/* 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
deleted file mode 100644
index 2832bd6b24..0000000000
--- a/engines/mohawk/video/qtrle.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/* 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);
-	Graphics::PixelFormat getPixelFormat() const { return _pixelFormat; }
-
-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
deleted file mode 100644
index f48c055ae2..0000000000
--- a/engines/mohawk/video/rpza.cpp
+++ /dev/null
@@ -1,208 +0,0 @@
-/* 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
deleted file mode 100644
index c6d0ada6f5..0000000000
--- a/engines/mohawk/video/rpza.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/* 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);
-	Graphics::PixelFormat getPixelFormat() const { return _pixelFormat; }
-
-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
deleted file mode 100644
index 4a0d16dfcc..0000000000
--- a/engines/mohawk/video/smc.cpp
+++ /dev/null
@@ -1,385 +0,0 @@
-/* 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
deleted file mode 100644
index c52226100e..0000000000
--- a/engines/mohawk/video/smc.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/* 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);
-	Graphics::PixelFormat getPixelFormat() const { return Graphics::PixelFormat::createFormatCLUT8(); }
-
-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
deleted file mode 100644
index 86ecd4dedf..0000000000
--- a/engines/mohawk/video/video.cpp
+++ /dev/null
@@ -1,377 +0,0 @@
-/* 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/resource.h"
-#include "mohawk/video/video.h"
-#include "mohawk/video/qt_player.h"
-
-#include "common/events.h"
-
-namespace Mohawk {
-
-VideoManager::VideoManager(MohawkEngine* vm) : _vm(vm) {
-}
-
-VideoManager::~VideoManager() {
-	_mlstRecords.clear();
-	stopVideos();
-}
-
-void VideoManager::pauseVideos() {
-	for (uint16 i = 0; i < _videoStreams.size(); i++)
-		_videoStreams[i]->pauseVideo(true);
-}
-
-void VideoManager::resumeVideos() {
-	for (uint16 i = 0; i < _videoStreams.size(); i++)
-		_videoStreams[i]->pauseVideo(false);
-}
-
-void VideoManager::stopVideos() {
-	for (uint16 i = 0; i < _videoStreams.size(); i++)
-		delete _videoStreams[i].video;
-	_videoStreams.clear();
-}
-
-void VideoManager::playMovie(Common::String filename, uint16 x, uint16 y, bool clearScreen) {
-	VideoHandle videoHandle = createVideoHandle(filename, x, y, false);
-	if (videoHandle == NULL_VID_HANDLE)
-		return;
-
-	// Clear screen if requested
-	if (clearScreen) {
-		_vm->_system->fillScreen(_vm->_system->getScreenFormat().RGBToColor(0, 0, 0));
-		_vm->_system->updateScreen();
-	}
-
-	waitUntilMovieEnds(videoHandle);
-}
-
-void VideoManager::playMovieCentered(Common::String filename, bool clearScreen) {
-	VideoHandle videoHandle = createVideoHandle(filename, 0, 0, false);
-	if (videoHandle == NULL_VID_HANDLE)
-		return;
-
-	// Clear screen if requested
-	if (clearScreen) {
-		_vm->_system->fillScreen(_vm->_system->getScreenFormat().RGBToColor(0, 0, 0));
-		_vm->_system->updateScreen();
-	}
-
-	_videoStreams[videoHandle].x = (_vm->_system->getWidth() - _videoStreams[videoHandle]->getWidth()) / 2;
-	_videoStreams[videoHandle].y = (_vm->_system->getHeight() - _videoStreams[videoHandle]->getHeight()) / 2;
-
-	waitUntilMovieEnds(videoHandle);
-}
-
-void VideoManager::waitUntilMovieEnds(VideoHandle videoHandle) {
-	bool continuePlaying = true;
-
-	while (!_videoStreams[videoHandle]->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);
-	}
-
-	_videoStreams[videoHandle]->close();
-	_videoStreams.clear();
-}
-
-void VideoManager::playBackgroundMovie(Common::String filename, int16 x, int16 y, bool loop) {
-	VideoHandle videoHandle = createVideoHandle(filename, x, y, loop);
-	if (videoHandle == NULL_VID_HANDLE)
-		return;
-
-	// Center x if requested
-	if (x < 0)
-		_videoStreams[videoHandle].x = (_vm->_system->getWidth() - _videoStreams[videoHandle]->getWidth()) / 2;
-
-	// Center y if requested
-	if (y < 0)
-		_videoStreams[videoHandle].y = (_vm->_system->getHeight() - _videoStreams[videoHandle]->getHeight()) / 2;
-}
-
-bool VideoManager::updateBackgroundMovies() {
-	bool updateScreen = false;
-
-	for (uint32 i = 0; i < _videoStreams.size() && !_vm->shouldQuit(); i++) {
-		// Skip deleted videos
-		if (!_videoStreams[i].video)
-			continue;
-
-		// Remove any videos that are over
-		if (_videoStreams[i]->endOfVideo()) {
-			if (_videoStreams[i].loop) {
-				_videoStreams[i]->rewind();
-			} else {
-				delete _videoStreams[i].video;
-				memset(&_videoStreams[i], 0, sizeof(VideoEntry));
-				_videoStreams[i].video = NULL;
-				continue;
-			}
-		}
-
-		// Check if we need to draw a frame
-		if (_videoStreams[i]->needsUpdate()) {
-			Graphics::Surface *frame = _videoStreams[i]->decodeNextFrame();
-			bool deleteFrame = false;
-
-			if (frame && _videoStreams[i].enabled) {
-				// 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 * 3];
-							byte g = palette[palIndex * 3 + 1];
-							byte b = palette[palIndex * 3 + 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;
-				}
-
-				// 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");
-
-		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) {
-			debug(1, "Play tMOV %d (non-blocking) at (%d, %d) %s", _mlstRecords[i].movieID, _mlstRecords[i].left, _mlstRecords[i].top, _mlstRecords[i].loop != 0 ? "looping" : "non-looping");
-			createVideoHandle(_mlstRecords[i].movieID, _mlstRecords[i].left, _mlstRecords[i].top, _mlstRecords[i].loop != 0);
-			return;
-		}
-}
-
-void VideoManager::playMovieBlocking(uint16 id) {
-	for (uint16 i = 0; i < _mlstRecords.size(); i++)
-		if (_mlstRecords[i].code == id) {
-			debug(1, "Play tMOV %d (blocking) at (%d, %d)", _mlstRecords[i].movieID, _mlstRecords[i].left, _mlstRecords[i].top);
-			VideoHandle videoHandle = createVideoHandle(_mlstRecords[i].movieID, _mlstRecords[i].left, _mlstRecords[i].top, false);
-			waitUntilMovieEnds(videoHandle);
-			return;
-		}
-}
-
-void VideoManager::stopMovie(uint16 id) {
-	debug(2, "Stopping movie %d", id);
-	for (uint16 i = 0; i < _mlstRecords.size(); i++)
-		if (_mlstRecords[i].code == id)
-			for (uint16 j = 0; j < _videoStreams.size(); j++)
-				if (_mlstRecords[i].movieID == _videoStreams[j].id) {
-					delete _videoStreams[i].video;
-					memset(&_videoStreams[i].video, 0, sizeof(VideoEntry));
-					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)
-			for (uint16 j = 0; j < _videoStreams.size(); j++)
-				if (_mlstRecords[i].movieID == _videoStreams[j].id) {
-					_videoStreams[j].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)
-			for (uint16 j = 0; j < _videoStreams.size(); j++)
-				if (_mlstRecords[i].movieID == _videoStreams[j].id) {
-					_videoStreams[j].enabled = false;
-					return;
-				}
-}
-
-void VideoManager::disableAllMovies() {
-	debug(2, "Disabling all movies");
-	for (uint16 i = 0; i < _videoStreams.size(); i++)
-		_videoStreams[i].enabled = false;
-}
-
-VideoHandle VideoManager::createVideoHandle(uint16 id, uint16 x, uint16 y, bool loop) {
-	// First, check to see if that video is already playing
-	for (uint32 i = 0; i < _videoStreams.size(); i++)
-		if (_videoStreams[i].id == id)
-			return i;
-
-	// Otherwise, create a new entry
-	VideoEntry entry;
-	entry.video = new QTPlayer();
-	entry.x = x;
-	entry.y = y;
-	entry.filename = "";
-	entry.id = id;
-	entry.loop = loop;
-	entry.enabled = true;
-	entry->setChunkBeginOffset(_vm->getResourceOffset(ID_TMOV, id));
-	entry->load(*_vm->getRawData(ID_TMOV, id));
-
-	// Search for any deleted videos so we can take a formerly used slot
-	for (uint32 i = 0; i < _videoStreams.size(); i++)
-		if (!_videoStreams[i].video) {
-			_videoStreams[i] = entry;
-			return i;
-		}
-
-	// Otherwise, just add it to the list
-	_videoStreams.push_back(entry);
-	return _videoStreams.size() - 1;
-}
-
-VideoHandle VideoManager::createVideoHandle(Common::String filename, uint16 x, uint16 y, bool loop) {
-	// First, check to see if that video is already playing
-	for (uint32 i = 0; i < _videoStreams.size(); i++)
-		if (_videoStreams[i].filename == filename)
-			return i;
-
-	// Otherwise, create a new entry
-	VideoEntry entry;
-	entry.video = new QTPlayer();
-	entry.x = x;
-	entry.y = y;
-	entry.filename = filename;
-	entry.id = 0;
-	entry.loop = loop;
-	entry.enabled = true;
-	
-	Common::File *file = new Common::File();
-	if (!file->open(filename)) {
-		delete file;
-		return NULL_VID_HANDLE;
-	}
-	
-	entry->load(*file);
-	
-	// Search for any deleted videos so we can take a formerly used slot
-	for (uint32 i = 0; i < _videoStreams.size(); i++)
-		if (!_videoStreams[i].video) {
-			_videoStreams[i] = entry;
-			return i;
-		}
-			
-	// Otherwise, just add it to the list
-	_videoStreams.push_back(entry);
-	return _videoStreams.size() - 1;
-}
-
-} // End of namespace Mohawk
diff --git a/engines/mohawk/video/video.h b/engines/mohawk/video/video.h
deleted file mode 100644
index a5d2bde65d..0000000000
--- a/engines/mohawk/video/video.h
+++ /dev/null
@@ -1,107 +0,0 @@
-/* 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 "graphics/pixelformat.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;
-};
-
-class QTPlayer;
-
-struct VideoEntry {
-	QTPlayer *video;
-	uint16 x;
-	uint16 y;
-	bool loop;
-	Common::String filename;
-	uint16 id; // Riven only
-	bool enabled;
-
-	QTPlayer *operator->() const { assert(video); return video; }
-};
-
-typedef int32 VideoHandle;
-
-enum {
-	NULL_VID_HANDLE = -1
-};
-
-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 waitUntilMovieEnds(VideoHandle videoHandle);
-
-	// Keep tabs on any videos playing
-	Common::Array<VideoEntry> _videoStreams;
-
-	VideoHandle createVideoHandle(uint16 id, uint16 x, uint16 y, bool loop);
-	VideoHandle createVideoHandle(Common::String filename, uint16 x, uint16 y, bool loop);
-};
-
-} // End of namespace Mohawk
-
-#endif
-- 
cgit v1.2.3