@remotion/media-parser 4.0.247 → 4.0.249

package/dist/boxes/avc/key.d.ts

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

package/dist/boxes/iso-base-media/get-children.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 } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export declare const getChildren: ({ boxType, iterator, bytesRemainingInBox, state, signal, logLevel, fields, }: {
+    boxType: string;
+    iterator: BufferIterator;
+    bytesRemainingInBox: number;
+    state: ParserState;
+    signal: AbortSignal | null;
+    logLevel: LogLevel;
+    fields: Options<ParseMediaFields>;
+}) => Promise<IsoBaseMediaBox[]>;

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

@@ -0,0 +1,39 @@
+"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)({
+            iterator,
+            maxBytes: bytesRemainingInBox,
+            allowIncompleteBoxes: false,
+            initialBoxes: boxes,
+            state,
+            signal,
+            logLevel,
+            fields,
+        });
+        if (parsed.status === 'incomplete') {
+            throw new Error('Incomplete boxes are not allowed');
+        }
+        return boxes;
+    }
+    if (bytesRemainingInBox < 0) {
+        throw new Error('Box size is too big ' + JSON.stringify({ boxType }));
+    }
+    iterator.discard(bytesRemainingInBox);
+    return [];
+};
+exports.getChildren = getChildren;

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

@@ -1,5 +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';
@@ -21,5 +22,5 @@ export declare const parseMdat: ({ data, size, fileOffset, existingBoxes, state,
     state: ParserState;
     signal: AbortSignal | null;
     maySkipSampleProcessing: boolean;
-}) => Promise<MdatBox>;
+}) => Promise<MdatBox | PartialMdatBox>;
 export {};

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

@@ -6,7 +6,7 @@ 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.hasTracks)({
+    const alreadyHas = (0, get_tracks_1.getHasTracks)({
         type: 'iso-base-media',
         boxes: existingBoxes,
     }, state);
@@ -122,6 +122,15 @@ const parseMdat = async ({ data, size, fileOffset, existingBoxes, state, signal,
             break;
         }
     }
+    const expectedOffsetNow = size + fileOffset;
+    const actualOffsetNow = data.counter.getOffset();
+    if (expectedOffsetNow !== actualOffsetNow) {
+        return Promise.resolve({
+            type: 'partial-mdat-box',
+            boxSize: size,
+            fileOffset,
+        });
+    }
     return Promise.resolve({
         type: 'mdat-box',
         boxSize: size,

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

@@ -1,16 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMoov = void 0;
-const process_box_1 = require("../process-box");
+const parse_boxes_1 = require("../parse-boxes");
 const parseMoov = async ({ iterator, offset, size, state, signal, logLevel, fields, }) => {
     const boxes = [];
-    const children = await (0, process_box_1.parseIsoBaseMediaBoxes)({
+    const children = await (0, parse_boxes_1.parseIsoBaseMediaBoxes)({
         iterator,
         maxBytes: size - (iterator.counter.getOffset() - offset),
         allowIncompleteBoxes: false,
         initialBoxes: boxes,
         state,
-        continueMdat: false,
         signal,
         logLevel,
         fields,

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

@@ -0,0 +1,15 @@
+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 parseIsoBaseMediaBoxes: ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, state, signal, logLevel, fields, }: {
+    iterator: BufferIterator;
+    maxBytes: number;
+    allowIncompleteBoxes: boolean;
+    initialBoxes: IsoBaseMediaBox[];
+    state: ParserState;
+    signal: AbortSignal | null;
+    logLevel: LogLevel;
+    fields: Options<ParseMediaFields>;
+}) => Promise<ParseResult>;

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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIsoBaseMediaBoxes = void 0;
+const continue_mdat_routine_1 = require("../../continue-mdat-routine");
+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 process_box_1 = require("./process-box");
+const traversal_1 = require("./traversal");
+const parseIsoBaseMediaBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, state, signal, logLevel, fields, }) => {
+    var _a;
+    const initialOffset = iterator.counter.getOffset();
+    const continueParsing = () => {
+        return (0, exports.parseIsoBaseMediaBoxes)({
+            iterator,
+            maxBytes,
+            allowIncompleteBoxes,
+            initialBoxes,
+            state,
+            signal,
+            logLevel,
+            fields,
+        });
+    };
+    const alreadyHasMdat = (_a = state.structure
+        .getStructureOrNull()) === null || _a === void 0 ? void 0 : _a.boxes.find((b) => b.type === 'mdat-box');
+    while (iterator.bytesRemaining() > 0 &&
+        iterator.counter.getOffset() - initialOffset < maxBytes) {
+        const result = await (0, process_box_1.processBox)({
+            iterator,
+            allowIncompleteBoxes,
+            parsedBoxes: initialBoxes,
+            state,
+            signal,
+            logLevel,
+            fields,
+        });
+        if (result.type === 'incomplete') {
+            if (Number.isFinite(maxBytes)) {
+                throw new Error('maxBytes must be Infinity for top-level boxes');
+            }
+            return {
+                status: 'incomplete',
+                continueParsing,
+                skipTo: null,
+            };
+        }
+        if (result.type === 'partial-mdat-box') {
+            return {
+                status: 'incomplete',
+                continueParsing: () => {
+                    return Promise.resolve((0, continue_mdat_routine_1.continueMdatRoutine)({
+                        iterator,
+                        maxBytes,
+                        allowIncompleteBoxes,
+                        initialBoxes,
+                        state,
+                        continueMdat: result,
+                        signal,
+                        logLevel,
+                        fields,
+                    }));
+                },
+                skipTo: null,
+            };
+        }
+        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',
+                };
+            }
+        }
+        if (result.skipTo !== null) {
+            if (!state.supportsContentRange) {
+                throw new Error('Content-Range header is not supported by the reader, but was asked to seek');
+            }
+            return {
+                status: 'incomplete',
+                continueParsing,
+                skipTo: result.skipTo,
+            };
+        }
+        if (iterator.bytesRemaining() < 0) {
+            return {
+                status: 'incomplete',
+                continueParsing,
+                skipTo: null,
+            };
+        }
+        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, exports.parseIsoBaseMediaBoxes)({
+                    iterator,
+                    maxBytes,
+                    allowIncompleteBoxes: false,
+                    initialBoxes,
+                    state,
+                    signal,
+                    logLevel,
+                    fields,
+                });
+            },
+            skipTo: skipped ? mdatState.fileOffset : null,
+        };
+    }
+    return {
+        status: 'done',
+    };
+};
+exports.parseIsoBaseMediaBoxes = parseIsoBaseMediaBoxes;

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

@@ -0,0 +1,12 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { IsoBaseMediaBox } from '../../parse-result';
+import type { BoxAndNext } from '../../parse-video';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseMdatPartially: ({ iterator, boxSize, fileOffset, parsedBoxes, state, signal, }: {
+    iterator: BufferIterator;
+    boxSize: number;
+    fileOffset: number;
+    parsedBoxes: IsoBaseMediaBox[];
+    state: ParserState;
+    signal: AbortSignal | null;
+}) => Promise<BoxAndNext>;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMdatPartially = void 0;
+const mdat_1 = require("./mdat/mdat");
+const parseMdatPartially = async ({ iterator, boxSize, fileOffset, parsedBoxes, state, signal, }) => {
+    const box = await (0, mdat_1.parseMdat)({
+        data: iterator,
+        size: boxSize,
+        fileOffset,
+        existingBoxes: parsedBoxes,
+        state,
+        signal,
+        maySkipSampleProcessing: state.supportsContentRange,
+    });
+    if (box.type === 'partial-mdat-box') {
+        return box;
+    }
+    if ((box.status === 'samples-processed' || box.status === 'samples-buffered') &&
+        box.fileOffset + boxSize === iterator.counter.getOffset()) {
+        return {
+            type: 'complete',
+            box,
+            size: boxSize,
+            skipTo: null,
+        };
+    }
+    return {
+        type: 'partial-mdat-box',
+        boxSize,
+        fileOffset,
+    };
+};
+exports.parseMdatPartially = parseMdatPartially;

package/dist/boxes/iso-base-media/process-box.d.ts

@@ -1,17 +1,9 @@
 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 { BoxAndNext, PartialMdatBox } from '../../parse-video';
+import type { IsoBaseMediaBox } from '../../parse-result';
+import type { BoxAndNext } from '../../parse-video';
 import type { ParserState } from '../../state/parser-state';
-export declare const parseMdatPartially: ({ iterator, boxSize, fileOffset, parsedBoxes, state, signal, }: {
-    iterator: BufferIterator;
-    boxSize: number;
-    fileOffset: number;
-    parsedBoxes: IsoBaseMediaBox[];
-    state: ParserState;
-    signal: AbortSignal | null;
-}) => Promise<BoxAndNext>;
 export declare const processBox: ({ iterator, allowIncompleteBoxes, parsedBoxes, state, signal, logLevel, fields, }: {
     iterator: BufferIterator;
     allowIncompleteBoxes: boolean;
@@ -21,14 +13,3 @@ export declare const processBox: ({ iterator, allowIncompleteBoxes, parsedBoxes,
     logLevel: LogLevel;
     fields: Options<ParseMediaFields>;
 }) => Promise<BoxAndNext>;
-export declare const parseIsoBaseMediaBoxes: ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, state, continueMdat, signal, logLevel, fields, }: {
-    iterator: BufferIterator;
-    maxBytes: number;
-    allowIncompleteBoxes: boolean;
-    initialBoxes: IsoBaseMediaBox[];
-    state: ParserState;
-    continueMdat: false | PartialMdatBox;
-    signal: AbortSignal | null;
-    logLevel: LogLevel;
-    fields: Options<ParseMediaFields>;
-}) => Promise<ParseResult>;