@remotion/media-parser 4.0.231 → 4.0.232

package/dist/esm/index.mjs

@@ -2117,10 +2117,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;
     }
   };
 };
@@ -3095,10 +3091,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 +3116,119 @@ var createMatroskaMedia = async ({
   };
 };
 
+// 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
+}) => {
+  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));
+      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);
+      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 +3394,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;
-    }
-    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;
-    }
+  const videoSample = stsd.samples.find((s) => s.type === "audio");
+  if (!videoSample || videoSample.type !== "audio") {
+    return false;
   }
-  return samples;
+  return true;
 };
-
-// src/samples-from-moof.ts
-var getSamplesFromTraf = (trafSegment, moofOffset) => {
-  if (trafSegment.type !== "regular-box" || trafSegment.boxType !== "traf") {
-    throw new Error("Expected traf-box");
+var trakBoxContainsVideo = (trakBox) => {
+  const stsd = getStsdBox(trakBox);
+  if (!stsd) {
+    return false;
   }
-  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;
-    }
+  const videoSample = stsd.samples.find((s) => s.type === "video");
+  if (!videoSample || videoSample.type !== "video") {
+    return false;
   }
-  return samples;
+  return true;
 };
-var getSamplesFromMoof = ({
-  moofBox,
-  trackId
-}) => {
-  if (moofBox.type !== "regular-box") {
-    throw new Error("Expected moof-box");
+var getTimescaleAndDuration = (trakBox) => {
+  const mdhdBox = getMdhdBox(trakBox);
+  if (mdhdBox) {
+    return { timescale: mdhdBox.timescale, duration: mdhdBox.duration };
   }
-  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);
+  return null;
 };
-
-// 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);
+var getFpsFromMp4TrakBox = (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 (!timescaleAndDuration) {
+    return null;
   }
+  const sttsBox = getSttsBox(trakBox);
   if (!sttsBox) {
-    throw new Error("Expected stts box in trak box");
-  }
-  if (!timescaleAndDuration) {
-    throw new Error("Expected timescale and duration in trak box");
+    return null;
   }
-  let samplePositions = getSamplePositions({
-    stcoBox,
-    stscBox,
-    stszBox,
-    stssBox,
+  return calculateFps({
     sttsBox,
-    cttsBox
+    timeScale: timescaleAndDuration.timescale,
+    durationInSamples: timescaleAndDuration.duration
   });
-  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") {
+var getFpsFromIsoMaseMedia = (structure) => {
+  const moovBox = getMoovBox(structure.boxes);
+  if (!moovBox) {
     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;
-  }
-  const moofBox = getMoofBox(boxes);
-  const mvhdBox = getMvhdBox(moovBox);
-  if (!mvhdBox) {
+  const trackBoxes = getTraks(moovBox);
+  const trackBox = trackBoxes.find(trakBoxContainsVideo);
+  if (!trackBox) {
     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;
+  return getFpsFromMp4TrakBox(trackBox);
 };
-var getTimescaleAndDuration = (trakBox) => {
-  const mdhdBox = getMdhdBox(trakBox);
-  if (mdhdBox) {
-    return { timescale: mdhdBox.timescale, duration: mdhdBox.duration };
+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");
+    }
+    if (strh.fccType === "auds") {
+      continue;
+    }
+    return strh.rate;
   }
   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;
+  if (segments.type === "iso-base-media") {
+    return getFpsFromIsoMaseMedia(segments);
   }
-  const trackBoxes = getTraks(moovBox);
-  const trackBox = trackBoxes.find(trakBoxContainsVideo);
-  if (!trackBox) {
+  if (segments.type === "riff") {
+    return getFpsFromAvi(segments);
+  }
+  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 +3545,8 @@ var getAudioCodec = (boxes, parserState) => {
   }
   return null;
 };
-var hasAudioCodec = (boxes) => {
-  return hasTracks(boxes);
+var hasAudioCodec = (boxes, state) => {
+  return hasTracks(boxes, state);
 };
 var getCodecSpecificatorFromEsdsBox = ({
   child
@@ -3987,6 +3908,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 +3956,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,6 +3966,18 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     counter.increment(8);
     return val;
   };
+  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);
@@ -4185,9 +4121,7 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     leb128,
     removeBytesRead,
     isWebm,
-    discard: (length) => {
-      counter.increment(length);
-    },
+    discard,
     getEightByteNumber,
     getFourByteNumber,
     getSlice,
@@ -4281,6 +4215,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 +4275,8 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     destroy,
     isMp3,
     disallowDiscard,
-    allowDiscard
+    allowDiscard,
+    startBox
   };
 };
 
@@ -4445,14 +4385,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 +4416,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);
@@ -4577,7 +4544,7 @@ var makeBaseMediaTrack = (trakBox) => {
       sampleRate,
       description,
       trakBox,
-      codecPrivate: getCodecPrivateFromTrak(trakBox),
+      codecPrivate: getCodecPrivateFromTrak(trakBox) ?? description ?? null,
       codecWithoutConfig: getAudioCodecFromTrack(trakBox)
     };
   }
@@ -4636,6 +4603,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();
@@ -5009,48 +5105,63 @@ var getTracksFromMatroska = (segment, timescale2) => {
 };
 
 // src/get-tracks.ts
-var getNumberOfTracks = (moovBox) => {
+var getNumberOfTracks2 = (moovBox) => {
   const mvHdBox = getMvhdBox(moovBox);
   if (!mvHdBox) {
     return 0;
   }
   return mvHdBox.nextTrackId - 1;
 };
-var hasTracks = (segments) => {
-  const mainSegment = getMainSegment(segments);
-  if (mainSegment) {
+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;
   }
-  const moovBox = getMoovBox(segments);
-  if (!moovBox) {
-    return false;
+  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;
   }
-  const numberOfTracks = getNumberOfTracks(moovBox);
-  const tracks2 = getTraks(moovBox);
-  return tracks2.length === numberOfTracks;
+  if (structure.type === "riff") {
+    return hasAllTracksFromAvi(structure, state);
+  }
+  throw new Error("Unknown container");
 };
-var getTracks = (segments, state) => {
+var getTracksFromMa = (segments, state) => {
   const videoTracks = [];
   const audioTracks = [];
   const otherTracks = [];
   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);
-      }
+  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
-    };
   }
+  return {
+    videoTracks,
+    audioTracks,
+    otherTracks
+  };
+};
+var getTracksFromIsoBaseMedia = (segments) => {
+  const videoTracks = [];
+  const audioTracks = [];
+  const otherTracks = [];
   const moovBox = getMoovBox(segments);
   if (!moovBox) {
     return {
@@ -5079,18 +5190,33 @@ var getTracks = (segments, state) => {
     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) => {
-  const moovBox = getMoovBox(segments);
-  if (moovBox) {
+  if (segments.type === "iso-base-media") {
     return "mp4";
   }
-  const mainSegment = getMainSegment(segments);
-  if (mainSegment) {
+  if (segments.type === "matroska") {
     return "webm";
   }
-  return null;
+  if (segments.type === "riff") {
+    if (isRiffAvi(segments)) {
+      return "avi";
+    }
+  }
+  throw new Error("Unknown container");
 };
 var hasContainer = (boxes) => {
   try {
@@ -5123,6 +5249,258 @@ var hasDimensions = (boxes, state) => {
   }
 };
 
+// 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/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;
+};
+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 getDurationFromIsoBaseMedia = (structure, parserState) => {
+  const moovBox = getMoovBox(structure.boxes);
+  if (!moovBox) {
+    return null;
+  }
+  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 Math.max(...lengths);
+};
+var getDuration = (structure, parserState) => {
+  if (structure.type === "matroska") {
+    return getDurationFromMatroska(structure.boxes);
+  }
+  if (structure.type === "iso-base-media") {
+    return getDurationFromIsoBaseMedia(structure, parserState);
+  }
+  if (structure.type === "riff") {
+    return getDurationFromAvi(structure);
+  }
+  throw new Error("Has no duration");
+};
+var hasDuration = (structure, parserState) => {
+  return hasTracks(structure, parserState);
+};
+
 // src/emit-available-info.ts
 var emitAvailableInfo = ({
   hasInfo,
@@ -5135,10 +5513,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;
     }
@@ -5254,7 +5632,7 @@ var emitAvailableInfo = ({
 var getAvailableInfo = (options, parseResult, state) => {
   const keys = Object.entries(options).filter(([, value]) => value);
   const infos = keys.map(([key]) => {
-    if (key === "boxes") {
+    if (key === "structure") {
       return Boolean(parseResult && parseResult.status === "done");
     }
     if (key === "durationInSeconds") {
@@ -5267,13 +5645,13 @@ var getAvailableInfo = (options, parseResult, state) => {
       return Boolean(parseResult && hasFps(parseResult.segments));
     }
     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,6 +5675,35 @@ 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) => {
   const layerTag = iterator.getUint8();
@@ -5471,7 +5878,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 +5901,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 +6020,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 +6037,7 @@ var parseMoov = async ({
     offset,
     boxSize: size,
     type: "moov-box",
-    children: children.segments
+    children: children.segments.boxes
   };
 };
 
@@ -5932,7 +6342,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 +6361,7 @@ var parseMebx = async ({
     offset,
     dataReferenceIndex,
     format: "mebx",
-    children: children.segments
+    children: children.segments.boxes
   };
 };
 
@@ -6142,7 +6552,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 +6584,7 @@ var processSample = async ({
           bytesPerPacket: null,
           bytesPerFrame: null,
           bitsPerSample: null,
-          children: children.segments
+          children: children.segments.boxes
         }
       };
     }
@@ -6189,7 +6599,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,7 +6631,7 @@ var processSample = async ({
           bytesPerPacket,
           bytesPerFrame,
           bitsPerSample: bytesPerSample,
-          children: children.segments
+          children: children.segments.boxes
         }
       };
     }
@@ -6240,7 +6650,7 @@ var processSample = async ({
       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,
@@ -6272,7 +6682,7 @@ var processSample = async ({
           bytesPerPacket: null,
           bytesPerFrame,
           bitsPerSample: bitsPerCodedSample,
-          children: children.segments
+          children: children.segments.boxes
         }
       };
     }
@@ -6294,7 +6704,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 +6713,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 +6738,7 @@ var processSample = async ({
         compressorName,
         depth,
         colorTableId,
-        descriptors: children.segments
+        descriptors: children.segments.boxes
       }
     };
   }
@@ -6650,7 +7060,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 +7077,7 @@ var parseTrak = async ({
     offset: offsetAtStart,
     boxSize: size,
     type: "trak-box",
-    children: children.segments
+    children: children.segments.boxes
   };
 };
 
@@ -6724,7 +7134,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 +7147,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 +7221,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 +7450,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",
@@ -7188,7 +7595,7 @@ var processBox = async ({
     skipTo: null
   };
 };
-var parseBoxes = async ({
+var parseIsoBaseMediaBoxes = async ({
   iterator,
   maxBytes,
   allowIncompleteBoxes,
@@ -7198,9 +7605,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 +7633,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 +7652,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 +7669,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 +7685,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 +7704,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 +7722,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 +7749,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 +8941,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 +8978,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 +8998,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 +9063,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 +9111,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 +9131,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 +9149,13 @@ var makeParserState = ({
     },
     getInternalStats: () => ({}),
     getTimescale,
-    setTimescale
+    setTimescale,
+    getSamplesForTrack: (trackId) => {
+      return samplesForTrack[trackId] ?? 0;
+    },
+    getAvcProfile: () => {
+      return avcProfile;
+    }
   };
 };
 
@@ -8146,7 +9200,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) {
@@ -8242,12 +9297,13 @@ var parseMedia = async ({
   return returnValue;
 };
 // src/version.ts
-var VERSION = "4.0.231";
+var VERSION = "4.0.232";
 
 // src/index.ts
 var MediaParserInternals = {
   createMatroskaMedia,
   createIsoBaseMedia,
+  createWav,
   Log
 };
 export {