mediabunny 1.32.2 → 1.33.0

package/dist/bundles/mediabunny.cjs

@@ -937,7 +937,9 @@ var Mediabunny = (() => {
     "opus",
     "mp3",
     "vorbis",
-    "flac"
+    "flac",
+    "ac3",
+    "eac3"
   ];
   var AUDIO_CODECS = [
     ...NON_PCM_AUDIO_CODECS,
@@ -1340,6 +1342,10 @@ var Mediabunny = (() => {
       return "vorbis";
     } else if (codec === "flac") {
       return "flac";
+    } else if (codec === "ac3") {
+      return "ac-3";
+    } else if (codec === "eac3") {
+      return "ec-3";
     } else if (PCM_AUDIO_CODECS.includes(codec)) {
       return codec;
     }
@@ -1371,6 +1377,10 @@ var Mediabunny = (() => {
       return "vorbis";
     } else if (codec === "flac") {
       return "flac";
+    } else if (codec === "ac3") {
+      return "ac-3";
+    } else if (codec === "eac3") {
+      return "ec-3";
     } else if (codec && PCM_AUDIO_CODECS.includes(codec)) {
       return codec;
     }
@@ -1503,6 +1513,10 @@ var Mediabunny = (() => {
       return "vorbis";
     } else if (codecString === "flac") {
       return "flac";
+    } else if (codecString === "ac-3" || codecString === "ac3") {
+      return "ac3";
+    } else if (codecString === "ec-3" || codecString === "eac3") {
+      return "eac3";
     } else if (codecString === "ulaw") {
       return "ulaw";
     } else if (codecString === "alaw") {
@@ -1573,7 +1587,7 @@ var Mediabunny = (() => {
     }
     if (!VALID_VIDEO_CODEC_STRING_PREFIXES.some((prefix) => metadata.decoderConfig.codec.startsWith(prefix))) {
       throw new TypeError(
-        "Video chunk metadata decoder configuration codec string must be a valid video codec string as specified in the WebCodecs Codec Registry."
+        "Video chunk metadata decoder configuration codec string must be a valid video codec string as specified in the Mediabunny Codec Registry."
       );
     }
     if (!Number.isInteger(metadata.decoderConfig.codedWidth) || metadata.decoderConfig.codedWidth <= 0) {
@@ -1654,7 +1668,18 @@ var Mediabunny = (() => {
       }
     }
   };
-  var VALID_AUDIO_CODEC_STRING_PREFIXES = ["mp4a", "mp3", "opus", "vorbis", "flac", "ulaw", "alaw", "pcm"];
+  var VALID_AUDIO_CODEC_STRING_PREFIXES = [
+    "mp4a",
+    "mp3",
+    "opus",
+    "vorbis",
+    "flac",
+    "ulaw",
+    "alaw",
+    "pcm",
+    "ac-3",
+    "ec-3"
+  ];
   var validateAudioChunkMetadata = (metadata) => {
     if (!metadata) {
       throw new TypeError("Audio chunk metadata must be provided.");
@@ -1673,7 +1698,7 @@ var Mediabunny = (() => {
     }
     if (!VALID_AUDIO_CODEC_STRING_PREFIXES.some((prefix) => metadata.decoderConfig.codec.startsWith(prefix))) {
       throw new TypeError(
-        "Audio chunk metadata decoder configuration codec string must be a valid audio codec string as specified in the WebCodecs Codec Registry."
+        "Audio chunk metadata decoder configuration codec string must be a valid audio codec string as specified in the Mediabunny Codec Registry."
       );
     }
     if (!Number.isInteger(metadata.decoderConfig.sampleRate) || metadata.decoderConfig.sampleRate <= 0) {
@@ -1734,6 +1759,14 @@ var Mediabunny = (() => {
           "Audio chunk metadata decoder configuration for FLAC must include a description, which is expected to adhere to the format described in https://www.w3.org/TR/webcodecs-flac-codec-registration/."
         );
       }
+    } else if (metadata.decoderConfig.codec.startsWith("ac-3") || metadata.decoderConfig.codec.startsWith("ac3")) {
+      if (metadata.decoderConfig.codec !== "ac-3") {
+        throw new TypeError('Audio chunk metadata decoder configuration codec string for AC-3 must be "ac-3".');
+      }
+    } else if (metadata.decoderConfig.codec.startsWith("ec-3") || metadata.decoderConfig.codec.startsWith("eac3")) {
+      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("pcm") || metadata.decoderConfig.codec.startsWith("ulaw") || metadata.decoderConfig.codec.startsWith("alaw")) {
       if (!PCM_AUDIO_CODECS.includes(metadata.decoderConfig.codec)) {
         throw new TypeError(
@@ -3973,6 +4006,287 @@ var Mediabunny = (() => {
     }
     return commentHeader;
   };
+  var AC3_SAMPLE_RATES = [48e3, 44100, 32e3];
+  var AC3_ACMOD_CHANNEL_COUNTS = [2, 1, 2, 3, 3, 4, 4, 5];
+  var parseAc3SyncFrame = (data) => {
+    if (data.length < 7) {
+      return null;
+    }
+    if (data[0] !== 11 || data[1] !== 119) {
+      return null;
+    }
+    const bitstream = new Bitstream(data);
+    bitstream.skipBits(16);
+    bitstream.skipBits(16);
+    const fscod = bitstream.readBits(2);
+    if (fscod === 3) {
+      return null;
+    }
+    const frmsizecod = bitstream.readBits(6);
+    const bsid = bitstream.readBits(5);
+    if (bsid > 8) {
+      return null;
+    }
+    const bsmod = bitstream.readBits(3);
+    const acmod = bitstream.readBits(3);
+    if ((acmod & 1) !== 0 && acmod !== 1) {
+      bitstream.skipBits(2);
+    }
+    if ((acmod & 4) !== 0) {
+      bitstream.skipBits(2);
+    }
+    if (acmod === 2) {
+      bitstream.skipBits(2);
+    }
+    const lfeon = bitstream.readBits(1);
+    const bitRateCode = Math.floor(frmsizecod / 2);
+    return { fscod, bsid, bsmod, acmod, lfeon, bitRateCode };
+  };
+  var AC3_FRAME_SIZES = [
+    // frmsizecod, [48kHz, 44.1kHz, 32kHz] in bytes
+    64 * 2,
+    69 * 2,
+    96 * 2,
+    64 * 2,
+    70 * 2,
+    96 * 2,
+    80 * 2,
+    87 * 2,
+    120 * 2,
+    80 * 2,
+    88 * 2,
+    120 * 2,
+    96 * 2,
+    104 * 2,
+    144 * 2,
+    96 * 2,
+    105 * 2,
+    144 * 2,
+    112 * 2,
+    121 * 2,
+    168 * 2,
+    112 * 2,
+    122 * 2,
+    168 * 2,
+    128 * 2,
+    139 * 2,
+    192 * 2,
+    128 * 2,
+    140 * 2,
+    192 * 2,
+    160 * 2,
+    174 * 2,
+    240 * 2,
+    160 * 2,
+    175 * 2,
+    240 * 2,
+    192 * 2,
+    208 * 2,
+    288 * 2,
+    192 * 2,
+    209 * 2,
+    288 * 2,
+    224 * 2,
+    243 * 2,
+    336 * 2,
+    224 * 2,
+    244 * 2,
+    336 * 2,
+    256 * 2,
+    278 * 2,
+    384 * 2,
+    256 * 2,
+    279 * 2,
+    384 * 2,
+    320 * 2,
+    348 * 2,
+    480 * 2,
+    320 * 2,
+    349 * 2,
+    480 * 2,
+    384 * 2,
+    417 * 2,
+    576 * 2,
+    384 * 2,
+    418 * 2,
+    576 * 2,
+    448 * 2,
+    487 * 2,
+    672 * 2,
+    448 * 2,
+    488 * 2,
+    672 * 2,
+    512 * 2,
+    557 * 2,
+    768 * 2,
+    512 * 2,
+    558 * 2,
+    768 * 2,
+    640 * 2,
+    696 * 2,
+    960 * 2,
+    640 * 2,
+    697 * 2,
+    960 * 2,
+    768 * 2,
+    835 * 2,
+    1152 * 2,
+    768 * 2,
+    836 * 2,
+    1152 * 2,
+    896 * 2,
+    975 * 2,
+    1344 * 2,
+    896 * 2,
+    976 * 2,
+    1344 * 2,
+    1024 * 2,
+    1114 * 2,
+    1536 * 2,
+    1024 * 2,
+    1115 * 2,
+    1536 * 2,
+    1152 * 2,
+    1253 * 2,
+    1728 * 2,
+    1152 * 2,
+    1254 * 2,
+    1728 * 2,
+    1280 * 2,
+    1393 * 2,
+    1920 * 2,
+    1280 * 2,
+    1394 * 2,
+    1920 * 2
+  ];
+  var AC3_SAMPLES_PER_FRAME = 1536;
+  var AC3_REGISTRATION_DESCRIPTOR = new Uint8Array([5, 4, 65, 67, 45, 51]);
+  var EAC3_REGISTRATION_DESCRIPTOR = new Uint8Array([5, 4, 69, 65, 67, 51]);
+  var EAC3_REDUCED_SAMPLE_RATES = [24e3, 22050, 16e3];
+  var EAC3_NUMBLKS_TABLE = [1, 2, 3, 6];
+  var parseEac3SyncFrame = (data) => {
+    if (data.length < 6) {
+      return null;
+    }
+    if (data[0] !== 11 || data[1] !== 119) {
+      return null;
+    }
+    const bitstream = new Bitstream(data);
+    bitstream.skipBits(16);
+    const strmtyp = bitstream.readBits(2);
+    bitstream.skipBits(3);
+    if (strmtyp !== 0 && strmtyp !== 2) {
+      return null;
+    }
+    const frmsiz = bitstream.readBits(11);
+    const fscod = bitstream.readBits(2);
+    let fscod2 = 0;
+    let numblkscod;
+    if (fscod === 3) {
+      fscod2 = bitstream.readBits(2);
+      numblkscod = 3;
+    } else {
+      numblkscod = bitstream.readBits(2);
+    }
+    const acmod = bitstream.readBits(3);
+    const lfeon = bitstream.readBits(1);
+    const bsid = bitstream.readBits(5);
+    if (bsid < 11 || bsid > 16) {
+      return null;
+    }
+    const numblks = EAC3_NUMBLKS_TABLE[numblkscod];
+    let fs;
+    if (fscod < 3) {
+      fs = AC3_SAMPLE_RATES[fscod] / 1e3;
+    } else {
+      fs = EAC3_REDUCED_SAMPLE_RATES[fscod2] / 1e3;
+    }
+    const dataRate = Math.round((frmsiz + 1) * fs / (numblks * 16));
+    const bsmod = 0;
+    const numDepSub = 0;
+    const chanLoc = 0;
+    const substream = {
+      fscod,
+      fscod2,
+      bsid,
+      bsmod,
+      acmod,
+      lfeon,
+      numDepSub,
+      chanLoc
+    };
+    return {
+      dataRate,
+      substreams: [substream]
+    };
+  };
+  var parseEac3Config = (data) => {
+    if (data.length < 2) {
+      return null;
+    }
+    const bitstream = new Bitstream(data);
+    const dataRate = bitstream.readBits(13);
+    const numIndSub = bitstream.readBits(3);
+    const substreams = [];
+    for (let i = 0; i <= numIndSub; i++) {
+      if (Math.ceil(bitstream.pos / 8) + 3 > data.length) {
+        break;
+      }
+      const fscod = bitstream.readBits(2);
+      const bsid = bitstream.readBits(5);
+      bitstream.skipBits(1);
+      bitstream.skipBits(1);
+      const bsmod = bitstream.readBits(3);
+      const acmod = bitstream.readBits(3);
+      const lfeon = bitstream.readBits(1);
+      bitstream.skipBits(3);
+      const numDepSub = bitstream.readBits(4);
+      let chanLoc = 0;
+      if (numDepSub > 0) {
+        chanLoc = bitstream.readBits(9);
+      } else {
+        bitstream.skipBits(1);
+      }
+      substreams.push({
+        fscod,
+        fscod2: null,
+        bsid,
+        bsmod,
+        acmod,
+        lfeon,
+        numDepSub,
+        chanLoc
+      });
+    }
+    if (substreams.length === 0) {
+      return null;
+    }
+    return { dataRate, substreams };
+  };
+  var getEac3SampleRate = (config) => {
+    const sub = config.substreams[0];
+    assert(sub);
+    if (sub.fscod < 3) {
+      return AC3_SAMPLE_RATES[sub.fscod];
+    } else if (sub.fscod2 !== null && sub.fscod2 < 3) {
+      return EAC3_REDUCED_SAMPLE_RATES[sub.fscod2];
+    }
+    return null;
+  };
+  var getEac3ChannelCount = (config) => {
+    const sub = config.substreams[0];
+    assert(sub);
+    let channels = AC3_ACMOD_CHANNEL_COUNTS[sub.acmod] + sub.lfeon;
+    if (sub.numDepSub > 0) {
+      const CHAN_LOC_COUNTS = [2, 2, 1, 1, 2, 2, 2, 1, 1];
+      for (let bit = 0; bit < 9; bit++) {
+        if (sub.chanLoc & 1 << 8 - bit) {
+          channels += CHAN_LOC_COUNTS[bit];
+        }
+      }
+    }
+    return channels;
+  };
 
   // src/demuxer.ts
   var Demuxer = class {
@@ -8087,6 +8401,10 @@ var Mediabunny = (() => {
                   track.info.codec = "ulaw";
                 } else if (lowercaseBoxName === "alaw") {
                   track.info.codec = "alaw";
+                } else if (lowercaseBoxName === "ac-3") {
+                  track.info.codec = "ac3";
+                } else if (lowercaseBoxName === "ec-3") {
+                  track.info.codec = "eac3";
                 } else {
                   console.warn(`Unsupported audio codec (sample entry type '${sampleBoxInfo.name}').`);
                 }
@@ -8532,6 +8850,47 @@ var Mediabunny = (() => {
           }
           ;
           break;
+        case "dac3":
+          {
+            const track = this.currentTrack;
+            if (!track) {
+              break;
+            }
+            assert(track.info?.type === "audio");
+            const bytes2 = readBytes(slice, 3);
+            const bitstream = new Bitstream(bytes2);
+            const fscod = bitstream.readBits(2);
+            bitstream.skipBits(5 + 3);
+            const acmod = bitstream.readBits(3);
+            const lfeon = bitstream.readBits(1);
+            if (fscod < 3) {
+              track.info.sampleRate = AC3_SAMPLE_RATES[fscod];
+            }
+            track.info.numberOfChannels = AC3_ACMOD_CHANNEL_COUNTS[acmod] + lfeon;
+          }
+          ;
+          break;
+        case "dec3":
+          {
+            const track = this.currentTrack;
+            if (!track) {
+              break;
+            }
+            assert(track.info?.type === "audio");
+            const bytes2 = readBytes(slice, boxInfo.contentSize);
+            const config = parseEac3Config(bytes2);
+            if (!config) {
+              console.warn("Invalid dec3 box contents, ignoring.");
+              break;
+            }
+            const sampleRate = getEac3SampleRate(config);
+            if (sampleRate !== null) {
+              track.info.sampleRate = sampleRate;
+            }
+            track.info.numberOfChannels = getEac3ChannelCount(config);
+          }
+          ;
+          break;
         case "stts":
           {
             const track = this.currentTrack;
@@ -10399,6 +10758,8 @@ var Mediabunny = (() => {
     "opus": "A_OPUS",
     "vorbis": "A_VORBIS",
     "flac": "A_FLAC",
+    "ac3": "A_AC3",
+    "eac3": "A_EAC3",
     "pcm-u8": "A_PCM/INT/LIT",
     "pcm-s16": "A_PCM/INT/LIT",
     "pcm-s16be": "A_PCM/INT/BIG",
@@ -11064,6 +11425,12 @@ var Mediabunny = (() => {
                 } else if (codecIdWithoutSuffix === CODEC_STRING_MAP.flac) {
                   this.currentTrack.info.codec = "flac";
                   this.currentTrack.info.codecDescription = this.currentTrack.codecPrivate;
+                } else if (codecIdWithoutSuffix === CODEC_STRING_MAP.ac3) {
+                  this.currentTrack.info.codec = "ac3";
+                  this.currentTrack.info.codecDescription = this.currentTrack.codecPrivate;
+                } else if (codecIdWithoutSuffix === CODEC_STRING_MAP.eac3) {
+                  this.currentTrack.info.codec = "eac3";
+                  this.currentTrack.info.codecDescription = this.currentTrack.codecPrivate;
                 } else if (this.currentTrack.codecId === "A_PCM/INT/LIT") {
                   if (this.currentTrack.info.bitDepth === 8) {
                     this.currentTrack.info.codec = "pcm-u8";
@@ -14910,7 +15277,19 @@ var Mediabunny = (() => {
               const elementaryPid = bitstream.readBits(13);
               bitstream.skipBits(6);
               const esInfoLength = bitstream.readBits(10);
-              bitstream.skipBits(8 * esInfoLength);
+              const esInfoEndPos = bitstream.pos + 8 * esInfoLength;
+              let hasAc3Descriptor = false;
+              let hasEac3Descriptor = false;
+              while (bitstream.pos < esInfoEndPos) {
+                const descriptorTag = bitstream.readBits(8);
+                const descriptorLength = bitstream.readBits(8);
+                if (descriptorTag === 106) {
+                  hasAc3Descriptor = true;
+                } else if (descriptorTag === 122 || descriptorTag === 204) {
+                  hasEac3Descriptor = true;
+                }
+                bitstream.skipBits(8 * descriptorLength);
+              }
               let info = null;
               switch (streamType) {
                 case 3 /* MP3_MPEG1 */:
@@ -14950,6 +15329,52 @@ var Mediabunny = (() => {
                   }
                   ;
                   break;
+                case 129 /* AC3_SYSTEM_A */:
+                  {
+                    info = {
+                      type: "audio",
+                      codec: "ac3",
+                      aacCodecInfo: null,
+                      numberOfChannels: -1,
+                      sampleRate: -1
+                    };
+                  }
+                  ;
+                  break;
+                case 135 /* EAC3_SYSTEM_A */:
+                  {
+                    info = {
+                      type: "audio",
+                      codec: "eac3",
+                      aacCodecInfo: null,
+                      numberOfChannels: -1,
+                      sampleRate: -1
+                    };
+                  }
+                  ;
+                  break;
+                case 6 /* PRIVATE_DATA */:
+                  {
+                    if (hasEac3Descriptor) {
+                      info = {
+                        type: "audio",
+                        codec: "eac3",
+                        aacCodecInfo: null,
+                        numberOfChannels: -1,
+                        sampleRate: -1
+                      };
+                    } else if (hasAc3Descriptor) {
+                      info = {
+                        type: "audio",
+                        codec: "ac3",
+                        aacCodecInfo: null,
+                        numberOfChannels: -1,
+                        sampleRate: -1
+                      };
+                    }
+                  }
+                  ;
+                  break;
                 default: {
                   console.warn(`Unsupported stream_type 0x${streamType.toString(16)}; ignoring stream.`);
                 }
@@ -15051,6 +15476,37 @@ var Mediabunny = (() => {
                   elementaryStream.info.numberOfChannels = result.header.channel === 3 ? 1 : 2;
                   elementaryStream.info.sampleRate = result.header.sampleRate;
                   elementaryStream.initialized = true;
+                } else if (elementaryStream.info.codec === "ac3") {
+                  const frameInfo = parseAc3SyncFrame(pesPacket.data);
+                  if (!frameInfo) {
+                    throw new Error(
+                      "Invalid AC-3 audio stream; could not read sync frame from first packet."
+                    );
+                  }
+                  if (frameInfo.fscod === 3) {
+                    throw new Error(
+                      "Invalid AC-3 audio stream; reserved sample rate code found in first packet."
+                    );
+                  }
+                  elementaryStream.info.numberOfChannels = AC3_ACMOD_CHANNEL_COUNTS[frameInfo.acmod] + frameInfo.lfeon;
+                  elementaryStream.info.sampleRate = AC3_SAMPLE_RATES[frameInfo.fscod];
+                  elementaryStream.initialized = true;
+                } else if (elementaryStream.info.codec === "eac3") {
+                  const frameInfo = parseEac3SyncFrame(pesPacket.data);
+                  if (!frameInfo) {
+                    throw new Error(
+                      "Invalid E-AC-3 audio stream; could not read sync frame from first packet."
+                    );
+                  }
+                  const sampleRate = getEac3SampleRate(frameInfo);
+                  if (sampleRate === null) {
+                    throw new Error(
+                      "Invalid E-AC-3 audio stream; reserved sample rate code found in first packet."
+                    );
+                  }
+                  elementaryStream.info.numberOfChannels = getEac3ChannelCount(frameInfo);
+                  elementaryStream.info.sampleRate = sampleRate;
+                  elementaryStream.initialized = true;
                 } else {
                   throw new Error("Unhandled.");
                 }
@@ -15955,6 +16411,66 @@ var Mediabunny = (() => {
             } else {
               context.seekTo(possibleHeaderStartPos + 1);
             }
+          } else if (codec === "ac3") {
+            if (byte !== 11) {
+              continue;
+            }
+            context.skip(-1);
+            const possibleSyncPos = context.currentPos;
+            let remaining2 = context.ensureBuffered(5);
+            if (remaining2 instanceof Promise) remaining2 = await remaining2;
+            if (remaining2 < 5) {
+              return;
+            }
+            const headerBytes = context.readBytes(5);
+            if (headerBytes[0] !== 11 || headerBytes[1] !== 119) {
+              context.seekTo(possibleSyncPos + 1);
+              continue;
+            }
+            const fscod = headerBytes[4] >> 6;
+            const frmsizecod = headerBytes[4] & 63;
+            if (fscod === 3 || frmsizecod > 37) {
+              context.seekTo(possibleSyncPos + 1);
+              continue;
+            }
+            const frameSize = AC3_FRAME_SIZES[3 * frmsizecod + fscod];
+            assert(frameSize !== void 0);
+            context.seekTo(possibleSyncPos);
+            remaining2 = context.ensureBuffered(frameSize);
+            if (remaining2 instanceof Promise) remaining2 = await remaining2;
+            const duration = Math.round(
+              AC3_SAMPLES_PER_FRAME * TIMESCALE / elementaryStream.info.sampleRate
+            );
+            return context.supplyPacket(remaining2, duration);
+          } else if (codec === "eac3") {
+            if (byte !== 11) {
+              continue;
+            }
+            context.skip(-1);
+            const possibleSyncPos = context.currentPos;
+            let remaining2 = context.ensureBuffered(5);
+            if (remaining2 instanceof Promise) remaining2 = await remaining2;
+            if (remaining2 < 5) {
+              return;
+            }
+            const headerBytes = context.readBytes(5);
+            if (headerBytes[0] !== 11 || headerBytes[1] !== 119) {
+              context.seekTo(possibleSyncPos + 1);
+              continue;
+            }
+            const frmsiz = (headerBytes[2] & 7) << 8 | headerBytes[3];
+            const frameSize = (frmsiz + 1) * 2;
+            const fscod = headerBytes[4] >> 6;
+            const numblkscod = fscod === 3 ? 3 : headerBytes[4] >> 4 & 3;
+            const numblks = EAC3_NUMBLKS_TABLE[numblkscod];
+            context.seekTo(possibleSyncPos);
+            remaining2 = context.ensureBuffered(frameSize);
+            if (remaining2 instanceof Promise) remaining2 = await remaining2;
+            const samplesPerFrame = numblks * 256;
+            const duration = Math.round(
+              samplesPerFrame * TIMESCALE / elementaryStream.info.sampleRate
+            );
+            return context.supplyPacket(remaining2, duration);
           } else {
             throw new Error("Unhandled.");
           }
@@ -20150,6 +20666,63 @@ var Mediabunny = (() => {
       u8(8 * sampleSize)
     ]);
   };
+  var dac3 = (trackData) => {
+    const frameInfo = parseAc3SyncFrame(trackData.info.firstPacket.data);
+    if (!frameInfo) {
+      throw new Error(
+        "Couldn't extract AC-3 frame info from the audio packet. Ensure the packets contain valid AC-3 sync frames (as specified in ETSI TS 102 366)."
+      );
+    }
+    const bytes2 = new Uint8Array(3);
+    const bitstream = new Bitstream(bytes2);
+    bitstream.writeBits(2, frameInfo.fscod);
+    bitstream.writeBits(5, frameInfo.bsid);
+    bitstream.writeBits(3, frameInfo.bsmod);
+    bitstream.writeBits(3, frameInfo.acmod);
+    bitstream.writeBits(1, frameInfo.lfeon);
+    bitstream.writeBits(5, frameInfo.bitRateCode);
+    bitstream.writeBits(5, 0);
+    return box("dac3", [...bytes2]);
+  };
+  var dec3 = (trackData) => {
+    const frameInfo = parseEac3SyncFrame(trackData.info.firstPacket.data);
+    if (!frameInfo) {
+      throw new Error(
+        "Couldn't extract E-AC-3 frame info from the audio packet. Ensure the packets contain valid E-AC-3 sync frames (as specified in ETSI TS 102 366)."
+      );
+    }
+    let totalBits = 16;
+    for (const sub of frameInfo.substreams) {
+      totalBits += 23;
+      if (sub.numDepSub > 0) {
+        totalBits += 9;
+      } else {
+        totalBits += 1;
+      }
+    }
+    const size = Math.ceil(totalBits / 8);
+    const bytes2 = new Uint8Array(size);
+    const bitstream = new Bitstream(bytes2);
+    bitstream.writeBits(13, frameInfo.dataRate);
+    bitstream.writeBits(3, frameInfo.substreams.length - 1);
+    for (const sub of frameInfo.substreams) {
+      bitstream.writeBits(2, sub.fscod);
+      bitstream.writeBits(5, sub.bsid);
+      bitstream.writeBits(1, 0);
+      bitstream.writeBits(1, 0);
+      bitstream.writeBits(3, sub.bsmod);
+      bitstream.writeBits(3, sub.acmod);
+      bitstream.writeBits(1, sub.lfeon);
+      bitstream.writeBits(3, 0);
+      bitstream.writeBits(4, sub.numDepSub);
+      if (sub.numDepSub > 0) {
+        bitstream.writeBits(9, sub.chanLoc);
+      } else {
+        bitstream.writeBits(1, 0);
+      }
+    }
+    return box("dec3", [...bytes2]);
+  };
   var subtitleSampleDescription = (compressionType, trackData) => box(compressionType, [
     Array(6).fill(0),
     // Reserved
@@ -20818,6 +21391,10 @@ var Mediabunny = (() => {
         return "raw ";
       case "pcm-s8":
         return "sowt";
+      case "ac3":
+        return "ac-3";
+      case "eac3":
+        return "ec-3";
     }
     if (isQuickTime) {
       switch (codec) {
@@ -20879,6 +21456,10 @@ var Mediabunny = (() => {
         return esds;
       case "flac":
         return dfLa;
+      case "ac3":
+        return dac3;
+      case "eac3":
+        return dec3;
     }
     if (isQuickTime) {
       switch (codec) {
@@ -21576,9 +22157,10 @@ var Mediabunny = (() => {
           sampleRate: meta.decoderConfig.sampleRate,
           decoderConfig,
           requiresPcmTransformation: !this.isFragmented && PCM_AUDIO_CODECS.includes(track.source._codec),
-          requiresAdtsStripping
+          requiresAdtsStripping,
+          firstPacket: packet
         },
-        timescale: meta.decoderConfig.sampleRate,
+        timescale: decoderConfig.sampleRate,
         samples: [],
         sampleQueue: [],
         timestampProcessingQueue: [],
@@ -23806,10 +24388,40 @@ ${cue.notes ?? ""}`;
       validateAudioChunkMetadata(meta);
       assert(meta?.decoderConfig);
       const codec = track.source._codec;
-      assert(codec === "aac" || codec === "mp3");
-      const streamType = codec === "aac" ? 15 /* AAC */ : 3 /* MP3_MPEG1 */;
+      assert(codec === "aac" || codec === "mp3" || codec === "ac3" || codec === "eac3");
+      let streamType;
+      let streamId;
+      switch (codec) {
+        case "aac":
+          {
+            streamType = 15 /* AAC */;
+            streamId = AUDIO_STREAM_ID_BASE + this.audioTrackIndex++;
+          }
+          ;
+          break;
+        case "mp3":
+          {
+            streamType = 3 /* MP3_MPEG1 */;
+            streamId = AUDIO_STREAM_ID_BASE + this.audioTrackIndex++;
+          }
+          ;
+          break;
+        case "ac3":
+          {
+            streamType = 129 /* AC3_SYSTEM_A */;
+            streamId = 189;
+          }
+          ;
+          break;
+        case "eac3":
+          {
+            streamType = 135 /* EAC3_SYSTEM_A */;
+            streamId = 189;
+          }
+          ;
+          break;
+      }
       const pid = FIRST_TRACK_PID + this.trackDatas.length;
-      const streamId = AUDIO_STREAM_ID_BASE + this.audioTrackIndex++;
       const newTrackData = {
         track,
         pid,
@@ -23958,7 +24570,7 @@ ${cue.notes ?? ""}`;
     }
     prepareAudioPacket(trackData, packet, meta) {
       const codec = trackData.track.source._codec;
-      if (codec === "mp3") {
+      if (codec === "mp3" || codec === "ac3" || codec === "eac3") {
         return packet.data;
       }
       if (trackData.inputIsAdts === null) {
@@ -24186,7 +24798,16 @@ ${cue.notes ?? ""}`;
     view2.setUint32(12, computeMpegTsCrc32(PAT_SECTION.subarray(0, 12)), false);
   }
   var buildPmt = (trackDatas) => {
-    const sectionLength = 9 + trackDatas.length * 5 + 4;
+    let totalEsBytes = 0;
+    for (const trackData of trackDatas) {
+      totalEsBytes += 5;
+      if (trackData.streamType === 129 /* AC3_SYSTEM_A */) {
+        totalEsBytes += AC3_REGISTRATION_DESCRIPTOR.length;
+      } else if (trackData.streamType === 135 /* EAC3_SYSTEM_A */) {
+        totalEsBytes += EAC3_REGISTRATION_DESCRIPTOR.length;
+      }
+    }
+    const sectionLength = 9 + totalEsBytes + 4;
     const section = new Uint8Array(3 + sectionLength - 4);
     const view2 = toDataView(section);
     section[0] = 2;
@@ -24202,8 +24823,20 @@ ${cue.notes ?? ""}`;
       section[offset++] = trackData.streamType;
       view2.setUint16(offset, 57344 | trackData.pid & 8191, false);
       offset += 2;
-      view2.setUint16(offset, 61440, false);
-      offset += 2;
+      if (trackData.streamType === 129 /* AC3_SYSTEM_A */) {
+        view2.setUint16(offset, 61440 | AC3_REGISTRATION_DESCRIPTOR.length, false);
+        offset += 2;
+        section.set(AC3_REGISTRATION_DESCRIPTOR, offset);
+        offset += AC3_REGISTRATION_DESCRIPTOR.length;
+      } else if (trackData.streamType === 135 /* EAC3_SYSTEM_A */) {
+        view2.setUint16(offset, 61440 | EAC3_REGISTRATION_DESCRIPTOR.length, false);
+        offset += 2;
+        section.set(EAC3_REGISTRATION_DESCRIPTOR, offset);
+        offset += EAC3_REGISTRATION_DESCRIPTOR.length;
+      } else {
+        view2.setUint16(offset, 61440, false);
+        offset += 2;
+      }
     }
     const crc = computeMpegTsCrc32(section);
     const result = new Uint8Array(section.length + 4);
@@ -24581,6 +25214,9 @@ ${cue.notes ?? ""}`;
     get supportsVideoRotationMetadata() {
       return true;
     }
+    get supportsTimestampedMediaData() {
+      return true;
+    }
     /** @internal */
     _createMuxer(output) {
       return new IsobmffMuxer2(output, this);
@@ -24605,7 +25241,7 @@ ${cue.notes ?? ""}`;
       return [
         ...VIDEO_CODECS,
         ...NON_PCM_AUDIO_CODECS,
-        // These are supported via ISO/IEC 23003-5
+        // These are supported via ISO/IEC 23003-5:
         "pcm-s16",
         "pcm-s16be",
         "pcm-s24",
@@ -24714,6 +25350,9 @@ ${cue.notes ?? ""}`;
     get supportsVideoRotationMetadata() {
       return false;
     }
+    get supportsTimestampedMediaData() {
+      return true;
+    }
   };
   var WebMOutputFormat = class extends MkvOutputFormat2 {
     /** Creates a new {@link WebMOutputFormat} configured with the specified `options`. */
@@ -24788,6 +25427,9 @@ ${cue.notes ?? ""}`;
     get supportsVideoRotationMetadata() {
       return false;
     }
+    get supportsTimestampedMediaData() {
+      return false;
+    }
   };
   var WavOutputFormat = class extends OutputFormat {
     /** Creates a new {@link WavOutputFormat} configured with the specified `options`. */
@@ -24839,6 +25481,9 @@ ${cue.notes ?? ""}`;
     get supportsVideoRotationMetadata() {
       return false;
     }
+    get supportsTimestampedMediaData() {
+      return false;
+    }
   };
   var OggOutputFormat = class extends OutputFormat {
     /** Creates a new {@link OggOutputFormat} configured with the specified `options`. */
@@ -24886,6 +25531,9 @@ ${cue.notes ?? ""}`;
     get supportsVideoRotationMetadata() {
       return false;
     }
+    get supportsTimestampedMediaData() {
+      return false;
+    }
   };
   var AdtsOutputFormat = class extends OutputFormat {
     /** Creates a new {@link AdtsOutputFormat} configured with the specified `options`. */
@@ -24927,6 +25575,9 @@ ${cue.notes ?? ""}`;
     get supportsVideoRotationMetadata() {
       return false;
     }
+    get supportsTimestampedMediaData() {
+      return false;
+    }
   };
   var FlacOutputFormat = class extends OutputFormat {
     /** Creates a new {@link FlacOutputFormat} configured with the specified `options`. */
@@ -24965,6 +25616,9 @@ ${cue.notes ?? ""}`;
     get supportsVideoRotationMetadata() {
       return false;
     }
+    get supportsTimestampedMediaData() {
+      return false;
+    }
   };
   var MpegTsOutputFormat = class extends OutputFormat {
     /** Creates a new {@link MpegTsOutputFormat} configured with the specified `options`. */
@@ -25006,12 +25660,15 @@ ${cue.notes ?? ""}`;
     getSupportedCodecs() {
       return [
         ...VIDEO_CODECS.filter((codec) => ["avc", "hevc"].includes(codec)),
-        ...AUDIO_CODECS.filter((codec) => ["aac", "mp3"].includes(codec))
+        ...AUDIO_CODECS.filter((codec) => ["aac", "mp3", "ac3", "eac3"].includes(codec))
       ];
     }
     get supportsVideoRotationMetadata() {
       return false;
     }
+    get supportsTimestampedMediaData() {
+      return true;
+    }
   };
 
   // src/encode.ts
@@ -25188,8 +25845,12 @@ ${cue.notes ?? ""}`;
         // 64kbps base for Opus
         mp3: 16e4,
         // 160kbps base for MP3
-        vorbis: 64e3
+        vorbis: 64e3,
         // 64kbps base for Vorbis
+        ac3: 384e3,
+        // 384kbps base for AC-3
+        eac3: 192e3
+        // 192kbps base for E-AC-3
       };
       const baseBitrate = baseRates[codec];
       if (!baseBitrate) {
@@ -27561,11 +28222,11 @@ ${cue.notes ?? ""}`;
       if (options.trim !== void 0 && (!options.trim || typeof options.trim !== "object")) {
         throw new TypeError("options.trim, when provided, must be an object.");
       }
-      if (options.trim?.start !== void 0 && (!Number.isFinite(options.trim.start) || options.trim.start < 0)) {
-        throw new TypeError("options.trim.start, when provided, must be a non-negative number.");
+      if (options.trim?.start !== void 0 && !Number.isFinite(options.trim.start)) {
+        throw new TypeError("options.trim.start, when provided, must be a finite number.");
       }
-      if (options.trim?.end !== void 0 && (!Number.isFinite(options.trim.end) || options.trim.end < 0)) {
-        throw new TypeError("options.trim.end, when provided, must be a non-negative number.");
+      if (options.trim?.end !== void 0 && !Number.isFinite(options.trim.end)) {
+        throw new TypeError("options.trim.end, when provided, must be a finite number.");
       }
       if (options.trim?.start !== void 0 && options.trim.end !== void 0 && options.trim.start >= options.trim.end) {
         throw new TypeError("options.trim.start must be less than options.trim.end.");
@@ -27600,7 +28261,7 @@ ${cue.notes ?? ""}`;
         // those out by default.
         0
       );
-      this._endTimestamp = this._options.trim?.end ?? Infinity;
+      this._endTimestamp = Math.max(this._options.trim?.end ?? Infinity, this._startTimestamp);
       const inputTracks = await this.input.getTracks();
       const outputTrackCounts = this.output.format.getSupportedTrackCounts();
       let nVideo = 1;
@@ -28126,7 +28787,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       const firstTimestamp = await track.getFirstTimestamp();
       let numberOfChannels = trackOptions.numberOfChannels ?? originalNumberOfChannels;
       let sampleRate = trackOptions.sampleRate ?? originalSampleRate;
-      let needsResample = numberOfChannels !== originalNumberOfChannels || sampleRate !== originalSampleRate || firstTimestamp < this._startTimestamp;
+      let needsResample = numberOfChannels !== originalNumberOfChannels || sampleRate !== originalSampleRate || firstTimestamp < this._startTimestamp || firstTimestamp > this._startTimestamp && !this.output.format.supportsTimestampedMediaData;
       let audioCodecs = this.output.format.getSupportedAudioCodecs();
       if (!trackOptions.forceTranscode && !trackOptions.bitrate && !needsResample && audioCodecs.includes(sourceCodec) && (!trackOptions.codec || trackOptions.codec === sourceCodec) && !trackOptions.process) {
         const source = new EncodedAudioPacketSource(sourceCodec);