midi.cpp

Go to the documentation of this file.

/*
 * midi.cpp
 *
 * Copyright 2002 Thomas A. Vaughan
 * All rights reserved.
 *
 * Implements some basic midi-handling functions
 */

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


// namespace
namespace media
{


/*
 * data size table
 */
const static int s_DataSize[8] = {
        2,      // eNoteOff
        2,      // eNoteOn
        2,      // eNoteAfter
        2,      // eControl
        1,      // eProgram
        1,      // eChannelAfter
        3,      // ePitch (3 --> SPECIAL, represent as word value)
        0,      // eSystem
};


static const char * s_EventName[8] = {
        "Note Off",
        "Note On",
        "Note Aftertouch",
        "Control Change",
        "Program Change",
        "Channel Aftertouch",
        "Pitch",
        "System Exclusive"
};


static const char * s_DataName[8][2] = {
        { "Note Number",                "Velocity"      },
        { "Note Number",                "Velocity"      },
        { "Note Number",                "Pressure"      },
        { "Control Number",             "Control Value" },
        { "Patch",                      NULL            },
        { "Pressure Value",             NULL            },
        { "Pitch Bend",                 NULL            },
        { NULL,                         NULL            }
};

/*
 * class MidiEventImpl
 *
 * Gives access to protected data
 */
class MidiEventImpl : public MidiEvent {
public:
        void SetStatus(IN byte_t status) throw()
                { m_status = status; }
        void SetData(IN int index, IN byte_t value) throw()
                { m_data[index] = value; }
};



////////////////////////////////////////////////////////////////////////////////
//
//      MidiEvent - static public methods (utility methods)
//
////////////////////////////////////////////////////////////////////////////////

bool
MidiEvent::IsValidStatus
(
IN eStatus status
)
throw()
{
        switch (status) {
                case eNoteOn:
                case eNoteOff:
                case eNoteAfter:
                case eControl:
                case eProgram:
                case eChannelAfter:
                case ePitch:
                case eSystem:
                        return true;
                
                default:
                        return false;
        }
}


int
MidiEvent::GetDataByteCount
(
IN eStatus status
)
throw()
{
        int retval;
        
        ASSERT(IsValidStatus(status), "Invalid status");

        retval = s_DataSize[status - 8];
        if (3 == retval)
                retval = 2;     // handle special word case

        return retval;
}



/*
 * Function:    ParseMidi
 *
 * Description:
 *      Given a raw byte input, parses through and finds midi events.
 */
void
ParseMidi
(
IN MidiReceiver * receiver,
IN const byte_t * buffer,
IN long bytes,
OUT long * offset
)
{
        MidiEventImpl event;
        int count = 0;

        ASSERT(receiver, "NULL receiver");
        ASSERT(buffer, "NULL buffer");
        ASSERT(bytes > 0, "invalid byte count");
        ASSERT(offset, "NULL offset pointer");
        *offset = 0;

        for (;;) {
                // look for status byte
                while (*buffer < 0x80 && bytes > 0) {
                        DPRINTF("Skipping non-status byte: 0x%02x",
                            (int) *buffer);
                        buffer++;
                        bytes--;
                }

                // end of parsing?
                if (bytes <= 0) {
                        ASSERT(0 == bytes, "Invalid remainder");
                        break;
                }

                // found a status byte!
                count = *(buffer);      // status byte
                count = (count >> 4) & 0xf;     // get high bits
                ASSERT(count >= 8, "Invalid count?");
                // DPRINTF("  MIDI event: %d", count);
                count -= 8;
                ASSERT(count >= 0 && count < 8, "Invalid status?");
                count = s_DataSize[count];      // look up data size (bytes)
                // DPRINTF("  data bytes: %d", count);

                // can we read this?
                if (count >= bytes) {
                        // not enough data in buffer--tell clients how many
                        // bytes we left in buffer
                        *offset = bytes;
                        break;
                }

                // set status byte
                event.SetStatus(*buffer);
                buffer++;
                bytes--;

                if (0 == count) {
                        DPRINTF("SYSTEM EXCLUSIVE!!  Ignoring status = 0x%02x",
                            event.GetStatus());
                        continue;
                }

                // read first data byte?
                if (count > 0) {
                        event.SetData(0, *buffer);
                        buffer++;
                        bytes--;
                }

                // read second data byte?
                if (count > 1) {
                        event.SetData(1, *buffer);
                        buffer++;
                        bytes--;
                }

                // fire event
                receiver->NotifyEvent(event);
        }
}



void
PrintEvent
(
IN FILE * output,
IN const MidiEvent& event
)
throw()
{
        int index;
        int count;

        ASSERT(output, "NULL output stream");

        index = event.GetStatus() - 0x8;
        if (index < 0 || index > 7) {
                DPRINTF("Invalid status?");
                return;
        }

        fprintf(output, "Event: %s\n", s_EventName[index]);
        fprintf(output, "  Channel: %d\n", (int) event.GetChannel());

        count = s_DataSize[index];
        if (1 == count || 2 == count) {
                fprintf(output, "  %s: %d\n", s_DataName[index][0],
                    (int) event.GetNote());
        }

        if (2 == count) {
                fprintf(output, "  %s: %d\n", s_DataName[index][1],
                    (int) event.GetVelocity());
        }

        if (3 == count) {
                fprintf(output, "  %s: %d\n", s_DataName[index][0],
                    (int) event.GetPitch());
        }
}



};      // media namespace