hls.js 1.6.0-beta.2.0.canary.10882 → 1.6.0-beta.2.0.canary.10883

package/dist/hls.mjs

@@ -77,6 +77,7 @@ let Events = /*#__PURE__*/function (Events) {
   Events["MEDIA_DETACHING"] = "hlsMediaDetaching";
   Events["MEDIA_DETACHED"] = "hlsMediaDetached";
   Events["MEDIA_ENDED"] = "hlsMediaEnded";
+  Events["STALL_RESOLVED"] = "hlsStallResolved";
   Events["BUFFER_RESET"] = "hlsBufferReset";
   Events["BUFFER_CODECS"] = "hlsBufferCodecs";
   Events["BUFFER_CREATED"] = "hlsBufferCreated";
@@ -401,7 +402,7 @@ function enableLogs(debugConfig, context, id) {
     // Some browsers don't allow to use bind on console object anyway
     // fallback to default if needed
     try {
-      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.0-beta.2.0.canary.10882"}`);
+      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.0-beta.2.0.canary.10883"}`);
     } catch (e) {
       /* log fn threw an exception. All logger methods are no-ops. */
       return createLogger();
@@ -5862,8 +5863,7 @@ class BufferHelper {
     return {
       len: 0,
       start: pos,
-      end: pos,
-      nextStart: undefined
+      end: pos
     };
   }
   static bufferedInfo(buffered, pos, maxHoleDuration) {
@@ -5926,7 +5926,8 @@ class BufferHelper {
       len: bufferLen,
       start: bufferStart || 0,
       end: bufferEnd || 0,
-      nextStart: bufferStartNext
+      nextStart: bufferStartNext,
+      buffered
     };
   }
 
@@ -9847,7 +9848,7 @@ var eventemitter3 = {exports: {}};
 var eventemitter3Exports = eventemitter3.exports;
 var EventEmitter = /*@__PURE__*/getDefaultExportFromCjs(eventemitter3Exports);
 
-const version = "1.6.0-beta.2.0.canary.10882";
+const version = "1.6.0-beta.2.0.canary.10883";
 
 // ensure the worker ends up in the bundle
 // If the worker should not be included this gets aliased to empty.js
@@ -29443,6 +29444,7 @@ const hlsDefaultConfig = _objectSpread2(_objectSpread2({
   progressive: false,
   lowLatencyMode: true,
   cmcd: undefined,
+  detectStallWithCurrentTimeMs: 1250,
   enableDateRangeMetadataCues: true,
   enableEmsgMetadataCues: true,
   enableEmsgKLVMetadata: false,
@@ -30851,32 +30853,28 @@ function assignTrackIdsByGroup(tracks) {
   });
 }
 
-const STALL_MINIMUM_DURATION_MS = 250;
 const MAX_START_GAP_JUMP = 2.0;
 const SKIP_BUFFER_HOLE_STEP_SECONDS = 0.1;
 const SKIP_BUFFER_RANGE_START = 0.05;
 class GapController extends Logger {
-  constructor(config, media, fragmentTracker, hls) {
+  constructor(media, fragmentTracker, hls) {
     super('gap-controller', hls.logger);
-    this.config = undefined;
     this.media = null;
-    this.fragmentTracker = undefined;
-    this.hls = undefined;
+    this.fragmentTracker = null;
+    this.hls = null;
     this.nudgeRetry = 0;
     this.stallReported = false;
     this.stalled = null;
     this.moved = false;
     this.seeking = false;
     this.ended = 0;
-    this.config = config;
+    this.waiting = 0;
     this.media = media;
     this.fragmentTracker = fragmentTracker;
     this.hls = hls;
   }
   destroy() {
-    this.media = null;
-    // @ts-ignore
-    this.hls = this.fragmentTracker = null;
+    this.media = this.hls = this.fragmentTracker = null;
   }
 
   /**
@@ -30886,12 +30884,12 @@ class GapController extends Logger {
    * @param lastCurrentTime - Previously read playhead position
    */
   poll(lastCurrentTime, activeFrag, levelDetails, state) {
+    var _this$hls;
     const {
-      config,
       media,
       stalled
     } = this;
-    if (media === null) {
+    if (!media) {
       return;
     }
     const {
@@ -30911,43 +30909,45 @@ class GapController extends Logger {
       if (!seeking) {
         this.nudgeRetry = 0;
       }
-      if (stalled !== null) {
-        // The playhead is now moving, but was previously stalled
-        if (this.stallReported) {
-          const _stalledDuration = self.performance.now() - stalled;
-          this.warn(`playback not stuck anymore @${currentTime}, after ${Math.round(_stalledDuration)}ms`);
-          this.stallReported = false;
-        }
-        this.stalled = null;
+      if (this.waiting === 0) {
+        this.stallResolved(currentTime);
       }
       return;
     }
 
     // Clear stalled state when beginning or finishing seeking so that we don't report stalls coming out of a seek
     if (beginSeek || seeked) {
-      this.stalled = null;
+      if (seeked) {
+        this.stallResolved(currentTime);
+      }
       return;
     }
 
     // The playhead should not be moving
-    if (media.paused && !seeking || media.ended || media.playbackRate === 0 || !BufferHelper.getBuffered(media).length) {
+    if (media.paused && !seeking || media.ended || media.playbackRate === 0) {
+      this.nudgeRetry = 0;
+      this.stallResolved(currentTime);
       // Fire MEDIA_ENDED to workaround event not being dispatched by browser
-      if (!this.ended && media.ended) {
+      if (!this.ended && media.ended && this.hls) {
         this.ended = currentTime || 1;
         this.hls.trigger(Events.MEDIA_ENDED, {
           stalled: false
         });
       }
+      return;
+    }
+    if (!BufferHelper.getBuffered(media).length) {
       this.nudgeRetry = 0;
       return;
     }
     const bufferInfo = BufferHelper.bufferInfo(media, currentTime, 0);
     const nextStart = bufferInfo.nextStart || 0;
-    if (seeking) {
+    const fragmentTracker = this.fragmentTracker;
+    if (seeking && fragmentTracker) {
       // Waiting for seeking in a buffered range to complete
       const hasEnoughBuffer = bufferInfo.len > MAX_START_GAP_JUMP;
       // Next buffered range is too far ahead to jump to while still seeking
-      const noBufferGap = !nextStart || activeFrag && activeFrag.start <= currentTime || nextStart - currentTime > MAX_START_GAP_JUMP && !this.fragmentTracker.getPartialFragment(currentTime);
+      const noBufferGap = !nextStart || activeFrag && activeFrag.start <= currentTime || nextStart - currentTime > MAX_START_GAP_JUMP && !fragmentTracker.getPartialFragment(currentTime);
       if (hasEnoughBuffer || noBufferGap) {
         return;
       }
@@ -30957,7 +30957,7 @@ class GapController extends Logger {
 
     // Skip start gaps if we haven't played, but the last poll detected the start of a stall
     // The addition poll gives the browser a chance to jump the gap for us
-    if (!this.moved && this.stalled !== null) {
+    if (!this.moved && this.stalled !== null && fragmentTracker) {
       // There is no playable buffer (seeked, waiting for buffer)
       const isBuffered = bufferInfo.len > 0;
       if (!isBuffered && !nextStart) {
@@ -30971,7 +30971,7 @@ class GapController extends Logger {
       // that begins over 1 target duration after the video start position.
       const isLive = !!(levelDetails != null && levelDetails.live);
       const maxStartGapJump = isLive ? levelDetails.targetduration * 2 : MAX_START_GAP_JUMP;
-      const partialOrGap = this.fragmentTracker.getPartialFragment(currentTime);
+      const partialOrGap = fragmentTracker.getPartialFragment(currentTime);
       if (startJump > 0 && (startJump <= maxStartGapJump || partialOrGap)) {
         if (!media.paused) {
           this._trySkipBufferHole(partialOrGap);
@@ -30981,16 +30981,27 @@ class GapController extends Logger {
     }
 
     // Start tracking stall time
+    const config = (_this$hls = this.hls) == null ? undefined : _this$hls.config;
+    if (!config) {
+      return;
+    }
+    const detectStallWithCurrentTimeMs = config.detectStallWithCurrentTimeMs;
     const tnow = self.performance.now();
+    const tWaiting = this.waiting;
     if (stalled === null) {
-      this.stalled = tnow;
+      // Use time of recent "waiting" event
+      if (tWaiting > 0 && tnow - tWaiting < detectStallWithCurrentTimeMs) {
+        this.stalled = tWaiting;
+      } else {
+        this.stalled = tnow;
+      }
       return;
     }
     const stalledDuration = tnow - stalled;
-    if (!seeking && stalledDuration >= STALL_MINIMUM_DURATION_MS) {
+    if (!seeking && (stalledDuration >= detectStallWithCurrentTimeMs || tWaiting) && this.hls) {
       // Dispatch MEDIA_ENDED when media.ended/ended event is not signalled at end of stream
       if (state === State.ENDED && !(levelDetails != null && levelDetails.live) && Math.abs(currentTime - ((levelDetails == null ? undefined : levelDetails.edge) || 0)) < 1) {
-        if (stalledDuration < 1000 || this.ended) {
+        if (this.ended) {
           return;
         }
         this.ended = currentTime || 1;
@@ -31001,13 +31012,27 @@ class GapController extends Logger {
       }
       // Report stalling after trying to fix
       this._reportStall(bufferInfo);
-      if (!this.media) {
+      if (!this.media || !this.hls) {
         return;
       }
     }
     const bufferedWithHoles = BufferHelper.bufferInfo(media, currentTime, config.maxBufferHole);
     this._tryFixBufferStall(bufferedWithHoles, stalledDuration);
   }
+  stallResolved(currentTime) {
+    const stalled = this.stalled;
+    if (stalled && this.hls) {
+      this.stalled = null;
+      // The playhead is now moving, but was previously stalled
+      if (this.stallReported) {
+        const stalledDuration = self.performance.now() - stalled;
+        this.warn(`playback not stuck anymore @${currentTime}, after ${Math.round(stalledDuration)}ms`);
+        this.stallReported = false;
+        this.waiting = 0;
+        this.hls.trigger(Events.STALL_RESOLVED, {});
+      }
+    }
+  }
 
   /**
    * Detects and attempts to fix known buffer stalling issues.
@@ -31016,12 +31041,13 @@ class GapController extends Logger {
    * @private
    */
   _tryFixBufferStall(bufferInfo, stalledDurationMs) {
+    var _this$hls2;
     const {
-      config,
       fragmentTracker,
       media
     } = this;
-    if (media === null) {
+    const config = (_this$hls2 = this.hls) == null ? undefined : _this$hls2.config;
+    if (!media || !fragmentTracker || !config) {
       return;
     }
     const currentTime = media.currentTime;
@@ -31041,13 +31067,12 @@ class GapController extends Logger {
     // we may just have to "nudge" the playlist as the browser decoding/rendering engine
     // needs to cross some sort of threshold covering all source-buffers content
     // to start playing properly.
-    if ((bufferInfo.len > config.maxBufferHole || bufferInfo.nextStart && bufferInfo.nextStart - currentTime < config.maxBufferHole) && stalledDurationMs > config.highBufferWatchdogPeriod * 1000) {
+    const bufferedRanges = bufferInfo.buffered;
+    if ((bufferedRanges && bufferedRanges.length > 1 && bufferInfo.len > config.maxBufferHole || bufferInfo.nextStart && bufferInfo.nextStart - currentTime < config.maxBufferHole) && stalledDurationMs > config.highBufferWatchdogPeriod * 1000) {
       this.warn('Trying to nudge playhead over buffer-hole');
       // Try to nudge currentTime over a buffer hole if we've been stalling for the configured amount of seconds
       // We only try to jump the hole if it's under the configured size
-      // Reset stalled so to rearm watchdog timer
-      this.stalled = null;
-      this._tryNudgeBuffer();
+      this._tryNudgeBuffer(bufferInfo);
     }
   }
 
@@ -31060,9 +31085,10 @@ class GapController extends Logger {
     const {
       hls,
       media,
-      stallReported
+      stallReported,
+      stalled
     } = this;
-    if (!stallReported && media) {
+    if (!stallReported && stalled !== null && media && hls) {
       // Report stalled error once
       this.stallReported = true;
       const error = new Error(`Playback stalling at @${media.currentTime} due to low buffer (${JSON.stringify(bufferInfo)})`);
@@ -31072,7 +31098,11 @@ class GapController extends Logger {
         details: ErrorDetails.BUFFER_STALLED_ERROR,
         fatal: false,
         error,
-        buffer: bufferInfo.len
+        buffer: bufferInfo.len,
+        bufferInfo,
+        stalled: {
+          start: stalled
+        }
       });
     }
   }
@@ -31083,12 +31113,13 @@ class GapController extends Logger {
    * @private
    */
   _trySkipBufferHole(partial) {
+    var _this$hls3;
     const {
-      config,
-      hls,
+      fragmentTracker,
       media
     } = this;
-    if (media === null) {
+    const config = (_this$hls3 = this.hls) == null ? undefined : _this$hls3.config;
+    if (!media || !fragmentTracker || !config) {
       return 0;
     }
 
@@ -31103,9 +31134,6 @@ class GapController extends Logger {
       if (gapLength > 0 && (bufferStarved || waiting)) {
         // Only allow large gaps to be skipped if it is a start gap, or all fragments in skip range are partial
         if (gapLength > config.maxBufferHole) {
-          const {
-            fragmentTracker
-          } = this;
           let startGap = false;
           if (currentTime === 0) {
             const startFrag = fragmentTracker.getAppendedFrag(0, PlaylistLevelType.MAIN);
@@ -31136,17 +31164,18 @@ class GapController extends Logger {
         const targetTime = Math.max(startTime + SKIP_BUFFER_RANGE_START, currentTime + SKIP_BUFFER_HOLE_STEP_SECONDS);
         this.warn(`skipping hole, adjusting currentTime from ${currentTime} to ${targetTime}`);
         this.moved = true;
-        this.stalled = null;
         media.currentTime = targetTime;
-        if (partial && !partial.gap) {
+        if (partial && !partial.gap && this.hls) {
           const error = new Error(`fragment loaded with buffer holes, seeking from ${currentTime} to ${targetTime}`);
-          hls.trigger(Events.ERROR, {
+          this.hls.trigger(Events.ERROR, {
             type: ErrorTypes.MEDIA_ERROR,
             details: ErrorDetails.BUFFER_SEEK_OVER_HOLE,
             fatal: false,
             error,
             reason: error.message,
-            frag: partial
+            frag: partial,
+            buffer: bufferInfo.len,
+            bufferInfo
           });
         }
         return targetTime;
@@ -31159,15 +31188,15 @@ class GapController extends Logger {
    * Attempts to fix buffer stalls by advancing the mediaElement's current time by a small amount.
    * @private
    */
-  _tryNudgeBuffer() {
+  _tryNudgeBuffer(bufferInfo) {
     const {
-      config,
       hls,
       media,
       nudgeRetry
     } = this;
-    if (media === null) {
-      return;
+    const config = hls == null ? undefined : hls.config;
+    if (!media || !config) {
+      return 0;
     }
     const currentTime = media.currentTime;
     this.nudgeRetry++;
@@ -31181,7 +31210,9 @@ class GapController extends Logger {
         type: ErrorTypes.MEDIA_ERROR,
         details: ErrorDetails.BUFFER_NUDGE_ON_STALL,
         error,
-        fatal: false
+        fatal: false,
+        buffer: bufferInfo.len,
+        bufferInfo
       });
     } else {
       const error = new Error(`Playhead still not moving while enough data buffered @${currentTime} after ${config.nudgeMaxRetry} nudges`);
@@ -31190,7 +31221,9 @@ class GapController extends Logger {
         type: ErrorTypes.MEDIA_ERROR,
         details: ErrorDetails.BUFFER_STALLED_ERROR,
         error,
-        fatal: true
+        fatal: true,
+        buffer: bufferInfo.len,
+        bufferInfo
       });
     }
   }
@@ -31241,11 +31274,18 @@ class StreamController extends BaseStreamController {
     this.backtrackFragment = null;
     this.audioCodecSwitch = false;
     this.videoBuffer = null;
+    this.onMediaWaiting = () => {
+      const gapController = this.gapController;
+      if (gapController) {
+        gapController.waiting = self.performance.now();
+      }
+    };
     this.onMediaPlaying = () => {
       // tick to speed up FRAG_CHANGED triggering
       const gapController = this.gapController;
       if (gapController) {
         gapController.ended = 0;
+        gapController.waiting = 0;
       }
       this.tick();
     };
@@ -31301,7 +31341,7 @@ class StreamController extends BaseStreamController {
   }
   onHandlerDestroying() {
     // @ts-ignore
-    this.onMediaPlaying = this.onMediaSeeked = null;
+    this.onMediaPlaying = this.onMediaSeeked = this.onMediaWaiting = null;
     this.unregisterListeners();
     super.onHandlerDestroying();
   }
@@ -31632,9 +31672,11 @@ class StreamController extends BaseStreamController {
     const media = data.media;
     media.removeEventListener('playing', this.onMediaPlaying);
     media.removeEventListener('seeked', this.onMediaSeeked);
+    media.removeEventListener('waiting', this.onMediaWaiting);
     media.addEventListener('playing', this.onMediaPlaying);
     media.addEventListener('seeked', this.onMediaSeeked);
-    this.gapController = new GapController(this.config, media, this.fragmentTracker, this.hls);
+    media.addEventListener('waiting', this.onMediaWaiting);
+    this.gapController = new GapController(media, this.fragmentTracker, this.hls);
   }
   onMediaDetaching(event, data) {
     const {
@@ -31643,6 +31685,7 @@ class StreamController extends BaseStreamController {
     if (media) {
       media.removeEventListener('playing', this.onMediaPlaying);
       media.removeEventListener('seeked', this.onMediaSeeked);
+      media.removeEventListener('waiting', this.onMediaWaiting);
     }
     this.videoBuffer = null;
     this.fragPlaying = null;
@@ -32070,7 +32113,7 @@ class StreamController extends BaseStreamController {
     let startPosition = this.startPosition;
     // only adjust currentTime if different from startPosition or if startPosition not buffered
     // at that stage, there should be only one buffered range, as we reach that code after first fragment has been buffered
-    if (startPosition >= 0) {
+    if (startPosition >= 0 && currentTime < startPosition) {
       if (media.seeking) {
         this.log(`could not seek to ${startPosition}, already seeking at ${currentTime}`);
         return;