timer.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_TIMER_H
#define _NICMIDI_TIMER_H
 
#include <chrono>
#include <thread>
#include <atomic>
 
 
 
 
 
typedef unsigned long long tMsecs;
typedef  void (MIDITick)(tMsecs, void*);
 
 
class MIDITimer {
    public:
 
        typedef std::chrono::steady_clock::time_point timepoint;
                typedef std::chrono::milliseconds duration;
                                    MIDITimer() = delete;
        static unsigned int         GetResolution()                 { return resolution; }
        static MIDITick*            GetMIDITick()                   { return tick_proc; }
        static bool                 IsOpen()                        { return (num_open > 0);  }
 
        static void                 SetResolution(unsigned int res);
        static void                 SetMIDITick(MIDITick* t, void* tp = 0);
 
        static bool                 Start();
        static void                 Stop();
        static void                 HardStop();
 
        static tMsecs               GetSysTimeMs()
                                        { return std::chrono::duration_cast<std::chrono::milliseconds>
                                                 (std::chrono::steady_clock::now() - sys_clock_base).count(); }
        static void                 Wait(unsigned int msecs)
                                        { std::this_thread::sleep_for(std::chrono::milliseconds(msecs)); }
 
    protected:
 
        static const unsigned int   DEFAULT_RESOLUTION = 10;
        static void                 ThreadProc();
 
        static unsigned int         resolution;         // The actual timer resolution
        static MIDITick*            tick_proc;          // The callback function set by the user
        static void*                tick_param;         // The callback second parameter set by the user
        static std::thread          bg_thread;          // The background thread
        static std::atomic<int>     num_open;           // The number of times Start() was called without a corresponding Stop()
        static const timepoint      sys_clock_base;     // The base timepoint for calculating system time
        static timepoint            current;            // Internal use
};
 
//extern MIDITimer main_timer;
 
#endif // TIMER_H_INCLUDED