agentroam-runtime-darwin-arm64 0.2.0-preview.68 → 0.2.0-preview.69

package/runtime/node_modules/mediabunny/dist/bundles/mediabunny.cjs

@@ -977,6 +977,13 @@ var Mediabunny = (() => {
     }
     return chromiumVersionCache = Number(match[1]);
   };
+  var isAndroidCache = null;
+  var isAndroid = () => {
+    if (isAndroidCache !== null) {
+      return isAndroidCache;
+    }
+    return isAndroidCache = typeof navigator !== "undefined" && /Android/.test(navigator.userAgent);
+  };
   var missingWebCodecsClassMessage = (className) => {
     if (typeof globalThis.isSecureContext !== "undefined" && !globalThis.isSecureContext) {
       return `${className} is not available in this environment; this may be because this page is running in an insecure context. Try serving your page over HTTPS or use localhost.`;
@@ -1157,7 +1164,7 @@ var Mediabunny = (() => {
     let minValue = Infinity;
     for (let i = 0; i < array.length; i++) {
       const value = getValue(array[i]);
-      if (value < minValue) {
+      if (minIndex === -1 || value < minValue) {
         minValue = value;
         minIndex = i;
       }
@@ -1169,7 +1176,7 @@ var Mediabunny = (() => {
     let maxValue = -Infinity;
     for (let i = 0; i < array.length; i++) {
       const value = getValue(array[i]);
-      if (value > maxValue) {
+      if (maxIndex === -1 || value > maxValue) {
         maxValue = value;
         maxIndex = i;
       }
@@ -1566,9 +1573,9 @@ var Mediabunny = (() => {
         throw new TypeError("tags.raw, when provided, must be an object.");
       }
       for (const value of Object.values(tags.raw)) {
-        if (value !== null && typeof value !== "string" && !(Array.isArray(value) && value.every((x) => typeof x === "string")) && !(value instanceof Uint8Array) && !(value instanceof RichImageData) && !(value instanceof AttachedFile) && !isRecordStringString(value)) {
+        if (value !== null && typeof value !== "string" && !(Array.isArray(value) && value.every((x) => typeof x === "string")) && !(value instanceof Uint8Array) && !(Array.isArray(value) && value.every((x) => x instanceof Uint8Array)) && !(value instanceof RichImageData) && !(value instanceof AttachedFile) && !isRecordStringString(value)) {
           throw new TypeError(
-            "Each value in tags.raw must be a string, string array, Uint8Array, RichImageData, AttachedFile, Record<string, string>, or null."
+            "Each value in tags.raw must be a string, string array, Uint8Array, Uint8Array array, RichImageData, AttachedFile, Record<string, string>, or null."
           );
         }
       }
@@ -1703,6 +1710,7 @@ var Mediabunny = (() => {
     7350
   ];
   var aacChannelMap = [-1, 1, 2, 3, 4, 5, 6, 8];
+  var generalAudioObjectTypes = [1, 2, 3, 4, 6, 7, 17, 19, 20, 21, 22];
   var parseAacAudioSpecificConfig = (bytes2) => {
     if (!bytes2 || bytes2.byteLength < 2) {
       throw new TypeError("AAC description must be at least 2 bytes long.");
@@ -1725,7 +1733,12 @@ var Mediabunny = (() => {
       if (coreObjectType === 22) {
         bitstream.skipBits(4);
       }
-    } else {
+    }
+    let frameLength = 1024;
+    if (generalAudioObjectTypes.includes(coreObjectType)) {
+      frameLength = bitstream.readBits(1) ? 960 : 1024;
+    }
+    if (objectType !== 5 && objectType !== 29) {
       while (bitstream.getBitsLeft() > 15) {
         const searchStart = bitstream.pos;
         if (bitstream.readBits(11) !== 695) {
@@ -1749,8 +1762,10 @@ var Mediabunny = (() => {
       coreObjectType,
       frequencyIndex,
       channelConfiguration,
+      coreSampleRate: sampleRate,
       outputSampleRate,
-      outputNumberOfChannels: psPresent && numberOfChannels === 1 ? 2 : numberOfChannels
+      outputNumberOfChannels: psPresent && numberOfChannels === 1 ? 2 : numberOfChannels,
+      frameLength
     };
   };
   var readAacObjectType = (bitstream) => {
@@ -1851,12 +1866,289 @@ var Mediabunny = (() => {
     bitstream.writeBits(13, frameLength);
   };
 
+  // shared/mp3-misc.ts
+  var MP3_FRAME_HEADER_SIZE = 4;
+  var MP3_DECODER_DELAY = 529;
+  var SAMPLING_RATES = [44100, 48e3, 32e3];
+  var KILOBIT_RATES = [
+    // lowSamplingFrequency === 0
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    // layer = 0
+    -1,
+    32,
+    40,
+    48,
+    56,
+    64,
+    80,
+    96,
+    112,
+    128,
+    160,
+    192,
+    224,
+    256,
+    320,
+    -1,
+    // layer 1
+    -1,
+    32,
+    48,
+    56,
+    64,
+    80,
+    96,
+    112,
+    128,
+    160,
+    192,
+    224,
+    256,
+    320,
+    384,
+    -1,
+    // layer = 2
+    -1,
+    32,
+    64,
+    96,
+    128,
+    160,
+    192,
+    224,
+    256,
+    288,
+    320,
+    352,
+    384,
+    416,
+    448,
+    -1,
+    // layer = 3
+    // lowSamplingFrequency === 1
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    // layer = 0
+    -1,
+    8,
+    16,
+    24,
+    32,
+    40,
+    48,
+    56,
+    64,
+    80,
+    96,
+    112,
+    128,
+    144,
+    160,
+    -1,
+    // layer = 1
+    -1,
+    8,
+    16,
+    24,
+    32,
+    40,
+    48,
+    56,
+    64,
+    80,
+    96,
+    112,
+    128,
+    144,
+    160,
+    -1,
+    // layer = 2
+    -1,
+    32,
+    48,
+    56,
+    64,
+    80,
+    96,
+    112,
+    128,
+    144,
+    160,
+    176,
+    192,
+    224,
+    256,
+    -1
+    // layer = 3
+  ];
+  var XING = 1483304551;
+  var INFO = 1231971951;
+  var computeMp3FrameSize = (lowSamplingFrequency, layer, bitrate, sampleRate, padding) => {
+    if (layer === 0) {
+      return 0;
+    } else if (layer === 1) {
+      return Math.floor(144 * bitrate / (sampleRate << lowSamplingFrequency)) + padding;
+    } else if (layer === 2) {
+      return Math.floor(144 * bitrate / sampleRate) + padding;
+    } else {
+      return (Math.floor(12 * bitrate / sampleRate) + padding) * 4;
+    }
+  };
+  var computeAverageMp3FrameSize = (lowSamplingFrequency, layer, bitrate, sampleRate) => {
+    if (layer === 0) {
+      return 0;
+    } else if (layer === 1) {
+      return 144 * bitrate / (sampleRate << lowSamplingFrequency);
+    } else if (layer === 2) {
+      return 144 * bitrate / sampleRate;
+    } else {
+      return 12 * bitrate / sampleRate * 4;
+    }
+  };
+  var getXingOffset = (mpegVersionId, channel) => {
+    return mpegVersionId === 3 ? channel === 3 ? 21 : 36 : channel === 3 ? 13 : 21;
+  };
+  var readMp3FrameHeader = (word, remainingBytes) => {
+    const firstByte = word >>> 24;
+    const secondByte = word >>> 16 & 255;
+    const thirdByte = word >>> 8 & 255;
+    const fourthByte = word & 255;
+    if (firstByte !== 255 && secondByte !== 255 && thirdByte !== 255 && fourthByte !== 255) {
+      return {
+        header: null,
+        bytesAdvanced: 4
+      };
+    }
+    if (firstByte !== 255) {
+      return { header: null, bytesAdvanced: 1 };
+    }
+    if ((secondByte & 224) !== 224) {
+      return { header: null, bytesAdvanced: 1 };
+    }
+    let lowSamplingFrequency = 0;
+    let mpeg25 = 0;
+    if (secondByte & 1 << 4) {
+      lowSamplingFrequency = secondByte & 1 << 3 ? 0 : 1;
+    } else {
+      lowSamplingFrequency = 1;
+      mpeg25 = 1;
+    }
+    const mpegVersionId = secondByte >> 3 & 3;
+    const layer = secondByte >> 1 & 3;
+    const bitrateIndex = thirdByte >> 4 & 15;
+    const frequencyIndex = (thirdByte >> 2 & 3) % 3;
+    const padding = thirdByte >> 1 & 1;
+    const channel = fourthByte >> 6 & 3;
+    const modeExtension = fourthByte >> 4 & 3;
+    const copyright = fourthByte >> 3 & 1;
+    const original = fourthByte >> 2 & 1;
+    const emphasis = fourthByte & 3;
+    const kilobitRate = KILOBIT_RATES[lowSamplingFrequency * 16 * 4 + layer * 16 + bitrateIndex];
+    if (kilobitRate === -1) {
+      return { header: null, bytesAdvanced: 1 };
+    }
+    const bitrate = kilobitRate * 1e3;
+    const sampleRate = SAMPLING_RATES[frequencyIndex] >> lowSamplingFrequency + mpeg25;
+    const frameLength = computeMp3FrameSize(lowSamplingFrequency, layer, bitrate, sampleRate, padding);
+    if (remainingBytes !== null && remainingBytes < frameLength) {
+      return { header: null, bytesAdvanced: 1 };
+    }
+    let audioSamplesInFrame;
+    if (mpegVersionId === 3) {
+      audioSamplesInFrame = layer === 3 ? 384 : 1152;
+    } else {
+      if (layer === 3) {
+        audioSamplesInFrame = 384;
+      } else if (layer === 2) {
+        audioSamplesInFrame = 1152;
+      } else {
+        audioSamplesInFrame = 576;
+      }
+    }
+    return {
+      header: {
+        totalSize: frameLength,
+        mpegVersionId,
+        lowSamplingFrequency,
+        layer,
+        bitrate,
+        frequencyIndex,
+        sampleRate,
+        channel,
+        modeExtension,
+        copyright,
+        original,
+        emphasis,
+        audioSamplesInFrame
+      },
+      bytesAdvanced: 1
+    };
+  };
+  var encodeSynchsafe = (unsynchsafed) => {
+    let mask = 127;
+    let synchsafed = 0;
+    let unsynchsafedRest = unsynchsafed;
+    while ((mask ^ 2147483647) !== 0) {
+      synchsafed = unsynchsafedRest & ~mask;
+      synchsafed <<= 1;
+      synchsafed |= unsynchsafedRest & mask;
+      mask = (mask + 1 << 8) - 1;
+      unsynchsafedRest = synchsafed;
+    }
+    return synchsafed;
+  };
+  var decodeSynchsafe = (synchsafed) => {
+    let mask = 2130706432;
+    let unsynchsafed = 0;
+    while (mask !== 0) {
+      unsynchsafed >>= 1;
+      unsynchsafed |= synchsafed & mask;
+      mask >>= 8;
+    }
+    return unsynchsafed;
+  };
+  var getMp3ChannelCount = (channel) => {
+    return channel === 3 ? 1 : 2;
+  };
+
   // shared/ac3-misc.ts
   var AC3_SAMPLE_RATES = [48e3, 44100, 32e3];
   var EAC3_REDUCED_SAMPLE_RATES = [24e3, 22050, 16e3];
 
+  // shared/truehd-misc.ts
+  var TRUEHD_MAJOR_SYNC_WORD = 4168249274;
+
   // src/version.ts
-  var VERSION = "1.62.1";
+  var VERSION = "1.64.0";
   var VERSIONED_NAME = `Mediabunny v${VERSION}`;
 
   // src/codec-data.ts
@@ -3749,6 +4041,14 @@ var Mediabunny = (() => {
         ;
     }
   };
+  var determineAudioPacketType = (codec, packetData) => {
+    if (codec === "truehd") {
+      const syncWord = packetData.byteLength >= 8 ? toDataView(packetData).getUint32(4) : null;
+      return syncWord === TRUEHD_MAJOR_SYNC_WORD ? "key" : "delta";
+    } else {
+      return "key";
+    }
+  };
   var readVorbisComments = (bytes2, metadataTags) => {
     const commentView = toDataView(bytes2);
     let commentPos = 0;
@@ -4796,7 +5096,8 @@ var Mediabunny = (() => {
     "flac",
     "ac3",
     "eac3",
-    "dts"
+    "dts",
+    "truehd"
   ];
   var AUDIO_CODECS = [
     ...NON_PCM_AUDIO_CODECS,
@@ -4805,6 +5106,7 @@ var Mediabunny = (() => {
   var SUBTITLE_CODECS = [
     "webvtt"
   ];
+  var AUDIO_CODECS_WITH_DELTA_PACKETS = ["truehd"];
   var AVC_LEVEL_TABLE = [
     { maxMacroblocks: 99, maxBitrate: 64e3, maxDpbMbs: 396, level: 10 },
     // Level 1
@@ -5011,14 +5313,15 @@ var Mediabunny = (() => {
   ];
   var buildVideoCodecString = (codec, width, height, bitrate, alpha) => {
     if (codec === "avc") {
-      const profileIndication = 100;
+      const constrainedBaseline = isWebKit();
+      const profileIndication = constrainedBaseline ? 66 : 100;
       const totalMacroblocks = Math.ceil(width / 16) * Math.ceil(height / 16);
       const levelInfo = AVC_LEVEL_TABLE.find(
         (level) => totalMacroblocks <= level.maxMacroblocks && bitrate <= level.maxBitrate
       ) ?? last(AVC_LEVEL_TABLE);
       const levelIndication = levelInfo ? levelInfo.level : 0;
       const hexProfileIndication = profileIndication.toString(16).padStart(2, "0");
-      const hexProfileCompatibility = "00";
+      const hexProfileCompatibility = constrainedBaseline ? "40" : "00";
       const hexLevelIndication = levelIndication.toString(16).padStart(2, "0");
       return `avc1.${hexProfileIndication}${hexProfileCompatibility}${hexLevelIndication}`;
     } else if (codec === "hevc") {
@@ -5377,6 +5680,8 @@ var Mediabunny = (() => {
       return "ec-3";
     } else if (codec === "dts") {
       return "dtsc";
+    } else if (codec === "truehd") {
+      return "mlpa";
     } else if (PCM_AUDIO_CODECS.includes(codec)) {
       return codec;
     }
@@ -5414,6 +5719,8 @@ var Mediabunny = (() => {
       return "ec-3";
     } else if (codec === "dts") {
       return dtsFormat ?? "dtsc";
+    } else if (codec === "truehd") {
+      return "mlpa";
     } else if (codec && PCM_AUDIO_CODECS.includes(codec)) {
       return codec;
     }
@@ -5449,7 +5756,80 @@ var Mediabunny = (() => {
         return void 0;
     }
   };
+  var getAudioPreRollDuration = (codec, decoderConfig) => {
+    switch (codec) {
+      case "aac": {
+        if (!decoderConfig.description) {
+          return 1024 / decoderConfig.sampleRate;
+        }
+        const audioSpecificConfig = parseAacAudioSpecificConfig(toUint8Array(decoderConfig.description));
+        if (audioSpecificConfig.coreSampleRate === null) {
+          throw new Error("Invalid AAC sampling frequency index.");
+        }
+        return audioSpecificConfig.frameLength / audioSpecificConfig.coreSampleRate;
+      }
+      case "opus": {
+        return OPUS_PRE_ROLL_DURATION;
+      }
+      case "mp3": {
+        const { sampleRate, numberOfChannels } = decoderConfig;
+        const isMpeg1 = sampleRate >= 32e3;
+        const frameSamples = isMpeg1 ? 1152 : 576;
+        const minBitrate = isMpeg1 ? 32e3 : 8e3;
+        const maxMainDataBegin = isMpeg1 ? 511 : 255;
+        const sideInfoSize = isMpeg1 ? numberOfChannels === 1 ? 17 : 32 : numberOfChannels === 1 ? 9 : 17;
+        const minFrameSize = Math.floor(frameSamples / 8 * minBitrate / sampleRate);
+        const minMainDataSize = minFrameSize - MP3_FRAME_HEADER_SIZE - sideInfoSize;
+        const frameCount = 1 + Math.ceil(maxMainDataBegin / minMainDataSize);
+        return frameCount * frameSamples / sampleRate;
+      }
+      case "vorbis": {
+        assert(decoderConfig.description);
+        const bytes2 = toUint8Array(decoderConfig.description);
+        let pos = 1;
+        let lacedLengthsLeft = 2;
+        while (lacedLengthsLeft > 0) {
+          if (bytes2[pos++] < 255) {
+            lacedLengthsLeft--;
+          }
+        }
+        const blockSizeByte = bytes2[pos + 28];
+        const longBlockSize = 1 << (blockSizeByte >> 4);
+        return longBlockSize / 2 / decoderConfig.sampleRate;
+      }
+      case "ac3":
+      case "eac3": {
+        return 256 / decoderConfig.sampleRate;
+      }
+      case "dts": {
+        return 512 / decoderConfig.sampleRate;
+      }
+      case "flac":
+      case "truehd":
+      case "pcm-s16":
+      case "pcm-s16be":
+      case "pcm-s24":
+      case "pcm-s24be":
+      case "pcm-s32":
+      case "pcm-s32be":
+      case "pcm-f32":
+      case "pcm-f32be":
+      case "pcm-f64":
+      case "pcm-f64be":
+      case "pcm-u8":
+      case "pcm-s8":
+      case "ulaw":
+      case "alaw": {
+        return 0;
+      }
+      default: {
+        assertNever(codec);
+        assert(false);
+      }
+    }
+  };
   var OPUS_SAMPLE_RATE = 48e3;
+  var OPUS_PRE_ROLL_DURATION = 0.4;
   var PCM_CODEC_REGEX = /^pcm-([usf])(\d+)(be)?$/;
   var parsePcmCodec = (codec) => {
     assert(PCM_AUDIO_CODECS.includes(codec));
@@ -5503,6 +5883,8 @@ var Mediabunny = (() => {
       return "eac3";
     } else if (DTS_FOURCCS.includes(codecString)) {
       return "dts";
+    } else if (codecString === "mlpa") {
+      return "truehd";
     } else if (codecString === "ulaw") {
       return "ulaw";
     } else if (codecString === "alaw") {
@@ -5691,7 +6073,8 @@ var Mediabunny = (() => {
     "pcm",
     "ac-3",
     "ec-3",
-    "dts"
+    "dts",
+    "mlpa"
   ];
   var validateAudioChunkMetadata = (metadata, trackCodec) => {
     if (!metadata) {
@@ -5786,6 +6169,10 @@ var Mediabunny = (() => {
           `Audio chunk metadata decoder configuration codec string for DTS must be one of the following four-character codes: ${DTS_FOURCCS.join(", ")}.`
         );
       }
+    } else if (metadata.decoderConfig.codec.startsWith("mlpa")) {
+      if (metadata.decoderConfig.codec !== "mlpa") {
+        throw new TypeError('Audio chunk metadata decoder configuration codec string for TrueHD must be "mlpa".');
+      }
     } else if (metadata.decoderConfig.codec.startsWith("pcm") || metadata.decoderConfig.codec.startsWith("ulaw") || metadata.decoderConfig.codec.startsWith("alaw")) {
       if (!PCM_AUDIO_CODECS.includes(metadata.decoderConfig.codec)) {
         throw new TypeError(
@@ -5817,279 +6204,6 @@ var Mediabunny = (() => {
     }
   };
 
-  // shared/mp3-misc.ts
-  var MP3_FRAME_HEADER_SIZE = 4;
-  var SAMPLING_RATES = [44100, 48e3, 32e3];
-  var KILOBIT_RATES = [
-    // lowSamplingFrequency === 0
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    // layer = 0
-    -1,
-    32,
-    40,
-    48,
-    56,
-    64,
-    80,
-    96,
-    112,
-    128,
-    160,
-    192,
-    224,
-    256,
-    320,
-    -1,
-    // layer 1
-    -1,
-    32,
-    48,
-    56,
-    64,
-    80,
-    96,
-    112,
-    128,
-    160,
-    192,
-    224,
-    256,
-    320,
-    384,
-    -1,
-    // layer = 2
-    -1,
-    32,
-    64,
-    96,
-    128,
-    160,
-    192,
-    224,
-    256,
-    288,
-    320,
-    352,
-    384,
-    416,
-    448,
-    -1,
-    // layer = 3
-    // lowSamplingFrequency === 1
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    -1,
-    // layer = 0
-    -1,
-    8,
-    16,
-    24,
-    32,
-    40,
-    48,
-    56,
-    64,
-    80,
-    96,
-    112,
-    128,
-    144,
-    160,
-    -1,
-    // layer = 1
-    -1,
-    8,
-    16,
-    24,
-    32,
-    40,
-    48,
-    56,
-    64,
-    80,
-    96,
-    112,
-    128,
-    144,
-    160,
-    -1,
-    // layer = 2
-    -1,
-    32,
-    48,
-    56,
-    64,
-    80,
-    96,
-    112,
-    128,
-    144,
-    160,
-    176,
-    192,
-    224,
-    256,
-    -1
-    // layer = 3
-  ];
-  var XING = 1483304551;
-  var INFO = 1231971951;
-  var computeMp3FrameSize = (lowSamplingFrequency, layer, bitrate, sampleRate, padding) => {
-    if (layer === 0) {
-      return 0;
-    } else if (layer === 1) {
-      return Math.floor(144 * bitrate / (sampleRate << lowSamplingFrequency)) + padding;
-    } else if (layer === 2) {
-      return Math.floor(144 * bitrate / sampleRate) + padding;
-    } else {
-      return (Math.floor(12 * bitrate / sampleRate) + padding) * 4;
-    }
-  };
-  var computeAverageMp3FrameSize = (lowSamplingFrequency, layer, bitrate, sampleRate) => {
-    if (layer === 0) {
-      return 0;
-    } else if (layer === 1) {
-      return 144 * bitrate / (sampleRate << lowSamplingFrequency);
-    } else if (layer === 2) {
-      return 144 * bitrate / sampleRate;
-    } else {
-      return 12 * bitrate / sampleRate * 4;
-    }
-  };
-  var getXingOffset = (mpegVersionId, channel) => {
-    return mpegVersionId === 3 ? channel === 3 ? 21 : 36 : channel === 3 ? 13 : 21;
-  };
-  var readMp3FrameHeader = (word, remainingBytes) => {
-    const firstByte = word >>> 24;
-    const secondByte = word >>> 16 & 255;
-    const thirdByte = word >>> 8 & 255;
-    const fourthByte = word & 255;
-    if (firstByte !== 255 && secondByte !== 255 && thirdByte !== 255 && fourthByte !== 255) {
-      return {
-        header: null,
-        bytesAdvanced: 4
-      };
-    }
-    if (firstByte !== 255) {
-      return { header: null, bytesAdvanced: 1 };
-    }
-    if ((secondByte & 224) !== 224) {
-      return { header: null, bytesAdvanced: 1 };
-    }
-    let lowSamplingFrequency = 0;
-    let mpeg25 = 0;
-    if (secondByte & 1 << 4) {
-      lowSamplingFrequency = secondByte & 1 << 3 ? 0 : 1;
-    } else {
-      lowSamplingFrequency = 1;
-      mpeg25 = 1;
-    }
-    const mpegVersionId = secondByte >> 3 & 3;
-    const layer = secondByte >> 1 & 3;
-    const bitrateIndex = thirdByte >> 4 & 15;
-    const frequencyIndex = (thirdByte >> 2 & 3) % 3;
-    const padding = thirdByte >> 1 & 1;
-    const channel = fourthByte >> 6 & 3;
-    const modeExtension = fourthByte >> 4 & 3;
-    const copyright = fourthByte >> 3 & 1;
-    const original = fourthByte >> 2 & 1;
-    const emphasis = fourthByte & 3;
-    const kilobitRate = KILOBIT_RATES[lowSamplingFrequency * 16 * 4 + layer * 16 + bitrateIndex];
-    if (kilobitRate === -1) {
-      return { header: null, bytesAdvanced: 1 };
-    }
-    const bitrate = kilobitRate * 1e3;
-    const sampleRate = SAMPLING_RATES[frequencyIndex] >> lowSamplingFrequency + mpeg25;
-    const frameLength = computeMp3FrameSize(lowSamplingFrequency, layer, bitrate, sampleRate, padding);
-    if (remainingBytes !== null && remainingBytes < frameLength) {
-      return { header: null, bytesAdvanced: 1 };
-    }
-    let audioSamplesInFrame;
-    if (mpegVersionId === 3) {
-      audioSamplesInFrame = layer === 3 ? 384 : 1152;
-    } else {
-      if (layer === 3) {
-        audioSamplesInFrame = 384;
-      } else if (layer === 2) {
-        audioSamplesInFrame = 1152;
-      } else {
-        audioSamplesInFrame = 576;
-      }
-    }
-    return {
-      header: {
-        totalSize: frameLength,
-        mpegVersionId,
-        lowSamplingFrequency,
-        layer,
-        bitrate,
-        frequencyIndex,
-        sampleRate,
-        channel,
-        modeExtension,
-        copyright,
-        original,
-        emphasis,
-        audioSamplesInFrame
-      },
-      bytesAdvanced: 1
-    };
-  };
-  var encodeSynchsafe = (unsynchsafed) => {
-    let mask = 127;
-    let synchsafed = 0;
-    let unsynchsafedRest = unsynchsafed;
-    while ((mask ^ 2147483647) !== 0) {
-      synchsafed = unsynchsafedRest & ~mask;
-      synchsafed <<= 1;
-      synchsafed |= unsynchsafedRest & mask;
-      mask = (mask + 1 << 8) - 1;
-      unsynchsafedRest = synchsafed;
-    }
-    return synchsafed;
-  };
-  var decodeSynchsafe = (synchsafed) => {
-    let mask = 2130706432;
-    let unsynchsafed = 0;
-    while (mask !== 0) {
-      unsynchsafed >>= 1;
-      unsynchsafed |= synchsafed & mask;
-      mask >>= 8;
-    }
-    return unsynchsafed;
-  };
-  var getMp3ChannelCount = (channel) => {
-    return channel === 3 ? 1 : 2;
-  };
-
   // src/demuxer.ts
   var Demuxer = class {
     constructor(input) {
@@ -6619,6 +6733,7 @@ var Mediabunny = (() => {
   };
 
   // src/isobmff/isobmff-demuxer.ts
+  var TRUEHD_CHANNEL_ASSIGNMENT_COUNTS = [2, 1, 1, 2, 2, 2, 2, 1, 1, 2, 2, 1, 1];
   var MAX_BOX_NESTING_DEPTH = 64;
   var IsobmffDemuxer = class _IsobmffDemuxer extends Demuxer {
     constructor(input) {
@@ -7427,6 +7542,8 @@ var Mediabunny = (() => {
                 } else if (DTS_FOURCCS.includes(codecName)) {
                   track.info.codec = "dts";
                   track.info.dtsFormat = codecName;
+                } else if (codecName === "mlpa") {
+                  track.info.codec = "truehd";
                 } else if (codecName === "twos") {
                   if (sampleSize === 8) {
                     track.info.codec = "pcm-s8";
@@ -7979,6 +8096,32 @@ var Mediabunny = (() => {
           }
           ;
           break;
+        case "dmlp":
+          {
+            const track = this.currentTrack;
+            if (!track || track.info?.type !== "audio") {
+              break;
+            }
+            const formatInfo = readU32Be(slice);
+            const rateBits = formatInfo >>> 28;
+            if (rateBits === 15) {
+              Logging._warn("Invalid dmlp box contents, ignoring.");
+              break;
+            }
+            track.info.sampleRate = (rateBits & 8 ? 44100 : 48e3) << (rateBits & 7);
+            const sixChannelAssignment = formatInfo >>> 15 & 31;
+            const eightChannelAssignment = formatInfo & 8191;
+            const channelAssignment = eightChannelAssignment || sixChannelAssignment;
+            let numberOfChannels = 0;
+            for (let i = 0; i < TRUEHD_CHANNEL_ASSIGNMENT_COUNTS.length; i++) {
+              if (channelAssignment & 1 << i) {
+                numberOfChannels += TRUEHD_CHANNEL_ASSIGNMENT_COUNTS[i];
+              }
+            }
+            track.info.numberOfChannels = numberOfChannels;
+          }
+          ;
+          break;
         case "stts":
           {
             const track = this.currentTrack;
@@ -10465,6 +10608,7 @@ var Mediabunny = (() => {
     "ac3": "A_AC3",
     "eac3": "A_EAC3",
     "dts": "A_DTS",
+    "truehd": "A_TRUEHD",
     "pcm-u8": "A_PCM/INT/LIT",
     "pcm-s16": "A_PCM/INT/LIT",
     "pcm-s16be": "A_PCM/INT/BIG",
@@ -10754,6 +10898,7 @@ var Mediabunny = (() => {
         if (track.defaultDurationNs !== null) {
           track.defaultDuration = this.currentSegment.timestampFactor * track.defaultDurationNs / 1e9;
         }
+        track.codecDelay = Math.round(this.currentSegment.timestampFactor * track.codecDelayNs / 1e9);
       }
       for (const cuePoint of this.currentSegment.cuePoints) {
         const track = this.currentSegment.idToTrack.get(cuePoint.trackId);
@@ -11152,6 +11297,8 @@ var Mediabunny = (() => {
               codecPrivate: null,
               defaultDuration: null,
               defaultDurationNs: null,
+              codecDelay: 0,
+              codecDelayNs: 0,
               name: null,
               languageCode: "eng",
               // The default in Matroska
@@ -11251,6 +11398,8 @@ var Mediabunny = (() => {
                   } else if (this.currentTrack.codecId === "A_DTS/LOSSLESS") {
                     this.currentTrack.info.dtsFormat = "dtsl";
                   }
+                } else if (codecIdWithoutSuffix === CODEC_STRING_MAP.truehd) {
+                  this.currentTrack.info.codec = "truehd";
                 } else if (this.currentTrack.codecId === "A_PCM/INT/LIT") {
                   if (this.currentTrack.info.bitDepth === 8) {
                     this.currentTrack.info.codec = "pcm-u8";
@@ -11408,6 +11557,13 @@ var Mediabunny = (() => {
           }
           ;
           break;
+        case 22186 /* CodecDelay */:
+          {
+            if (!this.currentTrack) break;
+            this.currentTrack.codecDelayNs = readUnsignedInt(slice, size);
+          }
+          ;
+          break;
         case 21358 /* Name */:
           {
             if (!this.currentTrack) break;
@@ -11676,7 +11832,7 @@ var Mediabunny = (() => {
             const flags = readU8(blockSlice);
             const lacing = flags >> 1 & 3;
             let isKeyFrame = !!(flags & 128);
-            if (trackData.track.info?.type === "audio" && trackData.track.info.codec) {
+            if (trackData.track.info?.type === "audio" && trackData.track.info.codec && !AUDIO_CODECS_WITH_DELTA_PACKETS.includes(trackData.track.info.codec)) {
               isKeyFrame = true;
             }
             const blockData = readBytes(blockSlice, blockSlice.remainingLength);
@@ -12152,7 +12308,8 @@ var Mediabunny = (() => {
       if (segment.duration <= 0) {
         return null;
       }
-      return segment.duration / segment.timestampFactor;
+      const minCodecDelay = Math.min(...segment.tracks.map((x) => x.codecDelay));
+      return (segment.duration - minCodecDelay) / segment.timestampFactor;
     }
   };
   var MatroskaTrackBacking = class {
@@ -12241,7 +12398,7 @@ var Mediabunny = (() => {
       );
     }
     intoTimescale(timestamp) {
-      return roundIfAlmostInteger(timestamp * this.internalTrack.segment.timestampFactor);
+      return roundIfAlmostInteger(timestamp * this.internalTrack.segment.timestampFactor) + this.internalTrack.codecDelay;
     }
     async getPacket(timestamp, options) {
       const timestampInTimescale = this.intoTimescale(timestamp);
@@ -12393,8 +12550,9 @@ var Mediabunny = (() => {
         block.postProcessed = true;
       }
       const data = options.metadataOnly ? PLACEHOLDER_DATA : block.data;
-      const timestamp = block.timestamp / this.internalTrack.segment.timestampFactor;
-      const duration = block.duration / this.internalTrack.segment.timestampFactor;
+      const { codecDelay, segment } = this.internalTrack;
+      const timestamp = (block.timestamp - codecDelay) / segment.timestampFactor;
+      const duration = block.duration / segment.timestampFactor;
       const sideData = {};
       if (block.mainAdditional && this.internalTrack.info?.type === "video" && this.internalTrack.info.alphaMode) {
         sideData.alpha = options.metadataOnly ? PLACEHOLDER_DATA : block.mainAdditional;
@@ -12726,6 +12884,7 @@ var Mediabunny = (() => {
       this.lastSampleLoaded = false;
       this.lastLoadedPos = 0;
       this.nextTimestampInSamples = 0;
+      this.primingDelay = 0;
       this.reader = input._reader;
     }
     async readMetadata() {
@@ -12790,9 +12949,24 @@ var Mediabunny = (() => {
               const view2 = toDataView(xingData);
               const flags = view2.getUint32(0, false);
               this.xingData = {
+                // LAME and FFmpeg write the same header with 'Info' in place of 'Xing' for CBR streams
+                isVbr: word === XING,
                 frameCount: flags & 1 /* FrameCount */ ? view2.getUint32(4, false) : null,
                 fileSize: flags & 2 /* FileSize */ ? view2.getUint32(8, false) : null
               };
+              const lameOffset = result.startPos + xingOffset + 8 + (flags & 1 /* FrameCount */ ? 4 : 0) + (flags & 2 /* FileSize */ ? 4 : 0) + (flags & 4 /* Toc */ ? 100 : 0) + (flags & 8 /* Quality */ ? 4 : 0);
+              if (!this.firstFrameHeader && lameOffset + 24 <= result.startPos + header.totalSize) {
+                let lameSlice = this.reader.requestSlice(lameOffset, 24);
+                if (isThenable(lameSlice)) lameSlice = await lameSlice;
+                if (lameSlice) {
+                  const lame = readBytes(lameSlice, 24);
+                  const encoder = String.fromCharCode(...lame.subarray(0, 4));
+                  if (encoder === "LAME" || encoder === "Lavf" || encoder === "Lavc") {
+                    this.primingDelay = (lame[21] << 4 | lame[22] >> 4) + MP3_DECODER_DELAY;
+                    this.nextTimestampInSamples = -this.primingDelay;
+                  }
+                }
+              }
             }
           }
           return;
@@ -12875,7 +13049,7 @@ var Mediabunny = (() => {
     }
     getTimeResolution() {
       assert(this.demuxer.firstFrameHeader);
-      return this.demuxer.firstFrameHeader.sampleRate / this.demuxer.firstFrameHeader.audioSamplesInFrame;
+      return this.demuxer.firstFrameHeader.sampleRate;
     }
     isRelativeToUnixEpoch() {
       return false;
@@ -12896,11 +13070,9 @@ var Mediabunny = (() => {
       const demuxer = this.demuxer;
       assert(demuxer.firstFrameHeader !== null);
       assert(demuxer.firstFrameHeaderPos !== null);
-      if (demuxer.xingData) {
-        if (demuxer.xingData.frameCount !== null) {
-          return demuxer.xingData.frameCount * demuxer.firstFrameHeader.audioSamplesInFrame / demuxer.firstFrameHeader.sampleRate;
-        }
-      } else {
+      if (demuxer.xingData && demuxer.xingData.frameCount !== null) {
+        return (demuxer.xingData.frameCount * demuxer.firstFrameHeader.audioSamplesInFrame - demuxer.primingDelay) / demuxer.firstFrameHeader.sampleRate;
+      } else if (!demuxer.xingData?.isVbr) {
         if (demuxer.reader.fileSize !== null) {
           const averageFrameSize = computeAverageMp3FrameSize(
             demuxer.firstFrameHeader.lowSamplingFrequency,
@@ -12909,7 +13081,7 @@ var Mediabunny = (() => {
             demuxer.firstFrameHeader.sampleRate
           );
           const frameCount = (demuxer.reader.fileSize - demuxer.firstFrameHeaderPos) / averageFrameSize;
-          return Math.round(frameCount) * demuxer.firstFrameHeader.audioSamplesInFrame / demuxer.firstFrameHeader.sampleRate;
+          return (Math.round(frameCount) * demuxer.firstFrameHeader.audioSamplesInFrame - demuxer.primingDelay) / demuxer.firstFrameHeader.sampleRate;
         }
       }
       return null;
@@ -13069,7 +13241,7 @@ var Mediabunny = (() => {
         if (modeNumber >= codecInfo.vorbisInfo.modeBlockflags.length) {
           throw new Error("Invalid mode number.");
         }
-        let prevBlocksize = vorbisLastBlocksize;
+        let prevBlocksize = vorbisLastBlocksize ?? codecInfo.vorbisInfo.blocksizes[0];
         const blockflag = codecInfo.vorbisInfo.modeBlockflags[modeNumber];
         currentBlocksize = codecInfo.vorbisInfo.blocksizes[blockflag];
         if (blockflag === 1) {
@@ -13077,7 +13249,7 @@ var Mediabunny = (() => {
           const flag = data[0] & prevMask ? 1 : 0;
           prevBlocksize = codecInfo.vorbisInfo.blocksizes[flag];
         }
-        durationInSamples = prevBlocksize !== null ? prevBlocksize + currentBlocksize >> 2 : 0;
+        durationInSamples = prevBlocksize + currentBlocksize >> 2;
       } else if (codecInfo.codec === "opus") {
         const toc = parseOpusTocByte(data);
         durationInSamples = toc.durationInSamples;
@@ -13541,16 +13713,14 @@ var Mediabunny = (() => {
       let { durationInSamples } = sampleMetadata;
       const isEos = !!(packet.endPage.headerType & 4);
       if (isEos && packet.endSegmentIndex === packet.endPage.lacingValues.length - 1) {
-        const endTimestampInSamples2 = this.granulePositionToTimestampInSamples(packet.endPage.granulePosition);
-        durationInSamples = clamp(endTimestampInSamples2 - additional.timestampInSamples, 0, durationInSamples);
+        const endTimestampInSamples = this.granulePositionToTimestampInSamples(packet.endPage.granulePosition);
+        durationInSamples = clamp(endTimestampInSamples - additional.timestampInSamples, 0, durationInSamples);
       }
-      const startTimestampInSamples = Math.max(additional.timestampInSamples, 0);
-      const endTimestampInSamples = Math.max(additional.timestampInSamples + durationInSamples, 0);
       const encodedPacket = new EncodedPacket(
         options.metadataOnly ? PLACEHOLDER_DATA : packet.data,
         "key",
-        startTimestampInSamples / this.internalSampleRate,
-        (endTimestampInSamples - startTimestampInSamples) / this.internalSampleRate,
+        additional.timestampInSamples / this.internalSampleRate,
+        durationInSamples / this.internalSampleRate,
         packet.endPage.headerStartPos + packet.endSegmentIndex,
         packet.data.byteLength
       );
@@ -13573,6 +13743,7 @@ var Mediabunny = (() => {
         }
         let firstEndPage = null;
         let totalDurationInSamples = 0;
+        let firstPacketDurationInSamples = null;
         let vorbisLastBlocksize = null;
         while (position) {
           const packet = await this.demuxer.readPacket(position.startPage, position.startSegmentIndex);
@@ -13589,13 +13760,16 @@ var Mediabunny = (() => {
             vorbisLastBlocksize
           );
           totalDurationInSamples += durationInSamples;
+          firstPacketDurationInSamples ??= durationInSamples;
           vorbisLastBlocksize = vorbisBlockSize;
           position = await this.demuxer.findNextPacketStart(packet);
         }
         if (!firstEndPage) {
           return defaultTimestampInSamples;
         }
-        return defaultTimestampInSamples + Math.max(firstEndPage.granulePosition - totalDurationInSamples, 0);
+        assert(firstPacketDurationInSamples !== null);
+        const minStartInSamples = this.bitstream.codecInfo.codec === "vorbis" ? -firstPacketDurationInSamples : 0;
+        return defaultTimestampInSamples + Math.max(firstEndPage.granulePosition - totalDurationInSamples, minStartInSamples);
       })();
     }
     async getFirstPacket(options) {
@@ -13644,10 +13818,10 @@ var Mediabunny = (() => {
       }
       const timestampInSamples = roundIfAlmostInteger(timestamp * this.internalSampleRate);
       const firstTimestampInSamples = await this.getFirstTimestampInSamples();
-      if (timestampInSamples === Math.max(firstTimestampInSamples, 0)) {
+      if (timestampInSamples === firstTimestampInSamples) {
         return this.getFirstPacket(options);
       }
-      if (timestampInSamples < Math.max(firstTimestampInSamples, 0)) {
+      if (timestampInSamples < firstTimestampInSamples) {
         return null;
       }
       assert(this.bitstream.lastMetadataPacket);
@@ -13848,7 +14022,7 @@ var Mediabunny = (() => {
           lastEncodedPacket = encodedPacket;
           lastEncodedPacketMetadata = encodedPacketMetadata;
           if (currentTimestampIsCorrect && // Next timestamp will be too late
-          (Math.max(currentTimestampInSamples, 0) > timestampInSamples || Math.max(encodedPacketMetadata.timestampInSamples, 0) === timestampInSamples)) {
+          (currentTimestampInSamples > timestampInSamples || encodedPacketMetadata.timestampInSamples === timestampInSamples)) {
             break;
           }
         }
@@ -14615,8 +14789,7 @@ var Mediabunny = (() => {
       return 1;
     }
     getTimeResolution() {
-      const sampleRate = this.getSampleRate();
-      return sampleRate / SAMPLES_PER_AAC_FRAME;
+      return this.getSampleRate();
     }
     isRelativeToUnixEpoch() {
       return false;
@@ -15074,7 +15247,7 @@ var Mediabunny = (() => {
       const maximumSliceLength = effectiveMaxFrameSize + maximumHeaderLength;
       const slice = await this.reader.requestSliceRange(
         startPos,
-        maximumHeaderLength,
+        minimumHeaderLength,
         maximumSliceLength
       );
       if (!slice) {
@@ -15391,7 +15564,7 @@ var Mediabunny = (() => {
   };
 
   // src/mpeg-ts/mpeg-ts-misc.ts
-  var TIMESCALE = 9e4;
+  var MPEG_TS_TIMESCALE = 9e4;
   var TIMESTAMP_MODULUS = 2 ** 33;
   var TS_PACKET_SIZE = 188;
   var buildMpegTsMimeType = (codecStrings) => {
@@ -15402,6 +15575,23 @@ var Mediabunny = (() => {
     }
     return string;
   };
+  var secondsToMpegTsTimestamp = (seconds) => {
+    return modEuclid(Math.round(MPEG_TS_TIMESCALE * seconds), TIMESTAMP_MODULUS);
+  };
+  var createTimestampWrapInfo = (firstTimestamp) => {
+    const tolerance = 60 * MPEG_TS_TIMESCALE;
+    return {
+      reference: firstTimestamp - tolerance,
+      offset: firstTimestamp >= TIMESTAMP_MODULUS - tolerance ? -TIMESTAMP_MODULUS : TIMESTAMP_MODULUS
+    };
+  };
+  var normalizeWrappedTimestamp = (timestamp, wrapInfo) => {
+    const { reference, offset } = wrapInfo;
+    if (offset < 0 && timestamp >= reference || offset > 0 && timestamp < reference) {
+      return timestamp + offset;
+    }
+    return timestamp;
+  };
 
   // src/mpeg-ts/mpeg-ts-demuxer.ts
   var MISSING_PTS_ERROR_MESSAGE = "PES packet is missing PTS where it was expected. PES packets without PTS are not currently supported. If you think this file should be supported, please report it.";
@@ -16085,18 +16275,8 @@ var Mediabunny = (() => {
       };
     }
     normalizeTimestamp(timestamp) {
-      if (!this.timestampWrapInfo) {
-        const tolerance = 60 * TIMESCALE;
-        this.timestampWrapInfo = {
-          reference: timestamp - tolerance,
-          offset: timestamp >= TIMESTAMP_MODULUS - tolerance ? -TIMESTAMP_MODULUS : TIMESTAMP_MODULUS
-        };
-      }
-      const { reference, offset } = this.timestampWrapInfo;
-      if (offset < 0 && timestamp >= reference || offset > 0 && timestamp < reference) {
-        return timestamp + offset;
-      }
-      return timestamp;
+      this.timestampWrapInfo ??= createTimestampWrapInfo(timestamp);
+      return normalizeWrappedTimestamp(timestamp, this.timestampWrapInfo);
     }
   };
   var readPesPacketHeader = (demuxer, section, expectPts) => {
@@ -16210,7 +16390,7 @@ var Mediabunny = (() => {
       };
     }
     getTimeResolution() {
-      return TIMESCALE;
+      return MPEG_TS_TIMESCALE;
     }
     isRelativeToUnixEpoch() {
       return false;
@@ -16243,8 +16423,8 @@ var Mediabunny = (() => {
       return new EncodedPacket(
         options.metadataOnly ? PLACEHOLDER_DATA : suppliedPacket.data,
         packetType,
-        suppliedPacket.pts / TIMESCALE,
-        Math.max(duration / TIMESCALE, 0),
+        suppliedPacket.pts / MPEG_TS_TIMESCALE,
+        Math.max(duration / MPEG_TS_TIMESCALE, 0),
         suppliedPacket.sequenceNumber,
         suppliedPacket.data.byteLength
       );
@@ -16327,7 +16507,7 @@ var Mediabunny = (() => {
      * make it more performant for small files and over high-latency readers such as the network.
      */
     async doPacketLookup(timestamp, keyframesOnly, options) {
-      const searchPts = roundIfAlmostInteger(timestamp * TIMESCALE);
+      const searchPts = roundIfAlmostInteger(timestamp * MPEG_TS_TIMESCALE);
       const demuxer = this.elementaryStream.demuxer;
       const { reader, seekChunkSize } = demuxer;
       const pid = this.elementaryStream.pid;
@@ -16366,7 +16546,7 @@ var Mediabunny = (() => {
       const referencePesPackets = this.elementaryStream.referencePesPackets;
       const referencePointIndex = binarySearchLessOrEqual(referencePesPackets, searchPts, (x) => x.pts);
       const referencePoint = referencePointIndex !== -1 ? referencePesPackets[referencePointIndex] : null;
-      if (referencePoint && searchPts - referencePoint.pts < TIMESCALE / 2) {
+      if (referencePoint && searchPts - referencePoint.pts < MPEG_TS_TIMESCALE / 2) {
         scanStartPos = referencePoint.sectionStartPos;
       } else {
         let startChunkIndex = 0;
@@ -16716,7 +16896,12 @@ var Mediabunny = (() => {
         }
       }
     }
-    referencePesPackets.splice(index + 1, 0, pesPacketHeader);
+    referencePesPackets.splice(index + 1, 0, {
+      sectionStartPos: pesPacketHeader.sectionStartPos,
+      sectionEndPos: pesPacketHeader.sectionEndPos,
+      pts: pesPacketHeader.pts,
+      randomAccessIndicator: pesPacketHeader.randomAccessIndicator
+    });
     return true;
   };
   var PacketReadingContext = class {
@@ -16992,7 +17177,9 @@ var Mediabunny = (() => {
                 if (isThenable(remaining3)) remaining3 = await remaining3;
                 return this.supplyPacket(
                   remaining3,
-                  Math.round(SAMPLES_PER_AAC_FRAME * TIMESCALE / elementaryStream.info.sampleRate)
+                  Math.round(
+                    SAMPLES_PER_AAC_FRAME * MPEG_TS_TIMESCALE / elementaryStream.info.sampleRate
+                  )
                 );
               } else {
                 this.seekTo(possibleHeaderStartPos + 1);
@@ -17015,7 +17202,7 @@ var Mediabunny = (() => {
                 this.seekTo(possibleHeaderStartPos);
                 let remaining3 = this.ensureBuffered(result.header.totalSize);
                 if (isThenable(remaining3)) remaining3 = await remaining3;
-                const duration = result.header.audioSamplesInFrame * TIMESCALE / elementaryStream.info.sampleRate;
+                const duration = result.header.audioSamplesInFrame * MPEG_TS_TIMESCALE / elementaryStream.info.sampleRate;
                 return this.supplyPacket(remaining3, Math.round(duration));
               } else {
                 this.seekTo(possibleHeaderStartPos + 1);
@@ -17048,7 +17235,7 @@ var Mediabunny = (() => {
               remaining2 = this.ensureBuffered(frameSize);
               if (isThenable(remaining2)) remaining2 = await remaining2;
               const duration = Math.round(
-                AC3_SAMPLES_PER_FRAME * TIMESCALE / elementaryStream.info.sampleRate
+                AC3_SAMPLES_PER_FRAME * MPEG_TS_TIMESCALE / elementaryStream.info.sampleRate
               );
               return this.supplyPacket(remaining2, duration);
             } else if (codec === "eac3") {
@@ -17077,7 +17264,7 @@ var Mediabunny = (() => {
               if (isThenable(remaining2)) remaining2 = await remaining2;
               const samplesPerFrame = numblks * 256;
               const duration = Math.round(
-                samplesPerFrame * TIMESCALE / elementaryStream.info.sampleRate
+                samplesPerFrame * MPEG_TS_TIMESCALE / elementaryStream.info.sampleRate
               );
               return this.supplyPacket(remaining2, duration);
             } else if (codec === "dts") {
@@ -17134,7 +17321,7 @@ var Mediabunny = (() => {
               remaining2 = this.ensureBuffered(frameSize);
               if (isThenable(remaining2)) remaining2 = await remaining2;
               const duration = Math.round(
-                sampleCount * TIMESCALE / elementaryStream.info.sampleRate
+                sampleCount * MPEG_TS_TIMESCALE / elementaryStream.info.sampleRate
               );
               return this.supplyPacket(remaining2, duration);
             } else {
@@ -17305,10 +17492,12 @@ var Mediabunny = (() => {
   var TAG_BYTERANGE = "#EXT-X-BYTERANGE:";
   var TAG_PROGRAM_DATE_TIME = "#EXT-X-PROGRAM-DATE-TIME:";
   var TAG_DISCONTINUITY = "#EXT-X-DISCONTINUITY";
+  var TAG_DISCONTINUITY_SEQUENCE = "#EXT-X-DISCONTINUITY-SEQUENCE:";
   var TAG_TARGETDURATION = "#EXT-X-TARGETDURATION:";
   var TAG_ENDLIST = "#EXT-X-ENDLIST";
   var TAG_PLAYLIST_TYPE = "#EXT-X-PLAYLIST-TYPE:";
   var TAG_I_FRAMES_ONLY = "#EXT-X-I-FRAMES-ONLY";
+  var TIMESTAMP_PRIV_OWNER = "com.apple.streaming.transportStreamTimestamp";
   var canIgnoreLine = (line) => line.length === 0 || line.startsWith("#") && !line.startsWith("#EXT");
   var AttributeList = class {
     constructor(str, variables) {
@@ -17445,7 +17634,9 @@ var Mediabunny = (() => {
       this.inputCache = [];
       this.trackBackingsPromise = null;
       this.firstSegment = null;
-      this.firstSegmentFirstTimestamps = /* @__PURE__ */ new WeakMap();
+      // Roughly maps local segment timestamps onto actual packet timestamps
+      this.learnedSegmentTimestampOffset = null;
+      this.segmentMediaOffsets = /* @__PURE__ */ new WeakMap();
       this.input = input;
       this.path = path;
       this.trackDeclarations = trackDeclarations;
@@ -17457,7 +17648,7 @@ var Mediabunny = (() => {
       if (!lastSegment) {
         return null;
       }
-      return lastSegment.timestamp + lastSegment.duration;
+      return lastSegment.timestamp + await this.getFirstSegmentTimestampOffset() + lastSegment.duration;
     }
     async getUnixTimeForTimestamp(timestamp) {
       let segment = await this.getSegmentAt(timestamp, {});
@@ -17465,7 +17656,7 @@ var Mediabunny = (() => {
       if (!segment || segment.unixEpochTimestamp === null) {
         return null;
       }
-      const elapsed = timestamp - segment.timestamp;
+      const elapsed = timestamp - (segment.timestamp + await this.getFirstSegmentTimestampOffset());
       return segment.unixEpochTimestamp + elapsed;
     }
     async getTrackBackings() {
@@ -17515,19 +17706,29 @@ var Mediabunny = (() => {
         return backings;
       })();
     }
-    async getMediaOffset(segment, input) {
-      const format = await input.getFormat();
-      if (!format.supportsTimestampedMediaData) {
-        return segment.timestamp;
-      }
-      const firstSegment = segment.firstSegment ?? segment;
-      let firstSegmentFirstTimestamp = this.firstSegmentFirstTimestamps.get(firstSegment);
-      if (firstSegmentFirstTimestamp === void 0) {
-        const firstInput = this.getInputForSegment(firstSegment);
-        firstSegmentFirstTimestamp = await firstInput.getFirstTimestamp();
-        this.firstSegmentFirstTimestamps.set(firstSegment, firstSegmentFirstTimestamp);
-      }
-      return firstSegment.timestamp - firstSegmentFirstTimestamp;
+    getMediaOffset(segment, input) {
+      let promise = this.segmentMediaOffsets.get(segment);
+      if (promise) {
+        return promise;
+      }
+      promise = (async () => {
+        const rawTimestampOffset = await this.getRawTimestampOffset(input);
+        if (rawTimestampOffset === null) {
+          return segment.timestamp;
+        }
+        let mediaOffset = rawTimestampOffset + await this.getMediaOffsetForDiscontinuity(segment.discontinuityNumber);
+        const period = this.getTimestampWrapPeriod();
+        if (period < Infinity) {
+          const tracks = await input.getTracks();
+          const track = tracks.find((x) => x.type === "video") ?? tracks[0];
+          assert(track);
+          const mediaStart = await track.getFirstTimestamp() + mediaOffset;
+          mediaOffset += period * Math.round((segment.timestamp - mediaStart) / period);
+        }
+        return mediaOffset;
+      })();
+      this.segmentMediaOffsets.set(segment, promise);
+      return promise;
     }
     dispose() {
       for (const entry of this.inputCache) {
@@ -17745,6 +17946,21 @@ var Mediabunny = (() => {
           continue;
         }
         const mediaOffset = await this.segmentedInput.getMediaOffset(currentSegment, input);
+        const firstPacket = this.segmentedInput.learnedSegmentTimestampOffset === null ? await track._backing.getFirstPacket({ ...options, metadataOnly: true }) : null;
+        if (firstPacket) {
+          const segmentStart = firstPacket.timestamp + mediaOffset;
+          this.segmentedInput.learnedSegmentTimestampOffset = segmentStart - currentSegment.timestamp;
+          const distance = timestamp - segmentStart;
+          if (distance < -currentSegment.duration || distance >= 2 * currentSegment.duration) {
+            const segment = await this.segmentedInput.getSegmentAt(timestamp, {
+              skipLiveWait: options.skipLiveWait
+            });
+            if (segment !== currentSegment) {
+              currentSegment = segment;
+              continue;
+            }
+          }
+        }
         const offsetTimestamp = timestamp - mediaOffset;
         const packet = keyframesOnly ? await track._backing.getKeyPacket(offsetTimestamp, options) : await track._backing.getPacket(offsetTimestamp, options);
         if (!packet) {
@@ -18379,6 +18595,7 @@ var Mediabunny = (() => {
     }
     /** @internal */
     async _runWorker(worker) {
+      let consecutiveEmptyResponses = 0;
       while (true) {
         if (worker.aborted) {
           this._orchestrator.signalWorkerStoppedRunning(worker);
@@ -18452,6 +18669,7 @@ var Mediabunny = (() => {
           return;
         }
         const reader = response.body.getReader();
+        const responseStartPos = worker.currentPos;
         while (true) {
           if (worker.currentPos >= worker.targetPos || worker.aborted) {
             abortController.abort();
@@ -18484,6 +18702,18 @@ var Mediabunny = (() => {
               return;
             }
             if (worker.strictTarget) {
+              if (worker.currentPos > responseStartPos) {
+                consecutiveEmptyResponses = 0;
+                break;
+              }
+              consecutiveEmptyResponses++;
+              const error = new Error("Range response ended without delivering any data.");
+              const retryDelayInSeconds = this._getRetryDelay(consecutiveEmptyResponses, error, this._url);
+              if (retryDelayInSeconds === null) {
+                throw error;
+              }
+              Logging._error("Retrying range request that ended without delivering any data.");
+              await wait(1e3 * retryDelayInSeconds);
               break;
             } else {
               this._orchestrator.onWorkerFinished(worker);
@@ -19644,15 +19874,17 @@ var Mediabunny = (() => {
   var BASE64_DATA_URI_REGEX = /^data:.*;base64,/i;
   var MAX_DURATION = 1e9;
   var HlsSegmentedInput = class extends SegmentedInput {
-    // Reasonable default in case the playlist doesn't specify it
     constructor(demuxer, path, trackDeclarations, lines) {
       super(demuxer.input, path, trackDeclarations);
       this.segments = [];
       this.nextLines = null;
       this.currentUpdateSegmentsPromise = null;
       this.streamHasEnded = false;
+      this.neverRemovesSegments = false;
       this.lastSegmentUpdateTime = -Infinity;
       this.refreshInterval = 5;
+      // Reasonable default in case the playlist doesn't specify it
+      this.segmentTimestampOffsetPromise = null;
       this.rootPath = path;
       this.demuxer = demuxer;
       this.nextLines = lines;
@@ -19722,13 +19954,12 @@ var Mediabunny = (() => {
       let nextSegmentDuration = null;
       let currentKey = null;
       let nextSequenceNumber = 0;
+      let nextDiscontinuityNumber = 0;
       let currentFirstSegment = null;
       let currentInitSegment = null;
       let lastByteRangeEnd = null;
       let nextByteRange = null;
       let lastProgramDateTimeSeconds = null;
-      let targetDuration = null;
-      let segmentSeen = false;
       let prevLastSegment = last(this.segments) ?? null;
       const parseByteRange = (content) => {
         const atIndex = content.indexOf("@");
@@ -19791,6 +20022,7 @@ var Mediabunny = (() => {
               index: this.segments.length,
               timestamp: accumulatedTime,
               unixEpochTimestamp: accumulatedUnixTime,
+              discontinuityNumber: nextDiscontinuityNumber,
               firstSegment: currentFirstSegment,
               sequenceNumber: nextSequenceNumber,
               location,
@@ -19817,15 +20049,8 @@ var Mediabunny = (() => {
         }
         if (line.startsWith(TAG_EXTINF)) {
           if (prevLastSegment) {
-            segmentSeen = true;
             continue;
           }
-          if (!segmentSeen) {
-            if (lastProgramDateTimeSeconds === null && nextSequenceNumber > 0 && targetDuration !== null) {
-              accumulatedTime = nextSequenceNumber * targetDuration;
-            }
-            segmentSeen = true;
-          }
           const extinfContent = line.slice(TAG_EXTINF.length);
           const commaIndex = extinfContent.indexOf(",");
           const durationStr = commaIndex === -1 ? extinfContent : extinfContent.slice(0, commaIndex);
@@ -19864,6 +20089,7 @@ var Mediabunny = (() => {
               index: -1,
               timestamp: accumulatedTime,
               unixEpochTimestamp: accumulatedUnixTime,
+              discontinuityNumber: nextDiscontinuityNumber,
               firstSegment: null,
               sequenceNumber: null,
               location,
@@ -19997,6 +20223,14 @@ var Mediabunny = (() => {
           }
         } else if (line === TAG_DISCONTINUITY) {
           currentFirstSegment = null;
+          nextDiscontinuityNumber++;
+        } else if (line.startsWith(TAG_DISCONTINUITY_SEQUENCE)) {
+          const value = line.slice(TAG_DISCONTINUITY_SEQUENCE.length);
+          const number = Number(value);
+          if (!Number.isSafeInteger(number) || number < 0) {
+            throw new Error(`Invalid EXT-X-DISCONTINUITY-SEQUENCE value '${value}'.`);
+          }
+          nextDiscontinuityNumber = number;
         } else if (line.startsWith(TAG_TARGETDURATION)) {
           const value = line.slice(TAG_TARGETDURATION.length);
           const duration = Number(value);
@@ -20004,15 +20238,17 @@ var Mediabunny = (() => {
             throw new Error(`Invalid EXT-X-TARGETDURATION value '${value}'.`);
           }
           this.refreshInterval = clamp(duration, 0.5, 3600);
-          targetDuration = duration;
         } else if (line === TAG_ENDLIST) {
           this.streamHasEnded = true;
           break;
         } else if (line.startsWith(TAG_PLAYLIST_TYPE)) {
-          const type = line.slice(TAG_PLAYLIST_TYPE.length);
-          if (type.toLowerCase() === "vod") {
+          const type = line.slice(TAG_PLAYLIST_TYPE.length).toLowerCase();
+          if (type === "vod") {
             this.streamHasEnded = true;
           }
+          if (type === "vod" || type === "event") {
+            this.neverRemovesSegments = true;
+          }
         }
       }
       if (!headerRead) {
@@ -20029,9 +20265,10 @@ var Mediabunny = (() => {
       if (this.segments.length === 0) {
         await this.runUpdateSegments();
       }
+      const playlistTimestamp = timestamp - (this.learnedSegmentTimestampOffset ?? 0);
       let isLazy = !!options.skipLiveWait && this.getRemainingWaitTimeMs() > 0;
       while (true) {
-        const index = binarySearchLessOrEqual(this.segments, timestamp, (x) => x.timestamp);
+        const index = binarySearchLessOrEqual(this.segments, playlistTimestamp, (x) => x.timestamp);
         if (index === -1) {
           return null;
         }
@@ -20039,7 +20276,7 @@ var Mediabunny = (() => {
           return this.segments[index];
         }
         const segment = this.segments[index];
-        if (timestamp < segment.timestamp + segment.duration) {
+        if (playlistTimestamp < segment.timestamp + segment.duration) {
           return segment;
         }
         await this.runUpdateSegments();
@@ -20196,6 +20433,65 @@ var Mediabunny = (() => {
       }
       return this.streamHasEnded ? null : this.refreshInterval;
     }
+    getMediaOffsetForDiscontinuity(discontinuityNumber) {
+      return this.demuxer.getMediaOffsetForDiscontinuity(discontinuityNumber);
+    }
+    getFirstSegmentTimestampOffset() {
+      return this.segmentTimestampOffsetPromise ??= (async () => {
+        const firstSegment = await this.getFirstSegment();
+        assert(firstSegment);
+        const referenceSegmentedInput = this.demuxer.getReferenceSegmentedInput();
+        if (this === referenceSegmentedInput) {
+          return 0;
+        }
+        const referenceFirstSegment = await referenceSegmentedInput.getFirstSegment();
+        if (referenceFirstSegment && (this.listsAllSegments() && referenceSegmentedInput.listsAllSegments() || firstSegment.unixEpochTimestamp === firstSegment.timestamp && referenceFirstSegment.unixEpochTimestamp === referenceFirstSegment.timestamp)) {
+          return 0;
+        }
+        const input = this.getInputForSegment(firstSegment);
+        if (await this.getRawTimestampOffset(input) === null) {
+          return 0;
+        }
+        const tracks = await input.getTracks();
+        const track = tracks.find((x) => x.type === "video") ?? tracks[0];
+        if (!track) {
+          throw new Error("The playlist's first segment contains no tracks.");
+        }
+        const mediaOffset = await this.getMediaOffset(firstSegment, input);
+        const offset = await track.getFirstTimestamp() + mediaOffset - firstSegment.timestamp;
+        this.learnedSegmentTimestampOffset ??= offset;
+        return offset;
+      })();
+    }
+    listsAllSegments() {
+      return this.segments[0].sequenceNumber === 0 || this.neverRemovesSegments;
+    }
+    async getRawTimestampOffset(input) {
+      const format = await input.getFormat();
+      if (format.supportsTimestampedMediaData) {
+        return 0;
+      }
+      const tags = await input.getMetadataTags();
+      const priv = tags.raw?.["PRIV"];
+      for (const frame of toArray(priv)) {
+        if (!(frame instanceof Uint8Array) || frame.length !== TIMESTAMP_PRIV_OWNER.length + 1 + 8 || textDecoder.decode(frame.subarray(0, TIMESTAMP_PRIV_OWNER.length)) !== TIMESTAMP_PRIV_OWNER || frame[TIMESTAMP_PRIV_OWNER.length] !== 0) {
+          continue;
+        }
+        const view2 = toDataView(frame);
+        const timestampHigh = view2.getUint32(TIMESTAMP_PRIV_OWNER.length + 1);
+        const timestampLow = view2.getUint32(TIMESTAMP_PRIV_OWNER.length + 5);
+        if (timestampHigh > 1) {
+          continue;
+        }
+        const timestamp = 2 ** 32 * timestampHigh + timestampLow;
+        const privTimestamp = normalizeWrappedTimestamp(timestamp, createTimestampWrapInfo(timestamp)) / MPEG_TS_TIMESCALE;
+        return privTimestamp - await input.getFirstTimestamp();
+      }
+      return null;
+    }
+    getTimestampWrapPeriod() {
+      return TIMESTAMP_MODULUS / MPEG_TS_TIMESCALE;
+    }
   };
 
   // src/hls/hls-demuxer.ts
@@ -20210,6 +20506,7 @@ var Mediabunny = (() => {
       this.segmentedInputs = [];
       this.hasMasterPlaylist = true;
       this.masterPlaylistVariables = null;
+      this.mediaOffsets = /* @__PURE__ */ new Map();
     }
     readMetadata() {
       return this.metadataPromise ??= (async () => {
@@ -20588,6 +20885,46 @@ var Mediabunny = (() => {
       assert(this.trackBackings);
       return this.trackBackings;
     }
+    getMediaOffsetForDiscontinuity(discontinuityNumber) {
+      let promise = this.mediaOffsets.get(discontinuityNumber);
+      if (promise) {
+        return promise;
+      }
+      promise = (async () => {
+        const referenceSegmentedInput = this.getReferenceSegmentedInput();
+        let segment = await referenceSegmentedInput.getFirstSegment();
+        while (segment && segment.discontinuityNumber < discontinuityNumber) {
+          segment = await referenceSegmentedInput.getNextSegment(segment, {});
+        }
+        if (!segment || segment.discontinuityNumber !== discontinuityNumber) {
+          throw new Error(
+            `The reference playlist contains no segment in discontinuity ${discontinuityNumber}, so the discontinuity can't be synchronized across tracks. If you think this is a bug, please raise an issue and include the playlist.`
+          );
+        }
+        const input = referenceSegmentedInput.getInputForSegment(segment);
+        const rawTimestampOffset = await referenceSegmentedInput.getRawTimestampOffset(input) ?? 0;
+        const tracks = await input.getTracks();
+        const track = tracks.find((x) => x.type === "video") ?? tracks[0];
+        if (!track) {
+          throw new Error("The reference playlist's segment contains no tracks.");
+        }
+        return segment.timestamp - (rawTimestampOffset + await track.getFirstTimestamp());
+      })();
+      this.mediaOffsets.set(discontinuityNumber, promise);
+      return promise;
+    }
+    getReferenceSegmentedInput() {
+      if (!this.hasMasterPlaylist) {
+        return this.segmentedInputs[0];
+      }
+      assert(this.internalTracks);
+      const candidates = this.internalTracks.filter((x) => !x.hasOnlyKeyPackets);
+      const videoCandidates = candidates.filter((x) => x.info.type === "video");
+      const pool = videoCandidates.length > 0 ? videoCandidates : candidates;
+      const index = arrayArgmin(pool, (x) => x.peakBitrate ?? Infinity);
+      assert(index !== -1);
+      return this.getSegmentedInputForPath(pool[index].fullPath);
+    }
     getSegmentedInputForPath(path) {
       let segmentedInput = this.segmentedInputs.find((x) => x.path === path);
       if (segmentedInput) {
@@ -23923,7 +24260,7 @@ var Mediabunny = (() => {
       throw new TypeError(`Invalid audio codec '${config.codec}'. Must be one of: ${AUDIO_CODECS.join(", ")}.`);
     }
     const bitrate = config.bitrate;
-    if (config.quality === void 0 && bitrate === void 0 && !(PCM_AUDIO_CODECS.includes(config.codec) || config.codec === "flac")) {
+    if (config.quality === void 0 && bitrate === void 0 && !(PCM_AUDIO_CODECS.includes(config.codec) || config.codec === "flac" || config.codec === "truehd")) {
       throw new TypeError("config.quality must be provided for compressed audio codecs.");
     }
     if (config.quality !== void 0 && bitrate !== void 0) {
@@ -24104,7 +24441,7 @@ var Mediabunny = (() => {
     }
     /** @internal */
     _toAudioBitrate(codec) {
-      if (PCM_AUDIO_CODECS.includes(codec) || codec === "flac") {
+      if (PCM_AUDIO_CODECS.includes(codec) || codec === "flac" || codec === "truehd") {
         return void 0;
       }
       if (this._bitrate !== void 0) {
@@ -24952,7 +25289,12 @@ var Mediabunny = (() => {
         });
         decoder.onDequeue = () => onQueueDequeue();
         const packetSink = this._createPacketSink();
-        const keyPacket = await packetSink.getKeyPacket(startTimestamp, packetRetrievalOptions) ?? await packetSink.getFirstKeyPacket(packetRetrievalOptions);
+        const preRollDuration = await this._getPreRollDuration();
+        const startPacket = await packetSink.getPacket(startTimestamp, packetRetrievalOptions);
+        const keyPacket = await packetSink.getKeyPacket(
+          (startPacket?.timestamp ?? startTimestamp) - preRollDuration,
+          packetRetrievalOptions
+        ) ?? await packetSink.getFirstKeyPacket(packetRetrievalOptions);
         let currentPacket = keyPacket;
         const endPacket = void 0;
         const packets = packetSink.packets(keyPacket ?? void 0, endPacket, packetRetrievalOptions);
@@ -25056,6 +25398,16 @@ var Mediabunny = (() => {
         onQueueNotEmpty();
         ({ promise: queueNotEmpty, resolve: onQueueNotEmpty } = promiseWithResolvers());
       };
+      let heldSample = null;
+      const emitHeldSample = (count) => {
+        for (let i = 0; i < count; i++) {
+          pushToQueue(heldSample && (i < count - 1 ? heldSample.clone() : heldSample));
+        }
+        if (count === 0) {
+          heldSample?.close();
+        }
+        heldSample = null;
+      };
       const retrievalOptions = {
         ...options,
         verifyKeyPackets: true,
@@ -25068,18 +25420,13 @@ var Mediabunny = (() => {
             sample.close();
             return;
           }
-          let sampleUses = 0;
-          while (timestampsOfInterest.length > 0 && sample.timestamp - timestampsOfInterest[0] > -1e-10) {
-            sampleUses++;
+          let heldSampleUses = 0;
+          while (timestampsOfInterest.length > 0 && sample.timestamp - timestampsOfInterest[0] > 1e-10) {
+            heldSampleUses++;
             timestampsOfInterest.shift();
           }
-          if (sampleUses > 0) {
-            for (let i = 0; i < sampleUses; i++) {
-              pushToQueue(i < sampleUses - 1 ? sample.clone() : sample);
-            }
-          } else {
-            sample.close();
-          }
+          emitHeldSample(heldSampleUses);
+          heldSample = sample;
         }, (error) => {
           if (!hasOutOfBandError) {
             outOfBandError = error;
@@ -25089,14 +25436,20 @@ var Mediabunny = (() => {
         });
         decoder.onDequeue = () => onQueueDequeue();
         const packetSink = this._createPacketSink();
+        const preRollDuration = await this._getPreRollDuration();
         let lastPacket = null;
+        let lastTimestamp = -Infinity;
         let lastKeyPacket = null;
+        let lastDecodedPacket = null;
         let maxSequenceNumber = -1;
         const decodePackets = async () => {
           assert(lastKeyPacket);
           assert(decoder);
-          let currentPacket = lastKeyPacket;
-          decoder.decode(currentPacket);
+          let currentPacket = lastDecodedPacket;
+          if (!currentPacket) {
+            currentPacket = lastKeyPacket;
+            decoder.decode(currentPacket);
+          }
           while (currentPacket.sequenceNumber < maxSequenceNumber) {
             while (sampleQueue.length + decoder.getDecodeQueueSize() >= MAX_QUEUE_SIZE && !terminated) {
               ({ promise: queueDequeue, resolve: onQueueDequeue } = promiseWithResolvers());
@@ -25112,14 +25465,12 @@ var Mediabunny = (() => {
             decoder.decode(nextPacket);
             currentPacket = nextPacket;
           }
-          maxSequenceNumber = -1;
+          lastDecodedPacket = currentPacket;
         };
         const flushDecoder = async () => {
           assert(decoder);
           await decoder.flush();
-          for (let i = 0; i < timestampsOfInterest.length; i++) {
-            pushToQueue(null);
-          }
+          emitHeldSample(timestampsOfInterest.length);
           timestampsOfInterest.length = 0;
         };
         for await (const timestamp of timestampIterator) {
@@ -25128,29 +25479,39 @@ var Mediabunny = (() => {
             break;
           }
           const targetPacket = await packetSink.getPacket(timestamp, retrievalOptions);
-          const keyPacket = targetPacket && await packetSink.getKeyPacket(timestamp, retrievalOptions);
-          if (!keyPacket) {
-            if (maxSequenceNumber !== -1) {
-              await decodePackets();
+          let keyPacket = targetPacket && await packetSink.getKeyPacket(
+            targetPacket.timestamp - preRollDuration,
+            retrievalOptions
+          );
+          if (targetPacket && !keyPacket) {
+            const firstKeyPacket = await packetSink.getFirstKeyPacket(retrievalOptions);
+            if (firstKeyPacket && firstKeyPacket.timestamp <= targetPacket.timestamp) {
+              keyPacket = firstKeyPacket;
+            }
+          }
+          if (!targetPacket || !keyPacket) {
+            if (lastPacket) {
               await flushDecoder();
             }
             pushToQueue(null);
             lastPacket = null;
             continue;
           }
-          if (lastPacket && (keyPacket.sequenceNumber !== lastKeyPacket.sequenceNumber || targetPacket.timestamp < lastPacket.timestamp)) {
-            await decodePackets();
-            await flushDecoder();
+          if (!lastPacket || keyPacket.sequenceNumber > maxSequenceNumber + 1 || timestamp < lastTimestamp) {
+            if (lastPacket) {
+              await flushDecoder();
+            }
+            lastKeyPacket = keyPacket;
+            lastDecodedPacket = null;
+            maxSequenceNumber = -1;
           }
-          timestampsOfInterest.push(targetPacket.timestamp);
+          timestampsOfInterest.push(timestamp);
           maxSequenceNumber = Math.max(targetPacket.sequenceNumber, maxSequenceNumber);
           lastPacket = targetPacket;
-          lastKeyPacket = keyPacket;
+          lastTimestamp = timestamp;
+          await decodePackets();
         }
         if (!terminated && !this._track.input._disposed) {
-          if (maxSequenceNumber !== -1) {
-            await decodePackets();
-          }
           await flushDecoder();
         }
         decoderIsFlushed = true;
@@ -25166,6 +25527,8 @@ var Mediabunny = (() => {
       });
       const track = this._track;
       const closeSamples = () => {
+        heldSample?.close();
+        heldSample = null;
         for (const sample of sampleQueue) {
           sample?.close();
         }
@@ -25245,6 +25608,9 @@ var Mediabunny = (() => {
       // For HEVC stuff
       this.finalSamples = [];
       this.mergeAlphaPromises = [];
+      this.flushing = false;
+      // Needed for a Chromium for Android workaround
+      this.frameCopyContext = null;
       const MatchingCustomDecoder = customVideoDecoders.find((x) => x.supports(codec, decoderConfig));
       if (MatchingCustomDecoder) {
         this.customDecoder = new MatchingCustomDecoder();
@@ -25310,7 +25676,7 @@ var Mediabunny = (() => {
         this.decoder = new VideoDecoder({
           output: (frame) => {
             try {
-              colorHandler(frame);
+              colorHandler(this.copyFrameIfNeeded(frame));
             } catch (error) {
               this.onError(error);
             }
@@ -25434,7 +25800,7 @@ var Mediabunny = (() => {
         this.alphaDecoder = new VideoDecoder({
           output: (frame) => {
             try {
-              alphaHandler(frame);
+              alphaHandler(this.copyFrameIfNeeded(frame));
             } catch (error) {
               this.onError(error);
             }
@@ -25550,15 +25916,60 @@ var Mediabunny = (() => {
         resolver.resolve();
       }
     }
+    /**
+     * This is a workaround for https://issues.chromium.org/issues/579043455. It circumvents the problem by instantly
+     * drawing a frame to a new region of GPU memory (a canvas), which we know for certain won't get fucked up by
+     * other draws.
+     * Also see: https://github.com/Vanilagy/mediabunny/issues/573
+     */
+    copyFrameIfNeeded(frame) {
+      if (!isChromium() || !isAndroid()) {
+        return frame;
+      }
+      const visibleRect = frame.visibleRect;
+      const width = visibleRect.width;
+      const height = visibleRect.height;
+      if (!this.frameCopyContext) {
+        let context;
+        if (typeof OffscreenCanvas !== "undefined") {
+          context = new OffscreenCanvas(width, height).getContext("2d", { alpha: false });
+        } else {
+          context = document.createElement("canvas").getContext("2d", { alpha: false });
+        }
+        if (!context) {
+          throw new Error("The '2d' canvas context is required to decode video on Chromium for Android.");
+        }
+        this.frameCopyContext = context;
+      }
+      const canvas = this.frameCopyContext.canvas;
+      if (canvas.width !== width || canvas.height !== height) {
+        canvas.width = width;
+        canvas.height = height;
+      }
+      this.frameCopyContext.drawImage(frame, 0, 0, width, height);
+      if (this.flushing) {
+        this.frameCopyContext.getImageData(0, 0, 1, 1);
+      }
+      const copy = new VideoFrame(canvas, {
+        timestamp: frame.timestamp,
+        duration: frame.duration ?? void 0,
+        displayWidth: frame.displayWidth,
+        displayHeight: frame.displayHeight
+      });
+      frame.close();
+      return copy;
+    }
     async flush() {
       if (this.customDecoder) {
         await this.customDecoderCallSerializer.call(() => this.customDecoder.flush());
       } else {
         assert(this.decoder);
+        this.flushing = true;
         await Promise.all([
           this.decoder.flush(),
           this.alphaDecoder?.flush()
         ]);
+        this.flushing = false;
         await Promise.all(this.mergeAlphaPromises);
         this.colorQueue.forEach((x) => x.close());
         this.colorQueue.length = 0;
@@ -25884,6 +26295,10 @@ var Mediabunny = (() => {
     _createPacketSink() {
       return new EncodedPacketSink(this._track);
     }
+    /** @internal */
+    async _getPreRollDuration() {
+      return 0;
+    }
     /**
      * Retrieves the video sample (frame) corresponding to the given timestamp, in seconds. More specifically, returns
      * the last video sample (in presentation order) with a start timestamp less than or equal to the given timestamp.
@@ -26120,11 +26535,11 @@ var Mediabunny = (() => {
       // Chromium does not respect negative packet timestamps, so we must do the fixin' ourselves
       this.expectedFirstTimestamp = null;
       this.timestampOffset = 0;
+      const opusPreSkip = codec === "opus" && decoderConfig.description ? parseOpusIdentificationHeader(toUint8Array(decoderConfig.description)).preSkip / OPUS_SAMPLE_RATE : 0;
       const sampleHandler = (sample) => {
         let sampleTimestamp = sample.timestamp;
         if (this.expectedFirstTimestamp !== null && this.currentTimestamp === null) {
-          this.timestampOffset = this.expectedFirstTimestamp - sampleTimestamp;
-          ;
+          this.timestampOffset = this.expectedFirstTimestamp + opusPreSkip - sampleTimestamp;
         }
         sampleTimestamp += this.timestampOffset;
         if (this.currentTimestamp === null || Math.abs(sampleTimestamp - this.currentTimestamp) >= sample.duration) {
@@ -26433,6 +26848,12 @@ var Mediabunny = (() => {
     _createPacketSink() {
       return new EncodedPacketSink(this._track);
     }
+    /** @internal */
+    async _getPreRollDuration() {
+      const preRollDuration = await this._track.getPreRollDuration();
+      assert(preRollDuration !== null);
+      return preRollDuration;
+    }
     /**
      * Retrieves the audio sample corresponding to the given timestamp, in seconds. More specifically, returns
      * the last audio sample (in presentation order) with a start timestamp less than or equal to the given timestamp.
@@ -27238,7 +27659,8 @@ var Mediabunny = (() => {
       return requireSync(this._backing.getCodec(), "codec", "getCodec");
     }
     async hasOnlyKeyPackets() {
-      return await this._backing.getHasOnlyKeyPackets?.() ?? true;
+      const codec = await this._backing.getCodec();
+      return await this._backing.getHasOnlyKeyPackets?.() ?? (codec === null || !AUDIO_CODECS_WITH_DELTA_PACKETS.includes(codec));
     }
     /** Returns the number of audio channels in the track. */
     async getNumberOfChannels() {
@@ -27278,6 +27700,20 @@ var Mediabunny = (() => {
       const decoderConfig = await this._backing.getDecoderConfig();
       return decoderConfig?.codec ?? null;
     }
+    /**
+     * Returns the decoder pre-roll duration for this track. It specifies how far ahead of any given timestamp,
+     * in seconds, decoding must start so that the audio at that timestamp comes out correctly and the codec state has
+     * properly converged. Returns `null` if the track's codec is unknown.
+     */
+    async getPreRollDuration() {
+      const codec = await this._backing.getCodec();
+      if (codec === null) {
+        return null;
+      }
+      const decoderConfig = await this._backing.getDecoderConfig();
+      assert(decoderConfig);
+      return getAudioPreRollDuration(codec, decoderConfig);
+    }
     async canDecode() {
       try {
         const decoderConfig = await this._backing.getDecoderConfig();
@@ -27307,10 +27743,14 @@ var Mediabunny = (() => {
       if (!(packet instanceof EncodedPacket)) {
         throw new TypeError("packet must be an EncodedPacket.");
       }
-      if (await this.getCodec() === null) {
+      if (packet.isMetadataOnly) {
+        throw new TypeError("packet must not be metadata-only to determine its type.");
+      }
+      const codec = await this.getCodec();
+      if (codec === null) {
         return null;
       }
-      return "key";
+      return determineAudioPacketType(codec, packet.data);
     }
   };
   var asc = (value) => {
@@ -28598,7 +29038,15 @@ var Mediabunny = (() => {
       } else if (frame.id[0] === "T") {
         tags.raw[frame.id] ??= reader.readId3V2EncodingAndText(frameEndPos);
       } else {
-        tags.raw[frame.id] ??= reader.readBytes(frameEndPos - reader.pos);
+        const bytes3 = reader.readBytes(frameEndPos - reader.pos);
+        const existing = tags.raw[frame.id];
+        if (existing instanceof Uint8Array) {
+          tags.raw[frame.id] = [existing, bytes3];
+        } else if (Array.isArray(existing)) {
+          existing.push(bytes3);
+        } else {
+          tags.raw[frame.id] ??= bytes3;
+        }
       }
       reader.pos = frameStartPos;
       switch (frame.id) {
@@ -29114,8 +29562,9 @@ var Mediabunny = (() => {
           if (value == null || key.length !== 4 || writtenTags.has(key)) {
             continue;
           }
-          let bytes2;
+          let frames;
           if (typeof value === "string") {
+            let bytes2;
             const useIso88591 = isIso88591Compatible(value);
             if (useIso88591) {
               bytes2 = new Uint8Array(value.length + 2);
@@ -29129,8 +29578,11 @@ var Mediabunny = (() => {
               bytes2[0] = 3 /* UTF_8 */;
               bytes2.set(encoded, 1);
             }
+            frames = [bytes2];
           } else if (value instanceof Uint8Array) {
-            bytes2 = value;
+            frames = [value];
+          } else if (Array.isArray(value) && value.every((x) => x instanceof Uint8Array)) {
+            frames = value;
           } else if (key === "TXXX" && isRecordStringString(value)) {
             for (const description in value) {
               const frameValue = value[description];
@@ -29158,10 +29610,12 @@ var Mediabunny = (() => {
           } else {
             continue;
           }
-          this.writeAscii(key);
-          this.writeSynchsafeU32(bytes2.byteLength);
-          this.writeU16(0);
-          this.writer.write(bytes2);
+          for (const bytes2 of frames) {
+            this.writeAscii(key);
+            this.writeSynchsafeU32(bytes2.byteLength);
+            this.writeU16(0);
+            this.writer.write(bytes2);
+          }
         }
       }
       const framesEndPos = this.writer.getPos();
@@ -30240,7 +30694,8 @@ var Mediabunny = (() => {
       stsc(trackData),
       stsz(trackData),
       stco(trackData),
-      stss(trackData)
+      stss(trackData),
+      ...sgpdAndSbgp(trackData.samples, false)
     ]);
   };
   var stsd = (trackData) => {
@@ -30406,7 +30861,7 @@ var Mediabunny = (() => {
         version = 1;
       }
     }
-    if (trackData.muxer.isQuickTime) {
+    if (trackData.muxer.isQuickTime && trackData.track.source._codec !== "truehd") {
       version = 1;
     }
     if (version === 0) {
@@ -30429,10 +30884,12 @@ var Mediabunny = (() => {
         // Compression ID
         u16(0),
         // Packet size
-        u16(trackData.info.sampleRate < 2 ** 16 ? trackData.info.sampleRate : 0),
-        // Sample rate (upper)
-        u16(0)
-        // Sample rate (lower)
+        trackData.track.source._codec === "truehd" ? u32(trackData.info.sampleRate) : [
+          u16(trackData.info.sampleRate < 2 ** 16 ? trackData.info.sampleRate : 0),
+          // Sample rate (upper)
+          u16(0)
+          // Sample rate (lower)
+        ]
       ];
     } else {
       const compressionId = isPcmCodec ? 0 : -2;
@@ -30578,7 +31035,7 @@ var Mediabunny = (() => {
   };
   var dOps = (trackData) => {
     let outputChannelCount = trackData.info.numberOfChannels;
-    let preSkip = 3840;
+    let preSkip = 312;
     let inputSampleRate = trackData.info.sampleRate;
     let outputGain = 0;
     let channelMappingFamily = 0;
@@ -30698,6 +31155,26 @@ var Mediabunny = (() => {
     }
     return box("ddts", [...buildDtsSpecificBox(frameInfo)]);
   };
+  var dmlp = (trackData) => {
+    assert(trackData.info.primingPacket);
+    const data = trackData.info.primingPacket.data;
+    if (determineAudioPacketType("truehd", data) !== "key") {
+      throw new Error(
+        "Couldn't extract TrueHD stream info from the audio packet. Ensure the first packet is an access unit carrying a major sync."
+      );
+    }
+    const view2 = toDataView(data);
+    const formatInfo = view2.getUint32(8);
+    const peakDataRate = view2.getUint16(18) & 32767;
+    return box("dmlp", [
+      u32(formatInfo),
+      // Format info
+      u16(peakDataRate << 1),
+      // Peak data rate (15 bits) + reserved (1 bit)
+      u32(0)
+      // Reserved
+    ]);
+  };
   var subtitleSampleDescription = (compressionType, trackData) => box(compressionType, [
     Array(6).fill(0),
     // Reserved
@@ -30835,6 +31312,55 @@ var Mediabunny = (() => {
       // Composition end time
     ]);
   };
+  var sgpdAndSbgp = (samples, inTrackFragment) => {
+    const entries = [];
+    for (const sample of samples) {
+      if (entries.length === 0) {
+        entries.push({
+          sampleCount: 1,
+          prerollSamples: sample.prerollSamples
+        });
+      } else {
+        const lastEntry = entries[entries.length - 1];
+        if (lastEntry.prerollSamples === sample.prerollSamples) {
+          lastEntry.sampleCount++;
+        } else {
+          entries.push({
+            sampleCount: 1,
+            prerollSamples: sample.prerollSamples
+          });
+        }
+      }
+    }
+    const rollEntries = entries.filter((x) => x.prerollSamples !== 0);
+    if (rollEntries.length === 0) {
+      return [];
+    }
+    let nextGroupIndex = inTrackFragment ? 65537 : 1;
+    return [
+      fullBox("sgpd", 1, 0, [
+        ascii("roll"),
+        // Grouping type
+        u32(2),
+        // Default length
+        u32(rollEntries.length),
+        // Entry count
+        ...rollEntries.map((x) => i16(x.prerollSamples))
+      ]),
+      fullBox("sbgp", 0, 0, [
+        ascii("roll"),
+        // Grouping type
+        u32(entries.length),
+        // Entry count
+        ...entries.map((x) => [
+          u32(x.sampleCount),
+          // Sample count
+          u32(x.prerollSamples !== 0 ? nextGroupIndex++ : 0)
+          // Samples with no preroll belong to no group
+        ])
+      ])
+    ];
+  };
   var mvex = (trackDatas) => {
     return box("mvex", void 0, trackDatas.map(trex));
   };
@@ -30882,7 +31408,8 @@ var Mediabunny = (() => {
     return box("traf", void 0, [
       tfhd(trackData),
       tfdt(trackData),
-      trun(trackData)
+      trun(trackData),
+      ...sgpdAndSbgp(trackData.currentChunk.samples, true)
     ]);
   };
   var tfhd = (trackData) => {
@@ -31400,6 +31927,8 @@ var Mediabunny = (() => {
         return "ec-3";
       case "dts":
         return fullCodecString;
+      case "truehd":
+        return "mlpa";
     }
     if (isQuickTime) {
       switch (codec) {
@@ -31467,6 +31996,8 @@ var Mediabunny = (() => {
         return dec3;
       case "dts":
         return ddts;
+      case "truehd":
+        return dmlp;
     }
     if (isQuickTime) {
       switch (codec) {
@@ -31698,6 +32229,8 @@ var Mediabunny = (() => {
     }
     /** @internal */
     _ensureSize(size) {
+      assert(this._buffer);
+      assert(this._bytes);
       let newLength = this._buffer.byteLength;
       while (newLength < size) newLength *= 2;
       if (newLength === this._buffer.byteLength) return;
@@ -31721,6 +32254,7 @@ var Mediabunny = (() => {
     }
     /** @internal */
     _write(data, pos) {
+      assert(this._bytes);
       this._ensureSize(pos + data.byteLength);
       this._bytes.set(data, pos);
       this._maxPos = Math.max(this._maxPos, pos + data.byteLength);
@@ -31731,7 +32265,14 @@ var Mediabunny = (() => {
     }
     /** @internal */
     async _finalize() {
-      this.buffer = this._buffer.slice(0, this._maxPos);
+      assert(this._buffer);
+      if ("transferToFixedLength" in this._buffer) {
+        this.buffer = this._buffer.transferToFixedLength(this._maxPos);
+      } else {
+        this.buffer = this._buffer.slice(0, this._maxPos);
+      }
+      this._buffer = null;
+      this._bytes = null;
       if (this._options.onFinalize) {
         await this._options.onFinalize(this.buffer);
       }
@@ -31742,6 +32283,7 @@ var Mediabunny = (() => {
     }
     /** @internal */
     _getSlice(start, end) {
+      assert(this._bytes);
       return this._bytes.slice(start, end);
     }
   };
@@ -32153,6 +32695,7 @@ var Mediabunny = (() => {
   // src/isobmff/isobmff-muxer.ts
   var GLOBAL_TIMESCALE = 57600;
   var TIMESTAMP_OFFSET = 2082844800;
+  var MIN_CHUNK_DURATION = 0.5;
   var getTrackMetadata = (trackData) => {
     const metadata = {};
     const track = trackData.track;
@@ -32448,6 +32991,9 @@ var Mediabunny = (() => {
         if (track.source._codec === "dts") {
           throw new Error("DTS requires a priming packet.");
         }
+        if (track.source._codec === "truehd") {
+          throw new Error("TrueHD requires a priming packet.");
+        }
       }
       const newTrackData = {
         muxer: this,
@@ -32460,7 +33006,12 @@ var Mediabunny = (() => {
           requiresPcmTransformation: !this.isFragmented && PCM_AUDIO_CODECS.includes(track.source._codec),
           expectedNextPcmPacketTimestamp: null,
           requiresAdtsStripping,
-          primingPacket: packet
+          primingPacket: packet,
+          preroll: {
+            packetCount: 0,
+            accumulatedAudioSamples: 0,
+            audioSampleDurationHistory: []
+          }
         },
         timescale: decoderConfig.sampleRate,
         samples: [],
@@ -32552,7 +33103,8 @@ var Mediabunny = (() => {
           packetData,
           packet.timestamp,
           packet.duration,
-          packet.type
+          packet.type,
+          0
         );
         await this.registerSample(trackData, internalSample);
       } finally {
@@ -32600,12 +33152,31 @@ var Mediabunny = (() => {
           }
           trackData.info.expectedNextPcmPacketTimestamp = timestamp + duration;
         }
+        const { preroll } = trackData.info;
+        let prerollSamples = 0;
+        if (track.source._codec === "aac" || track.source._codec === "vorbis") {
+          prerollSamples = -Math.min(1, preroll.packetCount);
+        } else if (track.source._codec === "mp3") {
+          prerollSamples = -Math.min(2, preroll.packetCount);
+        } else if (track.source._codec === "opus") {
+          const OPUS_PREROLL_SAMPLES = Math.round(OPUS_PRE_ROLL_DURATION * OPUS_SAMPLE_RATE);
+          prerollSamples = -preroll.audioSampleDurationHistory.length;
+          const toc = parseOpusTocByte(packetData);
+          preroll.accumulatedAudioSamples += toc.durationInSamples;
+          preroll.audioSampleDurationHistory.push(toc.durationInSamples);
+          while (preroll.accumulatedAudioSamples - preroll.audioSampleDurationHistory[0] >= OPUS_PREROLL_SAMPLES) {
+            preroll.accumulatedAudioSamples -= preroll.audioSampleDurationHistory.shift();
+            assert(preroll.audioSampleDurationHistory.length > 0);
+          }
+        }
+        preroll.packetCount++;
         const internalSample = this.createSampleForTrack(
           trackData,
           packetData,
           timestamp,
           duration,
-          packet.type
+          packet.type,
+          prerollSamples
         );
         await this.registerSample(trackData, internalSample);
       } finally {
@@ -32626,7 +33197,8 @@ var Mediabunny = (() => {
           new Uint8Array(data.buffer),
           timestamp,
           duration,
-          "key"
+          "key",
+          0
         );
         await this.registerSample(trackData, paddingSample);
       }
@@ -32672,7 +33244,8 @@ var Mediabunny = (() => {
             body2,
             trackData.lastCueEndTimestamp,
             sampleStart - trackData.lastCueEndTimestamp,
-            "key"
+            "key",
+            0
           );
           await this.registerSample(trackData, sample2);
           trackData.lastCueEndTimestamp = sampleStart;
@@ -32708,12 +33281,12 @@ var Mediabunny = (() => {
           }
         }
         const body = this.auxTarget._getSlice(0, this.auxWriter.getPos());
-        const sample = this.createSampleForTrack(trackData, body, sampleStart, sampleEnd - sampleStart, "key");
+        const sample = this.createSampleForTrack(trackData, body, sampleStart, sampleEnd - sampleStart, "key", 0);
         await this.registerSample(trackData, sample);
         trackData.lastCueEndTimestamp = sampleEnd;
       }
     }
-    createSampleForTrack(trackData, data, timestamp, duration, type) {
+    createSampleForTrack(trackData, data, timestamp, duration, type, prerollSamples) {
       const sample = {
         timestamp,
         decodeTimestamp: timestamp,
@@ -32722,8 +33295,9 @@ var Mediabunny = (() => {
         data,
         size: data.byteLength,
         type,
-        timescaleUnitsToNextSample: intoTimescale(duration, trackData.timescale)
+        timescaleUnitsToNextSample: intoTimescale(duration, trackData.timescale),
         // Will be refined
+        prerollSamples
       };
       return sample;
     }
@@ -32837,14 +33411,8 @@ var Mediabunny = (() => {
         this.processTimestamps(trackData, sample);
       }
       trackData.timestampProcessingQueue.push(sample);
-      if (this.isFragmented) {
-        trackData.sampleQueue.push(sample);
-        await this.interleaveSamples();
-      } else if (this.fastStart === "reserve") {
-        await this.registerSampleFastStartReserve(trackData, sample);
-      } else {
-        await this.addSampleToTrack(trackData, sample);
-      }
+      trackData.sampleQueue.push(sample);
+      await this.interleaveSamples();
     }
     async addSampleToTrack(trackData, sample) {
       if (!this.isFragmented) {
@@ -32884,12 +33452,15 @@ var Mediabunny = (() => {
             await this.finalizeFragment();
           }
         } else {
-          beginNewChunk = currentChunkDuration >= 0.5;
+          beginNewChunk = currentChunkDuration >= MIN_CHUNK_DURATION;
         }
       }
       if (beginNewChunk) {
-        if (trackData.currentChunk) {
-          await this.finalizeCurrentChunk(trackData);
+        if (!this.isFragmented) {
+          const tracksToFinalize = this.trackDatas.filter((x) => x.currentChunk && sample.timestamp - x.currentChunk.startTimestamp >= MIN_CHUNK_DURATION).sort((a, b) => a.currentChunk.startTimestamp - b.currentChunk.startTimestamp);
+          for (const otherTrackData of tracksToFinalize) {
+            await this.finalizeCurrentChunk(otherTrackData);
+          }
         }
         trackData.currentChunk = {
           startTimestamp: sample.timestamp,
@@ -32910,12 +33481,14 @@ var Mediabunny = (() => {
     async finalizeCurrentChunk(trackData) {
       assert(!this.isFragmented);
       assert(this.writer);
-      if (!trackData.currentChunk) return;
-      trackData.finalizedChunks.push(trackData.currentChunk);
-      this.finalizedChunks.push(trackData.currentChunk);
-      let sampleCount = trackData.currentChunk.samples.length;
+      const chunk = trackData.currentChunk;
+      assert(chunk);
+      trackData.currentChunk = null;
+      trackData.finalizedChunks.push(chunk);
+      this.finalizedChunks.push(chunk);
+      let sampleCount = chunk.samples.length;
       if (trackData.type === "audio" && trackData.info.requiresPcmTransformation) {
-        sampleCount = trackData.currentChunk.samples.reduce((acc, sample) => acc + intoTimescale(sample.duration, trackData.timescale), 0);
+        sampleCount = chunk.samples.reduce((acc, sample) => acc + intoTimescale(sample.duration, trackData.timescale), 0);
       }
       if (trackData.compactlyCodedChunkTable.length === 0 || last(trackData.compactlyCodedChunkTable).samplesPerChunk !== sampleCount) {
         trackData.compactlyCodedChunkTable.push({
@@ -32925,11 +33498,11 @@ var Mediabunny = (() => {
         });
       }
       if (this.fastStart === "in-memory") {
-        trackData.currentChunk.offset = 0;
+        chunk.offset = 0;
         return;
       }
-      trackData.currentChunk.offset = this.writer.getPos();
-      for (const sample of trackData.currentChunk.samples) {
+      chunk.offset = this.writer.getPos();
+      for (const sample of chunk.samples) {
         assert(sample.data);
         this.writer.write(sample.data);
         sample.data = null;
@@ -32937,10 +33510,12 @@ var Mediabunny = (() => {
       await this.writer.flush();
     }
     async interleaveSamples(isFinalCall = false) {
-      assert(this.isFragmented);
       if (!isFinalCall && !this.allTracksAreKnown()) {
         return;
       }
+      if (this.fastStart === "reserve" && !this.mdat) {
+        await this.createFastStartReserveMdat();
+      }
       outer:
         while (true) {
           let trackWithMinTimestamp = null;
@@ -33062,16 +33637,6 @@ var Mediabunny = (() => {
         await this.writer.flush();
       }
     }
-    async registerSampleFastStartReserve(trackData, sample) {
-      if (this.allTracksAreKnown()) {
-        if (!this.mdat) {
-          await this.createFastStartReserveMdat();
-        }
-        await this.addSampleToTrack(trackData, sample);
-      } else {
-        trackData.sampleQueue.push(sample);
-      }
-    }
     async createFastStartReserveMdat() {
       assert(this.writer);
       assert(this.boxWriter);
@@ -33086,12 +33651,6 @@ var Mediabunny = (() => {
       }
       this.mdat = mdat(true);
       this.boxWriter.writeBox(this.mdat);
-      for (const trackData of this.trackDatas) {
-        for (const sample of trackData.sampleQueue) {
-          await this.addSampleToTrack(trackData, sample);
-        }
-        trackData.sampleQueue.length = 0;
-      }
     }
     computeSampleTableSizeUpperBound() {
       assert(this.fastStart === "reserve");
@@ -33122,9 +33681,7 @@ var Mediabunny = (() => {
       if (this.allTracksAreKnown()) {
         this.allTracksKnown.resolve();
       }
-      if (this.isFragmented) {
-        await this.interleaveSamples();
-      }
+      await this.interleaveSamples();
       release();
     }
     ensureOneEnabledTrack() {
@@ -33165,9 +33722,6 @@ var Mediabunny = (() => {
       const release = await this.mutex.acquire();
       this.allTracksKnown.resolve();
       this.ensureOneEnabledTrack();
-      if (!this.mdat && this.fastStart === "reserve") {
-        await this.createFastStartReserveMdat();
-      }
       for (const trackData of this.trackDatas) {
         trackData.closed = true;
         if (trackData.type === "subtitle" && trackData.track.source._codec === "webvtt") {
@@ -33175,12 +33729,15 @@ var Mediabunny = (() => {
         }
         this.processTimestamps(trackData);
       }
+      await this.interleaveSamples(true);
       if (this.isFragmented) {
-        await this.interleaveSamples(true);
         await this.finalizeFragment(false);
       } else {
-        for (const trackData of this.trackDatas) {
+        const tracksToFinalize = this.trackDatas.filter((x) => x.currentChunk).sort((a, b) => a.currentChunk.startTimestamp - b.currentChunk.startTimestamp);
+        for (const trackData of tracksToFinalize) {
           await this.finalizeCurrentChunk(trackData);
+        }
+        for (const trackData of this.trackDatas) {
           const span = presentationSpan(trackData);
           if (span > 0) {
             let totalBytes = 0;
@@ -33333,10 +33890,9 @@ var Mediabunny = (() => {
       this.attachmentsElement = null;
       this.segmentDuration = null;
       this.cues = null;
-      this.currentCluster = null;
+      this.currentClusterBlocks = [];
       this.currentClusterStartMsTimestamp = null;
       this.currentClusterMaxMsTimestamp = null;
-      this.trackDatasInCurrentCluster = /* @__PURE__ */ new Map();
       this.startTimestamp = Infinity;
       this.endTimestamp = -Infinity;
       this.warnedAboutTooNegativeTimestamp = false;
@@ -33468,14 +34024,12 @@ var Mediabunny = (() => {
           }
         }
         let seekPreRollNs = 0;
-        if (trackData.type === "audio" && trackData.track.source._codec === "opus") {
-          seekPreRollNs = 1e6 * 80;
-          const description = trackData.info.decoderConfig.description;
-          if (description) {
-            const bytes2 = toUint8Array(description);
-            const header = parseOpusIdentificationHeader(bytes2);
-            seekPreRollNs = Math.round(1e9 * (header.preSkip / OPUS_SAMPLE_RATE));
-          }
+        if (trackData.type === "audio") {
+          const preRollDuration = getAudioPreRollDuration(
+            trackData.track.source._codec,
+            trackData.info.decoderConfig
+          );
+          seekPreRollNs = Math.round(1e9 * preRollDuration);
         }
         tracksElement.data.push({ id: 174 /* TrackEntry */, data: [
           { id: 215 /* TrackNumber */, data: trackData.track.id },
@@ -33491,6 +34045,7 @@ var Mediabunny = (() => {
           { id: 2274716 /* Language */, data: trackData.track.metadata.languageCode ?? UNDETERMINED_LANGUAGE },
           { id: 134 /* CodecID */, data: codecId },
           trackData.codecPrivate ? { id: 25506 /* CodecPrivate */, data: toUint8Array(trackData.codecPrivate) } : null,
+          trackData.type === "audio" && trackData.info.codecDelay ? { id: 22186 /* CodecDelay */, data: Math.round(1e9 * trackData.info.codecDelay) } : null,
           seekPreRollNs > 0 ? { id: 22203 /* SeekPreRoll */, data: seekPreRollNs } : null,
           trackData.track.metadata.name !== void 0 ? { id: 21358 /* Name */, data: new EBMLUnicodeString(trackData.track.metadata.name) } : null,
           trackData.type === "video" ? this.videoSpecificTrackInfo(trackData) : null,
@@ -33953,7 +34508,8 @@ var Mediabunny = (() => {
           numberOfChannels: meta.decoderConfig.numberOfChannels,
           sampleRate: meta.decoderConfig.sampleRate,
           decoderConfig,
-          requiresAdtsStripping
+          requiresAdtsStripping,
+          codecDelay: null
         },
         chunkQueue: [],
         lastWrittenMsTimestamp: null,
@@ -34037,7 +34593,13 @@ var Mediabunny = (() => {
         }
         const isKeyFrame = packet.type === "key";
         this.validateTimestamp(trackData.track, packet.timestamp, isKeyFrame);
-        const audioChunk = this.createInternalChunk(packetData, packet.timestamp, packet.duration, packet.type);
+        trackData.info.codecDelay ??= Math.max(-packet.timestamp, 0);
+        const audioChunk = this.createInternalChunk(
+          packetData,
+          packet.timestamp + trackData.info.codecDelay,
+          packet.duration,
+          packet.type
+        );
         trackData.chunkQueue.push(audioChunk);
         await this.interleaveChunks();
       } finally {
@@ -34095,7 +34657,7 @@ ${cue.notes ?? ""}`;
             break;
           }
           const chunk = trackWithMinTimestamp.chunkQueue.shift();
-          this.writeBlock(trackWithMinTimestamp, chunk);
+          this.addBlock(trackWithMinTimestamp, chunk);
         }
       if (!isFinalCall) {
         await this.writer.flush();
@@ -34141,8 +34703,8 @@ ${cue.notes ?? ""}`;
       };
       return internalChunk;
     }
-    /** Writes a block containing media data to the file. */
-    writeBlock(trackData, chunk) {
+    /** Adds a block containing media data to the current cluster. */
+    addBlock(trackData, chunk) {
       if (!this.segment) {
         this.createSegment();
       }
@@ -34158,16 +34720,15 @@ ${cue.notes ?? ""}`;
         return otherTrackData.closed;
       });
       let shouldCreateNewCluster = false;
-      if (!this.currentCluster) {
+      if (this.currentClusterStartMsTimestamp === null) {
         shouldCreateNewCluster = true;
       } else {
-        assert(this.currentClusterStartMsTimestamp !== null);
         assert(this.currentClusterMaxMsTimestamp !== null);
         const relativeTimestamp2 = msTimestamp - this.currentClusterStartMsTimestamp;
         shouldCreateNewCluster = keyFrameQueuedEverywhere && msTimestamp > this.currentClusterMaxMsTimestamp && relativeTimestamp2 >= 1e3 * (this.format._options.minimumClusterDuration ?? 1) || relativeTimestamp2 > MAX_CLUSTER_TIMESTAMP_MS;
       }
       if (shouldCreateNewCluster) {
-        this.createNewCluster(msTimestamp);
+        this.startNewCluster(msTimestamp);
       }
       const relativeTimestamp = msTimestamp - this.currentClusterStartMsTimestamp;
       if (relativeTimestamp < MIN_CLUSTER_TIMESTAMP_MS) {
@@ -34180,109 +34741,124 @@ ${cue.notes ?? ""}`;
         }
         return;
       }
-      const prelude = new Uint8Array(4);
-      const view2 = new DataView(prelude.buffer);
-      view2.setUint8(0, 128 | trackData.track.id);
-      view2.setInt16(1, relativeTimestamp, false);
-      const msDuration = Math.round(1e3 * chunk.duration);
-      const needsBlockGroup = !!chunk.additions || trackData.type === "subtitle";
-      if (!needsBlockGroup) {
-        view2.setUint8(3, Number(chunk.type === "key") << 7);
-        const simpleBlock = { id: 163 /* SimpleBlock */, data: [
-          prelude,
-          chunk.data
-        ] };
-        this.ebmlWriter.writeEBML(simpleBlock);
-      } else {
-        const blockGroup = { id: 160 /* BlockGroup */, data: [
-          { id: 161 /* Block */, data: [
-            prelude,
-            chunk.data
-          ] },
-          chunk.type === "delta" ? {
-            id: 251 /* ReferenceBlock */,
-            data: new EBMLSignedInt(trackData.lastWrittenMsTimestamp - msTimestamp)
-          } : null,
-          chunk.additions ? { id: 30113 /* BlockAdditions */, data: [
-            { id: 166 /* BlockMore */, data: [
-              { id: 238 /* BlockAddID */, data: 1 },
-              // Some players expect BlockAddID to come first
-              { id: 165 /* BlockAdditional */, data: chunk.additions }
-            ] }
-          ] } : null,
-          msDuration > 0 ? { id: 155 /* BlockDuration */, data: msDuration } : null
-        ] };
-        this.ebmlWriter.writeEBML(blockGroup);
-      }
+      this.currentClusterBlocks.push({
+        trackData,
+        chunk,
+        msTimestamp,
+        previousMsTimestamp: trackData.lastWrittenMsTimestamp
+      });
       this.startTimestamp = Math.min(this.startTimestamp, msTimestamp);
-      this.endTimestamp = Math.max(this.endTimestamp, msTimestamp + msDuration);
+      this.endTimestamp = Math.max(this.endTimestamp, msTimestamp + Math.round(1e3 * chunk.duration));
       trackData.lastWrittenMsTimestamp = msTimestamp;
-      if (!this.trackDatasInCurrentCluster.has(trackData)) {
-        this.trackDatasInCurrentCluster.set(trackData, {
-          firstMsTimestamp: msTimestamp
-        });
-      }
       this.currentClusterMaxMsTimestamp = Math.max(this.currentClusterMaxMsTimestamp, msTimestamp);
     }
-    /** Creates a new Cluster element to contain media chunks. */
-    createNewCluster(msTimestamp) {
-      msTimestamp = Math.max(0, msTimestamp);
-      if (this.currentCluster) {
-        this.finalizeCurrentCluster();
-      }
-      if (this.format._options.onCluster) {
-        this.writer.startTrackingWrites();
+    /** Writes out the current cluster, if any, and begins a new one. */
+    startNewCluster(msTimestamp) {
+      if (this.currentClusterStartMsTimestamp !== null) {
+        this.writeCurrentCluster();
+      }
+      const clusterMsTimestamp = Math.max(0, msTimestamp);
+      this.currentClusterStartMsTimestamp = clusterMsTimestamp;
+      this.currentClusterMaxMsTimestamp = clusterMsTimestamp;
+    }
+    /** Writes the current cluster with all of its blocks to the file. */
+    writeCurrentCluster() {
+      assert(this.currentClusterStartMsTimestamp !== null);
+      const clusterMsTimestamp = this.currentClusterStartMsTimestamp;
+      const firstKeyBlockPerTrack = /* @__PURE__ */ new Map();
+      const lastBlockPerTrack = /* @__PURE__ */ new Map();
+      for (const block of this.currentClusterBlocks) {
+        if (block.chunk.type === "key" && !firstKeyBlockPerTrack.has(block.trackData)) {
+          firstKeyBlockPerTrack.set(block.trackData, block);
+        }
+        lastBlockPerTrack.set(block.trackData, block);
+      }
+      const blockElements = /* @__PURE__ */ new Map();
+      for (const block of this.currentClusterBlocks) {
+        blockElements.set(block, this.createBlockElement(
+          block,
+          clusterMsTimestamp,
+          lastBlockPerTrack.get(block.trackData) === block
+        ));
       }
-      this.currentCluster = {
+      const cluster = {
         id: 524531317 /* Cluster */,
         size: this.format._options.appendOnly ? -1 : CLUSTER_SIZE_BYTES,
         data: [
-          { id: 231 /* Timestamp */, data: msTimestamp }
+          { id: 231 /* Timestamp */, data: clusterMsTimestamp },
+          ...blockElements.values()
         ]
       };
-      this.ebmlWriter.writeEBML(this.currentCluster);
-      this.currentClusterStartMsTimestamp = msTimestamp;
-      this.currentClusterMaxMsTimestamp = msTimestamp;
-      this.trackDatasInCurrentCluster.clear();
-    }
-    finalizeCurrentCluster() {
-      assert(this.currentCluster);
-      if (!this.format._options.appendOnly) {
-        const clusterSize = this.writer.getPos() - this.ebmlWriter.dataOffsets.get(this.currentCluster);
-        const endPos = this.writer.getPos();
-        this.writer.seek(this.ebmlWriter.offsets.get(this.currentCluster) + 4);
-        this.ebmlWriter.writeVarInt(clusterSize, CLUSTER_SIZE_BYTES);
-        this.writer.seek(endPos);
+      if (this.format._options.onCluster) {
+        this.writer.startTrackingWrites();
       }
+      this.ebmlWriter.writeEBML(cluster);
+      this.currentClusterBlocks = [];
       if (this.format._options.onCluster) {
-        assert(this.currentClusterStartMsTimestamp !== null);
         const { data, start } = this.writer.stopTrackingWrites();
-        this.format._options.onCluster(data, start, this.currentClusterStartMsTimestamp / 1e3);
+        this.format._options.onCluster(data, start, clusterMsTimestamp / 1e3);
       }
-      const clusterOffsetFromSegment = this.ebmlWriter.offsets.get(this.currentCluster) - this.segmentDataOffset;
+      const clusterOffsetFromSegment = this.ebmlWriter.offsets.get(cluster) - this.segmentDataOffset;
+      const clusterDataOffset = this.ebmlWriter.dataOffsets.get(cluster);
       const groupedByTimestamp = /* @__PURE__ */ new Map();
-      for (const [trackData, { firstMsTimestamp }] of this.trackDatasInCurrentCluster) {
-        if (!groupedByTimestamp.has(firstMsTimestamp)) {
-          groupedByTimestamp.set(firstMsTimestamp, []);
+      for (const block of firstKeyBlockPerTrack.values()) {
+        if (!groupedByTimestamp.has(block.msTimestamp)) {
+          groupedByTimestamp.set(block.msTimestamp, []);
         }
-        groupedByTimestamp.get(firstMsTimestamp).push(trackData);
+        groupedByTimestamp.get(block.msTimestamp).push(block);
       }
       const groupedAndSortedByTimestamp = [...groupedByTimestamp.entries()].sort((a, b) => a[0] - b[0]);
-      for (const [msTimestamp, trackDatas] of groupedAndSortedByTimestamp) {
+      for (const [msTimestamp, blocks] of groupedAndSortedByTimestamp) {
         assert(this.cues);
         this.cues.data.push({ id: 187 /* CuePoint */, data: [
           { id: 179 /* CueTime */, data: Math.max(0, msTimestamp) },
           // CueTime is unsigned
-          // Create CueTrackPositions for each track that starts at this timestamp
-          ...trackDatas.map((trackData) => {
+          // Create CueTrackPositions for each track whose first key packet is at this timestamp
+          ...blocks.map((block) => {
+            const blockOffset = this.ebmlWriter.offsets.get(blockElements.get(block));
             return { id: 183 /* CueTrackPositions */, data: [
-              { id: 247 /* CueTrack */, data: trackData.track.id },
-              { id: 241 /* CueClusterPosition */, data: clusterOffsetFromSegment }
+              { id: 247 /* CueTrack */, data: block.trackData.track.id },
+              { id: 241 /* CueClusterPosition */, data: clusterOffsetFromSegment },
+              { id: 240 /* CueRelativePosition */, data: blockOffset - clusterDataOffset }
             ] };
           })
         ] });
       }
     }
+    createBlockElement(block, clusterMsTimestamp, isLastOfTrack) {
+      const { trackData, chunk, msTimestamp } = block;
+      const prelude = new Uint8Array(4);
+      const view2 = new DataView(prelude.buffer);
+      view2.setUint8(0, 128 | trackData.track.id);
+      view2.setInt16(1, msTimestamp - clusterMsTimestamp, false);
+      const msDuration = Math.round(1e3 * chunk.duration);
+      const needsBlockGroup = !!chunk.additions || trackData.type === "subtitle" || isLastOfTrack && msDuration > 0;
+      if (!needsBlockGroup) {
+        view2.setUint8(3, Number(chunk.type === "key") << 7);
+        return { id: 163 /* SimpleBlock */, data: [
+          prelude,
+          chunk.data
+        ] };
+      }
+      return { id: 160 /* BlockGroup */, data: [
+        { id: 161 /* Block */, data: [
+          prelude,
+          chunk.data
+        ] },
+        chunk.type === "delta" ? {
+          id: 251 /* ReferenceBlock */,
+          data: new EBMLSignedInt(block.previousMsTimestamp - msTimestamp)
+        } : null,
+        chunk.additions ? { id: 30113 /* BlockAdditions */, data: [
+          { id: 166 /* BlockMore */, data: [
+            { id: 238 /* BlockAddID */, data: 1 },
+            // Some players expect BlockAddID to come first
+            { id: 165 /* BlockAdditional */, data: chunk.additions }
+          ] }
+        ] } : null,
+        msDuration > 0 ? { id: 155 /* BlockDuration */, data: msDuration } : null
+      ] };
+    }
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
     async onTrackClose(track) {
       const release = await this.mutex.acquire();
@@ -34307,8 +34883,8 @@ ${cue.notes ?? ""}`;
         this.createSegment();
       }
       await this.interleaveChunks(true);
-      if (this.currentCluster) {
-        this.finalizeCurrentCluster();
+      if (this.currentClusterStartMsTimestamp !== null) {
+        this.writeCurrentCluster();
       }
       assert(this.cues);
       this.ebmlWriter.writeEBML(this.cues);
@@ -34335,13 +34911,24 @@ ${cue.notes ?? ""}`;
       this.writer = writer;
       this.helper = new Uint8Array(8);
       this.helperView = new DataView(this.helper.buffer);
+      this.crc = 0;
+    }
+    writeAndUpdateCrc(bytes2) {
+      for (const byte of bytes2) {
+        this.crc ^= byte;
+        for (let bit = 0; bit < 8; bit++) {
+          this.crc = this.crc >>> 1 ^ (this.crc & 1 ? 40961 : 0);
+        }
+      }
+      this.writer.write(bytes2);
     }
     writeU32(value) {
       this.helperView.setUint32(0, value, false);
-      this.writer.write(this.helper.subarray(0, 4));
+      this.writeAndUpdateCrc(this.helper.subarray(0, 4));
     }
     writeXingFrame(data) {
       const startPos = this.writer.getPos();
+      this.crc = 0;
       const firstByte = 255;
       const secondByte = 224 | data.mpegVersionId << 3 | data.layer << 1;
       let lowSamplingFrequency;
@@ -34351,7 +34938,8 @@ ${cue.notes ?? ""}`;
         lowSamplingFrequency = 1;
       }
       const padding = 0;
-      const neededBytes = 155;
+      const xingOffset = getXingOffset(data.mpegVersionId, data.channel);
+      const neededBytes = data.encoderDelayInSamples === null ? 155 : xingOffset + 8 + 4 + 4 + 100 + 36;
       let bitrateIndex = -1;
       const bitrateOffset = lowSamplingFrequency * 16 * 4 + data.layer * 16;
       for (let i = 0; i < 16; i++) {
@@ -34371,10 +34959,9 @@ ${cue.notes ?? ""}`;
       this.helper[1] = secondByte;
       this.helper[2] = thirdByte;
       this.helper[3] = fourthByte;
-      this.writer.write(this.helper.subarray(0, 4));
-      const xingOffset = getXingOffset(data.mpegVersionId, data.channel);
-      this.writer.seek(startPos + xingOffset);
-      this.writeU32(XING);
+      this.writeAndUpdateCrc(this.helper.subarray(0, 4));
+      this.writeAndUpdateCrc(new Uint8Array(xingOffset - 4));
+      this.writeU32(data.isCbr ? INFO : XING);
       let flags = 0;
       if (data.frameCount !== null) {
         flags |= 1 /* FrameCount */;
@@ -34388,7 +34975,17 @@ ${cue.notes ?? ""}`;
       this.writeU32(flags);
       this.writeU32(data.frameCount ?? 0);
       this.writeU32(data.fileSize ?? 0);
-      this.writer.write(data.toc ?? new Uint8Array(100));
+      this.writeAndUpdateCrc(data.toc ?? new Uint8Array(100));
+      if (data.encoderDelayInSamples !== null) {
+        const lame = new Uint8Array(36);
+        lame.set([76, 65, 77, 69]);
+        lame[21] = data.encoderDelayInSamples >> 4;
+        lame[22] = (data.encoderDelayInSamples & 15) << 4 | MP3_DECODER_DELAY >> 8;
+        lame[23] = MP3_DECODER_DELAY & 255;
+        this.writeAndUpdateCrc(lame.subarray(0, 34));
+        new DataView(lame.buffer).setUint16(34, this.crc);
+        this.writer.write(lame.subarray(34));
+      }
       const kilobitRate = KILOBIT_RATES[bitrateOffset + bitrateIndex];
       const frameSize = computeMp3FrameSize(
         lowSamplingFrequency,
@@ -34407,6 +35004,8 @@ ${cue.notes ?? ""}`;
       super(output);
       this.xingFrameData = null;
       this.frameCount = 0;
+      this.frameBitrate = null;
+      this.hasVariableBitrate = false;
       this.framePositions = [];
       this.xingFramePos = null;
       this.format = format;
@@ -34431,7 +35030,7 @@ ${cue.notes ?? ""}`;
     async addEncodedAudioPacket(track, packet) {
       const release = await this.mutex.acquire();
       try {
-        if (!this.xingFrameData && this.writeXingHeader) {
+        if (this.writeXingHeader) {
           const view2 = toDataView(packet.data);
           if (view2.byteLength < 4) {
             throw new Error("Invalid MP3 header in sample.");
@@ -34441,31 +35040,44 @@ ${cue.notes ?? ""}`;
           if (!header) {
             throw new Error("Invalid MP3 header in sample.");
           }
-          const xingOffset = getXingOffset(header.mpegVersionId, header.channel);
-          if (view2.byteLength >= xingOffset + 4) {
-            const word2 = view2.getUint32(xingOffset, false);
-            const isXing = word2 === XING || word2 === INFO;
-            if (isXing) {
-              return;
+          if (!this.xingFrameData) {
+            const xingOffset = getXingOffset(header.mpegVersionId, header.channel);
+            if (view2.byteLength >= xingOffset + 4) {
+              const word2 = view2.getUint32(xingOffset, false);
+              const isXing = word2 === XING || word2 === INFO;
+              if (isXing) {
+                return;
+              }
             }
+            let encoderDelay = packet.timestamp < 0 ? Math.round(-packet.timestamp * header.sampleRate) - MP3_DECODER_DELAY : null;
+            if (encoderDelay !== null && (encoderDelay < 0 || encoderDelay > 4095)) {
+              encoderDelay = null;
+            }
+            this.xingFrameData = {
+              mpegVersionId: header.mpegVersionId,
+              layer: header.layer,
+              frequencyIndex: header.frequencyIndex,
+              sampleRate: header.sampleRate,
+              channel: header.channel,
+              modeExtension: header.modeExtension,
+              copyright: header.copyright,
+              original: header.original,
+              emphasis: header.emphasis,
+              isCbr: false,
+              frameCount: null,
+              fileSize: null,
+              toc: null,
+              encoderDelayInSamples: encoderDelay
+            };
+            this.xingFramePos = this.writer.getPos();
+            this.mp3Writer.writeXingFrame(this.xingFrameData);
+            this.frameCount++;
+          }
+          if (this.frameBitrate === null) {
+            this.frameBitrate = header.bitrate;
+          } else if (header.bitrate !== this.frameBitrate) {
+            this.hasVariableBitrate = true;
           }
-          this.xingFrameData = {
-            mpegVersionId: header.mpegVersionId,
-            layer: header.layer,
-            frequencyIndex: header.frequencyIndex,
-            sampleRate: header.sampleRate,
-            channel: header.channel,
-            modeExtension: header.modeExtension,
-            copyright: header.copyright,
-            original: header.original,
-            emphasis: header.emphasis,
-            frameCount: null,
-            fileSize: null,
-            toc: null
-          };
-          this.xingFramePos = this.writer.getPos();
-          this.mp3Writer.writeXingFrame(this.xingFrameData);
-          this.frameCount++;
         }
         this.validateTimestamp(track, packet.timestamp, packet.type === "key");
         if (this.writeXingHeader) {
@@ -34513,9 +35125,11 @@ ${cue.notes ?? ""}`;
             copyright: header.copyright,
             original: header.original,
             emphasis: header.emphasis,
+            isCbr: false,
             frameCount: null,
             fileSize: null,
-            toc: null
+            toc: null,
+            encoderDelayInSamples: null
           };
         } else if (track.metadata.decoderConfig) {
           const { sampleRate, numberOfChannels } = track.metadata.decoderConfig;
@@ -34544,9 +35158,11 @@ ${cue.notes ?? ""}`;
             copyright: 0,
             original: 0,
             emphasis: 0,
+            isCbr: false,
             frameCount: null,
             fileSize: null,
-            toc: null
+            toc: null,
+            encoderDelayInSamples: null
           };
         } else {
           throw new Error(
@@ -34572,6 +35188,7 @@ ${cue.notes ?? ""}`;
           }
           this.xingFrameData.toc = toc;
         }
+        this.xingFrameData.isCbr = this.frameBitrate !== null && !this.hasVariableBitrate;
         this.xingFrameData.frameCount = this.frameCount;
         this.xingFrameData.fileSize = audioDataEndPos;
         if (this.format._options.onXingFrame) {
@@ -34643,7 +35260,7 @@ ${cue.notes ?? ""}`;
         },
         vorbisLastBlocksize: null,
         packetQueue: [],
-        startTimestampInSamples: null,
+        startOffsetInSamples: null,
         currentTimestampInSamples: 0,
         audioPacketCount: 0,
         pagesWritten: 0,
@@ -34765,22 +35382,24 @@ ${cue.notes ?? ""}`;
       try {
         const trackData = this.getTrackData(track, meta);
         this.validateTimestamp(trackData.track, packet.timestamp, packet.type === "key");
-        if (trackData.startTimestampInSamples === null) {
-          const timestampInSamples = Math.round(packet.timestamp * trackData.internalSampleRate);
-          const preSkip = trackData.codecInfo.opusInfo?.preSkip ?? 0;
-          trackData.startTimestampInSamples = timestampInSamples > 0 ? timestampInSamples + preSkip : 0;
-          trackData.currentTimestampInSamples = trackData.startTimestampInSamples;
-        }
-        const currentTimestampInSamples = trackData.currentTimestampInSamples;
         const { durationInSamples, vorbisBlockSize } = extractSampleMetadata(
           packet.data,
           trackData.codecInfo,
           trackData.vorbisLastBlocksize
         );
+        if (trackData.startOffsetInSamples === null) {
+          const timestampInSamples = Math.round(packet.timestamp * trackData.internalSampleRate);
+          const preSkip = trackData.codecInfo.opusInfo?.preSkip ?? 0;
+          const minTimestampInSamples = trackData.codecInfo.codec === "vorbis" ? -durationInSamples : -preSkip;
+          const startTimestampInSamples = Math.max(timestampInSamples, minTimestampInSamples);
+          trackData.startOffsetInSamples = startTimestampInSamples - minTimestampInSamples;
+          trackData.currentTimestampInSamples = startTimestampInSamples + preSkip;
+        }
+        const currentTimestampInSamples = trackData.currentTimestampInSamples;
         trackData.currentTimestampInSamples += durationInSamples;
         trackData.vorbisLastBlocksize = vorbisBlockSize;
         const trimmedDurationInSamples = packet.duration > 0 ? clamp(Math.round(packet.duration * trackData.internalSampleRate), 0, durationInSamples) : durationInSamples;
-        const forcePageFlush = trackData.startTimestampInSamples > 0 && trackData.audioPacketCount === 1;
+        const forcePageFlush = trackData.startOffsetInSamples > 0 && trackData.audioPacketCount === 1;
         trackData.audioPacketCount++;
         trackData.packetQueue.push({
           data: packet.data,
@@ -34989,6 +35608,7 @@ ${cue.notes ?? ""}`;
       this.adaptationFieldBuffer = new Uint8Array(184);
       this.payloadBuffer = new Uint8Array(184);
       this.format = format;
+      this.timestampOffset = format._options.timestampOffset ?? 0;
     }
     async start() {
       const release = await this.mutex.acquire();
@@ -35358,8 +35978,7 @@ ${cue.notes ?? ""}`;
       pesView.setUint8(6, 132);
       pesView.setUint8(7, includeDts ? 192 : 128);
       pesView.setUint8(8, headerDataLength);
-      const unwrappedPts = Math.round(queuedPacket.presentationTimestamp * TIMESCALE);
-      const pts = modEuclid(unwrappedPts, TIMESTAMP_MODULUS);
+      const pts = secondsToMpegTsTimestamp(queuedPacket.presentationTimestamp + this.timestampOffset);
       ptsDtsBitstream.pos = 0;
       ptsDtsBitstream.writeBits(4, includeDts ? 3 : 2);
       ptsDtsBitstream.writeBits(3, Math.floor(pts / 2 ** 30));
@@ -35370,8 +35989,7 @@ ${cue.notes ?? ""}`;
       ptsDtsBitstream.writeBits(1, 1);
       if (includeDts) {
         assert(queuedPacket.decodeTimestamp !== null);
-        const unwrappedDts = Math.round(queuedPacket.decodeTimestamp * TIMESCALE);
-        const dts = modEuclid(unwrappedDts, TIMESTAMP_MODULUS);
+        const dts = secondsToMpegTsTimestamp(queuedPacket.decodeTimestamp + this.timestampOffset);
         ptsDtsBitstream.writeBits(4, 1);
         ptsDtsBitstream.writeBits(3, Math.floor(dts / 2 ** 30));
         ptsDtsBitstream.writeBits(1, 1);
@@ -35992,10 +36610,12 @@ ${cue.notes ?? ""}`;
       const sourceDataSize = audioSample.allocationSize({ planeIndex: 0, format: "f32" });
       const sourceView = new Float32Array(this.tempSourceBuffer.buffer, 0, sourceDataSize / 4);
       audioSample.copyTo(sourceView, { planeIndex: 0, format: "f32" });
-      const inputStartTime = audioSample.timestamp - this.startTime;
-      const inputEndTime = inputStartTime + audioSample.duration;
-      const outputStartFrame = Math.floor((inputStartTime - 1 / this.sourceSampleRate) * this.targetSampleRate) + 1;
-      const outputEndFrame = Math.ceil(inputEndTime * this.targetSampleRate);
+      const sourceStartFrame = Math.round((audioSample.timestamp - this.startTime) * this.sourceSampleRate);
+      const sourceEndFrame = sourceStartFrame + audioSample.numberOfFrames;
+      const outputStartFrame = Math.floor(
+        (sourceStartFrame - 1) * this.targetSampleRate / this.sourceSampleRate
+      ) + 1;
+      const outputEndFrame = Math.ceil(sourceEndFrame * this.targetSampleRate / this.sourceSampleRate);
       for (let outputFrame = outputStartFrame; outputFrame < outputEndFrame; outputFrame++) {
         if (outputFrame < this.bufferStartFrame) {
           continue;
@@ -36006,9 +36626,7 @@ ${cue.notes ?? ""}`;
         }
         const bufferFrameIndex = outputFrame - this.bufferStartFrame;
         assert(bufferFrameIndex < this.bufferCapacityInFrames);
-        const outputTime = outputFrame / this.targetSampleRate;
-        const inputTime = outputTime - inputStartTime;
-        const sourcePosition = inputTime * this.sourceSampleRate;
+        const sourcePosition = outputFrame * this.sourceSampleRate / this.targetSampleRate - sourceStartFrame;
         const sourceLowerFrame = Math.floor(sourcePosition);
         const sourceUpperFrame = Math.ceil(sourcePosition);
         const fraction = sourcePosition - sourceLowerFrame;
@@ -37691,7 +38309,7 @@ ${cue.notes ?? ""}`;
     }
     ensureEncoder(audioSample) {
       this.ensureEncoderPromise = (async () => {
-        const { numberOfChannels, sampleRate } = audioSample;
+        const { numberOfChannels, sampleRate, timestamp } = audioSample;
         const quality = resolveQuality(this.encodingConfig.quality, this.encodingConfig.bitrate);
         const encoderConfig = buildAudioEncoderConfig({
           numberOfChannels,
@@ -37743,39 +38361,33 @@ ${cue.notes ?? ""}`;
               `This specific encoder configuration (${encoderConfig.codec}, ${encoderConfig.bitrate} bps, ${encoderConfig.numberOfChannels} channels, ${encoderConfig.sampleRate} Hz) is not supported in this environment. Consider using another codec or changing your audio parameters.`
             );
           }
+          const primingShiftInSamples = await detectAudioEncoderPrimingShift(
+            this.encodingConfig.codec,
+            encoderConfig.codec
+          );
+          const primingShift = primingShiftInSamples / encoderConfig.sampleRate;
+          let opusPreSkip = 0;
           const stack = new Error("Encoding error").stack;
           this.encoder = new AudioEncoder({
             output: (chunk, meta) => {
-              if (this.encodingConfig.codec === "aac" && meta?.decoderConfig) {
-                if (meta.decoderConfig.description && meta.decoderConfig.description.byteLength > 0 && toUint8Array(meta.decoderConfig.description)[0] === 3) {
-                  const { decoderSpecificInfo } = readEsDescriptor(
-                    FileSlice4.tempFromBytes(toUint8Array(meta.decoderConfig.description))
-                  );
-                  meta.decoderConfig.description = decoderSpecificInfo ?? void 0;
-                }
-                let needsDescriptionOverwrite = false;
-                if (!meta.decoderConfig.description || meta.decoderConfig.description.byteLength < 2) {
-                  needsDescriptionOverwrite = true;
-                } else {
-                  const audioSpecificConfig = parseAacAudioSpecificConfig(
-                    toUint8Array(meta.decoderConfig.description)
-                  );
-                  needsDescriptionOverwrite = audioSpecificConfig.objectType === 0;
-                }
-                if (needsDescriptionOverwrite) {
-                  const objectType = Number(last(encoderConfig.codec.split(".")));
-                  meta.decoderConfig.description = buildAacAudioSpecificConfig({
-                    objectType,
-                    outputNumberOfChannels: meta.decoderConfig.numberOfChannels,
-                    outputSampleRate: meta.decoderConfig.sampleRate
-                  });
+              if (meta?.decoderConfig) {
+                fixAudioDecoderConfig(this.encodingConfig.codec, encoderConfig, meta.decoderConfig);
+                if (this.encodingConfig.codec === "opus" && meta.decoderConfig.description) {
+                  const description = toUint8Array(meta.decoderConfig.description);
+                  opusPreSkip = parseOpusIdentificationHeader(description).preSkip / OPUS_SAMPLE_RATE;
                 }
               }
               let packet = EncodedPacket.fromEncodedChunk(chunk);
               packet = packet.clone({
-                timestamp: roundToDivisor(packet.timestamp, encoderConfig.sampleRate),
+                timestamp: roundToDivisor(
+                  packet.timestamp - primingShift - opusPreSkip,
+                  encoderConfig.sampleRate
+                ),
                 duration: chunk.duration != null ? roundToDivisor(packet.duration, encoderConfig.sampleRate) : void 0
               });
+              if (isFirefox()) {
+                opusPreSkip = 0;
+              }
               this.encodingConfig.onEncodedPacket?.(packet, meta);
               this.lastMuxerPromise = this.muxer.addEncodedAudioPacket(this.source._connectedTrack, packet, meta).catch((error) => {
                 this.setError(error);
@@ -37787,6 +38399,9 @@ ${cue.notes ?? ""}`;
             }
           });
           this.encoder.configure(encoderConfig);
+          if (this.encodingConfig.codec === "aac" && isWebKit()) {
+            encodeAacSilencePrefix(this.encoder, numberOfChannels, sampleRate, timestamp);
+          }
         }
         assert(this.source._connectedTrack);
         this.muxer = this.source._connectedTrack.output._muxer;
@@ -37941,6 +38556,138 @@ ${cue.notes ?? ""}`;
       }
     }
   };
+  var audioEncoderPrimingShiftPromises = /* @__PURE__ */ new Map();
+  var detectAudioEncoderPrimingShift = (codec, codecString) => {
+    let promise = audioEncoderPrimingShiftPromises.get(codecString);
+    if (promise) {
+      return promise;
+    }
+    promise = (async () => {
+      const numberOfChannels = 1;
+      const sampleRate = 48e3;
+      const encoderConfig = {
+        codec: codecString,
+        numberOfChannels,
+        sampleRate,
+        ...getAudioEncoderConfigExtension(codec)
+      };
+      const impulseIndex = 4096;
+      const numberOfFrames = 2 * impulseIndex;
+      const chunks = [];
+      let decoderConfig = null;
+      let peakIndex = null;
+      let peakValue = -Infinity;
+      let decodedFrames = 0;
+      let codecError = null;
+      const encoder = new AudioEncoder({
+        output: (chunk, meta) => {
+          if (meta?.decoderConfig) {
+            decoderConfig ??= meta.decoderConfig;
+          }
+          chunks.push(chunk);
+        },
+        error: (error) => {
+          codecError ??= error;
+        }
+      });
+      const decoder = new AudioDecoder({
+        output: (audioData) => {
+          const values = new Float32Array(audioData.numberOfFrames);
+          audioData.copyTo(values, { planeIndex: 0, format: "f32-planar" });
+          audioData.close();
+          for (let i = 0; i < values.length; i++) {
+            if (values[i] > peakValue) {
+              peakValue = values[i];
+              peakIndex = decodedFrames + i;
+            }
+          }
+          decodedFrames += values.length;
+        },
+        error: (error) => {
+          codecError ??= error;
+        }
+      });
+      try {
+        encoder.configure(encoderConfig);
+        if (codec === "aac" && isWebKit()) {
+          encodeAacSilencePrefix(encoder, numberOfChannels, sampleRate, 0);
+        }
+        const data = new Float32Array(numberOfChannels * numberOfFrames);
+        data[impulseIndex] = 1;
+        const audioData = new AudioData({
+          data,
+          format: "f32-planar",
+          numberOfChannels,
+          numberOfFrames,
+          sampleRate,
+          timestamp: 0
+        });
+        encoder.encode(audioData);
+        audioData.close();
+        await encoder.flush();
+        assert(decoderConfig);
+        fixAudioDecoderConfig(codec, encoderConfig, decoderConfig);
+        decoder.configure(decoderConfig);
+        for (const chunk of chunks) {
+          decoder.decode(chunk);
+        }
+        await decoder.flush();
+      } catch (error) {
+        throw codecError ?? error;
+      } finally {
+        if (encoder.state !== "closed") {
+          encoder.close();
+        }
+        if (decoder.state !== "closed") {
+          decoder.close();
+        }
+      }
+      assert(peakIndex !== null);
+      const firstChunkTimestampInSamples = Math.round(chunks[0].timestamp / 1e6 * sampleRate);
+      return peakIndex - impulseIndex + firstChunkTimestampInSamples;
+    })();
+    audioEncoderPrimingShiftPromises.set(codecString, promise);
+    promise.catch(() => audioEncoderPrimingShiftPromises.delete(codecString));
+    return promise;
+  };
+  var encodeAacSilencePrefix = (encoder, numberOfChannels, sampleRate, timestamp) => {
+    const numberOfFrames = 1024;
+    const audioData = new AudioData({
+      data: new Float32Array(numberOfChannels * numberOfFrames),
+      format: "f32-planar",
+      numberOfChannels,
+      numberOfFrames,
+      sampleRate,
+      timestamp: Math.round(1e6 * (timestamp - numberOfFrames / sampleRate))
+    });
+    encoder.encode(audioData);
+    audioData.close();
+  };
+  var fixAudioDecoderConfig = (codec, encoderConfig, decoderConfig) => {
+    if (codec === "aac") {
+      if (decoderConfig.description && decoderConfig.description.byteLength > 0 && toUint8Array(decoderConfig.description)[0] === 3) {
+        const { decoderSpecificInfo } = readEsDescriptor(
+          FileSlice4.tempFromBytes(toUint8Array(decoderConfig.description))
+        );
+        decoderConfig.description = decoderSpecificInfo ?? void 0;
+      }
+      let needsDescriptionOverwrite = false;
+      if (!decoderConfig.description || decoderConfig.description.byteLength < 2) {
+        needsDescriptionOverwrite = true;
+      } else {
+        const audioSpecificConfig = parseAacAudioSpecificConfig(toUint8Array(decoderConfig.description));
+        needsDescriptionOverwrite = audioSpecificConfig.objectType === 0;
+      }
+      if (needsDescriptionOverwrite) {
+        const objectType = Number(last(encoderConfig.codec.split(".")));
+        decoderConfig.description = buildAacAudioSpecificConfig({
+          objectType,
+          outputNumberOfChannels: decoderConfig.numberOfChannels,
+          outputSampleRate: decoderConfig.sampleRate
+        });
+      }
+    }
+  };
   var AudioSampleSource = class extends AudioSource {
     /**
      * Creates a new {@link AudioSampleSource} whose samples are encoded according to the specified
@@ -38365,6 +39112,7 @@ ${cue.notes ?? ""}`;
       }
       super(output);
       this.trackDatas = [];
+      this.firstPacketTimestamp = null;
       this.isRelativeToUnixEpoch = false;
       this.numWrittenMasterPlaylists = 0;
       this.playlists = [];
@@ -38374,6 +39122,7 @@ ${cue.notes ?? ""}`;
       this.singleFilePerPlaylist = format._options.singleFilePerPlaylist ?? false;
       this.isLive = format._options.live ?? false;
       this.maxLiveSegmentCount = format._options.maxLiveSegmentCount ?? Infinity;
+      this.mediaTimestampBase = format._options.mediaTimestampBase ?? 10;
       this.globalTargetDuration = this.targetSegmentDuration;
       this.getPlaylistPath = format._options.getPlaylistPath ?? (({ n }) => `playlist-${n}.m3u8`);
       this.getSegmentPath = format._options.getSegmentPath ?? ((info) => info.isSingleFile ? `segments-${info.playlist.n}${info.format.fileExtension}` : `segment-${info.playlist.n}-${info.n}${info.format.fileExtension}`);
@@ -38745,6 +39494,7 @@ ${cue.notes ?? ""}`;
       try {
         this.validateTimestamp(track, packet.timestamp, packet.type === "key");
         trackData.packets.push(packet);
+        this.firstPacketTimestamp ??= packet.timestamp;
         if (playlist.currentSegmentStartTimestamp === null) {
           playlist.currentSegmentStartTimestamp = packet.timestamp;
         } else if (!playlist.currentSegmentStartTimestampIsFixed) {
@@ -38765,6 +39515,7 @@ ${cue.notes ?? ""}`;
       try {
         this.validateTimestamp(track, packet.timestamp, packet.type === "key");
         trackData.packets.push(packet);
+        this.firstPacketTimestamp ??= packet.timestamp;
         if (playlist.currentSegmentStartTimestamp === null) {
           playlist.currentSegmentStartTimestamp = packet.timestamp;
         } else if (!playlist.currentSegmentStartTimestampIsFixed) {
@@ -39100,6 +39851,16 @@ ${cue.notes ?? ""}`;
                 decoderConfig: audioTrack.info.decoderConfig,
                 primingPacket: audioTrack.info.primingPacket ?? void 0
               });
+              if (!playlist.segmentFormat.supportsTimestampedMediaData && audioEndIndex > 0) {
+                const firstTimestamp = this.toMediaTimestamp(audioTrack.packets[0].timestamp);
+                const pts = secondsToMpegTsTimestamp(firstTimestamp);
+                const priv = new Uint8Array(TIMESTAMP_PRIV_OWNER.length + 1 + 8);
+                priv.set(textEncoder.encode(TIMESTAMP_PRIV_OWNER), 0);
+                const view2 = toDataView(priv);
+                view2.setUint32(TIMESTAMP_PRIV_OWNER.length + 1, Math.floor(pts / 2 ** 32));
+                view2.setUint32(TIMESTAMP_PRIV_OWNER.length + 5, pts % 2 ** 32);
+                output.setMetadataTags({ raw: { PRIV: priv } });
+              }
             }
             await output.start();
           }
@@ -39108,7 +39869,10 @@ ${cue.notes ?? ""}`;
             const meta = { decoderConfig: videoTrack.info.decoderConfig };
             for (let i = 0; i < videoEndIndex; i++) {
               const packet = videoTrack.packets[i];
-              await videoSource.add(packet, meta);
+              const offsetPacket = packet.clone({
+                timestamp: this.toMediaTimestamp(packet.timestamp)
+              });
+              await videoSource.add(offsetPacket, meta);
               maxEndTimestamp = Math.max(maxEndTimestamp, packet.timestamp + packet.duration);
             }
           }
@@ -39117,7 +39881,10 @@ ${cue.notes ?? ""}`;
             const meta = { decoderConfig: audioTrack.info.decoderConfig };
             for (let i = 0; i < audioEndIndex; i++) {
               const packet = audioTrack.packets[i];
-              await audioSource.add(packet, meta);
+              const offsetPacket = packet.clone({
+                timestamp: this.toMediaTimestamp(packet.timestamp)
+              });
+              await audioSource.add(offsetPacket, meta);
               maxEndTimestamp = Math.max(maxEndTimestamp, packet.timestamp + packet.duration);
             }
           }
@@ -39194,6 +39961,10 @@ ${cue.notes ?? ""}`;
         }
       }
     }
+    toMediaTimestamp(timestamp) {
+      assert(this.firstPacketTimestamp !== null);
+      return timestamp - this.firstPacketTimestamp + this.mediaTimestampBase;
+    }
     async onPlaylistDone(playlist) {
       assert(!playlist.done);
       playlist.done = true;
@@ -40078,6 +40849,9 @@ ${cue.notes ?? ""}`;
       if (!options || typeof options !== "object") {
         throw new TypeError("options must be an object.");
       }
+      if (options.timestampOffset !== void 0 && (!Number.isFinite(options.timestampOffset) || options.timestampOffset < 0)) {
+        throw new TypeError("options.timestampOffset, when provided, must be a non-negative number.");
+      }
       if (options.onPacket !== void 0 && typeof options.onPacket !== "function") {
         throw new TypeError("options.onPacket, when provided, must be a function.");
       }
@@ -40148,6 +40922,9 @@ ${cue.notes ?? ""}`;
       if (options.maxLiveSegmentCount !== void 0 && (typeof options.maxLiveSegmentCount !== "number" || options.maxLiveSegmentCount < 1 || Number.isFinite(options.maxLiveSegmentCount) && !Number.isInteger(options.maxLiveSegmentCount))) {
         throw new TypeError("options.maxLiveSegmentCount, when provided, must be a positive integer or Infinity.");
       }
+      if (options.mediaTimestampBase !== void 0 && !Number.isFinite(options.mediaTimestampBase)) {
+        throw new TypeError("options.mediaTimestampBase, when provided, must be a finite number.");
+      }
       if (options.getPlaylistPath !== void 0 && typeof options.getPlaylistPath !== "function") {
         throw new TypeError("options.getPlaylistPath, when provided, must be a function.");
       }
@@ -40191,6 +40968,9 @@ ${cue.notes ?? ""}`;
     }
     getSupportedCodecs() {
       const uniqueCodecs = new Set(toArray(this._options.segmentFormat).flatMap((x) => x.getSupportedCodecs()));
+      for (const codec of AUDIO_CODECS_WITH_DELTA_PACKETS) {
+        uniqueCodecs.delete(codec);
+      }
       return [...uniqueCodecs];
     }
     getSupportedTrackCounts() {
@@ -41786,7 +42566,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
             const tempSource = new VideoSampleSource(encodingConfig);
             tempOutput.addVideoTrack(tempSource);
             await tempOutput.start();
-            const sink = new VideoSampleSink(track);
+            const sink = new VideoSampleSink(track, { hardwareAcceleration: trackOptions.hardwareAcceleration });
             const firstSample = __using(_stack, await sink.getSample(await track.getFirstTimestamp()));
             if (firstSample) {
               try {
@@ -41836,7 +42616,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         const source = new VideoSampleSource(encodingConfig);
         videoSource = source;
         this._registerTrackPump(async (pump) => {
-          const sink = new VideoSampleSink(track);
+          const sink = new VideoSampleSink(track, { hardwareAcceleration: trackOptions.hardwareAcceleration });
           for await (var _sample of sink.samples(this._startTimestamp, this._endTimestamp)) {
             var _stack2 = [];
             try {
@@ -41919,18 +42699,17 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       let copyStartPacket = null;
       if (!needsTranscode) {
         const sink = new EncodedPacketSink(track);
-        let startPacket = await sink.getKeyPacket(this._startTimestamp) ?? await sink.getFirstKeyPacket();
+        let startPacket = await sink.getKeyPacket(this._startTimestamp, { verifyKeyPackets: true }) ?? await sink.getFirstKeyPacket({ verifyKeyPackets: true });
         if (startPacket && (this._copyBoundaryPolicy === "shrink" && startPacket.timestamp < this._startTimestamp || this._copyBoundaryPolicy === "expand" && startPacket.timestamp + startPacket.duration <= this._startTimestamp)) {
-          startPacket = await sink.getNextKeyPacket(startPacket);
+          startPacket = await sink.getNextKeyPacket(startPacket, { verifyKeyPackets: true });
         }
-        const hasDecoderWarmup = NON_PCM_AUDIO_CODECS.includes(sourceCodec) && sourceCodec !== "flac";
-        if (startPacket && this._copyBoundaryPolicy === "expand" && hasDecoderWarmup) {
-          const previousPacket = await sink.getKeyPacket(
-            startPacket.timestamp - 1 / await track.getTimeResolution()
-          );
-          if (previousPacket) {
-            startPacket = previousPacket;
-          }
+        const preRollDuration = await track.getPreRollDuration();
+        assert(preRollDuration !== null);
+        if (startPacket && this._copyBoundaryPolicy === "expand" && preRollDuration > 0) {
+          startPacket = await sink.getKeyPacket(
+            startPacket.timestamp - preRollDuration,
+            { verifyKeyPackets: true }
+          ) ?? await sink.getFirstKeyPacket({ verifyKeyPackets: true });
         }
         copyStartPacket = startPacket;
         if (startPacket) {