@remotion/media-parser 4.0.327 → 4.0.330

package/dist/esm/worker-web-entry.mjs

@@ -3071,6 +3071,11 @@ var getVideoCodecString = (trakBox) => {
   return videoSample.format;
 };
 
+// src/normalize-video-rotation.ts
+var normalizeVideoRotation = (rotation) => {
+  return (rotation % 360 + 360) % 360;
+};
+
 // src/webcodecs-timescale.ts
 var WEBCODECS_TIMESCALE = 1e6;
 
@@ -3311,6 +3316,45 @@ var getVideoCodecFromIsoTrak = (trakBox) => {
   throw new Error("Could not find video codec");
 };
 
+// src/containers/iso-base-media/mdat/get-editlist.ts
+var findTrackStartTimeInSeconds = ({
+  movieTimeScale,
+  trakBox
+}) => {
+  const elstBox = getElstBox(trakBox);
+  if (!elstBox) {
+    return 0;
+  }
+  const { entries } = elstBox;
+  let dwellTime = 0;
+  for (const entry of entries) {
+    const { editDuration, mediaTime } = entry;
+    if (mediaTime !== -1) {
+      continue;
+    }
+    dwellTime += editDuration;
+  }
+  return dwellTime / movieTimeScale;
+};
+var findTrackMediaTimeOffsetInTrackTimescale = ({
+  trakBox
+}) => {
+  const elstBox = getElstBox(trakBox);
+  if (!elstBox) {
+    return 0;
+  }
+  const { entries } = elstBox;
+  let dwellTime = 0;
+  for (const entry of entries) {
+    const { mediaTime } = entry;
+    if (mediaTime === -1) {
+      continue;
+    }
+    dwellTime += mediaTime;
+  }
+  return dwellTime;
+};
+
 // src/containers/iso-base-media/make-track.ts
 var makeBaseMediaTrack = (trakBox, startTimeInSeconds) => {
   const tkhdBox = getTkhdBox(trakBox);
@@ -3351,7 +3395,10 @@ var makeBaseMediaTrack = (trakBox, startTimeInSeconds) => {
       codecData: actual.codecPrivate,
       codecEnum,
       startInSeconds: startTimeInSeconds,
-      timescale: WEBCODECS_TIMESCALE
+      timescale: WEBCODECS_TIMESCALE,
+      trackMediaTimeOffsetInTrackTimescale: findTrackMediaTimeOffsetInTrackTimescale({
+        trakBox
+      })
     };
   }
   if (!trakBoxContainsVideo(trakBox)) {
@@ -3361,7 +3408,10 @@ var makeBaseMediaTrack = (trakBox, startTimeInSeconds) => {
       originalTimescale: timescaleAndDuration.timescale,
       trakBox,
       startInSeconds: startTimeInSeconds,
-      timescale: WEBCODECS_TIMESCALE
+      timescale: WEBCODECS_TIMESCALE,
+      trackMediaTimeOffsetInTrackTimescale: findTrackMediaTimeOffsetInTrackTimescale({
+        trakBox
+      })
     };
   }
   const videoSample = getStsdVideoConfig(trakBox);
@@ -3403,39 +3453,21 @@ var makeBaseMediaTrack = (trakBox, startTimeInSeconds) => {
     codedHeight: videoSample.height,
     displayAspectWidth,
     displayAspectHeight,
-    rotation,
+    rotation: normalizeVideoRotation(0 - rotation),
     codecData: privateData,
     colorSpace: mediaParserAdvancedColorToWebCodecsColor(advancedColor),
     advancedColor,
     codecEnum: getVideoCodecFromIsoTrak(trakBox),
     fps: getFpsFromMp4TrakBox(trakBox),
     startInSeconds: startTimeInSeconds,
-    timescale: WEBCODECS_TIMESCALE
+    timescale: WEBCODECS_TIMESCALE,
+    trackMediaTimeOffsetInTrackTimescale: findTrackMediaTimeOffsetInTrackTimescale({
+      trakBox
+    })
   };
   return track;
 };
 
-// src/containers/iso-base-media/mdat/get-editlist.ts
-var findTrackStartTimeInSeconds = ({
-  movieTimeScale,
-  trakBox
-}) => {
-  const elstBox = getElstBox(trakBox);
-  if (!elstBox) {
-    return 0;
-  }
-  const { entries } = elstBox;
-  let dwellTime = 0;
-  for (const entry of entries) {
-    const { editDuration, mediaTime } = entry;
-    if (mediaTime !== -1) {
-      continue;
-    }
-    dwellTime += editDuration;
-  }
-  return dwellTime / movieTimeScale;
-};
-
 // src/containers/avc/codec-string.ts
 var getCodecStringFromSpsAndPps = (sps) => {
   return `avc1.${sps.spsData.profile.toString(16).padStart(2, "0")}${sps.spsData.compatibility.toString(16).padStart(2, "0")}${sps.spsData.level.toString(16).padStart(2, "0")}`;
@@ -3536,7 +3568,8 @@ var makeAviAudioTrack = ({
     originalTimescale: MEDIA_PARSER_RIFF_TIMESCALE,
     trackId: index,
     startInSeconds: 0,
-    timescale: WEBCODECS_TIMESCALE
+    timescale: WEBCODECS_TIMESCALE,
+    trackMediaTimeOffsetInTrackTimescale: 0
   };
 };
 var makeAviVideoTrack = ({
@@ -3581,7 +3614,8 @@ var makeAviVideoTrack = ({
     },
     fps: strh.rate / strh.scale,
     startInSeconds: 0,
-    timescale: WEBCODECS_TIMESCALE
+    timescale: WEBCODECS_TIMESCALE,
+    trackMediaTimeOffsetInTrackTimescale: 0
   };
 };
 var getTracksFromAvi = (structure, state) => {
@@ -4248,7 +4282,8 @@ var getTrack = ({
       codecEnum,
       fps: null,
       startInSeconds: 0,
-      timescale: WEBCODECS_TIMESCALE
+      timescale: WEBCODECS_TIMESCALE,
+      trackMediaTimeOffsetInTrackTimescale: 0
     };
   }
   if (trackTypeToString(trackType2.value.value) === "audio") {
@@ -4272,7 +4307,8 @@ var getTrack = ({
         track
       }),
       startInSeconds: 0,
-      timescale: WEBCODECS_TIMESCALE
+      timescale: WEBCODECS_TIMESCALE,
+      trackMediaTimeOffsetInTrackTimescale: 0
     };
   }
   return null;
@@ -7110,7 +7146,8 @@ var handleAvcPacket = async ({
       colorSpace: mediaParserAdvancedColorToWebCodecsColor(advancedColor),
       advancedColor,
       startInSeconds: 0,
-      timescale: WEBCODECS_TIMESCALE
+      timescale: WEBCODECS_TIMESCALE,
+      trackMediaTimeOffsetInTrackTimescale: 0
     };
     await registerVideoTrack({
       track,
@@ -8762,7 +8799,8 @@ var parseAac = async (state) => {
         trackId: 0,
         type: "audio",
         startInSeconds: 0,
-        timescale: WEBCODECS_TIMESCALE
+        timescale: WEBCODECS_TIMESCALE,
+        trackMediaTimeOffsetInTrackTimescale: 0
       },
       registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
       tracks: state.callbacks.tracks,
@@ -9169,7 +9207,8 @@ var parseStreamInfo = async ({
       originalTimescale: WEBCODECS_TIMESCALE,
       trackId: 0,
       startInSeconds: 0,
-      timescale: WEBCODECS_TIMESCALE
+      timescale: WEBCODECS_TIMESCALE,
+      trackMediaTimeOffsetInTrackTimescale: 0
     },
     registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
     tracks: state.callbacks.tracks,
@@ -9270,7 +9309,10 @@ var calculateFlatSamples = ({
   if (!moov) {
     throw new Error("No moov box found");
   }
-  const flatSamples = tracks2.map((track) => {
+  const offsets = [];
+  const trackIds = [];
+  const map = new Map;
+  for (const track of tracks2) {
     const trakBox = getTrakBoxByTrackId(moov, track.trackId);
     if (!trakBox) {
       throw new Error("No trak box found");
@@ -9281,14 +9323,17 @@ var calculateFlatSamples = ({
       moofComplete,
       trexBoxes: getTrexBoxes(moov)
     });
-    return samplePositions.map((samplePosition) => {
-      return {
+    trackIds.push(track.trackId);
+    for (const samplePosition of samplePositions) {
+      offsets.push(samplePosition.offset);
+      map.set(samplePosition.offset, {
         track,
         samplePosition
-      };
-    });
-  });
-  return flatSamples;
+      });
+    }
+  }
+  offsets.sort((a, b) => a - b);
+  return { flatSamples: map, offsets, trackIds };
 };
 var cachedSamplePositionsState = () => {
   const cachedForMdatStart = {};
@@ -11612,31 +11657,36 @@ var getMoovAtom = async ({
 // src/containers/iso-base-media/mdat/calculate-jump-marks.ts
 var MAX_SPREAD_IN_SECONDS = 8;
 var getKey = (samplePositionTrack) => {
-  return `${samplePositionTrack.track.trackId}-${samplePositionTrack.samplePosition.decodingTimestamp}`;
+  return `${samplePositionTrack.track.trackId}-${samplePositionTrack.samplePosition.decodingTimestamp}.${samplePositionTrack.samplePosition.offset}`;
 };
 var findBestJump = ({
-  allSamplesSortedByOffset,
+  sampleMap,
+  offsetsSorted,
   visited,
   progresses
 }) => {
   const minProgress = Math.min(...Object.values(progresses));
   const trackNumberWithLowestProgress = Object.entries(progresses).find(([, progress]) => progress === minProgress)?.[0];
-  const firstSampleAboveMinProgress = allSamplesSortedByOffset.findIndex((sample) => sample.track.trackId === Number(trackNumberWithLowestProgress) && !visited.has(getKey(sample)));
+  const firstSampleAboveMinProgress = offsetsSorted.findIndex((offset) => sampleMap.get(offset).track.trackId === Number(trackNumberWithLowestProgress) && !visited.has(getKey(sampleMap.get(offset))));
   return firstSampleAboveMinProgress;
 };
-var calculateJumpMarks = (samplePositionTracks, endOfMdat) => {
+var calculateJumpMarks = ({
+  sampleMap,
+  offsetsSorted,
+  trackIds,
+  endOfMdat
+}) => {
   const progresses = {};
-  for (const track of samplePositionTracks) {
-    progresses[track[0].track.trackId] = 0;
+  for (const trackId of trackIds) {
+    progresses[trackId] = 0;
   }
   const jumpMarks = [];
-  const allSamplesSortedByOffset = samplePositionTracks.flat(1).filter((s) => s.track.type === "audio" || s.track.type === "video").sort((a, b) => a.samplePosition.offset - b.samplePosition.offset);
   let indexToVisit = 0;
   const visited = new Set;
   let rollOverToProcess = false;
   const increaseIndex = () => {
     indexToVisit++;
-    if (indexToVisit >= allSamplesSortedByOffset.length) {
+    if (indexToVisit >= offsetsSorted.length) {
       rollOverToProcess = true;
       indexToVisit = 0;
     }
@@ -11650,23 +11700,24 @@ var calculateJumpMarks = (samplePositionTracks, endOfMdat) => {
     }
     const jumpMark = {
       afterSampleWithOffset: lastVisitedSample.samplePosition.offset,
-      jumpToOffset: allSamplesSortedByOffset[firstSampleAboveMinProgress].samplePosition.offset
+      jumpToOffset: offsetsSorted[firstSampleAboveMinProgress]
     };
     indexToVisit = firstSampleAboveMinProgress;
     jumpMarks.push(jumpMark);
   };
   const addFinalJumpIfNecessary = () => {
-    if (indexToVisit === allSamplesSortedByOffset.length - 1) {
+    if (indexToVisit === offsetsSorted.length - 1) {
       return;
     }
     jumpMarks.push({
-      afterSampleWithOffset: allSamplesSortedByOffset[indexToVisit].samplePosition.offset,
+      afterSampleWithOffset: offsetsSorted[indexToVisit],
       jumpToOffset: endOfMdat
     });
   };
   const considerJump = () => {
     const firstSampleAboveMinProgress = findBestJump({
-      allSamplesSortedByOffset,
+      sampleMap,
+      offsetsSorted,
       visited,
       progresses
     });
@@ -11676,14 +11727,14 @@ var calculateJumpMarks = (samplePositionTracks, endOfMdat) => {
     } else {
       while (true) {
         increaseIndex();
-        if (!visited.has(getKey(allSamplesSortedByOffset[indexToVisit]))) {
+        if (!visited.has(getKey(sampleMap.get(offsetsSorted[indexToVisit])))) {
           break;
         }
       }
     }
   };
   while (true) {
-    const currentSamplePosition = allSamplesSortedByOffset[indexToVisit];
+    const currentSamplePosition = sampleMap.get(offsetsSorted[indexToVisit]);
     const sampleKey = getKey(currentSamplePosition);
     if (visited.has(sampleKey)) {
       considerJump();
@@ -11701,7 +11752,7 @@ var calculateJumpMarks = (samplePositionTracks, endOfMdat) => {
       rollOverToProcess = false;
     }
     lastVisitedSample = currentSamplePosition;
-    if (visited.size === allSamplesSortedByOffset.length) {
+    if (visited.size === offsetsSorted.length) {
       addFinalJumpIfNecessary();
       break;
     }
@@ -11711,7 +11762,7 @@ var calculateJumpMarks = (samplePositionTracks, endOfMdat) => {
     const maxProgress = Math.max(...progressValues);
     const minProgress = Math.min(...progressValues);
     const spread = maxProgress - minProgress;
-    if (visited.size === allSamplesSortedByOffset.length) {
+    if (visited.size === offsetsSorted.length) {
       addFinalJumpIfNecessary();
       break;
     }
@@ -11793,24 +11844,32 @@ var parseMdatSection = async (state) => {
     return parseMdatSection(state);
   }
   if (!state.iso.flatSamples.getSamples(mediaSection.start)) {
-    const flattedSamples = calculateFlatSamples({
+    const {
+      flatSamples: flatSamplesMap,
+      offsets,
+      trackIds
+    } = calculateFlatSamples({
       state,
       mediaSectionStart: mediaSection.start
     });
-    const calcedJumpMarks = calculateJumpMarks(flattedSamples, endOfMdat);
+    const calcedJumpMarks = calculateJumpMarks({
+      sampleMap: flatSamplesMap,
+      offsetsSorted: offsets,
+      trackIds,
+      endOfMdat
+    });
     state.iso.flatSamples.setJumpMarks(mediaSection.start, calcedJumpMarks);
-    state.iso.flatSamples.setSamples(mediaSection.start, flattedSamples.flat(1));
+    state.iso.flatSamples.setSamples(mediaSection.start, flatSamplesMap);
   }
   const flatSamples = state.iso.flatSamples.getSamples(mediaSection.start);
   const jumpMarks = state.iso.flatSamples.getJumpMarks(mediaSection.start);
   const { iterator } = state;
-  const samplesWithIndex = flatSamples.find((sample) => {
-    return sample.samplePosition.offset === iterator.counter.getOffset();
-  });
+  const samplesWithIndex = flatSamples.get(iterator.counter.getOffset());
   if (!samplesWithIndex) {
-    const nextSample_ = flatSamples.filter((s) => s.samplePosition.offset > iterator.counter.getOffset()).sort((a, b) => a.samplePosition.offset - b.samplePosition.offset)[0];
+    const offsets = Array.from(flatSamples.keys());
+    const nextSample_ = offsets.filter((s) => s > iterator.counter.getOffset()).sort((a, b) => a - b)[0];
     if (nextSample_) {
-      iterator.discard(nextSample_.samplePosition.offset - iterator.counter.getOffset());
+      iterator.discard(nextSample_ - iterator.counter.getOffset());
       return null;
     }
     Log.verbose(state.logLevel, "Could not find sample at offset", iterator.counter.getOffset(), "skipping to end of mdat");
@@ -11832,9 +11891,14 @@ var parseMdatSection = async (state) => {
     bigEndian,
     chunkSize
   } = samplesWithIndex.samplePosition;
-  const { originalTimescale, startInSeconds } = samplesWithIndex.track;
-  const cts = rawCts + startInSeconds * originalTimescale;
-  const dts = rawDts + startInSeconds * originalTimescale;
+  const {
+    originalTimescale,
+    startInSeconds,
+    trackMediaTimeOffsetInTrackTimescale,
+    timescale: trackTimescale
+  } = samplesWithIndex.track;
+  const cts = rawCts + startInSeconds * originalTimescale - trackMediaTimeOffsetInTrackTimescale / trackTimescale * WEBCODECS_TIMESCALE;
+  const dts = rawDts + startInSeconds * originalTimescale - trackMediaTimeOffsetInTrackTimescale / trackTimescale * WEBCODECS_TIMESCALE;
   const bytes = postprocessBytes({
     bytes: iterator.getSlice(samplesWithIndex.samplePosition.size),
     bigEndian,
@@ -13184,7 +13248,8 @@ var parseMpegHeader = async ({
         originalTimescale: 1e6,
         trackId: 0,
         startInSeconds: 0,
-        timescale: WEBCODECS_TIMESCALE
+        timescale: WEBCODECS_TIMESCALE,
+        trackMediaTimeOffsetInTrackTimescale: 0
       },
       registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
       tracks: state.callbacks.tracks,
@@ -14271,7 +14336,8 @@ var handleAacPacket = async ({
       numberOfChannels: channelConfiguration,
       sampleRate,
       startInSeconds: 0,
-      timescale: WEBCODECS_TIMESCALE
+      timescale: WEBCODECS_TIMESCALE,
+      trackMediaTimeOffsetInTrackTimescale: 0
     };
     await registerAudioTrack({
       track,
@@ -14904,7 +14970,8 @@ var parseFmt = async ({
       originalTimescale: 1e6,
       trackId: 0,
       startInSeconds: 0,
-      timescale: WEBCODECS_TIMESCALE
+      timescale: WEBCODECS_TIMESCALE,
+      trackMediaTimeOffsetInTrackTimescale: 0
     },
     container: "wav",
     registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
@@ -15902,9 +15969,11 @@ var parseLoop = async ({
       try {
         await triggerInfoEmit(state);
         await state.controller._internals.checkForAbortAndPause();
+        const parseLoopStart = Date.now();
         const result = await runParseIteration({
           state
         });
+        state.timings.timeInParseLoop += Date.now() - parseLoopStart;
         if (result !== null && result.action === "fetch-more-data") {
           Log.verbose(state.logLevel, `Need to fetch ${result.bytesNeeded} more bytes before we can continue`);
           const startBytesRemaining = state.iterator.bytesRemaining();
@@ -15993,6 +16062,7 @@ var printTimings = (state) => {
   Log.verbose(state.logLevel, `Time seeking: ${state.timings.timeSeeking}ms`);
   Log.verbose(state.logLevel, `Time checking if done: ${state.timings.timeCheckingIfDone}ms`);
   Log.verbose(state.logLevel, `Time freeing data: ${state.timings.timeFreeingData}ms`);
+  Log.verbose(state.logLevel, `Time in parse loop: ${state.timings.timeInParseLoop}ms`);
 };
 
 // src/remotion-license-acknowledge.ts
@@ -17597,7 +17667,8 @@ var timingsState = () => {
     timeReadingData: 0,
     timeSeeking: 0,
     timeCheckingIfDone: 0,
-    timeFreeingData: 0
+    timeFreeingData: 0,
+    timeInParseLoop: 0
   };
 };
 

package/dist/get-tracks.d.ts

@@ -40,6 +40,7 @@ export type MediaParserVideoTrack = {
     advancedColor: MediaParserAdvancedColor;
     m3uStreamFormat: 'ts' | 'mp4' | null;
     startInSeconds: number;
+    trackMediaTimeOffsetInTrackTimescale: number;
 };
 export type MediaParserAudioTrack = {
     codec: string;
@@ -53,6 +54,7 @@ export type MediaParserAudioTrack = {
     originalTimescale: number;
     codecData: MediaParserCodecData | null;
     startInSeconds: number;
+    trackMediaTimeOffsetInTrackTimescale: number;
 };
 export type MediaParserOtherTrack = {
     type: 'other';
@@ -61,6 +63,7 @@ export type MediaParserOtherTrack = {
     originalTimescale: number;
     trakBox: TrakBox | null;
     startInSeconds: number;
+    trackMediaTimeOffsetInTrackTimescale: number;
 };
 export type MediaParserTrack = MediaParserVideoTrack | MediaParserAudioTrack | MediaParserOtherTrack;
 export declare const getNumberOfTracks: (moovBox: MoovBox) => number;

package/dist/index.d.ts

@@ -900,8 +900,8 @@ export declare const MediaParserInternals: {
         };
         iso: {
             flatSamples: {
-                getSamples: (mdatStart: number) => import("./state/iso-base-media/cached-sample-positions").FlatSample[];
-                setSamples: (mdatStart: number, samples: import("./state/iso-base-media/cached-sample-positions").FlatSample[]) => void;
+                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[];
             };
@@ -1027,6 +1027,7 @@ export declare const MediaParserInternals: {
             timeSeeking: number;
             timeCheckingIfDone: number;
             timeFreeingData: number;
+            timeInParseLoop: number;
         };
         callbacks: {
             registerVideoSampleCallback: (id: number, callback: import("./webcodec-sample-types").MediaParserOnVideoSample | null) => Promise<void>;

package/dist/normalize-video-rotation.d.ts

@@ -0,0 +1 @@
+export declare const normalizeVideoRotation: (rotation: number) => number;

package/dist/normalize-video-rotation.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeVideoRotation = void 0;
+const normalizeVideoRotation = (rotation) => {
+    return ((rotation % 360) + 360) % 360;
+};
+exports.normalizeVideoRotation = normalizeVideoRotation;

package/dist/parse-loop.js

@@ -45,9 +45,11 @@ const parseLoop = async ({ state, throttledState, onError, }) => {
             try {
                 await (0, emit_all_info_1.triggerInfoEmit)(state);
                 await state.controller._internals.checkForAbortAndPause();
+                const parseLoopStart = Date.now();
                 const result = await (0, run_parse_iteration_1.runParseIteration)({
                     state,
                 });
+                state.timings.timeInParseLoop += Date.now() - parseLoopStart;
                 if (result !== null && result.action === 'fetch-more-data') {
                     log_1.Log.verbose(state.logLevel, `Need to fetch ${result.bytesNeeded} more bytes before we can continue`);
                     const startBytesRemaining = state.iterator.bytesRemaining();

package/dist/print-timings.js

@@ -8,5 +8,6 @@ const printTimings = (state) => {
     log_1.Log.verbose(state.logLevel, `Time seeking: ${state.timings.timeSeeking}ms`);
     log_1.Log.verbose(state.logLevel, `Time checking if done: ${state.timings.timeCheckingIfDone}ms`);
     log_1.Log.verbose(state.logLevel, `Time freeing data: ${state.timings.timeFreeingData}ms`);
+    log_1.Log.verbose(state.logLevel, `Time in parse loop: ${state.timings.timeInParseLoop}ms`);
 };
 exports.printTimings = printTimings;

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

@@ -21,12 +21,13 @@ export declare const calculateFlatSamples: ({ state, mediaSectionStart, }: {
     state: ParserState;
     mediaSectionStart: number;
 }) => {
-    track: import("../../get-tracks").MediaParserTrack;
-    samplePosition: SamplePosition;
-}[][];
+    flatSamples: Map<number, FlatSample>;
+    offsets: number[];
+    trackIds: number[];
+};
 export declare const cachedSamplePositionsState: () => {
-    getSamples: (mdatStart: number) => FlatSample[];
-    setSamples: (mdatStart: number, samples: FlatSample[]) => void;
+    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[];
 };

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

@@ -28,7 +28,10 @@ const calculateFlatSamples = ({ state, mediaSectionStart, }) => {
     if (!moov) {
         throw new Error('No moov box found');
     }
-    const flatSamples = tracks.map((track) => {
+    const offsets = [];
+    const trackIds = [];
+    const map = new Map();
+    for (const track of tracks) {
         const trakBox = (0, traversal_1.getTrakBoxByTrackId)(moov, track.trackId);
         if (!trakBox) {
             throw new Error('No trak box found');
@@ -39,17 +42,21 @@ const calculateFlatSamples = ({ state, mediaSectionStart, }) => {
             moofComplete,
             trexBoxes: (0, traversal_1.getTrexBoxes)(moov),
         });
-        return samplePositions.map((samplePosition) => {
-            return {
+        trackIds.push(track.trackId);
+        for (const samplePosition of samplePositions) {
+            offsets.push(samplePosition.offset);
+            map.set(samplePosition.offset, {
                 track,
                 samplePosition,
-            };
-        });
-    });
-    return flatSamples;
+            });
+        }
+    }
+    offsets.sort((a, b) => a - b);
+    return { flatSamples: map, offsets, trackIds };
 };
 exports.calculateFlatSamples = calculateFlatSamples;
 const cachedSamplePositionsState = () => {
+    // offset -> flat sample
     const cachedForMdatStart = {};
     const jumpMarksForMdatStart = {};
     return {

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

@@ -12,8 +12,8 @@ export declare const isoBaseMediaState: ({ contentLength, controller, readerInte
     prefetchCache: PrefetchCache;
 }) => {
     flatSamples: {
-        getSamples: (mdatStart: number) => import("./cached-sample-positions").FlatSample[];
-        setSamples: (mdatStart: number, samples: import("./cached-sample-positions").FlatSample[]) => void;
+        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[];
     };

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

@@ -164,8 +164,8 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     };
     iso: {
         flatSamples: {
-            getSamples: (mdatStart: number) => import("./iso-base-media/cached-sample-positions").FlatSample[];
-            setSamples: (mdatStart: number, samples: import("./iso-base-media/cached-sample-positions").FlatSample[]) => void;
+            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[];
         };
@@ -291,6 +291,7 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         timeSeeking: number;
         timeCheckingIfDone: number;
         timeFreeingData: number;
+        timeInParseLoop: number;
     };
     callbacks: {
         registerVideoSampleCallback: (id: number, callback: import("../webcodec-sample-types").MediaParserOnVideoSample | null) => Promise<void>;

package/dist/state/timings.d.ts

@@ -4,5 +4,6 @@ export declare const timingsState: () => {
     timeSeeking: number;
     timeCheckingIfDone: number;
     timeFreeingData: number;
+    timeInParseLoop: number;
 };
 export type TimingsState = ReturnType<typeof timingsState>;

package/dist/state/timings.js

@@ -8,6 +8,7 @@ const timingsState = () => {
         timeSeeking: 0,
         timeCheckingIfDone: 0,
         timeFreeingData: 0,
+        timeInParseLoop: 0,
     };
 };
 exports.timingsState = timingsState;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "4.0.327";
+export declare const VERSION = "4.0.330";

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.327';
+exports.VERSION = '4.0.330';

package/package.json

@@ -3,15 +3,16 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-parser"
   },
   "name": "@remotion/media-parser",
-  "version": "4.0.327",
+  "version": "4.0.330",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
     "@types/wicg-file-system-access": "2023.10.5",
     "eslint": "9.19.0",
+    "mediabunny": "1.3.0",
     "@types/bun": "1.2.8",
-    "@remotion/example-videos": "4.0.327",
-    "@remotion/eslint-config-internal": "4.0.327"
+    "@remotion/example-videos": "4.0.330",
+    "@remotion/eslint-config-internal": "4.0.330"
   },
   "publishConfig": {
     "access": "public"