Skip to content

🎥 Make videos programmatically with React

6.6 KB
Raw Blame
import type {CompletedClientRender} from '@remotion/studio-shared';
import type {
	WebRendererAudioCodec,
	WebRendererContainer,
	WebRendererQuality,
} from '@remotion/web-renderer';
import {renderMediaOnWeb, renderStillOnWeb} from '@remotion/web-renderer';
import {useCallback, useContext, useEffect} from 'react';
import {
	registerClientRender,
	saveOutputFile,
} from '../../api/save-render-output';
import {getBrowserStudioOperations} from '../../helpers/browser-studio-operations';
import {downloadBlob} from '../../helpers/download-blob';
import type {
	ClientRenderJob,
	ClientRenderJobProgress,
	ClientStillRenderJob,
	ClientVideoRenderJob,
	GetBlobCallback,
} from './client-side-render-types';
import {RenderQueueContext} from './context';

type RenderResult = {
	getBlob: GetBlobCallback;
	width: number;
	height: number;
};

export const ClientRenderQueueProcessor: React.FC = () => {
	const {
		getAbortController,
		getCompositionForJob,
		updateClientJobProgress,
		markClientJobSaving,
		markClientJobDone,
		markClientJobFailed,
		markClientJobCancelled,
		setProcessJobCallback,
	} = useContext(RenderQueueContext);

	const processStillJob = useCallback(
		async (
			job: ClientStillRenderJob,
			signal: AbortSignal,
		): Promise<RenderResult> => {
			const compositionRef = getCompositionForJob(job.id);
			if (!compositionRef) {
				throw new Error(`Composition not found for job ${job.id}`);
			}

			const blob = await (
				await renderStillOnWeb({
					composition: {
						component: compositionRef.component,
						width: compositionRef.width,
						height: compositionRef.height,
						fps: compositionRef.fps,
						durationInFrames: compositionRef.durationInFrames,
						defaultProps: compositionRef.defaultProps,
						calculateMetadata: compositionRef.calculateMetadata ?? undefined,
						id: job.compositionId,
					},
					frame: job.frame,
					inputProps: job.inputProps,
					delayRenderTimeoutInMilliseconds: job.delayRenderTimeout,
					mediaCacheSizeInBytes: job.mediaCacheSizeInBytes,
					logLevel: job.logLevel,
					licenseKey: job.licenseKey ?? undefined,
					scale: job.scale,
					signal,
					allowHtmlInCanvas: job.allowHtmlInCanvas,
				})
			).blob({format: job.imageFormat});

			return {
				getBlob: () => Promise.resolve(blob),
				width: compositionRef.width,
				height: compositionRef.height,
			};
		},
		[getCompositionForJob],
	);

	const processVideoJob = useCallback(
		async (
			job: ClientVideoRenderJob,
			signal: AbortSignal,
			onProgress: (jobId: string, progress: ClientRenderJobProgress) => void,
		): Promise<RenderResult> => {
			const compositionRef = getCompositionForJob(job.id);
			if (!compositionRef) {
				throw new Error(`Composition not found for job ${job.id}`);
			}

			const totalFrames = job.endFrame - job.startFrame + 1;

			const {getBlob} = await renderMediaOnWeb({
				composition: {
					component: compositionRef.component,
					width: compositionRef.width,
					height: compositionRef.height,
					fps: compositionRef.fps,
					durationInFrames: compositionRef.durationInFrames,
					defaultProps: compositionRef.defaultProps,
					calculateMetadata: compositionRef.calculateMetadata ?? undefined,
					id: job.compositionId,
				},
				inputProps: job.inputProps,
				delayRenderTimeoutInMilliseconds: job.delayRenderTimeout,
				mediaCacheSizeInBytes: job.mediaCacheSizeInBytes,
				logLevel: job.logLevel,
				videoCodec: job.videoCodec ?? undefined,
				audioCodec: job.audioCodec as WebRendererAudioCodec,
				audioBitrate: job.audioBitrate as WebRendererQuality,
				container: job.container as WebRendererContainer,
				videoBitrate: job.videoBitrate as WebRendererQuality,
				hardwareAcceleration: job.hardwareAcceleration as
					| 'no-preference'
					| 'prefer-hardware'
					| 'prefer-software',
				keyframeIntervalInSeconds: job.keyframeIntervalInSeconds,
				frameRange: [job.startFrame, job.endFrame],
				transparent: job.transparent,
				muted: job.muted,
				scale: job.scale,
				signal,
				onProgress: (progress) => {
					onProgress(job.id, {
						encodedFrames: progress.encodedFrames,
						totalFrames,
						doneIn: progress.doneIn,
						renderEstimatedTime: progress.renderEstimatedTime,
						progress: progress.progress,
					});
				},
				outputTarget: null,
				licenseKey: job.licenseKey ?? undefined,
				pageResponsiveness: job.pageResponsiveness,
				allowHtmlInCanvas: job.allowHtmlInCanvas,
			});

			return {
				getBlob,
				width: compositionRef.width,
				height: compositionRef.height,
			};
		},
		[getCompositionForJob],
	);

	const processJob = useCallback(
		async (job: ClientRenderJob) => {
			const abortController = getAbortController(job.id);

			try {
				let result: RenderResult;

				if (job.type === 'client-still') {
					result = await processStillJob(
						job as ClientStillRenderJob,
						abortController.signal,
					);
				} else if (job.type === 'client-video') {
					result = await processVideoJob(
						job as ClientVideoRenderJob,
						abortController.signal,
						updateClientJobProgress,
					);
				} else {
					throw new Error(`Unknown job type`);
				}

				const blob = await result.getBlob();
				const metadata: CompletedClientRender['metadata'] = {
					width: result.width,
					height: result.height,
					sizeInBytes: blob.size,
				};

				markClientJobSaving(job.id);

				const getBlob = () => Promise.resolve(blob);

				const downloadAndFinish = () => {
					downloadBlob(blob, job.outName);
					markClientJobDone(job.id, metadata, getBlob);
				};

				if (
					window.remotion_isReadOnlyStudio ||
					getBrowserStudioOperations() !== null
				) {
					downloadAndFinish();
				} else {
					try {
						await saveOutputFile({blob, filePath: job.outName});
						await registerClientRender({
							id: job.id,
							type: job.type,
							compositionId: job.compositionId,
							outName: job.outName,
							startedAt: job.startedAt,
							deletedOutputLocation: false,
							metadata,
						});
						markClientJobDone(job.id, metadata);
					} catch (err) {
						// eslint-disable-next-line no-console
						console.error(
							'Failed to save render output, falling back to browser download.',
							err,
						);
						downloadAndFinish();
					}
				}
			} catch (err) {
				if (abortController.signal.aborted) {
					markClientJobCancelled(job.id);
				} else {
					markClientJobFailed(job.id, err as Error);
				}
			}
		},
		[
			getAbortController,
			processStillJob,
			processVideoJob,
			updateClientJobProgress,
			markClientJobSaving,
			markClientJobDone,
			markClientJobFailed,
			markClientJobCancelled,
		],
	);

	useEffect(() => {
		setProcessJobCallback(processJob);
		return () => setProcessJobCallback(null);
	}, [processJob, setProcessJobCallback]);

	return null;
};