Skip to content

🎥 Make videos programmatically with React

Respect keyframe bounds when trimming the left edge

JonnyBurgerbd5ea4e05d5f
diff --git a/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx b/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx
index 3c4abb7155..48d72477ba 100644
--- a/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx
+++ b/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx
@@ -560,6 +560,8 @@ const getTimelineSequenceLeftEdgeDragValuesForTarget = ({
? Math.max(-target.initialFrom, localDeltaFrames)
: localDeltaFrames;
+ // A left trim keeps the right edge fixed. Apply keyframe duration bounds
+ // separately from spatial/source end bounds, which constrain the right edge.
if (target.timingLimits) {
clampedDeltaFrames = trimBeforeOnly
? Math.min(
@@ -571,11 +573,17 @@ const getTimelineSequenceLeftEdgeDragValuesForTarget = ({
clampedDeltaFrames,
),
)
- : Math.max(
- target.positionField === null
- ? -Infinity
- : target.timingLimits.minimumFrom - target.initialFrom,
- clampedDeltaFrames,
+ : Math.min(
+ target.initialDuration -
+ target.timingLimits.keyframes.minimumDuration,
+ Math.max(
+ target.initialDuration -
+ target.timingLimits.keyframes.maximumDuration,
+ target.positionField === null
+ ? -Infinity
+ : target.timingLimits.minimumFrom - target.initialFrom,
+ clampedDeltaFrames,
+ ),
);
}
@@ -2005,18 +2013,30 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
limits?.limitReasons.maximumTrimBefore ?? null,
],
])
- : nextValues.durationInFrames === target.minimumDuration
- ? target.minimumDuration > 1
- ? 'Transition limit'
- : 'Minimum duration'
- : nextValues.trimBefore === 0
+ : (getTimelineTrimLimitReason(nextValues.durationInFrames, [
+ [
+ limits?.keyframes.minimumDuration ?? NaN,
+ limits?.keyframes.minimumReason ?? null,
+ ],
+ [
+ limits?.keyframes.maximumDuration ?? NaN,
+ limits?.keyframes.maximumReason ?? null,
+ ],
+ [
+ target.minimumDuration,
+ target.minimumDuration > 1
+ ? 'Transition limit'
+ : 'Minimum duration',
+ ],
+ ]) ??
+ (nextValues.trimBefore === 0
? 'Source start'
: getTimelineTrimLimitReason(nextValues.from, [
[
limits?.minimumFrom ?? NaN,
limits?.limitReasons.minimumFrom ?? null,
],
- ]);
+ ])));
limitReason ??=
getVisibleTimelineTrimLimitReason(targetLimitReason);
}
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 29d34db40d..13f00f96b2 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
@@ -314,6 +314,12 @@ export const getTimelineSequenceTimingLimits = ({
: 'Parent edge';
return {
playbackRate,
+ keyframes: {
+ minimumDuration: keyframeMinimumDuration,
+ maximumDuration: keyframeMaximumDuration,
+ minimumReason: keyframeLimits.minimumReason,
+ maximumReason: keyframeLimits.maximumReason,
+ },
minimumDuration,
maximumDuration: Math.max(minimumDuration, maximumDuration),
minimumFrom,
diff --git a/packages/studio/src/test/keyframe-trim-constraints.test.ts b/packages/studio/src/test/keyframe-trim-constraints.test.ts
index 9f870a8aa7..a01538edd6 100644
--- a/packages/studio/src/test/keyframe-trim-constraints.test.ts
+++ b/packages/studio/src/test/keyframe-trim-constraints.test.ts
@@ -12,6 +12,8 @@ import {loadKeyframeTrimConstraints} from '../components/Timeline/load-keyframe-
import {
getTimelineSequenceDurationDragChanges,
getTimelineSequenceDurationDragTargets,
+ getTimelineSequenceLeftEdgeDragChanges,
+ getTimelineSequenceLeftEdgeDragTargets,
} from '../components/Timeline/TimelineSequenceRightEdgeDragHandle';
import {calculateTimeline} from '../helpers/calculate-timeline';
import {makeBrowserStudioOperations} from './make-browser-studio-operations';
@@ -237,6 +239,121 @@ test.each([
expect(targets[0].minimumDurationReason).toBe('Computed keyframes');
});
+test.each([
+ 'dev.remotion.remotion.Sequence',
+ 'dev.remotion.remotion.Series.Sequence',
+ 'dev.remotion.transitions.TransitionSeries.Sequence',
+])('left-edge trims respect keyframe bounds for %s', (componentIdentity) => {
+ for (const {
+ range,
+ deltaFrames,
+ from,
+ trimBefore,
+ playbackRate,
+ expectedDuration,
+ } of [
+ {
+ range: '[0, durationInFrames - 50]',
+ deltaFrames: 40,
+ from: 0,
+ trimBefore: 0,
+ playbackRate: 1,
+ expectedDuration: 51,
+ },
+ {
+ range: '[0, durationInFrames - 50]',
+ deltaFrames: 40,
+ from: 0,
+ trimBefore: 0,
+ playbackRate: 2,
+ expectedDuration: 52,
+ },
+ {
+ range: '[0, durationInFrames, 100]',
+ deltaFrames: -40,
+ from: 30,
+ trimBefore: 30,
+ playbackRate: 1,
+ expectedDuration: 69,
+ },
+ {
+ range: '[0, Math.max(1, durationInFrames - 50)]',
+ deltaFrames: 40,
+ from: 0,
+ trimBefore: 0,
+ playbackRate: 1,
+ expectedDuration: 60,
+ },
+ ]) {
+ const fixture = makeFixture(range, 'child', 60);
+ const parentPath = fixture.mappings.parent;
+ fixture.files[parentPath.absolutePath] =
+ `import {Sequence} from 'remotion'; export const App = () => <Sequence from={${from}} trimBefore={${trimBefore}} durationInFrames={60}><Content /></Sequence>;`;
+ const parentNode = getNodes({
+ project: {rootDir: '/trim-test', files: fixture.files},
+ filePath: parentPath.absolutePath,
+ })[0];
+ fixture.mappings.parent = {
+ ...parentPath,
+ nodePath: parentNode.nodePath,
+ sequenceKeys: ['durationInFrames', 'from', 'trimBefore'],
+ };
+ fixture.propStatuses[
+ Internals.makeSequencePropsSubscriptionKey(fixture.mappings.parent)
+ ] = getNodeProps({
+ project: {rootDir: '/trim-test', files: fixture.files},
+ node: parentNode,
+ keys: fixture.mappings.parent.sequenceKeys,
+ effectKeys: [],
+ });
+ fixture.sequences[0].from = from;
+ fixture.sequences[0].trimBefore = trimBefore;
+ fixture.sequences[0].duration = 60 / playbackRate;
+ fixture.sequences[0].sequencePlaybackRate = playbackRate;
+ fixture.sequences[0].controls!.componentIdentity = componentIdentity;
+ fixture.sequences[1].controls!.videoConfigValues = config(60 + trimBefore);
+ prepareSource(fixture);
+ const tracks = calculateTimeline({
+ sequences: fixture.sequences,
+ overrideIdsToNodePaths: fixture.mappings,
+ });
+ const targets = getTimelineSequenceLeftEdgeDragTargets({
+ draggedNodePathInfo: tracks.find(
+ (track) => track.sequence.id === 'parent',
+ )!.nodePathInfo!,
+ selectedItems: [],
+ sequences: fixture.sequences,
+ overrideIdsToNodePaths: fixture.mappings,
+ propStatuses: fixture.propStatuses,
+ timelineDurationInFrames: 1000,
+ trimBeforeOnly: false,
+ rippleEdit: false,
+ });
+ expect(targets).not.toBeNull();
+ const changes = getTimelineSequenceLeftEdgeDragChanges({
+ targets: targets!,
+ deltaFrames,
+ trimBeforeOnly: false,
+ });
+ expect(
+ changes.find((change) => change.fieldKey === 'durationInFrames')?.value ??
+ 60,
+ ).toBe(expectedDuration);
+ const appliedDelta = (60 - expectedDuration) / playbackRate;
+ expect(
+ changes.find((change) => change.fieldKey === 'trimBefore')?.value ??
+ trimBefore,
+ ).toBe(trimBefore + appliedDelta * playbackRate);
+ if (componentIdentity === 'dev.remotion.remotion.Sequence') {
+ expect(
+ changes.find((change) => change.fieldKey === 'from')?.value ?? from,
+ ).toBe(from + appliedDelta);
+ } else {
+ expect(changes.some((change) => change.fieldKey === 'from')).toBe(false);
+ }
+ }
+});
+
test('converts descendant constraints through offsets and playback rates', () => {
const fixture = makeFixture(
'[10, 21, durationInFrames - 18, durationInFrames - 8]',