hls.js 1.6.7-0.canary.11366 → 1.6.7-0.canary.11369

package/package.json

@@ -127,7 +127,7 @@
     "rollup": "4.44.1",
     "rollup-plugin-istanbul": "5.0.0",
     "sauce-connect-launcher": "1.3.2",
-    "selenium-webdriver": "4.33.0",
+    "selenium-webdriver": "4.34.0",
     "semver": "7.7.2",
     "sinon": "19.0.5",
     "sinon-chai": "3.7.0",
@@ -135,5 +135,5 @@
     "url-toolkit": "2.2.5",
     "wrangler": "4.22.0"
   },
-  "version": "1.6.7-0.canary.11366"
+  "version": "1.6.7-0.canary.11369"
 }

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

@@ -201,9 +201,7 @@ class AudioStreamController
     const syncFrag = findNearestWithCC(trackDetails, targetDiscontinuity, pos);
     // Only stop waiting for audioFrag.cc if an audio segment of the same discontinuity domain (cc) is found
     if (syncFrag) {
-      this.log(
-        `Waiting fragment cc (${waitingToAppend?.cc}) cancelled because video is at cc ${mainAnchor.cc}`,
-      );
+      this.log(`Syncing with main frag at ${syncFrag.start} cc ${syncFrag.cc}`);
       this.startFragRequested = false;
       this.nextLoadPosition = syncFrag.start;
       this.resetLoadingState();

package/src/controller/eme-controller.ts

@@ -17,21 +17,11 @@ import {
   getKeySystemsForConfig,
   getSupportedMediaKeySystemConfigurations,
   isPersistentSessionType,
+  keySystemDomainToKeySystemFormat,
   keySystemFormatToKeySystemDomain,
-  keySystemIdToKeySystemDomain,
   KeySystems,
-  keySystemDomainToKeySystemFormat as keySystemToKeySystemFormat,
-  parsePlayReadyWRM,
   requestMediaKeySystemAccess,
 } from '../utils/mediakeys-helper';
-import {
-  bin2str,
-  parseMultiPssh,
-  parseSinf,
-  type PsshData,
-  type PsshInvalidResult,
-} from '../utils/mp4-tools';
-import { base64Decode } from '../utils/numeric-encoding-utils';
 import { stringify } from '../utils/safe-json-stringify';
 import { strToUtf8array } from '../utils/utf8-utils';
 import type { EMEControllerConfig, HlsConfig, LoadPolicy } from '../config';
@@ -119,7 +109,7 @@ class EMEController extends Logger implements ComponentAPI {
     // @ts-ignore
     this.hls = this.config = this.keyIdToKeySessionPromise = null;
     // @ts-ignore
-    this.onMediaEncrypted = this.onWaitingForKey = null;
+    this.onWaitingForKey = null;
   }
 
   private registerListeners() {
@@ -398,7 +388,7 @@ class EMEController extends Logger implements ComponentAPI {
         hasMediaKeys: this.keySystemAccessPromises[keySystem].hasMediaKeys,
       }))
       .filter(({ hasMediaKeys }) => !!hasMediaKeys)
-      .map(({ keySystem }) => keySystemToKeySystemFormat(keySystem))
+      .map(({ keySystem }) => keySystemDomainToKeySystemFormat(keySystem))
       .filter((keySystem): keySystem is KeySystemFormats => !!keySystem);
   }
 
@@ -416,7 +406,7 @@ class EMEController extends Logger implements ComponentAPI {
     return new Promise((resolve, reject) => {
       return this.getKeySystemSelectionPromise(keySystemsToAttempt)
         .then(({ keySystem }) => {
-          const keySystemFormat = keySystemToKeySystemFormat(keySystem);
+          const keySystemFormat = keySystemDomainToKeySystemFormat(keySystem);
           if (keySystemFormat) {
             resolve(keySystemFormat);
           } else {
@@ -562,197 +552,6 @@ class EMEController extends Logger implements ComponentAPI {
     return this.attemptKeySystemAccess(keySystemsToAttempt);
   }
 
-  private onMediaEncrypted = (event: MediaEncryptedEvent) => {
-    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,
-      ) as KeySystems[];
-      if (!keySystems.length) {
-        keySystems = getKeySystemsForConfig(this.config);
-      }
-      const keyFormats = keySystems
-        .map(keySystemToKeySystemFormat)
-        .filter((k) => !!k) as KeySystemFormats[];
-      this.keyFormatPromise = this.getKeyFormatPromise(keyFormats);
-    }
-
-    this.keyFormatPromise.then((keySystemFormat) => {
-      const keySystem = keySystemFormatToKeySystemDomain(keySystemFormat);
-
-      let keyId: Uint8Array<ArrayBuffer> | 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;
-        }
-        // 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 = new Uint8Array(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 is PsshData =>
-            !!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 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`,
-            );
-          }
-          return;
-        }
-
-        keySystemDomain = keySystemIdToKeySystemDomain(psshInfo.systemId);
-        if (psshInfo.version === 0 && psshInfo.data) {
-          if (keySystemDomain === KeySystems.WIDEVINE) {
-            const offset = psshInfo.data.length - 22;
-            keyId = new Uint8Array(psshInfo.data.subarray(offset, offset + 16));
-          } else if (keySystemDomain === KeySystems.PLAYREADY) {
-            keyId = parsePlayReadyWRM(psshInfo.data);
-          }
-        }
-      }
-
-      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',
-              );
-            });
-          keySessionContextPromise.catch((error) => this.handleError(error));
-          break;
-        }
-      }
-
-      if (!keySessionContextPromise) {
-        if (keySystemDomain !== keySystem) {
-          this.log(
-            `Ignoring "${event.type}" event 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;
-              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));
-      }
-    });
-  };
-
   private onWaitingForKey = (event: Event) => {
     this.log(`"${event.type}" event`);
   };
@@ -1331,7 +1130,6 @@ class EMEController extends Logger implements ComponentAPI {
     // keep reference of media
     this.media = media;
 
-    addEventListener(media, 'encrypted', this.onMediaEncrypted);
     addEventListener(media, 'waitingforkey', this.onWaitingForKey);
   }
 
@@ -1339,7 +1137,6 @@ class EMEController extends Logger implements ComponentAPI {
     const media = this.media;
 
     if (media) {
-      removeEventListener(media, 'encrypted', this.onMediaEncrypted);
       removeEventListener(media, 'waitingforkey', this.onWaitingForKey);
       this.media = null;
       this.mediaKeys = null;

package/src/controller/id3-track-controller.ts

@@ -6,6 +6,7 @@ import {
   isSCTE35Attribute,
 } from '../loader/date-range';
 import { MetadataSchema } from '../types/demuxer';
+import { hexToArrayBuffer } from '../utils/hex';
 import { stringify } from '../utils/safe-json-stringify';
 import {
   clearCurrentCues,
@@ -73,15 +74,6 @@ const MAX_CUE_ENDTIME = (() => {
   return Number.POSITIVE_INFINITY;
 })();
 
-function hexToArrayBuffer(str): ArrayBuffer {
-  return Uint8Array.from(
-    str
-      .replace(/^0x/, '')
-      .replace(/([\da-fA-F]{2}) ?/g, '0x$1 ')
-      .replace(/ +$/, '')
-      .split(' '),
-  ).buffer;
-}
 class ID3TrackController implements ComponentAPI {
   private hls: Hls;
   private id3Track: TextTrack | null = null;

package/src/loader/level-key.ts

@@ -1,4 +1,5 @@
 import { isFullSegmentEncryption } from '../utils/encryption-methods-util';
+import { hexToArrayBuffer } from '../utils/hex';
 import { convertDataUriToArrayBytes } from '../utils/keysystem-util';
 import { logger } from '../utils/logger';
 import { KeySystemFormats, parsePlayReadyWRM } from '../utils/mediakeys-helper';
@@ -41,6 +42,7 @@ export class LevelKey implements DecryptData {
     format: string,
     formatversions: number[] = [1],
     iv: Uint8Array<ArrayBuffer> | null = null,
+    keyId?: string,
   ) {
     this.method = method;
     this.uri = uri;
@@ -50,6 +52,20 @@ export class LevelKey implements DecryptData {
     this.encrypted = method ? method !== 'NONE' : false;
     this.isCommonEncryption =
       this.encrypted && !isFullSegmentEncryption(method);
+    if (keyId?.startsWith('0x')) {
+      this.keyId = new Uint8Array(hexToArrayBuffer(keyId));
+    }
+  }
+
+  public matches(key: LevelKey): boolean {
+    return (
+      key.uri === this.uri &&
+      key.method === this.method &&
+      key.encrypted === this.encrypted &&
+      key.keyFormat === this.keyFormat &&
+      key.keyFormatVersions.join(',') === this.keyFormatVersions.join(',') &&
+      key.iv?.join(',') === this.iv?.join(',')
+    );
   }
 
   public isSupported(): boolean {
@@ -113,6 +129,10 @@ export class LevelKey implements DecryptData {
       return this;
     }
 
+    if (this.pssh && this.keyId) {
+      return this;
+    }
+
     // Initialize keyId if possible
     const keyBytes = convertDataUriToArrayBytes(this.uri);
     if (keyBytes) {
@@ -121,12 +141,10 @@ export class LevelKey implements DecryptData {
           // 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) {
-            this.keyId = keyBytes.subarray(
-              keyBytes.length - 22,
-              keyBytes.length - 6,
-            );
+          // In case of Widevine, if KEYID is not in the playlist, assume only two fields in the pssh KEY tag URI.
+          if (!this.keyId && keyBytes.length >= 22) {
+            const offset = keyBytes.length - 22;
+            this.keyId = keyBytes.subarray(offset, offset + 16);
           }
           break;
         case KeySystemFormats.PLAYREADY: {

package/src/loader/m3u8-parser.ts

@@ -572,10 +572,14 @@ export default class M3U8Parser {
               if (!levelkeys) {
                 levelkeys = {};
               }
-              if (levelkeys[levelKey.keyFormat]) {
-                levelkeys = Object.assign({}, levelkeys);
+              const currentKey = levelkeys[levelKey.keyFormat];
+              // Ignore duplicate playlist KEY tags
+              if (!currentKey?.matches(levelKey)) {
+                if (currentKey) {
+                  levelkeys = Object.assign({}, levelkeys);
+                }
+                levelkeys[levelKey.keyFormat] = levelKey;
               }
-              levelkeys[levelKey.keyFormat] = levelKey;
             } else {
               logger.warn(`[Keys] Ignoring invalid EXT-X-KEY tag: "${value1}"`);
             }
@@ -856,6 +860,7 @@ function parseKey(
     decryptkeyformat,
     keyFormatVersions,
     decryptiv,
+    keyAttrs.KEYID,
   );
 }
 

package/src/utils/hex.ts

@@ -3,7 +3,7 @@
  */
 
 const Hex = {
-  hexDump: function (array: Uint8Array) {
+  hexDump: function (array: Uint8Array<ArrayBuffer>) {
     let str = '';
     for (let i = 0; i < array.length; i++) {
       let h = array[i].toString(16);
@@ -17,4 +17,14 @@ const Hex = {
   },
 };
 
+export function hexToArrayBuffer(str: string): ArrayBuffer {
+  return Uint8Array.from(
+    str
+      .replace(/^0x/, '')
+      .replace(/([\da-fA-F]{2}) ?/g, '0x$1 ')
+      .replace(/ +$/, '')
+      .split(' '),
+  ).buffer;
+}
+
 export default Hex;

package/src/utils/mediakeys-helper.ts

@@ -177,7 +177,7 @@ export function isPersistentSessionType(
   );
 }
 
-export function parsePlayReadyWRM(keyBytes: Uint8Array) {
+export function parsePlayReadyWRM(keyBytes: Uint8Array<ArrayBuffer>) {
   const keyBytesUtf16 = new Uint16Array(
     keyBytes.buffer,
     keyBytes.byteOffset,

package/src/utils/mp4-tools.ts

@@ -590,7 +590,7 @@ export function patchEncyptionData(
           const tenc = parseSinf(sinf);
           if (tenc) {
             // Look for default key id (keyID offset is always 8 within the tenc box):
-            const tencKeyId = tenc.subarray(8, 24);
+            const tencKeyId = tenc.subarray(8, 24) as Uint8Array<ArrayBuffer>;
             if (!tencKeyId.some((b) => b !== 0)) {
               logger.log(
                 `[eme] Patching keyId in 'enc${
@@ -1353,8 +1353,8 @@ export function mp4pssh(
 export type PsshData = {
   version: 0 | 1;
   systemId: KeySystemIds;
-  kids: null | Uint8Array[];
-  data: null | Uint8Array;
+  kids: null | Uint8Array<ArrayBuffer>[];
+  data: null | Uint8Array<ArrayBuffer>;
   offset: number;
   size: number;
 };
@@ -1382,7 +1382,7 @@ export function parseMultiPssh(
   return results;
 }
 
-function parsePssh(view: DataView): PsshData | PsshInvalidResult {
+function parsePssh(view: DataView<ArrayBuffer>): PsshData | PsshInvalidResult {
   const size = view.getUint32(0);
   const offset = view.byteOffset;
   const length = view.byteLength;
@@ -1405,8 +1405,8 @@ function parsePssh(view: DataView): PsshData | PsshInvalidResult {
     new Uint8Array(buffer, offset + 12, 16),
   ) as KeySystemIds;
 
-  let kids: null | Uint8Array[] = null;
-  let data: null | Uint8Array = null;
+  let kids: null | Uint8Array<ArrayBuffer>[] = null;
+  let data: null | Uint8Array<ArrayBuffer> = null;
   let dataSizeOffset = 0;
 
   if (version === 0) {