@remotion/media-parser 4.0.247 → 4.0.249

package/dist/boxes/mp3/id3.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseId3 = void 0;
+function combine28Bits(a, b, c, d) {
+    // Mask each number to ignore first bit (& 0x7F)
+    const val1 = a & 0x7f; // 7 bits from first byte
+    const val2 = b & 0x7f; // 7 bits from second byte
+    const val3 = c & 0x7f; // 7 bits from third byte
+    const val4 = d & 0x7f; // 7 bits from fourth byte
+    // Combine all values using bitwise operations
+    return (val1 << 21) | (val2 << 14) | (val3 << 7) | val4;
+}
+const parseId3 = ({ iterator, structure, state, }) => {
+    if (iterator.bytesRemaining() < 9) {
+        return;
+    }
+    const { returnToCheckpoint } = iterator.startCheckpoint();
+    iterator.discard(3);
+    const versionMajor = iterator.getUint8();
+    const versionMinor = iterator.getUint8();
+    const flags = iterator.getUint8();
+    const sizeArr = iterator.getSlice(4);
+    const size = combine28Bits(sizeArr[0], sizeArr[1], sizeArr[2], sizeArr[3]);
+    if (iterator.bytesRemaining() < size) {
+        returnToCheckpoint();
+        return;
+    }
+    const entries = [];
+    const initial = iterator.counter.getOffset();
+    while (iterator.counter.getOffset() < size + initial) {
+        const name = versionMajor === 3
+            ? iterator.getByteString(4, true)
+            : iterator.getByteString(3, true);
+        if (name === '') {
+            iterator.discard(size + initial - iterator.counter.getOffset());
+            break;
+        }
+        const s = versionMajor === 3 ? iterator.getUint32() : iterator.getUint24();
+        if (versionMajor === 3) {
+            iterator.getUint16(); // flags
+        }
+        let subtract = 0;
+        if (!name.startsWith('W')) {
+            iterator.getUint8(); // encoding
+            subtract += 1;
+        }
+        if (name === 'APIC') {
+            const { discardRest } = iterator.planBytes(s - subtract);
+            const mimeType = iterator.readUntilNullTerminator();
+            iterator.getUint16(); // picture type
+            const description = iterator.readUntilNullTerminator();
+            iterator.discard(1);
+            const data = discardRest();
+            state.images.addImage({
+                data,
+                description,
+                mimeType,
+            });
+        }
+        else {
+            const information = iterator.getByteString(s - subtract, true);
+            entries.push({
+                key: name,
+                value: information,
+                trackId: null,
+            });
+        }
+    }
+    structure.boxes.push({
+        type: 'id3-header',
+        flags,
+        size,
+        versionMajor,
+        versionMinor,
+        metatags: entries,
+    });
+};
+exports.parseId3 = parseId3;

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

@@ -0,0 +1,8 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { Mp3Structure, ParseResult } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseMp3: ({ iterator, structure, state, }: {
+    iterator: BufferIterator;
+    structure: Mp3Structure;
+    state: ParserState;
+}) => Promise<ParseResult>;

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

@@ -0,0 +1,57 @@
+"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, structure, state, }) => {
+    const continueParsing = () => {
+        return (0, exports.parseMp3)({ iterator, structure, state });
+    };
+    if (iterator.bytesRemaining() === 0) {
+        return Promise.resolve({
+            status: 'done',
+        });
+    }
+    if (iterator.bytesRemaining() < 3) {
+        return {
+            status: 'incomplete',
+            skipTo: null,
+            continueParsing,
+        };
+    }
+    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 {
+            status: 'incomplete',
+            continueParsing,
+            skipTo: null,
+        };
+    }
+    // ID3 v2 or v3
+    if (bytes[0] === 0x49 && bytes[1] === 0x44 && bytes[2] === 0x33) {
+        (0, id3_1.parseId3)({ iterator, structure, state });
+        return {
+            status: 'incomplete',
+            continueParsing,
+            skipTo: null,
+        };
+    }
+    if (bytes[0] === 0xff) {
+        await (0, parse_mpeg_header_1.parseMpegHeader)({
+            iterator,
+            state,
+        });
+        return {
+            status: 'incomplete',
+            continueParsing,
+            skipTo: null,
+        };
+    }
+    throw new Error('Unknown MP3 header ');
+};
+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,4 +1,5 @@
 import type { BufferIterator } from '../../buffer-iterator';
+import type { Options, ParseMediaFields } from '../../options';
 import type { RiffStructure } from '../../parse-result';
 import type { ParserState } from '../../state/parser-state';
 import type { RiffBox } from './riff-box';
@@ -10,8 +11,9 @@ export type RiffResult = {
     box: RiffBox | null;
     skipTo: number | null;
 };
-export declare const expectRiffBox: ({ iterator, state, structure, }: {
+export declare const expectRiffBox: ({ iterator, state, structure, fields, }: {
     iterator: BufferIterator;
     state: ParserState;
     structure: RiffStructure;
+    fields: Options<ParseMediaFields>;
 }) => Promise<RiffResult>;

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

@@ -4,13 +4,13 @@ exports.expectRiffBox = void 0;
 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 expectRiffBox = async ({ iterator, state, structure, fields, }) => {
     // 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 });
+                return (0, exports.expectRiffBox)({ structure, iterator, state, fields });
             },
         };
     }
@@ -30,7 +30,7 @@ const expectRiffBox = async ({ iterator, state, structure, }) => {
         return {
             type: 'incomplete',
             continueParsing: () => {
-                return (0, exports.expectRiffBox)({ structure, iterator, state });
+                return (0, exports.expectRiffBox)({ structure, iterator, state, fields });
             },
         };
     }
@@ -42,6 +42,7 @@ const expectRiffBox = async ({ iterator, state, structure, }) => {
             size: ckSize,
             boxes: structure.boxes,
             state,
+            fields,
         }),
         skipTo: null,
     };

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;