Skip to content

🎥 Make videos programmatically with React

4.9 KB
Raw Blame
import clsx from 'clsx';
import {FastAverageColor} from 'fast-average-color';
import React, {
	useCallback,
	useEffect,
	useImperativeHandle,
	useRef,
	useState,
} from 'react';
import {setFileDragData} from '~/lib/file-drag';
import {useIsNarrow} from '~/lib/is-narrow';

export const THUMBNAIL_HEIGHT = Math.round((350 / 16) * 9);

type Props = {
	readonly smallThumbOnMobile: boolean;
	readonly userRotation: number;
	readonly trackRotation: number | null;
	readonly mirrorHorizontal: boolean;
	readonly mirrorVertical: boolean;
	readonly initialReveal: boolean;
	readonly draggableFile?: File | null;
	readonly draggableFileName?: string | null;
};

export type VideoThumbnailRef = {
	draw: (videoFrame: VideoFrame) => void;
	onDone: () => void;
	copy: () => Promise<ImageBitmap>;
	hasBitmap: boolean;
	addOnChangeListener: (listener: () => void) => void;
	removeOnChangeListener: (listener: () => void) => void;
};

const VideoThumbnailRefForward: React.ForwardRefRenderFunction<
	VideoThumbnailRef,
	Props
> = (
	{
		smallThumbOnMobile,
		userRotation,
		trackRotation,
		mirrorHorizontal,
		mirrorVertical,
		initialReveal,
		draggableFile = null,
		draggableFileName = null,
	},
	forwardedRef,
) => {
	const ref = useRef<HTMLCanvasElement>(null);

	const [color, setColor] = useState<string>('transparent');
	const [dimensions, setDimensions] = useState<{width: number}>({width: 350});
	const [reveal, setReveal] = useState(initialReveal);
	const [drawn, setDrawn] = useState(false);
	const [needsRotation, setNeedsRotation] = useState(false);
	const [dragObjectUrl, setDragObjectUrl] = useState<string | null>(null);

	useEffect(() => {
		if (!draggableFile) {
			setDragObjectUrl(null);
			return;
		}

		try {
			const objectUrl = URL.createObjectURL(draggableFile);
			setDragObjectUrl(objectUrl);
			return () => URL.revokeObjectURL(objectUrl);
		} catch {
			setDragObjectUrl(null);
		}
	}, [draggableFile]);

	const onChangeListeners = useRef<(() => void)[]>([]);

	const drawThumbnail = useCallback((unrotatedVideoFrame: VideoFrame) => {
		const scaleRatio = THUMBNAIL_HEIGHT / unrotatedVideoFrame.displayHeight;
		const w = Math.round(unrotatedVideoFrame.displayWidth * scaleRatio);
		setDimensions({width: w});

		const canvas = ref.current;
		if (!canvas) {
			return;
		}

		canvas.width = w;
		const twoDContext = canvas.getContext('2d');
		if (!twoDContext) {
			return;
		}

		twoDContext.drawImage(unrotatedVideoFrame, 0, 0, w, THUMBNAIL_HEIGHT);
		setColor((c) => {
			if (c !== 'transparent') {
				return c;
			}

			return new FastAverageColor().getColor(canvas).hex;
		});
		setDrawn(true);
		setNeedsRotation(!('rotation' in unrotatedVideoFrame));
	}, []);

	useImperativeHandle(
		forwardedRef,
		() => ({
			draw: drawThumbnail,
			onDone: () => {
				onChangeListeners.current.forEach((l) => l());
				setReveal(true);
			},
			copy: () => {
				const canvas = ref.current;
				if (!canvas) {
					throw new Error('Canvas not ready');
				}

				return createImageBitmap(canvas);
			},
			addOnChangeListener(listener) {
				onChangeListeners.current.push(listener);
			},
			removeOnChangeListener(listener) {
				onChangeListeners.current = onChangeListeners.current.filter(
					(l) => l !== listener,
				);
			},
			hasBitmap: drawn,
		}),
		[drawThumbnail, drawn],
	);

	const isNarrow = useIsNarrow();

	const scale = isNarrow && smallThumbOnMobile ? 0.5 : 1;

	const rotation =
		userRotation - (needsRotation ? 0 - (trackRotation ?? 0) : 0);

	const scaleTransform =
		rotation % 90 === 0 && rotation % 180 !== 0
			? THUMBNAIL_HEIGHT / dimensions.width
			: 1;

	const canDrag = draggableFile !== null && dragObjectUrl !== null;
	const onDragStart = useCallback(
		(event: React.DragEvent<HTMLDivElement>) => {
			if (
				!draggableFile ||
				!dragObjectUrl ||
				!setFileDragData({
					dataTransfer: event.dataTransfer,
					file: draggableFile,
					fileName: draggableFileName ?? draggableFile.name,
					objectUrl: dragObjectUrl,
				})
			) {
				event.preventDefault();
			}
		},
		[dragObjectUrl, draggableFile, draggableFileName],
	);

	return (
		<div
			className={clsx(
				isNarrow && smallThumbOnMobile ? 'border-r-2' : 'border-b-2',
				'border-black overflow-hidden bg-slate-100',
				canDrag && 'cursor-grab active:cursor-grabbing',
			)}
			draggable={canDrag || undefined}
			onDragStart={canDrag ? onDragStart : undefined}
			// +2 to account for border
			style={{height: THUMBNAIL_HEIGHT * scale + 2}}
		>
			<div
				className="flex justify-center transition-opacity"
				style={{backgroundColor: color, opacity: reveal && drawn ? 1 : 0}}
			>
				<canvas
					ref={ref}
					height={THUMBNAIL_HEIGHT}
					style={{
						maxHeight: THUMBNAIL_HEIGHT * scale,
						width: dimensions.width * scale,
						transform: `scale(${scaleTransform * (mirrorHorizontal ? -1 : 1)}, ${scaleTransform * (mirrorVertical ? -1 : 1)}) rotate(${rotation}deg)`,
						transition: 'transform 0.3s',
					}}
				/>
			</div>
		</div>
	);
};

export const VideoThumbnail = React.forwardRef(VideoThumbnailRefForward);