Fix wrong retimed detection on image sequence clip.

client/ayon_core/pipeline/editorial.py

@@ -88,7 +88,7 @@ def trim_media_range(media_range, source_range):
 
     """
     rw_media_start = _ot.RationalTime(
-        media_range.start_time.value + source_range.start_time.value,
+        source_range.start_time.value,
         media_range.start_time.rate
     )
     rw_media_duration = _ot.RationalTime(
@@ -173,11 +173,132 @@ def _sequence_resize(source, length):
         yield (1 - ratio) * source[int(low)] + ratio * source[int(high)]
 
 
+def is_clip_from_media_sequence(otio_clip):
+    """
+    Args:
+        otio_clip (otio.schema.Clip): The OTIO clip to check.
+
+    Returns:
+        bool. Is the provided clip from an input media sequence ?
+    """
+    media_ref = otio_clip.media_reference
+    metadata = media_ref.metadata
+
+    # OpenTimelineIO 0.13 and newer
+    is_input_sequence = (
+        hasattr(otio.schema, "ImageSequenceReference") and
+        isinstance(media_ref, otio.schema.ImageSequenceReference)
+    )
+
+    # OpenTimelineIO 0.12 and older
+    is_input_sequence_legacy = bool(metadata.get("padding"))
+
+    return is_input_sequence or is_input_sequence_legacy
+
+
+def remap_range_on_file_sequence(otio_clip, in_out_range):
+    """
+    Args:
+        otio_clip (otio.schema.Clip): The OTIO clip to check.
+        in_out_range (tuple[float, float]): The in-out range to remap.
+
+    Returns:
+        tuple(int, int): The remapped range as discrete frame number.
+
+    Raises:
+        ValueError. When the otio_clip or provided range is invalid.
+    """
+    if not is_clip_from_media_sequence(otio_clip):
+        raise ValueError(f"Cannot map on non-file sequence clip {otio_clip}.")
+
+    try:
+        media_in_trimmed, media_out_trimmed = in_out_range
+
+    except ValueError as error:
+        raise ValueError("Invalid in_out_range provided.") from error
+
+    media_ref = otio_clip.media_reference
+    available_range = otio_clip.available_range()
+    source_range = otio_clip.source_range
+    available_range_rate = available_range.start_time.rate
+    media_in = available_range.start_time.value
+
+    # Temporary.
+    # Some AYON custom OTIO exporter were implemented with relative
+    # source range for image sequence. Following code maintain
+    # backward-compatibility by adjusting media_in
+    # while we are updating those.
+    if (
+        is_clip_from_media_sequence(otio_clip)
+        and otio_clip.available_range().start_time.to_frames() == media_ref.start_frame
+        and source_range.start_time.to_frames() < media_ref.start_frame
+    ):
+        media_in = 0
+
+    frame_in = otio.opentime.RationalTime.from_frames(
+        media_in_trimmed - media_in + media_ref.start_frame,
+        rate=available_range_rate,
+    ).to_frames()
+    frame_out = otio.opentime.RationalTime.from_frames(
+        media_out_trimmed - media_in + media_ref.start_frame,
+        rate=available_range_rate,
+    ).to_frames()
+
+    return frame_in, frame_out
+
+
 def get_media_range_with_retimes(otio_clip, handle_start, handle_end):
     source_range = otio_clip.source_range
     available_range = otio_clip.available_range()
-    media_in = available_range.start_time.value
-    media_out = available_range.end_time_inclusive().value
+    available_range_rate = available_range.start_time.rate
+
+    # If media source is an image sequence, returned
+    # mediaIn/mediaOut have to correspond
+    # to frame numbers from source sequence.
+    media_ref = otio_clip.media_reference
+    is_input_sequence = is_clip_from_media_sequence(otio_clip)
+
+    # Temporary.
+    # Some AYON custom OTIO exporter were implemented with relative
+    # source range for image sequence. Following code maintain
+    # backward-compatibility by adjusting available range
+    # while we are updating those.
+    if (
+        is_input_sequence
+        and available_range.start_time.to_frames() == media_ref.start_frame
+        and source_range.start_time.to_frames() < media_ref.start_frame
+    ):
+        available_range = _ot.TimeRange(
+            _ot.RationalTime(0, rate=available_range_rate),
+            available_range.duration,
+        )
+
+    # Conform source range bounds to available range rate
+    # .e.g. embedded TC of (3600 sec/ 1h), duration 100 frames
+    #
+    # available  |----------------------------------------|  24fps
+    #           86400                                86500
+    #
+    #
+    #                90010                90060
+    # src        |-----|______duration 2s___|----|        25fps
+    #           90000
+    #
+    #
+    #                86409.6                  86466.8
+    # conformed  |-------|_____duration _2.38s____|-------|  24fps
+    #           86400
+    #
+    # Note that 24fps is slower than 25fps hence extended duration
+    # to preserve media range
+
+    # Compute new source range based on available rate
+    conformed_src_in = source_range.start_time.rescaled_to(available_range_rate)
+    conformed_src_duration = source_range.duration.rescaled_to(available_range_rate)
+    conformed_source_range = otio.opentime.TimeRange(
+        start_time=conformed_src_in,
+        duration=conformed_src_duration
+    )
 
     # modifiers
     time_scalar = 1.
@@ -224,55 +345,68 @@ def get_media_range_with_retimes(otio_clip, handle_start, handle_end):
     offset_in *= time_scalar
     offset_out *= time_scalar
 
-    # filip offset if reversed speed
-    if time_scalar < 0:
-        _offset_in = offset_out
-        _offset_out = offset_in
-        offset_in = _offset_in
-        offset_out = _offset_out
-
     # scale handles
     handle_start *= abs(time_scalar)
     handle_end *= abs(time_scalar)
 
-    # filip handles if reversed speed
+    # flip offset and handles if reversed speed
     if time_scalar < 0:
-        _handle_start = handle_end
-        _handle_end = handle_start
-        handle_start = _handle_start
-        handle_end = _handle_end
-
-    source_in = source_range.start_time.value
+        offset_in, offset_out = offset_out, offset_in
+        handle_start, handle_end = handle_end, handle_start
+
+    # compute retimed range
+    media_in_trimmed = conformed_source_range.start_time.value + offset_in
+    media_out_trimmed = media_in_trimmed + (
+        (
+            conformed_source_range.duration.value
+            * abs(time_scalar)
+            + offset_out
+        ) - 1
+    )
 
-    media_in_trimmed = (
-        media_in + source_in + offset_in)
-    media_out_trimmed = (
-        media_in + source_in + (
-            ((source_range.duration.value - 1) * abs(
-                time_scalar)) + offset_out))
+    media_in = available_range.start_time.value
+    media_out = available_range.end_time_inclusive().value
 
-    # calculate available handles
+    # If media source is an image sequence, returned
+    # mediaIn/mediaOut have to correspond
+    # to frame numbers from source sequence.
+    if is_input_sequence:
+        # preserve discrete frame numbers
+        media_in_trimmed, media_out_trimmed = remap_range_on_file_sequence(
+            otio_clip,
+            (media_in_trimmed, media_out_trimmed)
+        )
+        media_in = media_ref.start_frame
+        media_out = media_in + available_range.duration.to_frames() - 1
+
+    # adjust available handles if needed
     if (media_in_trimmed - media_in) < handle_start:
-        handle_start = (media_in_trimmed - media_in)
+        handle_start = max(0, media_in_trimmed - media_in)
     if (media_out - media_out_trimmed) < handle_end:
-        handle_end = (media_out - media_out_trimmed)
+        handle_end = max(0, media_out - media_out_trimmed)
+
+    # FFmpeg extraction ignores embedded timecode
+    # so substract to get a (mediaIn-mediaOut) range from 0.
+    if not is_input_sequence:
+        media_in_trimmed -= media_in
+        media_out_trimmed -= media_in
 
     # create version data
     version_data = {
         "versionData": {
             "retime": True,
             "speed": time_scalar,
             "timewarps": time_warp_nodes,
-            "handleStart": int(round(handle_start)),
-            "handleEnd": int(round(handle_end))
+            "handleStart": int(handle_start),
+            "handleEnd": int(handle_end)
         }
     }
 
     returning_dict = {
         "mediaIn": media_in_trimmed,
         "mediaOut": media_out_trimmed,
-        "handleStart": int(round(handle_start)),
-        "handleEnd": int(round(handle_end)),
+        "handleStart": int(handle_start),
+        "handleEnd": int(handle_end),
         "speed": time_scalar
     }