@remotion/media-parser 4.0.229 → 4.0.230

package/dist/esm/index.mjs

@@ -1021,7 +1021,1111 @@ var combineUint8Arrays = (arrays) => {
   return result;
 };
 
-// src/create/cluster-segment.ts
+// src/log.ts
+var logLevels = ["trace", "verbose", "info", "warn", "error"];
+var getNumberForLogLevel = (level) => {
+  return logLevels.indexOf(level);
+};
+var isEqualOrBelowLogLevel = (currentLevel, level) => {
+  return getNumberForLogLevel(currentLevel) <= getNumberForLogLevel(level);
+};
+var Log = {
+  trace: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "trace")) {
+      return console.log(...args);
+    }
+  },
+  verbose: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "verbose")) {
+      return console.log(...args);
+    }
+  },
+  info: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "info")) {
+      return console.log(...args);
+    }
+  },
+  warn: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "warn")) {
+      return console.warn(...args);
+    }
+  },
+  error: (...args) => {
+    return console.error(...args);
+  }
+};
+
+// src/create/iso-base-media/primitives.ts
+var stringsToUint8Array = (str) => {
+  return new TextEncoder().encode(str);
+};
+var numberTo32BitUIntOrInt = (num) => {
+  return new Uint8Array([
+    num >> 24 & 255,
+    num >> 16 & 255,
+    num >> 8 & 255,
+    num & 255
+  ]);
+};
+var numberTo32BitUIntOrIntLeading128 = (num) => {
+  const arr = [
+    num >> 24 & 255,
+    num >> 16 & 255,
+    num >> 8 & 255,
+    num & 255
+  ];
+  for (const i in arr) {
+    if (arr[i] === 0) {
+      arr[i] = 128;
+    } else {
+      break;
+    }
+  }
+  return new Uint8Array(arr);
+};
+var numberTo16BitUIntOrInt = (num) => {
+  return new Uint8Array([num >> 8 & 255, num & 255]);
+};
+var setFixedPointSignedOrUnsigned1616Number = (num) => {
+  const val = Math.round(num * 2 ** 16);
+  return numberTo32BitUIntOrInt(val);
+};
+var setFixedPointSigned230Number = (num) => {
+  const val = Math.round(num * 2 ** 30);
+  return numberTo32BitUIntOrInt(val);
+};
+var addSize = (arr) => {
+  return combineUint8Arrays([numberTo32BitUIntOrInt(arr.length + 4), arr]);
+};
+var addLeading128Size = (arr) => {
+  return combineUint8Arrays([
+    numberTo32BitUIntOrIntLeading128(arr.length),
+    arr
+  ]);
+};
+var floatTo16Point1632Bit = (number) => {
+  const fixedNumber = Number(number.toFixed(2));
+  const result = new Uint8Array(4);
+  const tens = Math.floor(fixedNumber / 10);
+  const ones = Math.floor(fixedNumber % 10);
+  const tenths = Math.floor(fixedNumber * 10 % 10);
+  const hundredths = Math.floor(fixedNumber * 100 % 10);
+  result[0] = tens;
+  result[1] = ones;
+  result[2] = tenths;
+  result[3] = hundredths;
+  return result;
+};
+var floatTo16Point16_16Bit = (number) => {
+  const fixedNumber = Number(number.toFixed(2));
+  const result = new Uint8Array(2);
+  const ones = Math.floor(fixedNumber % 10);
+  const tenths = Math.floor(fixedNumber * 10 % 10);
+  result[0] = ones;
+  result[1] = tenths;
+  return result;
+};
+var serializeMatrix = (matrix) => {
+  return combineUint8Arrays([
+    setFixedPointSignedOrUnsigned1616Number(matrix[0]),
+    setFixedPointSignedOrUnsigned1616Number(matrix[1]),
+    setFixedPointSigned230Number(matrix[2]),
+    setFixedPointSignedOrUnsigned1616Number(matrix[3]),
+    setFixedPointSignedOrUnsigned1616Number(matrix[4]),
+    setFixedPointSigned230Number(matrix[5]),
+    setFixedPointSignedOrUnsigned1616Number(matrix[6]),
+    setFixedPointSignedOrUnsigned1616Number(matrix[7]),
+    setFixedPointSigned230Number(matrix[8])
+  ]);
+};
+var stringToPascalString = (str) => {
+  const buffer = new Uint8Array(32);
+  for (let i = 0;i < Math.min(str.length, 32); i++) {
+    buffer[i] = str.charCodeAt(i);
+  }
+  return buffer;
+};
+var padIsoBaseMediaBytes = (data, totalLength) => {
+  if (data.length - 8 > totalLength) {
+    throw new Error(`Data is longer than the total length: ${data.length - 8} > ${totalLength}`);
+  }
+  if (data.length - 8 === totalLength) {
+    return data;
+  }
+  return combineUint8Arrays([
+    data,
+    addSize(combineUint8Arrays([
+      stringsToUint8Array("free"),
+      new Uint8Array(totalLength - (data.length - 8))
+    ]))
+  ]);
+};
+var IDENTITY_MATRIX = [1, 0, 0, 0, 1, 0, 0, 0, 1];
+
+// src/create/iso-base-media/create-ftyp.ts
+var createFtyp = ({
+  majorBrand,
+  minorBrand,
+  compatibleBrands
+}) => {
+  const type = stringsToUint8Array("ftyp");
+  const majorBrandArr = stringsToUint8Array(majorBrand);
+  const minorBrandArr = numberTo32BitUIntOrInt(minorBrand);
+  const compatibleBrandsArr = combineUint8Arrays(compatibleBrands.map((b) => stringsToUint8Array(b)));
+  return addSize(combineUint8Arrays([
+    type,
+    majorBrandArr,
+    minorBrandArr,
+    compatibleBrandsArr
+  ]));
+};
+var createIsoBaseMediaFtyp = ({
+  majorBrand,
+  minorBrand,
+  compatibleBrands
+}) => {
+  return createFtyp({ compatibleBrands, majorBrand, minorBrand });
+};
+
+// src/create/iso-base-media/create-ilst.ts
+var createIlst = (items) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("ilst"),
+    ...items
+  ]));
+};
+
+// src/create/iso-base-media/create-moov.ts
+var createMoov = ({
+  mvhd,
+  traks,
+  udta
+}) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("moov"),
+    mvhd,
+    ...traks,
+    udta
+  ]));
+};
+
+// src/boxes/iso-base-media/to-date.ts
+var toUnixTimestamp = (value) => {
+  if (value === 0) {
+    return null;
+  }
+  const baseDate = new Date("1904-01-01T00:00:00Z");
+  return Math.floor(value + baseDate.getTime() / 1000) * 1000;
+};
+var fromUnixTimestamp = (value) => {
+  if (value === null) {
+    return 0;
+  }
+  const baseDate = new Date("1904-01-01T00:00:00Z");
+  return Math.floor(value / 1000 - baseDate.getTime() / 1000);
+};
+
+// src/create/iso-base-media/create-mvhd.ts
+var createMvhd = ({
+  timescale,
+  durationInUnits,
+  rate,
+  volume,
+  nextTrackId,
+  matrix,
+  creationTime,
+  modificationTime
+}) => {
+  if (matrix.length !== 9) {
+    throw new Error("Matrix must be 9 elements long");
+  }
+  const content = combineUint8Arrays([
+    stringsToUint8Array("mvhd"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    creationTime === null ? numberTo32BitUIntOrInt(0) : numberTo32BitUIntOrInt(fromUnixTimestamp(creationTime)),
+    modificationTime === null ? numberTo32BitUIntOrInt(0) : numberTo32BitUIntOrInt(fromUnixTimestamp(modificationTime)),
+    numberTo32BitUIntOrInt(timescale),
+    numberTo32BitUIntOrInt(durationInUnits),
+    floatTo16Point1632Bit(rate),
+    floatTo16Point16_16Bit(volume),
+    new Uint8Array([0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    serializeMatrix(matrix),
+    combineUint8Arrays(new Array(6).fill(new Uint8Array([0, 0, 0, 0]))),
+    numberTo32BitUIntOrInt(nextTrackId)
+  ]);
+  return addSize(content);
+};
+
+// src/create/iso-base-media/create-udta.ts
+var createUdta = (children) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("udta"),
+    children
+  ]));
+};
+
+// src/create/iso-base-media/ilst/create-cmt.ts
+var createCmt = (comment) => {
+  return addSize(combineUint8Arrays([
+    new Uint8Array([169, 99, 109, 116]),
+    addSize(combineUint8Arrays([
+      stringsToUint8Array("data"),
+      new Uint8Array([0, 0]),
+      new Uint8Array([0, 1]),
+      new Uint8Array([0, 0]),
+      new Uint8Array([0, 0]),
+      stringsToUint8Array(comment)
+    ]))
+  ]));
+};
+
+// src/create/iso-base-media/ilst/create-too.ts
+var createToo = (value) => {
+  return addSize(combineUint8Arrays([
+    new Uint8Array([169, 116, 111, 111]),
+    addSize(combineUint8Arrays([
+      new Uint8Array([100, 97, 116, 97]),
+      new Uint8Array([0, 0]),
+      new Uint8Array([0, 1]),
+      new Uint8Array([0, 0]),
+      new Uint8Array([0, 0]),
+      stringsToUint8Array(value)
+    ]))
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-avcc.ts
+var createAvccBox = (privateData) => {
+  if (!privateData) {
+    throw new Error("privateData is required");
+  }
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("avcC"),
+    privateData
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-pasp.ts
+var createPasp = (x, y) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("pasp"),
+    numberTo32BitUIntOrInt(x),
+    numberTo32BitUIntOrInt(y)
+  ]));
+};
+
+// src/create/iso-base-media/codec-specific/avc1.ts
+var createAvc1Data = ({
+  avccBox,
+  pasp,
+  width,
+  height,
+  horizontalResolution,
+  verticalResolution,
+  compressorName,
+  depth
+}) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("avc1"),
+    new Uint8Array([0, 0, 0, 0, 0, 0]),
+    new Uint8Array([0, 1]),
+    new Uint8Array([0, 0]),
+    new Uint8Array([0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    numberTo16BitUIntOrInt(width),
+    numberTo16BitUIntOrInt(height),
+    setFixedPointSignedOrUnsigned1616Number(horizontalResolution),
+    setFixedPointSignedOrUnsigned1616Number(verticalResolution),
+    new Uint8Array([0, 0, 0, 0]),
+    numberTo16BitUIntOrInt(1),
+    stringToPascalString(compressorName),
+    numberTo16BitUIntOrInt(depth),
+    numberTo16BitUIntOrInt(-1),
+    avccBox,
+    pasp
+  ]));
+};
+
+// src/create/iso-base-media/codec-specific/mp4a.ts
+var createMp4a = ({
+  sampleRate,
+  channelCount,
+  avgBitrate,
+  maxBitrate,
+  codecPrivate: codecPrivate2
+}) => {
+  if (!codecPrivate2) {
+    throw new Error("Need codecPrivate for mp4a");
+  }
+  const esdsAtom = addSize(combineUint8Arrays([
+    stringsToUint8Array("esds"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    new Uint8Array([3]),
+    addLeading128Size(combineUint8Arrays([
+      numberTo16BitUIntOrInt(2),
+      new Uint8Array([0]),
+      new Uint8Array([4]),
+      addLeading128Size(combineUint8Arrays([
+        new Uint8Array([64]),
+        new Uint8Array([21]),
+        new Uint8Array([0, 0, 0]),
+        numberTo32BitUIntOrInt(maxBitrate),
+        numberTo32BitUIntOrInt(avgBitrate),
+        new Uint8Array([5]),
+        addLeading128Size(codecPrivate2)
+      ])),
+      new Uint8Array([6]),
+      addLeading128Size(new Uint8Array([2]))
+    ]))
+  ]));
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("mp4a"),
+    new Uint8Array([0, 0, 0, 0, 0, 0]),
+    numberTo16BitUIntOrInt(1),
+    numberTo16BitUIntOrInt(0),
+    numberTo16BitUIntOrInt(0),
+    new Uint8Array([0, 0, 0, 0]),
+    numberTo16BitUIntOrInt(channelCount),
+    numberTo16BitUIntOrInt(16),
+    numberTo16BitUIntOrInt(0),
+    numberTo16BitUIntOrInt(0),
+    setFixedPointSignedOrUnsigned1616Number(sampleRate),
+    esdsAtom
+  ]));
+};
+
+// src/create/iso-base-media/codec-specific/create-codec-specific-data.ts
+var createCodecSpecificData = (track) => {
+  if (track.type === "video") {
+    return createAvc1Data({
+      avccBox: createAvccBox(track.codecPrivate),
+      compressorName: "WebCodecs",
+      depth: 24,
+      horizontalResolution: 72,
+      verticalResolution: 72,
+      height: track.height,
+      width: track.width,
+      pasp: createPasp(1, 1),
+      type: "avc1-data"
+    });
+  }
+  if (track.type === "audio") {
+    return createMp4a({
+      type: "mp4a-data",
+      avgBitrate: 128 * 1024,
+      maxBitrate: 128 * 1024,
+      channelCount: track.numberOfChannels,
+      sampleRate: track.sampleRate,
+      codecPrivate: track.codecPrivate
+    });
+  }
+  throw new Error("Unsupported codec specific data " + track);
+};
+
+// src/create/iso-base-media/create-mdia.ts
+var createMdia = ({
+  mdhd,
+  hdlr,
+  minf
+}) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("mdia"),
+    mdhd,
+    hdlr,
+    minf
+  ]));
+};
+
+// src/truthy.ts
+function truthy(value) {
+  return Boolean(value);
+}
+
+// src/create/iso-base-media/create-trak.ts
+var createTrak = ({
+  tkhd,
+  mdia
+}) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("trak"),
+    tkhd,
+    mdia
+  ].filter(truthy)));
+};
+
+// src/create/iso-base-media/mdia/create-mdhd.ts
+var createMdhd = ({
+  creationTime,
+  modificationTime,
+  timescale,
+  duration: duration2
+}) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("mdhd"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    creationTime === null ? numberTo32BitUIntOrInt(0) : numberTo32BitUIntOrInt(fromUnixTimestamp(creationTime)),
+    modificationTime === null ? numberTo32BitUIntOrInt(0) : numberTo32BitUIntOrInt(fromUnixTimestamp(modificationTime)),
+    numberTo32BitUIntOrInt(timescale),
+    numberTo32BitUIntOrInt(Math.round(duration2 / 1000 * timescale)),
+    new Uint8Array([85, 196]),
+    new Uint8Array([0, 0])
+  ]));
+};
+
+// src/create/iso-base-media/trak/create-tkhd.ts
+var TKHD_FLAGS = {
+  TRACK_ENABLED: 1,
+  TRACK_IN_MOVIE: 2,
+  TRACK_IN_PREVIEW: 4,
+  TRACK_IN_POSTER: 8
+};
+var createTkhdForAudio = ({
+  creationTime,
+  modificationTime,
+  flags,
+  trackId,
+  duration: duration2,
+  volume,
+  timescale
+}) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("tkhd"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, flags]),
+    creationTime === null ? numberTo32BitUIntOrInt(0) : numberTo32BitUIntOrInt(fromUnixTimestamp(creationTime)),
+    modificationTime === null ? numberTo32BitUIntOrInt(0) : numberTo32BitUIntOrInt(fromUnixTimestamp(modificationTime)),
+    numberTo32BitUIntOrInt(trackId),
+    new Uint8Array([0, 0, 0, 0]),
+    numberTo32BitUIntOrInt(Math.round(duration2 / 1000 * timescale)),
+    new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0]),
+    new Uint8Array([0, 1]),
+    floatTo16Point16_16Bit(volume),
+    new Uint8Array([0, 0]),
+    serializeMatrix(IDENTITY_MATRIX),
+    setFixedPointSignedOrUnsigned1616Number(0),
+    setFixedPointSignedOrUnsigned1616Number(0)
+  ]));
+};
+var createTkhdForVideo = ({
+  creationTime,
+  modificationTime,
+  duration: duration2,
+  trackId,
+  volume,
+  matrix,
+  width,
+  height,
+  flags,
+  timescale
+}) => {
+  const content = combineUint8Arrays([
+    stringsToUint8Array("tkhd"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, flags]),
+    creationTime === null ? numberTo32BitUIntOrInt(0) : numberTo32BitUIntOrInt(fromUnixTimestamp(creationTime)),
+    modificationTime === null ? numberTo32BitUIntOrInt(0) : numberTo32BitUIntOrInt(fromUnixTimestamp(modificationTime)),
+    numberTo32BitUIntOrInt(trackId),
+    new Uint8Array([0, 0, 0, 0]),
+    numberTo32BitUIntOrInt(duration2 / 1000 * timescale),
+    new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0]),
+    new Uint8Array([0, 0]),
+    floatTo16Point16_16Bit(volume),
+    new Uint8Array([0, 0]),
+    serializeMatrix(matrix),
+    setFixedPointSignedOrUnsigned1616Number(width),
+    setFixedPointSignedOrUnsigned1616Number(height)
+  ]);
+  return addSize(content);
+};
+
+// src/create/iso-base-media/trak/mdia/minf/create-dinf.ts
+var createDinf = () => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("dinf"),
+    addSize(combineUint8Arrays([
+      stringsToUint8Array("dref"),
+      new Uint8Array([0]),
+      new Uint8Array([0, 0, 0]),
+      new Uint8Array([0, 0, 0, 1]),
+      addSize(combineUint8Arrays([
+        stringsToUint8Array("url "),
+        new Uint8Array([0]),
+        new Uint8Array([0, 0, 1])
+      ]))
+    ]))
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/create-minf.ts
+var createMinf = ({
+  vmhdAtom,
+  stblAtom
+}) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("minf"),
+    vmhdAtom,
+    createDinf(),
+    stblAtom
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/create-smhd.ts
+var createSmhd = () => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("smhd"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    new Uint8Array([0, 0]),
+    new Uint8Array([0, 0])
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/stbl/create-ctts.ts
+var makeEntry = (entry) => {
+  return combineUint8Arrays([
+    numberTo32BitUIntOrInt(entry.sampleCount),
+    numberTo32BitUIntOrInt(entry.sampleOffset)
+  ]);
+};
+var createCttsBox = (samplePositions) => {
+  const offsets = samplePositions.map((s) => s.cts - s.dts);
+  const entries = [];
+  let lastOffset = null;
+  for (const offset of offsets) {
+    if (lastOffset === offset) {
+      entries[entries.length - 1].sampleCount++;
+    } else {
+      entries.push({
+        sampleCount: 1,
+        sampleOffset: offset
+      });
+    }
+    lastOffset = offset;
+  }
+  const needsCtts = entries.length > 0 && entries.some((e) => e.sampleOffset !== 0);
+  if (!needsCtts) {
+    return null;
+  }
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("ctts"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    numberTo32BitUIntOrInt(entries.length),
+    ...entries.map((e) => makeEntry(e))
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/stbl/create-stco.ts
+var createStcoAtom = (samplePositions) => {
+  const chunkOffsets = [];
+  let lastChunk;
+  for (const sample of samplePositions) {
+    if (lastChunk !== sample.chunk) {
+      chunkOffsets.push(sample.offset);
+    }
+    lastChunk = sample.chunk;
+  }
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("stco"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    numberTo32BitUIntOrInt(chunkOffsets.length),
+    ...chunkOffsets.map((offset) => numberTo32BitUIntOrInt(offset))
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/stbl/create-stsc.ts
+var createEntry = (entry) => {
+  return combineUint8Arrays([
+    numberTo32BitUIntOrInt(entry.firstChunk),
+    numberTo32BitUIntOrInt(entry.samplesPerChunk),
+    numberTo32BitUIntOrInt(entry.sampleDescriptionIndex)
+  ]);
+};
+var createStsc = (samplePositions) => {
+  const entries = [];
+  const deduplicateLastEntry = () => {
+    const lastEntry = entries[entries.length - 1];
+    const secondToLastEntry = entries[entries.length - 2];
+    if (lastEntry && secondToLastEntry && lastEntry.samplesPerChunk === secondToLastEntry.samplesPerChunk && lastEntry.sampleDescriptionIndex === secondToLastEntry.sampleDescriptionIndex) {
+      const lastIndex = entries.length - 1;
+      entries.length = lastIndex;
+    }
+  };
+  let lastChunk;
+  for (const samplePosition of samplePositions) {
+    if (samplePosition.chunk === lastChunk) {
+      entries[entries.length - 1].samplesPerChunk++;
+    } else {
+      deduplicateLastEntry();
+      entries.push({
+        firstChunk: samplePosition.chunk,
+        samplesPerChunk: 1,
+        sampleDescriptionIndex: 1
+      });
+      lastChunk = samplePosition.chunk;
+    }
+  }
+  deduplicateLastEntry();
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("stsc"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    numberTo32BitUIntOrInt(entries.length),
+    ...entries.map((e) => createEntry(e))
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/stbl/create-stss.ts
+var createStss = (samplePositions) => {
+  const samples = samplePositions.map((sample, i) => [sample.isKeyframe, i]).filter((s) => s[0]).map((s) => s[1] + 1);
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("stss"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    numberTo32BitUIntOrInt(samples.length),
+    ...samples.map((sample) => numberTo32BitUIntOrInt(sample))
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/stbl/create-stsz.ts
+var createStsz = (samplePositions) => {
+  const sampleSizes = samplePositions.map((samplePosition) => samplePosition.size);
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("stsz"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    numberTo32BitUIntOrInt(0),
+    numberTo32BitUIntOrInt(sampleSizes.length),
+    ...sampleSizes.map((size) => numberTo32BitUIntOrInt(size))
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/stbl/create-stts.ts
+var makeEntry2 = (entry) => {
+  return combineUint8Arrays([
+    numberTo32BitUIntOrInt(entry.sampleCount),
+    numberTo32BitUIntOrInt(entry.sampleOffset)
+  ]);
+};
+var createSttsAtom = (samplePositions) => {
+  let lastDuration = null;
+  const durations = samplePositions.map((_, i, a) => {
+    if (a[i].duration === undefined || a[i].duration === 0) {
+      return (a[i + 1]?.dts ?? a[i].dts) - a[i].dts;
+    }
+    return a[i].duration;
+  });
+  const entries = [];
+  for (const duration2 of durations) {
+    if (duration2 === lastDuration) {
+      entries[entries.length - 1].sampleCount++;
+    } else {
+      entries.push({
+        sampleCount: 1,
+        sampleOffset: duration2
+      });
+    }
+    lastDuration = duration2;
+  }
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("stts"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    numberTo32BitUIntOrInt(entries.length),
+    ...entries.map((e) => makeEntry2(e))
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-avc1.ts
+var createStsdData = (codecSpecificData) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("stsd"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    new Uint8Array([0, 0, 0, 1]),
+    codecSpecificData
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/create-stbl.ts
+var createStbl = ({
+  samplePositions,
+  codecSpecificData,
+  isVideo
+}) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("stbl"),
+    createStsdData(codecSpecificData),
+    createSttsAtom(samplePositions),
+    isVideo ? createStss(samplePositions) : null,
+    createCttsBox(samplePositions),
+    createStsc(samplePositions),
+    createStsz(samplePositions),
+    createStcoAtom(samplePositions),
+    isVideo ? null : new Uint8Array([
+      0,
+      0,
+      0,
+      26,
+      115,
+      103,
+      112,
+      100,
+      1,
+      0,
+      0,
+      0,
+      114,
+      111,
+      108,
+      108,
+      0,
+      0,
+      0,
+      2,
+      0,
+      0,
+      0,
+      1,
+      255,
+      255,
+      0,
+      0,
+      0,
+      28,
+      115,
+      98,
+      103,
+      112,
+      0,
+      0,
+      0,
+      0,
+      114,
+      111,
+      108,
+      108,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      10,
+      25,
+      0,
+      0,
+      0,
+      1
+    ])
+  ].filter(truthy)));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/create-vmhd.ts
+var createVmhd = () => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("vmhd"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 1]),
+    new Uint8Array([0, 0]),
+    new Uint8Array([0, 0, 0, 0, 0, 0])
+  ]));
+};
+
+// src/create/iso-base-media/udta/meta/create-hdlr.ts
+var createHdlr = (type) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("hdlr"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    stringsToUint8Array(type === "mdir" ? "mdir" : type === "video" ? "vide" : "soun"),
+    type === "mdir" ? numberTo32BitUIntOrInt(1634758764) : new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    stringsToUint8Array(type === "mdir" ? "\0" : type === "video" ? "VideoHandler\0" : "SoundHandler\0")
+  ]));
+};
+
+// src/create/iso-base-media/serialize-track.ts
+var serializeTrack = ({
+  track,
+  durationInUnits,
+  samplePositions,
+  timescale
+}) => {
+  if (track.codec !== "h264" && track.codec !== "aac") {
+    throw new Error("Currently only H.264 and AAC is supported");
+  }
+  return createTrak({
+    tkhd: track.codec === "aac" ? createTkhdForAudio({
+      creationTime: Date.now(),
+      flags: TKHD_FLAGS.TRACK_ENABLED | TKHD_FLAGS.TRACK_IN_MOVIE,
+      modificationTime: Date.now(),
+      duration: durationInUnits,
+      trackId: track.trackNumber,
+      volume: 1,
+      timescale
+    }) : track.type === "video" ? createTkhdForVideo({
+      creationTime: Date.now(),
+      modificationTime: Date.now(),
+      duration: durationInUnits,
+      flags: TKHD_FLAGS.TRACK_ENABLED | TKHD_FLAGS.TRACK_IN_MOVIE,
+      height: track.height,
+      width: track.width,
+      matrix: IDENTITY_MATRIX,
+      trackId: track.trackNumber,
+      volume: 0,
+      timescale
+    }) : new Uint8Array(stringsToUint8Array("wrong")),
+    mdia: createMdia({
+      mdhd: createMdhd({
+        creationTime: null,
+        modificationTime: null,
+        duration: durationInUnits,
+        timescale: track.timescale
+      }),
+      hdlr: track.type === "video" ? createHdlr("video") : createHdlr("audio"),
+      minf: createMinf({
+        stblAtom: createStbl({
+          samplePositions,
+          isVideo: track.type === "video",
+          codecSpecificData: createCodecSpecificData(track)
+        }),
+        vmhdAtom: track.type === "audio" ? createSmhd() : createVmhd()
+      })
+    })
+  });
+};
+
+// src/create/iso-base-media/udta/create-meta.ts
+var createMeta = ({
+  hdlr,
+  ilst
+}) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("meta"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    hdlr,
+    ilst
+  ]));
+};
+
+// src/create/iso-base-media/mp4-header.ts
+var HEADER_LENGTH = 1024000;
+var createPaddedMoovAtom = ({
+  durationInUnits,
+  trackInfo,
+  timescale
+}) => {
+  return padIsoBaseMediaBytes(createMoov({
+    mvhd: createMvhd({
+      timescale,
+      durationInUnits,
+      matrix: IDENTITY_MATRIX,
+      nextTrackId: trackInfo.map((t) => t.track.trackNumber).reduce((a, b) => Math.max(a, b), 0) + 1,
+      rate: 1,
+      volume: 1,
+      creationTime: Date.now(),
+      modificationTime: Date.now()
+    }),
+    traks: trackInfo.map((track) => {
+      return serializeTrack({
+        timescale,
+        track: track.track,
+        durationInUnits,
+        samplePositions: track.samplePositions
+      });
+    }),
+    udta: createUdta(createMeta({
+      hdlr: createHdlr("mdir"),
+      ilst: createIlst([
+        createToo("WebCodecs"),
+        createCmt("Made with @remotion/webcodecs")
+      ])
+    }))
+  }), HEADER_LENGTH);
+};
+
+// src/create/iso-base-media/create-iso-base-media.ts
+var createIsoBaseMedia = async ({
+  writer,
+  onBytesProgress,
+  onMillisecondsProgress,
+  logLevel
+}) => {
+  const header = createIsoBaseMediaFtyp({
+    compatibleBrands: ["isom", "iso2", "avc1", "mp42"],
+    majorBrand: "isom",
+    minorBrand: 512
+  });
+  const w = await writer.createContent();
+  await w.write(header);
+  let durationInUnits = 0;
+  const currentTracks = [];
+  const samplePositions = [];
+  const sampleChunkIndices = [];
+  const moovOffset = w.getWrittenByteCount();
+  const getPaddedMoovAtom = () => {
+    return createPaddedMoovAtom({
+      durationInUnits,
+      trackInfo: currentTracks.map((track) => {
+        return {
+          track,
+          durationInUnits,
+          samplePositions: samplePositions[track.trackNumber] ?? [],
+          timescale: track.timescale
+        };
+      }),
+      timescale: 1000
+    });
+  };
+  await w.write(getPaddedMoovAtom());
+  let mdatSize = 8;
+  const mdatSizeOffset = w.getWrittenByteCount();
+  await w.write(combineUint8Arrays([
+    numberTo32BitUIntOrInt(mdatSize),
+    stringsToUint8Array("mdat")
+  ]));
+  const updateMdatSize = async () => {
+    await w.updateDataAt(mdatSizeOffset, numberTo32BitUIntOrInt(mdatSize));
+    onBytesProgress(w.getWrittenByteCount());
+  };
+  const operationProm = { current: Promise.resolve() };
+  const updateMoov = async () => {
+    await w.updateDataAt(moovOffset, getPaddedMoovAtom());
+    onBytesProgress(w.getWrittenByteCount());
+  };
+  const updateDuration = (newDuration) => {
+    durationInUnits = newDuration;
+    onMillisecondsProgress(newDuration);
+  };
+  const addCodecPrivateToTrack = ({
+    trackNumber: trackNumber2,
+    codecPrivate: codecPrivate2
+  }) => {
+    currentTracks.forEach((track) => {
+      if (track.trackNumber === trackNumber2) {
+        track.codecPrivate = codecPrivate2;
+      }
+    });
+  };
+  let lastChunkWasVideo = false;
+  const addSample = async ({
+    chunk,
+    trackNumber: trackNumber2,
+    isVideo,
+    timescale,
+    codecPrivate: codecPrivate2
+  }) => {
+    const position = w.getWrittenByteCount();
+    await w.write(chunk.data);
+    mdatSize += chunk.data.length;
+    onBytesProgress(w.getWrittenByteCount());
+    if (codecPrivate2) {
+      addCodecPrivateToTrack({ trackNumber: trackNumber2, codecPrivate: codecPrivate2 });
+    }
+    const newDuration = Math.round((chunk.timestamp + (chunk.duration ?? 0)) / 1000);
+    updateDuration(newDuration);
+    if (!samplePositions[trackNumber2]) {
+      samplePositions[trackNumber2] = [];
+    }
+    if (typeof sampleChunkIndices[trackNumber2] === "undefined") {
+      sampleChunkIndices[trackNumber2] = 0;
+    }
+    if (isVideo && chunk.type === "key") {
+      sampleChunkIndices[trackNumber2]++;
+    } else if (!isVideo && samplePositions[trackNumber2].length % 22 === 0) {
+      sampleChunkIndices[trackNumber2]++;
+    } else if (lastChunkWasVideo !== isVideo) {
+      sampleChunkIndices[trackNumber2]++;
+    }
+    const samplePositionToAdd = {
+      isKeyframe: chunk.type === "key",
+      offset: position,
+      chunk: sampleChunkIndices[trackNumber2],
+      cts: Math.round(chunk.cts / (1e6 / timescale)),
+      dts: Math.round(chunk.dts / (1e6 / timescale)),
+      duration: Math.round((chunk.duration ?? 0) / (1e6 / timescale)),
+      size: chunk.data.length
+    };
+    lastChunkWasVideo = isVideo;
+    samplePositions[trackNumber2].push(samplePositionToAdd);
+  };
+  const addTrack = (track) => {
+    const trackNumber2 = currentTracks.length + 1;
+    currentTracks.push({ ...track, trackNumber: trackNumber2 });
+    return Promise.resolve({ trackNumber: trackNumber2 });
+  };
+  const waitForFinishPromises = [];
+  return {
+    save: async () => {
+      const file = await w.save();
+      return file;
+    },
+    remove: async () => {
+      await w.remove();
+    },
+    addSample: ({ chunk, trackNumber: trackNumber2, isVideo, timescale, codecPrivate: codecPrivate2 }) => {
+      operationProm.current = operationProm.current.then(() => {
+        return addSample({
+          chunk,
+          trackNumber: trackNumber2,
+          isVideo,
+          timescale,
+          codecPrivate: codecPrivate2
+        });
+      });
+      return operationProm.current;
+    },
+    addTrack: (track) => {
+      operationProm.current = operationProm.current.then(() => addTrack(track));
+      return operationProm.current;
+    },
+    updateTrackSampleRate: ({ sampleRate, trackNumber: trackNumber2 }) => {
+      currentTracks.forEach((track) => {
+        if (track.trackNumber === trackNumber2) {
+          if (track.type !== "audio") {
+            throw new Error(`Tried to update sample rate of track ${trackNumber2}, but it's not an audio track`);
+          }
+          track.sampleRate = sampleRate;
+        }
+      });
+    },
+    addWaitForFinishPromise: (promise) => {
+      waitForFinishPromises.push(promise);
+    },
+    async waitForFinish() {
+      Log.verbose(logLevel, "All write operations queued. Waiting for finish...");
+      await Promise.all(waitForFinishPromises.map((p) => p()));
+      Log.verbose(logLevel, "Cleanup tasks executed");
+      await operationProm.current;
+      await updateMoov();
+      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;
+    }
+  };
+};
+
+// src/create/matroska/cluster-segment.ts
 var CLUSTER_MIN_VINT_WIDTH = 8;
 var createClusterSegment = (timestamp) => {
   return makeMatroskaBytes({
@@ -1062,32 +2166,30 @@ var makeSimpleBlock = ({
   ]);
 };
 
-// src/create/timescale.ts
-var CREATE_TIME_SCALE = 1e6;
-
-// src/create/cluster.ts
+// src/create/matroska/cluster.ts
 var maxClusterTimestamp = 2 ** 15;
-var timestampToClusterTimestamp = (timestamp) => {
-  return Math.round(timestamp / CREATE_TIME_SCALE * 1000);
+var timestampToClusterTimestamp = (timestamp, timescale) => {
+  return Math.round(timestamp / timescale * 1000);
 };
 var canFitInCluster = ({
   clusterStartTimestamp,
-  chunk
+  chunk,
+  timescale
 }) => {
-  const timecodeRelativeToCluster = timestampToClusterTimestamp(chunk.timestamp) - timestampToClusterTimestamp(clusterStartTimestamp);
+  const timecodeRelativeToCluster = timestampToClusterTimestamp(chunk.timestamp, timescale) - timestampToClusterTimestamp(clusterStartTimestamp, timescale);
   if (timecodeRelativeToCluster < 0) {
     throw new Error(`timecodeRelativeToCluster is negative`);
   }
   return timecodeRelativeToCluster <= maxClusterTimestamp;
 };
-var makeCluster = async (w, clusterStartTimestamp) => {
-  const cluster = createClusterSegment(timestampToClusterTimestamp(clusterStartTimestamp));
+var makeCluster = async (w, clusterStartTimestamp, timescale) => {
+  const cluster = createClusterSegment(timestampToClusterTimestamp(clusterStartTimestamp, timescale));
   const clusterVIntPosition = w.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);
   const addSample = async (chunk, trackNumber2) => {
-    const timecodeRelativeToCluster = timestampToClusterTimestamp(chunk.timestamp) - timestampToClusterTimestamp(clusterStartTimestamp);
-    if (!canFitInCluster({ clusterStartTimestamp, chunk })) {
+    const timecodeRelativeToCluster = timestampToClusterTimestamp(chunk.timestamp, timescale) - timestampToClusterTimestamp(clusterStartTimestamp, timescale);
+    if (!canFitInCluster({ clusterStartTimestamp, chunk, timescale })) {
       throw new Error(`timecodeRelativeToCluster is too big: ${timecodeRelativeToCluster} > ${maxClusterTimestamp}`);
     }
     const keyframe = chunk.type === "key";
@@ -1109,11 +2211,12 @@ var makeCluster = async (w, clusterStartTimestamp) => {
     chunk,
     newT
   }) => {
-    const newTimestamp = timestampToClusterTimestamp(newT);
-    const oldTimestamp = timestampToClusterTimestamp(clusterStartTimestamp);
+    const newTimestamp = timestampToClusterTimestamp(newT, timescale);
+    const oldTimestamp = timestampToClusterTimestamp(clusterStartTimestamp, timescale);
     const canFit = canFitInCluster({
       chunk,
-      clusterStartTimestamp
+      clusterStartTimestamp,
+      timescale
     });
     if (!canFit) {
       return true;
@@ -1128,7 +2231,7 @@ var makeCluster = async (w, clusterStartTimestamp) => {
   };
 };
 
-// src/create/make-duration-with-padding.ts
+// src/create/matroska/make-duration-with-padding.ts
 var makeDurationWithPadding = (newDuration) => {
   return makeMatroskaBytes({
     type: "Duration",
@@ -1140,7 +2243,7 @@ var makeDurationWithPadding = (newDuration) => {
   });
 };
 
-// src/create/matroska-cues.ts
+// src/create/matroska/matroska-cues.ts
 var createMatroskaCues = (cues) => {
   return makeMatroskaBytes({
     type: "Cues",
@@ -1186,7 +2289,7 @@ var createMatroskaCues = (cues) => {
   });
 };
 
-// src/create/matroska-header.ts
+// src/create/matroska/matroska-header.ts
 var makeMatroskaHeader = () => {
   return makeMatroskaBytes({
     type: "Header",
@@ -1249,7 +2352,7 @@ var makeMatroskaHeader = () => {
   });
 };
 
-// src/create/matroska-info.ts
+// src/create/matroska/matroska-info.ts
 var makeMatroskaInfo = ({ timescale }) => {
   return makeMatroskaBytes({
     type: "Info",
@@ -1278,7 +2381,7 @@ var makeMatroskaInfo = ({ timescale }) => {
   });
 };
 
-// src/create/matroska-seek.ts
+// src/create/matroska/matroska-seek.ts
 var createMatroskaSeekHead = (seeks) => {
   return padMatroskaBytes(makeMatroskaBytes({
     type: "SeekHead",
@@ -1307,7 +2410,7 @@ var createMatroskaSeekHead = (seeks) => {
   }), 200);
 };
 
-// src/create/matroska-segment.ts
+// src/create/matroska/matroska-segment.ts
 var MATROSKA_SEGMENT_MIN_VINT_WIDTH = 8;
 var createMatroskaSegment = (children) => {
   return makeMatroskaBytes({
@@ -1317,11 +2420,6 @@ var createMatroskaSegment = (children) => {
   });
 };
 
-// src/truthy.ts
-function truthy(value) {
-  return Boolean(value);
-}
-
 // src/boxes/webm/traversal.ts
 var getMainSegment = (segments) => {
   return segments.find((s) => s.type === "Segment");
@@ -1584,7 +2682,7 @@ var makeMatroskaColorBytes = ({
   });
 };
 
-// src/create/matroska-trackentry.ts
+// src/create/matroska/matroska-trackentry.ts
 var makeMatroskaVideoBytes = ({
   color: color2,
   width,
@@ -1824,15 +2922,20 @@ var makeMatroskaVideoTrackEntryBytes = ({
   });
 };
 var makeMatroskaTracks = (tracks2) => {
+  const bytesArr = tracks2.map((t) => {
+    const bytes = t.type === "video" ? makeMatroskaVideoTrackEntryBytes(t) : makeMatroskaAudioTrackEntryBytes(t);
+    return bytes;
+  });
   return padMatroskaBytes(makeMatroskaBytes({
     type: "Tracks",
-    value: tracks2,
+    value: bytesArr,
     minVintWidth: null
   }), 500);
 };
 
-// src/create/create-media.ts
-var createMedia = async ({
+// src/create/matroska/create-matroska-media.ts
+var timescale = 1e6;
+var createMatroskaMedia = async ({
   writer,
   onBytesProgress,
   onMillisecondsProgress
@@ -1841,7 +2944,7 @@ var createMedia = async ({
   const w = await writer.createContent();
   await w.write(header.bytes);
   const matroskaInfo = makeMatroskaInfo({
-    timescale: CREATE_TIME_SCALE
+    timescale
   });
   const currentTracks = [];
   const seeks = [];
@@ -1890,7 +2993,7 @@ var createMedia = async ({
   };
   await w.write(matroskaSegment.bytes);
   const clusterOffset = w.getWrittenByteCount();
-  let currentCluster = await makeCluster(w, 0);
+  let currentCluster = await makeCluster(w, 0, timescale);
   seeks.push({
     hexString: matroskaElements.Cluster,
     byte: clusterOffset - seekHeadOffset
@@ -1908,7 +3011,7 @@ var createMedia = async ({
     })) {
       return { cluster: currentCluster, isNew: false, smallestProgress };
     }
-    currentCluster = await makeCluster(w, smallestProgress);
+    currentCluster = await makeCluster(w, smallestProgress, timescale);
     return { cluster: currentCluster, isNew: true, smallestProgress };
   };
   const updateDuration = async (newDuration) => {
@@ -1916,7 +3019,11 @@ var createMedia = async ({
     await w.updateDataAt(durationOffset, blocks.bytes);
     onBytesProgress(w.getWrittenByteCount());
   };
-  const addSample = async (chunk, trackNumber2, isVideo) => {
+  const addSample = async ({
+    chunk,
+    trackNumber: trackNumber2,
+    isVideo
+  }) => {
     trackNumberProgresses[trackNumber2] = chunk.timestamp;
     const { cluster, isNew, smallestProgress } = await getClusterOrMakeNew({
       chunk,
@@ -1928,7 +3035,7 @@ var createMedia = async ({
     if (isNew) {
       const newCluster = w.getWrittenByteCount();
       cues.push({
-        time: timestampToClusterTimestamp(smallestProgress) + timecodeRelativeToCluster,
+        time: timestampToClusterTimestamp(smallestProgress, timescale) + timecodeRelativeToCluster,
         clusterPosition: newCluster - seekHeadOffset,
         trackNumber: trackNumber2
       });
@@ -1944,6 +3051,16 @@ var createMedia = async ({
   const operationProm = { current: Promise.resolve() };
   const waitForFinishPromises = [];
   return {
+    updateTrackSampleRate: ({ sampleRate, trackNumber: trackNumber2 }) => {
+      currentTracks.forEach((track) => {
+        if (track.trackNumber === trackNumber2) {
+          if (track.type !== "audio") {
+            throw new Error("track is not audio");
+          }
+          track.sampleRate = sampleRate;
+        }
+      });
+    },
     save: async () => {
       const file = await w.save();
       return file;
@@ -1951,8 +3068,8 @@ var createMedia = async ({
     remove: async () => {
       await w.remove();
     },
-    addSample: (chunk, trackNumber2, isVideo) => {
-      operationProm.current = operationProm.current.then(() => addSample(chunk, trackNumber2, isVideo));
+    addSample: ({ chunk, trackNumber: trackNumber2, isVideo }) => {
+      operationProm.current = operationProm.current.then(() => addSample({ chunk, trackNumber: trackNumber2, isVideo }));
       return operationProm.current;
     },
     updateDuration: (duration2) => {
@@ -1961,8 +3078,7 @@ var createMedia = async ({
     },
     addTrack: (track) => {
       const trackNumber2 = currentTracks.length + 1;
-      const bytes = track.type === "video" ? makeMatroskaVideoTrackEntryBytes({ ...track, trackNumber: trackNumber2 }) : makeMatroskaAudioTrackEntryBytes({ ...track, trackNumber: trackNumber2 });
-      operationProm.current = operationProm.current.then(() => addTrack(bytes));
+      operationProm.current = operationProm.current.then(() => addTrack({ ...track, trackNumber: trackNumber2 }));
       trackNumbers.push(trackNumber2);
       return operationProm.current.then(() => ({ trackNumber: trackNumber2 }));
     },
@@ -1985,40 +3101,6 @@ var createMedia = async ({
   };
 };
 
-// src/log.ts
-var logLevels = ["trace", "verbose", "info", "warn", "error"];
-var getNumberForLogLevel = (level) => {
-  return logLevels.indexOf(level);
-};
-var isEqualOrBelowLogLevel = (currentLevel, level) => {
-  return getNumberForLogLevel(currentLevel) <= getNumberForLogLevel(level);
-};
-var Log = {
-  trace: (logLevel, ...args) => {
-    if (isEqualOrBelowLogLevel(logLevel, "trace")) {
-      return console.log(...args);
-    }
-  },
-  verbose: (logLevel, ...args) => {
-    if (isEqualOrBelowLogLevel(logLevel, "verbose")) {
-      return console.log(...args);
-    }
-  },
-  info: (logLevel, ...args) => {
-    if (isEqualOrBelowLogLevel(logLevel, "info")) {
-      return console.log(...args);
-    }
-  },
-  warn: (logLevel, ...args) => {
-    if (isEqualOrBelowLogLevel(logLevel, "warn")) {
-      return console.warn(...args);
-    }
-  },
-  error: (...args) => {
-    return console.error(...args);
-  }
-};
-
 // src/boxes/iso-base-media/traversal.ts
 var getMoovBox = (segments) => {
   const moovBox = segments.find((s) => s.type === "moov-box");
@@ -2227,21 +3309,12 @@ var getTimescaleAndDuration = (trakBox) => {
   }
   return null;
 };
-var getFps = (segments) => {
-  const moovBox = getMoovBox(segments);
-  if (!moovBox) {
-    return null;
-  }
-  const trackBoxes = getTraks(moovBox);
-  const trackBox = trackBoxes.find(trakBoxContainsVideo);
-  if (!trackBox) {
-    return null;
-  }
-  const timescaleAndDuration = getTimescaleAndDuration(trackBox);
+var getFpsFromMp4TrakBox = (trakBox) => {
+  const timescaleAndDuration = getTimescaleAndDuration(trakBox);
   if (!timescaleAndDuration) {
     return null;
   }
-  const sttsBox = getSttsBox(trackBox);
+  const sttsBox = getSttsBox(trakBox);
   if (!sttsBox) {
     return null;
   }
@@ -2251,6 +3324,18 @@ var getFps = (segments) => {
     durationInSamples: timescaleAndDuration.duration
   });
 };
+var getFps = (segments) => {
+  const moovBox = getMoovBox(segments);
+  if (!moovBox) {
+    return null;
+  }
+  const trackBoxes = getTraks(moovBox);
+  const trackBox = trackBoxes.find(trakBoxContainsVideo);
+  if (!trackBox) {
+    return null;
+  }
+  return getFpsFromMp4TrakBox(trackBox);
+};
 var hasFps = (boxes) => {
   try {
     return getFps(boxes) !== null;
@@ -2300,9 +3385,9 @@ var getCodecSpecificatorFromEsdsBox = ({
     };
   }
   const audioSpecificConfig = descriptor.decoderSpecificConfigs.find((d) => {
-    return d.type === "audio-specific-config" ? d : null;
+    return d.type === "mp4a-specific-config" ? d : null;
   });
-  if (!audioSpecificConfig || audioSpecificConfig.type !== "audio-specific-config") {
+  if (!audioSpecificConfig || audioSpecificConfig.type !== "mp4a-specific-config") {
     throw new Error("No audio-specific-config");
   }
   return {
@@ -2311,6 +3396,29 @@ var getCodecSpecificatorFromEsdsBox = ({
     description: audioSpecificConfig.asBytes
   };
 };
+var getCodecPrivateFromTrak = (trakBox) => {
+  const stsdBox = getStsdBox(trakBox);
+  if (!stsdBox) {
+    return null;
+  }
+  const audioSample = stsdBox.samples.find((s) => s.type === "audio");
+  if (!audioSample || audioSample.type !== "audio") {
+    return null;
+  }
+  const esds = audioSample.children.find((b) => b.type === "esds-box");
+  if (!esds || esds.type !== "esds-box") {
+    return null;
+  }
+  const decoderConfigDescriptor = esds.descriptors.find((d) => d.type === "decoder-config-descriptor");
+  if (!decoderConfigDescriptor) {
+    return null;
+  }
+  const mp4a = decoderConfigDescriptor.decoderSpecificConfigs.find((d) => d.type === "mp4a-specific-config");
+  if (!mp4a) {
+    return null;
+  }
+  return mp4a.asBytes;
+};
 var onSample = (sample, children) => {
   const child = children.find((c) => c.type === "esds-box");
   if (child && child.type === "esds-box") {
@@ -2655,14 +3763,7 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     ]);
     return Number(bigInt);
   };
-  const getFourByteNumber = (littleEndian = false) => {
-    if (littleEndian) {
-      const one = getUint8();
-      const two = getUint8();
-      const three = getUint8();
-      const four = getUint8();
-      return four << 24 | three << 16 | two << 8 | one;
-    }
+  const getFourByteNumber = () => {
     return getUint8() << 24 | getUint8() << 16 | getUint8() << 8 | getUint8();
   };
   const getPaddedFourByteNumber = () => {
@@ -3016,7 +4117,7 @@ var parseAv1PrivateData = (data, colrAtom) => {
   const chroma_sample_position = iterator.getBits(2);
   str += subsampling_x && subsampling_y ? chroma_sample_position === 1 ? "1" : "0" : "0";
   str += ".";
-  if (colrAtom) {
+  if (colrAtom && colrAtom.colorType === "transfer-characteristics") {
     str += colrAtom.primaries.toString().padStart(2, "0");
     str += ".";
     str += colrAtom.transfer.toString().padStart(2, "0");
@@ -3159,6 +4260,9 @@ var getIsoBmColrConfig = (trakBox) => {
   if (!colrAtom) {
     return null;
   }
+  if (colrAtom.colorType !== "transfer-characteristics") {
+    return null;
+  }
   return {
     fullRange: colrAtom.fullRangeFlag,
     matrixCoefficients: colrAtom.matrixIndex === 1 ? "bt709" : colrAtom.matrixIndex === 5 ? "bt470bg" : colrAtom.matrixIndex === 6 ? "smpte170m" : null,
@@ -3217,7 +4321,7 @@ var makeBaseMediaTrack = (trakBox) => {
       sampleRate,
       description,
       trakBox,
-      codecPrivate: null,
+      codecPrivate: getCodecPrivateFromTrak(trakBox),
       codecWithoutConfig: getAudioCodecFromTrack(trakBox)
     };
   }
@@ -3270,7 +4374,8 @@ var makeBaseMediaTrack = (trakBox) => {
       primaries: null,
       transferCharacteristics: null
     },
-    codecWithoutConfig: getVideoCodecFromIsoTrak(trakBox)
+    codecWithoutConfig: getVideoCodecFromIsoTrak(trakBox),
+    fps: getFpsFromMp4TrakBox(trakBox)
   };
   return track;
 };
@@ -3534,7 +4639,7 @@ var getMatroskaAudioCodecString = (track) => {
   throw new Error(`Unknown codec: ${codec.value}`);
 };
 var getTrack = ({
-  timescale,
+  timescale: timescale2,
   track
 }) => {
   const trackType2 = getTrackTypeSegment(track);
@@ -3577,7 +4682,7 @@ var getTrack = ({
         numerator: 1,
         denominator: 1
       },
-      timescale,
+      timescale: timescale2,
       codedHeight: height.value.value,
       codedWidth: width.value.value,
       displayAspectHeight: displayHeight2 ? displayHeight2.value.value : height.value.value,
@@ -3593,7 +4698,8 @@ var getTrack = ({
       },
       codecWithoutConfig: getMatroskaVideoCodecWithoutConfigString({
         codecSegment: codec
-      })
+      }),
+      fps: null
     };
   }
   if (trackTypeToString(trackType2.value.value) === "audio") {
@@ -3607,7 +4713,7 @@ var getTrack = ({
       type: "audio",
       trackId,
       codec: getMatroskaAudioCodecString(track),
-      timescale,
+      timescale: timescale2,
       numberOfChannels,
       sampleRate,
       description: getAudioDescription(track),
@@ -3622,7 +4728,7 @@ var getTrack = ({
 };
 
 // src/boxes/webm/get-ready-tracks.ts
-var getTracksFromMatroska = (segment, timescale) => {
+var getTracksFromMatroska = (segment, timescale2) => {
   const tracksSegment = getTracksSegment(segment);
   if (!tracksSegment) {
     throw new Error("No tracks segment");
@@ -3637,7 +4743,7 @@ var getTracksFromMatroska = (segment, timescale) => {
     }
     const track = getTrack({
       track: trackEntrySegment,
-      timescale
+      timescale: timescale2
     });
     if (track) {
       tracks2.push(track);
@@ -3806,7 +4912,8 @@ var getSamplePositions = ({
         isKeyframe,
         dts,
         cts,
-        duration: delta
+        duration: delta,
+        chunk: i
       });
       dts += delta;
       offsetInThisChunk += size;
@@ -3859,7 +4966,8 @@ var getSamplesFromTraf = (trafSegment, moofOffset) => {
         cts: dts,
         duration: duration2,
         isKeyframe: keyframe,
-        size
+        size,
+        chunk: 0
       };
       samples.push(samplePosition);
       offset += size;
@@ -4169,7 +5277,7 @@ var getAvailableInfo = (options, parseResult, state) => {
 };
 
 // src/boxes/iso-base-media/esds/decoder-specific-config.ts
-var parseDecoderSpecificConfig = (iterator) => {
+var parseDecoderSpecificConfig = (iterator, logLevel) => {
   const layerTag = iterator.getUint8();
   const layerSize = iterator.getPaddedFourByteNumber();
   const start = iterator.counter.getOffset();
@@ -4193,13 +5301,15 @@ var parseDecoderSpecificConfig = (iterator) => {
   if (read < layerSize) {
     iterator.discard(layerSize - read);
   }
-  const patchedAsBytes = bytes.byteLength === 2 && bytes[0] === 17 && bytes[1] === 136 ? new Uint8Array([17, 144]) : bytes;
+  if (bytes.byteLength === 2 && bytes[0] === 17 && bytes[1] === 136) {
+    Log.warn(logLevel, "Chrome has a bug and might not be able to decode this audio. It will be fixed, see: https://issues.chromium.org/issues/360083330");
+  }
   return {
-    type: "audio-specific-config",
+    type: "mp4a-specific-config",
     audioObjectType,
     samplingFrequencyIndex,
     channelConfiguration,
-    asBytes: patchedAsBytes
+    asBytes: bytes
   };
 };
 
@@ -4214,7 +5324,8 @@ var mapToObjectAudioIndicator = (num) => {
   return "unknown";
 };
 var processDescriptor = ({
-  iterator
+  iterator,
+  logLevel
 }) => {
   const tag = iterator.getUint8();
   if (tag === 4) {
@@ -4230,8 +5341,8 @@ var processDescriptor = ({
     const maxBitrate = iterator.getUint32();
     const avgBitrate = iterator.getUint32();
     const decoderSpecificConfigs = [];
-    while (size - (iterator.counter.getOffset() - initialOffset) >= 0) {
-      const decoderSpecificConfig = parseDecoderSpecificConfig(iterator);
+    while (size - (iterator.counter.getOffset() - initialOffset) > 0) {
+      const decoderSpecificConfig = parseDecoderSpecificConfig(iterator, logLevel);
       decoderSpecificConfigs.push(decoderSpecificConfig);
     }
     return {
@@ -4261,12 +5372,13 @@ var processDescriptor = ({
     descriptor: null
   };
 };
-var parseDescriptors = (iterator, maxBytes) => {
+var parseDescriptors = (iterator, maxBytes, logLevel) => {
   const descriptors = [];
   const initialOffset = iterator.counter.getOffset();
   while (iterator.bytesRemaining() > 0 && iterator.counter.getOffset() - initialOffset < maxBytes) {
     const { descriptor } = processDescriptor({
-      iterator
+      iterator,
+      logLevel
     });
     if (descriptor) {
       descriptors.push(descriptor);
@@ -4281,7 +5393,8 @@ var parseDescriptors = (iterator, maxBytes) => {
 var parseEsds = ({
   data,
   size,
-  fileOffset
+  fileOffset,
+  logLevel
 }) => {
   const version = data.getUint8();
   data.discard(3);
@@ -4290,7 +5403,7 @@ var parseEsds = ({
   const esId = data.getUint16();
   data.discard(1);
   const remaining = size - (data.counter.getOffset() - fileOffset);
-  const descriptors = parseDescriptors(data, remaining);
+  const descriptors = parseDescriptors(data, remaining, logLevel);
   const remainingNow = size - (data.counter.getOffset() - fileOffset);
   data.discard(remainingNow);
   return {
@@ -4397,15 +5510,19 @@ var parseMdat = async ({
       break;
     }
     const bytes = data.getSlice(samplesWithIndex.samplePosition.size);
-    const timestamp = Math.floor(samplesWithIndex.samplePosition.cts * 1e6 / samplesWithIndex.track.timescale);
-    const duration2 = Math.floor(samplesWithIndex.samplePosition.duration * 1e6 / samplesWithIndex.track.timescale);
+    const timestamp = samplesWithIndex.samplePosition.cts * 1e6 / samplesWithIndex.track.timescale;
+    const duration2 = samplesWithIndex.samplePosition.duration * 1e6 / samplesWithIndex.track.timescale;
+    const cts = samplesWithIndex.samplePosition.cts * 1e6 / samplesWithIndex.track.timescale;
+    const dts = samplesWithIndex.samplePosition.dts * 1e6 / samplesWithIndex.track.timescale;
     if (samplesWithIndex.track.type === "audio") {
       await options.parserState.onAudioSample(samplesWithIndex.track.trackId, {
         data: bytes,
         timestamp,
+        duration: duration2,
+        cts,
+        dts,
         trackId: samplesWithIndex.track.trackId,
-        type: samplesWithIndex.samplePosition.isKeyframe ? "key" : "delta",
-        duration: duration2
+        type: samplesWithIndex.samplePosition.isKeyframe ? "key" : "delta"
       });
     }
     if (samplesWithIndex.track.type === "video") {
@@ -4413,8 +5530,8 @@ var parseMdat = async ({
         data: bytes,
         timestamp,
         duration: duration2,
-        cts: samplesWithIndex.samplePosition.cts,
-        dts: samplesWithIndex.samplePosition.dts,
+        cts,
+        dts,
         trackId: samplesWithIndex.track.trackId,
         type: samplesWithIndex.samplePosition.isKeyframe ? "key" : "delta"
       });
@@ -4443,7 +5560,7 @@ var parseMdhd = ({
   data.discard(3);
   const creationTime = version === 1 ? Number(data.getUint64()) : data.getUint32();
   const modificationTime = version === 1 ? Number(data.getUint64()) : data.getUint32();
-  const timescale = data.getUint32();
+  const timescale2 = data.getUint32();
   const duration2 = version === 1 ? data.getUint64() : data.getUint32();
   const language2 = data.getUint16();
   const quality = data.getUint16();
@@ -4454,7 +5571,7 @@ var parseMdhd = ({
   return {
     type: "mdhd-box",
     duration: Number(duration2),
-    timescale,
+    timescale: timescale2,
     version,
     language: language2,
     quality,
@@ -4469,7 +5586,8 @@ var parseMoov = async ({
   offset,
   size,
   options,
-  signal
+  signal,
+  logLevel
 }) => {
   const children = await parseBoxes({
     iterator,
@@ -4478,8 +5596,8 @@ var parseMoov = async ({
     initialBoxes: [],
     options,
     continueMdat: false,
-    littleEndian: false,
-    signal
+    signal,
+    logLevel
   });
   if (children.status === "incomplete") {
     throw new Error("Incomplete boxes are not allowed");
@@ -4492,15 +5610,6 @@ var parseMoov = async ({
   };
 };
 
-// src/boxes/iso-base-media/to-date.ts
-var toUnixTimestamp = (value) => {
-  if (value === 0) {
-    return null;
-  }
-  const baseDate = new Date("1904-01-01T00:00:00Z");
-  return Math.floor(value + baseDate.getTime() / 1000) * 1000;
-};
-
 // src/boxes/iso-base-media/mvhd.ts
 var parseMvhd = ({
   iterator,
@@ -4523,14 +5632,17 @@ var parseMvhd = ({
   iterator.discard(2);
   iterator.discard(4);
   iterator.discard(4);
-  const matrix = [];
-  for (let i = 0;i < 9; i++) {
-    if (i % 3 === 2) {
-      matrix.push(iterator.getFixedPointSigned230Number());
-    } else {
-      matrix.push(iterator.getFixedPointSigned1616Number());
-    }
-  }
+  const matrix = [
+    iterator.getFixedPointSigned1616Number(),
+    iterator.getFixedPointSigned1616Number(),
+    iterator.getFixedPointSigned230Number(),
+    iterator.getFixedPointSigned1616Number(),
+    iterator.getFixedPointSigned1616Number(),
+    iterator.getFixedPointSigned230Number(),
+    iterator.getFixedPointSigned1616Number(),
+    iterator.getFixedPointSigned1616Number(),
+    iterator.getFixedPointSigned230Number()
+  ];
   iterator.discard(4 * 6);
   const nextTrackId = iterator.getUint32();
   volumeView.destroy();
@@ -4587,9 +5699,115 @@ var parseAvcc = ({
   };
 };
 
+// src/boxes/iso-base-media/parse-icc-profile.ts
+var parseIccProfile = (data) => {
+  const iterator = getArrayBufferIterator(data, Infinity);
+  const size = iterator.getUint32();
+  if (size !== data.length) {
+    throw new Error("Invalid ICC profile size");
+  }
+  const preferredCMMType = iterator.getByteString(4);
+  const profileVersion = iterator.getByteString(4);
+  const profileDeviceClass = iterator.getByteString(4);
+  const colorSpace = iterator.getByteString(4);
+  const pcs = iterator.getByteString(4);
+  const dateTime = iterator.getSlice(12);
+  const signature = iterator.getByteString(4);
+  if (signature !== "acsp") {
+    throw new Error("Invalid ICC profile signature");
+  }
+  const primaryPlatform = iterator.getByteString(4);
+  const profileFlags = iterator.getUint32();
+  const deviceManufacturer = iterator.getByteString(4);
+  const deviceModel = iterator.getByteString(4);
+  const deviceAttributes = iterator.getUint64();
+  const renderingIntent = iterator.getUint32();
+  const pcsIlluminant1 = iterator.getUint32();
+  const pcsIlluminant2 = iterator.getUint32();
+  const pcsIlluminant3 = iterator.getUint32();
+  const profileCreator = iterator.getByteString(4);
+  const profileId = iterator.getByteString(16);
+  iterator.discard(28);
+  const tagCount = iterator.getUint32();
+  const entries = [];
+  for (let i = 0;i < tagCount; i++) {
+    const entry = {
+      tag: iterator.getByteString(4),
+      offset: iterator.getUint32(),
+      size: iterator.getUint32()
+    };
+    entries.push(entry);
+  }
+  let lastOffset = -1;
+  let rXYZ = null;
+  let gXYZ = null;
+  let bXYZ = null;
+  let whitePoint = null;
+  for (const entry of entries) {
+    const found = data.slice(entry.offset, entry.offset + entry.size);
+    if (entry.tag === "rXYZ" || entry.tag === "gXYZ" || entry.tag === "bXYZ" || entry.tag === "wtpt") {
+      const it = getArrayBufferIterator(found, Infinity);
+      it.discard(4);
+      const x = it.getInt32() / 65536;
+      const y = it.getInt32() / 65536;
+      const z = it.getInt32() / 65536;
+      it.destroy();
+      const point = { x, y, z };
+      if (entry.tag === "rXYZ") {
+        rXYZ = point;
+      } else if (entry.tag === "gXYZ") {
+        gXYZ = point;
+      } else if (entry.tag === "bXYZ") {
+        bXYZ = point;
+      } else if (entry.tag === "wtpt") {
+        whitePoint = point;
+      }
+    }
+    if (lastOffset !== -1) {
+      const bytesToAdvance = entry.offset - lastOffset;
+      const bytesToGoBackwards = entry.size - bytesToAdvance;
+      if (bytesToGoBackwards > 0) {
+        iterator.counter.decrement(bytesToGoBackwards);
+      }
+    }
+    lastOffset = entry.offset;
+  }
+  const profile = {
+    size,
+    preferredCMMType,
+    profileVersion,
+    profileDeviceClass,
+    colorSpace,
+    pcs,
+    dateTime,
+    signature,
+    primaryPlatform,
+    profileFlags,
+    deviceManufacturer,
+    deviceModel,
+    deviceAttributes,
+    renderingIntent,
+    pcsIlluminant: [
+      pcsIlluminant1 / 65536,
+      pcsIlluminant2 / 65536,
+      pcsIlluminant3 / 65536
+    ],
+    profileCreator,
+    profileId,
+    entries,
+    bXYZ,
+    gXYZ,
+    rXYZ,
+    whitePoint
+  };
+  iterator.destroy();
+  return profile;
+};
+
 // src/boxes/iso-base-media/stsd/colr.ts
 var parseColorParameterBox = ({
-  iterator
+  iterator,
+  size
 }) => {
   const byteString = iterator.getByteString(4);
   if (byteString === "nclx") {
@@ -4601,6 +5819,7 @@ var parseColorParameterBox = ({
     iterator.stopReadingBits();
     return {
       type: "colr-box",
+      colorType: "transfer-characteristics",
       fullRangeFlag,
       matrixIndex,
       primaries: primaries2,
@@ -4613,12 +5832,22 @@ var parseColorParameterBox = ({
     const matrixIndex = iterator.getUint16();
     return {
       type: "colr-box",
+      colorType: "transfer-characteristics",
       fullRangeFlag: false,
       matrixIndex,
       primaries: primaries2,
       transfer
     };
   }
+  if (byteString === "prof") {
+    const profile = iterator.getSlice(size - 12);
+    return {
+      type: "colr-box",
+      colorType: "icc-profile",
+      profile,
+      parsed: parseIccProfile(profile)
+    };
+  }
   throw new Error("Unexpected box type " + byteString);
 };
 
@@ -4678,7 +5907,6 @@ var parseMebx = async ({
   offset,
   size,
   options,
-  littleEndian,
   signal
 }) => {
   iterator.discard(6);
@@ -4690,8 +5918,8 @@ var parseMebx = async ({
     initialBoxes: [],
     options,
     continueMdat: false,
-    littleEndian,
-    signal
+    signal,
+    logLevel: "info"
   });
   if (children.status === "incomplete") {
     throw new Error("Incomplete boxes are not allowed");
@@ -4855,7 +6083,8 @@ var audioTags = [
 var processSample = async ({
   iterator,
   options,
-  signal
+  signal,
+  logLevel
 }) => {
   const fileOffset = iterator.counter.getOffset();
   const bytesRemaining = iterator.bytesRemaining();
@@ -4899,8 +6128,8 @@ var processSample = async ({
         initialBoxes: [],
         options,
         continueMdat: false,
-        littleEndian: false,
-        signal
+        signal,
+        logLevel
       });
       if (children.status === "incomplete") {
         throw new Error("Incomplete boxes are not allowed");
@@ -4946,8 +6175,8 @@ var processSample = async ({
         initialBoxes: [],
         options,
         continueMdat: false,
-        littleEndian: false,
-        signal
+        signal,
+        logLevel
       });
       if (children.status === "incomplete") {
         throw new Error("Incomplete boxes are not allowed");
@@ -4997,8 +6226,8 @@ var processSample = async ({
         initialBoxes: [],
         options,
         continueMdat: false,
-        littleEndian: false,
-        signal
+        signal,
+        logLevel
       });
       if (children.status === "incomplete") {
         throw new Error("Incomplete boxes are not allowed");
@@ -5051,8 +6280,8 @@ var processSample = async ({
       initialBoxes: [],
       options,
       continueMdat: false,
-      littleEndian: false,
-      signal
+      signal,
+      logLevel
     }) : (iterator.discard(bytesRemainingInBox), { status: "done", segments: [] });
     if (children.status === "incomplete") {
       throw new Error("Incomplete boxes are not allowed");
@@ -5088,7 +6317,8 @@ var parseSamples = async ({
   iterator,
   maxBytes,
   options,
-  signal
+  signal,
+  logLevel
 }) => {
   const samples = [];
   const initialOffset = iterator.counter.getOffset();
@@ -5096,7 +6326,8 @@ var parseSamples = async ({
     const { sample } = await processSample({
       iterator,
       options,
-      signal
+      signal,
+      logLevel
     });
     if (sample) {
       samples.push(sample);
@@ -5124,7 +6355,8 @@ var parseStsd = async ({
     iterator,
     maxBytes: bytesRemainingInBox,
     options,
-    signal
+    signal,
+    logLevel: "info"
   });
   if (boxes.length !== numberOfEntries) {
     throw new Error(`Expected ${numberOfEntries} sample descriptions, got ${boxes.length}`);
@@ -5394,7 +6626,8 @@ var parseTrak = async ({
   size,
   offsetAtStart,
   options,
-  signal
+  signal,
+  logLevel
 }) => {
   const children = await parseBoxes({
     iterator: data,
@@ -5403,8 +6636,8 @@ var parseTrak = async ({
     initialBoxes: [],
     options,
     continueMdat: false,
-    littleEndian: false,
-    signal
+    signal,
+    logLevel
   });
   if (children.status === "incomplete") {
     throw new Error("Incomplete boxes are not allowed");
@@ -5465,8 +6698,8 @@ var getChildren = async ({
   iterator,
   bytesRemainingInBox,
   options,
-  littleEndian,
-  signal
+  signal,
+  logLevel
 }) => {
   const parseChildren = boxType === "mdia" || boxType === "minf" || boxType === "stbl" || boxType === "moof" || boxType === "dims" || boxType === "wave" || boxType === "traf" || boxType === "stsb";
   if (parseChildren) {
@@ -5477,8 +6710,8 @@ var getChildren = async ({
       initialBoxes: [],
       options,
       continueMdat: false,
-      littleEndian,
-      signal
+      signal,
+      logLevel
     });
     if (parsed.status === "incomplete") {
       throw new Error("Incomplete boxes are not allowed");
@@ -5527,12 +6760,12 @@ var processBox = async ({
   allowIncompleteBoxes,
   parsedBoxes,
   options,
-  littleEndian,
-  signal
+  signal,
+  logLevel
 }) => {
   const fileOffset = iterator.counter.getOffset();
   const bytesRemaining = iterator.bytesRemaining();
-  const boxSizeRaw = iterator.getFourByteNumber(littleEndian);
+  const boxSizeRaw = iterator.getFourByteNumber();
   if (boxSizeRaw === 1 && iterator.bytesRemaining() < 12 || iterator.bytesRemaining() < 4) {
     iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
     if (allowIncompleteBoxes) {
@@ -5554,7 +6787,7 @@ var processBox = async ({
     };
   }
   const boxType = iterator.getByteString(4);
-  const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber(littleEndian) : boxSizeRaw;
+  const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber() : boxSizeRaw;
   if (bytesRemaining < boxSize) {
     if (boxType === "mdat") {
       const shouldSkip = (options.canSkipVideoData || !hasTracks(parsedBoxes)) && options.supportsContentRange;
@@ -5604,7 +6837,8 @@ var processBox = async ({
   }
   if (boxType === "colr") {
     const box = parseColorParameterBox({
-      iterator
+      iterator,
+      size: boxSize
     });
     return {
       type: "complete",
@@ -5749,7 +6983,6 @@ var processBox = async ({
       offset: fileOffset,
       size: boxSize,
       options,
-      littleEndian,
       signal
     });
     return {
@@ -5765,7 +6998,8 @@ var processBox = async ({
       offset: fileOffset,
       size: boxSize,
       options,
-      signal
+      signal,
+      logLevel
     });
     return {
       type: "complete",
@@ -5780,7 +7014,8 @@ var processBox = async ({
       size: boxSize,
       offsetAtStart: fileOffset,
       options,
-      signal
+      signal,
+      logLevel
     });
     const transformedTrack = makeBaseMediaTrack(box);
     if (transformedTrack) {
@@ -5880,7 +7115,8 @@ var processBox = async ({
     const box = parseEsds({
       data: iterator,
       size: boxSize,
-      fileOffset
+      fileOffset,
+      logLevel
     });
     return {
       type: "complete",
@@ -5915,8 +7151,8 @@ var processBox = async ({
     iterator,
     bytesRemainingInBox,
     options,
-    littleEndian,
-    signal
+    signal,
+    logLevel
   });
   return {
     type: "complete",
@@ -5938,8 +7174,8 @@ var parseBoxes = async ({
   initialBoxes,
   options,
   continueMdat,
-  littleEndian,
-  signal
+  signal,
+  logLevel
 }) => {
   let boxes = initialBoxes;
   const initialOffset = iterator.counter.getOffset();
@@ -5957,8 +7193,8 @@ var parseBoxes = async ({
       allowIncompleteBoxes,
       parsedBoxes: initialBoxes,
       options,
-      littleEndian,
-      signal
+      signal,
+      logLevel
     });
     if (result.type === "incomplete") {
       if (Number.isFinite(maxBytes)) {
@@ -5975,8 +7211,8 @@ var parseBoxes = async ({
             initialBoxes: boxes,
             options,
             continueMdat: false,
-            littleEndian,
-            signal
+            signal,
+            logLevel
           });
         },
         skipTo: null
@@ -5994,8 +7230,8 @@ var parseBoxes = async ({
             initialBoxes: boxes,
             options,
             continueMdat: result,
-            littleEndian,
-            signal
+            signal,
+            logLevel
           }));
         },
         skipTo: null
@@ -6027,8 +7263,8 @@ var parseBoxes = async ({
             initialBoxes: boxes,
             options,
             continueMdat: false,
-            littleEndian,
-            signal
+            signal,
+            logLevel
           });
         },
         skipTo: result.skipTo
@@ -6046,8 +7282,8 @@ var parseBoxes = async ({
             initialBoxes: boxes,
             options,
             continueMdat: false,
-            littleEndian,
-            signal
+            signal,
+            logLevel
           });
         },
         skipTo: null
@@ -6073,8 +7309,8 @@ var parseBoxes = async ({
           initialBoxes: boxes,
           options,
           continueMdat: false,
-          littleEndian,
-          signal
+          signal,
+          logLevel
         });
       },
       skipTo: skipped ? mdatState.fileOffset : null
@@ -6145,11 +7381,11 @@ var getSampleFromBlock = (ebml, parserContext, offset) => {
   const { keyframe } = parseBlockFlags(iterator, ebml.type === "SimpleBlock" ? matroskaElements.SimpleBlock : matroskaElements.Block);
   const { codec, trackTimescale } = parserContext.parserState.getTrackInfoByNumber(trackNumber2);
   const clusterOffset = parserContext.parserState.getTimestampOffsetForByteOffset(offset);
-  const timescale = parserContext.parserState.getTimescale();
+  const timescale2 = parserContext.parserState.getTimescale();
   if (clusterOffset === undefined) {
     throw new Error("Could not find offset for byte offset " + offset);
   }
-  const timecodeInNanoSeconds = (timecodeRelativeToCluster + clusterOffset) * timescale * (trackTimescale ?? 1);
+  const timecodeInNanoSeconds = (timecodeRelativeToCluster + clusterOffset) * timescale2 * (trackTimescale ?? 1);
   const timecodeInMicroseconds = timecodeInNanoSeconds / 1000;
   if (!codec) {
     throw new Error(`Could not find codec for track ${trackNumber2}`);
@@ -6158,8 +7394,8 @@ var getSampleFromBlock = (ebml, parserContext, offset) => {
   if (codec.startsWith("V_")) {
     const partialVideoSample = {
       data: iterator.getSlice(remainingNow),
-      cts: null,
-      dts: null,
+      cts: timecodeInMicroseconds,
+      dts: timecodeInMicroseconds,
       duration: undefined,
       trackId: trackNumber2,
       timestamp: timecodeInMicroseconds
@@ -6187,7 +7423,9 @@ var getSampleFromBlock = (ebml, parserContext, offset) => {
       trackId: trackNumber2,
       timestamp: timecodeInMicroseconds,
       type: "key",
-      duration: undefined
+      duration: undefined,
+      cts: timecodeInMicroseconds,
+      dts: timecodeInMicroseconds
     };
     iterator.destroy();
     return {
@@ -6603,7 +7841,8 @@ var parseWebm = (counter, parserContext) => {
 var parseVideo = ({
   iterator,
   options,
-  signal
+  signal,
+  logLevel
 }) => {
   if (iterator.bytesRemaining() === 0) {
     return Promise.resolve({
@@ -6613,7 +7852,8 @@ var parseVideo = ({
         return parseVideo({
           iterator,
           options,
-          signal
+          signal,
+          logLevel
         });
       },
       skipTo: null
@@ -6630,8 +7870,8 @@ var parseVideo = ({
       initialBoxes: [],
       options,
       continueMdat: false,
-      littleEndian: false,
-      signal
+      signal,
+      logLevel
     });
   }
   if (iterator.isWebm()) {
@@ -6673,15 +7913,15 @@ var makeParserState = ({
   const queuedAudioSamples = {};
   const queuedVideoSamples = {};
   const declinedTrackNumbers = [];
-  let timescale = null;
+  let timescale2 = null;
   const getTimescale = () => {
-    if (timescale === null) {
+    if (timescale2 === null) {
       return 1e6;
     }
-    return timescale;
+    return timescale2;
   };
   const setTimescale = (newTimescale) => {
-    timescale = newTimescale;
+    timescale2 = newTimescale;
   };
   const timestampMap = new Map;
   const setTimestampOffset = (byteOffset, timestamp) => {
@@ -6775,6 +8015,7 @@ var parseMedia = async ({
   onAudioTrack,
   onVideoTrack,
   signal,
+  logLevel = "info",
   ...more
 }) => {
   const state = makeParserState({
@@ -6834,7 +8075,8 @@ var parseMedia = async ({
       parseResult = await parseVideo({
         iterator,
         options,
-        signal: signal ?? null
+        signal: signal ?? null,
+        logLevel
       });
     }
     const availableInfo = getAvailableInfo(fields ?? {}, parseResult, state);
@@ -6879,7 +8121,8 @@ var parseMedia = async ({
 };
 // src/index.ts
 var MediaParserInternals = {
-  createMedia,
+  createMatroskaMedia,
+  createIsoBaseMedia,
   Log
 };
 export {