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

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

@@ -1,15 +1,12 @@
 import TaskLoop from '../task-loop';
 import { FragmentState } from './fragment-tracker';
 import { Bufferable, BufferHelper, BufferInfo } from '../utils/buffer-helper';
+import { logger } from '../utils/logger';
 import { Events } from '../events';
 import { ErrorDetails, ErrorTypes } from '../errors';
 import { ChunkMetadata } from '../types/transmuxer';
 import { appendUint8Array } from '../utils/mp4-tools';
 import { alignStream } from '../utils/discontinuities';
-import {
-  isFullSegmentEncryption,
-  getAesModeFromFullSegmentMethod,
-} from '../utils/encryption-methods-util';
 import {
   findFragmentByPDT,
   findFragmentByPTS,
@@ -22,7 +19,7 @@ import {
   updateFragPTSDTS,
 } from '../utils/level-helper';
 import TransmuxerInterface from '../demux/transmuxer-interface';
-import { Fragment, MediaFragment, Part } from '../loader/fragment';
+import { Fragment, Part } from '../loader/fragment';
 import FragmentLoader, {
   FragmentLoadProgressCallback,
   LoadError,
@@ -77,7 +74,7 @@ export default class BaseStreamController
 {
   protected hls: Hls;
 
-  protected fragPrevious: MediaFragment | null = null;
+  protected fragPrevious: Fragment | null = null;
   protected fragCurrent: Fragment | null = null;
   protected fragmentTracker: FragmentTracker;
   protected transmuxer: TransmuxerInterface | null = null;
@@ -100,9 +97,12 @@ export default class BaseStreamController
   protected startFragRequested: boolean = false;
   protected decrypter: Decrypter;
   protected initPTS: RationalTimestamp[] = [];
-  protected buffering: boolean = true;
-  protected loadingParts: boolean = false;
-  private loopSn?: string | number;
+  protected onvseeking: EventListener | null = null;
+  protected onvended: EventListener | null = null;
+
+  private readonly logPrefix: string = '';
+  protected log: (msg: any) => void;
+  protected warn: (msg: any) => void;
 
   constructor(
     hls: Hls,
@@ -111,32 +111,18 @@ export default class BaseStreamController
     logPrefix: string,
     playlistType: PlaylistLevelType,
   ) {
-    super(logPrefix, hls.logger);
+    super();
     this.playlistType = playlistType;
+    this.logPrefix = logPrefix;
+    this.log = logger.log.bind(logger, `${logPrefix}:`);
+    this.warn = logger.warn.bind(logger, `${logPrefix}:`);
     this.hls = hls;
     this.fragmentLoader = new FragmentLoader(hls.config);
     this.keyLoader = keyLoader;
     this.fragmentTracker = fragmentTracker;
     this.config = hls.config;
     this.decrypter = new Decrypter(hls.config);
-  }
-
-  protected 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.MANIFEST_LOADED, this.onManifestLoaded, this);
-    hls.on(Events.ERROR, this.onError, this);
-  }
-
-  protected unregisterListeners() {
-    const { hls } = this;
-    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.MANIFEST_LOADED, this.onManifestLoaded, this);
-    hls.off(Events.ERROR, this.onError, this);
   }
 
   protected doTick() {
@@ -149,9 +135,6 @@ 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;
@@ -167,14 +150,6 @@ export default class BaseStreamController
     this.state = State.STOPPED;
   }
 
-  public pauseBuffering() {
-    this.buffering = false;
-  }
-
-  public resumeBuffering() {
-    this.buffering = true;
-  }
-
   protected _streamEnded(
     bufferInfo: BufferInfo,
     levelDetails: LevelDetails,
@@ -222,8 +197,10 @@ export default class BaseStreamController
     data: MediaAttachedData,
   ) {
     const media = (this.media = this.mediaBuffer = data.media);
-    media.addEventListener('seeking', this.onMediaSeeking);
-    media.addEventListener('ended', this.onMediaEnded);
+    this.onvseeking = this.onMediaSeeking.bind(this) as EventListener;
+    this.onvended = this.onMediaEnded.bind(this) as EventListener;
+    media.addEventListener('seeking', this.onvseeking);
+    media.addEventListener('ended', this.onvended);
     const config = this.config;
     if (this.levels && config.autoStartLoad && this.state === State.STOPPED) {
       this.startLoad(config.startPosition);
@@ -238,30 +215,21 @@ export default class BaseStreamController
     }
 
     // remove video listeners
-    if (media) {
-      media.removeEventListener('seeking', this.onMediaSeeking);
-      media.removeEventListener('ended', this.onMediaEnded);
+    if (media && this.onvseeking && this.onvended) {
+      media.removeEventListener('seeking', this.onvseeking);
+      media.removeEventListener('ended', this.onvended);
+      this.onvseeking = this.onvended = null;
     }
     if (this.keyLoader) {
       this.keyLoader.detach();
     }
     this.media = this.mediaBuffer = null;
-    this.loopSn = undefined;
-    this.startFragRequested = this.loadedmetadata = this.loadingParts = false;
+    this.loadedmetadata = false;
     this.fragmentTracker.removeAllFragments();
     this.stopLoad();
   }
 
-  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) {}
-
-  protected onMediaSeeking = () => {
+  protected onMediaSeeking() {
     const { config, fragCurrent, media, mediaBuffer, state } = this;
     const currentTime: number = media ? media.currentTime : 0;
     const bufferInfo = BufferHelper.bufferInfo(
@@ -314,27 +282,7 @@ export default class BaseStreamController
         true,
       );
 
-      // Don't set lastCurrentTime with backward seeks (allows for frag selection with strict tolerances)
-      const lastCurrentTime = this.lastCurrentTime;
-      if (currentTime > lastCurrentTime) {
-        this.lastCurrentTime = currentTime;
-      }
-
-      if (!this.loadingParts) {
-        const bufferEnd = Math.max(bufferInfo.end, currentTime);
-        const shouldLoadParts = this.shouldLoadParts(
-          this.getLevelDetails(),
-          bufferEnd,
-        );
-        if (shouldLoadParts) {
-          this.log(
-            `LL-Part loading ON after seeking to ${currentTime.toFixed(
-              2,
-            )} with buffer @${bufferEnd.toFixed(2)}`,
-          );
-          this.loadingParts = shouldLoadParts;
-        }
-      }
+      this.lastCurrentTime = currentTime;
     }
 
     // in case seeking occurs although no media buffered, adjust startPosition and nextLoadPosition to seek target
@@ -344,34 +292,27 @@ export default class BaseStreamController
 
     // Async tick to speed up processing
     this.tickImmediate();
-  };
+  }
 
-  protected onMediaEnded = () => {
+  protected onMediaEnded() {
     // reset startPosition and lastCurrentTime to restart playback @ stream beginning
     this.startPosition = this.lastCurrentTime = 0;
-    if (this.playlistType === PlaylistLevelType.MAIN) {
-      this.hls.trigger(Events.MEDIA_ENDED, {
-        stalled: false,
-      });
-    }
-  };
+  }
 
   protected onManifestLoaded(
     event: Events.MANIFEST_LOADED,
     data: ManifestLoadedData,
   ): void {
     this.startTimeOffset = data.startTimeOffset;
+    this.initPTS = [];
   }
 
   protected onHandlerDestroying() {
+    this.hls.off(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
     this.stopLoad();
-    if (this.transmuxer) {
-      this.transmuxer.destroy();
-      this.transmuxer = null;
-    }
     super.onHandlerDestroying();
     // @ts-ignore
-    this.hls = this.onMediaSeeking = this.onMediaEnded = null;
+    this.hls = null;
   }
 
   protected onHandlerDestroyed() {
@@ -402,7 +343,6 @@ export default class BaseStreamController
     level: Level,
     targetBufferTime: number,
   ) {
-    this.startFragRequested = true;
     this._loadFragForPlayback(frag, level, targetBufferTime);
   }
 
@@ -446,9 +386,7 @@ export default class BaseStreamController
         }
 
         if ('payload' in data) {
-          this.log(
-            `Loaded ${frag.type} sn: ${frag.sn} of ${this.playlistLabel()} ${frag.level}`,
-          );
+          this.log(`Loaded fragment ${frag.sn} of level ${frag.level}`);
           this.hls.trigger(Events.FRAG_LOADED, data);
         }
 
@@ -558,7 +496,7 @@ export default class BaseStreamController
           payload.byteLength > 0 &&
           decryptData?.key &&
           decryptData.iv &&
-          isFullSegmentEncryption(decryptData.method)
+          decryptData.method === 'AES-128'
         ) {
           const startTime = self.performance.now();
           // decrypt init segment data
@@ -567,7 +505,6 @@ export default class BaseStreamController
               new Uint8Array(payload),
               decryptData.key.buffer,
               decryptData.iv.buffer,
-              getAesModeFromFullSegmentMethod(decryptData.method),
             )
             .catch((err) => {
               hls.trigger(Events.ERROR, {
@@ -611,9 +548,7 @@ export default class BaseStreamController
       throw new Error('init load aborted, missing levels');
     }
     const stats = data.frag.stats;
-    if (this.state !== State.STOPPED) {
-      this.state = State.IDLE;
-    }
+    this.state = State.IDLE;
     data.frag.data = new Uint8Array(data.payload);
     stats.parsing.start = stats.buffering.start = self.performance.now();
     stats.parsing.end = stats.buffering.end = self.performance.now();
@@ -635,7 +570,11 @@ export default class BaseStreamController
     this.log(
       `Buffered ${frag.type} sn: ${frag.sn}${
         part ? ' part: ' + part.index : ''
-      } of ${this.fragInfo(frag)} > buffer:${
+      } of ${
+        this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track'
+      } ${frag.level} (frag:[${(frag.startPTS ?? NaN).toFixed(3)}-${(
+        frag.endPTS ?? NaN
+      ).toFixed(3)}] > buffer:${
         media
           ? TimeRanges.toString(BufferHelper.getBuffered(media))
           : '(detached)'
@@ -709,7 +648,6 @@ 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(
@@ -720,7 +658,9 @@ export default class BaseStreamController
     let keyLoadingPromise: Promise<KeyLoadedData | void> | null = null;
     if (frag.encrypted && !frag.decryptdata?.key) {
       this.log(
-        `Loading key for ${frag.sn} of [${details.startSN}-${details.endSN}], ${this.playlistLabel()} ${frag.level}`,
+        `Loading key for ${frag.sn} of [${details.startSN}-${details.endSN}], ${
+          this.logPrefix === '[stream-controller]' ? 'level' : 'track'
+        } ${frag.level}`,
       );
       this.state = State.KEY_LOADING;
       this.fragCurrent = frag;
@@ -743,23 +683,8 @@ export default class BaseStreamController
       this.keyLoader.loadClear(frag, details.encryptedFragments);
     }
 
-    const fragPrevious = this.fragPrevious;
-    if (
-      frag.sn !== 'initSegment' &&
-      (!fragPrevious || frag.sn !== fragPrevious.sn)
-    ) {
-      const shouldLoadParts = this.shouldLoadParts(level.details, frag.end);
-      if (shouldLoadParts !== this.loadingParts) {
-        this.log(
-          `LL-Part loading ${
-            shouldLoadParts ? 'ON' : 'OFF'
-          } loading sn ${fragPrevious?.sn}->${frag.sn}`,
-        );
-        this.loadingParts = shouldLoadParts;
-      }
-    }
     targetBufferTime = Math.max(frag.start, targetBufferTime || 0);
-    if (this.loadingParts && frag.sn !== 'initSegment') {
+    if (this.config.lowLatencyMode && frag.sn !== 'initSegment') {
       const partList = details.partList;
       if (partList && progressCallback) {
         if (targetBufferTime > frag.end && details.fragmentHint) {
@@ -773,7 +698,9 @@ export default class BaseStreamController
               frag.cc
             } of playlist [${details.startSN}-${
               details.endSN
-            }] parts [0-${partIndex}-${partList.length - 1}] ${this.playlistLabel()}: ${frag.level}, target: ${parseFloat(
+            }] parts [0-${partIndex}-${partList.length - 1}] ${
+              this.logPrefix === '[stream-controller]' ? 'level' : 'track'
+            }: ${frag.level}, target: ${parseFloat(
               targetBufferTime.toFixed(3),
             )}`,
           );
@@ -828,21 +755,11 @@ export default class BaseStreamController
       }
     }
 
-    if (frag.sn !== 'initSegment' && this.loadingParts) {
-      this.log(
-        `LL-Part loading OFF after next part miss @${targetBufferTime.toFixed(
-          2,
-        )}`,
-      );
-      this.loadingParts = false;
-    } else if (!frag.url) {
-      // Selected fragment hint for part but not loading parts
-      return Promise.resolve(null);
-    }
-
     this.log(
-      `Loading ${frag.type} sn: ${frag.sn} of ${this.fragInfo(frag, false)}) cc: ${frag.cc} ${
-        details ? '[' + details.startSN + '-' + details.endSN + ']' : ''
+      `Loading fragment ${frag.sn} cc: ${frag.cc} ${
+        details ? 'of [' + details.startSN + '-' + details.endSN + '] ' : ''
+      }${this.logPrefix === '[stream-controller]' ? 'level' : 'track'}: ${
+        frag.level
       }, target: ${parseFloat(targetBufferTime.toFixed(3))}`,
     );
     // Don't update nextLoadPosition for fragments which are not buffered
@@ -908,7 +825,7 @@ export default class BaseStreamController
               const loadedPart = partLoadedData.part as Part;
               this.hls.trigger(Events.FRAG_LOADED, partLoadedData);
               const nextPart =
-                getPartWith(level.details, frag.sn as number, part.index + 1) ||
+                getPartWith(level, frag.sn as number, part.index + 1) ||
                 findPart(initialPartList, frag.sn as number, part.index + 1);
               if (nextPart) {
                 loadPart(nextPart);
@@ -965,50 +882,12 @@ export default class BaseStreamController
     if (part) {
       part.stats.parsing.end = now;
     }
-    // See if part loading should be disabled/enabled based on buffer and playback position.
-    const levelDetails = this.getLevelDetails();
-    const loadingPartsAtEdge = levelDetails && frag.sn > levelDetails.endSN;
-    const shouldLoadParts =
-      loadingPartsAtEdge || this.shouldLoadParts(levelDetails, frag.end);
-    if (shouldLoadParts !== this.loadingParts) {
-      this.log(
-        `LL-Part loading ${
-          shouldLoadParts ? 'ON' : 'OFF'
-        } after parsing segment ending @${frag.end.toFixed(2)}`,
-      );
-      this.loadingParts = shouldLoadParts;
-    }
     this.updateLevelTiming(frag, part, level, chunkMeta.partial);
   }
 
-  private shouldLoadParts(
-    details: LevelDetails | undefined,
-    bufferEnd: number,
-  ): boolean {
-    if (this.config.lowLatencyMode) {
-      if (!details) {
-        return this.loadingParts;
-      }
-      if (details?.partList) {
-        // Buffer must be ahead of first part + duration of parts after last segment
-        // and playback must be at or past segment adjacent to part list
-        const firstPart = details.partList[0];
-        const safePartStart =
-          firstPart.end + (details.fragmentHint?.duration || 0);
-        if (
-          bufferEnd >= safePartStart &&
-          this.lastCurrentTime > firstPart.start - firstPart.fragment.duration
-        ) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-
   protected getCurrentContext(
     chunkMeta: ChunkMetadata,
-  ): { frag: MediaFragment; part: Part | null; level: Level } | null {
+  ): { frag: Fragment; part: Part | null; level: Level } | null {
     const { levels, fragCurrent } = this;
     const { level: levelIndex, sn, part: partIndex } = chunkMeta;
     if (!levels?.[levelIndex]) {
@@ -1018,13 +897,10 @@ export default class BaseStreamController
       return null;
     }
     const level = levels[levelIndex];
-    const levelDetails = level.details;
-
-    const part =
-      partIndex > -1 ? getPartWith(levelDetails, sn, partIndex) : null;
+    const part = partIndex > -1 ? getPartWith(level, sn, partIndex) : null;
     const frag = part
       ? part.fragment
-      : getFragmentWithSN(levelDetails, sn, fragCurrent);
+      : getFragmentWithSN(level, sn, fragCurrent);
     if (!frag) {
       return null;
     }
@@ -1110,26 +986,22 @@ export default class BaseStreamController
     if (!Number.isFinite(pos)) {
       return null;
     }
-    const backwardSeek = this.lastCurrentTime > pos;
-    const maxBufferHole =
-      backwardSeek || this.media?.paused ? 0 : this.config.maxBufferHole;
-    return this.getFwdBufferInfoAtPos(bufferable, pos, type, maxBufferHole);
+    return this.getFwdBufferInfoAtPos(bufferable, pos, type);
   }
 
-  private getFwdBufferInfoAtPos(
+  protected getFwdBufferInfoAtPos(
     bufferable: Bufferable | null,
     pos: number,
     type: PlaylistLevelType,
-    maxBufferHole: number,
   ): BufferInfo | null {
+    const {
+      config: { maxBufferHole },
+    } = this;
     const bufferInfo = BufferHelper.bufferInfo(bufferable, pos, maxBufferHole);
     // Workaround flaw in getting forward buffer when maxBufferHole is smaller than gap at current pos
     if (bufferInfo.len === 0 && bufferInfo.nextStart !== undefined) {
       const bufferedFragAtPos = this.fragmentTracker.getBufferedFrag(pos, type);
-      if (
-        bufferedFragAtPos &&
-        (bufferInfo.nextStart <= bufferedFragAtPos.end || bufferedFragAtPos.gap)
-      ) {
+      if (bufferedFragAtPos && bufferInfo.nextStart < bufferedFragAtPos.end) {
         return BufferHelper.bufferInfo(
           bufferable,
           pos,
@@ -1142,7 +1014,7 @@ export default class BaseStreamController
 
   protected getMaxBufferLength(levelBitrate?: number): number {
     const { config } = this;
-    let maxBufLen: number;
+    let maxBufLen;
     if (levelBitrate) {
       maxBufLen = Math.max(
         (8 * config.maxBufferSize) / levelBitrate,
@@ -1178,9 +1050,9 @@ export default class BaseStreamController
     position: number,
     playlistType: PlaylistLevelType = PlaylistLevelType.MAIN,
   ): Fragment | null {
-    const fragOrPart = this.fragmentTracker?.getAppendedFrag(
+    const fragOrPart = this.fragmentTracker.getAppendedFrag(
       position,
-      playlistType,
+      PlaylistLevelType.MAIN,
     );
     if (fragOrPart && 'fragment' in fragOrPart) {
       return fragOrPart.fragment;
@@ -1202,8 +1074,7 @@ export default class BaseStreamController
     // find fragment index, contiguous with end of buffer position
     const { config } = this;
     const start = fragments[0].start;
-    const canLoadParts = config.lowLatencyMode && !!levelDetails.partList;
-    let frag: MediaFragment | null = null;
+    let frag;
 
     if (levelDetails.live) {
       const initialLiveManifestSize = config.initialLiveManifestSize;
@@ -1223,10 +1094,6 @@ export default class BaseStreamController
           this.startPosition === -1) ||
         pos < start
       ) {
-        if (canLoadParts && !this.loadingParts) {
-          this.log(`LL-Part loading ON for initial live fragment`);
-          this.loadingParts = true;
-        }
         frag = this.getInitialLiveFragment(levelDetails, fragments);
         this.startPosition = this.nextLoadPosition = frag
           ? this.hls.liveSyncPosition || frag.start
@@ -1239,7 +1106,7 @@ export default class BaseStreamController
 
     // If we haven't run into any special cases already, just load the fragment most closely matching the requested position
     if (!frag) {
-      const end = this.loadingParts
+      const end = config.lowLatencyMode
         ? levelDetails.partEnd
         : levelDetails.fragmentEnd;
       frag = this.getFragmentAtPosition(pos, end, levelDetails);
@@ -1264,35 +1131,34 @@ export default class BaseStreamController
     playlistType: PlaylistLevelType,
     maxBufLen: number,
   ): Fragment | null {
-    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,
-          0,
+    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}`,
         );
-        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 null;
       }
     }
-    this.loopSn = undefined;
-    return nextFragment;
+    return frag;
   }
 
   mapToInitFragWhenRequired(frag: Fragment | null): typeof frag {
@@ -1347,10 +1213,10 @@ export default class BaseStreamController
   */
   protected getInitialLiveFragment(
     levelDetails: LevelDetails,
-    fragments: MediaFragment[],
-  ): MediaFragment | null {
+    fragments: Array<Fragment>,
+  ): Fragment | null {
     const fragPrevious = this.fragPrevious;
-    let frag: MediaFragment | null = null;
+    let frag: Fragment | null = null;
     if (fragPrevious) {
       if (levelDetails.hasProgramDateTime) {
         // Prefer using PDT, because it can be accurate enough to choose the correct fragment without knowing the level sliding
@@ -1414,7 +1280,7 @@ export default class BaseStreamController
     bufferEnd: number,
     end: number,
     levelDetails: LevelDetails,
-  ): MediaFragment | null {
+  ): Fragment | null {
     const { config } = this;
     let { fragPrevious } = this;
     let { fragments, endSN } = levelDetails;
@@ -1423,25 +1289,20 @@ export default class BaseStreamController
     const partList = levelDetails.partList;
 
     const loadingParts = !!(
-      this.loadingParts &&
+      config.lowLatencyMode &&
       partList?.length &&
       fragmentHint
     );
     if (loadingParts && fragmentHint && !this.bitrateTest) {
       // Include incomplete fragment with parts at end
       fragments = fragments.concat(fragmentHint);
-      endSN = fragmentHint.sn;
+      endSN = fragmentHint.sn as number;
     }
 
-    let frag: MediaFragment | null;
+    let frag;
     if (bufferEnd < end) {
-      const backwardSeek = bufferEnd < this.lastCurrentTime;
       const lookupTolerance =
-        backwardSeek ||
-        bufferEnd > end - maxFragLookUpTolerance ||
-        this.media?.paused
-          ? 0
-          : maxFragLookUpTolerance;
+        bufferEnd > end - maxFragLookUpTolerance ? 0 : maxFragLookUpTolerance;
       // Remove the tolerance if it would put the bufferEnd past the actual end of stream
       // Uses buffer and sequence number to calculate switch segment (required if using EXT-X-DISCONTINUITY-SEQUENCE)
       frag = findFragmentByPTS(
@@ -1594,7 +1455,7 @@ export default class BaseStreamController
       if (startTimeOffset !== null && Number.isFinite(startTimeOffset)) {
         startPosition = sliding + startTimeOffset;
         if (startTimeOffset < 0) {
-          startPosition += details.edge;
+          startPosition += details.totalduration;
         }
         startPosition = Math.min(
           Math.max(sliding, startPosition),
@@ -1675,7 +1536,7 @@ export default class BaseStreamController
     }
     const gapTagEncountered = data.details === ErrorDetails.FRAG_GAP;
     if (gapTagEncountered) {
-      this.fragmentTracker.fragBuffered(frag as MediaFragment, true);
+      this.fragmentTracker.fragBuffered(frag, true);
     }
     // keep retrying until the limit will be reached
     const errorAction = data.errorAction;
@@ -1708,7 +1569,7 @@ export default class BaseStreamController
           errorAction.resolved = true;
         }
       } else {
-        this.warn(
+        logger.warn(
           `${data.details} reached or exceeded max retry (${retryCount})`,
         );
         return;
@@ -1798,9 +1659,7 @@ export default class BaseStreamController
     this.log('Reset loading state');
     this.fragCurrent = null;
     this.fragPrevious = null;
-    if (this.state !== State.STOPPED) {
-      this.state = State.IDLE;
-    }
+    this.state = State.IDLE;
   }
 
   protected resetStartWhenNotLoaded(level: Level | null): void {
@@ -1840,7 +1699,7 @@ export default class BaseStreamController
   }
 
   private updateLevelTiming(
-    frag: MediaFragment,
+    frag: Fragment,
     part: Part | null,
     level: Level,
     partial: boolean,
@@ -1916,35 +1775,20 @@ export default class BaseStreamController
       // For this error fallthrough. Marking parsed will allow advancing to next fragment.
     }
     this.state = State.PARSED;
-    this.log(
-      `Parsed ${frag.type} sn: ${frag.sn}${
-        part ? ' part: ' + part.index : ''
-      } of ${this.fragInfo(frag)})`,
-    );
     this.hls.trigger(Events.FRAG_PARSED, { frag, part });
   }
 
-  private playlistLabel() {
-    return this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track';
-  }
-
-  private fragInfo(frag: Fragment, pts: boolean = true): string {
-    return `${this.playlistLabel()} ${frag.level} (frag:[${((pts ? frag.startPTS : frag.start) ?? NaN).toFixed(3)}-${(
-      (pts ? frag.endPTS : frag.end) ?? NaN
-    ).toFixed(3)}]`;
-  }
-
   protected resetTransmuxer() {
-    this.transmuxer?.reset();
+    if (this.transmuxer) {
+      this.transmuxer.destroy();
+      this.transmuxer = null;
+    }
   }
 
   protected recoverWorkerError(data: ErrorData) {
     if (data.event === 'demuxerWorker') {
       this.fragmentTracker.removeAllFragments();
-      if (this.transmuxer) {
-        this.transmuxer.destroy();
-        this.transmuxer = null;
-      }
+      this.resetTransmuxer();
       this.resetStartWhenNotLoaded(this.levelLastLoaded);
       this.resetLoadingState();
     }