metronome.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_METRONOME_H
#define _NICMIDI_METRONOME_H
 
 
#include "midi.h"
#include "notifier.h"
#include "tick.h"
 
 
 
class Metronome : public MIDITickComponent {
    public:
                                        Metronome(MIDISequencerGUINotifier* n = 0);
        virtual                         ~Metronome() { Stop(); }
        virtual void                    Reset();
        MIDIClockTime                   GetCurrentMIDIClockTime() const     { return cur_clock; }
        float                           GetCurrentTimeMs() const;
        unsigned int                    GetCurrentMeasure() const           { return cur_measure; }
        unsigned int                    GetCurrentBeat() const              { return cur_beat; }
        unsigned int                    GetTempoScale() const               { return new_tempo_scale; }
        float                           GetTempoWithoutScale() const        { return new_tempobpm; }
        float                           GetTempoWithScale() const           { return new_tempobpm * new_tempo_scale * 0.01; }
        unsigned int                    GetOutPort() const                  { return new_out_port; }
        unsigned int                    GetOutChannel() const               { return new_chan; }
        unsigned char                   GetMeasNote() const                 { return new_meas_note; }
        unsigned char                   GetBeatNote() const                 { return new_beat_note; }
        unsigned char                   GetSubdNote() const                 { return new_subd_note; }
        unsigned char                   GetSubdType() const                 { return new_subd_type; }
        unsigned char                   GetTimeSigNumerator() const         { return timesig_numerator; }
        // TODO: Actually denominator is not implemented.
        //unsigned char                   GetTimeSigDenominator() const       { return timesig_denominator; }
        bool                            SetTempo(float t);
        bool                            SetTempoScale(unsigned int scale);
        bool                            SetOutPort(unsigned int port);
        bool                            SetOutChannel(unsigned int chan);
        void                            SetMeasNote(unsigned char note);
        void                            SetBeatNote(unsigned char note);
        void                            SetSubdNote(unsigned char note);
        bool                            SetSubdType(unsigned char type);
        void                            SetTimeSigNumerator(unsigned char n);
        // TODO: Actually this is not implemented: denominator is assumed 4
        //void                            SetTimeSigDenominator(unsigned char d);
 
        // Inherited from MIDITICK
 
        virtual void                    Start();
        virtual void                    Stop();
 
 
    protected:
        void                            UpdateValues();
        static void                     StaticTickProc(tMsecs sys_time, void* pt);
        virtual void                    TickProc(tMsecs sys_time);
 
        MIDISequencerGUINotifier*       notifier;           // The (optional) notifier
        unsigned int                    out_port;           // The out port id
        unsigned char                   chan;               // The MIDI channel for sound output
        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 char                   subd_note;          // The MIDI note number for subdivision click
        unsigned char                   subd_type;          // Number of subdivisions (can be 2, 3, 4, 5, 6, 0 = disable subd click)
        unsigned char                   timesig_numerator;  // The numerator of current time signature (0 = disable measure click)
        // TODO: actually denominator is assumed 4
        //unsigned char                   timesig_denominator;// The denominator of current time signature (can be 2, 4, 8, 16)
        float                           tempobpm;           // The current tempo in beats per minute
        unsigned int                    tempo_scale;        // The tempo scale in percentage (100 = true time)
 
        MIDIClockTime                   cur_clock;          // The current MIDI clock in MIDI ticks from the metronme start
        float                           cur_time_ms;        // The current clock in milliseconds from the metronoe start
        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
        float                           msecs_per_beat;     // Milliseconds per beat (for internal use)
        float                           onoff_time;         // Milliseconds between note on and off
        float                           next_time_on;       // The time of the next Note On message (for internal use)
        float                           next_time_off;      // The time of the next Note Off message (for internal use)
 
 
        /* UNUSED ????
        static int                      metronome_mode;     ///< Flag affecting how metronome beat is calculated
        MIDITimedMessage                msg_beat;
        */
 
 
        static const MIDIClockTime      QUARTER_LENGTH = DEFAULT_CLKS_PER_BEAT;
        static const unsigned char      DEFAULT_CHAN = 9;
        static const unsigned char      DEFAULT_MEAS_NOTE = 60;
        static const unsigned char      DEFAULT_BEAT_NOTE = 58;
        static const unsigned char      DEFAULT_SUBD_NOTE = 56;
        static const unsigned char      MEAS_NOTE_VEL = 120;
        static const unsigned char      BEAT_NOTE_VEL = 100;
        static const unsigned char      SUBD_NOTE_VEL = 80;
        static const int                MIN_NOTE_LEN = 20;      // C++ trouble if you declare it float!
 
    private:
        // These are set by our set methods, and are used as buffer values, because real values are updated only at a
        // metronome (or measure) click
        unsigned int                    new_out_port;
        unsigned char                   new_chan;
        unsigned char                   new_meas_note;
        unsigned char                   new_beat_note;
        unsigned char                   new_subd_note;
        unsigned char                   new_subd_type;
        unsigned char                   new_timesig_numerator;
        unsigned char                   new_timesig_denominator;
        float                           new_tempobpm;
        unsigned int                    new_tempo_scale;
};
 
 
#endif // METRONOME_H_INCLUDED