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.  * Parses info from the ContentProtection elements at the AdaptationSet level.
  114.  *
  115.  * @param {!Array.<!Element>} elems
  116.  * @param {shakaExtern.DashContentProtectionCallback} callback
  117.  * @param {boolean} ignoreDrmInfo
  118.  * @return {shaka.dash.ContentProtection.Context}
  119.  */
  120. shaka.dash.ContentProtection.parseFromAdaptationSet = function(
  121.     elems, callback, ignoreDrmInfo) {
  122.   var ContentProtection = shaka.dash.ContentProtection;
  123.   var Functional = shaka.util.Functional;
  124.   var MapUtils = shaka.util.MapUtils;
  125.   var ManifestParserUtils = shaka.util.ManifestParserUtils;
  126.   var parsed = ContentProtection.parseElements_(elems);
  127.   /** @type {Array.<shakaExtern.InitDataOverride>} */
  128.   var defaultInit = null;
  129.   /** @type {!Array.<shakaExtern.DrmInfo>} */
  130.   var drmInfos = [];
  131.   var parsedNonCenc = [];
  133.   // Get the default key ID; if there are multiple, they must all match.
  134.   var keyIds = parsed.map(function(elem) { return elem.keyId; })
  135.       .filter(Functional.isNotNull);
  136.   if (keyIds.length) {
  137.     if (keyIds.filter(Functional.isNotDuplicate).length > 1) {
  138.       throw new shaka.util.Error(
  139.           shaka.util.Error.Severity.CRITICAL,
  140.           shaka.util.Error.Category.MANIFEST,
  141.           shaka.util.Error.Code.DASH_CONFLICTING_KEY_IDS);
  142.     }
  143.   }
  145.   if (!ignoreDrmInfo) {
  146.     // Find the default key ID and init data.  Create a new array of all the
  147.     // non-CENC elements.
  148.     parsedNonCenc = parsed.filter(function(elem) {
  149.       if (elem.schemeUri == ContentProtection.MP4Protection_) {
  150.         goog.asserts.assert(!elem.init || elem.init.length,
  151.                             'Init data must be null or non-empty.');
  152.         defaultInit = elem.init || defaultInit;
  153.         return false;
  154.       } else {
  155.         return true;
  156.       }
  157.     });
  159.     if (parsedNonCenc.length) {
  160.       drmInfos = ContentProtection.convertElements_(
  161.           defaultInit, callback, parsedNonCenc);
  163.       // If there are no drmInfos after parsing, then add a dummy entry.
  164.       // This may be removed in parseKeyIds.
  165.       if (drmInfos.length == 0) {
  166.         drmInfos = [ManifestParserUtils.createDrmInfo('', defaultInit)];
  167.       }
  168.     }
  169.   }
  171.   // If there are only CENC element(s) or ignoreDrmInfo flag is set, assume all
  172.   // key-systems are supported.
  173.   if (parsed.length && (ignoreDrmInfo || !parsedNonCenc.length)) {
  174.     var keySystems = ContentProtection.defaultKeySystems_;
  175.     drmInfos =
  176.         MapUtils.values(keySystems)
  177.             .map(function(keySystem) {
  178.               return ManifestParserUtils.createDrmInfo(keySystem, defaultInit);
  179.             });
  180.   }
  182.   /** @type {?string} */
  183.   var defaultKeyId = keyIds[0] || null;
  185.   // attach the default keyId, if it exists, to every initData
  186.   if (defaultKeyId) {
  187.     drmInfos.forEach(function(drmInfo) {
  188.       drmInfo.initData.forEach(function(initData) {
  189.         initData.keyId = defaultKeyId;
  190.       });
  191.     });
  192.   }
  194.   return {
  195.     defaultKeyId: defaultKeyId,
  196.     defaultInit: defaultInit,
  197.     drmInfos: drmInfos,
  198.     firstRepresentation: true
  199.   };
  200. };
  203. /**
  204.  * Parses the given ContentProtection elements found at the Representation
  205.  * level.  This may update the |context|.
  206.  *
  207.  * @param {!Array.<!Element>} elems
  208.  * @param {shakaExtern.DashContentProtectionCallback} callback
  209.  * @param {shaka.dash.ContentProtection.Context} context
  210.  * @param {boolean} ignoreDrmInfo
  211.  * @return {?string} The parsed key ID
  212.  */
  213. shaka.dash.ContentProtection.parseFromRepresentation = function(
  214.     elems, callback, context, ignoreDrmInfo) {
  215.   var ContentProtection = shaka.dash.ContentProtection;
  216.   var repContext = ContentProtection.parseFromAdaptationSet(
  217.       elems, callback, ignoreDrmInfo);
  219.   if (context.firstRepresentation) {
  220.     var asUnknown = context.drmInfos.length == 1 &&
  221.         !context.drmInfos[0].keySystem;
  222.     var asUnencrypted = context.drmInfos.length == 0;
  223.     var repUnencrypted = repContext.drmInfos.length == 0;
  225.     // There are two cases when we need to replace the |drmInfos| in the context
  226.     // with those in the Representation:
  227.     // * The AdaptationSet does not list any ContentProtection.
  228.     // * The AdaptationSet only lists unknown key-systems.
  229.     if (asUnencrypted || (asUnknown && !repUnencrypted)) {
  230.       context.drmInfos = repContext.drmInfos;
  231.     }
  232.     context.firstRepresentation = false;
  233.   } else if (repContext.drmInfos.length > 0) {
  234.     // If this is not the first Representation, then we need to remove entries
  235.     // from the context that do not appear in this Representation.
  236.     context.drmInfos = context.drmInfos.filter(function(asInfo) {
  237.       return repContext.drmInfos.some(function(repInfo) {
  238.         return repInfo.keySystem == asInfo.keySystem;
  239.       });
  240.     });
  241.     // If we have filtered out all key-systems, throw an error.
  242.     if (context.drmInfos.length == 0) {
  243.       throw new shaka.util.Error(
  244.           shaka.util.Error.Severity.CRITICAL,
  245.           shaka.util.Error.Category.MANIFEST,
  246.           shaka.util.Error.Code.DASH_NO_COMMON_KEY_SYSTEM);
  247.     }
  248.   }
  250.   return repContext.defaultKeyId || context.defaultKeyId;
  251. };
  254. /**
  255.  * Creates DrmInfo objects from the given element.
  256.  *
  257.  * @param {Array.<shakaExtern.InitDataOverride>} defaultInit
  258.  * @param {shakaExtern.DashContentProtectionCallback} callback
  259.  * @param {!Array.<shaka.dash.ContentProtection.Element>} elements
  260.  * @return {!Array.<shakaExtern.DrmInfo>}
  261.  * @private
  262.  */
  263. shaka.dash.ContentProtection.convertElements_ = function(
  264.     defaultInit, callback, elements) {
  265.   var Functional = shaka.util.Functional;
  266.   return elements.map(
  267.       /**
  268.        * @param {shaka.dash.ContentProtection.Element} element
  269.        * @return {!Array.<shakaExtern.DrmInfo>}
  270.        */
  271.       function(element) {
  272.         var ManifestParserUtils = shaka.util.ManifestParserUtils;
  273.         var ContentProtection = shaka.dash.ContentProtection;
  274.         var keySystem = ContentProtection.defaultKeySystems_[element.schemeUri];
  275.         if (keySystem) {
  276.           goog.asserts.assert(!element.init || element.init.length,
  277.                               'Init data must be null or non-empty.');
  278.           var initData = element.init || defaultInit;
  279.           return [ManifestParserUtils.createDrmInfo(keySystem, initData)];
  280.         } else {
  281.           goog.asserts.assert(
  282.               callback, 'ContentProtection callback is required');
  283.           return callback(element.node) || [];
  284.         }
  285.       }).reduce(Functional.collapseArrays, []);
  286. };
  289. /**
  290.  * Parses the given ContentProtection elements.  If there is an error, it
  291.  * removes those elements.
  292.  *
  293.  * @param {!Array.<!Element>} elems
  294.  * @return {!Array.<shaka.dash.ContentProtection.Element>}
  295.  * @private
  296.  */
  297. shaka.dash.ContentProtection.parseElements_ = function(elems) {
  298.   var Functional = shaka.util.Functional;
  299.   return elems.map(
  300.       /**
  301.        * @param {!Element} elem
  302.        * @return {?shaka.dash.ContentProtection.Element}
  303.        */
  304.       function(elem) {
  305.         /** @type {?string} */
  306.         var schemeUri = elem.getAttribute('schemeIdUri');
  307.         /** @type {?string} */
  308.         var keyId = elem.getAttribute('cenc:default_KID');
  309.         /** @type {!Array.<string>} */
  310.         var psshs = shaka.util.XmlUtils.findChildren(elem, 'cenc:pssh')
  311.                         .map(shaka.util.XmlUtils.getContents);
  313.         if (!schemeUri) {
  314.           shaka.log.error('Missing required schemeIdUri attribute on',
  315.                           'ContentProtection element', elem);
  316.           return null;
  317.         }
  319.         schemeUri = schemeUri.toLowerCase();
  320.         if (keyId) {
  321.           keyId = keyId.replace(/-/g, '').toLowerCase();
  322.           if (keyId.indexOf(' ') >= 0) {
  323.             throw new shaka.util.Error(
  324.                 shaka.util.Error.Severity.CRITICAL,
  325.                 shaka.util.Error.Category.MANIFEST,
  326.                 shaka.util.Error.Code.DASH_MULTIPLE_KEY_IDS_NOT_SUPPORTED);
  327.           }
  328.         }
  330.         /** @type {!Array.<shakaExtern.InitDataOverride>} */
  331.         var init = [];
  332.         try {
  333.           init = psshs.map(function(pssh) {
  334.             /** @type {shakaExtern.InitDataOverride} */
  335.             var ret = {
  336.               initDataType: 'cenc',
  337.               initData: shaka.util.Uint8ArrayUtils.fromBase64(pssh),
  338.               keyId: null
  339.             };
  340.             return ret;
  341.           });
  342.         } catch (e) {
  343.           throw new shaka.util.Error(
  344.               shaka.util.Error.Severity.CRITICAL,
  345.               shaka.util.Error.Category.MANIFEST,
  346.               shaka.util.Error.Code.DASH_PSSH_BAD_ENCODING);
  347.         }
  349.         /** @type {shaka.dash.ContentProtection.Element} */
  350.         var element = {
  351.           node: elem,
  352.           schemeUri: schemeUri,
  353.           keyId: keyId,
  354.           init: (init.length > 0 ? init : null)
  355.         };
  356.         return element;
  357.       }).filter(Functional.isNotNull);
  358. };