@remotion/media-parser 4.0.249 → 4.0.251

package/dist/add-avc-profile-to-track.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addAvcProfileToTrack = void 0;
-const codec_string_1 = require("./boxes/avc/codec-string");
-const create_sps_pps_data_1 = require("./boxes/avc/create-sps-pps-data");
+const codec_string_1 = require("./containers/avc/codec-string");
+const create_sps_pps_data_1 = require("./containers/avc/create-sps-pps-data");
 const addAvcProfileToTrack = (track, avc1Profile) => {
     if (avc1Profile === null) {
         return track;

package/dist/buffer-iterator.d.ts

@@ -12,16 +12,15 @@ export declare class OffsetCounter {
 export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes: number | null) => {
     startReadingBits: () => void;
     stopReadingBits: () => void;
-    skipTo: (offset: number, reset: boolean) => void;
+    skipTo: (offset: number) => void;
     addData: (newData: Uint8Array) => void;
     counter: OffsetCounter;
     peekB: (length: number) => void;
     peekD: (length: number) => void;
     getBits: (bits: number) => number;
-    byteLength: () => number;
     bytesRemaining: () => number;
     leb128: () => number;
-    removeBytesRead: () => void;
+    removeBytesRead: (force: boolean) => number | undefined;
     discard: (length: number) => void;
     getEightByteNumber: (littleEndian?: boolean) => number;
     getFourByteNumber: () => number;
@@ -58,8 +57,6 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes:
     getInt32Le: () => number;
     getInt32: () => number;
     destroy: () => void;
-    disallowDiscard: () => void;
-    allowDiscard: () => void;
     startBox: (size: number) => {
         discardRest: () => void;
         expectNoMoreBytes: () => void;
@@ -68,5 +65,6 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes:
     startCheckpoint: () => {
         returnToCheckpoint: () => void;
     };
+    getFlacCodecNumber: () => number;
 };
 export type BufferIterator = ReturnType<typeof getArrayBufferIterator>;

package/dist/buffer-iterator.js

@@ -14,7 +14,7 @@ var _OffsetCounter_offset, _OffsetCounter_discardedBytes;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getArrayBufferIterator = exports.OffsetCounter = void 0;
 /* eslint-disable @typescript-eslint/no-use-before-define */
-const all_segments_1 = require("./boxes/webm/segments/all-segments");
+const all_segments_1 = require("./containers/webm/segments/all-segments");
 const file_types_1 = require("./file-types");
 class OffsetCounter {
     constructor(initial) {
@@ -65,11 +65,10 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
     if (!buf.resize) {
         throw new Error('`ArrayBuffer.resize` is not supported in this Runtime. On the server: Use at least Node.js 20 or Bun. In the browser: Chrome 111, Edge 111, Safari 16.4, Firefox 128, Opera 111');
     }
-    let data = new Uint8Array(buf);
-    data.set(initialData);
-    let view = new DataView(data.buffer);
+    let uintArray = new Uint8Array(buf);
+    uintArray.set(initialData);
+    let view = new DataView(uintArray.buffer);
     const counter = makeOffsetCounter();
-    let discardAllowed = true;
     const startCheckpoint = () => {
         const checkpoint = counter.getOffset();
         return {
@@ -79,16 +78,10 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         };
     };
     const getSlice = (amount) => {
-        const value = data.slice(counter.getDiscardedOffset(), counter.getDiscardedOffset() + amount);
+        const value = uintArray.slice(counter.getDiscardedOffset(), counter.getDiscardedOffset() + amount);
         counter.increment(amount);
         return value;
     };
-    const disallowDiscard = () => {
-        discardAllowed = false;
-    };
-    const allowDiscard = () => {
-        discardAllowed = true;
-    };
     const discard = (length) => {
         counter.increment(length);
     };
@@ -199,56 +192,50 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
     const addData = (newData) => {
         const oldLength = buf.byteLength;
         const newLength = oldLength + newData.byteLength;
+        if (newLength < oldLength) {
+            throw new Error('Cannot decrement size');
+        }
+        if (newLength > (maxBytes !== null && maxBytes !== void 0 ? maxBytes : Infinity)) {
+            throw new Error(`Exceeded maximum byte length ${maxBytes} with ${newLength}`);
+        }
         buf.resize(newLength);
         const newArray = new Uint8Array(buf);
         newArray.set(newData, oldLength);
-        data = newArray;
-        view = new DataView(data.buffer);
-    };
-    const byteLength = () => {
-        return data.byteLength;
+        uintArray = newArray;
+        view = new DataView(uintArray.buffer);
     };
     const bytesRemaining = () => {
-        return data.byteLength - counter.getDiscardedOffset();
+        return uintArray.byteLength - counter.getDiscardedOffset();
     };
-    const removeBytesRead = () => {
-        if (!discardAllowed) {
-            return;
-        }
+    const removeBytesRead = (force) => {
         const bytesToRemove = counter.getDiscardedOffset();
         // Only do this operation if it is really worth it 😇
-        if (bytesToRemove < 100000) {
+        // let's set the threshold to 3MB
+        if (bytesToRemove < 3000000 && !force) {
+            return;
+        }
+        // Don't remove if the data is not even available
+        if (view.byteLength < bytesToRemove && !force) {
             return;
         }
         counter.discardBytes(bytesToRemove);
-        const newData = data.slice(bytesToRemove);
-        data.set(newData);
+        const newData = uintArray.slice(bytesToRemove);
+        uintArray.set(newData);
         buf.resize(newData.byteLength);
-        view = new DataView(data.buffer);
+        view = new DataView(uintArray.buffer);
+        return bytesToRemove;
     };
-    const skipTo = (offset, reset) => {
+    const skipTo = (offset) => {
         const becomesSmaller = offset < counter.getOffset();
-        if (becomesSmaller) {
-            if (reset) {
-                buf.resize(0);
-                counter.decrement(counter.getOffset() - offset);
-                counter.setDiscardedOffset(offset);
-            }
-            else {
-                const toDecrement = counter.getOffset() - offset;
-                const newOffset = counter.getOffset() - toDecrement;
-                counter.decrement(toDecrement);
-                const c = counter.getDiscardedBytes();
-                if (c > newOffset) {
-                    throw new Error('already discarded too many bytes');
-                }
-            }
-        }
-        else {
+        if (!becomesSmaller) {
             const currentOffset = counter.getOffset();
             counter.increment(offset - currentOffset);
-            removeBytesRead();
+            removeBytesRead(true);
+            return;
         }
+        buf.resize(0);
+        counter.decrement(counter.getOffset() - offset);
+        counter.setDiscardedOffset(offset);
     };
     const readExpGolomb = () => {
         if (!bitReadingMode) {
@@ -299,6 +286,37 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         bitReadingMode = true;
         byteToShift = getUint8();
     };
+    // https://www.rfc-editor.org/rfc/rfc9639.html#name-coded-number
+    const getFlacCodecNumber = () => {
+        let ones = 0;
+        let bits = 0;
+        // eslint-disable-next-line no-constant-binary-expression
+        while ((++bits || true) && getBits(1) === 1) {
+            ones++;
+        }
+        if (ones === 0) {
+            return getBits(7);
+        }
+        const bitArray = [];
+        const firstByteBits = 8 - ones - 1;
+        for (let i = 0; i < firstByteBits; i++) {
+            bitArray.unshift(getBits(1));
+        }
+        const extraBytes = ones - 1;
+        for (let i = 0; i < extraBytes; i++) {
+            for (let j = 0; j < 8; j++) {
+                const val = getBits(1);
+                if (j < 2) {
+                    continue;
+                }
+                bitArray.unshift(val);
+            }
+        }
+        const encoded = bitArray.reduce((acc, bit, index) => {
+            return acc | (bit << index);
+        }, 0);
+        return encoded;
+    };
     const getBits = (bits) => {
         let result = 0;
         let bitsCollected = 0;
@@ -319,7 +337,7 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         return result;
     };
     const destroy = () => {
-        data = new Uint8Array(0);
+        uintArray = new Uint8Array(0);
         buf.resize(0);
     };
     return {
@@ -331,7 +349,6 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         peekB,
         peekD,
         getBits,
-        byteLength,
         bytesRemaining,
         leb128,
         removeBytesRead,
@@ -344,7 +361,7 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
             return new TextDecoder().decode(atom);
         },
         detectFileType: () => {
-            return (0, file_types_1.detectFileType)(data);
+            return (0, file_types_1.detectFileType)(uintArray);
         },
         getPaddedFourByteNumber,
         getMatroskaSegmentId: () => {
@@ -536,11 +553,10 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         getInt32Le,
         getInt32,
         destroy,
-        disallowDiscard,
-        allowDiscard,
         startBox,
         readExpGolomb,
         startCheckpoint,
+        getFlacCodecNumber,
     };
 };
 exports.getArrayBufferIterator = getArrayBufferIterator;

package/dist/containers/aac/parse-aac.d.ts

@@ -0,0 +1,3 @@
+import type { ParseResult } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseAac: (state: ParserState) => Promise<ParseResult>;

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAac = void 0;
+const aac_codecprivate_1 = require("../../aac-codecprivate");
+const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
+const register_track_1 = require("../../register-track");
+const parseAac = async (state) => {
+    const { iterator } = state;
+    const startOffset = iterator.counter.getOffset();
+    iterator.startReadingBits();
+    const syncWord = iterator.getBits(12);
+    if (syncWord !== 0xfff) {
+        throw new Error('Invalid syncword: ' + syncWord);
+    }
+    const id = iterator.getBits(1);
+    if (id !== 0) {
+        throw new Error('Only supporting MPEG-4 for .aac');
+    }
+    const layer = iterator.getBits(2);
+    if (layer !== 0) {
+        throw new Error('Only supporting layer 0 for .aac');
+    }
+    const protectionAbsent = iterator.getBits(1); // protection absent
+    const audioObjectType = iterator.getBits(2); // 1 = 'AAC-LC'
+    const samplingFrequencyIndex = iterator.getBits(4);
+    const sampleRate = (0, aac_codecprivate_1.getSampleRateFromSampleFrequencyIndex)(samplingFrequencyIndex);
+    iterator.getBits(1); // private bit
+    const channelConfiguration = iterator.getBits(3);
+    const codecPrivate = (0, aac_codecprivate_1.createAacCodecPrivate)({
+        audioObjectType,
+        sampleRate,
+        channelConfiguration,
+    });
+    iterator.getBits(1); // originality
+    iterator.getBits(1); // home
+    iterator.getBits(1); // copyright bit
+    iterator.getBits(1); // copy start
+    const frameLength = iterator.getBits(13); // frame length
+    iterator.getBits(11); // buffer fullness
+    iterator.getBits(2); // number of AAC frames minus 1
+    if (!protectionAbsent) {
+        iterator.getBits(16); // crc
+    }
+    iterator.stopReadingBits();
+    iterator.counter.decrement(iterator.counter.getOffset() - startOffset);
+    const data = iterator.getSlice(frameLength);
+    if (state.callbacks.tracks.getTracks().length === 0) {
+        await (0, register_track_1.registerTrack)({
+            state,
+            container: 'aac',
+            track: {
+                codec: (0, aac_codecprivate_1.mapAudioObjectTypeToCodecString)(audioObjectType),
+                codecWithoutConfig: 'aac',
+                codecPrivate,
+                description: codecPrivate,
+                numberOfChannels: channelConfiguration,
+                sampleRate,
+                timescale: 1000000,
+                trackId: 0,
+                trakBox: null,
+                type: 'audio',
+            },
+        });
+        state.callbacks.tracks.setIsDone();
+    }
+    const duration = 1024 / sampleRate;
+    const { index } = state.aac.addSample({ offset: startOffset, size: frameLength });
+    const timestamp = (1024 / sampleRate) * index;
+    // One ADTS frame contains 1024 samples
+    await state.callbacks.onAudioSample(0, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+        duration,
+        type: 'key',
+        data,
+        offset: startOffset,
+        timescale: 1000000,
+        trackId: 0,
+        cts: timestamp,
+        dts: timestamp,
+        timestamp,
+    }, 1));
+    return Promise.resolve({ skipTo: null });
+};
+exports.parseAac = parseAac;

package/dist/containers/aac/types.d.ts

@@ -0,0 +1,4 @@
+export type AacStructure = {
+    type: 'aac';
+    boxes: never[];
+};

package/dist/{boxes → containers}/avc/key.d.ts

@@ -1,2 +1,2 @@
 import type { AvcInfo } from './parse-avc';
-export declare const getKeyFrameOrDeltaFromAvcInfo: (infos: AvcInfo[]) => "delta" | "key";
+export declare const getKeyFrameOrDeltaFromAvcInfo: (infos: AvcInfo[]) => "key" | "delta";

package/dist/containers/flac/get-block-size.d.ts

@@ -0,0 +1,2 @@
+import type { BufferIterator } from '../../buffer-iterator';
+export declare const getBlockSize: (iterator: BufferIterator) => number | "uncommon-u16" | "uncommon-u8";

package/dist/containers/flac/get-block-size.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBlockSize = void 0;
+const getBlockSize = (iterator) => {
+    const bits = iterator.getBits(4);
+    if (bits === 0b0000) {
+        throw new Error('Reserved block size');
+    }
+    if (bits === 0b0001) {
+        return 192;
+    }
+    if (bits >= 0b0010 && bits <= 0b0101) {
+        return 144 * 2 ** bits;
+    }
+    if (bits === 0b0110) {
+        return 'uncommon-u8';
+    }
+    if (bits === 0b0111) {
+        return 'uncommon-u16';
+    }
+    if (bits >= 0b1000 && bits <= 0b1111) {
+        return 2 ** bits;
+    }
+    throw new Error('Invalid block size');
+};
+exports.getBlockSize = getBlockSize;

package/dist/containers/flac/get-channel-count.d.ts

@@ -0,0 +1,2 @@
+import type { BufferIterator } from '../../buffer-iterator';
+export declare const getChannelCount: (iterator: BufferIterator) => 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;

package/dist/containers/flac/get-channel-count.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChannelCount = void 0;
+// https://www.rfc-editor.org/rfc/rfc9639.html#name-channels-bits
+const getChannelCount = (iterator) => {
+    const bits = iterator.getBits(4);
+    if (bits === 0b0000) {
+        return 1;
+    }
+    if (bits === 0b0001) {
+        return 2;
+    }
+    if (bits === 0b0010) {
+        return 3;
+    }
+    if (bits === 0b0011) {
+        return 4;
+    }
+    if (bits === 0b0100) {
+        return 5;
+    }
+    if (bits === 0b0101) {
+        return 6;
+    }
+    if (bits === 0b0110) {
+        return 7;
+    }
+    if (bits === 0b0111) {
+        return 8;
+    }
+    if (bits === 0b1000 || bits === 0b1001 || bits === 0b1010) {
+        return 2;
+    }
+    throw new Error(`Invalid channel count: ${bits.toString(2)}`);
+};
+exports.getChannelCount = getChannelCount;

package/dist/containers/flac/get-duration-from-flac.d.ts

@@ -0,0 +1,2 @@
+import type { ParserState } from '../../state/parser-state';
+export declare const getDurationFromFlac: (parserState: ParserState) => number;

package/dist/containers/flac/get-duration-from-flac.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDurationFromFlac = void 0;
+const getDurationFromFlac = (parserState) => {
+    const structure = parserState.structure.getStructure();
+    if (structure.type !== 'flac') {
+        throw new Error('Not a FLAC file');
+    }
+    const streaminfo = structure.boxes.find((b) => b.type === 'flac-streaminfo');
+    if (!streaminfo) {
+        throw new Error('Streaminfo not found');
+    }
+    return streaminfo.totalSamples / streaminfo.sampleRate;
+};
+exports.getDurationFromFlac = getDurationFromFlac;

package/dist/containers/flac/get-metadata-from-flac.d.ts

@@ -0,0 +1,2 @@
+import type { FlacStructure } from './types';
+export declare const getMetadataFromFlac: (structure: FlacStructure) => import("../..").MetadataEntry[] | null;

package/dist/containers/flac/get-metadata-from-flac.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetadataFromFlac = void 0;
+const getMetadataFromFlac = (structure) => {
+    const box = structure.boxes.find((b) => b.type === 'flac-vorbis-comment');
+    if (!box) {
+        return null;
+    }
+    return box.fields;
+};
+exports.getMetadataFromFlac = getMetadataFromFlac;

package/dist/containers/flac/get-sample-rate.d.ts

@@ -0,0 +1,3 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { ParserState } from '../../state/parser-state';
+export declare const getSampleRate: (iterator: BufferIterator, state: ParserState) => number | "uncommon-u8" | "uncommon-u16" | "uncommon-u16-10";

package/dist/containers/flac/get-sample-rate.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSampleRate = void 0;
+// https://www.rfc-editor.org/rfc/rfc9639.html#name-sample-rate-bits
+const getSampleRate = (iterator, state) => {
+    var _a, _b;
+    const mode = iterator.getBits(4);
+    if (mode === 0b0000) {
+        const structure = state.structure.getStructure();
+        const sampleRate = (_b = (_a = structure.boxes.find((box) => box.type === 'flac-streaminfo')) === null || _a === void 0 ? void 0 : _a.sampleRate) !== null && _b !== void 0 ? _b : null;
+        if (sampleRate === null) {
+            throw new Error('Sample rate not found');
+        }
+        return sampleRate;
+    }
+    if (mode === 0b0001) {
+        return 88200;
+    }
+    if (mode === 0b0010) {
+        return 176400;
+    }
+    if (mode === 0b0011) {
+        return 192000;
+    }
+    if (mode === 0b0100) {
+        return 8000;
+    }
+    if (mode === 0b0101) {
+        return 16000;
+    }
+    if (mode === 0b0110) {
+        return 22050;
+    }
+    if (mode === 0b0111) {
+        return 24000;
+    }
+    if (mode === 0b1000) {
+        return 32000;
+    }
+    if (mode === 0b1001) {
+        return 44100;
+    }
+    if (mode === 0b1010) {
+        return 48000;
+    }
+    if (mode === 0b1011) {
+        return 96000;
+    }
+    if (mode === 0b1100) {
+        return 'uncommon-u8';
+    }
+    if (mode === 0b1101) {
+        return 'uncommon-u16';
+    }
+    if (mode === 0b1110) {
+        return 'uncommon-u16-10';
+    }
+    throw new Error(`Invalid sample rate mode: ${mode.toString(2)}`);
+};
+exports.getSampleRate = getSampleRate;

package/dist/containers/flac/parse-flac-frame.d.ts

@@ -0,0 +1,15 @@
+import { type BufferIterator } from '../../buffer-iterator';
+import type { ParseResult } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseFrameHeader: ({ iterator, state, }: {
+    iterator: BufferIterator;
+    state: ParserState;
+}) => {
+    num: number;
+    blockSize: number;
+    sampleRate: number;
+} | null;
+export declare const parseFlacFrame: ({ state, iterator, }: {
+    state: ParserState;
+    iterator: BufferIterator;
+}) => Promise<ParseResult>;