MidiEvent.h

Go to the documentation of this file.

// TODO: make this adjustable
#define SYSEX_BUFFER_LEN 128
 
namespace daisy
{
enum MidiMessageType
{
    NoteOff,               
    NoteOn,                
    PolyphonicKeyPressure, 
    ControlChange,         
    ProgramChange,         
    ChannelPressure,       
    PitchBend,             
    SystemCommon,          
    SystemRealTime,        
    ChannelMode,           
    MessageLast,           
};
 
enum SystemCommonType
{
    SystemExclusive,     
    MTCQuarterFrame,     
    SongPositionPointer, 
    SongSelect,          
    SCUndefined0,        
    SCUndefined1,        
    TuneRequest,         
    SysExEnd,            
    SystemCommonLast,    
};
 
enum SystemRealTimeType
{
    TimingClock,        
    SRTUndefined0,      
    Start,              
    Continue,           
    Stop,               
    SRTUndefined1,      
    ActiveSensing,      
    Reset,              
    SystemRealTimeLast, 
};
 
enum ChannelModeType
{
    AllSoundOff,         
    ResetAllControllers, 
    LocalControl,        
    AllNotesOff,         
    OmniModeOff,         
    OmniModeOn,          
    MonoModeOn,          
    PolyModeOn,          
    ChannelModeLast,     
};
 
struct NoteOffEvent
{
    int     channel;  
    uint8_t note;     
    uint8_t velocity; 
};
 
 
struct NoteOnEvent
{
    int     channel;  
    uint8_t note;     
    uint8_t velocity; 
};
struct PolyphonicKeyPressureEvent
{
    int     channel;
    uint8_t note;
    uint8_t pressure;
};
struct ControlChangeEvent
{
    int     channel;        
    uint8_t control_number; 
    uint8_t value;          
};
struct ProgramChangeEvent
{
    int     channel; 
    uint8_t program; 
};
struct ChannelPressureEvent
{
    int     channel;  
    uint8_t pressure; 
};
struct PitchBendEvent
{
    int     channel; 
    int16_t value;   
};
struct ChannelModeEvent
{
    int             channel;    
    ChannelModeType event_type; 
    int16_t         value;      
};
struct SystemExclusiveEvent
{
    int     length;
    uint8_t data[SYSEX_BUFFER_LEN]; 
};
struct MTCQuarterFrameEvent
{
    uint8_t message_type; 
    uint8_t value;        
};
struct SongPositionPointerEvent
{
    uint16_t position; 
};
struct SongSelectEvent
{
    uint8_t song; 
};
struct AllSoundOffEvent
{
    int channel; 
};
struct ResetAllControllersEvent
{
    int     channel; 
    uint8_t value;   
};
struct LocalControlEvent
{
    int  channel;           
    bool local_control_off; 
    bool local_control_on;  
};
struct AllNotesOffEvent
{
    int channel; 
};
struct OmniModeOffEvent
{
    int channel; 
};
struct OmniModeOnEvent
{
    int channel; 
};
struct MonoModeOnEvent
{
    int     channel;      
    uint8_t num_channels; 
};
struct PolyModeOnEvent
{
    int channel; 
};
 
 
struct MidiEvent
{
    // Newer ish.
    MidiMessageType    type;                         
    int                channel;                      
    uint8_t            data[2];                      
    uint8_t            sysex_data[SYSEX_BUFFER_LEN]; 
    uint8_t            sysex_message_len;
    SystemCommonType   sc_type;
    SystemRealTimeType srt_type;
    ChannelModeType    cm_type;
 
    NoteOffEvent AsNoteOff()
    {
        NoteOffEvent m;
        m.channel  = channel;
        m.note     = data[0];
        m.velocity = data[1];
        return m;
    }
 
    NoteOnEvent AsNoteOn()
    {
        NoteOnEvent m;
        m.channel  = channel;
        m.note     = data[0];
        m.velocity = data[1];
        return m;
    }
 
    PolyphonicKeyPressureEvent AsPolyphonicKeyPressure()
    {
        PolyphonicKeyPressureEvent m;
        m.channel  = channel;
        m.note     = data[0];
        m.pressure = data[1];
        return m;
    }
 
    ControlChangeEvent AsControlChange()
    {
        ControlChangeEvent m;
        m.channel        = channel;
        m.control_number = data[0];
        m.value          = data[1];
        return m;
    }
 
    ProgramChangeEvent AsProgramChange()
    {
        ProgramChangeEvent m;
        m.channel = channel;
        m.program = data[0];
        return m;
    }
 
    ChannelPressureEvent AsChannelPressure()
    {
        ChannelPressureEvent m;
        m.channel  = channel;
        m.pressure = data[0];
        return m;
    }
 
    PitchBendEvent AsPitchBend()
    {
        PitchBendEvent m;
        m.channel = channel;
        m.value   = ((uint16_t)data[1] << 7) + (data[0] - 8192);
        return m;
    }
 
    ChannelModeEvent AsChannelMode()
    {
        ChannelModeEvent m;
 
        m.channel    = channel;
        m.event_type = (ChannelModeType)(data[0] - 120);
        m.value      = data[1];
 
        return m;
    }
 
    SystemExclusiveEvent AsSystemExclusive()
    {
        SystemExclusiveEvent m;
        m.length = sysex_message_len;
        for(int i = 0; i < SYSEX_BUFFER_LEN; i++)
        {
            m.data[i] = 0;
            if(i < m.length)
            {
                m.data[i] = sysex_data[i];
            }
        }
        return m;
    }
    MTCQuarterFrameEvent AsMTCQuarterFrame()
    {
        MTCQuarterFrameEvent m;
        m.message_type = (data[0] & 0x70) >> 4;
        m.value        = data[0] & 0x0f;
        return m;
    }
    SongPositionPointerEvent AsSongPositionPointer()
    {
        SongPositionPointerEvent m;
        m.position = ((uint16_t)data[1] << 7) | data[0];
        return m;
    }
    SongSelectEvent AsSongSelect()
    {
        SongSelectEvent m;
        m.song = data[0];
        return m;
    }
    AllSoundOffEvent AsAllSoundOff()
    {
        AllSoundOffEvent m;
        m.channel = channel;
        return m;
    }
    ResetAllControllersEvent AsResetAllControllers()
    {
        ResetAllControllersEvent m;
        m.channel = channel;
        m.value   = data[1];
        return m;
    }
    LocalControlEvent AsLocalControl()
    {
        LocalControlEvent m;
        m.channel           = channel;
        m.local_control_off = data[1] == 0;
        m.local_control_on  = data[1] == 127;
        return m;
    }
    AllNotesOffEvent AsAllNotesOff()
    {
        AllNotesOffEvent m;
        m.channel = channel;
        return m;
    }
    OmniModeOffEvent AsOmniModeOff()
    {
        OmniModeOffEvent m;
        m.channel = channel;
        return m;
    }
    OmniModeOnEvent AsOmniModeOn()
    {
        OmniModeOnEvent m;
        m.channel = channel;
        return m;
    }
    MonoModeOnEvent AsMonoModeOn()
    {
        MonoModeOnEvent m;
        m.channel      = channel;
        m.num_channels = data[1];
        return m;
    }
    PolyModeOnEvent AsPolyModeOn()
    {
        PolyModeOnEvent m;
        m.channel = channel;
        return m;
    }
 
    static const char* GetTypeAsString(MidiEvent& msg)
    {
        switch(msg.type)
        {
            case NoteOff: return "NoteOff";
            case NoteOn: return "NoteOn";
            case PolyphonicKeyPressure: return "PolyKeyPres.";
            case ControlChange: return "CC";
            case ProgramChange: return "Prog. Change";
            case ChannelPressure: return "Chn. Pressure";
            case PitchBend: return "PitchBend";
            case SystemCommon: return "Sys. Common";
            case SystemRealTime: return "Sys. Realtime";
            case ChannelMode: return "Chn. Mode";
            default: return "Unknown";
        }
    }
};
 
 
} //namespace daisy