DynamicClock.hh

Go to the documentation of this file.

#ifndef DYNAMICCLOCK_HH
#define DYNAMICCLOCK_HH
 
#include "EmuTime.hh"
#include "DivModBySame.hh"
#include "narrow.hh"
#include <cassert>
 
namespace openmsx {
 
class DynamicClock
{
public:
        // Note: default copy constructor and assignment operator are ok.
 
        explicit DynamicClock(EmuTime::param time) : lastTick(time) {}
 
        DynamicClock(EmuTime::param time, unsigned freq)
                : lastTick(time)
        {
                setFreq(freq);
        }
 
        [[nodiscard]] EmuTime::param getTime() const {
                return lastTick;
        }
 
        [[nodiscard]] bool before(EmuTime::param e) const {
                return lastTick.time < e.time;
        }
 
        [[nodiscard]] unsigned getTicksTill(EmuTime::param e) const {
                assert(e.time >= lastTick.time);
                return divMod.div(e.time - lastTick.time);
        }
        struct IntegralFractional {
                unsigned integral;
                float fractional;
        };
        [[nodiscard]] IntegralFractional getTicksTillAsIntFloat(EmuTime::param e) const {
                assert(e.time >= lastTick.time);
                auto dur = e.time - lastTick.time;
                auto [q, r] = divMod.divMod(dur);
                auto f = float(r) / float(getStep());
                assert(0.0f <= f); assert(f < 1.0f);
                return {q, f};
        }
 
        template<typename FIXED>
        void getTicksTill(EmuTime::param e, FIXED& result) const {
                assert(e.time >= lastTick.time);
                uint64_t tmp = (e.time - lastTick.time) << FIXED::FRACTION_BITS;
                result = FIXED::create(divMod.div(tmp + (getStep() / 2)));
        }
 
        [[nodiscard]] unsigned getTicksTillUp(EmuTime::param e) const {
                assert(e.time >= lastTick.time);
                return divMod.div(e.time - lastTick.time + (getStep() - 1));
        }
 
        [[nodiscard]] double getTicksTillDouble(EmuTime::param e) const {
                assert(e.time >= lastTick.time);
                return double(e.time - lastTick.time) / getStep();
        }
 
        [[nodiscard]] uint64_t getTotalTicks() const {
                // note: don't use divMod.div() because that one only returns a
                //       32 bit result. Maybe improve in the future.
                return lastTick.time / getStep();
        }
 
        void setFreq(unsigned freq) {
                unsigned newStep = (MAIN_FREQ32 + (freq / 2)) / freq;
                setPeriod(EmuDuration(uint64_t(newStep)));
        }
        void setFreq(unsigned freq_num, unsigned freq_denom) {
                static_assert(MAIN_FREQ < (1ull << 32), "must fit in 32 bit");
                uint64_t p = MAIN_FREQ * freq_denom + (freq_num / 2);
                uint64_t newStep = p / freq_num;
                setPeriod(EmuDuration(newStep));
        }
 
        [[nodiscard]] unsigned getFreq() const {
                auto step = getStep();
                return narrow<unsigned>((MAIN_FREQ + (step / 2)) / step);
        }
 
        [[nodiscard]] EmuDuration getPeriod() const {
                return EmuDuration(uint64_t(getStep()));
        }
 
        void setPeriod(EmuDuration period) {
                assert(period.length() < (1ull << 32));
                divMod.setDivisor(uint32_t(period.length()));
        }
 
        void reset(EmuTime::param e) {
                lastTick.time = e.time;
        }
 
        void advance(EmuTime::param e) {
                assert(lastTick.time <= e.time);
                lastTick.time = e.time - divMod.mod(e.time - lastTick.time);
        }
 
        void operator+=(uint64_t n) {
                lastTick.time += n * getStep();
        }
 
        [[nodiscard]] EmuTime operator+(uint64_t n) const {
                return EmuTime(lastTick.time + n * getStep());
        }
 
        void fastAdd(unsigned n) {
                #ifdef DEBUG
                // we don't even want this overhead in development versions
                assert((uint64_t(n) * getStep()) < (1ull << 32));
                #endif
                lastTick.time += n * getStep();
        }
        [[nodiscard]] EmuTime getFastAdd(unsigned n) const {
                return add(lastTick, n);
        }
        [[nodiscard]] EmuTime add(EmuTime::param time, unsigned n) const {
                #ifdef DEBUG
                assert((uint64_t(n) * getStep()) < (1ull << 32));
                #endif
                return EmuTime(time.time + n * getStep());
        }
 
        template<typename Archive>
        void serialize(Archive& ar, unsigned version);
 
private:
        [[nodiscard]] unsigned getStep() const { return divMod.getDivisor(); }
 
private:
        EmuTime lastTick;
 
        DivModBySame divMod;
};
SERIALIZE_CLASS_VERSION(DynamicClock, 2);
 
} // namespace openmsx
 
#endif