@remotion/media-parser 4.0.193 → 4.0.195

package/dist/get-dimensions.d.ts

@@ -1,7 +1,13 @@
 import type { AnySegment } from './parse-result';
+import type { ParserState } from './parser-state';
 export type Dimensions = {
     width: number;
     height: number;
 };
-export declare const getDimensions: (boxes: AnySegment[]) => Dimensions;
-export declare const hasDimensions: (boxes: AnySegment[]) => boolean;
+export type ExpandedDimensions = Dimensions & {
+    rotation: number;
+    unrotatedWidth: number;
+    unrotatedHeight: number;
+};
+export declare const getDimensions: (boxes: AnySegment[], state: ParserState) => ExpandedDimensions;
+export declare const hasDimensions: (boxes: AnySegment[], state: ParserState) => boolean;

package/dist/get-dimensions.js

@@ -1,105 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasDimensions = exports.getDimensions = void 0;
-const getDimensionsFromMatroska = (segments) => {
-    const tracksSegment = segments.children.find((b) => b.type === 'tracks-segment');
-    if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
-        throw new Error('No tracks 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');
-    }
-    const videoSegment = trackEntrySegment.children.find((b) => b.type === 'video-segment');
-    if (!videoSegment || videoSegment.type !== 'video-segment') {
-        throw new Error('No video segment');
-    }
-    const widthSegment = videoSegment.children.find((b) => b.type === 'width-segment');
-    if (!widthSegment || widthSegment.type !== 'width-segment') {
-        throw new Error('No width segment');
-    }
-    const heightSegment = videoSegment.children.find((b) => b.type === 'height-segment');
-    if (!heightSegment || heightSegment.type !== 'height-segment') {
-        throw new Error('No height segment');
+const get_tracks_1 = require("./get-tracks");
+const getDimensions = (boxes, state) => {
+    const { videoTracks } = (0, get_tracks_1.getTracks)(boxes, state);
+    if (!videoTracks.length) {
+        throw new Error('Expected video track');
     }
+    const firstVideoTrack = videoTracks[0];
     return {
-        width: widthSegment.width,
-        height: heightSegment.height,
+        width: firstVideoTrack.width,
+        height: firstVideoTrack.height,
+        rotation: firstVideoTrack.rotation,
+        unrotatedHeight: firstVideoTrack.displayAspectHeight,
+        unrotatedWidth: firstVideoTrack.displayAspectWidth,
     };
 };
-const getDimensions = (boxes) => {
-    const matroskaBox = boxes.find((b) => b.type === 'main-segment');
-    if (matroskaBox && matroskaBox.type === 'main-segment') {
-        return getDimensionsFromMatroska(matroskaBox);
-    }
-    const moovBox = boxes.find((b) => b.type === 'moov-box');
-    if (!moovBox || moovBox.type !== 'moov-box') {
-        throw new Error('Expected moov box');
-    }
-    const { children } = moovBox;
-    if (!children) {
-        throw new Error('Expected moov box children');
-    }
-    const t = children.find((b) => b.type === 'trak-box');
-    if (!t || t.type !== 'trak-box') {
-        throw new Error('Expected trak box');
-    }
-    const mdiaBox = t.children.find((c) => c.type === 'regular-box' && c.boxType === 'mdia');
-    const tkhdBox = t.children.find((c) => c.type === 'tkhd-box');
-    if (tkhdBox && tkhdBox.type === 'tkhd-box') {
-        return {
-            width: tkhdBox.width,
-            height: tkhdBox.height,
-        };
-    }
-    if (!mdiaBox) {
-        throw new Error('Expected mdia box');
-    }
-    if (mdiaBox.type !== 'regular-box') {
-        throw new Error('Expected mdia box');
-    }
-    const minfBox = mdiaBox.children.find((c) => c.type === 'regular-box' && c.boxType === 'minf');
-    if (!minfBox) {
-        throw new Error('Expected minf box');
-    }
-    if (minfBox.type !== 'regular-box') {
-        throw new Error('Expected minf box');
-    }
-    const stblBox = minfBox.children.find((c) => c.type === 'regular-box' && c.boxType === 'stbl');
-    if (!stblBox) {
-        throw new Error('Expected stbl box');
-    }
-    if (stblBox.type !== 'regular-box') {
-        throw new Error('Expected stbl box');
-    }
-    const stsdBox = stblBox.children.find((c) => c.type === 'stsd-box');
-    if (!stsdBox) {
-        throw new Error('Expected stsd box');
-    }
-    if (stsdBox.type !== 'stsd-box') {
-        throw new Error('Expected stsd box');
-    }
-    const videoSamples = stsdBox.samples.filter((s) => s.type === 'video');
-    if (videoSamples.length === 0) {
-        throw new Error('Has no video stream');
-    }
-    const [firstTrack] = videoSamples;
-    if (firstTrack.type !== 'video') {
-        throw new Error('Expected video track');
-    }
-    return { width: firstTrack.width, height: firstTrack.height };
-};
 exports.getDimensions = getDimensions;
 // TODO: An audio track should return 'hasDimensions' = true on an audio file
 // and stop parsing
-const hasDimensions = (boxes) => {
+const hasDimensions = (boxes, state) => {
     try {
-        return (0, exports.getDimensions)(boxes) !== null;
+        return (0, exports.getDimensions)(boxes, state) !== null;
     }
     catch (err) {
         return false;

package/dist/get-duration.js

@@ -1,6 +1,7 @@
 "use strict";
 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') {
@@ -32,15 +33,11 @@ const getDuration = (boxes) => {
     if (matroskaBox) {
         return getDurationFromMatroska(boxes);
     }
-    const moovBox = boxes.find((b) => b.type === 'moov-box');
-    if (!moovBox || moovBox.type !== 'moov-box') {
+    const moovBox = (0, traversal_1.getMoovBox)(boxes);
+    if (!moovBox) {
         return null;
     }
-    const { children } = moovBox;
-    if (!children) {
-        return null;
-    }
-    const mvhdBox = children.find((b) => b.type === 'mvhd-box');
+    const mvhdBox = (0, traversal_1.getMvhdBox)(moovBox);
     if (!mvhdBox) {
         return null;
     }

package/dist/get-fps.d.ts

@@ -1,11 +1,12 @@
+import type { TrakBox } from './boxes/iso-base-media/trak/trak';
 import type { AnySegment } from './parse-result';
 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 trakBoxContainsAudio: (trakBox: TrakBox) => boolean;
+export declare const trakBoxContainsVideo: (trakBox: TrakBox) => boolean;
+export declare const getTimescaleAndDuration: (trakBox: TrakBox) => TimescaleAndDuration | null;
 export declare const getFps: (segments: AnySegment[]) => number | null;
 export declare const hasFps: (boxes: AnySegment[]) => boolean;
 export {};

package/dist/get-fps.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasFps = exports.getFps = exports.getTimescaleAndDuration = exports.trakBoxContainsVideo = exports.trakBoxContainsAudio = void 0;
+const traversal_1 = require("./traversal");
 const calculateFps = ({ sttsBox, timeScale, durationInSamples, }) => {
     let totalSamples = 0;
     for (const sample of sttsBox.sampleDistribution) {
@@ -11,29 +12,8 @@ const calculateFps = ({ sttsBox, timeScale, durationInSamples, }) => {
     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') {
+    const stsd = (0, traversal_1.getStsdBox)(trakBox);
+    if (!stsd) {
         return false;
     }
     const videoSample = stsd.samples.find((s) => s.type === 'audio');
@@ -44,29 +24,8 @@ const trakBoxContainsAudio = (trakBox) => {
 };
 exports.trakBoxContainsAudio = trakBoxContainsAudio;
 const trakBoxContainsVideo = (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') {
+    const stsd = (0, traversal_1.getStsdBox)(trakBox);
+    if (!stsd) {
         return false;
     }
     const videoSample = stsd.samples.find((s) => s.type === 'video');
@@ -76,88 +35,30 @@ const trakBoxContainsVideo = (trakBox) => {
     return true;
 };
 exports.trakBoxContainsVideo = trakBoxContainsVideo;
-const getTimescaleAndDuration = (boxes) => {
-    const moovBox = boxes.find((s) => s.type === 'moov-box');
-    if (!moovBox || moovBox.type !== 'moov-box') {
-        return null;
-    }
-    const { children } = moovBox;
-    const trackBoxes = children.filter((c) => c.type === 'trak-box');
-    if (!trackBoxes || trackBoxes.length === 0) {
-        return null;
-    }
-    const trackBox = trackBoxes.find(exports.trakBoxContainsVideo);
-    if (!trackBox || trackBox.type !== 'trak-box') {
-        return null;
-    }
-    const trackBoxChildren = trackBox.children;
-    if (!trackBoxChildren || trackBoxChildren.length === 0) {
-        return null;
-    }
-    const mdiaBox = trackBoxChildren.find((c) => c.type === 'regular-box' && c.boxType === 'mdia');
-    if (!mdiaBox ||
-        mdiaBox.type !== 'regular-box' ||
-        mdiaBox.boxType !== 'mdia') {
-        return null;
-    }
-    const mdhdBox = mdiaBox === null || mdiaBox === void 0 ? void 0 : mdiaBox.children.find((c) => c.type === 'mdhd-box');
-    if (mdhdBox && mdhdBox.type === 'mdhd-box') {
+const getTimescaleAndDuration = (trakBox) => {
+    const mdhdBox = (0, traversal_1.getMdhdBox)(trakBox);
+    if (mdhdBox) {
         return { timescale: mdhdBox.timescale, duration: mdhdBox.duration };
     }
-    const mvhdBox = moovBox.children.find((c) => c.type === 'mvhd-box');
-    if (!mvhdBox || mvhdBox.type !== 'mvhd-box') {
-        return null;
-    }
-    const { timeScale, durationInUnits } = mvhdBox;
-    return { timescale: timeScale, duration: durationInUnits };
+    return null;
 };
 exports.getTimescaleAndDuration = getTimescaleAndDuration;
 const getFps = (segments) => {
-    const timescaleAndDuration = (0, exports.getTimescaleAndDuration)(segments);
-    if (!timescaleAndDuration) {
-        return null;
-    }
-    const moovBox = segments.find((s) => s.type === 'moov-box');
-    if (!moovBox || moovBox.type !== 'moov-box') {
-        return null;
-    }
-    const mvhdBox = moovBox.children.find((c) => c.type === 'mvhd-box');
-    if (!mvhdBox || mvhdBox.type !== 'mvhd-box') {
-        return null;
-    }
-    const { children } = moovBox;
-    const trackBoxes = children.filter((c) => c.type === 'trak-box');
-    if (!trackBoxes || trackBoxes.length === 0) {
+    const moovBox = (0, traversal_1.getMoovBox)(segments);
+    if (!moovBox) {
         return null;
     }
+    const trackBoxes = (0, traversal_1.getTraks)(moovBox);
     const trackBox = trackBoxes.find(exports.trakBoxContainsVideo);
-    if (!trackBox || trackBox.type !== 'trak-box') {
-        return null;
-    }
-    const trackBoxChildren = trackBox.children;
-    if (!trackBoxChildren || trackBoxChildren.length === 0) {
+    if (!trackBox) {
         return null;
     }
-    const mdiaBox = trackBoxChildren.find((c) => c.type === 'regular-box' && c.boxType === 'mdia');
-    if (!mdiaBox ||
-        mdiaBox.type !== 'regular-box' ||
-        mdiaBox.boxType !== 'mdia') {
-        return null;
-    }
-    const minfBox = mdiaBox.children.find((c) => c.type === 'regular-box' && c.boxType === 'minf');
-    if (!minfBox ||
-        minfBox.type !== 'regular-box' ||
-        minfBox.boxType !== 'minf') {
-        return null;
-    }
-    const stblBox = minfBox.children.find((c) => c.type === 'regular-box' && c.boxType === 'stbl');
-    if (!stblBox ||
-        stblBox.type !== 'regular-box' ||
-        stblBox.boxType !== 'stbl') {
+    const timescaleAndDuration = (0, exports.getTimescaleAndDuration)(trackBox);
+    if (!timescaleAndDuration) {
         return null;
     }
-    const sttsBox = stblBox.children.find((c) => c.type === 'stts-box');
-    if (!sttsBox || sttsBox.type !== 'stts-box') {
+    const sttsBox = (0, traversal_1.getSttsBox)(trackBox);
+    if (!sttsBox) {
         return null;
     }
     return calculateFps({

package/dist/get-sample-aspect-ratio.d.ts

@@ -0,0 +1,37 @@
+import type { Av1CBox } from './boxes/iso-base-media/stsd/av1c';
+import type { AvccBox } from './boxes/iso-base-media/stsd/avcc';
+import type { ColorParameterBox } from './boxes/iso-base-media/stsd/colr';
+import type { HvccBox } from './boxes/iso-base-media/stsd/hvcc';
+import type { PaspBox } from './boxes/iso-base-media/stsd/pasp';
+import type { VideoSample } from './boxes/iso-base-media/stsd/samples';
+import type { TkhdBox } from './boxes/iso-base-media/tkhd';
+import type { TrakBox } from './boxes/iso-base-media/trak/trak';
+import type { Dimensions } from './get-dimensions';
+type AspectRatio = {
+    numerator: number;
+    denominator: number;
+};
+export declare const getVideoSample: (trakBox: TrakBox) => VideoSample | null;
+export declare const getAvccBox: (trakBox: TrakBox) => AvccBox | null;
+export declare const getAv1CBox: (trakBox: TrakBox) => Av1CBox | null;
+export declare const getPaspBox: (trakBox: TrakBox) => PaspBox | null;
+export declare const getHvccBox: (trakBox: TrakBox) => HvccBox | null;
+export declare const getSampleAspectRatio: (trakBox: TrakBox) => AspectRatio;
+export declare const getColrBox: (videoSample: VideoSample) => ColorParameterBox | null;
+export declare const applyTkhdBox: (aspectRatioApplied: Dimensions, tkhdBox: TkhdBox) => {
+    displayAspectWidth: number;
+    displayAspectHeight: number;
+    width: number;
+    height: number;
+    rotation: number;
+};
+export declare const applyAspectRatios: ({ dimensions, sampleAspectRatio, displayAspectRatio, }: {
+    dimensions: Dimensions;
+    sampleAspectRatio: AspectRatio;
+    displayAspectRatio: AspectRatio;
+}) => Dimensions;
+export declare const getDisplayAspectRatio: ({ sampleAspectRatio, nativeDimensions, }: {
+    sampleAspectRatio: AspectRatio;
+    nativeDimensions: Dimensions;
+}) => AspectRatio;
+export {};

package/dist/get-sample-aspect-ratio.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDisplayAspectRatio = exports.applyAspectRatios = exports.applyTkhdBox = exports.getColrBox = exports.getSampleAspectRatio = exports.getHvccBox = exports.getPaspBox = exports.getAv1CBox = exports.getAvccBox = exports.getVideoSample = void 0;
+const traversal_1 = require("./traversal");
+const getVideoSample = (trakBox) => {
+    const stsdBox = (0, traversal_1.getStsdBox)(trakBox);
+    if (!stsdBox) {
+        return null;
+    }
+    const videoSample = stsdBox.samples.find((s) => s.type === 'video');
+    if (!videoSample || videoSample.type !== 'video') {
+        return null;
+    }
+    return videoSample;
+};
+exports.getVideoSample = getVideoSample;
+const getAvccBox = (trakBox) => {
+    const videoSample = (0, exports.getVideoSample)(trakBox);
+    if (!videoSample) {
+        return null;
+    }
+    const avccBox = videoSample.descriptors.find((c) => c.type === 'avcc-box');
+    if (!avccBox || avccBox.type !== 'avcc-box') {
+        return null;
+    }
+    return avccBox;
+};
+exports.getAvccBox = getAvccBox;
+const getAv1CBox = (trakBox) => {
+    const videoSample = (0, exports.getVideoSample)(trakBox);
+    if (!videoSample) {
+        return null;
+    }
+    const av1cBox = videoSample.descriptors.find((c) => c.type === 'av1C-box');
+    if (!av1cBox || av1cBox.type !== 'av1C-box') {
+        return null;
+    }
+    return av1cBox;
+};
+exports.getAv1CBox = getAv1CBox;
+const getPaspBox = (trakBox) => {
+    const videoSample = (0, exports.getVideoSample)(trakBox);
+    if (!videoSample) {
+        return null;
+    }
+    const paspBox = videoSample.descriptors.find((c) => c.type === 'pasp-box');
+    if (!paspBox || paspBox.type !== 'pasp-box') {
+        return null;
+    }
+    return paspBox;
+};
+exports.getPaspBox = getPaspBox;
+const getHvccBox = (trakBox) => {
+    const videoSample = (0, exports.getVideoSample)(trakBox);
+    if (!videoSample) {
+        return null;
+    }
+    const hvccBox = videoSample.descriptors.find((c) => c.type === 'hvcc-box');
+    if (!hvccBox || hvccBox.type !== 'hvcc-box') {
+        return null;
+    }
+    return hvccBox;
+};
+exports.getHvccBox = getHvccBox;
+const getSampleAspectRatio = (trakBox) => {
+    const paspBox = (0, exports.getPaspBox)(trakBox);
+    if (!paspBox) {
+        return {
+            numerator: 1,
+            denominator: 1,
+        };
+    }
+    return {
+        numerator: paspBox.hSpacing,
+        denominator: paspBox.vSpacing,
+    };
+};
+exports.getSampleAspectRatio = getSampleAspectRatio;
+const getColrBox = (videoSample) => {
+    const colrBox = videoSample.descriptors.find((c) => c.type === 'colr-box');
+    if (!colrBox || colrBox.type !== 'colr-box') {
+        return null;
+    }
+    return colrBox;
+};
+exports.getColrBox = getColrBox;
+const applyTkhdBox = (aspectRatioApplied, tkhdBox) => {
+    if (tkhdBox === null || tkhdBox.rotation === 0) {
+        return {
+            displayAspectWidth: aspectRatioApplied.width,
+            displayAspectHeight: aspectRatioApplied.height,
+            width: aspectRatioApplied.width,
+            height: aspectRatioApplied.height,
+            rotation: 0,
+        };
+    }
+    return {
+        width: tkhdBox.width,
+        height: tkhdBox.height,
+        rotation: tkhdBox.rotation,
+        displayAspectWidth: aspectRatioApplied.width,
+        displayAspectHeight: aspectRatioApplied.height,
+    };
+};
+exports.applyTkhdBox = applyTkhdBox;
+const applyAspectRatios = ({ dimensions, sampleAspectRatio, displayAspectRatio, }) => {
+    if (displayAspectRatio.numerator === 0) {
+        return dimensions;
+    }
+    if (displayAspectRatio.denominator === 0) {
+        return dimensions;
+    }
+    const newWidth = Math.round((dimensions.width * sampleAspectRatio.numerator) /
+        sampleAspectRatio.denominator);
+    const newHeight = Math.floor(newWidth / (displayAspectRatio.numerator / displayAspectRatio.denominator));
+    return {
+        width: Math.floor(newWidth),
+        height: newHeight,
+    };
+};
+exports.applyAspectRatios = applyAspectRatios;
+function gcd(a, b) {
+    return b === 0 ? a : gcd(b, a % b);
+}
+function reduceFraction(numerator, denominator) {
+    const greatestCommonDivisor = gcd(Math.abs(numerator), Math.abs(denominator));
+    return {
+        numerator: numerator / greatestCommonDivisor,
+        denominator: denominator / greatestCommonDivisor,
+    };
+}
+const getDisplayAspectRatio = ({ sampleAspectRatio, nativeDimensions, }) => {
+    const num = Math.round(nativeDimensions.width * sampleAspectRatio.numerator);
+    const den = Math.round(nativeDimensions.height * sampleAspectRatio.denominator);
+    return reduceFraction(num, den);
+};
+exports.getDisplayAspectRatio = getDisplayAspectRatio;

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

@@ -0,0 +1,22 @@
+import type { CttsBox } from './boxes/iso-base-media/stsd/ctts';
+import type { StcoBox } from './boxes/iso-base-media/stsd/stco';
+import type { StscBox } from './boxes/iso-base-media/stsd/stsc';
+import type { StssBox } from './boxes/iso-base-media/stsd/stss';
+import type { StszBox } from './boxes/iso-base-media/stsd/stsz';
+import type { SttsBox } from './boxes/iso-base-media/stsd/stts';
+export type SamplePosition = {
+    offset: number;
+    size: number;
+    isKeyframe: boolean;
+    dts: number;
+    cts: number;
+    duration: number;
+};
+export declare const getSamplePositions: ({ stcoBox, stszBox, stscBox, stssBox, sttsBox, cttsBox, }: {
+    stcoBox: StcoBox;
+    stszBox: StszBox;
+    stscBox: StscBox;
+    stssBox: StssBox | null;
+    sttsBox: SttsBox;
+    cttsBox: CttsBox | null;
+}) => SamplePosition[];

package/dist/get-sample-positions.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSamplePositions = void 0;
+const getSamplePositions = ({ stcoBox, stszBox, stscBox, stssBox, sttsBox, cttsBox, }) => {
+    var _a;
+    const sttsDeltas = [];
+    for (const distribution of sttsBox.sampleDistribution) {
+        for (let i = 0; i < distribution.sampleCount; i++) {
+            sttsDeltas.push(distribution.sampleDelta);
+        }
+    }
+    const cttsEntries = [];
+    for (const entry of (_a = cttsBox === null || cttsBox === void 0 ? void 0 : cttsBox.entries) !== null && _a !== void 0 ? _a : [
+        { sampleCount: sttsDeltas.length, sampleOffset: 0 },
+    ]) {
+        for (let i = 0; i < entry.sampleCount; i++) {
+            cttsEntries.push(entry.sampleOffset);
+        }
+    }
+    let dts = 0;
+    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.countType === 'fixed'
+                ? stszBox.sampleSize
+                : stszBox.entries[samples.length];
+            const isKeyframe = stssBox
+                ? stssBox.sampleNumber.includes(samples.length + 1)
+                : true;
+            const delta = sttsDeltas[samples.length];
+            const ctsOffset = cttsEntries[samples.length];
+            const cts = dts + ctsOffset;
+            samples.push({
+                offset: chunks[i] + offsetInThisChunk,
+                size,
+                isKeyframe,
+                dts,
+                cts,
+                duration: delta,
+            });
+            dts += delta;
+            offsetInThisChunk += size;
+        }
+    }
+    return samples;
+};
+exports.getSamplePositions = getSamplePositions;

package/dist/get-tracks.d.ts

@@ -0,0 +1,49 @@
+import type { MoovBox } from './boxes/iso-base-media/moov/moov';
+import type { SamplePosition } from './get-sample-positions';
+import type { AnySegment } from './parse-result';
+import type { ParserState } from './parser-state';
+type SampleAspectRatio = {
+    numerator: number;
+    denominator: number;
+};
+export type VideoTrack = {
+    type: 'video';
+    samplePositions: SamplePosition[] | null;
+    trackId: number;
+    description: Uint8Array | undefined;
+    timescale: number;
+    codec: string;
+    sampleAspectRatio: SampleAspectRatio;
+    width: number;
+    height: number;
+    displayAspectWidth: number;
+    displayAspectHeight: number;
+    codedWidth: number;
+    codedHeight: number;
+    rotation: number;
+};
+export type AudioTrack = {
+    type: 'audio';
+    samplePositions: SamplePosition[] | null;
+    trackId: number;
+    timescale: number;
+    codec: string;
+    numberOfChannels: number;
+    sampleRate: number;
+    description: Uint8Array | undefined;
+};
+export type OtherTrack = {
+    type: 'other';
+    samplePositions: SamplePosition[] | null;
+    trackId: number;
+    timescale: number;
+};
+export type Track = VideoTrack | AudioTrack | OtherTrack;
+export declare const getNumberOfTracks: (moovBox: MoovBox) => number;
+export declare const hasTracks: (segments: AnySegment[]) => boolean;
+export declare const getTracks: (segments: AnySegment[], state: ParserState) => {
+    videoTracks: VideoTrack[];
+    audioTracks: AudioTrack[];
+    otherTracks: OtherTrack[];
+};
+export {};