hls.js 1.5.5-0.canary.9984 → 1.5.5-0.canary.9986

package/dist/hls.js

@@ -644,7 +644,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.9984");
+        newLogger.log("Debug logs enabled for \"" + context + "\" in hls.js version " + "1.5.5-0.canary.9986");
       } catch (e) {
         /* log fn threw an exception. All logger methods are no-ops. */
         return createLogger();
@@ -6502,7 +6502,12 @@
           var cdnAge = lastAdvanced + details.ageHeader;
           var currentGoal = Math.min(cdnAge - details.partTarget, details.targetduration * 1.5);
           if (currentGoal > 0) {
-            if (previousDetails && currentGoal > previousDetails.tuneInGoal) {
+            if (cdnAge > details.targetduration * 3) {
+              // Omit segment and part directives when the last response was more than 3 target durations ago,
+              this.log("Playlist last advanced " + lastAdvanced.toFixed(2) + "s ago. Omitting segment and part directives.");
+              msn = undefined;
+              part = undefined;
+            } else if (previousDetails != null && previousDetails.tuneInGoal && cdnAge - details.partTarget > previousDetails.tuneInGoal) {
               // If we attempted to get the next or latest playlist update, but currentGoal increased,
               // then we either can't catchup, or the "age" header cannot be trusted.
               this.warn("CDN Tune-in goal increased from: " + previousDetails.tuneInGoal + " to: " + currentGoal + " with playlist age: " + details.age);
@@ -9549,6 +9554,7 @@
       _this.decrypter = void 0;
       _this.initPTS = [];
       _this.buffering = true;
+      _this.loadingParts = false;
       _this.onMediaSeeking = function () {
         var _assertThisInitialize = _assertThisInitialized(_this),
           config = _assertThisInitialize.config,
@@ -9584,6 +9590,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
@@ -9993,8 +10007,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) {
@@ -10036,6 +10058,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) {
@@ -10138,8 +10167,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;
@@ -10274,7 +10331,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) {
@@ -10286,6 +10344,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;
         }
@@ -10296,7 +10358,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);
@@ -10410,7 +10472,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);
@@ -27203,7 +27265,12 @@
         if (curLevel.fragmentError === 0) {
           curLevel.loadError = 0;
         }
-        this.playlistLoaded(level, data, curLevel.details);
+        // Ignore matching details populated by loading a Media Playlist directly
+        var previousDetails = curLevel.details;
+        if (previousDetails === data.details && previousDetails.advanced) {
+          previousDetails = undefined;
+        }
+        this.playlistLoaded(level, data, previousDetails);
       } else if ((_data$deliveryDirecti2 = data.deliveryDirectives) != null && _data$deliveryDirecti2.skip) {
         // received a delta playlist update that cannot be merged
         details.deltaUpdateFailed = true;
@@ -30024,7 +30091,7 @@
        * Get the video-dev/hls.js package version.
        */
       function get() {
-        return "1.5.5-0.canary.9984";
+        return "1.5.5-0.canary.9986";
       }
     }, {
       key: "Events",

package/dist/hls.js.d.ts

@@ -247,6 +247,7 @@ export declare class BaseStreamController extends TaskLoop implements NetworkCom
     protected decrypter: Decrypter;
     protected initPTS: RationalTimestamp[];
     protected buffering: boolean;
+    private loadingParts;
     constructor(hls: Hls, fragmentTracker: FragmentTracker, keyLoader: KeyLoader, logPrefix: string, playlistType: PlaylistLevelType);
     protected registerListeners(): void;
     protected unregisterListeners(): void;
@@ -283,6 +284,7 @@ export declare class BaseStreamController extends TaskLoop implements NetworkCom
     private doFragPartsLoad;
     private handleFragLoadError;
     protected _handleTransmuxerFlush(chunkMeta: ChunkMetadata): void;
+    private shouldLoadParts;
     protected getCurrentContext(chunkMeta: ChunkMetadata): {
         frag: Fragment;
         part: Part | null;