thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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.

Browse source 
svn-id: r7654
This commit is contained in:
Jamieson Christian 2003-05-18 23:55:53 +00:00
parent b43bca21cb
commit c81b58d38e
12 changed files with 362 additions and 507 deletions
Download patch file Download diff file Expand all files Collapse all files

3
backends/midi/adlib.cpp
View file

@ -867,6 +867,9 @@ int MidiDriver_ADLIB::open() {
} }
void MidiDriver_ADLIB::close() { void MidiDriver_ADLIB::close() {
if (!_isOpen)
return;
uint i; uint i;
for (i = 0; i < ARRAYSIZE(_voices); ++i) { for (i = 0; i < ARRAYSIZE(_voices); ++i) {
if (_voices [i]._part) if (_voices [i]._part)

3
backends/midi/windows.cpp
View file

@ -65,6 +65,8 @@ int MidiDriver_WIN::open() {
} }
void MidiDriver_WIN::close() { void MidiDriver_WIN::close() {
if (!_isOpen)
return;
_isOpen = false; _isOpen = false;
midiOutUnprepareHeader (_mo, &_streamHeader, sizeof (_streamHeader)); midiOutUnprepareHeader (_mo, &_streamHeader, sizeof (_streamHeader));
check_error(midiOutClose(_mo)); check_error(midiOutClose(_mo));
@ -83,7 +85,6 @@ void MidiDriver_WIN::send(uint32 b)
u.bData[1] = (byte)((b & 0x0000FF00) >> 8); u.bData[1] = (byte)((b & 0x0000FF00) >> 8);
u.bData[0] = (byte)(b & 0x000000FF); 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)); check_error(midiOutShortMsg(_mo, u.dwData));
} }

4
scummvm.dsp
View file

@ -266,6 +266,10 @@ SOURCE=.\sound\midiparser.h
# End Source File # End Source File
# Begin Source File # Begin Source File
SOURCE=.\sound\midiparser_smf.cpp
# End Source File
# Begin Source File
SOURCE=.\sound\midiparser_xmidi.cpp SOURCE=.\sound\midiparser_xmidi.cpp
# End Source File # End Source File
# Begin Source File # Begin Source File

5
simon/items.cpp
View file

@ -1451,8 +1451,9 @@ void SimonState::o_unk_127() {
_vc72_var3 = 0xffff; _vc72_var3 = 0xffff;
_midi_unk2 = 0xffff; _midi_unk2 = 0xffff;
if (_game & GF_WIN) { if (_game & GF_WIN) {
midi.initialize(); // FIXME: What do we expect to happen at this moment?
midi.play(); // midi.initialize();
// midi.play();
} }
_vc72_var1 = b; _vc72_var1 = b;
} else { } else {

597
simon/midi.cpp
View file

@ -24,411 +24,138 @@
#include "scummsys.h" #include "scummsys.h"
#include "common/system.h" #include "common/system.h"
#include "common/file.h" #include "common/file.h"
#include "sound/midistreamer.h"
#include "sound/mixer.h" #include "sound/mixer.h"
#include "simon/simon.h" #include "simon/simon.h"
MidiPlayer::MidiPlayer() { MidiPlayer::MidiPlayer (OSystem *system) {
// Since initialize() is called every time the music changes, // Since initialize() is called every time the music changes,
// this is where we'll initialize stuff that must persist // this is where we'll initialize stuff that must persist
// between songs. // between songs.
_system = system;
_mutex = system->create_mutex();
_data = 0;
_masterVolume = 255; _masterVolume = 255;
_num_songs = 0;
_currentTrack = 255;
} }
void MidiPlayer::read_all_songs(File *in, uint music) { MidiPlayer::~MidiPlayer() {
uint i, num; _system->lock_mutex (_mutex);
close();
_currentSong = _songs; _system->unlock_mutex (_mutex);
_system->delete_mutex (_mutex);
num = in->readByte();
for (i = 0; i != num; i++) {
read_one_song(in, &_songs[i], music);
}
} }
void MidiPlayer::read_all_songs_old(File *in, uint music) { int MidiPlayer::open() {
uint i, num; // Don't ever call open without first setting the output driver!
if (!_driver)
return 255;
_currentSong = _songs; int ret = _driver->open();
if (ret)
num = 1; return ret;
_driver->setTimerCallback (this, &onTimer);
for (i = 0; i != num; i++) { return 0;
read_one_song(in, &_songs[i], music);
}
} }
void MidiPlayer::read_all_songs_old(File *in, uint music, uint16 size) { void MidiPlayer::close() {
_currentSong = _songs; _system->lock_mutex (_mutex);
stop();
_lastDelay = 0; if (_driver)
_driver->close();
read_one_song(in, &_songs[0], music, size); _driver = NULL;
clearConstructs();
_system->unlock_mutex (_mutex);
} }
void MidiPlayer::read_mthd(File *in, Song *s, bool old, uint music, uint16 size) { void MidiPlayer::send (uint32 b) {
Track *t; byte volume;
uint i;
if (!old) { // Only thing we care about is volume control changes.
if (in->readUint32BE() != 6) if ((b & 0xFFF0) == 0x07B0) {
error("Invalid 'MThd' chunk size"); volume = (byte) ((b >> 16) & 0xFF) * _masterVolume / 255;
s->midi_format = in->readUint16BE(); _volumeTable [b & 0xF] = volume;
s->num_tracks = in->readUint16BE(); b = (b & 0xFF00FFFF) | (volume << 16);
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)); _driver->send (b);
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::read_one_song(File *in, Song *s, uint music, uint16 size) { void MidiPlayer::metaEvent (byte type, byte *data, uint16 length) {
_lastDelay = 0; // Only thing we care about is End of Track.
if (type != 0x2F)
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)
return; return;
Track *t; _parser->jumpToTick (0);
uint i; }
_lastDelay = 0; void MidiPlayer::onTimer (void *data) {
MidiPlayer *player = (MidiPlayer *) data;
for (i = 0, t = _currentSong->tracks; i != _currentSong->num_tracks; i++, t++) { if (player->_paused)
t->data_cur_size = t->data_size; return;
t->data_cur_ptr = t->data_ptr; if (player->_parser) {
t->a = 0; player->_system->lock_mutex (player->_mutex);
t->last_cmd = 0; player->_parser->onTimer();
t->delay = 0; player->_system->unlock_mutex (player->_mutex);
if (t->data_cur_size == 0) {
t->a |= 1;
} else {
t->delay = track_read_gamma(t);
}
} }
} }
void MidiPlayer::read_next_note(Track *t, NoteRec *nr) { void MidiPlayer::jump (uint16 track, uint16 tick) {
byte cmd_byte; if (track == _currentTrack)
uint i; return;
nr->delay = 0; if (_num_songs > 0) {
nr->cmd = 0; if (track >= _num_songs)
nr->param_1 = 0; return;
nr->param_2 = 0;
nr->cmd_length = 0;
nr->sysex_data = NULL;
if (t->a & 1 || t->data_cur_size == 0) _system->lock_mutex (_mutex);
error("read next note when track ended");
/* read next midi byte, but skip any pitch bends. */ if (_parser) {
for (;;) { delete _parser;
cmd_byte = track_read_byte(t); _parser = 0;
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");
} }
nr->param_1 = track_read_byte(t); MidiParser *parser = MidiParser::createParser_SMF();
if (nr->cmd_length == 3) parser->setMidiDriver (this);
nr->param_2 = track_read_byte(t); parser->setTimerRate (_driver->getBaseTempo());
if (!parser->loadMusic (_songs[track], _song_sizes[track])) {
} else if (cmd_byte == 0xF0 || cmd_byte == 0xF7) { printf ("Error reading track!\n");
nr->cmd = cmd_byte; delete parser;
nr->cmd_length = track_read_gamma(t); parser = 0;
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");
}
nr->delay = t->delay; _currentTrack = (byte) track;
if (!(t->a & 1)) { for (int i = ARRAYSIZE (_volumeTable); i; --i)
t->delay += track_read_gamma(t); _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() { void MidiPlayer::stop() {
_midiDriver->close(); _system->lock_mutex (_mutex);
unload(); if (_parser)
} _parser->unloadMusic();
_currentTrack = 255;
void MidiPlayer::unload() { _system->unlock_mutex (_mutex);
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::pause (bool b) { void MidiPlayer::pause (bool b) {
if (_paused == b) if (_paused == b)
return; return;
_paused = b; _paused = b;
_midiDriver->pause(b);
for (int i = ARRAYSIZE (_volumeTable); i; --i) { _system->lock_mutex (_mutex);
_midiDriver->send (((_paused ? 0 : (_volumeTable[i-1] * _masterVolume / 255)) << 16) | (7 << 8) | 0xB0 | i); 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);
}
int MidiPlayer::get_volume() {
return _masterVolume;
} }
void MidiPlayer::set_volume (int volume) { void MidiPlayer::set_volume (int volume) {
@ -443,16 +170,152 @@ void MidiPlayer::set_volume (int volume) {
_masterVolume = volume; _masterVolume = volume;
// Now tell all the channels this. // Now tell all the channels this.
if (_midiDriver && !_paused) { _system->lock_mutex (_mutex);
if (_driver && !_paused) {
for (int i = ARRAYSIZE (_volumeTable); i; --i) { 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) { void MidiPlayer::set_driver(MidiDriver *md) {
// We must always use the MidiStreamer front-end // Don't try to set this more than once.
// so we can support user-initiated MIDI events (like volume). if (_driver)
_midiDriver = new MidiStreamer (md); return;
_midiDriver->set_stream_callback(this, on_fill); _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);
} }

103
simon/midi.h
View file

@ -22,79 +22,64 @@
#ifndef SIMON_MIDI_H #ifndef SIMON_MIDI_H
#define SIMON_MIDI_H #define SIMON_MIDI_H
class MidiDriver; #include "sound/mididrv.h"
class MidiStreamer; #include "sound/midiparser.h"
class File; class File;
struct MidiEvent; class OSystem;
class MidiPlayer { class MidiPlayer : public MidiDriver {
public: protected:
MidiPlayer(); OSystem *_system;
void *_mutex;
MidiDriver *_driver;
MidiParser *_parser;
bool _midi_sfx_toggle; byte *_data;
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);
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 _volumeTable[16]; // 0-127 byte _volumeTable[16]; // 0-127
byte _masterVolume; // 0-255 byte _masterVolume; // 0-255
bool _paused; 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); public:
static byte track_read_byte(Track *t); bool _midi_sfx_toggle;
int fill (MidiEvent *me, int num_event); MidiPlayer (OSystem *system);
bool fill_helper (NoteRec *nr, MidiEvent *me); ~MidiPlayer();
void reset_tracks(); void playSMF (File *in);
void read_next_note(Track *t, NoteRec *nr); void playMultipleSMF (File *in);
void playXMIDI (File *in);
void jump (uint16 track, uint16 tick);
void stop();
void pause (bool b);
void unload(); int get_volume() { return _masterVolume; }
void set_volume (int volume);
void set_driver (MidiDriver *md);
static int on_fill(void *param, MidiEvent *ev, int num); public:
// MidiDriver interface implementation
int open();
void close();
void send(uint32 b);
void metaEvent (byte type, byte *data, uint16 length);
// 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 #endif

40
simon/simon.cpp
View file

@ -170,7 +170,7 @@ Engine *Engine_SIMON_create(GameDetector *detector, OSystem *syst) {
} }
SimonState::SimonState(GameDetector *detector, OSystem *syst) SimonState::SimonState(GameDetector *detector, OSystem *syst)
: Engine(detector, syst) { : Engine(detector, syst), midi (syst) {
MidiDriver *driver = detector->createMidi(); MidiDriver *driver = detector->createMidi();
_dummy_item_1 = new Item(); _dummy_item_1 = new Item();
@ -183,6 +183,9 @@ SimonState::SimonState(GameDetector *detector, OSystem *syst)
if (!driver) if (!driver)
driver = MidiDriver_ADLIB_create(); driver = MidiDriver_ADLIB_create();
midi.set_driver(driver); midi.set_driver(driver);
int ret = midi.open();
if (ret)
warning ("MIDI Player init failed: \"%s\"", midi.getErrorName (ret));
_game = (byte)detector->_features; _game = (byte)detector->_features;
@ -857,11 +860,12 @@ void SimonState::playSting(uint a) {
if (_mus_file->read(_mus_offsets, size) != size) if (_mus_file->read(_mus_offsets, size) != size)
error("Can't read offsets"); error("Can't read offsets");
midi.shutdown(); // midi.shutdown();
_mus_file->seek(_mus_offsets[a], SEEK_SET); _mus_file->seek(_mus_offsets[a], SEEK_SET);
midi.read_all_songs_old(_mus_file, a, _mus_offsets[a+1] - _mus_offsets[a]); // midi.read_all_songs_old(_mus_file, a, _mus_offsets[a+1] - _mus_offsets[a]);
midi.initialize(); // midi.initialize();
midi.play(); // midi.play();
midi.playSMF (_mus_file);
} }
Subroutine *SimonState::getSubroutineByID(uint subroutine_id) { Subroutine *SimonState::getSubroutineByID(uint subroutine_id) {
@ -3113,7 +3117,7 @@ void SimonState::processSpecialKeys() {
if (_game == GAME_SIMON1DOS) { if (_game == GAME_SIMON1DOS) {
midi._midi_sfx_toggle ^= 1; midi._midi_sfx_toggle ^= 1;
if (midi._midi_sfx_toggle) if (midi._midi_sfx_toggle)
midi.shutdown(); midi.stop();
else else
playMusic(0, _last_music_played); playMusic(0, _last_music_played);
} else } else
@ -5043,14 +5047,13 @@ void SimonState::playMusic(uint music_unk, uint music) {
if (_game & GF_SIMON2) { // Simon 2 music if (_game & GF_SIMON2) { // Simon 2 music
if (_game & GF_WIN) { if (_game & GF_WIN) {
midi.shutdown(); midi.stop();
_game_file->seek(_game_offsets_ptr[gss->MUSIC_INDEX_BASE + music - 1], SEEK_SET); _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 { } else {
/* TODO Add XMI midi format support for simon2dos/talkie */ midi.stop();
//midi.shutdown(); _game_file->seek(_game_offsets_ptr[gss->MUSIC_INDEX_BASE + music - 1], SEEK_SET);
//_game_file->seek(_game_offsets_ptr[gss->MUSIC_INDEX_BASE + music - 1], SEEK_SET); midi.playXMIDI (_game_file);
//midi.read_xmi_songs(_game_file, music);
} }
_midi_unk1 = music; _midi_unk1 = music;
_vc72_var1 = music_unk; _vc72_var1 = music_unk;
@ -5066,13 +5069,15 @@ void SimonState::playMusic(uint music_unk, uint music) {
} else if (_game & GF_DEMO) { } else if (_game & GF_DEMO) {
/* TODO Add music support for simon1demo */ /* TODO Add music support for simon1demo */
} else { } else {
midi.shutdown(); midi.stop();
if (_game & GF_WIN) { if (_game & GF_WIN) {
_game_file->seek(_game_offsets_ptr[gss->MUSIC_INDEX_BASE + music], SEEK_SET); _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) { } else if (_game & GF_TALKIE) {
_game_file->seek(_game_offsets_ptr[gss->MUSIC_INDEX_BASE + music], SEEK_SET); _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 { } else {
char buf[50]; char buf[50];
File *f = new File(); File *f = new File();
@ -5082,11 +5087,10 @@ void SimonState::playMusic(uint music_unk, uint music) {
warning("Can't load music from '%s'", buf); warning("Can't load music from '%s'", buf);
return; return;
} }
midi.read_all_songs_old(f, music); // midi.read_all_songs_old(f, music);
midi.playSMF (f);
delete f; delete f;
} }
midi.initialize();
midi.play();
} }
} }
} }

8
simon/vga.cpp
View file

@ -1814,8 +1814,9 @@ void SimonState::vc_69() {
if (_vc72_var1 == 999) { if (_vc72_var1 == 999) {
_vc70_var2 = b; _vc70_var2 = b;
if (_game & GF_WIN) { if (_game & GF_WIN) {
midi.initialize(); // FIXME: What do we expect to have happen here?
midi.play(); // midi.initialize();
// midi.play();
} }
_vc72_var1 = b; _vc72_var1 = b;
} else if (_vc72_var1 != 0xFFFF) { } else if (_vc72_var1 != 0xFFFF) {
@ -1854,8 +1855,7 @@ void SimonState::vc_72() {
_vc72_var3 = a; _vc72_var3 = a;
} }
if (_debugMode) midi.jump (a, b);
warning("vc_72(%d,%d): music stuff?", a, b);
} }
void SimonState::vc_73_set_op189_flag() { void SimonState::vc_73_set_op189_flag() {

4
sound/midiparser.h
View file

@ -34,7 +34,7 @@ protected:
uint32 _timer_rate; uint32 _timer_rate;
public: public:
virtual bool loadMusic (byte *data) = 0; virtual bool loadMusic (byte *data, uint32 size) = 0;
virtual void unloadMusic() = 0; virtual void unloadMusic() = 0;
void setMidiDriver (MidiDriver *driver) { _driver = driver; } void setMidiDriver (MidiDriver *driver) { _driver = driver; }
@ -44,7 +44,7 @@ public:
virtual void setTrack (byte track) = 0; virtual void setTrack (byte track) = 0;
virtual void jumpToTick (uint32 tick) = 0; virtual void jumpToTick (uint32 tick) = 0;
static MidiParser *createParser_RIFF(); static MidiParser *createParser_SMF();
static MidiParser *createParser_XMIDI(); static MidiParser *createParser_XMIDI();
}; };

17
sound/midiparser_smf.cpp
View file

@ -48,8 +48,6 @@ protected:
uint32 _ppqn; uint32 _ppqn;
uint32 _psec_per_tick; // Microseconds per delta tick uint32 _psec_per_tick; // Microseconds per delta tick
int _lock;
protected: protected:
uint32 read4high (byte * &data) { uint32 read4high (byte * &data) {
uint32 val = 0; uint32 val = 0;
@ -109,16 +107,9 @@ uint32 MidiParser_SMF::readVLQ (byte * &data) {
} }
void MidiParser_SMF::onTimer() { void MidiParser_SMF::onTimer() {
if (_lock++) {
--_lock;
return;
}
if (!_play_pos || !_driver) if (!_play_pos || !_driver)
return; return;
playToTime (_play_time + _timer_rate, true); playToTime (_play_time + _timer_rate, true);
_lock = 0;
} }
void MidiParser_SMF::playToTime (uint32 psec, bool transmit) { void MidiParser_SMF::playToTime (uint32 psec, bool transmit) {
@ -215,7 +206,6 @@ void MidiParser_SMF::playToTime (uint32 psec, bool transmit) {
if (transmit) { if (transmit) {
_driver->metaEvent (event, pos, (uint16) length); _driver->metaEvent (event, pos, (uint16) length);
} }
_lock = 0;
return; return;
} else if (event == 0x51) { } else if (event == 0x51) {
if (length >= 3) { if (length >= 3) {
@ -238,8 +228,6 @@ void MidiParser_SMF::playToTime (uint32 psec, bool transmit) {
_play_pos = pos; _play_pos = pos;
} }
// This code was adapted from the exult methods
// XMIDI::ExtractTracks and XMIDI::ExtractTracksFromXmi
bool MidiParser_SMF::loadMusic (byte *data, uint32 size) { bool MidiParser_SMF::loadMusic (byte *data, uint32 size) {
uint32 len; uint32 len;
bool isGMD = false; // Indicates an older GMD file without block headers bool isGMD = false; // Indicates an older GMD file without block headers
@ -465,9 +453,6 @@ void MidiParser_SMF::allNotesOff() {
} }
void MidiParser_SMF::unloadMusic() { void MidiParser_SMF::unloadMusic() {
while (_lock);
++_lock;
_play_pos = NULL; _play_pos = NULL;
_data = NULL; _data = NULL;
_num_tracks = 0; _num_tracks = 0;
@ -476,8 +461,6 @@ void MidiParser_SMF::unloadMusic() {
_last_event_time = 0; _last_event_time = 0;
_running_status = 0; _running_status = 0;
allNotesOff(); allNotesOff();
_lock = 0;
} }
void MidiParser_SMF::setTrack (byte track) { void MidiParser_SMF::setTrack (byte track) {

83
sound/midiparser_xmidi.cpp
View file

@ -51,8 +51,6 @@ protected:
NoteTimer _notes_cache[32]; NoteTimer _notes_cache[32];
int _lock;
protected: protected:
uint32 read4high (byte * &data) { uint32 read4high (byte * &data) {
uint32 val = 0; uint32 val = 0;
@ -69,8 +67,10 @@ protected:
uint32 readVLQ (byte * &data); uint32 readVLQ (byte * &data);
uint32 readVLQ2 (byte * &data); uint32 readVLQ2 (byte * &data);
void playToTime (uint32 psec, bool transmit);
public: public:
bool loadMusic (byte *data); bool loadMusic (byte *data, uint32 size);
void unloadMusic(); void unloadMusic();
void setMidiDriver (MidiDriver *driver) { _driver = driver; } void setMidiDriver (MidiDriver *driver) { _driver = driver; }
@ -130,6 +130,12 @@ uint32 MidiParser_XMIDI::readVLQ2 (byte * &pos) {
} }
void MidiParser_XMIDI::onTimer() { 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 delta;
uint32 end_time; uint32 end_time;
uint32 event_time; uint32 event_time;
@ -143,15 +149,7 @@ void MidiParser_XMIDI::onTimer() {
byte vel; byte vel;
uint32 note_length; uint32 note_length;
if (_lock++) { end_time = psec;
--_lock;
return;
}
if (!_play_pos || !_driver)
return;
end_time = _play_time + _timer_rate;
pos = _play_pos; pos = _play_pos;
// Send any necessary note off events. // Send any necessary note off events.
@ -159,7 +157,8 @@ void MidiParser_XMIDI::onTimer() {
for (i = ARRAYSIZE(_notes_cache); i; --i, ++ptr) { for (i = ARRAYSIZE(_notes_cache); i; --i, ++ptr) {
if (ptr->time_left) { if (ptr->time_left) {
if (ptr->time_left <= _timer_rate) { 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; ptr->time_left = 0;
} else { } else {
ptr->time_left -= _timer_rate; ptr->time_left -= _timer_rate;
@ -191,7 +190,8 @@ void MidiParser_XMIDI::onTimer() {
ptr->time_left = note_length; ptr->time_left = note_length;
ptr->channel = event & 0x0F; ptr->channel = event & 0x0F;
ptr->note = note; ptr->note = note;
_driver->send (event | (note << 8) | (vel << 16)); if (transmit)
_driver->send (event | (note << 8) | (vel << 16));
break; break;
} }
} }
@ -199,7 +199,8 @@ void MidiParser_XMIDI::onTimer() {
case 0xC: // Program Change case 0xC: // Program Change
case 0xD: // Channel Aftertouch case 0xD: // Channel Aftertouch
_driver->send (event | (pos[0] << 8)); if (transmit)
_driver->send (event | (pos[0] << 8));
++pos; ++pos;
break; break;
@ -207,19 +208,22 @@ void MidiParser_XMIDI::onTimer() {
case 0xA: // Key Aftertouch case 0xA: // Key Aftertouch
case 0xB: // Control Change case 0xB: // Control Change
case 0xE: // Pitch Bender 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; pos += 2;
break; break;
case 0xF: // Meta or SysEx event case 0xF: // Meta or SysEx event
switch (event & 0x0F) { switch (event & 0x0F) {
case 0x2: // Song Position Pointer 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; pos += 2;
break; break;
case 0x3: // Song Select case 0x3: // Song Select
_driver->send (event | (pos[0] << 8)); if (transmit)
_driver->send (event | (pos[0] << 8));
++pos; ++pos;
break; break;
@ -229,37 +233,42 @@ void MidiParser_XMIDI::onTimer() {
case 0xB: // Sequencer Continue case 0xB: // Sequencer Continue
case 0xC: // Sequencer Stop case 0xC: // Sequencer Stop
case 0xE: // Active Sensing case 0xE: // Active Sensing
_driver->send (event); if (transmit)
_driver->send (event);
break;
case 0x0: // SysEx case 0x0: // SysEx
length = readVLQ (pos); length = readVLQ (pos);
_driver->sysEx (pos, (uint16)(length - 1)); if (transmit)
_driver->sysEx (pos, (uint16)(length - 1));
pos += length; pos += length;
break; break;
case 0xF: // META event case 0xF: // META event
event = *pos++; event = *pos++;
length = readVLQ (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) { if (event == 0x2F) {
// End of song. See if there are still holding notes // End of song must be processed by us,
// we need to wait for. // as well as sending it to the output device.
ptr = &_notes_cache[0]; ptr = &_notes_cache[0];
for (i = ARRAYSIZE(_notes_cache); i; --i, ++ptr) { for (i = ARRAYSIZE(_notes_cache); i; --i, ++ptr) {
if (ptr->time_left) { 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; ptr->time_left = 0;
} }
} }
_play_pos = 0; _play_pos = 0;
_lock = 0; if (transmit)
_driver->metaEvent (event, pos, (uint16) length);
return; return;
} }
if (transmit)
_driver->metaEvent (event, pos, (uint16) length);
pos += length; pos += length;
break;
} }
} }
@ -268,12 +277,9 @@ void MidiParser_XMIDI::onTimer() {
_play_time = end_time; _play_time = end_time;
_play_pos = pos; _play_pos = pos;
_lock = 0;
} }
// This code was adapted from the exult methods bool MidiParser_XMIDI::loadMusic (byte *data, uint32 size) {
// XMIDI::ExtractTracks and XMIDI::ExtractTracksFromXmi
bool MidiParser_XMIDI::loadMusic (byte *data) {
uint32 i = 0; uint32 i = 0;
byte *start; byte *start;
uint32 len; uint32 len;
@ -419,9 +425,6 @@ void MidiParser_XMIDI::unloadMusic() {
int i; int i;
NoteTimer *ptr; NoteTimer *ptr;
while (_lock);
++_lock;
_play_pos = NULL; _play_pos = NULL;
_data = NULL; _data = NULL;
_num_tracks = 0; _num_tracks = 0;
@ -437,8 +440,6 @@ void MidiParser_XMIDI::unloadMusic() {
ptr->time_left = 0; ptr->time_left = 0;
} }
} }
_lock = 0;
} }
void MidiParser_XMIDI::setTrack (byte track) { void MidiParser_XMIDI::setTrack (byte track) {
@ -451,7 +452,15 @@ void MidiParser_XMIDI::setTrack (byte track) {
} }
void MidiParser_XMIDI::jumpToTick (uint32 tick) { 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; } MidiParser *MidiParser::createParser_XMIDI() { return new MidiParser_XMIDI; }

2
sound/module.mk
View file

@ -2,6 +2,8 @@ MODULE := sound
MODULE_OBJS = \ MODULE_OBJS = \
sound/fmopl.o \ sound/fmopl.o \
sound/midiparser_smf.o \
sound/midiparser_xmidi.o \
sound/midistreamer.o \ sound/midistreamer.o \
sound/midiparser_xmidi.o \ sound/midiparser_xmidi.o \
sound/mixer.o \ sound/mixer.o \