hls.js 1.5.12-0.canary.10397 → 1.5.12-0.canary.10399

package/dist/hls.js

@@ -522,7 +522,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.12-0.canary.10397");
+        newLogger.log("Debug logs enabled for \"" + context + "\" in hls.js version " + "1.5.12-0.canary.10399");
       } catch (e) {
         /* log fn threw an exception. All logger methods are no-ops. */
         return createLogger();
@@ -5339,6 +5339,7 @@
       this.currentTime = 0;
       this.stallCount = 0;
       this._latency = null;
+      this._targetLatencyUpdated = false;
       this.onTimeupdate = function () {
         var media = _this.media,
           levelDetails = _this.levelDetails;
@@ -5483,11 +5484,16 @@
           lowLatencyMode = _this$config2.lowLatencyMode;
         var userConfig = this.hls.userConfig;
         var targetLatency = lowLatencyMode ? partHoldBack || holdBack : holdBack;
-        if (userConfig.liveSyncDuration || userConfig.liveSyncDurationCount || targetLatency === 0) {
+        if (this._targetLatencyUpdated || userConfig.liveSyncDuration || userConfig.liveSyncDurationCount || targetLatency === 0) {
           targetLatency = liveSyncDuration !== undefined ? liveSyncDuration : liveSyncDurationCount * targetduration;
         }
         var maxLiveSyncOnStallIncrease = targetduration;
         return targetLatency + Math.min(this.stallCount * this.config.liveSyncOnStallIncrease, maxLiveSyncOnStallIncrease);
+      },
+      set: function set(latency) {
+        this.stallCount = 0;
+        this.config.liveSyncDuration = latency;
+        this._targetLatencyUpdated = true;
       }
     }, {
       key: "liveSyncPosition",
@@ -10258,7 +10264,7 @@
         // If backtracking, always remove from the tracker without reducing max buffer length
         var backtrackFragment = this.backtrackFragment;
         var backtracked = backtrackFragment ? frag.sn - backtrackFragment.sn : 0;
-        if (backtracked === 1 || this.reduceMaxBufferLength(minForwardBufferLength)) {
+        if (backtracked === 1 || this.reduceMaxBufferLength(minForwardBufferLength, frag.duration)) {
           fragmentTracker.removeFragment(frag);
         }
       } else if (((_this$mediaBuffer = this.mediaBuffer) == null ? void 0 : _this$mediaBuffer.buffered.length) === 0) {
@@ -10756,10 +10762,10 @@
       }
       return Math.min(maxBufLen, config.maxMaxBufferLength);
     };
-    _proto.reduceMaxBufferLength = function reduceMaxBufferLength(threshold) {
+    _proto.reduceMaxBufferLength = function reduceMaxBufferLength(threshold, fragDuration) {
       var config = this.config;
-      var minLength = threshold || config.maxBufferLength;
-      var reducedLength = config.maxMaxBufferLength / 2;
+      var minLength = Math.max(Math.min(threshold, config.maxBufferLength), fragDuration);
+      var reducedLength = Math.max(threshold - fragDuration * 3, config.maxMaxBufferLength / 2);
       if (reducedLength >= minLength) {
         // reduce max buffer length as it might be too high. we do this to avoid loop flushing ...
         config.maxMaxBufferLength = reducedLength;
@@ -11134,13 +11140,14 @@
     _proto.reduceLengthAndFlushBuffer = function reduceLengthAndFlushBuffer(data) {
       // if in appending state
       if (this.state === State.PARSING || this.state === State.PARSED) {
+        var frag = data.frag;
         var playlistType = data.parent;
         var bufferedInfo = this.getFwdBufferInfo(this.mediaBuffer, playlistType);
         // 0.5 : tolerance needed as some browsers stalls playback before reaching buffered end
         // reduce max buf len if current position is buffered
         var buffered = bufferedInfo && bufferedInfo.len > 0.5;
         if (buffered) {
-          this.reduceMaxBufferLength(bufferedInfo.len);
+          this.reduceMaxBufferLength(bufferedInfo.len, (frag == null ? void 0 : frag.duration) || 10);
         }
         var flushBuffer = !buffered;
         if (flushBuffer) {
@@ -11149,9 +11156,9 @@
           // in that case flush the whole audio buffer to recover
           this.warn("Buffer full error while media.currentTime is not buffered, flush " + playlistType + " buffer");
         }
-        if (data.frag) {
-          this.fragmentTracker.removeFragment(data.frag);
-          this.nextLoadPosition = data.frag.start;
+        if (frag) {
+          this.fragmentTracker.removeFragment(frag);
+          this.nextLoadPosition = frag.start;
         }
         this.resetLoadingState();
         return flushBuffer;
@@ -30740,6 +30747,9 @@
       key: "targetLatency",
       get: function get() {
         return this.latencyController.targetLatency;
+      },
+      set: function set(latency) {
+        this.latencyController.targetLatency = latency;
       }
 
       /**
@@ -30778,7 +30788,7 @@
        * Get the video-dev/hls.js package version.
        */
       function get() {
-        return "1.5.12-0.canary.10397";
+        return "1.5.12-0.canary.10399";
       }
     }, {
       key: "Events",

package/dist/hls.js.d.ts

@@ -302,7 +302,7 @@ export declare class BaseStreamController extends TaskLoop implements NetworkCom
     protected getFwdBufferInfo(bufferable: Bufferable | null, type: PlaylistLevelType): BufferInfo | null;
     protected getFwdBufferInfoAtPos(bufferable: Bufferable | null, pos: number, type: PlaylistLevelType): BufferInfo | null;
     protected getMaxBufferLength(levelBitrate?: number): number;
-    protected reduceMaxBufferLength(threshold: number): boolean;
+    protected reduceMaxBufferLength(threshold: number, fragDuration: number): boolean;
     protected getAppendedFrag(position: number, playlistType?: PlaylistLevelType): Fragment | null;
     protected getNextFragment(pos: number, levelDetails: LevelDetails): Fragment | null;
     protected isLoopLoading(frag: Fragment, targetBufferTime: number): boolean;
@@ -1673,6 +1673,7 @@ declare class Hls implements HlsEventEmitter {
      * target distance from the edge as calculated by the latency controller
      */
     get targetLatency(): number | null;
+    set targetLatency(latency: number);
     /**
      * the rate at which the edge of the current live playlist is advancing or 1 if there is none
      */