🎥 Make videos programmatically with React
import type {MediaParserController} from '../controller/media-parser-controller';
import type {SeekSignal} from '../controller/seek-signal';
import type {AllOptions, Options, ParseMediaFields} from '../fields';
import type {MediaParserLogLevel} from '../log';
import {Log} from '../log';
import type {ParseMediaSrc} from '../options';
import type {
MediaParserAudioSample,
MediaParserOnAudioSample,
MediaParserOnVideoSample,
MediaParserVideoSample,
OnTrackDoneCallback,
} from '../webcodec-sample-types';
import {WEBCODECS_TIMESCALE} from '../webcodecs-timescale';
import {makeCanSkipTracksState} from './can-skip-tracks';
import {makeTracksSectionState} from './has-tracks-section';
import {type KeyframesState} from './keyframes';
import {needsToIterateOverSamples} from './need-samples-for-fields';
import type {SamplesObservedState} from './samples-observed/slow-duration-fps';
import type {StructureState} from './structure';
export const callbacksState = ({
controller,
hasAudioTrackHandlers,
hasVideoTrackHandlers,
fields,
keyframes,
emittedFields,
samplesObserved,
structure,
src,
seekSignal,
logLevel,
}: {
controller: MediaParserController;
hasAudioTrackHandlers: boolean;
hasVideoTrackHandlers: boolean;
fields: Options<ParseMediaFields>;
keyframes: KeyframesState;
emittedFields: AllOptions<ParseMediaFields>;
samplesObserved: SamplesObservedState;
structure: StructureState;
src: ParseMediaSrc;
seekSignal: SeekSignal;
logLevel: MediaParserLogLevel;
}) => {
const videoSampleCallbacks: Record<number, MediaParserOnVideoSample> = {};
const audioSampleCallbacks: Record<number, MediaParserOnAudioSample> = {};
const onTrackDoneCallback: Record<number, OnTrackDoneCallback | null> = {};
const queuedAudioSamples: Record<number, MediaParserAudioSample[]> = {};
const queuedVideoSamples: Record<number, MediaParserVideoSample[]> = {};
const canSkipTracksState = makeCanSkipTracksState({
hasAudioTrackHandlers,
fields,
hasVideoTrackHandlers,
structure,
});
const tracksState = makeTracksSectionState(canSkipTracksState, src);
return {
registerVideoSampleCallback: async (
id: number,
callback: MediaParserOnVideoSample | null,
) => {
if (callback === null) {
delete videoSampleCallbacks[id];
return;
}
videoSampleCallbacks[id] = callback;
for (const queued of queuedVideoSamples[id] ?? []) {
await callback(queued);
}
queuedVideoSamples[id] = [];
},
onAudioSample: async ({
audioSample,
trackId,
}: {
trackId: number;
audioSample: MediaParserAudioSample;
}) => {
if (controller._internals.signal.aborted) {
throw new Error('Aborted');
}
const callback = audioSampleCallbacks[trackId];
if (audioSample.data.length > 0) {
// If we emit samples with data length 0, Chrome will fail
if (callback) {
if (seekSignal.getSeek() !== null) {
Log.trace(
logLevel,
'Not emitting sample because seek is processing',
);
} else {
const trackDoneCallback = await callback(audioSample);
onTrackDoneCallback[trackId] = trackDoneCallback ?? null;
}
}
}
if (needsToIterateOverSamples({emittedFields, fields})) {
samplesObserved.addAudioSample(audioSample);
}
},
onVideoSample: async ({
trackId,
videoSample,
}: {
trackId: number;
videoSample: MediaParserVideoSample;
}) => {
if (controller._internals.signal.aborted) {
throw new Error('Aborted');
}
if (videoSample.data.length > 0) {
const callback = videoSampleCallbacks[trackId];
// If we emit samples with data 0, Chrome will fail
if (callback) {
if (seekSignal.getSeek() !== null) {
Log.trace(
logLevel,
'Not emitting sample because seek is processing',
);
} else {
const trackDoneCallback = await callback(videoSample);
onTrackDoneCallback[trackId] = trackDoneCallback ?? null;
}
}
}
if (videoSample.type === 'key') {
keyframes.addKeyframe({
trackId,
decodingTimeInSeconds:
videoSample.decodingTimestamp / WEBCODECS_TIMESCALE,
positionInBytes: videoSample.offset,
presentationTimeInSeconds:
videoSample.timestamp / WEBCODECS_TIMESCALE,
sizeInBytes: videoSample.data.length,
});
}
if (
needsToIterateOverSamples({
fields,
emittedFields,
})
) {
samplesObserved.addVideoSample(videoSample);
}
},
canSkipTracksState,
registerAudioSampleCallback: async (
id: number,
callback: MediaParserOnAudioSample | null,
) => {
if (callback === null) {
delete audioSampleCallbacks[id];
return;
}
audioSampleCallbacks[id] = callback;
for (const queued of queuedAudioSamples[id] ?? []) {
await callback(queued);
}
queuedAudioSamples[id] = [];
},
tracks: tracksState,
audioSampleCallbacks,
videoSampleCallbacks,
hasAudioTrackHandlers,
hasVideoTrackHandlers,
callTracksDoneCallback: async () => {
for (const callback of Object.values(onTrackDoneCallback)) {
if (callback) {
await callback();
}
}
},
};
};
export type CallbacksState = ReturnType<typeof callbacksState>;