hls.js 1.6.3-0.canary.11254 → 1.6.3-0.canary.11257

package/dist/hls.mjs

@@ -523,7 +523,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.3-0.canary.11254"}`);
+      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.3-0.canary.11257"}`);
     } catch (e) {
       /* log fn threw an exception. All logger methods are no-ops. */
       return createLogger();
@@ -8901,8 +8901,11 @@ class BaseStreamController extends TaskLoop {
       if (this.fragCurrent === null) {
         keyLoadingPromise = Promise.reject(new Error(`frag load aborted, context changed in KEY_LOADING`));
       }
-    } else if (!frag.encrypted && details.encryptedFragments.length) {
-      this.keyLoader.loadClear(frag, details.encryptedFragments);
+    } else if (!frag.encrypted) {
+      keyLoadingPromise = this.keyLoader.loadClear(frag, details.encryptedFragments);
+      if (keyLoadingPromise) {
+        this.log(`[eme] blocking frag load until media-keys acquired`);
+      }
     }
     const fragPrevious = this.fragPrevious;
     if (isMediaFragment(frag) && (!fragPrevious || frag.sn !== fragPrevious.sn)) {
@@ -10231,7 +10234,7 @@ function requireEventemitter3 () {
 var eventemitter3Exports = requireEventemitter3();
 var EventEmitter = /*@__PURE__*/getDefaultExportFromCjs(eventemitter3Exports);
 
-const version = "1.6.3-0.canary.11254";
+const version = "1.6.3-0.canary.11257";
 
 // ensure the worker ends up in the bundle
 // If the worker should not be included this gets aliased to empty.js
@@ -21832,6 +21835,7 @@ class EMEController extends Logger {
         this.log(`Create media-keys for "${keySystem}"`);
         _keySystemAccessPromises.mediaKeys = mediaKeySystemAccess.createMediaKeys().then(mediaKeys => {
           this.log(`Media-keys created for "${keySystem}"`);
+          _keySystemAccessPromises.hasMediaKeys = true;
           return certificateRequest.then(certificate => {
             if (certificate) {
               return this.setMediaKeysServerCertificate(mediaKeys, keySystem, certificate);
@@ -21892,18 +21896,26 @@ class EMEController extends Logger {
       } (data length: ${data ? data.byteLength : data})`);
     return keySession.update(data);
   }
-  selectKeySystemFormat(frag) {
-    const keyFormats = Object.keys(frag.levelkeys || {});
-    if (!this.keyFormatPromise) {
-      this.log(`Selecting key-system from fragment (sn: ${frag.sn} ${frag.type}: ${frag.level}) key formats ${keyFormats.join(', ')}`);
-      this.keyFormatPromise = this.getKeyFormatPromise(keyFormats);
-    }
-    return this.keyFormatPromise;
+  getSelectedKeySystemFormats() {
+    return Object.keys(this.keySystemAccessPromises).map(keySystem => ({
+      keySystem,
+      hasMediaKeys: this.keySystemAccessPromises[keySystem].hasMediaKeys
+    })).filter(({
+      hasMediaKeys
+    }) => !!hasMediaKeys).map(({
+      keySystem
+    }) => keySystemDomainToKeySystemFormat(keySystem)).filter(keySystem => !!keySystem);
+  }
+  getKeySystemAccess(keySystemsToAttempt) {
+    return this.getKeySystemSelectionPromise(keySystemsToAttempt).then(({
+      keySystem,
+      mediaKeys
+    }) => {
+      return this.attemptSetMediaKeys(keySystem, mediaKeys);
+    });
   }
-  getKeyFormatPromise(keyFormats) {
+  selectKeySystem(keySystemsToAttempt) {
     return new Promise((resolve, reject) => {
-      const keySystemsInConfig = getKeySystemsForConfig(this.config);
-      const keySystemsToAttempt = keyFormats.map(keySystemFormatToKeySystemDomain).filter(value => !!value && keySystemsInConfig.indexOf(value) !== -1);
       return this.getKeySystemSelectionPromise(keySystemsToAttempt).then(({
         keySystem
       }) => {
@@ -21916,6 +21928,19 @@ class EMEController extends Logger {
       }).catch(reject);
     });
   }
+  selectKeySystemFormat(frag) {
+    const keyFormats = Object.keys(frag.levelkeys || {});
+    if (!this.keyFormatPromise) {
+      this.log(`Selecting key-system from fragment (sn: ${frag.sn} ${frag.type}: ${frag.level}) key formats ${keyFormats.join(', ')}`);
+      this.keyFormatPromise = this.getKeyFormatPromise(keyFormats);
+    }
+    return this.keyFormatPromise;
+  }
+  getKeyFormatPromise(keyFormats) {
+    const keySystemsInConfig = getKeySystemsForConfig(this.config);
+    const keySystemsToAttempt = keyFormats.map(keySystemFormatToKeySystemDomain).filter(value => !!value && keySystemsInConfig.indexOf(value) !== -1);
+    return this.selectKeySystem(keySystemsToAttempt);
+  }
   loadKey(data) {
     const decryptdata = data.keyInfo.decryptdata;
     const keyId = this.getKeyIdString(decryptdata);
@@ -30296,6 +30321,8 @@ const hlsDefaultConfig = _objectSpread2(_objectSpread2({
   // used by eme-controller
   requestMediaKeySystemAccessFunc: requestMediaKeySystemAccess ,
   // used by eme-controller
+  requireKeySystemAccessOnStart: false,
+  // used by eme-controller
   testBandwidth: true,
   progressive: false,
   lowLatencyMode: true,
@@ -33686,22 +33713,35 @@ class KeyLoader {
     });
   }
   loadClear(loadingFrag, encryptedFragments) {
-    if (this.emeController && this.config.emeEnabled) {
-      // access key-system with nearest key on start (loaidng frag is unencrypted)
-      const {
-        sn,
-        cc
-      } = loadingFrag;
-      for (let i = 0; i < encryptedFragments.length; i++) {
-        const frag = encryptedFragments[i];
-        if (cc <= frag.cc && (sn === 'initSegment' || frag.sn === 'initSegment' || sn < frag.sn)) {
-          this.emeController.selectKeySystemFormat(frag).then(keySystemFormat => {
-            frag.setKeyFormat(keySystemFormat);
-          });
-          break;
+    if (this.emeController && this.config.emeEnabled && !this.emeController.getSelectedKeySystemFormats().length) {
+      // access key-system with nearest key on start (loading frag is unencrypted)
+      if (encryptedFragments.length) {
+        const {
+          sn,
+          cc
+        } = loadingFrag;
+        for (let i = 0; i < encryptedFragments.length; i++) {
+          const frag = encryptedFragments[i];
+          if (cc <= frag.cc && (sn === 'initSegment' || frag.sn === 'initSegment' || sn < frag.sn)) {
+            return this.emeController.selectKeySystemFormat(frag).then(keySystemFormat => {
+              frag.setKeyFormat(keySystemFormat);
+              if (this.emeController && this.config.requireKeySystemAccessOnStart) {
+                const keySystem = keySystemFormatToKeySystemDomain(keySystemFormat);
+                if (keySystem) {
+                  return this.emeController.getKeySystemAccess([keySystem]);
+                }
+              }
+            });
+          }
+        }
+      } else if (this.config.requireKeySystemAccessOnStart) {
+        const keySystemsInConfig = getKeySystemsForConfig(this.config);
+        if (keySystemsInConfig.length) {
+          return this.emeController.getKeySystemAccess(keySystemsInConfig);
         }
       }
     }
+    return null;
   }
   load(frag) {
     if (!frag.decryptdata && frag.encrypted && this.emeController && this.config.emeEnabled) {