Limit buffering while paused outside live sliding window (#7788)

* Limit buffering while paused outside live sliding window and better handle QuotaExceededError
Improve flushing behavior on next and immediate switch when playhead is behind live window
Fixes #7777

* Remove buffered audio on full quality switch when playhead is behind live sliding start to keep buffered media aligned

Author: robwalch

api-extractor/report/hls.js.api.md

@@ -404,6 +404,8 @@ export class BaseStreamController extends TaskLoop implements NetworkComponentAP
     // (undocumented)
     protected doTick(): void;
     // (undocumented)
+    protected exceedsMaxBuffer(bufferInfo: BufferInfo, maxBufLen: number, selected: Fragment): boolean;
+    // (undocumented)
     protected filterReplacedPrimary(frag: MediaFragment | null, details: LevelDetails | undefined): MediaFragment | null;
     // (undocumented)
     protected flushBufferGap(frag: Fragment): void;

src/controller/audio-stream-controller.ts

@@ -413,6 +413,10 @@ class AudioStreamController
       return;
     }
 
+    if (this.exceedsMaxBuffer(bufferInfo, maxBufLen, frag)) {
+      return;
+    }
+
     // Request audio segments up to one fragment ahead of main stream-controller
     let mainFragLoading = this.mainFragLoading?.frag || null;
     if (

src/controller/base-stream-controller.ts

@@ -1295,6 +1295,28 @@ export default class BaseStreamController
     return Math.min(maxBufLen, config.maxMaxBufferLength);
   }
 
+  protected exceedsMaxBuffer(
+    bufferInfo: BufferInfo,
+    maxBufLen: number,
+    selected: Fragment,
+  ): boolean {
+    const nextStart = bufferInfo.nextStart;
+    if (nextStart && selected.start > nextStart) {
+      const bufferedRanges = bufferInfo.buffered;
+      if (bufferedRanges) {
+        let fullBufferLength = bufferInfo.len;
+        const bufferedIndex = bufferInfo.bufferedIndex;
+        for (let i = bufferedRanges.length - 1; i > bufferedIndex; i--) {
+          if (bufferedRanges[i].start < selected.start) {
+            fullBufferLength += bufferedRanges[i].end - bufferedRanges[i].start;
+          }
+        }
+        return fullBufferLength >= maxBufLen;
+      }
+    }
+    return false;
+  }
+
   protected reduceMaxBufferLength(threshold: number, fragDuration: number) {
     const config = this.config;
     const minLength = Math.max(
@@ -1341,7 +1363,7 @@ export default class BaseStreamController
 
     // find fragment index, contiguous with end of buffer position
     const { config } = this;
-    const start = fragments[0].start;
+    const playlistStart = levelDetails.fragmentStart;
     const canLoadParts = config.lowLatencyMode && !!levelDetails.partList;
     let frag: MediaFragment | null = null;
 
@@ -1361,26 +1383,49 @@ export default class BaseStreamController
         (!levelDetails.PTSKnown &&
           !this.startFragRequested &&
           this.startPosition === -1) ||
-        pos < start
+        pos < playlistStart
       ) {
         if (canLoadParts && !this.loadingParts) {
           this.log(`LL-Part loading ON for initial live fragment`);
           this.loadingParts = true;
         }
         frag = this.getInitialLiveFragment(levelDetails);
+        const configValue = this.config.startPosition;
         const mainStart = this.hls.startPosition;
         const liveSyncPosition = this.hls.liveSyncPosition;
-        const startPosition = frag
-          ? (mainStart !== -1 && mainStart >= start
-              ? mainStart
-              : liveSyncPosition) || frag.start
-          : pos;
-        this.log(
-          `Setting startPosition to ${startPosition} to match start frag at live edge. mainStart: ${mainStart} liveSyncPosition: ${liveSyncPosition} frag.start: ${frag?.start}`,
-        );
-        this.startPosition = this.nextLoadPosition = startPosition;
+        const fragStart = frag?.start || 0;
+
+        let startPosition: number | undefined;
+        let reason: string | undefined;
+        if (mainStart !== -1 && mainStart >= playlistStart) {
+          startPosition = mainStart;
+          reason = mainStart === configValue ? 'config' : 'next load start';
+        } else if (liveSyncPosition !== null) {
+          startPosition = liveSyncPosition;
+          reason = 'live edge';
+        } else {
+          startPosition = pos;
+          reason = 'buffer pos';
+        }
+        if (startPosition < fragStart) {
+          startPosition = fragStart;
+          reason = 'live frag start';
+        }
+        if (startPosition < playlistStart) {
+          startPosition = playlistStart;
+          reason = 'playlist start';
+        }
+        if (
+          this.startPosition != startPosition ||
+          this.nextLoadPosition != startPosition
+        ) {
+          this.log(
+            `Setting startPosition to ${startPosition.toFixed(3)} ${mainStart === -1 ? '' : `(from ${configValue}) `}based on ${reason}. live edge: ${liveSyncPosition} live frag start: ${fragStart.toFixed(3)} playlist start: ${playlistStart.toFixed(3)} buffer pos: ${pos}`,
+          );
+          this.startPosition = this.nextLoadPosition = startPosition;
+        }
       }
-    } else if (pos <= start) {
+    } else if (pos <= playlistStart) {
       // VoD playlist: if loadPosition before start of playlist, load first fragment
       frag = fragments[0];
     }
@@ -1404,11 +1449,13 @@ export default class BaseStreamController
   }
 
   protected isLoopLoading(frag: Fragment, targetBufferTime: number): boolean {
+    if (this.nextLoadPosition <= targetBufferTime) {
+      return false;
+    }
     const trackerState = this.fragmentTracker.getState(frag);
     return (
-      (trackerState === FragmentState.OK ||
-        (trackerState === FragmentState.PARTIAL && !!frag.gap)) &&
-      this.nextLoadPosition > targetBufferTime
+      trackerState === FragmentState.OK ||
+      (trackerState === FragmentState.PARTIAL && !!frag.gap)
     );
   }
 
@@ -1596,14 +1643,16 @@ export default class BaseStreamController
     if (fragPrevious) {
       if (levelDetails.hasProgramDateTime) {
         // Prefer using PDT, because it can be accurate enough to choose the correct fragment without knowing the level sliding
-        this.log(
-          `Live playlist, switching playlist, load frag with same PDT: ${fragPrevious.programDateTime}`,
-        );
         frag = findFragmentByPDT(
           fragments,
           fragPrevious.endProgramDateTime,
           this.config.maxFragLookUpTolerance,
         );
+        if (frag) {
+          this.log(
+            `Live playlist, switching playlist, load frag with same PDT: ${fragPrevious.programDateTime}`,
+          );
+        }
       }
       if (!frag) {
         // SN does not need to be accurate between renditions, but depending on the packaging it may be so.

src/controller/stream-controller.ts

@@ -370,6 +370,11 @@ export default class StreamController
     if (!frag) {
       return;
     }
+
+    if (this.exceedsMaxBuffer(bufferInfo, maxBufLen, frag)) {
+      return;
+    }
+
     if (frag.initSegment && !frag.initSegment.data && !this.bitrateTest) {
       frag = frag.initSegment;
     }
@@ -427,6 +432,13 @@ export default class StreamController
   public immediateLevelSwitch() {
     this.abortCurrentFrag();
     this.flushMainBuffer(0, Number.POSITIVE_INFINITY);
+    if (this.altAudio !== AlternateAudio.DISABLED) {
+      // If behind the live window, remove audio too to keep buffered media aligned
+      const liveWindowStart = this.getLevelDetails()?.fragmentStart || 0;
+      if (liveWindowStart > this.lastCurrentTime) {
+        super.flushMainBuffer(0, Number.POSITIVE_INFINITY, 'audio');
+      }
+    }
   }
 
   /**