@remotion/media-parser 4.0.209 → 4.0.211

package/buffer.js

@@ -0,0 +1,2 @@
+// For backwards compatibility when you use Metro
+module.exports = require('./dist/writers/buffer');

package/dist/boxes/iso-base-media/get-sample-positions-from-track.js

@@ -4,7 +4,7 @@ exports.getSamplePositionsFromTrack = void 0;
 const get_fps_1 = require("../../get-fps");
 const get_sample_positions_1 = require("../../get-sample-positions");
 const samples_from_moof_1 = require("../../samples-from-moof");
-const traversal_1 = require("../../traversal");
+const traversal_1 = require("./traversal");
 const getSamplePositionsFromTrack = (trakBox, moofBox) => {
     const stszBox = (0, traversal_1.getStszBox)(trakBox);
     const stcoBox = (0, traversal_1.getStcoBox)(trakBox);

package/dist/boxes/iso-base-media/make-track.js

@@ -5,8 +5,9 @@ const get_audio_codec_1 = require("../../get-audio-codec");
 const get_fps_1 = require("../../get-fps");
 const get_sample_aspect_ratio_1 = require("../../get-sample-aspect-ratio");
 const get_video_codec_1 = require("../../get-video-codec");
-const traversal_1 = require("../../traversal");
+const traversal_1 = require("./traversal");
 const makeBaseMediaTrack = (trakBox) => {
+    var _a;
     const tkhdBox = (0, traversal_1.getTkhdBox)(trakBox);
     const videoDescriptors = (0, traversal_1.getVideoDescriptors)(trakBox);
     const timescaleAndDuration = (0, get_fps_1.getTimescaleAndDuration)(trakBox);
@@ -35,6 +36,8 @@ const makeBaseMediaTrack = (trakBox) => {
             sampleRate,
             description,
             trakBox,
+            codecPrivate: null,
+            codecWithoutConfig: (0, get_audio_codec_1.getAudioCodecFromTrack)(trakBox),
         };
     }
     if (!(0, get_fps_1.trakBoxContainsVideo)(trakBox)) {
@@ -45,7 +48,7 @@ const makeBaseMediaTrack = (trakBox) => {
             trakBox,
         };
     }
-    const videoSample = (0, get_sample_aspect_ratio_1.getVideoSample)(trakBox);
+    const videoSample = (0, get_sample_aspect_ratio_1.getStsdVideoConfig)(trakBox);
     if (!videoSample) {
         throw new Error('No video sample');
     }
@@ -63,6 +66,7 @@ const makeBaseMediaTrack = (trakBox) => {
     if (!codec) {
         throw new Error('Could not find video codec');
     }
+    const privateData = (0, get_video_codec_1.getVideoPrivateData)(trakBox);
     const track = {
         type: 'video',
         trackId: tkhdBox.trackId,
@@ -79,6 +83,14 @@ const makeBaseMediaTrack = (trakBox) => {
         displayAspectHeight,
         rotation,
         trakBox,
+        codecPrivate: privateData,
+        color: (_a = (0, get_video_codec_1.getIsoBmColrConfig)(trakBox)) !== null && _a !== void 0 ? _a : {
+            fullRange: null,
+            matrixCoefficients: null,
+            primaries: null,
+            transferCharacteristics: null,
+        },
+        codecWithoutConfig: (0, get_video_codec_1.getVideoCodecFromIsoTrak)(trakBox),
     };
     return track;
 };

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

@@ -1,16 +1,25 @@
 import type { BufferIterator } from '../../../buffer-iterator';
 import type { AnySegment } from '../../../parse-result';
 import type { ParserContext } from '../../../parser-context';
-export interface MdatBox {
+type MdatStatus = {
+    status: 'samples-buffered';
+} | {
+    status: 'samples-skipped';
+} | {
+    status: 'samples-processed';
+};
+export type MdatBox = {
     type: 'mdat-box';
-    samplesProcessed: boolean;
     boxSize: number;
     fileOffset: number;
-}
-export declare const parseMdat: ({ data, size, fileOffset, existingBoxes, options, }: {
+} & MdatStatus;
+export declare const parseMdat: ({ data, size, fileOffset, existingBoxes, options, signal, maySkipSampleProcessing, }: {
     data: BufferIterator;
     size: number;
     fileOffset: number;
     existingBoxes: AnySegment[];
     options: ParserContext;
+    signal: AbortSignal | null;
+    maySkipSampleProcessing: boolean;
 }) => Promise<MdatBox>;
+export {};

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

@@ -2,16 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMdat = void 0;
 const get_tracks_1 = require("../../../get-tracks");
-const traversal_1 = require("../../../traversal");
 const get_sample_positions_from_track_1 = require("../get-sample-positions-from-track");
-const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, }) => {
+const traversal_1 = require("../traversal");
+const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, signal, maySkipSampleProcessing, }) => {
     const alreadyHas = (0, get_tracks_1.hasTracks)(existingBoxes);
     if (!alreadyHas) {
+        if (maySkipSampleProcessing) {
+            data.discard(size - (data.counter.getOffset() - fileOffset));
+            return Promise.resolve({
+                type: 'mdat-box',
+                boxSize: size,
+                status: 'samples-skipped',
+                fileOffset,
+            });
+        }
         data.discard(size - (data.counter.getOffset() - fileOffset));
+        data.disallowDiscard();
         return Promise.resolve({
             type: 'mdat-box',
             boxSize: size,
-            samplesProcessed: false,
+            status: 'samples-buffered',
             fileOffset,
         });
     }
@@ -37,6 +47,9 @@ const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, }) =>
         .flat(1);
     // eslint-disable-next-line no-constant-condition
     while (true) {
+        if (signal && signal.aborted) {
+            break;
+        }
         const samplesWithIndex = flatSamples.find((sample) => {
             return sample.samplePosition.offset === data.counter.getOffset();
         });
@@ -62,9 +75,11 @@ const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, }) =>
         }
         const bytes = data.getSlice(samplesWithIndex.samplePosition.size);
         if (samplesWithIndex.track.type === 'audio') {
+            const timestamp = Math.floor((samplesWithIndex.samplePosition.cts * 1000000) /
+                samplesWithIndex.track.timescale);
             await options.parserState.onAudioSample(samplesWithIndex.track.trackId, {
                 data: bytes,
-                timestamp: samplesWithIndex.samplePosition.offset,
+                timestamp,
                 trackId: samplesWithIndex.track.trackId,
                 type: samplesWithIndex.samplePosition.isKeyframe ? 'key' : 'delta',
             });
@@ -93,7 +108,7 @@ const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, }) =>
     return Promise.resolve({
         type: 'mdat-box',
         boxSize: size,
-        samplesProcessed: true,
+        status: 'samples-processed',
         fileOffset,
     });
 };

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

@@ -6,9 +6,10 @@ export interface MoovBox extends BaseBox {
     type: 'moov-box';
     children: AnySegment[];
 }
-export declare const parseMoov: ({ iterator, offset, size, options, }: {
+export declare const parseMoov: ({ iterator, offset, size, options, signal, }: {
     iterator: BufferIterator;
     offset: number;
     size: number;
     options: ParserContext;
+    signal: AbortSignal | null;
 }) => Promise<MoovBox>;

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMoov = void 0;
 const process_box_1 = require("../process-box");
-const parseMoov = async ({ iterator, offset, size, options, }) => {
+const parseMoov = async ({ iterator, offset, size, options, signal, }) => {
     const children = await (0, process_box_1.parseBoxes)({
         iterator,
         maxBytes: size - (iterator.counter.getOffset() - offset),
@@ -11,6 +11,7 @@ const parseMoov = async ({ iterator, offset, size, options, }) => {
         options,
         continueMdat: false,
         littleEndian: false,
+        signal,
     });
     if (children.status === 'incomplete') {
         throw new Error('Incomplete boxes are not allowed');

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

@@ -2,21 +2,23 @@ import type { BufferIterator } from '../../buffer-iterator';
 import type { AnySegment, IsoBaseMediaBox, ParseResult } from '../../parse-result';
 import type { BoxAndNext, PartialMdatBox } from '../../parse-video';
 import type { ParserContext } from '../../parser-context';
-export declare const parseMdatPartially: ({ iterator, boxSize, fileOffset, parsedBoxes, options, }: {
+export declare const parseMdatPartially: ({ iterator, boxSize, fileOffset, parsedBoxes, options, signal, }: {
     iterator: BufferIterator;
     boxSize: number;
     fileOffset: number;
     parsedBoxes: AnySegment[];
     options: ParserContext;
+    signal: AbortSignal | null;
 }) => Promise<BoxAndNext>;
-export declare const processBox: ({ iterator, allowIncompleteBoxes, parsedBoxes, options, littleEndian, }: {
+export declare const processBox: ({ iterator, allowIncompleteBoxes, parsedBoxes, options, littleEndian, signal, }: {
     iterator: BufferIterator;
     allowIncompleteBoxes: boolean;
     parsedBoxes: AnySegment[];
     options: ParserContext;
     littleEndian: boolean;
+    signal: AbortSignal | null;
 }) => Promise<BoxAndNext>;
-export declare const parseBoxes: ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, littleEndian, }: {
+export declare const parseBoxes: ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, littleEndian, signal, }: {
     iterator: BufferIterator;
     maxBytes: number;
     allowIncompleteBoxes: boolean;
@@ -24,4 +26,5 @@ export declare const parseBoxes: ({ iterator, maxBytes, allowIncompleteBoxes, in
     options: ParserContext;
     continueMdat: false | PartialMdatBox;
     littleEndian: boolean;
+    signal: AbortSignal | null;
 }) => Promise<ParseResult>;

package/dist/boxes/iso-base-media/process-box.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseBoxes = exports.processBox = exports.parseMdatPartially = void 0;
 const get_tracks_1 = require("../../get-tracks");
-const traversal_1 = require("../../traversal");
 const esds_1 = require("./esds/esds");
 const ftyp_1 = require("./ftyp");
 const make_track_1 = require("./make-track");
@@ -27,8 +26,9 @@ const tfdt_1 = require("./tfdt");
 const tfhd_1 = require("./tfhd");
 const tkhd_1 = require("./tkhd");
 const trak_1 = require("./trak/trak");
+const traversal_1 = require("./traversal");
 const trun_1 = require("./trun");
-const getChildren = async ({ boxType, iterator, bytesRemainingInBox, options, littleEndian, }) => {
+const getChildren = async ({ boxType, iterator, bytesRemainingInBox, options, littleEndian, signal, }) => {
     const parseChildren = boxType === 'mdia' ||
         boxType === 'minf' ||
         boxType === 'stbl' ||
@@ -46,6 +46,7 @@ const getChildren = async ({ boxType, iterator, bytesRemainingInBox, options, li
             options,
             continueMdat: false,
             littleEndian,
+            signal,
         });
         if (parsed.status === 'incomplete') {
             throw new Error('Incomplete boxes are not allowed');
@@ -58,15 +59,17 @@ const getChildren = async ({ boxType, iterator, bytesRemainingInBox, options, li
     iterator.discard(bytesRemainingInBox);
     return [];
 };
-const parseMdatPartially = async ({ iterator, boxSize, fileOffset, parsedBoxes, options, }) => {
+const parseMdatPartially = async ({ iterator, boxSize, fileOffset, parsedBoxes, options, signal, }) => {
     const box = await (0, mdat_1.parseMdat)({
         data: iterator,
         size: boxSize,
         fileOffset,
         existingBoxes: parsedBoxes,
         options,
+        signal,
+        maySkipSampleProcessing: options.supportsContentRange,
     });
-    if (box.samplesProcessed &&
+    if ((box.status === 'samples-processed' || box.status === 'samples-buffered') &&
         box.fileOffset + boxSize === iterator.counter.getOffset()) {
         return {
             type: 'complete',
@@ -82,7 +85,7 @@ const parseMdatPartially = async ({ iterator, boxSize, fileOffset, parsedBoxes,
     };
 };
 exports.parseMdatPartially = parseMdatPartially;
-const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options, littleEndian, }) => {
+const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options, littleEndian, signal, }) => {
     var _a, _b;
     const fileOffset = iterator.counter.getOffset();
     const bytesRemaining = iterator.bytesRemaining();
@@ -113,7 +116,8 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
     const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber(littleEndian) : boxSizeRaw;
     if (bytesRemaining < boxSize) {
         if (boxType === 'mdat') {
-            const shouldSkip = options.canSkipVideoData || !(0, get_tracks_1.hasTracks)(parsedBoxes);
+            const shouldSkip = (options.canSkipVideoData || !(0, get_tracks_1.hasTracks)(parsedBoxes)) &&
+                options.supportsContentRange;
             if (shouldSkip) {
                 const skipTo = fileOffset + boxSize;
                 const bytesToSkip = skipTo - iterator.counter.getOffset();
@@ -125,7 +129,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
                             type: 'mdat-box',
                             boxSize,
                             fileOffset,
-                            samplesProcessed: false,
+                            status: 'samples-skipped',
                         },
                         size: boxSize,
                         skipTo: fileOffset + boxSize,
@@ -139,6 +143,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
                     fileOffset,
                     parsedBoxes,
                     options,
+                    signal,
                 });
             }
         }
@@ -212,6 +217,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             offset: fileOffset,
             size: boxSize,
             options,
+            signal,
         });
         return {
             type: 'complete',
@@ -306,6 +312,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             size: boxSize,
             options,
             littleEndian,
+            signal,
         });
         return {
             type: 'complete',
@@ -320,6 +327,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             offset: fileOffset,
             size: boxSize,
             options,
+            signal,
         });
         return {
             type: 'complete',
@@ -334,6 +342,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             size: boxSize,
             offsetAtStart: fileOffset,
             options,
+            signal,
         });
         const transformedTrack = (0, make_track_1.makeBaseMediaTrack)(box);
         if (transformedTrack) {
@@ -449,7 +458,12 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             fileOffset,
             existingBoxes: parsedBoxes,
             options,
+            signal,
+            maySkipSampleProcessing: options.supportsContentRange,
         });
+        if (box === null) {
+            throw new Error('Unexpected null');
+        }
         return {
             type: 'complete',
             box,
@@ -464,6 +478,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
         bytesRemainingInBox,
         options,
         littleEndian,
+        signal,
     });
     return {
         type: 'complete',
@@ -479,7 +494,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
     };
 };
 exports.processBox = processBox;
-const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, littleEndian, }) => {
+const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, littleEndian, signal, }) => {
     let boxes = initialBoxes;
     const initialOffset = iterator.counter.getOffset();
     const alreadyHasMdat = boxes.find((b) => b.type === 'mdat-box');
@@ -492,6 +507,7 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                 fileOffset: continueMdat.fileOffset,
                 parsedBoxes: initialBoxes,
                 options,
+                signal,
             })
             : await (0, exports.processBox)({
                 iterator,
@@ -499,6 +515,7 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                 parsedBoxes: initialBoxes,
                 options,
                 littleEndian,
+                signal,
             });
         if (result.type === 'incomplete') {
             if (Number.isFinite(maxBytes)) {
@@ -516,6 +533,7 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                         options,
                         continueMdat: false,
                         littleEndian,
+                        signal,
                     });
                 },
                 skipTo: null,
@@ -534,6 +552,7 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                         options,
                         continueMdat: result,
                         littleEndian,
+                        signal,
                     }));
                 },
                 skipTo: null,
@@ -542,12 +561,19 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
         if (result.box.type === 'mdat-box' && alreadyHasMdat) {
             boxes = boxes.filter((b) => b.type !== 'mdat-box');
             boxes.push(result.box);
+            iterator.allowDiscard();
+            if (result.box.status !== 'samples-processed') {
+                throw new Error('unexpected');
+            }
             break;
         }
         else {
             boxes.push(result.box);
         }
         if (result.skipTo !== null) {
+            if (!options.supportsContentRange) {
+                throw new Error('Content-Range header is not supported by the reader, but was asked to seek');
+            }
             return {
                 status: 'incomplete',
                 segments: boxes,
@@ -560,30 +586,58 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                         options,
                         continueMdat: false,
                         littleEndian,
+                        signal,
                     });
                 },
                 skipTo: result.skipTo,
             };
         }
+        if (iterator.bytesRemaining() < 0) {
+            return {
+                status: 'incomplete',
+                segments: boxes,
+                continueParsing: () => {
+                    return (0, exports.parseBoxes)({
+                        iterator,
+                        maxBytes,
+                        allowIncompleteBoxes,
+                        initialBoxes: boxes,
+                        options,
+                        continueMdat: false,
+                        littleEndian,
+                        signal,
+                    });
+                },
+                skipTo: null,
+            };
+        }
         iterator.removeBytesRead();
     }
-    const mdatState = (0, traversal_1.hasSkippedMdatProcessing)(boxes);
-    if (mdatState.skipped && !options.canSkipVideoData) {
+    const mdatState = (0, traversal_1.getMdatBox)(boxes);
+    const skipped = (mdatState === null || mdatState === void 0 ? void 0 : mdatState.status) === 'samples-skipped' &&
+        !options.canSkipVideoData &&
+        options.supportsContentRange;
+    const buffered = (mdatState === null || mdatState === void 0 ? void 0 : mdatState.status) === 'samples-buffered' && !options.canSkipVideoData;
+    if (skipped || buffered) {
         return {
             status: 'incomplete',
             segments: boxes,
             continueParsing: () => {
+                if (buffered) {
+                    iterator.skipTo(mdatState.fileOffset, false);
+                }
                 return (0, exports.parseBoxes)({
                     iterator,
                     maxBytes,
-                    allowIncompleteBoxes,
+                    allowIncompleteBoxes: false,
                     initialBoxes: boxes,
                     options,
                     continueMdat: false,
                     littleEndian,
+                    signal,
                 });
             },
-            skipTo: mdatState.fileOffset,
+            skipTo: skipped ? mdatState.fileOffset : null,
         };
     }
     return {

package/dist/boxes/iso-base-media/stsd/avcc.d.ts

@@ -1,7 +1,7 @@
 import type { BufferIterator } from '../../../buffer-iterator';
 export interface AvccBox {
     type: 'avcc-box';
-    description: Uint8Array;
+    privateData: Uint8Array;
     configurationString: string;
 }
 export declare const parseAvcc: ({ data, size, }: {

package/dist/boxes/iso-base-media/stsd/avcc.js

@@ -11,10 +11,10 @@ const parseAvcc = ({ data, size, }) => {
     const level = data.getUint8();
     const str = `${profile.toString(16).padStart(2, '0')}${profileCompatibility.toString(16).padStart(2, '0')}${level.toString(16).padStart(2, '0')}`;
     data.counter.decrement(4);
-    const description = data.getSlice(size - 8);
+    const privateData = data.getSlice(size - 8);
     return {
         type: 'avcc-box',
-        description,
+        privateData,
         configurationString: str,
     };
 };

package/dist/boxes/iso-base-media/stsd/ctts.js

@@ -13,12 +13,9 @@ const parseCtts = ({ iterator, offset, size, }) => {
         const sampleCount = iterator.getUint32();
         // V1 = signed, V0 = unsigned
         // however some files are buggy
-        // Let's do the same thing as mp4box but uint32, based on our test set of videos
+        // Let's do the same thing as mp4box
         // https://github.com/gpac/mp4box.js/blob/c6cc468145bc5b031b866446111f29c8b620dbe6/src/parsing/ctts.js#L2
-        const sampleOffset = iterator.getUint32();
-        if (sampleOffset < 0) {
-            throw new Error('ctts box uses negative values without using version 1');
-        }
+        const sampleOffset = iterator.getInt32();
         entries.push({
             sampleCount,
             sampleOffset,

package/dist/boxes/iso-base-media/stsd/hvcc.d.ts

@@ -1,7 +1,7 @@
 import type { BufferIterator } from '../../../buffer-iterator';
 export interface HvccBox {
     type: 'hvcc-box';
-    data: Uint8Array;
+    privateData: Uint8Array;
     configurationString: string;
 }
 export declare const parseHvcc: ({ data, size, offset, }: {

package/dist/boxes/iso-base-media/stsd/hvcc.js

@@ -3,14 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseHvcc = void 0;
 const make_hvc1_codec_strings_1 = require("../../../make-hvc1-codec-strings");
 const parseHvcc = ({ data, size, offset, }) => {
-    const raw = data.getSlice(size - 8);
+    const privateData = data.getSlice(size - 8);
     data.counter.decrement(size - 8);
     const constraintString = (0, make_hvc1_codec_strings_1.getHvc1CodecString)(data);
     const remaining = size - (data.counter.getOffset() - offset);
     data.discard(remaining);
     return {
         type: 'hvcc-box',
-        data: raw,
+        privateData,
         configurationString: constraintString,
     };
 };

package/dist/boxes/iso-base-media/stsd/mebx.d.ts

@@ -8,10 +8,11 @@ export interface MebxBox extends BaseBox {
     format: string;
     children: AnySegment[];
 }
-export declare const parseMebx: ({ iterator, offset, size, options, littleEndian, }: {
+export declare const parseMebx: ({ iterator, offset, size, options, littleEndian, signal, }: {
     iterator: BufferIterator;
     offset: number;
     size: number;
     options: ParserContext;
     littleEndian: boolean;
+    signal: AbortSignal | null;
 }) => Promise<MebxBox>;

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMebx = void 0;
 const process_box_1 = require("../process-box");
-const parseMebx = async ({ iterator, offset, size, options, littleEndian, }) => {
+const parseMebx = async ({ iterator, offset, size, options, littleEndian, signal, }) => {
     // reserved, 6 bit
     iterator.discard(6);
     const dataReferenceIndex = iterator.getUint16();
@@ -14,6 +14,7 @@ const parseMebx = async ({ iterator, offset, size, options, littleEndian, }) =>
         options,
         continueMdat: false,
         littleEndian,
+        signal,
     });
     if (children.status === 'incomplete') {
         throw new Error('Incomplete boxes are not allowed');

package/dist/boxes/iso-base-media/stsd/samples.d.ts

@@ -48,13 +48,15 @@ export type Sample = AudioSample | VideoSample | UnknownSample;
 type SampleAndNext = {
     sample: Sample | null;
 };
-export declare const processSample: ({ iterator, options, }: {
+export declare const processSample: ({ iterator, options, signal, }: {
     iterator: BufferIterator;
     options: ParserContext;
+    signal: AbortSignal | null;
 }) => Promise<SampleAndNext>;
-export declare const parseSamples: ({ iterator, maxBytes, options, }: {
+export declare const parseSamples: ({ iterator, maxBytes, options, signal, }: {
     iterator: BufferIterator;
     maxBytes: number;
     options: ParserContext;
+    signal: AbortSignal | null;
 }) => Promise<Sample[]>;
 export {};