mediabunny 1.6.2 → 1.7.1

package/dist/bundles/mediabunny.cjs

@@ -344,6 +344,10 @@ var Mediabunny = (() => {
     }
     return ans;
   };
+  var insertSorted = (arr, item, valueGetter) => {
+    const insertionIndex = binarySearchLessOrEqual(arr, valueGetter(item), valueGetter);
+    arr.splice(insertionIndex + 1, 0, item);
+  };
   var promiseWithResolvers = () => {
     let resolve;
     let reject;
@@ -550,6 +554,15 @@ var Mediabunny = (() => {
       return this.currentPromise = this.currentPromise.then(fn);
     }
   };
+  var isSafariCache = null;
+  var isSafari = () => {
+    if (isSafariCache !== null) {
+      return isSafariCache;
+    }
+    const result = !!(typeof navigator !== "undefined" && navigator.vendor?.match(/apple/i) && !navigator.userAgent?.match(/crios/i) && !navigator.userAgent?.match(/fxios/i) && !navigator.userAgent?.match(/Opera|OPT\//));
+    isSafariCache = result;
+    return result;
+  };
 
   // src/custom-coder.ts
   var CustomVideoDecoder = class {
@@ -5536,8 +5549,7 @@ var Mediabunny = (() => {
       }
       this.writer.write(this.helper.subarray(0, pos));
     }
-    // Assumes the string is ASCII
-    writeString(str) {
+    writeAsciiString(str) {
       this.writer.write(new Uint8Array(str.split("").map((x) => x.charCodeAt(0))));
     }
     writeEBML(data) {
@@ -5575,7 +5587,7 @@ var Mediabunny = (() => {
           this.writeUnsignedInt(data.data, size);
         } else if (typeof data.data === "string") {
           this.writeVarInt(data.data.length);
-          this.writeString(data.data);
+          this.writeAsciiString(data.data);
         } else if (data.data instanceof Uint8Array) {
           this.writeVarInt(data.data.byteLength, data.size);
           this.writer.write(data.data);
@@ -5677,7 +5689,7 @@ var Mediabunny = (() => {
       this.pos += width;
       return value;
     }
-    readString(length) {
+    readAsciiString(length) {
       const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + length);
       this.pos += length;
       let strLength = 0;
@@ -6637,7 +6649,8 @@ ${cue.notes ?? ""}`;
     async addEncodedAudioPacket(track, packet) {
       const release = await this.mutex.acquire();
       try {
-        if (!this.xingFrameData) {
+        const writeXingHeader = this.format._options.xingHeader !== false;
+        if (!this.xingFrameData && writeXingHeader) {
           const view2 = toDataView(packet.data);
           if (view2.byteLength < 4) {
             throw new Error("Invalid MP3 header in sample.");
@@ -6672,10 +6685,12 @@ ${cue.notes ?? ""}`;
           this.frameCount++;
         }
         this.validateAndNormalizeTimestamp(track, packet.timestamp, packet.type === "key");
-        this.framePositions.push(this.writer.getPos());
         this.writer.write(packet.data);
         this.frameCount++;
         await this.writer.flush();
+        if (writeXingHeader) {
+          this.framePositions.push(this.writer.getPos());
+        }
       } finally {
         release();
       }
@@ -8745,6 +8760,7 @@ ${cue.notes ?? ""}`;
     return decodedSampleQueueSize === 0 ? 40 : 8;
   };
   var VideoDecoderWrapper = class extends DecoderWrapper {
+    // Safari-specific thing, check usage.
     constructor(onSample, onError, codec, decoderConfig, rotation, timeResolution) {
       super(onSample, onError);
       this.rotation = rotation;
@@ -8753,21 +8769,9 @@ ${cue.notes ?? ""}`;
       this.customDecoder = null;
       this.customDecoderCallSerializer = new CallSerializer();
       this.customDecoderQueueSize = 0;
+      this.inputTimestamps = [];
+      // Timestamps input into the decoder, sorted.
       this.sampleQueue = [];
-      const sampleHandler = (sample) => {
-        if (this.sampleQueue.length > 0 && sample.timestamp >= last(this.sampleQueue).timestamp) {
-          for (const sample2 of this.sampleQueue) {
-            this.finalizeAndEmitSample(sample2);
-          }
-          this.sampleQueue.length = 0;
-        }
-        const insertionIndex = binarySearchLessOrEqual(
-          this.sampleQueue,
-          sample.timestamp,
-          (x) => x.timestamp
-        );
-        this.sampleQueue.splice(insertionIndex + 1, 0, sample);
-      };
       const MatchingCustomDecoder = customVideoDecoders.find((x) => x.supports(codec, decoderConfig));
       if (MatchingCustomDecoder) {
         this.customDecoder = new MatchingCustomDecoder();
@@ -8777,10 +8781,26 @@ ${cue.notes ?? ""}`;
           if (!(sample instanceof VideoSample)) {
             throw new TypeError("The argument passed to onSample must be a VideoSample.");
           }
-          sampleHandler(sample);
+          this.finalizeAndEmitSample(sample);
         };
         void this.customDecoderCallSerializer.call(() => this.customDecoder.init());
       } else {
+        const sampleHandler = (sample) => {
+          if (isSafari()) {
+            if (this.sampleQueue.length > 0 && sample.timestamp >= last(this.sampleQueue).timestamp) {
+              for (const sample2 of this.sampleQueue) {
+                this.finalizeAndEmitSample(sample2);
+              }
+              this.sampleQueue.length = 0;
+            }
+            insertSorted(this.sampleQueue, sample, (x) => x.timestamp);
+          } else {
+            const timestamp = this.inputTimestamps.shift();
+            assert(timestamp !== void 0);
+            sample.setTimestamp(timestamp);
+            this.finalizeAndEmitSample(sample);
+          }
+        };
         this.decoder = new VideoDecoder({
           output: (frame) => sampleHandler(new VideoSample(frame)),
           error: onError
@@ -8808,6 +8828,9 @@ ${cue.notes ?? ""}`;
         void this.customDecoderCallSerializer.call(() => this.customDecoder.decode(packet)).then(() => this.customDecoderQueueSize--);
       } else {
         assert(this.decoder);
+        if (!isSafari()) {
+          insertSorted(this.inputTimestamps, packet.timestamp, (x) => x);
+        }
         this.decoder.decode(packet.toEncodedVideoChunk());
       }
     }
@@ -8818,10 +8841,12 @@ ${cue.notes ?? ""}`;
         assert(this.decoder);
         await this.decoder.flush();
       }
-      for (const sample of this.sampleQueue) {
-        this.finalizeAndEmitSample(sample);
+      if (isSafari()) {
+        for (const sample of this.sampleQueue) {
+          this.finalizeAndEmitSample(sample);
+        }
+        this.sampleQueue.length = 0;
       }
-      this.sampleQueue.length = 0;
     }
     close() {
       if (this.customDecoder) {
@@ -10420,6 +10445,9 @@ ${cue.notes ?? ""}`;
       if (!options || typeof options !== "object") {
         throw new TypeError("options must be an object.");
       }
+      if (options.xingHeader !== void 0 && typeof options.xingHeader !== "boolean") {
+        throw new TypeError("options.xingHeader, when provided, must be a boolean.");
+      }
       if (options.onXingFrame !== void 0 && typeof options.onXingFrame !== "function") {
         throw new TypeError("options.onXingFrame, when provided, must be a function.");
       }
@@ -11567,6 +11595,7 @@ ${cue.notes ?? ""}`;
           this._promiseWithResolvers.reject(error);
         });
       } else {
+        const AudioContext = window.AudioContext || window.webkitAudioContext;
         this._audioContext = new AudioContext({ sampleRate: this._track.getSettings().sampleRate });
         const sourceNode = this._audioContext.createMediaStreamSource(new MediaStream([this._track]));
         this._scriptProcessorNode = this._audioContext.createScriptProcessor(4096);
@@ -12100,7 +12129,9 @@ ${cue.notes ?? ""}`;
       super();
       /** @internal */
       this._fullData = null;
-      this._url = url2;
+      /** @internal */
+      this._nextUrlVersion = null;
+      this._url = url2 instanceof URL ? url2 : new URL(url2);
       this._options = options;
     }
     /** @internal */
@@ -12109,6 +12140,10 @@ ${cue.notes ?? ""}`;
       if (range) {
         headers["Range"] = `bytes=${range.start}-${range.end - 1}`;
       }
+      if (this._nextUrlVersion !== null) {
+        this._url.searchParams.set("mediabunny_version", this._nextUrlVersion.toString());
+        this._nextUrlVersion++;
+      }
       const response = await retriedFetch(
         this._url,
         mergeObjectsDeeply(this._options.requestInit ?? {}, {
@@ -12121,6 +12156,10 @@ ${cue.notes ?? ""}`;
         throw new Error(`Error fetching ${this._url}: ${response.status} ${response.statusText}`);
       }
       const buffer = await response.arrayBuffer();
+      if (response.status === 206 && range && buffer.byteLength !== range.end - range.start && this._nextUrlVersion === null) {
+        this._nextUrlVersion = 1;
+        return this._makeRequest(range);
+      }
       if (response.status === 200) {
         this._fullData = buffer;
       }
@@ -13365,12 +13404,7 @@ ${cue.notes ?? ""}`;
               isKnownToBeFirstFragment: false
             };
             this.readContiguousBoxes(boxInfo.contentSize);
-            const insertionIndex = binarySearchLessOrEqual(
-              this.fragments,
-              this.currentFragment.moofOffset,
-              (x) => x.moofOffset
-            );
-            this.fragments.splice(insertionIndex + 1, 0, this.currentFragment);
+            insertSorted(this.fragments, this.currentFragment, (x) => x.moofOffset);
             for (const [, trackData] of this.currentFragment.trackData) {
               const firstSample = trackData.samples[0];
               const lastSample = last(trackData.samples);
@@ -13394,20 +13428,14 @@ ${cue.notes ?? ""}`;
             if (this.currentTrack) {
               const trackData = this.currentFragment.trackData.get(this.currentTrack.id);
               if (trackData) {
-                const insertionIndex = binarySearchLessOrEqual(
-                  this.currentTrack.fragments,
-                  this.currentFragment.moofOffset,
-                  (x) => x.moofOffset
-                );
-                this.currentTrack.fragments.splice(insertionIndex + 1, 0, this.currentFragment);
+                insertSorted(this.currentTrack.fragments, this.currentFragment, (x) => x.moofOffset);
                 const hasKeyFrame = trackData.firstKeyFrameTimestamp !== null;
                 if (hasKeyFrame) {
-                  const insertionIndex2 = binarySearchLessOrEqual(
+                  insertSorted(
                     this.currentTrack.fragmentsWithKeyFrame,
-                    this.currentFragment.moofOffset,
+                    this.currentFragment,
                     (x) => x.moofOffset
                   );
-                  this.currentTrack.fragmentsWithKeyFrame.splice(insertionIndex2 + 1, 0, this.currentFragment);
                 }
                 const { currentFragmentState } = this.currentTrack;
                 assert(currentFragmentState);
@@ -14496,29 +14524,14 @@ ${cue.notes ?? ""}`;
         trackData.startTimestamp = firstBlock.timestamp;
         trackData.endTimestamp = lastBlock.timestamp + lastBlock.duration;
         if (track) {
-          const insertionIndex2 = binarySearchLessOrEqual(
-            track.clusters,
-            cluster.elementStartPos,
-            (x) => x.elementStartPos
-          );
-          track.clusters.splice(insertionIndex2 + 1, 0, cluster);
+          insertSorted(track.clusters, cluster, (x) => x.elementStartPos);
           const hasKeyFrame = trackData.firstKeyFrameTimestamp !== null;
           if (hasKeyFrame) {
-            const insertionIndex3 = binarySearchLessOrEqual(
-              track.clustersWithKeyFrame,
-              cluster.elementStartPos,
-              (x) => x.elementStartPos
-            );
-            track.clustersWithKeyFrame.splice(insertionIndex3 + 1, 0, cluster);
+            insertSorted(track.clustersWithKeyFrame, cluster, (x) => x.elementStartPos);
           }
         }
       }
-      const insertionIndex = binarySearchLessOrEqual(
-        segment.clusters,
-        elementStartPos,
-        (x) => x.elementStartPos
-      );
-      segment.clusters.splice(insertionIndex + 1, 0, cluster);
+      insertSorted(segment.clusters, cluster, (x) => x.elementStartPos);
       this.currentCluster = null;
       return cluster;
     }
@@ -14638,7 +14651,7 @@ ${cue.notes ?? ""}`;
       switch (id) {
         case 17026 /* DocType */:
           {
-            this.isWebM = reader.readString(size) === "webm";
+            this.isWebM = reader.readAsciiString(size) === "webm";
           }
           ;
           break;
@@ -14836,7 +14849,7 @@ ${cue.notes ?? ""}`;
         case 134 /* CodecID */:
           {
             if (!this.currentTrack) break;
-            this.currentTrack.codecId = reader.readString(size);
+            this.currentTrack.codecId = reader.readAsciiString(size);
           }
           ;
           break;
@@ -14857,7 +14870,7 @@ ${cue.notes ?? ""}`;
         case 2274716 /* Language */:
           {
             if (!this.currentTrack) break;
-            this.currentTrack.languageCode = reader.readString(size);
+            this.currentTrack.languageCode = reader.readAsciiString(size);
             if (!isIso639Dash2LanguageCode(this.currentTrack.languageCode)) {
               this.currentTrack.languageCode = UNDETERMINED_LANGUAGE;
             }
@@ -15672,45 +15685,21 @@ ${cue.notes ?? ""}`;
       super(input);
       this.metadataPromise = null;
       this.firstFrameHeader = null;
-      this.allSamples = [];
+      this.loadedSamples = [];
+      // All samples from the start of the file to lastLoadedPos
       this.tracks = [];
+      this.loadingMutex = new AsyncMutex();
+      this.lastLoadedPos = 0;
+      this.fileSize = 0;
+      this.nextTimestampInSamples = 0;
       this.reader = new Mp3Reader(input._mainReader);
     }
     async readMetadata() {
       return this.metadataPromise ??= (async () => {
-        const fileSize = await this.input.source.getSize();
-        this.reader.fileSize = fileSize;
-        await this.reader.reader.loadRange(0, fileSize);
-        const id3Tag = this.reader.readId3();
-        if (id3Tag) {
-          this.reader.pos += id3Tag.size;
-        }
-        let nextTimestampInSamples = 0;
-        while (true) {
-          const header = this.reader.readNextFrameHeader();
-          if (!header) {
-            break;
-          }
-          const xingOffset = getXingOffset(header.mpegVersionId, header.channel);
-          this.reader.pos = header.startPos + xingOffset;
-          const word = this.reader.readU32();
-          const isXing = word === XING || word === INFO;
-          this.reader.pos = header.startPos + header.totalSize - 1;
-          if (isXing) {
-            continue;
-          }
-          if (!this.firstFrameHeader) {
-            this.firstFrameHeader = header;
-          }
-          const sampleDuration = header.audioSamplesInFrame / header.sampleRate;
-          const sample = {
-            timestamp: nextTimestampInSamples / header.sampleRate,
-            duration: sampleDuration,
-            dataStart: header.startPos,
-            dataSize: header.totalSize
-          };
-          this.allSamples.push(sample);
-          nextTimestampInSamples += header.audioSamplesInFrame;
+        this.fileSize = await this.input.source.getSize();
+        this.reader.fileSize = this.fileSize;
+        while (!this.firstFrameHeader && this.lastLoadedPos < this.fileSize) {
+          await this.loadNextChunk();
         }
         if (!this.firstFrameHeader) {
           throw new Error("No MP3 frames found.");
@@ -15718,6 +15707,61 @@ ${cue.notes ?? ""}`;
         this.tracks = [new InputAudioTrack(new Mp3AudioTrackBacking(this))];
       })();
     }
+    /** Loads the next 0.5 MiB of frames. */
+    async loadNextChunk() {
+      const release = await this.loadingMutex.acquire();
+      try {
+        assert(this.lastLoadedPos < this.fileSize);
+        const chunkSize = 0.5 * 1024 * 1024;
+        const endPos = Math.min(this.lastLoadedPos + chunkSize, this.fileSize);
+        await this.reader.reader.loadRange(this.lastLoadedPos, endPos);
+        this.lastLoadedPos = endPos;
+        assert(this.lastLoadedPos <= this.fileSize);
+        if (this.reader.pos === 0) {
+          const id3Tag = this.reader.readId3();
+          if (id3Tag) {
+            this.reader.pos += id3Tag.size;
+          }
+        }
+        this.parseFramesFromLoadedData();
+      } finally {
+        release();
+      }
+    }
+    parseFramesFromLoadedData() {
+      while (true) {
+        const startPos = this.reader.pos;
+        const header = this.reader.readNextFrameHeader();
+        if (!header) {
+          break;
+        }
+        if (header.startPos + header.totalSize > this.lastLoadedPos) {
+          this.reader.pos = startPos;
+          this.lastLoadedPos = startPos;
+          break;
+        }
+        const xingOffset = getXingOffset(header.mpegVersionId, header.channel);
+        this.reader.pos = header.startPos + xingOffset;
+        const word = this.reader.readU32();
+        const isXing = word === XING || word === INFO;
+        this.reader.pos = header.startPos + header.totalSize - 1;
+        if (isXing) {
+          continue;
+        }
+        if (!this.firstFrameHeader) {
+          this.firstFrameHeader = header;
+        }
+        const sampleDuration = header.audioSamplesInFrame / header.sampleRate;
+        const sample = {
+          timestamp: this.nextTimestampInSamples / header.sampleRate,
+          duration: sampleDuration,
+          dataStart: header.startPos,
+          dataSize: header.totalSize
+        };
+        this.loadedSamples.push(sample);
+        this.nextTimestampInSamples += header.audioSamplesInFrame;
+      }
+    }
     async getMimeType() {
       return "audio/mpeg";
     }
@@ -15727,9 +15771,9 @@ ${cue.notes ?? ""}`;
     }
     async computeDuration() {
       await this.readMetadata();
-      const lastSample = last(this.allSamples);
-      assert(lastSample);
-      return lastSample.timestamp + lastSample.duration;
+      const track = this.tracks[0];
+      assert(track);
+      return track.computeDuration();
     }
   };
   var Mp3AudioTrackBacking = class {
@@ -15746,8 +15790,9 @@ ${cue.notes ?? ""}`;
       assert(this.demuxer.firstFrameHeader);
       return this.demuxer.firstFrameHeader.sampleRate / this.demuxer.firstFrameHeader.audioSamplesInFrame;
     }
-    computeDuration() {
-      return this.demuxer.computeDuration();
+    async computeDuration() {
+      const lastPacket = await this.getPacket(Infinity, { metadataOnly: true });
+      return (lastPacket?.timestamp ?? 0) + (lastPacket?.duration ?? 0);
     }
     getLanguageCode() {
       return UNDETERMINED_LANGUAGE;
@@ -15775,7 +15820,7 @@ ${cue.notes ?? ""}`;
       if (sampleIndex === -1) {
         return null;
       }
-      const rawSample = this.demuxer.allSamples[sampleIndex];
+      const rawSample = this.demuxer.loadedSamples[sampleIndex];
       if (!rawSample) {
         return null;
       }
@@ -15796,26 +15841,44 @@ ${cue.notes ?? ""}`;
       );
     }
     async getFirstPacket(options) {
+      while (this.demuxer.loadedSamples.length === 0 && this.demuxer.lastLoadedPos < this.demuxer.fileSize) {
+        await this.demuxer.loadNextChunk();
+      }
       return this.getPacketAtIndex(0, options);
     }
     async getNextPacket(packet, options) {
       const sampleIndex = binarySearchExact(
-        this.demuxer.allSamples,
+        this.demuxer.loadedSamples,
         packet.timestamp,
         (x) => x.timestamp
       );
       if (sampleIndex === -1) {
         throw new Error("Packet was not created from this track.");
       }
-      return this.getPacketAtIndex(sampleIndex + 1, options);
+      const nextIndex = sampleIndex + 1;
+      while (nextIndex >= this.demuxer.loadedSamples.length && this.demuxer.lastLoadedPos < this.demuxer.fileSize) {
+        await this.demuxer.loadNextChunk();
+      }
+      return this.getPacketAtIndex(nextIndex, options);
     }
     async getPacket(timestamp, options) {
-      const index = binarySearchLessOrEqual(
-        this.demuxer.allSamples,
-        timestamp,
-        (x) => x.timestamp
-      );
-      return this.getPacketAtIndex(index, options);
+      while (true) {
+        const index = binarySearchLessOrEqual(
+          this.demuxer.loadedSamples,
+          timestamp,
+          (x) => x.timestamp
+        );
+        if (index === -1 && this.demuxer.loadedSamples.length > 0) {
+          return null;
+        }
+        if (this.demuxer.lastLoadedPos === this.demuxer.fileSize) {
+          return this.getPacketAtIndex(index, options);
+        }
+        if (index >= 0 && index + 1 < this.demuxer.loadedSamples.length) {
+          return this.getPacketAtIndex(index, options);
+        }
+        await this.demuxer.loadNextChunk();
+      }
     }
     getKeyPacket(timestamp, options) {
       return this.getPacket(timestamp, options);
@@ -16615,7 +16678,7 @@ ${cue.notes ?? ""}`;
             break;
           case 17026 /* DocType */:
             {
-              const docType = ebmlReader.readString(size);
+              const docType = ebmlReader.readAsciiString(size);
               if (docType !== desiredDocType) {
                 return false;
               }
@@ -16856,6 +16919,70 @@ ${cue.notes ?? ""}`;
   };
 
   // src/conversion.ts
+  var validateVideoOptions = (videoOptions) => {
+    if (videoOptions !== void 0 && (!videoOptions || typeof videoOptions !== "object")) {
+      throw new TypeError("options.video, when provided, must be an object.");
+    }
+    if (videoOptions?.discard !== void 0 && typeof videoOptions.discard !== "boolean") {
+      throw new TypeError("options.video.discard, when provided, must be a boolean.");
+    }
+    if (videoOptions?.forceTranscode !== void 0 && typeof videoOptions.forceTranscode !== "boolean") {
+      throw new TypeError("options.video.forceTranscode, when provided, must be a boolean.");
+    }
+    if (videoOptions?.codec !== void 0 && !VIDEO_CODECS.includes(videoOptions.codec)) {
+      throw new TypeError(
+        `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)) {
+      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)) {
+      throw new TypeError("options.video.width, when provided, must be a positive integer.");
+    }
+    if (videoOptions?.height !== void 0 && (!Number.isInteger(videoOptions.height) || videoOptions.height <= 0)) {
+      throw new TypeError("options.video.height, when provided, must be a positive integer.");
+    }
+    if (videoOptions?.fit !== void 0 && !["fill", "contain", "cover"].includes(videoOptions.fit)) {
+      throw new TypeError('options.video.fit, when provided, must be one of "fill", "contain", or "cover".');
+    }
+    if (videoOptions?.width !== void 0 && videoOptions.height !== void 0 && videoOptions.fit === void 0) {
+      throw new TypeError(
+        "When both options.video.width and options.video.height are provided, options.video.fit must also be provided."
+      );
+    }
+    if (videoOptions?.rotate !== void 0 && ![0, 90, 180, 270].includes(videoOptions.rotate)) {
+      throw new TypeError("options.video.rotate, when provided, must be 0, 90, 180 or 270.");
+    }
+    if (videoOptions?.frameRate !== void 0 && (!Number.isFinite(videoOptions.frameRate) || videoOptions.frameRate <= 0)) {
+      throw new TypeError("options.video.frameRate, when provided, must be a finite positive number.");
+    }
+  };
+  var validateAudioOptions = (audioOptions) => {
+    if (audioOptions !== void 0 && (!audioOptions || typeof audioOptions !== "object")) {
+      throw new TypeError("options.audio, when provided, must be an object.");
+    }
+    if (audioOptions?.discard !== void 0 && typeof audioOptions.discard !== "boolean") {
+      throw new TypeError("options.audio.discard, when provided, must be a boolean.");
+    }
+    if (audioOptions?.forceTranscode !== void 0 && typeof audioOptions.forceTranscode !== "boolean") {
+      throw new TypeError("options.audio.forceTranscode, when provided, must be a boolean.");
+    }
+    if (audioOptions?.codec !== void 0 && !AUDIO_CODECS.includes(audioOptions.codec)) {
+      throw new TypeError(
+        `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)) {
+      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)) {
+      throw new TypeError("options.audio.numberOfChannels, when provided, must be a positive integer.");
+    }
+    if (audioOptions?.sampleRate !== void 0 && (!Number.isInteger(audioOptions.sampleRate) || audioOptions.sampleRate <= 0)) {
+      throw new TypeError("options.audio.sampleRate, when provided, must be a positive integer.");
+    }
+  };
   var FALLBACK_NUMBER_OF_CHANNELS = 2;
   var FALLBACK_SAMPLE_RATE = 48e3;
   var Conversion = class _Conversion {
@@ -16909,65 +17036,13 @@ ${cue.notes ?? ""}`;
       if (options.output._tracks.length > 0 || options.output.state !== "pending") {
         throw new TypeError("options.output must be fresh: no tracks added and not started.");
       }
-      if (options.video !== void 0 && (!options.video || typeof options.video !== "object")) {
-        throw new TypeError("options.video, when provided, must be an object.");
-      }
-      if (options.video?.discard !== void 0 && typeof options.video.discard !== "boolean") {
-        throw new TypeError("options.video.discard, when provided, must be a boolean.");
-      }
-      if (options.video?.forceTranscode !== void 0 && typeof options.video.forceTranscode !== "boolean") {
-        throw new TypeError("options.video.forceTranscode, when provided, must be a boolean.");
-      }
-      if (options.video?.codec !== void 0 && !VIDEO_CODECS.includes(options.video.codec)) {
-        throw new TypeError(
-          `options.video.codec, when provided, must be one of: ${VIDEO_CODECS.join(", ")}.`
-        );
-      }
-      if (options.video?.bitrate !== void 0 && !(options.video.bitrate instanceof Quality) && (!Number.isInteger(options.video.bitrate) || options.video.bitrate <= 0)) {
-        throw new TypeError("options.video.bitrate, when provided, must be a positive integer or a quality.");
-      }
-      if (options.video?.width !== void 0 && (!Number.isInteger(options.video.width) || options.video.width <= 0)) {
-        throw new TypeError("options.video.width, when provided, must be a positive integer.");
-      }
-      if (options.video?.height !== void 0 && (!Number.isInteger(options.video.height) || options.video.height <= 0)) {
-        throw new TypeError("options.video.height, when provided, must be a positive integer.");
-      }
-      if (options.video?.fit !== void 0 && !["fill", "contain", "cover"].includes(options.video.fit)) {
-        throw new TypeError('options.video.fit, when provided, must be one of "fill", "contain", or "cover".');
-      }
-      if (options.video?.width !== void 0 && options.video.height !== void 0 && options.video.fit === void 0) {
-        throw new TypeError(
-          "When both options.video.width and options.video.height are provided, options.video.fit must also be provided."
-        );
-      }
-      if (options.video?.rotate !== void 0 && ![0, 90, 180, 270].includes(options.video.rotate)) {
-        throw new TypeError("options.video.rotate, when provided, must be 0, 90, 180 or 270.");
-      }
-      if (options.video?.frameRate !== void 0 && (!Number.isFinite(options.video.frameRate) || options.video.frameRate <= 0)) {
-        throw new TypeError("options.video.frameRate, when provided, must be a finite positive number.");
-      }
-      if (options.audio !== void 0 && (!options.audio || typeof options.audio !== "object")) {
-        throw new TypeError("options.audio, when provided, must be an object.");
-      }
-      if (options.audio?.discard !== void 0 && typeof options.audio.discard !== "boolean") {
-        throw new TypeError("options.audio.discard, when provided, must be a boolean.");
-      }
-      if (options.audio?.forceTranscode !== void 0 && typeof options.audio.forceTranscode !== "boolean") {
-        throw new TypeError("options.audio.forceTranscode, when provided, must be a boolean.");
-      }
-      if (options.audio?.codec !== void 0 && !AUDIO_CODECS.includes(options.audio.codec)) {
-        throw new TypeError(
-          `options.audio.codec, when provided, must be one of: ${AUDIO_CODECS.join(", ")}.`
-        );
-      }
-      if (options.audio?.bitrate !== void 0 && !(options.audio.bitrate instanceof Quality) && (!Number.isInteger(options.audio.bitrate) || options.audio.bitrate <= 0)) {
-        throw new TypeError("options.audio.bitrate, when provided, must be a positive integer or a quality.");
-      }
-      if (options.audio?.numberOfChannels !== void 0 && (!Number.isInteger(options.audio.numberOfChannels) || options.audio.numberOfChannels <= 0)) {
-        throw new TypeError("options.audio.numberOfChannels, when provided, must be a positive integer.");
+      if (typeof options.video !== "function") {
+        validateVideoOptions(options.video);
+      } else {
       }
-      if (options.audio?.sampleRate !== void 0 && (!Number.isInteger(options.audio.sampleRate) || options.audio.sampleRate <= 0)) {
-        throw new TypeError("options.audio.sampleRate, when provided, must be a positive integer.");
+      if (typeof options.audio !== "function") {
+        validateAudioOptions(options.audio);
+      } else {
       }
       if (options.trim !== void 0 && (!options.trim || typeof options.trim !== "object")) {
         throw new TypeError("options.trim, when provided, must be an object.");
@@ -17000,15 +17075,34 @@ ${cue.notes ?? ""}`;
     async _init() {
       const inputTracks = await this.input.getTracks();
       const outputTrackCounts = this.output.format.getSupportedTrackCounts();
+      let nVideo = 1;
+      let nAudio = 1;
       for (const track of inputTracks) {
-        if (track.isVideoTrack() && this._options.video?.discard) {
-          this.discardedTracks.push({
-            track,
-            reason: "discarded_by_user"
-          });
-          continue;
+        let trackOptions = void 0;
+        if (track.isVideoTrack()) {
+          if (this._options.video) {
+            if (typeof this._options.video === "function") {
+              trackOptions = await this._options.video(track, nVideo);
+              validateVideoOptions(trackOptions);
+              nVideo++;
+            } else {
+              trackOptions = this._options.video;
+            }
+          }
+        } else if (track.isAudioTrack()) {
+          if (this._options.audio) {
+            if (typeof this._options.audio === "function") {
+              trackOptions = await this._options.audio(track, nAudio);
+              validateAudioOptions(trackOptions);
+              nAudio++;
+            } else {
+              trackOptions = this._options.audio;
+            }
+          }
+        } else {
+          assert(false);
         }
-        if (track.isAudioTrack() && this._options.audio?.discard) {
+        if (trackOptions?.discard) {
           this.discardedTracks.push({
             track,
             reason: "discarded_by_user"
@@ -17030,9 +17124,9 @@ ${cue.notes ?? ""}`;
           continue;
         }
         if (track.isVideoTrack()) {
-          await this._processVideoTrack(track);
+          await this._processVideoTrack(track, trackOptions ?? {});
         } else if (track.isAudioTrack()) {
-          await this._processAudioTrack(track);
+          await this._processAudioTrack(track, trackOptions ?? {});
         }
       }
       const unintentionallyDiscardedTracks = this.discardedTracks.filter((x) => x.reason !== "discarded_by_user");
@@ -17086,7 +17180,7 @@ ${cue.notes ?? ""}`;
       await this.output.cancel();
     }
     /** @internal */
-    async _processVideoTrack(track) {
+    async _processVideoTrack(track, trackOptions) {
       const sourceCodec = track.codec;
       if (!sourceCodec) {
         this.discardedTracks.push({
@@ -17096,28 +17190,28 @@ ${cue.notes ?? ""}`;
         return;
       }
       let videoSource;
-      const totalRotation = normalizeRotation(track.rotation + (this._options.video?.rotate ?? 0));
+      const totalRotation = normalizeRotation(track.rotation + (trackOptions.rotate ?? 0));
       const outputSupportsRotation = this.output.format.supportsVideoRotationMetadata;
       const [originalWidth, originalHeight] = totalRotation % 180 === 0 ? [track.codedWidth, track.codedHeight] : [track.codedHeight, track.codedWidth];
       let width = originalWidth;
       let height = originalHeight;
       const aspectRatio = width / height;
       const ceilToMultipleOfTwo = (value) => Math.ceil(value / 2) * 2;
-      if (this._options.video?.width !== void 0 && this._options.video.height === void 0) {
-        width = ceilToMultipleOfTwo(this._options.video.width);
+      if (trackOptions.width !== void 0 && trackOptions.height === void 0) {
+        width = ceilToMultipleOfTwo(trackOptions.width);
         height = ceilToMultipleOfTwo(Math.round(width / aspectRatio));
-      } else if (this._options.video?.width === void 0 && this._options.video?.height !== void 0) {
-        height = ceilToMultipleOfTwo(this._options.video.height);
+      } else if (trackOptions.width === void 0 && trackOptions.height !== void 0) {
+        height = ceilToMultipleOfTwo(trackOptions.height);
         width = ceilToMultipleOfTwo(Math.round(height * aspectRatio));
-      } else if (this._options.video?.width !== void 0 && this._options.video.height !== void 0) {
-        width = ceilToMultipleOfTwo(this._options.video.width);
-        height = ceilToMultipleOfTwo(this._options.video.height);
+      } else if (trackOptions.width !== void 0 && trackOptions.height !== void 0) {
+        width = ceilToMultipleOfTwo(trackOptions.width);
+        height = ceilToMultipleOfTwo(trackOptions.height);
       }
       const firstTimestamp = await track.getFirstTimestamp();
-      const needsTranscode = !!this._options.video?.forceTranscode || this._startTimestamp > 0 || firstTimestamp < 0 || !!this._options.video?.frameRate;
+      const needsTranscode = !!trackOptions.forceTranscode || this._startTimestamp > 0 || firstTimestamp < 0 || !!trackOptions.frameRate;
       const needsRerender = width !== originalWidth || height !== originalHeight || totalRotation !== 0 && !outputSupportsRotation;
       let videoCodecs = this.output.format.getSupportedVideoCodecs();
-      if (!needsTranscode && !this._options.video?.bitrate && !needsRerender && videoCodecs.includes(sourceCodec) && (!this._options.video?.codec || this._options.video?.codec === sourceCodec)) {
+      if (!needsTranscode && !trackOptions.bitrate && !needsRerender && videoCodecs.includes(sourceCodec) && (!trackOptions.codec || trackOptions.codec === sourceCodec)) {
         const source = new EncodedVideoPacketSource(sourceCodec);
         videoSource = source;
         this._trackPromises.push((async () => {
@@ -17148,10 +17242,10 @@ ${cue.notes ?? ""}`;
           });
           return;
         }
-        if (this._options.video?.codec) {
-          videoCodecs = videoCodecs.filter((codec) => codec === this._options.video?.codec);
+        if (trackOptions.codec) {
+          videoCodecs = videoCodecs.filter((codec) => codec === trackOptions.codec);
         }
-        const bitrate = this._options.video?.bitrate ?? QUALITY_HIGH;
+        const bitrate = trackOptions.bitrate ?? QUALITY_HIGH;
         const encodableCodec = await getFirstEncodableVideoCodec(videoCodecs, { width, height, bitrate });
         if (!encodableCodec) {
           this.discardedTracks.push({
@@ -17173,13 +17267,13 @@ ${cue.notes ?? ""}`;
             const sink = new CanvasSink(track, {
               width,
               height,
-              fit: this._options.video?.fit ?? "fill",
+              fit: trackOptions.fit ?? "fill",
               rotation: totalRotation,
               // Bake the rotation into the output
               poolSize: 1
             });
             const iterator = sink.canvases(this._startTimestamp, this._endTimestamp);
-            const frameRate = this._options.video?.frameRate;
+            const frameRate = trackOptions.frameRate;
             let lastCanvas = null;
             let lastCanvasTimestamp = null;
             let lastCanvasEndTimestamp = null;
@@ -17241,7 +17335,7 @@ ${cue.notes ?? ""}`;
           this._trackPromises.push((async () => {
             await this._started;
             const sink = new VideoSampleSink(track);
-            const frameRate = this._options.video?.frameRate;
+            const frameRate = trackOptions.frameRate;
             let lastSample = null;
             let lastSampleTimestamp = null;
             let lastSampleEndTimestamp = null;
@@ -17301,7 +17395,7 @@ ${cue.notes ?? ""}`;
         }
       }
       this.output.addVideoTrack(videoSource, {
-        frameRate: this._options.video?.frameRate,
+        frameRate: trackOptions.frameRate,
         languageCode: track.languageCode,
         rotation: needsRerender ? 0 : totalRotation
         // Rerendering will bake the rotation into the output
@@ -17311,7 +17405,7 @@ ${cue.notes ?? ""}`;
       this.utilizedTracks.push(track);
     }
     /** @internal */
-    async _processAudioTrack(track) {
+    async _processAudioTrack(track, trackOptions) {
       const sourceCodec = track.codec;
       if (!sourceCodec) {
         this.discardedTracks.push({
@@ -17324,11 +17418,11 @@ ${cue.notes ?? ""}`;
       const originalNumberOfChannels = track.numberOfChannels;
       const originalSampleRate = track.sampleRate;
       const firstTimestamp = await track.getFirstTimestamp();
-      let numberOfChannels = this._options.audio?.numberOfChannels ?? originalNumberOfChannels;
-      let sampleRate = this._options.audio?.sampleRate ?? originalSampleRate;
+      let numberOfChannels = trackOptions.numberOfChannels ?? originalNumberOfChannels;
+      let sampleRate = trackOptions.sampleRate ?? originalSampleRate;
       let needsResample = numberOfChannels !== originalNumberOfChannels || sampleRate !== originalSampleRate || this._startTimestamp > 0 || firstTimestamp < 0;
       let audioCodecs = this.output.format.getSupportedAudioCodecs();
-      if (!this._options.audio?.forceTranscode && !this._options.audio?.bitrate && !needsResample && audioCodecs.includes(sourceCodec) && (!this._options.audio?.codec || this._options.audio.codec === sourceCodec)) {
+      if (!trackOptions.forceTranscode && !trackOptions.bitrate && !needsResample && audioCodecs.includes(sourceCodec) && (!trackOptions.codec || trackOptions.codec === sourceCodec)) {
         const source = new EncodedAudioPacketSource(sourceCodec);
         audioSource = source;
         this._trackPromises.push((async () => {
@@ -17360,10 +17454,10 @@ ${cue.notes ?? ""}`;
           return;
         }
         let codecOfChoice = null;
-        if (this._options.audio?.codec) {
-          audioCodecs = audioCodecs.filter((codec) => codec === this._options.audio.codec);
+        if (trackOptions.codec) {
+          audioCodecs = audioCodecs.filter((codec) => codec === trackOptions.codec);
         }
-        const bitrate = this._options.audio?.bitrate ?? QUALITY_HIGH;
+        const bitrate = trackOptions.bitrate ?? QUALITY_HIGH;
         const encodableCodecs = await getEncodableAudioCodecs(audioCodecs, {
           numberOfChannels,
           sampleRate,