🎥 Make videos programmatically with React
import type {MediaParserLogLevel} from '@remotion/media-parser';
import type {FlushPending} from './flush-pending';
import {makeFlushPending} from './flush-pending';
import {makeIoSynchronizer} from './io-manager/io-synchronizer';
import {VideoUndecodableError} from './undecodable-error';
import type {WebCodecsController} from './webcodecs-controller';
export type WebCodecsVideoDecoder = {
decode: (
videoSample: EncodedVideoChunkInit | EncodedVideoChunk,
) => Promise<void>;
close: () => void;
flush: () => Promise<void>;
waitForQueueToBeLessThan: (items: number) => Promise<void>;
reset: () => void;
checkReset: () => {
wasReset: () => boolean;
};
getMostRecentSampleInput: () => number | null;
};
export const internalCreateVideoDecoder = async ({
onFrame,
onError,
controller,
config,
logLevel,
}: {
onFrame: (frame: VideoFrame) => Promise<void> | void;
onError: (error: Error) => void;
controller: WebCodecsController | null;
config: VideoDecoderConfig;
logLevel: MediaParserLogLevel;
}): Promise<WebCodecsVideoDecoder> => {
if (
controller &&
controller._internals._mediaParserController._internals.signal.aborted
) {
throw new Error('Not creating audio decoder, already aborted');
}
const ioSynchronizer = makeIoSynchronizer({
logLevel,
label: 'Video decoder',
controller,
});
let mostRecentSampleReceived: number | null = null;
const videoDecoder = new VideoDecoder({
async output(frame) {
try {
await onFrame(frame);
} catch (err) {
onError(err as Error);
frame.close();
}
ioSynchronizer.onOutput(frame.timestamp);
},
error(error) {
onError(error);
},
});
const close = () => {
if (controller) {
controller._internals._mediaParserController._internals.signal.removeEventListener(
'abort',
// eslint-disable-next-line @typescript-eslint/no-use-before-define
onAbort,
);
}
if (videoDecoder.state === 'closed') {
return;
}
videoDecoder.close();
};
const onAbort = () => {
close();
};
if (controller) {
controller._internals._mediaParserController._internals.signal.addEventListener(
'abort',
onAbort,
);
}
const isConfigSupported = await VideoDecoder.isConfigSupported(config);
if (!isConfigSupported) {
throw new VideoUndecodableError({
message: 'Video cannot be decoded by this browser',
config,
});
}
videoDecoder.configure(config);
const decode = async (sample: EncodedVideoChunkInit | EncodedVideoChunk) => {
if (videoDecoder.state === 'closed') {
return;
}
try {
await controller?._internals._mediaParserController._internals.checkForAbortAndPause();
} catch (err) {
onError(err as Error);
return;
}
mostRecentSampleReceived = sample.timestamp;
const encodedChunk =
sample instanceof EncodedVideoChunk
? sample
: new EncodedVideoChunk(sample);
videoDecoder.decode(encodedChunk);
ioSynchronizer.inputItem(sample.timestamp);
};
let flushPending: FlushPending | null = null;
let lastReset: number | null = null;
return {
decode,
close,
flush: () => {
if (flushPending) {
throw new Error('Flush already pending');
}
const pendingFlush = makeFlushPending();
flushPending = pendingFlush;
Promise.resolve()
.then(() => {
return videoDecoder.flush();
})
.catch(() => {
// Firefox might throw "Needs to be configured first"
})
.finally(() => {
pendingFlush.resolve();
flushPending = null;
});
return pendingFlush.promise;
},
waitForQueueToBeLessThan: ioSynchronizer.waitForQueueSize,
reset: () => {
lastReset = Date.now();
flushPending?.resolve();
ioSynchronizer.clearQueue();
videoDecoder.reset();
videoDecoder.configure(config);
},
checkReset: () => {
const initTime = Date.now();
return {
wasReset: () => lastReset !== null && lastReset > initTime,
};
},
getMostRecentSampleInput() {
return mostRecentSampleReceived;
},
};
};
/**
* @deprecated Use Mediabunny instead: https://www.remotion.dev/docs/mediabunny
*/
export const createVideoDecoder = ({
onFrame,
onError,
controller,
track,
logLevel,
}: {
track: VideoDecoderConfig;
onFrame: (frame: VideoFrame) => Promise<void> | void;
onError: (error: Error) => void;
controller?: WebCodecsController;
logLevel?: MediaParserLogLevel;
}): Promise<WebCodecsVideoDecoder> => {
return internalCreateVideoDecoder({
onFrame,
onError,
controller: controller ?? null,
config: track,
logLevel: logLevel ?? 'info',
});
};