five_bit_bitshift() [2/2]

void fl::five_bit_bitshift ( uint16_t r16, uint16_t g16, uint16_t b16, uint8_t brightness, CRGB * out, uint8_t * out_power_5bit )

inline

Definition at line 125 of file five_bit_hd_gamma.h.

                                                       {
 
    // NEW in 3.10.2: A new closed form solution has been found!
    // Thank you https://github.com/gwgill!
    // It's okay if you don't know how this works, few do, but it tests
    // very well and is better than the old iterative approach which had
    // bad quantization issues (sudden jumps in brightness in certain intervals).
 
    // ix/31 * 255/65536 * 256 scaling factors, valid for indexes 1..31
    static uint32_t bright_scale[32] = {
        0,      2023680, 1011840, 674560, 505920, 404736, 337280, 289097,
        252960, 224853,  202368,  183971, 168640, 155668, 144549, 134912,
        126480, 119040,  112427,  106509, 101184, 96366,  91985,  87986,
        84320,  80947,   77834,   74951,  72274,  69782,  67456,  65280};
 
    auto max3 = [](u16 a, u16 b, u16 c) { return fl_max(fl_max(a, b), c); };
 
 
    if (brightness == 0) {
        *out = CRGB(0, 0, 0);
        *out_power_5bit = 0;
        return;
    }
    if (r16 == 0 && g16 == 0 && b16 == 0) {
        *out = CRGB(0, 0, 0);
        *out_power_5bit = (brightness <= 31) ? brightness : 31;
        return;
    }
 
    uint8_t r8 = 0, g8 = 0, b8 = 0;
 
    // Apply any brightness setting (we assume brightness is 0..255)
    if (brightness != 0xff) {
        r16 = scale16by8(r16, brightness);
        g16 = scale16by8(g16, brightness);
        b16 = scale16by8(b16, brightness);
    }
 
    // Locate the largest value to set the brightness/scale factor
    uint16_t scale = max3(r16, g16, b16);
 
    if (scale == 0) {
        *out = CRGB(0, 0, 0);
        *out_power_5bit = 0;
        return;
    } else {
        uint32_t scalef;
 
        // Compute 5 bit quantized scale that is at or above the maximum value.
        scale = (scale + (2047 - (scale >> 5))) >> 11;
 
        // Adjust the 16 bit values to account for the scale, then round to 8
        // bits
        scalef = bright_scale[scale];
        r8 = (r16 * scalef + 0x808000) >> 24;
        g8 = (g16 * scalef + 0x808000) >> 24;
        b8 = (b16 * scalef + 0x808000) >> 24;
 
        *out = CRGB(r8, g8, b8);
        *out_power_5bit = static_cast<uint8_t>(scale);
        return;
    }
}

References brightness(), fl_max(), scale, and scale16by8().

Here is the call graph for this function: