recorder.h

Go to the documentation of this file.

/*
 *   NiCMidi - A C++ Class Library for MIDI
 *
 *   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_RECORDER_H
#define _NICMIDI_RECORDER_H
 
#include "sequencer.h"
#include "processor.h"
 
#include <atomic>
#include <vector>
#include <set>
#include <stack>
 
/*
class MIDIMultiTrackCopier {
    public:
                                        MIDIMultiTrackCopier();
        virtual                         ~MIDIMultiTrackCopier();
 
        void                            Reset();
        MIDITrack*                      GetTrackDest(unsigned int n) const;
 
        void                            SetTrackDest(unsigned int n, MIDITrack* trk);
        void                            ResetTrackDest(unsigned int n);
 
        void                            Copy();
 
    private:
        MIDIMultiTrack* source;
        std::vector<MIDITrack*> dest;
};
*/
 
/*
class MIDIRecorderState : 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:
                                MIDIRecorderState(MIDIMultiTrack *multitrack_,
                                                  MIDISequencerGUINotifier *n = 0);
                                MIDIRecorderState(const MIDIRecorderState &s);
        virtual                 ~MIDIRecorderState();
        const MIDIRecorderState& operator= (const MIDIRecorderState &s);
 
        void                    Reset();
        bool                    Process( MIDITimedMessage* msg );
        void                    Notify(int group, int item = 0) const;
        void                    NotifyTrack(int item) const;
 
        MIDISequencerGUINotifier* notifier;         ///< The notifier
        MIDIMultiTrack*         multitrack;         ///< The MIDIMultiTrack holding MIDI messages
        MIDIMultiTrackIterator  iterator;           ///< The iterator for moving along the multitrack
 
        MIDIClockTime           cur_clock;          ///< The current MIDI clock in MIDI ticks
        float                   cur_time_ms;        ///< The current clock in milliseconds
        unsigned int            cur_beat;           ///< The current beat in the measure (1st beat is 0)
        unsigned int            cur_measure;        ///< The current measure (1st measure is 0)
        MIDIClockTime           beat_length;        ///< The duration of a beat
        MIDIClockTime           next_beat_time;     ///< The MIDI time of the next beat (for internal use)
 
        float                   tempobpm;           ///< The current tempo in beats per minute
        char                    timesig_numerator;  ///< The numerator of current time signature
        char                    timesig_denominator;///< The denominator of current time signature
        //char                    keysig_sharpflat;   ///< The current key signature accidents (
        //char                    keysig_mode;        ///< Major mode (0) or minor (1)
        //std::string             marker_text;        ///< The current marker
        //std::vector<MIDISequencerTrackState*>
        //                        track_states;       ///< A track state for every track
        int                     last_event_track;   ///< Internal use
        MIDIClockTime           last_beat_time;     ///< Internal use
        static int              metronome_mode;     ///< Flag affecting how metronome beat is calculated
};
*/
 
 
class RecNotifier: public MIDISequencerGUINotifier {
    public:
                                        RecNotifier(MIDISequencer* seq = 0);
        unsigned char                   GetMeasNote() const                 { return meas_note; }
        unsigned char                   GetBeatNote() const                 { return beat_note; }
        MIDISequencerGUINotifier*       GetOtherNotifier() const            { return other_notifier; }
        void                            SetMeasNote(unsigned char note)     { meas_note = note; }
        void                            SetBeatNote(unsigned char note)     { beat_note = note; }
        void                            SetOutPort(unsigned int p)          { port = p; }
        void                            SetOutChannel(int ch)               { chan = ch & 0x0f; }
        void                            SetOtherNotifier(MIDISequencerGUINotifier* n)
                                                                            { other_notifier = n; }
        virtual void                    Notify(const MIDISequencerGUIEvent &ev);
    private:
        const unsigned char             DEFAULT_MEAS_NOTE = 68;
        const unsigned char             DEFAULT_BEAT_NOTE = 60;
 
        unsigned char                   meas_note;          // The MIDI note number for the measure click (1st note of a measure)
        unsigned char                   beat_note;          // The MIDI note number for the ordinary beat click
        unsigned int                    port;               // The out port id
        unsigned char                   chan;               // The MIDI channel for sound output
        MIDIMessage                     on_msg;
        MIDIMessage                     off_msg;
        unsigned char                   num_beats;
        MIDISequencerGUINotifier*       other_notifier;
};
 
 
class MIDIRecorder : public MIDITickComponent {
    public:
                                        MIDIRecorder(MIDISequencer* const s);
        virtual                         ~MIDIRecorder();
        virtual void                    Reset();
        MIDIMultiTrack*                 GetMultiTrack() const           { return tracks; }
        int                             GetRecMode() const              { return rec_mode; }
        MIDIClockTime                   GetStartRecTime() const         { return rec_start_time; }
        MIDIClockTime                   GetEndRecTime() const           { return rec_end_time; }
        MIDITrack*                      GetTrack(unsigned int trk_num)  { return tracks->GetTrack(trk_num); }
        const MIDITrack*                GetTrack(unsigned int trk_num) const
                                                                        { return tracks->GetTrack(trk_num); }
        unsigned int                    GetTrackInPort(unsigned int trk_num) const
                                                                { return seq->GetTrack(trk_num)->GetInPort(); }
        int                             GetTrackRecChannel(unsigned int trk_num)
                                                                { return seq->GetTrack(trk_num)->GetRecChannel(); }
        bool                            SetTrackInPort(unsigned int trk_num, unsigned int port);
        bool                            SetTrackRecChannel(unsigned int trk_num, int chan);
        bool                            SetRecMode(int mode);
        bool                            SetStartRecTime(MIDIClockTime t);
        bool                            SetStartRecTime(unsigned int meas, unsigned int beat = 0)
                                                            { return SetStartRecTime(seq->MeasToMIDI(meas, beat)); }
        bool                            SetEndRecTime(MIDIClockTime t);
        bool                            SetEndRecTime(unsigned int meas, unsigned int beat = 0)
                                                            { return SetEndRecTime(seq->MeasToMIDI(meas, beat)); }
 
        bool                            InsertTrack(int trk_num = -1);
        bool                            DeleteTrack(int trk_num = -1);
        bool                            MoveTrack(int from, int to);
        bool                            EnableTrack(unsigned int trk_num);
        bool                            DisableTrack(unsigned int trk_num);
        bool                            UndoRec();
 
        virtual void                    Start();
        virtual void                    Stop();
 
        enum {
            REC_MERGE,                      
            REC_OVER                        
        };
 
    protected:
        void                            ResizeTracks(unsigned int max_num);
        void                            SetSeqNotifier();
        void                            ResetSeqNotifier();
        void                            PrepareTrack(unsigned int trk_num);
        static void                     StaticTickProc(tMsecs sys_time, void* pt);
        virtual void                    TickProc(tMsecs sys_time);
 
        MIDISequencer* const            seq;                // The attached sequencer
        MIDIMultiTrack*                 tracks;             // The internal MIDIMultiTrack
        MIDIMultiTrack*                 seq_tracks;         // The sequencer multitrack
        std::vector<bool>               en_tracks;          // True if the corresponding track isenabled
        std::set<unsigned int>          en_ports;           // Enabled input ports
 
        tMsecs                          rec_time_offset;    // The time between time 0 and sequencer start
        //tMsecs                          sys_time_offset;    ///< The time between the timer start and the sequencer start
        MIDIClockTime                   rec_start_time;     // The MIDIClockTime of the beginning of recording
        MIDIClockTime                   rec_end_time;       // The MIDIClockTime of the end of recording
        int                             rec_mode;           // The recording mode (REC_MERGE or REC_OVER)
        RecNotifier                     notifier;           // A notifier used as a metronome
        int                             old_seq_mode;       // Internal use
        std::atomic<bool>               rec_on;             // Internal use
        std::stack<MIDIMultiTrack*>     undo_stack;         // Stack of multitracks for undo
 
};
 
 
 
#endif // RECORDER_H_INCLUDED