mediabunny 1.46.0 → 1.47.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;
@@ -20577,6 +20578,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 +21055,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 +21153,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) => {
@@ -24537,7 +24603,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 +32059,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 +32159,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 +32213,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 +32385,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 +32522,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 +32533,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 +32788,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 +33662,7 @@ ${cue.notes ?? ""}`;
        */
       this.error = null;
       this.lastMuxerPromise = Promise.resolve();
+      this.closed = false;
     }
     async add(audioSample, shouldClose) {
       try {
@@ -33607,8 +33685,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 +33753,9 @@ ${cue.notes ?? ""}`;
           }
         }
         assert(this.encoderInitialized);
+        if (this.closed) {
+          return;
+        }
         {
           const startSampleIndex = Math.round(
             audioSample.timestamp * audioSample.sampleRate
@@ -33702,6 +33781,7 @@ ${cue.notes ?? ""}`;
             this.lastEndSampleIndex += audioSample.numberOfFrames;
           }
         }
+        this.encodingConfig.onEncodedSample?.(audioSample);
         if (this.customEncoder) {
           this.customEncoderQueueSize++;
           const clonedSample = audioSample.clone();
@@ -33974,6 +34054,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 +37417,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 +37429,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 +37445,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 +37479,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 +37495,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 +37554,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 +37569,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 +37653,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;