@remotion/media-parser 4.0.200 → 4.0.201

package/dist/buffer-iterator.js

@@ -51,6 +51,7 @@ exports.OffsetCounter = OffsetCounter;
 _OffsetCounter_offset = new WeakMap(), _OffsetCounter_discardedBytes = new WeakMap();
 const isoBaseMediaMp4Pattern = new TextEncoder().encode('ftyp');
 const mpegPattern = new Uint8Array([0xff, 0xf3, 0xe4, 0x64]);
+const riffPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
 const matchesPattern = (pattern) => {
     return (data) => {
         return pattern.every((value, index) => data[index] === value);
@@ -61,7 +62,9 @@ const makeOffsetCounter = () => {
 };
 const getArrayBufferIterator = (initialData, maxBytes) => {
     const buf = new ArrayBuffer(initialData.byteLength, {
-        maxByteLength: maxBytes !== null && maxBytes !== void 0 ? maxBytes : 1000000000,
+        maxByteLength: maxBytes
+            ? Math.min(maxBytes, 2 ** 32)
+            : 1000000000,
     });
     if (!buf.resize) {
         throw new Error('`ArrayBuffer.resize` is not supported in this Runtime. On the server: Use at least Node.js 20 or Bun. In the browser: Chrome 111, Edge 111, Safari 16.4, Firefox 128, Opera 111');
@@ -80,7 +83,52 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         counter.increment(1);
         return val;
     };
-    const getFourByteNumber = () => {
+    const getEightByteNumber = (littleEndian = false) => {
+        if (littleEndian) {
+            const one = getUint8();
+            const two = getUint8();
+            const three = getUint8();
+            const four = getUint8();
+            const five = getUint8();
+            const six = getUint8();
+            const seven = getUint8();
+            const eight = getUint8();
+            return ((eight << 56) |
+                (seven << 48) |
+                (six << 40) |
+                (five << 32) |
+                (four << 24) |
+                (three << 16) |
+                (two << 8) |
+                one);
+        }
+        function byteArrayToBigInt(byteArray) {
+            let result = BigInt(0);
+            for (let i = 0; i < byteArray.length; i++) {
+                result = (result << BigInt(8)) + BigInt(byteArray[i]);
+            }
+            return result;
+        }
+        const bigInt = byteArrayToBigInt([
+            getUint8(),
+            getUint8(),
+            getUint8(),
+            getUint8(),
+            getUint8(),
+            getUint8(),
+            getUint8(),
+            getUint8(),
+        ]);
+        return Number(bigInt);
+    };
+    const getFourByteNumber = (littleEndian = false) => {
+        if (littleEndian) {
+            const one = getUint8();
+            const two = getUint8();
+            const three = getUint8();
+            const four = getUint8();
+            return (four << 24) | (three << 16) | (two << 8) | one;
+        }
         return ((getUint8() << 24) | (getUint8() << 16) | (getUint8() << 8) | getUint8());
     };
     const getPaddedFourByteNumber = () => {
@@ -90,11 +138,16 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         }
         return lastInt;
     };
-    const getUint32 = () => {
-        const val = view.getUint32(counter.getDiscardedOffset());
+    const getUint32 = (littleEndian = false) => {
+        const val = view.getUint32(counter.getDiscardedOffset(), littleEndian);
         counter.increment(4);
         return val;
     };
+    const getUint64 = (littleEndian = false) => {
+        const val = view.getBigUint64(counter.getDiscardedOffset(), littleEndian);
+        counter.increment(8);
+        return val;
+    };
     const getUint32Le = () => {
         const val = view.getUint32(counter.getDiscardedOffset(), true);
         counter.increment(4);
@@ -128,6 +181,9 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
     const isIsoBaseMedia = () => {
         return matchesPattern(isoBaseMediaMp4Pattern)(data.subarray(4, 8));
     };
+    const isRiff = () => {
+        return matchesPattern(riffPattern)(data.subarray(0, 4));
+    };
     const isWebm = () => {
         return matchesPattern(make_header_1.webmPattern)(data.subarray(0, 4));
     };
@@ -154,7 +210,6 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
             counter.setDiscardedOffset(offset);
         }
         else {
-            buf.resize(offset);
             const currentOffset = counter.getOffset();
             counter.increment(offset - currentOffset);
             removeBytesRead();
@@ -225,19 +280,24 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         bytesRemaining,
         isIsoBaseMedia,
         leb128,
-        discardFirstBytes: removeBytesRead,
+        removeBytesRead,
         isWebm,
         discard: (length) => {
             counter.increment(length);
         },
+        getEightByteNumber,
         getFourByteNumber,
         getSlice,
         getAtom: () => {
             const atom = getSlice(4);
             return new TextDecoder().decode(atom);
         },
+        isRiff,
         getPaddedFourByteNumber,
         getMatroskaSegmentId: () => {
+            if (bytesRemaining() === 0) {
+                return null;
+            }
             const first = getSlice(1);
             const firstOneString = `0x${Array.from(new Uint8Array(first))
                 .map((b) => {
@@ -249,6 +309,9 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
             if (all_segments_1.knownIdsWithOneLength.includes(firstOneString)) {
                 return firstOneString;
             }
+            if (bytesRemaining() === 0) {
+                return null;
+            }
             const firstTwo = getSlice(1);
             const firstTwoString = `${firstOneString}${Array.from(new Uint8Array(firstTwo))
                 .map((b) => {
@@ -258,6 +321,9 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
             if (all_segments_1.knownIdsWithTwoLength.includes(firstTwoString)) {
                 return firstTwoString;
             }
+            if (bytesRemaining() === 0) {
+                return null;
+            }
             const firstThree = getSlice(1);
             const firstThreeString = `${firstTwoString}${Array.from(new Uint8Array(firstThree))
                 .map((b) => {
@@ -267,6 +333,9 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
             if (all_segments_1.knownIdsWithThreeLength.includes(firstThreeString)) {
                 return firstThreeString;
             }
+            if (bytesRemaining() === 0) {
+                return null;
+            }
             const segmentId = getSlice(1);
             return `${firstThreeString}${Array.from(new Uint8Array(segmentId))
                 .map((b) => {
@@ -275,6 +344,9 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
                 .join('')}`;
         },
         getVint: () => {
+            if (bytesRemaining() === 0) {
+                return null;
+            }
             const firstByte = getUint8();
             const totalLength = firstByte;
             if (totalLength === 0) {
@@ -285,6 +357,9 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
             while (((totalLength >> (7 - actualLength)) & 0x01) === 0) {
                 actualLength++;
             }
+            if (bytesRemaining() < actualLength) {
+                return null;
+            }
             const slice = getSlice(actualLength);
             const d = [firstByte, ...Array.from(new Uint8Array(slice))];
             actualLength += 1; // Include the first byte set as 1
@@ -328,6 +403,7 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
             return val;
         },
         getUint32,
+        getUint64,
         // https://developer.apple.com/documentation/quicktime-file-format/sound_sample_description_version_1
         // A 32-bit unsigned fixed-point number (16.16) that indicates the rate at which the sound samples were obtained.
         getFixedPointUnsigned1616Number: () => {
@@ -346,7 +422,7 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
             const val = getSlice(32);
             return [...Array.from(new Uint8Array(val))];
         },
-        getDecimalBytes(length) {
+        getUint(length) {
             const bytes = getSlice(length);
             const numbers = [...Array.from(new Uint8Array(bytes))];
             return numbers.reduce((acc, byte, index) => acc + (byte << (8 * (numbers.length - index - 1))), 0);

package/dist/from-fetch.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchReader = void 0;
 exports.fetchReader = {
-    read: async (src, range) => {
+    read: async (src, range, signal) => {
         if (typeof src !== 'string') {
-            throw new Error('src must be a string when using `webReader`');
+            throw new Error('src must be a string when using `fetchReader`');
         }
         const resolvedUrl = typeof window !== 'undefined' && typeof window.location !== 'undefined'
             ? new URL(src, window.location.origin).toString()
@@ -24,20 +24,30 @@ exports.fetchReader = {
                     : {
                         Range: `bytes=${`${range[0]}-${range[1]}`}`,
                     },
+            signal,
             // Disable Next.js caching
             cache: 'no-store',
         });
+        if (res.status.toString().startsWith('4') ||
+            res.status.toString().startsWith('5')) {
+            throw new Error(`Server returned status code ${res.status} for ${src}`);
+        }
         if (!res.body) {
             throw new Error('No body');
         }
         const length = res.headers.get('content-length');
         const contentLength = length === null ? null : parseInt(length, 10);
         const reader = res.body.getReader();
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                reader.cancel();
+            }, { once: true });
+        }
         return { reader, contentLength };
     },
     getLength: async (src) => {
         if (typeof src !== 'string') {
-            throw new Error('src must be a string when using `webReader`');
+            throw new Error('src must be a string when using `fetchReader`');
         }
         const res = await fetch(src, {
             method: 'HEAD',

package/dist/from-input-type-file.d.ts

@@ -0,0 +1,2 @@
+import type { ReaderInterface } from './reader';
+export declare const inputTypeFileReader: ReaderInterface;

package/dist/from-input-type-file.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inputTypeFileReader = void 0;
+exports.inputTypeFileReader = {
+    read: (file, range) => {
+        if (typeof file === 'string') {
+            throw new Error('`inputTypeFileReader` only supports `File` objects');
+        }
+        if (range !== null) {
+            throw new Error('`inputTypeFileReader` does not support `range`');
+        }
+        const part = range === null
+            ? file
+            : typeof range === 'number'
+                ? file.slice(range)
+                : file.slice(range[0], range[1]);
+        const reader = new FileReader();
+        reader.readAsArrayBuffer(file);
+        return new Promise((resolve, reject) => {
+            reader.onload = () => {
+                resolve({
+                    reader: part.stream().getReader(),
+                    contentLength: file.size,
+                });
+            };
+            reader.onerror = (error) => {
+                reject(error);
+            };
+        });
+    },
+    getLength: (src) => {
+        if (typeof src === 'string') {
+            throw new Error('`inputTypeFileReader` only supports `File` objects');
+        }
+        return Promise.resolve(src.size);
+    },
+};

package/dist/from-node.js

@@ -5,7 +5,7 @@ const fs_1 = require("fs");
 const promises_1 = require("node:fs/promises");
 const stream_1 = require("stream");
 exports.nodeReader = {
-    read: async (src, range) => {
+    read: async (src, range, signal) => {
         if (typeof src !== 'string') {
             throw new Error('src must be a string when using `nodeReader`');
         }
@@ -16,10 +16,17 @@ exports.nodeReader = {
                 : typeof range === 'number'
                     ? Infinity
                     : range[1],
+            signal,
         });
         const stats = await (0, promises_1.stat)(src);
+        const reader = stream_1.Readable.toWeb(stream).getReader();
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                reader.cancel();
+            }, { once: true });
+        }
         return {
-            reader: stream_1.Readable.toWeb(stream).getReader(),
+            reader,
             contentLength: stats.size,
         };
     },

package/dist/from-web-file.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.webFileReader = void 0;
 exports.webFileReader = {
-    read: (file, range) => {
+    read: (file, range, signal) => {
         if (typeof file === 'string') {
             throw new Error('`inputTypeFileReader` only supports `File` objects');
         }
@@ -13,6 +13,11 @@ exports.webFileReader = {
                 : file.slice(range[0], range[1]);
         const reader = new FileReader();
         reader.readAsArrayBuffer(file);
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                reader.abort();
+            }, { once: true });
+        }
         return new Promise((resolve, reject) => {
             reader.onload = () => {
                 resolve({

package/dist/from-web.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.webReader = void 0;
 exports.webReader = {
     read: async (src, range) => {
+        if (typeof src !== 'string') {
+            throw new Error('src must be a string when using `webReader`');
+        }
         const resolvedUrl = typeof window !== 'undefined' && typeof window.location !== 'undefined'
             ? new URL(src, window.location.origin).toString()
             : src;
@@ -14,22 +17,28 @@ exports.webReader = {
         const res = await fetch(resolvedUrl, {
             headers: range === null
                 ? {}
-                : {
-                    Range: `bytes=${`${range[0]}-${range[1]}`}`,
-                },
+                : typeof range === 'number'
+                    ? {
+                        Range: `bytes=${range}`,
+                    }
+                    : {
+                        Range: `bytes=${`${range[0]}-${range[1]}`}`,
+                    },
+            // Disable Next.js caching
+            cache: 'no-store',
         });
         if (!res.body) {
             throw new Error('No body');
         }
         const length = res.headers.get('content-length');
-        if (!length) {
-            throw new Error('No content-length');
-        }
         const contentLength = length === null ? null : parseInt(length, 10);
         const reader = res.body.getReader();
         return { reader, contentLength };
     },
     getLength: async (src) => {
+        if (typeof src !== 'string') {
+            throw new Error('src must be a string when using `webReader`');
+        }
         const res = await fetch(src, {
             method: 'HEAD',
         });

package/dist/get-audio-codec.d.ts

@@ -14,7 +14,7 @@ export declare const getNumberOfChannelsFromTrak: (trak: TrakBox) => number | nu
 export declare const getSampleRate: (trak: TrakBox) => number | null;
 export declare const getAudioCodecFromTrak: (trak: TrakBox) => AudioCodecInfo | null;
 export declare const getAudioCodecFromIso: (moov: MoovBox) => AudioCodecInfo | null;
-export declare const getAudioCodecFromMatroska: (mainSegment: MainSegment) => "vorbis" | "opus" | "mp3" | "aac" | "pcm" | null;
+export declare const getAudioCodecFromMatroska: (mainSegment: MainSegment) => "aac" | "mp3" | "opus" | "pcm" | "vorbis" | null;
 export declare const getAudioCodecStringFromTrak: (trak: TrakBox) => {
     codecString: string;
     description: Uint8Array | undefined;

package/dist/get-codec.d.ts

@@ -0,0 +1,4 @@
+import type { KnownVideoCodecs } from './options';
+import type { AnySegment } from './parse-result';
+export declare const hasVideoCodec: (boxes: AnySegment[]) => boolean;
+export declare const getVideoCodec: (boxes: AnySegment[]) => KnownVideoCodecs | null;

package/dist/get-codec.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVideoCodec = exports.hasVideoCodec = void 0;
+const hasVideoCodec = (boxes) => {
+    try {
+        return boxes.some((b) => b.type === 'ftyp-box');
+    }
+    catch (err) {
+        return false;
+    }
+};
+exports.hasVideoCodec = hasVideoCodec;
+const getVideoCodec = (boxes) => {
+    const ftypBox = boxes.find((b) => b.type === 'ftyp-box');
+    if (ftypBox && ftypBox.type === 'ftyp-box') {
+        if (ftypBox.compatibleBrands.find((b) => b === 'avc1')) {
+            return 'h264';
+        }
+    }
+    return null;
+};
+exports.getVideoCodec = getVideoCodec;

package/dist/get-sample-positions.js

@@ -38,7 +38,7 @@ const getSamplePositions = ({ stcoBox, stszBox, stscBox, stssBox, sttsBox, cttsB
             const ctsOffset = cttsEntries[samples.length];
             const cts = dts + ctsOffset;
             samples.push({
-                offset: chunks[i] + offsetInThisChunk,
+                offset: Number(chunks[i]) + offsetInThisChunk,
                 size,
                 isKeyframe,
                 dts,

package/dist/has-all-info.js

@@ -20,7 +20,7 @@ const hasAllInfo = (options, parseResult, state) => {
         }
         if (key === 'dimensions' ||
             key === 'rotation' ||
-            key === 'unrotatedDimension') {
+            key === 'unrotatedDimensions') {
             return (0, get_dimensions_1.hasDimensions)(parseResult.segments, state);
         }
         if (key === 'fps') {

package/dist/options.d.ts

@@ -15,7 +15,7 @@ export type Options<EnableDimensions extends boolean, EnableDuration extends boo
     audioCodec?: EnableAudioCodec;
     tracks?: EnableTracks;
     rotation?: EnableRotation;
-    unrotatedDimension?: EnableUnrotatedDimensions;
+    unrotatedDimensions?: EnableUnrotatedDimensions;
     internalStats?: EnableInternalStats;
 };
 export type Metadata<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean, EnableAudioCodec extends boolean, EnableTracks extends boolean, EnableRotation extends boolean, EnableUnrotatedDimensions extends boolean, EnableInternalStats extends boolean> = (EnableDimensions extends true ? {
@@ -36,7 +36,7 @@ export type Metadata<EnableDimensions extends boolean, EnableDuration extends bo
 } : {}) & (EnableRotation extends true ? {
     rotation: number | null;
 } : {}) & (EnableUnrotatedDimensions extends true ? {
-    unrotatedDimension: Dimensions;
+    unrotatedDimensions: Dimensions;
 } : {}) & (EnableInternalStats extends true ? {
     internalStats: InternalStats;
 } : {});
@@ -46,4 +46,5 @@ export type ParseMedia = <EnableDimensions extends boolean, EnableDuration exten
     reader?: ReaderInterface;
     onAudioTrack?: OnAudioTrack;
     onVideoTrack?: OnVideoTrack;
+    signal?: AbortSignal;
 }) => Promise<Metadata<EnableDimensions, EnableDuration, EnableBoxes, EnableFps, EnableVideoCodec, EnableAudioCodec, EnableTracks, EnableRotation, EnableUnrotatedDimensions, EnableInternalStats>>;

package/dist/parse-media.js

@@ -12,16 +12,17 @@ const get_video_codec_1 = require("./get-video-codec");
 const has_all_info_1 = require("./has-all-info");
 const parse_video_1 = require("./parse-video");
 const parser_state_1 = require("./parser-state");
-const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.fetchReader, onAudioTrack, onVideoTrack, }) => {
-    const { reader, contentLength } = await readerInterface.read(src, null);
-    let currentReader = reader;
-    const returnValue = {};
-    let iterator = null;
-    let parseResult = null;
+const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.fetchReader, onAudioTrack, onVideoTrack, signal, }) => {
     const state = (0, parser_state_1.makeParserState)({
         hasAudioCallbacks: onAudioTrack !== null,
         hasVideoCallbacks: onVideoTrack !== null,
+        signal,
     });
+    const { reader, contentLength } = await readerInterface.read(src, null, signal);
+    let currentReader = reader;
+    const returnValue = {};
+    let iterator = null;
+    let parseResult = null;
     const options = {
         canSkipVideoData: !(onAudioTrack || onVideoTrack),
         onAudioTrack: onAudioTrack !== null && onAudioTrack !== void 0 ? onAudioTrack : null,
@@ -29,6 +30,9 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
         parserState: state,
     };
     while (parseResult === null || parseResult.status === 'incomplete') {
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            throw new Error('Aborted');
+        }
         const result = await currentReader.read();
         if (iterator) {
             if (!result.done) {
@@ -66,7 +70,7 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
             if (!currentReader.closed) {
                 currentReader.cancel(new Error('skipped ahead'));
             }
-            const { reader: newReader } = await readerInterface.read(src, parseResult.skipTo);
+            const { reader: newReader } = await readerInterface.read(src, parseResult.skipTo, signal);
             currentReader = newReader;
             iterator.skipTo(parseResult.skipTo);
         }
@@ -81,9 +85,9 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
             height: dimensions.height,
         };
     }
-    if (fields === null || fields === void 0 ? void 0 : fields.unrotatedDimension) {
+    if (fields === null || fields === void 0 ? void 0 : fields.unrotatedDimensions) {
         const dimensions = (0, get_dimensions_1.getDimensions)(parseResult.segments, state);
-        returnValue.unrotatedDimension = {
+        returnValue.unrotatedDimensions = {
             width: dimensions.unrotatedWidth,
             height: dimensions.unrotatedHeight,
         };

package/dist/parse-video.js

@@ -17,6 +17,21 @@ const parseVideo = ({ iterator, options, }) => {
             skipTo: null,
         });
     }
+    if (iterator.isRiff()) {
+        throw new Error('AVI files are not yet supported');
+        /*
+        iterator.discard(4);
+        return parseBoxes({
+            iterator,
+            maxBytes: Infinity,
+            allowIncompleteBoxes: true,
+            initialBoxes: [],
+            options,
+            continueMdat: false,
+            littleEndian: true,
+        });
+        */
+    }
     if (iterator.isIsoBaseMedia()) {
         return (0, process_box_1.parseBoxes)({
             iterator,
@@ -25,6 +40,7 @@ const parseVideo = ({ iterator, options, }) => {
             initialBoxes: [],
             options,
             continueMdat: false,
+            littleEndian: false,
         });
     }
     if (iterator.isWebm()) {

package/dist/parser-state.d.ts

@@ -1,13 +1,14 @@
 import type { OnTrackEntrySegment } from './boxes/webm/segments';
-import type { CodecSegment } from './boxes/webm/segments/track-entry';
+import type { TrackInfo } from './boxes/webm/segments/track-entry';
 import type { AudioSample, OnAudioSample, OnVideoSample, VideoSample } from './webcodec-sample-types';
 export type InternalStats = {};
-export declare const makeParserState: ({ hasAudioCallbacks, hasVideoCallbacks, }: {
+export declare const makeParserState: ({ hasAudioCallbacks, hasVideoCallbacks, signal, }: {
     hasAudioCallbacks: boolean;
     hasVideoCallbacks: boolean;
+    signal: AbortSignal | undefined;
 }) => {
     onTrackEntrySegment: OnTrackEntrySegment;
-    getTrackInfoByNumber: (id: number) => CodecSegment;
+    getTrackInfoByNumber: (id: number) => TrackInfo;
     registerVideoSampleCallback: (id: number, callback: OnVideoSample | null) => Promise<void>;
     setTimestampOffset: (byteOffset: number, timestamp: number) => void;
     getTimestampOffsetForByteOffset: (byteOffset: number) => number | undefined;

package/dist/parser-state.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeParserState = void 0;
 const traversal_1 = require("./boxes/webm/traversal");
 const traversal_2 = require("./traversal");
-const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, }) => {
+const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, signal, }) => {
     const trackEntries = {};
     const onTrackEntrySegment = (trackEntry) => {
         const trackId = (0, traversal_2.getTrackId)(trackEntry);
@@ -17,7 +17,11 @@ const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, }) => {
         if (!codec) {
             throw new Error('Expected codec');
         }
-        trackEntries[trackId] = codec;
+        const trackTimescale = (0, traversal_1.getTrackTimestampScale)(trackEntry);
+        trackEntries[trackId] = {
+            codec: codec.codec,
+            trackTimescale,
+        };
     };
     const videoSampleCallbacks = {};
     const audioSampleCallbacks = {};
@@ -26,8 +30,10 @@ const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, }) => {
     const declinedTrackNumbers = [];
     let timescale = null;
     const getTimescale = () => {
+        // https://www.matroska.org/technical/notes.html
+        // When using the default value of TimestampScale of “1,000,000”, one Segment Tick represents one millisecond.
         if (timescale === null) {
-            throw new Error('Timescale not set');
+            return 1000000;
         }
         return timescale;
     };
@@ -85,6 +91,9 @@ const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, }) => {
             queuedAudioSamples[id] = [];
         },
         onAudioSample: async (trackId, audioSample) => {
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                throw new Error('Aborted');
+            }
             const callback = audioSampleCallbacks[trackId];
             if (callback) {
                 await callback(audioSample);
@@ -99,6 +108,9 @@ const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, }) => {
             }
         },
         onVideoSample: async (trackId, videoSample) => {
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                throw new Error('Aborted');
+            }
             const callback = videoSampleCallbacks[trackId];
             if (callback) {
                 await callback(videoSample);

package/dist/reader.d.ts

@@ -2,7 +2,7 @@ type ReadResult = {
     reader: ReadableStreamDefaultReader<Uint8Array>;
     contentLength: number | null;
 };
-type ReadContent = (src: string | File, range: [number, number] | number | null) => Promise<ReadResult>;
+type ReadContent = (src: string | File, range: [number, number] | number | null, signal: AbortSignal | undefined) => Promise<ReadResult>;
 type GetLength = (src: string | File) => Promise<number>;
 export type ReaderInterface = {
     read: ReadContent;

package/dist/web-file.d.ts

@@ -0,0 +1,2 @@
+import type { ReaderInterface } from './reader';
+export declare const inputTypeFileReader: ReaderInterface;