@remotion/media-parser 4.0.192 → 4.0.194

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStsc = void 0;
+const parseStsc = ({ iterator, offset, size, }) => {
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported STSD version ${version}`);
+    }
+    const flags = iterator.getSlice(3);
+    const entryCount = iterator.getUint32();
+    const entries = [];
+    for (let i = 0; i < entryCount; i++) {
+        const firstChunk = iterator.getUint32();
+        const samplesPerChunk = iterator.getUint32();
+        const sampleDescriptionIndex = iterator.getUint32();
+        if (sampleDescriptionIndex !== 1) {
+            throw new Error(`Expected sampleDescriptionIndex to be 1, but got ${sampleDescriptionIndex}`);
+        }
+        entries.push({
+            firstChunk,
+            samplesPerChunk,
+        });
+    }
+    return {
+        type: 'stsc-box',
+        boxSize: size,
+        offset,
+        version,
+        flags: [...flags],
+        entryCount,
+        entries,
+    };
+};
+exports.parseStsc = parseStsc;

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

@@ -0,0 +1,15 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { BaseBox } from '../base-type';
+export type StszBox = BaseBox & {
+    type: 'stsz-box';
+    version: number;
+    flags: number[];
+    sampleSize: number;
+    sampleCount: number;
+    samples: number[];
+};
+export declare const parseStsz: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+}) => StszBox;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStsz = void 0;
+const parseStsz = ({ iterator, offset, size, }) => {
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported STSD version ${version}`);
+    }
+    const flags = iterator.getSlice(3);
+    const sampleSize = iterator.getUint32();
+    const sampleCount = iterator.getUint32();
+    const samples = [];
+    for (let i = 0; i < sampleCount; i++) {
+        const bytesRemaining = size - (iterator.counter.getOffset() - offset);
+        if (bytesRemaining < 4) {
+            break;
+        }
+        samples.push(iterator.getUint32());
+    }
+    iterator.discard(size - (iterator.counter.getOffset() - offset));
+    return {
+        type: 'stsz-box',
+        boxSize: size,
+        offset,
+        version,
+        flags: [...flags],
+        sampleSize,
+        sampleCount,
+        samples,
+    };
+};
+exports.parseStsz = parseStsz;

package/dist/boxes/webm/parse-webm-header.js

@@ -6,11 +6,11 @@ const segments_1 = require("./segments");
 const parseWebm = (counter) => {
     counter.discard(4);
     const length = counter.getVint();
-    if (length !== 31) {
-        throw new Error(`Expected header length 31, got ${length}`);
+    if (length !== 31 && length !== 35) {
+        throw new Error(`Expected header length 31 or 25, got ${length}`);
     }
     // Discard header for now
-    counter.discard(31);
+    counter.discard(length);
     return { status: 'done', segments: [(0, segments_1.expectSegment)(counter)] };
 };
 exports.parseWebm = parseWebm;

package/dist/boxes/webm/segments/track-entry.d.ts

@@ -79,3 +79,23 @@ export type InterlacedSegment = {
     interlaced: boolean;
 };
 export declare const parseInterlacedSegment: (iterator: BufferIterator) => InterlacedSegment;
+export type CodecPrivateSegment = {
+    type: 'codec-private-segment';
+    codecPrivateData: number[];
+};
+export declare const parseCodecPrivateSegment: (iterator: BufferIterator) => CodecPrivateSegment;
+export type Crc32Segment = {
+    type: 'crc32-segment';
+    crc32: number[];
+};
+export declare const parseCrc32Segment: (iterator: BufferIterator) => Crc32Segment;
+export type SegmentUUIDSegment = {
+    type: 'segment-uuid-segment';
+    segmentUUID: string;
+};
+export declare const parseSegmentUUIDSegment: (iterator: BufferIterator) => SegmentUUIDSegment;
+export type DefaultFlagSegment = {
+    type: 'default-flag-segment';
+    defaultFlag: boolean;
+};
+export declare const parseDefaultFlagSegment: (iterator: BufferIterator) => DefaultFlagSegment;

package/dist/boxes/webm/segments/track-entry.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseInterlacedSegment = exports.parseTitleSegment = exports.parseColorSegment = exports.parseMaxBlockAdditionId = exports.parseAlphaModeSegment = exports.parseHeightSegment = exports.parseWidthSegment = exports.parseVideoSegment = exports.parseDefaultDurationSegment = exports.parseTrackTypeSegment = exports.parseCodecSegment = exports.parseLanguageSegment = exports.parseFlagLacing = exports.parseTrackUID = exports.parseTrackNumber = exports.parseTrackEntry = void 0;
+exports.parseDefaultFlagSegment = exports.parseSegmentUUIDSegment = exports.parseCrc32Segment = exports.parseCodecPrivateSegment = exports.parseInterlacedSegment = exports.parseTitleSegment = exports.parseColorSegment = exports.parseMaxBlockAdditionId = exports.parseAlphaModeSegment = exports.parseHeightSegment = exports.parseWidthSegment = exports.parseVideoSegment = exports.parseDefaultDurationSegment = exports.parseTrackTypeSegment = exports.parseCodecSegment = exports.parseLanguageSegment = exports.parseFlagLacing = exports.parseTrackUID = exports.parseTrackNumber = exports.parseTrackEntry = void 0;
 const parse_children_1 = require("./parse-children");
 const parseTrackEntry = (iterator) => {
     const offset = iterator.counter.getOffset();
@@ -162,7 +162,7 @@ const parseMaxBlockAdditionId = (iterator) => {
 exports.parseMaxBlockAdditionId = parseMaxBlockAdditionId;
 const parseColorSegment = (iterator) => {
     const length = iterator.getVint();
-    iterator.discard(length - 1);
+    iterator.discard(length);
     return {
         type: 'color-segment',
     };
@@ -189,3 +189,38 @@ const parseInterlacedSegment = (iterator) => {
     };
 };
 exports.parseInterlacedSegment = parseInterlacedSegment;
+const parseCodecPrivateSegment = (iterator) => {
+    const length = iterator.getVint();
+    return {
+        type: 'codec-private-segment',
+        codecPrivateData: [...iterator.getSlice(length)],
+    };
+};
+exports.parseCodecPrivateSegment = parseCodecPrivateSegment;
+const parseCrc32Segment = (iterator) => {
+    const length = iterator.getVint();
+    return {
+        type: 'crc32-segment',
+        crc32: [...iterator.getSlice(length)],
+    };
+};
+exports.parseCrc32Segment = parseCrc32Segment;
+const parseSegmentUUIDSegment = (iterator) => {
+    const length = iterator.getVint();
+    return {
+        type: 'segment-uuid-segment',
+        segmentUUID: iterator.getSlice(length).toString(),
+    };
+};
+exports.parseSegmentUUIDSegment = parseSegmentUUIDSegment;
+const parseDefaultFlagSegment = (iterator) => {
+    const length = iterator.getVint();
+    if (length !== 1) {
+        throw new Error('Expected default flag segment to be 1 byte');
+    }
+    return {
+        type: 'default-flag-segment',
+        defaultFlag: Boolean(iterator.getUint8()),
+    };
+};
+exports.parseDefaultFlagSegment = parseDefaultFlagSegment;

package/dist/boxes/webm/segments.d.ts

@@ -7,10 +7,10 @@ import { type SeekSegment } from './segments/seek';
 import type { SeekHeadSegment } from './segments/seek-head';
 import { type SeekPositionSegment } from './segments/seek-position';
 import type { TimestampScaleSegment } from './segments/timestamp-scale';
-import type { AlphaModeSegment, CodecSegment, ColorSegment, DefaultDurationSegment, FlagLacingSegment, HeightSegment, InterlacedSegment, LanguageSegment, MaxBlockAdditionId, TitleSegment, TrackEntrySegment, TrackNumberSegment, TrackTypeSegment, TrackUIDSegment, VideoSegment, WidthSegment } from './segments/track-entry';
+import type { AlphaModeSegment, CodecPrivateSegment, CodecSegment, ColorSegment, Crc32Segment, DefaultDurationSegment, DefaultFlagSegment, FlagLacingSegment, HeightSegment, InterlacedSegment, LanguageSegment, MaxBlockAdditionId, SegmentUUIDSegment, TitleSegment, TrackEntrySegment, TrackNumberSegment, TrackTypeSegment, TrackUIDSegment, VideoSegment, WidthSegment } from './segments/track-entry';
 import type { TracksSegment } from './segments/tracks';
 import type { UnknownSegment } from './segments/unknown';
 import type { VoidSegment } from './segments/void';
 import type { WritingAppSegment } from './segments/writing';
-export type MatroskaSegment = MainSegment | UnknownSegment | SeekHeadSegment | SeekSegment | SeekPositionSegment | VoidSegment | InfoSegment | TimestampScaleSegment | MuxingAppSegment | WritingAppSegment | DurationSegment | TracksSegment | TrackEntrySegment | TrackNumberSegment | TrackUIDSegment | FlagLacingSegment | LanguageSegment | CodecSegment | TrackTypeSegment | DefaultDurationSegment | VideoSegment | WidthSegment | HeightSegment | AlphaModeSegment | MaxBlockAdditionId | ColorSegment | TitleSegment | InterlacedSegment;
+export type MatroskaSegment = MainSegment | UnknownSegment | SeekHeadSegment | SeekSegment | SeekPositionSegment | VoidSegment | InfoSegment | TimestampScaleSegment | MuxingAppSegment | WritingAppSegment | DurationSegment | TracksSegment | TrackEntrySegment | TrackNumberSegment | TrackUIDSegment | FlagLacingSegment | LanguageSegment | CodecSegment | TrackTypeSegment | DefaultDurationSegment | VideoSegment | WidthSegment | HeightSegment | AlphaModeSegment | MaxBlockAdditionId | ColorSegment | TitleSegment | InterlacedSegment | CodecPrivateSegment | Crc32Segment | SegmentUUIDSegment | DefaultFlagSegment;
 export declare const expectSegment: (iterator: BufferIterator) => MatroskaSegment;

package/dist/boxes/webm/segments.js

@@ -100,9 +100,21 @@ const expectSegment = (iterator) => {
     if (segmentId === '0x53c0') {
         return (0, track_entry_1.parseAlphaModeSegment)(iterator);
     }
+    if (segmentId === '0x63a2') {
+        return (0, track_entry_1.parseCodecPrivateSegment)(iterator);
+    }
     if (segmentId === '0x7ba9') {
         return (0, track_entry_1.parseTitleSegment)(iterator);
     }
+    if (segmentId === '0xbf') {
+        return (0, track_entry_1.parseCrc32Segment)(iterator);
+    }
+    if (segmentId === '0x73a4') {
+        return (0, track_entry_1.parseSegmentUUIDSegment)(iterator);
+    }
+    if (segmentId === '0x88') {
+        return (0, track_entry_1.parseDefaultFlagSegment)(iterator);
+    }
     const length = iterator.getVint();
     const bytesRemaining = iterator.byteLength() - iterator.counter.getOffset();
     const toDiscard = Math.min(bytesRemaining, length > 0 ? length : bytesRemaining);

package/dist/buffer-iterator.d.ts

@@ -7,7 +7,8 @@ export declare class OffsetCounter {
     discardBytes(amount: number): void;
     decrement(amount: number): void;
 }
-export declare const getArrayBufferIterator: (initialData: Uint8Array) => {
+export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes?: number) => {
+    skipTo: (offset: number) => void;
     addData: (newData: Uint8Array) => void;
     counter: OffsetCounter;
     byteLength: () => number;
@@ -19,6 +20,7 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array) => {
     getFourByteNumber: () => number;
     getSlice: (amount: number) => Uint8Array;
     getAtom: () => string;
+    getPaddedFourByteNumber: () => number;
     getMatroskaSegmentId: () => string;
     getVint: () => number;
     getUint8: () => number;

package/dist/buffer-iterator.js

@@ -54,8 +54,15 @@ const matchesPattern = (pattern) => {
 const makeOffsetCounter = () => {
     return new OffsetCounter(0);
 };
-const getArrayBufferIterator = (initialData) => {
-    let data = initialData;
+const getArrayBufferIterator = (initialData, maxBytes) => {
+    const buf = new ArrayBuffer(initialData.byteLength, {
+        maxByteLength: maxBytes !== null && maxBytes !== void 0 ? maxBytes : 1000000000,
+    });
+    if (!buf.resize) {
+        throw new Error('`ArrayBuffer.resize` is not supported in this Runtime. Use at least Node.js 20 or Bun.');
+    }
+    let data = new Uint8Array(buf);
+    data.set(initialData);
     let view = new DataView(data.buffer);
     const counter = makeOffsetCounter();
     const getSlice = (amount) => {
@@ -71,15 +78,24 @@ const getArrayBufferIterator = (initialData) => {
     const getFourByteNumber = () => {
         return ((getUint8() << 24) | (getUint8() << 16) | (getUint8() << 8) | getUint8());
     };
+    const getPaddedFourByteNumber = () => {
+        let lastInt = 128;
+        while (((lastInt = getUint8()), lastInt === 128)) {
+            // Do nothing
+        }
+        return lastInt;
+    };
     const getUint32 = () => {
         const val = view.getUint32(counter.getDiscardedOffset());
         counter.increment(4);
         return val;
     };
     const addData = (newData) => {
-        const newArray = new Uint8Array(data.buffer.byteLength + newData.byteLength);
-        newArray.set(data);
-        newArray.set(new Uint8Array(newData), data.byteLength);
+        const oldLength = buf.byteLength;
+        const newLength = oldLength + newData.byteLength;
+        buf.resize(newLength);
+        const newArray = new Uint8Array(buf);
+        newArray.set(newData, oldLength);
         data = newArray;
         view = new DataView(data.buffer);
     };
@@ -97,13 +113,24 @@ const getArrayBufferIterator = (initialData) => {
     };
     const removeBytesRead = () => {
         const bytesToRemove = counter.getDiscardedOffset();
+        // Only to this operation if it is really worth it 😇
+        if (bytesToRemove < 100000) {
+            return;
+        }
         counter.discardBytes(bytesToRemove);
-        const newArray = new Uint8Array(data.buffer.byteLength - bytesToRemove);
-        newArray.set(data.slice(bytesToRemove));
-        data = newArray;
+        const newData = data.slice(bytesToRemove);
+        data.set(newData);
+        buf.resize(newData.byteLength);
         view = new DataView(data.buffer);
     };
+    const skipTo = (offset) => {
+        buf.resize(offset);
+        const currentOffset = counter.getOffset();
+        counter.increment(offset - currentOffset);
+        removeBytesRead();
+    };
     return {
+        skipTo,
         addData,
         counter,
         byteLength,
@@ -120,6 +147,7 @@ const getArrayBufferIterator = (initialData) => {
             const atom = getSlice(4);
             return new TextDecoder().decode(atom);
         },
+        getPaddedFourByteNumber,
         getMatroskaSegmentId: () => {
             const first = getSlice(1);
             const firstOneString = `0x${Array.from(new Uint8Array(first))
@@ -140,6 +168,9 @@ const getArrayBufferIterator = (initialData) => {
                 '0xb0',
                 '0xba',
                 '0x9a',
+                '0xe1',
+                '0xbf',
+                '0x88',
             ];
             if (knownIdsWithOneLength.includes(firstOneString)) {
                 return firstOneString;
@@ -157,6 +188,8 @@ const getArrayBufferIterator = (initialData) => {
                 '0x55ee',
                 '0x55b0',
                 '0x7ba9',
+                '0x63a2',
+                '0x73a4',
             ];
             const firstTwoString = `${firstOneString}${Array.from(new Uint8Array(firstTwo))
                 .map((b) => {

package/dist/from-node.js

@@ -5,12 +5,20 @@ const fs_1 = require("fs");
 const promises_1 = require("node:fs/promises");
 const stream_1 = require("stream");
 exports.nodeReader = {
-    read: (src, range) => {
+    read: async (src, range) => {
         const stream = (0, fs_1.createReadStream)(src, {
-            start: range === null ? 0 : range[0],
-            end: range === null ? Infinity : range[1],
+            start: range === null ? 0 : typeof range === 'number' ? range : range[0],
+            end: range === null
+                ? Infinity
+                : typeof range === 'number'
+                    ? Infinity
+                    : range[1],
         });
-        return Promise.resolve(stream_1.Readable.toWeb(stream).getReader());
+        const stats = await (0, promises_1.stat)(src);
+        return {
+            reader: stream_1.Readable.toWeb(stream).getReader(),
+            contentLength: stats.size,
+        };
     },
     getLength: async (src) => {
         const stats = await (0, promises_1.stat)(src);

package/dist/from-web.js

@@ -14,15 +14,23 @@ 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');
+        const contentLength = length === null ? null : parseInt(length, 10);
         const reader = res.body.getReader();
-        return reader;
+        return { reader, contentLength };
     },
     getLength: async (src) => {
         const res = await fetch(src, {

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

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

package/dist/get-audio-codec.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAudioCodec = exports.hasAudioCodec = void 0;
+const get_fps_1 = require("./get-fps");
+const hasAudioCodec = (boxes) => {
+    try {
+        return (0, exports.getAudioCodec)(boxes) !== null;
+    }
+    catch (e) {
+        return false;
+    }
+};
+exports.hasAudioCodec = hasAudioCodec;
+const onEsdsBox = (child) => {
+    if (child && child.type === 'esds-box') {
+        const descriptor = child.descriptors.find((d) => d.type === 'decoder-config-descriptor');
+        if (descriptor && descriptor.type === 'decoder-config-descriptor') {
+            return descriptor.objectTypeIndication;
+        }
+    }
+    return null;
+};
+const onSample = (sample) => {
+    if (!sample) {
+        return null;
+    }
+    if (sample.type !== 'audio') {
+        return null;
+    }
+    if (sample.format === 'sowt') {
+        return 'aiff';
+    }
+    const child = sample.children.find((c) => c.type === 'esds-box');
+    if (child && child.type === 'esds-box') {
+        const ret = onEsdsBox(child);
+        if (ret) {
+            return ret;
+        }
+    }
+};
+const getAudioCodec = (boxes) => {
+    const moovBox = boxes.find((b) => b.type === 'moov-box');
+    if (moovBox && moovBox.type === 'moov-box') {
+        const trakBox = moovBox.children.find((b) => b.type === 'trak-box' && (0, get_fps_1.trakBoxContainsAudio)(b));
+        if (trakBox && trakBox.type === 'trak-box') {
+            const mdiaBox = trakBox.children.find((b) => b.type === 'regular-box' && b.boxType === 'mdia');
+            if (mdiaBox &&
+                mdiaBox.type === 'regular-box' &&
+                mdiaBox.boxType === 'mdia') {
+                const minfBox = mdiaBox === null || mdiaBox === void 0 ? void 0 : mdiaBox.children.find((b) => b.type === 'regular-box' && b.boxType === 'minf');
+                if (minfBox &&
+                    minfBox.type === 'regular-box' &&
+                    minfBox.boxType === 'minf') {
+                    const stblBox = minfBox === null || minfBox === void 0 ? void 0 : minfBox.children.find((b) => b.type === 'regular-box' && b.boxType === 'stbl');
+                    if (stblBox && stblBox.type === 'regular-box') {
+                        const stsdBox = stblBox === null || stblBox === void 0 ? void 0 : stblBox.children.find((b) => b.type === 'stsd-box');
+                        if (stsdBox && stsdBox.type === 'stsd-box') {
+                            const sample = stsdBox.samples.find((s) => s.type === 'audio');
+                            if (sample && sample.type === 'audio') {
+                                const ret = onSample(sample);
+                                if (ret) {
+                                    return ret;
+                                }
+                                const waveBox = sample.children.find((b) => b.type === 'regular-box' && b.boxType === 'wave');
+                                if (waveBox &&
+                                    waveBox.type === 'regular-box' &&
+                                    waveBox.boxType === 'wave') {
+                                    const esdsBox = waveBox.children.find((b) => b.type === 'esds-box');
+                                    if (esdsBox && esdsBox.type === 'esds-box') {
+                                        const ret2 = onEsdsBox(esdsBox);
+                                        if (ret2) {
+                                            return ret2;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    const mainSegment = boxes.find((b) => b.type === 'main-segment');
+    if (!mainSegment || mainSegment.type !== 'main-segment') {
+        return null;
+    }
+    const tracksSegment = mainSegment.children.find((b) => b.type === 'tracks-segment');
+    if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
+        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 === 'A_OPUS') {
+                    return 'opus';
+                }
+                if (trackType.codec === 'A_PCM/INT/LIT') {
+                    return 'pcm';
+                }
+            }
+        }
+    }
+    return null;
+};
+exports.getAudioCodec = getAudioCodec;

package/dist/get-dimensions.js

@@ -6,8 +6,12 @@ const getDimensionsFromMatroska = (segments) => {
     if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
         throw new Error('No tracks segment');
     }
-    // TODO: What if there are multiple video tracks, or audio track is first?
-    const trackEntrySegment = tracksSegment.children.find((b) => b.type === 'track-entry-segment');
+    const trackEntrySegment = tracksSegment.children.find((b) => {
+        if (b.type !== 'track-entry-segment') {
+            return false;
+        }
+        return (b.children.find((c) => c.type === 'codec-segment' && c.codec.startsWith('V_')) !== undefined);
+    });
     if (!trackEntrySegment || trackEntrySegment.type !== 'track-entry-segment') {
         throw new Error('No track entry segment');
     }

package/dist/get-fps.d.ts

@@ -3,6 +3,7 @@ type TimescaleAndDuration = {
     timescale: number;
     duration: number;
 };
+export declare const trakBoxContainsAudio: (trakBox: AnySegment) => boolean;
 export declare const trakBoxContainsVideo: (trakBox: AnySegment) => boolean;
 export declare const getTimescaleAndDuration: (boxes: AnySegment[]) => TimescaleAndDuration | null;
 export declare const getFps: (segments: AnySegment[]) => number | null;

package/dist/get-fps.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasFps = exports.getFps = exports.getTimescaleAndDuration = exports.trakBoxContainsVideo = void 0;
+exports.hasFps = exports.getFps = exports.getTimescaleAndDuration = exports.trakBoxContainsVideo = exports.trakBoxContainsAudio = void 0;
 const calculateFps = ({ sttsBox, timeScale, durationInSamples, }) => {
     let totalSamples = 0;
     for (const sample of sttsBox.sampleDistribution) {
@@ -10,6 +10,39 @@ const calculateFps = ({ sttsBox, timeScale, durationInSamples, }) => {
     const fps = totalSamples / durationInSeconds;
     return fps;
 };
+const trakBoxContainsAudio = (trakBox) => {
+    if (trakBox.type !== 'trak-box') {
+        return false;
+    }
+    const { children } = trakBox;
+    const mediaBoxes = children.filter((c) => c.type === 'regular-box' && c.boxType === 'mdia');
+    if (!mediaBoxes || mediaBoxes.length === 0) {
+        return false;
+    }
+    const firstMediaBox = mediaBoxes[0];
+    if (firstMediaBox.type !== 'regular-box' ||
+        firstMediaBox.boxType !== 'mdia') {
+        return false;
+    }
+    const minf = firstMediaBox.children.find((c) => c.type === 'regular-box' && c.boxType === 'minf');
+    if (!minf || minf.type !== 'regular-box' || minf.boxType !== 'minf') {
+        return false;
+    }
+    const stbl = minf.children.find((c) => c.type === 'regular-box' && c.boxType === 'stbl');
+    if (!stbl || stbl.type !== 'regular-box' || stbl.boxType !== 'stbl') {
+        return false;
+    }
+    const stsd = stbl.children.find((c) => c.type === 'stsd-box');
+    if (!stsd || stsd.type !== 'stsd-box') {
+        return false;
+    }
+    const videoSample = stsd.samples.find((s) => s.type === 'audio');
+    if (!videoSample || videoSample.type !== 'audio') {
+        return false;
+    }
+    return true;
+};
+exports.trakBoxContainsAudio = trakBoxContainsAudio;
 const trakBoxContainsVideo = (trakBox) => {
     if (trakBox.type !== 'trak-box') {
         return false;

package/dist/get-sample-positions.d.ts

@@ -0,0 +1,12 @@
+import type { StcoBox } from './boxes/iso-base-media/stsd/stco';
+import type { StscBox } from './boxes/iso-base-media/stsd/stsc';
+import type { StszBox } from './boxes/iso-base-media/stsd/stsz';
+export type SamplePosition = {
+    offset: number;
+    size: number;
+};
+export declare const getSamplePositions: ({ stcoBox, stszBox, stscBox, }: {
+    stcoBox: StcoBox;
+    stszBox: StszBox;
+    stscBox: StscBox;
+}) => SamplePosition[];

package/dist/get-sample-positions.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSamplePositions = void 0;
+const getSamplePositions = ({ stcoBox, stszBox, stscBox, }) => {
+    const chunks = stcoBox.entries;
+    const samples = [];
+    let samplesPerChunk = 1;
+    for (let i = 0; i < chunks.length; i++) {
+        const hasEntry = stscBox.entries.find((entry) => entry.firstChunk === i + 1);
+        if (hasEntry) {
+            samplesPerChunk = hasEntry.samplesPerChunk;
+        }
+        let offsetInThisChunk = 0;
+        for (let j = 0; j < samplesPerChunk; j++) {
+            const size = stszBox.samples[samples.length];
+            samples.push({
+                offset: chunks[i] + offsetInThisChunk,
+                size,
+            });
+            offsetInThisChunk += size;
+        }
+    }
+    return samples;
+};
+exports.getSamplePositions = getSamplePositions;

package/dist/get-samples.js

@@ -0,0 +1 @@
+"use strict";

package/dist/get-tracks.d.ts

@@ -0,0 +1,10 @@
+import type { SamplePosition } from './get-sample-positions';
+import type { AnySegment } from './parse-result';
+type Track = {
+    type: 'audio' | 'video';
+    samplePositions: SamplePosition[];
+    trackId: number;
+};
+export declare const getNumberOfTracks: (segments: AnySegment[]) => number;
+export declare const getTracks: (segments: AnySegment[]) => Track[];
+export {};