Function bitcount

cmp_compressonatorlib/astc/astc_encode_kernel.cpp:9046–9094

after a few rounds of k-means-clustering, we should have a set of 2, 3 or 4 partitions; we turn this set into 2, 3 or 4 bitmaps. Then, for each of the ( 64 bit uses 1024) (32 bit uses ???) partitions, we try to match the bitmaps as well as possible. maybe an issue for GPU to work in 64bits static inline

//# maybe an issue for GPU to work in 64bits
//static inline
int bitcount(uint64_cl p)
{
#ifdef ENABLE_64Bit_Support
    bool isTrue = sizeof(void*) > 4;
    if (isTrue)
    {
        uint64_cl mask1 = 0x5555555555555555ULL;
        uint64_cl mask2 = 0x3333333333333333ULL;
        uint64_cl mask3 = 0x0F0F0F0F0F0F0F0FULL;
        // best-known algorithm for 64-bit bitcount, assuming 64-bit processor
        // should probably be adapted for use with 32-bit processors and/or processors
        // with a POPCNT instruction, but leave that for later.
        p -= (p >> 1) & mask1;
        p = (p & mask2) + ((p >> 2) & mask2);
        p += p >> 4;
        p &= mask3;
        p *= 0x0101010101010101ULL;
        p >>= 56;
        return (int)p;
    }
    else
#endif
    {
        uint32_t mask1 = 0x55555555U;
        uint32_t mask2 = 0x33333333U;
        uint32_t mask3 = 0x0F0F0F0FU;

        // on 32-bit processor, split the 64-bit input argument in two,
        // and bitcount each half separately.
        uint32_t p1 = (uint32_t)p;

        p1 = p1 - ((p1 >> 1) & mask1);
        p1 = (p1 & mask2) + ((p1 >> 2) & mask2);
        p1 += p1 >> 4;
        p1 &= mask3;

#ifdef ENABLE_64Bit_Support
        uint32_t p2 = (uint32_t)(p >> 32);
        p2          = p2 - ((p2 >> 1) & mask1);
        p2          = (p2 & mask2) + ((p2 >> 2) & mask2);
        p2 += p2 >> 4;
        p2 &= mask3;
        p1 += p2;
#endif
        p1 *= 0x01010101U;
        p1 >>= 24;
        return (int)p1;
    }
}

//static inline
int MIN3(int a, int b, int c)