hls.js 1.5.17 → 1.5.18

package/dist/hls.light.mjs

@@ -411,7 +411,7 @@ function enableLogs(debugConfig, id) {
     // Some browsers don't allow to use bind on console object anyway
     // fallback to default if needed
     try {
-      exportedLogger.log(`Debug logs enabled for "${id}" in hls.js version ${"1.5.17"}`);
+      exportedLogger.log(`Debug logs enabled for "${id}" in hls.js version ${"1.5.18"}`);
     } catch (e) {
       exportedLogger = fakeLogger;
     }
@@ -7220,6 +7220,7 @@ class BufferController {
       this.resetBuffer(type);
     });
     this._initSourceBuffer();
+    this.hls.resumeBuffering();
   }
   resetBuffer(type) {
     const sb = this.sourceBuffer[type];
@@ -8857,47 +8858,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);
         }
       }
     }
@@ -11899,6 +11904,7 @@ class BaseStreamController extends TaskLoop {
     this.startFragRequested = false;
     this.decrypter = void 0;
     this.initPTS = [];
+    this.buffering = true;
     this.onvseeking = null;
     this.onvended = null;
     this.logPrefix = '';
@@ -11938,6 +11944,12 @@ class BaseStreamController extends TaskLoop {
     this.clearNextTick();
     this.state = State.STOPPED;
   }
+  pauseBuffering() {
+    this.buffering = false;
+  }
+  resumeBuffering() {
+    this.buffering = true;
+  }
   _streamEnded(bufferInfo, levelDetails) {
     // If playlist is live, there is another buffered range after the current range, nothing buffered, media is detached,
     // of nothing loading/loaded return false
@@ -16187,19 +16199,23 @@ class MP4Remuxer {
     this.videoTrackConfig = undefined;
   }
   getVideoStartPts(videoSamples) {
+    // Get the minimum PTS value relative to the first sample's PTS, normalized for 33-bit wrapping
     let rolloverDetected = false;
+    const firstPts = videoSamples[0].pts;
     const startPTS = videoSamples.reduce((minPTS, sample) => {
-      const delta = sample.pts - minPTS;
+      let pts = sample.pts;
+      let delta = pts - minPTS;
       if (delta < -4294967296) {
         // 2^32, see PTSNormalize for reasoning, but we're hitting a rollover here, and we don't want that to impact the timeOffset calculation
         rolloverDetected = true;
-        return normalizePts(minPTS, sample.pts);
-      } else if (delta > 0) {
+        pts = normalizePts(pts, firstPts);
+        delta = pts - minPTS;
+      }
+      if (delta > 0) {
         return minPTS;
-      } else {
-        return sample.pts;
       }
-    }, videoSamples[0].pts);
+      return pts;
+    }, firstPts);
     if (rolloverDetected) {
       logger.debug('PTS rollover detected');
     }
@@ -18745,7 +18761,7 @@ class StreamController extends BaseStreamController {
     if (this.altAudio && this.audioOnly) {
       return;
     }
-    const level = hls.nextLoadLevel;
+    const level = this.buffering ? hls.nextLoadLevel : hls.loadLevel;
     if (!(levels != null && levels[level])) {
       return;
     }
@@ -18767,6 +18783,9 @@ class StreamController extends BaseStreamController {
       this.state = State.ENDED;
       return;
     }
+    if (!this.buffering) {
+      return;
+    }
 
     // set next load level : this will trigger a playlist load if needed
     if (hls.loadLevel !== level && hls.manualLevel === -1) {
@@ -19729,7 +19748,7 @@ class Hls {
    * Get the video-dev/hls.js package version.
    */
   static get version() {
-    return "1.5.17";
+    return "1.5.18";
   }
 
   /**
@@ -20010,9 +20029,13 @@ class Hls {
   startLoad(startPosition = -1) {
     logger.log(`startLoad(${startPosition})`);
     this.started = true;
-    this.networkControllers.forEach(controller => {
-      controller.startLoad(startPosition);
-    });
+    this.resumeBuffering();
+    for (let i = 0; i < this.networkControllers.length; i++) {
+      this.networkControllers[i].startLoad(startPosition);
+      if (!this.started || !this.networkControllers) {
+        break;
+      }
+    }
   }
 
   /**
@@ -20021,32 +20044,35 @@ class Hls {
   stopLoad() {
     logger.log('stopLoad');
     this.started = false;
-    this.networkControllers.forEach(controller => {
-      controller.stopLoad();
-    });
+    for (let i = 0; i < this.networkControllers.length; i++) {
+      this.networkControllers[i].stopLoad();
+      if (this.started || !this.networkControllers) {
+        break;
+      }
+    }
   }
 
   /**
-   * Resumes stream controller segment loading if previously started.
+   * Resumes stream controller segment loading after `pauseBuffering` has been called.
    */
   resumeBuffering() {
-    if (this.started) {
-      this.networkControllers.forEach(controller => {
-        if ('fragmentLoader' in controller) {
-          controller.startLoad(-1);
-        }
-      });
-    }
+    logger.log(`resume buffering`);
+    this.networkControllers.forEach(controller => {
+      if (controller.resumeBuffering) {
+        controller.resumeBuffering();
+      }
+    });
   }
 
   /**
-   * Stops stream controller segment loading without changing 'started' state like stopLoad().
+   * Prevents stream controller from loading new segments until `resumeBuffering` is called.
    * This allows for media buffering to be paused without interupting playlist loading.
    */
   pauseBuffering() {
+    logger.log(`pause buffering`);
     this.networkControllers.forEach(controller => {
-      if ('fragmentLoader' in controller) {
-        controller.stopLoad();
+      if (controller.pauseBuffering) {
+        controller.pauseBuffering();
       }
     });
   }