Найти последовательность единичных битов

#include <iostream>
#include <cstdint>
#include <climits>
 
size_t find_bit_seq(std::uint8_t* bitmap, std::size_t size, std::size_t length){
   if (length > size*CHAR_BIT)
      return size;
   for(std::size_t bit = 0, bitseq = 0, byte = 0; byte != size; ++byte){
      for(std::uint8_t b = 1 << (CHAR_BIT - 1); b != 0; b >>= 1, ++bit){
         if (bitmap[byte] & b)
            ++bitseq;
         else
            bitseq = 0;
         if (bitseq == length)
            return bit + 1 - length;
      }
   }
   return size;
}
 
int main(){
   const std::size_t SIZE = 2;
   std::uint8_t bitmap[SIZE] = {
      0b11000001,
      0b11101010
   };
   size_t pos = find_bit_seq(bitmap, SIZE, 4);
   if (pos == SIZE)
      std::cout << "not found";
   else
      std::cout << "found at : " << pos;
   std::cout << std::endl;
}

uint8_t bitmap[SIZE] = {
0b11000001,0b11101010,0b00001100,0b00000000,0b00000000,0b00000000,0b00000000,0b00000011,0b11100000,0b00000000,0b00000000,0b00000000

int main()
{
    const size_t SIZE = 12;
    
    uint8_t bitmap[SIZE] = {
0b11000001,0b11101010,0b00001100,0b00000000,0b00000000,0b00000000,0b00000000,0b00000011,0b11100000,0b00000000,0b00000000,0b00000000
    };
uint8_t *ptr = &bitmap[0];
 
    for (short j = 0; j < SIZE; ++j) {
        for (int i = 7; i >= 0; --i) {
            if (*ptr & (1 << i))
                printf("%c", '1');
            else printf("%c", '0');
        }
        ++ptr;
        }

int main()
{
    const size_t SIZE = 12;
    uint8_t bitmap[SIZE] = {
0b11000001,0b11101010,0b00001100,0b00000000,0b00000000,0b00000000,
0b00000000,0b00000011,0b11100000,0b00000000,0b00000000,0b00000000
    };
uint8_t *ptr = &bitmap[0];// int покрывает четыра байта сразу
unsigned short sdf{};
unsigned short indx{};
 
for (short j = 0; j < SIZE; ++j) {
    for (int i = 7; i >= 0; --i) {
        if (*ptr & (1 << i)) {
            ++sdf;
        } else {
            printf("index-%u --- count %u\n  ", indx - sdf, sdf); sdf = 0;
             }
        ++indx;
    }
    ++ptr;
}
getchar();
}

int leftDictionary[255]; // сколько единиц вначале
int rightDictionary[255]; //сколько единиц вконце
 
int position[6][256]; // если есть непрерывная последоваетльность до 6 байт строго внутри байта, то будет битовый адрес, иначе -1
 
 
int find_bit_seq(uint8_t* bitmap, int arraySize, int length)
{
    int continuesSequenceLength = 0; // текущая длина непрерыной последовательности байт
    int startIndex = 0; // индекс начала непрерывной последовательности 
    int canFullContainsInByte = length<7;
    for (int i=0; i<arraySize; i++)
    {
        int currentByte = bitmap[i];
        if (currentByte == 0xFF) // 8 единиц - продолжаем считать
        {
            continuesSequenceLength += 8;
            continue;
        }
        continuesSequenceLength += leftDictionary[currentByte]; // в последовательности есть хоть один ноль, значит добавить число бит из начала
        if (continuesSequenceLength == length)
            return startIndex;
        if (canFullContainsInByte && position[length][currentByte]>0) // если последоваетльность коротка, то проверить есть ли строго в середине байта.
            return i*8 + position[length][currentByte];
        continuesSequenceLength = rightDictionary[currentByte]; // начать отсчитывать новую непрерывную последоваетельность байт с конца.
        startIndex = (i+1)*8 - continuesSequenceLength;
        
    }
    
    if (continuesSequenceLength == length)
    return startIndex;
}

#include <cassert>
#include <intrin.h>
#include <stdint.h>
#include <stdio.h>
#include "type.h"
 
#define __packed
#pragma pack(push, 1)
typedef unsigned long u32p8;
#pragma pack(pop)
 
//#define ncell(m) (sizeof(m) / sizeof((m)[0]))
 
struct BitmapPad {
  enum {SIZE = 256};
  u32 data[(SIZE + 3) / 4];
  u32 pad;
  int BitsFind(int len);
} bitmapPad;
 
int BitmapPad::BitsFind(int len)
{
  assert(len && len < 33);
  ulong i0, i1;
  pad = 0;
  if (SIZE & 3) data[ncell(data) - 1] = data[ncell(data) - 1] << 32 - (SIZE & 3) * 8 >> 32 - (SIZE & 3) * 8;
  u32 mask = (1 << len) - 1;
  u32 *p = (u32 *)&data[0];
  u32 j, j0 = *p++, j1;
  uint n = ncell(data);
  do {
    for (j1 = *p++; _BitScanForward(&i0, j0); j0 = j0 << i0) {
      j0 >>= i0;
      if (!(mask & ~(j0 | j1 << 32 - i0))) return ((u8 *)p - (u8 *)&data[2]) * 8 + i0;
      _BitScanForward(&i1, ~j0);
      i0 += i1;
      j0 >>= i1;
    }
    j0 = j1;
  } while (--n);
  return -1;
}
 
int main()
{
  int i;
 
  memset(&bitmapPad, 0, sizeof(bitmapPad));
  *(u32p8 *)&bitmapPad.data[32] = 31 << 7;
  i = bitmapPad.BitsFind(5);
  if (i < 0) printf("1. Not found\n");
  else printf("1. Found at bit = %u\n", i);
 
  memset(&bitmapPad, 0, sizeof(bitmapPad));
  *(u32p8 *)((u8 *)&bitmapPad.data[32] + 3) = 31 << 5 | 15;
  i = bitmapPad.BitsFind(5);
  if (i < 0) printf("2. Not found\n");
  else printf("2. Found at bit = %u\n", i);
 
  memset(&bitmapPad, 0, sizeof(bitmapPad));
  *(u32p8 *)((u8 *)&bitmapPad.data[32] + 3) = 15 << 5 | 15;
  i = bitmapPad.BitsFind(5);
  if (i < 0) printf("3. Not found\n");
  else printf("3. Found at bit = %u\n", i);
 
  return 0;
}