hls.js 1.5.7-0.canary.10014 → 1.5.7-0.canary.10016

package/dist/hls.mjs

@@ -512,7 +512,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.7-0.canary.10014"}`);
+      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.5.7-0.canary.10016"}`);
     } catch (e) {
       /* log fn threw an exception. All logger methods are no-ops. */
       return createLogger();
@@ -1941,7 +1941,9 @@ function parseStsd(stsd) {
 }
 function skipBERInteger(bytes, i) {
   const limit = i + 5;
-  while (bytes[i++] & 0x80 && i < limit) {}
+  while (bytes[i++] & 0x80 && i < limit) {
+    /* do nothing */
+  }
   return i;
 }
 function toHex(x) {
@@ -7290,6 +7292,9 @@ class AbrController extends Logger {
       partCurrent,
       hls
     } = this;
+    if (hls.levels.length <= 1) {
+      return hls.loadLevel;
+    }
     const {
       maxAutoLevel,
       config,
@@ -7700,13 +7705,16 @@ class FragmentTracker {
    * If not found any Fragment, return null
    */
   getBufferedFrag(position, levelType) {
+    return this.getFragAtPos(position, levelType, true);
+  }
+  getFragAtPos(position, levelType, buffered) {
     const {
       fragments
     } = this;
     const keys = Object.keys(fragments);
     for (let i = keys.length; i--;) {
       const fragmentEntity = fragments[keys[i]];
-      if ((fragmentEntity == null ? void 0 : fragmentEntity.body.type) === levelType && fragmentEntity.buffered) {
+      if ((fragmentEntity == null ? void 0 : fragmentEntity.body.type) === levelType && (!buffered || fragmentEntity.buffered)) {
         const frag = fragmentEntity.body;
         if (frag.start <= position && position <= frag.end) {
           return frag;
@@ -7961,7 +7969,8 @@ class FragmentTracker {
     const {
       frag,
       part,
-      timeRanges
+      timeRanges,
+      type
     } = data;
     if (frag.sn === 'initSegment') {
       return;
@@ -7976,10 +7985,8 @@ class FragmentTracker {
     }
     // Store the latest timeRanges loaded in the buffer
     this.timeRanges = timeRanges;
-    Object.keys(timeRanges).forEach(elementaryStream => {
-      const timeRange = timeRanges[elementaryStream];
-      this.detectEvictedFragments(elementaryStream, timeRange, playlistType, part);
-    });
+    const timeRange = timeRanges[type];
+    this.detectEvictedFragments(type, timeRange, playlistType, part);
   }
   onFragBuffered(event, data) {
     this.detectPartialFragments(data);
@@ -9934,7 +9941,7 @@ class BaseStreamController extends TaskLoop {
     // 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) {
+      if (bufferedFragAtPos && (bufferInfo.nextStart <= bufferedFragAtPos.end || bufferedFragAtPos.gap)) {
         return BufferHelper.bufferInfo(bufferable, pos, Math.max(bufferInfo.nextStart, maxBufferHole));
       }
     }
@@ -16790,9 +16797,8 @@ class AudioStreamController extends BaseStreamController {
       this.state = State.ENDED;
       return;
     }
-    const mainBufferInfo = this.getFwdBufferInfo(this.videoBuffer ? this.videoBuffer : this.media, PlaylistLevelType.MAIN);
     const bufferLen = bufferInfo.len;
-    const maxBufLen = this.getMaxBufferLength(mainBufferInfo == null ? void 0 : mainBufferInfo.len);
+    const maxBufLen = hls.maxBufferLength;
     const fragments = trackDetails.fragments;
     const start = fragments[0].start;
     let targetBufferTime = this.flushing ? this.getLoadPosition() : bufferInfo.end;
@@ -16827,32 +16833,25 @@ class AudioStreamController extends BaseStreamController {
       this.bufferFlushed = true;
       return;
     }
-
-    // Buffer audio up to one target duration ahead of main buffer
-    const atBufferSyncLimit = mainBufferInfo && frag.start > mainBufferInfo.end + trackDetails.targetduration;
-    if (atBufferSyncLimit ||
-    // Or wait for main buffer after buffing some audio
-    !(mainBufferInfo != null && mainBufferInfo.len) && bufferInfo.len) {
-      // 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 || (atGap = !!mainFrag.gap || !!atBufferSyncLimit && mainBufferInfo.len === 0);
-      if (atBufferSyncLimit && !atGap || atGap && bufferInfo.nextStart && bufferInfo.nextStart < mainFrag.end) {
-        return;
+    if (!trackDetails.live || targetBufferTime < this.hls.liveSyncPosition) {
+      // Request audio segments up to one fragment ahead of main buffer
+      const mainBufferInfo = this.getFwdBufferInfo(this.videoBuffer ? this.videoBuffer : this.media, PlaylistLevelType.MAIN);
+      const atBufferSyncLimit = !!mainBufferInfo && frag.start > mainBufferInfo.end + frag.duration;
+      if (atBufferSyncLimit) {
+        // Check fragment-tracker for main fragments since GAP segments do not show up in bufferInfo
+        const mainFrag = this.fragmentTracker.getFragAtPos(frag.start, PlaylistLevelType.MAIN);
+        if (mainFrag === null) {
+          return;
+        }
+        // Bridge gaps in main buffer (also prevents loop loading at gaps)
+        atGap || (atGap = !!mainFrag.gap || mainBufferInfo.len === 0);
+        if (!atGap || bufferInfo.nextStart && bufferInfo.nextStart < mainFrag.end) {
+          return;
+        }
       }
     }
     this.loadFragment(frag, levelInfo, targetBufferTime);
   }
-  getMaxBufferLength(mainBufferLength) {
-    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;
@@ -17946,9 +17945,8 @@ class SubtitleStreamController extends BaseStreamController {
         end: targetBufferTime,
         len: bufferLen
       } = bufferedInfo;
-      const mainBufferInfo = this.getFwdBufferInfo(this.media, PlaylistLevelType.MAIN);
       const trackDetails = track.details;
-      const maxBufLen = this.getMaxBufferLength(mainBufferInfo == null ? void 0 : mainBufferInfo.len) + trackDetails.levelTargetDuration;
+      const maxBufLen = this.hls.maxBufferLength + trackDetails.levelTargetDuration;
       if (bufferLen > maxBufLen) {
         return;
       }
@@ -17985,13 +17983,6 @@ class SubtitleStreamController extends BaseStreamController {
       }
     }
   }
-  getMaxBufferLength(mainBufferLength) {
-    const maxConfigBuffer = super.getMaxBufferLength();
-    if (!mainBufferLength) {
-      return maxConfigBuffer;
-    }
-    return Math.max(maxConfigBuffer, mainBufferLength);
-  }
   loadFragment(frag, level, targetBufferTime) {
     this.fragCurrent = frag;
     if (frag.sn === 'initSegment') {
@@ -18489,24 +18480,22 @@ class BufferOperationQueue {
       this.executeNext(type);
     }
   }
-  insertAbort(operation, type) {
-    const queue = this.queues[type];
-    queue.unshift(operation);
-    this.executeNext(type);
-  }
   appendBlocker(type) {
-    let execute;
-    const promise = new Promise(resolve => {
-      execute = resolve;
+    return new Promise(resolve => {
+      const operation = {
+        execute: resolve,
+        onStart: () => {},
+        onComplete: () => {},
+        onError: () => {}
+      };
+      this.append(operation, type);
     });
-    const operation = {
-      execute,
-      onStart: () => {},
-      onComplete: () => {},
-      onError: () => {}
-    };
-    this.append(operation, type);
-    return promise;
+  }
+  unblockAudio(op) {
+    const queue = this.queues.audio;
+    if (queue[0] === op) {
+      this.shiftAndExecuteNext('audio');
+    }
   }
   executeNext(type) {
     const queue = this.queues[type];
@@ -18539,7 +18528,7 @@ class BufferOperationQueue {
 
 const VIDEO_CODEC_PROFILE_REPLACE = /(avc[1234]|hvc1|hev1|dvh[1e]|vp09|av01)(?:\.[^.,]+)+/;
 class BufferController extends Logger {
-  constructor(hls) {
+  constructor(hls, fragmentTracker) {
     super('buffer-controller', hls.logger);
     // The level details used to determine duration, target-duration and live
     this.details = null;
@@ -18550,6 +18539,7 @@ class BufferController extends Logger {
     // References to event listeners for each SourceBuffer, so that they can be referenced for event removal
     this.listeners = void 0;
     this.hls = void 0;
+    this.fragmentTracker = void 0;
     // The number of BUFFER_CODEC events received before any sourceBuffers are created
     this.bufferCodecEventsExpected = 0;
     // The total number of BUFFER_CODEC events received
@@ -18560,6 +18550,10 @@ class BufferController extends Logger {
     this.mediaSource = null;
     // Last MP3 audio chunk appended
     this.lastMpegAudioChunk = null;
+    // Audio fragment blocked from appending until corresponding video appends or context changes
+    this.blockedAudioAppend = null;
+    // Keep track of video append position for unblocking audio
+    this.lastVideoAppendEnd = 0;
     this.appendSource = void 0;
     // counters
     this.appendErrors = {
@@ -18591,7 +18585,10 @@ class BufferController extends Logger {
       this.log('Media source opened');
       if (media) {
         media.removeEventListener('emptied', this._onMediaEmptied);
-        this.updateMediaElementDuration();
+        const durationAndRange = this.getDurationAndRange();
+        if (durationAndRange) {
+          this.updateMediaSource(durationAndRange);
+        }
         this.hls.trigger(Events.MEDIA_ATTACHED, {
           media,
           mediaSource: mediaSource
@@ -18619,6 +18616,7 @@ class BufferController extends Logger {
       }
     };
     this.hls = hls;
+    this.fragmentTracker = fragmentTracker;
     this.appendSource = hls.config.preferManagedMediaSource;
     this._initSourceBuffer();
     this.registerListeners();
@@ -18631,7 +18629,7 @@ class BufferController extends Logger {
     this.details = null;
     this.lastMpegAudioChunk = null;
     // @ts-ignore
-    this.hls = null;
+    this.hls = this.fragmentTracker = null;
     // @ts-ignore
     this._onMediaSourceOpen = this._onMediaSourceClose = null;
     // @ts-ignore
@@ -18687,6 +18685,8 @@ class BufferController extends Logger {
       audiovideo: 0
     };
     this.lastMpegAudioChunk = null;
+    this.blockedAudioAppend = null;
+    this.lastVideoAppendEnd = 0;
   }
   onManifestLoading() {
     this.bufferCodecEventsExpected = this._bufferCodecEventsTotal = 0;
@@ -18824,9 +18824,10 @@ class BufferController extends Logger {
     const trackNames = Object.keys(data);
     trackNames.forEach(trackName => {
       if (sourceBufferCount) {
+        var _track$buffer;
         // check if SourceBuffer codec needs to change
         const track = this.tracks[trackName];
-        if (track && typeof track.buffer.changeType === 'function') {
+        if (track && typeof ((_track$buffer = track.buffer) == null ? void 0 : _track$buffer.changeType) === 'function') {
           var _trackCodec;
           const {
             id,
@@ -18896,20 +18897,54 @@ class BufferController extends Logger {
     };
     operationQueue.append(operation, type, !!this.pendingTracks[type]);
   }
+  blockAudio(partOrFrag) {
+    var _this$fragmentTracker;
+    const pStart = partOrFrag.start;
+    const pTime = pStart + partOrFrag.duration * 0.05;
+    const atGap = ((_this$fragmentTracker = this.fragmentTracker.getAppendedFrag(pStart, PlaylistLevelType.MAIN)) == null ? void 0 : _this$fragmentTracker.gap) === true;
+    if (atGap) {
+      return;
+    }
+    const op = {
+      execute: () => {
+        var _this$fragmentTracker2;
+        if (this.lastVideoAppendEnd > pTime || this.sourceBuffer.video && BufferHelper.isBuffered(this.sourceBuffer.video, pTime) || ((_this$fragmentTracker2 = this.fragmentTracker.getAppendedFrag(pTime, PlaylistLevelType.MAIN)) == null ? void 0 : _this$fragmentTracker2.gap) === true) {
+          this.blockedAudioAppend = null;
+          this.operationQueue.shiftAndExecuteNext('audio');
+        }
+      },
+      onStart: () => {},
+      onComplete: () => {},
+      onError: () => {}
+    };
+    this.blockedAudioAppend = {
+      op,
+      frag: partOrFrag
+    };
+    this.operationQueue.append(op, 'audio', true);
+  }
+  unblockAudio() {
+    const blockedAudioAppend = this.blockedAudioAppend;
+    if (blockedAudioAppend) {
+      this.blockedAudioAppend = null;
+      this.operationQueue.unblockAudio(blockedAudioAppend.op);
+    }
+  }
   onBufferAppending(event, eventData) {
     const {
-      hls,
       operationQueue,
       tracks
     } = this;
     const {
       data,
       type,
+      parent,
       frag,
       part,
       chunkMeta
     } = eventData;
     const chunkStats = chunkMeta.buffering[type];
+    const sn = frag.sn;
     const bufferAppendingStart = self.performance.now();
     chunkStats.start = bufferAppendingStart;
     const fragBuffering = frag.stats.buffering;
@@ -18932,7 +18967,36 @@ class BufferController extends Logger {
       checkTimestampOffset = !this.lastMpegAudioChunk || chunkMeta.id === 1 || this.lastMpegAudioChunk.sn !== chunkMeta.sn;
       this.lastMpegAudioChunk = chunkMeta;
     }
-    const fragStart = frag.start;
+
+    // Block audio append until overlapping video append
+    const videoSb = this.sourceBuffer.video;
+    if (videoSb && sn !== 'initSegment') {
+      const partOrFrag = part || frag;
+      const blockedAudioAppend = this.blockedAudioAppend;
+      if (type === 'audio' && parent !== 'main' && !this.blockedAudioAppend) {
+        const pStart = partOrFrag.start;
+        const pTime = pStart + partOrFrag.duration * 0.05;
+        const vbuffered = videoSb.buffered;
+        const vappending = this.operationQueue.current('video');
+        if (!vbuffered.length && !vappending) {
+          // wait for video before appending audio
+          this.blockAudio(partOrFrag);
+        } else if (!vappending && !BufferHelper.isBuffered(videoSb, pTime) && this.lastVideoAppendEnd < pTime) {
+          // audio is ahead of video
+          this.blockAudio(partOrFrag);
+        }
+      } else if (type === 'video') {
+        const videoAppendEnd = partOrFrag.end;
+        if (blockedAudioAppend) {
+          const audioStart = blockedAudioAppend.frag.start;
+          if (videoAppendEnd > audioStart || videoAppendEnd < this.lastVideoAppendEnd || BufferHelper.isBuffered(videoSb, audioStart)) {
+            this.unblockAudio();
+          }
+        }
+        this.lastVideoAppendEnd = videoAppendEnd;
+      }
+    }
+    const fragStart = (part || frag).start;
     const operation = {
       execute: () => {
         chunkStats.executeStart = self.performance.now();
@@ -18941,7 +19005,7 @@ class BufferController extends Logger {
           if (sb) {
             const delta = fragStart - sb.timestampOffset;
             if (Math.abs(delta) >= 0.1) {
-              this.log(`Updating audio SourceBuffer timestampOffset to ${fragStart} (delta: ${delta}) sn: ${frag.sn})`);
+              this.log(`Updating audio SourceBuffer timestampOffset to ${fragStart} (delta: ${delta}) sn: ${sn})`);
               sb.timestampOffset = fragStart;
             }
           }
@@ -19008,22 +19072,21 @@ class BufferController extends Logger {
           /* with UHD content, we could get loop of quota exceeded error until
             browser is able to evict some data from sourcebuffer. Retrying can help recover.
           */
-          this.warn(`Failed ${appendErrorCount}/${hls.config.appendErrorMaxRetry} times to append segment in "${type}" sourceBuffer`);
-          if (appendErrorCount >= hls.config.appendErrorMaxRetry) {
+          this.warn(`Failed ${appendErrorCount}/${this.hls.config.appendErrorMaxRetry} times to append segment in "${type}" sourceBuffer`);
+          if (appendErrorCount >= this.hls.config.appendErrorMaxRetry) {
             event.fatal = true;
           }
         }
-        hls.trigger(Events.ERROR, event);
+        this.hls.trigger(Events.ERROR, event);
       }
     };
     operationQueue.append(operation, type, !!this.pendingTracks[type]);
   }
-  onBufferFlushing(event, data) {
-    const {
-      operationQueue
-    } = this;
-    const flushOperation = type => ({
-      execute: this.removeExecutor.bind(this, type, data.startOffset, data.endOffset),
+  getFlushOp(type, start, end) {
+    return {
+      execute: () => {
+        this.removeExecutor(type, start, end);
+      },
       onStart: () => {
         // logger.debug(`[buffer-controller]: Started flushing ${data.startOffset} -> ${data.endOffset} for ${type} Source Buffer`);
       },
@@ -19036,12 +19099,22 @@ class BufferController extends Logger {
       onError: error => {
         this.warn(`Failed to remove from ${type} SourceBuffer`, error);
       }
-    });
-    if (data.type) {
-      operationQueue.append(flushOperation(data.type), data.type);
+    };
+  }
+  onBufferFlushing(event, data) {
+    const {
+      operationQueue
+    } = this;
+    const {
+      type,
+      startOffset,
+      endOffset
+    } = data;
+    if (type) {
+      operationQueue.append(this.getFlushOp(type, startOffset, endOffset), type);
     } else {
-      this.getSourceBufferTypes().forEach(type => {
-        operationQueue.append(flushOperation(type), type);
+      this.getSourceBufferTypes().forEach(sbType => {
+        operationQueue.append(this.getFlushOp(sbType, startOffset, endOffset), sbType);
       });
     }
   }
@@ -19088,6 +19161,9 @@ class BufferController extends Logger {
   // on BUFFER_EOS mark matching sourcebuffer(s) as ended and trigger checkEos()
   // an undefined data.type will mark all buffers as EOS.
   onBufferEos(event, data) {
+    if (data.type === 'video') {
+      this.unblockAudio();
+    }
     const ended = this.getSourceBufferTypes().reduce((acc, type) => {
       const sb = this.sourceBuffer[type];
       if (sb && (!data.type || data.type === type)) {
@@ -19130,10 +19206,14 @@ class BufferController extends Logger {
       return;
     }
     this.details = details;
+    const durationAndRange = this.getDurationAndRange();
+    if (!durationAndRange) {
+      return;
+    }
     if (this.getSourceBufferTypes().length) {
-      this.blockBuffers(this.updateMediaElementDuration.bind(this));
+      this.blockBuffers(() => this.updateMediaSource(durationAndRange));
     } else {
-      this.updateMediaElementDuration();
+      this.updateMediaSource(durationAndRange);
     }
   }
   trimBuffers() {
@@ -19238,9 +19318,9 @@ class BufferController extends Logger {
    * 'liveDurationInfinity` is set to `true`
    * More details: https://github.com/video-dev/hls.js/issues/355
    */
-  updateMediaElementDuration() {
+  getDurationAndRange() {
     if (!this.details || !this.media || !this.mediaSource || this.mediaSource.readyState !== 'open') {
-      return;
+      return null;
     }
     const {
       details,
@@ -19254,25 +19334,41 @@ class BufferController extends Logger {
     if (details.live && hls.config.liveDurationInfinity) {
       // Override duration to Infinity
       mediaSource.duration = Infinity;
-      this.updateSeekableRange(details);
+      const len = details.fragments.length;
+      if (len && details.live && !!mediaSource.setLiveSeekableRange) {
+        const start = Math.max(0, details.fragments[0].start);
+        const end = Math.max(start, start + details.totalduration);
+        return {
+          duration: Infinity,
+          start,
+          end
+        };
+      }
+      return {
+        duration: Infinity
+      };
     } else if (levelDuration > msDuration && levelDuration > mediaDuration || !isFiniteNumber(mediaDuration)) {
-      // levelDuration was the last value we set.
-      // not using mediaSource.duration as the browser may tweak this value
-      // only update Media Source duration if its value increase, this is to avoid
-      // flushing already buffered portion when switching between quality level
-      this.log(`Updating Media Source duration to ${levelDuration.toFixed(3)}`);
-      mediaSource.duration = levelDuration;
+      return {
+        duration: levelDuration
+      };
     }
+    return null;
   }
-  updateSeekableRange(levelDetails) {
-    const mediaSource = this.mediaSource;
-    const fragments = levelDetails.fragments;
-    const len = fragments.length;
-    if (len && levelDetails.live && mediaSource != null && mediaSource.setLiveSeekableRange) {
-      const start = Math.max(0, fragments[0].start);
-      const end = Math.max(start, start + levelDetails.totalduration);
-      this.log(`Media Source duration is set to ${mediaSource.duration}. Setting seekable range to ${start}-${end}.`);
-      mediaSource.setLiveSeekableRange(start, end);
+  updateMediaSource({
+    duration,
+    start,
+    end
+  }) {
+    if (!this.media || !this.mediaSource || this.mediaSource.readyState !== 'open') {
+      return;
+    }
+    if (isFiniteNumber(duration)) {
+      this.log(`Updating Media Source duration to ${duration.toFixed(3)}`);
+    }
+    this.mediaSource.duration = duration;
+    if (start !== undefined && end !== undefined) {
+      this.log(`Media Source duration is set to ${this.mediaSource.duration}. Setting seekable range to ${start}-${end}.`);
+      this.mediaSource.setLiveSeekableRange(start, end);
     }
   }
   checkPendingTracks() {
@@ -19455,6 +19551,7 @@ class BufferController extends Logger {
       }
       return;
     }
+    sb.ending = false;
     sb.ended = false;
     sb.appendBuffer(data);
   }
@@ -19474,10 +19571,14 @@ class BufferController extends Logger {
 
     // logger.debug(`[buffer-controller]: Blocking ${buffers} SourceBuffer`);
     const blockingOperations = buffers.map(type => operationQueue.appendBlocker(type));
-    Promise.all(blockingOperations).then(() => {
+    const audioBlocked = buffers.length > 1 && !!this.blockedAudioAppend;
+    if (audioBlocked) {
+      this.unblockAudio();
+    }
+    Promise.all(blockingOperations).then(result => {
       // logger.debug(`[buffer-controller]: Blocking operation resolved; unblocking ${buffers} SourceBuffer`);
       onUnblocked();
-      buffers.forEach(type => {
+      buffers.forEach((type, i) => {
         const sb = this.sourceBuffer[type];
         // Only cycle the queue if the SB is not updating. There's a bug in Chrome which sets the SB updating flag to
         // true when changing the MediaSource duration (https://bugs.chromium.org/p/chromium/issues/detail?id=959359&can=2&q=mediasource%20duration)
@@ -28496,6 +28597,17 @@ class StreamController extends BaseStreamController {
   getMainFwdBufferInfo() {
     return this.getFwdBufferInfo(this.mediaBuffer ? this.mediaBuffer : this.media, PlaylistLevelType.MAIN);
   }
+  get maxBufferLength() {
+    const {
+      levels,
+      level
+    } = this;
+    const levelInfo = levels == null ? void 0 : levels[level];
+    if (!levelInfo) {
+      return this.config.maxBufferLength;
+    }
+    return this.getMaxBufferLength(levelInfo.maxBitrate);
+  }
   backtrack(frag) {
     this.couldBacktrack = true;
     // Causes findFragments to backtrack through fragments to find the keyframe
@@ -28601,7 +28713,7 @@ class Hls {
    * Get the video-dev/hls.js package version.
    */
   static get version() {
-    return "1.5.7-0.canary.10014";
+    return "1.5.7-0.canary.10016";
   }
 
   /**
@@ -28703,7 +28815,9 @@ class Hls {
     } = config;
     const errorController = new ConfigErrorController(this);
     const abrController = this.abrController = new ConfigAbrController(this);
-    const bufferController = this.bufferController = new ConfigBufferController(this);
+    // FragmentTracker must be defined before StreamController because the order of event handling is important
+    const fragmentTracker = new FragmentTracker(this);
+    const bufferController = this.bufferController = new ConfigBufferController(this, fragmentTracker);
     const capLevelController = this.capLevelController = new ConfigCapLevelController(this);
     const fpsController = new ConfigFpsController(this);
     const playListLoader = new PlaylistLoader(this);
@@ -28712,8 +28826,6 @@ class Hls {
     // ConentSteeringController is defined before LevelController to receive Multivariant Playlist events first
     const contentSteering = ConfigContentSteeringController ? new ConfigContentSteeringController(this) : null;
     const levelController = this.levelController = new LevelController(this, contentSteering);
-    // FragmentTracker must be defined before StreamController because the order of event handling is important
-    const fragmentTracker = new FragmentTracker(this);
     const keyLoader = new KeyLoader(this.config);
     const streamController = this.streamController = new StreamController(this, fragmentTracker, keyLoader);
 
@@ -29241,6 +29353,9 @@ class Hls {
   get mainForwardBufferInfo() {
     return this.streamController.getMainFwdBufferInfo();
   }
+  get maxBufferLength() {
+    return this.streamController.maxBufferLength;
+  }
 
   /**
    * Find and select the best matching audio track, making a level switch when a Group change is necessary.