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