🎥 Make videos programmatically with React
import type {RequestListener} from 'node:http';
import {URLSearchParams} from 'node:url';
import {downloadAsset} from './assets/download-and-map-assets-to-file';
import type {DownloadMap} from './assets/download-map';
import type {Compositor} from './compositor/compositor';
import {makeLazyCompositor} from './compositor/compositor';
import type {LogLevel} from './log-level';
import {Log} from './logger';
import {validateOffthreadVideoCacheSizeInBytes} from './options/offthreadvideo-cache-size';
export const extractUrlAndSourceFromUrl = (url: string) => {
const parsed = new URL(url, 'http://localhost');
const query = parsed.search;
if (!query.trim()) {
throw new Error('Expected query from ' + url);
}
const params = new URLSearchParams(query);
const src = params.get('src');
if (!src) {
throw new Error('Did not pass `src` parameter');
}
const time = params.get('time');
if (!time) {
throw new Error('Did not get `time` parameter');
}
const transparent = params.get('transparent');
const toneMapped = params.get('toneMapped');
if (!toneMapped) {
throw new Error('Did not get `toneMapped` parameter');
}
return {
src,
time: parseFloat(time),
transparent: transparent === 'true',
toneMapped: toneMapped === 'true',
};
};
const REQUEST_CLOSED_TOKEN = 'Request closed';
export const startOffthreadVideoServer = ({
downloadMap,
logLevel,
indent,
offthreadVideoCacheSizeInBytes,
binariesDirectory,
offthreadVideoThreads,
}: {
downloadMap: DownloadMap;
offthreadVideoCacheSizeInBytes: number | null;
offthreadVideoThreads: number;
logLevel: LogLevel;
indent: boolean;
binariesDirectory: string | null;
}): {
listener: RequestListener;
close: () => Promise<void>;
compositor: Compositor;
} => {
validateOffthreadVideoCacheSizeInBytes(offthreadVideoCacheSizeInBytes);
const compositor = makeLazyCompositor({
extraThreads: offthreadVideoThreads,
maximumFrameCacheItemsInBytes: offthreadVideoCacheSizeInBytes,
logLevel,
indent,
binariesDirectory,
});
return {
close: () => {
return compositor.shutDownOrKill();
},
listener: (req, response) => {
if (!req.url) {
throw new Error('Request came in without URL');
}
if (!req.url.startsWith('/proxy')) {
response.writeHead(404);
response.end();
return;
}
const {src, time, transparent, toneMapped} = extractUrlAndSourceFromUrl(
req.url,
);
response.setHeader('access-control-allow-origin', '*');
// Prevent caching of the response and excessive disk writes
// https://github.com/remotion-dev/remotion/issues/2760
response.setHeader(
'cache-control',
'no-cache, no-store, must-revalidate',
);
// Handling this case on Lambda:
// https://support.google.com/chrome/a/answer/7679408?hl=en
// Chrome sends Private Network Access preflights for subresources
if (req.method === 'OPTIONS') {
response.statusCode = 200;
if (req.headers['access-control-request-private-network']) {
response.setHeader('Access-Control-Allow-Private-Network', 'true');
}
response.end();
return;
}
let closed = false;
req.on('close', () => {
closed = true;
});
let extractStart = Date.now();
downloadAsset({
src,
downloadMap,
indent,
logLevel,
binariesDirectory,
cancelSignalForAudioAnalysis: undefined,
shouldAnalyzeAudioImmediately: true,
audioStreamIndex: undefined,
})
.then((to) => {
return new Promise<Uint8Array>((resolve, reject) => {
if (closed) {
reject(Error(REQUEST_CLOSED_TOKEN));
return;
}
extractStart = Date.now();
compositor
.executeCommand('ExtractFrame', {
src: to,
original_src: src,
time,
transparent,
tone_mapped: toneMapped,
})
.then(resolve)
.catch(reject);
});
})
.then((readable) => {
return new Promise<void>((resolve, reject) => {
if (closed) {
reject(Error(REQUEST_CLOSED_TOKEN));
return;
}
if (!readable) {
reject(new Error('no readable from compositor'));
return;
}
const extractEnd = Date.now();
const timeToExtract = extractEnd - extractStart;
if (timeToExtract > 1000) {
Log.verbose(
{indent, logLevel},
`Took ${timeToExtract}ms to extract frame from ${src} at ${time}`,
);
}
const firstByte = readable.at(0);
const secondByte = readable.at(1);
const thirdByte = readable.at(2);
const isPng =
firstByte === 0x89 && secondByte === 0x50 && thirdByte === 0x4e;
const isBmp = firstByte === 0x42 && secondByte === 0x4d;
if (isPng) {
response.setHeader('content-type', `image/png`);
response.setHeader('content-length', readable.byteLength);
} else if (isBmp) {
response.setHeader('content-type', `image/bmp`);
response.setHeader('content-length', readable.byteLength);
} else {
reject(
new Error(
`Unknown file type: ${firstByte} ${secondByte} ${thirdByte}`,
),
);
return;
}
response.writeHead(200);
response.write(readable, (err) => {
response.end();
if (err) {
reject(err);
} else {
resolve();
}
});
});
})
.catch((err) => {
Log.error(
{indent, logLevel},
'Could not extract frame from compositor',
err,
);
if (response.headersSent) {
Log.error(
{indent, logLevel},
'Cannot propagate error message to client because headers have already been sent',
);
} else {
response.writeHead(500);
response.write(JSON.stringify({error: err.stack}));
}
response.end();
});
},
compositor,
};
};
type DownloadEventPayload = {
src: string;
};
type ProgressEventPayload = {
percent: number | null;
downloaded: number;
totalSize: number | null;
src: string;
};
type EventMap = {
progress: ProgressEventPayload;
download: DownloadEventPayload;
};
export type EventTypes = keyof EventMap;
export type CallbackListener<T extends EventTypes> = (data: {
detail: EventMap[T];
}) => void;
type Listeners = {
[EventType in EventTypes]: CallbackListener<EventType>[];
};
export class OffthreadVideoServerEmitter {
listeners: Listeners = {
progress: [],
download: [],
};
addEventListener<Q extends EventTypes>(
name: Q,
callback: CallbackListener<Q>,
) {
(this.listeners[name] as CallbackListener<Q>[]).push(callback);
return () => {
this.removeEventListener(name, callback);
};
}
removeEventListener<Q extends EventTypes>(
name: Q,
callback: CallbackListener<Q>,
) {
this.listeners[name] = this.listeners[name].filter(
(l) => l !== callback,
) as Listeners[Q];
}
private dispatchEvent<T extends EventTypes>(
dispatchName: T,
context: EventMap[T],
) {
(this.listeners[dispatchName] as CallbackListener<T>[]).forEach(
(callback) => {
callback({detail: context});
},
);
}
dispatchDownloadProgress(
src: string,
percent: number | null,
downloaded: number,
totalSize: number | null,
) {
this.dispatchEvent('progress', {
downloaded,
percent,
totalSize,
src,
});
}
dispatchDownload(src: string) {
this.dispatchEvent('download', {
src,
});
}
}