hls.js 1.5.13-0.canary.10410 → 1.5.13

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

@@ -1,18 +1,14 @@
 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';
-import {
-  Fragment,
-  ElementaryStreamTypes,
-  Part,
-  MediaFragment,
-} from '../loader/fragment';
+import { Fragment, ElementaryStreamTypes, Part } from '../loader/fragment';
 import ChunkCache from '../demux/chunk-cache';
 import TransmuxerInterface from '../demux/transmuxer-interface';
 import { ChunkMetadata } from '../types/transmuxer';
-import { findFragWithCC, findNearestWithCC } from './fragment-finders';
+import { fragmentWithinToleranceTest } from './fragment-finders';
 import { alignMediaPlaylistByPDT } from '../utils/discontinuities';
 import { mediaAttributesIdentical } from '../utils/media-option-attributes';
 import { ErrorDetails } from '../errors';
@@ -38,15 +34,13 @@ import type {
   FragBufferedData,
   ErrorData,
   BufferFlushingData,
-  BufferCodecsData,
-  FragLoadingData,
 } from '../types/events';
 import type { MediaPlaylist } from '../types/media-playlist';
 
 const TICK_INTERVAL = 100; // how often to tick in ms
 
 type WaitingForPTSData = {
-  frag: MediaFragment;
+  frag: Fragment;
   part: Part | null;
   cache: ChunkCache;
   complete: boolean;
@@ -56,8 +50,9 @@ class AudioStreamController
   extends BaseStreamController
   implements NetworkComponentAPI
 {
-  private videoAnchor: MediaFragment | null = null;
-  private mainFragLoading: FragLoadingData | null = null;
+  private videoBuffer: Bufferable | null = null;
+  private videoTrackCC: number = -1;
+  private waitingVideoCC: number = -1;
   private bufferedTrack: MediaPlaylist | null = null;
   private switchingTrack: MediaPlaylist | null = null;
   private trackId: number = -1;
@@ -76,52 +71,53 @@ class AudioStreamController
       hls,
       fragmentTracker,
       keyLoader,
-      'audio-stream-controller',
+      '[audio-stream-controller]',
       PlaylistLevelType.AUDIO,
     );
-    this.registerListeners();
+    this._registerListeners();
   }
 
   protected onHandlerDestroying() {
-    this.unregisterListeners();
+    this._unregisterListeners();
     super.onHandlerDestroying();
     this.mainDetails = null;
     this.bufferedTrack = null;
     this.switchingTrack = null;
   }
 
-  protected registerListeners() {
-    super.registerListeners();
+  private _registerListeners() {
     const { hls } = this;
+    hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
+    hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
+    hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.on(Events.LEVEL_LOADED, this.onLevelLoaded, this);
     hls.on(Events.AUDIO_TRACKS_UPDATED, this.onAudioTracksUpdated, this);
     hls.on(Events.AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
     hls.on(Events.AUDIO_TRACK_LOADED, this.onAudioTrackLoaded, this);
+    hls.on(Events.ERROR, this.onError, this);
     hls.on(Events.BUFFER_RESET, this.onBufferReset, this);
     hls.on(Events.BUFFER_CREATED, this.onBufferCreated, this);
     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);
   }
 
-  protected unregisterListeners() {
+  private _unregisterListeners() {
     const { hls } = this;
-    if (!hls) {
-      return;
-    }
-    super.unregisterListeners();
+    hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
+    hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
+    hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.off(Events.LEVEL_LOADED, this.onLevelLoaded, this);
     hls.off(Events.AUDIO_TRACKS_UPDATED, this.onAudioTracksUpdated, this);
     hls.off(Events.AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
     hls.off(Events.AUDIO_TRACK_LOADED, this.onAudioTrackLoaded, this);
+    hls.off(Events.ERROR, this.onError, this);
     hls.off(Events.BUFFER_RESET, this.onBufferReset, this);
     hls.off(Events.BUFFER_CREATED, this.onBufferCreated, this);
     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);
   }
 
@@ -132,44 +128,18 @@ class AudioStreamController
   ) {
     // Always update the new INIT PTS
     // Can change due level switch
-    if (id === PlaylistLevelType.MAIN) {
+    if (id === 'main') {
       const cc = frag.cc;
-      const inFlightFrag = this.fragCurrent;
-      this.initPTS[cc] = { baseTime: initPTS, timescale };
-      this.log(
-        `InitPTS for cc: ${cc} found from main: ${initPTS}/${timescale}`,
-      );
-      this.videoAnchor = frag;
+      this.initPTS[frag.cc] = { baseTime: initPTS, timescale };
+      this.log(`InitPTS for cc: ${cc} found from main: ${initPTS}`);
+      this.videoTrackCC = cc;
       // 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;
@@ -232,9 +202,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 = {
@@ -247,15 +217,33 @@ class AudioStreamController
             if (complete) {
               super._handleFragmentLoadComplete(data);
             }
-          } else if (videoAnchor && videoAnchor.cc !== waitingData.frag.cc) {
+          } else if (this.videoTrackCC !== this.waitingVideoCC) {
             // 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 ${videoAnchor.cc}`,
+              `Waiting fragment cc (${frag.cc}) cancelled because video is at cc ${this.videoTrackCC}`,
             );
-            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 if (this.state !== State.STOPPED) {
+        } else {
           this.state = State.IDLE;
         }
       }
@@ -267,15 +255,10 @@ 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;
-      if (this.state !== State.STOPPED) {
-        this.state = State.IDLE;
-      }
+      this.waitingVideoCC = -1;
+      this.state = State.IDLE;
     }
   }
 
@@ -298,14 +281,12 @@ class AudioStreamController
     const { hls, levels, media, trackId } = this;
     const config = hls.config;
 
-    // 1. if buffering is suspended
-    // 2. if video not attached AND
+    // 1. if video not attached AND
     //    start fragment already requested OR start frag prefetch not enabled
-    // 3. if tracks or track not loaded and selected
+    // 2. if tracks or track not loaded and selected
     // then exit loop
     // => if media not attached but start frag prefetch is enabled and start frag not requested yet, we will not exit loop
     if (
-      !this.buffering ||
       (!media && (this.startFragRequested || !config.startFragPrefetch)) ||
       !levels?.[trackId]
     ) {
@@ -349,16 +330,21 @@ class AudioStreamController
       return;
     }
 
+    const mainBufferInfo = this.getFwdBufferInfo(
+      this.videoBuffer ? this.videoBuffer : this.media,
+      PlaylistLevelType.MAIN,
+    );
     const bufferLen = bufferInfo.len;
-    const maxBufLen = hls.maxBufferLength;
+    const maxBufLen = this.getMaxBufferLength(mainBufferInfo?.len);
 
     const fragments = trackDetails.fragments;
     const start = fragments[0].start;
-    const loadPosition = this.getLoadPosition();
-    let targetBufferTime = this.flushing ? loadPosition : bufferInfo.end;
+    let targetBufferTime = this.flushing
+      ? this.getLoadPosition()
+      : bufferInfo.end;
 
     if (switchingTrack && media) {
-      const pos = loadPosition;
+      const pos = this.getLoadPosition();
       // STABLE
       if (
         bufferedTrack &&
@@ -388,8 +374,10 @@ 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,
@@ -403,18 +391,27 @@ class AudioStreamController
       return;
     }
 
+    // Buffer audio up to one target duration ahead of main buffer
+    const atBufferSyncLimit =
+      mainBufferInfo &&
+      frag.start > mainBufferInfo.end + trackDetails.targetduration;
     if (
-      this.startFragRequested &&
-      (!trackDetails.live || targetBufferTime < this.hls.liveSyncPosition!)
+      atBufferSyncLimit ||
+      // Or wait for main buffer after buffing some audio
+      (!mainBufferInfo?.len && bufferInfo.len)
     ) {
-      // Request audio segments up to one fragment ahead of main buffer
-      const mainFragLoading = this.mainFragLoading;
-      const mainTargetBufferEnd = mainFragLoading
-        ? (mainFragLoading.part || mainFragLoading.frag).end
-        : null;
-      const atBufferSyncLimit =
-        mainTargetBufferEnd !== null && frag.start > mainTargetBufferEnd;
-      if (atBufferSyncLimit && !frag.endList) {
+      // Check fragment-tracker for main fragments since GAP segments do not show up in bufferInfo
+      const mainFrag = this.getAppendedFrag(frag.start, PlaylistLevelType.MAIN);
+      if (mainFrag === null) {
+        return;
+      }
+      // Bridge gaps in main buffer
+      atGap ||=
+        !!mainFrag.gap || (!!atBufferSyncLimit && mainBufferInfo.len === 0);
+      if (
+        (atBufferSyncLimit && !atGap) ||
+        (atGap && bufferInfo.nextStart && bufferInfo.nextStart < mainFrag.end)
+      ) {
         return;
       }
     }
@@ -422,12 +419,24 @@ class AudioStreamController
     this.loadFragment(frag, levelInfo, targetBufferTime);
   }
 
-  protected onMediaDetaching() {
+  protected getMaxBufferLength(mainBufferLength?: number): number {
+    const maxConfigBuffer = super.getMaxBufferLength();
+    if (!mainBufferLength) {
+      return maxConfigBuffer;
+    }
+    return Math.min(
+      Math.max(maxConfigBuffer, mainBufferLength),
+      this.config.maxMaxBufferLength,
+    );
+  }
+
+  onMediaDetaching() {
+    this.videoBuffer = null;
     this.bufferFlushed = this.flushing = false;
     super.onMediaDetaching();
   }
 
-  private onAudioTracksUpdated(
+  onAudioTracksUpdated(
     event: Events.AUDIO_TRACKS_UPDATED,
     { audioTracks }: AudioTracksUpdatedData,
   ) {
@@ -436,7 +445,7 @@ class AudioStreamController
     this.levels = audioTracks.map((mediaPlaylist) => new Level(mediaPlaylist));
   }
 
-  private onAudioTrackSwitching(
+  onAudioTrackSwitching(
     event: Events.AUDIO_TRACK_SWITCHING,
     data: AudioTrackSwitchingData,
   ) {
@@ -450,41 +459,44 @@ class AudioStreamController
       this.removeUnbufferedFrags(fragCurrent.start);
     }
     this.resetLoadingState();
+    // destroy useless transmuxer when switching audio to main
+    if (!altAudio) {
+      this.resetTransmuxer();
+    } else {
+      // switching to audio track, start timer if not already started
+      this.setInterval(TICK_INTERVAL);
+    }
 
     // should we switch tracks ?
     if (altAudio) {
       this.switchingTrack = data;
       // main audio track are handled by stream-controller, just do something if switching to alt audio track
+      this.state = State.IDLE;
       this.flushAudioIfNeeded(data);
-      if (this.state !== State.STOPPED) {
-        // switching to audio track, start timer if not already started
-        this.setInterval(TICK_INTERVAL);
-        this.state = State.IDLE;
-        this.tick();
-      }
     } else {
-      // destroy useless transmuxer when switching audio to main
-      this.resetTransmuxer();
       this.switchingTrack = null;
       this.bufferedTrack = data;
-      this.clearInterval();
+      this.state = State.STOPPED;
     }
+    this.tick();
   }
 
-  protected onManifestLoading() {
-    super.onManifestLoading();
+  onManifestLoading() {
+    this.fragmentTracker.removeAllFragments();
+    this.startPosition = this.lastCurrentTime = 0;
     this.bufferFlushed = this.flushing = false;
-    this.mainDetails =
+    this.levels =
+      this.mainDetails =
       this.waitingData =
-      this.videoAnchor =
       this.bufferedTrack =
       this.cachedTrackLoadedData =
       this.switchingTrack =
         null;
-    this.trackId = -1;
+    this.startFragRequested = false;
+    this.trackId = this.videoTrackCC = this.waitingVideoCC = -1;
   }
 
-  private onLevelLoaded(event: Events.LEVEL_LOADED, data: LevelLoadedData) {
+  onLevelLoaded(event: Events.LEVEL_LOADED, data: LevelLoadedData) {
     this.mainDetails = data.details;
     if (this.cachedTrackLoadedData !== null) {
       this.hls.trigger(Events.AUDIO_TRACK_LOADED, this.cachedTrackLoadedData);
@@ -492,10 +504,7 @@ class AudioStreamController
     }
   }
 
-  private onAudioTrackLoaded(
-    event: Events.AUDIO_TRACK_LOADED,
-    data: TrackLoadedData,
-  ) {
+  onAudioTrackLoaded(event: Events.AUDIO_TRACK_LOADED, data: TrackLoadedData) {
     if (this.mainDetails == null) {
       this.cachedTrackLoadedData = data;
       return;
@@ -561,8 +570,7 @@ class AudioStreamController
   }
 
   _handleFragmentLoadProgress(data: FragLoadedData) {
-    const frag = data.frag as MediaFragment;
-    const { part, payload } = data;
+    const { frag, part, payload } = data;
     const { config, trackId, levels } = this;
     if (!levels) {
       this.warn(
@@ -607,7 +615,7 @@ class AudioStreamController
       const partial = partIndex !== -1;
       const chunkMeta = new ChunkMetadata(
         frag.level,
-        frag.sn,
+        frag.sn as number,
         frag.stats.chunkCount,
         payload.byteLength,
         partIndex,
@@ -636,6 +644,7 @@ class AudioStreamController
         complete: false,
       });
       cache.push(new Uint8Array(payload));
+      this.waitingVideoCC = this.videoTrackCC;
       this.state = State.WAITING_INIT_PTS;
     }
   }
@@ -648,44 +657,32 @@ class AudioStreamController
     super._handleFragmentLoadComplete(fragLoadedData);
   }
 
-  private onBufferReset(/* event: Events.BUFFER_RESET */) {
+  onBufferReset(/* event: Events.BUFFER_RESET */) {
     // reset reference to sourcebuffers
-    this.mediaBuffer = null;
+    this.mediaBuffer = this.videoBuffer = null;
     this.loadedmetadata = false;
   }
 
-  private onBufferCreated(
-    event: Events.BUFFER_CREATED,
-    data: BufferCreatedData,
-  ) {
+  onBufferCreated(event: Events.BUFFER_CREATED, data: BufferCreatedData) {
     const audioTrack = data.tracks.audio;
     if (audioTrack) {
       this.mediaBuffer = audioTrack.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();
-      }
+    if (data.tracks.video) {
+      this.videoBuffer = data.tracks.video.buffer || null;
     }
   }
 
-  private onFragBuffered(event: Events.FRAG_BUFFERED, data: FragBufferedData) {
+  onFragBuffered(event: Events.FRAG_BUFFERED, data: FragBufferedData) {
     const { frag, part } = data;
     if (frag.type !== PlaylistLevelType.AUDIO) {
       if (!this.loadedmetadata && frag.type === PlaylistLevelType.MAIN) {
-        const bufferedState = this.fragmentTracker.getState(frag);
-        if (
-          bufferedState === FragmentState.OK ||
-          bufferedState === FragmentState.PARTIAL
-        ) {
-          this.loadedmetadata = true;
+        const bufferable = this.videoBuffer || this.media;
+        if (bufferable) {
+          const bufferedTimeRanges = BufferHelper.getBuffered(bufferable);
+          if (bufferedTimeRanges.length) {
+            this.loadedmetadata = true;
+          }
         }
       }
       return;
@@ -705,7 +702,7 @@ class AudioStreamController
       return;
     }
     if (frag.sn !== 'initSegment') {
-      this.fragPrevious = frag as MediaFragment;
+      this.fragPrevious = frag;
       const track = this.switchingTrack;
       if (track) {
         this.bufferedTrack = track;
@@ -716,7 +713,7 @@ class AudioStreamController
     this.fragBufferedComplete(frag, part);
   }
 
-  protected onError(event: Events.ERROR, data: ErrorData) {
+  private onError(event: Events.ERROR, data: ErrorData) {
     if (data.fatal) {
       this.state = State.ERROR;
       return;
@@ -890,15 +887,12 @@ class AudioStreamController
     if (tracks.video) {
       delete tracks.video;
     }
-    if (tracks.audiovideo) {
-      delete tracks.audiovideo;
-    }
 
     // include levelCodec in audio and video tracks
-    if (!tracks.audio) {
+    const track = tracks.audio;
+    if (!track) {
       return;
     }
-    const track = tracks.audio;
 
     track.id = 'audio';
 
@@ -910,7 +904,7 @@ class AudioStreamController
     if (variantAudioCodecs && variantAudioCodecs.split(',').length === 1) {
       track.levelCodec = variantAudioCodecs;
     }
-    this.hls.trigger(Events.BUFFER_CODECS, tracks as BufferCodecsData);
+    this.hls.trigger(Events.BUFFER_CODECS, tracks);
     const initSegment = track.initSegment;
     if (initSegment?.byteLength) {
       const segment: BufferAppendingData = {
@@ -934,6 +928,7 @@ 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 (
@@ -956,6 +951,7 @@ class AudioStreamController
           alignMediaPlaylistByPDT(track.details, mainDetails);
         }
       } else {
+        this.startFragRequested = true;
         super.loadFragment(frag, track, targetBufferTime);
       }
     } else {

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

@@ -33,7 +33,7 @@ class AudioTrackController extends BasePlaylistController {
   private selectDefaultTrack: boolean = true;
 
   constructor(hls: Hls) {
-    super(hls, 'audio-track-controller');
+    super(hls, '[audio-track-controller]');
     this.registerListeners();
   }
 

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

@@ -1,16 +1,11 @@
 import type Hls from '../hls';
 import type { NetworkComponentAPI } from '../types/component-api';
-import {
-  getSkipValue,
-  HlsSkip,
-  HlsUrlParameters,
-  type Level,
-} from '../types/level';
+import { getSkipValue, HlsSkip, HlsUrlParameters, Level } from '../types/level';
 import { computeReloadInterval, mergeDetails } from '../utils/level-helper';
-import type { ErrorData } from '../types/events';
+import { ErrorData } from '../types/events';
 import { getRetryDelay, isTimeoutError } from '../utils/error-helper';
 import { NetworkErrorAction } from './error-controller';
-import { Logger } from '../utils/logger';
+import { logger } from '../utils/logger';
 import type { LevelDetails } from '../loader/level-details';
 import type { MediaPlaylist } from '../types/media-playlist';
 import type {
@@ -19,17 +14,17 @@ import type {
   TrackLoadedData,
 } from '../types/events';
 
-export default class BasePlaylistController
-  extends Logger
-  implements NetworkComponentAPI
-{
+export default class BasePlaylistController implements NetworkComponentAPI {
   protected hls: Hls;
   protected timer: number = -1;
   protected requestScheduled: number = -1;
   protected canLoad: boolean = false;
+  protected log: (msg: any) => void;
+  protected warn: (msg: any) => void;
 
   constructor(hls: Hls, logPrefix: string) {
-    super(logPrefix, hls.logger);
+    this.log = logger.log.bind(logger, `${logPrefix}:`);
+    this.warn = logger.warn.bind(logger, `${logPrefix}:`);
     this.hls = hls;
   }
 
@@ -71,7 +66,7 @@ export default class BasePlaylistController
         try {
           uri = new self.URL(attr.URI, previous.url).href;
         } catch (error) {
-          this.warn(
+          logger.warn(
             `Could not construct new URL for Rendition Report: ${error}`,
           );
           uri = attr.URI || '';
@@ -195,19 +190,7 @@ export default class BasePlaylistController
           details.targetduration * 1.5,
         );
         if (currentGoal > 0) {
-          if (cdnAge > details.targetduration * 3) {
-            // Omit segment and part directives when the last response was more than 3 target durations ago,
-            this.log(
-              `Playlist last advanced ${lastAdvanced.toFixed(
-                2,
-              )}s ago. Omitting segment and part directives.`,
-            );
-            msn = undefined;
-            part = undefined;
-          } else if (
-            previousDetails?.tuneInGoal &&
-            cdnAge - details.partTarget > previousDetails.tuneInGoal
-          ) {
+          if (previousDetails && currentGoal > previousDetails.tuneInGoal) {
             // If we attempted to get the next or latest playlist update, but currentGoal increased,
             // then we either can't catchup, or the "age" header cannot be trusted.
             this.warn(