π₯ Make videos programmatically with React
import type {MediaParserLogLevel} from '../log';
import {Log} from '../log';
import type {ParseMediaMode} from '../options';
import type {OffsetCounter} from './offset-counter';
import {ResizableBuffer} from './polyfilled-arraybuffer';
const makeBufferWithMaxBytes = (initialData: Uint8Array, maxBytes: number) => {
const maxByteLength = Math.min(maxBytes, 2 ** 31);
try {
const buf = new ArrayBuffer(initialData.byteLength, {
maxByteLength,
});
return new ResizableBuffer(buf);
} catch (e) {
// Cloudflare Workers have a limit of 128MB max array buffer size
if (e instanceof RangeError && maxBytes > 2 ** 27) {
return new ResizableBuffer(
new ArrayBuffer(initialData.byteLength, {
maxByteLength: 2 ** 27,
}),
);
}
throw e;
}
};
export const bufferManager = ({
initialData,
maxBytes,
counter,
logLevel,
}: {
initialData: Uint8Array;
maxBytes: number;
counter: OffsetCounter;
logLevel: MediaParserLogLevel;
}) => {
const buf = makeBufferWithMaxBytes(initialData, maxBytes);
if (!buf.buffer.resize) {
Log.warn(
logLevel,
'`ArrayBuffer.resize` is not supported in this Runtime. Using slow polyfill.',
);
}
buf.uintarray.set(initialData);
let view = new DataView(buf.uintarray.buffer);
const destroy = () => {
buf.uintarray = new Uint8Array(0);
buf.resize(0);
};
const flushBytesRead = (force: boolean, mode: ParseMediaMode) => {
const bytesToRemove = counter.getDiscardedOffset();
// Only do this operation if it is really worth it π
// let's set the threshold to 3MB
if (bytesToRemove < 3_000_000 && !force) {
return {bytesRemoved: 0, removedData: null};
}
// Don't remove if the data is not even available
if (view.byteLength < bytesToRemove && !force) {
return {bytesRemoved: 0, removedData: null};
}
counter.discardBytes(bytesToRemove);
const removedData =
mode === 'download' ? buf.uintarray.slice(0, bytesToRemove) : null;
const newData = buf.uintarray.slice(bytesToRemove);
buf.uintarray.set(newData);
buf.resize(newData.byteLength);
view = new DataView(buf.uintarray.buffer);
return {bytesRemoved: bytesToRemove, removedData};
};
const skipTo = (offset: number) => {
const becomesSmaller = offset < counter.getOffset();
if (becomesSmaller) {
const toDecrement = counter.getOffset() - offset;
if (toDecrement > counter.getDiscardedOffset()) {
throw new Error(
'Cannot count backwards, data has already been flushed',
);
}
counter.decrement(toDecrement);
}
const currentOffset = counter.getOffset();
counter.increment(offset - currentOffset);
};
const addData = (newData: Uint8Array) => {
const oldLength = buf.buffer.byteLength;
const newLength = oldLength + newData.byteLength;
if (newLength < oldLength) {
throw new Error('Cannot decrement size');
}
if (newLength > (maxBytes ?? Infinity)) {
throw new Error(
`Exceeded maximum byte length ${maxBytes} with ${newLength}`,
);
}
buf.resize(newLength);
buf.uintarray = new Uint8Array(buf.buffer);
buf.uintarray.set(newData, oldLength);
view = new DataView(buf.uintarray.buffer);
};
const replaceData = (newData: Uint8Array, seekTo: number) => {
buf.resize(newData.byteLength);
buf.uintarray = new Uint8Array(buf.buffer);
buf.uintarray.set(newData);
view = new DataView(buf.uintarray.buffer);
counter.setDiscardedOffset(seekTo);
// reset counter to 0
counter.decrement(counter.getOffset());
// seek to the new position
counter.increment(seekTo);
};
return {
getView: () => view,
getUint8Array: () => buf.uintarray,
destroy,
addData,
skipTo,
removeBytesRead: flushBytesRead,
replaceData,
};
};