midi_obj.cpp

Go to the documentation of this file.

/*
 * midi_obj.cpp
 *
 * Copyright 2002 Thomas A. Vaughan
 * All rights reserved.
 *
 * Implements the midi object for messaging in a distributed object directory.
 */

// includes --------------------------------------------------------------------
#include "midi_obj.h"                   // always include our own header first!

#include <sys/types.h>
#include <sys/stat.h>

#include <unistd.h>
#include <fcntl.h>

#include <map>

#include "util/eventq.h"                // event queue
#include "common/handler.h"             // command handler macros

#include "midi.h"                       // MIDI event parser

// namespace
namespace media
{


// statics
static const char * s_MidiIn            = "/dev/midi";

struct status_record {
        MidiEvent::eStatus      status;
        const char             *name;
};

#define STAT_ENTRY(enum, name) { MidiEvent::e ##enum , name },
static const status_record s_StatusTable[] =
{
        STAT_ENTRY(NoteOff,     "note_off")
        STAT_ENTRY(NoteOn,      "note_on")
        STAT_ENTRY(NoteAfter,   "note_after")
        STAT_ENTRY(Control,     "control")
        STAT_ENTRY(Program,     "program")
        STAT_ENTRY(ChannelAfter,"channel_after")
        STAT_ENTRY(Pitch,       "pitch")

        // must be last!
        STAT_ENTRY(Invalid,     NULL)
};


////////////////////////////////////////////////////////////////////////////////
//
//      static helpers
//
////////////////////////////////////////////////////////////////////////////////

void
get_token
(
IN const char *& str,
OUT std::string& token
)
throw()
{
        ASSERT(str, "NULL string");

        // skip whitespace
        while (*str && isspace(*str)) { ++str; }

        // copy characters
        token = "";
        while (*str && !isspace(*str)) {
                token += *str;
                ++str;
        }
}


MidiEvent::eStatus
get_status
(
IN const char * status
)
{
        const status_record * p = s_StatusTable;
        while (p->name) {
                // name match?
                if (!strcmp(status, p->name)) {
                        break;
                }

                // next record
                ++p;
        }

        return p->status;
}


/*
 * class MidiImpl
 *
 * Class that implements the LocalObject interface for midi objects.
 */
class MidiImpl : public objdir::LocalObject,
                 public MidiReceiver
{
public:
        // constructor, destructor ---------------------------------------------
        MidiImpl(void) throw();
        ~MidiImpl(void) throw();

        // public class methods ------------------------------------------------
        error_t Initialize(void) throw();

        // class objdir::LocalObject interface methods -------------------------
        virtual void NotifyDirectory(IN objdir::Directory * directory) throw();
        virtual error_t ReceiveMessage(IN const char * from_object,
                        IN const char * message) throw();

        // media::MidiReceiver class interface methods -------------------------
        virtual error_t NotifyEvent(IN const MidiEvent& event) throw();

private:
        // private typedefs ----------------------------------------------------
        struct trigger_info {
                MidiEvent::eStatus      status;         // status
                int                     channel;        // MIDI channel
                int                     byte0;
                int                     byte1;
                std::string             object;
                std::string             message;
        };
        typedef std::map<std::string, smart_ptr<trigger_info> > MapTriggers;

        // private methods -----------------------------------------------------
        static void * ThreadStart(IN void * context) throw();
        void Trigger(IN const char * object, IN const char * message,
                IN const MidiEvent& event) throw();

        // command handlers ----------------------------------------------------
        HANDLER_DECL(MidiImpl, AddTrigger)

        // private member data -------------------------------------------------
        objdir::Directory      *m_directory;    // directory that owns us
        pthread_t               m_listen;       // listening for MIDI input
        MapTriggers             m_triggers;     // registered triggers
        int                     m_fdMIDI;       // file descriptor for MIDI i/o

        // private member data (non-DWORD aligned...) --------------------------
        bool                    m_shutdown;     // shutting down?

        // static private data -------------------------------------------------
        HANDLER_TABLE_DECL(MidiImpl,    ms_handlers)
};



////////////////////////////////////////////////////////////////////////////////
//
//      MidiImpl -- static member definitions
//
////////////////////////////////////////////////////////////////////////////////

#define ENTRY(cmd, handler) HANDLER_ENTRY(MidiImpl, cmd, handler)

HANDLER_TABLE_START(MidiImpl, ms_handlers)
        // command_string               handler_name
        ENTRY("add_trigger",            AddTrigger)
HANDLER_TABLE_END()




////////////////////////////////////////////////////////////////////////////////
//
//      MidiImpl - constructor, destructor
//
////////////////////////////////////////////////////////////////////////////////

// c'tor
MidiImpl::MidiImpl(void) throw() :
m_directory(NULL),
m_listen(0),
m_fdMIDI(-1),
m_shutdown(false)
{
        DPRINTF("MidiImpl constructor...");
}


// d'tor
MidiImpl::~MidiImpl(void) throw()
{
        void *ret;

        DPRINTF("MidiImpl destructor...");

        // NOTE: close down midi thread first
        // tell thread we're shutting down, and wait for it
        if (m_listen) {
                m_shutdown = true;
                pthread_join(m_listen, &ret);
        }

        // close fd's
        if (m_fdMIDI > 0)
                close(m_fdMIDI);
}



////////////////////////////////////////////////////////////////////////////////
//
//      MidiImpl - public class methods
//
////////////////////////////////////////////////////////////////////////////////

error_t
MidiImpl::Initialize(void)
throw()
{
        error_t error = 0;

        // open MIDI input
        ASSERT(m_fdMIDI < 0, "Already have a MIDI in descriptor");
        m_fdMIDI = open(s_MidiIn, O_RDWR);
        if (-1 == m_fdMIDI)
                CHECK_ERROR(errno, "Failed to open %s for read/write: %s",
                    s_MidiIn, strerror(errno));
        ASSERT(m_fdMIDI > 0, "Bad MIDI in file descriptor");

        // create thread to listen for MIDI input
        ASSERT(!m_listen, "Already have a listening thread");
        CHECK_ERROR(pthread_create(&m_listen, NULL, ThreadStart, this),
            "Failed to create MIDI input thread");
        ASSERT(m_listen, "Should have MIDI input thread handle");

out:
        return error;
}


////////////////////////////////////////////////////////////////////////////////
//
//      MidiImpl - objdir::LocalObject class interface methods
//
////////////////////////////////////////////////////////////////////////////////

void
MidiImpl::NotifyDirectory
(
IN objdir::Directory * directory
)
throw()
{
        ASSERT(directory, "NULL directory");
        ASSERT(!m_directory, "Already have a directory pointer");

        m_directory = directory;
}



error_t
MidiImpl::ReceiveMessage
(
IN const char * from_object,
IN const char * message
)
throw()
{
        return DISPATCH_COMMAND(MidiImpl, this, message, ms_handlers);
}



////////////////////////////////////////////////////////////////////////////////
//
//      MidiImpl - MidiReceiver class interface methods
//
////////////////////////////////////////////////////////////////////////////////

error_t
MidiImpl::NotifyEvent
(
IN const MidiEvent& event
)
throw()
{
        error_t error = 0;
        MapTriggers::iterator iter;
        trigger_info *trigger;

        // loop through triggers, see if any should fire
        for (iter = m_triggers.begin(); iter != m_triggers.end(); ++iter) {
                // get trigger pointer
                trigger = iter->second;

                // see if status + channel match
                if (event.GetStatus() == trigger->status &&
                    event.GetChannel() == trigger->channel) {
                        // does byte0 match?
                        if (-1 == trigger->byte0 ||
                            event.GetByte0() == trigger->byte0) {
                                // does byte1 match?
                                if (-1 == trigger->byte1 ||
                                    event.GetByte1() == trigger->byte1) {
                                        // matches!
                                        this->Trigger(trigger->object.c_str(),
                                            trigger->message.c_str(), event);
                                }
                        }
                }
        }

//out:
        return error;
}



////////////////////////////////////////////////////////////////////////////////
//
//      MidiImpl -- command handlers
//
////////////////////////////////////////////////////////////////////////////////

error_t
MidiImpl::Handle_AddTrigger
(
IN const char * cmd
)
throw()
{
        error_t error = 0;
        smart_ptr<trigger_info> trigger;
        std::string status, name;

        DPRINTF("In AddTrigger()...");
        DPRINTF("  cmd = %s", cmd);

        // allocate new trigger
        trigger = new trigger_info;
        ASSERT(trigger, "Should have valid info");

        // trigger name
        get_token(cmd, name);

        // status code
        get_token(cmd, status);
        trigger->status = get_status(status.c_str());
        if (MidiEvent::eInvalid == trigger->status)
                CHECK_ERROR(EINVAL, "Midi event status '%s' is not valid",
                    status.c_str());

        // midi channel
        while (*cmd && isspace(*cmd)) { ++cmd; }
        trigger->channel = atoi(cmd);
        if (trigger->channel < 0 ||
            trigger->channel > 15)
                CHECK_ERROR(EINVAL, "Midi channel %d invalid: should be 0-15",
                    trigger->channel);
        while (*cmd && !isspace(*cmd)) { ++cmd; }

        // byte0
        while (*cmd && isspace(*cmd)) { ++cmd; }
        if ('*' == *cmd)
                trigger->byte0 = -1;
        else
                trigger->byte0 = atoi(cmd);
        while (*cmd && !isspace(*cmd)) { ++cmd; }

        // byte1
        while (*cmd && isspace(*cmd)) { ++cmd; }
        if ('*' == *cmd)
                trigger->byte1 = -1;
        else
                trigger->byte1 = atoi(cmd);
        while (*cmd && !isspace(*cmd)) { ++cmd; }

        // destination object
        get_token(cmd, trigger->object);

        // message
        while (*cmd && isspace(*cmd)) { ++cmd; }
        trigger->message = cmd;

        DPRINTF("Adding trigger: %s --> %s",
            trigger->object.c_str(), trigger->message.c_str());

        // add to map
        m_triggers.insert(MapTriggers::value_type(name, trigger));
        ASSERT(!trigger, "map should take ownership");

out:
        return error;
}



////////////////////////////////////////////////////////////////////////////////
//
//      MidiImpl - private helper methods
//
////////////////////////////////////////////////////////////////////////////////

/*
 * Function:    MidiImpl::ThreadStart
 *
 * Description:
 *      This is the entry point for the MIDI listening thread.  Just waits for
 *      input.
 */
void *
MidiImpl::ThreadStart
(
IN void * context
)
throw()
{
        void * ret = NULL;
        error_t error = 0;
        const int buff_size = 5;
        byte_t buffer[buff_size];
        long i, bytes, offset;
        MidiImpl * pThis = (MidiImpl *) context;

        ASSERT(pThis, "NULL context");
        ASSERT(pThis->m_fdMIDI > 0, "Bad MIDI fd");

        // loop until we shut down
        // TODO: need a select() here.
        offset = 0;
        bytes = buff_size;
        while (!pThis->m_shutdown) {
                // read any MIDI input
                bytes = read(pThis->m_fdMIDI, buffer + offset, bytes);
                if (-1 == bytes)
                        CHECK_ERROR(errno, "Could not read from MIDI in");

                // parse stream for midi events
                CHECK_ERROR(ParseMidi(pThis, buffer, bytes + offset, &offset),
                    "Failed to parse midi buffer");

                // shift data
                for (i = 0; i < offset; i++) {
                        buffer[i] = buffer[buff_size - offset + i];
                }
                bytes = buff_size - offset;
                if (bytes < 1)
                        CHECK_ERROR(EINVAL, "Bad data stream?");
        }

out:
        return ret;
}


void
MidiImpl::Trigger
(
IN const char * object,
IN const char * message,
IN const MidiEvent& event
)
throw()
{
        std::string output;
        const char * p;
        char buffer[8];
        const status_record *rec;
        int i;

        ASSERT(object, "NULL object");
        ASSERT(message, "NULL message");
        ASSERT(m_directory, "Should have a parent directory object");

        // have to substitute format codes in message
        p = message;
        while (*p) {
                if ('%' != *p) {
                        // not a control code--keep going
                        output += *p;
                        ++p;
                } else {
                        // control code
                        ++p;
                        switch (*p) {
                        case '%':
                                // just an escaped percent sign
                                output += '%';
                                ++p;
                                break;

                        case 'c':
                                // MIDI channel
                                sprintf(buffer, "%d", event.GetChannel());
                                output += buffer;
                                ++p;
                                break;

                        case 's':
                                // status
                                rec = s_StatusTable;
                                while (rec->name) {
                                        if (rec->status == event.GetStatus()) {
                                                output += rec->name;
                                                break;
                                        }
                                }
                                ++p;
                                break;

                        case 'b':
                                // byte value
                                ++p;
                                if ('0' == *p)
                                        i = event.GetByte0();
                                else if ('1' == *p)
                                        i = event.GetByte1();
                                else {
                                        DPRINTF("Unknown byte escape: %%b%c",
                                            *p);
                                        return;
                                }
                                sprintf(buffer, "%d", i);
                                output += buffer;
                                ++p;
                                break;
                                
                        default:
                                DPRINTF("Unknown escape code in trigger "
                                  "message: %%%c", *p);
                                return;
                        }
                }
        }

        DPRINTF("message '%s' --> '%s'", message, output.c_str());

        // send formatted output
        m_directory->SendMessage(object, output.c_str());
}


////////////////////////////////////////////////////////////////////////////////
//
//      public factory methods
//
////////////////////////////////////////////////////////////////////////////////

error_t
CreateMidiObject
(
OUT smart_ptr<objdir::LocalObject>& midi
)
throw()
{
        error_t error = 0;
        smart_ptr<MidiImpl> local;

        // create object
        local = new MidiImpl;
        ASSERT(local, "Should have midi object");

        // initialize
        CHECK_ERROR(local->Initialize(),
            "Failed to initialize MIDI media object");

        // hand over to caller
        midi = local;           // caller takes ownership
        ASSERT(2 == midi.get_ref_count(), "Bad ref count");

out:
        return error;
}

};      // end of media namespace