@remotion/media-parser 4.0.249 → 4.0.251

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIsoBaseMedia = void 0;
+const mdat_1 = require("./mdat/mdat");
+const process_box_1 = require("./process-box");
+const parseIsoBaseMedia = async (state) => {
+    const videoSectionState = state.videoSection.isInVideoSectionState(state.iterator);
+    if (videoSectionState === 'in-section') {
+        const skipTo = await (0, mdat_1.parseMdatSection)(state);
+        return {
+            skipTo,
+        };
+    }
+    const result = await (0, process_box_1.processBox)(state);
+    if (result.box) {
+        state.structure.getStructure().boxes.push(result.box);
+    }
+    const { iterator } = state;
+    if (iterator.counter.getOffset() === state.contentLength &&
+        state.iso.getShouldReturnToVideoSectionAfterEnd()) {
+        state.iso.setShouldReturnToVideoSectionAfterEnd(false);
+        return {
+            skipTo: state.videoSection.getVideoSection().start,
+        };
+    }
+    if (result.skipTo !== null) {
+        return {
+            skipTo: result.skipTo,
+        };
+    }
+    if (iterator.bytesRemaining() < 0) {
+        return {
+            skipTo: null,
+        };
+    }
+    return {
+        skipTo: null,
+    };
+};
+exports.parseIsoBaseMedia = parseIsoBaseMedia;

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

@@ -0,0 +1,3 @@
+import type { ParserState } from '../../state/parser-state';
+import type { BoxAndNext } from './base-media-box';
+export declare const processBox: (state: ParserState) => Promise<BoxAndNext>;

package/dist/{boxes → containers}/iso-base-media/process-box.js

@@ -1,20 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processBox = void 0;
-const get_tracks_1 = require("../../get-tracks");
-const may_skip_video_data_1 = require("../../may-skip-video-data/may-skip-video-data");
+const log_1 = require("../../log");
 const register_track_1 = require("../../register-track");
 const esds_1 = require("./esds/esds");
 const ftyp_1 = require("./ftyp");
 const get_children_1 = require("./get-children");
 const make_track_1 = require("./make-track");
-const mdat_1 = require("./mdat/mdat");
 const mdhd_1 = require("./mdhd");
 const hdlr_1 = require("./meta/hdlr");
 const ilst_1 = require("./meta/ilst");
 const moov_1 = require("./moov/moov");
 const mvhd_1 = require("./mvhd");
-const parse_mdat_partially_1 = require("./parse-mdat-partially");
 const av1c_1 = require("./stsd/av1c");
 const avcc_1 = require("./stsd/avcc");
 const colr_1 = require("./stsd/colr");
@@ -34,18 +31,18 @@ const tfhd_1 = require("./tfhd");
 const tkhd_1 = require("./tkhd");
 const trak_1 = require("./trak/trak");
 const trun_1 = require("./trun");
-const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state, signal, logLevel, fields, }) => {
+const processBox = async (state) => {
+    const { iterator } = state;
     const fileOffset = iterator.counter.getOffset();
+    const { returnToCheckpoint } = iterator.startCheckpoint();
     const bytesRemaining = iterator.bytesRemaining();
     const boxSizeRaw = iterator.getFourByteNumber();
     if (boxSizeRaw === 0) {
         return {
-            type: 'complete',
             box: {
                 type: 'void-box',
                 boxSize: 0,
             },
-            size: 4,
             skipTo: null,
         };
     }
@@ -53,64 +50,32 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
     if ((boxSizeRaw === 1 && iterator.bytesRemaining() < 12) ||
         iterator.bytesRemaining() < 4) {
         iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
-        if (!allowIncompleteBoxes) {
-            throw new Error(`Expected box size of ${bytesRemaining}, got ${boxSizeRaw}. Incomplete boxes are not allowed.`);
-        }
-        return {
-            type: 'incomplete',
-        };
+        throw new Error(`Expected box size of ${bytesRemaining}, got ${boxSizeRaw}. Incomplete boxes are not allowed.`);
     }
     const boxType = iterator.getByteString(4, false);
     const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber() : boxSizeRaw;
+    log_1.Log.trace(state.logLevel, 'Found box', boxType, boxSize);
+    if (boxType === 'mdat') {
+        state.videoSection.setVideoSection({
+            size: boxSize - 8,
+            start: iterator.counter.getOffset(),
+        });
+        return {
+            box: null,
+            skipTo: null,
+        };
+    }
     if (bytesRemaining < boxSize) {
-        if (boxType !== 'mdat') {
-            iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
-            if (!allowIncompleteBoxes) {
-                throw new Error(`Expected box size of ${bytesRemaining}, got ${boxSize}. Incomplete boxes are not allowed.`);
-            }
-            return {
-                type: 'incomplete',
-            };
-        }
-        // Check if the moov atom is at the end
-        const shouldSkip = (0, may_skip_video_data_1.maySkipVideoData)({ state }) ||
-            (!(0, get_tracks_1.getHasTracks)({ type: 'iso-base-media', boxes: parsedBoxes }, state) &&
-                state.supportsContentRange);
-        if (shouldSkip) {
-            const skipTo = fileOffset + boxSize;
-            const bytesToSkip = skipTo - iterator.counter.getOffset();
-            // If there is a huge mdat chunk, we can skip it because we don't need it for the metadata
-            if (bytesToSkip > 1000000) {
-                return {
-                    type: 'complete',
-                    box: {
-                        type: 'mdat-box',
-                        boxSize,
-                        fileOffset,
-                        status: 'samples-skipped',
-                    },
-                    size: boxSize,
-                    skipTo: fileOffset + boxSize,
-                };
-            }
-        }
-        else {
-            return (0, parse_mdat_partially_1.parseMdatPartially)({
-                iterator,
-                boxSize,
-                fileOffset,
-                parsedBoxes,
-                state,
-                signal,
-            });
-        }
+        returnToCheckpoint();
+        return {
+            box: null,
+            skipTo: null,
+        };
     }
     if (boxType === 'ftyp') {
         const box = (0, ftyp_1.parseFtyp)({ iterator, size: boxSize, offset: fileOffset });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
@@ -120,61 +85,46 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
             size: boxSize,
         });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
     if (boxType === 'mvhd') {
         const box = (0, mvhd_1.parseMvhd)({ iterator, offset: fileOffset, size: boxSize });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
     if (boxType === 'tkhd') {
         const box = (0, tkhd_1.parseTkhd)({ iterator, offset: fileOffset, size: boxSize });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
     if (boxType === 'trun') {
         const box = (0, trun_1.parseTrun)({ iterator, offset: fileOffset, size: boxSize });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
     if (boxType === 'tfdt') {
         const box = (0, tfdt_1.parseTfdt)({ iterator, size: boxSize, offset: fileOffset });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
     if (boxType === 'stsd') {
         const box = await (0, stsd_1.parseStsd)({
-            iterator,
             offset: fileOffset,
             size: boxSize,
             state,
-            signal,
-            fields,
         });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
@@ -185,9 +135,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
             size: boxSize,
         });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
@@ -199,9 +147,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
             mode64Bit: boxType === 'co64',
         });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
@@ -212,9 +158,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
             size: boxSize,
         });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
@@ -225,9 +169,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
             boxSize,
         });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
@@ -238,9 +180,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
             size: boxSize,
         });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
@@ -251,43 +191,32 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
             size: boxSize,
         });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
     if (boxType === 'mebx') {
         const box = await (0, mebx_1.parseMebx)({
-            iterator,
             offset: fileOffset,
             size: boxSize,
             state,
-            signal,
-            fields,
         });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
     if (boxType === 'hdlr') {
         const box = await (0, hdlr_1.parseHdlr)({ iterator, size: boxSize, offset: fileOffset });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
     if (boxType === 'keys') {
         const box = (0, keys_1.parseKeys)({ iterator, size: boxSize, offset: fileOffset });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
@@ -298,39 +227,34 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
             size: boxSize,
         });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
     if (boxType === 'moov') {
+        if (state.callbacks.tracks.hasAllTracks()) {
+            iterator.discard(boxSize - 8);
+            return {
+                box: null,
+                skipTo: null,
+            };
+        }
         const box = await (0, moov_1.parseMoov)({
-            iterator,
             offset: fileOffset,
             size: boxSize,
             state,
-            signal,
-            logLevel,
-            fields,
         });
         state.callbacks.tracks.setIsDone();
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
     if (boxType === 'trak') {
         const box = await (0, trak_1.parseTrak)({
-            data: iterator,
             size: boxSize,
             offsetAtStart: fileOffset,
             state,
-            signal,
-            logLevel,
-            fields,
         });
         const transformedTrack = (0, make_track_1.makeBaseMediaTrack)(box);
         if (transformedTrack) {
@@ -341,9 +265,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
             });
         }
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
@@ -354,9 +276,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
             fileOffset,
         });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
@@ -366,9 +286,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
             size: boxSize,
         });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
@@ -378,9 +296,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
             size: boxSize,
         });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
@@ -391,9 +307,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
             offset: fileOffset,
         });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
@@ -404,9 +318,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
             size: boxSize,
         });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
@@ -417,9 +329,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
             fileOffset,
         });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
@@ -430,52 +340,44 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
             fileOffset,
         });
         return {
-            type: 'complete',
             box,
-            size: boxSize,
             skipTo: null,
         };
     }
-    if (boxType === 'mdat') {
-        const box = await (0, mdat_1.parseMdat)({
-            data: iterator,
-            size: boxSize,
-            fileOffset,
-            existingBoxes: parsedBoxes,
+    if (boxType === 'mdia' ||
+        boxType === 'minf' ||
+        boxType === 'stbl' ||
+        boxType === 'udta' ||
+        boxType === 'moof' ||
+        boxType === 'dims' ||
+        boxType === 'meta' ||
+        boxType === 'wave' ||
+        boxType === 'traf' ||
+        boxType === 'stsb') {
+        const children = await (0, get_children_1.getIsoBaseMediaChildren)({
             state,
-            signal,
-            maySkipSampleProcessing: state.supportsContentRange,
+            size: boxSize - 8,
         });
-        if (box.type === 'partial-mdat-box') {
-            return box;
-        }
         return {
-            type: 'complete',
-            box,
-            size: boxSize,
+            box: {
+                type: 'regular-box',
+                boxType,
+                boxSize,
+                children,
+                offset: fileOffset,
+            },
             skipTo: null,
         };
     }
-    const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-    const children = await (0, get_children_1.getChildren)({
-        boxType,
-        iterator,
-        bytesRemainingInBox,
-        state,
-        signal,
-        logLevel,
-        fields,
-    });
+    iterator.discard(boxSize - 8);
     return {
-        type: 'complete',
         box: {
             type: 'regular-box',
             boxType,
             boxSize,
-            children,
+            children: [],
             offset: fileOffset,
         },
-        size: boxSize,
         skipTo: null,
     };
 };

package/dist/{boxes → containers}/iso-base-media/stsd/mebx.d.ts

@@ -1,5 +1,3 @@
-import type { BufferIterator } from '../../../buffer-iterator';
-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';
@@ -9,11 +7,8 @@ export interface MebxBox extends BaseBox {
     format: string;
     children: AnySegment[];
 }
-export declare const parseMebx: ({ iterator, offset, size, state, signal, fields, }: {
-    iterator: BufferIterator;
+export declare const parseMebx: ({ offset, size, state, }: {
     offset: number;
     size: number;
     state: ParserState;
-    signal: AbortSignal | null;
-    fields: Options<ParseMediaFields>;
 }) => Promise<MebxBox>;

package/dist/containers/iso-base-media/stsd/mebx.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMebx = void 0;
+const get_children_1 = require("../get-children");
+const parseMebx = async ({ offset, size, state, }) => {
+    // reserved, 6 bit
+    state.iterator.discard(6);
+    const dataReferenceIndex = state.iterator.getUint16();
+    const children = await (0, get_children_1.getIsoBaseMediaChildren)({
+        state,
+        size: size - 8,
+    });
+    return {
+        type: 'mebx-box',
+        boxSize: size,
+        offset,
+        dataReferenceIndex,
+        format: 'mebx',
+        children,
+    };
+};
+exports.parseMebx = parseMebx;

package/dist/{boxes → containers}/iso-base-media/stsd/samples.d.ts

@@ -1,8 +1,6 @@
-import type { BufferIterator } from '../../../buffer-iterator';
-import type { LogLevel } from '../../../log';
-import type { Options, ParseMediaFields } from '../../../options';
-import type { AnySegment, IsoBaseMediaBox } from '../../../parse-result';
+import type { AnySegment } from '../../../parse-result';
 import type { ParserState } from '../../../state/parser-state';
+import type { IsoBaseMediaBox } from '../base-media-box';
 type SampleBase = {
     format: string;
     offset: number;
@@ -47,22 +45,14 @@ type UnknownSample = SampleBase & {
     type: 'unknown';
 };
 export type Sample = AudioSample | VideoSample | UnknownSample;
-type SampleAndNext = {
+type FormatBoxAndNext = {
     sample: Sample | null;
 };
-export declare const processSample: ({ iterator, state: options, signal, logLevel, fields, }: {
-    iterator: BufferIterator;
+export declare const processIsoFormatBox: ({ state, }: {
     state: ParserState;
-    signal: AbortSignal | null;
-    logLevel: LogLevel;
-    fields: Options<ParseMediaFields>;
-}) => Promise<SampleAndNext>;
-export declare const parseSamples: ({ iterator, maxBytes, state, signal, logLevel, fields, }: {
-    iterator: BufferIterator;
+}) => Promise<FormatBoxAndNext>;
+export declare const parseIsoFormatBoxes: ({ maxBytes, state, }: {
     maxBytes: number;
     state: ParserState;
-    signal: AbortSignal | null;
-    logLevel: LogLevel;
-    fields: Options<ParseMediaFields>;
 }) => Promise<Sample[]>;
 export {};