Source: lib/util/uint8array_utils.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.Uint8ArrayUtils');
  9. goog.require('shaka.Deprecate');
  10. goog.require('shaka.util.BufferUtils');
  11. goog.require('shaka.util.Iterables');
  12. goog.require('shaka.util.StringUtils');
  15. // TODO: revisit this when Closure Compiler supports partially-exported classes.
  16. /**
  17.  * @summary A set of Uint8Array utility functions.
  18.  * @export
  19.  */
  20. shaka.util.Uint8ArrayUtils = class {
  21.   /**
  22.    * Compare two Uint8Arrays for equality.
  23.    * @param {Uint8Array} arr1
  24.    * @param {Uint8Array} arr2
  25.    * @return {boolean}
  26.    * @deprecated
  27.    * @export
  28.    */
  29.   static equal(arr1, arr2) {
  30.     shaka.Deprecate.deprecateFeature(4,
  31.         'shaka.util.Uint8ArrayUtils.equal',
  32.         'Please use shaka.util.BufferUtils.equal instead.');
  33.     return shaka.util.BufferUtils.equal(arr1, arr2);
  34.   }
  36.   /**
  37.    * Convert a buffer to a base64 string. The output will be standard
  38.    * alphabet as opposed to base64url safe alphabet.
  39.    * @param {BufferSource} data
  40.    * @return {string}
  41.    * @export
  42.    */
  43.   static toStandardBase64(data) {
  44.     const bytes = shaka.util.StringUtils.fromCharCode(
  45.         shaka.util.BufferUtils.toUint8(data));
  46.     return btoa(bytes);
  47.   }
  49.   /**
  50.    * Convert a buffer to a base64 string.  The output will always use the
  51.    * alternate encoding/alphabet also known as "base64url".
  52.    * @param {BufferSource} data
  53.    * @param {boolean=} padding If true, pad the output with equals signs.
  54.    *   Defaults to true.
  55.    * @return {string}
  56.    * @export
  57.    */
  58.   static toBase64(data, padding) {
  59.     padding = (padding == undefined) ? true : padding;
  60.     const base64 = shaka.util.Uint8ArrayUtils.toStandardBase64(data)
  61.         .replace(/\+/g, '-').replace(/\//g, '_');
  62.     return padding ? base64 : base64.replace(/[=]*$/, '');
  63.   }
  65.   /**
  66.    * Convert a base64 string to a Uint8Array.  Accepts either the standard
  67.    * alphabet or the alternate "base64url" alphabet.
  68.    * @param {string} str
  69.    * @return {!Uint8Array}
  70.    * @export
  71.    */
  72.   static fromBase64(str) {
  73.     // atob creates a "raw string" where each character is interpreted as a
  74.     // byte.
  75.     const bytes = window.atob(str.replace(/-/g, '+').replace(/_/g, '/'));
  76.     const result = new Uint8Array(bytes.length);
  77.     const enumerate = (it) => shaka.util.Iterables.enumerate(it);
  78.     for (const {i, item} of enumerate(bytes)) {
  79.       result[i] = item.charCodeAt(0);
  80.     }
  81.     return result;
  82.   }
  85.   /**
  86.    * Convert a hex string to a Uint8Array.
  87.    * @param {string} str
  88.    * @return {!Uint8Array}
  89.    * @export
  90.    */
  91.   static fromHex(str) {
  92.     const size = str.length / 2;
  93.     const arr = new Uint8Array(size);
  94.     for (const i of shaka.util.Iterables.range(size)) {
  95.       arr[i] = window.parseInt(str.substr(i * 2, 2), 16);
  96.     }
  97.     return arr;
  98.   }
  101.   /**
  102.    * Convert a buffer to a hex string.
  103.    * @param {BufferSource} data
  104.    * @return {string}
  105.    * @export
  106.    */
  107.   static toHex(data) {
  108.     const arr = shaka.util.BufferUtils.toUint8(data);
  109.     let hex = '';
  110.     for (let value of arr) {
  111.       value = value.toString(16);
  112.       if (value.length == 1) {
  113.         value = '0' + value;
  114.       }
  115.       hex += value;
  116.     }
  117.     return hex;
  118.   }
  121.   /**
  122.    * Concatenate buffers.
  123.    * @param {...BufferSource} varArgs
  124.    * @return {!Uint8Array}
  125.    * @export
  126.    */
  127.   static concat(...varArgs) {
  128.     let totalLength = 0;
  129.     for (const arr of varArgs) {
  130.       totalLength += arr.byteLength;
  131.     }
  133.     const result = new Uint8Array(totalLength);
  134.     let offset = 0;
  135.     for (const arr of varArgs) {
  136.       result.set(shaka.util.BufferUtils.toUint8(arr), offset);
  137.       offset += arr.byteLength;
  138.     }
  139.     return result;
  140.   }
  141. };