X-Git-Url: https://main.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Fdcpomatic_time.h;h=a09dd93e9c179f515b08bfd093f8aaada36f2937;hp=494aebba73c32583d902608a55d5184a9523af1c;hb=HEAD;hpb=6300edd66433dffed9fb30a0b3b8db7ca3355809 diff --git a/src/lib/dcpomatic_time.h b/src/lib/dcpomatic_time.h index 494aebba7..1b12ea901 100644 --- a/src/lib/dcpomatic_time.h +++ b/src/lib/dcpomatic_time.h @@ -1,42 +1,71 @@ /* - Copyright (C) 2014-2015 Carl Hetherington + Copyright (C) 2014-2021 Carl Hetherington - This program is free software; you can redistribute it and/or modify + This file is part of DCP-o-matic. + + DCP-o-matic 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 2 of the License, or (at your option) any later version. - This program is distributed in the hope that it will be useful, + DCP-o-matic 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 this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + along with DCP-o-matic. If not, see . */ + /** @file src/lib/dcpomatic_time.h * @brief Types to describe time. */ + #ifndef DCPOMATIC_TIME_H #define DCPOMATIC_TIME_H + #include "frame_rate_change.h" -#include "safe_stringstream.h" #include "dcpomatic_assert.h" +#include #include #include #include -#include #include +#include + + +struct dcpomatic_time_ceil_test; +struct dcpomatic_time_floor_test; + + +namespace dcpomatic { + + +class HMSF +{ +public: + HMSF () {} + + HMSF (int h_, int m_, int s_, int f_) + : h(h_) + , m(m_) + , s(s_) + , f(f_) + {} + + int h = 0; + int m = 0; + int s = 0; + int f = 0; +}; -class dcpomatic_round_up_test; /** A time in seconds, expressed as a number scaled up by Time::HZ. We want two different - * versions of this class, ContentTime and DCPTime, and we want it to be impossible to + * versions of this class, dcpomatic::ContentTime and dcpomatic::DCPTime, and we want it to be impossible to * convert implicitly between the two. Hence there's this template hack. I'm not * sure if it's the best way to do it. * @@ -63,6 +92,16 @@ public: /* Explicit conversion from type O */ Time (Time d, FrameRateChange f); + /** @param hmsf Hours, minutes, seconds, frames. + * @param fps Frame rate + */ + Time (HMSF const& hmsf, float fps) { + *this = from_seconds (hmsf.h * 3600) + + from_seconds (hmsf.m * 60) + + from_seconds (hmsf.s) + + from_frames (hmsf.f, fps); + } + Type get () const { return _t; } @@ -113,14 +152,24 @@ public: return *this; } + Time operator/ (int o) const { + return Time (_t / o); + } + /** Round up to the nearest sampling interval * at some sampling rate. * @param r Sampling rate. */ - Time round_up (float r) { - Type const n = rint (HZ / r); - Type const a = _t + n - 1; - return Time (a - (a % n)); + Time ceil (double r) const { + return Time (llrint(HZ * frames_ceil(r) / r)); + } + + Time floor (double r) const { + return Time (llrint(HZ * frames_floor(r) / r)); + } + + Time round (double r) const { + return Time (llrint(HZ * frames_round(r) / r)); } double seconds () const { @@ -128,54 +177,67 @@ public: } Time abs () const { - return Time (std::abs (_t)); + return Time (std::abs(_t)); } template - int64_t frames (T r) const { - return floor (_t * r / HZ); + int64_t frames_round (T r) const { + /* We must cast to double here otherwise if T is integer + the calculation will round down before we get the chance + to llrint(). + */ + return llrint (_t * double(r) / HZ); } - /** @param r Frames per second */ template - void split (T r, int& h, int& m, int& s, int& f) const + int64_t frames_floor (T r) const { + return ::floor (_t * r / HZ); + } + + template + int64_t frames_ceil (T r) const { + /* We must cast to double here otherwise if T is integer + the calculation will round down before we get the chance + to ceil(). + */ + return ::ceil (_t * double(r) / HZ); + } + + /** Split a time into hours, minutes, seconds and frames. + * @param r Frames per second. + * @return Split time. + */ + template + HMSF split (T r) const { /* Do this calculation with frames so that we can round to a frame boundary at the start rather than the end. */ - int64_t ff = frames (r); - - h = ff / (3600 * r); - ff -= h * 3600 * r; - m = ff / (60 * r); - ff -= m * 60 * r; - s = ff / r; - ff -= s * r; - - f = static_cast (ff); + auto ff = frames_round (r); + HMSF hmsf; + + hmsf.h = ff / (3600 * r); + ff -= static_cast(hmsf.h) * 3600 * r; + hmsf.m = ff / (60 * r); + ff -= static_cast(hmsf.m) * 60 * r; + hmsf.s = ff / r; + ff -= static_cast(hmsf.s) * r; + + hmsf.f = static_cast (ff); + return hmsf; } template std::string timecode (T r) const { - int h; - int m; - int s; - int f; - split (r, h, m, s, f); + auto hmsf = split (r); - SafeStringStream o; - o.width (2); - o.fill ('0'); - o << std::setw(2) << std::setfill('0') << h << ":" - << std::setw(2) << std::setfill('0') << m << ":" - << std::setw(2) << std::setfill('0') << s << ":" - << std::setw(2) << std::setfill('0') << f; - return o.str (); + char buffer[128]; + snprintf (buffer, sizeof(buffer), "%02d:%02d:%02d:%02d", hmsf.h, hmsf.m, hmsf.s, hmsf.f); + return buffer; } - static Time from_seconds (double s) { - return Time (rint (s * HZ)); + return Time (llrint (s * HZ)); } template @@ -196,16 +258,20 @@ public: return Time (INT64_MAX); } + static const int HZ = 96000; + private: - friend struct dcptime_round_up_test; + friend struct ::dcpomatic_time_ceil_test; + friend struct ::dcpomatic_time_floor_test; Type _t; - static const int HZ = 96000; }; + class ContentTimeDifferentiator {}; class DCPTimeDifferentiator {}; + /* Specializations for the two allowed explicit conversions */ template<> @@ -214,37 +280,124 @@ Time::Time (Time Time::Time (Time d, FrameRateChange f); + /** Time relative to the start or position of a piece of content in its native frame rate */ typedef Time ContentTime; /** Time relative to the start of the output DCP in its frame rate */ typedef Time DCPTime; -class ContentTimePeriod +template +class TimePeriod { public: - ContentTimePeriod () {} + TimePeriod () {} - ContentTimePeriod (ContentTime f, ContentTime t) + TimePeriod (T f, T t) : from (f) , to (t) {} - ContentTime from; - ContentTime to; + /** start time of sampling interval that the period is from */ + T from; + /** start time of next sampling interval after the period */ + T to; + + T duration () const { + return to - from; + } + + TimePeriod operator+ (T const & o) const { + return TimePeriod (from + o, to + o); + } + + boost::optional> overlap (TimePeriod const & other) const { + T const max_from = std::max (from, other.from); + T const min_to = std::min (to, other.to); + + if (max_from >= min_to) { + return {}; + } + + return TimePeriod (max_from, min_to); + } + + bool contains (T const & other) const { + return (from <= other && other < to); + } - ContentTimePeriod operator+ (ContentTime const & o) const { - return ContentTimePeriod (from + o, to + o); + bool operator< (TimePeriod const & o) const { + if (from != o.from) { + return from < o.from; + } + return to < o.to; } - bool overlaps (ContentTimePeriod const & o) const; - bool contains (ContentTime const & o) const; + bool operator== (TimePeriod const & other) const { + return from == other.from && to == other.to; + } + + bool operator!= (TimePeriod const & other) const { + return !(*this == other); + } }; + +/** @param A Period which is subtracted from. + * @param B Periods to subtract from `A', must be in ascending order of start time and must not overlap. + */ +template +std::list> subtract (TimePeriod A, std::list> const & B) +{ + std::list> result; + result.push_back (A); + + for (auto i: B) { + std::list> new_result; + for (auto j: result) { + auto ov = i.overlap (j); + if (ov) { + if (*ov == i) { + /* A contains all of B */ + if (i.from != j.from) { + new_result.push_back (TimePeriod(j.from, i.from)); + } + if (i.to != j.to) { + new_result.push_back (TimePeriod(i.to, j.to)); + } + } else if (*ov == j) { + /* B contains all of A */ + } else if (i.from < j.from) { + /* B overlaps start of A */ + new_result.push_back (TimePeriod(i.to, j.to)); + } else if (i.to > j.to) { + /* B overlaps end of A */ + new_result.push_back (TimePeriod(j.from, i.from)); + } + } else { + new_result.push_back (j); + } + } + result = new_result; + } + + return result; +} + + +typedef TimePeriod ContentTimePeriod; +typedef TimePeriod DCPTimePeriod; + + DCPTime min (DCPTime a, DCPTime b); DCPTime max (DCPTime a, DCPTime b); ContentTime min (ContentTime a, ContentTime b); ContentTime max (ContentTime a, ContentTime b); -std::ostream& operator<< (std::ostream& s, ContentTime t); -std::ostream& operator<< (std::ostream& s, DCPTime t); +std::string to_string (ContentTime t); +std::string to_string (DCPTime t); +std::string to_string (DCPTimePeriod p); + + +} + #endif