hls.js 1.5.14-0.canary.10515 → 1.5.14

package/src/controller/fragment-tracker.ts

@@ -1,5 +1,5 @@
 import { Events } from '../events';
-import { Fragment, MediaFragment, Part } from '../loader/fragment';
+import { Fragment, Part } from '../loader/fragment';
 import { PlaylistLevelType } from '../types/loader';
 import type { SourceBufferName } from '../types/buffer';
 import type {
@@ -47,7 +47,6 @@ 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);
@@ -55,7 +54,6 @@ 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);
@@ -109,23 +107,12 @@ export class FragmentTracker implements ComponentAPI {
   public getBufferedFrag(
     position: number,
     levelType: PlaylistLevelType,
-  ): MediaFragment | null {
-    return this.getFragAtPos(position, levelType, true);
-  }
-
-  public getFragAtPos(
-    position: number,
-    levelType: PlaylistLevelType,
-    buffered?: boolean,
-  ): MediaFragment | null {
+  ): Fragment | 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 &&
-        (!buffered || fragmentEntity.buffered)
-      ) {
+      if (fragmentEntity?.body.type === levelType && fragmentEntity.buffered) {
         const frag = fragmentEntity.body;
         if (frag.start <= position && position <= frag.end) {
           return frag;
@@ -145,26 +132,22 @@ 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;
+    const appendedPartSn = (appendedPart?.fragment.sn || -1) as number;
     Object.keys(this.fragments).forEach((key) => {
       const fragmentEntity = this.fragments[key];
       if (!fragmentEntity) {
         return;
       }
-      if (appendedPartSn >= fragmentEntity.body.sn) {
+      if (appendedPartSn >= (fragmentEntity.body.sn as number)) {
         return;
       }
-      if (
-        !fragmentEntity.buffered &&
-        (!fragmentEntity.loaded || removeAppending)
-      ) {
+      if (!fragmentEntity.buffered && !fragmentEntity.loaded) {
         if (fragmentEntity.body.type === playlistType) {
           this.removeFragment(fragmentEntity.body);
         }
@@ -174,10 +157,6 @@ 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,
@@ -199,11 +178,11 @@ export class FragmentTracker implements ComponentAPI {
    */
   public detectPartialFragments(data: FragBufferedData) {
     const timeRanges = this.timeRanges;
-    if (!timeRanges || data.frag.sn === 'initSegment') {
+    const { frag, part } = data;
+    if (!timeRanges || 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)) {
@@ -219,7 +198,7 @@ export class FragmentTracker implements ComponentAPI {
       const partial = isFragHint || streamInfo.partial === true;
       fragmentEntity.range[elementaryStream] = this.getBufferedTimes(
         frag,
-        data.part,
+        part,
         partial,
         timeRange,
       );
@@ -234,7 +213,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 - 1, frag.type);
+        this.removeParts((frag.sn as number) - 1, frag.type);
       }
     } else {
       // remove fragment if nothing was appended
@@ -248,11 +227,11 @@ export class FragmentTracker implements ComponentAPI {
       return;
     }
     this.activePartLists[levelType] = activeParts.filter(
-      (part) => part.fragment.sn >= snToKeep,
+      (part) => (part.fragment.sn as number) >= snToKeep,
     );
   }
 
-  public fragBuffered(frag: MediaFragment, force?: true) {
+  public fragBuffered(frag: Fragment, force?: true) {
     const fragKey = getFragmentKey(frag);
     let fragmentEntity = this.fragments[fragKey];
     if (!fragmentEntity && force) {
@@ -397,20 +376,16 @@ 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 (data.frag.sn === 'initSegment' || data.frag.bitrateTest) {
+    if (frag.sn === 'initSegment' || frag.bitrateTest) {
       return;
     }
 
-    const frag = data.frag as MediaFragment;
     // Fragment entity `loaded` FragLoadedData is null when loading parts
-    const loaded = data.part ? null : data;
+    const loaded = part ? null : data;
 
     const fragKey = getFragmentKey(frag);
     this.fragments[fragKey] = {
@@ -426,7 +401,7 @@ export class FragmentTracker implements ComponentAPI {
     event: Events.BUFFER_APPENDED,
     data: BufferAppendedData,
   ) {
-    const { frag, part, timeRanges, type } = data;
+    const { frag, part, timeRanges } = data;
     if (frag.sn === 'initSegment') {
       return;
     }
@@ -440,8 +415,15 @@ export class FragmentTracker implements ComponentAPI {
     }
     // Store the latest timeRanges loaded in the buffer
     this.timeRanges = timeRanges;
-    const timeRange = timeRanges[type] as TimeRanges;
-    this.detectEvictedFragments(type, timeRange, playlistType, part);
+    Object.keys(timeRanges).forEach((elementaryStream: SourceBufferName) => {
+      const timeRange = timeRanges[elementaryStream] as TimeRanges;
+      this.detectEvictedFragments(
+        elementaryStream,
+        timeRange,
+        playlistType,
+        part,
+      );
+    });
   }
 
   private onFragBuffered(event: Events.FRAG_BUFFERED, data: FragBufferedData) {
@@ -453,21 +435,6 @@ 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,22 +1,20 @@
-import { State } from './base-stream-controller';
+import type { BufferInfo } from '../utils/buffer-helper';
 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 extends Logger {
+export default class GapController {
   private config: HlsConfig;
   private media: HTMLMediaElement | null = null;
   private fragmentTracker: FragmentTracker;
@@ -26,15 +24,8 @@ export default class GapController extends Logger {
   private stalled: number | null = null;
   private moved: boolean = false;
   private seeking: boolean = false;
-  private ended: number = 0;
 
-  constructor(
-    config: HlsConfig,
-    media: HTMLMediaElement,
-    fragmentTracker: FragmentTracker,
-    hls: Hls,
-  ) {
-    super('gap-controller', hls.logger);
+  constructor(config, media, fragmentTracker, hls) {
     this.config = config;
     this.media = media;
     this.fragmentTracker = fragmentTracker;
@@ -53,12 +44,7 @@ export default class GapController extends Logger {
    *
    * @param lastCurrentTime - Previously read playhead position
    */
-  public poll(
-    lastCurrentTime: number,
-    activeFrag: Fragment | null,
-    levelDetails: LevelDetails | undefined,
-    state: string,
-  ) {
+  public poll(lastCurrentTime: number, activeFrag: Fragment | null) {
     const { config, media, stalled } = this;
     if (media === null) {
       return;
@@ -71,7 +57,6 @@ export default class GapController extends Logger {
 
     // The playhead is moving, no-op
     if (currentTime !== lastCurrentTime) {
-      this.ended = 0;
       this.moved = true;
       if (!seeking) {
         this.nudgeRetry = 0;
@@ -80,7 +65,7 @@ export default class GapController extends Logger {
         // The playhead is now moving, but was previously stalled
         if (this.stallReported) {
           const stalledDuration = self.performance.now() - stalled;
-          this.warn(
+          logger.warn(
             `playback not stuck anymore @${currentTime}, after ${Math.round(
               stalledDuration,
             )}ms`,
@@ -143,9 +128,12 @@ export default class GapController extends Logger {
       // 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 isLive = !!levelDetails?.live;
+      const level = this.hls.levels
+        ? this.hls.levels[this.hls.currentLevel]
+        : null;
+      const isLive = level?.details?.live;
       const maxStartGapJump = isLive
-        ? levelDetails!.targetduration * 2
+        ? level!.details!.targetduration * 2
         : MAX_START_GAP_JUMP;
       const partialOrGap = this.fragmentTracker.getPartialFragment(currentTime);
       if (startJump > 0 && (startJump <= maxStartGapJump || partialOrGap)) {
@@ -165,21 +153,6 @@ export default class GapController extends Logger {
 
     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) {
@@ -233,7 +206,7 @@ export default class GapController extends Logger {
           bufferInfo.nextStart - currentTime < config.maxBufferHole)) &&
       stalledDurationMs > config.highBufferWatchdogPeriod * 1000
     ) {
-      this.warn('Trying to nudge playhead over buffer-hole');
+      logger.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
@@ -257,7 +230,7 @@ export default class GapController extends Logger {
           media.currentTime
         } due to low buffer (${JSON.stringify(bufferInfo)})`,
       );
-      this.warn(error.message);
+      logger.warn(error.message);
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
         details: ErrorDetails.BUFFER_STALLED_ERROR,
@@ -332,7 +305,7 @@ export default class GapController extends Logger {
           startTime + SKIP_BUFFER_RANGE_START,
           currentTime + SKIP_BUFFER_HOLE_STEP_SECONDS,
         );
-        this.warn(
+        logger.warn(
           `skipping hole, adjusting currentTime from ${currentTime} to ${targetTime}`,
         );
         this.moved = true;
@@ -375,7 +348,7 @@ export default class GapController extends Logger {
       const error = new Error(
         `Nudging 'currentTime' from ${currentTime} to ${targetTime}`,
       );
-      this.warn(error.message);
+      logger.warn(error.message);
       media.currentTime = targetTime;
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
@@ -387,7 +360,7 @@ export default class GapController extends Logger {
       const error = new Error(
         `Playhead still not moving while enough data buffered @${currentTime} after ${config.nudgeMaxRetry} nudges`,
       );
-      this.error(error.message);
+      logger.error(error.message);
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
         details: ErrorDetails.BUFFER_STALLED_ERROR,

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

@@ -4,24 +4,21 @@ 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 {
@@ -71,6 +68,10 @@ 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
@@ -98,7 +99,7 @@ class ID3TrackController implements ComponentAPI {
     this._registerListeners();
   }
 
-  public destroy() {
+  destroy() {
     this._unregisterListeners();
     this.id3Track = null;
     this.media = null;
@@ -115,7 +116,6 @@ 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.
-  private onMediaAttached(
+  protected onMediaAttached(
     event: Events.MEDIA_ATTACHED,
     data: MediaAttachedData,
   ): void {
     this.media = data.media;
   }
 
-  private onMediaDetaching(): void {
-    if (this.id3Track) {
-      clearCurrentCues(this.id3Track);
-      this.id3Track = null;
+  protected onMediaDetaching(): void {
+    if (!this.id3Track) {
+      return;
     }
+    clearCurrentCues(this.id3Track);
+    this.id3Track = null;
     this.media = null;
     this.dateRangeCuesAppended = {};
   }
@@ -150,13 +150,13 @@ class ID3TrackController implements ComponentAPI {
     this.dateRangeCuesAppended = {};
   }
 
-  private createTrack(media: HTMLMediaElement): TextTrack {
+  createTrack(media: HTMLMediaElement): TextTrack {
     const track = this.getID3Track(media.textTracks) as TextTrack;
     track.mode = 'hidden';
     return track;
   }
 
-  private getID3Track(textTracks: TextTrackList): TextTrack | void {
+  getID3Track(textTracks: TextTrackList): TextTrack | void {
     if (!this.media) {
       return;
     }
@@ -173,7 +173,7 @@ class ID3TrackController implements ComponentAPI {
     return this.media.addTextTrack('metadata', 'id3');
   }
 
-  private onFragParsingMetadata(
+  onFragParsingMetadata(
     event: Events.FRAG_PARSING_METADATA,
     data: FragParsingMetadataData,
   ) {
@@ -211,7 +211,7 @@ class ID3TrackController implements ComponentAPI {
         continue;
       }
 
-      const frames = getId3Frames(samples[i].data);
+      const frames = ID3.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 (!isId3TimestampFrame(frame)) {
+          if (!ID3.isTimeStampFrame(frame)) {
             // add a bounds to any unbounded cues
             this.updateId3CueEnds(startTime, type);
             const cue = createCueWithDataFields(
@@ -247,7 +247,7 @@ class ID3TrackController implements ComponentAPI {
     }
   }
 
-  private updateId3CueEnds(startTime: number, type: MetadataSchema) {
+  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 {
     }
   }
 
-  private onBufferFlushing(
+  onBufferFlushing(
     event: Events.BUFFER_FLUSHING,
     { startOffset, endOffset, type }: BufferFlushingData,
   ) {
@@ -295,23 +295,7 @@ class ID3TrackController implements ComponentAPI {
     }
   }
 
-  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) {
+  onLevelUpdated(event: Events.LEVEL_UPDATED, { details }: LevelUpdatedData) {
     if (
       !this.media ||
       !details.hasProgramDateTime ||
@@ -323,7 +307,7 @@ class ID3TrackController implements ComponentAPI {
     const { dateRanges } = details;
     const ids = Object.keys(dateRanges);
     // Remove cues from track not found in details.dateRanges
-    if (id3Track && removeOldCues) {
+    if (id3Track) {
       const idsToRemove = Object.keys(dateRangeCuesAppended).filter(
         (id) => !ids.includes(id),
       );
@@ -345,20 +329,26 @@ 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 = dateRange.startTime;
+      const startTime = dateRangeDateToTimelineSeconds(
+        dateRange.startDate,
+        dateTimeOffset,
+      );
 
       // 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 { duration, endDate } = dateRange;
-      if (endDate && duration !== null) {
-        endTime = startTime + duration;
+      const endDate = dateRange.endDate;
+      if (endDate) {
+        endTime = dateRangeDateToTimelineSeconds(endDate, dateTimeOffset);
         durationKnown = true;
       } else if (dateRange.endOnNext && !durationKnown) {
         const nextDateRangeWithSameClass = ids.reduce(
@@ -379,7 +369,10 @@ class ID3TrackController implements ComponentAPI {
           null,
         );
         if (nextDateRangeWithSameClass) {
-          endTime = nextDateRangeWithSameClass.startTime;
+          endTime = dateRangeDateToTimelineSeconds(
+            nextDateRangeWithSameClass.startDate,
+            dateTimeOffset,
+          );
           durationKnown = true;
         }
       }
@@ -396,9 +389,6 @@ 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,6 +6,7 @@ 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';
@@ -18,7 +19,7 @@ export default class LatencyController implements ComponentAPI {
   private currentTime: number = 0;
   private stallCount: number = 0;
   private _latency: number | null = null;
-  private _targetLatencyUpdated = false;
+  private timeupdateHandler = () => this.timeupdate();
 
   constructor(hls: Hls) {
     this.hls = hls;
@@ -51,7 +52,6 @@ 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,21 +62,16 @@ export default class LatencyController implements ComponentAPI {
           : liveSyncDurationCount * targetduration;
     }
     const maxLiveSyncOnStallIncrease = targetduration;
+    const liveSyncOnStallIncrease = 1.0;
     return (
       targetLatency +
       Math.min(
-        this.stallCount * this.config.liveSyncOnStallIncrease,
+        this.stallCount * 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;
@@ -131,7 +126,7 @@ export default class LatencyController implements ComponentAPI {
     this.onMediaDetaching();
     this.levelDetails = null;
     // @ts-ignore
-    this.hls = null;
+    this.hls = this.timeupdateHandler = null;
   }
 
   private registerListeners() {
@@ -155,12 +150,12 @@ export default class LatencyController implements ComponentAPI {
     data: MediaAttachingData,
   ) {
     this.media = data.media;
-    this.media.addEventListener('timeupdate', this.onTimeupdate);
+    this.media.addEventListener('timeupdate', this.timeupdateHandler);
   }
 
   private onMediaDetaching() {
     if (this.media) {
-      this.media.removeEventListener('timeupdate', this.onTimeupdate);
+      this.media.removeEventListener('timeupdate', this.timeupdateHandler);
       this.media = null;
     }
   }
@@ -177,10 +172,10 @@ export default class LatencyController implements ComponentAPI {
   ) {
     this.levelDetails = details;
     if (details.advanced) {
-      this.onTimeupdate();
+      this.timeupdate();
     }
     if (!details.live && this.media) {
-      this.media.removeEventListener('timeupdate', this.onTimeupdate);
+      this.media.removeEventListener('timeupdate', this.timeupdateHandler);
     }
   }
 
@@ -190,13 +185,13 @@ export default class LatencyController implements ComponentAPI {
     }
     this.stallCount++;
     if (this.levelDetails?.live) {
-      this.hls.logger.warn(
-        '[latency-controller]: Stall detected, adjusting target latency',
+      logger.warn(
+        '[playback-rate-controller]: Stall detected, adjusting target latency',
       );
     }
   }
 
-  private onTimeupdate = () => {
+  private timeupdate() {
     const { media, levelDetails } = this;
     if (!media || !levelDetails) {
       return;
@@ -247,7 +242,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;