multitrack.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_MULTITRACK_H
#define _NICMIDI_MULTITRACK_H
 
#include "track.h"
 
#include <vector>
 
 
class MIDIEditMultiTrack;       // forward declaration
 
class MIDIMultiTrack {
    public:
                                    MIDIMultiTrack(unsigned int num_tracks = 0,
                                                   unsigned int cl_p_b = DEFAULT_CLKS_PER_BEAT);
 
                                    MIDIMultiTrack(const MIDIMultiTrack& mlt);
        virtual                     ~MIDIMultiTrack();
 
        MIDIMultiTrack&             operator=(const MIDIMultiTrack& mlt);
        void                        Reset(unsigned int num_tracks = 0);
        void                        ClearTracks(bool mantain_end = false);
 
        unsigned int                GetClksPerBeat() const          { return clks_per_beat; }
        MIDITrack*                  GetTrack(unsigned int trk_num)  { return tracks[trk_num]; }
        const MIDITrack*            GetTrack(unsigned int trk_num) const
                                                                    { return tracks[trk_num]; }
        int                         GetTrackNum(MIDITrack* trk) const;
        unsigned int                GetNumTracks() const                        { return tracks.size(); }
        unsigned int                GetNumTracksWithEvents() const;
        unsigned int                GetNumEvents() const;
        MIDIClockTime               GetEndTime() const;
        bool                        IsValidTrackNumber(unsigned int trk_num) const
                                                                    { return (trk_num < tracks.size()); }
        bool                        IsEmpty() const                 { return (GetNumEvents() == GetNumTracks() &&
                                                                              GetEndTime() == 0); }
 
        void                        SetClksPerBeat(unsigned int cl_p_b);
        bool                        SetEndTime(MIDIClockTime end_time);
 
        void                        ShrinkEndTime();
 
        void                        AssignEventsToTracks (const MIDITrack *src);
        void                        AssignEventsToTracks (unsigned int trk_num = 0)
                                            { return AssignEventsToTracks(GetTrack(trk_num)); }
        bool                        InsertTrack(int trk_num = -1);
        bool                        InsertTrack(const MIDITrack* trk, int trk_num = -1);
        bool                        DeleteTrack(int trk_num = -1);
        bool                        MoveTrack(int from, int to);
        bool                        SetTrack(const MIDITrack* trk, unsigned int trk_num);
        bool                        InsertEvent(unsigned int trk_num,  const MIDITimedMessage& msg, tInsMode _ins_mode = INSMODE_DEFAULT);
        bool                        InsertNote(unsigned int trk_num, const MIDITimedMessage& msg,
                                            MIDIClockTime len, tInsMode _ins_mode = INSMODE_DEFAULT);
        bool                        DeleteEvent(unsigned int trk_num,  const MIDITimedMessage& msg);
        bool                        DeleteNote(unsigned int trk_num, const MIDITimedMessage& msg);
 
 
        void                        EditCopy(MIDIClockTime start, MIDIClockTime end, int tr_start,
                                                int tr_end, MIDIEditMultiTrack* edit);
                                        // makes a new interval in *edit, with tracks from tr_start to tr_end
        void                        EditCut(MIDIClockTime start, MIDIClockTime end, MIDIEditMultiTrack* edit);
                                        // deletes events and shifts subsequents (only on entire multitrack)
        void                        EditClear(MIDIClockTime start, MIDIClockTime end, int tr_start, int tr_end);
                                        // erase events in tracks tr_start ... tr_end
        void                        EditInsert(MIDIClockTime start, int tr_start, int times, MIDIEditMultiTrack* edit);
                                        // insert interval <edit> in <time_start>
                                        // (if <edit> == 0 insert a blank interval)
        void                        EditReplace(MIDIClockTime start, int tr_start, int times,
                                                bool sysex, MIDIEditMultiTrack* edit);
 
    protected:
        unsigned int                clks_per_beat;      
        std::vector<MIDITrack*>     tracks;             // The array of pointers to the MIDITrack objects
};
 
 
class MIDIMultiTrackIteratorState {
    // This is used only by the MIDIMultiTrackIterator, so all is protected
    friend class MIDIMultiTrackIterator;
 
    public:
        // The constructor.
                                    MIDIMultiTrackIteratorState(int n_tracks);
 
                    // . . . no need for dtor and others . . .
    protected:
        // Changes the number of tracks (this causes a reset of the state).
        void                        SetNumTracks(unsigned int n);
        // Sets the time to 0 and an undefined first event and track. Does not reset time shift mode.
        // \warning this is, in general, **not** a valid state. Don't call this but MIDIMultiTrackIterator::Reset().
        void                        Reset();
        // Internal use.
        int                         FindTrackOfFirstEvent();
 
        unsigned int                num_tracks;         // The number of tracks
        MIDIClockTime               cur_time;           // The current time
        int                         cur_event_track;    // The track of the next event
        std::vector<int>            next_event_number;  // Array holding the next event for every track (or -1 if no events left)
        std::vector<MIDIClockTime>  next_event_time;    // Array holding the next event time for every track
        std::vector<bool>           enabled;            // Array for enabling and disabling tracks
        bool                        time_shift_mode;    // Time shift on/off
};
 
 
class MIDIMultiTrackIterator {
    public:
 
                                    MIDIMultiTrackIterator (MIDIMultiTrack *mlt);
        void                        Reset();
        MIDIClockTime               GetCurrentTime() const              { return state.cur_time; }
        bool                        GetTimeShiftMode() const            { return state.time_shift_mode; }
        MIDIMultiTrackIteratorState&        GetState()                  { return state; }
        const MIDIMultiTrackIteratorState&  GetState() const            { return state; }
        void                        SetTimeShiftMode(bool f)            { state.time_shift_mode = f; }
        void                        SetEnable(unsigned int trk_num, bool f);
        void                        SetState(const MIDIMultiTrackIteratorState& s) { state = s; }
        bool                        GoToTime(MIDIClockTime time);
        bool                        GetNextEvent(int *track, MIDITimedMessage **msg);
        bool                        GetNextEventOnTrack(int track, MIDITimedMessage **msg);
        bool                        GetNextEventTime(MIDIClockTime *t) const;
        // Returns a pointer to the MIDIMultiTrack the iterator is attached to.
        //MIDIMultiTrack*             GetMultiTrack()                               { return multitrack; }
        //const MIDIMultiTrack*       GetMultiTrack() const                 { return multitrack; }
 
    protected:
        // Returns the time of the given MIDITimedMessage in the given track, taking into account the time
        // shifting. This is the same time of the message if time shifting is off or _msg_ is not a channel
        // or sysex message, otherwise this will return the message time plus the track offset.
        MIDIClockTime               GetShiftedTime(const MIDITimedMessage* msg, int trk);
 
        MIDIMultiTrack*             multitrack;     // The MIDIMultiTrack the class refers to
        MIDIMultiTrackIteratorState state;          // The iterator state
};
 
 
 
class MIDIEditMultiTrack : public MIDIMultiTrack {
    public:
                                    MIDIEditMultiTrack(unsigned int cl_p_b = DEFAULT_CLKS_PER_BEAT) :
                                    MIDIMultiTrack(cl_p_b), start_track(0), end_track(0) {}
        virtual                     ~MIDIEditMultiTrack() {}
 
        void                        SetStartTrack(int trk)      { start_track = trk; }
        void                        SetEndTrack(int trk)        { end_track = trk; }
        int                         GetStartTrack() const       { return start_track; }
        int                         GetEndTrack() const         { return end_track; }
 
                    // these must be disabled in derived class: so they are declared but not implemented
        void                        EditCopy(MIDIClockTime start, MIDIClockTime end, int tr_start,
                                                int tr_end, MIDIEditMultiTrack* edit) {}
        void                        EditCut(MIDIClockTime start, MIDIClockTime end, MIDIEditMultiTrack* edit) {}
        void                        EditClear(MIDIClockTime start, MIDIClockTime end, int tr_start, int tr_end) {}
        void                        EditInsert(MIDIClockTime start, int tr_start, int times,
                                                bool sysex, MIDIEditMultiTrack* edit) {}
        void                        EditReplace(MIDIClockTime start, int tr_start, int times,
                                                bool sysex, MIDIEditMultiTrack* edit) {}
 
 
        //void                    CopyTrack(int n, MIDIMultiTrack* trk);
                                // use operator= instead!
        void                        CopyAll(MIDIMultiTrack* m);
                                // does a Clear and copy
 
    private:
 
        int                         start_track;
        int                         end_track;
 
 
};
 
 
#endif