C: Computing a series of bits spanned over several bytes - c

Question

I have got a unsigned char array of bytes like:
unsigned char[20] = {0xff, 0x1a, 0x70, 0xa9, ...}
I now want to perform computations over x consecutive bits of this array (with x > 8; e.g x = 15). In particular, I want to perform majortiy voting on every 15 bits, which returns a single bit. Subsequently, the returned single bits shall be converted to an unsigned char byte again.
I already implemented the majorityVoting algorithm. I also implemented a naive algorithm for the whole problem, which works this way:
Convert the byte array into a bit array (also unsigned char[] holding zeros and ones)
Loop over the bit array and pass every series of x bits to the majority voting function
Collect the majority vote results also in a bit array (unsigned char[])
Loop over this bit array and use bitwise operations to construct bytes from every series of 8 bits.
To me this seems intuitive but cumbersome at the same time.
Do you see any possibilities for optimization or could you even give a slicker algorithm?
Best regards,
P.

Answer 1

You could get the next bit of the array with a function like that
int nextBit( unsigned char [] arr, int *pByte, size_t nBytes, int *pBit )
{
int result;
if( *pByte >= nBytes ) {
// Padding, neccessary if nBytes % 15 != 0
return 0;
} else {
result = ( arr[*pByte] >> (*pBit) ) & 0x1;
if( *pBit == 7 ) {
(*pByte)++;
*pBit = 0;
} else {
(*pBit)++;
}
return result;
}
}
and loop:
int byte=0, bit=0;
int result;
int i;
while( byte < sizeof( arr ) ) {
for( i=0; i<15; i++ ) {
result = nextBit( arr, &byte, sizeof( arr ), &bit );
// do the majority voting
}
}
A quite similar function can be created to directly create an array of the majority bits

Answer 2

You could bitshift every byte into 17 bits (and store them in 17 bytes).
uint8_t bits[17];
bits[0] = !!(bytes[0] & 128);
bits[1] = !!(bytes[0] & 64);
bits[2] = !!(bytes[0] & 32);
bits[3] = !!(bytes[0] & 16);
bits[4] = !!(bytes[0] & 8);
bits[5] = !!(bytes[0] & 4);
bits[6] = !!(bytes[0] & 2);
bits[7] = !!(bytes[0] & 1);
bits[8] = !!(bytes[1] & 128);
bits[9] = !!(bytes[1] & 64);
bits[10] = !!(bytes[1] & 32);
bits[11] = !!(bytes[1] & 16);
bits[12] = !!(bytes[1] & 8);
bits[13] = !!(bytes[1] & 4);
bits[14] = !!(bytes[1] & 2);
bits[15] = !!(bytes[1] & 1);
bits[16] = !!(bytes[2] & 128);
I'm not sure about what you want to do with those bits, but you can also consider storing the bits in a 32 bit integer:
uint32_t chunk = (bytes[0] << 9) | (bytes[1] << 1) | (bytes[2] & 1);