server/supernova/utilities/time_tag.hpp

   1 //  server scheduler
   2 //  Copyright (C) 2008 Tim Blechmann
   3 //
   4 //  This program is free software; you can redistribute it and/or modify
   5 //  it under the terms of the GNU General Public License as published by
   6 //  the Free Software Foundation; either version 2 of the License, or
   7 //  (at your option) any later version.
   8 //
   9 //  This program is distributed in the hope that it will be useful,
  10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 //  GNU General Public License for more details.
  13 //
  14 //  You should have received a copy of the GNU General Public License
  15 //  along with this program; see the file COPYING.  If not, write to
  16 //  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17 //  Boston, MA 02111-1307, USA.
  18
  19 #ifndef UTILITIES_TIME_TAG_HPP
  20 #define UTILITIES_TIME_TAG_HPP
  21
  22 #include <cstdint>
  23 #include <cmath>
  24
  25 #include "boost/date_time/posix_time/posix_time_types.hpp"
  26 #include "boost/date_time/gregorian/gregorian_types.hpp"
  27
  28 namespace nova {
  29
  30 /** time_tag class, compatible to osc time tags */
  31 class time_tag
  32 {
  33     typedef std::uint32_t uint32;
  34     typedef std::uint64_t uint64;
  35
  36     typedef union
  37     {
  38         uint64 packed;
  39         uint32 unpacked[2];
  40     } cast_union;
  41
  42     static const uint32 ntp_offset = 2208988800UL; /* seconds between 01-01-1900 and 01-01-1970 */
  43
  44 public:
  45     static const uint64 fraction_steps = uint64(1)<<32;
  46
  47     time_tag(void):
  48         data_(0)
  49     {}
  50
  51     time_tag(time_tag const & rhs):
  52         data_(rhs.data_)
  53     {}
  54
  55     time_tag(uint64 timetag):
  56         data_(timetag)
  57     {}
  58
  59     time_tag(uint32 secs, uint32 fraction)
  60     {
  61         cast_union cu;
  62         cu.unpacked[1] = secs;
  63         cu.unpacked[0] = fraction;
  64
  65         data_ = cu.packed;
  66     }
  67
  68     uint32 get_secs(void) const
  69     {
  70         return reinterpret_cast<const cast_union*>(&data_)->unpacked[1];
  71     }
  72
  73     uint32 get_fraction(void) const
  74     {
  75         return reinterpret_cast<const cast_union*>(&data_)->unpacked[0];
  76     }
  77
  78     double get_nanoseconds(void) const
  79     {
  80         return get_fractional_seconds() * 1e9;
  81     }
  82
  83     double get_fractional_seconds(void) const
  84     {
  85         return get_fraction() / double(fraction_steps);
  86     }
  87
  88     bool operator<(time_tag const & rhs) const
  89     {
  90         return data_ < rhs.data_;
  91     }
  92
  93     bool operator<=(time_tag const & rhs) const
  94     {
  95         return data_ <= rhs.data_;
  96     }
  97
  98     bool operator==(time_tag const & rhs) const
  99     {
 100         return data_ == rhs.data_;
 101     }
 102
 103     bool operator!=(time_tag const & rhs) const
 104     {
 105         return !operator==(rhs);
 106     }
 107
 108     time_tag & operator+=(time_tag const & rhs)
 109     {
 110         data_ += rhs.data_;
 111         return *this;
 112     }
 113
 114     time_tag operator+(time_tag const & rhs) const
 115     {
 116         time_tag ret (*this);
 117         ret += rhs;
 118         return ret;
 119     }
 120
 121     time_tag & operator-=(time_tag const & rhs)
 122     {
 123         data_ -= rhs.data_;
 124         return *this;
 125     }
 126
 127     time_tag operator-(time_tag const & rhs) const
 128     {
 129         time_tag ret (*this);
 130         ret -= rhs;
 131         return ret;
 132     }
 133
 134     template <typename float_t>
 135     static time_tag from_ns(float_t ns)
 136     {
 137         const float_t units_per_ns = float_t(fraction_steps) / 1e9;
 138
 139         if (ns < 1e9)
 140             return time_tag(0, ns * units_per_ns);
 141         else
 142         {
 143             float_t secs = std::floor(ns / 1e9);
 144             ns = std::fmod(ns, 1e9);
 145             return time_tag(secs, ns * units_per_ns);
 146         }
 147     }
 148
 149     static time_tag from_samples_small(unsigned int sample_count, float samplerate)
 150     {
 151         assert(sample_count < samplerate);
 152
 153         const float units_per_sample = float(fraction_steps) / samplerate;
 154         return time_tag(0, sample_count * units_per_sample);
 155     }
 156
 157     static time_tag from_samples(unsigned int sample_count, float samplerate)
 158     {
 159         const float_t units_per_sample = float_t(fraction_steps) / samplerate;
 160
 161         if (sample_count < samplerate)
 162             return from_samples_small(sample_count, samplerate);
 163         else
 164         {
 165             float_t secs = std::floor(sample_count / samplerate);
 166             float_t samples = std::fmod(sample_count, samplerate);
 167             return time_tag(secs, samples * units_per_sample);
 168         }
 169     }
 170
 171     float to_samples(float samplerate)
 172     {
 173         float seconds = get_fractional_seconds();
 174         uint32_t secs = get_secs();
 175
 176         if (secs == 0)
 177             seconds += (float)secs;
 178         return seconds * samplerate;
 179     }
 180
 181     static time_tag from_ptime(boost::posix_time::ptime const & pt)
 182     {
 183         using namespace boost::gregorian;
 184         using namespace boost::posix_time;
 185
 186         const date base(1970, Jan, 1);
 187
 188         time_duration diff = pt - ptime(base);
 189
 190         uint32 secs = diff.total_seconds() + ntp_offset;
 191
 192         double fraction = double(diff.fractional_seconds());
 193
 194         if (diff.resolution() == boost::date_time::nano)
 195             fraction /= 1000000000;
 196         else if (diff.resolution() == boost::date_time::micro)
 197             fraction /= 1000000;
 198         else if (diff.resolution() == boost::date_time::milli)
 199             fraction /= 1000;
 200         else
 201             assert(false);
 202
 203         assert (fraction < 1.0 && fraction >= 0);
 204
 205         uint32 fraction_units = std::floor(fraction * double(std::numeric_limits<uint32>::max()));
 206         return time_tag(secs, fraction_units);
 207     }
 208
 209     boost::posix_time::ptime to_ptime(void) const
 210     {
 211         using namespace boost::gregorian;
 212         using namespace boost::posix_time;
 213
 214         const date base(1970, Jan, 1);
 215 #ifdef BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
 216         time_duration offset = seconds(get_secs() - ntp_offset) + nanoseconds(get_nanoseconds());
 217 #else
 218         time_duration offset = seconds(get_secs() - ntp_offset) + microseconds(get_nanoseconds()/1000);
 219 #endif
 220         return ptime(base, offset);
 221     }
 222
 223 private:
 224     uint64 data_;
 225 };
 226
 227 } /* namespace nova */
 228
 229 #endif /* UTILITIES_TIME_TAG_HPP */