sequencer.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_SEQUENCER_H
#define _NICMIDI_SEQUENCER_H
 
#include "multitrack.h"
#include "matrix.h"
#include "processor.h"
#include "notifier.h"
#include "tick.h"
 
#include <string>
#include <mutex>
#include <atomic>
 
 
class MIDISequencer;        // forward declaration
 
 
 
class MIDISequencerTrackState {
    public:
                        MIDISequencerTrackState();
        virtual         ~MIDISequencerTrackState() {}
 
        // Copy constructor and assignment operator generated by the compiler
        //                MIDISequencerTrackState(const MIDISequencerTrackState &s);
 
        virtual void    Reset();
 
        int16_t         program;                    
        int16_t         bender_value;           
        std::string     track_name;             
        bool            notes_are_on;       
        MIDIMatrix      note_matrix;        
        int16_t         control_values[C_ALL_NOTES_OFF];
        bool            got_good_track_name;
};
 
 
class MIDISequencerState : public MIDIProcessor {
// Doesn't inherit from MIDISequencerGUINotifier because notifier and sequencer must be independent objects
// (notifier is used also by the MIDIManager)
// All is public: used by various classes
    public:
                                MIDISequencerState(MIDIMultiTrack *multitrack_,
                                                   MIDISequencerGUINotifier *n = 0);
                                MIDISequencerState(const MIDISequencerState &s);
        virtual                 ~MIDISequencerState();
        const MIDISequencerState& operator= (const MIDISequencerState &s);
 
        void                    Reset();
        bool                    Process(MIDITimedMessage* msg);
        void                    Notify(int group, int item = 0) const;
        void                    NotifyTrack(int item) const;
        void                    GoForwardNoEvent(MIDIClockTime t);
 
 
 
        MIDISequencerGUINotifier* notifier;         
        MIDIMultiTrack*         multitrack;         
        MIDIMultiTrackIterator  iterator;           
 
        MIDIClockTime           cur_clock;          
        float                   cur_time_ms;        
        unsigned int            cur_beat;           
        unsigned int            cur_measure;        
        MIDIClockTime           beat_length;        
        unsigned int            number_of_beats;    
        MIDIClockTime           next_beat_time;     
 
        float                   tempobpm;           
        unsigned int            tempo_scale;        
        unsigned char           timesig_numerator;  
        unsigned char           timesig_denominator;
        signed char             keysig_sharpflat;   
        unsigned char           keysig_mode;        
        std::string             marker_text;        
        std::vector<MIDISequencerTrackState*>
                                track_states;       
        int                     last_event_track;   
        MIDIClockTime           last_beat_time;     
        float                   ms_per_clock;       
        float                   last_time_ms;       
        MIDIClockTime           last_tempo_change;  
        MIDIClockTime           count_in_time;      
 
        // TODO: change the name of this variable for example count_in_stop
        unsigned char           playing_status;     
        static int              metronome_mode;     
};
 
 
class MIDISequencer : public MIDITickComponent {
    public:
                                        MIDISequencer(MIDIMultiTrack* m, MIDISequencerGUINotifier* n = 0);
        virtual                         ~MIDISequencer();
        virtual void                    Reset();
 
        //virtual bool                    IsPlaying() const       { return (MIDITickComponent::IsPlaying() || autostop.load()); }
        MIDIClockTime                   GetCurrentMIDIClockTime() const;
        float                           GetCurrentTimeMs() const;
        unsigned int                    GetCurrentMeasure() const
                                                                { return state.cur_measure; }
        unsigned int                    GetCurrentBeat() const  { return state.cur_beat; }
        MIDIClockTime                   GetCurrentBeatOffset() const
                                                                { return state.cur_clock - state.last_beat_time; }
        unsigned int                    GetClksPerBeat() const  { return state.multitrack->GetClksPerBeat(); }
 
        MIDIMultiTrack*                 GetMultiTrack()         { return state.multitrack; }
        const MIDIMultiTrack*           GetMultiTrack() const   { return state.multitrack; }
        MIDITrack*                      GetTrack(unsigned int trk_num)
                                            { return state.multitrack->IsValidTrackNumber(trk_num) ?
                                                     state.multitrack->GetTrack(trk_num) : 0; }
        unsigned int                    GetNumTracks() const    { return state.multitrack->GetNumTracks(); }
        unsigned int                    GetTempoScale() const   { return state.tempo_scale; }
        float                           GetTempoWithoutScale() const
                                                                { return state.tempobpm; }
        float                           GetTempoWithScale() const
                                                                { return state.tempobpm * state.tempo_scale * 0.01; }
        bool                            GetRepeatPlay() const   { return repeat_play_mode; }
        unsigned int                    GetRepeatPlayStart() const
                                                                { return repeat_start_meas; }
        unsigned int                    GetRepeatPlayEnd() const
                                                                { return repeat_end_meas; }
        bool                            GetCountInEnable() const    { return state.playing_status & COUNT_IN_ENABLED; }
        bool                            GetCountInPending() const   { return state.playing_status & COUNT_IN_PENDING; }
 
        bool                            GetTimeShiftMode() const    { return time_shift_mode; }
        MIDISequencerState*             GetState()              { return &state; }
        const MIDISequencerState*       GetState() const        { return &state; }
        bool                            GetPlayMode()           { return play_mode; }
        MIDISequencerTrackState*        GetTrackState(unsigned int trk_num)
                                                                { return state.track_states[trk_num]; }
        const MIDISequencerTrackState*  GetTrackState(unsigned int trk_num) const
                                                                { return state.track_states[trk_num]; }
        unsigned int                    GetTrackOutPort(unsigned int trk_num) const
                                                                { return state.multitrack->GetTrack(trk_num)->GetOutPort(); }
        MIDIProcessor*                  GetTrackProcessor(unsigned int trk_num)
                                                                { return track_processors[trk_num]; }
        const MIDIProcessor*            GetTrackProcessor(unsigned int trk_num) const
                                                                { return track_processors[trk_num]; }
        int                             GetTrackTimeShift(unsigned int trk_num) const
                                                                { return state.multitrack->GetTrack(trk_num)->GetTimeShift(); }
        virtual bool                    SetRepeatPlay(int on_off, int start_meas = -1, int end_meas = -1);
        virtual void                    SetCountIn(bool on_off);
        virtual bool                    SetTempoScale(unsigned int scale);
        virtual void                    SetTimeShiftMode(bool f);
        virtual void                    SetState(MIDISequencerState* s);
        virtual void                    SetPlayMode(int mode);
        virtual bool                    SetTrackOutPort(unsigned int trk_num, unsigned int port);
        virtual bool                    SetTrackProcessor(unsigned int trk_num, MIDIProcessor* p);
        virtual bool                    SetTrackTimeShift(unsigned int trk_num, int offset);
 
        virtual bool                    InsertTrack(int trk_num = -1);
        virtual bool                    DeleteTrack(int trk_num = -1);
        virtual bool                    MoveTrack(int from, int to);
        virtual void                    GoToZero();
        virtual bool                    GoToTime (MIDIClockTime time_clk);
        virtual bool                    GoToTimeMs (float time_ms);
        virtual bool                    GoToMeasure (unsigned int measure, unsigned int beat = 0);
        virtual bool                    GetNextEvent (int *trk_num, MIDITimedMessage *msg);
        virtual bool                    GetNextEventTime (MIDIClockTime *time_clk);
        virtual bool                    GetNextEventTimeMs (float *time_ms);
        float                           MIDItoMs(MIDIClockTime time_clk);  // new : added by me
        MIDIClockTime                   MeasToMIDI(unsigned int meas, unsigned int beat = 0, unsigned int offset = 0);
        virtual void                    UpdateStatus()  { GoToTime(state.cur_clock); }
 
        // Inherited from MIDITICK
        virtual void                    Start();
        virtual void                    Stop();
        virtual void                    Play()         { Start(); }
 
        enum {
            FOLLOW_MIDI_TIMESIG_MESSAGE,    
            FOLLOW_TIMESIG_DENOMINATOR,     
            FOLLOW_THEORETIC_VALUE          
        };
 
        static void                     SetMetronomeMode(int mode)
                                                        { MIDISequencerState::metronome_mode = mode; }
 
        enum {
            PLAY_BOUNDED,                   
            PLAY_UNBOUNDED                  
        };
 
        enum {
            COUNT_IN_ENABLED  = 1,          
            COUNT_IN_PENDING  = 2,          
            AUTO_STOP_PENDING = 4           
        };
 
    protected:
        static void                     StaticTickProc(tMsecs sys_time, void* pt);
        virtual void                    TickProc(tMsecs sys_time);
        static void                     StaticStopProc(MIDISequencer* p)    { p->Stop(); }
 
        // Internal use: scans events at 'now' time upgrading the sequencer state
        void                            ScanEventsAtThisTime();
 
        // Internal use: prepares the count in
        void                            CountInPrepare();
 
        MIDITimedMessage                beat_marker_msg;    // Used by the sequencer to send beat marker messages
 
        bool                            repeat_play_mode;   // Enables the repeat play mode
        unsigned int                    repeat_start_meas;  // The loop start measure
        unsigned int                    repeat_end_meas;    // The loop end measure
        bool                            time_shift_mode;    // The time shift on/off (during playback time shift is always on)
        int                             play_mode;          // PLAY_BOUNDED or PLAY_UNBOUNDED
 
        std::vector<MIDIProcessor*>     track_processors;   // A MIDIProcessor for every track
        MIDISequencerState              state;              // The sequencer state
};
 
 
#endif