Implemented new Simon MIDI module, switching from MidiStreamer to MidiParser. Restructuring enables XMIDI support and vc_72 implementation. Various cleanup on MidiParser's and MidiDriver's.

svn-id: r7654

12 files changed, 355 insertions, 500 deletions

diff --git a/backends/midi/adlib.cpp b/backends/midi/adlib.cpp
index 769ad3e0d2..909aa655a8 100644
--- a/backends/midi/adlib.cpp
+++ b/backends/midi/adlib.cpp
@@ -867,6 +867,9 @@ int MidiDriver_ADLIB::open() {
 }
 
 void MidiDriver_ADLIB::close() {
+	if (!_isOpen)
+		return;
+
 	uint i;
 	for (i = 0; i < ARRAYSIZE(_voices); ++i) {
 		if (_voices [i]._part)
diff --git a/backends/midi/windows.cpp b/backends/midi/windows.cpp
index 91cb3ccf87..e1b61cbaa6 100644
--- a/backends/midi/windows.cpp
+++ b/backends/midi/windows.cpp
@@ -65,6 +65,8 @@ int MidiDriver_WIN::open() {
 }
 
 void MidiDriver_WIN::close() {
+	if (!_isOpen)
+		return;
 	_isOpen = false;
 	midiOutUnprepareHeader (_mo, &_streamHeader, sizeof (_streamHeader));
 	check_error(midiOutClose(_mo));
@@ -83,7 +85,6 @@ void MidiDriver_WIN::send(uint32 b)
 	u.bData[1] = (byte)((b & 0x0000FF00) >> 8);
 	u.bData[0] = (byte)(b & 0x000000FF);
 
-	// printMidi(u.bData[0], u.bData[1], u.bData[2], u.bData[3]);
 	check_error(midiOutShortMsg(_mo, u.dwData));
 }
 
diff --git a/scummvm.dsp b/scummvm.dsp
index 6aadc648ce..c0ba5fb729 100644
--- a/scummvm.dsp
+++ b/scummvm.dsp
@@ -266,6 +266,10 @@ SOURCE=.\sound\midiparser.h
 # End Source File

 # Begin Source File

 

+SOURCE=.\sound\midiparser_smf.cpp

+# End Source File

+# Begin Source File

+

 SOURCE=.\sound\midiparser_xmidi.cpp

 # End Source File

 # Begin Source File

diff --git a/simon/items.cpp b/simon/items.cpp
index e69b85886e..f2f84fba06 100644
--- a/simon/items.cpp
+++ b/simon/items.cpp
@@ -1451,8 +1451,9 @@ void SimonState::o_unk_127() {
 				_vc72_var3 = 0xffff;
 				_midi_unk2 = 0xffff;
 				if (_game & GF_WIN) {
-					midi.initialize();
-					midi.play();
+					// FIXME: What do we expect to happen at this moment?
+					// midi.initialize();
+					// midi.play();
 				}
 				_vc72_var1 = b;
 			} else {
diff --git a/simon/midi.cpp b/simon/midi.cpp
index ad6ec27a43..0cb9815d31 100644
--- a/simon/midi.cpp
+++ b/simon/midi.cpp
@@ -24,435 +24,298 @@
 #include "scummsys.h"
 #include "common/system.h"
 #include "common/file.h"
-#include "sound/midistreamer.h"
 #include "sound/mixer.h"
 #include "simon/simon.h"
 
-MidiPlayer::MidiPlayer() {
+MidiPlayer::MidiPlayer (OSystem *system) {
 	// Since initialize() is called every time the music changes,
 	// this is where we'll initialize stuff that must persist
 	// between songs.
+	_system = system;
+	_mutex = system->create_mutex();
+	_data = 0;
 	_masterVolume = 255;
+	_num_songs = 0;
+	_currentTrack = 255;
 }
 
-void MidiPlayer::read_all_songs(File *in, uint music) {
-	uint i, num;
-
-	_currentSong = _songs;
-
-	num = in->readByte();
-
-	for (i = 0; i != num; i++) {
-		read_one_song(in, &_songs[i], music);
-	}
+MidiPlayer::~MidiPlayer() {
+	_system->lock_mutex (_mutex);
+	close();
+	_system->unlock_mutex (_mutex);
+	_system->delete_mutex (_mutex);
 }
 
-void MidiPlayer::read_all_songs_old(File *in, uint music) {
-	uint i, num;
+int MidiPlayer::open() {
+	// Don't ever call open without first setting the output driver!
+	if (!_driver)
+		return 255;
 
-	_currentSong = _songs;
-
-	num = 1;
-
-	for (i = 0; i != num; i++) {
-		read_one_song(in, &_songs[i], music);
-	}
+	int ret = _driver->open();
+	if (ret)
+		return ret;
+	_driver->setTimerCallback (this, &onTimer);
+	return 0;
 }
 
-void MidiPlayer::read_all_songs_old(File *in, uint music, uint16 size) {
-	_currentSong = _songs;
-
-	_lastDelay = 0;
-
-	read_one_song(in, &_songs[0], music, size);
-}
-
-void MidiPlayer::read_mthd(File *in, Song *s, bool old, uint music, uint16 size) {
-	Track *t;
-	uint i;
-
-	if (!old) {
-		if (in->readUint32BE() != 6)
-			error("Invalid 'MThd' chunk size");
-		s->midi_format = in->readUint16BE();
-		s->num_tracks = in->readUint16BE();
-		s->ppqn = in->readUint16BE();
-	} else {
-		s->midi_format = 0;
-		s->num_tracks = 1;
-		s->ppqn = 0xc0;
-
-		in->readUint16BE();
-		in->readByte();
-	}
-
-	s->tracks = t = (Track *)calloc(s->num_tracks, sizeof(Track));
-	if (t == NULL)
-		error("Out of memory when allocating MIDI tracks");
-
-	for (i = 0; i != s->num_tracks; i++, t++) {
-		if (!old) {
-			if (in->readUint32BE() != 'MTrk')
-				error("Midi track has no 'MTrk'");
-
-			t->data_size = in->readUint32BE();
-		} else {
-			//FIXME We currently don't know how to find out music track size for GMF midi format
-			// So we use music files sizes minues header for now to allow looping
-			int music_data_size[] = {8900, 12166, 2848, 3442, 4034, 4508, 7064, 9730, 6014, 4742, 3138,
-						6570, 5384, 8909, 6457, 16321, 2742, 8968, 4804, 8442, 7717,
-						9444, 5800, 1381, 5660, 6684, 2456, 4744, 2455, 1177, 1232,
-						17256, 5103, 8794, 4884, 16};
-			if (size)
-				t->data_size = size - 8;
-			else
-			t->data_size = music_data_size[music] - 8;
-		}
-
-		t->data_ptr = (byte *)calloc(t->data_size, 1);
-		if (t->data_ptr == NULL)
-			error("Out of memory when allocating MIDI track data (%d)", t->data_size);
-
-		in->read(t->data_ptr, t->data_size);
-
-		t->data_cur_size = t->data_size;
-		t->data_cur_ptr = t->data_ptr;
-
-		t->a = 0;
-		t->last_cmd = 0;
-		t->delay = 0;
-
-		if (t->data_cur_size == 0) {
-			t->a |= 1;
-			continue;
-		}
-
-		t->delay = track_read_gamma(t);
-	}
+void MidiPlayer::close() {
+	_system->lock_mutex (_mutex);
+	stop();
+	if (_driver)
+		_driver->close();
+	_driver = NULL;
+	clearConstructs();
+	_system->unlock_mutex (_mutex);
 }
 
-void MidiPlayer::read_one_song(File *in, Song *s, uint music, uint16 size) {
-	_lastDelay = 0;
-
-	s->ppqn = 0;
-	s->midi_format = 0;
-	s->num_tracks = 0;
-	s->tracks = NULL;
+void MidiPlayer::send (uint32 b) {
+	byte volume;
 
-	uint32 id = in->readUint32BE();
-
-	switch (id) {
-	case 'MThd':
-		read_mthd(in, s, false, music, size);
-		break;
-
-	case 'GMF\x1':
-		read_mthd(in, s, true, music, size);
-		break;
-
-	default:
-		error("Midi song has no 'MThd'");
+	// Only thing we care about is volume control changes.
+	if ((b & 0xFFF0) == 0x07B0) {
+		volume = (byte) ((b >> 16) & 0xFF) * _masterVolume / 255;
+		_volumeTable [b & 0xF] = volume;
+		b = (b & 0xFF00FFFF) | (volume << 16);
 	}
 
+	_driver->send (b);
 }
 
-uint32 MidiPlayer::track_read_gamma(Track *t) {
-	uint32 sum;
-	byte b;
-
-	sum = 0;
-	do {
-		b = track_read_byte(t);
-		sum = (sum << 7) | (b & 0x7F);
-	} while (b & 0x80);
+void MidiPlayer::metaEvent (byte type, byte *data, uint16 length) {
+	// Only thing we care about is End of Track.
+	if (type != 0x2F)
+		return;
 
-	return sum;
+	_parser->jumpToTick (0);
 }
 
-byte MidiPlayer::track_read_byte(Track *t) {
-	if (t->a & 1)
-		error("Trying to read byte from MIDI stream when end reached");
-
-	if (!--t->data_cur_size) {
-		t->a |= 1;
+void MidiPlayer::onTimer (void *data) {
+	MidiPlayer *player = (MidiPlayer *) data;
+	if (player->_paused)
+		return;
+	if (player->_parser) {
+		player->_system->lock_mutex (player->_mutex);
+		player->_parser->onTimer();
+		player->_system->unlock_mutex (player->_mutex);
 	}
-
-	return *t->data_cur_ptr++;
 }
 
-void MidiPlayer::initialize() {
-	int res;
-	int i;
-
-	for (i = 0; i != 16; i++)
-		_volumeTable[i] = 127;
-
-	_midiDriver->property(MidiDriver::PROP_TIMEDIV, _songs[0].ppqn);
+void MidiPlayer::jump (uint16 track, uint16 tick) {
+	if (track == _currentTrack)
+		return;
 
-	res = _midiDriver->open();
-	if (res != 0)
-		error("MidiPlayer::initializer, got %s", MidiDriver::getErrorName(res));
+	if (_num_songs > 0) {
+		if (track >= _num_songs)
+			return;
 
-	if (_paused)
-		_midiDriver->pause (true);
-}
+		_system->lock_mutex (_mutex);
 
-int MidiPlayer::fill(MidiEvent *me, int num_event) {
-	uint32 best, j;
-	Track *best_track, *t;
-	bool did_reset;
-	NoteRec midi_tmp_note_rec;
-	int i = 0;
-
-	did_reset = false;
-
-	for (i = 0; i != num_event;) {
-		best_track = NULL;
-		best = 0xFFFFFFFF;
-
-		/* Locate which track that's next */
-		t = _currentSong->tracks;
-		for (j = _currentSong->num_tracks; j; j--, t++) {
-			if (!(t->a & 1)) {
-				if (t->delay < best) {
-					best = t->delay;
-					best_track = t;
-				}
-			}
+		if (_parser) {
+			delete _parser;
+			_parser = 0;
 		}
 
-		if (best_track == NULL) {
-			/* reset tracks if song ended? */
-			if (did_reset) {
-				/* exit if song ended completely */
-				return i;
-			}
-			did_reset = true;
-			reset_tracks();
-			continue;
+		MidiParser *parser = MidiParser::createParser_SMF();
+		parser->setMidiDriver (this);
+		parser->setTimerRate (_driver->getBaseTempo());
+		if (!parser->loadMusic (_songs[track], _song_sizes[track])) {
+			printf ("Error reading track!\n");
+			delete parser;
+			parser = 0;
 		}
 
-		read_next_note(best_track, &midi_tmp_note_rec);
-		if (fill_helper(&midi_tmp_note_rec, me + i))
-			i++;
-
-		if (midi_tmp_note_rec.sysex_data)
-			free(midi_tmp_note_rec.sysex_data);
+		_currentTrack = (byte) track;
+		for (int i = ARRAYSIZE (_volumeTable); i; --i)
+			_volumeTable[i-1] = 127;
+		_parser = parser; // That plugs the power cord into the wall
+
+		_system->unlock_mutex (_mutex);
+	} else if (_parser) {
+		_system->lock_mutex (_mutex);
+		_currentTrack = (byte) track;
+		_parser->setTrack ((byte) track);
+		_parser->jumpToTick (tick - 1);
+		_system->unlock_mutex (_mutex);
 	}
-
-	return i;
 }
 
-int MidiPlayer::on_fill(void *param, MidiEvent *ev, int num) {
-	MidiPlayer *mp = (MidiPlayer *) param;
-	return mp->fill(ev, num);
+void MidiPlayer::stop() {
+	_system->lock_mutex (_mutex);
+	if (_parser)
+		_parser->unloadMusic();
+	_currentTrack = 255;
+	_system->unlock_mutex (_mutex);
 }
 
-bool MidiPlayer::fill_helper(NoteRec *nr, MidiEvent *me) {
-	uint b;
+void MidiPlayer::pause (bool b) {
+	if (_paused == b)
+		return;
+	_paused = b;
 
-	b = nr->delay - _lastDelay;
-	_lastDelay = nr->delay;
+	_system->lock_mutex (_mutex);
+	for (int i = ARRAYSIZE (_volumeTable); i; --i)
+		_driver->send (((_paused ? 0 : (_volumeTable[i-1] * _masterVolume / 255)) << 16) | (7 << 8) | 0xB0 | i);
+	_system->unlock_mutex (_mutex);
+}
 
-	if (nr->cmd < 0xF0) {
-		me->delta = b;
-		me->event = nr->cmd | (nr->param_1 << 8) | (nr->param_2 << 16);
+void MidiPlayer::set_volume (int volume) {
+	if (volume < 0)
+		volume = 0;
+	else if (volume > 255)
+		volume = 255;
 
-		if ((nr->cmd & 0xF0) == 0xB0 && nr->param_1 == 7) {
-			_volumeTable[nr->cmd & 0xF] = nr->param_2;
-//			nr->param_1 = 0x76;
-			me->event = nr->cmd | (nr->param_1 << 8) | ((nr->param_2 * _masterVolume / 255) << 16) /* | MEVT_F_CALLBACK */ ;
-		}
-		return true;
+	if (_masterVolume == volume)
+		return;
 
-	}
+	_masterVolume = volume;
 
-	if (nr->cmd == 0xF0 || nr->cmd == 0xF7 || nr->param_1 != 0x51) {
-		return false;
+	// Now tell all the channels this.
+	_system->lock_mutex (_mutex);
+	if (_driver && !_paused) {
+		for (int i = ARRAYSIZE (_volumeTable); i; --i) {
+			_driver->send (((_volumeTable[i-1] * _masterVolume / 255) << 16) | (7 << 8) | 0xB0 | i);
+		}
 	}
-
-	int tempo = nr->sysex_data[2] | (nr->sysex_data[1] << 8) | (nr->sysex_data[0] << 16);
-//	_midi_var8 = (_currentSong->ppqn * 60000) / tempo;
-
-	me->delta = b;
-	me->event = (MidiStreamer::ME_TEMPO << 24) | tempo;
-
-	return true;
+	_system->unlock_mutex (_mutex);
 }
 
-void MidiPlayer::reset_tracks() {
-	if (_midi_sfx_toggle)
+void MidiPlayer::set_driver(MidiDriver *md) {
+	// Don't try to set this more than once.
+	if (_driver)
 		return;
-
-	Track *t;
-	uint i;
-
-	_lastDelay = 0;
-
-	for (i = 0, t = _currentSong->tracks; i != _currentSong->num_tracks; i++, t++) {
-		t->data_cur_size = t->data_size;
-		t->data_cur_ptr = t->data_ptr;
-		t->a = 0;
-		t->last_cmd = 0;
-		t->delay = 0;
-		if (t->data_cur_size == 0) {
-			t->a |= 1;
-		} else {
-			t->delay = track_read_gamma(t);
-		}
-	}
+	_driver = md;
 }
 
-void MidiPlayer::read_next_note(Track *t, NoteRec *nr) {
-	byte cmd_byte;
-	uint i;
-
-	nr->delay = 0;
-	nr->cmd = 0;
-	nr->param_1 = 0;
-	nr->param_2 = 0;
-	nr->cmd_length = 0;
-	nr->sysex_data = NULL;
-
-	if (t->a & 1 || t->data_cur_size == 0)
-		error("read next note when track ended");
-
-	/* read next midi byte, but skip any pitch bends. */
-	for (;;) {
-		cmd_byte = track_read_byte(t);
-		if ((cmd_byte & 0xF0) != 0xE0)
-			break;
-
-		track_read_byte(t);
-//		track_read_byte(t);
-	}
-
-	if (!(cmd_byte & 0x80)) {
-		/* running status? */
-		if (t->last_cmd == 0)
-			error("Last cmd = 0");
-		nr->cmd = t->last_cmd;
-		nr->param_1 = cmd_byte;
-		cmd_byte = nr->cmd & 0xF0;
-		nr->cmd_length = 2;
-		if (cmd_byte != 0xC0 && cmd_byte != 0xD0) {
-			nr->param_2 = track_read_byte(t);
-			nr->cmd_length++;
-		}
-	} else if ((cmd_byte & 0xF0) != 0xF0) {
-		nr->cmd = cmd_byte;
-		t->last_cmd = cmd_byte;
-		cmd_byte &= 0xF0;
-		nr->cmd_length = (cmd_byte == 0xC0 || cmd_byte == 0xD0) ? 2 : 3;
-
-		if (t->data_cur_size < nr->cmd_length - 1) {
-			error("read_next_note: end of stream");
+void MidiPlayer::clearConstructs() {
+	if (_num_songs > 0) {
+		byte i;
+		for (i = 0; i < _num_songs; ++i) {
+			free (_songs [i]);
 		}
-
-		nr->param_1 = track_read_byte(t);
-		if (nr->cmd_length == 3)
-			nr->param_2 = track_read_byte(t);
-
-	} else if (cmd_byte == 0xF0 || cmd_byte == 0xF7) {
-		nr->cmd = cmd_byte;
-		nr->cmd_length = track_read_gamma(t);
-		if (t->data_cur_size < nr->cmd_length)
-			error("read_next_note: end of stream 2");
-		nr->sysex_data = (byte *)malloc(nr->cmd_length);
-		if (nr->sysex_data == NULL)
-			error("read_next_note: out of memory");
-		for (i = 0; i != nr->cmd_length; i++)
-			nr->sysex_data[i] = track_read_byte(t);
-	} else if (cmd_byte == 0xFF) {
-
-		nr->cmd = cmd_byte;
-		nr->param_1 = track_read_byte(t);
-		nr->cmd_length = track_read_gamma(t);
-		if (nr->cmd_length) {
-			if (t->data_cur_size < nr->cmd_length)
-				error("read_next_note: end of stream 3");
-			nr->sysex_data = (byte *)malloc(nr->cmd_length);
-			if (nr->sysex_data == NULL)
-				error("read_next_note: out of memory");
-			for (i = 0; i != nr->cmd_length; i++)
-				nr->sysex_data[i] = track_read_byte(t);
-		}
-		if (nr->param_1 == 0x2F)
-			t->a |= 1;
-	} else {
-		error("Invalid sysex cmd");
+		_num_songs = 0;
 	}
 
-	nr->delay = t->delay;
-	if (!(t->a & 1)) {
-		t->delay += track_read_gamma(t);
+	if (_data) {
+		free (_data);
+		_data = 0;
 	}
-}
 
-void MidiPlayer::shutdown() {
-	_midiDriver->close();
-	unload();
+	if (_parser) {
+		delete _parser;
+		_parser = 0;
+	}
 }
 
-void MidiPlayer::unload() {
-	uint i, j;
-	Song *s;
-	Track *t;
-	for (i = 0, s = _songs; i != 8; i++, s++) {
-		if (s->tracks) {
-			for (j = 0, t = s->tracks; j != s->num_tracks; j++, t++) {
-				if (t->data_ptr)
-					free(t->data_ptr);
-			}
-			free(s->tracks);
-			s->tracks = NULL;
-		}
+void MidiPlayer::playSMF (File *in) {
+	_system->lock_mutex (_mutex);
+	clearConstructs();
+	uint32 size = in->size() - in->pos();
+	if (size > 64000)
+		size = 64000;
+	_data = (byte *) calloc (size, 1);
+	in->read (_data, size);
+
+	MidiParser *parser = MidiParser::createParser_SMF();
+	parser->setMidiDriver (this);
+	parser->setTimerRate (_driver->getBaseTempo());
+	if (!parser->loadMusic (_data, size)) {
+		printf ("Error reading track!\n");
+		delete parser;
+		parser = 0;
 	}
-}
 
-void MidiPlayer::play() {
-	if (!_paused)
-		_midiDriver->pause(false);
+	_currentTrack = 0;
+	for (int i = ARRAYSIZE (_volumeTable); i; --i)
+		_volumeTable[i-1] = 127;
+	_parser = parser; // That plugs the power cord into the wall
+	_system->unlock_mutex (_mutex);
 }
 
-void MidiPlayer::pause (bool b) {
-	if (_paused == b)
+void MidiPlayer::playMultipleSMF (File *in) {
+	// This is a special case for Simon 2 Windows.
+	// Instead of having multiple sequences as
+	// separate tracks in a Type 2 file, simon2win
+	// has multiple songs, each of which is a Type 1
+	// file. Thus, preceding the songs is a single
+	// byte specifying how many songs are coming.
+	// We need to load ALL the songs and then
+	// treat them as separate tracks -- for the
+	// purpose of jumps, anyway.
+	_system->lock_mutex (_mutex);
+	clearConstructs();
+	_num_songs = in->readByte();
+	if (_num_songs > 16) {
+		printf ("playMultipleSMF: %d is too many songs to keep track of!\n", (int) _num_songs);
+		_system->unlock_mutex (_mutex);
 		return;
-	_paused = b;
-	_midiDriver->pause(b);
+	}
 
-	for (int i = ARRAYSIZE (_volumeTable); i; --i) {
-		_midiDriver->send (((_paused ? 0 : (_volumeTable[i-1] * _masterVolume / 255)) << 16) | (7 << 8) | 0xB0 | i);
+	byte i;
+	for (i = 0; i < _num_songs; ++i) {
+		byte buf[5];
+		uint32 pos = in->pos();
+
+		// Make sure there's a MThd
+		in->read (buf, 4);
+		if (memcmp (buf, "MThd", 4)) {
+			printf ("Expected MThd but found '%c%c%c%c' instead!\n", buf[0], buf[1], buf[2], buf[3]);
+			_system->unlock_mutex (_mutex);
+			return;
+		}
+		in->seek (in->readUint32BE() + in->pos(), SEEK_SET);
+
+		// Now skip all the MTrk blocks
+		while (true) {
+			in->read (buf, 4);
+			if (memcmp (buf, "MTrk", 4))
+				break;
+			in->seek (in->readUint32BE() + in->pos(), SEEK_SET);
+		}
+
+		uint32 pos2 = in->pos() - 4;
+		uint32 size = pos2 - pos;
+		_songs[i] = (byte *) calloc (size, 1);
+		in->seek (pos, SEEK_SET);
+		in->read (_songs[i], size);
+		_song_sizes[i] = size;
 	}
-	
-}
 
-int MidiPlayer::get_volume() {
-	return _masterVolume;
+	_system->unlock_mutex (_mutex);
+	jump (0, 1);
 }
 
-void MidiPlayer::set_volume (int volume) {
-	if (volume < 0)
-		volume = 0;
-	else if (volume > 255)
-		volume = 255;
-
-	if (_masterVolume == volume)
+void MidiPlayer::playXMIDI (File *in) {
+	_system->lock_mutex (_mutex);
+	clearConstructs();
+
+	char buf[4];
+	uint32 pos = in->pos();
+	uint32 size = 4;
+	in->read (buf, 4);
+	if (!memcmp (buf, "FORM", 4)) {
+		while (memcmp (buf, "CAT ", 4)) { size += 4; in->read (buf, 4); }
+		size += 4 + in->readUint32BE();
+		in->seek (pos, 0);
+		_data = (byte *) calloc (size, 1);
+		in->read (_data, size);
+	} else {
+		printf ("ERROR! Expected 'FORM' tag but found '%c%c%c%c' instead!\n", buf[0], buf[1], buf[2], buf[3]);
+		_system->unlock_mutex (_mutex);
 		return;
+	}
 
-	_masterVolume = volume;
-
-	// Now tell all the channels this.
-	if (_midiDriver && !_paused) {
-		for (int i = ARRAYSIZE (_volumeTable); i; --i) {
-			_midiDriver->send (((_volumeTable[i-1] * _masterVolume / 255) << 16) | (7 << 8) | 0xB0 | i);
-		}
+	MidiParser *parser = MidiParser::createParser_XMIDI();
+	parser->setMidiDriver (this);
+	parser->setTimerRate (_driver->getBaseTempo());
+	if (!parser->loadMusic (_data, size)) {
+		printf ("Error reading track!\n");
+		delete parser;
+		parser = 0;
 	}
-}
 
-void MidiPlayer::set_driver(MidiDriver *md) {
-	// We must always use the MidiStreamer front-end
-	// so we can support user-initiated MIDI events (like volume).
-	_midiDriver = new MidiStreamer (md);
-	_midiDriver->set_stream_callback(this, on_fill);
+	_currentTrack = 0;
+	for (int i = ARRAYSIZE (_volumeTable); i; --i)
+		_volumeTable[i-1] = 127;
+	_parser = parser; // That plugs the power cord into the wall
+	_system->unlock_mutex (_mutex);
 }
diff --git a/simon/midi.h b/simon/midi.h
index fe42bfc9df..9c1dd7540f 100644
--- a/simon/midi.h
+++ b/simon/midi.h
@@ -22,79 +22,64 @@
 #ifndef SIMON_MIDI_H
 #define SIMON_MIDI_H
 
-class MidiDriver;
-class MidiStreamer;
-class File;
-struct MidiEvent;
+#include "sound/mididrv.h"
+#include "sound/midiparser.h"
 
-class MidiPlayer {
-public:
-	MidiPlayer();
+class File;
+class OSystem;
 
-	bool _midi_sfx_toggle;
-	void read_all_songs (File *in, uint music);
-	void read_all_songs_old (File *in, uint music, uint16 size);
-	void read_all_songs_old (File *in, uint music);
-	void initialize();
-	void shutdown();
-	void play();
-	void pause (bool b);
-	int  get_volume();
-	void set_volume (int volume);
-	void set_driver (MidiDriver *md);
+class MidiPlayer : public MidiDriver {
+protected:
+	OSystem *_system;
+	void *_mutex;
+	MidiDriver *_driver;
+	MidiParser *_parser;
 
-private:
-	struct Track {
-		uint32 a;
-		uint32 data_size;
-		uint32 data_cur_size;
-		byte *data_ptr;
-		byte *data_cur_ptr;
-		uint32 delay;
-		byte last_cmd;
-	};
-
-	struct Song {
-		uint ppqn;
-		uint midi_format;
-		uint num_tracks;
-		Track *tracks;
-	};
-
-	struct NoteRec {
-		uint32 delay;
-		byte cmd;
-		byte param_1;
-		byte param_2;
-		uint cmd_length;
-		byte *sysex_data;
-	};
-
-	MidiStreamer *_midiDriver;
-	uint _lastDelay;
-	Song *_currentSong;
-	Song _songs[8];
+	byte *_data;
 	byte _volumeTable[16]; // 0-127
 	byte _masterVolume;    // 0-255
 	bool _paused;
+	byte _currentTrack;
 
-	void read_mthd(File *in, Song *s, bool old, uint music, uint16 size);
+	byte _num_songs;
+	byte *_songs[16];
+	uint32 _song_sizes[16];
 
-	void read_one_song(File *in, Song *s, uint music, uint16 size = 0);
+	static void onTimer (void *data);
+	void clearConstructs();
 
-	static uint32 track_read_gamma(Track *t);
-	static byte track_read_byte(Track *t);
+public:
+	bool _midi_sfx_toggle;
+
+	 MidiPlayer (OSystem *system);
+	~MidiPlayer();
 
-	int fill (MidiEvent *me, int num_event);
-	bool fill_helper (NoteRec *nr, MidiEvent *me);
+	void playSMF (File *in);
+	void playMultipleSMF (File *in);
+	void playXMIDI (File *in);
+	void jump (uint16 track, uint16 tick);
+	void stop();
+	void pause (bool b);
 
-	void reset_tracks();
-	void read_next_note(Track *t, NoteRec *nr);
+	int  get_volume() { return _masterVolume; }
+	void set_volume (int volume);
+	void set_driver (MidiDriver *md);
+
+public:
+	// MidiDriver interface implementation
+	int open();
+	void close();
+	void send(uint32 b);
 
-	void unload();
+	void metaEvent (byte type, byte *data, uint16 length);
 
-	static int on_fill(void *param, MidiEvent *ev, int num);
+	// Timing functions - MidiDriver now operates timers
+	void setTimerCallback (void *timer_param, void (*timer_proc) (void *)) { }
+	uint32 getBaseTempo (void) { return _driver ? _driver->getBaseTempo() : 0x4A0000; }
 
+	// Channel allocation functions
+	MidiChannel *allocateChannel() { return 0; }
+	MidiChannel *getPercussionChannel() { return 0; }
 };
 
 #endif
diff --git a/simon/simon.cpp b/simon/simon.cpp
index 494c525713..b2f29de705 100644
--- a/simon/simon.cpp
+++ b/simon/simon.cpp
@@ -170,7 +170,7 @@ Engine *Engine_SIMON_create(GameDetector *detector, OSystem *syst) {
 }
 
 SimonState::SimonState(GameDetector *detector, OSystem *syst)
-	: Engine(detector, syst) {
+	: Engine(detector, syst), midi (syst) {
 	MidiDriver *driver = detector->createMidi();
 
 	_dummy_item_1 = new Item();
@@ -183,6 +183,9 @@ SimonState::SimonState(GameDetector *detector, OSystem *syst)
 	if (!driver)
 		driver = MidiDriver_ADLIB_create();
 	midi.set_driver(driver);
+	int ret = midi.open();
+	if (ret)
+		warning ("MIDI Player init failed: \"%s\"", midi.getErrorName (ret));
 
 	_game = (byte)detector->_features;
 
@@ -857,11 +860,12 @@ void SimonState::playSting(uint a) {
 	if (_mus_file->read(_mus_offsets, size) != size)
 		error("Can't read offsets");
 
-	midi.shutdown();
+	// midi.shutdown();
 	_mus_file->seek(_mus_offsets[a], SEEK_SET);
-	midi.read_all_songs_old(_mus_file, a, _mus_offsets[a+1] - _mus_offsets[a]);
-	midi.initialize();
-	midi.play();
+	// midi.read_all_songs_old(_mus_file, a, _mus_offsets[a+1] - _mus_offsets[a]);
+	// midi.initialize();
+	// midi.play();
+	midi.playSMF (_mus_file);
 }
 
 Subroutine *SimonState::getSubroutineByID(uint subroutine_id) {
@@ -3113,7 +3117,7 @@ void SimonState::processSpecialKeys() {
 			if (_game == GAME_SIMON1DOS) {
 				midi._midi_sfx_toggle ^= 1;
 				if (midi._midi_sfx_toggle)
-					midi.shutdown();
+					midi.stop();
 				else
 					playMusic(0, _last_music_played);
 			} else
@@ -5043,14 +5047,13 @@ void SimonState::playMusic(uint music_unk, uint music) {
 
 	if (_game & GF_SIMON2) {        // Simon 2 music
 		if (_game & GF_WIN) {	
-			midi.shutdown();
+			midi.stop();
 			_game_file->seek(_game_offsets_ptr[gss->MUSIC_INDEX_BASE + music - 1], SEEK_SET);
-			midi.read_all_songs(_game_file, music);
+			midi.playMultipleSMF (_game_file);
 		} else {
-			/* TODO Add XMI midi format support for simon2dos/talkie */
-			//midi.shutdown();
-			//_game_file->seek(_game_offsets_ptr[gss->MUSIC_INDEX_BASE + music - 1], SEEK_SET);
-			//midi.read_xmi_songs(_game_file, music);
+			midi.stop();
+			_game_file->seek(_game_offsets_ptr[gss->MUSIC_INDEX_BASE + music - 1], SEEK_SET);
+			midi.playXMIDI (_game_file);
 		}
 		_midi_unk1 = music;
 		_vc72_var1 = music_unk;
@@ -5066,13 +5069,15 @@ void SimonState::playMusic(uint music_unk, uint music) {
 		} else if (_game & GF_DEMO) {
 			/* TODO Add music support for simon1demo */
 		} else {
-			midi.shutdown();
+			midi.stop();
 			if (_game & GF_WIN) {	
 				_game_file->seek(_game_offsets_ptr[gss->MUSIC_INDEX_BASE + music], SEEK_SET);
-				midi.read_all_songs(_game_file, music);
+				// midi.read_all_songs(_game_file, music);
+				midi.playSMF (_game_file);
 			} else if (_game & GF_TALKIE) {
 				_game_file->seek(_game_offsets_ptr[gss->MUSIC_INDEX_BASE + music], SEEK_SET);
-				midi.read_all_songs_old(_game_file, music);
+				// midi.read_all_songs_old(_game_file, music);
+				midi.playSMF (_game_file);
 			} else {
 				char buf[50];
 				File *f = new File();
@@ -5082,11 +5087,10 @@ void SimonState::playMusic(uint music_unk, uint music) {
 					warning("Can't load music from '%s'", buf);
 					return;
 				}
-				midi.read_all_songs_old(f, music);
+				// midi.read_all_songs_old(f, music);
+				midi.playSMF (f);
 				delete f;
 			}
-			midi.initialize();
-			midi.play();
 		}
 	}
 }
diff --git a/simon/vga.cpp b/simon/vga.cpp
index 39f1575abc..06ddb8a4fc 100644
--- a/simon/vga.cpp
+++ b/simon/vga.cpp
@@ -1814,8 +1814,9 @@ void SimonState::vc_69() {
 	if (_vc72_var1 == 999) {
 		_vc70_var2 = b;
 		if (_game & GF_WIN) {
-			midi.initialize();
-			midi.play();
+			// FIXME: What do we expect to have happen here?
+			// midi.initialize();
+			// midi.play();
 		}
 		_vc72_var1 = b;
 	} else if (_vc72_var1 != 0xFFFF) {
@@ -1854,8 +1855,7 @@ void SimonState::vc_72() {
 		_vc72_var3 = a;
 	}
 
-	if (_debugMode)
-		warning("vc_72(%d,%d): music stuff?", a, b);
+	midi.jump (a, b);
 }
 
 void SimonState::vc_73_set_op189_flag() {
diff --git a/sound/midiparser.h b/sound/midiparser.h
index 3324f4e268..c46c5789d6 100644
--- a/sound/midiparser.h
+++ b/sound/midiparser.h
@@ -34,7 +34,7 @@ protected:
 	uint32 _timer_rate;
 
 public:
-	virtual bool loadMusic (byte *data) = 0;
+	virtual bool loadMusic (byte *data, uint32 size) = 0;
 	virtual void unloadMusic() = 0;
 
 	void setMidiDriver (MidiDriver *driver) { _driver = driver; }
@@ -44,7 +44,7 @@ public:
 	virtual void setTrack (byte track) = 0;
 	virtual void jumpToTick (uint32 tick) = 0;
 
-	static MidiParser *createParser_RIFF();
+	static MidiParser *createParser_SMF();
 	static MidiParser *createParser_XMIDI();
 };
 
diff --git a/sound/midiparser_smf.cpp b/sound/midiparser_smf.cpp
index b429f7484a..5c72ceb21b 100644
--- a/sound/midiparser_smf.cpp
+++ b/sound/midiparser_smf.cpp
@@ -48,8 +48,6 @@ protected:
 	uint32 _ppqn;
 	uint32 _psec_per_tick; // Microseconds per delta tick
 
-	int _lock;
-
 protected:
 	uint32 read4high (byte * &data) {
 		uint32 val = 0;
@@ -109,16 +107,9 @@ uint32 MidiParser_SMF::readVLQ (byte * &data) {
 }
 
 void MidiParser_SMF::onTimer() {
-	if (_lock++) {
-		--_lock;
-		return;
-	}
-
 	if (!_play_pos || !_driver)
 		return;
-
 	playToTime (_play_time + _timer_rate, true);
-	_lock = 0;
 }
 
 void MidiParser_SMF::playToTime (uint32 psec, bool transmit) {
@@ -215,7 +206,6 @@ void MidiParser_SMF::playToTime (uint32 psec, bool transmit) {
 					if (transmit) {
 						_driver->metaEvent (event, pos, (uint16) length);
 					}
-					_lock = 0;
 					return;
 				} else if (event == 0x51) {
 					if (length >= 3) {
@@ -238,8 +228,6 @@ void MidiParser_SMF::playToTime (uint32 psec, bool transmit) {
 	_play_pos = pos;
 }
 
-// This code was adapted from the exult methods
-// XMIDI::ExtractTracks and XMIDI::ExtractTracksFromXmi
 bool MidiParser_SMF::loadMusic (byte *data, uint32 size) {
 	uint32 len;
 	bool isGMD = false; // Indicates an older GMD file without block headers
@@ -465,9 +453,6 @@ void MidiParser_SMF::allNotesOff() {
 }
 
 void MidiParser_SMF::unloadMusic() {
-	while (_lock);
-	++_lock;
-
 	_play_pos = NULL;
 	_data = NULL;
 	_num_tracks = 0;
@@ -476,8 +461,6 @@ void MidiParser_SMF::unloadMusic() {
 	_last_event_time = 0;
 	_running_status = 0;
 	allNotesOff();
-
-	_lock = 0;
 }
 
 void MidiParser_SMF::setTrack (byte track) {
diff --git a/sound/midiparser_xmidi.cpp b/sound/midiparser_xmidi.cpp
index cc165c854c..6e7a40f295 100644
--- a/sound/midiparser_xmidi.cpp
+++ b/sound/midiparser_xmidi.cpp
@@ -51,8 +51,6 @@ protected:
 
 	NoteTimer _notes_cache[32];
 
-	int _lock;
-
 protected:
 	uint32 read4high (byte * &data) {
 		uint32 val = 0;
@@ -69,8 +67,10 @@ protected:
 	uint32 readVLQ (byte * &data);
 	uint32 readVLQ2 (byte * &data);
 
+	void playToTime (uint32 psec, bool transmit);
+
 public:
-	bool loadMusic (byte *data);
+	bool loadMusic (byte *data, uint32 size);
 	void unloadMusic();
 
 	void setMidiDriver (MidiDriver *driver) { _driver = driver; }
@@ -130,6 +130,12 @@ uint32 MidiParser_XMIDI::readVLQ2 (byte * &pos) {
 }
 
 void MidiParser_XMIDI::onTimer() {
+	if (!_play_pos || !_driver)
+		return;
+	playToTime (_play_time + _timer_rate, true);
+}
+
+void MidiParser_XMIDI::playToTime (uint32 psec, bool transmit) {
 	uint32 delta;
 	uint32 end_time;
 	uint32 event_time;
@@ -143,15 +149,7 @@ void MidiParser_XMIDI::onTimer() {
 	byte vel;
 	uint32 note_length;
 	
-	if (_lock++) {
-		--_lock;
-		return;
-	}
-
-	if (!_play_pos || !_driver)
-		return;
-
-	end_time = _play_time + _timer_rate;
+	end_time = psec;
 	pos = _play_pos;
 
 	// Send any necessary note off events.
@@ -159,7 +157,8 @@ void MidiParser_XMIDI::onTimer() {
 	for (i = ARRAYSIZE(_notes_cache); i; --i, ++ptr) {
 		if (ptr->time_left) {
 			if (ptr->time_left <= _timer_rate) {
-				_driver->send (0x80 | ptr->channel | (ptr->note << 8));
+				if (transmit)
+					_driver->send (0x80 | ptr->channel | (ptr->note << 8));
 				ptr->time_left = 0;
 			} else {
 				ptr->time_left -= _timer_rate;
@@ -191,7 +190,8 @@ void MidiParser_XMIDI::onTimer() {
 					ptr->time_left = note_length;
 					ptr->channel = event & 0x0F;
 					ptr->note = note;
-					_driver->send (event | (note << 8) | (vel << 16));
+					if (transmit)
+						_driver->send (event | (note << 8) | (vel << 16));
 					break;
 				}
 			}
@@ -199,7 +199,8 @@ void MidiParser_XMIDI::onTimer() {
 
 		case 0xC: // Program Change
 		case 0xD: // Channel Aftertouch
-			_driver->send (event | (pos[0] << 8));
+			if (transmit)
+				_driver->send (event | (pos[0] << 8));
 			++pos;
 			break;
 
@@ -207,19 +208,22 @@ void MidiParser_XMIDI::onTimer() {
 		case 0xA: // Key Aftertouch
 		case 0xB: // Control Change
 		case 0xE: // Pitch Bender Change
-			_driver->send (event | (pos[0] << 8) | (pos[1] << 16));
+			if (transmit)
+				_driver->send (event | (pos[0] << 8) | (pos[1] << 16));
 			pos += 2;
 			break;
 
 		case 0xF: // Meta or SysEx event
 			switch (event & 0x0F) {
 			case 0x2: // Song Position Pointer
-				_driver->send (event | (pos[0] << 8) | (pos[1] << 16));
+				if (transmit)
+					_driver->send (event | (pos[0] << 8) | (pos[1] << 16));
 				pos += 2;
 				break;
 
 			case 0x3: // Song Select
-				_driver->send (event | (pos[0] << 8));
+				if (transmit)
+					_driver->send (event | (pos[0] << 8));
 				++pos;
 				break;
 
@@ -229,37 +233,42 @@ void MidiParser_XMIDI::onTimer() {
 			case 0xB: // Sequencer Continue
 			case 0xC: // Sequencer Stop
 			case 0xE: // Active Sensing
-				_driver->send (event);
+				if (transmit)
+					_driver->send (event);
+				break;
 
 			case 0x0: // SysEx
 				length = readVLQ (pos);
-				_driver->sysEx (pos, (uint16)(length - 1));
+				if (transmit)
+					_driver->sysEx (pos, (uint16)(length - 1));
 				pos += length;
 				break;
 
 			case 0xF: // META event
 				event = *pos++;
 				length = readVLQ (pos);
-				_driver->metaEvent (event, pos, (uint16) length);
 
-				// End of song must be processed by us,
-				// as well as sending it to the output device.
 				if (event == 0x2F) {
-					// End of song. See if there are still holding notes
-					// we need to wait for.
+					// End of song must be processed by us,
+					// as well as sending it to the output device.
 					ptr = &_notes_cache[0];
 					for (i = ARRAYSIZE(_notes_cache); i; --i, ++ptr) {
 						if (ptr->time_left) {
-							_driver->send (0x80 | ptr->channel | (ptr->note << 8));
+							if (transmit)
+								_driver->send (0x80 | ptr->channel | (ptr->note << 8));
 							ptr->time_left = 0;
 						}
 					}
 					_play_pos = 0;
-					_lock = 0;
+					if (transmit)
+						_driver->metaEvent (event, pos, (uint16) length);
 					return;
 				}
 
+				if (transmit)
+					_driver->metaEvent (event, pos, (uint16) length);
 				pos += length;
+				break;
 			}
 		}
 
@@ -268,12 +277,9 @@ void MidiParser_XMIDI::onTimer() {
 
 	_play_time = end_time;
 	_play_pos = pos;
-	_lock = 0;
 }
 
-// This code was adapted from the exult methods
-// XMIDI::ExtractTracks and XMIDI::ExtractTracksFromXmi
-bool MidiParser_XMIDI::loadMusic (byte *data) {
+bool MidiParser_XMIDI::loadMusic (byte *data, uint32 size) {
 	uint32 i = 0;
 	byte *start;
 	uint32 len;
@@ -419,9 +425,6 @@ void MidiParser_XMIDI::unloadMusic() {
 	int i;
 	NoteTimer *ptr;
 
-	while (_lock);
-	++_lock;
-
 	_play_pos = NULL;
 	_data = NULL;
 	_num_tracks = 0;
@@ -437,8 +440,6 @@ void MidiParser_XMIDI::unloadMusic() {
 			ptr->time_left = 0;
 		}
 	}
-
-	_lock = 0;
 }
 
 void MidiParser_XMIDI::setTrack (byte track) {
@@ -451,7 +452,15 @@ void MidiParser_XMIDI::setTrack (byte track) {
 }
 
 void MidiParser_XMIDI::jumpToTick (uint32 tick) {
-	// TODO: Implement this.
+	if (_active_track >= _num_tracks)
+		return;
+	_play_pos = _tracks[_active_track];
+	_play_time = 0;
+	_last_event_time = 0;
+	if (tick > 0) {
+		printf ("jumpToTick (%ld) not completely implemented!\n", tick);
+		playToTime (tick * MICROSECONDS_PER_TICK - 1, false);
+	}
 }
 
 MidiParser *MidiParser::createParser_XMIDI() { return new MidiParser_XMIDI; }
diff --git a/sound/module.mk b/sound/module.mk
index b83973ed8b..ed7a090a2c 100644
--- a/sound/module.mk
+++ b/sound/module.mk
@@ -2,6 +2,8 @@ MODULE := sound
 
 MODULE_OBJS = \
 	sound/fmopl.o \
+	sound/midiparser_smf.o \
+	sound/midiparser_xmidi.o \
 	sound/midistreamer.o \
 	sound/midiparser_xmidi.o \
 	sound/mixer.o \