diff options
Diffstat (limited to 'include/raul')
-rw-r--r-- | include/raul/TimeSlice.hpp | 167 | ||||
-rw-r--r-- | include/raul/TimeStamp.hpp | 254 |
2 files changed, 0 insertions, 421 deletions
diff --git a/include/raul/TimeSlice.hpp b/include/raul/TimeSlice.hpp deleted file mode 100644 index 3efa180..0000000 --- a/include/raul/TimeSlice.hpp +++ /dev/null @@ -1,167 +0,0 @@ -/* - Copyright 2007-2012 David Robillard <d@drobilla.net> - - Raul is free software: you can redistribute it and/or modify it under the - terms of the GNU General Public License as published by the Free Software - Foundation, either version 3 of the License, or any later version. - - Raul 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 General Public License for more details. - - You should have received a copy of the GNU General Public License - along with Raul. If not, see <http://www.gnu.org/licenses/>. -*/ - -#ifndef RAUL_TIMESLICE_HPP -#define RAUL_TIMESLICE_HPP - -#include "raul/Noncopyable.hpp" -#include "raul/TimeStamp.hpp" - -#include <cassert> -#include <cstdint> - -namespace Raul { - -/* FIXME: all the conversion here is wrong now */ - -/** A duration of time, with conversion between tick time and beat time. - * - * This is a slice along a single timeline (ie t=0 in ticks and t=0 in beats - * are equal). Relation to an external time base (e.g. Jack frame time) is - * represented by frame_offset (the idea is that this holds all the information - * necessary for passing to run() methods so they know the current state of - * things WRT time). - * - * This class handles conversion between two units of time: musical - * (beat) time, and real (tick) time. Real time is discrete, the smallest - * unit of time is the 'tick' (usually audio frames or MIDI ticks). Beat time - * is stored as a double (to be independent of any rates or timer precision). - * - * This caches as many values as possible to make calls less expensive, pass it - * around by reference, not value. - * - * \ingroup raul - */ -class TimeSlice : public Noncopyable -{ -public: - TimeSlice(uint32_t rate, uint32_t ppqn, double bpm) - : _tick_rate(rate) - , _beat_rate(60.0 / bpm) - , _start_ticks(Raul::TimeUnit(Raul::TimeUnit::FRAMES, rate), 0, 0) - , _length_ticks(TimeUnit(TimeUnit::FRAMES, rate), 0, 0) - , _start_beats(TimeUnit(TimeUnit::BEATS, ppqn), 0, 0) - , _length_beats(TimeUnit(TimeUnit::BEATS, ppqn), 0, 0) - , _offset_ticks(TimeUnit(TimeUnit::FRAMES, rate), 0, 0) - {} - - /** Set the start and length of the slice. - * - * Note that external offset is not affected by this, don't forget to reset - * the offset each cycle! - */ - void set_slice(TimeStamp start, TimeDuration length) - { - assert(start.unit() == ticks_unit()); - assert(length.unit() == ticks_unit()); - _start_ticks = start; - _length_ticks = length; - update_beat_time(); - } - - void set_length(TimeDuration length) - { - assert(length.unit() == ticks_unit()); - _length_ticks = length; - _length_beats = ticks_to_beats(_length_ticks); - } - - bool contains(TimeStamp time) const - { - return (time >= start_ticks() && time < start_ticks() + length_ticks()); - } - - double tick_rate() const { return _tick_rate; } - double beat_rate() const { return _beat_rate; } - double bpm() const { return 60 / _beat_rate; } - - void set_tick_rate(double tick_rate) - { - _tick_rate = tick_rate; - update_beat_time(); - } - - void set_bpm(double bpm) - { - _beat_rate = 60.0 / bpm; - update_beat_time(); - } - - inline TimeStamp beats_to_seconds(TimeStamp beats) const - { - return {real_unit(), beats.to_double() * 1 / _beat_rate}; - } - - inline TimeStamp beats_to_ticks(TimeStamp beats) const - { - return {ticks_unit(), beats.to_double() * _beat_rate * _tick_rate}; - } - - inline TimeStamp ticks_to_seconds(TimeStamp ticks) const - { - return {real_unit(), ticks.ticks() * 1 / _tick_rate}; - } - - inline TimeStamp ticks_to_beats(TimeStamp ticks) const - { - return {beats_unit(), ticks.ticks() * 1 / _tick_rate * _beat_rate}; - } - - /** Start of current sub-cycle in ticks */ - inline TimeStamp start_ticks() const { return _start_ticks; } - - /** Length of current sub-cycle in ticks */ - inline TimeDuration length_ticks() const { return _length_ticks; } - - /** Start of current sub-cycle in beats */ - inline TimeStamp start_beats() const { return _start_beats; } - - /** Length of current sub-cycle in beats */ - inline TimeDuration length_beats() const { return _length_beats; } - - /** Set the offset between real-time and timeslice-time. */ - inline void set_offset(TimeDuration offset) { _offset_ticks = offset; } - - /** Offset relative to external (e.g Jack) time */ - inline TimeDuration offset_ticks() const { return _offset_ticks; } - - inline TimeUnit beats_unit() const { return _start_beats.unit(); } - inline TimeUnit ticks_unit() const { return _start_ticks.unit(); } - - static inline TimeUnit real_unit() { return {TimeUnit::SECONDS, 0}; } - -private: - inline void update_beat_time() - { - _start_beats = ticks_to_beats(_start_ticks); - _length_beats = ticks_to_beats(_length_ticks); - } - - // Rate/Tempo - double _tick_rate; ///< Tick rate in Hz (e.g. sample rate) - double _beat_rate; ///< Beat rate in Hz - - // Current time - TimeStamp _start_ticks; ///< Current window start in ticks - TimeDuration _length_ticks; ///< Current window length in ticks - TimeStamp _start_beats; ///< Current window start in beats - TimeDuration _length_beats; ///< Current window length in beats - - TimeDuration _offset_ticks; ///< Offset to global time -}; - -} // namespace Raul - -#endif // RAUL_TIMESLICE_HPP diff --git a/include/raul/TimeStamp.hpp b/include/raul/TimeStamp.hpp deleted file mode 100644 index 0385ef3..0000000 --- a/include/raul/TimeStamp.hpp +++ /dev/null @@ -1,254 +0,0 @@ -/* - Copyright 2007-2014 David Robillard <d@drobilla.net> - - Raul is free software: you can redistribute it and/or modify it under the - terms of the GNU General Public License as published by the Free Software - Foundation, either version 3 of the License, or any later version. - - Raul 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 General Public License for more details. - - You should have received a copy of the GNU General Public License - along with Raul. If not, see <http://www.gnu.org/licenses/>. -*/ - -#ifndef RAUL_TIMESTAMP_HPP -#define RAUL_TIMESTAMP_HPP - -#include <algorithm> -#include <cassert> -#include <cmath> -#include <cstdint> -#include <iostream> -#include <limits> - -namespace Raul { - -/** A type of time stamp - * \ingroup raul - */ -class TimeUnit -{ -public: - enum Type { FRAMES, BEATS, SECONDS }; - - /** `ppt` (parts per tick) is the sample rate for FRAMES, PPQN for BEATS, - * and ignored for SECONDS. - */ - inline TimeUnit(Type type, uint32_t ppt) - : _type(type) - , _ppt(ppt) - { - assert(type == SECONDS || ppt != 0); - _type = type; - _ppt = ppt; - } - - static inline TimeUnit frames(uint32_t srate) { return {FRAMES, srate}; } - static inline TimeUnit beats(uint32_t ppqn) { return {BEATS, ppqn}; } - static inline TimeUnit seconds() - { - return {BEATS, std::numeric_limits<uint32_t>::max()}; - } - - inline Type type() const { return _type; } - inline uint32_t ppt() const { return _ppt; } - - inline bool operator==(const TimeUnit& rhs) const - { - return (_type == rhs._type && _ppt == rhs._ppt); - } - - inline bool operator!=(const TimeUnit& rhs) const - { - return (_type != rhs._type || _ppt != rhs._ppt); - } - -private: - Type _type; - uint32_t _ppt; -}; - -/** A real-time time stamp (possible units: frame, absolute (s), or beat). - * - * This is a uint32_t:uint32_t fixed point representation, capable of - * sub-sample accurate frame time, beat time (at any remotely sane - * tempo and sample rate), and absolute time. The absolute time (seconds) - * is compatible with standard OSC/NTP time stamps. - * - * \ingroup raul - */ -class TimeStamp -{ -public: - explicit TimeStamp(TimeUnit unit, uint32_t ticks = 0, uint32_t subticks = 0) - : _ticks(ticks) - , _subticks(subticks) - , _unit(unit) - {} - - inline TimeStamp(TimeUnit unit, double dec) - : _ticks(0u) - , _subticks(0u) - , _unit(unit) - { - dec = std::max(0.0, dec); - dec = std::min(double(std::numeric_limits<uint32_t>::max()), dec); - double integral = 0.0; - const double fractional = modf(dec, &integral); - _ticks = static_cast<uint32_t>(integral); - _subticks = static_cast<uint32_t>(fractional * unit.ppt()); - } - - TimeStamp(const TimeStamp&) = default; - TimeStamp& operator=(const TimeStamp&) = default; - - TimeStamp(TimeStamp&&) = default; - TimeStamp& operator=(TimeStamp&&) = default; - - ~TimeStamp() = default; - - inline TimeUnit unit() const { return _unit; } - inline uint32_t ticks() const { return _ticks; } - inline uint32_t subticks() const { return _subticks; } - - inline double to_double() const - { - return _ticks + (_subticks / static_cast<double>(_unit.ppt())); - } - - inline bool is_zero() const { return _ticks == 0 && _subticks == 0; } - - inline TimeStamp& operator=(uint32_t ticks) - { - _ticks = ticks; - _subticks = 0; - return *this; - } - - inline bool operator==(const TimeStamp& rhs) const - { - return _ticks == rhs._ticks && _subticks == rhs._subticks && - _unit == rhs._unit; - } - - inline bool operator!=(const TimeStamp& rhs) const - { - return !operator==(rhs); - } - - inline bool operator<(const TimeStamp& rhs) const - { - assert(_unit == rhs._unit); - return (_ticks < rhs._ticks || - (_ticks == rhs._ticks && _subticks < rhs._subticks)); - } - - inline bool operator>(const TimeStamp& rhs) const - { - assert(_unit == rhs._unit); - return (_ticks > rhs._ticks || - (_ticks == rhs._ticks && _subticks > rhs._subticks)); - } - - inline bool operator<=(const TimeStamp& rhs) const - { - return (*this == rhs) || ((*this) < rhs); - } - - inline bool operator>=(const TimeStamp& rhs) const - { - return (*this == rhs) || ((*this) > rhs); - } - - inline TimeStamp& operator+=(const TimeStamp& rhs) - { - assert(_unit == rhs._unit); - _ticks += rhs._ticks; - if (_subticks + rhs._subticks <= _unit.ppt()) { - _subticks += rhs._subticks; - } else if (rhs._subticks > 0) { - ++_ticks; - _subticks = rhs._subticks + _subticks - _unit.ppt(); - } - return *this; - } - - inline TimeStamp& operator-=(const TimeStamp& rhs) - { - assert(_unit == rhs._unit); - assert(rhs <= *this); - _ticks -= rhs._ticks; - if (_subticks >= rhs._subticks) { - _subticks -= rhs._subticks; - } else if (rhs._subticks > 0) { - --_ticks; - _subticks = _unit.ppt() - (rhs._subticks - _subticks); - } - return *this; - } - - inline TimeStamp operator+(const TimeStamp& rhs) const - { - assert(_unit == rhs._unit); - TimeStamp result = *this; - result += rhs; - return result; - } - - inline TimeStamp operator-(const TimeStamp& rhs) const - { - assert(_unit == rhs._unit); - TimeStamp result = *this; - result -= rhs; - return result; - } - -private: - uint32_t _ticks; - uint32_t _subticks; - TimeUnit _unit; -}; - -inline std::ostream& -operator<<(std::ostream& os, const TimeStamp& t) -{ - os << t.ticks() << ":" << t.subticks(); - switch (t.unit().type()) { - case TimeUnit::FRAMES: - os << " frames"; - break; - case TimeUnit::BEATS: - os << " beats"; - break; - case TimeUnit::SECONDS: - os << " seconds"; - break; - } - return os; -} - -class FrameStamp : public TimeStamp -{ -public: - explicit FrameStamp(uint32_t rate, uint32_t ticks = 0, uint32_t subticks = 0) - : TimeStamp(TimeUnit(TimeUnit::FRAMES, rate), ticks, subticks) - {} -}; - -class BeatStamp : public TimeStamp -{ -public: - explicit BeatStamp(uint32_t ppqn, uint32_t ticks = 0, uint32_t subticks = 0) - : TimeStamp(TimeUnit(TimeUnit::BEATS, ppqn), ticks, subticks) - {} -}; - -/** Same thing as TimeStamp really, but makes code clearer and enforces - * correct semantics via type safety */ -using TimeDuration = TimeStamp; - -} // namespace Raul - -#endif // RAUL_TIMESTAMP_HPP |