🎥 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.tsindex 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.tsindex 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);+ }+ },+);