🎥 Make videos programmatically with React
import {
LambdaClientInternals,
ServerlessRoutines,
type OnStream,
type ServerlessPayload,
} from '@remotion/lambda-client';
import type {
BrowserLog,
CancelSignal,
ChromiumOptions,
HeadlessBrowser,
} from '@remotion/renderer';
import {RenderInternals} from '@remotion/renderer';
import {getCurrentRegionInFunction} from './helpers/get-current-region';
import {onDownloadsHelper} from './on-downloads-helpers';
export const renderImageSequenceChunk = async ({
params,
browser,
chromiumOptions,
serializedInputProps,
serializedResolvedProps,
expectedBucketOwner,
onStream,
logs,
cancelSignal,
}: {
params: ServerlessPayload;
browser: HeadlessBrowser;
chromiumOptions: ChromiumOptions;
serializedInputProps: string;
serializedResolvedProps: string;
expectedBucketOwner: string | null;
onStream: OnStream;
logs: BrowserLog[];
cancelSignal: CancelSignal | null;
}) => {
if (
params.type !== ServerlessRoutines.renderer ||
params.output.type !== 'sequence'
) {
throw new Error('Expected an image sequence renderer payload');
}
const {output} = params;
const start = Date.now();
await onStream({type: 'lambda-invoked', payload: {attempt: params.attempt}});
const uploadedFrames = new Set<number>();
let sizeInBytes = 0;
let progressQueue = Promise.resolve();
const artifactUploads: Promise<void>[] = [];
let artifactError: Error | null = null;
// Each worker awaits its uploads before freeing a browser page. This bounds
// the number of image buffers to concurrencyPerLambda.
await RenderInternals.internalRenderFrames({
composition: {
id: params.composition,
width: params.width,
height: params.height,
fps: params.fps,
durationInFrames: params.durationInFrames,
defaultCodec: null,
defaultOutName: null,
defaultPixelFormat: null,
defaultVideoImageFormat: null,
defaultProResProfile: null,
defaultSampleRate: null,
},
webpackBundleOrServeUrl: params.serveUrl,
serializedInputPropsWithCustomSchema: serializedInputProps,
serializedResolvedPropsWithCustomSchema: serializedResolvedProps,
puppeteerInstance: browser,
chromiumOptions,
outputDir: null,
imageFormat: output.imageFormat,
jpegQuality: params.jpegQuality ?? 80,
frameRange: params.frameRange,
frames: null,
everyNthFrame: params.everyNthFrame,
outputFramesInSequence: false,
envVariables: params.envVariables ?? {},
concurrency: params.concurrencyPerLambda,
scale: params.scale,
timeoutInMilliseconds: params.timeoutInMilliseconds,
cancelSignal: cancelSignal ?? undefined,
muted: true,
logLevel: params.logLevel,
indent: false,
onStart: null,
onFrameUpdate: null,
onFrameBuffer: async (buffer, frame) => {
await LambdaClientInternals.lambdaWriteFileImplementation({
bucketName: output.bucketName,
key: LambdaClientInternals.getImageSequenceFrameKey({...output, frame}),
body: new Uint8Array(
buffer.buffer,
buffer.byteOffset,
buffer.byteLength,
),
region: getCurrentRegionInFunction(),
privacy: params.privacy,
expectedBucketOwner,
downloadBehavior: output.downloadBehavior,
customCredentials: output.customCredentials,
forcePathStyle: params.forcePathStyle,
storageClass: output.storageClass,
requestHandler: null,
});
if (!uploadedFrames.has(frame)) {
uploadedFrames.add(frame);
sizeInBytes += buffer.length;
}
if (uploadedFrames.size % params.progressEveryNthFrame === 0) {
const uploaded = uploadedFrames.size;
const size = sizeInBytes;
progressQueue = progressQueue.then(async () => {
await onStream({
type: 'frames-rendered',
payload: {rendered: uploaded, encoded: 0},
});
await onStream({
type: 'frames-uploaded',
payload: {uploaded, sizeInBytes: size},
});
});
await progressQueue;
}
},
onFrame: null,
remotionSharedMemory: null,
onArtifact: (artifact) => {
artifactUploads.push(
onStream({
type: 'artifact-emitted',
payload: {
artifact: LambdaClientInternals.serializeArtifact(artifact),
},
}).catch((err) => {
artifactError ??= err as Error;
}),
);
},
onDownload: onDownloadsHelper(params.logLevel),
onBrowserLog: (log) => logs.push(log),
onBrowserDownload: () => {
throw new Error('Should not download a browser in a function');
},
browserExecutable: null,
port: null,
server: undefined,
parallelEncodingEnabled: false,
compositionStart: params.compositionStart,
forSeamlessAacConcatenation: false,
binariesDirectory: null,
chromeMode: 'headless-shell',
offthreadVideoCacheSizeInBytes: params.offthreadVideoCacheSizeInBytes,
offthreadVideoThreads: params.offthreadVideoThreads,
mediaCacheSizeInBytes: params.mediaCacheSizeInBytes,
imageSequencePattern: null,
sampleRate: params.sampleRate,
onLog: RenderInternals.defaultOnLog,
});
await progressQueue;
await Promise.all(artifactUploads);
if (artifactError !== null) {
throw artifactError;
}
const expectedFrames = RenderInternals.getFramesToRender(
params.frameRange,
params.everyNthFrame,
).length;
if (uploadedFrames.size !== expectedFrames) {
throw new Error(
`Expected ${expectedFrames} uploaded frames, got ${uploadedFrames.size}`,
);
}
await onStream({
type: 'frames-rendered',
payload: {rendered: uploadedFrames.size, encoded: 0},
});
await onStream({
type: 'frames-uploaded',
payload: {uploaded: uploadedFrames.size, sizeInBytes},
});
await onStream({
type: 'chunk-complete',
payload: {start, rendered: Date.now()},
});
};