Merge the gsoc2009-mods branch into trunk (along with some svn:mergeinfo property removals).

svn-id: r43703

27 files changed, 3632 insertions, 95 deletions

diff --git a/README b/README
index 3b2e827cd3..e1f37417df 100644
--- a/README
+++ b/README
@@ -779,7 +779,7 @@ site, please see the section on reporting bugs.
       original game.
 
   The Legend of Kyrandia:
-    - No music or sound effects in the Amiga and Macintosh floppy versions.
+    - No music or sound effects in the Macintosh floppy versions.
     - Macintosh CD is using included DOS music and sound effects.
     - PC-9821 version lacks support for sound effects.
 
diff --git a/engines/kyra/kyra_lok.cpp b/engines/kyra/kyra_lok.cpp
index 36f134d9e4..fc19b2fb65 100644
--- a/engines/kyra/kyra_lok.cpp
+++ b/engines/kyra/kyra_lok.cpp
@@ -183,8 +183,13 @@ Common::Error KyraEngine_LoK::init() {
 
 	_sound->setSoundList(&_soundData[kMusicIntro]);
 
-	_trackMap = _dosTrackMap;
-	_trackMapSize = _dosTrackMapSize;
+	if (_flags.platform == Common::kPlatformAmiga) {
+		_trackMap = _amigaTrackMap;
+		_trackMapSize = _amigaTrackMapSize;
+	} else {
+		_trackMap = _dosTrackMap;
+		_trackMapSize = _dosTrackMapSize;
+	}
 
 	if (!_sound->init())
 		error("Couldn't init sound");
diff --git a/engines/kyra/kyra_lok.h b/engines/kyra/kyra_lok.h
index e7cc92c5e1..5d20cb0652 100644
--- a/engines/kyra/kyra_lok.h
+++ b/engines/kyra/kyra_lok.h
@@ -507,6 +507,9 @@ protected:
 	static const int8 _dosTrackMap[];
 	static const int _dosTrackMapSize;
 
+	static const int8 _amigaTrackMap[];
+	static const int _amigaTrackMapSize;
+
 	// TODO: get rid of all variables having pointers to the static resources if possible
 	// i.e. let them directly use the _staticres functions
 	void initStaticResource();
diff --git a/engines/kyra/kyra_v1.cpp b/engines/kyra/kyra_v1.cpp
index d8e91b138d..cf2b360d79 100644
--- a/engines/kyra/kyra_v1.cpp
+++ b/engines/kyra/kyra_v1.cpp
@@ -50,7 +50,10 @@ KyraEngine_v1::KyraEngine_v1(OSystem *system, const GameFlags &flags)
 	_emc = 0;
 	_debugger = 0;
 
-	_gameSpeed = 60;
+	if (_flags.platform == Common::kPlatformAmiga)
+		_gameSpeed = 50;
+	else
+		_gameSpeed = 60;
 	_tickLength = (uint8)(1000.0 / _gameSpeed);
 
 	_trackMap = 0;
@@ -114,6 +117,8 @@ Common::Error KyraEngine_v1::init() {
 				_sound = new SoundPC98(this, _mixer);
 			else
 				_sound = new SoundTownsPC98_v2(this, _mixer);
+		} else if (_flags.platform == Common::kPlatformAmiga) {
+			_sound = new SoundAmiga(this, _mixer);
 		} else if (midiDriver == MD_ADLIB) {
 			_sound = new SoundAdlibPC(this, _mixer);
 		} else {
diff --git a/engines/kyra/module.mk b/engines/kyra/module.mk
index 7b0c0dfb68..b484fa345f 100644
--- a/engines/kyra/module.mk
+++ b/engines/kyra/module.mk
@@ -50,6 +50,7 @@ MODULE_OBJS := \
 	sequences_hof.o \
 	sequences_mr.o \
 	sound_adlib.o \
+	sound_amiga.o \
 	sound_digital.o \
 	sound_midi.o \
 	sound_pcspk.o \
diff --git a/engines/kyra/seqplayer.cpp b/engines/kyra/seqplayer.cpp
index 38d1b90e7a..4086d06c00 100644
--- a/engines/kyra/seqplayer.cpp
+++ b/engines/kyra/seqplayer.cpp
@@ -414,8 +414,6 @@ void SeqPlayer::s1_fillRect() {
 
 void SeqPlayer::s1_playEffect() {
 	uint8 track = *_seqData++;
-	if (_vm->gameFlags().platform == Common::kPlatformAmiga)
-		return;
 	_vm->delay(3 * _vm->tickLength());
 	_sound->playSoundEffect(track);
 }
@@ -423,9 +421,6 @@ void SeqPlayer::s1_playEffect() {
 void SeqPlayer::s1_playTrack() {
 	uint8 msg = *_seqData++;
 
-	if (_vm->gameFlags().platform == Common::kPlatformAmiga)
-		return;
-
 	if (msg == 1) {
 		_sound->beginFadeOut();
 	} else {
diff --git a/engines/kyra/sequences_lok.cpp b/engines/kyra/sequences_lok.cpp
index d13dc2d291..16c9b75f3a 100644
--- a/engines/kyra/sequences_lok.cpp
+++ b/engines/kyra/sequences_lok.cpp
@@ -110,7 +110,7 @@ void KyraEngine_LoK::seq_intro() {
 
 	_seq->setCopyViewOffs(true);
 	_screen->setFont(Screen::FID_8_FNT);
-	if (_flags.platform != Common::kPlatformFMTowns && _flags.platform != Common::kPlatformPC98)
+	if (_flags.platform != Common::kPlatformFMTowns && _flags.platform != Common::kPlatformPC98 && _flags.platform != Common::kPlatformAmiga)
 		snd_playTheme(0, 2);
 	_text->setTalkCoords(144);
 
@@ -994,6 +994,14 @@ int KyraEngine_LoK::seq_playEnd() {
 		snd_playWanderScoreViaMap(50, 1);
 		setupPanPages();
 
+		if (_flags.platform == Common::kPlatformAmiga) {
+			_sound->loadSoundFile(kMusicFinale);
+
+			// The original started song 0 directly here. Since our player
+			// uses 0, 1 for stop and fade we start song 0 with 2
+			_sound->playTrack(2);
+		}
+
 		_finalA = createWSAMovie();
 		assert(_finalA);
 		_finalA->open("finala.wsa", 1, 0);
diff --git a/engines/kyra/sound.cpp b/engines/kyra/sound.cpp
index 91945d91ee..781516282e 100644
--- a/engines/kyra/sound.cpp
+++ b/engines/kyra/sound.cpp
@@ -215,6 +215,13 @@ void KyraEngine_v1::snd_playWanderScoreViaMap(int command, int restart) {
 				_sound->playTrack(command);
 			}
 		}
+	} else if (_flags.platform == Common::kPlatformAmiga) {
+		if (_curMusicTheme != 1)
+			snd_playTheme(1, -1);
+
+		assert(command < _trackMapSize);
+		if (_trackMap[_lastMusicCommand] != _trackMap[command])
+			_sound->playTrack(_trackMap[command]);
 	}
 
 	_lastMusicCommand = command;
diff --git a/engines/kyra/sound.h b/engines/kyra/sound.h
index 263cd586f7..2f24a264f1 100644
--- a/engines/kyra/sound.h
+++ b/engines/kyra/sound.h
@@ -55,7 +55,8 @@ public:
 		kMidiGM,
 		kTowns,
 		kPC98,
-		kPCSpkr
+		kPCSpkr,
+		kAmiga
 	};
 
 	virtual kType getMusicType() const = 0;
diff --git a/engines/kyra/sound_amiga.cpp b/engines/kyra/sound_amiga.cpp
new file mode 100644
index 0000000000..0b64e67525
--- /dev/null
+++ b/engines/kyra/sound_amiga.cpp
@@ -0,0 +1,239 @@
+/* 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 "common/mutex.h"
+#include "kyra/resource.h"
+#include "kyra/sound_intern.h"
+
+#include "sound/mixer.h"
+#include "sound/mods/maxtrax.h"
+#include "sound/audiostream.h"
+
+namespace {
+
+FORCEINLINE uint8 sfxTableGetNote(const byte* address) {
+	return (uint8)address[0];
+}
+FORCEINLINE uint8 sfxTableGetPatch(const byte* address) {
+	return (uint8)address[1];
+}
+FORCEINLINE uint16 sfxTableGetDuration(const byte* address) {
+	return READ_BE_UINT16(&address[4]);
+}
+FORCEINLINE int8 sfxTableGetVolume(const byte* address) {
+	return (int8)address[6];
+}
+FORCEINLINE int8 sfxTableGetPan(const byte* address) {
+	return (int8)address[7];
+}
+
+} // end of namespace
+
+namespace Kyra {
+
+SoundAmiga::SoundAmiga(KyraEngine_v1 *vm, Audio::Mixer *mixer)
+	: Sound(vm, mixer),
+	  _driver(0),
+	  _musicHandle(),
+	  _fileLoaded(kFileNone),
+	  _tableSfxIntro(),
+	  _tableSfxGame() {
+}
+
+SoundAmiga::~SoundAmiga() {
+	_mixer->stopHandle(_musicHandle);
+	delete _driver;
+}
+
+extern const byte LoKAmigaSfxIntro[];
+extern const byte LoKAmigaSfxGame[];
+
+bool SoundAmiga::init() {
+	_driver = new Audio::MaxTrax(_mixer->getOutputRate(), true);
+	_tableSfxIntro = LoKAmigaSfxIntro;
+	_tableSfxGame = LoKAmigaSfxGame;
+
+	return _driver != 0 && _tableSfxIntro && _tableSfxGame;
+}
+
+void SoundAmiga::loadSoundFile(uint file) {
+	debugC(5, kDebugLevelSound, "SoundAmiga::loadSoundFile(%d)", file);
+
+	static const char *const tableFilenames[3][2] = {
+		{ "introscr.mx",  "introinst.mx" },
+		{ "kyramusic.mx", 0 },
+		{ "finalescr.mx", "introinst.mx" }
+	};
+	assert(file < ARRAYSIZE(tableFilenames));
+	if (_fileLoaded == (FileType)file)
+		return;
+	const char* scoreName = tableFilenames[file][0];
+	const char* sampleName = tableFilenames[file][1];
+	bool loaded = false;
+
+	Common::SeekableReadStream *scoreIn = _vm->resource()->createReadStream(scoreName);
+	if (sampleName) {
+		Common::SeekableReadStream *sampleIn = _vm->resource()->createReadStream(sampleName);
+		if (scoreIn && sampleIn) {
+			_fileLoaded = kFileNone;
+			loaded = _driver->load(*scoreIn, true, false);
+			loaded = loaded && _driver->load(*sampleIn, false, true);
+		} else
+			warning("SoundAmiga: missing atleast one of those music files: %s, %s", scoreName, sampleName);
+		delete sampleIn;
+	} else {
+		if (scoreIn) {
+			_fileLoaded = kFileNone;
+			loaded = _driver->load(*scoreIn);
+		} else
+			warning("SoundAmiga: missing music file: %s", scoreName);
+	}
+	delete scoreIn;
+
+	if (loaded)
+		_fileLoaded = (FileType)file;
+}
+
+void SoundAmiga::playTrack(uint8 track) {
+	debugC(5, kDebugLevelSound, "SoundAmiga::playTrack(%d)", track);
+
+	static const byte tempoIntro[] = { 0x46, 0x55, 0x3C, 0x41 };
+	static const byte tempoFinal[] = { 0x78, 0x50 };
+	static const byte tempoIngame[] = {
+		0x64, 0x64, 0x64, 0x64, 0x64, 0x73, 0x4B, 0x64,
+		0x64, 0x64, 0x55, 0x9C, 0x6E, 0x91, 0x78, 0x84,
+		0x32, 0x64, 0x64, 0x6E, 0x3C, 0xD8, 0xAF
+	};
+	static const byte loopIngame[] = {
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01,
+		0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00
+	};
+
+	int score = -1;
+	bool loop = false;
+	byte volume = 0x40;
+	byte tempo = 0;
+
+
+	switch (_fileLoaded) {
+	case kFileIntro:
+		if (track >= 2 && track < ARRAYSIZE(tempoIntro) + 2) {
+			score = track - 2;
+			tempo = tempoIntro[score];
+		}
+		break;
+
+	case kFileGame:
+		if (track >= 11 && track < ARRAYSIZE(tempoIngame) + 11) {
+			score = track - 11;
+			loop = loopIngame[score] != 0;
+			tempo = tempoIngame[score];
+		}
+		break;
+
+	case kFileFinal:
+		// score 0 gets started immediately after loading the music-files with different tempo.
+		// we need to define a track-value for the fake call of this function
+		if (track >= 2 && track < ARRAYSIZE(tempoFinal) + 2) {
+			score = track - 2;
+			loop = true;
+			tempo = tempoFinal[score];
+		}
+		break;
+
+	default:
+		return;
+	}
+
+	if (score >= 0) {
+		if (_musicEnabled && _driver->playSong(score, loop)) {
+			_driver->setVolume(volume);
+			_driver->setTempo(tempo << 4);
+			if (!_mixer->isSoundHandleActive(_musicHandle))
+				_mixer->playInputStream(Audio::Mixer::kPlainSoundType, &_musicHandle, _driver, -1, Audio::Mixer::kMaxChannelVolume, 0, false);
+		}
+	} else if (track == 0)
+		_driver->stopMusic();
+	else if (track == 1)
+		beginFadeOut();
+}
+
+void SoundAmiga::haltTrack() {
+	debugC(5, kDebugLevelSound, "SoundAmiga::haltTrack()");
+	_driver->stopMusic();
+}
+
+void SoundAmiga::beginFadeOut() {
+	debugC(5, kDebugLevelSound, "SoundAmiga::beginFadeOut()");
+	for (int i = 0x3F; i >= 0; --i) {
+		_driver->setVolume((byte)i);
+		_vm->delay(_vm->tickLength());
+	}
+
+	_driver->stopMusic();
+	_vm->delay(_vm->tickLength());
+	_driver->setVolume(0x40);
+}
+
+void SoundAmiga::playSoundEffect(uint8 track) {
+	debugC(5, kDebugLevelSound, "SoundAmiga::playSoundEffect(%d)", track);
+	const byte* tableEntry = 0;
+	bool pan = false;
+
+	switch (_fileLoaded) {
+	case kFileFinal:
+	case kFileIntro:
+		// We only allow playing of sound effects, which are included in the table.
+		if (track < 40) {
+			tableEntry = &_tableSfxIntro[track * 8];
+			pan = (sfxTableGetPan(tableEntry) != 0);
+		}
+		break;
+
+	case kFileGame:
+		if (0x61 <= track && track <= 0x63)
+			playTrack(track - 0x4F);
+
+		assert(track < 120);
+		if (sfxTableGetNote(&_tableSfxGame[track * 8])) { 
+			tableEntry = &_tableSfxGame[track * 8];
+			pan = (sfxTableGetPan(tableEntry) != 0) && (sfxTableGetPan(tableEntry) != 2);
+		}
+		break;
+	default:
+		;
+	}
+
+	if (_sfxEnabled && tableEntry) {
+		const bool success = _driver->playNote(sfxTableGetNote(tableEntry), sfxTableGetPatch(tableEntry), sfxTableGetDuration(tableEntry), sfxTableGetVolume(tableEntry), pan);
+		if (success && !_mixer->isSoundHandleActive(_musicHandle))
+			_mixer->playInputStream(Audio::Mixer::kPlainSoundType, &_musicHandle, _driver, -1, Audio::Mixer::kMaxChannelVolume, 0, false);
+	}
+}
+
+} // end of namespace Kyra
+
diff --git a/engines/kyra/sound_intern.h b/engines/kyra/sound_intern.h
index 975672b76a..b85b8a2e30 100644
--- a/engines/kyra/sound_intern.h
+++ b/engines/kyra/sound_intern.h
@@ -37,6 +37,7 @@
 
 namespace Audio {
 class PCSpeaker;
+class MaxTrax;
 } // end of namespace Audio
 
 namespace Kyra {
@@ -284,7 +285,34 @@ private:
 	static const uint8 _noteTable2[];
 };
 
+class SoundAmiga : public Sound {
+public:
+	SoundAmiga(KyraEngine_v1 *vm, Audio::Mixer *mixer);
+	~SoundAmiga();
+
+	virtual kType getMusicType() const { return kAmiga; } //FIXME
+
+	bool init();
+
+	void process() {}
+	void loadSoundFile(uint file);
+	void loadSoundFile(Common::String) {}
+
+	void playTrack(uint8 track);
+	void haltTrack();
+	void beginFadeOut();
+
+	int32 voicePlay(const char *file, Audio::SoundHandle *handle, uint8 volume, bool isSfx) { return -1; }
+	void playSoundEffect(uint8);
+
+protected:
+	Audio::MaxTrax *_driver;
+	Audio::SoundHandle _musicHandle;
+	enum FileType { kFileNone = -1, kFileIntro = 0, kFileGame = 1, kFileFinal = 2 } _fileLoaded;
+	const byte *_tableSfxIntro;
+	const byte *_tableSfxGame;
+};
+
 } // end of namespace Kyra
 
 #endif
-
diff --git a/engines/kyra/staticres.cpp b/engines/kyra/staticres.cpp
index 4f3824479d..be73df47f7 100644
--- a/engines/kyra/staticres.cpp
+++ b/engines/kyra/staticres.cpp
@@ -2356,6 +2356,18 @@ const int8 KyraEngine_LoK::_dosTrackMap[] = {
 
 const int KyraEngine_LoK::_dosTrackMapSize = ARRAYSIZE(KyraEngine_LoK::_dosTrackMap);
 
+const int8 KyraEngine_LoK::_amigaTrackMap[] = {
+	 0,  1, 32, 26, 31, 30, 33, 33,
+	32, 17, 27, 32, 25, 29, 25, 24,
+	23, 26, 26, 30, 28, 21, 21, 15,
+	 3, 15, 23, 25, 33, 21, 30, 22,
+	15,  3, 33, 11, 12, 13, 14, 22,
+	22, 22,  3,  3,  3, 23,  3,  3,
+	23,  3,  3,  3,  3,  3,  3, 33
+};
+
+const int KyraEngine_LoK::_amigaTrackMapSize = ARRAYSIZE(KyraEngine_LoK::_amigaTrackMap);
+
 // kyra engine v2 static data
 
 const int GUI_v2::_sliderBarsPosition[] = {
@@ -3378,4 +3390,172 @@ const int LoLEngine::_outroMonsterScaleTableY[] = {
 
 #endif // ENABLE_LOL
 
+// TODO: fileoffset = 0x32D5C, len = 40 * 8
+extern const byte LoKAmigaSfxIntro[] = {
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x3C, 0x19, 0x00, 0x00, 0x25, 0x2C, 0x6E, 0x00,
+	0x3C, 0x19, 0x00, 0x00, 0x25, 0x2C, 0x6E, 0x00,
+	0x3C, 0x19, 0x00, 0x00, 0x25, 0x2C, 0x6E, 0x00,
+	0x3C, 0x13, 0x00, 0x00, 0x1B, 0x91, 0x6E, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x3C, 0x16, 0x00, 0x00, 0x26, 0x77, 0x6E, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x3C, 0x17, 0x00, 0x00, 0x11, 0x98, 0x6E, 0x00,
+	0x3C, 0x19, 0x00, 0x00, 0x25, 0x2C, 0x6E, 0x00,
+	0x3C, 0x18, 0x00, 0x00, 0x22, 0xD1, 0x6E, 0x00,
+	0x3C, 0x19, 0x00, 0x00, 0x25, 0x2C, 0x6E, 0x00,
+	0x45, 0x03, 0x00, 0x00, 0x02, 0x24, 0x6E, 0x00,
+	0x3C, 0x16, 0x00, 0x00, 0x26, 0x77, 0x6E, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+// TODO: fileoffset = 0x2C55E, len = 120 * 8
+extern const byte LoKAmigaSfxGame[] = {
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x3C, 0x13, 0x00, 0x00, 0x01, 0x56, 0x78, 0x02,
+	0x3C, 0x14, 0x00, 0x00, 0x27, 0x2C, 0x78, 0x02,
+	0x3C, 0x15, 0x00, 0x00, 0x1B, 0x91, 0x78, 0x02,
+	0x3C, 0x16, 0x00, 0x00, 0x1E, 0x97, 0x78, 0x02,
+	0x3C, 0x17, 0x00, 0x00, 0x12, 0x2B, 0x78, 0x02,
+	0x3C, 0x16, 0x00, 0x00, 0x1E, 0x97, 0x78, 0x02,
+	0x45, 0x03, 0x00, 0x00, 0x02, 0x24, 0x78, 0x02,
+	0x3C, 0x16, 0x00, 0x00, 0x1E, 0x97, 0x78, 0x02,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x3C, 0x19, 0x00, 0x00, 0x25, 0x2C, 0x78, 0x02,
+	0x2C, 0x04, 0x00, 0x00, 0x09, 0x10, 0x78, 0x02,
+	0x3C, 0x19, 0x00, 0x00, 0x25, 0x2C, 0x78, 0x02,
+	0x3C, 0x1A, 0x00, 0x00, 0x3A, 0xEB, 0x78, 0x02,
+	0x25, 0x1B, 0x00, 0x00, 0x13, 0x8B, 0x78, 0x02,
+	0x18, 0x03, 0x00, 0x00, 0x0F, 0x52, 0x78, 0x02,
+	0x3E, 0x1C, 0x00, 0x00, 0x06, 0x22, 0x78, 0x02,
+	0x3B, 0x1C, 0x00, 0x00, 0x07, 0x54, 0x78, 0x02,
+	0x16, 0x03, 0x00, 0x00, 0x20, 0x6F, 0x78, 0x02,
+	0x3C, 0x19, 0x00, 0x00, 0x25, 0x2C, 0x78, 0x02,
+	0x3C, 0x1D, 0x00, 0x00, 0x09, 0xEA, 0x78, 0x02,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x3C, 0x14, 0x00, 0x00, 0x27, 0x2C, 0x78, 0x02,
+	0x3C, 0x1E, 0x00, 0x00, 0x03, 0x6E, 0x78, 0x02,
+	0x3C, 0x17, 0x00, 0x00, 0x12, 0x2B, 0x78, 0x02,
+	0x4E, 0x0B, 0x00, 0x00, 0x09, 0x91, 0x78, 0x02,
+	0x47, 0x1B, 0x00, 0x00, 0x02, 0xBC, 0x78, 0x02,
+	0x4C, 0x1B, 0x00, 0x00, 0x02, 0x11, 0x78, 0x02,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x3C, 0x13, 0x00, 0x00, 0x01, 0x56, 0x78, 0x02,
+	0x3C, 0x13, 0x00, 0x00, 0x01, 0x56, 0x78, 0x02,
+	0x3C, 0x1F, 0x00, 0x00, 0x0E, 0x9E, 0x78, 0x02,
+	0x3C, 0x20, 0x00, 0x00, 0x01, 0x0C, 0x78, 0x02,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x3C, 0x19, 0x00, 0x00, 0x25, 0x2C, 0x78, 0x02,
+	0x3C, 0x21, 0x00, 0x00, 0x0F, 0x7C, 0x78, 0x02,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x2A, 0x0B, 0x00, 0x00, 0x4C, 0x47, 0x78, 0x02,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x3C, 0x1B, 0x00, 0x00, 0x05, 0x28, 0x78, 0x02,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x2C, 0x04, 0x00, 0x00, 0x09, 0x10, 0x78, 0x02,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x3C, 0x22, 0x00, 0x00, 0x0A, 0xEE, 0x78, 0x02,
+	0x3C, 0x16, 0x00, 0x00, 0x1E, 0x97, 0x78, 0x02,
+	0x3C, 0x15, 0x00, 0x00, 0x1B, 0x91, 0x78, 0x02,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x3C, 0x14, 0x00, 0x00, 0x27, 0x2C, 0x78, 0x02,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x3C, 0x22, 0x00, 0x00, 0x0A, 0xEE, 0x78, 0x02,
+	0x3C, 0x14, 0x00, 0x00, 0x27, 0x2C, 0x78, 0x02,
+	0x32, 0x23, 0x00, 0x00, 0x14, 0x19, 0x9C, 0x02,
+	0x3C, 0x19, 0x00, 0x00, 0x17, 0x1C, 0x78, 0x02,
+	0x3C, 0x14, 0x00, 0x00, 0x27, 0x2C, 0x78, 0x02,
+	0x3E, 0x1C, 0x00, 0x00, 0x06, 0x22, 0x78, 0x02,
+	0x43, 0x13, 0x00, 0x00, 0x02, 0x01, 0x78, 0x02,
+	0x3C, 0x24, 0x00, 0x00, 0x12, 0x43, 0x5A, 0x02,
+	0x3E, 0x20, 0x00, 0x00, 0x00, 0xEE, 0x78, 0x02,
+	0x3C, 0x19, 0x00, 0x00, 0x25, 0x2C, 0x78, 0x02,
+	0x29, 0x04, 0x00, 0x00, 0x19, 0xEA, 0x78, 0x02,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x3C, 0x20, 0x00, 0x00, 0x01, 0x0C, 0x78, 0x02,
+	0x3C, 0x25, 0x00, 0x00, 0x30, 0xB6, 0x78, 0x02,
+	0x3C, 0x19, 0x00, 0x00, 0x25, 0x2C, 0x78, 0x02,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x3C, 0x16, 0x00, 0x00, 0x1E, 0x97, 0x78, 0x02,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x3C, 0x1A, 0x00, 0x00, 0x3A, 0xEB, 0x78, 0x02,
+	0x1B, 0x04, 0x00, 0x00, 0x39, 0xF3, 0x78, 0x02,
+	0x30, 0x23, 0x00, 0x00, 0x16, 0x99, 0x50, 0x02,
+	0x3C, 0x15, 0x00, 0x00, 0x1B, 0x91, 0x78, 0x02,
+	0x29, 0x06, 0x00, 0x00, 0x19, 0xEA, 0x50, 0x02,
+	0x3C, 0x19, 0x00, 0x00, 0x25, 0x2C, 0x78, 0x02,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x3C, 0x1A, 0x00, 0x00, 0x3A, 0xEB, 0x78, 0x02,
+	0x3C, 0x19, 0x00, 0x00, 0x25, 0x2C, 0x78, 0x02,
+	0x3C, 0x26, 0x00, 0x00, 0x07, 0x13, 0x78, 0x02,
+	0x3C, 0x26, 0x00, 0x00, 0x07, 0x13, 0x78, 0x02,
+	0x3C, 0x14, 0x00, 0x00, 0x27, 0x2C, 0x78, 0x02,
+	0x30, 0x23, 0x00, 0x00, 0x16, 0x99, 0x50, 0x02,
+	0x30, 0x23, 0x00, 0x00, 0x16, 0x99, 0x50, 0x02,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x3C, 0x13, 0x00, 0x00, 0x01, 0x56, 0x78, 0x02
+};
+
 } // End of namespace Kyra
diff --git a/engines/scumm/module.mk b/engines/scumm/module.mk
index 58d8db91fc..51fbecdb0d 100644
--- a/engines/scumm/module.mk
+++ b/engines/scumm/module.mk
@@ -40,6 +40,7 @@ MODULE_OBJS := \
 	player_v2a.o \
 	player_v2cms.o \
 	player_v3a.o \
+	player_v4a.o \
 	resource_v2.o \
 	resource_v3.o \
 	resource_v4.o \
diff --git a/engines/scumm/music.h b/engines/scumm/music.h
index c6555318a9..2fd7c50bce 100644
--- a/engines/scumm/music.h
+++ b/engines/scumm/music.h
@@ -81,12 +81,6 @@ public:
 	 * @return the music timer
 	 */
 	virtual int  getMusicTimer() const { return 0; }
-
-	/**
-	 * Terminate the music engine. Called just before the music engine
-	 * is deleted.
-	 */
-	virtual void terminate() {}
 };
 
 } // End of namespace Scumm
diff --git a/engines/scumm/player_v4a.cpp b/engines/scumm/player_v4a.cpp
new file mode 100644
index 0000000000..f441b3b364
--- /dev/null
+++ b/engines/scumm/player_v4a.cpp
@@ -0,0 +1,193 @@
+/* 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 "engines/engine.h"
+#include "scumm/player_v4a.h"
+#include "scumm/scumm.h"
+
+#include "common/file.h"
+
+namespace Scumm {
+
+Player_V4A::Player_V4A(ScummEngine *scumm, Audio::Mixer *mixer)
+	: _vm(scumm),
+	  _mixer(mixer),
+	  _tfmxMusic(_mixer->getOutputRate(), true),
+	  _tfmxSfx(_mixer->getOutputRate(), true),
+	  _musicHandle(),
+	  _sfxHandle(),
+	  _musicId(),
+	  _sfxSlots(),
+	  _initState(0),
+	  _signal(0) {
+
+	assert(scumm);
+	assert(mixer);
+	assert(_vm->_game.id == GID_MONKEY_VGA);
+	_tfmxMusic.setSignalPtr(&_signal, 1);
+}
+
+bool Player_V4A::init() {
+	if (_vm->_game.id != GID_MONKEY_VGA)
+		error("player_v4a - unknown game");
+	
+	Common::File fileMdat, fileSample;
+
+	if (fileMdat.open("music.dat") && fileSample.open("sample.dat")) {
+		// explicitly request that no instance delets the resources automatically
+		if (_tfmxMusic.load(fileMdat, fileSample, false)) {
+			_tfmxSfx.setModuleData(_tfmxMusic);
+			return true;
+		}
+	} else
+		warning("player_v4a: couldnt load one of the music resources: music.dat, sample.dat");
+	
+	return false;
+}
+
+Player_V4A::~Player_V4A() {
+	_mixer->stopHandle(_musicHandle);
+	_mixer->stopHandle(_sfxHandle);
+	_tfmxMusic.freeResources();
+}
+
+void Player_V4A::setMusicVolume(int vol) {
+	debug(5, "player_v4a: setMusicVolume %i", vol);
+}
+
+void Player_V4A::stopAllSounds() {
+	debug(5, "player_v4a: stopAllSounds");
+	if (_initState > 0) {
+		_tfmxMusic.stopSong();
+		_signal = 0;		
+		_musicId = 0;
+
+		_tfmxSfx.stopSong();
+		clearSfxSlots();
+	} else
+		_mixer->stopHandle(_musicHandle);
+}
+
+void Player_V4A::stopSound(int nr) {
+	debug(5, "player_v4a: stopSound %d", nr);
+	if (nr == 0)
+		return;
+	if (nr == _musicId) {
+		_musicId = 0;
+		if (_initState > 0)
+			_tfmxMusic.stopSong();
+		else
+			_mixer->stopHandle(_musicHandle);
+		_signal = 0;
+	} else {
+		const int chan = getSfxChan(nr);
+		if (chan != -1) {
+			setSfxSlot(chan, 0);
+			_tfmxSfx.stopMacroEffect(chan);
+		}
+	}
+}
+
+void Player_V4A::startSound(int nr) {
+	static const int8 monkeyCommands[52] = {
+		 -1,  -2,  -3,  -4,  -5,  -6,  -7,  -8,
+		 -9, -10, -11, -12, -13, -14,  18,  17,
+		-17, -18, -19, -20, -21, -22, -23, -24,
+		-25, -26, -27, -28, -29, -30, -31, -32,
+		-33,  16, -35,   0,   1,   2,   3,   7,
+		  8,  10,  11,   4,   5,  14,  15,  12,
+		  6,  13,   9,  19
+	};
+
+	const byte *ptr = _vm->getResourceAddress(rtSound, nr);
+	assert(ptr);
+
+	const int val = ptr[9];
+	if (val < 0 || val >= ARRAYSIZE(monkeyCommands)) {
+		warning("player_v4a: illegal Songnumber %i", val);
+		return;
+	}
+
+	if (!_initState)
+		_initState = init() ? 1 : -1;
+
+	if (_initState < 0)
+		return;
+
+	int index = monkeyCommands[val];
+	const byte type = ptr[6];
+	if (index < 0) {	// SoundFX
+		index = -index - 1;
+		debug(3, "player_v4a: play %d: custom %i - %02X", nr, index, type);
+
+		// start an empty Song so timing is setup
+		if (_tfmxSfx.getSongIndex() < 0)
+			_tfmxSfx.doSong(0x18);
+
+		const int chan = _tfmxSfx.doSfx((uint16)index);
+		if (chan >= 0 && chan < ARRAYSIZE(_sfxSlots))
+			setSfxSlot(chan, nr, type);
+		else
+			warning("player_v4a: custom %i is not of required type", index);
+
+		// the Tfmx-player never "ends" the output by itself, so this should be threadsafe
+		if (!_mixer->isSoundHandleActive(_sfxHandle))
+			_mixer->playInputStream(Audio::Mixer::kSFXSoundType, &_sfxHandle, &_tfmxSfx, -1, Audio::Mixer::kMaxChannelVolume, 0, false);
+
+	} else {	// Song
+		debug(3, "player_v4a: play %d: song %i - %02X", nr, index, type);
+		if (ptr[6] != 0x7F)
+			warning("player_v4a: Song has wrong type");
+
+		_tfmxMusic.doSong(index);
+		_signal = 2;
+
+		// the Tfmx-player never "ends" the output by itself, so this should be threadsafe 
+		if (!_mixer->isSoundHandleActive(_musicHandle))
+			_mixer->playInputStream(Audio::Mixer::kMusicSoundType, &_musicHandle, &_tfmxMusic, -1, Audio::Mixer::kMaxChannelVolume, 0, false);
+		_musicId = nr;
+	}
+}
+
+int Player_V4A::getMusicTimer() const {
+	// A workaround if the modplayer couldnt load the datafiles - just return a number big enough to pass all tests
+	if (_initState < 0)
+		return 2000;
+	if (_musicId) {
+		// The titlesong (and a few others) is running with ~70 ticks per second and the scale seems to be based on that. 
+		// The Game itself doesnt get the timing from the Tfmx Player however, so we just use the elapsed time
+		// 357 ~ 1000 * 25 * (1 / 70)
+		return _mixer->getSoundElapsedTime(_musicHandle) / 357;
+	}
+	return 0;
+}
+
+int Player_V4A::getSoundStatus(int nr) const {
+	// For music the game queues a variable the Tfmx Player sets through a special command.
+	// For sfx there seems to be no way to queue them, and the game doesnt try to.
+	return (nr == _musicId) ? _signal : 0;
+}
+
+} // End of namespace Scumm
diff --git a/engines/scumm/player_v4a.h b/engines/scumm/player_v4a.h
new file mode 100644
index 0000000000..5f5fae6b56
--- /dev/null
+++ b/engines/scumm/player_v4a.h
@@ -0,0 +1,98 @@
+/* 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 SCUMM_PLAYER_V4A_H
+#define SCUMM_PLAYER_V4A_H
+
+#include "common/scummsys.h"
+#include "scumm/music.h"
+#include "sound/mixer.h"
+#include "sound/mods/tfmx.h"
+
+class Mixer;
+
+namespace Scumm {
+
+class ScummEngine;
+
+/**
+ * Scumm V4 Amiga sound/music driver.
+ */
+class Player_V4A : public MusicEngine {
+public:
+	Player_V4A(ScummEngine *scumm, Audio::Mixer *mixer);
+	virtual ~Player_V4A();
+
+	virtual void setMusicVolume(int vol);
+	virtual void startSound(int sound);
+	virtual void stopSound(int sound);
+	virtual void stopAllSounds();
+	virtual int  getMusicTimer() const;
+	virtual int  getSoundStatus(int sound) const;
+
+private:
+	ScummEngine *const _vm;
+	Audio::Mixer *const _mixer;
+
+	Audio::Tfmx _tfmxMusic;
+	Audio::Tfmx _tfmxSfx;
+	Audio::SoundHandle _musicHandle;
+	Audio::SoundHandle _sfxHandle;
+
+	int _musicId;
+	uint16 _signal;
+
+	struct SfxChan {
+		int id;
+//		byte type;
+	} _sfxSlots[4];
+
+	int8 _initState; // < 0: failed, 0: uninitialised, > 0: initialised  
+
+	int getSfxChan(int id) const {
+		for (int i = 0; i < ARRAYSIZE(_sfxSlots); ++i)
+			if (_sfxSlots[i].id == id)
+				return i;
+		return -1;
+	}
+
+	void setSfxSlot(int channel, int id, byte type = 0) {
+		_sfxSlots[channel].id = id;
+//		_sfxSlots[channel].type = type;
+	}
+
+	void clearSfxSlots() {
+		for (int i = 0; i < ARRAYSIZE(_sfxSlots); ++i){
+			_sfxSlots[i].id = 0;
+//			_sfxSlots[i].type = 0;
+		}
+	}
+
+	bool init();
+};
+
+} // End of namespace Scumm
+
+#endif
diff --git a/engines/scumm/scumm.cpp b/engines/scumm/scumm.cpp
index af6b9278c6..587e2a8abe 100644
--- a/engines/scumm/scumm.cpp
+++ b/engines/scumm/scumm.cpp
@@ -56,6 +56,7 @@
 #include "scumm/player_v2.h"
 #include "scumm/player_v2a.h"
 #include "scumm/player_v3a.h"
+#include "scumm/player_v4a.h"
 #include "scumm/he/resource_he.h"
 #include "scumm/scumm_v0.h"
 #include "scumm/scumm_v8.h"
@@ -284,7 +285,6 @@ ScummEngine::ScummEngine(OSystem *syst, const DetectorResult &dr)
 	_useTalkAnims = false;
 	_defaultTalkDelay = 0;
 	_musicType = MDT_NONE;
-	_tempMusic = 0;
 	_saveSound = 0;
 	memset(_extraBoxFlags, 0, sizeof(_extraBoxFlags));
 	memset(_scaleSlots, 0, sizeof(_scaleSlots));
@@ -554,10 +554,7 @@ ScummEngine::ScummEngine(OSystem *syst, const DetectorResult &dr)
 ScummEngine::~ScummEngine() {
 	Common::clearAllDebugChannels();
 
-	if (_musicEngine) {
-		_musicEngine->terminate();
-		delete _musicEngine;
-	}
+	delete _musicEngine;
 
 	_mixer->stopAll();
 
@@ -1296,7 +1293,6 @@ void ScummEngine::setupCostumeRenderer() {
 void ScummEngine::resetScumm() {
 	int i;
 
-	_tempMusic = 0;
 	debug(9, "resetScumm");
 
 	if (_game.version == 0) {
@@ -1698,7 +1694,7 @@ void ScummEngine::setupMusic(int midi) {
 	} else if (_game.platform == Common::kPlatformPCEngine && _game.version == 3) {
 		// TODO: Add support for music format
 	} else if (_game.platform == Common::kPlatformAmiga && _game.version <= 4) {
-		// TODO: Add support for music format
+		_musicEngine = new Player_V4A(this, _mixer);
 	} else if (_game.id == GID_MANIAC && _game.version == 1) {
 		_musicEngine = new Player_V1(this, _mixer, midiDriver != MD_PCSPK);
 	} else if (_game.version <= 2) {
@@ -1909,17 +1905,6 @@ void ScummEngine::scummLoop(int delta) {
 		if (_musicEngine) {
 			// The music engine generates the timer data for us.
 			VAR(VAR_MUSIC_TIMER) = _musicEngine->getMusicTimer();
-		} else {
-			// Used for Money Island 1 (Amiga)
-			// TODO: The music delay (given in milliseconds) might have to be tuned a little
-			// to get it correct for all games. Without the ability to watch/listen to the
-			// original games, I can't do that myself.
-			const int MUSIC_DELAY = 350;
-			_tempMusic += delta * 1000 / 60;	// Convert delta to milliseconds
-			if (_tempMusic >= MUSIC_DELAY) {
-				_tempMusic -= MUSIC_DELAY;
-				VAR(VAR_MUSIC_TIMER) += 1;
-			}
 		}
 	}
 
diff --git a/engines/scumm/scumm.h b/engines/scumm/scumm.h
index 6866b17668..940ea512d5 100644
--- a/engines/scumm/scumm.h
+++ b/engines/scumm/scumm.h
@@ -1139,7 +1139,6 @@ protected:
 	bool _haveActorSpeechMsg;
 	bool _useTalkAnims;
 	uint16 _defaultTalkDelay;
-	int _tempMusic;
 	int _saveSound;
 	bool _native_mt32;
 	bool _enable_gs;
diff --git a/engines/scumm/sound.cpp b/engines/scumm/sound.cpp
index 524dbf70ea..82ed2a62e6 100644
--- a/engines/scumm/sound.cpp
+++ b/engines/scumm/sound.cpp
@@ -436,26 +436,6 @@ void Sound::playSound(int soundID) {
 
 		if (_vm->_game.id == GID_MONKEY_VGA || _vm->_game.id == GID_MONKEY_EGA
 			|| (_vm->_game.id == GID_MONKEY && _vm->_game.platform == Common::kPlatformMacintosh)) {
-			// Sound is currently not supported at all in the amiga versions of these games
-			if (_vm->_game.platform == Common::kPlatformAmiga) {
-				int track = -1;
-				if (soundID == 50)
-					track = 17;
-				else if (ptr[6] == 0x7F && ptr[7] == 0x00 && ptr[8] == 0x80) {
-					static const char tracks[16] = {13,14,10,3,4,9,16,5,1,8,2,15,6,7,11,12};
-					if (ptr[9] == 0x0E)
-						track = 18;
-					else
-						track = tracks[ptr[9] - 0x23];
-				}
-				if (track != -1) {
-					playCDTrack(track,((track < 5) || (track > 16)) ? 1 : -1,0,0);
-					stopCDTimer();
-					_currentCDSound = soundID;
-				}
-				return;
-			}
-
 			// Works around the fact that in some places in MonkeyEGA/VGA,
 			// the music is never explicitly stopped.
 			// Rather it seems that starting a new music is supposed to
diff --git a/sound/mods/maxtrax.cpp b/sound/mods/maxtrax.cpp
new file mode 100644
index 0000000000..90ac3d55ca
--- /dev/null
+++ b/sound/mods/maxtrax.cpp
@@ -0,0 +1,1038 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "common/scummsys.h"
+#include "common/endian.h"
+#include "common/stream.h"
+#include "common/util.h"
+#include "common/debug.h"
+
+#include "sound/mods/maxtrax.h"
+
+// test for engines using this class.
+#if defined(SOUND_MODS_MAXTRAX_H)
+
+namespace {
+
+enum { K_VALUE = 0x9fd77, PREF_PERIOD = 0x8fd77, PERIOD_LIMIT = 0x6f73d };
+enum { NO_BEND = 64 << 7, MAX_BEND_RANGE = 24 };
+
+int32 precalcNote(byte baseNote, int16 tune, byte octave) {
+	return K_VALUE + 0x3C000 - ((baseNote << 14) + (tune << 11) / 3) / 3 - (octave << 16);
+}
+
+int32 calcVolumeDelta(int32 delta, uint16 time, uint16 vBlankFreq) {
+	const int32 div = time * vBlankFreq;
+	// div <= 1000 means time to small (or even 0)
+	return (div <= 1000) ? delta : (1000 * delta) / div;
+}
+
+int32 calcTempo(const uint16 tempo, uint16 vBlankFreq) {
+	return (int32)(((uint32)(tempo & 0xFFF0) << 8) / (uint16)(5 * vBlankFreq));
+}
+
+void nullFunc(int) {}
+
+// Function to calculate 2^x, where x is a fixedpoint number with 16 fraction bits
+// using exp would be more accurate and needs less space if mathlibrary is already linked
+// but this function should be faster and doesnt use floats
+#if 1
+inline uint32 pow2Fixed(int32 val) {
+	static const uint16 tablePow2[] = {
+			0,   178,   356,   535,   714,   893,  1073,  1254,  1435,  1617,  1799,  1981,  2164,  2348,  2532,  2716,
+		 2902,  3087,  3273,  3460,  3647,  3834,  4022,  4211,  4400,  4590,  4780,  4971,  5162,  5353,  5546,  5738,
+		 5932,  6125,  6320,  6514,  6710,  6906,  7102,  7299,  7496,  7694,  7893,  8092,  8292,  8492,  8693,  8894,
+		 9096,  9298,  9501,  9704,  9908, 10113, 10318, 10524, 10730, 10937, 11144, 11352, 11560, 11769, 11979, 12189,
+		12400, 12611, 12823, 13036, 13249, 13462, 13676, 13891, 14106, 14322, 14539, 14756, 14974, 15192, 15411, 15630,
+		15850, 16071, 16292, 16514, 16737, 16960, 17183, 17408, 17633, 17858, 18084, 18311, 18538, 18766, 18995, 19224,
+		19454, 19684, 19915, 20147, 20379, 20612, 20846, 21080, 21315, 21550, 21786, 22023, 22260, 22498, 22737, 22977,
+		23216, 23457, 23698, 23940, 24183, 24426, 24670, 24915, 25160, 25406, 25652, 25900, 26148, 26396, 26645, 26895,
+		27146, 27397, 27649, 27902, 28155, 28409, 28664, 28919, 29175, 29432, 29690, 29948, 30207, 30466, 30727, 30988,
+		31249, 31512, 31775, 32039, 32303, 32568, 32834, 33101, 33369, 33637, 33906, 34175, 34446, 34717, 34988, 35261,
+		35534, 35808, 36083, 36359, 36635, 36912, 37190, 37468, 37747, 38028, 38308, 38590, 38872, 39155, 39439, 39724,
+		40009, 40295, 40582, 40870, 41158, 41448, 41738, 42029, 42320, 42613, 42906, 43200, 43495, 43790, 44087, 44384,
+		44682, 44981, 45280, 45581, 45882, 46184, 46487, 46791, 47095, 47401, 47707, 48014, 48322, 48631, 48940, 49251,
+		49562, 49874, 50187, 50500, 50815, 51131, 51447, 51764, 52082, 52401, 52721, 53041, 53363, 53685, 54008, 54333,
+		54658, 54983, 55310, 55638, 55966, 56296, 56626, 56957, 57289, 57622, 57956, 58291, 58627, 58964, 59301, 59640,
+		59979, 60319, 60661, 61003, 61346, 61690, 62035, 62381, 62727, 63075, 63424, 63774, 64124, 64476, 64828, 65182,
+			0
+	};
+	const uint16 whole = val >> 16;
+	const uint8 index = (uint8)(val >> 8);
+	// calculate fractional part.
+	const uint16 base = tablePow2[index];
+	// linear interpolation and add 1.0
+	uint32 exponent = ((uint32)(uint16)(tablePow2[index + 1] - base) * (uint8)val) + ((uint32)base << 8) + (1 << 24);
+
+	if (whole < 24) {
+		// shift away all but the last fractional bit which is used for rounding,
+		// then round to nearest integer
+		exponent = ((exponent >> (23 - whole)) + 1) >> 1;
+	} else if (whole < 32) {
+		// no need to round here
+		exponent <<= whole - 24;
+	} else if (val > 0) {
+		// overflow
+		exponent = 0xFFFFFFFF;
+	} else  {
+		// negative integer, test if >= -0.5
+		exponent = (val >= -0x8000) ? 1 : 0;
+	}
+	return exponent;
+}
+#else
+inline uint32 pow2Fixed(int32 val) {
+	return (uint32)(expf((float)val * (float)(0.69314718055994530942 / (1 << 16))) + 0.5f);
+}
+#endif
+
+}	// End of namespace
+
+namespace Audio {
+
+MaxTrax::MaxTrax(int rate, bool stereo, uint16 vBlankFreq, uint16 maxScores)
+	: Paula(stereo, rate, rate / vBlankFreq),
+	  _patch(),
+	  _scores(),
+	  _numScores() {
+	_playerCtx.maxScoreNum = maxScores;
+	_playerCtx.vBlankFreq = vBlankFreq;
+	_playerCtx.frameUnit = (uint16)((1000 << 8) /  vBlankFreq);
+	_playerCtx.scoreIndex = -1;
+	_playerCtx.volume = 0x40;
+
+	_playerCtx.tempo = 120;
+	_playerCtx.tempoTime = 0;
+	_playerCtx.filterOn = true;
+	_playerCtx.syncCallBack = &nullFunc;
+
+	resetPlayer();
+	for (int i = 0; i < ARRAYSIZE(_channelCtx); ++i)
+		_channelCtx[i].regParamNumber = 0;
+}
+
+MaxTrax::~MaxTrax() {
+	stopMusic();
+	freePatches();
+	freeScores();
+}
+
+void MaxTrax::interrupt() {
+	// a5 - maxtraxm a4 . globaldata
+
+	// TODO
+	// test for changes in shared struct and make changes
+	// specifically all used channels get marked altered
+
+	_playerCtx.ticks += _playerCtx.tickUnit;
+	const int32 millis = _playerCtx.ticks >> 8; // d4
+
+	for (int i = 0; i < ARRAYSIZE(_voiceCtx); ++i) {
+		VoiceContext &voice = _voiceCtx[i];
+		if (voice.stopEventTime >= 0) {
+			assert(voice.channel);
+			voice.stopEventTime -= (voice.channel < &_channelCtx[kNumChannels]) ? _playerCtx.tickUnit : _playerCtx.frameUnit;
+			if (voice.stopEventTime <= 0 && voice.status > VoiceContext::kStatusRelease) {
+				if ((voice.channel->flags & ChannelContext::kFlagDamper) != 0)
+					voice.hasDamper = true;
+				else
+					voice.status = VoiceContext::kStatusRelease;
+			}
+		}
+	}
+
+	if (_playerCtx.scoreIndex >= 0) {
+		const Event *curEvent = _playerCtx.nextEvent;
+		int32 eventDelta = _playerCtx.nextEventTime - millis;
+		for (; eventDelta <= 0; eventDelta += (++curEvent)->startTime) {
+			const byte cmd = curEvent->command;
+			ChannelContext &channel = _channelCtx[curEvent->parameter & 0x0F];
+
+			// outPutEvent(*curEvent);
+			// debug("CurTime, EventDelta, NextDelta: %d, %d, %d", millis, eventDelta, eventDelta + curEvent[1].startTime );
+
+			if (cmd < 0x80) {	// Note
+				const int8 voiceIndex = noteOn(channel, cmd, (curEvent->parameter & 0xF0) >> 1, kPriorityScore);
+				if (voiceIndex >= 0)
+					_voiceCtx[voiceIndex].stopEventTime = MAX(0, (eventDelta + curEvent->stopTime) << 8);
+
+			} else {
+				switch (cmd) {
+
+				case 0x80:	// TEMPO
+					if ((_playerCtx.tickUnit >> 8) > curEvent->stopTime) {
+						_playerCtx.tickUnit = calcTempo(curEvent->parameter << 4, _playerCtx.vBlankFreq);
+						_playerCtx.tempoTime = 0;
+					} else {
+						_playerCtx.tempoStart = _playerCtx.tempo;
+						_playerCtx.tempoDelta = (curEvent->parameter << 4) - _playerCtx.tempoStart;
+						_playerCtx.tempoTime  = (curEvent->stopTime << 8);
+						_playerCtx.tempoTicks = 0;
+					}
+					break;
+				
+				case 0xC0:	// PROGRAM
+					channel.patch = &_patch[curEvent->stopTime & (kNumPatches - 1)];
+					break;
+
+				case 0xE0:	// BEND
+					channel.pitchBend = ((curEvent->stopTime & 0x7F00) >> 1) | (curEvent->stopTime & 0x7f);
+					channel.pitchReal = (((int32)channel.pitchBendRange * channel.pitchBend) >> 5) - (channel.pitchBendRange << 8);
+					channel.isAltered = true;
+					break;
+
+				case 0xFF:	// END
+					if (_playerCtx.musicLoop) {
+						curEvent = _scores[_playerCtx.scoreIndex].events;
+						eventDelta = curEvent->startTime - millis;
+						_playerCtx.ticks = 0;
+					} else
+						_playerCtx.scoreIndex = -1;
+					// stop processing for this tick
+					goto endOfEventLoop;
+
+				case 0xA0: 	// SPECIAL
+					switch (curEvent->stopTime >> 8){
+					case 0x01:	// SPECIAL_SYNC
+						_playerCtx.syncCallBack(curEvent->stopTime & 0xFF);
+						break;
+					case 0x02:	// SPECIAL_BEGINREP
+						// we allow a depth of 4 loops
+						for (int i = 0; i < ARRAYSIZE(_playerCtx.repeatPoint); ++i) {
+							if (!_playerCtx.repeatPoint[i]) {
+								_playerCtx.repeatPoint[i] = curEvent;
+								_playerCtx.repeatCount[i] = curEvent->stopTime & 0xFF;
+								break;
+							}
+						}
+						break;
+					case 0x03:	// SPECIAL_ENDREP
+						for (int i = ARRAYSIZE(_playerCtx.repeatPoint) - 1; i >= 0; --i) {
+							if (_playerCtx.repeatPoint[i]) {
+								if (_playerCtx.repeatCount[i]--)
+									curEvent = _playerCtx.repeatPoint[i]; // gets incremented by 1 at end of loop
+								else
+									_playerCtx.repeatPoint[i] = 0;
+								break;
+							}
+						}
+						break;
+					}
+					break;
+
+				case 0xB0:	// CONTROL
+					controlCh(channel, (byte)(curEvent->stopTime >> 8), (byte)curEvent->stopTime);
+					break;
+
+				default:
+					debug("Unhandled Command");
+					outPutEvent(*curEvent);
+				}
+			}
+		}
+endOfEventLoop:
+		_playerCtx.nextEvent = curEvent;
+		_playerCtx.nextEventTime = eventDelta + millis;
+
+		// tempoEffect
+		if (_playerCtx.tempoTime) {
+			_playerCtx.tempoTicks += _playerCtx.tickUnit;
+			uint16 newTempo = _playerCtx.tempoStart;
+			if (_playerCtx.tempoTicks < _playerCtx.tempoTime) {
+				newTempo += (uint16)((_playerCtx.tempoTicks * _playerCtx.tempoDelta) / _playerCtx.tempoTime);
+			} else {
+				_playerCtx.tempoTime = 0;
+				newTempo += _playerCtx.tempoDelta;
+			}
+			_playerCtx.tickUnit = calcTempo(newTempo, _playerCtx.vBlankFreq);
+		}
+	}
+
+	// Handling of Envelopes and Portamento
+	for (int i = 0; i < ARRAYSIZE(_voiceCtx); ++i) {
+		VoiceContext &voice = _voiceCtx[i];
+		if (!voice.channel)
+			continue;
+		const ChannelContext &channel = *voice.channel;
+		const Patch &patch = *voice.patch;
+
+		switch (voice.status) {
+		case VoiceContext::kStatusSustain:
+			// we need to check if some voices have no sustainSample.
+			// in that case they are finished after the attackSample is done
+			if (voice.dmaOff && Paula::getChannelDmaCount((byte)i) >= voice.dmaOff ) {
+				voice.dmaOff = 0;
+				voice.isBlocked = 0;
+				voice.priority = 0;
+				// disable it in next tick
+				voice.stopEventTime = 0;
+			}
+			if (!channel.isAltered && !voice.hasPortamento && !channel.modulation)
+				continue;
+			// Update Volume and Period
+			break;
+
+		case VoiceContext::kStatusHalt:
+			killVoice((byte)i);
+			continue;
+
+		case VoiceContext::kStatusStart:
+			if (patch.attackLen) {
+				voice.envelope = patch.attackPtr;
+				const uint16 duration = voice.envelope->duration;
+				voice.envelopeLeft = patch.attackLen;
+				voice.ticksLeft = duration << 8;
+				voice.status = VoiceContext::kStatusAttack;
+				voice.incrVolume = calcVolumeDelta((int32)voice.envelope->volume, duration, _playerCtx.vBlankFreq);
+				// Process Envelope
+			} else {
+				voice.status = VoiceContext::kStatusSustain;
+				voice.baseVolume = patch.volume;
+				// Update Volume and Period
+			}
+			break;
+
+		case VoiceContext::kStatusRelease:
+			if (patch.releaseLen) {
+				voice.envelope = patch.attackPtr + patch.attackLen;
+				const uint16 duration = voice.envelope->duration;
+				voice.envelopeLeft = patch.releaseLen;
+				voice.ticksLeft = duration << 8;
+				voice.status = VoiceContext::kStatusDecay;
+				voice.incrVolume = calcVolumeDelta((int32)voice.envelope->volume - voice.baseVolume, duration, _playerCtx.vBlankFreq);
+				// Process Envelope
+			} else {
+				voice.status = VoiceContext::kStatusHalt;
+				voice.lastVolume = 0;
+				// Send Audio Packet
+			}
+			voice.stopEventTime = -1;
+			break;
+		}
+
+		// Process Envelope
+		const uint16 envUnit = _playerCtx.frameUnit;
+		if (voice.envelope) {
+			if (voice.ticksLeft > envUnit) {	// envelope still active
+				voice.baseVolume = (uint16)MIN(MAX(0, voice.baseVolume + voice.incrVolume), 0x8000);
+				voice.ticksLeft -= envUnit;
+				// Update Volume and Period
+
+			} else {	// next or last Envelope
+				voice.baseVolume = voice.envelope->volume;
+				assert(voice.envelopeLeft > 0);
+				if (--voice.envelopeLeft) {
+					++voice.envelope;
+					const uint16 duration = voice.envelope->duration;
+					voice.ticksLeft = duration << 8;
+					voice.incrVolume = calcVolumeDelta((int32)voice.envelope->volume - voice.baseVolume, duration, _playerCtx.vBlankFreq);
+					// Update Volume and Period
+				} else if (voice.status == VoiceContext::kStatusDecay) {
+					voice.status = VoiceContext::kStatusHalt;
+					voice.envelope = 0;
+					voice.lastVolume = 0;
+					// Send Audio Packet
+				} else {
+					assert(voice.status == VoiceContext::kStatusAttack);
+					voice.status = VoiceContext::kStatusSustain;
+					voice.envelope = 0;
+					// Update Volume and Period
+				}
+			}
+		}
+
+		// Update Volume and Period
+		if (voice.status >= VoiceContext::kStatusDecay) {
+			// Calc volume
+			uint16 vol = (voice.noteVolume < (1 << 7)) ? (voice.noteVolume * _playerCtx.volume) >> 7 : _playerCtx.volume;
+			if (voice.baseVolume < (1 << 15))
+				vol = (uint16)(((uint32)vol * voice.baseVolume) >> 15);
+			if (voice.channel->volume < (1 << 7))
+				vol = (vol * voice.channel->volume) >> 7;
+			voice.lastVolume = (byte)MIN(vol, (uint16)0x64);
+
+			// Calc Period
+			if (voice.hasPortamento) {
+				voice.portaTicks += envUnit;
+				if ((uint16)(voice.portaTicks >> 8) >= channel.portamentoTime) {
+					voice.hasPortamento = false;
+					voice.baseNote = voice.endNote;
+					voice.preCalcNote = precalcNote(voice.baseNote, patch.tune, voice.octave);
+				}
+				voice.lastPeriod = calcNote(voice);
+			} else if (channel.isAltered || channel.modulation)
+				voice.lastPeriod = calcNote(voice);
+		}
+
+		// Send Audio Packet
+		Paula::setChannelPeriod((byte)i, (voice.lastPeriod) ? voice.lastPeriod : 1000);
+		Paula::setChannelVolume((byte)i, (voice.lastPeriod) ? voice.lastVolume : 0);
+	}
+	for (ChannelContext *c = _channelCtx; c != &_channelCtx[ARRAYSIZE(_channelCtx)]; ++c)
+		c->isAltered = false;
+
+#ifdef MAXTRAX_HAS_MODULATION
+	// original player had _playerCtx.sineValue = _playerCtx.frameUnit >> 2
+	// this should fit the comments that modtime=1000 is one second ?
+	_playerCtx.sineValue += _playerCtx.frameUnit;
+#endif
+}
+
+void MaxTrax::controlCh(ChannelContext &channel, const byte command, const byte data) {
+	switch (command) {
+	case 0x01:	// modulation level MSB
+		channel.modulation = data << 8;
+		break;
+	case 0x21:	// modulation level LSB
+		channel.modulation = (channel.modulation & 0xFF00) || ((data * 2) & 0xFF);
+		break;
+	case 0x05:	// portamento time MSB
+		channel.portamentoTime = data << 7;
+		break;
+	case 0x25:	// portamento time LSB
+		channel.portamentoTime = (channel.portamentoTime & 0x3f80) || data;
+		break;
+	case 0x06:	// data entry MSB
+		if (channel.regParamNumber == 0) {
+			channel.pitchBendRange = (int8)MIN((uint8)MAX_BEND_RANGE, (uint8)data);
+			channel.pitchReal = (((int32)channel.pitchBendRange * channel.pitchBend) >> 5) - (channel.pitchBendRange << 8);
+			channel.isAltered = true;
+		}
+		break;
+	case 0x07:	// Main Volume MSB
+		channel.volume = (data == 0) ? 0 : data + 1;
+		channel.isAltered = true;
+		break;
+	case 0x0A:	// Pan
+		if (data > 0x40 || (data == 0x40 && ((&channel - _channelCtx) & 1) != 0))
+			channel.flags |= ChannelContext::kFlagRightChannel;
+		else
+			channel.flags &= ~ChannelContext::kFlagRightChannel;
+		break;
+	case 0x10:	// GPC as Modulation Time MSB
+		channel.modulationTime = data << 7;
+		break;
+	case 0x30:	// GPC as Modulation Time LSB
+		channel.modulationTime = (channel.modulationTime & 0x3f80) || data;
+		break;
+	case 0x11:	// GPC as Microtonal Set MSB
+		channel.microtonal = data << 8;
+		break;
+	case 0x31:	// GPC as Microtonal Set LSB
+		channel.microtonal = (channel.microtonal & 0xFF00) || ((data * 2) & 0xFF);
+		break;
+	case 0x40:	// Damper Pedal
+		if ((data & 0x40) != 0)
+			channel.flags |= ChannelContext::kFlagDamper;
+		else {
+			channel.flags &= ~ChannelContext::kFlagDamper;
+			// release all dampered voices on this channel
+			for (int i = 0; i < ARRAYSIZE(_voiceCtx); ++i) {
+				if (_voiceCtx[i].channel == &channel && _voiceCtx[i].hasDamper) {
+					_voiceCtx[i].hasDamper = false;
+					_voiceCtx[i].status = VoiceContext::kStatusRelease;
+				}
+			}
+		}
+		break;
+	case 0x41:	// Portamento off/on
+		if ((data & 0x40) != 0)
+			channel.flags |= ChannelContext::kFlagPortamento;
+		else
+			channel.flags &= ~ChannelContext::kFlagPortamento;
+		break;
+	case 0x50:	// Microtonal off/on 
+		if ((data & 0x40) != 0)
+			channel.flags |= ChannelContext::kFlagMicrotonal;
+		else
+			channel.flags &= ~ChannelContext::kFlagMicrotonal;
+		break;
+	case 0x51:	// Audio Filter off/on
+		Paula::setAudioFilter(data > 0x40 || (data == 0x40 && _playerCtx.filterOn));
+		break;
+	case 0x65:	// RPN MSB
+		channel.regParamNumber = (data << 8) || (channel.regParamNumber & 0xFF);
+		break;
+	case 0x64:	// RPN LSB
+		channel.regParamNumber = (channel.regParamNumber & 0xFF00) || data;
+		break;
+	case 0x79:	// Reset All Controllers
+		resetChannel(channel, ((&channel - _channelCtx) & 1) != 0);
+		break;
+	case 0x7E:	// MONO mode
+		channel.flags |= ChannelContext::kFlagMono;
+		goto allNotesOff;
+	case 0x7F:	// POLY mode
+		channel.flags &= ~ChannelContext::kFlagMono;
+		// Fallthrough
+	case 0x7B:	// All Notes Off
+allNotesOff:
+		for (int i = 0; i < ARRAYSIZE(_voiceCtx); ++i) {
+			if (_voiceCtx[i].channel == &channel) {
+				if ((channel.flags & ChannelContext::kFlagDamper) != 0)
+					_voiceCtx[i].hasDamper = true;
+				else
+					_voiceCtx[i].status = VoiceContext::kStatusRelease;
+			}
+		}
+		break;
+	case 0x78:	// All Sounds Off
+		for (int i = 0; i < ARRAYSIZE(_voiceCtx); ++i) {
+			if (_voiceCtx[i].channel == &channel)
+				killVoice((byte)i);
+		}
+		break;
+	}
+}
+
+void MaxTrax::setTempo(const uint16 tempo) {
+	Common::StackLock lock(_mutex);
+	_playerCtx.tickUnit = calcTempo(tempo, _playerCtx.vBlankFreq);
+}
+
+void MaxTrax::resetPlayer() {
+	for (int i = 0; i < ARRAYSIZE(_voiceCtx); ++i)
+		killVoice((byte)i);
+
+	for (int i = 0; i < ARRAYSIZE(_channelCtx); ++i) {
+		_channelCtx[i].flags = 0;
+		_channelCtx[i].lastNote = (uint8)-1;
+		resetChannel(_channelCtx[i], (i & 1) != 0);
+		_channelCtx[i].patch = (i < kNumChannels) ? &_patch[i] : 0;
+	}
+
+#ifdef MAXTRAX_HAS_MICROTONAL
+	for (int i = 0; i < ARRAYSIZE(_microtonal); ++i)
+		_microtonal[i] = (int16)(i << 8);
+#endif
+}
+
+void MaxTrax::stopMusic() {
+	Common::StackLock lock(_mutex);
+	_playerCtx.scoreIndex = -1;
+	for (int i = 0; i < ARRAYSIZE(_voiceCtx); ++i) {
+		if (_voiceCtx[i].channel < &_channelCtx[kNumChannels])
+			killVoice((byte)i);
+	}
+}
+
+bool MaxTrax::playSong(int songIndex, bool loop) {
+	if (songIndex < 0 || songIndex >= _numScores)
+		return false;
+	Common::StackLock lock(_mutex);
+	_playerCtx.scoreIndex = -1;
+	resetPlayer();
+	for (int i = 0; i < ARRAYSIZE(_playerCtx.repeatPoint); ++i)
+		_playerCtx.repeatPoint[i] = 0;
+
+	setTempo(_playerCtx.tempoInitial << 4);
+	Paula::setAudioFilter(_playerCtx.filterOn);
+	_playerCtx.musicLoop = loop;
+	_playerCtx.tempoTime = 0;
+	_playerCtx.scoreIndex = songIndex;
+	_playerCtx.ticks = 0;
+
+	_playerCtx.nextEvent = _scores[songIndex].events;;
+	_playerCtx.nextEventTime = _playerCtx.nextEvent->startTime;
+
+	Paula::startPaula();
+	return true;
+}
+
+void MaxTrax::advanceSong(int advance) {
+	Common::StackLock lock(_mutex);
+	if (_playerCtx.scoreIndex >= 0) {
+		const Event *cev = _playerCtx.nextEvent;
+		if (cev) {
+			for (; advance > 0; --advance) {
+				// TODO - check for boundaries 
+				for (; cev->command != 0xFF && (cev->command != 0xA0 || (cev->stopTime >> 8) != 0x00); ++cev)
+					; // no end_command or special_command + end
+			}
+			_playerCtx.nextEvent = cev;
+		}
+	}
+}
+
+void MaxTrax::killVoice(byte num) {
+	VoiceContext &voice = _voiceCtx[num];
+	voice.channel = 0;
+	voice.envelope = 0;
+	voice.status = VoiceContext::kStatusFree;
+	voice.isBlocked = 0;
+	voice.hasDamper = false;
+	voice.hasPortamento = false;
+	voice.priority = 0;
+	voice.stopEventTime = -1;
+	voice.dmaOff = 0;
+	voice.lastVolume = 0;
+	voice.tieBreak = 0;
+	//voice.uinqueId = 0;
+
+	// "stop" voice, set period to 1, vol to 0
+	Paula::disableChannel(num);
+	Paula::setChannelPeriod(num, 1);
+	Paula::setChannelVolume(num, 0);
+}
+
+int8 MaxTrax::pickvoice(uint pick, int16 pri) {
+	enum { kPrioFlagFixedSide = 1 << 3 };
+	pick &= 3;
+	if ((pri & (kPrioFlagFixedSide)) == 0) {
+		const bool leftSide = (uint)(pick - 1) > 1;
+		const int leftBest = MIN(_voiceCtx[0].status, _voiceCtx[3].status);
+		const int rightBest = MIN(_voiceCtx[1].status, _voiceCtx[2].status);
+		const int sameSide = (leftSide) ? leftBest : rightBest;
+		const int otherSide = leftBest + rightBest - sameSide;
+
+		if (sameSide > VoiceContext::kStatusRelease && otherSide <= VoiceContext::kStatusRelease)
+			pick ^= 1; // switches sides
+	}
+	pri &= ~kPrioFlagFixedSide;
+
+	for (int i = 2; i > 0; --i) {
+		VoiceContext *voice = &_voiceCtx[pick];
+		VoiceContext *alternate = &_voiceCtx[pick ^ 3];
+
+		const uint16 voiceVal = voice->status << 8 | voice->lastVolume;
+		const uint16 altVal = alternate->status << 8 | alternate->lastVolume;
+
+		if (voiceVal + voice->tieBreak > altVal 
+			|| voice->isBlocked > alternate->isBlocked) {
+
+			// this is somewhat different to the original player,
+			// but has a similar result
+			voice->tieBreak = 0;
+			alternate->tieBreak = 1;
+
+			pick ^= 3; // switch channels
+			VoiceContext *tmp = voice;
+			voice = alternate;
+			alternate = tmp;
+		}
+
+		if (voice->isBlocked || voice->priority > pri) {
+			// if not already done, switch sides and try again
+			pick ^= 1;
+			continue;
+		}
+		// succeded
+		return (int8)pick;
+	}
+	// failed
+	debug(5, "MaxTrax: could not find channel for note");
+	return -1;
+}
+
+uint16 MaxTrax::calcNote(const VoiceContext &voice) {
+	const ChannelContext &channel = *voice.channel;
+	int16 bend = channel.pitchReal;
+
+#ifdef MAXTRAX_HAS_MICROTONAL
+	if (voice.hasPortamento) {
+		if ((channel.flags & ChannelContext::kFlagMicrotonal) != 0)
+			bend += (int16)(((_microtonal[voice.endNote] - _microtonal[voice.baseNote]) * voice.portaTicks) >> 8) / channel.portamentoTime;
+		else
+			bend += (int16)(((int8)(voice.endNote - voice.baseNote)) * voice.portaTicks) / channel.portamentoTime;
+	}
+
+	if ((channel.flags & ChannelContext::kFlagMicrotonal) != 0)
+		bend += _microtonal[voice.baseNote];
+#else
+	if (voice.hasPortamento)
+		bend += (int16)(((int8)(voice.endNote - voice.baseNote)) * voice.portaTicks) / channel.portamentoTime;
+#endif
+
+#ifdef MAXTRAX_HAS_MODULATION
+	static const uint8 tableSine[] = {
+		  0,   5,  12,  18,  24,  30,  37,  43,  49,  55,  61,  67,  73,  79,  85,  91,
+		 97, 103, 108, 114, 120, 125, 131, 136, 141, 146, 151, 156, 161, 166, 171, 176,
+		180, 184, 189, 193, 197, 201, 205, 208, 212, 215, 219, 222, 225, 228, 230, 233,
+		236, 238, 240, 242, 244, 246, 247, 249, 250, 251, 252, 253, 254, 254, 255, 255,
+		255, 255, 255, 254, 254, 253, 252, 251, 250, 249, 247, 246, 244, 242, 240, 238,
+		236, 233, 230, 228, 225, 222, 219, 215, 212, 208, 205, 201, 197, 193, 189, 184,
+		180, 176, 171, 166, 161, 156, 151, 146, 141, 136, 131, 125, 120, 114, 108, 103,
+		 97,  91,  85,  79,  73,  67,  61,  55,  49,  43,  37,  30,  24,  18,  12,   5
+	};
+	if (channel.modulation) {
+		if ((channel.flags & ChannelContext::kFlagModVolume) == 0) {
+			const uint8 sineByte = _playerCtx.sineValue / channel.modulationTime;
+			const uint8 sineIndex = sineByte & 0x7F;
+			const int16 modVal = ((uint32)(uint16)(tableSine[sineIndex] + (sineIndex ? 1 : 0)) * channel.modulation) >> 8;
+			bend = (sineByte < 0x80) ? bend + modVal : bend - modVal;
+		} 
+	}
+#endif
+
+	// tone = voice.baseNote << 8 + microtonal
+	// bend = channelPitch + porta + modulation
+
+	const int32 tone = voice.preCalcNote + (bend << 6) / 3;
+
+	return (tone >= PERIOD_LIMIT) ? (uint16)pow2Fixed(tone) : 0;
+}
+
+int8 MaxTrax::noteOn(ChannelContext &channel, const byte note, uint16 volume, uint16 pri) {
+#ifdef MAXTRAX_HAS_MICROTONAL
+	if (channel.microtonal >= 0)
+		_microtonal[note % 127] = channel.microtonal;
+#endif
+
+	if (!volume)
+		return -1;
+
+	const Patch &patch = *channel.patch;
+	if (!patch.samplePtr || patch.sampleTotalLen == 0)
+		return -1;
+	int8 voiceNum = -1;
+	if ((channel.flags & ChannelContext::kFlagMono) == 0) {
+		voiceNum = pickvoice((channel.flags & ChannelContext::kFlagRightChannel) != 0 ? 1 : 0, pri);
+	} else {
+		VoiceContext *voice = _voiceCtx + ARRAYSIZE(_voiceCtx) - 1;
+		for (voiceNum = ARRAYSIZE(_voiceCtx) - 1; voiceNum >= 0 && voice->channel != &channel; --voiceNum, --voice)
+			;
+		if (voiceNum < 0)
+			voiceNum = pickvoice((channel.flags & ChannelContext::kFlagRightChannel) != 0 ? 1 : 0, pri);
+		else if (voice->status >= VoiceContext::kStatusSustain && (channel.flags & ChannelContext::kFlagPortamento) != 0) {
+			// reset previous porta
+			if (voice->hasPortamento)
+				voice->baseNote = voice->endNote;
+			voice->preCalcNote = precalcNote(voice->baseNote, patch.tune, voice->octave);
+			voice->noteVolume = (_playerCtx.handleVolume) ? volume + 1 : 128;
+			voice->portaTicks = 0;
+			voice->hasPortamento = true;
+			voice->endNote = channel.lastNote = note;
+			return voiceNum;
+		}
+	}	
+
+	if (voiceNum >= 0) {
+		VoiceContext &voice = _voiceCtx[voiceNum];
+		voice.hasDamper = false;
+		voice.isBlocked = 0;
+		voice.hasPortamento = false;
+		if (voice.channel)
+			killVoice(voiceNum);
+		voice.channel = &channel;
+		voice.patch = &patch;
+		voice.baseNote = note;
+
+		// always base octave on the note in the command, regardless of porta
+		const int32 plainNote = precalcNote(note, patch.tune, 0);
+		// calculate which sample to use
+		const int useOctave = (plainNote <= PREF_PERIOD) ? 0 : MIN<int32>((plainNote + 0xFFFF - PREF_PERIOD) >> 16, patch.sampleOctaves - 1);
+		voice.octave = (byte)useOctave;
+		// adjust precalculated value
+		voice.preCalcNote = plainNote - (useOctave << 16);
+
+		// next calculate the actual period which depends on wether porta is enabled
+		if (&channel < &_channelCtx[kNumChannels] && (channel.flags & ChannelContext::kFlagPortamento) != 0) {
+			if ((channel.flags & ChannelContext::kFlagMono) != 0 && channel.lastNote < 0x80 && channel.lastNote != note) {
+				voice.portaTicks = 0;
+				voice.baseNote = channel.lastNote;
+				voice.endNote = note;
+				voice.hasPortamento = true;
+				voice.preCalcNote = precalcNote(voice.baseNote, patch.tune, voice.octave);
+			}
+			channel.lastNote = note;
+		}
+		
+		voice.lastPeriod = calcNote(voice);
+
+		voice.priority = (byte)pri;
+		voice.status = VoiceContext::kStatusStart;
+
+		voice.noteVolume = (_playerCtx.handleVolume) ? volume + 1 : 128;
+		voice.baseVolume = 0;
+
+		// TODO: since the original player is using the OS-functions, more than 1 sample could be queued up already
+		// get samplestart for the given octave
+		const int8 *samplePtr = patch.samplePtr + (patch.sampleTotalLen << useOctave) - patch.sampleTotalLen;
+		if (patch.sampleAttackLen) {
+			Paula::setChannelSampleStart(voiceNum, samplePtr);
+			Paula::setChannelSampleLen(voiceNum, (patch.sampleAttackLen << useOctave) / 2);
+
+			Paula::enableChannel(voiceNum);
+			// wait  for dma-clear
+		}
+
+		if (patch.sampleTotalLen > patch.sampleAttackLen) {
+			Paula::setChannelSampleStart(voiceNum, samplePtr + (patch.sampleAttackLen << useOctave));
+			Paula::setChannelSampleLen(voiceNum, ((patch.sampleTotalLen - patch.sampleAttackLen) << useOctave) / 2);
+			if (!patch.sampleAttackLen)
+				Paula::enableChannel(voiceNum); // need to enable channel
+			// another pointless wait for DMA-Clear???
+
+		} else { // no sustain sample
+			// this means we must stop playback after the attacksample finished
+			// so we queue up an "empty" sample and note that we need to kill the sample after dma finished
+			Paula::setChannelSampleStart(voiceNum, 0);
+			Paula::setChannelSampleLen(voiceNum, 0);
+			Paula::setChannelDmaCount(voiceNum);
+			voice.dmaOff = 1;
+		}
+
+		Paula::setChannelPeriod(voiceNum, (voice.lastPeriod) ? voice.lastPeriod : 1000);
+		Paula::setChannelVolume(voiceNum, 0);
+	}
+	return voiceNum;
+}
+
+void MaxTrax::resetChannel(ChannelContext &chan, bool rightChannel) {
+	chan.modulation = 0;
+	chan.modulationTime = 1000;
+	chan.microtonal = -1;
+	chan.portamentoTime = 500;
+	chan.pitchBend = NO_BEND;
+	chan.pitchReal = 0;
+	chan.pitchBendRange = MAX_BEND_RANGE;
+	chan.volume = 128;
+	chan.flags &= ~(ChannelContext::kFlagPortamento | ChannelContext::kFlagMicrotonal | ChannelContext::kFlagRightChannel);
+	chan.isAltered = true;
+	if (rightChannel)
+		chan.flags |= ChannelContext::kFlagRightChannel;
+}
+
+void MaxTrax::freeScores() {
+	if (_scores) {
+		for (int i = 0; i < _numScores; ++i)
+			delete[] _scores[i].events;
+		delete[] _scores;
+		_scores = 0;
+	}
+	_numScores = 0;
+	_playerCtx.tempo = 120;
+	_playerCtx.filterOn = true;
+}
+
+void MaxTrax::freePatches() {
+	for (int i = 0; i < ARRAYSIZE(_patch); ++i) {
+		delete[] _patch[i].samplePtr;
+		delete[] _patch[i].attackPtr;
+	}
+	memset(_patch, 0, sizeof(_patch));
+}
+
+void MaxTrax::setSignalCallback(void (*callback) (int)) {
+	Common::StackLock lock(_mutex);
+	_playerCtx.syncCallBack = (callback == 0) ? nullFunc : callback;
+}
+
+int MaxTrax::playNote(byte note, byte patch, uint16 duration, uint16 volume, bool rightSide) {
+	Common::StackLock lock(_mutex);
+	assert(patch < ARRAYSIZE(_patch));
+
+	ChannelContext &channel = _channelCtx[kNumChannels];
+	channel.flags = (rightSide) ? ChannelContext::kFlagRightChannel : 0;
+	channel.isAltered = false;
+	channel.patch = &_patch[patch];
+	const int8 voiceIndex = noteOn(channel, note, (byte)volume, kPriorityNote);
+	if (voiceIndex >= 0)
+		_voiceCtx[voiceIndex].stopEventTime = duration << 8;
+	return voiceIndex;
+}
+
+bool MaxTrax::load(Common::SeekableReadStream &musicData, bool loadScores, bool loadSamples) {
+	Common::StackLock lock(_mutex);
+	stopMusic();
+	if (loadSamples)
+		freePatches();
+	if (loadScores)
+		freeScores();
+	const char *errorMsg = 0;
+	// 0x0000: 4 Bytes Header "MXTX"
+	// 0x0004: uint16 tempo
+	// 0x0006: uint16 flags. bit0 = lowpassfilter, bit1 = attackvolume, bit15 = microtonal	
+	if (musicData.size() < 10 || musicData.readUint32BE() != 0x4D585458) {
+		warning("Maxtrax: File is not a Maxtrax Module");
+		return false;
+	}
+	const uint16 songTempo = musicData.readUint16BE();
+	const uint16 flags = musicData.readUint16BE();
+	if (loadScores) {
+		_playerCtx.tempoInitial = songTempo;
+		_playerCtx.filterOn = (flags & 1) != 0;
+		_playerCtx.handleVolume = (flags & 2) != 0;
+	}
+
+	if (flags & (1 << 15)) {
+		debug(5, "Maxtrax: Song has microtonal");
+#ifdef MAXTRAX_HAS_MICROTONAL
+		if (loadScores) {
+			for (int i = 0; i < ARRAYSIZE(_microtonal); ++i)
+				_microtonal[i] = musicData.readUint16BE();
+		} else
+			musicData.skip(128 * 2);
+#else
+		musicData.skip(128 * 2);
+#endif
+	}
+
+	int scoresLoaded = 0;
+	// uint16 number of Scores
+	const uint16 scoresInFile = musicData.readUint16BE();
+
+	if (musicData.err() || musicData.eos())
+		goto ioError;
+
+	if (loadScores) {
+		const uint16 tempScores = MIN(scoresInFile, _playerCtx.maxScoreNum);
+		Score *curScore = new Score[tempScores];
+		if (!curScore)
+			goto allocError;
+		_scores = curScore;
+		
+		for (scoresLoaded = 0; scoresLoaded < tempScores; ++scoresLoaded, ++curScore) {
+			const uint32 numEvents = musicData.readUint32BE();
+			Event *curEvent = new Event[numEvents];
+			if (!curEvent)
+				goto allocError;
+			curScore->events = curEvent;
+			for (int j = numEvents; j > 0; --j, ++curEvent) {
+				curEvent->command = musicData.readByte();
+				curEvent->parameter = musicData.readByte();
+				curEvent->startTime = musicData.readUint16BE();
+				curEvent->stopTime = musicData.readUint16BE();
+			}
+			curScore->numEvents = numEvents;
+		}
+		_numScores = scoresLoaded;
+	}
+
+	if (loadSamples) {
+		// skip over remaining scores in file
+		for (int i = scoresInFile - scoresLoaded; i > 0; --i)
+			musicData.skip(musicData.readUint32BE() * 6);
+
+		// uint16 number of Samples
+		const uint16 wavesInFile = musicData.readUint16BE();
+		for (int i = wavesInFile; i > 0; --i) {
+			// load disksample structure
+			const uint16 number = musicData.readUint16BE();
+			assert(number < ARRAYSIZE(_patch));
+
+			Patch &curPatch = _patch[number];
+			if (curPatch.attackPtr || curPatch.samplePtr) {
+				delete curPatch.attackPtr;
+				curPatch.attackPtr = 0;
+				delete curPatch.samplePtr;
+				curPatch.samplePtr = 0;
+			}
+			curPatch.tune = musicData.readSint16BE();
+			curPatch.volume = musicData.readUint16BE();
+			curPatch.sampleOctaves = musicData.readUint16BE();
+			curPatch.sampleAttackLen = musicData.readUint32BE();
+			const uint32 sustainLen = musicData.readUint32BE();
+			curPatch.sampleTotalLen = curPatch.sampleAttackLen + sustainLen;
+			// each octave the number of samples doubles.
+			const uint32 totalSamples = curPatch.sampleTotalLen * ((1 << curPatch.sampleOctaves) - 1);
+			curPatch.attackLen = musicData.readUint16BE();
+			curPatch.releaseLen = musicData.readUint16BE();
+			const uint32 totalEnvs = curPatch.attackLen + curPatch.releaseLen;
+
+			// Allocate space for both attack and release Segment.
+			Envelope *envPtr = new Envelope[totalEnvs];
+			if (!envPtr)
+				goto allocError;
+			// Attack Segment
+			curPatch.attackPtr = envPtr;
+			// Release Segment
+			// curPatch.releasePtr = envPtr + curPatch.attackLen;
+
+			// Read Attack and Release Segments
+			for (int j = totalEnvs; j > 0; --j, ++envPtr) {
+				envPtr->duration = musicData.readUint16BE();
+				envPtr->volume = musicData.readUint16BE();
+			}
+
+			// read Samples
+			int8 *allocSamples = new int8[totalSamples];
+			if (!allocSamples)
+				goto allocError;
+			curPatch.samplePtr = allocSamples;
+			musicData.read(allocSamples, totalSamples);
+		}
+	}
+	if (!musicData.err() && !musicData.eos())
+		return true;
+ioError:
+	errorMsg = "Maxtrax: Encountered IO-Error";
+allocError:
+	if (!errorMsg)
+		errorMsg = "Maxtrax: Could not allocate Memory";
+
+	warning("%s", errorMsg);
+	if (loadSamples)
+		freePatches();
+	if (loadScores)
+		freeScores();
+	return false;
+}
+
+#if !defined(NDEBUG) && 0
+void MaxTrax::outPutEvent(const Event &ev, int num) {
+	struct {
+		byte cmd;
+		const char *name;
+		const char *param;
+	} COMMANDS[] = {
+		{0x80, "TEMPO   ", "TEMPO, N/A      "},
+		{0xa0, "SPECIAL ", "CHAN, SPEC # | VAL"},
+		{0xb0, "CONTROL ", "CHAN, CTRL # | VAL"},
+		{0xc0, "PROGRAM ", "CHANNEL, PROG # "},
+		{0xe0, "BEND    ", "CHANNEL, BEND VALUE"},
+		{0xf0, "SYSEX   ", "TYPE, SIZE      "},
+		{0xf8, "REALTIME", "REALTIME, N/A   "},
+		{0xff, "END     ", "N/A, N/A        "},
+		{0xff, "NOTE    ", "VOL | CHAN, STOP"},
+	};
+
+	int i = 0;
+	for (; i < ARRAYSIZE(COMMANDS) - 1 && ev.command != COMMANDS[i].cmd; ++i)
+		;
+
+	if (num == -1)
+		debug("Event    : %02X %s %s %02X %04X %04X", ev.command, COMMANDS[i].name, COMMANDS[i].param, ev.parameter, ev.startTime, ev.stopTime);
+	else
+		debug("Event %3d: %02X %s %s %02X %04X %04X", num, ev.command, COMMANDS[i].name, COMMANDS[i].param, ev.parameter, ev.startTime, ev.stopTime);
+}
+
+void MaxTrax::outPutScore(const Score &sc, int num) {
+	if (num == -1)
+		debug("score   : %i Events", sc.numEvents);
+	else
+		debug("score %2d: %i Events", num, sc.numEvents);
+	for (uint i = 0; i < sc.numEvents; ++i)
+		outPutEvent(sc.events[i], i);
+	debug("");
+}
+#else
+void MaxTrax::outPutEvent(const Event &ev, int num) {}
+void MaxTrax::outPutScore(const Score &sc, int num) {}
+#endif	// #ifndef NDEBUG
+
+}	// End of namespace Audio
+
+#endif // #if defined(SOUND_MODS_MAXTRAX_H)
diff --git a/sound/mods/maxtrax.h b/sound/mods/maxtrax.h
new file mode 100644
index 0000000000..3cd5ebc94b
--- /dev/null
+++ b/sound/mods/maxtrax.h
@@ -0,0 +1,225 @@
+/* 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$
+ *
+ */
+
+// see if all engines using this class are DISABLED
+#if !defined(ENABLE_KYRA)
+
+// normal Header Guard
+#elif !defined SOUND_MODS_MAXTRAX_H
+#define SOUND_MODS_MAXTRAX_H
+
+// #define MAXTRAX_HAS_MODULATION
+// #define MAXTRAX_HAS_MICROTONAL
+
+#include "sound/mods/paula.h"
+
+namespace Audio {
+
+class MaxTrax : public Paula {
+public:
+	MaxTrax(int rate, bool stereo, uint16 vBlankFreq = 50, uint16 maxScores = 128);
+	virtual ~MaxTrax();
+
+	bool load(Common::SeekableReadStream &musicData, bool loadScores = true, bool loadSamples = true);
+	bool playSong(int songIndex, bool loop = false);
+	void advanceSong(int advance = 1);
+	int playNote(byte note, byte patch, uint16 duration, uint16 volume, bool rightSide);
+	void setVolume(const byte volume) { Common::StackLock lock(_mutex); _playerCtx.volume = volume; }
+	void setTempo(const uint16 tempo);
+	void stopMusic();
+	/**
+	 * Set a callback function for sync-events.
+	 * @param callback Callback function, will be called synchronously, so DONT modify the player 
+	 *		directly in response
+	 */
+	void setSignalCallback(void (*callback) (int));
+
+protected:
+	void interrupt();
+
+private:
+	enum { kNumPatches = 64, kNumVoices = 4, kNumChannels = 16, kNumExtraChannels = 1 };
+	enum { kPriorityScore, kPriorityNote, kPrioritySound };
+
+#ifdef MAXTRAX_HAS_MICROTONAL
+	int16	_microtonal[128];
+#endif
+
+	struct Event {
+		uint16	startTime;
+		uint16	stopTime;
+		byte	command;
+		byte	parameter;
+	};
+
+	const struct Score {
+		const Event	*events;
+		uint32	numEvents;
+	} *_scores;
+
+	int _numScores;
+
+	struct {
+		uint32	sineValue;
+		uint16	vBlankFreq;
+		int32	ticks;
+		int32	tickUnit;
+		uint16	frameUnit;
+
+		uint16	maxScoreNum;
+		uint16	tempo;
+		uint16	tempoInitial;
+		uint16	tempoStart;
+		int16	tempoDelta;
+		int32	tempoTime;
+		int32	tempoTicks;
+
+		byte	volume;
+
+		bool	filterOn;
+		bool	handleVolume;
+		bool	musicLoop;
+
+		int		scoreIndex;
+		const Event	*nextEvent;
+		int32	nextEventTime;
+
+		void (*syncCallBack) (int);
+		const Event	*repeatPoint[4];
+		byte	repeatCount[4];
+	} _playerCtx;
+
+	struct Envelope {
+		uint16	duration;
+		uint16	volume;
+	};
+
+	struct Patch {
+		const Envelope *attackPtr;
+		//Envelope *releasePtr;
+		uint16	attackLen;
+		uint16	releaseLen;
+
+		int16	tune;
+		uint16	volume;
+
+		// this was the SampleData struct in the assembler source
+		const int8	*samplePtr;
+		uint32	sampleTotalLen;
+		uint32	sampleAttackLen;
+		uint16	sampleOctaves;
+	} _patch[kNumPatches];
+
+	struct ChannelContext {
+		const Patch	*patch;
+		uint16	regParamNumber;
+
+		uint16	modulation;
+		uint16	modulationTime;
+
+		int16	microtonal;
+
+		uint16	portamentoTime;
+
+		int16	pitchBend;
+		int16	pitchReal;
+		int8	pitchBendRange;
+
+		uint8	volume;
+//		uint8	voicesActive;
+
+		enum {
+			kFlagRightChannel = 1 << 0,
+			kFlagPortamento = 1 << 1,
+			kFlagDamper = 1 << 2,
+			kFlagMono = 1 << 3,
+			kFlagMicrotonal = 1 << 4,
+			kFlagModVolume = 1 << 5
+		};
+		byte	flags;
+		bool	isAltered;
+
+		uint8	lastNote;
+//		uint8	program;
+
+	} _channelCtx[kNumChannels + kNumExtraChannels];
+
+	struct VoiceContext {
+		ChannelContext *channel;
+		const Patch	*patch;
+		const Envelope *envelope;
+//		uint32	uinqueId;
+		int32	preCalcNote;
+		uint32	ticksLeft;
+		int32	portaTicks;
+		int32	incrVolume;
+//		int32	periodOffset;
+		uint16	envelopeLeft;
+		uint16	noteVolume;
+		uint16	baseVolume;
+		uint16	lastPeriod;
+		byte	baseNote;
+		byte	endNote;
+		byte	octave;
+//		byte	number;
+//		byte	link;
+		enum {
+			kStatusFree,
+			kStatusHalt,
+			kStatusDecay,
+			kStatusRelease,
+			kStatusSustain,
+			kStatusAttack,
+			kStatusStart
+		};
+		uint8	isBlocked;
+		uint8	priority;
+		byte	status;
+		byte	lastVolume;
+		byte	tieBreak;
+		bool	hasDamper;
+		bool	hasPortamento;
+		byte	dmaOff;
+
+		int32	stopEventTime;
+	} _voiceCtx[kNumVoices];
+
+	void controlCh(ChannelContext &channel, byte command, byte data);
+	void freePatches();
+	void freeScores();
+	void resetChannel(ChannelContext &chan, bool rightChannel);
+	void resetPlayer();
+
+	int8 pickvoice(uint pick, int16 pri);
+	uint16 calcNote(const VoiceContext &voice);
+	int8 noteOn(ChannelContext &channel, byte note, uint16 volume, uint16 pri);
+	void killVoice(byte num);
+
+	static void outPutEvent(const Event &ev, int num = -1);
+	static void outPutScore(const Score &sc, int num = -1);
+};
+}	// End of namespace Audio
+
+#endif // !defined SOUND_MODS_MAXTRAX_H
diff --git a/sound/mods/paula.cpp b/sound/mods/paula.cpp
index 545390ff93..1f557e0ece 100644
--- a/sound/mods/paula.cpp
+++ b/sound/mods/paula.cpp
@@ -27,19 +27,20 @@
 
 namespace Audio {
 
-Paula::Paula(bool stereo, int rate, int interruptFreq) :
-		_stereo(stereo), _rate(rate), _intFreq(interruptFreq) {
+Paula::Paula(bool stereo, int rate, uint interruptFreq) :
+		_stereo(stereo), _rate(rate), _periodScale((double)kPalPaulaClock / rate), _intFreq(interruptFreq) {
 
 	clearVoices();
-	_voice[0].panning = 63;
-	_voice[1].panning = 191;
-	_voice[2].panning = 191;
-	_voice[3].panning = 63;
+	_voice[0].panning = 191;
+	_voice[1].panning = 63;
+	_voice[2].panning = 63;
+	_voice[3].panning = 191;
 
-	if (_intFreq <= 0)
+	if (_intFreq == 0)
 		_intFreq = _rate;
 
-	_curInt = _intFreq;
+	_curInt = 0;
+	_timerBase = 1;
 	_playing = false;
 	_end = true;
 }
@@ -57,6 +58,7 @@ void Paula::clearVoice(byte voice) {
 	_voice[voice].period = 0;
 	_voice[voice].volume = 0;
 	_voice[voice].offset = 0;
+	_voice[voice].dmaCount = 0;
 }
 
 int Paula::readBuffer(int16 *buffer, const int numSamples) {
@@ -95,18 +97,17 @@ int Paula::readBufferIntern(int16 *buffer, const int numSamples) {
 
 		// Handle 'interrupts'. This gives subclasses the chance to adjust the channel data
 		// (e.g. insert new samples, do pitch bending, whatever).
-		if (_curInt == _intFreq) {
+		if (_curInt == 0) {
+			_curInt = _intFreq;
 			interrupt();
-			_curInt = 0;
 		}
 
 		// Compute how many samples to generate: at most the requested number of samples,
 		// of course, but we may stop earlier when an 'interrupt' is expected.
-		const int nSamples = MIN(samples, _intFreq - _curInt);
+		const uint nSamples = MIN((uint)samples, _curInt);
 
 		// Loop over the four channels of the emulated Paula chip
 		for (int voice = 0; voice < NUM_VOICES; voice++) {
-
 			// No data, or paused -> skip channel
 			if (!_voice[voice].data || (_voice[voice].period <= 0))
 				continue;
@@ -115,8 +116,7 @@ int Paula::readBufferIntern(int16 *buffer, const int numSamples) {
 			// the requested output sampling rate (typicall 44.1 kHz or 22.05 kHz)
 			// as well as the "period" of the channel we are processing right now,
 			// to compute the correct output 'rate'.
-			const double frequency = (7093789.2 / 2.0) / _voice[voice].period;
-			frac_t rate = doubleToFrac(frequency / _rate);
+			frac_t rate = doubleToFrac(_periodScale / _voice[voice].period);
 
 			// Cap the volume
 			_voice[voice].volume = MIN((byte) 0x40, _voice[voice].volume);
@@ -126,50 +126,67 @@ int Paula::readBufferIntern(int16 *buffer, const int numSamples) {
 			frac_t offset = _voice[voice].offset;
 			frac_t sLen = intToFrac(_voice[voice].length);
 			const int8 *data = _voice[voice].data;
+			int dmaCount = _voice[voice].dmaCount;
 			int16 *p = buffer;
 			int end = 0;
 			int neededSamples = nSamples;
+			assert(offset < sLen);
 
 			// Compute the number of samples to generate; that is, either generate
 			// just as many as were requested, or until the buffer is used up.
 			// Note that dividing two frac_t yields an integer (as the denominators
 			// cancel out each other).
 			// Note that 'end' could be 0 here. No harm in that :-).
-			end = MIN(neededSamples, (int)((sLen - offset + rate - 1) / rate));
+			const int leftSamples = (int)((sLen - offset + rate - 1) / rate);
+			end = MIN(neededSamples, leftSamples);
 			mixBuffer<stereo>(p, data, offset, rate, end, _voice[voice].volume, _voice[voice].panning);
 			neededSamples -= end;
 
-			// If we have not yet generated enough samples, and looping is active: loop!
-			if (neededSamples > 0 && _voice[voice].lengthRepeat > 2) {
-
-				// At this point we know that we have used up all samples in the buffer, so reset it.
-				_voice[voice].data = data = _voice[voice].dataRepeat;
+			if (leftSamples > 0 && end == leftSamples) {
+				dmaCount++;
+				data = _voice[voice].data = _voice[voice].dataRepeat;
 				_voice[voice].length = _voice[voice].lengthRepeat;
+				// TODO: offset -= sLen; but make sure there is no way offset >= 2*sLen
+				offset &= FRAC_LO_MASK;
+			}
+
+			// If we have not yet generated enough samples, and looping is active: loop!
+			if (neededSamples > 0 && _voice[voice].length > 2) {
 				sLen = intToFrac(_voice[voice].length);
 
 				// If the "rate" exceeds the sample rate, we would have to perform constant
 				// wrap arounds. So, apply the first step of the euclidean algorithm to
 				// achieve the same more efficiently: Take rate modulo sLen
+				// TODO: This messes up dmaCount and shouldnt happen?
 				if (sLen < rate)
-					rate %= sLen;
+					warning("Paula: length %d is lesser than rate", _voice[voice].length);
+//					rate %= sLen;
 
 				// Repeat as long as necessary.
 				while (neededSamples > 0) {
-					offset = 0;
-
+					// TODO: offset -= sLen; but make sure there is no way offset >= 2*sLen
+					offset &= FRAC_LO_MASK;
+					dmaCount++;
 					// Compute the number of samples to generate (see above) and mix 'em.
 					end = MIN(neededSamples, (int)((sLen - offset + rate - 1) / rate));
 					mixBuffer<stereo>(p, data, offset, rate, end, _voice[voice].volume, _voice[voice].panning);
 					neededSamples -= end;
 				}
+
+				if (offset < sLen)
+					dmaCount--;
+				else
+					offset &= FRAC_LO_MASK;
+
 			}
 
 			// Write back the cached data
 			_voice[voice].offset = offset;
+			_voice[voice].dmaCount = dmaCount;
 
 		}
 		buffer += _stereo ? nSamples * 2 : nSamples;
-		_curInt += nSamples;
+		_curInt -= nSamples;
 		samples -= nSamples;
 	}
 	return numSamples;
diff --git a/sound/mods/paula.h b/sound/mods/paula.h
index e3c6002451..647dc5fe56 100644
--- a/sound/mods/paula.h
+++ b/sound/mods/paula.h
@@ -40,12 +40,29 @@ namespace Audio {
 class Paula : public AudioStream {
 public:
 	static const int NUM_VOICES = 4;
+	enum {
+		kPalSystemClock  = 7093790,
+		kNtscSystemClock = 7159090,
+		kPalCiaClock     = kPalSystemClock / 10,
+		kNtscCiaClock    = kNtscSystemClock / 10,
+		kPalPaulaClock   = kPalSystemClock / 2,
+		kNtscPauleClock  = kNtscSystemClock / 2
+	};
 
-	Paula(bool stereo = false, int rate = 44100, int interruptFreq = 0);
+	Paula(bool stereo = false, int rate = 44100, uint interruptFreq = 0);
 	~Paula();
 
 	bool playing() const { return _playing; }
-	void setInterruptFreq(int freq) { _curInt = _intFreq = freq; }
+	void setTimerBaseValue( uint32 ticksPerSecond ) { _timerBase = ticksPerSecond; }
+	uint32 getTimerBaseValue() { return _timerBase; }
+	void setSingleInterrupt(uint sampleDelay) { assert(sampleDelay < _intFreq); _curInt = sampleDelay; }
+	void setSingleInterruptUnscaled(uint timerDelay) { 
+		setSingleInterrupt((uint)(((double)timerDelay * getRate()) / _timerBase));
+	}
+	void setInterruptFreq(uint sampleDelay) { _intFreq = sampleDelay; _curInt = 0; }
+	void setInterruptFreqUnscaled(uint timerDelay) { 
+		setInterruptFreq((uint)(((double)timerDelay * getRate()) / _timerBase));
+	}
 	void clearVoice(byte voice);
 	void clearVoices() { for (int i = 0; i < NUM_VOICES; ++i) clearVoice(i); }
 	void startPlay(void) { _playing = true; }
@@ -68,6 +85,7 @@ protected:
 		byte volume;
 		frac_t offset;
 		byte panning; // For stereo mixing: 0 = far left, 255 = far right
+		int dmaCount;
 	};
 
 	bool _end;
@@ -90,6 +108,21 @@ protected:
 		_voice[channel].panning = panning;
 	}
 
+	void disableChannel(byte channel) {
+		assert(channel < NUM_VOICES);
+		_voice[channel].data = 0;
+	}
+
+	void enableChannel(byte channel) {
+		assert(channel < NUM_VOICES);
+		Channel &ch = _voice[channel];
+		ch.data = ch.dataRepeat;
+		ch.length = ch.lengthRepeat;
+		// actually first 2 bytes are dropped?
+		ch.offset = intToFrac(0);
+		// ch.period = ch.periodRepeat;
+	}
+
 	void setChannelPeriod(byte channel, int16 period) {
 		assert(channel < NUM_VOICES);
 		_voice[channel].period = period;
@@ -100,6 +133,17 @@ protected:
 		_voice[channel].volume = volume;
 	}
 
+	void setChannelSampleStart(byte channel, const int8 *data) {
+		assert(channel < NUM_VOICES);
+		_voice[channel].dataRepeat = data;
+	}
+
+	void setChannelSampleLen(byte channel, uint32 length) {
+		assert(channel < NUM_VOICES);
+		assert(length < 32768/2);
+		_voice[channel].lengthRepeat = 2 * length;
+	}
+
 	void setChannelData(uint8 channel, const int8 *data, const int8 *dataRepeat, uint32 length, uint32 lengthRepeat, int32 offset = 0) {
 		assert(channel < NUM_VOICES);
 
@@ -110,11 +154,14 @@ protected:
 		assert(lengthRepeat < 32768);
 
 		Channel &ch = _voice[channel];
-		ch.data = data;
+
+		ch.dataRepeat = data;
+		ch.lengthRepeat = length;
+		enableChannel(channel);
+		ch.offset = intToFrac(offset);
+
 		ch.dataRepeat = dataRepeat;
-		ch.length = length;
 		ch.lengthRepeat = lengthRepeat;
-		ch.offset = intToFrac(offset);
 	}
 
 	void setChannelOffset(byte channel, frac_t offset) {
@@ -128,13 +175,29 @@ protected:
 		return _voice[channel].offset;
 	}
 
+	int getChannelDmaCount(byte channel) {
+		assert(channel < NUM_VOICES);
+		return _voice[channel].dmaCount;
+	}
+
+	void setChannelDmaCount(byte channel, int dmaVal = 0) {
+		assert(channel < NUM_VOICES);
+		_voice[channel].dmaCount = dmaVal;
+	}
+
+	void setAudioFilter(bool enable) {
+		// TODO: implement
+	}
+
 private:
 	Channel _voice[NUM_VOICES];
 
 	const bool _stereo;
 	const int _rate;
-	int _intFreq;
-	int _curInt;
+	const double _periodScale;
+	uint _intFreq;
+	uint _curInt;
+	uint32 _timerBase;
 	bool _playing;
 
 	template<bool stereo>
diff --git a/sound/mods/soundfx.cpp b/sound/mods/soundfx.cpp
index 101d8a077d..3af8ca19c6 100644
--- a/sound/mods/soundfx.cpp
+++ b/sound/mods/soundfx.cpp
@@ -46,8 +46,7 @@ public:
 
 	enum {
 		NUM_CHANNELS = 4,
-		NUM_INSTRUMENTS = 15,
-		CIA_FREQ = 715909
+		NUM_INSTRUMENTS = 15
 	};
 
 	SoundFx(int rate, bool stereo);
@@ -75,12 +74,12 @@ protected:
 	uint16 _curPos;
 	uint8 _ordersTable[128];
 	uint8 *_patternData;
-	int _eventsFreq;
 	uint16 _effects[NUM_CHANNELS];
 };
 
 SoundFx::SoundFx(int rate, bool stereo)
 	: Paula(stereo, rate) {
+	setTimerBaseValue(kPalCiaClock);
 	_ticks = 0;
 	_delay = 0;
 	memset(_instruments, 0, sizeof(_instruments));
@@ -89,7 +88,6 @@ SoundFx::SoundFx(int rate, bool stereo)
 	_curPos = 0;
 	memset(_ordersTable, 0, sizeof(_ordersTable));
 	_patternData = 0;
-	_eventsFreq = 0;
 	memset(_effects, 0, sizeof(_effects));
 }
 
@@ -167,8 +165,7 @@ void SoundFx::play() {
 	_curPos = 0;
 	_curOrder = 0;
 	_ticks = 0;
-	_eventsFreq = CIA_FREQ / _delay;
-	setInterruptFreq(getRate() / _eventsFreq);
+	setInterruptFreqUnscaled(_delay);
 	startPaula();
 }
 
@@ -252,7 +249,7 @@ void SoundFx::handleTick() {
 }
 
 void SoundFx::disablePaulaChannel(uint8 channel) {
-	setChannelPeriod(channel, 0);
+	disableChannel(channel);
 }
 
 void SoundFx::setupPaulaChannel(uint8 channel, const int8 *data, uint16 len, uint16 repeatPos, uint16 repeatLen) {
diff --git a/sound/mods/tfmx.cpp b/sound/mods/tfmx.cpp
new file mode 100644
index 0000000000..2ef7d79b7a
--- /dev/null
+++ b/sound/mods/tfmx.cpp
@@ -0,0 +1,1189 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "common/scummsys.h"
+#include "common/endian.h"
+#include "common/stream.h"
+#include "common/util.h"
+#include "common/debug.h"
+
+#include "sound/mods/tfmx.h"
+
+// test for engines using this class.
+#if defined(SOUND_MODS_TFMX_H)
+
+// couple debug-functions
+namespace {
+	void displayPatternstep(const void *const vptr);
+	void displayMacroStep(const void *const vptr);
+
+	const uint16 noteIntervalls[64] = {
+	1710, 1614, 1524, 1438, 1357, 1281, 1209, 1141, 1077, 1017,  960,  908,
+	 856,  810,  764,  720,  680,  642,  606,  571,  539,  509,  480,  454,
+	 428,  404,  381,  360,  340,  320,  303,  286,  270,  254,  240,  227,
+	 214,  202,  191,  180,  170,  160,  151,  143,  135,  127,  120,  113,
+	 214,  202,  191,  180,  170,  160,  151,  143,  135,  127,  120,  113,
+	 214,  202,  191,  180 };
+}
+
+namespace Audio {
+
+Tfmx::Tfmx(int rate, bool stereo)
+	: Paula(stereo, rate), 
+	  _resource(), 
+	  _resourceSample(), 
+	  _playerCtx(),
+	  _deleteResource(false) {
+
+	_playerCtx.stopWithLastPattern = false;
+
+	for (int i = 0; i < kNumVoices; ++i) 
+		_channelCtx[i].paulaChannel = (byte)i;
+
+	_playerCtx.volume = 0x40;
+	_playerCtx.patternSkip = 6;
+	stopSongImpl();
+
+	setTimerBaseValue(kPalCiaClock);
+	setInterruptFreqUnscaled(kPalDefaultCiaVal);
+}
+
+Tfmx::~Tfmx() {
+	freeResourceDataImpl();
+}
+
+void Tfmx::interrupt() {
+	assert(!_end);
+	++_playerCtx.tickCount;
+
+	for (int i = 0; i < kNumVoices; ++i) {
+		if (_channelCtx[i].dmaIntCount) {
+			// wait for DMA Interupts to happen
+			int doneDma = getChannelDmaCount(i);
+			if (doneDma >= _channelCtx[i].dmaIntCount) {
+				_channelCtx[i].dmaIntCount = 0;
+				_channelCtx[i].macroRun = true;
+			}
+		}
+	}
+
+	for (int i = 0; i < kNumVoices; ++i) {
+		ChannelContext &channel = _channelCtx[i];
+
+		if (channel.sfxLockTime >= 0)
+			--channel.sfxLockTime;
+		else {
+			channel.sfxLocked = false;
+			channel.customMacroPrio = 0;
+		}
+
+		// externally queued macros
+		if (channel.customMacro) {
+			const byte *const noteCmd = (const byte *)&channel.customMacro;
+			channel.sfxLocked = false;
+			noteCommand(noteCmd[0], noteCmd[1], (noteCmd[2] & 0xF0) | (uint8)i, noteCmd[3]);
+			channel.customMacro = 0;
+			channel.sfxLocked = (channel.customMacroPrio != 0);
+		}
+
+		// apply timebased effects on Parameters
+		if (channel.macroSfxRun > 0)
+			effects(channel);
+
+		// see if we have to run the macro-program
+		if (channel.macroRun) {
+			if (!channel.macroWait)
+				macroRun(channel);
+			else
+				--channel.macroWait;
+		}
+
+		Paula::setChannelPeriod(i, channel.period);
+		if (channel.macroSfxRun >= 0)
+			channel.macroSfxRun = 1;
+
+		// TODO: handling pending DMAOff?
+	}
+
+	// Patterns are only processed each _playerCtx.timerCount + 1 tick
+	if (_playerCtx.song >= 0 && !_playerCtx.patternCount--) {
+		_playerCtx.patternCount = _playerCtx.patternSkip;
+		advancePatterns();
+	}
+}
+
+void Tfmx::effects(ChannelContext &channel) {
+	// addBegin
+	if (channel.addBeginLength) {
+		channel.sampleStart += channel.addBeginDelta;
+		Paula::setChannelSampleStart(channel.paulaChannel, getSamplePtr(channel.sampleStart));
+		if (!(--channel.addBeginCount)) {
+			channel.addBeginCount = channel.addBeginLength;
+			channel.addBeginDelta = -channel.addBeginDelta;
+		}
+	}
+
+	// vibrato
+	if (channel.vibLength) {
+		channel.vibValue += channel.vibDelta;
+		if (--channel.vibCount == 0) {
+			channel.vibCount = channel.vibLength;
+			channel.vibDelta = -channel.vibDelta;
+		}
+		if (!channel.portaDelta) {
+			// 16x16 bit multiplication, casts needed for the right results
+			channel.period = (uint16)(((uint32)channel.refPeriod * (uint16)((1 << 11) + channel.vibValue)) >> 11);
+		}
+	}
+
+	// portamento
+	if (channel.portaDelta && !(--channel.portaCount)) {
+		channel.portaCount = channel.portaSkip;
+
+		bool resetPorta = true;
+		const uint16 period = channel.refPeriod;
+		uint16 portaVal = channel.portaValue;
+
+		if (period > portaVal) {
+			portaVal = ((uint32)portaVal * (uint16)((1 << 8) + channel.portaDelta)) >> 8;
+			resetPorta = (period <= portaVal);
+
+		} else if (period < portaVal) {
+			portaVal = ((uint32)portaVal * (uint16)((1 << 8) - channel.portaDelta)) >> 8;
+			resetPorta = (period >= portaVal);
+		}
+
+		if (resetPorta) {
+			channel.portaDelta = 0;
+			channel.portaValue = period & 0x7FF;
+		} else
+			channel.period = channel.portaValue = portaVal & 0x7FF;
+	}
+
+	// envelope
+	if (channel.envSkip && !channel.envCount--) {
+		channel.envCount = channel.envSkip;
+
+		const int8 endVol = channel.envEndVolume;
+		int8 volume = channel.volume;
+		bool resetEnv = true;
+
+		if (endVol > volume) {
+			volume += channel.envDelta;
+			resetEnv = endVol <= volume;
+		} else {
+			volume -= channel.envDelta;
+			resetEnv = volume <= 0 || endVol >= volume;
+		}
+
+		if (resetEnv) {
+			channel.envSkip = 0;
+			volume = endVol;
+		}
+		channel.volume = volume;
+	}
+
+	// Fade
+	if (_playerCtx.fadeDelta && !(--_playerCtx.fadeCount)) {
+		_playerCtx.fadeCount = _playerCtx.fadeSkip;
+
+		_playerCtx.volume += _playerCtx.fadeDelta;
+		if (_playerCtx.volume == _playerCtx.fadeEndVolume)
+			_playerCtx.fadeDelta = 0;
+	}
+
+	// Volume
+	const uint8 finVol = _playerCtx.volume * channel.volume >> 6;
+	Paula::setChannelVolume(channel.paulaChannel, finVol);
+}
+
+void Tfmx::macroRun(ChannelContext &channel) {
+	bool deferWait = channel.deferWait;
+	for (;;) {
+		const byte *const macroPtr = (const byte *)(getMacroPtr(channel.macroOffset) + channel.macroStep);
+		++channel.macroStep;
+
+		switch (macroPtr[0]) {
+		case 0x00:	// Reset + DMA Off. Parameters: deferWait, addset, vol
+			clearEffects(channel);
+			// FT
+		case 0x13:	// DMA Off. Parameters:  deferWait, addset, vol
+			// TODO: implement PArameters
+			Paula::disableChannel(channel.paulaChannel);
+			channel.deferWait = deferWait = (macroPtr[1] != 0);
+			if (deferWait) {
+				// if set, then we expect a DMA On in the same tick.
+				channel.period = 4;
+				//Paula::setChannelPeriod(channel.paulaChannel, channel.period);
+				Paula::setChannelSampleLen(channel.paulaChannel, 1);
+				// in this state we then need to allow some commands that normally
+				// would halt the macroprogamm to continue instead.
+				// those commands are: Wait, WaitDMA, AddPrevNote, AddNote, SetNote, <unknown Cmd>
+				// DMA On is affected aswell
+				// TODO remember time disabled, remember pending dmaoff?.
+			}
+
+			if (macroPtr[2] || macroPtr[3]) {
+				channel.volume = (macroPtr[2] ? 0 : channel.relVol * 3) + macroPtr[3];
+				Paula::setChannelVolume(channel.paulaChannel, channel.volume);
+			}
+			continue;
+
+		case 0x01:	// DMA On
+			// TODO: Parameter macroPtr[1] - en-/disable effects
+			channel.dmaIntCount = 0;
+			if (deferWait) {
+				// TODO
+				// there is actually a small delay in the player, but I think that
+				// only allows to clear DMA-State on real Hardware
+			}
+			Paula::setChannelPeriod(channel.paulaChannel, channel.period);
+			Paula::enableChannel(channel.paulaChannel);
+			channel.deferWait = deferWait = false;
+			continue;
+
+		case 0x02:	// Set Beginn. Parameters: SampleOffset(L)
+			channel.addBeginLength = 0;
+			channel.sampleStart = READ_BE_UINT32(macroPtr) & 0xFFFFFF;
+			Paula::setChannelSampleStart(channel.paulaChannel, getSamplePtr(channel.sampleStart));
+			continue;
+
+		case 0x03:	// SetLength. Parameters: SampleLength(W)
+			channel.sampleLen = READ_BE_UINT16(&macroPtr[2]);
+			Paula::setChannelSampleLen(channel.paulaChannel, channel.sampleLen);
+			continue;
+
+		case 0x04:	// Wait. Parameters: Ticks to wait(W).
+			// TODO: some unkown Parameter? (macroPtr[1] & 1)
+			channel.macroWait = READ_BE_UINT16(&macroPtr[2]);
+			break;
+
+		case 0x10:	// Loop Key Up. Parameters: Loopcount, MacroStep(W)
+			if (channel.keyUp)
+				continue;
+			// FT
+		case 0x05:	// Loop. Parameters: Loopcount, MacroStep(W)
+			if (channel.macroLoopCount != 0) {
+				if (channel.macroLoopCount == 0xFF)
+					channel.macroLoopCount = macroPtr[1];
+				channel.macroStep = READ_BE_UINT16(&macroPtr[2]);
+			}
+			--channel.macroLoopCount;
+			continue;
+
+		case 0x06:	// Jump. Parameters: MacroIndex, MacroStep(W)
+			// channel.macroIndex = macroPtr[1] & (kMaxMacroOffsets - 1);
+			channel.macroOffset = _resource->macroOffset[macroPtr[1] & (kMaxMacroOffsets - 1)];
+			channel.macroStep = READ_BE_UINT16(&macroPtr[2]);
+			channel.macroLoopCount = 0xFF;
+			continue;
+
+		case 0x07:	// Stop Macro
+			channel.macroRun = false;
+			--channel.macroStep;
+			return;
+
+		case 0x08:	// AddNote. Parameters: Note, Finetune(W)
+			setNoteMacro(channel, channel.note + macroPtr[1], READ_BE_UINT16(&macroPtr[2]));
+			break;
+
+		case 0x09:	// SetNote. Parameters: Note, Finetune(W)
+			setNoteMacro(channel, macroPtr[1], READ_BE_UINT16(&macroPtr[2]));
+			break;
+
+		case 0x0A:	// Clear Effects
+			clearEffects(channel);
+			continue;
+
+		case 0x0B:	// Portamento. Parameters: count, speed
+			channel.portaSkip = macroPtr[1];
+			channel.portaCount = 1;
+			// if porta is already running, then keep using old value
+			if (!channel.portaDelta)
+				channel.portaValue = channel.refPeriod;
+			channel.portaDelta = READ_BE_UINT16(&macroPtr[2]);
+			continue;
+
+		case 0x0C:	// Vibrato. Parameters: Speed, intensity
+			channel.vibLength = macroPtr[1];
+			channel.vibCount = macroPtr[1] / 2;
+			channel.vibDelta = macroPtr[3];
+			// TODO: Perhaps a bug, vibValue could be left uninitialised
+			if (!channel.portaDelta) {
+				channel.period = channel.refPeriod;
+				channel.vibValue = 0;
+			}
+			continue;
+
+		case 0x0D:	// Add Volume. Parameters: note, addNoteFlag, volume
+			if (macroPtr[2] == 0xFE)
+				setNoteMacro(channel, channel.note + macroPtr[1], 0);
+			channel.volume = channel.relVol * 3 + macroPtr[3];
+			continue;
+
+		case 0x0E:	// Set Volume. Parameters: note, addNoteFlag, volume
+			if (macroPtr[2] == 0xFE)
+				setNoteMacro(channel, channel.note + macroPtr[1], 0);
+			channel.volume = macroPtr[3];
+			continue;
+
+		case 0x0F:	// Envelope. Parameters: speed, count, endvol
+			channel.envDelta = macroPtr[1];
+			channel.envCount = channel.envSkip = macroPtr[2];
+			channel.envEndVolume = macroPtr[3];
+			continue;
+
+		case 0x11:	// Add Beginn. Parameters: times, Offset(W)
+			channel.addBeginLength = channel.addBeginCount = macroPtr[1];
+			channel.addBeginDelta = (int16)READ_BE_UINT16(&macroPtr[2]);
+			channel.sampleStart += channel.addBeginDelta;
+			Paula::setChannelSampleStart(channel.paulaChannel, getSamplePtr(channel.sampleStart));
+			continue;
+
+		case 0x12:	// Add Length. Parameters: added Length(W)
+			channel.sampleLen += (int16)READ_BE_UINT16(&macroPtr[2]);
+			Paula::setChannelSampleLen(channel.paulaChannel, channel.sampleLen);
+			continue;
+
+		case 0x14:	// Wait key up. Parameters: wait cycles
+			if (channel.keyUp || channel.macroLoopCount == 0) {
+				channel.macroLoopCount = 0xFF;
+				continue;
+			} else if (channel.macroLoopCount == 0xFF)
+				channel.macroLoopCount = macroPtr[3];
+			--channel.macroLoopCount;
+			--channel.macroStep;
+			return;
+
+		case 0x15:	// Subroutine. Parameters: MacroIndex, Macrostep(W)
+			channel.macroReturnOffset = channel.macroOffset;
+			channel.macroReturnStep = channel.macroStep;
+
+			channel.macroOffset = _resource->macroOffset[macroPtr[1] & (kMaxMacroOffsets - 1)];
+			channel.macroStep = READ_BE_UINT16(&macroPtr[2]);
+			// TODO: MI does some weird stuff there. Figure out which varioables need to be set
+			continue;
+
+		case 0x16:	// Return from Sub.
+			channel.macroOffset = channel.macroReturnOffset;
+			channel.macroStep = channel.macroReturnStep;
+			continue;
+
+		case 0x17:	// Set Period. Parameters: Period(W)
+			channel.refPeriod = READ_BE_UINT16(&macroPtr[2]);
+			if (!channel.portaDelta) {
+				channel.period = channel.refPeriod;
+				//Paula::setChannelPeriod(channel.paulaChannel, channel.period);
+			}
+			continue;
+
+		case 0x18: {	// Sampleloop. Parameters: Offset from Samplestart(W)
+			// TODO: MI loads 24 bit, but thats useless?
+			const uint16 temp = /* ((int8)macroPtr[1] << 16) | */ READ_BE_UINT16(&macroPtr[2]);
+			if (macroPtr[1] || (temp & 1))
+				warning("Tfmx: Problematic value for sampleloop: %06X", (macroPtr[1] << 16) | temp);
+			channel.sampleStart += temp & 0xFFFE;
+			channel.sampleLen -= (temp / 2) /* & 0x7FFF */;
+			Paula::setChannelSampleStart(channel.paulaChannel, getSamplePtr(channel.sampleStart));
+			Paula::setChannelSampleLen(channel.paulaChannel, channel.sampleLen);
+			continue;
+		}
+		case 0x19:	// Set One-Shot Sample
+			channel.addBeginLength = 0;
+			channel.sampleStart = 0;
+			channel.sampleLen = 1;
+			Paula::setChannelSampleStart(channel.paulaChannel, getSamplePtr(0));
+			Paula::setChannelSampleLen(channel.paulaChannel, 1);
+			continue;
+
+		case 0x1A:	// Wait on DMA. Parameters: Cycles-1(W) to wait
+			channel.dmaIntCount = READ_BE_UINT16(&macroPtr[2]) + 1;
+			channel.macroRun = false;
+			Paula::setChannelDmaCount(channel.paulaChannel);
+			break;
+
+/*		case 0x1B:	// Random play. Parameters: macro/speed/mode
+			warnMacroUnimplemented(macroPtr, 0);
+			continue;*/
+
+		case 0x1C:	// Branch on Note. Parameters: note/macrostep(W)
+			if (channel.note > macroPtr[1])
+				channel.macroStep = READ_BE_UINT16(&macroPtr[2]);
+			continue;
+
+		case 0x1D:	// Branch on Volume. Parameters: volume/macrostep(W)
+			if (channel.volume > macroPtr[1])
+				channel.macroStep = READ_BE_UINT16(&macroPtr[2]);
+			continue;
+
+/*		case 0x1E:	// Addvol+note. Parameters: note/CONST./volume
+			warnMacroUnimplemented(macroPtr, 0);
+			continue;*/
+
+		case 0x1F:	// AddPrevNote. Parameters: Note, Finetune(W)
+			setNoteMacro(channel, channel.prevNote + macroPtr[1], READ_BE_UINT16(&macroPtr[2]));
+			break;
+
+		case 0x20:	// Signal. Parameters: signalnumber, value(W)
+			if (_playerCtx.numSignals > macroPtr[1])
+				_playerCtx.signal[macroPtr[1]] = READ_BE_UINT16(&macroPtr[2]);
+			continue;
+
+		case 0x21:	// Play macro. Parameters: macro, chan, detune
+			noteCommand(channel.note, macroPtr[1], (channel.relVol << 4) | macroPtr[2], macroPtr[3]);
+			continue;
+
+		// 0x22 - 0x29 are used by Gem`X
+		// 0x30 - 0x34 are used by Carribean Disaster
+
+		default:
+			debug(3, "Tfmx: Macro %02X not supported", macroPtr[0]);
+		}
+		if (!deferWait)
+			return;
+	}
+}
+
+void Tfmx::advancePatterns() {
+startPatterns:
+	int runningPatterns = 0;
+
+	for (int i = 0; i < kNumChannels; ++i) {
+		PatternContext &pattern = _patternCtx[i];
+		const uint8 pattCmd = pattern.command;
+		if (pattCmd < 0x90) {	// execute Patternstep
+			++runningPatterns;
+			if (!pattern.wait) {
+				// issue all Steps for this tick
+				if (patternRun(pattern)) {
+					// we load the next Trackstep Command and then process all Channels again
+					if (trackRun(true))
+						goto startPatterns;
+					else
+						break;
+				}
+
+			} else 
+				--pattern.wait;
+
+		} else if (pattCmd == 0xFE) {	// Stop voice in pattern.expose
+			pattern.command = 0xFF;
+			ChannelContext &channel = _channelCtx[pattern.expose & (kNumVoices - 1)];
+			if (!channel.sfxLocked) {
+				haltMacroProgramm(channel);
+				Paula::disableChannel(channel.paulaChannel);
+			}
+		} // else this pattern-Channel is stopped
+	}
+	if (_playerCtx.stopWithLastPattern && !runningPatterns) {
+		stopPaula();
+	}
+}
+
+bool Tfmx::patternRun(PatternContext &pattern) {
+	for (;;) {
+		const byte *const patternPtr = (const byte *)(getPatternPtr(pattern.offset) + pattern.step);
+		++pattern.step;
+		const byte pattCmd = patternPtr[0];
+
+		if (pattCmd < 0xF0) { // Playnote
+			bool doWait = false;
+			byte noteCmd = pattCmd + pattern.expose;
+			byte param3  = patternPtr[3];
+			if (pattCmd < 0xC0) {	// Note
+				if (pattCmd >= 0x80) {	// Wait
+					pattern.wait = param3;
+					param3 = 0;
+					doWait = true;
+				}
+				noteCmd &= 0x3F;
+			}	// else Portamento 
+			noteCommand(noteCmd, patternPtr[1], patternPtr[2], param3);
+			if (doWait)
+				return false;
+
+		} else {	// Patterncommand
+			switch (pattCmd & 0xF) {
+			case 0: 	// End Pattern + Next Trackstep
+				pattern.command = 0xFF;
+				--pattern.step;
+				return true;
+
+			case 1: 	// Loop Pattern. Parameters: Loopcount, PatternStep(W)
+				if (pattern.loopCount != 0) {
+					if (pattern.loopCount == 0xFF)
+						pattern.loopCount = patternPtr[1];
+					pattern.step = READ_BE_UINT16(&patternPtr[2]);
+				}
+				--pattern.loopCount;
+				continue;
+
+			case 2: 	// Jump. Parameters: PatternIndex, PatternStep(W)
+				pattern.offset = _resource->patternOffset[patternPtr[1] & (kMaxPatternOffsets - 1)];
+				pattern.step = READ_BE_UINT16(&patternPtr[2]);
+				continue;
+
+			case 3: 	// Wait. Paramters: ticks to wait
+				pattern.wait = patternPtr[1];
+				return false;
+
+			case 14: 	// Stop custompattern
+				// TODO apparently toggles on/off pattern channel 7
+				debug(3, "Tfmx: Encountered 'Stop custompattern' command");
+				// FT
+			case 4: 	// Stop this pattern
+				pattern.command = 0xFF;
+				--pattern.step;
+				// TODO: try figuring out if this was the last Channel?
+				return false;
+
+			case 5: 	// Key Up Signal. Paramters: channel
+				if (!_channelCtx[patternPtr[2] & (kNumVoices - 1)].sfxLocked)
+					_channelCtx[patternPtr[2] & (kNumVoices - 1)].keyUp = true;
+				continue;
+
+			case 6: 	// Vibrato. Parameters: length, channel, rate
+			case 7: 	// Envelope. Parameters: rate, tempo | channel, endVol
+				noteCommand(pattCmd, patternPtr[1], patternPtr[2], patternPtr[3]);
+				continue;
+
+			case 8: 	// Subroutine. Parameters: pattern, patternstep(W)
+				pattern.savedOffset = pattern.offset;
+				pattern.savedStep = pattern.step;
+
+				pattern.offset = _resource->patternOffset[patternPtr[1] & (kMaxPatternOffsets - 1)];
+				pattern.step = READ_BE_UINT16(&patternPtr[2]);
+				continue;
+
+			case 9: 	// Return from Subroutine
+				pattern.offset = pattern.savedOffset;
+				pattern.step = pattern.savedStep;
+				continue;
+
+			case 10:	// fade. Parameters: tempo, endVol
+				initFadeCommand((uint8)patternPtr[1], (int8)patternPtr[3]);
+				continue;
+
+			case 11:	// play pattern. Parameters: patternCmd, channel, expose
+				initPattern(_patternCtx[patternPtr[2] & (kNumChannels - 1)], patternPtr[1], patternPtr[3], _resource->patternOffset[patternPtr[1] & (kMaxPatternOffsets - 1)]);
+				continue;
+
+			case 12: 	// Lock. Parameters: lockFlag, channel, lockTime
+				_channelCtx[patternPtr[2] & (kNumVoices - 1)].sfxLocked = (patternPtr[1] != 0);
+				_channelCtx[patternPtr[2] & (kNumVoices - 1)].sfxLockTime = patternPtr[3];
+				continue;
+
+			case 13: 	// Cue. Parameters: signalnumber, value(W)
+				if (_playerCtx.numSignals > patternPtr[1])
+					_playerCtx.signal[patternPtr[1]] = READ_BE_UINT16(&patternPtr[2]);
+				continue;
+
+			case 15: 	// NOP
+				continue;
+			}
+		}
+	}
+}
+
+bool Tfmx::trackRun(const bool incStep) {
+	assert(_playerCtx.song >= 0);
+	if (incStep) {
+		// TODO Optionally disable looping
+		if (_trackCtx.posInd == _trackCtx.stopInd)
+			_trackCtx.posInd = _trackCtx.startInd;
+		else
+			++_trackCtx.posInd;
+	}
+	for (;;) {
+		const uint16 *const trackData = getTrackPtr(_trackCtx.posInd);
+
+		if (trackData[0] != FROM_BE_16(0xEFFE)) {
+			// 8 commands for Patterns
+			for (int i = 0; i < 8; ++i) {
+				const uint8 *patCmd = (const uint8 *)&trackData[i];
+				// First byte is pattern number
+				const uint8 patNum = patCmd[0];
+				// if highest bit is set then keep previous pattern
+				if (patNum < 0x80) {
+					initPattern(_patternCtx[i], patNum, patCmd[1], _resource->patternOffset[patNum]);
+				} else {
+					_patternCtx[i].command = patNum;
+					_patternCtx[i].expose = (int8)patCmd[1];
+				}
+			}
+			return true;
+
+		} else {
+			// 16 byte Trackstep Command
+			switch (READ_BE_UINT16(&trackData[1])) {
+			case 0:	// Stop Player. No Parameters
+				stopPaula();
+				return false;
+
+			case 1:	// Branch/Loop section of tracksteps. Parameters: branch target, loopcount
+				if (_trackCtx.loopCount != 0) {
+					if (_trackCtx.loopCount < 0)
+						_trackCtx.loopCount = READ_BE_UINT16(&trackData[3]);
+					_trackCtx.posInd    = READ_BE_UINT16(&trackData[2]);
+					continue;
+				}
+				--_trackCtx.loopCount;
+				break;
+
+			case 2:	{ // Set Tempo. Parameters: tempo, divisor
+				_playerCtx.patternCount = _playerCtx.patternSkip = READ_BE_UINT16(&trackData[2]); // tempo
+				const uint16 temp = READ_BE_UINT16(&trackData[3]); // divisor
+
+				if (!(temp & 0x8000) && (temp & 0x1FF))
+					setInterruptFreqUnscaled(temp & 0x1FF);
+				break;
+			}
+			case 4:	// Fade. Parameters: tempo, endVol
+				// load the LSB of the 16bit words
+				initFadeCommand(((const uint8 *)&trackData[2])[1], ((const int8 *)&trackData[3])[1]);
+				break;
+
+			case 3:	// Unknown, stops player aswell
+			default:
+				debug(3, "Tfmx: Unknown Trackstep Command: %02X", READ_BE_UINT16(&trackData[1]));
+				// MI-Player handles this by stopping the player, we just continue
+			}
+		}
+
+		if (_trackCtx.posInd == _trackCtx.stopInd) {
+			warning("Tfmx: Reached invalid Song-Position");
+			return false;
+		}
+		++_trackCtx.posInd;
+	}
+}
+
+void Tfmx::noteCommand(const uint8 note, const uint8 param1, const uint8 param2, const uint8 param3) {
+	ChannelContext &channel = _channelCtx[param2 & (kNumVoices - 1)];
+
+	if (note == 0xFC) {	// Lock command
+		channel.sfxLocked = (param1 != 0);
+		channel.sfxLockTime = param3; // only 1 byte read! 
+
+	} else if (channel.sfxLocked) {	// Channel still locked, do nothing
+	
+	} else if (note < 0xC0) {	// Play Note - Parameters: note, macro, relVol | channel, finetune
+
+		channel.prevNote = channel.note;
+		channel.note = note;
+		// channel.macroIndex = param1 & (kMaxMacroOffsets - 1);
+		channel.macroOffset = _resource->macroOffset[param1 & (kMaxMacroOffsets - 1)];
+		channel.relVol = param2 >> 4;
+		channel.fineTune = (int8)param3;
+
+		// TODO: the point where the channel gets initialised varies with the games, needs more research.
+		initMacroProgramm(channel);
+		channel.keyUp = false; // key down = playing a Note
+
+	} else if (note < 0xF0) {	// Portamento - Parameters: note, tempo, channel, rate
+		channel.portaSkip = param1;
+		channel.portaCount = 1;
+		if (!channel.portaDelta)
+			channel.portaValue = channel.refPeriod;
+		channel.portaDelta = param3;
+
+		channel.note = note & 0x3F;
+		channel.refPeriod = noteIntervalls[channel.note];
+
+	} else switch (note) {	// Command
+
+		case 0xF5:	// Key Up Signal
+			channel.keyUp = true;
+			break;
+
+		case 0xF6:	// Vibratio - Parameters: length, channel, rate
+			channel.vibLength = param1 & 0xFE;
+			channel.vibCount = param1 / 2;
+			channel.vibDelta = param3;
+			channel.vibValue = 0;
+			break;
+
+		case 0xF7:	// Envelope - Parameters: rate, tempo | channel, endVol
+			channel.envDelta = param1;
+			channel.envCount = channel.envSkip = (param2 >> 4) + 1;
+			channel.envEndVolume = param3;
+			break;
+	}
+}
+
+void Tfmx::initMacroProgramm(ChannelContext &channel) {
+	channel.macroStep = 0;
+	channel.macroWait = 0;
+	channel.macroRun = true;
+	channel.macroSfxRun = 0;
+	channel.macroLoopCount = 0xFF;
+	channel.dmaIntCount = 0;
+	channel.deferWait = false;
+
+	channel.macroReturnOffset = 0;
+	channel.macroReturnStep = 0;
+}
+
+void Tfmx::clearEffects(ChannelContext &channel) {
+	channel.addBeginLength = 0;
+	channel.envSkip = 0;
+	channel.vibLength = 0;
+	channel.portaDelta = 0;
+}
+
+void Tfmx::haltMacroProgramm(ChannelContext &channel) {
+	channel.macroRun = false;
+	channel.dmaIntCount = 0;
+}
+
+void Tfmx::unlockMacroChannel(ChannelContext &channel) {
+	channel.customMacro = 0;
+	channel.customMacroIndex = 0;
+	channel.customMacroPrio = 0;
+	channel.sfxLocked = false;
+	channel.sfxLockTime = -1;
+}
+
+void Tfmx::initPattern(PatternContext &pattern, uint8 cmd, int8 expose, uint32 offset) {
+	pattern.command = cmd;
+	pattern.offset = offset;
+	pattern.expose = expose;
+	pattern.step = 0;
+	pattern.wait = 0;
+	pattern.loopCount = 0xFF;
+
+	pattern.savedOffset = 0;
+	pattern.savedStep = 0;
+}
+
+void Tfmx::stopSongImpl(bool stopAudio) {
+	 _playerCtx.song = -1;
+	for (int i = 0; i < kNumChannels; ++i) {
+		_patternCtx[i].command = 0xFF;
+		_patternCtx[i].expose = 0;
+	}
+	if (stopAudio) {
+		stopPaula();
+		for (int i = 0; i < kNumVoices; ++i) {
+			clearEffects(_channelCtx[i]);
+			unlockMacroChannel(_channelCtx[i]);
+			haltMacroProgramm(_channelCtx[i]);
+			_channelCtx[i].note = 0;
+			_channelCtx[i].volume = 0;
+			_channelCtx[i].macroSfxRun = -1;
+			_channelCtx[i].vibValue = 0;
+
+			_channelCtx[i].sampleStart = 0;
+			_channelCtx[i].sampleLen = 2;
+			_channelCtx[i].refPeriod = 4;
+			_channelCtx[i].period = 4;
+			Paula::disableChannel(i);
+		}
+	}
+}
+
+void Tfmx::setNoteMacro(ChannelContext &channel, uint note, int fineTune) {
+	const uint16 noteInt = noteIntervalls[note & 0x3F];
+	const uint16 finetune = (uint16)(fineTune + channel.fineTune + (1 << 8));
+	channel.refPeriod = ((uint32)noteInt * finetune >> 8);
+	if (!channel.portaDelta)
+		channel.period = channel.refPeriod;
+}
+
+void Tfmx::initFadeCommand(const uint8 fadeTempo, const int8 endVol) {
+	_playerCtx.fadeCount = _playerCtx.fadeSkip = fadeTempo;
+	_playerCtx.fadeEndVolume = endVol;
+
+	if (fadeTempo) {
+		const int diff = _playerCtx.fadeEndVolume - _playerCtx.volume;
+		_playerCtx.fadeDelta = (diff != 0) ? ((diff > 0) ? 1 : -1) : 0;
+	} else {
+		_playerCtx.volume = endVol;
+		_playerCtx.fadeDelta = 0;
+	}
+}
+
+void Tfmx::setModuleData(Tfmx &otherPlayer) {
+	setModuleData(otherPlayer._resource, otherPlayer._resourceSample.sampleData, otherPlayer._resourceSample.sampleLen, false);
+}
+
+bool Tfmx::load(Common::SeekableReadStream &musicData, Common::SeekableReadStream &sampleData, bool autoDelete) {
+	const MdatResource *mdat = loadMdatFile(musicData);
+	if (mdat) {
+		uint32 sampleLen = 0;
+		const int8 *sampleDat = loadSampleFile(sampleLen, sampleData);
+		if (sampleDat) {
+			setModuleData(mdat, sampleDat, sampleLen, autoDelete);
+			return true;
+		}
+		delete[] mdat->mdatAlloc;
+		delete mdat;
+	}
+	return false;
+}
+
+void Tfmx::freeResourceDataImpl() {
+	if (_deleteResource) {
+		if (_resource) {
+			delete[] _resource->mdatAlloc;
+			delete _resource;
+		}
+		delete[] _resourceSample.sampleData;
+	}
+	_resource = 0;
+	_resourceSample.sampleData = 0;
+	_resourceSample.sampleLen = 0;
+	_deleteResource = false;
+}
+
+void Tfmx::setModuleData(const MdatResource *resource, const int8 *sampleData, uint32 sampleLen, bool autoDelete) {
+	Common::StackLock lock(_mutex);
+	stopSongImpl(true);
+	freeResourceDataImpl();
+	_resource = resource;
+	_resourceSample.sampleData = sampleData;
+	_resourceSample.sampleLen = sampleData ? sampleLen : 0;
+	_deleteResource = autoDelete;
+}
+
+const int8 *Tfmx::loadSampleFile(uint32 &sampleLen, Common::SeekableReadStream &sampleStream) {
+	sampleLen = 0;
+
+	const int32 sampleSize = sampleStream.size();
+	if (sampleSize < 4) {
+		warning("Tfmx: Cant load Samplefile");
+		return false;
+	}
+
+	int8 *sampleAlloc = new int8[sampleSize];
+	if (!sampleAlloc) {
+		warning("Tfmx: Could not allocate Memory: %dKB", sampleSize / 1024);
+		return 0;
+	}
+
+	if (sampleStream.read(sampleAlloc, sampleSize) == (uint32)sampleSize) {
+		sampleAlloc[0] = sampleAlloc[1] = sampleAlloc[2] = sampleAlloc[3] = 0;
+		sampleLen = sampleSize;
+	} else {
+		delete sampleAlloc;
+		warning("Tfmx: Encountered IO-Error");
+		return 0;
+	}
+	return sampleAlloc;
+}
+
+const Tfmx::MdatResource *Tfmx::loadMdatFile(Common::SeekableReadStream &musicData) {
+	bool hasHeader = false;
+	const int32 mdatSize = musicData.size();
+	if (mdatSize >= 0x200) {
+		byte buf[16] = { 0 };
+		// 0x0000: 10 Bytes Header "TFMX-SONG "
+		musicData.read(buf, 10);
+		hasHeader = memcmp(buf, "TFMX-SONG ", 10) == 0;
+	}
+	
+	if (!hasHeader) {
+		warning("Tfmx: File is not a Tfmx Module");
+		return 0;
+	}
+
+	MdatResource *resource = new MdatResource;
+
+	resource->mdatAlloc = 0;
+	resource->mdatData = 0;
+	resource->mdatLen = 0;
+
+	// 0x000A: int16 flags
+	resource->headerFlags = musicData.readUint16BE();
+	// 0x000C: int32 ?
+	// 0x0010: 6*40 Textfield
+	musicData.skip(4 + 6 * 40);
+
+	/* 0x0100: Songstart x 32*/
+	for (int i = 0; i < kNumSubsongs; ++i)
+		resource->subsong[i].songstart = musicData.readUint16BE();
+	/* 0x0140: Songend x 32*/
+	for (int i = 0; i < kNumSubsongs; ++i)
+		resource->subsong[i].songend = musicData.readUint16BE();
+	/* 0x0180: Tempo x 32*/
+	for (int i = 0; i < kNumSubsongs; ++i)
+		resource->subsong[i].tempo  = musicData.readUint16BE();
+
+	/* 0x01c0: unused ? */
+	musicData.skip(16);
+
+	/* 0x01d0: trackstep, pattern data p, macro data p */
+	const uint32 offTrackstep = musicData.readUint32BE();
+	uint32 offPatternP, offMacroP;
+
+	// This is how MI`s TFMX-Player tests for unpacked Modules.
+	if (offTrackstep == 0) { // unpacked File
+		resource->trackstepOffset = 0x600 + 0x200;
+		offPatternP		= 0x200 + 0x200;
+		offMacroP		= 0x400 + 0x200;
+	} else { // packed File
+		resource->trackstepOffset = offTrackstep;
+		offPatternP = musicData.readUint32BE();
+		offMacroP = musicData.readUint32BE();
+	}
+
+	// End of basic header, check if everything worked ok
+	if (musicData.err()) {
+		warning("Tfmx: Encountered IO-Error");
+		delete resource;
+		return 0;
+	}
+
+	// TODO: if a File is packed it could have for Ex only 2 Patterns/Macros
+	// the following loops could then read beyond EOF. 
+	// To correctly handle this it would be necessary to sort the pointers and
+	// figure out the number of Macros/Patterns
+	// We could also analyze pointers if they are correct offsets,
+	// so that accesses can be unchecked later
+
+	// Read in pattern starting offsets
+	musicData.seek(offPatternP);
+	for (int i = 0; i < kMaxPatternOffsets; ++i)
+		resource->patternOffset[i] = musicData.readUint32BE();
+
+	// use last PatternOffset (stored at 0x5FC in mdat) if unpacked File
+	// or fixed offset 0x200 if packed
+	resource->sfxTableOffset = offTrackstep ? 0x200 : resource->patternOffset[127];
+
+	// Read in macro starting offsets
+	musicData.seek(offMacroP);
+	for (int i = 0; i < kMaxMacroOffsets; ++i)
+		resource->macroOffset[i] = musicData.readUint32BE();
+
+	// Read in mdat-file
+	// TODO: we can skip everything thats already stored in the resource-structure.
+	const int32 mdatOffset = offTrackstep ? 0x200 : 0x600;	// 0x200 is very conservative
+	const uint32 allocSize = (uint32)mdatSize - mdatOffset;
+	
+	byte *mdatAlloc = new byte[allocSize];
+	if (!mdatAlloc) {
+		warning("Tfmx: Could not allocate Memory: %dKB", allocSize / 1024);
+		delete resource;
+		return 0;
+	}
+	musicData.seek(mdatOffset);
+	if (musicData.read(mdatAlloc, allocSize) == allocSize) {
+		resource->mdatAlloc = mdatAlloc;
+		resource->mdatData = mdatAlloc - mdatOffset;
+		resource->mdatLen = mdatSize;
+	} else {
+		delete mdatAlloc;
+		warning("Tfmx: Encountered IO-Error");
+		delete resource;
+		return 0;
+	}
+
+	return resource;
+}
+
+void Tfmx::doMacro(int note, int macro, int relVol, int finetune, int channelNo) {
+	assert(0 <= macro && macro < kMaxMacroOffsets);
+	assert(0 <= note && note < 0xC0);
+	Common::StackLock lock(_mutex);
+
+	if (!hasResources())
+		return;
+	channelNo &= (kNumVoices - 1);
+	ChannelContext &channel = _channelCtx[channelNo];
+	unlockMacroChannel(channel);
+
+	noteCommand((uint8)note, (uint8)macro, (uint8)((relVol << 4) | channelNo), (uint8)finetune);
+	startPaula();
+}
+
+void Tfmx::stopMacroEffect(int channel) {
+	assert(0 <= channel && channel < kNumVoices);
+	Common::StackLock lock(_mutex);
+	unlockMacroChannel(_channelCtx[channel]);
+	haltMacroProgramm(_channelCtx[channel]);
+	Paula::disableChannel(_channelCtx[channel].paulaChannel);
+}
+
+void Tfmx::doSong(int songPos, bool stopAudio) {
+	assert(0 <= songPos && songPos < kNumSubsongs);
+	Common::StackLock lock(_mutex);
+
+	stopSongImpl(stopAudio);
+
+	if (!hasResources())
+		return;
+
+	_trackCtx.loopCount = -1;
+	_trackCtx.startInd = _trackCtx.posInd = _resource->subsong[songPos].songstart;
+	_trackCtx.stopInd = _resource->subsong[songPos].songend;
+	_playerCtx.song = (int8)songPos;
+
+	const bool palFlag = (_resource->headerFlags & 2) != 0;
+	const uint16 tempo = _resource->subsong[songPos].tempo;
+	uint16 ciaIntervall;
+	if (tempo >= 0x10) {
+		ciaIntervall = (uint16)(kCiaBaseInterval / tempo);
+		_playerCtx.patternSkip = 0;
+	} else {
+		ciaIntervall = palFlag ? (uint16)kPalDefaultCiaVal : (uint16)kNtscDefaultCiaVal;
+		_playerCtx.patternSkip = tempo;
+	}
+	setInterruptFreqUnscaled(ciaIntervall);
+	Paula::setAudioFilter(true);
+
+	_playerCtx.patternCount = 0;
+	if (trackRun())
+		startPaula();
+}
+
+int Tfmx::doSfx(uint16 sfxIndex, bool unlockChannel) {
+	assert(sfxIndex < 128);
+	Common::StackLock lock(_mutex);
+
+	if (!hasResources())
+		return -1;
+	const byte *sfxEntry = getSfxPtr(sfxIndex);
+	if (sfxEntry[0] == 0xFB) {
+		warning("Tfmx: custom patterns are not supported");
+		// custompattern
+		/* const uint8 patCmd = sfxEntry[2];
+		const int8 patExp = (int8)sfxEntry[3]; */
+	} else {
+		// custommacro
+		const byte channelNo = ((_playerCtx.song >= 0) ? sfxEntry[2] : sfxEntry[4]) & (kNumVoices - 1);
+		const byte priority = sfxEntry[5] & 0x7F;
+
+		ChannelContext &channel = _channelCtx[channelNo];
+		if (unlockChannel)
+			unlockMacroChannel(channel);
+
+		const int16 sfxLocktime = channel.sfxLockTime;
+		if (priority >= channel.customMacroPrio || sfxLocktime < 0) {
+			if (sfxIndex != channel.customMacroIndex || sfxLocktime < 0 || (sfxEntry[5] < 0x80)) {
+				channel.customMacro = READ_UINT32(sfxEntry); // intentionally not "endian-correct"
+				channel.customMacroPrio = priority;
+				channel.customMacroIndex = (uint8)sfxIndex;
+				debug(3, "Tfmx: running Macro %08X on channel %i - priority: %02X", TO_BE_32(channel.customMacro), channelNo, priority);
+				return channelNo;
+			}
+		}
+	}
+	return -1;
+}
+
+}	// End of namespace Audio
+
+// some debugging functions
+namespace {
+#if !defined(NDEBUG) && 0
+void displayMacroStep(const void *const vptr) {
+	const char *tableMacros[] = {
+		"DMAoff+Resetxx/xx/xx flag/addset/vol   ",
+		"DMAon (start sample at selected begin) ",
+		"SetBegin    xxxxxx   sample-startadress",
+		"SetLen      ..xxxx   sample-length     ",
+		"Wait        ..xxxx   count (VBI''s)    ",
+		"Loop        xx/xxxx  count/step        ",
+		"Cont        xx/xxxx  macro-number/step ",
+		"-------------STOP----------------------",
+		"AddNote     xx/xxxx  note/detune       ",
+		"SetNote     xx/xxxx  note/detune       ",
+		"Reset   Vibrato-Portamento-Envelope    ",
+		"Portamento  xx/../xx count/speed       ",
+		"Vibrato     xx/../xx speed/intensity   ",
+		"AddVolume   ....xx   volume 00-3F      ",
+		"SetVolume   ....xx   volume 00-3F      ",
+		"Envelope    xx/xx/xx speed/count/endvol",
+		"Loop key up xx/xxxx  count/step        ",
+		"AddBegin    xx/xxxx  count/add to start",
+		"AddLen      ..xxxx   add to sample-len ",
+		"DMAoff stop sample but no clear        ",
+		"Wait key up ....xx   count (VBI''s)    ",
+		"Go submacro xx/xxxx  macro-number/step ",
+		"--------Return to old macro------------",
+		"Setperiod   ..xxxx   DMA period        ",
+		"Sampleloop  ..xxxx   relative adress   ",
+		"-------Set one shot sample-------------",
+		"Wait on DMA ..xxxx   count (Wavecycles)",
+		"Random play xx/xx/xx macro/speed/mode  ",
+		"Splitkey    xx/xxxx  key/macrostep     ",
+		"Splitvolume xx/xxxx  volume/macrostep  ",
+		"Addvol+note xx/fe/xx note/CONST./volume",
+		"SetPrevNote xx/xxxx  note/detune       ",
+		"Signal      xx/xxxx  signalnumber/value",
+		"Play macro  xx/.x/xx macro/chan/detune ",
+		"SID setbeg  xxxxxx   sample-startadress",
+		"SID setlen  xx/xxxx  buflen/sourcelen  ",
+		"SID op3 ofs xxxxxx   offset            ",
+		"SID op3 frq xx/xxxx  speed/amplitude   ",
+		"SID op2 ofs xxxxxx   offset            ",
+		"SID op2 frq xx/xxxx  speed/amplitude   ",
+		"SID op1     xx/xx/xx speed/amplitude/TC",
+		"SID stop    xx....   flag (1=clear all)"
+	};
+
+	const byte *const macroData = (const byte *const)vptr;
+	if (macroData[0] < ARRAYSIZE(tableMacros))
+		debug("%s %02X%02X%02X", tableMacros[macroData[0]], macroData[1], macroData[2], macroData[3]);
+	else
+		debug("Unkown Macro #%02X %02X%02X%02X", macroData[0], macroData[1], macroData[2], macroData[3]);
+}
+
+void displayPatternstep(const void *const vptr) {
+	const char *tablePatterns[] = {
+		"End --Next track  step--",
+		"Loop[count     / step.w]",
+		"Cont[patternno./ step.w]",
+		"Wait[count 00-FF--------",
+		"Stop--Stop this pattern-",
+		"Kup^-Set key up/channel]",
+		"Vibr[speed     / rate.b]",
+		"Enve[speed /endvolume.b]",
+		"GsPt[patternno./ step.w]",
+		"RoPt-Return old pattern-",
+		"Fade[speed /endvolume.b]",
+		"PPat[patt./track+transp]",
+		"Lock---------ch./time.b]",
+		"Cue [number.b/  value.w]",
+		"Stop-Stop custompattern-",
+		"NOP!-no operation-------"
+	};
+
+	const byte *const patData = (const byte *const)vptr;
+	const byte command = patData[0];
+	if (command < 0xF0) { // Playnote
+		const byte flags = command >> 6; // 0-1 means note+detune, 2 means wait, 3 means portamento?
+		const char *flagsSt[] = { "Note ", "Note ", "Wait ", "Porta" };
+		debug("%s %02X%02X%02X%02X", flagsSt[flags], patData[0], patData[1], patData[2], patData[3]);
+	} else
+		debug("%s %02X%02X%02X",tablePatterns[command & 0xF], patData[1], patData[2], patData[3]);
+}
+#else
+void displayMacroStep(const void *const vptr, int chan, int index) {}
+void displayPatternstep(const void *const vptr) {}
+#endif
+}	// End of namespace
+
+#endif // #if defined(SOUND_MODS_TFMX_H)
diff --git a/sound/mods/tfmx.h b/sound/mods/tfmx.h
new file mode 100644
index 0000000000..26018d9466
--- /dev/null
+++ b/sound/mods/tfmx.h
@@ -0,0 +1,284 @@
+/* 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$
+ *
+ */
+
+// see if all engines using this class are DISABLED
+#if !defined(ENABLE_SCUMM)
+
+// normal Header Guard
+#elif !defined(SOUND_MODS_TFMX_H)
+#define SOUND_MODS_TFMX_H
+
+#include "sound/mods/paula.h"
+
+namespace Audio {
+
+class Tfmx : public Paula {
+public:
+	Tfmx(int rate, bool stereo);
+	virtual ~Tfmx();
+
+	/**
+	 * Stops a playing Song (but leaves macros running) and optionally also stops the player
+	 *
+	 * @param stopAudio	stops player and audio output
+	 * @param dataSize	number of bytes to be written
+	 * @return the number of bytes which were actually written.
+	 */
+	void stopSong(bool stopAudio = true) { Common::StackLock lock(_mutex); stopSongImpl(stopAudio); }
+	/**
+	 * Stops currently playing Song (if any) and cues up a new one.
+	 * if stopAudio is specified, the player gets reset before starting the new song
+	 *
+	 * @param songPos	index of Song to play
+	 * @param stopAudio	stops player and audio output
+	 * @param dataSize	number of bytes to be written
+	 * @return the number of bytes which were actually written.
+	 */
+	void doSong(int songPos, bool stopAudio = false);
+	/**
+	 * plays an effect from the sfx-table, does not start audio-playback. 
+	 *
+	 * @param sfxIndex	index of effect to play
+	 * @param unlockChannel	overwrite higher priority effects
+	 * @return	index of the channel which now queued up the effect.
+	 *			-1 in case the effect couldnt be queued up
+	 */
+	int doSfx(uint16 sfxIndex, bool unlockChannel = false);
+	/**
+	 * stop a running macro channel
+	 *
+	 * @param channel	index of effect to stop
+	 */
+	void stopMacroEffect(int channel);
+
+	void doMacro(int note, int macro, int relVol = 0, int finetune = 0, int channelNo = 0);
+	int getTicks() const { return _playerCtx.tickCount; } 
+	int getSongIndex() const { return _playerCtx.song; }
+	void setSignalPtr(uint16 *ptr, uint16 numSignals) { _playerCtx.signal = ptr; _playerCtx.numSignals = numSignals; }
+	void freeResources() { _deleteResource = true; freeResourceDataImpl(); }
+	bool load(Common::SeekableReadStream &musicData, Common::SeekableReadStream &sampleData, bool autoDelete = true);
+	void setModuleData(Tfmx &otherPlayer);
+
+protected:
+	void interrupt();
+
+private:
+	enum { kPalDefaultCiaVal = 11822, kNtscDefaultCiaVal = 14320, kCiaBaseInterval = 0x1B51F8 };
+	enum { kNumVoices = 4, kNumChannels = 8, kNumSubsongs = 32, kMaxPatternOffsets = 128, kMaxMacroOffsets = 128 };
+
+	struct MdatResource {
+		const byte *mdatAlloc;	//!< allocated Block of Memory
+		const byte *mdatData;  	//!< Start of mdat-File, might point before mdatAlloc to correct Offset
+		uint32 mdatLen;
+
+		uint16 headerFlags;
+//		uint32 headerUnknown;
+//		char textField[6 * 40];
+
+		struct Subsong {
+			uint16 songstart;	//!< Index in Trackstep-Table
+			uint16 songend;		//!< Last index in Trackstep-Table
+			uint16 tempo;
+		} subsong[kNumSubsongs];
+
+		uint32 trackstepOffset;	//!< Offset in mdat
+		uint32 sfxTableOffset;
+
+		uint32 patternOffset[kMaxPatternOffsets];	//!< Offset in mdat
+		uint32 macroOffset[kMaxMacroOffsets];	//!< Offset in mdat
+
+		void boundaryCheck(const void *address, size_t accessLen = 1) const {
+			assert(mdatAlloc <= address && (const byte *)address + accessLen <= (const byte *)mdatData + mdatLen);
+		}
+	} const *_resource;
+
+	struct SampleResource {
+		const int8 *sampleData;	//!< The whole sample-File
+		uint32 sampleLen;
+
+		void boundaryCheck(const void *address, size_t accessLen = 2) const {
+			assert(sampleData <= address && (const byte *)address + accessLen <= (const byte *)sampleData + sampleLen);
+		}
+	} _resourceSample;
+
+	bool _deleteResource;
+
+	bool hasResources() {
+		return _resource && _resource->mdatLen && _resourceSample.sampleLen;
+	}
+
+	struct ChannelContext {
+		byte	paulaChannel;
+
+//		byte	macroIndex;
+		uint16	macroWait;
+		uint32	macroOffset;
+		uint32	macroReturnOffset;
+		uint16	macroStep;
+		uint16	macroReturnStep;
+		uint8	macroLoopCount;
+		bool	macroRun;
+		int8	macroSfxRun;	//!< values are the folowing: -1 macro disabled, 0 macro init, 1 macro running
+
+		uint32	customMacro;
+		uint8	customMacroIndex;
+		uint8	customMacroPrio;
+
+		bool	sfxLocked;
+		int16	sfxLockTime;
+		bool	keyUp;
+
+		bool	deferWait;
+		uint16	dmaIntCount;
+
+		uint32	sampleStart;
+		uint16	sampleLen;
+		uint16	refPeriod;
+		uint16	period;
+
+		int8	volume;
+		uint8	relVol;
+		uint8	note;
+		uint8	prevNote;
+		int16	fineTune; // always a signextended byte
+
+		uint8	portaSkip;
+		uint8	portaCount;
+		uint16	portaDelta;
+		uint16	portaValue;
+
+		uint8	envSkip;
+		uint8	envCount;
+		uint8	envDelta;
+		int8	envEndVolume;
+
+		uint8	vibLength;
+		uint8	vibCount;
+		int16	vibValue;
+		int8	vibDelta;
+
+		uint8	addBeginLength;
+		uint8	addBeginCount;
+		int32	addBeginDelta;
+	} _channelCtx[kNumVoices];
+
+	struct PatternContext {
+		uint32	offset; // patternStart, Offset from mdat
+		uint32	savedOffset;	// for subroutine calls
+		uint16	step;	// distance from patternStart
+		uint16	savedStep;
+
+		uint8	command;
+		int8	expose; 
+		uint8	loopCount;
+		uint8	wait;	//!< how many ticks to wait before next Command
+	} _patternCtx[kNumChannels];
+
+	struct TrackStepContext {
+		uint16	startInd;
+		uint16	stopInd;
+		uint16	posInd;
+		int16	loopCount;
+	} _trackCtx;
+
+	struct PlayerContext {
+		int8	song;	//!< >= 0 if Song is running (means process Patterns)
+
+		uint16	patternCount;
+		uint16	patternSkip;	//!< skip that amount of CIA-Interrupts
+
+		int8	volume;	//!< Master Volume
+
+		uint8	fadeSkip;
+		uint8	fadeCount;
+		int8	fadeEndVolume;
+		int8	fadeDelta;
+
+		int		tickCount;
+
+		uint16	*signal;
+		uint16	numSignals;
+
+		bool	stopWithLastPattern; //!< hack to automatically stop the whole player if no Pattern is running
+	} _playerCtx;
+
+	const byte *getSfxPtr(uint16 index = 0) const {
+		const byte *sfxPtr = (const byte *)(_resource->mdatData + _resource->sfxTableOffset + index * 8);
+
+		_resource->boundaryCheck(sfxPtr, 8);
+		return sfxPtr;
+	}
+
+	const uint16 *getTrackPtr(uint16 trackstep = 0) const {
+		const uint16 *trackData = (const uint16 *)(_resource->mdatData + _resource->trackstepOffset + 16 * trackstep);
+
+		_resource->boundaryCheck(trackData, 16);
+		return trackData;
+	}
+
+	const uint32 *getPatternPtr(uint32 offset) const {
+		const uint32 *pattData = (const uint32 *)(_resource->mdatData + offset);
+
+		_resource->boundaryCheck(pattData, 4);
+		return pattData;
+	}
+
+	const uint32 *getMacroPtr(uint32 offset) const {
+		const uint32 *macroData = (const uint32 *)(_resource->mdatData + offset);
+
+		_resource->boundaryCheck(macroData, 4);
+		return macroData;
+	}
+
+	const int8 *getSamplePtr(const uint32 offset) const {
+		const int8 *sample = _resourceSample.sampleData + offset;
+
+		_resourceSample.boundaryCheck(sample, 2);
+		return sample;
+	}
+
+	static inline void initMacroProgramm(ChannelContext &channel);
+	static inline void clearEffects(ChannelContext &channel);
+	static inline void haltMacroProgramm(ChannelContext &channel);
+	static inline void unlockMacroChannel(ChannelContext &channel);
+	static inline void initPattern(PatternContext &pattern, uint8 cmd, int8 expose, uint32 offset);
+	void stopSongImpl(bool stopAudio = true);
+	static void inline setNoteMacro(ChannelContext &channel, uint note, int fineTune);
+	void initFadeCommand(const uint8 fadeTempo, const int8 endVol);
+	void setModuleData(const MdatResource *resource, const int8 *sampleData, uint32 sampleLen, bool autoDelete = true);
+	static const MdatResource *loadMdatFile(Common::SeekableReadStream &musicData);
+	static const int8 *loadSampleFile(uint32 &sampleLen, Common::SeekableReadStream &sampleStream);	
+	void freeResourceDataImpl();
+	void effects(ChannelContext &channel);
+	void macroRun(ChannelContext &channel);
+	void advancePatterns();
+	bool patternRun(PatternContext &pattern);
+	bool trackRun(bool incStep = false);
+	void noteCommand(uint8 note, uint8 param1, uint8 param2, uint8 param3);
+};
+
+}	// End of namespace Audio
+
+#endif // !defined(SOUND_MODS_TFMX_H)
diff --git a/sound/module.mk b/sound/module.mk
index 3bcdd47c56..aabe7fe729 100644
--- a/sound/module.mk
+++ b/sound/module.mk
@@ -24,11 +24,13 @@ MODULE_OBJS := \
 	vorbis.o \
 	wave.o \
 	mods/infogrames.o \
+	mods/maxtrax.o \
 	mods/module.o \
 	mods/protracker.o \
 	mods/paula.o \
 	mods/rjp1.o \
 	mods/soundfx.o \
+	mods/tfmx.o \
 	softsynth/adlib.o \
 	softsynth/opl/dosbox.o \
 	softsynth/opl/mame.o \