- #if defined (WIN32) && !defined(_WIN32_WCE)

- #elif defined (_WIN32_WCE) || defined(UNIX) || defined(X11_BACKEND)

- virtual void setPitchBendRange (byte channel, uint range)

- virtual void sysEx (byte *msg, uint16 length) { }

- virtual void sysEx_customInstrument (byte channel, uint32 type, byte *instr) { }

- virtual void metaEvent (byte type, byte*data, uint16 length) { }

- virtual void setTimerCallback (void *timer_param, Common::Timer::TimerProc timer_proc) = 0;

- virtual uint32 getBaseTempo (void) = 0;

- virtual void send (uint32 b) = 0; // 4-bit channel portion is ignored

- virtual void noteOff (byte note) = 0;

- virtual void noteOn (byte note, byte velocity) = 0;

- virtual void programChange (byte program) = 0;

- virtual void pitchBend (int16 bend) = 0; // -0x2000 to +0x1FFF

- virtual void controlChange (byte control, byte value) = 0;

- virtual void modulationWheel (byte value) { controlChange (1, value); }

- virtual void volume (byte value) { controlChange (7, value); }

- virtual void panPosition (byte value) { controlChange (10, value); }

- virtual void pitchBendFactor (byte value) = 0;

- virtual void detune (byte value) { controlChange (17, value); }

- virtual void priority (byte value) { }

- virtual void sustain (bool value) { controlChange (64, value ? 1 : 0); }

- virtual void effectLevel (byte value) { controlChange (91, value); }

- virtual void chorusLevel (byte value) { controlChange (93, value); }

- virtual void sysEx_customInstrument (uint32 type, byte *instr) = 0;

-_hanging_notes_count (0),

-_driver (0),

-_timer_rate (0x4A0000),

-_ppqn (96),

-_tempo (500000),

-_psec_per_tick (5208), // 500000 / 96

-_autoLoop (false),

-_smartJump (false),

-_num_tracks (0),

-_active_track (255),

-_abort_parse (0) {

- memset (_active_notes, 0, sizeof(_active_notes));

-void MidiParser::property (int prop, int value) {

-void MidiParser::setTempo (uint32 tempo) {

-uint32 MidiParser::readVLQ (byte * &data) {

-void MidiParser::activeNote (byte channel, byte note, bool active) {

-void MidiParser::hangingNote (byte channel, byte note, uint32 time_left, bool recycle) {

- if (recycle) _driver->send (0x80 | channel | note << 8);

- _driver->send (0x80 | ptr->channel | ptr->note << 8);

- _driver->sysEx (info.ext.data, (uint16) info.length);

- jumpToTick (0);

- parseNextEvent (_next_event);

- _driver->metaEvent (info.ext.type, info.ext.data, (uint16) info.length);

- setTempo (info.ext.data[0] << 16 | info.ext.data[1] << 8 | info.ext.data[2]);

- _driver->metaEvent (info.ext.type, info.ext.data, (uint16) info.length);

- activeNote (info.channel(), info.basic.param1, false);

- hangingNote (info.channel(), info.basic.param1, info.length * _psec_per_tick - (end_time - event_time));

- activeNote (info.channel(), info.basic.param1, true);

- _driver->send (info.event | info.basic.param1 << 8 | info.basic.param2 << 16);

- parseNextEvent (_next_event);

- _driver->send (0x80 | j | i << 8);

- _driver->send (0x80 | _hanging_notes[i].channel | _hanging_notes[i].note << 8);

- _driver->send (0x007BB0 | i);

- memset (_active_notes, 0, sizeof(_active_notes));

-bool MidiParser::setTrack (int track) {

- memset (_active_notes, 0, sizeof(_active_notes));

- parseNextEvent (_next_event);

- uint16 temp_active [128];

- memcpy (temp_active, _active_notes, sizeof (temp_active));

- if (temp_active[i] != 0) break;

- if (i == 128) break;

- parseNextEvent (_next_event);

- hangingNote (_next_event.channel(), _next_event.basic.param1, (advance_tick - _position._last_event_tick) * _psec_per_tick, false);

- activeNote (j, i, false);

- _driver->send (0x80 | j | i << 8);

-bool MidiParser::jumpToTick (uint32 tick, bool fireEvents) {

- Tracker currentPos (_position);

- EventInfo currentEvent (_next_event);

- parseNextEvent (_next_event);

- setTempo (info.ext.data[0] << 16 | info.ext.data[1] << 8 | info.ext.data[2]);

- _driver->metaEvent (info.ext.type, info.ext.data, (uint16) info.length);

- _driver->sysEx (info.ext.data, (uint16) info.length);

- _driver->send (info.event | info.basic.param1 << 8 | info.basic.param2 << 16);

- parseNextEvent (_next_event);

- EventInfo targetEvent (_next_event);

- Tracker targetPosition (_position);

- Tracker (const Tracker &copy) :

- _play_pos (copy._play_pos),

- _play_time (copy._play_time),

- _play_tick (copy._play_tick),

- _last_event_time (copy._last_event_time),

- _last_event_tick (copy._last_event_tick),

- _running_status (copy._running_status)

- static uint32 readVLQ (byte * &data);

- virtual void parseNextEvent (EventInfo &info) = 0;

- void activeNote (byte channel, byte note, bool active);

- void hangingNote (byte channel, byte note, uint32 ticks_left, bool recycle = true);

- uint32 read4high (byte * &data) {

- uint32 val = READ_BE_UINT32 (data);

- uint16 read2low (byte * &data) {

- uint16 val = READ_LE_UINT16 (data);

- virtual bool loadMusic (byte *data, uint32 size) = 0;

- virtual void property (int prop, int value);

- void setMidiDriver (MidiDriver *driver) { _driver = driver; }

- void setTimerRate (uint32 rate) { _timer_rate = rate; }

- void setTempo (uint32 tempo);

- bool setTrack (int track);

- bool jumpToTick (uint32 tick, bool fireEvents = false);

- static void timerCallback (void *data) { ((MidiParser *) data)->onTimer(); }

- void parseNextEvent (EventInfo &info);

- bool loadMusic (byte *data, uint32 size);

- void property (int property, int value);

- free (_buffer);

-void MidiParser_SMF::property (int prop, int value) {

- MidiParser::property (prop, value);

-void MidiParser_SMF::parseNextEvent (EventInfo &info) {

- info.delta = readVLQ (_position._play_pos);

- info.length = readVLQ (_position._play_pos);

- info.length = readVLQ (_position._play_pos);

-bool MidiParser_SMF::loadMusic (byte *data, uint32 size) {

- if (!memcmp (pos, "RIFF", 4)) {

- if (!memcmp (pos, "MThd", 4)) {

- len = read4high (pos);

- warning("MThd length 6 expected but found %d", (int) len);

- warning("No support for a Type %d MIDI with %d tracks", (int) midi_type, (int) _num_tracks);

- } else if (!memcmp (pos, "GMF\x1", 4)) {

- warning("Can only handle %d tracks but was handed %d", (int) ARRAYSIZE(_tracks), (int) _num_tracks);

- if (memcmp (pos, "MTrk", 4) && !isGMF) {

- len = read4high (pos);

- free (_buffer);

- _buffer = (byte *) malloc (size * 2);

- setTempo (500000);

- setTrack (0);

- track_timer[i] = readVLQ (track_pos[i]);

- byte active_tracks = (byte) _num_tracks;

- if (command_lengths [(event >> 4) - 8] > 0) {

- copy_bytes = command_lengths [(event >> 4) - 8];

- } else if (special_lengths [(event & 0x0F)] > 0) {

- copy_bytes = special_lengths [(event & 0x0F)];

- length = readVLQ (pos);

- length = readVLQ (pos);

- warning("Bad MIDI command %02X", (int) event);

- *output++ = (byte) (delta & 0xFF);

- *output++ = (byte) (delta & 0xFF);

- memcpy (output, track_pos[best_i], copy_bytes);

- track_timer[best_i] += readVLQ (track_pos[best_i]);

- warning("Invalid chunk length %d for 'INFO' block!", (int) chunk_len);

- _num_tracks = (byte) read2low(pos);

- warning("Chunk length %d is greater than 2", (int) chunk_len);

- warning("Can only handle %d tracks but was handed %d", (int) ARRAYSIZE(_tracks), (int) _num_tracks);