Method resizeBitSizedArray

src/ArrayUtil.js:207–253

* Composes a new array with elements having the given number of bits and * translates the content of the source array to it. * @param {number[]} src Source array * @param {number} srcSize Bit size of source array elements * @param {number} dstSize Bit size of destination array elements

(src, srcSize, dstSize, trimEnd = false)

   * Uint8Array, if dstSize is set to 8.
   */
  static resizeBitSizedArray (src, srcSize, dstSize, trimEnd = false) {
    const size = Math.ceil(src.length * srcSize / dstSize)
    const dst = dstSize === 8 ? new Uint8Array(size) : new Array(size).fill(0)

    // Destination element mask (e.g. 11111111b for dstSize = 8)
    const dstElementMask = (1 << dstSize) - 1

    let element, startBitIndex, endBitIndex, dstStartIndex, dstEndIndex
    let rightBitOffset, remainder, j

    for (let i = 0; i < src.length; i++) {
      element = src[i]

      // Start and end bit index of the current element
      startBitIndex = i * srcSize
      endBitIndex = (i + 1) * srcSize

      // Start and end index in the destination array
      dstStartIndex = Math.floor(startBitIndex / dstSize)
      dstEndIndex = Math.floor(endBitIndex / dstSize)

      // Calculate right bit offset in the last destination element
      rightBitOffset = dstSize - endBitIndex % dstSize

      // Begin at the end
      dst[dstEndIndex] |= (element << rightBitOffset) & dstElementMask
      remainder = element >> (dstSize - rightBitOffset)

      // Inject each dst element until no remainder is left
      j = dstEndIndex
      while (--j >= dstStartIndex && remainder > 0) {
        dst[j] |= remainder & dstElementMask
        remainder = remainder >> dstSize
      }
    }

    if (trimEnd) {
      // Trim trailing elements at the end
      let k = dst.length - 1
      while (dst[k] === 0) {
        k--
      }
      return dst.slice(0, k + 1)
    }

    return dst
  }
}