@remotion/media-parser 4.0.248 → 4.0.250

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 parseMp3 = async ({ iterator, state, }) => {
+    if (iterator.bytesRemaining() < 3) {
+        return {
+            skipTo: null,
+        };
+    }
+    const { returnToCheckpoint } = iterator.startCheckpoint();
+    const bytes = iterator.getSlice(3);
+    returnToCheckpoint();
+    // ID3 v1
+    if (bytes[0] === 0x54 && bytes[1] === 0x41 && bytes[2] === 0x47) {
+        (0, id3_v1_1.parseID3V1)(iterator);
+        return {
+            skipTo: null,
+        };
+    }
+    // ID3 v2 or v3
+    if (bytes[0] === 0x49 && bytes[1] === 0x44 && bytes[2] === 0x33) {
+        (0, id3_1.parseId3)({ iterator, state });
+        return {
+            skipTo: null,
+        };
+    }
+    if (bytes[0] === 0xff) {
+        await (0, parse_mpeg_header_1.parseMpegHeader)({
+            iterator,
+            state,
+        });
+        return {
+            skipTo: null,
+        };
+    }
+    throw new Error('Unknown MP3 header ' + JSON.stringify(bytes));
+};
+exports.parseMp3 = parseMp3;

package/dist/boxes/mp3/parse-mpeg-header.d.ts

@@ -0,0 +1,6 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseMpegHeader: ({ iterator, state, }: {
+    iterator: BufferIterator;
+    state: ParserState;
+}) => Promise<void>;

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

@@ -0,0 +1,274 @@
+"use strict";
+// spec: http://www.mp3-tech.org/programmer/frame_header.html
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMpegHeader = void 0;
+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 parseMpegHeader = async ({ 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');
+        }
+    }
+    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);
+    if (state.callbacks.tracks.getTracks().length === 0) {
+        state.mp3Info.setMp3Info({
+            layer,
+            mpegVersion,
+            sampleRate,
+            bitrateKbit,
+            startOfMpegStream: initialOffset,
+        });
+        await (0, register_track_1.registerTrack)({
+            container: 'mp3',
+            state,
+            track: {
+                type: 'audio',
+                codec: 'mp3',
+                codecPrivate: null,
+                codecWithoutConfig: 'mp3',
+                description: undefined,
+                numberOfChannels,
+                sampleRate,
+                timescale: 1000000,
+                trackId: 0,
+                trakBox: null,
+            },
+        });
+        state.callbacks.tracks.setIsDone();
+    }
+    const mp3Info = state.mp3Info.getMp3Info();
+    if (!mp3Info) {
+        throw new Error('No MP3 info by now');
+    }
+    const avgLength = (0, get_frame_length_1.getAverageMpegFrameLength)({
+        bitrateKbit,
+        layer,
+        samplesPerFrame,
+        samplingFrequency: sampleRate,
+    });
+    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 state.callbacks.onAudioSample(0, {
+        data,
+        cts: timestamp,
+        dts: timestamp,
+        duration,
+        offset: initialOffset,
+        timescale: 1000000,
+        timestamp,
+        trackId: 0,
+        type: 'key',
+    });
+};
+exports.parseMpegHeader = parseMpegHeader;

package/dist/boxes/mp3/samples-per-mpeg-file.d.ts

@@ -0,0 +1,4 @@
+export declare const getSamplesPerMpegFrame: ({ mpegVersion, layer, }: {
+    mpegVersion: 1 | 2;
+    layer: number;
+}) => 384 | 1152 | 576;

package/dist/boxes/mp3/samples-per-mpeg-file.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSamplesPerMpegFrame = void 0;
+const getSamplesPerMpegFrame = ({ mpegVersion, layer, }) => {
+    if (mpegVersion === 1) {
+        if (layer === 1) {
+            return 384;
+        }
+        if (layer === 2 || layer === 3) {
+            return 1152;
+        }
+    }
+    if (mpegVersion === 2) {
+        if (layer === 1) {
+            return 384;
+        }
+        if (layer === 2) {
+            return 1152;
+        }
+        if (layer === 3) {
+            return 576;
+        }
+    }
+    throw new Error('Invalid MPEG layer');
+};
+exports.getSamplesPerMpegFrame = getSamplesPerMpegFrame;

package/dist/boxes/riff/continue-after-riff-result.d.ts

@@ -0,0 +1,13 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { Options, ParseMediaFields } from '../../options';
+import type { ParseResult, RiffStructure } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+import type { RiffResult } from './expect-riff-box';
+export declare const continueAfterRiffBoxResult: ({ result, structure, iterator, maxOffset, state: options, fields, }: {
+    result: RiffResult;
+    structure: RiffStructure;
+    iterator: BufferIterator;
+    maxOffset: number;
+    state: ParserState;
+    fields: Options<ParseMediaFields>;
+}) => Promise<ParseResult>;

package/dist/boxes/riff/continue-after-riff-result.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.continueAfterRiffBoxResult = void 0;
+const parse_riff_body_1 = require("./parse-riff-body");
+const continueAfterRiffBoxResult = ({ result, structure, iterator, maxOffset, state: options, fields, }) => {
+    if (result.type === 'incomplete') {
+        return Promise.resolve({
+            status: 'incomplete',
+            async continueParsing() {
+                return Promise.resolve((0, exports.continueAfterRiffBoxResult)({
+                    result: await result.continueParsing(),
+                    structure,
+                    iterator,
+                    maxOffset,
+                    state: options,
+                    fields,
+                }));
+            },
+            segments: structure,
+            skipTo: null,
+        });
+    }
+    if (result.type === 'complete' && result.box) {
+        structure.boxes.push(result.box);
+    }
+    return (0, parse_riff_body_1.parseRiffBody)({
+        iterator,
+        maxOffset,
+        state: options,
+        structure,
+        fields,
+    });
+};
+exports.continueAfterRiffBoxResult = continueAfterRiffBoxResult;

package/dist/boxes/riff/expect-riff-box.d.ts

@@ -1,17 +1,11 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { RiffStructure } from '../../parse-result';
 import type { ParserState } from '../../state/parser-state';
 import type { RiffBox } from './riff-box';
 export type RiffResult = {
-    type: 'incomplete';
-    continueParsing: () => Promise<RiffResult>;
-} | {
-    type: 'complete';
     box: RiffBox | null;
     skipTo: number | null;
 };
-export declare const expectRiffBox: ({ iterator, state, structure, }: {
+export declare const expectRiffBox: ({ iterator, state, }: {
     iterator: BufferIterator;
     state: ParserState;
-    structure: RiffStructure;
 }) => Promise<RiffResult>;

package/dist/boxes/riff/expect-riff-box.js

@@ -1,48 +1,71 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expectRiffBox = void 0;
+const register_track_1 = require("../../register-track");
+const get_tracks_from_avi_1 = require("./get-tracks-from-avi");
 const is_movi_1 = require("./is-movi");
-const parse_movi_1 = require("./parse-movi");
 const parse_riff_box_1 = require("./parse-riff-box");
-const expectRiffBox = async ({ iterator, state, structure, }) => {
+const parse_video_section_1 = require("./parse-video-section");
+const expectRiffBox = async ({ iterator, state, }) => {
     // Need at least 16 bytes to read LIST,size,movi,size
     if (iterator.bytesRemaining() < 16) {
         return {
-            type: 'incomplete',
-            continueParsing() {
-                return (0, exports.expectRiffBox)({ structure, iterator, state });
-            },
+            box: null,
+            skipTo: null,
         };
     }
+    const checkpoint = iterator.startCheckpoint();
     const ckId = iterator.getByteString(4, false);
     const ckSize = iterator.getUint32Le();
     if ((0, is_movi_1.isMoviAtom)(iterator, ckId)) {
         iterator.discard(4);
-        return (0, parse_movi_1.parseMovi)({
-            iterator,
-            maxOffset: ckSize + iterator.counter.getOffset() - 4,
-            state,
-            structure,
+        state.videoSection.setVideoSection({
+            start: iterator.counter.getOffset(),
+            size: ckSize - 4,
         });
+        return (0, parse_video_section_1.parseVideoSection)({ state, iterator });
     }
     if (iterator.bytesRemaining() < ckSize) {
-        iterator.counter.decrement(8);
+        checkpoint.returnToCheckpoint();
         return {
-            type: 'incomplete',
-            continueParsing: () => {
-                return (0, exports.expectRiffBox)({ structure, iterator, state });
-            },
+            box: null,
+            skipTo: null,
         };
     }
+    const box = await (0, parse_riff_box_1.parseRiffBox)({
+        id: ckId,
+        iterator,
+        size: ckSize,
+        state,
+    });
+    if (box.type === 'strh-box') {
+        if (box.strf.type === 'strf-box-audio' && state.onAudioTrack) {
+            const audioTrack = (0, get_tracks_from_avi_1.makeAviAudioTrack)({
+                index: state.riff.getNextTrackIndex(),
+                strf: box.strf,
+            });
+            await (0, register_track_1.registerTrack)({
+                state,
+                track: audioTrack,
+                container: 'avi',
+            });
+        }
+        if (state.onVideoTrack && box.strf.type === 'strf-box-video') {
+            const videoTrack = (0, get_tracks_from_avi_1.makeAviVideoTrack)({
+                strh: box,
+                index: state.riff.getNextTrackIndex(),
+                strf: box.strf,
+            });
+            (0, register_track_1.registerVideoTrackWhenProfileIsAvailable)({
+                state,
+                track: videoTrack,
+                container: 'avi',
+            });
+        }
+        state.riff.incrementNextTrackIndex();
+    }
     return {
-        type: 'complete',
-        box: await (0, parse_riff_box_1.parseRiffBox)({
-            id: ckId,
-            iterator,
-            size: ckSize,
-            boxes: structure.boxes,
-            state,
-        }),
+        box,
         skipTo: null,
     };
 };

package/dist/boxes/riff/get-tracks-from-avi.d.ts

@@ -19,4 +19,4 @@ export declare const makeAviVideoTrack: ({ strh, strf, index, }: {
     index: number;
 }) => VideoTrack;
 export declare const getTracksFromAvi: (structure: RiffStructure, state: ParserState) => AllTracks;
-export declare const hasAllTracksFromAvi: (structure: RiffStructure, state: ParserState) => boolean;
+export declare const hasAllTracksFromAvi: (state: ParserState) => boolean;

package/dist/boxes/riff/get-tracks-from-avi.js

@@ -67,9 +67,6 @@ const makeAviVideoTrack = ({ strh, strf, index, }) => {
 };
 exports.makeAviVideoTrack = makeAviVideoTrack;
 const getTracksFromAvi = (structure, state) => {
-    if (!(0, traversal_1.isRiffAvi)(structure)) {
-        throw new Error('Not an AVI file');
-    }
     const videoTracks = [];
     const audioTracks = [];
     const otherTracks = [];
@@ -77,10 +74,10 @@ const getTracksFromAvi = (structure, state) => {
     let i = 0;
     for (const box of boxes) {
         const strh = (0, traversal_1.getStrhBox)(box.children);
-        const strf = (0, traversal_1.getStrfBox)(box.children);
-        if (!strh || !strf) {
+        if (!strh) {
             continue;
         }
+        const { strf } = strh;
         if (strf.type === 'strf-box-video') {
             videoTracks.push((0, add_avc_profile_to_track_1.addAvcProfileToTrack)((0, exports.makeAviVideoTrack)({ strh, strf, index: i }), state.riff.getAvcProfile()));
         }
@@ -95,17 +92,16 @@ const getTracksFromAvi = (structure, state) => {
     return { audioTracks, otherTracks, videoTracks };
 };
 exports.getTracksFromAvi = getTracksFromAvi;
-const hasAllTracksFromAvi = (structure, state) => {
-    if (!(0, traversal_1.isRiffAvi)(structure)) {
-        throw new Error('Not an AVI file');
-    }
+const hasAllTracksFromAvi = (state) => {
     try {
+        const structure = state.structure.getStructure();
         const numberOfTracks = (0, exports.getNumberOfTracks)(structure);
         const tracks = (0, exports.getTracksFromAvi)(structure, state);
         return (tracks.videoTracks.length +
             tracks.audioTracks.length +
             tracks.otherTracks.length ===
-            numberOfTracks);
+            numberOfTracks &&
+            !tracks.videoTracks.find((t) => t.codec === exports.TO_BE_OVERRIDDEN_LATER));
     }
     catch (_a) {
         return false;

package/dist/boxes/riff/parse-box.d.ts

@@ -1,13 +1,7 @@
 import type { BufferIterator } from '../../buffer-iterator';
 import type { Options, ParseMediaFields } from '../../options';
-import type { ParseResult, RiffStructure } from '../../parse-result';
+import type { ParseResult } from '../../parse-result';
 import type { ParserState } from '../../state/parser-state';
-export declare const parseRiffBody: ({ iterator, structure, maxOffset, state, }: {
-    iterator: BufferIterator;
-    structure: RiffStructure;
-    maxOffset: number;
-    state: ParserState;
-}) => Promise<ParseResult>;
 export declare const parseRiff: ({ iterator, state, fields, }: {
     iterator: BufferIterator;
     state: ParserState;