Source: lib/dash/content_protection.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.dash.ContentProtection');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.log');
  22. goog.require('shaka.util.Error');
  23. goog.require('shaka.util.Functional');
  24. goog.require('shaka.util.ManifestParserUtils');
  25. goog.require('shaka.util.MapUtils');
  26. goog.require('shaka.util.Uint8ArrayUtils');
  27. goog.require('shaka.util.XmlUtils');
  30. /**
  31.  * @namespace shaka.dash.ContentProtection
  32.  * @summary A set of functions for parsing and interpreting ContentProtection
  33.  *   elements.
  34.  */
  37. /**
  38.  * @typedef {{
  39.  *   defaultKeyId: ?string,
  40.  *   defaultInit: Array.<shakaExtern.InitDataOverride>,
  41.  *   drmInfos: !Array.<shakaExtern.DrmInfo>,
  42.  *   firstRepresentation: boolean
  43.  * }}
  44.  *
  45.  * @description
  46.  * Contains information about the ContentProtection elements found at the
  47.  * AdaptationSet level.
  48.  *
  49.  * @property {?string} defaultKeyId
  50.  *   The default key ID to use.  This is used by parseKeyIds as a default.  This
  51.  *   can be null to indicate that there is no default.
  52.  * @property {Array.<shakaExtern.InitDataOverride>} defaultInit
  53.  *   The default init data override.  This can be null to indicate that there
  54.  *   is no default.
  55.  * @property {!Array.<shakaExtern.DrmInfo>} drmInfos
  56.  *   The DrmInfo objects.
  57.  * @property {boolean} firstRepresentation
  58.  *   True when first parsed; changed to false after the first call to
  59.  *   parseKeyIds.  This is used to determine if a dummy key-system should be
  60.  *   overwritten; namely that the first representation can replace the dummy
  61.  *   from the AdaptationSet.
  62.  */
  63. shaka.dash.ContentProtection.Context;
  66. /**
  67.  * @typedef {{
  68.  *   node: !Element,
  69.  *   schemeUri: string,
  70.  *   keyId: ?string,
  71.  *   init: Array.<shakaExtern.InitDataOverride>
  72.  * }}
  73.  *
  74.  * @description
  75.  * The parsed result of a single ContentProtection element.
  76.  *
  77.  * @property {!Element} node
  78.  *   The ContentProtection XML element.
  79.  * @property {string} schemeUri
  80.  *   The scheme URI.
  81.  * @property {?string} keyId
  82.  *   The default key ID, if present.
  83.  * @property {Array.<shakaExtern.InitDataOverride>} init
  84.  *   The init data, if present.  If there is no init data, it will be null.  If
  85.  *   this is non-null, there is at least one element.
  86.  */
  87. shaka.dash.ContentProtection.Element;
  90. /**
  91.  * A map of scheme URI to key system name.
  92.  *
  93.  * @const {!Object.<string, string>}
  94.  * @private
  95.  */
  96. shaka.dash.ContentProtection.defaultKeySystems_ = {
  97.   'urn:uuid:1077efec-c0b2-4d02-ace3-3c1e52e2fb4b': 'org.w3.clearkey',
  98.   'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed': 'com.widevine.alpha',
  99.   'urn:uuid:9a04f079-9840-4286-ab92-e65be0885f95': 'com.microsoft.playready',
  100.   'urn:uuid:f239e769-efa3-4850-9c16-a903c6932efb': 'com.adobe.primetime'
  101. };
  104. /**
  105.  * @const {string}
  106.  * @private
  107.  */
  108. shaka.dash.ContentProtection.MP4Protection_ =
  109.     'urn:mpeg:dash:mp4protection:2011';
  112. /**
  113.  * @const {string}
  114.  * @private
  115.  */
  116. shaka.dash.ContentProtection.CencNamespaceUri_ = 'urn:mpeg:cenc:2013';
  119. /**
  120.  * Parses info from the ContentProtection elements at the AdaptationSet level.
  121.  *
  122.  * @param {!Array.<!Element>} elems
  123.  * @param {shakaExtern.DashContentProtectionCallback} callback
  124.  * @param {boolean} ignoreDrmInfo
  125.  * @return {shaka.dash.ContentProtection.Context}
  126.  */
  127. shaka.dash.ContentProtection.parseFromAdaptationSet = function(
  128.     elems, callback, ignoreDrmInfo) {
  129.   const ContentProtection = shaka.dash.ContentProtection;
  130.   const Functional = shaka.util.Functional;
  131.   const MapUtils = shaka.util.MapUtils;
  132.   const ManifestParserUtils = shaka.util.ManifestParserUtils;
  133.   let parsed = ContentProtection.parseElements_(elems);
  134.   /** @type {Array.<shakaExtern.InitDataOverride>} */
  135.   let defaultInit = null;
  136.   /** @type {!Array.<shakaExtern.DrmInfo>} */
  137.   let drmInfos = [];
  138.   let parsedNonCenc = [];
  140.   // Get the default key ID; if there are multiple, they must all match.
  141.   let keyIds = parsed.map(function(elem) { return elem.keyId; })
  142.       .filter(Functional.isNotNull);
  143.   if (keyIds.length) {
  144.     if (keyIds.filter(Functional.isNotDuplicate).length > 1) {
  145.       throw new shaka.util.Error(
  146.           shaka.util.Error.Severity.CRITICAL,
  147.           shaka.util.Error.Category.MANIFEST,
  148.           shaka.util.Error.Code.DASH_CONFLICTING_KEY_IDS);
  149.     }
  150.   }
  152.   if (!ignoreDrmInfo) {
  153.     // Find the default key ID and init data.  Create a new array of all the
  154.     // non-CENC elements.
  155.     parsedNonCenc = parsed.filter(function(elem) {
  156.       if (elem.schemeUri == ContentProtection.MP4Protection_) {
  157.         goog.asserts.assert(!elem.init || elem.init.length,
  158.                             'Init data must be null or non-empty.');
  159.         defaultInit = elem.init || defaultInit;
  160.         return false;
  161.       } else {
  162.         return true;
  163.       }
  164.     });
  166.     if (parsedNonCenc.length) {
  167.       drmInfos = ContentProtection.convertElements_(
  168.           defaultInit, callback, parsedNonCenc);
  170.       // If there are no drmInfos after parsing, then add a dummy entry.
  171.       // This may be removed in parseKeyIds.
  172.       if (drmInfos.length == 0) {
  173.         drmInfos = [ManifestParserUtils.createDrmInfo('', defaultInit)];
  174.       }
  175.     }
  176.   }
  178.   // If there are only CENC element(s) or ignoreDrmInfo flag is set, assume all
  179.   // key-systems are supported.
  180.   if (parsed.length && (ignoreDrmInfo || !parsedNonCenc.length)) {
  181.     let keySystems = ContentProtection.defaultKeySystems_;
  182.     drmInfos =
  183.         MapUtils.values(keySystems)
  184.             .filter(function(keySystem) {
  185.               // If the manifest doesn't specify any key systems, we shouldn't
  186.               // put clearkey in this list.  Otherwise, it may be triggered when
  187.               // a real key system should be used instead.
  188.               return keySystem != 'org.w3.clearkey';
  189.             })
  190.             .map(function(keySystem) {
  191.               return ManifestParserUtils.createDrmInfo(keySystem, defaultInit);
  192.             });
  193.   }
  195.   /** @type {?string} */
  196.   let defaultKeyId = keyIds[0] || null;
  198.   // Attach the default keyId, if it exists, to every initData.
  199.   if (defaultKeyId) {
  200.     drmInfos.forEach(function(drmInfo) {
  201.       drmInfo.initData.forEach(function(initData) {
  202.         initData.keyId = defaultKeyId;
  203.       });
  204.     });
  205.   }
  207.   return {
  208.     defaultKeyId: defaultKeyId,
  209.     defaultInit: defaultInit,
  210.     drmInfos: drmInfos,
  211.     firstRepresentation: true
  212.   };
  213. };
  216. /**
  217.  * Parses the given ContentProtection elements found at the Representation
  218.  * level.  This may update the |context|.
  219.  *
  220.  * @param {!Array.<!Element>} elems
  221.  * @param {shakaExtern.DashContentProtectionCallback} callback
  222.  * @param {shaka.dash.ContentProtection.Context} context
  223.  * @param {boolean} ignoreDrmInfo
  224.  * @return {?string} The parsed key ID
  225.  */
  226. shaka.dash.ContentProtection.parseFromRepresentation = function(
  227.     elems, callback, context, ignoreDrmInfo) {
  228.   const ContentProtection = shaka.dash.ContentProtection;
  229.   let repContext = ContentProtection.parseFromAdaptationSet(
  230.       elems, callback, ignoreDrmInfo);
  232.   if (context.firstRepresentation) {
  233.     let asUnknown = context.drmInfos.length == 1 &&
  234.         !context.drmInfos[0].keySystem;
  235.     let asUnencrypted = context.drmInfos.length == 0;
  236.     let repUnencrypted = repContext.drmInfos.length == 0;
  238.     // There are two cases where we need to replace the |drmInfos| in the
  239.     // context with those in the Representation:
  240.     //   1. The AdaptationSet does not list any ContentProtection.
  241.     //   2. The AdaptationSet only lists unknown key-systems.
  242.     if (asUnencrypted || (asUnknown && !repUnencrypted)) {
  243.       context.drmInfos = repContext.drmInfos;
  244.     }
  245.     context.firstRepresentation = false;
  246.   } else if (repContext.drmInfos.length > 0) {
  247.     // If this is not the first Representation, then we need to remove entries
  248.     // from the context that do not appear in this Representation.
  249.     context.drmInfos = context.drmInfos.filter(function(asInfo) {
  250.       return repContext.drmInfos.some(function(repInfo) {
  251.         return repInfo.keySystem == asInfo.keySystem;
  252.       });
  253.     });
  254.     // If we have filtered out all key-systems, throw an error.
  255.     if (context.drmInfos.length == 0) {
  256.       throw new shaka.util.Error(
  257.           shaka.util.Error.Severity.CRITICAL,
  258.           shaka.util.Error.Category.MANIFEST,
  259.           shaka.util.Error.Code.DASH_NO_COMMON_KEY_SYSTEM);
  260.     }
  261.   }
  263.   return repContext.defaultKeyId || context.defaultKeyId;
  264. };
  267. /**
  268.  * Creates DrmInfo objects from the given element.
  269.  *
  270.  * @param {Array.<shakaExtern.InitDataOverride>} defaultInit
  271.  * @param {shakaExtern.DashContentProtectionCallback} callback
  272.  * @param {!Array.<shaka.dash.ContentProtection.Element>} elements
  273.  * @return {!Array.<shakaExtern.DrmInfo>}
  274.  * @private
  275.  */
  276. shaka.dash.ContentProtection.convertElements_ = function(
  277.     defaultInit, callback, elements) {
  278.   const Functional = shaka.util.Functional;
  279.   return elements.map(
  280.       /**
  281.        * @param {shaka.dash.ContentProtection.Element} element
  282.        * @return {!Array.<shakaExtern.DrmInfo>}
  283.        */
  284.       function(element) {
  285.         const ManifestParserUtils = shaka.util.ManifestParserUtils;
  286.         const ContentProtection = shaka.dash.ContentProtection;
  287.         let keySystem = ContentProtection.defaultKeySystems_[element.schemeUri];
  288.         if (keySystem) {
  289.           goog.asserts.assert(!element.init || element.init.length,
  290.                               'Init data must be null or non-empty.');
  291.           let initData = element.init || defaultInit;
  292.           return [ManifestParserUtils.createDrmInfo(keySystem, initData)];
  293.         } else {
  294.           goog.asserts.assert(
  295.               callback, 'ContentProtection callback is required');
  296.           return callback(element.node) || [];
  297.         }
  298.       }).reduce(Functional.collapseArrays, []);
  299. };
  302. /**
  303.  * Parses the given ContentProtection elements.  If there is an error, it
  304.  * removes those elements.
  305.  *
  306.  * @param {!Array.<!Element>} elems
  307.  * @return {!Array.<shaka.dash.ContentProtection.Element>}
  308.  * @private
  309.  */
  310. shaka.dash.ContentProtection.parseElements_ = function(elems) {
  311.   const Functional = shaka.util.Functional;
  312.   return elems.map(
  313.       /**
  314.        * @param {!Element} elem
  315.        * @return {?shaka.dash.ContentProtection.Element}
  316.        */
  317.       function(elem) {
  318.         const NS = shaka.dash.ContentProtection.CencNamespaceUri_;
  319.         /** @type {?string} */
  320.         let schemeUri = elem.getAttribute('schemeIdUri');
  321.         /** @type {?string} */
  322.         let keyId = shaka.util.XmlUtils.getAttributeNS(elem, NS, 'default_KID');
  323.         /** @type {!Array.<string>} */
  324.         let psshs = shaka.util.XmlUtils.findChildrenNS(elem, NS, 'pssh')
  325.                         .map(shaka.util.XmlUtils.getContents);
  327.         if (!schemeUri) {
  328.           shaka.log.error('Missing required schemeIdUri attribute on',
  329.                           'ContentProtection element', elem);
  330.           return null;
  331.         }
  333.         schemeUri = schemeUri.toLowerCase();
  334.         if (keyId) {
  335.           keyId = keyId.replace(/-/g, '').toLowerCase();
  336.           if (keyId.indexOf(' ') >= 0) {
  337.             throw new shaka.util.Error(
  338.                 shaka.util.Error.Severity.CRITICAL,
  339.                 shaka.util.Error.Category.MANIFEST,
  340.                 shaka.util.Error.Code.DASH_MULTIPLE_KEY_IDS_NOT_SUPPORTED);
  341.           }
  342.         }
  344.         /** @type {!Array.<shakaExtern.InitDataOverride>} */
  345.         let init = [];
  346.         try {
  347.           init = psshs.map(function(pssh) {
  348.             /** @type {shakaExtern.InitDataOverride} */
  349.             let ret = {
  350.               initDataType: 'cenc',
  351.               initData: shaka.util.Uint8ArrayUtils.fromBase64(pssh),
  352.               keyId: null
  353.             };
  354.             return ret;
  355.           });
  356.         } catch (e) {
  357.           throw new shaka.util.Error(
  358.               shaka.util.Error.Severity.CRITICAL,
  359.               shaka.util.Error.Category.MANIFEST,
  360.               shaka.util.Error.Code.DASH_PSSH_BAD_ENCODING);
  361.         }
  363.         /** @type {shaka.dash.ContentProtection.Element} */
  364.         let element = {
  365.           node: elem,
  366.           schemeUri: schemeUri,
  367.           keyId: keyId,
  368.           init: (init.length > 0 ? init : null)
  369.         };
  370.         return element;
  371.       }).filter(Functional.isNotNull);
  372. };