Use FAB subtitler's rather odd DFC -> frame rate mapping.

[libsub.git] / src / metric_time.cc

diff --git a/src/metric_time.cc b/src/metric_time.cc
index 3fc78741723f970e74d62a99e1e29a83a130ce08..4fad39047870633e82170a341f411a96f1b5181d 100644 (file)
--- a/src/metric_time.cc
+++ b/src/metric_time.cc
@@ -20,46 +20,101 @@
 #include "metric_time.h"
 #include "compose.hpp"
 #include <iostream>
+#include <cmath>
 
 using std::ostream;
 using std::string;
+using std::cout;
 using namespace sub;
 
 MetricTime::MetricTime (int h, int m, int s, int ms)
-       : _milliseconds ((h * 3600 + m * 60 + s) * 1000 + ms)
+        /* cast up to int64_t to force a 64-bit calculation */
+       : _ms ((int64_t (h) * 3600 + m * 60 + s) * 1000 + ms)
 {
 
 }
 
+void
+MetricTime::split (int& h, int &m, int& s, int& ms) const
+{
+       int64_t w = _ms;
+       h = floor (w / (3600 * 1000));
+       /* this multiply could overflow 32 bits so cast to make sure it is done as 64-bit */
+       w -= int64_t (h) * (3600 * 1000);
+       m = floor (w / (60 * 1000));
+       w -= m * (60 * 1000);
+       s = floor (w / 1000);
+       w -= s * 1000;
+       ms = w;
+}
+
+int
+MetricTime::hours () const
+{
+       int h, m, s, ms;
+       split (h, m, s, ms);
+       return h;
+}
+
+int
+MetricTime::minutes () const
+{
+       int h, m, s, ms;
+       split (h, m, s, ms);
+       return m;
+}
+
+int
+MetricTime::seconds () const
+{
+       int h, m, s, ms;
+       split (h, m, s, ms);
+       return s;
+}
+
+int
+MetricTime::milliseconds () const
+{
+       int h, m, s, ms;
+       split (h, m, s, ms);
+       return ms;
+}
+
+void
+MetricTime::add (MetricTime t)
+{
+       _ms += t._ms;
+}
+
+void
+MetricTime::scale (float f)
+{
+       _ms *= f;
+}
+
 bool
 sub::operator== (MetricTime const & a, MetricTime const & b)
 {
-       return a._milliseconds == b._milliseconds;
+       return a._ms == b._ms;
 }
 
 bool
 sub::operator> (MetricTime const & a, MetricTime const & b)
 {
-       return a._milliseconds > b._milliseconds;
+       return a._ms > b._ms;
 }
 
 bool
 sub::operator< (MetricTime const & a, MetricTime const & b)
 {
-       return a._milliseconds < b._milliseconds;
+       return a._ms < b._ms;
 }
 
 ostream&
 sub::operator<< (ostream& st, MetricTime const & t)
 {
-       int64_t ms = t._milliseconds;
-       int const h = ms / (3600 * 1000);
-       ms -= h * 3600 * 1000;
-       int const m = ms / (60 * 1000);
-       ms -= m * 60 * 1000;
-       int const s = ms / 1000;
-       ms -= s * 1000;
-
+       int h, m, s, ms;
+       t.split (h, m, s, ms);
        st << h << ":" << m << ":" << s << ":" << ms;
        return st;
 }