mediabunny 1.46.0 → 1.48.0

package/dist/bundles/mediabunny.cjs

@@ -6890,35 +6890,39 @@ var Mediabunny = (() => {
             this.readContiguousBoxes(slice.slice(contentStartPos, boxInfo.contentSize));
             if (this.currentTrack) {
               const trackData = this.currentFragment.trackData.get(this.currentTrack.id);
-              if (trackData) {
-                this.currentFragment.implicitBaseDataOffset = trackData.currentOffset;
-                trackData.presentationTimestamps = trackData.samples.map((x, i) => ({ presentationTimestamp: x.presentationTimestamp, sampleIndex: i })).sort((a, b) => a.presentationTimestamp - b.presentationTimestamp);
-                for (let i = 0; i < trackData.presentationTimestamps.length; i++) {
-                  const currentEntry = trackData.presentationTimestamps[i];
-                  const currentSample = trackData.samples[currentEntry.sampleIndex];
-                  if (trackData.firstKeyFrameTimestamp === null && currentSample.isKeyFrame) {
-                    trackData.firstKeyFrameTimestamp = currentSample.presentationTimestamp;
+              cond:
+                if (trackData) {
+                  if (trackData.samples.length === 0) {
+                    this.currentFragment.trackData.delete(this.currentTrack.id);
+                    break cond;
                   }
-                  if (i < trackData.presentationTimestamps.length - 1) {
-                    const nextEntry = trackData.presentationTimestamps[i + 1];
-                    const duration = nextEntry.presentationTimestamp - currentEntry.presentationTimestamp;
-                    currentSample.duration = duration;
+                  trackData.presentationTimestamps = trackData.samples.map((x, i) => ({ presentationTimestamp: x.presentationTimestamp, sampleIndex: i })).sort((a, b) => a.presentationTimestamp - b.presentationTimestamp);
+                  for (let i = 0; i < trackData.presentationTimestamps.length; i++) {
+                    const currentEntry = trackData.presentationTimestamps[i];
+                    const currentSample = trackData.samples[currentEntry.sampleIndex];
+                    if (trackData.firstKeyFrameTimestamp === null && currentSample.isKeyFrame) {
+                      trackData.firstKeyFrameTimestamp = currentSample.presentationTimestamp;
+                    }
+                    if (i < trackData.presentationTimestamps.length - 1) {
+                      const nextEntry = trackData.presentationTimestamps[i + 1];
+                      const duration = nextEntry.presentationTimestamp - currentEntry.presentationTimestamp;
+                      currentSample.duration = duration;
+                    }
+                  }
+                  const firstSample = trackData.samples[trackData.presentationTimestamps[0].sampleIndex];
+                  const lastSample = trackData.samples[last(trackData.presentationTimestamps).sampleIndex];
+                  trackData.startTimestamp = firstSample.presentationTimestamp;
+                  trackData.endTimestamp = lastSample.presentationTimestamp + lastSample.duration;
+                  const { currentFragmentState } = this.currentTrack;
+                  assert(currentFragmentState);
+                  if (currentFragmentState.startTimestamp !== null) {
+                    offsetFragmentTrackDataByTimestamp(trackData, currentFragmentState.startTimestamp);
+                    trackData.startTimestampIsFinal = true;
+                  }
+                  if (currentFragmentState.encryptionAuxInfo && !trackData.samples[0].encryption) {
+                    trackData.encryptionAuxInfo = currentFragmentState.encryptionAuxInfo;
                   }
                 }
-                const firstSample = trackData.samples[trackData.presentationTimestamps[0].sampleIndex];
-                const lastSample = trackData.samples[last(trackData.presentationTimestamps).sampleIndex];
-                trackData.startTimestamp = firstSample.presentationTimestamp;
-                trackData.endTimestamp = lastSample.presentationTimestamp + lastSample.duration;
-                const { currentFragmentState } = this.currentTrack;
-                assert(currentFragmentState);
-                if (currentFragmentState.startTimestamp !== null) {
-                  offsetFragmentTrackDataByTimestamp(trackData, currentFragmentState.startTimestamp);
-                  trackData.startTimestampIsFinal = true;
-                }
-                if (currentFragmentState.encryptionAuxInfo && !trackData.samples[0].encryption) {
-                  trackData.encryptionAuxInfo = currentFragmentState.encryptionAuxInfo;
-                }
-              }
               this.currentTrack.currentFragmentState = null;
               this.currentTrack = null;
             }
@@ -7051,10 +7055,6 @@ var Mediabunny = (() => {
               };
               this.currentFragment.trackData.set(track.id, trackData);
             }
-            if (sampleCount === 0) {
-              this.currentFragment.implicitBaseDataOffset = trackData.currentOffset;
-              break;
-            }
             for (let i = 0; i < sampleCount; i++) {
               let sampleDuration;
               if (sampleDurationPresent) {
@@ -7100,6 +7100,7 @@ var Mediabunny = (() => {
               trackData.currentOffset += sampleSize;
               trackData.currentTimestamp += sampleDuration;
             }
+            this.currentFragment.implicitBaseDataOffset = trackData.currentOffset;
           }
           ;
           break;
@@ -7577,6 +7578,9 @@ var Mediabunny = (() => {
     isRelativeToUnixEpoch() {
       return false;
     }
+    getUnixTimeForTimestamp() {
+      return null;
+    }
     getDisposition() {
       return this.internalTrack.disposition;
     }
@@ -10454,6 +10458,9 @@ var Mediabunny = (() => {
     isRelativeToUnixEpoch() {
       return false;
     }
+    getUnixTimeForTimestamp() {
+      return null;
+    }
     getDisposition() {
       return this.internalTrack.disposition;
     }
@@ -11074,6 +11081,9 @@ var Mediabunny = (() => {
     isRelativeToUnixEpoch() {
       return false;
     }
+    getUnixTimeForTimestamp() {
+      return null;
+    }
     getPairingMask() {
       return 1n;
     }
@@ -11642,6 +11652,9 @@ var Mediabunny = (() => {
     isRelativeToUnixEpoch() {
       return false;
     }
+    getUnixTimeForTimestamp() {
+      return null;
+    }
     getPairingMask() {
       return 1n;
     }
@@ -12414,6 +12427,9 @@ var Mediabunny = (() => {
     isRelativeToUnixEpoch() {
       return false;
     }
+    getUnixTimeForTimestamp() {
+      return null;
+    }
     getPairingMask() {
       return 1n;
     }
@@ -12712,6 +12728,9 @@ var Mediabunny = (() => {
     isRelativeToUnixEpoch() {
       return false;
     }
+    getUnixTimeForTimestamp() {
+      return null;
+    }
     getPairingMask() {
       return 1n;
     }
@@ -13332,6 +13351,9 @@ var Mediabunny = (() => {
     isRelativeToUnixEpoch() {
       return false;
     }
+    getUnixTimeForTimestamp() {
+      return null;
+    }
     getPairingMask() {
       return 1n;
     }
@@ -14200,6 +14222,9 @@ var Mediabunny = (() => {
     isRelativeToUnixEpoch() {
       return false;
     }
+    getUnixTimeForTimestamp() {
+      return null;
+    }
     getPairingMask() {
       return 1n;
     }
@@ -15238,6 +15263,15 @@ var Mediabunny = (() => {
       }
       return lastSegment.timestamp + lastSegment.duration;
     }
+    async getUnixTimeForTimestamp(timestamp) {
+      let segment = await this.getSegmentAt(timestamp, {});
+      segment ??= await this.getFirstSegment({});
+      if (!segment || segment.unixEpochTimestamp === null) {
+        return null;
+      }
+      const elapsed = timestamp - segment.timestamp;
+      return segment.unixEpochTimestamp + elapsed;
+    }
     async getTrackBackings() {
       return this.trackBackingsPromise ??= (async () => {
         const backings = [];
@@ -15395,7 +15429,10 @@ var Mediabunny = (() => {
     async isRelativeToUnixEpoch() {
       await this.hydrate();
       assert(this.segmentedInput.firstSegment);
-      return this.segmentedInput.firstSegment.relativeToUnixEpoch;
+      return this.segmentedInput.firstSegment.unixEpochTimestamp === this.segmentedInput.firstSegment.timestamp;
+    }
+    getUnixTimeForTimestamp(timestamp) {
+      return this.segmentedInput.getUnixTimeForTimestamp(timestamp);
     }
     getBitrate() {
       return this.delegate(() => this.firstInputTrack._backing.getBitrate());
@@ -15985,7 +16022,10 @@ var Mediabunny = (() => {
         throw new TypeError("options.fetchFn, when provided, must be a function.");
       }
       const urlString = url2 instanceof Request ? url2.url : url2 instanceof URL ? url2.href : url2;
-      super(urlString, (request) => new _UrlSource(request.path, this._options));
+      super(
+        urlString,
+        (request) => new _UrlSource(request.path, this._options)
+      );
       /** @internal */
       this._offset = 0;
       /** @internal */
@@ -16090,6 +16130,9 @@ var Mediabunny = (() => {
         if (!response.ok) {
           throw new Error(`Error fetching ${String(this._url)}: ${response.status} ${response.statusText}`);
         }
+        if (response.redirected) {
+          this.rootPath = response.url;
+        }
         outer:
           if (this._orchestrator.fileSize === null) {
             const contentRange = response.headers.get("Content-Range");
@@ -16750,6 +16793,12 @@ var Mediabunny = (() => {
           offset: innerStart
         });
       } else {
+        promise.catch((error) => {
+          if (this.disposed) {
+            return;
+          }
+          throw error;
+        });
       }
       return result;
     }
@@ -16834,11 +16883,11 @@ var Mediabunny = (() => {
         if (worker.pendingSlices.length > 0) {
           worker.pendingSlices.forEach((x) => x.reject(error));
           worker.pendingSlices.length = 0;
-        } else {
+        } else if (!worker.aborted && !this.disposed) {
           throw error;
         }
       }).finally(() => {
-        if (worker.running) {
+        if (worker.running || this.workers.length >= this.options.maxWorkerCount) {
           return;
         }
         if (this.queuedReads.length > 0) {
@@ -17151,6 +17200,7 @@ var Mediabunny = (() => {
       this.streamHasEnded = false;
       this.lastSegmentUpdateTime = -Infinity;
       this.refreshInterval = 5;
+      this.rootPath = path;
       this.demuxer = demuxer;
       this.nextLines = lines;
     }
@@ -17186,19 +17236,24 @@ var Mediabunny = (() => {
       if (!lines) {
         var _stack = [];
         try {
-          const ref = __using(_stack, await this.demuxer.input._getSourceUncached({ path: this.path, isRoot: false }));
+          const ref = __using(_stack, await this.demuxer.input._getSourceUncached({ path: this.rootPath, isRoot: false }));
           const reader = new Reader12(ref.source);
           const slice = await reader.requestEntireFile();
           assert(slice);
           lines = readAllLines(slice, slice.length, { ignore: canIgnoreLine });
+          if (ref.source instanceof PathedSource) {
+            this.rootPath = ref.source.rootPath;
+          }
         } catch (_) {
           var _error = _, _hasError = true;
         } finally {
           __callDispose(_stack, _error, _hasError);
         }
       }
+      const offsetTimestampsByDateTime = this.input._formatOptions.hls?.offsetTimestampsByDateTime !== false;
       let headerRead = false;
       let accumulatedTime = 0;
+      let accumulatedUnixTime = null;
       let nextSegmentDuration = null;
       let currentKey = null;
       let nextSequenceNumber = 0;
@@ -17234,6 +17289,7 @@ var Mediabunny = (() => {
             currentFirstSegment = prevLastSegment.firstSegment;
             currentInitSegment = prevLastSegment.initSegment;
             lastProgramDateTimeSeconds = prevLastSegment.lastProgramDateTimeSeconds;
+            accumulatedUnixTime = prevLastSegment.unixEpochTimestamp !== null ? prevLastSegment.unixEpochTimestamp + prevLastSegment.duration : null;
             prevLastSegment = null;
           }
         }
@@ -17260,7 +17316,7 @@ var Mediabunny = (() => {
               view2.setUint32(12, nextSequenceNumber);
               key = { ...key, iv };
             }
-            const fullPath = joinPaths(this.path, line);
+            const fullPath = joinPaths(this.rootPath, line);
             const location = {
               path: fullPath,
               offset: nextByteRange?.offset ?? 0,
@@ -17268,7 +17324,7 @@ var Mediabunny = (() => {
             };
             const segment = {
               timestamp: accumulatedTime,
-              relativeToUnixEpoch: lastProgramDateTimeSeconds !== null,
+              unixEpochTimestamp: accumulatedUnixTime,
               firstSegment: currentFirstSegment,
               sequenceNumber: nextSequenceNumber,
               location,
@@ -17279,6 +17335,9 @@ var Mediabunny = (() => {
             };
             currentFirstSegment ??= segment;
             accumulatedTime += nextSegmentDuration;
+            if (accumulatedUnixTime !== null) {
+              accumulatedUnixTime += nextSegmentDuration;
+            }
             this.segments.push(segment);
           } else {
           }
@@ -17324,7 +17383,7 @@ var Mediabunny = (() => {
             throw new Error("Invalid #EXT-X-MAP tag; BYTERANGE attribute must have a specified offset.");
           }
           if (!prevLastSegment) {
-            const fullPath = joinPaths(this.path, uri);
+            const fullPath = joinPaths(this.rootPath, uri);
             const location = {
               path: fullPath,
               offset: parsedByteRange?.offset ?? 0,
@@ -17335,7 +17394,7 @@ var Mediabunny = (() => {
             }
             const segment = {
               timestamp: accumulatedTime,
-              relativeToUnixEpoch: lastProgramDateTimeSeconds !== null,
+              unixEpochTimestamp: accumulatedUnixTime,
               firstSegment: null,
               sequenceNumber: null,
               location,
@@ -17385,7 +17444,7 @@ var Mediabunny = (() => {
             }
             currentKey = {
               method: "AES-128",
-              keyUri: joinPaths(this.path, uri),
+              keyUri: joinPaths(this.rootPath, uri),
               iv,
               keyFormat
             };
@@ -17455,13 +17514,17 @@ var Mediabunny = (() => {
             const lastSegmentEnd = lastSegment.timestamp + lastSegment.duration;
             const offset = dateTimeSeconds - lastSegmentEnd;
             for (const segment of this.segments) {
-              segment.timestamp += offset;
-              segment.relativeToUnixEpoch = true;
+              segment.unixEpochTimestamp = segment.timestamp + offset;
+              if (offsetTimestampsByDateTime) {
+                segment.timestamp = segment.unixEpochTimestamp;
+              }
             }
-            accumulatedTime += offset;
           }
           lastProgramDateTimeSeconds = dateTimeSeconds;
-          accumulatedTime = dateTimeSeconds;
+          accumulatedUnixTime = dateTimeSeconds;
+          if (offsetTimestampsByDateTime) {
+            accumulatedTime = dateTimeSeconds;
+          }
         } else if (line === TAG_DISCONTINUITY) {
           currentFirstSegment = null;
         } else if (line.startsWith(TAG_TARGETDURATION)) {
@@ -17678,10 +17741,10 @@ var Mediabunny = (() => {
     readMetadata() {
       return this.metadataPromise ??= (async () => {
         assert(this.input._rootSource instanceof PathedSource);
-        const { rootPath } = this.input._rootSource;
         const slice = await this.input._reader.requestEntireFile();
         assert(slice);
         const lines = readAllLines(slice, slice.length, { ignore: canIgnoreLine });
+        const { rootPath } = this.input._rootSource;
         const variantStreams = [];
         const mediaTags = [];
         for (let i = 1; i < lines.length; i++) {
@@ -18196,6 +18259,9 @@ var Mediabunny = (() => {
     isRelativeToUnixEpoch() {
       return this.delegate(() => this.internalTrack.backingTrack.isRelativeToUnixEpoch());
     }
+    getUnixTimeForTimestamp(timestamp) {
+      return this.delegate(() => this.internalTrack.backingTrack.getUnixTimeForTimestamp(timestamp));
+    }
     getBitrate() {
       return this.internalTrack.peakBitrate;
     }
@@ -18784,6 +18850,14 @@ var Mediabunny = (() => {
         throw new TypeError(`${prefix}.isobmff.resolveKeyId, when provided, must be a function.`);
       }
     }
+    if (options.hls !== void 0) {
+      if (!options.hls || typeof options.hls !== "object") {
+        throw new TypeError(`${prefix}.hls, when provided, must be an object.`);
+      }
+      if (options.hls.offsetTimestampsByDateTime !== void 0 && typeof options.hls.offsetTimestampsByDateTime !== "boolean") {
+        throw new TypeError(`${prefix}.hls.offsetTimestampsByDateTime, when provided, must be a boolean.`);
+      }
+    }
   };
 
   // src/decode.ts
@@ -20577,6 +20651,65 @@ var Mediabunny = (() => {
         });
       }
     }
+    /**
+     * Returns a new {@link AudioSample} containing only the frames in the range [startSample, endSample). Both bounds
+     * must lie within this sample's range of frames. The returned sample's timestamp is shifted to match the start of
+     * the trimmed section.
+     */
+    trim(startSample, endSample = this.numberOfFrames) {
+      if (!Number.isInteger(startSample) || startSample < 0) {
+        throw new TypeError("startSample must be a non-negative integer.");
+      }
+      if (!Number.isInteger(endSample) || endSample < 0) {
+        throw new TypeError("endSample must be a non-negative integer.");
+      }
+      if (startSample > this.numberOfFrames) {
+        throw new RangeError("startSample out of range.");
+      }
+      if (endSample > this.numberOfFrames) {
+        throw new RangeError("endSample out of range.");
+      }
+      if (endSample < startSample) {
+        throw new RangeError("endSample must not be less than startSample.");
+      }
+      if (this._closed) {
+        throw new Error("AudioSample is closed.");
+      }
+      const frameCount = endSample - startSample;
+      const bytesPerSample = getBytesPerSample(this.format);
+      let data;
+      if (formatIsPlanar(this.format)) {
+        const planeSize = frameCount * bytesPerSample;
+        data = new Uint8Array(planeSize * this.numberOfChannels);
+        if (frameCount > 0) {
+          for (let i = 0; i < this.numberOfChannels; i++) {
+            this.copyTo(data.subarray(i * planeSize, (i + 1) * planeSize), {
+              planeIndex: i,
+              format: this.format,
+              frameOffset: startSample,
+              frameCount
+            });
+          }
+        }
+      } else {
+        data = new Uint8Array(frameCount * this.numberOfChannels * bytesPerSample);
+        if (frameCount > 0) {
+          this.copyTo(data, {
+            planeIndex: 0,
+            format: this.format,
+            frameOffset: startSample,
+            frameCount
+          });
+        }
+      }
+      return new _AudioSample({
+        data,
+        format: this.format,
+        sampleRate: this.sampleRate,
+        numberOfChannels: this.numberOfChannels,
+        timestamp: this.timestamp + startSample / this.sampleRate
+      });
+    }
     /**
      * Closes this audio sample, releasing held resources. Audio samples should be closed as soon as they are not
      * needed anymore.
@@ -20995,6 +21128,9 @@ var Mediabunny = (() => {
     if (config.onEncoderConfig !== void 0 && typeof config.onEncoderConfig !== "function") {
       throw new TypeError("config.onEncoderConfig, when provided, must be a function.");
     }
+    if (config.onEncodedSample !== void 0 && typeof config.onEncodedSample !== "function") {
+      throw new TypeError("config.onEncodedSample, when provided, must be a function.");
+    }
     validateVideoEncodingAdditionalOptions(config.codec, config);
   };
   var validateVideoEncodingAdditionalOptions = (codec, options) => {
@@ -21090,6 +21226,9 @@ var Mediabunny = (() => {
     if (config.onEncoderConfig !== void 0 && typeof config.onEncoderConfig !== "function") {
       throw new TypeError("config.onEncoderConfig, when provided, must be a function.");
     }
+    if (config.onEncodedSample !== void 0 && typeof config.onEncodedSample !== "function") {
+      throw new TypeError("config.onEncodedSample, when provided, must be a function.");
+    }
     validateAudioEncodingAdditionalOptions(config.codec, config);
   };
   var validateAudioEncodingAdditionalOptions = (codec, options) => {
@@ -22779,14 +22918,29 @@ var Mediabunny = (() => {
       }
     };
   };
+  var validateVideoSinkDecoderOptions = (decoderOptions) => {
+    if (!decoderOptions || typeof decoderOptions !== "object") {
+      throw new TypeError("decoderOptions must be an object.");
+    }
+    if (decoderOptions.hardwareAcceleration !== void 0 && !["no-preference", "prefer-hardware", "prefer-software"].includes(decoderOptions.hardwareAcceleration)) {
+      throw new TypeError(
+        "decoderOptions.hardwareAcceleration, when provided, must be 'no-preference', 'prefer-hardware' or 'prefer-software'."
+      );
+    }
+    if (decoderOptions.optimizeForLatency !== void 0 && typeof decoderOptions.optimizeForLatency !== "boolean") {
+      throw new TypeError("decoderOptions.optimizeForLatency, when provided, must be a boolean.");
+    }
+  };
   var VideoSampleSink = class extends BaseMediaSampleSink {
     /** Creates a new {@link VideoSampleSink} for the given {@link InputVideoTrack}. */
-    constructor(videoTrack) {
+    constructor(videoTrack, decoderOptions = {}) {
       if (!(videoTrack instanceof InputVideoTrack)) {
         throw new TypeError("videoTrack must be an InputVideoTrack.");
       }
+      validateVideoSinkDecoderOptions(decoderOptions);
       super();
       this._track = videoTrack;
+      this._decoderOptions = decoderOptions;
     }
     /** @internal */
     async _createDecoder(onSample, onError) {
@@ -22797,9 +22951,14 @@ var Mediabunny = (() => {
       }
       const codec = await this._track.getCodec();
       const rotation = await this._track.getRotation();
-      const decoderConfig = await this._track.getDecoderConfig();
+      let decoderConfig = await this._track.getDecoderConfig();
       const timeResolution = await this._track.getTimeResolution();
       assert(codec && decoderConfig);
+      decoderConfig = {
+        ...decoderConfig,
+        hardwareAcceleration: this._decoderOptions.hardwareAcceleration,
+        optimizeForLatency: this._decoderOptions.optimizeForLatency
+      };
       return new VideoDecoderWrapper(onSample, onError, codec, decoderConfig, rotation, timeResolution);
     }
     /** @internal */
@@ -22889,11 +23048,14 @@ var Mediabunny = (() => {
       if (options.poolSize !== void 0 && (typeof options.poolSize !== "number" || !Number.isInteger(options.poolSize) || options.poolSize < 0)) {
         throw new TypeError("poolSize must be a non-negative integer.");
       }
+      if (options.decoderOptions !== void 0) {
+        validateVideoSinkDecoderOptions(options.decoderOptions);
+      }
       this._videoTrack = videoTrack;
       this._alpha = options.alpha ?? false;
       this._options = options;
       this._fit = options.fit ?? "fill";
-      this._videoSampleSink = new VideoSampleSink(videoTrack);
+      this._videoSampleSink = new VideoSampleSink(videoTrack, options.decoderOptions);
       this._canvasPool = Array.from({ length: options.poolSize ?? 0 }, () => null);
     }
     /** @internal */
@@ -23536,6 +23698,26 @@ var Mediabunny = (() => {
     async isRelativeToUnixEpoch() {
       return this._backing.isRelativeToUnixEpoch();
     }
+    /**
+     * Returns the Unix time (in seconds since January 1, 1970 00:00:00 UTC) that the given track timestamp (in seconds)
+     * maps to, or `null` if there is no such mapping. This provides a piecewise-continuous mapping from this track's
+     * timestamp space into wall-clock time. Such mapping exists, for example, for HLS playlists with
+     * `#EXT-X-PROGRAM-DATE-TIME` tags present.
+     *
+     * This mapping can be available even when {@link InputTrack.isRelativeToUnixEpoch} is `false`, for example for HLS
+     * streams with program date time information but with {@link HlsInputFormatOptions.offsetTimestampsByDateTime}
+     * set to `false`.
+     */
+    async getUnixTimeForTimestamp(timestamp) {
+      return this._backing.getUnixTimeForTimestamp(timestamp);
+    }
+    /**
+     * Whether the track's timestamps can be mapped to Unix wall clock time via
+     * {@link InputTrack.getUnixTimeForTimestamp}.
+     */
+    async hasUnixTimeMapping() {
+      return await this._backing.getUnixTimeForTimestamp(await this.getFirstTimestamp()) !== null;
+    }
     /** Returns the track's disposition, i.e. information about its intended usage. */
     async getDisposition() {
       return this._backing.getDisposition();
@@ -24537,7 +24719,10 @@ var Mediabunny = (() => {
         ref.free();
       }
       this._sourceRefs.length = 0;
-      void this._demuxerPromise?.then((demuxer) => demuxer.dispose());
+      if (this._demuxerPromise) {
+        void this._demuxerPromise.then((demuxer) => demuxer.dispose()).catch(() => {
+        });
+      }
     }
     /**
      * Calls `.dispose()` on the input, implementing the `Disposable` interface for use with
@@ -31990,17 +32175,17 @@ ${cue.notes ?? ""}`;
     constructor(options) {
       this.sourceSampleRate = null;
       this.sourceNumberOfChannels = null;
+      this.startTime = null;
+      /** Start frame of current buffer */
+      this.bufferStartFrame = 0;
       /** The highest index written to in the current buffer */
       this.maxWrittenFrame = null;
       this.targetSampleRate = options.targetSampleRate;
       this.targetNumberOfChannels = options.targetNumberOfChannels;
-      this.endTime = options.endTime;
       this.onSample = options.onSample;
       this.bufferSizeInFrames = Math.floor(this.targetSampleRate * 5);
       this.bufferSizeInSamples = this.bufferSizeInFrames * this.targetNumberOfChannels;
       this.outputBuffer = new Float32Array(this.bufferSizeInSamples);
-      this.bufferStartFrame = Math.floor(options.startTime * this.targetSampleRate);
-      this.timestampOffset = options.startTime - this.bufferStartFrame / this.targetSampleRate;
     }
     /**
      * Sets up the channel mixer to handle up/downmixing in the case where input and output channel counts don't match.
@@ -32090,16 +32275,18 @@ ${cue.notes ?? ""}`;
       if (this.sourceSampleRate === null) {
         this.sourceSampleRate = audioSample.sampleRate;
         this.sourceNumberOfChannels = audioSample.numberOfChannels;
+        this.startTime = audioSample.timestamp;
         this.tempSourceBuffer = new Float32Array(this.sourceSampleRate * this.sourceNumberOfChannels);
         this.doChannelMixerSetup();
       }
+      assert(this.startTime !== null);
       const requiredSamples = audioSample.numberOfFrames * audioSample.numberOfChannels;
       this.ensureTempBufferSize(requiredSamples);
       const sourceDataSize = audioSample.allocationSize({ planeIndex: 0, format: "f32" });
       const sourceView = new Float32Array(this.tempSourceBuffer.buffer, 0, sourceDataSize / 4);
       audioSample.copyTo(sourceView, { planeIndex: 0, format: "f32" });
-      const inputStartTime = audioSample.timestamp;
-      const inputEndTime = Math.min(audioSample.timestamp + audioSample.duration, this.endTime);
+      const inputStartTime = audioSample.timestamp - this.startTime;
+      const inputEndTime = inputStartTime + audioSample.duration;
       const outputStartFrame = Math.floor(inputStartTime * this.targetSampleRate);
       const outputEndFrame = Math.ceil(inputEndTime * this.targetSampleRate);
       for (let outputFrame = outputStartFrame; outputFrame < outputEndFrame; outputFrame++) {
@@ -32142,15 +32329,15 @@ ${cue.notes ?? ""}`;
       if (this.maxWrittenFrame === null) {
         return;
       }
+      assert(this.startTime !== null);
       const samplesWritten = (this.maxWrittenFrame + 1) * this.targetNumberOfChannels;
       const outputData = new Float32Array(samplesWritten);
       outputData.set(this.outputBuffer.subarray(0, samplesWritten));
-      const timestampSeconds = this.bufferStartFrame / this.targetSampleRate;
       const audioSample = new AudioSample({
         format: "f32",
         sampleRate: this.targetSampleRate,
         numberOfChannels: this.targetNumberOfChannels,
-        timestamp: timestampSeconds + this.timestampOffset,
+        timestamp: this.startTime + this.bufferStartFrame / this.targetSampleRate,
         data: outputData
       });
       await this.onSample(audioSample);
@@ -32314,6 +32501,7 @@ ${cue.notes ?? ""}`;
        * So, we keep track of the encoder error and throw it as soon as we get the chance.
        */
       this.error = null;
+      this.closed = false;
       this.lastMuxerPromise = Promise.resolve();
     }
     async add(videoSample, shouldClose, encodeOptions) {
@@ -32450,6 +32638,9 @@ ${cue.notes ?? ""}`;
             }
           }
           assert(this.encoderInitialized);
+          if (this.closed) {
+            break;
+          }
           const keyFrameInterval = this.encodingConfig.keyFrameInterval ?? 2;
           const multipleOfKeyFrameInterval = Math.floor(sampleToEncode.timestamp / keyFrameInterval);
           const mergedEncodeOptions = { ...sampleToEncode.encodeOptions, ...encodeOptions };
@@ -32458,6 +32649,7 @@ ${cue.notes ?? ""}`;
             keyFrame: mergedEncodeOptions.keyFrame !== void 0 ? mergedEncodeOptions.keyFrame : keyFrameInterval === 0 || multipleOfKeyFrameInterval !== this.lastMultipleOfKeyFrameInterval
           };
           this.lastMultipleOfKeyFrameInterval = multipleOfKeyFrameInterval;
+          this.encodingConfig.onEncodedSample?.(sampleToEncode);
           if (this.customEncoder) {
             this.customEncoderQueueSize++;
             const clonedSample = sampleToEncode.clone();
@@ -32712,6 +32904,7 @@ ${cue.notes ?? ""}`;
         const alignedEnd = floorToDivisor(this.frameRateLastEndTimestamp, frameRate);
         await this.padFrameRate(alignedEnd);
       }
+      this.closed = true;
       this.frameRateLastSample?.close();
       this.frameRateLastSample = null;
       if (this.customEncoder) {
@@ -33585,6 +33778,7 @@ ${cue.notes ?? ""}`;
        */
       this.error = null;
       this.lastMuxerPromise = Promise.resolve();
+      this.closed = false;
     }
     async add(audioSample, shouldClose) {
       try {
@@ -33607,8 +33801,6 @@ ${cue.notes ?? ""}`;
             this.resampler = new AudioResampler({
               targetNumberOfChannels: config.transform.numberOfChannels ?? audioSample.numberOfChannels,
               targetSampleRate: config.transform.sampleRate ?? audioSample.sampleRate,
-              startTime: audioSample.timestamp,
-              endTime: Infinity,
               onSample: async (sample) => {
                 await this.processAndEncode(sample, true);
               }
@@ -33677,6 +33869,9 @@ ${cue.notes ?? ""}`;
           }
         }
         assert(this.encoderInitialized);
+        if (this.closed) {
+          return;
+        }
         {
           const startSampleIndex = Math.round(
             audioSample.timestamp * audioSample.sampleRate
@@ -33702,6 +33897,7 @@ ${cue.notes ?? ""}`;
             this.lastEndSampleIndex += audioSample.numberOfFrames;
           }
         }
+        this.encodingConfig.onEncodedSample?.(audioSample);
         if (this.customEncoder) {
           this.customEncoderQueueSize++;
           const clonedSample = audioSample.clone();
@@ -33974,6 +34170,7 @@ ${cue.notes ?? ""}`;
         await this.resampler.finalize();
       }
       this.resampler = null;
+      this.closed = true;
       if (this.customEncoder) {
         if (!forceClose) {
           void this.customEncoderCallSerializer.call(() => this.customEncoder.flush());
@@ -37336,6 +37533,9 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         if (trackOptions.frameRate) {
           encodingConfig.transform.frameRate = trackOptions.frameRate;
         }
+        if (trackOptions.process) {
+          encodingConfig.transform.process = trackOptions.process;
+        }
         if (needsRerender) {
           outputTrackRotation = 0;
           encodingConfig.transform.width = width;
@@ -37345,6 +37545,10 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
           encodingConfig.transform.crop = crop;
           encodingConfig.transform.alpha = alpha;
         }
+        let lastSampleTimestamp = null;
+        encodingConfig.onEncodedSample = (sample) => {
+          lastSampleTimestamp = sample.timestamp;
+        };
         const source = new VideoSampleSource(encodingConfig);
         videoSource = source;
         this._trackPromises.push((async () => {
@@ -37357,7 +37561,13 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
             }
             const adjustedSampleTimestamp = Math.max(sample.timestamp - this._startTimestamp, 0);
             sample.setTimestamp(adjustedSampleTimestamp);
-            await this._registerVideoSample(trackOptions, outputTrackId, source, sample);
+            this._reportProgress(outputTrackId, sample.timestamp + sample.duration);
+            await source.add(sample);
+            if (lastSampleTimestamp !== null) {
+              if (this._synchronizer.shouldWait(outputTrackId, lastSampleTimestamp)) {
+                await this._synchronizer.wait(lastSampleTimestamp);
+              }
+            }
             sample.close();
           }
           source.close();
@@ -37385,52 +37595,6 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       this._outputOwnTrackGroups.push(ownGroup);
     }
     /** @internal */
-    async _registerVideoSample(trackOptions, outputTrackId, source, sample) {
-      if (this._canceled) {
-        return;
-      }
-      this._reportProgress(outputTrackId, sample.timestamp + sample.duration);
-      let finalSamples;
-      if (!trackOptions.process) {
-        finalSamples = [sample];
-      } else {
-        let processed = trackOptions.process(sample);
-        if (processed instanceof Promise) processed = await processed;
-        if (!Array.isArray(processed)) {
-          processed = processed === null ? [] : [processed];
-        }
-        finalSamples = processed.map((x) => {
-          if (x instanceof VideoSample) {
-            return x;
-          }
-          if (typeof VideoFrame !== "undefined" && x instanceof VideoFrame) {
-            return new VideoSample(x);
-          }
-          return new VideoSample(x, {
-            timestamp: sample.timestamp,
-            duration: sample.duration
-          });
-        });
-      }
-      try {
-        for (const finalSample of finalSamples) {
-          if (this._canceled) {
-            break;
-          }
-          await source.add(finalSample);
-          if (this._synchronizer.shouldWait(outputTrackId, finalSample.timestamp)) {
-            await this._synchronizer.wait(finalSample.timestamp);
-          }
-        }
-      } finally {
-        for (const finalSample of finalSamples) {
-          if (finalSample !== sample) {
-            finalSample.close();
-          }
-        }
-      }
-    }
-    /** @internal */
     async _processAudioTrack(track, trackOptions, outputTrackId) {
       const sourceCodec = await track.getCodec();
       if (!sourceCodec) {
@@ -37447,9 +37611,10 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       const firstTimestamp = await track.getFirstTimestamp();
       let numberOfChannels = trackOptions.numberOfChannels ?? originalNumberOfChannels;
       let sampleRate = trackOptions.sampleRate ?? originalSampleRate;
-      let needsResample = numberOfChannels !== originalNumberOfChannels || sampleRate !== originalSampleRate || firstTimestamp < this._startTimestamp || firstTimestamp > this._startTimestamp && !this.output.format.supportsTimestampedMediaData;
+      const needsTrimming = firstTimestamp < this._startTimestamp;
+      const needsPadding = firstTimestamp > this._startTimestamp && !this.output.format.supportsTimestampedMediaData;
       let audioCodecs = this.output.format.getSupportedAudioCodecs();
-      if (!trackOptions.forceTranscode && !trackOptions.bitrate && !needsResample && audioCodecs.includes(sourceCodec) && (!trackOptions.codec || trackOptions.codec === sourceCodec) && !trackOptions.process && trackOptions.sampleFormat === void 0) {
+      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) {
         const source = new EncodedAudioPacketSource(sourceCodec);
         audioSource = source;
         this._trackPromises.push((async () => {
@@ -37505,7 +37670,6 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
           });
           const nonPcmCodec = encodableCodecsWithDefaultParams.find((codec) => NON_PCM_AUDIO_CODECS.includes(codec));
           if (nonPcmCodec) {
-            needsResample = true;
             codecOfChoice = nonPcmCodec;
             numberOfChannels = FALLBACK_NUMBER_OF_CHANNELS;
             sampleRate = FALLBACK_SAMPLE_RATE;
@@ -37521,38 +37685,70 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
           });
           return;
         }
-        if (needsResample) {
-          audioSource = this._resampleAudio(
-            track,
-            trackOptions,
-            outputTrackId,
-            codecOfChoice,
-            numberOfChannels,
-            sampleRate,
-            bitrate
-          );
-        } else {
-          const source = new AudioSampleSource({
-            codec: codecOfChoice,
-            bitrate
-          });
-          audioSource = source;
-          this._trackPromises.push((async () => {
-            await this._started;
-            const sink = new AudioSampleSink(track);
-            for await (const sample of sink.samples(void 0, this._endTimestamp)) {
-              if (this._canceled) {
+        const encodingConfig = {
+          codec: codecOfChoice,
+          bitrate,
+          transform: {
+            sampleFormat: trackOptions.sampleFormat,
+            process: trackOptions.process
+          }
+        };
+        assert(encodingConfig.transform);
+        if (numberOfChannels !== originalNumberOfChannels) {
+          encodingConfig.transform.numberOfChannels = numberOfChannels;
+        }
+        if (sampleRate !== originalSampleRate) {
+          encodingConfig.transform.sampleRate = sampleRate;
+        }
+        let lastSampleTimestamp = null;
+        encodingConfig.onEncodedSample = (sample) => {
+          lastSampleTimestamp = sample.timestamp;
+        };
+        const source = new AudioSampleSource(encodingConfig);
+        audioSource = source;
+        this._trackPromises.push((async () => {
+          await this._started;
+          if (needsPadding) {
+            const paddingLength = firstTimestamp - this._startTimestamp;
+            const paddingLengthSamples = Math.round(paddingLength * originalSampleRate);
+            const silentSample = new AudioSample({
+              data: new Float32Array(paddingLengthSamples * originalNumberOfChannels),
+              format: "f32-planar",
+              numberOfChannels: originalNumberOfChannels,
+              sampleRate: originalSampleRate,
+              timestamp: 0
+            });
+            await this._registerAudioSample(silentSample, source, outputTrackId, () => lastSampleTimestamp);
+          }
+          const sink = new AudioSampleSink(track);
+          for await (let sample of sink.samples(this._startTimestamp, this._endTimestamp)) {
+            if (this._canceled) {
+              sample.close();
+              return;
+            }
+            let startFrame = 0;
+            let endFrame = sample.numberOfFrames;
+            if (sample.timestamp < this._startTimestamp) {
+              startFrame = Math.round((this._startTimestamp - sample.timestamp) * sample.sampleRate);
+            }
+            if (sample.timestamp + sample.duration > this._endTimestamp) {
+              endFrame = Math.round((this._endTimestamp - sample.timestamp) * sample.sampleRate);
+            }
+            if (startFrame > 0 || endFrame < sample.numberOfFrames) {
+              const trimmedSample = sample.trim(startFrame, endFrame);
+              sample.close();
+              sample = trimmedSample;
+              if (sample.numberOfFrames === 0) {
                 sample.close();
-                return;
+                continue;
               }
-              sample.setTimestamp(sample.timestamp - this._startTimestamp);
-              await this._registerAudioSample(trackOptions, outputTrackId, source, sample);
-              sample.close();
             }
-            source.close();
-            this._synchronizer.closeTrack(outputTrackId);
-          })());
-        }
+            sample.setTimestamp(sample.timestamp - this._startTimestamp);
+            await this._registerAudioSample(sample, source, outputTrackId, () => lastSampleTimestamp);
+          }
+          source.close();
+          this._synchronizer.closeTrack(outputTrackId);
+        })());
       }
       let ownGroup = null;
       if (!trackOptions.group) {
@@ -37573,89 +37769,18 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       this._outputOwnTrackGroups.push(ownGroup);
     }
     /** @internal */
-    async _registerAudioSample(trackOptions, outputTrackId, source, inputSample) {
-      if (this._canceled) {
-        return;
-      }
-      let sample = inputSample;
-      if (trackOptions.sampleFormat !== void 0 && toInterleavedAudioFormat(sample.format) !== trackOptions.sampleFormat) {
-        sample = audioSampleToInterleavedFormat(sample, trackOptions.sampleFormat);
-      }
+    async _registerAudioSample(sample, source, outputTrackId, getLastSampleTimestamp) {
       this._reportProgress(outputTrackId, sample.timestamp + sample.duration);
-      let finalSamples;
-      if (!trackOptions.process) {
-        finalSamples = [sample];
-      } else {
-        let processed = trackOptions.process(sample);
-        if (processed instanceof Promise) processed = await processed;
-        if (!Array.isArray(processed)) {
-          processed = processed === null ? [] : [processed];
-        }
-        if (!processed.every((x) => x instanceof AudioSample)) {
-          throw new TypeError(
-            "The audio process function must return an AudioSample, null, or an array of AudioSamples."
-          );
-        }
-        finalSamples = processed;
-      }
-      try {
-        for (const finalSample of finalSamples) {
-          if (this._canceled) {
-            break;
-          }
-          await source.add(finalSample);
-          if (this._synchronizer.shouldWait(outputTrackId, finalSample.timestamp)) {
-            await this._synchronizer.wait(finalSample.timestamp);
-          }
-        }
-      } finally {
-        if (sample !== inputSample) {
-          sample.close();
-        }
-        for (const finalSample of finalSamples) {
-          if (finalSample !== inputSample) {
-            finalSample.close();
-          }
+      await source.add(sample);
+      sample.close();
+      const lastSampleTimestamp = getLastSampleTimestamp();
+      if (lastSampleTimestamp !== null) {
+        if (this._synchronizer.shouldWait(outputTrackId, lastSampleTimestamp)) {
+          await this._synchronizer.wait(lastSampleTimestamp);
         }
       }
     }
     /** @internal */
-    _resampleAudio(track, trackOptions, outputTrackId, codec, targetNumberOfChannels, targetSampleRate, bitrate) {
-      const source = new AudioSampleSource({
-        codec,
-        bitrate
-      });
-      this._trackPromises.push((async () => {
-        await this._started;
-        const resampler = new AudioResampler({
-          targetNumberOfChannels,
-          targetSampleRate,
-          startTime: this._startTimestamp,
-          endTime: this._endTimestamp,
-          onSample: async (sample) => {
-            assert(sample.timestamp >= this._startTimestamp);
-            sample.setTimestamp(sample.timestamp - this._startTimestamp);
-            await this._registerAudioSample(trackOptions, outputTrackId, source, sample);
-            sample.close();
-          }
-        });
-        const sink = new AudioSampleSink(track);
-        const iterator = sink.samples(this._startTimestamp, this._endTimestamp);
-        for await (const sample of iterator) {
-          if (this._canceled) {
-            sample.close();
-            return;
-          }
-          await resampler.add(sample);
-          sample.close();
-        }
-        await resampler.finalize();
-        source.close();
-        this._synchronizer.closeTrack(outputTrackId);
-      })());
-      return source;
-    }
-    /** @internal */
     _reportProgress(trackId, endTimestamp) {
       if (!this._computeProgress) {
         return;