hls.js 1.5.5-0.canary.9985 → 1.5.5-0.canary.9987

package/dist/hls.light.js

@@ -613,7 +613,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.5.5-0.canary.9985");
+        newLogger.log("Debug logs enabled for \"" + context + "\" in hls.js version " + "1.5.5-0.canary.9987");
       } catch (e) {
         /* log fn threw an exception. All logger methods are no-ops. */
         return createLogger();
@@ -12307,6 +12307,7 @@
       _this.decrypter = void 0;
       _this.initPTS = [];
       _this.buffering = true;
+      _this.loadingParts = false;
       _this.onMediaSeeking = function () {
         var _assertThisInitialize = _assertThisInitialized(_this),
           config = _assertThisInitialize.config,
@@ -12342,6 +12343,14 @@
           // Remove gap fragments
           _this.fragmentTracker.removeFragmentsInRange(currentTime, Infinity, _this.playlistType, true);
           _this.lastCurrentTime = currentTime;
+          if (!_this.loadingParts) {
+            var bufferEnd = Math.max(bufferInfo.end, currentTime);
+            var shouldLoadParts = _this.shouldLoadParts(_this.getLevelDetails(), bufferEnd);
+            if (shouldLoadParts) {
+              _this.log("LL-Part loading ON after seeking to " + currentTime.toFixed(2) + " with buffer @" + bufferEnd.toFixed(2));
+              _this.loadingParts = shouldLoadParts;
+            }
+          }
         }
 
         // in case seeking occurs although no media buffered, adjust startPosition and nextLoadPosition to seek target
@@ -12751,8 +12760,16 @@
       } else if (!frag.encrypted && details.encryptedFragments.length) {
         this.keyLoader.loadClear(frag, details.encryptedFragments);
       }
+      var fragPrevious = this.fragPrevious;
+      if (frag.sn !== 'initSegment' && (!fragPrevious || frag.sn !== fragPrevious.sn)) {
+        var shouldLoadParts = this.shouldLoadParts(level.details, frag.end);
+        if (shouldLoadParts !== this.loadingParts) {
+          this.log("LL-Part loading " + (shouldLoadParts ? 'ON' : 'OFF') + " loading sn " + (fragPrevious == null ? void 0 : fragPrevious.sn) + "->" + frag.sn);
+          this.loadingParts = shouldLoadParts;
+        }
+      }
       targetBufferTime = Math.max(frag.start, targetBufferTime || 0);
-      if (this.config.lowLatencyMode && frag.sn !== 'initSegment') {
+      if (this.loadingParts && frag.sn !== 'initSegment') {
         var partList = details.partList;
         if (partList && progressCallback) {
           if (targetBufferTime > frag.end && details.fragmentHint) {
@@ -12794,6 +12811,13 @@
           }
         }
       }
+      if (frag.sn !== 'initSegment' && this.loadingParts) {
+        this.log("LL-Part loading OFF after next part miss @" + targetBufferTime.toFixed(2));
+        this.loadingParts = false;
+      } else if (!frag.url) {
+        // Selected fragment hint for part but not loading parts
+        return Promise.resolve(null);
+      }
       this.log("Loading fragment " + frag.sn + " cc: " + frag.cc + " " + (details ? 'of [' + details.startSN + '-' + details.endSN + '] ' : '') + (this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track') + ": " + frag.level + ", target: " + parseFloat(targetBufferTime.toFixed(3)));
       // Don't update nextLoadPosition for fragments which are not buffered
       if (isFiniteNumber(frag.sn) && !this.bitrateTest) {
@@ -12896,8 +12920,36 @@
       if (part) {
         part.stats.parsing.end = now;
       }
+      // See if part loading should be disabled/enabled based on buffer and playback position.
+      if (frag.sn !== 'initSegment') {
+        var levelDetails = this.getLevelDetails();
+        var loadingPartsAtEdge = levelDetails && frag.sn > levelDetails.endSN;
+        var shouldLoadParts = loadingPartsAtEdge || this.shouldLoadParts(levelDetails, frag.end);
+        if (shouldLoadParts !== this.loadingParts) {
+          this.log("LL-Part loading " + (shouldLoadParts ? 'ON' : 'OFF') + " after parsing segment ending @" + frag.end.toFixed(2));
+          this.loadingParts = shouldLoadParts;
+        }
+      }
       this.updateLevelTiming(frag, part, level, chunkMeta.partial);
     };
+    _proto.shouldLoadParts = function shouldLoadParts(details, bufferEnd) {
+      if (this.config.lowLatencyMode) {
+        if (!details) {
+          return this.loadingParts;
+        }
+        if (details != null && details.partList) {
+          var _details$fragmentHint;
+          // Buffer must be ahead of first part + duration of parts after last segment
+          // and playback must be at or past segment adjacent to part list
+          var firstPart = details.partList[0];
+          var safePartStart = firstPart.end + (((_details$fragmentHint = details.fragmentHint) == null ? void 0 : _details$fragmentHint.duration) || 0);
+          if (bufferEnd >= safePartStart && this.lastCurrentTime > firstPart.start - firstPart.fragment.duration) {
+            return true;
+          }
+        }
+      }
+      return false;
+    };
     _proto.getCurrentContext = function getCurrentContext(chunkMeta) {
       var levels = this.levels,
         fragCurrent = this.fragCurrent;
@@ -13032,7 +13084,8 @@
       // find fragment index, contiguous with end of buffer position
       var config = this.config;
       var start = fragments[0].start;
-      var frag;
+      var canLoadParts = config.lowLatencyMode && !!levelDetails.partList;
+      var frag = null;
       if (levelDetails.live) {
         var initialLiveManifestSize = config.initialLiveManifestSize;
         if (fragLen < initialLiveManifestSize) {
@@ -13044,6 +13097,10 @@
         // Do not load using live logic if the starting frag is requested - we want to use getFragmentAtPosition() so that
         // we get the fragment matching that start time
         if (!levelDetails.PTSKnown && !this.startFragRequested && this.startPosition === -1 || pos < start) {
+          if (canLoadParts && !this.loadingParts) {
+            this.log("LL-Part loading ON for initial live fragment");
+            this.loadingParts = true;
+          }
           frag = this.getInitialLiveFragment(levelDetails, fragments);
           this.startPosition = this.nextLoadPosition = frag ? this.hls.liveSyncPosition || frag.start : pos;
         }
@@ -13054,7 +13111,7 @@
 
       // If we haven't run into any special cases already, just load the fragment most closely matching the requested position
       if (!frag) {
-        var end = config.lowLatencyMode ? levelDetails.partEnd : levelDetails.fragmentEnd;
+        var end = this.loadingParts ? levelDetails.partEnd : levelDetails.fragmentEnd;
         frag = this.getFragmentAtPosition(pos, end, levelDetails);
       }
       return this.mapToInitFragWhenRequired(frag);
@@ -13168,7 +13225,7 @@
       var fragmentHint = levelDetails.fragmentHint;
       var tolerance = config.maxFragLookUpTolerance;
       var partList = levelDetails.partList;
-      var loadingParts = !!(config.lowLatencyMode && partList != null && partList.length && fragmentHint);
+      var loadingParts = !!(this.loadingParts && partList != null && partList.length && fragmentHint);
       if (loadingParts && fragmentHint && !this.bitrateTest) {
         // Include incomplete fragment with parts at end
         fragments = fragments.concat(fragmentHint);
@@ -21268,7 +21325,7 @@
        * Get the video-dev/hls.js package version.
        */
       function get() {
-        return "1.5.5-0.canary.9985";
+        return "1.5.5-0.canary.9987";
       }
     }, {
       key: "Events",