LowLevelMidiDriver.cpp

Go to the documentation of this file.

/*
Copyright (C) 2003-2005  The Pentagram Team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "pent_include.h"
#include <cstring>

#ifndef PENTAGRAM_IN_EXULT
#include "IDataSource.h"
#endif

#include "LowLevelMidiDriver.h"
#include "XMidiSequence.h"
#include "XMidiFile.h"
#include "XMidiEvent.h"
#include "XMidiEventList.h"

#define LLMD_MSG_PLAY                                   1
#define LLMD_MSG_FINISH                                 2
#define LLMD_MSG_PAUSE                                  3
#define LLMD_MSG_SET_VOLUME                             4
#define LLMD_MSG_SET_SPEED                              5
#define LLMD_MSG_PRECACHE_TIMBRES               6

// These are only used by thread
#define LLMD_MSG_THREAD_INIT                    -1      
#define LLMD_MSG_THREAD_INIT_FAILED             -2
#define LLMD_MSG_THREAD_EXIT                    -3

// If the time to wait is less than this then we yield instead of waiting on the condition variable
// This must be great than or equal to 2
#define LLMD_MINIMUM_YIELD_THRESHOLD 6

//#define DO_SMP_TEST

#ifdef DO_SMP_TEST
#define giveinfo() perr << __FILE__ << ":" << __LINE__ << std::endl; perr.flush();
#else
#define giveinfo()
#endif

//
// MT32 SysEx
//
static const uint32 sysex_data_start = 7;               // Data starts at byte 7
static const uint32 sysex_max_data_size = 256;


//
// Percussion
//

static const uint32 rhythm_base = 0x030110;     // Note, these are 7 bit!
static const uint32 rhythm_mem_size = 4;

static const uint32 rhythm_first_note = 24;
static const uint32 rhythm_num_notes = 64;

// Memory offset based on index in the table
static inline uint32 rhythm_mem_offset(uint32 index_num) { 
        return index_num * 4; 
}

// Memory offset based on note key num
static inline uint32 rhythm_mem_offset_note(uint32 rhythm_note_num) { 
        return (rhythm_note_num-rhythm_first_note) * 4; 
}



//
// Timbre Memory Consts
//
static const uint32 timbre_temp_base = 0x040000;
static const uint32 timbre_unk_base = 0x060000;
static const uint32 timbre_base = 0x080000;     // Note, these are 7 bit!
static const uint32 timbre_mem_size = 246;
static inline uint32 timbre_mem_offset(uint32 timbre_num) { return timbre_num * 256; }

//
// Patch Temp Consts
//
static const uint32 patch_temp_base = 0x030000;
static const uint32 patch_temp_size = 16;
static inline uint32 patch_temp_offset(uint32 patch_num) { return patch_num * 16; }


//
// Patch Memory Consts
//
static const uint32 patch_base = 0x050000;              // Note, these are 7 bit!
static const uint32 patch_mem_size = 8;
static inline uint32 patch_mem_offset(uint32 patch_num) { return patch_num * 8; }

const LowLevelMidiDriver::MT32Patch LowLevelMidiDriver::mt32_patch_template = {
        0,              // timbre_group
        0,              // timbre_num
        24,             // key_shift
        50,             // fine_tune
        24,             // bender_range
        0,              // assign_mode
        1,              // reverb_switch
        0               // dummy
};

//
// All Dev Reset
//
static const uint32 all_dev_reset_base = 0x7f0000;

// Display  Consts
//
static const uint32 display_base = 0x200000;    // Note, these are 7 bit!
static const uint32 display_mem_size = 0x14;    // Display is 20 ASCII characters (32-127)

// Convert 14 Bit base address to real
static inline int ConvBaseToActual(uint32 address_base)
{
        return ((address_base>>2) & (0x7f<<14)) | 
                        ((address_base>>1) & (0x7f<<7)) | 
                        ((address_base>>0) & (0x7f<<0));
}

using std::string;
using std::endl;

LowLevelMidiDriver::LowLevelMidiDriver() :
        MidiDriver(), mutex(0), cbmutex(0),cond(0), 
        global_volume(255), thread(0)
{
}

LowLevelMidiDriver::~LowLevelMidiDriver()
{
        // Just kill it
        if (initialized) 
        {
                perr << "Warning: Destructing LowLevelMidiDriver and destroyMidiDriver() wasn't called!" << std::endl;
                //destroyMidiDriver();
                if (thread) SDL_KillThread(thread);
        }
        thread = 0;
}

//
// MidiDriver API
//

int LowLevelMidiDriver::initMidiDriver(uint32 samp_rate, bool is_stereo)
{
        // Destroy first before re-initing
        if (initialized) destroyMidiDriver();

        string s;

        // Reset the current stream states
        std::memset(sequences, 0, sizeof (XMidiSequence*) * LLMD_NUM_SEQ);
        std::memset(chan_locks, -1, sizeof (sint32) * 16);
        std::memset(chan_map, -1, sizeof (sint32) * LLMD_NUM_SEQ * 16);
        for (int i = 0; i < LLMD_NUM_SEQ; i++) {
                playing[i] = false;
                callback_data[i] = -1;
        }

        mutex = SDL_CreateMutex();
        cbmutex = SDL_CreateMutex();
        cond = SDL_CreateCond();
        thread = 0;
        sample_rate = samp_rate;
        stereo = is_stereo;
        uploading_timbres = false;
        next_sysex = 0;

        // Zero the memory
        std::memset(mt32_patch_banks,0,sizeof(mt32_patch_banks[0])*128);
        std::memset(mt32_timbre_banks,0,sizeof(mt32_timbre_banks[0])*128);
        std::memset(mt32_timbre_used,-1,sizeof(mt32_timbre_used[0])*64);
        std::memset(mt32_bank_sel,0,sizeof(mt32_bank_sel[0])*LLMD_NUM_SEQ);
        std::memset(mt32_patch_bank_sel,0,sizeof(mt32_patch_bank_sel[0])*128);
        std::memset(mt32_rhythm_bank,0,sizeof(mt32_rhythm_bank[0])*128);
        
        int code = 0;

        if (isSampleProducer()) code = initSoftwareSynth();
        else code = initThreadedSynth();

        if (code)
        {
                perr << "Failed to initialize midi player (code: " << code << ")" << endl;
                SDL_DestroyMutex(mutex);
                SDL_DestroyMutex(cbmutex);
                SDL_DestroyCond(cond);
                thread = 0;
                mutex = 0;
                cbmutex = 0;
                cond = 0;
        }
        else
                initialized = true;

        return code;
}

void LowLevelMidiDriver::destroyMidiDriver()
{
        if (!initialized) return;

        waitTillNoComMessages();

        if (isSampleProducer()) destroySoftwareSynth();
        else destroyThreadedSynth();

        initialized = false;

        SDL_DestroyMutex(mutex);
        SDL_DestroyMutex(cbmutex);
        SDL_DestroyCond(cond);
        cbmutex = 0;
        mutex = 0;
        thread = 0;
        cond = 0;

        giveinfo();
}

int LowLevelMidiDriver::maxSequences()
{
        return LLMD_NUM_SEQ;
}

void LowLevelMidiDriver::startSequence(int seq_num, XMidiEventList *eventlist, bool repeat, int vol, int branch)
{
        if (seq_num >= LLMD_NUM_SEQ || seq_num < 0) return;

        if (!initialized)
                return;

        // Special handling for if we were uploading a timbre
        // Wait till the timbres have finished being sent
        while (uploading_timbres) {
                waitTillNoComMessages();
                
                lockComMessage();
                bool isplaying = playing[3];
                unlockComMessage();

                // If sequence is still playing timbres are still loading
                // so we need to wait and try it again
                if (isplaying) yield();
                else uploading_timbres = false;
        }

        eventlist->incerementCounter();

        ComMessage message(LLMD_MSG_PLAY);
        message.sequence = seq_num;
        message.data.play.list = eventlist;
        message.data.play.repeat = repeat;
        message.data.play.volume = vol;
        message.data.play.branch = branch;

        sendComMessage(message);
}

void LowLevelMidiDriver::finishSequence(int seq_num)
{
        if (seq_num >= LLMD_NUM_SEQ || seq_num < 0) return;
        if (!initialized) return;
        if (uploading_timbres) return;

        ComMessage message(LLMD_MSG_FINISH);
        message.sequence = seq_num;

        sendComMessage(message);
}

void LowLevelMidiDriver::setSequenceVolume(int seq_num, int vol)
{
        if (seq_num >= LLMD_NUM_SEQ || seq_num < 0) return;
        if (vol < 0 || vol > 255) return;
        if (!initialized) return;
        if (uploading_timbres) return;

        ComMessage message(LLMD_MSG_SET_VOLUME);
        message.sequence = seq_num;
        message.data.volume.level = vol;

        sendComMessage(message);
}

void LowLevelMidiDriver::setGlobalVolume(int vol)
{
        if (vol < 0 || vol > 255) return;
        if (!initialized) return;

        ComMessage message(LLMD_MSG_SET_VOLUME);
        message.sequence = -1;
        message.data.volume.level = vol;

        sendComMessage(message);
}

void LowLevelMidiDriver::setSequenceSpeed(int seq_num, int speed)
{
        if (seq_num >= LLMD_NUM_SEQ || seq_num < 0) return;
        if (speed < 0) return;
        if (!initialized) return;
        if (uploading_timbres) return;

        ComMessage message(LLMD_MSG_SET_SPEED);
        message.sequence = seq_num;
        message.data.speed.percentage = speed;

        sendComMessage(message);
}

bool LowLevelMidiDriver::isSequencePlaying(int seq_num)
{
        if (seq_num >= LLMD_NUM_SEQ || seq_num < 0) return false;
        if (uploading_timbres) return false;

        waitTillNoComMessages();
        
        lockComMessage();
        bool ret = playing[seq_num];
        unlockComMessage();

        return ret;
}

void LowLevelMidiDriver::pauseSequence(int seq_num)
{
        if (seq_num >= LLMD_NUM_SEQ || seq_num < 0) return;
        if (!initialized) return;
        if (uploading_timbres) return;

        ComMessage message(LLMD_MSG_PAUSE);
        message.sequence = seq_num;
        message.data.pause.paused = true;

        sendComMessage(message);
}

void LowLevelMidiDriver::unpauseSequence(int seq_num)
{
        if (seq_num >= LLMD_NUM_SEQ || seq_num < 0) return;
        if (!initialized) return;
        if (uploading_timbres) return;

        ComMessage message(LLMD_MSG_PAUSE);
        message.sequence = seq_num;
        message.data.pause.paused = false;

        sendComMessage(message);
}

uint32 LowLevelMidiDriver::getSequenceCallbackData(int seq_num)
{
        if (seq_num >= LLMD_NUM_SEQ || seq_num < 0) return 0;

        SDL_mutexP(cbmutex);
        uint32 ret = callback_data[seq_num];
        SDL_mutexV(cbmutex);

        return ret;
}

//
// Communications
// 

sint32 LowLevelMidiDriver::peekComMessageType()
{
        lockComMessage();
        sint32 ret = 0;
        if (messages.size()) ret = messages.front().type;
        unlockComMessage();
        return ret;
}

void LowLevelMidiDriver::sendComMessage(ComMessage& message)
{
        lockComMessage();
        messages.push(message);
        SDL_CondSignal(cond);
        unlockComMessage();
}

void LowLevelMidiDriver::waitTillNoComMessages()
{
        while (peekComMessageType()) yield ();
}

void LowLevelMidiDriver::lockComMessage()
{
        SDL_mutexP(mutex);
}

void LowLevelMidiDriver::unlockComMessage()
{
        SDL_mutexV(mutex);
}

//
// Thread Stuff
//

int LowLevelMidiDriver::initThreadedSynth()
{
        // Create the thread
        giveinfo();
        
        ComMessage message(LLMD_MSG_THREAD_INIT);
        sendComMessage(message);

        thread = SDL_CreateThread (threadMain_Static, static_cast<void*>(this));

        while (peekComMessageType() == LLMD_MSG_THREAD_INIT) 
                yield ();

        int code = 0;

        lockComMessage();
        {
                while (!messages.empty()) 
                {
                        if (messages.front().type == LLMD_MSG_THREAD_INIT_FAILED)
                                code = messages.front().data.init_failed.code;
                        messages.pop();
                }
        }
        unlockComMessage();

        return code;
}

void LowLevelMidiDriver::destroyThreadedSynth()
{
        ComMessage message(LLMD_MSG_THREAD_EXIT);
        sendComMessage(message);

        int count = 0;
        
        while (count < 400)
        {
                giveinfo();
                // Wait 1 MS before trying again
                if (peekComMessageType() != 0)
                {
                        yield ();
                        SDL_Delay(1);
                }
                else break;
                
                count++;
        }

        // We waited a while and it still didn't terminate
        if (count == 400 && peekComMessageType() != 0) {
                perr << "MidiPlayer Thread failed to stop in time. Killing it." << std::endl;
                SDL_KillThread (thread);
        }

        lockComMessage();
        {
                // Get rid of all the messages
                while (!messages.empty()) messages.pop();
        }
        unlockComMessage();

}

int LowLevelMidiDriver::threadMain_Static(void *data)
{
        giveinfo();
        LowLevelMidiDriver *ptr=static_cast<LowLevelMidiDriver *>(data);
        giveinfo();
        return ptr->threadMain();
}

int LowLevelMidiDriver::threadMain()
{
        giveinfo();

        // Open the device
        int code = open();

        lockComMessage();
        {
                // Pop all the messages
                while(!messages.empty()) messages.pop();

                // If we have an error code, push it to the message queue then return
                // else we are ok to go
                if (code)
                {
                        ComMessage message(LLMD_MSG_THREAD_INIT_FAILED);
                        message.data.init_failed.code = code;
                        messages.push(message);
                }
        }
        unlockComMessage();

        if (code) return code;

        // Increase the thread priority, IF possible
        increaseThreadPriority();

        // Execute the play loop
        for (;;)
        {
                xmidi_clock = SDL_GetTicks()*6;
                if (playSequences()) break;

                sint32 time_till_next = 0x7FFFFFFF;

                for (int i = 0; i < LLMD_NUM_SEQ; i++)
                {
                        int seq = i;

                        if (sequences[seq])
                        {
                                sint32 ms = sequences[seq]->timeTillNext();
                                if (ms < time_till_next) time_till_next = ms;
                        }
                }

                if (time_till_next <= LLMD_MINIMUM_YIELD_THRESHOLD)
                {
                        bool wait = false;
                        lockComMessage();
                        if (messages.empty()) wait = true;
                        unlockComMessage();
                        if (wait) 
                        {
                                //printf("Yielding\n");
                                yield();
                                //printf("Finished Yielding\n");
                        }
                        else
                        {
                                //printf("Messages in queue, not Yielding\n");
                        }
                }
                else
                {
                        lockComMessage();
                                if (messages.empty())
                                {
                                        //printf("Waiting %i ms\n", time_till_next-2);
                                        SDL_CondWaitTimeout(cond, mutex,time_till_next-2);
                                        //printf("Finished Waiting\n");
                                }
                                else
                                {
                                        //printf("Messages in queue, not waiting\n");
                                }
                        unlockComMessage();
                }
        }

        // Display messages          0123456789ABCDEF0123
        const char exit_display[] = "Poor Poor Avatar... ";
        sendMT32SystemMessage(display_base,0,display_mem_size,exit_display);
        sendMT32SystemMessage(all_dev_reset_base,0,1,exit_display);
        SDL_Delay(40);

        // Close the device
        close();

        lockComMessage();
        {
                // Pop all messages
                while(!messages.empty()) messages.pop();
                initialized = false;
        }
        unlockComMessage();

        return 0;
}

//
// Software Synth Stuff
//

int LowLevelMidiDriver::initSoftwareSynth()
{
        // Open the device
        int ret = open();

        // Uh oh, failed
        if (ret) return 1;

        // Now setup all our crap
        total_seconds = 0;
        samples_this_second = 0;

        // This value doesn't 'really' matter all that much
        // Smaller values are more accurate (more iterations)

        if (sample_rate == 11025)
                samples_per_iteration = 49;                                     // exactly 225 times a second
        if (sample_rate == 22050)
                samples_per_iteration = 98;                                     // exactly 225 times a second
        else if (sample_rate == 44100)
                samples_per_iteration = 147;                            // exactly 300 times a second
        else 
        {
                samples_per_iteration = sample_rate/480;        // Approx 480 times a second

                // Try to see if it can be 240 times/second
                if (!(samples_per_iteration&1)) samples_per_iteration>>=1;
                // Try to see if it can be 120 times/second
                if (!(samples_per_iteration&1)) samples_per_iteration>>=1;
        }

        return 0;
}

void LowLevelMidiDriver::destroySoftwareSynth()
{
        // Will cause the synth to set it self uninitialized
        ComMessage message(LLMD_MSG_THREAD_EXIT);
        sendComMessage(message);

        // Wait till all pending commands have been executed
        waitTillNoComMessages();

        close();
}

void LowLevelMidiDriver::produceSamples(sint16 *samples, uint32 bytes)
{
        // Hey, we're not supposed to be here
        if (!initialized) return;

        int stereo_mult = 1;
        if (stereo) stereo_mult = 2;

        uint32 num_samples = bytes/(2*stereo_mult);

        // Now, do the note playing iterations
        while (num_samples > 0)
        {
                uint32 samples_to_produce = samples_per_iteration;
                if (samples_to_produce > num_samples) samples_to_produce = num_samples;

                // Increment the timing counter(s)
                samples_this_second += samples_to_produce;
                while (samples_this_second > sample_rate)
                {
                        total_seconds++;
                        samples_this_second -= sample_rate;
                }

                // Calc Xmidi Clock
                xmidi_clock = (total_seconds*6000) + (samples_this_second*6000)/sample_rate;

                // We care about the return code now
                if (playSequences()) {

                        lockComMessage();
                        {
                                // Pop all messages
                                while(!messages.empty()) messages.pop();
                                initialized = false;
                        }
                        unlockComMessage();

                        break;
                }

                // Produce the samples
                lowLevelProduceSamples(samples, samples_to_produce);

                // Increment the counters
                samples += samples_to_produce*stereo_mult;
        num_samples -= samples_to_produce;
        }
}

//
// Shared Stuff
//

bool LowLevelMidiDriver::playSequences ()
{
        int i;

        // Play all notes, from all sequences
        for (i = 0; i < LLMD_NUM_SEQ; i++)
        {
                int seq = i;

                while (sequences[seq] && !peekComMessageType())
                {
                        sint32 pending_events = sequences[seq]->playEvent();

                        if (pending_events > 0) break;
                        else if (pending_events == -1)
                        {
                                delete sequences[seq]; 
                                sequences[seq] = 0;
                                lockComMessage();
                                        playing[seq] = false;
                                unlockComMessage();
                        }
                }
        }

        // Did we get issued a music command?
        lockComMessage();
        {
                while (!messages.empty()) 
                {
                        ComMessage message = messages.front();

                        // Quick Exit if we get a 'queue' and get an exit command
                        if (messages.back().type == LLMD_MSG_THREAD_EXIT)
                                message = messages.back();

                        switch (message.type)
                        {
                        case LLMD_MSG_FINISH:
                                {
                                        delete sequences[message.sequence]; 
                                        sequences[message.sequence] = 0;
                                        playing[message.sequence] = false;
                                        callback_data[message.sequence] = -1;
                                        unlockAndUnprotectChannel(message.sequence);
                                }
                                break;

                        case LLMD_MSG_THREAD_EXIT:
                                {
                                        for (i = 0; i < LLMD_NUM_SEQ; i++)
                                        {
                                                delete sequences[i]; 
                                                sequences[i] = 0;
                                                playing[i] = false;
                                                callback_data[i] = -1;
                                                unlockAndUnprotectChannel(i);
                                        }
                                }
                                unlockComMessage();
                                return true;

                        case LLMD_MSG_SET_VOLUME:
                                {
                                        if (message.sequence == -1)
                                        {
                                                global_volume = message.data.volume.level;
                                                for (i = 0; i < LLMD_NUM_SEQ; i++)
                                                        if (sequences[i])
                                                                sequences[i]->setVolume(sequences[i]->getVolume());
                                        }
                                        else if (sequences[message.sequence]) 
                                                sequences[message.sequence]->setVolume(message.data.volume.level);
                                }
                                break;

                        case LLMD_MSG_SET_SPEED:
                                {
                                        if (sequences[message.sequence]) 
                                                sequences[message.sequence]->setSpeed(message.data.speed.percentage);
                                }
                                break;

                        case LLMD_MSG_PAUSE:
                                {
                                        if (sequences[message.sequence]) 
                                        {
                                                if (!message.data.pause.paused) sequences[message.sequence]->unpause();
                                                else sequences[message.sequence]->pause();
                                        }
                                }
                                break;

                        case LLMD_MSG_PLAY:
                                {
                                        // Kill the previous stream
                                        delete sequences[message.sequence]; 
                                        sequences[message.sequence] = 0;
                                        playing[message.sequence] = false;
                                        callback_data[message.sequence] = -1;
                                        unlockAndUnprotectChannel(message.sequence);

                                        giveinfo();

                                        if (message.data.play.list) 
                                        {
                                                sequences[message.sequence] = new XMidiSequence(
                                                                                        this, 
                                                                                        message.sequence,
                                                                                        message.data.play.list, 
                                                                                        message.data.play.repeat, 
                                                                                        message.data.play.volume,
                                                                                        message.data.play.branch);

                                                playing[message.sequence] = true;

                                                uint16 mask = sequences[message.sequence]->getChanMask();

                                                // Allocate some channels
                                                /*
                                                for (i = 0; i < 16; i++)
                                                        if (mask & (1<<i)) allocateChannel(message.sequence, i);
                                                */
                                        }

                                }
                                break;

                                // Attempt to load first 64 timbres into memory
                        case LLMD_MSG_PRECACHE_TIMBRES:
                                {
                                        int count = 0;

                                        for (int bank = 0; bank < 128; bank++)
                                        {
                                                if (mt32_timbre_banks[bank]) for (int timbre = 0; timbre < 128; timbre++)
                                                {
                                                        if (mt32_timbre_banks[bank][timbre])
                                                        {
                                                                uploadTimbre(bank,timbre);
                                                                count++;

                                                                if (count == 64) break;
                                                        }
                                                }
                                                if (count == 64) break;
                                        }

                                        if (mt32_patch_banks[0]) for (int patch = 0; patch < 128; patch++)
                                        {
                                                if (mt32_patch_banks[0][patch] && mt32_patch_banks[0][patch]->timbre_bank >= 2)
                                                        setPatchBank(0,patch);
                                        }
                                }
                                break;

                                // Uh we have no idea what it is
                        default:
                                break;
                        }

                        // Pop it
                        messages.pop();
                }
        }
        unlockComMessage();

        return false;
}

void LowLevelMidiDriver::sequenceSendEvent(uint16 sequence_id, uint32 message)
{
        int log_chan = message & 0xF;
        message &= 0xFFFFFFF0;  // Strip the channel number

        // Controller handling
        if ((message & 0x00F0) == (MIDI_STATUS_CONTROLLER << 4))
        {
                // Screw around with volume
                if ((message & 0xFF00) == (7 << 8))
                {
                        int vol = (message >> 16) & 0xFF;
                        message &= 0x00FFFF;
                        // Global volume
                        vol = (vol * global_volume) / 0xFF;
                        message |= vol << 16;
                }
                else if ((message & 0xFF00) == (XMIDI_CONTROLLER_CHAN_LOCK << 8))
                {
                        lockChannel(sequence_id, log_chan, ((message>>16)&0xFF)>=64);
                        return;
                }
                else if ((message & 0xFF00) == (XMIDI_CONTROLLER_CHAN_LOCK_PROT << 8))
                {
                        protectChannel(sequence_id, log_chan, ((message>>16)&0xFF)>=64);
                        return;
                }
                else if ((message & 0xFF00) == (XMIDI_CONTROLLER_BANK_CHANGE << 8))
                {
                        //pout << "Bank change in seq: " << sequence_id << " Channel: " << log_chan << " Bank: " << ((message>>16)&0xFF) << std::endl;
                        mt32_bank_sel[sequence_id][log_chan] = (message>>16)&0xFF;
                        // Note, we will pass this onto the midi driver, because they (i.e. FMOpl) might want them)
                }
        }
        else if ((message & 0x00F0) == (MIDI_STATUS_PROG_CHANGE << 4))
        {
                if (mt32_patch_banks[0]) 
                {
                        int bank = mt32_bank_sel[sequence_id][log_chan];
                        int patch = (message & 0xFF00)>>8;
                        //pout << "Program in seq: " << sequence_id << " Channel: " << log_chan << " Bank: " << bank << " Patch: " << patch << std::endl;
                        if (bank != mt32_patch_bank_sel[patch]) setPatchBank(bank,patch);
                }
        }
        else if ((message & 0x00F0) == (MIDI_STATUS_NOTE_ON << 4) && log_chan == 0x9)
        {
                int temp = (message>>8)&0xFF;
                if (mt32_rhythm_bank[temp]) loadRhythmTemp(temp);
        }

        // Ok, get the physical channel number from the logical.
    int phys_chan = chan_map[sequence_id][log_chan];

        if (phys_chan == -2) return;
        else if (phys_chan < 0) phys_chan = log_chan;

        send(message|phys_chan);
}

void LowLevelMidiDriver::sequenceSendSysEx(uint16 sequence_id, uint8 status, const uint8 *msg, uint16 length)
{
        // Ignore Metadata
        if (status == 0xFF) return;

        // Ignore what would appear to be invalid SysEx data
        if (!msg || !length) return;

        // When uploading timbres, we will not send certain data types
        if (uploading_timbres && length > 7)
        {
                // make sure it's for MT32

                if (msg[0] == 0x41 && msg[1] == 0x10 && msg[2] == 0x16 && msg[3] == 0x12)
                {
                        uint32 actual_address = (msg[4]<<14) | (msg[5]<<7) | msg[6];

                        uint32 timbre_add_start = ConvBaseToActual(timbre_base);
                        uint32 timbre_add_end = timbre_add_start + timbre_mem_offset(64);
                        uint32 patch_add_start = ConvBaseToActual(patch_base);
                        uint32 patch_add_end = patch_add_start + patch_mem_offset(128);
                        uint32 rhythm_add_start = ConvBaseToActual(rhythm_base);
                        uint32 rhythm_add_end = rhythm_add_start + rhythm_mem_offset(85);
                        uint32 timbre_temp_add_start = ConvBaseToActual(timbre_temp_base);
                        uint32 timbre_temp_add_end = timbre_temp_add_start + timbre_mem_offset(8);
                        uint32 patch_temp_add_start = ConvBaseToActual(patch_temp_base);
                        uint32 patch_temp_add_end = patch_temp_add_start + patch_temp_offset(8);
                        uint32 timbre_unk_add_start = ConvBaseToActual(timbre_unk_base);
                        uint32 timbre_unk_add_end = timbre_unk_add_start + timbre_mem_offset(128);

                        uint32 sysex_size = length-(4+3+1+1);

                        if (actual_address >= timbre_add_start && actual_address < timbre_add_end)
                        {
                                return;
                        }
                        if (actual_address >= timbre_temp_add_start && actual_address < timbre_temp_add_end)
                        {
                                return;
                        }
                        if (actual_address >= timbre_unk_add_start && actual_address < timbre_unk_add_end)
                        {
                                return;
                        }
                        if (actual_address >= patch_add_start && actual_address < patch_add_end)
                        {
                                return;
                        }
                        if (actual_address >= patch_temp_add_start && actual_address < patch_temp_add_end)
                        {
                                return;
                        }
                        if (actual_address >= rhythm_add_start && actual_address < rhythm_add_end)
                        {
                                return;
                        }
                }
        }

        // Just send it

        int ticks = SDL_GetTicks();
        if (next_sysex > ticks) SDL_Delay(next_sysex-ticks); // Wait till we think the buffer is empty
        send_sysex(status,msg,length);
        next_sysex = SDL_GetTicks() + 40;
}

uint32 LowLevelMidiDriver::getTickCount(uint16 sequence_id)
{
        return xmidi_clock;
}

void LowLevelMidiDriver::handleCallbackTrigger(uint16 sequence_id, uint8 data)
{
        SDL_mutexP(cbmutex);
        callback_data[sequence_id] = data;
        SDL_mutexV(cbmutex);
}

int LowLevelMidiDriver::protectChannel(uint16 sequence_id, int chan, bool protect)
{
        // Unprotect the channel
        if (!protect) 
        {
                chan_locks[chan] = -1;
                chan_map[sequence_id][chan] = -1;
        }
        // Protect the channel (if required)
        else if (chan_locks[chan] != -2)
        {
                // First check to see if the channel has been locked by something
                int relock_sid = -1;
                int relock_log = -1;
                if (chan_locks[chan] != -1)
                {
                        relock_sid = chan_locks[chan];

                        // It has, so what we want to do is unlock the channel, then 
                        for (int c = 0; c < 16; c++)
                        {
                                if (chan_map[relock_sid][c] == chan) 
                                {
                                        relock_log = c;
                                        break;
                                }
                        }

                        // Release the previous lock
                        lockChannel(relock_sid, relock_log, false);
                }

                // Now protect the channel
                chan_locks[chan] = -2;