@remotion/media-parser 4.0.231 → 4.0.233

package/dist/esm/index.mjs

@@ -105,6 +105,27 @@ var fetchReader = {
   }
 };
 
+// src/create/event-emitter.ts
+class IoEventEmitter {
+  listeners = {
+    input: [],
+    output: [],
+    processed: [],
+    progress: []
+  };
+  addEventListener(name, callback) {
+    this.listeners[name].push(callback);
+  }
+  removeEventListener(name, callback) {
+    this.listeners[name] = this.listeners[name].filter((l) => l !== callback);
+  }
+  dispatchEvent(dispatchName, context) {
+    this.listeners[dispatchName].forEach((callback) => {
+      callback({ detail: context });
+    });
+  }
+}
+
 // src/boxes/webm/ebml.ts
 var measureEBMLVarInt = (value) => {
   if (value < (1 << 7) - 1) {
@@ -848,6 +869,15 @@ var incrementOffsetAndChildren = (offset, increment) => {
 };
 
 // src/boxes/webm/make-header.ts
+var webmPattern = new Uint8Array([26, 69, 223, 163]);
+var matroskaToHex = (matrId) => {
+  const numbers = new Uint8Array((matrId.length - 2) / 2);
+  for (let i = 2;i < matrId.length; i += 2) {
+    const hex = matrId.substring(i, i + 2);
+    numbers[(i - 2) / 2] = parseInt(hex, 16);
+  }
+  return numbers;
+};
 function putUintDynamic(number, minimumLength) {
   if (number < 0) {
     throw new Error("This function is designed for non-negative integers only.");
@@ -859,21 +889,6 @@ function putUintDynamic(number, minimumLength) {
   }
   return bytes;
 }
-function serializeUint16(value) {
-  const buffer = new ArrayBuffer(2);
-  const view = new DataView(buffer);
-  view.setUint16(0, value);
-  return new Uint8Array(buffer);
-}
-var webmPattern = new Uint8Array([26, 69, 223, 163]);
-var matroskaToHex = (matrId) => {
-  const numbers = new Uint8Array((matrId.length - 2) / 2);
-  for (let i = 2;i < matrId.length; i += 2) {
-    const hex = matrId.substring(i, i + 2);
-    numbers[(i - 2) / 2] = parseInt(hex, 16);
-  }
-  return numbers;
-};
 var makeFromStructure = (fields) => {
   if ("bytes" in fields) {
     return fields;
@@ -1020,6 +1035,12 @@ var combineUint8Arrays = (arrays) => {
   }
   return result;
 };
+function serializeUint16(value) {
+  const buffer = new ArrayBuffer(2);
+  const view = new DataView(buffer);
+  view.setUint16(0, value);
+  return new Uint8Array(buffer);
+}
 
 // src/log.ts
 var logLevels = ["trace", "verbose", "info", "warn", "error"];
@@ -1855,7 +1876,7 @@ var createHdlr = (type) => {
     type === "mdir" ? numberTo32BitUIntOrInt(1634758764) : new Uint8Array([0, 0, 0, 0]),
     new Uint8Array([0, 0, 0, 0]),
     new Uint8Array([0, 0, 0, 0]),
-    stringsToUint8Array(type === "mdir" ? "\0" : type === "video" ? "VideoHandler\0" : "SoundHandler\0")
+    stringsToUint8Array(type === "mdir" ? "\x00" : type === "video" ? "VideoHandler\x00" : "SoundHandler\x00")
   ]));
 };
 
@@ -1966,7 +1987,8 @@ var createIsoBaseMedia = async ({
   onBytesProgress,
   onMillisecondsProgress,
   logLevel,
-  filename
+  filename,
+  progressTracker
 }) => {
   const header = createIsoBaseMediaFtyp({
     compatibleBrands: ["isom", "iso2", "avc1", "mp42"],
@@ -2036,6 +2058,7 @@ var createIsoBaseMedia = async ({
     await w.write(chunk.data);
     mdatSize += chunk.data.length;
     onBytesProgress(w.getWrittenByteCount());
+    progressTracker.updateTrackProgress(trackNumber2, chunk.timestamp);
     if (codecPrivate2) {
       addCodecPrivateToTrack({ trackNumber: trackNumber2, codecPrivate: codecPrivate2 });
     }
@@ -2069,6 +2092,7 @@ var createIsoBaseMedia = async ({
   const addTrack = (track) => {
     const trackNumber2 = currentTracks.length + 1;
     currentTracks.push({ ...track, trackNumber: trackNumber2 });
+    progressTracker.registerTrack(trackNumber2);
     return Promise.resolve({ trackNumber: trackNumber2 });
   };
   const waitForFinishPromises = [];
@@ -2117,10 +2141,6 @@ var createIsoBaseMedia = async ({
       await updateMdatSize();
       Log.verbose(logLevel, "All write operations done. Waiting for finish...");
       await w.waitForFinish();
-    },
-    updateDuration: (duration2) => {
-      operationProm.current = operationProm.current.then(() => updateDuration(duration2));
-      return operationProm.current;
     }
   };
 };
@@ -2178,7 +2198,7 @@ var canFitInCluster = ({
 }) => {
   const timecodeRelativeToCluster = timestampToClusterTimestamp(chunk.timestamp, timescale) - timestampToClusterTimestamp(clusterStartTimestamp, timescale);
   if (timecodeRelativeToCluster < 0) {
-    throw new Error(`timecodeRelativeToCluster is negative`);
+    throw new Error(`timecodeRelativeToCluster is negative, tried to add ${chunk.timestamp} to ${clusterStartTimestamp}`);
   }
   return timecodeRelativeToCluster <= maxClusterTimestamp;
 };
@@ -2947,7 +2967,8 @@ var createMatroskaMedia = async ({
   onBytesProgress,
   onMillisecondsProgress,
   filename,
-  logLevel
+  logLevel,
+  progressTracker
 }) => {
   const header = makeMatroskaHeader();
   const w = await writer.createContent({ filename, mimeType: "video/webm" });
@@ -3012,17 +3033,11 @@ var createMatroskaMedia = async ({
     hexString: matroskaElements.Cluster,
     byte: clusterOffset - seekHeadOffset
   });
-  const trackNumberProgresses = {};
   const getClusterOrMakeNew = async ({
     chunk,
-    isVideo,
-    trackNumber: trackNumber2
+    isVideo
   }) => {
-    const trackProgressValues = Object.values(trackNumberProgresses);
-    const smallestProgress = trackProgressValues.length === 0 ? 0 : Math.min(...trackProgressValues);
-    if (chunk.type === "key") {
-      trackNumberProgresses[trackNumber2] = chunk.timestamp;
-    }
+    const smallestProgress = progressTracker.getSmallestProgress();
     if (!currentCluster.shouldMakeNewCluster({
       newT: smallestProgress,
       isVideo,
@@ -3050,8 +3065,7 @@ var createMatroskaMedia = async ({
   }) => {
     const { cluster, isNew, smallestProgress } = await getClusterOrMakeNew({
       chunk,
-      isVideo,
-      trackNumber: trackNumber2
+      isVideo
     });
     const newDuration = Math.round((chunk.timestamp + (chunk.duration ?? 0)) / 1000);
     await updateDuration(newDuration);
@@ -3064,12 +3078,16 @@ var createMatroskaMedia = async ({
         trackNumber: trackNumber2
       });
     }
+    if (chunk.type === "key") {
+      progressTracker.updateTrackProgress(trackNumber2, chunk.timestamp);
+    }
     onBytesProgress(w.getWrittenByteCount());
     onMillisecondsProgress(newDuration);
   };
   const addTrack = async (track) => {
     currentTracks.push(track);
     const newTracks = makeMatroskaTracks(currentTracks);
+    progressTracker.registerTrack(track.trackNumber);
     await w.updateDataAt(tracksOffset, combineUint8Arrays(newTracks.map((b) => b.bytes)));
   };
   const operationProm = { current: Promise.resolve() };
@@ -3095,10 +3113,6 @@ var createMatroskaMedia = async ({
       operationProm.current = operationProm.current.then(() => addSample({ chunk, trackNumber: trackNumber2, isVideo }));
       return operationProm.current;
     },
-    updateDuration: (duration2) => {
-      operationProm.current = operationProm.current.then(() => updateDuration(duration2));
-      return operationProm.current;
-    },
     addTrack: (track) => {
       const trackNumber2 = currentTracks.length + 1;
       operationProm.current = operationProm.current.then(() => addTrack({ ...track, trackNumber: trackNumber2 }));
@@ -3124,6 +3138,186 @@ var createMatroskaMedia = async ({
   };
 };
 
+// src/create/with-resolvers.ts
+var withResolvers = function() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+};
+var withResolversAndWaitForReturn = () => {
+  const { promise, reject, resolve } = withResolvers();
+  const { promise: returnPromise, resolve: resolveReturn } = withResolvers();
+  return {
+    getPromiseToImmediatelyReturn: () => {
+      resolveReturn(undefined);
+      return promise;
+    },
+    reject: (reason) => {
+      returnPromise.then(() => reject(reason));
+    },
+    resolve
+  };
+};
+
+// src/create/progress-tracker.ts
+var makeProgressTracker = () => {
+  const trackNumberProgresses = {};
+  const eventEmitter = new IoEventEmitter;
+  const calculateSmallestProgress = () => {
+    const progressValues = Object.values(trackNumberProgresses);
+    if (progressValues.length === 0) {
+      return 0;
+    }
+    return Math.min(...progressValues);
+  };
+  return {
+    registerTrack: (trackNumber2) => {
+      trackNumberProgresses[trackNumber2] = 0;
+    },
+    getSmallestProgress: () => {
+      return calculateSmallestProgress();
+    },
+    updateTrackProgress: (trackNumber2, progress) => {
+      if (trackNumberProgresses[trackNumber2] === undefined) {
+        throw new Error(`Tried to update progress for a track that was not registered: ${trackNumber2}`);
+      }
+      trackNumberProgresses[trackNumber2] = progress;
+      eventEmitter.dispatchEvent("progress", {
+        smallestProgress: calculateSmallestProgress()
+      });
+    },
+    waitForProgress: () => {
+      const { promise, resolve } = withResolvers();
+      const on = () => {
+        eventEmitter.removeEventListener("processed", on);
+        resolve();
+      };
+      eventEmitter.addEventListener("processed", on);
+      return promise;
+    }
+  };
+};
+
+// src/create/wav/create-wav.ts
+var numberTo32BiIntLittleEndian = (num) => {
+  return new Uint8Array([
+    num & 255,
+    num >> 8 & 255,
+    num >> 16 & 255,
+    num >> 24 & 255
+  ]);
+};
+var numberTo16BitLittleEndian = (num) => {
+  return new Uint8Array([num & 255, num >> 8 & 255]);
+};
+var BIT_DEPTH = 16;
+var BYTES_PER_SAMPLE = BIT_DEPTH / 8;
+var createWav = async ({
+  filename,
+  logLevel,
+  onBytesProgress,
+  onMillisecondsProgress,
+  writer,
+  progressTracker
+}) => {
+  const w = await writer.createContent({ filename, mimeType: "audio/wav" });
+  await w.write(new Uint8Array([82, 73, 70, 70]));
+  const sizePosition = w.getWrittenByteCount();
+  await w.write(new Uint8Array([0, 0, 0, 0]));
+  await w.write(new Uint8Array([87, 65, 86, 69]));
+  await w.write(new Uint8Array([102, 109, 116, 32]));
+  await w.write(new Uint8Array([16, 0, 0, 0]));
+  await w.write(new Uint8Array([1, 0]));
+  const channelNumPosition = w.getWrittenByteCount();
+  await w.write(new Uint8Array([1, 0]));
+  const sampleRatePosition = w.getWrittenByteCount();
+  await w.write(new Uint8Array([0, 0, 0, 0]));
+  const byteRatePosition = w.getWrittenByteCount();
+  await w.write(new Uint8Array([0, 0, 0, 0]));
+  const blockAlignPosition = w.getWrittenByteCount();
+  await w.write(new Uint8Array([0, 0]));
+  await w.write(numberTo16BitLittleEndian(BIT_DEPTH));
+  await w.write(new Uint8Array([100, 97, 116, 97]));
+  const dataSizePosition = w.getWrittenByteCount();
+  await w.write(new Uint8Array([0, 0, 0, 0]));
+  const operationProm = { current: Promise.resolve() };
+  const updateSize = async () => {
+    const size = w.getWrittenByteCount() - sizePosition - 4;
+    await w.updateDataAt(sizePosition, numberTo32BiIntLittleEndian(size));
+    const dataSize = w.getWrittenByteCount() - dataSizePosition - 4;
+    await w.updateDataAt(dataSizePosition, numberTo32BiIntLittleEndian(dataSize));
+  };
+  const updateChannelNum = async (numberOfChannels) => {
+    await w.updateDataAt(channelNumPosition, new Uint8Array([numberOfChannels, 0]));
+  };
+  const updateSampleRate = async (sampleRate) => {
+    await w.updateDataAt(sampleRatePosition, numberTo32BiIntLittleEndian(sampleRate));
+  };
+  const updateByteRate = async ({
+    sampleRate,
+    numberOfChannels
+  }) => {
+    await w.updateDataAt(byteRatePosition, numberTo32BiIntLittleEndian(sampleRate * numberOfChannels + BYTES_PER_SAMPLE));
+  };
+  const updateBlockAlign = async (numberOfChannels) => {
+    await w.updateDataAt(blockAlignPosition, new Uint8Array(numberTo16BitLittleEndian(numberOfChannels * BYTES_PER_SAMPLE)));
+  };
+  const addSample = async (chunk) => {
+    Log.verbose(logLevel, "Adding sample", chunk);
+    await w.write(chunk.data);
+    onMillisecondsProgress((chunk.timestamp + (chunk.duration ?? 0)) / 1000);
+    onBytesProgress(w.getWrittenByteCount());
+  };
+  const waitForFinishPromises = [];
+  return {
+    save: () => {
+      return w.save();
+    },
+    remove: () => {
+      return w.remove();
+    },
+    addSample: ({ chunk, trackNumber: trackNumber2 }) => {
+      if (trackNumber2 !== 1) {
+        throw new Error("Only one track supported for WAV");
+      }
+      operationProm.current = operationProm.current.then(() => addSample(chunk));
+      progressTracker.updateTrackProgress(trackNumber2, chunk.timestamp);
+      return operationProm.current;
+    },
+    updateTrackSampleRate: () => {
+      throw new Error("updateTrackSampleRate() not implemented for WAV encoder");
+    },
+    addWaitForFinishPromise: (promise) => {
+      waitForFinishPromises.push(promise);
+    },
+    async waitForFinish() {
+      Log.verbose(logLevel, "All write operations queued. Waiting for finish...");
+      await Promise.all(waitForFinishPromises.map((p) => p()));
+      await operationProm.current;
+      await updateSize();
+      await w.waitForFinish();
+    },
+    addTrack: async (track) => {
+      if (track.type !== "audio") {
+        throw new Error("Only audio tracks supported for WAV");
+      }
+      await updateChannelNum(track.numberOfChannels);
+      await updateSampleRate(track.sampleRate);
+      await updateByteRate({
+        sampleRate: track.sampleRate,
+        numberOfChannels: track.numberOfChannels
+      });
+      await updateBlockAlign(track.numberOfChannels);
+      progressTracker.registerTrack(1);
+      return Promise.resolve({ trackNumber: 1 });
+    }
+  };
+};
+
 // src/boxes/iso-base-media/traversal.ts
 var getMoovBox = (segments) => {
   const moovBox = segments.find((s) => s.type === "moov-box");
@@ -3289,317 +3483,133 @@ var getMdatBox = (anySegment) => {
   return mdat;
 };
 
-// src/get-sample-positions.ts
-var getSamplePositions = ({
-  stcoBox,
-  stszBox,
-  stscBox,
-  stssBox,
+// src/boxes/riff/traversal.ts
+var isRiffAvi = (structure) => {
+  return structure.boxes.some((box) => box.type === "riff-header" && box.fileType === "AVI");
+};
+var getHdlrBox = (structure) => {
+  return structure.boxes.find((box) => box.type === "list-box" && box.listType === "hdrl");
+};
+var getAvihBox = (structure) => {
+  const hdlrBox = getHdlrBox(structure);
+  if (!hdlrBox) {
+    return null;
+  }
+  return hdlrBox.children.find((box) => box.type === "avih-box");
+};
+var getStrlBoxes = (structure) => {
+  const hdlrBox = getHdlrBox(structure);
+  if (!hdlrBox) {
+    return [];
+  }
+  return hdlrBox.children.filter((box) => box.type === "list-box" && box.listType === "strl");
+};
+var getStrhBox = (strlBoxChildren) => {
+  return strlBoxChildren.find((box) => box.type === "strh-box");
+};
+var getStrfBox = (strlBoxChildren) => {
+  return strlBoxChildren.find((box) => box.type === "strf-box-audio" || box.type === "strf-box-video") ?? null;
+};
+
+// src/get-fps.ts
+var calculateFps = ({
   sttsBox,
-  cttsBox
+  timeScale,
+  durationInSamples
 }) => {
-  const sttsDeltas = [];
-  for (const distribution of sttsBox.sampleDistribution) {
-    for (let i = 0;i < distribution.sampleCount; i++) {
-      sttsDeltas.push(distribution.sampleDelta);
-    }
+  let totalSamples = 0;
+  for (const sample of sttsBox.sampleDistribution) {
+    totalSamples += sample.sampleCount;
   }
-  const cttsEntries = [];
-  for (const entry of cttsBox?.entries ?? [
-    { sampleCount: sttsDeltas.length, sampleOffset: 0 }
-  ]) {
-    for (let i = 0;i < entry.sampleCount; i++) {
-      cttsEntries.push(entry.sampleOffset);
-    }
+  const durationInSeconds = durationInSamples / timeScale;
+  const fps = totalSamples / durationInSeconds;
+  return fps;
+};
+var trakBoxContainsAudio = (trakBox) => {
+  const stsd = getStsdBox(trakBox);
+  if (!stsd) {
+    return false;
   }
-  let dts = 0;
-  const chunks = stcoBox.entries;
-  const samples = [];
-  let samplesPerChunk = 1;
-  for (let i = 0;i < chunks.length; i++) {
-    const hasEntry = stscBox.entries.find((entry) => entry.firstChunk === i + 1);
-    if (hasEntry) {
-      samplesPerChunk = hasEntry.samplesPerChunk;
+  const videoSample = stsd.samples.find((s) => s.type === "audio");
+  if (!videoSample || videoSample.type !== "audio") {
+    return false;
+  }
+  return true;
+};
+var trakBoxContainsVideo = (trakBox) => {
+  const stsd = getStsdBox(trakBox);
+  if (!stsd) {
+    return false;
+  }
+  const videoSample = stsd.samples.find((s) => s.type === "video");
+  if (!videoSample || videoSample.type !== "video") {
+    return false;
+  }
+  return true;
+};
+var getTimescaleAndDuration = (trakBox) => {
+  const mdhdBox = getMdhdBox(trakBox);
+  if (mdhdBox) {
+    return { timescale: mdhdBox.timescale, duration: mdhdBox.duration };
+  }
+  return null;
+};
+var getFpsFromMp4TrakBox = (trakBox) => {
+  const timescaleAndDuration = getTimescaleAndDuration(trakBox);
+  if (!timescaleAndDuration) {
+    return null;
+  }
+  const sttsBox = getSttsBox(trakBox);
+  if (!sttsBox) {
+    return null;
+  }
+  return calculateFps({
+    sttsBox,
+    timeScale: timescaleAndDuration.timescale,
+    durationInSamples: timescaleAndDuration.duration
+  });
+};
+var getFpsFromIsoMaseMedia = (structure) => {
+  const moovBox = getMoovBox(structure.boxes);
+  if (!moovBox) {
+    return null;
+  }
+  const trackBoxes = getTraks(moovBox);
+  const trackBox = trackBoxes.find(trakBoxContainsVideo);
+  if (!trackBox) {
+    return null;
+  }
+  return getFpsFromMp4TrakBox(trackBox);
+};
+var getFpsFromAvi = (structure) => {
+  const strl = getStrlBoxes(structure);
+  for (const s of strl) {
+    const strh = getStrhBox(s.children);
+    if (!strh) {
+      throw new Error("No strh box");
     }
-    let offsetInThisChunk = 0;
-    for (let j = 0;j < samplesPerChunk; j++) {
-      const size = stszBox.countType === "fixed" ? stszBox.sampleSize : stszBox.entries[samples.length];
-      const isKeyframe = stssBox ? stssBox.sampleNumber.includes(samples.length + 1) : true;
-      const delta = sttsDeltas[samples.length];
-      const ctsOffset = cttsEntries[samples.length];
-      const cts = dts + ctsOffset;
-      samples.push({
-        offset: Number(chunks[i]) + offsetInThisChunk,
-        size,
-        isKeyframe,
-        dts,
-        cts,
-        duration: delta,
-        chunk: i
-      });
-      dts += delta;
-      offsetInThisChunk += size;
+    if (strh.fccType === "auds") {
+      continue;
     }
+    return strh.rate;
   }
-  return samples;
+  return null;
 };
-
-// src/samples-from-moof.ts
-var getSamplesFromTraf = (trafSegment, moofOffset) => {
-  if (trafSegment.type !== "regular-box" || trafSegment.boxType !== "traf") {
-    throw new Error("Expected traf-box");
+var getFps = (segments) => {
+  if (segments.type === "iso-base-media") {
+    return getFpsFromIsoMaseMedia(segments);
   }
-  const tfhdBox = getTfhdBox(trafSegment);
-  const defaultSampleDuration = tfhdBox?.defaultSampleDuration ?? null;
-  const defaultSampleSize = tfhdBox?.defaultSampleSize ?? null;
-  const defaultSampleFlags = tfhdBox?.defaultSampleFlags ?? null;
-  const tfdtBox = getTfdtBox(trafSegment);
-  const trunBoxes = getTrunBoxes(trafSegment);
-  let time = 0;
-  let offset = 0;
-  let dataOffset = 0;
-  const samples = [];
-  for (const trunBox of trunBoxes) {
-    let i = -1;
-    if (trunBox.dataOffset) {
-      dataOffset = trunBox.dataOffset;
-      offset = 0;
-    }
-    for (const sample of trunBox.samples) {
-      i++;
-      const duration2 = sample.sampleDuration ?? defaultSampleDuration;
-      if (duration2 === null) {
-        throw new Error("Expected duration");
-      }
-      const size = sample.sampleSize ?? defaultSampleSize;
-      if (size === null) {
-        throw new Error("Expected size");
-      }
-      const isFirstSample = i === 0;
-      const sampleFlags = sample.sampleFlags ? sample.sampleFlags : isFirstSample && trunBox.firstSampleFlags !== null ? trunBox.firstSampleFlags : defaultSampleFlags;
-      if (sampleFlags === null) {
-        throw new Error("Expected sample flags");
-      }
-      const keyframe = !(sampleFlags >> 16 & 1);
-      const dts = time + (tfdtBox?.baseMediaDecodeTime ?? 0);
-      const samplePosition = {
-        offset: offset + (moofOffset ?? 0) + (dataOffset ?? 0),
-        dts,
-        cts: dts,
-        duration: duration2,
-        isKeyframe: keyframe,
-        size,
-        chunk: 0
-      };
-      samples.push(samplePosition);
-      offset += size;
-      time += duration2;
-    }
-  }
-  return samples;
-};
-var getSamplesFromMoof = ({
-  moofBox,
-  trackId
-}) => {
-  if (moofBox.type !== "regular-box") {
-    throw new Error("Expected moof-box");
-  }
-  const trafs = moofBox.children.filter((c) => c.type === "regular-box" && c.boxType === "traf");
-  const mapped = trafs.map((traf) => {
-    const tfhdBox = getTfhdBox(traf);
-    return tfhdBox?.trackId === trackId ? getSamplesFromTraf(traf, moofBox.offset) : [];
-  });
-  return mapped.flat(1);
-};
-
-// src/boxes/iso-base-media/get-sample-positions-from-track.ts
-var getSamplePositionsFromTrack = (trakBox, moofBox) => {
-  const stszBox = getStszBox(trakBox);
-  const stcoBox = getStcoBox(trakBox);
-  const stscBox = getStscBox(trakBox);
-  const stssBox = getStssBox(trakBox);
-  const sttsBox = getSttsBox(trakBox);
-  const tkhdBox = getTkhdBox(trakBox);
-  const cttsBox = getCttsBox(trakBox);
-  const timescaleAndDuration = getTimescaleAndDuration(trakBox);
-  if (!tkhdBox) {
-    throw new Error("Expected tkhd box in trak box");
-  }
-  if (!stszBox) {
-    throw new Error("Expected stsz box in trak box");
-  }
-  if (!stcoBox) {
-    throw new Error("Expected stco box in trak box");
-  }
-  if (!stscBox) {
-    throw new Error("Expected stsc box in trak box");
-  }
-  if (!sttsBox) {
-    throw new Error("Expected stts box in trak box");
-  }
-  if (!timescaleAndDuration) {
-    throw new Error("Expected timescale and duration in trak box");
-  }
-  let samplePositions = getSamplePositions({
-    stcoBox,
-    stscBox,
-    stszBox,
-    stssBox,
-    sttsBox,
-    cttsBox
-  });
-  if (samplePositions.length === 0 && moofBox) {
-    samplePositions = getSamplesFromMoof({ moofBox, trackId: tkhdBox.trackId });
-  }
-  return samplePositions;
-};
-
-// src/get-duration.ts
-var getDurationFromMatroska = (segments) => {
-  const mainSegment = segments.find((s) => s.type === "Segment");
-  if (!mainSegment || mainSegment.type !== "Segment") {
-    return null;
-  }
-  const { value: children } = mainSegment;
-  if (!children) {
-    return null;
-  }
-  const infoSegment = children.find((s) => s.type === "Info");
-  const relevantBoxes = [
-    ...mainSegment.value,
-    ...infoSegment && infoSegment.type === "Info" ? infoSegment.value : []
-  ];
-  const timestampScale2 = relevantBoxes.find((s) => s.type === "TimestampScale");
-  if (!timestampScale2 || timestampScale2.type !== "TimestampScale") {
-    return null;
-  }
-  const duration2 = relevantBoxes.find((s) => s.type === "Duration");
-  if (!duration2 || duration2.type !== "Duration") {
-    return null;
-  }
-  return duration2.value.value / timestampScale2.value.value * 1000;
-};
-var isMatroska = (boxes) => {
-  const matroskaBox = boxes.find((b) => b.type === "Segment");
-  return matroskaBox;
-};
-var getDuration = (boxes, parserState) => {
-  if (isMatroska(boxes)) {
-    return getDurationFromMatroska(boxes);
-  }
-  const moovBox = getMoovBox(boxes);
-  if (!moovBox) {
-    return null;
+  if (segments.type === "riff") {
+    return getFpsFromAvi(segments);
   }
-  const moofBox = getMoofBox(boxes);
-  const mvhdBox = getMvhdBox(moovBox);
-  if (!mvhdBox) {
-    return null;
-  }
-  if (mvhdBox.type !== "mvhd-box") {
-    throw new Error("Expected mvhd-box");
-  }
-  if (mvhdBox.durationInSeconds > 0) {
-    return mvhdBox.durationInSeconds;
-  }
-  const tracks2 = getTracks(boxes, parserState);
-  const allTracks = [
-    ...tracks2.videoTracks,
-    ...tracks2.audioTracks,
-    ...tracks2.otherTracks
-  ];
-  const allSamples = allTracks.map((t) => {
-    const { timescale: ts } = t;
-    const samplePositions = getSamplePositionsFromTrack(t.trakBox, moofBox);
-    const highest = samplePositions?.map((sp) => (sp.cts + sp.duration) / ts).reduce((a, b) => Math.max(a, b), 0);
-    return highest ?? 0;
-  });
-  const highestTimestamp = Math.max(...allSamples);
-  return highestTimestamp;
-};
-var hasDuration = (boxes, parserState) => {
-  try {
-    const duration2 = getDuration(boxes, parserState);
-    return getDuration(boxes, parserState) !== null && duration2 !== 0;
-  } catch {
-    return false;
-  }
-};
-
-// src/get-fps.ts
-var calculateFps = ({
-  sttsBox,
-  timeScale,
-  durationInSamples
-}) => {
-  let totalSamples = 0;
-  for (const sample of sttsBox.sampleDistribution) {
-    totalSamples += sample.sampleCount;
-  }
-  const durationInSeconds = durationInSamples / timeScale;
-  const fps = totalSamples / durationInSeconds;
-  return fps;
-};
-var trakBoxContainsAudio = (trakBox) => {
-  const stsd = getStsdBox(trakBox);
-  if (!stsd) {
-    return false;
-  }
-  const videoSample = stsd.samples.find((s) => s.type === "audio");
-  if (!videoSample || videoSample.type !== "audio") {
-    return false;
-  }
-  return true;
-};
-var trakBoxContainsVideo = (trakBox) => {
-  const stsd = getStsdBox(trakBox);
-  if (!stsd) {
-    return false;
-  }
-  const videoSample = stsd.samples.find((s) => s.type === "video");
-  if (!videoSample || videoSample.type !== "video") {
-    return false;
-  }
-  return true;
-};
-var getTimescaleAndDuration = (trakBox) => {
-  const mdhdBox = getMdhdBox(trakBox);
-  if (mdhdBox) {
-    return { timescale: mdhdBox.timescale, duration: mdhdBox.duration };
-  }
-  return null;
-};
-var getFpsFromMp4TrakBox = (trakBox) => {
-  const timescaleAndDuration = getTimescaleAndDuration(trakBox);
-  if (!timescaleAndDuration) {
-    return null;
-  }
-  const sttsBox = getSttsBox(trakBox);
-  if (!sttsBox) {
-    return null;
-  }
-  return calculateFps({
-    sttsBox,
-    timeScale: timescaleAndDuration.timescale,
-    durationInSamples: timescaleAndDuration.duration
-  });
-};
-var getFps = (segments) => {
-  const moovBox = getMoovBox(segments);
-  if (!moovBox) {
-    return null;
-  }
-  const trackBoxes = getTraks(moovBox);
-  const trackBox = trackBoxes.find(trakBoxContainsVideo);
-  if (!trackBox) {
+  if (segments.type === "matroska") {
     return null;
   }
-  return getFpsFromMp4TrakBox(trackBox);
+  throw new Error("Cannot get fps, not implemented");
 };
 var hasFps = (boxes) => {
   try {
-    if (isMatroska(boxes)) {
+    if (boxes.type === "matroska") {
       return true;
     }
     return getFps(boxes) !== null;
@@ -3624,8 +3634,8 @@ var getAudioCodec = (boxes, parserState) => {
   }
   return null;
 };
-var hasAudioCodec = (boxes) => {
-  return hasTracks(boxes);
+var hasAudioCodec = (boxes, state) => {
+  return hasTracks(boxes, state);
 };
 var getCodecSpecificatorFromEsdsBox = ({
   child
@@ -3741,11 +3751,20 @@ var getAudioCodecFromTrak = (trak) => {
   }
   return null;
 };
+var isLpcmAudioCodec = (trak) => {
+  return getAudioCodecFromTrak(trak)?.format === "lpcm";
+};
 var getAudioCodecStringFromTrak = (trak) => {
   const codec = getAudioCodecFromTrak(trak);
   if (!codec) {
     throw new Error("Expected codec");
   }
+  if (codec.format === "lpcm") {
+    return {
+      codecString: "pcm-s16",
+      description: codec.description
+    };
+  }
   const codecStringWithoutMp3Exception = [
     codec.format,
     codec.primarySpecificator ? codec.primarySpecificator.toString(16) : null,
@@ -3761,6 +3780,9 @@ var getAudioCodecFromAudioCodecInfo = (codec) => {
   if (codec.format === "twos") {
     return "pcm-s16";
   }
+  if (codec.format === "lpcm") {
+    return "pcm-s16";
+  }
   if (codec.format === "sowt") {
     return "aiff";
   }
@@ -3787,16 +3809,6 @@ var getAudioCodecFromTrack = (track) => {
 };
 
 // src/get-sample-aspect-ratio.ts
-function gcd(a, b) {
-  return b === 0 ? a : gcd(b, a % b);
-}
-function reduceFraction(numerator, denominator) {
-  const greatestCommonDivisor = gcd(Math.abs(numerator), Math.abs(denominator));
-  return {
-    numerator: numerator / greatestCommonDivisor,
-    denominator: denominator / greatestCommonDivisor
-  };
-}
 var getStsdVideoConfig = (trakBox) => {
   const stsdBox = getStsdBox(trakBox);
   if (!stsdBox) {
@@ -3908,6 +3920,16 @@ var applyAspectRatios = ({
     height: newHeight
   };
 };
+function gcd(a, b) {
+  return b === 0 ? a : gcd(b, a % b);
+}
+function reduceFraction(numerator, denominator) {
+  const greatestCommonDivisor = gcd(Math.abs(numerator), Math.abs(denominator));
+  return {
+    numerator: numerator / greatestCommonDivisor,
+    denominator: denominator / greatestCommonDivisor
+  };
+}
 var getDisplayAspectRatio = ({
   sampleAspectRatio,
   nativeDimensions
@@ -3987,6 +4009,9 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
   const allowDiscard = () => {
     discardAllowed = true;
   };
+  const discard = (length) => {
+    counter.increment(length);
+  };
   const getUint8 = () => {
     const val = view.getUint8(counter.getDiscardedOffset());
     counter.increment(1);
@@ -4032,8 +4057,8 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     }
     return lastInt;
   };
-  const getUint32 = (littleEndian = false) => {
-    const val = view.getUint32(counter.getDiscardedOffset(), littleEndian);
+  const getUint32 = () => {
+    const val = view.getUint32(counter.getDiscardedOffset());
     counter.increment(4);
     return val;
   };
@@ -4042,9 +4067,21 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     counter.increment(8);
     return val;
   };
-  const getUint32Le = () => {
-    const val = view.getUint32(counter.getDiscardedOffset(), true);
-    counter.increment(4);
+  const startBox = (size) => {
+    const startOffset = counter.getOffset();
+    return {
+      discardRest: () => discard(size - (counter.getOffset() - startOffset)),
+      expectNoMoreBytes: () => {
+        const remaining = size - (counter.getOffset() - startOffset);
+        if (remaining !== 0) {
+          throw new Error("expected 0 bytes, got " + remaining);
+        }
+      }
+    };
+  };
+  const getUint32Le = () => {
+    const val = view.getUint32(counter.getDiscardedOffset(), true);
+    counter.increment(4);
     return val;
   };
   const getInt32Le = () => {
@@ -4185,9 +4222,7 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     leb128,
     removeBytesRead,
     isWebm,
-    discard: (length) => {
-      counter.increment(length);
-    },
+    discard,
     getEightByteNumber,
     getFourByteNumber,
     getSlice,
@@ -4281,6 +4316,11 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
       counter.increment(2);
       return val;
     },
+    getUint16Le: () => {
+      const val = view.getUint16(counter.getDiscardedOffset(), true);
+      counter.increment(2);
+      return val;
+    },
     getUint24: () => {
       const val1 = view.getUint8(counter.getDiscardedOffset());
       const val2 = view.getUint8(counter.getDiscardedOffset() + 1);
@@ -4336,7 +4376,8 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     destroy,
     isMp3,
     disallowDiscard,
-    allowDiscard
+    allowDiscard,
+    startBox
   };
 };
 
@@ -4445,14 +4486,7 @@ var getVideoCodecFromIsoTrak = (trakBox) => {
   }
   throw new Error("Could not find video codec");
 };
-var getVideoCodec = (boxes) => {
-  const moovBox = getMoovBox(boxes);
-  if (moovBox) {
-    const trakBox = getTraks(moovBox).filter((t) => trakBoxContainsVideo(t))[0];
-    if (trakBox) {
-      return getVideoCodecFromIsoTrak(trakBox);
-    }
-  }
+var getVideoCodecFromMatroska = (boxes) => {
   const mainSegment = boxes.find((b) => b.type === "Segment");
   if (!mainSegment || mainSegment.type !== "Segment") {
     return null;
@@ -4483,10 +4517,44 @@ var getVideoCodec = (boxes) => {
       }
     }
   }
+  throw new Error("Could not find video codec");
+};
+var getVideoCodecFromAvi = (structure) => {
+  const strl = getStrlBoxes(structure);
+  for (const s of strl) {
+    const strh = getStrhBox(s.children);
+    if (!strh) {
+      throw new Error("No strh box");
+    }
+    if (strh.fccType === "auds") {
+      continue;
+    }
+    if (strh.handler === "H264") {
+      return "h264";
+    }
+  }
+  throw new Error("Unsupported codec");
+};
+var getVideoCodec = (boxes) => {
+  if (boxes.type === "iso-base-media") {
+    const moovBox = getMoovBox(boxes.boxes);
+    if (moovBox) {
+      const trakBox = getTraks(moovBox).filter((t) => trakBoxContainsVideo(t))[0];
+      if (trakBox) {
+        return getVideoCodecFromIsoTrak(trakBox);
+      }
+    }
+  }
+  if (boxes.type === "riff") {
+    return getVideoCodecFromAvi(boxes);
+  }
+  if (boxes.type === "matroska") {
+    return getVideoCodecFromMatroska(boxes.boxes);
+  }
   return null;
 };
-var hasVideoCodec = (boxes) => {
-  return hasTracks(boxes);
+var hasVideoCodec = (boxes, state) => {
+  return hasTracks(boxes, state);
 };
 var getVideoPrivateData = (trakBox) => {
   const videoSample = getStsdVideoConfig(trakBox);
@@ -4521,9 +4589,9 @@ var getIsoBmColrConfig = (trakBox) => {
   }
   return {
     fullRange: colrAtom.fullRangeFlag,
-    matrixCoefficients: colrAtom.matrixIndex === 1 ? "bt709" : colrAtom.matrixIndex === 5 ? "bt470bg" : colrAtom.matrixIndex === 6 ? "smpte170m" : null,
-    primaries: colrAtom.primaries === 1 ? "bt709" : colrAtom.primaries === 5 ? "bt470bg" : colrAtom.primaries === 6 ? "smpte170m" : null,
-    transferCharacteristics: colrAtom.transfer === 1 ? "bt709" : colrAtom.transfer === 6 ? "smpte170m" : colrAtom.transfer === 13 ? "iec61966-2-1" : null
+    matrixCoefficients: colrAtom.matrixIndex === 1 ? "bt709" : colrAtom.matrixIndex === 5 ? "bt470bg" : colrAtom.matrixIndex === 6 ? "smpte170m" : colrAtom.matrixIndex === 9 ? "bt2020" : null,
+    primaries: colrAtom.primaries === 1 ? "bt709" : colrAtom.primaries === 5 ? "bt470bg" : colrAtom.primaries === 6 ? "smpte170m" : colrAtom.primaries === 9 ? "bt2020" : null,
+    transferCharacteristics: colrAtom.transfer === 1 ? "bt709" : colrAtom.transfer === 6 ? "smpte170m" : colrAtom.transfer === 13 ? "iec61966-2-1" : colrAtom.transfer === 18 ? "arib-std-b67" : null
   };
 };
 var getVideoCodecString = (trakBox) => {
@@ -4577,7 +4645,7 @@ var makeBaseMediaTrack = (trakBox) => {
       sampleRate,
       description,
       trakBox,
-      codecPrivate: getCodecPrivateFromTrak(trakBox),
+      codecPrivate: getCodecPrivateFromTrak(trakBox) ?? description ?? null,
       codecWithoutConfig: getAudioCodecFromTrack(trakBox)
     };
   }
@@ -4636,6 +4704,135 @@ var makeBaseMediaTrack = (trakBox) => {
   return track;
 };
 
+// src/add-avc-profile-to-track.ts
+var addAvcProfileToTrack = (track, avc1Profile) => {
+  if (avc1Profile === null) {
+    return track;
+  }
+  return {
+    ...track,
+    codec: `avc1.${avc1Profile.sps.profile.toString(16).padStart(2, "0")}${avc1Profile.sps.compatibility.toString(16).padStart(2, "0")}${avc1Profile.sps.level.toString(16).padStart(2, "0")}`,
+    codecPrivate: combineUint8Arrays([
+      new Uint8Array([
+        1,
+        avc1Profile.sps.level,
+        avc1Profile.sps.compatibility,
+        avc1Profile.sps.profile,
+        255,
+        225
+      ]),
+      serializeUint16(avc1Profile.sps.sps.length),
+      avc1Profile.sps.sps,
+      new Uint8Array([1]),
+      serializeUint16(avc1Profile.pps.pps.length),
+      avc1Profile.pps.pps
+    ])
+  };
+};
+
+// src/boxes/riff/timescale.ts
+var MEDIA_PARSER_RIFF_TIMESCALE = 1e6;
+
+// src/boxes/riff/get-tracks-from-avi.ts
+var getNumberOfTracks = (structure) => {
+  const avihBox = getAvihBox(structure);
+  if (avihBox) {
+    return avihBox.streams;
+  }
+  throw new Error("No avih box found");
+};
+var makeAviAudioTrack = ({
+  strf,
+  index
+}) => {
+  if (strf.formatTag !== 255) {
+    throw new Error(`Unsupported audio format ${strf.formatTag}`);
+  }
+  return {
+    type: "audio",
+    codec: "mp4a.40.2",
+    codecPrivate: new Uint8Array([18, 16]),
+    codecWithoutConfig: "aac",
+    description: new Uint8Array([18, 16]),
+    numberOfChannels: strf.numberOfChannels,
+    sampleRate: strf.sampleRate,
+    timescale: MEDIA_PARSER_RIFF_TIMESCALE,
+    trackId: index,
+    trakBox: null
+  };
+};
+var makeAviVideoTrack = ({
+  strh,
+  strf,
+  index
+}) => {
+  if (strh.handler !== "H264") {
+    throw new Error(`Unsupported video codec ${strh.handler}`);
+  }
+  return {
+    codecPrivate: null,
+    codec: "to-be-overriden-later",
+    codecWithoutConfig: "h264",
+    codedHeight: strf.height,
+    codedWidth: strf.width,
+    width: strf.width,
+    height: strf.height,
+    type: "video",
+    displayAspectHeight: strf.height,
+    timescale: MEDIA_PARSER_RIFF_TIMESCALE,
+    description: undefined,
+    trackId: index,
+    color: {
+      fullRange: null,
+      matrixCoefficients: null,
+      primaries: null,
+      transferCharacteristics: null
+    },
+    displayAspectWidth: strf.width,
+    trakBox: null,
+    rotation: 0,
+    sampleAspectRatio: {
+      numerator: 1,
+      denominator: 1
+    },
+    fps: strh.rate / strh.scale
+  };
+};
+var getTracksFromAvi = (structure, state) => {
+  if (!isRiffAvi(structure)) {
+    throw new Error("Not an AVI file");
+  }
+  const videoTracks = [];
+  const audioTracks = [];
+  const otherTracks = [];
+  const boxes = getStrlBoxes(structure);
+  let i = 0;
+  for (const box of boxes) {
+    const strh = getStrhBox(box.children);
+    const strf = getStrfBox(box.children);
+    if (!strh || !strf) {
+      continue;
+    }
+    if (strf.type === "strf-box-video") {
+      videoTracks.push(addAvcProfileToTrack(makeAviVideoTrack({ strh, strf, index: i }), state.getAvcProfile()));
+    } else if (strh.fccType === "auds") {
+      audioTracks.push(makeAviAudioTrack({ strf, index: i }));
+    } else {
+      throw new Error(`Unsupported track type ${strh.fccType}`);
+    }
+    i++;
+  }
+  return { audioTracks, otherTracks, videoTracks };
+};
+var hasAllTracksFromAvi = (structure, state) => {
+  if (!isRiffAvi(structure)) {
+    throw new Error("Not an AVI file");
+  }
+  const numberOfTracks = getNumberOfTracks(structure);
+  const tracks2 = getTracksFromAvi(structure, state);
+  return tracks2.videoTracks.length + tracks2.audioTracks.length + tracks2.otherTracks.length === numberOfTracks;
+};
+
 // src/make-hvc1-codec-strings.ts
 var getHvc1CodecString = (data) => {
   const configurationVersion = data.getUint8();
@@ -4980,147 +5177,485 @@ var getTrack = ({
       })
     };
   }
-  return null;
+  return null;
+};
+
+// src/boxes/webm/get-ready-tracks.ts
+var getTracksFromMatroska = (segment, timescale2) => {
+  const tracksSegment = getTracksSegment(segment);
+  if (!tracksSegment) {
+    throw new Error("No tracks segment");
+  }
+  const tracks2 = [];
+  for (const trackEntrySegment of tracksSegment.value) {
+    if (trackEntrySegment.type === "Crc32") {
+      continue;
+    }
+    if (trackEntrySegment.type !== "TrackEntry") {
+      throw new Error("Expected track entry segment");
+    }
+    const track = getTrack({
+      track: trackEntrySegment,
+      timescale: timescale2
+    });
+    if (track) {
+      tracks2.push(track);
+    }
+  }
+  return tracks2;
+};
+
+// src/get-tracks.ts
+var getNumberOfTracks2 = (moovBox) => {
+  const mvHdBox = getMvhdBox(moovBox);
+  if (!mvHdBox) {
+    return 0;
+  }
+  return mvHdBox.nextTrackId - 1;
+};
+var hasTracks = (structure, state) => {
+  if (structure.type === "matroska") {
+    const mainSegment = getMainSegment(structure.boxes);
+    if (!mainSegment) {
+      throw new Error("No main segment found");
+    }
+    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;
+  }
+  if (structure.type === "riff") {
+    return hasAllTracksFromAvi(structure, state);
+  }
+  throw new Error("Unknown container");
+};
+var getTracksFromMa = (segments, state) => {
+  const videoTracks = [];
+  const audioTracks = [];
+  const otherTracks = [];
+  const mainSegment = segments.find((s) => s.type === "Segment");
+  if (!mainSegment) {
+    throw new Error("No main segment found");
+  }
+  const matroskaTracks = getTracksFromMatroska(mainSegment, state.getTimescale());
+  for (const track of matroskaTracks) {
+    if (track.type === "video") {
+      videoTracks.push(track);
+    } else if (track.type === "audio") {
+      audioTracks.push(track);
+    } else if (track.type === "other") {
+      otherTracks.push(track);
+    }
+  }
+  return {
+    videoTracks,
+    audioTracks,
+    otherTracks
+  };
+};
+var getTracksFromIsoBaseMedia = (segments) => {
+  const videoTracks = [];
+  const audioTracks = [];
+  const otherTracks = [];
+  const moovBox = getMoovBox(segments);
+  if (!moovBox) {
+    return {
+      videoTracks,
+      audioTracks,
+      otherTracks
+    };
+  }
+  const tracks2 = getTraks(moovBox);
+  for (const trakBox of tracks2) {
+    const track = makeBaseMediaTrack(trakBox);
+    if (!track) {
+      continue;
+    }
+    if (track.type === "video") {
+      videoTracks.push(track);
+    } else if (track.type === "audio") {
+      audioTracks.push(track);
+    } else if (track.type === "other") {
+      otherTracks.push(track);
+    }
+  }
+  return {
+    videoTracks,
+    audioTracks,
+    otherTracks
+  };
+};
+var getTracks = (segments, state) => {
+  if (segments.type === "matroska") {
+    return getTracksFromMa(segments.boxes, state);
+  }
+  if (segments.type === "iso-base-media") {
+    return getTracksFromIsoBaseMedia(segments.boxes);
+  }
+  if (segments.type === "riff") {
+    return getTracksFromAvi(segments, state);
+  }
+  throw new Error("Unknown container");
+};
+
+// src/get-container.ts
+var getContainer = (segments) => {
+  if (segments.type === "iso-base-media") {
+    return "mp4";
+  }
+  if (segments.type === "matroska") {
+    return "webm";
+  }
+  if (segments.type === "riff") {
+    if (isRiffAvi(segments)) {
+      return "avi";
+    }
+  }
+  throw new Error("Unknown container");
+};
+var hasContainer = (boxes) => {
+  try {
+    return getContainer(boxes) !== null;
+  } catch {
+    return false;
+  }
+};
+
+// src/get-dimensions.ts
+var getDimensions = (boxes, state) => {
+  const { videoTracks } = getTracks(boxes, state);
+  if (!videoTracks.length) {
+    throw new Error("Expected video track");
+  }
+  const firstVideoTrack = videoTracks[0];
+  return {
+    width: firstVideoTrack.width,
+    height: firstVideoTrack.height,
+    rotation: firstVideoTrack.rotation,
+    unrotatedHeight: firstVideoTrack.displayAspectHeight,
+    unrotatedWidth: firstVideoTrack.displayAspectWidth
+  };
+};
+var hasDimensions = (boxes, state) => {
+  try {
+    return getDimensions(boxes, state) !== null;
+  } catch {
+    return false;
+  }
+};
+
+// src/get-sample-positions.ts
+var getSamplePositions = ({
+  stcoBox,
+  stszBox,
+  stscBox,
+  stssBox,
+  sttsBox,
+  cttsBox
+}) => {
+  const sttsDeltas = [];
+  for (const distribution of sttsBox.sampleDistribution) {
+    for (let i = 0;i < distribution.sampleCount; i++) {
+      sttsDeltas.push(distribution.sampleDelta);
+    }
+  }
+  const cttsEntries = [];
+  for (const entry of cttsBox?.entries ?? [
+    { sampleCount: sttsDeltas.length, sampleOffset: 0 }
+  ]) {
+    for (let i = 0;i < entry.sampleCount; i++) {
+      cttsEntries.push(entry.sampleOffset);
+    }
+  }
+  let dts = 0;
+  const chunks = stcoBox.entries;
+  const samples = [];
+  let samplesPerChunk = 1;
+  for (let i = 0;i < chunks.length; i++) {
+    const hasEntry = stscBox.entries.find((entry) => entry.firstChunk === i + 1);
+    if (hasEntry) {
+      samplesPerChunk = hasEntry.samplesPerChunk;
+    }
+    let offsetInThisChunk = 0;
+    for (let j = 0;j < samplesPerChunk; j++) {
+      const size = stszBox.countType === "fixed" ? stszBox.sampleSize : stszBox.entries[samples.length];
+      const isKeyframe = stssBox ? stssBox.sampleNumber.includes(samples.length + 1) : true;
+      const delta = sttsDeltas[samples.length];
+      const ctsOffset = cttsEntries[samples.length];
+      const cts = dts + ctsOffset;
+      samples.push({
+        offset: Number(chunks[i]) + offsetInThisChunk,
+        size,
+        isKeyframe,
+        dts,
+        cts,
+        duration: delta,
+        chunk: i
+      });
+      dts += delta;
+      offsetInThisChunk += size;
+    }
+  }
+  return samples;
+};
+
+// src/get-sample-positions-from-lpcm.ts
+var getSamplePositionsFromLpcm = (trakBox) => {
+  const stscBox = getStscBox(trakBox);
+  const stszBox = getStszBox(trakBox);
+  const stcoBox = getStcoBox(trakBox);
+  if (!stscBox) {
+    throw new Error("Expected stsc box in trak box");
+  }
+  if (!stcoBox) {
+    throw new Error("Expected stco box in trak box");
+  }
+  if (!stszBox) {
+    throw new Error("Expected stsz box in trak box");
+  }
+  if (stszBox.countType !== "fixed") {
+    throw new Error("Only supporting fixed count type in stsz box");
+  }
+  const samples = [];
+  let timestamp = 0;
+  for (let i = 0;i < stcoBox.entries.length; i++) {
+    const entry = stcoBox.entries[i];
+    const chunk = i + 1;
+    const stscEntry = stscBox.entries.findLast((e) => e.firstChunk <= chunk);
+    if (!stscEntry) {
+      throw new Error("should not be");
+    }
+    samples.push({
+      chunk,
+      cts: timestamp,
+      dts: timestamp,
+      offset: Number(entry),
+      size: stszBox.sampleSize * stscEntry.samplesPerChunk,
+      duration: stscEntry.samplesPerChunk,
+      isKeyframe: true
+    });
+    timestamp += stscEntry.samplesPerChunk;
+  }
+  return samples;
+};
+
+// src/samples-from-moof.ts
+var getSamplesFromTraf = (trafSegment, moofOffset) => {
+  if (trafSegment.type !== "regular-box" || trafSegment.boxType !== "traf") {
+    throw new Error("Expected traf-box");
+  }
+  const tfhdBox = getTfhdBox(trafSegment);
+  const defaultSampleDuration = tfhdBox?.defaultSampleDuration ?? null;
+  const defaultSampleSize = tfhdBox?.defaultSampleSize ?? null;
+  const defaultSampleFlags = tfhdBox?.defaultSampleFlags ?? null;
+  const tfdtBox = getTfdtBox(trafSegment);
+  const trunBoxes = getTrunBoxes(trafSegment);
+  let time = 0;
+  let offset = 0;
+  let dataOffset = 0;
+  const samples = [];
+  for (const trunBox of trunBoxes) {
+    let i = -1;
+    if (trunBox.dataOffset) {
+      dataOffset = trunBox.dataOffset;
+      offset = 0;
+    }
+    for (const sample of trunBox.samples) {
+      i++;
+      const duration2 = sample.sampleDuration ?? defaultSampleDuration;
+      if (duration2 === null) {
+        throw new Error("Expected duration");
+      }
+      const size = sample.sampleSize ?? defaultSampleSize;
+      if (size === null) {
+        throw new Error("Expected size");
+      }
+      const isFirstSample = i === 0;
+      const sampleFlags = sample.sampleFlags ? sample.sampleFlags : isFirstSample && trunBox.firstSampleFlags !== null ? trunBox.firstSampleFlags : defaultSampleFlags;
+      if (sampleFlags === null) {
+        throw new Error("Expected sample flags");
+      }
+      const keyframe = !(sampleFlags >> 16 & 1);
+      const dts = time + (tfdtBox?.baseMediaDecodeTime ?? 0);
+      const samplePosition = {
+        offset: offset + (moofOffset ?? 0) + (dataOffset ?? 0),
+        dts,
+        cts: dts,
+        duration: duration2,
+        isKeyframe: keyframe,
+        size,
+        chunk: 0
+      };
+      samples.push(samplePosition);
+      offset += size;
+      time += duration2;
+    }
+  }
+  return samples;
 };
-
-// src/boxes/webm/get-ready-tracks.ts
-var getTracksFromMatroska = (segment, timescale2) => {
-  const tracksSegment = getTracksSegment(segment);
-  if (!tracksSegment) {
-    throw new Error("No tracks segment");
-  }
-  const tracks2 = [];
-  for (const trackEntrySegment of tracksSegment.value) {
-    if (trackEntrySegment.type === "Crc32") {
-      continue;
-    }
-    if (trackEntrySegment.type !== "TrackEntry") {
-      throw new Error("Expected track entry segment");
-    }
-    const track = getTrack({
-      track: trackEntrySegment,
-      timescale: timescale2
-    });
-    if (track) {
-      tracks2.push(track);
-    }
+var getSamplesFromMoof = ({
+  moofBox,
+  trackId
+}) => {
+  if (moofBox.type !== "regular-box") {
+    throw new Error("Expected moof-box");
   }
-  return tracks2;
+  const trafs = moofBox.children.filter((c) => c.type === "regular-box" && c.boxType === "traf");
+  const mapped = trafs.map((traf) => {
+    const tfhdBox = getTfhdBox(traf);
+    return tfhdBox?.trackId === trackId ? getSamplesFromTraf(traf, moofBox.offset) : [];
+  });
+  return mapped.flat(1);
 };
 
-// src/get-tracks.ts
-var getNumberOfTracks = (moovBox) => {
-  const mvHdBox = getMvhdBox(moovBox);
-  if (!mvHdBox) {
-    return 0;
+// src/boxes/iso-base-media/get-sample-positions-from-track.ts
+var getSamplePositionsFromTrack = (trakBox, moofBox) => {
+  const isLpcm = isLpcmAudioCodec(trakBox);
+  const timescaleAndDuration = getTimescaleAndDuration(trakBox);
+  if (isLpcm) {
+    return getSamplePositionsFromLpcm(trakBox);
   }
-  return mvHdBox.nextTrackId - 1;
-};
-var hasTracks = (segments) => {
-  const mainSegment = getMainSegment(segments);
-  if (mainSegment) {
-    return getTracksSegment(mainSegment) !== null;
+  const stszBox = getStszBox(trakBox);
+  const stcoBox = getStcoBox(trakBox);
+  const stscBox = getStscBox(trakBox);
+  const stssBox = getStssBox(trakBox);
+  const sttsBox = getSttsBox(trakBox);
+  const tkhdBox = getTkhdBox(trakBox);
+  const cttsBox = getCttsBox(trakBox);
+  if (!tkhdBox) {
+    throw new Error("Expected tkhd box in trak box");
   }
-  const moovBox = getMoovBox(segments);
-  if (!moovBox) {
-    return false;
+  if (!stszBox) {
+    throw new Error("Expected stsz box in trak box");
   }
-  const numberOfTracks = getNumberOfTracks(moovBox);
-  const tracks2 = getTraks(moovBox);
-  return tracks2.length === numberOfTracks;
+  if (!stcoBox) {
+    throw new Error("Expected stco box in trak box");
+  }
+  if (!stscBox) {
+    throw new Error("Expected stsc box in trak box");
+  }
+  if (!sttsBox) {
+    throw new Error("Expected stts box in trak box");
+  }
+  if (!timescaleAndDuration) {
+    throw new Error("Expected timescale and duration in trak box");
+  }
+  let samplePositions = getSamplePositions({
+    stcoBox,
+    stscBox,
+    stszBox,
+    stssBox,
+    sttsBox,
+    cttsBox
+  });
+  if (samplePositions.length === 0 && moofBox) {
+    samplePositions = getSamplesFromMoof({ moofBox, trackId: tkhdBox.trackId });
+  }
+  return samplePositions;
 };
-var getTracks = (segments, state) => {
-  const videoTracks = [];
-  const audioTracks = [];
-  const otherTracks = [];
+
+// src/get-duration.ts
+var getDurationFromMatroska = (segments) => {
   const mainSegment = segments.find((s) => s.type === "Segment");
-  if (mainSegment && mainSegment.type === "Segment") {
-    const matroskaTracks = getTracksFromMatroska(mainSegment, state.getTimescale());
-    for (const track of matroskaTracks) {
-      if (track.type === "video") {
-        videoTracks.push(track);
-      } else if (track.type === "audio") {
-        audioTracks.push(track);
-      } else if (track.type === "other") {
-        otherTracks.push(track);
-      }
-    }
-    return {
-      videoTracks,
-      audioTracks,
-      otherTracks
-    };
+  if (!mainSegment || mainSegment.type !== "Segment") {
+    return null;
   }
-  const moovBox = getMoovBox(segments);
+  const { value: children } = mainSegment;
+  if (!children) {
+    return null;
+  }
+  const infoSegment = children.find((s) => s.type === "Info");
+  const relevantBoxes = [
+    ...mainSegment.value,
+    ...infoSegment && infoSegment.type === "Info" ? infoSegment.value : []
+  ];
+  const timestampScale2 = relevantBoxes.find((s) => s.type === "TimestampScale");
+  if (!timestampScale2 || timestampScale2.type !== "TimestampScale") {
+    return null;
+  }
+  const duration2 = relevantBoxes.find((s) => s.type === "Duration");
+  if (!duration2 || duration2.type !== "Duration") {
+    return null;
+  }
+  return duration2.value.value / timestampScale2.value.value * 1000;
+};
+var getDurationFromIsoBaseMedia = (structure, parserState) => {
+  const moovBox = getMoovBox(structure.boxes);
   if (!moovBox) {
-    return {
-      videoTracks,
-      audioTracks,
-      otherTracks
-    };
+    return null;
   }
-  const tracks2 = getTraks(moovBox);
-  for (const trakBox of tracks2) {
-    const track = makeBaseMediaTrack(trakBox);
-    if (!track) {
-      continue;
-    }
-    if (track.type === "video") {
-      videoTracks.push(track);
-    } else if (track.type === "audio") {
-      audioTracks.push(track);
-    } else if (track.type === "other") {
-      otherTracks.push(track);
+  const moofBox = getMoofBox(structure.boxes);
+  const mvhdBox = getMvhdBox(moovBox);
+  if (!mvhdBox) {
+    return null;
+  }
+  if (mvhdBox.type !== "mvhd-box") {
+    throw new Error("Expected mvhd-box");
+  }
+  if (mvhdBox.durationInSeconds > 0) {
+    return mvhdBox.durationInSeconds;
+  }
+  const tracks2 = getTracks(structure, parserState);
+  const allTracks = [
+    ...tracks2.videoTracks,
+    ...tracks2.audioTracks,
+    ...tracks2.otherTracks
+  ];
+  const allSamples = allTracks.map((t) => {
+    const { timescale: ts } = t;
+    const samplePositions = getSamplePositionsFromTrack(t.trakBox, moofBox);
+    const highest = samplePositions?.map((sp) => (sp.cts + sp.duration) / ts).reduce((a, b) => Math.max(a, b), 0);
+    return highest ?? 0;
+  });
+  const highestTimestamp = Math.max(...allSamples);
+  return highestTimestamp;
+};
+var getDurationFromAvi = (structure) => {
+  const strl = getStrlBoxes(structure);
+  const lengths = [];
+  for (const s of strl) {
+    const strh = getStrhBox(s.children);
+    if (!strh) {
+      throw new Error("No strh box");
     }
+    const samplesPerSecond = strh.rate / strh.scale;
+    const streamLength = strh.length / samplesPerSecond;
+    lengths.push(streamLength);
   }
-  return {
-    videoTracks,
-    audioTracks,
-    otherTracks
-  };
+  return Math.max(...lengths);
 };
-
-// src/get-container.ts
-var getContainer = (segments) => {
-  const moovBox = getMoovBox(segments);
-  if (moovBox) {
-    return "mp4";
+var getDuration = (structure, parserState) => {
+  if (structure.type === "matroska") {
+    return getDurationFromMatroska(structure.boxes);
   }
-  const mainSegment = getMainSegment(segments);
-  if (mainSegment) {
-    return "webm";
+  if (structure.type === "iso-base-media") {
+    return getDurationFromIsoBaseMedia(structure, parserState);
   }
-  return null;
-};
-var hasContainer = (boxes) => {
-  try {
-    return getContainer(boxes) !== null;
-  } catch {
-    return false;
+  if (structure.type === "riff") {
+    return getDurationFromAvi(structure);
   }
+  throw new Error("Has no duration");
+};
+var hasDuration = (structure, parserState) => {
+  return hasTracks(structure, parserState);
 };
 
-// src/get-dimensions.ts
-var getDimensions = (boxes, state) => {
+// src/get-is-hdr.ts
+var isVideoTrackHdr = (track) => {
+  return track.color.matrixCoefficients === "bt2020" && track.color.transferCharacteristics === "arib-std-b67" && track.color.primaries === "bt2020";
+};
+var getIsHdr = (boxes, state) => {
   const { videoTracks } = getTracks(boxes, state);
-  if (!videoTracks.length) {
-    throw new Error("Expected video track");
-  }
-  const firstVideoTrack = videoTracks[0];
-  return {
-    width: firstVideoTrack.width,
-    height: firstVideoTrack.height,
-    rotation: firstVideoTrack.rotation,
-    unrotatedHeight: firstVideoTrack.displayAspectHeight,
-    unrotatedWidth: firstVideoTrack.displayAspectWidth
-  };
+  return videoTracks.some((track) => isVideoTrackHdr(track));
 };
-var hasDimensions = (boxes, state) => {
-  try {
-    return getDimensions(boxes, state) !== null;
-  } catch {
-    return false;
-  }
+var hasHdr = (boxes, state) => {
+  return hasTracks(boxes, state);
 };
 
 // src/emit-available-info.ts
@@ -5135,10 +5670,10 @@ var emitAvailableInfo = ({
 }) => {
   const keys = Object.keys(hasInfo);
   for (const key of keys) {
-    if (key === "boxes") {
-      if (parseResult && hasInfo.boxes && returnValue.boxes === undefined) {
-        moreFields.onBoxes?.(parseResult.segments);
-        returnValue.boxes = parseResult.segments;
+    if (key === "structure") {
+      if (parseResult && hasInfo.structure && returnValue.structure === undefined) {
+        moreFields.onStructure?.(parseResult.segments);
+        returnValue.structure = parseResult.segments;
       }
       continue;
     }
@@ -5238,6 +5773,14 @@ var emitAvailableInfo = ({
       }
       continue;
     }
+    if (key === "isHdr") {
+      if (returnValue.isHdr === undefined && hasInfo.isHdr && parseResult) {
+        const isHdr = getIsHdr(parseResult.segments, state);
+        moreFields.onIsHdr?.(isHdr);
+        returnValue.isHdr = isHdr;
+      }
+      continue;
+    }
     if (key === "container") {
       if (returnValue.container === undefined && hasInfo.container && parseResult) {
         const container = getContainer(parseResult.segments);
@@ -5253,8 +5796,9 @@ var emitAvailableInfo = ({
 // src/has-all-info.ts
 var getAvailableInfo = (options, parseResult, state) => {
   const keys = Object.entries(options).filter(([, value]) => value);
-  const infos = keys.map(([key]) => {
-    if (key === "boxes") {
+  const infos = keys.map(([_key]) => {
+    const key = _key;
+    if (key === "structure") {
       return Boolean(parseResult && parseResult.status === "done");
     }
     if (key === "durationInSeconds") {
@@ -5266,14 +5810,17 @@ var getAvailableInfo = (options, parseResult, state) => {
     if (key === "fps") {
       return Boolean(parseResult && hasFps(parseResult.segments));
     }
+    if (key === "isHdr") {
+      return Boolean(parseResult && hasHdr(parseResult.segments, state));
+    }
     if (key === "videoCodec") {
-      return Boolean(parseResult && hasVideoCodec(parseResult.segments));
+      return Boolean(parseResult && hasVideoCodec(parseResult.segments, state));
     }
     if (key === "audioCodec") {
-      return Boolean(parseResult && hasAudioCodec(parseResult.segments));
+      return Boolean(parseResult && hasAudioCodec(parseResult.segments, state));
     }
     if (key === "tracks") {
-      return Boolean(parseResult && hasTracks(parseResult.segments));
+      return Boolean(parseResult && hasTracks(parseResult.segments, state));
     }
     if (key === "internalStats") {
       return false;
@@ -5297,8 +5844,37 @@ var getAvailableInfo = (options, parseResult, state) => {
   return Object.fromEntries(entries);
 };
 
+// src/register-track.ts
+var registerTrack = async ({
+  state,
+  options,
+  track
+}) => {
+  if (track.type === "video" && options.onVideoTrack) {
+    const callback = await options.onVideoTrack(track);
+    await state.registerVideoSampleCallback(track.trackId, callback ?? null);
+  }
+  if (track.type === "audio" && options.onAudioTrack) {
+    const callback = await options.onAudioTrack(track);
+    await state.registerAudioSampleCallback(track.trackId, callback ?? null);
+  }
+};
+var registerVideoTrackWhenProfileIsAvailable = ({
+  options,
+  state,
+  track
+}) => {
+  state.registerOnAvcProfileCallback(async (profile) => {
+    await registerTrack({
+      options,
+      state,
+      track: addAvcProfileToTrack(track, profile)
+    });
+  });
+};
+
 // src/boxes/iso-base-media/esds/decoder-specific-config.ts
-var parseDecoderSpecificConfig = (iterator, logLevel) => {
+var parseDecoderSpecificConfig = (iterator) => {
   const layerTag = iterator.getUint8();
   const layerSize = iterator.getPaddedFourByteNumber();
   const start = iterator.counter.getOffset();
@@ -5322,9 +5898,6 @@ var parseDecoderSpecificConfig = (iterator, logLevel) => {
   if (read < layerSize) {
     iterator.discard(layerSize - read);
   }
-  if (bytes.byteLength === 2 && bytes[0] === 17 && bytes[1] === 136) {
-    Log.warn(logLevel, "Chrome has a bug and might not be able to decode this audio. It will be fixed, see: https://issues.chromium.org/issues/360083330");
-  }
   return {
     type: "mp4a-specific-config",
     audioObjectType,
@@ -5345,8 +5918,7 @@ var mapToObjectAudioIndicator = (num) => {
   return "unknown";
 };
 var processDescriptor = ({
-  iterator,
-  logLevel
+  iterator
 }) => {
   const tag = iterator.getUint8();
   if (tag === 4) {
@@ -5363,7 +5935,7 @@ var processDescriptor = ({
     const avgBitrate = iterator.getUint32();
     const decoderSpecificConfigs = [];
     while (size - (iterator.counter.getOffset() - initialOffset) > 0) {
-      const decoderSpecificConfig = parseDecoderSpecificConfig(iterator, logLevel);
+      const decoderSpecificConfig = parseDecoderSpecificConfig(iterator);
       decoderSpecificConfigs.push(decoderSpecificConfig);
     }
     return {
@@ -5393,13 +5965,12 @@ var processDescriptor = ({
     descriptor: null
   };
 };
-var parseDescriptors = (iterator, maxBytes, logLevel) => {
+var parseDescriptors = (iterator, maxBytes) => {
   const descriptors = [];
   const initialOffset = iterator.counter.getOffset();
   while (iterator.bytesRemaining() > 0 && iterator.counter.getOffset() - initialOffset < maxBytes) {
     const { descriptor } = processDescriptor({
-      iterator,
-      logLevel
+      iterator
     });
     if (descriptor) {
       descriptors.push(descriptor);
@@ -5414,8 +5985,7 @@ var parseDescriptors = (iterator, maxBytes, logLevel) => {
 var parseEsds = ({
   data,
   size,
-  fileOffset,
-  logLevel
+  fileOffset
 }) => {
   const version = data.getUint8();
   data.discard(3);
@@ -5424,7 +5994,7 @@ var parseEsds = ({
   const esId = data.getUint16();
   data.discard(1);
   const remaining = size - (data.counter.getOffset() - fileOffset);
-  const descriptors = parseDescriptors(data, remaining, logLevel);
+  const descriptors = parseDescriptors(data, remaining);
   const remainingNow = size - (data.counter.getOffset() - fileOffset);
   data.discard(remainingNow);
   return {
@@ -5471,7 +6041,10 @@ var parseMdat = async ({
   signal,
   maySkipSampleProcessing
 }) => {
-  const alreadyHas = hasTracks(existingBoxes);
+  const alreadyHas = hasTracks({
+    type: "iso-base-media",
+    boxes: existingBoxes
+  }, options.parserState);
   if (!alreadyHas) {
     if (maySkipSampleProcessing) {
       data.discard(size - (data.counter.getOffset() - fileOffset));
@@ -5491,7 +6064,7 @@ var parseMdat = async ({
       fileOffset
     });
   }
-  const tracks2 = getTracks(existingBoxes, options.parserState);
+  const tracks2 = getTracks({ type: "iso-base-media", boxes: existingBoxes }, options.parserState);
   const allTracks = [
     ...tracks2.videoTracks,
     ...tracks2.audioTracks,
@@ -5610,7 +6183,7 @@ var parseMoov = async ({
   signal,
   logLevel
 }) => {
-  const children = await parseBoxes({
+  const children = await parseIsoBaseMediaBoxes({
     iterator,
     maxBytes: size - (iterator.counter.getOffset() - offset),
     allowIncompleteBoxes: false,
@@ -5627,7 +6200,7 @@ var parseMoov = async ({
     offset,
     boxSize: size,
     type: "moov-box",
-    children: children.segments
+    children: children.segments.boxes
   };
 };
 
@@ -5932,7 +6505,7 @@ var parseMebx = async ({
 }) => {
   iterator.discard(6);
   const dataReferenceIndex = iterator.getUint16();
-  const children = await parseBoxes({
+  const children = await parseIsoBaseMediaBoxes({
     iterator,
     maxBytes: iterator.counter.getOffset() - offset,
     allowIncompleteBoxes: false,
@@ -5951,7 +6524,7 @@ var parseMebx = async ({
     offset,
     dataReferenceIndex,
     format: "mebx",
-    children: children.segments
+    children: children.segments.boxes
   };
 };
 
@@ -6085,6 +6658,7 @@ var audioTags = [
   "MAC6 ",
   "ima4",
   "fl32",
+  "lpcm",
   "fl64",
   "in24",
   "in32",
@@ -6142,7 +6716,7 @@ var processSample = async ({
       const packetSize = iterator.getUint16();
       const sampleRate = iterator.getFixedPointUnsigned1616Number();
       const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-      const children = await parseBoxes({
+      const children = await parseIsoBaseMediaBoxes({
         iterator,
         allowIncompleteBoxes: false,
         maxBytes: bytesRemainingInBox,
@@ -6174,7 +6748,7 @@ var processSample = async ({
           bytesPerPacket: null,
           bytesPerFrame: null,
           bitsPerSample: null,
-          children: children.segments
+          children: children.segments.boxes
         }
       };
     }
@@ -6189,7 +6763,7 @@ var processSample = async ({
       const bytesPerFrame = iterator.getUint32();
       const bytesPerSample = iterator.getUint32();
       const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-      const children = await parseBoxes({
+      const children = await parseIsoBaseMediaBoxes({
         iterator,
         allowIncompleteBoxes: false,
         maxBytes: bytesRemainingInBox,
@@ -6221,26 +6795,26 @@ var processSample = async ({
           bytesPerPacket,
           bytesPerFrame,
           bitsPerSample: bytesPerSample,
-          children: children.segments
+          children: children.segments.boxes
         }
       };
     }
     if (version === 2) {
-      const numberOfChannels = iterator.getUint16();
+      iterator.getUint16();
       const sampleSize = iterator.getUint16();
       const compressionId = iterator.getUint16();
       const packetSize = iterator.getUint16();
       iterator.getFixedPointUnsigned1616Number();
       iterator.getUint32();
       const higherSampleRate = iterator.getFloat64();
+      const numAudioChannel = iterator.getUint32();
       iterator.getUint32();
-      iterator.getUint32();
-      const bitsPerCodedSample = iterator.getUint32();
+      const bitsPerChannel = iterator.getUint32();
       iterator.getUint32();
       const bytesPerFrame = iterator.getUint32();
       const samplesPerPacket = iterator.getUint32();
       const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-      const children = await parseBoxes({
+      const children = await parseIsoBaseMediaBoxes({
         iterator,
         allowIncompleteBoxes: false,
         maxBytes: bytesRemainingInBox,
@@ -6263,7 +6837,7 @@ var processSample = async ({
           vendor: [...Array.from(new Uint8Array(vendor))],
           size: boxSize,
           type: "audio",
-          numberOfChannels,
+          numberOfChannels: numAudioChannel,
           sampleSize,
           compressionId,
           packetSize,
@@ -6271,8 +6845,8 @@ var processSample = async ({
           samplesPerPacket,
           bytesPerPacket: null,
           bytesPerFrame,
-          bitsPerSample: bitsPerCodedSample,
-          children: children.segments
+          bitsPerSample: bitsPerChannel,
+          children: children.segments.boxes
         }
       };
     }
@@ -6294,7 +6868,7 @@ var processSample = async ({
     const depth = iterator.getUint16();
     const colorTableId = iterator.getInt16();
     const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-    const children = bytesRemainingInBox > 8 ? await parseBoxes({
+    const children = bytesRemainingInBox > 8 ? await parseIsoBaseMediaBoxes({
       iterator,
       allowIncompleteBoxes: false,
       maxBytes: bytesRemainingInBox,
@@ -6303,7 +6877,7 @@ var processSample = async ({
       continueMdat: false,
       signal,
       logLevel
-    }) : (iterator.discard(bytesRemainingInBox), { status: "done", segments: [] });
+    }) : (iterator.discard(bytesRemainingInBox), { status: "done", segments: { boxes: [], type: "iso-base-media" } });
     if (children.status === "incomplete") {
       throw new Error("Incomplete boxes are not allowed");
     }
@@ -6328,7 +6902,7 @@ var processSample = async ({
         compressorName,
         depth,
         colorTableId,
-        descriptors: children.segments
+        descriptors: children.segments.boxes
       }
     };
   }
@@ -6650,7 +7224,7 @@ var parseTrak = async ({
   signal,
   logLevel
 }) => {
-  const children = await parseBoxes({
+  const children = await parseIsoBaseMediaBoxes({
     iterator: data,
     maxBytes: size - (data.counter.getOffset() - offsetAtStart),
     allowIncompleteBoxes: false,
@@ -6667,7 +7241,7 @@ var parseTrak = async ({
     offset: offsetAtStart,
     boxSize: size,
     type: "trak-box",
-    children: children.segments
+    children: children.segments.boxes
   };
 };
 
@@ -6724,7 +7298,7 @@ var getChildren = async ({
 }) => {
   const parseChildren = boxType === "mdia" || boxType === "minf" || boxType === "stbl" || boxType === "moof" || boxType === "dims" || boxType === "wave" || boxType === "traf" || boxType === "stsb";
   if (parseChildren) {
-    const parsed = await parseBoxes({
+    const parsed = await parseIsoBaseMediaBoxes({
       iterator,
       maxBytes: bytesRemainingInBox,
       allowIncompleteBoxes: false,
@@ -6737,7 +7311,7 @@ var getChildren = async ({
     if (parsed.status === "incomplete") {
       throw new Error("Incomplete boxes are not allowed");
     }
-    return parsed.segments;
+    return parsed.segments.boxes;
   }
   if (bytesRemainingInBox < 0) {
     throw new Error("Box size is too big " + JSON.stringify({ boxType }));
@@ -6811,7 +7385,7 @@ var processBox = async ({
   const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber() : boxSizeRaw;
   if (bytesRemaining < boxSize) {
     if (boxType === "mdat") {
-      const shouldSkip = (options.canSkipVideoData || !hasTracks(parsedBoxes)) && options.supportsContentRange;
+      const shouldSkip = (options.canSkipVideoData || !hasTracks({ type: "iso-base-media", boxes: parsedBoxes }, options.parserState)) && options.supportsContentRange;
       if (shouldSkip) {
         const skipTo = fileOffset + boxSize;
         const bytesToSkip = skipTo - iterator.counter.getOffset();
@@ -7040,14 +7614,11 @@ var processBox = async ({
     });
     const transformedTrack = makeBaseMediaTrack(box);
     if (transformedTrack) {
-      if (transformedTrack.type === "audio") {
-        const callback = await options.onAudioTrack?.(transformedTrack);
-        await options.parserState.registerAudioSampleCallback(transformedTrack.trackId, callback ?? null);
-      }
-      if (transformedTrack.type === "video") {
-        const callback = await options.onVideoTrack?.(transformedTrack);
-        await options.parserState.registerVideoSampleCallback(transformedTrack.trackId, callback ?? null);
-      }
+      await registerTrack({
+        options,
+        state: options.parserState,
+        track: transformedTrack
+      });
     }
     return {
       type: "complete",
@@ -7136,8 +7707,7 @@ var processBox = async ({
     const box = parseEsds({
       data: iterator,
       size: boxSize,
-      fileOffset,
-      logLevel
+      fileOffset
     });
     return {
       type: "complete",
@@ -7188,7 +7758,7 @@ var processBox = async ({
     skipTo: null
   };
 };
-var parseBoxes = async ({
+var parseIsoBaseMediaBoxes = async ({
   iterator,
   maxBytes,
   allowIncompleteBoxes,
@@ -7198,9 +7768,12 @@ var parseBoxes = async ({
   signal,
   logLevel
 }) => {
-  let boxes = initialBoxes;
+  const structure = {
+    type: "iso-base-media",
+    boxes: initialBoxes
+  };
   const initialOffset = iterator.counter.getOffset();
-  const alreadyHasMdat = boxes.find((b) => b.type === "mdat-box");
+  const alreadyHasMdat = structure.boxes.find((b) => b.type === "mdat-box");
   while (iterator.bytesRemaining() > 0 && iterator.counter.getOffset() - initialOffset < maxBytes) {
     const result = continueMdat ? await parseMdatPartially({
       iterator,
@@ -7223,13 +7796,13 @@ var parseBoxes = async ({
       }
       return {
         status: "incomplete",
-        segments: boxes,
+        segments: structure,
         continueParsing: () => {
-          return parseBoxes({
+          return parseIsoBaseMediaBoxes({
             iterator,
             maxBytes,
             allowIncompleteBoxes,
-            initialBoxes: boxes,
+            initialBoxes: structure.boxes,
             options,
             continueMdat: false,
             signal,
@@ -7242,13 +7815,13 @@ var parseBoxes = async ({
     if (result.type === "partial-mdat-box") {
       return {
         status: "incomplete",
-        segments: boxes,
+        segments: structure,
         continueParsing: () => {
-          return Promise.resolve(parseBoxes({
+          return Promise.resolve(parseIsoBaseMediaBoxes({
             iterator,
             maxBytes,
             allowIncompleteBoxes,
-            initialBoxes: boxes,
+            initialBoxes: structure.boxes,
             options,
             continueMdat: result,
             signal,
@@ -7259,15 +7832,15 @@ var parseBoxes = async ({
       };
     }
     if (result.box.type === "mdat-box" && alreadyHasMdat) {
-      boxes = boxes.filter((b) => b.type !== "mdat-box");
-      boxes.push(result.box);
+      structure.boxes = structure.boxes.filter((b) => b.type !== "mdat-box");
+      structure.boxes.push(result.box);
       iterator.allowDiscard();
       if (result.box.status !== "samples-processed") {
         throw new Error("unexpected");
       }
       break;
     } else {
-      boxes.push(result.box);
+      structure.boxes.push(result.box);
     }
     if (result.skipTo !== null) {
       if (!options.supportsContentRange) {
@@ -7275,13 +7848,13 @@ var parseBoxes = async ({
       }
       return {
         status: "incomplete",
-        segments: boxes,
+        segments: structure,
         continueParsing: () => {
-          return parseBoxes({
+          return parseIsoBaseMediaBoxes({
             iterator,
             maxBytes,
             allowIncompleteBoxes,
-            initialBoxes: boxes,
+            initialBoxes: structure.boxes,
             options,
             continueMdat: false,
             signal,
@@ -7294,13 +7867,13 @@ var parseBoxes = async ({
     if (iterator.bytesRemaining() < 0) {
       return {
         status: "incomplete",
-        segments: boxes,
+        segments: structure,
         continueParsing: () => {
-          return parseBoxes({
+          return parseIsoBaseMediaBoxes({
             iterator,
             maxBytes,
             allowIncompleteBoxes,
-            initialBoxes: boxes,
+            initialBoxes: structure.boxes,
             options,
             continueMdat: false,
             signal,
@@ -7312,22 +7885,22 @@ var parseBoxes = async ({
     }
     iterator.removeBytesRead();
   }
-  const mdatState = getMdatBox(boxes);
+  const mdatState = getMdatBox(structure.boxes);
   const skipped = mdatState?.status === "samples-skipped" && !options.canSkipVideoData && options.supportsContentRange;
   const buffered = mdatState?.status === "samples-buffered" && !options.canSkipVideoData;
   if (skipped || buffered) {
     return {
       status: "incomplete",
-      segments: boxes,
+      segments: structure,
       continueParsing: () => {
         if (buffered) {
           iterator.skipTo(mdatState.fileOffset, false);
         }
-        return parseBoxes({
+        return parseIsoBaseMediaBoxes({
           iterator,
           maxBytes,
           allowIncompleteBoxes: false,
-          initialBoxes: boxes,
+          initialBoxes: structure.boxes,
           options,
           continueMdat: false,
           signal,
@@ -7339,24 +7912,651 @@ var parseBoxes = async ({
   }
   return {
     status: "done",
-    segments: boxes
+    segments: structure
   };
 };
 
-// src/add-new-matroska-tracks.ts
-var registerTrack = async ({
-  state,
+// src/boxes/riff/is-movi.ts
+var isMoviAtom = (iterator, ckId) => {
+  if (ckId !== "LIST") {
+    return false;
+  }
+  const listType = iterator.getByteString(4);
+  iterator.counter.decrement(4);
+  return listType === "movi";
+};
+
+// src/boxes/avc/parse-avc.ts
+var readSps = (iterator) => {
+  const profile = iterator.getUint8();
+  const compatibility = iterator.getUint8();
+  const level = iterator.getUint8();
+  return {
+    profile,
+    compatibility,
+    level
+  };
+};
+var findEnd = (buffer) => {
+  let zeroesInARow = 0;
+  for (let i = 0;i < buffer.length; i++) {
+    const val = buffer[i];
+    if (val === 0) {
+      zeroesInARow++;
+      continue;
+    }
+    if (zeroesInARow >= 2 && val === 1) {
+      return i - zeroesInARow;
+    }
+    zeroesInARow = 0;
+  }
+  return null;
+};
+var inspect = (buffer) => {
+  const iterator = getArrayBufferIterator(buffer, buffer.byteLength);
+  iterator.startReadingBits();
+  iterator.getBits(1);
+  iterator.getBits(2);
+  const type = iterator.getBits(5);
+  iterator.stopReadingBits();
+  if (type === 7) {
+    const end = findEnd(buffer);
+    const data = readSps(iterator);
+    const sps = buffer.slice(1, end === null ? Infinity : end);
+    return {
+      level: data.level,
+      profile: data.profile,
+      compatibility: data.compatibility,
+      sps,
+      type: "avc-profile"
+    };
+  }
+  if (type === 5) {
+    return {
+      type: "keyframe"
+    };
+  }
+  if (type === 8) {
+    const end = findEnd(buffer);
+    const pps = buffer.slice(0, end === null ? Infinity : end);
+    return {
+      type: "avc-pps",
+      pps
+    };
+  }
+  if (type === 1) {
+    return {
+      type: "delta-frame"
+    };
+  }
+  iterator.destroy();
+  return null;
+};
+var parseAvc = (buffer) => {
+  let zeroesInARow = 0;
+  const infos = [];
+  for (let i = 0;i < buffer.length; i++) {
+    const val = buffer[i];
+    if (val === 0) {
+      zeroesInARow++;
+      continue;
+    }
+    if (zeroesInARow >= 2 && val === 1) {
+      zeroesInARow = 0;
+      const info = inspect(buffer.slice(i + 1, i + 100));
+      if (info) {
+        infos.push(info);
+        if (info.type === "keyframe" || info.type === "delta-frame") {
+          break;
+        }
+      }
+    }
+    if (val !== 1) {
+      zeroesInARow = 0;
+    }
+  }
+  return infos;
+};
+
+// src/boxes/riff/parse-movi.ts
+var getStrhForIndex = (structure, trackId) => {
+  const boxes = getStrlBoxes(structure);
+  const box = boxes[trackId];
+  if (!box) {
+    throw new Error("Expected box");
+  }
+  const strh = getStrhBox(box.children);
+  if (!strh) {
+    throw new Error("strh");
+  }
+  return strh;
+};
+var handleChunk = async ({
+  iterator,
   options,
-  track
+  structure,
+  ckId,
+  ckSize
 }) => {
-  if (track.type === "video" && options.onVideoTrack) {
-    const callback = await options.onVideoTrack(track);
-    await state.registerVideoSampleCallback(track.trackId, callback ?? null);
+  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 timeInSec = nthSample / samplesPerSecond;
+    const timestamp = Math.floor(timeInSec * MEDIA_PARSER_RIFF_TIMESCALE);
+    const duration2 = Math.floor(1 / samplesPerSecond * MEDIA_PARSER_RIFF_TIMESCALE);
+    const data = iterator.getSlice(ckSize);
+    const infos = parseAvc(data);
+    const keyOrDelta = infos.find((i) => i.type === "keyframe" || i.type === "delta-frame");
+    if (!keyOrDelta) {
+      throw new Error("expected avc to contain info about key or delta");
+    }
+    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 });
+    }
+    await options.parserState.onVideoSample(trackId, {
+      cts: timestamp,
+      dts: timestamp,
+      data,
+      duration: duration2,
+      timestamp,
+      trackId,
+      type: keyOrDelta.type === "keyframe" ? "key" : "delta"
+    });
+  } else {
+    const audioChunk = ckId.match(/^([0-9]{2})wb$/);
+    if (audioChunk) {
+      const trackId = parseInt(audioChunk[1], 10);
+      const strh = getStrhForIndex(structure, trackId);
+      const samplesPerSecond = strh.rate / strh.scale;
+      const nthSample = options.parserState.getSamplesForTrack(trackId);
+      const timeInSec = nthSample / samplesPerSecond;
+      const timestamp = timeInSec * MEDIA_PARSER_RIFF_TIMESCALE;
+      const duration2 = 1 / samplesPerSecond * MEDIA_PARSER_RIFF_TIMESCALE;
+      await options.parserState.onAudioSample(trackId, {
+        cts: timestamp,
+        dts: timestamp,
+        data: iterator.getSlice(ckSize),
+        duration: duration2,
+        timestamp,
+        trackId,
+        type: "key"
+      });
+    }
   }
-  if (track.type === "audio" && options.onAudioTrack) {
-    const callback = await options.onAudioTrack(track);
-    await state.registerAudioSampleCallback(track.trackId, callback ?? null);
+};
+var parseMovi = async ({
+  iterator,
+  maxOffset,
+  options,
+  structure
+}) => {
+  while (iterator.counter.getOffset() < maxOffset) {
+    if (iterator.bytesRemaining() < 8) {
+      return {
+        type: "incomplete",
+        continueParsing: () => {
+          return Promise.resolve(parseMovi({ iterator, maxOffset, options, structure }));
+        }
+      };
+    }
+    const ckId = iterator.getByteString(4);
+    const ckSize = iterator.getUint32Le();
+    if (iterator.bytesRemaining() < ckSize) {
+      iterator.counter.decrement(8);
+      return {
+        type: "incomplete",
+        continueParsing: () => {
+          return Promise.resolve(parseMovi({ iterator, maxOffset, options, structure }));
+        }
+      };
+    }
+    await handleChunk({ iterator, options, structure, ckId, ckSize });
+    while (iterator.counter.getOffset() < maxOffset && iterator.bytesRemaining() > 0) {
+      if (iterator.getUint8() !== 0) {
+        iterator.counter.decrement(1);
+        break;
+      }
+    }
+  }
+  if (iterator.counter.getOffset() === maxOffset) {
+    return {
+      type: "complete",
+      box: {
+        type: "movi-box"
+      }
+    };
+  }
+  if (iterator.counter.getOffset() > maxOffset) {
+    throw new Error("Oops, this should not happen!");
+  }
+  return {
+    type: "incomplete",
+    continueParsing: () => {
+      return Promise.resolve(parseMovi({ iterator, maxOffset, options, structure }));
+    }
+  };
+};
+
+// src/boxes/riff/parse-avih.ts
+var parseAvih = ({
+  iterator,
+  size
+}) => {
+  const { expectNoMoreBytes } = iterator.startBox(size);
+  const dwMicroSecPerFrame = iterator.getUint32Le();
+  const dwMaxBytesPerSec = iterator.getUint32Le();
+  const paddingGranularity = iterator.getUint32Le();
+  const flags = iterator.getUint32Le();
+  const totalFrames = iterator.getUint32Le();
+  const initialFrames = iterator.getUint32Le();
+  const streams = iterator.getUint32Le();
+  const suggestedBufferSize = iterator.getUint32Le();
+  const width = iterator.getUint32Le();
+  const height = iterator.getUint32Le();
+  iterator.discard(16);
+  expectNoMoreBytes();
+  return {
+    type: "avih-box",
+    microSecPerFrame: dwMicroSecPerFrame,
+    maxBytesPerSecond: dwMaxBytesPerSec,
+    paddingGranularity,
+    flags,
+    totalFrames,
+    initialFrames,
+    streams,
+    suggestedBufferSize,
+    height,
+    width
+  };
+};
+
+// src/boxes/riff/parse-fmt-box.ts
+var parseFmtBox = ({
+  iterator,
+  boxes,
+  size
+}) => {
+  const box = iterator.startBox(size);
+  const header = boxes.find((b) => b.type === "riff-header");
+  if (!header) {
+    throw new Error("Expected RIFF header");
+  }
+  if (header.fileType !== "WAVE") {
+    throw new Error("Only supporting WAVE type");
+  }
+  const wFormatTag = iterator.getUint16Le();
+  if (wFormatTag !== 1) {
+    throw new Error("Expected wFormatTag to be 1, only supporting this");
+  }
+  const numberOfChannels = iterator.getUint16Le();
+  const sampleRate = iterator.getUint32Le();
+  const byteRate = iterator.getUint32Le();
+  const blockAlign = iterator.getUint16Le();
+  const bitsPerSample = iterator.getUint16Le();
+  box.expectNoMoreBytes();
+  return {
+    type: "wave-format-box",
+    formatTag: wFormatTag,
+    numberOfChannels,
+    sampleRate,
+    blockAlign,
+    byteRate,
+    bitsPerSample
+  };
+};
+
+// src/boxes/riff/parse-list-box.ts
+var parseListBox = async ({
+  iterator,
+  size,
+  options
+}) => {
+  const counter = iterator.counter.getOffset();
+  const listType = iterator.getByteString(4);
+  if (listType === "movi") {
+    throw new Error("should not be handled here");
+  }
+  const structure = {
+    type: "riff",
+    boxes: []
+  };
+  const result = await parseRiffBody({
+    structure,
+    iterator,
+    maxOffset: counter + size,
+    options
+  });
+  if (result.status === "incomplete") {
+    throw new Error(`Should only parse complete boxes (${listType})`);
+  }
+  return {
+    type: "list-box",
+    listType,
+    children: structure.boxes
+  };
+};
+
+// src/boxes/riff/parse-strf.ts
+var parseStrfAudio = ({
+  iterator,
+  size
+}) => {
+  const box = iterator.startBox(size);
+  const formatTag = iterator.getUint16Le();
+  const numberOfChannels = iterator.getUint16Le();
+  const samplesPerSec = iterator.getUint32Le();
+  const avgBytesPerSec = iterator.getUint32Le();
+  const blockAlign = iterator.getUint16Le();
+  const bitsPerSample = iterator.getUint16Le();
+  const cbSize = iterator.getUint16Le();
+  box.expectNoMoreBytes();
+  return {
+    type: "strf-box-audio",
+    avgBytesPerSecond: avgBytesPerSec,
+    bitsPerSample,
+    blockAlign,
+    cbSize,
+    formatTag,
+    numberOfChannels,
+    sampleRate: samplesPerSec
+  };
+};
+var parseStrfVideo = ({
+  iterator,
+  size
+}) => {
+  const box = iterator.startBox(size);
+  const biSize = iterator.getUint32Le();
+  const width = iterator.getInt32Le();
+  const height = iterator.getInt32Le();
+  const planes = iterator.getUint16Le();
+  const bitCount = iterator.getUint16Le();
+  const compression = iterator.getByteString(4);
+  const sizeImage = iterator.getUint32Le();
+  const xPelsPerMeter = iterator.getInt32Le();
+  const yPelsPerMeter = iterator.getInt32Le();
+  const clrUsed = iterator.getUint32Le();
+  const clrImportant = iterator.getUint32Le();
+  box.expectNoMoreBytes();
+  return {
+    type: "strf-box-video",
+    biSize,
+    bitCount,
+    clrImportant,
+    clrUsed,
+    compression,
+    height,
+    planes,
+    sizeImage,
+    width,
+    xPelsPerMeter,
+    yPelsPerMeter
+  };
+};
+var parseStrf = ({
+  iterator,
+  size,
+  boxes
+}) => {
+  const strh = boxes.find((b) => b.type === "strh-box");
+  if (!strh) {
+    throw new Error("strh box not found");
+  }
+  if (strh.fccType === "vids") {
+    return parseStrfVideo({ iterator, size });
+  }
+  if (strh.fccType === "auds") {
+    return parseStrfAudio({ iterator, size });
+  }
+  throw new Error(`Unsupported fccType: ${strh.fccType}`);
+};
+
+// src/boxes/riff/parse-strh.ts
+var parseStrh = ({
+  iterator,
+  size
+}) => {
+  const box = iterator.startBox(size);
+  const fccType = iterator.getByteString(4);
+  if (fccType !== "vids" && fccType !== "auds") {
+    throw new Error("Expected AVI handler to be vids / auds");
+  }
+  const handler = fccType === "vids" ? iterator.getByteString(4) : iterator.getUint32Le();
+  if (typeof handler === "string" && handler !== "H264") {
+    throw new Error(`Only H264 is supported as a stream type in .avi, got ${handler}`);
+  }
+  if (fccType === "auds" && handler !== 1) {
+    throw new Error(`Only "1" is supported as a stream type in .avi, got ${handler}`);
+  }
+  const flags = iterator.getUint32Le();
+  const priority = iterator.getUint16Le();
+  const language2 = iterator.getUint16Le();
+  const initialFrames = iterator.getUint32Le();
+  const scale = iterator.getUint32Le();
+  const rate = iterator.getUint32Le();
+  const start = iterator.getUint32Le();
+  const length = iterator.getUint32Le();
+  const suggestedBufferSize = iterator.getUint32Le();
+  const quality = iterator.getUint32Le();
+  const sampleSize = iterator.getUint32Le();
+  box.discardRest();
+  return {
+    type: "strh-box",
+    fccType,
+    handler,
+    flags,
+    priority,
+    initialFrames,
+    length,
+    quality,
+    rate,
+    sampleSize,
+    scale,
+    start,
+    suggestedBufferSize,
+    language: language2
+  };
+};
+
+// src/boxes/riff/parse-riff-box.ts
+var parseRiffBox = ({
+  iterator,
+  size,
+  id,
+  boxes,
+  options
+}) => {
+  if (id === "fmt") {
+    return Promise.resolve(parseFmtBox({ iterator, boxes, size }));
+  }
+  if (id === "LIST") {
+    return parseListBox({ iterator, size, options });
+  }
+  if (id === "avih") {
+    return Promise.resolve(parseAvih({ iterator, size }));
+  }
+  if (id === "strh") {
+    return Promise.resolve(parseStrh({ iterator, size }));
+  }
+  if (id === "strf") {
+    return Promise.resolve(parseStrf({ iterator, size, boxes }));
+  }
+  iterator.discard(size);
+  const box = {
+    type: "riff-box",
+    size,
+    id
+  };
+  return Promise.resolve(box);
+};
+
+// src/boxes/riff/expect-riff-box.ts
+var expectRiffBox = async ({
+  iterator,
+  options,
+  structure
+}) => {
+  if (iterator.bytesRemaining() < 16) {
+    return {
+      type: "incomplete",
+      continueParsing() {
+        return expectRiffBox({ structure, iterator, options });
+      }
+    };
+  }
+  const ckId = iterator.getByteString(4);
+  const ckSize = iterator.getUint32Le();
+  if (isMoviAtom(iterator, ckId)) {
+    iterator.discard(4);
+    return parseMovi({
+      iterator,
+      maxOffset: ckSize + iterator.counter.getOffset() - 4,
+      options,
+      structure
+    });
+  }
+  if (iterator.bytesRemaining() < ckSize) {
+    iterator.counter.decrement(8);
+    return {
+      type: "incomplete",
+      continueParsing: () => {
+        return expectRiffBox({ structure, iterator, options });
+      }
+    };
+  }
+  return {
+    type: "complete",
+    box: await parseRiffBox({
+      id: ckId,
+      iterator,
+      size: ckSize,
+      boxes: structure.boxes,
+      options
+    })
+  };
+};
+
+// src/boxes/riff/parse-box.ts
+var continueAfterRiffBoxResult = ({
+  result,
+  structure,
+  iterator,
+  maxOffset,
+  options
+}) => {
+  if (result.type === "incomplete") {
+    return Promise.resolve({
+      status: "incomplete",
+      async continueParsing() {
+        return Promise.resolve(continueAfterRiffBoxResult({
+          result: await result.continueParsing(),
+          structure,
+          iterator,
+          maxOffset,
+          options
+        }));
+      },
+      segments: structure,
+      skipTo: null
+    });
+  }
+  if (result.type === "complete") {
+    if (result.box) {
+      structure.boxes.push(result.box);
+    }
+  }
+  return parseRiffBody({ iterator, maxOffset, options, structure });
+};
+var parseRiffBody = async ({
+  iterator,
+  structure,
+  maxOffset,
+  options
+}) => {
+  while (iterator.bytesRemaining() > 0 && iterator.counter.getOffset() < maxOffset) {
+    const result = await expectRiffBox({
+      iterator,
+      options,
+      structure
+    });
+    if (result.type === "incomplete") {
+      return {
+        status: "incomplete",
+        async continueParsing() {
+          return Promise.resolve(continueAfterRiffBoxResult({
+            iterator,
+            maxOffset,
+            options,
+            result: await result.continueParsing(),
+            structure
+          }));
+        },
+        segments: structure,
+        skipTo: null
+      };
+    }
+    if (result.box === null) {
+      continue;
+    }
+    structure.boxes.push(result.box);
+    if (result.box.type === "strf-box-video" || result.box.type === "strf-box-audio") {
+      const strh = getStrhBox(structure.boxes);
+      const strf = getStrfBox(structure.boxes);
+      if (!strh || !strf) {
+        throw new Error("strh or strf box missing");
+      }
+      if (strf.type === "strf-box-audio" && options.onAudioTrack) {
+        const audioTrack = makeAviAudioTrack({
+          index: options.nextTrackIndex,
+          strf
+        });
+        await registerTrack({
+          options,
+          state: options.parserState,
+          track: audioTrack
+        });
+      }
+      if (options.onVideoTrack && strf.type === "strf-box-video") {
+        const videoTrack = makeAviVideoTrack({
+          strh,
+          index: options.nextTrackIndex,
+          strf
+        });
+        registerVideoTrackWhenProfileIsAvailable({
+          options,
+          state: options.parserState,
+          track: videoTrack
+        });
+      }
+      options.nextTrackIndex++;
+    }
+  }
+  return {
+    status: "done",
+    segments: structure
+  };
+};
+var parseRiff = ({
+  iterator,
+  options
+}) => {
+  const structure = { type: "riff", boxes: [] };
+  const riff = iterator.getByteString(4);
+  if (riff !== "RIFF") {
+    throw new Error("Not a RIFF file");
   }
+  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 });
+  return parseRiffBody({ iterator, structure, maxOffset: Infinity, options });
 };
 
 // src/boxes/webm/segments/block-simple-block-flags.ts
@@ -7904,33 +9104,33 @@ var expectChildren = async ({
 };
 
 // src/boxes/webm/parse-webm-header.ts
-var continueAfterMatroskaResult = (result, children) => {
+var continueAfterMatroskaResult = (result, structure) => {
   if (result.status === "done") {
     return {
       status: "done",
-      segments: children
+      segments: structure
     };
   }
   return {
     status: "incomplete",
-    segments: children,
+    segments: structure,
     continueParsing: async () => {
       const newResult = await result.continueParsing();
-      return continueAfterMatroskaResult(newResult, children);
+      return continueAfterMatroskaResult(newResult, structure);
     },
     skipTo: null
   };
 };
 var parseWebm = async (counter, parserContext) => {
-  const children = [];
+  const structure = { type: "matroska", boxes: [] };
   const results = await expectChildren({
     iterator: counter,
     length: Infinity,
-    children,
+    children: structure.boxes,
     parserContext,
     startOffset: counter.counter.getOffset()
   });
-  return continueAfterMatroskaResult(results, children);
+  return continueAfterMatroskaResult(results, structure);
 };
 
 // src/parse-video.ts
@@ -7941,26 +9141,14 @@ var parseVideo = ({
   logLevel
 }) => {
   if (iterator.bytesRemaining() === 0) {
-    return Promise.resolve({
-      status: "incomplete",
-      segments: [],
-      continueParsing: () => {
-        return parseVideo({
-          iterator,
-          options,
-          signal,
-          logLevel
-        });
-      },
-      skipTo: null
-    });
+    return Promise.reject(new Error("no bytes"));
   }
   if (iterator.isRiff()) {
-    throw new Error("AVI files are not yet supported");
+    return Promise.resolve(parseRiff({ iterator, options }));
   }
   if (iterator.isIsoBaseMedia()) {
     Log.verbose(logLevel, "Detected ISO Base Media container");
-    return parseBoxes({
+    return parseIsoBaseMediaBoxes({
       iterator,
       maxBytes: Infinity,
       allowIncompleteBoxes: true,
@@ -7973,7 +9161,7 @@ var parseVideo = ({
   }
   if (iterator.isWebm()) {
     Log.verbose(logLevel, "Detected Matroska container");
-    return Promise.resolve(parseWebm(iterator, options));
+    return parseWebm(iterator, options);
   }
   if (iterator.isMp3()) {
     return Promise.reject(new Error("MP3 files are not yet supported"));
@@ -8038,8 +9226,23 @@ var makeParserState = ({
     }
     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;
+  };
   return {
     onTrackEntrySegment,
+    onProfile,
+    registerOnAvcProfileCallback,
     getTrackInfoByNumber: (id) => trackEntries[id],
     registerVideoSampleCallback: async (id, callback) => {
       if (callback === null) {
@@ -8071,6 +9274,10 @@ var makeParserState = ({
       if (signal?.aborted) {
         throw new Error("Aborted");
       }
+      if (typeof samplesForTrack[trackId] === "undefined") {
+        samplesForTrack[trackId] = 0;
+      }
+      samplesForTrack[trackId]++;
       const callback = audioSampleCallbacks[trackId];
       if (callback) {
         await callback(audioSample);
@@ -8087,6 +9294,10 @@ var makeParserState = ({
       if (signal?.aborted) {
         throw new Error("Aborted");
       }
+      if (typeof samplesForTrack[trackId] === "undefined") {
+        samplesForTrack[trackId] = 0;
+      }
+      samplesForTrack[trackId]++;
       const callback = videoSampleCallbacks[trackId];
       if (callback) {
         await callback(videoSample);
@@ -8101,7 +9312,13 @@ var makeParserState = ({
     },
     getInternalStats: () => ({}),
     getTimescale,
-    setTimescale
+    setTimescale,
+    getSamplesForTrack: (trackId) => {
+      return samplesForTrack[trackId] ?? 0;
+    },
+    getAvcProfile: () => {
+      return avcProfile;
+    }
   };
 };
 
@@ -8146,7 +9363,8 @@ var parseMedia = async ({
     onVideoTrack: onVideoTrack ?? null,
     parserState: state,
     nullifySamples: !(typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.KEEP_SAMPLES === "true"),
-    supportsContentRange
+    supportsContentRange,
+    nextTrackIndex: 0
   };
   const hasAllInfo = () => {
     if (parseResult === null) {
@@ -8201,7 +9419,7 @@ var parseMedia = async ({
     });
     triggerInfoEmit();
     if (parseResult && parseResult.status === "incomplete") {
-      Log.verbose(logLevel, "Continuing parsing of file, currently at position", iterator.counter.getOffset(), getAvailableInfo(fields ?? {}, parseResult, state));
+      Log.verbose(logLevel, "Continuing parsing of file, currently at position", iterator.counter.getOffset());
       parseResult = await parseResult.continueParsing();
     } else {
       parseResult = await parseVideo({
@@ -8242,13 +9460,18 @@ var parseMedia = async ({
   return returnValue;
 };
 // src/version.ts
-var VERSION = "4.0.231";
+var VERSION = "4.0.233";
 
 // src/index.ts
 var MediaParserInternals = {
   createMatroskaMedia,
   createIsoBaseMedia,
-  Log
+  createWav,
+  Log,
+  IoEventEmitter,
+  makeProgressTracker,
+  withResolvers,
+  withResolversAndWaitForReturn
 };
 export {
   parseMedia,