shaka-player 4.9.12 → 4.9.13

package/lib/util/drm_utils.js

@@ -6,8 +6,113 @@
 
 goog.provide('shaka.util.DrmUtils');
 
+goog.require('shaka.util.BufferUtils');
+goog.require('shaka.util.Lazy');
+
 
 shaka.util.DrmUtils = class {
+  /**
+   * Returns true if the browser has recent EME APIs.
+   *
+   * @return {boolean}
+   */
+  static isBrowserSupported() {
+    const basic =
+        !!window.MediaKeys &&
+        !!window.navigator &&
+        !!window.navigator.requestMediaKeySystemAccess &&
+        !!window.MediaKeySystemAccess &&
+        // eslint-disable-next-line no-restricted-syntax
+        !!window.MediaKeySystemAccess.prototype.getConfiguration;
+
+    return basic;
+  }
+
+  /**
+   * Checks if two DrmInfos can be decrypted using the same key system.
+   * Clear content is considered compatible with every key system.
+   *
+   * @param {!Array<!shaka.extern.DrmInfo>} drms1
+   * @param {!Array<!shaka.extern.DrmInfo>} drms2
+   * @return {boolean}
+   */
+  static areDrmCompatible(drms1, drms2) {
+    if (!drms1.length || !drms2.length) {
+      return true;
+    }
+
+    if (drms1 === drms2) {
+      return true;
+    }
+
+    return shaka.util.DrmUtils.getCommonDrmInfos(
+        drms1, drms2).length > 0;
+  }
+
+  /**
+   * Returns an array of drm infos that are present in both input arrays.
+   * If one of the arrays is empty, returns the other one since clear
+   * content is considered compatible with every drm info.
+   *
+   * @param {!Array<!shaka.extern.DrmInfo>} drms1
+   * @param {!Array<!shaka.extern.DrmInfo>} drms2
+   * @return {!Array<!shaka.extern.DrmInfo>}
+   */
+  static getCommonDrmInfos(drms1, drms2) {
+    if (!drms1.length) {
+      return drms2;
+    }
+    if (!drms2.length) {
+      return drms1;
+    }
+
+    const commonDrms = [];
+
+    for (const drm1 of drms1) {
+      for (const drm2 of drms2) {
+        if (drm1.keySystem == drm2.keySystem) {
+          const initDataMap = new Map();
+          const bothInitDatas = (drm1.initData || [])
+              .concat(drm2.initData || []);
+          for (const d of bothInitDatas) {
+            initDataMap.set(d.keyId, d);
+          }
+          const initData = Array.from(initDataMap.values());
+
+          const keyIds = drm1.keyIds && drm2.keyIds ?
+              new Set([...drm1.keyIds, ...drm2.keyIds]) :
+              drm1.keyIds || drm2.keyIds;
+          const mergedDrm = {
+            keySystem: drm1.keySystem,
+            licenseServerUri: drm1.licenseServerUri || drm2.licenseServerUri,
+            distinctiveIdentifierRequired: drm1.distinctiveIdentifierRequired ||
+                drm2.distinctiveIdentifierRequired,
+            persistentStateRequired: drm1.persistentStateRequired ||
+                drm2.persistentStateRequired,
+            videoRobustness: drm1.videoRobustness || drm2.videoRobustness,
+            audioRobustness: drm1.audioRobustness || drm2.audioRobustness,
+            serverCertificate: drm1.serverCertificate || drm2.serverCertificate,
+            serverCertificateUri: drm1.serverCertificateUri ||
+                drm2.serverCertificateUri,
+            initData,
+            keyIds,
+          };
+          commonDrms.push(mergedDrm);
+          break;
+        }
+      }
+    }
+
+    return commonDrms;
+  }
+
+  /**
+   * @param {?shaka.extern.DrmInfo} drmInfo
+   * @return {string} */
+  static keySystem(drmInfo) {
+    return drmInfo ? drmInfo.keySystem : '';
+  }
+
   /**
    * @param {?string} keySystem
    * @return {boolean}
@@ -31,4 +136,90 @@ shaka.util.DrmUtils = class {
 
     return false;
   }
+
+  /**
+   * A method for generating a key for the MediaKeySystemAccessRequests cache.
+   *
+   * @param {string} videoCodec
+   * @param {string} audioCodec
+   * @param {string} keySystem
+   * @return {string}
+   * @private
+   */
+  static generateKeySystemCacheKey_(videoCodec, audioCodec, keySystem) {
+    return `${videoCodec}#${audioCodec}#${keySystem}`;
+  }
+
+  /**
+   * Check does MediaKeySystemAccess cache contains something for following
+   * attributes.
+   *
+   * @param {string} videoCodec
+   * @param {string} audioCodec
+   * @param {string} keySystem
+   * @return {boolean}
+   */
+  static hasMediaKeySystemAccess(videoCodec, audioCodec, keySystem) {
+    const DrmUtils = shaka.util.DrmUtils;
+    const key = DrmUtils.generateKeySystemCacheKey_(
+        videoCodec, audioCodec, keySystem);
+    return DrmUtils.memoizedMediaKeySystemAccessRequests_.has(key);
+  }
+
+  /**
+   * Get MediaKeySystemAccess object for following attributes.
+   *
+   * @param {string} videoCodec
+   * @param {string} audioCodec
+   * @param {string} keySystem
+   * @return {?MediaKeySystemAccess}
+   */
+  static getMediaKeySystemAccess(videoCodec, audioCodec, keySystem) {
+    const DrmUtils = shaka.util.DrmUtils;
+    const key = DrmUtils.generateKeySystemCacheKey_(
+        videoCodec, audioCodec, keySystem);
+    return DrmUtils.memoizedMediaKeySystemAccessRequests_.get(key) || null;
+  }
+
+  /**
+   * Store MediaKeySystemAccess object associated with specified attributes.
+   *
+   * @param {string} videoCodec
+   * @param {string} audioCodec
+   * @param {string} keySystem
+   * @param {!MediaKeySystemAccess} mksa
+   */
+  static setMediaKeySystemAccess(videoCodec, audioCodec, keySystem, mksa) {
+    const DrmUtils = shaka.util.DrmUtils;
+    const key = DrmUtils.generateKeySystemCacheKey_(
+        videoCodec, audioCodec, keySystem);
+    return DrmUtils.memoizedMediaKeySystemAccessRequests_.set(key, mksa);
+  }
+
+  /**
+   * Clears underlying cache.
+   */
+  static clearMediaKeySystemAccessMap() {
+    const DrmUtils = shaka.util.DrmUtils;
+    DrmUtils.memoizedMediaKeySystemAccessRequests_.clear();
+  }
 };
+
+
+/**
+ * Contains the suggested "default" key ID used by EME polyfills that do not
+ * have a per-key key status. See w3c/encrypted-media#32.
+ * @type {!shaka.util.Lazy<!ArrayBuffer>}
+ */
+shaka.util.DrmUtils.DUMMY_KEY_ID = new shaka.util.Lazy(
+    () => shaka.util.BufferUtils.toArrayBuffer(new Uint8Array([0])));
+
+
+/**
+ * A cache that stores the MediaKeySystemAccess result of calling
+ * `navigator.requestMediaKeySystemAccess` by a key combination of
+ * video/audio codec and key system string.
+ *
+ * @private {!Map<string, !MediaKeySystemAccess>}
+ */
+shaka.util.DrmUtils.memoizedMediaKeySystemAccessRequests_ = new Map();

package/lib/util/periods.js

@@ -8,9 +8,9 @@ goog.provide('shaka.util.PeriodCombiner');
 
 goog.require('goog.asserts');
 goog.require('shaka.log');
-goog.require('shaka.media.DrmEngine');
 goog.require('shaka.media.MetaSegmentIndex');
 goog.require('shaka.media.SegmentIndex');
+goog.require('shaka.util.DrmUtils');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.IReleasable');
 goog.require('shaka.util.LanguageUtils');
@@ -282,7 +282,7 @@ shaka.util.PeriodCombiner = class {
     } else {
       for (const audio of this.audioStreams_) {
         for (const video of this.videoStreams_) {
-          const commonDrmInfos = shaka.media.DrmEngine.getCommonDrmInfos(
+          const commonDrmInfos = shaka.util.DrmUtils.getCommonDrmInfos(
               audio.drmInfos, video.drmInfos);
 
           if (audio.drmInfos.length && video.drmInfos.length &&
@@ -855,7 +855,7 @@ shaka.util.PeriodCombiner = class {
       output.originalId += ',' + (input.originalId || '');
     }
 
-    const commonDrmInfos = shaka.media.DrmEngine.getCommonDrmInfos(
+    const commonDrmInfos = shaka.util.DrmUtils.getCommonDrmInfos(
         output.drmInfos, input.drmInfos);
     if (input.drmInfos.length && output.drmInfos.length &&
         !commonDrmInfos.length) {
@@ -1115,7 +1115,7 @@ shaka.util.PeriodCombiner = class {
     if (outputStream.drmInfos) {
       // Check for compatible DRM systems.  Note that clear streams are
       // implicitly compatible with any DRM and with each other.
-      if (!shaka.media.DrmEngine.areDrmCompatible(outputStream.drmInfos,
+      if (!shaka.util.DrmUtils.areDrmCompatible(outputStream.drmInfos,
           candidate.drmInfos)) {
         return false;
       }

package/lib/util/ts_parser.js

@@ -726,7 +726,7 @@ shaka.util.TsParser = class {
   }
 
   /**
-   * Return the audio data
+   * Return the video data
    *
    * @param {boolean=} naluProcessing
    * @return {!Array.<shaka.extern.MPEG_PES>}
@@ -760,15 +760,15 @@ shaka.util.TsParser = class {
       if (naluProcessing) {
         let lastNalu;
         let lastState;
+        const pesWithLength = [];
         for (const pes of this.videoPes_) {
           pes.nalus = this.parseNalus(pes, lastNalu, lastState);
           if (pes.nalus.length) {
+            pesWithLength.push(pes);
             lastNalu = pes.nalus[pes.nalus.length - 1];
           }
         }
-        this.videoPes_ = this.videoPes_.filter((pes) => {
-          return pes.nalus.length;
-        });
+        this.videoPes_ = pesWithLength;
       }
       if (sort) {
         this.videoPes_ = this.videoPes_.sort((a, b) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shaka-player",
   "description": "DASH/EME video player library",
-  "version": "4.9.12",
+  "version": "4.9.13",
   "homepage": "https://github.com/shaka-project/shaka-player",
   "author": "Google",
   "maintainers": [

package/ui/statistics_button.js

@@ -229,8 +229,11 @@ shaka.ui.StatisticsButton = class extends shaka.ui.Element {
   loadContainer_() {
     for (const name of this.controls.getConfig().statisticsList) {
       if (name in this.currentStats_ && !this.skippedStats_.includes(name)) {
-        this.container_.appendChild(this.generateComponent_(name));
+        const element = this.generateComponent_(name);
+        this.container_.appendChild(element);
         this.statisticsList_.push(name);
+        shaka.ui.Utils.setDisplay(element.parentElement,
+            !isNaN(this.currentStats_[name]));
       } else {
         shaka.log.alwaysWarn('Unrecognized statistic element:', name);
       }
@@ -242,8 +245,12 @@ shaka.ui.StatisticsButton = class extends shaka.ui.Element {
     this.currentStats_ = this.player.getStats();
 
     for (const name of this.statisticsList_) {
-      this.displayedElements_[name].textContent =
-          this.parseFrom_[name](name);
+      const element = this.displayedElements_[name];
+      element.textContent = this.parseFrom_[name](name);
+      if (element && element.parentElement) {
+        shaka.ui.Utils.setDisplay(element.parentElement,
+            !isNaN(this.currentStats_[name]));
+      }
     }
   }