hls.js 1.5.17 → 1.5.19

package/package.json

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

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/eme-controller.ts

@@ -9,12 +9,11 @@ import { logger } from '../utils/logger';
 import {
   getKeySystemsForConfig,
   getSupportedMediaKeySystemConfigurations,
-  keySystemDomainToKeySystemFormat as keySystemToKeySystemFormat,
-  KeySystemFormats,
   keySystemFormatToKeySystemDomain,
-  KeySystemIds,
   keySystemIdToKeySystemDomain,
   KeySystems,
+  keySystemDomainToKeySystemFormat as keySystemToKeySystemFormat,
+  parsePlayReadyWRM,
   requestMediaKeySystemAccess,
 } from '../utils/mediakeys-helper';
 import { strToUtf8array } from '../utils/keysystem-util';
@@ -45,6 +44,7 @@ import type {
   LoaderConfiguration,
   LoaderContext,
 } from '../types/loader';
+import type { KeySystemFormats } from '../utils/mediakeys-helper';
 
 const LOGGER_PREFIX = '[eme]';
 
@@ -94,8 +94,6 @@ class EMEController implements ComponentAPI {
   private setMediaKeysQueue: Promise<void>[] = EMEController.CDMCleanupPromise
     ? [EMEController.CDMCleanupPromise]
     : [];
-  private onMediaEncrypted = this._onMediaEncrypted.bind(this);
-  private onWaitingForKey = this._onWaitingForKey.bind(this);
 
   private debug: (msg: any) => void = logger.debug.bind(logger, LOGGER_PREFIX);
   private log: (msg: any) => void = logger.log.bind(logger, LOGGER_PREFIX);
@@ -117,13 +115,9 @@ class EMEController implements ComponentAPI {
     config.licenseXhrSetup = config.licenseResponseCallback = undefined;
     config.drmSystems = config.drmSystemOptions = {};
     // @ts-ignore
-    this.hls =
-      this.onMediaEncrypted =
-      this.onWaitingForKey =
-      this.keyIdToKeySessionPromise =
-        null as any;
+    this.hls = this.config = this.keyIdToKeySessionPromise = null;
     // @ts-ignore
-    this.config = null;
+    this.onMediaEncrypted = this.onWaitingForKey = null;
   }
 
   private registerListeners() {
@@ -140,7 +134,7 @@ class EMEController implements ComponentAPI {
     this.hls.off(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
   }
 
-  private getLicenseServerUrl(keySystem: KeySystems): string | never {
+  private getLicenseServerUrl(keySystem: KeySystems): string | undefined {
     const { drmSystems, widevineLicenseUrl } = this.config;
     const keySystemConfiguration = drmSystems[keySystem];
 
@@ -152,10 +146,16 @@ class EMEController implements ComponentAPI {
     if (keySystem === KeySystems.WIDEVINE && widevineLicenseUrl) {
       return widevineLicenseUrl;
     }
+  }
 
-    throw new Error(
-      `no license server URL configured for key-system "${keySystem}"`,
-    );
+  private getLicenseServerUrlOrThrow(keySystem: KeySystems): string | never {
+    const url = this.getLicenseServerUrl(keySystem);
+    if (url === undefined) {
+      throw new Error(
+        `no license server URL configured for key-system "${keySystem}"`,
+      );
+    }
+    return url;
   }
 
   private getServerCertificateUrl(keySystem: KeySystems): string | void {
@@ -527,7 +527,7 @@ class EMEController implements ComponentAPI {
     return this.attemptKeySystemAccess(keySystemsToAttempt);
   }
 
-  private _onMediaEncrypted(event: MediaEncryptedEvent) {
+  private onMediaEncrypted = (event: MediaEncryptedEvent) => {
     const { initDataType, initData } = event;
     const logMessage = `"${event.type}" event: init data type: "${initDataType}"`;
     this.debug(logMessage);
@@ -537,133 +537,191 @@ class EMEController implements ComponentAPI {
       return;
     }
 
-    let keyId: Uint8Array | undefined;
-    let keySystemDomain: KeySystems | undefined;
+    if (!this.keyFormatPromise) {
+      let keySystems = Object.keys(
+        this.keySystemAccessPromises,
+      ) as KeySystems[];
+      if (!keySystems.length) {
+        keySystems = getKeySystemsForConfig(this.config);
+      }
+      const keyFormats = keySystems
+        .map(keySystemToKeySystemFormat)
+        .filter((k) => !!k) as KeySystemFormats[];
+      this.keyFormatPromise = this.getKeyFormatPromise(keyFormats);
+    }
 
-    if (
-      initDataType === 'sinf' &&
-      this.config.drmSystems[KeySystems.FAIRPLAY]
-    ) {
-      // Match sinf keyId to playlist skd://keyId=
-      const json = bin2str(new Uint8Array(initData));
-      try {
-        const sinf = base64Decode(JSON.parse(json).sinf);
-        const tenc = parseSinf(new Uint8Array(sinf));
-        if (!tenc) {
-          throw new Error(
-            `'schm' box missing or not cbcs/cenc with schi > tenc`,
+    this.keyFormatPromise.then((keySystemFormat) => {
+      const keySystem = keySystemFormatToKeySystemDomain(keySystemFormat);
+
+      let keyId: Uint8Array | null | undefined;
+      let keySystemDomain: KeySystems | undefined;
+
+      if (initDataType === 'sinf') {
+        if (keySystem !== KeySystems.FAIRPLAY) {
+          this.warn(
+            `Ignoring unexpected "${event.type}" event with init data type: "${initDataType}" for selected key-system ${keySystem}`,
           );
+          return;
         }
-        keyId = tenc.subarray(8, 24);
-        keySystemDomain = KeySystems.FAIRPLAY;
-      } catch (error) {
-        this.warn(`${logMessage} Failed to parse sinf: ${error}`);
-        return;
-      }
-    } else {
-      // Support Widevine clear-lead key-session creation (otherwise depend on playlist keys)
-      const psshResults = parseMultiPssh(initData);
-      const psshInfo = psshResults.filter(
-        (pssh): pssh is PsshData => pssh.systemId === KeySystemIds.WIDEVINE,
-      )[0];
-      if (!psshInfo) {
+        // Match sinf keyId to playlist skd://keyId=
+        const json = bin2str(new Uint8Array(initData));
+        try {
+          const sinf = base64Decode(JSON.parse(json).sinf);
+          const tenc = parseSinf(sinf);
+          if (!tenc) {
+            throw new Error(
+              `'schm' box missing or not cbcs/cenc with schi > tenc`,
+            );
+          }
+          keyId = tenc.subarray(8, 24);
+          keySystemDomain = KeySystems.FAIRPLAY;
+        } catch (error) {
+          this.warn(`${logMessage} Failed to parse sinf: ${error}`);
+          return;
+        }
+      } else {
         if (
-          psshResults.length === 0 ||
-          psshResults.some((pssh): pssh is PsshInvalidResult => !pssh.systemId)
+          keySystem !== KeySystems.WIDEVINE &&
+          keySystem !== KeySystems.PLAYREADY
         ) {
-          this.warn(`${logMessage} contains incomplete or invalid pssh data`);
-        } else {
-          this.log(
-            `ignoring ${logMessage} for ${(psshResults as PsshData[])
-              .map((pssh) => keySystemIdToKeySystemDomain(pssh.systemId))
-              .join(',')} pssh data in favor of playlist keys`,
+          this.warn(
+            `Ignoring unexpected "${event.type}" event with init data type: "${initDataType}" for selected key-system ${keySystem}`,
           );
+          return;
         }
-        return;
-      }
-      keySystemDomain = keySystemIdToKeySystemDomain(psshInfo.systemId);
-      if (psshInfo.version === 0 && psshInfo.data) {
-        const offset = psshInfo.data.length - 22;
-        keyId = psshInfo.data.subarray(offset, offset + 16);
-      }
-    }
-
-    if (!keySystemDomain || !keyId) {
-      return;
-    }
+        // Support Widevine/PlayReady clear-lead key-session creation (otherwise depend on playlist keys)
+        const psshResults = parseMultiPssh(initData);
 
-    const keyIdHex = Hex.hexDump(keyId);
-    const { keyIdToKeySessionPromise, mediaKeySessions } = this;
+        const psshInfos = psshResults.filter(
+          (pssh): pssh is PsshData =>
+            !!pssh.systemId &&
+            keySystemIdToKeySystemDomain(pssh.systemId) === keySystem,
+        );
 
-    let keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex];
-    for (let i = 0; i < mediaKeySessions.length; i++) {
-      // Match playlist key
-      const keyContext = mediaKeySessions[i];
-      const decryptdata = keyContext.decryptdata;
-      if (!decryptdata.keyId) {
-        continue;
-      }
-      const oldKeyIdHex = Hex.hexDump(decryptdata.keyId);
-      if (
-        keyIdHex === oldKeyIdHex ||
-        decryptdata.uri.replace(/-/g, '').indexOf(keyIdHex) !== -1
-      ) {
-        keySessionContextPromise = keyIdToKeySessionPromise[oldKeyIdHex];
-        if (decryptdata.pssh) {
-          break;
+        if (psshInfos.length > 1) {
+          this.warn(
+            `${logMessage} Using first of ${psshInfos.length} pssh found for selected key-system ${keySystem}`,
+          );
         }
-        delete keyIdToKeySessionPromise[oldKeyIdHex];
-        decryptdata.pssh = new Uint8Array(initData);
-        decryptdata.keyId = keyId;
-        keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex] =
-          keySessionContextPromise.then(() => {
-            return this.generateRequestWithPreferredKeySession(
-              keyContext,
-              initDataType,
-              initData,
-              'encrypted-event-key-match',
+
+        const psshInfo = psshInfos[0];
+
+        if (!psshInfo) {
+          if (
+            psshResults.length === 0 ||
+            psshResults.some(
+              (pssh): pssh is PsshInvalidResult => !pssh.systemId,
+            )
+          ) {
+            this.warn(`${logMessage} contains incomplete or invalid pssh data`);
+          } else {
+            this.log(
+              `ignoring ${logMessage} for ${(psshResults as PsshData[])
+                .map((pssh) => keySystemIdToKeySystemDomain(pssh.systemId))
+                .join(',')} pssh data in favor of playlist keys`,
             );
-          });
-        break;
+          }
+          return;
+        }
+
+        keySystemDomain = keySystemIdToKeySystemDomain(psshInfo.systemId);
+        if (psshInfo.version === 0 && psshInfo.data) {
+          if (keySystemDomain === KeySystems.WIDEVINE) {
+            const offset = psshInfo.data.length - 22;
+            keyId = psshInfo.data.subarray(offset, offset + 16);
+          } else if (keySystemDomain === KeySystems.PLAYREADY) {
+            keyId = parsePlayReadyWRM(psshInfo.data);
+          }
+        }
       }
-    }
 
-    if (!keySessionContextPromise) {
-      // Clear-lead key (not encountered in playlist)
-      keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex] =
-        this.getKeySystemSelectionPromise([keySystemDomain]).then(
-          ({ keySystem, mediaKeys }) => {
-            this.throwIfDestroyed();
-            const decryptdata = new LevelKey(
-              'ISO-23001-7',
-              keyIdHex,
-              keySystemToKeySystemFormat(keySystem) ?? '',
-            );
-            decryptdata.pssh = new Uint8Array(initData);
-            decryptdata.keyId = keyId as Uint8Array;
-            return this.attemptSetMediaKeys(keySystem, mediaKeys).then(() => {
-              this.throwIfDestroyed();
-              const keySessionContext = this.createMediaKeySessionContext({
-                decryptdata,
-                keySystem,
-                mediaKeys,
-              });
+      if (!keySystemDomain || !keyId) {
+        this.log(`Unable to handle ${logMessage} with key-system ${keySystem}`);
+        return;
+      }
+
+      const keyIdHex = Hex.hexDump(keyId);
+      const { keyIdToKeySessionPromise, mediaKeySessions } = this;
+
+      let keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex];
+      for (let i = 0; i < mediaKeySessions.length; i++) {
+        // Match playlist key
+        const keyContext = mediaKeySessions[i];
+        const decryptdata = keyContext.decryptdata;
+        if (!decryptdata.keyId) {
+          continue;
+        }
+        const oldKeyIdHex = Hex.hexDump(decryptdata.keyId);
+        if (
+          keyIdHex === oldKeyIdHex ||
+          decryptdata.uri.replace(/-/g, '').indexOf(keyIdHex) !== -1
+        ) {
+          keySessionContextPromise = keyIdToKeySessionPromise[oldKeyIdHex];
+          if (decryptdata.pssh) {
+            break;
+          }
+          delete keyIdToKeySessionPromise[oldKeyIdHex];
+          decryptdata.pssh = new Uint8Array(initData);
+          decryptdata.keyId = keyId;
+          keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex] =
+            keySessionContextPromise.then(() => {
               return this.generateRequestWithPreferredKeySession(
-                keySessionContext,
+                keyContext,
                 initDataType,
                 initData,
-                'encrypted-event-no-match',
+                'encrypted-event-key-match',
               );
             });
-          },
-        );
-    }
-    keySessionContextPromise.catch((error) => this.handleError(error));
-  }
+          keySessionContextPromise.catch((error) => this.handleError(error));
+          break;
+        }
+      }
+
+      if (!keySessionContextPromise) {
+        if (keySystemDomain !== keySystem) {
+          this.log(
+            `Ignoring "${logMessage}" with ${keySystemDomain} init data for selected key-system ${keySystem}`,
+          );
+          return;
+        }
+        // "Clear-lead" (misc key not encountered in playlist)
+        keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex] =
+          this.getKeySystemSelectionPromise([keySystemDomain]).then(
+            ({ keySystem, mediaKeys }) => {
+              this.throwIfDestroyed();
+
+              const decryptdata = new LevelKey(
+                'ISO-23001-7',
+                keyIdHex,
+                keySystemToKeySystemFormat(keySystem) ?? '',
+              );
+              decryptdata.pssh = new Uint8Array(initData);
+              decryptdata.keyId = keyId as Uint8Array;
+              return this.attemptSetMediaKeys(keySystem, mediaKeys).then(() => {
+                this.throwIfDestroyed();
+                const keySessionContext = this.createMediaKeySessionContext({
+                  decryptdata,
+                  keySystem,
+                  mediaKeys,
+                });
+                return this.generateRequestWithPreferredKeySession(
+                  keySessionContext,
+                  initDataType,
+                  initData,
+                  'encrypted-event-no-match',
+                );
+              });
+            },
+          );
 
-  private _onWaitingForKey(event: Event) {
+        keySessionContextPromise.catch((error) => this.handleError(error));
+      }
+    });
+  };
+
+  private onWaitingForKey = (event: Event) => {
     this.log(`"${event.type}" event`);
-  }
+  };
 
   private attemptSetMediaKeys(
     keySystem: KeySystems,
@@ -1111,7 +1169,7 @@ class EMEController implements ComponentAPI {
   ): Promise<ArrayBuffer> {
     const keyLoadPolicy = this.config.keyLoadPolicy.default;
     return new Promise((resolve, reject) => {
-      const url = this.getLicenseServerUrl(keySessionContext.keySystem);
+      const url = this.getLicenseServerUrlOrThrow(keySessionContext.keySystem);
       this.log(`Sending license request to URL: ${url}`);
       const xhr = new XMLHttpRequest();
       xhr.responseType = 'arraybuffer';
@@ -1216,6 +1274,8 @@ class EMEController implements ComponentAPI {
     // keep reference of media
     this.media = media;
 
+    media.removeEventListener('encrypted', this.onMediaEncrypted);
+    media.removeEventListener('waitingforkey', this.onWaitingForKey);
     media.addEventListener('encrypted', this.onMediaEncrypted);
     media.addEventListener('waitingforkey', this.onWaitingForKey);
   }

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/loader/key-loader.ts

@@ -112,7 +112,12 @@ export default class KeyLoader implements ComponentAPI {
   }
 
   load(frag: Fragment): Promise<KeyLoadedData> {
-    if (!frag.decryptdata && frag.encrypted && this.emeController) {
+    if (
+      !frag.decryptdata &&
+      frag.encrypted &&
+      this.emeController &&
+      this.config.emeEnabled
+    ) {
       // Multiple keys, but none selected, resolve in eme-controller
       return this.emeController
         .selectKeySystemFormat(frag)

package/src/loader/level-key.ts

@@ -2,7 +2,7 @@ import {
   changeEndianness,
   convertDataUriToArrayBytes,
 } from '../utils/keysystem-util';
-import { KeySystemFormats } from '../utils/mediakeys-helper';
+import { KeySystemFormats, parsePlayReadyWRM } from '../utils/mediakeys-helper';
 import { mp4pssh } from '../utils/mp4-tools';
 import { logger } from '../utils/logger';
 import { base64Decode } from '../utils/numeric-encoding-utils';
@@ -121,6 +121,8 @@ export class LevelKey implements DecryptData {
     if (keyBytes) {
       switch (this.keyFormat) {
         case KeySystemFormats.WIDEVINE:
+          // Setting `pssh` on this LevelKey/DecryptData allows HLS.js to generate a session using
+          // the playlist-key before the "encrypted" event. (Comment out to only use "encrypted" path.)
           this.pssh = keyBytes;
           // In case of widevine keyID is embedded in PSSH box. Read Key ID.
           if (keyBytes.length >= 22) {
@@ -136,38 +138,12 @@ export class LevelKey implements DecryptData {
             0x5b, 0xe0, 0x88, 0x5f, 0x95,
           ]);
 
+          // Setting `pssh` on this LevelKey/DecryptData allows HLS.js to generate a session using
+          // the playlist-key before the "encrypted" event. (Comment out to only use "encrypted" path.)
           this.pssh = mp4pssh(PlayReadyKeySystemUUID, null, keyBytes);
 
-          const keyBytesUtf16 = new Uint16Array(
-            keyBytes.buffer,
-            keyBytes.byteOffset,
-            keyBytes.byteLength / 2,
-          );
-          const keyByteStr = String.fromCharCode.apply(
-            null,
-            Array.from(keyBytesUtf16),
-          );
+          this.keyId = parsePlayReadyWRM(keyBytes);
 
-          // Parse Playready WRMHeader XML
-          const xmlKeyBytes = keyByteStr.substring(
-            keyByteStr.indexOf('<'),
-            keyByteStr.length,
-          );
-          const parser = new DOMParser();
-          const xmlDoc = parser.parseFromString(xmlKeyBytes, 'text/xml');
-          const keyData = xmlDoc.getElementsByTagName('KID')[0];
-          if (keyData) {
-            const keyId = keyData.childNodes[0]
-              ? keyData.childNodes[0].nodeValue
-              : keyData.getAttribute('VALUE');
-            if (keyId) {
-              const keyIdArray = base64Decode(keyId).subarray(0, 16);
-              // KID value in PRO is a base64-encoded little endian GUID interpretation of UUID
-              // KID value in ‘tenc’ is a big endian UUID GUID interpretation of UUID
-              changeEndianness(keyIdArray);
-              this.keyId = keyIdArray;
-            }
-          }
           break;
         }
         default: {

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;
 }