@remotion/media-parser 4.0.288 → 4.0.289

package/dist/containers/iso-base-media/stsd/samples.js

@@ -63,7 +63,7 @@ const audioTags = [
     'mp4a',
     'ac-3',
 ];
-const processIsoFormatBox = async ({ iterator, logLevel, }) => {
+const processIsoFormatBox = async ({ iterator, logLevel, contentLength, }) => {
     const fileOffset = iterator.counter.getOffset();
     const bytesRemaining = iterator.bytesRemaining();
     const boxSize = iterator.getUint32();
@@ -104,6 +104,7 @@ const processIsoFormatBox = async ({ iterator, logLevel, }) => {
                 logLevel,
                 size: boxSize - (iterator.counter.getOffset() - fileOffset),
                 onlyIfMoovAtomExpected: null,
+                contentLength,
             });
             return {
                 sample: {
@@ -143,6 +144,7 @@ const processIsoFormatBox = async ({ iterator, logLevel, }) => {
                 logLevel,
                 size: boxSize - (iterator.counter.getOffset() - fileOffset),
                 onlyIfMoovAtomExpected: null,
+                contentLength,
             });
             return {
                 sample: {
@@ -186,6 +188,7 @@ const processIsoFormatBox = async ({ iterator, logLevel, }) => {
                 logLevel,
                 size: boxSize - (iterator.counter.getOffset() - fileOffset),
                 onlyIfMoovAtomExpected: null,
+                contentLength,
             });
             return {
                 sample: {
@@ -234,6 +237,7 @@ const processIsoFormatBox = async ({ iterator, logLevel, }) => {
                 iterator,
                 logLevel,
                 size: bytesRemainingInBox,
+                contentLength,
             })
             : (iterator.discard(bytesRemainingInBox), []);
         return {
@@ -264,7 +268,7 @@ const processIsoFormatBox = async ({ iterator, logLevel, }) => {
     throw new Error(`Unknown sample format ${boxFormat}`);
 };
 exports.processIsoFormatBox = processIsoFormatBox;
-const parseIsoFormatBoxes = async ({ maxBytes, logLevel, iterator, }) => {
+const parseIsoFormatBoxes = async ({ maxBytes, logLevel, iterator, contentLength, }) => {
     const samples = [];
     const initialOffset = iterator.counter.getOffset();
     while (iterator.bytesRemaining() > 0 &&
@@ -272,6 +276,7 @@ const parseIsoFormatBoxes = async ({ maxBytes, logLevel, iterator, }) => {
         const { sample } = await (0, exports.processIsoFormatBox)({
             iterator,
             logLevel,
+            contentLength,
         });
         if (sample) {
             samples.push(sample);

package/dist/containers/iso-base-media/stsd/stsd.d.ts

@@ -7,9 +7,10 @@ export interface StsdBox extends BaseBox {
     numberOfEntries: number;
     samples: Sample[];
 }
-export declare const parseStsd: ({ offset, size, iterator, logLevel, }: {
+export declare const parseStsd: ({ offset, size, iterator, logLevel, contentLength, }: {
     offset: number;
     size: number;
     iterator: BufferIterator;
     logLevel: LogLevel;
+    contentLength: number;
 }) => Promise<StsdBox>;

package/dist/containers/iso-base-media/stsd/stsd.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseStsd = void 0;
 const samples_1 = require("./samples");
-const parseStsd = async ({ offset, size, iterator, logLevel, }) => {
+const parseStsd = async ({ offset, size, iterator, logLevel, contentLength, }) => {
     const version = iterator.getUint8();
     if (version !== 0) {
         throw new Error(`Unsupported STSD version ${version}`);
@@ -15,6 +15,7 @@ const parseStsd = async ({ offset, size, iterator, logLevel, }) => {
         maxBytes: bytesRemainingInBox,
         logLevel,
         iterator,
+        contentLength,
     });
     if (boxes.length !== numberOfEntries) {
         throw new Error(`Expected ${numberOfEntries} sample descriptions, got ${boxes.length}`);

package/dist/containers/iso-base-media/trak/trak.d.ts

@@ -6,9 +6,10 @@ export interface TrakBox extends BaseBox {
     type: 'trak-box';
     children: AnySegment[];
 }
-export declare const parseTrak: ({ size, offsetAtStart, iterator, logLevel, }: {
+export declare const parseTrak: ({ size, offsetAtStart, iterator, logLevel, contentLength, }: {
     size: number;
     offsetAtStart: number;
     iterator: BufferIterator;
     logLevel: LogLevel;
+    contentLength: number;
 }) => Promise<TrakBox>;

package/dist/containers/iso-base-media/trak/trak.js

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTrak = void 0;
 const get_children_1 = require("../get-children");
-const parseTrak = async ({ size, offsetAtStart, iterator, logLevel, }) => {
+const parseTrak = async ({ size, offsetAtStart, iterator, logLevel, contentLength, }) => {
     const children = await (0, get_children_1.getIsoBaseMediaChildren)({
         onlyIfMoovAtomExpected: null,
         size: size - 8,
         iterator,
         logLevel,
+        contentLength,
     });
     return {
         offset: offsetAtStart,

package/dist/containers/mp3/audio-sample-from-cbr.d.ts

@@ -0,0 +1,11 @@
+import type { ParserState } from '../../state/parser-state';
+import type { AudioOrVideoSample } from '../../webcodec-sample-types';
+export declare const getAudioSampleFromCbr: ({ bitrateInKbit, initialOffset, layer, sampleRate, samplesPerFrame, data, state, }: {
+    bitrateInKbit: number;
+    layer: number;
+    samplesPerFrame: number;
+    sampleRate: number;
+    initialOffset: number;
+    data: Uint8Array;
+    state: ParserState;
+}) => AudioOrVideoSample;

package/dist/containers/mp3/audio-sample-from-cbr.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAudioSampleFromCbr = void 0;
+const get_frame_length_1 = require("./get-frame-length");
+const getAudioSampleFromCbr = ({ bitrateInKbit, initialOffset, layer, sampleRate, samplesPerFrame, data, state, }) => {
+    const avgLength = (0, get_frame_length_1.getAverageMpegFrameLength)({
+        bitrateKbit: bitrateInKbit,
+        layer,
+        samplesPerFrame,
+        samplingFrequency: sampleRate,
+    });
+    const mp3Info = state.mp3.getMp3Info();
+    if (!mp3Info) {
+        throw new Error('No MP3 info');
+    }
+    const nthFrame = Math.round((initialOffset - state.mediaSection.getMediaSectionAssertOnlyOne().start) /
+        avgLength);
+    const durationInSeconds = samplesPerFrame / sampleRate;
+    const timeInSeconds = (nthFrame * samplesPerFrame) / sampleRate;
+    const timestamp = Math.round(timeInSeconds * 1000000);
+    const duration = Math.round(durationInSeconds * 1000000);
+    const audioSample = {
+        data,
+        cts: timestamp,
+        dts: timestamp,
+        duration,
+        offset: initialOffset,
+        timescale: 1000000,
+        timestamp,
+        trackId: 0,
+        type: 'key',
+    };
+    return audioSample;
+};
+exports.getAudioSampleFromCbr = getAudioSampleFromCbr;

package/dist/containers/mp3/get-duration.js

@@ -1,26 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDurationFromMp3 = void 0;
+exports.getDurationFromMp3 = exports.getDurationFromMp3Xing = void 0;
 const get_frame_length_1 = require("./get-frame-length");
 const samples_per_mpeg_file_1 = require("./samples-per-mpeg-file");
+const getDurationFromMp3Xing = ({ xingData, samplesPerFrame, }) => {
+    const xingFrames = xingData.numberOfFrames;
+    if (!xingFrames) {
+        throw new Error('Cannot get duration of VBR MP3 file - no frames');
+    }
+    const { sampleRate } = xingData;
+    if (!sampleRate) {
+        throw new Error('Cannot get duration of VBR MP3 file - no sample rate');
+    }
+    const xingSamples = xingFrames * samplesPerFrame;
+    return xingSamples / sampleRate;
+};
+exports.getDurationFromMp3Xing = getDurationFromMp3Xing;
 const getDurationFromMp3 = (state) => {
-    const mp3Info = state.mp3Info.getMp3Info();
-    const mp3CbrInfo = state.mp3Info.getCbrMp3Info();
-    if (!mp3Info || !mp3CbrInfo) {
+    const mp3Info = state.mp3.getMp3Info();
+    const mp3BitrateInfo = state.mp3.getMp3BitrateInfo();
+    if (!mp3Info || !mp3BitrateInfo) {
         return null;
     }
     const samplesPerFrame = (0, samples_per_mpeg_file_1.getSamplesPerMpegFrame)({
         layer: mp3Info.layer,
         mpegVersion: mp3Info.mpegVersion,
     });
+    if (mp3BitrateInfo.type === 'variable') {
+        return (0, exports.getDurationFromMp3Xing)({
+            xingData: mp3BitrateInfo.xingData,
+            samplesPerFrame,
+        });
+    }
+    /**
+     * sonnet: The variation between 1044 and 1045 bytes in MP3 frames occurs due to the bit reservoir mechanism in MP3 encoding. Here's the typical distribution:
+     * •	1044 bytes (99% of frames)
+     * •	1045 bytes (1% of frames)
+     */
+    // we ignore that fact for now
     const frameLengthInBytes = (0, get_frame_length_1.getMpegFrameLength)({
-        bitrateKbit: mp3CbrInfo.bitrateKbit,
+        bitrateKbit: mp3BitrateInfo.bitrateInKbit,
         padding: false,
         samplesPerFrame,
         samplingFrequency: mp3Info.sampleRate,
         layer: mp3Info.layer,
     });
-    const frames = Math.floor((state.contentLength - mp3Info.startOfMpegStream) / frameLengthInBytes);
+    const frames = Math.floor((state.contentLength -
+        state.mediaSection.getMediaSectionAssertOnlyOne().start) /
+        frameLengthInBytes);
     const samples = frames * samplesPerFrame;
     const durationInSeconds = samples / mp3Info.sampleRate;
     return durationInSeconds;

package/dist/containers/mp3/get-seeking-byte.d.ts

@@ -0,0 +1,6 @@
+import type { SeekResolution } from '../../work-on-seek-request';
+import type { Mp3SeekingHints } from './seeking-hints';
+export declare const getSeekingByteForMp3: ({ time, info, }: {
+    time: number;
+    info: Mp3SeekingHints;
+}) => SeekResolution;

package/dist/containers/mp3/get-seeking-byte.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSeekingByteForMp3 = void 0;
+const get_approximate_byte_from_bitrate_1 = require("./seek/get-approximate-byte-from-bitrate");
+const get_byte_from_observed_samples_1 = require("./seek/get-byte-from-observed-samples");
+const get_seek_point_from_xing_1 = require("./seek/get-seek-point-from-xing");
+const getSeekingByteForMp3 = ({ time, info, }) => {
+    var _a;
+    if (info.mp3BitrateInfo === null ||
+        info.mp3Info === null ||
+        info.mediaSection === null) {
+        return {
+            type: 'valid-but-must-wait',
+        };
+    }
+    const approximateByte = (0, get_approximate_byte_from_bitrate_1.getApproximateByteFromBitrate)({
+        mp3BitrateInfo: info.mp3BitrateInfo,
+        timeInSeconds: time,
+        mp3Info: info.mp3Info,
+        mediaSection: info.mediaSection,
+        contentLength: info.contentLength,
+    });
+    const bestAudioSample = (0, get_byte_from_observed_samples_1.getByteFromObservedSamples)({
+        info,
+        timeInSeconds: time,
+    });
+    const xingSeekPoint = info.mp3BitrateInfo.type === 'variable'
+        ? (0, get_seek_point_from_xing_1.getSeekPointFromXing)({
+            mp3Info: info.mp3Info,
+            timeInSeconds: time,
+            xingData: info.mp3BitrateInfo.xingData,
+        })
+        : null;
+    const candidates = [
+        approximateByte,
+        (_a = bestAudioSample === null || bestAudioSample === void 0 ? void 0 : bestAudioSample.offset) !== null && _a !== void 0 ? _a : null,
+        xingSeekPoint,
+    ].filter((b) => b !== null);
+    if (candidates.length === 0) {
+        return {
+            type: 'valid-but-must-wait',
+        };
+    }
+    return {
+        type: 'do-seek',
+        byte: Math.max(...candidates),
+    };
+};
+exports.getSeekingByteForMp3 = getSeekingByteForMp3;

package/dist/containers/mp3/parse-mp3.js

@@ -4,11 +4,20 @@ exports.parseMp3 = void 0;
 const id3_1 = require("./id3");
 const id3_v1_1 = require("./id3-v1");
 const parse_mpeg_header_1 = require("./parse-mpeg-header");
+const wait_until_syncword_1 = require("./seek/wait-until-syncword");
 const parseMp3 = async (state) => {
     const { iterator } = state;
     if (iterator.bytesRemaining() < 3) {
         return null;
     }
+    // When coming from a seek, we need to discard until the syncword
+    if (state.mediaSection.isCurrentByteInMediaSection(iterator) === 'in-section') {
+        (0, wait_until_syncword_1.discardUntilSyncword)({ iterator });
+        await (0, parse_mpeg_header_1.parseMpegHeader)({
+            state,
+        });
+        return null;
+    }
     const { returnToCheckpoint } = iterator.startCheckpoint();
     const bytes = iterator.getSlice(3);
     returnToCheckpoint();

package/dist/containers/mp3/parse-mpeg-header.js

@@ -2,299 +2,110 @@
 // spec: http://www.mp3-tech.org/programmer/frame_header.html
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMpegHeader = void 0;
-const emit_audio_sample_1 = require("../../emit-audio-sample");
 const log_1 = require("../../log");
 const register_track_1 = require("../../register-track");
-const get_frame_length_1 = require("./get-frame-length");
-const samples_per_mpeg_file_1 = require("./samples-per-mpeg-file");
-function getSamplingFrequency({ bits, mpegVersion, }) {
-    const samplingTable = {
-        0b00: { MPEG1: 44100, MPEG2: 22050 },
-        0b01: { MPEG1: 48000, MPEG2: 24000 },
-        0b10: { MPEG1: 32000, MPEG2: 16000 },
-        0b11: { MPEG1: 'reserved', MPEG2: 'reserved' },
-    };
-    const key = `MPEG${mpegVersion}`;
-    const value = samplingTable[bits][key];
-    if (value === 'reserved') {
-        throw new Error('Reserved sampling frequency');
-    }
-    if (!value) {
-        throw new Error('Invalid sampling frequency for MPEG version: ' +
-            JSON.stringify({ bits, version: mpegVersion }));
-    }
-    return value;
-}
-function getBitrateKB({ bits, mpegVersion, level, }) {
-    const bitrateTable = {
-        0b0000: {
-            'V1,L1': 'free',
-            'V1,L2': 'free',
-            'V1,L3': 'free',
-            'V2,L1': 'free',
-            'V2,L2&L3': 'free',
-        },
-        0b0001: { 'V1,L1': 32, 'V1,L2': 32, 'V1,L3': 32, 'V2,L1': 32, 'V2,L2&L3': 8 },
-        0b0010: {
-            'V1,L1': 64,
-            'V1,L2': 48,
-            'V1,L3': 40,
-            'V2,L1': 48,
-            'V2,L2&L3': 16,
-        },
-        0b0011: {
-            'V1,L1': 96,
-            'V1,L2': 56,
-            'V1,L3': 48,
-            'V2,L1': 56,
-            'V2,L2&L3': 24,
-        },
-        0b0100: {
-            'V1,L1': 128,
-            'V1,L2': 64,
-            'V1,L3': 56,
-            'V2,L1': 64,
-            'V2,L2&L3': 32,
-        },
-        0b0101: {
-            'V1,L1': 160,
-            'V1,L2': 80,
-            'V1,L3': 64,
-            'V2,L1': 80,
-            'V2,L2&L3': 40,
-        },
-        0b0110: {
-            'V1,L1': 192,
-            'V1,L2': 96,
-            'V1,L3': 80,
-            'V2,L1': 96,
-            'V2,L2&L3': 48,
-        },
-        0b0111: {
-            'V1,L1': 224,
-            'V1,L2': 112,
-            'V1,L3': 96,
-            'V2,L1': 112,
-            'V2,L2&L3': 56,
-        },
-        0b1000: {
-            'V1,L1': 256,
-            'V1,L2': 128,
-            'V1,L3': 112,
-            'V2,L1': 128,
-            'V2,L2&L3': 64,
-        },
-        0b1001: {
-            'V1,L1': 288,
-            'V1,L2': 160,
-            'V1,L3': 128,
-            'V2,L1': 144,
-            'V2,L2&L3': 80,
-        },
-        0b1010: {
-            'V1,L1': 320,
-            'V1,L2': 192,
-            'V1,L3': 160,
-            'V2,L1': 160,
-            'V2,L2&L3': 96,
-        },
-        0b1011: {
-            'V1,L1': 352,
-            'V1,L2': 224,
-            'V1,L3': 192,
-            'V2,L1': 176,
-            'V2,L2&L3': 112,
-        },
-        0b1100: {
-            'V1,L1': 384,
-            'V1,L2': 256,
-            'V1,L3': 224,
-            'V2,L1': 192,
-            'V2,L2&L3': 128,
-        },
-        0b1101: {
-            'V1,L1': 416,
-            'V1,L2': 320,
-            'V1,L3': 256,
-            'V2,L1': 224,
-            'V2,L2&L3': 144,
-        },
-        0b1110: {
-            'V1,L1': 448,
-            'V1,L2': 384,
-            'V1,L3': 320,
-            'V2,L1': 256,
-            'V2,L2&L3': 160,
-        },
-        0b1111: {
-            'V1,L1': 'bad',
-            'V1,L2': 'bad',
-            'V1,L3': 'bad',
-            'V2,L1': 'bad',
-            'V2,L2&L3': 'bad',
-        },
-    };
-    // Determine the correct key based on version and level
-    let key;
-    if (mpegVersion === 2 && (level === 2 || level === 3)) {
-        key = 'V2,L2&L3';
-    }
-    else {
-        key = `V${mpegVersion},L${level}`;
-    }
-    // Return the corresponding bitrate
-    return bitrateTable[bits][key];
-}
+const parse_packet_header_1 = require("./parse-packet-header");
+const parse_xing_1 = require("./parse-xing");
+const audio_sample_from_cbr_1 = require("./seek/audio-sample-from-cbr");
+const audio_sample_from_vbr_1 = require("./seek/audio-sample-from-vbr");
 const parseMpegHeader = async ({ state, }) => {
     const { iterator } = state;
     const initialOffset = iterator.counter.getOffset();
     if (iterator.bytesRemaining() < 32) {
         return;
     }
-    iterator.startReadingBits();
-    for (let i = 0; i < 11; i++) {
-        const expectToBe1 = iterator.getBits(1);
-        if (expectToBe1 !== 1) {
-            throw new Error('Expected 1');
+    // parse header
+    const { frameLength, bitrateInKbit, layer, mpegVersion, numberOfChannels, sampleRate, samplesPerFrame, } = (0, parse_packet_header_1.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 audioVersionId = iterator.getBits(2);
-    /**
-   * 00 - MPEG Version 2.5 (later extension of MPEG 2)
-     01 - reserved
-     10 - MPEG Version 2 (ISO/IEC 13818-3)
-     11 - MPEG Version 1 (ISO/IEC 11172-3)
-   */
-    if (audioVersionId !== 0b11 && audioVersionId !== 0b10) {
-        throw new Error('Expected MPEG Version 1 or 2');
-    }
-    const mpegVersion = audioVersionId === 0b11 ? 1 : 2;
-    const layerBits = iterator.getBits(2);
-    /**
-   * 00 - reserved
-     01 - Layer III
-     10 - Layer II
-     11 - Layer I
-   */
-    if (layerBits === 0b00) {
-        throw new Error('Expected Layer I, II or III');
-    }
-    const layer = layerBits === 0b11 ? 1 : layerBits === 0b10 ? 2 : 3;
-    const protectionBit = iterator.getBits(1);
-    if (protectionBit !== 0b1) {
-        throw new Error('Does not support CRC yet');
-    }
-    const bitrateIndex = iterator.getBits(4);
-    const bitrateKbit = getBitrateKB({
-        bits: bitrateIndex,
-        mpegVersion,
-        level: audioVersionId,
-    });
-    if (bitrateKbit === 'bad') {
-        throw new Error('Invalid bitrate');
-    }
-    if (bitrateKbit === 'free') {
-        throw new Error('Free bitrate not supported');
-    }
-    const samplingFrequencyIndex = iterator.getBits(2);
-    const sampleRate = getSamplingFrequency({
-        bits: samplingFrequencyIndex,
-        mpegVersion,
-    });
-    const padding = Boolean(iterator.getBits(1));
-    iterator.getBits(1); // private bit
-    const channelMode = iterator.getBits(2); // channel mode
-    iterator.getBits(2); // mode extension
-    iterator.getBits(1); // copyright
-    iterator.getBits(1); // original
-    iterator.getBits(2); // emphasis
-    const numberOfChannels = channelMode === 0b11 ? 1 : 2;
-    const samplesPerFrame = (0, samples_per_mpeg_file_1.getSamplesPerMpegFrame)({ mpegVersion, layer });
-    const frameLength = (0, get_frame_length_1.getMpegFrameLength)({
-        bitrateKbit,
-        padding,
-        samplesPerFrame,
-        samplingFrequency: sampleRate,
-        layer,
-    });
-    iterator.stopReadingBits();
     const offsetNow = iterator.counter.getOffset();
     iterator.counter.decrement(offsetNow - initialOffset);
     const data = iterator.getSlice(frameLength);
-    let isInfoTag = false;
     if (state.callbacks.tracks.getTracks().length === 0) {
         const info = {
             layer,
             mpegVersion,
             sampleRate,
-            startOfMpegStream: initialOffset,
         };
         const asText = new TextDecoder().decode(data);
-        const isVbr = asText.includes('Xing') || asText.includes('VBRI');
-        isInfoTag = isVbr || asText.includes('Info');
+        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 = (0, parse_xing_1.parseXing)(data);
             log_1.Log.verbose(state.logLevel, 'MP3 has variable bit rate. Requiring whole file to be read');
-        }
-        else {
-            state.mp3Info.setCbrMp3Info({
-                bitrateKbit,
+            state.mp3.setMp3BitrateInfo({
+                type: 'variable',
+                xingData,
             });
+            return;
         }
-        if (!isInfoTag) {
-            state.mp3Info.setMp3Info(info);
-            await (0, register_track_1.registerAudioTrack)({
-                container: 'mp3',
-                track: {
-                    type: 'audio',
-                    codec: 'mp3',
-                    codecPrivate: null,
-                    codecWithoutConfig: 'mp3',
-                    description: undefined,
-                    numberOfChannels,
-                    sampleRate,
-                    timescale: 1000000,
-                    trackId: 0,
-                    trakBox: null,
-                },
-                registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
-                tracks: state.callbacks.tracks,
-                logLevel: state.logLevel,
-                onAudioTrack: state.onAudioTrack,
+        if (!state.mp3.getMp3BitrateInfo()) {
+            state.mp3.setMp3BitrateInfo({
+                bitrateInKbit,
+                type: 'constant',
             });
-            state.callbacks.tracks.setIsDone(state.logLevel);
-        }
-    }
-    const avgLength = (0, get_frame_length_1.getAverageMpegFrameLength)({
-        bitrateKbit,
-        layer,
-        samplesPerFrame,
-        samplingFrequency: sampleRate,
-    });
-    if (!isInfoTag) {
-        const mp3Info = state.mp3Info.getMp3Info();
-        if (!mp3Info) {
-            throw new Error('No MP3 info');
         }
-        const nthFrame = Math.round((initialOffset - mp3Info.startOfMpegStream) / avgLength);
-        const durationInSeconds = samplesPerFrame / sampleRate;
-        const timeInSeconds = (nthFrame * samplesPerFrame) / sampleRate;
-        const timestamp = Math.round(timeInSeconds * 1000000);
-        const duration = Math.round(durationInSeconds * 1000000);
-        await (0, emit_audio_sample_1.emitAudioSample)({
-            trackId: 0,
-            audioSample: {
-                data,
-                cts: timestamp,
-                dts: timestamp,
-                duration,
-                offset: initialOffset,
+        state.mp3.setMp3Info(info);
+        await (0, register_track_1.registerAudioTrack)({
+            container: 'mp3',
+            track: {
+                type: 'audio',
+                codec: 'mp3',
+                codecPrivate: null,
+                codecWithoutConfig: 'mp3',
+                description: undefined,
+                numberOfChannels,
+                sampleRate,
                 timescale: 1000000,
-                timestamp,
                 trackId: 0,
-                type: 'key',
+                trakBox: null,
             },
-            callbacks: state.callbacks,
+            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'
+        ? (0, audio_sample_from_cbr_1.getAudioSampleFromCbr)({
+            bitrateInKbit,
+            data,
+            initialOffset,
+            layer,
+            sampleRate,
+            samplesPerFrame,
+            state,
+        })
+        : (0, audio_sample_from_vbr_1.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(0, audioSample);
 };
 exports.parseMpegHeader = parseMpegHeader;