hls.js 1.5.12-0.canary.10366 → 1.5.12-0.canary.10367

package/dist/hls.light.mjs

@@ -420,7 +420,7 @@ function enableLogs(debugConfig, context, id) {
     // Some browsers don't allow to use bind on console object anyway
     // fallback to default if needed
     try {
-      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.5.12-0.canary.10366"}`);
+      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.5.12-0.canary.10367"}`);
     } catch (e) {
       /* log fn threw an exception. All logger methods are no-ops. */
       return createLogger();
@@ -3535,10 +3535,9 @@ class PlaylistLoader {
       type
     } = context;
     const url = getResponseUrl(response, context);
-    const levelUrlId = 0;
     const levelId = isFiniteNumber(level) ? level : isFiniteNumber(id) ? id : 0;
     const levelType = mapContextToLevelType(context);
-    const levelDetails = M3U8Parser.parseLevelPlaylist(response.data, url, levelId, levelType, levelUrlId, this.variableList);
+    const levelDetails = M3U8Parser.parseLevelPlaylist(response.data, url, levelId, levelType, 0, this.variableList);
 
     // We have done our first request (Manifest-type) and receive
     // not a master playlist but a chunk-list (track/level)
@@ -5284,8 +5283,7 @@ function computeReloadInterval(newDetails, distanceToLiveEdgeMs = Infinity) {
   }
   return Math.round(reloadInterval);
 }
-function getFragmentWithSN(level, sn, fragCurrent) {
-  const details = level == null ? void 0 : level.details;
+function getFragmentWithSN(details, sn, fragCurrent) {
   if (!details) {
     return null;
   }
@@ -5302,12 +5300,11 @@ function getFragmentWithSN(level, sn, fragCurrent) {
   }
   return null;
 }
-function getPartWith(level, sn, partIndex) {
-  var _level$details;
-  if (!(level != null && level.details)) {
+function getPartWith(details, sn, partIndex) {
+  if (!details) {
     return null;
   }
-  return findPart((_level$details = level.details) == null ? void 0 : _level$details.partList, sn, partIndex);
+  return findPart(details.partList, sn, partIndex);
 }
 function findPart(partList, sn, partIndex) {
   if (partList) {
@@ -5451,12 +5448,15 @@ function findFragmentByPDT(fragments, PDTValue, maxFragLookUpTolerance) {
 function findFragmentByPTS(fragPrevious, fragments, bufferEnd = 0, maxFragLookUpTolerance = 0, nextFragLookupTolerance = 0.005) {
   let fragNext = null;
   if (fragPrevious) {
-    fragNext = fragments[fragPrevious.sn - fragments[0].sn + 1] || null;
+    fragNext = fragments[1 + fragPrevious.sn - fragments[0].sn] || null;
     // check for buffer-end rounding error
     const bufferEdgeError = fragPrevious.endDTS - bufferEnd;
     if (bufferEdgeError > 0 && bufferEdgeError < 0.0000015) {
       bufferEnd += 0.0000015;
     }
+    if (fragNext && fragPrevious.level !== fragNext.level && fragNext.end <= fragPrevious.end) {
+      fragNext = fragments[2 + fragPrevious.sn - fragments[0].sn] || null;
+    }
   } else if (bufferEnd === 0 && fragments[0].start === 0) {
     fragNext = fragments[0];
   }
@@ -5608,7 +5608,7 @@ class ErrorController extends Logger {
     this.playlistError = 0;
   }
   onError(event, data) {
-    var _data$frag, _data$level;
+    var _data$frag;
     if (data.fatal) {
       return;
     }
@@ -5624,10 +5624,7 @@ class ErrorController extends Logger {
       case ErrorDetails.FRAG_PARSING_ERROR:
         // ignore empty segment errors marked as gap
         if ((_data$frag = data.frag) != null && _data$frag.gap) {
-          data.errorAction = {
-            action: NetworkErrorAction.DoNothing,
-            flags: ErrorActionFlags.None
-          };
+          data.errorAction = createDoNothingErrorAction();
           return;
         }
       // falls through
@@ -5694,7 +5691,11 @@ class ErrorController extends Logger {
       case ErrorDetails.BUFFER_ADD_CODEC_ERROR:
       case ErrorDetails.REMUX_ALLOC_ERROR:
       case ErrorDetails.BUFFER_APPEND_ERROR:
-        data.errorAction = this.getLevelSwitchAction(data, (_data$level = data.level) != null ? _data$level : hls.loadLevel);
+        // Buffer-controller can set errorAction when append errors can be ignored or resolved locally
+        if (!data.errorAction) {
+          var _data$level;
+          data.errorAction = this.getLevelSwitchAction(data, (_data$level = data.level) != null ? _data$level : hls.loadLevel);
+        }
         return;
       case ErrorDetails.INTERNAL_EXCEPTION:
       case ErrorDetails.BUFFER_APPENDING_ERROR:
@@ -5703,10 +5704,7 @@ class ErrorController extends Logger {
       case ErrorDetails.BUFFER_STALLED_ERROR:
       case ErrorDetails.BUFFER_SEEK_OVER_HOLE:
       case ErrorDetails.BUFFER_NUDGE_ON_STALL:
-        data.errorAction = {
-          action: NetworkErrorAction.DoNothing,
-          flags: ErrorActionFlags.None
-        };
+        data.errorAction = createDoNothingErrorAction();
         return;
     }
     if (data.type === ErrorTypes.KEY_SYSTEM_ERROR) {
@@ -5919,6 +5917,13 @@ class ErrorController extends Logger {
     }
   }
 }
+function createDoNothingErrorAction(resolved) {
+  const errorAction = {
+    action: NetworkErrorAction.DoNothing,
+    flags: ErrorActionFlags.None
+  };
+  return errorAction;
+}
 
 class BasePlaylistController extends Logger {
   constructor(hls, logPrefix) {
@@ -6371,6 +6376,7 @@ function getStartCodecTier(codecTiers, currentVideoRange, currentBw, audioPrefer
   if (!hasCurrentVideoRange) {
     currentVideoRange = undefined;
   }
+  const hasMultipleSets = codecSets.length > 1;
   const codecSet = codecSets.reduce((selected, candidate) => {
     // Remove candiates which do not meet bitrate, default audio, stereo or channels preference, 1080p or lower, 30fps or lower, or SDR/HDR selection if present
     const candidateTier = codecTiers[candidate];
@@ -6378,46 +6384,48 @@ function getStartCodecTier(codecTiers, currentVideoRange, currentBw, audioPrefer
       return selected;
     }
     videoRanges = hasCurrentVideoRange ? allowedVideoRanges.filter(range => candidateTier.videoRanges[range] > 0) : [];
-    if (candidateTier.minBitrate > currentBw) {
-      logStartCodecCandidateIgnored(candidate, `min bitrate of ${candidateTier.minBitrate} > current estimate of ${currentBw}`);
-      return selected;
-    }
-    if (!candidateTier.hasDefaultAudio) {
-      logStartCodecCandidateIgnored(candidate, `no renditions with default or auto-select sound found`);
-      return selected;
-    }
-    if (audioCodecPreference && candidate.indexOf(audioCodecPreference.substring(0, 4)) % 5 !== 0) {
-      logStartCodecCandidateIgnored(candidate, `audio codec preference "${audioCodecPreference}" not found`);
-      return selected;
-    }
-    if (channelsPreference && !preferStereo) {
-      if (!candidateTier.channels[channelsPreference]) {
-        logStartCodecCandidateIgnored(candidate, `no renditions with ${channelsPreference} channel sound found (channels options: ${Object.keys(candidateTier.channels)})`);
+    if (hasMultipleSets) {
+      if (candidateTier.minBitrate > currentBw) {
+        logStartCodecCandidateIgnored(candidate, `min bitrate of ${candidateTier.minBitrate} > current estimate of ${currentBw}`);
+        return selected;
+      }
+      if (!candidateTier.hasDefaultAudio) {
+        logStartCodecCandidateIgnored(candidate, `no renditions with default or auto-select sound found`);
+        return selected;
+      }
+      if (audioCodecPreference && candidate.indexOf(audioCodecPreference.substring(0, 4)) % 5 !== 0) {
+        logStartCodecCandidateIgnored(candidate, `audio codec preference "${audioCodecPreference}" not found`);
+        return selected;
+      }
+      if (channelsPreference && !preferStereo) {
+        if (!candidateTier.channels[channelsPreference]) {
+          logStartCodecCandidateIgnored(candidate, `no renditions with ${channelsPreference} channel sound found (channels options: ${Object.keys(candidateTier.channels)})`);
+          return selected;
+        }
+      } else if ((!audioCodecPreference || preferStereo) && hasStereo && candidateTier.channels['2'] === 0) {
+        logStartCodecCandidateIgnored(candidate, `no renditions with stereo sound found`);
+        return selected;
+      }
+      if (candidateTier.minHeight > maxHeight) {
+        logStartCodecCandidateIgnored(candidate, `min resolution of ${candidateTier.minHeight} > maximum of ${maxHeight}`);
+        return selected;
+      }
+      if (candidateTier.minFramerate > maxFramerate) {
+        logStartCodecCandidateIgnored(candidate, `min framerate of ${candidateTier.minFramerate} > maximum of ${maxFramerate}`);
+        return selected;
+      }
+      if (!videoRanges.some(range => candidateTier.videoRanges[range] > 0)) {
+        logStartCodecCandidateIgnored(candidate, `no variants with VIDEO-RANGE of ${JSON.stringify(videoRanges)} found`);
+        return selected;
+      }
+      if (videoCodecPreference && candidate.indexOf(videoCodecPreference.substring(0, 4)) % 5 !== 0) {
+        logStartCodecCandidateIgnored(candidate, `video codec preference "${videoCodecPreference}" not found`);
+        return selected;
+      }
+      if (candidateTier.maxScore < selectedScore) {
+        logStartCodecCandidateIgnored(candidate, `max score of ${candidateTier.maxScore} < selected max of ${selectedScore}`);
         return selected;
       }
-    } else if ((!audioCodecPreference || preferStereo) && hasStereo && candidateTier.channels['2'] === 0) {
-      logStartCodecCandidateIgnored(candidate, `no renditions with stereo sound found`);
-      return selected;
-    }
-    if (candidateTier.minHeight > maxHeight) {
-      logStartCodecCandidateIgnored(candidate, `min resolution of ${candidateTier.minHeight} > maximum of ${maxHeight}`);
-      return selected;
-    }
-    if (candidateTier.minFramerate > maxFramerate) {
-      logStartCodecCandidateIgnored(candidate, `min framerate of ${candidateTier.minFramerate} > maximum of ${maxFramerate}`);
-      return selected;
-    }
-    if (!videoRanges.some(range => candidateTier.videoRanges[range] > 0)) {
-      logStartCodecCandidateIgnored(candidate, `no variants with VIDEO-RANGE of ${JSON.stringify(videoRanges)} found`);
-      return selected;
-    }
-    if (videoCodecPreference && candidate.indexOf(videoCodecPreference.substring(0, 4)) % 5 !== 0) {
-      logStartCodecCandidateIgnored(candidate, `video codec preference "${videoCodecPreference}" not found`);
-      return selected;
-    }
-    if (candidateTier.maxScore < selectedScore) {
-      logStartCodecCandidateIgnored(candidate, `max score of ${candidateTier.maxScore} < selected max of ${selectedScore}`);
-      return selected;
     }
     // Remove candiates with less preferred codecs or more errors
     if (selected && (codecsSetSelectionPreferenceValue(candidate) >= codecsSetSelectionPreferenceValue(selected) || candidateTier.fragmentError > codecTiers[selected].fragmentError)) {
@@ -7095,7 +7103,7 @@ class AbrController extends Logger {
           if (levelsSkipped.length) {
             this.trace(`Skipped level(s) ${levelsSkipped.join(',')} of ${maxAutoLevel} max with CODECS and VIDEO-RANGE:"${levels[levelsSkipped[0]].codecs}" ${levels[levelsSkipped[0]].videoRange}; not compatible with "${level.codecs}" ${currentVideoRange}`);
           }
-          this.info(`switch candidate:${selectionBaseLevel}->${i} adjustedbw(${Math.round(adjustedbw)})-bitrate=${Math.round(adjustedbw - bitrate)} ttfb:${ttfbEstimateSec.toFixed(1)} avgDuration:${avgDuration.toFixed(1)} maxFetchDuration:${maxFetchDuration.toFixed(1)} fetchDuration:${fetchDuration.toFixed(1)} firstSelection:${firstSelection} codecSet:${level.codecSet} videoRange:${level.videoRange} hls.loadLevel:${loadLevel}`);
+          this.info(`switch candidate:${selectionBaseLevel}->${i} adjustedbw(${Math.round(adjustedbw)})-bitrate=${Math.round(adjustedbw - bitrate)} ttfb:${ttfbEstimateSec.toFixed(1)} avgDuration:${avgDuration.toFixed(1)} maxFetchDuration:${maxFetchDuration.toFixed(1)} fetchDuration:${fetchDuration.toFixed(1)} firstSelection:${firstSelection} codecSet:${levelInfo.codecSet} videoRange:${levelInfo.videoRange} hls.loadLevel:${loadLevel}`);
         }
         if (firstSelection) {
           this.firstSelection = i;
@@ -7437,6 +7445,7 @@ class BufferController extends Logger {
     hls.on(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
     hls.on(Events.FRAG_PARSED, this.onFragParsed, this);
     hls.on(Events.FRAG_CHANGED, this.onFragChanged, this);
+    hls.on(Events.ERROR, this.onError, this);
   }
   unregisterListeners() {
     const {
@@ -7454,6 +7463,7 @@ class BufferController extends Logger {
     hls.off(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
     hls.off(Events.FRAG_PARSED, this.onFragParsed, this);
     hls.off(Events.FRAG_CHANGED, this.onFragChanged, this);
+    hls.off(Events.ERROR, this.onError, this);
   }
   _initSourceBuffer() {
     this.sourceBuffer = {};
@@ -7463,11 +7473,7 @@ class BufferController extends Logger {
       video: [],
       audiovideo: []
     };
-    this.appendErrors = {
-      audio: 0,
-      video: 0,
-      audiovideo: 0
-    };
+    this.resetAppendErrors();
     this.lastMpegAudioChunk = null;
     this.blockedAudioAppend = null;
     this.lastVideoAppendEnd = 0;
@@ -8004,6 +8010,22 @@ class BufferController extends Logger {
       this.updateMediaSource(durationAndRange);
     }
   }
+  onError(event, data) {
+    if (data.details === ErrorDetails.BUFFER_APPEND_ERROR && data.frag) {
+      var _data$errorAction;
+      const nextAutoLevel = (_data$errorAction = data.errorAction) == null ? void 0 : _data$errorAction.nextAutoLevel;
+      if (isFiniteNumber(nextAutoLevel) && nextAutoLevel !== data.frag.level) {
+        this.resetAppendErrors();
+      }
+    }
+  }
+  resetAppendErrors() {
+    this.appendErrors = {
+      audio: 0,
+      video: 0,
+      audiovideo: 0
+    };
+  }
   trimBuffers() {
     const {
       hls,
@@ -10672,6 +10694,7 @@ class FragmentTracker {
     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);
@@ -10680,6 +10703,7 @@ class FragmentTracker {
     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);
@@ -10745,7 +10769,7 @@ class FragmentTracker {
    * The browser will unload parts of the buffer to free up memory for new buffer data
    * Fragments will need to be reloaded when the buffer is freed up, removing partial fragments will allow them to reload(since there might be parts that are still playable)
    */
-  detectEvictedFragments(elementaryStream, timeRange, playlistType, appendedPart) {
+  detectEvictedFragments(elementaryStream, timeRange, playlistType, appendedPart, removeAppending) {
     if (this.timeRanges) {
       this.timeRanges[elementaryStream] = timeRange;
     }
@@ -10760,7 +10784,7 @@ class FragmentTracker {
       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);
         }
@@ -10770,6 +10794,10 @@ class FragmentTracker {
       if (!esData) {
         return;
       }
+      if (esData.time.length === 0) {
+        this.removeFragment(fragmentEntity.body);
+        return;
+      }
       esData.time.some(time => {
         const isNotBuffered = !this.isTimeBuffered(time.startPTS, time.endPTS, timeRange);
         if (isNotBuffered) {
@@ -10956,6 +10984,9 @@ class FragmentTracker {
     }
     return false;
   }
+  onManifestLoading() {
+    this.removeAllFragments();
+  }
   onFragLoaded(event, data) {
     // don't track initsegment (for which sn is not a number)
     // don't track frags used for bitrateTest, they're irrelevant.
@@ -11004,6 +11035,22 @@ class FragmentTracker {
     const fragKey = getFragmentKey(fragment);
     return !!this.fragments[fragKey];
   }
+  hasFragments(type) {
+    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 == null ? void 0 : fragmentEntity.body.type) === type) {
+        return true;
+      }
+    }
+    return false;
+  }
   hasParts(type) {
     var _this$activePartLists;
     return !!((_this$activePartLists = this.activePartLists[type]) != null && _this$activePartLists.length);
@@ -11105,8 +11152,9 @@ class FragmentLoader {
           frag.gap = false;
         }
       }
-      const loader = this.loader = frag.loader = FragmentILoader ? new FragmentILoader(config) : new DefaultILoader(config);
+      const loader = this.loader = FragmentILoader ? new FragmentILoader(config) : new DefaultILoader(config);
       const loaderContext = createLoaderContext(frag);
+      frag.loader = loader;
       const loadPolicy = getLoaderConfigWithoutReties(config.fragLoadPolicy.default);
       const loaderConfig = {
         loadPolicy,
@@ -11199,8 +11247,9 @@ class FragmentLoader {
         reject(createGapLoadError(frag, part));
         return;
       }
-      const loader = this.loader = frag.loader = FragmentILoader ? new FragmentILoader(config) : new DefaultILoader(config);
+      const loader = this.loader = FragmentILoader ? new FragmentILoader(config) : new DefaultILoader(config);
       const loaderContext = createLoaderContext(frag, part);
+      frag.loader = loader;
       // Should we define another load policy for parts?
       const loadPolicy = getLoaderConfigWithoutReties(config.fragLoadPolicy.default);
       const loaderConfig = {
@@ -12438,6 +12487,7 @@ class BaseStreamController extends TaskLoop {
     this.initPTS = [];
     this.buffering = true;
     this.loadingParts = false;
+    this.loopSn = void 0;
     this.onMediaSeeking = () => {
       const {
         config,
@@ -12537,6 +12587,9 @@ class BaseStreamController extends TaskLoop {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   startLoad(startPosition) {}
   stopLoad() {
+    if (this.state === State.STOPPED) {
+      return;
+    }
     this.fragmentLoader.abort();
     this.keyLoader.abort(this.playlistType);
     const frag = this.fragCurrent;
@@ -12610,15 +12663,20 @@ class BaseStreamController extends TaskLoop {
       this.keyLoader.detach();
     }
     this.media = this.mediaBuffer = null;
-    this.loadedmetadata = false;
+    this.loopSn = undefined;
+    this.startFragRequested = this.loadedmetadata = this.loadingParts = false;
     this.fragmentTracker.removeAllFragments();
     this.stopLoad();
   }
-  onManifestLoading() {}
+  onManifestLoading() {
+    this.initPTS = [];
+    this.levels = this.levelLastLoaded = this.fragCurrent = null;
+    this.lastCurrentTime = this.startPosition = 0;
+    this.startFragRequested = false;
+  }
   onError(event, data) {}
   onManifestLoaded(event, data) {
     this.startTimeOffset = data.startTimeOffset;
-    this.initPTS = [];
   }
   onHandlerDestroying() {
     this.stopLoad();
@@ -12641,6 +12699,7 @@ class BaseStreamController extends TaskLoop {
     super.onHandlerDestroyed();
   }
   loadFragment(frag, level, targetBufferTime) {
+    this.startFragRequested = true;
     this._loadFragForPlayback(frag, level, targetBufferTime);
   }
   _loadFragForPlayback(frag, level, targetBufferTime) {
@@ -12869,6 +12928,7 @@ class BaseStreamController extends TaskLoop {
   _handleFragmentLoadProgress(frag) {}
   _doFragLoad(frag, level, targetBufferTime = null, progressCallback) {
     var _frag$decryptdata;
+    this.fragCurrent = frag;
     const details = level == null ? void 0 : level.details;
     if (!this.levels || !details) {
       throw new Error(`frag load aborted, missing level${details ? '' : ' detail'}s`);
@@ -12996,7 +13056,7 @@ class BaseStreamController extends TaskLoop {
           partsLoaded[part.index] = partLoadedData;
           const loadedPart = partLoadedData.part;
           this.hls.trigger(Events.FRAG_LOADED, partLoadedData);
-          const nextPart = getPartWith(level, frag.sn, part.index + 1) || findPart(initialPartList, frag.sn, part.index + 1);
+          const nextPart = getPartWith(level.details, frag.sn, part.index + 1) || findPart(initialPartList, frag.sn, part.index + 1);
           if (nextPart) {
             loadPart(nextPart);
           } else {
@@ -13091,8 +13151,9 @@ class BaseStreamController extends TaskLoop {
       return null;
     }
     const level = levels[levelIndex];
-    const part = partIndex > -1 ? getPartWith(level, sn, partIndex) : null;
-    const frag = part ? part.fragment : getFragmentWithSN(level, sn, fragCurrent);
+    const levelDetails = level.details;
+    const part = partIndex > -1 ? getPartWith(levelDetails, sn, partIndex) : null;
+    const frag = part ? part.fragment : getFragmentWithSN(levelDetails, sn, fragCurrent);
     if (!frag) {
       return null;
     }
@@ -13207,7 +13268,8 @@ class BaseStreamController extends TaskLoop {
     return false;
   }
   getAppendedFrag(position, playlistType = PlaylistLevelType.MAIN) {
-    const fragOrPart = this.fragmentTracker.getAppendedFrag(position, PlaylistLevelType.MAIN);
+    var _this$fragmentTracker;
+    const fragOrPart = (_this$fragmentTracker = this.fragmentTracker) == null ? void 0 : _this$fragmentTracker.getAppendedFrag(position, playlistType);
     if (fragOrPart && 'fragment' in fragOrPart) {
       return fragOrPart.fragment;
     }
@@ -13262,22 +13324,25 @@ class BaseStreamController extends TaskLoop {
     return (trackerState === FragmentState.OK || trackerState === FragmentState.PARTIAL && !!frag.gap) && this.nextLoadPosition > targetBufferTime;
   }
   getNextFragmentLoopLoading(frag, levelDetails, bufferInfo, playlistType, maxBufLen) {
-    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}`);
-        return null;
+    let nextFragment = 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);
+        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 frag;
+    this.loopSn = undefined;
+    return nextFragment;
   }
   mapToInitFragWhenRequired(frag) {
     // If an initSegment is present, it must be buffered first
@@ -13486,7 +13551,7 @@ class BaseStreamController extends TaskLoop {
       if (startTimeOffset !== null && isFiniteNumber(startTimeOffset)) {
         startPosition = sliding + startTimeOffset;
         if (startTimeOffset < 0) {
-          startPosition += details.totalduration;
+          startPosition += details.edge;
         }
         startPosition = Math.min(Math.max(sliding, startPosition), sliding + details.totalduration);
         this.log(`Start time offset ${startTimeOffset} found in ${offsetInMultivariantPlaylist ? 'multivariant' : 'media'} playlist, adjust startPosition to ${startPosition}`);
@@ -17053,10 +17118,11 @@ class MP4Remuxer {
       if (this.ISGenerated) {
         var _videoTrack$pixelRati, _config$pixelRatio, _videoTrack$pixelRati2, _config$pixelRatio2;
         const config = this.videoTrackConfig;
-        if (config && (videoTrack.width !== config.width || videoTrack.height !== config.height || ((_videoTrack$pixelRati = videoTrack.pixelRatio) == null ? void 0 : _videoTrack$pixelRati[0]) !== ((_config$pixelRatio = config.pixelRatio) == null ? void 0 : _config$pixelRatio[0]) || ((_videoTrack$pixelRati2 = videoTrack.pixelRatio) == null ? void 0 : _videoTrack$pixelRati2[1]) !== ((_config$pixelRatio2 = config.pixelRatio) == null ? void 0 : _config$pixelRatio2[1]))) {
+        if (config && (videoTrack.width !== config.width || videoTrack.height !== config.height || ((_videoTrack$pixelRati = videoTrack.pixelRatio) == null ? void 0 : _videoTrack$pixelRati[0]) !== ((_config$pixelRatio = config.pixelRatio) == null ? void 0 : _config$pixelRatio[0]) || ((_videoTrack$pixelRati2 = videoTrack.pixelRatio) == null ? void 0 : _videoTrack$pixelRati2[1]) !== ((_config$pixelRatio2 = config.pixelRatio) == null ? void 0 : _config$pixelRatio2[1])) || !config && enoughVideoSamples || this.nextAudioPts === null && enoughAudioSamples) {
           this.resetInitSegment();
         }
-      } else {
+      }
+      if (!this.ISGenerated) {
         initSegment = this.generateIS(audioTrack, videoTrack, timeOffset, accurateTimeOffset);
       }
       const isVideoContiguous = this.isVideoContiguous;
@@ -17974,7 +18040,7 @@ class PassThroughRemuxer {
     if (isInvalidInitPts(initPTS, decodeTime, timeOffset, duration) || initSegment.timescale !== initPTS.timescale && accurateTimeOffset) {
       initSegment.initPTS = decodeTime - timeOffset;
       if (initPTS && initPTS.timescale === 1) {
-        logger.warn(`Adjusting initPTS by ${initSegment.initPTS - initPTS.baseTime}`);
+        logger.warn(`Adjusting initPTS @${timeOffset} from ${initPTS.baseTime / initPTS.timescale} to ${initSegment.initPTS}`);
       }
       this.initPTS = initPTS = {
         baseTime: initSegment.initPTS,
@@ -19693,7 +19759,6 @@ class StreamController extends BaseStreamController {
   loadFragment(frag, level, targetBufferTime) {
     // Check if fragment is not loaded
     const fragState = this.fragmentTracker.getState(frag);
-    this.fragCurrent = frag;
     if (fragState === FragmentState.NOT_LOADED || fragState === FragmentState.PARTIAL) {
       if (frag.sn === 'initSegment') {
         this._loadInitSegment(frag, level);
@@ -19701,7 +19766,6 @@ class StreamController extends BaseStreamController {
         this.log(`Fragment ${frag.sn} of level ${frag.level} is being downloaded to test bitrate and will not be buffered`);
         this._loadBitrateTestFrag(frag, level);
       } else {
-        this.startFragRequested = true;
         super.loadFragment(frag, level, targetBufferTime);
       }
     } else {
@@ -19835,14 +19899,14 @@ class StreamController extends BaseStreamController {
     super.onMediaDetaching();
   }
   onManifestLoading() {
+    super.onManifestLoading();
     // reset buffer on manifest loading
     this.log('Trigger BUFFER_RESET');
     this.hls.trigger(Events.BUFFER_RESET, undefined);
-    this.fragmentTracker.removeAllFragments();
     this.couldBacktrack = false;
-    this.startPosition = this.lastCurrentTime = this.fragLastKbps = 0;
-    this.levels = this.fragPlaying = this.backtrackFragment = this.levelLastLoaded = null;
-    this.altAudio = this.audioOnly = this.startFragRequested = false;
+    this.fragLastKbps = 0;
+    this.fragPlaying = this.backtrackFragment = null;
+    this.altAudio = this.audioOnly = false;
   }
   onManifestParsed(event, data) {
     // detect if we have different kind of audio codecs used amongst playlists
@@ -20138,7 +20202,7 @@ class StreamController extends BaseStreamController {
     // in that case, reset startFragRequested flag
     if (!this.loadedmetadata) {
       this.startFragRequested = false;
-      this.nextLoadPosition = this.startPosition;
+      this.nextLoadPosition = this.lastCurrentTime;
     }
     this.tickImmediate();
   }
@@ -20226,7 +20290,7 @@ class StreamController extends BaseStreamController {
   }
   _handleTransmuxComplete(transmuxResult) {
     var _id3$samples;
-    const id = 'main';
+    const id = this.playlistType;
     const {
       hls
     } = this;
@@ -20431,31 +20495,38 @@ class StreamController extends BaseStreamController {
       audio.levelCodec = audioCodec;
       audio.id = 'main';
       this.log(`Init audio buffer, container:${audio.container}, codecs[selected/level/parsed]=[${audioCodec || ''}/${currentLevel.audioCodec || ''}/${audio.codec}]`);
+      delete tracks.audiovideo;
     }
     if (video) {
       video.levelCodec = currentLevel.videoCodec;
       video.id = 'main';
       this.log(`Init video buffer, container:${video.container}, codecs[level/parsed]=[${currentLevel.videoCodec || ''}/${video.codec}]`);
+      delete tracks.audiovideo;
     }
     if (audiovideo) {
       this.log(`Init audiovideo buffer, container:${audiovideo.container}, codecs[level/parsed]=[${currentLevel.codecs}/${audiovideo.codec}]`);
+      delete tracks.video;
+      delete tracks.audio;
+    }
+    const trackTypes = Object.keys(tracks);
+    if (trackTypes.length) {
+      this.hls.trigger(Events.BUFFER_CODECS, tracks);
+      // loop through tracks that are going to be provided to bufferController
+      trackTypes.forEach(trackName => {
+        const track = tracks[trackName];
+        const initSegment = track.initSegment;
+        if (initSegment != null && initSegment.byteLength) {
+          this.hls.trigger(Events.BUFFER_APPENDING, {
+            type: trackName,
+            data: initSegment,
+            frag,
+            part: null,
+            chunkMeta,
+            parent: frag.type
+          });
+        }
+      });
     }
-    this.hls.trigger(Events.BUFFER_CODECS, tracks);
-    // loop through tracks that are going to be provided to bufferController
-    Object.keys(tracks).forEach(trackName => {
-      const track = tracks[trackName];
-      const initSegment = track.initSegment;
-      if (initSegment != null && initSegment.byteLength) {
-        this.hls.trigger(Events.BUFFER_APPENDING, {
-          type: trackName,
-          data: initSegment,
-          frag,
-          part: null,
-          chunkMeta,
-          parent: frag.type
-        });
-      }
-    });
     // trigger handler right now
     this.tickImmediate();
   }
@@ -20532,20 +20603,28 @@ class StreamController extends BaseStreamController {
     return -1;
   }
   get currentFrag() {
-    const media = this.media;
-    if (media) {
-      return this.fragPlaying || this.getAppendedFrag(media.currentTime);
+    var _this$media2;
+    if (this.fragPlaying) {
+      return this.fragPlaying;
+    }
+    const currentTime = ((_this$media2 = this.media) == null ? void 0 : _this$media2.currentTime) || this.lastCurrentTime;
+    if (isFiniteNumber(currentTime)) {
+      return this.getAppendedFrag(currentTime);
     }
     return null;
   }
   get currentProgramDateTime() {
-    const media = this.media;
-    if (media) {
-      const currentTime = media.currentTime;
-      const frag = this.currentFrag;
-      if (frag && isFiniteNumber(currentTime) && isFiniteNumber(frag.programDateTime)) {
-        const epocMs = frag.programDateTime + (currentTime - frag.start) * 1000;
-        return new Date(epocMs);
+    var _this$media3;
+    const currentTime = ((_this$media3 = this.media) == null ? void 0 : _this$media3.currentTime) || this.lastCurrentTime;
+    if (isFiniteNumber(currentTime)) {
+      const details = this.getLevelDetails();
+      const frag = this.currentFrag || (details ? findFragmentByPTS(null, details.fragments, currentTime) : null);
+      if (frag) {
+        const programDateTime = frag.programDateTime;
+        if (programDateTime !== null) {
+          const epocMs = programDateTime + (currentTime - frag.start) * 1000;
+          return new Date(epocMs);
+        }
       }
     }
     return null;
@@ -20578,7 +20657,7 @@ class Hls {
    * Get the video-dev/hls.js package version.
    */
   static get version() {
-    return "1.5.12-0.canary.10366";
+    return "1.5.12-0.canary.10367";
   }
 
   /**
@@ -20709,7 +20788,7 @@ class Hls {
     if (AudioStreamControllerClass) {
       networkControllers.push(new AudioStreamControllerClass(this, fragmentTracker, keyLoader));
     }
-    // subtitleTrackController must be defined before subtitleStreamController because the order of event handling is important
+    // Instantiate subtitleTrackController before SubtitleStreamController to receive level events first
     this.subtitleTrackController = this.createController(config.subtitleTrackController, networkControllers);
     const SubtitleStreamControllerClass = config.subtitleStreamController;
     if (SubtitleStreamControllerClass) {