Add midi streaming support from Jamieson630

svn-id: r5522

simon/midi.cpp

@@ -28,6 +28,9 @@
 #include "sound/mixer.h"
 #include "simon/simon.h"
 
+// FIXME: This is a horrible place to put this, but for now....
+#include "sound/midistreamer.cpp"
+
 void MidiPlayer::read_all_songs(File *in)
 {
 	uint i, num;
@@ -178,6 +181,14 @@ void MidiPlayer::initialize()
 	_midiDriver->property(MidiDriver::PROP_TIMEDIV, _songs[0].ppqn);
 
 	res = _midiDriver->open(MidiDriver::MO_STREAMING);
+	if (res == MidiDriver::MERR_STREAMING_NOT_AVAILABLE) {
+		// No direct streaming, slap a front-end on.
+		_midiDriver = new MidiStreamer (_midiDriver);
+		_midiDriver->property (MidiDriver::PROP_TIMEDIV, _songs[0].ppqn);
+		_midiDriver->set_stream_callback (this, on_fill);
+		res = _midiDriver->open (MidiDriver::MO_STREAMING);
+	}
+
 	if (res != 0)
 		error("MidiPlayer::initializer, got %s", MidiDriver::get_error_name(res));
 }
@@ -408,5 +419,5 @@ void MidiPlayer::play()
 void MidiPlayer::set_driver(MidiDriver *md)
 {
 	_midiDriver = md;
-	md->set_stream_callback(this, on_fill);
+	_midiDriver->set_stream_callback(this, on_fill);
 }

sound/midistreamer.cpp

@@ -0,0 +1,181 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001/2002 The ScummVM project
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+
+#include "stdafx.h"
+#include "mididrv.h"
+#include "engine.h"
+#include "common/util.h"
+
+class MidiStreamer : public MidiDriver {
+private:
+	MidiDriver *_target;
+	StreamCallback *_stream_proc;
+	void *_stream_param;
+	int _mode;
+	bool _paused;
+
+	MidiEvent _events [64];
+	int _event_count;
+	int _event_index;
+
+	long _tempo;
+	uint16 _ticks_per_beat;
+	long _delay;
+
+	volatile bool _active;
+
+	uint32 property(int prop, uint32 param);
+	static int timer_thread (void *param);
+	void on_timer (void);
+
+public:
+	MidiStreamer (MidiDriver *target);
+
+	int open(int mode);
+	void close();
+	void send(uint32 b) { _target->send (b); }
+	void pause(bool p) { _paused = p; }
+	void set_stream_callback(void *param, StreamCallback *sc);
+	void setPitchBendRange (byte channel, uint range) { _target->setPitchBendRange (channel, range); }
+};
+
+MidiStreamer::MidiStreamer (MidiDriver *target) :
+_target (target),
+_stream_proc (0),
+_stream_param (0),
+_mode (0),
+_paused (false),
+_event_count (0),
+_event_index (0),
+_tempo (500000), // 120 BPM = 500,000 microseconds between each beat
+_ticks_per_beat (96),
+_delay (0),
+_active (false)
+{ }
+
+void MidiStreamer::set_stream_callback (void *param, StreamCallback *sc)
+{
+	_stream_param = param;
+	_stream_proc = sc;
+
+	if (_mode) {
+		_event_count = _stream_proc (_stream_param, _events, ARRAYSIZE (_events));
+		_event_index = 0;
+	}
+}
+
+int MidiStreamer::timer_thread (void *param) {
+	MidiStreamer *mid = (MidiStreamer *) param;
+	int old_time, cur_time;
+	while (mid->_mode) {
+		while (!mid->_stream_proc);
+		old_time = g_system->get_msecs();
+		while (!mid->_paused) {
+			g_system->delay_msecs(10);
+
+			cur_time = g_system->get_msecs();
+			while (old_time < cur_time) {
+				old_time += 10;
+				mid->on_timer();
+			}
+		}
+	}
+
+	// Turn off all notes on all channels,
+	// just to catch anything still playing.
+	int i;
+	for (i = 0; i < 16; ++i)
+		mid->send ((0x7B << 8) | 0xB0 | i);
+	mid->_active = false;
+	return 0;
+}
+
+void MidiStreamer::on_timer()
+{
+	_delay += 10000;
+	while (true) {
+		if (_event_index >= _event_count) {
+			_event_count = _stream_proc (_stream_param, _events, ARRAYSIZE (_events));
+			_event_index = 0;
+		}
+
+		if (!_event_count)
+			return;
+
+		MidiEvent *ev = &_events [_event_index];
+		if (_delay < _tempo * (long) ev->delta / (long) _ticks_per_beat)
+			return;
+		_delay -= _tempo * ev->delta / _ticks_per_beat;
+		if ((ev->event >> 24) != ME_TEMPO) {
+			_target->send (ev->event);
+		} else {
+			_tempo = ev->event & 0xFFFFFF;
+		}
+
+		++_event_index;
+	} // end while
+}
+
+int MidiStreamer::open (int mode)
+{
+	if (_mode != 0)
+		close();
+
+	int res = _target->open (MidiDriver::MO_SIMPLE);
+	if (res && res != MERR_ALREADY_OPEN)
+		return res;
+
+	// Wait for existing timer thread to shut down.
+	while (_active);
+
+	_event_index = _event_count = _delay = 0;
+	_mode = mode;
+	_paused = false;
+	_active = true;
+
+	if (mode == MO_SIMPLE)
+		return 0;
+
+	g_system->create_thread (timer_thread, this);
+	return 0;
+}
+
+void MidiStreamer::close()
+{
+	if (!_mode)
+		return;
+	_mode = 0;
+	_paused = true;
+}
+
+uint32 MidiStreamer::property (int prop, uint32 param)
+{
+	switch (prop) {
+
+	// 16-bit time division according to standard midi specification
+	case PROP_TIMEDIV:
+		_ticks_per_beat = (uint16)param;
+		return 1;
+	}
+
+	return 0;
+}