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

package/dist/hls.js

@@ -785,6 +785,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";
@@ -1058,7 +1059,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.10884");
       } catch (e) {
         /* log fn threw an exception. All logger methods are no-ops. */
         return createLogger();
@@ -6521,8 +6522,7 @@
       return {
         len: 0,
         start: pos,
-        end: pos,
-        nextStart: undefined
+        end: pos
       };
     };
     BufferHelper.bufferedInfo = function bufferedInfo(buffered, pos, maxHoleDuration) {
@@ -6587,7 +6587,8 @@
         len: bufferLen,
         start: bufferStart || 0,
         end: bufferEnd || 0,
-        nextStart: bufferStartNext
+        nextStart: bufferStartNext,
+        buffered: buffered
       };
     }
 
@@ -6986,8 +6987,6 @@
       this.advancedDateTime = undefined;
       this.updated = true;
       this.advanced = true;
-      this.availabilityDelay = undefined;
-      // Manifest reload synchronization
       this.misses = 0;
       this.startCC = 0;
       this.startSN = 0;
@@ -7040,7 +7039,6 @@
       } else {
         this.misses = previous.misses + 1;
       }
-      this.availabilityDelay = previous.availabilityDelay;
     };
     return _createClass(LevelDetails, [{
       key: "hasProgramDateTime",
@@ -8042,7 +8040,7 @@
         if (!level.live) {
           lastFragment.endList = true;
         }
-        if (firstFragment && !level.startCC) {
+        if (firstFragment && level.startCC === undefined) {
           level.startCC = firstFragment.cc;
         }
         /**
@@ -8332,15 +8330,16 @@
       delete oldDetails.fragmentHint.endPTS;
     }
     // check if old/new playlists have fragments in common
-    // loop through overlapping SN and update startPTS , cc, and duration if any found
-    var ccOffset = 0;
+    // loop through overlapping SN and update startPTS, cc, and duration if any found
     var PTSFrag;
-    mapFragmentIntersection(oldDetails, newDetails, function (oldFrag, newFrag) {
-      if (oldFrag.relurl) {
-        // Do not compare CC if the old fragment has no url. This is a level.fragmentHint used by LL-HLS parts.
-        // It maybe be off by 1 if it was created before any parts or discontinuity tags were appended to the end
-        // of the playlist.
-        ccOffset = oldFrag.cc - newFrag.cc;
+    mapFragmentIntersection(oldDetails, newDetails, function (oldFrag, newFrag, newFragIndex, newFragments) {
+      if (newDetails.skippedSegments) {
+        if (newFrag.cc !== oldFrag.cc) {
+          var ccOffset = oldFrag.cc - newFrag.cc;
+          for (var _i = newFragIndex; _i < newFragments.length; _i++) {
+            newFragments[_i].cc += ccOffset;
+          }
+        }
       }
       if (isFiniteNumber(oldFrag.startPTS) && isFiniteNumber(oldFrag.endPTS)) {
         newFrag.setStart(newFrag.startPTS = oldFrag.startPTS);
@@ -8369,7 +8368,8 @@
         currentInitSegment = oldFrag.initSegment;
       }
     });
-    var fragmentsToCheck = newDetails.fragmentHint ? newDetails.fragments.concat(newDetails.fragmentHint) : newDetails.fragments;
+    var newFragments = newDetails.fragments;
+    var fragmentsToCheck = newDetails.fragmentHint ? newFragments.concat(newDetails.fragmentHint) : newFragments;
     if (currentInitSegment) {
       fragmentsToCheck.forEach(function (frag) {
         var _currentInitSegment;
@@ -8379,19 +8379,17 @@
       });
     }
     if (newDetails.skippedSegments) {
-      newDetails.deltaUpdateFailed = newDetails.fragments.some(function (frag) {
+      newDetails.deltaUpdateFailed = newFragments.some(function (frag) {
         return !frag;
       });
       if (newDetails.deltaUpdateFailed) {
         logger.warn('[level-helper] Previous playlist missing segments skipped in delta playlist');
-        for (var _i = newDetails.skippedSegments; _i--;) {
-          newDetails.fragments.shift();
-        }
-        newDetails.startSN = newDetails.fragments[0].sn;
-        if (!newDetails.startCC) {
-          newDetails.startCC = newDetails.fragments[0].cc;
+        for (var _i2 = newDetails.skippedSegments; _i2--;) {
+          newFragments.shift();
         }
+        newDetails.startSN = newFragments[0].sn;
       } else {
+        newDetails.endCC = newFragments[newFragments.length - 1].cc;
         if (newDetails.canSkipDateRanges) {
           newDetails.dateRanges = mergeDateRanges(oldDetails.dateRanges, newDetails);
         }
@@ -8399,25 +8397,15 @@
           return frag.rawProgramDateTime;
         });
         if (oldDetails.hasProgramDateTime && !newDetails.hasProgramDateTime) {
-          for (var _i2 = 1; _i2 < fragmentsToCheck.length; _i2++) {
-            if (fragmentsToCheck[_i2].programDateTime === null) {
-              assignProgramDateTime(fragmentsToCheck[_i2], fragmentsToCheck[_i2 - 1], programDateTimes);
+          for (var _i3 = 1; _i3 < fragmentsToCheck.length; _i3++) {
+            if (fragmentsToCheck[_i3].programDateTime === null) {
+              assignProgramDateTime(fragmentsToCheck[_i3], fragmentsToCheck[_i3 - 1], programDateTimes);
             }
           }
         }
         mapDateRanges(programDateTimes, newDetails);
       }
     }
-    var newFragments = newDetails.fragments;
-    if (ccOffset) {
-      logger.warn('discontinuity sliding from playlist, take drift into account');
-      for (var _i3 = 0; _i3 < newFragments.length; _i3++) {
-        newFragments[_i3].cc += ccOffset;
-      }
-    }
-    if (newDetails.skippedSegments) {
-      newDetails.startCC = newDetails.fragments[0].cc;
-    }
 
     // Merge parts
     mapPartIntersection(oldDetails.partList, newDetails.partList, function (oldPart, newPart) {
@@ -8513,7 +8501,7 @@
         _newFrag = newDetails.fragments[i] = _oldFrag;
       }
       if (_oldFrag && _newFrag) {
-        intersectionFn(_oldFrag, _newFrag);
+        intersectionFn(_oldFrag, _newFrag, i, newFrags);
       }
     }
   }
@@ -16320,7 +16308,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.10884";
 
   // ensure the worker ends up in the bundle
   // If the worker should not be included this gets aliased to empty.js
@@ -30362,6 +30350,7 @@
     progressive: false,
     lowLatencyMode: true,
     cmcd: undefined,
+    detectStallWithCurrentTimeMs: 1250,
     enableDateRangeMetadataCues: true,
     enableEmsgMetadataCues: true,
     enableEmsgKLVMetadata: false,
@@ -31787,25 +31776,23 @@
     });
   }
 
-  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;
@@ -31814,9 +31801,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;
     }
 
     /**
@@ -31826,10 +31811,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,
@@ -31847,43 +31832,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;
         }
@@ -31893,7 +31880,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) {
@@ -31907,7 +31894,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);
@@ -31917,16 +31904,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;
@@ -31937,12 +31935,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, {});
+        }
+      }
     }
 
     /**
@@ -31952,10 +31964,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;
@@ -31975,13 +31988,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);
       }
     }
 
@@ -31993,8 +32005,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) + ")");
@@ -32004,7 +32017,11 @@
           details: ErrorDetails.BUFFER_STALLED_ERROR,
           fatal: false,
           error: error,
-          buffer: bufferInfo.len
+          buffer: bufferInfo.len,
+          bufferInfo: bufferInfo,
+          stalled: {
+            start: stalled
+          }
         });
       }
     }
@@ -32015,10 +32032,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;
       }
 
@@ -32033,7 +32051,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);
@@ -32064,17 +32081,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;
@@ -32087,13 +32105,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++;
@@ -32107,7 +32125,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");
@@ -32116,7 +32136,9 @@
           type: ErrorTypes.MEDIA_ERROR,
           details: ErrorDetails.BUFFER_STALLED_ERROR,
           error: _error,
-          fatal: true
+          fatal: true,
+          buffer: bufferInfo.len,
+          bufferInfo: bufferInfo
         });
       }
     };
@@ -32172,11 +32194,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();
       };
@@ -32231,7 +32260,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);
     };
@@ -32552,15 +32581,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;
@@ -32970,7 +33002,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;

package/dist/hls.js.d.ts

@@ -571,6 +571,19 @@ export declare type BufferInfo = {
     start: number;
     end: number;
     nextStart?: number;
+    buffered?: BufferTimeRange[];
+};
+
+/**
+ * Provides methods dealing with buffer length retrieval for example.
+ *
+ * In general, a helper around HTML5 MediaElement TimeRanges gathered from `buffered` property.
+ *
+ * Also @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/buffered
+ */
+export declare type BufferTimeRange = {
+    start: number;
+    end: number;
 };
 
 export declare class CapLevelController implements ComponentAPI {
@@ -1017,6 +1030,7 @@ export declare interface ErrorData {
     fatal: boolean;
     errorAction?: IErrorAction;
     buffer?: number;
+    bufferInfo?: BufferInfo;
     bytes?: number;
     chunkMeta?: ChunkMetadata;
     context?: PlaylistLoaderContext;
@@ -1027,6 +1041,9 @@ export declare interface ErrorData {
     levelRetry?: boolean;
     loader?: Loader<LoaderContext>;
     networkDetails?: any;
+    stalled?: {
+        start: number;
+    };
     stats?: LoaderStats;
     mimeType?: string;
     reason?: string;
@@ -1110,6 +1127,7 @@ export declare enum Events {
     MEDIA_DETACHING = "hlsMediaDetaching",
     MEDIA_DETACHED = "hlsMediaDetached",
     MEDIA_ENDED = "hlsMediaEnded",
+    STALL_RESOLVED = "hlsStallResolved",
     BUFFER_RESET = "hlsBufferReset",
     BUFFER_CODECS = "hlsBufferCodecs",
     BUFFER_CREATED = "hlsBufferCreated",
@@ -1948,6 +1966,7 @@ export declare type HlsConfig = {
     progressive: boolean;
     lowLatencyMode: boolean;
     primarySessionId?: string;
+    detectStallWithCurrentTimeMs: number;
 } & ABRControllerConfig & BufferControllerConfig & CapLevelControllerConfig & EMEControllerConfig & FPSControllerConfig & LevelControllerConfig & MP4RemuxerConfig & StreamControllerConfig & SelectionPreferences & LatencyControllerConfig & MetadataControllerConfig & TimelineControllerConfig & TSDemuxerConfig & HlsLoadPolicies & FragmentLoaderConfig & PlaylistLoaderConfig;
 
 export declare interface HlsEventEmitter {
@@ -1969,6 +1988,7 @@ export declare interface HlsListeners {
     [Events.MEDIA_DETACHING]: (event: Events.MEDIA_DETACHING, data: MediaDetachingData) => void;
     [Events.MEDIA_DETACHED]: (event: Events.MEDIA_DETACHED, data: MediaDetachedData) => void;
     [Events.MEDIA_ENDED]: (event: Events.MEDIA_ENDED, data: MediaEndedData) => void;
+    [Events.STALL_RESOLVED]: (event: Events.STALL_RESOLVED, data: {}) => void;
     [Events.BUFFER_RESET]: (event: Events.BUFFER_RESET) => void;
     [Events.BUFFER_CODECS]: (event: Events.BUFFER_CODECS, data: BufferCodecsData) => void;
     [Events.BUFFER_CREATED]: (event: Events.BUFFER_CREATED, data: BufferCreatedData) => void;
@@ -2558,7 +2578,6 @@ export declare class LevelDetails {
     advancedDateTime?: number;
     updated: boolean;
     advanced: boolean;
-    availabilityDelay?: number;
     misses: number;
     startCC: number;
     startSN: number;
@@ -3340,6 +3359,7 @@ export declare class StreamController extends BaseStreamController implements Ne
     protected flushMainBuffer(startOffset: number, endOffset: number): void;
     protected onMediaAttached(event: Events.MEDIA_ATTACHED, data: MediaAttachedData): void;
     protected onMediaDetaching(event: Events.MEDIA_DETACHING, data: MediaDetachingData): void;
+    private onMediaWaiting;
     private onMediaPlaying;
     private onMediaSeeked;
     protected triggerEnded(): void;