@kenzuya/mediabunny 1.26.0 → 1.28.5

package/dist/packages/eac3/mediabunny-eac3.js

@@ -0,0 +1,1058 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+// src/misc.ts
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+var toDataView = (source) => {
+  if (source.constructor === DataView) {
+    return source;
+  }
+  if (ArrayBuffer.isView(source)) {
+    return new DataView(source.buffer, source.byteOffset, source.byteLength);
+  }
+  if (typeof SharedArrayBuffer !== "undefined" && source instanceof SharedArrayBuffer) {
+    return new DataView(source);
+  }
+  return new DataView(source);
+};
+var textDecoder = new TextDecoder;
+var textEncoder = new TextEncoder;
+var invertObject = (object) => {
+  return Object.fromEntries(Object.entries(object).map(([key, value]) => [value, key]));
+};
+var COLOR_PRIMARIES_MAP = {
+  bt709: 1,
+  bt470bg: 5,
+  smpte170m: 6,
+  bt2020: 9,
+  smpte432: 12
+};
+var COLOR_PRIMARIES_MAP_INVERSE = invertObject(COLOR_PRIMARIES_MAP);
+var TRANSFER_CHARACTERISTICS_MAP = {
+  bt709: 1,
+  smpte170m: 6,
+  linear: 8,
+  "iec61966-2-1": 13,
+  pq: 16,
+  hlg: 18
+};
+var TRANSFER_CHARACTERISTICS_MAP_INVERSE = invertObject(TRANSFER_CHARACTERISTICS_MAP);
+var MATRIX_COEFFICIENTS_MAP = {
+  rgb: 0,
+  bt709: 1,
+  bt470bg: 5,
+  smpte170m: 6,
+  "bt2020-ncl": 9
+};
+var MATRIX_COEFFICIENTS_MAP_INVERSE = invertObject(MATRIX_COEFFICIENTS_MAP);
+var isAllowSharedBufferSource = (x) => {
+  return x instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && x instanceof SharedArrayBuffer || ArrayBuffer.isView(x);
+};
+
+class AsyncMutex {
+  currentPromise = Promise.resolve();
+  async acquire() {
+    let resolver;
+    const nextPromise = new Promise((resolve) => {
+      resolver = resolve;
+    });
+    const currentPromiseAlias = this.currentPromise;
+    this.currentPromise = nextPromise;
+    await currentPromiseAlias;
+    return resolver;
+  }
+}
+var clamp = (value, min, max) => {
+  return Math.max(min, Math.min(max, value));
+};
+var SECOND_TO_MICROSECOND_FACTOR = 1e6 * (1 + Number.EPSILON);
+class CallSerializer {
+  currentPromise = Promise.resolve();
+  call(fn) {
+    return this.currentPromise = this.currentPromise.then(fn);
+  }
+}
+var polyfillSymbolDispose = () => {
+  Symbol.dispose ??= Symbol("Symbol.dispose");
+};
+
+// src/custom-coder.ts
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+class CustomVideoDecoder {
+  codec;
+  config;
+  onSample;
+  static supports(codec, config) {
+    return false;
+  }
+}
+
+class CustomAudioDecoder {
+  codec;
+  config;
+  onSample;
+  static supports(codec, config) {
+    return false;
+  }
+}
+
+class CustomVideoEncoder {
+  codec;
+  config;
+  onPacket;
+  static supports(codec, config) {
+    return false;
+  }
+}
+
+class CustomAudioEncoder {
+  codec;
+  config;
+  onPacket;
+  static supports(codec, config) {
+    return false;
+  }
+}
+var customVideoDecoders = [];
+var customAudioDecoders = [];
+var customVideoEncoders = [];
+var customAudioEncoders = [];
+var registerDecoder = (decoder) => {
+  if (decoder.prototype instanceof CustomVideoDecoder) {
+    const casted = decoder;
+    if (customVideoDecoders.includes(casted)) {
+      console.warn("Video decoder already registered.");
+      return;
+    }
+    customVideoDecoders.push(casted);
+  } else if (decoder.prototype instanceof CustomAudioDecoder) {
+    const casted = decoder;
+    if (customAudioDecoders.includes(casted)) {
+      console.warn("Audio decoder already registered.");
+      return;
+    }
+    customAudioDecoders.push(casted);
+  } else {
+    throw new TypeError("Decoder must be a CustomVideoDecoder or CustomAudioDecoder.");
+  }
+};
+var registerEncoder = (encoder) => {
+  if (encoder.prototype instanceof CustomVideoEncoder) {
+    const casted = encoder;
+    if (customVideoEncoders.includes(casted)) {
+      console.warn("Video encoder already registered.");
+      return;
+    }
+    customVideoEncoders.push(casted);
+  } else if (encoder.prototype instanceof CustomAudioEncoder) {
+    const casted = encoder;
+    if (customAudioEncoders.includes(casted)) {
+      console.warn("Audio encoder already registered.");
+      return;
+    }
+    customAudioEncoders.push(casted);
+  } else {
+    throw new TypeError("Encoder must be a CustomVideoEncoder or CustomAudioEncoder.");
+  }
+};
+
+// src/packet.ts
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+var PLACEHOLDER_DATA = new Uint8Array(0);
+
+class EncodedPacket {
+  data;
+  type;
+  timestamp;
+  duration;
+  sequenceNumber;
+  byteLength;
+  sideData;
+  constructor(data, type, timestamp, duration, sequenceNumber = -1, byteLength, sideData) {
+    this.data = data;
+    this.type = type;
+    this.timestamp = timestamp;
+    this.duration = duration;
+    this.sequenceNumber = sequenceNumber;
+    if (data === PLACEHOLDER_DATA && byteLength === undefined) {
+      throw new Error("Internal error: byteLength must be explicitly provided when constructing metadata-only packets.");
+    }
+    if (byteLength === undefined) {
+      byteLength = data.byteLength;
+    }
+    if (!(data instanceof Uint8Array)) {
+      throw new TypeError("data must be a Uint8Array.");
+    }
+    if (type !== "key" && type !== "delta") {
+      throw new TypeError('type must be either "key" or "delta".');
+    }
+    if (!Number.isFinite(timestamp)) {
+      throw new TypeError("timestamp must be a number.");
+    }
+    if (!Number.isFinite(duration) || duration < 0) {
+      throw new TypeError("duration must be a non-negative number.");
+    }
+    if (!Number.isFinite(sequenceNumber)) {
+      throw new TypeError("sequenceNumber must be a number.");
+    }
+    if (!Number.isInteger(byteLength) || byteLength < 0) {
+      throw new TypeError("byteLength must be a non-negative integer.");
+    }
+    if (sideData !== undefined && (typeof sideData !== "object" || !sideData)) {
+      throw new TypeError("sideData, when provided, must be an object.");
+    }
+    if (sideData?.alpha !== undefined && !(sideData.alpha instanceof Uint8Array)) {
+      throw new TypeError("sideData.alpha, when provided, must be a Uint8Array.");
+    }
+    if (sideData?.alphaByteLength !== undefined && (!Number.isInteger(sideData.alphaByteLength) || sideData.alphaByteLength < 0)) {
+      throw new TypeError("sideData.alphaByteLength, when provided, must be a non-negative integer.");
+    }
+    this.byteLength = byteLength;
+    this.sideData = sideData ?? {};
+    if (this.sideData.alpha && this.sideData.alphaByteLength === undefined) {
+      this.sideData.alphaByteLength = this.sideData.alpha.byteLength;
+    }
+  }
+  get isMetadataOnly() {
+    return this.data === PLACEHOLDER_DATA;
+  }
+  get microsecondTimestamp() {
+    return Math.trunc(SECOND_TO_MICROSECOND_FACTOR * this.timestamp);
+  }
+  get microsecondDuration() {
+    return Math.trunc(SECOND_TO_MICROSECOND_FACTOR * this.duration);
+  }
+  toEncodedVideoChunk() {
+    if (this.isMetadataOnly) {
+      throw new TypeError("Metadata-only packets cannot be converted to a video chunk.");
+    }
+    if (typeof EncodedVideoChunk === "undefined") {
+      throw new Error("Your browser does not support EncodedVideoChunk.");
+    }
+    return new EncodedVideoChunk({
+      data: this.data,
+      type: this.type,
+      timestamp: this.microsecondTimestamp,
+      duration: this.microsecondDuration
+    });
+  }
+  alphaToEncodedVideoChunk(type = this.type) {
+    if (!this.sideData.alpha) {
+      throw new TypeError("This packet does not contain alpha side data.");
+    }
+    if (this.isMetadataOnly) {
+      throw new TypeError("Metadata-only packets cannot be converted to a video chunk.");
+    }
+    if (typeof EncodedVideoChunk === "undefined") {
+      throw new Error("Your browser does not support EncodedVideoChunk.");
+    }
+    return new EncodedVideoChunk({
+      data: this.sideData.alpha,
+      type,
+      timestamp: this.microsecondTimestamp,
+      duration: this.microsecondDuration
+    });
+  }
+  toEncodedAudioChunk() {
+    if (this.isMetadataOnly) {
+      throw new TypeError("Metadata-only packets cannot be converted to an audio chunk.");
+    }
+    if (typeof EncodedAudioChunk === "undefined") {
+      throw new Error("Your browser does not support EncodedAudioChunk.");
+    }
+    return new EncodedAudioChunk({
+      data: this.data,
+      type: this.type,
+      timestamp: this.microsecondTimestamp,
+      duration: this.microsecondDuration
+    });
+  }
+  static fromEncodedChunk(chunk, sideData) {
+    if (!(chunk instanceof EncodedVideoChunk || chunk instanceof EncodedAudioChunk)) {
+      throw new TypeError("chunk must be an EncodedVideoChunk or EncodedAudioChunk.");
+    }
+    const data = new Uint8Array(chunk.byteLength);
+    chunk.copyTo(data);
+    return new EncodedPacket(data, chunk.type, chunk.timestamp / 1e6, (chunk.duration ?? 0) / 1e6, undefined, undefined, sideData);
+  }
+  clone(options) {
+    if (options !== undefined && (typeof options !== "object" || options === null)) {
+      throw new TypeError("options, when provided, must be an object.");
+    }
+    if (options?.timestamp !== undefined && !Number.isFinite(options.timestamp)) {
+      throw new TypeError("options.timestamp, when provided, must be a number.");
+    }
+    if (options?.duration !== undefined && !Number.isFinite(options.duration)) {
+      throw new TypeError("options.duration, when provided, must be a number.");
+    }
+    return new EncodedPacket(this.data, this.type, options?.timestamp ?? this.timestamp, options?.duration ?? this.duration, this.sequenceNumber, this.byteLength);
+  }
+}
+
+// src/sample.ts
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+polyfillSymbolDispose();
+var lastVideoGcErrorLog = -Infinity;
+var lastAudioGcErrorLog = -Infinity;
+var finalizationRegistry = null;
+if (typeof FinalizationRegistry !== "undefined") {
+  finalizationRegistry = new FinalizationRegistry((value) => {
+    const now = Date.now();
+    if (value.type === "video") {
+      if (now - lastVideoGcErrorLog >= 1000) {
+        console.error(`A VideoSample was garbage collected without first being closed. For proper resource management,` + ` make sure to call close() on all your VideoSamples as soon as you're done using them.`);
+        lastVideoGcErrorLog = now;
+      }
+      if (typeof VideoFrame !== "undefined" && value.data instanceof VideoFrame) {
+        value.data.close();
+      }
+    } else {
+      if (now - lastAudioGcErrorLog >= 1000) {
+        console.error(`An AudioSample was garbage collected without first being closed. For proper resource management,` + ` make sure to call close() on all your AudioSamples as soon as you're done using them.`);
+        lastAudioGcErrorLog = now;
+      }
+      if (typeof AudioData !== "undefined" && value.data instanceof AudioData) {
+        value.data.close();
+      }
+    }
+  });
+}
+var VIDEO_SAMPLE_PIXEL_FORMATS = [
+  "I420",
+  "I420P10",
+  "I420P12",
+  "I420A",
+  "I420AP10",
+  "I420AP12",
+  "I422",
+  "I422P10",
+  "I422P12",
+  "I422A",
+  "I422AP10",
+  "I422AP12",
+  "I444",
+  "I444P10",
+  "I444P12",
+  "I444A",
+  "I444AP10",
+  "I444AP12",
+  "NV12",
+  "RGBA",
+  "RGBX",
+  "BGRA",
+  "BGRX"
+];
+var VIDEO_SAMPLE_PIXEL_FORMATS_SET = new Set(VIDEO_SAMPLE_PIXEL_FORMATS);
+var AUDIO_SAMPLE_FORMATS = new Set([
+  "f32",
+  "f32-planar",
+  "s16",
+  "s16-planar",
+  "s32",
+  "s32-planar",
+  "u8",
+  "u8-planar"
+]);
+
+class AudioSample {
+  _data;
+  _closed = false;
+  format;
+  sampleRate;
+  numberOfFrames;
+  numberOfChannels;
+  duration;
+  timestamp;
+  get microsecondTimestamp() {
+    return Math.trunc(SECOND_TO_MICROSECOND_FACTOR * this.timestamp);
+  }
+  get microsecondDuration() {
+    return Math.trunc(SECOND_TO_MICROSECOND_FACTOR * this.duration);
+  }
+  constructor(init) {
+    if (isAudioData(init)) {
+      if (init.format === null) {
+        throw new TypeError("AudioData with null format is not supported.");
+      }
+      this._data = init;
+      this.format = init.format;
+      this.sampleRate = init.sampleRate;
+      this.numberOfFrames = init.numberOfFrames;
+      this.numberOfChannels = init.numberOfChannels;
+      this.timestamp = init.timestamp / 1e6;
+      this.duration = init.numberOfFrames / init.sampleRate;
+    } else {
+      if (!init || typeof init !== "object") {
+        throw new TypeError("Invalid AudioDataInit: must be an object.");
+      }
+      if (!AUDIO_SAMPLE_FORMATS.has(init.format)) {
+        throw new TypeError("Invalid AudioDataInit: invalid format.");
+      }
+      if (!Number.isFinite(init.sampleRate) || init.sampleRate <= 0) {
+        throw new TypeError("Invalid AudioDataInit: sampleRate must be > 0.");
+      }
+      if (!Number.isInteger(init.numberOfChannels) || init.numberOfChannels === 0) {
+        throw new TypeError("Invalid AudioDataInit: numberOfChannels must be an integer > 0.");
+      }
+      if (!Number.isFinite(init?.timestamp)) {
+        throw new TypeError("init.timestamp must be a number.");
+      }
+      const numberOfFrames = init.data.byteLength / (getBytesPerSample(init.format) * init.numberOfChannels);
+      if (!Number.isInteger(numberOfFrames)) {
+        throw new TypeError("Invalid AudioDataInit: data size is not a multiple of frame size.");
+      }
+      this.format = init.format;
+      this.sampleRate = init.sampleRate;
+      this.numberOfFrames = numberOfFrames;
+      this.numberOfChannels = init.numberOfChannels;
+      this.timestamp = init.timestamp;
+      this.duration = numberOfFrames / init.sampleRate;
+      let dataBuffer;
+      if (init.data instanceof ArrayBuffer) {
+        dataBuffer = new Uint8Array(init.data);
+      } else if (ArrayBuffer.isView(init.data)) {
+        dataBuffer = new Uint8Array(init.data.buffer, init.data.byteOffset, init.data.byteLength);
+      } else {
+        throw new TypeError("Invalid AudioDataInit: data is not a BufferSource.");
+      }
+      const expectedSize = this.numberOfFrames * this.numberOfChannels * getBytesPerSample(this.format);
+      if (dataBuffer.byteLength < expectedSize) {
+        throw new TypeError("Invalid AudioDataInit: insufficient data size.");
+      }
+      this._data = dataBuffer;
+    }
+    finalizationRegistry?.register(this, { type: "audio", data: this._data }, this);
+  }
+  allocationSize(options) {
+    if (!options || typeof options !== "object") {
+      throw new TypeError("options must be an object.");
+    }
+    if (!Number.isInteger(options.planeIndex) || options.planeIndex < 0) {
+      throw new TypeError("planeIndex must be a non-negative integer.");
+    }
+    if (options.format !== undefined && !AUDIO_SAMPLE_FORMATS.has(options.format)) {
+      throw new TypeError("Invalid format.");
+    }
+    if (options.frameOffset !== undefined && (!Number.isInteger(options.frameOffset) || options.frameOffset < 0)) {
+      throw new TypeError("frameOffset must be a non-negative integer.");
+    }
+    if (options.frameCount !== undefined && (!Number.isInteger(options.frameCount) || options.frameCount < 0)) {
+      throw new TypeError("frameCount must be a non-negative integer.");
+    }
+    if (this._closed) {
+      throw new Error("AudioSample is closed.");
+    }
+    const destFormat = options.format ?? this.format;
+    const frameOffset = options.frameOffset ?? 0;
+    if (frameOffset >= this.numberOfFrames) {
+      throw new RangeError("frameOffset out of range");
+    }
+    const copyFrameCount = options.frameCount !== undefined ? options.frameCount : this.numberOfFrames - frameOffset;
+    if (copyFrameCount > this.numberOfFrames - frameOffset) {
+      throw new RangeError("frameCount out of range");
+    }
+    const bytesPerSample = getBytesPerSample(destFormat);
+    const isPlanar = formatIsPlanar(destFormat);
+    if (isPlanar && options.planeIndex >= this.numberOfChannels) {
+      throw new RangeError("planeIndex out of range");
+    }
+    if (!isPlanar && options.planeIndex !== 0) {
+      throw new RangeError("planeIndex out of range");
+    }
+    const elementCount = isPlanar ? copyFrameCount : copyFrameCount * this.numberOfChannels;
+    return elementCount * bytesPerSample;
+  }
+  copyTo(destination, options) {
+    if (!isAllowSharedBufferSource(destination)) {
+      throw new TypeError("destination must be an ArrayBuffer or an ArrayBuffer view.");
+    }
+    if (!options || typeof options !== "object") {
+      throw new TypeError("options must be an object.");
+    }
+    if (!Number.isInteger(options.planeIndex) || options.planeIndex < 0) {
+      throw new TypeError("planeIndex must be a non-negative integer.");
+    }
+    if (options.format !== undefined && !AUDIO_SAMPLE_FORMATS.has(options.format)) {
+      throw new TypeError("Invalid format.");
+    }
+    if (options.frameOffset !== undefined && (!Number.isInteger(options.frameOffset) || options.frameOffset < 0)) {
+      throw new TypeError("frameOffset must be a non-negative integer.");
+    }
+    if (options.frameCount !== undefined && (!Number.isInteger(options.frameCount) || options.frameCount < 0)) {
+      throw new TypeError("frameCount must be a non-negative integer.");
+    }
+    if (this._closed) {
+      throw new Error("AudioSample is closed.");
+    }
+    const { planeIndex, format, frameCount: optFrameCount, frameOffset: optFrameOffset } = options;
+    const destFormat = format ?? this.format;
+    if (!destFormat)
+      throw new Error("Destination format not determined");
+    const numFrames = this.numberOfFrames;
+    const numChannels = this.numberOfChannels;
+    const frameOffset = optFrameOffset ?? 0;
+    if (frameOffset >= numFrames) {
+      throw new RangeError("frameOffset out of range");
+    }
+    const copyFrameCount = optFrameCount !== undefined ? optFrameCount : numFrames - frameOffset;
+    if (copyFrameCount > numFrames - frameOffset) {
+      throw new RangeError("frameCount out of range");
+    }
+    const destBytesPerSample = getBytesPerSample(destFormat);
+    const destIsPlanar = formatIsPlanar(destFormat);
+    if (destIsPlanar && planeIndex >= numChannels) {
+      throw new RangeError("planeIndex out of range");
+    }
+    if (!destIsPlanar && planeIndex !== 0) {
+      throw new RangeError("planeIndex out of range");
+    }
+    const destElementCount = destIsPlanar ? copyFrameCount : copyFrameCount * numChannels;
+    const requiredSize = destElementCount * destBytesPerSample;
+    if (destination.byteLength < requiredSize) {
+      throw new RangeError("Destination buffer is too small");
+    }
+    const destView = toDataView(destination);
+    const writeFn = getWriteFunction(destFormat);
+    if (isAudioData(this._data)) {
+      if (destIsPlanar) {
+        if (destFormat === "f32-planar") {
+          this._data.copyTo(destination, {
+            planeIndex,
+            frameOffset,
+            frameCount: copyFrameCount,
+            format: "f32-planar"
+          });
+        } else {
+          const tempBuffer = new ArrayBuffer(copyFrameCount * 4);
+          const tempArray = new Float32Array(tempBuffer);
+          this._data.copyTo(tempArray, {
+            planeIndex,
+            frameOffset,
+            frameCount: copyFrameCount,
+            format: "f32-planar"
+          });
+          const tempView = new DataView(tempBuffer);
+          for (let i = 0;i < copyFrameCount; i++) {
+            const destOffset = i * destBytesPerSample;
+            const sample = tempView.getFloat32(i * 4, true);
+            writeFn(destView, destOffset, sample);
+          }
+        }
+      } else {
+        const numCh = numChannels;
+        const temp = new Float32Array(copyFrameCount);
+        for (let ch = 0;ch < numCh; ch++) {
+          this._data.copyTo(temp, {
+            planeIndex: ch,
+            frameOffset,
+            frameCount: copyFrameCount,
+            format: "f32-planar"
+          });
+          for (let i = 0;i < copyFrameCount; i++) {
+            const destIndex = i * numCh + ch;
+            const destOffset = destIndex * destBytesPerSample;
+            writeFn(destView, destOffset, temp[i]);
+          }
+        }
+      }
+    } else {
+      const uint8Data = this._data;
+      const srcView = toDataView(uint8Data);
+      const srcFormat = this.format;
+      const readFn = getReadFunction(srcFormat);
+      const srcBytesPerSample = getBytesPerSample(srcFormat);
+      const srcIsPlanar = formatIsPlanar(srcFormat);
+      for (let i = 0;i < copyFrameCount; i++) {
+        if (destIsPlanar) {
+          const destOffset = i * destBytesPerSample;
+          let srcOffset;
+          if (srcIsPlanar) {
+            srcOffset = (planeIndex * numFrames + (i + frameOffset)) * srcBytesPerSample;
+          } else {
+            srcOffset = ((i + frameOffset) * numChannels + planeIndex) * srcBytesPerSample;
+          }
+          const normalized = readFn(srcView, srcOffset);
+          writeFn(destView, destOffset, normalized);
+        } else {
+          for (let ch = 0;ch < numChannels; ch++) {
+            const destIndex = i * numChannels + ch;
+            const destOffset = destIndex * destBytesPerSample;
+            let srcOffset;
+            if (srcIsPlanar) {
+              srcOffset = (ch * numFrames + (i + frameOffset)) * srcBytesPerSample;
+            } else {
+              srcOffset = ((i + frameOffset) * numChannels + ch) * srcBytesPerSample;
+            }
+            const normalized = readFn(srcView, srcOffset);
+            writeFn(destView, destOffset, normalized);
+          }
+        }
+      }
+    }
+  }
+  clone() {
+    if (this._closed) {
+      throw new Error("AudioSample is closed.");
+    }
+    if (isAudioData(this._data)) {
+      const sample = new AudioSample(this._data.clone());
+      sample.setTimestamp(this.timestamp);
+      return sample;
+    }
+    return new AudioSample({
+      format: this.format,
+      sampleRate: this.sampleRate,
+      numberOfFrames: this.numberOfFrames,
+      numberOfChannels: this.numberOfChannels,
+      timestamp: this.timestamp,
+      data: this._data
+    });
+  }
+  close() {
+    if (this._closed) {
+      return;
+    }
+    finalizationRegistry?.unregister(this);
+    if (isAudioData(this._data)) {
+      this._data.close();
+    } else {
+      this._data = new Uint8Array(0);
+    }
+    this._closed = true;
+  }
+  toAudioData() {
+    if (this._closed) {
+      throw new Error("AudioSample is closed.");
+    }
+    if (isAudioData(this._data)) {
+      if (this._data.timestamp === this.microsecondTimestamp) {
+        return this._data.clone();
+      }
+      if (formatIsPlanar(this.format)) {
+        const size = this.allocationSize({
+          planeIndex: 0,
+          format: this.format
+        });
+        const data2 = new ArrayBuffer(size * this.numberOfChannels);
+        for (let i = 0;i < this.numberOfChannels; i++) {
+          this.copyTo(new Uint8Array(data2, i * size, size), {
+            planeIndex: i,
+            format: this.format
+          });
+        }
+        return new AudioData({
+          format: this.format,
+          sampleRate: this.sampleRate,
+          numberOfFrames: this.numberOfFrames,
+          numberOfChannels: this.numberOfChannels,
+          timestamp: this.microsecondTimestamp,
+          data: data2
+        });
+      }
+      const data = new ArrayBuffer(this.allocationSize({ planeIndex: 0, format: this.format }));
+      this.copyTo(data, { planeIndex: 0, format: this.format });
+      return new AudioData({
+        format: this.format,
+        sampleRate: this.sampleRate,
+        numberOfFrames: this.numberOfFrames,
+        numberOfChannels: this.numberOfChannels,
+        timestamp: this.microsecondTimestamp,
+        data
+      });
+    }
+    return new AudioData({
+      format: this.format,
+      sampleRate: this.sampleRate,
+      numberOfFrames: this.numberOfFrames,
+      numberOfChannels: this.numberOfChannels,
+      timestamp: this.microsecondTimestamp,
+      data: this._data.buffer instanceof ArrayBuffer ? this._data.buffer : this._data.slice()
+    });
+  }
+  toAudioBuffer() {
+    if (this._closed) {
+      throw new Error("AudioSample is closed.");
+    }
+    const audioBuffer = new AudioBuffer({
+      numberOfChannels: this.numberOfChannels,
+      length: this.numberOfFrames,
+      sampleRate: this.sampleRate
+    });
+    const dataBytes = new Float32Array(this.allocationSize({ planeIndex: 0, format: "f32-planar" }) / 4);
+    for (let i = 0;i < this.numberOfChannels; i++) {
+      this.copyTo(dataBytes, { planeIndex: i, format: "f32-planar" });
+      audioBuffer.copyToChannel(dataBytes, i);
+    }
+    return audioBuffer;
+  }
+  setTimestamp(newTimestamp) {
+    if (!Number.isFinite(newTimestamp)) {
+      throw new TypeError("newTimestamp must be a number.");
+    }
+    this.timestamp = newTimestamp;
+  }
+  [Symbol.dispose]() {
+    this.close();
+  }
+  static *_fromAudioBuffer(audioBuffer, timestamp) {
+    if (!(audioBuffer instanceof AudioBuffer)) {
+      throw new TypeError("audioBuffer must be an AudioBuffer.");
+    }
+    const MAX_FLOAT_COUNT = 48000 * 5;
+    const numberOfChannels = audioBuffer.numberOfChannels;
+    const sampleRate = audioBuffer.sampleRate;
+    const totalFrames = audioBuffer.length;
+    const maxFramesPerChunk = Math.floor(MAX_FLOAT_COUNT / numberOfChannels);
+    let currentRelativeFrame = 0;
+    let remainingFrames = totalFrames;
+    while (remainingFrames > 0) {
+      const framesToCopy = Math.min(maxFramesPerChunk, remainingFrames);
+      const chunkData = new Float32Array(numberOfChannels * framesToCopy);
+      for (let channel = 0;channel < numberOfChannels; channel++) {
+        audioBuffer.copyFromChannel(chunkData.subarray(channel * framesToCopy, (channel + 1) * framesToCopy), channel, currentRelativeFrame);
+      }
+      yield new AudioSample({
+        format: "f32-planar",
+        sampleRate,
+        numberOfFrames: framesToCopy,
+        numberOfChannels,
+        timestamp: timestamp + currentRelativeFrame / sampleRate,
+        data: chunkData
+      });
+      currentRelativeFrame += framesToCopy;
+      remainingFrames -= framesToCopy;
+    }
+  }
+  static fromAudioBuffer(audioBuffer, timestamp) {
+    if (!(audioBuffer instanceof AudioBuffer)) {
+      throw new TypeError("audioBuffer must be an AudioBuffer.");
+    }
+    const MAX_FLOAT_COUNT = 48000 * 5;
+    const numberOfChannels = audioBuffer.numberOfChannels;
+    const sampleRate = audioBuffer.sampleRate;
+    const totalFrames = audioBuffer.length;
+    const maxFramesPerChunk = Math.floor(MAX_FLOAT_COUNT / numberOfChannels);
+    let currentRelativeFrame = 0;
+    let remainingFrames = totalFrames;
+    const result = [];
+    while (remainingFrames > 0) {
+      const framesToCopy = Math.min(maxFramesPerChunk, remainingFrames);
+      const chunkData = new Float32Array(numberOfChannels * framesToCopy);
+      for (let channel = 0;channel < numberOfChannels; channel++) {
+        audioBuffer.copyFromChannel(chunkData.subarray(channel * framesToCopy, (channel + 1) * framesToCopy), channel, currentRelativeFrame);
+      }
+      const audioSample = new AudioSample({
+        format: "f32-planar",
+        sampleRate,
+        numberOfFrames: framesToCopy,
+        numberOfChannels,
+        timestamp: timestamp + currentRelativeFrame / sampleRate,
+        data: chunkData
+      });
+      result.push(audioSample);
+      currentRelativeFrame += framesToCopy;
+      remainingFrames -= framesToCopy;
+    }
+    return result;
+  }
+}
+var getBytesPerSample = (format) => {
+  switch (format) {
+    case "u8":
+    case "u8-planar":
+      return 1;
+    case "s16":
+    case "s16-planar":
+      return 2;
+    case "s32":
+    case "s32-planar":
+      return 4;
+    case "f32":
+    case "f32-planar":
+      return 4;
+    default:
+      throw new Error("Unknown AudioSampleFormat");
+  }
+};
+var formatIsPlanar = (format) => {
+  switch (format) {
+    case "u8-planar":
+    case "s16-planar":
+    case "s32-planar":
+    case "f32-planar":
+      return true;
+    default:
+      return false;
+  }
+};
+var getReadFunction = (format) => {
+  switch (format) {
+    case "u8":
+    case "u8-planar":
+      return (view, offset) => (view.getUint8(offset) - 128) / 128;
+    case "s16":
+    case "s16-planar":
+      return (view, offset) => view.getInt16(offset, true) / 32768;
+    case "s32":
+    case "s32-planar":
+      return (view, offset) => view.getInt32(offset, true) / 2147483648;
+    case "f32":
+    case "f32-planar":
+      return (view, offset) => view.getFloat32(offset, true);
+  }
+};
+var getWriteFunction = (format) => {
+  switch (format) {
+    case "u8":
+    case "u8-planar":
+      return (view, offset, value) => view.setUint8(offset, clamp((value + 1) * 127.5, 0, 255));
+    case "s16":
+    case "s16-planar":
+      return (view, offset, value) => view.setInt16(offset, clamp(Math.round(value * 32767), -32768, 32767), true);
+    case "s32":
+    case "s32-planar":
+      return (view, offset, value) => view.setInt32(offset, clamp(Math.round(value * 2147483647), -2147483648, 2147483647), true);
+    case "f32":
+    case "f32-planar":
+      return (view, offset, value) => view.setFloat32(offset, value, true);
+  }
+};
+var isAudioData = (x) => {
+  return typeof AudioData !== "undefined" && x instanceof AudioData;
+};
+// src/index.ts
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+// packages/eac3/src/index.ts
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors (Wiedy Mi)
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+var decodeWorkerUrl = new URL("./decode.worker.ts", import.meta.url);
+var encodeWorkerUrl = new URL("./encode.worker.ts", import.meta.url);
+var createWorker = (url) => {
+  return new Worker(url, { type: "module" });
+};
+var AV_CODEC_ID_AC3 = 86019;
+var AV_CODEC_ID_EAC3 = 86056;
+
+class Eac3Decoder extends CustomAudioDecoder {
+  worker = null;
+  nextMessageId = 0;
+  pendingMessages = new Map;
+  static supports(codec, _config) {
+    return codec === "eac3" || codec === "ac3";
+  }
+  async init() {
+    this.worker = createWorker(decodeWorkerUrl);
+    const onMessage = (event) => {
+      const data = event.data;
+      const pending = this.pendingMessages.get(data.id);
+      assert2(pending !== undefined);
+      this.pendingMessages.delete(data.id);
+      if (data.success) {
+        pending.resolve(data.data);
+      } else {
+        pending.reject(data.error);
+      }
+    };
+    this.worker.addEventListener("message", onMessage);
+    await this.sendCommand({
+      type: "init",
+      data: {
+        sampleRate: this.config.sampleRate,
+        channels: this.config.numberOfChannels,
+        codec: this.codec
+      }
+    });
+  }
+  async decode(packet) {
+    const packetData = packet.data.slice().buffer;
+    const result = await this.sendCommand({
+      type: "decode",
+      data: { packetData }
+    }, [packetData]);
+    if (!result || !("pcmData" in result)) {
+      return;
+    }
+    const audioSample = new AudioSample({
+      data: new Float32Array(result.pcmData),
+      format: "f32",
+      numberOfChannels: result.channels,
+      sampleRate: result.sampleRate,
+      timestamp: packet.timestamp
+    });
+    this.onSample(audioSample);
+  }
+  async flush() {
+    await this.sendCommand({ type: "flush" });
+  }
+  close() {
+    if (this.worker) {
+      this.sendCommand({ type: "close" });
+      this.worker.terminate();
+    }
+  }
+  sendCommand(command, transferables) {
+    return new Promise((resolve, reject) => {
+      const id = this.nextMessageId++;
+      this.pendingMessages.set(id, { resolve, reject });
+      assert2(this.worker);
+      if (transferables) {
+        this.worker.postMessage({ id, command }, transferables);
+      } else {
+        this.worker.postMessage({ id, command });
+      }
+    });
+  }
+}
+
+class Eac3Encoder extends CustomAudioEncoder {
+  worker = null;
+  nextMessageId = 0;
+  pendingMessages = new Map;
+  currentTimestamp = 0;
+  chunkMetadata = {};
+  static supports(codec, _config) {
+    return codec === "eac3" || codec === "ac3";
+  }
+  async init() {
+    this.worker = createWorker(encodeWorkerUrl);
+    const onMessage = (event) => {
+      const data = event.data;
+      const pending = this.pendingMessages.get(data.id);
+      assert2(pending !== undefined);
+      this.pendingMessages.delete(data.id);
+      if (data.success) {
+        pending.resolve(data.data);
+      } else {
+        pending.reject(data.error);
+      }
+    };
+    this.worker.addEventListener("message", onMessage);
+    assert2(this.config.bitrate);
+    await this.sendCommand({
+      type: "init",
+      data: {
+        sampleRate: this.config.sampleRate,
+        channels: this.config.numberOfChannels,
+        bitrate: this.config.bitrate,
+        codec: this.codec
+      }
+    });
+    this.chunkMetadata = {
+      decoderConfig: {
+        codec: this.codec === "eac3" ? "ec-3" : "ac3",
+        numberOfChannels: this.config.numberOfChannels,
+        sampleRate: this.config.sampleRate
+      }
+    };
+  }
+  async encode(audioSample) {
+    const sizePerChannel = audioSample.allocationSize({
+      format: "f32-planar",
+      planeIndex: 0
+    });
+    const requiredBytes = audioSample.numberOfChannels * sizePerChannel;
+    const audioData = new ArrayBuffer(requiredBytes);
+    const audioBytes = new Uint8Array(audioData);
+    for (let i = 0;i < audioSample.numberOfChannels; i++) {
+      audioSample.copyTo(audioBytes.subarray(i * sizePerChannel), {
+        format: "f32-planar",
+        planeIndex: i
+      });
+    }
+    const result = await this.sendCommand({
+      type: "encode",
+      data: {
+        pcmData: audioData,
+        numberOfFrames: audioSample.numberOfFrames
+      }
+    }, [audioData]);
+    assert2(result && "encodedData" in result);
+    const duration = audioSample.numberOfFrames / this.config.sampleRate;
+    const encodedPacket = new EncodedPacket(new Uint8Array(result.encodedData), "key", this.currentTimestamp, duration);
+    this.onPacket(encodedPacket, this.currentTimestamp === 0 ? this.chunkMetadata : undefined);
+    if (this.currentTimestamp === 0) {
+      this.chunkMetadata = {};
+    }
+    this.currentTimestamp += duration;
+  }
+  async flush() {
+    await this.sendCommand({ type: "flush" });
+  }
+  close() {
+    if (this.worker) {
+      this.sendCommand({ type: "close" });
+      this.worker.terminate();
+    }
+  }
+  sendCommand(command, transferables) {
+    return new Promise((resolve, reject) => {
+      const id = this.nextMessageId++;
+      this.pendingMessages.set(id, { resolve, reject });
+      assert2(this.worker);
+      if (transferables) {
+        this.worker.postMessage({ id, command }, transferables);
+      } else {
+        this.worker.postMessage({ id, command });
+      }
+    });
+  }
+}
+var registerEac3Decoder = () => {
+  registerDecoder(Eac3Decoder);
+};
+var registerEac3Encoder = () => {
+  registerEncoder(Eac3Encoder);
+};
+function assert2(x) {
+  if (!x) {
+    throw new Error("Assertion failed.");
+  }
+}
+export {
+  registerEac3Encoder,
+  registerEac3Decoder,
+  AV_CODEC_ID_EAC3,
+  AV_CODEC_ID_AC3
+};