mediabunny 1.42.0 → 1.43.0

package/dist/bundles/mediabunny.cjs

@@ -3064,6 +3064,16 @@ var Mediabunny = (() => {
     bitstream.skipBits(5);
     bitstream.skipBits(5);
   };
+  var concatHevcNalUnits = (nalUnits, decoderConfig) => {
+    if (decoderConfig.description) {
+      const bytes2 = toUint8Array(decoderConfig.description);
+      const lengthSizeMinusOne = bytes2[21] & 3;
+      const lengthSize = lengthSizeMinusOne + 1;
+      return concatNalUnitsInLengthPrefixed(nalUnits, lengthSize);
+    } else {
+      return concatNalUnitsInAnnexB(nalUnits);
+    }
+  };
   var iterateHevcNalUnits = (packetData, decoderConfig) => {
     if (decoderConfig.description) {
       const bytes2 = toUint8Array(decoderConfig.description);
@@ -3663,6 +3673,70 @@ var Mediabunny = (() => {
       return null;
     }
   };
+  var sanitizeHevcPacketForChromium = (packetData, decoderConfig) => {
+    const removedNalUnits = /* @__PURE__ */ new Set();
+    let orderState = 0 /* audAllowed */;
+    for (const loc of iterateHevcNalUnits(packetData, decoderConfig)) {
+      if (orderState === 4 /* noMoreDataAllowed */) {
+        removedNalUnits.add(loc.offset);
+        continue;
+      }
+      const type = extractNalUnitTypeForHevc(packetData[loc.offset]);
+      if (orderState === 3 /* eoBitstreamAllowed */ && type !== 37) {
+        removedNalUnits.add(loc.offset);
+        continue;
+      }
+      let remove = false;
+      if (type === 35) {
+        if (orderState > 0 /* audAllowed */) {
+          remove = true;
+        } else {
+          orderState = 1 /* beforeFirstVcl */;
+        }
+      } else if (type <= 31) {
+        if (orderState > 2 /* afterFirstVcl */) {
+          remove = true;
+        } else {
+          orderState = 2 /* afterFirstVcl */;
+        }
+      } else if (type === 36) {
+        if (orderState !== 2 /* afterFirstVcl */) {
+          remove = true;
+        } else {
+          orderState = 3 /* eoBitstreamAllowed */;
+        }
+      } else if (type === 37) {
+        if (orderState < 2 /* afterFirstVcl */) {
+          remove = true;
+        } else {
+          orderState = 4 /* noMoreDataAllowed */;
+        }
+      } else if (type === 32 || type === 33 || type === 34 || type === 39 || type >= 41 && type <= 44 || type >= 48 && type <= 55) {
+        if (orderState > 1 /* beforeFirstVcl */) {
+          remove = true;
+        } else {
+          orderState = 1 /* beforeFirstVcl */;
+        }
+      } else if (type === 38 || type === 40 || type >= 45 && type <= 47 || type >= 56 && type <= 63) {
+        if (orderState < 2 /* afterFirstVcl */) {
+          remove = true;
+        }
+      }
+      if (remove) {
+        removedNalUnits.add(loc.offset);
+      }
+    }
+    if (removedNalUnits.size === 0) {
+      return null;
+    }
+    const filteredNalUnits = [];
+    for (const loc of iterateHevcNalUnits(packetData, decoderConfig)) {
+      if (!removedNalUnits.has(loc.offset)) {
+        filteredNalUnits.push(packetData.subarray(loc.offset, loc.offset + loc.length));
+      }
+    }
+    return concatHevcNalUnits(filteredNalUnits, decoderConfig);
+  };
   var extractVp9CodecInfoFromPacket = (packet) => {
     const bitstream = new Bitstream(packet);
     const frameMarker = bitstream.readBits(2);
@@ -20021,6 +20095,20 @@ var Mediabunny = (() => {
   var isAudioData = (x) => {
     return typeof AudioData !== "undefined" && x instanceof AudioData;
   };
+  var toInterleavedAudioFormat = (format) => {
+    switch (format) {
+      case "u8-planar":
+        return "u8";
+      case "s16-planar":
+        return "s16";
+      case "s32-planar":
+        return "s32";
+      case "f32-planar":
+        return "f32";
+      default:
+        return format;
+    }
+  };
   var doAudioDataCopyToWebKitWorkaround = (audioData, destView, srcFormat, destFormat, numChannels, planeIndex, frameOffset, copyFrameCount) => {
     const readFn = getReadFunction(srcFormat);
     const writeFn = getWriteFunction(destFormat);
@@ -20100,6 +20188,19 @@ var Mediabunny = (() => {
       }
     }
   };
+  var audioSampleToInterleavedFormat = (sample, format) => {
+    const size = sample.allocationSize({ format, planeIndex: 0 });
+    const buffer = new ArrayBuffer(size);
+    sample.copyTo(buffer, { format, planeIndex: 0 });
+    return new AudioSample({
+      data: buffer,
+      format,
+      numberOfChannels: sample.numberOfChannels,
+      sampleRate: sample.sampleRate,
+      timestamp: sample.timestamp,
+      duration: sample.duration
+    });
+  };
 
   // src/encode.ts
   var canEncodeVideoMemo = /* @__PURE__ */ new Map();
@@ -20233,7 +20334,7 @@ var Mediabunny = (() => {
     if (!AUDIO_CODECS.includes(config.codec)) {
       throw new TypeError(`Invalid audio codec '${config.codec}'. Must be one of: ${AUDIO_CODECS.join(", ")}.`);
     }
-    if (config.bitrate === void 0 && (!PCM_AUDIO_CODECS.includes(config.codec) || config.codec === "flac")) {
+    if (config.bitrate === void 0 && !(PCM_AUDIO_CODECS.includes(config.codec) || config.codec === "flac")) {
       throw new TypeError("config.bitrate must be provided for compressed audio codecs.");
     }
     if (config.bitrate !== void 0 && !(config.bitrate instanceof Quality) && (!Number.isInteger(config.bitrate) || config.bitrate <= 0)) {
@@ -20249,6 +20350,9 @@ var Mediabunny = (() => {
       if (config.transform.sampleRate !== void 0 && (!Number.isInteger(config.transform.sampleRate) || config.transform.sampleRate <= 0)) {
         throw new TypeError("config.transform.sampleRate, when provided, must be a positive integer.");
       }
+      if (config.transform.sampleFormat !== void 0 && !["u8", "s16", "s32", "f32"].includes(config.transform.sampleFormat)) {
+        throw new TypeError("config.transform.sampleFormat, when provided, must be one of: u8, s16, s32, f32.");
+      }
       if (config.transform.process !== void 0 && typeof config.transform.process !== "function") {
         throw new TypeError("config.transform.process, when provided, must be a function.");
       }
@@ -21389,16 +21493,23 @@ var Mediabunny = (() => {
         if (!isWebKit()) {
           insertSorted(this.inputTimestamps, packet.timestamp, (x) => x);
         }
-        if (isChromium() && this.currentPacketIndex === 0 && this.codec === "avc") {
-          const filteredNalUnits = [];
-          for (const loc of iterateAvcNalUnits(packet.data, this.decoderConfig)) {
-            const type = extractNalUnitTypeForAvc(packet.data[loc.offset]);
-            if (!(type >= 20 && type <= 31)) {
-              filteredNalUnits.push(packet.data.subarray(loc.offset, loc.offset + loc.length));
+        if (isChromium() && this.currentPacketIndex === 0) {
+          if (this.codec === "avc") {
+            const filteredNalUnits = [];
+            for (const loc of iterateAvcNalUnits(packet.data, this.decoderConfig)) {
+              const type = extractNalUnitTypeForAvc(packet.data[loc.offset]);
+              if (!(type >= 20 && type <= 31)) {
+                filteredNalUnits.push(packet.data.subarray(loc.offset, loc.offset + loc.length));
+              }
+            }
+            const newData = concatAvcNalUnits(filteredNalUnits, this.decoderConfig);
+            packet = new EncodedPacket(newData, packet.type, packet.timestamp, packet.duration);
+          } else if (this.codec === "hevc") {
+            const sanitizedData = sanitizeHevcPacketForChromium(packet.data, this.decoderConfig);
+            if (sanitizedData) {
+              packet = new EncodedPacket(sanitizedData, packet.type, packet.timestamp, packet.duration);
             }
           }
-          const newData = concatAvcNalUnits(filteredNalUnits, this.decoderConfig);
-          packet = new EncodedPacket(newData, packet.type, packet.timestamp, packet.duration);
         }
         this.decoder.decode(packet.toEncodedVideoChunk());
         this.decodeAlphaData(packet);
@@ -25266,6 +25377,11 @@ var Mediabunny = (() => {
     view.setUint32(4, value, false);
     return [bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7]];
   };
+  var i64 = (value) => {
+    view.setInt32(0, Math.floor(value / 2 ** 32), false);
+    view.setUint32(4, value, false);
+    return [bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7]];
+  };
   var fixed_8_8 = (value) => {
     view.setInt16(0, 2 ** 8 * value, false);
     return [bytes[0], bytes[1]];
@@ -25436,10 +25552,10 @@ var Mediabunny = (() => {
     udta(muxer)
   ]);
   var mvhd = (creationTime, trackDatas) => {
-    const duration = intoTimescale(Math.max(
+    const duration = Math.max(
       0,
-      ...trackDatas.map((x) => presentationSpan(x))
-    ), GLOBAL_TIMESCALE);
+      ...trackDatas.map((trackData) => intoTimescale(presentationSpan(trackData), GLOBAL_TIMESCALE) + intoTimescale(trackData.startTimestampOffset ?? 0, GLOBAL_TIMESCALE))
+    );
     const nextTrackId = Math.max(0, ...trackDatas.map((x) => x.track.id)) + 1;
     const needsU64 = !isU32(creationTime) || !isU32(duration);
     const u32OrU64 = needsU64 ? u64 : u32;
@@ -25472,7 +25588,8 @@ var Mediabunny = (() => {
     }
     let minTimestamp = Infinity;
     let maxEndTimestamp = -Infinity;
-    for (const sample of trackData.samples) {
+    for (let i = 0; i < trackData.samples.length; i++) {
+      const sample = trackData.samples[i];
       if (sample.timestamp < minTimestamp) {
         minTimestamp = sample.timestamp;
       }
@@ -25487,8 +25604,10 @@ var Mediabunny = (() => {
   };
   var trak = (trackData, creationTime) => {
     const trackMetadata = getTrackMetadata(trackData);
+    const needsEditList = trackData.startTimestampOffset !== null && trackData.startTimestampOffset > 0;
     return box("trak", void 0, [
       tkhd(trackData, creationTime),
+      needsEditList ? edts(trackData, trackData.startTimestampOffset) : null,
       mdia(trackData, creationTime),
       trackMetadata.name !== void 0 ? box("udta", void 0, [
         box("name", [
@@ -25499,10 +25618,7 @@ var Mediabunny = (() => {
     ]);
   };
   var tkhd = (trackData, creationTime) => {
-    const durationInGlobalTimescale = intoTimescale(
-      presentationSpan(trackData),
-      GLOBAL_TIMESCALE
-    );
+    const durationInGlobalTimescale = intoTimescale(presentationSpan(trackData), GLOBAL_TIMESCALE) + intoTimescale(trackData.startTimestampOffset ?? 0, GLOBAL_TIMESCALE);
     const needsU64 = !isU32(creationTime) || !isU32(durationInGlobalTimescale);
     const u32OrU64 = needsU64 ? u64 : u32;
     let matrix;
@@ -25545,6 +25661,33 @@ var Mediabunny = (() => {
       // Track height
     ]);
   };
+  var edts = (trackData, offset) => {
+    const startOffset = intoTimescale(offset, GLOBAL_TIMESCALE);
+    const mediaDuration = intoTimescale(presentationSpan(trackData), GLOBAL_TIMESCALE);
+    const needs64Bits = !isU32(startOffset) || !isU32(mediaDuration);
+    const u32OrU64 = needs64Bits ? u64 : u32;
+    const i32OrI64 = needs64Bits ? i64 : i32;
+    return box("edts", void 0, [
+      fullBox("elst", needs64Bits ? 1 : 0, 0, [
+        u32(2),
+        // Entry count
+        // #1
+        u32OrU64(startOffset),
+        // Segment duration
+        i32OrI64(-1),
+        // Media time
+        fixed_16_16(1),
+        // Media rate
+        // #2
+        u32OrU64(mediaDuration),
+        // Segment duration
+        i32OrI64(0),
+        // Media time
+        fixed_16_16(1)
+        // Media rate
+      ])
+    ]);
+  };
   var mdia = (trackData, creationTime) => box("mdia", void 0, [
     mdhd(trackData, creationTime),
     hdlr(true, TRACK_TYPE_TO_COMPONENT_SUBTYPE[trackData.type], TRACK_TYPE_TO_HANDLER_NAME[trackData.type]),
@@ -27473,7 +27616,7 @@ var Mediabunny = (() => {
   };
 
   // src/isobmff/isobmff-muxer.ts
-  var GLOBAL_TIMESCALE = 1e3;
+  var GLOBAL_TIMESCALE = 57600;
   var TIMESTAMP_OFFSET = 2082844800;
   var getTrackMetadata = (trackData) => {
     const metadata = {};
@@ -27641,7 +27784,10 @@ var Mediabunny = (() => {
         decoderConfig.description = serializeHevcDecoderConfigurationRecord(decoderConfigurationRecord);
         requiresAnnexBTransformation = true;
       }
-      const timescale = computeRationalApproximation(1 / (track.metadata.frameRate ?? 57600), 1e6).denominator;
+      const timescale = computeRationalApproximation(
+        1 / (track.metadata.frameRate ?? GLOBAL_TIMESCALE),
+        1e6
+      ).denominator;
       const displayAspectWidth = decoderConfig.displayAspectWidth;
       const displayAspectHeight = decoderConfig.displayAspectHeight;
       const pixelAspectRatio = displayAspectWidth === void 0 || displayAspectHeight === void 0 ? { num: 1, den: 1 } : simplifyRational({
@@ -27667,6 +27813,7 @@ var Mediabunny = (() => {
         compositionTimeOffsetTable: [],
         lastTimescaleUnits: null,
         lastSample: null,
+        startTimestampOffset: null,
         finalizedChunks: [],
         currentChunk: null,
         compactlyCodedChunkTable: [],
@@ -27717,6 +27864,7 @@ var Mediabunny = (() => {
           sampleRate: meta.decoderConfig.sampleRate,
           decoderConfig,
           requiresPcmTransformation: !this.isFragmented && PCM_AUDIO_CODECS.includes(track.source._codec),
+          expectedNextPcmPacketTimestamp: null,
           requiresAdtsStripping,
           firstPacket: packet
         },
@@ -27728,6 +27876,7 @@ var Mediabunny = (() => {
         compositionTimeOffsetTable: [],
         lastTimescaleUnits: null,
         lastSample: null,
+        startTimestampOffset: null,
         finalizedChunks: [],
         currentChunk: null,
         compactlyCodedChunkTable: [],
@@ -27764,6 +27913,7 @@ var Mediabunny = (() => {
         compositionTimeOffsetTable: [],
         lastTimescaleUnits: null,
         lastSample: null,
+        startTimestampOffset: null,
         finalizedChunks: [],
         currentChunk: null,
         compactlyCodedChunkTable: [],
@@ -27824,31 +27974,48 @@ var Mediabunny = (() => {
           const headerLength = adtsFrame.crcCheck === null ? MIN_ADTS_FRAME_HEADER_SIZE : MAX_ADTS_FRAME_HEADER_SIZE;
           packetData = packetData.subarray(headerLength);
         }
-        const timestamp = this.validateAndNormalizeTimestamp(
+        let timestamp = this.validateAndNormalizeTimestamp(
           trackData.track,
           packet.timestamp,
           packet.type === "key"
         );
+        let duration = packet.duration;
+        if (trackData.info.requiresPcmTransformation) {
+          const pcmInfo = parsePcmCodec(
+            trackData.info.decoderConfig.codec
+          );
+          const frameSize = pcmInfo.sampleSize * trackData.info.numberOfChannels;
+          duration = packetData.byteLength / frameSize / trackData.info.sampleRate;
+          if (trackData.info.expectedNextPcmPacketTimestamp !== null) {
+            const diff = timestamp - trackData.info.expectedNextPcmPacketTimestamp;
+            if (diff < 0.01) {
+              timestamp = trackData.info.expectedNextPcmPacketTimestamp;
+            } else {
+              const paddedDuration = await this.padWithSilence(
+                trackData,
+                trackData.info.expectedNextPcmPacketTimestamp,
+                diff
+              );
+              timestamp = trackData.info.expectedNextPcmPacketTimestamp + paddedDuration;
+            }
+          }
+          trackData.info.expectedNextPcmPacketTimestamp = timestamp + duration;
+        }
         const internalSample = this.createSampleForTrack(
           trackData,
           packetData,
           timestamp,
-          packet.duration,
+          duration,
           packet.type
         );
-        if (trackData.info.requiresPcmTransformation) {
-          await this.maybePadWithSilence(trackData, timestamp);
-        }
         await this.registerSample(trackData, internalSample);
       } finally {
         release();
       }
     }
-    async maybePadWithSilence(trackData, untilTimestamp) {
-      const lastSample = last(trackData.samples);
-      const lastEndTimestamp = lastSample ? lastSample.timestamp + lastSample.duration : 0;
-      const delta = untilTimestamp - lastEndTimestamp;
-      const deltaInTimescale = intoTimescale(delta, trackData.timescale);
+    async padWithSilence(trackData, timestamp, duration) {
+      const deltaInTimescale = intoTimescale(duration, trackData.timescale);
+      duration = deltaInTimescale / trackData.timescale;
       if (deltaInTimescale > 0) {
         const { sampleSize, silentValue } = parsePcmCodec(
           trackData.info.decoderConfig.codec
@@ -27858,12 +28025,13 @@ var Mediabunny = (() => {
         const paddingSample = this.createSampleForTrack(
           trackData,
           new Uint8Array(data.buffer),
-          lastEndTimestamp,
-          delta,
+          timestamp,
+          duration,
           "key"
         );
         await this.registerSample(trackData, paddingSample);
       }
+      return duration;
     }
     async addSubtitleCue(track, cue, meta) {
       const release = await this.mutex.acquire();
@@ -27964,6 +28132,9 @@ var Mediabunny = (() => {
         return;
       }
       if (trackData.type === "audio" && trackData.info.requiresPcmTransformation) {
+        if (!this.isFragmented) {
+          trackData.startTimestampOffset ??= trackData.timestampProcessingQueue[0].timestamp;
+        }
         let totalDuration = 0;
         for (let i = 0; i < trackData.timestampProcessingQueue.length; i++) {
           const sample = trackData.timestampProcessingQueue[i];
@@ -27983,12 +28154,12 @@ var Mediabunny = (() => {
         return;
       }
       const sortedTimestamps = trackData.timestampProcessingQueue.map((x) => x.timestamp).sort((a, b) => a - b);
+      if (!this.isFragmented) {
+        trackData.startTimestampOffset ??= sortedTimestamps[0];
+      }
       for (let i = 0; i < trackData.timestampProcessingQueue.length; i++) {
         const sample = trackData.timestampProcessingQueue[i];
         sample.decodeTimestamp = sortedTimestamps[i];
-        if (!this.isFragmented && trackData.lastTimescaleUnits === null) {
-          sample.decodeTimestamp = 0;
-        }
         const sampleCompositionTimeOffset = intoTimescale(sample.timestamp - sample.decodeTimestamp, trackData.timescale);
         const durationInTimescale = intoTimescale(sample.duration, trackData.timescale);
         if (trackData.lastTimescaleUnits !== null) {
@@ -28352,6 +28523,12 @@ var Mediabunny = (() => {
       } else {
         for (const trackData of this.trackDatas) {
           await this.finalizeCurrentChunk(trackData);
+          assert(trackData.startTimestampOffset !== null);
+          for (let i = 0; i < trackData.samples.length; i++) {
+            const sample = trackData.samples[i];
+            sample.timestamp -= trackData.startTimestampOffset;
+            sample.decodeTimestamp -= trackData.startTimestampOffset;
+          }
         }
       }
       assert(this.writer);
@@ -32320,6 +32497,14 @@ ${cue.notes ?? ""}`;
      */
     async processAndEncode(audioSample, shouldClose) {
       const config = this.encodingConfig;
+      if (config.transform?.sampleFormat !== void 0 && toInterleavedAudioFormat(audioSample.format) !== config.transform.sampleFormat) {
+        const newSample = audioSampleToInterleavedFormat(audioSample, config.transform.sampleFormat);
+        if (shouldClose) {
+          audioSample.close();
+        }
+        audioSample = newSample;
+        shouldClose = true;
+      }
       if (config.transform?.process) {
         let processed = config.transform.process(audioSample);
         if (processed instanceof Promise) {
@@ -32339,6 +32524,9 @@ ${cue.notes ?? ""}`;
           }
           await this.encodeSample(sample, true);
         }
+        if (shouldClose) {
+          audioSample.close();
+        }
       } else {
         await this.encodeSample(audioSample, shouldClose);
       }
@@ -35418,6 +35606,9 @@ ${cue.notes ?? ""}`;
     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.");
     }
+    if (audioOptions?.sampleFormat !== void 0 && !["u8", "s16", "s32", "f32"].includes(audioOptions.sampleFormat)) {
+      throw new TypeError("options.audio.sampleFormat, when provided, must be one of: u8, s16, s32, f32.");
+    }
     if (audioOptions?.process !== void 0 && typeof audioOptions.process !== "function") {
       throw new TypeError("options.audio.process, when provided, must be a function.");
     }
@@ -36036,7 +36227,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
                   timestamp: lastCanvasTimestamp + i / frameRate,
                   duration: 1 / frameRate
                 });
-                await this._registerVideoSample(track, trackOptions, outputTrackId, source, sample);
+                await this._registerVideoSample(trackOptions, outputTrackId, source, sample);
                 sample.close();
               }
             };
@@ -36063,7 +36254,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
                 timestamp: adjustedSampleTimestamp,
                 duration: frameRate !== void 0 ? 1 / frameRate : duration
               });
-              await this._registerVideoSample(track, trackOptions, outputTrackId, source, sample);
+              await this._registerVideoSample(trackOptions, outputTrackId, source, sample);
               sample.close();
               if (frameRate !== void 0) {
                 lastCanvas = canvas;
@@ -36093,7 +36284,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
               for (let i = 1; i < frameDifference; i++) {
                 lastSample.setTimestamp(lastSampleTimestamp + i / frameRate);
                 lastSample.setDuration(1 / frameRate);
-                await this._registerVideoSample(track, trackOptions, outputTrackId, source, lastSample);
+                await this._registerVideoSample(trackOptions, outputTrackId, source, lastSample);
               }
               lastSample.close();
             };
@@ -36121,7 +36312,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
                 sample.setDuration(1 / frameRate);
               }
               sample.setTimestamp(adjustedSampleTimestamp);
-              await this._registerVideoSample(track, trackOptions, outputTrackId, source, sample);
+              await this._registerVideoSample(trackOptions, outputTrackId, source, sample);
               if (frameRate !== void 0) {
                 lastSample = sample;
                 lastSampleTimestamp = adjustedSampleTimestamp;
@@ -36160,7 +36351,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       this._outputOwnTrackGroups.push(ownGroup);
     }
     /** @internal */
-    async _registerVideoSample(track, trackOptions, outputTrackId, source, sample) {
+    async _registerVideoSample(trackOptions, outputTrackId, source, sample) {
       if (this._canceled) {
         return;
       }
@@ -36224,7 +36415,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       let sampleRate = trackOptions.sampleRate ?? originalSampleRate;
       let needsResample = numberOfChannels !== originalNumberOfChannels || sampleRate !== originalSampleRate || firstTimestamp < this._startTimestamp || 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) {
+      if (!trackOptions.forceTranscode && !trackOptions.bitrate && !needsResample && 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 () => {
@@ -36321,7 +36512,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
                 return;
               }
               sample.setTimestamp(sample.timestamp - this._startTimestamp);
-              await this._registerAudioSample(track, trackOptions, outputTrackId, source, sample);
+              await this._registerAudioSample(trackOptions, outputTrackId, source, sample);
               sample.close();
             }
             source.close();
@@ -36348,10 +36539,14 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       this._outputOwnTrackGroups.push(ownGroup);
     }
     /** @internal */
-    async _registerAudioSample(track, trackOptions, outputTrackId, source, sample) {
+    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);
+      }
       this._reportProgress(outputTrackId, sample.timestamp + sample.duration);
       let finalSamples;
       if (!trackOptions.process) {
@@ -36380,8 +36575,11 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
           }
         }
       } finally {
+        if (sample !== inputSample) {
+          sample.close();
+        }
         for (const finalSample of finalSamples) {
-          if (finalSample !== sample) {
+          if (finalSample !== inputSample) {
             finalSample.close();
           }
         }
@@ -36402,7 +36600,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
           endTime: this._endTimestamp,
           onSample: async (sample) => {
             sample.setTimestamp(sample.timestamp - this._startTimestamp);
-            await this._registerAudioSample(track, trackOptions, outputTrackId, source, sample);
+            await this._registerAudioSample(trackOptions, outputTrackId, source, sample);
             sample.close();
           }
         });