hls.js 1.5.14-0.canary.10567 → 1.5.14-0.canary.10570

package/dist/hls.mjs

@@ -421,7 +421,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.5.14-0.canary.10567"}`);
+      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.5.14-0.canary.10570"}`);
     } catch (e) {
       /* log fn threw an exception. All logger methods are no-ops. */
       return createLogger();
@@ -1365,6 +1365,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.
@@ -2703,6 +2724,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) {
@@ -2712,25 +2735,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:
@@ -11070,7 +11079,7 @@ function concatUint8Arrays(chunks, dataLength) {
   return result;
 }
 
-const version = "1.5.14-0.canary.10567";
+const version = "1.5.14-0.canary.10570";
 
 // ensure the worker ends up in the bundle
 // If the worker should not be included this gets aliased to empty.js
@@ -11388,23 +11397,11 @@ const initPTSFn = (timestamp, timeOffset, initPTS) => {
   return timeOffset * 90000 + init90kHz;
 };
 
-/**
- * ADTS parser helper
- * @link https://wiki.multimedia.cx/index.php?title=ADTS
- */
-function getAudioConfig(observer, data, offset, audioCodec) {
-  let adtsObjectType;
-  let originalAdtsObjectType;
-  let adtsExtensionSamplingIndex;
-  let adtsChannelConfig;
-  let config;
-  const userAgent = navigator.userAgent.toLowerCase();
-  const manifestCodec = audioCodec;
+function getAudioConfig(observer, data, offset, manifestCodec) {
   const adtsSamplingRates = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
-  // byte 2
-  adtsObjectType = originalAdtsObjectType = ((data[offset + 2] & 0xc0) >>> 6) + 1;
-  const adtsSamplingIndex = (data[offset + 2] & 0x3c) >>> 2;
-  if (adtsSamplingIndex > adtsSamplingRates.length - 1) {
+  const byte2 = data[offset + 2];
+  const adtsSamplingIndex = byte2 >> 2 & 0xf;
+  if (adtsSamplingIndex > 12) {
     const error = new Error(`invalid ADTS sampling index:${adtsSamplingIndex}`);
     observer.emit(Events.ERROR, Events.ERROR, {
       type: ErrorTypes.MEDIA_ERROR,
@@ -11415,53 +11412,12 @@ function getAudioConfig(observer, data, offset, audioCodec) {
     });
     return;
   }
-  adtsChannelConfig = (data[offset + 2] & 0x01) << 2;
-  // byte 3
-  adtsChannelConfig |= (data[offset + 3] & 0xc0) >>> 6;
-  logger.log(`manifest codec:${audioCodec}, ADTS type:${adtsObjectType}, samplingIndex:${adtsSamplingIndex}`);
-  // Firefox and Pale Moon: freq less than 24kHz = AAC SBR (HE-AAC)
-  if (/firefox|palemoon/i.test(userAgent)) {
-    if (adtsSamplingIndex >= 6) {
-      adtsObjectType = 5;
-      config = new Array(4);
-      // HE-AAC uses SBR (Spectral Band Replication) , high frequencies are constructed from low frequencies
-      // there is a factor 2 between frame sample rate and output sample rate
-      // multiply frequency by 2 (see table below, equivalent to substract 3)
-      adtsExtensionSamplingIndex = adtsSamplingIndex - 3;
-    } else {
-      adtsObjectType = 2;
-      config = new Array(2);
-      adtsExtensionSamplingIndex = adtsSamplingIndex;
-    }
-    // Android : always use AAC
-  } else if (userAgent.indexOf('android') !== -1) {
-    adtsObjectType = 2;
-    config = new Array(2);
-    adtsExtensionSamplingIndex = adtsSamplingIndex;
-  } else {
-    /*  for other browsers (Chrome/Vivaldi/Opera ...)
-        always force audio type to be HE-AAC SBR, as some browsers do not support audio codec switch properly (like Chrome ...)
-    */
-    adtsObjectType = 5;
-    config = new Array(4);
-    // if (manifest codec is HE-AAC or HE-AACv2) OR (manifest codec not specified AND frequency less than 24kHz)
-    if (audioCodec && (audioCodec.indexOf('mp4a.40.29') !== -1 || audioCodec.indexOf('mp4a.40.5') !== -1) || !audioCodec && adtsSamplingIndex >= 6) {
-      // HE-AAC uses SBR (Spectral Band Replication) , high frequencies are constructed from low frequencies
-      // there is a factor 2 between frame sample rate and output sample rate
-      // multiply frequency by 2 (see table below, equivalent to substract 3)
-      adtsExtensionSamplingIndex = adtsSamplingIndex - 3;
-    } else {
-      // if (manifest codec is AAC) AND (frequency less than 24kHz AND nb channel is 1) OR (manifest codec not specified and mono audio)
-      // Chrome fails to play back with low frequency AAC LC mono when initialized with HE-AAC.  This is not a problem with stereo.
-      if (audioCodec && audioCodec.indexOf('mp4a.40.2') !== -1 && (adtsSamplingIndex >= 6 && adtsChannelConfig === 1 || /vivaldi/i.test(userAgent)) || !audioCodec && adtsChannelConfig === 1) {
-        adtsObjectType = 2;
-        config = new Array(2);
-      }
-      adtsExtensionSamplingIndex = adtsSamplingIndex;
-    }
-  }
+  // MPEG-4 Audio Object Type (profile_ObjectType+1)
+  const adtsObjectType = (byte2 >> 6 & 0x3) + 1;
+  const channelCount = data[offset + 3] >> 6 & 0x3 | (byte2 & 1) << 2;
+  const codec = 'mp4a.40.' + adtsObjectType;
   /* refer to http://wiki.multimedia.cx/index.php?title=MPEG-4_Audio#Audio_Specific_Config
-      ISO 14496-3 (AAC).pdf - Table 1.13 — Syntax of AudioSpecificConfig()
+      ISO/IEC 14496-3 - Table 1.13 — Syntax of AudioSpecificConfig()
     Audio Profile / Audio Object Type
     0: Null
     1: AAC Main
@@ -11494,27 +11450,22 @@ function getAudioConfig(observer, data, offset, audioCodec) {
     2: 2 channels: front-left, front-right
   */
   // audioObjectType = profile => profile, the MPEG-4 Audio Object Type minus 1
-  config[0] = adtsObjectType << 3;
-  // samplingFrequencyIndex
-  config[0] |= (adtsSamplingIndex & 0x0e) >> 1;
-  config[1] |= (adtsSamplingIndex & 0x01) << 7;
-  // channelConfiguration
-  config[1] |= adtsChannelConfig << 3;
-  if (adtsObjectType === 5) {
-    // adtsExtensionSamplingIndex
-    config[1] |= (adtsExtensionSamplingIndex & 0x0e) >> 1;
-    config[2] = (adtsExtensionSamplingIndex & 0x01) << 7;
-    // adtsObjectType (force to 2, chrome is checking that object type is less than 5 ???
-    //    https://chromium.googlesource.com/chromium/src.git/+/master/media/formats/mp4/aac.cc
-    config[2] |= 2 << 2;
-    config[3] = 0;
-  }
+  const samplerate = adtsSamplingRates[adtsSamplingIndex];
+  let aacSampleIndex = adtsSamplingIndex;
+  if (adtsObjectType === 5 || adtsObjectType === 29) {
+    // HE-AAC uses SBR (Spectral Band Replication) , high frequencies are constructed from low frequencies
+    // there is a factor 2 between frame sample rate and output sample rate
+    // multiply frequency by 2 (see table above, equivalent to substract 3)
+    aacSampleIndex -= 3;
+  }
+  const config = [adtsObjectType << 3 | (aacSampleIndex & 0x0e) >> 1, (aacSampleIndex & 0x01) << 7 | channelCount << 3];
+  logger.log(`manifest codec:${manifestCodec}, parsed codec:${codec}, channels:${channelCount}, rate:${samplerate} (ADTS object type:${adtsObjectType} sampling index:${adtsSamplingIndex})`);
   return {
     config,
-    samplerate: adtsSamplingRates[adtsSamplingIndex],
-    channelCount: adtsChannelConfig,
-    codec: 'mp4a.40.' + adtsObjectType,
-    parsedCodec: 'mp4a.40.' + originalAdtsObjectType,
+    samplerate,
+    channelCount,
+    codec,
+    parsedCodec: codec,
     manifestCodec
   };
 }
@@ -11564,13 +11515,7 @@ function initTrackConfig(track, observer, data, offset, audioCodec) {
     if (!config) {
       return;
     }
-    track.config = config.config;
-    track.samplerate = config.samplerate;
-    track.channelCount = config.channelCount;
-    track.codec = config.codec;
-    track.manifestCodec = config.manifestCodec;
-    track.parsedCodec = config.parsedCodec;
-    logger.log(`parsed codec:${track.parsedCodec}, codec:${track.codec}, rate:${config.samplerate}, channels:${config.channelCount}`);
+    _extends(track, config);
   }
 }
 function getFrameDuration(samplerate) {
@@ -14736,7 +14681,7 @@ class MP4 {
     vSpacing >> 16 & 0xff, vSpacing >> 8 & 0xff, vSpacing & 0xff])));
   }
   static esds(track) {
-    const configlen = track.config.length;
+    const config = track.config;
     return new Uint8Array([0x00,
     // version 0
     0x00, 0x00, 0x00,
@@ -14744,16 +14689,18 @@ class MP4 {
 
     0x03,
     // descriptor_type
-    0x17 + configlen,
+    0x19,
     // length
+
     0x00, 0x01,
     // es_id
+
     0x00,
     // stream_priority
 
     0x04,
     // descriptor_type
-    0x0f + configlen,
+    0x11,
     // length
     0x40,
     // codec : mpeg4_audio
@@ -14766,8 +14713,12 @@ class MP4 {
     0x00, 0x00, 0x00, 0x00,
     // avgBitrate
 
-    0x05 // descriptor_type
-    ].concat([configlen]).concat(track.config).concat([0x06, 0x01, 0x02])); // GASpecificConfig)); // length + audio config descriptor
+    0x05,
+    // descriptor_type
+    0x02,
+    // length
+    ...config, 0x06, 0x01, 0x02 // GASpecificConfig)); // length + audio config descriptor
+    ]);
   }
   static audioStsd(track) {
     const samplerate = track.samplerate;
@@ -23626,7 +23577,7 @@ class EMEController extends Logger {
       }
       let keyId;
       let keySystemDomain;
-      if (initDataType === 'sinf' && this.config.drmSystems[KeySystems.FAIRPLAY]) {
+      if (initDataType === 'sinf' && this.getLicenseServerUrl(KeySystems.FAIRPLAY)) {
         // Match sinf keyId to playlist skd://keyId=
         const json = bin2str(new Uint8Array(initData));
         try {
@@ -23641,10 +23592,19 @@ class EMEController extends Logger {
           this.warn(`${logMessage} Failed to parse sinf: ${error}`);
           return;
         }
-      } else {
+      } else if (this.getLicenseServerUrl(KeySystems.WIDEVINE)) {
         // 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];
+
+        // TODO: If using keySystemAccessPromises we might want to wait until one is resolved
+        let keySystems = Object.keys(this.keySystemAccessPromises);
+        if (!keySystems.length) {
+          keySystems = getKeySystemsForConfig(this.config);
+        }
+        const psshInfo = psshResults.filter(pssh => {
+          const keySystem = pssh.systemId ? keySystemIdToKeySystemDomain(pssh.systemId) : null;
+          return keySystem ? keySystems.indexOf(keySystem) > -1 : false;
+        })[0];
         if (!psshInfo) {
           if (psshResults.length === 0 || psshResults.some(pssh => !pssh.systemId)) {
             this.warn(`${logMessage} contains incomplete or invalid pssh data`);
@@ -23655,8 +23615,12 @@ class EMEController extends Logger {
         }
         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 === 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) {
@@ -23760,7 +23724,13 @@ class EMEController extends Logger {
     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 {
@@ -24288,7 +24258,7 @@ class EMEController extends Logger {
   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';