@remotion/media-parser 4.0.247 → 4.0.249

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

@@ -1,125 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseRiff = exports.parseRiffBody = void 0;
-const get_tracks_1 = require("../../get-tracks");
+exports.parseRiff = void 0;
 const has_all_info_1 = require("../../has-all-info");
-const register_track_1 = require("../../register-track");
-const expect_riff_box_1 = require("./expect-riff-box");
-const get_tracks_from_avi_1 = require("./get-tracks-from-avi");
-const traversal_1 = require("./traversal");
-const continueAfterRiffBoxResult = ({ result, structure, iterator, maxOffset, state: options, }) => {
-    if (result.type === 'incomplete') {
-        return Promise.resolve({
-            status: 'incomplete',
-            async continueParsing() {
-                return Promise.resolve(continueAfterRiffBoxResult({
-                    result: await result.continueParsing(),
-                    structure,
-                    iterator,
-                    maxOffset,
-                    state: options,
-                }));
-            },
-            segments: structure,
-            skipTo: null,
-        });
-    }
-    if (result.type === 'complete' && result.box) {
-        structure.boxes.push(result.box);
-    }
-    return (0, exports.parseRiffBody)({ iterator, maxOffset, state: options, structure });
-};
-const parseRiffBody = async ({ iterator, structure, maxOffset, state, }) => {
-    while (iterator.bytesRemaining() > 0 &&
-        iterator.counter.getOffset() < maxOffset) {
-        const result = await (0, expect_riff_box_1.expectRiffBox)({
-            iterator,
-            state,
-            structure,
-        });
-        if (result.type === 'complete' && result.skipTo !== null) {
-            return {
-                status: 'incomplete',
-                skipTo: result.skipTo,
-                continueParsing() {
-                    return Promise.resolve(continueAfterRiffBoxResult({
-                        iterator,
-                        maxOffset,
-                        state,
-                        result,
-                        structure,
-                    }));
-                },
-            };
-        }
-        if (result.type === 'incomplete') {
-            return {
-                status: 'incomplete',
-                async continueParsing() {
-                    return Promise.resolve(continueAfterRiffBoxResult({
-                        iterator,
-                        maxOffset,
-                        state,
-                        result: await result.continueParsing(),
-                        structure,
-                    }));
-                },
-                skipTo: null,
-            };
-        }
-        if (result.box === null) {
-            continue;
-        }
-        structure.boxes.push(result.box);
-        // When parsing an AVI
-        if (result.box.type === 'list-box' && result.box.listType === 'hdrl') {
-            const tracks = (0, get_tracks_1.getTracks)(structure, state);
-            if (!tracks.videoTracks.some((t) => t.codec === get_tracks_from_avi_1.TO_BE_OVERRIDDEN_LATER)) {
-                state.callbacks.tracks.setIsDone();
-            }
-        }
-        // When parsing a WAV
-        if (result.box.type === 'wave-format-box') {
-            state.callbacks.tracks.setIsDone();
-        }
-        if (result.box.type === 'strf-box-video' ||
-            result.box.type === 'strf-box-audio') {
-            const strh = (0, traversal_1.getStrhBox)(structure.boxes);
-            const strf = (0, traversal_1.getStrfBox)(structure.boxes);
-            if (!strh || !strf) {
-                throw new Error('strh or strf box missing');
-            }
-            if (strf.type === 'strf-box-audio' && state.onAudioTrack) {
-                const audioTrack = (0, get_tracks_from_avi_1.makeAviAudioTrack)({
-                    index: state.riff.getNextTrackIndex(),
-                    strf,
-                });
-                await (0, register_track_1.registerTrack)({
-                    state,
-                    track: audioTrack,
-                    container: 'avi',
-                });
-            }
-            if (state.onVideoTrack && strf.type === 'strf-box-video') {
-                const videoTrack = (0, get_tracks_from_avi_1.makeAviVideoTrack)({
-                    strh,
-                    index: state.riff.getNextTrackIndex(),
-                    strf,
-                });
-                (0, register_track_1.registerVideoTrackWhenProfileIsAvailable)({
-                    state,
-                    track: videoTrack,
-                    container: 'avi',
-                });
-            }
-            state.riff.incrementNextTrackIndex();
-        }
-    }
-    return {
-        status: 'done',
-    };
-};
-exports.parseRiffBody = parseRiffBody;
+const parse_riff_body_1 = require("./parse-riff-body");
 const parseRiff = ({ iterator, state, fields, }) => {
     const riff = iterator.getByteString(4, false);
     if (riff !== 'RIFF') {
@@ -141,11 +24,12 @@ const parseRiff = ({ iterator, state, fields, }) => {
             segments: structure,
         });
     }
-    return (0, exports.parseRiffBody)({
+    return (0, parse_riff_body_1.parseRiffBody)({
         iterator,
         maxOffset: Infinity,
         state,
         structure,
+        fields,
     });
 };
 exports.parseRiff = parseRiff;

package/dist/boxes/riff/parse-list-box.d.ts

@@ -1,8 +1,10 @@
 import type { BufferIterator } from '../../buffer-iterator';
+import type { Options, ParseMediaFields } from '../../options';
 import type { ParserState } from '../../state/parser-state';
 import type { RiffBox } from './riff-box';
-export declare const parseListBox: ({ iterator, size, state, }: {
+export declare const parseListBox: ({ iterator, size, state, fields, }: {
     iterator: BufferIterator;
     size: number;
     state: ParserState;
+    fields: Options<ParseMediaFields>;
 }) => Promise<RiffBox>;

package/dist/boxes/riff/parse-list-box.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseListBox = void 0;
-const parse_box_1 = require("./parse-box");
-const parseListBox = async ({ iterator, size, state, }) => {
+const parse_riff_body_1 = require("./parse-riff-body");
+const parseListBox = async ({ iterator, size, state, fields, }) => {
     const counter = iterator.counter.getOffset();
     const listType = iterator.getByteString(4, false);
     if (listType === 'movi') {
@@ -12,11 +12,12 @@ const parseListBox = async ({ iterator, size, state, }) => {
         type: 'riff',
         boxes: [],
     };
-    const result = await (0, parse_box_1.parseRiffBody)({
+    const result = await (0, parse_riff_body_1.parseRiffBody)({
         structure,
         iterator,
         maxOffset: counter + size,
         state,
+        fields,
     });
     if (result.status === 'incomplete') {
         throw new Error(`Should only parse complete boxes (${listType})`);

package/dist/boxes/riff/parse-riff-body.d.ts

@@ -0,0 +1,11 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { Options, ParseMediaFields } from '../../options';
+import type { ParseResult, RiffStructure } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseRiffBody: ({ iterator, structure, maxOffset, state, fields, }: {
+    iterator: BufferIterator;
+    structure: RiffStructure;
+    maxOffset: number;
+    state: ParserState;
+    fields: Options<ParseMediaFields>;
+}) => Promise<ParseResult>;

package/dist/boxes/riff/parse-riff-body.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRiffBody = void 0;
+const get_tracks_1 = require("../../get-tracks");
+const has_all_info_1 = require("../../has-all-info");
+const register_track_1 = require("../../register-track");
+const continue_after_riff_result_1 = require("./continue-after-riff-result");
+const expect_riff_box_1 = require("./expect-riff-box");
+const get_tracks_from_avi_1 = require("./get-tracks-from-avi");
+const traversal_1 = require("./traversal");
+const parseRiffBody = async ({ iterator, structure, maxOffset, state, fields, }) => {
+    while (iterator.bytesRemaining() > 0 &&
+        iterator.counter.getOffset() < maxOffset &&
+        !(0, has_all_info_1.hasAllInfo)({ fields, state })) {
+        const result = await (0, expect_riff_box_1.expectRiffBox)({
+            iterator,
+            state,
+            structure,
+            fields,
+        });
+        if (result.type === 'complete' && result.skipTo !== null) {
+            return {
+                status: 'incomplete',
+                skipTo: result.skipTo,
+                continueParsing() {
+                    return Promise.resolve((0, continue_after_riff_result_1.continueAfterRiffBoxResult)({
+                        iterator,
+                        maxOffset,
+                        state,
+                        result,
+                        structure,
+                        fields,
+                    }));
+                },
+            };
+        }
+        if (result.type === 'incomplete') {
+            return {
+                status: 'incomplete',
+                async continueParsing() {
+                    return Promise.resolve((0, continue_after_riff_result_1.continueAfterRiffBoxResult)({
+                        iterator,
+                        maxOffset,
+                        state,
+                        result: await result.continueParsing(),
+                        structure,
+                        fields,
+                    }));
+                },
+                skipTo: null,
+            };
+        }
+        if (result.box === null) {
+            continue;
+        }
+        structure.boxes.push(result.box);
+        // When parsing an AVI
+        if (result.box.type === 'list-box' && result.box.listType === 'hdrl') {
+            const tracks = (0, get_tracks_1.getTracks)(structure, state);
+            if (!tracks.videoTracks.some((t) => t.codec === get_tracks_from_avi_1.TO_BE_OVERRIDDEN_LATER)) {
+                state.callbacks.tracks.setIsDone();
+            }
+        }
+        // When parsing a WAV
+        if (result.box.type === 'wave-format-box') {
+            state.callbacks.tracks.setIsDone();
+        }
+        if (result.box.type === 'strf-box-video' ||
+            result.box.type === 'strf-box-audio') {
+            const strh = (0, traversal_1.getStrhBox)(structure.boxes);
+            const strf = (0, traversal_1.getStrfBox)(structure.boxes);
+            if (!strh || !strf) {
+                throw new Error('strh or strf box missing');
+            }
+            if (strf.type === 'strf-box-audio' && state.onAudioTrack) {
+                const audioTrack = (0, get_tracks_from_avi_1.makeAviAudioTrack)({
+                    index: state.riff.getNextTrackIndex(),
+                    strf,
+                });
+                await (0, register_track_1.registerTrack)({
+                    state,
+                    track: audioTrack,
+                    container: 'avi',
+                });
+            }
+            if (state.onVideoTrack && strf.type === 'strf-box-video') {
+                const videoTrack = (0, get_tracks_from_avi_1.makeAviVideoTrack)({
+                    strh,
+                    index: state.riff.getNextTrackIndex(),
+                    strf,
+                });
+                (0, register_track_1.registerVideoTrackWhenProfileIsAvailable)({
+                    state,
+                    track: videoTrack,
+                    container: 'avi',
+                });
+            }
+            state.riff.incrementNextTrackIndex();
+        }
+    }
+    return {
+        status: 'done',
+    };
+};
+exports.parseRiffBody = parseRiffBody;

package/dist/boxes/riff/parse-riff-box.d.ts

@@ -1,10 +1,12 @@
 import type { BufferIterator } from '../../buffer-iterator';
+import type { Options, ParseMediaFields } from '../../options';
 import type { ParserState } from '../../state/parser-state';
 import type { RiffBox } from './riff-box';
-export declare const parseRiffBox: ({ iterator, size, id, boxes, state, }: {
+export declare const parseRiffBox: ({ iterator, size, id, boxes, state, fields, }: {
     iterator: BufferIterator;
     size: number;
     id: string;
     boxes: RiffBox[];
     state: ParserState;
+    fields: Options<ParseMediaFields>;
 }) => Promise<RiffBox>;

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

@@ -7,12 +7,12 @@ const parse_isft_1 = require("./parse-isft");
 const parse_list_box_1 = require("./parse-list-box");
 const parse_strf_1 = require("./parse-strf");
 const parse_strh_1 = require("./parse-strh");
-const parseRiffBox = ({ iterator, size, id, boxes, state, }) => {
+const parseRiffBox = ({ iterator, size, id, boxes, state, fields, }) => {
     if (id === 'fmt') {
         return Promise.resolve((0, parse_fmt_box_1.parseFmtBox)({ iterator, boxes, size }));
     }
     if (id === 'LIST') {
-        return (0, parse_list_box_1.parseListBox)({ iterator, size, state });
+        return (0, parse_list_box_1.parseListBox)({ iterator, size, state, fields });
     }
     if (id === 'ISFT') {
         return Promise.resolve((0, parse_isft_1.parseIsft)({ iterator, size }));

package/dist/boxes/transport-stream/parse-transport-stream.js

@@ -17,56 +17,45 @@ const parseTransportStream = async ({ iterator, state, streamBuffers, fields, ne
         });
         return Promise.resolve({
             status: 'done',
-            segments: structure,
         });
     }
-    while (true) {
-        if ((0, has_all_info_1.hasAllInfo)({
-            fields,
-            state,
-        })) {
-            break;
-        }
-        if (iterator.bytesRemaining() < 188) {
-            return Promise.resolve({
-                status: 'incomplete',
-                segments: structure,
-                skipTo: null,
-                continueParsing: () => {
-                    return (0, exports.parseTransportStream)({
-                        iterator,
-                        state,
-                        streamBuffers,
-                        fields,
-                        nextPesHeaderStore,
-                    });
-                },
-            });
-        }
-        const packet = await (0, parse_packet_1.parsePacket)({
+    const continueParsing = () => {
+        return (0, exports.parseTransportStream)({
             iterator,
-            structure,
+            state,
             streamBuffers,
-            parserState: state,
+            fields,
             nextPesHeaderStore,
         });
-        if (packet) {
-            structure.boxes.push(packet);
-            break;
-        }
+    };
+    if ((0, has_all_info_1.hasAllInfo)({
+        fields,
+        state,
+    })) {
+        return Promise.resolve({
+            status: 'done',
+        });
+    }
+    if (iterator.bytesRemaining() < 188) {
+        return Promise.resolve({
+            status: 'incomplete',
+            continueParsing,
+            skipTo: null,
+        });
+    }
+    const packet = await (0, parse_packet_1.parsePacket)({
+        iterator,
+        structure,
+        streamBuffers,
+        parserState: state,
+        nextPesHeaderStore,
+    });
+    if (packet) {
+        structure.boxes.push(packet);
     }
     return Promise.resolve({
-        segments: structure,
         status: 'incomplete',
-        continueParsing() {
-            return (0, exports.parseTransportStream)({
-                iterator,
-                state,
-                streamBuffers,
-                fields,
-                nextPesHeaderStore,
-            });
-        },
+        continueParsing,
         skipTo: null,
     });
 };

package/dist/buffer-iterator.d.ts

@@ -48,6 +48,9 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes:
     getPascalString: () => number[];
     getUint(length: number): number;
     getByteString(length: number, trimTrailingZeroes: boolean): string;
+    planBytes: (size: number) => {
+        discardRest: () => Uint8Array;
+    };
     getFloat64: () => number;
     readUntilNullTerminator: () => string;
     getFloat32: () => number;
@@ -62,5 +65,8 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes:
         expectNoMoreBytes: () => void;
     };
     readExpGolomb: () => number;
+    startCheckpoint: () => {
+        returnToCheckpoint: () => void;
+    };
 };
 export type BufferIterator = ReturnType<typeof getArrayBufferIterator>;

package/dist/buffer-iterator.js

@@ -70,6 +70,14 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
     let view = new DataView(data.buffer);
     const counter = makeOffsetCounter();
     let discardAllowed = true;
+    const startCheckpoint = () => {
+        const checkpoint = counter.getOffset();
+        return {
+            returnToCheckpoint: () => {
+                counter.decrement(counter.getOffset() - checkpoint);
+            },
+        };
+    };
     const getSlice = (amount) => {
         const value = data.slice(counter.getDiscardedOffset(), counter.getDiscardedOffset() + amount);
         counter.increment(amount);
@@ -501,6 +509,18 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
             }
             return new TextDecoder().decode(bytes).trim();
         },
+        planBytes: (size) => {
+            const currentOffset = counter.getOffset();
+            return {
+                discardRest: () => {
+                    const toDiscard = size - (counter.getOffset() - currentOffset);
+                    if (toDiscard < 0) {
+                        throw new Error('read too many bytes');
+                    }
+                    return getSlice(toDiscard);
+                },
+            };
+        },
         getFloat64: () => {
             const val = view.getFloat64(counter.getDiscardedOffset());
             counter.increment(8);
@@ -520,6 +540,7 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         allowDiscard,
         startBox,
         readExpGolomb,
+        startCheckpoint,
     };
 };
 exports.getArrayBufferIterator = getArrayBufferIterator;

package/dist/continue-mdat-routine.d.ts

@@ -0,0 +1,17 @@
+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 { PartialMdatBox } from './parse-video';
+import type { ParserState } from './state/parser-state';
+export declare const continueMdatRoutine: ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, state, continueMdat, signal, logLevel, fields, }: {
+    iterator: BufferIterator;
+    maxBytes: number;
+    allowIncompleteBoxes: boolean;
+    initialBoxes: IsoBaseMediaBox[];
+    state: ParserState;
+    continueMdat: PartialMdatBox;
+    signal: AbortSignal | null;
+    logLevel: LogLevel;
+    fields: Options<ParseMediaFields>;
+}) => Promise<ParseResult>;

package/dist/continue-mdat-routine.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.continueMdatRoutine = void 0;
+const parse_boxes_1 = require("./boxes/iso-base-media/parse-boxes");
+const parse_mdat_partially_1 = require("./boxes/iso-base-media/parse-mdat-partially");
+const traversal_1 = require("./boxes/iso-base-media/traversal");
+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 continueMdatRoutine = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, state, continueMdat, signal, logLevel, fields, }) => {
+    var _a;
+    const initialOffset = iterator.counter.getOffset();
+    while (iterator.bytesRemaining() > 0 &&
+        iterator.counter.getOffset() - initialOffset < maxBytes) {
+        const result = await (0, parse_mdat_partially_1.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: () => {
+                    return Promise.resolve((0, exports.continueMdatRoutine)({
+                        iterator,
+                        maxBytes,
+                        allowIncompleteBoxes,
+                        initialBoxes,
+                        state,
+                        continueMdat: result,
+                        signal,
+                        logLevel,
+                        fields,
+                    }));
+                },
+                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();
+            break;
+        }
+        else {
+            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;
+    const buffered = (mdatState === null || mdatState === void 0 ? void 0 : mdatState.status) === 'samples-buffered' && !(0, may_skip_video_data_1.maySkipVideoData)({ state });
+    if (skipped || buffered) {
+        return {
+            status: 'incomplete',
+            continueParsing: () => {
+                if (buffered) {
+                    iterator.skipTo(mdatState.fileOffset, false);
+                }
+                return (0, parse_boxes_1.parseIsoBaseMediaBoxes)({
+                    iterator,
+                    maxBytes,
+                    allowIncompleteBoxes: false,
+                    initialBoxes,
+                    state,
+                    signal,
+                    logLevel,
+                    fields,
+                });
+            },
+            skipTo: skipped ? mdatState.fileOffset : null,
+        };
+    }
+    return {
+        status: 'done',
+    };
+};
+exports.continueMdatRoutine = continueMdatRoutine;