mediabunny 1.8.0 → 1.9.0

package/dist/bundles/mediabunny.cjs

@@ -31,6 +31,7 @@ var Mediabunny = (() => {
     ALL_FORMATS: () => ALL_FORMATS,
     ALL_TRACK_TYPES: () => ALL_TRACK_TYPES,
     AUDIO_CODECS: () => AUDIO_CODECS,
+    AdtsOutputFormat: () => AdtsOutputFormat,
     AudioBufferSink: () => AudioBufferSink,
     AudioBufferSource: () => AudioBufferSource,
     AudioSample: () => AudioSample,
@@ -169,6 +170,18 @@ var Mediabunny = (() => {
       }
       return result;
     }
+    writeBits(n, value) {
+      const end = this.pos + n;
+      for (let i = this.pos; i < end; i++) {
+        const byteIndex = Math.floor(i / 8);
+        let byte = this.bytes[byteIndex];
+        const bitIndex = 7 - (i & 7);
+        byte &= ~(1 << bitIndex);
+        byte |= (value & 1 << end - i - 1) >> end - i - 1 << bitIndex;
+        this.bytes[byteIndex] = byte;
+      }
+      this.pos = end;
+    }
     readAlignedByte() {
       if (this.pos % 8 !== 0) {
         throw new Error("Bitstream is not byte-aligned.");
@@ -1098,6 +1111,22 @@ var Mediabunny = (() => {
     }
     throw new TypeError(`Unhandled codec '${codec}'.`);
   };
+  var aacFrequencyTable = [
+    96e3,
+    88200,
+    64e3,
+    48e3,
+    44100,
+    32e3,
+    24e3,
+    22050,
+    16e3,
+    12e3,
+    11025,
+    8e3,
+    7350
+  ];
+  var aacChannelMap = [-1, 1, 2, 3, 4, 5, 6, 8];
   var parseAacAudioSpecificConfig = (bytes2) => {
     if (!bytes2 || bytes2.byteLength < 2) {
       throw new TypeError("AAC description must be at least 2 bytes long.");
@@ -1112,38 +1141,14 @@ var Mediabunny = (() => {
     if (frequencyIndex === 15) {
       sampleRate = bitstream.readBits(24);
     } else {
-      const freqTable = [
-        96e3,
-        88200,
-        64e3,
-        48e3,
-        44100,
-        32e3,
-        24e3,
-        22050,
-        16e3,
-        12e3,
-        11025,
-        8e3,
-        7350
-      ];
-      if (frequencyIndex < freqTable.length) {
-        sampleRate = freqTable[frequencyIndex];
+      if (frequencyIndex < aacFrequencyTable.length) {
+        sampleRate = aacFrequencyTable[frequencyIndex];
       }
     }
     const channelConfiguration = bitstream.readBits(4);
     let numberOfChannels = null;
     if (channelConfiguration >= 1 && channelConfiguration <= 7) {
-      const channelMap = {
-        1: 1,
-        2: 2,
-        3: 3,
-        4: 4,
-        5: 5,
-        6: 6,
-        7: 8
-      };
-      numberOfChannels = channelMap[channelConfiguration];
+      numberOfChannels = aacChannelMap[channelConfiguration];
     }
     return {
       objectType,
@@ -1695,6 +1700,119 @@ var Mediabunny = (() => {
     return null;
   };
 
+  // src/muxer.ts
+  var Muxer = class {
+    constructor(output) {
+      this.mutex = new AsyncMutex();
+      /**
+       * This field is used to synchronize multiple MediaStreamTracks. They use the same time coordinate system across
+       * tracks, and to ensure correct audio-video sync, we must use the same offset for all of them. The reason an offset
+       * is needed at all is because the timestamps typically don't start at zero.
+       */
+      this.firstMediaStreamTimestamp = null;
+      this.trackTimestampInfo = /* @__PURE__ */ new WeakMap();
+      this.output = output;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onTrackClose(track) {
+    }
+    validateAndNormalizeTimestamp(track, timestampInSeconds, isKeyFrame) {
+      timestampInSeconds += track.source._timestampOffset;
+      let timestampInfo = this.trackTimestampInfo.get(track);
+      if (!timestampInfo) {
+        if (!isKeyFrame) {
+          throw new Error("First frame must be a key frame.");
+        }
+        timestampInfo = {
+          maxTimestamp: timestampInSeconds,
+          maxTimestampBeforeLastKeyFrame: timestampInSeconds
+        };
+        this.trackTimestampInfo.set(track, timestampInfo);
+      }
+      if (timestampInSeconds < 0) {
+        throw new Error(`Timestamps must be non-negative (got ${timestampInSeconds}s).`);
+      }
+      if (isKeyFrame) {
+        timestampInfo.maxTimestampBeforeLastKeyFrame = timestampInfo.maxTimestamp;
+      }
+      if (timestampInSeconds < timestampInfo.maxTimestampBeforeLastKeyFrame) {
+        throw new Error(
+          `Timestamps cannot be smaller than the highest timestamp of the previous run (a run begins with a key frame and ends right before the next key frame). Got ${timestampInSeconds}s, but highest timestamp is ${timestampInfo.maxTimestampBeforeLastKeyFrame}s.`
+        );
+      }
+      timestampInfo.maxTimestamp = Math.max(timestampInfo.maxTimestamp, timestampInSeconds);
+      return timestampInSeconds;
+    }
+  };
+
+  // src/adts/adts-muxer.ts
+  var AdtsMuxer = class extends Muxer {
+    constructor(output, format) {
+      super(output);
+      this.header = new Uint8Array(7);
+      this.headerBitstream = new Bitstream(this.header);
+      this.audioSpecificConfig = null;
+      this.format = format;
+      this.writer = output._writer;
+    }
+    async start() {
+    }
+    async getMimeType() {
+      return "audio/aac";
+    }
+    async addEncodedVideoPacket() {
+      throw new Error("ADTS does not support video.");
+    }
+    async addEncodedAudioPacket(track, packet, meta) {
+      const release = await this.mutex.acquire();
+      try {
+        if (!this.audioSpecificConfig) {
+          validateAudioChunkMetadata(meta);
+          const description = meta?.decoderConfig?.description;
+          assert(description);
+          this.audioSpecificConfig = parseAacAudioSpecificConfig(toUint8Array(description));
+          const { objectType, frequencyIndex, channelConfiguration } = this.audioSpecificConfig;
+          const profile = objectType - 1;
+          this.headerBitstream.writeBits(12, 4095);
+          this.headerBitstream.writeBits(1, 0);
+          this.headerBitstream.writeBits(2, 0);
+          this.headerBitstream.writeBits(1, 1);
+          this.headerBitstream.writeBits(2, profile);
+          this.headerBitstream.writeBits(4, frequencyIndex);
+          this.headerBitstream.writeBits(1, 0);
+          this.headerBitstream.writeBits(3, channelConfiguration);
+          this.headerBitstream.writeBits(1, 0);
+          this.headerBitstream.writeBits(1, 0);
+          this.headerBitstream.writeBits(1, 0);
+          this.headerBitstream.writeBits(1, 0);
+          this.headerBitstream.skipBits(13);
+          this.headerBitstream.writeBits(11, 2047);
+          this.headerBitstream.writeBits(2, 0);
+        }
+        const frameLength = packet.data.byteLength + this.header.byteLength;
+        this.headerBitstream.pos = 30;
+        this.headerBitstream.writeBits(13, frameLength);
+        const startPos = this.writer.getPos();
+        this.writer.write(this.header);
+        this.writer.write(packet.data);
+        if (this.format._options.onFrame) {
+          const frameBytes = new Uint8Array(frameLength);
+          frameBytes.set(this.header, 0);
+          frameBytes.set(packet.data, this.header.byteLength);
+          this.format._options.onFrame(frameBytes, startPos);
+        }
+        await this.writer.flush();
+      } finally {
+        release();
+      }
+    }
+    async addSubtitleCue() {
+      throw new Error("ADTS does not support subtitles.");
+    }
+    async finalize() {
+    }
+  };
+
   // src/subtitles.ts
   var cueBlockHeaderRegex = /(?:(.+?)\n)?((?:\d{2}:)?\d{2}:\d{2}.\d{3})\s+-->\s+((?:\d{2}:)?\d{2}:\d{2}.\d{3})/g;
   var preambleStartRegex = /^WEBVTT(.|\n)*?\n{2}/;
@@ -4064,51 +4182,6 @@ var Mediabunny = (() => {
     webvtt: vttC
   };
 
-  // src/muxer.ts
-  var Muxer = class {
-    constructor(output) {
-      this.mutex = new AsyncMutex();
-      /**
-       * This field is used to synchronize multiple MediaStreamTracks. They use the same time coordinate system across
-       * tracks, and to ensure correct audio-video sync, we must use the same offset for all of them. The reason an offset
-       * is needed at all is because the timestamps typically don't start at zero.
-       */
-      this.firstMediaStreamTimestamp = null;
-      this.trackTimestampInfo = /* @__PURE__ */ new WeakMap();
-      this.output = output;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    onTrackClose(track) {
-    }
-    validateAndNormalizeTimestamp(track, timestampInSeconds, isKeyFrame) {
-      timestampInSeconds += track.source._timestampOffset;
-      let timestampInfo = this.trackTimestampInfo.get(track);
-      if (!timestampInfo) {
-        if (!isKeyFrame) {
-          throw new Error("First frame must be a key frame.");
-        }
-        timestampInfo = {
-          maxTimestamp: timestampInSeconds,
-          maxTimestampBeforeLastKeyFrame: timestampInSeconds
-        };
-        this.trackTimestampInfo.set(track, timestampInfo);
-      }
-      if (timestampInSeconds < 0) {
-        throw new Error(`Timestamps must be non-negative (got ${timestampInSeconds}s).`);
-      }
-      if (isKeyFrame) {
-        timestampInfo.maxTimestampBeforeLastKeyFrame = timestampInfo.maxTimestamp;
-      }
-      if (timestampInSeconds < timestampInfo.maxTimestampBeforeLastKeyFrame) {
-        throw new Error(
-          `Timestamps cannot be smaller than the highest timestamp of the previous run (a run begins with a key frame and ends right before the next key frame). Got ${timestampInSeconds}s, but highest timestamp is ${timestampInfo.maxTimestampBeforeLastKeyFrame}s.`
-        );
-      }
-      timestampInfo.maxTimestamp = Math.max(timestampInfo.maxTimestamp, timestampInSeconds);
-      return timestampInSeconds;
-    }
-  };
-
   // src/writer.ts
   var Writer = class {
     constructor() {
@@ -10625,6 +10698,46 @@ ${cue.notes ?? ""}`;
       return false;
     }
   };
+  var AdtsOutputFormat = class extends OutputFormat {
+    constructor(options = {}) {
+      if (!options || typeof options !== "object") {
+        throw new TypeError("options must be an object.");
+      }
+      if (options.onFrame !== void 0 && typeof options.onFrame !== "function") {
+        throw new TypeError("options.onFrame, when provided, must be a function.");
+      }
+      super();
+      this._options = options;
+    }
+    /** @internal */
+    _createMuxer(output) {
+      return new AdtsMuxer(output, this);
+    }
+    /** @internal */
+    get _name() {
+      return "ADTS";
+    }
+    getSupportedTrackCounts() {
+      return {
+        video: { min: 0, max: 0 },
+        audio: { min: 1, max: 1 },
+        subtitle: { min: 0, max: 0 },
+        total: { min: 1, max: 1 }
+      };
+    }
+    get fileExtension() {
+      return ".aac";
+    }
+    get mimeType() {
+      return "audio/aac";
+    }
+    getSupportedCodecs() {
+      return ["aac"];
+    }
+    get supportsVideoRotationMetadata() {
+      return false;
+    }
+  };
 
   // src/media-source.ts
   var MediaSource = class {
@@ -12954,7 +13067,7 @@ ${cue.notes ?? ""}`;
             const chromaSubsamplingX = thirdByte >> 3 & 1;
             const chromaSubsamplingY = thirdByte >> 2 & 1;
             const chromaSamplePosition = thirdByte & 3;
-            const bitDepth = profile == 2 && highBitDepth ? twelveBit ? 12 : 10 : highBitDepth ? 10 : 8;
+            const bitDepth = profile === 2 && highBitDepth ? twelveBit ? 12 : 10 : highBitDepth ? 10 : 8;
             track.info.av1CodecInfo = {
               profile,
               level,
@@ -15764,7 +15877,7 @@ ${cue.notes ?? ""}`;
       this.loadedSamples = [];
       // All samples from the start of the file to lastLoadedPos
       this.tracks = [];
-      this.loadingMutex = new AsyncMutex();
+      this.readingMutex = new AsyncMutex();
       this.lastLoadedPos = 0;
       this.fileSize = 0;
       this.nextTimestampInSamples = 0;
@@ -15777,32 +15890,25 @@ ${cue.notes ?? ""}`;
         while (!this.firstFrameHeader && this.lastLoadedPos < this.fileSize) {
           await this.loadNextChunk();
         }
-        if (!this.firstFrameHeader) {
-          throw new Error("No MP3 frames found.");
-        }
+        assert(this.firstFrameHeader);
         this.tracks = [new InputAudioTrack(new Mp3AudioTrackBacking(this))];
       })();
     }
     /** Loads the next 0.5 MiB of frames. */
     async loadNextChunk() {
-      const release = await this.loadingMutex.acquire();
-      try {
-        assert(this.lastLoadedPos < this.fileSize);
-        const chunkSize = 0.5 * 1024 * 1024;
-        const endPos = Math.min(this.lastLoadedPos + chunkSize, this.fileSize);
-        await this.reader.reader.loadRange(this.lastLoadedPos, endPos);
-        this.lastLoadedPos = endPos;
-        assert(this.lastLoadedPos <= this.fileSize);
-        if (this.reader.pos === 0) {
-          const id3Tag = this.reader.readId3();
-          if (id3Tag) {
-            this.reader.pos += id3Tag.size;
-          }
-        }
-        this.parseFramesFromLoadedData();
-      } finally {
-        release();
+      assert(this.lastLoadedPos < this.fileSize);
+      const chunkSize = 0.5 * 1024 * 1024;
+      const endPos = Math.min(this.lastLoadedPos + chunkSize, this.fileSize);
+      await this.reader.reader.loadRange(this.lastLoadedPos, endPos);
+      this.lastLoadedPos = endPos;
+      assert(this.lastLoadedPos <= this.fileSize);
+      if (this.reader.pos === 0) {
+        const id3Tag = this.reader.readId3();
+        if (id3Tag) {
+          this.reader.pos += id3Tag.size;
+        }
       }
+      this.parseFramesFromLoadedData();
     }
     parseFramesFromLoadedData() {
       while (true) {
@@ -15917,43 +16023,50 @@ ${cue.notes ?? ""}`;
       );
     }
     async getFirstPacket(options) {
-      while (this.demuxer.loadedSamples.length === 0 && this.demuxer.lastLoadedPos < this.demuxer.fileSize) {
-        await this.demuxer.loadNextChunk();
-      }
       return this.getPacketAtIndex(0, options);
     }
     async getNextPacket(packet, options) {
-      const sampleIndex = binarySearchExact(
-        this.demuxer.loadedSamples,
-        packet.timestamp,
-        (x) => x.timestamp
-      );
-      if (sampleIndex === -1) {
-        throw new Error("Packet was not created from this track.");
-      }
-      const nextIndex = sampleIndex + 1;
-      while (nextIndex >= this.demuxer.loadedSamples.length && this.demuxer.lastLoadedPos < this.demuxer.fileSize) {
-        await this.demuxer.loadNextChunk();
-      }
-      return this.getPacketAtIndex(nextIndex, options);
-    }
-    async getPacket(timestamp, options) {
-      while (true) {
-        const index = binarySearchLessOrEqual(
+      const release = await this.demuxer.readingMutex.acquire();
+      try {
+        const sampleIndex = binarySearchExact(
           this.demuxer.loadedSamples,
-          timestamp,
+          packet.timestamp,
           (x) => x.timestamp
         );
-        if (index === -1 && this.demuxer.loadedSamples.length > 0) {
-          return null;
+        if (sampleIndex === -1) {
+          throw new Error("Packet was not created from this track.");
         }
-        if (this.demuxer.lastLoadedPos === this.demuxer.fileSize) {
-          return this.getPacketAtIndex(index, options);
+        const nextIndex = sampleIndex + 1;
+        while (nextIndex >= this.demuxer.loadedSamples.length && this.demuxer.lastLoadedPos < this.demuxer.fileSize) {
+          await this.demuxer.loadNextChunk();
         }
-        if (index >= 0 && index + 1 < this.demuxer.loadedSamples.length) {
-          return this.getPacketAtIndex(index, options);
+        return this.getPacketAtIndex(nextIndex, options);
+      } finally {
+        release();
+      }
+    }
+    async getPacket(timestamp, options) {
+      const release = await this.demuxer.readingMutex.acquire();
+      try {
+        while (true) {
+          const index = binarySearchLessOrEqual(
+            this.demuxer.loadedSamples,
+            timestamp,
+            (x) => x.timestamp
+          );
+          if (index === -1 && this.demuxer.loadedSamples.length > 0) {
+            return null;
+          }
+          if (this.demuxer.lastLoadedPos === this.demuxer.fileSize) {
+            return this.getPacketAtIndex(index, options);
+          }
+          if (index >= 0 && index + 1 < this.demuxer.loadedSamples.length) {
+            return this.getPacketAtIndex(index, options);
+          }
+          await this.demuxer.loadNextChunk();
         }
-        await this.demuxer.loadNextChunk();
+      } finally {
+        release();
       }
     }
     getKeyPacket(timestamp, options) {
@@ -16659,6 +16772,282 @@ ${cue.notes ?? ""}`;
     return { page: previousPage, segmentIndex: previousPage.lacingValues.length - 1 };
   };
 
+  // src/adts/adts-reader.ts
+  var MAX_FRAME_HEADER_SIZE = 9;
+  var AdtsReader = class {
+    constructor(reader) {
+      this.reader = reader;
+      this.pos = 0;
+    }
+    readBytes(length) {
+      const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + length);
+      this.pos += length;
+      return new Uint8Array(view2.buffer, offset, length);
+    }
+    readFrameHeader() {
+      const startPos = this.pos;
+      const bytes2 = this.readBytes(9);
+      const bitstream = new Bitstream(bytes2);
+      const syncword = bitstream.readBits(12);
+      if (syncword !== 4095) {
+        return null;
+      }
+      bitstream.skipBits(1);
+      const layer = bitstream.readBits(2);
+      if (layer !== 0) {
+        return null;
+      }
+      const protectionAbsence = bitstream.readBits(1);
+      const objectType = bitstream.readBits(2) + 1;
+      const samplingFrequencyIndex = bitstream.readBits(4);
+      if (samplingFrequencyIndex === 15) {
+        return null;
+      }
+      bitstream.skipBits(1);
+      const channelConfiguration = bitstream.readBits(3);
+      if (channelConfiguration === 0) {
+        throw new Error("ADTS frames with channel configuration 0 are not supported.");
+      }
+      bitstream.skipBits(1);
+      bitstream.skipBits(1);
+      bitstream.skipBits(1);
+      bitstream.skipBits(1);
+      const frameLength = bitstream.readBits(13);
+      bitstream.skipBits(11);
+      const numberOfAacFrames = bitstream.readBits(2) + 1;
+      if (numberOfAacFrames !== 1) {
+        throw new Error("ADTS frames with more than one AAC frame are not supported.");
+      }
+      let crcCheck = null;
+      if (protectionAbsence === 1) {
+        this.pos -= 2;
+      } else {
+        crcCheck = bitstream.readBits(16);
+      }
+      return {
+        objectType,
+        samplingFrequencyIndex,
+        channelConfiguration,
+        frameLength,
+        numberOfAacFrames,
+        crcCheck,
+        startPos
+      };
+    }
+  };
+
+  // src/adts/adts-demuxer.ts
+  var SAMPLES_PER_AAC_FRAME = 1024;
+  var AdtsDemuxer = class extends Demuxer {
+    constructor(input) {
+      super(input);
+      this.metadataPromise = null;
+      this.firstFrameHeader = null;
+      this.loadedSamples = [];
+      // All samples from the start of the file to lastLoadedPos
+      this.tracks = [];
+      this.readingMutex = new AsyncMutex();
+      this.lastLoadedPos = 0;
+      this.fileSize = 0;
+      this.nextTimestampInSamples = 0;
+      this.reader = new AdtsReader(input._mainReader);
+    }
+    async readMetadata() {
+      return this.metadataPromise ??= (async () => {
+        this.fileSize = await this.input.source.getSize();
+        await this.loadNextChunk();
+        assert(this.firstFrameHeader);
+        this.tracks = [new InputAudioTrack(new AdtsAudioTrackBacking(this))];
+      })();
+    }
+    async loadNextChunk() {
+      assert(this.lastLoadedPos < this.fileSize);
+      const chunkSize = 0.5 * 1024 * 1024;
+      const endPos = Math.min(this.lastLoadedPos + chunkSize, this.fileSize);
+      await this.reader.reader.loadRange(this.lastLoadedPos, endPos);
+      this.lastLoadedPos = endPos;
+      assert(this.lastLoadedPos <= this.fileSize);
+      this.parseFramesFromLoadedData();
+    }
+    parseFramesFromLoadedData() {
+      while (this.reader.pos <= this.fileSize - MAX_FRAME_HEADER_SIZE) {
+        const startPos = this.reader.pos;
+        const header = this.reader.readFrameHeader();
+        if (!header) {
+          break;
+        }
+        if (startPos + header.frameLength > this.lastLoadedPos) {
+          this.reader.pos = startPos;
+          this.lastLoadedPos = startPos;
+          break;
+        }
+        if (!this.firstFrameHeader) {
+          this.firstFrameHeader = header;
+        }
+        const sampleRate = aacFrequencyTable[header.samplingFrequencyIndex];
+        assert(sampleRate !== void 0);
+        const sampleDuration = SAMPLES_PER_AAC_FRAME / sampleRate;
+        const headerSize = header.crcCheck ? MAX_FRAME_HEADER_SIZE : MAX_FRAME_HEADER_SIZE - 2;
+        const sample = {
+          timestamp: this.nextTimestampInSamples / sampleRate,
+          duration: sampleDuration,
+          dataStart: startPos + headerSize,
+          dataSize: header.frameLength - headerSize
+        };
+        this.loadedSamples.push(sample);
+        this.nextTimestampInSamples += SAMPLES_PER_AAC_FRAME;
+        this.reader.pos = startPos + header.frameLength;
+      }
+    }
+    async getMimeType() {
+      return "audio/aac";
+    }
+    async getTracks() {
+      await this.readMetadata();
+      return this.tracks;
+    }
+    async computeDuration() {
+      await this.readMetadata();
+      const track = this.tracks[0];
+      assert(track);
+      return track.computeDuration();
+    }
+  };
+  var AdtsAudioTrackBacking = class {
+    constructor(demuxer) {
+      this.demuxer = demuxer;
+    }
+    getId() {
+      return 1;
+    }
+    async getFirstTimestamp() {
+      return 0;
+    }
+    getTimeResolution() {
+      const sampleRate = this.getSampleRate();
+      return sampleRate / SAMPLES_PER_AAC_FRAME;
+    }
+    async computeDuration() {
+      const lastPacket = await this.getPacket(Infinity, { metadataOnly: true });
+      return (lastPacket?.timestamp ?? 0) + (lastPacket?.duration ?? 0);
+    }
+    getLanguageCode() {
+      return UNDETERMINED_LANGUAGE;
+    }
+    getCodec() {
+      return "aac";
+    }
+    getNumberOfChannels() {
+      assert(this.demuxer.firstFrameHeader);
+      const numberOfChannels = aacChannelMap[this.demuxer.firstFrameHeader.channelConfiguration];
+      assert(numberOfChannels !== void 0);
+      return numberOfChannels;
+    }
+    getSampleRate() {
+      assert(this.demuxer.firstFrameHeader);
+      const sampleRate = aacFrequencyTable[this.demuxer.firstFrameHeader.samplingFrequencyIndex];
+      assert(sampleRate !== void 0);
+      return sampleRate;
+    }
+    async getDecoderConfig() {
+      assert(this.demuxer.firstFrameHeader);
+      const bytes2 = new Uint8Array(3);
+      const bitstream = new Bitstream(bytes2);
+      const { objectType, samplingFrequencyIndex, channelConfiguration } = this.demuxer.firstFrameHeader;
+      if (objectType > 31) {
+        bitstream.writeBits(5, 31);
+        bitstream.writeBits(6, objectType - 32);
+      } else {
+        bitstream.writeBits(5, objectType);
+      }
+      bitstream.writeBits(4, samplingFrequencyIndex);
+      bitstream.writeBits(4, channelConfiguration);
+      return {
+        codec: `mp4a.40.${this.demuxer.firstFrameHeader.objectType}`,
+        numberOfChannels: this.getNumberOfChannels(),
+        sampleRate: this.getSampleRate(),
+        description: bytes2.subarray(0, Math.ceil((bitstream.pos - 1) / 8))
+      };
+    }
+    getPacketAtIndex(sampleIndex, options) {
+      if (sampleIndex === -1) {
+        return null;
+      }
+      const rawSample = this.demuxer.loadedSamples[sampleIndex];
+      if (!rawSample) {
+        return null;
+      }
+      let data;
+      if (options.metadataOnly) {
+        data = PLACEHOLDER_DATA;
+      } else {
+        this.demuxer.reader.pos = rawSample.dataStart;
+        data = this.demuxer.reader.readBytes(rawSample.dataSize);
+      }
+      return new EncodedPacket(
+        data,
+        "key",
+        rawSample.timestamp,
+        rawSample.duration,
+        sampleIndex,
+        rawSample.dataSize
+      );
+    }
+    async getFirstPacket(options) {
+      return this.getPacketAtIndex(0, options);
+    }
+    async getNextPacket(packet, options) {
+      const release = await this.demuxer.readingMutex.acquire();
+      try {
+        const sampleIndex = binarySearchExact(
+          this.demuxer.loadedSamples,
+          packet.timestamp,
+          (x) => x.timestamp
+        );
+        if (sampleIndex === -1) {
+          throw new Error("Packet was not created from this track.");
+        }
+        const nextIndex = sampleIndex + 1;
+        while (nextIndex >= this.demuxer.loadedSamples.length && this.demuxer.lastLoadedPos < this.demuxer.fileSize) {
+          await this.demuxer.loadNextChunk();
+        }
+        return this.getPacketAtIndex(nextIndex, options);
+      } finally {
+        release();
+      }
+    }
+    async getPacket(timestamp, options) {
+      const release = await this.demuxer.readingMutex.acquire();
+      try {
+        while (true) {
+          const index = binarySearchLessOrEqual(
+            this.demuxer.loadedSamples,
+            timestamp,
+            (x) => x.timestamp
+          );
+          if (index === -1 && this.demuxer.loadedSamples.length > 0) {
+            return null;
+          }
+          if (this.demuxer.lastLoadedPos === this.demuxer.fileSize) {
+            return this.getPacketAtIndex(index, options);
+          }
+          if (index >= 0 && index + 1 < this.demuxer.loadedSamples.length) {
+            return this.getPacketAtIndex(index, options);
+          }
+          await this.demuxer.loadNextChunk();
+        }
+      } finally {
+        release();
+      }
+    }
+    getKeyPacket(timestamp, options) {
+      return this.getPacket(timestamp, options);
+    }
+    getNextKeyPacket(packet, options) {
+      return this.getNextPacket(packet, options);
+    }
+  };
+
   // src/input-format.ts
   var InputFormat = class {
   };
@@ -16903,6 +17292,40 @@ ${cue.notes ?? ""}`;
       return "application/ogg";
     }
   };
+  var AdtsInputFormat = class extends InputFormat {
+    /** @internal */
+    async _canReadInput(input) {
+      const sourceSize = await input._mainReader.source.getSize();
+      if (sourceSize < MAX_FRAME_HEADER_SIZE) {
+        return false;
+      }
+      const adtsReader = new AdtsReader(input._mainReader);
+      const firstHeader = adtsReader.readFrameHeader();
+      if (!firstHeader) {
+        return false;
+      }
+      if (sourceSize < firstHeader.frameLength + MAX_FRAME_HEADER_SIZE) {
+        return false;
+      }
+      adtsReader.pos = firstHeader.frameLength;
+      await adtsReader.reader.loadRange(adtsReader.pos, adtsReader.pos + MAX_FRAME_HEADER_SIZE);
+      const secondHeader = adtsReader.readFrameHeader();
+      if (!secondHeader) {
+        return false;
+      }
+      return firstHeader.objectType === secondHeader.objectType && firstHeader.samplingFrequencyIndex === secondHeader.samplingFrequencyIndex && firstHeader.channelConfiguration === secondHeader.channelConfiguration;
+    }
+    /** @internal */
+    _createDemuxer(input) {
+      return new AdtsDemuxer(input);
+    }
+    get name() {
+      return "ADTS";
+    }
+    get mimeType() {
+      return "audio/aac";
+    }
+  };
   var MP4 = new Mp4InputFormat();
   var QTFF = new QuickTimeInputFormat();
   var MATROSKA = new MatroskaInputFormat();
@@ -16910,7 +17333,8 @@ ${cue.notes ?? ""}`;
   var MP3 = new Mp3InputFormat();
   var WAVE = new WaveInputFormat();
   var OGG = new OggInputFormat();
-  var ALL_FORMATS = [MP4, QTFF, MATROSKA, WEBM, WAVE, OGG, MP3];
+  var ADTS = new AdtsInputFormat();
+  var ALL_FORMATS = [MP4, QTFF, MATROSKA, WEBM, WAVE, OGG, MP3, ADTS];
 
   // src/input.ts
   var Input = class {