🎥 Make videos programmatically with React
import type {MediaParserCodecData} from './codec-data';
import type {
MediaParserMatrixCoefficients,
MediaParserPrimaries,
MediaParserTransferCharacteristics,
} from './containers/avc/color';
import {makeBaseMediaTrack} from './containers/iso-base-media/make-track';
import {findTrackStartTimeInSeconds} from './containers/iso-base-media/mdat/get-editlist';
import type {MoovBox} from './containers/iso-base-media/moov/moov';
import type {TrakBox} from './containers/iso-base-media/trak/trak';
import {
getMoovBoxFromState,
getMvhdBox,
getTraks,
} from './containers/iso-base-media/traversal';
import {
getTracksFromAvi,
hasAllTracksFromAvi,
} from './containers/riff/get-tracks-from-avi';
import {
getTracksFromTransportStream,
hasAllTracksFromTransportStream,
} from './containers/transport-stream/get-tracks';
import {
getTracksFromMatroska,
matroskaHasTracks,
} from './containers/webm/get-ready-tracks';
import type {M3uPlaylistContext} from './options';
import type {IsoBaseMediaState} from './state/iso-base-media/iso-state';
import type {ParserState} from './state/parser-state';
import type {StructureState} from './state/structure';
export type MediaParserSampleAspectRatio = {
numerator: number;
denominator: number;
};
export type MediaParserAdvancedColor = {
transfer: MediaParserTransferCharacteristics | null;
matrix: MediaParserMatrixCoefficients | null;
primaries: MediaParserPrimaries | null;
fullRange: boolean | null;
};
export type MediaParserVideoCodec =
| 'vp8'
| 'vp9'
| 'h264'
| 'av1'
| 'h265'
| 'prores';
export type MediaParserAudioCodec =
| 'opus'
| 'aac'
| 'mp3'
| 'ac3'
| 'vorbis'
| 'pcm-u8'
| 'pcm-s16'
| 'pcm-s24'
| 'pcm-s32'
| 'pcm-f32'
| 'flac'
| 'aiff';
export type MediaParserVideoTrack = {
// WebCodecs
codec: string;
description: Uint8Array | undefined;
colorSpace: VideoColorSpaceInit;
codedWidth: number;
codedHeight: number;
displayAspectWidth: number;
displayAspectHeight: number;
// Non-WebCodecs
type: 'video';
trackId: number;
codecEnum: MediaParserVideoCodec;
codecData: MediaParserCodecData | null;
sampleAspectRatio: MediaParserSampleAspectRatio;
width: number;
height: number;
rotation: number;
fps: number | null;
timescale: 1_000_000;
originalTimescale: number;
advancedColor: MediaParserAdvancedColor;
m3uStreamFormat: 'ts' | 'mp4' | null;
startInSeconds: number;
trackMediaTimeOffsetInTrackTimescale: number;
};
export type MediaParserAudioTrack = {
// WebCodecs
codec: string;
sampleRate: number;
description: Uint8Array | undefined;
numberOfChannels: number;
// Non-WebCodecs
type: 'audio';
trackId: number;
codecEnum: MediaParserAudioCodec;
timescale: 1_000_000;
originalTimescale: number;
codecData: MediaParserCodecData | null;
startInSeconds: number;
trackMediaTimeOffsetInTrackTimescale: number;
};
export type MediaParserOtherTrack = {
type: 'other';
trackId: number;
timescale: 1_000_000;
originalTimescale: number;
trakBox: TrakBox | null;
startInSeconds: number;
trackMediaTimeOffsetInTrackTimescale: number;
};
export type MediaParserTrack =
| MediaParserVideoTrack
| MediaParserAudioTrack
| MediaParserOtherTrack;
export const getNumberOfTracks = (moovBox: MoovBox): number => {
const mvHdBox = getMvhdBox(moovBox);
if (!mvHdBox) {
return 0;
}
return mvHdBox.nextTrackId - 1;
};
export const isoBaseMediaHasTracks = (
state: ParserState,
mayUsePrecomputed: boolean,
) => {
return Boolean(
getMoovBoxFromState({
structureState: state.structure,
isoState: state.iso,
mp4HeaderSegment: state.m3uPlaylistContext?.mp4HeaderSegment ?? null,
mayUsePrecomputed,
}),
);
};
export const getHasTracks = (
state: ParserState,
mayUsePrecomputed: boolean,
): boolean => {
const structure = state.structure.getStructure();
if (structure.type === 'matroska') {
return matroskaHasTracks({
structureState: state.structure,
webmState: state.webm,
});
}
if (structure.type === 'iso-base-media') {
return isoBaseMediaHasTracks(state, mayUsePrecomputed);
}
if (structure.type === 'riff') {
return hasAllTracksFromAvi(state);
}
if (structure.type === 'transport-stream') {
return hasAllTracksFromTransportStream(state);
}
if (structure.type === 'mp3') {
return state.callbacks.tracks.getTracks().length > 0;
}
if (structure.type === 'wav') {
return state.callbacks.tracks.hasAllTracks();
}
if (structure.type === 'aac') {
return state.callbacks.tracks.hasAllTracks();
}
if (structure.type === 'flac') {
return state.callbacks.tracks.hasAllTracks();
}
if (structure.type === 'm3u') {
return state.callbacks.tracks.hasAllTracks();
}
throw new Error('Unknown container ' + (structure satisfies never));
};
const getCategorizedTracksFromMatroska = (
state: ParserState,
): MediaParserTrack[] => {
const {resolved} = getTracksFromMatroska({
structureState: state.structure,
webmState: state.webm,
});
return resolved;
};
export const getTracksFromMoovBox = (moovBox: MoovBox): MediaParserTrack[] => {
const mediaParserTracks: MediaParserTrack[] = [];
const tracks = getTraks(moovBox);
for (const trakBox of tracks) {
const mvhdBox = getMvhdBox(moovBox);
if (!mvhdBox) {
throw new Error('Mvhd box is not found');
}
const startTime = findTrackStartTimeInSeconds({
movieTimeScale: mvhdBox.timeScale,
trakBox,
});
const track = makeBaseMediaTrack(trakBox, startTime);
if (!track) {
continue;
}
mediaParserTracks.push(track);
}
return mediaParserTracks;
};
export const getTracksFromIsoBaseMedia = ({
mayUsePrecomputed,
structure,
isoState,
m3uPlaylistContext,
}: {
structure: StructureState;
isoState: IsoBaseMediaState;
m3uPlaylistContext: M3uPlaylistContext | null;
mayUsePrecomputed: boolean;
}): MediaParserTrack[] => {
const moovBox = getMoovBoxFromState({
structureState: structure,
isoState,
mp4HeaderSegment: m3uPlaylistContext?.mp4HeaderSegment ?? null,
mayUsePrecomputed,
});
if (!moovBox) {
return [];
}
return getTracksFromMoovBox(moovBox);
};
export const defaultGetTracks = (
parserState: ParserState,
): MediaParserTrack[] => {
const tracks = parserState.callbacks.tracks.getTracks();
if (tracks.length === 0) {
throw new Error('No tracks found');
}
return tracks;
};
export const defaultHasallTracks = (parserState: ParserState): boolean => {
try {
defaultGetTracks(parserState);
return true;
} catch {
return false;
}
};
export const getTracks = (
state: ParserState,
mayUsePrecomputed: boolean,
): MediaParserTrack[] => {
const structure = state.structure.getStructure();
if (structure.type === 'matroska') {
return getCategorizedTracksFromMatroska(state);
}
if (structure.type === 'iso-base-media') {
return getTracksFromIsoBaseMedia({
isoState: state.iso,
m3uPlaylistContext: state.m3uPlaylistContext,
structure: state.structure,
mayUsePrecomputed,
});
}
if (structure.type === 'riff') {
return getTracksFromAvi(structure, state);
}
if (structure.type === 'transport-stream') {
return getTracksFromTransportStream(state);
}
if (
structure.type === 'mp3' ||
structure.type === 'wav' ||
structure.type === 'flac' ||
structure.type === 'aac' ||
structure.type === 'm3u'
) {
return defaultGetTracks(state);
}
throw new Error(`Unknown container${structure satisfies never}`);
};