nks cut reference videos

pype/plugins/global/publish/extract_burnin.py

@@ -18,7 +18,7 @@ class ExtractBurnin(pype.api.Extractor):
     label = "Extract burnins"
     order = pyblish.api.ExtractorOrder + 0.03
     families = ["review", "burnin"]
-    hosts = ["nuke", "maya", "shell", "premiere"]
+    hosts = ["nuke", "maya", "shell", "nukestudio", "premiere"]
     optional = True
 
     def process(self, instance):
@@ -193,7 +193,7 @@ def process(self, instance):
             self.log.debug("Output: {}".format(output))
 
             repre_update = {
-                "anatomy_template": "render",
+                "anatomy_template": repre.get("anatomy_template", "render"),
                 "files": movieFileBurnin,
                 "name": repre["name"],
                 "tags": [x for x in repre["tags"] if x != "delete"]

pype/plugins/global/publish/extract_review.py

@@ -20,15 +20,15 @@ class ExtractReview(pyblish.api.InstancePlugin):
     label = "Extract Review"
     order = pyblish.api.ExtractorOrder + 0.02
     families = ["review"]
-    hosts = ["nuke", "maya", "shell", "premiere"]
+    hosts = ["nuke", "maya", "shell", "nukestudio", "premiere"]
 
     outputs = {}
     ext_filter = []
     to_width = 1920
     to_height = 1080
 
-    def process(self, instance):
 
+    def process(self, instance):
         output_profiles = self.outputs or {}
 
         inst_data = instance.data
@@ -82,6 +82,12 @@ def process(self, instance):
                 repre_new = repre.copy()
                 ext = profile.get("ext", None)
                 p_tags = profile.get('tags', [])
+
+                # append repre tags into profile tags
+                for t in tags:
+                    if t not in p_tags:
+                        p_tags.append(t)
+
                 self.log.info("p_tags: `{}`".format(p_tags))
 
                 # adding control for presets to be sequence
@@ -175,7 +181,8 @@ def process(self, instance):
                 frame_start_handle = frame_start - handle_start
                 frame_end_handle = frame_end + handle_end
                 if isinstance(repre["files"], list):
-                    if frame_start_handle != repre.get("detectedStart", frame_start_handle):
+                    if frame_start_handle != repre.get(
+                            "detectedStart", frame_start_handle):
                         frame_start_handle = repre.get("detectedStart")
 
                     # exclude handle if no handles defined

pype/plugins/nukestudio/publish/collect_clips.py

@@ -103,8 +103,7 @@ def process(self, context):
                         "effects": effects,
                         "sourceIn": int(item.sourceIn()),
                         "sourceOut": int(item.sourceOut()),
-                        "mediaDuration": (int(item.sourceOut()) -
-                            int(item.sourceIn())) + 1,
+                        "mediaDuration": source.duration(),
                         "clipIn": int(item.timelineIn()),
                         "clipOut": int(item.timelineOut()),
                         "clipDuration": (

pype/plugins/nukestudio/publish/collect_frame_ranges.py

@@ -34,15 +34,18 @@ def process(self, instance):
             frame_start = timeline_in
 
         frame_end = frame_start + (timeline_out - timeline_in)
-
-        data.update(
-            {
-                "sourceInH": source_in_h,
-                "sourceOutH": source_out_h,
-                "frameStart": frame_start,
-                "frameEnd": frame_end,
-                "clipInH": timeline_in_h,
-                "clipOutH": timeline_out_h
+        source = instance.data.get("source")
+
+        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,
+            "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_plates.py

@@ -185,8 +185,7 @@ def process(self, instance):
                 "frameEnd": instance.data["sourceOut"] - instance.data["sourceIn"] + 1,
                 'step': 1,
                 'fps': instance.context.data["fps"],
-                'preview': True,
-                'thumbnail': False,
+                'tags': ["preview"],
                 'name': "preview",
                 'ext': "mov",
             }

pype/plugins/nukestudio/publish/collect_reviews.py

@@ -78,8 +78,6 @@ def process(self, instance):
         file_dir = os.path.dirname(file_path)
         file = os.path.basename(file_path)
         ext = os.path.splitext(file)[-1][1:]
-        handleStart = rev_inst.data.get("handleStart")
-        handleEnd = rev_inst.data.get("handleEnd")
 
         # change label
         instance.data["label"] = "{0} - {1} - ({2}) - review".format(
@@ -94,15 +92,27 @@ def process(self, instance):
             "stagingDir": file_dir,
             "frameStart": rev_inst.data.get("sourceIn"),
             "frameEnd": rev_inst.data.get("sourceOut"),
-            "frameStartFtrack": rev_inst.data.get("sourceIn") - handleStart,
-            "frameEndFtrack": rev_inst.data.get("sourceOut") + handleEnd,
+            "frameStartFtrack": rev_inst.data.get("sourceInH"),
+            "frameEndFtrack": rev_inst.data.get("sourceOutH"),
             "step": 1,
             "fps": rev_inst.data.get("fps"),
-            "preview": True,
-            "thumbnail": False,
             "name": "preview",
+            "tags": ["preview"],
             "ext": ext
         }
+
+        media_duration = instance.data.get("mediaDuration")
+        clip_duration_h = instance.data.get("clipDurationH")
+
+        if media_duration > clip_duration_h:
+            self.log.debug("Media duration higher: {}".format(
+                (media_duration - clip_duration_h)))
+            representation.update({
+                "frameStart": instance.data.get("sourceInH"),
+                "frameEnd": instance.data.get("sourceOutH"),
+                "tags": ["cut-up", "delete"]
+            })
+
         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))

pype/plugins/nukestudio/publish/extract_review_cutup_video.py

@@ -0,0 +1,107 @@
+import os
+from pyblish import api
+import pype
+
+
+class ExtractReviewCutUpVideo(pype.api.Extractor):
+    """Cut up clips from long video file"""
+
+    order = api.ExtractorOrder
+    # order = api.CollectorOrder + 0.1023
+    label = "Extract Review CutUp Video"
+    hosts = ["nukestudio"]
+    families = ["review"]
+
+    # presets
+    tags_addition = []
+
+    def process(self, instance):
+        inst_data = instance.data
+        asset = inst_data['asset']
+
+        # get representation and loop them
+        representations = inst_data["representations"]
+
+        ffmpeg_path = pype.lib.get_ffmpeg_tool_path("ffmpeg")
+
+        # filter out mov and img sequences
+        representations_new = representations[:]
+        for repre in representations:
+            input_args = list()
+            output_args = list()
+
+            tags = repre.get("tags", [])
+
+            if "cut-up" not in tags:
+                continue
+
+            self.log.debug("__ repre: {}".format(repre))
+
+            file = repre.get("files")
+            staging_dir = repre.get("stagingDir")
+            frame_start = repre.get("frameStart")
+            frame_end = repre.get("frameEnd")
+            fps = repre.get("fps")
+            ext = repre.get("ext")
+
+            new_file_name = "{}_{}".format(asset, file)
+
+            full_input_path = os.path.join(
+                staging_dir, file)
+
+            full_output_path = os.path.join(
+                staging_dir, new_file_name)
+
+            self.log.debug("__ full_input_path: {}".format(full_input_path))
+            self.log.debug("__ full_output_path: {}".format(full_output_path))
+
+            input_args.append("-y")
+            input_args.append("-i {}".format(full_input_path))
+
+            start_sec = float(frame_start) / fps
+            input_args.append("-ss {:0.2f}".format(start_sec))
+
+            output_args.append("-c copy")
+            duration_sec = float(frame_end - frame_start + 1) / fps
+            output_args.append("-t {:0.2f}".format(duration_sec))
+
+            # output filename
+            output_args.append(full_output_path)
+
+            mov_args = [
+                ffmpeg_path,
+                " ".join(input_args),
+                " ".join(output_args)
+            ]
+            subprcs_cmd = " ".join(mov_args)
+
+            # run subprocess
+            self.log.debug("Executing: {}".format(subprcs_cmd))
+            output = pype.api.subprocess(subprcs_cmd)
+            self.log.debug("Output: {}".format(output))
+
+            repre_new = {
+                "files": new_file_name,
+                "stagingDir": staging_dir,
+                "frameStart": frame_start,
+                "frameEnd": frame_end,
+                "frameStartFtrack": frame_start,
+                "frameEndFtrack": frame_end,
+                "step": 1,
+                "fps": fps,
+                "name": "cut_up_preview",
+                "tags": ["cut-up", "review", "delete"] + self.tags_addition,
+                "ext": ext,
+                "anatomy_template": "publish"
+            }
+
+            representations_new.append(repre_new)
+
+        for repre in representations_new:
+            if ("delete" in repre.get("tags", [])) and (
+                    "cut_up_preview" not in repre["name"]):
+                representations_new.remove(repre)
+
+        self.log.debug(
+            "new representations: {}".format(representations_new))
+        instance.data["representations"] = representations_new