controller_dither_reserve_mW()

fl::u32 controller_dither_reserve_mW

(

const fl::CLEDController &

controller

)

dither_reserve_mW() for a controller that dithers, and zero for one that does not: a mode other than BINARY_DITHER, or an active RGBW/RGBWW conversion (which reads the raw pixel on every non-AVR target).

A colour-managed channel never takes the legacy offsets (C5); with BINARY_DITHER it runs the pipeline's temporal dither instead, and is reserved one code on every channel of every lit pixel.

On the TINY memory tier (FL_PLATFORM_HAS_TINY_MEMORY) both of these are compiled out and the reserve is zero: the 64-bit arithmetic the bound needs costs 468 B of an ATtiny85's 8 KiB, which is what pushed TwinkleFox over the flash region (#4478). Every tier that can afford it keeps the reserve.

Definition at line 507 of file power_mgt.cpp.hpp.

                                                                       {
    if (controller.getDither() != BINARY_DITHER) {
        return 0;
    }
#if FL_COLOR_PIPELINE_SHARED
    // A managed channel never takes the legacy offsets (C5); with
    // BINARY_DITHER it runs the pipeline's temporal dither instead, which
    // emits floor(x) or floor(x) + 1 of the exact code -- at most one code
    // above the rounded code its estimate charges. The solve can light a
    // channel the source left dark, so every channel of every lit pixel is
    // reserved one code.
    if (controller.colorPipeline()) {
        const fl::span<const CRGB> leds(controller.leds(),
                                        static_cast<fl::size>(controller.size()));
        fl::u32 lit = 0;
        for (fl::size i = 0; i < leds.size(); ++i) {
            lit += (leds[i].r | leds[i].g | leds[i].b) != 0 ? 1u : 0u;
        }
        const fl::u8 emitters = controller.getRgbww().active()
                                    ? 5 : (controller.getRgbw().active() ? 4 : 3);
        fl::u8 weights[5];
        emitter_power_weights(emitters, weights);
        fl::u32 sum_weights = 0;
        for (fl::u8 i = 0; i < emitters; ++i) {
            sum_weights += weights[i];
        }
        const fl::u64 per_code = static_cast<fl::u64>(lit) * sum_weights;
        const fl::u64 reserve = (per_code * max_power_step() + 255) >> 8;
        return reserve > 0xFFFFFFFFu ? 0xFFFFFFFFu
                                     : static_cast<fl::u32>(reserve);
    }
#endif
#if !defined(FL_IS_AVR)
    // Legacy RGBW and RGBWW conversions read the raw pixel, not the
    // dithered one. Managed channels have already returned above.
    if (controller.getRgbw().active() || controller.getRgbww().active()) {
        return 0;
    }
#endif
    return dither_reserve_mW(fl::span<const CRGB>(
        controller.leds(), static_cast<fl::size>(controller.size())));
}

References BINARY_DITHER, controller, dither_reserve_mW(), emitter_power_weights(), leds, and max_power_step().

Referenced by calculate_max_brightness_for_power_mW(), and CFastLED::getEstimatedPowerInMilliWatts().

Here is the call graph for this function:

Here is the caller graph for this function: