hls.js 1.5.17 → 1.5.18

package/package.json

@@ -130,5 +130,5 @@
     "url-toolkit": "2.2.5",
     "wrangler": "3.22.4"
   },
-  "version": "1.5.17"
+  "version": "1.5.18"
 }

package/src/controller/audio-stream-controller.ts

@@ -281,12 +281,14 @@ class AudioStreamController
     const { hls, levels, media, trackId } = this;
     const config = hls.config;
 
-    // 1. if video not attached AND
+    // 1. if buffering is suspended
+    // 2. if video not attached AND
     //    start fragment already requested OR start frag prefetch not enabled
-    // 2. if tracks or track not loaded and selected
+    // 3. if tracks or track not loaded and selected
     // then exit loop
     // => if media not attached but start frag prefetch is enabled and start frag not requested yet, we will not exit loop
     if (
+      !this.buffering ||
       (!media && (this.startFragRequested || !config.startFragPrefetch)) ||
       !levels?.[trackId]
     ) {

package/src/controller/base-stream-controller.ts

@@ -97,6 +97,7 @@ export default class BaseStreamController
   protected startFragRequested: boolean = false;
   protected decrypter: Decrypter;
   protected initPTS: RationalTimestamp[] = [];
+  protected buffering: boolean = true;
   protected onvseeking: EventListener | null = null;
   protected onvended: EventListener | null = null;
 
@@ -150,6 +151,14 @@ export default class BaseStreamController
     this.state = State.STOPPED;
   }
 
+  public pauseBuffering() {
+    this.buffering = false;
+  }
+
+  public resumeBuffering() {
+    this.buffering = true;
+  }
+
   protected _streamEnded(
     bufferInfo: BufferInfo,
     levelDetails: LevelDetails,

package/src/controller/buffer-controller.ts

@@ -309,6 +309,7 @@ export default class BufferController implements ComponentAPI {
       this.resetBuffer(type);
     });
     this._initSourceBuffer();
+    this.hls.resumeBuffering();
   }
 
   private resetBuffer(type: SourceBufferName) {

package/src/controller/stream-controller.ts

@@ -237,7 +237,7 @@ export default class StreamController
       return;
     }
 
-    const level = hls.nextLoadLevel;
+    const level = this.buffering ? hls.nextLoadLevel : hls.loadLevel;
     if (!levels?.[level]) {
       return;
     }
@@ -262,6 +262,9 @@ export default class StreamController
       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) {

package/src/hls.ts

@@ -430,9 +430,13 @@ export default class Hls implements HlsEventEmitter {
   startLoad(startPosition: number = -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;
+      }
+    }
   }
 
   /**
@@ -441,32 +445,35 @@ export default class Hls implements HlsEventEmitter {
   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();
       }
     });
   }

package/src/remux/mp4-remuxer.ts

@@ -100,20 +100,24 @@ export default class MP4Remuxer implements Remuxer {
     this.videoTrackConfig = undefined;
   }
 
-  getVideoStartPts(videoSamples) {
+  getVideoStartPts(videoSamples: VideoSample[]) {
+    // 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');
     }

package/src/types/component-api.ts

@@ -15,4 +15,6 @@ export interface AbrComponentAPI extends ComponentAPI {
 export interface NetworkComponentAPI extends ComponentAPI {
   startLoad(startPosition: number): void;
   stopLoad(): void;
+  pauseBuffering?(): void;
+  resumeBuffering?(): void;
 }

package/src/utils/xhr-loader.ts

@@ -203,59 +203,62 @@ class XhrLoader implements Loader<LoaderContext> {
         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 ?? 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: LoaderResponse = {
+              url: xhr.responseURL,
+              data: data,
+              code: status,
+            };
+
+            this.callbacks.onSuccess(response, stats, context, xhr);
             return;
           }
-          const response: LoaderResponse = {
-            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: LoaderResponse = {
+          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: LoaderResponse = {
-            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,
+          );
         }
       }
     }