msg.h

Go to the documentation of this file.

/*
 *   NiCMidi - A C++ Class Library for MIDI
 *
 *   Copyright (C) 2004  J.D. Koftinoff Software, Ltd.
 *   www.jdkoftinoff.com jeffk@jdkoftinoff.com
 *   Copyright (C) 2021, 2022  Nicola Cassetta
 *   https://github.com/ncassetta/NiCMidi
 *
 *   This file is part of NiCMidi.
 *
 *   NiCMidi is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Lesser General Public License as
 *   published by the Free Software Foundation, either version 3 of
 *   the License, or (at your option) any later version.
 *
 *   NiCMidi 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 Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public
 *   License along with NiCMidi. If not, see <http://www.gnu.org/licenses/>.
 */
 
 
 
 
#ifndef _NICMIDI_MSG_H
#define _NICMIDI_MSG_H
 
#include "midi.h"
#include "sysex.h"
 
#include <string>
 
 
class   MIDIMessage {
    public:
                                MIDIMessage();
                                MIDIMessage(const MIDIMessage &msg);
        virtual                 ~MIDIMessage();
        virtual void            Clear();
        void                    ClearSysEx();
        const MIDIMessage&      operator= (const MIDIMessage &msg);
 
        int                         GetLength() const;
        unsigned char           GetStatus() const               { return (unsigned char)status; }
        unsigned char           GetChannel() const          { return (unsigned char)(status  &0x0f);    }
        unsigned char           GetType() const             { return (unsigned char)(status & 0xf0);    }
        unsigned char           GetMetaType() const             { return byte1; }
        unsigned char           GetByte1() const                { return byte1; }
        unsigned char           GetByte2() const                { return byte2; }
        unsigned char           GetByte3() const                { return byte3; }
        MIDISystemExclusive*    GetSysEx()                  { return sysex; }
        const MIDISystemExclusive*GetSysEx() const          { return sysex; }
        unsigned char           GetNote() const                 { return byte1; }
        unsigned char           GetVelocity() const             { return byte2; }
        unsigned char           GetChannelPressure() const  { return byte1; }
        unsigned char           GetProgramValue() const     { return byte1;     }
        unsigned char           GetController() const       { return byte1; }
        unsigned char           GetControllerValue() const  { return byte2;     }
        int16_t                 GetBenderValue() const      { return (int16_t)(((byte2 << 7) | byte1) - 8192); }
        uint16_t                    GetMetaValue()      const       { return (uint16_t)((byte3 << 8) | byte2); }
        unsigned char           GetTimeSigNumerator() const { return byte2; }
        unsigned char           GetTimeSigDenominator() const { return byte3; }
        signed char             GetKeySigSharpsFlats() const { return (signed char)byte2; }
        unsigned char           GetKeySigMode() const { return byte3; }
        float                   GetTempo() const;
        unsigned long           GetInternalTempo() const;
        std::string             GetText() const;
 
        bool                    IsChannelMsg() const        { return (status >= 0x80) && (status < 0xf0); }
        bool                    IsNoteOn() const            { return ((status & 0xf0) == NOTE_ON) && byte2; }
        bool                    IsNoteOff() const           { return ((status & 0xf0) == NOTE_OFF) ||
                                                              (((status & 0xf0) == NOTE_ON) && byte2 == 0); }
        bool                    IsNote() const              { return IsNoteOn() || IsNoteOff(); }
        bool                    IsPolyPressure() const      { return ((status & 0xf0) == POLY_PRESSURE); }
        bool                    IsControlChange() const     { return ((status & 0xf0) == CONTROL_CHANGE) &&
                                                                        (byte1 < C_ALL_SOUND_OFF); }
        bool                    IsVolumeChange() const      { return IsControlChange() && GetController() == C_MAIN_VOLUME; }
        bool                    IsPanChange() const         { return IsControlChange() && GetController() == C_PAN; }
        bool                    IsPedalOn() const           { return IsControlChange() && GetController() == C_DAMPER &&
                                                                                          GetControllerValue() & 0x40; }
        bool                    IsPedalOff() const          { return IsControlChange() && GetController() == C_DAMPER &&
                                                                                          !(GetControllerValue() & 0x40); }
        bool                    IsProgramChange() const     { return ((status & 0xf0) == PROGRAM_CHANGE); }
        bool                    IsChannelPressure() const   { return ((status & 0xf0) == CHANNEL_PRESSURE); }
        bool                    IsPitchBend() const         { return ((status & 0xf0) == PITCH_BEND); }
        bool                    IsChannelMode() const       { return ((status & 0xf0) == CONTROL_CHANGE) &&
                                                                      (byte1 >= C_ALL_SOUND_OFF); }
        bool                    IsAllNotesOff() const       { return ((status & 0xf0) == CONTROL_CHANGE) &&
                                                                      (byte1 == C_ALL_NOTES_OFF); }
        bool                    IsSystemMessage() const     { return (status & 0xf0) == 0xf0; }
        bool                    IsSysEx() const             { return (status == SYSEX_START); }
        bool                    IsMetaEvent() const         { return (status == META_EVENT); }
        bool                    IsTextEvent() const         { return (status == META_EVENT && byte1 >= 0x1 && byte1 <= 0xf); }
        bool                    IsTrackName() const         { return (IsTextEvent() && GetMetaType() == META_TRACK_NAME); }
        bool                    IsMarkerText() const        { return (IsTextEvent() && GetMetaType() == META_MARKER_TEXT); }
        bool                    IsTempo() const             { return (status == META_EVENT) && (byte1 == META_TEMPO); }
        bool                    IsDataEnd() const           { return (status == META_EVENT) && (byte1 == META_END_OF_TRACK); }
        bool                    IsSMPTEOffset() const       { return (status == META_EVENT) && (byte1 == META_SMPTE); }
        bool                    IsTimeSig() const           { return (status == META_EVENT) && (byte1 == META_TIMESIG); }
        bool                    IsKeySig() const            { return (status == META_EVENT) && (byte1 == META_KEYSIG); }
        bool                    IsNoOp() const              { return (status == STATUS_SERVICE) && (byte1 == NO_OP_VAL); }
        bool                    IsBeatMarker() const        { return (status == STATUS_SERVICE) && (byte1 == BEAT_MARKER_VAL); }
 
        void                    SetStatus(unsigned char s)              { status = s; }
        void                    SetChannel(unsigned char s)         { status = (unsigned char)((status & 0xf0) | (s & 0x0f)); }
        void                    SetType(unsigned char s)            { status = (unsigned char)((status & 0x0f) | (s & 0xf0)); }
        void                    SetByte1(unsigned char b)                   { byte1 = b; }
        void                    SetByte2(unsigned char b)                   { byte2 = b; }
        void                    SetByte3(unsigned char b)                   { byte3 = b; }
        void                    SetNote(unsigned char n)                    { byte1 = n; }
        void                    SetVelocity(unsigned char v)        { byte2 = v; }
        void                    SetController(unsigned char c)      { byte1 = c; }
        void                    SetControllerValue(unsigned char v) { byte2 = v; }
        void                    SetProgramValue(unsigned char v)    { byte1 = v; }
        void                    SetBenderValue(int16_t v);
        void                    SetMetaType(unsigned char t)        { byte1 = t; }
        void                    SetMetaValue(unsigned short v);
        void                    SetNoteOn(unsigned char chan, unsigned char note, unsigned char vel);
        void                    SetNoteOff(unsigned char chan, unsigned char note, unsigned char vel);
        void                    SetPolyPressure(unsigned char chan, unsigned char note, unsigned char pres);
        void                    SetControlChange(unsigned char chan, unsigned char ctrl, unsigned char val);
        void                    SetVolumeChange (unsigned char chan, unsigned char val)
                                            { SetControlChange( chan, C_MAIN_VOLUME, val); }
        void                    SetPanChange (unsigned char chan, unsigned char val)
                                            { SetControlChange( chan, C_PAN, val); }
        void                    SetProgramChange(unsigned char chan, unsigned char prog);
        void                    SetChannelPressure(unsigned char chan, unsigned char pres);
        void                    SetPitchBend(unsigned char chan, short val);
        void                    SetChannelMode(unsigned char chan, unsigned char type, unsigned char val = 0)
                                                    { SetControlChange(chan, type, val); }
        void                    SetAllNotesOff(unsigned char chan)
                                                    { SetControlChange(chan, C_ALL_NOTES_OFF, 0); }
        void                    SetSysEx(const MIDISystemExclusive* se);
        void                    SetMTC(unsigned char field, unsigned char val);
        void                    SetSongPosition(int16_t pos);
        void                    SetSongSelect(unsigned char sng);
        void                    SetSystemMessage(unsigned char type);
        void                    SetMetaEvent(unsigned char type, unsigned char v1, unsigned char v2);
        void                    SetMetaEvent(unsigned char type, unsigned short val);
        void                    SetText(const char* text, unsigned char type = META_GENERIC_TEXT);
        void                    SetDataEnd()                        { SetMetaEvent(META_END_OF_TRACK, 0); }
        void                    SetTempo(float tempo_bpm);
        void                    SetSMPTEOffset(unsigned char hour, unsigned char min, unsigned char sec,
                                               unsigned char frame,unsigned char subframe);
        void                    SetTimeSig(unsigned char num, unsigned char den,
                                           unsigned char clocks_per_metronome = 0, unsigned char num_32_per_quarter = 8);
        void                    SetKeySig(signed char sharp_flats, unsigned char major_minor)
                                                                    { SetMetaEvent(META_KEYSIG, sharp_flats, major_minor); }
        void                    SetNoOp()                           { Clear(); }
        void                    SetBeatMarker();
 
        virtual std::string     MsgToText(bool chan_from_1 = false) const;
        void                    AllocateSysEx(unsigned int len);
        void                    CopySysEx(const MIDISystemExclusive* se);
        friend bool             operator== (const MIDIMessage &m1, const MIDIMessage &m2);
 
        static void             UseNoteOnv0ForOff(bool f)           { use_note_onv0 = f; }
 
        enum { STATUS_SERVICE = 0,              // Status byte for a service (non MIDI) message
               NO_OP_VAL = 0,                   // Byte 1 for a NoOp (uninitialized) message
               BEAT_MARKER_VAL = 1 };           // Byte 1 for a beat marker message (used internally by the sequencer)
 
    protected:
 
        unsigned char           status;         // The status byte.
        unsigned char           byte1;          // 1st data byte.
        unsigned char           byte2;          // 2nd data byte.
        unsigned char           byte3;              // 3rd data byte (only used for some meta-events).
        MIDISystemExclusive*    sysex;          // The sysex pointer.
        static bool             use_note_onv0;  // This flag influences the SetNoteOff() method behavior.
};
 
// NO NEED TO ADD A Reset MESSAGE (status = 0xff)! If you want it can use SetSystemMessage(0xff)
 
/* ********************************************************************************************/
/*                   C L A S S   M I D I T i m e d M e s s a g e                              */
/* ********************************************************************************************/
 
 
class   MIDITimedMessage : public MIDIMessage {
    public:
 
                                MIDITimedMessage();
                                MIDITimedMessage(const MIDITimedMessage &msg);
                                MIDITimedMessage(const MIDIMessage &msg);
                                ~MIDITimedMessage();
        virtual void            Clear();
 
        const MIDITimedMessage &operator= (const MIDITimedMessage &msg);
        const MIDITimedMessage &operator= (const MIDIMessage &msg);
 
        virtual std::string     MsgToText(unsigned char chan_from_1 = 0) const;
 
        MIDIClockTime           GetTime() const                 { return time; }
        void                    SetTime(MIDIClockTime t)        { time = t; }
        void                    AddTime(MIDIClockTime t)        { time += t; }
        void                    SubTime(MIDIClockTime t)        { time = (t > time ? 0 : time - t); }
 
        void                    SetNoOp()                       { Clear(); }
 
        friend int              CompareEventsForInsert (const MIDITimedMessage &m1, const MIDITimedMessage &m2);
 
        friend bool             IsSameKind (const MIDITimedMessage &m1, const MIDITimedMessage &m2);
 
        friend bool             operator==(const MIDITimedMessage &m1, const MIDITimedMessage &m2);
 
    protected:
 
        MIDIClockTime           time;           
};
 
#endif