mediabunny 1.50.7 → 1.50.9

package/dist/bundles/mediabunny.cjs

@@ -4215,8 +4215,17 @@ var Mediabunny = (() => {
   ];
   var parseOpusTocByte = (packet) => {
     const config = packet[0] >> 3;
+    const code = packet[0] & 3;
+    let frameCount;
+    if (code === 0) {
+      frameCount = 1;
+    } else if (code === 1 || code === 2) {
+      frameCount = 2;
+    } else {
+      frameCount = packet[1] & 63;
+    }
     return {
-      durationInSamples: OPUS_FRAME_DURATION_TABLE[config]
+      durationInSamples: OPUS_FRAME_DURATION_TABLE[config] * frameCount
     };
   };
   var parseModesFromVorbisSetupPacket = (setupHeader) => {
@@ -12379,6 +12388,21 @@ var Mediabunny = (() => {
       if (formatTag === 7 /* MULAW */ || formatTag === 6 /* ALAW */) {
         bitsPerSample = 8;
       }
+      if (formatTag !== 1 /* PCM */ && formatTag !== 3 /* IEEE_FLOAT */ && formatTag !== 6 /* ALAW */ && formatTag !== 7 /* MULAW */) {
+        throw new Error(
+          `Unsupported WAVE codec (format tag ${formatTag}). Only integer/float PCM, A-law, and \u03BC-law are supported.`
+        );
+      }
+      if (formatTag === 1 /* PCM */ && ![8, 16, 24, 32].includes(bitsPerSample)) {
+        throw new Error(
+          `Unsupported WAVE PCM bit depth (${bitsPerSample}). Only 8, 16, 24, and 32 bits are supported.`
+        );
+      }
+      if (formatTag === 3 /* IEEE_FLOAT */ && ![32, 64].includes(bitsPerSample)) {
+        throw new Error(
+          `Unsupported WAVE float bit depth (${bitsPerSample}). Only 32 and 64 bits are supported.`
+        );
+      }
       this.audioInfo = {
         format: formatTag,
         numberOfChannels: numChannels,
@@ -12527,9 +12551,11 @@ var Mediabunny = (() => {
       if (this.audioInfo.format === 3 /* IEEE_FLOAT */) {
         if (this.audioInfo.sampleSizeInBytes === 4) {
           return "pcm-f32";
+        } else if (this.audioInfo.sampleSizeInBytes === 8) {
+          return "pcm-f64";
         }
       }
-      return null;
+      assert(false);
     }
     async getMimeType() {
       return "audio/wav";
@@ -28949,6 +28975,7 @@ var Mediabunny = (() => {
       this.isQuickTime = format instanceof MovOutputFormat;
       this.isCmaf = format instanceof CmafOutputFormat;
       this.minimumFragmentDuration = format._options.minimumFragmentDuration ?? (format instanceof CmafOutputFormat ? Infinity : 1);
+      this.auxWriter.start();
     }
     async start() {
       const release = await this.mutex.acquire();
@@ -30750,7 +30777,8 @@ ${cue.notes ?? ""}`;
       view2.setUint8(0, 128 | trackData.track.id);
       view2.setInt16(1, relativeTimestamp, false);
       const msDuration = Math.round(1e3 * chunk.duration);
-      if (!chunk.additions) {
+      const needsBlockGroup = !!chunk.additions || trackData.type === "subtitle";
+      if (!needsBlockGroup) {
         view2.setUint8(3, Number(chunk.type === "key") << 7);
         const simpleBlock = { id: 163 /* SimpleBlock */, data: [
           prelude,
@@ -35907,7 +35935,7 @@ ${cue.notes ?? ""}`;
     getSupportedCodecs() {
       return [
         ...PCM_AUDIO_CODECS.filter(
-          (codec) => ["pcm-s16", "pcm-s24", "pcm-s32", "pcm-f32", "pcm-u8", "ulaw", "alaw"].includes(codec)
+          (codec) => ["pcm-s16", "pcm-s24", "pcm-s32", "pcm-f32", "pcm-f64", "pcm-u8", "ulaw", "alaw"].includes(codec)
         )
       ];
     }
@@ -37423,32 +37451,39 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         assert(encodingConfig.transform);
         let needsRerender = width !== originalWidth || height !== originalHeight || totalRotation !== 0 && (!canUseRotationMetadata || trackOptions.process !== void 0) || !!crop || squarePixelWidth !== await track.getCodedWidth() || squarePixelHeight !== await track.getCodedHeight();
         if (!needsRerender) {
-          const tempOutput = new Output({
-            format: new Mp4OutputFormat(),
-            // Supports all video codecs
-            target: new NullTarget()
-          });
-          const tempSource = new VideoSampleSource(encodingConfig);
-          tempOutput.addVideoTrack(tempSource);
-          await tempOutput.start();
-          const sink = new VideoSampleSink(track);
-          const firstSample = await sink.getSample(firstTimestamp);
-          if (firstSample) {
-            try {
-              await tempSource.add(firstSample);
-              firstSample.close();
-              await tempOutput.finalize();
-            } catch (error) {
-              Logging._warn(
-                "An error occurred when probing encoder support. Falling back to rerender path.",
-                error
-              );
-              void tempOutput.cancel();
-              needsRerender = true;
-              encodingConfig.transform.force = true;
+          var _stack = [];
+          try {
+            const tempOutput = new Output({
+              format: new Mp4OutputFormat(),
+              // Supports all video codecs
+              target: new NullTarget()
+            });
+            const tempSource = new VideoSampleSource(encodingConfig);
+            tempOutput.addVideoTrack(tempSource);
+            await tempOutput.start();
+            const sink = new VideoSampleSink(track);
+            const firstSample = __using(_stack, await sink.getSample(firstTimestamp));
+            if (firstSample) {
+              try {
+                await tempSource.add(firstSample);
+                firstSample.close();
+                await tempOutput.finalize();
+              } catch (error) {
+                Logging._warn(
+                  "An error occurred when probing encoder support. Falling back to rerender path.",
+                  error
+                );
+                void tempOutput.cancel();
+                needsRerender = true;
+                encodingConfig.transform.force = true;
+              }
+            } else {
+              await tempOutput.cancel();
             }
-          } else {
-            await tempOutput.cancel();
+          } catch (_) {
+            var _error = _, _hasError = true;
+          } finally {
+            __callDispose(_stack, _error, _hasError);
           }
         }
         if (trackOptions.frameRate) {
@@ -37475,21 +37510,28 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         this._trackPromises.push((async () => {
           await this._started;
           const sink = new VideoSampleSink(track);
-          for await (const sample of sink.samples(this._startTimestamp, this._endTimestamp)) {
-            if (this._canceled) {
+          for await (var _sample of sink.samples(this._startTimestamp, this._endTimestamp)) {
+            var _stack2 = [];
+            try {
+              const sample = __using(_stack2, _sample);
+              if (this._canceled) {
+                return;
+              }
+              const adjustedSampleTimestamp = Math.max(sample.timestamp - this._startTimestamp, 0);
+              sample.setTimestamp(adjustedSampleTimestamp);
+              this._reportProgress(outputTrackId, sample.timestamp + sample.duration);
+              await source.add(sample);
               sample.close();
-              return;
-            }
-            const adjustedSampleTimestamp = Math.max(sample.timestamp - this._startTimestamp, 0);
-            sample.setTimestamp(adjustedSampleTimestamp);
-            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);
+              if (lastSampleTimestamp !== null) {
+                if (this._synchronizer.shouldWait(outputTrackId, lastSampleTimestamp)) {
+                  await this._synchronizer.wait(lastSampleTimestamp);
+                }
               }
+            } catch (_2) {
+              var _error2 = _2, _hasError2 = true;
+            } finally {
+              __callDispose(_stack2, _error2, _hasError2);
             }
-            sample.close();
           }
           source.close();
           this._synchronizer.closeTrack(outputTrackId);
@@ -37630,50 +37672,75 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
         this._trackPromises.push((async () => {
           await this._started;
           const sink = new AudioSampleSink(track);
-          for await (let sample of sink.samples(this._startTimestamp, this._endTimestamp)) {
-            if (this._canceled) {
-              sample.close();
-              return;
-            }
-            if (needsPadding) {
-              const paddingLength = firstTimestamp - this._startTimestamp;
-              const paddingLengthSamples = Math.round(paddingLength * originalSampleRate);
-              const bytesPerSample = getBytesPerSample(sample.format);
-              const data = new Uint8Array(bytesPerSample * paddingLengthSamples * originalNumberOfChannels);
-              if (sample.format === "u8" || sample.format === "u8-planar") {
-                data.fill(2 ** 7);
-              }
-              const silentSample = new AudioSample({
-                data,
-                // Use the same format the decoder is spitting out. This avoids feeding changing sample
-                // formats to the audio encoder.
-                format: sample.format,
-                numberOfChannels: originalNumberOfChannels,
-                sampleRate: originalSampleRate,
-                timestamp: 0
-              });
-              await this._registerAudioSample(silentSample, source, outputTrackId, () => lastSampleTimestamp);
-              needsPadding = false;
-            }
-            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();
-                continue;
+          for await (var _sample of sink.samples(this._startTimestamp, this._endTimestamp)) {
+            var _stack3 = [];
+            try {
+              const sample = __using(_stack3, _sample);
+              var _stack2 = [];
+              try {
+                if (this._canceled) {
+                  return;
+                }
+                if (needsPadding) {
+                  var _stack = [];
+                  try {
+                    const paddingLength = firstTimestamp - this._startTimestamp;
+                    const paddingLengthSamples = Math.round(paddingLength * originalSampleRate);
+                    const bytesPerSample = getBytesPerSample(sample.format);
+                    const data = new Uint8Array(bytesPerSample * paddingLengthSamples * originalNumberOfChannels);
+                    if (sample.format === "u8" || sample.format === "u8-planar") {
+                      data.fill(2 ** 7);
+                    }
+                    const silentSample = __using(_stack, new AudioSample({
+                      data,
+                      // Use the same format the decoder is spitting out. This avoids feeding changing sample
+                      // formats to the audio encoder.
+                      format: sample.format,
+                      numberOfChannels: originalNumberOfChannels,
+                      sampleRate: originalSampleRate,
+                      timestamp: 0
+                    }));
+                    await this._registerAudioSample(silentSample, source, outputTrackId, () => lastSampleTimestamp);
+                    needsPadding = false;
+                  } catch (_) {
+                    var _error = _, _hasError = true;
+                  } finally {
+                    __callDispose(_stack, _error, _hasError);
+                  }
+                }
+                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);
+                }
+                let finalSampleLet;
+                if (startFrame > 0 || endFrame < sample.numberOfFrames) {
+                  const trimmedSample = sample.trim(startFrame, endFrame);
+                  sample.close();
+                  finalSampleLet = trimmedSample;
+                  if (trimmedSample.numberOfFrames === 0) {
+                    trimmedSample.close();
+                    continue;
+                  }
+                } else {
+                  finalSampleLet = sample;
+                }
+                const finalSample = __using(_stack2, finalSampleLet);
+                finalSample.setTimestamp(finalSample.timestamp - this._startTimestamp);
+                await this._registerAudioSample(finalSample, source, outputTrackId, () => lastSampleTimestamp);
+              } catch (_2) {
+                var _error2 = _2, _hasError2 = true;
+              } finally {
+                __callDispose(_stack2, _error2, _hasError2);
               }
+            } catch (_3) {
+              var _error3 = _3, _hasError3 = true;
+            } finally {
+              __callDispose(_stack3, _error3, _hasError3);
             }
-            sample.setTimestamp(sample.timestamp - this._startTimestamp);
-            await this._registerAudioSample(sample, source, outputTrackId, () => lastSampleTimestamp);
           }
           source.close();
           this._synchronizer.closeTrack(outputTrackId);