Skip to content

🎥 Make videos programmatically with React

`@remotion/lambda`: Render single-function media directly

Jonny Burger09f467fc6ea7
diff --git a/packages/lambda/src/test/integration/renders/muted-render.test.ts b/packages/lambda/src/test/integration/renders/muted-render.test.ts
index 470817295b..2c38544526 100644
--- a/packages/lambda/src/test/integration/renders/muted-render.test.ts
+++ b/packages/lambda/src/test/integration/renders/muted-render.test.ts
@@ -10,7 +10,7 @@ import {mockImplementation} from '../../mocks/mock-implementation';
import {getMockInvocationTypesForRender} from '../../mocks/mock-invocations';
import {simulateLambdaRender} from '../simulate-lambda-render';
-test('Should directly make a muted render with one Lambda', async () => {
+test('Should directly render final media with one Lambda', async () => {
const {close, file, progress, renderId} = await simulateLambdaRender({
codec: 'h264',
composition: 'framer',
@@ -19,7 +19,7 @@ test('Should directly make a muted render with one Lambda', async () => {
logLevel: 'verbose',
region: 'eu-central-1',
inputProps: {},
- muted: true,
+ muted: false,
concurrency: 1,
});
@@ -35,19 +35,29 @@ test('Should directly make a muted render with one Lambda', async () => {
const out = await RenderInternals.callFf({
bin: 'ffprobe',
- args: [tmpfile],
+ args: [
+ '-v',
+ 'error',
+ '-show_entries',
+ 'stream=codec_type',
+ '-of',
+ 'json',
+ tmpfile,
+ ],
indent: false,
binariesDirectory: null,
cancelSignal: undefined,
logLevel: 'error',
});
- expect(out.stdout).not.toContain('Audio');
+ expect(out.stdout).toContain('"codec_type": "video"');
+ expect(out.stdout).toContain('"codec_type": "audio"');
expect(getMockInvocationTypesForRender(renderId)).toEqual([
ServerlessRoutines.launch,
]);
expect(progress.renderMetadata?.estimatedTotalLambdaInvokations).toBe(1);
expect(progress.renderMetadata?.estimatedRenderLambdaInvokations).toBe(0);
+ expect(progress.timeToCombine).toBeNull();
const progressString = makeProgressString({
downloadInfo: null,
overall: progress,
diff --git a/packages/serverless/src/finish-render.ts b/packages/serverless/src/finish-render.ts
new file mode 100644
index 0000000000..350e08de29
--- /dev/null
+++ b/packages/serverless/src/finish-render.ts
@@ -0,0 +1,123 @@
+import fs from 'node:fs';
+import type {LogLevel} from '@remotion/renderer';
+import type {
+ CloudProvider,
+ CustomCredentials,
+ DownloadBehavior,
+ PostRenderData,
+ Privacy,
+ ProviderSpecifics,
+ RenderMetadata,
+ SerializedInputProps,
+} from '@remotion/serverless-client';
+import {inspectErrors} from '@remotion/serverless-client';
+import {cleanupProps} from './cleanup-props';
+import {createPostRenderData} from './create-post-render-data';
+import type {OverallProgressHelper} from './overall-render-progress';
+import type {InsideFunctionSpecifics} from './provider-implementation';
+
+export const finishRender = async <Provider extends CloudProvider>({
+ expectedBucketOwner,
+ renderBucketName,
+ customCredentials,
+ downloadBehavior,
+ key,
+ privacy,
+ inputProps,
+ serializedResolvedProps,
+ renderMetadata,
+ logLevel,
+ overallProgress,
+ startTime,
+ providerSpecifics,
+ insideFunctionSpecifics,
+ forcePathStyle,
+ storageClass,
+ requestHandler,
+ outputFile,
+ timeToCombine,
+}: {
+ expectedBucketOwner: string;
+ renderBucketName: string;
+ customCredentials: CustomCredentials<Provider> | null;
+ downloadBehavior: DownloadBehavior;
+ key: string;
+ privacy: Privacy;
+ inputProps: SerializedInputProps;
+ serializedResolvedProps: SerializedInputProps;
+ renderMetadata: RenderMetadata<Provider>;
+ logLevel: LogLevel;
+ overallProgress: OverallProgressHelper<Provider>;
+ startTime: number;
+ providerSpecifics: ProviderSpecifics<Provider>;
+ insideFunctionSpecifics: InsideFunctionSpecifics<Provider>;
+ forcePathStyle: boolean;
+ storageClass: Provider['storageClass'] | null;
+ requestHandler: Provider['requestHandler'] | null;
+ outputFile: string;
+ timeToCombine: number | null;
+}): Promise<PostRenderData<Provider>> => {
+ const outputSize = fs.statSync(outputFile).size;
+
+ const writeToBucket = insideFunctionSpecifics.timer(
+ `Writing to bucket (${outputSize} bytes)`,
+ logLevel,
+ );
+
+ await providerSpecifics.writeFile({
+ bucketName: renderBucketName,
+ key,
+ body: fs.createReadStream(outputFile),
+ region: insideFunctionSpecifics.getCurrentRegionInFunction(),
+ privacy,
+ expectedBucketOwner,
+ downloadBehavior,
+ customCredentials,
+ forcePathStyle,
+ storageClass,
+ requestHandler,
+ });
+
+ writeToBucket.end();
+
+ const errorExplanations = inspectErrors({
+ errors: overallProgress.get().errors,
+ });
+
+ const cleanupProm = cleanupProps({
+ inputProps,
+ serializedResolvedProps,
+ providerSpecifics,
+ forcePathStyle,
+ insideFunctionSpecifics,
+ });
+
+ const {url: outputUrl} = providerSpecifics.getOutputUrl({
+ bucketName: renderBucketName,
+ currentRegion: insideFunctionSpecifics.getCurrentRegionInFunction(),
+ customCredentials,
+ renderMetadata,
+ });
+
+ const postRenderData = createPostRenderData({
+ region: insideFunctionSpecifics.getCurrentRegionInFunction(),
+ memorySizeInMb: insideFunctionSpecifics.getCurrentMemorySizeInMb(),
+ renderMetadata,
+ errorExplanations,
+ timeToDelete: (await cleanupProm).reduce((a, b) => Math.max(a, b), 0),
+ outputFile: {
+ sizeInBytes: outputSize,
+ url: outputUrl,
+ },
+ outputSize,
+ timeToCombine,
+ overallProgress: overallProgress.get(),
+ timeToFinish: Date.now() - startTime,
+ providerSpecifics,
+ });
+
+ await overallProgress.setPostRenderData(postRenderData);
+
+ fs.unlinkSync(outputFile);
+ return postRenderData;
+};
diff --git a/packages/serverless/src/handlers/launch.ts b/packages/serverless/src/handlers/launch.ts
index ca086eea3e..a294a2f1fa 100644
--- a/packages/serverless/src/handlers/launch.ts
+++ b/packages/serverless/src/handlers/launch.ts
@@ -35,6 +35,7 @@ import {
} from '../artifact-registry';
import {cleanupProps} from '../cleanup-props';
import {findOutputFileInBucket} from '../find-output-file-in-bucket';
+import {finishRender} from '../finish-render';
import type {LaunchedBrowser} from '../get-browser-instance';
import {getTmpDirStateIfENoSp} from '../get-tmp-dir';
import {mergeChunksAndFinishRender} from '../merge-chunks';
@@ -337,11 +338,10 @@ const innerLaunchHandler = async <Provider extends CloudProvider>({
const rendererFunctionName =
params.rendererFunctionName ??
insideFunctionSpecifics.getCurrentFunctionName();
- const directRequestContext =
- params.concurrency === 1 && params.rendererFunctionName === null
- ? options.requestContext
- : null;
- const shouldRenderDirectly = directRequestContext !== null;
+ const shouldRenderDirectly =
+ params.concurrency === 1 &&
+ params.rendererFunctionName === null &&
+ options.requestContext !== null;
const renderMetadata: RenderMetadata<Provider> = {
startedDate,
@@ -422,16 +422,6 @@ const innerLaunchHandler = async <Provider extends CloudProvider>({
overallProgress.setRenderMetadata(renderMetadata);
- const outdir = join(RenderInternals.tmpDir(CONCAT_FOLDER_TOKEN), 'bucket');
- if (existsSync(outdir)) {
- rmSync(outdir, {
- recursive: true,
- });
- }
-
- mkdirSync(outdir);
-
- const files: string[] = [];
const artifactRegistry = makeArtifactRegistry();
const onArtifact: OnArtifactFromRenderer = ({artifact, chunk, attempt}) => {
@@ -506,19 +496,56 @@ const innerLaunchHandler = async <Provider extends CloudProvider>({
return artifactRegistration;
};
- if (directRequestContext) {
- await renderWithSingleFunction({
- payload: lambdaPayloads[0],
- files,
- outdir,
+ let postRenderData: PostRenderData<Provider>;
+ if (shouldRenderDirectly) {
+ const directRender = await renderWithSingleFunction({
+ params,
+ composition: comp,
+ serializedInputPropsWithCustomSchema,
+ frameRange: realFrameRange,
+ browserInstance: instance,
+ chromiumOptions: chromiumParams,
overallProgress,
onArtifact,
providerSpecifics,
insideFunctionSpecifics,
- expectedBucketOwner: options.expectedBucketOwner,
- requestContext: directRequestContext,
});
+ try {
+ postRenderData = await finishRender({
+ expectedBucketOwner: options.expectedBucketOwner,
+ renderBucketName,
+ customCredentials,
+ downloadBehavior: params.downloadBehavior,
+ key,
+ privacy: params.privacy,
+ inputProps: params.inputProps,
+ serializedResolvedProps,
+ renderMetadata,
+ logLevel: params.logLevel,
+ overallProgress,
+ startTime,
+ providerSpecifics,
+ insideFunctionSpecifics,
+ forcePathStyle: params.forcePathStyle,
+ storageClass: params.storageClass,
+ requestHandler: null,
+ outputFile: directRender.outputFile,
+ timeToCombine: null,
+ });
+ } finally {
+ await directRender.cleanup();
+ }
} else {
+ const outdir = join(RenderInternals.tmpDir(CONCAT_FOLDER_TOKEN), 'bucket');
+ if (existsSync(outdir)) {
+ rmSync(outdir, {
+ recursive: true,
+ });
+ }
+
+ mkdirSync(outdir);
+ const files: string[] = [];
+
await Promise.all(
lambdaPayloads.map(async (payload) => {
await renderRendererFunctionWithRetry({
@@ -536,47 +563,48 @@ const innerLaunchHandler = async <Provider extends CloudProvider>({
});
}),
);
- }
- const postRenderData = await mergeChunksAndFinishRender({
- bucketName: params.bucketName,
- renderId: params.renderId,
- expectedBucketOwner: options.expectedBucketOwner,
- numberOfFrames: comp.durationInFrames,
- audioCodec: params.audioCodec,
- chunkCount: chunks.length,
- codec: params.codec,
- customCredentials,
- downloadBehavior: params.downloadBehavior,
- fps,
- key,
- numberOfGifLoops: params.numberOfGifLoops,
- privacy: params.privacy,
- renderBucketName,
- inputProps: params.inputProps,
- serializedResolvedProps,
- renderMetadata,
- audioBitrate: params.audioBitrate,
- logLevel: params.logLevel,
- framesPerLambda,
- binariesDirectory: null,
- preferLossless: params.preferLossless,
- compositionStart: realFrameRange[0],
- outdir,
- files: files.sort(),
- overallProgress,
- startTime,
- providerSpecifics,
- forcePathStyle: params.forcePathStyle,
- insideFunctionSpecifics,
- everyNthFrame: params.everyNthFrame,
- frameRange: params.frameRange,
- storageClass: params.storageClass,
- requestHandler: null,
- sampleRate: params.sampleRate,
- });
+ postRenderData = await mergeChunksAndFinishRender({
+ bucketName: params.bucketName,
+ renderId: params.renderId,
+ expectedBucketOwner: options.expectedBucketOwner,
+ numberOfFrames: comp.durationInFrames,
+ audioCodec: params.audioCodec,
+ chunkCount: chunks.length,
+ codec: params.codec,
+ customCredentials,
+ downloadBehavior: params.downloadBehavior,
+ fps,
+ key,
+ numberOfGifLoops: params.numberOfGifLoops,
+ privacy: params.privacy,
+ renderBucketName,
+ inputProps: params.inputProps,
+ serializedResolvedProps,
+ renderMetadata,
+ audioBitrate: params.audioBitrate,
+ logLevel: params.logLevel,
+ framesPerLambda,
+ binariesDirectory: null,
+ preferLossless: params.preferLossless,
+ compositionStart: realFrameRange[0],
+ outdir,
+ files: files.sort(),
+ overallProgress,
+ startTime,
+ providerSpecifics,
+ forcePathStyle: params.forcePathStyle,
+ insideFunctionSpecifics,
+ everyNthFrame: params.everyNthFrame,
+ frameRange: params.frameRange,
+ storageClass: params.storageClass,
+ requestHandler: null,
+ sampleRate: params.sampleRate,
+ });
+ }
if (
+ !shouldRenderDirectly &&
providerSpecifics.getRendererFunctionTransport(
insideFunctionSpecifics.getCurrentRegionInFunction(),
) === 's3'
diff --git a/packages/serverless/src/merge-chunks.ts b/packages/serverless/src/merge-chunks.ts
index 8cf6b5ee65..e4f2e1782f 100644
--- a/packages/serverless/src/merge-chunks.ts
+++ b/packages/serverless/src/merge-chunks.ts
@@ -1,13 +1,11 @@
-import fs from 'fs';
import type {
AudioCodec,
CombineChunksOnProgress,
- SingleFrameRange,
LogLevel,
+ SingleFrameRange,
} from '@remotion/renderer';
import type {DownloadBehavior} from '@remotion/serverless-client';
import {
- inspectErrors,
type CloudProvider,
type CustomCredentials,
type PostRenderData,
@@ -17,9 +15,8 @@ import {
type SerializedInputProps,
type ServerlessCodec,
} from '@remotion/serverless-client';
-import {cleanupProps} from './cleanup-props';
import {concatVideos} from './concat-videos';
-import {createPostRenderData} from './create-post-render-data';
+import {finishRender} from './finish-render';
import type {OverallProgressHelper} from './overall-render-progress';
import type {InsideFunctionSpecifics} from './provider-implementation';
@@ -99,68 +96,28 @@ export const mergeChunksAndFinishRender = async <
const encodingStop = Date.now();
options.overallProgress.setTimeToCombine(encodingStop - encodingStart);
- const outputSize = fs.statSync(outfile).size;
-
- const writeToBucket = options.insideFunctionSpecifics.timer(
- `Writing to bucket (${outputSize} bytes)`,
- options.logLevel,
- );
-
- await options.providerSpecifics.writeFile({
- bucketName: options.renderBucketName,
- key: options.key,
- body: fs.createReadStream(outfile),
- region: options.insideFunctionSpecifics.getCurrentRegionInFunction(),
- privacy: options.privacy,
+ const postRenderData = await finishRender({
expectedBucketOwner: options.expectedBucketOwner,
- downloadBehavior: options.downloadBehavior,
+ renderBucketName: options.renderBucketName,
customCredentials: options.customCredentials,
- forcePathStyle: options.forcePathStyle,
- storageClass: options.storageClass,
- requestHandler: options.requestHandler,
- });
-
- writeToBucket.end();
-
- const errorExplanations = inspectErrors({
- errors: options.overallProgress.get().errors,
- });
-
- const cleanupProm = cleanupProps({
+ downloadBehavior: options.downloadBehavior,
+ key: options.key,
+ privacy: options.privacy,
inputProps: options.inputProps,
serializedResolvedProps: options.serializedResolvedProps,
+ renderMetadata: options.renderMetadata,
+ logLevel: options.logLevel,
+ overallProgress: options.overallProgress,
+ startTime: options.startTime,
providerSpecifics: options.providerSpecifics,
- forcePathStyle: options.forcePathStyle,
insideFunctionSpecifics: options.insideFunctionSpecifics,
- });
-
- const {url: outputUrl} = options.providerSpecifics.getOutputUrl({
- bucketName: options.renderBucketName,
- currentRegion: options.insideFunctionSpecifics.getCurrentRegionInFunction(),
- customCredentials: options.customCredentials,
- renderMetadata: options.renderMetadata,
- });
-
- const postRenderData = createPostRenderData({
- region: options.insideFunctionSpecifics.getCurrentRegionInFunction(),
- memorySizeInMb: options.insideFunctionSpecifics.getCurrentMemorySizeInMb(),
- renderMetadata: options.renderMetadata,
- errorExplanations,
- timeToDelete: (await cleanupProm).reduce((a, b) => Math.max(a, b), 0),
- outputFile: {
- sizeInBytes: outputSize,
- url: outputUrl,
- },
- outputSize,
+ forcePathStyle: options.forcePathStyle,
+ storageClass: options.storageClass,
+ requestHandler: options.requestHandler,
+ outputFile: outfile,
timeToCombine: encodingStop - encodingStart,
- overallProgress: options.overallProgress.get(),
- timeToFinish: Date.now() - options.startTime,
- providerSpecifics: options.providerSpecifics,
});
- await options.overallProgress.setPostRenderData(postRenderData);
-
- fs.unlinkSync(outfile);
await cleanupChunksProm;
return postRenderData;
};
diff --git a/packages/serverless/src/render-with-single-function.ts b/packages/serverless/src/render-with-single-function.ts
index 98ade45a4e..43acd92ee3 100644
--- a/packages/serverless/src/render-with-single-function.ts
+++ b/packages/serverless/src/render-with-single-function.ts
@@ -1,170 +1,177 @@
-import {rename} from 'node:fs/promises';
+import fs from 'node:fs';
import {join} from 'node:path';
+import {
+ makeCancelSignal,
+ renderMedia,
+ RenderInternals,
+} from '@remotion/renderer';
+import type {
+ Bitrate,
+ ChromiumOptions,
+ ResolvedFrameRange,
+} from '@remotion/renderer';
import type {
CloudProvider,
ProviderSpecifics,
ServerlessPayload,
+ VideoConfig,
} from '@remotion/serverless-client';
-import {
- deserializeArtifact,
- ServerlessRoutines,
-} from '@remotion/serverless-client';
+import {ServerlessRoutines} from '@remotion/serverless-client';
import type {OnArtifactFromRenderer} from './artifact-registry';
-import type {RequestContext} from './handlers/renderer';
-import {rendererHandler} from './handlers/renderer';
+import {startCancellationPolling} from './cancellation-polling';
+import type {LaunchedBrowser} from './get-browser-instance';
+import {onDownloadsHelper} from './on-downloads-helpers';
import type {OverallProgressHelper} from './overall-render-progress';
import type {InsideFunctionSpecifics} from './provider-implementation';
export const renderWithSingleFunction = async <Provider extends CloudProvider>({
- payload,
- files,
- outdir,
+ params,
+ composition,
+ serializedInputPropsWithCustomSchema,
+ frameRange,
+ browserInstance,
+ chromiumOptions,
overallProgress,
onArtifact,
providerSpecifics,
insideFunctionSpecifics,
- expectedBucketOwner,
- requestContext,
}: {
- payload: ServerlessPayload<Provider>;
- files: string[];
- outdir: string;
+ params: ServerlessPayload<Provider>;
+ composition: VideoConfig;
+ serializedInputPropsWithCustomSchema: string;
+ frameRange: ResolvedFrameRange;
+ browserInstance: LaunchedBrowser['instance'];
+ chromiumOptions: ChromiumOptions;
overallProgress: OverallProgressHelper<Provider>;
onArtifact: OnArtifactFromRenderer;
providerSpecifics: ProviderSpecifics<Provider>;
insideFunctionSpecifics: InsideFunctionSpecifics<Provider>;
- expectedBucketOwner: string;
- requestContext: RequestContext;
-}): Promise<void> => {
- if (payload.type !== ServerlessRoutines.renderer) {
- throw new Error('Expected renderer type');
+}): Promise<{
+ outputFile: string;
+ cleanup: () => Promise<void>;
+}> => {
+ if (params.type !== ServerlessRoutines.launch) {
+ throw new Error('Expected launch type');
}
- const rendererState: {
- error: {
- error: string;
- shouldRetry: boolean;
- } | null;
- } = {error: null};
- const renderedFiles: string[] = [];
-
- await rendererHandler({
- params: payload,
- options: {
- expectedBucketOwner,
- isWarm: true,
- },
- onStream: (message) => {
- if (message.type === 'lambda-invoked') {
- return Promise.resolve();
- }
-
- if (message.type === 'frames-rendered') {
- overallProgress.setFrames({
- index: payload.chunk,
- encoded: message.payload.encoded,
- rendered: message.payload.rendered,
- });
- return Promise.resolve();
- }
-
- if (message.type === 'chunk-complete') {
- overallProgress.addChunkCompleted(
- payload.chunk,
- message.payload.start,
- message.payload.rendered,
- );
- return Promise.resolve();
- }
+ const outputDirectory = RenderInternals.tmpDir('remotion-direct-render-');
+ const outputFile = join(
+ outputDirectory,
+ `output.${RenderInternals.getFileExtensionFromCodec(
+ params.codec,
+ params.audioCodec,
+ )}`,
+ );
+ const cleanup = () =>
+ fs.promises.rm(outputDirectory, {recursive: true, force: true});
+ const frameCount = RenderInternals.getFramesToRender(
+ frameRange,
+ params.everyNthFrame,
+ ).length;
+ const startedAt = Date.now();
+ const {cancel, cancelSignal} = makeCancelSignal();
+ const stopCancellationPolling = params.enableCancellation
+ ? startCancellationPolling({
+ bucketName: params.bucketName,
+ renderId: params.renderId,
+ region: insideFunctionSpecifics.getCurrentRegionInFunction(),
+ providerSpecifics,
+ forcePathStyle: params.forcePathStyle,
+ intervalInMilliseconds: 1000,
+ logLevel: params.logLevel,
+ onCancelled: cancel,
+ })
+ : () => undefined;
- if (message.type === 'artifact-emitted') {
- const artifact = deserializeArtifact(message.payload.artifact);
+ try {
+ await renderMedia({
+ composition,
+ serveUrl: params.serveUrl,
+ codec: params.codec,
+ outputLocation: outputFile,
+ inputProps: JSON.parse(serializedInputPropsWithCustomSchema) as Record<
+ string,
+ unknown
+ >,
+ imageFormat: params.imageFormat,
+ frameRange,
+ concurrency: params.concurrencyPerFunction,
+ puppeteerInstance: browserInstance,
+ jpegQuality: params.jpegQuality ?? RenderInternals.DEFAULT_JPEG_QUALITY,
+ envVariables: params.envVariables ?? {},
+ logLevel: params.logLevel,
+ crf: params.crf,
+ pixelFormat: params.pixelFormat ?? undefined,
+ proResProfile: params.proResProfile ?? undefined,
+ x264Preset: params.x264Preset,
+ gopSize: params.gopSize ?? null,
+ onDownload: onDownloadsHelper(params.logLevel),
+ overwrite: true,
+ chromiumOptions,
+ scale: params.scale,
+ timeoutInMilliseconds: params.timeoutInMilliseconds,
+ everyNthFrame: params.everyNthFrame,
+ numberOfGifLoops: params.numberOfGifLoops,
+ muted: params.muted,
+ enforceAudioTrack: true,
+ audioBitrate: params.audioBitrate as Bitrate | null,
+ videoBitrate: params.videoBitrate as Bitrate | null,
+ encodingBufferSize: params.encodingBufferSize as Bitrate | null,
+ encodingMaxRate: params.encodingMaxRate as Bitrate | null,
+ audioCodec: params.audioCodec,
+ preferLossless: params.preferLossless,
+ browserExecutable: providerSpecifics.getChromiumPath(),
+ cancelSignal: params.enableCancellation ? cancelSignal : undefined,
+ disallowParallelEncoding: false,
+ offthreadVideoCacheSizeInBytes: params.offthreadVideoCacheSizeInBytes,
+ colorSpace: params.colorSpace ?? undefined,
+ repro: false,
+ binariesDirectory: null,
+ onBrowserDownload: () => {
+ throw new Error('Should not download a browser in Lambda');
+ },
+ onArtifact: (artifact) => {
const registration = onArtifact({
artifact,
- chunk: payload.chunk,
- attempt: payload.attempt,
+ chunk: 0,
+ attempt: 1,
});
if (registration.type === 'conflict') {
- rendererState.error = {
- error: `Chunk ${payload.chunk} emitted an asset filename ${artifact.filename} at frame ${artifact.frame} but there is already another artifact with the same name. https://remotion.dev/docs/artifacts`,
- shouldRetry: false,
- };
+ throw new Error(
+ `The artifact filename ${artifact.filename} was emitted more than once. https://remotion.dev/docs/artifacts`,
+ );
}
-
- return Promise.resolve();
- }
-
- if (message.type === 'error-occurred') {
- overallProgress.addErrorWithoutUpload(message.payload.errorInfo);
+ },
+ metadata: params.metadata,
+ hardwareAcceleration: 'disable',
+ chromeMode: 'headless-shell',
+ offthreadVideoThreads: params.offthreadVideoThreads,
+ mediaCacheSizeInBytes: params.mediaCacheSizeInBytes,
+ licenseKey: null,
+ isProduction: false,
+ sampleRate: params.sampleRate,
+ onProgress: ({renderedFrames, encodedFrames}) => {
overallProgress.setFrames({
- encoded: 0,
- index: payload.chunk,
- rendered: 0,
+ index: 0,
+ rendered: renderedFrames,
+ encoded: encodedFrames,
});
- rendererState.error = {
- error: message.payload.error,
- shouldRetry: message.payload.shouldRetry,
- };
- return Promise.resolve();
- }
-
- throw new Error(`Unexpected ${message.type} event from direct renderer`);
- },
- requestContext,
- providerSpecifics,
- insideFunctionSpecifics,
- executionMode: 'direct',
- onMediaFiles: async ({
- videoOutputLocation,
- audioOutputLocation,
- isAudioOnly,
- }) => {
- const chunkName = `chunk:${String(payload.chunk).padStart(8, '0')}`;
- const videoDestination = join(outdir, `${chunkName}:video`);
- const audioDestination = join(outdir, `${chunkName}:audio`);
-
- if (isAudioOnly) {
- await rename(videoOutputLocation, audioDestination);
- renderedFiles.push(audioDestination);
- return;
- }
-
- await rename(videoOutputLocation, videoDestination);
- renderedFiles.push(videoDestination);
- if (audioOutputLocation) {
- await rename(audioOutputLocation, audioDestination);
- renderedFiles.push(audioDestination);
- }
- },
- });
-
- if (rendererState.error) {
- if (!rendererState.error.shouldRetry || payload.retriesLeft <= 0) {
- throw new Error(rendererState.error.error);
- }
-
- overallProgress.addRetry({
- attempt: payload.attempt + 1,
- time: Date.now(),
- chunk: payload.chunk,
- });
- await renderWithSingleFunction({
- payload: {
- ...payload,
- attempt: payload.attempt + 1,
- retriesLeft: payload.retriesLeft - 1,
},
- files,
- outdir,
- overallProgress,
- onArtifact,
- providerSpecifics,
- insideFunctionSpecifics,
- expectedBucketOwner,
- requestContext,
});
- return;
- }
- files.push(...renderedFiles);
+ overallProgress.setFrames({
+ index: 0,
+ rendered: frameCount,
+ encoded: frameCount,
+ });
+ overallProgress.addChunkCompleted(0, startedAt, Date.now());
+ overallProgress.setCombinedFrames(frameCount);
+
+ return {outputFile, cleanup};
+ } catch (err) {
+ await cleanup();
+ throw err;
+ } finally {
+ stopCancellationPolling();
+ }
};