Merge branch 'feature/nuke_studio_publish_review_cut_ffmpeg' into feature/PYPE-654-nks-cut-reference-videos

pype/plugins/nukestudio/publish/collect_frame_ranges.py

@@ -34,15 +34,22 @@ class CollectClipFrameRanges(pyblish.api.InstancePlugin):
             frame_start = timeline_in
 
         frame_end = frame_start + (timeline_out - timeline_in)
+        source = instance.data.get("source")
 
         data.update(
             {
+        data.update({
+                "sourceFirst": source_in_h,
                 "sourceInH": source_in_h,
                 "sourceOutH": source_out_h,
                 "frameStart": frame_start,
                 "frameEnd": frame_end,
                 "clipInH": timeline_in_h,
-                "clipOutH": timeline_out_h
+                "clipOutH": timeline_out_h,
+                "mediaDurationH": instance.data.get(
+                    "mediaDuration") + handle_start + handle_end,
+                "clipDurationH": instance.data.get(
+                    "clipDuration") + handle_start + handle_end
             }
         )
         self.log.debug("__ data: {}".format(data))

pype/plugins/nukestudio/publish/collect_framerate.py

@@ -1,5 +1,6 @@
 from pyblish import api
 
+
 class CollectFramerate(api.ContextPlugin):
     """Collect framerate from selected sequence."""
 
@@ -9,4 +10,13 @@ class CollectFramerate(api.ContextPlugin):
 
     def process(self, context):
         sequence = context.data["activeSequence"]
-        context.data["fps"] = sequence.framerate().toFloat()
+        context.data["fps"] = self.get_rate(sequence)
+
+    def get_rate(self, sequence):
+        num, den = sequence.framerate().toRational()
+        rate = float(num) / float(den)
+
+        if rate.is_integer():
+            return rate
+
+        return round(rate, 3)

pype/plugins/nukestudio/publish/collect_reviews.py

@@ -100,6 +100,19 @@ class CollectReviews(api.InstancePlugin):
             "name": "preview",
             "ext": ext
         }
+
+        # if int(rev_inst.data.get("sourceIn")) >
+        mediaDuration = instance.data.get("mediaDuration")
+        clipDuration = instance.data.get("clipDuration")
+
+        if mediaDuration > clipDuration:
+            self.log.debug("Media duration higher: {}".format(
+                (mediaDuration - clipDuration)))
+            # representation.update({
+            #     "frameStart": instance.data.get("sourceInH"),
+            #     "frameEnd": instance.data.get("sourceOutH")
+            # })
+
         instance.data["representations"].append(representation)
 
         self.log.debug("Added representation: {}".format(representation))

pype/plugins/nukestudio/publish/collect_timecodes.py

@@ -0,0 +1,88 @@
+import pyblish.api
+import opentimelineio.opentime as otio_ot
+
+
+class CollectClipTimecodes(pyblish.api.InstancePlugin):
+    """Collect time with OpenTimelineIO: source_h(In,Out)[timecode, sec], timeline(In,Out)[timecode, sec]"""
+
+    order = pyblish.api.CollectorOrder + 0.101
+    label = "Collect Timecodes"
+    hosts = ["nukestudio"]
+
+    def process(self, instance):
+
+        data = dict()
+        self.log.debug("__ instance.data: {}".format(instance.data))
+        # Timeline data.
+        handle_start = instance.data["handleStart"]
+        handle_end = instance.data["handleEnd"]
+
+        source_in_h = instance.data("sourceInH",
+                                    instance.data("sourceIn") - handle_start)
+        source_out_h = instance.data("sourceOutH",
+                                     instance.data("sourceOut") + handle_end)
+
+        timeline_in = instance.data["clipIn"]
+        timeline_out = instance.data["clipOut"]
+
+        # set frame start with tag or take it from timeline
+        frame_start = instance.data.get("startingFrame")
+
+        if not frame_start:
+            frame_start = timeline_in
+
+        source = instance.data.get("source")
+
+        otio_data = dict()
+        self.log.debug("__ source: `{}`".format(source))
+
+        rate_fps = instance.context.data["fps"]
+
+        otio_in_h_ratio = otio_ot.RationalTime(
+            value=(source.timecodeStart() + (
+                source_in_h + (source_out_h - source_in_h))),
+            rate=rate_fps)
+
+        otio_out_h_ratio = otio_ot.RationalTime(
+            value=(source.timecodeStart() + source_in_h),
+            rate=rate_fps)
+
+        otio_timeline_in_ratio = otio_ot.RationalTime(
+            value=int(
+                instance.data.get("timelineTimecodeStart", 0)) + timeline_in,
+            rate=rate_fps)
+
+        otio_timeline_out_ratio = otio_ot.RationalTime(
+            value=int(
+                instance.data.get("timelineTimecodeStart", 0)) + timeline_out,
+            rate=rate_fps)
+
+        otio_data.update({
+
+            "otioClipInHTimecode": otio_ot.to_timecode(otio_in_h_ratio),
+
+            "otioClipOutHTimecode": otio_ot.to_timecode(otio_out_h_ratio),
+
+            "otioClipInHSec": otio_ot.to_seconds(otio_in_h_ratio),
+
+            "otioClipOutHSec": otio_ot.to_seconds(otio_out_h_ratio),
+
+            "otioTimelineInTimecode": otio_ot.to_timecode(
+                otio_timeline_in_ratio),
+
+            "otioTimelineOutTimecode": otio_ot.to_timecode(
+                otio_timeline_out_ratio),
+
+            "otioTimelineInSec": otio_ot.to_seconds(otio_timeline_in_ratio),
+
+            "otioTimelineOutSec": otio_ot.to_seconds(otio_timeline_out_ratio)
+        })
+
+        data.update({
+                "otioData": otio_data,
+                "sourceTimecodeIn": otio_ot.to_timecode(otio_in_h_ratio),
+                "sourceTimecodeOut": otio_ot.to_timecode(otio_out_h_ratio),
+            }
+        )
+        instance.data.update(data)
+        self.log.debug("data: {}".format(instance.data))