🎥 Make videos programmatically with React
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;
};