Source: lib/util/uint8array_utils.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.util.Uint8ArrayUtils');
  20. goog.require('shaka.util.StringUtils');
  23. /**
  24.  * @namespace shaka.util.Uint8ArrayUtils
  25.  * @summary A set of Uint8Array utility functions.
  26.  * @exportDoc
  27.  */
  30. /**
  31.  * Convert a Uint8Array to a base64 string.  The output will always use the
  32.  * alternate encoding/alphabet also known as "base64url".
  33.  * @param {!Uint8Array} arr
  34.  * @param {boolean=} opt_padding If true, pad the output with equals signs.
  35.  *   Defaults to true.
  36.  * @return {string}
  37.  * @export
  38.  */
  39. shaka.util.Uint8ArrayUtils.toBase64 = function(arr, opt_padding) {
  40.   // btoa expects a "raw string" where each character is interpreted as a byte.
  41.   let bytes = shaka.util.StringUtils.fromCharCode(arr);
  42.   let padding = (opt_padding == undefined) ? true : opt_padding;
  43.   let base64 = window.btoa(bytes).replace(/\+/g, '-').replace(/\//g, '_');
  44.   return padding ? base64 : base64.replace(/=*$/, '');
  45. };
  48. /**
  49.  * Convert a base64 string to a Uint8Array.  Accepts either the standard
  50.  * alphabet or the alternate "base64url" alphabet.
  51.  * @param {string} str
  52.  * @return {!Uint8Array}
  53.  * @export
  54.  */
  55. shaka.util.Uint8ArrayUtils.fromBase64 = function(str) {
  56.   // atob creates a "raw string" where each character is interpreted as a byte.
  57.   let bytes = window.atob(str.replace(/-/g, '+').replace(/_/g, '/'));
  58.   let result = new Uint8Array(bytes.length);
  59.   for (let i = 0; i < bytes.length; ++i) {
  60.     result[i] = bytes.charCodeAt(i);
  61.   }
  62.   return result;
  63. };
  66. /**
  67.  * Convert a hex string to a Uint8Array.
  68.  * @param {string} str
  69.  * @return {!Uint8Array}
  70.  * @export
  71.  */
  72. shaka.util.Uint8ArrayUtils.fromHex = function(str) {
  73.   let arr = new Uint8Array(str.length / 2);
  74.   for (let i = 0; i < str.length; i += 2) {
  75.     arr[i / 2] = window.parseInt(str.substr(i, 2), 16);
  76.   }
  77.   return arr;
  78. };
  81. /**
  82.  * Convert a Uint8Array to a hex string.
  83.  * @param {!Uint8Array} arr
  84.  * @return {string}
  85.  * @export
  86.  */
  87. shaka.util.Uint8ArrayUtils.toHex = function(arr) {
  88.   let hex = '';
  89.   for (let i = 0; i < arr.length; ++i) {
  90.     let value = arr[i].toString(16);
  91.     if (value.length == 1) value = '0' + value;
  92.     hex += value;
  93.   }
  94.   return hex;
  95. };
  98. /**
  99.  * Compare two Uint8Arrays for equality.
  100.  * @param {Uint8Array} arr1
  101.  * @param {Uint8Array} arr2
  102.  * @return {boolean}
  103.  * @export
  104.  */
  105. shaka.util.Uint8ArrayUtils.equal = function(arr1, arr2) {
  106.   if (!arr1 && !arr2) return true;
  107.   if (!arr1 || !arr2) return false;
  108.   if (arr1.length != arr2.length) return false;
  109.   for (let i = 0; i < arr1.length; ++i) {
  110.     if (arr1[i] != arr2[i]) return false;
  111.   }
  112.   return true;
  113. };
  116. /**
  117.  * Concatenate Uint8Arrays.
  118.  * @param {...Uint8Array} var_args
  119.  * @return {Uint8Array}
  120.  * @export
  121.  */
  122. shaka.util.Uint8ArrayUtils.concat = function(var_args) {
  123.   let totalLength = 0;
  124.   for (let i = 0; i < arguments.length; ++i) {
  125.     totalLength += arguments[i].length;
  126.   }
  128.   let result = new Uint8Array(totalLength);
  129.   let offset = 0;
  130.   for (let i = 0; i < arguments.length; ++i) {
  131.     result.set(arguments[i], offset);
  132.     offset += arguments[i].length;
  133.   }
  134.   return result;
  135. };