Accessing 8-bit data as 7-bit

Not sure what you mean by "cleaner". Typically, people who work on a problem like this regularly see wrapping and masking as the right primitive tool to use. It is possible to do something like defining a bit abstraction with a method to read an arbitrary number of bits from the stream. This abstraction sometimes appears in compression applications. The internals of the method, of course, use offset and masking.

One fairly clean approach is to write a function that retrieves a 7-bit number at any bit index in an unsigned char array. Use division to convert the bit index to byte index and modulus to get the bit index in byte. Then slide and mask. The input bits can span two bytes, so you either need to glue the 16-bit value before extracting, or do two smaller extractions and / or together to plot the result.

If I were aiming for something moderately productive, I would probably take one of two approaches:

The first has two state variables that indicate how many bits to take from the current and next bytes. It will use shift, masking and bitwise value, or to create the current output (for example, a number from 0 to 127 as an int), then the loop will update both state variables by adding and modulo, and will increment the current byte pointers if all bits are in the first byte were used.

The second approach is to load the 56 bit (8 outputs of the input) into a 64 bit integer and use the fully expanded structure to extract each of the 8 outputs. Doing this without using unmodified memory reads requires building a 64-bit integer chunk. (56 bits is special because the starting bit position is byte-aligned.)

To go really fast, I can try writing SIMD code in Halide. I suppose this is out of scope. (And it's not clear that he will actually win much.)

Constructs that read more than one byte into an integer at a time will probably have to respect the processor's byte order.

Here's one approach without manual switching. This is just a rough POC, but hopefully you can learn something from this. I don't know if you can easily convert your input to bitbit, but I think it should be possible.

int bytes = 0x01234567;
bitset<32> bs(bytes);
cout << "Input: " << bs << endl;
for(int i = 0; i < 5; i++)
{
    bitset<7> slice(bs.to_string().substr(i*7, 7));
    cout << slice << endl;
}

      

        
        
        
      

    

Plus, it's probably much less doable than the bitrate version, so I wouldn't recommend it for heavy work.

You can use this to get the 7 bit index element from in

(note that it does not have proper array processing completion). Simple, fast.

int get7(const uint8_t *in, int index) {
    int fidx = index*7;
    int idx = fidx>>3;
    int sidx = fidx&7;

    return (in[idx]>>sidx|in[idx+1]<<(8-sidx))&0x7f;
}

      

        
        
        
      

    

Process them in groups of 8 (since 8x7 are nicely rounded to 8-bit aligned). Bitwise operators are the order of the day here. Hunting with the last (up) 7 numbers is a little awkward, but not impossible. (This code assumes they are unsigned 7-bit integers! A signed conversion would require you to consider flipping the top bit if bit [6] is 1)

// convert 8 x 7bit ints in one go
void extract8(const uint8_t input[7], uint8_t output[8])
{
  output[0] =   input[0] & 0x7F;
  output[1] =  (input[0] >> 7)  | ((input[1] << 1) & 0x7F);
  output[2] =  (input[1] >> 6)  | ((input[2] << 2) & 0x7F);
  output[3] =  (input[2] >> 5)  | ((input[3] << 3) & 0x7F);
  output[4] =  (input[3] >> 4)  | ((input[4] << 4) & 0x7F);
  output[5] =  (input[4] >> 3)  | ((input[5] << 5) & 0x7F);
  output[6] =  (input[5] >> 2)  | ((input[6] << 6) & 0x7F);
  output[7] =   input[6] >> 1;
}

// convert array of 7bit ints to 8bit
void seven_bit_to_8bit(const uint8_t* const input, uint8_t* const output, const size_t count)
{
  size_t count8 = count >> 3;
  for(size_t i = 0; i < count8; ++i)
  {
    extract8(input + 7 * i, output + 8 * i);
  }

  // handle remaining (upto) 7 bytes 
  const size_t countr = (count % 8);
  if(countr)
  {
    // how many bytes do we need to copy from the input?
    size_t remaining_bits = 7 * countr;
    if(remaining_bits % 8)
    {
      // round to next nearest multiple of 8
      remaining_bits += (8 - remaining_bits % 8);
    }
    remaining_bits /= 8;
    {
      uint8_t in[7] = {0}, out[8] = {0};
      for(size_t i = 0; i < remaining_bits; ++i)
      {
        in[i] = input[count8 * 7 + i];
      }
      extract8(in, out);
      for(size_t i = 0; i < countr; ++i)
      {
        output[count8 * 8 + i] = in[i];
      }
    }
  }
}