Fix audio playlist fragment selection syncing with main playlist discontinuity sequence

robwalch · robwalch · commit a2d6b48ef238 · 2025-05-28T14:52:16.000-07:00
Fixes #7262
diff --git a/api-extractor/report/hls.js.api.md b/api-extractor/report/hls.js.api.md
@@ -183,10 +183,10 @@ export type AudioSelectionOption = {
 export class AudioStreamController extends BaseStreamController implements NetworkComponentAPI {
     constructor(hls: Hls, fragmentTracker: FragmentTracker, keyLoader: KeyLoader);
     // (undocumented)
-    clearWaitingFragment(): void;
-    // (undocumented)
     doTick(): void;
     // (undocumented)
+    protected getLoadPosition(): number;
+    // (undocumented)
     protected _handleFragmentLoadComplete(fragLoadedData: FragLoadedData): void;
     // (undocumented)
     _handleFragmentLoadProgress(data: FragLoadedData): void;
@@ -434,7 +434,7 @@ export class BaseStreamController extends TaskLoop implements NetworkComponentAP
     // (undocumented)
     protected getFwdBufferInfoAtPos(bufferable: Bufferable | null, pos: number, type: PlaylistLevelType, maxBufferHole: number): BufferInfo | null;
     // (undocumented)
-    protected getInitialLiveFragment(levelDetails: LevelDetails, fragments: MediaFragment[]): MediaFragment | null;
+    protected getInitialLiveFragment(levelDetails: LevelDetails): MediaFragment | null;
     // (undocumented)
     getLevelDetails(): LevelDetails | undefined;
     // (undocumented)
diff --git a/src/controller/audio-stream-controller.ts b/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();
   }
 
diff --git a/src/controller/base-stream-controller.ts b/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}`,
diff --git a/src/controller/fragment-finders.ts b/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;
diff --git a/src/controller/interstitials-controller.ts b/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) {
diff --git a/tests/mocks/data.ts b/tests/mocks/data.ts
@@ -1,10 +1,21 @@
 import { Fragment } from '../../src/loader/fragment';
 import { PlaylistLevelType } from '../../src/types/loader';
+import type { MediaFragment } from '../../src/loader/fragment';
 
-function fragment(options) {
+type MockMediaFragmentData = {
+  level: number;
+  programDateTime: number;
+  duration: number;
+  start: number;
+  sn: number;
+  cc: number;
+  deltaPTS?: number;
+} & Partial<MediaFragment>;
+
+export function fragment(options: MockMediaFragmentData): MediaFragment {
   const frag = new Fragment(PlaylistLevelType.MAIN, '');
-  Object.assign(frag, options);
-  return frag;
+  Object.assign(frag, { level: 0 }, options);
+  return frag as MediaFragment;
 }
 
 export const mockFragments = [
@@ -50,3 +61,30 @@ export const mockFragments = [
     cc: 1,
   }),
 ];
+
+export const mockFragmentsWithDiscos = mockFragments.concat([
+  fragment({
+    programDateTime: 1505502691523,
+    level: 2,
+    duration: 5.0,
+    start: 25.0,
+    sn: 5,
+    cc: 2,
+  }),
+  fragment({
+    programDateTime: 1505502696523,
+    level: 2,
+    duration: 5.0,
+    start: 30.0,
+    sn: 6,
+    cc: 2,
+  }),
+  fragment({
+    programDateTime: 1505502701523,
+    level: 2,
+    duration: 5.0,
+    start: 35.0,
+    sn: 7,
+    cc: 2,
+  }),
+]);
diff --git a/tests/unit/controller/fragment-finders.ts b/tests/unit/controller/fragment-finders.ts
diff --git a/tests/unit/controller/stream-controller.ts b/tests/unit/controller/stream-controller.ts

Original file line number	Diff line number	Diff line change
`@@ -2437,7 +2437,7 @@ Schedule: ${scheduleItems.map((seg) => segmentToString(seg))} pos: ${this.timeli`
`2437`	`2437`	`}`
`2438`	`2438`
`2439`	`2439`	`private bufferAssetPlayer(player: HlsAssetPlayer, media: HTMLMediaElement) {`
`2440`		`- const { interstitial, assetItem, assetId } = player;`
	`2440`	`+ const { interstitial, assetItem } = player;`
`2441`	`2441`	`const scheduleIndex = this.schedule.findEventIndex(interstitial.identifier);`
`2442`	`2442`	`const item = this.schedule.items?.[scheduleIndex];`
`2443`	`2443`	`if (!item) {`