🎥 Make videos programmatically with React
import type {MediaParserLogLevel, Writer} from '@remotion/media-parser';
import {
MediaParserInternals,
type MediaParserAudioSample,
type MediaParserVideoSample,
} from '@remotion/media-parser';
import {Log} from '../../log';
import {
CLUSTER_MIN_VINT_WIDTH,
createClusterSegment,
makeSimpleBlock,
} from './cluster-segment';
import {getVariableInt, matroskaToHex} from './matroska-utils';
const maxClusterTimestamp = 2 ** 15;
export const timestampToClusterTimestamp = (
timestamp: number,
timescale: number,
) => {
return Math.round((timestamp / timescale) * 1000);
};
export const canFitInCluster = ({
clusterStartTimestamp,
chunk,
timescale,
}: {
clusterStartTimestamp: number;
chunk: MediaParserAudioSample | MediaParserVideoSample;
timescale: number;
}) => {
const timecodeRelativeToCluster =
timestampToClusterTimestamp(chunk.timestamp, timescale) -
timestampToClusterTimestamp(clusterStartTimestamp, timescale);
if (timecodeRelativeToCluster < 0) {
throw new Error(
`timecodeRelativeToCluster is negative, tried to add ${chunk.timestamp} to ${clusterStartTimestamp}`,
);
}
return timecodeRelativeToCluster <= maxClusterTimestamp;
};
export const makeCluster = async ({
writer,
clusterStartTimestamp,
timescale,
logLevel,
}: {
writer: Writer;
clusterStartTimestamp: number;
timescale: number;
logLevel: MediaParserLogLevel;
}) => {
Log.verbose(
logLevel,
`Making new Matroska cluster with timestamp ${clusterStartTimestamp}`,
);
const cluster = createClusterSegment(
timestampToClusterTimestamp(clusterStartTimestamp, timescale),
);
const clusterVIntPosition =
writer.getWrittenByteCount() +
cluster.offsets.offset +
matroskaToHex(MediaParserInternals.matroskaElements.Cluster).byteLength;
let clusterSize =
cluster.bytes.byteLength -
matroskaToHex(MediaParserInternals.matroskaElements.Cluster).byteLength -
CLUSTER_MIN_VINT_WIDTH;
await writer.write(cluster.bytes);
const addSample = async (
chunk: MediaParserAudioSample | MediaParserVideoSample,
trackNumber: number,
) => {
const timecodeRelativeToCluster =
timestampToClusterTimestamp(chunk.timestamp, timescale) -
timestampToClusterTimestamp(clusterStartTimestamp, timescale);
if (!canFitInCluster({clusterStartTimestamp, chunk, timescale})) {
throw new Error(
`timecodeRelativeToCluster is too big: ${timecodeRelativeToCluster} > ${maxClusterTimestamp}`,
);
}
const keyframe = chunk.type === 'key';
const simpleBlock = makeSimpleBlock({
bytes: chunk.data,
invisible: false,
keyframe,
lacing: 0,
trackNumber,
timecodeRelativeToCluster,
});
clusterSize += simpleBlock.byteLength;
await writer.updateDataAt(
clusterVIntPosition,
getVariableInt(clusterSize, CLUSTER_MIN_VINT_WIDTH),
);
await writer.write(simpleBlock);
return {timecodeRelativeToCluster};
};
const shouldMakeNewCluster = ({
isVideo,
chunk,
newT,
}: {
newT: number;
chunk: MediaParserAudioSample | MediaParserVideoSample;
isVideo: boolean;
}) => {
const newTimestamp = timestampToClusterTimestamp(newT, timescale);
const oldTimestamp = timestampToClusterTimestamp(
clusterStartTimestamp,
timescale,
);
const canFit = canFitInCluster({
chunk,
clusterStartTimestamp,
timescale,
});
if (!canFit) {
// We must create a new cluster
// This is for example if we have an audio-only file
Log.verbose(
logLevel,
`Cannot fit ${chunk.timestamp} in cluster ${clusterStartTimestamp}. Creating new cluster`,
);
return true;
}
const keyframe = chunk.type === 'key';
// TODO: Timestamp falls apart when video only
return newTimestamp - oldTimestamp >= 2000 && keyframe && isVideo;
};
return {
addSample,
shouldMakeNewCluster,
startTimestamp: clusterStartTimestamp,
};
};