Add effect and marker initialization to Clip

src/opentimelineio/clip.cpp

@@ -13,8 +13,10 @@ Clip::Clip(
     MediaReference*                 media_reference,
     std::optional<TimeRange> const& source_range,
     AnyDictionary const&            metadata,
+    std::vector<Effect*> const&     effects,
+    std::vector<Marker*> const&     markers,
     std::string const&              active_media_reference_key)
-    : Parent{ name, source_range, metadata }
+    : Parent{ name, source_range, metadata, effects, markers }
     , _active_media_reference_key(active_media_reference_key)
 {
     set_media_reference(media_reference);

src/opentimelineio/clip.h

@@ -27,6 +27,8 @@ class Clip : public Item
         MediaReference*                 media_reference = nullptr,
         std::optional<TimeRange> const& source_range    = std::nullopt,
         AnyDictionary const&            metadata        = AnyDictionary(),
+        std::vector<Effect*> const& effects             = std::vector<Effect*>(),
+        std::vector<Marker*> const& markers             = std::vector<Marker*>(),
         std::string const& active_media_reference_key   = default_media_key);
 
     void            set_media_reference(MediaReference* media_reference);

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

@@ -425,13 +425,20 @@ Contains a :class:`.MediaReference` and a trim on that media reference.
 )docstring")
         .def(py::init([](std::string name, MediaReference* media_reference,
                          std::optional<TimeRange> source_range, py::object metadata,
+                         std::optional<std::vector<Effect*>> effects,
+                         std::optional<std::vector<Marker*>> markers,
                          const std::string&  active_media_reference) {
-                          return new Clip(name, media_reference, source_range, py_to_any_dictionary(metadata), active_media_reference);
+                          return new Clip(name, media_reference, source_range, py_to_any_dictionary(metadata),
+                                          vector_or_default<Effect>(effects),
+                                          vector_or_default<Marker>(markers),
+                                          active_media_reference);
                       }),
              py::arg_v("name"_a = std::string()),
              "media_reference"_a = nullptr,
              "source_range"_a = std::nullopt,
              py::arg_v("metadata"_a = py::none()),
+             "effects"_a = py::none(),
+             "markers"_a = py::none(),
              "active_media_reference"_a = std::string(Clip::default_media_key))
         .def_property_readonly_static("DEFAULT_MEDIA_KEY",[](py::object /* self */) { 
             return Clip::default_media_key; 

src/py-opentimelineio/opentimelineio/schema/clip.py

@@ -7,11 +7,13 @@
 
 @add_method(_otio.Clip)
 def __str__(self):
-    return 'Clip("{}", {}, {}, {})'.format(
+    return 'Clip("{}", {}, {}, {}, {}, {})'.format(
         self.name,
         self.media_reference,
         self.source_range,
-        self.metadata
+        self.metadata,
+        self.effects,
+        self.markers
     )
 
 
@@ -22,12 +24,16 @@ def __repr__(self):
         'name={}, '
         'media_reference={}, '
         'source_range={}, '
-        'metadata={}'
+        'metadata={}, '
+        'effects={}, '
+        'markers={}'
         ')'.format(
             repr(self.name),
             repr(self.media_reference),
             repr(self.source_range),
             repr(self.metadata),
+            repr(self.effects),
+            repr(self.markers)
         )
     )
 

tests/test_clip.cpp

@@ -9,6 +9,9 @@
 #include <opentimelineio/missingReference.h>
 #include <opentimelineio/serializableCollection.h>
 #include <opentimelineio/timeline.h>
+#include <opentimelineio/freezeFrame.h>
+#include <opentimelineio/linearTimeWarp.h>
+#include <opentimelineio/marker.h>
 
 #include <iostream>
 
@@ -150,6 +153,22 @@ main(int argc, char** argv)
     tests.add_test("test_clip_media_representation", [] {
         using namespace otio;
 
+        static constexpr auto time_scalar = 1.5;
+
+        SerializableObject::Retainer<LinearTimeWarp> ltw(new LinearTimeWarp(
+            LinearTimeWarp::Schema::name,
+            LinearTimeWarp::Schema::name,
+            time_scalar));
+        std::vector<Effect*> effects = { ltw };
+
+        static constexpr auto red = Marker::Color::red;
+
+        SerializableObject::Retainer<Marker> m(new Marker(
+            LinearTimeWarp::Schema::name,
+            TimeRange(),
+            red));
+        std::vector<Marker*> markers = { m };
+
         static constexpr auto high_quality  = "high_quality";
         static constexpr auto proxy_quality = "proxy_quality";
 
@@ -161,6 +180,8 @@ main(int argc, char** argv)
             media,
             std::nullopt,
             AnyDictionary(),
+            effects,
+            markers,
             high_quality));
 
         assertEqual(clip->active_media_reference_key().c_str(), high_quality);
@@ -225,6 +246,18 @@ main(int argc, char** argv)
         // should work
         clip->set_media_references({ { "cloud", ref4 } }, "cloud");
         assertEqual(clip->media_reference(), ref4.value);
+
+        // basic test for an effect
+        assertEqual(clip->effects().size(), effects.size());
+        auto effect = dynamic_cast<OTIO_NS::LinearTimeWarp*>(
+            clip->effects().front().value);
+        assertEqual(effect->time_scalar(), time_scalar);
+
+        // basic test for a marker
+        assertEqual(clip->markers().size(), markers.size());
+        auto marker = dynamic_cast<OTIO_NS::Marker*>(
+            clip->markers().front().value);
+        assertEqual(marker->color().c_str(), red);
     });
 
     tests.run(argc, argv);

tests/test_clip.py

@@ -21,17 +21,35 @@ def test_cons(self):
             target_url="/var/tmp/test.mov"
         )
 
+        ltw = otio.schema.LinearTimeWarp(
+            name="linear_time_warp",
+            time_scalar=1.5)
+        effects = []
+        effects.append(ltw)
+
+        red = otio.schema.MarkerColor.RED
+        m = otio.schema.Marker(
+            name="red_marker", color=red)
+        markers = []
+        markers.append(m)
+
         cl = otio.schema.Clip(
             name=name,
             media_reference=mr,
             source_range=tr,
+            effects=effects,
+            markers=markers,
             # transition_in
             # transition_out
         )
         self.assertEqual(cl.name, name)
         self.assertEqual(cl.source_range, tr)
         self.assertIsOTIOEquivalentTo(cl.media_reference, mr)
 
+        self.assertTrue(isinstance(cl.effects[0], otio.schema.LinearTimeWarp))
+
+        self.assertEqual(cl.markers[0].color, red)
+
         encoded = otio.adapters.otio_json.write_to_string(cl)
         decoded = otio.adapters.otio_json.read_from_string(encoded)
         self.assertIsOTIOEquivalentTo(cl, decoded)