🎥 Make videos programmatically with React
import {useContext} from 'react';
import {getRemotionEnvironment} from './get-remotion-environment.js';
import type {LogLevel} from './log.js';
import {Log} from './log.js';
import {playbackLogging} from './playback-logging.js';
import {PreloadContext, setPreloads} from './prefetch-state.js';
export const removeAndGetHashFragment = (src: string) => {
const hashIndex = src.indexOf('#');
if (hashIndex === -1) {
return null;
}
return hashIndex;
};
export const getSrcWithoutHash = (src: string) => {
const hashIndex = removeAndGetHashFragment(src);
if (hashIndex === null) {
return src;
}
return src.slice(0, hashIndex);
};
export const usePreload = (src: string): string => {
const preloads = useContext(PreloadContext);
const hashFragmentIndex = removeAndGetHashFragment(src);
const withoutHashFragment = getSrcWithoutHash(src);
if (!preloads[withoutHashFragment]) {
return src;
}
if (hashFragmentIndex !== null) {
return preloads[withoutHashFragment] + src.slice(hashFragmentIndex);
}
return preloads[withoutHashFragment];
};
type FetchAndPreload = {
free: () => void;
waitUntilDone: () => Promise<string>;
};
const blobToBase64 = function (blob: Blob): Promise<string> {
const reader = new FileReader();
return new Promise((resolve, reject) => {
reader.onload = function () {
const dataUrl = reader.result as string;
resolve(dataUrl);
};
reader.onerror = (err) => {
return reject(err);
};
reader.readAsDataURL(blob);
});
};
export type PrefetchOnProgress = (options: {
totalBytes: number | null;
loadedBytes: number;
}) => void;
const getBlobFromReader = async ({
reader,
contentType,
contentLength,
onProgress,
}: {
reader: ReadableStreamDefaultReader<Uint8Array>;
contentType: string | null;
contentLength: number | null;
onProgress: PrefetchOnProgress | undefined;
}): Promise<Blob> => {
let receivedLength = 0;
const chunks = [];
while (true) {
const {done, value} = await reader.read();
if (done) {
break;
}
chunks.push(value);
receivedLength += value.length;
if (onProgress) {
onProgress({loadedBytes: receivedLength, totalBytes: contentLength});
}
}
const chunksAll = new Uint8Array(receivedLength);
let position = 0;
for (const chunk of chunks) {
chunksAll.set(chunk, position);
position += chunk.length;
}
return new Blob([chunksAll], {
type: contentType ?? undefined,
});
};
/*
* @description When you call the prefetch() function, an asset will be fetched and kept in memory so it is ready when you want to play it in a <Player>.
* @see [Documentation](https://www.remotion.dev/docs/prefetch)
*/
export const prefetch = (
src: string,
options?: {
method?: 'blob-url' | 'base64';
contentType?: string;
onProgress?: PrefetchOnProgress;
credentials?: RequestCredentials;
logLevel?: LogLevel;
},
): FetchAndPreload => {
const method = options?.method ?? 'blob-url';
const logLevel = options?.logLevel ?? 'info';
const srcWithoutHash = getSrcWithoutHash(src);
if (getRemotionEnvironment().isRendering) {
return {
free: () => undefined,
waitUntilDone: () => Promise.resolve(srcWithoutHash),
};
}
Log.verbose(
{logLevel, tag: 'prefetch'},
`Starting prefetch ${srcWithoutHash}`,
);
let canceled = false;
let objectUrl: string | null = null;
let resolve: (src: string) => void = () => undefined;
let reject: (err: Error) => void = () => undefined;
const waitUntilDone = new Promise<string>((res, rej) => {
resolve = res;
reject = rej;
});
waitUntilDone.catch(() => undefined);
const controller = new AbortController();
let reader: ReadableStreamDefaultReader<Uint8Array> | null = null;
fetch(srcWithoutHash, {
signal: controller.signal,
credentials: options?.credentials ?? undefined,
})
.then((res) => {
if (canceled) {
return null;
}
if (!res.ok) {
throw new Error(`HTTP error, status = ${res.status}`);
}
const headerContentType = res.headers.get('Content-Type');
const contentType = options?.contentType ?? headerContentType;
const hasProperContentType =
contentType &&
(contentType.startsWith('video/') ||
contentType.startsWith('audio/') ||
contentType.startsWith('image/'));
if (!hasProperContentType) {
// eslint-disable-next-line no-console
console.warn(
`Called prefetch() on ${srcWithoutHash} which returned a "Content-Type" of ${headerContentType}. Prefetched content should have a proper content type (video/... or audio/...) or a contentType passed the options of prefetch(). Otherwise, prefetching will not work properly in all browsers.`,
);
}
if (!res.body) {
throw new Error(`HTTP response of ${srcWithoutHash} has no body`);
}
const responseReader = res.body.getReader();
reader = responseReader;
return getBlobFromReader({
reader: responseReader,
contentType: options?.contentType ?? headerContentType ?? null,
contentLength: res.headers.get('Content-Length')
? parseInt(res.headers.get('Content-Length')!, 10)
: null,
onProgress: options?.onProgress,
});
})
.then((buf) => {
if (!buf || canceled) {
return;
}
const actualBlob = options?.contentType
? new Blob([buf], {type: options.contentType})
: buf;
if (method === 'base64') {
return blobToBase64(actualBlob);
}
return URL.createObjectURL(actualBlob);
})
.then((url) => {
if (canceled) {
return;
}
playbackLogging({
logLevel,
tag: 'prefetch',
message: `Finished prefetch ${srcWithoutHash} with method ${method}`,
mountTime: null,
});
objectUrl = url as string;
setPreloads((p) => ({
...p,
[srcWithoutHash]: objectUrl as string,
}));
resolve(objectUrl);
})
.catch((err) => {
if (err?.message.includes('free() called')) {
return;
}
reject(err);
});
return {
free: () => {
playbackLogging({
logLevel,
tag: 'prefetch',
message: `Freeing ${srcWithoutHash}`,
mountTime: null,
});
if (objectUrl) {
if (method === 'blob-url') {
URL.revokeObjectURL(objectUrl);
}
setPreloads((p) => {
const copy = {...p};
delete copy[srcWithoutHash];
return copy;
});
} else {
if (canceled) {
return;
}
canceled = true;
const cancellationError = new Error('free() called');
reject(cancellationError);
try {
controller.abort(cancellationError);
} catch {}
reader?.cancel(cancellationError).catch(() => undefined);
}
},
waitUntilDone: () => {
return waitUntilDone;
},
};
};