Merge pull request #6922 from video-dev/bugfix/live-av-desync-init-pts

- Do not adjust initPTS without accurate playlist time offset (when live playlist is out of sync).
- Do not re-emit AUDIO_TRACK_LOADED for track sync as it reruns playlist merge logic.
- Keep audio-stream-controller startPosition within playlist bounds.
- Fix audio-only main <-> track switching buffer flushing issues
- Do not treat live playlists as expired after three "misses" (static responses -> archived live / load segments anyway)

src/controller/audio-stream-controller.ts

@@ -14,6 +14,7 @@ import {
   alignMediaPlaylistByPDT,
 } from '../utils/discontinuities';
 import { mediaAttributesIdentical } from '../utils/media-option-attributes';
+import { useAlternateAudio } from '../utils/rendition-helper';
 import type { FragmentTracker } from './fragment-tracker';
 import type Hls from '../hls';
 import type { Fragment, MediaFragment, Part } from '../loader/fragment';
@@ -519,7 +520,7 @@ class AudioStreamController
     const cachedTrackLoadedData = this.cachedTrackLoadedData;
     if (cachedTrackLoadedData) {
       this.cachedTrackLoadedData = null;
-      this.hls.trigger(Events.AUDIO_TRACK_LOADED, cachedTrackLoadedData);
+      this.onAudioTrackLoaded(Events.AUDIO_TRACK_LOADED, cachedTrackLoadedData);
     }
   }
 
@@ -528,25 +529,28 @@ class AudioStreamController
     data: TrackLoadedData,
   ) {
     const { levels } = this;
-    const { details: newDetails, id: trackId } = data;
+    const { details: newDetails, id: trackId, groupId, track } = data;
+    if (!levels) {
+      this.warn(
+        `Audio tracks reset while loading track ${trackId} "${track.name}" of "${groupId}"`,
+      );
+      return;
+    }
     const mainDetails = this.mainDetails;
     if (
       !mainDetails ||
-      mainDetails.expired ||
-      newDetails.endCC > mainDetails.endCC
+      newDetails.endCC > mainDetails.endCC ||
+      mainDetails.expired
     ) {
       this.cachedTrackLoadedData = data;
       if (this.state !== State.STOPPED) {
         this.state = State.WAITING_TRACK;
       }
       return;
     }
-    if (!levels) {
-      this.warn(`Audio tracks were reset while loading level ${trackId}`);
-      return;
-    }
+    this.cachedTrackLoadedData = null;
     this.log(
-      `Audio track ${trackId} loaded [${newDetails.startSN},${
+      `Audio track ${trackId} "${track.name}" of "${groupId}" loaded [${newDetails.startSN},${
         newDetails.endSN
       }]${
         newDetails.lastPartSn
@@ -555,18 +559,18 @@ class AudioStreamController
       },duration:${newDetails.totalduration}`,
     );
 
-    const track = levels[trackId];
+    const trackLevel = levels[trackId];
     let sliding = 0;
-    if (newDetails.live || track.details?.live) {
+    if (newDetails.live || trackLevel.details?.live) {
       this.checkLiveUpdate(newDetails);
       if (newDetails.deltaUpdateFailed) {
         return;
       }
 
-      if (track.details) {
+      if (trackLevel.details) {
         sliding = this.alignPlaylists(
           newDetails,
-          track.details,
+          trackLevel.details,
           this.levelLastLoaded?.details,
         );
       }
@@ -580,8 +584,8 @@ class AudioStreamController
         sliding = newDetails.fragmentStart;
       }
     }
-    track.details = newDetails;
-    this.levelLastLoaded = track;
+    trackLevel.details = newDetails;
+    this.levelLastLoaded = trackLevel;
 
     // compute start position if we are aligned with the main playlist
     if (!this.startFragRequested) {
@@ -1026,9 +1030,14 @@ class AudioStreamController
         bufferedTrack.name !== switchingTrack.name ||
         bufferedTrack.lang !== switchingTrack.lang)
     ) {
-      this.log('Switching audio track : flushing all audio');
-      super.flushMainBuffer(0, Number.POSITIVE_INFINITY, 'audio');
-      this.bufferedTrack = null;
+      if (useAlternateAudio(switchingTrack.url, this.hls)) {
+        this.log('Switching audio track : flushing all audio');
+        super.flushMainBuffer(0, Number.POSITIVE_INFINITY, 'audio');
+        this.bufferedTrack = null;
+      } else {
+        // Main is being buffered. Set bufferedTrack so that it is flushed when switching back to alt-audio
+        this.bufferedTrack = switchingTrack;
+      }
     }
   }
 

src/controller/base-stream-controller.ts

@@ -1308,7 +1308,9 @@ export default class BaseStreamController
         const mainStart = this.hls.startPosition;
         const liveSyncPosition = this.hls.liveSyncPosition;
         const startPosition = frag
-          ? (mainStart !== -1 ? mainStart : liveSyncPosition) || frag.start
+          ? (mainStart !== -1 && mainStart >= start
+              ? mainStart
+              : liveSyncPosition) || frag.start
           : pos;
         this.log(
           `Setting startPosition to ${startPosition} to match initial live edge. mainStart: ${mainStart} liveSyncPosition: ${liveSyncPosition} frag.start: ${frag?.start}`,

src/controller/stream-controller.ts

@@ -882,12 +882,16 @@ export default class StreamController
       }
       // If switching from alt to main audio, flush all audio and trigger track switched
       if (fromAltAudio) {
+        this.fragmentTracker.removeAllFragments();
+        hls.once(Events.BUFFER_FLUSHED, () => {
+          this.hls?.trigger(Events.AUDIO_TRACK_SWITCHED, data);
+        });
         hls.trigger(Events.BUFFER_FLUSHING, {
           startOffset: 0,
           endOffset: Number.POSITIVE_INFINITY,
           type: null,
         });
-        this.fragmentTracker.removeAllFragments();
+        return;
       }
       hls.trigger(Events.AUDIO_TRACK_SWITCHED, data);
     } else {

src/loader/level-details.ts

@@ -179,7 +179,7 @@ export class LevelDetails {
   }
 
   get expired(): boolean {
-    if (this.live && this.age) {
+    if (this.live && this.age && this.misses < 3) {
       const playlistWindowDuration = this.partEnd - this.fragmentStart;
       return (
         this.age >

src/remux/passthrough-remuxer.ts

@@ -184,8 +184,9 @@ class PassThroughRemuxer implements Remuxer {
     const startDTS = getStartDTS(initData, data);
     const decodeTime = startDTS === null ? timeOffset : startDTS;
     if (
-      isInvalidInitPts(initPTS, decodeTime, timeOffset, duration) ||
-      (initSegment.timescale !== initPTS.timescale && accurateTimeOffset)
+      (accurateTimeOffset || !initPTS) &&
+      (isInvalidInitPts(initPTS, decodeTime, timeOffset, duration) ||
+        initSegment.timescale !== initPTS.timescale)
     ) {
       initSegment.initPTS = decodeTime - timeOffset;
       if (initPTS && initPTS.timescale === 1) {

src/utils/level-helper.ts

@@ -136,7 +136,10 @@ export function updateFragPTSDTS(
 export function mergeDetails(
   oldDetails: LevelDetails,
   newDetails: LevelDetails,
-): void {
+) {
+  if (oldDetails === newDetails) {
+    return;
+  }
   // Track the last initSegment processed. Initialize it to the last one on the timeline.
   let currentInitSegment: Fragment | null = null;
   const oldFragments = oldDetails.fragments;

src/utils/rendition-helper.ts

@@ -502,6 +502,9 @@ function searchDownAndUpList(
   return -1;
 }
 
-export function useAlternateAudio(audioTrackUrl: string, hls: Hls): boolean {
+export function useAlternateAudio(
+  audioTrackUrl: string | undefined,
+  hls: Hls,
+): boolean {
   return !!audioTrackUrl && audioTrackUrl !== hls.levels[hls.loadLevel]?.uri;
 }