android-15.0.0_r3/s

// Compute shader to perform ASTC decoding.
//
// Usage:
// #include "AstcDecompressor.glsl"
//
// main() {
//   uvec4 astcBlock = ... // read an ASTC block
//   astcDecoderInitialize(astcBlock, blockSize);
//   uvec2 posInBlock = uvec2(0, 0);  // which texel we want to decode in the block
//   uvec4 texel = astcDecodeTexel(pos);
// }
//
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Please refer for the ASTC spec for all the details:
// https://www.khronos.org/registry/OpenGL/extensions/KHR/KHR_texture_compression_astc_hdr.txt
//
//
// Quick reminder of an ASTC block layout
// --------------------------------------
//
// Each ASTC block is 128 bits. From top to bottom (from bit 127 to bit 0), we have:
//    1. weight data (24 - 96 bits). Starts at bit 127 and grows down. (So it needs to be reversed)
//    2. extra CEM data. 0 bits if only 1 partition OR if CEM selector value in bits [24:23] is 00,
//       otherwise 2, 5 or 8 bits for 2, 3, or 4 partitions respectively.
//    3. color component selector (CCS) - 2 bits if dual plane is active, otherwise 0 bits.
//    4. Color endpoint data - variable length
//    5. CEM                 4 bits if single partition, else 6 bits.
//    6. partition seed     10 bits (13-22) - only if more than 1 partition
//    7. partition count     2 bits (11-12)
//    8. block mode         11 bits ( 0-10)
//
// Optimization ideas
// ------------------
//
//   1. Use a uniform buffer instead of static arrays to load the tables in AstcLookupTables.glsl
//   2. Investigate using SSBO or sampled image instead of storage image for the input.
//   3. Make decodeTrit() / decodeQuint() return a pair of values, since we always need at least 2
//   4. Look into which queue we use to run the shader, some GPUs may have a separate compute queue.
//   5. Use a `shared` variable to share the block data and common block config, once we change the
//      local group size to match the block size.
//
// Missing features
// ----------------
//
//   1. Make sure we cover all the cases where we should return the error color? See section C.2.24
//      Illegal Encodings for the full list.
//   2. Add support for 3D slices.
//   3. HDR support? Probably not worth it.

#include "AstcLookupTables.glsl"

const uvec4 kErrorColor = uvec4(255, 0, 255, 255);  // beautiful magenta, as per the spec

// Global variables ////////////////////////////////////////////////////////////////////////////////

uvec4 astcBlock;       // Full ASTC block data
uvec2 blockSize;       // Size of the ASTC block
bool decodeError;      // True if there's an error in the block.
bool voidExtent;       // True if void-extent block (all pixels are the same color)
bool dualPlane;        // True for dual plane blocks (a block with 2 sets of weights)
uvec2 weightGridSize;  // Width and height of the weight grid. Always <= blockSize.
uint numWeights;       // Number of weights
uvec3 weightEncoding;  // Number of trits (x), quints (y) and bits (z) to encode the weights.
uint weightDataSize;   // Size of the weight data in bits
uint numPartitions;    // Number of partitions (1-4)
uint partitionSeed;    // Determines which partition pattern we use (10 bits)

////////////////////////////////////////////////////////////////////////////////////////////////////

// Returns the number of bits needed to encode `numVals` values using a given encoding.
// encoding: number of trits (x), quints (y) and bits (z) used for the encoding.
uint getEncodingSize(uint numVals, uvec3 encoding) {
    // See section C.2.22.
    uvec2 tqBits = (numVals * encoding.xy * uvec2(8, 7) + uvec2(4, 2)) / uvec2(5, 3);
    return numVals * encoding.z + (tqBits.x + tqBits.y);
}

// This function sets all the global variables above
void astcDecoderInitialize(uvec4 blockData, uvec2 blockSize_) {
    astcBlock = blockData;
    blockSize = blockSize_;
    decodeError = false;

    voidExtent = (astcBlock[3] & 0x1FF) == 0x1FC;
    if (voidExtent) return;

    const uint bits01 = bitfieldExtract(astcBlock[3], 0, 2);
    const uint bits23 = bitfieldExtract(astcBlock[3], 2, 2);
    const uint bit4 = bitfieldExtract(astcBlock[3], 4, 1);
    const uint bits56 = bitfieldExtract(astcBlock[3], 5, 2);
    const uint bits78 = bitfieldExtract(astcBlock[3], 7, 2);

    uint r;
    uint h = bitfieldExtract(astcBlock[3], 9, 1);
    dualPlane = bool(bitfieldExtract(astcBlock[3], 10, 1));

    // Refer to "Table C.2.8 - 2D Block Mode Layout"
    if (bits01 == 0) {
        r = bits23 << 1 | bit4;
        switch (bits78) {
            case 0:
                weightGridSize = uvec2(12, bits56 + 2);
                break;
            case 1:
                weightGridSize = uvec2(bits56 + 2, 12);
                break;
            case 2:
                weightGridSize = uvec2(bits56 + 6, bitfieldExtract(astcBlock[3], 9, 2) + 6);
                dualPlane = false;
                h = 0;
                break;
            case 3:
                if (bits56 == 0) {
                    weightGridSize = uvec2(6, 10);
                } else if (bits56 == 1) {
                    weightGridSize = uvec2(10, 6);
                } else {
                    decodeError = true;
                    return;
                }
        }
    } else {
        r = bits01 << 1 | bit4;
        switch (bits23) {
            case 0:
                weightGridSize = uvec2(bits78 + 4, bits56 + 2);
                break;
            case 1:
                weightGridSize = uvec2(bits78 + 8, bits56 + 2);
                break;
            case 2:
                weightGridSize = uvec2(bits56 + 2, bits78 + 8);
                break;
            case 3:
                if (bits78 >> 1 == 0) {
                    weightGridSize = uvec2(bits56 + 2, (bits78 & 1) + 6);
                } else {
                    weightGridSize = uvec2((bits78 & 1) + 2, bits56 + 2);
                }
        }
    }

    if (any(greaterThan(weightGridSize, blockSize))) {
        decodeError = true;
        return;
    }

    // weigths
    weightEncoding = kWeightEncodings[h << 3 | r];
    numWeights = (weightGridSize.x * weightGridSize.y) << int(dualPlane);
    weightDataSize = getEncodingSize(numWeights, weightEncoding);
    if (weightDataSize < 24 || weightDataSize > 96 || numWeights > 64) {
        decodeError = true;
        return;
    }

    numPartitions = bitfieldExtract(astcBlock[3], 11, 2) + 1;
    if (numPartitions > 1) {
        partitionSeed = bitfieldExtract(astcBlock[3], 13, 10);
    }

    if (dualPlane && numPartitions == 4) {
        decodeError = true;
        return;
    }
}

// Extracts a range of bits from a uvec4, treating it as a single 128-bit field.
// offset: index of the first bit to extract (0-127).
// numBits: number of bits to extract. (0-32). If numBits is 0, this returns 0.
// Result is undefined if offset >= 128 or offset + numBits > 128
uint extractBits(uvec4 data, uint offset, uint numBits) {
    if (numBits == 0) return 0;

    const uint i = 3 - offset / 32;
    const uint j = 3 - (offset + numBits - 1) / 32;
    const uint start = offset & 31;
    if (i == j) {
        // All the bits to extract are located on the same component of the vector
        return bitfieldExtract(data[i], int(start), int(numBits));
    } else {
        uint numLowBits = 32 - start;
        uint lowBits = bitfieldExtract(data[i], int(start), int(numLowBits));
        uint highBits = bitfieldExtract(data[j], 0, int(numBits - numLowBits));
        return (highBits << numLowBits) | lowBits;
    }
}

// Returns the CEM, a number between 0 and 15 that determines how the endpoints are encoded.
// Also sets a couple of output parameters:
// - startOfExtraCem: bit position of the start of the extra CEM
// - totalEndpoints: number of endpoints in the block, for all partitions.
// - baseEndpointIndex: index of the first endpoint for this partition
// Refer to "Section C.2.11  Color Endpoint Mode" for decoding details
uint decodeCEM(uint partitionIndex, out uint startOfExtraCem, out uint totalEndpoints,
               out uint baseEndpointIndex) {
    if (numPartitions == 1) {
        startOfExtraCem = 128 - weightDataSize;
        const uint cem = bitfieldExtract(astcBlock[3], 13, 4);
        totalEndpoints = 2 * (cem >> 2) + 2;
        baseEndpointIndex = 0;
        return cem;
    } else {
        const uint cemSelector = bitfieldExtract(astcBlock[3], 23, 2);
        const uint baseCem = bitfieldExtract(astcBlock[3], 25, 4);

        if (cemSelector == 0) {
            // We're in the multi-partition, single CEM case
            startOfExtraCem = 128 - weightDataSize;
            const uint endpointsPerPartition = 2 * (baseCem >> 2) + 2;
            totalEndpoints = endpointsPerPartition * numPartitions;
            baseEndpointIndex = endpointsPerPartition * partitionIndex;
            return baseCem;
        } else {
            // Refer to "Figure C.4" for the details of the encoding here.

            // Size in bits of the extra CEM data, which is located right after the weight data.
            const uint sizeOfExtraCem = 3 * numPartitions - 4;
            startOfExtraCem = 128 - weightDataSize - sizeOfExtraCem;

            // Extract the extra CEM data
            const uint extraCem = extractBits(astcBlock, startOfExtraCem, sizeOfExtraCem);
            const uint fullCem = extraCem << 4 | baseCem;

            const uint mValue =
                bitfieldExtract(fullCem, int(2 * partitionIndex + numPartitions), 2);
            const uint cValues = bitfieldExtract(fullCem, 0, int(numPartitions));

            // TODO(gregschlom): investigate whether a couple of small lookup tables would be more
            // efficient here.
            totalEndpoints = 2 * (cemSelector * numPartitions + bitCount(cValues));
            baseEndpointIndex = 2 * (cemSelector * partitionIndex +
                                     bitCount(bitfieldExtract(cValues, 0, int(partitionIndex))));
            uint baseClass = cemSelector - 1 + bitfieldExtract(cValues, int(partitionIndex), 1);
            return baseClass << 2 | mValue;
        }
    }
}

// Decodes a single trit within a block of 5.
// offset: bit offset where the block of trits starts, within the 128 bits of data
// numBits: how many bits are used to encode the LSB (0-6)
// i: index of the trit within the block (0-4)
// See section "C.2.12  Integer Sequence Encoding"
uint decodeTrit(uvec4 data, uint offset, uint numBits, uint i) {
    const int inumBits = int(numBits);

    // In the largest encoding possible (1 trit + 6 bits), the block is 38 bits long (5 * 6 + 8).
    // Since this wouldn't fit in 32 bits, we extract the low bits for the trit index 0 separately,
    // this way we only need at most 4 * 6 + 8 = 32 bits, which fits perfectly.
    const uint block = extractBits(data, offset + numBits, 4 * numBits + 8);

    // Extract the 8 bits that encode the pack of 5 trits
    // TODO(gregschlom): Optimization idea: if numbits == 0, then packedTrits = block. Worth doing?
    const uint packedTrits = bitfieldExtract(block, 0, 2) |
                             bitfieldExtract(block, 1 * inumBits + 2, 2) << 2 |
                             bitfieldExtract(block, 2 * inumBits + 4, 1) << 4 |
                             bitfieldExtract(block, 3 * inumBits + 5, 2) << 5 |
                             bitfieldExtract(block, 4 * inumBits + 7, 1) << 7;

    // Extract the LSB
    uint lowBits;
    if (i == 0) {
        lowBits = extractBits(data, offset, numBits);
    } else {
        const int j = int(i) - 1;
        const ivec4 deltas = {2, 4, 5, 7};
        lowBits = bitfieldExtract(block, j * inumBits + deltas[j], inumBits);
    }

    const uint decoded = kTritEncodings[packedTrits];
    return bitfieldExtract(decoded, 2 * int(i), 2) << numBits | lowBits;
}

// Decodes a single quint within a block of 3.
// offset: bit offset where the block of quint starts, within the 128 bits of data
// numBits: how many bits are used to encode the LSB (0-5)
// i: index of the quint within the block (0-2)
// See section "C.2.12  Integer Sequence Encoding"
uint decodeQuint(uvec4 data, uint offset, uint numBits, uint i) {
    const int inumBits = int(numBits);

    // Note that we don't have the same size issue as trits (see above), since the largest encoding
    // here is 1 quint and 5 bits, which is 3 * 5 + 7 = 22 bits long
    const uint block = extractBits(data, offset, 3 * numBits + 7);

    // Extract the 7 bits that encode the pack of 3 quints
    const uint packedQuints = bitfieldExtract(block, inumBits, 3) |
                              bitfieldExtract(block, 2 * inumBits + 3, 2) << 3 |
                              bitfieldExtract(block, 3 * inumBits + 5, 2) << 5;

    // Extract the LSB
    const ivec3 deltas = {0, 3, 5};
    const uint lowBits = bitfieldExtract(block, int(i) * inumBits + deltas[i], inumBits);

    const uint decoded = kQuintEncodings[packedQuints];
    return bitfieldExtract(decoded, 3 * int(i), 3) << numBits | lowBits;
}

uint decode1Weight(uvec4 weightData, uvec3 encoding, uint numWeights, uint index) {
    if (index >= numWeights) return 0;

    uint numBits = encoding.z;

    if (encoding.x == 1) {
        // 1 trit
        uint offset = (index / 5) * (5 * numBits + 8);
        uint w = decodeTrit(weightData, offset, numBits, index % 5);
        return kUnquantTritWeightMap[3 * ((1 << numBits) - 1) + w];
    } else if (encoding.y == 1) {
        // 1 quint
        uint offset = (index / 3) * (3 * numBits + 7);
        uint w = decodeQuint(weightData, offset, numBits, index % 3);
        return kUnquantQuintWeightMap[5 * ((1 << numBits) - 1) + w];
    } else {
        // only bits, no trits or quints. We can have between 1 and 6 bits.
        uint offset = index * numBits;
        uint w = extractBits(weightData, offset, numBits);

        // The first number in the table is the multiplication factor: 63 / (2^numBits - 1)
        // The second number is a shift factor to adjust when the previous result isn't an integer.
        const uvec2 kUnquantTable[] = {{63, 8}, {21, 8}, {9, 8}, {4, 2}, {2, 4}, {1, 8}};
        const uvec2 unquant = kUnquantTable[numBits - 1];
        w = w * unquant.x | w >> unquant.y;
        if (w > 32) w += 1;
        return w;
    }
}

uint interpolateWeights(uvec4 weightData, uvec3 encoding, uint numWeights, uint index,
                        uint gridWidth, uint stride, uint offset, uvec2 fractionalPart) {
    uvec4 weightIndices = stride * (uvec4(index) + uvec4(0, 1, gridWidth, gridWidth + 1)) + offset;

    // TODO(gregschlom): Optimization idea: instead of always decoding 4 weights, we could decode
    // just what we need depending on whether fractionalPart.x and fractionalPart.y are 0
    uvec4 weights = uvec4(decode1Weight(weightData, encoding, numWeights, weightIndices[0]),
                          decode1Weight(weightData, encoding, numWeights, weightIndices[1]),
                          decode1Weight(weightData, encoding, numWeights, weightIndices[2]),
                          decode1Weight(weightData, encoding, numWeights, weightIndices[3]));

    uint w11 = (fractionalPart.x * fractionalPart.y + 8) >> 4;
    uvec4 factors = uvec4(16 - fractionalPart.x - fractionalPart.y + w11,  // w00
                          fractionalPart.x - w11,                          // w01
                          fractionalPart.y - w11,                          // w10
                          w11);                                            // w11

    return uint(dot(weights, factors) + 8) >> 4;  // this is what the spec calls "effective weight"
}

uvec2 decodeWeights(uvec4 weightData, const uvec2 posInBlock) {
    // Refer to "C.2.18  Weight Infill to interpolate between 4 grid points"

    // TODO(gregschlom): The spec says: "since the block dimensions are constrained, these are
    // easily looked up in a table." - Is it worth doing?
    uvec2 scaleFactor = (1024 + blockSize / 2) / (blockSize - 1);

    uvec2 homogeneousCoords = posInBlock * scaleFactor;
    uvec2 gridCoords = (homogeneousCoords * (weightGridSize - 1) + 32) >> 6;
    uvec2 integralPart = gridCoords >> 4;
    uvec2 fractionalPart = gridCoords & 0xf;

    uint gridWidth = weightGridSize.x;
    uint v0 = integralPart.y * gridWidth + integralPart.x;

    uvec2 weights = uvec2(0);
    weights.x = interpolateWeights(weightData, weightEncoding, numWeights, v0, gridWidth,
                                   1 << int(dualPlane), 0, fractionalPart);
    if (dualPlane) {
        weights.y = interpolateWeights(weightData, weightEncoding, numWeights, v0, gridWidth, 2, 1,
                                       fractionalPart);
    }
    return weights;
}

uint hash52(uint p) {
    p ^= p >> 15;
    p -= p << 17;
    p += p << 7;
    p += p << 4;
    p ^= p >> 5;
    p += p << 16;
    p ^= p >> 7;
    p ^= p >> 3;
    p ^= p << 6;
    p ^= p >> 17;
    return p;
}

uint selectPartition(uint seed, uvec2 pos, uint numPartitions) {
    if (numPartitions == 1) {
        return 0;
    }
    if (blockSize.x * blockSize.y < 31) {
        pos <<= 1;
    }
    seed = 1024 * numPartitions + (seed - 1024);
    uint rnum = hash52(seed);
    // TODO(gregschlom): micro-optimization: could repetedly halve the bits to extract them in 6
    // calls to bitfieldExtract instead of 8.
    uvec4 seedA = uvec4(bitfieldExtract(rnum, 0, 4), bitfieldExtract(rnum, 4, 4),
                        bitfieldExtract(rnum, 8, 4), bitfieldExtract(rnum, 12, 4));
    uvec4 seedB = uvec4(bitfieldExtract(rnum, 16, 4), bitfieldExtract(rnum, 20, 4),
                        bitfieldExtract(rnum, 24, 4), bitfieldExtract(rnum, 28, 4));

    seedA = seedA * seedA;
    seedB = seedB * seedB;

    uvec2 shifts1 = uvec2((seed & 2) != 0 ? 4 : 5, numPartitions == 3 ? 6 : 5);
    uvec4 shifts2 = (seed & 1) != 0 ? shifts1.xyxy : shifts1.yxyx;

    seedA >>= shifts2;
    seedB >>= shifts2;

    // Note: this could be implemented as matrix multiplication, but we'd have to use floats and I'm
    // not sure if the values are always small enough to stay accurate.
    uvec4 result =
        uvec4(dot(seedA.xy, pos), dot(seedA.zw, pos), dot(seedB.xy, pos), dot(seedB.zw, pos)) +
        (uvec4(rnum) >> uvec4(14, 10, 6, 2));

    result &= uvec4(0x3F);

    if (numPartitions == 2) {
        result.zw = uvec2(0);
    } else if (numPartitions == 3) {
        result.w = 0;
    }

    // Return the index of the largest component in `result`
    if (all(greaterThanEqual(uvec3(result.x), result.yzw))) {
        return 0;
    } else if (all(greaterThanEqual(uvec2(result.y), result.zw))) {
        return 1;
    } else if (result.z >= result.w) {
        return 2;
    } else {
        return 3;
    }
}

uvec3 getEndpointEncoding(uint availableEndpointBits, uint numEndpoints, out uint actualSize) {
    // This implements the algorithm described in section "C.2.22  Data Size Determination"
    // TODO(gregschlom): This could be implemented with a lookup table instead. Or we could use a
    // binary search but not sure if worth it due to the extra cost of branching.
    for (uint i = 0; i < kColorEncodings.length(); ++i) {
        uvec3 encoding = kColorEncodings[i];
        actualSize = getEncodingSize(numEndpoints, encoding);
        if (actualSize <= availableEndpointBits) {
            return encoding;
        }
    }
    return uvec3(0);  // this should never happen
}

ivec4 blueContract(ivec4 v) { return ivec4((v.r + v.b) >> 1, (v.g + v.b) >> 1, v.ba); }

int sum(ivec3 v) { return v.x + v.y + v.z; }

void bitTransferSigned(inout ivec4 a, inout ivec4 b) {
    b >>= 1;
    b |= a & 0x80;
    a >>= 1;
    a &= 0x3f;
    // This is equivalent to: "if ((a & 0x20) != 0) a -= 0x40;" in the spec. It treats "a" as a
    // 6-bit signed integer, converting it from (0, 63) to (-32, 31)
    a = bitfieldExtract(a, 0, 6);
}

// Decodes the endpoints and writes them to ep0 and ep1.
// vA: even-numbered values in the spec (ie: v0, v2, v4 and v6)
// vB: odd-numbered values in the spec (ie: v1, v3, v5 and v7)
// mode: the CEM (color endpoint mode)
// Note: HDR modes are not supported.
void decodeEndpoints(ivec4 vA, ivec4 vB, uint mode, out uvec4 ep0, out uvec4 ep1) {
    switch (mode) {
        case 0:  // LDR luminance only, direct
            ep0 = uvec4(vA.xxx, 255);
            ep1 = uvec4(vB.xxx, 255);
            return;

        case 1: {  // LDR luminance only, base + offset
            const int l0 = (vA.x >> 2) | (vB.x & 0xC0);
            const int l1 = min(l0 + (vB.x & 0x3F), 255);
            ep0 = uvec4(uvec3(l0), 255);
            ep1 = uvec4(uvec3(l1), 255);
            return;
        }

        case 4:  // LDR luminance + alpha, direct
            ep0 = vA.xxxy;
            ep1 = vB.xxxy;
            return;

        case 5:  // LDR luminance + alpha, base + offset
            bitTransferSigned(vB, vA);
            ep0 = clamp(vA.xxxy, 0, 255);
            ep1 = clamp(vA.xxxy + vB.xxxy, 0, 255);
            return;

        case 6:  // LDR RGB, base + scale
            ep1 = uvec4(vA.x, vB.x, vA.y, 255);
            ep0 = uvec4((ep1.rgb * vB.y) >> 8, 255);
            return;

        case 10:  //  LDR RGB, base + scale, plus alphas
            ep1 = uvec4(vA.x, vB.x, vA.y, vB.z);
            ep0 = uvec4((ep1.rgb * vB.y) >> 8, vA.z);
            return;

        case 8:  // LDR RGB, direct
            vA.a = 255;
            vB.a = 255;
        case 12:  // LDR RGBA, direct
            if (sum(vB.rgb) >= sum(vA.rgb)) {
                ep0 = vA;
                ep1 = vB;
            } else {
                ep0 = blueContract(vB);
                ep1 = blueContract(vA);
            }
            return;

        case 9:  // LDR RGB, base + offset
            // We will end up with vA.a = 255 and vB.a = 0 after calling bitTransferSigned(vB, vA)
            vA.a = 255;
            vB.a = -128;
        case 13:  // LDR RGBA, base + offset
            bitTransferSigned(vB, vA);
            if (sum(vB.rgb) >= 0) {
                ep0 = clamp(vA, 0, 255);
                ep1 = clamp(vA + vB, 0, 255);
            } else {
                ep0 = clamp(blueContract(vA + vB), 0, 255);
                ep1 = clamp(blueContract(vA), 0, 255);
            }
            return;

        default:
            // Unimplemented color encoding. (HDR)
            ep0 = uvec4(0);
            ep1 = uvec4(0);
    }
}

uint decode1Endpoint(uvec4 data, uint startOffset, uint index, uvec3 encoding) {
    uint numBits = encoding.z;

    if (encoding.x == 1) {
        // 1 trit
        uint offset = (index / 5) * (5 * numBits + 8) + startOffset;
        uint ep = decodeTrit(data, offset, numBits, index % 5);
        return kUnquantTritColorMap[3 * ((1 << numBits) - 1) + ep];
    } else if (encoding.y == 1) {
        // 1 quint
        uint offset = (index / 3) * (3 * numBits + 7) + startOffset;
        uint ep = decodeQuint(data, offset, numBits, index % 3);
        return kUnquantQuintColorMap[5 * ((1 << numBits) - 1) + ep];
    } else {
        // only bits, no trits or quints. We can have between 1 and 8 bits.
        uint offset = index * numBits + startOffset;
        uint w = extractBits(data, offset, numBits);
        // The first number in the table is the multiplication factor. 255 / (2^numBits - 1)
        // The second number is a shift factor to adjust when the previous result isn't an integer.
        const uvec2 kUnquantTable[] = {{255, 8}, {85, 8}, {36, 1}, {17, 8},
                                       {8, 2},   {4, 4},  {2, 6},  {1, 8}};
        const uvec2 unquant = kUnquantTable[numBits - 1];
        return w * unquant.x | w >> unquant.y;
    }
}

// Creates a 128-bit mask with the lower n bits set to 1
uvec4 buildBitmask(uint bits) {
    ivec4 numBits = int(bits) - ivec4(96, 64, 32, 0);
    uvec4 mask = (uvec4(1) << clamp(numBits, ivec4(0), ivec4(31))) - 1;
    return mix(mask, uvec4(0xffffffffu), greaterThanEqual(uvec4(bits), uvec4(128, 96, 64, 32)));
}

// Main function to decode the texel at a given position in the block
uvec4 astcDecodeTexel(const uvec2 posInBlock) {
    if (decodeError) {
        return kErrorColor;
    }

    if (voidExtent) {
        return uvec4(bitfieldExtract(astcBlock[1], 8, 8), bitfieldExtract(astcBlock[1], 24, 8),
                     bitfieldExtract(astcBlock[0], 8, 8), bitfieldExtract(astcBlock[0], 24, 8));
    }

    const uvec4 weightData = bitfieldReverse(astcBlock.wzyx) & buildBitmask(weightDataSize);
    const uvec2 weights = decodeWeights(weightData, posInBlock);

    const uint partitionIndex = selectPartition(partitionSeed, posInBlock, numPartitions);

    uint startOfExtraCem = 0;
    uint totalEndpoints = 0;
    uint baseEndpointIndex = 0;
    uint cem = decodeCEM(partitionIndex, startOfExtraCem, totalEndpoints, baseEndpointIndex);

    // Per spec, we must return the error color if we require more than 18 color endpoints
    if (totalEndpoints > 18) {
        return kErrorColor;
    }

    const uint endpointsStart = (numPartitions == 1) ? 17 : 29;
    const uint endpointsEnd = -2 * int(dualPlane) + startOfExtraCem;
    const uint availableEndpointBits = endpointsEnd - endpointsStart;
    // TODO(gregschlom): Do we need this: if (availableEndpointBits >= 128) return kErrorColor;

    uint actualEndpointBits;
    const uvec3 endpointEncoding =
        getEndpointEncoding(availableEndpointBits, totalEndpoints, actualEndpointBits);
    // TODO(gregschlom): Do we need this: if (endpointEncoding == uvec3(0)) return kErrorColor;

    // Number of endpoints pairs in this partition. (Between 1 and 4)
    // This is the n field from "Table C.2.17 - Color Endpoint Modes" divided by two
    const uint numEndpointPairs = (cem >> 2) + 1;

    ivec4 vA = ivec4(0);  // holds what the spec calls v0, v2, v4 and v6
    ivec4 vB = ivec4(0);  // holds what the spec calls v1, v3, v5 and v7

    uvec4 epData = astcBlock & buildBitmask(endpointsStart + actualEndpointBits);

    for (uint i = 0; i < numEndpointPairs; ++i) {
        const uint epIdx = 2 * i + baseEndpointIndex;
        vA[i] = int(decode1Endpoint(epData, endpointsStart, epIdx, endpointEncoding));
        vB[i] = int(decode1Endpoint(epData, endpointsStart, epIdx + 1, endpointEncoding));
    }

    uvec4 ep0, ep1;
    decodeEndpoints(vA, vB, cem, ep0, ep1);

    uvec4 weightsPerChannel = uvec4(weights[0]);
    if (dualPlane) {
        uint ccs = extractBits(astcBlock, endpointsEnd, 2);
        weightsPerChannel[ccs] = weights[1];
    }

    return (ep0 * (64 - weightsPerChannel) + ep1 * weightsPerChannel + 32) >> 6;

    // TODO(gregschlom): Check section "C.2.19  Weight Application" - we're supposed to do something
    // else here, depending on whether we're using sRGB or not. Currently we have a difference of up
    // to 1 when compared against the reference decoder. Probably not worth trying to fix it though.
}