X-Git-Url: https://main.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Fdcpomatic_time.h;h=62d8a28ccf1ddee397e85ed014e77beb929fae92;hp=90e79de0a7b4cec45cee0a495d63554f2a6fa2c6;hb=a5d004b0773f633401528392fc28e66d70e13ac8;hpb=6f23b55a7783f93549115a133ca2e6e938bd0cd1 diff --git a/src/lib/dcpomatic_time.h b/src/lib/dcpomatic_time.h index 90e79de0a..62d8a28cc 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,21 @@ #define DCPOMATIC_TIME_H #include "frame_rate_change.h" -#include "safe_stringstream.h" #include "dcpomatic_assert.h" +#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 +117,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,20 +147,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); } template int64_t frames_ceil (T r) const { - return ceil (_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 ceil(). + */ + return ::ceil (_t * double(r) / HZ); } - /** @param r Frames per second */ + /** 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 { @@ -172,14 +201,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; } @@ -205,11 +229,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 {}; @@ -239,7 +265,9 @@ public: , to (t) {} + /** 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 { @@ -250,19 +278,78 @@ public: return TimePeriod (from + o, to + o); } - bool overlaps (TimePeriod const & other) const { - return (from < other.to && to > other.from); + 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); + + for (auto i: B) { + std::list > new_result; + for (auto 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; @@ -270,8 +357,10 @@ 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::ostream& operator<< (std::ostream& s, DCPTimePeriod p); +std::string to_string (ContentTime t); +std::string to_string (DCPTime t); +std::string to_string (DCPTimePeriod p); + +} #endif