mediabunny 1.22.0 → 1.24.0

package/dist/bundles/mediabunny.cjs

@@ -77,6 +77,7 @@ var Mediabunny = (() => {
     EncodedVideoPacketSource: () => EncodedVideoPacketSource,
     FLAC: () => FLAC,
     FilePathSource: () => FilePathSource,
+    FilePathTarget: () => FilePathTarget,
     FlacInputFormat: () => FlacInputFormat,
     FlacOutputFormat: () => FlacOutputFormat,
     Input: () => Input,
@@ -312,7 +313,7 @@ var Mediabunny = (() => {
     // Linear transfer characteristics
     "iec61966-2-1": 13,
     // IEC 61966-2-1
-    "pg": 16,
+    "pq": 16,
     // Rec. ITU-R BT.2100-2 perceptual quantization (PQ) system
     "hlg": 18
     // Rec. ITU-R BT.2100-2 hybrid loggamma (HLG) system
@@ -15655,6 +15656,7 @@ var Mediabunny = (() => {
       this.workers = [];
       this.cache = [];
       this.currentCacheSize = 0;
+      this.disposed = false;
     }
     read(innerStart, innerEnd) {
       assert(this.fileSize !== null);
@@ -15831,6 +15833,9 @@ var Mediabunny = (() => {
     }
     /** Called by a worker when it has read some data. */
     supplyWorkerData(worker, bytes2) {
+      if (this.disposed) {
+        return;
+      }
       const start = worker.currentPos;
       const end = start + bytes2.length;
       this.insertIntoCache({
@@ -15962,6 +15967,7 @@ var Mediabunny = (() => {
       }
       this.workers.length = 0;
       this.cache.length = 0;
+      this.disposed = true;
     }
   };
 
@@ -18494,6 +18500,8 @@ var Mediabunny = (() => {
   };
 
   // src/target.ts
+  var nodeAlias2 = __toESM(require_node(), 1);
+  var node2 = typeof nodeAlias2 !== "undefined" ? nodeAlias2 : void 0;
   var Target = class {
     constructor() {
       /** @internal */
@@ -18542,6 +18550,44 @@ var Mediabunny = (() => {
       return new StreamTargetWriter(this);
     }
   };
+  var FilePathTarget = class extends Target {
+    /** Creates a new {@link FilePathTarget} that writes to the file at the specified file path. */
+    constructor(filePath, options = {}) {
+      if (typeof filePath !== "string") {
+        throw new TypeError("filePath must be a string.");
+      }
+      if (!options || typeof options !== "object") {
+        throw new TypeError("options must be an object.");
+      }
+      super();
+      /** @internal */
+      this._fileHandle = null;
+      const writable = new WritableStream({
+        start: async () => {
+          this._fileHandle = await node2.fs.open(filePath, "w");
+        },
+        write: async (chunk) => {
+          assert(this._fileHandle);
+          await this._fileHandle.write(chunk.data, 0, chunk.data.byteLength, chunk.position);
+        },
+        close: async () => {
+          if (this._fileHandle) {
+            await this._fileHandle.close();
+            this._fileHandle = null;
+          }
+        }
+      });
+      this._streamTarget = new StreamTarget(writable, {
+        chunked: true,
+        ...options
+      });
+      this._streamTarget._output = this._output;
+    }
+    /** @internal */
+    _createWriter() {
+      return this._streamTarget._createWriter();
+    }
+  };
   var NullTarget = class extends Target {
     /** @internal */
     _createWriter() {
@@ -23864,7 +23910,16 @@ ${cue.notes ?? ""}`;
       throw new TypeError("options.video.alpha, when provided, must be either 'discard' or 'keep'.");
     }
     if (videoOptions?.keyFrameInterval !== void 0 && (!Number.isFinite(videoOptions.keyFrameInterval) || videoOptions.keyFrameInterval < 0)) {
-      throw new TypeError("config.keyFrameInterval, when provided, must be a non-negative number.");
+      throw new TypeError("options.video.keyFrameInterval, when provided, must be a non-negative number.");
+    }
+    if (videoOptions?.process !== void 0 && typeof videoOptions.process !== "function") {
+      throw new TypeError("options.video.process, when provided, must be a function.");
+    }
+    if (videoOptions?.processedWidth !== void 0 && (!Number.isInteger(videoOptions.processedWidth) || videoOptions.processedWidth <= 0)) {
+      throw new TypeError("options.video.processedWidth, when provided, must be a positive integer.");
+    }
+    if (videoOptions?.processedHeight !== void 0 && (!Number.isInteger(videoOptions.processedHeight) || videoOptions.processedHeight <= 0)) {
+      throw new TypeError("options.video.processedHeight, when provided, must be a positive integer.");
     }
   };
   var validateAudioOptions = (audioOptions) => {
@@ -23891,6 +23946,15 @@ ${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?.process !== void 0 && typeof audioOptions.process !== "function") {
+      throw new TypeError("options.audio.process, when provided, must be a function.");
+    }
+    if (audioOptions?.processedNumberOfChannels !== void 0 && (!Number.isInteger(audioOptions.processedNumberOfChannels) || audioOptions.processedNumberOfChannels <= 0)) {
+      throw new TypeError("options.audio.processedNumberOfChannels, when provided, must be a positive integer.");
+    }
+    if (audioOptions?.processedSampleRate !== void 0 && (!Number.isInteger(audioOptions.processedSampleRate) || audioOptions.processedSampleRate <= 0)) {
+      throw new TypeError("options.audio.processedSampleRate, when provided, must be a positive integer.");
+    }
   };
   var FALLBACK_NUMBER_OF_CHANNELS = 2;
   var FALLBACK_SAMPLE_RATE = 48e3;
@@ -24225,7 +24289,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         height = ceilToMultipleOfTwo(trackOptions.height);
       }
       const firstTimestamp = await track.getFirstTimestamp();
-      const needsTranscode = !!trackOptions.forceTranscode || this._startTimestamp > 0 || firstTimestamp < 0 || !!trackOptions.frameRate || trackOptions.keyFrameInterval !== void 0;
+      const needsTranscode = !!trackOptions.forceTranscode || this._startTimestamp > 0 || firstTimestamp < 0 || !!trackOptions.frameRate || trackOptions.keyFrameInterval !== void 0 || trackOptions.process !== void 0;
       let needsRerender = width !== originalWidth || height !== originalHeight || totalRotation !== 0 && !outputSupportsRotation || !!crop;
       const alpha = trackOptions.alpha ?? "discard";
       let videoCodecs = this.output.format.getSupportedVideoCodecs();
@@ -24239,9 +24303,6 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
           const meta = { decoderConfig: decoderConfig ?? void 0 };
           const endPacket = Number.isFinite(this._endTimestamp) ? await sink.getPacket(this._endTimestamp, { metadataOnly: true }) ?? void 0 : void 0;
           for await (const packet of sink.packets(void 0, endPacket, { verifyKeyPackets: true })) {
-            if (this._synchronizer.shouldWait(track.id, packet.timestamp)) {
-              await this._synchronizer.wait(packet.timestamp);
-            }
             if (this._canceled) {
               return;
             }
@@ -24249,8 +24310,11 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
               delete packet.sideData.alpha;
               delete packet.sideData.alphaByteLength;
             }
+            this._reportProgress(track.id, packet.timestamp);
             await source.add(packet, meta);
-            this._reportProgress(track.id, packet.timestamp + packet.duration);
+            if (this._synchronizer.shouldWait(track.id, packet.timestamp)) {
+              await this._synchronizer.wait(packet.timestamp);
+            }
           }
           source.close();
           this._synchronizer.closeTrack(track.id);
@@ -24268,7 +24332,11 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
           videoCodecs = videoCodecs.filter((codec) => codec === trackOptions.codec);
         }
         const bitrate = trackOptions.bitrate ?? QUALITY_HIGH;
-        const encodableCodec = await getFirstEncodableVideoCodec(videoCodecs, { width, height, bitrate });
+        const encodableCodec = await getFirstEncodableVideoCodec(videoCodecs, {
+          width: trackOptions.process && trackOptions.processedWidth ? trackOptions.processedWidth : width,
+          height: trackOptions.process && trackOptions.processedHeight ? trackOptions.processedHeight : height,
+          bitrate
+        });
         if (!encodableCodec) {
           this.discardedTracks.push({
             track,
@@ -24281,8 +24349,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
           bitrate,
           keyFrameInterval: trackOptions.keyFrameInterval,
           sizeChangeBehavior: trackOptions.fit ?? "passThrough",
-          alpha,
-          onEncodedPacket: (sample) => this._reportProgress(track.id, sample.timestamp + sample.duration)
+          alpha
         };
         const source = new VideoSampleSource(encodingConfig);
         videoSource = source;
@@ -24338,13 +24405,10 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
                   timestamp: lastCanvasTimestamp + i / frameRate,
                   duration: 1 / frameRate
                 });
-                await source.add(sample);
+                await this._registerVideoSample(track, trackOptions, source, sample);
               }
             };
             for await (const { canvas, timestamp, duration } of iterator) {
-              if (this._synchronizer.shouldWait(track.id, timestamp)) {
-                await this._synchronizer.wait(timestamp);
-              }
               if (this._canceled) {
                 return;
               }
@@ -24367,7 +24431,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
                 timestamp: adjustedSampleTimestamp,
                 duration: frameRate !== void 0 ? 1 / frameRate : duration
               });
-              await source.add(sample);
+              await this._registerVideoSample(track, trackOptions, source, sample);
               if (frameRate !== void 0) {
                 lastCanvas = canvas;
                 lastCanvasTimestamp = adjustedSampleTimestamp;
@@ -24398,14 +24462,11 @@ 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 source.add(lastSample);
+                await this._registerVideoSample(track, trackOptions, source, lastSample);
               }
               lastSample.close();
             };
             for await (const sample of sink.samples(this._startTimestamp, this._endTimestamp)) {
-              if (this._synchronizer.shouldWait(track.id, sample.timestamp)) {
-                await this._synchronizer.wait(sample.timestamp);
-              }
               if (this._canceled) {
                 lastSample?.close();
                 return;
@@ -24428,7 +24489,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
                 sample.setDuration(1 / frameRate);
               }
               sample.setTimestamp(adjustedSampleTimestamp);
-              await source.add(sample);
+              await this._registerVideoSample(track, trackOptions, source, sample);
               if (frameRate !== void 0) {
                 lastSample = sample;
                 lastSampleTimestamp = adjustedSampleTimestamp;
@@ -24459,6 +24520,49 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       this.utilizedTracks.push(track);
     }
     /** @internal */
+    async _registerVideoSample(track, trackOptions, source, sample) {
+      if (this._canceled) {
+        return;
+      }
+      this._reportProgress(track.id, sample.timestamp);
+      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
+          });
+        });
+      }
+      for (const finalSample of finalSamples) {
+        if (this._canceled) {
+          break;
+        }
+        await source.add(finalSample);
+        if (this._synchronizer.shouldWait(track.id, finalSample.timestamp)) {
+          await this._synchronizer.wait(finalSample.timestamp);
+        }
+      }
+      for (const finalSample of finalSamples) {
+        if (finalSample !== sample) {
+          finalSample.close();
+        }
+      }
+    }
+    /** @internal */
     async _processAudioTrack(track, trackOptions) {
       const sourceCodec = track.codec;
       if (!sourceCodec) {
@@ -24476,7 +24580,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       let sampleRate = trackOptions.sampleRate ?? originalSampleRate;
       let needsResample = numberOfChannels !== originalNumberOfChannels || sampleRate !== originalSampleRate || this._startTimestamp > 0 || firstTimestamp < 0;
       let audioCodecs = this.output.format.getSupportedAudioCodecs();
-      if (!trackOptions.forceTranscode && !trackOptions.bitrate && !needsResample && audioCodecs.includes(sourceCodec) && (!trackOptions.codec || trackOptions.codec === sourceCodec)) {
+      if (!trackOptions.forceTranscode && !trackOptions.bitrate && !needsResample && audioCodecs.includes(sourceCodec) && (!trackOptions.codec || trackOptions.codec === sourceCodec) && !trackOptions.process) {
         const source = new EncodedAudioPacketSource(sourceCodec);
         audioSource = source;
         this._trackPromises.push((async () => {
@@ -24486,14 +24590,14 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
           const meta = { decoderConfig: decoderConfig ?? void 0 };
           const endPacket = Number.isFinite(this._endTimestamp) ? await sink.getPacket(this._endTimestamp, { metadataOnly: true }) ?? void 0 : void 0;
           for await (const packet of sink.packets(void 0, endPacket)) {
-            if (this._synchronizer.shouldWait(track.id, packet.timestamp)) {
-              await this._synchronizer.wait(packet.timestamp);
-            }
             if (this._canceled) {
               return;
             }
+            this._reportProgress(track.id, packet.timestamp);
             await source.add(packet, meta);
-            this._reportProgress(track.id, packet.timestamp + packet.duration);
+            if (this._synchronizer.shouldWait(track.id, packet.timestamp)) {
+              await this._synchronizer.wait(packet.timestamp);
+            }
           }
           source.close();
           this._synchronizer.closeTrack(track.id);
@@ -24513,11 +24617,11 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         }
         const bitrate = trackOptions.bitrate ?? QUALITY_HIGH;
         const encodableCodecs = await getEncodableAudioCodecs(audioCodecs, {
-          numberOfChannels,
-          sampleRate,
+          numberOfChannels: trackOptions.process && trackOptions.processedNumberOfChannels ? trackOptions.processedNumberOfChannels : numberOfChannels,
+          sampleRate: trackOptions.process && trackOptions.processedSampleRate ? trackOptions.processedSampleRate : sampleRate,
           bitrate
         });
-        if (!encodableCodecs.some((codec) => NON_PCM_AUDIO_CODECS.includes(codec)) && audioCodecs.some((codec) => NON_PCM_AUDIO_CODECS.includes(codec)) && (numberOfChannels !== FALLBACK_NUMBER_OF_CHANNELS || sampleRate !== FALLBACK_SAMPLE_RATE)) {
+        if (!encodableCodecs.some((codec) => NON_PCM_AUDIO_CODECS.includes(codec)) && audioCodecs.some((codec) => NON_PCM_AUDIO_CODECS.includes(codec)) && (numberOfChannels !== FALLBACK_NUMBER_OF_CHANNELS || sampleRate !== FALLBACK_SAMPLE_RATE) && !trackOptions.process) {
           const encodableCodecsWithDefaultParams = await getEncodableAudioCodecs(audioCodecs, {
             numberOfChannels: FALLBACK_NUMBER_OF_CHANNELS,
             sampleRate: FALLBACK_SAMPLE_RATE,
@@ -24541,25 +24645,28 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
           return;
         }
         if (needsResample) {
-          audioSource = this._resampleAudio(track, codecOfChoice, numberOfChannels, sampleRate, bitrate);
+          audioSource = this._resampleAudio(
+            track,
+            trackOptions,
+            codecOfChoice,
+            numberOfChannels,
+            sampleRate,
+            bitrate
+          );
         } else {
           const source = new AudioSampleSource({
             codec: codecOfChoice,
-            bitrate,
-            onEncodedPacket: (packet) => this._reportProgress(track.id, packet.timestamp + packet.duration)
+            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._synchronizer.shouldWait(track.id, sample.timestamp)) {
-                await this._synchronizer.wait(sample.timestamp);
-              }
               if (this._canceled) {
                 return;
               }
-              await source.add(sample);
+              await this._registerAudioSample(track, trackOptions, source, sample);
               sample.close();
             }
             source.close();
@@ -24577,11 +24684,47 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       this.utilizedTracks.push(track);
     }
     /** @internal */
-    _resampleAudio(track, codec, targetNumberOfChannels, targetSampleRate, bitrate) {
+    async _registerAudioSample(track, trackOptions, source, sample) {
+      if (this._canceled) {
+        return;
+      }
+      this._reportProgress(track.id, sample.timestamp);
+      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;
+      }
+      for (const finalSample of finalSamples) {
+        if (this._canceled) {
+          break;
+        }
+        await source.add(finalSample);
+        if (this._synchronizer.shouldWait(track.id, finalSample.timestamp)) {
+          await this._synchronizer.wait(finalSample.timestamp);
+        }
+      }
+      for (const finalSample of finalSamples) {
+        if (finalSample !== sample) {
+          finalSample.close();
+        }
+      }
+    }
+    /** @internal */
+    _resampleAudio(track, trackOptions, codec, targetNumberOfChannels, targetSampleRate, bitrate) {
       const source = new AudioSampleSource({
         codec,
-        bitrate,
-        onEncodedPacket: (packet) => this._reportProgress(track.id, packet.timestamp + packet.duration)
+        bitrate
       });
       this._trackPromises.push((async () => {
         await this._started;
@@ -24590,14 +24733,11 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
           targetSampleRate,
           startTime: this._startTimestamp,
           endTime: this._endTimestamp,
-          onSample: (sample) => source.add(sample)
+          onSample: (sample) => this._registerAudioSample(track, trackOptions, source, sample)
         });
         const sink = new AudioSampleSink(track);
         const iterator = sink.samples(this._startTimestamp, this._endTimestamp);
         for await (const sample of iterator) {
-          if (this._synchronizer.shouldWait(track.id, sample.timestamp)) {
-            await this._synchronizer.wait(sample.timestamp);
-          }
           if (this._canceled) {
             return;
           }