hls.js 1.5.18 → 1.5.19

package/dist/hls.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.18"}`);
+      exportedLogger.log(`Debug logs enabled for "${id}" in hls.js version ${"1.5.19"}`);
     } catch (e) {
       exportedLogger = fakeLogger;
     }
@@ -1157,6 +1157,27 @@ function createMediaKeySystemConfigurations(initDataTypes, audioCodecs, videoCod
   };
   return [baseConfig];
 }
+function parsePlayReadyWRM(keyBytes) {
+  const keyBytesUtf16 = new Uint16Array(keyBytes.buffer, keyBytes.byteOffset, keyBytes.byteLength / 2);
+  const keyByteStr = String.fromCharCode.apply(null, Array.from(keyBytesUtf16));
+
+  // 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);
+      return keyIdArray;
+    }
+  }
+  return null;
+}
 
 function sliceUint8(array, start, end) {
   // @ts-expect-error This polyfills IE11 usage of Uint8Array slice.
@@ -2773,6 +2794,8 @@ class LevelKey {
     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) {
@@ -2782,25 +2805,11 @@ class LevelKey {
         case KeySystemFormats.PLAYREADY:
           {
             const PlayReadyKeySystemUUID = new Uint8Array([0x9a, 0x04, 0xf0, 0x79, 0x98, 0x40, 0x42, 0x86, 0xab, 0x92, 0xe6, 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));
-
-            // 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;
-              }
-            }
+            this.keyId = parsePlayReadyWRM(keyBytes);
             break;
           }
         default:
@@ -5250,15 +5259,16 @@ function mergeDetails(oldDetails, newDetails) {
     delete oldDetails.fragmentHint.endPTS;
   }
   // check if old/new playlists have fragments in common
-  // loop through overlapping SN and update startPTS , cc, and duration if any found
-  let ccOffset = 0;
+  // loop through overlapping SN and update startPTS, cc, and duration if any found
   let PTSFrag;
-  mapFragmentIntersection(oldDetails, newDetails, (oldFrag, newFrag) => {
-    if (oldFrag.relurl) {
-      // Do not compare CC if the old fragment has no url. This is a level.fragmentHint used by LL-HLS parts.
-      // It maybe be off by 1 if it was created before any parts or discontinuity tags were appended to the end
-      // of the playlist.
-      ccOffset = oldFrag.cc - newFrag.cc;
+  mapFragmentIntersection(oldDetails, newDetails, (oldFrag, newFrag, newFragIndex, newFragments) => {
+    if (newDetails.skippedSegments) {
+      if (newFrag.cc !== oldFrag.cc) {
+        const ccOffset = oldFrag.cc - newFrag.cc;
+        for (let i = newFragIndex; i < newFragments.length; i++) {
+          newFragments[i].cc += ccOffset;
+        }
+      }
     }
     if (isFiniteNumber(oldFrag.startPTS) && isFiniteNumber(oldFrag.endPTS)) {
       newFrag.start = newFrag.startPTS = oldFrag.startPTS;
@@ -5283,8 +5293,9 @@ function mergeDetails(oldDetails, newDetails) {
       currentInitSegment = oldFrag.initSegment;
     }
   });
+  const newFragments = newDetails.fragments;
   if (currentInitSegment) {
-    const fragmentsToCheck = newDetails.fragmentHint ? newDetails.fragments.concat(newDetails.fragmentHint) : newDetails.fragments;
+    const fragmentsToCheck = newDetails.fragmentHint ? newFragments.concat(newDetails.fragmentHint) : newFragments;
     fragmentsToCheck.forEach(frag => {
       var _currentInitSegment;
       if (frag && (!frag.initSegment || frag.initSegment.relurl === ((_currentInitSegment = currentInitSegment) == null ? void 0 : _currentInitSegment.relurl))) {
@@ -5293,27 +5304,20 @@ function mergeDetails(oldDetails, newDetails) {
     });
   }
   if (newDetails.skippedSegments) {
-    newDetails.deltaUpdateFailed = newDetails.fragments.some(frag => !frag);
+    newDetails.deltaUpdateFailed = newFragments.some(frag => !frag);
     if (newDetails.deltaUpdateFailed) {
       logger.warn('[level-helper] Previous playlist missing segments skipped in delta playlist');
       for (let i = newDetails.skippedSegments; i--;) {
-        newDetails.fragments.shift();
+        newFragments.shift();
+      }
+      newDetails.startSN = newFragments[0].sn;
+    } else {
+      if (newDetails.canSkipDateRanges) {
+        newDetails.dateRanges = mergeDateRanges(oldDetails.dateRanges, newDetails.dateRanges, newDetails.recentlyRemovedDateranges);
       }
-      newDetails.startSN = newDetails.fragments[0].sn;
-      newDetails.startCC = newDetails.fragments[0].cc;
-    } else if (newDetails.canSkipDateRanges) {
-      newDetails.dateRanges = mergeDateRanges(oldDetails.dateRanges, newDetails.dateRanges, newDetails.recentlyRemovedDateranges);
-    }
-  }
-  const newFragments = newDetails.fragments;
-  if (ccOffset) {
-    logger.warn('discontinuity sliding from playlist, take drift into account');
-    for (let i = 0; i < newFragments.length; i++) {
-      newFragments[i].cc += ccOffset;
     }
-  }
-  if (newDetails.skippedSegments) {
     newDetails.startCC = newDetails.fragments[0].cc;
+    newDetails.endCC = newFragments[newFragments.length - 1].cc;
   }
 
   // Merge parts
@@ -5397,7 +5401,7 @@ function mapFragmentIntersection(oldDetails, newDetails, intersectionFn) {
       newFrag = newDetails.fragments[i] = oldFrag;
     }
     if (oldFrag && newFrag) {
-      intersectionFn(oldFrag, newFrag);
+      intersectionFn(oldFrag, newFrag, i, newFrags);
     }
   }
 }
@@ -22012,12 +22016,148 @@ class EMEController {
     this.mediaKeySessions = [];
     this.keyIdToKeySessionPromise = {};
     this.setMediaKeysQueue = EMEController.CDMCleanupPromise ? [EMEController.CDMCleanupPromise] : [];
-    this.onMediaEncrypted = this._onMediaEncrypted.bind(this);
-    this.onWaitingForKey = this._onWaitingForKey.bind(this);
     this.debug = logger.debug.bind(logger, LOGGER_PREFIX);
     this.log = logger.log.bind(logger, LOGGER_PREFIX);
     this.warn = logger.warn.bind(logger, LOGGER_PREFIX);
     this.error = logger.error.bind(logger, LOGGER_PREFIX);
+    this.onMediaEncrypted = event => {
+      const {
+        initDataType,
+        initData
+      } = event;
+      const logMessage = `"${event.type}" event: init data type: "${initDataType}"`;
+      this.debug(logMessage);
+
+      // Ignore event when initData is null
+      if (initData === null) {
+        return;
+      }
+      if (!this.keyFormatPromise) {
+        let keySystems = Object.keys(this.keySystemAccessPromises);
+        if (!keySystems.length) {
+          keySystems = getKeySystemsForConfig(this.config);
+        }
+        const keyFormats = keySystems.map(keySystemDomainToKeySystemFormat).filter(k => !!k);
+        this.keyFormatPromise = this.getKeyFormatPromise(keyFormats);
+      }
+      this.keyFormatPromise.then(keySystemFormat => {
+        const keySystem = keySystemFormatToKeySystemDomain(keySystemFormat);
+        let keyId;
+        let keySystemDomain;
+        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;
+          }
+          // 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 (keySystem !== KeySystems.WIDEVINE && keySystem !== KeySystems.PLAYREADY) {
+            this.warn(`Ignoring unexpected "${event.type}" event with init data type: "${initDataType}" for selected key-system ${keySystem}`);
+            return;
+          }
+          // Support Widevine/PlayReady clear-lead key-session creation (otherwise depend on playlist keys)
+          const psshResults = parseMultiPssh(initData);
+          const psshInfos = psshResults.filter(pssh => !!pssh.systemId && keySystemIdToKeySystemDomain(pssh.systemId) === keySystem);
+          if (psshInfos.length > 1) {
+            this.warn(`${logMessage} Using first of ${psshInfos.length} pssh found for selected key-system ${keySystem}`);
+          }
+          const psshInfo = psshInfos[0];
+          if (!psshInfo) {
+            if (psshResults.length === 0 || psshResults.some(pssh => !pssh.systemId)) {
+              this.warn(`${logMessage} contains incomplete or invalid pssh data`);
+            } else {
+              this.log(`ignoring ${logMessage} for ${psshResults.map(pssh => keySystemIdToKeySystemDomain(pssh.systemId)).join(',')} pssh data in favor of playlist keys`);
+            }
+            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 (!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(keyContext, initDataType, initData, 'encrypted-event-key-match');
+            });
+            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
+          }) => {
+            var _keySystemToKeySystem;
+            this.throwIfDestroyed();
+            const decryptdata = new LevelKey('ISO-23001-7', keyIdHex, (_keySystemToKeySystem = keySystemDomainToKeySystemFormat(keySystem)) != null ? _keySystemToKeySystem : '');
+            decryptdata.pssh = new Uint8Array(initData);
+            decryptdata.keyId = keyId;
+            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');
+            });
+          });
+          keySessionContextPromise.catch(error => this.handleError(error));
+        }
+      });
+    };
+    this.onWaitingForKey = event => {
+      this.log(`"${event.type}" event`);
+    };
     this.hls = hls;
     this.config = hls.config;
     this.registerListeners();
@@ -22031,9 +22171,9 @@ class EMEController {
     config.licenseXhrSetup = config.licenseResponseCallback = undefined;
     config.drmSystems = config.drmSystemOptions = {};
     // @ts-ignore
-    this.hls = this.onMediaEncrypted = this.onWaitingForKey = this.keyIdToKeySessionPromise = null;
+    this.hls = this.config = this.keyIdToKeySessionPromise = null;
     // @ts-ignore
-    this.config = null;
+    this.onMediaEncrypted = this.onWaitingForKey = null;
   }
   registerListeners() {
     this.hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
@@ -22061,7 +22201,13 @@ class EMEController {
     if (keySystem === KeySystems.WIDEVINE && widevineLicenseUrl) {
       return widevineLicenseUrl;
     }
-    throw new Error(`no license server URL configured for key-system "${keySystem}"`);
+  }
+  getLicenseServerUrlOrThrow(keySystem) {
+    const url = this.getLicenseServerUrl(keySystem);
+    if (url === undefined) {
+      throw new Error(`no license server URL configured for key-system "${keySystem}"`);
+    }
+    return url;
   }
   getServerCertificateUrl(keySystem) {
     const {
@@ -22297,111 +22443,6 @@ class EMEController {
     }
     return this.attemptKeySystemAccess(keySystemsToAttempt);
   }
-  _onMediaEncrypted(event) {
-    const {
-      initDataType,
-      initData
-    } = event;
-    const logMessage = `"${event.type}" event: init data type: "${initDataType}"`;
-    this.debug(logMessage);
-
-    // Ignore event when initData is null
-    if (initData === null) {
-      return;
-    }
-    let keyId;
-    let keySystemDomain;
-    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`);
-        }
-        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.systemId === KeySystemIds.WIDEVINE)[0];
-      if (!psshInfo) {
-        if (psshResults.length === 0 || psshResults.some(pssh => !pssh.systemId)) {
-          this.warn(`${logMessage} contains incomplete or invalid pssh data`);
-        } else {
-          this.log(`ignoring ${logMessage} for ${psshResults.map(pssh => keySystemIdToKeySystemDomain(pssh.systemId)).join(',')} pssh data in favor of playlist keys`);
-        }
-        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;
-    }
-    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(keyContext, initDataType, initData, 'encrypted-event-key-match');
-        });
-        break;
-      }
-    }
-    if (!keySessionContextPromise) {
-      // Clear-lead key (not encountered in playlist)
-      keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex] = this.getKeySystemSelectionPromise([keySystemDomain]).then(({
-        keySystem,
-        mediaKeys
-      }) => {
-        var _keySystemToKeySystem;
-        this.throwIfDestroyed();
-        const decryptdata = new LevelKey('ISO-23001-7', keyIdHex, (_keySystemToKeySystem = keySystemDomainToKeySystemFormat(keySystem)) != null ? _keySystemToKeySystem : '');
-        decryptdata.pssh = new Uint8Array(initData);
-        decryptdata.keyId = keyId;
-        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');
-        });
-      });
-    }
-    keySessionContextPromise.catch(error => this.handleError(error));
-  }
-  _onWaitingForKey(event) {
-    this.log(`"${event.type}" event`);
-  }
   attemptSetMediaKeys(keySystem, mediaKeys) {
     const queue = this.setMediaKeysQueue.slice();
     this.log(`Setting media-keys for "${keySystem}"`);
@@ -22694,7 +22735,7 @@ class EMEController {
   requestLicense(keySessionContext, licenseChallenge) {
     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';
@@ -22764,6 +22805,8 @@ class EMEController {
 
     // 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);
   }
@@ -26113,7 +26156,7 @@ class KeyLoader {
     }
   }
   load(frag) {
-    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).then(keySystemFormat => {
         return this.loadInternal(frag, keySystemFormat);
@@ -27801,7 +27844,7 @@ class Hls {
    * Get the video-dev/hls.js package version.
    */
   static get version() {
-    return "1.5.18";
+    return "1.5.19";
   }
 
   /**