plumb uint64_t support all the way through the SDK

- When a uint64_t is serialized, it is bitwise & with INT64_MAX first to
  avoid overflowing the integer.  In order to do that comparison at
  serialization time, the uint64_t needs to be stored as a uint64_t all
  the way through the python bindings into the any mapping.
- the next step is to move the & operation up into the python bindings
  and prevent people from storing invalid numbers in OTIO files.

Author: ssteinbach

src/opentimelineio/deserialization.cpp

@@ -35,15 +35,20 @@ class JSONDecoder : public OTIO_rapidjson::BaseReaderHandler<OTIO_rapidjson::UTF
         }
     }
 
-    bool Null() {  return store(any()); }
+    bool Null() { return store(any()); }
     bool Bool(bool b) { return store(any(b)); }
-
-    // coerce all integer types to int64_t
-    bool Int(int i) {  return store(any(static_cast<int64_t>(i))); }
-    bool Uint(unsigned u) {  return store(any(static_cast<int64_t>(u))); }
+ 
+    // coerce all integer types to int64_t...
+    bool Int(int i) { return store(any(static_cast<int64_t>(i))); }
     bool Int64(int64_t i) { return store(any(static_cast<int64_t>(i))); }
-    bool Uint64(uint64_t u) { return store(any(static_cast<int64_t>(u))); }
 
+    bool Uint(unsigned u) { return store(any(static_cast<int64_t>(u))); }
+    bool Uint64(uint64_t u) {
+        /// prevent an overflow
+        return store(any(static_cast<int64_t>(u & 0x7FFFFFFFFFFFFFFF)));
+    }
+
+    // ...and all floating point types to double
     bool Double(double d) { return store(any(d)); }
 
     bool String(const char* str, OTIO_rapidjson::SizeType length, bool /* copy */) {

src/opentimelineio/safely_typed_any.cpp

@@ -14,6 +14,10 @@ any create_safely_typed_any(int64_t&& value) {
     return any(value);
 }
 
+any create_safely_typed_any(uint64_t&& value) {
+    return any(value);
+}
+
 any create_safely_typed_any(double&& value) {
     return any(value);
 }    
@@ -59,6 +63,10 @@ int64_t safely_cast_int64_any(any const& a) {
     return any_cast<int64_t>(a);
 }
 
+uint64_t safely_cast_uint64_any(any const& a) {
+    return any_cast<uint64_t>(a);
+}
+
 double safely_cast_double_any(any const& a) {
     return any_cast<double>(a);
 }

src/opentimelineio/safely_typed_any.h

@@ -27,6 +27,7 @@ namespace opentimelineio { namespace OPENTIMELINEIO_VERSION  {
 any create_safely_typed_any(bool&&);
 any create_safely_typed_any(int&&);
 any create_safely_typed_any(int64_t&&);
+any create_safely_typed_any(uint64_t&&);
 any create_safely_typed_any(double&&);
 any create_safely_typed_any(std::string&&);
 any create_safely_typed_any(RationalTime&&);
@@ -39,6 +40,7 @@ any create_safely_typed_any(SerializableObject*);
 bool safely_cast_bool_any(any const& a);
 int safely_cast_int_any(any const& a);
 int64_t safely_cast_int64_any(any const& a);
+uint64_t safely_cast_uint64_any(any const& a);
 double safely_cast_double_any(any const& a);
 std::string safely_cast_string_any(any const& a);
 RationalTime safely_cast_rational_time_any(any const& a);

src/opentimelineio/serialization.cpp

@@ -47,6 +47,7 @@ class Encoder {
     virtual void write_value(bool value) = 0;
     virtual void write_value(int value) = 0;
     virtual void write_value(int64_t value) = 0;
+    virtual void write_value(uint64_t value) = 0;
     virtual void write_value(double value) = 0;
     virtual void write_value(std::string const& value) = 0;
     virtual void write_value(class RationalTime const& value) = 0;
@@ -128,6 +129,10 @@ class CloningEncoder : public Encoder {
         _store(any(value));
     }
 
+    void write_value(uint64_t value) {
+        _store(any(value));
+    }
+
     void write_value(std::string const& value) {
         _store(any(value));
     }
@@ -282,6 +287,10 @@ class JSONEncoder : public Encoder {
         _writer.Int64(value);
     }
 
+    void write_value(uint64_t value) {
+        _writer.Uint64(value);
+    }
+
     void write_value(std::string const& value) {
         _writer.String(value.c_str());
     }
@@ -394,6 +403,7 @@ void SerializableObject::Writer::_build_dispatch_tables() {
     wt[&typeid(bool)] = [this](any const& value) { _encoder.write_value(any_cast<bool>(value)); };
     wt[&typeid(int)] = [this](any const& value) { _encoder.write_value(any_cast<int>(value)); };
     wt[&typeid(int64_t)] = [this](any const& value) { _encoder.write_value(any_cast<int64_t>(value)); };
+    wt[&typeid(uint64_t)] = [this](any const& value) { _encoder.write_value(any_cast<uint64_t>(value)); };
     wt[&typeid(double)] = [this](any const& value) { _encoder.write_value(any_cast<double>(value)); };
     wt[&typeid(std::string)] = [this](any const& value) { _encoder.write_value(any_cast<std::string const&>(value)); };
     wt[&typeid(char const*)] = [this](any const& value) {
@@ -427,6 +437,7 @@ void SerializableObject::Writer::_build_dispatch_tables() {
     et[&typeid(bool)] = &_simple_any_comparison<bool>;
     et[&typeid(int)] = &_simple_any_comparison<int>;
     et[&typeid(int64_t)] = &_simple_any_comparison<int64_t>;
+    et[&typeid(uint64_t)] = &_simple_any_comparison<uint64_t>;
     et[&typeid(double)] = &_simple_any_comparison<double>;
     et[&typeid(std::string)] = &_simple_any_comparison<std::string>;
     et[&typeid(char const*)] = &_simple_any_comparison<char const*>;

src/py-opentimelineio/opentimelineio-bindings/otio_bindings.cpp

@@ -97,6 +97,7 @@ PYBIND11_MODULE(_otio, m) {
         .def(py::init([](bool b) { return new PyAny(b); }))
         .def(py::init([](int i) { return new PyAny(i); }))
         .def(py::init([](int64_t i) { return new PyAny(i); }))
+        .def(py::init([](uint64_t i) { return new PyAny(i); }))
         .def(py::init([](double d) { return new PyAny(d); }))
         .def(py::init([](std::string s) { return new PyAny(s); }))
         .def(py::init([](py::none) { return new PyAny(); }))

src/py-opentimelineio/opentimelineio-bindings/otio_tests.cpp

@@ -4,6 +4,7 @@
 #include "opentimelineio/serializableObject.h"
 #include "opentimelineio/serializableObjectWithMetadata.h"
 #include "opentimelineio/serializableCollection.h"
+#include "opentimelineio/timeline.h"
 #include "otio_utils.h"
 
 namespace py = pybind11;
@@ -130,6 +131,26 @@ void otio_xyzzy(std::string msg) {
     /* used as a debugger breakpoint */
 }
 
+/// test the behavior of big integers in OTIO
+bool test_big_uint() {
+    int64_t some_int = 4;
+    uint64_t number_base = INT64_MAX;
+    uint64_t giant_number = number_base + some_int;
+
+    SerializableObjectWithMetadata* so = new SerializableObjectWithMetadata();
+
+    so->metadata()["giant_number"] = giant_number;
+
+    bool result = true;
+
+    if (any_cast<uint64_t>(so->metadata()["giant_number"]) != giant_number) {
+        return false;
+    }
+
+    so->possibly_delete();
+    return true;
+}
+
 void otio_tests_bindings(py::module m) {
     TypeRegistry& r = TypeRegistry::instance();
     r.register_type<TestObject>();
@@ -146,4 +167,5 @@ void otio_tests_bindings(py::module m) {
     test.def("bash_retainers2", &test_bash_retainers2);
     test.def("gil_scoping", &test_gil_scoping);
     test.def("xyzzy", &otio_xyzzy);
+    test.def("test_big_uint", &test_big_uint);
 }

src/py-opentimelineio/opentimelineio-bindings/otio_utils.cpp

@@ -39,13 +39,19 @@ py::object plain_int(int64_t i) {
     return py::reinterpret_steal<py::object>(p);
 }
 
+py::object plain_uint(uint64_t i) {
+    PyObject *p = PyLong_FromUnsignedLongLong(i);
+    return py::reinterpret_steal<py::object>(p);
+}
+
 void _build_any_to_py_dispatch_table() {
     auto& t = _py_cast_dispatch_table;
 
     t[&typeid(void)] = [](any const& /* a */, bool) { return py::none(); };
     t[&typeid(bool)] = [](any const& a, bool) { return py::cast(safely_cast_bool_any(a)); };
     t[&typeid(int)] = [](any const& a, bool) {  return plain_int(safely_cast_int_any(a)); };
     t[&typeid(int64_t)] = [](any const& a, bool) {  return plain_int(safely_cast_int64_any(a)); };
+    t[&typeid(uint64_t)] = [](any const& a, bool) {  return plain_uint(safely_cast_uint64_any(a)); };
     t[&typeid(double)] = [](any const& a, bool) { return py::cast(safely_cast_double_any(a)); };
     t[&typeid(std::string)] = [](any const& a, bool) { return py::cast(safely_cast_string_any(a)); };
     t[&typeid(RationalTime)] = [](any const& a, bool) { return py::cast(safely_cast_rational_time_any(a)); };

tests/test_timeline.py

@@ -57,6 +57,19 @@ def test_big_integers(self):
         self.assertTrue(result.tracks[0][0].metadata["foobar"]["toobig"] > 0)
         self.assertTrue(result.tracks[0][0].metadata["foobar"]["verybig"] > 0)
 
+    def test_big_unsigned_integer_overflow(self):
+        test_tl = otio.schema.Timeline()
+        some_number = 4
+        num_base = 0x7FFFFFFFFFFFFFFF
+        some_even_bigger_number = num_base + some_number
+        test_tl.metadata['big_uint'] = some_even_bigger_number
+        self.assertEqual(test_tl.metadata['big_uint'], some_even_bigger_number)
+
+        serialized = otio.adapters.write_to_string(test_tl, 'otio_json')
+        result = otio.adapters.read_from_string(serialized, 'otio_json')
+
+        self.assertEqual(result.metadata['big_uint'], some_number - 1)
+
     def test_range(self):
         track = otio.schema.Track(name="test_track")
         tl = otio.schema.Timeline("test_timeline", tracks=[track])