@remotion/media-parser 4.0.288 → 4.0.290

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

@@ -4909,24 +4909,45 @@ var getSamplesPerMpegFrame = ({
 };
 
 // src/containers/mp3/get-duration.ts
+var getDurationFromMp3Xing = ({
+  xingData,
+  samplesPerFrame
+}) => {
+  const xingFrames = xingData.numberOfFrames;
+  if (!xingFrames) {
+    throw new Error("Cannot get duration of VBR MP3 file - no frames");
+  }
+  const { sampleRate } = xingData;
+  if (!sampleRate) {
+    throw new Error("Cannot get duration of VBR MP3 file - no sample rate");
+  }
+  const xingSamples = xingFrames * samplesPerFrame;
+  return xingSamples / sampleRate;
+};
 var getDurationFromMp3 = (state) => {
-  const mp3Info = state.mp3Info.getMp3Info();
-  const mp3CbrInfo = state.mp3Info.getCbrMp3Info();
-  if (!mp3Info || !mp3CbrInfo) {
+  const mp3Info = state.mp3.getMp3Info();
+  const mp3BitrateInfo = state.mp3.getMp3BitrateInfo();
+  if (!mp3Info || !mp3BitrateInfo) {
     return null;
   }
   const samplesPerFrame = getSamplesPerMpegFrame({
     layer: mp3Info.layer,
     mpegVersion: mp3Info.mpegVersion
   });
+  if (mp3BitrateInfo.type === "variable") {
+    return getDurationFromMp3Xing({
+      xingData: mp3BitrateInfo.xingData,
+      samplesPerFrame
+    });
+  }
   const frameLengthInBytes = getMpegFrameLength({
-    bitrateKbit: mp3CbrInfo.bitrateKbit,
+    bitrateKbit: mp3BitrateInfo.bitrateInKbit,
     padding: false,
     samplesPerFrame,
     samplingFrequency: mp3Info.sampleRate,
     layer: mp3Info.layer
   });
-  const frames = Math.floor((state.contentLength - mp3Info.startOfMpegStream) / frameLengthInBytes);
+  const frames = Math.floor((state.contentLength - state.mediaSection.getMediaSectionAssertOnlyOne().start) / frameLengthInBytes);
   const samples = frames * samplesPerFrame;
   const durationInSeconds = samples / mp3Info.sampleRate;
   return durationInSeconds;
@@ -5465,6 +5486,60 @@ var hasSampleRate = (state) => {
   return state.callbacks.tracks.hasAllTracks();
 };
 
+// src/containers/aac/get-seeking-byte.ts
+var getSeekingByteForAac = ({
+  time,
+  seekingHints
+}) => {
+  let bestAudioSample;
+  for (const hint of seekingHints.audioSampleMap) {
+    if (hint.timeInSeconds > time) {
+      continue;
+    }
+    if (hint.timeInSeconds + hint.durationInSeconds < time && !seekingHints.lastSampleObserved) {
+      continue;
+    }
+    if (!bestAudioSample) {
+      bestAudioSample = hint;
+      continue;
+    }
+    if (bestAudioSample.timeInSeconds < hint.timeInSeconds) {
+      bestAudioSample = hint;
+    }
+  }
+  if (bestAudioSample) {
+    return { type: "do-seek", byte: bestAudioSample.offset };
+  }
+  return { type: "valid-but-must-wait" };
+};
+
+// src/containers/flac/get-seeking-byte.ts
+var getSeekingByteForFlac = ({
+  time,
+  seekingHints
+}) => {
+  let bestAudioSample;
+  for (const hint of seekingHints.audioSampleMap) {
+    if (hint.timeInSeconds > time) {
+      continue;
+    }
+    if (hint.timeInSeconds + hint.durationInSeconds < time && !seekingHints.lastSampleObserved) {
+      continue;
+    }
+    if (!bestAudioSample) {
+      bestAudioSample = hint;
+      continue;
+    }
+    if (bestAudioSample.timeInSeconds < hint.timeInSeconds) {
+      bestAudioSample = hint;
+    }
+  }
+  if (bestAudioSample) {
+    return bestAudioSample.offset;
+  }
+  return null;
+};
+
 // src/state/video-section.ts
 var isByteInMediaSection = ({
   position,
@@ -5734,6 +5809,312 @@ var getSeekingByteFromIsoBaseMedia = async ({
   };
 };
 
+// src/containers/mp3/seek/get-approximate-byte-from-bitrate.ts
+var getApproximateByteFromBitrate = ({
+  mp3BitrateInfo,
+  timeInSeconds,
+  mp3Info,
+  mediaSection,
+  contentLength
+}) => {
+  if (mp3BitrateInfo.type === "variable") {
+    return null;
+  }
+  const samplesPerFrame = getSamplesPerMpegFrame({
+    layer: mp3Info.layer,
+    mpegVersion: mp3Info.mpegVersion
+  });
+  const frameLengthInBytes = getMpegFrameLength({
+    bitrateKbit: mp3BitrateInfo.bitrateInKbit,
+    padding: false,
+    samplesPerFrame,
+    samplingFrequency: mp3Info.sampleRate,
+    layer: mp3Info.layer
+  });
+  const frameIndexUnclamped = Math.floor(timeInSeconds * mp3Info.sampleRate / samplesPerFrame);
+  const frames = Math.floor((contentLength - mediaSection.start) / frameLengthInBytes);
+  const frameIndex = Math.min(frames - 1, frameIndexUnclamped);
+  const byteRelativeToMediaSection = frameIndex * frameLengthInBytes;
+  const byteBeforeFrame = byteRelativeToMediaSection + mediaSection.start;
+  return byteBeforeFrame;
+};
+
+// src/containers/mp3/seek/get-byte-from-observed-samples.ts
+var getByteFromObservedSamples = ({
+  info,
+  timeInSeconds
+}) => {
+  let bestAudioSample;
+  for (const hint of info.audioSampleMap) {
+    if (hint.timeInSeconds > timeInSeconds) {
+      continue;
+    }
+    if (hint.timeInSeconds + hint.durationInSeconds < timeInSeconds && !info.lastSampleObserved) {
+      continue;
+    }
+    if (!bestAudioSample) {
+      bestAudioSample = hint;
+      continue;
+    }
+    if (bestAudioSample.timeInSeconds < hint.timeInSeconds) {
+      bestAudioSample = hint;
+    }
+  }
+  return bestAudioSample;
+};
+
+// src/containers/mp3/parse-xing.ts
+var SAMPLE_RATES = [44100, 48000, 32000, 99999];
+var FRAMES_FLAG = 1;
+var BYTES_FLAG = 2;
+var TOC_FLAG = 4;
+var VBR_SCALE_FLAG = 8;
+var extractI4 = (data, offset) => {
+  let x = 0;
+  x = data[offset];
+  x <<= 8;
+  x |= data[offset + 1];
+  x <<= 8;
+  x |= data[offset + 2];
+  x <<= 8;
+  x |= data[offset + 3];
+  return x;
+};
+var parseXing = (data) => {
+  const h_id = data[1] >> 3 & 1;
+  const h_sr_index = data[2] >> 2 & 3;
+  const h_mode = data[3] >> 6 & 3;
+  let xingOffset = 0;
+  if (h_id) {
+    if (h_mode !== 3) {
+      xingOffset += 32 + 4;
+    } else {
+      xingOffset += 17 + 4;
+    }
+  } else if (h_mode !== 3) {
+    xingOffset += 17 + 4;
+  } else {
+    xingOffset += 9 + 4;
+  }
+  const expectXing = new TextDecoder("utf8").decode(data.slice(xingOffset, xingOffset + 4));
+  if (expectXing !== "Xing") {
+    throw new Error("Invalid Xing header");
+  }
+  let sampleRate = SAMPLE_RATES[h_sr_index];
+  if (h_id === 0) {
+    sampleRate >>= 1;
+  }
+  let offset = xingOffset + 4;
+  const flags = extractI4(data, offset);
+  offset += 4;
+  let numberOfFrames;
+  let fileSize;
+  let tableOfContents;
+  let vbrScale;
+  if (flags & FRAMES_FLAG) {
+    numberOfFrames = extractI4(data, offset);
+    offset += 4;
+  }
+  if (flags & BYTES_FLAG) {
+    fileSize = extractI4(data, offset);
+    offset += 4;
+  }
+  if (flags & TOC_FLAG) {
+    tableOfContents = data.slice(offset, offset + 100);
+    offset += 100;
+  }
+  if (flags & VBR_SCALE_FLAG) {
+    vbrScale = extractI4(data, offset);
+    offset += 4;
+  }
+  if (offset !== data.length) {
+    throw new Error("xing header was parsed wrong: " + JSON.stringify(data));
+  }
+  return {
+    sampleRate,
+    numberOfFrames: numberOfFrames ?? null,
+    fileSize: fileSize ?? null,
+    tableOfContents: tableOfContents ? Array.from(tableOfContents.slice(0, 100)) : null,
+    vbrScale: vbrScale ?? null
+  };
+};
+var getSeekPointInBytes = ({
+  fileSize,
+  percentBetween0And100,
+  tableOfContents
+}) => {
+  let index = Math.floor(percentBetween0And100);
+  if (index > 99) {
+    index = 99;
+  }
+  const fa = tableOfContents[index];
+  let fb;
+  if (index < 99) {
+    fb = tableOfContents[index + 1];
+  } else {
+    fb = 256;
+  }
+  const fx = fa + (fb - fa) * (percentBetween0And100 - index);
+  const seekPoint = 1 / 256 * fx * fileSize;
+  return Math.floor(seekPoint);
+};
+var getTimeFromPosition = ({
+  position,
+  fileSize,
+  tableOfContents,
+  durationInSeconds
+}) => {
+  const positionNormalized = position / fileSize * 256;
+  let index = 0;
+  while (index < 99 && tableOfContents[index + 1] <= positionNormalized) {
+    index++;
+  }
+  const fa = tableOfContents[index];
+  const fb = index < 99 ? tableOfContents[index + 1] : 256;
+  const percentWithinSegment = (positionNormalized - fa) / (fb - fa);
+  const percentBetween0And100 = index + percentWithinSegment;
+  return percentBetween0And100 / 100 * durationInSeconds;
+};
+
+// src/containers/mp3/seek/get-seek-point-from-xing.ts
+var getSeekPointFromXing = ({
+  timeInSeconds,
+  xingData,
+  mp3Info
+}) => {
+  const samplesPerFrame = getSamplesPerMpegFrame({
+    layer: mp3Info.layer,
+    mpegVersion: mp3Info.mpegVersion
+  });
+  const duration2 = getDurationFromMp3Xing({
+    xingData,
+    samplesPerFrame
+  });
+  const totalSamples = timeInSeconds * xingData.sampleRate;
+  const oneFrameSubtracted = totalSamples - samplesPerFrame;
+  const timeToTarget = Math.max(0, oneFrameSubtracted / xingData.sampleRate);
+  if (!xingData.fileSize || !xingData.tableOfContents) {
+    throw new Error("Cannot seek of VBR MP3 file");
+  }
+  return getSeekPointInBytes({
+    fileSize: xingData.fileSize,
+    percentBetween0And100: timeToTarget / duration2 * 100,
+    tableOfContents: xingData.tableOfContents
+  });
+};
+
+// src/containers/mp3/get-seeking-byte.ts
+var getSeekingByteForMp3 = ({
+  time,
+  info
+}) => {
+  if (info.mp3BitrateInfo === null || info.mp3Info === null || info.mediaSection === null) {
+    return {
+      type: "valid-but-must-wait"
+    };
+  }
+  const approximateByte = getApproximateByteFromBitrate({
+    mp3BitrateInfo: info.mp3BitrateInfo,
+    timeInSeconds: time,
+    mp3Info: info.mp3Info,
+    mediaSection: info.mediaSection,
+    contentLength: info.contentLength
+  });
+  const bestAudioSample = getByteFromObservedSamples({
+    info,
+    timeInSeconds: time
+  });
+  const xingSeekPoint = info.mp3BitrateInfo.type === "variable" ? getSeekPointFromXing({
+    mp3Info: info.mp3Info,
+    timeInSeconds: time,
+    xingData: info.mp3BitrateInfo.xingData
+  }) : null;
+  const candidates = [
+    approximateByte,
+    bestAudioSample?.offset ?? null,
+    xingSeekPoint
+  ].filter((b) => b !== null);
+  if (candidates.length === 0) {
+    return {
+      type: "valid-but-must-wait"
+    };
+  }
+  return {
+    type: "do-seek",
+    byte: Math.max(...candidates)
+  };
+};
+
+// src/find-last-keyframe.ts
+function findLastKeyframe({
+  keyframes,
+  timeInSeconds
+}) {
+  let bestKeyframe = null;
+  for (const keyframe of keyframes) {
+    if (keyframe.presentationTimeInSeconds > timeInSeconds && keyframe.decodingTimeInSeconds > timeInSeconds) {
+      break;
+    }
+    if (bestKeyframe === null || keyframe.presentationTimeInSeconds > bestKeyframe.presentationTimeInSeconds) {
+      bestKeyframe = keyframe;
+    }
+  }
+  return bestKeyframe;
+}
+
+// src/containers/riff/get-seeking-byte.ts
+var getSeekingByteForRiff = async ({
+  info,
+  time,
+  riffState
+}) => {
+  const idx1Entries = await (info.hasIndex ? riffState.lazyIdx1.waitForLoaded() : Promise.resolve(null));
+  if (idx1Entries === null) {
+    const lastKeyframe = findLastKeyframe({
+      keyframes: info.observedKeyframes,
+      timeInSeconds: time
+    });
+    if (lastKeyframe === null) {
+      return {
+        type: "valid-but-must-wait"
+      };
+    }
+    riffState.sampleCounter.setSamplesFromSeek(lastKeyframe.sampleCounts);
+    return {
+      type: "do-seek",
+      byte: lastKeyframe.positionInBytes
+    };
+  }
+  if (idx1Entries.videoTrackIndex === null) {
+    throw new Error("videoTrackIndex is null");
+  }
+  if (info.samplesPerSecond === null) {
+    throw new Error("samplesPerSecond is null");
+  }
+  const index = Math.floor(time * info.samplesPerSecond);
+  let bestEntry = null;
+  for (const entry of idx1Entries.entries) {
+    if (entry.sampleCounts[idx1Entries.videoTrackIndex] > index) {
+      continue;
+    }
+    if (bestEntry && entry.sampleCounts[idx1Entries.videoTrackIndex] < bestEntry.sampleCounts[idx1Entries.videoTrackIndex]) {
+      continue;
+    }
+    bestEntry = entry;
+  }
+  if (!bestEntry) {
+    throw new Error("No best entry");
+  }
+  if (info.moviOffset === null) {
+    throw new Error("moviOffset is null");
+  }
+  riffState.sampleCounter.setSamplesFromSeek(bestEntry.sampleCounts);
+  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 = ({
@@ -5880,22 +6261,6 @@ var convertAudioOrVideoSampleToWebCodecsTimestamps = ({
   };
 };
 
-// src/emit-audio-sample.ts
-var emitAudioSample = async ({
-  trackId,
-  audioSample,
-  callbacks
-}) => {
-  await callbacks.onAudioSample(trackId, audioSample);
-};
-var emitVideoSample = async ({
-  trackId,
-  videoSample,
-  callbacks
-}) => {
-  await callbacks.onVideoSample(trackId, videoSample);
-};
-
 // src/register-track.ts
 var registerVideoTrack = async ({
   track,
@@ -6320,14 +6685,11 @@ var handleAvcPacket = async ({
   if (type === "key") {
     transportStream.observedPesHeaders.markPtsAsKeyframe(streamBuffer.pesHeader.pts);
   }
-  await emitVideoSample({
-    trackId: programId,
-    videoSample: convertAudioOrVideoSampleToWebCodecsTimestamps({
-      sample,
-      timescale: MPEG_TIMESCALE
-    }),
-    callbacks: sampleCallbacks
+  const videoSample = convertAudioOrVideoSampleToWebCodecsTimestamps({
+    sample,
+    timescale: MPEG_TIMESCALE
   });
+  await sampleCallbacks.onVideoSample(programId, videoSample);
   transportStream.lastEmittedSample.setLastEmittedSample(sample);
 };
 
@@ -6381,7 +6743,8 @@ var getSeekingByte = ({
   webmState,
   mediaSection,
   mp4HeaderSegment,
-  structure
+  structure,
+  riffState
 }) => {
   if (info.type === "iso-base-media-seeking-hints") {
     return getSeekingByteFromIsoBaseMedia({
@@ -6409,6 +6772,21 @@ var getSeekingByte = ({
       mediaSection
     });
   }
+  if (info.type === "flac-seeking-hints") {
+    const byte = getSeekingByteForFlac({
+      seekingHints: info,
+      time
+    });
+    if (byte) {
+      return Promise.resolve({
+        type: "do-seek",
+        byte
+      });
+    }
+    return Promise.resolve({
+      type: "valid-but-must-wait"
+    });
+  }
   if (info.type === "transport-stream-seeking-hints") {
     const lastKeyframeBeforeTimeInSeconds = getLastKeyFrameBeforeTimeInSeconds({
       observedPesHeaders: info.observedPesHeaders,
@@ -6422,9 +6800,63 @@ var getSeekingByte = ({
       byte
     });
   }
+  if (info.type === "riff-seeking-hints") {
+    return getSeekingByteForRiff({
+      info,
+      time,
+      riffState
+    });
+  }
+  if (info.type === "mp3-seeking-hints") {
+    return Promise.resolve(getSeekingByteForMp3({
+      info,
+      time
+    }));
+  }
+  if (info.type === "aac-seeking-hints") {
+    return Promise.resolve(getSeekingByteForAac({
+      time,
+      seekingHints: info
+    }));
+  }
   throw new Error(`Unknown seeking info type: ${info}`);
 };
 
+// src/containers/aac/seeking-hints.ts
+var getSeekingHintsForAac = ({
+  aacState,
+  samplesObserved
+}) => {
+  return {
+    type: "aac-seeking-hints",
+    audioSampleMap: aacState.audioSamples.getSamples(),
+    lastSampleObserved: samplesObserved.getLastSampleObserved()
+  };
+};
+var setSeekingHintsForAac = () => {};
+
+// src/containers/flac/seeking-hints.ts
+var getSeekingHintsForFlac = ({
+  flacState,
+  samplesObserved
+}) => {
+  return {
+    type: "flac-seeking-hints",
+    audioSampleMap: flacState.audioSamples.getSamples(),
+    blockingBitStrategy: flacState.getBlockingBitStrategy() ?? null,
+    lastSampleObserved: samplesObserved.getLastSampleObserved()
+  };
+};
+var setSeekingHintsForFlac = ({
+  hints,
+  state
+}) => {
+  if (hints.blockingBitStrategy !== null) {
+    state.flac.setBlockingBitStrategy(hints.blockingBitStrategy);
+  }
+  state.flac.audioSamples.setFromSeekingHints(hints.audioSampleMap);
+};
+
 // src/state/iso-base-media/precomputed-tfra.ts
 var precomputedTfraState = () => {
   let tfraBoxes = [];
@@ -6475,6 +6907,72 @@ var getSeekingHintsFromMp4 = ({
 };
 var setSeekingHintsForMp4 = ({}) => {};
 
+// src/containers/mp3/seeking-hints.ts
+var getSeekingHintsForMp3 = ({
+  mp3State,
+  samplesObserved,
+  mediaSectionState: mediaSectionState2,
+  contentLength
+}) => {
+  return {
+    type: "mp3-seeking-hints",
+    audioSampleMap: mp3State.audioSamples.getSamples(),
+    lastSampleObserved: samplesObserved.getLastSampleObserved(),
+    mp3BitrateInfo: mp3State.getMp3BitrateInfo(),
+    mp3Info: mp3State.getMp3Info(),
+    mediaSection: mediaSectionState2.getMediaSections()[0] ?? null,
+    contentLength
+  };
+};
+var setSeekingHintsForMp3 = ({
+  hints,
+  state
+}) => {
+  state.mp3.audioSamples.setFromSeekingHints(hints.audioSampleMap);
+};
+
+// src/containers/riff/has-index.ts
+var riffHasIndex = (structure) => {
+  return structure.boxes.find((b) => b.type === "list-box" && b.listType === "hdrl")?.children.find((box) => box.type === "avih-box")?.hasIndex ?? false;
+};
+
+// src/containers/riff/seeking-hints.ts
+var getSeekingHintsForRiff = ({
+  structureState,
+  riffState,
+  mediaSectionState: mediaSectionState2
+}) => {
+  const structure = structureState.getRiffStructure();
+  const strl = getStrlBoxes(structure);
+  let samplesPerSecond = null;
+  for (const s of strl) {
+    const strh = getStrhBox(s.children);
+    if (!strh) {
+      throw new Error("No strh box");
+    }
+    if (strh.strf.type !== "strf-box-video") {
+      continue;
+    }
+    samplesPerSecond = strh.rate / strh.scale;
+    break;
+  }
+  return {
+    type: "riff-seeking-hints",
+    hasIndex: riffHasIndex(structure),
+    idx1Entries: riffState.lazyIdx1.getIfAlreadyLoaded(),
+    samplesPerSecond,
+    moviOffset: mediaSectionState2.getMediaSections()[0]?.start ?? null,
+    observedKeyframes: riffState.sampleCounter.riffKeys.getKeyframes()
+  };
+};
+var setSeekingHintsForRiff = ({
+  hints,
+  state
+}) => {
+  state.riff.lazyIdx1.setFromSeekingHints(hints);
+  state.riff.sampleCounter.riffKeys.setFromSeekingHints(hints.observedKeyframes);
+};
+
 // src/containers/transport-stream/seeking-hints.ts
 var getSeekingHintsFromTransportStream = (transportStream, tracksState) => {
   const firstVideoTrack = tracksState.getTracks().find((t) => t.type === "video");
@@ -6548,7 +7046,7 @@ var setSeekingHintsForWebm = ({
   state
 }) => {
   state.webm.cues.setFromSeekingHints(hints);
-  state.keyframes.setFromSeekingHints(hints);
+  state.keyframes.setFromSeekingHints(hints.keyframes);
   state.webm.setTimeStampMapForSeekingHints(hints.timestampMap);
 };
 
@@ -6561,7 +7059,13 @@ var getSeekingHints = ({
   transportStream,
   tracksState,
   keyframesState,
-  webmState
+  webmState,
+  flacState,
+  samplesObserved,
+  riffState,
+  mp3State,
+  contentLength,
+  aacState
 }) => {
   const structure = structureState.getStructureOrNull();
   if (!structure) {
@@ -6587,6 +7091,33 @@ var getSeekingHints = ({
   if (structure.type === "transport-stream") {
     return getSeekingHintsFromTransportStream(transportStream, tracksState);
   }
+  if (structure.type === "flac") {
+    return getSeekingHintsForFlac({
+      flacState,
+      samplesObserved
+    });
+  }
+  if (structure.type === "riff") {
+    return getSeekingHintsForRiff({
+      structureState,
+      riffState,
+      mediaSectionState: mediaSectionState2
+    });
+  }
+  if (structure.type === "mp3") {
+    return getSeekingHintsForMp3({
+      mp3State,
+      samplesObserved,
+      mediaSectionState: mediaSectionState2,
+      contentLength
+    });
+  }
+  if (structure.type === "aac") {
+    return getSeekingHintsForAac({
+      aacState,
+      samplesObserved
+    });
+  }
   throw new Error(`Seeking is not supported for this format: ${structure.type}`);
 };
 
@@ -6801,7 +7332,13 @@ var turnSeekIntoByte = async ({
   transportStream,
   tracksState,
   webmState,
-  keyframes
+  keyframes,
+  flacState,
+  samplesObserved,
+  riffState,
+  mp3State,
+  contentLength,
+  aacState
 }) => {
   const mediaSections = mediaSectionState2.getMediaSections();
   if (mediaSections.length === 0) {
@@ -6815,6 +7352,8 @@ var turnSeekIntoByte = async ({
       throw new Error(`Cannot seek to a negative time: ${JSON.stringify(seek2)}`);
     }
     const seekingHints = getSeekingHints({
+      riffState,
+      samplesObserved,
       structureState,
       mp4HeaderSegment,
       mediaSectionState: mediaSectionState2,
@@ -6822,7 +7361,11 @@ var turnSeekIntoByte = async ({
       transportStream,
       tracksState,
       keyframesState: keyframes,
-      webmState
+      webmState,
+      flacState,
+      mp3State,
+      contentLength,
+      aacState
     });
     if (!seekingHints) {
       Log.trace(logLevel, "No seeking info, cannot seek yet");
@@ -6840,7 +7383,8 @@ var turnSeekIntoByte = async ({
       webmState,
       mediaSection: mediaSectionState2,
       mp4HeaderSegment,
-      structure: structureState
+      structure: structureState,
+      riffState
     });
     return seekingByte;
   }
@@ -6872,7 +7416,12 @@ var getWorkOnSeekRequestOptions = (state) => {
     transportStream: state.transportStream,
     tracksState: state.callbacks.tracks,
     webmState: state.webm,
-    keyframes: state.keyframes
+    keyframes: state.keyframes,
+    flacState: state.flac,
+    samplesObserved: state.samplesObserved,
+    riffState: state.riff,
+    mp3State: state.mp3,
+    aacState: state.aac
   };
 };
 var workOnSeekRequest = async (options) => {
@@ -6895,7 +7444,12 @@ var workOnSeekRequest = async (options) => {
     transportStream,
     tracksState,
     webmState,
-    keyframes
+    keyframes,
+    flacState,
+    samplesObserved,
+    riffState,
+    mp3State,
+    aacState
   } = options;
   const seek2 = controller._internals.seekSignal.getSeek();
   if (!seek2) {
@@ -6913,7 +7467,13 @@ var workOnSeekRequest = async (options) => {
     transportStream,
     tracksState,
     webmState,
-    keyframes
+    keyframes,
+    flacState,
+    samplesObserved,
+    riffState,
+    mp3State,
+    contentLength,
+    aacState
   });
   Log.trace(logLevel, `Seek action: ${JSON.stringify(resolution)}`);
   if (resolution.type === "intermediary-seek") {
@@ -7007,7 +7567,7 @@ var emitAvailableInfo = async ({
     }
     if (key === "slowDurationInSeconds") {
       if (hasInfo.slowDurationInSeconds && !emittedFields.slowDurationInSeconds) {
-        const slowDurationInSeconds = getDuration(state) ?? state.slowDurationAndFps.getSlowDurationInSeconds();
+        const slowDurationInSeconds = getDuration(state) ?? state.samplesObserved.getSlowDurationInSeconds();
         await callbackFunctions.onSlowDurationInSeconds?.(slowDurationInSeconds);
         if (fieldsInReturnValue.slowDurationInSeconds) {
           returnValue.slowDurationInSeconds = slowDurationInSeconds;
@@ -7041,7 +7601,7 @@ var emitAvailableInfo = async ({
     }
     if (key === "slowFps") {
       if (hasInfo.slowFps && !emittedFields.slowFps) {
-        const slowFps = state.slowDurationAndFps.getFps();
+        const slowFps = state.samplesObserved.getFps();
         await callbackFunctions.onSlowFps?.(slowFps);
         if (fieldsInReturnValue.slowFps) {
           returnValue.slowFps = slowFps;
@@ -7221,9 +7781,9 @@ var emitAvailableInfo = async ({
     }
     if (key === "slowNumberOfFrames") {
       if (!emittedFields.slowNumberOfFrames && hasInfo.slowNumberOfFrames) {
-        await callbackFunctions.onSlowNumberOfFrames?.(state.slowDurationAndFps.getSlowNumberOfFrames());
+        await callbackFunctions.onSlowNumberOfFrames?.(state.samplesObserved.getSlowNumberOfFrames());
         if (fieldsInReturnValue.slowNumberOfFrames) {
-          returnValue.slowNumberOfFrames = state.slowDurationAndFps.getSlowNumberOfFrames();
+          returnValue.slowNumberOfFrames = state.samplesObserved.getSlowNumberOfFrames();
         }
         emittedFields.slowNumberOfFrames = true;
       }
@@ -7231,9 +7791,9 @@ var emitAvailableInfo = async ({
     }
     if (key === "slowAudioBitrate") {
       if (!emittedFields.slowAudioBitrate && hasInfo.slowAudioBitrate) {
-        await callbackFunctions.onSlowAudioBitrate?.(state.slowDurationAndFps.getAudioBitrate());
+        await callbackFunctions.onSlowAudioBitrate?.(state.samplesObserved.getAudioBitrate());
         if (fieldsInReturnValue.slowAudioBitrate) {
-          returnValue.slowAudioBitrate = state.slowDurationAndFps.getAudioBitrate();
+          returnValue.slowAudioBitrate = state.samplesObserved.getAudioBitrate();
         }
         emittedFields.slowAudioBitrate = true;
       }
@@ -7241,9 +7801,9 @@ var emitAvailableInfo = async ({
     }
     if (key === "slowVideoBitrate") {
       if (!emittedFields.slowVideoBitrate && hasInfo.slowVideoBitrate) {
-        await callbackFunctions.onSlowVideoBitrate?.(state.slowDurationAndFps.getVideoBitrate());
+        await callbackFunctions.onSlowVideoBitrate?.(state.samplesObserved.getVideoBitrate());
         if (fieldsInReturnValue.slowVideoBitrate) {
-          returnValue.slowVideoBitrate = state.slowDurationAndFps.getVideoBitrate();
+          returnValue.slowVideoBitrate = state.samplesObserved.getVideoBitrate();
         }
         emittedFields.slowVideoBitrate = true;
       }
@@ -7520,6 +8080,10 @@ var parseAac = async (state) => {
   iterator.counter.decrement(iterator.counter.getOffset() - startOffset);
   const data = iterator.getSlice(frameLength);
   if (state.callbacks.tracks.getTracks().length === 0) {
+    state.mediaSection.addMediaSection({
+      start: startOffset,
+      size: state.contentLength - startOffset
+    });
     await registerAudioTrack({
       container: "aac",
       track: {
@@ -7544,24 +8108,26 @@ var parseAac = async (state) => {
   const duration2 = 1024 / sampleRate;
   const { index } = state.aac.addSample({ offset: startOffset, size: frameLength });
   const timestamp = 1024 / sampleRate * index;
-  await emitAudioSample({
-    trackId: 0,
-    audioSample: convertAudioOrVideoSampleToWebCodecsTimestamps({
-      sample: {
-        duration: duration2,
-        type: "key",
-        data,
-        offset: startOffset,
-        timescale: 1e6,
-        trackId: 0,
-        cts: timestamp,
-        dts: timestamp,
-        timestamp
-      },
-      timescale: 1
-    }),
-    callbacks: state.callbacks
+  state.aac.audioSamples.addSample({
+    timeInSeconds: timestamp,
+    offset: startOffset,
+    durationInSeconds: duration2
   });
+  const audioSample = convertAudioOrVideoSampleToWebCodecsTimestamps({
+    sample: {
+      duration: duration2,
+      type: "key",
+      data,
+      offset: startOffset,
+      timescale: 1e6,
+      trackId: 0,
+      cts: timestamp,
+      dts: timestamp,
+      timestamp
+    },
+    timescale: 1
+  });
+  await state.callbacks.onAudioSample(0, audioSample);
   return Promise.resolve(null);
 };
 
@@ -7751,24 +8317,26 @@ var emitSample = async ({
     throw new Error("Cannot determine timestamp");
   }
   const timestamp = num * streamInfo.maximumBlockSize / streamInfo.sampleRate;
-  await emitAudioSample({
-    trackId: 0,
-    audioSample: convertAudioOrVideoSampleToWebCodecsTimestamps({
-      sample: {
-        data,
-        duration: duration2,
-        cts: timestamp,
-        dts: timestamp,
-        timestamp,
-        type: "key",
-        offset,
-        timescale: 1e6,
-        trackId: 0
-      },
-      timescale: 1
-    }),
-    callbacks: state.callbacks
+  state.flac.audioSamples.addSample({
+    timeInSeconds: timestamp,
+    offset,
+    durationInSeconds: duration2
   });
+  const audioSample = convertAudioOrVideoSampleToWebCodecsTimestamps({
+    sample: {
+      data,
+      duration: duration2,
+      cts: timestamp,
+      dts: timestamp,
+      timestamp,
+      type: "key",
+      offset,
+      timescale: 1,
+      trackId: 0
+    },
+    timescale: 1
+  });
+  await state.callbacks.onAudioSample(0, audioSample);
   iterator.destroy();
 };
 var parseFlacFrame = async ({
@@ -7950,27 +8518,15 @@ var parseFlacUnkownBlock = ({
   return Promise.resolve(null);
 };
 
-// src/containers/flac/parse-flac.ts
+// src/containers/flac/parse-meta.ts
 var flacTypes = {
   streaminfo: 0,
   vorbisComment: 4
 };
-var parseFlac = ({
+var parseMetaBlock = ({
   iterator,
   state
 }) => {
-  const mediaSectionState2 = state.mediaSection.isCurrentByteInMediaSection(iterator);
-  if (mediaSectionState2 === "in-section") {
-    if (maySkipVideoData({ state })) {
-      return Promise.resolve(makeSkip(state.contentLength));
-    }
-    return parseFlacFrame({ state, iterator });
-  }
-  const bytes = iterator.getByteString(4, true);
-  if (bytes === "fLaC") {
-    return parseFlacHeader({ state, iterator });
-  }
-  iterator.counter.decrement(4);
   iterator.startReadingBits();
   const isLastMetadata = iterator.getBits(1);
   const metaBlockType = iterator.getBits(7);
@@ -7991,6 +8547,29 @@ var parseFlac = ({
   return parseFlacUnkownBlock({ iterator, state, size });
 };
 
+// src/containers/flac/parse-flac.ts
+var parseFlac = ({
+  iterator,
+  state
+}) => {
+  const mediaSectionState2 = state.mediaSection.isCurrentByteInMediaSection(iterator);
+  if (mediaSectionState2 === "in-section") {
+    if (maySkipVideoData({ state })) {
+      return Promise.resolve(makeSkip(state.contentLength));
+    }
+    return parseFlacFrame({ state, iterator });
+  }
+  const bytes = iterator.getByteString(4, true);
+  if (bytes === "fLaC") {
+    return parseFlacHeader({ state, iterator });
+  }
+  iterator.counter.decrement(4);
+  return parseMetaBlock({
+    iterator,
+    state
+  });
+};
+
 // src/state/iso-base-media/cached-sample-positions.ts
 var calculateFlatSamples = (state) => {
   const tracks2 = getTracks(state, true);
@@ -8342,7 +8921,8 @@ var getIsoBaseMediaChildren = async ({
   size,
   iterator,
   logLevel,
-  onlyIfMoovAtomExpected
+  onlyIfMoovAtomExpected,
+  contentLength
 }) => {
   const boxes = [];
   const initial = iterator.counter.getOffset();
@@ -8351,7 +8931,8 @@ var getIsoBaseMediaChildren = async ({
       iterator,
       logLevel,
       onlyIfMoovAtomExpected,
-      onlyIfMdatAtomExpected: null
+      onlyIfMdatAtomExpected: null,
+      contentLength
     });
     if (!parsed) {
       throw new Error("Expected box");
@@ -8614,13 +9195,15 @@ var parseMoov = async ({
   size,
   onlyIfMoovAtomExpected,
   iterator,
-  logLevel
+  logLevel,
+  contentLength
 }) => {
   const children = await getIsoBaseMediaChildren({
     onlyIfMoovAtomExpected,
     size: size - 8,
     iterator,
-    logLevel
+    logLevel,
+    contentLength
   });
   return {
     offset,
@@ -8968,7 +9551,8 @@ var parseMebx = async ({
   offset,
   size,
   iterator,
-  logLevel
+  logLevel,
+  contentLength
 }) => {
   iterator.discard(6);
   const dataReferenceIndex = iterator.getUint16();
@@ -8976,7 +9560,8 @@ var parseMebx = async ({
     iterator,
     size: size - 8,
     logLevel,
-    onlyIfMoovAtomExpected: null
+    onlyIfMoovAtomExpected: null,
+    contentLength
   });
   return {
     type: "mebx-box",
@@ -9138,7 +9723,8 @@ var audioTags = [
 ];
 var processIsoFormatBox = async ({
   iterator,
-  logLevel
+  logLevel,
+  contentLength
 }) => {
   const fileOffset = iterator.counter.getOffset();
   const bytesRemaining = iterator.bytesRemaining();
@@ -9178,7 +9764,8 @@ var processIsoFormatBox = async ({
         iterator,
         logLevel,
         size: boxSize - (iterator.counter.getOffset() - fileOffset),
-        onlyIfMoovAtomExpected: null
+        onlyIfMoovAtomExpected: null,
+        contentLength
       });
       return {
         sample: {
@@ -9217,7 +9804,8 @@ var processIsoFormatBox = async ({
         iterator,
         logLevel,
         size: boxSize - (iterator.counter.getOffset() - fileOffset),
-        onlyIfMoovAtomExpected: null
+        onlyIfMoovAtomExpected: null,
+        contentLength
       });
       return {
         sample: {
@@ -9260,7 +9848,8 @@ var processIsoFormatBox = async ({
         iterator,
         logLevel,
         size: boxSize - (iterator.counter.getOffset() - fileOffset),
-        onlyIfMoovAtomExpected: null
+        onlyIfMoovAtomExpected: null,
+        contentLength
       });
       return {
         sample: {
@@ -9307,7 +9896,8 @@ var processIsoFormatBox = async ({
       onlyIfMoovAtomExpected: null,
       iterator,
       logLevel,
-      size: bytesRemainingInBox
+      size: bytesRemainingInBox,
+      contentLength
     }) : (iterator.discard(bytesRemainingInBox), []);
     return {
       sample: {
@@ -9339,14 +9929,16 @@ var processIsoFormatBox = async ({
 var parseIsoFormatBoxes = async ({
   maxBytes,
   logLevel,
-  iterator
+  iterator,
+  contentLength
 }) => {
   const samples = [];
   const initialOffset = iterator.counter.getOffset();
   while (iterator.bytesRemaining() > 0 && iterator.counter.getOffset() - initialOffset < maxBytes) {
     const { sample } = await processIsoFormatBox({
       iterator,
-      logLevel
+      logLevel,
+      contentLength
     });
     if (sample) {
       samples.push(sample);
@@ -9360,7 +9952,8 @@ var parseStsd = async ({
   offset,
   size,
   iterator,
-  logLevel
+  logLevel,
+  contentLength
 }) => {
   const version = iterator.getUint8();
   if (version !== 0) {
@@ -9372,7 +9965,8 @@ var parseStsd = async ({
   const boxes = await parseIsoFormatBoxes({
     maxBytes: bytesRemainingInBox,
     logLevel,
-    iterator
+    iterator,
+    contentLength
   });
   if (boxes.length !== numberOfEntries) {
     throw new Error(`Expected ${numberOfEntries} sample descriptions, got ${boxes.length}`);
@@ -9641,13 +10235,15 @@ var parseTrak = async ({
   size,
   offsetAtStart,
   iterator,
-  logLevel
+  logLevel,
+  contentLength
 }) => {
   const children = await getIsoBaseMediaChildren({
     onlyIfMoovAtomExpected: null,
     size: size - 8,
     iterator,
-    logLevel
+    logLevel,
+    contentLength
   });
   return {
     offset: offsetAtStart,
@@ -9704,7 +10300,8 @@ var processBox = async ({
   iterator,
   logLevel,
   onlyIfMoovAtomExpected,
-  onlyIfMdatAtomExpected
+  onlyIfMdatAtomExpected,
+  contentLength
 }) => {
   const fileOffset = iterator.counter.getOffset();
   const { returnToCheckpoint } = iterator.startCheckpoint();
@@ -9721,13 +10318,14 @@ var processBox = async ({
     iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
     throw new Error(`Expected box size of ${bytesRemaining}, got ${boxSizeRaw}. Incomplete boxes are not allowed.`);
   }
+  const maxSize = contentLength - startOff;
   const boxType = iterator.getByteString(4, false);
-  const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber() : boxSizeRaw;
-  Log.trace(logLevel, "Found box", boxType, boxSize);
+  const boxSizeUnlimited = boxSizeRaw === 1 ? iterator.getEightByteNumber() : boxSizeRaw;
+  const boxSize = Math.min(boxSizeUnlimited, maxSize);
   const headerLength = iterator.counter.getOffset() - startOff;
   if (boxType === "mdat") {
     if (!onlyIfMdatAtomExpected) {
-      throw new Error("State is required");
+      return null;
     }
     const { mediaSectionState: mediaSectionState2 } = onlyIfMdatAtomExpected;
     mediaSectionState2.addMediaSection({
@@ -9766,7 +10364,8 @@ var processBox = async ({
       offset: fileOffset,
       size: boxSize,
       iterator,
-      logLevel
+      logLevel,
+      contentLength
     });
   }
   if (boxType === "stsz") {
@@ -9817,7 +10416,8 @@ var processBox = async ({
       offset: fileOffset,
       size: boxSize,
       iterator,
-      logLevel
+      logLevel,
+      contentLength
     });
   }
   if (boxType === "hdlr") {
@@ -9859,7 +10459,8 @@ var processBox = async ({
       size: boxSize,
       onlyIfMoovAtomExpected,
       iterator,
-      logLevel
+      logLevel,
+      contentLength
     });
     tracks2.setIsDone(logLevel);
     return box;
@@ -9873,7 +10474,8 @@ var processBox = async ({
       size: boxSize,
       offsetAtStart: fileOffset,
       iterator,
-      logLevel
+      logLevel,
+      contentLength
     });
     const transformedTrack = makeBaseMediaTrack(box);
     if (transformedTrack && transformedTrack.type === "video") {
@@ -9953,7 +10555,8 @@ var processBox = async ({
       iterator,
       size: boxSize - 8,
       logLevel,
-      onlyIfMoovAtomExpected
+      onlyIfMoovAtomExpected,
+      contentLength
     });
     return {
       type: "regular-box",
@@ -10015,7 +10618,7 @@ var getMoovAtom = async ({
     });
     return null;
   } : null;
-  const iterator = getArrayBufferIterator(new Uint8Array([]), state.contentLength);
+  const iterator = getArrayBufferIterator(new Uint8Array([]), state.contentLength - endOfMdat);
   while (true) {
     const result = await reader.reader.read();
     if (result.value) {
@@ -10045,7 +10648,8 @@ var getMoovAtom = async ({
         registerVideoSampleCallback: () => Promise.resolve(),
         registerAudioSampleCallback: () => Promise.resolve()
       },
-      onlyIfMdatAtomExpected: null
+      onlyIfMdatAtomExpected: null,
+      contentLength: state.contentLength - endOfMdat
     });
     if (box) {
       boxes.push(box);
@@ -10139,24 +10743,21 @@ var parseMdatSection = async (state) => {
     chunkSize
   });
   if (samplesWithIndex.track.type === "audio") {
-    await emitAudioSample({
-      trackId: samplesWithIndex.track.trackId,
-      audioSample: convertAudioOrVideoSampleToWebCodecsTimestamps({
-        sample: {
-          data: bytes,
-          timestamp: cts,
-          duration: duration2,
-          cts,
-          dts,
-          trackId: samplesWithIndex.track.trackId,
-          type: isKeyframe ? "key" : "delta",
-          offset,
-          timescale: samplesWithIndex.track.timescale
-        },
+    const audioSample = convertAudioOrVideoSampleToWebCodecsTimestamps({
+      sample: {
+        data: bytes,
+        timestamp: cts,
+        duration: duration2,
+        cts,
+        dts,
+        trackId: samplesWithIndex.track.trackId,
+        type: isKeyframe ? "key" : "delta",
+        offset,
         timescale: samplesWithIndex.track.timescale
-      }),
-      callbacks: state.callbacks
+      },
+      timescale: samplesWithIndex.track.timescale
     });
+    await state.callbacks.onAudioSample(samplesWithIndex.track.trackId, audioSample);
   }
   if (samplesWithIndex.track.type === "video") {
     const nalUnitType = bytes[4] & 31;
@@ -10165,24 +10766,21 @@ var parseMdatSection = async (state) => {
       const seiType = bytes[5];
       isRecoveryPoint = seiType === 6;
     }
-    await emitVideoSample({
-      trackId: samplesWithIndex.track.trackId,
-      videoSample: convertAudioOrVideoSampleToWebCodecsTimestamps({
-        sample: {
-          data: bytes,
-          timestamp: cts,
-          duration: duration2,
-          cts,
-          dts,
-          trackId: samplesWithIndex.track.trackId,
-          type: isKeyframe && !isRecoveryPoint ? "key" : "delta",
-          offset,
-          timescale: samplesWithIndex.track.timescale
-        },
+    const videoSample = convertAudioOrVideoSampleToWebCodecsTimestamps({
+      sample: {
+        data: bytes,
+        timestamp: cts,
+        duration: duration2,
+        cts,
+        dts,
+        trackId: samplesWithIndex.track.trackId,
+        type: isKeyframe && !isRecoveryPoint ? "key" : "delta",
+        offset,
         timescale: samplesWithIndex.track.timescale
-      }),
-      callbacks: state.callbacks
+      },
+      timescale: samplesWithIndex.track.timescale
     });
+    await state.callbacks.onVideoSample(samplesWithIndex.track.trackId, videoSample);
   }
   return null;
 };
@@ -10207,7 +10805,8 @@ var parseIsoBaseMedia = async (state) => {
     },
     onlyIfMdatAtomExpected: {
       mediaSectionState: state.mediaSection
-    }
+    },
+    contentLength: state.contentLength
   });
   if (result) {
     state.structure.getIsoStructure().boxes.push(result);
@@ -10981,7 +11580,7 @@ var parseID3V1 = (iterator) => {
   iterator.discard(128);
 };
 
-// src/containers/mp3/parse-mpeg-header.ts
+// src/containers/mp3/parse-packet-header.ts
 function getSamplingFrequency({
   bits,
   mpegVersion
@@ -11123,15 +11722,7 @@ function getBitrateKB({
   }
   return bitrateTable[bits][key];
 }
-var parseMpegHeader = async ({
-  state
-}) => {
-  const { iterator } = state;
-  const initialOffset = iterator.counter.getOffset();
-  if (iterator.bytesRemaining() < 32) {
-    return;
-  }
-  iterator.startReadingBits();
+var innerParseMp3PacketHeader = (iterator) => {
   for (let i = 0;i < 11; i++) {
     const expectToBe1 = iterator.getBits(1);
     if (expectToBe1 !== 1) {
@@ -11153,15 +11744,15 @@ var parseMpegHeader = async ({
     throw new Error("Does not support CRC yet");
   }
   const bitrateIndex = iterator.getBits(4);
-  const bitrateKbit = getBitrateKB({
+  const bitrateInKbit = getBitrateKB({
     bits: bitrateIndex,
     mpegVersion,
     level: audioVersionId
   });
-  if (bitrateKbit === "bad") {
+  if (bitrateInKbit === "bad") {
     throw new Error("Invalid bitrate");
   }
-  if (bitrateKbit === "free") {
+  if (bitrateInKbit === "free") {
     throw new Error("Free bitrate not supported");
   }
   const samplingFrequencyIndex = iterator.getBits(2);
@@ -11179,89 +11770,272 @@ var parseMpegHeader = async ({
   const numberOfChannels = channelMode === 3 ? 1 : 2;
   const samplesPerFrame = getSamplesPerMpegFrame({ mpegVersion, layer });
   const frameLength = getMpegFrameLength({
-    bitrateKbit,
+    bitrateKbit: bitrateInKbit,
     padding,
     samplesPerFrame,
     samplingFrequency: sampleRate,
     layer
   });
+  return {
+    frameLength,
+    bitrateInKbit,
+    layer,
+    mpegVersion,
+    numberOfChannels,
+    sampleRate,
+    samplesPerFrame
+  };
+};
+var parseMp3PacketHeader = (iterator) => {
+  iterator.startReadingBits();
+  const d = innerParseMp3PacketHeader(iterator);
   iterator.stopReadingBits();
+  return d;
+};
+var isMp3PacketHeaderHere = (iterator) => {
+  const offset = iterator.counter.getOffset();
+  iterator.startReadingBits();
+  try {
+    const res = innerParseMp3PacketHeader(iterator);
+    iterator.stopReadingBits();
+    iterator.counter.decrement(iterator.counter.getOffset() - offset);
+    return res;
+  } catch {
+    iterator.stopReadingBits();
+    iterator.counter.decrement(iterator.counter.getOffset() - offset);
+    return false;
+  }
+};
+var isMp3PacketHeaderHereAndInNext = (iterator) => {
+  const offset = iterator.counter.getOffset();
+  const res = isMp3PacketHeaderHere(iterator);
+  if (!res) {
+    return false;
+  }
+  if (iterator.bytesRemaining() <= res.frameLength) {
+    return true;
+  }
+  iterator.counter.increment(res.frameLength);
+  const isHere = isMp3PacketHeaderHere(iterator);
+  iterator.counter.decrement(iterator.counter.getOffset() - offset);
+  return isHere;
+};
+
+// src/containers/mp3/seek/audio-sample-from-cbr.ts
+var getAudioSampleFromCbr = ({
+  bitrateInKbit,
+  initialOffset,
+  layer,
+  sampleRate,
+  samplesPerFrame,
+  data,
+  state
+}) => {
+  const avgLength = getAverageMpegFrameLength({
+    bitrateKbit: bitrateInKbit,
+    layer,
+    samplesPerFrame,
+    samplingFrequency: sampleRate
+  });
+  const mp3Info = state.mp3.getMp3Info();
+  if (!mp3Info) {
+    throw new Error("No MP3 info");
+  }
+  const nthFrame = Math.round((initialOffset - state.mediaSection.getMediaSectionAssertOnlyOne().start) / avgLength);
+  const durationInSeconds = samplesPerFrame / sampleRate;
+  const timeInSeconds = nthFrame * samplesPerFrame / sampleRate;
+  const timestamp = Math.round(timeInSeconds * 1e6);
+  const duration2 = Math.round(durationInSeconds * 1e6);
+  const audioSample = {
+    data,
+    cts: timestamp,
+    dts: timestamp,
+    duration: duration2,
+    offset: initialOffset,
+    timescale: 1e6,
+    timestamp,
+    trackId: 0,
+    type: "key"
+  };
+  return { audioSample, timeInSeconds, durationInSeconds };
+};
+
+// src/containers/mp3/seek/audio-sample-from-vbr.ts
+var getAudioSampleFromVbr = ({
+  info,
+  position,
+  mp3Info,
+  data
+}) => {
+  if (!mp3Info) {
+    throw new Error("No MP3 info");
+  }
+  const samplesPerFrame = getSamplesPerMpegFrame({
+    layer: mp3Info.layer,
+    mpegVersion: mp3Info.mpegVersion
+  });
+  const wholeFileDuration = getDurationFromMp3Xing({
+    samplesPerFrame,
+    xingData: info.xingData
+  });
+  if (!info.xingData.fileSize) {
+    throw new Error("file size");
+  }
+  if (!info.xingData.tableOfContents) {
+    throw new Error("table of contents");
+  }
+  const timeInSeconds = getTimeFromPosition({
+    durationInSeconds: wholeFileDuration,
+    fileSize: info.xingData.fileSize,
+    position,
+    tableOfContents: info.xingData.tableOfContents
+  });
+  const durationInSeconds = samplesPerFrame / info.xingData.sampleRate;
+  const timestamp = Math.round(timeInSeconds * 1e6);
+  const duration2 = Math.round(durationInSeconds * 1e6);
+  const audioSample = {
+    data,
+    cts: timestamp,
+    dts: timestamp,
+    duration: duration2,
+    offset: position,
+    timescale: 1e6,
+    timestamp,
+    trackId: 0,
+    type: "key"
+  };
+  return { timeInSeconds, audioSample, durationInSeconds };
+};
+
+// src/containers/mp3/parse-mpeg-header.ts
+var parseMpegHeader = async ({
+  state
+}) => {
+  const { iterator } = state;
+  const initialOffset = iterator.counter.getOffset();
+  if (iterator.bytesRemaining() < 32) {
+    return;
+  }
+  const {
+    frameLength,
+    bitrateInKbit,
+    layer,
+    mpegVersion,
+    numberOfChannels,
+    sampleRate,
+    samplesPerFrame
+  } = parseMp3PacketHeader(iterator);
+  const cbrMp3Info = state.mp3.getMp3BitrateInfo();
+  if (cbrMp3Info && cbrMp3Info.type === "constant") {
+    if (bitrateInKbit !== cbrMp3Info.bitrateInKbit) {
+      throw new Error(`Bitrate mismatch at offset ${initialOffset}: ${bitrateInKbit} !== ${cbrMp3Info.bitrateInKbit}`);
+    }
+  }
   const offsetNow = iterator.counter.getOffset();
   iterator.counter.decrement(offsetNow - initialOffset);
   const data = iterator.getSlice(frameLength);
-  let isInfoTag = false;
   if (state.callbacks.tracks.getTracks().length === 0) {
     const info = {
       layer,
       mpegVersion,
-      sampleRate,
-      startOfMpegStream: initialOffset
+      sampleRate
     };
     const asText = new TextDecoder().decode(data);
-    const isVbr = asText.includes("Xing") || asText.includes("VBRI");
-    isInfoTag = isVbr || asText.includes("Info");
+    if (asText.includes("VBRI")) {
+      throw new Error("MP3 files with VBRI are currently unsupported because we have no sample file. Submit this file at remotion.dev/report if you would like us to support this file.");
+    }
+    if (asText.includes("Info")) {
+      return;
+    }
+    const isVbr = asText.includes("Xing");
     if (isVbr) {
+      const xingData = parseXing(data);
       Log.verbose(state.logLevel, "MP3 has variable bit rate. Requiring whole file to be read");
-    } else {
-      state.mp3Info.setCbrMp3Info({
-        bitrateKbit
+      state.mp3.setMp3BitrateInfo({
+        type: "variable",
+        xingData
       });
+      return;
     }
-    if (!isInfoTag) {
-      state.mp3Info.setMp3Info(info);
-      await registerAudioTrack({
-        container: "mp3",
-        track: {
-          type: "audio",
-          codec: "mp3",
-          codecPrivate: null,
-          codecWithoutConfig: "mp3",
-          description: undefined,
-          numberOfChannels,
-          sampleRate,
-          timescale: 1e6,
-          trackId: 0,
-          trakBox: null
-        },
-        registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
-        tracks: state.callbacks.tracks,
-        logLevel: state.logLevel,
-        onAudioTrack: state.onAudioTrack
+    if (!state.mp3.getMp3BitrateInfo()) {
+      state.mp3.setMp3BitrateInfo({
+        bitrateInKbit,
+        type: "constant"
       });
-      state.callbacks.tracks.setIsDone(state.logLevel);
     }
-  }
-  const avgLength = getAverageMpegFrameLength({
-    bitrateKbit,
-    layer,
-    samplesPerFrame,
-    samplingFrequency: sampleRate
-  });
-  if (!isInfoTag) {
-    const mp3Info = state.mp3Info.getMp3Info();
-    if (!mp3Info) {
-      throw new Error("No MP3 info");
-    }
-    const nthFrame = Math.round((initialOffset - mp3Info.startOfMpegStream) / avgLength);
-    const durationInSeconds = samplesPerFrame / sampleRate;
-    const timeInSeconds = nthFrame * samplesPerFrame / sampleRate;
-    const timestamp = Math.round(timeInSeconds * 1e6);
-    const duration2 = Math.round(durationInSeconds * 1e6);
-    await emitAudioSample({
-      trackId: 0,
-      audioSample: {
-        data,
-        cts: timestamp,
-        dts: timestamp,
-        duration: duration2,
-        offset: initialOffset,
+    state.mp3.setMp3Info(info);
+    await registerAudioTrack({
+      container: "mp3",
+      track: {
+        type: "audio",
+        codec: "mp3",
+        codecPrivate: null,
+        codecWithoutConfig: "mp3",
+        description: undefined,
+        numberOfChannels,
+        sampleRate,
         timescale: 1e6,
-        timestamp,
         trackId: 0,
-        type: "key"
+        trakBox: null
       },
-      callbacks: state.callbacks
+      registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
+      tracks: state.callbacks.tracks,
+      logLevel: state.logLevel,
+      onAudioTrack: state.onAudioTrack
     });
+    state.callbacks.tracks.setIsDone(state.logLevel);
+    state.mediaSection.addMediaSection({
+      start: initialOffset,
+      size: state.contentLength - initialOffset
+    });
+  }
+  const bitrateInfo = state.mp3.getMp3BitrateInfo();
+  if (!bitrateInfo) {
+    throw new Error("No bitrate info");
+  }
+  const sample = bitrateInfo.type === "constant" ? getAudioSampleFromCbr({
+    bitrateInKbit,
+    data,
+    initialOffset,
+    layer,
+    sampleRate,
+    samplesPerFrame,
+    state
+  }) : getAudioSampleFromVbr({
+    data,
+    info: bitrateInfo,
+    mp3Info: state.mp3.getMp3Info(),
+    position: initialOffset
+  });
+  const { audioSample, timeInSeconds, durationInSeconds } = sample;
+  state.mp3.audioSamples.addSample({
+    timeInSeconds,
+    offset: initialOffset,
+    durationInSeconds
+  });
+  await state.callbacks.onAudioSample(0, audioSample);
+};
+
+// src/containers/mp3/seek/wait-until-syncword.ts
+var discardUntilSyncword = ({
+  iterator
+}) => {
+  while (true) {
+    const next2Bytes = iterator.getUint8();
+    if (next2Bytes !== 255) {
+      continue;
+    }
+    const nextByte = iterator.getUint8();
+    const mask = 224;
+    if ((nextByte & mask) !== mask) {
+      continue;
+    }
+    iterator.counter.decrement(2);
+    if (isMp3PacketHeaderHereAndInNext(iterator)) {
+      break;
+    } else {
+      iterator.counter.increment(2);
+    }
   }
 };
 
@@ -11271,6 +12045,13 @@ var parseMp3 = async (state) => {
   if (iterator.bytesRemaining() < 3) {
     return null;
   }
+  if (state.mediaSection.isCurrentByteInMediaSection(iterator) === "in-section") {
+    discardUntilSyncword({ iterator });
+    await parseMpegHeader({
+      state
+    });
+    return null;
+  }
   const { returnToCheckpoint } = iterator.startCheckpoint();
   const bytes = iterator.getSlice(3);
   returnToCheckpoint();
@@ -11302,6 +12083,7 @@ var isMoviAtom = (iterator, ckId) => {
 };
 
 // src/containers/riff/parse-avih.ts
+var AVIF_HAS_INDEX = 16;
 var parseAvih = ({
   iterator,
   size
@@ -11317,10 +12099,12 @@ var parseAvih = ({
   const suggestedBufferSize = iterator.getUint32Le();
   const width = iterator.getUint32Le();
   const height = iterator.getUint32Le();
+  const hasIndex = (flags & AVIF_HAS_INDEX) !== 0;
   iterator.discard(16);
   expectNoMoreBytes();
   return {
     type: "avih-box",
+    hasIndex,
     microSecPerFrame: dwMicroSecPerFrame,
     maxBytesPerSecond: dwMaxBytesPerSec,
     paddingGranularity,
@@ -11334,6 +12118,54 @@ var parseAvih = ({
   };
 };
 
+// src/containers/riff/parse-idx1.ts
+var AVIIF_KEYFRAME = 16;
+var parseIdx1 = ({
+  iterator,
+  size
+}) => {
+  const box = iterator.startBox(size);
+  const offset = iterator.counter.getOffset();
+  const entries = [];
+  const sampleCounts = {};
+  let videoTrackIndex = null;
+  while (iterator.counter.getOffset() < offset + size) {
+    const chunkId = iterator.getByteString(4, false);
+    const flags = iterator.getUint32Le();
+    const moffset = iterator.getUint32Le();
+    const msize = iterator.getUint32Le();
+    const chunk = chunkId.match(/^([0-9]{2})(wb|dc)$/);
+    const isVideo = chunkId.endsWith("dc");
+    if (isVideo) {
+      videoTrackIndex = chunk ? parseInt(chunk[1], 10) : null;
+    }
+    const trackId = chunk ? parseInt(chunk[1], 10) : null;
+    if (trackId === null) {
+      continue;
+    }
+    if (!sampleCounts[trackId]) {
+      sampleCounts[trackId] = 0;
+    }
+    const isKeyFrame = (flags & AVIIF_KEYFRAME) !== 0;
+    if (isKeyFrame) {
+      entries.push({
+        flags,
+        id: chunkId,
+        offset: moffset,
+        size: msize,
+        sampleCounts: { ...sampleCounts }
+      });
+    }
+    sampleCounts[trackId]++;
+  }
+  box.expectNoMoreBytes();
+  return {
+    type: "idx1-box",
+    entries,
+    videoTrackIndex
+  };
+};
+
 // src/containers/riff/parse-isft.ts
 var parseIsft = ({
   iterator,
@@ -11355,9 +12187,9 @@ var parseIsft = ({
 // src/containers/riff/parse-list-box.ts
 var parseListBox = async ({
   size,
-  state
+  iterator,
+  stateIfExpectingSideEffects
 }) => {
-  const { iterator } = state;
   const counter = iterator.counter.getOffset();
   const listType = iterator.getByteString(4, false);
   if (listType === "movi") {
@@ -11366,10 +12198,16 @@ var parseListBox = async ({
   const boxes = [];
   const maxOffset = counter + size;
   while (iterator.counter.getOffset() < maxOffset) {
-    const box = await expectRiffBox(state);
+    const box = await expectRiffBox({
+      iterator,
+      stateIfExpectingSideEffects
+    });
     if (box === null) {
       throw new Error("Unexpected result");
     }
+    if (stateIfExpectingSideEffects) {
+      await postProcessRiffBox(stateIfExpectingSideEffects, box);
+    }
     boxes.push(box);
   }
   return {
@@ -11511,11 +12349,15 @@ var parseStrh = ({
 var parseRiffBox = ({
   size,
   id,
-  state
+  iterator,
+  stateIfExpectingSideEffects
 }) => {
-  const { iterator } = state;
   if (id === "LIST") {
-    return parseListBox({ size, state });
+    return parseListBox({
+      size,
+      iterator,
+      stateIfExpectingSideEffects
+    });
   }
   if (id === "ISFT") {
     return Promise.resolve(parseIsft({ iterator, size }));
@@ -11526,41 +12368,20 @@ var parseRiffBox = ({
   if (id === "strh") {
     return Promise.resolve(parseStrh({ iterator, size }));
   }
-  iterator.discard(size);
-  const box = {
-    type: "riff-box",
-    size,
-    id
-  };
-  return Promise.resolve(box);
-};
-
-// src/containers/riff/expect-riff-box.ts
-var expectRiffBox = async (state) => {
-  const { iterator } = state;
-  if (state.iterator.bytesRemaining() < 16) {
-    return null;
-  }
-  const checkpoint = iterator.startCheckpoint();
-  const ckId = iterator.getByteString(4, false);
-  const ckSize = iterator.getUint32Le();
-  if (isMoviAtom(iterator, ckId)) {
-    iterator.discard(4);
-    state.mediaSection.addMediaSection({
-      start: iterator.counter.getOffset(),
-      size: ckSize - 4
-    });
-    return null;
-  }
-  if (iterator.bytesRemaining() < ckSize) {
-    checkpoint.returnToCheckpoint();
-    return null;
+  if (id === "idx1") {
+    return Promise.resolve(parseIdx1({ iterator, size }));
   }
-  const box = await parseRiffBox({
-    id: ckId,
-    size: ckSize,
-    state
-  });
+  iterator.discard(size);
+  const box = {
+    type: "riff-box",
+    size,
+    id
+  };
+  return Promise.resolve(box);
+};
+
+// src/containers/riff/expect-riff-box.ts
+var postProcessRiffBox = async (state, box) => {
   if (box.type === "strh-box") {
     if (box.strf.type === "strf-box-audio" && state.onAudioTrack) {
       const audioTrack = makeAviAudioTrack({
@@ -11590,6 +12411,41 @@ var expectRiffBox = async (state) => {
     }
     state.riff.incrementNextTrackIndex();
   }
+};
+var expectRiffBox = async ({
+  iterator,
+  stateIfExpectingSideEffects
+}) => {
+  if (iterator.bytesRemaining() < 16) {
+    return null;
+  }
+  const checkpoint = iterator.startCheckpoint();
+  const ckId = iterator.getByteString(4, false);
+  const ckSize = iterator.getUint32Le();
+  if (isMoviAtom(iterator, ckId)) {
+    iterator.discard(4);
+    if (!stateIfExpectingSideEffects) {
+      throw new Error("No state if expecting side effects");
+    }
+    stateIfExpectingSideEffects.mediaSection.addMediaSection({
+      start: iterator.counter.getOffset(),
+      size: ckSize - 4
+    });
+    if (riffHasIndex(stateIfExpectingSideEffects.structure.getRiffStructure())) {
+      stateIfExpectingSideEffects.riff.lazyIdx1.triggerLoad(iterator.counter.getOffset() + ckSize - 4);
+    }
+    return null;
+  }
+  if (iterator.bytesRemaining() < ckSize) {
+    checkpoint.returnToCheckpoint();
+    return null;
+  }
+  const box = await parseRiffBox({
+    id: ckId,
+    size: ckSize,
+    iterator,
+    stateIfExpectingSideEffects
+  });
   return box;
 };
 
@@ -11612,13 +12468,13 @@ var handleChunk = async ({
   ckSize
 }) => {
   const { iterator } = state;
-  const offset = iterator.counter.getOffset();
+  const offset = iterator.counter.getOffset() - 8;
   const videoChunk = ckId.match(/^([0-9]{2})dc$/);
   if (videoChunk) {
     const trackId = parseInt(videoChunk[1], 10);
     const strh = getStrhForIndex(state.structure.getRiffStructure(), trackId);
     const samplesPerSecond = strh.rate / strh.scale;
-    const nthSample = state.callbacks.getSamplesForTrack(trackId);
+    const nthSample = state.riff.sampleCounter.getSamplesForTrack(trackId);
     const timeInSec = nthSample / samplesPerSecond;
     const timestamp = timeInSec;
     const data = iterator.getSlice(ckSize);
@@ -11630,24 +12486,22 @@ var handleChunk = async ({
       await state.riff.onProfile({ pps: ppsProfile, sps: avcProfile });
       state.callbacks.tracks.setIsDone(state.logLevel);
     }
-    await emitVideoSample({
-      trackId,
-      videoSample: convertAudioOrVideoSampleToWebCodecsTimestamps({
-        sample: {
-          cts: timestamp,
-          dts: timestamp,
-          data,
-          duration: undefined,
-          timestamp,
-          trackId,
-          type: keyOrDelta,
-          offset,
-          timescale: samplesPerSecond
-        },
-        timescale: 1
-      }),
-      callbacks: state.callbacks
+    const videoSample = convertAudioOrVideoSampleToWebCodecsTimestamps({
+      sample: {
+        cts: timestamp,
+        dts: timestamp,
+        data,
+        duration: undefined,
+        timestamp,
+        trackId,
+        type: keyOrDelta,
+        offset,
+        timescale: samplesPerSecond
+      },
+      timescale: 1
     });
+    state.riff.sampleCounter.onVideoSample(trackId, videoSample);
+    await state.callbacks.onVideoSample(trackId, videoSample);
     return;
   }
   const audioChunk = ckId.match(/^([0-9]{2})wb$/);
@@ -11655,28 +12509,26 @@ var handleChunk = async ({
     const trackId = parseInt(audioChunk[1], 10);
     const strh = getStrhForIndex(state.structure.getRiffStructure(), trackId);
     const samplesPerSecond = strh.rate / strh.scale;
-    const nthSample = state.callbacks.getSamplesForTrack(trackId);
+    const nthSample = state.riff.sampleCounter.getSamplesForTrack(trackId);
     const timeInSec = nthSample / samplesPerSecond;
     const timestamp = timeInSec;
     const data = iterator.getSlice(ckSize);
-    await emitAudioSample({
-      trackId,
-      audioSample: convertAudioOrVideoSampleToWebCodecsTimestamps({
-        sample: {
-          cts: timestamp,
-          dts: timestamp,
-          data,
-          duration: undefined,
-          timestamp,
-          trackId,
-          type: "key",
-          offset,
-          timescale: samplesPerSecond
-        },
-        timescale: 1
-      }),
-      callbacks: state.callbacks
+    const audioSample = convertAudioOrVideoSampleToWebCodecsTimestamps({
+      sample: {
+        cts: timestamp,
+        dts: timestamp,
+        data,
+        duration: undefined,
+        timestamp,
+        trackId,
+        type: "key",
+        offset,
+        timescale: samplesPerSecond
+      },
+      timescale: 1
     });
+    state.riff.sampleCounter.onAudioSample(trackId, audioSample);
+    await state.callbacks.onAudioSample(trackId, audioSample);
   }
 };
 var parseMovi = async ({
@@ -11733,8 +12585,12 @@ var parseRiffBody = async (state) => {
     await parseMediaSection(state);
     return null;
   }
-  const box = await expectRiffBox(state);
+  const box = await expectRiffBox({
+    iterator: state.iterator,
+    stateIfExpectingSideEffects: state
+  });
   if (box !== null) {
+    await postProcessRiffBox(state, box);
     const structure = state.structure.getRiffStructure();
     structure.boxes.push(box);
   }
@@ -12116,14 +12972,11 @@ var handleAacPacket = async ({
     offset,
     timescale: MPEG_TIMESCALE
   };
-  await emitAudioSample({
-    trackId: programId,
-    audioSample: convertAudioOrVideoSampleToWebCodecsTimestamps({
-      sample,
-      timescale: MPEG_TIMESCALE
-    }),
-    callbacks: sampleCallbacks
+  const audioSample = convertAudioOrVideoSampleToWebCodecsTimestamps({
+    sample,
+    timescale: MPEG_TIMESCALE
   });
+  await sampleCallbacks.onAudioSample(programId, audioSample);
   transportStream.lastEmittedSample.setLastEmittedSample(sample);
 };
 
@@ -12703,24 +13556,21 @@ var parseMediaSection2 = async ({
   const duration2 = toRead / (fmtBox.sampleRate * fmtBox.blockAlign);
   const timestamp = (offset - videoSection.start) / (fmtBox.sampleRate * fmtBox.blockAlign);
   const data = iterator.getSlice(toRead);
-  await emitAudioSample({
-    trackId: 0,
-    audioSample: convertAudioOrVideoSampleToWebCodecsTimestamps({
-      sample: {
-        cts: timestamp,
-        dts: timestamp,
-        data,
-        duration: duration2,
-        timestamp,
-        trackId: 0,
-        type: "key",
-        offset,
-        timescale: 1e6
-      },
-      timescale: 1
-    }),
-    callbacks: state.callbacks
+  const audioSample = convertAudioOrVideoSampleToWebCodecsTimestamps({
+    sample: {
+      cts: timestamp,
+      dts: timestamp,
+      data,
+      duration: duration2,
+      timestamp,
+      trackId: 0,
+      type: "key",
+      offset,
+      timescale: 1e6
+    },
+    timescale: 1
   });
+  await state.callbacks.onAudioSample(0, audioSample);
   return null;
 };
 
@@ -13048,11 +13898,7 @@ var postprocessEbml = async ({
   if (ebml.type === "Block" || ebml.type === "SimpleBlock") {
     const sample = getSampleFromBlock(ebml, webmState, offset, structureState2);
     if (sample.type === "video-sample") {
-      await emitVideoSample({
-        trackId: sample.videoSample.trackId,
-        videoSample: sample.videoSample,
-        callbacks
-      });
+      await callbacks.onVideoSample(sample.videoSample.trackId, sample.videoSample);
       return {
         type: "Block",
         value: new Uint8Array([]),
@@ -13060,11 +13906,7 @@ var postprocessEbml = async ({
       };
     }
     if (sample.type === "audio-sample") {
-      await emitAudioSample({
-        trackId: sample.audioSample.trackId,
-        audioSample: sample.audioSample,
-        callbacks
-      });
+      await callbacks.onAudioSample(sample.audioSample.trackId, sample.audioSample);
       return {
         type: "Block",
         value: new Uint8Array([]),
@@ -13091,11 +13933,7 @@ var postprocessEbml = async ({
         ...sample.partialVideoSample,
         type: hasReferenceBlock ? "delta" : "key"
       };
-      await emitVideoSample({
-        trackId: sample.partialVideoSample.trackId,
-        videoSample: completeFrame,
-        callbacks
-      });
+      await callbacks.onVideoSample(sample.partialVideoSample.trackId, completeFrame);
     }
     return {
       type: "BlockGroup",
@@ -13521,6 +14359,7 @@ var parseLoop = async ({
         if (skip !== null) {
           state.increaseSkippedBytes(skip.skipTo - state.iterator.counter.getOffset());
           if (skip.skipTo === state.contentLength) {
+            state.iterator.discard(skip.skipTo - state.iterator.counter.getOffset());
             Log.verbose(state.logLevel, "Skipped to end of file, not fetching.");
             break;
           }
@@ -13567,6 +14406,19 @@ var parseLoop = async ({
       iterationWithThisOffset = 0;
     }
   }
+  state.samplesObserved.setLastSampleObserved();
+  if (state.controller._internals.seekSignal.getSeek()) {
+    Log.verbose(state.logLevel, "Reached end of samples, but there is a pending seek. Trying to seek...");
+    await workOnSeekRequest(getWorkOnSeekRequestOptions(state));
+    if (state.controller._internals.seekSignal.getSeek()) {
+      throw new Error("Reached the end of the file even though a seek was requested. This is likely a bug in the parser. You can report this at https://remotion.dev/report and we will fix it as soon as possible.");
+    }
+    await parseLoop({
+      onError,
+      throttledState,
+      state
+    });
+  }
 };
 
 // src/print-timings.ts
@@ -13617,6 +14469,22 @@ var setSeekingHints = ({
     setSeekingHintsForWebm({ hints, state });
     return;
   }
+  if (hints.type === "flac-seeking-hints") {
+    setSeekingHintsForFlac({ hints, state });
+    return;
+  }
+  if (hints.type === "riff-seeking-hints") {
+    setSeekingHintsForRiff({ hints, state });
+    return;
+  }
+  if (hints.type === "mp3-seeking-hints") {
+    setSeekingHintsForMp3({ hints, state });
+    return;
+  }
+  if (hints.type === "aac-seeking-hints") {
+    setSeekingHintsForAac();
+    return;
+  }
   throw new Error(`Unknown seeking hints type: ${hints}`);
 };
 
@@ -13659,18 +14527,39 @@ var getFieldsFromCallback = ({
   return newFields;
 };
 
+// src/state/audio-sample-map.ts
+var audioSampleMapState = () => {
+  let map = [];
+  const addSample = (audioSampleOffset) => {
+    if (map.find((m) => m.offset === audioSampleOffset.offset)) {
+      return;
+    }
+    map.push(audioSampleOffset);
+  };
+  return {
+    addSample,
+    getSamples: () => map,
+    setFromSeekingHints: (newMap) => {
+      map = newMap;
+    }
+  };
+};
+
 // src/state/aac-state.ts
 var aacState = () => {
   const samples = [];
+  const audioSamples = audioSampleMapState();
   return {
     addSample: ({ offset, size }) => {
-      if (samples.find((s) => s.offset === offset)) {
-        throw new Error("Duplicate sample");
+      const index = samples.findIndex((s) => s.offset === offset);
+      if (index !== -1) {
+        return samples[index];
       }
       samples.push({ offset, index: samples.length, size });
       return samples[samples.length - 1];
     },
-    getSamples: () => samples
+    getSamples: () => samples,
+    audioSamples
   };
 };
 
@@ -13723,11 +14612,13 @@ var emittedState = () => {
 // src/state/flac-state.ts
 var flacState = () => {
   let blockingBitStrategy;
+  const audioSamples = audioSampleMapState();
   return {
     setBlockingBitStrategy: (strategy) => {
       blockingBitStrategy = strategy;
     },
-    getBlockingBitStrategy: () => blockingBitStrategy
+    getBlockingBitStrategy: () => blockingBitStrategy,
+    audioSamples
   };
 };
 
@@ -13837,7 +14728,8 @@ var getMfraSeekingBox = async ({
     iterator: mfraAtom,
     logLevel,
     size: parentSize - 8,
-    onlyIfMoovAtomExpected: null
+    onlyIfMoovAtomExpected: null,
+    contentLength
   });
 };
 
@@ -13931,8 +14823,8 @@ var keyframesState = () => {
   const getKeyframes2 = () => {
     return keyframes;
   };
-  const setFromSeekingHints = (hints) => {
-    for (const keyframe of hints.keyframes) {
+  const setFromSeekingHints = (keyframesFromHints) => {
+    for (const keyframe of keyframesFromHints) {
       addKeyframe(keyframe);
     }
   };
@@ -14218,6 +15110,9 @@ var lazyCuesFetch = ({
   let sOffset = null;
   let result = null;
   const triggerLoad = (position, segmentOffset) => {
+    if (result) {
+      return Promise.resolve(result);
+    }
     if (prom) {
       return prom;
     }
@@ -14243,6 +15138,15 @@ var lazyCuesFetch = ({
     if (!prom) {
       return null;
     }
+    if (result) {
+      if (!sOffset) {
+        throw new Error("Segment offset not set");
+      }
+      return {
+        cues: result,
+        segmentOffset: sOffset
+      };
+    }
     const cues = await prom;
     if (!cues) {
       return null;
@@ -14257,7 +15161,7 @@ var lazyCuesFetch = ({
   };
   const getIfAlreadyLoaded = () => {
     if (result) {
-      if (!sOffset) {
+      if (sOffset === null) {
         throw new Error("Segment offset not set");
       }
       return {
@@ -14405,21 +15309,203 @@ var webmState = ({
 // src/state/mp3.ts
 var makeMp3State = () => {
   let mp3Info = null;
-  let cbrMp3Info = null;
+  let bitrateInfo = null;
+  const audioSamples = audioSampleMapState();
   return {
     getMp3Info: () => mp3Info,
     setMp3Info: (info) => {
       mp3Info = info;
     },
-    getCbrMp3Info: () => cbrMp3Info,
-    setCbrMp3Info: (info) => {
-      cbrMp3Info = info;
+    getMp3BitrateInfo: () => bitrateInfo,
+    setMp3BitrateInfo: (info) => {
+      bitrateInfo = info;
+    },
+    audioSamples
+  };
+};
+
+// src/containers/riff/seek/fetch-idx1.ts
+var fetchIdx1 = async ({
+  src,
+  readerInterface,
+  controller,
+  position,
+  logLevel
+}) => {
+  Log.verbose(logLevel, "Making request to fetch idx1 from ", src, "position", position);
+  const result = await readerInterface.read({
+    controller,
+    range: position,
+    src
+  });
+  const iterator = getArrayBufferIterator(new Uint8Array, Infinity);
+  while (true) {
+    const res = await result.reader.reader.read();
+    if (res.value) {
+      iterator.addData(res.value);
+    }
+    if (res.done) {
+      break;
+    }
+  }
+  const box = await expectRiffBox({
+    iterator,
+    stateIfExpectingSideEffects: null
+  });
+  iterator.destroy();
+  if (box === null || box.type !== "idx1-box") {
+    throw new Error("Expected idx1-box");
+  }
+  return {
+    entries: box.entries.filter((entry) => entry.id.endsWith("dc")),
+    videoTrackIndex: box.videoTrackIndex
+  };
+};
+
+// src/state/riff/lazy-idx1-fetch.ts
+var lazyIdx1Fetch = ({
+  controller,
+  logLevel,
+  readerInterface,
+  src
+}) => {
+  let prom = null;
+  let result = null;
+  const triggerLoad = (position) => {
+    if (result) {
+      return Promise.resolve(result);
+    }
+    if (prom) {
+      return prom;
+    }
+    prom = fetchIdx1({
+      controller,
+      logLevel,
+      position,
+      readerInterface,
+      src
+    }).then((entries) => {
+      prom = null;
+      result = entries;
+      return entries;
+    });
+    return prom;
+  };
+  const getLoadedIdx1 = async () => {
+    if (!prom) {
+      return null;
+    }
+    const entries = await prom;
+    return entries;
+  };
+  const getIfAlreadyLoaded = () => {
+    if (result) {
+      return result;
+    }
+    return null;
+  };
+  const setFromSeekingHints = (hints) => {
+    if (hints.idx1Entries) {
+      result = hints.idx1Entries;
+    }
+  };
+  const waitForLoaded = () => {
+    if (result) {
+      return Promise.resolve(result);
+    }
+    if (prom) {
+      return prom;
+    }
+    return Promise.resolve(null);
+  };
+  return {
+    triggerLoad,
+    getLoadedIdx1,
+    getIfAlreadyLoaded,
+    setFromSeekingHints,
+    waitForLoaded
+  };
+};
+
+// src/state/riff/riff-keyframes.ts
+var riffKeyframesState = () => {
+  const keyframes = [];
+  const addKeyframe = (keyframe) => {
+    if (keyframes.find((k) => k.positionInBytes === keyframe.positionInBytes)) {
+      return;
+    }
+    keyframes.push(keyframe);
+  };
+  const getKeyframes2 = () => {
+    return keyframes;
+  };
+  const setFromSeekingHints = (keyframesFromHints) => {
+    for (const keyframe of keyframesFromHints) {
+      addKeyframe(keyframe);
+    }
+  };
+  return {
+    addKeyframe,
+    getKeyframes: getKeyframes2,
+    setFromSeekingHints
+  };
+};
+
+// src/state/riff/sample-counter.ts
+var riffSampleCounter = () => {
+  const samplesForTrack = {};
+  const riffKeys = riffKeyframesState();
+  const onAudioSample = (trackId, audioSample) => {
+    if (typeof samplesForTrack[trackId] === "undefined") {
+      samplesForTrack[trackId] = 0;
+    }
+    if (audioSample.data.length > 0) {
+      samplesForTrack[trackId]++;
+    }
+    samplesForTrack[trackId]++;
+  };
+  const onVideoSample = (trackId, videoSample) => {
+    if (typeof samplesForTrack[trackId] === "undefined") {
+      samplesForTrack[trackId] = 0;
+    }
+    if (videoSample.type === "key") {
+      riffKeys.addKeyframe({
+        trackId,
+        decodingTimeInSeconds: videoSample.dts / videoSample.timescale,
+        positionInBytes: videoSample.offset,
+        presentationTimeInSeconds: videoSample.cts / videoSample.timescale,
+        sizeInBytes: videoSample.data.length,
+        sampleCounts: { ...samplesForTrack }
+      });
+    }
+    if (videoSample.data.length > 0) {
+      samplesForTrack[trackId]++;
+    }
+  };
+  const getSamplesForTrack = (trackId) => {
+    return samplesForTrack[trackId] ?? 0;
+  };
+  const setSamplesFromSeek = (samples) => {
+    for (const trackId in samples) {
+      samplesForTrack[trackId] = samples[trackId];
     }
   };
+  return {
+    onAudioSample,
+    onVideoSample,
+    getSamplesForTrack,
+    setSamplesFromSeek,
+    riffKeys
+  };
 };
 
 // src/state/riff.ts
-var riffSpecificState = () => {
+var riffSpecificState = ({
+  controller,
+  logLevel,
+  readerInterface,
+  src
+}) => {
   let avcProfile = null;
   let nextTrackIndex = 0;
   const profileCallbacks = [];
@@ -14433,6 +15519,13 @@ var riffSpecificState = () => {
     }
     profileCallbacks.length = 0;
   };
+  const lazyIdx1 = lazyIdx1Fetch({
+    controller,
+    logLevel,
+    readerInterface,
+    src
+  });
+  const sampleCounter = riffSampleCounter();
   return {
     getAvcProfile: () => {
       return avcProfile;
@@ -14444,7 +15537,9 @@ var riffSpecificState = () => {
     },
     incrementNextTrackIndex: () => {
       nextTrackIndex++;
-    }
+    },
+    lazyIdx1,
+    sampleCounter
   };
 };
 
@@ -14456,7 +15551,7 @@ var sampleCallback = ({
   fields,
   keyframes,
   emittedFields,
-  slowDurationAndFpsState,
+  samplesObserved,
   structure,
   src,
   seekSignal,
@@ -14473,7 +15568,6 @@ var sampleCallback = ({
     structure
   });
   const tracksState = makeTracksSectionState(canSkipTracksState, src);
-  const samplesForTrack = {};
   return {
     registerVideoSampleCallback: async (id, callback) => {
       if (callback === null) {
@@ -14490,12 +15584,8 @@ var sampleCallback = ({
       if (controller._internals.signal.aborted) {
         throw new Error("Aborted");
       }
-      if (typeof samplesForTrack[trackId] === "undefined") {
-        samplesForTrack[trackId] = 0;
-      }
       const callback = audioSampleCallbacks[trackId];
       if (audioSample.data.length > 0) {
-        samplesForTrack[trackId]++;
         if (callback) {
           if (seekSignal.getSeek()) {
             Log.trace(logLevel, "Not emitting sample because seek is processing");
@@ -14505,21 +15595,14 @@ var sampleCallback = ({
         }
       }
       if (needsToIterateOverSamples({ emittedFields, fields })) {
-        slowDurationAndFpsState.addAudioSample(audioSample);
+        samplesObserved.addAudioSample(audioSample);
       }
     },
-    getSamplesForTrack: (trackId) => {
-      return samplesForTrack[trackId] ?? 0;
-    },
     onVideoSample: async (trackId, videoSample) => {
       if (controller._internals.signal.aborted) {
         throw new Error("Aborted");
       }
-      if (typeof samplesForTrack[trackId] === "undefined") {
-        samplesForTrack[trackId] = 0;
-      }
       if (videoSample.data.length > 0) {
-        samplesForTrack[trackId]++;
         const callback = videoSampleCallbacks[trackId];
         if (callback) {
           if (seekSignal.getSeek()) {
@@ -14542,7 +15625,7 @@ var sampleCallback = ({
         fields,
         emittedFields
       })) {
-        slowDurationAndFpsState.addVideoSample(videoSample);
+        samplesObserved.addVideoSample(videoSample);
       }
     },
     canSkipTracksState,
@@ -14571,6 +15654,7 @@ var samplesObservedState = () => {
   let largestVideoSample;
   let smallestAudioSample;
   let largestAudioSample;
+  let lastSampleObserved = false;
   const videoSamples = new Map;
   const audioSamples = new Map;
   const getSlowVideoDurationInSeconds = () => {
@@ -14636,6 +15720,10 @@ var samplesObservedState = () => {
     const videoSizesInBytes = Array.from(videoSamples.values()).reduce((acc, size) => acc + size, 0);
     return videoSizesInBytes * 8 / videoDuration;
   };
+  const getLastSampleObserved = () => lastSampleObserved;
+  const setLastSampleObserved = () => {
+    lastSampleObserved = true;
+  };
   return {
     addVideoSample,
     addAudioSample,
@@ -14643,7 +15731,9 @@ var samplesObservedState = () => {
     getFps: getFps2,
     getSlowNumberOfFrames,
     getAudioBitrate,
-    getVideoBitrate
+    getVideoBitrate,
+    getLastSampleObserved,
+    setLastSampleObserved
   };
 };
 
@@ -14779,8 +15869,8 @@ var makeParserState = ({
   const structure = structureState();
   const keyframes = keyframesState();
   const emittedFields = emittedState();
-  const slowDurationAndFps = samplesObservedState();
-  const mp3Info = makeMp3State();
+  const samplesObserved = samplesObservedState();
+  const mp3 = makeMp3State();
   const images = imagesState();
   const timings = timingsState();
   const seekInfiniteLoop = seekInfiniteLoopDetectionState();
@@ -14800,7 +15890,7 @@ var makeParserState = ({
     callbacks
   });
   return {
-    riff: riffSpecificState(),
+    riff: riffSpecificState({ controller, logLevel, readerInterface, src }),
     transportStream: transportStreamState(),
     webm: webmState({ controller, logLevel, readerInterface, src }),
     iso: isoBaseMediaState({
@@ -14810,7 +15900,7 @@ var makeParserState = ({
       src,
       logLevel
     }),
-    mp3Info,
+    mp3,
     aac: aacState(),
     flac: flacState(),
     m3u: m3uState(logLevel),
@@ -14822,7 +15912,7 @@ var makeParserState = ({
       fields,
       keyframes,
       emittedFields,
-      slowDurationAndFpsState: slowDurationAndFps,
+      samplesObserved,
       structure,
       src,
       seekSignal: controller._internals.seekSignal,
@@ -14840,7 +15930,7 @@ var makeParserState = ({
     onVideoTrack,
     emittedFields,
     fields,
-    slowDurationAndFps,
+    samplesObserved,
     contentLength,
     images,
     mediaSection: mediaSectionState(),
@@ -15004,7 +16094,13 @@ var internalParseMedia = async function({
     mp4HeaderSegment: state.mp4HeaderSegment,
     mediaSectionState: state.mediaSection,
     isoState: state.iso,
-    transportStream: state.transportStream
+    transportStream: state.transportStream,
+    flacState: state.flac,
+    samplesObserved: state.samplesObserved,
+    riffState: state.riff,
+    mp3State: state.mp3,
+    contentLength: state.contentLength,
+    aacState: state.aac
   })));
   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."));