@remotion/media-parser 4.0.250 → 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,7 +12,7 @@ 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;
@@ -20,7 +20,7 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes:
     getBits: (bits: number) => number;
     bytesRemaining: () => number;
     leb128: () => number;
-    removeBytesRead: () => void;
+    removeBytesRead: (force: boolean) => number | undefined;
     discard: (length: number) => void;
     getEightByteNumber: (littleEndian?: boolean) => number;
     getFourByteNumber: () => number;
@@ -65,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,9 +65,9 @@ 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();
     const startCheckpoint = () => {
         const checkpoint = counter.getOffset();
@@ -78,7 +78,7 @@ 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;
     };
@@ -201,47 +201,41 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         buf.resize(newLength);
         const newArray = new Uint8Array(buf);
         newArray.set(newData, oldLength);
-        data = newArray;
-        view = new DataView(data.buffer);
+        uintArray = newArray;
+        view = new DataView(uintArray.buffer);
     };
     const bytesRemaining = () => {
-        return data.byteLength - counter.getDiscardedOffset();
+        return uintArray.byteLength - counter.getDiscardedOffset();
     };
-    const removeBytesRead = () => {
+    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) {
@@ -292,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;
@@ -312,7 +337,7 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         return result;
     };
     const destroy = () => {
-        data = new Uint8Array(0);
+        uintArray = new Uint8Array(0);
         buf.resize(0);
     };
     return {
@@ -336,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: () => {
@@ -531,6 +556,7 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         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>;

package/dist/containers/flac/parse-flac-frame.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFlacFrame = exports.parseFrameHeader = void 0;
+const buffer_iterator_1 = require("../../buffer-iterator");
+const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
+const get_block_size_1 = require("./get-block-size");
+const get_channel_count_1 = require("./get-channel-count");
+const get_sample_rate_1 = require("./get-sample-rate");
+// https://www.rfc-editor.org/rfc/rfc9639.html#section-9.1.1
+function calculateCRC8(data) {
+    const polynomial = 0x07; // x^8 + x^2 + x^1 + x^0
+    let crc = 0x00; // Initialize CRC to 0
+    for (const byte of data) {
+        crc ^= byte; // XOR byte into least significant byte of crc
+        for (let i = 0; i < 8; i++) {
+            // For each bit in the byte
+            if ((crc & 0x80) !== 0) {
+                // If the leftmost bit (MSB) is set
+                crc = (crc << 1) ^ polynomial; // Shift left and XOR with polynomial
+            }
+            else {
+                crc <<= 1; // Just shift left
+            }
+            crc &= 0xff; // Ensure CRC remains 8-bit
+        }
+    }
+    return crc;
+}
+const parseFrameHeader = ({ iterator, state, }) => {
+    if (iterator.bytesRemaining() < 10) {
+        return null;
+    }
+    const startOffset = iterator.counter.getOffset();
+    iterator.discard(2); // sync code
+    iterator.startReadingBits();
+    const blockSizeBits = (0, get_block_size_1.getBlockSize)(iterator);
+    const sampleRateBits = (0, get_sample_rate_1.getSampleRate)(iterator, state);
+    (0, get_channel_count_1.getChannelCount)(iterator); // channel count
+    iterator.getBits(3); // bit depth
+    iterator.getBits(1);
+    const num = iterator.getFlacCodecNumber();
+    const blockSize = blockSizeBits === 'uncommon-u16'
+        ? iterator.getBits(16) + 1
+        : blockSizeBits === 'uncommon-u8'
+            ? iterator.getBits(8) + 1
+            : blockSizeBits;
+    const sampleRate = sampleRateBits === 'uncommon-u16'
+        ? iterator.getBits(16)
+        : sampleRateBits === 'uncommon-u16-10'
+            ? iterator.getBits(16) * 10
+            : sampleRateBits === 'uncommon-u8'
+                ? iterator.getBits(8)
+                : sampleRateBits;
+    iterator.stopReadingBits();
+    const size = iterator.counter.getOffset() - startOffset;
+    const crc = iterator.getUint8();
+    iterator.counter.decrement(size + 1);
+    const crcCalculated = calculateCRC8(iterator.getSlice(size));
+    iterator.counter.decrement(size);
+    if (crcCalculated !== crc) {
+        return null;
+    }
+    return { num, blockSize, sampleRate };
+};
+exports.parseFrameHeader = parseFrameHeader;
+const emitSample = async ({ state, data, offset, }) => {
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(data, null);
+    const parsed = (0, exports.parseFrameHeader)({ iterator, state });
+    if (!parsed) {
+        throw new Error('Invalid CRC');
+    }
+    const { blockSize, num, sampleRate } = parsed;
+    const duration = blockSize / sampleRate;
+    const structure = state.structure.getStructure();
+    const streamInfo = structure.boxes.find((box) => box.type === 'flac-streaminfo');
+    if (!streamInfo) {
+        throw new Error('Stream info not found');
+    }
+    if (streamInfo.minimumBlockSize !== streamInfo.maximumBlockSize) {
+        throw new Error('Cannot determine timestamp');
+    }
+    const timestamp = (num * streamInfo.maximumBlockSize) / streamInfo.sampleRate;
+    await state.callbacks.onAudioSample(0, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+        data,
+        duration,
+        cts: timestamp,
+        dts: timestamp,
+        timestamp,
+        type: 'key',
+        offset,
+        timescale: 1000000,
+        trackId: 0,
+    }, 1));
+    iterator.destroy();
+};
+const parseFlacFrame = async ({ state, iterator, }) => {
+    var _a, _b;
+    const blockingBit = state.flac.getBlockingBitStrategy();
+    const offset = iterator.counter.getOffset();
+    const { returnToCheckpoint } = iterator.startCheckpoint();
+    iterator.startReadingBits();
+    if (blockingBit === undefined) {
+        const bits = iterator.getBits(15);
+        if (bits !== 0b111111111111100) {
+            throw new Error('Invalid sync code');
+        }
+        state.flac.setBlockingBitStrategy(iterator.getBits(1));
+    }
+    else if (blockingBit === 1) {
+        const bits = iterator.getBits(16);
+        if (bits !== 0b1111111111111001) {
+            throw new Error('Blocking bit changed, it should not');
+        }
+    }
+    else if (blockingBit === 0) {
+        const bits = iterator.getBits(16);
+        if (bits !== 0b1111111111111000) {
+            throw new Error('Blocking bit changed, it should not');
+        }
+    }
+    const setBlockingBit = state.flac.getBlockingBitStrategy();
+    if (setBlockingBit === undefined) {
+        throw new Error('Blocking bit should be set');
+    }
+    iterator.stopReadingBits();
+    const structure = state.structure.getStructure();
+    if (structure.type !== 'flac') {
+        throw new Error('Expected flac-structure');
+    }
+    const minimumFrameSize = (_b = (_a = structure.boxes.find((b) => b.type === 'flac-streaminfo')) === null || _a === void 0 ? void 0 : _a.minimumFrameSize) !== null && _b !== void 0 ? _b : null;
+    if (minimumFrameSize === null) {
+        throw new Error('Expected flac-streaminfo');
+    }
+    if (minimumFrameSize !== 0) {
+        iterator.getSlice(minimumFrameSize - 2);
+    }
+    while (true) {
+        if (!state.contentLength) {
+            throw new Error('Need content-length for FLAC to parse');
+        }
+        if (iterator.counter.getOffset() === state.contentLength) {
+            const size = iterator.counter.getOffset() - offset;
+            returnToCheckpoint();
+            const slice = iterator.getSlice(size);
+            await emitSample({ state, data: slice, offset });
+            break;
+        }
+        if (iterator.bytesRemaining() === 0) {
+            returnToCheckpoint();
+            break;
+        }
+        const nextByte = iterator.getUint8();
+        if (nextByte === 0xff) {
+            const nextBits = iterator.getUint8();
+            const expected = setBlockingBit === 1 ? 249 : 248;
+            if (nextBits !== expected) {
+                iterator.counter.decrement(1);
+                continue;
+            }
+            iterator.counter.decrement(2);
+            const nextIsLegit = (0, exports.parseFrameHeader)({ iterator, state });
+            if (!nextIsLegit) {
+                iterator.discard(1);
+                continue;
+            }
+            const size = iterator.counter.getOffset() - offset;
+            returnToCheckpoint();
+            const data = iterator.getSlice(size);
+            await emitSample({ state, data, offset });
+            break;
+        }
+    }
+    return { skipTo: null };
+};
+exports.parseFlacFrame = parseFlacFrame;

package/dist/{boxes/riff/parse-riff.d.ts → containers/flac/parse-flac.d.ts}

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