π₯ Make videos programmatically with React
import type {MediaParserCodecData} from './codec-data';
import type {EsdsBox} from './containers/iso-base-media/esds/esds';
import type {AudioSample} from './containers/iso-base-media/stsd/samples';
import type {TrakBox} from './containers/iso-base-media/trak/trak';
import {getStsdBox} from './containers/iso-base-media/traversal';
import {
getHasTracks,
getTracks,
type MediaParserAudioCodec,
} from './get-tracks';
import type {AnySegment} from './parse-result';
import type {ParserState} from './state/parser-state';
export const getAudioCodec = (
parserState: ParserState,
): MediaParserAudioCodec | null => {
const tracks = getTracks(parserState, true);
if (tracks.length === 0) {
throw new Error('No tracks yet');
}
const audioTrack = tracks.find((t) => t.type === 'audio');
if (!audioTrack) {
return null;
}
if (audioTrack.type === 'audio') {
return audioTrack.codecEnum;
}
return null;
};
export const hasAudioCodec = (state: ParserState): boolean => {
return getHasTracks(state, true);
};
const getCodecSpecificatorFromEsdsBox = ({
child,
}: {
child: EsdsBox;
}): {
primary: number;
secondary: number | null;
description: Uint8Array | undefined;
} => {
const descriptor = child.descriptors.find(
(d) => d.type === 'decoder-config-descriptor',
);
if (!descriptor) {
throw new Error('No decoder-config-descriptor');
}
if (descriptor.type !== 'decoder-config-descriptor') {
throw new Error('Expected decoder-config-descriptor');
}
if (descriptor.asNumber !== 0x40) {
return {
primary: descriptor.asNumber,
secondary: null,
description: undefined,
};
}
const audioSpecificConfig = descriptor.decoderSpecificConfigs.find((d) => {
return d.type === 'mp4a-specific-config' ? d : null;
});
if (
!audioSpecificConfig ||
audioSpecificConfig.type !== 'mp4a-specific-config'
) {
throw new Error('No audio-specific-config');
}
return {
primary: descriptor.asNumber,
secondary: audioSpecificConfig.audioObjectType,
description: audioSpecificConfig.asBytes,
};
};
type AudioCodecInfo = {
format: string;
primarySpecificator: number | null;
secondarySpecificator: number | null;
description: Uint8Array | undefined;
};
export const getCodecPrivateFromTrak = (
trakBox: TrakBox,
): MediaParserCodecData | null => {
const stsdBox = getStsdBox(trakBox);
if (!stsdBox) {
return null;
}
const audioSample = stsdBox.samples.find((s) => s.type === 'audio');
if (!audioSample || audioSample.type !== 'audio') {
return null;
}
const esds = audioSample.children.find((b) => b.type === 'esds-box');
if (!esds || esds.type !== 'esds-box') {
return null;
}
const decoderConfigDescriptor = esds.descriptors.find(
(d) => d.type === 'decoder-config-descriptor',
);
if (!decoderConfigDescriptor) {
return null;
}
const mp4a = decoderConfigDescriptor.decoderSpecificConfigs.find(
(d) => d.type === 'mp4a-specific-config',
);
if (!mp4a) {
return null;
}
return {type: 'aac-config', data: mp4a.asBytes};
};
const onSample = (
sample: AudioSample,
children: AnySegment[],
): AudioCodecInfo | null => {
const child = children.find((c) => c.type === 'esds-box');
if (child && child.type === 'esds-box') {
const ret = getCodecSpecificatorFromEsdsBox({child});
return {
format: sample.format,
primarySpecificator: ret.primary,
secondarySpecificator: ret.secondary,
description: ret.description,
};
}
return {
format: sample.format,
primarySpecificator: null,
secondarySpecificator: null,
description: undefined,
};
};
export const getNumberOfChannelsFromTrak = (trak: TrakBox): number | null => {
const stsdBox = getStsdBox(trak);
if (!stsdBox) {
return null;
}
const sample = stsdBox.samples.find((s) => s.type === 'audio');
if (!sample || sample.type !== 'audio') {
return null;
}
return sample.numberOfChannels;
};
export const getSampleRate = (trak: TrakBox): number | null => {
const stsdBox = getStsdBox(trak);
if (!stsdBox) {
return null;
}
const sample = stsdBox.samples.find((s) => s.type === 'audio');
if (!sample || sample.type !== 'audio') {
return null;
}
return sample.sampleRate;
};
export const getAudioCodecFromTrak = (trak: TrakBox): AudioCodecInfo | null => {
const stsdBox = getStsdBox(trak);
if (!stsdBox) {
return null;
}
const sample = stsdBox.samples.find((s) => s.type === 'audio');
if (!sample || sample.type !== 'audio') {
return null;
}
const waveBox = sample.children.find(
(b) => b.type === 'regular-box' && b.boxType === 'wave',
);
if (waveBox && waveBox.type === 'regular-box' && waveBox.boxType === 'wave') {
const esdsSample = onSample(sample, waveBox.children);
if (esdsSample) {
return esdsSample;
}
}
const ret = onSample(sample, sample.children);
if (ret) {
return ret;
}
return null;
};
export const isLpcmAudioCodec = (trak: TrakBox): boolean => {
return getAudioCodecFromTrak(trak)?.format === 'lpcm';
};
export const isIn24AudioCodec = (trak: TrakBox): boolean => {
return getAudioCodecFromTrak(trak)?.format === 'in24';
};
export const isTwosAudioCodec = (trak: TrakBox): boolean => {
return getAudioCodecFromTrak(trak)?.format === 'twos';
};
export const getAudioCodecStringFromTrak = (
trak: TrakBox,
): {codecString: string; description: MediaParserCodecData | undefined} => {
const codec = getAudioCodecFromTrak(trak);
if (!codec) {
throw new Error('Expected codec');
}
if (codec.format === 'lpcm') {
return {
codecString: 'pcm-s16',
description: codec.description
? {type: 'unknown-data', data: codec.description}
: undefined,
};
}
if (codec.format === 'twos') {
return {
codecString: 'pcm-s16',
description: codec.description
? {type: 'unknown-data', data: codec.description}
: undefined,
};
}
if (codec.format === 'in24') {
return {
codecString: 'pcm-s24',
description: codec.description
? {type: 'unknown-data', data: codec.description}
: undefined,
};
}
const codecStringWithoutMp3Exception = (
[
codec.format,
codec.primarySpecificator ? codec.primarySpecificator.toString(16) : null,
codec.secondarySpecificator
? codec.secondarySpecificator.toString().padStart(2, '0')
: null,
].filter(Boolean) as string[]
).join('.');
// Really, MP3? π
const codecString =
codecStringWithoutMp3Exception.toLowerCase() === 'mp4a.6b' ||
codecStringWithoutMp3Exception.toLowerCase() === 'mp4a.69'
? 'mp3' // or "mp4a.6B" would also work, with the uppercasing, but mp3 is probably more obvious
: codecStringWithoutMp3Exception;
if (codecString === 'mp3') {
return {
codecString,
description: codec.description
? {
type: 'unknown-data',
data: codec.description,
}
: undefined,
};
}
if (codecString.startsWith('mp4a.')) {
return {
codecString,
description: codec.description
? {
type: 'aac-config',
data: codec.description,
}
: undefined,
};
}
return {
codecString,
description: codec.description
? {
type: 'unknown-data',
data: codec.description,
}
: undefined,
};
};
const getAudioCodecFromAudioCodecInfo = (
codec: AudioCodecInfo,
): MediaParserAudioCodec => {
if (codec.format === 'twos') {
return 'pcm-s16';
}
if (codec.format === 'in24') {
return 'pcm-s24';
}
if (codec.format === 'lpcm') {
return 'pcm-s16';
}
if (codec.format === 'sowt') {
return 'aiff';
}
if (codec.format === 'ac-3') {
return 'ac3';
}
if (codec.format === 'Opus') {
return 'opus';
}
if (codec.format === 'mp4a') {
if (codec.primarySpecificator === 0x40) {
return 'aac';
}
if (codec.primarySpecificator === 0x6b) {
return 'mp3';
}
if (codec.primarySpecificator === null) {
return 'aac';
}
throw new Error('Unknown mp4a codec: ' + codec.primarySpecificator);
}
throw new Error(`Unknown audio format: ${codec.format}`);
};
export const getAudioCodecFromTrack = (track: TrakBox) => {
const audioSample = getAudioCodecFromTrak(track);
if (!audioSample) {
throw new Error('Could not find audio sample');
}
return getAudioCodecFromAudioCodecInfo(audioSample);
};