shaka-player 4.12.8 → 4.13.0

package/lib/{util → drm}/drm_utils.js

@@ -4,13 +4,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-goog.provide('shaka.util.DrmUtils');
+goog.provide('shaka.drm.DrmUtils');
 
 goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.Lazy');
 
 
-shaka.util.DrmUtils = class {
+shaka.drm.DrmUtils = class {
   /**
    * Returns true if the browser has recent EME APIs.
    *
@@ -45,7 +45,7 @@ shaka.util.DrmUtils = class {
       return true;
     }
 
-    return shaka.util.DrmUtils.getCommonDrmInfos(
+    return shaka.drm.DrmUtils.getCommonDrmInfos(
         drms1, drms2).length > 0;
   }
 
@@ -108,7 +108,8 @@ shaka.util.DrmUtils = class {
 
   /**
    * @param {?shaka.extern.DrmInfo} drmInfo
-   * @return {string} */
+   * @return {string}
+   */
   static keySystem(drmInfo) {
     return drmInfo ? drmInfo.keySystem : '';
   }
@@ -157,6 +158,14 @@ shaka.util.DrmUtils = class {
     return false;
   }
 
+  /**
+   * @param {?string} keySystem
+   * @return {boolean}
+   */
+  static isWisePlayKeySystem(keySystem) {
+    return keySystem === 'com.huawei.wiseplay';
+  }
+
   /**
    * A method for generating a key for the MediaKeySystemAccessRequests cache.
    *
@@ -180,7 +189,7 @@ shaka.util.DrmUtils = class {
    * @return {boolean}
    */
   static hasMediaKeySystemAccess(videoCodec, audioCodec, keySystem) {
-    const DrmUtils = shaka.util.DrmUtils;
+    const DrmUtils = shaka.drm.DrmUtils;
     const key = DrmUtils.generateKeySystemCacheKey_(
         videoCodec, audioCodec, keySystem);
     return DrmUtils.memoizedMediaKeySystemAccessRequests_.has(key);
@@ -195,7 +204,7 @@ shaka.util.DrmUtils = class {
    * @return {?MediaKeySystemAccess}
    */
   static getMediaKeySystemAccess(videoCodec, audioCodec, keySystem) {
-    const DrmUtils = shaka.util.DrmUtils;
+    const DrmUtils = shaka.drm.DrmUtils;
     const key = DrmUtils.generateKeySystemCacheKey_(
         videoCodec, audioCodec, keySystem);
     return DrmUtils.memoizedMediaKeySystemAccessRequests_.get(key) || null;
@@ -210,17 +219,17 @@ shaka.util.DrmUtils = class {
    * @param {!MediaKeySystemAccess} mksa
    */
   static setMediaKeySystemAccess(videoCodec, audioCodec, keySystem, mksa) {
-    const DrmUtils = shaka.util.DrmUtils;
+    const DrmUtils = shaka.drm.DrmUtils;
     const key = DrmUtils.generateKeySystemCacheKey_(
         videoCodec, audioCodec, keySystem);
-    return DrmUtils.memoizedMediaKeySystemAccessRequests_.set(key, mksa);
+    DrmUtils.memoizedMediaKeySystemAccessRequests_.set(key, mksa);
   }
 
   /**
    * Clears underlying cache.
    */
   static clearMediaKeySystemAccessMap() {
-    const DrmUtils = shaka.util.DrmUtils;
+    const DrmUtils = shaka.drm.DrmUtils;
     DrmUtils.memoizedMediaKeySystemAccessRequests_.clear();
   }
 };
@@ -231,7 +240,7 @@ shaka.util.DrmUtils = class {
  * 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.drm.DrmUtils.DUMMY_KEY_ID = new shaka.util.Lazy(
     () => shaka.util.BufferUtils.toArrayBuffer(new Uint8Array([0])));
 
 
@@ -242,4 +251,4 @@ shaka.util.DrmUtils.DUMMY_KEY_ID = new shaka.util.Lazy(
  *
  * @private {!Map<string, !MediaKeySystemAccess>}
  */
-shaka.util.DrmUtils.memoizedMediaKeySystemAccessRequests_ = new Map();
+shaka.drm.DrmUtils.memoizedMediaKeySystemAccessRequests_ = new Map();

package/lib/drm/playready.js

@@ -0,0 +1,233 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.drm.PlayReady');
+
+goog.require('shaka.log');
+goog.require('shaka.util.BufferUtils');
+goog.require('shaka.util.StringUtils');
+goog.require('shaka.util.TXml');
+goog.require('shaka.util.Uint8ArrayUtils');
+
+
+/**
+ * @summary A set of functions for parsing Microsoft Playready Objects.
+ */
+shaka.drm.PlayReady = class {
+  /**
+   * Parses an Array buffer starting at byteOffset for PlayReady Object Records.
+   * Each PRO Record is preceded by its PlayReady Record type and length in
+   * bytes.
+   *
+   * PlayReady Object Record format: https://goo.gl/FTcu46
+   *
+   * @param {!DataView} view
+   * @param {number} byteOffset
+   * @return {!Array<shaka.drm.PlayReady.PlayReadyRecord>}
+   * @private
+   */
+  static parseMsProRecords_(view, byteOffset) {
+    const records = [];
+
+    while (byteOffset < view.byteLength - 1) {
+      const type = view.getUint16(byteOffset, true);
+      byteOffset += 2;
+
+      const byteLength = view.getUint16(byteOffset, true);
+      byteOffset += 2;
+
+      if ((byteLength & 1) != 0 || byteLength + byteOffset > view.byteLength) {
+        shaka.log.warning('Malformed MS PRO object');
+        return [];
+      }
+
+      const recordValue = shaka.util.BufferUtils.toUint8(
+          view, byteOffset, byteLength);
+      records.push({
+        type: type,
+        value: recordValue,
+      });
+
+      byteOffset += byteLength;
+    }
+
+    return records;
+  }
+
+  /**
+   * Parses a buffer for PlayReady Objects.  The data
+   * should contain a 32-bit integer indicating the length of
+   * the PRO in bytes.  Following that, a 16-bit integer for
+   * the number of PlayReady Object Records in the PRO.  Lastly,
+   * a byte array of the PRO Records themselves.
+   *
+   * PlayReady Object format: https://goo.gl/W8yAN4
+   *
+   * @param {BufferSource} data
+   * @return {!Array<shaka.drm.PlayReady.PlayReadyRecord>}
+   * @private
+   */
+  static parseMsPro_(data) {
+    let byteOffset = 0;
+    const view = shaka.util.BufferUtils.toDataView(data);
+
+    // First 4 bytes is the PRO length (DWORD)
+    const byteLength = view.getUint32(byteOffset, /* littleEndian= */ true);
+    byteOffset += 4;
+
+    if (byteLength != data.byteLength) {
+      // Malformed PRO
+      shaka.log.warning('PlayReady Object with invalid length encountered.');
+      return [];
+    }
+
+    // Skip PRO Record count (WORD)
+    byteOffset += 2;
+
+    // Rest of the data contains the PRO Records
+    return shaka.drm.PlayReady.parseMsProRecords_(view, byteOffset);
+  }
+
+  /**
+   * PlayReady Header format: https://goo.gl/dBzxNA
+   *
+   * @param {!shaka.extern.xml.Node} xml
+   * @return {string}
+   * @private
+   */
+  static getLaurl_(xml) {
+    const TXml = shaka.util.TXml;
+    // LA_URL element is optional and no more than one is
+    // allowed inside the DATA element. Only absolute URLs are allowed.
+    // If the LA_URL element exists, it must not be empty.
+    for (const elem of TXml.getElementsByTagName(xml, 'DATA')) {
+      if (elem.children) {
+        for (const child of elem.children) {
+          if (child.tagName == 'LA_URL') {
+            return /** @type {string} */(
+              shaka.util.TXml.getTextContents(child));
+          }
+        }
+      }
+    }
+
+    // Not found
+    return '';
+  }
+
+  /**
+   * Gets a PlayReady Header Object
+   *
+   * @param {!shaka.extern.xml.Node} element
+   * @return {?shaka.extern.xml.Node}
+   * @private
+   */
+  static getPlayReadyHeaderObject_(element) {
+    const PLAYREADY_RECORD_TYPES = shaka.drm.PlayReady.PLAYREADY_RECORD_TYPES;
+
+    const bytes = shaka.util.Uint8ArrayUtils.fromBase64(
+        /** @type {string} */ (shaka.util.TXml.getTextContents(element)));
+    const records = shaka.drm.PlayReady.parseMsPro_(bytes);
+    const record = records.filter((record) => {
+      return record.type === PLAYREADY_RECORD_TYPES.RIGHTS_MANAGEMENT;
+    })[0];
+
+    if (!record) {
+      return null;
+    }
+
+    const xml = shaka.util.StringUtils.fromUTF16(record.value, true);
+    const rootElement = shaka.util.TXml.parseXmlString(xml, 'WRMHEADER');
+    if (!rootElement) {
+      return null;
+    }
+    return rootElement;
+  }
+
+  /**
+   * Gets a PlayReady license URL from a PlayReady Header Object
+   *
+   * @param {!shaka.extern.xml.Node} element
+   * @return {string}
+   */
+  static getLicenseUrl(element) {
+    try {
+      const headerObject =
+          shaka.drm.PlayReady.getPlayReadyHeaderObject_(element);
+      if (!headerObject) {
+        return '';
+      }
+
+      return shaka.drm.PlayReady.getLaurl_(headerObject);
+    } catch (e) {
+      return '';
+    }
+  }
+
+  /**
+   * Gets a PlayReady KID from a protection element containing a
+   * PlayReady Header Object
+   *
+   * @param {!shaka.extern.xml.Node} element
+   * @return {?string}
+   */
+  static getPlayReadyKID(element) {
+    const rootElement = shaka.drm.PlayReady.getPlayReadyHeaderObject_(element);
+    if (!rootElement) {
+      return null;
+    }
+
+    const TXml = shaka.util.TXml;
+    // KID element is optional and no more than one is
+    // allowed inside the DATA element.
+    for (const elem of TXml.getElementsByTagName(rootElement, 'DATA')) {
+      const kid = TXml.findChild(elem, 'KID');
+      if (kid) {
+        // GUID: [DWORD, WORD, WORD, 8-BYTE]
+        const guidBytes =
+            shaka.util.Uint8ArrayUtils.fromBase64(
+                /** @type {string} */ (shaka.util.TXml.getTextContents(kid)));
+        // Reverse byte order from little-endian to big-endian
+        const kidBytes = new Uint8Array([
+          guidBytes[3], guidBytes[2], guidBytes[1], guidBytes[0],
+          guidBytes[5], guidBytes[4],
+          guidBytes[7], guidBytes[6],
+          ...guidBytes.slice(8),
+        ]);
+        return shaka.util.Uint8ArrayUtils.toHex(kidBytes);
+      }
+    }
+
+    // Not found
+    return null;
+  }
+};
+
+/**
+ * @typedef {{
+ *   type: number,
+ *   value: !Uint8Array
+ * }}
+ *
+ * @description
+ * The parsed result of a PlayReady object record.
+ *
+ * @property {number} type
+ *   Type of data stored in the record.
+ * @property {!Uint8Array} value
+ *   Record content.
+ */
+shaka.drm.PlayReady.PlayReadyRecord;
+
+/**
+ * Enum for PlayReady record types.
+ * @enum {number}
+ */
+shaka.drm.PlayReady.PLAYREADY_RECORD_TYPES = {
+  RIGHTS_MANAGEMENT: 0x001,
+  RESERVED: 0x002,
+  EMBEDDED_LICENSE: 0x003,
+};

package/lib/hls/hls_classes.js

@@ -20,17 +20,17 @@ goog.require('shaka.util.Error');
 shaka.hls.Playlist = class {
   /**
    * @param {!shaka.hls.PlaylistType} type
-   * @param {!Array.<shaka.hls.Tag>} tags
-   * @param {!Array.<shaka.hls.Segment>=} segments
+   * @param {!Array<shaka.hls.Tag>} tags
+   * @param {!Array<shaka.hls.Segment>=} segments
    */
   constructor(type, tags, segments) {
     /** @const {shaka.hls.PlaylistType} */
     this.type = type;
 
-    /** @const {!Array.<!shaka.hls.Tag>} */
+    /** @const {!Array<!shaka.hls.Tag>} */
     this.tags = tags;
 
-    /** @const {Array.<!shaka.hls.Segment>} */
+    /** @const {Array<!shaka.hls.Segment>} */
     this.segments = segments || null;
   }
 };
@@ -52,7 +52,7 @@ shaka.hls.Tag = class {
   /**
    * @param {number} id
    * @param {string} name
-   * @param {!Array.<shaka.hls.Attribute>} attributes
+   * @param {!Array<shaka.hls.Attribute>} attributes
    * @param {?string=} value
    */
   constructor(id, name, attributes, value = null) {
@@ -62,7 +62,7 @@ shaka.hls.Tag = class {
     /** @type {string} */
     this.name = name;
 
-    /** @const {!Array.<shaka.hls.Attribute>} */
+    /** @const {!Array<shaka.hls.Attribute>} */
     this.attributes = attributes;
 
     /** @const {?string} */
@@ -78,7 +78,7 @@ shaka.hls.Tag = class {
    * As in some cases (like in tests) the tag never existed in string form, it
    * is far easier to recreate the tag from the parsed form.
    *
-   * @param {?Set.<string>=} attributesToSkip
+   * @param {?Set<string>=} attributesToSkip
    * @return {string}
    * @override
    */
@@ -120,11 +120,11 @@ shaka.hls.Tag = class {
   /**
    * Create the string key of the tag.
    *
-   * @param {boolean} keepAllAtributtes
+   * @param {boolean} keepAllAttributes
    * @return {string}
    */
-  getTagKey(keepAllAtributtes) {
-    if (keepAllAtributtes) {
+  getTagKey(keepAllAttributes) {
+    if (keepAllAttributes) {
       return this.toString();
     }
     const attributesToSkip = new Set()
@@ -221,17 +221,17 @@ shaka.hls.Segment = class {
    * Creates an HLS segment object.
    *
    * @param {string} verbatimSegmentUri verbatim segment URI.
-   * @param {!Array.<shaka.hls.Tag>} tags
-   * @param {!Array.<shaka.hls.Tag>=} partialSegments
+   * @param {!Array<shaka.hls.Tag>} tags
+   * @param {!Array<shaka.hls.Tag>=} partialSegments
    */
   constructor(verbatimSegmentUri, tags, partialSegments=[]) {
-    /** @const {!Array.<shaka.hls.Tag>} */
+    /** @const {!Array<shaka.hls.Tag>} */
     this.tags = tags;
 
     /** @const {?string} */
     this.verbatimSegmentUri = verbatimSegmentUri;
 
-    /** @type {!Array.<shaka.hls.Tag>} */
+    /** @type {!Array<shaka.hls.Tag>} */
     this.partialSegments = partialSegments;
   }
 };