hls.js 1.5.12-0.canary.10366 → 1.5.12-0.canary.10367

package/package.json

@@ -130,5 +130,5 @@
     "url-toolkit": "2.2.5",
     "wrangler": "3.59.0"
   },
-  "version": "1.5.12-0.canary.10366"
+  "version": "1.5.12-0.canary.10367"
 }

package/src/controller/abr-controller.ts

@@ -879,7 +879,7 @@ class AbrController extends Logger implements AbrComponentAPI {
               1,
             )} fetchDuration:${fetchDuration.toFixed(
               1,
-            )} firstSelection:${firstSelection} codecSet:${level.codecSet} videoRange:${level.videoRange} hls.loadLevel:${loadLevel}`,
+            )} firstSelection:${firstSelection} codecSet:${levelInfo.codecSet} videoRange:${levelInfo.videoRange} hls.loadLevel:${loadLevel}`,
           );
         }
         if (firstSelection) {

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

@@ -1,6 +1,5 @@
 import BaseStreamController, { State } from './base-stream-controller';
 import { Events } from '../events';
-import { Bufferable, BufferHelper } from '../utils/buffer-helper';
 import { FragmentState } from './fragment-tracker';
 import { Level } from '../types/level';
 import { PlaylistContextType, PlaylistLevelType } from '../types/loader';
@@ -13,7 +12,7 @@ import {
 import ChunkCache from '../demux/chunk-cache';
 import TransmuxerInterface from '../demux/transmuxer-interface';
 import { ChunkMetadata } from '../types/transmuxer';
-import { fragmentWithinToleranceTest } from './fragment-finders';
+import { findFragWithCC, findNearestWithCC } from './fragment-finders';
 import { alignMediaPlaylistByPDT } from '../utils/discontinuities';
 import { mediaAttributesIdentical } from '../utils/media-option-attributes';
 import { ErrorDetails } from '../errors';
@@ -39,6 +38,8 @@ import type {
   FragBufferedData,
   ErrorData,
   BufferFlushingData,
+  BufferCodecsData,
+  FragLoadingData,
 } from '../types/events';
 import type { MediaPlaylist } from '../types/media-playlist';
 
@@ -55,9 +56,8 @@ class AudioStreamController
   extends BaseStreamController
   implements NetworkComponentAPI
 {
-  private videoBuffer: Bufferable | null = null;
-  private videoTrackCC: number = -1;
-  private waitingVideoCC: number = -1;
+  private videoAnchor: MediaFragment | null = null;
+  private mainFragLoading: FragLoadingData | null = null;
   private bufferedTrack: MediaPlaylist | null = null;
   private switchingTrack: MediaPlaylist | null = null;
   private trackId: number = -1;
@@ -102,6 +102,7 @@ class AudioStreamController
     hls.on(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
     hls.on(Events.BUFFER_FLUSHED, this.onBufferFlushed, this);
     hls.on(Events.INIT_PTS_FOUND, this.onInitPtsFound, this);
+    hls.on(Events.FRAG_LOADING, this.onFragLoading, this);
     hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
   }
 
@@ -120,6 +121,7 @@ class AudioStreamController
     hls.off(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
     hls.off(Events.BUFFER_FLUSHED, this.onBufferFlushed, this);
     hls.off(Events.INIT_PTS_FOUND, this.onInitPtsFound, this);
+    hls.on(Events.FRAG_LOADING, this.onFragLoading, this);
     hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
   }
 
@@ -130,20 +132,44 @@ class AudioStreamController
   ) {
     // Always update the new INIT PTS
     // Can change due level switch
-    if (id === 'main') {
+    if (id === PlaylistLevelType.MAIN) {
       const cc = frag.cc;
-      this.initPTS[frag.cc] = { baseTime: initPTS, timescale };
+      const inFlightFrag = this.fragCurrent;
+      this.initPTS[cc] = { baseTime: initPTS, timescale };
       this.log(
         `InitPTS for cc: ${cc} found from main: ${initPTS}/${timescale}`,
       );
-      this.videoTrackCC = cc;
+      this.videoAnchor = frag;
       // If we are waiting, tick immediately to unblock audio fragment transmuxing
       if (this.state === State.WAITING_INIT_PTS) {
+        const waitingData = this.waitingData;
+        if (!waitingData || waitingData.frag.cc !== cc) {
+          this.nextLoadPosition = this.findSyncFrag(frag).start;
+        }
         this.tick();
+      } else if (
+        !this.loadedmetadata &&
+        inFlightFrag &&
+        inFlightFrag.cc !== cc
+      ) {
+        this.startFragRequested = false;
+        this.nextLoadPosition = this.findSyncFrag(frag).start;
+        inFlightFrag.abortRequests();
+        this.resetLoadingState();
       }
     }
   }
 
+  private findSyncFrag(mainFrag: MediaFragment): MediaFragment {
+    const trackDetails = this.getLevelDetails();
+    const cc = mainFrag.cc;
+    return (
+      findNearestWithCC(trackDetails, cc, mainFrag) ||
+      (trackDetails && findFragWithCC(trackDetails.fragments, cc)) ||
+      mainFrag
+    );
+  }
+
   startLoad(startPosition: number) {
     if (!this.levels) {
       this.startPosition = startPosition;
@@ -206,9 +232,9 @@ class AudioStreamController
         const waitingData = this.waitingData;
         if (waitingData) {
           const { frag, part, cache, complete } = waitingData;
+          const videoAnchor = this.videoAnchor;
           if (this.initPTS[frag.cc] !== undefined) {
             this.waitingData = null;
-            this.waitingVideoCC = -1;
             this.state = State.FRAG_LOADING;
             const payload = cache.flush();
             const data: FragLoadedData = {
@@ -221,33 +247,15 @@ class AudioStreamController
             if (complete) {
               super._handleFragmentLoadComplete(data);
             }
-          } else if (this.videoTrackCC !== this.waitingVideoCC) {
+          } else if (videoAnchor && videoAnchor.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 ${this.videoTrackCC}`,
+              `Waiting fragment cc (${frag.cc}) cancelled because video is at cc ${videoAnchor.cc}`,
             );
+            this.nextLoadPosition = this.findSyncFrag(videoAnchor).start;
             this.clearWaitingFragment();
-          } else {
-            // Drop waiting fragment if an earlier fragment is needed
-            const pos = this.getLoadPosition();
-            const bufferInfo = BufferHelper.bufferInfo(
-              this.mediaBuffer,
-              pos,
-              this.config.maxBufferHole,
-            );
-            const waitingFragmentAtPosition = fragmentWithinToleranceTest(
-              bufferInfo.end,
-              this.config.maxFragLookUpTolerance,
-              frag,
-            );
-            if (waitingFragmentAtPosition < 0) {
-              this.log(
-                `Waiting fragment cc (${frag.cc}) @ ${frag.start} cancelled because another fragment at ${bufferInfo.end} is needed`,
-              );
-              this.clearWaitingFragment();
-            }
           }
-        } else {
+        } else if (this.state !== State.STOPPED) {
           this.state = State.IDLE;
         }
       }
@@ -259,9 +267,12 @@ class AudioStreamController
   clearWaitingFragment() {
     const waitingData = this.waitingData;
     if (waitingData) {
+      if (!this.loadedmetadata) {
+        // Load overlapping fragment on start when discontinuity start times are not aligned
+        this.startFragRequested = false;
+      }
       this.fragmentTracker.removeFragment(waitingData.frag);
       this.waitingData = null;
-      this.waitingVideoCC = -1;
       if (this.state !== State.STOPPED) {
         this.state = State.IDLE;
       }
@@ -343,12 +354,11 @@ class AudioStreamController
 
     const fragments = trackDetails.fragments;
     const start = fragments[0].start;
-    let targetBufferTime = this.flushing
-      ? this.getLoadPosition()
-      : bufferInfo.end;
+    const loadPosition = this.getLoadPosition();
+    let targetBufferTime = this.flushing ? loadPosition : bufferInfo.end;
 
     if (switchingTrack && media) {
-      const pos = this.getLoadPosition();
+      const pos = loadPosition;
       // STABLE
       if (
         bufferedTrack &&
@@ -378,10 +388,8 @@ class AudioStreamController
     }
 
     let frag = this.getNextFragment(targetBufferTime, trackDetails);
-    let atGap = false;
     // Avoid loop loading by using nextLoadPosition set for backtracking and skipping consecutive GAP tags
     if (frag && this.isLoopLoading(frag, targetBufferTime)) {
-      atGap = !!frag.gap;
       frag = this.getNextFragmentLoopLoading(
         frag,
         trackDetails,
@@ -395,31 +403,19 @@ class AudioStreamController
       return;
     }
 
-    if (!trackDetails.live || targetBufferTime < this.hls.liveSyncPosition!) {
+    if (
+      this.startFragRequested &&
+      (!trackDetails.live || targetBufferTime < this.hls.liveSyncPosition!)
+    ) {
       // Request audio segments up to one fragment ahead of main buffer
-      const mainBufferInfo = this.getFwdBufferInfo(
-        this.videoBuffer ? this.videoBuffer : this.media,
-        PlaylistLevelType.MAIN,
-      );
+      const mainFragLoading = this.mainFragLoading;
+      const mainTargetBufferEnd = mainFragLoading
+        ? (mainFragLoading.part || mainFragLoading.frag).end
+        : null;
       const atBufferSyncLimit =
-        !!mainBufferInfo && frag.start > mainBufferInfo.end + frag.duration;
-      if (atBufferSyncLimit) {
-        // Check fragment-tracker for main fragments since GAP segments do not show up in bufferInfo
-        const mainFrag = this.fragmentTracker.getFragAtPos(
-          frag.start,
-          PlaylistLevelType.MAIN,
-        );
-        if (mainFrag === null) {
-          return;
-        }
-        // Bridge gaps in main buffer (also prevents loop loading at gaps)
-        atGap ||= !!mainFrag.gap || mainBufferInfo.len === 0;
-        if (
-          !atGap ||
-          (bufferInfo.nextStart && bufferInfo.nextStart < mainFrag.end)
-        ) {
-          return;
-        }
+        mainTargetBufferEnd !== null && frag.start > mainTargetBufferEnd;
+      if (atBufferSyncLimit && !frag.endList) {
+        return;
       }
     }
 
@@ -427,7 +423,6 @@ class AudioStreamController
   }
 
   protected onMediaDetaching() {
-    this.videoBuffer = null;
     this.bufferFlushed = this.flushing = false;
     super.onMediaDetaching();
   }
@@ -477,18 +472,16 @@ class AudioStreamController
   }
 
   protected onManifestLoading() {
-    this.fragmentTracker.removeAllFragments();
-    this.startPosition = this.lastCurrentTime = 0;
+    super.onManifestLoading();
     this.bufferFlushed = this.flushing = false;
-    this.levels =
-      this.mainDetails =
+    this.mainDetails =
       this.waitingData =
+      this.videoAnchor =
       this.bufferedTrack =
       this.cachedTrackLoadedData =
       this.switchingTrack =
         null;
-    this.startFragRequested = false;
-    this.trackId = this.videoTrackCC = this.waitingVideoCC = -1;
+    this.trackId = -1;
   }
 
   private onLevelLoaded(event: Events.LEVEL_LOADED, data: LevelLoadedData) {
@@ -643,7 +636,6 @@ class AudioStreamController
         complete: false,
       });
       cache.push(new Uint8Array(payload));
-      this.waitingVideoCC = this.videoTrackCC;
       this.state = State.WAITING_INIT_PTS;
     }
   }
@@ -658,7 +650,7 @@ class AudioStreamController
 
   private onBufferReset(/* event: Events.BUFFER_RESET */) {
     // reset reference to sourcebuffers
-    this.mediaBuffer = this.videoBuffer = null;
+    this.mediaBuffer = null;
     this.loadedmetadata = false;
   }
 
@@ -670,8 +662,17 @@ class AudioStreamController
     if (audioTrack) {
       this.mediaBuffer = audioTrack.buffer || null;
     }
-    if (data.tracks.video) {
-      this.videoBuffer = data.tracks.video.buffer || null;
+  }
+
+  private onFragLoading(event: Events.FRAG_LOADING, data: FragLoadingData) {
+    if (
+      data.frag.type === PlaylistLevelType.MAIN &&
+      data.frag.sn !== 'initSegment'
+    ) {
+      this.mainFragLoading = data;
+      if (this.state === State.IDLE) {
+        this.tick();
+      }
     }
   }
 
@@ -679,12 +680,12 @@ class AudioStreamController
     const { frag, part } = data;
     if (frag.type !== PlaylistLevelType.AUDIO) {
       if (!this.loadedmetadata && frag.type === PlaylistLevelType.MAIN) {
-        const bufferable = this.videoBuffer || this.media;
-        if (bufferable) {
-          const bufferedTimeRanges = BufferHelper.getBuffered(bufferable);
-          if (bufferedTimeRanges.length) {
-            this.loadedmetadata = true;
-          }
+        const bufferedState = this.fragmentTracker.getState(frag);
+        if (
+          bufferedState === FragmentState.OK ||
+          bufferedState === FragmentState.PARTIAL
+        ) {
+          this.loadedmetadata = true;
         }
       }
       return;
@@ -704,7 +705,7 @@ class AudioStreamController
       return;
     }
     if (frag.sn !== 'initSegment') {
-      this.fragPrevious = frag;
+      this.fragPrevious = frag as MediaFragment;
       const track = this.switchingTrack;
       if (track) {
         this.bufferedTrack = track;
@@ -889,12 +890,15 @@ class AudioStreamController
     if (tracks.video) {
       delete tracks.video;
     }
+    if (tracks.audiovideo) {
+      delete tracks.audiovideo;
+    }
 
     // include levelCodec in audio and video tracks
-    const track = tracks.audio;
-    if (!track) {
+    if (!tracks.audio) {
       return;
     }
+    const track = tracks.audio;
 
     track.id = 'audio';
 
@@ -906,7 +910,7 @@ class AudioStreamController
     if (variantAudioCodecs && variantAudioCodecs.split(',').length === 1) {
       track.levelCodec = variantAudioCodecs;
     }
-    this.hls.trigger(Events.BUFFER_CODECS, tracks);
+    this.hls.trigger(Events.BUFFER_CODECS, tracks as BufferCodecsData);
     const initSegment = track.initSegment;
     if (initSegment?.byteLength) {
       const segment: BufferAppendingData = {
@@ -930,7 +934,6 @@ class AudioStreamController
   ) {
     // only load if fragment is not loaded or if in audio switch
     const fragState = this.fragmentTracker.getState(frag);
-    this.fragCurrent = frag;
 
     // we force a frag loading in audio switch as fragment tracker might not have evicted previous frags in case of quick audio switch
     if (
@@ -953,7 +956,6 @@ class AudioStreamController
           alignMediaPlaylistByPDT(track.details, mainDetails);
         }
       } else {
-        this.startFragRequested = true;
         super.loadFragment(frag, track, targetBufferTime);
       }
     } else {

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

@@ -77,7 +77,7 @@ export default class BaseStreamController
 {
   protected hls: Hls;
 
-  protected fragPrevious: Fragment | null = null;
+  protected fragPrevious: MediaFragment | null = null;
   protected fragCurrent: Fragment | null = null;
   protected fragmentTracker: FragmentTracker;
   protected transmuxer: TransmuxerInterface | null = null;
@@ -102,6 +102,7 @@ export default class BaseStreamController
   protected initPTS: RationalTimestamp[] = [];
   protected buffering: boolean = true;
   private loadingParts: boolean = false;
+  private loopSn?: string | number;
 
   constructor(
     hls: Hls,
@@ -148,6 +149,9 @@ export default class BaseStreamController
   public startLoad(startPosition: number): void {}
 
   public stopLoad() {
+    if (this.state === State.STOPPED) {
+      return;
+    }
     this.fragmentLoader.abort();
     this.keyLoader.abort(this.playlistType);
     const frag = this.fragCurrent;
@@ -242,12 +246,18 @@ export default class BaseStreamController
       this.keyLoader.detach();
     }
     this.media = this.mediaBuffer = null;
-    this.loadedmetadata = false;
+    this.loopSn = undefined;
+    this.startFragRequested = this.loadedmetadata = this.loadingParts = false;
     this.fragmentTracker.removeAllFragments();
     this.stopLoad();
   }
 
-  protected onManifestLoading() {}
+  protected onManifestLoading() {
+    this.initPTS = [];
+    this.levels = this.levelLastLoaded = this.fragCurrent = null;
+    this.lastCurrentTime = this.startPosition = 0;
+    this.startFragRequested = false;
+  }
 
   protected onError(event: Events.ERROR, data: ErrorData) {}
 
@@ -346,7 +356,6 @@ export default class BaseStreamController
     data: ManifestLoadedData,
   ): void {
     this.startTimeOffset = data.startTimeOffset;
-    this.initPTS = [];
   }
 
   protected onHandlerDestroying() {
@@ -384,6 +393,7 @@ export default class BaseStreamController
     level: Level,
     targetBufferTime: number,
   ) {
+    this.startFragRequested = true;
     this._loadFragForPlayback(frag, level, targetBufferTime);
   }
 
@@ -692,6 +702,7 @@ export default class BaseStreamController
     targetBufferTime: number | null = null,
     progressCallback?: FragmentLoadProgressCallback,
   ): Promise<PartsLoadedData | FragLoadedData | null> {
+    this.fragCurrent = frag;
     const details = level?.details;
     if (!this.levels || !details) {
       throw new Error(
@@ -896,7 +907,7 @@ export default class BaseStreamController
               const loadedPart = partLoadedData.part as Part;
               this.hls.trigger(Events.FRAG_LOADED, partLoadedData);
               const nextPart =
-                getPartWith(level, frag.sn as number, part.index + 1) ||
+                getPartWith(level.details, frag.sn as number, part.index + 1) ||
                 findPart(initialPartList, frag.sn as number, part.index + 1);
               if (nextPart) {
                 loadPart(nextPart);
@@ -966,12 +977,7 @@ export default class BaseStreamController
       );
       this.loadingParts = shouldLoadParts;
     }
-    this.updateLevelTiming(
-      frag as MediaFragment,
-      part,
-      level,
-      chunkMeta.partial,
-    );
+    this.updateLevelTiming(frag, part, level, chunkMeta.partial);
   }
 
   private shouldLoadParts(
@@ -1011,10 +1017,13 @@ export default class BaseStreamController
       return null;
     }
     const level = levels[levelIndex];
-    const part = partIndex > -1 ? getPartWith(level, sn, partIndex) : null;
+    const levelDetails = level.details;
+
+    const part =
+      partIndex > -1 ? getPartWith(levelDetails, sn, partIndex) : null;
     const frag = part
       ? part.fragment
-      : getFragmentWithSN(level, sn, fragCurrent);
+      : getFragmentWithSN(levelDetails, sn, fragCurrent);
     if (!frag) {
       return null;
     }
@@ -1160,9 +1169,9 @@ export default class BaseStreamController
     position: number,
     playlistType: PlaylistLevelType = PlaylistLevelType.MAIN,
   ): Fragment | null {
-    const fragOrPart = this.fragmentTracker.getAppendedFrag(
+    const fragOrPart = this.fragmentTracker?.getAppendedFrag(
       position,
-      PlaylistLevelType.MAIN,
+      playlistType,
     );
     if (fragOrPart && 'fragment' in fragOrPart) {
       return fragOrPart.fragment;
@@ -1246,34 +1255,34 @@ export default class BaseStreamController
     playlistType: PlaylistLevelType,
     maxBufLen: number,
   ): Fragment | null {
-    const gapStart = frag.gap;
-    const nextFragment = this.getNextFragment(
-      this.nextLoadPosition,
-      levelDetails,
-    );
-    if (nextFragment === null) {
-      return nextFragment;
-    }
-    frag = nextFragment;
-    if (gapStart && frag && !frag.gap && bufferInfo.nextStart) {
-      // Media buffered after GAP tags should not make the next buffer timerange exceed forward buffer length
-      const nextbufferInfo = this.getFwdBufferInfoAtPos(
-        this.mediaBuffer ? this.mediaBuffer : this.media,
-        bufferInfo.nextStart,
-        playlistType,
-      );
-      if (
-        nextbufferInfo !== null &&
-        bufferInfo.len + nextbufferInfo.len >= maxBufLen
-      ) {
-        // Returning here might result in not finding an audio and video candiate to skip to
-        this.log(
-          `buffer full after gaps in "${playlistType}" playlist starting at sn: ${frag.sn}`,
+    let nextFragment: Fragment | null = null;
+    if (frag.gap) {
+      nextFragment = this.getNextFragment(this.nextLoadPosition, levelDetails);
+      if (nextFragment && !nextFragment.gap && bufferInfo.nextStart) {
+        // Media buffered after GAP tags should not make the next buffer timerange exceed forward buffer length
+        const nextbufferInfo = this.getFwdBufferInfoAtPos(
+          this.mediaBuffer ? this.mediaBuffer : this.media,
+          bufferInfo.nextStart,
+          playlistType,
         );
-        return null;
+        if (
+          nextbufferInfo !== null &&
+          bufferInfo.len + nextbufferInfo.len >= maxBufLen
+        ) {
+          // Returning here might result in not finding an audio and video candiate to skip to
+          const sn = nextFragment.sn;
+          if (this.loopSn !== sn) {
+            this.log(
+              `buffer full after gaps in "${playlistType}" playlist starting at sn: ${sn}`,
+            );
+            this.loopSn = sn;
+          }
+          return null;
+        }
       }
     }
-    return frag;
+    this.loopSn = undefined;
+    return nextFragment;
   }
 
   mapToInitFragWhenRequired(frag: Fragment | null): typeof frag {
@@ -1570,7 +1579,7 @@ export default class BaseStreamController
       if (startTimeOffset !== null && Number.isFinite(startTimeOffset)) {
         startPosition = sliding + startTimeOffset;
         if (startTimeOffset < 0) {
-          startPosition += details.totalduration;
+          startPosition += details.edge;
         }
         startPosition = Math.min(
           Math.max(sliding, startPosition),

package/src/controller/buffer-controller.ts

@@ -147,6 +147,7 @@ export default class BufferController extends Logger implements ComponentAPI {
     hls.on(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
     hls.on(Events.FRAG_PARSED, this.onFragParsed, this);
     hls.on(Events.FRAG_CHANGED, this.onFragChanged, this);
+    hls.on(Events.ERROR, this.onError, this);
   }
 
   protected unregisterListeners() {
@@ -163,6 +164,7 @@ export default class BufferController extends Logger implements ComponentAPI {
     hls.off(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
     hls.off(Events.FRAG_PARSED, this.onFragParsed, this);
     hls.off(Events.FRAG_CHANGED, this.onFragChanged, this);
+    hls.off(Events.ERROR, this.onError, this);
   }
 
   private _initSourceBuffer() {
@@ -173,11 +175,7 @@ export default class BufferController extends Logger implements ComponentAPI {
       video: [],
       audiovideo: [],
     };
-    this.appendErrors = {
-      audio: 0,
-      video: 0,
-      audiovideo: 0,
-    };
+    this.resetAppendErrors();
     this.lastMpegAudioChunk = null;
     this.blockedAudioAppend = null;
     this.lastVideoAppendEnd = 0;
@@ -793,6 +791,23 @@ export default class BufferController extends Logger implements ComponentAPI {
     }
   }
 
+  private onError(event: Events.ERROR, data: ErrorData) {
+    if (data.details === ErrorDetails.BUFFER_APPEND_ERROR && data.frag) {
+      const nextAutoLevel = data.errorAction?.nextAutoLevel;
+      if (Number.isFinite(nextAutoLevel) && nextAutoLevel !== data.frag.level) {
+        this.resetAppendErrors();
+      }
+    }
+  }
+
+  private resetAppendErrors() {
+    this.appendErrors = {
+      audio: 0,
+      video: 0,
+      audiovideo: 0,
+    };
+  }
+
   trimBuffers() {
     const { hls, details, media } = this;
     if (!media || details === null) {