Загрузить черно-белое изображение в массив

#include <iostream>
#include <fstream>
#include <stdint.h>
 
//загрузка в однобайтовый массив монохромный образ
bool load_monochrome(const char* filename, uint8_t*& bits, int& width, int& height){
    std::ifstream fp(filename, std::ifstream::binary);
    if(! fp.is_open())
        return false;
 
    uint16_t ws[7];
    fp.read((char*)&ws[0], sizeof(ws)); 
    if(fp.fail() || (ws[0] != 0x4D42))
        return false;
 
    int32_t ds[10];
    fp.read((char*)&ds[0], sizeof(ds));
 
    int bpp = (int)(ds[3] >> 16);
    if(fp.fail() || (ds[4] != 0) || (bpp != 1))
        return false;
 
    width  = ds[1];
    height = (ds[2] < 0) ? -ds[2] : ds[2];
 
    int      lrow  = (width * bpp + 31) / 32 * 4;
    int32_t  lsize = (ds[5] > 0) ? ds[5] : (lrow * height);
    uint8_t* lbuf  = new (std::nothrow) uint8_t[lsize];
    if(lbuf == NULL)
        return false;
 
    uint32_t rgb[2];
    fp.read((char*)&rgb[0], sizeof(rgb));
    if(fp.gcount() != sizeof(rgb)){
        delete[] lbuf;
        return false;
    }
 
    fp.seekg((((long)ws[6] << 16) | ws[5]), fp.beg);
    fp.read((char*)lbuf, lsize);
    if(fp.gcount() != lsize){
        delete[] lbuf;
        return false;
    }
    fp.close();
 
    bits = new (std::nothrow) uint8_t[width * height];
    if(bits == NULL){
        delete[] lbuf;
        return false;
    }
 
    uint8_t* lbits;
    int      lpitch;
    if(ds[2] < 0){
        lbits  = lbuf;
        lpitch = lrow;
    } else {
        lbits  = lbuf + ((height - 1) * lrow);  
        lpitch = -lrow;
    }
 
    uint8_t* src, *dst;
    for(int y = 0; y < height; ++y){
        src = lbits + (y * lpitch);
 
        if(ds[2] < 0)
            dst = bits + ((height - 1 - y) * width);
        else
            dst = bits + (y * width);
 
        for(int x = 0; x < width; ++x)
            *dst++ = rgb[(src[x / 8] >> (7 - x % 8)) & 1] != 0;
    }
    delete[] lbuf;
    return true;
}
 
 
int main(void){ 
    char fn[] = "car.bmp";
        
    int      width, height;
    uint8_t* bits;
    if(load_monochrome(fn, bits, width, height)){
 
        /*
        for(int y = 0; y < height; ++y){
            for(int x = 0; x < width; ++x){
                bits[y*width + x]
                ...
            }
        }*/
 
        //...
 
        delete[] bits;
    } else
        std::cerr << "error load!" << std::endl;
 
    std::cin.get();
    return 0;
}