Function buildHuffmanTable

js/decode.ts:1499–1557

(tableGroup: Int32Array, tableIdx: number, rootBits: number, codeLengths: Int32Array, codeLengthsSize: number)

  return bits - rootBits;
}
function buildHuffmanTable(tableGroup: Int32Array, tableIdx: number, rootBits: number, codeLengths: Int32Array, codeLengthsSize: number): number {
  const tableOffset: number = tableGroup[tableIdx];
  const sorted = new Int32Array(codeLengthsSize);
  const count = new Int32Array(16);
  const offset = new Int32Array(16);
  for (let sym = 0; sym < codeLengthsSize; ++sym) {
    count[codeLengths[sym]]++;
  }
  offset[1] = 0;
  for (let len = 1; len < 15; ++len) {
    offset[len + 1] = offset[len] + count[len];
  }
  for (let sym = 0; sym < codeLengthsSize; ++sym) {
    if (codeLengths[sym] !== 0) {
      sorted[offset[codeLengths[sym]]++] = sym;
    }
  }
  let tableBits: number = rootBits;
  let tableSize: number = 1 << tableBits;
  let totalSize: number = tableSize;
  if (offset[15] === 1) {
    for (let k = 0; k < totalSize; ++k) {
      tableGroup[tableOffset + k] = sorted[0];
    }
    return totalSize;
  }
  let key = 0;
  let symbol = 0;
  let step = 1;
  for (let len = 1; len <= rootBits; ++len) {
    step = step << 1;
    while (count[len] > 0) {
      replicateValue(tableGroup, tableOffset + key, step, tableSize, len << 16 | sorted[symbol++]);
      key = getNextKey(key, len);
      count[len]--;
    }
  }
  const mask: number = totalSize - 1;
  let low: number = -1;
  let currentOffset: number = tableOffset;
  step = 1;
  for (let len: number = rootBits + 1; len <= 15; ++len) {
    step = step << 1;
    while (count[len] > 0) {
      if ((key & mask) !== low) {
        currentOffset += tableSize;
        tableBits = nextTableBitSize(count, len, rootBits);
        tableSize = 1 << tableBits;
        totalSize += tableSize;
        low = key & mask;
        tableGroup[tableOffset + low] = (tableBits + rootBits) << 16 | (currentOffset - tableOffset - low);
      }
      replicateValue(tableGroup, currentOffset + (key >> rootBits), step, tableSize, (len - rootBits) << 16 | sorted[symbol++]);
      key = getNextKey(key, len);
      count[len]--;
    }
  }
  return totalSize;