mediabunny 1.47.0 → 1.48.0

package/dist/bundles/mediabunny.cjs

@@ -7578,6 +7578,9 @@ var Mediabunny = (() => {
     isRelativeToUnixEpoch() {
       return false;
     }
+    getUnixTimeForTimestamp() {
+      return null;
+    }
     getDisposition() {
       return this.internalTrack.disposition;
     }
@@ -10455,6 +10458,9 @@ var Mediabunny = (() => {
     isRelativeToUnixEpoch() {
       return false;
     }
+    getUnixTimeForTimestamp() {
+      return null;
+    }
     getDisposition() {
       return this.internalTrack.disposition;
     }
@@ -11075,6 +11081,9 @@ var Mediabunny = (() => {
     isRelativeToUnixEpoch() {
       return false;
     }
+    getUnixTimeForTimestamp() {
+      return null;
+    }
     getPairingMask() {
       return 1n;
     }
@@ -11643,6 +11652,9 @@ var Mediabunny = (() => {
     isRelativeToUnixEpoch() {
       return false;
     }
+    getUnixTimeForTimestamp() {
+      return null;
+    }
     getPairingMask() {
       return 1n;
     }
@@ -12415,6 +12427,9 @@ var Mediabunny = (() => {
     isRelativeToUnixEpoch() {
       return false;
     }
+    getUnixTimeForTimestamp() {
+      return null;
+    }
     getPairingMask() {
       return 1n;
     }
@@ -12713,6 +12728,9 @@ var Mediabunny = (() => {
     isRelativeToUnixEpoch() {
       return false;
     }
+    getUnixTimeForTimestamp() {
+      return null;
+    }
     getPairingMask() {
       return 1n;
     }
@@ -13333,6 +13351,9 @@ var Mediabunny = (() => {
     isRelativeToUnixEpoch() {
       return false;
     }
+    getUnixTimeForTimestamp() {
+      return null;
+    }
     getPairingMask() {
       return 1n;
     }
@@ -14201,6 +14222,9 @@ var Mediabunny = (() => {
     isRelativeToUnixEpoch() {
       return false;
     }
+    getUnixTimeForTimestamp() {
+      return null;
+    }
     getPairingMask() {
       return 1n;
     }
@@ -15239,6 +15263,15 @@ var Mediabunny = (() => {
       }
       return lastSegment.timestamp + lastSegment.duration;
     }
+    async getUnixTimeForTimestamp(timestamp) {
+      let segment = await this.getSegmentAt(timestamp, {});
+      segment ??= await this.getFirstSegment({});
+      if (!segment || segment.unixEpochTimestamp === null) {
+        return null;
+      }
+      const elapsed = timestamp - segment.timestamp;
+      return segment.unixEpochTimestamp + elapsed;
+    }
     async getTrackBackings() {
       return this.trackBackingsPromise ??= (async () => {
         const backings = [];
@@ -15396,7 +15429,10 @@ var Mediabunny = (() => {
     async isRelativeToUnixEpoch() {
       await this.hydrate();
       assert(this.segmentedInput.firstSegment);
-      return this.segmentedInput.firstSegment.relativeToUnixEpoch;
+      return this.segmentedInput.firstSegment.unixEpochTimestamp === this.segmentedInput.firstSegment.timestamp;
+    }
+    getUnixTimeForTimestamp(timestamp) {
+      return this.segmentedInput.getUnixTimeForTimestamp(timestamp);
     }
     getBitrate() {
       return this.delegate(() => this.firstInputTrack._backing.getBitrate());
@@ -15986,7 +16022,10 @@ var Mediabunny = (() => {
         throw new TypeError("options.fetchFn, when provided, must be a function.");
       }
       const urlString = url2 instanceof Request ? url2.url : url2 instanceof URL ? url2.href : url2;
-      super(urlString, (request) => new _UrlSource(request.path, this._options));
+      super(
+        urlString,
+        (request) => new _UrlSource(request.path, this._options)
+      );
       /** @internal */
       this._offset = 0;
       /** @internal */
@@ -16091,6 +16130,9 @@ var Mediabunny = (() => {
         if (!response.ok) {
           throw new Error(`Error fetching ${String(this._url)}: ${response.status} ${response.statusText}`);
         }
+        if (response.redirected) {
+          this.rootPath = response.url;
+        }
         outer:
           if (this._orchestrator.fileSize === null) {
             const contentRange = response.headers.get("Content-Range");
@@ -16751,6 +16793,12 @@ var Mediabunny = (() => {
           offset: innerStart
         });
       } else {
+        promise.catch((error) => {
+          if (this.disposed) {
+            return;
+          }
+          throw error;
+        });
       }
       return result;
     }
@@ -16835,11 +16883,11 @@ var Mediabunny = (() => {
         if (worker.pendingSlices.length > 0) {
           worker.pendingSlices.forEach((x) => x.reject(error));
           worker.pendingSlices.length = 0;
-        } else {
+        } else if (!worker.aborted && !this.disposed) {
           throw error;
         }
       }).finally(() => {
-        if (worker.running) {
+        if (worker.running || this.workers.length >= this.options.maxWorkerCount) {
           return;
         }
         if (this.queuedReads.length > 0) {
@@ -17152,6 +17200,7 @@ var Mediabunny = (() => {
       this.streamHasEnded = false;
       this.lastSegmentUpdateTime = -Infinity;
       this.refreshInterval = 5;
+      this.rootPath = path;
       this.demuxer = demuxer;
       this.nextLines = lines;
     }
@@ -17187,19 +17236,24 @@ var Mediabunny = (() => {
       if (!lines) {
         var _stack = [];
         try {
-          const ref = __using(_stack, await this.demuxer.input._getSourceUncached({ path: this.path, isRoot: false }));
+          const ref = __using(_stack, await this.demuxer.input._getSourceUncached({ path: this.rootPath, isRoot: false }));
           const reader = new Reader12(ref.source);
           const slice = await reader.requestEntireFile();
           assert(slice);
           lines = readAllLines(slice, slice.length, { ignore: canIgnoreLine });
+          if (ref.source instanceof PathedSource) {
+            this.rootPath = ref.source.rootPath;
+          }
         } catch (_) {
           var _error = _, _hasError = true;
         } finally {
           __callDispose(_stack, _error, _hasError);
         }
       }
+      const offsetTimestampsByDateTime = this.input._formatOptions.hls?.offsetTimestampsByDateTime !== false;
       let headerRead = false;
       let accumulatedTime = 0;
+      let accumulatedUnixTime = null;
       let nextSegmentDuration = null;
       let currentKey = null;
       let nextSequenceNumber = 0;
@@ -17235,6 +17289,7 @@ var Mediabunny = (() => {
             currentFirstSegment = prevLastSegment.firstSegment;
             currentInitSegment = prevLastSegment.initSegment;
             lastProgramDateTimeSeconds = prevLastSegment.lastProgramDateTimeSeconds;
+            accumulatedUnixTime = prevLastSegment.unixEpochTimestamp !== null ? prevLastSegment.unixEpochTimestamp + prevLastSegment.duration : null;
             prevLastSegment = null;
           }
         }
@@ -17261,7 +17316,7 @@ var Mediabunny = (() => {
               view2.setUint32(12, nextSequenceNumber);
               key = { ...key, iv };
             }
-            const fullPath = joinPaths(this.path, line);
+            const fullPath = joinPaths(this.rootPath, line);
             const location = {
               path: fullPath,
               offset: nextByteRange?.offset ?? 0,
@@ -17269,7 +17324,7 @@ var Mediabunny = (() => {
             };
             const segment = {
               timestamp: accumulatedTime,
-              relativeToUnixEpoch: lastProgramDateTimeSeconds !== null,
+              unixEpochTimestamp: accumulatedUnixTime,
               firstSegment: currentFirstSegment,
               sequenceNumber: nextSequenceNumber,
               location,
@@ -17280,6 +17335,9 @@ var Mediabunny = (() => {
             };
             currentFirstSegment ??= segment;
             accumulatedTime += nextSegmentDuration;
+            if (accumulatedUnixTime !== null) {
+              accumulatedUnixTime += nextSegmentDuration;
+            }
             this.segments.push(segment);
           } else {
           }
@@ -17325,7 +17383,7 @@ var Mediabunny = (() => {
             throw new Error("Invalid #EXT-X-MAP tag; BYTERANGE attribute must have a specified offset.");
           }
           if (!prevLastSegment) {
-            const fullPath = joinPaths(this.path, uri);
+            const fullPath = joinPaths(this.rootPath, uri);
             const location = {
               path: fullPath,
               offset: parsedByteRange?.offset ?? 0,
@@ -17336,7 +17394,7 @@ var Mediabunny = (() => {
             }
             const segment = {
               timestamp: accumulatedTime,
-              relativeToUnixEpoch: lastProgramDateTimeSeconds !== null,
+              unixEpochTimestamp: accumulatedUnixTime,
               firstSegment: null,
               sequenceNumber: null,
               location,
@@ -17386,7 +17444,7 @@ var Mediabunny = (() => {
             }
             currentKey = {
               method: "AES-128",
-              keyUri: joinPaths(this.path, uri),
+              keyUri: joinPaths(this.rootPath, uri),
               iv,
               keyFormat
             };
@@ -17456,13 +17514,17 @@ var Mediabunny = (() => {
             const lastSegmentEnd = lastSegment.timestamp + lastSegment.duration;
             const offset = dateTimeSeconds - lastSegmentEnd;
             for (const segment of this.segments) {
-              segment.timestamp += offset;
-              segment.relativeToUnixEpoch = true;
+              segment.unixEpochTimestamp = segment.timestamp + offset;
+              if (offsetTimestampsByDateTime) {
+                segment.timestamp = segment.unixEpochTimestamp;
+              }
             }
-            accumulatedTime += offset;
           }
           lastProgramDateTimeSeconds = dateTimeSeconds;
-          accumulatedTime = dateTimeSeconds;
+          accumulatedUnixTime = dateTimeSeconds;
+          if (offsetTimestampsByDateTime) {
+            accumulatedTime = dateTimeSeconds;
+          }
         } else if (line === TAG_DISCONTINUITY) {
           currentFirstSegment = null;
         } else if (line.startsWith(TAG_TARGETDURATION)) {
@@ -17679,10 +17741,10 @@ var Mediabunny = (() => {
     readMetadata() {
       return this.metadataPromise ??= (async () => {
         assert(this.input._rootSource instanceof PathedSource);
-        const { rootPath } = this.input._rootSource;
         const slice = await this.input._reader.requestEntireFile();
         assert(slice);
         const lines = readAllLines(slice, slice.length, { ignore: canIgnoreLine });
+        const { rootPath } = this.input._rootSource;
         const variantStreams = [];
         const mediaTags = [];
         for (let i = 1; i < lines.length; i++) {
@@ -18197,6 +18259,9 @@ var Mediabunny = (() => {
     isRelativeToUnixEpoch() {
       return this.delegate(() => this.internalTrack.backingTrack.isRelativeToUnixEpoch());
     }
+    getUnixTimeForTimestamp(timestamp) {
+      return this.delegate(() => this.internalTrack.backingTrack.getUnixTimeForTimestamp(timestamp));
+    }
     getBitrate() {
       return this.internalTrack.peakBitrate;
     }
@@ -18785,6 +18850,14 @@ var Mediabunny = (() => {
         throw new TypeError(`${prefix}.isobmff.resolveKeyId, when provided, must be a function.`);
       }
     }
+    if (options.hls !== void 0) {
+      if (!options.hls || typeof options.hls !== "object") {
+        throw new TypeError(`${prefix}.hls, when provided, must be an object.`);
+      }
+      if (options.hls.offsetTimestampsByDateTime !== void 0 && typeof options.hls.offsetTimestampsByDateTime !== "boolean") {
+        throw new TypeError(`${prefix}.hls.offsetTimestampsByDateTime, when provided, must be a boolean.`);
+      }
+    }
   };
 
   // src/decode.ts
@@ -22845,14 +22918,29 @@ var Mediabunny = (() => {
       }
     };
   };
+  var validateVideoSinkDecoderOptions = (decoderOptions) => {
+    if (!decoderOptions || typeof decoderOptions !== "object") {
+      throw new TypeError("decoderOptions must be an object.");
+    }
+    if (decoderOptions.hardwareAcceleration !== void 0 && !["no-preference", "prefer-hardware", "prefer-software"].includes(decoderOptions.hardwareAcceleration)) {
+      throw new TypeError(
+        "decoderOptions.hardwareAcceleration, when provided, must be 'no-preference', 'prefer-hardware' or 'prefer-software'."
+      );
+    }
+    if (decoderOptions.optimizeForLatency !== void 0 && typeof decoderOptions.optimizeForLatency !== "boolean") {
+      throw new TypeError("decoderOptions.optimizeForLatency, when provided, must be a boolean.");
+    }
+  };
   var VideoSampleSink = class extends BaseMediaSampleSink {
     /** Creates a new {@link VideoSampleSink} for the given {@link InputVideoTrack}. */
-    constructor(videoTrack) {
+    constructor(videoTrack, decoderOptions = {}) {
       if (!(videoTrack instanceof InputVideoTrack)) {
         throw new TypeError("videoTrack must be an InputVideoTrack.");
       }
+      validateVideoSinkDecoderOptions(decoderOptions);
       super();
       this._track = videoTrack;
+      this._decoderOptions = decoderOptions;
     }
     /** @internal */
     async _createDecoder(onSample, onError) {
@@ -22863,9 +22951,14 @@ var Mediabunny = (() => {
       }
       const codec = await this._track.getCodec();
       const rotation = await this._track.getRotation();
-      const decoderConfig = await this._track.getDecoderConfig();
+      let decoderConfig = await this._track.getDecoderConfig();
       const timeResolution = await this._track.getTimeResolution();
       assert(codec && decoderConfig);
+      decoderConfig = {
+        ...decoderConfig,
+        hardwareAcceleration: this._decoderOptions.hardwareAcceleration,
+        optimizeForLatency: this._decoderOptions.optimizeForLatency
+      };
       return new VideoDecoderWrapper(onSample, onError, codec, decoderConfig, rotation, timeResolution);
     }
     /** @internal */
@@ -22955,11 +23048,14 @@ var Mediabunny = (() => {
       if (options.poolSize !== void 0 && (typeof options.poolSize !== "number" || !Number.isInteger(options.poolSize) || options.poolSize < 0)) {
         throw new TypeError("poolSize must be a non-negative integer.");
       }
+      if (options.decoderOptions !== void 0) {
+        validateVideoSinkDecoderOptions(options.decoderOptions);
+      }
       this._videoTrack = videoTrack;
       this._alpha = options.alpha ?? false;
       this._options = options;
       this._fit = options.fit ?? "fill";
-      this._videoSampleSink = new VideoSampleSink(videoTrack);
+      this._videoSampleSink = new VideoSampleSink(videoTrack, options.decoderOptions);
       this._canvasPool = Array.from({ length: options.poolSize ?? 0 }, () => null);
     }
     /** @internal */
@@ -23602,6 +23698,26 @@ var Mediabunny = (() => {
     async isRelativeToUnixEpoch() {
       return this._backing.isRelativeToUnixEpoch();
     }
+    /**
+     * Returns the Unix time (in seconds since January 1, 1970 00:00:00 UTC) that the given track timestamp (in seconds)
+     * maps to, or `null` if there is no such mapping. This provides a piecewise-continuous mapping from this track's
+     * timestamp space into wall-clock time. Such mapping exists, for example, for HLS playlists with
+     * `#EXT-X-PROGRAM-DATE-TIME` tags present.
+     *
+     * This mapping can be available even when {@link InputTrack.isRelativeToUnixEpoch} is `false`, for example for HLS
+     * streams with program date time information but with {@link HlsInputFormatOptions.offsetTimestampsByDateTime}
+     * set to `false`.
+     */
+    async getUnixTimeForTimestamp(timestamp) {
+      return this._backing.getUnixTimeForTimestamp(timestamp);
+    }
+    /**
+     * Whether the track's timestamps can be mapped to Unix wall clock time via
+     * {@link InputTrack.getUnixTimeForTimestamp}.
+     */
+    async hasUnixTimeMapping() {
+      return await this._backing.getUnixTimeForTimestamp(await this.getFirstTimestamp()) !== null;
+    }
     /** Returns the track's disposition, i.e. information about its intended usage. */
     async getDisposition() {
       return this._backing.getDisposition();