mediabunny 1.53.1 → 1.55.0

package/dist/bundles/mediabunny.cjs

@@ -590,6 +590,14 @@ var Mediabunny = (() => {
     }
     return ret;
   };
+  var popcount = (value) => {
+    let count = 0;
+    while (value !== 0) {
+      value &= value - 1;
+      count++;
+    }
+    return count;
+  };
   var ISO_639_2_REGEX = /^[a-z]{3}$/;
   var isIso639Dash2LanguageCode = (x) => {
     return ISO_639_2_REGEX.test(x);
@@ -1528,7 +1536,8 @@ var Mediabunny = (() => {
     "vorbis",
     "flac",
     "ac3",
-    "eac3"
+    "eac3",
+    "dts"
   ];
   var AUDIO_CODECS = [
     ...NON_PCM_AUDIO_CODECS,
@@ -1717,6 +1726,16 @@ var Mediabunny = (() => {
     "apco"
     // ProRes 422 Proxy
   ];
+  var DTS_FOURCCS = [
+    "dtsc",
+    // DTS core
+    "dtsh",
+    // DTS-HD, core plus extension substreams
+    "dtsl",
+    // DTS-HD Lossless, no core
+    "dtse"
+    // DTS Express
+  ];
   var PRORES_PROFILE_TARGET_BITRATES = [
     { fourCc: "apco", bitrate: 45e6, alpha: false },
     // 422 Proxy
@@ -1992,13 +2011,15 @@ var Mediabunny = (() => {
       return "ac-3";
     } else if (codec === "eac3") {
       return "ec-3";
+    } else if (codec === "dts") {
+      return "dtsc";
     } else if (PCM_AUDIO_CODECS.includes(codec)) {
       return codec;
     }
     throw new TypeError(`Unhandled codec '${codec}'.`);
   };
   var extractAudioCodecString = (trackInfo) => {
-    const { codec, codecDescription, aacCodecInfo } = trackInfo;
+    const { codec, codecDescription, aacCodecInfo, dtsFormat } = trackInfo;
     if (codec === "aac") {
       if (!aacCodecInfo) {
         throw new TypeError("AAC codec info must be provided.");
@@ -2027,6 +2048,8 @@ var Mediabunny = (() => {
       return "ac-3";
     } else if (codec === "eac3") {
       return "ec-3";
+    } else if (codec === "dts") {
+      return dtsFormat ?? "dtsc";
     } else if (codec && PCM_AUDIO_CODECS.includes(codec)) {
       return codec;
     }
@@ -2114,6 +2137,8 @@ var Mediabunny = (() => {
       return "ac3";
     } else if (codecString === "ec-3" || codecString === "eac3") {
       return "eac3";
+    } else if (DTS_FOURCCS.includes(codecString)) {
+      return "dts";
     } else if (codecString === "ulaw") {
       return "ulaw";
     } else if (codecString === "alaw") {
@@ -2301,7 +2326,8 @@ var Mediabunny = (() => {
     "alaw",
     "pcm",
     "ac-3",
-    "ec-3"
+    "ec-3",
+    "dts"
   ];
   var validateAudioChunkMetadata = (metadata, trackCodec) => {
     if (!metadata) {
@@ -2390,6 +2416,12 @@ var Mediabunny = (() => {
       if (metadata.decoderConfig.codec !== "ec-3") {
         throw new TypeError('Audio chunk metadata decoder configuration codec string for EC-3 must be "ec-3".');
       }
+    } else if (metadata.decoderConfig.codec.startsWith("dts")) {
+      if (!DTS_FOURCCS.includes(metadata.decoderConfig.codec)) {
+        throw new TypeError(
+          `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("pcm") || metadata.decoderConfig.codec.startsWith("ulaw") || metadata.decoderConfig.codec.startsWith("alaw")) {
       if (!PCM_AUDIO_CODECS.includes(metadata.decoderConfig.codec)) {
         throw new TypeError(
@@ -5059,6 +5091,364 @@ var Mediabunny = (() => {
     }
     return channels;
   };
+  var DTS_EXSS_SYNC_WORD = 1683496997;
+  var DTS_CORE_FRAME_HEADER_SIZE = 18;
+  var DTS_EXSS_HEADER_PREFIX_SIZE = 10;
+  var DTS_EXSS_MAX_HEADER_SIZE = 4096;
+  var DTS_PCM_BLOCK_SAMPLES = 32;
+  var DTS_SPECIFIC_BOX_SIZE = 20;
+  var DTS_SUBBAND_SAMPLES = 8;
+  var DTS_CORE_SAMPLE_RATES = [
+    0,
+    8e3,
+    16e3,
+    32e3,
+    0,
+    0,
+    11025,
+    22050,
+    44100,
+    0,
+    0,
+    12e3,
+    24e3,
+    48e3,
+    96e3,
+    192e3
+  ];
+  var DTS_CORE_BIT_RATES = [
+    32e3,
+    56e3,
+    64e3,
+    96e3,
+    112e3,
+    128e3,
+    192e3,
+    224e3,
+    256e3,
+    32e4,
+    384e3,
+    448e3,
+    512e3,
+    576e3,
+    64e4,
+    768e3,
+    96e4,
+    1024e3,
+    1152e3,
+    128e4,
+    1344e3,
+    1408e3,
+    1411200,
+    1472e3,
+    1536e3,
+    192e4,
+    2048e3,
+    3072e3,
+    384e4,
+    0,
+    0,
+    0
+  ];
+  var DTS_PCM_RESOLUTIONS = [16, 16, 20, 20, 0, 24, 24, 0];
+  var DTS_AMODE_CHANNEL_COUNTS = [1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 6, 6, 6, 7, 8, 8];
+  var DTS_AMODE_CHANNEL_LAYOUTS = [
+    1,
+    2,
+    2,
+    2,
+    2,
+    3,
+    18,
+    19,
+    6,
+    7,
+    518,
+    323,
+    83,
+    519,
+    582,
+    535
+  ];
+  var DTS_CHANNEL_LAYOUT_LFE1 = 8;
+  var DTS_CHANNEL_LAYOUT_PAIR_MASK = 44646;
+  var DTS_EXSS_REF_CLOCKS = [32e3, 44100, 48e3, 0];
+  var DTS_EXSS_SAMPLE_RATES = [
+    8e3,
+    16e3,
+    32e3,
+    64e3,
+    128e3,
+    22050,
+    44100,
+    88200,
+    176400,
+    352800,
+    12e3,
+    24e3,
+    48e3,
+    96e3,
+    192e3,
+    384e3
+  ];
+  var DTS_SPECIFIC_BOX_FRAME_DURATIONS = [512, 1024, 2048, 4096];
+  var parseDtsFrame = (data) => {
+    const core = parseDtsCoreFrameHeader(data);
+    const view2 = toDataView(data);
+    let offset = core ? Math.ceil(core.frameSize / 4) * 4 : 0;
+    let firstExss = null;
+    while (offset + 4 <= data.length && view2.getUint32(offset) === DTS_EXSS_SYNC_WORD) {
+      const exss = parseDtsExssHeader(data.subarray(offset));
+      if (!exss) {
+        break;
+      }
+      firstExss ??= exss;
+      offset += exss.frameSize;
+    }
+    if (core) {
+      return {
+        frameSize: firstExss ? offset : core.frameSize,
+        sampleRate: core.sampleRate,
+        numberOfChannels: core.numberOfChannels,
+        sampleCount: core.sampleCount,
+        channelLayout: core.channelLayout,
+        pcmResolution: core.pcmResolution,
+        bitRate: core.bitRate,
+        core,
+        hasExtensions: firstExss !== null
+      };
+    }
+    if (!firstExss?.asset) {
+      return null;
+    }
+    const { asset } = firstExss;
+    return {
+      frameSize: offset,
+      sampleRate: asset.sampleRate,
+      numberOfChannels: asset.numberOfChannels,
+      sampleCount: asset.sampleCount,
+      channelLayout: asset.channelLayout,
+      pcmResolution: asset.pcmResolution,
+      bitRate: 0,
+      core: null,
+      hasExtensions: true
+    };
+  };
+  var extractDtsFourCcFromPacket = (data) => {
+    const frameInfo = parseDtsFrame(data);
+    if (!frameInfo?.core) {
+      return null;
+    }
+    return frameInfo.hasExtensions ? "dtsh" : "dtsc";
+  };
+  var parseDtsCoreFrameHeader = (data) => {
+    if (data.length < DTS_CORE_FRAME_HEADER_SIZE) {
+      return null;
+    }
+    if (data[0] !== 127 || data[1] !== 254 || data[2] !== 128 || data[3] !== 1) {
+      return null;
+    }
+    const bitstream = new Bitstream(data);
+    bitstream.skipBits(32);
+    bitstream.skipBits(1);
+    if (bitstream.readBits(5) !== DTS_PCM_BLOCK_SAMPLES - 1) {
+      return null;
+    }
+    const cpf = bitstream.readBits(1);
+    const npcmblocks = bitstream.readBits(7) + 1;
+    if (npcmblocks % DTS_SUBBAND_SAMPLES !== 0) {
+      return null;
+    }
+    const frameSize = bitstream.readBits(14) + 1;
+    if (frameSize < 96) {
+      return null;
+    }
+    const amode = bitstream.readBits(6);
+    if (amode >= DTS_AMODE_CHANNEL_COUNTS.length) {
+      return null;
+    }
+    const sampleRate = DTS_CORE_SAMPLE_RATES[bitstream.readBits(4)];
+    if (sampleRate === 0) {
+      return null;
+    }
+    const bitRate = DTS_CORE_BIT_RATES[bitstream.readBits(5)];
+    if (bitstream.readBits(1) !== 0) {
+      return null;
+    }
+    bitstream.skipBits(1 + 1 + 1 + 1);
+    bitstream.skipBits(3 + 1 + 1);
+    const lff = bitstream.readBits(2);
+    if (lff === 3) {
+      return null;
+    }
+    bitstream.skipBits(1);
+    if (cpf) {
+      bitstream.skipBits(16);
+    }
+    bitstream.skipBits(1 + 4 + 2);
+    const pcmResolution = DTS_PCM_RESOLUTIONS[bitstream.readBits(3)];
+    if (pcmResolution === 0) {
+      return null;
+    }
+    const lfePresent = lff !== 0;
+    return {
+      frameSize,
+      sampleRate,
+      numberOfChannels: DTS_AMODE_CHANNEL_COUNTS[amode] + (lfePresent ? 1 : 0),
+      sampleCount: npcmblocks * DTS_PCM_BLOCK_SAMPLES,
+      channelLayout: DTS_AMODE_CHANNEL_LAYOUTS[amode] | (lfePresent ? DTS_CHANNEL_LAYOUT_LFE1 : 0),
+      amode,
+      lfePresent,
+      bitRate,
+      pcmResolution
+    };
+  };
+  var parseDtsExssHeader = (data) => {
+    if (data.length < DTS_EXSS_HEADER_PREFIX_SIZE) {
+      return null;
+    }
+    if (data[0] !== 100 || data[1] !== 88 || data[2] !== 32 || data[3] !== 37) {
+      return null;
+    }
+    const bitstream = new Bitstream(data);
+    bitstream.skipBits(32);
+    bitstream.skipBits(8);
+    const extSsIndex = bitstream.readBits(2);
+    const wideHeader = bitstream.readBits(1);
+    const headerSizeBits = 8 + 4 * wideHeader;
+    const frameSizeBits = 16 + 4 * wideHeader;
+    bitstream.skipBits(headerSizeBits);
+    const frameSize = bitstream.readBits(frameSizeBits) + 1;
+    const incomplete = { frameSize, asset: null };
+    if (!bitstream.readBits(1)) {
+      return incomplete;
+    }
+    const refClock = DTS_EXSS_REF_CLOCKS[bitstream.readBits(2)];
+    const frameDurationCycles = 512 * (bitstream.readBits(3) + 1);
+    if (bitstream.readBits(1)) {
+      bitstream.skipBits(32 + 4);
+    }
+    const numAudioPresentations = bitstream.readBits(3) + 1;
+    const numAssets = bitstream.readBits(3) + 1;
+    const activeExssMasks = [];
+    for (let i = 0; i < numAudioPresentations; i++) {
+      activeExssMasks.push(bitstream.readBits(extSsIndex + 1));
+    }
+    for (const mask of activeExssMasks) {
+      bitstream.skipBits(8 * popcount(mask));
+    }
+    if (bitstream.readBits(1)) {
+      bitstream.skipBits(2);
+      const spkrMaskBits = bitstream.readBits(2) + 1 << 2;
+      const numMixOutConfigs = bitstream.readBits(2) + 1;
+      bitstream.skipBits(numMixOutConfigs * spkrMaskBits);
+    }
+    for (let i = 0; i < numAssets; i++) {
+      bitstream.skipBits(frameSizeBits);
+    }
+    bitstream.skipBits(9);
+    bitstream.skipBits(3);
+    if (bitstream.readBits(1)) {
+      bitstream.skipBits(4);
+    }
+    if (bitstream.readBits(1)) {
+      bitstream.skipBits(24);
+    }
+    if (bitstream.readBits(1)) {
+      bitstream.skipBits(8 * (bitstream.readBits(10) + 1));
+    }
+    const pcmResolution = bitstream.readBits(5) + 1;
+    const sampleRate = DTS_EXSS_SAMPLE_RATES[bitstream.readBits(4)];
+    const numberOfChannels = bitstream.readBits(8) + 1;
+    let channelLayout = 0;
+    if (bitstream.readBits(1)) {
+      if (numberOfChannels > 2) {
+        bitstream.skipBits(1);
+      }
+      if (numberOfChannels > 6) {
+        bitstream.skipBits(1);
+      }
+      if (bitstream.readBits(1)) {
+        const spkrMaskBits = bitstream.readBits(2) + 1 << 2;
+        channelLayout = bitstream.readBits(spkrMaskBits);
+      }
+    }
+    if (refClock === 0 || bitstream.getBitsLeft() < 0) {
+      return incomplete;
+    }
+    return {
+      frameSize,
+      asset: {
+        sampleRate,
+        numberOfChannels,
+        sampleCount: Math.round(frameDurationCycles * sampleRate / refClock),
+        channelLayout,
+        pcmResolution
+      }
+    };
+  };
+  var parseDtsSpecificBox = (data) => {
+    if (data.length < DTS_SPECIFIC_BOX_SIZE) {
+      return null;
+    }
+    const view2 = toDataView(data);
+    const sampleRate = view2.getUint32(0);
+    if (sampleRate === 0) {
+      return null;
+    }
+    const bitstream = new Bitstream(data);
+    bitstream.seekToByte(13);
+    const frameDuration = bitstream.readBits(2);
+    bitstream.skipBits(5);
+    const coreLfePresent = bitstream.readBits(1);
+    const coreLayout = bitstream.readBits(6);
+    bitstream.skipBits(14);
+    bitstream.skipBits(1);
+    bitstream.skipBits(3);
+    const channelLayout = bitstream.readBits(16);
+    let numberOfChannels = null;
+    if (channelLayout !== 0) {
+      numberOfChannels = getDtsChannelCount(channelLayout);
+    } else if (coreLayout < DTS_AMODE_CHANNEL_COUNTS.length) {
+      numberOfChannels = DTS_AMODE_CHANNEL_COUNTS[coreLayout] + coreLfePresent;
+    }
+    return {
+      sampleRate,
+      maxBitrate: view2.getUint32(4),
+      avgBitrate: view2.getUint32(8),
+      pcmSampleDepth: data[12],
+      sampleCount: DTS_SPECIFIC_BOX_FRAME_DURATIONS[frameDuration],
+      channelLayout,
+      numberOfChannels
+    };
+  };
+  var buildDtsSpecificBox = (frameInfo) => {
+    const bytes2 = new Uint8Array(DTS_SPECIFIC_BOX_SIZE);
+    const view2 = toDataView(bytes2);
+    view2.setUint32(0, frameInfo.sampleRate);
+    view2.setUint32(4, frameInfo.bitRate);
+    view2.setUint32(8, frameInfo.bitRate);
+    bytes2[12] = frameInfo.pcmResolution;
+    const streamConstruction = frameInfo.core && !frameInfo.hasExtensions ? 1 : 0;
+    const bitstream = new Bitstream(bytes2);
+    bitstream.seekToByte(13);
+    bitstream.writeBits(2, Math.max(DTS_SPECIFIC_BOX_FRAME_DURATIONS.indexOf(frameInfo.sampleCount), 0));
+    bitstream.writeBits(5, streamConstruction);
+    bitstream.writeBits(1, frameInfo.core?.lfePresent ? 1 : 0);
+    bitstream.writeBits(6, frameInfo.core?.amode ?? 0);
+    bitstream.writeBits(14, frameInfo.core ? frameInfo.core.frameSize - 1 : 0);
+    bitstream.writeBits(1, 0);
+    bitstream.writeBits(3, 0);
+    bitstream.writeBits(16, frameInfo.channelLayout);
+    bitstream.writeBits(1, 0);
+    bitstream.writeBits(1, 0);
+    bitstream.writeBits(1, 0);
+    bitstream.writeBits(5, 0);
+    return bytes2;
+  };
+  var getDtsChannelCount = (channelLayout) => {
+    return popcount(channelLayout) + popcount(channelLayout & DTS_CHANNEL_LAYOUT_PAIR_MASK);
+  };
 
   // src/demuxer.ts
   var Demuxer = class {
@@ -6122,6 +6512,7 @@ var Mediabunny = (() => {
                 codec: null,
                 codecDescription: null,
                 aacCodecInfo: null,
+                dtsFormat: null,
                 pcmLittleEndian: false,
                 pcmSampleSize: null
               };
@@ -6244,6 +6635,9 @@ var Mediabunny = (() => {
                   track.info.codec = "ac3";
                 } else if (codecName === "ec-3") {
                   track.info.codec = "eac3";
+                } else if (DTS_FOURCCS.includes(codecName)) {
+                  track.info.codec = "dts";
+                  track.info.dtsFormat = codecName;
                 } else if (codecName === "twos") {
                   if (sampleSize === 8) {
                     track.info.codec = "pcm-s8";
@@ -6603,6 +6997,8 @@ var Mediabunny = (() => {
               track.info.codec = "mp3";
             } else if (objectTypeIndication === 221) {
               track.info.codec = "vorbis";
+            } else if (objectTypeIndication === 169) {
+              track.info.codec = "dts";
             } else {
               Logging._warn(
                 `Unsupported audio codec (objectTypeIndication ${objectTypeIndication}) - discarding track.`
@@ -6769,6 +7165,26 @@ var Mediabunny = (() => {
           }
           ;
           break;
+        case "ddts":
+          {
+            const track = this.currentTrack;
+            if (!track) {
+              break;
+            }
+            assert(track.info?.type === "audio");
+            const bytes2 = readBytes(slice, Math.min(boxInfo.contentSize, DTS_SPECIFIC_BOX_SIZE));
+            const config = parseDtsSpecificBox(bytes2);
+            if (!config) {
+              Logging._warn("Invalid ddts box contents, ignoring.");
+              break;
+            }
+            track.info.sampleRate = config.sampleRate;
+            if (config.numberOfChannels !== null) {
+              track.info.numberOfChannels = config.numberOfChannels;
+            }
+          }
+          ;
+          break;
         case "stts":
           {
             const track = this.currentTrack;
@@ -8184,7 +8600,7 @@ var Mediabunny = (() => {
   var IsobmffAudioTrackBacking = class extends IsobmffTrackBacking {
     constructor(internalTrack) {
       super(internalTrack);
-      this.decoderConfig = null;
+      this.decoderConfigPromise = null;
       this.internalTrack = internalTrack;
     }
     getType() {
@@ -8203,12 +8619,18 @@ var Mediabunny = (() => {
       if (!this.internalTrack.info.codec) {
         return null;
       }
-      return this.decoderConfig ??= {
-        codec: extractAudioCodecString(this.internalTrack.info),
-        numberOfChannels: this.internalTrack.info.numberOfChannels,
-        sampleRate: this.internalTrack.info.sampleRate,
-        description: this.internalTrack.info.codecDescription ?? void 0
-      };
+      return this.decoderConfigPromise ??= (async () => {
+        if (this.internalTrack.info.codec === "dts" && !this.internalTrack.info.dtsFormat) {
+          const firstPacket = await this.getFirstPacket({});
+          this.internalTrack.info.dtsFormat = firstPacket && extractDtsFourCcFromPacket(firstPacket.data);
+        }
+        return {
+          codec: extractAudioCodecString(this.internalTrack.info),
+          numberOfChannels: this.internalTrack.info.numberOfChannels,
+          sampleRate: this.internalTrack.info.sampleRate,
+          description: this.internalTrack.info.codecDescription ?? void 0
+        };
+      })();
     }
   };
   var getSampleIndexForTimestamp = (sampleTable, timescaleUnits) => {
@@ -9055,6 +9477,7 @@ var Mediabunny = (() => {
     "flac": "A_FLAC",
     "ac3": "A_AC3",
     "eac3": "A_EAC3",
+    "dts": "A_DTS",
     "pcm-u8": "A_PCM/INT/LIT",
     "pcm-s16": "A_PCM/INT/LIT",
     "pcm-s16be": "A_PCM/INT/BIG",
@@ -9749,6 +10172,13 @@ var Mediabunny = (() => {
                 } else if (codecIdWithoutSuffix === CODEC_STRING_MAP.eac3) {
                   this.currentTrack.info.codec = "eac3";
                   this.currentTrack.info.codecDescription = this.currentTrack.codecPrivate;
+                } else if (codecIdWithoutSuffix === CODEC_STRING_MAP.dts) {
+                  this.currentTrack.info.codec = "dts";
+                  if (this.currentTrack.codecId === "A_DTS/EXPRESS") {
+                    this.currentTrack.info.dtsFormat = "dtse";
+                  } else if (this.currentTrack.codecId === "A_DTS/LOSSLESS") {
+                    this.currentTrack.info.dtsFormat = "dtsl";
+                  }
                 } else if (this.currentTrack.codecId === "A_PCM/INT/LIT") {
                   if (this.currentTrack.info.bitDepth === 8) {
                     this.currentTrack.info.codec = "pcm-u8";
@@ -9823,7 +10253,8 @@ var Mediabunny = (() => {
                 bitDepth: -1,
                 codec: null,
                 codecDescription: null,
-                aacCodecInfo: null
+                aacCodecInfo: null,
+                dtsFormat: null
               };
             }
           }
@@ -11056,7 +11487,7 @@ var Mediabunny = (() => {
   var MatroskaAudioTrackBacking = class extends MatroskaTrackBacking {
     constructor(internalTrack) {
       super(internalTrack);
-      this.decoderConfig = null;
+      this.decoderConfigPromise = null;
       this.internalTrack = internalTrack;
     }
     getType() {
@@ -11075,16 +11506,23 @@ var Mediabunny = (() => {
       if (!this.internalTrack.info.codec) {
         return null;
       }
-      return this.decoderConfig ??= {
-        codec: extractAudioCodecString({
-          codec: this.internalTrack.info.codec,
-          codecDescription: this.internalTrack.info.codecDescription,
-          aacCodecInfo: this.internalTrack.info.aacCodecInfo
-        }),
-        numberOfChannels: this.internalTrack.info.numberOfChannels,
-        sampleRate: this.internalTrack.info.sampleRate,
-        description: this.internalTrack.info.codecDescription ?? void 0
-      };
+      return this.decoderConfigPromise ??= (async () => {
+        if (this.internalTrack.info.codec === "dts" && !this.internalTrack.info.dtsFormat) {
+          const firstPacket = await this.getFirstPacket({});
+          this.internalTrack.info.dtsFormat = firstPacket && extractDtsFourCcFromPacket(firstPacket.data);
+        }
+        return {
+          codec: extractAudioCodecString({
+            codec: this.internalTrack.info.codec,
+            codecDescription: this.internalTrack.info.codecDescription,
+            aacCodecInfo: this.internalTrack.info.aacCodecInfo,
+            dtsFormat: this.internalTrack.info.dtsFormat
+          }),
+          numberOfChannels: this.internalTrack.info.numberOfChannels,
+          sampleRate: this.internalTrack.info.sampleRate,
+          description: this.internalTrack.info.codecDescription ?? void 0
+        };
+      })();
     }
   };
 
@@ -13737,6 +14175,15 @@ var Mediabunny = (() => {
 
   // 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.";
+  var REGISTRATION_DESCRIPTOR_TAG = 5;
+  var HDMV_FORMAT_IDENTIFIER = 1212435798;
+  var HDPR_FORMAT_IDENTIFIER = 1212436562;
+  var DTS_FORMAT_IDENTIFIER_PREFIX = 1146376960;
+  var BLU_RAY_DTS_STREAM_TYPES = /* @__PURE__ */ new Set([
+    133 /* BLU_RAY_DTS_HD */,
+    134 /* BLU_RAY_DTS_HD_MASTER */,
+    162 /* BLU_RAY_DTS_EXPRESS_SECONDARY */
+  ]);
   var ignoredStreamTypes = /* @__PURE__ */ new Set();
   var MpegTsDemuxer = class extends Demuxer {
     constructor(input) {
@@ -13845,7 +14292,19 @@ var Mediabunny = (() => {
             const pcrPid = bitstream.readBits(13);
             bitstream.skipBits(6);
             const programInfoLength = bitstream.readBits(10);
-            bitstream.skipBits(8 * programInfoLength);
+            const programInfoEndPos = bitstream.pos + 8 * programInfoLength;
+            let isBluRayProgram = false;
+            while (bitstream.pos < programInfoEndPos) {
+              const descriptorTag = bitstream.readBits(8);
+              const descriptorLength = bitstream.readBits(8);
+              const descriptorEndPos = bitstream.pos + 8 * descriptorLength;
+              if (descriptorTag === REGISTRATION_DESCRIPTOR_TAG && descriptorLength >= 4) {
+                const formatIdentifier = bitstream.readBits(32);
+                isBluRayProgram ||= formatIdentifier === HDMV_FORMAT_IDENTIFIER || formatIdentifier === HDPR_FORMAT_IDENTIFIER;
+              }
+              bitstream.pos = descriptorEndPos;
+            }
+            bitstream.pos = programInfoEndPos;
             while (8 * (sectionLength + BYTES_BEFORE_SECTION_LENGTH) - bitstream.pos > BITS_IN_CRC_32) {
               const streamType = bitstream.readBits(8);
               bitstream.skipBits(3);
@@ -13855,18 +14314,26 @@ var Mediabunny = (() => {
               const esInfoEndPos = bitstream.pos + 8 * esInfoLength;
               let hasAc3Descriptor = false;
               let hasEac3Descriptor = false;
+              let hasDtsDescriptor = false;
               while (bitstream.pos < esInfoEndPos) {
                 const descriptorTag = bitstream.readBits(8);
                 const descriptorLength = bitstream.readBits(8);
+                const descriptorEndPos = bitstream.pos + 8 * descriptorLength;
                 if (descriptorTag === 106) {
                   hasAc3Descriptor = true;
                 } else if (descriptorTag === 122 || descriptorTag === 204) {
                   hasEac3Descriptor = true;
+                } else if (descriptorTag === 123) {
+                  hasDtsDescriptor = true;
+                } else if (descriptorTag === REGISTRATION_DESCRIPTOR_TAG && descriptorLength >= 4) {
+                  const formatIdentifier = bitstream.readBits(32);
+                  hasDtsDescriptor ||= (formatIdentifier & 4294967040) === DTS_FORMAT_IDENTIFIER_PREFIX;
                 }
-                bitstream.skipBits(8 * descriptorLength);
+                bitstream.pos = descriptorEndPos;
               }
               let info = null;
-              switch (streamType) {
+              const effectiveStreamType = isBluRayProgram && BLU_RAY_DTS_STREAM_TYPES.has(streamType) ? 130 /* DTS */ : streamType;
+              switch (effectiveStreamType) {
                 case 27 /* AVC */:
                 case 36 /* HEVC */:
                   {
@@ -13897,24 +14364,27 @@ var Mediabunny = (() => {
                 case 15 /* AAC */:
                 case 129 /* AC3_SYSTEM_A */:
                 case 135 /* EAC3_SYSTEM_A */:
+                case 130 /* DTS */:
+                case 138 /* DTS_ATSC */:
                   {
                     let codec;
-                    if (streamType === 3 /* MP3_MPEG1 */ || streamType === 4 /* MP3_MPEG2 */) {
+                    if (effectiveStreamType === 3 /* MP3_MPEG1 */ || effectiveStreamType === 4 /* MP3_MPEG2 */) {
                       codec = "mp3";
-                    } else if (streamType === 15 /* AAC */) {
+                    } else if (effectiveStreamType === 15 /* AAC */) {
                       codec = "aac";
-                    } else if (streamType === 129 /* AC3_SYSTEM_A */) {
+                    } else if (effectiveStreamType === 129 /* AC3_SYSTEM_A */) {
                       codec = "ac3";
-                    } else if (streamType === 135 /* EAC3_SYSTEM_A */) {
+                    } else if (effectiveStreamType === 135 /* EAC3_SYSTEM_A */) {
                       codec = "eac3";
                     } else {
-                      throw new Error("Unreachable.");
+                      codec = "dts";
                     }
                     info = {
                       type: "audio",
                       codec,
                       decoderConfig: null,
                       aacCodecInfo: null,
+                      dtsFormat: null,
                       numberOfChannels: -1,
                       sampleRate: -1
                     };
@@ -13929,6 +14399,7 @@ var Mediabunny = (() => {
                         codec: "eac3",
                         decoderConfig: null,
                         aacCodecInfo: null,
+                        dtsFormat: null,
                         numberOfChannels: -1,
                         sampleRate: -1
                       };
@@ -13938,6 +14409,17 @@ var Mediabunny = (() => {
                         codec: "ac3",
                         decoderConfig: null,
                         aacCodecInfo: null,
+                        dtsFormat: null,
+                        numberOfChannels: -1,
+                        sampleRate: -1
+                      };
+                    } else if (hasDtsDescriptor) {
+                      info = {
+                        type: "audio",
+                        codec: "dts",
+                        decoderConfig: null,
+                        aacCodecInfo: null,
+                        dtsFormat: null,
                         numberOfChannels: -1,
                         sampleRate: -1
                       };
@@ -14157,6 +14639,18 @@ var Mediabunny = (() => {
                     }
                     elementaryStream.info.numberOfChannels = getEac3ChannelCount(frameInfo);
                     elementaryStream.info.sampleRate = sampleRate;
+                  } else if (elementaryStream.info.codec === "dts") {
+                    const frameInfo = parseDtsFrame(context.suppliedPacket.data);
+                    if (!frameInfo) {
+                      throw new Error(
+                        "Invalid DTS audio stream; could not read frame header from first packet."
+                      );
+                    }
+                    elementaryStream.info.numberOfChannels = frameInfo.numberOfChannels;
+                    elementaryStream.info.sampleRate = frameInfo.sampleRate;
+                    if (frameInfo.core) {
+                      elementaryStream.info.dtsFormat = frameInfo.hasExtensions ? "dtsh" : "dtsc";
+                    }
                   } else {
                     throw new Error("Unhandled.");
                   }
@@ -14164,7 +14658,8 @@ var Mediabunny = (() => {
                     codec: extractAudioCodecString({
                       codec: elementaryStream.info.codec,
                       codecDescription: null,
-                      aacCodecInfo: elementaryStream.info.aacCodecInfo
+                      aacCodecInfo: elementaryStream.info.aacCodecInfo,
+                      dtsFormat: elementaryStream.info.dtsFormat
                     }),
                     numberOfChannels: elementaryStream.info.numberOfChannels,
                     sampleRate: elementaryStream.info.sampleRate
@@ -15312,6 +15807,63 @@ var Mediabunny = (() => {
                 samplesPerFrame * TIMESCALE / elementaryStream.info.sampleRate
               );
               return this.supplyPacket(remaining2, duration);
+            } else if (codec === "dts") {
+              if (byte !== 127 && byte !== 100) {
+                continue;
+              }
+              this.skip(-1);
+              const possibleSyncPos = this.currentPos;
+              let remaining2 = this.ensureBuffered(DTS_CORE_FRAME_HEADER_SIZE);
+              if (remaining2 instanceof Promise) remaining2 = await remaining2;
+              if (remaining2 < DTS_CORE_FRAME_HEADER_SIZE) {
+                return;
+              }
+              const headerBytes = this.readBytes(DTS_CORE_FRAME_HEADER_SIZE);
+              const core = parseDtsCoreFrameHeader(headerBytes);
+              let leadingExss = core ? null : parseDtsExssHeader(headerBytes);
+              if (!core && !leadingExss) {
+                this.seekTo(possibleSyncPos + 1);
+                continue;
+              }
+              if (leadingExss && !leadingExss.asset) {
+                this.seekTo(possibleSyncPos);
+                const headerBound = Math.min(leadingExss.frameSize, DTS_EXSS_MAX_HEADER_SIZE);
+                let remaining3 = this.ensureBuffered(headerBound);
+                if (remaining3 instanceof Promise) remaining3 = await remaining3;
+                leadingExss = parseDtsExssHeader(this.readBytes(remaining3)) ?? leadingExss;
+              }
+              let frameSize = core ? core.frameSize : leadingExss.frameSize;
+              if (core) {
+                let nextSubstreamPos = Math.ceil(core.frameSize / 4) * 4;
+                while (true) {
+                  this.seekTo(possibleSyncPos);
+                  const neededBytes = nextSubstreamPos + DTS_EXSS_HEADER_PREFIX_SIZE;
+                  let remaining3 = this.ensureBuffered(neededBytes);
+                  if (remaining3 instanceof Promise) remaining3 = await remaining3;
+                  if (remaining3 < neededBytes) {
+                    break;
+                  }
+                  this.seekTo(possibleSyncPos + nextSubstreamPos);
+                  const exss = parseDtsExssHeader(this.readBytes(DTS_EXSS_HEADER_PREFIX_SIZE));
+                  if (!exss) {
+                    break;
+                  }
+                  nextSubstreamPos += exss.frameSize;
+                  frameSize = nextSubstreamPos;
+                }
+              }
+              const sampleCount = core?.sampleCount ?? leadingExss.asset?.sampleCount;
+              if (sampleCount === void 0) {
+                this.seekTo(possibleSyncPos + 1);
+                continue;
+              }
+              this.seekTo(possibleSyncPos);
+              remaining2 = this.ensureBuffered(frameSize);
+              if (remaining2 instanceof Promise) remaining2 = await remaining2;
+              const duration = Math.round(
+                sampleCount * TIMESCALE / elementaryStream.info.sampleRate
+              );
+              return this.supplyPacket(remaining2, duration);
             } else {
               throw new Error("Unhandled.");
             }
@@ -21938,8 +22490,10 @@ var Mediabunny = (() => {
         // 64kbps base for Vorbis
         ac3: 384e3,
         // 384kbps base for AC-3
-        eac3: 192e3
+        eac3: 192e3,
         // 192kbps base for E-AC-3
+        dts: 768e3
+        // 768kbps base for DTS
       };
       const baseBitrate = baseRates[codec];
       if (!baseBitrate) {
@@ -22072,7 +22626,7 @@ var Mediabunny = (() => {
       throw new TypeError("bitrate must be a positive integer or a quality.");
     }
     validateVideoEncodingAdditionalOptions(codec, restOptions);
-    const resolvedQuality = resolveQuality(quality, bitrate) ?? new Quality({ bitrate: 1e6 });
+    const resolvedQuality = resolveQuality(quality, bitrate) ?? new Quality("medium");
     let candidates;
     try {
       candidates = buildVideoEncoderConfigs({
@@ -22181,7 +22735,7 @@ var Mediabunny = (() => {
       throw new TypeError("bitrate must be a positive integer.");
     }
     validateAudioEncodingAdditionalOptions(codec, restOptions);
-    const resolvedQuality = resolveQuality(quality, bitrate) ?? new Quality({ bitrate: 128e3 });
+    const resolvedQuality = resolveQuality(quality, bitrate) ?? new Quality("medium");
     const encoderConfig = buildAudioEncoderConfig({
       codec,
       numberOfChannels,
@@ -23312,8 +23866,12 @@ var Mediabunny = (() => {
         void this.customDecoderCallSerializer.call(() => this.customDecoder.close());
       } else {
         assert(this.decoder);
-        this.decoder.close();
-        this.alphaDecoder?.close();
+        if (this.decoder.state !== "closed") {
+          this.decoder.close();
+        }
+        if (this.alphaDecoder && this.alphaDecoder.state !== "closed") {
+          this.alphaDecoder.close();
+        }
         this.colorQueue.forEach((x) => x.close());
         this.colorQueue.length = 0;
         this.alphaQueue.forEach((x) => x?.close());
@@ -23906,7 +24464,9 @@ var Mediabunny = (() => {
         void this.customDecoderCallSerializer.call(() => this.customDecoder.close());
       } else {
         assert(this.decoder);
-        this.decoder.close();
+        if (this.decoder.state !== "closed") {
+          this.decoder.close();
+        }
       }
     }
   };
@@ -24778,6 +25338,100 @@ var Mediabunny = (() => {
       assert(decoderConfig);
       return determineVideoPacketType(codec, decoderConfig, packet.data);
     }
+    /**
+     * Computes frame rate metrics for this video track, i.e. estimates the video's frame rate. Frame rate is never
+     * determined from file metadata (which is unreliable) but is always deduced directly from the actual frame
+     * timestamps.
+     */
+    async computeFrameRateMetrics(options = {}) {
+      if (!options || typeof options !== "object") {
+        throw new TypeError("options must be an object.");
+      }
+      if (options.targetPacketCount !== void 0 && (!Number.isFinite(options.targetPacketCount) || options.targetPacketCount < 0)) {
+        throw new TypeError("options.targetPacketCount must be a non-negative number.");
+      }
+      const timeResolution = await this.getTimeResolution();
+      const targetPacketCount = options.targetPacketCount ?? 256;
+      const sink = new EncodedPacketSink(this);
+      const timestamps = [];
+      let maxTimestamp = -Infinity;
+      let probedPacketCount = 0;
+      for await (const packet of sink.packets(void 0, void 0, { metadataOnly: true })) {
+        if (timestamps.length >= targetPacketCount && packet.timestamp >= maxTimestamp) {
+          break;
+        }
+        timestamps.push(packet.timestamp);
+        maxTimestamp = Math.max(maxTimestamp, packet.timestamp);
+        probedPacketCount++;
+      }
+      const ticks = new Float64Array(timestamps.length);
+      for (let i = 0; i < timestamps.length; i++) {
+        ticks[i] = Math.round(timestamps[i] * timeResolution);
+      }
+      ticks.sort();
+      let n = 1;
+      for (let i = 1; i < ticks.length; i++) {
+        if (ticks[i] !== ticks[n - 1]) {
+          ticks[n++] = ticks[i];
+        }
+      }
+      if (n < 2) {
+        return {
+          underlyingFrameRate: null,
+          bestGuessFrameRate: timeResolution,
+          minFrameRate: timeResolution,
+          maxFrameRate: timeResolution,
+          averageFrameRate: timeResolution,
+          medianFrameRate: timeResolution,
+          frameRateIsConstant: true,
+          probedPacketCount
+        };
+      }
+      const activeTicks = ticks.subarray(0, n);
+      const underlyingFrameRate = findUnderlyingFrameRate(activeTicks, timeResolution);
+      const unitRate = underlyingFrameRate ?? timeResolution;
+      const ticksPerFrame = underlyingFrameRate !== null ? timeResolution / underlyingFrameRate : null;
+      const histogram = /* @__PURE__ */ new Map();
+      let minDifference = Infinity;
+      let maxDifference = -Infinity;
+      let totalDifference = 0;
+      for (let i = 1; i < n; i++) {
+        const tickDifference = activeTicks[i] - activeTicks[i - 1];
+        const difference = ticksPerFrame !== null ? Math.max(1, Math.round(tickDifference / ticksPerFrame)) : tickDifference;
+        histogram.set(difference, (histogram.get(difference) ?? 0) + 1);
+        minDifference = Math.min(minDifference, difference);
+        maxDifference = Math.max(maxDifference, difference);
+        totalDifference += difference;
+      }
+      const differenceCount = n - 1;
+      const sortedDifferences = [...histogram.keys()].sort((a, b) => a - b);
+      const middleA = differenceCount - 1 >> 1;
+      const middleB = differenceCount >> 1;
+      let medianDifferenceA = 0;
+      let medianDifferenceB = 0;
+      let cumulativeCount = 0;
+      for (const difference of sortedDifferences) {
+        cumulativeCount += histogram.get(difference);
+        if (medianDifferenceA === 0 && cumulativeCount > middleA) {
+          medianDifferenceA = difference;
+        }
+        if (cumulativeCount > middleB) {
+          medianDifferenceB = difference;
+          break;
+        }
+      }
+      const medianFrameRate = (unitRate / medianDifferenceA + unitRate / medianDifferenceB) / 2;
+      return {
+        underlyingFrameRate,
+        bestGuessFrameRate: underlyingFrameRate !== null ? underlyingFrameRate : getBestGuessFrameRate(medianFrameRate),
+        minFrameRate: unitRate / maxDifference,
+        maxFrameRate: unitRate / minDifference,
+        averageFrameRate: unitRate * differenceCount / totalDifference,
+        medianFrameRate,
+        frameRateIsConstant: underlyingFrameRate !== null && minDifference === 1 && maxDifference === 1,
+        probedPacketCount
+      };
+    }
   };
   var InputAudioTrack = class extends InputTrack {
     /** @internal */
@@ -24995,6 +25649,183 @@ var Mediabunny = (() => {
       return 0;
     }).map((x) => x.track);
   };
+  var findUnderlyingFrameRate = (ticks, resolution) => {
+    const MAX_DENOMINATOR = 1e6;
+    const MIN_INLIER_RATIO = 0.98;
+    const DELTA_TOLERANCE = 1 + 1e-9;
+    const MAX_EFFECTIVE_FRAME_SPAN = 1e3;
+    const KNOWN_FRAME_RATES = [
+      12,
+      15,
+      20,
+      24e3 / 1001,
+      24,
+      25,
+      3e4 / 1001,
+      30,
+      48,
+      50,
+      6e4 / 1001,
+      60,
+      100,
+      12e4 / 1001,
+      120,
+      144,
+      240
+    ];
+    if (ticks.length < 2) {
+      return null;
+    }
+    const gaps = new Float64Array(ticks.length - 1);
+    for (let i = 1; i < ticks.length; i++) {
+      const gap = ticks[i] - ticks[i - 1];
+      if (!(gap > 0)) {
+        return null;
+      }
+      gaps[i - 1] = gap;
+    }
+    const sortedGaps = gaps.slice();
+    sortedGaps.sort();
+    let period = sortedGaps[Math.floor(sortedGaps.length * 0.05)];
+    for (let iteration = 0; iteration < 6; iteration++) {
+      let totalTicks2 = 0;
+      let totalFrames2 = 0;
+      for (const gap of gaps) {
+        const multiple = Math.max(1, Math.round(gap / period));
+        if (Math.abs(gap - multiple * period) >= DELTA_TOLERANCE) {
+          continue;
+        }
+        totalTicks2 += gap;
+        totalFrames2 += multiple;
+      }
+      if (totalFrames2 === 0) {
+        return null;
+      }
+      const refinedPeriod = totalTicks2 / totalFrames2;
+      if (Math.abs(refinedPeriod - period) <= 1e-12 * Math.max(1, period)) {
+        period = refinedPeriod;
+        break;
+      }
+      period = refinedPeriod;
+    }
+    let inlierCount = 0;
+    let totalTicks = 0;
+    let totalFrames = 0;
+    for (const gap of gaps) {
+      const multiple = Math.max(1, Math.round(gap / period));
+      if (Math.abs(gap - multiple * period) >= DELTA_TOLERANCE) {
+        continue;
+      }
+      inlierCount++;
+      totalTicks += gap;
+      totalFrames += multiple;
+    }
+    if (inlierCount / gaps.length < MIN_INLIER_RATIO) {
+      return null;
+    }
+    period = totalTicks / totalFrames;
+    const uncertainty = 1 / Math.min(
+      totalFrames,
+      MAX_EFFECTIVE_FRAME_SPAN
+    );
+    const periodLo = Math.max(Number.EPSILON, period - uncertainty);
+    const periodHi = period + uncertainty;
+    const fpsLo = resolution / periodHi;
+    const fpsHi = resolution / periodLo;
+    const fittedFps = resolution / period;
+    let fps = null;
+    let bestKnownError = Infinity;
+    for (const candidate of KNOWN_FRAME_RATES) {
+      if (candidate < fpsLo || candidate > fpsHi) {
+        continue;
+      }
+      const error = Math.abs(candidate / fittedFps - 1);
+      if (error < bestKnownError) {
+        fps = candidate;
+        bestKnownError = error;
+      }
+    }
+    if (fps === null) {
+      const periodFraction = simplestFractionBetween(
+        periodLo,
+        periodHi,
+        MAX_DENOMINATOR
+      );
+      const fpsFraction = simplestFractionBetween(
+        fpsLo,
+        fpsHi,
+        MAX_DENOMINATOR
+      );
+      if (fpsFraction && (!periodFraction || fpsFraction.den < periodFraction.den || fpsFraction.den === periodFraction.den && fpsFraction.num <= periodFraction.num)) {
+        fps = fpsFraction.num / fpsFraction.den;
+      } else if (periodFraction) {
+        fps = resolution * periodFraction.den / periodFraction.num;
+      } else {
+        return null;
+      }
+    }
+    const finalPeriod = resolution / fps;
+    let finalInlierCount = 0;
+    for (const gap of gaps) {
+      const multiple = Math.max(1, Math.round(gap / finalPeriod));
+      if (Math.abs(gap - multiple * finalPeriod) < DELTA_TOLERANCE) {
+        finalInlierCount++;
+      }
+    }
+    if (finalInlierCount / gaps.length < MIN_INLIER_RATIO) {
+      return null;
+    }
+    return fps;
+  };
+  var simplestFractionBetween = (lo, hi, maxDenominator) => {
+    for (let den = 1; den <= maxDenominator; den++) {
+      const num = Math.floor(lo * den) + 1;
+      if (num / den < hi) {
+        return simplifyRational({ num, den });
+      }
+    }
+    return null;
+  };
+  var getBestGuessFrameRate = (frameRate) => {
+    const SPECIAL_FRAME_RATES = [
+      24 / 1.001,
+      30 / 1.001,
+      60 / 1.001,
+      120 / 1.001
+    ];
+    const COMMON_FRAME_RATES = [
+      12,
+      15,
+      20,
+      24,
+      25,
+      30,
+      48,
+      50,
+      60,
+      100,
+      120,
+      144,
+      240
+    ];
+    const SPECIAL_TOLERANCE = 5e-4;
+    const COMMON_TOLERANCE = 0.025;
+    for (const candidate of SPECIAL_FRAME_RATES) {
+      if (Math.abs(candidate / frameRate - 1) <= SPECIAL_TOLERANCE) {
+        return candidate;
+      }
+    }
+    let best = frameRate;
+    let bestError = Infinity;
+    for (const candidate of COMMON_FRAME_RATES) {
+      const error = Math.abs(candidate / frameRate - 1);
+      if (error <= COMMON_TOLERANCE && error < bestError) {
+        best = candidate;
+        bestError = error;
+      }
+    }
+    return best;
+  };
 
   // src/input.ts
   polyfillSymbolDispose();
@@ -27597,7 +28428,11 @@ var Mediabunny = (() => {
         trackData
       );
     } else if (trackData.type === "audio") {
-      const boxName = audioCodecToBoxName(trackData.track.source._codec, trackData.muxer.isQuickTime);
+      const boxName = audioCodecToBoxName(
+        trackData.track.source._codec,
+        trackData.info.decoderConfig.codec,
+        trackData.muxer.isQuickTime
+      );
       assert(boxName);
       sampleDescription = soundSampleDescription(
         boxName,
@@ -27887,7 +28722,11 @@ var Mediabunny = (() => {
   };
   var frma = (trackData) => {
     return box("frma", [
-      ascii(audioCodecToBoxName(trackData.track.source._codec, trackData.muxer.isQuickTime))
+      ascii(audioCodecToBoxName(
+        trackData.track.source._codec,
+        trackData.info.decoderConfig.codec,
+        trackData.muxer.isQuickTime
+      ))
     ]);
   };
   var enda = (trackData) => {
@@ -28008,6 +28847,16 @@ var Mediabunny = (() => {
     }
     return box("dec3", [...bytes2]);
   };
+  var ddts = (trackData) => {
+    assert(trackData.info.primingPacket);
+    const frameInfo = parseDtsFrame(trackData.info.primingPacket.data);
+    if (!frameInfo) {
+      throw new Error(
+        "Couldn't extract DTS frame info from the audio packet. Ensure the packets contain valid DTS frames as specified in ETSI TS 102 114."
+      );
+    }
+    return box("ddts", [...buildDtsSpecificBox(frameInfo)]);
+  };
   var subtitleSampleDescription = (compressionType, trackData) => box(compressionType, [
     Array(6).fill(0),
     // Reserved
@@ -28659,7 +29508,7 @@ var Mediabunny = (() => {
     av1: av1C,
     prores: null
   };
-  var audioCodecToBoxName = (codec, isQuickTime) => {
+  var audioCodecToBoxName = (codec, fullCodecString, isQuickTime) => {
     switch (codec) {
       case "aac":
         return "mp4a";
@@ -28683,6 +29532,8 @@ var Mediabunny = (() => {
         return "ac-3";
       case "eac3":
         return "ec-3";
+      case "dts":
+        return fullCodecString;
     }
     if (isQuickTime) {
       switch (codec) {
@@ -28748,6 +29599,8 @@ var Mediabunny = (() => {
         return dac3;
       case "eac3":
         return dec3;
+      case "dts":
+        return ddts;
     }
     if (isQuickTime) {
       switch (codec) {
@@ -29699,10 +30552,13 @@ var Mediabunny = (() => {
         });
         requiresAdtsStripping = true;
       }
-      if (track.source._codec === "ac3" || track.source._codec === "eac3") {
-        if (!packet) {
+      if (!packet) {
+        if (track.source._codec === "ac3" || track.source._codec === "eac3") {
           throw new Error("AC-3/E-AC-3 require a priming packet.");
         }
+        if (track.source._codec === "dts") {
+          throw new Error("DTS requires a priming packet.");
+        }
       }
       const newTrackData = {
         muxer: this,
@@ -30679,8 +31535,15 @@ var Mediabunny = (() => {
       const tracksElement = { id: 374648427 /* Tracks */, data: [] };
       this.tracksElement = tracksElement;
       for (const trackData of this.trackDatas) {
-        const codecId = CODEC_STRING_MAP[trackData.track.source._codec];
+        let codecId = CODEC_STRING_MAP[trackData.track.source._codec];
         assert(codecId);
+        if (trackData.type === "audio" && trackData.track.source._codec === "dts") {
+          if (trackData.info.decoderConfig.codec === "dtse") {
+            codecId = "A_DTS/EXPRESS";
+          } else if (trackData.info.decoderConfig.codec === "dtsl") {
+            codecId = "A_DTS/LOSSLESS";
+          }
+        }
         let seekPreRollNs = 0;
         if (trackData.type === "audio" && trackData.track.source._codec === "opus") {
           seekPreRollNs = 1e6 * 80;
@@ -32186,7 +33049,7 @@ ${cue.notes ?? ""}`;
       validateAudioChunkMetadata(meta, track.source._codec);
       assert(meta?.decoderConfig);
       const codec = track.source._codec;
-      assert(codec === "aac" || codec === "mp3" || codec === "ac3" || codec === "eac3");
+      assert(codec === "aac" || codec === "mp3" || codec === "ac3" || codec === "eac3" || codec === "dts");
       let streamType;
       let streamId;
       switch (codec) {
@@ -32218,6 +33081,13 @@ ${cue.notes ?? ""}`;
           }
           ;
           break;
+        case "dts":
+          {
+            streamType = 130 /* DTS */;
+            streamId = 189;
+          }
+          ;
+          break;
       }
       const pid = FIRST_TRACK_PID + this.trackDatas.length;
       const newTrackData = {
@@ -32376,7 +33246,7 @@ ${cue.notes ?? ""}`;
     }
     prepareAudioPacket(trackData, packet, meta) {
       const codec = trackData.track.source._codec;
-      if (codec === "mp3" || codec === "ac3" || codec === "eac3") {
+      if (codec === "mp3" || codec === "ac3" || codec === "eac3" || codec === "dts") {
         return packet.data;
       }
       if (trackData.inputIsAdts === null) {
@@ -37023,7 +37893,7 @@ ${cue.notes ?? ""}`;
     getSupportedCodecs() {
       return [
         ...VIDEO_CODECS.filter((codec) => ["avc", "hevc"].includes(codec)),
-        ...AUDIO_CODECS.filter((codec) => ["aac", "mp3", "ac3", "eac3"].includes(codec))
+        ...AUDIO_CODECS.filter((codec) => ["aac", "mp3", "ac3", "eac3", "dts"].includes(codec))
       ];
     }
     get supportsVideoRotationMetadata() {