Skip to content

🎥 Make videos programmatically with React

7.2 KB
Raw Blame
import {hasSequenceTimingTraits} from '@remotion/studio-shared';
import type {
	CanUpdateSequencePropStatus,
	PropStatuses,
	TSequence,
} from 'remotion';
import {Internals} from 'remotion';
import type {
	SequenceNodePathInfo,
	TimelineTrackData,
} from '../../helpers/get-timeline-sequence-sort-key';
import {showNotification} from '../Notifications/NotificationCenter';
import {splitSequences as splitSequencesApi} from '../split-sequences-api';
import {findTrackForNodePathInfo} from './find-track-for-node-path-info';
import type {TimelineSelection} from './TimelineSelection';

export type SplitTimelineSequenceEligibility =
	| {
			canSplit: true;
			nodePathInfo: SequenceNodePathInfo;
	  }
	| {
			canSplit: false;
			reason: string;
	  };

type SplitPropStatuses = Partial<
	Record<
		'from' | 'durationInFrames' | 'trimBefore',
		CanUpdateSequencePropStatus
	>
>;

export const getSequenceSourceSplitFrame = ({
	timelineFrame,
	keyframeDisplayOffset,
	keyframePlaybackRate,
}: {
	readonly timelineFrame: number;
	readonly keyframeDisplayOffset: TimelineTrackData['keyframeDisplayOffset'];
	readonly keyframePlaybackRate: TimelineTrackData['keyframePlaybackRate'];
}): number => {
	return (timelineFrame - keyframeDisplayOffset) * keyframePlaybackRate;
};

const staticNumberish = (
	status: CanUpdateSequencePropStatus | undefined,
): boolean => {
	if (!status) {
		return true;
	}

	return (
		status.status === 'static' &&
		(typeof status.codeValue === 'number' || status.codeValue === undefined)
	);
};

export const getTimelineSequenceSplitEligibility = ({
	selection,
	sequence,
	splitFrame,
	propStatuses,
}: {
	selection: TimelineSelection;
	sequence: TSequence | null;
	splitFrame: number;
	propStatuses?: SplitPropStatuses;
}): SplitTimelineSequenceEligibility => {
	if (selection.type !== 'sequence') {
		return {
			canSplit: false,
			reason: 'Select one sequence to split',
		};
	}

	if (!sequence) {
		return {
			canSplit: false,
			reason: 'Could not find selected sequence',
		};
	}

	if (
		sequence.timelineTrack?.role === 'track' ||
		sequence.controls?.componentIdentity === 'dev.remotion.remotion.Track'
	) {
		return {
			canSplit: false,
			reason: 'Track containers cannot be split from the Studio',
		};
	}

	if (!Number.isInteger(splitFrame)) {
		return {
			canSplit: false,
			reason: 'Split frame must be an integer',
		};
	}

	if (sequence.isInsideSeries) {
		return {
			canSplit: false,
			reason: 'Series.Sequence clips cannot be split from source',
		};
	}

	// `trimBefore` is both where playback starts and where the loop restarts,
	// so the right half could not resume mid-cycle.
	if (sequence.loopDisplay) {
		return {
			canSplit: false,
			reason: 'Looping sequences cannot be split',
		};
	}

	if (
		!hasSequenceTimingTraits(
			selection.nodePathInfo.sequenceSubscriptionKey.sequenceKeys,
		)
	) {
		return {
			canSplit: false,
			reason: 'Sequence does not expose timing traits that can be split',
		};
	}

	const {nodePathInfo} = selection;
	if (!nodePathInfo.sequenceSubscriptionKey.nodePath) {
		return {
			canSplit: false,
			reason: 'Sequence has no editable source node',
		};
	}

	if (nodePathInfo.numberOfSequencesWithThisNodePath > 1) {
		return {
			canSplit: false,
			reason: 'Programmatically duplicated sequences cannot be split',
		};
	}

	if (
		!staticNumberish(propStatuses?.from) ||
		!staticNumberish(propStatuses?.durationInFrames) ||
		!staticNumberish(propStatuses?.trimBefore)
	) {
		return {
			canSplit: false,
			reason: 'Sequence timing props must be static numbers',
		};
	}

	const start = sequence.from;
	const end =
		sequence.duration === Infinity
			? Infinity
			: sequence.from + sequence.duration;

	if (splitFrame <= start) {
		return {
			canSplit: false,
			reason: 'Cannot split at the sequence start',
		};
	}

	if (splitFrame >= end) {
		return {
			canSplit: false,
			reason: 'Cannot split at the sequence end',
		};
	}

	return {
		canSplit: true,
		nodePathInfo,
	};
};

export const splitTimelineSequenceFromSource = ({
	nodePathInfo,
	splitFrame,
}: {
	nodePathInfo: SequenceNodePathInfo;
	splitFrame: number;
}): Promise<boolean> => {
	return splitTimelineSequencesFromSource({
		sequences: [{nodePathInfo, splitFrame}],
	});
};

export const splitTimelineSequencesFromSource = ({
	sequences,
}: {
	sequences: Array<{
		nodePathInfo: SequenceNodePathInfo;
		splitFrame: number;
	}>;
}): Promise<boolean> => {
	return splitSequencesApi({
		sequences: sequences.map(({nodePathInfo, splitFrame}) => {
			const nodePath = nodePathInfo.sequenceSubscriptionKey;
			return {
				fileName: nodePath.absolutePath,
				nodePath: nodePath.nodePath,
				sequenceKeys: nodePath.sequenceKeys,
				splitFrame,
				videoConfigValues: nodePath.videoConfigValues,
			};
		}),
	})
		.then((result) => {
			if (result.success) {
				return true;
			}

			showNotification(result.reason, 4000);
			return false;
		})
		.catch((err) => {
			showNotification((err as Error).message, 4000);
			return false;
		});
};

export const splitSelectedTimelineItems = ({
	selections,
	tracks,
	propStatuses,
	splitFrame,
	splitSequences = splitTimelineSequencesFromSource,
	notify = showNotification,
}: {
	selections: readonly TimelineSelection[];
	readonly tracks: readonly TimelineTrackData[];
	propStatuses: PropStatuses | undefined;
	splitFrame: number;
	splitSequences?: (options: {
		sequences: Array<{
			nodePathInfo: SequenceNodePathInfo;
			splitFrame: number;
		}>;
	}) => Promise<boolean>;
	notify?: (message: string, durationInMs: number) => void;
}): Promise<boolean> | null => {
	if (
		selections.length === 0 ||
		selections.some((selection) => selection.type !== 'sequence')
	) {
		return null;
	}

	const eligible: Array<{
		nodePathInfo: SequenceNodePathInfo;
		splitFrame: number;
	}> = [];
	const skippedReasons: string[] = [];
	for (const selection of selections) {
		if (selection.type !== 'sequence') {
			continue;
		}

		const track = findTrackForNodePathInfo({
			tracks,
			nodePathInfo: selection.nodePathInfo,
		});
		const sequencePropStatuses = propStatuses
			? Internals.getPropStatusesCtx(
					propStatuses,
					selection.nodePathInfo.sequenceSubscriptionKey,
				)
			: undefined;
		const eligibility = getTimelineSequenceSplitEligibility({
			selection,
			sequence: track?.sequence ?? null,
			splitFrame,
			propStatuses: sequencePropStatuses,
		});
		if (eligibility.canSplit) {
			eligible.push({
				nodePathInfo: eligibility.nodePathInfo,
				splitFrame: track
					? getSequenceSourceSplitFrame({
							timelineFrame: splitFrame,
							keyframeDisplayOffset: track.keyframeDisplayOffset,
							keyframePlaybackRate: track.keyframePlaybackRate,
						})
					: splitFrame,
			});
		} else {
			skippedReasons.push(eligibility.reason);
		}
	}

	if (eligible.length === 0) {
		notify(
			selections.length === 1
				? skippedReasons[0]
				: `None of the ${selections.length} selected clips can be split at the playhead`,
			4000,
		);
		return Promise.resolve(false);
	}

	return splitSequences({sequences: eligible}).then((success) => {
		if (success && skippedReasons.length > 0) {
			notify(
				`Split ${eligible.length} ${eligible.length === 1 ? 'clip' : 'clips'}. Skipped ${skippedReasons.length} ${skippedReasons.length === 1 ? 'clip' : 'clips'} that could not be split.`,
				4000,
			);
		}

		return success;
	});
};