Welcome to the Lounge

Stuart Dootson wrote:

a whole set of bitmask and bitfield register functions that do as much work as possible at compile-time to ensure that a) bit-mask constants can be used in a constexpr context

honey the codewitch wrote:

Made extra difficult for the fact that in certain cases (like with 1 bit monochrome) I am not reading and writing on byte boundaries, but bit boundaries

using bf1 = bit_field_t<21, 10>;
using bf2 = bit_field_t<31, 24>;
using bf3 = bit_field_t<0, 0>;
using bf4 = bit_field_t<1, 1>;
using bf5 = bit_field_t<2, 2>;
using bf6 = bit_field_t<3, 3>;
using bf7 = bit_field_t<4, 8>;
using bf9 = bit_field_t<6, 6>;
using reg1_t = bit_field_register_t<bf1, bf2, bf3, bf4, bf5, bf6, bf7>;
using reg2_t = bit_field_register_t<bf1, bf2, bf3, bf4, bf5, bf6, bf9>;

int foo(reg1_t *r1) {
  r1->insert<bf1>(123);
  return r1->extract<bf7>();
}

mov     eax, dword ptr [rdi]
mov     ecx, eax
and     ecx, -4193281
or      ecx, 125952
mov     dword ptr [rdi], ecx
shr     eax, 4
and     eax, 31
ret

constexpr inline static int_type at(const uint8_t* bitmap,size_t index) {
    if(native_int) {
        // best case:
        const size_t offs = index;
        return order_guard(*(((int_type*)bitmap)+offs));
    } 
    const size_t ofsb=((index*bit_depth)/8);
    bitmap+=ofsb;
    const size_t ofsm=(index*bit_depth)-(ofsb*8);
    // most general case: (read 1 bit at a time)
    int_type result = 0;
    uint8_t dat = *(bitmap);
    for(size_t i = 0;i<bit_depth;++i) {
        const size_t bit = 7-((ofsm+i)&7);
        const uint8_t msk = (1<<bit);
        const bool mov = bit==7;
        result<<=1;
        result|=(0!=(dat&msk));
        if(mov) // get next byte
            dat=*(++bitmap);
    }
    return order_guard(result);
}
... (below is from main)

typedef channel_traits<channel_name::V,channel_kind::luminosity,uint8_t,1> mono_1bit_luminosity_channel_t;
typedef pixel<color_model::none, false, mono_1bit_luminosity_channel_t> mono1_t;

uint16_t data=0xCCCC;
for(size_t x=0;x<16;++x) {
    auto val = mono1_t::at((uint8_t*)&data,x);
    printf("%d",val);
}
printf("\r\n");
return 0;

main:
        push    rbp
        mov     ebp, 1
        push    rbx
        xor     ebx, ebx
        sub     rsp, 24
        mov     WORD PTR [rsp+14], -13108
.L2:
        mov     rcx, rbx
        mov     rdx, rbx
        mov     eax, ebp
        xor     esi, esi
        not     rcx
        shr     rdx, 3
        mov     edi, OFFSET FLAT:.LC0
        and     ecx, 7
        sal     eax, cl
        test    BYTE PTR [rsp+14+rdx], al
        setne   sil
        xor     eax, eax
        inc     rbx
        call    printf
        cmp     rbx, 16
        jne     .L2
        mov     edi, OFFSET FLAT:.LC1
        call    puts
        add     rsp, 24
        xor     eax, eax
        pop     rbx
        pop     rbp
        ret

Quote:

rewriting from scratch a stupendous marvel!

Quote:

"the user doesn't want to change their workflow"