/home/pete/Work/TSE3.svn/tse3/src/tse3/Midi.h

Go to the documentation of this file.

/*
 * @(#)Midi.h 3.00 14 May 1999
 *
 * Copyright (c) 2000 Pete Goodliffe (pete@cthree.org)
 *
 * This file is part of TSE3 - the Trax Sequencer Engine version 3.00.
 *
 * This library is modifiable/redistributable under the terms of the GNU
 * General Public License.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING. If not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 */

#ifndef TSE3_MIDI_H
#define TSE3_MIDI_H

namespace TSE3
{
    struct Clock
    {
        static const int PPQN = 96;

        Clock(int pulses = 0) : pulses(pulses)   {}
        Clock(const Clock &m) : pulses(m.pulses) {}

        int beat() const { return pulses / PPQN; }

        int pulse() const { return pulses % PPQN; }

        int pulses;

        static Clock convert(Clock time, int otherPPQN)
        {
            return (time * Clock::PPQN) / otherPPQN;
        }

        /*
         * Dull stuff to make Clock behave like the ints do.
         */

        operator int() const { return pulses; }

        const Clock operator+(const Clock &c)
        {
            Clock ret;
            ret.pulses = pulses + c.pulses;
            return ret;
        }
        const Clock operator+(int i)
        {
            Clock ret;
            ret.pulses = pulses + i;
            return ret;
        }
        Clock operator+=(const Clock &c)
        {
            pulses += c.pulses;
            return *this;
        }
        const Clock operator-(const Clock &c)
        {
            Clock ret;
            ret.pulses = pulses - c.pulses;
            return ret;
        }
        const Clock operator-(int i)
        {
            Clock ret;
            ret.pulses = pulses - i;
            return ret;
        }
        Clock operator-=(const Clock &c)
        {
            pulses -= c.pulses;
            return *this;
        }
        const Clock operator*(const Clock &c)
        {
            Clock ret;
            ret.pulses = pulses * c.pulses;
            return ret;
        }
        const Clock operator*(int i)
        {
            Clock ret;
            ret.pulses = pulses * i;
            return ret;
        }
        Clock operator*=(const Clock &c)
        {
            pulses *= c.pulses;
            return *this;
        }
        Clock operator*=(int i)
        {
            pulses *= i;
            return *this;
        }
        const Clock operator/(const Clock &c)
        {
            Clock ret;
            ret.pulses = pulses / c.pulses;
            return ret;
        }
        const Clock operator/(int i)
        {
            Clock ret;
            ret.pulses = pulses / i;
            return ret;
        }
        Clock operator/=(const Clock &c)
        {
            pulses /= c.pulses;
            return *this;
        }
        Clock operator/=(int i)
        {
            pulses /= i;
            return *this;
        }
        const Clock operator%(const Clock &c)
        {
            Clock ret;
            ret.pulses = pulses % c.pulses;
            return ret;
        }
        const Clock operator%(int i)
        {
            Clock ret;
            ret.pulses = pulses % i;
            return ret;
        }
        Clock operator%=(const Clock &c)
        {
            pulses %= c.pulses;
            return *this;
        }
        Clock operator%=(int i)
        {
            pulses %= i;
            return *this;
        }
    };

    template <class etype>
    struct Event
    {
        typedef etype event_type;

        Event(etype data, Clock time) : data(data), time(time) {}

        etype data;

        Clock time;

        int operator<(const Event<etype> &e) const
        {
            return time.pulses < e.time.pulses;
        }

        int operator<=(const Event<etype> &e) const
        {
            return time.pulses <= e.time.pulses;
        }

        int operator>(const Event<etype> &e) const
        {
            return time.pulses > e.time.pulses;
        }

        int operator>=(const Event<etype> &e) const
        {
            return time.pulses >= e.time.pulses;
        }

        int operator==(const Event<etype> &e) const
        {
            return time.pulses == e.time.pulses;
        }

        bool equals(const Event<etype> &e) const
        {
            return (*this == e) && data == e.data;
        }

        class equal_to
        {
            public:
                equal_to(const Event<etype> &e) : e1(e) {}
                bool operator()(const Event<etype> &e2) const
                {
                    return e1.equals(e2);
                }
            private:
                const Event<etype> &e1;
        };
    };


    /**************************************************************************
     * A selection of useful MIDI command definitions.
     *************************************************************************/

    enum MidiCommands
    {
        // Channel messages
        MidiCommand_NoteOff             = 0x8,
        MidiCommand_NoteOn              = 0x9,
        MidiCommand_KeyPressure         = 0xa,
        MidiCommand_ControlChange       = 0xb,
        MidiCommand_ProgramChange       = 0xc,
        MidiCommand_ChannelPressure     = 0xd,
        MidiCommand_PitchBend           = 0xe,
        MidiCommand_System              = 0xf,

        // Meta MIDI messages
        MidiCommand_Invalid             = 0x0,
        MidiCommand_TSE_Meta            = 0x1,
        MidiCommand_NoteEdit_Meta       = 0x2
    };

    enum TSEMetaMidiCommands
    {
        MidiCommand_TSE_Meta_Tempo      = 0x00,
        MidiCommand_TSE_Meta_TimeSig    = 0x01,
        MidiCommand_TSE_Meta_KeySig     = 0x02,
        MidiCommand_TSE_Meta_MoveTo     = 0x03
    };

    extern unsigned int MidiCommand_NoDataBytes[];

    enum MidiSystemCommands
    {
        MidiSystem_SysExStart           = 0x0,
        MidiSystem_MidiTimeCode         = 0x1,
        MidiSystem_SongPosition         = 0x2,
        MidiSystem_SongSelect           = 0x3,
        MidiSystem_TuneRequest          = 0x6,
        MidiSystem_SysExEnd             = 0x7,
        MidiSystem_TimingClock          = 0x8,
        MidiSystem_Start                = 0xa,
        MidiSystem_Continue             = 0xb,
        MidiSystem_Stop                 = 0xc,
        MidiSystem_ActiveSensing        = 0xe,
        MidiSystem_SystemReset          = 0xf
    };

    enum MidiControlChanges
    {
        MidiControl_BankSelectMSB       = 0x00,
        MidiControl_ModulationMSB       = 0x01,
        MidiControl_BreathControllerMSB = 0x02,
        MidiControl_FootController      = 0x04,
        MidiControl_PortamentoTimeMSB   = 0x05,
        MidiControl_DataEntryMSB        = 0x06,
        MidiControl_ChannelVolumeMSB    = 0x07,
        MidiControl_BalanceMSB          = 0x08,
        MidiControl_PanMSB              = 0x0a,
        MidiControl_ExpressionCtrlMSB   = 0x0b,
        MidiControl_EffectCtrl1MSB      = 0x0c,
        MidiControl_EffectCtrl2MSB      = 0x0d,
        MidiControl_GeneralCtrl1MSB     = 0x10,
        MidiControl_GeneralCtrl2MSB     = 0x11,
        MidiControl_GeneralCtrl3MSB     = 0x12,
        MidiControl_GeneralCtrl4MSB     = 0x13,

        MidiControl_BankSelectLSB       = 0x20,
        MidiControl_ModulationLSB       = 0x21,
        MidiControl_BreathControllerLSB = 0x22,
        MidiControl_FootControlLer      = 0x24,
        MidiControl_PortamentoTimeLSB   = 0x25,
        MidiControl_DataEntryLSB        = 0x26,
        MidiControl_ChannelVolumeLSB    = 0x27,
        MidiControl_BalanceLSB          = 0x28,
        MidiControl_PanLSB              = 0x2a,
        MidiControl_ExpressionCtrlLSB   = 0x2b,
        MidiControl_EffectCtrl1LSB      = 0x2c,
        MidiControl_EffectCtrl2LSB      = 0x2d,
        MidiControl_GeneralCtrl1LSB     = 0x30,
        MidiControl_GeneralCtrl2LSB     = 0x31,
        MidiControl_GeneralCtrl3LSB     = 0x32,
        MidiControl_GeneralCtrl4LSB     = 0x33,

        MidiControl_SustainPedal        = 0x40,
        MidiControl_Portamento          = 0x41,
        MidiControl_Sostenuto           = 0x42,
        MidiControl_SoftPedal           = 0x43,
        MidiControl_Legato              = 0x44,
        MidiControl_Hold2               = 0x45,

        MidiControl_SoundVariationLSB   = 0x46,
        MidiControl_Timbre              = 0x47,
        MidiControl_ReleaseTime         = 0x48,
        MidiControl_AttackTime          = 0x49,
        MidiControl_Brightness          = 0x4a,

        MidiControl_GeneralCtrl5        = 0x50,
        MidiControl_GeneralCtrl6        = 0x51,
        MidiControl_GeneralCtrl7        = 0x52,
        MidiControl_GeneralCtrl8        = 0x53,
        MidiControl_PortamentoSource    = 0x54,
        MidiControl_ReverbDepth         = 0x5b,
        MidiControl_TremoloDepth        = 0x5c,
        MidiControl_ChorusDepth         = 0x5d,
        MidiControl_CelesteDepth        = 0x5e,
        MidiControl_PhaserDepth         = 0x5f,
        MidiControl_DataIncrement       = 0x60,
        MidiControl_DataDecrement       = 0x61,
        MidiControl_NRPM_LSB            = 0x62,
        MidiControl_NRPM_MSB            = 0x63,
        MidiControl_RPM_LSB             = 0x64,
        MidiControl_RPM_MSB             = 0x65,

        MidiControl_AllSoundOff         = 0x78,
        MidiControl_ResetAllControllers = 0x79,
        MidiControl_LocalControl        = 0x7a,
        MidiControl_AllNotesOff         = 0x7b,
        MidiControl_OmniModeOff         = 0x7c,
        MidiControl_OmniModeOn          = 0x7d,
        MidiControl_MonoModeOn          = 0x7e,
        MidiControl_PolyModeOn          = 0x7f
    };

    struct MidiCommand
    {
        MidiCommand(int status, int channel, int port,
                    int data1, int data2)
            : port(port), status(status), channel(channel),
              data1(data1), data2(data2), selected(0) {}

        MidiCommand(int status, int channel, int port,
                    int data1)
            : port(port), status(status), channel(channel),
              data1(data1), data2(0), selected(0) {}

        MidiCommand()
            : port(0), status(MidiCommand_Invalid), channel(0),
              data1(0), data2(0), selected(0) {}

        int noDataBytes() const
        {
            return MidiCommand_NoDataBytes[status << 4];
        }

        bool isChannel() const
        {
            return (status >= MidiCommand_NoteOn
                    && status <= MidiCommand_PitchBend);
        }

        bool isNote() const
        {
            return (status >= MidiCommand_NoteOff
                    && status <= MidiCommand_KeyPressure);
        }

        int port;

        unsigned status   : 4;

        signed channel  : 5;

        unsigned data1    : 8;

        unsigned data2    : 8;

        unsigned selected : 1;

        enum MagicPortNumbers
        {
            NoPort   = -1,
            AllPorts = -2,
            SamePort = -3
        };

        enum MagicChannelNumbers
        {
            NoChannel   = -1,
            AllChannels = -2,
            SameChannel = -3
        };

        int operator==(const MidiCommand &c) const
        {
            return channel == c.channel
                   && status == c.status
                   && data1  == c.data1
                   && data2  == c.data2
                   && port   == c.port;
        }
    };


    struct MidiEvent
    {
        MidiEvent()
        : data(MidiCommand()), time(0), offData(MidiCommand()), offTime(0) {}

        MidiEvent(MidiCommand mc, Clock t)
        : data(mc), time(t), offData(MidiCommand()), offTime(0) {}

        MidiEvent(MidiCommand mc, Clock t, MidiCommand oc, Clock ot)
        : data(mc), time(t), offData(oc), offTime(ot) {}

        MidiEvent(MidiCommand mc, Clock t, int offVel, Clock ot)
        : data(mc), time(t), offData(mc), offTime(ot)
        {
            offData.status = MidiCommand_NoteOff;
            offData.data2 = offVel;
        }

        MidiCommand data;

        Clock time;

        MidiCommand offData;

        Clock offTime;

        /*
         * This comparison operator only compares event times, NOT the data
         * contents.
         */
        int operator<(const MidiEvent &e) const { return time < e.time; }

        int operator<=(const MidiEvent &e) const { return time <= e.time; }

        /*
         * This comparison operator only compares event times, NOT the data
         * contents.
         */
        int operator>(const MidiEvent &e) const { return time > e.time; }

        int operator>=(const MidiEvent &e) const { return time >= e.time; }

        int operator==(const MidiEvent &e) const { return time == e.time; }

        int operator!=(const MidiEvent &e) const { return time != e.time; }

        bool equals(const MidiEvent &e) const
        {
            return (time == e.time) && (data == e.data);
            // XXX: what about MidiCommand_NoteOffs ???
        }

        class equal_to
        {
            public:
                equal_to(const MidiEvent &e) : e1(e) {}
                bool operator()(const MidiEvent &e2) const
                {
                    return e1.equals(e2);
                }
            private:
                const MidiEvent &e1;
        };
    };
};

#endif

---