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
This commit is contained in:
Jamieson Christian
parent
b43bca21cb
commit
c81b58d38e
12 changed files with 362 additions and 507 deletions
597
simon/midi.cpp
597
simon/midi.cpp
|
|
@ -24,411 +24,138 @@
|
|||
#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::close() {
|
||||
_system->lock_mutex (_mutex);
|
||||
stop();
|
||||
if (_driver)
|
||||
_driver->close();
|
||||
_driver = NULL;
|
||||
clearConstructs();
|
||||
_system->unlock_mutex (_mutex);
|
||||
}
|
||||
|
||||
void MidiPlayer::read_mthd(File *in, Song *s, bool old, uint music, uint16 size) {
|
||||
Track *t;
|
||||
uint i;
|
||||
void MidiPlayer::send (uint32 b) {
|
||||
byte volume;
|
||||
|
||||
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();
|
||||
// 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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
_driver->send (b);
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
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'");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
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);
|
||||
|
||||
return sum;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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);
|
||||
|
||||
res = _midiDriver->open();
|
||||
if (res != 0)
|
||||
error("MidiPlayer::initializer, got %s", MidiDriver::getErrorName(res));
|
||||
|
||||
if (_paused)
|
||||
_midiDriver->pause (true);
|
||||
}
|
||||
|
||||
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 (best_track == NULL) {
|
||||
/* reset tracks if song ended? */
|
||||
if (did_reset) {
|
||||
/* exit if song ended completely */
|
||||
return i;
|
||||
}
|
||||
did_reset = true;
|
||||
reset_tracks();
|
||||
continue;
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
int MidiPlayer::on_fill(void *param, MidiEvent *ev, int num) {
|
||||
MidiPlayer *mp = (MidiPlayer *) param;
|
||||
return mp->fill(ev, num);
|
||||
}
|
||||
|
||||
bool MidiPlayer::fill_helper(NoteRec *nr, MidiEvent *me) {
|
||||
uint b;
|
||||
|
||||
b = nr->delay - _lastDelay;
|
||||
_lastDelay = nr->delay;
|
||||
|
||||
if (nr->cmd < 0xF0) {
|
||||
me->delta = b;
|
||||
me->event = nr->cmd | (nr->param_1 << 8) | (nr->param_2 << 16);
|
||||
|
||||
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 (nr->cmd == 0xF0 || nr->cmd == 0xF7 || nr->param_1 != 0x51) {
|
||||
return false;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
void MidiPlayer::reset_tracks() {
|
||||
if (_midi_sfx_toggle)
|
||||
void MidiPlayer::metaEvent (byte type, byte *data, uint16 length) {
|
||||
// Only thing we care about is End of Track.
|
||||
if (type != 0x2F)
|
||||
return;
|
||||
|
||||
Track *t;
|
||||
uint i;
|
||||
_parser->jumpToTick (0);
|
||||
}
|
||||
|
||||
_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);
|
||||
}
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
void MidiPlayer::read_next_note(Track *t, NoteRec *nr) {
|
||||
byte cmd_byte;
|
||||
uint i;
|
||||
void MidiPlayer::jump (uint16 track, uint16 tick) {
|
||||
if (track == _currentTrack)
|
||||
return;
|
||||
|
||||
nr->delay = 0;
|
||||
nr->cmd = 0;
|
||||
nr->param_1 = 0;
|
||||
nr->param_2 = 0;
|
||||
nr->cmd_length = 0;
|
||||
nr->sysex_data = NULL;
|
||||
if (_num_songs > 0) {
|
||||
if (track >= _num_songs)
|
||||
return;
|
||||
|
||||
if (t->a & 1 || t->data_cur_size == 0)
|
||||
error("read next note when track ended");
|
||||
_system->lock_mutex (_mutex);
|
||||
|
||||
/* 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");
|
||||
if (_parser) {
|
||||
delete _parser;
|
||||
_parser = 0;
|
||||
}
|
||||
|
||||
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);
|
||||
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;
|
||||
}
|
||||
if (nr->param_1 == 0x2F)
|
||||
t->a |= 1;
|
||||
} else {
|
||||
error("Invalid sysex cmd");
|
||||
}
|
||||
|
||||
nr->delay = t->delay;
|
||||
if (!(t->a & 1)) {
|
||||
t->delay += track_read_gamma(t);
|
||||
_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);
|
||||
}
|
||||
}
|
||||
|
||||
void MidiPlayer::shutdown() {
|
||||
_midiDriver->close();
|
||||
unload();
|
||||
}
|
||||
|
||||
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::play() {
|
||||
if (!_paused)
|
||||
_midiDriver->pause(false);
|
||||
void MidiPlayer::stop() {
|
||||
_system->lock_mutex (_mutex);
|
||||
if (_parser)
|
||||
_parser->unloadMusic();
|
||||
_currentTrack = 255;
|
||||
_system->unlock_mutex (_mutex);
|
||||
}
|
||||
|
||||
void MidiPlayer::pause (bool b) {
|
||||
if (_paused == b)
|
||||
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);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
int MidiPlayer::get_volume() {
|
||||
return _masterVolume;
|
||||
_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);
|
||||
}
|
||||
|
||||
void MidiPlayer::set_volume (int volume) {
|
||||
|
|
@ -443,16 +170,152 @@ void MidiPlayer::set_volume (int volume) {
|
|||
_masterVolume = volume;
|
||||
|
||||
// Now tell all the channels this.
|
||||
if (_midiDriver && !_paused) {
|
||||
_system->lock_mutex (_mutex);
|
||||
if (_driver && !_paused) {
|
||||
for (int i = ARRAYSIZE (_volumeTable); i; --i) {
|
||||
_midiDriver->send (((_volumeTable[i-1] * _masterVolume / 255) << 16) | (7 << 8) | 0xB0 | i);
|
||||
_driver->send (((_volumeTable[i-1] * _masterVolume / 255) << 16) | (7 << 8) | 0xB0 | i);
|
||||
}
|
||||
}
|
||||
_system->unlock_mutex (_mutex);
|
||||
}
|
||||
|
||||
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);
|
||||
// Don't try to set this more than once.
|
||||
if (_driver)
|
||||
return;
|
||||
_driver = md;
|
||||
}
|
||||
|
||||
void MidiPlayer::clearConstructs() {
|
||||
if (_num_songs > 0) {
|
||||
byte i;
|
||||
for (i = 0; i < _num_songs; ++i) {
|
||||
free (_songs [i]);
|
||||
}
|
||||
_num_songs = 0;
|
||||
}
|
||||
|
||||
if (_data) {
|
||||
free (_data);
|
||||
_data = 0;
|
||||
}
|
||||
|
||||
if (_parser) {
|
||||
delete _parser;
|
||||
_parser = 0;
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
_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::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;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
_system->unlock_mutex (_mutex);
|
||||
jump (0, 1);
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
_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);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue