@remotion/media-parser 4.0.209 → 4.0.210

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

@@ -7,10 +7,11 @@ export interface MdatBox {
     boxSize: number;
     fileOffset: number;
 }
-export declare const parseMdat: ({ data, size, fileOffset, existingBoxes, options, }: {
+export declare const parseMdat: ({ data, size, fileOffset, existingBoxes, options, signal, }: {
     data: BufferIterator;
     size: number;
     fileOffset: number;
     existingBoxes: AnySegment[];
     options: ParserContext;
+    signal: AbortSignal | null;
 }) => Promise<MdatBox>;

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

@@ -2,9 +2,9 @@
 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, }) => {
     const alreadyHas = (0, get_tracks_1.hasTracks)(existingBoxes);
     if (!alreadyHas) {
         data.discard(size - (data.counter.getOffset() - fileOffset));
@@ -37,6 +37,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 +65,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',
             });

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,13 +59,14 @@ 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,
     });
     if (box.samplesProcessed &&
         box.fileOffset + boxSize === iterator.counter.getOffset()) {
@@ -82,7 +84,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();
@@ -139,6 +141,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
                     fileOffset,
                     parsedBoxes,
                     options,
+                    signal,
                 });
             }
         }
@@ -212,6 +215,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             offset: fileOffset,
             size: boxSize,
             options,
+            signal,
         });
         return {
             type: 'complete',
@@ -306,6 +310,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             size: boxSize,
             options,
             littleEndian,
+            signal,
         });
         return {
             type: 'complete',
@@ -320,6 +325,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             offset: fileOffset,
             size: boxSize,
             options,
+            signal,
         });
         return {
             type: 'complete',
@@ -334,6 +340,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,6 +456,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             fileOffset,
             existingBoxes: parsedBoxes,
             options,
+            signal,
         });
         return {
             type: 'complete',
@@ -464,6 +472,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
         bytesRemainingInBox,
         options,
         littleEndian,
+        signal,
     });
     return {
         type: 'complete',
@@ -479,7 +488,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 +501,7 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                 fileOffset: continueMdat.fileOffset,
                 parsedBoxes: initialBoxes,
                 options,
+                signal,
             })
             : await (0, exports.processBox)({
                 iterator,
@@ -499,6 +509,7 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                 parsedBoxes: initialBoxes,
                 options,
                 littleEndian,
+                signal,
             });
         if (result.type === 'incomplete') {
             if (Number.isFinite(maxBytes)) {
@@ -516,6 +527,7 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                         options,
                         continueMdat: false,
                         littleEndian,
+                        signal,
                     });
                 },
                 skipTo: null,
@@ -534,6 +546,7 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                         options,
                         continueMdat: result,
                         littleEndian,
+                        signal,
                     }));
                 },
                 skipTo: null,
@@ -560,6 +573,7 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                         options,
                         continueMdat: false,
                         littleEndian,
+                        signal,
                     });
                 },
                 skipTo: result.skipTo,
@@ -581,6 +595,7 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                     options,
                     continueMdat: false,
                     littleEndian,
+                    signal,
                 });
             },
             skipTo: mdatState.fileOffset,

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 {};

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

@@ -61,7 +61,7 @@ const audioTags = [
     'mp4a',
     'ac-3',
 ];
-const processSample = async ({ iterator, options, }) => {
+const processSample = async ({ iterator, options, signal, }) => {
     const fileOffset = iterator.counter.getOffset();
     const bytesRemaining = iterator.bytesRemaining();
     const boxSize = iterator.getUint32();
@@ -106,6 +106,7 @@ const processSample = async ({ iterator, options, }) => {
                 options,
                 continueMdat: false,
                 littleEndian: false,
+                signal,
             });
             if (children.status === 'incomplete') {
                 throw new Error('Incomplete boxes are not allowed');
@@ -152,6 +153,7 @@ const processSample = async ({ iterator, options, }) => {
                 options,
                 continueMdat: false,
                 littleEndian: false,
+                signal,
             });
             if (children.status === 'incomplete') {
                 throw new Error('Incomplete boxes are not allowed');
@@ -179,6 +181,57 @@ const processSample = async ({ iterator, options, }) => {
                 },
             };
         }
+        if (version === 2) {
+            const numberOfChannels = iterator.getUint16();
+            const sampleSize = iterator.getUint16();
+            const compressionId = iterator.getUint16();
+            const packetSize = iterator.getUint16();
+            iterator.getFixedPointUnsigned1616Number(); // LQ sample rate;
+            iterator.getUint32(); // ignore
+            const higherSampleRate = iterator.getFloat64();
+            iterator.getUint32(); // ignore;
+            iterator.getUint32(); // ignore, always 0x7F000000?
+            const bitsPerCodedSample = iterator.getUint32();
+            iterator.getUint32(); // ignore;
+            const bytesPerFrame = iterator.getUint32();
+            const samplesPerPacket = iterator.getUint32();
+            const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
+            const children = await (0, process_box_1.parseBoxes)({
+                iterator,
+                allowIncompleteBoxes: false,
+                maxBytes: bytesRemainingInBox,
+                initialBoxes: [],
+                options,
+                continueMdat: false,
+                littleEndian: false,
+                signal,
+            });
+            if (children.status === 'incomplete') {
+                throw new Error('Incomplete boxes are not allowed');
+            }
+            return {
+                sample: {
+                    format: boxFormat,
+                    offset: fileOffset,
+                    dataReferenceIndex,
+                    version,
+                    revisionLevel,
+                    vendor: [...Array.from(new Uint8Array(vendor))],
+                    size: boxSize,
+                    type: 'audio',
+                    numberOfChannels,
+                    sampleSize,
+                    compressionId,
+                    packetSize,
+                    sampleRate: higherSampleRate,
+                    samplesPerPacket,
+                    bytesPerPacket: null,
+                    bytesPerFrame,
+                    bitsPerSample: bitsPerCodedSample,
+                    children: children.segments,
+                },
+            };
+        }
         throw new Error(`Unsupported version ${version}`);
     }
     if (isVideo) {
@@ -197,15 +250,19 @@ const processSample = async ({ iterator, options, }) => {
         const depth = iterator.getUint16();
         const colorTableId = iterator.getInt16();
         const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-        const children = await (0, process_box_1.parseBoxes)({
-            iterator,
-            allowIncompleteBoxes: false,
-            maxBytes: bytesRemainingInBox,
-            initialBoxes: [],
-            options,
-            continueMdat: false,
-            littleEndian: false,
-        });
+        const children = bytesRemainingInBox > 8
+            ? await (0, process_box_1.parseBoxes)({
+                iterator,
+                allowIncompleteBoxes: false,
+                maxBytes: bytesRemainingInBox,
+                initialBoxes: [],
+                options,
+                continueMdat: false,
+                littleEndian: false,
+                signal,
+            })
+            : (iterator.discard(bytesRemainingInBox),
+                { status: 'done', segments: [] });
         if (children.status === 'incomplete') {
             throw new Error('Incomplete boxes are not allowed');
         }
@@ -237,7 +294,7 @@ const processSample = async ({ iterator, options, }) => {
     throw new Error(`Unknown sample format ${boxFormat}`);
 };
 exports.processSample = processSample;
-const parseSamples = async ({ iterator, maxBytes, options, }) => {
+const parseSamples = async ({ iterator, maxBytes, options, signal, }) => {
     const samples = [];
     const initialOffset = iterator.counter.getOffset();
     while (iterator.bytesRemaining() > 0 &&
@@ -245,6 +302,7 @@ const parseSamples = async ({ iterator, maxBytes, options, }) => {
         const { sample } = await (0, exports.processSample)({
             iterator,
             options,
+            signal,
         });
         if (sample) {
             samples.push(sample);

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

@@ -7,9 +7,10 @@ export interface StsdBox extends BaseBox {
     numberOfEntries: number;
     samples: Sample[];
 }
-export declare const parseStsd: ({ iterator, offset, size, options, }: {
+export declare const parseStsd: ({ iterator, offset, size, options, signal, }: {
     iterator: BufferIterator;
     offset: number;
     size: number;
     options: ParserContext;
+    signal: AbortSignal | null;
 }) => Promise<StsdBox>;

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseStsd = void 0;
 const samples_1 = require("./samples");
-const parseStsd = async ({ iterator, offset, size, options, }) => {
+const parseStsd = async ({ iterator, offset, size, options, signal, }) => {
     const version = iterator.getUint8();
     if (version !== 0) {
         throw new Error(`Unsupported STSD version ${version}`);
@@ -15,6 +15,7 @@ const parseStsd = async ({ iterator, offset, size, options, }) => {
         iterator,
         maxBytes: bytesRemainingInBox,
         options,
+        signal,
     });
     if (boxes.length !== numberOfEntries) {
         throw new Error(`Expected ${numberOfEntries} sample descriptions, got ${boxes.length}`);

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

@@ -6,9 +6,10 @@ export interface TrakBox extends BaseBox {
     type: 'trak-box';
     children: AnySegment[];
 }
-export declare const parseTrak: ({ data, size, offsetAtStart, options, }: {
+export declare const parseTrak: ({ data, size, offsetAtStart, options, signal, }: {
     data: BufferIterator;
     size: number;
     offsetAtStart: number;
     options: ParserContext;
+    signal: AbortSignal | null;
 }) => Promise<TrakBox>;

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

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