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

package/dist/hls.light.js

@@ -756,6 +756,7 @@
     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";
@@ -1029,7 +1030,7 @@
       // 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();
@@ -3621,8 +3622,7 @@
       return {
         len: 0,
         start: pos,
-        end: pos,
-        nextStart: undefined
+        end: pos
       };
     };
     BufferHelper.bufferedInfo = function bufferedInfo(buffered, pos, maxHoleDuration) {
@@ -3687,7 +3687,8 @@
         len: bufferLen,
         start: bufferStart || 0,
         end: bufferEnd || 0,
-        nextStart: bufferStartNext
+        nextStart: bufferStartNext,
+        buffered: buffered
       };
     }
 
@@ -14972,6 +14973,7 @@
     progressive: false,
     lowLatencyMode: true,
     cmcd: undefined,
+    detectStallWithCurrentTimeMs: 1250,
     enableDateRangeMetadataCues: true,
     enableEmsgMetadataCues: true,
     enableEmsgKLVMetadata: false,
@@ -19236,25 +19238,23 @@
     }]);
   }(TaskLoop);
 
-  var STALL_MINIMUM_DURATION_MS = 250;
   var MAX_START_GAP_JUMP = 2.0;
   var SKIP_BUFFER_HOLE_STEP_SECONDS = 0.1;
   var SKIP_BUFFER_RANGE_START = 0.05;
   var GapController = /*#__PURE__*/function (_Logger) {
-    function GapController(config, media, fragmentTracker, hls) {
+    function GapController(media, fragmentTracker, hls) {
       var _this;
       _this = _Logger.call(this, 'gap-controller', hls.logger) || this;
-      _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;
@@ -19263,9 +19263,7 @@
     _inheritsLoose(GapController, _Logger);
     var _proto = GapController.prototype;
     _proto.destroy = function destroy() {
-      this.media = null;
-      // @ts-ignore
-      this.hls = this.fragmentTracker = null;
+      this.media = this.hls = this.fragmentTracker = null;
     }
 
     /**
@@ -19275,10 +19273,10 @@
      * @param lastCurrentTime - Previously read playhead position
      */;
     _proto.poll = function poll(lastCurrentTime, activeFrag, levelDetails, state) {
-      var config = this.config,
-        media = this.media,
+      var _this$hls;
+      var media = this.media,
         stalled = this.stalled;
-      if (media === null) {
+      if (!media) {
         return;
       }
       var currentTime = media.currentTime,
@@ -19296,43 +19294,45 @@
         if (!seeking) {
           this.nudgeRetry = 0;
         }
-        if (stalled !== null) {
-          // The playhead is now moving, but was previously stalled
-          if (this.stallReported) {
-            var _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;
       }
       var bufferInfo = BufferHelper.bufferInfo(media, currentTime, 0);
       var nextStart = bufferInfo.nextStart || 0;
-      if (seeking) {
+      var fragmentTracker = this.fragmentTracker;
+      if (seeking && fragmentTracker) {
         // Waiting for seeking in a buffered range to complete
         var hasEnoughBuffer = bufferInfo.len > MAX_START_GAP_JUMP;
         // Next buffered range is too far ahead to jump to while still seeking
-        var noBufferGap = !nextStart || activeFrag && activeFrag.start <= currentTime || nextStart - currentTime > MAX_START_GAP_JUMP && !this.fragmentTracker.getPartialFragment(currentTime);
+        var noBufferGap = !nextStart || activeFrag && activeFrag.start <= currentTime || nextStart - currentTime > MAX_START_GAP_JUMP && !fragmentTracker.getPartialFragment(currentTime);
         if (hasEnoughBuffer || noBufferGap) {
           return;
         }
@@ -19342,7 +19342,7 @@
 
       // 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)
         var isBuffered = bufferInfo.len > 0;
         if (!isBuffered && !nextStart) {
@@ -19356,7 +19356,7 @@
         // that begins over 1 target duration after the video start position.
         var isLive = !!(levelDetails != null && levelDetails.live);
         var maxStartGapJump = isLive ? levelDetails.targetduration * 2 : MAX_START_GAP_JUMP;
-        var partialOrGap = this.fragmentTracker.getPartialFragment(currentTime);
+        var partialOrGap = fragmentTracker.getPartialFragment(currentTime);
         if (startJump > 0 && (startJump <= maxStartGapJump || partialOrGap)) {
           if (!media.paused) {
             this._trySkipBufferHole(partialOrGap);
@@ -19366,16 +19366,27 @@
       }
 
       // Start tracking stall time
+      var config = (_this$hls = this.hls) == null ? undefined : _this$hls.config;
+      if (!config) {
+        return;
+      }
+      var detectStallWithCurrentTimeMs = config.detectStallWithCurrentTimeMs;
       var tnow = self.performance.now();
+      var 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;
       }
       var 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;
@@ -19386,12 +19397,26 @@
         }
         // Report stalling after trying to fix
         this._reportStall(bufferInfo);
-        if (!this.media) {
+        if (!this.media || !this.hls) {
           return;
         }
       }
       var bufferedWithHoles = BufferHelper.bufferInfo(media, currentTime, config.maxBufferHole);
       this._tryFixBufferStall(bufferedWithHoles, stalledDuration);
+    };
+    _proto.stallResolved = function stallResolved(currentTime) {
+      var stalled = this.stalled;
+      if (stalled && this.hls) {
+        this.stalled = null;
+        // The playhead is now moving, but was previously stalled
+        if (this.stallReported) {
+          var 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, {});
+        }
+      }
     }
 
     /**
@@ -19401,10 +19426,11 @@
      * @private
      */;
     _proto._tryFixBufferStall = function _tryFixBufferStall(bufferInfo, stalledDurationMs) {
-      var config = this.config,
-        fragmentTracker = this.fragmentTracker,
+      var _this$hls2;
+      var fragmentTracker = this.fragmentTracker,
         media = this.media;
-      if (media === null) {
+      var config = (_this$hls2 = this.hls) == null ? undefined : _this$hls2.config;
+      if (!media || !fragmentTracker || !config) {
         return;
       }
       var currentTime = media.currentTime;
@@ -19424,13 +19450,12 @@
       // 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) {
+      var 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);
       }
     }
 
@@ -19442,8 +19467,9 @@
     _proto._reportStall = function _reportStall(bufferInfo) {
       var hls = this.hls,
         media = this.media,
-        stallReported = this.stallReported;
-      if (!stallReported && media) {
+        stallReported = this.stallReported,
+        stalled = this.stalled;
+      if (!stallReported && stalled !== null && media && hls) {
         // Report stalled error once
         this.stallReported = true;
         var error = new Error("Playback stalling at @" + media.currentTime + " due to low buffer (" + JSON.stringify(bufferInfo) + ")");
@@ -19453,7 +19479,11 @@
           details: ErrorDetails.BUFFER_STALLED_ERROR,
           fatal: false,
           error: error,
-          buffer: bufferInfo.len
+          buffer: bufferInfo.len,
+          bufferInfo: bufferInfo,
+          stalled: {
+            start: stalled
+          }
         });
       }
     }
@@ -19464,10 +19494,11 @@
      * @private
      */;
     _proto._trySkipBufferHole = function _trySkipBufferHole(partial) {
-      var config = this.config,
-        hls = this.hls,
+      var _this$hls3;
+      var fragmentTracker = this.fragmentTracker,
         media = this.media;
-      if (media === null) {
+      var config = (_this$hls3 = this.hls) == null ? undefined : _this$hls3.config;
+      if (!media || !fragmentTracker || !config) {
         return 0;
       }
 
@@ -19482,7 +19513,6 @@
         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) {
-            var fragmentTracker = this.fragmentTracker;
             var startGap = false;
             if (currentTime === 0) {
               var startFrag = fragmentTracker.getAppendedFrag(0, PlaylistLevelType.MAIN);
@@ -19513,17 +19543,18 @@
           var 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) {
             var 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: error,
               reason: error.message,
-              frag: partial
+              frag: partial,
+              buffer: bufferInfo.len,
+              bufferInfo: bufferInfo
             });
           }
           return targetTime;
@@ -19536,13 +19567,13 @@
      * Attempts to fix buffer stalls by advancing the mediaElement's current time by a small amount.
      * @private
      */;
-    _proto._tryNudgeBuffer = function _tryNudgeBuffer() {
-      var config = this.config,
-        hls = this.hls,
+    _proto._tryNudgeBuffer = function _tryNudgeBuffer(bufferInfo) {
+      var hls = this.hls,
         media = this.media,
         nudgeRetry = this.nudgeRetry;
-      if (media === null) {
-        return;
+      var config = hls == null ? undefined : hls.config;
+      if (!media || !config) {
+        return 0;
       }
       var currentTime = media.currentTime;
       this.nudgeRetry++;
@@ -19556,7 +19587,9 @@
           type: ErrorTypes.MEDIA_ERROR,
           details: ErrorDetails.BUFFER_NUDGE_ON_STALL,
           error: error,
-          fatal: false
+          fatal: false,
+          buffer: bufferInfo.len,
+          bufferInfo: bufferInfo
         });
       } else {
         var _error = new Error("Playhead still not moving while enough data buffered @" + currentTime + " after " + config.nudgeMaxRetry + " nudges");
@@ -19565,7 +19598,9 @@
           type: ErrorTypes.MEDIA_ERROR,
           details: ErrorDetails.BUFFER_STALLED_ERROR,
           error: _error,
-          fatal: true
+          fatal: true,
+          buffer: bufferInfo.len,
+          bufferInfo: bufferInfo
         });
       }
     };
@@ -19735,7 +19770,7 @@
     return !remuxResult.audio && !remuxResult.video && !remuxResult.text && !remuxResult.id3 && !remuxResult.initSegment;
   }
 
-  var version = "1.6.0-beta.2.0.canary.10882";
+  var 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
@@ -20155,11 +20190,18 @@
       _this.backtrackFragment = null;
       _this.audioCodecSwitch = false;
       _this.videoBuffer = null;
+      _this.onMediaWaiting = function () {
+        var gapController = _this.gapController;
+        if (gapController) {
+          gapController.waiting = self.performance.now();
+        }
+      };
       _this.onMediaPlaying = function () {
         // tick to speed up FRAG_CHANGED triggering
         var gapController = _this.gapController;
         if (gapController) {
           gapController.ended = 0;
+          gapController.waiting = 0;
         }
         _this.tick();
       };
@@ -20214,7 +20256,7 @@
     };
     _proto.onHandlerDestroying = function onHandlerDestroying() {
       // @ts-ignore
-      this.onMediaPlaying = this.onMediaSeeked = null;
+      this.onMediaPlaying = this.onMediaSeeked = this.onMediaWaiting = null;
       this.unregisterListeners();
       _BaseStreamController.prototype.onHandlerDestroying.call(this);
     };
@@ -20535,15 +20577,18 @@
       var 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);
     };
     _proto.onMediaDetaching = function onMediaDetaching(event, data) {
       var media = this.media;
       if (media) {
         media.removeEventListener('playing', this.onMediaPlaying);
         media.removeEventListener('seeked', this.onMediaSeeked);
+        media.removeEventListener('waiting', this.onMediaWaiting);
       }
       this.videoBuffer = null;
       this.fragPlaying = null;
@@ -20953,7 +20998,7 @@
       var 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;