mediabunny 1.54.0 → 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();
+        }
       }
     }
   };
@@ -27868,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,
@@ -28158,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) => {
@@ -28279,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
@@ -28930,7 +29508,7 @@ var Mediabunny = (() => {
     av1: av1C,
     prores: null
   };
-  var audioCodecToBoxName = (codec, isQuickTime) => {
+  var audioCodecToBoxName = (codec, fullCodecString, isQuickTime) => {
     switch (codec) {
       case "aac":
         return "mp4a";
@@ -28954,6 +29532,8 @@ var Mediabunny = (() => {
         return "ac-3";
       case "eac3":
         return "ec-3";
+      case "dts":
+        return fullCodecString;
     }
     if (isQuickTime) {
       switch (codec) {
@@ -29019,6 +29599,8 @@ var Mediabunny = (() => {
         return dac3;
       case "eac3":
         return dec3;
+      case "dts":
+        return ddts;
     }
     if (isQuickTime) {
       switch (codec) {
@@ -29970,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,
@@ -30950,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;
@@ -32457,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) {
@@ -32489,6 +33081,13 @@ ${cue.notes ?? ""}`;
           }
           ;
           break;
+        case "dts":
+          {
+            streamType = 130 /* DTS */;
+            streamId = 189;
+          }
+          ;
+          break;
       }
       const pid = FIRST_TRACK_PID + this.trackDatas.length;
       const newTrackData = {
@@ -32647,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) {
@@ -37294,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() {