hls.js 1.6.0-beta.1.0.canary.10751 → 1.6.0-beta.1.0.canary.10754

package/dist/hls.mjs

@@ -400,7 +400,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.6.0-beta.1.0.canary.10751"}`);
+      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.0-beta.1.0.canary.10754"}`);
     } catch (e) {
       /* log fn threw an exception. All logger methods are no-ops. */
       return createLogger();
@@ -1375,7 +1375,7 @@ class AbrController extends Logger {
       const bwEstimate = this.getBwEstimate();
       const levels = hls.levels;
       const level = levels[frag.level];
-      const expectedLen = stats.total || Math.max(stats.loaded, Math.round(duration * level.averageBitrate / 8));
+      const expectedLen = Math.max(stats.loaded, Math.round(duration * (frag.bitrate || level.averageBitrate) / 8));
       let timeStreaming = loadedFirstByte ? timeLoading - ttfb : timeLoading;
       if (timeStreaming < 1 && loadedFirstByte) {
         timeStreaming = Math.min(timeLoading, stats.loaded * 8 / bwEstimate);
@@ -1933,7 +1933,7 @@ class AbrController extends Logger {
       }
 
       // Use average bitrate when starvation delay (buffer length) is gt or eq two segment durations and rebuffering is not expected (maxStarvationDelay > 0)
-      const bitrate = currentFragDuration && bufferStarvationDelay >= currentFragDuration * 2 && maxStarvationDelay === 0 ? levels[i].averageBitrate : levels[i].maxBitrate;
+      const bitrate = currentFragDuration && bufferStarvationDelay >= currentFragDuration * 2 && maxStarvationDelay === 0 ? levelInfo.averageBitrate : levelInfo.maxBitrate;
       const fetchDuration = this.getTimeToLoadFrag(ttfbEstimateSec, adjustedbw, bitrate * avgDuration, levelDetails === undefined);
       const canSwitchWithinTolerance =
       // if adjusted bw is greater than level bitrate AND
@@ -3737,6 +3737,8 @@ class Fragment extends BaseSegment {
     this._decryptdata = null;
     this._programDateTime = null;
     this._ref = null;
+    // Approximate bit rate of the fragment expressed in bits per second (bps) as indicated by the last EXT-X-BITRATE (kbps) tag
+    this._bitrate = void 0;
     this.rawProgramDateTime = null;
     this.tagList = [];
     // EXTINF has to be present for a m3u8 to be considered valid
@@ -3791,6 +3793,34 @@ class Fragment extends BaseSegment {
     this.urlId = 0;
     this.type = type;
   }
+  get byteLength() {
+    if (this.hasStats) {
+      const total = this.stats.total;
+      if (total) {
+        return total;
+      }
+    }
+    if (this.byteRange) {
+      const start = this.byteRange[0];
+      const end = this.byteRange[1];
+      if (isFiniteNumber(start) && isFiniteNumber(end)) {
+        return end - start;
+      }
+    }
+    return null;
+  }
+  get bitrate() {
+    if (this.byteLength) {
+      return this.byteLength * 8 / this.duration;
+    }
+    if (this._bitrate) {
+      return this._bitrate;
+    }
+    return null;
+  }
+  set bitrate(value) {
+    this._bitrate = value;
+  }
   get decryptdata() {
     const {
       levelkeys
@@ -6918,6 +6948,7 @@ class M3U8Parser {
     let currentPart = 0;
     let totalduration = 0;
     let discontinuityCounter = 0;
+    let currentBitrate = 0;
     let prevFrag = null;
     let frag = new Fragment(type, base);
     let result;
@@ -6938,6 +6969,9 @@ class M3U8Parser {
         frag.start = totalduration;
         frag.sn = currentSN;
         frag.cc = discontinuityCounter;
+        if (currentBitrate) {
+          frag.bitrate = currentBitrate;
+        }
         frag.level = id;
         if (currentInitSegment) {
           frag.initSegment = currentInitSegment;
@@ -7067,6 +7101,12 @@ class M3U8Parser {
             break;
           case 'BITRATE':
             frag.tagList.push([tag, value1]);
+            currentBitrate = parseInt(value1) * 1000;
+            if (isFiniteNumber(currentBitrate)) {
+              frag.bitrate = currentBitrate;
+            } else {
+              currentBitrate = 0;
+            }
             break;
           case 'DATERANGE':
             {
@@ -9734,7 +9774,7 @@ var eventemitter3 = {exports: {}};
 var eventemitter3Exports = eventemitter3.exports;
 var EventEmitter = /*@__PURE__*/getDefaultExportFromCjs(eventemitter3Exports);
 
-const version = "1.6.0-beta.1.0.canary.10751";
+const version = "1.6.0-beta.1.0.canary.10754";
 
 // ensure the worker ends up in the bundle
 // If the worker should not be included this gets aliased to empty.js
@@ -17320,12 +17360,16 @@ class AudioTrackController extends BasePlaylistController {
     return -1;
   }
   loadPlaylist(hlsUrlParameters) {
+    var _this$hls$levels$this;
     const audioTrack = this.currentTrack;
-    if (this.shouldLoadPlaylist(audioTrack) && audioTrack) {
+    if (!audioTrack) {
+      return;
+    }
+    let url = audioTrack.url;
+    if (this.shouldLoadPlaylist(audioTrack) && url !== ((_this$hls$levels$this = this.hls.levels[this.hls.loadLevel]) == null ? void 0 : _this$hls$levels$this.uri)) {
       super.loadPlaylist();
       const id = audioTrack.id;
       const groupId = audioTrack.groupId;
-      let url = audioTrack.url;
       if (hlsUrlParameters) {
         try {
           url = hlsUrlParameters.addDirectives(url);
@@ -28953,47 +28997,51 @@ class XhrLoader {
         xhr.onprogress = null;
         const status = xhr.status;
         // http status between 200 to 299 are all successful
-        const useResponse = xhr.responseType !== 'text';
-        if (status >= 200 && status < 300 && (useResponse && xhr.response || xhr.responseText !== null)) {
-          stats.loading.end = Math.max(self.performance.now(), stats.loading.first);
-          const data = useResponse ? xhr.response : xhr.responseText;
-          const len = xhr.responseType === 'arraybuffer' ? data.byteLength : data.length;
-          stats.loaded = stats.total = len;
-          stats.bwEstimate = stats.total * 8000 / (stats.loading.end - stats.loading.first);
-          if (!this.callbacks) {
-            return;
-          }
-          const onProgress = this.callbacks.onProgress;
-          if (onProgress) {
-            onProgress(stats, context, data, xhr);
-          }
-          if (!this.callbacks) {
+        const useResponseText = xhr.responseType === 'text' ? xhr.responseText : null;
+        if (status >= 200 && status < 300) {
+          const data = useResponseText != null ? useResponseText : xhr.response;
+          if (data != null) {
+            stats.loading.end = Math.max(self.performance.now(), stats.loading.first);
+            const len = xhr.responseType === 'arraybuffer' ? data.byteLength : data.length;
+            stats.loaded = stats.total = len;
+            stats.bwEstimate = stats.total * 8000 / (stats.loading.end - stats.loading.first);
+            if (!this.callbacks) {
+              return;
+            }
+            const onProgress = this.callbacks.onProgress;
+            if (onProgress) {
+              onProgress(stats, context, data, xhr);
+            }
+            if (!this.callbacks) {
+              return;
+            }
+            const _response = {
+              url: xhr.responseURL,
+              data: data,
+              code: status
+            };
+            this.callbacks.onSuccess(_response, stats, context, xhr);
             return;
           }
-          const response = {
-            url: xhr.responseURL,
-            data: data,
-            code: status
-          };
-          this.callbacks.onSuccess(response, stats, context, xhr);
+        }
+
+        // Handle bad status or nullish response
+        const retryConfig = config.loadPolicy.errorRetry;
+        const retryCount = stats.retry;
+        // if max nb of retries reached or if http status between 400 and 499 (such error cannot be recovered, retrying is useless), return error
+        const response = {
+          url: context.url,
+          data: undefined,
+          code: status
+        };
+        if (shouldRetry(retryConfig, retryCount, false, response)) {
+          this.retry(retryConfig);
         } else {
-          const retryConfig = config.loadPolicy.errorRetry;
-          const retryCount = stats.retry;
-          // if max nb of retries reached or if http status between 400 and 499 (such error cannot be recovered, retrying is useless), return error
-          const response = {
-            url: context.url,
-            data: undefined,
-            code: status
-          };
-          if (shouldRetry(retryConfig, retryCount, false, response)) {
-            this.retry(retryConfig);
-          } else {
-            logger.error(`${status} while loading ${context.url}`);
-            this.callbacks.onError({
-              code: status,
-              text: xhr.statusText
-            }, context, xhr, stats);
-          }
+          logger.error(`${status} while loading ${context.url}`);
+          this.callbacks.onError({
+            code: status,
+            text: xhr.statusText
+          }, context, xhr, stats);
         }
       }
     }