hls.js 1.5.13 → 1.5.14-0.canary.10417

package/src/controller/fragment-tracker.ts

@@ -1,5 +1,5 @@
 import { Events } from '../events';
-import { Fragment, Part } from '../loader/fragment';
+import { Fragment, MediaFragment, Part } from '../loader/fragment';
 import { PlaylistLevelType } from '../types/loader';
 import type { SourceBufferName } from '../types/buffer';
 import type {
@@ -47,6 +47,7 @@ export class FragmentTracker implements ComponentAPI {
 
   private _registerListeners() {
     const { hls } = this;
+    hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.on(Events.BUFFER_APPENDED, this.onBufferAppended, this);
     hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
     hls.on(Events.FRAG_LOADED, this.onFragLoaded, this);
@@ -54,6 +55,7 @@ export class FragmentTracker implements ComponentAPI {
 
   private _unregisterListeners() {
     const { hls } = this;
+    hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.off(Events.BUFFER_APPENDED, this.onBufferAppended, this);
     hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
     hls.off(Events.FRAG_LOADED, this.onFragLoaded, this);
@@ -107,12 +109,23 @@ export class FragmentTracker implements ComponentAPI {
   public getBufferedFrag(
     position: number,
     levelType: PlaylistLevelType,
-  ): Fragment | null {
+  ): MediaFragment | null {
+    return this.getFragAtPos(position, levelType, true);
+  }
+
+  public getFragAtPos(
+    position: number,
+    levelType: PlaylistLevelType,
+    buffered?: boolean,
+  ): MediaFragment | null {
     const { fragments } = this;
     const keys = Object.keys(fragments);
     for (let i = keys.length; i--; ) {
       const fragmentEntity = fragments[keys[i]];
-      if (fragmentEntity?.body.type === levelType && fragmentEntity.buffered) {
+      if (
+        fragmentEntity?.body.type === levelType &&
+        (!buffered || fragmentEntity.buffered)
+      ) {
         const frag = fragmentEntity.body;
         if (frag.start <= position && position <= frag.end) {
           return frag;
@@ -132,22 +145,26 @@ export class FragmentTracker implements ComponentAPI {
     timeRange: TimeRanges,
     playlistType: PlaylistLevelType,
     appendedPart?: Part | null,
+    removeAppending?: boolean,
   ) {
     if (this.timeRanges) {
       this.timeRanges[elementaryStream] = timeRange;
     }
     // Check if any flagged fragments have been unloaded
     // excluding anything newer than appendedPartSn
-    const appendedPartSn = (appendedPart?.fragment.sn || -1) as number;
+    const appendedPartSn = appendedPart?.fragment.sn || -1;
     Object.keys(this.fragments).forEach((key) => {
       const fragmentEntity = this.fragments[key];
       if (!fragmentEntity) {
         return;
       }
-      if (appendedPartSn >= (fragmentEntity.body.sn as number)) {
+      if (appendedPartSn >= fragmentEntity.body.sn) {
         return;
       }
-      if (!fragmentEntity.buffered && !fragmentEntity.loaded) {
+      if (
+        !fragmentEntity.buffered &&
+        (!fragmentEntity.loaded || removeAppending)
+      ) {
         if (fragmentEntity.body.type === playlistType) {
           this.removeFragment(fragmentEntity.body);
         }
@@ -157,6 +174,10 @@ export class FragmentTracker implements ComponentAPI {
       if (!esData) {
         return;
       }
+      if (esData.time.length === 0) {
+        this.removeFragment(fragmentEntity.body);
+        return;
+      }
       esData.time.some((time: FragmentTimeRange) => {
         const isNotBuffered = !this.isTimeBuffered(
           time.startPTS,
@@ -178,11 +199,11 @@ export class FragmentTracker implements ComponentAPI {
    */
   public detectPartialFragments(data: FragBufferedData) {
     const timeRanges = this.timeRanges;
-    const { frag, part } = data;
-    if (!timeRanges || frag.sn === 'initSegment') {
+    if (!timeRanges || data.frag.sn === 'initSegment') {
       return;
     }
 
+    const frag = data.frag as MediaFragment;
     const fragKey = getFragmentKey(frag);
     const fragmentEntity = this.fragments[fragKey];
     if (!fragmentEntity || (fragmentEntity.buffered && frag.gap)) {
@@ -198,7 +219,7 @@ export class FragmentTracker implements ComponentAPI {
       const partial = isFragHint || streamInfo.partial === true;
       fragmentEntity.range[elementaryStream] = this.getBufferedTimes(
         frag,
-        part,
+        data.part,
         partial,
         timeRange,
       );
@@ -213,7 +234,7 @@ export class FragmentTracker implements ComponentAPI {
       }
       if (!isPartial(fragmentEntity)) {
         // Remove older fragment parts from lookup after frag is tracked as buffered
-        this.removeParts((frag.sn as number) - 1, frag.type);
+        this.removeParts(frag.sn - 1, frag.type);
       }
     } else {
       // remove fragment if nothing was appended
@@ -227,11 +248,11 @@ export class FragmentTracker implements ComponentAPI {
       return;
     }
     this.activePartLists[levelType] = activeParts.filter(
-      (part) => (part.fragment.sn as number) >= snToKeep,
+      (part) => part.fragment.sn >= snToKeep,
     );
   }
 
-  public fragBuffered(frag: Fragment, force?: true) {
+  public fragBuffered(frag: MediaFragment, force?: true) {
     const fragKey = getFragmentKey(frag);
     let fragmentEntity = this.fragments[fragKey];
     if (!fragmentEntity && force) {
@@ -376,16 +397,20 @@ export class FragmentTracker implements ComponentAPI {
     return false;
   }
 
+  private onManifestLoading() {
+    this.removeAllFragments();
+  }
+
   private onFragLoaded(event: Events.FRAG_LOADED, data: FragLoadedData) {
-    const { frag, part } = data;
     // don't track initsegment (for which sn is not a number)
     // don't track frags used for bitrateTest, they're irrelevant.
-    if (frag.sn === 'initSegment' || frag.bitrateTest) {
+    if (data.frag.sn === 'initSegment' || data.frag.bitrateTest) {
       return;
     }
 
+    const frag = data.frag as MediaFragment;
     // Fragment entity `loaded` FragLoadedData is null when loading parts
-    const loaded = part ? null : data;
+    const loaded = data.part ? null : data;
 
     const fragKey = getFragmentKey(frag);
     this.fragments[fragKey] = {
@@ -401,7 +426,7 @@ export class FragmentTracker implements ComponentAPI {
     event: Events.BUFFER_APPENDED,
     data: BufferAppendedData,
   ) {
-    const { frag, part, timeRanges } = data;
+    const { frag, part, timeRanges, type } = data;
     if (frag.sn === 'initSegment') {
       return;
     }
@@ -415,15 +440,8 @@ export class FragmentTracker implements ComponentAPI {
     }
     // Store the latest timeRanges loaded in the buffer
     this.timeRanges = timeRanges;
-    Object.keys(timeRanges).forEach((elementaryStream: SourceBufferName) => {
-      const timeRange = timeRanges[elementaryStream] as TimeRanges;
-      this.detectEvictedFragments(
-        elementaryStream,
-        timeRange,
-        playlistType,
-        part,
-      );
-    });
+    const timeRange = timeRanges[type] as TimeRanges;
+    this.detectEvictedFragments(type, timeRange, playlistType, part);
   }
 
   private onFragBuffered(event: Events.FRAG_BUFFERED, data: FragBufferedData) {
@@ -435,6 +453,21 @@ export class FragmentTracker implements ComponentAPI {
     return !!this.fragments[fragKey];
   }
 
+  public hasFragments(type?: PlaylistLevelType): boolean {
+    const { fragments } = this;
+    const keys = Object.keys(fragments);
+    if (!type) {
+      return keys.length > 0;
+    }
+    for (let i = keys.length; i--; ) {
+      const fragmentEntity = fragments[keys[i]];
+      if (fragmentEntity?.body.type === type) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   public hasParts(type: PlaylistLevelType): boolean {
     return !!this.activePartLists[type]?.length;
   }

package/src/controller/gap-controller.ts

@@ -1,20 +1,22 @@
-import type { BufferInfo } from '../utils/buffer-helper';
+import { State } from './base-stream-controller';
 import { BufferHelper } from '../utils/buffer-helper';
 import { ErrorTypes, ErrorDetails } from '../errors';
 import { PlaylistLevelType } from '../types/loader';
 import { Events } from '../events';
-import { logger } from '../utils/logger';
+import { Logger } from '../utils/logger';
 import type Hls from '../hls';
+import type { BufferInfo } from '../utils/buffer-helper';
 import type { HlsConfig } from '../config';
 import type { Fragment } from '../loader/fragment';
 import type { FragmentTracker } from './fragment-tracker';
+import type { LevelDetails } from '../loader/level-details';
 
 export const STALL_MINIMUM_DURATION_MS = 250;
 export const MAX_START_GAP_JUMP = 2.0;
 export const SKIP_BUFFER_HOLE_STEP_SECONDS = 0.1;
 export const SKIP_BUFFER_RANGE_START = 0.05;
 
-export default class GapController {
+export default class GapController extends Logger {
   private config: HlsConfig;
   private media: HTMLMediaElement | null = null;
   private fragmentTracker: FragmentTracker;
@@ -24,8 +26,15 @@ export default class GapController {
   private stalled: number | null = null;
   private moved: boolean = false;
   private seeking: boolean = false;
+  private ended: number = 0;
 
-  constructor(config, media, fragmentTracker, hls) {
+  constructor(
+    config: HlsConfig,
+    media: HTMLMediaElement,
+    fragmentTracker: FragmentTracker,
+    hls: Hls,
+  ) {
+    super('gap-controller', hls.logger);
     this.config = config;
     this.media = media;
     this.fragmentTracker = fragmentTracker;
@@ -44,7 +53,12 @@ export default class GapController {
    *
    * @param lastCurrentTime - Previously read playhead position
    */
-  public poll(lastCurrentTime: number, activeFrag: Fragment | null) {
+  public poll(
+    lastCurrentTime: number,
+    activeFrag: Fragment | null,
+    levelDetails: LevelDetails | undefined,
+    state: string,
+  ) {
     const { config, media, stalled } = this;
     if (media === null) {
       return;
@@ -57,6 +71,7 @@ export default class GapController {
 
     // The playhead is moving, no-op
     if (currentTime !== lastCurrentTime) {
+      this.ended = 0;
       this.moved = true;
       if (!seeking) {
         this.nudgeRetry = 0;
@@ -65,7 +80,7 @@ export default class GapController {
         // The playhead is now moving, but was previously stalled
         if (this.stallReported) {
           const stalledDuration = self.performance.now() - stalled;
-          logger.warn(
+          this.warn(
             `playback not stuck anymore @${currentTime}, after ${Math.round(
               stalledDuration,
             )}ms`,
@@ -128,12 +143,9 @@ export default class GapController {
       // When joining a live stream with audio tracks, account for live playlist window sliding by allowing
       // a larger jump over start gaps caused by the audio-stream-controller buffering a start fragment
       // that begins over 1 target duration after the video start position.
-      const level = this.hls.levels
-        ? this.hls.levels[this.hls.currentLevel]
-        : null;
-      const isLive = level?.details?.live;
+      const isLive = !!levelDetails?.live;
       const maxStartGapJump = isLive
-        ? level!.details!.targetduration * 2
+        ? levelDetails!.targetduration * 2
         : MAX_START_GAP_JUMP;
       const partialOrGap = this.fragmentTracker.getPartialFragment(currentTime);
       if (startJump > 0 && (startJump <= maxStartGapJump || partialOrGap)) {
@@ -153,6 +165,21 @@ export default class GapController {
 
     const stalledDuration = tnow - stalled;
     if (!seeking && stalledDuration >= STALL_MINIMUM_DURATION_MS) {
+      // Dispatch MEDIA_ENDED when media.ended/ended event is not signalled at end of stream
+      if (
+        state === State.ENDED &&
+        !levelDetails?.live &&
+        Math.abs(currentTime - (levelDetails?.edge || 0)) < 1
+      ) {
+        if (stalledDuration < 1000 || this.ended) {
+          return;
+        }
+        this.ended = currentTime;
+        this.hls.trigger(Events.MEDIA_ENDED, {
+          stalled: true,
+        });
+        return;
+      }
       // Report stalling after trying to fix
       this._reportStall(bufferInfo);
       if (!this.media) {
@@ -206,7 +233,7 @@ export default class GapController {
           bufferInfo.nextStart - currentTime < config.maxBufferHole)) &&
       stalledDurationMs > config.highBufferWatchdogPeriod * 1000
     ) {
-      logger.warn('Trying to nudge playhead over buffer-hole');
+      this.warn('Trying to nudge playhead over buffer-hole');
       // Try to nudge currentTime over a buffer hole if we've been stalling for the configured amount of seconds
       // We only try to jump the hole if it's under the configured size
       // Reset stalled so to rearm watchdog timer
@@ -230,7 +257,7 @@ export default class GapController {
           media.currentTime
         } due to low buffer (${JSON.stringify(bufferInfo)})`,
       );
-      logger.warn(error.message);
+      this.warn(error.message);
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
         details: ErrorDetails.BUFFER_STALLED_ERROR,
@@ -305,7 +332,7 @@ export default class GapController {
           startTime + SKIP_BUFFER_RANGE_START,
           currentTime + SKIP_BUFFER_HOLE_STEP_SECONDS,
         );
-        logger.warn(
+        this.warn(
           `skipping hole, adjusting currentTime from ${currentTime} to ${targetTime}`,
         );
         this.moved = true;
@@ -348,7 +375,7 @@ export default class GapController {
       const error = new Error(
         `Nudging 'currentTime' from ${currentTime} to ${targetTime}`,
       );
-      logger.warn(error.message);
+      this.warn(error.message);
       media.currentTime = targetTime;
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
@@ -360,7 +387,7 @@ export default class GapController {
       const error = new Error(
         `Playhead still not moving while enough data buffered @${currentTime} after ${config.nudgeMaxRetry} nudges`,
       );
-      logger.error(error.message);
+      this.error(error.message);
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
         details: ErrorDetails.BUFFER_STALLED_ERROR,

package/src/controller/id3-track-controller.ts

@@ -4,21 +4,24 @@ import {
   clearCurrentCues,
   removeCuesInRange,
 } from '../utils/texttrack-utils';
-import * as ID3 from '../demux/id3';
 import {
   DateRange,
   isDateRangeCueAttribute,
   isSCTE35Attribute,
 } from '../loader/date-range';
+import { LevelDetails } from '../loader/level-details';
 import { MetadataSchema } from '../types/demuxer';
 import type {
   BufferFlushingData,
   FragParsingMetadataData,
+  LevelPTSUpdatedData,
   LevelUpdatedData,
   MediaAttachedData,
 } from '../types/events';
 import type { ComponentAPI } from '../types/component-api';
 import type Hls from '../hls';
+import { getId3Frames } from '@svta/common-media-library/id3/getId3Frames';
+import { isId3TimestampFrame } from '@svta/common-media-library/id3/isId3TimestampFrame';
 
 declare global {
   interface Window {
@@ -68,10 +71,6 @@ const MAX_CUE_ENDTIME = (() => {
   return Number.POSITIVE_INFINITY;
 })();
 
-function dateRangeDateToTimelineSeconds(date: Date, offset: number): number {
-  return date.getTime() / 1000 - offset;
-}
-
 function hexToArrayBuffer(str): ArrayBuffer {
   return Uint8Array.from(
     str
@@ -99,7 +98,7 @@ class ID3TrackController implements ComponentAPI {
     this._registerListeners();
   }
 
-  destroy() {
+  public destroy() {
     this._unregisterListeners();
     this.id3Track = null;
     this.media = null;
@@ -116,6 +115,7 @@ class ID3TrackController implements ComponentAPI {
     hls.on(Events.FRAG_PARSING_METADATA, this.onFragParsingMetadata, this);
     hls.on(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
     hls.on(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
+    hls.on(Events.LEVEL_PTS_UPDATED, this.onLevelPtsUpdated, this);
   }
 
   private _unregisterListeners() {
@@ -126,22 +126,22 @@ class ID3TrackController implements ComponentAPI {
     hls.off(Events.FRAG_PARSING_METADATA, this.onFragParsingMetadata, this);
     hls.off(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
     hls.off(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
+    hls.off(Events.LEVEL_PTS_UPDATED, this.onLevelPtsUpdated, this);
   }
 
   // Add ID3 metatadata text track.
-  protected onMediaAttached(
+  private onMediaAttached(
     event: Events.MEDIA_ATTACHED,
     data: MediaAttachedData,
   ): void {
     this.media = data.media;
   }
 
-  protected onMediaDetaching(): void {
-    if (!this.id3Track) {
-      return;
+  private onMediaDetaching(): void {
+    if (this.id3Track) {
+      clearCurrentCues(this.id3Track);
+      this.id3Track = null;
     }
-    clearCurrentCues(this.id3Track);
-    this.id3Track = null;
     this.media = null;
     this.dateRangeCuesAppended = {};
   }
@@ -150,13 +150,13 @@ class ID3TrackController implements ComponentAPI {
     this.dateRangeCuesAppended = {};
   }
 
-  createTrack(media: HTMLMediaElement): TextTrack {
+  private createTrack(media: HTMLMediaElement): TextTrack {
     const track = this.getID3Track(media.textTracks) as TextTrack;
     track.mode = 'hidden';
     return track;
   }
 
-  getID3Track(textTracks: TextTrackList): TextTrack | void {
+  private getID3Track(textTracks: TextTrackList): TextTrack | void {
     if (!this.media) {
       return;
     }
@@ -173,7 +173,7 @@ class ID3TrackController implements ComponentAPI {
     return this.media.addTextTrack('metadata', 'id3');
   }
 
-  onFragParsingMetadata(
+  private onFragParsingMetadata(
     event: Events.FRAG_PARSING_METADATA,
     data: FragParsingMetadataData,
   ) {
@@ -211,7 +211,7 @@ class ID3TrackController implements ComponentAPI {
         continue;
       }
 
-      const frames = ID3.getID3Frames(samples[i].data);
+      const frames = getId3Frames(samples[i].data);
       if (frames) {
         const startTime = samples[i].pts;
         let endTime: number = startTime + samples[i].duration;
@@ -228,7 +228,7 @@ class ID3TrackController implements ComponentAPI {
         for (let j = 0; j < frames.length; j++) {
           const frame = frames[j];
           // Safari doesn't put the timestamp frame in the TextTrack
-          if (!ID3.isTimeStampFrame(frame)) {
+          if (!isId3TimestampFrame(frame)) {
             // add a bounds to any unbounded cues
             this.updateId3CueEnds(startTime, type);
             const cue = createCueWithDataFields(
@@ -247,7 +247,7 @@ class ID3TrackController implements ComponentAPI {
     }
   }
 
-  updateId3CueEnds(startTime: number, type: MetadataSchema) {
+  private updateId3CueEnds(startTime: number, type: MetadataSchema) {
     const cues = this.id3Track?.cues;
     if (cues) {
       for (let i = cues.length; i--; ) {
@@ -263,7 +263,7 @@ class ID3TrackController implements ComponentAPI {
     }
   }
 
-  onBufferFlushing(
+  private onBufferFlushing(
     event: Events.BUFFER_FLUSHING,
     { startOffset, endOffset, type }: BufferFlushingData,
   ) {
@@ -295,7 +295,23 @@ class ID3TrackController implements ComponentAPI {
     }
   }
 
-  onLevelUpdated(event: Events.LEVEL_UPDATED, { details }: LevelUpdatedData) {
+  private onLevelUpdated(
+    event: Events.LEVEL_UPDATED,
+    { details }: LevelUpdatedData,
+  ) {
+    this.updateDateRangeCues(details, true);
+  }
+
+  private onLevelPtsUpdated(
+    event: Events.LEVEL_PTS_UPDATED,
+    data: LevelPTSUpdatedData,
+  ) {
+    if (Math.abs(data.drift) > 0.01) {
+      this.updateDateRangeCues(data.details);
+    }
+  }
+
+  private updateDateRangeCues(details: LevelDetails, removeOldCues?: true) {
     if (
       !this.media ||
       !details.hasProgramDateTime ||
@@ -307,7 +323,7 @@ class ID3TrackController implements ComponentAPI {
     const { dateRanges } = details;
     const ids = Object.keys(dateRanges);
     // Remove cues from track not found in details.dateRanges
-    if (id3Track) {
+    if (id3Track && removeOldCues) {
       const idsToRemove = Object.keys(dateRangeCuesAppended).filter(
         (id) => !ids.includes(id),
       );
@@ -329,26 +345,20 @@ class ID3TrackController implements ComponentAPI {
       this.id3Track = this.createTrack(this.media);
     }
 
-    const dateTimeOffset =
-      (lastFragment.programDateTime as number) / 1000 - lastFragment.start;
     const Cue = getCueClass();
-
     for (let i = 0; i < ids.length; i++) {
       const id = ids[i];
       const dateRange = dateRanges[id];
-      const startTime = dateRangeDateToTimelineSeconds(
-        dateRange.startDate,
-        dateTimeOffset,
-      );
+      const startTime = dateRange.startTime;
 
       // Process DateRanges to determine end-time (known DURATION, END-DATE, or END-ON-NEXT)
       const appendedDateRangeCues = dateRangeCuesAppended[id];
       const cues = appendedDateRangeCues?.cues || {};
       let durationKnown = appendedDateRangeCues?.durationKnown || false;
       let endTime = MAX_CUE_ENDTIME;
-      const endDate = dateRange.endDate;
-      if (endDate) {
-        endTime = dateRangeDateToTimelineSeconds(endDate, dateTimeOffset);
+      const { duration, endDate } = dateRange;
+      if (endDate && duration !== null) {
+        endTime = startTime + duration;
         durationKnown = true;
       } else if (dateRange.endOnNext && !durationKnown) {
         const nextDateRangeWithSameClass = ids.reduce(
@@ -369,10 +379,7 @@ class ID3TrackController implements ComponentAPI {
           null,
         );
         if (nextDateRangeWithSameClass) {
-          endTime = dateRangeDateToTimelineSeconds(
-            nextDateRangeWithSameClass.startDate,
-            dateTimeOffset,
-          );
+          endTime = nextDateRangeWithSameClass.startTime;
           durationKnown = true;
         }
       }
@@ -389,6 +396,9 @@ class ID3TrackController implements ComponentAPI {
         if (cue) {
           if (durationKnown && !appendedDateRangeCues.durationKnown) {
             cue.endTime = endTime;
+          } else if (Math.abs(cue.startTime - startTime) > 0.01) {
+            cue.startTime = startTime;
+            cue.endTime = endTime;
           }
         } else if (Cue) {
           let data = dateRange.attr[key];

package/src/controller/latency-controller.ts

@@ -6,7 +6,6 @@ import type {
   LevelUpdatedData,
   MediaAttachingData,
 } from '../types/events';
-import { logger } from '../utils/logger';
 import type { ComponentAPI } from '../types/component-api';
 import type Hls from '../hls';
 import type { HlsConfig } from '../config';
@@ -19,7 +18,7 @@ export default class LatencyController implements ComponentAPI {
   private currentTime: number = 0;
   private stallCount: number = 0;
   private _latency: number | null = null;
-  private timeupdateHandler = () => this.timeupdate();
+  private _targetLatencyUpdated = false;
 
   constructor(hls: Hls) {
     this.hls = hls;
@@ -52,6 +51,7 @@ export default class LatencyController implements ComponentAPI {
     const userConfig = this.hls.userConfig;
     let targetLatency = lowLatencyMode ? partHoldBack || holdBack : holdBack;
     if (
+      this._targetLatencyUpdated ||
       userConfig.liveSyncDuration ||
       userConfig.liveSyncDurationCount ||
       targetLatency === 0
@@ -62,16 +62,21 @@ export default class LatencyController implements ComponentAPI {
           : liveSyncDurationCount * targetduration;
     }
     const maxLiveSyncOnStallIncrease = targetduration;
-    const liveSyncOnStallIncrease = 1.0;
     return (
       targetLatency +
       Math.min(
-        this.stallCount * liveSyncOnStallIncrease,
+        this.stallCount * this.config.liveSyncOnStallIncrease,
         maxLiveSyncOnStallIncrease,
       )
     );
   }
 
+  set targetLatency(latency: number) {
+    this.stallCount = 0;
+    this.config.liveSyncDuration = latency;
+    this._targetLatencyUpdated = true;
+  }
+
   get liveSyncPosition(): number | null {
     const liveEdge = this.estimateLiveEdge();
     const targetLatency = this.targetLatency;
@@ -126,7 +131,7 @@ export default class LatencyController implements ComponentAPI {
     this.onMediaDetaching();
     this.levelDetails = null;
     // @ts-ignore
-    this.hls = this.timeupdateHandler = null;
+    this.hls = null;
   }
 
   private registerListeners() {
@@ -150,12 +155,12 @@ export default class LatencyController implements ComponentAPI {
     data: MediaAttachingData,
   ) {
     this.media = data.media;
-    this.media.addEventListener('timeupdate', this.timeupdateHandler);
+    this.media.addEventListener('timeupdate', this.onTimeupdate);
   }
 
   private onMediaDetaching() {
     if (this.media) {
-      this.media.removeEventListener('timeupdate', this.timeupdateHandler);
+      this.media.removeEventListener('timeupdate', this.onTimeupdate);
       this.media = null;
     }
   }
@@ -172,10 +177,10 @@ export default class LatencyController implements ComponentAPI {
   ) {
     this.levelDetails = details;
     if (details.advanced) {
-      this.timeupdate();
+      this.onTimeupdate();
     }
     if (!details.live && this.media) {
-      this.media.removeEventListener('timeupdate', this.timeupdateHandler);
+      this.media.removeEventListener('timeupdate', this.onTimeupdate);
     }
   }
 
@@ -185,13 +190,13 @@ export default class LatencyController implements ComponentAPI {
     }
     this.stallCount++;
     if (this.levelDetails?.live) {
-      logger.warn(
-        '[playback-rate-controller]: Stall detected, adjusting target latency',
+      this.hls.logger.warn(
+        '[latency-controller]: Stall detected, adjusting target latency',
       );
     }
   }
 
-  private timeupdate() {
+  private onTimeupdate = () => {
     const { media, levelDetails } = this;
     if (!media || !levelDetails) {
       return;
@@ -242,7 +247,7 @@ export default class LatencyController implements ComponentAPI {
     } else if (media.playbackRate !== 1 && media.playbackRate !== 0) {
       media.playbackRate = 1;
     }
-  }
+  };
 
   private estimateLiveEdge(): number | null {
     const { levelDetails } = this;