@remotion/media-parser 4.0.241 → 4.0.243

package/dist/esm/index.mjs

@@ -1367,7 +1367,7 @@ var createIsoBaseMediaFtyp = ({
 };
 
 // src/version.ts
-var VERSION = "4.0.241";
+var VERSION = "4.0.243";
 
 // src/create/iso-base-media/create-ilst.ts
 var createIlst = (items) => {
@@ -3230,6 +3230,7 @@ var createMatroskaMedia = async ({
     chunk,
     isVideo
   }) => {
+    progressTracker.setPossibleLowestTimestamp(Math.min(chunk.timestamp, chunk.cts ?? Infinity, chunk.dts ?? Infinity));
     const smallestProgress = progressTracker.getSmallestProgress();
     if (!currentCluster.shouldMakeNewCluster({
       newT: smallestProgress,
@@ -3403,10 +3404,10 @@ var makeProgressTracker = () => {
     waitForProgress: () => {
       const { promise, resolve } = withResolvers();
       const on = () => {
-        eventEmitter.removeEventListener("processed", on);
+        eventEmitter.removeEventListener("progress", on);
         resolve();
       };
-      eventEmitter.addEventListener("processed", on);
+      eventEmitter.addEventListener("progress", on);
       return promise;
     },
     getStartingTimestamp,
@@ -4127,19 +4128,22 @@ var getFps = (segments) => {
   }
   throw new Error("Cannot get fps, not implemented");
 };
-var hasFps = (boxes) => {
+var hasFpsSuitedForSlowFps = (boxes) => {
   try {
-    if (boxes.type === "matroska") {
-      return true;
-    }
-    if (boxes.type === "transport-stream") {
-      return true;
-    }
     return getFps(boxes) !== null;
   } catch {
     return false;
   }
 };
+var hasFps = (boxes) => {
+  if (boxes.type === "matroska") {
+    return true;
+  }
+  if (boxes.type === "transport-stream") {
+    return true;
+  }
+  return hasFpsSuitedForSlowFps(boxes);
+};
 
 // src/get-audio-codec.ts
 var getAudioCodec = (boxes, parserState) => {
@@ -4485,7 +4489,8 @@ var isRiffAvi2 = (data) => {
     return false;
   }
   const fileType = data.subarray(8, 12);
-  return new TextDecoder().decode(fileType) === "AVI ";
+  const aviPattern = new Uint8Array([65, 86, 73, 32]);
+  return matchesPattern(aviPattern)(fileType);
 };
 var isRiffWave = (data) => {
   const riffPattern = new Uint8Array([82, 73, 70, 70]);
@@ -4493,7 +4498,8 @@ var isRiffWave = (data) => {
     return false;
   }
   const fileType = data.subarray(8, 12);
-  return new TextDecoder().decode(fileType) === "WAVE";
+  const wavePattern = new Uint8Array([87, 65, 86, 69]);
+  return matchesPattern(wavePattern)(fileType);
 };
 var isWebm = (data) => {
   return matchesPattern(webmPattern)(data.subarray(0, 4));
@@ -5454,14 +5460,19 @@ var makeBaseMediaTrack = (trakBox) => {
   return track;
 };
 
-// src/boxes/avc/codec-private.ts
-var getAvccBoxContent = (avc1Profile) => {
+// src/boxes/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")}`;
+};
+
+// src/boxes/avc/create-sps-pps-data.ts
+var createSpsPpsData = (avc1Profile) => {
   return combineUint8Arrays([
     new Uint8Array([
       1,
-      avc1Profile.sps.spsData.level,
-      avc1Profile.sps.spsData.compatibility,
       avc1Profile.sps.spsData.profile,
+      avc1Profile.sps.spsData.compatibility,
+      avc1Profile.sps.spsData.level,
       255,
       225
     ]),
@@ -5473,11 +5484,6 @@ var getAvccBoxContent = (avc1Profile) => {
   ]);
 };
 
-// src/boxes/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")}`;
-};
-
 // src/add-avc-profile-to-track.ts
 var addAvcProfileToTrack = (track, avc1Profile) => {
   if (avc1Profile === null) {
@@ -5486,7 +5492,7 @@ var addAvcProfileToTrack = (track, avc1Profile) => {
   return {
     ...track,
     codec: getCodecStringFromSpsAndPps(avc1Profile.sps),
-    codecPrivate: getAvccBoxContent(avc1Profile)
+    codecPrivate: createSpsPpsData(avc1Profile)
   };
 };
 
@@ -5575,7 +5581,7 @@ var getTracksFromAvi = (structure, state) => {
       continue;
     }
     if (strf.type === "strf-box-video") {
-      videoTracks.push(addAvcProfileToTrack(makeAviVideoTrack({ strh, strf, index: i }), state.getAvcProfile()));
+      videoTracks.push(addAvcProfileToTrack(makeAviVideoTrack({ strh, strf, index: i }), state.riff.getAvcProfile()));
     } else if (strh.fccType === "auds") {
       audioTracks.push(makeAviAudioTrack({ strf, index: i }));
     } else {
@@ -5627,7 +5633,7 @@ var getStreamForId = (structure, packetIdentifier) => {
 // src/boxes/transport-stream/get-tracks.ts
 var getTracksFromTransportStream = (structure, parserState) => {
   const programMapTable = findProgramMapTableOrThrow(structure);
-  const parserTracks = parserState.tracks.getTracks();
+  const parserTracks = parserState.callbacks.tracks.getTracks();
   const mapped = programMapTable.streams.map((stream) => {
     return parserTracks.find((track) => track.trackId === stream.pid);
   }).filter(truthy);
@@ -6029,6 +6035,15 @@ var getNumberOfTracks2 = (moovBox) => {
   }
   return mvHdBox.nextTrackId - 1;
 };
+var isoBaseMediaHasTracks = (structure) => {
+  const moovBox = getMoovBox(structure.boxes);
+  if (!moovBox) {
+    return false;
+  }
+  const numberOfTracks = getNumberOfTracks2(moovBox);
+  const tracks2 = getTraks(moovBox);
+  return tracks2.length === numberOfTracks;
+};
 var hasTracks = (structure, state) => {
   if (structure.type === "matroska") {
     const mainSegment = getMainSegment(structure.boxes);
@@ -6038,13 +6053,7 @@ var hasTracks = (structure, state) => {
     return getTracksSegment(mainSegment) !== null;
   }
   if (structure.type === "iso-base-media") {
-    const moovBox = getMoovBox(structure.boxes);
-    if (!moovBox) {
-      return false;
-    }
-    const numberOfTracks = getNumberOfTracks2(moovBox);
-    const tracks2 = getTraks(moovBox);
-    return tracks2.length === numberOfTracks;
+    return isoBaseMediaHasTracks(structure);
   }
   if (structure.type === "riff") {
     return hasAllTracksFromAvi(structure, state);
@@ -6062,7 +6071,7 @@ var getTracksFromMa = (segments, state) => {
   if (!mainSegment) {
     throw new Error("No main segment found");
   }
-  const matroskaTracks = getTracksFromMatroska(mainSegment, state.getTimescale());
+  const matroskaTracks = getTracksFromMatroska(mainSegment, state.webm.getTimescale());
   for (const track of matroskaTracks) {
     if (track.type === "video") {
       videoTracks.push(track);
@@ -6473,6 +6482,13 @@ var getDuration = (structure, parserState) => {
 var hasDuration = (structure, parserState) => {
   return hasTracks(structure, parserState);
 };
+var hasSlowDuration = (structure, parserState) => {
+  try {
+    return getDuration(structure, parserState) !== null;
+  } catch {
+    return false;
+  }
+};
 
 // src/get-is-hdr.ts
 var isVideoTrackHdr = (track) => {
@@ -6486,6 +6502,43 @@ var hasHdr = (boxes, state) => {
   return hasTracks(boxes, state);
 };
 
+// src/boxes/iso-base-media/get-keyframes.ts
+var getKeyframesFromIsoBaseMedia = (structure) => {
+  const { videoTracks } = getTracksFromIsoBaseMedia(structure.boxes);
+  const moofBox = getMoofBox(structure.boxes);
+  const allSamples = videoTracks.map((t) => {
+    const { timescale: ts } = t;
+    const samplePositions = getSamplePositionsFromTrack(t.trakBox, moofBox);
+    const keyframes = samplePositions.filter((k) => {
+      return k.isKeyframe;
+    }).map((k) => {
+      return {
+        trackId: t.trackId,
+        presentationTimeInSeconds: k.cts / ts,
+        decodingTimeInSeconds: k.dts / ts,
+        positionInBytes: k.offset,
+        sizeInBytes: k.size
+      };
+    });
+    return keyframes;
+  });
+  return allSamples.flat();
+};
+
+// src/get-keyframes.ts
+var getKeyframes = (structure) => {
+  if (structure.type === "iso-base-media") {
+    return getKeyframesFromIsoBaseMedia(structure);
+  }
+  return null;
+};
+var hasKeyframes = (structure, parserState) => {
+  if (structure.type === "iso-base-media") {
+    return hasTracks(structure, parserState);
+  }
+  return true;
+};
+
 // src/get-location.ts
 function parseLocation(locationString) {
   const locationPattern = /^([+-]\d{2}\.?\d{0,10})([+-]\d{3}\.?\d{0,10})([+-]\d+(\.\d+)?)?\/$/;
@@ -6529,35 +6582,93 @@ var emitAvailableInfo = ({
   contentLength,
   name,
   mimeType,
-  fieldsInReturnValue,
-  emittedFields
+  fieldsInReturnValue
 }) => {
   const keys = Object.keys(hasInfo);
+  const segments = state.structure.getStructureOrNull();
+  const { emittedFields } = state;
   for (const key of keys) {
     if (key === "structure") {
-      if (parseResult && hasInfo.structure && !emittedFields.structure) {
-        callbacks.onStructure?.(parseResult.segments);
+      if (parseResult && hasInfo.structure && !emittedFields.structure && segments) {
+        callbacks.onStructure?.(segments);
         if (fieldsInReturnValue.structure) {
-          returnValue.structure = parseResult.segments;
+          returnValue.structure = segments;
         }
         emittedFields.structure = true;
       }
       continue;
     }
     if (key === "durationInSeconds") {
-      if (hasInfo.durationInSeconds && !emittedFields.durationInSeconds && parseResult) {
-        const durationInSeconds = getDuration(parseResult.segments, state);
-        callbacks.onDurationInSeconds?.(durationInSeconds);
-        if (fieldsInReturnValue.durationInSeconds) {
-          returnValue.durationInSeconds = durationInSeconds;
+      if (hasInfo.durationInSeconds && parseResult && segments) {
+        if (!emittedFields.durationInSeconds) {
+          const durationInSeconds = getDuration(segments, state);
+          callbacks.onDurationInSeconds?.(durationInSeconds);
+          if (fieldsInReturnValue.durationInSeconds) {
+            returnValue.durationInSeconds = durationInSeconds;
+          }
+          emittedFields.durationInSeconds = true;
+        }
+        if (!emittedFields.slowDurationInSeconds) {
+          const durationInSeconds = getDuration(segments, state);
+          if (durationInSeconds !== null) {
+            callbacks.onSlowDurationInSeconds?.(durationInSeconds);
+            if (fieldsInReturnValue.slowDurationInSeconds) {
+              returnValue.slowDurationInSeconds = durationInSeconds;
+            }
+            emittedFields.slowDurationInSeconds = true;
+          }
+        }
+      }
+      continue;
+    }
+    if (key === "slowDurationInSeconds") {
+      if (hasInfo.slowDurationInSeconds && !emittedFields.slowDurationInSeconds && parseResult && segments) {
+        const slowDurationInSeconds = state.slowDurationAndFps.getSlowDurationInSeconds();
+        callbacks.onSlowDurationInSeconds?.(slowDurationInSeconds);
+        if (fieldsInReturnValue.slowDurationInSeconds) {
+          returnValue.slowDurationInSeconds = slowDurationInSeconds;
+        }
+        emittedFields.slowDurationInSeconds = true;
+      }
+      continue;
+    }
+    if (key === "fps") {
+      if (hasInfo.fps && parseResult && segments) {
+        if (!emittedFields.fps) {
+          const fps = getFps(segments);
+          callbacks.onFps?.(fps);
+          if (fieldsInReturnValue.fps) {
+            returnValue.fps = fps;
+          }
+          emittedFields.fps = true;
         }
-        emittedFields.durationInSeconds = true;
+        if (!emittedFields.slowFps) {
+          const fps = getFps(segments);
+          if (fps) {
+            callbacks.onSlowFps?.(fps);
+            if (fieldsInReturnValue.slowFps) {
+              returnValue.slowFps = fps;
+            }
+            emittedFields.slowFps = true;
+          }
+        }
+      }
+      continue;
+    }
+    if (key === "slowFps") {
+      if (hasInfo.slowFps && !emittedFields.slowFps && parseResult && segments) {
+        const slowFps = state.slowDurationAndFps.getFps();
+        callbacks.onSlowFps?.(slowFps);
+        if (fieldsInReturnValue.slowFps) {
+          returnValue.slowFps = slowFps;
+        }
+        emittedFields.slowFps = true;
       }
       continue;
     }
     if (key === "dimensions") {
-      if (hasInfo.dimensions && !emittedFields.dimensions && parseResult) {
-        const dimensionsQueried = getDimensions(parseResult.segments, state);
+      if (hasInfo.dimensions && !emittedFields.dimensions && parseResult && segments) {
+        const dimensionsQueried = getDimensions(segments, state);
         const dimensions = {
           height: dimensionsQueried.height,
           width: dimensionsQueried.width
@@ -6571,8 +6682,8 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "unrotatedDimensions") {
-      if (hasInfo.unrotatedDimensions && !emittedFields.unrotatedDimensions && parseResult) {
-        const dimensionsQueried = getDimensions(parseResult.segments, state);
+      if (hasInfo.unrotatedDimensions && !emittedFields.unrotatedDimensions && parseResult && segments) {
+        const dimensionsQueried = getDimensions(segments, state);
         const unrotatedDimensions = {
           height: dimensionsQueried.unrotatedHeight,
           width: dimensionsQueried.unrotatedWidth
@@ -6586,8 +6697,8 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "rotation") {
-      if (hasInfo.rotation && !emittedFields.rotation && parseResult) {
-        const dimensionsQueried = getDimensions(parseResult.segments, state);
+      if (hasInfo.rotation && !emittedFields.rotation && parseResult && segments) {
+        const dimensionsQueried = getDimensions(segments, state);
         const { rotation } = dimensionsQueried;
         callbacks.onRotation?.(rotation);
         if (fieldsInReturnValue.rotation) {
@@ -6597,20 +6708,9 @@ var emitAvailableInfo = ({
       }
       continue;
     }
-    if (key === "fps") {
-      if (!emittedFields.fps && hasInfo.fps && parseResult) {
-        const fps = getFps(parseResult.segments);
-        callbacks.onFps?.(fps);
-        if (fieldsInReturnValue.fps) {
-          returnValue.fps = fps;
-        }
-        emittedFields.fps = true;
-      }
-      continue;
-    }
     if (key === "videoCodec") {
-      if (!emittedFields.videoCodec && hasInfo.videoCodec && parseResult) {
-        const videoCodec = getVideoCodec(parseResult.segments, state);
+      if (!emittedFields.videoCodec && hasInfo.videoCodec && parseResult && segments) {
+        const videoCodec = getVideoCodec(segments, state);
         callbacks.onVideoCodec?.(videoCodec);
         if (fieldsInReturnValue.videoCodec) {
           returnValue.videoCodec = videoCodec;
@@ -6620,8 +6720,8 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "audioCodec") {
-      if (!emittedFields.audioCodec && hasInfo.audioCodec && parseResult) {
-        const audioCodec = getAudioCodec(parseResult.segments, state);
+      if (!emittedFields.audioCodec && hasInfo.audioCodec && parseResult && segments) {
+        const audioCodec = getAudioCodec(segments, state);
         callbacks.onAudioCodec?.(audioCodec);
         if (fieldsInReturnValue.audioCodec) {
           returnValue.audioCodec = audioCodec;
@@ -6631,8 +6731,8 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "tracks") {
-      if (!emittedFields.tracks && hasInfo.tracks && parseResult) {
-        const { videoTracks, audioTracks } = getTracks(parseResult.segments, state);
+      if (!emittedFields.tracks && hasInfo.tracks && parseResult && segments) {
+        const { videoTracks, audioTracks } = getTracks(segments, state);
         callbacks.onTracks?.({ videoTracks, audioTracks });
         if (fieldsInReturnValue.tracks) {
           returnValue.tracks = { videoTracks, audioTracks };
@@ -6682,8 +6782,8 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "isHdr") {
-      if (!returnValue.isHdr && hasInfo.isHdr && parseResult) {
-        const isHdr = getIsHdr(parseResult.segments, state);
+      if (!returnValue.isHdr && hasInfo.isHdr && parseResult && segments) {
+        const isHdr = getIsHdr(segments, state);
         callbacks.onIsHdr?.(isHdr);
         if (fieldsInReturnValue.isHdr) {
           returnValue.isHdr = isHdr;
@@ -6693,8 +6793,8 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "container") {
-      if (!returnValue.container && hasInfo.container && parseResult) {
-        const container = getContainer(parseResult.segments);
+      if (!returnValue.container && hasInfo.container && parseResult && segments) {
+        const container = getContainer(segments);
         callbacks.onContainer?.(container);
         if (fieldsInReturnValue.container) {
           returnValue.container = container;
@@ -6704,8 +6804,8 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "metadata") {
-      if (!emittedFields.metadata && hasInfo.metadata && parseResult) {
-        const metadata = getMetadata(parseResult.segments);
+      if (!emittedFields.metadata && hasInfo.metadata && parseResult && segments) {
+        const metadata = getMetadata(segments);
         callbacks.onMetadata?.(metadata);
         if (fieldsInReturnValue.metadata) {
           returnValue.metadata = metadata;
@@ -6715,8 +6815,8 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "location") {
-      if (!emittedFields.location && hasInfo.location && parseResult) {
-        const location = getLocation(parseResult.segments);
+      if (!emittedFields.location && hasInfo.location && parseResult && segments) {
+        const location = getLocation(segments);
         callbacks.onLocation?.(location);
         if (fieldsInReturnValue.location) {
           returnValue.location = location;
@@ -6725,6 +6825,36 @@ var emitAvailableInfo = ({
       }
       continue;
     }
+    if (key === "slowKeyframes") {
+      if (!emittedFields.slowKeyframes && hasInfo.slowKeyframes && parseResult) {
+        callbacks.onSlowKeyframes?.(state.keyframes.getKeyframes());
+        if (fieldsInReturnValue.slowKeyframes) {
+          returnValue.slowKeyframes = state.keyframes.getKeyframes();
+        }
+        emittedFields.slowKeyframes = true;
+      }
+      continue;
+    }
+    if (key === "slowNumberOfFrames") {
+      if (!emittedFields.slowNumberOfFrames && hasInfo.slowNumberOfFrames && parseResult) {
+        callbacks.onSlowNumberOfFrames?.(state.slowDurationAndFps.getSlowNumberOfFrames());
+        if (fieldsInReturnValue.slowNumberOfFrames) {
+          returnValue.slowNumberOfFrames = state.slowDurationAndFps.getSlowNumberOfFrames();
+        }
+        emittedFields.slowNumberOfFrames = true;
+      }
+      continue;
+    }
+    if (key === "keyframes") {
+      if (!emittedFields.keyframes && hasInfo.keyframes && parseResult) {
+        callbacks.onKeyframes?.(getKeyframes(state.structure.getStructure()));
+        if (fieldsInReturnValue.keyframes) {
+          returnValue.keyframes = getKeyframes(state.structure.getStructure());
+        }
+        emittedFields.keyframes = true;
+      }
+      continue;
+    }
     throw new Error(`Unhandled key: ${key}`);
   }
 };
@@ -6752,18 +6882,65 @@ var getFieldsFromCallback = ({
     tracks: Boolean(callbacks.onTracks),
     unrotatedDimensions: Boolean(callbacks.onUnrotatedDimensions),
     videoCodec: Boolean(callbacks.onVideoCodec),
+    slowKeyframes: Boolean(callbacks.onSlowKeyframes),
+    slowDurationInSeconds: Boolean(callbacks.onSlowDurationInSeconds),
+    slowFps: Boolean(callbacks.onSlowFps),
+    slowNumberOfFrames: Boolean(callbacks.onSlowNumberOfFrames),
+    keyframes: Boolean(callbacks.onKeyframes),
     ...fields
   };
   return newFields;
 };
 
+// src/may-skip-video-data/need-samples-for-fields.ts
+var needsSamples = {
+  slowDurationInSeconds: true,
+  slowFps: true,
+  slowKeyframes: true,
+  slowNumberOfFrames: true,
+  audioCodec: false,
+  container: false,
+  dimensions: false,
+  durationInSeconds: false,
+  fps: false,
+  internalStats: false,
+  isHdr: false,
+  name: false,
+  rotation: false,
+  size: false,
+  structure: false,
+  tracks: false,
+  unrotatedDimensions: false,
+  videoCodec: false,
+  metadata: false,
+  location: false,
+  mimeType: false,
+  keyframes: false
+};
+var needsToIterateOverSamples = ({
+  fields,
+  emittedFields
+}) => {
+  const keys = Object.keys(fields ?? {});
+  const selectedKeys = keys.filter((k) => fields[k]);
+  return selectedKeys.some((k) => needsSamples[k] && !emittedFields[k]);
+};
+
+// src/may-skip-video-data/may-skip-video-data.ts
+var maySkipVideoData = ({ state }) => {
+  return state.callbacks.tracks.hasAllTracks() && Object.values(state.callbacks.videoSampleCallbacks).length === 0 && Object.values(state.callbacks.audioSampleCallbacks).length === 0 && !needsToIterateOverSamples({
+    emittedFields: state.emittedFields,
+    fields: state.fields
+  });
+};
+
 // src/has-all-info.ts
 var getAvailableInfo = ({
   fieldsToFetch,
-  structure,
   state
 }) => {
   const keys = Object.entries(fieldsToFetch).filter(([, value]) => value);
+  const structure = state.structure.getStructureOrNull();
   const infos = keys.map(([_key]) => {
     const key = _key;
     if (key === "structure") {
@@ -6772,12 +6949,18 @@ var getAvailableInfo = ({
     if (key === "durationInSeconds") {
       return Boolean(structure && hasDuration(structure, state));
     }
+    if (key === "slowDurationInSeconds") {
+      return Boolean(structure && hasSlowDuration(structure, state));
+    }
     if (key === "dimensions" || key === "rotation" || key === "unrotatedDimensions") {
       return Boolean(structure && hasDimensions(structure, state));
     }
     if (key === "fps") {
       return Boolean(structure && hasFps(structure));
     }
+    if (key === "slowFps") {
+      return Boolean(structure && hasFpsSuitedForSlowFps(structure));
+    }
     if (key === "isHdr") {
       return Boolean(structure && hasHdr(structure, state));
     }
@@ -6790,6 +6973,9 @@ var getAvailableInfo = ({
     if (key === "tracks") {
       return Boolean(structure && hasTracks(structure, state));
     }
+    if (key === "keyframes") {
+      return Boolean(structure && hasKeyframes(structure, state));
+    }
     if (key === "internalStats") {
       return true;
     }
@@ -6808,6 +6994,12 @@ var getAvailableInfo = ({
     if (key === "metadata" || key === "location") {
       return false;
     }
+    if (key === "slowKeyframes") {
+      return false;
+    }
+    if (key === "slowNumberOfFrames") {
+      return false;
+    }
     throw new Error(`Unknown key: ${key}`);
   });
   const entries = [];
@@ -6819,46 +7011,44 @@ var getAvailableInfo = ({
 };
 var hasAllInfo = ({
   fields,
-  state,
-  structure
+  state
 }) => {
   const availableInfo = getAvailableInfo({
     fieldsToFetch: fields ?? {},
-    structure,
     state
   });
-  return Object.values(availableInfo).every(Boolean) && (state.maySkipVideoData() || state.canSkipTracksState.canSkipTracks());
+  return Object.values(availableInfo).every(Boolean) && (maySkipVideoData({ state }) || state.callbacks.canSkipTracksState.canSkipTracks());
 };
 
 // src/register-track.ts
 var registerTrack = async ({
-  options,
+  state,
   track,
   container
 }) => {
   if (track.type === "video") {
-    options.parserState.tracks.addTrack(track);
-    if (options.onVideoTrack) {
-      const callback = await options.onVideoTrack({ track, container });
-      await options.parserState.registerVideoSampleCallback(track.trackId, callback ?? null);
+    state.callbacks.tracks.addTrack(track);
+    if (state.onVideoTrack) {
+      const callback = await state.onVideoTrack({ track, container });
+      await state.callbacks.registerVideoSampleCallback(track.trackId, callback ?? null);
     }
   }
   if (track.type === "audio") {
-    options.parserState.tracks.addTrack(track);
-    if (options.onAudioTrack) {
-      const callback = await options.onAudioTrack({ track, container });
-      await options.parserState.registerAudioSampleCallback(track.trackId, callback ?? null);
+    state.callbacks.tracks.addTrack(track);
+    if (state.onAudioTrack) {
+      const callback = await state.onAudioTrack({ track, container });
+      await state.callbacks.registerAudioSampleCallback(track.trackId, callback ?? null);
     }
   }
 };
 var registerVideoTrackWhenProfileIsAvailable = ({
-  options,
+  state,
   track,
   container
 }) => {
-  options.parserState.registerOnAvcProfileCallback(async (profile) => {
+  state.riff.registerOnAvcProfileCallback(async (profile) => {
     await registerTrack({
-      options,
+      state,
       track: addAvcProfileToTrack(track, profile),
       container
     });
@@ -7030,10 +7220,12 @@ var convertAudioOrVideoSampleToWebCodecsTimestamps = (sample, timescale2) => {
     cts: cts * 1e6 / timescale2,
     dts: dts * 1e6 / timescale2,
     timestamp: timestamp * 1e6 / timescale2,
-    duration: (sample.duration ?? 0) * 1e6 / timescale2,
+    duration: sample.duration === undefined ? undefined : sample.duration * 1e6 / timescale2,
     data: sample.data,
     trackId: sample.trackId,
-    type: sample.type
+    type: sample.type,
+    offset: sample.offset,
+    timescale: 1e6
   };
 };
 
@@ -7043,14 +7235,14 @@ var parseMdat = async ({
   size,
   fileOffset,
   existingBoxes,
-  options,
+  state,
   signal,
   maySkipSampleProcessing
 }) => {
   const alreadyHas = hasTracks({
     type: "iso-base-media",
     boxes: existingBoxes
-  }, options.parserState);
+  }, state);
   if (!alreadyHas) {
     if (maySkipSampleProcessing) {
       data.discard(size - (data.counter.getOffset() - fileOffset));
@@ -7070,7 +7262,7 @@ var parseMdat = async ({
       fileOffset
     });
   }
-  const tracks2 = getTracks({ type: "iso-base-media", boxes: existingBoxes }, options.parserState);
+  const tracks2 = getTracks({ type: "iso-base-media", boxes: existingBoxes }, state);
   const allTracks = [
     ...tracks2.videoTracks,
     ...tracks2.audioTracks,
@@ -7112,25 +7304,29 @@ var parseMdat = async ({
     const bytes = data.getSlice(samplesWithIndex.samplePosition.size);
     const { cts, dts, duration: duration2 } = samplesWithIndex.samplePosition;
     if (samplesWithIndex.track.type === "audio") {
-      await options.parserState.onAudioSample(samplesWithIndex.track.trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
+      await state.callbacks.onAudioSample(samplesWithIndex.track.trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
         data: bytes,
         timestamp: cts,
         duration: duration2,
         cts,
         dts,
         trackId: samplesWithIndex.track.trackId,
-        type: samplesWithIndex.samplePosition.isKeyframe ? "key" : "delta"
+        type: samplesWithIndex.samplePosition.isKeyframe ? "key" : "delta",
+        offset: samplesWithIndex.samplePosition.offset,
+        timescale: samplesWithIndex.track.timescale
       }, samplesWithIndex.track.timescale));
     }
     if (samplesWithIndex.track.type === "video") {
-      await options.parserState.onVideoSample(samplesWithIndex.track.trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
+      await state.callbacks.onVideoSample(samplesWithIndex.track.trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
         data: bytes,
         timestamp: cts,
         duration: duration2,
         cts,
         dts,
         trackId: samplesWithIndex.track.trackId,
-        type: samplesWithIndex.samplePosition.isKeyframe ? "key" : "delta"
+        type: samplesWithIndex.samplePosition.isKeyframe ? "key" : "delta",
+        offset: samplesWithIndex.samplePosition.offset,
+        timescale: samplesWithIndex.track.timescale
       }, samplesWithIndex.track.timescale));
     }
     const remaining = size - (data.counter.getOffset() - fileOffset);
@@ -7295,17 +7491,18 @@ var parseMoov = async ({
   iterator,
   offset,
   size,
-  options,
+  state,
   signal,
   logLevel,
   fields
 }) => {
+  const boxes = [];
   const children = await parseIsoBaseMediaBoxes({
     iterator,
     maxBytes: size - (iterator.counter.getOffset() - offset),
     allowIncompleteBoxes: false,
-    initialBoxes: [],
-    options,
+    initialBoxes: boxes,
+    state,
     continueMdat: false,
     signal,
     logLevel,
@@ -7318,7 +7515,7 @@ var parseMoov = async ({
     offset,
     boxSize: size,
     type: "moov-box",
-    children: children.segments.boxes
+    children: boxes
   };
 };
 
@@ -7651,18 +7848,19 @@ var parseMebx = async ({
   iterator,
   offset,
   size,
-  options,
+  state,
   signal,
   fields
 }) => {
   iterator.discard(6);
   const dataReferenceIndex = iterator.getUint16();
+  const boxes = [];
   const children = await parseIsoBaseMediaBoxes({
     iterator,
     maxBytes: iterator.counter.getOffset() - offset,
     allowIncompleteBoxes: false,
-    initialBoxes: [],
-    options,
+    initialBoxes: boxes,
+    state,
     continueMdat: false,
     signal,
     logLevel: "info",
@@ -7677,7 +7875,7 @@ var parseMebx = async ({
     offset,
     dataReferenceIndex,
     format: "mebx",
-    children: children.segments.boxes
+    children: boxes
   };
 };
 
@@ -7830,7 +8028,7 @@ var audioTags = [
 ];
 var processSample = async ({
   iterator,
-  options,
+  state: options,
   signal,
   logLevel,
   fields
@@ -7870,12 +8068,13 @@ var processSample = async ({
       const packetSize = iterator.getUint16();
       const sampleRate = iterator.getFixedPointUnsigned1616Number();
       const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
+      const initialBoxes = [];
       const children = await parseIsoBaseMediaBoxes({
         iterator,
         allowIncompleteBoxes: false,
         maxBytes: bytesRemainingInBox,
-        initialBoxes: [],
-        options,
+        initialBoxes,
+        state: options,
         continueMdat: false,
         signal,
         logLevel,
@@ -7903,7 +8102,7 @@ var processSample = async ({
           bytesPerPacket: null,
           bytesPerFrame: null,
           bitsPerSample: null,
-          children: children.segments.boxes
+          children: initialBoxes
         }
       };
     }
@@ -7918,12 +8117,13 @@ var processSample = async ({
       const bytesPerFrame = iterator.getUint32();
       const bytesPerSample = iterator.getUint32();
       const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
+      const initialBoxes = [];
       const children = await parseIsoBaseMediaBoxes({
         iterator,
         allowIncompleteBoxes: false,
         maxBytes: bytesRemainingInBox,
-        initialBoxes: [],
-        options,
+        initialBoxes,
+        state: options,
         continueMdat: false,
         signal,
         logLevel,
@@ -7951,7 +8151,7 @@ var processSample = async ({
           bytesPerPacket,
           bytesPerFrame,
           bitsPerSample: bytesPerSample,
-          children: children.segments.boxes
+          children: initialBoxes
         }
       };
     }
@@ -7975,7 +8175,7 @@ var processSample = async ({
         allowIncompleteBoxes: false,
         maxBytes: bytesRemainingInBox,
         initialBoxes: [],
-        options,
+        state: options,
         continueMdat: false,
         signal,
         logLevel,
@@ -7984,6 +8184,7 @@ var processSample = async ({
       if (children.status === "incomplete") {
         throw new Error("Incomplete boxes are not allowed");
       }
+      const initialBoxes = [];
       return {
         sample: {
           format: boxFormat,
@@ -8003,7 +8204,7 @@ var processSample = async ({
           bytesPerPacket: null,
           bytesPerFrame,
           bitsPerSample: bitsPerChannel,
-          children: children.segments.boxes
+          children: initialBoxes
         }
       };
     }
@@ -8025,17 +8226,18 @@ var processSample = async ({
     const depth = iterator.getUint16();
     const colorTableId = iterator.getInt16();
     const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
+    const initialBoxes = [];
     const children = bytesRemainingInBox > 8 ? await parseIsoBaseMediaBoxes({
       iterator,
       allowIncompleteBoxes: false,
       maxBytes: bytesRemainingInBox,
-      initialBoxes: [],
-      options,
+      initialBoxes,
+      state: options,
       continueMdat: false,
       signal,
       logLevel,
       fields
-    }) : (iterator.discard(bytesRemainingInBox), { status: "done", segments: { boxes: [], type: "iso-base-media" } });
+    }) : (iterator.discard(bytesRemainingInBox), { status: "done" });
     if (children.status === "incomplete") {
       throw new Error("Incomplete boxes are not allowed");
     }
@@ -8060,7 +8262,7 @@ var processSample = async ({
         compressorName,
         depth,
         colorTableId,
-        descriptors: children.segments.boxes
+        descriptors: initialBoxes
       }
     };
   }
@@ -8069,7 +8271,7 @@ var processSample = async ({
 var parseSamples = async ({
   iterator,
   maxBytes,
-  options,
+  state,
   signal,
   logLevel,
   fields
@@ -8079,7 +8281,7 @@ var parseSamples = async ({
   while (iterator.bytesRemaining() > 0 && iterator.counter.getOffset() - initialOffset < maxBytes) {
     const { sample } = await processSample({
       iterator,
-      options,
+      state,
       signal,
       logLevel,
       fields
@@ -8096,7 +8298,7 @@ var parseStsd = async ({
   iterator,
   offset,
   size,
-  options,
+  state,
   signal,
   fields
 }) => {
@@ -8110,7 +8312,7 @@ var parseStsd = async ({
   const boxes = await parseSamples({
     iterator,
     maxBytes: bytesRemainingInBox,
-    options,
+    state,
     signal,
     logLevel: "info",
     fields
@@ -8382,30 +8584,31 @@ var parseTrak = async ({
   data,
   size,
   offsetAtStart,
-  options,
+  state: options,
   signal,
   logLevel,
   fields
 }) => {
-  const children = await parseIsoBaseMediaBoxes({
+  const initialBoxes = [];
+  const result = await parseIsoBaseMediaBoxes({
     iterator: data,
     maxBytes: size - (data.counter.getOffset() - offsetAtStart),
     allowIncompleteBoxes: false,
-    initialBoxes: [],
-    options,
+    initialBoxes,
+    state: options,
     continueMdat: false,
     signal,
     logLevel,
     fields
   });
-  if (children.status === "incomplete") {
+  if (result.status === "incomplete") {
     throw new Error("Incomplete boxes are not allowed");
   }
   return {
     offset: offsetAtStart,
     boxSize: size,
     type: "trak-box",
-    children: children.segments.boxes
+    children: initialBoxes
   };
 };
 
@@ -8456,19 +8659,20 @@ var getChildren = async ({
   boxType,
   iterator,
   bytesRemainingInBox,
-  options,
+  state,
   signal,
   logLevel,
   fields
 }) => {
   const parseChildren = boxType === "mdia" || boxType === "minf" || boxType === "stbl" || boxType === "udta" || boxType === "moof" || boxType === "dims" || boxType === "meta" || boxType === "wave" || boxType === "traf" || boxType === "stsb";
   if (parseChildren) {
+    const boxes = [];
     const parsed = await parseIsoBaseMediaBoxes({
       iterator,
       maxBytes: bytesRemainingInBox,
       allowIncompleteBoxes: false,
-      initialBoxes: [],
-      options,
+      initialBoxes: boxes,
+      state,
       continueMdat: false,
       signal,
       logLevel,
@@ -8477,7 +8681,7 @@ var getChildren = async ({
     if (parsed.status === "incomplete") {
       throw new Error("Incomplete boxes are not allowed");
     }
-    return parsed.segments.boxes;
+    return boxes;
   }
   if (bytesRemainingInBox < 0) {
     throw new Error("Box size is too big " + JSON.stringify({ boxType }));
@@ -8490,7 +8694,7 @@ var parseMdatPartially = async ({
   boxSize,
   fileOffset,
   parsedBoxes,
-  options,
+  state,
   signal
 }) => {
   const box = await parseMdat({
@@ -8498,9 +8702,9 @@ var parseMdatPartially = async ({
     size: boxSize,
     fileOffset,
     existingBoxes: parsedBoxes,
-    options,
+    state,
     signal,
-    maySkipSampleProcessing: options.supportsContentRange
+    maySkipSampleProcessing: state.supportsContentRange
   });
   if ((box.status === "samples-processed" || box.status === "samples-buffered") && box.fileOffset + boxSize === iterator.counter.getOffset()) {
     return {
@@ -8520,7 +8724,7 @@ var processBox = async ({
   iterator,
   allowIncompleteBoxes,
   parsedBoxes,
-  options,
+  state,
   signal,
   logLevel,
   fields
@@ -8552,7 +8756,7 @@ var processBox = async ({
   const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber() : boxSizeRaw;
   if (bytesRemaining < boxSize) {
     if (boxType === "mdat") {
-      const shouldSkip = options.parserState.maySkipVideoData() || !hasTracks({ type: "iso-base-media", boxes: parsedBoxes }, options.parserState) && options.supportsContentRange;
+      const shouldSkip = maySkipVideoData({ state }) || !hasTracks({ type: "iso-base-media", boxes: parsedBoxes }, state) && state.supportsContentRange;
       if (shouldSkip) {
         const skipTo = fileOffset + boxSize;
         const bytesToSkip = skipTo - iterator.counter.getOffset();
@@ -8575,7 +8779,7 @@ var processBox = async ({
           boxSize,
           fileOffset,
           parsedBoxes,
-          options,
+          state,
           signal
         });
       }
@@ -8650,7 +8854,7 @@ var processBox = async ({
       iterator,
       offset: fileOffset,
       size: boxSize,
-      options,
+      state,
       signal,
       fields
     });
@@ -8745,7 +8949,7 @@ var processBox = async ({
       iterator,
       offset: fileOffset,
       size: boxSize,
-      options,
+      state,
       signal,
       fields
     });
@@ -8792,12 +8996,12 @@ var processBox = async ({
       iterator,
       offset: fileOffset,
       size: boxSize,
-      options,
+      state,
       signal,
       logLevel,
       fields
     });
-    options.parserState.tracks.setIsDone();
+    state.callbacks.tracks.setIsDone();
     return {
       type: "complete",
       box,
@@ -8810,7 +9014,7 @@ var processBox = async ({
       data: iterator,
       size: boxSize,
       offsetAtStart: fileOffset,
-      options,
+      state,
       signal,
       logLevel,
       fields
@@ -8818,7 +9022,7 @@ var processBox = async ({
     const transformedTrack = makeBaseMediaTrack(box);
     if (transformedTrack) {
       await registerTrack({
-        options,
+        state,
         track: transformedTrack,
         container: "mp4"
       });
@@ -8925,9 +9129,9 @@ var processBox = async ({
       size: boxSize,
       fileOffset,
       existingBoxes: parsedBoxes,
-      options,
+      state,
       signal,
-      maySkipSampleProcessing: options.supportsContentRange
+      maySkipSampleProcessing: state.supportsContentRange
     });
     if (box === null) {
       throw new Error("Unexpected null");
@@ -8944,7 +9148,7 @@ var processBox = async ({
     boxType,
     iterator,
     bytesRemainingInBox,
-    options,
+    state,
     signal,
     logLevel,
     fields
@@ -8967,31 +9171,27 @@ var parseIsoBaseMediaBoxes = async ({
   maxBytes,
   allowIncompleteBoxes,
   initialBoxes,
-  options,
+  state,
   continueMdat,
   signal,
   logLevel,
   fields
 }) => {
-  const structure = {
-    type: "iso-base-media",
-    boxes: initialBoxes
-  };
   const initialOffset = iterator.counter.getOffset();
-  const alreadyHasMdat = structure.boxes.find((b) => b.type === "mdat-box");
+  const alreadyHasMdat = state.structure.getStructureOrNull()?.boxes.find((b) => b.type === "mdat-box");
   while (iterator.bytesRemaining() > 0 && iterator.counter.getOffset() - initialOffset < maxBytes) {
     const result = continueMdat ? await parseMdatPartially({
       iterator,
       boxSize: continueMdat.boxSize,
       fileOffset: continueMdat.fileOffset,
       parsedBoxes: initialBoxes,
-      options,
+      state,
       signal
     }) : await processBox({
       iterator,
       allowIncompleteBoxes,
       parsedBoxes: initialBoxes,
-      options,
+      state,
       signal,
       logLevel,
       fields
@@ -9002,14 +9202,13 @@ var parseIsoBaseMediaBoxes = async ({
       }
       return {
         status: "incomplete",
-        segments: structure,
         continueParsing: () => {
           return parseIsoBaseMediaBoxes({
             iterator,
             maxBytes,
             allowIncompleteBoxes,
-            initialBoxes: structure.boxes,
-            options,
+            initialBoxes,
+            state,
             continueMdat: false,
             signal,
             logLevel,
@@ -9022,14 +9221,13 @@ var parseIsoBaseMediaBoxes = async ({
     if (result.type === "partial-mdat-box") {
       return {
         status: "incomplete",
-        segments: structure,
         continueParsing: () => {
           return Promise.resolve(parseIsoBaseMediaBoxes({
             iterator,
             maxBytes,
             allowIncompleteBoxes,
-            initialBoxes: structure.boxes,
-            options,
+            initialBoxes,
+            state,
             continueMdat: result,
             signal,
             logLevel,
@@ -9040,36 +9238,34 @@ var parseIsoBaseMediaBoxes = async ({
       };
     }
     if (result.box.type === "mdat-box" && alreadyHasMdat) {
-      structure.boxes = structure.boxes.filter((b) => b.type !== "mdat-box");
-      structure.boxes.push(result.box);
+      initialBoxes = initialBoxes.filter((b) => b.type !== "mdat-box");
+      initialBoxes.push(result.box);
       iterator.allowDiscard();
       if (result.box.status !== "samples-processed") {
         throw new Error("unexpected");
       }
       break;
     } else {
-      structure.boxes.push(result.box);
-      if (hasAllInfo({ fields, state: options.parserState, structure })) {
+      initialBoxes.push(result.box);
+      if (hasAllInfo({ fields, state })) {
         return {
-          status: "done",
-          segments: structure
+          status: "done"
         };
       }
     }
     if (result.skipTo !== null) {
-      if (!options.supportsContentRange) {
+      if (!state.supportsContentRange) {
         throw new Error("Content-Range header is not supported by the reader, but was asked to seek");
       }
       return {
         status: "incomplete",
-        segments: structure,
         continueParsing: () => {
           return parseIsoBaseMediaBoxes({
             iterator,
             maxBytes,
             allowIncompleteBoxes,
-            initialBoxes: structure.boxes,
-            options,
+            initialBoxes,
+            state,
             continueMdat: false,
             signal,
             logLevel,
@@ -9082,14 +9278,13 @@ var parseIsoBaseMediaBoxes = async ({
     if (iterator.bytesRemaining() < 0) {
       return {
         status: "incomplete",
-        segments: structure,
         continueParsing: () => {
           return parseIsoBaseMediaBoxes({
             iterator,
             maxBytes,
             allowIncompleteBoxes,
-            initialBoxes: structure.boxes,
-            options,
+            initialBoxes,
+            state,
             continueMdat: false,
             signal,
             logLevel,
@@ -9101,13 +9296,12 @@ var parseIsoBaseMediaBoxes = async ({
     }
     iterator.removeBytesRead();
   }
-  const mdatState = getMdatBox(structure.boxes);
-  const skipped = mdatState?.status === "samples-skipped" && !options.parserState.maySkipVideoData() && options.supportsContentRange;
-  const buffered = mdatState?.status === "samples-buffered" && !options.parserState.maySkipVideoData();
+  const mdatState = getMdatBox(initialBoxes);
+  const skipped = mdatState?.status === "samples-skipped" && !maySkipVideoData({ state }) && state.supportsContentRange;
+  const buffered = mdatState?.status === "samples-buffered" && !maySkipVideoData({ state });
   if (skipped || buffered) {
     return {
       status: "incomplete",
-      segments: structure,
       continueParsing: () => {
         if (buffered) {
           iterator.skipTo(mdatState.fileOffset, false);
@@ -9116,8 +9310,8 @@ var parseIsoBaseMediaBoxes = async ({
           iterator,
           maxBytes,
           allowIncompleteBoxes: false,
-          initialBoxes: structure.boxes,
-          options,
+          initialBoxes,
+          state,
           continueMdat: false,
           signal,
           logLevel,
@@ -9128,8 +9322,7 @@ var parseIsoBaseMediaBoxes = async ({
     };
   }
   return {
-    status: "done",
-    segments: structure
+    status: "done"
   };
 };
 
@@ -9397,37 +9590,39 @@ var getStrhForIndex = (structure, trackId) => {
 };
 var handleChunk = async ({
   iterator,
-  options,
+  state,
   structure,
   ckId,
   ckSize
 }) => {
+  const offset = iterator.counter.getOffset();
   const videoChunk = ckId.match(/^([0-9]{2})dc$/);
   if (videoChunk) {
     const trackId = parseInt(videoChunk[1], 10);
     const strh = getStrhForIndex(structure, trackId);
     const samplesPerSecond = strh.rate / strh.scale;
-    const nthSample = options.parserState.getSamplesForTrack(trackId);
+    const nthSample = state.callbacks.getSamplesForTrack(trackId);
     const timeInSec = nthSample / samplesPerSecond;
-    const timestamp = Math.floor(timeInSec);
-    const duration2 = Math.floor(1 / samplesPerSecond);
+    const timestamp = timeInSec;
     const data = iterator.getSlice(ckSize);
     const infos = parseAvc(data);
     const keyOrDelta = getKeyFrameOrDeltaFromAvcInfo(infos);
     const avcProfile = infos.find((i) => i.type === "avc-profile");
     const ppsProfile = infos.find((i) => i.type === "avc-pps");
     if (avcProfile && ppsProfile) {
-      await options.parserState.onProfile({ pps: ppsProfile, sps: avcProfile });
-      options.parserState.tracks.setIsDone();
+      await state.riff.onProfile({ pps: ppsProfile, sps: avcProfile });
+      state.callbacks.tracks.setIsDone();
     }
-    await options.parserState.onVideoSample(trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
+    await state.callbacks.onVideoSample(trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
       cts: timestamp,
       dts: timestamp,
       data,
-      duration: duration2,
+      duration: undefined,
       timestamp,
       trackId,
-      type: keyOrDelta
+      type: keyOrDelta,
+      offset,
+      timescale: samplesPerSecond
     }, 1));
     return;
   }
@@ -9436,25 +9631,27 @@ var handleChunk = async ({
     const trackId = parseInt(audioChunk[1], 10);
     const strh = getStrhForIndex(structure, trackId);
     const samplesPerSecond = strh.rate / strh.scale;
-    const nthSample = options.parserState.getSamplesForTrack(trackId);
+    const nthSample = state.callbacks.getSamplesForTrack(trackId);
     const timeInSec = nthSample / samplesPerSecond;
     const timestamp = timeInSec;
-    const duration2 = 1 / samplesPerSecond;
-    await options.parserState.onAudioSample(trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
+    const data = iterator.getSlice(ckSize);
+    await state.callbacks.onAudioSample(trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
       cts: timestamp,
       dts: timestamp,
-      data: iterator.getSlice(ckSize),
-      duration: duration2,
+      data,
+      duration: undefined,
       timestamp,
       trackId,
-      type: "key"
+      type: "key",
+      offset,
+      timescale: samplesPerSecond
     }, 1));
   }
 };
 var parseMovi = async ({
   iterator,
   maxOffset,
-  options,
+  state,
   structure
 }) => {
   while (iterator.counter.getOffset() < maxOffset) {
@@ -9462,13 +9659,15 @@ var parseMovi = async ({
       return {
         type: "incomplete",
         continueParsing: () => {
-          return Promise.resolve(parseMovi({ iterator, maxOffset, options, structure }));
+          return Promise.resolve(parseMovi({ iterator, maxOffset, state, structure }));
         }
       };
     }
     const ckId = iterator.getByteString(4);
     const ckSize = iterator.getUint32Le();
-    if (options.parserState.maySkipVideoData() && options.parserState.getAvcProfile()) {
+    if (maySkipVideoData({
+      state
+    }) && state.riff.getAvcProfile()) {
       return {
         type: "complete",
         box: {
@@ -9482,11 +9681,11 @@ var parseMovi = async ({
       return {
         type: "incomplete",
         continueParsing: () => {
-          return Promise.resolve(parseMovi({ iterator, maxOffset, options, structure }));
+          return Promise.resolve(parseMovi({ iterator, maxOffset, state, structure }));
         }
       };
     }
-    await handleChunk({ iterator, options, structure, ckId, ckSize });
+    await handleChunk({ iterator, state, structure, ckId, ckSize });
     while (iterator.counter.getOffset() < maxOffset && iterator.bytesRemaining() > 0) {
       if (iterator.getUint8() !== 0) {
         iterator.counter.decrement(1);
@@ -9509,7 +9708,7 @@ var parseMovi = async ({
   return {
     type: "incomplete",
     continueParsing: () => {
-      return Promise.resolve(parseMovi({ iterator, maxOffset, options, structure }));
+      return Promise.resolve(parseMovi({ iterator, maxOffset, state, structure }));
     }
   };
 };
@@ -9604,7 +9803,7 @@ var parseIsft = ({
 var parseListBox = async ({
   iterator,
   size,
-  options
+  state
 }) => {
   const counter = iterator.counter.getOffset();
   const listType = iterator.getByteString(4);
@@ -9619,7 +9818,7 @@ var parseListBox = async ({
     structure,
     iterator,
     maxOffset: counter + size,
-    options
+    state
   });
   if (result.status === "incomplete") {
     throw new Error(`Should only parse complete boxes (${listType})`);
@@ -9759,13 +9958,13 @@ var parseRiffBox = ({
   size,
   id,
   boxes,
-  options
+  state
 }) => {
   if (id === "fmt") {
     return Promise.resolve(parseFmtBox({ iterator, boxes, size }));
   }
   if (id === "LIST") {
-    return parseListBox({ iterator, size, options });
+    return parseListBox({ iterator, size, state });
   }
   if (id === "ISFT") {
     return Promise.resolve(parseIsft({ iterator, size }));
@@ -9791,14 +9990,14 @@ var parseRiffBox = ({
 // src/boxes/riff/expect-riff-box.ts
 var expectRiffBox = async ({
   iterator,
-  options,
+  state,
   structure
 }) => {
   if (iterator.bytesRemaining() < 16) {
     return {
       type: "incomplete",
       continueParsing() {
-        return expectRiffBox({ structure, iterator, options });
+        return expectRiffBox({ structure, iterator, state });
       }
     };
   }
@@ -9809,7 +10008,7 @@ var expectRiffBox = async ({
     return parseMovi({
       iterator,
       maxOffset: ckSize + iterator.counter.getOffset() - 4,
-      options,
+      state,
       structure
     });
   }
@@ -9818,7 +10017,7 @@ var expectRiffBox = async ({
     return {
       type: "incomplete",
       continueParsing: () => {
-        return expectRiffBox({ structure, iterator, options });
+        return expectRiffBox({ structure, iterator, state });
       }
     };
   }
@@ -9829,7 +10028,7 @@ var expectRiffBox = async ({
       iterator,
       size: ckSize,
       boxes: structure.boxes,
-      options
+      state
     }),
     skipTo: null
   };
@@ -9841,7 +10040,7 @@ var continueAfterRiffBoxResult = ({
   structure,
   iterator,
   maxOffset,
-  options
+  state: options
 }) => {
   if (result.type === "incomplete") {
     return Promise.resolve({
@@ -9852,7 +10051,7 @@ var continueAfterRiffBoxResult = ({
           structure,
           iterator,
           maxOffset,
-          options
+          state: options
         }));
       },
       segments: structure,
@@ -9862,30 +10061,29 @@ var continueAfterRiffBoxResult = ({
   if (result.type === "complete" && result.box) {
     structure.boxes.push(result.box);
   }
-  return parseRiffBody({ iterator, maxOffset, options, structure });
+  return parseRiffBody({ iterator, maxOffset, state: options, structure });
 };
 var parseRiffBody = async ({
   iterator,
   structure,
   maxOffset,
-  options
+  state
 }) => {
   while (iterator.bytesRemaining() > 0 && iterator.counter.getOffset() < maxOffset) {
     const result = await expectRiffBox({
       iterator,
-      options,
+      state,
       structure
     });
     if (result.type === "complete" && result.skipTo !== null) {
       return {
         status: "incomplete",
         skipTo: result.skipTo,
-        segments: structure,
         continueParsing() {
           return Promise.resolve(continueAfterRiffBoxResult({
             iterator,
             maxOffset,
-            options,
+            state,
             result,
             structure
           }));
@@ -9899,12 +10097,11 @@ var parseRiffBody = async ({
           return Promise.resolve(continueAfterRiffBoxResult({
             iterator,
             maxOffset,
-            options,
+            state,
             result: await result.continueParsing(),
             structure
           }));
         },
-        segments: structure,
         skipTo: null
       };
     }
@@ -9913,13 +10110,13 @@ var parseRiffBody = async ({
     }
     structure.boxes.push(result.box);
     if (result.box.type === "list-box" && result.box.listType === "hdrl") {
-      const tracks2 = getTracks(structure, options.parserState);
+      const tracks2 = getTracks(structure, state);
       if (!tracks2.videoTracks.some((t) => t.codec === TO_BE_OVERRIDDEN_LATER)) {
-        options.parserState.tracks.setIsDone();
+        state.callbacks.tracks.setIsDone();
       }
     }
     if (result.box.type === "wave-format-box") {
-      options.parserState.tracks.setIsDone();
+      state.callbacks.tracks.setIsDone();
     }
     if (result.box.type === "strf-box-video" || result.box.type === "strf-box-audio") {
       const strh = getStrhBox(structure.boxes);
@@ -9927,60 +10124,67 @@ var parseRiffBody = async ({
       if (!strh || !strf) {
         throw new Error("strh or strf box missing");
       }
-      if (strf.type === "strf-box-audio" && options.onAudioTrack) {
+      if (strf.type === "strf-box-audio" && state.onAudioTrack) {
         const audioTrack = makeAviAudioTrack({
-          index: options.nextTrackIndex,
+          index: state.riff.getNextTrackIndex(),
           strf
         });
         await registerTrack({
-          options,
+          state,
           track: audioTrack,
           container: "avi"
         });
       }
-      if (options.onVideoTrack && strf.type === "strf-box-video") {
+      if (state.onVideoTrack && strf.type === "strf-box-video") {
         const videoTrack = makeAviVideoTrack({
           strh,
-          index: options.nextTrackIndex,
+          index: state.riff.getNextTrackIndex(),
           strf
         });
         registerVideoTrackWhenProfileIsAvailable({
-          options,
+          state,
           track: videoTrack,
           container: "avi"
         });
       }
-      options.nextTrackIndex++;
+      state.riff.incrementNextTrackIndex();
     }
   }
   return {
-    status: "done",
-    segments: structure
+    status: "done"
   };
 };
 var parseRiff = ({
   iterator,
-  options,
+  state,
   fields
 }) => {
-  const structure = { type: "riff", boxes: [] };
   const riff = iterator.getByteString(4);
   if (riff !== "RIFF") {
     throw new Error("Not a RIFF file");
   }
+  const structure = state.structure.getStructure();
+  if (structure.type !== "riff") {
+    throw new Error("Structure is not a RIFF structure");
+  }
   const size = iterator.getUint32Le();
   const fileType = iterator.getByteString(4);
   if (fileType !== "WAVE" && fileType !== "AVI") {
     throw new Error(`File type ${fileType} not supported`);
   }
   structure.boxes.push({ type: "riff-header", fileSize: size, fileType });
-  if (hasAllInfo({ fields, structure, state: options.parserState })) {
+  if (hasAllInfo({ fields, state })) {
     return Promise.resolve({
       status: "done",
       segments: structure
     });
   }
-  return parseRiffBody({ iterator, structure, maxOffset: Infinity, options });
+  return parseRiffBody({
+    iterator,
+    maxOffset: Infinity,
+    state,
+    structure
+  });
 };
 
 // src/boxes/transport-stream/next-pes-header-store.ts
@@ -10320,10 +10524,11 @@ var MPEG_TIMESCALE = 90000;
 var handleAvcPacket = async ({
   streamBuffer,
   programId,
-  options
+  state,
+  offset
 }) => {
   const avc = parseAvc(streamBuffer.buffer);
-  const isTrackRegistered = options.parserState.tracks.getTracks().find((t) => {
+  const isTrackRegistered = state.callbacks.tracks.getTracks().find((t) => {
     return t.trackId === programId;
   });
   if (!isTrackRegistered) {
@@ -10336,7 +10541,7 @@ var handleAvcPacket = async ({
       type: "video",
       timescale: MPEG_TIMESCALE,
       codec: getCodecStringFromSpsAndPps(spsAndPps.sps),
-      codecPrivate: getAvccBoxContent(spsAndPps),
+      codecPrivate: createSpsPpsData(spsAndPps),
       fps: null,
       codedWidth: dimensions.width,
       codedHeight: dimensions.height,
@@ -10353,7 +10558,7 @@ var handleAvcPacket = async ({
       },
       color: getVideoColorFromSps(spsAndPps.sps.spsData)
     };
-    await registerTrack({ track, options, container: "transport-stream" });
+    await registerTrack({ track, state, container: "transport-stream" });
   }
   const sample = {
     cts: streamBuffer.pesHeader.pts,
@@ -10362,23 +10567,26 @@ var handleAvcPacket = async ({
     duration: undefined,
     data: new Uint8Array(streamBuffer.buffer),
     trackId: programId,
-    type: getKeyFrameOrDeltaFromAvcInfo(avc)
+    type: getKeyFrameOrDeltaFromAvcInfo(avc),
+    offset,
+    timescale: MPEG_TIMESCALE
   };
-  await options.parserState.onVideoSample(programId, convertAudioOrVideoSampleToWebCodecsTimestamps(sample, MPEG_TIMESCALE));
+  await state.callbacks.onVideoSample(programId, convertAudioOrVideoSampleToWebCodecsTimestamps(sample, MPEG_TIMESCALE));
 };
 
 // src/boxes/transport-stream/handle-aac-packet.ts
 var handleAacPacket = async ({
   streamBuffer,
-  options,
-  programId
+  state,
+  programId,
+  offset
 }) => {
   const adtsHeader = readAdtsHeader(streamBuffer.buffer);
   if (!adtsHeader) {
     throw new Error("Invalid ADTS header - too short");
   }
   const { channelConfiguration, codecPrivate: codecPrivate2, sampleRate, audioObjectType } = adtsHeader;
-  const isTrackRegistered = options.parserState.tracks.getTracks().find((t) => {
+  const isTrackRegistered = state.callbacks.tracks.getTracks().find((t) => {
     return t.trackId === programId;
   });
   if (!isTrackRegistered) {
@@ -10396,7 +10604,7 @@ var handleAacPacket = async ({
     };
     await registerTrack({
       track,
-      options,
+      state,
       container: "transport-stream"
     });
   }
@@ -10407,15 +10615,17 @@ var handleAacPacket = async ({
     duration: undefined,
     data: new Uint8Array(streamBuffer.buffer),
     trackId: programId,
-    type: "key"
+    type: "key",
+    offset,
+    timescale: MPEG_TIMESCALE
   };
-  await options.parserState.onAudioSample(programId, convertAudioOrVideoSampleToWebCodecsTimestamps(sample, MPEG_TIMESCALE));
+  await state.callbacks.onAudioSample(programId, convertAudioOrVideoSampleToWebCodecsTimestamps(sample, MPEG_TIMESCALE));
 };
 
 // src/boxes/transport-stream/process-stream-buffers.ts
 var processStreamBuffer = async ({
   streamBuffer,
-  options,
+  state,
   programId,
   structure
 }) => {
@@ -10424,28 +10634,38 @@ var processStreamBuffer = async ({
     throw new Error("No stream found");
   }
   if (stream.streamType === 27) {
-    await handleAvcPacket({ programId, streamBuffer, options });
+    await handleAvcPacket({
+      programId,
+      streamBuffer,
+      state,
+      offset: streamBuffer.offset
+    });
   } else if (stream.streamType === 15) {
-    await handleAacPacket({ streamBuffer, options, programId });
+    await handleAacPacket({
+      streamBuffer,
+      state,
+      programId,
+      offset: streamBuffer.offset
+    });
   }
-  if (!options.parserState.tracks.hasAllTracks()) {
-    const tracksRegistered = options.parserState.tracks.getTracks().length;
+  if (!state.callbacks.tracks.hasAllTracks()) {
+    const tracksRegistered = state.callbacks.tracks.getTracks().length;
     const { streams } = findProgramMapTableOrThrow(structure);
     if (streams.length === tracksRegistered) {
-      options.parserState.tracks.setIsDone();
+      state.callbacks.tracks.setIsDone();
     }
   }
 };
 var processFinalStreamBuffers = async ({
   streamBufferMap,
-  parserContext,
+  state,
   structure
 }) => {
   for (const [programId, buffer] of streamBufferMap) {
     if (buffer.buffer.byteLength > 0) {
       await processStreamBuffer({
         streamBuffer: buffer,
-        options: parserContext,
+        state,
         programId,
         structure
       });
@@ -10460,14 +10680,16 @@ var parseAdtsStream = async ({
   transportStreamEntry,
   streamBuffers,
   nextPesHeader,
-  options,
-  structure
+  state,
+  structure,
+  offset
 }) => {
   const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
   if (!streamBuffer) {
     streamBuffers.set(transportStreamEntry.pid, {
       buffer: restOfPacket,
-      pesHeader: nextPesHeader
+      pesHeader: nextPesHeader,
+      offset
     });
     return;
   }
@@ -10481,13 +10703,14 @@ var parseAdtsStream = async ({
     await processStreamBuffer({
       streamBuffer,
       programId: transportStreamEntry.pid,
-      options,
+      state,
       structure
     });
     const rest = restOfPacket.slice(bytesToTake);
     streamBuffers.set(transportStreamEntry.pid, {
       buffer: rest,
-      pesHeader: nextPesHeader
+      pesHeader: nextPesHeader,
+      offset
     });
   }
 };
@@ -10497,8 +10720,9 @@ var parseAvcStream = async ({
   streamBuffers,
   nextPesHeader,
   programId,
-  parserContext,
-  structure
+  state,
+  structure,
+  offset
 }) => {
   const indexOfSeparator = findNextSeparator(restOfPacket, transportStreamEntry);
   const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
@@ -10512,7 +10736,8 @@ var parseAvcStream = async ({
     }
     streamBuffers.set(programId, {
       pesHeader: nextPesHeader,
-      buffer: restOfPacket
+      buffer: restOfPacket,
+      offset
     });
     return;
   }
@@ -10520,7 +10745,7 @@ var parseAvcStream = async ({
     const packet = restOfPacket.slice(0, indexOfSeparator);
     streamBuffer.buffer = combineUint8Arrays([streamBuffer.buffer, packet]);
     await processStreamBuffer({
-      options: parserContext,
+      state,
       streamBuffer,
       programId,
       structure
@@ -10528,7 +10753,8 @@ var parseAvcStream = async ({
     const rest = restOfPacket.slice(indexOfSeparator);
     streamBuffers.set(programId, {
       pesHeader: nextPesHeader,
-      buffer: rest
+      buffer: rest,
+      offset
     });
     return;
   }
@@ -10537,14 +10763,15 @@ var parseAvcStream = async ({
   }
   streamBuffers.set(programId, {
     pesHeader: nextPesHeader,
-    buffer: restOfPacket.slice(indexOfSeparator)
+    buffer: restOfPacket.slice(indexOfSeparator),
+    offset
   });
 };
 var parseStream = ({
   iterator,
   transportStreamEntry,
   streamBuffers,
-  parserContext,
+  state,
   programId,
   structure,
   nextPesHeader
@@ -10556,9 +10783,10 @@ var parseStream = ({
       transportStreamEntry,
       streamBuffers,
       nextPesHeader,
-      parserContext,
+      state,
       programId,
-      structure
+      structure,
+      offset: iterator.counter.getOffset()
     });
   }
   if (transportStreamEntry.streamType === 15) {
@@ -10567,8 +10795,9 @@ var parseStream = ({
       transportStreamEntry,
       streamBuffers,
       nextPesHeader,
-      options: parserContext,
-      structure
+      state,
+      structure,
+      offset: iterator.counter.getOffset()
     });
   }
   throw new Error(`Unsupported stream type ${transportStreamEntry.streamType}`);
@@ -10579,7 +10808,7 @@ var parsePacket = async ({
   iterator,
   structure,
   streamBuffers,
-  parserContext,
+  parserState,
   nextPesHeaderStore
 }) => {
   const offset = iterator.counter.getOffset();
@@ -10643,7 +10872,7 @@ var parsePacket = async ({
       transportStreamEntry: stream,
       streamBuffers,
       nextPesHeader: nextPesHeaderStore.getNextPesHeader(),
-      parserContext,
+      state: parserState,
       programId,
       structure
     });
@@ -10655,16 +10884,19 @@ var parsePacket = async ({
 // src/boxes/transport-stream/parse-transport-stream.ts
 var parseTransportStream = async ({
   iterator,
-  parserContext,
-  structure,
+  state,
   streamBuffers,
   fields,
   nextPesHeaderStore
 }) => {
+  const structure = state.structure.getStructure();
+  if (structure.type !== "transport-stream") {
+    throw new Error("Invalid structure type");
+  }
   if (iterator.bytesRemaining() === 0) {
     await processFinalStreamBuffers({
       streamBufferMap: streamBuffers,
-      parserContext,
+      state,
       structure
     });
     return Promise.resolve({
@@ -10675,8 +10907,7 @@ var parseTransportStream = async ({
   while (true) {
     if (hasAllInfo({
       fields,
-      state: parserContext.parserState,
-      structure
+      state
     })) {
       break;
     }
@@ -10688,8 +10919,7 @@ var parseTransportStream = async ({
         continueParsing: () => {
           return parseTransportStream({
             iterator,
-            parserContext,
-            structure,
+            state,
             streamBuffers,
             fields,
             nextPesHeaderStore
@@ -10701,7 +10931,7 @@ var parseTransportStream = async ({
       iterator,
       structure,
       streamBuffers,
-      parserContext,
+      parserState: state,
       nextPesHeaderStore
     });
     if (packet) {
@@ -10715,8 +10945,7 @@ var parseTransportStream = async ({
     continueParsing() {
       return parseTransportStream({
         iterator,
-        parserContext,
-        structure,
+        state,
         streamBuffers,
         fields,
         nextPesHeaderStore
@@ -10759,7 +10988,7 @@ var parseBlockFlags = (iterator, type) => {
 };
 
 // src/boxes/webm/get-sample-from-block.ts
-var getSampleFromBlock = (ebml, parserContext, offset) => {
+var getSampleFromBlock = (ebml, state, offset) => {
   const iterator = getArrayBufferIterator(ebml.value, ebml.value.length);
   const trackNumber2 = iterator.getVint();
   if (trackNumber2 === null) {
@@ -10767,9 +10996,9 @@ var getSampleFromBlock = (ebml, parserContext, offset) => {
   }
   const timecodeRelativeToCluster = iterator.getInt16();
   const { keyframe } = parseBlockFlags(iterator, ebml.type === "SimpleBlock" ? matroskaElements.SimpleBlock : matroskaElements.Block);
-  const { codec, trackTimescale } = parserContext.parserState.getTrackInfoByNumber(trackNumber2);
-  const clusterOffset = parserContext.parserState.getTimestampOffsetForByteOffset(offset);
-  const timescale2 = parserContext.parserState.getTimescale();
+  const { codec, trackTimescale } = state.webm.getTrackInfoByNumber(trackNumber2);
+  const clusterOffset = state.webm.getTimestampOffsetForByteOffset(offset);
+  const timescale2 = state.webm.getTimescale();
   if (clusterOffset === undefined) {
     throw new Error("Could not find offset for byte offset " + offset);
   }
@@ -10786,7 +11015,9 @@ var getSampleFromBlock = (ebml, parserContext, offset) => {
       dts: timecodeInMicroseconds,
       duration: undefined,
       trackId: trackNumber2,
-      timestamp: timecodeInMicroseconds
+      timestamp: timecodeInMicroseconds,
+      offset,
+      timescale: timescale2
     };
     if (keyframe === null) {
       iterator.destroy();
@@ -10813,7 +11044,9 @@ var getSampleFromBlock = (ebml, parserContext, offset) => {
       type: "key",
       duration: undefined,
       cts: timecodeInMicroseconds,
-      dts: timecodeInMicroseconds
+      dts: timecodeInMicroseconds,
+      offset,
+      timescale: timescale2
     };
     iterator.destroy();
     return {
@@ -10828,7 +11061,7 @@ var getSampleFromBlock = (ebml, parserContext, offset) => {
 };
 
 // src/boxes/webm/parse-ebml.ts
-var parseEbml = async (iterator, parserContext) => {
+var parseEbml = async (iterator, state) => {
   const hex = iterator.getMatroskaSegmentId();
   if (hex === null) {
     throw new Error("Not enough bytes left to parse EBML - this should not happen");
@@ -10897,11 +11130,11 @@ var parseEbml = async (iterator, parserContext) => {
         break;
       }
       const offset = iterator.counter.getOffset();
-      const value = await parseEbml(iterator, parserContext);
+      const value = await parseEbml(iterator, state);
       const remapped = await postprocessEbml({
         offset,
         ebml: value,
-        parserContext
+        state
       });
       children.push(remapped);
       const offsetNow = iterator.counter.getOffset();
@@ -10919,47 +11152,47 @@ var parseEbml = async (iterator, parserContext) => {
 var postprocessEbml = async ({
   offset,
   ebml,
-  parserContext
+  state
 }) => {
   if (ebml.type === "TimestampScale") {
-    parserContext.parserState.setTimescale(ebml.value.value);
+    state.webm.setTimescale(ebml.value.value);
   }
   if (ebml.type === "TrackEntry") {
-    parserContext.parserState.onTrackEntrySegment(ebml);
+    state.webm.onTrackEntrySegment(ebml);
     const track = getTrack({
       track: ebml,
-      timescale: parserContext.parserState.getTimescale()
+      timescale: state.webm.getTimescale()
     });
     if (track) {
       await registerTrack({
-        options: parserContext,
+        state,
         track,
         container: "webm"
       });
     }
   }
   if (ebml.type === "Timestamp") {
-    parserContext.parserState.setTimestampOffset(offset, ebml.value.value);
+    state.webm.setTimestampOffset(offset, ebml.value.value);
   }
   if (ebml.type === "Block" || ebml.type === "SimpleBlock") {
-    const sample = getSampleFromBlock(ebml, parserContext, offset);
-    if (sample.type === "video-sample" && parserContext.nullifySamples) {
-      await parserContext.parserState.onVideoSample(sample.videoSample.trackId, sample.videoSample);
+    const sample = getSampleFromBlock(ebml, state, offset);
+    if (sample.type === "video-sample" && state.nullifySamples) {
+      await state.callbacks.onVideoSample(sample.videoSample.trackId, sample.videoSample);
       return {
         type: "Block",
         value: new Uint8Array([]),
         minVintWidth: ebml.minVintWidth
       };
     }
-    if (sample.type === "audio-sample" && parserContext.nullifySamples) {
-      await parserContext.parserState.onAudioSample(sample.audioSample.trackId, sample.audioSample);
+    if (sample.type === "audio-sample" && state.nullifySamples) {
+      await state.callbacks.onAudioSample(sample.audioSample.trackId, sample.audioSample);
       return {
         type: "Block",
         value: new Uint8Array([]),
         minVintWidth: ebml.minVintWidth
       };
     }
-    if (sample.type === "no-sample" && parserContext.nullifySamples) {
+    if (sample.type === "no-sample" && state.nullifySamples) {
       return {
         type: "Block",
         value: new Uint8Array([]),
@@ -10973,15 +11206,15 @@ var postprocessEbml = async ({
       throw new Error("Expected block segment");
     }
     const hasReferenceBlock = ebml.value.find((c) => c.type === "ReferenceBlock");
-    const sample = block2.value.length === 0 ? null : getSampleFromBlock(block2, parserContext, offset);
+    const sample = block2.value.length === 0 ? null : getSampleFromBlock(block2, state, offset);
     if (sample && sample.type === "partial-video-sample") {
       const completeFrame = {
         ...sample.partialVideoSample,
         type: hasReferenceBlock ? "delta" : "key"
       };
-      await parserContext.parserState.onVideoSample(sample.partialVideoSample.trackId, completeFrame);
+      await state.callbacks.onVideoSample(sample.partialVideoSample.trackId, completeFrame);
     }
-    if (parserContext.nullifySamples) {
+    if (state.nullifySamples) {
       return {
         type: "BlockGroup",
         value: [],
@@ -10996,7 +11229,7 @@ var postprocessEbml = async ({
 var continueAfterMatroskaParseResult = async ({
   result,
   iterator,
-  parserContext,
+  state,
   segment
 }) => {
   if (result.status === "done") {
@@ -11014,7 +11247,7 @@ var continueAfterMatroskaParseResult = async ({
       return continueAfterMatroskaParseResult({
         result: proceeded,
         iterator,
-        parserContext,
+        state,
         segment
       });
     },
@@ -11024,7 +11257,7 @@ var continueAfterMatroskaParseResult = async ({
 };
 var expectSegment = async ({
   iterator,
-  parserContext,
+  state,
   offset,
   children,
   fields,
@@ -11037,7 +11270,7 @@ var expectSegment = async ({
       continueParsing: () => {
         return expectAndProcessSegment({
           iterator,
-          parserContext,
+          state,
           offset,
           children,
           fields,
@@ -11055,7 +11288,7 @@ var expectSegment = async ({
       continueParsing: () => {
         return expectAndProcessSegment({
           iterator,
-          parserContext,
+          state,
           offset,
           children,
           fields,
@@ -11075,7 +11308,7 @@ var expectSegment = async ({
       continueParsing: () => {
         return expectSegment({
           iterator,
-          parserContext,
+          state,
           offset,
           children,
           fields,
@@ -11096,7 +11329,7 @@ var expectSegment = async ({
       iterator,
       length,
       children: newSegment.value,
-      parserContext,
+      state,
       startOffset: iterator.counter.getOffset(),
       fields,
       topLevelStructure
@@ -11107,7 +11340,7 @@ var expectSegment = async ({
         continueParsing: () => {
           return continueAfterMatroskaParseResult({
             iterator,
-            parserContext,
+            state,
             result: main,
             segment: newSegment
           });
@@ -11129,7 +11362,7 @@ var expectSegment = async ({
       continueParsing: () => {
         return expectSegment({
           iterator,
-          parserContext,
+          state,
           offset,
           children,
           fields,
@@ -11142,7 +11375,7 @@ var expectSegment = async ({
     segmentId,
     iterator,
     length,
-    parserContext,
+    state,
     headerReadSoFar: iterator.counter.getOffset() - offset
   });
   return {
@@ -11154,7 +11387,7 @@ var parseSegment = async ({
   segmentId,
   iterator,
   length,
-  parserContext,
+  state,
   headerReadSoFar
 }) => {
   if (length < 0) {
@@ -11162,8 +11395,8 @@ var parseSegment = async ({
   }
   iterator.counter.decrement(headerReadSoFar);
   const offset = iterator.counter.getOffset();
-  const ebml = await parseEbml(iterator, parserContext);
-  const remapped = await postprocessEbml({ offset, ebml, parserContext });
+  const ebml = await parseEbml(iterator, state);
+  const remapped = await postprocessEbml({ offset, ebml, state });
   return remapped;
 };
 
@@ -11177,14 +11410,14 @@ var processParseResult = ({
 }) => {
   if (parseResult.segment && !children.includes(parseResult.segment)) {
     children.push(parseResult.segment);
-    if (hasAllInfo({ fields, state, structure: topLevelStructure })) {
+    if (hasAllInfo({ fields, state })) {
       return {
         status: "done",
         segment: parseResult.segment
       };
     }
     if (parseResult.segment.type === "Tracks") {
-      state.tracks.setIsDone();
+      state.callbacks.tracks.setIsDone();
     }
   }
   if (parseResult.status === "incomplete") {
@@ -11210,7 +11443,7 @@ var processParseResult = ({
 };
 var expectAndProcessSegment = async ({
   iterator,
-  parserContext,
+  state,
   offset,
   children,
   fields,
@@ -11218,7 +11451,7 @@ var expectAndProcessSegment = async ({
 }) => {
   const segment = await expectSegment({
     iterator,
-    parserContext,
+    state,
     offset,
     children,
     fields,
@@ -11227,7 +11460,7 @@ var expectAndProcessSegment = async ({
   return processParseResult({
     children,
     parseResult: segment,
-    state: parserContext.parserState,
+    state,
     fields,
     topLevelStructure
   });
@@ -11236,7 +11469,7 @@ var continueAfterSegmentResult = async ({
   result,
   length,
   children,
-  parserContext,
+  state,
   iterator,
   startOffset,
   fields,
@@ -11254,7 +11487,7 @@ var continueAfterSegmentResult = async ({
           children,
           iterator,
           length,
-          parserContext,
+          state,
           startOffset,
           fields,
           topLevelStructure
@@ -11271,7 +11504,7 @@ var continueAfterSegmentResult = async ({
         children,
         iterator,
         length,
-        parserContext,
+        state,
         startOffset,
         fields,
         topLevelStructure
@@ -11284,7 +11517,7 @@ var expectChildren = async ({
   iterator,
   length,
   children,
-  parserContext,
+  state,
   startOffset,
   fields,
   topLevelStructure
@@ -11296,7 +11529,7 @@ var expectChildren = async ({
     const currentOffset = iterator.counter.getOffset();
     const child = await expectAndProcessSegment({
       iterator,
-      parserContext,
+      state,
       offset: currentOffset,
       children,
       fields,
@@ -11304,8 +11537,7 @@ var expectChildren = async ({
     });
     if (hasAllInfo({
       fields,
-      state: parserContext.parserState,
-      structure: topLevelStructure
+      state
     })) {
       return {
         status: "done"
@@ -11320,7 +11552,7 @@ var expectChildren = async ({
             children,
             iterator,
             length: length - (currentOffset - startOffset),
-            parserContext,
+            state,
             startOffset: currentOffset,
             fields,
             topLevelStructure
@@ -11339,13 +11571,11 @@ var expectChildren = async ({
 var continueAfterMatroskaResult = (result, structure) => {
   if (result.status === "done") {
     return {
-      status: "done",
-      segments: structure
+      status: "done"
     };
   }
   return {
     status: "incomplete",
-    segments: structure,
     continueParsing: async () => {
       const newResult = await result.continueParsing();
       return continueAfterMatroskaResult(newResult, structure);
@@ -11355,15 +11585,18 @@ var continueAfterMatroskaResult = (result, structure) => {
 };
 var parseWebm = async ({
   counter,
-  parserContext,
+  state,
   fields
 }) => {
-  const structure = { type: "matroska", boxes: [] };
+  const structure = state.structure.getStructure();
+  if (structure.type !== "matroska") {
+    throw new Error("Invalid structure type");
+  }
   const results = await expectChildren({
     iterator: counter,
     length: Infinity,
     children: structure.boxes,
-    parserContext,
+    state,
     startOffset: counter.counter.getOffset(),
     fields,
     topLevelStructure: structure
@@ -11374,7 +11607,7 @@ var parseWebm = async ({
 // src/parse-video.ts
 var parseVideo = ({
   iterator,
-  options,
+  state,
   signal,
   logLevel,
   fields,
@@ -11388,16 +11621,25 @@ var parseVideo = ({
   const fileType = iterator.detectFileType();
   if (fileType.type === "riff") {
     Log.verbose(logLevel, "Detected RIFF container");
-    return Promise.resolve(parseRiff({ iterator, options, fields }));
+    state.structure.setStructure({
+      type: "riff",
+      boxes: []
+    });
+    return Promise.resolve(parseRiff({ iterator, state, fields }));
   }
   if (fileType.type === "iso-base-media") {
     Log.verbose(logLevel, "Detected ISO Base Media container");
+    const initialBoxes = [];
+    state.structure.setStructure({
+      type: "iso-base-media",
+      boxes: initialBoxes
+    });
     return parseIsoBaseMediaBoxes({
       iterator,
       maxBytes: Infinity,
       allowIncompleteBoxes: true,
-      initialBoxes: [],
-      options,
+      initialBoxes,
+      state,
       continueMdat: false,
       signal,
       logLevel,
@@ -11406,16 +11648,21 @@ var parseVideo = ({
   }
   if (fileType.type === "webm") {
     Log.verbose(logLevel, "Detected Matroska container");
-    return parseWebm({ counter: iterator, parserContext: options, fields });
+    state.structure.setStructure({
+      boxes: [],
+      type: "matroska"
+    });
+    return parseWebm({ counter: iterator, state, fields });
   }
   if (fileType.type === "transport-stream") {
+    Log.verbose(logLevel, "Detected MPEG-2 Transport Stream");
+    state.structure.setStructure({
+      boxes: [],
+      type: "transport-stream"
+    });
     return parseTransportStream({
       iterator,
-      parserContext: options,
-      structure: {
-        type: "transport-stream",
-        boxes: []
-      },
+      state,
       streamBuffers: new Map,
       fields,
       nextPesHeaderStore: makeNextPesHeaderStore()
@@ -11485,12 +11732,86 @@ var parseVideo = ({
   return Promise.reject(new Error("Unknown video format " + fileType));
 };
 
+// src/state/emitted-fields.ts
+var emittedState = () => {
+  const emittedFields = {
+    audioCodec: false,
+    container: false,
+    dimensions: false,
+    durationInSeconds: false,
+    fps: false,
+    internalStats: false,
+    isHdr: false,
+    location: false,
+    metadata: false,
+    mimeType: false,
+    name: false,
+    rotation: false,
+    size: false,
+    structure: false,
+    tracks: false,
+    videoCodec: false,
+    unrotatedDimensions: false,
+    slowDurationInSeconds: false,
+    slowFps: false,
+    slowKeyframes: false,
+    slowNumberOfFrames: false,
+    keyframes: false
+  };
+  return emittedFields;
+};
+
+// src/state/keyframes.ts
+var keyframesState = () => {
+  const keyframes = [];
+  return {
+    addKeyframe: (keyframe) => {
+      keyframes.push(keyframe);
+    },
+    getKeyframes: () => {
+      return keyframes;
+    }
+  };
+};
+
+// src/state/riff.ts
+var riffSpecificState = () => {
+  let avcProfile = null;
+  let nextTrackIndex = 0;
+  const profileCallbacks = [];
+  const registerOnAvcProfileCallback = (callback) => {
+    profileCallbacks.push(callback);
+  };
+  const onProfile = async (profile) => {
+    avcProfile = profile;
+    for (const callback of profileCallbacks) {
+      await callback(profile);
+    }
+    profileCallbacks.length = 0;
+  };
+  return {
+    getAvcProfile: () => {
+      return avcProfile;
+    },
+    onProfile,
+    registerOnAvcProfileCallback,
+    getNextTrackIndex: () => {
+      return nextTrackIndex;
+    },
+    incrementNextTrackIndex: () => {
+      nextTrackIndex++;
+    }
+  };
+};
+
 // src/state/can-skip-tracks.ts
 var needsTracksField = {
   audioCodec: true,
   container: false,
   dimensions: true,
   durationInSeconds: true,
+  slowDurationInSeconds: true,
+  slowFps: true,
   fps: true,
   internalStats: false,
   isHdr: true,
@@ -11503,7 +11824,10 @@ var needsTracksField = {
   videoCodec: true,
   metadata: true,
   location: true,
-  mimeType: false
+  mimeType: false,
+  slowKeyframes: true,
+  slowNumberOfFrames: true,
+  keyframes: true
 };
 var makeCanSkipTracksState = ({
   hasAudioTrackHandlers,
@@ -11546,92 +11870,28 @@ var makeTracksSectionState = (canSkipTracksState) => {
   };
 };
 
-// src/state/parser-state.ts
-var makeParserState = ({
+// src/state/sample-callbacks.ts
+var sampleCallback = ({
+  signal,
   hasAudioTrackHandlers,
   hasVideoTrackHandlers,
-  signal,
-  getIterator,
-  fields
+  fields,
+  keyframes,
+  emittedFields,
+  slowDurationAndFpsState
 }) => {
-  const trackEntries = {};
-  const onTrackEntrySegment = (trackEntry2) => {
-    const trackId = getTrackId(trackEntry2);
-    if (!trackId) {
-      throw new Error("Expected track id");
-    }
-    if (trackEntries[trackId]) {
-      return;
-    }
-    const codec = getTrackCodec(trackEntry2);
-    if (!codec) {
-      throw new Error("Expected codec");
-    }
-    const trackTimescale = getTrackTimestampScale(trackEntry2);
-    trackEntries[trackId] = {
-      codec: codec.value,
-      trackTimescale: trackTimescale?.value ?? null
-    };
-  };
   const videoSampleCallbacks = {};
   const audioSampleCallbacks = {};
   const queuedAudioSamples = {};
   const queuedVideoSamples = {};
-  let timescale2 = null;
-  let skippedBytes = 0;
-  const getTimescale = () => {
-    if (timescale2 === null) {
-      return 1e6;
-    }
-    return timescale2;
-  };
-  const increaseSkippedBytes = (bytes) => {
-    skippedBytes += bytes;
-  };
-  const setTimescale = (newTimescale) => {
-    timescale2 = newTimescale;
-  };
-  const timestampMap = new Map;
-  const setTimestampOffset = (byteOffset, timestamp) => {
-    timestampMap.set(byteOffset, timestamp);
-  };
-  const getTimestampOffsetForByteOffset = (byteOffset) => {
-    const entries = Array.from(timestampMap.entries());
-    const sortedByByteOffset = entries.sort((a, b) => {
-      return a[0] - b[0];
-    }).reverse();
-    for (const [offset, timestamp] of sortedByByteOffset) {
-      if (offset >= byteOffset) {
-        continue;
-      }
-      return timestamp;
-    }
-    return timestampMap.get(byteOffset);
-  };
-  const samplesForTrack = {};
-  const profileCallbacks = [];
-  const registerOnAvcProfileCallback = (callback) => {
-    profileCallbacks.push(callback);
-  };
-  let avcProfile = null;
-  const onProfile = async (profile) => {
-    avcProfile = profile;
-    for (const callback of profileCallbacks) {
-      await callback(profile);
-    }
-    profileCallbacks.length = 0;
-  };
   const canSkipTracksState = makeCanSkipTracksState({
     hasAudioTrackHandlers,
     fields,
     hasVideoTrackHandlers
   });
   const tracksState = makeTracksSectionState(canSkipTracksState);
+  const samplesForTrack = {};
   return {
-    onTrackEntrySegment,
-    onProfile,
-    registerOnAvcProfileCallback,
-    getTrackInfoByNumber: (id) => trackEntries[id],
     registerVideoSampleCallback: async (id, callback) => {
       if (callback === null) {
         delete videoSampleCallbacks[id];
@@ -11643,19 +11903,6 @@ var makeParserState = ({
       }
       queuedVideoSamples[id] = [];
     },
-    setTimestampOffset,
-    getTimestampOffsetForByteOffset,
-    registerAudioSampleCallback: async (id, callback) => {
-      if (callback === null) {
-        delete audioSampleCallbacks[id];
-        return;
-      }
-      audioSampleCallbacks[id] = callback;
-      for (const queued of queuedAudioSamples[id] ?? []) {
-        await callback(queued);
-      }
-      queuedAudioSamples[id] = [];
-    },
     onAudioSample: async (trackId, audioSample) => {
       if (signal?.aborted) {
         throw new Error("Aborted");
@@ -11663,12 +11910,17 @@ var makeParserState = ({
       if (typeof samplesForTrack[trackId] === "undefined") {
         samplesForTrack[trackId] = 0;
       }
-      samplesForTrack[trackId]++;
       const callback = audioSampleCallbacks[trackId];
-      if (callback) {
-        await callback(audioSample);
+      if (audioSample.data.length > 0) {
+        samplesForTrack[trackId]++;
+        if (callback) {
+          await callback(audioSample);
+        }
       }
     },
+    getSamplesForTrack: (trackId) => {
+      return samplesForTrack[trackId] ?? 0;
+    },
     onVideoSample: async (trackId, videoSample) => {
       if (signal?.aborted) {
         throw new Error("Aborted");
@@ -11676,31 +11928,204 @@ var makeParserState = ({
       if (typeof samplesForTrack[trackId] === "undefined") {
         samplesForTrack[trackId] = 0;
       }
-      samplesForTrack[trackId]++;
-      const callback = videoSampleCallbacks[trackId];
-      if (callback) {
-        await callback(videoSample);
+      if (videoSample.data.length > 0) {
+        samplesForTrack[trackId]++;
+        const callback = videoSampleCallbacks[trackId];
+        if (callback) {
+          await callback(videoSample);
+        }
+      }
+      if (needsToIterateOverSamples({
+        fields,
+        emittedFields
+      })) {
+        if (fields.slowKeyframes && videoSample.type === "key") {
+          keyframes.addKeyframe({
+            trackId,
+            decodingTimeInSeconds: videoSample.dts / videoSample.timescale,
+            positionInBytes: videoSample.offset,
+            presentationTimeInSeconds: videoSample.cts / videoSample.timescale,
+            sizeInBytes: videoSample.data.length
+          });
+        }
+        slowDurationAndFpsState.addSample(videoSample);
       }
     },
-    getTimescale,
-    setTimescale,
-    getSamplesForTrack: (trackId) => {
-      return samplesForTrack[trackId] ?? 0;
+    canSkipTracksState,
+    registerAudioSampleCallback: async (id, callback) => {
+      if (callback === null) {
+        delete audioSampleCallbacks[id];
+        return;
+      }
+      audioSampleCallbacks[id] = callback;
+      for (const queued of queuedAudioSamples[id] ?? []) {
+        await callback(queued);
+      }
+      queuedAudioSamples[id] = [];
     },
-    getAvcProfile: () => {
-      return avcProfile;
+    tracks: tracksState,
+    audioSampleCallbacks,
+    videoSampleCallbacks
+  };
+};
+
+// src/state/slow-duration-fps.ts
+var slowDurationAndFpsState = () => {
+  let smallestSample;
+  let largestSample;
+  let samples = 0;
+  const getSlowDurationInSeconds = () => {
+    if (smallestSample !== undefined && largestSample !== undefined) {
+      const startingTimestampDifference = largestSample - smallestSample;
+      const timeBetweenSamples = startingTimestampDifference / (samples - 1);
+      return timeBetweenSamples * samples;
+    }
+    throw new Error("No samples");
+  };
+  return {
+    addSample: (videoSample) => {
+      samples++;
+      const presentationTimeInSeconds = videoSample.cts / videoSample.timescale;
+      if (largestSample === undefined || presentationTimeInSeconds > largestSample) {
+        largestSample = presentationTimeInSeconds;
+      }
+      if (smallestSample === undefined || presentationTimeInSeconds < smallestSample) {
+        smallestSample = presentationTimeInSeconds;
+      }
+    },
+    getSlowDurationInSeconds,
+    getFps: () => {
+      return samples / getSlowDurationInSeconds();
     },
+    getSlowNumberOfFrames: () => samples
+  };
+};
+
+// src/state/structure.ts
+var structureState = () => {
+  let structure = null;
+  return {
+    getStructureOrNull: () => {
+      return structure;
+    },
+    getStructure: () => {
+      if (structure === null) {
+        throw new Error("Expected structure");
+      }
+      return structure;
+    },
+    setStructure: (value) => {
+      structure = value;
+    }
+  };
+};
+
+// src/state/webm.ts
+var webmState = () => {
+  const trackEntries = {};
+  const onTrackEntrySegment = (trackEntry2) => {
+    const trackId = getTrackId(trackEntry2);
+    if (!trackId) {
+      throw new Error("Expected track id");
+    }
+    if (trackEntries[trackId]) {
+      return;
+    }
+    const codec = getTrackCodec(trackEntry2);
+    if (!codec) {
+      throw new Error("Expected codec");
+    }
+    const trackTimescale = getTrackTimestampScale(trackEntry2);
+    trackEntries[trackId] = {
+      codec: codec.value,
+      trackTimescale: trackTimescale?.value ?? null
+    };
+  };
+  const timestampMap = new Map;
+  const getTimestampOffsetForByteOffset = (byteOffset) => {
+    const entries = Array.from(timestampMap.entries());
+    const sortedByByteOffset = entries.sort((a, b) => {
+      return a[0] - b[0];
+    }).reverse();
+    for (const [offset, timestamp] of sortedByByteOffset) {
+      if (offset >= byteOffset) {
+        continue;
+      }
+      return timestamp;
+    }
+    return timestampMap.get(byteOffset);
+  };
+  const setTimestampOffset = (byteOffset, timestamp) => {
+    timestampMap.set(byteOffset, timestamp);
+  };
+  let timescale2 = null;
+  const setTimescale = (newTimescale) => {
+    timescale2 = newTimescale;
+  };
+  const getTimescale = () => {
+    if (timescale2 === null) {
+      return 1e6;
+    }
+    return timescale2;
+  };
+  return {
+    onTrackEntrySegment,
+    getTrackInfoByNumber: (id) => trackEntries[id],
+    setTimestampOffset,
+    getTimestampOffsetForByteOffset,
+    timescale: timescale2,
+    getTimescale,
+    setTimescale
+  };
+};
+
+// src/state/parser-state.ts
+var makeParserState = ({
+  hasAudioTrackHandlers,
+  hasVideoTrackHandlers,
+  signal,
+  getIterator,
+  fields,
+  nullifySamples,
+  onAudioTrack,
+  onVideoTrack,
+  supportsContentRange
+}) => {
+  let skippedBytes = 0;
+  const increaseSkippedBytes = (bytes) => {
+    skippedBytes += bytes;
+  };
+  const structure = structureState();
+  const keyframes = keyframesState();
+  const emittedFields = emittedState();
+  const slowDurationAndFps = slowDurationAndFpsState();
+  return {
+    riff: riffSpecificState(),
+    callbacks: sampleCallback({
+      signal,
+      hasAudioTrackHandlers,
+      hasVideoTrackHandlers,
+      fields,
+      keyframes,
+      emittedFields,
+      slowDurationAndFpsState: slowDurationAndFps
+    }),
     getInternalStats: () => ({
       skippedBytes,
       finalCursorOffset: getIterator()?.counter.getOffset() ?? 0
     }),
     getSkipBytes: () => skippedBytes,
     increaseSkippedBytes,
-    maySkipVideoData: () => {
-      return tracksState.hasAllTracks() && Object.values(videoSampleCallbacks).length === 0 && Object.values(audioSampleCallbacks).length === 0;
-    },
-    tracks: tracksState,
-    canSkipTracksState
+    keyframes,
+    structure,
+    nullifySamples,
+    onAudioTrack,
+    onVideoTrack,
+    supportsContentRange,
+    webm: webmState(),
+    emittedFields,
+    fields,
+    slowDurationAndFps
   };
 };
 
@@ -11723,13 +12148,6 @@ var parseMedia = async function({
     fields: fieldsInReturnValue,
     callbacks: more
   });
-  const state = makeParserState({
-    hasAudioTrackHandlers: Boolean(onAudioTrack),
-    hasVideoTrackHandlers: Boolean(onVideoTrack),
-    signal,
-    getIterator: () => iterator,
-    fields
-  });
   const {
     reader,
     contentLength,
@@ -11737,41 +12155,24 @@ var parseMedia = async function({
     contentType,
     supportsContentRange: readerSupportsContentRange
   } = await readerInterface.read(src, null, signal);
-  let currentReader = reader;
-  const emittedFields = {
-    audioCodec: false,
-    container: false,
-    dimensions: false,
-    durationInSeconds: false,
-    fps: false,
-    internalStats: false,
-    isHdr: false,
-    location: false,
-    metadata: false,
-    mimeType: false,
-    name: false,
-    rotation: false,
-    size: false,
-    structure: false,
-    tracks: false,
-    videoCodec: false,
-    unrotatedDimensions: false
-  };
   const supportsContentRange = readerSupportsContentRange && !(typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.DISABLE_CONTENT_RANGE === "true");
-  const returnValue = {};
-  const moreFields = more;
-  const options = {
+  const state = makeParserState({
+    hasAudioTrackHandlers: Boolean(onAudioTrack),
+    hasVideoTrackHandlers: Boolean(onVideoTrack),
+    signal,
+    getIterator: () => iterator,
+    fields,
     onAudioTrack: onAudioTrack ?? null,
     onVideoTrack: onVideoTrack ?? null,
-    parserState: state,
     nullifySamples: !(typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.KEEP_SAMPLES === "true"),
-    supportsContentRange,
-    nextTrackIndex: 0
-  };
+    supportsContentRange
+  });
+  let currentReader = reader;
+  const returnValue = {};
+  const moreFields = more;
   const triggerInfoEmit = () => {
     const availableInfo = getAvailableInfo({
       fieldsToFetch: fields,
-      structure: parseResult?.segments ?? null,
       state
     });
     emitAvailableInfo({
@@ -11783,8 +12184,7 @@ var parseMedia = async function({
       returnValue,
       contentLength,
       name,
-      mimeType: contentType,
-      emittedFields
+      mimeType: contentType
     });
   };
   triggerInfoEmit();
@@ -11821,12 +12221,12 @@ var parseMedia = async function({
     });
     triggerInfoEmit();
     if (parseResult && parseResult.status === "incomplete") {
-      Log.verbose(logLevel, "Continuing parsing of file, currently at position", iterator.counter.getOffset());
+      Log.trace(logLevel, "Continuing parsing of file, currently at position", iterator.counter.getOffset());
       parseResult = await parseResult.continueParsing();
     } else {
       parseResult = await parseVideo({
         iterator,
-        options,
+        state,
         signal: signal ?? null,
         logLevel,
         fields,
@@ -11840,7 +12240,6 @@ var parseMedia = async function({
     }
     if (hasAllInfo({
       fields,
-      structure: parseResult.segments,
       state
     })) {
       Log.verbose(logLevel, "Got all info, skipping to the end.");
@@ -11880,12 +12279,11 @@ var parseMedia = async function({
     returnValue,
     contentLength,
     mimeType: contentType,
-    name,
-    emittedFields
+    name
   });
   currentReader.abort();
   iterator?.destroy();
-  state.tracks.ensureHasTracksAtEnd();
+  state.callbacks.tracks.ensureHasTracksAtEnd();
   return returnValue;
 };
 // src/index.ts