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

package/src/controller/eme-controller.ts

@@ -52,6 +52,7 @@ interface KeySystemAccessPromises {
   keySystemAccess: Promise<MediaKeySystemAccess>;
   mediaKeys?: Promise<MediaKeys>;
   certificate?: Promise<BufferSource | void>;
+  hasMediaKeys?: boolean;
 }
 
 export interface MediaKeySessionContext {
@@ -285,6 +286,7 @@ class EMEController extends Logger implements ComponentAPI {
           .createMediaKeys()
           .then((mediaKeys) => {
             this.log(`Media-keys created for "${keySystem}"`);
+            keySystemAccessPromises.hasMediaKeys = true;
             return certificateRequest.then((certificate) => {
               if (certificate) {
                 return this.setMediaKeysServerCertificate(
@@ -384,29 +386,29 @@ class EMEController extends Logger implements ComponentAPI {
     return keySession.update(data);
   }
 
-  public selectKeySystemFormat(frag: Fragment): Promise<KeySystemFormats> {
-    const keyFormats = Object.keys(frag.levelkeys || {}) as KeySystemFormats[];
-    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;
+  public getSelectedKeySystemFormats(): KeySystemFormats[] {
+    return (Object.keys(this.keySystemAccessPromises) as KeySystems[])
+      .map((keySystem) => ({
+        keySystem,
+        hasMediaKeys: this.keySystemAccessPromises[keySystem].hasMediaKeys,
+      }))
+      .filter(({ hasMediaKeys }) => !!hasMediaKeys)
+      .map(({ keySystem }) => keySystemToKeySystemFormat(keySystem))
+      .filter((keySystem): keySystem is KeySystemFormats => !!keySystem);
   }
 
-  private getKeyFormatPromise(
-    keyFormats: KeySystemFormats[],
+  public getKeySystemAccess(keySystemsToAttempt: KeySystems[]): Promise<void> {
+    return this.getKeySystemSelectionPromise(keySystemsToAttempt).then(
+      ({ keySystem, mediaKeys }) => {
+        return this.attemptSetMediaKeys(keySystem, mediaKeys);
+      },
+    );
+  }
+
+  public selectKeySystem(
+    keySystemsToAttempt: KeySystems[],
   ): Promise<KeySystemFormats> {
     return new Promise((resolve, reject) => {
-      const keySystemsInConfig = getKeySystemsForConfig(this.config);
-      const keySystemsToAttempt = keyFormats
-        .map(keySystemFormatToKeySystemDomain)
-        .filter(
-          (value) => !!value && keySystemsInConfig.indexOf(value) !== -1,
-        ) as any as KeySystems[];
       return this.getKeySystemSelectionPromise(keySystemsToAttempt)
         .then(({ keySystem }) => {
           const keySystemFormat = keySystemToKeySystemFormat(keySystem);
@@ -422,6 +424,32 @@ class EMEController extends Logger implements ComponentAPI {
     });
   }
 
+  public selectKeySystemFormat(frag: Fragment): Promise<KeySystemFormats> {
+    const keyFormats = Object.keys(frag.levelkeys || {}) as KeySystemFormats[];
+    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;
+  }
+
+  private getKeyFormatPromise(
+    keyFormats: KeySystemFormats[],
+  ): Promise<KeySystemFormats> {
+    const keySystemsInConfig = getKeySystemsForConfig(this.config);
+    const keySystemsToAttempt = keyFormats
+      .map(keySystemFormatToKeySystemDomain)
+      .filter(
+        (value) => !!value && keySystemsInConfig.indexOf(value) !== -1,
+      ) as any as KeySystems[];
+
+    return this.selectKeySystem(keySystemsToAttempt);
+  }
+
   public loadKey(data: KeyLoadedData): Promise<MediaKeySessionContext> {
     const decryptdata = data.keyInfo.decryptdata;
 

package/src/loader/key-loader.ts

@@ -1,7 +1,11 @@
 import { LoadError } from './fragment-loader';
 import { ErrorDetails, ErrorTypes } from '../errors';
-import type { HlsConfig } from '../config';
+import {
+  getKeySystemsForConfig,
+  keySystemFormatToKeySystemDomain,
+} from '../utils/mediakeys-helper';
 import type { LevelKey } from './level-key';
+import type { HlsConfig } from '../config';
 import type EMEController from '../controller/eme-controller';
 import type { MediaKeySessionContext } from '../controller/eme-controller';
 import type { Fragment } from '../loader/fragment';
@@ -90,25 +94,46 @@ export default class KeyLoader implements ComponentAPI {
   loadClear(
     loadingFrag: Fragment,
     encryptedFragments: Fragment[],
-  ): void | Promise<void> {
-    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;
+  ): null | Promise<void> {
+    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: Fragment): Promise<KeyLoadedData> {