@remotion/media-parser 4.0.332 → 4.0.334

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

@@ -1228,6 +1228,17 @@ var getAvccBox = (trakBox) => {
   }
   return avccBox;
 };
+var getVpccBox = (trakBox) => {
+  const videoConfig = getStsdVideoConfig(trakBox);
+  if (!videoConfig) {
+    return null;
+  }
+  const vpccBox = videoConfig.descriptors.find((c) => c.type === "vpcc-box");
+  if (!vpccBox || vpccBox.type !== "vpcc-box") {
+    return null;
+  }
+  return vpccBox;
+};
 var getAv1CBox = (trakBox) => {
   const videoConfig = getStsdVideoConfig(trakBox);
   if (!videoConfig) {
@@ -3053,21 +3064,25 @@ var getIsoBmColrConfig = (trakBox) => {
 var getVideoCodecString = (trakBox) => {
   const videoSample = getStsdVideoConfig(trakBox);
   const avccBox = getAvccBox(trakBox);
-  const hvccBox = getHvccBox(trakBox);
-  const av1cBox = getAv1CBox(trakBox);
   if (!videoSample) {
     return null;
   }
   if (avccBox) {
     return `${videoSample.format}.${avccBox.configurationString}`;
   }
+  const hvccBox = getHvccBox(trakBox);
   if (hvccBox) {
     return `${videoSample.format}.${hvccBox.configurationString}`;
   }
+  const av1cBox = getAv1CBox(trakBox);
   if (av1cBox) {
     const colrAtom = getColrBox(videoSample);
     return parseAv1PrivateData(av1cBox.privateData, colrAtom);
   }
+  const vpccBox = getVpccBox(trakBox);
+  if (vpccBox) {
+    return `${videoSample.format}.${vpccBox.codecString}`;
+  }
   return videoSample.format;
 };
 
@@ -3287,6 +3302,9 @@ var getVideoCodecFromIsoTrak = (trakBox) => {
       if (videoSample.format === "av01") {
         return "av1";
       }
+      if (videoSample.format === "vp09") {
+        return "vp9";
+      }
       if (videoSample.format === "ap4h") {
         return "prores";
       }
@@ -7913,7 +7931,8 @@ var performSeek = async ({
   src,
   discardReadBytes,
   fields,
-  prefetchCache
+  prefetchCache,
+  isoState
 }) => {
   const byteInMediaSection = isByteInMediaSection({
     position: seekTo,
@@ -7977,6 +7996,9 @@ var performSeek = async ({
       prefetchCache
     });
   }
+  if (userInitiated) {
+    isoState.flatSamples.updateAfterSeek(seekTo);
+  }
   await controller._internals.checkForAbortAndPause();
 };
 
@@ -8155,7 +8177,8 @@ var workOnSeekRequest = async (options) => {
       src,
       discardReadBytes,
       fields,
-      prefetchCache
+      prefetchCache,
+      isoState
     });
     return;
   }
@@ -8175,7 +8198,8 @@ var workOnSeekRequest = async (options) => {
       src,
       discardReadBytes,
       fields,
-      prefetchCache
+      prefetchCache,
+      isoState
     });
     const { hasChanged } = controller._internals.seekSignal.clearSeekIfStillSame(seek2);
     if (hasChanged) {
@@ -9285,9 +9309,10 @@ var parseFlac = ({
 };
 
 // src/state/iso-base-media/cached-sample-positions.ts
-var calculateFlatSamples = ({
+var calculateSamplePositions = ({
   state,
-  mediaSectionStart
+  mediaSectionStart,
+  trackIds
 }) => {
   const tracks2 = getTracks(state, true);
   const moofBoxes = getMoofBoxes(state.structure.getIsoStructure().boxes);
@@ -9309,11 +9334,13 @@ var calculateFlatSamples = ({
   if (!moov) {
     throw new Error("No moov box found");
   }
-  const offsets = [];
-  const trackIds = [];
-  const map = new Map;
+  const trackIdAndSamplePositions = [];
   for (const track of tracks2) {
     const trakBox = getTrakBoxByTrackId(moov, track.trackId);
+    if (!trackIds.includes(track.trackId)) {
+      Log.verbose(state.logLevel, "Skipping calculating sample positions for track", track.trackId);
+      continue;
+    }
     if (!trakBox) {
       throw new Error("No trak box found");
     }
@@ -9323,36 +9350,88 @@ var calculateFlatSamples = ({
       moofComplete,
       trexBoxes: getTrexBoxes(moov)
     });
-    trackIds.push(track.trackId);
-    for (const samplePosition of samplePositions) {
-      offsets.push(samplePosition.offset);
-      map.set(samplePosition.offset, {
-        track,
-        samplePosition
-      });
+    trackIdAndSamplePositions.push({
+      trackId: track.trackId,
+      samplePositions
+    });
+  }
+  return trackIdAndSamplePositions;
+};
+var updateSampleIndicesAfterSeek = ({
+  samplePositionsForMdatStart,
+  seekedByte
+}) => {
+  const currentSampleIndices = {};
+  const keys = Object.keys(samplePositionsForMdatStart).map(Number).sort();
+  const mdat = keys.find((key) => seekedByte >= key);
+  if (!mdat) {
+    return currentSampleIndices;
+  }
+  const samplePositions = samplePositionsForMdatStart[mdat];
+  if (!samplePositions) {
+    return currentSampleIndices;
+  }
+  for (const track of samplePositions) {
+    const currentSampleIndex = track.samplePositions.findIndex((sample) => sample.offset >= seekedByte);
+    if (!currentSampleIndices[mdat]) {
+      currentSampleIndices[mdat] = {};
+    }
+    if (!currentSampleIndices[mdat][track.trackId]) {
+      currentSampleIndices[mdat][track.trackId] = 0;
+    }
+    if (currentSampleIndex === -1) {
+      currentSampleIndices[mdat][track.trackId] = track.samplePositions.length;
+    } else {
+      currentSampleIndices[mdat][track.trackId] = currentSampleIndex;
     }
   }
-  offsets.sort((a, b) => a - b);
-  return { flatSamples: map, offsets, trackIds };
+  return currentSampleIndices;
 };
 var cachedSamplePositionsState = () => {
-  const cachedForMdatStart = {};
-  const jumpMarksForMdatStart = {};
+  const samplePositionsForMdatStart = {};
+  let currentSampleIndex = {};
   return {
     getSamples: (mdatStart) => {
-      return cachedForMdatStart[mdatStart] ?? null;
+      return samplePositionsForMdatStart[mdatStart] ?? null;
     },
     setSamples: (mdatStart, samples) => {
-      cachedForMdatStart[mdatStart] = samples;
+      samplePositionsForMdatStart[mdatStart] = samples;
     },
-    setJumpMarks: (mdatStart, marks) => {
-      jumpMarksForMdatStart[mdatStart] = marks;
+    setCurrentSampleIndex: (mdatStart, trackId, index) => {
+      if (!currentSampleIndex[mdatStart]) {
+        currentSampleIndex[mdatStart] = {};
+      }
+      if (!currentSampleIndex[mdatStart][trackId]) {
+        currentSampleIndex[mdatStart][trackId] = 0;
+      }
+      currentSampleIndex[mdatStart][trackId] = index;
     },
-    getJumpMarks: (mdatStart) => {
-      return jumpMarksForMdatStart[mdatStart];
+    getCurrentSampleIndices: (mdatStart) => {
+      return currentSampleIndex[mdatStart] ?? {};
+    },
+    updateAfterSeek: (seekedByte) => {
+      currentSampleIndex = updateSampleIndicesAfterSeek({
+        samplePositionsForMdatStart,
+        seekedByte
+      });
     }
   };
 };
+var getSampleWithLowestDts = (samplePositions, currentSampleIndexMap) => {
+  const lowestDts = [];
+  for (const track of samplePositions) {
+    const currentSampleIndex = currentSampleIndexMap[track.trackId] ?? 0;
+    const currentSample = track.samplePositions[currentSampleIndex];
+    if (currentSample && (lowestDts.length === 0 || currentSample.decodingTimestamp <= lowestDts[0].samplePosition.decodingTimestamp)) {
+      lowestDts.push({
+        samplePosition: currentSample,
+        trackId: track.trackId,
+        index: currentSampleIndex
+      });
+    }
+  }
+  return lowestDts;
+};
 
 // src/state/iso-base-media/last-moof-box.ts
 var getLastMoofBox = (boxes) => {
@@ -10551,7 +10630,9 @@ var videoTags = [
   "hvc1",
   "hev1",
   "ap4h",
-  "av01"
+  "av01",
+  "vp08",
+  "vp09"
 ];
 var audioTags = [
   0,
@@ -10950,6 +11031,53 @@ var parseStts = ({
   };
 };
 
+// src/containers/iso-base-media/stsd/vpcc.ts
+var getvp09ConfigurationString = ({
+  profile,
+  level,
+  bitDepth: bitDepth2
+}) => {
+  return `${String(profile).padStart(2, "0")}.${String(level).padStart(2, "0")}.${String(bitDepth2).padStart(2, "0")}`;
+};
+var parseVpcc = ({
+  data,
+  size
+}) => {
+  const box = data.startBox(size - 8);
+  const confVersion = data.getUint8();
+  if (confVersion !== 1) {
+    throw new Error(`Unsupported AVCC version ${confVersion}`);
+  }
+  data.discard(3);
+  const profile = data.getUint8();
+  const level = data.getUint8();
+  data.startReadingBits();
+  const bitDepth2 = data.getBits(4);
+  const chromaSubsampling = data.getBits(3);
+  const videoFullRangeFlag = data.getBits(1);
+  const videoColorPrimaries = data.getBits(8);
+  const videoTransferCharacteristics = data.getBits(8);
+  const videoMatrixCoefficients = data.getBits(8);
+  data.stopReadingBits();
+  const codecInitializationDataSize = data.getUint16();
+  const codecInitializationData = data.getSlice(codecInitializationDataSize);
+  box.expectNoMoreBytes();
+  return {
+    type: "vpcc-box",
+    profile,
+    level,
+    bitDepth: bitDepth2,
+    chromaSubsampling,
+    videoFullRangeFlag,
+    videoColorPrimaries,
+    videoTransferCharacteristics,
+    videoMatrixCoefficients,
+    codecInitializationDataSize,
+    codecInitializationData,
+    codecString: getvp09ConfigurationString({ profile, level, bitDepth: bitDepth2 })
+  };
+};
+
 // src/containers/iso-base-media/tfdt.ts
 var parseTfdt = ({
   iterator,
@@ -11277,7 +11405,7 @@ var processBox = async ({
   if (boxType === "stsz") {
     return {
       type: "box",
-      box: await parseStsz({
+      box: parseStsz({
         iterator,
         offset: fileOffset,
         size: boxSize
@@ -11287,7 +11415,7 @@ var processBox = async ({
   if (boxType === "stco" || boxType === "co64") {
     return {
       type: "box",
-      box: await parseStco({
+      box: parseStco({
         iterator,
         offset: fileOffset,
         size: boxSize,
@@ -11298,7 +11426,7 @@ var processBox = async ({
   if (boxType === "pasp") {
     return {
       type: "box",
-      box: await parsePasp({
+      box: parsePasp({
         iterator,
         offset: fileOffset,
         size: boxSize
@@ -11308,7 +11436,7 @@ var processBox = async ({
   if (boxType === "stss") {
     return {
       type: "box",
-      box: await parseStss({
+      box: parseStss({
         iterator,
         offset: fileOffset,
         boxSize
@@ -11318,7 +11446,7 @@ var processBox = async ({
   if (boxType === "ctts") {
     return {
       type: "box",
-      box: await parseCtts({
+      box: parseCtts({
         iterator,
         offset: fileOffset,
         size: boxSize
@@ -11328,7 +11456,7 @@ var processBox = async ({
   if (boxType === "stsc") {
     return {
       type: "box",
-      box: await parseStsc({
+      box: parseStsc({
         iterator,
         offset: fileOffset,
         size: boxSize
@@ -11447,7 +11575,7 @@ var processBox = async ({
   if (boxType === "stts") {
     return {
       type: "box",
-      box: await parseStts({
+      box: parseStts({
         data: iterator,
         size: boxSize,
         fileOffset
@@ -11457,16 +11585,22 @@ var processBox = async ({
   if (boxType === "avcC") {
     return {
       type: "box",
-      box: await parseAvcc({
+      box: parseAvcc({
         data: iterator,
         size: boxSize
       })
     };
   }
+  if (boxType === "vpcC") {
+    return {
+      type: "box",
+      box: parseVpcc({ data: iterator, size: boxSize })
+    };
+  }
   if (boxType === "av1C") {
     return {
       type: "box",
-      box: await parseAv1C({
+      box: parseAv1C({
         data: iterator,
         size: boxSize
       })
@@ -11475,7 +11609,7 @@ var processBox = async ({
   if (boxType === "hvcC") {
     return {
       type: "box",
-      box: await parseHvcc({
+      box: parseHvcc({
         data: iterator,
         size: boxSize,
         offset: fileOffset
@@ -11485,7 +11619,7 @@ var processBox = async ({
   if (boxType === "tfhd") {
     return {
       type: "box",
-      box: await getTfhd({
+      box: getTfhd({
         iterator,
         offset: fileOffset,
         size: boxSize
@@ -11495,7 +11629,7 @@ var processBox = async ({
   if (boxType === "mdhd") {
     return {
       type: "box",
-      box: await parseMdhd({
+      box: parseMdhd({
         data: iterator,
         size: boxSize,
         fileOffset
@@ -11505,7 +11639,7 @@ var processBox = async ({
   if (boxType === "esds") {
     return {
       type: "box",
-      box: await parseEsds({
+      box: parseEsds({
         data: iterator,
         size: boxSize,
         fileOffset
@@ -11515,7 +11649,7 @@ var processBox = async ({
   if (boxType === "trex") {
     return {
       type: "box",
-      box: await parseTrex({ iterator, offset: fileOffset, size: boxSize })
+      box: parseTrex({ iterator, offset: fileOffset, size: boxSize })
     };
   }
   if (boxType === "moof") {
@@ -11654,127 +11788,6 @@ var getMoovAtom = async ({
   return moov;
 };
 
-// src/containers/iso-base-media/mdat/calculate-jump-marks.ts
-var MAX_SPREAD_IN_SECONDS = 8;
-var getKey = (samplePositionTrack) => {
-  return `${samplePositionTrack.track.trackId}-${samplePositionTrack.samplePosition.decodingTimestamp}.${samplePositionTrack.samplePosition.offset}`;
-};
-var findBestJump = ({
-  sampleMap,
-  offsetsSorted,
-  visited,
-  progresses
-}) => {
-  const minProgress = Math.min(...Object.values(progresses));
-  const trackNumberWithLowestProgress = Object.entries(progresses).find(([, progress]) => progress === minProgress)?.[0];
-  const firstSampleAboveMinProgress = offsetsSorted.findIndex((offset) => sampleMap.get(offset).track.trackId === Number(trackNumberWithLowestProgress) && !visited.has(getKey(sampleMap.get(offset))));
-  return firstSampleAboveMinProgress;
-};
-var calculateJumpMarks = ({
-  sampleMap,
-  offsetsSorted,
-  trackIds,
-  endOfMdat
-}) => {
-  const progresses = {};
-  for (const trackId of trackIds) {
-    progresses[trackId] = 0;
-  }
-  const jumpMarks = [];
-  let indexToVisit = 0;
-  const visited = new Set;
-  let rollOverToProcess = false;
-  const increaseIndex = () => {
-    indexToVisit++;
-    if (indexToVisit >= offsetsSorted.length) {
-      rollOverToProcess = true;
-      indexToVisit = 0;
-    }
-  };
-  let lastVisitedSample = null;
-  const addJumpMark = ({
-    firstSampleAboveMinProgress
-  }) => {
-    if (!lastVisitedSample) {
-      throw new Error("no last visited sample");
-    }
-    const jumpMark = {
-      afterSampleWithOffset: lastVisitedSample.samplePosition.offset,
-      jumpToOffset: offsetsSorted[firstSampleAboveMinProgress]
-    };
-    indexToVisit = firstSampleAboveMinProgress;
-    jumpMarks.push(jumpMark);
-  };
-  const addFinalJumpIfNecessary = () => {
-    if (indexToVisit === offsetsSorted.length - 1) {
-      return;
-    }
-    jumpMarks.push({
-      afterSampleWithOffset: offsetsSorted[indexToVisit],
-      jumpToOffset: endOfMdat
-    });
-  };
-  const considerJump = () => {
-    const firstSampleAboveMinProgress = findBestJump({
-      sampleMap,
-      offsetsSorted,
-      visited,
-      progresses
-    });
-    if (firstSampleAboveMinProgress > -1 && firstSampleAboveMinProgress !== indexToVisit + 1) {
-      addJumpMark({ firstSampleAboveMinProgress });
-      indexToVisit = firstSampleAboveMinProgress;
-    } else {
-      while (true) {
-        increaseIndex();
-        if (!visited.has(getKey(sampleMap.get(offsetsSorted[indexToVisit])))) {
-          break;
-        }
-      }
-    }
-  };
-  while (true) {
-    const currentSamplePosition = sampleMap.get(offsetsSorted[indexToVisit]);
-    const sampleKey = getKey(currentSamplePosition);
-    if (visited.has(sampleKey)) {
-      considerJump();
-      continue;
-    }
-    visited.add(sampleKey);
-    if (rollOverToProcess) {
-      if (!lastVisitedSample) {
-        throw new Error("no last visited sample");
-      }
-      jumpMarks.push({
-        afterSampleWithOffset: lastVisitedSample.samplePosition.offset,
-        jumpToOffset: currentSamplePosition.samplePosition.offset
-      });
-      rollOverToProcess = false;
-    }
-    lastVisitedSample = currentSamplePosition;
-    if (visited.size === offsetsSorted.length) {
-      addFinalJumpIfNecessary();
-      break;
-    }
-    const timestamp = currentSamplePosition.samplePosition.decodingTimestamp / currentSamplePosition.track.originalTimescale;
-    progresses[currentSamplePosition.track.trackId] = timestamp;
-    const progressValues = Object.values(progresses);
-    const maxProgress = Math.max(...progressValues);
-    const minProgress = Math.min(...progressValues);
-    const spread = maxProgress - minProgress;
-    if (visited.size === offsetsSorted.length) {
-      addFinalJumpIfNecessary();
-      break;
-    }
-    if (spread > MAX_SPREAD_IN_SECONDS) {
-      considerJump();
-    } else {
-      increaseIndex();
-    }
-  }
-  return jumpMarks;
-};
-
 // src/containers/iso-base-media/mdat/postprocess-bytes.ts
 var postprocessBytes = ({
   bytes,
@@ -11835,52 +11848,53 @@ var parseMdatSection = async (state) => {
       endOfMdat,
       state
     });
+    const tracksFromMoov = getTracksFromMoovBox(moov);
     state.iso.moov.setMoovBox({
       moovBox: moov,
       precomputed: false
     });
+    const existingTracks = state.callbacks.tracks.getTracks();
+    for (const trackFromMoov of tracksFromMoov) {
+      if (existingTracks.find((t) => t.trackId === trackFromMoov.trackId)) {
+        continue;
+      }
+      if (trackFromMoov.type === "other") {
+        continue;
+      }
+      state.callbacks.tracks.addTrack(trackFromMoov);
+    }
     state.callbacks.tracks.setIsDone(state.logLevel);
     state.structure.getIsoStructure().boxes.push(moov);
     return parseMdatSection(state);
   }
+  const tracks2 = state.callbacks.tracks.getTracks();
   if (!state.iso.flatSamples.getSamples(mediaSection.start)) {
-    const {
-      flatSamples: flatSamplesMap,
-      offsets,
-      trackIds
-    } = calculateFlatSamples({
+    const samplePosition = calculateSamplePositions({
       state,
-      mediaSectionStart: mediaSection.start
+      mediaSectionStart: mediaSection.start,
+      trackIds: tracks2.map((t) => t.trackId)
     });
-    const calcedJumpMarks = calculateJumpMarks({
-      sampleMap: flatSamplesMap,
-      offsetsSorted: offsets,
-      trackIds,
-      endOfMdat
-    });
-    state.iso.flatSamples.setJumpMarks(mediaSection.start, calcedJumpMarks);
-    state.iso.flatSamples.setSamples(mediaSection.start, flatSamplesMap);
+    state.iso.flatSamples.setSamples(mediaSection.start, samplePosition);
   }
-  const flatSamples = state.iso.flatSamples.getSamples(mediaSection.start);
-  const jumpMarks = state.iso.flatSamples.getJumpMarks(mediaSection.start);
-  const { iterator } = state;
-  const samplesWithIndex = flatSamples.get(iterator.counter.getOffset());
-  if (!samplesWithIndex) {
-    const offsets = Array.from(flatSamples.keys());
-    const nextSample_ = offsets.filter((s) => s > iterator.counter.getOffset()).sort((a, b) => a - b)[0];
-    if (nextSample_) {
-      iterator.discard(nextSample_ - iterator.counter.getOffset());
-      return null;
-    }
-    Log.verbose(state.logLevel, "Could not find sample at offset", iterator.counter.getOffset(), "skipping to end of mdat");
+  const samplePositions = state.iso.flatSamples.getSamples(mediaSection.start);
+  const sampleIndices = state.iso.flatSamples.getCurrentSampleIndices(mediaSection.start);
+  const nextSampleArray = getSampleWithLowestDts(samplePositions, sampleIndices);
+  if (nextSampleArray.length === 0) {
+    Log.verbose(state.logLevel, "Iterated over all samples.", endOfMdat);
     return makeSkip(endOfMdat);
   }
-  if (samplesWithIndex.samplePosition.offset + samplesWithIndex.samplePosition.size > state.contentLength) {
-    Log.verbose(state.logLevel, "Sample is beyond the end of the file. Don't process it.", samplesWithIndex.samplePosition.offset + samplesWithIndex.samplePosition.size, endOfMdat);
+  const exactMatch = nextSampleArray.find((s) => s.samplePosition.offset === state.iterator.counter.getOffset());
+  const nextSample = exactMatch ?? nextSampleArray[0];
+  if (nextSample.samplePosition.offset !== state.iterator.counter.getOffset()) {
+    return makeSkip(nextSample.samplePosition.offset);
+  }
+  if (nextSample.samplePosition.offset + nextSample.samplePosition.size > state.contentLength) {
+    Log.verbose(state.logLevel, "Sample is beyond the end of the file. Don't process it.", nextSample.samplePosition.offset + nextSample.samplePosition.size, endOfMdat);
     return makeSkip(endOfMdat);
   }
-  if (iterator.bytesRemaining() < samplesWithIndex.samplePosition.size) {
-    return makeFetchMoreData(samplesWithIndex.samplePosition.size - iterator.bytesRemaining());
+  const { iterator } = state;
+  if (iterator.bytesRemaining() < nextSample.samplePosition.size) {
+    return makeFetchMoreData(nextSample.samplePosition.size - iterator.bytesRemaining());
   }
   const {
     timestamp: rawCts,
@@ -11890,21 +11904,22 @@ var parseMdatSection = async (state) => {
     offset,
     bigEndian,
     chunkSize
-  } = samplesWithIndex.samplePosition;
+  } = nextSample.samplePosition;
+  const track = tracks2.find((t) => t.trackId === nextSample.trackId);
   const {
     originalTimescale,
     startInSeconds,
     trackMediaTimeOffsetInTrackTimescale,
     timescale: trackTimescale
-  } = samplesWithIndex.track;
+  } = track;
   const cts = rawCts + startInSeconds * originalTimescale - trackMediaTimeOffsetInTrackTimescale / trackTimescale * WEBCODECS_TIMESCALE;
   const dts = rawDts + startInSeconds * originalTimescale - trackMediaTimeOffsetInTrackTimescale / trackTimescale * WEBCODECS_TIMESCALE;
   const bytes = postprocessBytes({
-    bytes: iterator.getSlice(samplesWithIndex.samplePosition.size),
+    bytes: iterator.getSlice(nextSample.samplePosition.size),
     bigEndian,
     chunkSize
   });
-  if (samplesWithIndex.track.type === "audio") {
+  if (track.type === "audio") {
     const audioSample = convertAudioOrVideoSampleToWebCodecsTimestamps({
       sample: {
         data: bytes,
@@ -11918,10 +11933,10 @@ var parseMdatSection = async (state) => {
     });
     await state.callbacks.onAudioSample({
       audioSample,
-      trackId: samplesWithIndex.track.trackId
+      trackId: track.trackId
     });
   }
-  if (samplesWithIndex.track.type === "video") {
+  if (track.type === "video") {
     const nalUnitType = bytes[4] & 31;
     let isRecoveryPoint = false;
     if (nalUnitType === 6) {
@@ -11941,14 +11956,10 @@ var parseMdatSection = async (state) => {
     });
     await state.callbacks.onVideoSample({
       videoSample,
-      trackId: samplesWithIndex.track.trackId
+      trackId: track.trackId
     });
   }
-  const jump = jumpMarks.find((j) => j.afterSampleWithOffset === offset);
-  if (jump) {
-    Log.verbose(state.logLevel, "Found jump mark", jump.jumpToOffset, "skipping to jump mark");
-    return makeSkip(jump.jumpToOffset);
-  }
+  state.iso.flatSamples.setCurrentSampleIndex(mediaSection.start, nextSample.trackId, nextSample.index + 1);
   return null;
 };
 
@@ -13016,10 +13027,7 @@ var innerParseMp3PacketHeader = (iterator) => {
     throw new Error("Expected Layer I, II or III");
   }
   const layer = layerBits === 3 ? 1 : layerBits === 2 ? 2 : 3;
-  const protectionBit = iterator.getBits(1);
-  if (protectionBit !== 1) {
-    throw new Error("Does not support CRC yet");
-  }
+  iterator.getBits(1);
   const bitrateIndex = iterator.getBits(4);
   const bitrateInKbit = getBitrateKB({
     bits: bitrateIndex,
@@ -15123,7 +15131,7 @@ var parseWav = (state) => {
   if (type === "id3") {
     return parseId32({ state });
   }
-  if (type === "junk" || type === "fllr") {
+  if (type === "junk" || type === "fllr" || type === "bext") {
     return parseJunk({ state });
   }
   if (type === "fact") {
@@ -16011,7 +16019,8 @@ var parseLoop = async ({
             fields: state.fields,
             src: state.src,
             discardReadBytes: state.discardReadBytes,
-            prefetchCache: state.prefetchCache
+            prefetchCache: state.prefetchCache,
+            isoState: state.iso
           });
           state.timings.timeSeeking += Date.now() - seekStart;
         }