hls.js 1.6.0-beta.2.0.canary.10873 → 1.6.0-beta.2.0.canary.10877

package/package.json

@@ -134,5 +134,5 @@
     "url-toolkit": "2.2.5",
     "wrangler": "3.99.0"
   },
-  "version": "1.6.0-beta.2.0.canary.10873"
+  "version": "1.6.0-beta.2.0.canary.10877"
 }

package/src/controller/eme-controller.ts

@@ -535,147 +535,185 @@ class EMEController extends Logger implements ComponentAPI {
       return;
     }
 
-    let keyId: Uint8Array | null | undefined;
-    let keySystemDomain: KeySystems | undefined;
-
-    if (
-      initDataType === 'sinf' &&
-      this.getLicenseServerUrl(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(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 (this.getLicenseServerUrl(KeySystems.WIDEVINE)) {
-      // Support Widevine clear-lead key-session creation (otherwise depend on playlist keys)
-      const psshResults = parseMultiPssh(initData);
-
-      // TODO: If using keySystemAccessPromises we might want to wait until one is resolved
+    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);
+    }
 
-      const psshInfo = psshResults.filter((pssh): pssh is PsshData => {
-        const keySystem = pssh.systemId
-          ? keySystemIdToKeySystemDomain(pssh.systemId)
-          : null;
-        return keySystem ? keySystems.indexOf(keySystem) > -1 : false;
-      })[0];
+    this.keyFormatPromise.then((keySystemFormat) => {
+      const keySystem = keySystemFormatToKeySystemDomain(keySystemFormat);
 
-      if (!psshInfo) {
+      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;
+        }
+        // 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;
-      }
+        // Support Widevine/PlayReady clear-lead key-session creation (otherwise depend on playlist keys)
+        const psshResults = parseMultiPssh(initData);
 
-      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);
+        const psshInfos = psshResults.filter(
+          (pssh): pssh is PsshData =>
+            !!pssh.systemId &&
+            keySystemIdToKeySystemDomain(pssh.systemId) === keySystem,
+        );
+
+        if (psshInfos.length) {
+          this.warn(
+            `${logMessage} Using first of ${psshInfos.length} pssh found for selected key-system ${keySystem}`,
+          );
         }
-      }
-    }
 
-    if (!keySystemDomain || !keyId) {
-      return;
-    }
+        const psshInfo = psshInfos[0];
 
-    const keyIdHex = Hex.hexDump(keyId);
-    const { keyIdToKeySessionPromise, mediaKeySessions } = this;
+        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;
+        }
 
-    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;
+        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);
+          }
         }
-        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) {
-      // 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) {
+        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 "${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 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',
+                );
+              });
+            },
+          );
+
+        keySessionContextPromise.catch((error) => this.handleError(error));
+      }
+    });
   };
 
   private onWaitingForKey = (event: Event) => {

package/src/demux/audio/base-audio-demuxer.ts

@@ -18,8 +18,8 @@ import { dummyTrack } from '../dummy-demuxed-track';
 import type { RationalTimestamp } from '../../utils/timescale-conversion';
 
 class BaseAudioDemuxer implements Demuxer {
-  protected _audioTrack!: DemuxedAudioTrack;
-  protected _id3Track!: DemuxedMetadataTrack;
+  protected _audioTrack?: DemuxedAudioTrack;
+  protected _id3Track?: DemuxedMetadataTrack;
   protected frameIndex: number = 0;
   protected cachedData: Uint8Array | null = null;
   protected basePTS: number | null = null;
@@ -74,8 +74,8 @@ class BaseAudioDemuxer implements Demuxer {
     let id3Data: Uint8Array | undefined = getId3Data(data, 0);
     let offset = id3Data ? id3Data.length : 0;
     let lastDataIndex;
-    const track = this._audioTrack;
-    const id3Track = this._id3Track;
+    const track = this._audioTrack as DemuxedAudioTrack;
+    const id3Track = this._id3Track as DemuxedMetadataTrack;
     const timestamp = id3Data ? getId3Timestamp(id3Data) : undefined;
     const length = data.length;
 
@@ -167,9 +167,9 @@ class BaseAudioDemuxer implements Demuxer {
     }
 
     return {
-      audioTrack: this._audioTrack,
+      audioTrack: this._audioTrack as DemuxedAudioTrack,
       videoTrack: dummyTrack() as DemuxedVideoTrackBase,
-      id3Track: this._id3Track,
+      id3Track: this._id3Track as DemuxedMetadataTrack,
       textTrack: dummyTrack() as DemuxedUserdataTrack,
     };
   }

package/src/demux/tsdemuxer.ts

@@ -774,8 +774,8 @@ function parsePMT(
     audioPid: -1,
     videoPid: -1,
     id3Pid: -1,
-    segmentVideoCodec: 'avc',
-    segmentAudioCodec: 'aac',
+    segmentVideoCodec: 'avc' as 'avc' | 'hevc',
+    segmentAudioCodec: 'aac' as 'aac' | 'ac3' | 'mp3',
   };
   const sectionLength = ((data[offset + 1] & 0x0f) << 8) | data[offset + 2];
   const tableEnd = offset + 3 + sectionLength - 4;
@@ -822,7 +822,6 @@ function parsePMT(
         // logger.log('AVC PID:'  + pid);
         if (result.videoPid === -1) {
           result.videoPid = pid;
-          result.segmentVideoCodec = 'avc';
         }
 
         break;

package/src/demux/video/hevc-video-parser.ts

@@ -158,12 +158,7 @@ class HevcVideoParser extends BaseVideoParser {
               track.params[prop] = config.params[prop];
             }
           }
-          if (
-            (!track.vps && !track.sps.length) ||
-            (track.vps && track.vps[0] === this.initVPS)
-          ) {
-            track.sps.push(unit.data);
-          }
+          this.pushParameterSet(track.sps, unit.data, track.vps);
           if (!VideoSample) {
             VideoSample = this.VideoSample = this.createVideoSample(
               true,
@@ -185,12 +180,7 @@ class HevcVideoParser extends BaseVideoParser {
                 track.params[prop] = config[prop];
               }
             }
-            if (
-              (!track.vps && !track.pps.length) ||
-              (track.vps && track.vps[0] === this.initVPS)
-            ) {
-              track.pps.push(unit.data);
-            }
+            this.pushParameterSet(track.pps, unit.data, track.vps);
           }
           break;
 
@@ -227,6 +217,16 @@ class HevcVideoParser extends BaseVideoParser {
     }
   }
 
+  private pushParameterSet(
+    parameterSets: Uint8Array[],
+    data: Uint8Array,
+    vps: Uint8Array[] | undefined,
+  ) {
+    if ((vps && vps[0] === this.initVPS) || (!vps && !parameterSets.length)) {
+      parameterSets.push(data);
+    }
+  }
+
   protected getNALuType(data: Uint8Array, offset: number): number {
     return (data[offset] & 0x7e) >>> 1;
   }

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)