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() {
if (!_isOpen)
return;
uint i;
for (i = 0; i < ARRAYSIZE(_voices); ++i) {
if (_voices [i]._part)

3
backends/midi/windows.cpp
View file

@ -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));
}

4
scummvm.dsp
View file

@ -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

5
simon/items.cpp
View file

@ -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 {

595
simon/midi.cpp
View file

@ -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 (_parser) {
delete _parser;
_parser = 0;
}
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");
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;
}
nr->param_1 = track_read_byte(t);
if (nr->cmd_length == 3)
nr->param_2 = track_read_byte(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
} 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");
}
nr->delay = t->delay;
if (!(t->a & 1)) {
t->delay += track_read_gamma(t);
_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);
}

103
simon/midi.h
View file

@ -22,79 +22,64 @@
#ifndef SIMON_MIDI_H
#define SIMON_MIDI_H
class MidiDriver;
class MidiStreamer;
#include "sound/mididrv.h"
#include "sound/midiparser.h"
class File;
struct MidiEvent;
class OSystem;
class MidiPlayer {
public:
MidiPlayer();
class MidiPlayer : public MidiDriver {
protected:
OSystem *_system;
void *_mutex;
MidiDriver *_driver;
MidiParser *_parser;
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);
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;
int fill (MidiEvent *me, int num_event);
bool fill_helper (NoteRec *nr, MidiEvent *me);
MidiPlayer (OSystem *system);
~MidiPlayer();
void reset_tracks();
void read_next_note(Track *t, NoteRec *nr);
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 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

40
simon/simon.cpp
View file

@ -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();
}
}
}

8
simon/vga.cpp
View file

@ -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() {

4
sound/midiparser.h
View file

@ -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();
};

17
sound/midiparser_smf.cpp
View file

@ -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) {

63
sound/midiparser_xmidi.cpp
View file

@ -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,6 +157,7 @@ void MidiParser_XMIDI::onTimer() {
for (i = ARRAYSIZE(_notes_cache); i; --i, ++ptr) {
if (ptr->time_left) {
if (ptr->time_left <= _timer_rate) {
if (transmit)
_driver->send (0x80 | ptr->channel | (ptr->note << 8));
ptr->time_left = 0;
} else {
@ -191,6 +190,7 @@ void MidiParser_XMIDI::onTimer() {
ptr->time_left = note_length;
ptr->channel = event & 0x0F;
ptr->note = note;
if (transmit)
_driver->send (event | (note << 8) | (vel << 16));
break;
}
@ -199,6 +199,7 @@ void MidiParser_XMIDI::onTimer() {
case 0xC: // Program Change
case 0xD: // Channel Aftertouch
if (transmit)
_driver->send (event | (pos[0] << 8));
++pos;
break;
@ -207,6 +208,7 @@ void MidiParser_XMIDI::onTimer() {
case 0xA: // Key Aftertouch
case 0xB: // Control Change
case 0xE: // Pitch Bender Change
if (transmit)
_driver->send (event | (pos[0] << 8) | (pos[1] << 16));
pos += 2;
break;
@ -214,11 +216,13 @@ void MidiParser_XMIDI::onTimer() {
case 0xF: // Meta or SysEx event
switch (event & 0x0F) {
case 0x2: // Song Position Pointer
if (transmit)
_driver->send (event | (pos[0] << 8) | (pos[1] << 16));
pos += 2;
break;
case 0x3: // Song Select
if (transmit)
_driver->send (event | (pos[0] << 8));
++pos;
break;
@ -229,10 +233,13 @@ void MidiParser_XMIDI::onTimer() {
case 0xB: // Sequencer Continue
case 0xC: // Sequencer Stop
case 0xE: // Active Sensing
if (transmit)
_driver->send (event);
break;
case 0x0: // SysEx
length = readVLQ (pos);
if (transmit)
_driver->sysEx (pos, (uint16)(length - 1));
pos += length;
break;
@ -240,26 +247,28 @@ void MidiParser_XMIDI::onTimer() {
case 0xF: // META event
event = *pos++;
length = readVLQ (pos);
_driver->metaEvent (event, pos, (uint16) length);
if (event == 0x2F) {
// 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.
ptr = &_notes_cache[0];
for (i = ARRAYSIZE(_notes_cache); i; --i, ++ptr) {
if (ptr->time_left) {
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; }

2
sound/module.mk
View file

@ -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 \