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

package/dist/hls.light.mjs

@@ -420,7 +420,7 @@ function enableLogs(debugConfig, context, id) {
     // 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();
@@ -4570,6 +4570,7 @@ class LatencyController {
     this.currentTime = 0;
     this.stallCount = 0;
     this._latency = null;
+    this._targetLatencyUpdated = false;
     this.onTimeupdate = () => {
       const {
         media,
@@ -4647,12 +4648,17 @@ class LatencyController {
     } = this.config;
     const userConfig = this.hls.userConfig;
     let 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;
     }
     const maxLiveSyncOnStallIncrease = targetduration;
     return targetLatency + Math.min(this.stallCount * this.config.liveSyncOnStallIncrease, maxLiveSyncOnStallIncrease);
   }
+  set targetLatency(latency) {
+    this.stallCount = 0;
+    this.config.liveSyncDuration = latency;
+    this._targetLatencyUpdated = true;
+  }
   get liveSyncPosition() {
     const liveEdge = this.estimateLiveEdge();
     const targetLatency = this.targetLatency;
@@ -12755,7 +12761,7 @@ class BaseStreamController extends TaskLoop {
       // If backtracking, always remove from the tracker without reducing max buffer length
       const backtrackFragment = this.backtrackFragment;
       const 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) {
@@ -13256,10 +13262,10 @@ class BaseStreamController extends TaskLoop {
     }
     return Math.min(maxBufLen, config.maxMaxBufferLength);
   }
-  reduceMaxBufferLength(threshold) {
+  reduceMaxBufferLength(threshold, fragDuration) {
     const config = this.config;
-    const minLength = threshold || config.maxBufferLength;
-    const reducedLength = config.maxMaxBufferLength / 2;
+    const minLength = Math.max(Math.min(threshold, config.maxBufferLength), fragDuration);
+    const 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;
@@ -13649,13 +13655,14 @@ class BaseStreamController extends TaskLoop {
   reduceLengthAndFlushBuffer(data) {
     // if in appending state
     if (this.state === State.PARSING || this.state === State.PARSED) {
+      const frag = data.frag;
       const playlistType = data.parent;
       const 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
       const buffered = bufferedInfo && bufferedInfo.len > 0.5;
       if (buffered) {
-        this.reduceMaxBufferLength(bufferedInfo.len);
+        this.reduceMaxBufferLength(bufferedInfo.len, (frag == null ? void 0 : frag.duration) || 10);
       }
       const flushBuffer = !buffered;
       if (flushBuffer) {
@@ -13664,9 +13671,9 @@ class BaseStreamController extends TaskLoop {
         // 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;
@@ -20658,7 +20665,7 @@ class Hls {
    * Get the video-dev/hls.js package version.
    */
   static get version() {
-    return "1.5.12-0.canary.10397";
+    return "1.5.12-0.canary.10399";
   }
 
   /**
@@ -21453,6 +21460,9 @@ class Hls {
   get targetLatency() {
     return this.latencyController.targetLatency;
   }
+  set targetLatency(latency) {
+    this.latencyController.targetLatency = latency;
+  }
 
   /**
    * the rate at which the edge of the current live playlist is advancing or 1 if there is none