Skip to content

πŸŽ₯ Make videos programmatically with React

Clamp Studio trims to safe keyframe durations

JonnyBurger175bd1c5f277
diff --git a/packages/codemods/src/sequence-props.ts b/packages/codemods/src/sequence-props.ts
index f9966c3167..429c4465a8 100644
--- a/packages/codemods/src/sequence-props.ts
+++ b/packages/codemods/src/sequence-props.ts
@@ -31,6 +31,7 @@ import {NoReactInternals} from 'remotion/no-react';
import {getReadOnlySourceSnapshot} from './sequence-props-snapshot';
import {computeEffectPropStatus} from './sequence-props/can-update-effect-props';
import {getCssShorthandForLonghand} from './sequence-props/css-shorthand-properties';
+import {getDurationDependentKeyframes} from './sequence-props/duration-dependent-keyframes';
import {getAstNodePath} from './sequence-props/get-ast-node-path';
import {toImportAgnosticNodePath} from './sequence-props/import-agnostic-node-path';
import {
@@ -2324,6 +2325,11 @@ const computeSequencePropsStatusFromAstAndIdentifiers = ({
ast,
videoConfigValues: videoConfigIdentifierValues,
});
+ const durationDependentKeyframes = getDurationDependentKeyframes({
+ ast,
+ jsxPath,
+ videoConfigIdentifierValues,
+ });
const addDefaultKeyframeDisplayOffsetAdjustment = (
status: CanUpdateSequencePropSource,
): CanUpdateSequencePropSource => {
@@ -2361,6 +2367,7 @@ const computeSequencePropsStatusFromAstAndIdentifiers = ({
return {
canUpdate: true as const,
+ ...(durationDependentKeyframes ? {durationDependentKeyframes} : {}),
props: Object.fromEntries(
Object.entries(filteredProps).map(([key, status]) => [
key,
diff --git a/packages/codemods/src/sequence-props/duration-dependent-keyframes.ts b/packages/codemods/src/sequence-props/duration-dependent-keyframes.ts
new file mode 100644
index 0000000000..ca1781dccd
--- /dev/null
+++ b/packages/codemods/src/sequence-props/duration-dependent-keyframes.ts
@@ -0,0 +1,188 @@
+import type {Expression, File, Identifier, Node} from '@babel/types';
+import * as recast from 'recast';
+import type {
+ CanUpdateSequencePropsResponseTrue,
+ SourceNumericValue,
+} from 'remotion';
+import {getNodePathForRecastPath} from '../sequence-props';
+import {getKeyframeInterpolationFunctionForCallee} from './keyframe-interpolation-function';
+import {parseVideoConfigNumericExpression} from './video-config-numeric-expression';
+import type {VideoConfigIdentifierValues} from './video-config-values';
+
+type DurationDependentKeyframes = NonNullable<
+ CanUpdateSequencePropsResponseTrue['durationDependentKeyframes']
+>;
+const cache = new WeakMap<object, DurationDependentKeyframes | null>();
+const functionTypes = new Set([
+ 'FunctionDeclaration',
+ 'FunctionExpression',
+ 'ArrowFunctionExpression',
+]);
+
+const getConstantInitializer = (
+ path: recast.types.NodePath,
+): recast.types.NodePath | null => {
+ const node = path.node as Node;
+ if (node.type !== 'Identifier') return null;
+ const binding = path.scope.lookup(node.name)?.getBindings()[node.name]?.[0];
+ const declaration = binding?.parentPath;
+ return declaration?.node.type === 'VariableDeclarator' &&
+ declaration.node.id === binding.node &&
+ declaration.parentPath.node.kind === 'const' &&
+ declaration.node.init
+ ? declaration.get('init')
+ : null;
+};
+
+const parseFrame = (
+ path: recast.types.NodePath,
+ bindings: VideoConfigIdentifierValues,
+ seen: Set<object>,
+): SourceNumericValue | null => {
+ const node = path.node as Expression;
+ if (!node || seen.has(node)) return null;
+ const nextSeen = new Set(seen).add(node);
+ const parsed = parseVideoConfigNumericExpression({
+ node,
+ videoConfigValues: bindings,
+ });
+ if (parsed) return parsed;
+ const initializer = getConstantInitializer(path);
+ if (initializer) return parseFrame(initializer, bindings, nextSeen);
+ if (node.type === 'TSAsExpression')
+ return parseFrame(path.get('expression'), bindings, nextSeen);
+ if (
+ node.type === 'BinaryExpression' &&
+ ['+', '-', '*', '/'].includes(node.operator)
+ ) {
+ const left = parseFrame(path.get('left'), bindings, nextSeen);
+ const right = parseFrame(path.get('right'), bindings, nextSeen);
+ return left !== null && right !== null
+ ? {
+ type: 'binary',
+ operator: node.operator as '+' | '-' | '*' | '/',
+ left,
+ right,
+ }
+ : null;
+ }
+
+ return null;
+};
+
+export const getDurationDependentKeyframes = ({
+ ast,
+ jsxPath,
+ videoConfigIdentifierValues,
+}: {
+ ast: File;
+ jsxPath: recast.types.NodePath;
+ videoConfigIdentifierValues: VideoConfigIdentifierValues;
+}): DurationDependentKeyframes | null => {
+ let scopePath: recast.types.NodePath | null = jsxPath;
+ while (scopePath && !functionTypes.has((scopePath.node as Node).type)) {
+ scopePath = scopePath.parentPath;
+ }
+
+ if (!scopePath) return null;
+ const scopeNode = scopePath.node as Node;
+ if (cache.has(scopeNode)) return cache.get(scopeNode)!;
+ const inputRanges: (SourceNumericValue[] | null)[] = [];
+ // Inspect the whole render scope, including variables, effects, and ordinary
+ // JSX children with no editable schema. Source snapshots cache this per scope.
+ recast.types.visit(scopePath as unknown as Node, {
+ visitCallExpression(path) {
+ const {callee} = path.node;
+ if (
+ callee.type !== 'Identifier' ||
+ !path.node.arguments[1] ||
+ getKeyframeInterpolationFunctionForCallee({
+ ast,
+ callee: callee as Identifier,
+ }) === null
+ ) {
+ return this.traverse(path);
+ }
+
+ let dependsOnDuration = false;
+ const pending = [path.get('arguments', 1)];
+ const seen = new Set<object>();
+ while (pending.length > 0) {
+ const rangePath = pending.pop()!;
+ if (seen.has(rangePath.node as Node)) continue;
+ seen.add(rangePath.node as Node);
+ recast.types.visit(rangePath as unknown as Node, {
+ visitIdentifier(identifierPath) {
+ const binding =
+ videoConfigIdentifierValues instanceof Map
+ ? videoConfigIdentifierValues.get(
+ identifierPath.node as Identifier,
+ )
+ : videoConfigIdentifierValues[identifierPath.node.name];
+ if (
+ binding?.type === 'video-config' &&
+ binding.field === 'durationInFrames'
+ ) {
+ const declaration = identifierPath.scope
+ .lookup(identifierPath.node.name)
+ ?.getBindings()[identifierPath.node.name]?.[0];
+ let owner = declaration?.parentPath;
+ while (
+ owner &&
+ owner.node !== scopeNode &&
+ !functionTypes.has(owner.node.type)
+ ) {
+ owner = owner.parentPath;
+ }
+
+ // A nested component's hook has an independent duration.
+ dependsOnDuration ||= owner?.node === scopeNode;
+ } else {
+ const initializer = getConstantInitializer(
+ identifierPath as unknown as recast.types.NodePath,
+ );
+ if (initializer) pending.push(initializer);
+ }
+
+ return false;
+ },
+ });
+ }
+
+ if (dependsOnDuration) {
+ let rangePath = path.get('arguments', 1);
+ const seenRanges = new Set<object>();
+ while (!seenRanges.has(rangePath.node as Node)) {
+ seenRanges.add(rangePath.node as Node);
+ const initializer = getConstantInitializer(rangePath);
+ if (!initializer) break;
+ rangePath = initializer;
+ }
+
+ const range = rangePath.node as Node;
+ const expressions =
+ range.type === 'ArrayExpression'
+ ? range.elements.map((_, index) =>
+ parseFrame(
+ rangePath.get('elements', index),
+ videoConfigIdentifierValues,
+ new Set(),
+ ),
+ )
+ : null;
+ // Unknown duration arithmetic must not become an unsafe trim.
+ inputRanges.push(
+ expressions?.every((value) => value !== null) ? expressions : null,
+ );
+ }
+
+ return this.traverse(path);
+ },
+ });
+ const result =
+ inputRanges.length > 0
+ ? {scope: getNodePathForRecastPath(scopePath, ast), inputRanges}
+ : null;
+ cache.set(scopeNode, result);
+ return result;
+};
diff --git a/packages/core/src/SequenceManager.tsx b/packages/core/src/SequenceManager.tsx
index cf8a577425..28e8963594 100644
--- a/packages/core/src/SequenceManager.tsx
+++ b/packages/core/src/SequenceManager.tsx
@@ -197,6 +197,11 @@ export type CanUpdateSequencePropsResponseTrue<Numeric = SourceNumericValue> = {
canUpdate: true;
props: Record<string, CanUpdateSequencePropStatus<Numeric>>;
effects: CanUpdateEffectPropsResponse<Numeric>[];
+ /** Source ranges also include interpolations outside the editable schema. */
+ durationDependentKeyframes?: {
+ readonly scope: SequenceNodePath;
+ readonly inputRanges: readonly (readonly SourceNumericValue[] | null)[];
+ };
};
export type CanUpdateSequencePropsResponseFalse = {
diff --git a/packages/example/src/KeyframeTrimTestbed.tsx b/packages/example/src/KeyframeTrimTestbed.tsx
new file mode 100644
index 0000000000..b7a7c4e5d5
--- /dev/null
+++ b/packages/example/src/KeyframeTrimTestbed.tsx
@@ -0,0 +1,545 @@
+import {blur} from '@remotion/effects/blur';
+import {Audio, Video} from '@remotion/media';
+import {linearTiming, TransitionSeries} from '@remotion/transitions';
+import {fade} from '@remotion/transitions/fade';
+import type {ReactNode} from 'react';
+import {
+ AbsoluteFill,
+ Easing,
+ Interactive,
+ Internals,
+ interpolate,
+ Sequence,
+ Series,
+ Solid,
+ staticFile,
+ Track,
+ useCurrentFrame,
+ useVideoConfig,
+} from 'remotion';
+
+const Card = ({
+ title,
+ limit,
+ description,
+ children,
+}: {
+ readonly title: string;
+ readonly limit: string;
+ readonly description: string;
+ readonly children: ReactNode;
+}) => (
+ <div
+ style={{
+ backgroundColor: '#172033',
+ border: '1px solid #34425a',
+ borderRadius: 18,
+ padding: 16,
+ minHeight: 0,
+ display: 'flex',
+ flexDirection: 'column',
+ gap: 8,
+ }}
+ >
+ <div style={{fontSize: 21, fontWeight: 700}}>{title}</div>
+ <div style={{fontSize: 18, color: '#8ee6c1', fontWeight: 600}}>{limit}</div>
+ <div
+ style={{fontSize: 16, color: '#bac5d6', lineHeight: 1.4, minHeight: 44}}
+ >
+ {description}
+ </div>
+ <div
+ style={{
+ position: 'relative',
+ flex: 1,
+ minHeight: 60,
+ display: 'flex',
+ justifyContent: 'center',
+ alignItems: 'center',
+ backgroundColor: '#0d1422',
+ borderRadius: 12,
+ }}
+ >
+ {children}
+ </div>
+ </div>
+);
+
+const Clock = () => {
+ const frame = useCurrentFrame();
+ const {durationInFrames} = useVideoConfig();
+ return (
+ <div
+ style={{
+ position: 'absolute',
+ bottom: 10,
+ left: 0,
+ right: 0,
+ textAlign: 'center',
+ fontSize: 16,
+ color: '#9eacc0',
+ fontVariantNumeric: 'tabular-nums',
+ }}
+ >
+ Local frame {Math.round(frame * 100) / 100} Β· duration {durationInFrames}
+ </div>
+ );
+};
+
+// Issue #12153: these four input frames stop increasing below 40 frames.
+// The ordinary SVG circle deliberately has no editable property schema.
+const CircleContent = () => {
+ const frame = useCurrentFrame();
+ const {durationInFrames, fps} = useVideoConfig();
+ return (
+ <>
+ <Interactive.Svg
+ name="SVG child with duration-dependent radius"
+ viewBox="0 0 64 60"
+ width={128}
+ height={120}
+ style={{marginBottom: 24}}
+ premountFor={fps}
+ >
+ <circle
+ cx="32"
+ cy="30"
+ r="22"
+ fill="none"
+ stroke="#34425a"
+ strokeWidth="0.6"
+ />
+ <circle
+ cx="32"
+ cy="30"
+ r={interpolate(
+ frame,
+ [10, 21, durationInFrames - 18, durationInFrames - 8],
+ [0, 9, 9, 0],
+ {
+ easing: Easing.out(Easing.cubic),
+ extrapolateLeft: 'clamp',
+ extrapolateRight: 'clamp',
+ },
+ )}
+ fill="#8ee6c1"
+ />
+ </Interactive.Svg>
+ <Clock />
+ </>
+ );
+};
+
+const PropertyContent = () => {
+ const frame = useCurrentFrame();
+ const {durationInFrames, fps} = useVideoConfig();
+ return (
+ <>
+ <Solid
+ name="Opacity keyframes"
+ width={120}
+ height={100}
+ color="#77b4ff"
+ premountFor={fps}
+ style={{
+ borderRadius: 18,
+ marginBottom: 24,
+ opacity: interpolate(
+ frame,
+ [10, 21, durationInFrames - 18, durationInFrames - 8],
+ [0.2, 1, 1, 0.2],
+ {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'},
+ ),
+ }}
+ />
+ <Clock />
+ </>
+ );
+};
+
+const EffectContent = () => {
+ const frame = useCurrentFrame();
+ const {durationInFrames, fps} = useVideoConfig();
+ return (
+ <>
+ <Solid
+ name="Blur effect keyframes"
+ width={120}
+ height={100}
+ color="#ffbf83"
+ premountFor={fps}
+ style={{borderRadius: 18, marginBottom: 24}}
+ effects={[
+ blur({
+ radius: interpolate(
+ frame,
+ [10, 21, durationInFrames - 18, durationInFrames - 8],
+ [12, 0, 0, 12],
+ {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'},
+ ),
+ }),
+ ]}
+ />
+ <Clock />
+ </>
+ );
+};
+
+const NestedContent = () => {
+ const {fps} = useVideoConfig();
+ return (
+ <Sequence
+ name="Child: from 10, playback rate 2"
+ from={10}
+ durationInFrames={120}
+ playbackRate={2}
+ style={{justifyContent: 'center', alignItems: 'center'}}
+ premountFor={fps}
+ >
+ <CircleContent />
+ </Sequence>
+ );
+};
+
+const MaximumContent = () => {
+ const frame = useCurrentFrame();
+ const {durationInFrames, fps} = useVideoConfig();
+ return (
+ <>
+ <Solid
+ name="Bounded opacity keyframes"
+ width={120}
+ height={100}
+ color="#cfabff"
+ premountFor={fps}
+ style={{
+ borderRadius: 18,
+ marginBottom: 24,
+ opacity: interpolate(
+ frame,
+ [0, 10, durationInFrames, 90],
+ [0.2, 1, 1, 0.2],
+ {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'},
+ ),
+ }}
+ />
+ <Clock />
+ </>
+ );
+};
+
+const UnknownArithmeticContent = () => {
+ const frame = useCurrentFrame();
+ const {durationInFrames, fps} = useVideoConfig();
+ return (
+ <>
+ <Solid
+ name="Computed input range"
+ width={120}
+ height={100}
+ color="#ff8eac"
+ premountFor={fps}
+ style={{
+ borderRadius: 18,
+ marginBottom: 24,
+ opacity: interpolate(
+ frame,
+ [0, 10, Math.max(11, durationInFrames - 18), durationInFrames - 8],
+ [0.2, 1, 1, 0.2],
+ {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'},
+ ),
+ }}
+ />
+ <Clock />
+ </>
+ );
+};
+
+export const KeyframeTrimTestbed = () => {
+ const {fps} = useVideoConfig();
+ return (
+ <AbsoluteFill
+ style={{
+ backgroundColor: '#0b1120',
+ color: '#eef3fb',
+ fontFamily: 'Arial, sans-serif',
+ padding: 40,
+ gap: 24,
+ }}
+ >
+ <div style={{fontSize: 42, fontWeight: 700}}>Timeline trim limits</div>
+ <div style={{fontSize: 22, color: '#bac5d6', lineHeight: 1.5}}>
+ Each card names the expected feedback and the handle to drag. Rows 1–6
+ exercise keyframes; rows 7–16 cover the remaining boundaries. Seek back
+ inside shortened clips to see their content.
+ </div>
+ <div
+ style={{
+ display: 'grid',
+ gridTemplateColumns: 'repeat(4, 1fr)',
+ gridTemplateRows: 'repeat(4, minmax(0, 1fr))',
+ gap: 18,
+ minHeight: 0,
+ flex: 1,
+ }}
+ >
+ <Card
+ title="1. Plain SVG child"
+ limit="Keyframe constraint Β· minimum 40"
+ description="Original circle-radius reproduction. No schema on the animated circle."
+ >
+ <Sequence
+ name="1. SVG child β€” minimum 40"
+ durationInFrames={40}
+ style={{justifyContent: 'center', alignItems: 'center'}}
+ premountFor={fps}
+ >
+ <CircleContent />
+ </Sequence>
+ </Card>
+ <Card
+ title="2. Element property"
+ limit="Keyframe constraint Β· minimum 40"
+ description="Opacity is animated on an editable Solid property."
+ >
+ <Sequence
+ name="2. Property β€” minimum 40"
+ durationInFrames={40}
+ style={{justifyContent: 'center', alignItems: 'center'}}
+ premountFor={fps}
+ >
+ <PropertyContent />
+ </Sequence>
+ </Card>
+ <Card
+ title="3. Effect property"
+ limit="Keyframe constraint Β· minimum 40"
+ description="The same input range drives a blur effect's radius."
+ >
+ <Sequence
+ name="3. Effect β€” minimum 40"
+ durationInFrames={54}
+ style={{justifyContent: 'center', alignItems: 'center'}}
+ premountFor={fps}
+ >
+ <EffectContent />
+ </Sequence>
+ </Card>
+ <Card
+ title="4. Nested child"
+ limit="Keyframe constraint Β· parent minimum 30"
+ description="Child starts at 10 and plays at 2Γ—. Its local duration must stay at least 40."
+ >
+ <Sequence
+ name="4. Nested parent β€” minimum 30"
+ durationInFrames={38}
+ style={{justifyContent: 'center', alignItems: 'center'}}
+ premountFor={fps}
+ >
+ <NestedContent />
+ </Sequence>
+ </Card>
+ <Card
+ title="5. Maximum duration"
+ limit="Keyframe constraint Β· range 11–89"
+ description="Input range [0, 10, duration, 90]. Try extending the right edge past 89."
+ >
+ <Sequence
+ name="5. Upper bound β€” maximum 89"
+ durationInFrames={60}
+ style={{justifyContent: 'center', alignItems: 'center'}}
+ premountFor={fps}
+ >
+ <MaximumContent />
+ </Sequence>
+ </Card>
+ <Card
+ title="6. Unresolved arithmetic"
+ limit="Computed keyframes Β· stays at 90"
+ description="Math.max() in the range cannot be solved statically. Resizing stays locked."
+ >
+ <Sequence
+ name="6. Computed range β€” locked at 90"
+ durationInFrames={90}
+ style={{justifyContent: 'center', alignItems: 'center'}}
+ premountFor={fps}
+ >
+ <UnknownArithmeticContent />
+ </Sequence>
+ </Card>
+ <Card
+ title="7. One-frame minimum"
+ limit="Green glow only Β· one-frame minimum"
+ description="Drag the right edge left until only one frame remains."
+ >
+ <Sequence name="7. Minimum duration" durationInFrames={60}>
+ <Clock />
+ </Sequence>
+ </Card>
+ <Card
+ title="8. Transition overlap"
+ limit="Transition limit"
+ description="Shorten clip A with its right edge. The 20-frame fade sets its minimum."
+ >
+ <Internals.ExperimentalTracksEnabledContext.Provider value={false}>
+ <TransitionSeries name="8. Transition container">
+ <TransitionSeries.Sequence
+ name="8. Transition limit β€” clip A"
+ durationInFrames={60}
+ >
+ <Clock />
+ </TransitionSeries.Sequence>
+ <TransitionSeries.Transition
+ presentation={fade()}
+ timing={linearTiming({durationInFrames: 20})}
+ />
+ <TransitionSeries.Sequence
+ name="8. Transition clip B"
+ durationInFrames={60}
+ >
+ <Clock />
+ </TransitionSeries.Sequence>
+ </TransitionSeries>
+ </Internals.ExperimentalTracksEnabledContext.Provider>
+ </Card>
+ <Card
+ title="9. Source beginning"
+ limit="Green glow only Β· source start"
+ description="Drag the left edge left. Its 15 trimmed frames can be restored, then it stops."
+ >
+ <Sequence
+ name="9. Source start"
+ from={20}
+ trimBefore={15}
+ durationInFrames={60}
+ premountFor={fps}
+ >
+ <Clock />
+ </Sequence>
+ </Card>
+ <Card
+ title="10. Media ending"
+ limit="Green glow only Β· source end"
+ description="Extend the audio's right edge. The local 56-frame file ends before the composition."
+ >
+ <Audio
+ name="10. Source end"
+ src={staticFile('22khz.wav')}
+ trimBefore={5}
+ durationInFrames={51}
+ muted
+ />
+ <Clock />
+ </Card>
+ <Card
+ title="11. Parent boundary"
+ limit="Green glow only Β· parent edge"
+ description="Extend the child's right edge to frame 90, where its parent ends."
+ >
+ <Sequence name="11. Parent β€” 90 frames" durationInFrames={90}>
+ <Sequence
+ name="11. Parent edge β€” child"
+ from={10}
+ durationInFrames={40}
+ >
+ <Clock />
+ </Sequence>
+ </Sequence>
+ </Card>
+ <Card
+ title="12. Composition boundary"
+ limit="Green glow only Β· composition edge"
+ description="Extend the right edge to frame 180, the end of this composition."
+ >
+ <Sequence name="12. Composition edge" from={15} durationInFrames={75}>
+ <Clock />
+ </Sequence>
+ </Card>
+ <Card
+ title="13. Neighboring clips"
+ limit="Green glow only Β· adjacent clip"
+ description="Extend clip A to frame 80, where clip B starts on the same track."
+ >
+ <Internals.ExperimentalTracksEnabledContext.Provider value>
+ <Track name="13. Adjacent clips">
+ <Sequence name="13. Adjacent clip β€” A" durationInFrames={50}>
+ <Clock />
+ </Sequence>
+ <Sequence
+ name="13. Adjacent clip β€” B"
+ from={80}
+ durationInFrames={50}
+ premountFor={fps * 6}
+ >
+ <Clock />
+ </Sequence>
+ </Track>
+ </Internals.ExperimentalTracksEnabledContext.Provider>
+ </Card>
+ <Card
+ title="14. Inferred content ending"
+ limit="Green glow only Β· content end"
+ description="Extend the Series wrapper's right edge. Its two 45-frame children end at 90."
+ >
+ <Internals.ExperimentalTracksEnabledContext.Provider value={false}>
+ <Series name="14. Content end" durationInFrames={50}>
+ <Series.Sequence name="14. Content A" durationInFrames={45}>
+ <Clock />
+ </Series.Sequence>
+ <Series.Sequence name="14. Content B" durationInFrames={45}>
+ <Clock />
+ </Series.Sequence>
+ </Series>
+ </Internals.ExperimentalTracksEnabledContext.Provider>
+ </Card>
+ <Card
+ title="15. Unavailable media metadata"
+ limit="Unknown media duration"
+ description="Drag the inner source-start handle left. This deliberately invalid media has no known end."
+ >
+ <Video
+ name="15. Unknown media duration"
+ src={staticFile('example.txt')}
+ trimBefore={15}
+ durationInFrames={60}
+ onError={() => 'fallback'}
+ fallbackOffthreadVideoProps={{
+ onError: () => undefined,
+ pauseWhenBuffering: false,
+ }}
+ muted
+ style={{width: 1, height: 1}}
+ />
+ <Clock />
+ </Card>
+ <Card
+ title="16. Clipped-start fallback"
+ limit="Green glow only Β· fallback"
+ description="Cmd/Ctrl-select the clipped child and handle row, then drag the handle row's left edge left by 30 frames."
+ >
+ <Sequence name="16. Clipped parent" from={-30} durationInFrames={150}>
+ <Sequence
+ name="16. Trim limit β€” child"
+ from={20}
+ trimBefore={60}
+ durationInFrames={60}
+ >
+ <Clock />
+ </Sequence>
+ </Sequence>
+ <Sequence
+ name="16. Trim limit β€” drag handle"
+ from={45}
+ trimBefore={100}
+ durationInFrames={60}
+ premountFor={fps * 6}
+ />
+ </Card>
+ </div>
+ <div style={{fontSize: 18, color: '#8495ad'}}>
+ Also try values outside the allowed range in the Duration inspector, or
+ select several numbered rows and trim them together.
+ </div>
+ </AbsoluteFill>
+ );
+};
diff --git a/packages/example/src/Root.tsx b/packages/example/src/Root.tsx
index b7b20dcb11..c57119cd2b 100644
--- a/packages/example/src/Root.tsx
+++ b/packages/example/src/Root.tsx
@@ -118,6 +118,7 @@ import {
import {HugeImage} from './HugeImage';
import {HugePayload, hugePayloadSchema} from './HugePayload';
import {IntrinsicDurationLoopTestbed} from './IntrinsicDurationLoopTestbed';
+import {KeyframeTrimTestbed} from './KeyframeTrimTestbed';
import {Layers} from './Layers';
import {LongAudio} from './LongAudio';
import {ManyAudio} from './ManyAudio';
@@ -3127,6 +3128,14 @@ export const Index: React.FC = () => {
durationInFrames={300}
/>
<Folder name="VisualModeTests">
+ <Composition
+ id="keyframe-trim-testbed"
+ component={KeyframeTrimTestbed}
+ width={1920}
+ height={1440}
+ fps={30}
+ durationInFrames={180}
+ />
<Composition
id="SourceSubscriptionChurn"
component={SourceSubscriptionChurn}
diff --git a/packages/studio-shared/src/optimistic-update-for-prop-statuses.ts b/packages/studio-shared/src/optimistic-update-for-prop-statuses.ts
index 60ac30889a..a31db11f38 100644
--- a/packages/studio-shared/src/optimistic-update-for-prop-statuses.ts
+++ b/packages/studio-shared/src/optimistic-update-for-prop-statuses.ts
@@ -49,7 +49,7 @@ export const optimisticUpdateForPropStatuses = ({
}
return {
- canUpdate: true,
+ ...previous,
props,
effects: previous.effects,
};
diff --git a/packages/studio/src/components/Timeline/TimelineSequence.tsx b/packages/studio/src/components/Timeline/TimelineSequence.tsx
index 5308d411d5..db85b0cb5c 100644
--- a/packages/studio/src/components/Timeline/TimelineSequence.tsx
+++ b/packages/studio/src/components/Timeline/TimelineSequence.tsx
@@ -19,6 +19,7 @@ import {StudioServerConnectionCtx} from '../../helpers/client-id';
import {
BLACK_ALPHA_22,
BLUE,
+ RED,
TIMELINE_AUDIO_GRADIENT,
TIMELINE_BACKGROUND_COLOR,
TIMELINE_CAPTIONS_GRADIENT,
@@ -137,16 +138,22 @@ type TimelineEdgeHighlight = {
readonly edge: TimelineEdgeHighlightEdge;
};
+type TimelineEdgeHighlightState = {
+ readonly edge: TimelineEdgeHighlightEdge;
+ readonly isAtLimit: boolean;
+};
+
const TimelineEdgeHighlightContext = React.createContext<{
readonly register: (
nodePathKey: string,
listener: React.Dispatch<
- React.SetStateAction<TimelineEdgeHighlightEdge | null>
+ React.SetStateAction<TimelineEdgeHighlightState | null>
>,
) => () => void;
readonly setHighlights: (
highlights: readonly TimelineEdgeHighlight[],
) => void;
+ readonly setLimitReached: (isAtLimit: boolean) => void;
} | null>(null);
export const TimelineEdgeHighlightProvider: React.FC<{
@@ -155,11 +162,11 @@ export const TimelineEdgeHighlightProvider: React.FC<{
// Keep the context value stable so highlighting boundaries does not re-render
// every timeline sequence through a context broadcast.
const value = useMemo(() => {
- let highlights = new Map<string, TimelineEdgeHighlightEdge>();
+ let highlights = new Map<string, TimelineEdgeHighlightState>();
const listeners = new Map<
string,
Set<
- React.Dispatch<React.SetStateAction<TimelineEdgeHighlightEdge | null>>
+ React.Dispatch<React.SetStateAction<TimelineEdgeHighlightState | null>>
>
>();
@@ -167,7 +174,7 @@ export const TimelineEdgeHighlightProvider: React.FC<{
register: (
nodePathKey: string,
listener: React.Dispatch<
- React.SetStateAction<TimelineEdgeHighlightEdge | null>
+ React.SetStateAction<TimelineEdgeHighlightState | null>
>,
) => {
const listenersForNodePath = listeners.get(nodePathKey) ?? new Set();
@@ -187,7 +194,7 @@ export const TimelineEdgeHighlightProvider: React.FC<{
const nextHighlightMap = new Map(
nextHighlights.map((highlight) => [
highlight.nodePathKey,
- highlight.edge,
+ {edge: highlight.edge, isAtLimit: false},
]),
);
const changedNodePathKeys = new Set([
@@ -197,7 +204,10 @@ export const TimelineEdgeHighlightProvider: React.FC<{
for (const nodePathKey of changedNodePathKeys) {
const previousEdge = highlights.get(nodePathKey) ?? null;
const nextEdge = nextHighlightMap.get(nodePathKey) ?? null;
- if (previousEdge !== nextEdge) {
+ if (
+ previousEdge?.edge !== nextEdge?.edge ||
+ previousEdge?.isAtLimit !== nextEdge?.isAtLimit
+ ) {
for (const listener of listeners.get(nodePathKey) ?? []) {
listener(nextEdge);
}
@@ -206,6 +216,16 @@ export const TimelineEdgeHighlightProvider: React.FC<{
highlights = nextHighlightMap;
},
+ setLimitReached: (isAtLimit: boolean) => {
+ for (const [nodePathKey, highlight] of highlights) {
+ if (highlight.isAtLimit === isAtLimit) continue;
+ const next = {...highlight, isAtLimit};
+ highlights.set(nodePathKey, next);
+ for (const listener of listeners.get(nodePathKey) ?? []) {
+ listener(next);
+ }
+ }
+ },
};
}, []);
@@ -327,6 +347,7 @@ const TimelineSequenceBar: React.FC<{
readonly hasCaptionsSchema: boolean;
readonly connectedComposition: _InternalTypes['AnyComposition'] | null;
readonly activeTrimEdge: 'left' | 'right' | null;
+ readonly isAtTrimLimit: boolean;
readonly leftTrimHighlight: {
readonly left: number;
readonly width: number;
@@ -368,6 +389,7 @@ const TimelineSequenceBar: React.FC<{
hasCaptionsSchema,
connectedComposition,
activeTrimEdge,
+ isAtTrimLimit,
leftTrimHighlight,
displayDurationInFrames,
selectionBounds,
@@ -457,11 +479,12 @@ const TimelineSequenceBar: React.FC<{
Math.min(1, Math.max(0, paintedEnd - paintedStart - 1))
: 0;
// Back the antialiased rounded edge only when the glow is at the painted layer edge.
+ const trimHighlightColor = isAtTrimLimit ? RED : '#00E500';
const sequenceBackground =
activeTrimEdge === null ||
(activeTrimEdge === 'left' && leftTrimHighlight?.left !== negativeStartEnd)
? style.background
- : `linear-gradient(to ${activeTrimEdge === 'left' ? 'right' : 'left'}, #00E500 0 2px, #00E50000 2px), ${style.background ?? TRANSPARENT}`;
+ : `linear-gradient(to ${activeTrimEdge === 'left' ? 'right' : 'left'}, ${trimHighlightColor} 0 2px, transparent 2px), ${style.background ?? TRANSPARENT}`;
const actualStyle: React.CSSProperties = useMemo(() => {
return {
@@ -640,7 +663,7 @@ const TimelineSequenceBar: React.FC<{
? Math.min(EDGE_DRAG_HIGHLIGHT_WIDTH, leftTrimHighlight.width)
: `min(${EDGE_DRAG_HIGHLIGHT_WIDTH}px, 100%)`,
pointerEvents: 'none',
- background: `linear-gradient(to ${activeTrimEdge === 'left' ? 'right' : 'left'}, #00E500, #00E50000)`,
+ background: `linear-gradient(to ${activeTrimEdge === 'left' ? 'right' : 'left'}, ${trimHighlightColor}, transparent)`,
}}
/>
)}
@@ -764,8 +787,10 @@ const useTimelineSequenceState = (props: TimelineSequenceProps) => {
() => createDragAwareDoubleClickTracker(),
[],
);
- const [activeEdgeHighlight, setActiveEdgeHighlight] =
- useState<TimelineEdgeHighlightEdge | null>(null);
+ const [activeHighlight, setActiveHighlight] =
+ useState<TimelineEdgeHighlightState | null>(null);
+ const activeEdgeHighlight = activeHighlight?.edge ?? null;
+ const isAtTrimLimit = activeHighlight?.isAtLimit ?? false;
const activeTrimEdge =
activeEdgeHighlight === 'source-only' ? 'left' : activeEdgeHighlight;
useEffect(() => {
@@ -775,7 +800,7 @@ const useTimelineSequenceState = (props: TimelineSequenceProps) => {
return edgeHighlightController?.register(
stringifySequenceSubscriptionKey(nodePath),
- setActiveEdgeHighlight,
+ setActiveHighlight,
);
}, [edgeHighlightController, nodePath]);
const naturalSequenceDuration = useTimelineSequenceNaturalDuration({
@@ -860,6 +885,12 @@ const useTimelineSequenceState = (props: TimelineSequenceProps) => {
},
[dragAwareDoubleClick, edgeHighlightController],
);
+ const onTrimLimitChange = useCallback(
+ (isAtLimit: boolean) => {
+ edgeHighlightController?.setLimitReached(isAtLimit);
+ },
+ [edgeHighlightController],
+ );
const mediaMetadata = useMediaMetadata(
s.type === 'audio' || s.type === 'video' ? s.src : null,
@@ -1380,10 +1411,6 @@ const useTimelineSequenceState = (props: TimelineSequenceProps) => {
const timelineVolume = keyframedTimelineVolume ?? 1;
const isMedia = s.type === 'audio' || s.type === 'video';
- const hasImplicitMediaDuration =
- (s.type === 'audio' || s.type === 'video') &&
- propStatusesForOverride?.durationInFrames?.status === 'static' &&
- propStatusesForOverride.durationInFrames.codeValue === undefined;
const durationInFramesCodeValue =
propStatusesForOverride?.durationInFrames?.status === 'static'
? propStatusesForOverride.durationInFrames.codeValue
@@ -1403,7 +1430,6 @@ const useTimelineSequenceState = (props: TimelineSequenceProps) => {
explicitDurationInFrames === null
? null
: explicitDurationInFrames / s.playbackRate,
- hasImplicitDuration: hasImplicitMediaDuration,
naturalMediaDuration,
timelineDurationInFrames: video.durationInFrames,
})
@@ -1458,6 +1484,8 @@ const useTimelineSequenceState = (props: TimelineSequenceProps) => {
dragAwareDoubleClick,
activeEdgeHighlight,
activeTrimEdge,
+ isAtTrimLimit,
+ onTrimLimitChange,
naturalSequenceDuration,
startLeftEdgeDrag,
startRightEdgeDrag,
@@ -1534,6 +1562,8 @@ const TimelineSequenceLayoutInner: React.FC<{
dragAwareDoubleClick,
activeEdgeHighlight,
activeTrimEdge,
+ isAtTrimLimit,
+ onTrimLimitChange,
naturalSequenceDuration,
startLeftEdgeDrag,
startRightEdgeDrag,
@@ -1871,6 +1901,7 @@ const TimelineSequenceLayoutInner: React.FC<{
}
connectedComposition={connectedCompositions[0] ?? null}
activeTrimEdge={activeTrimEdge}
+ isAtTrimLimit={isAtTrimLimit}
leftTrimHighlight={
visibleLayout.media?.offset === 0 ? visibleLayout.media : null
}
@@ -1923,6 +1954,7 @@ const TimelineSequenceLayoutInner: React.FC<{
fps={video.fps}
onDragStart={startLeftEdgeDrag}
onDragEnd={endEdgeDrag}
+ onLimitChange={onTrimLimitChange}
onSelect={onSelect}
selected={selected}
/>
@@ -1952,6 +1984,7 @@ const TimelineSequenceLayoutInner: React.FC<{
fps={video.fps}
onDragStart={startRightEdgeDrag}
onDragEnd={endEdgeDrag}
+ onLimitChange={onTrimLimitChange}
onSelect={onSelect}
selected={selected}
/>
diff --git a/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx b/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx
index d64e717966..83180d4780 100644
--- a/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx
+++ b/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx
@@ -58,6 +58,11 @@ import {
saveSequenceProps,
type SaveSequencePropChange,
} from './save-sequence-prop';
+import {
+ getTimelineTrimLimitReason,
+ getVisibleTimelineTrimLimitReason,
+ type TimelineTrimLimitReason,
+} from './timeline-trim-limit-reason';
import {
getTimelineSequenceSelectionKey,
shouldSelectTimelineRowOnPointerDown,
@@ -110,7 +115,6 @@ export const getTimelineSequenceMediaDurationDragLimits = ({
displayStart,
effectiveMaxMediaDuration,
explicitDurationInFrames,
- hasImplicitDuration,
naturalMediaDuration,
timelineDurationInFrames,
}: {
@@ -119,7 +123,6 @@ export const getTimelineSequenceMediaDurationDragLimits = ({
readonly displayStart: number;
readonly effectiveMaxMediaDuration: number | null;
readonly explicitDurationInFrames: number | null;
- readonly hasImplicitDuration: boolean;
readonly naturalMediaDuration: number | null;
readonly timelineDurationInFrames: number;
}): TimelineSequenceMediaDurationDragLimits | null => {
@@ -160,19 +163,13 @@ export const getTimelineSequenceMediaDurationDragLimits = ({
const initialDuration = hasInvisibleExplicitTail
? containerEdgeDuration
: (explicitDurationInFrames ?? displayedMediaEdgeDuration);
- const naturalMaximumDuration =
- // Keeping duration omitted represents the media's natural end. An
- // explicit duration is only useful once its edge is before that end.
- Math.ceil(displayStart + naturalMediaDuration - cascadedStart) -
- (hasImplicitDuration ? 1 : 0);
+ const naturalMaximumDuration = Math.ceil(
+ displayStart + naturalMediaDuration - cascadedStart,
+ );
const maximumDuration = hasInvisibleExplicitTail
? Math.min(naturalMaximumDuration, containerEdgeDuration)
: naturalMaximumDuration;
- if (hasImplicitDuration && initialDuration > maximumDuration) {
- return null;
- }
-
return {initialDuration, maximumDuration};
};
@@ -228,6 +225,8 @@ type TimelineSequenceDurationDragTargetBase = {
readonly initialDuration: number;
readonly maximumDuration: number;
readonly minimumDuration: number;
+ readonly minimumDurationReason: TimelineTrimLimitReason;
+ readonly maximumDurationReason: TimelineTrimLimitReason;
readonly nodePath: SequencePropsSubscriptionKey;
readonly schema: InteractivitySchema;
readonly endField: TimelineSequenceEndField;
@@ -1015,10 +1014,19 @@ export const getTimelineSequenceDurationDragTargets = ({
return null;
}
+ const timingLimits = getTimelineSequenceTimingLimits({
+ propStatuses,
+ movingSequenceIds: null,
+ track,
+ tracks,
+ sequences,
+ timelineDurationInFrames,
+ });
const minimumDuration = Math.max(
(track.sequence.from + 1 - track.cascadedStart) *
track.keyframePlaybackRate,
getMinimumSequenceDuration({sequence: originalSequence, sequences}),
+ timingLimits.minimumDuration,
);
const initialDuration = mediaDurationDragLimits
? mediaDurationDragLimits.initialDuration * track.keyframePlaybackRate
@@ -1055,28 +1063,25 @@ export const getTimelineSequenceDurationDragTargets = ({
}
}
- const timingLimits = getTimelineSequenceTimingLimits({
- propStatuses,
- movingSequenceIds: null,
- track,
- tracks,
- sequences,
- timelineDurationInFrames,
- });
- const constrainedMaximumDuration = Math.min(
- timingLimits.maximumDuration,
- mediaDurationDragLimits
- ? Math.max(
- initialDuration,
- mediaDurationDragLimits.maximumDuration *
- track.keyframePlaybackRate,
- )
- : Infinity,
+ const mediaMaximumDuration = mediaDurationDragLimits
+ ? Math.max(
+ initialDuration,
+ mediaDurationDragLimits.maximumDuration *
+ track.keyframePlaybackRate,
+ )
+ : Infinity;
+ const compositionMaximumDuration =
(timelineDurationInFrames - track.cascadedStart) *
- track.keyframePlaybackRate,
+ track.keyframePlaybackRate;
+ const naturalMaximumDuration =
naturalDuration !== null && naturalDuration >= minimumDuration
? naturalDuration
- : Infinity,
+ : Infinity;
+ const constrainedMaximumDuration = Math.min(
+ timingLimits.maximumDuration,
+ mediaMaximumDuration,
+ compositionMaximumDuration,
+ naturalMaximumDuration,
parentDurationLimit,
);
const maximumDuration = Math.max(
@@ -1092,6 +1097,17 @@ export const getTimelineSequenceDurationDragTargets = ({
fileName: nodePath.absolutePath,
initialDuration,
maximumDuration,
+ minimumDurationReason: timingLimits.limitReasons.minimumDuration,
+ maximumDurationReason: getTimelineTrimLimitReason(maximumDuration, [
+ [
+ timingLimits.maximumDuration,
+ timingLimits.limitReasons.maximumDuration,
+ ],
+ [mediaMaximumDuration, 'Source end'],
+ [compositionMaximumDuration, 'Composition edge'],
+ [naturalMaximumDuration, 'Content end'],
+ [parentDurationLimit, 'Parent edge'],
+ ]),
...(naturalDuration !== null && maximumDuration === naturalDuration
? {naturalDuration, initiallyExplicit: !originalSequence.autoDuration}
: {}),
@@ -1606,6 +1622,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
targetNodePaths: readonly SequencePropsSubscriptionKey[],
) => void;
readonly onDragEnd: (wasDragged: boolean) => void;
+ readonly onLimitChange: (isAtLimit: boolean) => void;
readonly onSelect: (interaction?: TimelineSelectionInteraction) => void;
readonly selected: boolean;
}> = ({
@@ -1621,6 +1638,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
fps,
onDragStart,
onDragEnd,
+ onLimitChange,
onSelect,
selected,
}) => {
@@ -1647,6 +1665,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
lastPreviewDeltaFrames: number;
previousPreviewValues: Map<string, Map<string, number>>;
lastTooltipDelta: number | null;
+ lastTooltipReason: TimelineTrimLimitReason | null;
didMove: boolean;
pxPerFrame: number;
pointerId: number;
@@ -1664,6 +1683,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
clearDragOverrides,
previewServerState,
onDragEnd,
+ onLimitChange,
onSelect,
});
latestRef.current = {
@@ -1675,6 +1695,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
clearDragOverrides,
previewServerState,
onDragEnd,
+ onLimitChange,
onSelect,
};
@@ -1830,6 +1851,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
lastPreviewDeltaFrames: 0,
previousPreviewValues: new Map(),
lastTooltipDelta: null,
+ lastTooltipReason: null,
didMove: false,
pxPerFrame: canCalculateDelta ? pxPerFrame : 1,
pointerId: e.pointerId,
@@ -1877,6 +1899,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
dragState.lastPreviewDeltaFrames = deltaFrames;
const updates: DragOverrideUpdate[] = [];
+ let limitReason: TimelineTrimLimitReason | null = null;
for (const target of dragState.targets) {
if (target.ripplePrevious) {
const previous = target.ripplePrevious;
@@ -1886,6 +1909,14 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
maximumDuration: previous.maximumDuration,
minimumDuration: previous.minimumDuration,
});
+ if (nextDuration === previous.minimumDuration)
+ limitReason ??= getVisibleTimelineTrimLimitReason(
+ previous.minimumDurationReason,
+ );
+ if (nextDuration === previous.maximumDuration)
+ limitReason ??= getVisibleTimelineTrimLimitReason(
+ previous.maximumDurationReason,
+ );
queueStaticDragOverrideIfChanged({
updates,
previousValues: dragState.previousPreviewValues,
@@ -1908,6 +1939,49 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
deltaFrames,
trimBeforeOnly: dragState.mode === 'source-only',
});
+ // Probe both directions through the same clamp, including source-only
+ // trims and parent/neighbor bounds. No separate limit math to drift.
+ const targetIsAtLimit = [-1, 1].some((direction) => {
+ const adjacent = getTimelineSequenceLeftEdgeDragValuesForTarget({
+ target,
+ deltaFrames: deltaFrames + direction / target.parentPlaybackRate,
+ trimBeforeOnly: dragState.mode === 'source-only',
+ });
+ return (
+ adjacent.durationInFrames === nextValues.durationInFrames &&
+ adjacent.from === nextValues.from &&
+ adjacent.trimBefore === nextValues.trimBefore
+ );
+ });
+ if (targetIsAtLimit) {
+ const limits = target.timingLimits;
+ const targetLimitReason =
+ dragState.mode === 'source-only'
+ ? getTimelineTrimLimitReason(nextValues.trimBefore, [
+ [
+ limits?.minimumTrimBefore ?? NaN,
+ limits?.limitReasons.minimumTrimBefore ?? null,
+ ],
+ [
+ limits?.maximumTrimBefore ?? NaN,
+ limits?.limitReasons.maximumTrimBefore ?? null,
+ ],
+ ])
+ : nextValues.durationInFrames === 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);
+ }
if (
dragState.mode !== 'source-only' &&
@@ -1944,6 +2018,7 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
});
}
+ latestRef.current.onLimitChange(limitReason !== null);
if (updates.length > 0) {
if (latestRef.current.batchSetters) {
latestRef.current.batchSetters.setDragOverridesBatch(updates);
@@ -1989,9 +2064,14 @@ const TimelineSequenceLeftEdgeDragHandleInner: React.FC<{
(draggedTarget.positionField === null && ripplePrevious === null)
? 0
: appliedDelta;
- if (dragState.lastTooltipDelta !== appliedDelta) {
+ if (
+ dragState.lastTooltipDelta !== appliedDelta ||
+ dragState.lastTooltipReason !== limitReason
+ ) {
dragState.lastTooltipDelta = appliedDelta;
+ dragState.lastTooltipReason = limitReason;
setTrimTooltip({
+ limitReason,
deltaFrames: appliedDelta,
edgeFrame: initialTimelineEdge + edgeDelta,
x:
@@ -2470,6 +2550,7 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{
targetNodePaths: readonly SequencePropsSubscriptionKey[],
) => void;
readonly onDragEnd: (wasDragged: boolean) => void;
+ readonly onLimitChange: (isAtLimit: boolean) => void;
readonly onSelect: (interaction?: TimelineSelectionInteraction) => void;
readonly selected: boolean;
}> = ({
@@ -2482,6 +2563,7 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{
fps,
onDragStart,
onDragEnd,
+ onLimitChange,
onSelect,
selected,
}) => {
@@ -2512,6 +2594,7 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{
lastPreviewDeltaFrames: number;
previousPreviewValues: Map<string, Map<string, number>>;
lastTooltipDelta: number | null;
+ lastTooltipReason: TimelineTrimLimitReason | null;
didMove: boolean;
pxPerFrame: number;
pointerId: number;
@@ -2530,6 +2613,7 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{
clearDragOverrides,
previewServerState,
onDragEnd,
+ onLimitChange,
onSelect,
updateSnapFrameRef,
});
@@ -2543,6 +2627,7 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{
clearDragOverrides,
previewServerState,
onDragEnd,
+ onLimitChange,
onSelect,
updateSnapFrameRef,
};
@@ -2682,6 +2767,7 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{
lastPreviewDeltaFrames: 0,
previousPreviewValues: new Map(),
lastTooltipDelta: null,
+ lastTooltipReason: null,
didMove: false,
pxPerFrame: canCalculateDelta ? pxPerFrame : 1,
pointerId: e.pointerId,
@@ -2723,6 +2809,7 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{
dragState.lastPreviewDeltaFrames = deltaFrames;
const updates: DragOverrideUpdate[] = [];
+ let limitReason: TimelineTrimLimitReason | null = null;
for (const target of dragState.targets) {
const previewValue = getTimelineSequenceDurationDragValue({
initialDuration: target.initialDuration,
@@ -2730,6 +2817,14 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{
maximumDuration: target.maximumDuration,
minimumDuration: target.minimumDuration,
});
+ if (previewValue === target.minimumDuration)
+ limitReason ??= getVisibleTimelineTrimLimitReason(
+ target.minimumDurationReason,
+ );
+ if (previewValue === target.maximumDuration)
+ limitReason ??= getVisibleTimelineTrimLimitReason(
+ target.maximumDurationReason,
+ );
queueStaticDragOverrideIfChanged({
updates,
@@ -2747,6 +2842,7 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{
});
}
+ latestRef.current.onLimitChange(limitReason !== null);
if (updates.length > 0) {
if (latestRef.current.batchSetters) {
latestRef.current.batchSetters.setDragOverridesBatch(updates);
@@ -2777,9 +2873,14 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{
? initialTimelineEdge + appliedDelta
: null,
);
- if (dragState.lastTooltipDelta !== appliedDelta) {
+ if (
+ dragState.lastTooltipDelta !== appliedDelta ||
+ dragState.lastTooltipReason !== limitReason
+ ) {
dragState.lastTooltipDelta = appliedDelta;
+ dragState.lastTooltipReason = limitReason;
setTrimTooltip({
+ limitReason,
deltaFrames: appliedDelta,
edgeFrame: initialTimelineEdge + appliedDelta,
x:
diff --git a/packages/studio/src/components/Timeline/TimelineTrimTooltip.tsx b/packages/studio/src/components/Timeline/TimelineTrimTooltip.tsx
index fe90f387f6..9b20536cb4 100644
--- a/packages/studio/src/components/Timeline/TimelineTrimTooltip.tsx
+++ b/packages/studio/src/components/Timeline/TimelineTrimTooltip.tsx
@@ -4,6 +4,10 @@ import {BLACK_ALPHA_85, LIGHT_TEXT, WHITE} from '../../helpers/colors';
import {renderFrame} from '../../state/render-frame';
import {useZIndex} from '../../state/z-index';
import {getPortal} from '../Menu/portals';
+import {
+ getVisibleTimelineTrimLimitReason,
+ type TimelineTrimLimitReason,
+} from './timeline-trim-limit-reason';
import {TimelineTickFormatContext} from './TimelineTickFormatProvider';
export type TimelineTrimTooltipState = {
@@ -11,6 +15,7 @@ export type TimelineTrimTooltipState = {
readonly edgeFrame: number;
readonly x: number;
readonly y: number;
+ readonly limitReason: TimelineTrimLimitReason | null;
};
const tooltip: React.CSSProperties = {
@@ -50,15 +55,27 @@ export const TimelineTrimTooltip: React.FC<{
? format(0)
: `${delta < 0 ? 'βˆ’' : '+'}${format(Math.abs(delta))}`;
const edgeLabel = format(edge);
+ const limitReason = getVisibleTimelineTrimLimitReason(state.limitReason);
const tooltipWidth = Math.max(
82,
- Math.ceil(Math.max(deltaLabel.length, edgeLabel.length) * 7 + 14),
+ Math.ceil(
+ Math.max(deltaLabel.length, edgeLabel.length, limitReason?.length ?? 0) *
+ 7 +
+ 14,
+ ),
);
+ const tooltipHeight = limitReason === null ? 36 : 50;
const left = Math.max(
8,
Math.min(state.x - tooltipWidth / 2, window.innerWidth - tooltipWidth - 8),
);
- const top = Math.max(8, Math.min(state.y - 40, window.innerHeight - 44));
+ const top = Math.max(
+ 8,
+ Math.min(
+ state.y - tooltipHeight - 4,
+ window.innerHeight - tooltipHeight - 8,
+ ),
+ );
return createPortal(
<div
@@ -67,7 +84,10 @@ export const TimelineTrimTooltip: React.FC<{
style={{...tooltip, left, top, width: tooltipWidth}}
data-remotion-timeline-trim-tooltip="true"
>
- <div style={line}>{deltaLabel}</div>
+ {limitReason === null ? null : (
+ <div style={{...line, color: WHITE}}>{limitReason}</div>
+ )}
+ <div style={{...line, color: WHITE}}>{deltaLabel}</div>
<div style={{...line, color: LIGHT_TEXT}}>{edgeLabel}</div>
</div>,
getPortal(currentZIndex),
diff --git a/packages/studio/src/components/Timeline/get-keyframe-duration-limits.ts b/packages/studio/src/components/Timeline/get-keyframe-duration-limits.ts
new file mode 100644
index 0000000000..671b0e857a
--- /dev/null
+++ b/packages/studio/src/components/Timeline/get-keyframe-duration-limits.ts
@@ -0,0 +1,243 @@
+import {
+ Internals,
+ type PropStatuses,
+ type SourceNumericValue,
+ type TSequence,
+ type VideoConfigValues,
+} from 'remotion';
+import {NoReactInternals} from 'remotion/no-react';
+import type {TimelineTrackData} from '../../helpers/get-timeline-sequence-sort-key';
+import type {TimelineTrimLimitReason} from './timeline-trim-limit-reason';
+
+const getDurationCoefficients = (
+ expression: SourceNumericValue,
+ config: VideoConfigValues,
+): {factor: number; offset: number} | null => {
+ if (typeof expression === 'number' || expression.type === 'literal') {
+ return {
+ factor: 0,
+ offset: typeof expression === 'number' ? expression : expression.value,
+ };
+ }
+
+ if (expression.type !== 'binary') {
+ if (
+ expression.binding.type !== 'video-config' ||
+ expression.binding.field !== 'durationInFrames'
+ ) {
+ return {
+ factor: 0,
+ offset: NoReactInternals.evaluateSourceNumericValue(expression, config),
+ };
+ }
+
+ return {
+ factor:
+ expression.type === 'video-config-multiplication'
+ ? expression.multiplier
+ : 1,
+ offset:
+ expression.type === 'video-config-subtraction'
+ ? -expression.subtrahend
+ : 0,
+ };
+ }
+
+ const left = getDurationCoefficients(expression.left, config);
+ const right = getDurationCoefficients(expression.right, config);
+ if (!left || !right) return null;
+ if (expression.operator === '+' || expression.operator === '-') {
+ const sign = expression.operator === '+' ? 1 : -1;
+ return {
+ factor: left.factor + sign * right.factor,
+ offset: left.offset + sign * right.offset,
+ };
+ }
+
+ if (expression.operator === '*') {
+ return left.factor !== 0 && right.factor !== 0
+ ? null
+ : {
+ factor: left.factor * right.offset + right.factor * left.offset,
+ offset: left.offset * right.offset,
+ };
+ }
+
+ return right.factor !== 0 || right.offset === 0
+ ? null
+ : {
+ factor: left.factor / right.offset,
+ offset: left.offset / right.offset,
+ };
+};
+
+export const getKeyframeDurationLimits = ({
+ sequence,
+ sequences,
+ tracks,
+ propStatuses,
+}: {
+ readonly sequence: TSequence;
+ readonly sequences: readonly TSequence[];
+ readonly tracks: readonly TimelineTrackData[];
+ readonly propStatuses: PropStatuses;
+}) => {
+ const sequencesById = new Map(sequences.map((item) => [item.id, item]));
+ const tracksById = new Map(tracks.map((item) => [item.sequence.id, item]));
+ const visited = new Set<string>();
+ let minimumEnd = -Infinity;
+ let maximumEnd = Infinity;
+ let minimumReason: TimelineTrimLimitReason | null = null;
+ let maximumReason: TimelineTrimLimitReason | null = null;
+ for (const track of tracks) {
+ const nodePath = track.nodePathInfo?.sequenceSubscriptionKey;
+ if (!nodePath) continue;
+ const status =
+ propStatuses[Internals.makeSequencePropsSubscriptionKey(nodePath)];
+ const constraints = status?.canUpdate
+ ? status.durationDependentKeyframes
+ : null;
+ if (!constraints) continue;
+
+ // A hook in the render function reads the context outside its outermost
+ // JSX element. Nested JSX sequences do not change that hook's clock.
+ let scopeTrack = track;
+ let owner = sequencesById.get(scopeTrack.sequence.parent ?? '');
+ while (owner) {
+ const parentTrack = tracksById.get(owner.id);
+ const parentPath = parentTrack?.nodePathInfo?.sequenceSubscriptionKey;
+ if (
+ !parentTrack ||
+ !parentPath ||
+ parentPath.absolutePath !== nodePath.absolutePath ||
+ !constraints.scope.every(
+ (part, index) => parentPath.nodePath[index] === part,
+ )
+ )
+ break;
+ scopeTrack = parentTrack;
+ owner = sequencesById.get(owner.parent ?? '');
+ }
+
+ if (!owner) continue;
+ const chain: TSequence[] = [];
+ let ancestor: TSequence | undefined = owner;
+ while (ancestor && ancestor.id !== sequence.id) {
+ chain.push(ancestor);
+ ancestor = sequencesById.get(ancestor.parent ?? '');
+ }
+
+ if (!ancestor) continue;
+ const key = `${owner.id}\0${nodePath.absolutePath}\0${constraints.scope.join('.')}`;
+ if (visited.has(key)) continue;
+ visited.add(key);
+ const config = scopeTrack.sequence.controls?.videoConfigValues;
+ if (!config) continue;
+
+ let minimum = -Infinity;
+ let maximum = Infinity;
+ let locked = false;
+ for (const range of constraints.inputRanges) {
+ const coefficients = range?.map((expression) =>
+ getDurationCoefficients(expression, config),
+ );
+ if (!coefficients || coefficients.some((value) => value === null)) {
+ locked = true;
+ minimum = Math.max(minimum, config.durationInFrames);
+ maximum = Math.min(maximum, config.durationInFrames);
+ continue;
+ }
+
+ for (let index = 1; index < coefficients.length; index++) {
+ const previous = coefficients[index - 1]!;
+ const current = coefficients[index]!;
+ const factor = current.factor - previous.factor;
+ const offset = current.offset - previous.offset;
+ if (
+ !Number.isFinite(factor) ||
+ !Number.isFinite(offset) ||
+ (factor === 0 && offset <= 0)
+ ) {
+ locked = true;
+ minimum = Math.max(minimum, config.durationInFrames);
+ maximum = Math.min(maximum, config.durationInFrames);
+ } else if (factor > 0) {
+ minimum = Math.max(minimum, Math.floor(-offset / factor) + 1);
+ } else if (factor < 0) {
+ maximum = Math.min(maximum, Math.ceil(-offset / factor) - 1);
+ }
+ }
+ }
+
+ for (const child of chain) {
+ const childPath = tracksById.get(child.id)?.nodePathInfo
+ ?.sequenceSubscriptionKey;
+ const childProps = childPath
+ ? Internals.getPropStatusesCtx(propStatuses, childPath)
+ : null;
+ const childConfig = child.controls?.videoConfigValues;
+ const hasDependentTiming = [
+ 'from',
+ 'durationInFrames',
+ 'trimBefore',
+ 'playbackRate',
+ ].some((field) => {
+ const prop = childProps?.[field];
+ if (!prop) return false;
+ if (prop.status !== 'static') return true;
+ if (!prop.numericExpression || !childConfig) return false;
+ const coefficients = getDurationCoefficients(
+ prop.numericExpression,
+ childConfig,
+ );
+ return !coefficients || coefficients.factor !== 0;
+ });
+ if (child.loopDisplay || hasDependentTiming) {
+ locked = true;
+ // Partial loops and duration-dependent child timings are not affine
+ // in the ancestor's end. Preserve the current safe duration.
+ minimum =
+ sequence.duration * sequence.sequencePlaybackRate +
+ (sequence.trimBefore ?? 0);
+ maximum = minimum;
+ break;
+ }
+
+ const trimBefore = child.trimBefore ?? 0;
+ const runtimeDuration =
+ child.controls?.runtimeValues.getSnapshot().durationInFrames;
+ const ownDuration =
+ typeof runtimeDuration === 'number'
+ ? runtimeDuration
+ : child.unclippedDuration !== undefined &&
+ child.unclippedDuration !== null
+ ? child.unclippedDuration * child.sequencePlaybackRate
+ : Infinity;
+ // Once a child's explicit duration caps its clock, extending an
+ // ancestor cannot cross the child's upper interpolation bound.
+ if (ownDuration + trimBefore <= maximum) maximum = Infinity;
+ minimum =
+ child.from + (minimum - trimBefore) / child.sequencePlaybackRate;
+ maximum =
+ child.from + (maximum - trimBefore) / child.sequencePlaybackRate;
+ }
+
+ if (
+ Number.isFinite(minimum) &&
+ (minimum > minimumEnd || (minimum === minimumEnd && locked))
+ ) {
+ minimumEnd = minimum;
+ minimumReason = locked ? 'Computed keyframes' : 'Keyframe constraint';
+ }
+
+ if (
+ Number.isFinite(maximum) &&
+ (maximum < maximumEnd || (maximum === maximumEnd && locked))
+ ) {
+ maximumEnd = maximum;
+ maximumReason = locked ? 'Computed keyframes' : 'Keyframe constraint';
+ }
+ }
+
+ return {minimumEnd, maximumEnd, minimumReason, maximumReason};
+};
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 872bb054f4..29d34db40d 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
@@ -7,7 +7,12 @@ import type {
import {Internals} from 'remotion';
import type {TimelineTrackData} from '../../helpers/get-timeline-sequence-sort-key';
import {getCachedMediaMetadata} from '../../helpers/use-media-metadata';
+import {getKeyframeDurationLimits} from './get-keyframe-duration-limits';
import {getTimelineSequenceNaturalDuration} from './get-timeline-sequence-natural-duration';
+import {
+ getTimelineTrimLimitReason,
+ type TimelineTrimLimitReason,
+} from './timeline-trim-limit-reason';
const {sortItemsByCommitOrder} = CanvasInternals;
const isTransitionSeriesTransition = (sequence: TSequence | undefined) =>
sequence?.controls?.componentIdentity ===
@@ -129,10 +134,27 @@ export const getTimelineSequenceTimingLimits = ({
typeof runtimeValues.trimBefore === 'number'
? runtimeValues.trimBefore
: (sequence.trimBefore ?? 0);
+ const keyframeLimits = getKeyframeDurationLimits({
+ sequence,
+ sequences,
+ tracks,
+ propStatuses,
+ });
+ const transitionMinimumDuration = getMinimumSequenceDuration({
+ sequence,
+ sequences,
+ });
+ const keyframeMinimumDuration = Math.ceil(
+ (keyframeLimits.minimumEnd - trimBefore) / sequence.sequencePlaybackRate,
+ );
+ const keyframeMaximumDuration = Math.floor(
+ (keyframeLimits.maximumEnd - trimBefore) / sequence.sequencePlaybackRate,
+ );
const minimumDuration = Math.max(
(track.sequence.from + 1 - track.cascadedStart) *
track.keyframePlaybackRate,
- getMinimumSequenceDuration({sequence, sequences}),
+ transitionMinimumDuration,
+ keyframeMinimumDuration,
);
let initialDuration =
typeof runtimeValues.durationInFrames === 'number' &&
@@ -229,6 +251,7 @@ export const getTimelineSequenceTimingLimits = ({
const reservedDuration =
inferredDuration || loops ? minimumDuration : initialDuration;
const maximumDuration = Math.min(
+ keyframeMaximumDuration,
spatialMaximumDuration,
loops
? Infinity
@@ -252,30 +275,98 @@ export const getTimelineSequenceTimingLimits = ({
? parentEnd + (initialDuration - 1) / track.keyframePlaybackRate
: parentEnd,
);
+ const minimumFrom =
+ sequence.from +
+ (minimumMoveStart - track.cascadedStart) * track.keyframePlaybackRate;
+ const minimumTrimBefore = Math.max(
+ keyframeLimits.minimumEnd - initialDuration * sequence.sequencePlaybackRate,
+ isMedia && inferredDuration && !Number.isFinite(sourceEnd)
+ ? trimBefore
+ : inferredDuration && !loops && Number.isFinite(sourceEnd)
+ ? Math.max(0, sourceEnd - spatialMaximumDuration * playbackRate)
+ : 0,
+ );
+ const maximumTrimBefore = Math.min(
+ keyframeLimits.maximumEnd - initialDuration * sequence.sequencePlaybackRate,
+ isMedia && !Number.isFinite(sourceEnd)
+ ? trimBefore
+ : Math.max(0, sourceEnd - reservedDuration * playbackRate),
+ );
+ const spatialLimitReason: TimelineTrimLimitReason =
+ maximumEnd === maximumNeighbourEnd
+ ? 'Adjacent clip'
+ : parentEnd === timelineDurationInFrames
+ ? 'Composition edge'
+ : 'Parent edge';
+ const minimumDurationReason = getTimelineTrimLimitReason(minimumDuration, [
+ [keyframeMinimumDuration, keyframeLimits.minimumReason],
+ [
+ transitionMinimumDuration,
+ transitionMinimumDuration > 1 ? 'Transition limit' : 'Minimum duration',
+ ],
+ [minimumDuration, 'Minimum duration'],
+ ]);
+ const minimumFromReason: TimelineTrimLimitReason =
+ minimumMoveStart === minimumNeighbourStart
+ ? 'Adjacent clip'
+ : sequence.parent === null
+ ? 'Composition edge'
+ : 'Parent edge';
return {
playbackRate,
minimumDuration,
maximumDuration: Math.max(minimumDuration, maximumDuration),
- minimumFrom:
- sequence.from +
- (minimumMoveStart - track.cascadedStart) * track.keyframePlaybackRate,
+ minimumFrom,
maximumFrom:
sequence.from +
(maximumMoveEnd - track.cascadedStart) * track.keyframePlaybackRate -
initialDuration,
- minimumTrimBefore:
- isMedia && inferredDuration && !Number.isFinite(sourceEnd)
- ? trimBefore
- : inferredDuration && !loops && Number.isFinite(sourceEnd)
- ? Math.max(0, sourceEnd - spatialMaximumDuration * playbackRate)
- : 0,
- maximumTrimBefore:
- isMedia && !Number.isFinite(sourceEnd)
- ? trimBefore
- : Math.max(0, sourceEnd - reservedDuration * playbackRate),
+ minimumTrimBefore,
+ maximumTrimBefore,
+ limitReasons: {
+ minimumDuration: minimumDurationReason,
+ maximumDuration: getTimelineTrimLimitReason(
+ Math.max(minimumDuration, maximumDuration),
+ [
+ [keyframeMaximumDuration, keyframeLimits.maximumReason],
+ [spatialMaximumDuration, spatialLimitReason],
+ [minimumDuration, minimumDurationReason],
+ [maximumDuration, isMedia ? 'Source end' : 'Content end'],
+ ],
+ ),
+ minimumFrom: minimumFromReason,
+ minimumTrimBefore: getTimelineTrimLimitReason(minimumTrimBefore, [
+ [
+ keyframeLimits.minimumEnd -
+ initialDuration * sequence.sequencePlaybackRate,
+ keyframeLimits.minimumReason,
+ ],
+ [0, 'Source start'],
+ [
+ minimumTrimBefore,
+ isMedia && !Number.isFinite(sourceEnd)
+ ? 'Unknown media duration'
+ : spatialLimitReason,
+ ],
+ ]),
+ maximumTrimBefore: getTimelineTrimLimitReason(maximumTrimBefore, [
+ [
+ keyframeLimits.maximumEnd -
+ initialDuration * sequence.sequencePlaybackRate,
+ keyframeLimits.maximumReason,
+ ],
+ [
+ maximumTrimBefore,
+ isMedia && !Number.isFinite(sourceEnd)
+ ? 'Unknown media duration'
+ : 'Source end',
+ ],
+ ]),
+ },
maximumTrimAfter:
inferredDuration && !loops
? Math.min(
+ keyframeLimits.maximumEnd,
sourceMaximumTrimAfter,
trimBefore + spatialMaximumDuration * playbackRate,
)
diff --git a/packages/studio/src/components/Timeline/timeline-trim-limit-reason.ts b/packages/studio/src/components/Timeline/timeline-trim-limit-reason.ts
new file mode 100644
index 0000000000..81cd555308
--- /dev/null
+++ b/packages/studio/src/components/Timeline/timeline-trim-limit-reason.ts
@@ -0,0 +1,43 @@
+export const TIMELINE_TRIM_LIMIT_REASONS = [
+ 'Keyframe constraint',
+ 'Computed keyframes',
+ 'Unknown media duration',
+ 'Minimum duration',
+ 'Transition limit',
+ 'Source start',
+ 'Source end',
+ 'Parent edge',
+ 'Composition edge',
+ 'Adjacent clip',
+ 'Content end',
+ 'Trim limit',
+] as const;
+
+export type TimelineTrimLimitReason =
+ (typeof TIMELINE_TRIM_LIMIT_REASONS)[number];
+
+export const getVisibleTimelineTrimLimitReason = (
+ reason: TimelineTrimLimitReason | null,
+): TimelineTrimLimitReason | null => {
+ return reason === 'Keyframe constraint' ||
+ reason === 'Computed keyframes' ||
+ reason === 'Unknown media duration' ||
+ reason === 'Transition limit'
+ ? reason
+ : null;
+};
+
+export const getTimelineTrimLimitReason = (
+ value: number,
+ candidates: readonly (readonly [number, TimelineTrimLimitReason | null])[],
+): TimelineTrimLimitReason => {
+ return (
+ candidates.find(
+ ([limit, reason]) =>
+ reason !== null &&
+ Number.isFinite(limit) &&
+ Math.abs(value - limit) <=
+ Number.EPSILON * Math.max(1, Math.abs(value), Math.abs(limit)) * 8,
+ )?.[1] ?? 'Trim limit'
+ );
+};
diff --git a/packages/studio/src/test/timeline-selection.test.ts b/packages/studio/src/test/timeline-selection.test.ts
index 1a2826f617..c6060ce09e 100644
--- a/packages/studio/src/test/timeline-selection.test.ts
+++ b/packages/studio/src/test/timeline-selection.test.ts
@@ -2105,6 +2105,8 @@ test('Timeline duration drag supports interactive video clips', () => {
initialDuration: 78,
maximumDuration: 1000,
minimumDuration: 1,
+ minimumDurationReason: 'Minimum duration',
+ maximumDurationReason: 'Composition edge',
nodePath: nodePathInfo.sequenceSubscriptionKey,
schema: Internals.baseSchema,
endField: {fieldKey: 'durationInFrames', trimBefore: 0, playbackRate: 1},
@@ -2256,7 +2258,6 @@ test('Media duration drag limits account for a negative from', () => {
displayDurationInFrames: 108,
displayStart: 0,
explicitDurationInFrames: 300,
- hasImplicitDuration: false,
naturalMediaDuration: 33,
timelineDurationInFrames: 1000,
};
@@ -2277,14 +2278,13 @@ test('Media duration drag limits account for a negative from', () => {
).toEqual({initialDuration: 300, maximumDuration: 225});
});
-test('Implicit media cannot be resized once its edge reaches the asset end', () => {
+test('Implicit media can be shortened once its edge reaches the asset end', () => {
const common = {
cascadedStart: -34,
displayDurationInFrames: 266,
displayStart: 0,
effectiveMaxMediaDuration: null,
explicitDurationInFrames: null,
- hasImplicitDuration: true,
timelineDurationInFrames: 300,
};
@@ -2294,14 +2294,14 @@ test('Implicit media cannot be resized once its edge reaches the asset end', ()
// The video holds its last frame until the composition ends.
naturalMediaDuration: 220,
}),
- ).toBe(null);
+ ).toEqual({initialDuration: 300, maximumDuration: 254});
expect(
getTimelineSequenceMediaDurationDragLimits({
...common,
// The composition ends before the source video does.
naturalMediaDuration: 400,
}),
- ).toEqual({initialDuration: 300, maximumDuration: 433});
+ ).toEqual({initialDuration: 300, maximumDuration: 434});
});
test('Timeline duration drag clamps explicit audio and video to the asset end', () => {