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