midi.h

Go to the documentation of this file.

/*
 * midi.h
 *
 * Copyright 2002 Thomas A. Vaughan
 * All rights reserved.
 *
 * Header file for the MIDI library.
 */

#ifndef __MEDIA_MIDI_H__
#define __MEDIA_MIDI_H__


// includes --------------------------------------------------------------------
#include "common/common.h"


// namespace
namespace media {


////////////////////////////////////////////////////////////////////////////////
//
//      MIDI objects
//
////////////////////////////////////////////////////////////////////////////////

/*
 * class MidiEvent
 *
 * Generic structure for all (non-sysex) midi messages
 */
class MidiEvent {
public:
        // public typedefs -----------------------------------------------------
        enum eStatus {
                eNoteOff        = 0x8,  // note off event
                eNoteOn         = 0x9,  // note on event
                eNoteAfter      = 0xa,  // note aftertouch event
                eControl        = 0xb,  // control change event
                eProgram        = 0xc,  // program change event
                eChannelAfter   = 0xd,  // channel aftertouch event
                ePitch          = 0xe,  // pitch bend event
                eSystem         = 0xf,  // system exclusive event
                eInvalid        = 0x0   // invalid event value
        };

        // MidiEvent constructor, destructor -----------------------------------
        MidiEvent(void) throw() : m_status(0) { }       // invalid status
        MidiEvent(IN const MidiEvent& event) throw() {
                        *this = event;
                }

        // MidiEvent class methods ---------------------------------------------
        eStatus GetStatus(void) const throw();
        byte_t  GetChannel(void) const throw();
        byte_t  GetByte0(void) const throw();
        byte_t  GetByte1(void) const throw();
        byte_t  GetNote(void) const throw();
        byte_t  GetVelocity(void) const throw();
        byte_t  GetControlNumber(void) const throw();
        byte_t  GetControlValue(void) const throw();
        byte_t  GetPatch(void) const throw();
        byte_t  GetPressure(void) const throw();
        word_t  GetPitch(void) const throw();

        const MidiEvent& operator = (IN const MidiEvent& event) throw() {
                        m_status = event.m_status;
                        m_word = event.m_word;
                        return *this;
                }

        static bool IsValidStatus(IN eStatus status) throw();
        static int GetDataByteCount(IN eStatus status) throw();

        void    SetStatus(IN eStatus status) throw();
        void    SetChannel(IN int channel) throw();
        void    SetByte0(IN byte_t b0) throw() { m_data[0] = b0; }
        void    SetByte1(IN byte_t b1) throw() { m_data[1] = b1; }
        void    SetWord(IN word_t w) throw() { m_word = w; }

protected:
        // private data members ------------------------------------------------
        byte_t  m_status;       // status byte
        byte_t  m_unused;       // unused, kept to preserve DWORD/WORD alignment

        union {
                byte_t  m_data[2];      // data bytes
                word_t  m_word;         // bytes as word
        };
};



/*
 * class MidiReceiver
 *
 * Someone who wants to receive midi events
 */
class MidiReceiver {
public:
        // media::MidiReceiver class interface methods -------------------------
        virtual void NotifyEvent(IN const MidiEvent& event) = 0;

protected:
        // protected d'tor: you can't delete() one of these directly -----------
        virtual ~MidiReceiver(void) throw() { }
};



////////////////////////////////////////////////////////////////////////////////
//
//      MIDI functions
//
////////////////////////////////////////////////////////////////////////////////

// Parsing routines
void ParseMidi(IN MidiReceiver * receiver, IN const byte_t * buffer,
                IN long bytes, OUT long * offset); 

// Printing routines
void PrintEvent(IN FILE * output, IN const MidiEvent& event) throw();




////////////////////////////////////////////////////////////////////////////////
//
//      Inline functions (nothing interesting for clients beyond this point)
//
////////////////////////////////////////////////////////////////////////////////

inline MidiEvent::eStatus
MidiEvent::GetStatus(void)
const throw()
{
        return (MidiEvent::eStatus) ((m_status >> 4) & 0xf);
}


inline byte_t
MidiEvent::GetChannel(void)
const throw()
{
        return m_status & 0xf;
}


inline void
MidiEvent::SetStatus(IN eStatus status)
throw()
{
        ASSERT(IsValidStatus(status), "Invalid status");
        m_status = (m_status & 0x0f) + (status << 4);
}


inline void
MidiEvent::SetChannel(IN int channel)
throw()
{
        ASSERT(channel >=0 && channel < 16, "Invalid channel");
        m_status = (m_status & 0xf0) + (channel & 0x0f);
}


inline byte_t
MidiEvent::GetByte0(void)
const throw()
{
        return m_data[0];
}


inline byte_t
MidiEvent::GetByte1(void)
const throw()
{
        return m_data[1];
}


inline byte_t
MidiEvent::GetNote(void)
const throw()
{
        return m_data[0];
}


inline byte_t
MidiEvent::GetVelocity(void)
const throw()
{
        return m_data[1];
}


inline byte_t
MidiEvent::GetControlNumber(void)
const throw()
{
        return m_data[0];
}


inline byte_t
MidiEvent::GetControlValue(void)
const throw()
{
        return m_data[1];
}


inline byte_t
MidiEvent::GetPatch(void)
const throw()
{
        return m_data[0];
}


inline byte_t
MidiEvent::GetPressure(void)
const throw()
{
        return m_data[0];
}


inline word_t
MidiEvent::GetPitch(void)
const throw()
{
        return m_word;
}


};      // end of media namespace


#endif  // __MEDIA_MIDI_H__