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

package/dist/hls.js

@@ -644,7 +644,7 @@
       // 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.10015");
+        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();
@@ -7567,6 +7567,9 @@
       var fragCurrent = this.fragCurrent,
         partCurrent = this.partCurrent,
         hls = this.hls;
+      if (hls.levels.length <= 1) {
+        return hls.loadLevel;
+      }
       var maxAutoLevel = hls.maxAutoLevel,
         config = hls.config,
         minAutoLevel = hls.minAutoLevel;
@@ -8035,11 +8038,14 @@
      * If not found any Fragment, return null
      */;
     _proto.getBufferedFrag = function getBufferedFrag(position, levelType) {
+      return this.getFragAtPos(position, levelType, true);
+    };
+    _proto.getFragAtPos = function getFragAtPos(position, levelType, buffered) {
       var fragments = this.fragments;
       var keys = Object.keys(fragments);
       for (var i = keys.length; i--;) {
         var 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)) {
           var frag = fragmentEntity.body;
           if (frag.start <= position && position <= frag.end) {
             return frag;
@@ -8289,10 +8295,10 @@
       };
     };
     _proto.onBufferAppended = function onBufferAppended(event, data) {
-      var _this3 = this;
       var frag = data.frag,
         part = data.part,
-        timeRanges = data.timeRanges;
+        timeRanges = data.timeRanges,
+        type = data.type;
       if (frag.sn === 'initSegment') {
         return;
       }
@@ -8306,10 +8312,8 @@
       }
       // Store the latest timeRanges loaded in the buffer
       this.timeRanges = timeRanges;
-      Object.keys(timeRanges).forEach(function (elementaryStream) {
-        var timeRange = timeRanges[elementaryStream];
-        _this3.detectEvictedFragments(elementaryStream, timeRange, playlistType, part);
-      });
+      var timeRange = timeRanges[type];
+      this.detectEvictedFragments(type, timeRange, playlistType, part);
     };
     _proto.onFragBuffered = function onFragBuffered(event, data) {
       this.detectPartialFragments(data);
@@ -8323,12 +8327,12 @@
       return !!((_this$activePartLists = this.activePartLists[type]) != null && _this$activePartLists.length);
     };
     _proto.removeFragmentsInRange = function removeFragmentsInRange(start, end, playlistType, withGapOnly, unbufferedOnly) {
-      var _this4 = this;
+      var _this3 = this;
       if (withGapOnly && !this.hasGaps) {
         return;
       }
       Object.keys(this.fragments).forEach(function (key) {
-        var fragmentEntity = _this4.fragments[key];
+        var fragmentEntity = _this3.fragments[key];
         if (!fragmentEntity) {
           return;
         }
@@ -8337,7 +8341,7 @@
           return;
         }
         if (frag.start < end && frag.end > start && (fragmentEntity.buffered || unbufferedOnly)) {
-          _this4.removeFragment(frag);
+          _this3.removeFragment(frag);
         }
       });
     };
@@ -10299,7 +10303,7 @@
       // Workaround flaw in getting forward buffer when maxBufferHole is smaller than gap at current pos
       if (bufferInfo.len === 0 && bufferInfo.nextStart !== undefined) {
         var 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));
         }
       }
@@ -17342,9 +17346,8 @@
         this.state = State.ENDED;
         return;
       }
-      var mainBufferInfo = this.getFwdBufferInfo(this.videoBuffer ? this.videoBuffer : this.media, PlaylistLevelType.MAIN);
       var bufferLen = bufferInfo.len;
-      var maxBufLen = this.getMaxBufferLength(mainBufferInfo == null ? void 0 : mainBufferInfo.len);
+      var maxBufLen = hls.maxBufferLength;
       var fragments = trackDetails.fragments;
       var start = fragments[0].start;
       var targetBufferTime = this.flushing ? this.getLoadPosition() : bufferInfo.end;
@@ -17379,32 +17382,25 @@
         this.bufferFlushed = true;
         return;
       }
-
-      // Buffer audio up to one target duration ahead of main buffer
-      var 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
-        var 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
+        var mainBufferInfo = this.getFwdBufferInfo(this.videoBuffer ? this.videoBuffer : this.media, PlaylistLevelType.MAIN);
+        var 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
+          var 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);
     };
-    _proto.getMaxBufferLength = function getMaxBufferLength(mainBufferLength) {
-      var maxConfigBuffer = _BaseStreamController.prototype.getMaxBufferLength.call(this);
-      if (!mainBufferLength) {
-        return maxConfigBuffer;
-      }
-      return Math.min(Math.max(maxConfigBuffer, mainBufferLength), this.config.maxMaxBufferLength);
-    };
     _proto.onMediaDetaching = function onMediaDetaching() {
       this.videoBuffer = null;
       this.bufferFlushed = this.flushing = false;
@@ -18469,9 +18465,8 @@
         var bufferedInfo = BufferHelper.bufferedInfo(this.tracksBuffered[this.currentTrackId] || [], currentTime, config.maxBufferHole);
         var targetBufferTime = bufferedInfo.end,
           bufferLen = bufferedInfo.len;
-        var mainBufferInfo = this.getFwdBufferInfo(this.media, PlaylistLevelType.MAIN);
         var trackDetails = track.details;
-        var maxBufLen = this.getMaxBufferLength(mainBufferInfo == null ? void 0 : mainBufferInfo.len) + trackDetails.levelTargetDuration;
+        var maxBufLen = this.hls.maxBufferLength + trackDetails.levelTargetDuration;
         if (bufferLen > maxBufLen) {
           return;
         }
@@ -18508,13 +18503,6 @@
         }
       }
     };
-    _proto.getMaxBufferLength = function getMaxBufferLength(mainBufferLength) {
-      var maxConfigBuffer = _BaseStreamController.prototype.getMaxBufferLength.call(this);
-      if (!mainBufferLength) {
-        return maxConfigBuffer;
-      }
-      return Math.max(maxConfigBuffer, mainBufferLength);
-    };
     _proto.loadFragment = function loadFragment(frag, level, targetBufferTime) {
       this.fragCurrent = frag;
       if (frag.sn === 'initSegment') {
@@ -19032,24 +19020,23 @@
         this.executeNext(type);
       }
     };
-    _proto.insertAbort = function insertAbort(operation, type) {
-      var queue = this.queues[type];
-      queue.unshift(operation);
-      this.executeNext(type);
-    };
     _proto.appendBlocker = function appendBlocker(type) {
-      var execute;
-      var promise = new Promise(function (resolve) {
-        execute = resolve;
+      var _this = this;
+      return new Promise(function (resolve) {
+        var operation = {
+          execute: resolve,
+          onStart: function onStart() {},
+          onComplete: function onComplete() {},
+          onError: function onError() {}
+        };
+        _this.append(operation, type);
       });
-      var operation = {
-        execute: execute,
-        onStart: function onStart() {},
-        onComplete: function onComplete() {},
-        onError: function onError() {}
-      };
-      this.append(operation, type);
-      return promise;
+    };
+    _proto.unblockAudio = function unblockAudio(op) {
+      var queue = this.queues.audio;
+      if (queue[0] === op) {
+        this.shiftAndExecuteNext('audio');
+      }
     };
     _proto.executeNext = function executeNext(type) {
       var queue = this.queues[type];
@@ -19084,7 +19071,7 @@
   var VIDEO_CODEC_PROFILE_REPLACE = /(avc[1234]|hvc1|hev1|dvh[1e]|vp09|av01)(?:\.[^.,]+)+/;
   var BufferController = /*#__PURE__*/function (_Logger) {
     _inheritsLoose(BufferController, _Logger);
-    function BufferController(hls) {
+    function BufferController(hls, fragmentTracker) {
       var _this;
       _this = _Logger.call(this, 'buffer-controller', hls.logger) || this;
       // The level details used to determine duration, target-duration and live
@@ -19096,6 +19083,7 @@
       // 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
@@ -19106,6 +19094,10 @@
       _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 = {
@@ -19136,7 +19128,10 @@
         _this.log('Media source opened');
         if (media) {
           media.removeEventListener('emptied', _this._onMediaEmptied);
-          _this.updateMediaElementDuration();
+          var durationAndRange = _this.getDurationAndRange();
+          if (durationAndRange) {
+            _this.updateMediaSource(durationAndRange);
+          }
           _this.hls.trigger(Events.MEDIA_ATTACHED, {
             media: media,
             mediaSource: mediaSource
@@ -19163,6 +19158,7 @@
         }
       };
       _this.hls = hls;
+      _this.fragmentTracker = fragmentTracker;
       _this.appendSource = hls.config.preferManagedMediaSource;
       _this._initSourceBuffer();
       _this.registerListeners();
@@ -19177,7 +19173,7 @@
       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
@@ -19229,6 +19225,8 @@
         audiovideo: 0
       };
       this.lastMpegAudioChunk = null;
+      this.blockedAudioAppend = null;
+      this.lastVideoAppendEnd = 0;
     };
     _proto.onManifestLoading = function onManifestLoading() {
       this.bufferCodecEventsExpected = this._bufferCodecEventsTotal = 0;
@@ -19366,9 +19364,10 @@
       var trackNames = Object.keys(data);
       trackNames.forEach(function (trackName) {
         if (sourceBufferCount) {
+          var _track$buffer;
           // check if SourceBuffer codec needs to change
           var track = _this3.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;
             var _data$trackName = data[trackName],
               id = _data$trackName.id,
@@ -19436,17 +19435,52 @@
       };
       operationQueue.append(operation, type, !!this.pendingTracks[type]);
     };
+    _proto.blockAudio = function blockAudio(partOrFrag) {
+      var _this$fragmentTracker,
+        _this5 = this;
+      var pStart = partOrFrag.start;
+      var pTime = pStart + partOrFrag.duration * 0.05;
+      var atGap = ((_this$fragmentTracker = this.fragmentTracker.getAppendedFrag(pStart, PlaylistLevelType.MAIN)) == null ? void 0 : _this$fragmentTracker.gap) === true;
+      if (atGap) {
+        return;
+      }
+      var op = {
+        execute: function execute() {
+          var _this5$fragmentTracke;
+          if (_this5.lastVideoAppendEnd > pTime || _this5.sourceBuffer.video && BufferHelper.isBuffered(_this5.sourceBuffer.video, pTime) || ((_this5$fragmentTracke = _this5.fragmentTracker.getAppendedFrag(pTime, PlaylistLevelType.MAIN)) == null ? void 0 : _this5$fragmentTracke.gap) === true) {
+            _this5.blockedAudioAppend = null;
+            _this5.operationQueue.shiftAndExecuteNext('audio');
+          }
+        },
+        onStart: function onStart() {},
+        onComplete: function onComplete() {},
+        onError: function onError() {}
+      };
+      this.blockedAudioAppend = {
+        op: op,
+        frag: partOrFrag
+      };
+      this.operationQueue.append(op, 'audio', true);
+    };
+    _proto.unblockAudio = function unblockAudio() {
+      var blockedAudioAppend = this.blockedAudioAppend;
+      if (blockedAudioAppend) {
+        this.blockedAudioAppend = null;
+        this.operationQueue.unblockAudio(blockedAudioAppend.op);
+      }
+    };
     _proto.onBufferAppending = function onBufferAppending(event, eventData) {
-      var _this5 = this;
-      var hls = this.hls,
-        operationQueue = this.operationQueue,
+      var _this6 = this;
+      var operationQueue = this.operationQueue,
         tracks = this.tracks;
       var data = eventData.data,
         type = eventData.type,
+        parent = eventData.parent,
         frag = eventData.frag,
         part = eventData.part,
         chunkMeta = eventData.chunkMeta;
       var chunkStats = chunkMeta.buffering[type];
+      var sn = frag.sn;
       var bufferAppendingStart = self.performance.now();
       chunkStats.start = bufferAppendingStart;
       var fragBuffering = frag.stats.buffering;
@@ -19469,21 +19503,50 @@
         checkTimestampOffset = !this.lastMpegAudioChunk || chunkMeta.id === 1 || this.lastMpegAudioChunk.sn !== chunkMeta.sn;
         this.lastMpegAudioChunk = chunkMeta;
       }
-      var fragStart = frag.start;
+
+      // Block audio append until overlapping video append
+      var videoSb = this.sourceBuffer.video;
+      if (videoSb && sn !== 'initSegment') {
+        var partOrFrag = part || frag;
+        var blockedAudioAppend = this.blockedAudioAppend;
+        if (type === 'audio' && parent !== 'main' && !this.blockedAudioAppend) {
+          var pStart = partOrFrag.start;
+          var pTime = pStart + partOrFrag.duration * 0.05;
+          var vbuffered = videoSb.buffered;
+          var 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') {
+          var videoAppendEnd = partOrFrag.end;
+          if (blockedAudioAppend) {
+            var audioStart = blockedAudioAppend.frag.start;
+            if (videoAppendEnd > audioStart || videoAppendEnd < this.lastVideoAppendEnd || BufferHelper.isBuffered(videoSb, audioStart)) {
+              this.unblockAudio();
+            }
+          }
+          this.lastVideoAppendEnd = videoAppendEnd;
+        }
+      }
+      var fragStart = (part || frag).start;
       var operation = {
         execute: function execute() {
           chunkStats.executeStart = self.performance.now();
           if (checkTimestampOffset) {
-            var sb = _this5.sourceBuffer[type];
+            var sb = _this6.sourceBuffer[type];
             if (sb) {
               var delta = fragStart - sb.timestampOffset;
               if (Math.abs(delta) >= 0.1) {
-                _this5.log("Updating audio SourceBuffer timestampOffset to " + fragStart + " (delta: " + delta + ") sn: " + frag.sn + ")");
+                _this6.log("Updating audio SourceBuffer timestampOffset to " + fragStart + " (delta: " + delta + ") sn: " + sn + ")");
                 sb.timestampOffset = fragStart;
               }
             }
           }
-          _this5.appendExecutor(data, type);
+          _this6.appendExecutor(data, type);
         },
         onStart: function onStart() {
           // logger.debug(`[buffer-controller]: ${type} SourceBuffer updatestart`);
@@ -19498,19 +19561,19 @@
           if (partBuffering && partBuffering.first === 0) {
             partBuffering.first = end;
           }
-          var sourceBuffer = _this5.sourceBuffer;
+          var sourceBuffer = _this6.sourceBuffer;
           var timeRanges = {};
           for (var _type in sourceBuffer) {
             timeRanges[_type] = BufferHelper.getBuffered(sourceBuffer[_type]);
           }
-          _this5.appendErrors[type] = 0;
+          _this6.appendErrors[type] = 0;
           if (type === 'audio' || type === 'video') {
-            _this5.appendErrors.audiovideo = 0;
+            _this6.appendErrors.audiovideo = 0;
           } else {
-            _this5.appendErrors.audio = 0;
-            _this5.appendErrors.video = 0;
+            _this6.appendErrors.audio = 0;
+            _this6.appendErrors.video = 0;
           }
-          _this5.hls.trigger(Events.BUFFER_APPENDED, {
+          _this6.hls.trigger(Events.BUFFER_APPENDED, {
             type: type,
             frag: frag,
             part: part,
@@ -19538,51 +19601,57 @@
             // let's stop appending any segments, and report BUFFER_FULL_ERROR error
             event.details = ErrorDetails.BUFFER_FULL_ERROR;
           } else {
-            var appendErrorCount = ++_this5.appendErrors[type];
+            var appendErrorCount = ++_this6.appendErrors[type];
             event.details = ErrorDetails.BUFFER_APPEND_ERROR;
             /* 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.
             */
-            _this5.warn("Failed " + appendErrorCount + "/" + hls.config.appendErrorMaxRetry + " times to append segment in \"" + type + "\" sourceBuffer");
-            if (appendErrorCount >= hls.config.appendErrorMaxRetry) {
+            _this6.warn("Failed " + appendErrorCount + "/" + _this6.hls.config.appendErrorMaxRetry + " times to append segment in \"" + type + "\" sourceBuffer");
+            if (appendErrorCount >= _this6.hls.config.appendErrorMaxRetry) {
               event.fatal = true;
             }
           }
-          hls.trigger(Events.ERROR, event);
+          _this6.hls.trigger(Events.ERROR, event);
         }
       };
       operationQueue.append(operation, type, !!this.pendingTracks[type]);
     };
+    _proto.getFlushOp = function getFlushOp(type, start, end) {
+      var _this7 = this;
+      return {
+        execute: function execute() {
+          _this7.removeExecutor(type, start, end);
+        },
+        onStart: function onStart() {
+          // logger.debug(`[buffer-controller]: Started flushing ${data.startOffset} -> ${data.endOffset} for ${type} Source Buffer`);
+        },
+        onComplete: function onComplete() {
+          // logger.debug(`[buffer-controller]: Finished flushing ${data.startOffset} -> ${data.endOffset} for ${type} Source Buffer`);
+          _this7.hls.trigger(Events.BUFFER_FLUSHED, {
+            type: type
+          });
+        },
+        onError: function onError(error) {
+          _this7.warn("Failed to remove from " + type + " SourceBuffer", error);
+        }
+      };
+    };
     _proto.onBufferFlushing = function onBufferFlushing(event, data) {
-      var _this6 = this;
+      var _this8 = this;
       var operationQueue = this.operationQueue;
-      var flushOperation = function flushOperation(type) {
-        return {
-          execute: _this6.removeExecutor.bind(_this6, type, data.startOffset, data.endOffset),
-          onStart: function onStart() {
-            // logger.debug(`[buffer-controller]: Started flushing ${data.startOffset} -> ${data.endOffset} for ${type} Source Buffer`);
-          },
-          onComplete: function onComplete() {
-            // logger.debug(`[buffer-controller]: Finished flushing ${data.startOffset} -> ${data.endOffset} for ${type} Source Buffer`);
-            _this6.hls.trigger(Events.BUFFER_FLUSHED, {
-              type: type
-            });
-          },
-          onError: function onError(error) {
-            _this6.warn("Failed to remove from " + type + " SourceBuffer", error);
-          }
-        };
-      };
-      if (data.type) {
-        operationQueue.append(flushOperation(data.type), data.type);
+      var type = data.type,
+        startOffset = data.startOffset,
+        endOffset = data.endOffset;
+      if (type) {
+        operationQueue.append(this.getFlushOp(type, startOffset, endOffset), type);
       } else {
-        this.getSourceBufferTypes().forEach(function (type) {
-          operationQueue.append(flushOperation(type), type);
+        this.getSourceBufferTypes().forEach(function (sbType) {
+          operationQueue.append(_this8.getFlushOp(sbType, startOffset, endOffset), sbType);
         });
       }
     };
     _proto.onFragParsed = function onFragParsed(event, data) {
-      var _this7 = this;
+      var _this9 = this;
       var frag = data.frag,
         part = data.part;
       var buffersAppendedTo = [];
@@ -19604,7 +19673,7 @@
           part.stats.buffering.end = now;
         }
         var stats = part ? part.stats : frag.stats;
-        _this7.hls.trigger(Events.FRAG_BUFFERED, {
+        _this9.hls.trigger(Events.FRAG_BUFFERED, {
           frag: frag,
           part: part,
           stats: stats,
@@ -19624,14 +19693,17 @@
     // an undefined data.type will mark all buffers as EOS.
     ;
     _proto.onBufferEos = function onBufferEos(event, data) {
-      var _this8 = this;
+      var _this10 = this;
+      if (data.type === 'video') {
+        this.unblockAudio();
+      }
       var ended = this.getSourceBufferTypes().reduce(function (acc, type) {
-        var sb = _this8.sourceBuffer[type];
+        var sb = _this10.sourceBuffer[type];
         if (sb && (!data.type || data.type === type)) {
           sb.ending = true;
           if (!sb.ended) {
             sb.ended = true;
-            _this8.log(type + " sourceBuffer now EOS");
+            _this10.log(type + " sourceBuffer now EOS");
           }
         }
         return acc && !!(!sb || sb.ended);
@@ -19639,35 +19711,42 @@
       if (ended) {
         this.log("Queueing mediaSource.endOfStream()");
         this.blockBuffers(function () {
-          _this8.getSourceBufferTypes().forEach(function (type) {
-            var sb = _this8.sourceBuffer[type];
+          _this10.getSourceBufferTypes().forEach(function (type) {
+            var sb = _this10.sourceBuffer[type];
             if (sb) {
               sb.ending = false;
             }
           });
-          var mediaSource = _this8.mediaSource;
+          var mediaSource = _this10.mediaSource;
           if (!mediaSource || mediaSource.readyState !== 'open') {
             if (mediaSource) {
-              _this8.log("Could not call mediaSource.endOfStream(). mediaSource.readyState: " + mediaSource.readyState);
+              _this10.log("Could not call mediaSource.endOfStream(). mediaSource.readyState: " + mediaSource.readyState);
             }
             return;
           }
-          _this8.log("Calling mediaSource.endOfStream()");
+          _this10.log("Calling mediaSource.endOfStream()");
           // Allow this to throw and be caught by the enqueueing function
           mediaSource.endOfStream();
         });
       }
     };
     _proto.onLevelUpdated = function onLevelUpdated(event, _ref) {
+      var _this11 = this;
       var details = _ref.details;
       if (!details.fragments.length) {
         return;
       }
       this.details = details;
+      var durationAndRange = this.getDurationAndRange();
+      if (!durationAndRange) {
+        return;
+      }
       if (this.getSourceBufferTypes().length) {
-        this.blockBuffers(this.updateMediaElementDuration.bind(this));
+        this.blockBuffers(function () {
+          return _this11.updateMediaSource(durationAndRange);
+        });
       } else {
-        this.updateMediaElementDuration();
+        this.updateMediaSource(durationAndRange);
       }
     };
     _proto.trimBuffers = function trimBuffers() {
@@ -19700,7 +19779,7 @@
       }
     };
     _proto.flushBackBuffer = function flushBackBuffer(currentTime, targetDuration, targetBackBufferPosition) {
-      var _this9 = this;
+      var _this12 = this;
       var details = this.details,
         sourceBuffer = this.sourceBuffer;
       var sourceBufferTypes = this.getSourceBufferTypes();
@@ -19710,20 +19789,20 @@
           var buffered = BufferHelper.getBuffered(sb);
           // when target buffer start exceeds actual buffer start
           if (buffered.length > 0 && targetBackBufferPosition > buffered.start(0)) {
-            _this9.hls.trigger(Events.BACK_BUFFER_REACHED, {
+            _this12.hls.trigger(Events.BACK_BUFFER_REACHED, {
               bufferEnd: targetBackBufferPosition
             });
 
             // Support for deprecated event:
             if (details != null && details.live) {
-              _this9.hls.trigger(Events.LIVE_BACK_BUFFER_REACHED, {
+              _this12.hls.trigger(Events.LIVE_BACK_BUFFER_REACHED, {
                 bufferEnd: targetBackBufferPosition
               });
             } else if (sb.ended && buffered.end(buffered.length - 1) - currentTime < targetDuration * 2) {
-              _this9.log("Cannot flush " + type + " back buffer while SourceBuffer is in ended state");
+              _this12.log("Cannot flush " + type + " back buffer while SourceBuffer is in ended state");
               return;
             }
-            _this9.hls.trigger(Events.BUFFER_FLUSHING, {
+            _this12.hls.trigger(Events.BUFFER_FLUSHING, {
               startOffset: 0,
               endOffset: targetBackBufferPosition,
               type: type
@@ -19733,7 +19812,7 @@
       });
     };
     _proto.flushFrontBuffer = function flushFrontBuffer(currentTime, targetDuration, targetFrontBufferPosition) {
-      var _this10 = this;
+      var _this13 = this;
       var sourceBuffer = this.sourceBuffer;
       var sourceBufferTypes = this.getSourceBufferTypes();
       sourceBufferTypes.forEach(function (type) {
@@ -19751,10 +19830,10 @@
           if (targetFrontBufferPosition > bufferStart || currentTime >= bufferStart && currentTime <= bufferEnd) {
             return;
           } else if (sb.ended && currentTime - bufferEnd < 2 * targetDuration) {
-            _this10.log("Cannot flush " + type + " front buffer while SourceBuffer is in ended state");
+            _this13.log("Cannot flush " + type + " front buffer while SourceBuffer is in ended state");
             return;
           }
-          _this10.hls.trigger(Events.BUFFER_FLUSHING, {
+          _this13.hls.trigger(Events.BUFFER_FLUSHING, {
             startOffset: bufferStart,
             endOffset: Infinity,
             type: type
@@ -19768,9 +19847,9 @@
      * 'liveDurationInfinity` is set to `true`
      * More details: https://github.com/video-dev/hls.js/issues/355
      */;
-    _proto.updateMediaElementDuration = function updateMediaElementDuration() {
+    _proto.getDurationAndRange = function getDurationAndRange() {
       if (!this.details || !this.media || !this.mediaSource || this.mediaSource.readyState !== 'open') {
-        return;
+        return null;
       }
       var details = this.details,
         hls = this.hls,
@@ -19782,25 +19861,40 @@
       if (details.live && hls.config.liveDurationInfinity) {
         // Override duration to Infinity
         mediaSource.duration = Infinity;
-        this.updateSeekableRange(details);
+        var len = details.fragments.length;
+        if (len && details.live && !!mediaSource.setLiveSeekableRange) {
+          var start = Math.max(0, details.fragments[0].start);
+          var end = Math.max(start, start + details.totalduration);
+          return {
+            duration: Infinity,
+            start: start,
+            end: 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;
     };
-    _proto.updateSeekableRange = function updateSeekableRange(levelDetails) {
-      var mediaSource = this.mediaSource;
-      var fragments = levelDetails.fragments;
-      var len = fragments.length;
-      if (len && levelDetails.live && mediaSource != null && mediaSource.setLiveSeekableRange) {
-        var start = Math.max(0, fragments[0].start);
-        var 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);
+    _proto.updateMediaSource = function updateMediaSource(_ref2) {
+      var duration = _ref2.duration,
+        start = _ref2.start,
+        end = _ref2.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);
       }
     };
     _proto.checkPendingTracks = function checkPendingTracks() {
@@ -19839,7 +19933,7 @@
       }
     };
     _proto.createSourceBuffers = function createSourceBuffers(tracks) {
-      var _this11 = this;
+      var _this14 = this;
       var sourceBuffer = this.sourceBuffer,
         mediaSource = this.mediaSource;
       if (!mediaSource) {
@@ -19855,28 +19949,28 @@
           var codec = track.levelCodec || track.codec;
           if (codec) {
             if (trackName.slice(0, 5) === 'audio') {
-              codec = getCodecCompatibleName(codec, _this11.hls.config.preferManagedMediaSource);
+              codec = getCodecCompatibleName(codec, _this14.hls.config.preferManagedMediaSource);
             }
           }
           var mimeType = track.container + ";codecs=" + codec;
-          _this11.log("creating sourceBuffer(" + mimeType + ")");
+          _this14.log("creating sourceBuffer(" + mimeType + ")");
           try {
             var sb = sourceBuffer[trackName] = mediaSource.addSourceBuffer(mimeType);
             var sbName = trackName;
-            _this11.addBufferListener(sbName, 'updatestart', _this11._onSBUpdateStart);
-            _this11.addBufferListener(sbName, 'updateend', _this11._onSBUpdateEnd);
-            _this11.addBufferListener(sbName, 'error', _this11._onSBUpdateError);
+            _this14.addBufferListener(sbName, 'updatestart', _this14._onSBUpdateStart);
+            _this14.addBufferListener(sbName, 'updateend', _this14._onSBUpdateEnd);
+            _this14.addBufferListener(sbName, 'error', _this14._onSBUpdateError);
             // ManagedSourceBuffer bufferedchange event
-            _this11.addBufferListener(sbName, 'bufferedchange', function (type, event) {
+            _this14.addBufferListener(sbName, 'bufferedchange', function (type, event) {
               // If media was ejected check for a change. Added ranges are redundant with changes on 'updateend' event.
               var removedRanges = event.removedRanges;
               if (removedRanges != null && removedRanges.length) {
-                _this11.hls.trigger(Events.BUFFER_FLUSHED, {
+                _this14.hls.trigger(Events.BUFFER_FLUSHED, {
                   type: trackName
                 });
               }
             });
-            _this11.tracks[trackName] = {
+            _this14.tracks[trackName] = {
               buffer: sb,
               codec: codec,
               container: track.container,
@@ -19885,8 +19979,8 @@
               id: track.id
             };
           } catch (err) {
-            _this11.error("error while trying to add sourceBuffer: " + err.message);
-            _this11.hls.trigger(Events.ERROR, {
+            _this14.error("error while trying to add sourceBuffer: " + err.message);
+            _this14.hls.trigger(Events.ERROR, {
               type: ErrorTypes.MEDIA_ERROR,
               details: ErrorDetails.BUFFER_ADD_CODEC_ERROR,
               fatal: false,
@@ -19974,6 +20068,7 @@
         }
         return;
       }
+      sb.ending = false;
       sb.ended = false;
       sb.appendBuffer(data);
     }
@@ -19983,7 +20078,7 @@
     // upon completion, since we already do it here
     ;
     _proto.blockBuffers = function blockBuffers(onUnblocked, buffers) {
-      var _this12 = this;
+      var _this15 = this;
       if (buffers === void 0) {
         buffers = this.getSourceBufferTypes();
       }
@@ -19998,11 +20093,15 @@
       var blockingOperations = buffers.map(function (type) {
         return operationQueue.appendBlocker(type);
       });
-      Promise.all(blockingOperations).then(function () {
+      var audioBlocked = buffers.length > 1 && !!this.blockedAudioAppend;
+      if (audioBlocked) {
+        this.unblockAudio();
+      }
+      Promise.all(blockingOperations).then(function (result) {
         // logger.debug(`[buffer-controller]: Blocking operation resolved; unblocking ${buffers} SourceBuffer`);
         onUnblocked();
-        buffers.forEach(function (type) {
-          var sb = _this12.sourceBuffer[type];
+        buffers.forEach(function (type, i) {
+          var sb = _this15.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)
           // While this is a workaround, it's probably useful to have around
@@ -29177,6 +29276,17 @@
       }
     };
     _createClass(StreamController, [{
+      key: "maxBufferLength",
+      get: function get() {
+        var levels = this.levels,
+          level = this.level;
+        var levelInfo = levels == null ? void 0 : levels[level];
+        if (!levelInfo) {
+          return this.config.maxBufferLength;
+        }
+        return this.getMaxBufferLength(levelInfo.maxBitrate);
+      }
+    }, {
       key: "nextLevel",
       get: function get() {
         var frag = this.nextBufferedFrag;
@@ -29313,7 +29423,9 @@
         ConfigFpsController = config.fpsController;
       var errorController = new ConfigErrorController(this);
       var abrController = this.abrController = new ConfigAbrController(this);
-      var bufferController = this.bufferController = new ConfigBufferController(this);
+      // FragmentTracker must be defined before StreamController because the order of event handling is important
+      var fragmentTracker = new FragmentTracker(this);
+      var bufferController = this.bufferController = new ConfigBufferController(this, fragmentTracker);
       var capLevelController = this.capLevelController = new ConfigCapLevelController(this);
       var fpsController = new ConfigFpsController(this);
       var playListLoader = new PlaylistLoader(this);
@@ -29322,8 +29434,6 @@
       // ConentSteeringController is defined before LevelController to receive Multivariant Playlist events first
       var contentSteering = ConfigContentSteeringController ? new ConfigContentSteeringController(this) : null;
       var levelController = this.levelController = new LevelController(this, contentSteering);
-      // FragmentTracker must be defined before StreamController because the order of event handling is important
-      var fragmentTracker = new FragmentTracker(this);
       var keyLoader = new KeyLoader(this.config);
       var streamController = this.streamController = new StreamController(this, fragmentTracker, keyLoader);
 
@@ -29920,6 +30030,11 @@
       get: function get() {
         return this.streamController.getMainFwdBufferInfo();
       }
+    }, {
+      key: "maxBufferLength",
+      get: function get() {
+        return this.streamController.maxBufferLength;
+      }
     }, {
       key: "allAudioTracks",
       get: function get() {
@@ -30102,7 +30217,7 @@
        * Get the video-dev/hls.js package version.
        */
       function get() {
-        return "1.5.7-0.canary.10015";
+        return "1.5.7-0.canary.10016";
       }
     }, {
       key: "Events",