@remotion/media-parser 4.0.311 → 4.0.312

package/dist/esm/index.mjs

@@ -6860,24 +6860,38 @@ var mediaParserController = () => {
     await pauseSignal.waitUntilResume();
   };
   let seekingHintResolution = null;
+  let simulateSeekResolution = null;
   const getSeekingHints = () => {
     if (!seekingHintResolution) {
       throw new Error("The mediaParserController() was not yet used in a parseMedia() call");
     }
     return seekingHintResolution();
   };
+  const simulateSeek = (seekInSeconds) => {
+    if (!simulateSeekResolution) {
+      throw new Error("The mediaParserController() was not yet used in a parseMedia() call");
+    }
+    return simulateSeekResolution(seekInSeconds);
+  };
   const attachSeekingHintResolution = (callback) => {
     if (seekingHintResolution) {
       throw new Error("The mediaParserController() was used in multiple parseMedia() calls. Create a separate controller for each call.");
     }
     seekingHintResolution = callback;
   };
+  const attachSimulateSeekResolution = (callback) => {
+    if (simulateSeekResolution) {
+      throw new Error("The mediaParserController() was used in multiple parseMedia() calls. Create a separate controller for each call.");
+    }
+    simulateSeekResolution = callback;
+  };
   return {
     abort: (reason) => {
       abortController.abort(reason);
       emitter.dispatchAbort(reason);
     },
     seek: seekSignal.seek,
+    simulateSeek,
     pause: pauseSignal.pause,
     resume: pauseSignal.resume,
     addEventListener: emitter.addEventListener,
@@ -6889,7 +6903,8 @@ var mediaParserController = () => {
       seekSignal,
       markAsReadyToEmitEvents: emitter.markAsReady,
       performedSeeksSignal,
-      attachSeekingHintResolution
+      attachSeekingHintResolution,
+      attachSimulateSeekResolution
     }
   };
 };
@@ -8102,7 +8117,11 @@ var getSeekingByteForAac = ({
     }
   }
   if (bestAudioSample) {
-    return { type: "do-seek", byte: bestAudioSample.offset };
+    return {
+      type: "do-seek",
+      byte: bestAudioSample.offset,
+      timeInSeconds: bestAudioSample.timeInSeconds
+    };
   }
   return { type: "valid-but-must-wait" };
 };
@@ -8129,7 +8148,7 @@ var getSeekingByteForFlac = ({
     }
   }
   if (bestAudioSample) {
-    return bestAudioSample.offset;
+    return bestAudioSample;
   }
   return null;
 };
@@ -8167,7 +8186,7 @@ var findKeyframeBeforeTime = ({
     Log.trace(logLevel, "Found a sample, but the offset has not yet been marked as a video section yet. Not yet able to seek, but probably once we have started reading the next box.", videoSample);
     return null;
   }
-  return videoSample.offset;
+  return videoSample;
 };
 
 // src/containers/iso-base-media/find-track-to-seek.ts
@@ -8398,7 +8417,8 @@ var getSeekingByteFromFragmentedMp4 = async ({
       if (kf) {
         return {
           type: "do-seek",
-          byte: kf
+          byte: kf.offset,
+          timeInSeconds: Math.min(kf.decodingTimestamp, kf.timestamp) / firstTrack.originalTimescale
         };
       }
     }
@@ -8501,7 +8521,8 @@ var getSeekingByteFromIsoBaseMedia = ({
   if (keyframe) {
     return Promise.resolve({
       type: "do-seek",
-      byte: keyframe
+      byte: keyframe.offset,
+      timeInSeconds: Math.min(keyframe.decodingTimestamp, keyframe.timestamp) / track.originalTimescale
     });
   }
   return Promise.resolve({
@@ -8541,7 +8562,8 @@ var getSeekingByteForM3u8 = ({
   }
   return {
     type: "do-seek",
-    byte: currentPosition
+    byte: currentPosition,
+    timeInSeconds: time
   };
 };
 
@@ -8775,9 +8797,12 @@ var getSeekingByteForMp3 = ({
       type: "valid-but-must-wait"
     };
   }
+  const byte = Math.max(...candidates);
+  const timeInSeconds = byte === bestAudioSample?.offset ? bestAudioSample.timeInSeconds : time;
   return {
     type: "do-seek",
-    byte: Math.max(...candidates)
+    byte,
+    timeInSeconds
   };
 };
 
@@ -8821,7 +8846,8 @@ var getSeekingByteForRiff = async ({
     avcState.clear();
     return {
       type: "do-seek",
-      byte: lastKeyframe.positionInBytes
+      byte: lastKeyframe.positionInBytes,
+      timeInSeconds: Math.min(lastKeyframe.decodingTimeInSeconds, lastKeyframe.presentationTimeInSeconds)
     };
   }
   if (idx1Entries.videoTrackIndex === null) {
@@ -8852,121 +8878,8 @@ var getSeekingByteForRiff = async ({
   avcState.clear();
   return {
     type: "do-seek",
-    byte: bestEntry.offset + info.moviOffset - 4
-  };
-};
-
-// src/containers/wav/get-seeking-byte.ts
-var WAVE_SAMPLES_PER_SECOND = 25;
-var getSeekingByteFromWav = ({
-  info,
-  time
-}) => {
-  const bytesPerSecond = info.sampleRate * info.blockAlign;
-  const durationInSeconds = info.mediaSection.size / bytesPerSecond;
-  const timeRoundedDown = Math.floor(Math.min(time, durationInSeconds - 0.0000001) * WAVE_SAMPLES_PER_SECOND) / WAVE_SAMPLES_PER_SECOND;
-  const byteOffset = bytesPerSecond * timeRoundedDown;
-  return Promise.resolve({
-    type: "do-seek",
-    byte: byteOffset + info.mediaSection.start
-  });
-};
-
-// src/containers/webm/seek/get-seeking-byte.ts
-var toSeconds = (timeInTimescale, track) => {
-  return timeInTimescale / track.timescale * 1000;
-};
-var findBiggestCueBeforeTime = ({
-  cues,
-  time,
-  track
-}) => {
-  let biggestCueBeforeTime;
-  for (const cue of cues) {
-    const cueTimeInSeconds = toSeconds(cue.timeInTimescale, track);
-    if (cueTimeInSeconds < time && (!biggestCueBeforeTime || cueTimeInSeconds > toSeconds(biggestCueBeforeTime.timeInTimescale, track))) {
-      biggestCueBeforeTime = cue;
-    }
-  }
-  return biggestCueBeforeTime;
-};
-var findKeyframeBeforeTime2 = ({
-  keyframes,
-  time
-}) => {
-  let keyframeBeforeTime;
-  for (const keyframe of keyframes) {
-    if (keyframe.decodingTimeInSeconds < time && (!keyframeBeforeTime || keyframe.decodingTimeInSeconds > keyframeBeforeTime.decodingTimeInSeconds)) {
-      keyframeBeforeTime = keyframe;
-    }
-  }
-  return keyframeBeforeTime?.positionInBytes ?? null;
-};
-var getByteFromCues = ({
-  cuesResponse,
-  time,
-  info,
-  logLevel
-}) => {
-  if (!cuesResponse) {
-    Log.trace(logLevel, "Has no Matroska cues at the moment, cannot use them");
-    return null;
-  }
-  const { cues, segmentOffset } = cuesResponse;
-  Log.trace(logLevel, "Has Matroska cues. Will use them to perform a seek.");
-  const biggestCueBeforeTime = findBiggestCueBeforeTime({
-    cues,
-    time,
-    track: info.track
-  });
-  if (!biggestCueBeforeTime) {
-    return null;
-  }
-  return biggestCueBeforeTime.clusterPositionInSegment + segmentOffset;
-};
-var getSeekingByteFromMatroska = async ({
-  time,
-  webmState,
-  info,
-  logLevel,
-  mediaSection
-}) => {
-  if (!info.track) {
-    Log.trace(logLevel, "No video track found, cannot seek yet");
-    return {
-      type: "valid-but-must-wait"
-    };
-  }
-  const cuesResponse = info.loadedCues ?? await webmState.cues.getLoadedCues();
-  const byteFromObservedKeyframe = findKeyframeBeforeTime2({
-    keyframes: info.keyframes,
-    time
-  });
-  const byteFromCues = getByteFromCues({
-    cuesResponse,
-    time,
-    info,
-    logLevel
-  });
-  const byteFromFirstMediaSection = webmState.getFirstCluster()?.start ?? null;
-  const seekPossibilities = [
-    byteFromCues,
-    byteFromObservedKeyframe,
-    byteFromFirstMediaSection
-  ].filter((n) => n !== null);
-  const byteToSeekTo = seekPossibilities.length === 0 ? null : Math.max(...seekPossibilities);
-  if (byteToSeekTo === null) {
-    return {
-      type: "invalid"
-    };
-  }
-  mediaSection.addMediaSection({
-    start: byteToSeekTo,
-    size: 1
-  });
-  return {
-    type: "do-seek",
-    byte: byteToSeekTo
+    byte: bestEntry.offset + info.moviOffset - 4,
+    timeInSeconds: bestEntry.sampleCounts[idx1Entries.videoTrackIndex] / info.samplesPerSecond
   };
 };
 
@@ -9137,6 +9050,137 @@ var handleAvcPacket = async ({
   transportStream.lastEmittedSample.setLastEmittedSample(sample);
 };
 
+// src/containers/wav/get-seeking-byte.ts
+var WAVE_SAMPLES_PER_SECOND = 25;
+var getSeekingByteFromWav = ({
+  info,
+  time
+}) => {
+  const bytesPerSecond = info.sampleRate * info.blockAlign;
+  const durationInSeconds = info.mediaSection.size / bytesPerSecond;
+  const timeRoundedDown = Math.floor(Math.min(time, durationInSeconds - 0.0000001) * WAVE_SAMPLES_PER_SECOND) / WAVE_SAMPLES_PER_SECOND;
+  const byteOffset = bytesPerSecond * timeRoundedDown;
+  return Promise.resolve({
+    type: "do-seek",
+    byte: byteOffset + info.mediaSection.start,
+    timeInSeconds: timeRoundedDown
+  });
+};
+
+// src/containers/webm/seek/get-seeking-byte.ts
+var toSeconds = (timeInTimescale, track) => {
+  return timeInTimescale / track.timescale * 1000;
+};
+var findBiggestCueBeforeTime = ({
+  cues,
+  time,
+  track
+}) => {
+  let biggestCueBeforeTime;
+  for (const cue of cues) {
+    const cueTimeInSeconds = toSeconds(cue.timeInTimescale, track);
+    if (cueTimeInSeconds < time && (!biggestCueBeforeTime || cueTimeInSeconds > toSeconds(biggestCueBeforeTime.timeInTimescale, track))) {
+      biggestCueBeforeTime = cue;
+    }
+  }
+  return biggestCueBeforeTime;
+};
+var findKeyframeBeforeTime2 = ({
+  keyframes,
+  time
+}) => {
+  let keyframeBeforeTime;
+  for (const keyframe of keyframes) {
+    if (keyframe.decodingTimeInSeconds < time && (!keyframeBeforeTime || keyframe.decodingTimeInSeconds > keyframeBeforeTime.decodingTimeInSeconds)) {
+      keyframeBeforeTime = keyframe;
+    }
+  }
+  return keyframeBeforeTime ?? null;
+};
+var getByteFromCues = ({
+  cuesResponse,
+  time,
+  info,
+  logLevel
+}) => {
+  if (!cuesResponse) {
+    Log.trace(logLevel, "Has no Matroska cues at the moment, cannot use them");
+    return null;
+  }
+  const { cues, segmentOffset } = cuesResponse;
+  Log.trace(logLevel, "Has Matroska cues. Will use them to perform a seek.");
+  const biggestCueBeforeTime = findBiggestCueBeforeTime({
+    cues,
+    time,
+    track: info.track
+  });
+  if (!biggestCueBeforeTime) {
+    return null;
+  }
+  return {
+    byte: biggestCueBeforeTime.clusterPositionInSegment + segmentOffset,
+    timeInSeconds: toSeconds(biggestCueBeforeTime.timeInTimescale, info.track)
+  };
+};
+var getSeekingByteFromMatroska = async ({
+  time,
+  webmState,
+  info,
+  logLevel,
+  mediaSection
+}) => {
+  if (!info.track) {
+    Log.trace(logLevel, "No video track found, cannot seek yet");
+    return {
+      type: "valid-but-must-wait"
+    };
+  }
+  const cuesResponse = info.loadedCues ?? await webmState.cues.getLoadedCues();
+  const byteFromObservedKeyframe = findKeyframeBeforeTime2({
+    keyframes: info.keyframes,
+    time
+  });
+  const byteFromCues = getByteFromCues({
+    cuesResponse,
+    time,
+    info,
+    logLevel
+  });
+  const byteFromFirstMediaSection = webmState.getFirstCluster()?.start ?? null;
+  const seekPossibilities = [
+    byteFromCues?.byte ?? null,
+    byteFromObservedKeyframe?.positionInBytes ?? null,
+    byteFromFirstMediaSection
+  ].filter((n) => n !== null);
+  const byteToSeekTo = seekPossibilities.length === 0 ? null : Math.max(...seekPossibilities);
+  if (byteToSeekTo === null) {
+    return {
+      type: "invalid"
+    };
+  }
+  mediaSection.addMediaSection({
+    start: byteToSeekTo,
+    size: 1
+  });
+  const timeInSeconds = (() => {
+    if (byteToSeekTo === byteFromObservedKeyframe?.positionInBytes) {
+      return Math.min(byteFromObservedKeyframe.decodingTimeInSeconds, byteFromObservedKeyframe.presentationTimeInSeconds);
+    }
+    if (byteToSeekTo === byteFromCues?.byte) {
+      return byteFromCues.timeInSeconds;
+    }
+    if (byteToSeekTo === byteFromFirstMediaSection) {
+      return 0;
+    }
+    throw new Error("Should not happen");
+  })();
+  return {
+    type: "do-seek",
+    byte: byteToSeekTo,
+    timeInSeconds
+  };
+};
+
 // src/state/transport-stream/observed-pes-header.ts
 var makeObservedPesHeader = () => {
   const pesHeaders = [];
@@ -9226,7 +9270,8 @@ var getSeekingByte = ({
     if (byte) {
       return Promise.resolve({
         type: "do-seek",
-        byte
+        byte: byte.offset,
+        timeInSeconds: byte.timeInSeconds
       });
     }
     return Promise.resolve({
@@ -9239,11 +9284,20 @@ var getSeekingByte = ({
       timeInSeconds: time,
       ptsStartOffset: info.ptsStartOffset
     });
-    const byte = lastKeyframeBeforeTimeInSeconds?.offset ?? 0;
+    if (!lastKeyframeBeforeTimeInSeconds) {
+      transportStream.resetBeforeSeek();
+      return Promise.resolve({
+        type: "do-seek",
+        byte: 0,
+        timeInSeconds: 0
+      });
+    }
+    const byte = lastKeyframeBeforeTimeInSeconds.offset;
     transportStream.resetBeforeSeek();
     return Promise.resolve({
       type: "do-seek",
-      byte
+      byte,
+      timeInSeconds: Math.min(lastKeyframeBeforeTimeInSeconds.pts, lastKeyframeBeforeTimeInSeconds.dts ?? Infinity) / MPEG_TIMESCALE
     });
   }
   if (info.type === "riff-seeking-hints") {
@@ -15039,10 +15093,11 @@ var parseList = ({
   const metadata = [];
   const remainingBytes = () => ckSize - (iterator.counter.getOffset() - startOffset);
   while (remainingBytes() > 0) {
-    if (remainingBytes() < 4) {
-      iterator.discard(remainingBytes());
-      break;
+    const byte = iterator.getUint8();
+    if (byte === 0) {
+      continue;
     }
+    iterator.counter.decrement(1);
     const key = iterator.getByteString(4, false);
     const size = iterator.getUint32Le();
     const value = iterator.getByteString(size, true);
@@ -17598,6 +17653,46 @@ var internalParseMedia = async function({
     contentLength: state.contentLength,
     aacState: state.aac
   })));
+  controller._internals.attachSimulateSeekResolution((seek2) => {
+    const {
+      aacState: aacState2,
+      avcState: avcState2,
+      flacState: flacState2,
+      isoState,
+      iterator,
+      keyframes,
+      m3uState: m3uState2,
+      mediaSection,
+      mp3State,
+      riffState,
+      samplesObserved,
+      structureState: structureState2,
+      tracksState,
+      transportStream,
+      webmState: webmState2
+    } = getWorkOnSeekRequestOptions(state);
+    return turnSeekIntoByte({
+      aacState: aacState2,
+      seek: seek2,
+      avcState: avcState2,
+      contentLength,
+      flacState: flacState2,
+      isoState,
+      iterator,
+      keyframes,
+      logLevel,
+      m3uPlaylistContext,
+      m3uState: m3uState2,
+      mediaSectionState: mediaSection,
+      mp3State,
+      riffState,
+      samplesObserved,
+      structureState: structureState2,
+      tracksState,
+      transportStream,
+      webmState: webmState2
+    });
+  });
   if (!hasAudioTrackHandlers && !hasVideoTrackHandlers && Object.values(state.fields).every((v) => !v) && mode === "query") {
     Log.warn(logLevel, new Error("Warning - No `fields` and no `on*` callbacks were passed to `parseMedia()`. Specify the data you would like to retrieve."));
   }
@@ -17699,7 +17794,7 @@ var downloadAndParseMedia = async (options) => {
   return returnValue;
 };
 // src/version.ts
-var VERSION = "4.0.311";
+var VERSION = "4.0.312";
 
 // src/index.ts
 var MediaParserInternals = {

package/dist/esm/server-worker.mjs

@@ -243,6 +243,14 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
     seekingHintPromises.push(prom);
     return prom.promise;
   });
+  const simulateSeekPromises = {};
+  controller?._internals.attachSimulateSeekResolution((seek) => {
+    const prom = withResolvers();
+    const nonce = String(Math.random());
+    post(worker, { type: "request-simulate-seek", payload: seek, nonce });
+    simulateSeekPromises[nonce] = prom;
+    return prom.promise;
+  });
   const callbacks = {};
   function onMessage(message) {
     const data = message.data;
@@ -462,6 +470,15 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
       firstPromise.resolve(data.payload);
       return;
     }
+    if (data.type === "response-simulate-seek") {
+      const prom = simulateSeekPromises[data.nonce];
+      if (!prom) {
+        throw new Error("No simulate seek promise found");
+      }
+      prom.resolve(data.payload);
+      delete simulateSeekPromises[data.nonce];
+      return;
+    }
     throw new Error(`Unknown response type: ${JSON.stringify(data)}`);
   }
   worker.addEventListener("message", onMessage);