Welcome to the Lounge

// 24-bit BGR
using bgr888 = pixel<
    channel_traits<channel_name::B,8>,
    channel_traits<channel_name::G,8>,
    channel_traits<channel_name::R,8>
>;    
// 16-bit RGB
using rgb565 = pixel<
    channel_traits< channel_name::R,5>,
    channel_traits<channel_name::G,6>,
    channel_traits<channel_name::B,5>
>;
// 8-bit grayscale
using gsc8 = pixel<
    channel_traits<channel_name::L,8>
>;
// 1-bit monochrome
using mono1 = pixel<
    channel_traits<channel_name::L,1>
>;
// 8-bit RGB
using rgb888 = pixel<
        channel_traits<channel_name::R,8>,
        channel_traits<channel_name::G,8>,
        channel_traits<channel_name::B,8>
    >;
// 18-bit RGB
using rgb666 = pixel<
        channel_traits<channel_name::R,6>,
        channel_traits<channel_name::G,6>,
        channel_traits<channel_name::B,6>
    >;

using pixel_type = rgb666;
using bmp_type = bitmap<pixel_type>;

pixel_type p = color<pixel_type>::light_green;

uint8_t buf[bmp_type::sizeof_buffer(16,16)];

bmp_type bmp(16,16,buf);

bmp[point16(7,7)]=p;
p = bmp[point16(7,7)];

Greg Utas wrote:

Only those of us whose names end in -saurus wrote code for a PDP-10 or Univac.

const size_t offs =  ( (dstr.top()+dy)*dimensions().width+dstr.left() ) *pixel_type::bit_depth;

static void shift_left(void* bits,size_t offset_bits,size_t size_bits, size_t shift) {
    if(nullptr==bits || 0==size_bits || 0==shift) {
        return;
    }
    // special case if we shift all the bits out
    if(shift>=size_bits) {
        set_bits(bits,offset_bits,size_bits,false);
        return;
    }
    uint8_t* pbegin = ((uint8_t*)bits)+(offset_bits/8);
    const size_t offset = offset_bits % 8;
    const size_t shift_bytes = shift / 8;
    const size_t shift_bits = shift % 8;
    const size_t overhang = (size_bits+offset_bits) % 8;
    // preserves left prior to offset
    const uint8_t left_mask = ((uint8_t)uint8_t(0xFF<<(8-offset)));
    // preserves right after overhang
    const uint8_t right_mask = 0!=overhang?uint8_t(0xFF>>overhang):0;
    uint8_t* pend = pbegin+(size_t)((offset_bits+size_bits)/8.0+.999999);
    uint8_t* plast = pend-1;
    uint8_t* psrc = pbegin+shift_bytes;
    uint8_t* pdst = pbegin;
    if(pbegin+1==pend) {
        // special case for a shift all within one byte
        uint8_t save_mask = left_mask|right_mask;
        uint8_t tmp = *pbegin;
        *pbegin = uint8_t(uint8_t(tmp<<shift_bits)&~save_mask)|
                uint8_t(tmp&save_mask);
        return;
    }
    // preserve the ends so we can
    // fix them up later
    uint8_t left = *pbegin;
    uint8_t right = *(pend-1);
    
    while(pdst!=pend) {
        uint8_t src = psrc<pend?*psrc:0;
        uint8_t src2 = (psrc+1)<pend?*(psrc+1):0;
        *pdst = (src<<shift_bits)|(src2>>(8-shift_bits));
        ++psrc;
        ++pdst;
    }
    
    *pbegin=(left&left_mask)|uint8_t(*pbegin&~left_mask);
    --pend;
    *plast=uint8_t(right&right_mask)|uint8_t(*plast&uint8_t(~right_mask));
};

inline static void set_bits(size_t offset_bits,size_t size_bits,void* dst,const void* src) {
    const size_t offset_bytes = offset_bits / 8;
    const size_t offset = offset_bits % 8;
    const size_t total_size_bytes = (offset_bits+size_bits)/8.0+.999999999;
    const size_t overhang = (offset_bits+size_bits) % 8;
    uint8_t* pbegin = ((uint8_t*)dst)+offset_bytes;
    uint8_t* psbegin = ((uint8_t*)src)+offset_bytes;
    uint8_t* pend = ((uint8_t*)dst)+total_size_bytes;
    uint8_t* plast = pend-(pbegin!=pend);

    const uint8_t maskL = 0!=offset?
                                (uint8_t)((uint8_t(0xFF>>offset))):
                                uint8_t(0xff);
    const uint8_t maskR = 0!=overhang?
                            (uint8_t)~((uint8_t(0xFF>>overhang))):
                            uint8_t(0xFF);
    if(pbegin==plast) {
        uint8_t v = *psbegin;
        const uint8_t mask = maskL & maskR;
        v&=mask;
        *pbegin&=~mask;
        *pbegin|=v;
        return;
    }
    *pbegin&=~maskL;
    *pbegin|=((*psbegin)&maskL);
    *plast&=~maskR;
    *plast|=((*(psbegin+total_size_bytes-1))&maskR);
    if(pbegin+1<plast) {
        const size_t len = plast-(pbegin+1);
        if(0!=len&&len<=total_size_bytes) 
            memcpy(pbegin+1,psbegin+1,len);
    }
}