@remotion/media-parser 4.0.194 → 4.0.196

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

@@ -1,12 +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, }: {
+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

@@ -1,7 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSamplePositions = void 0;
-const getSamplePositions = ({ stcoBox, stszBox, stscBox, }) => {
+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;
@@ -12,11 +28,24 @@ const getSamplePositions = ({ stcoBox, stszBox, stscBox, }) => {
         }
         let offsetInThisChunk = 0;
         for (let j = 0; j < samplesPerChunk; j++) {
-            const size = stszBox.samples[samples.length];
+            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;
         }
     }

package/dist/get-tracks.d.ts

@@ -1,10 +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';
-type Track = {
-    type: 'audio' | 'video';
-    samplePositions: SamplePosition[];
+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 declare const getNumberOfTracks: (segments: AnySegment[]) => number;
-export declare const getTracks: (segments: AnySegment[]) => Track[];
 export {};

package/dist/get-tracks.js

@@ -1,66 +1,84 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTracks = exports.getNumberOfTracks = void 0;
-const get_fps_1 = require("./get-fps");
-const get_sample_positions_1 = require("./get-sample-positions");
-const traversal_1 = require("./traversal");
-// TODO: Use this to determine if all tracks are present
-const getNumberOfTracks = (segments) => {
-    const moovBox = (0, traversal_1.getMoovBox)(segments);
-    if (!moovBox) {
-        return 0;
-    }
-    const mvHdBox = (0, traversal_1.getMvhdBox)(moovBox);
+exports.getTracks = exports.hasTracks = exports.getNumberOfTracks = void 0;
+const make_track_1 = require("./boxes/iso-base-media/make-track");
+const get_ready_tracks_1 = require("./boxes/webm/get-ready-tracks");
+const traversal_1 = require("./boxes/webm/traversal");
+const traversal_2 = require("./traversal");
+const getNumberOfTracks = (moovBox) => {
+    const mvHdBox = (0, traversal_2.getMvhdBox)(moovBox);
     if (!mvHdBox) {
         return 0;
     }
     return mvHdBox.nextTrackId - 1;
 };
 exports.getNumberOfTracks = getNumberOfTracks;
-const getTracks = (segments) => {
-    const moovBox = (0, traversal_1.getMoovBox)(segments);
+const hasTracks = (segments) => {
+    const mainSegment = (0, traversal_1.getMainSegment)(segments);
+    if (mainSegment) {
+        return (0, traversal_2.getTracksSegment)(mainSegment) !== null;
+    }
+    const moovBox = (0, traversal_2.getMoovBox)(segments);
     if (!moovBox) {
-        return [];
+        return false;
     }
-    const foundTracks = [];
-    const tracks = (0, traversal_1.getTraks)(moovBox);
-    for (const track of tracks) {
-        const stszBox = (0, traversal_1.getStszBox)(track);
-        const stcoBox = (0, traversal_1.getStcoBox)(track);
-        const stscBox = (0, traversal_1.getStscBox)(track);
-        const tkhdBox = (0, traversal_1.getTkhdBox)(track);
-        if (!tkhdBox) {
-            throw new Error('Expected tkhd box in trak box');
-        }
-        if (!stszBox) {
-            throw new Error('Expected stsz box in trak box');
+    const numberOfTracks = (0, exports.getNumberOfTracks)(moovBox);
+    const tracks = (0, traversal_2.getTraks)(moovBox);
+    return tracks.length === numberOfTracks;
+};
+exports.hasTracks = hasTracks;
+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 matroskaTracks = (0, get_ready_tracks_1.getTracksFromMatroska)(mainSegment, state.getTimescale());
+        for (const track of matroskaTracks) {
+            if (track.type === 'video') {
+                videoTracks.push(track);
+            }
+            else if (track.type === 'audio') {
+                audioTracks.push(track);
+            }
+            else if (track.type === 'other') {
+                otherTracks.push(track);
+            }
         }
-        if (!stcoBox) {
-            throw new Error('Expected stco box in trak box');
+        return {
+            videoTracks,
+            audioTracks,
+            otherTracks,
+        };
+    }
+    const moovBox = (0, traversal_2.getMoovBox)(segments);
+    if (!moovBox) {
+        return {
+            videoTracks,
+            audioTracks,
+            otherTracks,
+        };
+    }
+    const tracks = (0, traversal_2.getTraks)(moovBox);
+    for (const trakBox of tracks) {
+        const track = (0, make_track_1.makeBaseMediaTrack)(trakBox);
+        if (!track) {
+            continue;
         }
-        if (!stscBox) {
-            throw new Error('Expected stsc box in trak box');
+        if (track.type === 'video') {
+            videoTracks.push(track);
         }
-        const samplePositions = (0, get_sample_positions_1.getSamplePositions)({
-            stcoBox,
-            stscBox,
-            stszBox,
-        });
-        if ((0, get_fps_1.trakBoxContainsAudio)(track)) {
-            foundTracks.push({
-                type: 'audio',
-                samplePositions,
-                trackId: tkhdBox.trackId,
-            });
+        else if (track.type === 'audio') {
+            audioTracks.push(track);
         }
-        if ((0, get_fps_1.trakBoxContainsVideo)(track)) {
-            foundTracks.push({
-                type: 'video',
-                samplePositions,
-                trackId: tkhdBox.trackId,
-            });
+        else if (track.type === 'other') {
+            otherTracks.push(track);
         }
     }
-    return foundTracks;
+    return {
+        videoTracks,
+        audioTracks,
+        otherTracks,
+    };
 };
 exports.getTracks = getTracks;

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

@@ -1,4 +1,6 @@
+import type { TrakBox } from './boxes/iso-base-media/trak/trak';
 import type { KnownVideoCodecs } from './options';
 import type { AnySegment } from './parse-result';
 export declare const hasVideoCodec: (boxes: AnySegment[]) => boolean;
+export declare const getVideoCodecString: (trakBox: TrakBox) => string | null;
 export declare const getVideoCodec: (boxes: AnySegment[]) => KnownVideoCodecs | null;