@remotion/media-parser 4.0.277 → 4.0.279

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

@@ -1968,46 +1968,12 @@ var detectFileType = (data) => {
   return { type: "unknown" };
 };
 
-// src/buffer-iterator.ts
-class OffsetCounter {
-  #offset;
-  #discardedBytes;
-  constructor(initial) {
-    this.#offset = initial;
-    this.#discardedBytes = 0;
-  }
-  increment(amount) {
-    if (amount < 0) {
-      throw new Error("Cannot increment by a negative amount: " + amount);
-    }
-    this.#offset += amount;
-  }
-  getOffset() {
-    return this.#offset;
-  }
-  getDiscardedOffset() {
-    return this.#offset - this.#discardedBytes;
-  }
-  setDiscardedOffset(offset) {
-    this.#discardedBytes = offset;
-  }
-  getDiscardedBytes() {
-    return this.#discardedBytes;
-  }
-  discardBytes(amount) {
-    this.#discardedBytes += amount;
-  }
-  decrement(amount) {
-    if (amount < 0) {
-      throw new Error("Cannot decrement by a negative amount");
-    }
-    this.#offset -= amount;
-  }
-}
-var makeOffsetCounter = () => {
-  return new OffsetCounter(0);
-};
-var getArrayBufferIterator = (initialData, maxBytes) => {
+// src/iterator/buffer-manager.ts
+var bufferManager = ({
+  initialData,
+  maxBytes,
+  counter
+}) => {
   const buf = new ArrayBuffer(initialData.byteLength, {
     maxByteLength: maxBytes === null ? initialData.byteLength : Math.min(maxBytes, 2 ** 32)
   });
@@ -2017,7 +1983,113 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
   let uintArray = new Uint8Array(buf);
   uintArray.set(initialData);
   let view = new DataView(uintArray.buffer);
-  const counter = makeOffsetCounter();
+  const destroy = () => {
+    uintArray = new Uint8Array(0);
+    buf.resize(0);
+  };
+  const flushBytesRead = (force, mode) => {
+    const bytesToRemove = counter.getDiscardedOffset();
+    if (bytesToRemove < 3000000 && !force) {
+      return { bytesRemoved: 0, removedData: null };
+    }
+    if (view.byteLength < bytesToRemove && !force) {
+      return { bytesRemoved: 0, removedData: null };
+    }
+    counter.discardBytes(bytesToRemove);
+    const removedData = mode === "download" ? uintArray.slice(0, bytesToRemove) : null;
+    const newData = uintArray.slice(bytesToRemove);
+    uintArray.set(newData);
+    buf.resize(newData.byteLength);
+    view = new DataView(uintArray.buffer);
+    return { bytesRemoved: bytesToRemove, removedData };
+  };
+  const skipTo = (offset) => {
+    const becomesSmaller = offset < counter.getOffset();
+    if (becomesSmaller) {
+      const toDecrement = counter.getOffset() - offset;
+      if (toDecrement > counter.getDiscardedOffset()) {
+        throw new Error("Cannot count backwards, data has already been flushed");
+      }
+      counter.decrement(toDecrement);
+    }
+    const currentOffset = counter.getOffset();
+    counter.increment(offset - currentOffset);
+  };
+  const addData = (newData) => {
+    const oldLength = buf.byteLength;
+    const newLength = oldLength + newData.byteLength;
+    if (newLength < oldLength) {
+      throw new Error("Cannot decrement size");
+    }
+    if (newLength > (maxBytes ?? Infinity)) {
+      throw new Error(`Exceeded maximum byte length ${maxBytes} with ${newLength}`);
+    }
+    buf.resize(newLength);
+    uintArray = new Uint8Array(buf);
+    uintArray.set(newData, oldLength);
+    view = new DataView(uintArray.buffer);
+  };
+  const replaceData = (newData, seekTo) => {
+    buf.resize(newData.byteLength);
+    uintArray = new Uint8Array(buf);
+    uintArray.set(newData);
+    view = new DataView(uintArray.buffer);
+    counter.setDiscardedOffset(0);
+    counter.decrement(counter.getOffset());
+    counter.increment(seekTo);
+  };
+  return {
+    view,
+    uintArray,
+    destroy,
+    addData,
+    skipTo,
+    removeBytesRead: flushBytesRead,
+    replaceData
+  };
+};
+
+// src/iterator/offset-counter.ts
+var makeOffsetCounter = (initial) => {
+  let offset = initial;
+  let discardedBytes = 0;
+  return {
+    getOffset: () => offset,
+    discardBytes: (bytes) => {
+      discardedBytes += bytes;
+    },
+    increment: (bytes) => {
+      if (bytes < 0) {
+        throw new Error("Cannot increment by a negative amount: " + bytes);
+      }
+      offset += bytes;
+    },
+    getDiscardedBytes: () => discardedBytes,
+    setDiscardedOffset: (bytes) => {
+      discardedBytes = bytes;
+    },
+    getDiscardedOffset: () => offset - discardedBytes,
+    decrement: (bytes) => {
+      if (bytes < 0) {
+        throw new Error("Cannot decrement by a negative amount: " + bytes);
+      }
+      offset -= bytes;
+    }
+  };
+};
+
+// src/iterator/buffer-iterator.ts
+var getArrayBufferIterator = (initialData, maxBytes) => {
+  const counter = makeOffsetCounter(0);
+  const {
+    uintArray,
+    view,
+    addData,
+    destroy,
+    removeBytesRead,
+    skipTo,
+    replaceData
+  } = bufferManager({ initialData, maxBytes, counter });
   const startCheckpoint = () => {
     const checkpoint = counter.getOffset();
     return {
@@ -2150,51 +2222,9 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     counter.increment(4);
     return val;
   };
-  const addData = (newData) => {
-    const oldLength = buf.byteLength;
-    const newLength = oldLength + newData.byteLength;
-    if (newLength < oldLength) {
-      throw new Error("Cannot decrement size");
-    }
-    if (newLength > (maxBytes ?? Infinity)) {
-      throw new Error(`Exceeded maximum byte length ${maxBytes} with ${newLength}`);
-    }
-    buf.resize(newLength);
-    const newArray = new Uint8Array(buf);
-    newArray.set(newData, oldLength);
-    uintArray = newArray;
-    view = new DataView(uintArray.buffer);
-  };
   const bytesRemaining = () => {
     return uintArray.byteLength - counter.getDiscardedOffset();
   };
-  const removeBytesRead = (force, mode) => {
-    const bytesToRemove = counter.getDiscardedOffset();
-    if (bytesToRemove < 3000000 && !force) {
-      return { bytesRemoved: 0, removedData: null };
-    }
-    if (view.byteLength < bytesToRemove && !force) {
-      return { bytesRemoved: 0, removedData: null };
-    }
-    counter.discardBytes(bytesToRemove);
-    const removedData = mode === "download" ? uintArray.slice(0, bytesToRemove) : null;
-    const newData = uintArray.slice(bytesToRemove);
-    uintArray.set(newData);
-    buf.resize(newData.byteLength);
-    view = new DataView(uintArray.buffer);
-    return { bytesRemoved: bytesToRemove, removedData };
-  };
-  const skipTo = (offset) => {
-    const becomesSmaller = offset < counter.getOffset();
-    if (!becomesSmaller) {
-      const currentOffset = counter.getOffset();
-      counter.increment(offset - currentOffset);
-      return;
-    }
-    buf.resize(0);
-    counter.decrement(counter.getOffset() - offset);
-    counter.setDiscardedOffset(offset);
-  };
   const readExpGolomb = () => {
     if (!bitReadingMode) {
       throw new Error("Not in bit reading mode");
@@ -2287,10 +2317,6 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     }
     return result;
   };
-  const destroy = () => {
-    uintArray = new Uint8Array(0);
-    buf.resize(0);
-  };
   return {
     startReadingBits,
     stopReadingBits,
@@ -2486,7 +2512,8 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     startCheckpoint,
     getFlacCodecNumber,
     readUntilLineEnd,
-    getSyncSafeInt32
+    getSyncSafeInt32,
+    replaceData
   };
 };
 
@@ -5078,22 +5105,237 @@ var hasSampleRate = (state) => {
   return state.callbacks.tracks.hasAllTracks();
 };
 
+// src/containers/iso-base-media/get-seeking-from-mp4.ts
+var getSeekingInfoFromMp4 = (state) => {
+  const structure = state.getIsoStructure();
+  const moovAtom = getMoovBoxFromState(state);
+  const moofBoxes = getMoofBoxes(structure.boxes);
+  if (!moovAtom) {
+    return null;
+  }
+  return {
+    type: "iso-base-media-seeking-info",
+    moovBox: moovAtom,
+    moofBoxes
+  };
+};
+var getSeekingByteFromIsoBaseMedia = (info, time) => {
+  const tracks2 = getTracksFromMoovBox(info.moovBox);
+  const allTracks = [
+    ...tracks2.videoTracks,
+    ...tracks2.audioTracks,
+    ...tracks2.otherTracks
+  ];
+  let byte = 0;
+  let sam = null;
+  for (const t of allTracks) {
+    const { timescale: ts, type } = t;
+    if (type !== "video") {
+      continue;
+    }
+    const samplePositions = getSamplePositionsFromTrack({
+      trakBox: t.trakBox,
+      moofBoxes: info.moofBoxes
+    });
+    for (const sample of samplePositions) {
+      const ctsInSeconds = sample.cts / ts;
+      const dtsInSeconds = sample.dts / ts;
+      if ((ctsInSeconds <= time || dtsInSeconds <= time) && byte <= sample.offset && type === "video" && sample.isKeyframe) {
+        byte = sample.offset;
+        sam = sample;
+      }
+    }
+  }
+  if (!sam) {
+    throw new Error("No sample found");
+  }
+  return sam;
+};
+
+// src/get-seeking-info.ts
+var getSeekingInfo = (state) => {
+  const structure = state.getStructureOrNull();
+  if (!structure) {
+    return null;
+  }
+  if (structure.type === "iso-base-media") {
+    return getSeekingInfoFromMp4(state);
+  }
+  return null;
+};
+var getSeekingByte = (info, time) => {
+  if (info.type === "iso-base-media-seeking-info") {
+    return getSeekingByteFromIsoBaseMedia(info, time).offset;
+  }
+  throw new Error(`Unknown seeking info type: ${info.type}`);
+};
+
+// src/log.ts
+var logLevels = ["trace", "verbose", "info", "warn", "error"];
+var getNumberForLogLevel = (level) => {
+  return logLevels.indexOf(level);
+};
+var isEqualOrBelowLogLevel = (currentLevel, level) => {
+  return getNumberForLogLevel(currentLevel) <= getNumberForLogLevel(level);
+};
+var Log = {
+  trace: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "trace")) {
+      return console.log(...args);
+    }
+  },
+  verbose: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "verbose")) {
+      return console.log(...args);
+    }
+  },
+  info: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "info")) {
+      return console.log(...args);
+    }
+  },
+  warn: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "warn")) {
+      return console.warn(...args);
+    }
+  },
+  error: (...args) => {
+    return console.error(...args);
+  }
+};
+
+// src/seek-backwards.ts
+var seekBackwards = async (state, seekTo) => {
+  const { iterator } = state;
+  const howManyBytesNotYetDiscarded = iterator.counter.getDiscardedOffset();
+  const howManyBytesWeCanGoBack = iterator.counter.getOffset() - howManyBytesNotYetDiscarded;
+  if (iterator.counter.getOffset() - howManyBytesWeCanGoBack <= seekTo) {
+    iterator.skipTo(seekTo);
+    return;
+  }
+  const time = Date.now();
+  Log.verbose(state.logLevel, `Seeking in video from position ${iterator.counter.getOffset()} -> ${seekTo}. Re-reading because this portion is not available`);
+  const { reader: newReader } = await state.readerInterface.read({
+    src: state.src,
+    range: seekTo,
+    controller: state.controller
+  });
+  iterator.replaceData(new Uint8Array([]), seekTo);
+  Log.verbose(state.logLevel, `Re-reading took ${Date.now() - time}ms. New position: ${iterator.counter.getOffset()}`);
+  state.currentReader = newReader;
+};
+
+// src/seek-forwards.ts
+var seekForward = async (state, seekTo) => {
+  const { iterator } = state;
+  const alreadyHasBuffer = iterator.bytesRemaining() >= seekTo - iterator.counter.getOffset();
+  Log.verbose(state.logLevel, `Performing seek from ${iterator.counter.getOffset()} to ${seekTo}`);
+  if (alreadyHasBuffer) {
+    iterator.skipTo(seekTo);
+    Log.verbose(state.logLevel, `Already read ahead enough, skipping forward`);
+    return state.currentReader;
+  }
+  const time = Date.now();
+  Log.verbose(state.logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${seekTo}. Re-reading because this portion is not available`);
+  const { reader: newReader } = await state.readerInterface.read({
+    src: state.src,
+    range: seekTo,
+    controller: state.controller
+  });
+  iterator.skipTo(seekTo);
+  await state.discardReadBytes(true);
+  Log.verbose(state.logLevel, `Re-reading took ${Date.now() - time}ms. New position: ${iterator.counter.getOffset()}`);
+  state.currentReader = newReader;
+};
+
+// src/perform-seek.ts
+var performSeek = async ({
+  seekTo,
+  state
+}) => {
+  const { iterator, logLevel, mode, contentLength } = state;
+  if (seekTo <= iterator.counter.getOffset() && mode === "download") {
+    throw new Error(`Seeking backwards is not supported in parseAndDownloadMedia() mode. Current position: ${iterator.counter.getOffset()}, seekTo: ${seekTo}`);
+  }
+  if (seekTo > state.contentLength) {
+    throw new Error(`Cannot seek beyond the end of the file: ${seekTo} > ${contentLength}`);
+  }
+  if (mode === "download") {
+    Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${seekTo}. Fetching but not reading all the data inbetween because in download mode`);
+    iterator.discard(seekTo - iterator.counter.getOffset());
+    return;
+  }
+  await state.controller?._internals.checkForAbortAndPause();
+  const alreadyAtByte = iterator.counter.getOffset() === seekTo;
+  if (alreadyAtByte) {
+    Log.verbose(logLevel, `Already at the desired position, seeking done`);
+    return;
+  }
+  const skippingForward = seekTo > iterator.counter.getOffset();
+  if (skippingForward) {
+    await seekForward(state, seekTo);
+  } else {
+    await seekBackwards(state, seekTo);
+  }
+  await state.controller?._internals.checkForAbortAndPause();
+};
+
+// src/work-on-seek-request.ts
+var turnSeekIntoByte = (seek2, state) => {
+  if (seek2.type === "keyframe-before-time-in-seconds") {
+    const seekingInfo = getSeekingInfo(state);
+    if (!seekingInfo) {
+      return {
+        type: "valid-but-must-wait"
+      };
+    }
+    const seekingByte = getSeekingByte(seekingInfo, seek2.time);
+    return {
+      type: "do-seek",
+      byte: seekingByte
+    };
+  }
+  throw new Error(`Cannot process seek request ${JSON.stringify(seek2)}`);
+};
+var workOnSeekRequest = async (state) => {
+  const seek2 = state.controller._internals.seekSignal.getSeek();
+  if (!seek2) {
+    return;
+  }
+  Log.trace(state.logLevel, `Has seek request: ${JSON.stringify(seek2)}`);
+  const resolution = turnSeekIntoByte(seek2, state);
+  Log.trace(state.logLevel, `Seek action: ${JSON.stringify(resolution)}`);
+  if (resolution.type === "do-seek") {
+    await performSeek({ state, seekTo: resolution.byte });
+    const { hasChanged } = state.controller._internals.seekSignal.clearSeekIfStillSame(seek2);
+    if (hasChanged) {
+      Log.trace(state.logLevel, `Seek request has changed while seeking, seeking again`);
+      await workOnSeekRequest(state);
+    }
+  }
+  if (resolution.type === "invalid") {
+    throw new Error(`The seek request ${JSON.stringify(seek2)} cannot be processed`);
+  }
+};
+
 // src/emit-available-info.ts
 var emitAvailableInfo = async ({
   hasInfo,
-  callbacks,
-  state,
-  returnValue,
-  name,
-  mimeType,
-  fieldsInReturnValue
+  state
 }) => {
   const keys = Object.keys(hasInfo);
-  const { emittedFields } = state;
+  const {
+    emittedFields,
+    fieldsInReturnValue,
+    returnValue,
+    name,
+    callbackFunctions
+  } = state;
   for (const key of keys) {
+    await workOnSeekRequest(state);
     if (key === "structure") {
       if (hasInfo.structure && !emittedFields.structure) {
-        await callbacks.onStructure?.(state.getStructure());
+        await callbackFunctions.onStructure?.(state.getStructure());
         if (fieldsInReturnValue.structure) {
           returnValue.structure = state.getStructure();
         }
@@ -5105,7 +5347,7 @@ var emitAvailableInfo = async ({
       if (hasInfo.durationInSeconds) {
         if (!emittedFields.durationInSeconds) {
           const durationInSeconds = getDuration(state);
-          await callbacks.onDurationInSeconds?.(durationInSeconds);
+          await callbackFunctions.onDurationInSeconds?.(durationInSeconds);
           if (fieldsInReturnValue.durationInSeconds) {
             returnValue.durationInSeconds = durationInSeconds;
           }
@@ -5117,7 +5359,7 @@ var emitAvailableInfo = async ({
     if (key === "slowDurationInSeconds") {
       if (hasInfo.slowDurationInSeconds && !emittedFields.slowDurationInSeconds) {
         const slowDurationInSeconds = getDuration(state) ?? state.slowDurationAndFps.getSlowDurationInSeconds();
-        await callbacks.onSlowDurationInSeconds?.(slowDurationInSeconds);
+        await callbackFunctions.onSlowDurationInSeconds?.(slowDurationInSeconds);
         if (fieldsInReturnValue.slowDurationInSeconds) {
           returnValue.slowDurationInSeconds = slowDurationInSeconds;
         }
@@ -5129,7 +5371,7 @@ var emitAvailableInfo = async ({
       if (hasInfo.fps) {
         if (!emittedFields.fps) {
           const fps = getFps(state);
-          await callbacks.onFps?.(fps);
+          await callbackFunctions.onFps?.(fps);
           if (fieldsInReturnValue.fps) {
             returnValue.fps = fps;
           }
@@ -5138,7 +5380,7 @@ var emitAvailableInfo = async ({
         if (!emittedFields.slowFps) {
           const fps = getFps(state);
           if (fps) {
-            await callbacks.onSlowFps?.(fps);
+            await callbackFunctions.onSlowFps?.(fps);
             if (fieldsInReturnValue.slowFps) {
               returnValue.slowFps = fps;
             }
@@ -5151,7 +5393,7 @@ var emitAvailableInfo = async ({
     if (key === "slowFps") {
       if (hasInfo.slowFps && !emittedFields.slowFps) {
         const slowFps = state.slowDurationAndFps.getFps();
-        await callbacks.onSlowFps?.(slowFps);
+        await callbackFunctions.onSlowFps?.(slowFps);
         if (fieldsInReturnValue.slowFps) {
           returnValue.slowFps = slowFps;
         }
@@ -5166,7 +5408,7 @@ var emitAvailableInfo = async ({
           height: dimensionsQueried.height,
           width: dimensionsQueried.width
         };
-        await callbacks.onDimensions?.(dimensions);
+        await callbackFunctions.onDimensions?.(dimensions);
         if (fieldsInReturnValue.dimensions) {
           returnValue.dimensions = dimensions;
         }
@@ -5181,7 +5423,7 @@ var emitAvailableInfo = async ({
           height: dimensionsQueried.unrotatedHeight,
           width: dimensionsQueried.unrotatedWidth
         };
-        await callbacks.onUnrotatedDimensions?.(unrotatedDimensions);
+        await callbackFunctions.onUnrotatedDimensions?.(unrotatedDimensions);
         if (fieldsInReturnValue.unrotatedDimensions) {
           returnValue.unrotatedDimensions = unrotatedDimensions;
         }
@@ -5193,7 +5435,7 @@ var emitAvailableInfo = async ({
       if (hasInfo.rotation && !emittedFields.rotation) {
         const dimensionsQueried = getDimensions(state);
         const rotation = dimensionsQueried?.rotation ?? 0;
-        await callbacks.onRotation?.(rotation);
+        await callbackFunctions.onRotation?.(rotation);
         if (fieldsInReturnValue.rotation) {
           returnValue.rotation = rotation;
         }
@@ -5204,7 +5446,7 @@ var emitAvailableInfo = async ({
     if (key === "videoCodec") {
       if (!emittedFields.videoCodec && hasInfo.videoCodec) {
         const videoCodec = getVideoCodec(state);
-        await callbacks.onVideoCodec?.(videoCodec);
+        await callbackFunctions.onVideoCodec?.(videoCodec);
         if (fieldsInReturnValue.videoCodec) {
           returnValue.videoCodec = videoCodec;
         }
@@ -5215,7 +5457,7 @@ var emitAvailableInfo = async ({
     if (key === "audioCodec") {
       if (!emittedFields.audioCodec && hasInfo.audioCodec) {
         const audioCodec = getAudioCodec(state);
-        await callbacks.onAudioCodec?.(audioCodec);
+        await callbackFunctions.onAudioCodec?.(audioCodec);
         if (fieldsInReturnValue.audioCodec) {
           returnValue.audioCodec = audioCodec;
         }
@@ -5226,7 +5468,7 @@ var emitAvailableInfo = async ({
     if (key === "tracks") {
       if (!emittedFields.tracks && hasInfo.tracks) {
         const { videoTracks, audioTracks } = getTracks(state);
-        await callbacks.onTracks?.({ videoTracks, audioTracks });
+        await callbackFunctions.onTracks?.({ videoTracks, audioTracks });
         if (fieldsInReturnValue.tracks) {
           returnValue.tracks = { videoTracks, audioTracks };
         }
@@ -5246,7 +5488,7 @@ var emitAvailableInfo = async ({
     }
     if (key === "size") {
       if (!emittedFields.size && hasInfo.size) {
-        await callbacks.onSize?.(state.contentLength);
+        await callbackFunctions.onSize?.(state.contentLength);
         if (fieldsInReturnValue.size) {
           returnValue.size = state.contentLength;
         }
@@ -5256,9 +5498,9 @@ var emitAvailableInfo = async ({
     }
     if (key === "mimeType") {
       if (!emittedFields.mimeType && hasInfo.mimeType) {
-        await callbacks.onMimeType?.(mimeType);
+        await callbackFunctions.onMimeType?.(state.mimeType);
         if (fieldsInReturnValue.mimeType) {
-          returnValue.mimeType = mimeType;
+          returnValue.mimeType = state.mimeType;
         }
         emittedFields.mimeType = true;
       }
@@ -5266,7 +5508,7 @@ var emitAvailableInfo = async ({
     }
     if (key === "name") {
       if (!emittedFields.name && hasInfo.name) {
-        await callbacks.onName?.(name);
+        await callbackFunctions.onName?.(name);
         if (fieldsInReturnValue.name) {
           returnValue.name = name;
         }
@@ -5277,7 +5519,7 @@ var emitAvailableInfo = async ({
     if (key === "isHdr") {
       if (!returnValue.isHdr && hasInfo.isHdr) {
         const isHdr = getIsHdr(state);
-        await callbacks.onIsHdr?.(isHdr);
+        await callbackFunctions.onIsHdr?.(isHdr);
         if (fieldsInReturnValue.isHdr) {
           returnValue.isHdr = isHdr;
         }
@@ -5288,7 +5530,7 @@ var emitAvailableInfo = async ({
     if (key === "container") {
       if (!returnValue.container && hasInfo.container) {
         const container = getContainer(state.getStructure());
-        await callbacks.onContainer?.(container);
+        await callbackFunctions.onContainer?.(container);
         if (fieldsInReturnValue.container) {
           returnValue.container = container;
         }
@@ -5299,7 +5541,7 @@ var emitAvailableInfo = async ({
     if (key === "metadata") {
       if (!emittedFields.metadata && hasInfo.metadata) {
         const metadata = getMetadata(state);
-        await callbacks.onMetadata?.(metadata);
+        await callbackFunctions.onMetadata?.(metadata);
         if (fieldsInReturnValue.metadata) {
           returnValue.metadata = metadata;
         }
@@ -5310,7 +5552,7 @@ var emitAvailableInfo = async ({
     if (key === "location") {
       if (!emittedFields.location && hasInfo.location) {
         const location = getLocation(state);
-        await callbacks.onLocation?.(location);
+        await callbackFunctions.onLocation?.(location);
         if (fieldsInReturnValue.location) {
           returnValue.location = location;
         }
@@ -5320,7 +5562,7 @@ var emitAvailableInfo = async ({
     }
     if (key === "slowKeyframes") {
       if (!emittedFields.slowKeyframes && hasInfo.slowKeyframes) {
-        await callbacks.onSlowKeyframes?.(state.keyframes.getKeyframes());
+        await callbackFunctions.onSlowKeyframes?.(state.keyframes.getKeyframes());
         if (fieldsInReturnValue.slowKeyframes) {
           returnValue.slowKeyframes = state.keyframes.getKeyframes();
         }
@@ -5330,7 +5572,7 @@ var emitAvailableInfo = async ({
     }
     if (key === "slowNumberOfFrames") {
       if (!emittedFields.slowNumberOfFrames && hasInfo.slowNumberOfFrames) {
-        await callbacks.onSlowNumberOfFrames?.(state.slowDurationAndFps.getSlowNumberOfFrames());
+        await callbackFunctions.onSlowNumberOfFrames?.(state.slowDurationAndFps.getSlowNumberOfFrames());
         if (fieldsInReturnValue.slowNumberOfFrames) {
           returnValue.slowNumberOfFrames = state.slowDurationAndFps.getSlowNumberOfFrames();
         }
@@ -5340,7 +5582,7 @@ var emitAvailableInfo = async ({
     }
     if (key === "slowAudioBitrate") {
       if (!emittedFields.slowAudioBitrate && hasInfo.slowAudioBitrate) {
-        await callbacks.onSlowAudioBitrate?.(state.slowDurationAndFps.getAudioBitrate());
+        await callbackFunctions.onSlowAudioBitrate?.(state.slowDurationAndFps.getAudioBitrate());
         if (fieldsInReturnValue.slowAudioBitrate) {
           returnValue.slowAudioBitrate = state.slowDurationAndFps.getAudioBitrate();
         }
@@ -5350,7 +5592,7 @@ var emitAvailableInfo = async ({
     }
     if (key === "slowVideoBitrate") {
       if (!emittedFields.slowVideoBitrate && hasInfo.slowVideoBitrate) {
-        await callbacks.onSlowVideoBitrate?.(state.slowDurationAndFps.getVideoBitrate());
+        await callbackFunctions.onSlowVideoBitrate?.(state.slowDurationAndFps.getVideoBitrate());
         if (fieldsInReturnValue.slowVideoBitrate) {
           returnValue.slowVideoBitrate = state.slowDurationAndFps.getVideoBitrate();
         }
@@ -5360,7 +5602,7 @@ var emitAvailableInfo = async ({
     }
     if (key === "keyframes") {
       if (!emittedFields.keyframes && hasInfo.keyframes) {
-        await callbacks.onKeyframes?.(getKeyframes(state));
+        await callbackFunctions.onKeyframes?.(getKeyframes(state));
         if (fieldsInReturnValue.keyframes) {
           returnValue.keyframes = getKeyframes(state);
         }
@@ -5370,7 +5612,7 @@ var emitAvailableInfo = async ({
     }
     if (key === "images") {
       if (!emittedFields.images && hasInfo.images) {
-        await callbacks.onImages?.(state.images.images);
+        await callbackFunctions.onImages?.(state.images.images);
         if (fieldsInReturnValue.images) {
           returnValue.images = state.images.images;
         }
@@ -5381,7 +5623,7 @@ var emitAvailableInfo = async ({
     if (key === "sampleRate") {
       if (!emittedFields.sampleRate && hasInfo.sampleRate) {
         const sampleRate = getSampleRate3(state);
-        await callbacks.onSampleRate?.(sampleRate);
+        await callbackFunctions.onSampleRate?.(sampleRate);
         if (fieldsInReturnValue.sampleRate) {
           returnValue.sampleRate = sampleRate;
         }
@@ -5392,7 +5634,7 @@ var emitAvailableInfo = async ({
     if (key === "numberOfAudioChannels") {
       if (!emittedFields.numberOfAudioChannels && hasInfo.numberOfAudioChannels) {
         const numberOfAudioChannels = getNumberOfAudioChannels(state);
-        await callbacks.onNumberOfAudioChannels?.(numberOfAudioChannels);
+        await callbackFunctions.onNumberOfAudioChannels?.(numberOfAudioChannels);
         if (fieldsInReturnValue.numberOfAudioChannels) {
           returnValue.numberOfAudioChannels = numberOfAudioChannels;
         }
@@ -5407,7 +5649,7 @@ var emitAvailableInfo = async ({
           originalSrc: state.src,
           readerInterface: state.readerInterface
         });
-        await callbacks.onM3uStreams?.(streams);
+        await callbackFunctions.onM3uStreams?.(streams);
         if (fieldsInReturnValue.m3uStreams) {
           returnValue.m3uStreams = streams;
         }
@@ -5417,45 +5659,7 @@ var emitAvailableInfo = async ({
     }
     throw new Error(`Unhandled key: ${key}`);
   }
-};
-
-// src/get-fields-from-callbacks.ts
-var getFieldsFromCallback = ({
-  fields,
-  callbacks
-}) => {
-  const newFields = {
-    audioCodec: Boolean(callbacks.onAudioCodec),
-    container: Boolean(callbacks.onContainer),
-    dimensions: Boolean(callbacks.onDimensions),
-    durationInSeconds: Boolean(callbacks.onDurationInSeconds),
-    fps: Boolean(callbacks.onFps),
-    internalStats: Boolean(callbacks.onInternalStats),
-    isHdr: Boolean(callbacks.onIsHdr),
-    location: Boolean(callbacks.onLocation),
-    metadata: Boolean(callbacks.onMetadata),
-    mimeType: Boolean(callbacks.onMimeType),
-    name: Boolean(callbacks.onName),
-    rotation: Boolean(callbacks.onRotation),
-    size: Boolean(callbacks.onSize),
-    structure: Boolean(callbacks.onStructure),
-    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),
-    images: Boolean(callbacks.onImages),
-    numberOfAudioChannels: Boolean(callbacks.onNumberOfAudioChannels),
-    sampleRate: Boolean(callbacks.onSampleRate),
-    slowAudioBitrate: Boolean(callbacks.onSlowAudioBitrate),
-    slowVideoBitrate: Boolean(callbacks.onSlowVideoBitrate),
-    m3uStreams: Boolean(callbacks.onM3uStreams),
-    ...fields
-  };
-  return newFields;
+  await workOnSeekRequest(state);
 };
 
 // src/state/need-samples-for-fields.ts
@@ -5511,10 +5715,9 @@ var maySkipVideoData = ({ state }) => {
 
 // src/has-all-info.ts
 var getAvailableInfo = ({
-  fieldsToFetch,
   state
 }) => {
-  const keys = Object.entries(fieldsToFetch).filter(([, value]) => value);
+  const keys = Object.entries(state.fields).filter(([, value]) => value);
   const structure = state.getStructureOrNull();
   const infos = keys.map(([_key]) => {
     const key = _key;
@@ -5590,12 +5793,8 @@ var getAvailableInfo = ({
   }
   return Object.fromEntries(entries);
 };
-var hasAllInfo = ({
-  fields,
-  state
-}) => {
+var hasAllInfo = ({ state }) => {
   const availableInfo = getAvailableInfo({
-    fieldsToFetch: fields ?? {},
     state
   });
   if (!Object.values(availableInfo).every(Boolean)) {
@@ -5610,38 +5809,27 @@ var hasAllInfo = ({
   return false;
 };
 
-// src/log.ts
-var logLevels = ["trace", "verbose", "info", "warn", "error"];
-var getNumberForLogLevel = (level) => {
-  return logLevels.indexOf(level);
-};
-var isEqualOrBelowLogLevel = (currentLevel, level) => {
-  return getNumberForLogLevel(currentLevel) <= getNumberForLogLevel(level);
-};
-var Log = {
-  trace: (logLevel, ...args) => {
-    if (isEqualOrBelowLogLevel(logLevel, "trace")) {
-      return console.log(...args);
+// src/emit-all-info.ts
+var emitAllInfo = async (state) => {
+  const allFields = Object.keys(state.fields).reduce((acc, key) => {
+    if (state.fields?.[key]) {
+      acc[key] = true;
     }
-  },
-  verbose: (logLevel, ...args) => {
-    if (isEqualOrBelowLogLevel(logLevel, "verbose")) {
-      return console.log(...args);
-    }
-  },
-  info: (logLevel, ...args) => {
-    if (isEqualOrBelowLogLevel(logLevel, "info")) {
-      return console.log(...args);
-    }
-  },
-  warn: (logLevel, ...args) => {
-    if (isEqualOrBelowLogLevel(logLevel, "warn")) {
-      return console.warn(...args);
-    }
-  },
-  error: (...args) => {
-    return console.error(...args);
-  }
+    return acc;
+  }, {});
+  await emitAvailableInfo({
+    hasInfo: allFields,
+    state
+  });
+};
+var triggerInfoEmit = async (state) => {
+  const availableInfo = getAvailableInfo({
+    state
+  });
+  await emitAvailableInfo({
+    hasInfo: availableInfo,
+    state
+  });
 };
 
 // src/emitter.ts
@@ -5708,11 +5896,35 @@ var makePauseSignal = (emitter) => {
   };
 };
 
+// src/seek-signal.ts
+var makeSeekSignal = () => {
+  let seek2;
+  return {
+    seek: (time) => {
+      if (seek2) {
+        throw new Error("Seek already requested, must wait");
+      }
+      seek2 = time;
+    },
+    getSeek() {
+      return seek2;
+    },
+    clearSeekIfStillSame(previousSeek) {
+      if (seek2 === previousSeek) {
+        seek2 = undefined;
+        return { hasChanged: false };
+      }
+      return { hasChanged: true };
+    }
+  };
+};
+
 // src/media-parser-controller.ts
 var mediaParserController = () => {
   const abortController = new AbortController;
   const emitter = new MediaParserEmitter;
   const pauseSignal = makePauseSignal(emitter);
+  const seekSignal = makeSeekSignal();
   const checkForAbortAndPause = async () => {
     if (abortController.signal.aborted) {
       throw new MediaParserAbortError("Aborted");
@@ -5724,73 +5936,53 @@ var mediaParserController = () => {
       abortController.abort(reason);
       emitter.dispatchAbort(reason);
     },
+    _experimentalSeek: seekSignal.seek,
     pause: pauseSignal.pause,
     resume: pauseSignal.resume,
     addEventListener: emitter.addEventListener,
     removeEventListener: emitter.removeEventListener,
     _internals: {
       signal: abortController.signal,
-      checkForAbortAndPause
+      checkForAbortAndPause,
+      seekSignal
     }
   };
 };
 
-// src/perform-seek.ts
-var performSeek = async ({
-  seekTo,
-  state,
-  currentReader,
-  readerInterface,
-  src
-}) => {
-  const { iterator, logLevel, controller, mode, contentLength } = state;
-  if (seekTo <= iterator.counter.getOffset()) {
-    throw new Error(`Seeking backwards is not supported. Current position: ${iterator.counter.getOffset()}, seekTo: ${seekTo}`);
-  }
-  if (seekTo > state.contentLength) {
-    throw new Error(`Unexpected seek: ${seekTo} > ${contentLength}`);
+// src/check-if-done.ts
+var checkIfDone = async (state) => {
+  const startCheck = Date.now();
+  const hasAll = hasAllInfo({
+    state
+  });
+  state.timings.timeCheckingIfDone += Date.now() - startCheck;
+  if (hasAll && state.mode === "query") {
+    Log.verbose(state.logLevel, "Got all info, skipping to the end.");
+    state.increaseSkippedBytes(state.contentLength - state.iterator.counter.getOffset());
+    return true;
   }
-  if (iterator.counter.getOffset() + iterator.bytesRemaining() >= seekTo) {
-    Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${seekTo}. Data already fetched`);
-    iterator.discard(seekTo - iterator.counter.getOffset());
-    return currentReader;
+  if (state.iterator.counter.getOffset() === state.contentLength) {
+    if (state.getStructure().type === "m3u" && !state.m3u.getAllChunksProcessedOverall()) {
+      return false;
+    }
+    Log.verbose(state.logLevel, "Reached end of file");
+    await state.discardReadBytes(true);
+    return true;
   }
-  if (mode === "download") {
-    Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${seekTo}. Fetching but not reading all the data inbetween because in download mode`);
-    iterator.discard(seekTo - iterator.counter.getOffset());
-    return currentReader;
+  if (state.iterator.counter.getOffset() + state.iterator.bytesRemaining() === state.contentLength && state.errored) {
+    Log.verbose(state.logLevel, "Reached end of file and errorred");
+    return true;
   }
-  const time = Date.now();
-  Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${seekTo}. Re-reading because this portion is not available`);
-  currentReader.abort();
-  await controller?._internals.checkForAbortAndPause();
-  const { reader: newReader } = await readerInterface.read({
-    src,
-    range: seekTo,
-    controller
-  });
-  iterator.skipTo(seekTo);
-  await state.discardReadBytes(true);
-  Log.verbose(logLevel, `Re-reading took ${Date.now() - time}ms. New position: ${iterator.counter.getOffset()}`);
-  return newReader;
+  return false;
 };
 
-// src/remotion-license-acknowledge.ts
-var warningShown = false;
-var warnIfRemotionLicenseNotAcknowledged = ({
-  acknowledgeRemotionLicense,
-  logLevel,
-  apiName
-}) => {
-  if (acknowledgeRemotionLicense) {
-    return;
-  }
-  if (warningShown) {
-    return;
-  }
-  warningShown = true;
-  Log.warn(logLevel, "Note: Some companies are required to obtain a license to use @remotion/media-parser. See: https://remotion.dev/license");
-  Log.warn(logLevel, `Pass \`acknowledgeRemotionLicense: true\` to \`${apiName}\` function to make this message disappear.`);
+// src/make-progress-object.ts
+var makeProgressObject = (state) => {
+  return {
+    bytes: state.iterator.counter.getOffset(),
+    percentage: state.contentLength ? state.iterator.counter.getOffset() / state.contentLength : null,
+    totalBytes: state.contentLength
+  };
 };
 
 // src/convert-audio-or-video-sample.ts
@@ -5809,6 +6001,24 @@ var convertAudioOrVideoSampleToWebCodecsTimestamps = (sample, timescale) => {
   };
 };
 
+// src/emit-audio-sample.ts
+var emitAudioSample = async ({
+  trackId,
+  audioSample,
+  state
+}) => {
+  await state.callbacks.onAudioSample(trackId, audioSample);
+  await workOnSeekRequest(state);
+};
+var emitVideoSample = async ({
+  trackId,
+  videoSample,
+  state
+}) => {
+  await state.callbacks.onVideoSample(trackId, videoSample);
+  await workOnSeekRequest(state);
+};
+
 // src/register-track.ts
 var registerVideoTrack = async ({
   state,
@@ -5828,6 +6038,7 @@ var registerVideoTrack = async ({
   }
   const callback = await state.onVideoTrack({ track, container });
   await state.callbacks.registerVideoSampleCallback(track.trackId, callback ?? null);
+  await workOnSeekRequest(state);
   return callback;
 };
 var registerAudioTrack = async ({
@@ -5848,6 +6059,7 @@ var registerAudioTrack = async ({
   }
   const callback = await state.onAudioTrack({ track, container });
   await state.callbacks.registerAudioSampleCallback(track.trackId, callback ?? null);
+  await workOnSeekRequest(state);
   return callback;
 };
 var registerVideoTrackWhenProfileIsAvailable = ({
@@ -5928,17 +6140,21 @@ var parseAac = async (state) => {
   const duration2 = 1024 / sampleRate;
   const { index } = state.aac.addSample({ offset: startOffset, size: frameLength });
   const timestamp = 1024 / sampleRate * index;
-  await state.callbacks.onAudioSample(0, convertAudioOrVideoSampleToWebCodecsTimestamps({
-    duration: duration2,
-    type: "key",
-    data,
-    offset: startOffset,
-    timescale: 1e6,
+  await emitAudioSample({
     trackId: 0,
-    cts: timestamp,
-    dts: timestamp,
-    timestamp
-  }, 1));
+    audioSample: convertAudioOrVideoSampleToWebCodecsTimestamps({
+      duration: duration2,
+      type: "key",
+      data,
+      offset: startOffset,
+      timescale: 1e6,
+      trackId: 0,
+      cts: timestamp,
+      dts: timestamp,
+      timestamp
+    }, 1),
+    state
+  });
   return Promise.resolve(null);
 };
 
@@ -6128,17 +6344,21 @@ var emitSample = async ({
     throw new Error("Cannot determine timestamp");
   }
   const timestamp = num * streamInfo.maximumBlockSize / streamInfo.sampleRate;
-  await state.callbacks.onAudioSample(0, convertAudioOrVideoSampleToWebCodecsTimestamps({
-    data,
-    duration: duration2,
-    cts: timestamp,
-    dts: timestamp,
-    timestamp,
-    type: "key",
-    offset,
-    timescale: 1e6,
-    trackId: 0
-  }, 1));
+  await emitAudioSample({
+    trackId: 0,
+    audioSample: convertAudioOrVideoSampleToWebCodecsTimestamps({
+      data,
+      duration: duration2,
+      cts: timestamp,
+      dts: timestamp,
+      timestamp,
+      type: "key",
+      offset,
+      timescale: 1e6,
+      trackId: 0
+    }, 1),
+    state
+  });
   iterator.destroy();
 };
 var parseFlacFrame = async ({
@@ -6398,6 +6618,45 @@ var cachedSamplePositionsState = () => {
   };
 };
 
+// src/get-fields-from-callbacks.ts
+var getFieldsFromCallback = ({
+  fields,
+  callbacks
+}) => {
+  const newFields = {
+    audioCodec: Boolean(callbacks.onAudioCodec),
+    container: Boolean(callbacks.onContainer),
+    dimensions: Boolean(callbacks.onDimensions),
+    durationInSeconds: Boolean(callbacks.onDurationInSeconds),
+    fps: Boolean(callbacks.onFps),
+    internalStats: Boolean(callbacks.onInternalStats),
+    isHdr: Boolean(callbacks.onIsHdr),
+    location: Boolean(callbacks.onLocation),
+    metadata: Boolean(callbacks.onMetadata),
+    mimeType: Boolean(callbacks.onMimeType),
+    name: Boolean(callbacks.onName),
+    rotation: Boolean(callbacks.onRotation),
+    size: Boolean(callbacks.onSize),
+    structure: Boolean(callbacks.onStructure),
+    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),
+    images: Boolean(callbacks.onImages),
+    numberOfAudioChannels: Boolean(callbacks.onNumberOfAudioChannels),
+    sampleRate: Boolean(callbacks.onSampleRate),
+    slowAudioBitrate: Boolean(callbacks.onSlowAudioBitrate),
+    slowVideoBitrate: Boolean(callbacks.onSlowVideoBitrate),
+    m3uStreams: Boolean(callbacks.onM3uStreams),
+    ...fields
+  };
+  return newFields;
+};
+
 // src/state/aac-state.ts
 var aacState = () => {
   const samples = [];
@@ -6747,7 +7006,7 @@ var needsTracksForField = ({
   structure
 }) => {
   if (field === "dimensions") {
-    if (structure.type === "riff") {
+    if (structure?.type === "riff") {
       return false;
     }
     return true;
@@ -6773,7 +7032,10 @@ var makeCanSkipTracksState = ({
       }
       const keys = Object.keys(fields ?? {});
       const selectedKeys = keys.filter((k) => fields[k]);
-      return !selectedKeys.some((k) => needsTracksForField({ field: k, structure: structure.getStructure() }));
+      return !selectedKeys.some((k) => needsTracksForField({
+        field: k,
+        structure: structure.getStructureOrNull()
+      }));
     }
   };
 };
@@ -6820,7 +7082,9 @@ var sampleCallback = ({
   emittedFields,
   slowDurationAndFpsState,
   structure,
-  src
+  src,
+  seekSignal,
+  logLevel
 }) => {
   const videoSampleCallbacks = {};
   const audioSampleCallbacks = {};
@@ -6857,7 +7121,11 @@ var sampleCallback = ({
       if (audioSample.data.length > 0) {
         samplesForTrack[trackId]++;
         if (callback) {
-          await callback(audioSample);
+          if (seekSignal.getSeek()) {
+            Log.verbose(logLevel, "Not emitting sample because seek is processing");
+          } else {
+            await callback(audioSample);
+          }
         }
       }
       if (needsToIterateOverSamples({ emittedFields, fields })) {
@@ -6878,7 +7146,11 @@ var sampleCallback = ({
         samplesForTrack[trackId]++;
         const callback = videoSampleCallbacks[trackId];
         if (callback) {
-          await callback(videoSample);
+          if (seekSignal.getSeek()) {
+            Log.verbose(logLevel, "Not emitting sample because seek is processing");
+          } else {
+            await callback(videoSample);
+          }
         }
       }
       if (needsToIterateOverSamples({
@@ -7074,6 +7346,17 @@ var structureState = () => {
   };
 };
 
+// src/state/timings.ts
+var timingsState = () => {
+  return {
+    timeIterating: 0,
+    timeReadingData: 0,
+    timeSeeking: 0,
+    timeCheckingIfDone: 0,
+    timeFreeingData: 0
+  };
+};
+
 // src/containers/transport-stream/next-pes-header-store.ts
 var makeNextPesHeaderStore = () => {
   let nextPesHeader = null;
@@ -7231,7 +7514,6 @@ var makeParserState = ({
   hasAudioTrackHandlers,
   hasVideoTrackHandlers,
   controller,
-  fields,
   onAudioTrack,
   onVideoTrack,
   contentLength,
@@ -7242,9 +7524,16 @@ var makeParserState = ({
   onDiscardedData,
   selectM3uStreamFn,
   selectM3uAssociatedPlaylistsFn,
-  mp4HeaderSegment
+  mp4HeaderSegment,
+  contentType,
+  name,
+  callbacks,
+  fieldsInReturnValue,
+  mimeType,
+  initialReaderInstance
 }) => {
   let skippedBytes = 0;
+  const returnValue = {};
   const iterator = getArrayBufferIterator(new Uint8Array([]), contentLength);
   const increaseSkippedBytes = (bytes) => {
     skippedBytes += bytes;
@@ -7255,6 +7544,8 @@ var makeParserState = ({
   const slowDurationAndFps = slowDurationAndFpsState();
   const mp3Info = makeMp3State();
   const images = imagesState();
+  const timings = timingsState();
+  const errored = null;
   const discardReadBytes = async (force) => {
     const { bytesRemoved, removedData } = iterator.removeBytesRead(force, mode);
     if (bytesRemoved) {
@@ -7264,6 +7555,10 @@ var makeParserState = ({
       await onDiscardedData(removedData);
     }
   };
+  const fields = getFieldsFromCallback({
+    fields: fieldsInReturnValue,
+    callbacks
+  });
   return {
     riff: riffSpecificState(),
     transportStream: transportStreamState(),
@@ -7273,6 +7568,7 @@ var makeParserState = ({
     aac: aacState(),
     flac: flacState(),
     m3u: m3uState(logLevel),
+    timings,
     callbacks: sampleCallback({
       controller,
       hasAudioTrackHandlers,
@@ -7282,7 +7578,9 @@ var makeParserState = ({
       emittedFields,
       slowDurationAndFpsState: slowDurationAndFps,
       structure,
-      src
+      src,
+      seekSignal: controller._internals.seekSignal,
+      logLevel
     }),
     getInternalStats: () => ({
       skippedBytes,
@@ -7309,7 +7607,15 @@ var makeParserState = ({
     discardReadBytes,
     selectM3uStreamFn,
     selectM3uAssociatedPlaylistsFn,
-    mp4HeaderSegment
+    mp4HeaderSegment,
+    contentType,
+    name,
+    returnValue,
+    callbackFunctions: callbacks,
+    fieldsInReturnValue,
+    mimeType,
+    errored,
+    currentReader: initialReaderInstance
   };
 };
 
@@ -8965,9 +9271,6 @@ var getMoovAtom = async ({
     hasAudioTrackHandlers: false,
     hasVideoTrackHandlers: false,
     controller: state.controller,
-    fields: {
-      structure: true
-    },
     onAudioTrack: state.onAudioTrack ? async ({ track, container }) => {
       await registerAudioTrack({ state, track, container });
       return null;
@@ -8984,7 +9287,15 @@ var getMoovAtom = async ({
     onDiscardedData: null,
     selectM3uStreamFn: state.selectM3uStreamFn,
     selectM3uAssociatedPlaylistsFn: state.selectM3uAssociatedPlaylistsFn,
-    mp4HeaderSegment: state.mp4HeaderSegment
+    mp4HeaderSegment: state.mp4HeaderSegment,
+    callbacks: {},
+    fieldsInReturnValue: {
+      structure: true
+    },
+    contentType: null,
+    mimeType: null,
+    name: "",
+    initialReaderInstance: reader
   });
   while (true) {
     const result = await reader.reader.read();
@@ -9056,17 +9367,21 @@ var parseMdatSection = async (state) => {
   const bytes = iterator.getSlice(samplesWithIndex.samplePosition.size);
   const { cts, dts, duration: duration2, isKeyframe, offset } = samplesWithIndex.samplePosition;
   if (samplesWithIndex.track.type === "audio") {
-    await state.callbacks.onAudioSample(samplesWithIndex.track.trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
-      data: bytes,
-      timestamp: cts,
-      duration: duration2,
-      cts,
-      dts,
+    await emitAudioSample({
       trackId: samplesWithIndex.track.trackId,
-      type: isKeyframe ? "key" : "delta",
-      offset,
-      timescale: samplesWithIndex.track.timescale
-    }, samplesWithIndex.track.timescale));
+      audioSample: convertAudioOrVideoSampleToWebCodecsTimestamps({
+        data: bytes,
+        timestamp: cts,
+        duration: duration2,
+        cts,
+        dts,
+        trackId: samplesWithIndex.track.trackId,
+        type: isKeyframe ? "key" : "delta",
+        offset,
+        timescale: samplesWithIndex.track.timescale
+      }, samplesWithIndex.track.timescale),
+      state
+    });
   }
   if (samplesWithIndex.track.type === "video") {
     const nalUnitType = bytes[4] & 31;
@@ -9075,17 +9390,21 @@ var parseMdatSection = async (state) => {
       const seiType = bytes[5];
       isRecoveryPoint = seiType === 6;
     }
-    await state.callbacks.onVideoSample(samplesWithIndex.track.trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
-      data: bytes,
-      timestamp: cts,
-      duration: duration2,
-      cts,
-      dts,
+    await emitVideoSample({
       trackId: samplesWithIndex.track.trackId,
-      type: isKeyframe && !isRecoveryPoint ? "key" : "delta",
-      offset,
-      timescale: samplesWithIndex.track.timescale
-    }, samplesWithIndex.track.timescale));
+      videoSample: convertAudioOrVideoSampleToWebCodecsTimestamps({
+        data: bytes,
+        timestamp: cts,
+        duration: duration2,
+        cts,
+        dts,
+        trackId: samplesWithIndex.track.trackId,
+        type: isKeyframe && !isRecoveryPoint ? "key" : "delta",
+        offset,
+        timescale: samplesWithIndex.track.timescale
+      }, samplesWithIndex.track.timescale),
+      state
+    });
   }
   return null;
 };
@@ -10123,16 +10442,20 @@ var parseMpegHeader = async ({
     const timeInSeconds = nthFrame * samplesPerFrame / sampleRate;
     const timestamp = Math.round(timeInSeconds * 1e6);
     const duration2 = Math.round(durationInSeconds * 1e6);
-    await state.callbacks.onAudioSample(0, {
-      data,
-      cts: timestamp,
-      dts: timestamp,
-      duration: duration2,
-      offset: initialOffset,
-      timescale: 1e6,
-      timestamp,
+    await emitAudioSample({
       trackId: 0,
-      type: "key"
+      audioSample: {
+        data,
+        cts: timestamp,
+        dts: timestamp,
+        duration: duration2,
+        offset: initialOffset,
+        timescale: 1e6,
+        timestamp,
+        trackId: 0,
+        type: "key"
+      },
+      state
     });
   }
 };
@@ -10737,17 +11060,21 @@ var handleChunk = async ({
       await state.riff.onProfile({ pps: ppsProfile, sps: avcProfile });
       state.callbacks.tracks.setIsDone(state.logLevel);
     }
-    await state.callbacks.onVideoSample(trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
-      cts: timestamp,
-      dts: timestamp,
-      data,
-      duration: undefined,
-      timestamp,
+    await emitVideoSample({
       trackId,
-      type: keyOrDelta,
-      offset,
-      timescale: samplesPerSecond
-    }, 1));
+      videoSample: convertAudioOrVideoSampleToWebCodecsTimestamps({
+        cts: timestamp,
+        dts: timestamp,
+        data,
+        duration: undefined,
+        timestamp,
+        trackId,
+        type: keyOrDelta,
+        offset,
+        timescale: samplesPerSecond
+      }, 1),
+      state
+    });
     return;
   }
   const audioChunk = ckId.match(/^([0-9]{2})wb$/);
@@ -10759,17 +11086,21 @@ var handleChunk = async ({
     const timeInSec = nthSample / samplesPerSecond;
     const timestamp = timeInSec;
     const data = iterator.getSlice(ckSize);
-    await state.callbacks.onAudioSample(trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
-      cts: timestamp,
-      dts: timestamp,
-      data,
-      duration: undefined,
-      timestamp,
+    await emitAudioSample({
       trackId,
-      type: "key",
-      offset,
-      timescale: samplesPerSecond
-    }, 1));
+      audioSample: convertAudioOrVideoSampleToWebCodecsTimestamps({
+        cts: timestamp,
+        dts: timestamp,
+        data,
+        duration: undefined,
+        timestamp,
+        trackId,
+        type: "key",
+        offset,
+        timescale: samplesPerSecond
+      }, 1),
+      state
+    });
   }
 };
 var parseMovi = async ({
@@ -11231,7 +11562,11 @@ var handleAvcPacket = async ({
     offset,
     timescale: MPEG_TIMESCALE
   };
-  await state.callbacks.onVideoSample(programId, convertAudioOrVideoSampleToWebCodecsTimestamps(sample, MPEG_TIMESCALE));
+  await emitVideoSample({
+    trackId: programId,
+    videoSample: convertAudioOrVideoSampleToWebCodecsTimestamps(sample, MPEG_TIMESCALE),
+    state
+  });
 };
 
 // src/containers/transport-stream/handle-aac-packet.ts
@@ -11279,7 +11614,11 @@ var handleAacPacket = async ({
     offset,
     timescale: MPEG_TIMESCALE
   };
-  await state.callbacks.onAudioSample(programId, convertAudioOrVideoSampleToWebCodecsTimestamps(sample, MPEG_TIMESCALE));
+  await emitAudioSample({
+    trackId: programId,
+    audioSample: convertAudioOrVideoSampleToWebCodecsTimestamps(sample, MPEG_TIMESCALE),
+    state
+  });
 };
 
 // src/containers/transport-stream/process-stream-buffers.ts
@@ -11718,17 +12057,21 @@ var parseVideoSection2 = async ({
   const duration2 = toRead / (fmtBox.sampleRate * fmtBox.blockAlign);
   const timestamp = (offset - videoSection.start) / (fmtBox.sampleRate * fmtBox.blockAlign);
   const data = iterator.getSlice(toRead);
-  await state.callbacks.onAudioSample(0, convertAudioOrVideoSampleToWebCodecsTimestamps({
-    cts: timestamp,
-    dts: timestamp,
-    data,
-    duration: duration2,
-    timestamp,
+  await emitAudioSample({
     trackId: 0,
-    type: "key",
-    offset,
-    timescale: 1e6
-  }, 1));
+    audioSample: convertAudioOrVideoSampleToWebCodecsTimestamps({
+      cts: timestamp,
+      dts: timestamp,
+      data,
+      duration: duration2,
+      timestamp,
+      trackId: 0,
+      type: "key",
+      offset,
+      timescale: 1e6
+    }, 1),
+    state
+  });
   return null;
 };
 
@@ -12013,7 +12356,11 @@ var postprocessEbml = async ({
   if (ebml.type === "Block" || ebml.type === "SimpleBlock") {
     const sample = getSampleFromBlock(ebml, state, offset);
     if (sample.type === "video-sample") {
-      await state.callbacks.onVideoSample(sample.videoSample.trackId, sample.videoSample);
+      await emitVideoSample({
+        trackId: sample.videoSample.trackId,
+        videoSample: sample.videoSample,
+        state
+      });
       return {
         type: "Block",
         value: new Uint8Array([]),
@@ -12021,7 +12368,11 @@ var postprocessEbml = async ({
       };
     }
     if (sample.type === "audio-sample") {
-      await state.callbacks.onAudioSample(sample.audioSample.trackId, sample.audioSample);
+      await emitAudioSample({
+        trackId: sample.audioSample.trackId,
+        audioSample: sample.audioSample,
+        state
+      });
       return {
         type: "Block",
         value: new Uint8Array([]),
@@ -12048,7 +12399,11 @@ var postprocessEbml = async ({
         ...sample.partialVideoSample,
         type: hasReferenceBlock ? "delta" : "key"
       };
-      await state.callbacks.onVideoSample(sample.partialVideoSample.trackId, completeFrame);
+      await emitVideoSample({
+        trackId: sample.partialVideoSample.trackId,
+        videoSample: completeFrame,
+        state
+      });
     }
     return {
       type: "BlockGroup",
@@ -12180,13 +12535,9 @@ var parseWebm = async (state) => {
 };
 
 // src/init-video.ts
-var initVideo = async ({
-  state,
-  mimeType,
-  name,
-  contentLength
-}) => {
+var initVideo = async ({ state }) => {
   const fileType = state.iterator.detectFileType();
+  const { mimeType, name, contentLength } = state;
   if (fileType.type === "riff") {
     Log.verbose(state.logLevel, "Detected RIFF container");
     state.setStructure({
@@ -12329,10 +12680,7 @@ var initVideo = async ({
 
 // src/run-parse-iteration.ts
 var runParseIteration = async ({
-  state,
-  mimeType,
-  contentLength,
-  name
+  state
 }) => {
   const structure = state.getStructureOrNull();
   if (structure && structure.type === "m3u") {
@@ -12343,10 +12691,7 @@ var runParseIteration = async ({
   }
   if (structure === null) {
     await initVideo({
-      state,
-      mimeType,
-      name,
-      contentLength
+      state
     });
     return null;
   }
@@ -12377,6 +12722,116 @@ var runParseIteration = async ({
   return Promise.reject(new Error("Unknown video format " + structure));
 };
 
+// src/parse-loop.ts
+var fetchMoreData = async (state) => {
+  await state.controller._internals.checkForAbortAndPause();
+  const result = await state.currentReader.reader.read();
+  if (result.value) {
+    state.iterator.addData(result.value);
+  }
+  return result.done;
+};
+var parseLoop = async ({
+  state,
+  throttledState,
+  onError
+}) => {
+  let iterationWithThisOffset = 0;
+  while (!await checkIfDone(state)) {
+    await state.controller._internals.checkForAbortAndPause();
+    await workOnSeekRequest(state);
+    const offsetBefore = state.iterator.counter.getOffset();
+    const readStart = Date.now();
+    while (state.iterator.bytesRemaining() < 0) {
+      const done = await fetchMoreData(state);
+      if (done) {
+        break;
+      }
+    }
+    if (iterationWithThisOffset > 0 || state.iterator.bytesRemaining() <= 1e5) {
+      await fetchMoreData(state);
+    }
+    state.timings.timeReadingData += Date.now() - readStart;
+    throttledState.update?.(() => makeProgressObject(state));
+    if (!state.errored) {
+      Log.trace(state.logLevel, `Continuing parsing of file, currently at position ${state.iterator.counter.getOffset()}/${state.contentLength} (0x${state.iterator.counter.getOffset().toString(16)})`);
+      if (iterationWithThisOffset > 300 && state.getStructure().type !== "m3u") {
+        throw new Error("Infinite loop detected. The parser is not progressing. This is likely a bug in the parser. You can report this at https://remotion.dev/report and we will fix it as soon as possible.");
+      }
+      try {
+        await triggerInfoEmit(state);
+        const start = Date.now();
+        await state.controller._internals.checkForAbortAndPause();
+        const skip = await runParseIteration({
+          state
+        });
+        state.timings.timeIterating += Date.now() - start;
+        if (skip !== null) {
+          state.increaseSkippedBytes(skip.skipTo - state.iterator.counter.getOffset());
+          if (skip.skipTo === state.contentLength) {
+            Log.verbose(state.logLevel, "Skipped to end of file, not fetching.");
+            break;
+          }
+          const seekStart = Date.now();
+          await performSeek({
+            seekTo: skip.skipTo,
+            state
+          });
+          state.timings.timeSeeking += Date.now() - seekStart;
+        }
+      } catch (e) {
+        const err = await onError(e);
+        if (!err.action) {
+          throw new Error('onError was used but did not return an "action" field. See docs for this API on how to use onError.');
+        }
+        if (err.action === "fail") {
+          throw e;
+        }
+        if (err.action === "download") {
+          state.errored = e;
+          Log.verbose(state.logLevel, "Error was handled by onError and deciding to continue.");
+        }
+      }
+    }
+    const timeFreeStart = Date.now();
+    await state.discardReadBytes(false);
+    state.timings.timeFreeingData += Date.now() - timeFreeStart;
+    const didProgress = state.iterator.counter.getOffset() > offsetBefore;
+    if (!didProgress) {
+      iterationWithThisOffset++;
+    } else {
+      iterationWithThisOffset = 0;
+    }
+  }
+};
+
+// src/print-timings.ts
+var printTimings = (state) => {
+  Log.verbose(state.logLevel, `Time iterating over file: ${state.timings.timeIterating}ms`);
+  Log.verbose(state.logLevel, `Time fetching data: ${state.timings.timeReadingData}ms`);
+  Log.verbose(state.logLevel, `Time seeking: ${state.timings.timeSeeking}ms`);
+  Log.verbose(state.logLevel, `Time checking if done: ${state.timings.timeCheckingIfDone}ms`);
+  Log.verbose(state.logLevel, `Time freeing data: ${state.timings.timeFreeingData}ms`);
+};
+
+// src/remotion-license-acknowledge.ts
+var warningShown = false;
+var warnIfRemotionLicenseNotAcknowledged = ({
+  acknowledgeRemotionLicense,
+  logLevel,
+  apiName
+}) => {
+  if (acknowledgeRemotionLicense) {
+    return;
+  }
+  if (warningShown) {
+    return;
+  }
+  warningShown = true;
+  Log.warn(logLevel, "Note: Some companies are required to obtain a license to use @remotion/media-parser. See: https://remotion.dev/license");
+  Log.warn(logLevel, `Pass \`acknowledgeRemotionLicense: true\` to \`${apiName}\` function to make this message disappear.`);
+};
+
 // src/throttled-progress.ts
 var throttledStateUpdate = ({
   updateFn,
@@ -12462,11 +12917,6 @@ var internalParseMedia = async function({
     logLevel,
     apiName
   });
-  const fieldsInReturnValue = _fieldsInReturnValue ?? {};
-  const fields = getFieldsFromCallback({
-    fields: fieldsInReturnValue,
-    callbacks: more
-  });
   Log.verbose(logLevel, `Reading ${typeof src === "string" ? src : src instanceof URL ? src.toString() : src.name}`);
   const {
     reader: readerInstance,
@@ -12484,20 +12934,10 @@ var internalParseMedia = async function({
   }
   const hasAudioTrackHandlers = Boolean(onAudioTrack);
   const hasVideoTrackHandlers = Boolean(onVideoTrack);
-  if (!hasAudioTrackHandlers && !hasVideoTrackHandlers && Object.values(fields).every((v) => !v) && mode === "query") {
-    Log.warn(logLevel, new Error("Warning - No `fields` and no `on*` callbacks were passed to `parseMedia()`. Specify the data you would like to retrieve."));
-  }
-  let timeIterating = 0;
-  let timeReadingData = 0;
-  let timeSeeking = 0;
-  let timeCheckingIfDone = 0;
-  let timeFreeingData = 0;
-  let errored = null;
   const state = makeParserState({
     hasAudioTrackHandlers,
     hasVideoTrackHandlers,
     controller,
-    fields,
     onAudioTrack: onAudioTrack ?? null,
     onVideoTrack: onVideoTrack ?? null,
     contentLength,
@@ -12508,173 +12948,36 @@ var internalParseMedia = async function({
     onDiscardedData,
     selectM3uStreamFn,
     selectM3uAssociatedPlaylistsFn,
-    mp4HeaderSegment
+    mp4HeaderSegment,
+    contentType,
+    name,
+    callbacks: more,
+    fieldsInReturnValue: _fieldsInReturnValue ?? {},
+    mimeType: contentType,
+    initialReaderInstance: readerInstance
   });
-  const { iterator } = state;
-  let currentReader = readerInstance;
-  const returnValue = {};
-  const moreFields = more;
+  if (!hasAudioTrackHandlers && !hasVideoTrackHandlers && Object.values(state.fields).every((v) => !v) && mode === "query") {
+    Log.warn(logLevel, new Error("Warning - No `fields` and no `on*` callbacks were passed to `parseMedia()`. Specify the data you would like to retrieve."));
+  }
   const throttledState = throttledStateUpdate({
     updateFn: onParseProgressDoNotCallDirectly ?? null,
     everyMilliseconds: progressIntervalInMs ?? 100,
     controller,
     totalBytes: contentLength
   });
-  const triggerInfoEmit = async () => {
-    const availableInfo = getAvailableInfo({
-      fieldsToFetch: fields,
-      state
-    });
-    await emitAvailableInfo({
-      hasInfo: availableInfo,
-      callbacks: moreFields,
-      fieldsInReturnValue,
-      state,
-      returnValue,
-      name,
-      mimeType: contentType
-    });
-  };
-  const checkIfDone = async () => {
-    const startCheck = Date.now();
-    const hasAll = hasAllInfo({
-      fields,
-      state
-    });
-    timeCheckingIfDone += Date.now() - startCheck;
-    if (hasAll && mode === "query") {
-      Log.verbose(logLevel, "Got all info, skipping to the end.");
-      state.increaseSkippedBytes(contentLength - state.iterator.counter.getOffset());
-      return true;
-    }
-    if (state.iterator.counter.getOffset() === contentLength) {
-      if (state.getStructure().type === "m3u" && !state.m3u.getAllChunksProcessedOverall()) {
-        return false;
-      }
-      Log.verbose(logLevel, "Reached end of file");
-      await state.discardReadBytes(true);
-      return true;
-    }
-    if (state.iterator.counter.getOffset() + state.iterator.bytesRemaining() === contentLength && errored) {
-      Log.verbose(logLevel, "Reached end of file and errorred");
-      return true;
-    }
-    return false;
-  };
-  await triggerInfoEmit();
-  let iterationWithThisOffset = 0;
-  while (!await checkIfDone()) {
-    await controller._internals.checkForAbortAndPause();
-    const offsetBefore = iterator.counter.getOffset();
-    const fetchMoreData = async () => {
-      await controller._internals.checkForAbortAndPause();
-      const result = await currentReader.reader.read();
-      if (result.value) {
-        iterator.addData(result.value);
-      }
-      return result.done;
-    };
-    const readStart = Date.now();
-    while (iterator.bytesRemaining() < 0) {
-      const done = await fetchMoreData();
-      if (done) {
-        break;
-      }
-    }
-    const hasBigBuffer = iterator.bytesRemaining() > 1e5;
-    if (iterationWithThisOffset > 0 || !hasBigBuffer) {
-      await fetchMoreData();
-    }
-    timeReadingData += Date.now() - readStart;
-    throttledState.update?.(() => ({
-      bytes: iterator.counter.getOffset(),
-      percentage: contentLength ? iterator.counter.getOffset() / contentLength : null,
-      totalBytes: contentLength
-    }));
-    if (!errored) {
-      Log.trace(logLevel, `Continuing parsing of file, currently at position ${iterator.counter.getOffset()}/${contentLength} (0x${iterator.counter.getOffset().toString(16)})`);
-      if (iterationWithThisOffset > 300 && state.getStructure().type !== "m3u") {
-        throw new Error("Infinite loop detected. The parser is not progressing. This is likely a bug in the parser. You can report this at https://remotion.dev/report and we will fix it as soon as possible.");
-      }
-      try {
-        await triggerInfoEmit();
-        const start = Date.now();
-        await controller._internals.checkForAbortAndPause();
-        const skip = await runParseIteration({
-          state,
-          mimeType: contentType,
-          contentLength,
-          name
-        });
-        timeIterating += Date.now() - start;
-        if (skip !== null) {
-          state.increaseSkippedBytes(skip.skipTo - iterator.counter.getOffset());
-          if (skip.skipTo === contentLength) {
-            Log.verbose(logLevel, "Skipped to end of file, not fetching.");
-            break;
-          }
-          const seekStart = Date.now();
-          currentReader = await performSeek({
-            seekTo: skip.skipTo,
-            currentReader,
-            readerInterface,
-            src,
-            state
-          });
-          timeSeeking += Date.now() - seekStart;
-        }
-      } catch (e) {
-        const err = await onError(e);
-        if (!err.action) {
-          throw new Error('onError was used but did not return an "action" field. See docs for this API on how to use onError.');
-        }
-        if (err.action === "fail") {
-          throw e;
-        }
-        if (err.action === "download") {
-          errored = e;
-          Log.verbose(logLevel, "Error was handled by onError and deciding to continue.");
-        }
-      }
-      const didProgress = iterator.counter.getOffset() > offsetBefore;
-      if (!didProgress) {
-        iterationWithThisOffset++;
-      } else {
-        iterationWithThisOffset = 0;
-      }
-    }
-    const timeFreeStart = Date.now();
-    await state.discardReadBytes(false);
-    timeFreeingData += Date.now() - timeFreeStart;
-  }
+  await triggerInfoEmit(state);
+  await parseLoop({ state, throttledState, onError });
   Log.verbose(logLevel, "Finished parsing file");
-  await emitAvailableInfo({
-    hasInfo: Object.keys(fields).reduce((acc, key) => {
-      if (fields?.[key]) {
-        acc[key] = true;
-      }
-      return acc;
-    }, {}),
-    callbacks: moreFields,
-    fieldsInReturnValue,
-    state,
-    returnValue,
-    mimeType: contentType,
-    name
-  });
-  Log.verbose(logLevel, `Time iterating over file: ${timeIterating}ms`);
-  Log.verbose(logLevel, `Time fetching data: ${timeReadingData}ms`);
-  Log.verbose(logLevel, `Time seeking: ${timeSeeking}ms`);
-  Log.verbose(logLevel, `Time checking if done: ${timeCheckingIfDone}ms`);
-  Log.verbose(logLevel, `Time freeing data: ${timeFreeingData}ms`);
-  currentReader.abort();
-  iterator?.destroy();
-  state.callbacks.tracks.ensureHasTracksAtEnd(fields);
+  await emitAllInfo(state);
+  printTimings(state);
+  state.currentReader.abort();
+  state.iterator?.destroy();
+  state.callbacks.tracks.ensureHasTracksAtEnd(state.fields);
   state.m3u.abortM3UStreamRuns();
-  if (errored) {
-    throw errored;
+  if (state.errored) {
+    throw state.errored;
   }
-  return returnValue;
+  return state.returnValue;
 };
 
 // src/worker/forward-controller.ts