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.Functional');
  13. goog.require('shaka.util.Iterables');
  14. goog.require('shaka.util.Mp4Parser');
  15. goog.require('shaka.util.Uint8ArrayUtils');
  18. /**
  19.  * @summary
  20.  * Parse a PSSH box and extract the system IDs.
  21.  */
  22. shaka.util.Pssh = class {
  23.   /**
  24.    * @param {!Uint8Array} psshBox
  25.    */
  26.   constructor(psshBox) {
  27.     /**
  28.      * In hex.
  29.      * @type {!Array.<string>}
  30.      */
  31.     this.systemIds = [];
  33.     /**
  34.      * In hex.
  35.      * @type {!Array.<string>}
  36.      */
  37.     this.cencKeyIds = [];
  39.     /**
  40.      * Array with the pssh boxes found.
  41.      * @type {!Array.<!Uint8Array>}
  42.      */
  43.     this.data = [];
  45.     new shaka.util.Mp4Parser()
  46.         .box('moov', shaka.util.Mp4Parser.children)
  47.         .fullBox('pssh', (box) => this.parsePsshBox_(box))
  48.         .parse(psshBox);
  50.     if (this.data.length == 0) {
  51.       shaka.log.warning('No pssh box found!');
  52.     }
  53.   }
  56.   /**
  57.    * @param {!shaka.extern.ParsedBox} box
  58.    * @private
  59.    */
  60.   parsePsshBox_(box) {
  61.     goog.asserts.assert(
  62.         box.version != null,
  63.         'PSSH boxes are full boxes and must have a valid version');
  65.     goog.asserts.assert(
  66.         box.flags != null,
  67.         'PSSH boxes are full boxes and must have a valid flag');
  69.     if (box.version > 1) {
  70.       shaka.log.warning('Unrecognized PSSH version found!');
  71.       return;
  72.     }
  74.     // The "reader" gives us a view on the payload of the box.  Create a new
  75.     // view that contains the whole box.
  76.     const dataView = box.reader.getDataView();
  77.     goog.asserts.assert(
  78.         dataView.byteOffset >= 12, 'DataView at incorrect position');
  79.     const pssh = shaka.util.BufferUtils.toUint8(dataView, -12, box.size);
  80.     this.data.push(pssh);
  82.     this.systemIds.push(
  83.         shaka.util.Uint8ArrayUtils.toHex(box.reader.readBytes(16)));
  84.     if (box.version > 0) {
  85.       const numKeyIds = box.reader.readUint32();
  86.       for (const _ of shaka.util.Iterables.range(numKeyIds)) {
  87.         shaka.util.Functional.ignored(_);
  88.         const keyId =
  89.             shaka.util.Uint8ArrayUtils.toHex(box.reader.readBytes(16));
  90.         this.cencKeyIds.push(keyId);
  91.       }
  92.     }
  93.   }
  95.   /**
  96.    * Creates a pssh blob from the given system ID and data.
  97.    *
  98.    * @param {!Uint8Array} data
  99.    * @param {!Uint8Array} systemId
  100.    * @return {!Uint8Array}
  101.    */
  102.   static createPssh(data, systemId) {
  103.     goog.asserts.assert(systemId.byteLength == 16, 'Invalid system ID length');
  104.     const dataLength = data.length;
  105.     const psshSize = 0x4 + 0x4 + 0x4 + systemId.length + 0x4 + dataLength;
  107.     /** @type {!Uint8Array} */
  108.     const psshBox = new Uint8Array(psshSize);
  109.     /** @type {!DataView} */
  110.     const psshData = shaka.util.BufferUtils.toDataView(psshBox);
  112.     let byteCursor = 0;
  113.     psshData.setUint32(byteCursor, psshSize);
  114.     byteCursor += 0x4;
  115.     psshData.setUint32(byteCursor, 0x70737368);  // 'pssh'
  116.     byteCursor += 0x4;
  117.     psshData.setUint32(byteCursor, 0);  // flags
  118.     byteCursor += 0x4;
  119.     psshBox.set(systemId, byteCursor);
  120.     byteCursor += systemId.length;
  121.     psshData.setUint32(byteCursor, dataLength);
  122.     byteCursor += 0x4;
  123.     psshBox.set(data, byteCursor);
  124.     byteCursor += dataLength;
  126.     goog.asserts.assert(byteCursor === psshSize, 'PSSH invalid length.');
  127.     return psshBox;
  128.   }
  131.   /**
  132.    * Normalise the initData array. This is to apply browser specific
  133.    * work-arounds, e.g. removing duplicates which appears to occur
  134.    * intermittently when the native msneedkey event fires (i.e. event.initData
  135.    * contains dupes).
  136.    *
  137.    * @param {!Uint8Array} initData
  138.    * @return {!Uint8Array}
  139.    */
  140.   static normaliseInitData(initData) {
  141.     if (!initData) {
  142.       return initData;
  143.     }
  145.     const pssh = new shaka.util.Pssh(initData);
  147.     // If there is only a single pssh, return the original array.
  148.     if (pssh.data.length <= 1) {
  149.       return initData;
  150.     }
  152.     // Dedupe psshData.
  153.     /** @type {!Array.<!Uint8Array>} */
  154.     const dedupedInitDatas = [];
  155.     for (const initData of pssh.data) {
  156.       const found = dedupedInitDatas.some((x) => {
  157.         return shaka.util.BufferUtils.equal(x, initData);
  158.       });
  160.       if (!found) {
  161.         dedupedInitDatas.push(initData);
  162.       }
  163.     }
  165.     return shaka.util.Uint8ArrayUtils.concat(...dedupedInitDatas);
  166.   }
  167. };