hls.js 1.6.3-0.canary.11252 → 1.6.3-0.canary.11254

package/src/controller/audio-stream-controller.ts

@@ -1,5 +1,5 @@
 import BaseStreamController, { State } from './base-stream-controller';
-import { findFragWithCC, findNearestWithCC } from './fragment-finders';
+import { findNearestWithCC } from './fragment-finders';
 import { FragmentState } from './fragment-tracker';
 import ChunkCache from '../demux/chunk-cache';
 import TransmuxerInterface from '../demux/transmuxer-interface';
@@ -161,32 +161,56 @@ class AudioStreamController
           (!waitingData && !this.loadingParts) ||
           (waitingData && waitingData.frag.cc !== cc)
         ) {
-          this.nextLoadPosition = this.findSyncFrag(frag).start;
+          this.syncWithAnchor(frag, waitingData?.frag);
         }
-        this.tick();
       } else if (
         !this.hls.hasEnoughToStart &&
         inFlightFrag &&
         inFlightFrag.cc !== cc
       ) {
-        this.startFragRequested = false;
-        this.nextLoadPosition = this.findSyncFrag(frag).start;
         inFlightFrag.abortRequests();
-        this.resetLoadingState();
+        this.syncWithAnchor(frag, inFlightFrag);
       } else if (this.state === State.IDLE) {
         this.tick();
       }
     }
   }
 
-  private findSyncFrag(mainFrag: MediaFragment): MediaFragment {
+  protected getLoadPosition(): number {
+    if (!this.startFragRequested && this.nextLoadPosition >= 0) {
+      return this.nextLoadPosition;
+    }
+    return super.getLoadPosition();
+  }
+
+  private syncWithAnchor(
+    mainAnchor: MediaFragment,
+    waitingToAppend: Fragment | undefined,
+  ) {
+    // Drop waiting fragment if videoTrackCC has changed since waitingFragment was set and initPTS was not found
+    const mainFragLoading = this.mainFragLoading?.frag || null;
+    if (waitingToAppend) {
+      if (mainFragLoading?.cc === waitingToAppend.cc) {
+        // Wait for loading frag to complete and INIT_PTS_FOUND
+        return;
+      }
+    }
+    const targetDiscontinuity = (mainFragLoading || mainAnchor).cc;
     const trackDetails = this.getLevelDetails();
-    const cc = mainFrag.cc;
-    return (
-      findNearestWithCC(trackDetails, cc, mainFrag) ||
-      (trackDetails && findFragWithCC(trackDetails.fragments, cc)) ||
-      mainFrag
-    );
+    const pos = this.getLoadPosition();
+    const syncFrag = findNearestWithCC(trackDetails, targetDiscontinuity, pos);
+    // Only stop waiting for audioFrag.cc if an audio segment of the same discontinuity domain (cc) is found
+    if (syncFrag) {
+      this.log(
+        `Waiting fragment cc (${waitingToAppend?.cc}) cancelled because video is at cc ${mainAnchor.cc}`,
+      );
+      this.startFragRequested = false;
+      this.nextLoadPosition = syncFrag.start;
+      this.resetLoadingState();
+      if (this.state === State.IDLE) {
+        this.doTickIdle();
+      }
+    }
   }
 
   startLoad(startPosition: number, skipSeekToStartPosition?: boolean) {
@@ -265,12 +289,7 @@ class AudioStreamController
               super._handleFragmentLoadComplete(data);
             }
           } else if (mainAnchor && mainAnchor.cc !== waitingData.frag.cc) {
-            // Drop waiting fragment if videoTrackCC has changed since waitingFragment was set and initPTS was not found
-            this.log(
-              `Waiting fragment cc (${frag.cc}) cancelled because video is at cc ${mainAnchor.cc}`,
-            );
-            this.nextLoadPosition = this.findSyncFrag(mainAnchor).start;
-            this.clearWaitingFragment();
+            this.syncWithAnchor(mainAnchor, waitingData.frag);
           }
         } else {
           this.state = State.IDLE;
@@ -281,23 +300,12 @@ class AudioStreamController
     this.onTickEnd();
   }
 
-  clearWaitingFragment() {
+  protected resetLoadingState() {
     const waitingData = this.waitingData;
     if (waitingData) {
-      if (!this.hls.hasEnoughToStart) {
-        // Load overlapping fragment on start when discontinuity start times are not aligned
-        this.startFragRequested = false;
-      }
       this.fragmentTracker.removeFragment(waitingData.frag);
       this.waitingData = null;
-      if (this.state !== State.STOPPED) {
-        this.state = State.IDLE;
-      }
     }
-  }
-
-  protected resetLoadingState() {
-    this.clearWaitingFragment();
     super.resetLoadingState();
   }
 

package/src/controller/base-stream-controller.ts

@@ -2,7 +2,7 @@ import { ErrorActionFlags, NetworkErrorAction } from './error-controller';
 import {
   findFragmentByPDT,
   findFragmentByPTS,
-  findFragWithCC,
+  findNearestWithCC,
 } from './fragment-finders';
 import { FragmentState } from './fragment-tracker';
 import Decrypter from '../crypt/decrypter';
@@ -1298,7 +1298,7 @@ export default class BaseStreamController
           this.log(`LL-Part loading ON for initial live fragment`);
           this.loadingParts = true;
         }
-        frag = this.getInitialLiveFragment(levelDetails, fragments);
+        frag = this.getInitialLiveFragment(levelDetails);
         const mainStart = this.hls.startPosition;
         const liveSyncPosition = this.hls.liveSyncPosition;
         const startPosition = frag
@@ -1506,8 +1506,8 @@ export default class BaseStreamController
   */
   protected getInitialLiveFragment(
     levelDetails: LevelDetails,
-    fragments: MediaFragment[],
   ): MediaFragment | null {
+    const fragments = levelDetails.fragments;
     const fragPrevious = this.fragPrevious;
     let frag: MediaFragment | null = null;
     if (fragPrevious) {
@@ -1543,7 +1543,11 @@ export default class BaseStreamController
         // It's important to stay within the continuity range if available; otherwise the fragments in the playlist
         // will have the wrong start times
         if (!frag) {
-          frag = findFragWithCC(fragments, fragPrevious.cc);
+          frag = findNearestWithCC(
+            levelDetails,
+            fragPrevious.cc,
+            fragPrevious.end,
+          );
           if (frag) {
             this.log(
               `Live playlist, switching playlist, load frag with same CC: ${frag.sn}`,

package/src/controller/error-controller.ts

@@ -341,7 +341,7 @@ export default class ErrorController
       // Search for next level to retry
       let nextLevel = -1;
       const { levels, loadLevel, minAutoLevel, maxAutoLevel } = hls;
-      if (!hls.autoLevelEnabled) {
+      if (!hls.autoLevelEnabled && !hls.config.preserveManualLevelOnError) {
         hls.loadLevel = -1;
       }
       const fragErrorType = data.frag?.type;

package/src/controller/fragment-finders.ts

@@ -33,7 +33,6 @@ export function findFragmentByPDT(
     return null;
   }
 
-  maxFragLookUpTolerance = maxFragLookUpTolerance || 0;
   for (let seg = 0; seg < fragments.length; ++seg) {
     const frag = fragments[seg];
     if (pdtWithinToleranceTest(PDTValue, maxFragLookUpTolerance, frag)) {
@@ -225,28 +224,33 @@ export function findFragWithCC(
 export function findNearestWithCC(
   details: LevelDetails | undefined,
   cc: number,
-  fragment: MediaFragment,
+  pos: number,
 ): MediaFragment | null {
   if (details) {
     if (details.startCC <= cc && details.endCC >= cc) {
-      const start = fragment.start;
-      const end = fragment.end;
       let fragments = details.fragments;
-      if (!fragment.relurl) {
-        const { fragmentHint } = details;
-        if (fragmentHint) {
-          fragments = fragments.concat(fragmentHint);
-        }
+      const { fragmentHint } = details;
+      if (fragmentHint) {
+        fragments = fragments.concat(fragmentHint);
       }
-      return BinarySearch.search(fragments, (candidate) => {
-        if (candidate.cc < cc || candidate.end <= start) {
+      let closest: MediaFragment | undefined;
+      BinarySearch.search(fragments, (candidate) => {
+        if (candidate.cc < cc) {
+          return 1;
+        }
+        if (candidate.cc > cc) {
+          return -1;
+        }
+        closest = candidate;
+        if (candidate.end <= pos) {
           return 1;
-        } else if (candidate.cc > cc || candidate.start >= end) {
+        }
+        if (candidate.start > pos) {
           return -1;
-        } else {
-          return 0;
         }
+        return 0;
       });
+      return closest || null;
     }
   }
   return null;

package/src/controller/interstitials-controller.ts

@@ -2437,7 +2437,7 @@ Schedule: ${scheduleItems.map((seg) => segmentToString(seg))} pos: ${this.timeli
   }
 
   private bufferAssetPlayer(player: HlsAssetPlayer, media: HTMLMediaElement) {
-    const { interstitial, assetItem, assetId } = player;
+    const { interstitial, assetItem } = player;
     const scheduleIndex = this.schedule.findEventIndex(interstitial.identifier);
     const item = this.schedule.items?.[scheduleIndex];
     if (!item) {