@remotion/media-parser 4.0.249 → 4.0.251

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-box.d.ts → containers/flac/parse-flac.d.ts}

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

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFlac = void 0;
+const may_skip_video_data_1 = require("../../state/may-skip-video-data");
+const parse_flac_frame_1 = require("./parse-flac-frame");
+const parse_header_1 = require("./parse-header");
+const parse_metadata_1 = require("./parse-metadata");
+const parse_streaminfo_1 = require("./parse-streaminfo");
+const parse_unknown_block_1 = require("./parse-unknown-block");
+const flacTypes = {
+    streaminfo: 0,
+    vorbisComment: 4,
+};
+const parseFlac = ({ iterator, state, }) => {
+    const videoSectionState = state.videoSection.isInVideoSectionState(iterator);
+    if (videoSectionState === 'in-section') {
+        if ((0, may_skip_video_data_1.maySkipVideoData)({ state })) {
+            if (!state.contentLength) {
+                throw new Error('Need content-length for FLAC to parse');
+            }
+            return Promise.resolve({ skipTo: state.contentLength });
+        }
+        return (0, parse_flac_frame_1.parseFlacFrame)({ state, iterator });
+    }
+    const bytes = iterator.getByteString(4, true);
+    if (bytes === 'fLaC') {
+        return (0, parse_header_1.parseFlacHeader)({ state, iterator });
+    }
+    iterator.counter.decrement(4);
+    // https://www.rfc-editor.org/rfc/rfc9639.html#name-streaminfo
+    // section 8.1
+    iterator.startReadingBits();
+    const isLastMetadata = iterator.getBits(1);
+    const metaBlockType = iterator.getBits(7);
+    iterator.stopReadingBits();
+    const size = iterator.getUint24();
+    if (isLastMetadata) {
+        if (!state.contentLength) {
+            throw new Error('Need content-length for FLAC to parse');
+        }
+        state.videoSection.setVideoSection({
+            start: iterator.counter.getOffset() + size,
+            size: state.contentLength - iterator.counter.getOffset() - size,
+        });
+    }
+    if (metaBlockType === flacTypes.streaminfo) {
+        return (0, parse_streaminfo_1.parseStreamInfo)({ iterator, state });
+    }
+    if (metaBlockType === flacTypes.vorbisComment) {
+        return (0, parse_metadata_1.parseVorbisComment)({ iterator, state, size });
+    }
+    return (0, parse_unknown_block_1.parseFlacUnkownBlock)({ iterator, state, size });
+};
+exports.parseFlac = parseFlac;

package/dist/{boxes/mp3/parse-mpeg-header.d.ts → containers/flac/parse-header.d.ts}

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

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFlacHeader = void 0;
+const parseFlacHeader = ({ state, }) => {
+    state.structure.getStructure().boxes.push({
+        type: 'flac-header',
+    });
+    return Promise.resolve({ skipTo: null });
+};
+exports.parseFlacHeader = parseFlacHeader;

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

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

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVorbisComment = void 0;
+const parseVorbisComment = ({ state, iterator, size, }) => {
+    const { expectNoMoreBytes } = iterator.startBox(size);
+    const box = {
+        type: 'flac-vorbis-comment',
+        fields: [],
+    };
+    const vendorLength = iterator.getUint32Le();
+    const vendorString = iterator.getByteString(vendorLength, true);
+    const numberOfFields = iterator.getUint32Le();
+    box.fields.push({ key: 'vendor', value: vendorString, trackId: null });
+    for (let i = 0; i < numberOfFields; i++) {
+        const fieldLength = iterator.getUint32Le();
+        const field = iterator.getByteString(fieldLength, true);
+        const [key, value] = field.split('=');
+        box.fields.push({ key: key.toLowerCase(), value, trackId: null });
+    }
+    state.structure.getStructure().boxes.push(box);
+    expectNoMoreBytes();
+    return Promise.resolve({ skipTo: null });
+};
+exports.parseVorbisComment = parseVorbisComment;

package/dist/{boxes/webm/parse-webm-header.d.ts → containers/flac/parse-streaminfo.d.ts}

@@ -1,9 +1,7 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { Options, ParseMediaFields } from '../../options';
 import type { ParseResult } from '../../parse-result';
 import type { ParserState } from '../../state/parser-state';
-export declare const parseWebm: ({ counter, state, fields, }: {
-    counter: BufferIterator;
+export declare const parseStreamInfo: ({ iterator, state, }: {
+    iterator: BufferIterator;
     state: ParserState;
-    fields: Options<ParseMediaFields>;
 }) => Promise<ParseResult>;

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStreamInfo = void 0;
+const register_track_1 = require("../../register-track");
+const parseStreamInfo = async ({ iterator, state, }) => {
+    const counter = iterator.counter.getOffset();
+    const minimumBlockSize = iterator.getUint16();
+    const maximumBlockSize = iterator.getUint16();
+    const minimumFrameSize = iterator.getUint24();
+    const maximumFrameSize = iterator.getUint24();
+    iterator.startReadingBits();
+    const sampleRate = iterator.getBits(20);
+    const channels = iterator.getBits(3) + 1;
+    const bitsPerSample = iterator.getBits(5);
+    const totalSamples = iterator.getBits(36);
+    iterator.getBits(128); // md5
+    iterator.stopReadingBits();
+    const counterNow = iterator.counter.getOffset();
+    const size = counterNow - counter;
+    iterator.counter.decrement(size);
+    const asUint8Array = iterator.getSlice(size);
+    const flacStreamInfo = {
+        type: 'flac-streaminfo',
+        bitsPerSample,
+        channels,
+        maximumBlockSize,
+        maximumFrameSize,
+        minimumBlockSize,
+        minimumFrameSize,
+        sampleRate,
+        totalSamples,
+    };
+    state.structure.getStructure().boxes.push(flacStreamInfo);
+    await (0, register_track_1.registerTrack)({
+        container: 'flac',
+        state,
+        track: {
+            codec: 'flac',
+            type: 'audio',
+            description: asUint8Array,
+            codecPrivate: asUint8Array,
+            codecWithoutConfig: 'flac',
+            numberOfChannels: channels,
+            sampleRate,
+            timescale: 1000000,
+            trackId: 0,
+            trakBox: null,
+        },
+    });
+    state.callbacks.tracks.setIsDone();
+    return Promise.resolve({ skipTo: null });
+};
+exports.parseStreamInfo = parseStreamInfo;

package/dist/containers/flac/parse-unknown-block.d.ts

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

package/dist/containers/flac/parse-unknown-block.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFlacUnkownBlock = void 0;
+const parseFlacUnkownBlock = ({ iterator, state, size, }) => {
+    iterator.discard(size);
+    state.structure.getStructure().boxes.push({
+        type: 'flac-header',
+    });
+    return Promise.resolve({ skipTo: null });
+};
+exports.parseFlacUnkownBlock = parseFlacUnkownBlock;

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

@@ -0,0 +1,26 @@
+import type { MetadataEntry } from '../../metadata/get-metadata';
+export type FlacHeader = {
+    type: 'flac-header';
+};
+export type FlacStreamInfo = {
+    type: 'flac-streaminfo';
+    minimumBlockSize: number;
+    maximumBlockSize: number;
+    minimumFrameSize: number;
+    maximumFrameSize: number;
+    sampleRate: number;
+    channels: number;
+    bitsPerSample: number;
+    totalSamples: number;
+};
+export type FlacVorbisComment = {
+    type: 'flac-vorbis-comment';
+    fields: MetadataEntry[];
+};
+export type FlacUnknownBlock = {
+    type: 'flac-unknown-block';
+};
+export type FlacStructure = {
+    type: 'flac';
+    boxes: (FlacHeader | FlacStreamInfo | FlacUnknownBlock | FlacVorbisComment)[];
+};

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

@@ -0,0 +1,40 @@
+import type { BaseBox } from './base-type';
+import type { EsdsBox } from './esds/esds';
+import type { FtypBox } from './ftyp';
+import type { MdhdBox } from './mdhd';
+import type { HdlrBox } from './meta/hdlr';
+import type { IlstBox } from './meta/ilst';
+import type { MoovBox } from './moov/moov';
+import type { MvhdBox } from './mvhd';
+import type { Av1CBox } from './stsd/av1c';
+import type { AvccBox } from './stsd/avcc';
+import type { ColorParameterBox } from './stsd/colr';
+import type { CttsBox } from './stsd/ctts';
+import type { HvccBox } from './stsd/hvcc';
+import type { KeysBox } from './stsd/keys';
+import type { MebxBox } from './stsd/mebx';
+import type { PaspBox } from './stsd/pasp';
+import type { StcoBox } from './stsd/stco';
+import type { StscBox } from './stsd/stsc';
+import type { StsdBox } from './stsd/stsd';
+import type { StssBox } from './stsd/stss';
+import type { StszBox } from './stsd/stsz';
+import type { SttsBox } from './stsd/stts';
+import type { TfdtBox } from './tfdt';
+import type { TfhdBox } from './tfhd';
+import type { TkhdBox } from './tkhd';
+import type { TrakBox } from './trak/trak';
+import type { TrunBox } from './trun';
+import type { VoidBox } from './void-box';
+export interface RegularBox extends BaseBox {
+    boxType: string;
+    boxSize: number;
+    children: IsoBaseMediaBox[];
+    offset: number;
+    type: 'regular-box';
+}
+export type BoxAndNext = {
+    box: IsoBaseMediaBox | null;
+    skipTo: number | null;
+};
+export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | IlstBox | EsdsBox | StszBox | StcoBox | StscBox | AvccBox | HvccBox | VoidBox | StssBox | PaspBox | CttsBox | Av1CBox | TrunBox | HdlrBox | ColorParameterBox | TfdtBox | TfhdBox;

package/dist/containers/iso-base-media/get-children.d.ts

@@ -0,0 +1,6 @@
+import type { ParserState } from '../../state/parser-state';
+import type { IsoBaseMediaBox } from './base-media-box';
+export declare const getIsoBaseMediaChildren: ({ state, size, }: {
+    state: ParserState;
+    size: number;
+}) => Promise<IsoBaseMediaBox[]>;

package/dist/containers/iso-base-media/get-children.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIsoBaseMediaChildren = void 0;
+const process_box_1 = require("./process-box");
+const getIsoBaseMediaChildren = async ({ state, size, }) => {
+    const boxes = [];
+    const { iterator } = state;
+    const initial = iterator.counter.getOffset();
+    while (iterator.counter.getOffset() < size + initial) {
+        const parsed = await (0, process_box_1.processBox)(state);
+        if (!parsed.box) {
+            throw new Error('Expected box');
+        }
+        boxes.push(parsed.box);
+    }
+    if (iterator.counter.getOffset() > size + initial) {
+        throw new Error(`read too many bytes - size: ${size}, read: ${iterator.counter.getOffset() - initial}. initial offset: ${initial}`);
+    }
+    return boxes;
+};
+exports.getIsoBaseMediaChildren = getIsoBaseMediaChildren;

package/dist/{boxes → containers}/iso-base-media/get-sample-positions-from-track.d.ts

@@ -1,4 +1,4 @@
 import type { SamplePosition } from '../../get-sample-positions';
-import type { IsoBaseMediaBox } from '../../parse-result';
+import type { IsoBaseMediaBox } from './base-media-box';
 import type { TrakBox } from './trak/trak';
 export declare const getSamplePositionsFromTrack: (trakBox: TrakBox, moofBox: IsoBaseMediaBox | null) => SamplePosition[];

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

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

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMdatSection = void 0;
+const convert_audio_or_video_sample_1 = require("../../../convert-audio-or-video-sample");
+const get_tracks_1 = require("../../../get-tracks");
+const cached_sample_positions_1 = require("../../../state/iso-base-media/cached-sample-positions");
+const may_skip_video_data_1 = require("../../../state/may-skip-video-data");
+const parseMdatSection = async (state) => {
+    const videoSection = state.videoSection.getVideoSection();
+    // don't need mdat at all, can skip
+    if ((0, may_skip_video_data_1.maySkipVideoData)({ state })) {
+        return videoSection.size + videoSection.start;
+    }
+    const alreadyHas = (0, get_tracks_1.getHasTracks)(state);
+    if (!alreadyHas) {
+        // Will first read the end and then return
+        if (state.supportsContentRange) {
+            state.iso.setShouldReturnToVideoSectionAfterEnd(true);
+            return videoSection.size + videoSection.start;
+        }
+        throw new Error('Source does not support reading partially, but metadata is at the end of the file. This would require buffering the entire file in memory, leading to a leak. Remotion does not currently support this scenario, make sure to pass a source that supports Content-Range.');
+    }
+    if (!state.iso.flatSamples.getSamples()) {
+        state.iso.flatSamples.setSamples((0, cached_sample_positions_1.calculateFlatSamples)(state));
+    }
+    const flatSamples = state.iso.flatSamples.getSamples();
+    const { iterator } = state;
+    const samplesWithIndex = flatSamples.find((sample) => {
+        return sample.samplePosition.offset === iterator.counter.getOffset();
+    });
+    if (!samplesWithIndex) {
+        // There are various reasons why in mdat we find weird stuff:
+        // - iphonevideo.hevc has a fake hoov atom which is not mapped
+        // - corrupted.mp4 has a corrupt table
+        const nextSample_ = flatSamples
+            .filter((s) => s.samplePosition.offset > iterator.counter.getOffset())
+            .sort((a, b) => a.samplePosition.offset - b.samplePosition.offset)[0];
+        if (nextSample_) {
+            iterator.discard(nextSample_.samplePosition.offset - iterator.counter.getOffset());
+            return null;
+        }
+        // guess we reached the end!
+        // iphonevideo.mov has extra padding here, so let's make sure to jump ahead
+        return videoSection.size + videoSection.start;
+    }
+    if (iterator.bytesRemaining() < samplesWithIndex.samplePosition.size) {
+        return null;
+    }
+    const bytes = iterator.getSlice(samplesWithIndex.samplePosition.size);
+    const { cts, dts, duration, isKeyframe, offset } = samplesWithIndex.samplePosition;
+    if (samplesWithIndex.track.type === 'audio') {
+        await state.callbacks.onAudioSample(samplesWithIndex.track.trackId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+            data: bytes,
+            timestamp: cts,
+            duration,
+            cts,
+            dts,
+            trackId: samplesWithIndex.track.trackId,
+            type: isKeyframe ? 'key' : 'delta',
+            offset,
+            timescale: samplesWithIndex.track.timescale,
+        }, samplesWithIndex.track.timescale));
+    }
+    if (samplesWithIndex.track.type === 'video') {
+        // https://remotion-assets.s3.eu-central-1.amazonaws.com/example-videos/sei_checkpoint.mp4
+        // Position in file 0x0001aba615
+        // https://github.com/remotion-dev/remotion/issues/4680
+        // In Chrome, we may not treat recovery points as keyframes
+        // otherwise "a keyframe is required after flushing"
+        const nalUnitType = bytes[4] & 0b00011111;
+        let isRecoveryPoint = false;
+        // SEI (Supplemental enhancement information)
+        if (nalUnitType === 6) {
+            const seiType = bytes[5];
+            isRecoveryPoint = seiType === 6;
+        }
+        await state.callbacks.onVideoSample(samplesWithIndex.track.trackId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+            data: bytes,
+            timestamp: cts,
+            duration,
+            cts,
+            dts,
+            trackId: samplesWithIndex.track.trackId,
+            type: isKeyframe && !isRecoveryPoint ? 'key' : 'delta',
+            offset,
+            timescale: samplesWithIndex.track.timescale,
+        }, samplesWithIndex.track.timescale));
+    }
+    return null;
+};
+exports.parseMdatSection = parseMdatSection;

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

@@ -0,0 +1,12 @@
+import type { AnySegment } from '../../../parse-result';
+import type { ParserState } from '../../../state/parser-state';
+import type { BaseBox } from '../base-type';
+export interface MoovBox extends BaseBox {
+    type: 'moov-box';
+    children: AnySegment[];
+}
+export declare const parseMoov: ({ offset, size, state, }: {
+    offset: number;
+    size: number;
+    state: ParserState;
+}) => Promise<MoovBox>;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMoov = void 0;
+const get_children_1 = require("../get-children");
+const parseMoov = async ({ offset, size, state, }) => {
+    const children = await (0, get_children_1.getIsoBaseMediaChildren)({
+        state,
+        size: size - 8,
+    });
+    return {
+        offset,
+        boxSize: size,
+        type: 'moov-box',
+        children,
+    };
+};
+exports.parseMoov = parseMoov;

package/dist/containers/iso-base-media/parse-boxes.d.ts

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