mediabunny 1.47.0 → 1.48.1

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;
     }
@@ -13525,6 +13546,10 @@ var Mediabunny = (() => {
             currentPos += this.packetStride;
             continue;
           }
+          if (hasProgramMap && !this.elementaryStreams.some((x) => x.pid === packetHeader.pid)) {
+            currentPos += this.packetStride;
+            continue;
+          }
           const section = await this.readSection(
             currentPos,
             true,
@@ -14201,6 +14226,9 @@ var Mediabunny = (() => {
     isRelativeToUnixEpoch() {
       return false;
     }
+    getUnixTimeForTimestamp() {
+      return null;
+    }
     getPairingMask() {
       return 1n;
     }
@@ -14821,7 +14849,10 @@ var Mediabunny = (() => {
         if (codec !== "avc" && codec !== "hevc") {
           throw new Error("Unhandled.");
         }
+        const nalHeaderSize = codec === "avc" ? 1 : 2;
         let packetStartPos = null;
+        let frameStartFound = false;
+        let lastFirstMacroblockInSlice = 0;
         while (true) {
           let remaining = this.ensureBuffered(CHUNK_SIZE);
           if (remaining instanceof Promise) remaining = await remaining;
@@ -14839,7 +14870,7 @@ var Mediabunny = (() => {
             }
             i = zeroIndex;
             const posBeforeZero = chunkStartPos + i;
-            if (i + 4 >= length) {
+            if (i + 3 >= length) {
               this.seekTo(posBeforeZero);
               break;
             }
@@ -14847,32 +14878,68 @@ var Mediabunny = (() => {
             const b2 = chunk[i + 2];
             const b3 = chunk[i + 3];
             let startCodeLength = 0;
-            let nalUnitTypeByte = null;
             if (b1 === 0 && b2 === 0 && b3 === 1) {
               startCodeLength = 4;
-              nalUnitTypeByte = chunk[i + 4];
             } else if (b1 === 0 && b2 === 1) {
               startCodeLength = 3;
-              nalUnitTypeByte = b3;
             }
             if (startCodeLength === 0) {
               i++;
               continue;
             }
             const startCodePos = posBeforeZero;
-            if (packetStartPos === null) {
-              packetStartPos = startCodePos;
-              i += startCodeLength;
-              continue;
+            packetStartPos ??= startCodePos;
+            const nalHeaderStart = i + startCodeLength;
+            const payloadStart = nalHeaderStart + nalHeaderSize;
+            const AVC_SLICE_HEADER_PEEK_SIZE = 6;
+            const bytesNeeded = payloadStart + (codec === "avc" ? AVC_SLICE_HEADER_PEEK_SIZE : 1);
+            if (bytesNeeded > length) {
+              this.seekTo(posBeforeZero);
+              break;
             }
-            if (nalUnitTypeByte !== null) {
-              const nalUnitType = codec === "avc" ? extractNalUnitTypeForAvc(nalUnitTypeByte) : extractNalUnitTypeForHevc(nalUnitTypeByte);
-              const isAud = codec === "avc" ? nalUnitType === 9 /* AUD */ : nalUnitType === 35 /* AUD_NUT */;
-              if (isAud) {
-                const packetLength = startCodePos - packetStartPos;
-                this.seekTo(packetStartPos);
-                return this.supplyPacket(packetLength, 0);
+            const headerByte0 = chunk[nalHeaderStart];
+            let nalUnitType;
+            let isSlice;
+            let isAccessUnitStart;
+            if (codec === "avc") {
+              nalUnitType = extractNalUnitTypeForAvc(headerByte0);
+              isSlice = nalUnitType === 1 /* NON_IDR_SLICE */ || nalUnitType === 2 /* SLICE_DPA */ || nalUnitType === 5 /* IDR */;
+              isAccessUnitStart = nalUnitType === 6 /* SEI */ || nalUnitType === 7 /* SPS */ || nalUnitType === 8 /* PPS */ || nalUnitType === 9 /* AUD */;
+            } else {
+              nalUnitType = extractNalUnitTypeForHevc(headerByte0);
+              const layerId = (headerByte0 & 1) << 5 | chunk[nalHeaderStart + 1] >> 3;
+              if (layerId > 0) {
+                i += startCodeLength;
+                continue;
+              }
+              isSlice = nalUnitType <= 9 /* RASL_R */ || nalUnitType >= 16 /* BLA_W_LP */ && nalUnitType <= 21;
+              isAccessUnitStart = nalUnitType >= 32 /* VPS_NUT */ && nalUnitType <= 37 || nalUnitType === 39 /* PREFIX_SEI_NUT */ || nalUnitType >= 41 && nalUnitType <= 44 || nalUnitType >= 48 && nalUnitType <= 55;
+            }
+            let isFrameBoundary = false;
+            if (isSlice) {
+              let startsNewPicture;
+              if (codec === "avc") {
+                const headerBytes = chunk.subarray(payloadStart, payloadStart + AVC_SLICE_HEADER_PEEK_SIZE);
+                const firstMacroblockInSlice = readExpGolomb(new Bitstream(headerBytes));
+                startsNewPicture = !frameStartFound || firstMacroblockInSlice <= lastFirstMacroblockInSlice;
+                lastFirstMacroblockInSlice = firstMacroblockInSlice;
+              } else {
+                startsNewPicture = chunk[payloadStart] >> 7 === 1;
               }
+              if (startsNewPicture) {
+                if (frameStartFound) {
+                  isFrameBoundary = true;
+                } else {
+                  frameStartFound = true;
+                }
+              }
+            } else if (isAccessUnitStart && frameStartFound) {
+              isFrameBoundary = true;
+            }
+            if (isFrameBoundary) {
+              const packetLength = startCodePos - packetStartPos;
+              this.seekTo(packetStartPos);
+              return this.supplyPacket(packetLength, 0);
             }
             i += startCodeLength;
           }
@@ -14880,7 +14947,7 @@ var Mediabunny = (() => {
             break;
           }
         }
-        if (packetStartPos !== null) {
+        if (packetStartPos !== null && this.endPos > packetStartPos) {
           const packetLength = this.endPos - packetStartPos;
           this.seekTo(packetStartPos);
           return this.supplyPacket(packetLength, 0);
@@ -15239,6 +15306,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 +15472,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 +16065,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 +16173,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 +16836,12 @@ var Mediabunny = (() => {
           offset: innerStart
         });
       } else {
+        promise.catch((error) => {
+          if (this.disposed) {
+            return;
+          }
+          throw error;
+        });
       }
       return result;
     }
@@ -16835,11 +16926,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 +17243,7 @@ var Mediabunny = (() => {
       this.streamHasEnded = false;
       this.lastSegmentUpdateTime = -Infinity;
       this.refreshInterval = 5;
+      this.rootPath = path;
       this.demuxer = demuxer;
       this.nextLines = lines;
     }
@@ -17187,19 +17279,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 +17332,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 +17359,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 +17367,7 @@ var Mediabunny = (() => {
             };
             const segment = {
               timestamp: accumulatedTime,
-              relativeToUnixEpoch: lastProgramDateTimeSeconds !== null,
+              unixEpochTimestamp: accumulatedUnixTime,
               firstSegment: currentFirstSegment,
               sequenceNumber: nextSequenceNumber,
               location,
@@ -17280,6 +17378,9 @@ var Mediabunny = (() => {
             };
             currentFirstSegment ??= segment;
             accumulatedTime += nextSegmentDuration;
+            if (accumulatedUnixTime !== null) {
+              accumulatedUnixTime += nextSegmentDuration;
+            }
             this.segments.push(segment);
           } else {
           }
@@ -17325,7 +17426,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 +17437,7 @@ var Mediabunny = (() => {
             }
             const segment = {
               timestamp: accumulatedTime,
-              relativeToUnixEpoch: lastProgramDateTimeSeconds !== null,
+              unixEpochTimestamp: accumulatedUnixTime,
               firstSegment: null,
               sequenceNumber: null,
               location,
@@ -17386,7 +17487,7 @@ var Mediabunny = (() => {
             }
             currentKey = {
               method: "AES-128",
-              keyUri: joinPaths(this.path, uri),
+              keyUri: joinPaths(this.rootPath, uri),
               iv,
               keyFormat
             };
@@ -17456,13 +17557,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 +17784,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 +18302,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 +18893,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 +22961,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 +22994,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 +23091,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 +23741,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();