🎥 Make videos programmatically with React
import type * as ff from '@google-cloud/functions-framework';
import {Storage} from '@google-cloud/storage';
import type {
ChromiumOptions,
OnArtifact,
RenderMediaOnProgress,
} from '@remotion/renderer';
import {RenderInternals} from '@remotion/renderer';
import {NoReactInternals} from 'remotion/no-react';
import {VERSION} from 'remotion/version';
import {randomHash} from '../shared/random-hash';
import {getCompositionFromBody} from './helpers/get-composition-from-body';
import {getDownloadBehaviorSetting} from './helpers/get-download-behavior-setting';
import type {
CloudRunPayloadType,
RenderMediaOnCloudrunOutput,
} from './helpers/payloads';
import {writeCloudrunError} from './helpers/write-cloudrun-error';
export const renderMediaSingleThread = async (
body: CloudRunPayloadType,
res: ff.Response,
) => {
if (body.type !== 'media') {
throw new Error('expected type media');
}
if (body.clientVersion !== VERSION) {
if (!body.clientVersion) {
throw new Error(
`Version mismatch: When calling renderMediaOnCloudRun(), you called a service which has the version ${VERSION} but the @remotion/cloudrun package is an older version. Deploy a new service with matchin version and use it to call renderMediaOnCloudRun().`,
);
}
throw new Error(
`Version mismatch: When calling renderMediaOnCloudRun(), you called a service, which has the version ${VERSION}, but the @remotion/cloudrun package you used to invoke the function has version ${body.clientVersion}. Deploy a new service and use it to call renderMediaOnCloudrun().`,
);
}
const renderId = body.renderIdOverride ?? randomHash({randomInTests: true});
try {
const composition = await getCompositionFromBody(body);
const defaultOutName = `out.${RenderInternals.getFileExtensionFromCodec(
body.codec,
body.audioCodec,
)}`;
const tempFilePath = `/tmp/${defaultOutName}`;
let previousProgress = 0.02;
let lastWebhookProgress = 0;
let writingProgress = Promise.resolve();
const onProgress: RenderMediaOnProgress = ({
progress,
renderedFrames,
encodedFrames,
}) => {
if (previousProgress !== progress) {
RenderInternals.Log.info(
{indent: false, logLevel: body.logLevel},
'Render progress:',
renderedFrames,
'frames rendered',
encodedFrames,
'frames encoded',
Math.round(progress * 100),
'%',
);
writingProgress = writingProgress.then(() => {
return new Promise((resolve) => {
res.write(JSON.stringify({onProgress: progress}) + '\n', () => {
resolve();
});
});
});
if (body.renderStatusWebhook) {
const interval =
body.renderStatusWebhook.webhookProgressInterval ?? 0.1; // Default 10% intervals
const shouldCallWebhook =
progress === 1 || // Always call on completion
lastWebhookProgress === 0 || // Always call first time
progress - lastWebhookProgress >= interval; // Call if interval exceeded
if (shouldCallWebhook) {
fetch(body.renderStatusWebhook.url, {
method: 'POST',
headers: {
...body.renderStatusWebhook.headers,
'Content-Type': 'application/json',
},
body: JSON.stringify({
...body.renderStatusWebhook.data,
progress,
renderId,
renderedFrames,
encodedFrames,
}),
}).catch((err) => {
RenderInternals.Log.warn(
{indent: false, logLevel: body.logLevel},
'Failed to call webhook:',
err,
);
});
lastWebhookProgress = progress;
}
}
previousProgress = progress;
}
};
res.writeHead(200, {'Content-Type': 'text/html'});
const actualChromiumOptions: Required<ChromiumOptions> = {
...body.chromiumOptions,
ignoreCertificateErrors:
body.chromiumOptions?.ignoreCertificateErrors ?? false,
disableWebSecurity: body.chromiumOptions?.disableWebSecurity ?? false,
headless: body.chromiumOptions?.headless ?? true,
userAgent: body.chromiumOptions?.userAgent ?? null,
darkMode: body.chromiumOptions?.darkMode ?? false,
// Override the `null` value, which might come from CLI with swANGLE
gl: body.chromiumOptions?.gl ?? 'swangle',
enableMultiProcessOnLinux: true,
};
const onArtifact: OnArtifact = () => {
throw new Error('Emitting artifacts is not supported in Cloud Run');
};
await RenderInternals.internalRenderMedia({
composition: {
...composition,
height: body.forceHeight ?? composition.height,
width: body.forceWidth ?? composition.width,
fps: body.forceFps ?? composition.fps,
durationInFrames:
body.forceDurationInFrames ?? composition.durationInFrames,
},
serveUrl: body.serveUrl,
codec: body.codec,
outputLocation: tempFilePath,
serializedInputPropsWithCustomSchema:
body.serializedInputPropsWithCustomSchema,
serializedResolvedPropsWithCustomSchema:
NoReactInternals.serializeJSONWithSpecialTypes({
data: composition.props,
indent: undefined,
staticBase: null,
}).serializedString,
jpegQuality: body.jpegQuality ?? RenderInternals.DEFAULT_JPEG_QUALITY,
audioCodec: body.audioCodec,
audioBitrate: body.audioBitrate ?? null,
videoBitrate: body.videoBitrate,
encodingMaxRate: body.encodingMaxRate,
encodingBufferSize: body.encodingBufferSize,
crf: body.crf,
pixelFormat: body.pixelFormat ?? RenderInternals.DEFAULT_PIXEL_FORMAT,
imageFormat:
body.imageFormat ?? RenderInternals.DEFAULT_VIDEO_IMAGE_FORMAT,
scale: body.scale,
proResProfile: body.proResProfile ?? undefined,
x264Preset: body.x264Preset,
gopSize: body.gopSize,
everyNthFrame: body.everyNthFrame,
numberOfGifLoops: body.numberOfGifLoops,
onProgress,
frameRange: body.frameRange,
envVariables: body.envVariables,
chromiumOptions: actualChromiumOptions,
muted: body.muted,
logLevel: body.logLevel,
browserExecutable: null,
timeoutInMilliseconds:
body.delayRenderTimeoutInMilliseconds ??
RenderInternals.DEFAULT_TIMEOUT,
cancelSignal: undefined,
concurrency: body.concurrency ?? null,
disallowParallelEncoding: false,
disableSharedMemoryCapture: body.disableSharedMemoryCapture,
enforceAudioTrack: body.enforceAudioTrack,
ffmpegOverride: undefined,
indent: false,
onBrowserLog: null,
onCtrlCExit: () => undefined,
onDownload: () => undefined,
onStart: () => undefined,
overwrite: true,
port: null,
preferLossless: body.preferLossless,
puppeteerInstance: undefined,
server: undefined,
offthreadVideoCacheSizeInBytes: body.offthreadVideoCacheSizeInBytes,
mediaCacheSizeInBytes: body.mediaCacheSizeInBytes,
offthreadVideoThreads: body.offthreadVideoThreads,
colorSpace: body.colorSpace,
repro: false,
binariesDirectory: null,
separateAudioTo: null,
forSeamlessAacConcatenation: false,
compositionStart: 0,
onBrowserDownload: () => {
throw new Error('Should not download a browser in Cloud Run');
},
onArtifact,
metadata: body.metadata ?? null,
hardwareAcceleration: 'disable',
chromeMode: 'headless-shell',
onLog: RenderInternals.defaultOnLog,
licenseKey: null,
isProduction: null,
sampleRate: body.sampleRate ?? 48000,
});
const storage = new Storage();
const publicUpload = body.privacy === 'public' || !body.privacy;
const uploadedResponse = await storage
.bucket(body.outputBucket)
.upload(tempFilePath, {
destination: `renders/${renderId}/${body.outName ?? defaultOutName}`,
predefinedAcl: publicUpload ? 'publicRead' : 'projectPrivate',
metadata: getDownloadBehaviorSetting(body.downloadBehavior),
});
const uploadedFile = uploadedResponse[0];
const renderMetadata = await uploadedFile.getMetadata();
const responseData: RenderMediaOnCloudrunOutput = {
type: 'success',
publicUrl: publicUpload ? uploadedFile.publicUrl() : null,
cloudStorageUri: uploadedFile.cloudStorageURI.href,
size: renderMetadata[0].size as number,
bucketName: body.outputBucket,
renderId,
privacy: publicUpload ? 'public-read' : 'project-private',
};
RenderInternals.Log.info(
{indent: false, logLevel: body.logLevel},
'Render Completed:',
responseData,
);
res.end(JSON.stringify({response: responseData}));
} catch (err) {
await writeCloudrunError({
bucketName: body.outputBucket,
renderId,
errorInfo: {
name: (err as Error).name as string,
message: (err as Error).message as string,
stack: (err as Error).stack as string,
type: 'renderer',
},
publicUpload: body.privacy === 'public' || !body.privacy,
});
throw err;
}
};