X-Git-Url: https://main.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Fdcpomatic_time.h;h=897b725bd3e63587ba9390f194234847e01aedd1;hp=7d755a46cf1a7e53a826f3f7ddd1f596b35ccc81;hb=8f12e84009d7c2685bb2eeb32665876463d4e6e5;hpb=267e21bfb78593bcb87eb24ce01b88d0859566f7 diff --git a/src/lib/dcpomatic_time.h b/src/lib/dcpomatic_time.h index 7d755a46c..897b725bd 100644 --- a/src/lib/dcpomatic_time.h +++ b/src/lib/dcpomatic_time.h @@ -1,19 +1,20 @@ /* - Copyright (C) 2014-2015 Carl Hetherington + Copyright (C) 2014-2018 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 . */ @@ -25,17 +26,22 @@ #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; -class dcpomatic_round_up_test; +namespace dcpomatic { /** 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. * @@ -112,14 +118,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) const { - Type const n = llrintf (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 { @@ -132,15 +148,34 @@ public: template int64_t frames_round (T r) const { - return llrint (_t * r / HZ); + /* 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); } template int64_t frames_floor (T r) const { - return floor (_t * r / HZ); + return ::floor (_t * r / HZ); } - /** @param r Frames per second */ + 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. + * @param h Returned hours. + * @param m Returned minutes. + * @param s Returned seconds. + * @param f Returned frames. + */ template void split (T r, int& h, int& m, int& s, int& f) const { @@ -167,14 +202,9 @@ public: int f; split (r, h, m, s, f); - 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", h, m, s, f); + return buffer; } @@ -200,11 +230,13 @@ 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 {}; @@ -223,36 +255,113 @@ 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; - ContentTimePeriod operator+ (ContentTime const & o) const { - return ContentTimePeriod (from + o, to + o); + T duration () const { + return to - from; } - bool overlaps (ContentTimePeriod const & o) const; - bool contains (ContentTime const & o) const; + TimePeriod operator+ (T const & o) const { + return TimePeriod (from + o, to + o); + } - bool operator== (ContentTimePeriod const & o) const { - return from == o.from && to == o.to; + 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 boost::optional > (); + } + + return TimePeriod (max_from, min_to); + } + + bool contains (T const & other) const { + return (from <= other && other < to); + } + + bool operator< (TimePeriod const & o) const { + if (from != o.from) { + return from < o.from; + } + return to < o.to; + } + + 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); + + BOOST_FOREACH (TimePeriod i, B) { + std::list > new_result; + BOOST_FOREACH (TimePeriod j, result) { + boost::optional > 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