advancedsequencer.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_ADVANCEDSEQUENCER_H
#define _NICMIDI_ADVANCEDSEQUENCER_H
 
#include <vector>
#include <string>
 
#include "thru.h"
#include "multitrack.h"
#include "filereadmultitrack.h"
#include "sequencer.h"
#include "smpte.h"
 
 
class MIDISequencerTrackProcessor : public MIDIProcessor {
    public:
                        MIDISequencerTrackProcessor();
        virtual         ~MIDISequencerTrackProcessor() {}
 
        // Copy constructor and assignment operator generated by the compiler
 
        virtual void    Reset();
        void            SetExternalProcessor(MIDIProcessor* proc)
                                                { extra_proc = proc; }
        virtual bool    Process ( MIDITimedMessage *msg );
 
        bool            mute;                   
        int             solo;                   
        unsigned int    velocity_scale;         
        int             rechannel;              
        int             transpose;              
        MIDIProcessor   *extra_proc;            
 
        enum { NO_SOLO, SOLOED, NOT_SOLOED };
};
 
 
class AdvancedSequencer : public MIDISequencer {
    public:
                            AdvancedSequencer(MIDISequencerGUINotifier *n = 0);
                            AdvancedSequencer(MIDIMultiTrack* mlt, MIDISequencerGUINotifier *n = 0);
        virtual             ~AdvancedSequencer();
 
        virtual void        Reset();
        virtual bool        Load(const char *fname);
        virtual bool        Load(const MIDIMultiTrack* tracks);
        virtual void        UnLoad();
 
        bool                IsLoaded() const                    { return file_loaded; }
        std::string         GetFileName()                       { return header.filename; }
        const MIDIFileHeader& GetFileHeader()                   { return header; }
        MIDIThru*           GetMIDIThru()                       { return thru; }
        const MIDIThru*     GetMIDIThru() const                 { return thru; }
        bool                GetMIDIThruEnable() const           { return thru ? thru->IsPlaying() : false; }
        int                 GetMIDIThruChannel() const          { return thru ? thru->GetOutChannel() : -1; }
        int                 GetMIDIThruTranspose() const        { return thru ? thru_transposer->GetChannelTranspose(0) : 0; }
        bool                GetSoloMode() const;
        bool                GetTrackSolo(unsigned int trk_num) const
                                                { return (((MIDISequencerTrackProcessor *)track_processors[trk_num])->solo ==
                                                  MIDISequencerTrackProcessor::SOLOED); }
        bool                GetTrackMute (unsigned int trk_num) const
                                                { return ((MIDISequencerTrackProcessor *)track_processors[trk_num])->mute; }
        int                 GetNumMeasures() const              { return num_measures; }
        unsigned int        GetCurrentMeasure() const;
        unsigned int        GetCurrentBeat() const;
        MIDIClockTime       GetCurrentBeatOffset() const;
        int                 GetTimeSigNumerator() const;
        int                 GetTimeSigDenominator() const;
        int                 GetKeySigSharpsFlats() const;
        int                 GetKeySigMode() const;
        std::string         GetCurrentMarker() const;
        std::string         GetTrackName(unsigned int trk_num) const;
        int                 GetTrackVolume(unsigned int trk_num) const;     // MIDI value or -1
        int                 GetTrackProgram (unsigned int trk_num) const;   // MIDI value or -1
        int                 GetTrackNoteCount(unsigned int trk_num) const;
        unsigned int        GetTrackVelocityScale(unsigned int trk_num) const;
        int                 GetTrackRechannelize(unsigned int trk_num) const;
        int                 GetTrackChannel(unsigned int trk_num);          // NOT const!!!
        int                 GetTrackTranspose(unsigned int trk_num) const;
        int                 GetTrackTimeShift(unsigned int trk_num) const;
        MIDISequencerTrackProcessor*    GetTrackProcessor(unsigned int trk_num)
                                                { return (MIDISequencerTrackProcessor *)track_processors[trk_num]; }
        const MIDISequencerTrackProcessor* GetTrackProcessor(unsigned int trk_num) const
                                                { return (const MIDISequencerTrackProcessor *)track_processors[trk_num]; }
        void                SetFileName(std::string& fname)     { header.filename = fname; }
        bool                SetMIDIThruEnable(bool on_off);
        bool                SetMIDIThruChannel(int chan);
        bool                SetMIDIThruTranspose (int amt);
        bool                SetTrackSolo(unsigned int trk_num);
        void                UnSoloTrack();
        bool                SetTrackMute(unsigned int trk_num, bool f);
        void                UnmuteAllTracks();
        bool                SetTrackVelocityScale(unsigned int trk_num, unsigned int scale);
        bool                SetTrackRechannelize(unsigned int trk_num, int chan);
        bool                SetTrackTranspose(unsigned int trk_num, int amt);
        virtual void        GoToZero()                          { GoToTime(0); }
        virtual bool        GoToTime(MIDIClockTime time_clk);
        virtual bool        GoToTimeMs(float time_ms);
        virtual bool        GoToMeasure(int measure, int beat = 0);
 
 
        virtual void        Start();
        virtual void        Stop();
        void                OutputMessage(MIDITimedMessage& msg, unsigned int port);
        bool                SetSMPTE(SMPTE* s);
        virtual void        UpdateStatus();
 
    protected:
 
        void                ExtractWarpPositions();
        void                CatchEventsBefore();
        void                CatchEventsBefore(int trk_num);
 
        // The interval between measures in ExtractWarpPositions()
        static const int                    MEASURES_PER_WARP = 4;
        MIDIThru*                           thru;               // The embedded MIDI thru
        MIDIProcessorTransposer*            thru_transposer;    // Transposes thru note messages while playing
        int                                 num_measures;       // Number of measures
        MIDIFileHeader                      header;             // Stores the loaded file parameters
        int                                 file_loaded;        // True if the multitrack is not empty
 
        std::vector<MIDISequencerState>     warp_positions;     // Vector of MIDISequencerState objects for fast time moving
 
    private:
        bool                                owns_tracks;        // true if the multitrack is owned by the AdvancedSequencer
};
 
 
#endif // JDKSMIDI_ADVANCEDSEQUENCER_H