@remotion/media-parser 4.0.249 → 4.0.250

package/dist/boxes/iso-base-media/continue-mdat-routine.d.ts

@@ -0,0 +1,14 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { LogLevel } from '../../log';
+import type { Options, ParseMediaFields } from '../../options';
+import type { IsoBaseMediaBox, ParseResult } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export declare const continueMdatRoutine: ({ iterator, maxBytes, initialBoxes, state, signal, logLevel, fields, }: {
+    iterator: BufferIterator;
+    maxBytes: number;
+    initialBoxes: IsoBaseMediaBox[];
+    state: ParserState;
+    signal: AbortSignal | null;
+    logLevel: LogLevel;
+    fields: Options<ParseMediaFields>;
+}) => Promise<ParseResult>;

package/dist/boxes/iso-base-media/continue-mdat-routine.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.continueMdatRoutine = void 0;
+const has_all_info_1 = require("../../has-all-info");
+const may_skip_video_data_1 = require("../../may-skip-video-data/may-skip-video-data");
+const parse_boxes_1 = require("./parse-boxes");
+const traversal_1 = require("./traversal");
+const continueMdatRoutine = async ({ iterator, maxBytes, initialBoxes, state, signal, logLevel, fields, }) => {
+    var _a;
+    const continueParsing = () => {
+        return (0, parse_boxes_1.parseIsoBaseMedia)({
+            iterator,
+            maxBytes,
+            initialBoxes,
+            state,
+            signal,
+            logLevel,
+        });
+    };
+    const result = await parseMdatPartially({
+        iterator,
+        boxSize: continueMdat.boxSize,
+        fileOffset: continueMdat.fileOffset,
+        parsedBoxes: initialBoxes,
+        state,
+        signal,
+    });
+    if (result.type === 'incomplete') {
+        throw new Error('Incomplete boxes are not allowed in this routine');
+    }
+    if (result.type === 'partial-mdat-box') {
+        return {
+            status: 'incomplete',
+            continueParsing,
+            skipTo: null,
+        };
+    }
+    const alreadyHasMdat = (_a = state.structure
+        .getStructureOrNull()) === null || _a === void 0 ? void 0 : _a.boxes.find((b) => b.type === 'mdat-box');
+    if (result.box.type === 'mdat-box' && alreadyHasMdat) {
+        initialBoxes = initialBoxes.filter((b) => b.type !== 'mdat-box');
+        initialBoxes.push(result.box);
+        iterator.allowDiscard();
+        return {
+            continueParsing,
+            skipTo: null,
+            status: 'incomplete',
+        };
+    }
+    initialBoxes.push(result.box);
+    if ((0, has_all_info_1.hasAllInfo)({ fields, state })) {
+        return {
+            status: 'done',
+        };
+    }
+    iterator.removeBytesRead();
+    const mdatState = (0, traversal_1.getMdatBox)(initialBoxes);
+    const skipped = (mdatState === null || mdatState === void 0 ? void 0 : mdatState.status) === 'samples-skipped' &&
+        !(0, may_skip_video_data_1.maySkipVideoData)({ state }) &&
+        state.supportsContentRange;
+    if (skipped) {
+        return {
+            status: 'incomplete',
+            continueParsing,
+            skipTo: mdatState.fileOffset,
+        };
+    }
+    return {
+        status: 'incomplete',
+        continueParsing,
+        skipTo: null,
+    };
+};
+exports.continueMdatRoutine = continueMdatRoutine;

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

@@ -1,14 +1,8 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { LogLevel } from '../../log';
-import type { Options, ParseMediaFields } from '../../options';
 import type { IsoBaseMediaBox } from '../../parse-result';
 import type { ParserState } from '../../state/parser-state';
-export declare const getChildren: ({ boxType, iterator, bytesRemainingInBox, state, signal, logLevel, fields, }: {
-    boxType: string;
+export declare const getIsoBaseMediaChildren: ({ iterator, state, size, }: {
     iterator: BufferIterator;
-    bytesRemainingInBox: number;
     state: ParserState;
-    signal: AbortSignal | null;
-    logLevel: LogLevel;
-    fields: Options<ParseMediaFields>;
+    size: number;
 }) => Promise<IsoBaseMediaBox[]>;

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

@@ -1,39 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getChildren = void 0;
-const parse_boxes_1 = require("./parse-boxes");
-const getChildren = async ({ boxType, iterator, bytesRemainingInBox, state, signal, logLevel, fields, }) => {
-    const parseChildren = boxType === 'mdia' ||
-        boxType === 'minf' ||
-        boxType === 'stbl' ||
-        boxType === 'udta' ||
-        boxType === 'moof' ||
-        boxType === 'dims' ||
-        boxType === 'meta' ||
-        boxType === 'wave' ||
-        boxType === 'traf' ||
-        boxType === 'stsb';
-    if (parseChildren) {
-        const boxes = [];
-        const parsed = await (0, parse_boxes_1.parseIsoBaseMediaBoxes)({
+exports.getIsoBaseMediaChildren = void 0;
+const process_box_1 = require("./process-box");
+const getIsoBaseMediaChildren = async ({ iterator, state, size, }) => {
+    const boxes = [];
+    const initial = iterator.counter.getOffset();
+    while (iterator.counter.getOffset() < size + initial) {
+        const parsed = await (0, process_box_1.processBox)({
             iterator,
-            maxBytes: bytesRemainingInBox,
-            allowIncompleteBoxes: false,
-            initialBoxes: boxes,
             state,
-            signal,
-            logLevel,
-            fields,
         });
-        if (parsed.status === 'incomplete') {
-            throw new Error('Incomplete boxes are not allowed');
+        if (!parsed.box) {
+            throw new Error('Expected box');
         }
-        return boxes;
+        boxes.push(parsed.box);
     }
-    if (bytesRemainingInBox < 0) {
-        throw new Error('Box size is too big ' + JSON.stringify({ boxType }));
+    if (iterator.counter.getOffset() > size + initial) {
+        throw new Error(`read too many bytes - size: ${size}, read: ${iterator.counter.getOffset() - initial}. initial offset: ${initial}`);
     }
-    iterator.discard(bytesRemainingInBox);
-    return [];
+    return boxes;
 };
-exports.getChildren = getChildren;
+exports.getIsoBaseMediaChildren = getIsoBaseMediaChildren;

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

@@ -1,26 +1,6 @@
 import type { BufferIterator } from '../../../buffer-iterator';
-import type { IsoBaseMediaBox } from '../../../parse-result';
-import type { PartialMdatBox } from '../../../parse-video';
 import type { ParserState } from '../../../state/parser-state';
-type MdatStatus = {
-    status: 'samples-buffered';
-} | {
-    status: 'samples-skipped';
-} | {
-    status: 'samples-processed';
-};
-export type MdatBox = {
-    type: 'mdat-box';
-    boxSize: number;
-    fileOffset: number;
-} & MdatStatus;
-export declare const parseMdat: ({ data, size, fileOffset, existingBoxes, state, signal, maySkipSampleProcessing, }: {
-    data: BufferIterator;
-    size: number;
-    fileOffset: number;
-    existingBoxes: IsoBaseMediaBox[];
+export declare const parseMdatSection: ({ iterator, state, }: {
+    iterator: BufferIterator;
     state: ParserState;
-    signal: AbortSignal | null;
-    maySkipSampleProcessing: boolean;
-}) => Promise<MdatBox | PartialMdatBox>;
-export {};
+}) => Promise<number | null>;

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

@@ -1,141 +1,91 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseMdat = void 0;
+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 get_sample_positions_from_track_1 = require("../get-sample-positions-from-track");
-const traversal_1 = require("../traversal");
-const parseMdat = async ({ data, size, fileOffset, existingBoxes, state, signal, maySkipSampleProcessing, }) => {
-    const alreadyHas = (0, get_tracks_1.getHasTracks)({
-        type: 'iso-base-media',
-        boxes: existingBoxes,
-    }, state);
+const may_skip_video_data_1 = require("../../../may-skip-video-data/may-skip-video-data");
+const cached_sample_positions_1 = require("../../../state/iso-base-media/cached-sample-positions");
+const parseMdatSection = async ({ iterator, 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.structure.getStructure(), state);
     if (!alreadyHas) {
-        if (maySkipSampleProcessing) {
-            data.discard(size - (data.counter.getOffset() - fileOffset));
-            return Promise.resolve({
-                type: 'mdat-box',
-                boxSize: size,
-                status: 'samples-skipped',
-                fileOffset,
-            });
+        // Will first read the end and then return
+        if (state.supportsContentRange) {
+            state.iso.setShouldReturnToVideoSectionAfterEnd(true);
+            return videoSection.size + videoSection.start;
         }
-        data.discard(size - (data.counter.getOffset() - fileOffset));
-        data.disallowDiscard();
-        return Promise.resolve({
-            type: 'mdat-box',
-            boxSize: size,
-            status: 'samples-buffered',
-            fileOffset,
-        });
+        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.');
     }
-    const tracks = (0, get_tracks_1.getTracks)({ type: 'iso-base-media', boxes: existingBoxes }, state);
-    const allTracks = [
-        ...tracks.videoTracks,
-        ...tracks.audioTracks,
-        ...tracks.otherTracks,
-    ];
-    const flatSamples = allTracks
-        .map((track) => {
-        const samplePositions = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)(track.trakBox, (0, traversal_1.getMoofBox)(existingBoxes));
-        if (!samplePositions) {
-            throw new Error('No sample positions');
-        }
-        return samplePositions.map((samplePosition) => {
-            return {
-                track: { ...track },
-                samplePosition,
-            };
-        });
-    })
-        .flat(1);
-    while (true) {
-        if (signal && signal.aborted) {
-            break;
-        }
-        const samplesWithIndex = flatSamples.find((sample) => {
-            return sample.samplePosition.offset === data.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 > data.counter.getOffset())
-                .sort((a, b) => a.samplePosition.offset - b.samplePosition.offset)[0];
-            if (nextSample_) {
-                data.discard(nextSample_.samplePosition.offset - data.counter.getOffset());
-                continue;
-            }
-            else {
-                const bytesRemaining = size + fileOffset - data.counter.getOffset();
-                data.discard(bytesRemaining);
-                break;
-            }
-        }
-        if (data.bytesRemaining() < samplesWithIndex.samplePosition.size) {
-            break;
-        }
-        const bytes = data.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));
-        }
-        const remaining = size - (data.counter.getOffset() - fileOffset);
-        data.removeBytesRead();
-        if (remaining === 0) {
-            break;
+    if (!state.iso.flatSamples.getSamples()) {
+        state.iso.flatSamples.setSamples((0, cached_sample_positions_1.calculateFlatSamples)(state));
+    }
+    const flatSamples = state.iso.flatSamples.getSamples();
+    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;
     }
-    const expectedOffsetNow = size + fileOffset;
-    const actualOffsetNow = data.counter.getOffset();
-    if (expectedOffsetNow !== actualOffsetNow) {
-        return Promise.resolve({
-            type: 'partial-mdat-box',
-            boxSize: size,
-            fileOffset,
-        });
+    if (iterator.bytesRemaining() < samplesWithIndex.samplePosition.size) {
+        return null;
     }
-    return Promise.resolve({
-        type: 'mdat-box',
-        boxSize: size,
-        status: 'samples-processed',
-        fileOffset,
-    });
+    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));
+    }
+    iterator.removeBytesRead();
+    return null;
 };
-exports.parseMdat = parseMdat;
+exports.parseMdatSection = parseMdatSection;

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

@@ -1,6 +1,4 @@
 import type { BufferIterator } from '../../../buffer-iterator';
-import type { LogLevel } from '../../../log';
-import type { Options, ParseMediaFields } from '../../../options';
 import type { AnySegment } from '../../../parse-result';
 import type { ParserState } from '../../../state/parser-state';
 import type { BaseBox } from '../base-type';
@@ -8,12 +6,9 @@ export interface MoovBox extends BaseBox {
     type: 'moov-box';
     children: AnySegment[];
 }
-export declare const parseMoov: ({ iterator, offset, size, state, signal, logLevel, fields, }: {
+export declare const parseMoov: ({ iterator, offset, size, state, }: {
     iterator: BufferIterator;
     offset: number;
     size: number;
     state: ParserState;
-    signal: AbortSignal | null;
-    logLevel: LogLevel;
-    fields: Options<ParseMediaFields>;
 }) => Promise<MoovBox>;

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

@@ -1,27 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMoov = void 0;
-const parse_boxes_1 = require("../parse-boxes");
-const parseMoov = async ({ iterator, offset, size, state, signal, logLevel, fields, }) => {
-    const boxes = [];
-    const children = await (0, parse_boxes_1.parseIsoBaseMediaBoxes)({
+const get_children_1 = require("../get-children");
+const parseMoov = async ({ iterator, offset, size, state, }) => {
+    const children = await (0, get_children_1.getIsoBaseMediaChildren)({
         iterator,
-        maxBytes: size - (iterator.counter.getOffset() - offset),
-        allowIncompleteBoxes: false,
-        initialBoxes: boxes,
         state,
-        signal,
-        logLevel,
-        fields,
+        size: size - 8,
     });
-    if (children.status === 'incomplete') {
-        throw new Error('Incomplete boxes are not allowed');
-    }
     return {
         offset,
         boxSize: size,
         type: 'moov-box',
-        children: boxes,
+        children,
     };
 };
 exports.parseMoov = parseMoov;

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

@@ -0,0 +1,8 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { LogLevel } from '../../log';
+import type { IsoBaseMediaBox } from '../../parse-result';
+export declare const parseAllChildren: ({ iterator, logLevel, maxOffset, }: {
+    iterator: BufferIterator;
+    maxOffset: number;
+    logLevel: LogLevel;
+}) => Promise<IsoBaseMediaBox[]>;

package/dist/boxes/iso-base-media/parse-all-children.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAllChildren = void 0;
+const process_box_1 = require("./process-box");
+const parseAllChildren = async ({ iterator, logLevel, maxOffset, }) => {
+    const boxes = [];
+    // TODO: Ensure we are able to parse all children
+    while (iterator.counter.getOffset() < maxOffset) {
+        const box = await (0, process_box_1.processBox)({
+            iterator,
+            logLevel,
+            parsedBoxes,
+            signal,
+            state,
+        });
+        boxes.push(box);
+    }
+    return boxes;
+};
+exports.parseAllChildren = parseAllChildren;

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

@@ -1,15 +1,7 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { LogLevel } from '../../log';
-import type { Options, ParseMediaFields } from '../../options';
-import type { IsoBaseMediaBox, ParseResult } from '../../parse-result';
+import type { ParseResult } from '../../parse-result';
 import type { ParserState } from '../../state/parser-state';
-export declare const parseIsoBaseMediaBoxes: ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, state, signal, logLevel, fields, }: {
+export declare const parseIsoBaseMedia: ({ iterator, state, }: {
     iterator: BufferIterator;
-    maxBytes: number;
-    allowIncompleteBoxes: boolean;
-    initialBoxes: IsoBaseMediaBox[];
     state: ParserState;
-    signal: AbortSignal | null;
-    logLevel: LogLevel;
-    fields: Options<ParseMediaFields>;
 }) => Promise<ParseResult>;