Skip to content

🎥 Make videos programmatically with React

Preserve ancestor clipping when limiting timeline moves

Jonny Burgercf4c3a0746a0
diff --git a/packages/studio/src/components/Timeline/get-timeline-sequence-timing-limits.ts b/packages/studio/src/components/Timeline/get-timeline-sequence-timing-limits.ts
index 1300fc5730..872bb054f4 100644
--- a/packages/studio/src/components/Timeline/get-timeline-sequence-timing-limits.ts
+++ b/packages/studio/src/components/Timeline/get-timeline-sequence-timing-limits.ts
@@ -144,11 +144,13 @@ export const getTimelineSequenceTimingLimits = ({
track.cascadedStart) *
track.keyframePlaybackRate
: sequence.duration;
- let minimumStart = track.parentVisibleStart;
- let maximumEnd = Math.min(
+ const parentEnd = Math.min(
timelineDurationInFrames,
track.parentVisibleEnd ?? Infinity,
);
+ let maximumEnd = parentEnd;
+ let minimumNeighbourStart = -Infinity;
+ let maximumNeighbourEnd = Infinity;
// Only normal Track clips exclude their neighbours. Series manages overlaps itself.
if (
sequence.timelineTrack?.role === 'clip' &&
@@ -174,9 +176,13 @@ export const getTimelineSequenceTimingLimits = ({
}
if (sibling.from < track.sequence.from) {
- minimumStart = Math.max(minimumStart, sibling.from + sibling.duration);
+ minimumNeighbourStart = Math.max(
+ minimumNeighbourStart,
+ sibling.from + sibling.duration,
+ );
} else {
- maximumEnd = Math.min(maximumEnd, sibling.from);
+ maximumNeighbourEnd = Math.min(maximumNeighbourEnd, sibling.from);
+ maximumEnd = Math.min(maximumEnd, maximumNeighbourEnd);
}
}
}
@@ -230,16 +236,32 @@ export const getTimelineSequenceTimingLimits = ({
? Math.max(initialDuration, (sourceEnd - trimBefore) / playbackRate)
: (sourceEnd - trimBefore) / playbackRate,
);
+ // Preserve authored clipping: an already hidden edge may move farther outside
+ // its parent, provided one frame remains visible. Neighbours still exclude it.
+ const minimumMoveStart = Math.max(
+ minimumNeighbourStart,
+ track.cascadedStart < track.parentVisibleStart
+ ? track.parentVisibleStart -
+ (initialDuration - 1) / track.keyframePlaybackRate
+ : track.parentVisibleStart,
+ );
+ const maximumMoveEnd = Math.min(
+ maximumNeighbourEnd,
+ track.cascadedStart + initialDuration / track.keyframePlaybackRate >
+ parentEnd
+ ? parentEnd + (initialDuration - 1) / track.keyframePlaybackRate
+ : parentEnd,
+ );
return {
playbackRate,
minimumDuration,
maximumDuration: Math.max(minimumDuration, maximumDuration),
minimumFrom:
sequence.from +
- (minimumStart - track.cascadedStart) * track.keyframePlaybackRate,
+ (minimumMoveStart - track.cascadedStart) * track.keyframePlaybackRate,
maximumFrom:
sequence.from +
- (maximumEnd - track.cascadedStart) * track.keyframePlaybackRate -
+ (maximumMoveEnd - track.cascadedStart) * track.keyframePlaybackRate -
initialDuration,
minimumTrimBefore:
isMedia && inferredDuration && !Number.isFinite(sourceEnd)
diff --git a/packages/studio/src/test/timeline-selection.test.ts b/packages/studio/src/test/timeline-selection.test.ts
index b666961f2d..a45586c034 100644
--- a/packages/studio/src/test/timeline-selection.test.ts
+++ b/packages/studio/src/test/timeline-selection.test.ts
@@ -76,6 +76,7 @@ import {
isDuplicatableEffectSelection,
isDuplicatableSequenceRowSelection,
} from '../components/Timeline/duplicate-selected-timeline-item';
+import {getTimelineSequenceTimingLimits} from '../components/Timeline/get-timeline-sequence-timing-limits';
import {
getKeyframeClipboardDataFromSelections,
getPasteKeyframeTarget,
@@ -9307,3 +9308,221 @@ test('Selected timeline rows do not reselect on pointer down without modifiers',
}),
).toBe(true);
});
+
+test.each([
+ {
+ name: 'negative ancestor',
+ parentFrom: -30,
+ parentDuration: 300,
+ parentTrimBefore: 0,
+ childFrom: 10,
+ childDuration: 60,
+ deltaFrames: -10,
+ expectedFrom: 0,
+ },
+ {
+ name: 'trimmed ancestor',
+ parentFrom: 0,
+ parentDuration: 300,
+ parentTrimBefore: 30,
+ childFrom: 10,
+ childDuration: 60,
+ deltaFrames: -10,
+ expectedFrom: 0,
+ },
+ {
+ name: 'clipped trailing edge',
+ parentFrom: 0,
+ parentDuration: 60,
+ parentTrimBefore: 0,
+ childFrom: 40,
+ childDuration: 40,
+ deltaFrames: 10,
+ expectedFrom: 50,
+ },
+])('Timeline moves preserve existing ancestor clipping: $name', (scenario) => {
+ const nodePathInfo = makeNodePathInfo(['body', 0, 'children', 0], []);
+ const nodePath = nodePathInfo.sequenceSubscriptionKey;
+ const parent = makeTimelineSequence({
+ schema: {},
+ id: 'parent',
+ overrideId: 'parent',
+ from: scenario.parentFrom,
+ duration: scenario.parentDuration,
+ trimBefore: scenario.parentTrimBefore,
+ });
+ const child = makeTimelineSequence({
+ schema: {},
+ id: 'child',
+ overrideId: 'child',
+ parentId: parent.id,
+ from: scenario.childFrom,
+ duration: scenario.childDuration,
+ });
+ const sequences = [parent, child];
+ const overrideIdsToNodePaths = {child: nodePath};
+ const propStatuses = makeFromPropStatuses([nodePath]);
+ const tracks = calculateTimeline({sequences, overrideIdsToNodePaths});
+ const limits = getTimelineSequenceTimingLimits({
+ track: tracks.find((t) => t.sequence.id === child.id)!,
+ tracks,
+ sequences,
+ propStatuses,
+ timelineDurationInFrames: 600,
+ movingSequenceIds: null,
+ });
+ // Re-entering the existing From in the inspector must preserve it.
+ expect(
+ Math.max(limits.minimumFrom, Math.min(limits.maximumFrom, child.from)),
+ ).toBe(child.from);
+ expect(scenario.expectedFrom).toBeGreaterThanOrEqual(limits.minimumFrom);
+ expect(scenario.expectedFrom).toBeLessThanOrEqual(limits.maximumFrom);
+ const targets = getTimelineSequenceFromDragTargets({
+ draggedNodePathInfo: nodePathInfo,
+ selectedItems: [],
+ sequences,
+ overrideIdsToNodePaths,
+ propStatuses,
+ });
+ expect(targets).not.toBeNull();
+ const deltaFrames = getTimelineSequenceFromDragDelta({
+ targets: targets!,
+ deltaFrames: scenario.deltaFrames,
+ timelineDurationInFrames: 600,
+ pxPerFrame: 10,
+ snappingEnabled: false,
+ });
+ const changes = getTimelineSequenceFromDragChanges({
+ targets: targets!,
+ deltaFrames,
+ });
+ expect(changes.map((c) => c.value)).toEqual([scenario.expectedFrom]);
+ const movedTracks = calculateTimeline({
+ sequences: [parent, {...child, from: Number(changes[0].value)}],
+ overrideIdsToNodePaths,
+ });
+ expect(
+ movedTracks.find((t) => t.sequence.id === child.id)!.sequence.duration,
+ ).toBeGreaterThanOrEqual(1);
+});
+
+test.each([
+ {parentPlaybackRate: 1, media: false},
+ {parentPlaybackRate: 2, media: false},
+ {parentPlaybackRate: 1, media: true},
+])(
+ 'Timeline moves stop at Track neighbours after timing edits: %j',
+ ({parentPlaybackRate, media}) => {
+ const nodePathInfo = makeNodePathInfo(['body', 0, 'children', 1], []);
+ const nodePath = nodePathInfo.sequenceSubscriptionKey;
+ const parent = makeTimelineSequence({
+ schema: {},
+ id: 'track',
+ overrideId: 'track',
+ from: 30,
+ duration: 400,
+ sequencePlaybackRate: parentPlaybackRate,
+ componentIdentity: 'dev.remotion.remotion.Track',
+ });
+ parent.timelineTrack = {
+ id: parent.id,
+ role: 'track',
+ name: 'Track',
+ seriesOffset: null,
+ };
+ const previous = makeTimelineSequence({
+ schema: {},
+ id: 'previous',
+ overrideId: 'previous',
+ parentId: parent.id,
+ duration: 80,
+ });
+ const child = makeTimelineSequence({
+ schema: Internals.sequenceSchema,
+ id: 'child',
+ overrideId: 'child',
+ parentId: parent.id,
+ from: 100,
+ duration: media ? 34 : 40,
+ type: media ? 'video' : 'sequence',
+ componentIdentity: media ? 'dev.remotion.media.Video' : null,
+ currentRuntimeValueDotNotation: media
+ ? {durationInFrames: 42, playbackRate: 2, trimBefore: 30}
+ : {},
+ });
+ const next = makeTimelineSequence({
+ schema: {},
+ id: 'next',
+ overrideId: 'next',
+ parentId: parent.id,
+ from: 160,
+ duration: 60,
+ });
+ for (const item of [previous, child, next])
+ item.timelineTrack = {
+ id: parent.id,
+ role: 'clip',
+ name: 'Track',
+ seriesOffset: null,
+ };
+ const sequences = [parent, previous, child, next];
+ const overrideIdsToNodePaths = {child: nodePath};
+ const propStatuses = makeFromPropStatuses([nodePath]);
+ if (media) {
+ const status =
+ propStatuses[Internals.makeSequencePropsSubscriptionKey(nodePath)];
+ if (!status.canUpdate) throw new Error('Expected editable media');
+ status.props.durationInFrames = {
+ status: 'static',
+ codeValue: 68,
+ keyframeDisplayOffsetAdjustment: null,
+ };
+ }
+
+ const targets = getTimelineSequenceFromDragTargets({
+ draggedNodePathInfo: nodePathInfo,
+ selectedItems: [],
+ sequences,
+ overrideIdsToNodePaths,
+ propStatuses,
+ });
+ expect(targets).not.toBeNull();
+ for (const [requestedDelta, expectedFrom] of [
+ [-1000, 80],
+ [1000, media ? 126 : 120],
+ ]) {
+ const deltaFrames = getTimelineSequenceFromDragDelta({
+ targets: targets!,
+ deltaFrames: requestedDelta,
+ timelineDurationInFrames: 600,
+ pxPerFrame: 10,
+ snappingEnabled: false,
+ });
+ const changes = getTimelineSequenceFromDragChanges({
+ targets: targets!,
+ deltaFrames,
+ });
+ expect(changes.map((c) => c.value)).toEqual([expectedFrom]);
+ const movedTracks = calculateTimeline({
+ sequences: [
+ parent,
+ previous,
+ {...child, from: Number(changes[0].value)},
+ next,
+ ],
+ overrideIdsToNodePaths,
+ });
+ const moved = movedTracks.find(
+ (t) => t.sequence.id === child.id,
+ )!.sequence;
+ const before = movedTracks.find(
+ (t) => t.sequence.id === previous.id,
+ )!.sequence;
+ const after = movedTracks.find(
+ (t) => t.sequence.id === next.id,
+ )!.sequence;
+ expect(moved.from).toBeGreaterThanOrEqual(before.from + before.duration);
+ expect(moved.from + moved.duration).toBeLessThanOrEqual(after.from);
+ }
+ },
+);