@remotion/media-parser 4.0.332 → 4.0.334

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

@@ -4,6 +4,7 @@ import type { ColorParameterBox } from './containers/iso-base-media/stsd/colr';
 import type { HvccBox } from './containers/iso-base-media/stsd/hvcc';
 import type { PaspBox } from './containers/iso-base-media/stsd/pasp';
 import type { VideoSample } from './containers/iso-base-media/stsd/samples';
+import type { VpccBox } from './containers/iso-base-media/stsd/vpcc';
 import type { TkhdBox } from './containers/iso-base-media/tkhd';
 import type { TrakBox } from './containers/iso-base-media/trak/trak';
 import type { MediaParserDimensions } from './get-dimensions';
@@ -13,6 +14,7 @@ type AspectRatio = {
 };
 export declare const getStsdVideoConfig: (trakBox: TrakBox) => VideoSample | null;
 export declare const getAvccBox: (trakBox: TrakBox) => AvccBox | null;
+export declare const getVpccBox: (trakBox: TrakBox) => VpccBox | 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;

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

@@ -1,6 +1,6 @@
 "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.getStsdVideoConfig = void 0;
+exports.getDisplayAspectRatio = exports.applyAspectRatios = exports.applyTkhdBox = exports.getColrBox = exports.getSampleAspectRatio = exports.getHvccBox = exports.getPaspBox = exports.getAv1CBox = exports.getVpccBox = exports.getAvccBox = exports.getStsdVideoConfig = void 0;
 const traversal_1 = require("./containers/iso-base-media/traversal");
 const getStsdVideoConfig = (trakBox) => {
     const stsdBox = (0, traversal_1.getStsdBox)(trakBox);
@@ -26,6 +26,18 @@ const getAvccBox = (trakBox) => {
     return avccBox;
 };
 exports.getAvccBox = getAvccBox;
+const getVpccBox = (trakBox) => {
+    const videoConfig = (0, exports.getStsdVideoConfig)(trakBox);
+    if (!videoConfig) {
+        return null;
+    }
+    const vpccBox = videoConfig.descriptors.find((c) => c.type === 'vpcc-box');
+    if (!vpccBox || vpccBox.type !== 'vpcc-box') {
+        return null;
+    }
+    return vpccBox;
+};
+exports.getVpccBox = getVpccBox;
 const getAv1CBox = (trakBox) => {
     const videoConfig = (0, exports.getStsdVideoConfig)(trakBox);
     if (!videoConfig) {

package/dist/get-video-codec.js

@@ -60,21 +60,25 @@ exports.getIsoBmColrConfig = getIsoBmColrConfig;
 const getVideoCodecString = (trakBox) => {
     const videoSample = (0, get_sample_aspect_ratio_1.getStsdVideoConfig)(trakBox);
     const avccBox = (0, get_sample_aspect_ratio_1.getAvccBox)(trakBox);
-    const hvccBox = (0, get_sample_aspect_ratio_1.getHvccBox)(trakBox);
-    const av1cBox = (0, get_sample_aspect_ratio_1.getAv1CBox)(trakBox);
     if (!videoSample) {
         return null;
     }
     if (avccBox) {
         return `${videoSample.format}.${avccBox.configurationString}`;
     }
+    const hvccBox = (0, get_sample_aspect_ratio_1.getHvccBox)(trakBox);
     if (hvccBox) {
         return `${videoSample.format}.${hvccBox.configurationString}`;
     }
+    const av1cBox = (0, get_sample_aspect_ratio_1.getAv1CBox)(trakBox);
     if (av1cBox) {
         const colrAtom = (0, get_sample_aspect_ratio_1.getColrBox)(videoSample);
         return (0, av1_codec_private_1.parseAv1PrivateData)(av1cBox.privateData, colrAtom);
     }
+    const vpccBox = (0, get_sample_aspect_ratio_1.getVpccBox)(trakBox);
+    if (vpccBox) {
+        return `${videoSample.format}.${vpccBox.codecString}`;
+    }
     return videoSample.format;
 };
 exports.getVideoCodecString = getVideoCodecString;

package/dist/index.d.ts

@@ -901,10 +901,17 @@ export declare const MediaParserInternals: {
         };
         iso: {
             flatSamples: {
-                getSamples: (mdatStart: number) => Map<number, import("./state/iso-base-media/cached-sample-positions").FlatSample> | null;
-                setSamples: (mdatStart: number, samples: Map<number, import("./state/iso-base-media/cached-sample-positions").FlatSample>) => void;
-                setJumpMarks: (mdatStart: number, marks: import("./containers/iso-base-media/mdat/calculate-jump-marks").JumpMark[]) => void;
-                getJumpMarks: (mdatStart: number) => import("./containers/iso-base-media/mdat/calculate-jump-marks").JumpMark[];
+                getSamples: (mdatStart: number) => {
+                    trackId: number;
+                    samplePositions: SamplePosition[];
+                }[] | null;
+                setSamples: (mdatStart: number, samples: {
+                    trackId: number;
+                    samplePositions: SamplePosition[];
+                }[]) => void;
+                setCurrentSampleIndex: (mdatStart: number, trackId: number, index: number) => void;
+                getCurrentSampleIndices: (mdatStart: number) => Record<number, number>;
+                updateAfterSeek: (seekedByte: number) => void;
             };
             moov: {
                 setMoovBox: (moov: {

package/dist/parse-loop.js

@@ -89,6 +89,7 @@ const parseLoop = async ({ state, throttledState, onError, }) => {
                         src: state.src,
                         discardReadBytes: state.discardReadBytes,
                         prefetchCache: state.prefetchCache,
+                        isoState: state.iso,
                     });
                     state.timings.timeSeeking += Date.now() - seekStart;
                 }

package/dist/perform-seek.d.ts

@@ -6,9 +6,10 @@ import type { MediaParserLogLevel } from './log';
 import type { ParseMediaMode, ParseMediaSrc } from './options';
 import type { MediaParserReaderInterface } from './readers/reader';
 import type { CurrentReader } from './state/current-reader';
+import type { IsoBaseMediaState } from './state/iso-base-media/iso-state';
 import type { SeekInfiniteLoop } from './state/seek-infinite-loop';
 import type { MediaSectionState } from './state/video-section';
-export declare const performSeek: ({ seekTo, userInitiated, controller, mediaSection, iterator, seekInfiniteLoop, logLevel, mode, contentLength, currentReader, readerInterface, src, discardReadBytes, fields, prefetchCache, }: {
+export declare const performSeek: ({ seekTo, userInitiated, controller, mediaSection, iterator, seekInfiniteLoop, logLevel, mode, contentLength, currentReader, readerInterface, src, discardReadBytes, fields, prefetchCache, isoState, }: {
     seekTo: number;
     userInitiated: boolean;
     controller: MediaParserController;
@@ -24,4 +25,5 @@ export declare const performSeek: ({ seekTo, userInitiated, controller, mediaSec
     src: ParseMediaSrc;
     discardReadBytes: (force: boolean) => Promise<void>;
     prefetchCache: PrefetchCache;
+    isoState: IsoBaseMediaState;
 }) => Promise<void>;

package/dist/perform-seek.js

@@ -5,7 +5,7 @@ const log_1 = require("./log");
 const seek_backwards_1 = require("./seek-backwards");
 const seek_forwards_1 = require("./seek-forwards");
 const video_section_1 = require("./state/video-section");
-const performSeek = async ({ seekTo, userInitiated, controller, mediaSection, iterator, seekInfiniteLoop, logLevel, mode, contentLength, currentReader, readerInterface, src, discardReadBytes, fields, prefetchCache, }) => {
+const performSeek = async ({ seekTo, userInitiated, controller, mediaSection, iterator, seekInfiniteLoop, logLevel, mode, contentLength, currentReader, readerInterface, src, discardReadBytes, fields, prefetchCache, isoState, }) => {
     const byteInMediaSection = (0, video_section_1.isByteInMediaSection)({
         position: seekTo,
         mediaSections: mediaSection.getMediaSections(),
@@ -69,6 +69,9 @@ const performSeek = async ({ seekTo, userInitiated, controller, mediaSection, it
             prefetchCache,
         });
     }
+    if (userInitiated) {
+        isoState.flatSamples.updateAfterSeek(seekTo);
+    }
     await controller._internals.checkForAbortAndPause();
 };
 exports.performSeek = performSeek;

package/dist/state/iso-base-media/cached-sample-positions.d.ts

@@ -1,33 +1,25 @@
-import type { JumpMark } from '../../containers/iso-base-media/mdat/calculate-jump-marks';
 import type { SamplePosition } from '../../get-sample-positions';
-import type { MediaParserAudioTrack, MediaParserOtherTrack, MediaParserVideoTrack } from '../../get-tracks';
 import type { ParserState } from '../parser-state';
-export type FlatSample = {
-    track: MediaParserVideoTrack | MediaParserAudioTrack | MediaParserOtherTrack;
-    samplePosition: SamplePosition;
-};
-export type MinimalFlatSampleForTesting = {
-    track: {
-        trackId: number;
-        originalTimescale: number;
-        type: 'audio' | 'video' | 'other';
-    };
-    samplePosition: {
-        decodingTimestamp: number;
-        offset: number;
-    };
+type TrackIdAndSamplePositions = {
+    trackId: number;
+    samplePositions: SamplePosition[];
 };
-export declare const calculateFlatSamples: ({ state, mediaSectionStart, }: {
+export declare const calculateSamplePositions: ({ state, mediaSectionStart, trackIds, }: {
     state: ParserState;
     mediaSectionStart: number;
-}) => {
-    flatSamples: Map<number, FlatSample>;
-    offsets: number[];
     trackIds: number[];
-};
+}) => TrackIdAndSamplePositions[];
 export declare const cachedSamplePositionsState: () => {
-    getSamples: (mdatStart: number) => Map<number, FlatSample> | null;
-    setSamples: (mdatStart: number, samples: Map<number, FlatSample>) => void;
-    setJumpMarks: (mdatStart: number, marks: JumpMark[]) => void;
-    getJumpMarks: (mdatStart: number) => JumpMark[];
+    getSamples: (mdatStart: number) => TrackIdAndSamplePositions[] | null;
+    setSamples: (mdatStart: number, samples: TrackIdAndSamplePositions[]) => void;
+    setCurrentSampleIndex: (mdatStart: number, trackId: number, index: number) => void;
+    getCurrentSampleIndices: (mdatStart: number) => Record<number, number>;
+    updateAfterSeek: (seekedByte: number) => void;
+};
+type Lowest = {
+    samplePosition: SamplePosition;
+    trackId: number;
+    index: number;
 };
+export declare const getSampleWithLowestDts: (samplePositions: TrackIdAndSamplePositions[], currentSampleIndexMap: Record<number, number>) => Lowest[];
+export {};

package/dist/state/iso-base-media/cached-sample-positions.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cachedSamplePositionsState = exports.calculateFlatSamples = void 0;
+exports.getSampleWithLowestDts = exports.cachedSamplePositionsState = exports.calculateSamplePositions = void 0;
 const are_samples_complete_1 = require("../../containers/iso-base-media/are-samples-complete");
 const get_sample_positions_from_track_1 = require("../../containers/iso-base-media/get-sample-positions-from-track");
 const traversal_1 = require("../../containers/iso-base-media/traversal");
 const get_tracks_1 = require("../../get-tracks");
+const log_1 = require("../../log");
 const precomputed_tfra_1 = require("./precomputed-tfra");
-const calculateFlatSamples = ({ state, mediaSectionStart, }) => {
+const calculateSamplePositions = ({ state, mediaSectionStart, trackIds, }) => {
     var _a, _b;
     const tracks = (0, get_tracks_1.getTracks)(state, true);
     const moofBoxes = (0, traversal_1.getMoofBoxes)(state.structure.getIsoStructure().boxes);
@@ -28,11 +29,13 @@ const calculateFlatSamples = ({ state, mediaSectionStart, }) => {
     if (!moov) {
         throw new Error('No moov box found');
     }
-    const offsets = [];
-    const trackIds = [];
-    const map = new Map();
+    const trackIdAndSamplePositions = [];
     for (const track of tracks) {
         const trakBox = (0, traversal_1.getTrakBoxByTrackId)(moov, track.trackId);
+        if (!trackIds.includes(track.trackId)) {
+            log_1.Log.verbose(state.logLevel, 'Skipping calculating sample positions for track', track.trackId);
+            continue;
+        }
         if (!trakBox) {
             throw new Error('No trak box found');
         }
@@ -42,37 +45,93 @@ const calculateFlatSamples = ({ state, mediaSectionStart, }) => {
             moofComplete,
             trexBoxes: (0, traversal_1.getTrexBoxes)(moov),
         });
-        trackIds.push(track.trackId);
-        for (const samplePosition of samplePositions) {
-            offsets.push(samplePosition.offset);
-            map.set(samplePosition.offset, {
-                track,
-                samplePosition,
-            });
+        trackIdAndSamplePositions.push({
+            trackId: track.trackId,
+            samplePositions,
+        });
+    }
+    return trackIdAndSamplePositions;
+};
+exports.calculateSamplePositions = calculateSamplePositions;
+const updateSampleIndicesAfterSeek = ({ samplePositionsForMdatStart, seekedByte, }) => {
+    const currentSampleIndices = {};
+    const keys = Object.keys(samplePositionsForMdatStart).map(Number).sort();
+    const mdat = keys.find((key) => seekedByte >= key);
+    if (!mdat) {
+        return currentSampleIndices;
+    }
+    const samplePositions = samplePositionsForMdatStart[mdat];
+    if (!samplePositions) {
+        return currentSampleIndices;
+    }
+    for (const track of samplePositions) {
+        const currentSampleIndex = track.samplePositions.findIndex((sample) => sample.offset >= seekedByte);
+        if (!currentSampleIndices[mdat]) {
+            currentSampleIndices[mdat] = {};
+        }
+        if (!currentSampleIndices[mdat][track.trackId]) {
+            currentSampleIndices[mdat][track.trackId] = 0;
+        }
+        if (currentSampleIndex === -1) {
+            currentSampleIndices[mdat][track.trackId] = track.samplePositions.length;
+        }
+        else {
+            currentSampleIndices[mdat][track.trackId] = currentSampleIndex;
         }
     }
-    offsets.sort((a, b) => a - b);
-    return { flatSamples: map, offsets, trackIds };
+    return currentSampleIndices;
 };
-exports.calculateFlatSamples = calculateFlatSamples;
 const cachedSamplePositionsState = () => {
-    // offset -> flat sample
-    const cachedForMdatStart = {};
-    const jumpMarksForMdatStart = {};
+    // offset -> sample positions
+    const samplePositionsForMdatStart = {};
+    let currentSampleIndex = {};
     return {
         getSamples: (mdatStart) => {
             var _a;
-            return (_a = cachedForMdatStart[mdatStart]) !== null && _a !== void 0 ? _a : null;
+            return (_a = samplePositionsForMdatStart[mdatStart]) !== null && _a !== void 0 ? _a : null;
         },
         setSamples: (mdatStart, samples) => {
-            cachedForMdatStart[mdatStart] = samples;
+            samplePositionsForMdatStart[mdatStart] = samples;
+        },
+        setCurrentSampleIndex: (mdatStart, trackId, index) => {
+            if (!currentSampleIndex[mdatStart]) {
+                currentSampleIndex[mdatStart] = {};
+            }
+            if (!currentSampleIndex[mdatStart][trackId]) {
+                currentSampleIndex[mdatStart][trackId] = 0;
+            }
+            currentSampleIndex[mdatStart][trackId] = index;
         },
-        setJumpMarks: (mdatStart, marks) => {
-            jumpMarksForMdatStart[mdatStart] = marks;
+        getCurrentSampleIndices: (mdatStart) => {
+            var _a;
+            return (_a = currentSampleIndex[mdatStart]) !== null && _a !== void 0 ? _a : {};
         },
-        getJumpMarks: (mdatStart) => {
-            return jumpMarksForMdatStart[mdatStart];
+        updateAfterSeek: (seekedByte) => {
+            currentSampleIndex = updateSampleIndicesAfterSeek({
+                samplePositionsForMdatStart,
+                seekedByte,
+            });
         },
     };
 };
 exports.cachedSamplePositionsState = cachedSamplePositionsState;
+const getSampleWithLowestDts = (samplePositions, currentSampleIndexMap) => {
+    var _a;
+    const lowestDts = [];
+    for (const track of samplePositions) {
+        const currentSampleIndex = (_a = currentSampleIndexMap[track.trackId]) !== null && _a !== void 0 ? _a : 0;
+        const currentSample = track.samplePositions[currentSampleIndex];
+        if (currentSample &&
+            (lowestDts.length === 0 ||
+                currentSample.decodingTimestamp <=
+                    lowestDts[0].samplePosition.decodingTimestamp)) {
+            lowestDts.push({
+                samplePosition: currentSample,
+                trackId: track.trackId,
+                index: currentSampleIndex,
+            });
+        }
+    }
+    return lowestDts;
+};
+exports.getSampleWithLowestDts = getSampleWithLowestDts;

package/dist/state/iso-base-media/iso-state.d.ts

@@ -12,10 +12,17 @@ export declare const isoBaseMediaState: ({ contentLength, controller, readerInte
     prefetchCache: PrefetchCache;
 }) => {
     flatSamples: {
-        getSamples: (mdatStart: number) => Map<number, import("./cached-sample-positions").FlatSample> | null;
-        setSamples: (mdatStart: number, samples: Map<number, import("./cached-sample-positions").FlatSample>) => void;
-        setJumpMarks: (mdatStart: number, marks: import("../../containers/iso-base-media/mdat/calculate-jump-marks").JumpMark[]) => void;
-        getJumpMarks: (mdatStart: number) => import("../../containers/iso-base-media/mdat/calculate-jump-marks").JumpMark[];
+        getSamples: (mdatStart: number) => {
+            trackId: number;
+            samplePositions: import("../../get-sample-positions").SamplePosition[];
+        }[] | null;
+        setSamples: (mdatStart: number, samples: {
+            trackId: number;
+            samplePositions: import("../../get-sample-positions").SamplePosition[];
+        }[]) => void;
+        setCurrentSampleIndex: (mdatStart: number, trackId: number, index: number) => void;
+        getCurrentSampleIndices: (mdatStart: number) => Record<number, number>;
+        updateAfterSeek: (seekedByte: number) => void;
     };
     moov: {
         setMoovBox: (moov: {

package/dist/state/parser-state.d.ts

@@ -164,10 +164,17 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     };
     iso: {
         flatSamples: {
-            getSamples: (mdatStart: number) => Map<number, import("./iso-base-media/cached-sample-positions").FlatSample> | null;
-            setSamples: (mdatStart: number, samples: Map<number, import("./iso-base-media/cached-sample-positions").FlatSample>) => void;
-            setJumpMarks: (mdatStart: number, marks: import("../containers/iso-base-media/mdat/calculate-jump-marks").JumpMark[]) => void;
-            getJumpMarks: (mdatStart: number) => import("../containers/iso-base-media/mdat/calculate-jump-marks").JumpMark[];
+            getSamples: (mdatStart: number) => {
+                trackId: number;
+                samplePositions: import("../get-sample-positions").SamplePosition[];
+            }[] | null;
+            setSamples: (mdatStart: number, samples: {
+                trackId: number;
+                samplePositions: import("../get-sample-positions").SamplePosition[];
+            }[]) => void;
+            setCurrentSampleIndex: (mdatStart: number, trackId: number, index: number) => void;
+            getCurrentSampleIndices: (mdatStart: number) => Record<number, number>;
+            updateAfterSeek: (seekedByte: number) => void;
         };
         moov: {
             setMoovBox: (moov: {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "4.0.332";
+export declare const VERSION = "4.0.334";

package/dist/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // Automatically generated on publish
-exports.VERSION = '4.0.332';
+exports.VERSION = '4.0.334';

package/dist/work-on-seek-request.js

@@ -134,6 +134,7 @@ const workOnSeekRequest = async (options) => {
             discardReadBytes,
             fields,
             prefetchCache,
+            isoState,
         });
         return;
     }
@@ -154,6 +155,7 @@ const workOnSeekRequest = async (options) => {
             discardReadBytes,
             fields,
             prefetchCache,
+            isoState,
         });
         const { hasChanged } = controller._internals.seekSignal.clearSeekIfStillSame(seek);
         if (hasChanged) {

package/package.json

@@ -3,7 +3,7 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-parser"
   },
   "name": "@remotion/media-parser",
-  "version": "4.0.332",
+  "version": "4.0.334",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
@@ -11,8 +11,8 @@
     "eslint": "9.19.0",
     "mediabunny": "1.3.0",
     "@types/bun": "1.2.8",
-    "@remotion/example-videos": "4.0.332",
-    "@remotion/eslint-config-internal": "4.0.332"
+    "@remotion/example-videos": "4.0.334",
+    "@remotion/eslint-config-internal": "4.0.334"
   },
   "publishConfig": {
     "access": "public"