@remotion/media-parser 4.0.301 → 4.0.303

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

@@ -309,14 +309,7 @@ var fetchReadContent = async ({
     throw new Error("src must be a string when using `fetchReader`");
   }
   const fallbackName = src.toString().split("/").pop();
-  const {
-    reader,
-    contentLength,
-    needsContentRange,
-    name,
-    supportsContentRange,
-    contentType
-  } = await makeFetchRequestOrGetCached({
+  const res = makeFetchRequestOrGetCached({
     range,
     src,
     controller,
@@ -325,6 +318,14 @@ var fetchReadContent = async ({
   });
   const key = cacheKey({ src, range });
   prefetchCache.delete(key);
+  const {
+    reader,
+    contentLength,
+    needsContentRange,
+    name,
+    supportsContentRange,
+    contentType
+  } = await res;
   if (controller) {
     controller._internals.signal.addEventListener("abort", () => {
       reader.reader.cancel().catch(() => {});
@@ -1073,6 +1074,14 @@ var getTrakBoxByTrackId = (moovBox, trackId) => {
     return tkhd.trackId === trackId;
   }) ?? null;
 };
+var getElstBox = (trakBox) => {
+  const edtsBox = trakBox.children.find((s) => s.type === "regular-box" && s.boxType === "edts");
+  if (!edtsBox || edtsBox.type !== "regular-box") {
+    return null;
+  }
+  const elstBox = edtsBox.children.find((s) => s.type === "elst-box");
+  return elstBox;
+};
 
 // src/containers/riff/traversal.ts
 var isRiffAvi = (structure) => {
@@ -3331,7 +3340,7 @@ var getVideoCodecFromIsoTrak = (trakBox) => {
 };
 
 // src/containers/iso-base-media/make-track.ts
-var makeBaseMediaTrack = (trakBox) => {
+var makeBaseMediaTrack = (trakBox, startTimeInSeconds) => {
   const tkhdBox = getTkhdBox(trakBox);
   const videoDescriptors = getVideoDescriptors(trakBox);
   const timescaleAndDuration = getTimescaleAndDuration(trakBox);
@@ -3368,7 +3377,8 @@ var makeBaseMediaTrack = (trakBox) => {
       sampleRate: actual.sampleRate,
       description: actual.codecPrivate?.data ?? undefined,
       codecData: actual.codecPrivate,
-      codecEnum
+      codecEnum,
+      startInSeconds: startTimeInSeconds
     };
   }
   if (!trakBoxContainsVideo(trakBox)) {
@@ -3376,7 +3386,8 @@ var makeBaseMediaTrack = (trakBox) => {
       type: "other",
       trackId: tkhdBox.trackId,
       timescale: timescaleAndDuration.timescale,
-      trakBox
+      trakBox,
+      startInSeconds: startTimeInSeconds
     };
   }
   const videoSample = getStsdVideoConfig(trakBox);
@@ -3423,11 +3434,33 @@ var makeBaseMediaTrack = (trakBox) => {
     colorSpace: mediaParserAdvancedColorToWebCodecsColor(advancedColor),
     advancedColor,
     codecEnum: getVideoCodecFromIsoTrak(trakBox),
-    fps: getFpsFromMp4TrakBox(trakBox)
+    fps: getFpsFromMp4TrakBox(trakBox),
+    startInSeconds: startTimeInSeconds
   };
   return track;
 };
 
+// src/containers/iso-base-media/mdat/get-editlist.ts
+var findTrackStartTimeInSeconds = ({
+  movieTimeScale,
+  trakBox
+}) => {
+  const elstBox = getElstBox(trakBox);
+  if (!elstBox) {
+    return 0;
+  }
+  const { entries } = elstBox;
+  let dwellTime = 0;
+  for (const entry of entries) {
+    const { editDuration, mediaTime } = entry;
+    if (mediaTime !== -1) {
+      continue;
+    }
+    dwellTime += editDuration;
+  }
+  return dwellTime / movieTimeScale;
+};
+
 // src/containers/avc/codec-string.ts
 var getCodecStringFromSpsAndPps = (sps) => {
   return `avc1.${sps.spsData.profile.toString(16).padStart(2, "0")}${sps.spsData.compatibility.toString(16).padStart(2, "0")}${sps.spsData.level.toString(16).padStart(2, "0")}`;
@@ -3526,7 +3559,8 @@ var makeAviAudioTrack = ({
     numberOfChannels: strf.numberOfChannels,
     sampleRate: strf.sampleRate,
     timescale: MEDIA_PARSER_RIFF_TIMESCALE,
-    trackId: index
+    trackId: index,
+    startInSeconds: 0
   };
 };
 var makeAviVideoTrack = ({
@@ -3569,7 +3603,8 @@ var makeAviVideoTrack = ({
       numerator: 1,
       denominator: 1
     },
-    fps: strh.rate / strh.scale
+    fps: strh.rate / strh.scale,
+    startInSeconds: 0
   };
 };
 var getTracksFromAvi = (structure, state) => {
@@ -4222,7 +4257,8 @@ var getTrack = ({
       colorSpace: mediaParserAdvancedColorToWebCodecsColor(advancedColor),
       advancedColor,
       codecEnum,
-      fps: null
+      fps: null,
+      startInSeconds: 0
     };
   }
   if (trackTypeToString(trackType2.value.value) === "audio") {
@@ -4244,7 +4280,8 @@ var getTrack = ({
       codecData: codecPrivate2 ? codecString === "opus" ? { type: "ogg-identification", data: codecPrivate2 } : { type: "unknown-data", data: codecPrivate2 } : null,
       codecEnum: getMatroskaAudioCodecEnum({
         track
-      })
+      }),
+      startInSeconds: 0
     };
   }
   return null;
@@ -4365,7 +4402,15 @@ var getTracksFromMoovBox = (moovBox) => {
   const mediaParserTracks = [];
   const tracks2 = getTraks(moovBox);
   for (const trakBox of tracks2) {
-    const track = makeBaseMediaTrack(trakBox);
+    const mvhdBox = getMvhdBox(moovBox);
+    if (!mvhdBox) {
+      throw new Error("Mvhd box is not found");
+    }
+    const startTime = findTrackStartTimeInSeconds({
+      movieTimeScale: mvhdBox.timeScale,
+      trakBox
+    });
+    const track = makeBaseMediaTrack(trakBox, startTime);
     if (!track) {
       continue;
     }
@@ -5827,13 +5872,14 @@ var findKeyframeBeforeTime = ({
   time,
   timescale,
   mediaSections,
-  logLevel
+  logLevel,
+  startInSeconds
 }) => {
   let videoByte = 0;
   let videoSample = null;
   for (const sample of samplePositions) {
-    const ctsInSeconds = sample.cts / timescale;
-    const dtsInSeconds = sample.dts / timescale;
+    const ctsInSeconds = sample.cts / timescale + startInSeconds;
+    const dtsInSeconds = sample.dts / timescale + startInSeconds;
     if (!sample.isKeyframe) {
       continue;
     }
@@ -6078,7 +6124,8 @@ var getSeekingByteFromFragmentedMp4 = async ({
         time,
         timescale: firstTrack.timescale,
         logLevel,
-        mediaSections: info.mediaSections
+        mediaSections: info.mediaSections,
+        startInSeconds: firstTrack.startInSeconds
       });
       if (kf) {
         return {
@@ -6180,7 +6227,8 @@ var getSeekingByteFromIsoBaseMedia = ({
     time,
     timescale: track.timescale,
     logLevel,
-    mediaSections: info.mediaSections
+    mediaSections: info.mediaSections,
+    startInSeconds: track.startInSeconds
   });
   if (keyframe) {
     return Promise.resolve({
@@ -6486,7 +6534,8 @@ function findLastKeyframe({
 var getSeekingByteForRiff = async ({
   info,
   time,
-  riffState
+  riffState,
+  avcState
 }) => {
   const idx1Entries = await (info.hasIndex ? riffState.lazyIdx1.waitForLoaded() : Promise.resolve(null));
   if (idx1Entries === null) {
@@ -6500,6 +6549,8 @@ var getSeekingByteForRiff = async ({
       };
     }
     riffState.sampleCounter.setSamplesFromSeek(lastKeyframe.sampleCounts);
+    riffState.queuedBFrames.clear();
+    avcState.clear();
     return {
       type: "do-seek",
       byte: lastKeyframe.positionInBytes
@@ -6529,6 +6580,8 @@ var getSeekingByteForRiff = async ({
     throw new Error("moviOffset is null");
   }
   riffState.sampleCounter.setSamplesFromSeek(bestEntry.sampleCounts);
+  riffState.queuedBFrames.clear();
+  avcState.clear();
   return {
     type: "do-seek",
     byte: bestEntry.offset + info.moviOffset - 4
@@ -6677,7 +6730,8 @@ var convertAudioOrVideoSampleToWebCodecsTimestamps = ({
     trackId: sample.trackId,
     type: sample.type,
     offset: sample.offset,
-    timescale: TARGET_TIMESCALE
+    timescale: TARGET_TIMESCALE,
+    ..."avc" in sample ? { avc: sample.avc } : {}
   };
 };
 
@@ -6790,11 +6844,38 @@ var getKeyFrameOrDeltaFromAvcInfo = (infos) => {
   if (!keyOrDelta) {
     throw new Error("expected avc to contain info about key or delta");
   }
-  return keyOrDelta.type === "keyframe" ? "key" : "delta";
+  return keyOrDelta.type === "keyframe" ? "key" : keyOrDelta.isBidirectionalFrame ? "bidirectional" : "delta";
 };
 
 // src/containers/avc/parse-avc.ts
 var Extended_SAR = 255;
+var getPoc = (iterator, sps, avcState, isReferencePicture) => {
+  const { pic_order_cnt_type, log2_max_pic_order_cnt_lsb_minus4 } = sps;
+  if (pic_order_cnt_type !== 0) {
+    return null;
+  }
+  const prevPicOrderCntLsb = avcState.getPrevPicOrderCntLsb();
+  const prevPicOrderCntMsb = avcState.getPrevPicOrderCntMsb();
+  if (log2_max_pic_order_cnt_lsb_minus4 === null) {
+    throw new Error("log2_max_pic_order_cnt_lsb_minus4 is null");
+  }
+  const max_pic_order_cnt_lsb = 2 ** (log2_max_pic_order_cnt_lsb_minus4 + 4);
+  const pic_order_cnt_lsb = iterator.getBits(log2_max_pic_order_cnt_lsb_minus4 + 4);
+  let picOrderCntMsb;
+  if (pic_order_cnt_lsb < prevPicOrderCntLsb && prevPicOrderCntLsb - pic_order_cnt_lsb >= max_pic_order_cnt_lsb / 2) {
+    picOrderCntMsb = prevPicOrderCntMsb + max_pic_order_cnt_lsb;
+  } else if (pic_order_cnt_lsb > prevPicOrderCntLsb && pic_order_cnt_lsb - prevPicOrderCntLsb > max_pic_order_cnt_lsb / 2) {
+    picOrderCntMsb = prevPicOrderCntMsb - max_pic_order_cnt_lsb;
+  } else {
+    picOrderCntMsb = prevPicOrderCntMsb;
+  }
+  const poc = picOrderCntMsb + pic_order_cnt_lsb;
+  if (isReferencePicture) {
+    avcState.setPrevPicOrderCntLsb(pic_order_cnt_lsb);
+    avcState.setPrevPicOrderCntMsb(picOrderCntMsb);
+  }
+  return poc;
+};
 var readVuiParameters = (iterator) => {
   let sar_width = null;
   let sar_height = null;
@@ -6940,7 +7021,8 @@ var readSps = (iterator) => {
     frame_crop_right_offset,
     frame_crop_top_offset,
     mb_adaptive_frame_field_flag,
-    vui_parameters
+    vui_parameters,
+    pic_order_cnt_type
   };
 };
 var findEnd = (buffer) => {
@@ -6958,17 +7040,23 @@ var findEnd = (buffer) => {
   }
   return null;
 };
-var inspect = (buffer) => {
+var inspect = (buffer, avcState) => {
   const iterator = getArrayBufferIterator(buffer, buffer.byteLength);
   iterator.startReadingBits();
   iterator.getBits(1);
-  iterator.getBits(2);
+  const nal_ref_idc = iterator.getBits(2);
+  const isReferencePicture = nal_ref_idc !== 0;
   const type = iterator.getBits(5);
-  iterator.stopReadingBits();
   if (type === 7) {
+    iterator.stopReadingBits();
     const end = findEnd(buffer);
     const data = readSps(iterator);
     const sps = buffer.slice(0, end === null ? Infinity : end);
+    avcState.setSps(data);
+    if (isReferencePicture) {
+      avcState.setPrevPicOrderCntLsb(0);
+      avcState.setPrevPicOrderCntMsb(0);
+    }
     return {
       spsData: data,
       sps,
@@ -6976,11 +7064,31 @@ var inspect = (buffer) => {
     };
   }
   if (type === 5) {
+    avcState.setPrevPicOrderCntLsb(0);
+    avcState.setPrevPicOrderCntMsb(0);
+    iterator.readExpGolomb();
+    iterator.readExpGolomb();
+    iterator.readExpGolomb();
+    const sps = avcState.getSps();
+    if (!sps) {
+      throw new Error("SPS not found");
+    }
+    const numberOfBitsForFrameNum = sps.log2_max_frame_num_minus4 + 4;
+    iterator.getBits(numberOfBitsForFrameNum);
+    iterator.readExpGolomb();
+    const { pic_order_cnt_type } = sps;
+    let poc = null;
+    if (pic_order_cnt_type === 0) {
+      poc = getPoc(iterator, sps, avcState, isReferencePicture);
+    }
+    iterator.stopReadingBits();
     return {
-      type: "keyframe"
+      type: "keyframe",
+      poc
     };
   }
   if (type === 8) {
+    iterator.stopReadingBits();
     const end = findEnd(buffer);
     const pps = buffer.slice(0, end === null ? Infinity : end);
     return {
@@ -6989,14 +7097,32 @@ var inspect = (buffer) => {
     };
   }
   if (type === 1) {
+    iterator.readExpGolomb();
+    const slice_type = iterator.readExpGolomb();
+    const isBidirectionalFrame = slice_type === 6;
+    iterator.readExpGolomb();
+    const sps = avcState.getSps();
+    if (!sps) {
+      throw new Error("SPS not found");
+    }
+    const numberOfBitsForFrameNum = sps.log2_max_frame_num_minus4 + 4;
+    iterator.getBits(numberOfBitsForFrameNum);
+    const { pic_order_cnt_type } = sps;
+    let poc = null;
+    if (pic_order_cnt_type === 0) {
+      poc = getPoc(iterator, sps, avcState, isReferencePicture);
+    }
+    iterator.stopReadingBits();
     return {
-      type: "delta-frame"
+      type: "delta-frame",
+      isBidirectionalFrame,
+      poc
     };
   }
   iterator.destroy();
   return null;
 };
-var parseAvc = (buffer) => {
+var parseAvc = (buffer, avcState) => {
   let zeroesInARow = 0;
   const infos = [];
   for (let i = 0;i < buffer.length; i++) {
@@ -7007,7 +7133,7 @@ var parseAvc = (buffer) => {
     }
     if (zeroesInARow >= 2 && val === 1) {
       zeroesInARow = 0;
-      const info = inspect(buffer.slice(i + 1, i + 100));
+      const info = inspect(buffer.slice(i + 1, i + 100), avcState);
       if (info) {
         infos.push(info);
         if (info.type === "keyframe" || info.type === "delta-frame") {
@@ -7042,9 +7168,10 @@ var handleAvcPacket = async ({
   logLevel,
   onVideoTrack,
   transportStream,
-  makeSamplesStartAtZero
+  makeSamplesStartAtZero,
+  avcState
 }) => {
-  const avc = parseAvc(streamBuffer.getBuffer());
+  const avc = parseAvc(streamBuffer.getBuffer(), avcState);
   const isTrackRegistered = sampleCallbacks.tracks.getTracks().find((t) => {
     return t.trackId === programId;
   });
@@ -7081,7 +7208,8 @@ var handleAvcPacket = async ({
         numerator: sampleAspectRatio.width
       },
       colorSpace: mediaParserAdvancedColorToWebCodecsColor(advancedColor),
-      advancedColor
+      advancedColor,
+      startInSeconds: 0
     };
     await registerVideoTrack({
       track,
@@ -7100,7 +7228,7 @@ var handleAvcPacket = async ({
     duration: undefined,
     data: streamBuffer.getBuffer(),
     trackId: programId,
-    type,
+    type: type === "bidirectional" ? "delta" : type,
     offset,
     timescale: MPEG_TIMESCALE
   };
@@ -7167,7 +7295,8 @@ var getSeekingByte = ({
   m3uPlaylistContext,
   structure,
   riffState,
-  m3uState
+  m3uState,
+  avcState
 }) => {
   if (info.type === "iso-base-media-seeking-hints") {
     return getSeekingByteFromIsoBaseMedia({
@@ -7227,7 +7356,8 @@ var getSeekingByte = ({
     return getSeekingByteForRiff({
       info,
       time,
-      riffState
+      riffState,
+      avcState
     });
   }
   if (info.type === "mp3-seeking-hints") {
@@ -7790,7 +7920,8 @@ var turnSeekIntoByte = async ({
   mp3State,
   contentLength,
   aacState,
-  m3uState
+  m3uState,
+  avcState
 }) => {
   const mediaSections = mediaSectionState2.getMediaSections();
   if (mediaSections.length === 0) {
@@ -7836,7 +7967,8 @@ var turnSeekIntoByte = async ({
     m3uPlaylistContext,
     structure: structureState,
     riffState,
-    m3uState
+    m3uState,
+    avcState
   });
   return seekingByte;
 };
@@ -7867,7 +7999,8 @@ var getWorkOnSeekRequestOptions = (state) => {
     mp3State: state.mp3,
     aacState: state.aac,
     m3uState: state.m3u,
-    prefetchCache: state.prefetchCache
+    prefetchCache: state.prefetchCache,
+    avcState: state.avc
   };
 };
 var workOnSeekRequest = async (options) => {
@@ -7897,7 +8030,8 @@ var workOnSeekRequest = async (options) => {
     mp3State,
     aacState,
     prefetchCache,
-    m3uState
+    m3uState,
+    avcState
   } = options;
   const seek2 = controller._internals.seekSignal.getSeek();
   if (seek2 === null) {
@@ -7922,7 +8056,8 @@ var workOnSeekRequest = async (options) => {
     mp3State,
     contentLength,
     aacState,
-    m3uState
+    m3uState,
+    avcState
   });
   Log.trace(logLevel, `Seek action: ${JSON.stringify(resolution)}`);
   if (resolution.type === "intermediary-seek") {
@@ -8501,6 +8636,10 @@ var checkIfDone = async (state) => {
     if (state.structure.getStructure().type === "m3u" && !state.m3u.getAllChunksProcessedOverall()) {
       return false;
     }
+    state.riff.queuedBFrames.flush();
+    if (state.riff.queuedBFrames.hasReleasedFrames()) {
+      return false;
+    }
     Log.verbose(state.logLevel, "Reached end of file");
     await state.discardReadBytes(true);
     return true;
@@ -8579,7 +8718,8 @@ var parseAac = async (state) => {
         sampleRate,
         timescale: 1e6,
         trackId: 0,
-        type: "audio"
+        type: "audio",
+        startInSeconds: 0
       },
       registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
       tracks: state.callbacks.tracks,
@@ -8980,7 +9120,8 @@ var parseStreamInfo = async ({
       numberOfChannels: channels2,
       sampleRate,
       timescale: 1e6,
-      trackId: 0
+      trackId: 0,
+      startInSeconds: 0
     },
     registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
     tracks: state.callbacks.tracks,
@@ -9298,6 +9439,41 @@ var structureState = () => {
   };
 };
 
+// src/containers/iso-base-media/elst.ts
+var parseElst = ({
+  iterator,
+  size,
+  offset
+}) => {
+  const { expectNoMoreBytes } = iterator.startBox(size - 8);
+  const version = iterator.getUint8();
+  const flags = iterator.getUint24();
+  const entryCount = iterator.getUint32();
+  const entries = [];
+  for (let i = 0;i < entryCount; i++) {
+    const editDuration = iterator.getUint32();
+    const mediaTime = iterator.getInt32();
+    const mediaRateInteger = iterator.getUint16();
+    const mediaRateFraction = iterator.getUint16();
+    entries.push({
+      editDuration,
+      mediaTime,
+      mediaRateInteger,
+      mediaRateFraction
+    });
+  }
+  expectNoMoreBytes();
+  const result = {
+    type: "elst-box",
+    version,
+    flags,
+    entries,
+    boxSize: size,
+    offset
+  };
+  return result;
+};
+
 // src/containers/iso-base-media/esds/decoder-specific-config.ts
 var parseDecoderSpecificConfig = (iterator) => {
   const layerTag = iterator.getUint8();
@@ -10896,6 +11072,16 @@ var processBox = async ({
       box: parseFtyp({ iterator, size: boxSize, offset: fileOffset })
     };
   }
+  if (boxType === "elst") {
+    return {
+      type: "box",
+      box: parseElst({
+        iterator,
+        size: boxSize,
+        offset: fileOffset
+      })
+    };
+  }
   if (boxType === "colr") {
     return {
       type: "box",
@@ -10906,9 +11092,18 @@ var processBox = async ({
     };
   }
   if (boxType === "mvhd") {
+    const mvhdBox = parseMvhd({
+      iterator,
+      offset: fileOffset,
+      size: boxSize
+    });
+    if (!onlyIfMoovAtomExpected) {
+      throw new Error("State is required");
+    }
+    onlyIfMoovAtomExpected.movieTimeScaleState.setTrackTimescale(mvhdBox.timeScale);
     return {
       type: "box",
-      box: parseMvhd({ iterator, offset: fileOffset, size: boxSize })
+      box: mvhdBox
     };
   }
   if (boxType === "tkhd") {
@@ -11076,14 +11271,19 @@ var processBox = async ({
       throw new Error("State is required");
     }
     const { tracks: tracks2, onAudioTrack, onVideoTrack } = onlyIfMoovAtomExpected;
-    const box = await parseTrak({
+    const trakBox = await parseTrak({
       size: boxSize,
       offsetAtStart: fileOffset,
       iterator,
       logLevel,
       contentLength
     });
-    const transformedTrack = makeBaseMediaTrack(box);
+    const movieTimeScale = onlyIfMoovAtomExpected.movieTimeScaleState.getTrackTimescale();
+    if (movieTimeScale === null) {
+      throw new Error("Movie timescale is not set");
+    }
+    const editList = findTrackStartTimeInSeconds({ movieTimeScale, trakBox });
+    const transformedTrack = makeBaseMediaTrack(trakBox, editList);
     if (transformedTrack && transformedTrack.type === "video") {
       await registerVideoTrack({
         track: transformedTrack,
@@ -11104,7 +11304,7 @@ var processBox = async ({
         onAudioTrack
       });
     }
-    return { type: "box", box };
+    return { type: "box", box: trakBox };
   }
   if (boxType === "stts") {
     return {
@@ -11177,7 +11377,7 @@ var processBox = async ({
   if (boxType === "moof") {
     await onlyIfMoovAtomExpected?.isoState?.mfra.triggerLoad();
   }
-  if (boxType === "mdia" || boxType === "minf" || boxType === "stbl" || boxType === "udta" || boxType === "moof" || boxType === "dims" || boxType === "meta" || boxType === "wave" || boxType === "traf" || boxType === "mfra" || boxType === "stsb") {
+  if (boxType === "mdia" || boxType === "minf" || boxType === "stbl" || boxType === "udta" || boxType === "moof" || boxType === "dims" || boxType === "meta" || boxType === "wave" || boxType === "traf" || boxType === "mfra" || boxType === "edts" || boxType === "stsb") {
     const children = await getIsoBaseMediaChildren({
       iterator,
       size: boxSize - 8,
@@ -11278,6 +11478,7 @@ var getMoovAtom = async ({
       onlyIfMoovAtomExpected: {
         tracks: tracksState,
         isoState: null,
+        movieTimeScaleState: state.iso.movieTimeScale,
         onAudioTrack,
         onVideoTrack,
         registerVideoSampleCallback: () => Promise.resolve(),
@@ -11518,7 +11719,18 @@ var parseMdatSection = async (state) => {
   if (iterator.bytesRemaining() < samplesWithIndex.samplePosition.size) {
     return makeFetchMoreData(samplesWithIndex.samplePosition.size - iterator.bytesRemaining());
   }
-  const { cts, dts, duration: duration2, isKeyframe, offset, bigEndian, chunkSize } = samplesWithIndex.samplePosition;
+  const {
+    cts: rawCts,
+    dts: rawDts,
+    duration: duration2,
+    isKeyframe,
+    offset,
+    bigEndian,
+    chunkSize
+  } = samplesWithIndex.samplePosition;
+  const { timescale, startInSeconds } = samplesWithIndex.track;
+  const cts = rawCts + startInSeconds * timescale;
+  const dts = rawDts + startInSeconds * timescale;
   const bytes = postprocessBytes({
     bytes: iterator.getSlice(samplesWithIndex.samplePosition.size),
     bigEndian,
@@ -11535,9 +11747,9 @@ var parseMdatSection = async (state) => {
         trackId: samplesWithIndex.track.trackId,
         type: isKeyframe ? "key" : "delta",
         offset,
-        timescale: samplesWithIndex.track.timescale
+        timescale
       },
-      timescale: samplesWithIndex.track.timescale
+      timescale
     });
     await state.callbacks.onAudioSample(samplesWithIndex.track.trackId, audioSample);
   }
@@ -11558,9 +11770,9 @@ var parseMdatSection = async (state) => {
         trackId: samplesWithIndex.track.trackId,
         type: isKeyframe && !isRecoveryPoint ? "key" : "delta",
         offset,
-        timescale: samplesWithIndex.track.timescale
+        timescale
       },
-      timescale: samplesWithIndex.track.timescale
+      timescale
     });
     await state.callbacks.onVideoSample(samplesWithIndex.track.trackId, videoSample);
   }
@@ -11585,6 +11797,7 @@ var parseIsoBaseMedia = async (state) => {
     onlyIfMoovAtomExpected: {
       tracks: state.callbacks.tracks,
       isoState: state.iso,
+      movieTimeScaleState: state.iso.movieTimeScale,
       onAudioTrack: state.onAudioTrack,
       onVideoTrack: state.onVideoTrack,
       registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
@@ -12896,7 +13109,8 @@ var parseMpegHeader = async ({
         numberOfChannels,
         sampleRate,
         timescale: 1e6,
-        trackId: 0
+        trackId: 0,
+        startInSeconds: 0
       },
       registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
       tracks: state.callbacks.tracks,
@@ -12992,6 +13206,73 @@ var parseMp3 = async (state) => {
   throw new Error("Unknown MP3 header " + JSON.stringify(bytes));
 };
 
+// src/containers/riff/get-strh-for-index.ts
+var getStrhForIndex = (structure, trackId) => {
+  const boxes = getStrlBoxes(structure);
+  const box = boxes[trackId];
+  if (!box) {
+    throw new Error("Expected box");
+  }
+  const strh = getStrhBox(box.children);
+  if (!strh) {
+    throw new Error("strh");
+  }
+  return strh;
+};
+
+// src/containers/riff/convert-queued-sample-to-mediaparser-sample.ts
+var getKeyFrameOffsetAndPocs = ({
+  state,
+  sample
+}) => {
+  if (sample.type === "key") {
+    const sampleOffset = state.riff.sampleCounter.getSampleCountForTrack({
+      trackId: sample.trackId
+    });
+    return {
+      sampleOffsetAtKeyframe: sampleOffset,
+      pocsAtKeyframeOffset: [sample.avc?.poc ?? 0]
+    };
+  }
+  const riffKeyframes = state.riff.sampleCounter.riffKeys.getKeyframes();
+  const keyframeAtOffset = riffKeyframes.findLast((k) => k.positionInBytes <= sample.offset);
+  if (!keyframeAtOffset) {
+    throw new Error("no keyframe at offset");
+  }
+  const sampleOffsetAtKeyframe = keyframeAtOffset.sampleCounts[sample.trackId];
+  const pocsAtKeyframeOffset = state.riff.sampleCounter.getPocAtKeyframeOffset({
+    keyframeOffset: keyframeAtOffset.positionInBytes
+  });
+  return {
+    sampleOffsetAtKeyframe,
+    pocsAtKeyframeOffset
+  };
+};
+var convertQueuedSampleToMediaParserSample = (sample, state) => {
+  const strh = getStrhForIndex(state.structure.getRiffStructure(), sample.trackId);
+  const samplesPerSecond = strh.rate / strh.scale;
+  const { sampleOffsetAtKeyframe, pocsAtKeyframeOffset } = getKeyFrameOffsetAndPocs({
+    sample,
+    state
+  });
+  const indexOfPoc = pocsAtKeyframeOffset.findIndex((poc) => poc === sample.avc?.poc);
+  if (indexOfPoc === -1) {
+    throw new Error("poc not found");
+  }
+  const nthSample = indexOfPoc + sampleOffsetAtKeyframe;
+  const timestamp = nthSample / samplesPerSecond;
+  const videoSample = convertAudioOrVideoSampleToWebCodecsTimestamps({
+    sample: {
+      ...sample,
+      timestamp,
+      cts: timestamp,
+      dts: timestamp
+    },
+    timescale: 1
+  });
+  return videoSample;
+};
+
 // src/containers/riff/is-movi.ts
 var isMoviAtom = (iterator, ckId) => {
   if (ckId !== "LIST") {
@@ -13370,18 +13651,6 @@ var expectRiffBox = async ({
 };
 
 // src/containers/riff/parse-movi.ts
-var getStrhForIndex = (structure, trackId) => {
-  const boxes = getStrlBoxes(structure);
-  const box = boxes[trackId];
-  if (!box) {
-    throw new Error("Expected box");
-  }
-  const strh = getStrhBox(box.children);
-  if (!strh) {
-    throw new Error("strh");
-  }
-  return strh;
-};
 var handleChunk = async ({
   state,
   ckId,
@@ -13394,42 +13663,60 @@ var handleChunk = async ({
     const trackId = parseInt(videoChunk[1], 10);
     const strh = getStrhForIndex(state.structure.getRiffStructure(), trackId);
     const samplesPerSecond = strh.rate / strh.scale;
-    const nthSample = state.riff.sampleCounter.getSamplesForTrack(trackId);
-    const timeInSec = nthSample / samplesPerSecond;
-    const timestamp = timeInSec;
     const data = iterator.getSlice(ckSize);
-    const infos = parseAvc(data);
+    const infos = parseAvc(data, state.avc);
     const keyOrDelta = getKeyFrameOrDeltaFromAvcInfo(infos);
+    const info = infos.find((i) => i.type === "keyframe" || i.type === "delta-frame");
     const avcProfile = infos.find((i) => i.type === "avc-profile");
     const ppsProfile = infos.find((i) => i.type === "avc-pps");
     if (avcProfile && ppsProfile && !state.riff.getAvcProfile()) {
       await state.riff.onProfile({ pps: ppsProfile, sps: avcProfile });
       state.callbacks.tracks.setIsDone(state.logLevel);
     }
-    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);
+    const rawSample = {
+      data,
+      duration: 1 / samplesPerSecond,
+      trackId,
+      type: keyOrDelta === "bidirectional" ? "delta" : keyOrDelta,
+      offset,
+      timescale: samplesPerSecond,
+      avc: info
+    };
+    const maxFramesInBuffer = state.avc.getMaxFramesInBuffer();
+    if (maxFramesInBuffer === null) {
+      throw new Error("maxFramesInBuffer is null");
+    }
+    if ((info?.poc ?? null) === null) {
+      throw new Error("poc is null");
+    }
+    const keyframeOffset = state.riff.sampleCounter.getKeyframeAtOffset(rawSample);
+    if (keyframeOffset !== null) {
+      state.riff.sampleCounter.setPocAtKeyframeOffset({
+        keyframeOffset,
+        poc: info.poc
+      });
+    }
+    state.riff.queuedBFrames.addFrame(rawSample, maxFramesInBuffer);
+    const releasedFrame = state.riff.queuedBFrames.getReleasedFrame();
+    if (!releasedFrame) {
+      return;
+    }
+    const videoSample = convertQueuedSampleToMediaParserSample(releasedFrame, state);
+    state.riff.sampleCounter.onVideoSample(videoSample);
     await state.callbacks.onVideoSample(trackId, videoSample);
-    return;
   }
   const audioChunk = ckId.match(/^([0-9]{2})wb$/);
   if (audioChunk) {
     const trackId = parseInt(audioChunk[1], 10);
     const strh = getStrhForIndex(state.structure.getRiffStructure(), trackId);
-    const samplesPerSecond = strh.rate / strh.scale;
-    const nthSample = state.riff.sampleCounter.getSamplesForTrack(trackId);
+    const { strf } = strh;
+    if (strf.type !== "strf-box-audio") {
+      throw new Error("audio");
+    }
+    const samplesPerSecond = strh.rate / strh.scale * strf.numberOfChannels;
+    const nthSample = state.riff.sampleCounter.getSampleCountForTrack({
+      trackId
+    });
     const timeInSec = nthSample / samplesPerSecond;
     const timestamp = timeInSec;
     const data = iterator.getSlice(ckSize);
@@ -13489,6 +13776,13 @@ var parseMediaSection = async (state) => {
 
 // src/containers/riff/parse-riff-body.ts
 var parseRiffBody = async (state) => {
+  const releasedFrame = state.riff.queuedBFrames.getReleasedFrame();
+  if (releasedFrame) {
+    const converted = convertQueuedSampleToMediaParserSample(releasedFrame, state);
+    state.riff.sampleCounter.onVideoSample(converted);
+    await state.callbacks.onVideoSample(releasedFrame.trackId, converted);
+    return null;
+  }
   if (state.mediaSection.isCurrentByteInMediaSection(state.iterator) === "in-section") {
     if (maySkipVideoData({
       state
@@ -13869,7 +14163,8 @@ var handleAacPacket = async ({
       codec: mapAudioObjectTypeToCodecString(audioObjectType),
       description: codecPrivate2,
       numberOfChannels: channelConfiguration,
-      sampleRate
+      sampleRate,
+      startInSeconds: 0
     };
     await registerAudioTrack({
       track,
@@ -13956,7 +14251,8 @@ var processStreamBuffer = async ({
   onAudioTrack,
   onVideoTrack,
   transportStream,
-  makeSamplesStartAtZero
+  makeSamplesStartAtZero,
+  avcState
 }) => {
   const stream = getStreamForId(structure, programId);
   if (!stream) {
@@ -13974,7 +14270,8 @@ var processStreamBuffer = async ({
       onVideoTrack,
       offset: streamBuffer.offset,
       transportStream,
-      makeSamplesStartAtZero
+      makeSamplesStartAtZero,
+      avcState
     });
   } else if (stream.streamType === 15) {
     await handleAacPacket({
@@ -14003,7 +14300,8 @@ var processFinalStreamBuffers = async ({
   onAudioTrack,
   onVideoTrack,
   transportStream,
-  makeSamplesStartAtZero
+  makeSamplesStartAtZero,
+  avcState
 }) => {
   for (const [programId, buffer] of transportStream.streamBuffers) {
     if (buffer.getBuffer().byteLength > 0) {
@@ -14016,7 +14314,8 @@ var processFinalStreamBuffers = async ({
         onAudioTrack,
         onVideoTrack,
         transportStream,
-        makeSamplesStartAtZero
+        makeSamplesStartAtZero,
+        avcState
       });
       transportStream.streamBuffers.delete(programId);
     }
@@ -14143,7 +14442,8 @@ var processAudio = async ({
   onAudioTrack,
   onVideoTrack,
   transportStream,
-  makeSamplesStartAtZero
+  makeSamplesStartAtZero,
+  avcState
 }) => {
   const { streamBuffers, nextPesHeaderStore: nextPesHeader } = transportStream;
   const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
@@ -14170,7 +14470,8 @@ var processAudio = async ({
     onAudioTrack,
     onVideoTrack,
     transportStream,
-    makeSamplesStartAtZero
+    makeSamplesStartAtZero,
+    avcState
   });
   const rest = streamBuffer.getBuffer().slice(expectedLength);
   streamBuffers.set(transportStreamEntry.pid, makeTransportStreamPacketBuffer({
@@ -14199,7 +14500,8 @@ var processVideo = async ({
   onAudioTrack,
   onVideoTrack,
   transportStream,
-  makeSamplesStartAtZero
+  makeSamplesStartAtZero,
+  avcState
 }) => {
   const indexOfSeparator = streamBuffer.get2ndSubArrayIndex();
   if (indexOfSeparator === -1 || indexOfSeparator === 0) {
@@ -14221,7 +14523,8 @@ var processVideo = async ({
     onAudioTrack,
     onVideoTrack,
     transportStream,
-    makeSamplesStartAtZero
+    makeSamplesStartAtZero,
+    avcState
   });
   return rest;
 };
@@ -14249,7 +14552,8 @@ var processSampleIfPossible = async (state) => {
           onAudioTrack: state.onAudioTrack,
           onVideoTrack: state.onVideoTrack,
           transportStream: state.transportStream,
-          makeSamplesStartAtZero: state.makeSamplesStartAtZero
+          makeSamplesStartAtZero: state.makeSamplesStartAtZero,
+          avcState: state.avc
         });
         state.transportStream.streamBuffers.delete(stream.pid);
         state.transportStream.streamBuffers.set(stream.pid, makeTransportStreamPacketBuffer({
@@ -14272,7 +14576,8 @@ var processSampleIfPossible = async (state) => {
           onVideoTrack: state.onVideoTrack,
           transportStream: state.transportStream,
           makeSamplesStartAtZero: state.makeSamplesStartAtZero,
-          transportStreamEntry: stream
+          transportStreamEntry: stream,
+          avcState: state.avc
         });
         processed = true;
         break;
@@ -14309,7 +14614,8 @@ var parseTransportStream = async (state) => {
       logLevel: state.logLevel,
       onAudioTrack: state.onAudioTrack,
       onVideoTrack: state.onVideoTrack,
-      makeSamplesStartAtZero: state.makeSamplesStartAtZero
+      makeSamplesStartAtZero: state.makeSamplesStartAtZero,
+      avcState: state.avc
     });
   }
   return Promise.resolve(null);
@@ -14376,7 +14682,8 @@ var parseFmt = async ({
       numberOfChannels,
       sampleRate,
       timescale: 1e6,
-      trackId: 0
+      trackId: 0,
+      startInSeconds: 0
     },
     container: "wav",
     registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
@@ -14589,7 +14896,8 @@ var addAvcToTrackAndActivateTrackIfNecessary = async ({
   trackNumber: trackNumber2,
   logLevel,
   callbacks,
-  onVideoTrack
+  onVideoTrack,
+  avcState
 }) => {
   if (codec !== "V_MPEG4/ISO/AVC") {
     return;
@@ -14601,7 +14909,7 @@ var addAvcToTrackAndActivateTrackIfNecessary = async ({
   if (missingTracks.length === 0) {
     return;
   }
-  const parsed = parseAvc(partialVideoSample.data);
+  const parsed = parseAvc(partialVideoSample.data, avcState);
   for (const parse of parsed) {
     if (parse.type === "avc-profile") {
       webmState.setAvcProfileForTrackNumber(trackNumber2, parse);
@@ -14635,7 +14943,8 @@ var getSampleFromBlock = async ({
   structureState: structureState2,
   callbacks,
   logLevel,
-  onVideoTrack
+  onVideoTrack,
+  avcState
 }) => {
   const iterator = getArrayBufferIterator(ebml.value, ebml.value.length);
   const trackNumber2 = iterator.getVint();
@@ -14682,7 +14991,8 @@ var getSampleFromBlock = async ({
       trackNumber: trackNumber2,
       callbacks,
       logLevel,
-      onVideoTrack
+      onVideoTrack,
+      avcState
     });
     const sample = {
       ...partialVideoSample,
@@ -14816,7 +15126,8 @@ var postprocessEbml = async ({
     logLevel,
     onAudioTrack,
     onVideoTrack,
-    structureState: structureState2
+    structureState: structureState2,
+    avcState
   }
 }) => {
   if (ebml.type === "TimestampScale") {
@@ -14865,7 +15176,8 @@ var postprocessEbml = async ({
       structureState: structureState2,
       callbacks,
       logLevel,
-      onVideoTrack
+      onVideoTrack,
+      avcState
     });
     if (sample.type === "video-sample") {
       await callbacks.onVideoSample(sample.videoSample.trackId, sample.videoSample);
@@ -14904,7 +15216,8 @@ var postprocessEbml = async ({
       structureState: structureState2,
       callbacks,
       logLevel,
-      onVideoTrack
+      onVideoTrack,
+      avcState
     });
     if (sample && sample.type === "partial-video-sample") {
       const completeFrame = {
@@ -15033,7 +15346,8 @@ var selectStatesForProcessing = ({
   onAudioTrack,
   onVideoTrack,
   structure,
-  webm
+  webm,
+  avc
 }) => {
   return {
     webmState: webm,
@@ -15041,7 +15355,8 @@ var selectStatesForProcessing = ({
     logLevel,
     onAudioTrack,
     onVideoTrack,
-    structureState: structure
+    structureState: structure,
+    avcState: avc
   };
 };
 
@@ -15251,9 +15566,6 @@ var runParseIteration = async ({
   if (structure && structure.type === "m3u") {
     return parseM3u({ state });
   }
-  if (state.iterator.bytesRemaining() === 0) {
-    return Promise.reject(new Error("no bytes"));
-  }
   if (structure === null) {
     await initVideo({
       state
@@ -15554,6 +15866,82 @@ var aacState = () => {
   };
 };
 
+// src/containers/avc/max-buffer-size.ts
+var maxMacroblocksByLevel = {
+  10: 396,
+  11: 900,
+  12: 2376,
+  13: 2376,
+  20: 2376,
+  21: 4752,
+  22: 8100,
+  30: 8100,
+  31: 18000,
+  32: 20480,
+  40: 32768,
+  41: 32768,
+  42: 34816,
+  50: 110400,
+  51: 184320,
+  52: 184320,
+  60: 696320,
+  61: 696320,
+  62: 696320
+};
+var macroBlocksPerFrame = (sps) => {
+  const { pic_width_in_mbs_minus1, pic_height_in_map_units_minus1 } = sps;
+  return (pic_width_in_mbs_minus1 + 1) * (pic_height_in_map_units_minus1 + 1);
+};
+var maxMacroblockBufferSize = (sps) => {
+  const { level } = sps;
+  const maxMacroblocks = maxMacroblocksByLevel[level];
+  if (maxMacroblocks === undefined) {
+    throw new Error(`Unsupported level: ${level.toString(16)}`);
+  }
+  return maxMacroblocks;
+};
+
+// src/state/avc/avc-state.ts
+var avcState = () => {
+  let prevPicOrderCntLsb = 0;
+  let prevPicOrderCntMsb = 0;
+  let sps = null;
+  let maxFramesInBuffer = null;
+  return {
+    getPrevPicOrderCntLsb() {
+      return prevPicOrderCntLsb;
+    },
+    getPrevPicOrderCntMsb() {
+      return prevPicOrderCntMsb;
+    },
+    setPrevPicOrderCntLsb(value) {
+      prevPicOrderCntLsb = value;
+    },
+    setPrevPicOrderCntMsb(value) {
+      prevPicOrderCntMsb = value;
+    },
+    setSps(value) {
+      const macroblockBufferSize = macroBlocksPerFrame(value);
+      const maxBufferSize = maxMacroblockBufferSize(value);
+      const maxFrames = Math.min(16, Math.floor(maxBufferSize / macroblockBufferSize));
+      maxFramesInBuffer = maxFrames;
+      sps = value;
+    },
+    getSps() {
+      return sps;
+    },
+    getMaxFramesInBuffer() {
+      return maxFramesInBuffer;
+    },
+    clear() {
+      maxFramesInBuffer = null;
+      sps = null;
+      prevPicOrderCntLsb = 0;
+      prevPicOrderCntMsb = 0;
+    }
+  };
+};
+
 // src/state/current-reader.ts
 var currentReader = (initialReader) => {
   let current = initialReader;
@@ -15794,6 +16182,17 @@ var moovState = () => {
   };
 };
 
+// src/state/iso-base-media/timescale-state.ts
+var movieTimeScaleState = () => {
+  let trackTimescale = null;
+  return {
+    getTrackTimescale: () => trackTimescale,
+    setTrackTimescale: (timescale) => {
+      trackTimescale = timescale;
+    }
+  };
+};
+
 // src/state/iso-base-media/iso-state.ts
 var isoBaseMediaState = ({
   contentLength,
@@ -15815,7 +16214,8 @@ var isoBaseMediaState = ({
       prefetchCache
     }),
     moof: precomputedMoofState(),
-    tfra: precomputedTfraState()
+    tfra: precomputedTfraState(),
+    movieTimeScale: movieTimeScaleState()
   };
 };
 
@@ -16471,6 +16871,43 @@ var lazyIdx1Fetch = ({
   };
 };
 
+// src/state/riff/queued-frames.ts
+var queuedBFramesState = () => {
+  const queuedFrames = [];
+  const releasedFrames = [];
+  const flush = () => {
+    releasedFrames.push(...queuedFrames);
+    queuedFrames.length = 0;
+  };
+  return {
+    addFrame: (frame, maxFramesInBuffer) => {
+      if (frame.type === "key") {
+        flush();
+        releasedFrames.push(frame);
+        return;
+      }
+      queuedFrames.push(frame);
+      if (queuedFrames.length > maxFramesInBuffer) {
+        releasedFrames.push(queuedFrames.shift());
+      }
+    },
+    flush,
+    getReleasedFrame: () => {
+      if (releasedFrames.length === 0) {
+        return null;
+      }
+      return releasedFrames.shift();
+    },
+    hasReleasedFrames: () => {
+      return releasedFrames.length > 0;
+    },
+    clear: () => {
+      releasedFrames.length = 0;
+      queuedFrames.length = 0;
+    }
+  };
+};
+
 // src/state/riff/riff-keyframes.ts
 var riffKeyframesState = () => {
   const keyframes = [];
@@ -16479,6 +16916,7 @@ var riffKeyframesState = () => {
       return;
     }
     keyframes.push(keyframe);
+    keyframes.sort((a, b) => a.positionInBytes - b.positionInBytes);
   };
   const getKeyframes2 = () => {
     return keyframes;
@@ -16498,6 +16936,7 @@ var riffKeyframesState = () => {
 // src/state/riff/sample-counter.ts
 var riffSampleCounter = () => {
   const samplesForTrack = {};
+  const pocsAtKeyframeOffset = {};
   const riffKeys = riffKeyframesState();
   const onAudioSample = (trackId, audioSample) => {
     if (typeof samplesForTrack[trackId] === "undefined") {
@@ -16508,13 +16947,13 @@ var riffSampleCounter = () => {
     }
     samplesForTrack[trackId]++;
   };
-  const onVideoSample = (trackId, videoSample) => {
-    if (typeof samplesForTrack[trackId] === "undefined") {
-      samplesForTrack[trackId] = 0;
+  const onVideoSample = (videoSample) => {
+    if (typeof samplesForTrack[videoSample.trackId] === "undefined") {
+      samplesForTrack[videoSample.trackId] = 0;
     }
     if (videoSample.type === "key") {
       riffKeys.addKeyframe({
-        trackId,
+        trackId: videoSample.trackId,
         decodingTimeInSeconds: videoSample.dts / videoSample.timescale,
         positionInBytes: videoSample.offset,
         presentationTimeInSeconds: videoSample.cts / videoSample.timescale,
@@ -16523,10 +16962,10 @@ var riffSampleCounter = () => {
       });
     }
     if (videoSample.data.length > 0) {
-      samplesForTrack[trackId]++;
+      samplesForTrack[videoSample.trackId]++;
     }
   };
-  const getSamplesForTrack = (trackId) => {
+  const getSampleCountForTrack = ({ trackId }) => {
     return samplesForTrack[trackId] ?? 0;
   };
   const setSamplesFromSeek = (samples) => {
@@ -16534,12 +16973,39 @@ var riffSampleCounter = () => {
       samplesForTrack[trackId] = samples[trackId];
     }
   };
+  const setPocAtKeyframeOffset = ({
+    keyframeOffset,
+    poc
+  }) => {
+    if (typeof pocsAtKeyframeOffset[keyframeOffset] === "undefined") {
+      pocsAtKeyframeOffset[keyframeOffset] = [];
+    }
+    if (pocsAtKeyframeOffset[keyframeOffset].includes(poc)) {
+      return;
+    }
+    pocsAtKeyframeOffset[keyframeOffset].push(poc);
+    pocsAtKeyframeOffset[keyframeOffset].sort((a, b) => a - b);
+  };
+  const getPocAtKeyframeOffset = ({
+    keyframeOffset
+  }) => {
+    return pocsAtKeyframeOffset[keyframeOffset];
+  };
+  const getKeyframeAtOffset = (sample) => {
+    if (sample.type === "key") {
+      return sample.offset;
+    }
+    return riffKeys.getKeyframes().findLast((k) => k.positionInBytes <= sample.offset)?.positionInBytes ?? null;
+  };
   return {
     onAudioSample,
     onVideoSample,
-    getSamplesForTrack,
+    getSampleCountForTrack,
     setSamplesFromSeek,
-    riffKeys
+    riffKeys,
+    setPocAtKeyframeOffset,
+    getPocAtKeyframeOffset,
+    getKeyframeAtOffset
   };
 };
 
@@ -16572,6 +17038,7 @@ var riffSpecificState = ({
     prefetchCache
   });
   const sampleCounter = riffSampleCounter();
+  const queuedBFrames = queuedBFramesState();
   return {
     getAvcProfile: () => {
       return avcProfile;
@@ -16581,6 +17048,7 @@ var riffSpecificState = ({
     getNextTrackIndex: () => {
       return nextTrackIndex;
     },
+    queuedBFrames,
     incrementNextTrackIndex: () => {
       nextTrackIndex++;
     },
@@ -16920,6 +17388,7 @@ var makeParserState = ({
   const timings = timingsState();
   const seekInfiniteLoop = seekInfiniteLoopDetectionState();
   const currentReaderState = currentReader(initialReaderInstance);
+  const avc = avcState();
   const errored = null;
   const discardReadBytes = async (force) => {
     const { bytesRemoved, removedData } = iterator.removeBytesRead(force, mode);
@@ -17013,7 +17482,8 @@ var makeParserState = ({
     currentReader: currentReaderState,
     seekInfiniteLoop,
     makeSamplesStartAtZero,
-    prefetchCache
+    prefetchCache,
+    avc
   };
 };