@remotion/media-parser 4.0.200 → 4.0.202

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-duration.js

@@ -3,33 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasDuration = exports.getDuration = void 0;
 const traversal_1 = require("./traversal");
 const getDurationFromMatroska = (segments) => {
-    const mainSegment = segments.find((s) => s.type === 'main-segment');
-    if (!mainSegment || mainSegment.type !== 'main-segment') {
+    const mainSegment = segments.find((s) => s.type === 'Segment');
+    if (!mainSegment || mainSegment.type !== 'Segment') {
         return null;
     }
-    const { children } = mainSegment;
+    const { value: children } = mainSegment;
     if (!children) {
         return null;
     }
-    const infoSegment = children.find((s) => s.type === 'info-segment');
+    const infoSegment = children.find((s) => s.type === 'Info');
     const relevantBoxes = [
-        ...mainSegment.children,
-        ...(infoSegment && infoSegment.type === 'info-segment'
-            ? infoSegment.children
-            : []),
+        ...mainSegment.value,
+        ...(infoSegment && infoSegment.type === 'Info' ? infoSegment.value : []),
     ];
-    const timestampScale = relevantBoxes.find((s) => s.type === 'timestamp-scale-segment');
-    if (!timestampScale || timestampScale.type !== 'timestamp-scale-segment') {
+    const timestampScale = relevantBoxes.find((s) => s.type === 'TimestampScale');
+    if (!timestampScale || timestampScale.type !== 'TimestampScale') {
         return null;
     }
-    const duration = relevantBoxes.find((s) => s.type === 'duration-segment');
-    if (!duration || duration.type !== 'duration-segment') {
+    const duration = relevantBoxes.find((s) => s.type === 'Duration');
+    if (!duration || duration.type !== 'Duration') {
         return null;
     }
-    return (duration.duration / timestampScale.timestampScale) * 1000;
+    return (duration.value.value / timestampScale.value.value) * 1000;
 };
 const getDuration = (boxes) => {
-    const matroskaBox = boxes.find((b) => b.type === 'main-segment');
+    const matroskaBox = boxes.find((b) => b.type === 'Segment');
     if (matroskaBox) {
         return getDurationFromMatroska(boxes);
     }

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/get-tracks.js

@@ -31,8 +31,8 @@ const getTracks = (segments, state) => {
     const videoTracks = [];
     const audioTracks = [];
     const otherTracks = [];
-    const mainSegment = segments.find((s) => s.type === 'main-segment');
-    if (mainSegment && mainSegment.type === 'main-segment') {
+    const mainSegment = segments.find((s) => s.type === 'Segment');
+    if (mainSegment && mainSegment.type === 'Segment') {
         const matroskaTracks = (0, get_ready_tracks_1.getTracksFromMatroska)(mainSegment, state.getTimescale());
         for (const track of matroskaTracks) {
             if (track.type === 'video') {

package/dist/get-video-codec.js

@@ -60,31 +60,31 @@ const getVideoCodec = (boxes) => {
             }
         }
     }
-    const mainSegment = boxes.find((b) => b.type === 'main-segment');
-    if (!mainSegment || mainSegment.type !== 'main-segment') {
+    const mainSegment = boxes.find((b) => b.type === 'Segment');
+    if (!mainSegment || mainSegment.type !== 'Segment') {
         return null;
     }
-    const tracksSegment = mainSegment.children.find((b) => b.type === 'tracks-segment');
-    if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
+    const tracksSegment = mainSegment.value.find((b) => b.type === 'Tracks');
+    if (!tracksSegment || tracksSegment.type !== 'Tracks') {
         return null;
     }
-    for (const track of tracksSegment.children) {
-        if (track.type === 'track-entry-segment') {
-            const trackType = track.children.find((b) => b.type === 'codec-segment');
-            if (trackType && trackType.type === 'codec-segment') {
-                if (trackType.codec === 'V_VP8') {
+    for (const track of tracksSegment.value) {
+        if (track.type === 'TrackEntry') {
+            const trackType = track.value.find((b) => b.type === 'CodecID');
+            if (trackType && trackType.type === 'CodecID') {
+                if (trackType.value === 'V_VP8') {
                     return 'vp8';
                 }
-                if (trackType.codec === 'V_VP9') {
+                if (trackType.value === 'V_VP9') {
                     return 'vp9';
                 }
-                if (trackType.codec === 'V_AV1') {
+                if (trackType.value === 'V_AV1') {
                     return 'av1';
                 }
-                if (trackType.codec === 'V_MPEG4/ISO/AVC') {
+                if (trackType.value === 'V_MPEG4/ISO/AVC') {
                     return 'h264';
                 }
-                if (trackType.codec === 'V_MPEGH/ISO/HEVC') {
+                if (trackType.value === 'V_MPEGH/ISO/HEVC') {
                     return 'h265';
                 }
             }

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,23 +12,30 @@ 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,
         onVideoTrack: onVideoTrack !== null && onVideoTrack !== void 0 ? onVideoTrack : null,
         parserState: state,
+        nullifySamples: !(typeof process !== 'undefined' &&
+            typeof process.env !== 'undefined' &&
+            process.env.KEEP_SAMPLES === 'true'),
     };
     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) {
@@ -39,7 +46,7 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
             if (result.done) {
                 throw new Error('Unexpectedly reached EOF');
             }
-            iterator = (0, buffer_iterator_1.getArrayBufferIterator)(result.value, contentLength !== null && contentLength !== void 0 ? contentLength : undefined);
+            iterator = (0, buffer_iterator_1.getArrayBufferIterator)(result.value, contentLength !== null && contentLength !== void 0 ? contentLength : 1000000000);
         }
         if (parseResult && parseResult.status === 'incomplete') {
             parseResult = await parseResult.continueParsing();
@@ -66,7 +73,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 +88,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-context.d.ts

@@ -5,4 +5,5 @@ export type ParserContext = {
     onVideoTrack: OnVideoTrack | null;
     canSkipVideoData: boolean;
     parserState: ParserState;
+    nullifySamples: boolean;
 };

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,9 +3,10 @@ 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) => {
+        var _a;
         const trackId = (0, traversal_2.getTrackId)(trackEntry);
         if (!trackId) {
             throw new Error('Expected track id');
@@ -17,7 +18,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.value,
+            trackTimescale: (_a = trackTimescale === null || trackTimescale === void 0 ? void 0 : trackTimescale.value) !== null && _a !== void 0 ? _a : null,
+        };
     };
     const videoSampleCallbacks = {};
     const audioSampleCallbacks = {};
@@ -26,8 +31,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 +92,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 +109,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/readers/from-fetch.d.ts

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

package/dist/readers/from-fetch.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchReader = void 0;
+exports.fetchReader = {
+    read: async (src, range, signal) => {
+        if (typeof src !== 'string') {
+            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()
+            : src;
+        if (!resolvedUrl.startsWith('https://') &&
+            !resolvedUrl.startsWith('http://')) {
+            return Promise.reject(new Error(resolvedUrl +
+                ' is not a URL - needs to start with http:// or https://. If you want to read a local file, pass `nodeReader` to parseMedia().'));
+        }
+        const res = await fetch(resolvedUrl, {
+            headers: range === null
+                ? {}
+                : typeof range === 'number'
+                    ? {
+                        Range: `bytes=${range}`,
+                    }
+                    : {
+                        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 `fetchReader`');
+        }
+        const res = await fetch(src, {
+            method: 'HEAD',
+        });
+        if (!res.body) {
+            throw new Error('No body');
+        }
+        const length = res.headers.get('content-length');
+        if (!length) {
+            throw new Error('No content-length');
+        }
+        return parseInt(length, 10);
+    },
+};

package/dist/readers/from-node.d.ts

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

package/dist/readers/from-node.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeReader = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("node:fs/promises");
+const stream_1 = require("stream");
+exports.nodeReader = {
+    read: async (src, range, signal) => {
+        if (typeof src !== 'string') {
+            throw new Error('src must be a string when using `nodeReader`');
+        }
+        const stream = (0, fs_1.createReadStream)(src, {
+            start: range === null ? 0 : typeof range === 'number' ? range : range[0],
+            end: range === null
+                ? Infinity
+                : 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,
+            contentLength: stats.size,
+        };
+    },
+    getLength: async (src) => {
+        if (typeof src !== 'string') {
+            throw new Error('src must be a string when using `nodeReader`');
+        }
+        const stats = await (0, promises_1.stat)(src);
+        return stats.size;
+    },
+};

package/dist/readers/from-web-file.d.ts

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

package/dist/readers/from-web-file.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webFileReader = void 0;
+exports.webFileReader = {
+    read: (file, range, signal) => {
+        if (typeof file === 'string') {
+            throw new Error('`inputTypeFileReader` only supports `File` objects');
+        }
+        const part = range === null
+            ? file
+            : typeof range === 'number'
+                ? file.slice(range)
+                : 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({
+                    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/readers/reader.d.ts

@@ -0,0 +1,11 @@
+type ReadResult = {
+    reader: ReadableStreamDefaultReader<Uint8Array>;
+    contentLength: number | null;
+};
+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;
+    getLength: GetLength;
+};
+export {};

package/dist/readers/reader.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/traversal.d.ts

@@ -11,9 +11,7 @@ import type { StszBox } from './boxes/iso-base-media/stsd/stsz';
 import type { SttsBox } from './boxes/iso-base-media/stsd/stts';
 import type { TkhdBox } from './boxes/iso-base-media/tkhd';
 import type { TrakBox } from './boxes/iso-base-media/trak/trak';
-import type { MainSegment } from './boxes/webm/segments/main';
-import type { TimestampScaleSegment } from './boxes/webm/segments/timestamp-scale';
-import type { AudioSegment, ClusterSegment, CodecSegment, DisplayHeightSegment, DisplayWidthSegment, HeightSegment, TrackEntrySegment, TrackTypeSegment, VideoSegment, WidthSegment } from './boxes/webm/segments/track-entry';
+import type { AudioSegment, ClusterSegment, CodecIdSegment, DisplayHeightSegment, DisplayWidthSegment, HeightSegment, MainSegment, TimestampScaleSegment, TrackEntry, TrackTypeSegment, VideoSegment, WidthSegment } from './boxes/webm/segments/all-segments';
 import type { AnySegment, RegularBox } from './parse-result';
 export declare const getFtypBox: (segments: AnySegment[]) => FtypBox | null;
 export declare const getMoovBox: (segments: AnySegment[]) => MoovBox | null;
@@ -32,21 +30,25 @@ export declare const getStszBox: (trakBox: TrakBox) => StszBox | null;
 export declare const getStscBox: (trakBox: TrakBox) => StscBox | null;
 export declare const getStssBox: (trakBox: TrakBox) => StssBox | null;
 export declare const getClusterSegment: (segment: MainSegment) => ClusterSegment | null;
-export declare const getTracksSegment: (segment: MainSegment) => import("./boxes/webm/segments/tracks").TracksSegment | null;
+export declare const getTracksSegment: (segment: MainSegment) => {
+    type: "Tracks";
+    value: import("./boxes/webm/segments/all-segments").PossibleEbml[];
+    minVintWidth: number;
+} | null;
 export declare const getTimescaleSegment: (segment: MainSegment) => TimestampScaleSegment | null;
-export declare const getVideoSegment: (track: TrackEntrySegment) => VideoSegment | null;
-export declare const getAudioSegment: (track: TrackEntrySegment) => AudioSegment | null;
-export declare const getSampleRate: (track: TrackEntrySegment) => number | null;
-export declare const getNumberOfChannels: (track: TrackEntrySegment) => number;
-export declare const getBitDepth: (track: TrackEntrySegment) => number | null;
-export declare const getPrivateData: (track: TrackEntrySegment) => Uint8Array | null;
-export declare const getWidthSegment: (track: TrackEntrySegment) => WidthSegment | null;
-export declare const getHeightSegment: (track: TrackEntrySegment) => HeightSegment | null;
-export declare const getDisplayWidthSegment: (track: TrackEntrySegment) => DisplayWidthSegment | null;
-export declare const getDisplayHeightSegment: (track: TrackEntrySegment) => DisplayHeightSegment | null;
-export declare const getTrackTypeSegment: (track: TrackEntrySegment) => TrackTypeSegment | null;
-export declare const getTrackId: (track: TrackEntrySegment) => number;
-export declare const getCodecSegment: (track: TrackEntrySegment) => CodecSegment | null;
+export declare const getVideoSegment: (track: TrackEntry) => VideoSegment | null;
+export declare const getAudioSegment: (track: TrackEntry) => AudioSegment | null;
+export declare const getSampleRate: (track: TrackEntry) => number | null;
+export declare const getNumberOfChannels: (track: TrackEntry) => number;
+export declare const getBitDepth: (track: TrackEntry) => number | null;
+export declare const getPrivateData: (track: TrackEntry) => Uint8Array | null;
+export declare const getWidthSegment: (track: TrackEntry) => WidthSegment | null;
+export declare const getHeightSegment: (track: TrackEntry) => HeightSegment | null;
+export declare const getDisplayWidthSegment: (track: TrackEntry) => DisplayWidthSegment | null;
+export declare const getDisplayHeightSegment: (track: TrackEntry) => DisplayHeightSegment | null;
+export declare const getTrackTypeSegment: (track: TrackEntry) => TrackTypeSegment | null;
+export declare const getTrackId: (track: TrackEntry) => number;
+export declare const getCodecSegment: (track: TrackEntry) => CodecIdSegment | null;
 export declare const hasSkippedMdatProcessing: (anySegment: AnySegment[]) => {
     skipped: false;
     fileOffset?: undefined;