Function decode_ise

cmp_compressonatorlib/astc/astc_host.cpp:1633–1713

}

void decode_ise(int quantization_level, int elements, const uint8_t* input_data, uint8_t* output_data, int bit_offset)
{
    int i;
    // note: due to how the the trit/quint-block unpacking is done in this function,
    // we may write more temporary results than the number of outputs
    // The maximum actual number of results is 64 bit, but we keep 4 additional elements
    // of padding.
    uint8_t results[68];
    uint8_t tq_blocks[22];  // trit-blocks or quint-blocks

    int bits, trits, quints;
    find_number_of_bits_trits_quints(quantization_level, &bits, &trits, &quints);

    int lcounter = 0;
    int hcounter = 0;

    // trit-blocks or quint-blocks must be zeroed out before we collect them in the loop below.
    for (i = 0; i < 22; i++)
        tq_blocks[i] = 0;

    // collect bits for each element, as well as bits for any trit-blocks and quint-blocks.
    for (i = 0; i < elements; i++)
    {
        results[i] = (uint8_t)read_bits(bits, bit_offset, input_data);
        bit_offset += bits;
        if (trits)
        {
            static const int bits_to_read[5]  = {2, 2, 1, 2, 1};
            static const int block_shift[5]   = {0, 2, 4, 5, 7};
            static const int next_lcounter[5] = {1, 2, 3, 4, 0};
            static const int hcounter_incr[5] = {0, 0, 0, 0, 1};
            int              tdata            = read_bits(bits_to_read[lcounter], bit_offset, input_data);
            bit_offset += bits_to_read[lcounter];
            tq_blocks[hcounter] |= tdata << block_shift[lcounter];
            hcounter += hcounter_incr[lcounter];
            lcounter = next_lcounter[lcounter];
        }
        if (quints)
        {
            static const int bits_to_read[3]  = {3, 2, 2};
            static const int block_shift[3]   = {0, 3, 5};
            static const int next_lcounter[3] = {1, 2, 0};
            static const int hcounter_incr[3] = {0, 0, 1};
            int              tdata            = read_bits(bits_to_read[lcounter], bit_offset, input_data);
            bit_offset += bits_to_read[lcounter];
            tq_blocks[hcounter] |= tdata << block_shift[lcounter];
            hcounter += hcounter_incr[lcounter];
            lcounter = next_lcounter[lcounter];
        }
    }

    // unpack trit-blocks or quint-blocks as needed
    if (trits)
    {
        int trit_blocks = (elements + 4) / 5;
        for (i = 0; i < trit_blocks; i++)
        {
            const uint8_t* tritptr = trits_of_integer[tq_blocks[i]];