🎥 Make videos programmatically with React
// spec: http://www.mp3-tech.org/programmer/frame_header.html
import {Log} from '../../log';
import {registerAudioTrack} from '../../register-track';
import type {Mp3Info} from '../../state/mp3';
import type {ParserState} from '../../state/parser-state';
import {WEBCODECS_TIMESCALE} from '../../webcodecs-timescale';
import {parseMp3PacketHeader} from './parse-packet-header';
import {parseXing} from './parse-xing';
import {getAudioSampleFromCbr} from './seek/audio-sample-from-cbr';
import {getAudioSampleFromVbr} from './seek/audio-sample-from-vbr';
export const parseMpegHeader = async ({
state,
}: {
state: ParserState;
}): Promise<void> => {
const {iterator} = state;
const initialOffset = iterator.counter.getOffset();
if (iterator.bytesRemaining() < 32) {
return;
}
// parse header
const {
frameLength,
bitrateInKbit,
layer,
mpegVersion,
numberOfChannels,
sampleRate,
samplesPerFrame,
} = parseMp3PacketHeader(iterator);
const cbrMp3Info = state.mp3.getMp3BitrateInfo();
if (cbrMp3Info && cbrMp3Info.type === 'constant') {
if (bitrateInKbit !== cbrMp3Info.bitrateInKbit) {
throw new Error(
`Bitrate mismatch at offset ${initialOffset}: ${bitrateInKbit} !== ${cbrMp3Info.bitrateInKbit}`,
);
}
}
const offsetNow = iterator.counter.getOffset();
iterator.counter.decrement(offsetNow - initialOffset);
const data = iterator.getSlice(frameLength);
if (state.callbacks.tracks.getTracks().length === 0) {
const info: Mp3Info = {
layer,
mpegVersion,
sampleRate,
};
const asText = new TextDecoder().decode(data);
if (asText.includes('VBRI')) {
throw new Error(
'MP3 files with VBRI are currently unsupported because we have no sample file. Submit this file at remotion.dev/report if you would like us to support this file.',
);
}
if (asText.includes('Info')) {
return;
}
const isVbr = asText.includes('Xing');
if (isVbr) {
const xingData = parseXing(data);
Log.verbose(
state.logLevel,
'MP3 has variable bit rate. Requiring whole file to be read',
);
state.mp3.setMp3BitrateInfo({
type: 'variable',
xingData,
});
return;
}
if (!state.mp3.getMp3BitrateInfo()) {
state.mp3.setMp3BitrateInfo({
bitrateInKbit,
type: 'constant',
});
}
state.mp3.setMp3Info(info);
await registerAudioTrack({
container: 'mp3',
track: {
type: 'audio',
codec: 'mp3',
codecData: null,
codecEnum: 'mp3',
description: undefined,
numberOfChannels,
sampleRate,
originalTimescale: 1_000_000,
trackId: 0,
startInSeconds: 0,
timescale: WEBCODECS_TIMESCALE,
trackMediaTimeOffsetInTrackTimescale: 0,
},
registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
tracks: state.callbacks.tracks,
logLevel: state.logLevel,
onAudioTrack: state.onAudioTrack,
});
state.callbacks.tracks.setIsDone(state.logLevel);
state.mediaSection.addMediaSection({
start: initialOffset,
size: state.contentLength - initialOffset,
});
}
const bitrateInfo = state.mp3.getMp3BitrateInfo();
if (!bitrateInfo) {
throw new Error('No bitrate info');
}
const sample =
bitrateInfo.type === 'constant'
? getAudioSampleFromCbr({
bitrateInKbit,
data,
initialOffset,
layer,
sampleRate,
samplesPerFrame,
state,
})
: getAudioSampleFromVbr({
data,
info: bitrateInfo,
mp3Info: state.mp3.getMp3Info(),
position: initialOffset,
});
const {audioSample, timeInSeconds, durationInSeconds} = sample;
state.mp3.audioSamples.addSample({
timeInSeconds,
offset: initialOffset,
durationInSeconds,
});
await state.callbacks.onAudioSample({
audioSample,
trackId: 0,
});
};