Merge branch 'develop' into feature/OP-7176_Use-folder-path-as-unique-identifier

openpype/hosts/resolve/api/lib.py

@@ -6,7 +6,10 @@ import contextlib
 from opentimelineio import opentime
 
 from openpype.lib import Logger
-from openpype.pipeline.editorial import is_overlapping_otio_ranges
+from openpype.pipeline.editorial import (
+    is_overlapping_otio_ranges,
+    frames_to_timecode
+)
 
 from ..otio import davinci_export as otio_export
 
@@ -246,18 +249,22 @@ def get_media_pool_item(filepath, root: object = None) -> object:
     return None
 
 
-def create_timeline_item(media_pool_item: object,
-                         timeline: object = None,
-                         source_start: int = None,
-                         source_end: int = None) -> object:
+def create_timeline_item(
+        media_pool_item: object,
+        timeline: object = None,
+        timeline_in: int = None,
+        source_start: int = None,
+        source_end: int = None,
+) -> object:
     """
     Add media pool item to current or defined timeline.
 
     Args:
         media_pool_item (resolve.MediaPoolItem): resolve's object
-        timeline (resolve.Timeline)[optional]: resolve's object
-        source_start (int)[optional]: media source input frame (sequence frame)
-        source_end (int)[optional]: media source output frame (sequence frame)
+        timeline (Optional[resolve.Timeline]): resolve's object
+        timeline_in (Optional[int]): timeline input frame (sequence frame)
+        source_start (Optional[int]): media source input frame (sequence frame)
+        source_end (Optional[int]): media source output frame (sequence frame)
 
     Returns:
         object: resolve.TimelineItem
@@ -269,16 +276,29 @@ def create_timeline_item(media_pool_item: object,
     clip_name = _clip_property("File Name")
     timeline = timeline or get_current_timeline()
 
+    # timing variables
+    if all([timeline_in, source_start, source_end]):
+        fps = timeline.GetSetting("timelineFrameRate")
+        duration = source_end - source_start
+        timecode_in = frames_to_timecode(timeline_in, fps)
+        timecode_out = frames_to_timecode(timeline_in + duration, fps)
+    else:
+        timecode_in = None
+        timecode_out = None
+
     # if timeline was used then switch it to current timeline
     with maintain_current_timeline(timeline):
         # Add input mediaPoolItem to clip data
-        clip_data = {"mediaPoolItem": media_pool_item}
+        clip_data = {
+            "mediaPoolItem": media_pool_item,
+        }
 
-        # add source time range if input was given
-        if source_start is not None:
-            clip_data.update({"startFrame": source_start})
-        if source_end is not None:
-            clip_data.update({"endFrame": source_end})
+        if source_start:
+            clip_data["startFrame"] = source_start
+        if source_end:
+            clip_data["endFrame"] = source_end
+        if timecode_in:
+            clip_data["recordFrame"] = timecode_in
 
         # add to timeline
         media_pool.AppendToTimeline([clip_data])
@@ -286,10 +306,15 @@ def create_timeline_item(media_pool_item: object,
         output_timeline_item = get_timeline_item(
             media_pool_item, timeline)
 
-    assert output_timeline_item, AssertionError(
-        "Track Item with name `{}` doesn't exist on the timeline: `{}`".format(
-            clip_name, timeline.GetName()
-        ))
+    assert output_timeline_item, AssertionError((
+        "Clip name '{}' was't created on the timeline: '{}' \n\n"
+        "Please check if correct track position is activated, \n"
+        "or if a clip is not already at the timeline in \n"
+        "position: '{}' out: '{}'. \n\n"
+        "Clip data: {}"
+    ).format(
+        clip_name, timeline.GetName(), timecode_in, timecode_out, clip_data
+    ))
     return output_timeline_item
 
 
@@ -490,7 +515,7 @@ def imprint(timeline_item, data=None):
 
     Arguments:
         timeline_item (hiero.core.TrackItem): hiero track item object
-        data (dict): Any data which needst to be imprinted
+        data (dict): Any data which needs to be imprinted
 
     Examples:
         data = {

openpype/hosts/resolve/api/plugin.py

@@ -307,11 +307,18 @@ class ClipLoader:
         self.active_project = lib.get_current_project()
 
         # try to get value from options or evaluate key value for `handles`
-        self.with_handles = options.get("handles") or bool(
-            options.get("handles") is True)
+        self.with_handles = options.get("handles") is True
+
         # try to get value from options or evaluate key value for `load_to`
-        self.new_timeline = options.get("newTimeline") or bool(
-            "New timeline" in options.get("load_to", ""))
+        self.new_timeline = (
+            options.get("newTimeline") or
+            options.get("load_to") == "New timeline"
+        )
+        # try to get value from options or evaluate key value for `load_how`
+        self.sequential_load = (
+            options.get("sequentially") or
+            options.get("load_how") == "Sequentially in order"
+        )
 
         assert self._populate_data(), str(
             "Cannot Load selected data, look into database "
@@ -392,30 +399,70 @@ class ClipLoader:
         # create project bin for the media to be imported into
         self.active_bin = lib.create_bin(self.data["binPath"])
 
-        handle_start = self.data["versionData"].get("handleStart") or 0
-        handle_end = self.data["versionData"].get("handleEnd") or 0
-
+        # create mediaItem in active project bin
+        # create clip media
         media_pool_item = lib.create_media_pool_item(
             files,
             self.active_bin
         )
         _clip_property = media_pool_item.GetClipProperty
 
+        # get handles
+        handle_start = self.data["versionData"].get("handleStart")
+        handle_end = self.data["versionData"].get("handleEnd")
+        if handle_start is None:
+            handle_start = int(self.data["assetData"]["handleStart"])
+        if handle_end is None:
+            handle_end = int(self.data["assetData"]["handleEnd"])
+
+        # check frame duration from versionData or assetData
+        frame_start = self.data["versionData"].get("frameStart")
+        if frame_start is None:
+            frame_start = self.data["assetData"]["frameStart"]
+
+        # check frame duration from versionData or assetData
+        frame_end = self.data["versionData"].get("frameEnd")
+        if frame_end is None:
+            frame_end = self.data["assetData"]["frameEnd"]
+
+        db_frame_duration = int(frame_end) - int(frame_start) + 1
+
+        # get timeline in
+        timeline_start = self.active_timeline.GetStartFrame()
+        if self.sequential_load:
+            # set timeline start frame
+            timeline_in = int(timeline_start)
+        else:
+            # set timeline start frame + original clip in frame
+            timeline_in = int(
+                timeline_start + self.data["assetData"]["clipIn"])
+
         source_in = int(_clip_property("Start"))
         source_out = int(_clip_property("End"))
+        source_duration = int(_clip_property("Frames"))
 
-        if _clip_property("Type") == "Video":
+        # check if source duration is shorter than db frame duration
+        source_with_handles = True
+        if source_duration < db_frame_duration:
+            source_with_handles = False
+
+        # only exclude handles if source has no handles or
+        # if user wants to load without handles
+        if (
+            not self.with_handles
+            or not source_with_handles
+        ):
             source_in += handle_start
             source_out -= handle_end
 
-        # include handles
-        if self.with_handles:
-            source_in -= handle_start
-            source_out += handle_end
-
         # make track item from source in bin as item
         timeline_item = lib.create_timeline_item(
-            media_pool_item, self.active_timeline, source_in, source_out)
+            media_pool_item,
+            self.active_timeline,
+            timeline_in,
+            source_in,
+            source_out,
+        )
 
         print("Loading clips: `{}`".format(self.data["clip_name"]))
         return timeline_item
@@ -456,7 +503,7 @@ class TimelineItemLoader(LoaderPlugin):
     """
 
     options = [
-        qargparse.Toggle(
+        qargparse.Boolean(
             "handles",
             label="Include handles",
             default=0,
@@ -471,6 +518,16 @@ class TimelineItemLoader(LoaderPlugin):
             ],
             default=0,
             help="Where do you want clips to be loaded?"
+        ),
+        qargparse.Choice(
+            "load_how",
+            label="How to load clips",
+            items=[
+                "Original timing",
+                "Sequentially in order"
+            ],
+            default="Original timing",
+            help="Would you like to place it at original timing?"
         )
     ]