mediabunny 1.3.2 → 1.4.0

package/dist/bundles/mediabunny.cjs

@@ -4433,6 +4433,106 @@ var Mediabunny = (() => {
     return string;
   };
 
+  // src/isobmff/isobmff-reader.ts
+  var MIN_BOX_HEADER_SIZE = 8;
+  var MAX_BOX_HEADER_SIZE = 16;
+  var IsobmffReader = class {
+    constructor(reader) {
+      this.reader = reader;
+      this.pos = 0;
+    }
+    readBytes(length) {
+      const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + length);
+      this.pos += length;
+      return new Uint8Array(view2.buffer, offset, length);
+    }
+    readU8() {
+      const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + 1);
+      this.pos++;
+      return view2.getUint8(offset);
+    }
+    readU16() {
+      const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + 2);
+      this.pos += 2;
+      return view2.getUint16(offset, false);
+    }
+    readI16() {
+      const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + 2);
+      this.pos += 2;
+      return view2.getInt16(offset, false);
+    }
+    readU24() {
+      const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + 3);
+      this.pos += 3;
+      const high = view2.getUint16(offset, false);
+      const low = view2.getUint8(offset + 2);
+      return high * 256 + low;
+    }
+    readU32() {
+      const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + 4);
+      this.pos += 4;
+      return view2.getUint32(offset, false);
+    }
+    readI32() {
+      const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + 4);
+      this.pos += 4;
+      return view2.getInt32(offset, false);
+    }
+    readU64() {
+      const high = this.readU32();
+      const low = this.readU32();
+      return high * 4294967296 + low;
+    }
+    readI64() {
+      const high = this.readI32();
+      const low = this.readU32();
+      return high * 4294967296 + low;
+    }
+    readF64() {
+      const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + 8);
+      this.pos += 8;
+      return view2.getFloat64(offset, false);
+    }
+    readFixed_16_16() {
+      return this.readI32() / 65536;
+    }
+    readFixed_2_30() {
+      return this.readI32() / 1073741824;
+    }
+    readAscii(length) {
+      const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + length);
+      this.pos += length;
+      let str = "";
+      for (let i = 0; i < length; i++) {
+        str += String.fromCharCode(view2.getUint8(offset + i));
+      }
+      return str;
+    }
+    readIsomVariableInteger() {
+      let result = 0;
+      for (let i = 0; i < 4; i++) {
+        result <<= 7;
+        const nextByte = this.readU8();
+        result |= nextByte & 127;
+        if ((nextByte & 128) === 0) {
+          break;
+        }
+      }
+      return result;
+    }
+    readBoxHeader() {
+      let totalSize = this.readU32();
+      const name = this.readAscii(4);
+      let headerSize = 8;
+      const hasLargeSize = totalSize === 1;
+      if (hasLargeSize) {
+        totalSize = this.readU64();
+        headerSize = 16;
+      }
+      return { name, totalSize, headerSize, contentSize: totalSize - headerSize };
+    }
+  };
+
   // src/isobmff/isobmff-muxer.ts
   var GLOBAL_TIMESCALE = 1e3;
   var TIMESTAMP_OFFSET = 2082844800;
@@ -5067,8 +5167,7 @@ var Mediabunny = (() => {
       const moofBox = moof(fragmentNumber, tracksInFragment);
       const moofOffset = this.writer.getPos();
       const mdatStartPos = moofOffset + this.boxWriter.measureBox(moofBox);
-      const mdatHeaderSize = 16;
-      let currentPos = mdatStartPos + mdatHeaderSize;
+      let currentPos = mdatStartPos + MIN_BOX_HEADER_SIZE;
       let fragmentStartTimestamp = Infinity;
       for (const trackData of tracksInFragment) {
         trackData.currentChunk.offset = currentPos;
@@ -5079,6 +5178,12 @@ var Mediabunny = (() => {
         fragmentStartTimestamp = Math.min(fragmentStartTimestamp, trackData.currentChunk.startTimestamp);
       }
       const mdatSize = currentPos - mdatStartPos;
+      const needsLargeMdatSize = mdatSize >= 2 ** 32;
+      if (needsLargeMdatSize) {
+        for (const trackData of tracksInFragment) {
+          trackData.currentChunk.offset += MAX_BOX_HEADER_SIZE - MIN_BOX_HEADER_SIZE;
+        }
+      }
       if (this.format._options.onMoof) {
         this.writer.startTrackingWrites();
       }
@@ -5092,10 +5197,10 @@ var Mediabunny = (() => {
       if (this.format._options.onMdat) {
         this.writer.startTrackingWrites();
       }
-      const mdatBox = mdat(mdatSize >= 2 ** 32);
+      const mdatBox = mdat(needsLargeMdatSize);
       mdatBox.size = mdatSize;
       this.boxWriter.writeBox(mdatBox);
-      this.writer.seek(mdatStartPos + mdatHeaderSize);
+      this.writer.seek(mdatStartPos + (needsLargeMdatSize ? MAX_BOX_HEADER_SIZE : MIN_BOX_HEADER_SIZE));
       for (const trackData of tracksInFragment) {
         for (const sample of trackData.currentChunk.samples) {
           this.writer.write(sample.data);
@@ -7981,6 +8086,46 @@ ${cue.notes ?? ""}`;
       }
       this.timestamp = newTimestamp;
     }
+    /**
+     * Creates AudioSamples from an AudioBuffer, starting at the given timestamp in seconds. Typically creates exactly
+     * one sample, but may create multiple if the AudioBuffer is exceedingly large.
+     */
+    static fromAudioBuffer(audioBuffer, timestamp) {
+      if (!(audioBuffer instanceof AudioBuffer)) {
+        throw new TypeError("audioBuffer must be an AudioBuffer.");
+      }
+      const MAX_FLOAT_COUNT = 64 * 1024 * 1024;
+      const numberOfChannels = audioBuffer.numberOfChannels;
+      const sampleRate = audioBuffer.sampleRate;
+      const totalFrames = audioBuffer.length;
+      const maxFramesPerChunk = Math.floor(MAX_FLOAT_COUNT / numberOfChannels);
+      let currentRelativeFrame = 0;
+      let remainingFrames = totalFrames;
+      const result = [];
+      while (remainingFrames > 0) {
+        const framesToCopy = Math.min(maxFramesPerChunk, remainingFrames);
+        const chunkData = new Float32Array(numberOfChannels * framesToCopy);
+        for (let channel = 0; channel < numberOfChannels; channel++) {
+          audioBuffer.copyFromChannel(
+            chunkData.subarray(channel * framesToCopy, channel * framesToCopy + framesToCopy),
+            channel,
+            currentRelativeFrame
+          );
+        }
+        const audioSample = new _AudioSample({
+          format: "f32-planar",
+          sampleRate,
+          numberOfFrames: framesToCopy,
+          numberOfChannels,
+          timestamp: timestamp + currentRelativeFrame / sampleRate,
+          data: chunkData
+        });
+        result.push(audioSample);
+        currentRelativeFrame += framesToCopy;
+        remainingFrames -= framesToCopy;
+      }
+      return result;
+    }
   };
   var getBytesPerSample = (format) => {
     switch (format) {
@@ -10386,7 +10531,7 @@ ${cue.notes ?? ""}`;
       }
     }
     /** @internal */
-    _start() {
+    async _start() {
     }
     /** @internal */
     async _flushAndClose() {
@@ -10516,60 +10661,66 @@ ${cue.notes ?? ""}`;
       this.encoderError = null;
     }
     async add(videoSample, shouldClose, encodeOptions) {
-      this.checkForEncoderError();
-      this.source._ensureValidAdd();
-      if (this.lastWidth !== null && this.lastHeight !== null) {
-        if (videoSample.codedWidth !== this.lastWidth || videoSample.codedHeight !== this.lastHeight) {
-          throw new Error(
-            `Video sample size must remain constant. Expected ${this.lastWidth}x${this.lastHeight}, got ${videoSample.codedWidth}x${videoSample.codedHeight}.`
-          );
-        }
-      } else {
-        this.lastWidth = videoSample.codedWidth;
-        this.lastHeight = videoSample.codedHeight;
-      }
-      if (!this.encoderInitialized) {
-        if (!this.ensureEncoderPromise) {
-          void this.ensureEncoder(videoSample);
+      try {
+        this.checkForEncoderError();
+        this.source._ensureValidAdd();
+        if (this.lastWidth !== null && this.lastHeight !== null) {
+          if (videoSample.codedWidth !== this.lastWidth || videoSample.codedHeight !== this.lastHeight) {
+            throw new Error(
+              `Video sample size must remain constant. Expected ${this.lastWidth}x${this.lastHeight}, got ${videoSample.codedWidth}x${videoSample.codedHeight}.`
+            );
+          }
+        } else {
+          this.lastWidth = videoSample.codedWidth;
+          this.lastHeight = videoSample.codedHeight;
         }
         if (!this.encoderInitialized) {
-          await this.ensureEncoderPromise;
+          if (!this.ensureEncoderPromise) {
+            void this.ensureEncoder(videoSample);
+          }
+          if (!this.encoderInitialized) {
+            await this.ensureEncoderPromise;
+          }
         }
-      }
-      assert(this.encoderInitialized);
-      const keyFrameInterval = this.encodingConfig.keyFrameInterval ?? 5;
-      const multipleOfKeyFrameInterval = Math.floor(videoSample.timestamp / keyFrameInterval);
-      const finalEncodeOptions = {
-        ...encodeOptions,
-        keyFrame: encodeOptions?.keyFrame || keyFrameInterval === 0 || multipleOfKeyFrameInterval !== this.lastMultipleOfKeyFrameInterval
-      };
-      this.lastMultipleOfKeyFrameInterval = multipleOfKeyFrameInterval;
-      if (this.customEncoder) {
-        this.customEncoderQueueSize++;
-        const promise = this.customEncoderCallSerializer.call(() => this.customEncoder.encode(videoSample, finalEncodeOptions)).then(() => {
-          this.customEncoderQueueSize--;
+        assert(this.encoderInitialized);
+        const keyFrameInterval = this.encodingConfig.keyFrameInterval ?? 5;
+        const multipleOfKeyFrameInterval = Math.floor(videoSample.timestamp / keyFrameInterval);
+        const finalEncodeOptions = {
+          ...encodeOptions,
+          keyFrame: encodeOptions?.keyFrame || keyFrameInterval === 0 || multipleOfKeyFrameInterval !== this.lastMultipleOfKeyFrameInterval
+        };
+        this.lastMultipleOfKeyFrameInterval = multipleOfKeyFrameInterval;
+        if (this.customEncoder) {
+          this.customEncoderQueueSize++;
+          const promise = this.customEncoderCallSerializer.call(() => this.customEncoder.encode(videoSample, finalEncodeOptions)).then(() => {
+            this.customEncoderQueueSize--;
+            if (shouldClose) {
+              videoSample.close();
+            }
+          }).catch((error) => {
+            this.encoderError ??= error;
+          });
+          if (this.customEncoderQueueSize >= 4) {
+            await promise;
+          }
+        } else {
+          assert(this.encoder);
+          const videoFrame = videoSample.toVideoFrame();
+          this.encoder.encode(videoFrame, finalEncodeOptions);
+          videoFrame.close();
           if (shouldClose) {
             videoSample.close();
           }
-        }).catch((error) => {
-          this.encoderError ??= error;
-        });
-        if (this.customEncoderQueueSize >= 4) {
-          await promise;
+          if (this.encoder.encodeQueueSize >= 4) {
+            await new Promise((resolve) => this.encoder.addEventListener("dequeue", resolve, { once: true }));
+          }
         }
-      } else {
-        assert(this.encoder);
-        const videoFrame = videoSample.toVideoFrame();
-        this.encoder.encode(videoFrame, finalEncodeOptions);
-        videoFrame.close();
+        await this.muxer.mutex.currentPromise;
+      } finally {
         if (shouldClose) {
           videoSample.close();
         }
-        if (this.encoder.encodeQueueSize >= 4) {
-          await new Promise((resolve) => this.encoder.addEventListener("dequeue", resolve, { once: true }));
-        }
       }
-      await this.muxer.mutex.currentPromise;
     }
     async ensureEncoder(videoSample) {
       if (this.encoder) {
@@ -10735,36 +10886,94 @@ ${cue.notes ?? ""}`;
       super(encodingConfig.codec);
       /** @internal */
       this._abortController = null;
+      /** @internal */
+      this._workerTrackId = null;
+      /** @internal */
+      this._workerListener = null;
+      /** @internal */
+      this._promiseWithResolvers = promiseWithResolvers();
+      /** @internal */
+      this._errorPromiseAccessed = false;
       this._encoder = new VideoEncoderWrapper(this, encodingConfig);
       this._track = track;
     }
+    /** A promise that rejects upon any error within this source. This promise never resolves. */
+    get errorPromise() {
+      this._errorPromiseAccessed = true;
+      return this._promiseWithResolvers.promise;
+    }
     /** @internal */
-    _start() {
+    async _start() {
+      if (!this._errorPromiseAccessed) {
+        console.warn(
+          "Make sure not to ignore the `errorPromise` field on MediaStreamVideoTrackSource, so that any internal errors get bubbled up properly."
+        );
+      }
       this._abortController = new AbortController();
-      let frameReceived = false;
-      const processor = new MediaStreamTrackProcessor({ track: this._track });
-      const consumer = new WritableStream({
-        write: (videoFrame) => {
-          if (!frameReceived) {
-            setMediaStreamTimestampOffset(this, videoFrame);
-            frameReceived = true;
-          }
-          if (this._encoder.getQueueSize() >= 4) {
-            videoFrame.close();
-            return;
+      let firstVideoFrameTimestamp = null;
+      let errored = false;
+      const onVideoFrame = (videoFrame) => {
+        if (errored) {
+          videoFrame.close();
+          return;
+        }
+        if (firstVideoFrameTimestamp === null) {
+          firstVideoFrameTimestamp = videoFrame.timestamp / 1e6;
+          const muxer = this._connectedTrack.output._muxer;
+          if (muxer.firstMediaStreamTimestamp === null) {
+            muxer.firstMediaStreamTimestamp = performance.now() / 1e3;
+            this._timestampOffset = -firstVideoFrameTimestamp;
+          } else {
+            this._timestampOffset = performance.now() / 1e3 - muxer.firstMediaStreamTimestamp - firstVideoFrameTimestamp;
           }
-          void this._encoder.add(new VideoSample(videoFrame), true).catch((error) => {
-            this._abortController?.abort();
-            throw error;
-          });
         }
-      });
-      processor.readable.pipeTo(consumer, {
-        signal: this._abortController.signal
-      }).catch((err) => {
-        if (err instanceof DOMException && err.name === "AbortError") return;
-        console.error("Pipe error:", err);
-      });
+        if (this._encoder.getQueueSize() >= 4) {
+          videoFrame.close();
+          return;
+        }
+        void this._encoder.add(new VideoSample(videoFrame), true).catch((error) => {
+          errored = true;
+          this._abortController?.abort();
+          this._promiseWithResolvers.reject(error);
+          if (this._workerTrackId !== null) {
+            sendMessageToMediaStreamTrackProcessorWorker({
+              type: "stopTrack",
+              trackId: this._workerTrackId
+            });
+          }
+        });
+      };
+      if (typeof MediaStreamTrackProcessor !== "undefined") {
+        const processor = new MediaStreamTrackProcessor({ track: this._track });
+        const consumer = new WritableStream({ write: onVideoFrame });
+        processor.readable.pipeTo(consumer, {
+          signal: this._abortController.signal
+        }).catch((error) => {
+          if (error instanceof DOMException && error.name === "AbortError") return;
+          this._promiseWithResolvers.reject(error);
+        });
+      } else {
+        const supportedInWorker = await mediaStreamTrackProcessorIsSupportedInWorker();
+        if (supportedInWorker) {
+          this._workerTrackId = nextMediaStreamTrackProcessorWorkerId++;
+          sendMessageToMediaStreamTrackProcessorWorker({
+            type: "videoTrack",
+            trackId: this._workerTrackId,
+            track: this._track
+          }, [this._track]);
+          this._workerListener = (event) => {
+            const message = event.data;
+            if (message.type === "videoFrame" && message.trackId === this._workerTrackId) {
+              onVideoFrame(message.videoFrame);
+            } else if (message.type === "error" && message.trackId === this._workerTrackId) {
+              this._promiseWithResolvers.reject(message.error);
+            }
+          };
+          mediaStreamTrackProcessorWorker.addEventListener("message", this._workerListener);
+        } else {
+          throw new Error("MediaStreamTrackProcessor is required but not supported by this browser.");
+        }
+      }
     }
     /** @internal */
     async _flushAndClose() {
@@ -10772,6 +10981,25 @@ ${cue.notes ?? ""}`;
         this._abortController.abort();
         this._abortController = null;
       }
+      if (this._workerTrackId !== null) {
+        assert(this._workerListener);
+        sendMessageToMediaStreamTrackProcessorWorker({
+          type: "stopTrack",
+          trackId: this._workerTrackId
+        });
+        await new Promise((resolve) => {
+          const listener = (event) => {
+            const message = event.data;
+            if (message.type === "trackStopped" && message.trackId === this._workerTrackId) {
+              assert(this._workerListener);
+              mediaStreamTrackProcessorWorker.removeEventListener("message", this._workerListener);
+              mediaStreamTrackProcessorWorker.removeEventListener("message", listener);
+              resolve();
+            }
+          };
+          mediaStreamTrackProcessorWorker.addEventListener("message", listener);
+        });
+      }
       await this._encoder.flushAndClose();
     }
   };
@@ -10865,55 +11093,61 @@ ${cue.notes ?? ""}`;
       this.encoderError = null;
     }
     async add(audioSample, shouldClose) {
-      this.checkForEncoderError();
-      this.source._ensureValidAdd();
-      if (this.lastNumberOfChannels !== null && this.lastSampleRate !== null) {
-        if (audioSample.numberOfChannels !== this.lastNumberOfChannels || audioSample.sampleRate !== this.lastSampleRate) {
-          throw new Error(
-            `Audio parameters must remain constant. Expected ${this.lastNumberOfChannels} channels at ${this.lastSampleRate} Hz, got ${audioSample.numberOfChannels} channels at ${audioSample.sampleRate} Hz.`
-          );
-        }
-      } else {
-        this.lastNumberOfChannels = audioSample.numberOfChannels;
-        this.lastSampleRate = audioSample.sampleRate;
-      }
-      if (!this.encoderInitialized) {
-        if (!this.ensureEncoderPromise) {
-          void this.ensureEncoder(audioSample);
+      try {
+        this.checkForEncoderError();
+        this.source._ensureValidAdd();
+        if (this.lastNumberOfChannels !== null && this.lastSampleRate !== null) {
+          if (audioSample.numberOfChannels !== this.lastNumberOfChannels || audioSample.sampleRate !== this.lastSampleRate) {
+            throw new Error(
+              `Audio parameters must remain constant. Expected ${this.lastNumberOfChannels} channels at ${this.lastSampleRate} Hz, got ${audioSample.numberOfChannels} channels at ${audioSample.sampleRate} Hz.`
+            );
+          }
+        } else {
+          this.lastNumberOfChannels = audioSample.numberOfChannels;
+          this.lastSampleRate = audioSample.sampleRate;
         }
         if (!this.encoderInitialized) {
-          await this.ensureEncoderPromise;
+          if (!this.ensureEncoderPromise) {
+            void this.ensureEncoder(audioSample);
+          }
+          if (!this.encoderInitialized) {
+            await this.ensureEncoderPromise;
+          }
         }
-      }
-      assert(this.encoderInitialized);
-      if (this.customEncoder) {
-        this.customEncoderQueueSize++;
-        const promise = this.customEncoderCallSerializer.call(() => this.customEncoder.encode(audioSample)).then(() => {
-          this.customEncoderQueueSize--;
+        assert(this.encoderInitialized);
+        if (this.customEncoder) {
+          this.customEncoderQueueSize++;
+          const promise = this.customEncoderCallSerializer.call(() => this.customEncoder.encode(audioSample)).then(() => {
+            this.customEncoderQueueSize--;
+            if (shouldClose) {
+              audioSample.close();
+            }
+          }).catch((error) => {
+            this.encoderError ??= error;
+          });
+          if (this.customEncoderQueueSize >= 4) {
+            await promise;
+          }
+          await this.muxer.mutex.currentPromise;
+        } else if (this.isPcmEncoder) {
+          await this.doPcmEncoding(audioSample, shouldClose);
+        } else {
+          assert(this.encoder);
+          const audioData = audioSample.toAudioData();
+          this.encoder.encode(audioData);
+          audioData.close();
           if (shouldClose) {
             audioSample.close();
           }
-        }).catch((error) => {
-          this.encoderError ??= error;
-        });
-        if (this.customEncoderQueueSize >= 4) {
-          await promise;
+          if (this.encoder.encodeQueueSize >= 4) {
+            await new Promise((resolve) => this.encoder.addEventListener("dequeue", resolve, { once: true }));
+          }
+          await this.muxer.mutex.currentPromise;
         }
-        await this.muxer.mutex.currentPromise;
-      } else if (this.isPcmEncoder) {
-        await this.doPcmEncoding(audioSample, shouldClose);
-      } else {
-        assert(this.encoder);
-        const audioData = audioSample.toAudioData();
-        this.encoder.encode(audioData);
-        audioData.close();
+      } finally {
         if (shouldClose) {
           audioSample.close();
         }
-        if (this.encoder.encodeQueueSize >= 4) {
-          await new Promise((resolve) => this.encoder.addEventListener("dequeue", resolve, { once: true }));
-        }
-        await this.muxer.mutex.currentPromise;
       }
     }
     async doPcmEncoding(audioSample, shouldClose) {
@@ -11185,7 +11419,7 @@ ${cue.notes ?? ""}`;
       validateAudioEncodingConfig(encodingConfig);
       super(encodingConfig.codec);
       /** @internal */
-      this._accumulatedFrameCount = 0;
+      this._accumulatedTime = 0;
       this._encoder = new AudioEncoderWrapper(this, encodingConfig);
     }
     /**
@@ -11200,37 +11434,9 @@ ${cue.notes ?? ""}`;
       if (!(audioBuffer instanceof AudioBuffer)) {
         throw new TypeError("audioBuffer must be an AudioBuffer.");
       }
-      const MAX_FLOAT_COUNT = 64 * 1024 * 1024;
-      const numberOfChannels = audioBuffer.numberOfChannels;
-      const sampleRate = audioBuffer.sampleRate;
-      const totalFrames = audioBuffer.length;
-      const maxFramesPerChunk = Math.floor(MAX_FLOAT_COUNT / numberOfChannels);
-      let currentRelativeFrame = 0;
-      let remainingFrames = totalFrames;
-      const promises = [];
-      while (remainingFrames > 0) {
-        const framesToCopy = Math.min(maxFramesPerChunk, remainingFrames);
-        const chunkData = new Float32Array(numberOfChannels * framesToCopy);
-        for (let channel = 0; channel < numberOfChannels; channel++) {
-          audioBuffer.copyFromChannel(
-            chunkData.subarray(channel * framesToCopy, channel * framesToCopy + framesToCopy),
-            channel,
-            currentRelativeFrame
-          );
-        }
-        const audioSample = new AudioSample({
-          format: "f32-planar",
-          sampleRate,
-          numberOfFrames: framesToCopy,
-          numberOfChannels,
-          timestamp: (this._accumulatedFrameCount + currentRelativeFrame) / sampleRate,
-          data: chunkData
-        });
-        promises.push(this._encoder.add(audioSample, true));
-        currentRelativeFrame += framesToCopy;
-        remainingFrames -= framesToCopy;
-      }
-      this._accumulatedFrameCount += totalFrames;
+      const audioSamples = AudioSample.fromAudioBuffer(audioBuffer, this._accumulatedTime);
+      const promises = audioSamples.map((sample) => this._encoder.add(sample, true));
+      this._accumulatedTime += audioBuffer.duration;
       return Promise.all(promises);
     }
     /** @internal */
@@ -11247,36 +11453,97 @@ ${cue.notes ?? ""}`;
       super(encodingConfig.codec);
       /** @internal */
       this._abortController = null;
+      /** @internal */
+      this._audioContext = null;
+      /** @internal */
+      this._scriptProcessorNode = null;
+      // Deprecated but goated
+      /** @internal */
+      this._promiseWithResolvers = promiseWithResolvers();
+      /** @internal */
+      this._errorPromiseAccessed = false;
       this._encoder = new AudioEncoderWrapper(this, encodingConfig);
       this._track = track;
     }
+    /** A promise that rejects upon any error within this source. This promise never resolves. */
+    get errorPromise() {
+      this._errorPromiseAccessed = true;
+      return this._promiseWithResolvers.promise;
+    }
     /** @internal */
-    _start() {
+    async _start() {
+      if (!this._errorPromiseAccessed) {
+        console.warn(
+          "Make sure not to ignore the `errorPromise` field on MediaStreamVideoTrackSource, so that any internal errors get bubbled up properly."
+        );
+      }
       this._abortController = new AbortController();
-      let dataReceived = false;
-      const processor = new MediaStreamTrackProcessor({ track: this._track });
-      const consumer = new WritableStream({
-        write: (audioData) => {
-          if (!dataReceived) {
-            setMediaStreamTimestampOffset(this, audioData);
-            dataReceived = true;
-          }
-          if (this._encoder.getQueueSize() >= 4) {
-            audioData.close();
-            return;
+      if (typeof MediaStreamTrackProcessor !== "undefined") {
+        let firstAudioDataTimestamp = null;
+        const processor = new MediaStreamTrackProcessor({ track: this._track });
+        const consumer = new WritableStream({
+          write: (audioData) => {
+            if (firstAudioDataTimestamp === null) {
+              firstAudioDataTimestamp = audioData.timestamp / 1e6;
+              const muxer = this._connectedTrack.output._muxer;
+              if (muxer.firstMediaStreamTimestamp === null) {
+                muxer.firstMediaStreamTimestamp = performance.now() / 1e3;
+                this._timestampOffset = -firstAudioDataTimestamp;
+              } else {
+                this._timestampOffset = performance.now() / 1e3 - muxer.firstMediaStreamTimestamp - firstAudioDataTimestamp;
+              }
+            }
+            if (this._encoder.getQueueSize() >= 4) {
+              audioData.close();
+              return;
+            }
+            void this._encoder.add(new AudioSample(audioData), true).catch((error) => {
+              this._abortController?.abort();
+              this._promiseWithResolvers.reject(error);
+            });
           }
-          void this._encoder.add(new AudioSample(audioData), true).catch((error) => {
-            this._abortController?.abort();
-            throw error;
-          });
-        }
-      });
-      processor.readable.pipeTo(consumer, {
-        signal: this._abortController.signal
-      }).catch((err) => {
-        if (err instanceof DOMException && err.name === "AbortError") return;
-        console.error("Pipe error:", err);
-      });
+        });
+        processor.readable.pipeTo(consumer, {
+          signal: this._abortController.signal
+        }).catch((error) => {
+          if (error instanceof DOMException && error.name === "AbortError") return;
+          this._promiseWithResolvers.reject(error);
+        });
+      } else {
+        this._audioContext = new AudioContext({ sampleRate: this._track.getSettings().sampleRate });
+        const sourceNode = this._audioContext.createMediaStreamSource(new MediaStream([this._track]));
+        this._scriptProcessorNode = this._audioContext.createScriptProcessor(4096);
+        if (this._audioContext.state === "suspended") {
+          await this._audioContext.resume();
+        }
+        sourceNode.connect(this._scriptProcessorNode);
+        this._scriptProcessorNode.connect(this._audioContext.destination);
+        let audioReceived = false;
+        let totalDuration = 0;
+        this._scriptProcessorNode.onaudioprocess = (event) => {
+          const audioSamples = AudioSample.fromAudioBuffer(event.inputBuffer, totalDuration);
+          totalDuration += event.inputBuffer.duration;
+          for (const audioSample of audioSamples) {
+            if (!audioReceived) {
+              audioReceived = true;
+              const muxer = this._connectedTrack.output._muxer;
+              if (muxer.firstMediaStreamTimestamp === null) {
+                muxer.firstMediaStreamTimestamp = performance.now() / 1e3;
+              } else {
+                this._timestampOffset = performance.now() / 1e3 - muxer.firstMediaStreamTimestamp;
+              }
+            }
+            if (this._encoder.getQueueSize() >= 4) {
+              audioSample.close();
+              continue;
+            }
+            void this._encoder.add(audioSample, true).catch((error) => {
+              void this._audioContext.suspend();
+              this._promiseWithResolvers.reject(error);
+            });
+          }
+        };
+      }
     }
     /** @internal */
     async _flushAndClose() {
@@ -11284,17 +11551,120 @@ ${cue.notes ?? ""}`;
         this._abortController.abort();
         this._abortController = null;
       }
+      if (this._audioContext) {
+        assert(this._scriptProcessorNode);
+        this._scriptProcessorNode.disconnect();
+        await this._audioContext.suspend();
+      }
       await this._encoder.flushAndClose();
     }
   };
-  var setMediaStreamTimestampOffset = (source, sample) => {
-    const timestampInSeconds = sample.timestamp / 1e6;
-    assert(source._connectedTrack);
-    const muxer = source._connectedTrack.output._muxer;
-    if (muxer.firstMediaStreamTimestamp === null) {
-      muxer.firstMediaStreamTimestamp = timestampInSeconds;
+  var mediaStreamTrackProcessorWorkerCode = () => {
+    const sendMessage = (message, transfer) => {
+      if (transfer) {
+        self.postMessage(message, transfer);
+      } else {
+        self.postMessage(message);
+      }
+    };
+    sendMessage({
+      type: "support",
+      supported: typeof MediaStreamTrackProcessor !== "undefined"
+    });
+    const abortControllers = /* @__PURE__ */ new Map();
+    const stoppedTracks = /* @__PURE__ */ new Set();
+    self.addEventListener("message", (event) => {
+      const message = event.data;
+      switch (message.type) {
+        case "videoTrack":
+          {
+            const processor = new MediaStreamTrackProcessor({ track: message.track });
+            const consumer = new WritableStream({
+              write: (videoFrame) => {
+                if (stoppedTracks.has(message.trackId)) {
+                  videoFrame.close();
+                  return;
+                }
+                sendMessage({
+                  type: "videoFrame",
+                  trackId: message.trackId,
+                  videoFrame
+                }, [videoFrame]);
+              }
+            });
+            const abortController = new AbortController();
+            abortControllers.set(message.trackId, abortController);
+            processor.readable.pipeTo(consumer, {
+              signal: abortController.signal
+            }).catch((error) => {
+              if (error instanceof DOMException && error.name === "AbortError") return;
+              sendMessage({
+                type: "error",
+                trackId: message.trackId,
+                error
+              });
+            });
+          }
+          ;
+          break;
+        case "stopTrack":
+          {
+            const abortController = abortControllers.get(message.trackId);
+            if (abortController) {
+              abortController.abort();
+              abortControllers.delete(message.trackId);
+            }
+            stoppedTracks.add(message.trackId);
+            sendMessage({
+              type: "trackStopped",
+              trackId: message.trackId
+            });
+          }
+          ;
+          break;
+        default:
+          assertNever(message);
+      }
+    });
+  };
+  var nextMediaStreamTrackProcessorWorkerId = 0;
+  var mediaStreamTrackProcessorWorker = null;
+  var initMediaStreamTrackProcessorWorker = () => {
+    const blob = new Blob(
+      [`(${mediaStreamTrackProcessorWorkerCode.toString()})()`],
+      { type: "application/javascript" }
+    );
+    const url2 = URL.createObjectURL(blob);
+    mediaStreamTrackProcessorWorker = new Worker(url2);
+  };
+  var mediaStreamTrackProcessorIsSupportedInWorkerCache = null;
+  var mediaStreamTrackProcessorIsSupportedInWorker = async () => {
+    if (mediaStreamTrackProcessorIsSupportedInWorkerCache !== null) {
+      return mediaStreamTrackProcessorIsSupportedInWorkerCache;
+    }
+    if (!mediaStreamTrackProcessorWorker) {
+      initMediaStreamTrackProcessorWorker();
+    }
+    return new Promise((resolve) => {
+      assert(mediaStreamTrackProcessorWorker);
+      const listener = (event) => {
+        const message = event.data;
+        if (message.type === "support") {
+          mediaStreamTrackProcessorIsSupportedInWorkerCache = message.supported;
+          mediaStreamTrackProcessorWorker.removeEventListener("message", listener);
+          resolve(message.supported);
+        }
+      };
+      mediaStreamTrackProcessorWorker.addEventListener("message", listener);
+    });
+  };
+  var sendMessageToMediaStreamTrackProcessorWorker = (message, transfer) => {
+    assert(mediaStreamTrackProcessorWorker);
+    if (transfer) {
+      mediaStreamTrackProcessorWorker.postMessage(message, transfer);
+    } else {
+      mediaStreamTrackProcessorWorker.postMessage(message);
     }
-    source._timestampOffset = -Math.min(muxer.firstMediaStreamTimestamp, timestampInSeconds);
   };
   var SubtitleSource = class extends MediaSource {
     constructor(codec) {
@@ -11516,9 +11886,8 @@ ${cue.notes ?? ""}`;
         this._writer.start();
         const release = await this._mutex.acquire();
         await this._muxer.start();
-        for (const track of this._tracks) {
-          track.source._start();
-        }
+        const promises = this._tracks.map((track) => track.source._start());
+        await Promise.all(promises);
         release();
       })();
     }
@@ -11761,106 +12130,6 @@ ${cue.notes ?? ""}`;
     }
   };
 
-  // src/isobmff/isobmff-reader.ts
-  var MIN_BOX_HEADER_SIZE = 8;
-  var MAX_BOX_HEADER_SIZE = 16;
-  var IsobmffReader = class {
-    constructor(reader) {
-      this.reader = reader;
-      this.pos = 0;
-    }
-    readBytes(length) {
-      const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + length);
-      this.pos += length;
-      return new Uint8Array(view2.buffer, offset, length);
-    }
-    readU8() {
-      const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + 1);
-      this.pos++;
-      return view2.getUint8(offset);
-    }
-    readU16() {
-      const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + 2);
-      this.pos += 2;
-      return view2.getUint16(offset, false);
-    }
-    readI16() {
-      const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + 2);
-      this.pos += 2;
-      return view2.getInt16(offset, false);
-    }
-    readU24() {
-      const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + 3);
-      this.pos += 3;
-      const high = view2.getUint16(offset, false);
-      const low = view2.getUint8(offset + 2);
-      return high * 256 + low;
-    }
-    readU32() {
-      const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + 4);
-      this.pos += 4;
-      return view2.getUint32(offset, false);
-    }
-    readI32() {
-      const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + 4);
-      this.pos += 4;
-      return view2.getInt32(offset, false);
-    }
-    readU64() {
-      const high = this.readU32();
-      const low = this.readU32();
-      return high * 4294967296 + low;
-    }
-    readI64() {
-      const high = this.readI32();
-      const low = this.readU32();
-      return high * 4294967296 + low;
-    }
-    readF64() {
-      const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + 8);
-      this.pos += 8;
-      return view2.getFloat64(offset, false);
-    }
-    readFixed_16_16() {
-      return this.readI32() / 65536;
-    }
-    readFixed_2_30() {
-      return this.readI32() / 1073741824;
-    }
-    readAscii(length) {
-      const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + length);
-      this.pos += length;
-      let str = "";
-      for (let i = 0; i < length; i++) {
-        str += String.fromCharCode(view2.getUint8(offset + i));
-      }
-      return str;
-    }
-    readIsomVariableInteger() {
-      let result = 0;
-      for (let i = 0; i < 4; i++) {
-        result <<= 7;
-        const nextByte = this.readU8();
-        result |= nextByte & 127;
-        if ((nextByte & 128) === 0) {
-          break;
-        }
-      }
-      return result;
-    }
-    readBoxHeader() {
-      let totalSize = this.readU32();
-      const name = this.readAscii(4);
-      let headerSize = 8;
-      const hasLargeSize = totalSize === 1;
-      if (hasLargeSize) {
-        totalSize = this.readU64();
-        headerSize = 16;
-      }
-      return { name, totalSize, headerSize, contentSize: totalSize - headerSize };
-    }
-  };
-
   // src/isobmff/isobmff-demuxer.ts
   var IsobmffDemuxer = class extends Demuxer {
     constructor(input) {