1 files changed, 295 insertions, 0 deletions
diff --git a/src/lib/dcpomatic_time.h b/src/lib/dcpomatic_time.h
new file mode 100644
index 000000000..4afc9ab40
--- /dev/null
+++ b/src/lib/dcpomatic_time.h
@@ -0,0 +1,295 @@
+/*
+    Copyright (C) 2014 Carl Hetherington <cth@carlh.net>
+
+    This program 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,
+    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.
+
+*/
+
+#ifndef DCPOMATIC_TIME_H
+#define DCPOMATIC_TIME_H
+
+#include <cmath>
+#include <ostream>
+#include <sstream>
+#include <iomanip>
+#include <stdint.h>
+#include "frame_rate_change.h"
+
+class dcpomatic_round_up_test;
+
+class Time;
+
+/** A time in seconds, expressed as a number scaled up by Time::HZ. */
+class Time
+{
+public:
+	Time ()
+		: _t (0)
+	{}
+
+	explicit Time (int64_t t)
+		: _t (t)
+	{}
+
+	virtual ~Time () {}
+
+	int64_t get () const {
+		return _t;
+	}
+
+	double seconds () const {
+		return double (_t) / HZ;
+	}
+
+	template <typename T>
+	int64_t frames (T r) const {
+		return rint (_t * r / HZ);
+	}
+
+	template <typename T>
+	void split (T r, int& h, int& m, int& s, int& f) 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<int> (ff);
+	}
+
+	template <typename T>
+	std::string timecode (T r) const {
+		int h;
+		int m;
+		int s;
+		int f;
+		split (r, h, m, s, f);
+
+		std::ostringstream 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 ();
+	}
+
+protected:
+	friend class dcptime_round_up_test;
+	
+	int64_t _t;
+	static const int HZ = 96000;
+};
+
+class DCPTime;
+
+class ContentTime : public Time
+{
+public:
+	ContentTime () : Time () {}
+	explicit ContentTime (int64_t t) : Time (t) {}
+	ContentTime (int64_t n, int64_t d) : Time (n * HZ / d) {}
+	ContentTime (DCPTime d, FrameRateChange f);
+
+	bool operator< (ContentTime const & o) const {
+		return _t < o._t;
+	}
+
+	bool operator<= (ContentTime const & o) const {
+		return _t <= o._t;
+	}
+
+	bool operator== (ContentTime const & o) const {
+		return _t == o._t;
+	}
+
+	bool operator!= (ContentTime const & o) const {
+		return _t != o._t;
+	}
+
+	bool operator>= (ContentTime const & o) const {
+		return _t >= o._t;
+	}
+
+	bool operator> (ContentTime const & o) const {
+		return _t > o._t;
+	}
+
+	ContentTime operator+ (ContentTime const & o) const {
+		return ContentTime (_t + o._t);
+	}
+
+	ContentTime & operator+= (ContentTime const & o) {
+		_t += o._t;
+		return *this;
+	}
+
+	ContentTime operator- () const {
+		return ContentTime (-_t);
+	}
+
+	ContentTime operator- (ContentTime const & o) const {
+		return ContentTime (_t - o._t);
+	}
+
+	ContentTime & operator-= (ContentTime const & o) {
+		_t -= o._t;
+		return *this;
+	}
+
+	/** Round up to the nearest sampling interval
+	 *  at some sampling rate.
+	 *  @param r Sampling rate.
+	 */
+	ContentTime round_up (float r) {
+		int64_t const n = rint (HZ / r);
+		int64_t const a = _t + n - 1;
+		return ContentTime (a - (a % n));
+	}
+
+	static ContentTime from_seconds (double s) {
+		return ContentTime (s * HZ);
+	}
+
+	template <class T>
+	static ContentTime from_frames (int64_t f, T r) {
+		assert (r > 0);
+		return ContentTime (f * HZ / r);
+	}
+
+	static ContentTime max () {
+		return ContentTime (INT64_MAX);
+	}
+};
+
+std::ostream& operator<< (std::ostream& s, ContentTime t);
+
+class ContentTimePeriod
+{
+public:
+	ContentTimePeriod () {}
+	ContentTimePeriod (ContentTime f, ContentTime t)
+		: from (f)
+		, to (t)
+	{}
+
+	ContentTime from;
+	ContentTime to;
+
+	ContentTimePeriod operator+ (ContentTime const & o) const {
+		return ContentTimePeriod (from + o, to + o);
+	}
+
+	bool overlaps (ContentTimePeriod const & o) const;
+};
+
+class DCPTime : public Time
+{
+public:
+	DCPTime () : Time () {}
+	explicit DCPTime (int64_t t) : Time (t) {}
+	DCPTime (ContentTime t, FrameRateChange c) : Time (rint (t.get() / c.speed_up)) {}
+
+	bool operator< (DCPTime const & o) const {
+		return _t < o._t;
+	}
+
+	bool operator<= (DCPTime const & o) const {
+		return _t <= o._t;
+	}
+
+	bool operator== (DCPTime const & o) const {
+		return _t == o._t;
+	}
+
+	bool operator!= (DCPTime const & o) const {
+		return _t != o._t;
+	}
+
+	bool operator>= (DCPTime const & o) const {
+		return _t >= o._t;
+	}
+
+	bool operator> (DCPTime const & o) const {
+		return _t > o._t;
+	}
+
+	DCPTime operator+ (DCPTime const & o) const {
+		return DCPTime (_t + o._t);
+	}
+
+	DCPTime & operator+= (DCPTime const & o) {
+		_t += o._t;
+		return *this;
+	}
+
+	DCPTime operator- () const {
+		return DCPTime (-_t);
+	}
+
+	DCPTime operator- (DCPTime const & o) const {
+		return DCPTime (_t - o._t);
+	}
+
+	DCPTime & operator-= (DCPTime const & o) {
+		_t -= o._t;
+		return *this;
+	}
+
+	/** Round up to the nearest sampling interval
+	 *  at some sampling rate.
+	 *  @param r Sampling rate.
+	 */
+	DCPTime round_up (float r) {
+		int64_t const n = rint (HZ / r);
+		int64_t const a = _t + n - 1;
+		return DCPTime (a - (a % n));
+	}
+
+	DCPTime abs () const {
+		return DCPTime (std::abs (_t));
+	}
+
+	static DCPTime from_seconds (double s) {
+		return DCPTime (s * HZ);
+	}
+
+	template <class T>
+	static DCPTime from_frames (int64_t f, T r) {
+		assert (r > 0);
+		return DCPTime (f * HZ / r);
+	}
+
+	static DCPTime delta () {
+		return DCPTime (1);
+	}
+
+	static DCPTime max () {
+		return DCPTime (INT64_MAX);
+	}
+};
+
+DCPTime min (DCPTime a, DCPTime b);
+std::ostream& operator<< (std::ostream& s, DCPTime t);
+
+#endif