track.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_TRACK_H
#define _NICMIDI_TRACK_H
 
 
#include "manager.h"
#include "midi.h"
#include "sysex.h"
#include "msg.h"
 
#include <vector>
#include <string>
 
 
enum tInsMode
{
    INSMODE_DEFAULT,    
    INSMODE_INSERT,     
    INSMODE_REPLACE,    
    INSMODE_INSERT_OR_REPLACE,          
    INSMODE_INSERT_OR_REPLACE_BUT_NOTE  
};
 
 
enum
{
    COMPMODE_EQUAL,     
    COMPMODE_SAMEKIND,  
    COMPMODE_TIME       
};
 
 
class  MIDITrack {
    public:
                                    MIDITrack(MIDIClockTime end_time = 0);
                                    MIDITrack(const MIDITrack &trk);
        virtual                     ~MIDITrack()                {}
        // TODO: these should not be needed!
        MIDITrack&                  operator=(const MIDITrack &trk);
        void                        Reset();
        void                        Clear(bool mantain_end = false);
 
        unsigned int                GetNumEvents() const                { return events.size(); }
        bool                        IsValidEventNum(int ev_num) const
                                                { return (0 <= ev_num && (unsigned int)ev_num < events.size()); }
        bool                        IsEmpty() const                     { return events.size() == 1; }
        MIDIClockTime               GetEndTime() const                 { return events.back().GetTime(); }
        unsigned int                GetOutPort() const                  { return out_port; }
        unsigned int                GetInPort() const                   { return in_port; }
        int                         GetChannel();
        int                         GetStatus();
        unsigned char               GetType();
        int                         GetRecChannel()                         { return (int)rec_chan; }
        int                         GetTimeShift() const                    { return time_shift; }
        unsigned char               HasSysex();
        MIDITimedMessage*           GetEventAddress(unsigned int ev_num)    { return &events[ev_num]; }
        const MIDITimedMessage*     GetEventAddress(unsigned int ev_num) const      { return &events[ev_num]; }
        MIDITimedMessage&           GetEvent(unsigned int ev_num)           { return events[ev_num]; }
        const MIDITimedMessage&     GetEvent(unsigned int ev_num) const     { return events[ev_num]; }
 
        bool                        SetEndTime(MIDIClockTime end_time);
        bool                        SetChannel(int chan);
        bool                        SetRecChannel(int chan);
        bool                        SetInPort(unsigned int port);
        bool                        SetOutPort(unsigned int port);
        void                        SetTimeShift(int t)                 { time_shift = t; }
        void                        ShrinkEndTime();
        MIDIClockTime               GetNoteLength (const MIDITimedMessage& msg) const;
        bool                        InsertEvent(const MIDITimedMessage& msg, tInsMode mode = INSMODE_DEFAULT);
        bool                        InsertNote(const MIDITimedMessage& msg, MIDIClockTime len,
                                               tInsMode mode = INSMODE_DEFAULT);
        bool                        DeleteEvent(const MIDITimedMessage& msg);
        bool                        DeleteNote(const MIDITimedMessage& msg);
        void                        PushEvent(const MIDITimedMessage& msg);
        void                        InsertInterval(MIDIClockTime start, MIDIClockTime length, const MIDITrack* src = 0);
                                                    // if src == 0 only shift events of length clocks
        void                        MakeInterval(MIDIClockTime start, MIDIClockTime end, MIDITrack* interval) const;
        void                        DeleteInterval(MIDIClockTime start, MIDIClockTime end);
        void                        ClearInterval(MIDIClockTime start, MIDIClockTime end);
        void                        ReplaceInterval(MIDIClockTime start, MIDIClockTime end, const MIDITrack* src);
        // TODO: restored old version: test this (involves even interval methods)
        void                        CloseOpenEvents(MIDIClockTime from, MIDIClockTime to);
        bool                        FindEventNumber(const MIDITimedMessage& msg, int *event_num,
                                                    int mode = COMPMODE_EQUAL) const;
        bool                        FindEventNumber (MIDIClockTime time, int *event_num) const;
 
        static void                 SetInsertMode(tInsMode mode);
 
        enum {
            TYPE_EMPTY = 0,         
            TYPE_MAIN = 1,          
            TYPE_TEXT = 2,          
            TYPE_CHAN = 3,          
            TYPE_IRREG_CHAN = 4,    
            TYPE_MIXED_CHAN = 5,    
            TYPE_UNKNOWN = 6,       
            TYPE_SYSEX = 7,         
            TYPE_RESET_SYSEX = 8,   
            TYPE_BOTH_SYSEX = 9,    
            INIT_STATUS = 0xff,     
            HAS_MAIN_META = 0x100,  
            HAS_TEXT_META = 0x200,  
            HAS_ONE_CHAN = 0x400,   
            HAS_MANY_CHAN = 0x800,  
            HAS_SYSEX = 0x1000,     
            HAS_RESET_SYSEX = 0x2000,
            STATUS_DIRTY = 0x4000   
        };
 
 
    protected:
        void                        Analyze();
 
        std::vector<MIDITimedMessage>
                                    events;     // The buffer of events
        int                         status;     // A bitfield used to determine the track type
        signed char                 rec_chan;   // The channel for recordng, or -1 for all channels
        int                         time_shift; // The time shift in MIDI ticks
        unsigned int                in_port;    // The in port id for recording midi events
        unsigned int                out_port;   // The out port id for playing midi events
 
        static tInsMode             ins_mode;   // See SetInsertMode()
};
 
 
class MIDITrackIterator {
    public:
                                    MIDITrackIterator(MIDITrack* trk);
        void                        Reset();
        MIDITrack*                  GetTrack()                  { return track; }
        const MIDITrack*            GetTrack() const            { return track;  }
        void                        SetTrack(MIDITrack* trk);
        MIDIClockTime               GetCurrentTime() const      { return cur_time; }
        unsigned int                GetCurrentEventNum() const  { return cur_ev_num; }
        int16_t                     GetProgram() const          { return program; }
        int16_t                     GetControl(unsigned char c) const
                                                                { return controls[c]; }
        int16_t                     GetBender() const           { return bender_value; }
        int                         GetNotesOn() const          { return num_notes_on; }
        bool                        IsNoteOn(unsigned char n) const
                                                                { return (notes_on[n] > 0); }
        bool                        IsPedalOn() const           { return controls[64] > 64; }
        bool                        FindNoteOff(unsigned char note, MIDITimedMessage** msg);
        bool                        FindPedalOff(MIDITimedMessage** msg);
        bool                        GoToTime(MIDIClockTime time);
        bool                        GetNextEvent(MIDITimedMessage** msg);
        bool                        GetNextEventTime(MIDIClockTime* t) const;
        bool                        EventIsNow(const MIDITimedMessage& msg);
        //bool GoToNextEvent(); unused use GetNextEvent()
 
    protected:
 
        bool                        Process(const MIDITimedMessage *msg);
        void                        ScanEventsAtThisTime();
                                        // warning: this can be used only when we reach the first
                                        // event at a new time!
 
        MIDITrack*                  track;
        unsigned int                cur_ev_num;     // number of the current event
        MIDIClockTime               cur_time;       // current time
 
        int16_t                     program;        // current program change, or -1
        int16_t                     controls[128];  // value of every control change, or -1
        int16_t                     bender_value;       // last seen bender value
        unsigned char               num_notes_on;       // number of notes currently on
        unsigned char                   notes_on[128];  // 0 if off, or velocity
};
 
 
#endif