@remotion/media-parser 4.0.230 → 4.0.232

package/dist/esm/index.mjs

@@ -1965,14 +1965,15 @@ var createIsoBaseMedia = async ({
   writer,
   onBytesProgress,
   onMillisecondsProgress,
-  logLevel
+  logLevel,
+  filename
 }) => {
   const header = createIsoBaseMediaFtyp({
     compatibleBrands: ["isom", "iso2", "avc1", "mp42"],
     majorBrand: "isom",
     minorBrand: 512
   });
-  const w = await writer.createContent();
+  const w = await writer.createContent({ filename, mimeType: "video/mp4" });
   await w.write(header);
   let durationInUnits = 0;
   const currentTracks = [];
@@ -2072,9 +2073,8 @@ var createIsoBaseMedia = async ({
   };
   const waitForFinishPromises = [];
   return {
-    save: async () => {
-      const file = await w.save();
-      return file;
+    save: () => {
+      return w.save();
     },
     remove: async () => {
       await w.remove();
@@ -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;
     }
   };
 };
@@ -2182,11 +2178,17 @@ var canFitInCluster = ({
   }
   return timecodeRelativeToCluster <= maxClusterTimestamp;
 };
-var makeCluster = async (w, clusterStartTimestamp, timescale) => {
+var makeCluster = async ({
+  writer,
+  clusterStartTimestamp,
+  timescale,
+  logLevel
+}) => {
+  Log.verbose(logLevel, `Making new Matroska cluster with timestamp ${clusterStartTimestamp}`);
   const cluster = createClusterSegment(timestampToClusterTimestamp(clusterStartTimestamp, timescale));
-  const clusterVIntPosition = w.getWrittenByteCount() + cluster.offsets.offset + matroskaToHex(matroskaElements.Cluster).byteLength;
+  const clusterVIntPosition = writer.getWrittenByteCount() + cluster.offsets.offset + matroskaToHex(matroskaElements.Cluster).byteLength;
   let clusterSize = cluster.bytes.byteLength - matroskaToHex(matroskaElements.Cluster).byteLength - CLUSTER_MIN_VINT_WIDTH;
-  await w.write(cluster.bytes);
+  await writer.write(cluster.bytes);
   const addSample = async (chunk, trackNumber2) => {
     const timecodeRelativeToCluster = timestampToClusterTimestamp(chunk.timestamp, timescale) - timestampToClusterTimestamp(clusterStartTimestamp, timescale);
     if (!canFitInCluster({ clusterStartTimestamp, chunk, timescale })) {
@@ -2202,8 +2204,8 @@ var makeCluster = async (w, clusterStartTimestamp, timescale) => {
       timecodeRelativeToCluster
     });
     clusterSize += simpleBlock2.byteLength;
-    await w.updateDataAt(clusterVIntPosition, getVariableInt(clusterSize, CLUSTER_MIN_VINT_WIDTH));
-    await w.write(simpleBlock2);
+    await writer.updateDataAt(clusterVIntPosition, getVariableInt(clusterSize, CLUSTER_MIN_VINT_WIDTH));
+    await writer.write(simpleBlock2);
     return { timecodeRelativeToCluster };
   };
   const shouldMakeNewCluster = ({
@@ -2219,6 +2221,7 @@ var makeCluster = async (w, clusterStartTimestamp, timescale) => {
       timescale
     });
     if (!canFit) {
+      Log.verbose(logLevel, `Cannot fit ${chunk.timestamp} in cluster ${clusterStartTimestamp}. Creating new cluster`);
       return true;
     }
     const keyframe = chunk.type === "key";
@@ -2938,10 +2941,12 @@ var timescale = 1e6;
 var createMatroskaMedia = async ({
   writer,
   onBytesProgress,
-  onMillisecondsProgress
+  onMillisecondsProgress,
+  filename,
+  logLevel
 }) => {
   const header = makeMatroskaHeader();
-  const w = await writer.createContent();
+  const w = await writer.createContent({ filename, mimeType: "video/webm" });
   await w.write(header.bytes);
   const matroskaInfo = makeMatroskaInfo({
     timescale
@@ -2993,7 +2998,12 @@ var createMatroskaMedia = async ({
   };
   await w.write(matroskaSegment.bytes);
   const clusterOffset = w.getWrittenByteCount();
-  let currentCluster = await makeCluster(w, 0, timescale);
+  let currentCluster = await makeCluster({
+    writer: w,
+    clusterStartTimestamp: 0,
+    timescale,
+    logLevel
+  });
   seeks.push({
     hexString: matroskaElements.Cluster,
     byte: clusterOffset - seekHeadOffset
@@ -3001,9 +3011,14 @@ var createMatroskaMedia = async ({
   const trackNumberProgresses = {};
   const getClusterOrMakeNew = async ({
     chunk,
-    isVideo
+    isVideo,
+    trackNumber: trackNumber2
   }) => {
-    const smallestProgress = Math.min(...Object.values(trackNumberProgresses));
+    const trackProgressValues = Object.values(trackNumberProgresses);
+    const smallestProgress = trackProgressValues.length === 0 ? 0 : Math.min(...trackProgressValues);
+    if (chunk.type === "key") {
+      trackNumberProgresses[trackNumber2] = chunk.timestamp;
+    }
     if (!currentCluster.shouldMakeNewCluster({
       newT: smallestProgress,
       isVideo,
@@ -3011,7 +3026,12 @@ var createMatroskaMedia = async ({
     })) {
       return { cluster: currentCluster, isNew: false, smallestProgress };
     }
-    currentCluster = await makeCluster(w, smallestProgress, timescale);
+    currentCluster = await makeCluster({
+      writer: w,
+      clusterStartTimestamp: smallestProgress,
+      timescale,
+      logLevel
+    });
     return { cluster: currentCluster, isNew: true, smallestProgress };
   };
   const updateDuration = async (newDuration) => {
@@ -3024,10 +3044,10 @@ var createMatroskaMedia = async ({
     trackNumber: trackNumber2,
     isVideo
   }) => {
-    trackNumberProgresses[trackNumber2] = chunk.timestamp;
     const { cluster, isNew, smallestProgress } = await getClusterOrMakeNew({
       chunk,
-      isVideo
+      isVideo,
+      trackNumber: trackNumber2
     });
     const newDuration = Math.round((chunk.timestamp + (chunk.duration ?? 0)) / 1000);
     await updateDuration(newDuration);
@@ -3061,9 +3081,8 @@ var createMatroskaMedia = async ({
         }
       });
     },
-    save: async () => {
-      const file = await w.save();
-      return file;
+    save: () => {
+      return w.save();
     },
     remove: async () => {
       await w.remove();
@@ -3072,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 }));
@@ -3101,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");
@@ -3266,6 +3394,34 @@ var getMdatBox = (anySegment) => {
   return mdat;
 };
 
+// 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,
@@ -3324,8 +3480,8 @@ var getFpsFromMp4TrakBox = (trakBox) => {
     durationInSamples: timescaleAndDuration.duration
   });
 };
-var getFps = (segments) => {
-  const moovBox = getMoovBox(segments);
+var getFpsFromIsoMaseMedia = (structure) => {
+  const moovBox = getMoovBox(structure.boxes);
   if (!moovBox) {
     return null;
   }
@@ -3336,8 +3492,37 @@ var getFps = (segments) => {
   }
   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");
+    }
+    if (strh.fccType === "auds") {
+      continue;
+    }
+    return strh.rate;
+  }
+  return null;
+};
+var getFps = (segments) => {
+  if (segments.type === "iso-base-media") {
+    return getFpsFromIsoMaseMedia(segments);
+  }
+  if (segments.type === "riff") {
+    return getFpsFromAvi(segments);
+  }
+  if (segments.type === "matroska") {
+    return null;
+  }
+  throw new Error("Cannot get fps, not implemented");
+};
 var hasFps = (boxes) => {
   try {
+    if (boxes.type === "matroska") {
+      return true;
+    }
     return getFps(boxes) !== null;
   } catch {
     return false;
@@ -3361,11 +3546,7 @@ var getAudioCodec = (boxes, parserState) => {
   return null;
 };
 var hasAudioCodec = (boxes, state) => {
-  try {
-    return getAudioCodec(boxes, state) !== null;
-  } catch {
-    return false;
-  }
+  return hasTracks(boxes, state);
 };
 var getCodecSpecificatorFromEsdsBox = ({
   child
@@ -3727,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);
@@ -3772,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;
   };
@@ -3782,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);
@@ -3925,9 +4121,7 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     leb128,
     removeBytesRead,
     isWebm,
-    discard: (length) => {
-      counter.increment(length);
-    },
+    discard,
     getEightByteNumber,
     getFourByteNumber,
     getSlice,
@@ -4021,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);
@@ -4076,7 +4275,8 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     destroy,
     isMp3,
     disallowDiscard,
-    allowDiscard
+    allowDiscard,
+    startBox
   };
 };
 
@@ -4185,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;
@@ -4223,14 +4416,44 @@ var getVideoCodec = (boxes) => {
       }
     }
   }
-  return null;
+  throw new Error("Could not find video codec");
 };
-var hasVideoCodec = (boxes) => {
-  try {
-    return getVideoCodec(boxes) !== null;
-  } catch {
-    return false;
+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, state) => {
+  return hasTracks(boxes, state);
 };
 var getVideoPrivateData = (trakBox) => {
   const videoSample = getStsdVideoConfig(trakBox);
@@ -4321,7 +4544,7 @@ var makeBaseMediaTrack = (trakBox) => {
       sampleRate,
       description,
       trakBox,
-      codecPrivate: getCodecPrivateFromTrak(trakBox),
+      codecPrivate: getCodecPrivateFromTrak(trakBox) ?? description ?? null,
       codecWithoutConfig: getAudioCodecFromTrack(trakBox)
     };
   }
@@ -4380,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();
@@ -4753,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 {
@@ -4823,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 {
@@ -5058,16 +5440,12 @@ var getDurationFromMatroska = (segments) => {
   }
   return duration2.value.value / timestampScale2.value.value * 1000;
 };
-var getDuration = (boxes, parserState) => {
-  const matroskaBox = boxes.find((b) => b.type === "Segment");
-  if (matroskaBox) {
-    return getDurationFromMatroska(boxes);
-  }
-  const moovBox = getMoovBox(boxes);
+var getDurationFromIsoBaseMedia = (structure, parserState) => {
+  const moovBox = getMoovBox(structure.boxes);
   if (!moovBox) {
     return null;
   }
-  const moofBox = getMoofBox(boxes);
+  const moofBox = getMoofBox(structure.boxes);
   const mvhdBox = getMvhdBox(moovBox);
   if (!mvhdBox) {
     return null;
@@ -5078,7 +5456,7 @@ var getDuration = (boxes, parserState) => {
   if (mvhdBox.durationInSeconds > 0) {
     return mvhdBox.durationInSeconds;
   }
-  const tracks2 = getTracks(boxes, parserState);
+  const tracks2 = getTracks(structure, parserState);
   const allTracks = [
     ...tracks2.videoTracks,
     ...tracks2.audioTracks,
@@ -5093,13 +5471,34 @@ var getDuration = (boxes, parserState) => {
   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;
+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
@@ -5114,15 +5513,15 @@ var emitAvailableInfo = ({
 }) => {
   const keys = Object.keys(hasInfo);
   for (const key of keys) {
-    if (key === "boxes") {
-      if (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;
     }
     if (key === "durationInSeconds") {
-      if (hasInfo.durationInSeconds && returnValue.durationInSeconds === undefined) {
+      if (hasInfo.durationInSeconds && returnValue.durationInSeconds === undefined && parseResult) {
         const durationInSeconds = getDuration(parseResult.segments, state);
         moreFields.onDurationInSeconds?.(durationInSeconds);
         returnValue.durationInSeconds = durationInSeconds;
@@ -5130,7 +5529,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "dimensions") {
-      if (hasInfo.dimensions && returnValue.dimensions === undefined) {
+      if (hasInfo.dimensions && returnValue.dimensions === undefined && parseResult) {
         const dimensionsQueried = getDimensions(parseResult.segments, state);
         const dimensions = {
           height: dimensionsQueried.height,
@@ -5142,7 +5541,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "unrotatedDimensions") {
-      if (returnValue.unrotatedDimensions === undefined && hasInfo.unrotatedDimensions) {
+      if (returnValue.unrotatedDimensions === undefined && hasInfo.unrotatedDimensions && parseResult) {
         const dimensionsQueried = getDimensions(parseResult.segments, state);
         const unrotatedDimensions = {
           height: dimensionsQueried.unrotatedHeight,
@@ -5154,7 +5553,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "rotation") {
-      if (returnValue.rotation === undefined && hasInfo.rotation) {
+      if (returnValue.rotation === undefined && hasInfo.rotation && parseResult) {
         const dimensionsQueried = getDimensions(parseResult.segments, state);
         const { rotation } = dimensionsQueried;
         moreFields.onRotation?.(rotation);
@@ -5163,7 +5562,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "fps") {
-      if (returnValue.fps === undefined && hasInfo.fps) {
+      if (returnValue.fps === undefined && hasInfo.fps && parseResult) {
         const fps = getFps(parseResult.segments);
         moreFields.onFps?.(fps);
         returnValue.fps = fps;
@@ -5171,7 +5570,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "videoCodec") {
-      if (returnValue.videoCodec === undefined && hasInfo.videoCodec) {
+      if (returnValue.videoCodec === undefined && hasInfo.videoCodec && parseResult) {
         const videoCodec = getVideoCodec(parseResult.segments);
         moreFields.onVideoCodec?.(videoCodec);
         returnValue.videoCodec = videoCodec;
@@ -5179,7 +5578,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "audioCodec") {
-      if (returnValue.audioCodec === undefined && hasInfo.audioCodec) {
+      if (returnValue.audioCodec === undefined && hasInfo.audioCodec && parseResult) {
         const audioCodec = getAudioCodec(parseResult.segments, state);
         moreFields.onAudioCodec?.(audioCodec);
         returnValue.audioCodec = audioCodec;
@@ -5187,7 +5586,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "tracks") {
-      if (hasInfo.tracks && returnValue.videoTracks === undefined && returnValue.audioTracks === undefined) {
+      if (hasInfo.tracks && returnValue.videoTracks === undefined && returnValue.audioTracks === undefined && parseResult) {
         const { videoTracks, audioTracks } = getTracks(parseResult.segments, state);
         moreFields.onTracks?.({ videoTracks, audioTracks });
         returnValue.videoTracks = videoTracks;
@@ -5218,7 +5617,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "container") {
-      if (returnValue.container === undefined && hasInfo.container) {
+      if (returnValue.container === undefined && hasInfo.container && parseResult) {
         const container = getContainer(parseResult.segments);
         moreFields.onContainer?.(container);
         returnValue.container = container;
@@ -5233,26 +5632,26 @@ var emitAvailableInfo = ({
 var getAvailableInfo = (options, parseResult, state) => {
   const keys = Object.entries(options).filter(([, value]) => value);
   const infos = keys.map(([key]) => {
-    if (key === "boxes") {
-      return parseResult.status === "done";
+    if (key === "structure") {
+      return Boolean(parseResult && parseResult.status === "done");
     }
     if (key === "durationInSeconds") {
-      return hasDuration(parseResult.segments, state);
+      return Boolean(parseResult && hasDuration(parseResult.segments, state));
     }
     if (key === "dimensions" || key === "rotation" || key === "unrotatedDimensions") {
-      return hasDimensions(parseResult.segments, state);
+      return Boolean(parseResult && hasDimensions(parseResult.segments, state));
     }
     if (key === "fps") {
-      return hasFps(parseResult.segments);
+      return Boolean(parseResult && hasFps(parseResult.segments));
     }
     if (key === "videoCodec") {
-      return hasVideoCodec(parseResult.segments);
+      return Boolean(parseResult && hasVideoCodec(parseResult.segments, state));
     }
     if (key === "audioCodec") {
-      return hasAudioCodec(parseResult.segments, state);
+      return Boolean(parseResult && hasAudioCodec(parseResult.segments, state));
     }
     if (key === "tracks") {
-      return hasTracks(parseResult.segments);
+      return Boolean(parseResult && hasTracks(parseResult.segments, state));
     }
     if (key === "internalStats") {
       return false;
@@ -5264,7 +5663,7 @@ var getAvailableInfo = (options, parseResult, state) => {
       return true;
     }
     if (key === "container") {
-      return hasContainer(parseResult.segments);
+      return Boolean(parseResult && hasContainer(parseResult.segments));
     }
     throw new Error(`Unknown key: ${key}`);
   });
@@ -5276,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();
@@ -5450,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));
@@ -5470,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,
@@ -5589,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,
@@ -5606,7 +6037,7 @@ var parseMoov = async ({
     offset,
     boxSize: size,
     type: "moov-box",
-    children: children.segments
+    children: children.segments.boxes
   };
 };
 
@@ -5911,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,
@@ -5930,7 +6361,7 @@ var parseMebx = async ({
     offset,
     dataReferenceIndex,
     format: "mebx",
-    children: children.segments
+    children: children.segments.boxes
   };
 };
 
@@ -6121,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,
@@ -6153,7 +6584,7 @@ var processSample = async ({
           bytesPerPacket: null,
           bytesPerFrame: null,
           bitsPerSample: null,
-          children: children.segments
+          children: children.segments.boxes
         }
       };
     }
@@ -6168,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,
@@ -6200,7 +6631,7 @@ var processSample = async ({
           bytesPerPacket,
           bytesPerFrame,
           bitsPerSample: bytesPerSample,
-          children: children.segments
+          children: children.segments.boxes
         }
       };
     }
@@ -6219,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,
@@ -6251,7 +6682,7 @@ var processSample = async ({
           bytesPerPacket: null,
           bytesPerFrame,
           bitsPerSample: bitsPerCodedSample,
-          children: children.segments
+          children: children.segments.boxes
         }
       };
     }
@@ -6273,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,
@@ -6282,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");
     }
@@ -6307,7 +6738,7 @@ var processSample = async ({
         compressorName,
         depth,
         colorTableId,
-        descriptors: children.segments
+        descriptors: children.segments.boxes
       }
     };
   }
@@ -6629,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,
@@ -6646,7 +7077,7 @@ var parseTrak = async ({
     offset: offsetAtStart,
     boxSize: size,
     type: "trak-box",
-    children: children.segments
+    children: children.segments.boxes
   };
 };
 
@@ -6703,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,
@@ -6716,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 }));
@@ -6790,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();
@@ -7019,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",
@@ -7167,7 +7595,7 @@ var processBox = async ({
     skipTo: null
   };
 };
-var parseBoxes = async ({
+var parseIsoBaseMediaBoxes = async ({
   iterator,
   maxBytes,
   allowIncompleteBoxes,
@@ -7177,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,
@@ -7202,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,
@@ -7221,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,
@@ -7238,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) {
@@ -7254,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,
@@ -7273,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,
@@ -7291,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,
@@ -7318,24 +7749,651 @@ var parseBoxes = async ({
   }
   return {
     status: "done",
-    segments: boxes
+    segments: structure
   };
 };
 
-// src/add-new-matroska-tracks.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);
+// src/boxes/riff/is-movi.ts
+var isMoviAtom = (iterator, ckId) => {
+  if (ckId !== "LIST") {
+    return false;
   }
-  if (track.type === "audio" && options.onAudioTrack) {
-    const callback = await options.onAudioTrack(track);
-    await state.registerAudioSampleCallback(track.trackId, callback ?? null);
+  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,
+  structure,
+  ckId,
+  ckSize
+}) => {
+  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"
+      });
+    }
+  }
+};
+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
@@ -7605,32 +8663,54 @@ var postprocessEbml = async ({
 };
 
 // src/boxes/webm/segments.ts
-var parseSegment = async ({
-  segmentId,
+var continueAfterMatroskaParseResult = async ({
+  result,
   iterator,
-  length,
   parserContext,
-  headerReadSoFar
+  segment
 }) => {
-  if (length < 0) {
-    throw new Error(`Expected length of ${segmentId} to be greater or equal 0`);
+  if (result.status === "done") {
+    throw new Error("Should not continue after done");
   }
-  iterator.counter.decrement(headerReadSoFar);
-  const offset = iterator.counter.getOffset();
-  const ebml = await parseEbml(iterator, parserContext);
-  const remapped = await postprocessEbml({ offset, ebml, parserContext });
-  return remapped;
+  const proceeded = await result.continueParsing();
+  if (proceeded.status === "done") {
+    return {
+      status: "done",
+      segment
+    };
+  }
+  return {
+    continueParsing() {
+      return continueAfterMatroskaParseResult({
+        result: proceeded,
+        iterator,
+        parserContext,
+        segment
+      });
+    },
+    segment: null,
+    status: "incomplete"
+  };
 };
-var expectSegment = async (iterator, parserContext) => {
-  const offset = iterator.counter.getOffset();
+var expectSegment = async ({
+  iterator,
+  parserContext,
+  offset,
+  children
+}) => {
+  iterator.counter.decrement(iterator.counter.getOffset() - offset);
   if (iterator.bytesRemaining() === 0) {
     return {
       status: "incomplete",
-      segments: [],
       continueParsing: () => {
-        return Promise.resolve(expectSegment(iterator, parserContext));
+        return expectAndProcessSegment({
+          iterator,
+          parserContext,
+          offset,
+          children
+        });
       },
-      skipTo: null
+      segment: null
     };
   }
   const segmentId = iterator.getMatroskaSegmentId();
@@ -7638,11 +8718,15 @@ var expectSegment = async (iterator, parserContext) => {
     iterator.counter.decrement(iterator.counter.getOffset() - offset);
     return {
       status: "incomplete",
-      segments: [],
       continueParsing: () => {
-        return Promise.resolve(expectSegment(iterator, parserContext));
+        return expectAndProcessSegment({
+          iterator,
+          parserContext,
+          offset,
+          children
+        });
       },
-      skipTo: null
+      segment: null
     };
   }
   const offsetBeforeVInt = iterator.counter.getOffset();
@@ -7652,41 +8736,43 @@ var expectSegment = async (iterator, parserContext) => {
     iterator.counter.decrement(iterator.counter.getOffset() - offset);
     return {
       status: "incomplete",
-      segments: [],
       continueParsing: () => {
-        return Promise.resolve(expectSegment(iterator, parserContext));
+        return expectSegment({ iterator, parserContext, offset, children });
       },
-      skipTo: null
+      segment: null
     };
   }
   const bytesRemainingNow = iterator.byteLength() - iterator.counter.getOffset();
   if (segmentId === "0x18538067" || segmentId === "0x1f43b675") {
+    const newSegment = {
+      type: segmentId === "0x18538067" ? "Segment" : "Cluster",
+      minVintWidth: offsetAfterVInt - offsetBeforeVInt,
+      value: []
+    };
     const main = await expectChildren({
       iterator,
       length,
-      initialChildren: [],
-      wrap: segmentId === "0x18538067" ? (s) => ({
-        type: "Segment",
-        value: s,
-        minVintWidth: offsetAfterVInt - offsetBeforeVInt
-      }) : (s) => ({
-        type: "Cluster",
-        value: s,
-        minVintWidth: offsetAfterVInt - offsetBeforeVInt
-      }),
-      parserContext
+      children: newSegment.value,
+      parserContext,
+      startOffset: iterator.counter.getOffset()
     });
     if (main.status === "incomplete") {
       return {
         status: "incomplete",
-        segments: main.segments,
-        skipTo: null,
-        continueParsing: main.continueParsing
+        continueParsing: () => {
+          return continueAfterMatroskaParseResult({
+            iterator,
+            parserContext,
+            result: main,
+            segment: newSegment
+          });
+        },
+        segment: newSegment
       };
     }
     return {
       status: "done",
-      segments: main.segments
+      segment: newSegment
     };
   }
   if (bytesRemainingNow < length) {
@@ -7694,11 +8780,10 @@ var expectSegment = async (iterator, parserContext) => {
     iterator.counter.decrement(bytesRead);
     return {
       status: "incomplete",
-      segments: [],
+      segment: null,
       continueParsing: () => {
-        return Promise.resolve(expectSegment(iterator, parserContext));
-      },
-      skipTo: null
+        return expectSegment({ iterator, parserContext, offset, children });
+      }
     };
   }
   const segment = await parseSegment({
@@ -7710,131 +8795,179 @@ var expectSegment = async (iterator, parserContext) => {
   });
   return {
     status: "done",
-    segments: [segment]
+    segment
   };
 };
+var parseSegment = async ({
+  segmentId,
+  iterator,
+  length,
+  parserContext,
+  headerReadSoFar
+}) => {
+  if (length < 0) {
+    throw new Error(`Expected length of ${segmentId} to be greater or equal 0`);
+  }
+  iterator.counter.decrement(headerReadSoFar);
+  const offset = iterator.counter.getOffset();
+  const ebml = await parseEbml(iterator, parserContext);
+  const remapped = await postprocessEbml({ offset, ebml, parserContext });
+  return remapped;
+};
 
 // src/boxes/webm/segments/parse-children.ts
 var processParseResult = ({
   parseResult,
-  children,
-  wrap
+  children
 }) => {
+  if (parseResult.segment && !children.includes(parseResult.segment)) {
+    children.push(parseResult.segment);
+  }
   if (parseResult.status === "incomplete") {
     return {
       status: "incomplete",
-      segments: [],
+      segment: parseResult.segment,
       continueParsing: async () => {
         const newParseResult = await parseResult.continueParsing();
         return processParseResult({
           children,
-          parseResult: newParseResult,
-          wrap
+          parseResult: newParseResult
         });
-      },
-      skipTo: null
+      }
     };
   }
-  for (const segment of parseResult.segments) {
-    children.push(segment);
-  }
   return {
     status: "done",
-    segments: wrap ? [wrap(children)] : children
+    segment: parseResult.segment
   };
 };
-var continueParsingfunction = ({
-  result,
+var expectAndProcessSegment = async ({
   iterator,
+  parserContext,
+  offset,
+  children
+}) => {
+  const segment = await expectSegment({
+    iterator,
+    parserContext,
+    offset,
+    children
+  });
+  return processParseResult({
+    children,
+    parseResult: segment
+  });
+};
+var continueAfterSegmentResult = async ({
+  result,
+  length,
   children,
-  wrap,
   parserContext,
-  length
-}) => async () => {
-  if (result.status !== "incomplete") {
-    throw new Error("expected incomplete");
+  iterator,
+  startOffset
+}) => {
+  if (result.status === "done") {
+    throw new Error("Should not continue after done");
   }
-  const offset = iterator.counter.getOffset();
-  const continued = await result.continueParsing();
-  if (continued.status === "incomplete") {
-    if (!parserContext.supportsContentRange) {
-      throw new Error("Content-Range header is not supported by the reader, but was asked to seek");
-    }
+  const segmentResult = await result.continueParsing();
+  if (segmentResult.status === "done") {
     return {
       status: "incomplete",
-      continueParsing: continueParsingfunction({
-        result: continued,
-        iterator,
-        children,
-        wrap,
-        parserContext,
-        length: length - (iterator.counter.getOffset() - offset)
-      }),
-      skipTo: continued.skipTo,
-      segments: wrap ? [wrap(children)] : children
+      continueParsing: () => {
+        return expectChildren({
+          children,
+          iterator,
+          length,
+          parserContext,
+          startOffset
+        });
+      },
+      skipTo: null
     };
   }
-  return expectChildren({
-    iterator,
-    length: length - (iterator.counter.getOffset() - offset),
-    initialChildren: children,
-    wrap,
-    parserContext
-  });
+  return {
+    status: "incomplete",
+    continueParsing: () => {
+      return continueAfterSegmentResult({
+        result: segmentResult,
+        children,
+        iterator,
+        length,
+        parserContext,
+        startOffset
+      });
+    },
+    skipTo: null
+  };
 };
 var expectChildren = async ({
   iterator,
   length,
-  initialChildren,
-  wrap,
-  parserContext
+  children,
+  parserContext,
+  startOffset
 }) => {
-  const children = [...initialChildren];
-  const startOffset = iterator.counter.getOffset();
   while (iterator.counter.getOffset() < startOffset + length) {
     if (iterator.bytesRemaining() === 0) {
       break;
     }
-    const parseResult = await expectSegment(iterator, parserContext);
-    const child = processParseResult({
-      children,
-      parseResult,
-      wrap
+    const currentOffset = iterator.counter.getOffset();
+    const child = await expectAndProcessSegment({
+      iterator,
+      parserContext,
+      offset: currentOffset,
+      children
     });
     if (child.status === "incomplete") {
-      if (!parserContext.supportsContentRange) {
-        throw new Error("Content-Range header is not supported by the reader, but was asked to seek");
-      }
       return {
         status: "incomplete",
-        continueParsing: continueParsingfunction({
-          result: child,
-          iterator,
-          children,
-          wrap,
-          parserContext,
-          length: length - (iterator.counter.getOffset() - startOffset)
-        }),
-        skipTo: child.skipTo,
-        segments: wrap ? [wrap(children)] : children
+        continueParsing: () => {
+          return continueAfterSegmentResult({
+            result: child,
+            children,
+            iterator,
+            length: length - (currentOffset - startOffset),
+            parserContext,
+            startOffset: currentOffset
+          });
+        },
+        skipTo: null
       };
     }
   }
   return {
-    status: "done",
-    segments: wrap ? [wrap(children)] : children
+    status: "done"
   };
 };
 
 // src/boxes/webm/parse-webm-header.ts
-var parseWebm = (counter, parserContext) => {
-  return expectChildren({
+var continueAfterMatroskaResult = (result, structure) => {
+  if (result.status === "done") {
+    return {
+      status: "done",
+      segments: structure
+    };
+  }
+  return {
+    status: "incomplete",
+    segments: structure,
+    continueParsing: async () => {
+      const newResult = await result.continueParsing();
+      return continueAfterMatroskaResult(newResult, structure);
+    },
+    skipTo: null
+  };
+};
+var parseWebm = async (counter, parserContext) => {
+  const structure = { type: "matroska", boxes: [] };
+  const results = await expectChildren({
     iterator: counter,
     length: Infinity,
-    initialChildren: [],
-    wrap: null,
-    parserContext
+    children: structure.boxes,
+    parserContext,
+    startOffset: counter.counter.getOffset()
   });
+  return continueAfterMatroskaResult(results, structure);
 };
 
 // src/parse-video.ts
@@ -7845,25 +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()) {
-    return parseBoxes({
+    Log.verbose(logLevel, "Detected ISO Base Media container");
+    return parseIsoBaseMediaBoxes({
       iterator,
       maxBytes: Infinity,
       allowIncompleteBoxes: true,
@@ -7875,7 +8997,8 @@ var parseVideo = ({
     });
   }
   if (iterator.isWebm()) {
-    return Promise.resolve(parseWebm(iterator, options));
+    Log.verbose(logLevel, "Detected Matroska container");
+    return parseWebm(iterator, options);
   }
   if (iterator.isMp3()) {
     return Promise.reject(new Error("MP3 files are not yet supported"));
@@ -7940,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) {
@@ -7973,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);
@@ -7989,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);
@@ -8003,7 +9149,13 @@ var makeParserState = ({
     },
     getInternalStats: () => ({}),
     getTimescale,
-    setTimescale
+    setTimescale,
+    getSamplesForTrack: (trackId) => {
+      return samplesForTrack[trackId] ?? 0;
+    },
+    getAvcProfile: () => {
+      return avcProfile;
+    }
   };
 };
 
@@ -8016,6 +9168,7 @@ var parseMedia = async ({
   onVideoTrack,
   signal,
   logLevel = "info",
+  onParseProgress,
   ...more
 }) => {
   const state = makeParserState({
@@ -8035,14 +9188,41 @@ var parseMedia = async ({
   const moreFields = more;
   let iterator = null;
   let parseResult = null;
+  const canSkipVideoData = !onVideoTrack && !onAudioTrack;
+  if (canSkipVideoData) {
+    Log.verbose(logLevel, "Only parsing metadata, because no onVideoTrack and onAudioTrack callbacks were passed.");
+  } else {
+    Log.verbose(logLevel, "Parsing video data, because onVideoTrack/onAudioTrack callbacks were passed.");
+  }
   const options = {
-    canSkipVideoData: !(onAudioTrack || onVideoTrack),
+    canSkipVideoData,
     onAudioTrack: onAudioTrack ?? null,
     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) {
+      return false;
+    }
+    const availableInfo = getAvailableInfo(fields ?? {}, parseResult, state);
+    return Object.values(availableInfo).every(Boolean);
+  };
+  const triggerInfoEmit = () => {
+    const availableInfo = getAvailableInfo(fields ?? {}, parseResult, state);
+    emitAvailableInfo({
+      hasInfo: availableInfo,
+      moreFields,
+      parseResult,
+      state,
+      returnValue,
+      contentLength,
+      name
+    });
   };
+  triggerInfoEmit();
   while (parseResult === null || parseResult.status === "incomplete") {
     if (signal?.aborted) {
       throw new Error("Aborted");
@@ -8069,7 +9249,14 @@ var parseMedia = async ({
     if (!iterator) {
       throw new Error("Unexpected null");
     }
+    await onParseProgress?.({
+      bytes: iterator.counter.getOffset(),
+      percentage: contentLength ? iterator.counter.getOffset() / contentLength : null,
+      totalBytes: contentLength
+    });
+    triggerInfoEmit();
     if (parseResult && parseResult.status === "incomplete") {
+      Log.verbose(logLevel, "Continuing parsing of file, currently at position", iterator.counter.getOffset(), getAvailableInfo(fields ?? {}, parseResult, state));
       parseResult = await parseResult.continueParsing();
     } else {
       parseResult = await parseVideo({
@@ -8079,18 +9266,7 @@ var parseMedia = async ({
         logLevel
       });
     }
-    const availableInfo = getAvailableInfo(fields ?? {}, parseResult, state);
-    const hasAllInfo = Object.values(availableInfo).every(Boolean);
-    emitAvailableInfo({
-      hasInfo: availableInfo,
-      moreFields,
-      parseResult,
-      state,
-      returnValue,
-      contentLength,
-      name
-    });
-    if (hasAllInfo && !onVideoTrack && !onAudioTrack) {
+    if (hasAllInfo() && !onVideoTrack && !onAudioTrack) {
       break;
     }
     if (parseResult && parseResult.status === "incomplete" && parseResult.skipTo !== null) {
@@ -8103,6 +9279,7 @@ var parseMedia = async ({
       iterator.skipTo(parseResult.skipTo, true);
     }
   }
+  Log.verbose(logLevel, "Finished parsing file");
   emitAvailableInfo({
     hasInfo: Object.keys(fields ?? {}).reduce((acc, key) => {
       acc[key] = true;
@@ -8119,13 +9296,18 @@ var parseMedia = async ({
   iterator?.destroy();
   return returnValue;
 };
+// src/version.ts
+var VERSION = "4.0.232";
+
 // src/index.ts
 var MediaParserInternals = {
   createMatroskaMedia,
   createIsoBaseMedia,
+  createWav,
   Log
 };
 export {
   parseMedia,
+  VERSION,
   MediaParserInternals
 };