Source: lib/util/buffer_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.BufferUtils');
  9. goog.require('shaka.util.Iterables');
  12. /**
  13.  * @summary A set of BufferSource utility functions.
  14.  * @export
  15.  */
  16. shaka.util.BufferUtils = class {
  17.   /**
  18.    * Compare two buffers for equality.  For buffers of different types, this
  19.    * compares the underlying buffers as binary data.
  20.    *
  21.    * @param {?BufferSource} arr1
  22.    * @param {?BufferSource} arr2
  23.    * @return {boolean}
  24.    * @export
  25.    */
  26.   static equal(arr1, arr2) {
  27.     const BufferUtils = shaka.util.BufferUtils;
  28.     if (!arr1 && !arr2) {
  29.       return true;
  30.     }
  31.     if (!arr1 || !arr2) {
  32.       return false;
  33.     }
  34.     if (arr1.byteLength != arr2.byteLength) {
  35.       return false;
  36.     }
  38.     // Quickly check if these are views of the same buffer.  An ArrayBuffer can
  39.     // be passed but doesn't have a byteOffset field, so default to 0.
  40.     if (BufferUtils.unsafeGetArrayBuffer_(arr1) ==
  41.             BufferUtils.unsafeGetArrayBuffer_(arr2) &&
  42.         (arr1.byteOffset || 0) == (arr2.byteOffset || 0)) {
  43.       return true;
  44.     }
  46.     const uint8A = shaka.util.BufferUtils.toUint8(arr1);
  47.     const uint8B = shaka.util.BufferUtils.toUint8(arr2);
  48.     for (const i of shaka.util.Iterables.range(arr1.byteLength)) {
  49.       if (uint8A[i] != uint8B[i]) {
  50.         return false;
  51.       }
  52.     }
  53.     return true;
  54.   }
  56.   /**
  57.    * Gets the underlying ArrayBuffer of the given view.  The caller needs to
  58.    * ensure it uses the "byteOffset" and "byteLength" fields of the view to
  59.    * only use the same "view" of the data.
  60.    *
  61.    * @param {BufferSource} view
  62.    * @return {!ArrayBuffer}
  63.    * @private
  64.    */
  65.   static unsafeGetArrayBuffer_(view) {
  66.     if (view instanceof ArrayBuffer) {
  67.       return view;
  68.     } else {
  69.       return view.buffer;
  70.     }
  71.   }
  73.   /**
  74.    * Gets an ArrayBuffer that contains the data from the given TypedArray.  Note
  75.    * this will allocate a new ArrayBuffer if the object is a partial view of
  76.    * the data.
  77.    *
  78.    * @param {!BufferSource} view
  79.    * @return {!ArrayBuffer}
  80.    * @export
  81.    */
  82.   static toArrayBuffer(view) {
  83.     if (view instanceof ArrayBuffer) {
  84.       return view;
  85.     } else {
  86.       if (view.byteOffset == 0 && view.byteLength == view.buffer.byteLength) {
  87.         // This is a TypedArray over the whole buffer.
  88.         return view.buffer;
  89.       }
  90.       // This is a "view" on the buffer.  Create a new buffer that only contains
  91.       // the data.  Note that since this isn't an ArrayBuffer, the "new" call
  92.       // will allocate a new buffer to hold the copy.
  93.       return new Uint8Array(view).buffer;
  94.     }
  95.   }
  97.   /**
  98.    * Creates a new Uint8Array view on the same buffer.  This clamps the values
  99.    * to be within the same view (i.e. you can't use this to move past the end
  100.    * of the view, even if the underlying buffer is larger).  However, you can
  101.    * pass a negative offset to access the data before the view.
  102.    *
  103.    * @param {BufferSource} data
  104.    * @param {number=} offset The offset from the beginning of this data's view
  105.    *   to start the new view at.
  106.    * @param {number=} length The byte length of the new view.
  107.    * @return {!Uint8Array}
  108.    * @export
  109.    */
  110.   static toUint8(data, offset = 0, length = Infinity) {
  111.     return shaka.util.BufferUtils.view_(data, offset, length, Uint8Array);
  112.   }
  114.   /**
  115.    * Creates a DataView over the given buffer.
  116.    *
  117.    * @see toUint8
  118.    * @param {BufferSource} buffer
  119.    * @param {number=} offset
  120.    * @param {number=} length
  121.    * @return {!DataView}
  122.    * @export
  123.    */
  124.   static toDataView(buffer, offset = 0, length = Infinity) {
  125.     return shaka.util.BufferUtils.view_(buffer, offset, length, DataView);
  126.   }
  128.   /**
  129.    * @param {BufferSource} data
  130.    * @param {number} offset
  131.    * @param {number} length
  132.    * @param {function(new:T, ArrayBuffer, number, number)} Type
  133.    * @return {!T}
  134.    * @template T
  135.    * @private
  136.    */
  137.   static view_(data, offset, length, Type) {
  138.     const buffer = shaka.util.BufferUtils.unsafeGetArrayBuffer_(data);
  139.     // Absolute end of the |data| view within |buffer|.
  140.     const dataEnd = (data.byteOffset || 0) + data.byteLength;
  141.     // Absolute start of the result within |buffer|.
  142.     const rawStart = (data.byteOffset || 0) + offset;
  143.     const start = Math.max(0, Math.min(rawStart, dataEnd));
  144.     // Absolute end of the result within |buffer|.
  145.     const end = Math.min(start + Math.max(length, 0), dataEnd);
  146.     return new Type(buffer, start, end - start);
  147.   }
  148. };