clock.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cassert>
#include <promeki/atomic.h>
#include <promeki/namespace.h>
#include <promeki/clockdomain.h>
#include <promeki/duration.h>
#include <promeki/error.h>
#include <promeki/mediatimestamp.h>
#include <promeki/mutex.h>
#include <promeki/result.h>
#include <promeki/sharedptr.h>
#include <promeki/uniqueptr.h>
 
PROMEKI_NAMESPACE_BEGIN
 
struct ClockJitter {
                Duration minError;
 
                Duration maxError;
 
                Duration span() const { return maxError - minError; }
 
                bool isSymmetric() const { return minError.nanoseconds() == -maxError.nanoseconds(); }
};
 
class ClockFilter {
        public:
                using UPtr = UniquePtr<ClockFilter>;
 
                virtual ~ClockFilter() = default;
 
                virtual int64_t filter(int64_t rawNs) = 0;
};
 
enum class ClockPauseMode {
        CannotPause,           
        PausesRawKeepsRunning, 
        PausesRawStops         
};
 
class Clock {
        public:
                using Ptr = SharedPtr<Clock, /*CopyOnWrite=*/false, Clock>;
 
                Clock(const ClockDomain &domain, const Duration &fixedOffset = Duration::zero(),
                      ClockPauseMode pauseMode = ClockPauseMode::CannotPause, ClockFilter *filter = nullptr);
 
                virtual ~Clock();
 
                Clock(const Clock &) = delete;
                Clock &operator=(const Clock &) = delete;
                Clock(Clock &&) = delete;
                Clock &operator=(Clock &&) = delete;
 
                // ---- Identity / self-description ----
 
                ClockDomain domain() const { return _domain; }
 
                ClockPauseMode pauseMode() const { return _pauseMode; }
 
                bool canPause() const { return _pauseMode != ClockPauseMode::CannotPause; }
 
                virtual int64_t resolutionNs() const = 0;
 
                virtual ClockJitter jitter() const = 0;
 
                virtual double rateRatio() const { return 1.0; }
 
                // ---- Managed readings ----
 
                Result<MediaTimeStamp> now() const;
 
                Result<int64_t> nowNs() const;
 
                // ---- Offsets ----
 
                Duration fixedOffset() const;
 
                void setFixedOffset(const Duration &offset);
 
                // ---- Pause ----
 
                bool isPaused() const;
 
                Error setPause(bool paused);
 
                // ---- Wait primitives ----
 
                Error sleepUntil(const MediaTimeStamp &deadline) const;
 
                // Native shared-pointer plumbing.  Clock is not copyable;
                // _promeki_clone asserts if the SharedPtr ever tries to
                // detach, which should be impossible for CopyOnWrite=false.
                RefCount _promeki_refct;
 
                virtual Clock *_promeki_clone() const {
                        assert(false && "Clock is not copyable");
                        return nullptr;
                }
 
        protected:
                virtual Result<int64_t> raw() const = 0;
 
                virtual Error sleepUntilNs(int64_t targetNs) const = 0;
 
                virtual Error onPause(bool paused);
 
        private:
                Result<int64_t> applyFilter(int64_t raw) const;
 
                ClockDomain       _domain;
                ClockPauseMode    _pauseMode;
                ClockFilter::UPtr _filter;
 
                mutable Mutex _mutex;
                int64_t       _fixedOffsetNs;
                int64_t       _pausedOffsetNs;
                int64_t       _frozenFilteredNs;
                bool          _paused;
 
                mutable Atomic<int64_t> _lastNowNs;
};
 
class WallClock : public Clock {
        public:
                WallClock();
 
                int64_t     resolutionNs() const override;
                ClockJitter jitter() const override;
 
        protected:
                Result<int64_t> raw() const override;
                Error           sleepUntilNs(int64_t targetNs) const override;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE