Skip to content

🎥 Make videos programmatically with React

14.4 KB
Raw Blame
import {Audio, Video} from '@remotion/media';
import type {Size} from '@remotion/player';
import {PlayerInternals} from '@remotion/player';
import React, {
	useCallback,
	useContext,
	useEffect,
	useLayoutEffect,
	useMemo,
	useRef,
	useState,
} from 'react';
import {createPortal} from 'react-dom';
import type {CanvasContent} from 'remotion';
import {Internals, staticFile} from 'remotion';
import {ErrorLoader} from '../error-overlay/remotion-overlay/ErrorLoader';
import {addAssetCacheBust} from '../helpers/add-asset-cache-bust';
import {
	checkerboardBackgroundColor,
	checkerboardBackgroundImage,
	getCheckerboardBackgroundPos,
	getCheckerboardBackgroundSize,
} from '../helpers/checkerboard-background';
import {LIGHT_TEXT, RULER_COLOR} from '../helpers/colors';
import type {AssetMetadata} from '../helpers/get-asset-metadata';
import {getPreviewFileType} from '../helpers/get-preview-file-type';
import type {Dimensions} from '../helpers/is-current-selected-still';
import {calculateStudioCanvasTransformation} from '../helpers/studio-fit-padding';
import {AudioFileIcon} from '../icons/audio';
import {CheckerboardContext} from '../state/checkerboard';
import {EditorShowPixelGridContext} from '../state/editor-pixel-grid';
import {VERTICAL_SCROLLBAR_CLASSNAME} from './Menu/is-menu-item';
import {RenderPreview} from './RenderPreview';
import {SelectedOutlineOverlay} from './SelectedOutlineOverlay';
import {Spinner} from './Spinner';
import {StaticFilePreview} from './StaticFilePreview';
import {shouldClearSelectionOnPointerDown} from './Timeline/should-clear-selection-on-pointer-down';
import {useCurrentTimelineSelectionStateAsRef} from './Timeline/TimelineSelection';

const centeredContainer: React.CSSProperties = {
	display: 'flex',
	flex: 1,
	justifyContent: 'center',
	alignItems: 'center',
};

const label: React.CSSProperties = {
	fontFamily: 'sans-serif',
	fontSize: 14,
	color: LIGHT_TEXT,
};

const assetMetadataErrorContainer: React.CSSProperties = {
	marginLeft: 'auto',
	marginRight: 'auto',
	width: '100%',
	position: 'absolute',
	height: '100%',
	overflowY: 'auto',
};

const checkerboardSize = 49;
const PIXEL_GRID_MIN_SCALE = 4;

const containerStyle = (options: {
	scale: number;
	xCorrection: number;
	yCorrection: number;
	width: number;
	height: number;
	checkerboard: boolean;
}): React.CSSProperties => {
	return {
		transform: `scale(${options.scale})`,
		// Keep the scaled composition on its own layer so the checkerboard does
		// not bleed through its edges at fractional preview scales.
		willChange: 'transform',
		marginLeft: options.xCorrection,
		marginTop: options.yCorrection,
		width: options.width,
		height: options.height,
		display: 'flex',
		overflow: 'hidden',
		position: 'absolute',
		backgroundColor: checkerboardBackgroundColor(options.checkerboard),
		backgroundImage: checkerboardBackgroundImage(options.checkerboard),
		backgroundSize:
			getCheckerboardBackgroundSize(checkerboardSize) /* Must be a square */,
		backgroundPosition:
			getCheckerboardBackgroundPos(
				checkerboardSize,
			) /* Must be half of one side of the square */,
	};
};

const PixelGrid: React.FC<{
	readonly scale: number;
}> = ({scale}) => {
	const {editorShowPixelGrid} = useContext(EditorShowPixelGridContext);

	if (!editorShowPixelGrid || scale < PIXEL_GRID_MIN_SCALE) {
		return null;
	}

	return (
		<div
			aria-hidden="true"
			className="css-reset"
			data-testid="pixel-grid"
			style={{
				position: 'absolute',
				inset: 0,
				pointerEvents: 'none',
				opacity: 0.35,
				backgroundImage: `linear-gradient(to right, ${RULER_COLOR} 1px, transparent 1px), linear-gradient(to bottom, ${RULER_COLOR} 1px, transparent 1px)`,
				backgroundSize: `${scale}px ${scale}px`,
			}}
		/>
	);
};

export const VideoPreview: React.FC<{
	readonly canvasSize: Size;
	readonly contentDimensions: Dimensions | 'none' | null;
	readonly canvasContent: CanvasContent;
	readonly assetMetadata: AssetMetadata | null;
	readonly onRetryAssetMetadata?: () => void;
}> = ({
	canvasSize,
	contentDimensions,
	canvasContent,
	assetMetadata,
	onRetryAssetMetadata,
}) => {
	if (assetMetadata && assetMetadata.type === 'not-found') {
		return (
			<div style={centeredContainer}>
				<div style={label}>File does not exist</div>
			</div>
		);
	}

	if (assetMetadata && assetMetadata.type === 'metadata-error') {
		return (
			<div
				style={assetMetadataErrorContainer}
				className={VERTICAL_SCROLLBAR_CLASSNAME}
			>
				<ErrorLoader
					key={assetMetadata.error.stack}
					canHaveDismissButton={false}
					keyboardShortcuts={false}
					error={assetMetadata.error}
					onRetry={onRetryAssetMetadata ?? null}
					calculateMetadata={false}
				/>
			</div>
		);
	}

	if (
		contentDimensions === null ||
		(canvasContent.type !== 'composition' && assetMetadata === null)
	) {
		return (
			<div style={centeredContainer}>
				<Spinner duration={0.5} size={24} />
			</div>
		);
	}

	return (
		<CompWhenItHasDimensions
			contentDimensions={contentDimensions}
			canvasSize={canvasSize}
			canvasContent={canvasContent}
			assetMetadata={assetMetadata}
		/>
	);
};

const CompWhenItHasDimensions: React.FC<{
	readonly contentDimensions: Dimensions | 'none';
	readonly canvasSize: Size;
	readonly canvasContent: CanvasContent;
	readonly assetMetadata: AssetMetadata | null;
}> = ({contentDimensions, canvasSize, canvasContent, assetMetadata}) => {
	const {size: previewSize} = useContext(Internals.PreviewSizeContext);
	const {currentAssetMetadata} = useContext(Internals.CompositionManager);
	const [canvasHovered, setCanvasHovered] = useState(false);
	const compositionContainerRef = useRef<HTMLDivElement>(null);
	useEffect(() => {
		const compositionContainer = compositionContainerRef.current;
		if (compositionContainer === null) {
			setCanvasHovered(false);
			return;
		}

		const onPointerEnter = () => setCanvasHovered(true);
		const onPointerLeave = () => setCanvasHovered(false);
		const onDragOver = (event: DragEvent) => {
			const rect = compositionContainer.getBoundingClientRect();
			setCanvasHovered(
				event.clientX >= rect.left &&
					event.clientX <= rect.right &&
					event.clientY >= rect.top &&
					event.clientY <= rect.bottom,
			);
		};

		const onDragLeave = (event: DragEvent) => {
			if (
				event.relatedTarget instanceof Node &&
				compositionContainer.contains(event.relatedTarget)
			) {
				return;
			}

			onDragOver(event);
		};

		const onDragEnd = () => {
			requestAnimationFrame(() =>
				setCanvasHovered(compositionContainer.matches(':hover')),
			);
		};

		setCanvasHovered(compositionContainer.matches(':hover'));
		compositionContainer.addEventListener('pointerenter', onPointerEnter);
		compositionContainer.addEventListener('pointerleave', onPointerLeave);
		document.addEventListener('dragenter', onDragOver, {capture: true});
		document.addEventListener('dragover', onDragOver, {capture: true});
		document.addEventListener('dragleave', onDragLeave, {capture: true});
		document.addEventListener('drop', onDragEnd, {capture: true});
		document.addEventListener('dragend', onDragEnd, {capture: true});

		return () => {
			compositionContainer.removeEventListener('pointerenter', onPointerEnter);
			compositionContainer.removeEventListener('pointerleave', onPointerLeave);
			document.removeEventListener('dragenter', onDragOver, {capture: true});
			document.removeEventListener('dragover', onDragOver, {capture: true});
			document.removeEventListener('dragleave', onDragLeave, {capture: true});
			document.removeEventListener('drop', onDragEnd, {capture: true});
			document.removeEventListener('dragend', onDragEnd, {capture: true});
		};
	}, [canvasContent.type]);

	const {centerX, centerY, yCorrection, xCorrection, scale} = useMemo(() => {
		if (contentDimensions === 'none') {
			return {
				centerX: 0,
				centerY: 0,
				yCorrection: 0,
				xCorrection: 0,
				scale: 1,
			};
		}

		return canvasContent.type === 'composition'
			? calculateStudioCanvasTransformation({
					canvasSize,
					compositionHeight: contentDimensions.height,
					compositionWidth: contentDimensions.width,
					previewSize: previewSize.size,
				})
			: PlayerInternals.calculateCanvasTransformation({
					canvasSize,
					compositionHeight: contentDimensions.height,
					compositionWidth: contentDimensions.width,
					previewSize: previewSize.size,
				});
	}, [canvasContent.type, canvasSize, contentDimensions, previewSize.size]);
	const assetFileType =
		canvasContent.type === 'asset'
			? getPreviewFileType(canvasContent.asset)
			: null;
	const mediaCompositionFileType =
		(assetFileType === 'audio' || assetFileType === 'video') &&
		assetMetadata?.type === 'found' &&
		assetMetadata.mediaMetadata !== null &&
		canvasContent.type === 'asset' &&
		currentAssetMetadata?.asset === canvasContent.asset &&
		contentDimensions !== 'none'
			? assetFileType
			: null;

	const outer: React.CSSProperties = useMemo(() => {
		return {
			width:
				contentDimensions === 'none' ? '100%' : contentDimensions.width * scale,
			height:
				contentDimensions === 'none'
					? '100%'
					: contentDimensions.height * scale,
			display: 'flex',
			flexDirection: 'column',
			position: 'absolute',
			left: centerX - previewSize.translation.x,
			top: centerY - previewSize.translation.y,
			overflow: canvasContent.type === 'composition' ? 'visible' : 'hidden',
			justifyContent:
				canvasContent.type === 'asset' && mediaCompositionFileType === null
					? 'center'
					: 'flex-start',
			alignItems:
				canvasContent.type === 'asset' &&
				mediaCompositionFileType === null &&
				assetFileType === 'audio'
					? 'center'
					: 'normal',
		};
	}, [
		contentDimensions,
		scale,
		centerX,
		previewSize.translation.x,
		previewSize.translation.y,
		centerY,
		canvasContent,
		mediaCompositionFileType,
		assetFileType,
	]);

	if (canvasContent.type === 'asset') {
		if (
			mediaCompositionFileType !== null &&
			assetMetadata?.type === 'found' &&
			contentDimensions !== 'none'
		) {
			return (
				<div
					ref={compositionContainerRef}
					className="remotion-studio-composition-container"
					style={outer}
				>
					{mediaCompositionFileType === 'audio' ? (
						<AudioFileIcon
							aria-label="Audio asset"
							color={LIGHT_TEXT}
							role="img"
							style={{
								height: 64,
								left: '50%',
								opacity: 0.25,
								pointerEvents: 'none',
								position: 'absolute',
								top: '50%',
								transform: 'translate(-50%, -50%)',
								width: 64,
							}}
						/>
					) : null}
					<PortalContainer
						contentDimensions={contentDimensions}
						offscreen={mediaCompositionFileType === 'audio'}
						scale={scale}
						xCorrection={xCorrection}
						yCorrection={yCorrection}
					/>
					<AssetMediaComposition
						asset={canvasContent.asset}
						fetchedAt={assetMetadata.fetchedAt}
						fileType={mediaCompositionFileType}
					/>
				</div>
			);
		}

		return (
			<div style={outer}>
				<StaticFilePreview
					assetMetadata={assetMetadata}
					currentAsset={canvasContent.asset}
				/>
			</div>
		);
	}

	if (canvasContent.type === 'output') {
		return (
			<div style={outer}>
				<RenderPreview
					path={canvasContent.path}
					assetMetadata={assetMetadata}
				/>
			</div>
		);
	}

	if (canvasContent.type === 'output-blob') {
		return (
			<div style={outer}>
				<RenderPreview
					path={canvasContent.displayName}
					assetMetadata={assetMetadata}
					getBlob={canvasContent.getBlob}
				/>
			</div>
		);
	}

	return (
		<div
			ref={compositionContainerRef}
			className="remotion-studio-composition-container"
			style={outer}
		>
			<PortalContainer
				contentDimensions={contentDimensions as Dimensions}
				offscreen={false}
				scale={scale}
				xCorrection={xCorrection}
				yCorrection={yCorrection}
			/>
			<PixelGrid scale={scale} />
			<SelectedOutlineOverlay
				canvasHovered={canvasHovered}
				compositionHeight={(contentDimensions as Dimensions).height}
				compositionWidth={(contentDimensions as Dimensions).width}
				scale={scale}
			/>
		</div>
	);
};

const AssetMediaComposition: React.FC<{
	readonly asset: string;
	readonly fetchedAt: number;
	readonly fileType: 'audio' | 'video';
}> = ({asset, fetchedAt, fileType}) => {
	const src = addAssetCacheBust({
		fetchedAt,
		src: staticFile(asset),
	});
	const style: React.CSSProperties = {
		width: '100%',
		height: '100%',
	};

	return createPortal(
		<Internals.CanUseRemotionHooksProvider>
			<Internals.DisableInteractivityProvider>
				<div data-testid="asset-media-preview" style={style}>
					{fileType === 'video' ? (
						<Video name={asset} src={src} style={style} />
					) : (
						<Audio name={asset} src={src} />
					)}
				</div>
			</Internals.DisableInteractivityProvider>
		</Internals.CanUseRemotionHooksProvider>,
		Internals.portalNode(),
	);
};

const PortalContainer: React.FC<{
	readonly offscreen: boolean;
	readonly scale: number;
	readonly xCorrection: number;
	readonly yCorrection: number;
	readonly contentDimensions: Dimensions;
}> = ({offscreen, scale, xCorrection, yCorrection, contentDimensions}) => {
	const {checkerboard} = useContext(CheckerboardContext);
	const currentSelection = useCurrentTimelineSelectionStateAsRef();
	const portalContainer = useRef<HTMLDivElement>(null);

	const style = useMemo((): React.CSSProperties => {
		if (offscreen) {
			return {
				height: contentDimensions.height,
				left: -999999,
				overflow: 'hidden',
				position: 'fixed',
				top: 0,
				width: contentDimensions.width,
			};
		}

		return containerStyle({
			checkerboard,
			scale,
			xCorrection,
			yCorrection,
			width: contentDimensions.width,
			height: contentDimensions.height,
		});
	}, [
		checkerboard,
		contentDimensions.height,
		contentDimensions.width,
		offscreen,
		scale,
		xCorrection,
		yCorrection,
	]);

	useLayoutEffect(() => {
		const {current} = portalContainer;
		current?.appendChild(Internals.portalNode());

		return () => {
			const portalNode = Internals.portalNode();
			if (current && portalNode.parentNode === current) {
				current.removeChild(portalNode);
				Internals.setPortalNodeCurrentScale(1);
			}
		};
	}, []);

	useLayoutEffect(() => {
		Internals.setPortalNodeCurrentScale(scale);
	}, [scale]);

	const onPointerDown = useCallback(
		(event: PointerEvent) => {
			if (!shouldClearSelectionOnPointerDown(event)) {
				return;
			}

			currentSelection.current.clearSelection();
		},
		[currentSelection],
	);

	useEffect(() => {
		const {current} = portalContainer;
		if (!current) {
			return;
		}

		current.addEventListener('pointerdown', onPointerDown);

		return () => {
			current.removeEventListener('pointerdown', onPointerDown);
		};
	}, [onPointerDown]);

	return <div ref={portalContainer} style={style} />;
};