mediabunny 1.51.0 → 1.52.0

package/dist/bundles/mediabunny.cjs

@@ -558,6 +558,9 @@ var Mediabunny = (() => {
   var clamp = (value, min, max) => {
     return Math.max(min, Math.min(max, value));
   };
+  var lerp = (from, to, t) => {
+    return from + (to - from) * t;
+  };
   var UNDETERMINED_LANGUAGE = "und";
   var roundIfAlmostInteger = (value) => {
     const rounded = Math.round(value);
@@ -16837,6 +16840,9 @@ var Mediabunny = (() => {
     }
     /** @internal */
     _dispose() {
+      for (const pendingSlice of this._pendingSlices) {
+        pendingSlice.reject(new InputDisposedError());
+      }
       this._pendingSlices.length = 0;
       this._cache.length = 0;
       void this._reader?.cancel();
@@ -17288,7 +17294,9 @@ var Mediabunny = (() => {
     }
     signalWorkerStoppedRunning(worker) {
       worker.running = false;
-      worker.pendingSlices.length = 0;
+      if (!worker.aborted) {
+        worker.pendingSlices.length = 0;
+      }
     }
     /** Called when a worker reaches the end of the underlying data and must be cleaned up. */
     onWorkerFinished(worker) {
@@ -17371,10 +17379,20 @@ var Mediabunny = (() => {
     }
     dispose() {
       for (const worker of this.workers) {
+        for (const slice of worker.pendingSlices) {
+          slice.reject(new InputDisposedError());
+        }
+        worker.pendingSlices.length = 0;
         worker.aborted = true;
       }
+      for (const queuedRead of this.queuedReads) {
+        for (const slice of queuedRead.pendingSlices) {
+          slice.reject(new InputDisposedError());
+        }
+      }
       this.workers.length = 0;
       this.cache.length = 0;
+      this.queuedReads.length = 0;
       this.disposed = true;
     }
   };
@@ -21343,8 +21361,18 @@ var Mediabunny = (() => {
     if (!VIDEO_CODECS.includes(config.codec)) {
       throw new TypeError(`Invalid video codec '${config.codec}'. Must be one of: ${VIDEO_CODECS.join(", ")}.`);
     }
-    if (!(config.bitrate instanceof Quality) && (!Number.isInteger(config.bitrate) || config.bitrate <= 0)) {
-      throw new TypeError("config.bitrate must be a positive integer or a quality.");
+    const bitrate = config.bitrate;
+    if (config.quality === void 0 && bitrate === void 0) {
+      throw new TypeError("config.quality must be provided.");
+    }
+    if (config.quality !== void 0 && bitrate !== void 0) {
+      throw new TypeError("config.quality and config.bitrate cannot both be provided.");
+    }
+    if (config.quality !== void 0 && !(config.quality instanceof Quality)) {
+      throw new TypeError("config.quality, when provided, must be a Quality.");
+    }
+    if (bitrate !== void 0 && !(bitrate instanceof Quality) && (!Number.isInteger(bitrate) || bitrate <= 0)) {
+      throw new TypeError("config.bitrate, when provided, must be a positive integer or a quality.");
     }
     if (config.keyFrameInterval !== void 0 && (!Number.isFinite(config.keyFrameInterval) || config.keyFrameInterval < 0)) {
       throw new TypeError("config.keyFrameInterval, when provided, must be a non-negative number.");
@@ -21411,7 +21439,8 @@ var Mediabunny = (() => {
     if (options.alpha !== void 0 && !["discard", "keep"].includes(options.alpha)) {
       throw new TypeError("options.alpha, when provided, must be 'discard' or 'keep'.");
     }
-    if (options.bitrateMode !== void 0 && !["constant", "variable"].includes(options.bitrateMode)) {
+    const bitrateMode = options.bitrateMode;
+    if (bitrateMode !== void 0 && !["constant", "variable"].includes(bitrateMode)) {
       throw new TypeError("bitrateMode, when provided, must be 'constant' or 'variable'.");
     }
     if (options.latencyMode !== void 0 && !["quality", "realtime"].includes(options.latencyMode)) {
@@ -21437,22 +21466,28 @@ var Mediabunny = (() => {
       throw new TypeError("contentHint, when provided, must be a string.");
     }
   };
-  var buildVideoEncoderConfig = (options) => {
-    const resolvedBitrate = options.bitrate instanceof Quality ? options.bitrate._toVideoBitrate(options.codec, options.width, options.height) : options.bitrate;
-    return {
+  var buildVideoEncoderConfigs = (options) => {
+    const fallbackBitrateMode = options.bitrateMode;
+    const rateControl = options.quality._toVideoRateControl(
+      options.codec,
+      options.width,
+      options.height,
+      fallbackBitrateMode
+    );
+    const buildConfig = (bitrate, bitrateMode, bitrateEstimate) => ({
       codec: options.fullCodecString ?? buildVideoCodecString(
         options.codec,
         options.width,
         options.height,
-        resolvedBitrate,
+        bitrateEstimate,
         options.alpha === "keep"
       ),
       width: options.width,
       height: options.height,
       displayWidth: options.squarePixelWidth,
       displayHeight: options.squarePixelHeight,
-      bitrate: resolvedBitrate,
-      bitrateMode: options.bitrateMode,
+      bitrate,
+      bitrateMode,
       alpha: options.alpha ?? "discard",
       framerate: options.framerate,
       latencyMode: options.latencyMode,
@@ -21460,7 +21495,22 @@ var Mediabunny = (() => {
       scalabilityMode: options.scalabilityMode,
       contentHint: options.contentHint,
       ...getVideoEncoderConfigExtension(options.codec)
-    };
+    });
+    const candidates = [];
+    if (rateControl.quantizer !== null) {
+      candidates.push({
+        config: buildConfig(void 0, "quantizer", rateControl.bitrate),
+        quantizer: rateControl.quantizer
+      });
+    }
+    if (rateControl.bitrateMode !== "quantizer") {
+      candidates.push({
+        config: buildConfig(rateControl.bitrate, rateControl.bitrateMode, rateControl.bitrate),
+        quantizer: null
+      });
+    }
+    assert(candidates.length > 0);
+    return candidates;
   };
   var validateAudioEncodingConfig = (config) => {
     if (!config || typeof config !== "object") {
@@ -21469,10 +21519,17 @@ var Mediabunny = (() => {
     if (!AUDIO_CODECS.includes(config.codec)) {
       throw new TypeError(`Invalid audio codec '${config.codec}'. Must be one of: ${AUDIO_CODECS.join(", ")}.`);
     }
-    if (config.bitrate === void 0 && !(PCM_AUDIO_CODECS.includes(config.codec) || config.codec === "flac")) {
-      throw new TypeError("config.bitrate must be provided for compressed audio codecs.");
+    const bitrate = config.bitrate;
+    if (config.quality === void 0 && bitrate === void 0 && !(PCM_AUDIO_CODECS.includes(config.codec) || config.codec === "flac")) {
+      throw new TypeError("config.quality must be provided for compressed audio codecs.");
+    }
+    if (config.quality !== void 0 && bitrate !== void 0) {
+      throw new TypeError("config.quality and config.bitrate cannot both be provided.");
     }
-    if (config.bitrate !== void 0 && !(config.bitrate instanceof Quality) && (!Number.isInteger(config.bitrate) || config.bitrate <= 0)) {
+    if (config.quality !== void 0 && !(config.quality instanceof Quality)) {
+      throw new TypeError("config.quality, when provided, must be a Quality.");
+    }
+    if (bitrate !== void 0 && !(bitrate instanceof Quality) && (!Number.isInteger(bitrate) || bitrate <= 0)) {
       throw new TypeError("config.bitrate, when provided, must be a positive integer or a quality.");
     }
     if (config.transform !== void 0) {
@@ -21507,7 +21564,8 @@ var Mediabunny = (() => {
     if (!options || typeof options !== "object") {
       throw new TypeError("Encoding options must be an object.");
     }
-    if (options.bitrateMode !== void 0 && !["constant", "variable"].includes(options.bitrateMode)) {
+    const bitrateMode = options.bitrateMode;
+    if (bitrateMode !== void 0 && !["constant", "variable"].includes(bitrateMode)) {
       throw new TypeError("bitrateMode, when provided, must be 'constant' or 'variable'.");
     }
     if (options.fullCodecString !== void 0 && typeof options.fullCodecString !== "string") {
@@ -21520,7 +21578,7 @@ var Mediabunny = (() => {
     }
   };
   var buildAudioEncoderConfig = (options) => {
-    const resolvedBitrate = options.bitrate instanceof Quality ? options.bitrate._toAudioBitrate(options.codec) : options.bitrate;
+    const fallbackBitrateMode = options.bitrateMode;
     return {
       codec: options.fullCodecString ?? buildAudioCodecString(
         options.codec,
@@ -21529,46 +21587,132 @@ var Mediabunny = (() => {
       ),
       numberOfChannels: options.numberOfChannels,
       sampleRate: options.sampleRate,
-      bitrate: resolvedBitrate,
-      bitrateMode: options.bitrateMode,
+      bitrate: options.quality?._toAudioBitrate(options.codec),
+      bitrateMode: options.quality?._bitrateMode ?? fallbackBitrateMode,
       ...getAudioEncoderConfigExtension(options.codec)
     };
   };
   var Quality = class {
-    /** @internal */
-    constructor(factor) {
-      this._factor = factor;
+    constructor(options) {
+      if (typeof options === "number" || typeof options === "string") {
+        options = { quality: options };
+      }
+      if (!options || typeof options !== "object") {
+        throw new TypeError("options must be an object.");
+      }
+      if (options.bitrateMode !== void 0 && !["constant", "variable"].includes(options.bitrateMode)) {
+        throw new TypeError("options.bitrateMode, when provided, must be 'constant' or 'variable'.");
+      }
+      if ("quality" in options) {
+        if (typeof options.quality === "string" ? !(options.quality in QUALITY_LEVELS) : typeof options.quality !== "number" || Number.isNaN(options.quality)) {
+          throw new TypeError(
+            "options.quality must be a number, or one of 'very-low', 'low', 'medium', 'high' or 'very-high'."
+          );
+        }
+        if (options.preferBitrate !== void 0 && typeof options.preferBitrate !== "boolean") {
+          throw new TypeError("options.preferBitrate, when provided, must be a boolean.");
+        }
+        if ("bitrate" in options || "quantizer" in options) {
+          throw new TypeError("options.quality cannot be combined with options.bitrate or options.quantizer.");
+        }
+        this._quality = typeof options.quality === "string" ? QUALITY_LEVELS[options.quality] : options.quality;
+        this._preferBitrate = options.preferBitrate ?? false;
+        this._bitrate = void 0;
+        this._quantizer = void 0;
+      } else {
+        if (options.bitrate !== void 0 && (!Number.isInteger(options.bitrate) || options.bitrate <= 0)) {
+          throw new TypeError("options.bitrate, when provided, must be a positive integer.");
+        }
+        if (options.quantizer !== void 0 && (!Number.isInteger(options.quantizer) || options.quantizer < 0)) {
+          throw new TypeError("options.quantizer, when provided, must be a non-negative integer.");
+        }
+        if (options.bitrate === void 0 && options.quantizer === void 0) {
+          throw new TypeError("At least one of options.bitrate or options.quantizer must be set.");
+        }
+        if ("preferBitrate" in options) {
+          throw new TypeError("options.preferBitrate can only be combined with options.quality.");
+        }
+        this._quality = void 0;
+        this._preferBitrate = false;
+        this._bitrate = options.bitrate;
+        this._quantizer = options.quantizer;
+      }
+      this._bitrateMode = options.bitrateMode;
+    }
+    /**
+     * Determines the rate control methods usable for the given codec.
+     * @internal
+     */
+    _toVideoRateControl(codec, width, height, fallbackBitrateMode) {
+      const quantizerSupport = VIDEO_CODEC_QUANTIZER_SUPPORT[codec];
+      let quantizer = null;
+      let bitrateMode = this._bitrateMode ?? fallbackBitrateMode ?? "variable";
+      if (this._quantizer !== void 0) {
+        if (!quantizerSupport) {
+          if (this._bitrate === void 0) {
+            throw new Error(
+              `Codec '${codec}' does not support quantizer-based encoding. Provide a bitrate in the Quality to define a fallback.`
+            );
+          }
+        } else if (this._quantizer < quantizerSupport.min || this._quantizer > quantizerSupport.max) {
+          if (this._bitrate === void 0) {
+            throw new Error(
+              `Quantizer ${this._quantizer} is out of range for codec '${codec}'; must be between ${quantizerSupport.min} and ${quantizerSupport.max}.`
+            );
+          }
+        } else {
+          quantizer = this._quantizer;
+          if (this._bitrate === void 0) {
+            bitrateMode = "quantizer";
+          }
+        }
+      } else if (this._bitrate === void 0 && quantizerSupport && !this._preferBitrate) {
+        assert(this._quality !== void 0);
+        quantizer = clamp(
+          Math.round(lerp(quantizerSupport.worst, quantizerSupport.best, this._quality)),
+          quantizerSupport.min,
+          quantizerSupport.max
+        );
+      }
+      let bitrate;
+      if (this._bitrate !== void 0) {
+        bitrate = this._bitrate;
+      } else {
+        let quality = this._quality;
+        if (quality === void 0) {
+          assert(quantizer !== null && quantizerSupport);
+          quality = clamp(
+            (quantizer - quantizerSupport.worst) / (quantizerSupport.best - quantizerSupport.worst),
+            0,
+            1
+          );
+        }
+        bitrate = computeVideoBitrate(codec, width, height, qualityToBitrateFactor(quality));
+      }
+      return { quantizer, bitrate, bitrateMode };
     }
     /** @internal */
     _toVideoBitrate(codec, width, height) {
-      const pixels = width * height;
-      const referencePixels = 1920 * 1080;
-      const referenceBitrate = 3e6;
-      const scaleFactor = Math.pow(pixels / referencePixels, 0.95);
-      const baseBitrate = referenceBitrate * scaleFactor;
-      const codecEfficiencyFactors = {
-        avc: 1,
-        // H.264/AVC (baseline)
-        hevc: 0.6,
-        // H.265/HEVC (~40% more efficient than AVC)
-        vp9: 0.6,
-        // Similar to HEVC
-        av1: 0.4,
-        // ~60% more efficient than AVC
-        vp8: 1.2,
-        // Slightly less efficient than AVC
-        prores: 22e7 / referenceBitrate
-        // Apple ProRes white paper claims 220 Mbps for 1080p 422 HQ @30Hz
-      };
-      const codecAdjustedBitrate = baseBitrate * codecEfficiencyFactors[codec];
-      const finalBitrate = codecAdjustedBitrate * this._factor;
-      return Math.ceil(finalBitrate / 1e3) * 1e3;
+      if (this._bitrate !== void 0) {
+        return this._bitrate;
+      }
+      assert(this._quality !== void 0);
+      return computeVideoBitrate(codec, width, height, qualityToBitrateFactor(this._quality));
     }
     /** @internal */
     _toAudioBitrate(codec) {
       if (PCM_AUDIO_CODECS.includes(codec) || codec === "flac") {
         return void 0;
       }
+      if (this._bitrate !== void 0) {
+        return this._bitrate;
+      }
+      if (this._quality === void 0) {
+        throw new Error(
+          "This Quality defines neither a quality level nor a bitrate and therefore cannot be used for audio encoding."
+        );
+      }
+      const factor = qualityToBitrateFactor(this._quality);
       const baseRates = {
         aac: 128e3,
         // 128kbps base for AAC
@@ -21587,7 +21731,7 @@ var Mediabunny = (() => {
       if (!baseBitrate) {
         throw new Error(`Unhandled codec: ${codec}`);
       }
-      let finalBitrate = baseBitrate * this._factor;
+      let finalBitrate = baseBitrate * factor;
       if (codec === "aac") {
         const validRates = [96e3, 128e3, 16e4, 192e3];
         finalBitrate = validRates.reduce(
@@ -21621,11 +21765,61 @@ var Mediabunny = (() => {
       return Math.round(finalBitrate / 1e3) * 1e3;
     }
   };
-  var QUALITY_VERY_LOW = /* @__PURE__ */ new Quality(0.3);
-  var QUALITY_LOW = /* @__PURE__ */ new Quality(0.6);
-  var QUALITY_MEDIUM = /* @__PURE__ */ new Quality(1);
-  var QUALITY_HIGH = /* @__PURE__ */ new Quality(2);
-  var QUALITY_VERY_HIGH = /* @__PURE__ */ new Quality(4);
+  var QUALITY_LEVELS = {
+    "very-low": 0,
+    "low": 0.25,
+    "medium": 0.5,
+    "high": 0.75,
+    "very-high": 1
+  };
+  var VIDEO_CODEC_QUANTIZER_SUPPORT = {
+    avc: { min: 0, max: 51, worst: 41, best: 16 },
+    hevc: { min: 0, max: 51, worst: 41, best: 16 },
+    vp9: { min: 0, max: 63, worst: 52, best: 20 },
+    av1: { min: 0, max: 255, worst: 208, best: 80 }
+  };
+  var qualityToBitrateFactor = (quality) => 0.3 * Math.exp(2.5538 * quality);
+  var computeVideoBitrate = (codec, width, height, factor) => {
+    const pixels = width * height;
+    const referencePixels = 1920 * 1080;
+    const referenceBitrate = 3e6;
+    const scaleFactor = Math.pow(pixels / referencePixels, 0.95);
+    const baseBitrate = referenceBitrate * scaleFactor;
+    const codecEfficiencyFactors = {
+      avc: 1,
+      // H.264/AVC (baseline)
+      hevc: 0.6,
+      // H.265/HEVC (~40% more efficient than AVC)
+      vp9: 0.6,
+      // Similar to HEVC
+      av1: 0.4,
+      // ~60% more efficient than AVC
+      vp8: 1.2,
+      // Slightly less efficient than AVC
+      prores: 22e7 / referenceBitrate
+      // Apple ProRes white paper claims 220 Mbps for 1080p 422 HQ @30Hz
+    };
+    const codecAdjustedBitrate = baseBitrate * codecEfficiencyFactors[codec];
+    const finalBitrate = codecAdjustedBitrate * factor;
+    return Math.ceil(finalBitrate / 1e3) * 1e3;
+  };
+  var buildQuantizerEncodeOptions = (codec, quantizer) => {
+    if (codec === "avc") {
+      return { avc: { quantizer } };
+    } else if (codec === "hevc") {
+      return { hevc: { quantizer } };
+    } else if (codec === "vp9") {
+      return { vp9: { quantizer } };
+    } else if (codec === "av1") {
+      return { av1: { quantizer } };
+    }
+    assert(false);
+  };
+  var QUALITY_VERY_LOW = /* @__PURE__ */ new Quality("very-low");
+  var QUALITY_LOW = /* @__PURE__ */ new Quality("low");
+  var QUALITY_MEDIUM = /* @__PURE__ */ new Quality("medium");
+  var QUALITY_HIGH = /* @__PURE__ */ new Quality("high");
+  var QUALITY_VERY_HIGH = /* @__PURE__ */ new Quality("very-high");
   var canEncode = (codec) => {
     if (VIDEO_CODECS.includes(codec)) {
       return canEncodeVideo(codec);
@@ -21640,7 +21834,9 @@ var Mediabunny = (() => {
     const {
       width = 1280,
       height = 720,
-      bitrate = 1e6,
+      quality,
+      // eslint-disable-next-line @typescript-eslint/no-deprecated
+      bitrate,
       ...restOptions
     } = options;
     if (!VIDEO_CODECS.includes(codec)) {
@@ -21652,28 +21848,42 @@ var Mediabunny = (() => {
     if (!Number.isInteger(height) || height <= 0) {
       throw new TypeError("height must be a positive integer.");
     }
-    if (!(bitrate instanceof Quality) && (!Number.isInteger(bitrate) || bitrate <= 0)) {
+    if (quality !== void 0 && !(quality instanceof Quality)) {
+      throw new TypeError("quality, when provided, must be a Quality.");
+    }
+    if (quality !== void 0 && bitrate !== void 0) {
+      throw new TypeError("quality and bitrate cannot both be provided.");
+    }
+    if (bitrate !== void 0 && !(bitrate instanceof Quality) && (!Number.isInteger(bitrate) || bitrate <= 0)) {
       throw new TypeError("bitrate must be a positive integer or a quality.");
     }
     validateVideoEncodingAdditionalOptions(codec, restOptions);
-    const encoderConfig = buildVideoEncoderConfig({
-      codec,
-      width,
-      height,
-      bitrate,
-      framerate: void 0,
-      ...restOptions,
-      alpha: "discard"
-      // Since we handle alpha ourselves
-    });
-    const key = JSON.stringify(encoderConfig);
+    const resolvedQuality = resolveQuality(quality, bitrate) ?? new Quality({ bitrate: 1e6 });
+    let candidates;
+    try {
+      candidates = buildVideoEncoderConfigs({
+        codec,
+        width,
+        height,
+        quality: resolvedQuality,
+        framerate: void 0,
+        ...restOptions,
+        alpha: "discard"
+        // Since we handle alpha ourselves
+      });
+    } catch {
+      return false;
+    }
+    const key = JSON.stringify(candidates);
     const memoized = canEncodeVideoMemo.get(key);
     if (memoized) {
       return memoized;
     }
     const promise = (async () => {
-      if (customVideoEncoders.some((x) => x.supports(codec, encoderConfig))) {
-        return true;
+      for (const { config } of candidates) {
+        if (customVideoEncoders.some((x) => x.supports(codec, config))) {
+          return true;
+        }
       }
       if (typeof VideoEncoder === "undefined") {
         return false;
@@ -21682,19 +21892,22 @@ var Mediabunny = (() => {
       if (hasOddDimension && (codec === "avc" || codec === "hevc")) {
         return false;
       }
-      const support = await VideoEncoder.isConfigSupported(encoderConfig);
-      if (!support.supported) {
-        return false;
-      }
-      if (isFirefox()) {
-        return new Promise(async (resolve) => {
+      for (const { config, quantizer } of candidates) {
+        const support = await VideoEncoder.isConfigSupported(config);
+        if (!support.supported) {
+          continue;
+        }
+        if (!isFirefox()) {
+          return true;
+        }
+        const success = await new Promise(async (resolve) => {
           try {
             const encoder = new VideoEncoder({
               output: () => {
               },
               error: () => resolve(false)
             });
-            encoder.configure(encoderConfig);
+            encoder.configure(config);
             const frameData = new Uint8Array(width * height * 4);
             const frame = new VideoFrame(frameData, {
               format: "RGBA",
@@ -21702,7 +21915,10 @@ var Mediabunny = (() => {
               codedHeight: height,
               timestamp: 0
             });
-            encoder.encode(frame);
+            encoder.encode(
+              frame,
+              quantizer !== null ? buildQuantizerEncodeOptions(codec, quantizer) : void 0
+            );
             frame.close();
             await encoder.flush();
             resolve(true);
@@ -21710,8 +21926,11 @@ var Mediabunny = (() => {
             resolve(false);
           }
         });
+        if (success) {
+          return true;
+        }
       }
-      return true;
+      return false;
     })();
     canEncodeVideoMemo.set(key, promise);
     return promise;
@@ -21720,7 +21939,9 @@ var Mediabunny = (() => {
     const {
       numberOfChannels = 2,
       sampleRate = 48e3,
-      bitrate = 128e3,
+      quality,
+      // eslint-disable-next-line @typescript-eslint/no-deprecated
+      bitrate,
       ...restOptions
     } = options;
     if (!AUDIO_CODECS.includes(codec)) {
@@ -21732,15 +21953,22 @@ var Mediabunny = (() => {
     if (!Number.isInteger(sampleRate) || sampleRate <= 0) {
       throw new TypeError("sampleRate must be a positive integer.");
     }
-    if (!(bitrate instanceof Quality) && (!Number.isInteger(bitrate) || bitrate <= 0)) {
+    if (quality !== void 0 && !(quality instanceof Quality)) {
+      throw new TypeError("quality, when provided, must be a Quality.");
+    }
+    if (quality !== void 0 && bitrate !== void 0) {
+      throw new TypeError("quality and bitrate cannot both be provided.");
+    }
+    if (bitrate !== void 0 && !(bitrate instanceof Quality) && (!Number.isInteger(bitrate) || bitrate <= 0)) {
       throw new TypeError("bitrate must be a positive integer.");
     }
     validateAudioEncodingAdditionalOptions(codec, restOptions);
+    const resolvedQuality = resolveQuality(quality, bitrate) ?? new Quality({ bitrate: 128e3 });
     const encoderConfig = buildAudioEncoderConfig({
       codec,
       numberOfChannels,
       sampleRate,
-      bitrate,
+      quality: resolvedQuality,
       ...restOptions
     });
     const key = JSON.stringify(encoderConfig);
@@ -21764,6 +21992,15 @@ var Mediabunny = (() => {
     canEncodeAudioMemo.set(key, promise);
     return promise;
   };
+  var resolveQuality = (quality, bitrate) => {
+    if (quality !== void 0) {
+      return quality;
+    }
+    if (bitrate === void 0) {
+      return void 0;
+    }
+    return bitrate instanceof Quality ? bitrate : new Quality({ bitrate });
+  };
   var canEncodeSubtitles = async (codec) => {
     if (!SUBTITLE_CODECS.includes(codec)) {
       return false;
@@ -22241,6 +22478,7 @@ var Mediabunny = (() => {
       let decoderIsFlushed = false;
       let ended = false;
       let terminated = false;
+      let decoder = null;
       let outOfBandError = null;
       let hasOutOfBandError = false;
       const packetRetrievalOptions = {
@@ -22249,7 +22487,7 @@ var Mediabunny = (() => {
         metadataOnly: false
       };
       (async () => {
-        const decoder = await this._createDecoder((sample) => {
+        decoder = await this._createDecoder((sample) => {
           onQueueDequeue();
           if (sample.timestamp >= endTimestamp) {
             ended = true;
@@ -22306,7 +22544,6 @@ var Mediabunny = (() => {
         if (!terminated && !this._track.input._disposed) {
           await decoder.flush();
         }
-        decoder.close();
         if (!firstSampleQueued && lastSample) {
           sampleQueue.push(lastSample);
         }
@@ -22318,6 +22555,8 @@ var Mediabunny = (() => {
           hasOutOfBandError = true;
           onQueueNotEmpty();
         }
+      }).finally(() => {
+        decoder?.close();
       });
       const track = this._track;
       const closeSamples = () => {
@@ -22374,6 +22613,7 @@ var Mediabunny = (() => {
       let { promise: queueDequeue, resolve: onQueueDequeue } = promiseWithResolvers();
       let decoderIsFlushed = false;
       let terminated = false;
+      let decoder = null;
       let outOfBandError = null;
       let hasOutOfBandError = false;
       const pushToQueue = (sample) => {
@@ -22387,7 +22627,7 @@ var Mediabunny = (() => {
         metadataOnly: false
       };
       (async () => {
-        const decoder = await this._createDecoder((sample) => {
+        decoder = await this._createDecoder((sample) => {
           onQueueDequeue();
           if (terminated) {
             sample.close();
@@ -22418,6 +22658,7 @@ var Mediabunny = (() => {
         let maxSequenceNumber = -1;
         const decodePackets = async () => {
           assert(lastKeyPacket);
+          assert(decoder);
           let currentPacket = lastKeyPacket;
           decoder.decode(currentPacket);
           while (currentPacket.sequenceNumber < maxSequenceNumber) {
@@ -22437,6 +22678,7 @@ var Mediabunny = (() => {
           maxSequenceNumber = -1;
         };
         const flushDecoder = async () => {
+          assert(decoder);
           await decoder.flush();
           for (let i = 0; i < timestampsOfInterest.length; i++) {
             pushToQueue(null);
@@ -22474,7 +22716,6 @@ var Mediabunny = (() => {
           }
           await flushDecoder();
         }
-        decoder.close();
         decoderIsFlushed = true;
         onQueueNotEmpty();
       })().catch((error) => {
@@ -22483,6 +22724,8 @@ var Mediabunny = (() => {
           hasOutOfBandError = true;
           onQueueNotEmpty();
         }
+      }).finally(() => {
+        decoder?.close();
       });
       const track = this._track;
       const closeSamples = () => {
@@ -27156,9 +27399,10 @@ var Mediabunny = (() => {
     // Reserved
     u16(1),
     // Frame count
-    Array(32).fill(0),
     // Compressor name
-    u16(24),
+    ascii("Mediabunny"),
+    Array(32 - "Mediabunny".length).fill(0),
+    u16(trackData.info.hasAlphaChannel ? 32 : 24),
     // Depth
     i16(65535)
     // Pre-defined
@@ -29114,6 +29358,7 @@ var Mediabunny = (() => {
         num: displayAspectWidth * decoderConfig.codedHeight,
         den: displayAspectHeight * decoderConfig.codedWidth
       });
+      const hasAlphaChannel = decoderConfig.codec === "ap4h" || decoderConfig.codec === "ap4x";
       const newTrackData = {
         muxer: this,
         track,
@@ -29123,7 +29368,8 @@ var Mediabunny = (() => {
           height: decoderConfig.codedHeight,
           pixelAspectRatio,
           decoderConfig,
-          requiresAnnexBTransformation
+          requiresAnnexBTransformation,
+          hasAlphaChannel
         },
         timescale,
         samples: [],
@@ -32654,6 +32900,8 @@ ${cue.notes ?? ""}`;
       this.customEncoder = null;
       this.customEncoderCallSerializer = new CallSerializer();
       this.customEncoderQueueSize = 0;
+      // Set when the encoder uses quantizer-based rate control; carries the quantizer value applied to each frame
+      this.defaultEncodeOptions = {};
       // Alpha stuff
       this.alphaEncoder = null;
       this.splitter = null;
@@ -32783,18 +33031,36 @@ ${cue.notes ?? ""}`;
         if (!Array.isArray(processed)) {
           processed = [processed];
         }
-        samplesToEncode = processed.map((x) => {
-          if (x instanceof VideoSample) {
-            return x;
+        const mappedSamples = [];
+        try {
+          for (const x of processed) {
+            if (x instanceof VideoSample) {
+              mappedSamples.push(x);
+            } else if (typeof VideoFrame !== "undefined" && x instanceof VideoFrame) {
+              mappedSamples.push(new VideoSample(x));
+            } else {
+              mappedSamples.push(new VideoSample(x, {
+                timestamp: videoSample.timestamp,
+                duration: videoSample.duration
+              }));
+            }
           }
-          if (typeof VideoFrame !== "undefined" && x instanceof VideoFrame) {
-            return new VideoSample(x);
+        } catch (error) {
+          for (const sample of mappedSamples) {
+            if (sample !== videoSample) {
+              sample.close();
+            }
           }
-          return new VideoSample(x, {
-            timestamp: videoSample.timestamp,
-            duration: videoSample.duration
-          });
-        });
+          for (const x of processed) {
+            if (x instanceof VideoSample && x !== videoSample) {
+              x.close();
+            } else if (typeof VideoFrame !== "undefined" && x instanceof VideoFrame) {
+              x.close();
+            }
+          }
+          throw error;
+        }
+        samplesToEncode = mappedSamples;
       } else {
         samplesToEncode = [videoSample];
       }
@@ -32814,7 +33080,11 @@ ${cue.notes ?? ""}`;
           }
           const keyFrameInterval = this.encodingConfig.keyFrameInterval ?? 2;
           const multipleOfKeyFrameInterval = Math.floor(sampleToEncode.timestamp / keyFrameInterval);
-          const mergedEncodeOptions = { ...sampleToEncode.encodeOptions, ...encodeOptions };
+          const mergedEncodeOptions = {
+            ...this.defaultEncodeOptions,
+            ...sampleToEncode.encodeOptions,
+            ...encodeOptions
+          };
           const finalEncodeOptions = {
             ...mergedEncodeOptions,
             keyFrame: mergedEncodeOptions.keyFrame !== void 0 ? mergedEncodeOptions.keyFrame : keyFrameInterval === 0 || multipleOfKeyFrameInterval !== this.lastMultipleOfKeyFrameInterval
@@ -32860,22 +33130,31 @@ ${cue.notes ?? ""}`;
               }
             }
             if (!this.alphaEncoder) {
-              this.encoder.encode(videoFrame, finalEncodeOptions);
-              videoFrame.close();
+              try {
+                this.encoder.encode(videoFrame, finalEncodeOptions);
+              } finally {
+                videoFrame.close();
+              }
             } else {
               const frameDefinitelyHasNoAlpha = !!videoFrame.format && !videoFrame.format.includes("A");
               if (frameDefinitelyHasNoAlpha || this.splitterCreationFailed) {
                 this.alphaFrameQueue.push(null);
-                this.encoder.encode(videoFrame, finalEncodeOptions);
-                videoFrame.close();
+                try {
+                  this.encoder.encode(videoFrame, finalEncodeOptions);
+                } finally {
+                  videoFrame.close();
+                }
               } else {
                 if (!this.splitter) {
                   this.splitter = new ColorAlphaSplitter();
                 }
                 const { colorFrame, alphaFrame } = await this.splitter.split(videoFrame);
                 this.alphaFrameQueue.push(alphaFrame);
-                this.encoder.encode(colorFrame, finalEncodeOptions);
-                colorFrame.close();
+                try {
+                  this.encoder.encode(colorFrame, finalEncodeOptions);
+                } finally {
+                  colorFrame.close();
+                }
               }
             }
             if (this.encoder.encodeQueueSize >= 4) {
@@ -32900,28 +33179,83 @@ ${cue.notes ?? ""}`;
       assert(this.frameRateLastSample);
       const frameDifference = Math.round((until - this.frameRateLastTimestamp) * frameRate);
       for (let i = 1; i < frameDifference; i++) {
-        const sample = this.frameRateLastSample.clone();
-        sample.setTimestamp(this.frameRateLastTimestamp + i / frameRate);
-        sample.setDuration(1 / frameRate);
-        await this.processAndEncode(sample, encodeOptions);
-        sample.close();
+        var _stack = [];
+        try {
+          const sample = __using(_stack, this.frameRateLastSample.clone());
+          sample.setTimestamp(this.frameRateLastTimestamp + i / frameRate);
+          sample.setDuration(1 / frameRate);
+          await this.processAndEncode(sample, encodeOptions);
+        } catch (_) {
+          var _error = _, _hasError = true;
+        } finally {
+          __callDispose(_stack, _error, _hasError);
+        }
       }
     }
     ensureEncoder(videoSample) {
       this.ensureEncoderPromise = (async () => {
-        const encoderConfig = buildVideoEncoderConfig({
+        const quality = resolveQuality(this.encodingConfig.quality, this.encodingConfig.bitrate);
+        assert(quality !== void 0);
+        const candidates = buildVideoEncoderConfigs({
           ...this.encodingConfig,
+          quality,
           width: videoSample.codedWidth,
           height: videoSample.codedHeight,
           squarePixelWidth: videoSample.squarePixelWidth,
           squarePixelHeight: videoSample.squarePixelHeight,
           framerate: this.source._connectedTrack?.metadata.frameRate
         });
-        this.encodingConfig.onEncoderConfig?.(encoderConfig);
-        const MatchingCustomEncoder = customVideoEncoders.find((x) => x.supports(
-          this.encodingConfig.codec,
-          encoderConfig
-        ));
+        let selected = null;
+        let MatchingCustomEncoder;
+        for (const candidate of candidates) {
+          const candidateConfig = candidate.config;
+          this.encodingConfig.onEncoderConfig?.(candidateConfig);
+          MatchingCustomEncoder = customVideoEncoders.find((x) => x.supports(
+            this.encodingConfig.codec,
+            candidateConfig
+          ));
+          if (MatchingCustomEncoder) {
+            selected = candidate;
+            break;
+          }
+          if (typeof VideoEncoder === "undefined") {
+            continue;
+          }
+          candidateConfig.alpha = "discard";
+          if (this.encodingConfig.alpha === "keep") {
+            candidateConfig.latencyMode = "quality";
+          }
+          const hasOddDimension = candidateConfig.width % 2 === 1 || candidateConfig.height % 2 === 1;
+          if (hasOddDimension && (this.encodingConfig.codec === "avc" || this.encodingConfig.codec === "hevc")) {
+            throw new Error(
+              `The dimensions ${candidateConfig.width}x${candidateConfig.height} are not supported for codec '${this.encodingConfig.codec}'; both width and height must be even numbers. Make sure to round your dimensions to the nearest even number.`
+            );
+          }
+          const support = await VideoEncoder.isConfigSupported(candidateConfig);
+          if (support.supported) {
+            selected = candidate;
+            break;
+          }
+        }
+        if (!selected) {
+          if (typeof VideoEncoder === "undefined") {
+            throw new Error("VideoEncoder is not supported by this browser.");
+          }
+          const firstConfig = candidates[0].config;
+          const rateControls = candidates.map(
+            ({ config, quantizer }) => quantizer !== null ? `quantizer ${quantizer}` : `${config.bitrate} bps`
+          );
+          throw new Error(
+            `This specific encoder configuration (${firstConfig.codec}, ${rateControls.join(" / ")}, ${firstConfig.width}x${firstConfig.height}, hardware acceleration: ${firstConfig.hardwareAcceleration ?? "no-preference"}) is not supported by this browser. Consider using another codec or changing your video parameters.`
+          );
+        }
+        const encoderConfig = selected.config;
+        if (selected.quantizer !== null) {
+          this.defaultEncodeOptions = buildQuantizerEncodeOptions(
+            this.encodingConfig.codec,
+            selected.quantizer
+          );
+        }
         if (MatchingCustomEncoder) {
           this.customEncoder = new MatchingCustomEncoder();
           this.customEncoder.codec = this.encodingConfig.codec;
@@ -32944,25 +33278,6 @@ ${cue.notes ?? ""}`;
           };
           await this.customEncoder.init();
         } else {
-          if (typeof VideoEncoder === "undefined") {
-            throw new Error("VideoEncoder is not supported by this browser.");
-          }
-          encoderConfig.alpha = "discard";
-          if (this.encodingConfig.alpha === "keep") {
-            encoderConfig.latencyMode = "quality";
-          }
-          const hasOddDimension = encoderConfig.width % 2 === 1 || encoderConfig.height % 2 === 1;
-          if (hasOddDimension && (this.encodingConfig.codec === "avc" || this.encodingConfig.codec === "hevc")) {
-            throw new Error(
-              `The dimensions ${encoderConfig.width}x${encoderConfig.height} are not supported for codec '${this.encodingConfig.codec}'; both width and height must be even numbers. Make sure to round your dimensions to the nearest even number.`
-            );
-          }
-          const support = await VideoEncoder.isConfigSupported(encoderConfig);
-          if (!support.supported) {
-            throw new Error(
-              `This specific encoder configuration (${encoderConfig.codec}, ${encoderConfig.bitrate} bps, ${encoderConfig.width}x${encoderConfig.height}, hardware acceleration: ${encoderConfig.hardwareAcceleration ?? "no-preference"}) is not supported by this browser. Consider using another codec or changing your video parameters.`
-            );
-          }
           const colorChunkQueue = [];
           const nullAlphaChunkQueue = [];
           let encodedAlphaChunkCount = 0;
@@ -33014,6 +33329,7 @@ ${cue.notes ?? ""}`;
               assert(alphaFrame !== void 0);
               if (alphaFrame) {
                 this.alphaEncoder.encode(alphaFrame, {
+                  ...this.defaultEncodeOptions,
                   // Crucial: The alpha frame is forced to be a key frame whenever the color frame
                   // also is. Without this, playback can glitch and even crash in some browsers.
                   // This is the reason why the two encoders are wired in series and not in parallel.
@@ -33069,36 +33385,42 @@ ${cue.notes ?? ""}`;
       })();
     }
     async flushAndClose(forceClose) {
-      if (!forceClose) {
-        this.checkForEncoderError();
-      }
-      if (!forceClose && this.frameRateLastSample) {
-        const frameRate = this.encodingConfig.transform.frameRate;
-        const alignedEnd = floorToDivisor(this.frameRateLastEndTimestamp, frameRate);
-        await this.padFrameRate(alignedEnd);
-      }
-      this.closed = true;
-      this.frameRateLastSample?.close();
-      this.frameRateLastSample = null;
-      if (this.customEncoder) {
+      try {
         if (!forceClose) {
-          void this.customEncoderCallSerializer.call(() => this.customEncoder.flush());
+          this.checkForEncoderError();
+          if (this.frameRateLastSample) {
+            const frameRate = this.encodingConfig.transform.frameRate;
+            const alignedEnd = floorToDivisor(this.frameRateLastEndTimestamp, frameRate);
+            await this.padFrameRate(alignedEnd);
+          }
         }
-        await this.customEncoderCallSerializer.call(() => this.customEncoder.close());
-      } else if (this.encoder) {
+        this.closed = true;
         if (!forceClose) {
-          await this.encoder.flush();
-          await this.alphaEncoder?.flush();
-          await wait(25);
-        }
-        if (this.encoder.state !== "closed") {
-          this.encoder.close();
+          if (this.customEncoder) {
+            void this.customEncoderCallSerializer.call(() => this.customEncoder.flush());
+          } else if (this.encoder) {
+            await this.encoder.flush();
+            await this.alphaEncoder?.flush();
+            await wait(25);
+          }
         }
-        if (this.alphaEncoder && this.alphaEncoder.state !== "closed") {
-          this.alphaEncoder.close();
+      } finally {
+        this.closed = true;
+        this.frameRateLastSample?.close();
+        this.frameRateLastSample = null;
+        if (this.customEncoder) {
+          await this.customEncoderCallSerializer.call(() => this.customEncoder.close()).catch((error) => this.setError(error));
+        } else if (this.encoder) {
+          if (this.encoder.state !== "closed") {
+            this.encoder.close();
+          }
+          if (this.alphaEncoder && this.alphaEncoder.state !== "closed") {
+            this.alphaEncoder.close();
+          }
+          this.alphaFrameQueue.forEach((x) => x?.close());
+          this.alphaFrameQueue.length = 0;
+          this.splitter?.close();
         }
-        this.alphaFrameQueue.forEach((x) => x?.close());
-        this.splitter?.close();
       }
       if (!forceClose) {
         this.checkForEncoderError();
@@ -33762,26 +34084,39 @@ ${cue.notes ?? ""}`;
         shouldClose = true;
       }
       if (config.transform?.process) {
-        let processed = config.transform.process(audioSample);
-        if (processed instanceof Promise) {
-          processed = await processed;
-        }
-        if (processed === null) {
-          return;
-        }
-        if (!Array.isArray(processed)) {
-          processed = [processed];
-        }
-        for (const sample of processed) {
-          if (!(sample instanceof AudioSample)) {
-            throw new TypeError(
-              "The audio process function must return an AudioSample, null, or an array of AudioSamples."
-            );
+        try {
+          let processed = config.transform.process(audioSample);
+          if (processed instanceof Promise) {
+            processed = await processed;
+          }
+          if (processed === null) {
+            return;
+          }
+          if (!Array.isArray(processed)) {
+            processed = [processed];
+          }
+          try {
+            for (const sample of processed) {
+              if (!(sample instanceof AudioSample)) {
+                throw new TypeError(
+                  "The audio process function must return an AudioSample, null, or an array of AudioSamples."
+                );
+              }
+            }
+            for (const sample of processed) {
+              await this.encodeSample(sample, true);
+            }
+          } finally {
+            for (const sample of processed) {
+              if (sample instanceof AudioSample) {
+                sample.close();
+              }
+            }
+          }
+        } finally {
+          if (shouldClose) {
+            audioSample.close();
           }
-          await this.encodeSample(sample, true);
-        }
-        if (shouldClose) {
-          audioSample.close();
         }
       } else {
         await this.encodeSample(audioSample, shouldClose);
@@ -33917,10 +34252,12 @@ ${cue.notes ?? ""}`;
     ensureEncoder(audioSample) {
       this.ensureEncoderPromise = (async () => {
         const { numberOfChannels, sampleRate } = audioSample;
+        const quality = resolveQuality(this.encodingConfig.quality, this.encodingConfig.bitrate);
         const encoderConfig = buildAudioEncoderConfig({
           numberOfChannels,
           sampleRate,
-          ...this.encodingConfig
+          ...this.encodingConfig,
+          quality
         });
         this.encodingConfig.onEncoderConfig?.(encoderConfig);
         const MatchingCustomEncoder = customAudioEncoders.find((x) => x.supports(
@@ -34099,24 +34436,27 @@ ${cue.notes ?? ""}`;
       }
     }
     async flushAndClose(forceClose) {
-      if (!forceClose) {
-        this.checkForEncoderError();
-      }
-      if (!forceClose && this.resampler) {
-        await this.resampler.finalize();
-      }
-      this.resampler = null;
-      this.closed = true;
-      if (this.customEncoder) {
+      try {
         if (!forceClose) {
-          void this.customEncoderCallSerializer.call(() => this.customEncoder.flush());
+          this.checkForEncoderError();
+          if (this.resampler) {
+            await this.resampler.finalize();
+          }
         }
-        await this.customEncoderCallSerializer.call(() => this.customEncoder.close());
-      } else if (this.encoder) {
+        this.closed = true;
         if (!forceClose) {
-          await this.encoder.flush();
+          if (this.customEncoder) {
+            void this.customEncoderCallSerializer.call(() => this.customEncoder.flush());
+          } else if (this.encoder) {
+            await this.encoder.flush();
+          }
         }
-        if (this.encoder.state !== "closed") {
+      } finally {
+        this.closed = true;
+        this.resampler = null;
+        if (this.customEncoder) {
+          await this.customEncoderCallSerializer.call(() => this.customEncoder.close()).catch((error) => this.setError(error));
+        } else if (this.encoder && this.encoder.state !== "closed") {
           this.encoder.close();
         }
       }
@@ -36801,6 +37141,9 @@ ${cue.notes ?? ""}`;
           }
           this.state = "finalized";
         } finally {
+          await Promise.all([...this._unfinalizedTargets].map((target) => target._close().catch(() => {
+          })));
+          this._unfinalizedTargets.clear();
           release();
         }
       })();
@@ -36823,7 +37166,14 @@ ${cue.notes ?? ""}`;
         `options.video.codec, when provided, must be one of: ${VIDEO_CODECS.join(", ")}.`
       );
     }
-    if (videoOptions?.bitrate !== void 0 && !(videoOptions.bitrate instanceof Quality) && (!Number.isInteger(videoOptions.bitrate) || videoOptions.bitrate <= 0)) {
+    const bitrate = videoOptions?.bitrate;
+    if (videoOptions?.quality !== void 0 && !(videoOptions.quality instanceof Quality)) {
+      throw new TypeError("options.video.quality, when provided, must be a Quality.");
+    }
+    if (videoOptions?.quality !== void 0 && bitrate !== void 0) {
+      throw new TypeError("options.video.quality and options.video.bitrate cannot both be provided.");
+    }
+    if (bitrate !== void 0 && !(bitrate instanceof Quality) && (!Number.isInteger(bitrate) || bitrate <= 0)) {
       throw new TypeError("options.video.bitrate, when provided, must be a positive integer or a quality.");
     }
     if (videoOptions?.width !== void 0 && (!Number.isInteger(videoOptions.width) || videoOptions.width <= 0)) {
@@ -36893,7 +37243,14 @@ ${cue.notes ?? ""}`;
         `options.audio.codec, when provided, must be one of: ${AUDIO_CODECS.join(", ")}.`
       );
     }
-    if (audioOptions?.bitrate !== void 0 && !(audioOptions.bitrate instanceof Quality) && (!Number.isInteger(audioOptions.bitrate) || audioOptions.bitrate <= 0)) {
+    const bitrate = audioOptions?.bitrate;
+    if (audioOptions?.quality !== void 0 && !(audioOptions.quality instanceof Quality)) {
+      throw new TypeError("options.audio.quality, when provided, must be a Quality.");
+    }
+    if (audioOptions?.quality !== void 0 && bitrate !== void 0) {
+      throw new TypeError("options.audio.quality and options.audio.bitrate cannot both be provided.");
+    }
+    if (bitrate !== void 0 && !(bitrate instanceof Quality) && (!Number.isInteger(bitrate) || bitrate <= 0)) {
       throw new TypeError("options.audio.bitrate, when provided, must be a positive integer or a quality.");
     }
     if (audioOptions?.numberOfChannels !== void 0 && (!Number.isInteger(audioOptions.numberOfChannels) || audioOptions.numberOfChannels <= 0)) {
@@ -37277,24 +37634,26 @@ ${cue.notes ?? ""}`;
         if (encodabilityIsTheProblem) {
           const codecs = this.discardedTracks.flatMap((x) => {
             if (x.reason === "discarded_by_user") return [];
+            let supportedCodecs;
             if (x.track.type === "video") {
-              return this.output.format.getSupportedVideoCodecs();
+              supportedCodecs = this.output.format.getSupportedVideoCodecs();
             } else if (x.track.type === "audio") {
-              return this.output.format.getSupportedAudioCodecs();
+              supportedCodecs = this.output.format.getSupportedAudioCodecs();
             } else {
-              return this.output.format.getSupportedSubtitleCodecs();
+              supportedCodecs = this.output.format.getSupportedSubtitleCodecs();
             }
+            return supportedCodecs.filter((codec) => !x.trackOptions.codec || codec === x.trackOptions.codec);
           });
           const uniqueCodecs = [...new Set(codecs)];
           if (uniqueCodecs.length === 1) {
             elements.push(
               `
-Tracks were discarded because your environment is not able to encode '${uniqueCodecs[0]}'.`
+Tracks were discarded because your environment is not able to encode '${uniqueCodecs[0]}' with the provided parameters.`
             );
           } else {
             elements.push(
               `
-Tracks were discarded because your environment is not able to encode any of the following codecs: ${uniqueCodecs.map((x) => `'${x}'`).join(", ")}.`
+Tracks were discarded because your environment is not able to encode any of the codecs ${uniqueCodecs.map((x) => `'${x}'`).join(", ")} with the provided parameters.`
             );
           }
           if (uniqueCodecs.includes("mp3")) {
@@ -37497,7 +37856,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       }
       const firstTimestamp = await track.getFirstTimestamp();
       let videoCodecs = this.output.format.getSupportedVideoCodecs();
-      const needsTranscode = !!trackOptions.forceTranscode || firstTimestamp < this._startTimestamp || !!trackOptions.frameRate || trackOptions.keyFrameInterval !== void 0 || trackOptions.process !== void 0 || trackOptions.bitrate !== void 0 || !videoCodecs.includes(sourceCodec) || trackOptions.codec && trackOptions.codec !== sourceCodec || width !== originalWidth || height !== originalHeight || totalRotation !== 0 && !canUseRotationMetadata || !!crop;
+      const needsTranscode = !!trackOptions.forceTranscode || firstTimestamp < this._startTimestamp || !!trackOptions.frameRate || trackOptions.keyFrameInterval !== void 0 || trackOptions.process !== void 0 || trackOptions.quality !== void 0 || trackOptions.bitrate !== void 0 || !videoCodecs.includes(sourceCodec) || trackOptions.codec && trackOptions.codec !== sourceCodec || width !== originalWidth || height !== originalHeight || totalRotation !== 0 && !canUseRotationMetadata || !!crop;
       const alpha = trackOptions.alpha ?? "discard";
       if (!needsTranscode) {
         const source = new EncodedVideoPacketSource(sourceCodec);
@@ -37541,11 +37900,11 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         if (trackOptions.codec) {
           videoCodecs = videoCodecs.filter((codec) => codec === trackOptions.codec);
         }
-        const bitrate = trackOptions.bitrate ?? QUALITY_HIGH;
+        const quality = resolveQuality(trackOptions.quality, trackOptions.bitrate) ?? new Quality("high");
         const encodableCodec = await getFirstEncodableVideoCodec(videoCodecs, {
           width: trackOptions.process && trackOptions.processedWidth ? trackOptions.processedWidth : width,
           height: trackOptions.process && trackOptions.processedHeight ? trackOptions.processedHeight : height,
-          bitrate
+          quality
         });
         if (!encodableCodec) {
           this.discardedTracks.push({
@@ -37557,7 +37916,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         }
         const encodingConfig = {
           codec: encodableCodec,
-          bitrate,
+          quality,
           keyFrameInterval: trackOptions.keyFrameInterval,
           sizeChangeBehavior: trackOptions.fit ?? "passThrough",
           alpha,
@@ -37691,7 +38050,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       const needsTrimming = firstTimestamp < this._startTimestamp;
       let needsPadding = firstTimestamp > this._startTimestamp && !this.output.format.supportsTimestampedMediaData;
       let audioCodecs = this.output.format.getSupportedAudioCodecs();
-      if (!trackOptions.forceTranscode && !trackOptions.bitrate && numberOfChannels === originalNumberOfChannels && sampleRate === originalSampleRate && !needsTrimming && !needsPadding && audioCodecs.includes(sourceCodec) && (!trackOptions.codec || trackOptions.codec === sourceCodec) && !trackOptions.process && trackOptions.sampleFormat === void 0) {
+      if (!trackOptions.forceTranscode && !trackOptions.quality && !trackOptions.bitrate && numberOfChannels === originalNumberOfChannels && sampleRate === originalSampleRate && !needsTrimming && !needsPadding && audioCodecs.includes(sourceCodec) && (!trackOptions.codec || trackOptions.codec === sourceCodec) && !trackOptions.process && trackOptions.sampleFormat === void 0) {
         const source = new EncodedAudioPacketSource(sourceCodec);
         audioSource = source;
         this._registerTrackPump(async (pump) => {
@@ -37733,17 +38092,17 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         if (trackOptions.codec) {
           audioCodecs = audioCodecs.filter((codec) => codec === trackOptions.codec);
         }
-        const bitrate = trackOptions.bitrate ?? QUALITY_HIGH;
+        const quality = resolveQuality(trackOptions.quality, trackOptions.bitrate) ?? new Quality("high");
         const encodableCodecs = await getEncodableAudioCodecs(audioCodecs, {
           numberOfChannels: trackOptions.process && trackOptions.processedNumberOfChannels ? trackOptions.processedNumberOfChannels : numberOfChannels,
           sampleRate: trackOptions.process && trackOptions.processedSampleRate ? trackOptions.processedSampleRate : sampleRate,
-          bitrate
+          quality
         });
         if (!encodableCodecs.some((codec) => NON_PCM_AUDIO_CODECS.includes(codec)) && audioCodecs.some((codec) => NON_PCM_AUDIO_CODECS.includes(codec)) && (numberOfChannels !== FALLBACK_NUMBER_OF_CHANNELS || sampleRate !== FALLBACK_SAMPLE_RATE)) {
           const encodableCodecsWithDefaultParams = await getEncodableAudioCodecs(audioCodecs, {
             numberOfChannels: FALLBACK_NUMBER_OF_CHANNELS,
             sampleRate: FALLBACK_SAMPLE_RATE,
-            bitrate
+            quality
           });
           const nonPcmCodec = encodableCodecsWithDefaultParams.find((codec) => NON_PCM_AUDIO_CODECS.includes(codec));
           if (nonPcmCodec) {
@@ -37764,7 +38123,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         }
         const encodingConfig = {
           codec: codecOfChoice,
-          bitrate,
+          quality,
           transform: {
             sampleFormat: trackOptions.sampleFormat,
             process: trackOptions.process