Source: lib/util/pssh.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.Pssh');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.util.BufferUtils');
  12. goog.require('shaka.util.Mp4Parser');
  13. goog.require('shaka.util.Uint8ArrayUtils');
  16. /**
  17.  * @summary
  18.  * Parse a PSSH box and extract the system IDs.
  19.  */
  20. shaka.util.Pssh = class {
  21.   /**
  22.    * @param {!Uint8Array} psshBox
  23.    */
  24.   constructor(psshBox) {
  25.     /**
  26.      * In hex.
  27.      * @type {!Array.<string>}
  28.      */
  29.     this.systemIds = [];
  31.     /**
  32.      * In hex.
  33.      * @type {!Array.<string>}
  34.      */
  35.     this.cencKeyIds = [];
  37.     /**
  38.      * Array with the pssh boxes found.
  39.      * @type {!Array.<!Uint8Array>}
  40.      */
  41.     this.data = [];
  43.     new shaka.util.Mp4Parser()
  44.         .box('moov', shaka.util.Mp4Parser.children)
  45.         .fullBox('pssh', (box) => this.parsePsshBox_(box))
  46.         .parse(psshBox);
  48.     if (this.data.length == 0) {
  49.       shaka.log.warning('No pssh box found!');
  50.     }
  51.   }
  54.   /**
  55.    * @param {!shaka.extern.ParsedBox} box
  56.    * @private
  57.    */
  58.   parsePsshBox_(box) {
  59.     goog.asserts.assert(
  60.         box.version != null,
  61.         'PSSH boxes are full boxes and must have a valid version');
  63.     goog.asserts.assert(
  64.         box.flags != null,
  65.         'PSSH boxes are full boxes and must have a valid flag');
  67.     if (box.version > 1) {
  68.       shaka.log.warning('Unrecognized PSSH version found!');
  69.       return;
  70.     }
  72.     // The "reader" gives us a view on the payload of the box.  Create a new
  73.     // view that contains the whole box.
  74.     const dataView = box.reader.getDataView();
  75.     goog.asserts.assert(
  76.         dataView.byteOffset >= 12, 'DataView at incorrect position');
  77.     const pssh = shaka.util.BufferUtils.toUint8(dataView, -12, box.size);
  78.     this.data.push(pssh);
  80.     this.systemIds.push(
  81.         shaka.util.Uint8ArrayUtils.toHex(box.reader.readBytes(16)));
  82.     if (box.version > 0) {
  83.       const numKeyIds = box.reader.readUint32();
  84.       for (let i = 0; i < numKeyIds; i++) {
  85.         const keyId =
  86.             shaka.util.Uint8ArrayUtils.toHex(box.reader.readBytes(16));
  87.         this.cencKeyIds.push(keyId);
  88.       }
  89.     }
  90.   }
  92.   /**
  93.    * Creates a pssh blob from the given system ID, data, keyIds and version.
  94.    *
  95.    * @param {!Uint8Array} data
  96.    * @param {!Uint8Array} systemId
  97.    * @param {!Set.<string>} keyIds
  98.    * @param {number} version
  99.    * @return {!Uint8Array}
  100.    */
  101.   static createPssh(data, systemId, keyIds, version) {
  102.     goog.asserts.assert(systemId.byteLength == 16, 'Invalid system ID length');
  103.     const dataLength = data.length;
  104.     let psshSize = 0x4 + 0x4 + 0x4 + systemId.length + 0x4 + dataLength;
  105.     if (version > 0) {
  106.       psshSize += 0x4 + (16 * keyIds.size);
  107.     }
  109.     /** @type {!Uint8Array} */
  110.     const psshBox = new Uint8Array(psshSize);
  111.     /** @type {!DataView} */
  112.     const psshData = shaka.util.BufferUtils.toDataView(psshBox);
  114.     let byteCursor = 0;
  115.     psshData.setUint32(byteCursor, psshSize);
  116.     byteCursor += 0x4;
  117.     psshData.setUint32(byteCursor, 0x70737368);  // 'pssh'
  118.     byteCursor += 0x4;
  119.     (version < 1) ? psshData.setUint32(byteCursor, 0) :
  120.         psshData.setUint32(byteCursor, 0x01000000); // version + flags
  121.     byteCursor += 0x4;
  122.     psshBox.set(systemId, byteCursor);
  123.     byteCursor += systemId.length;
  125.     // if version > 0, add KID count and kid values.
  126.     if (version > 0) {
  127.       psshData.setUint32(byteCursor, keyIds.size); // KID_count
  128.       byteCursor += 0x4;
  129.       const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
  130.       for (const keyId of keyIds) {
  131.         const KID = Uint8ArrayUtils.fromHex(keyId);
  132.         psshBox.set(KID, byteCursor);
  133.         byteCursor += KID.length;
  134.       }
  135.     }
  137.     psshData.setUint32(byteCursor, dataLength);
  138.     byteCursor += 0x4;
  139.     psshBox.set(data, byteCursor);
  140.     byteCursor += dataLength;
  142.     goog.asserts.assert(byteCursor === psshSize, 'PSSH invalid length.');
  143.     return psshBox;
  144.   }
  147.   /**
  148.    * Normalise the initData array. This is to apply browser specific
  149.    * work-arounds, e.g. removing duplicates which appears to occur
  150.    * intermittently when the native msneedkey event fires (i.e. event.initData
  151.    * contains dupes).
  152.    *
  153.    * @param {!Uint8Array} initData
  154.    * @return {!Uint8Array}
  155.    */
  156.   static normaliseInitData(initData) {
  157.     if (!initData) {
  158.       return initData;
  159.     }
  161.     const pssh = new shaka.util.Pssh(initData);
  163.     // If there is only a single pssh, return the original array.
  164.     if (pssh.data.length <= 1) {
  165.       return initData;
  166.     }
  168.     // Dedupe psshData.
  169.     /** @type {!Array.<!Uint8Array>} */
  170.     const dedupedInitDatas = [];
  171.     for (const initData of pssh.data) {
  172.       const found = dedupedInitDatas.some((x) => {
  173.         return shaka.util.BufferUtils.equal(x, initData);
  174.       });
  176.       if (!found) {
  177.         dedupedInitDatas.push(initData);
  178.       }
  179.     }
  181.     return shaka.util.Uint8ArrayUtils.concat(...dedupedInitDatas);
  182.   }
  183. };