Is the idea that you want to play everything buffered between the currentTime and liveSyncPosition?

The problem is that live is supposed to maintain a prescribed distance from the edge. The purpose of this method is to catch up to that position. It is not meant to skip between unbuffered regions.

Hello @robwalch, thanks for the feedback. I agree that our primary goal is to maintain a prescribed distance from the live edge. However, my suggestion was made with unstable network conditions in mind.

In my experiments, under poor network connectivity, once playback had fallen behind the live edge and reached the if (media.readyState) block, executing:

media.currentTime = liveSyncPosition;

in the HLS.js demo resulted in:

The buffer spinner stopping entirely

The screen freezing for an extended period

No buffer being accumulated around liveSyncPosition, leaving playback stuck

This produced a very poor playback experience. I’ll further analyze the code to understand why no buffer is built when jumping to liveSyncPosition under weak network conditions.

However, to mitigate the long freezing when jumping to liveSyncPosition, I propose adding a new HLS.js configuration option. For example:

interface HlsConfig {
  // …existing options…
  /**
   * liveSyncMode:
   * - 'edge' (default): always jump straight to liveSyncPosition
   * - 'buffered': if liveSyncPosition is buffered, jump there; otherwise, play from the next buffered segment
   */
  liveSyncMode?: 'edge' | 'buffered'; // default: 'edge'
}

this.warn(
    `Playback: ${currentTime.toFixed(
    3,
    )} is located too far from the end of live sliding playlist: ${end}, reset currentTime to : 
    ${liveSyncPosition.toFixed(
    3,
  )}`,
);

if (this.config.liveSyncMode === 'buffered') {
  
const bufferInfo = BufferHelper.bufferInfo(
      this.media,
      liveSyncPosition,
      0,
    );
    
    if (!bufferInfo) {
        media.currentTime = liveSyncPosition;
        return;
    }

    const isLiveSyncInBuffer = bufferInfo.start <= currentTime;

    if (isLiveSyncInBuffer) {
      media.currentTime = liveSyncPosition;
      return;
    }

    if (!bufferInfo.buffered) {
      return;
    }

    let nextBufferedRange: BufferTimeRange | null = null;

    for (let i = 0; i < bufferInfo.buffered.length; i++) {
      const range = bufferInfo.buffered[i];
      if (range.start > currentTime) {
        nextBufferedRange = range;
        break;
      }
    }

    if (!nextBufferedRange) {
      return;
    }

    media.currentTime = nextBufferedRange.start;
} else {
  media.currentTime = liveSyncPosition;
}

Could you please let me know if I should submit the PR again with these suggestions, or if my proposal is not valid?
If this proposal is accepted, I will also add documentation for the liveSyncMode.
Thank you.

Check for no bufferInfo or buffered at once so that the default seek is performed:

if (!bufferInfo?.buffered) {
        media.currentTime = liveSyncPosition;
        return;
    }

Regarding nextBufferedRange, bufferInfo has a nextStart property (number when there in another buffered range otherwise undefined). Use that instead of looping.

https://github.com/video-dev/hls.js/blob/master/src/utils/buffer-helper.ts

@robwalch I’ve incorporated your requested changes into this PR. Could you please take a final look and let me know if there’s anything else that needs tweaking? Thanks!

This would work well with startOnSegmentBoundary added in #7211