@mediabunny/server 1.45.0

package/dist/bundles/mediabunny-server.cjs

@@ -0,0 +1,3361 @@
+/*!
+ * Copyright (c) 2026-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/.
+ */
+"use strict";
+var MediabunnyServer = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined") return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // packages/server/src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    AvFrameAudioSampleResource: () => AvFrameAudioSampleResource,
+    AvFrameVideoSampleResource: () => AvFrameVideoSampleResource,
+    registerMediabunnyServer: () => registerMediabunnyServer,
+    toAvFrame: () => toAvFrame
+  });
+  var import_mediabunny7 = __require("mediabunny");
+  var NodeAv8 = __toESM(__require("node-av"));
+
+  // packages/server/src/video-decoder.ts
+  var import_mediabunny2 = __require("mediabunny");
+  var NodeAv3 = __toESM(__require("node-av"));
+
+  // packages/server/src/misc.ts
+  var NodeAv = __toESM(__require("node-av"));
+  var CODEC_TO_CODEC_ID = {
+    avc: NodeAv.AV_CODEC_ID_H264,
+    hevc: NodeAv.AV_CODEC_ID_HEVC,
+    vp8: NodeAv.AV_CODEC_ID_VP8,
+    vp9: NodeAv.AV_CODEC_ID_VP9,
+    av1: NodeAv.AV_CODEC_ID_AV1,
+    aac: NodeAv.AV_CODEC_ID_AAC,
+    opus: NodeAv.AV_CODEC_ID_OPUS,
+    mp3: NodeAv.AV_CODEC_ID_MP3,
+    vorbis: NodeAv.AV_CODEC_ID_VORBIS,
+    flac: NodeAv.AV_CODEC_ID_FLAC,
+    ac3: NodeAv.AV_CODEC_ID_AC3,
+    eac3: NodeAv.AV_CODEC_ID_EAC3
+  };
+  var cachedHardwareContext = void 0;
+  var getHardwareContext = () => {
+    if (cachedHardwareContext === void 0) {
+      cachedHardwareContext = NodeAv.HardwareContext.auto();
+    }
+    return cachedHardwareContext;
+  };
+  var hardwareDecoderCodecCache = /* @__PURE__ */ new Map();
+  var getHardwareDecoderCodec = (codecId) => {
+    if (!hardwareDecoderCodecCache.has(codecId)) {
+      const hw = getHardwareContext();
+      hardwareDecoderCodecCache.set(codecId, hw?.getDecoderCodec(codecId) ?? null);
+    }
+    return hardwareDecoderCodecCache.get(codecId);
+  };
+  var hardwareEncoderCodecCache = /* @__PURE__ */ new Map();
+  var getHardwareEncoderCodec = (codecId) => {
+    if (!hardwareEncoderCodecCache.has(codecId)) {
+      const hw = getHardwareContext();
+      hardwareEncoderCodecCache.set(codecId, hw?.getEncoderCodec(codecId) ?? null);
+    }
+    return hardwareEncoderCodecCache.get(codecId);
+  };
+  var mapColorPrimaries = (primaries) => {
+    switch (primaries) {
+      case "bt709":
+        return NodeAv.AVCOL_PRI_BT709;
+      case "bt470bg":
+        return NodeAv.AVCOL_PRI_BT470BG;
+      case "smpte170m":
+        return NodeAv.AVCOL_PRI_SMPTE170M;
+      case "bt2020":
+        return NodeAv.AVCOL_PRI_BT2020;
+      case "smpte432":
+        return NodeAv.AVCOL_PRI_SMPTE432;
+    }
+    return null;
+  };
+  var unmapColorPrimaries = (primaries) => {
+    switch (primaries) {
+      case NodeAv.AVCOL_PRI_BT709:
+        return "bt709";
+      case NodeAv.AVCOL_PRI_BT470BG:
+        return "bt470bg";
+      case NodeAv.AVCOL_PRI_SMPTE170M:
+        return "smpte170m";
+      case NodeAv.AVCOL_PRI_BT2020:
+        return "bt2020";
+      case NodeAv.AVCOL_PRI_SMPTE432:
+        return "smpte432";
+    }
+    return null;
+  };
+  var mapTransferCharacteristics = (transfer) => {
+    switch (transfer) {
+      case "bt709":
+        return NodeAv.AVCOL_TRC_BT709;
+      case "smpte170m":
+        return NodeAv.AVCOL_TRC_SMPTE170M;
+      case "iec61966-2-1":
+        return NodeAv.AVCOL_TRC_IEC61966_2_1;
+      case "linear":
+        return NodeAv.AVCOL_TRC_LINEAR;
+      case "pq":
+        return NodeAv.AVCOL_TRC_SMPTE2084;
+      case "hlg":
+        return NodeAv.AVCOL_TRC_ARIB_STD_B67;
+    }
+    return null;
+  };
+  var unmapTransferCharacteristics = (transfer) => {
+    switch (transfer) {
+      case NodeAv.AVCOL_TRC_BT709:
+        return "bt709";
+      case NodeAv.AVCOL_TRC_SMPTE170M:
+        return "smpte170m";
+      case NodeAv.AVCOL_TRC_IEC61966_2_1:
+        return "iec61966-2-1";
+      case NodeAv.AVCOL_TRC_LINEAR:
+        return "linear";
+      case NodeAv.AVCOL_TRC_SMPTE2084:
+        return "pq";
+      case NodeAv.AVCOL_TRC_ARIB_STD_B67:
+        return "hlg";
+    }
+    return null;
+  };
+  var mapMatrixCoefficients = (matrix) => {
+    switch (matrix) {
+      case "rgb":
+        return NodeAv.AVCOL_SPC_RGB;
+      case "bt709":
+        return NodeAv.AVCOL_SPC_BT709;
+      case "bt470bg":
+        return NodeAv.AVCOL_SPC_BT470BG;
+      case "smpte170m":
+        return NodeAv.AVCOL_SPC_SMPTE170M;
+      case "bt2020-ncl":
+        return NodeAv.AVCOL_SPC_BT2020_NCL;
+    }
+    return null;
+  };
+  var unmapMatrixCoefficients = (matrix) => {
+    switch (matrix) {
+      case NodeAv.AVCOL_SPC_RGB:
+        return "rgb";
+      case NodeAv.AVCOL_SPC_BT709:
+        return "bt709";
+      case NodeAv.AVCOL_SPC_BT470BG:
+        return "bt470bg";
+      case NodeAv.AVCOL_SPC_SMPTE170M:
+        return "smpte170m";
+      case NodeAv.AVCOL_SPC_BT2020_NCL:
+        return "bt2020-ncl";
+    }
+    return null;
+  };
+  var toPixelFormat = (ffmpegPixelFormat) => {
+    switch (ffmpegPixelFormat) {
+      case NodeAv.AV_PIX_FMT_YUV420P:
+        return "I420";
+      // "deprecated in favor of AV_PIX_FMT_YUV420P and setting color_range"
+      case NodeAv.AV_PIX_FMT_YUVJ420P:
+        return "I420";
+      case NodeAv.AV_PIX_FMT_YUV420P10LE:
+        return "I420P10";
+      case NodeAv.AV_PIX_FMT_YUV420P12LE:
+        return "I420P12";
+      case NodeAv.AV_PIX_FMT_YUVA420P:
+        return "I420A";
+      case NodeAv.AV_PIX_FMT_YUVA420P10LE:
+        return "I420AP10";
+      case NodeAv.AV_PIX_FMT_YUV422P:
+        return "I422";
+      // "deprecated in favor of AV_PIX_FMT_YUV422P and setting color_range"
+      case NodeAv.AV_PIX_FMT_YUVJ422P:
+        return "I422";
+      case NodeAv.AV_PIX_FMT_YUV422P10LE:
+        return "I422P10";
+      case NodeAv.AV_PIX_FMT_YUV422P12LE:
+        return "I422P12";
+      case NodeAv.AV_PIX_FMT_YUVA422P:
+        return "I422A";
+      case NodeAv.AV_PIX_FMT_YUVA422P10LE:
+        return "I422AP10";
+      case NodeAv.AV_PIX_FMT_YUVA422P12LE:
+        return "I422AP12";
+      case NodeAv.AV_PIX_FMT_YUV444P:
+        return "I444";
+      // "deprecated in favor of AV_PIX_FMT_YUV444P and setting color_range"
+      case NodeAv.AV_PIX_FMT_YUVJ444P:
+        return "I444";
+      case NodeAv.AV_PIX_FMT_YUV444P10LE:
+        return "I444P10";
+      case NodeAv.AV_PIX_FMT_YUV444P12LE:
+        return "I444P12";
+      case NodeAv.AV_PIX_FMT_YUVA444P:
+        return "I444A";
+      case NodeAv.AV_PIX_FMT_YUVA444P10LE:
+        return "I444AP10";
+      case NodeAv.AV_PIX_FMT_YUVA444P12LE:
+        return "I444AP12";
+      case NodeAv.AV_PIX_FMT_NV12:
+        return "NV12";
+      case NodeAv.AV_PIX_FMT_RGBA:
+        return "RGBA";
+      case NodeAv.AV_PIX_FMT_RGB0:
+        return "RGBX";
+      case NodeAv.AV_PIX_FMT_BGRA:
+        return "BGRA";
+      case NodeAv.AV_PIX_FMT_BGR0:
+        return "BGRX";
+      default:
+        return null;
+    }
+  };
+  var fromPixelFormat = (pixelFormat) => {
+    switch (pixelFormat) {
+      case "I420":
+        return NodeAv.AV_PIX_FMT_YUV420P;
+      case "I420P10":
+        return NodeAv.AV_PIX_FMT_YUV420P10LE;
+      case "I420P12":
+        return NodeAv.AV_PIX_FMT_YUV420P12LE;
+      case "I420A":
+        return NodeAv.AV_PIX_FMT_YUVA420P;
+      case "I420AP10":
+        return NodeAv.AV_PIX_FMT_YUVA420P10LE;
+      case "I422":
+        return NodeAv.AV_PIX_FMT_YUV422P;
+      case "I422P10":
+        return NodeAv.AV_PIX_FMT_YUV422P10LE;
+      case "I422P12":
+        return NodeAv.AV_PIX_FMT_YUV422P12LE;
+      case "I422A":
+        return NodeAv.AV_PIX_FMT_YUVA422P;
+      case "I422AP10":
+        return NodeAv.AV_PIX_FMT_YUVA422P10LE;
+      case "I422AP12":
+        return NodeAv.AV_PIX_FMT_YUVA422P12LE;
+      case "I444":
+        return NodeAv.AV_PIX_FMT_YUV444P;
+      case "I444P10":
+        return NodeAv.AV_PIX_FMT_YUV444P10LE;
+      case "I444P12":
+        return NodeAv.AV_PIX_FMT_YUV444P12LE;
+      case "I444A":
+        return NodeAv.AV_PIX_FMT_YUVA444P;
+      case "I444AP10":
+        return NodeAv.AV_PIX_FMT_YUVA444P10LE;
+      case "I444AP12":
+        return NodeAv.AV_PIX_FMT_YUVA444P12LE;
+      case "NV12":
+        return NodeAv.AV_PIX_FMT_NV12;
+      case "RGBA":
+        return NodeAv.AV_PIX_FMT_RGBA;
+      case "RGBX":
+        return NodeAv.AV_PIX_FMT_RGB0;
+      case "BGRA":
+        return NodeAv.AV_PIX_FMT_BGRA;
+      case "BGRX":
+        return NodeAv.AV_PIX_FMT_BGR0;
+      default:
+        return NodeAv.AV_PIX_FMT_NONE;
+    }
+  };
+  var toAudioSampleFormat = (ffmpegSampleFormat) => {
+    switch (ffmpegSampleFormat) {
+      case NodeAv.AV_SAMPLE_FMT_U8:
+        return "u8";
+      case NodeAv.AV_SAMPLE_FMT_S16:
+        return "s16";
+      case NodeAv.AV_SAMPLE_FMT_S32:
+        return "s32";
+      case NodeAv.AV_SAMPLE_FMT_FLT:
+        return "f32";
+      case NodeAv.AV_SAMPLE_FMT_U8P:
+        return "u8-planar";
+      case NodeAv.AV_SAMPLE_FMT_S16P:
+        return "s16-planar";
+      case NodeAv.AV_SAMPLE_FMT_S32P:
+        return "s32-planar";
+      case NodeAv.AV_SAMPLE_FMT_FLTP:
+        return "f32-planar";
+      default:
+        return null;
+    }
+  };
+  var fromAudioSampleFormat = (sampleFormat) => {
+    switch (sampleFormat) {
+      case "u8":
+        return NodeAv.AV_SAMPLE_FMT_U8;
+      case "s16":
+        return NodeAv.AV_SAMPLE_FMT_S16;
+      case "s32":
+        return NodeAv.AV_SAMPLE_FMT_S32;
+      case "f32":
+        return NodeAv.AV_SAMPLE_FMT_FLT;
+      case "u8-planar":
+        return NodeAv.AV_SAMPLE_FMT_U8P;
+      case "s16-planar":
+        return NodeAv.AV_SAMPLE_FMT_S16P;
+      case "s32-planar":
+        return NodeAv.AV_SAMPLE_FMT_S32P;
+      case "f32-planar":
+        return NodeAv.AV_SAMPLE_FMT_FLTP;
+      default:
+        return NodeAv.AV_SAMPLE_FMT_NONE;
+    }
+  };
+  var getChannelLayout = (numChannels) => {
+    switch (numChannels) {
+      case 1:
+        return NodeAv.AV_CHANNEL_LAYOUT_MONO;
+      case 2:
+        return NodeAv.AV_CHANNEL_LAYOUT_STEREO;
+      case 4:
+        return NodeAv.AV_CHANNEL_LAYOUT_QUAD;
+      case 6:
+        return NodeAv.AV_CHANNEL_LAYOUT_5POINT1_BACK;
+      case 8:
+        return NodeAv.AV_CHANNEL_LAYOUT_7POINT1;
+      default:
+        return { nbChannels: numChannels, order: NodeAv.AV_CHANNEL_ORDER_UNSPEC, mask: 0n };
+    }
+  };
+  var LIBVPX_VP9 = "libvpx-vp9";
+
+  // src/misc.ts
+  function assert(x) {
+    if (!x) {
+      throw new Error("Assertion failed.");
+    }
+  }
+  var last = (arr) => {
+    return arr && arr[arr.length - 1];
+  };
+  var readExpGolomb = (bitstream) => {
+    let leadingZeroBits = 0;
+    while (bitstream.readBits(1) === 0 && leadingZeroBits < 32) {
+      leadingZeroBits++;
+    }
+    if (leadingZeroBits >= 32) {
+      throw new Error("Invalid exponential-Golomb code.");
+    }
+    const result = (1 << leadingZeroBits) - 1 + bitstream.readBits(leadingZeroBits);
+    return result;
+  };
+  var readSignedExpGolomb = (bitstream) => {
+    const codeNum = readExpGolomb(bitstream);
+    return (codeNum & 1) === 0 ? -(codeNum >> 1) : codeNum + 1 >> 1;
+  };
+  var toUint8Array = (source) => {
+    if (source.constructor === Uint8Array) {
+      return source;
+    } else if (ArrayBuffer.isView(source)) {
+      return new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    } else {
+      return new Uint8Array(source);
+    }
+  };
+  var toDataView = (source) => {
+    if (source.constructor === DataView) {
+      return source;
+    } else if (ArrayBuffer.isView(source)) {
+      return new DataView(source.buffer, source.byteOffset, source.byteLength);
+    } else {
+      return new DataView(source);
+    }
+  };
+  var COLOR_PRIMARIES_MAP = {
+    bt709: 1,
+    // ITU-R BT.709
+    bt470bg: 5,
+    // ITU-R BT.470BG
+    smpte170m: 6,
+    // ITU-R BT.601 525 - SMPTE 170M
+    bt2020: 9,
+    // ITU-R BT.202
+    smpte432: 12
+    // SMPTE EG 432-1
+  };
+  var TRANSFER_CHARACTERISTICS_MAP = {
+    "bt709": 1,
+    // ITU-R BT.709
+    "smpte170m": 6,
+    // SMPTE 170M
+    "linear": 8,
+    // Linear transfer characteristics
+    "iec61966-2-1": 13,
+    // IEC 61966-2-1
+    "pq": 16,
+    // Rec. ITU-R BT.2100-2 perceptual quantization (PQ) system
+    "hlg": 18
+    // Rec. ITU-R BT.2100-2 hybrid loggamma (HLG) system
+  };
+  var MATRIX_COEFFICIENTS_MAP = {
+    "rgb": 0,
+    // Identity
+    "bt709": 1,
+    // ITU-R BT.709
+    "bt470bg": 5,
+    // ITU-R BT.470BG
+    "smpte170m": 6,
+    // SMPTE 170M
+    "bt2020-ncl": 9
+    // ITU-R BT.2020-2 (non-constant luminance)
+  };
+  var bytesToHexString = (bytes) => {
+    return [...bytes].map((x) => x.toString(16).padStart(2, "0")).join("");
+  };
+  var reverseBitsU32 = (x) => {
+    x = x >> 1 & 1431655765 | (x & 1431655765) << 1;
+    x = x >> 2 & 858993459 | (x & 858993459) << 2;
+    x = x >> 4 & 252645135 | (x & 252645135) << 4;
+    x = x >> 8 & 16711935 | (x & 16711935) << 8;
+    x = x >> 16 & 65535 | (x & 65535) << 16;
+    return x >>> 0;
+  };
+  var binarySearchLessOrEqual = (arr, key, valueGetter) => {
+    let low = 0;
+    let high = arr.length - 1;
+    let ans = -1;
+    while (low <= high) {
+      const mid = low + (high - low + 1) / 2 | 0;
+      const midVal = valueGetter(arr[mid]);
+      if (midVal <= key) {
+        ans = mid;
+        low = mid + 1;
+      } else {
+        high = mid - 1;
+      }
+    }
+    return ans;
+  };
+  var SECOND_TO_MICROSECOND_FACTOR = 1e6 * (1 + Number.EPSILON);
+  var simplifyRational = (rational) => {
+    assert(Number.isInteger(rational.num));
+    assert(Number.isInteger(rational.den));
+    assert(rational.den !== 0);
+    let a = Math.abs(rational.num);
+    let b = Math.abs(rational.den);
+    while (b !== 0) {
+      const t = a % b;
+      a = b;
+      b = t;
+    }
+    const gcd = a || 1;
+    return {
+      num: rational.num / gcd,
+      den: rational.den / gcd
+    };
+  };
+
+  // packages/server/src/video-sample.ts
+  var import_mediabunny = __require("mediabunny");
+  var NodeAv2 = __toESM(__require("node-av"));
+  var JPEG_RANGE_PIX_FORMATS = /* @__PURE__ */ new Set([
+    NodeAv2.AV_PIX_FMT_YUVJ411P,
+    NodeAv2.AV_PIX_FMT_YUVJ420P,
+    NodeAv2.AV_PIX_FMT_YUVJ422P,
+    NodeAv2.AV_PIX_FMT_YUVJ440P,
+    NodeAv2.AV_PIX_FMT_YUVJ444P
+  ]);
+  var AvFrameVideoSampleResource = class _AvFrameVideoSampleResource extends import_mediabunny.VideoSampleResource {
+    /**
+     * The NodeAV [`Frame`](https://seydx.github.io/node-av/api/lib/classes/Frame.html) instance backing this resource.
+     * Access throws if the resource has already been closed.
+     */
+    get frame() {
+      if (!this._frame) {
+        throw new Error("AvFrameVideoSampleResource has been closed.");
+      }
+      return this._frame;
+    }
+    constructor(frame) {
+      super();
+      if (frame.getMediaType() !== NodeAv2.AVMEDIA_TYPE_VIDEO) {
+        throw new Error("AvFrameVideoSampleResource must be initialized with a video frame.");
+      }
+      this._frame = frame;
+    }
+    getFormat() {
+      return toPixelFormat(this.frame.format);
+    }
+    getCodedWidth() {
+      return this.frame.width;
+    }
+    getCodedHeight() {
+      return this.frame.height;
+    }
+    getSquarePixelWidth() {
+      if (this.frame.sampleAspectRatio.num > this.frame.sampleAspectRatio.den) {
+        return Math.round(this.frame.width * this.frame.sampleAspectRatio.num / this.frame.sampleAspectRatio.den);
+      } else {
+        return this.frame.width;
+      }
+    }
+    getSquarePixelHeight() {
+      if (this.frame.sampleAspectRatio.num > this.frame.sampleAspectRatio.den) {
+        return this.frame.height;
+      } else {
+        return Math.round(this.frame.height * this.frame.sampleAspectRatio.den / this.frame.sampleAspectRatio.num);
+      }
+    }
+    getColorSpace() {
+      return new import_mediabunny.VideoSampleColorSpace({
+        primaries: unmapColorPrimaries(this.frame.colorPrimaries),
+        transfer: unmapTransferCharacteristics(this.frame.colorTrc),
+        matrix: unmapMatrixCoefficients(this.frame.colorSpace),
+        fullRange: this.frame.colorRange === NodeAv2.AVCOL_RANGE_JPEG || JPEG_RANGE_PIX_FORMATS.has(this.frame.format) ? true : this.frame.colorRange === NodeAv2.AVCOL_RANGE_MPEG ? false : null
+      });
+    }
+    close() {
+      this.frame.free();
+      this._frame = null;
+    }
+    getDataPlanes() {
+      assert(this.frame.data);
+      return this.frame.data.map((data, i) => ({
+        data: toUint8Array(data),
+        stride: this.frame.linesize[i]
+      }));
+    }
+    async toRgbSample(init, colorSpace) {
+      const width = this.frame.width;
+      const height = this.frame.height;
+      const scaler = new NodeAv2.SoftwareScaleContext();
+      const srcFmt = this.frame.format;
+      const dstFmt = fromPixelFormat("RGBA");
+      scaler.getContext(
+        width,
+        height,
+        srcFmt,
+        width,
+        height,
+        dstFmt,
+        NodeAv2.SWS_BILINEAR
+      );
+      const dstFrame = new NodeAv2.Frame();
+      dstFrame.width = width;
+      dstFrame.height = height;
+      dstFrame.format = dstFmt;
+      dstFrame.alloc();
+      dstFrame.allocBuffer();
+      const srcFrame = this.frame;
+      try {
+        await scaler.scaleFrame(dstFrame, srcFrame);
+      } finally {
+        scaler.freeContext();
+      }
+      dstFrame.sampleAspectRatio = srcFrame.sampleAspectRatio;
+      return new import_mediabunny.VideoSample(new _AvFrameVideoSampleResource(dstFrame), init);
+    }
+  };
+  var copyVideoSampleToAvFrame = async (sample, frame, lastBuffer) => {
+    assert(sample.format !== null);
+    frame.format = fromPixelFormat(sample.format);
+    frame.width = sample.codedWidth;
+    frame.height = sample.codedHeight;
+    frame.sampleAspectRatio = new NodeAv2.Rational(
+      sample.pixelAspectRatio.num,
+      sample.pixelAspectRatio.den
+    );
+    frame.colorPrimaries = mapColorPrimaries(sample.colorSpace.primaries ?? "unknown") ?? NodeAv2.AVCOL_PRI_UNSPECIFIED;
+    frame.colorSpace = mapMatrixCoefficients(sample.colorSpace.matrix ?? "unknown") ?? NodeAv2.AVCOL_SPC_UNSPECIFIED;
+    frame.colorTrc = mapTransferCharacteristics(sample.colorSpace.transfer ?? "unknown") ?? NodeAv2.AVCOL_TRC_UNSPECIFIED;
+    frame.colorRange = sample.colorSpace.fullRange === false ? NodeAv2.AVCOL_RANGE_MPEG : sample.colorSpace.fullRange === true ? NodeAv2.AVCOL_RANGE_JPEG : NodeAv2.AVCOL_RANGE_UNSPECIFIED;
+    const size = sample.allocationSize();
+    if (!lastBuffer || lastBuffer.byteLength !== size) {
+      lastBuffer = Buffer.from({ length: size });
+    }
+    await sample.copyTo(lastBuffer);
+    frame.fromBuffer(lastBuffer);
+    return lastBuffer;
+  };
+  var transformVideoSample = async (sample, description) => {
+    let srcFrame;
+    let srcFrameOwned = false;
+    if (sample._data instanceof AvFrameVideoSampleResource) {
+      srcFrame = sample._data.frame;
+    } else {
+      if (sample.format === null) {
+        return null;
+      }
+      srcFrame = new NodeAv2.Frame();
+      srcFrame.alloc();
+      srcFrameOwned = true;
+      await copyVideoSampleToAvFrame(sample, srcFrame, null);
+    }
+    const chain = [];
+    if (sample.squarePixelWidth !== sample.codedWidth || sample.squarePixelHeight !== sample.codedHeight) {
+      chain.push(`scale=${sample.squarePixelWidth}:${sample.squarePixelHeight}`);
+      chain.push("setsar=1");
+    }
+    if (description.rotation === 90) {
+      chain.push("transpose=1");
+    } else if (description.rotation === 180) {
+      chain.push("transpose=1,transpose=1");
+    } else if (description.rotation === 270) {
+      chain.push("transpose=2");
+    }
+    chain.push(`crop=${Math.round(description.crop.width)}:${Math.round(description.crop.height)}:${Math.round(description.crop.left)}:${Math.round(description.crop.top)}`);
+    if (description.fit === "fill") {
+      chain.push(`scale=${description.width}:${description.height}`);
+    } else if (description.fit === "contain") {
+      chain.push(`scale=${description.width}:${description.height}:force_original_aspect_ratio=decrease`);
+      chain.push(`pad=${description.width}:${description.height}:(ow-iw)/2:(oh-ih)/2:color=black@0`);
+    } else if (description.fit === "cover") {
+      chain.push(`scale=${description.width}:${description.height}:force_original_aspect_ratio=increase`);
+      chain.push(`crop=${description.width}:${description.height}`);
+    }
+    chain.push("setsar=1");
+    const graph = new NodeAv2.FilterGraph();
+    graph.alloc();
+    try {
+      const srcArgs = `video_size=${srcFrame.width}x${srcFrame.height}:pix_fmt=${srcFrame.format}:time_base=1/1000000:pixel_aspect=${sample.pixelAspectRatio.num}/${sample.pixelAspectRatio.den}`;
+      const bufferSrc = graph.createFilter(NodeAv2.Filter.getByName("buffer"), "src", srcArgs);
+      const bufferSink = graph.createFilter(NodeAv2.Filter.getByName("buffersink"), "sink");
+      assert(bufferSrc && bufferSink);
+      const outputs = NodeAv2.FilterInOut.createList([{ name: "in", filterCtx: bufferSrc, padIdx: 0 }]);
+      const inputs = NodeAv2.FilterInOut.createList([{ name: "out", filterCtx: bufferSink, padIdx: 0 }]);
+      const parseRet = graph.parsePtr(`[in]${chain.join(",")}[out]`, inputs, outputs);
+      NodeAv2.FFmpegError.throwIfError(parseRet, "FilterGraph.parsePtr");
+      const configRet = await graph.config();
+      NodeAv2.FFmpegError.throwIfError(configRet, "FilterGraph.config");
+      const addRet = await bufferSrc.buffersrcAddFrame(srcFrame);
+      NodeAv2.FFmpegError.throwIfError(addRet, "buffersrcAddFrame");
+      await bufferSrc.buffersrcAddFrame(null);
+      const dstFrame = new NodeAv2.Frame();
+      dstFrame.alloc();
+      const getRet = await bufferSink.buffersinkGetFrame(dstFrame);
+      NodeAv2.FFmpegError.throwIfError(getRet, "buffersinkGetFrame");
+      return new import_mediabunny.VideoSample(new AvFrameVideoSampleResource(dstFrame), {
+        timestamp: sample.timestamp,
+        duration: sample.duration,
+        rotation: 0
+        // baked in by the filter graph
+      });
+    } finally {
+      graph.free();
+      if (srcFrameOwned) {
+        srcFrame.free();
+      }
+    }
+  };
+
+  // packages/server/src/video-decoder.ts
+  var NodeAvVideoDecoder = class extends import_mediabunny2.CustomVideoDecoder {
+    constructor() {
+      super(...arguments);
+      this.codecContext = null;
+      // Bookkeeping to restore the original timing information
+      this.preciseTimings = [];
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static supports(codec, config) {
+      return codec === "avc" || codec === "hevc" || codec === "vp8" || codec === "vp9" || codec === "av1";
+    }
+    async init() {
+      this.frame = new NodeAv3.Frame();
+      this.frame.alloc();
+      this.packet = new NodeAv3.Packet();
+      this.packet.alloc();
+    }
+    async initCodecContext(packet) {
+      assert(this.codecContext === null);
+      const codecId = CODEC_TO_CODEC_ID[this.codec];
+      assert(codecId !== void 0);
+      let codec;
+      if (this.codec === "vp9" && packet.sideData.alpha) {
+        codec = NodeAv3.Codec.findDecoderByName(LIBVPX_VP9) ?? NodeAv3.Codec.findDecoder(codecId);
+      } else if (
+        // This check used to be "is not prefer-hardware", meaning it would default to using software decode. I
+        // didn't leave a comment for that back then so I actually don't know what it was for. I'm sure it was to
+        // work around an issue but, I don't know. Not using hardware decode at all by defaults feels wrong to me,
+        // so I changed it to what it is right now. If an issue is encountered, I can always change it.
+        this.config.hardwareAcceleration === "prefer-software" || this.codec === "av1"
+      ) {
+        codec = NodeAv3.Codec.findDecoder(codecId);
+      } else {
+        codec = getHardwareDecoderCodec(codecId) ?? NodeAv3.Codec.findDecoder(codecId);
+      }
+      if (!codec) {
+        throw new Error(`Unable to obtain libav codec for '${this.codec}'.`);
+      }
+      const codecContext = new NodeAv3.CodecContext();
+      codecContext.allocContext3(codec);
+      this.pixelAspectRatio = simplifyRational({
+        num: (this.config.displayAspectWidth ?? this.config.codedWidth ?? 0) * (this.config.codedHeight ?? 0),
+        den: (this.config.displayAspectHeight ?? this.config.codedHeight ?? 0) * (this.config.codedWidth ?? 0) || 1
+      });
+      codecContext.width = this.config.codedWidth ?? 0;
+      codecContext.height = this.config.codedHeight ?? 0;
+      codecContext.codecType = NodeAv3.AVMEDIA_TYPE_VIDEO;
+      codecContext.codecId = codecId;
+      codecContext.extraData = this.config.description ? Buffer.from(toUint8Array(this.config.description)) : null;
+      codecContext.sampleAspectRatio = new NodeAv3.Rational(this.pixelAspectRatio.num, this.pixelAspectRatio.den);
+      const ret = await codecContext.open2();
+      NodeAv3.FFmpegError.throwIfError(ret, "Open codec context");
+      this.codecContext = codecContext;
+    }
+    async decode(packet) {
+      if (this.codecContext === null) {
+        await this.initCodecContext(packet);
+        assert(this.codecContext);
+      }
+      this.packet.isKeyframe = packet.type === "key";
+      this.packet.data = Buffer.from(packet.data);
+      this.packet.timeBase = { num: 1, den: 1e6 };
+      this.packet.pts = BigInt(packet.microsecondTimestamp);
+      this.packet.dts = NodeAv3.AV_NOPTS_VALUE;
+      this.packet.duration = BigInt(packet.microsecondDuration);
+      if (packet.sideData.alpha) {
+        const matroskaBlockAdditional = Buffer.alloc(8 + packet.sideData.alpha.byteLength);
+        matroskaBlockAdditional[7] = 1;
+        matroskaBlockAdditional.set(packet.sideData.alpha, 8);
+        this.packet.addSideData(NodeAv3.AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL, matroskaBlockAdditional);
+      }
+      const preciseTimingIndex = binarySearchLessOrEqual(
+        this.preciseTimings,
+        packet.microsecondTimestamp,
+        (x) => x.microsecondTimestamp
+      );
+      const existingEntry = preciseTimingIndex !== -1 ? this.preciseTimings[preciseTimingIndex] : null;
+      if (existingEntry && existingEntry.microsecondTimestamp === packet.microsecondTimestamp) {
+        if (existingEntry.timestamp !== packet.timestamp) {
+          existingEntry.timestampIsValid = false;
+        }
+        if (existingEntry.duration !== packet.duration) {
+          existingEntry.durationIsValid = false;
+        }
+      } else {
+        this.preciseTimings.splice(preciseTimingIndex + 1, 0, {
+          microsecondTimestamp: packet.microsecondTimestamp,
+          timestamp: packet.timestamp,
+          duration: packet.duration,
+          timestampIsValid: true,
+          durationIsValid: true
+        });
+        if (this.preciseTimings.length > 128) {
+          this.preciseTimings.shift();
+        }
+      }
+      const ret = await this.codecContext.sendPacket(this.packet);
+      NodeAv3.FFmpegError.throwIfError(ret, "Send packet");
+      while (true) {
+        const receiveRet = await this.codecContext.receiveFrame(this.frame);
+        if (receiveRet === NodeAv3.AVERROR_EAGAIN || receiveRet === NodeAv3.AVERROR_EOF) {
+          break;
+        }
+        this.receiveFrame(receiveRet);
+      }
+    }
+    receiveFrame(ret) {
+      NodeAv3.FFmpegError.throwIfError(ret, "Receive frame");
+      this.frame.sampleAspectRatio = new NodeAv3.Rational(this.pixelAspectRatio.num, this.pixelAspectRatio.den);
+      let timestamp = Number(this.frame.pts) / 1e6;
+      let duration = Number(this.frame.duration) / 1e6;
+      const preciseTimingIndex = binarySearchLessOrEqual(
+        this.preciseTimings,
+        Number(this.frame.pts),
+        (x) => x.microsecondTimestamp
+      );
+      const entry = preciseTimingIndex !== -1 ? this.preciseTimings[preciseTimingIndex] : null;
+      if (entry && entry.microsecondTimestamp === Number(this.frame.pts)) {
+        if (entry.timestampIsValid) {
+          timestamp = entry.timestamp;
+        }
+        if (entry.durationIsValid) {
+          duration = entry.duration;
+        }
+      }
+      const clone = this.frame.clone();
+      if (!clone) {
+        throw new Error("Frame clone allocation failed.");
+      }
+      this.onSample(new import_mediabunny2.VideoSample(new AvFrameVideoSampleResource(clone), {
+        timestamp,
+        duration
+      }));
+    }
+    async flush() {
+      if (!this.codecContext) {
+        return;
+      }
+      const ret = await this.codecContext.sendPacket(null);
+      NodeAv3.FFmpegError.throwIfError(ret, "Flush decoder");
+      while (true) {
+        const receiveRet = await this.codecContext.receiveFrame(this.frame);
+        if (receiveRet === NodeAv3.AVERROR_EAGAIN || receiveRet === NodeAv3.AVERROR_EOF) {
+          break;
+        }
+        this.receiveFrame(receiveRet);
+      }
+      this.codecContext.flushBuffers();
+    }
+    close() {
+      this.codecContext?.freeContext();
+      this.frame.free();
+      this.packet.free();
+    }
+  };
+
+  // packages/server/src/video-encoder.ts
+  var import_mediabunny3 = __require("mediabunny");
+  var NodeAv4 = __toESM(__require("node-av"));
+
+  // shared/bitstream.ts
+  var Bitstream = class _Bitstream {
+    constructor(bytes) {
+      this.bytes = bytes;
+      /** Current offset in bits. */
+      this.pos = 0;
+    }
+    seekToByte(byteOffset) {
+      this.pos = 8 * byteOffset;
+    }
+    readBit() {
+      const byteIndex = Math.floor(this.pos / 8);
+      const byte = this.bytes[byteIndex] ?? 0;
+      const bitIndex = 7 - (this.pos & 7);
+      const bit = (byte & 1 << bitIndex) >> bitIndex;
+      this.pos++;
+      return bit;
+    }
+    readBits(n) {
+      if (n === 1) {
+        return this.readBit();
+      }
+      let result = 0;
+      for (let i = 0; i < n; i++) {
+        result <<= 1;
+        result |= this.readBit();
+      }
+      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.");
+      }
+      const byteIndex = this.pos / 8;
+      const byte = this.bytes[byteIndex] ?? 0;
+      this.pos += 8;
+      return byte;
+    }
+    skipBits(n) {
+      this.pos += n;
+    }
+    getBitsLeft() {
+      return this.bytes.length * 8 - this.pos;
+    }
+    clone() {
+      const clone = new _Bitstream(this.bytes);
+      clone.pos = this.pos;
+      return clone;
+    }
+  };
+
+  // shared/aac-misc.ts
+  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 = (bytes) => {
+    if (!bytes || bytes.byteLength < 2) {
+      throw new TypeError("AAC description must be at least 2 bytes long.");
+    }
+    const bitstream = new Bitstream(bytes);
+    let objectType = bitstream.readBits(5);
+    if (objectType === 31) {
+      objectType = 32 + bitstream.readBits(6);
+    }
+    const frequencyIndex = bitstream.readBits(4);
+    let sampleRate = null;
+    if (frequencyIndex === 15) {
+      sampleRate = bitstream.readBits(24);
+    } else {
+      if (frequencyIndex < aacFrequencyTable.length) {
+        sampleRate = aacFrequencyTable[frequencyIndex];
+      }
+    }
+    const channelConfiguration = bitstream.readBits(4);
+    let numberOfChannels = null;
+    if (channelConfiguration >= 1 && channelConfiguration <= 7) {
+      numberOfChannels = aacChannelMap[channelConfiguration];
+    }
+    return {
+      objectType,
+      frequencyIndex,
+      sampleRate,
+      channelConfiguration,
+      numberOfChannels
+    };
+  };
+  var buildAdtsHeaderTemplate = (config) => {
+    const header = new Uint8Array(7);
+    const bitstream = new Bitstream(header);
+    const { objectType, frequencyIndex, channelConfiguration } = config;
+    const profile = objectType - 1;
+    bitstream.writeBits(12, 4095);
+    bitstream.writeBits(1, 0);
+    bitstream.writeBits(2, 0);
+    bitstream.writeBits(1, 1);
+    bitstream.writeBits(2, profile);
+    bitstream.writeBits(4, frequencyIndex);
+    bitstream.writeBits(1, 0);
+    bitstream.writeBits(3, channelConfiguration);
+    bitstream.writeBits(1, 0);
+    bitstream.writeBits(1, 0);
+    bitstream.writeBits(1, 0);
+    bitstream.writeBits(1, 0);
+    bitstream.skipBits(13);
+    bitstream.writeBits(11, 2047);
+    bitstream.writeBits(2, 0);
+    return { header, bitstream };
+  };
+
+  // src/codec.ts
+  var PCM_AUDIO_CODECS = [
+    "pcm-s16",
+    // We don't prefix 'le' so we're compatible with the WebCodecs-registered PCM codec strings
+    "pcm-s16be",
+    "pcm-s24",
+    "pcm-s24be",
+    "pcm-s32",
+    "pcm-s32be",
+    "pcm-f32",
+    "pcm-f32be",
+    "pcm-f64",
+    "pcm-f64be",
+    "pcm-u8",
+    "pcm-s8",
+    "ulaw",
+    "alaw"
+  ];
+  var NON_PCM_AUDIO_CODECS = [
+    "aac",
+    "opus",
+    "mp3",
+    "vorbis",
+    "flac",
+    "ac3",
+    "eac3"
+  ];
+  var AUDIO_CODECS = [
+    ...NON_PCM_AUDIO_CODECS,
+    ...PCM_AUDIO_CODECS
+  ];
+  var AVC_LEVEL_TABLE = [
+    { maxMacroblocks: 99, maxBitrate: 64e3, maxDpbMbs: 396, level: 10 },
+    // Level 1
+    { maxMacroblocks: 396, maxBitrate: 192e3, maxDpbMbs: 900, level: 11 },
+    // Level 1.1
+    { maxMacroblocks: 396, maxBitrate: 384e3, maxDpbMbs: 2376, level: 12 },
+    // Level 1.2
+    { maxMacroblocks: 396, maxBitrate: 768e3, maxDpbMbs: 2376, level: 13 },
+    // Level 1.3
+    { maxMacroblocks: 396, maxBitrate: 2e6, maxDpbMbs: 2376, level: 20 },
+    // Level 2
+    { maxMacroblocks: 792, maxBitrate: 4e6, maxDpbMbs: 4752, level: 21 },
+    // Level 2.1
+    { maxMacroblocks: 1620, maxBitrate: 4e6, maxDpbMbs: 8100, level: 22 },
+    // Level 2.2
+    { maxMacroblocks: 1620, maxBitrate: 1e7, maxDpbMbs: 8100, level: 30 },
+    // Level 3
+    { maxMacroblocks: 3600, maxBitrate: 14e6, maxDpbMbs: 18e3, level: 31 },
+    // Level 3.1
+    { maxMacroblocks: 5120, maxBitrate: 2e7, maxDpbMbs: 20480, level: 32 },
+    // Level 3.2
+    { maxMacroblocks: 8192, maxBitrate: 2e7, maxDpbMbs: 32768, level: 40 },
+    // Level 4
+    { maxMacroblocks: 8192, maxBitrate: 5e7, maxDpbMbs: 32768, level: 41 },
+    // Level 4.1
+    { maxMacroblocks: 8704, maxBitrate: 5e7, maxDpbMbs: 34816, level: 42 },
+    // Level 4.2
+    { maxMacroblocks: 22080, maxBitrate: 135e6, maxDpbMbs: 110400, level: 50 },
+    // Level 5
+    { maxMacroblocks: 36864, maxBitrate: 24e7, maxDpbMbs: 184320, level: 51 },
+    // Level 5.1
+    { maxMacroblocks: 36864, maxBitrate: 24e7, maxDpbMbs: 184320, level: 52 },
+    // Level 5.2
+    { maxMacroblocks: 139264, maxBitrate: 24e7, maxDpbMbs: 696320, level: 60 },
+    // Level 6
+    { maxMacroblocks: 139264, maxBitrate: 48e7, maxDpbMbs: 696320, level: 61 },
+    // Level 6.1
+    { maxMacroblocks: 139264, maxBitrate: 8e8, maxDpbMbs: 696320, level: 62 }
+    // Level 6.2
+  ];
+  var VP9_LEVEL_TABLE = [
+    { maxPictureSize: 36864, maxBitrate: 2e5, level: 10 },
+    // Level 1
+    { maxPictureSize: 73728, maxBitrate: 8e5, level: 11 },
+    // Level 1.1
+    { maxPictureSize: 122880, maxBitrate: 18e5, level: 20 },
+    // Level 2
+    { maxPictureSize: 245760, maxBitrate: 36e5, level: 21 },
+    // Level 2.1
+    { maxPictureSize: 552960, maxBitrate: 72e5, level: 30 },
+    // Level 3
+    { maxPictureSize: 983040, maxBitrate: 12e6, level: 31 },
+    // Level 3.1
+    { maxPictureSize: 2228224, maxBitrate: 18e6, level: 40 },
+    // Level 4
+    { maxPictureSize: 2228224, maxBitrate: 3e7, level: 41 },
+    // Level 4.1
+    { maxPictureSize: 8912896, maxBitrate: 6e7, level: 50 },
+    // Level 5
+    { maxPictureSize: 8912896, maxBitrate: 12e7, level: 51 },
+    // Level 5.1
+    { maxPictureSize: 8912896, maxBitrate: 18e7, level: 52 },
+    // Level 5.2
+    { maxPictureSize: 35651584, maxBitrate: 18e7, level: 60 },
+    // Level 6
+    { maxPictureSize: 35651584, maxBitrate: 24e7, level: 61 },
+    // Level 6.1
+    { maxPictureSize: 35651584, maxBitrate: 48e7, level: 62 }
+    // Level 6.2
+  ];
+  var VP9_DEFAULT_SUFFIX = ".01.01.01.01.00";
+  var AV1_DEFAULT_SUFFIX = ".0.110.01.01.01.0";
+  var extractVideoCodecString = (trackInfo) => {
+    const { codec, codecDescription, colorSpace, avcCodecInfo, hevcCodecInfo, vp9CodecInfo, av1CodecInfo } = trackInfo;
+    if (codec === "avc") {
+      assert(trackInfo.avcType !== null);
+      if (avcCodecInfo) {
+        const bytes = new Uint8Array([
+          avcCodecInfo.avcProfileIndication,
+          avcCodecInfo.profileCompatibility,
+          avcCodecInfo.avcLevelIndication
+        ]);
+        return `avc${trackInfo.avcType}.${bytesToHexString(bytes)}`;
+      }
+      if (!codecDescription || codecDescription.byteLength < 4) {
+        throw new TypeError("AVC decoder description is not provided or is not at least 4 bytes long.");
+      }
+      return `avc${trackInfo.avcType}.${bytesToHexString(codecDescription.subarray(1, 4))}`;
+    } else if (codec === "hevc") {
+      let generalProfileSpace;
+      let generalProfileIdc;
+      let compatibilityFlags;
+      let generalTierFlag;
+      let generalLevelIdc;
+      let constraintFlags;
+      if (hevcCodecInfo) {
+        generalProfileSpace = hevcCodecInfo.generalProfileSpace;
+        generalProfileIdc = hevcCodecInfo.generalProfileIdc;
+        compatibilityFlags = reverseBitsU32(hevcCodecInfo.generalProfileCompatibilityFlags);
+        generalTierFlag = hevcCodecInfo.generalTierFlag;
+        generalLevelIdc = hevcCodecInfo.generalLevelIdc;
+        constraintFlags = [...hevcCodecInfo.generalConstraintIndicatorFlags];
+      } else {
+        if (!codecDescription || codecDescription.byteLength < 23) {
+          throw new TypeError("HEVC decoder description is not provided or is not at least 23 bytes long.");
+        }
+        const view = toDataView(codecDescription);
+        const profileByte = view.getUint8(1);
+        generalProfileSpace = profileByte >> 6 & 3;
+        generalProfileIdc = profileByte & 31;
+        compatibilityFlags = reverseBitsU32(view.getUint32(2));
+        generalTierFlag = profileByte >> 5 & 1;
+        generalLevelIdc = view.getUint8(12);
+        constraintFlags = [];
+        for (let i = 0; i < 6; i++) {
+          constraintFlags.push(view.getUint8(6 + i));
+        }
+      }
+      let codecString = "hev1.";
+      codecString += ["", "A", "B", "C"][generalProfileSpace] + generalProfileIdc;
+      codecString += ".";
+      codecString += compatibilityFlags.toString(16).toUpperCase();
+      codecString += ".";
+      codecString += generalTierFlag === 0 ? "L" : "H";
+      codecString += generalLevelIdc;
+      while (constraintFlags.length > 0 && constraintFlags[constraintFlags.length - 1] === 0) {
+        constraintFlags.pop();
+      }
+      if (constraintFlags.length > 0) {
+        codecString += ".";
+        codecString += constraintFlags.map((x) => x.toString(16).toUpperCase()).join(".");
+      }
+      return codecString;
+    } else if (codec === "vp8") {
+      return "vp8";
+    } else if (codec === "vp9") {
+      if (!vp9CodecInfo) {
+        const pictureSize = trackInfo.width * trackInfo.height;
+        let level2 = last(VP9_LEVEL_TABLE).level;
+        for (const entry of VP9_LEVEL_TABLE) {
+          if (pictureSize <= entry.maxPictureSize) {
+            level2 = entry.level;
+            break;
+          }
+        }
+        return `vp09.00.${level2.toString().padStart(2, "0")}.08`;
+      }
+      const profile = vp9CodecInfo.profile.toString().padStart(2, "0");
+      const level = vp9CodecInfo.level.toString().padStart(2, "0");
+      const bitDepth = vp9CodecInfo.bitDepth.toString().padStart(2, "0");
+      const chromaSubsampling = vp9CodecInfo.chromaSubsampling.toString().padStart(2, "0");
+      const colourPrimaries = vp9CodecInfo.colourPrimaries.toString().padStart(2, "0");
+      const transferCharacteristics = vp9CodecInfo.transferCharacteristics.toString().padStart(2, "0");
+      const matrixCoefficients = vp9CodecInfo.matrixCoefficients.toString().padStart(2, "0");
+      const videoFullRangeFlag = vp9CodecInfo.videoFullRangeFlag.toString().padStart(2, "0");
+      let string = `vp09.${profile}.${level}.${bitDepth}.${chromaSubsampling}`;
+      string += `.${colourPrimaries}.${transferCharacteristics}.${matrixCoefficients}.${videoFullRangeFlag}`;
+      if (string.endsWith(VP9_DEFAULT_SUFFIX)) {
+        string = string.slice(0, -VP9_DEFAULT_SUFFIX.length);
+      }
+      return string;
+    } else if (codec === "av1") {
+      if (!av1CodecInfo) {
+        const pictureSize = trackInfo.width * trackInfo.height;
+        let level2 = last(VP9_LEVEL_TABLE).level;
+        for (const entry of VP9_LEVEL_TABLE) {
+          if (pictureSize <= entry.maxPictureSize) {
+            level2 = entry.level;
+            break;
+          }
+        }
+        return `av01.0.${level2.toString().padStart(2, "0")}M.08`;
+      }
+      const profile = av1CodecInfo.profile;
+      const level = av1CodecInfo.level.toString().padStart(2, "0");
+      const tier = av1CodecInfo.tier ? "H" : "M";
+      const bitDepth = av1CodecInfo.bitDepth.toString().padStart(2, "0");
+      const monochrome = av1CodecInfo.monochrome ? "1" : "0";
+      const chromaSubsampling = 100 * av1CodecInfo.chromaSubsamplingX + 10 * av1CodecInfo.chromaSubsamplingY + 1 * (av1CodecInfo.chromaSubsamplingX && av1CodecInfo.chromaSubsamplingY ? av1CodecInfo.chromaSamplePosition : 0);
+      const colorPrimaries = colorSpace?.primaries ? COLOR_PRIMARIES_MAP[colorSpace.primaries] : 1;
+      const transferCharacteristics = colorSpace?.transfer ? TRANSFER_CHARACTERISTICS_MAP[colorSpace.transfer] : 1;
+      const matrixCoefficients = colorSpace?.matrix ? MATRIX_COEFFICIENTS_MAP[colorSpace.matrix] : 1;
+      const videoFullRangeFlag = colorSpace?.fullRange ? 1 : 0;
+      let string = `av01.${profile}.${level}${tier}.${bitDepth}`;
+      string += `.${monochrome}.${chromaSubsampling.toString().padStart(3, "0")}`;
+      string += `.${colorPrimaries.toString().padStart(2, "0")}`;
+      string += `.${transferCharacteristics.toString().padStart(2, "0")}`;
+      string += `.${matrixCoefficients.toString().padStart(2, "0")}`;
+      string += `.${videoFullRangeFlag}`;
+      if (string.endsWith(AV1_DEFAULT_SUFFIX)) {
+        string = string.slice(0, -AV1_DEFAULT_SUFFIX.length);
+      }
+      return string;
+    }
+    throw new TypeError(`Unhandled codec '${codec}'.`);
+  };
+
+  // src/codec-data.ts
+  var iterateNalUnitsInAnnexB = function* (packetData) {
+    let i = 0;
+    let nalStart = -1;
+    while (i < packetData.length - 2) {
+      const zeroIndex = packetData.indexOf(0, i);
+      if (zeroIndex === -1 || zeroIndex >= packetData.length - 2) {
+        break;
+      }
+      i = zeroIndex;
+      let startCodeLength = 0;
+      if (i + 3 < packetData.length && packetData[i + 1] === 0 && packetData[i + 2] === 0 && packetData[i + 3] === 1) {
+        startCodeLength = 4;
+      } else if (packetData[i + 1] === 0 && packetData[i + 2] === 1) {
+        startCodeLength = 3;
+      }
+      if (startCodeLength === 0) {
+        i++;
+        continue;
+      }
+      if (nalStart !== -1 && i > nalStart) {
+        yield {
+          offset: nalStart,
+          length: i - nalStart
+        };
+      }
+      nalStart = i + startCodeLength;
+      i = nalStart;
+    }
+    if (nalStart !== -1 && nalStart < packetData.length) {
+      yield {
+        offset: nalStart,
+        length: packetData.length - nalStart
+      };
+    }
+  };
+  var extractNalUnitTypeForAvc = (byte) => {
+    return byte & 31;
+  };
+  var removeEmulationPreventionBytes = (data) => {
+    const result = [];
+    const len = data.length;
+    for (let i = 0; i < len; i++) {
+      if (i + 2 < len && data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 3) {
+        result.push(0, 0);
+        i += 2;
+      } else {
+        result.push(data[i]);
+      }
+    }
+    return new Uint8Array(result);
+  };
+  var ANNEX_B_START_CODE = new Uint8Array([0, 0, 0, 1]);
+  var extractAvcDecoderConfigurationRecord = (packetData) => {
+    try {
+      const spsUnits = [];
+      const ppsUnits = [];
+      const spsExtUnits = [];
+      for (const loc of iterateNalUnitsInAnnexB(packetData)) {
+        const nalUnit = packetData.subarray(loc.offset, loc.offset + loc.length);
+        const type = extractNalUnitTypeForAvc(nalUnit[0]);
+        if (type === 7 /* SPS */) {
+          spsUnits.push(nalUnit);
+        } else if (type === 8 /* PPS */) {
+          ppsUnits.push(nalUnit);
+        } else if (type === 13 /* SPS_EXT */) {
+          spsExtUnits.push(nalUnit);
+        }
+      }
+      if (spsUnits.length === 0) {
+        return null;
+      }
+      if (ppsUnits.length === 0) {
+        return null;
+      }
+      const spsData = spsUnits[0];
+      const spsInfo = parseAvcSps(spsData);
+      assert(spsInfo !== null);
+      const hasExtendedData = spsInfo.profileIdc === 100 || spsInfo.profileIdc === 110 || spsInfo.profileIdc === 122 || spsInfo.profileIdc === 144;
+      return {
+        configurationVersion: 1,
+        avcProfileIndication: spsInfo.profileIdc,
+        profileCompatibility: spsInfo.constraintFlags,
+        avcLevelIndication: spsInfo.levelIdc,
+        lengthSizeMinusOne: 3,
+        // Typically 4 bytes for length field
+        sequenceParameterSets: spsUnits,
+        pictureParameterSets: ppsUnits,
+        chromaFormat: hasExtendedData ? spsInfo.chromaFormatIdc : null,
+        bitDepthLumaMinus8: hasExtendedData ? spsInfo.bitDepthLumaMinus8 : null,
+        bitDepthChromaMinus8: hasExtendedData ? spsInfo.bitDepthChromaMinus8 : null,
+        sequenceParameterSetExt: hasExtendedData ? spsExtUnits : null
+      };
+    } catch (error) {
+      console.error("Error building AVC Decoder Configuration Record:", error);
+      return null;
+    }
+  };
+  var serializeAvcDecoderConfigurationRecord = (record) => {
+    const bytes = [];
+    bytes.push(record.configurationVersion);
+    bytes.push(record.avcProfileIndication);
+    bytes.push(record.profileCompatibility);
+    bytes.push(record.avcLevelIndication);
+    bytes.push(252 | record.lengthSizeMinusOne & 3);
+    bytes.push(224 | record.sequenceParameterSets.length & 31);
+    for (const sps of record.sequenceParameterSets) {
+      const length = sps.byteLength;
+      bytes.push(length >> 8);
+      bytes.push(length & 255);
+      for (let i = 0; i < length; i++) {
+        bytes.push(sps[i]);
+      }
+    }
+    bytes.push(record.pictureParameterSets.length);
+    for (const pps of record.pictureParameterSets) {
+      const length = pps.byteLength;
+      bytes.push(length >> 8);
+      bytes.push(length & 255);
+      for (let i = 0; i < length; i++) {
+        bytes.push(pps[i]);
+      }
+    }
+    if (record.avcProfileIndication === 100 || record.avcProfileIndication === 110 || record.avcProfileIndication === 122 || record.avcProfileIndication === 144) {
+      assert(record.chromaFormat !== null);
+      assert(record.bitDepthLumaMinus8 !== null);
+      assert(record.bitDepthChromaMinus8 !== null);
+      assert(record.sequenceParameterSetExt !== null);
+      bytes.push(252 | record.chromaFormat & 3);
+      bytes.push(248 | record.bitDepthLumaMinus8 & 7);
+      bytes.push(248 | record.bitDepthChromaMinus8 & 7);
+      bytes.push(record.sequenceParameterSetExt.length);
+      for (const spsExt of record.sequenceParameterSetExt) {
+        const length = spsExt.byteLength;
+        bytes.push(length >> 8);
+        bytes.push(length & 255);
+        for (let i = 0; i < length; i++) {
+          bytes.push(spsExt[i]);
+        }
+      }
+    }
+    return new Uint8Array(bytes);
+  };
+  var AVC_HEVC_ASPECT_RATIO_IDC_TABLE = {
+    1: { num: 1, den: 1 },
+    2: { num: 12, den: 11 },
+    3: { num: 10, den: 11 },
+    4: { num: 16, den: 11 },
+    5: { num: 40, den: 33 },
+    6: { num: 24, den: 11 },
+    7: { num: 20, den: 11 },
+    8: { num: 32, den: 11 },
+    9: { num: 80, den: 33 },
+    10: { num: 18, den: 11 },
+    11: { num: 15, den: 11 },
+    12: { num: 64, den: 33 },
+    13: { num: 160, den: 99 },
+    14: { num: 4, den: 3 },
+    15: { num: 3, den: 2 },
+    16: { num: 2, den: 1 }
+  };
+  var parseAvcSps = (sps) => {
+    try {
+      const bitstream = new Bitstream(removeEmulationPreventionBytes(sps));
+      bitstream.skipBits(1);
+      bitstream.skipBits(2);
+      const nalUnitType = bitstream.readBits(5);
+      if (nalUnitType !== 7) {
+        return null;
+      }
+      const profileIdc = bitstream.readAlignedByte();
+      const constraintFlags = bitstream.readAlignedByte();
+      const levelIdc = bitstream.readAlignedByte();
+      readExpGolomb(bitstream);
+      let chromaFormatIdc = 1;
+      let bitDepthLumaMinus8 = 0;
+      let bitDepthChromaMinus8 = 0;
+      let separateColourPlaneFlag = 0;
+      if (profileIdc === 100 || profileIdc === 110 || profileIdc === 122 || profileIdc === 244 || profileIdc === 44 || profileIdc === 83 || profileIdc === 86 || profileIdc === 118 || profileIdc === 128) {
+        chromaFormatIdc = readExpGolomb(bitstream);
+        if (chromaFormatIdc === 3) {
+          separateColourPlaneFlag = bitstream.readBits(1);
+        }
+        bitDepthLumaMinus8 = readExpGolomb(bitstream);
+        bitDepthChromaMinus8 = readExpGolomb(bitstream);
+        bitstream.skipBits(1);
+        const seqScalingMatrixPresentFlag = bitstream.readBits(1);
+        if (seqScalingMatrixPresentFlag) {
+          for (let i = 0; i < (chromaFormatIdc !== 3 ? 8 : 12); i++) {
+            const seqScalingListPresentFlag = bitstream.readBits(1);
+            if (seqScalingListPresentFlag) {
+              const sizeOfScalingList = i < 6 ? 16 : 64;
+              let lastScale = 8;
+              let nextScale = 8;
+              for (let j = 0; j < sizeOfScalingList; j++) {
+                if (nextScale !== 0) {
+                  const deltaScale = readSignedExpGolomb(bitstream);
+                  nextScale = (lastScale + deltaScale + 256) % 256;
+                }
+                lastScale = nextScale === 0 ? lastScale : nextScale;
+              }
+            }
+          }
+        }
+      }
+      readExpGolomb(bitstream);
+      const picOrderCntType = readExpGolomb(bitstream);
+      if (picOrderCntType === 0) {
+        readExpGolomb(bitstream);
+      } else if (picOrderCntType === 1) {
+        bitstream.skipBits(1);
+        readSignedExpGolomb(bitstream);
+        readSignedExpGolomb(bitstream);
+        const numRefFramesInPicOrderCntCycle = readExpGolomb(bitstream);
+        for (let i = 0; i < numRefFramesInPicOrderCntCycle; i++) {
+          readSignedExpGolomb(bitstream);
+        }
+      }
+      readExpGolomb(bitstream);
+      bitstream.skipBits(1);
+      const picWidthInMbsMinus1 = readExpGolomb(bitstream);
+      const picHeightInMapUnitsMinus1 = readExpGolomb(bitstream);
+      const codedWidth = 16 * (picWidthInMbsMinus1 + 1);
+      const codedHeight = 16 * (picHeightInMapUnitsMinus1 + 1);
+      let displayWidth = codedWidth;
+      let displayHeight = codedHeight;
+      const frameMbsOnlyFlag = bitstream.readBits(1);
+      if (!frameMbsOnlyFlag) {
+        bitstream.skipBits(1);
+      }
+      bitstream.skipBits(1);
+      const frameCroppingFlag = bitstream.readBits(1);
+      if (frameCroppingFlag) {
+        const frameCropLeftOffset = readExpGolomb(bitstream);
+        const frameCropRightOffset = readExpGolomb(bitstream);
+        const frameCropTopOffset = readExpGolomb(bitstream);
+        const frameCropBottomOffset = readExpGolomb(bitstream);
+        let cropUnitX;
+        let cropUnitY;
+        const chromaArrayType = separateColourPlaneFlag === 0 ? chromaFormatIdc : 0;
+        if (chromaArrayType === 0) {
+          cropUnitX = 1;
+          cropUnitY = 2 - frameMbsOnlyFlag;
+        } else {
+          const subWidthC = chromaFormatIdc === 3 ? 1 : 2;
+          const subHeightC = chromaFormatIdc === 1 ? 2 : 1;
+          cropUnitX = subWidthC;
+          cropUnitY = subHeightC * (2 - frameMbsOnlyFlag);
+        }
+        displayWidth -= cropUnitX * (frameCropLeftOffset + frameCropRightOffset);
+        displayHeight -= cropUnitY * (frameCropTopOffset + frameCropBottomOffset);
+      }
+      let colourPrimaries = 2;
+      let transferCharacteristics = 2;
+      let matrixCoefficients = 2;
+      let fullRangeFlag = 0;
+      let pixelAspectRatio = { num: 1, den: 1 };
+      let numReorderFrames = null;
+      let maxDecFrameBuffering = null;
+      const vuiParametersPresentFlag = bitstream.readBits(1);
+      if (vuiParametersPresentFlag) {
+        const aspectRatioInfoPresentFlag = bitstream.readBits(1);
+        if (aspectRatioInfoPresentFlag) {
+          const aspectRatioIdc = bitstream.readBits(8);
+          if (aspectRatioIdc === 255) {
+            pixelAspectRatio = {
+              num: bitstream.readBits(16),
+              den: bitstream.readBits(16)
+            };
+          } else {
+            const aspectRatio = AVC_HEVC_ASPECT_RATIO_IDC_TABLE[aspectRatioIdc];
+            if (aspectRatio) {
+              pixelAspectRatio = aspectRatio;
+            }
+          }
+        }
+        const overscanInfoPresentFlag = bitstream.readBits(1);
+        if (overscanInfoPresentFlag) {
+          bitstream.skipBits(1);
+        }
+        const videoSignalTypePresentFlag = bitstream.readBits(1);
+        if (videoSignalTypePresentFlag) {
+          bitstream.skipBits(3);
+          fullRangeFlag = bitstream.readBits(1);
+          const colourDescriptionPresentFlag = bitstream.readBits(1);
+          if (colourDescriptionPresentFlag) {
+            colourPrimaries = bitstream.readBits(8);
+            transferCharacteristics = bitstream.readBits(8);
+            matrixCoefficients = bitstream.readBits(8);
+          }
+        }
+        const chromaLocInfoPresentFlag = bitstream.readBits(1);
+        if (chromaLocInfoPresentFlag) {
+          readExpGolomb(bitstream);
+          readExpGolomb(bitstream);
+        }
+        const timingInfoPresentFlag = bitstream.readBits(1);
+        if (timingInfoPresentFlag) {
+          bitstream.skipBits(32);
+          bitstream.skipBits(32);
+          bitstream.skipBits(1);
+        }
+        const nalHrdParametersPresentFlag = bitstream.readBits(1);
+        if (nalHrdParametersPresentFlag) {
+          skipAvcHrdParameters(bitstream);
+        }
+        const vclHrdParametersPresentFlag = bitstream.readBits(1);
+        if (vclHrdParametersPresentFlag) {
+          skipAvcHrdParameters(bitstream);
+        }
+        if (nalHrdParametersPresentFlag || vclHrdParametersPresentFlag) {
+          bitstream.skipBits(1);
+        }
+        bitstream.skipBits(1);
+        const bitstreamRestrictionFlag = bitstream.readBits(1);
+        if (bitstreamRestrictionFlag) {
+          bitstream.skipBits(1);
+          readExpGolomb(bitstream);
+          readExpGolomb(bitstream);
+          readExpGolomb(bitstream);
+          readExpGolomb(bitstream);
+          numReorderFrames = readExpGolomb(bitstream);
+          maxDecFrameBuffering = readExpGolomb(bitstream);
+        }
+      }
+      if (numReorderFrames === null) {
+        assert(maxDecFrameBuffering === null);
+        const constraintSet3Flag = constraintFlags & 16;
+        if ((profileIdc === 44 || profileIdc === 86 || profileIdc === 100 || profileIdc === 110 || profileIdc === 122 || profileIdc === 244) && constraintSet3Flag) {
+          numReorderFrames = 0;
+          maxDecFrameBuffering = 0;
+        } else {
+          const picWidthInMbs = picWidthInMbsMinus1 + 1;
+          const picHeightInMapUnits = picHeightInMapUnitsMinus1 + 1;
+          const frameHeightInMbs = (2 - frameMbsOnlyFlag) * picHeightInMapUnits;
+          const levelInfo = AVC_LEVEL_TABLE.find(
+            (x) => x.level >= levelIdc
+          ) ?? last(AVC_LEVEL_TABLE);
+          const maxDpbFrames = Math.min(
+            Math.floor(levelInfo.maxDpbMbs / (picWidthInMbs * frameHeightInMbs)),
+            16
+          );
+          numReorderFrames = maxDpbFrames;
+          maxDecFrameBuffering = maxDpbFrames;
+        }
+      }
+      assert(maxDecFrameBuffering !== null);
+      return {
+        profileIdc,
+        constraintFlags,
+        levelIdc,
+        frameMbsOnlyFlag,
+        chromaFormatIdc,
+        bitDepthLumaMinus8,
+        bitDepthChromaMinus8,
+        codedWidth,
+        codedHeight,
+        displayWidth,
+        displayHeight,
+        pixelAspectRatio,
+        colourPrimaries,
+        matrixCoefficients,
+        transferCharacteristics,
+        fullRangeFlag,
+        numReorderFrames,
+        maxDecFrameBuffering
+      };
+    } catch (error) {
+      console.error("Error parsing AVC SPS:", error);
+      return null;
+    }
+  };
+  var skipAvcHrdParameters = (bitstream) => {
+    const cpb_cnt_minus1 = readExpGolomb(bitstream);
+    bitstream.skipBits(4);
+    bitstream.skipBits(4);
+    for (let i = 0; i <= cpb_cnt_minus1; i++) {
+      readExpGolomb(bitstream);
+      readExpGolomb(bitstream);
+      bitstream.skipBits(1);
+    }
+    bitstream.skipBits(5);
+    bitstream.skipBits(5);
+    bitstream.skipBits(5);
+    bitstream.skipBits(5);
+  };
+  var extractNalUnitTypeForHevc = (byte) => {
+    return byte >> 1 & 63;
+  };
+  var parseHevcSps = (sps) => {
+    try {
+      const bitstream = new Bitstream(removeEmulationPreventionBytes(sps));
+      bitstream.skipBits(16);
+      bitstream.readBits(4);
+      const spsMaxSubLayersMinus1 = bitstream.readBits(3);
+      const spsTemporalIdNestingFlag = bitstream.readBits(1);
+      const {
+        general_profile_space,
+        general_tier_flag,
+        general_profile_idc,
+        general_profile_compatibility_flags,
+        general_constraint_indicator_flags,
+        general_level_idc
+      } = parseProfileTierLevel(bitstream, spsMaxSubLayersMinus1);
+      readExpGolomb(bitstream);
+      const chromaFormatIdc = readExpGolomb(bitstream);
+      let separateColourPlaneFlag = 0;
+      if (chromaFormatIdc === 3) {
+        separateColourPlaneFlag = bitstream.readBits(1);
+      }
+      const picWidthInLumaSamples = readExpGolomb(bitstream);
+      const picHeightInLumaSamples = readExpGolomb(bitstream);
+      let displayWidth = picWidthInLumaSamples;
+      let displayHeight = picHeightInLumaSamples;
+      if (bitstream.readBits(1)) {
+        const confWinLeftOffset = readExpGolomb(bitstream);
+        const confWinRightOffset = readExpGolomb(bitstream);
+        const confWinTopOffset = readExpGolomb(bitstream);
+        const confWinBottomOffset = readExpGolomb(bitstream);
+        let subWidthC = 1;
+        let subHeightC = 1;
+        const chromaArrayType = separateColourPlaneFlag === 0 ? chromaFormatIdc : 0;
+        if (chromaArrayType === 1) {
+          subWidthC = 2;
+          subHeightC = 2;
+        } else if (chromaArrayType === 2) {
+          subWidthC = 2;
+          subHeightC = 1;
+        }
+        displayWidth -= (confWinLeftOffset + confWinRightOffset) * subWidthC;
+        displayHeight -= (confWinTopOffset + confWinBottomOffset) * subHeightC;
+      }
+      const bitDepthLumaMinus8 = readExpGolomb(bitstream);
+      const bitDepthChromaMinus8 = readExpGolomb(bitstream);
+      readExpGolomb(bitstream);
+      const spsSubLayerOrderingInfoPresentFlag = bitstream.readBits(1);
+      const startI = spsSubLayerOrderingInfoPresentFlag ? 0 : spsMaxSubLayersMinus1;
+      let spsMaxNumReorderPics = 0;
+      for (let i = startI; i <= spsMaxSubLayersMinus1; i++) {
+        readExpGolomb(bitstream);
+        spsMaxNumReorderPics = readExpGolomb(bitstream);
+        readExpGolomb(bitstream);
+      }
+      readExpGolomb(bitstream);
+      readExpGolomb(bitstream);
+      readExpGolomb(bitstream);
+      readExpGolomb(bitstream);
+      readExpGolomb(bitstream);
+      readExpGolomb(bitstream);
+      if (bitstream.readBits(1)) {
+        if (bitstream.readBits(1)) {
+          skipScalingListData(bitstream);
+        }
+      }
+      bitstream.skipBits(1);
+      bitstream.skipBits(1);
+      if (bitstream.readBits(1)) {
+        bitstream.skipBits(4);
+        bitstream.skipBits(4);
+        readExpGolomb(bitstream);
+        readExpGolomb(bitstream);
+        bitstream.skipBits(1);
+      }
+      const numShortTermRefPicSets = readExpGolomb(bitstream);
+      skipAllStRefPicSets(bitstream, numShortTermRefPicSets);
+      if (bitstream.readBits(1)) {
+        const numLongTermRefPicsSps = readExpGolomb(bitstream);
+        for (let i = 0; i < numLongTermRefPicsSps; i++) {
+          readExpGolomb(bitstream);
+          bitstream.skipBits(1);
+        }
+      }
+      bitstream.skipBits(1);
+      bitstream.skipBits(1);
+      let colourPrimaries = 2;
+      let transferCharacteristics = 2;
+      let matrixCoefficients = 2;
+      let fullRangeFlag = 0;
+      let minSpatialSegmentationIdc = 0;
+      let pixelAspectRatio = { num: 1, den: 1 };
+      if (bitstream.readBits(1)) {
+        const vui = parseHevcVui(bitstream, spsMaxSubLayersMinus1);
+        pixelAspectRatio = vui.pixelAspectRatio;
+        colourPrimaries = vui.colourPrimaries;
+        transferCharacteristics = vui.transferCharacteristics;
+        matrixCoefficients = vui.matrixCoefficients;
+        fullRangeFlag = vui.fullRangeFlag;
+        minSpatialSegmentationIdc = vui.minSpatialSegmentationIdc;
+      }
+      return {
+        displayWidth,
+        displayHeight,
+        pixelAspectRatio,
+        colourPrimaries,
+        transferCharacteristics,
+        matrixCoefficients,
+        fullRangeFlag,
+        maxDecFrameBuffering: spsMaxNumReorderPics + 1,
+        spsMaxSubLayersMinus1,
+        spsTemporalIdNestingFlag,
+        generalProfileSpace: general_profile_space,
+        generalTierFlag: general_tier_flag,
+        generalProfileIdc: general_profile_idc,
+        generalProfileCompatibilityFlags: general_profile_compatibility_flags,
+        generalConstraintIndicatorFlags: general_constraint_indicator_flags,
+        generalLevelIdc: general_level_idc,
+        chromaFormatIdc,
+        bitDepthLumaMinus8,
+        bitDepthChromaMinus8,
+        minSpatialSegmentationIdc
+      };
+    } catch (error) {
+      console.error("Error parsing HEVC SPS:", error);
+      return null;
+    }
+  };
+  var extractHevcDecoderConfigurationRecord = (packetData) => {
+    try {
+      const vpsUnits = [];
+      const spsUnits = [];
+      const ppsUnits = [];
+      const seiUnits = [];
+      for (const loc of iterateNalUnitsInAnnexB(packetData)) {
+        const nalUnit = packetData.subarray(loc.offset, loc.offset + loc.length);
+        const type = extractNalUnitTypeForHevc(nalUnit[0]);
+        if (type === 32 /* VPS_NUT */) {
+          vpsUnits.push(nalUnit);
+        } else if (type === 33 /* SPS_NUT */) {
+          spsUnits.push(nalUnit);
+        } else if (type === 34 /* PPS_NUT */) {
+          ppsUnits.push(nalUnit);
+        } else if (type === 39 /* PREFIX_SEI_NUT */ || type === 40 /* SUFFIX_SEI_NUT */) {
+          seiUnits.push(nalUnit);
+        }
+      }
+      if (spsUnits.length === 0 || ppsUnits.length === 0) return null;
+      const spsInfo = parseHevcSps(spsUnits[0]);
+      if (!spsInfo) return null;
+      let parallelismType = 0;
+      if (ppsUnits.length > 0) {
+        const pps = ppsUnits[0];
+        const ppsBitstream = new Bitstream(removeEmulationPreventionBytes(pps));
+        ppsBitstream.skipBits(16);
+        readExpGolomb(ppsBitstream);
+        readExpGolomb(ppsBitstream);
+        ppsBitstream.skipBits(1);
+        ppsBitstream.skipBits(1);
+        ppsBitstream.skipBits(3);
+        ppsBitstream.skipBits(1);
+        ppsBitstream.skipBits(1);
+        readExpGolomb(ppsBitstream);
+        readExpGolomb(ppsBitstream);
+        readSignedExpGolomb(ppsBitstream);
+        ppsBitstream.skipBits(1);
+        ppsBitstream.skipBits(1);
+        if (ppsBitstream.readBits(1)) {
+          readExpGolomb(ppsBitstream);
+        }
+        readSignedExpGolomb(ppsBitstream);
+        readSignedExpGolomb(ppsBitstream);
+        ppsBitstream.skipBits(1);
+        ppsBitstream.skipBits(1);
+        ppsBitstream.skipBits(1);
+        ppsBitstream.skipBits(1);
+        const tiles_enabled_flag = ppsBitstream.readBits(1);
+        const entropy_coding_sync_enabled_flag = ppsBitstream.readBits(1);
+        if (!tiles_enabled_flag && !entropy_coding_sync_enabled_flag) parallelismType = 0;
+        else if (tiles_enabled_flag && !entropy_coding_sync_enabled_flag) parallelismType = 2;
+        else if (!tiles_enabled_flag && entropy_coding_sync_enabled_flag) parallelismType = 3;
+        else parallelismType = 0;
+      }
+      const arrays = [
+        ...vpsUnits.length ? [
+          {
+            arrayCompleteness: 1,
+            nalUnitType: 32 /* VPS_NUT */,
+            nalUnits: vpsUnits
+          }
+        ] : [],
+        ...spsUnits.length ? [
+          {
+            arrayCompleteness: 1,
+            nalUnitType: 33 /* SPS_NUT */,
+            nalUnits: spsUnits
+          }
+        ] : [],
+        ...ppsUnits.length ? [
+          {
+            arrayCompleteness: 1,
+            nalUnitType: 34 /* PPS_NUT */,
+            nalUnits: ppsUnits
+          }
+        ] : [],
+        ...seiUnits.length ? [
+          {
+            arrayCompleteness: 1,
+            nalUnitType: extractNalUnitTypeForHevc(seiUnits[0][0]),
+            nalUnits: seiUnits
+          }
+        ] : []
+      ];
+      const record = {
+        configurationVersion: 1,
+        generalProfileSpace: spsInfo.generalProfileSpace,
+        generalTierFlag: spsInfo.generalTierFlag,
+        generalProfileIdc: spsInfo.generalProfileIdc,
+        generalProfileCompatibilityFlags: spsInfo.generalProfileCompatibilityFlags,
+        generalConstraintIndicatorFlags: spsInfo.generalConstraintIndicatorFlags,
+        generalLevelIdc: spsInfo.generalLevelIdc,
+        minSpatialSegmentationIdc: spsInfo.minSpatialSegmentationIdc,
+        parallelismType,
+        chromaFormatIdc: spsInfo.chromaFormatIdc,
+        bitDepthLumaMinus8: spsInfo.bitDepthLumaMinus8,
+        bitDepthChromaMinus8: spsInfo.bitDepthChromaMinus8,
+        avgFrameRate: 0,
+        constantFrameRate: 0,
+        numTemporalLayers: spsInfo.spsMaxSubLayersMinus1 + 1,
+        temporalIdNested: spsInfo.spsTemporalIdNestingFlag,
+        lengthSizeMinusOne: 3,
+        arrays
+      };
+      return record;
+    } catch (error) {
+      console.error("Error building HEVC Decoder Configuration Record:", error);
+      return null;
+    }
+  };
+  var parseProfileTierLevel = (bitstream, maxNumSubLayersMinus1) => {
+    const general_profile_space = bitstream.readBits(2);
+    const general_tier_flag = bitstream.readBits(1);
+    const general_profile_idc = bitstream.readBits(5);
+    let general_profile_compatibility_flags = 0;
+    for (let i = 0; i < 32; i++) {
+      general_profile_compatibility_flags = general_profile_compatibility_flags << 1 | bitstream.readBits(1);
+    }
+    const general_constraint_indicator_flags = new Uint8Array(6);
+    for (let i = 0; i < 6; i++) {
+      general_constraint_indicator_flags[i] = bitstream.readBits(8);
+    }
+    const general_level_idc = bitstream.readBits(8);
+    const sub_layer_profile_present_flag = [];
+    const sub_layer_level_present_flag = [];
+    for (let i = 0; i < maxNumSubLayersMinus1; i++) {
+      sub_layer_profile_present_flag.push(bitstream.readBits(1));
+      sub_layer_level_present_flag.push(bitstream.readBits(1));
+    }
+    if (maxNumSubLayersMinus1 > 0) {
+      for (let i = maxNumSubLayersMinus1; i < 8; i++) {
+        bitstream.skipBits(2);
+      }
+    }
+    for (let i = 0; i < maxNumSubLayersMinus1; i++) {
+      if (sub_layer_profile_present_flag[i]) bitstream.skipBits(88);
+      if (sub_layer_level_present_flag[i]) bitstream.skipBits(8);
+    }
+    return {
+      general_profile_space,
+      general_tier_flag,
+      general_profile_idc,
+      general_profile_compatibility_flags,
+      general_constraint_indicator_flags,
+      general_level_idc
+    };
+  };
+  var skipScalingListData = (bitstream) => {
+    for (let sizeId = 0; sizeId < 4; sizeId++) {
+      for (let matrixId = 0; matrixId < (sizeId === 3 ? 2 : 6); matrixId++) {
+        const scaling_list_pred_mode_flag = bitstream.readBits(1);
+        if (!scaling_list_pred_mode_flag) {
+          readExpGolomb(bitstream);
+        } else {
+          const coefNum = Math.min(64, 1 << 4 + (sizeId << 1));
+          if (sizeId > 1) {
+            readSignedExpGolomb(bitstream);
+          }
+          for (let i = 0; i < coefNum; i++) {
+            readSignedExpGolomb(bitstream);
+          }
+        }
+      }
+    }
+  };
+  var skipAllStRefPicSets = (bitstream, num_short_term_ref_pic_sets) => {
+    const NumDeltaPocs = [];
+    for (let stRpsIdx = 0; stRpsIdx < num_short_term_ref_pic_sets; stRpsIdx++) {
+      NumDeltaPocs[stRpsIdx] = skipStRefPicSet(bitstream, stRpsIdx, num_short_term_ref_pic_sets, NumDeltaPocs);
+    }
+  };
+  var skipStRefPicSet = (bitstream, stRpsIdx, num_short_term_ref_pic_sets, NumDeltaPocs) => {
+    let NumDeltaPocsThis = 0;
+    let inter_ref_pic_set_prediction_flag = 0;
+    let RefRpsIdx = 0;
+    if (stRpsIdx !== 0) {
+      inter_ref_pic_set_prediction_flag = bitstream.readBits(1);
+    }
+    if (inter_ref_pic_set_prediction_flag) {
+      if (stRpsIdx === num_short_term_ref_pic_sets) {
+        const delta_idx_minus1 = readExpGolomb(bitstream);
+        RefRpsIdx = stRpsIdx - (delta_idx_minus1 + 1);
+      } else {
+        RefRpsIdx = stRpsIdx - 1;
+      }
+      bitstream.readBits(1);
+      readExpGolomb(bitstream);
+      const numDelta = NumDeltaPocs[RefRpsIdx] ?? 0;
+      for (let j = 0; j <= numDelta; j++) {
+        const used_by_curr_pic_flag = bitstream.readBits(1);
+        if (!used_by_curr_pic_flag) {
+          bitstream.readBits(1);
+        }
+      }
+      NumDeltaPocsThis = NumDeltaPocs[RefRpsIdx];
+    } else {
+      const num_negative_pics = readExpGolomb(bitstream);
+      const num_positive_pics = readExpGolomb(bitstream);
+      for (let i = 0; i < num_negative_pics; i++) {
+        readExpGolomb(bitstream);
+        bitstream.readBits(1);
+      }
+      for (let i = 0; i < num_positive_pics; i++) {
+        readExpGolomb(bitstream);
+        bitstream.readBits(1);
+      }
+      NumDeltaPocsThis = num_negative_pics + num_positive_pics;
+    }
+    return NumDeltaPocsThis;
+  };
+  var parseHevcVui = (bitstream, sps_max_sub_layers_minus1) => {
+    let colourPrimaries = 2;
+    let transferCharacteristics = 2;
+    let matrixCoefficients = 2;
+    let fullRangeFlag = 0;
+    let minSpatialSegmentationIdc = 0;
+    let pixelAspectRatio = { num: 1, den: 1 };
+    if (bitstream.readBits(1)) {
+      const aspect_ratio_idc = bitstream.readBits(8);
+      if (aspect_ratio_idc === 255) {
+        pixelAspectRatio = {
+          num: bitstream.readBits(16),
+          den: bitstream.readBits(16)
+        };
+      } else {
+        const aspectRatio = AVC_HEVC_ASPECT_RATIO_IDC_TABLE[aspect_ratio_idc];
+        if (aspectRatio) {
+          pixelAspectRatio = aspectRatio;
+        }
+      }
+    }
+    if (bitstream.readBits(1)) {
+      bitstream.readBits(1);
+    }
+    if (bitstream.readBits(1)) {
+      bitstream.readBits(3);
+      fullRangeFlag = bitstream.readBits(1);
+      if (bitstream.readBits(1)) {
+        colourPrimaries = bitstream.readBits(8);
+        transferCharacteristics = bitstream.readBits(8);
+        matrixCoefficients = bitstream.readBits(8);
+      }
+    }
+    if (bitstream.readBits(1)) {
+      readExpGolomb(bitstream);
+      readExpGolomb(bitstream);
+    }
+    bitstream.readBits(1);
+    bitstream.readBits(1);
+    bitstream.readBits(1);
+    if (bitstream.readBits(1)) {
+      readExpGolomb(bitstream);
+      readExpGolomb(bitstream);
+      readExpGolomb(bitstream);
+      readExpGolomb(bitstream);
+    }
+    if (bitstream.readBits(1)) {
+      bitstream.readBits(32);
+      bitstream.readBits(32);
+      if (bitstream.readBits(1)) {
+        readExpGolomb(bitstream);
+      }
+      if (bitstream.readBits(1)) {
+        skipHevcHrdParameters(bitstream, true, sps_max_sub_layers_minus1);
+      }
+    }
+    if (bitstream.readBits(1)) {
+      bitstream.readBits(1);
+      bitstream.readBits(1);
+      bitstream.readBits(1);
+      minSpatialSegmentationIdc = readExpGolomb(bitstream);
+      readExpGolomb(bitstream);
+      readExpGolomb(bitstream);
+      readExpGolomb(bitstream);
+      readExpGolomb(bitstream);
+    }
+    return {
+      pixelAspectRatio,
+      colourPrimaries,
+      transferCharacteristics,
+      matrixCoefficients,
+      fullRangeFlag,
+      minSpatialSegmentationIdc
+    };
+  };
+  var skipHevcHrdParameters = (bitstream, commonInfPresentFlag, maxNumSubLayersMinus1) => {
+    let nal_hrd_parameters_present_flag = false;
+    let vcl_hrd_parameters_present_flag = false;
+    let sub_pic_hrd_params_present_flag = false;
+    if (commonInfPresentFlag) {
+      nal_hrd_parameters_present_flag = bitstream.readBits(1) === 1;
+      vcl_hrd_parameters_present_flag = bitstream.readBits(1) === 1;
+      if (nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag) {
+        sub_pic_hrd_params_present_flag = bitstream.readBits(1) === 1;
+        if (sub_pic_hrd_params_present_flag) {
+          bitstream.readBits(8);
+          bitstream.readBits(5);
+          bitstream.readBits(1);
+          bitstream.readBits(5);
+        }
+        bitstream.readBits(4);
+        bitstream.readBits(4);
+        if (sub_pic_hrd_params_present_flag) {
+          bitstream.readBits(4);
+        }
+        bitstream.readBits(5);
+        bitstream.readBits(5);
+        bitstream.readBits(5);
+      }
+    }
+    for (let i = 0; i <= maxNumSubLayersMinus1; i++) {
+      const fixed_pic_rate_general_flag = bitstream.readBits(1) === 1;
+      let fixed_pic_rate_within_cvs_flag = true;
+      if (!fixed_pic_rate_general_flag) {
+        fixed_pic_rate_within_cvs_flag = bitstream.readBits(1) === 1;
+      }
+      let low_delay_hrd_flag = false;
+      if (fixed_pic_rate_within_cvs_flag) {
+        readExpGolomb(bitstream);
+      } else {
+        low_delay_hrd_flag = bitstream.readBits(1) === 1;
+      }
+      let CpbCnt = 1;
+      if (!low_delay_hrd_flag) {
+        const cpb_cnt_minus1 = readExpGolomb(bitstream);
+        CpbCnt = cpb_cnt_minus1 + 1;
+      }
+      if (nal_hrd_parameters_present_flag) {
+        skipSubLayerHrdParameters(bitstream, CpbCnt, sub_pic_hrd_params_present_flag);
+      }
+      if (vcl_hrd_parameters_present_flag) {
+        skipSubLayerHrdParameters(bitstream, CpbCnt, sub_pic_hrd_params_present_flag);
+      }
+    }
+  };
+  var skipSubLayerHrdParameters = (bitstream, CpbCnt, sub_pic_hrd_params_present_flag) => {
+    for (let i = 0; i < CpbCnt; i++) {
+      readExpGolomb(bitstream);
+      readExpGolomb(bitstream);
+      if (sub_pic_hrd_params_present_flag) {
+        readExpGolomb(bitstream);
+        readExpGolomb(bitstream);
+      }
+      bitstream.readBits(1);
+    }
+  };
+  var serializeHevcDecoderConfigurationRecord = (record) => {
+    const bytes = [];
+    bytes.push(record.configurationVersion);
+    bytes.push(
+      (record.generalProfileSpace & 3) << 6 | (record.generalTierFlag & 1) << 5 | record.generalProfileIdc & 31
+    );
+    bytes.push(record.generalProfileCompatibilityFlags >>> 24 & 255);
+    bytes.push(record.generalProfileCompatibilityFlags >>> 16 & 255);
+    bytes.push(record.generalProfileCompatibilityFlags >>> 8 & 255);
+    bytes.push(record.generalProfileCompatibilityFlags & 255);
+    bytes.push(...record.generalConstraintIndicatorFlags);
+    bytes.push(record.generalLevelIdc & 255);
+    bytes.push(240 | record.minSpatialSegmentationIdc >> 8 & 15);
+    bytes.push(record.minSpatialSegmentationIdc & 255);
+    bytes.push(252 | record.parallelismType & 3);
+    bytes.push(252 | record.chromaFormatIdc & 3);
+    bytes.push(248 | record.bitDepthLumaMinus8 & 7);
+    bytes.push(248 | record.bitDepthChromaMinus8 & 7);
+    bytes.push(record.avgFrameRate >> 8 & 255);
+    bytes.push(record.avgFrameRate & 255);
+    bytes.push(
+      (record.constantFrameRate & 3) << 6 | (record.numTemporalLayers & 7) << 3 | (record.temporalIdNested & 1) << 2 | record.lengthSizeMinusOne & 3
+    );
+    bytes.push(record.arrays.length & 255);
+    for (const arr of record.arrays) {
+      bytes.push(
+        (arr.arrayCompleteness & 1) << 7 | 0 << 6 | arr.nalUnitType & 63
+      );
+      bytes.push(arr.nalUnits.length >> 8 & 255);
+      bytes.push(arr.nalUnits.length & 255);
+      for (const nal of arr.nalUnits) {
+        bytes.push(nal.length >> 8 & 255);
+        bytes.push(nal.length & 255);
+        for (let i = 0; i < nal.length; i++) {
+          bytes.push(nal[i]);
+        }
+      }
+    }
+    return new Uint8Array(bytes);
+  };
+  var extractVp9CodecInfoFromPacket = (packet) => {
+    const bitstream = new Bitstream(packet);
+    const frameMarker = bitstream.readBits(2);
+    if (frameMarker !== 2) {
+      return null;
+    }
+    const profileLowBit = bitstream.readBits(1);
+    const profileHighBit = bitstream.readBits(1);
+    const profile = (profileHighBit << 1) + profileLowBit;
+    if (profile === 3) {
+      bitstream.skipBits(1);
+    }
+    const showExistingFrame = bitstream.readBits(1);
+    if (showExistingFrame === 1) {
+      return null;
+    }
+    const frameType = bitstream.readBits(1);
+    if (frameType !== 0) {
+      return null;
+    }
+    bitstream.skipBits(2);
+    const syncCode = bitstream.readBits(24);
+    if (syncCode !== 4817730) {
+      return null;
+    }
+    let bitDepth = 8;
+    if (profile >= 2) {
+      const tenOrTwelveBit = bitstream.readBits(1);
+      bitDepth = tenOrTwelveBit ? 12 : 10;
+    }
+    const colorSpace = bitstream.readBits(3);
+    let chromaSubsampling = 0;
+    let videoFullRangeFlag = 0;
+    if (colorSpace !== 7) {
+      const colorRange = bitstream.readBits(1);
+      videoFullRangeFlag = colorRange;
+      if (profile === 1 || profile === 3) {
+        const subsamplingX = bitstream.readBits(1);
+        const subsamplingY = bitstream.readBits(1);
+        chromaSubsampling = !subsamplingX && !subsamplingY ? 3 : subsamplingX && !subsamplingY ? 2 : 1;
+        bitstream.skipBits(1);
+      } else {
+        chromaSubsampling = 1;
+      }
+    } else {
+      chromaSubsampling = 3;
+      videoFullRangeFlag = 1;
+    }
+    const widthMinusOne = bitstream.readBits(16);
+    const heightMinusOne = bitstream.readBits(16);
+    const width = widthMinusOne + 1;
+    const height = heightMinusOne + 1;
+    const pictureSize = width * height;
+    let level = last(VP9_LEVEL_TABLE).level;
+    for (const entry of VP9_LEVEL_TABLE) {
+      if (pictureSize <= entry.maxPictureSize) {
+        level = entry.level;
+        break;
+      }
+    }
+    const matrixCoefficients = colorSpace === 7 ? 0 : colorSpace === 2 ? 1 : colorSpace === 1 ? 6 : 2;
+    const colourPrimaries = colorSpace === 2 ? 1 : colorSpace === 1 ? 6 : 2;
+    const transferCharacteristics = colorSpace === 2 ? 1 : colorSpace === 1 ? 6 : 2;
+    return {
+      profile,
+      level,
+      bitDepth,
+      chromaSubsampling,
+      videoFullRangeFlag,
+      colourPrimaries,
+      transferCharacteristics,
+      matrixCoefficients
+    };
+  };
+  var iterateAv1PacketObus = function* (packet) {
+    const bitstream = new Bitstream(packet);
+    const readLeb128 = () => {
+      let value = 0;
+      for (let i = 0; i < 8; i++) {
+        const byte = bitstream.readAlignedByte();
+        value |= (byte & 127) << i * 7;
+        if (!(byte & 128)) {
+          break;
+        }
+        if (i === 7 && byte & 128) {
+          return null;
+        }
+      }
+      if (value >= 2 ** 32 - 1) {
+        return null;
+      }
+      return value;
+    };
+    while (bitstream.getBitsLeft() >= 8) {
+      bitstream.skipBits(1);
+      const obuType = bitstream.readBits(4);
+      const obuExtension = bitstream.readBits(1);
+      const obuHasSizeField = bitstream.readBits(1);
+      bitstream.skipBits(1);
+      if (obuExtension) {
+        bitstream.skipBits(8);
+      }
+      let obuSize;
+      if (obuHasSizeField) {
+        const obuSizeValue = readLeb128();
+        if (obuSizeValue === null) return;
+        obuSize = obuSizeValue;
+      } else {
+        obuSize = Math.floor(bitstream.getBitsLeft() / 8);
+      }
+      assert(bitstream.pos % 8 === 0);
+      yield {
+        type: obuType,
+        data: packet.subarray(bitstream.pos / 8, bitstream.pos / 8 + obuSize)
+      };
+      bitstream.skipBits(obuSize * 8);
+    }
+  };
+  var extractAv1CodecInfoFromPacket = (packet) => {
+    for (const { type, data } of iterateAv1PacketObus(packet)) {
+      if (type !== 1) {
+        continue;
+      }
+      const bitstream = new Bitstream(data);
+      const seqProfile = bitstream.readBits(3);
+      const stillPicture = bitstream.readBits(1);
+      const reducedStillPictureHeader = bitstream.readBits(1);
+      let seqLevel = 0;
+      let seqTier = 0;
+      let bufferDelayLengthMinus1 = 0;
+      if (reducedStillPictureHeader) {
+        seqLevel = bitstream.readBits(5);
+      } else {
+        const timingInfoPresentFlag = bitstream.readBits(1);
+        if (timingInfoPresentFlag) {
+          bitstream.skipBits(32);
+          bitstream.skipBits(32);
+          const equalPictureInterval = bitstream.readBits(1);
+          if (equalPictureInterval) {
+            return null;
+          }
+        }
+        const decoderModelInfoPresentFlag = bitstream.readBits(1);
+        if (decoderModelInfoPresentFlag) {
+          bufferDelayLengthMinus1 = bitstream.readBits(5);
+          bitstream.skipBits(32);
+          bitstream.skipBits(5);
+          bitstream.skipBits(5);
+        }
+        const operatingPointsCntMinus1 = bitstream.readBits(5);
+        for (let i = 0; i <= operatingPointsCntMinus1; i++) {
+          bitstream.skipBits(12);
+          const seqLevelIdx = bitstream.readBits(5);
+          if (i === 0) {
+            seqLevel = seqLevelIdx;
+          }
+          if (seqLevelIdx > 7) {
+            const seqTierTemp = bitstream.readBits(1);
+            if (i === 0) {
+              seqTier = seqTierTemp;
+            }
+          }
+          if (decoderModelInfoPresentFlag) {
+            const decoderModelPresentForThisOp = bitstream.readBits(1);
+            if (decoderModelPresentForThisOp) {
+              const n = bufferDelayLengthMinus1 + 1;
+              bitstream.skipBits(n);
+              bitstream.skipBits(n);
+              bitstream.skipBits(1);
+            }
+          }
+          const initialDisplayDelayPresentFlag = bitstream.readBits(1);
+          if (initialDisplayDelayPresentFlag) {
+            bitstream.skipBits(4);
+          }
+        }
+      }
+      const frameWidthBitsMinus1 = bitstream.readBits(4);
+      const frameHeightBitsMinus1 = bitstream.readBits(4);
+      const n1 = frameWidthBitsMinus1 + 1;
+      bitstream.skipBits(n1);
+      const n2 = frameHeightBitsMinus1 + 1;
+      bitstream.skipBits(n2);
+      let frameIdNumbersPresentFlag = 0;
+      if (reducedStillPictureHeader) {
+        frameIdNumbersPresentFlag = 0;
+      } else {
+        frameIdNumbersPresentFlag = bitstream.readBits(1);
+      }
+      if (frameIdNumbersPresentFlag) {
+        bitstream.skipBits(4);
+        bitstream.skipBits(3);
+      }
+      bitstream.skipBits(1);
+      bitstream.skipBits(1);
+      bitstream.skipBits(1);
+      if (!reducedStillPictureHeader) {
+        bitstream.skipBits(1);
+        bitstream.skipBits(1);
+        bitstream.skipBits(1);
+        bitstream.skipBits(1);
+        const enableOrderHint = bitstream.readBits(1);
+        if (enableOrderHint) {
+          bitstream.skipBits(1);
+          bitstream.skipBits(1);
+        }
+        const seqChooseScreenContentTools = bitstream.readBits(1);
+        let seqForceScreenContentTools = 0;
+        if (seqChooseScreenContentTools) {
+          seqForceScreenContentTools = 2;
+        } else {
+          seqForceScreenContentTools = bitstream.readBits(1);
+        }
+        if (seqForceScreenContentTools > 0) {
+          const seqChooseIntegerMv = bitstream.readBits(1);
+          if (!seqChooseIntegerMv) {
+            bitstream.skipBits(1);
+          }
+        }
+        if (enableOrderHint) {
+          bitstream.skipBits(3);
+        }
+      }
+      bitstream.skipBits(1);
+      bitstream.skipBits(1);
+      bitstream.skipBits(1);
+      const highBitdepth = bitstream.readBits(1);
+      let bitDepth = 8;
+      if (seqProfile === 2 && highBitdepth) {
+        const twelveBit = bitstream.readBits(1);
+        bitDepth = twelveBit ? 12 : 10;
+      } else if (seqProfile <= 2) {
+        bitDepth = highBitdepth ? 10 : 8;
+      }
+      let monochrome = 0;
+      if (seqProfile !== 1) {
+        monochrome = bitstream.readBits(1);
+      }
+      let chromaSubsamplingX = 1;
+      let chromaSubsamplingY = 1;
+      let chromaSamplePosition = 0;
+      if (!monochrome) {
+        if (seqProfile === 0) {
+          chromaSubsamplingX = 1;
+          chromaSubsamplingY = 1;
+        } else if (seqProfile === 1) {
+          chromaSubsamplingX = 0;
+          chromaSubsamplingY = 0;
+        } else {
+          if (bitDepth === 12) {
+            chromaSubsamplingX = bitstream.readBits(1);
+            if (chromaSubsamplingX) {
+              chromaSubsamplingY = bitstream.readBits(1);
+            }
+          }
+        }
+        if (chromaSubsamplingX && chromaSubsamplingY) {
+          chromaSamplePosition = bitstream.readBits(2);
+        }
+      }
+      return {
+        profile: seqProfile,
+        level: seqLevel,
+        tier: seqTier,
+        bitDepth,
+        monochrome,
+        chromaSubsamplingX,
+        chromaSubsamplingY,
+        chromaSamplePosition
+      };
+    }
+    return null;
+  };
+  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_REGISTRATION_DESCRIPTOR = new Uint8Array([5, 4, 65, 67, 45, 51]);
+  var EAC3_REGISTRATION_DESCRIPTOR = new Uint8Array([5, 4, 69, 65, 67, 51]);
+
+  // packages/server/src/video-encoder.ts
+  var NodeAvVideoEncoder = class extends import_mediabunny3.CustomVideoEncoder {
+    constructor() {
+      super(...arguments);
+      this.codecContext = null;
+      this.lastBuffer = null;
+      this.packetEmitted = false;
+      this.scaler = null;
+      this.lastScalerKey = null;
+      this.dstFrame = null;
+      // Bookkeeping to restore the original timing information
+      this.preciseTimings = [];
+    }
+    static supports(codec, config) {
+      return (codec === "avc" || codec === "hevc" || codec === "vp8" || codec === "vp9" || codec === "av1") && config.bitrateMode !== "quantizer";
+    }
+    async init() {
+      this.frame = new NodeAv4.Frame();
+      this.frame.alloc();
+      this.frame.timeBase = new NodeAv4.Rational(1, 1e6);
+      this.packet = new NodeAv4.Packet();
+      this.packet.alloc();
+      const codecId = CODEC_TO_CODEC_ID[this.codec];
+      assert(codecId !== void 0);
+      let codec = null;
+      if (this.codec === "vp9" && this.config.alpha === "keep") {
+        codec = NodeAv4.Codec.findEncoderByName(LIBVPX_VP9) ?? NodeAv4.Codec.findEncoder(codecId);
+      } else if (this.config.hardwareAcceleration === "prefer-software") {
+        codec = NodeAv4.Codec.findEncoder(codecId);
+      } else {
+        codec = getHardwareEncoderCodec(codecId) ?? NodeAv4.Codec.findEncoder(codecId);
+      }
+      if (!codec) {
+        throw new Error(`Unable to obtain libav codec for '${this.codec}'.`);
+      }
+      this.avCodec = codec;
+      await this.createCodecContext();
+    }
+    async createCodecContext() {
+      assert(this.codecContext === null);
+      const codecContext = new NodeAv4.CodecContext();
+      codecContext.allocContext3(this.avCodec);
+      let pixelFormat = NodeAv4.AV_PIX_FMT_YUV420P;
+      if (this.avCodec.pixelFormats) {
+        if (!this.avCodec.pixelFormats.includes(NodeAv4.AV_PIX_FMT_YUV420P)) {
+          pixelFormat = this.avCodec.pixelFormats[0];
+        }
+        if (this.config.alpha === "keep" && this.avCodec.pixelFormats.includes(NodeAv4.AV_PIX_FMT_YUVA420P)) {
+          pixelFormat = NodeAv4.AV_PIX_FMT_YUVA420P;
+        }
+      }
+      const pixelAspectRatio = simplifyRational({
+        num: (this.config.displayWidth ?? this.config.width) * this.config.height,
+        den: (this.config.displayHeight ?? this.config.height) * this.config.width
+      });
+      codecContext.width = this.config.width;
+      codecContext.height = this.config.height;
+      codecContext.pixelFormat = pixelFormat;
+      codecContext.timeBase = new NodeAv4.Rational(1, 1e6);
+      codecContext.gopSize = 60;
+      codecContext.framerate = new NodeAv4.Rational(Math.round(this.config.framerate ?? 0) || 30, 1);
+      codecContext.bitRate = BigInt(
+        this.config.bitrate ?? import_mediabunny3.QUALITY_MEDIUM._toVideoBitrate(this.codec, this.config.width, this.config.height)
+      );
+      codecContext.sampleAspectRatio = new NodeAv4.Rational(pixelAspectRatio.num, pixelAspectRatio.den);
+      if (this.config.bitrateMode === "constant") {
+        codecContext.rcMinRate = codecContext.bitRate;
+        codecContext.rcMaxRate = codecContext.bitRate;
+      }
+      const isRealtime = this.config.latencyMode === "realtime";
+      if (this.avCodec.name === "libx264") {
+        if (isRealtime) {
+          codecContext.setOption("tune", "zerolatency");
+          codecContext.setOption("preset", "ultrafast");
+        }
+      } else if (this.avCodec.name === "libx265") {
+        codecContext.setOption("x265-params", "log-level=error");
+        if (isRealtime) {
+          codecContext.setOption("tune", "zerolatency");
+          codecContext.setOption("preset", "ultrafast");
+        }
+      } else if (this.avCodec.name === "libvpx") {
+        if (isRealtime) {
+          codecContext.setOption("deadline", "realtime");
+          codecContext.setOption("cpu-used", "8");
+        } else {
+          codecContext.setOption("cpu-used", "8");
+        }
+      } else if (this.avCodec.name === "libvpx-vp9") {
+        codecContext.setOption("deadline", "realtime");
+        if (isRealtime) {
+          codecContext.setOption("cpu-used", "8");
+        } else {
+          codecContext.setOption("cpu-used", "5");
+        }
+      } else if (this.avCodec.name === "libsvtav1") {
+        process.env["SVT_LOG"] = "1";
+        if (isRealtime) {
+          codecContext.setOption("preset", "12");
+        }
+      }
+      const ret = await codecContext.open2();
+      NodeAv4.FFmpegError.throwIfError(ret, "Open codec context");
+      this.codecContext = codecContext;
+    }
+    async encode(videoSample, options) {
+      if (this.codecContext === null) {
+        await this.createCodecContext();
+        assert(this.codecContext);
+      }
+      if (videoSample._data instanceof AvFrameVideoSampleResource) {
+        this.frame.ref(videoSample._data.frame);
+      } else {
+        if (videoSample.format === null) {
+          throw new Error("Cannot encode foreign VideoSample with unknown (null) format.");
+        }
+        this.lastBuffer = await copyVideoSampleToAvFrame(videoSample, this.frame, this.lastBuffer);
+      }
+      let frameToEncode = this.frame;
+      const requiresScaler = this.codecContext.pixelFormat !== this.frame.format || this.codecContext.width !== this.frame.width || this.codecContext.height !== this.frame.height;
+      if (requiresScaler) {
+        if (!this.scaler) {
+          this.scaler = new NodeAv4.SoftwareScaleContext();
+        }
+        const key = `${this.frame.width}x${this.frame.height}:${this.frame.format}`;
+        const needsConfigure = key !== this.lastScalerKey;
+        if (needsConfigure) {
+          this.scaler.getContext(
+            this.frame.width,
+            this.frame.height,
+            this.frame.format,
+            this.codecContext.width,
+            this.codecContext.height,
+            this.codecContext.pixelFormat,
+            NodeAv4.SWS_FAST_BILINEAR
+          );
+          this.lastScalerKey = key;
+          const ret2 = this.scaler.initContext();
+          NodeAv4.FFmpegError.throwIfError(ret2, "initContext");
+        }
+        if (!this.dstFrame) {
+          this.dstFrame = new NodeAv4.Frame();
+          this.dstFrame.alloc();
+          this.dstFrame.width = this.codecContext.width;
+          this.dstFrame.height = this.codecContext.height;
+          this.dstFrame.format = this.codecContext.pixelFormat;
+          this.dstFrame.allocBuffer();
+        }
+        await this.scaler.scaleFrame(this.dstFrame, this.frame);
+        this.dstFrame.copyProps(this.frame);
+        frameToEncode = this.dstFrame;
+      }
+      frameToEncode.pts = BigInt(videoSample.microsecondTimestamp);
+      frameToEncode.duration = BigInt(videoSample.microsecondDuration);
+      frameToEncode.timeBase = new NodeAv4.Rational(1, 1e6);
+      frameToEncode.pictType = options?.keyFrame ? NodeAv4.AV_PICTURE_TYPE_I : NodeAv4.AV_PICTURE_TYPE_NONE;
+      frameToEncode.keyFrame = options?.keyFrame ? 1 : 0;
+      const preciseTimingIndex = binarySearchLessOrEqual(
+        this.preciseTimings,
+        videoSample.microsecondTimestamp,
+        (x) => x.microsecondTimestamp
+      );
+      const existingEntry = preciseTimingIndex !== -1 ? this.preciseTimings[preciseTimingIndex] : null;
+      if (existingEntry && existingEntry.microsecondTimestamp === videoSample.microsecondTimestamp) {
+        if (existingEntry.timestamp !== videoSample.timestamp) {
+          existingEntry.timestampIsValid = false;
+        }
+        if (existingEntry.duration !== videoSample.duration) {
+          existingEntry.durationIsValid = false;
+        }
+      } else {
+        this.preciseTimings.splice(preciseTimingIndex + 1, 0, {
+          microsecondTimestamp: videoSample.microsecondTimestamp,
+          timestamp: videoSample.timestamp,
+          duration: videoSample.duration,
+          timestampIsValid: true,
+          durationIsValid: true
+        });
+        if (this.preciseTimings.length > 128) {
+          this.preciseTimings.shift();
+        }
+      }
+      const ret = await this.codecContext.sendFrame(frameToEncode);
+      NodeAv4.FFmpegError.throwIfError(ret, "Send frame");
+      while (true) {
+        const receiveRet = await this.codecContext.receivePacket(this.packet);
+        if (receiveRet === NodeAv4.AVERROR_EAGAIN || receiveRet === NodeAv4.AVERROR_EOF) {
+          break;
+        }
+        this.receivePacket(receiveRet);
+      }
+    }
+    receivePacket(ret) {
+      assert(this.codecContext);
+      NodeAv4.FFmpegError.throwIfError(ret, "Receive packet");
+      if (!this.packet.data) {
+        return;
+      }
+      let packetData = toUint8Array(this.packet.data);
+      let timestamp = Number(this.packet.pts) / 1e6;
+      let duration = Number(this.packet.duration) / 1e6;
+      const preciseTimingIndex = binarySearchLessOrEqual(
+        this.preciseTimings,
+        Number(this.packet.pts),
+        (x) => x.microsecondTimestamp
+      );
+      const entry = preciseTimingIndex !== -1 ? this.preciseTimings[preciseTimingIndex] : null;
+      if (entry && entry.microsecondTimestamp === Number(this.packet.pts)) {
+        if (entry.timestampIsValid) {
+          timestamp = entry.timestamp;
+        }
+        if (entry.durationIsValid) {
+          duration = entry.duration;
+        }
+      }
+      const metadata = {};
+      let decoderConfigCodecString = null;
+      let decoderConfigDescription = null;
+      if (this.codec === "avc" || this.codec === "hevc") {
+        let expectsAnnexB = false;
+        if (this.codec === "avc") {
+          expectsAnnexB = this.config.avc?.format === "annexb";
+        } else {
+          expectsAnnexB = this.config.hevc?.format === "annexb";
+        }
+        if (!this.packetEmitted) {
+          let serializedRecord;
+          if (this.codec === "avc") {
+            const record = extractAvcDecoderConfigurationRecord(this.packet.data);
+            if (!record) {
+              throw new Error("Invalid AVC data, could not extract decoder configuration record.");
+            }
+            serializedRecord = serializeAvcDecoderConfigurationRecord(record);
+          } else {
+            const record = extractHevcDecoderConfigurationRecord(this.packet.data);
+            if (!record) {
+              throw new Error("Invalid HEVC data, could not extract decoder configuration record.");
+            }
+            serializedRecord = serializeHevcDecoderConfigurationRecord(record);
+          }
+          decoderConfigCodecString = extractVideoCodecString({
+            width: this.config.width,
+            height: this.config.height,
+            codec: this.codec,
+            codecDescription: serializedRecord,
+            colorSpace: null,
+            avcType: 1,
+            avcCodecInfo: null,
+            hevcCodecInfo: null,
+            vp9CodecInfo: null,
+            av1CodecInfo: null
+          });
+          if (!expectsAnnexB) {
+            decoderConfigDescription = serializedRecord;
+          }
+        }
+        if (!expectsAnnexB) {
+          const NAL_UNIT_LENGTH_SIZE = 4;
+          const nalUnits = [];
+          for (const loc of iterateNalUnitsInAnnexB(packetData)) {
+            if (this.codec === "avc") {
+              const naluType = extractNalUnitTypeForAvc(packetData[loc.offset]);
+              if (naluType !== 7 /* SPS */ && naluType !== 8 /* PPS */ && naluType !== 13 /* SPS_EXT */) {
+                nalUnits.push(loc);
+              }
+            } else {
+              const naluType = extractNalUnitTypeForHevc(packetData[loc.offset]);
+              if (naluType !== 33 /* SPS_NUT */ && naluType !== 34 /* PPS_NUT */ && naluType !== 32 /* VPS_NUT */) {
+                nalUnits.push(loc);
+              }
+            }
+          }
+          let totalSize = 0;
+          for (const nalUnit of nalUnits) {
+            totalSize += NAL_UNIT_LENGTH_SIZE + nalUnit.length;
+          }
+          const lengthPrefixedData = new Uint8Array(totalSize);
+          const dataView = new DataView(lengthPrefixedData.buffer);
+          let offset = 0;
+          for (const nalUnit of nalUnits) {
+            const length = nalUnit.length;
+            dataView.setUint32(offset, length, false);
+            offset += 4;
+            lengthPrefixedData.set(
+              packetData.subarray(nalUnit.offset, nalUnit.offset + nalUnit.length),
+              offset
+            );
+            offset += nalUnit.length;
+          }
+          packetData = lengthPrefixedData;
+        }
+      } else if (this.codec === "vp8") {
+        if (!this.packetEmitted) {
+          decoderConfigCodecString = extractVideoCodecString({
+            width: this.config.width,
+            height: this.config.height,
+            codec: "vp8",
+            codecDescription: null,
+            colorSpace: null,
+            avcType: null,
+            avcCodecInfo: null,
+            hevcCodecInfo: null,
+            vp9CodecInfo: null,
+            av1CodecInfo: null
+          });
+        }
+      } else if (this.codec === "vp9") {
+        if (!this.packetEmitted) {
+          const vp9CodecInfo = extractVp9CodecInfoFromPacket(packetData);
+          decoderConfigCodecString = extractVideoCodecString({
+            width: this.config.width,
+            height: this.config.height,
+            codec: "vp9",
+            codecDescription: null,
+            colorSpace: null,
+            avcType: null,
+            avcCodecInfo: null,
+            hevcCodecInfo: null,
+            vp9CodecInfo,
+            av1CodecInfo: null
+          });
+        }
+      } else if (this.codec === "av1") {
+        if (!this.packetEmitted) {
+          const av1CodecInfo = extractAv1CodecInfoFromPacket(packetData);
+          decoderConfigCodecString = extractVideoCodecString({
+            width: this.config.width,
+            height: this.config.height,
+            codec: "av1",
+            codecDescription: null,
+            colorSpace: null,
+            avcType: null,
+            avcCodecInfo: null,
+            hevcCodecInfo: null,
+            vp9CodecInfo: null,
+            av1CodecInfo
+          });
+        }
+      } else {
+        throw new Error("Unreachable.");
+      }
+      const sideData = {};
+      const matroskaBlockAdditional = this.packet.getSideData(NodeAv4.AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL);
+      if (matroskaBlockAdditional) {
+        sideData.alpha = toUint8Array(matroskaBlockAdditional).subarray(8);
+      }
+      const packet = new import_mediabunny3.EncodedPacket(
+        packetData,
+        this.packet.isKeyframe ? "key" : "delta",
+        timestamp,
+        duration,
+        void 0,
+        void 0,
+        sideData
+      );
+      if (decoderConfigCodecString !== null) {
+        metadata.decoderConfig = {
+          codec: decoderConfigCodecString,
+          codedWidth: this.codecContext.width,
+          codedHeight: this.codecContext.height,
+          displayAspectWidth: this.config.displayWidth ?? this.codecContext.width,
+          displayAspectHeight: this.config.displayHeight ?? this.codecContext.height,
+          description: decoderConfigDescription ?? void 0,
+          colorSpace: {
+            primaries: unmapColorPrimaries(this.codecContext.colorPrimaries),
+            matrix: unmapMatrixCoefficients(this.codecContext.colorSpace),
+            transfer: unmapTransferCharacteristics(this.codecContext.colorTrc),
+            fullRange: this.codecContext.colorRange === NodeAv4.AVCOL_RANGE_JPEG ? true : this.codecContext.colorRange === NodeAv4.AVCOL_RANGE_MPEG ? false : void 0
+          }
+        };
+      }
+      this.packetEmitted = true;
+      this.onPacket(packet, metadata);
+    }
+    async flush() {
+      if (this.codecContext) {
+        const ret = await this.codecContext.sendFrame(null);
+        NodeAv4.FFmpegError.throwIfError(ret, "Send frame");
+        while (true) {
+          const receiveRet = await this.codecContext.receivePacket(this.packet);
+          if (receiveRet === NodeAv4.AVERROR_EAGAIN || receiveRet === NodeAv4.AVERROR_EOF) {
+            break;
+          }
+          this.receivePacket(receiveRet);
+        }
+        this.codecContext.freeContext();
+        this.codecContext = null;
+      }
+      this.packetEmitted = false;
+    }
+    close() {
+      this.codecContext?.freeContext();
+      this.frame.free();
+      this.packet.free();
+      this.scaler?.freeContext();
+      this.dstFrame?.free();
+    }
+  };
+
+  // packages/server/src/audio-decoder.ts
+  var import_mediabunny5 = __require("mediabunny");
+  var NodeAv6 = __toESM(__require("node-av"));
+
+  // packages/server/src/audio-sample.ts
+  var import_mediabunny4 = __require("mediabunny");
+  var NodeAv5 = __toESM(__require("node-av"));
+  var AvFrameAudioSampleResource = class extends import_mediabunny4.AudioSampleResource {
+    /**
+     * The NodeAV [`Frame`](https://seydx.github.io/node-av/api/lib/classes/Frame.html) instance backing this resource.
+     * Access throws if the resource has already been closed.
+     */
+    get frame() {
+      if (!this._frame) {
+        throw new Error("AvFrameAudioSampleResource has been closed.");
+      }
+      return this._frame;
+    }
+    constructor(frame) {
+      super();
+      if (frame.getMediaType() !== NodeAv5.AVMEDIA_TYPE_AUDIO) {
+        throw new Error("AvFrameAudioSampleResource must be initialized with an audio frame.");
+      }
+      this._frame = frame;
+    }
+    getFormat() {
+      const result = toAudioSampleFormat(this.frame.format);
+      if (result === null) {
+        const name = NodeAv5.avGetSampleFmtName(this.frame.format);
+        throw new TypeError(`Unsupported audio sample format: ${name} (${this.frame.format})`);
+      }
+      return result;
+    }
+    getSampleRate() {
+      return this.frame.sampleRate;
+    }
+    getNumberOfChannels() {
+      return this.frame.channels;
+    }
+    getNumberOfFrames() {
+      return this.frame.nbSamples;
+    }
+    getTimestamp() {
+      return Number(this.frame.pts) / this.frame.timeBase.den;
+    }
+    close() {
+      this.frame.free();
+      this._frame = null;
+    }
+    getDataPlane(planeIndex) {
+      assert(this.frame.data && planeIndex < this.frame.data.length);
+      return toUint8Array(this.frame.data[planeIndex]);
+    }
+  };
+  var copyAudioSampleToAvFrame = (sample, frame) => {
+    frame.format = fromAudioSampleFormat(sample.format);
+    frame.nbSamples = sample.numberOfFrames;
+    frame.sampleRate = sample.sampleRate;
+    frame.channelLayout = getChannelLayout(sample.numberOfChannels);
+    frame.allocBuffer();
+    assert(frame.data);
+    for (let i = 0; i < frame.data.length; i++) {
+      sample.copyTo(frame.data[i], { planeIndex: i });
+    }
+  };
+
+  // packages/server/src/audio-decoder.ts
+  var NodeAvAudioDecoder = class extends import_mediabunny5.CustomAudioDecoder {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static supports(codec, config) {
+      return codec === "aac" || codec === "opus" || codec === "mp3" || codec === "vorbis" || codec === "flac" || codec === "ac3" || codec === "eac3";
+    }
+    async init() {
+      this.frame = new NodeAv6.Frame();
+      this.frame.alloc();
+      this.packet = new NodeAv6.Packet();
+      this.packet.alloc();
+      const codecId = CODEC_TO_CODEC_ID[this.codec];
+      assert(codecId !== void 0);
+      const codec = NodeAv6.Codec.findDecoder(codecId);
+      if (codec === null) {
+        throw new Error(`Unable to obtain libav codec for '${this.codec}'.`);
+      }
+      const codecContext = new NodeAv6.CodecContext();
+      codecContext.allocContext3(codec);
+      codecContext.sampleRate = this.config.sampleRate;
+      codecContext.channelLayout = getChannelLayout(this.config.numberOfChannels);
+      codecContext.timeBase = new NodeAv6.Rational(1, this.config.sampleRate);
+      codecContext.codecType = NodeAv6.AVMEDIA_TYPE_AUDIO;
+      codecContext.codecId = codecId;
+      codecContext.extraData = this.config.description ? Buffer.from(toUint8Array(this.config.description)) : null;
+      const ret = await codecContext.open2();
+      NodeAv6.FFmpegError.throwIfError(ret, "Open codec context");
+      this.codecContext = codecContext;
+    }
+    async decode(packet) {
+      this.packet.isKeyframe = packet.type === "key";
+      this.packet.data = Buffer.from(packet.data);
+      this.packet.timeBase = { num: 1, den: this.config.sampleRate };
+      this.packet.pts = BigInt(Math.round(packet.timestamp * this.config.sampleRate));
+      this.packet.dts = NodeAv6.AV_NOPTS_VALUE;
+      this.packet.duration = BigInt(Math.round(packet.duration * this.config.sampleRate));
+      const ret = await this.codecContext.sendPacket(this.packet);
+      NodeAv6.FFmpegError.throwIfError(ret, "Send packet");
+      while (true) {
+        const receiveRet = await this.codecContext.receiveFrame(this.frame);
+        if (receiveRet === NodeAv6.AVERROR_EAGAIN || receiveRet === NodeAv6.AVERROR_EOF) {
+          break;
+        }
+        this.receiveFrame(receiveRet);
+      }
+    }
+    receiveFrame(ret) {
+      NodeAv6.FFmpegError.throwIfError(ret, "Receive frame");
+      const clone = this.frame.clone();
+      if (!clone) {
+        throw new Error("Allocation failure during frame clone.");
+      }
+      clone.timeBase = new NodeAv6.Rational(1, this.config.sampleRate);
+      this.onSample(new import_mediabunny5.AudioSample(new AvFrameAudioSampleResource(clone)));
+    }
+    async flush() {
+      const ret = await this.codecContext.sendPacket(null);
+      NodeAv6.FFmpegError.throwIfError(ret, "Flush decoder");
+      while (true) {
+        const receiveRet = await this.codecContext.receiveFrame(this.frame);
+        if (receiveRet === NodeAv6.AVERROR_EAGAIN || receiveRet === NodeAv6.AVERROR_EOF) {
+          break;
+        }
+        this.receiveFrame(receiveRet);
+      }
+      this.codecContext.flushBuffers();
+    }
+    close() {
+      this.codecContext.freeContext();
+      this.frame.free();
+      this.packet.free();
+    }
+  };
+
+  // packages/server/src/audio-encoder.ts
+  var import_mediabunny6 = __require("mediabunny");
+  var NodeAv7 = __toESM(__require("node-av"));
+  var AAC_SAMPLE_RATES = [96e3, 88200, 64e3, 48e3, 44100, 32e3, 24e3, 22050, 16e3, 12e3, 11025, 8e3, 7350];
+  var OPUS_SAMPLE_RATES = [8e3, 12e3, 16e3, 24e3, 48e3];
+  var MP3_SAMPLE_RATES = [8e3, 11025, 12e3, 16e3, 22050, 24e3, 32e3, 44100, 48e3];
+  var AC3_SAMPLE_RATES = [32e3, 44100, 48e3];
+  var FRAME_SIZE_FALLBACK = 1024;
+  var NodeAvAudioEncoder = class extends import_mediabunny6.CustomAudioEncoder {
+    constructor() {
+      super(...arguments);
+      this.codecContext = null;
+      this.firstExpectedTimestamp = null;
+      this.outputTimestampOffset = 0;
+      this.resampler = null;
+      this.inputParametersKey = null;
+      this.resamplerInputSampleRate = null;
+      this.nextResamplerPts = null;
+      this.dstFrame = null;
+      this.packetEmitted = false;
+      this.adtsHeaderTemplate = null;
+    }
+    static supports(codec, config) {
+      const { numberOfChannels, sampleRate } = config;
+      return codec === "aac" && numberOfChannels >= 1 && numberOfChannels <= 48 && AAC_SAMPLE_RATES.includes(sampleRate) || codec === "opus" && numberOfChannels >= 1 && numberOfChannels <= 255 && OPUS_SAMPLE_RATES.includes(sampleRate) || codec === "mp3" && numberOfChannels >= 1 && numberOfChannels <= 2 && MP3_SAMPLE_RATES.includes(sampleRate) || codec === "vorbis" && numberOfChannels >= 1 && numberOfChannels <= 255 && sampleRate <= 2e5 || codec === "flac" && numberOfChannels >= 1 && numberOfChannels <= 8 && sampleRate <= 655350 || codec === "ac3" && numberOfChannels >= 1 && numberOfChannels <= 6 && AC3_SAMPLE_RATES.includes(sampleRate) || codec === "eac3" && numberOfChannels >= 1 && numberOfChannels <= 16 && AC3_SAMPLE_RATES.includes(sampleRate);
+    }
+    async init() {
+      this.frame = new NodeAv7.Frame();
+      this.frame.alloc();
+      this.packet = new NodeAv7.Packet();
+      this.packet.alloc();
+      const codecId = CODEC_TO_CODEC_ID[this.codec];
+      assert(codecId !== void 0);
+      const codec = NodeAv7.Codec.findEncoder(codecId);
+      if (!codec) {
+        throw new Error(`Unable to obtain libav codec for '${this.codec}'.`);
+      }
+      this.avCodec = codec;
+      await this.createCodecContext();
+    }
+    async createCodecContext() {
+      assert(this.codecContext === null);
+      const codecContext = new NodeAv7.CodecContext();
+      codecContext.allocContext3(this.avCodec);
+      let sampleFormat = NodeAv7.AV_SAMPLE_FMT_FLTP;
+      if (this.avCodec.sampleFormats && !this.avCodec.sampleFormats.includes(NodeAv7.AV_SAMPLE_FMT_FLTP)) {
+        sampleFormat = this.avCodec.sampleFormats[0];
+      }
+      codecContext.sampleRate = this.config.sampleRate;
+      codecContext.channelLayout = getChannelLayout(this.config.numberOfChannels);
+      codecContext.codecType = NodeAv7.AVMEDIA_TYPE_AUDIO;
+      codecContext.codecId = CODEC_TO_CODEC_ID[this.codec];
+      codecContext.sampleFormat = sampleFormat;
+      codecContext.timeBase = new NodeAv7.Rational(1, this.config.sampleRate);
+      codecContext.bitRate = BigInt(this.config.bitrate ?? import_mediabunny6.QUALITY_MEDIUM._toAudioBitrate(this.codec) ?? 0);
+      if (this.config.bitrateMode === "constant") {
+        codecContext.rcMinRate = codecContext.bitRate;
+        codecContext.rcMaxRate = codecContext.bitRate;
+      }
+      const ret = await codecContext.open2();
+      NodeAv7.FFmpegError.throwIfError(ret, "Open codec context");
+      this.codecContext = codecContext;
+    }
+    async encode(audioSample) {
+      if (this.codecContext === null) {
+        await this.createCodecContext();
+        assert(this.codecContext);
+      }
+      this.firstExpectedTimestamp ??= audioSample.timestamp;
+      if (audioSample._data instanceof AvFrameAudioSampleResource) {
+        this.frame.ref(audioSample._data.frame);
+      } else {
+        copyAudioSampleToAvFrame(audioSample, this.frame);
+      }
+      this.frame.pts = BigInt(Math.round(audioSample.timestamp * this.config.sampleRate));
+      this.frame.duration = BigInt(Math.round(audioSample.duration * this.config.sampleRate));
+      this.frame.timeBase = new NodeAv7.Rational(1, this.config.sampleRate);
+      const key = `${this.frame.sampleRate}:${this.frame.channels}:${this.frame.format}`;
+      if (this.inputParametersKey !== null && this.inputParametersKey !== key) {
+        throw new Error(
+          "Input audio parameters changed. For this audio encoder, you cannot change the input audio parameters over time."
+        );
+      }
+      this.inputParametersKey = key;
+      const requiresResampler = this.codecContext.frameSize > 0 || this.codecContext.sampleFormat !== this.frame.format || this.codecContext.sampleRate !== this.frame.sampleRate || this.codecContext.channels !== this.frame.channels;
+      if (requiresResampler) {
+        if (!this.resampler) {
+          this.resampler = new NodeAv7.SoftwareResampleContext();
+          this.resamplerInputSampleRate = this.frame.sampleRate;
+          const outLayout = getChannelLayout(this.codecContext.channels);
+          const inLayout = getChannelLayout(this.frame.channels);
+          const ret = this.resampler.allocSetOpts2(
+            outLayout,
+            this.codecContext.sampleFormat,
+            this.codecContext.sampleRate,
+            inLayout,
+            this.frame.format,
+            this.frame.sampleRate
+          );
+          NodeAv7.FFmpegError.throwIfError(ret, "allocSetOpts2");
+          const ret2 = this.resampler.init();
+          NodeAv7.FFmpegError.throwIfError(ret2, "init");
+          this.dstFrame = new NodeAv7.Frame();
+          this.dstFrame.alloc();
+          this.dstFrame.channelLayout = outLayout;
+          this.dstFrame.sampleRate = this.codecContext.sampleRate;
+          this.dstFrame.format = this.codecContext.sampleFormat;
+          this.dstFrame.nbSamples = this.codecContext.frameSize || FRAME_SIZE_FALLBACK;
+          this.dstFrame.duration = BigInt(this.dstFrame.nbSamples);
+          this.dstFrame.allocBuffer();
+          this.nextResamplerPts = this.frame.pts;
+        }
+        const inputBuffers = this.frame.data;
+        if (!inputBuffers) {
+          throw new DOMException("Frame has no data", "EncodingError");
+        }
+        await this.resampler.convert(null, 0, inputBuffers, this.frame.nbSamples);
+        await this.pullResampledFrames();
+      } else {
+        await this.sendFrameAndReceivePackets(this.frame);
+      }
+    }
+    async pullResampledFrames() {
+      assert(this.codecContext);
+      assert(this.resampler);
+      assert(this.dstFrame);
+      assert(this.nextResamplerPts !== null);
+      const frameSize = this.codecContext.frameSize || FRAME_SIZE_FALLBACK;
+      while (true) {
+        const available = this.resampler.getOutSamples(0);
+        if (available < frameSize) {
+          break;
+        }
+        await this.resampler.convert(this.dstFrame.data, frameSize, null, 0);
+        this.dstFrame.pts = this.nextResamplerPts;
+        await this.sendFrameAndReceivePackets(this.dstFrame);
+        this.nextResamplerPts += BigInt(frameSize);
+      }
+    }
+    async sendFrameAndReceivePackets(frame) {
+      assert(this.codecContext);
+      const ret = await this.codecContext.sendFrame(frame);
+      NodeAv7.FFmpegError.throwIfError(ret, "Send frame");
+      while (true) {
+        const receiveRet = await this.codecContext.receivePacket(this.packet);
+        if (receiveRet === NodeAv7.AVERROR_EAGAIN || receiveRet === NodeAv7.AVERROR_EOF) {
+          break;
+        }
+        this.receivePacket(receiveRet);
+      }
+    }
+    receivePacket(ret) {
+      assert(this.codecContext);
+      assert(this.firstExpectedTimestamp !== null);
+      NodeAv7.FFmpegError.throwIfError(ret, "Receive packet");
+      if (!this.packet.data) {
+        return;
+      }
+      let timestamp = Number(this.packet.pts) / this.codecContext.sampleRate;
+      const duration = Number(this.packet.duration) / this.codecContext.sampleRate;
+      let data = this.packet.data;
+      let metadata;
+      if (this.packetEmitted) {
+        metadata = {};
+      } else {
+        this.outputTimestampOffset = Math.max(this.firstExpectedTimestamp - timestamp, 0);
+        const codecString = this.config.codec;
+        let description = this.codecContext.extraData ? toUint8Array(this.codecContext.extraData) : void 0;
+        if (this.codec === "aac") {
+          if (!description) {
+            throw new Error("Extradata expected for AAC.");
+          }
+          const isAdts = this.config.aac?.format === "adts";
+          if (isAdts) {
+            const parsedConfig = parseAacAudioSpecificConfig(description);
+            this.adtsHeaderTemplate = buildAdtsHeaderTemplate(parsedConfig);
+            description = void 0;
+          }
+        } else if (this.codec === "opus") {
+          if (!description) {
+            throw new Error("Extradata expected for Opus.");
+          }
+        } else if (this.codec === "vorbis") {
+          if (!description) {
+            throw new Error("Extradata expected for Vorbis.");
+          }
+        } else if (this.codec === "flac") {
+          if (!description) {
+            throw new Error("Extradata expected for FLAC.");
+          }
+          description = new Uint8Array([
+            102,
+            76,
+            97,
+            67,
+            // 'fLaC'
+            128,
+            0,
+            0,
+            description.byteLength,
+            ...description
+          ]);
+        }
+        metadata = {
+          decoderConfig: {
+            codec: codecString,
+            sampleRate: this.codecContext.sampleRate,
+            numberOfChannels: this.codecContext.channels,
+            description
+          }
+        };
+      }
+      if (this.adtsHeaderTemplate) {
+        const frameLength = data.byteLength + this.adtsHeaderTemplate.header.byteLength;
+        this.adtsHeaderTemplate.bitstream.pos = 30;
+        this.adtsHeaderTemplate.bitstream.writeBits(13, frameLength);
+        const final = new Uint8Array(this.adtsHeaderTemplate.header.byteLength + data.byteLength);
+        final.set(this.adtsHeaderTemplate.header, 0);
+        final.set(data, this.adtsHeaderTemplate.header.byteLength);
+        data = final;
+      }
+      timestamp += this.outputTimestampOffset;
+      const packet = new import_mediabunny6.EncodedPacket(
+        data,
+        "key",
+        timestamp,
+        duration
+      );
+      this.packetEmitted = true;
+      this.onPacket(packet, metadata);
+    }
+    async flush() {
+      if (!this.codecContext) {
+        return;
+      }
+      outer:
+        if (this.resampler) {
+          assert(this.resamplerInputSampleRate !== null);
+          const currentOutSamples = this.resampler.getOutSamples(0);
+          if (currentOutSamples === 0) {
+            break outer;
+          }
+          const frameSize = this.codecContext.frameSize || FRAME_SIZE_FALLBACK;
+          assert(currentOutSamples < frameSize);
+          const inputSamplesNeeded = Math.ceil(
+            (frameSize - currentOutSamples) / this.codecContext.sampleRate * this.resamplerInputSampleRate
+          );
+          this.resampler.injectSilence(inputSamplesNeeded);
+          await this.pullResampledFrames();
+        }
+      await this.sendFrameAndReceivePackets(null);
+      this.codecContext.freeContext();
+      this.codecContext = null;
+      this.packetEmitted = false;
+      this.firstExpectedTimestamp = null;
+      this.outputTimestampOffset = 0;
+      this.adtsHeaderTemplate = null;
+      this.resampler?.free();
+      this.resampler = null;
+      this.inputParametersKey = null;
+      this.resamplerInputSampleRate = null;
+      this.nextResamplerPts = null;
+      this.dstFrame?.free();
+      this.dstFrame = null;
+    }
+    close() {
+      this.codecContext?.freeContext();
+      this.frame.free();
+      this.packet.free();
+      this.dstFrame?.free();
+      this.resampler?.free();
+    }
+  };
+
+  // packages/server/src/index.ts
+  var SERVER_LOADED_SYMBOL = Symbol.for("@mediabunny/server loaded");
+  if (globalThis[SERVER_LOADED_SYMBOL]) {
+    console.error(
+      "[WARNING]\n@mediabunny/server was loaded twice. This will likely cause the package not to work correctly. Check if multiple dependencies are importing different versions of @mediabunny/server, or if something is being bundled incorrectly."
+    );
+  }
+  globalThis[SERVER_LOADED_SYMBOL] = true;
+  var registered = false;
+  var registerMediabunnyServer = () => {
+    if (registered) {
+      return;
+    }
+    registered = true;
+    NodeAv8.Log.setLevel(NodeAv8.AV_LOG_ERROR);
+    (0, import_mediabunny7.registerDecoder)(NodeAvVideoDecoder);
+    (0, import_mediabunny7.registerEncoder)(NodeAvVideoEncoder);
+    (0, import_mediabunny7.registerDecoder)(NodeAvAudioDecoder);
+    (0, import_mediabunny7.registerEncoder)(NodeAvAudioEncoder);
+    (0, import_mediabunny7.registerVideoSampleTransformer)(transformVideoSample);
+  };
+  var toAvFrame = async (sample, frame) => {
+    if (sample instanceof import_mediabunny7.VideoSample) {
+      if (sample._data instanceof AvFrameVideoSampleResource) {
+        frame.ref(sample._data.frame);
+      } else {
+        if (sample.format === null) {
+          throw new Error("Cannot convert foreign VideoSample with unknown (null) format.");
+        }
+        await copyVideoSampleToAvFrame(sample, frame, null);
+      }
+      frame.pts = BigInt(sample.microsecondTimestamp);
+      frame.duration = BigInt(sample.microsecondDuration);
+      frame.timeBase = new NodeAv8.Rational(1, 1e6);
+    } else {
+      if (sample._data instanceof AvFrameAudioSampleResource) {
+        frame.ref(sample._data.frame);
+      } else {
+        copyAudioSampleToAvFrame(sample, frame);
+      }
+      frame.timeBase = new NodeAv8.Rational(1, sample.sampleRate);
+      frame.pts = BigInt(Math.round(sample.timestamp * sample.sampleRate));
+      frame.duration = BigInt(sample.numberOfFrames);
+    }
+  };
+  return __toCommonJS(index_exports);
+})();
+if (typeof module === "object" && typeof module.exports === "object") Object.assign(module.exports, MediabunnyServer)