colorutils.h

Go to the documentation of this file.

#pragma once

 
// #include "FastLED.h"
 
#include "fl/stl/int.h"
#include "fl/stl/span.h"
#include "crgb.h"  // IWYU pragma: keep
#include "fastled_progmem.h"
#include "fl/gfx/blur.h"  // IWYU pragma: keep
#include "fl/gfx/crgb16.h"
#include "fl/gfx/colorutils_misc.h"
#include "fl/gfx/fill.h"
#include "fl/math/xymap.h"  // IWYU pragma: keep
#include "fl/math/memmove.h"
#include "fl/stl/compiler_control.h"
#include "fl/stl/cstring.h"
#include "fl/log/log.h"  // IWYU pragma: keep
#include "platforms/is_platform.h"  // IWYU pragma: keep
#include "fl/stl/noexcept.h"
 
// #include "pixeltypes.h"  // pulls in FastLED.h, beware.
 
FL_DISABLE_WARNING_PUSH
FL_DISABLE_WARNING_UNUSED_PARAMETER
FL_DISABLE_WARNING_RETURN_TYPE
FL_DISABLE_WARNING_IMPLICIT_INT_CONVERSION
FL_DISABLE_WARNING_FLOAT_CONVERSION
FL_DISABLE_WARNING_SIGN_CONVERSION
 
#if !defined(FASTLED_USE_32_BIT_GRADIENT_FILL)
#if defined(FL_IS_AVR)
#define FASTLED_USE_32_BIT_GRADIENT_FILL 0
#else
#define FASTLED_USE_32_BIT_GRADIENT_FILL 1
#endif
#endif
 
FL_DISABLE_WARNING_PUSH
FL_DISABLE_WARNING(cast-align)
 
namespace fl {



void fadeLightBy(CRGB *leds, fl::u16 num_leds, fl::u8 fadeBy) FL_NOEXCEPT;

inline void fadeLightBy(fl::span<CRGB> leds, fl::u8 fadeBy) FL_NOEXCEPT {
    fadeLightBy(leds.data(), static_cast<fl::u16>(leds.size()), fadeBy);
}

void fade_video(CRGB *leds, fl::u16 num_leds, fl::u8 fadeBy) FL_NOEXCEPT;

inline void fade_video(fl::span<CRGB> leds, fl::u8 fadeBy) FL_NOEXCEPT {
    fade_video(leds.data(), static_cast<fl::u16>(leds.size()), fadeBy);
}

void nscale8_video(CRGB *leds, fl::u16 num_leds, fl::u8 scale) FL_NOEXCEPT;

inline void nscale8_video(fl::span<CRGB> leds, fl::u8 scale) FL_NOEXCEPT {
    nscale8_video(leds.data(), static_cast<fl::u16>(leds.size()), scale);
}

void fadeToBlackBy(CRGB *leds, fl::u16 num_leds, fl::u8 fadeBy) FL_NOEXCEPT;

inline void fadeToBlackBy(fl::span<CRGB> leds, fl::u8 fadeBy) FL_NOEXCEPT {
    fadeToBlackBy(leds.data(), static_cast<fl::u16>(leds.size()), fadeBy);
}

void fade_raw(CRGB *leds, fl::u16 num_leds, fl::u8 fadeBy) FL_NOEXCEPT;

inline void fade_raw(fl::span<CRGB> leds, fl::u8 fadeBy) FL_NOEXCEPT {
    fade_raw(leds.data(), static_cast<fl::u16>(leds.size()), fadeBy);
}

void nscale8(CRGB *leds, fl::u16 num_leds, fl::u8 scale) FL_NOEXCEPT;

inline void nscale8(fl::span<CRGB> leds, fl::u8 scale) FL_NOEXCEPT {
    nscale8(leds.data(), static_cast<fl::u16>(leds.size()), scale);
}

void fadeUsingColor(CRGB *leds, fl::u16 numLeds, const CRGB &colormask) FL_NOEXCEPT;

inline void fadeUsingColor(fl::span<CRGB> leds, const CRGB &colormask) FL_NOEXCEPT {
    fadeUsingColor(leds.data(), static_cast<fl::u16>(leds.size()), colormask);
}



CRGB blend(const CRGB &p1, const CRGB &p2, fract8 amountOfP2) FL_NOEXCEPT;

CHSV blend(const CHSV &p1, const CHSV &p2, fract8 amountOfP2,
           TGradientDirectionCode directionCode = SHORTEST_HUES) FL_NOEXCEPT;

CRGB *blend(const CRGB *src1, const CRGB *src2, CRGB *dest, fl::u16 count,
            fract8 amountOfsrc2) FL_NOEXCEPT;

inline void blend(fl::span<const CRGB> src1, fl::span<const CRGB> src2,
                  fl::span<CRGB> dest, fract8 amountOfsrc2) FL_NOEXCEPT {
    blend(src1.data(), src2.data(), dest.data(),
          static_cast<fl::u16>(dest.size()), amountOfsrc2);
}

CHSV *blend(const CHSV *src1, const CHSV *src2, CHSV *dest, fl::u16 count,
            fract8 amountOfsrc2,
            TGradientDirectionCode directionCode = SHORTEST_HUES) FL_NOEXCEPT;

CRGB &nblend(CRGB &existing, const CRGB &overlay, fract8 amountOfOverlay) FL_NOEXCEPT;

CHSV &nblend(CHSV &existing, const CHSV &overlay, fract8 amountOfOverlay,
             TGradientDirectionCode directionCode = SHORTEST_HUES) FL_NOEXCEPT;

void nblend(CRGB *existing, const CRGB *overlay, fl::u16 count,
            fract8 amountOfOverlay) FL_NOEXCEPT;

inline void nblend(fl::span<CRGB> existing, fl::span<const CRGB> overlay,
                   fract8 amountOfOverlay) FL_NOEXCEPT {
    nblend(existing.data(), overlay.data(),
           static_cast<fl::u16>(existing.size()), amountOfOverlay);
}

void nblend(CHSV *existing, const CHSV *overlay, fl::u16 count,
            fract8 amountOfOverlay,
            TGradientDirectionCode directionCode = SHORTEST_HUES) FL_NOEXCEPT;



CRGB HeatColor(fl::u8 temperature) FL_NOEXCEPT;



 
class CRGBPalette16;  // IWYU pragma: keep
class CRGBPalette32;  // IWYU pragma: keep
class CRGBPalette256;  // IWYU pragma: keep
class CHSVPalette16;  // IWYU pragma: keep
class CHSVPalette32;  // IWYU pragma: keep
class CHSVPalette256;  // IWYU pragma: keep

typedef union {
    struct {
        fl::u8 index; 
        fl::u8 r;     
        fl::u8 g;     
        fl::u8 b;     
    };
    fl::u32 dword;   
    fl::u8 bytes[4]; 
} TRGBGradientPaletteEntryUnion;

#define FASTLED_MAX_GRADIENT_PALETTE_ENTRIES 256
 
typedef fl::u8
    TDynamicRGBGradientPalette_byte; 
typedef const TDynamicRGBGradientPalette_byte
    *TDynamicRGBGradientPalette_bytes; 
typedef TDynamicRGBGradientPalette_bytes
    TDynamicRGBGradientPaletteRef; 



void UpscalePalette(const class CRGBPalette16 &srcpal16,
                    class CRGBPalette256 &destpal256) FL_NOEXCEPT;
void UpscalePalette(const class CHSVPalette16 &srcpal16,
                    class CHSVPalette256 &destpal256) FL_NOEXCEPT;

void UpscalePalette(const class CRGBPalette16 &srcpal16,
                    class CRGBPalette32 &destpal32) FL_NOEXCEPT;
void UpscalePalette(const class CHSVPalette16 &srcpal16,
                    class CHSVPalette32 &destpal32) FL_NOEXCEPT;

void UpscalePalette(const class CRGBPalette32 &srcpal32,
                    class CRGBPalette256 &destpal256) FL_NOEXCEPT;
void UpscalePalette(const class CHSVPalette32 &srcpal32,
                    class CHSVPalette256 &destpal256) FL_NOEXCEPT;


 
namespace detail {
 
template <typename TColor>
struct PaletteFillTraits;
 
template <>
struct PaletteFillTraits<CHSV> {
    static void fillSolid(CHSV *entries, fl::u16 size, const CHSV &color) FL_NOEXCEPT {
        fill_solid(entries, static_cast<int>(size), color);
    }
 
    static void fillGradient(CHSV *entries, fl::u16 size, const CHSV &c1,
                             const CHSV &c2) FL_NOEXCEPT {
        fill_gradient(entries, size, c1, c2);
    }
 
    static void fillGradient(CHSV *entries, fl::u16 size, const CHSV &c1,
                             const CHSV &c2, const CHSV &c3) FL_NOEXCEPT {
        fill_gradient(entries, size, c1, c2, c3);
    }
 
    static void fillGradient(CHSV *entries, fl::u16 size, const CHSV &c1,
                             const CHSV &c2, const CHSV &c3,
                             const CHSV &c4) FL_NOEXCEPT {
        fill_gradient(entries, size, c1, c2, c3, c4);
    }
};
 
template <>
struct PaletteFillTraits<CRGB> {
    static void fillSolid(CRGB *entries, fl::u16 size, const CRGB &color) FL_NOEXCEPT {
        fill_solid(entries, static_cast<int>(size), color);
    }
 
    static void fillGradient(CRGB *entries, fl::u16 size, const CRGB &c1,
                             const CRGB &c2) FL_NOEXCEPT {
        fill_gradient_RGB(entries, size, c1, c2);
    }
 
    static void fillGradient(CRGB *entries, fl::u16 size, const CRGB &c1,
                             const CRGB &c2, const CRGB &c3) FL_NOEXCEPT {
        fill_gradient_RGB(entries, size, c1, c2, c3);
    }
 
    static void fillGradient(CRGB *entries, fl::u16 size, const CRGB &c1,
                             const CRGB &c2, const CRGB &c3,
                             const CRGB &c4) FL_NOEXCEPT {
        fill_gradient_RGB(entries, size, c1, c2, c3, c4);
    }
};
 
template <typename TColor, fl::u16 Size>
class TColorPalette {
  public:
    TColor entries[Size];
 
    TColorPalette() FL_NOEXCEPT {}
 
    TColorPalette(const TColorPalette &rhs) FL_NOEXCEPT { copyBytes(rhs.entries); }
 
    TColorPalette(const TColor (&rhs)[Size]) FL_NOEXCEPT { copyBytes(rhs); }
 
    TColorPalette &operator=(const TColorPalette &rhs) FL_NOEXCEPT {
        copyBytes(rhs.entries);
        return *this;
    }
 
    TColorPalette &operator=(const TColor (&rhs)[Size]) FL_NOEXCEPT {
        copyBytes(rhs);
        return *this;
    }
 
    TColorPalette(const TColor &c1) FL_NOEXCEPT {
        PaletteFillTraits<TColor>::fillSolid(entries, Size, c1);
    }
 
    TColorPalette(const TColor &c1, const TColor &c2) FL_NOEXCEPT {
        PaletteFillTraits<TColor>::fillGradient(entries, Size, c1, c2);
    }
 
    TColorPalette(const TColor &c1, const TColor &c2,
                  const TColor &c3) FL_NOEXCEPT {
        PaletteFillTraits<TColor>::fillGradient(entries, Size, c1, c2, c3);
    }
 
    TColorPalette(const TColor &c1, const TColor &c2, const TColor &c3,
                  const TColor &c4) FL_NOEXCEPT {
        PaletteFillTraits<TColor>::fillGradient(entries, Size, c1, c2, c3, c4);
    }
 
    inline TColor &operator[](fl::u8 x) FL_NOEXCEPT __attribute__((always_inline)) {
        return entries[x];
    }
 
    inline const TColor &operator[](fl::u8 x) const FL_NOEXCEPT
        __attribute__((always_inline)) {
        return entries[x];
    }
 
    inline TColor &operator[](int x) FL_NOEXCEPT __attribute__((always_inline)) {
        return entries[(fl::u8)x];
    }
 
    inline const TColor &operator[](int x) const FL_NOEXCEPT
        __attribute__((always_inline)) {
        return entries[(fl::u8)x];
    }
 
    operator TColor *() FL_NOEXCEPT { return &(entries[0]); }
 
    // Hidden friends — C++20 deprecates synthesizing a reversed candidate
    // for member operator==, producing -Wambiguous-reversed-operator at every
    // call site. Defining the comparison as a non-member friend declared
    // inside the class body solves that cleanly (found only via ADL on the
    // palette type, no reverse-candidate synthesis applies). Derived classes
    // get these for free through ADL on the base, so the prior
    // `using Base::operator==/!=` injections are no longer needed. #2724
    friend bool operator==(const TColorPalette &lhs,
                           const TColorPalette &rhs) FL_NOEXCEPT {
        const TColor *lhs_entries = &(lhs.entries[0]);
        const TColor *rhs_entries = &(rhs.entries[0]);
        if (lhs_entries == rhs_entries) {
            return true;
        }
        return fl::memcmp(lhs_entries, rhs_entries, sizeof(lhs.entries)) == 0;
    }
 
    friend bool operator!=(const TColorPalette &lhs,
                           const TColorPalette &rhs) FL_NOEXCEPT {
        return !(lhs == rhs);
    }
 
  protected:
    void copyBytes(const TColor *rhs) FL_NOEXCEPT {
        memmove8((void *)&(entries[0]), rhs, sizeof(entries));
    }
 
    template <typename TOtherColor>
    void copyConverted(const TOtherColor *rhs) FL_NOEXCEPT {
        for (fl::u16 i = 0; i < Size; ++i) {
            entries[i] = rhs[i];
        }
    }
};
 
template <fl::u16 Size>
class TCRGBPalette : public TColorPalette<CRGB, Size> {
  public:
    using Base = TColorPalette<CRGB, Size>;
    using Base::Base;
    using Base::entries;
    // operator== / operator!= are hidden friends on Base (#2724); they reach
    // derived classes automatically via ADL, so no using-declaration needed.
    using Base::operator=;
    using Base::operator[];
    using Base::operator CRGB*;
 
    TCRGBPalette() FL_NOEXCEPT {}
 
    // Explicit Rule of 5 — the user-defined ctors below otherwise force the
    // copy-assign / destructor to be implicitly-declared, which C++11+
    // deprecates (-Wdeprecated-copy, ~472 hits across teensy30/31/40/41/LC).
    // Mirrors what CRGBPalette16 already does at lines 699-701. #2725
    TCRGBPalette(const TCRGBPalette &) FL_NOEXCEPT = default;
    TCRGBPalette &operator=(const TCRGBPalette &) FL_NOEXCEPT = default;
    ~TCRGBPalette() FL_NOEXCEPT = default;
 
    TCRGBPalette(const TColorPalette<CHSV, Size> &rhs) FL_NOEXCEPT {
        Base::copyConverted(rhs.entries);
    }
 
    TCRGBPalette(const CHSV (&rhs)[Size]) FL_NOEXCEPT {
        Base::copyConverted(rhs);
    }
 
    TCRGBPalette &operator=(const TColorPalette<CHSV, Size> &rhs) FL_NOEXCEPT {
        Base::copyConverted(rhs.entries);
        return *this;
    }
 
    TCRGBPalette &operator=(const CHSV (&rhs)[Size]) FL_NOEXCEPT {
        Base::copyConverted(rhs);
        return *this;
    }
 
    TCRGBPalette(const CHSV &c1) FL_NOEXCEPT {
        fill_solid(&(entries[0]), static_cast<int>(Size), c1);
    }
 
    TCRGBPalette(const CHSV &c1, const CHSV &c2) FL_NOEXCEPT {
        fill_gradient(&(entries[0]), Size, c1, c2);
    }
 
    TCRGBPalette(const CHSV &c1, const CHSV &c2,
                 const CHSV &c3) FL_NOEXCEPT {
        fill_gradient(&(entries[0]), Size, c1, c2, c3);
    }
 
    TCRGBPalette(const CHSV &c1, const CHSV &c2, const CHSV &c3,
                 const CHSV &c4) FL_NOEXCEPT {
        fill_gradient(&(entries[0]), Size, c1, c2, c3, c4);
    }
};
 
inline void loadProgmemPalette(CRGB *entries, const fl::u32 *rhs,
                               fl::u16 count) FL_NOEXCEPT {
    for (fl::u16 i = 0; i < count; ++i) {
        entries[i] = FL_PGM_READ_DWORD_NEAR(rhs + i);
    }
}
 
inline void loadProgmemPalette(CHSV *entries, const fl::u32 *rhs,
                               fl::u16 count) FL_NOEXCEPT {
    for (fl::u16 i = 0; i < count; ++i) {
        CRGB xyz(FL_PGM_READ_DWORD_NEAR(rhs + i));
        entries[i].hue = xyz.red;
        entries[i].sat = xyz.green;
        entries[i].val = xyz.blue;
    }
}
 
template <typename TPalette16, typename TColor>
void initPalette16(TPalette16 &palette, const TColor &c00, const TColor &c01,
                   const TColor &c02, const TColor &c03, const TColor &c04,
                   const TColor &c05, const TColor &c06, const TColor &c07,
                   const TColor &c08, const TColor &c09, const TColor &c10,
                   const TColor &c11, const TColor &c12, const TColor &c13,
                   const TColor &c14, const TColor &c15) FL_NOEXCEPT {
    const TColor colors[16] = {c00, c01, c02, c03, c04, c05, c06, c07,
                               c08, c09, c10, c11, c12, c13, c14, c15};
    palette = colors;
}
 
} // namespace detail

class CHSVPalette16 : public detail::TColorPalette<CHSV, 16> {
  public:
    using Base = detail::TColorPalette<CHSV, 16>;
    using Base::Base;
    using Base::entries;
    // operator== / operator!= are hidden friends on Base (#2724); they reach
    // derived classes automatically via ADL, so no using-declaration needed.
    using Base::operator=;
    using Base::operator[];
    using Base::operator CHSV*;
 
    CHSVPalette16() FL_NOEXCEPT = default;
    CHSVPalette16(const CHSVPalette16 &rhs) FL_NOEXCEPT = default;
    CHSVPalette16 &operator=(const CHSVPalette16 &rhs) FL_NOEXCEPT = default;
 
    CHSVPalette16(const CHSV &c00, const CHSV &c01, const CHSV &c02,
                  const CHSV &c03, const CHSV &c04, const CHSV &c05,
                  const CHSV &c06, const CHSV &c07, const CHSV &c08,
                  const CHSV &c09, const CHSV &c10, const CHSV &c11,
                  const CHSV &c12, const CHSV &c13, const CHSV &c14,
                  const CHSV &c15) FL_NOEXCEPT {
        detail::initPalette16(*this, c00, c01, c02, c03, c04, c05, c06, c07,
                              c08, c09, c10, c11, c12, c13, c14, c15);
    }
 
    CHSVPalette16(const TProgmemHSVPalette16 &rhs) FL_NOEXCEPT {
        detail::loadProgmemPalette(entries, rhs, 16);
    }
 
    CHSVPalette16 &operator=(const TProgmemHSVPalette16 &rhs) FL_NOEXCEPT {
        detail::loadProgmemPalette(entries, rhs, 16);
        return *this;
    }
};

class CHSVPalette256 : public detail::TColorPalette<CHSV, 256> {
  public:
    using Base = detail::TColorPalette<CHSV, 256>;
    using Base::Base;
    using Base::entries;
    // operator== / operator!= are hidden friends on Base (#2724); they reach
    // derived classes automatically via ADL, so no using-declaration needed.
    using Base::operator=;
    using Base::operator[];
    using Base::operator CHSV*;
 
    CHSVPalette256() FL_NOEXCEPT = default;
    CHSVPalette256(const CHSVPalette256 &rhs) FL_NOEXCEPT = default;
    CHSVPalette256 &operator=(const CHSVPalette256 &rhs) FL_NOEXCEPT = default;
 
    CHSVPalette256(const CHSV &c00, const CHSV &c01, const CHSV &c02,
                   const CHSV &c03, const CHSV &c04, const CHSV &c05,
                   const CHSV &c06, const CHSV &c07, const CHSV &c08,
                   const CHSV &c09, const CHSV &c10, const CHSV &c11,
                   const CHSV &c12, const CHSV &c13, const CHSV &c14,
                   const CHSV &c15) FL_NOEXCEPT {
        CHSVPalette16 p16(c00, c01, c02, c03, c04, c05, c06, c07, c08, c09,
                          c10, c11, c12, c13, c14, c15);
        *this = p16;
    }
 
    CHSVPalette256(const CHSVPalette16 &rhs16) FL_NOEXCEPT { UpscalePalette(rhs16, *this); }
 
    CHSVPalette256(const CHSVPalette32 &rhs32) FL_NOEXCEPT { UpscalePalette(rhs32, *this); }
 
    CHSVPalette256 &operator=(const CHSVPalette16 &rhs16) FL_NOEXCEPT {
        UpscalePalette(rhs16, *this);
        return *this;
    }
 
    CHSVPalette256 &operator=(const CHSVPalette32 &rhs32) FL_NOEXCEPT {
        UpscalePalette(rhs32, *this);
        return *this;
    }
 
    CHSVPalette256(const TProgmemHSVPalette16 &rhs) FL_NOEXCEPT {
        CHSVPalette16 p16(rhs);
        *this = p16;
    }
 
    CHSVPalette256 &operator=(const TProgmemHSVPalette16 &rhs) FL_NOEXCEPT {
        CHSVPalette16 p16(rhs);
        *this = p16;
        return *this;
    }
 
    CHSVPalette256(const TProgmemHSVPalette32 &rhs) FL_NOEXCEPT;
 
    CHSVPalette256 &operator=(const TProgmemHSVPalette32 &rhs) FL_NOEXCEPT;
};

class CRGBPalette16 : public detail::TCRGBPalette<16> {
  public:
    using Base = detail::TCRGBPalette<16>;
    using Base::Base;
    using Base::entries;
    // operator== / operator!= are hidden friends on Base (#2724); they reach
    // derived classes automatically via ADL, so no using-declaration needed.
    using Base::operator=;
    using Base::operator[];
    using Base::operator CRGB*;
 
    CRGBPalette16() FL_NOEXCEPT = default;
    CRGBPalette16(const CRGBPalette16 &rhs) FL_NOEXCEPT = default;
    CRGBPalette16 &operator=(const CRGBPalette16 &rhs) FL_NOEXCEPT = default;
 
    CRGBPalette16(const CRGB &c00, const CRGB &c01, const CRGB &c02,
                  const CRGB &c03, const CRGB &c04, const CRGB &c05,
                  const CRGB &c06, const CRGB &c07, const CRGB &c08,
                  const CRGB &c09, const CRGB &c10, const CRGB &c11,
                  const CRGB &c12, const CRGB &c13, const CRGB &c14,
                  const CRGB &c15) FL_NOEXCEPT {
        detail::initPalette16(*this, c00, c01, c02, c03, c04, c05, c06, c07,
                              c08, c09, c10, c11, c12, c13, c14, c15);
    }
 
    CRGBPalette16(const TProgmemRGBPalette16 &rhs) FL_NOEXCEPT {
        detail::loadProgmemPalette(entries, rhs, 16);
    }
 
    CRGBPalette16 &operator=(const TProgmemRGBPalette16 &rhs) FL_NOEXCEPT {
        detail::loadProgmemPalette(entries, rhs, 16);
        return *this;
    }

    CRGBPalette16(TProgmemRGBGradientPalette_bytes progpal) FL_NOEXCEPT { *this = progpal; }
    CRGBPalette16 &operator=(TProgmemRGBGradientPalette_bytes progpal) FL_NOEXCEPT {
        TRGBGradientPaletteEntryUnion *progent =
            // (TRGBGradientPaletteEntryUnion *)(progpal);
            fl::bit_cast<TRGBGradientPaletteEntryUnion *>(progpal);
        TRGBGradientPaletteEntryUnion u;
 
        // Count entries with safety limit to prevent buffer overrun
        fl::u16 count = 0;
        bool has_terminator = false;
        do {
            u.dword = FL_PGM_READ_DWORD_NEAR(progent + count);
            ++count;
            if (u.index == 255) {
                has_terminator = true;
                break;
            }
            if (count >= FASTLED_MAX_GRADIENT_PALETTE_ENTRIES) {
                FL_WARN("DEFINE_GRADIENT_PALETTE missing index=255 terminator! "
                        "This will cause buffer overruns and crashes. "
                        "Auto-correcting but please fix your gradient definition.");
                break;
            }
        } while (true);
 
        fl::i8 lastSlotUsed = -1;
 
        u.dword = FL_PGM_READ_DWORD_NEAR(progent);
        CRGB rgbstart(u.r, u.g, u.b);
 
        int indexstart = 0;
        fl::u8 istart8 = 0;
        fl::u8 iend8 = 0;
        fl::u16 entries_processed = 0;
        while (indexstart < 255) {
            // Safety: check BEFORE reading to prevent buffer overrun
            if (!has_terminator && entries_processed + 1 >= count) {
                // No more validated entries - extend current color to 255
                istart8 = indexstart / 16;
                iend8 = 255 / 16;
                if (count < 16) {
                    if ((istart8 <= lastSlotUsed) && (lastSlotUsed < 15)) {
                        istart8 = lastSlotUsed + 1;
                        if (iend8 < istart8) {
                            iend8 = istart8;
                        }
                    }
                }
                fill_gradient_RGB(&(entries[0]), istart8, rgbstart, iend8, rgbstart);
                break;
            }
 
            ++progent;
            u.dword = FL_PGM_READ_DWORD_NEAR(progent);
            int indexend = u.index;
            CRGB rgbend(u.r, u.g, u.b);
 
            istart8 = indexstart / 16;
            iend8 = indexend / 16;
            if (count < 16) {
                if ((istart8 <= lastSlotUsed) && (lastSlotUsed < 15)) {
                    istart8 = lastSlotUsed + 1;
                    if (iend8 < istart8) {
                        iend8 = istart8;
                    }
                }
                lastSlotUsed = iend8;
            }
            fill_gradient_RGB(&(entries[0]), istart8, rgbstart, iend8, rgbend);
            indexstart = indexend;
            rgbstart = rgbend;
            ++entries_processed;
        }
        return *this;
    }
    CRGBPalette16 &
    loadDynamicGradientPalette(TDynamicRGBGradientPalette_bytes gpal) FL_NOEXCEPT {
        TRGBGradientPaletteEntryUnion *ent =
            // (TRGBGradientPaletteEntryUnion *)(gpal);
            fl::bit_cast<TRGBGradientPaletteEntryUnion *>(gpal);
        TRGBGradientPaletteEntryUnion u;
 
        // Count entries with safety limit to prevent buffer overrun
        fl::u16 count = 0;
        bool has_terminator = false;
        do {
            u = *(ent + count);
            ++count;
            if (u.index == 255) {
                has_terminator = true;
                break;
            }
            if (count >= FASTLED_MAX_GRADIENT_PALETTE_ENTRIES) {
                FL_WARN("Dynamic gradient palette missing index=255 terminator! "
                        "This will cause buffer overruns and crashes. "
                        "Auto-correcting but please fix your gradient definition.");
                break;
            }
        } while (true);
 
        fl::i8 lastSlotUsed = -1;
 
        u = *ent;
        CRGB rgbstart(u.r, u.g, u.b);
 
        int indexstart = 0;
        fl::u8 istart8 = 0;
        fl::u8 iend8 = 0;
        fl::u16 entries_processed = 0;
        while (indexstart < 255) {
            // Safety: check BEFORE reading to prevent buffer overrun
            if (!has_terminator && entries_processed + 1 >= count) {
                // No more validated entries - extend current color to 255
                istart8 = indexstart / 16;
                iend8 = 255 / 16;
                if (count < 16) {
                    if ((istart8 <= lastSlotUsed) && (lastSlotUsed < 15)) {
                        istart8 = lastSlotUsed + 1;
                        if (iend8 < istart8) {
                            iend8 = istart8;
                        }
                    }
                }
                fill_gradient_RGB(&(entries[0]), istart8, rgbstart, iend8, rgbstart);
                break;
            }
 
            ++ent;
            u = *ent;
            int indexend = u.index;
            CRGB rgbend(u.r, u.g, u.b);
 
            istart8 = indexstart / 16;
            iend8 = indexend / 16;
            if (count < 16) {
                if ((istart8 <= lastSlotUsed) && (lastSlotUsed < 15)) {
                    istart8 = lastSlotUsed + 1;
                    if (iend8 < istart8) {
                        iend8 = istart8;
                    }
                }
                lastSlotUsed = iend8;
            }
            fill_gradient_RGB(&(entries[0]), istart8, rgbstart, iend8, rgbend);
            indexstart = indexend;
            rgbstart = rgbend;
            ++entries_processed;
        }
        return *this;
    }
};

class CHSVPalette32 : public detail::TColorPalette<CHSV, 32> {
  public:
    using Base = detail::TColorPalette<CHSV, 32>;
    using Base::Base;
    using Base::entries;
    // operator== / operator!= are hidden friends on Base (#2724); they reach
    // derived classes automatically via ADL, so no using-declaration needed.
    using Base::operator=;
    using Base::operator[];
    using Base::operator CHSV*;
 
    CHSVPalette32() FL_NOEXCEPT = default;
    CHSVPalette32(const CHSVPalette32 &rhs) FL_NOEXCEPT = default;
    CHSVPalette32 &operator=(const CHSVPalette32 &rhs) FL_NOEXCEPT = default;
 
    CHSVPalette32(const CHSV &c00, const CHSV &c01, const CHSV &c02,
                  const CHSV &c03, const CHSV &c04, const CHSV &c05,
                  const CHSV &c06, const CHSV &c07, const CHSV &c08,
                  const CHSV &c09, const CHSV &c10, const CHSV &c11,
                  const CHSV &c12, const CHSV &c13, const CHSV &c14,
                  const CHSV &c15) FL_NOEXCEPT {
        CHSVPalette16 p16(c00, c01, c02, c03, c04, c05, c06, c07, c08, c09,
                          c10, c11, c12, c13, c14, c15);
        *this = p16;
    }
 
    CHSVPalette32(const CHSVPalette16 &rhs16) FL_NOEXCEPT { UpscalePalette(rhs16, *this); }
 
    CHSVPalette32 &operator=(const CHSVPalette16 &rhs16) FL_NOEXCEPT {
        UpscalePalette(rhs16, *this);
        return *this;
    }
 
    CHSVPalette32(const TProgmemHSVPalette16 &rhs) FL_NOEXCEPT {
        CHSVPalette16 p16(rhs);
        *this = p16;
    }
 
    CHSVPalette32 &operator=(const TProgmemHSVPalette16 &rhs) FL_NOEXCEPT {
        CHSVPalette16 p16(rhs);
        *this = p16;
        return *this;
    }
 
    CHSVPalette32(const TProgmemHSVPalette32 &rhs) FL_NOEXCEPT {
        detail::loadProgmemPalette(entries, rhs, 32);
    }
 
    CHSVPalette32 &operator=(const TProgmemHSVPalette32 &rhs) FL_NOEXCEPT {
        detail::loadProgmemPalette(entries, rhs, 32);
        return *this;
    }
};
 
inline CHSVPalette256::CHSVPalette256(const TProgmemHSVPalette32 &rhs) FL_NOEXCEPT {
    CHSVPalette32 p32(rhs);
    *this = p32;
}
 
inline CHSVPalette256 &
CHSVPalette256::operator=(const TProgmemHSVPalette32 &rhs) FL_NOEXCEPT {
    CHSVPalette32 p32(rhs);
    *this = p32;
    return *this;
}

class CRGBPalette32 : public detail::TCRGBPalette<32> {
  public:
    using Base = detail::TCRGBPalette<32>;
    using Base::Base;
    using Base::entries;
    // operator== / operator!= are hidden friends on Base (#2724); they reach
    // derived classes automatically via ADL, so no using-declaration needed.
    using Base::operator=;
    using Base::operator[];
    using Base::operator CRGB*;
 
    CRGBPalette32() FL_NOEXCEPT = default;
    CRGBPalette32(const CRGBPalette32 &rhs) FL_NOEXCEPT = default;
    CRGBPalette32 &operator=(const CRGBPalette32 &rhs) FL_NOEXCEPT = default;
 
    CRGBPalette32(const CRGB &c00, const CRGB &c01, const CRGB &c02,
                  const CRGB &c03, const CRGB &c04, const CRGB &c05,
                  const CRGB &c06, const CRGB &c07, const CRGB &c08,
                  const CRGB &c09, const CRGB &c10, const CRGB &c11,
                  const CRGB &c12, const CRGB &c13, const CRGB &c14,
                  const CRGB &c15) FL_NOEXCEPT {
        CRGBPalette16 p16(c00, c01, c02, c03, c04, c05, c06, c07, c08, c09,
                          c10, c11, c12, c13, c14, c15);
        *this = p16;
    }
 
    CRGBPalette32(const CRGBPalette16 &rhs16) FL_NOEXCEPT { UpscalePalette(rhs16, *this); }
 
    CRGBPalette32 &operator=(const CRGBPalette16 &rhs16) FL_NOEXCEPT {
        UpscalePalette(rhs16, *this);
        return *this;
    }
 
    CRGBPalette32(const TProgmemRGBPalette16 &rhs) FL_NOEXCEPT {
        CRGBPalette16 p16(rhs);
        *this = p16;
    }
 
    CRGBPalette32 &operator=(const TProgmemRGBPalette16 &rhs) FL_NOEXCEPT {
        CRGBPalette16 p16(rhs);
        *this = p16;
        return *this;
    }
 
    CRGBPalette32(const TProgmemRGBPalette32 &rhs) FL_NOEXCEPT {
        detail::loadProgmemPalette(entries, rhs, 32);
    }
 
    CRGBPalette32 &operator=(const TProgmemRGBPalette32 &rhs) FL_NOEXCEPT {
        detail::loadProgmemPalette(entries, rhs, 32);
        return *this;
    }

    CRGBPalette32(TProgmemRGBGradientPalette_bytes progpal) FL_NOEXCEPT { *this = progpal; }
    CRGBPalette32 &operator=(TProgmemRGBGradientPalette_bytes progpal) FL_NOEXCEPT {
        TRGBGradientPaletteEntryUnion *progent =
            //(TRGBGradientPaletteEntryUnion *)(progpal);
            fl::bit_cast<TRGBGradientPaletteEntryUnion *>(progpal);
        TRGBGradientPaletteEntryUnion u;
 
        // Count entries with safety limit to prevent buffer overrun
        fl::u16 count = 0;
        bool has_terminator = false;
        do {
            u.dword = FL_PGM_READ_DWORD_NEAR(progent + count);
            ++count;
            if (u.index == 255) {
                has_terminator = true;
                break;
            }
            if (count >= FASTLED_MAX_GRADIENT_PALETTE_ENTRIES) {
                FL_WARN("DEFINE_GRADIENT_PALETTE missing index=255 terminator! "
                        "This will cause buffer overruns and crashes. "
                        "Auto-correcting but please fix your gradient definition.");
                break;
            }
        } while (true);
 
        fl::i8 lastSlotUsed = -1;
 
        u.dword = FL_PGM_READ_DWORD_NEAR(progent);
        CRGB rgbstart(u.r, u.g, u.b);
 
        int indexstart = 0;
        fl::u8 istart8 = 0;
        fl::u8 iend8 = 0;
        fl::u16 entries_processed = 0;
        while (indexstart < 255) {
            // Safety: check BEFORE reading to prevent buffer overrun
            if (!has_terminator && entries_processed + 1 >= count) {
                // No more validated entries - extend current color to 255
                istart8 = indexstart / 8;
                iend8 = 255 / 8;
                if (count < 16) {
                    if ((istart8 <= lastSlotUsed) && (lastSlotUsed < 31)) {
                        istart8 = lastSlotUsed + 1;
                        if (iend8 < istart8) {
                            iend8 = istart8;
                        }
                    }
                }
                fill_gradient_RGB(&(entries[0]), istart8, rgbstart, iend8, rgbstart);
                break;
            }
 
            ++progent;
            u.dword = FL_PGM_READ_DWORD_NEAR(progent);
            int indexend = u.index;
            CRGB rgbend(u.r, u.g, u.b);
 
 
            istart8 = indexstart / 8;
            iend8 = indexend / 8;
            if (count < 16) {
                if ((istart8 <= lastSlotUsed) && (lastSlotUsed < 31)) {
                    istart8 = lastSlotUsed + 1;
                    if (iend8 < istart8) {
                        iend8 = istart8;
                    }
                }
                lastSlotUsed = iend8;
            }
            fill_gradient_RGB(&(entries[0]), istart8, rgbstart, iend8, rgbend);
            indexstart = indexend;
            rgbstart = rgbend;
            ++entries_processed;
        }
        return *this;
    }
    CRGBPalette32 &
    loadDynamicGradientPalette(TDynamicRGBGradientPalette_bytes gpal) FL_NOEXCEPT {
        TRGBGradientPaletteEntryUnion *ent =
            // (TRGBGradientPaletteEntryUnion *)(gpal);
            fl::bit_cast<TRGBGradientPaletteEntryUnion *>(gpal);
        TRGBGradientPaletteEntryUnion u;
 
        // Count entries with safety limit to prevent buffer overrun
        fl::u16 count = 0;
        bool has_terminator = false;
        do {
            u = *(ent + count);
            ++count;
            if (u.index == 255) {
                has_terminator = true;
                break;
            }
            if (count >= FASTLED_MAX_GRADIENT_PALETTE_ENTRIES) {
                FL_WARN("Dynamic gradient palette missing index=255 terminator! "
                        "This will cause buffer overruns and crashes. "
                        "Auto-correcting but please fix your gradient definition.");
                break;
            }
        } while (true);
 
        fl::i8 lastSlotUsed = -1;
 
        u = *ent;
        CRGB rgbstart(u.r, u.g, u.b);
 
        int indexstart = 0;
        fl::u8 istart8 = 0;
        fl::u8 iend8 = 0;
        fl::u16 entries_processed = 0;
        while (indexstart < 255) {
            // Safety: check BEFORE reading to prevent buffer overrun
            if (!has_terminator && entries_processed + 1 >= count) {
                // No more validated entries - extend current color to 255
                istart8 = indexstart / 8;
                iend8 = 255 / 8;
                if (count < 16) {
                    if ((istart8 <= lastSlotUsed) && (lastSlotUsed < 31)) {
                        istart8 = lastSlotUsed + 1;
                        if (iend8 < istart8) {
                            iend8 = istart8;
                        }
                    }
                }
                fill_gradient_RGB(&(entries[0]), istart8, rgbstart, iend8, rgbstart);
                break;
            }
 
            ++ent;
            u = *ent;
            int indexend = u.index;
            CRGB rgbend(u.r, u.g, u.b);
 
 
            istart8 = indexstart / 8;
            iend8 = indexend / 8;
            if (count < 16) {
                if ((istart8 <= lastSlotUsed) && (lastSlotUsed < 31)) {
                    istart8 = lastSlotUsed + 1;
                    if (iend8 < istart8) {
                        iend8 = istart8;
                    }
                }
                lastSlotUsed = iend8;
            }
            fill_gradient_RGB(&(entries[0]), istart8, rgbstart, iend8, rgbend);
            indexstart = indexend;
            rgbstart = rgbend;
            ++entries_processed;
        }
        return *this;
    }
};

class CRGBPalette256 : public detail::TCRGBPalette<256> {
  public:
    using Base = detail::TCRGBPalette<256>;
    using Base::Base;
    using Base::entries;
    // operator== / operator!= are hidden friends on Base (#2724); they reach
    // derived classes automatically via ADL, so no using-declaration needed.
    using Base::operator=;
    using Base::operator[];
    using Base::operator CRGB*;
 
    CRGBPalette256() FL_NOEXCEPT = default;
    CRGBPalette256(const CRGBPalette256 &rhs) FL_NOEXCEPT = default;
    CRGBPalette256 &operator=(const CRGBPalette256 &rhs) FL_NOEXCEPT = default;
 
    CRGBPalette256(const CRGB &c00, const CRGB &c01, const CRGB &c02,
                   const CRGB &c03, const CRGB &c04, const CRGB &c05,
                   const CRGB &c06, const CRGB &c07, const CRGB &c08,
                   const CRGB &c09, const CRGB &c10, const CRGB &c11,
                   const CRGB &c12, const CRGB &c13, const CRGB &c14,
                   const CRGB &c15) FL_NOEXCEPT {
        CRGBPalette16 p16(c00, c01, c02, c03, c04, c05, c06, c07, c08, c09,
                          c10, c11, c12, c13, c14, c15);
        *this = p16;
    }
 
    CRGBPalette256(const CRGBPalette16 &rhs16) FL_NOEXCEPT { UpscalePalette(rhs16, *this); }
    CRGBPalette256(const CRGBPalette32 &rhs32) FL_NOEXCEPT { UpscalePalette(rhs32, *this); }
 
    CRGBPalette256 &operator=(const CRGBPalette16 &rhs16) FL_NOEXCEPT {
        UpscalePalette(rhs16, *this);
        return *this;
    }
 
    CRGBPalette256 &operator=(const CRGBPalette32 &rhs32) FL_NOEXCEPT {
        UpscalePalette(rhs32, *this);
        return *this;
    }
 
    CRGBPalette256(const TProgmemRGBPalette16 &rhs) FL_NOEXCEPT {
        CRGBPalette16 p16(rhs);
        *this = p16;
    }
 
    CRGBPalette256 &operator=(const TProgmemRGBPalette16 &rhs) FL_NOEXCEPT {
        CRGBPalette16 p16(rhs);
        *this = p16;
        return *this;
    }
 
    CRGBPalette256(const TProgmemRGBPalette32 &rhs) FL_NOEXCEPT {
        CRGBPalette32 p32(rhs);
        *this = p32;
    }
 
    CRGBPalette256 &operator=(const TProgmemRGBPalette32 &rhs) FL_NOEXCEPT {
        CRGBPalette32 p32(rhs);
        *this = p32;
        return *this;
    }

    CRGBPalette256(TProgmemRGBGradientPalette_bytes progpal) FL_NOEXCEPT {
        *this = progpal;
    }
    CRGBPalette256 &operator=(TProgmemRGBGradientPalette_bytes progpal) FL_NOEXCEPT {
        TRGBGradientPaletteEntryUnion *progent =
            // (TRGBGradientPaletteEntryUnion *)(progpal);
            fl::bit_cast<TRGBGradientPaletteEntryUnion *>(progpal);
        TRGBGradientPaletteEntryUnion u;
        u.dword = FL_PGM_READ_DWORD_NEAR(progent);
        CRGB rgbstart(u.r, u.g, u.b);
 
        int indexstart = 0;
        fl::u16 entries_processed = 0;
        while (indexstart < 255) {
            // Safety: check BEFORE reading to prevent buffer overrun
            if (entries_processed >= FASTLED_MAX_GRADIENT_PALETTE_ENTRIES) {
                FL_WARN("DEFINE_GRADIENT_PALETTE missing index=255 terminator! "
                        "This will cause buffer overruns and crashes. "
                        "Auto-correcting but please fix your gradient definition.");
                // Extend current color to 255
                fill_gradient_RGB(&(entries[0]), indexstart, rgbstart, 255, rgbstart);
                break;
            }
 
            ++progent;
            u.dword = FL_PGM_READ_DWORD_NEAR(progent);
            int indexend = u.index;
            CRGB rgbend(u.r, u.g, u.b);
 
            fill_gradient_RGB(&(entries[0]), indexstart, rgbstart, indexend,
                              rgbend);
            indexstart = indexend;
            rgbstart = rgbend;
            ++entries_processed;
        }
        return *this;
    }
    CRGBPalette256 &
    loadDynamicGradientPalette(TDynamicRGBGradientPalette_bytes gpal) FL_NOEXCEPT {
        TRGBGradientPaletteEntryUnion *ent =
            //(TRGBGradientPaletteEntryUnion *)(gpal);
            fl::bit_cast<TRGBGradientPaletteEntryUnion *>(gpal);
        TRGBGradientPaletteEntryUnion u;
        u = *ent;
        CRGB rgbstart(u.r, u.g, u.b);
 
        int indexstart = 0;
        fl::u16 entries_processed = 0;
        while (indexstart < 255) {
            // Safety: check BEFORE reading to prevent buffer overrun
            if (entries_processed >= FASTLED_MAX_GRADIENT_PALETTE_ENTRIES) {
                FL_WARN("Dynamic gradient palette missing index=255 terminator! "
                        "This will cause buffer overruns and crashes. "
                        "Auto-correcting but please fix your gradient definition.");
                // Extend current color to 255
                fill_gradient_RGB(&(entries[0]), indexstart, rgbstart, 255, rgbstart);
                break;
            }
 
            ++ent;
            u = *ent;
            int indexend = u.index;
            CRGB rgbend(u.r, u.g, u.b);
 
            fill_gradient_RGB(&(entries[0]), indexstart, rgbstart, indexend,
                              rgbend);
            indexstart = indexend;
            rgbstart = rgbend;
            ++entries_processed;
        }
        return *this;
    }
};



typedef enum {
    NOBLEND = 0,     
    BLEND = 1,       
    LINEARBLEND = 1, 
    LINEARBLEND_NOWRAP =
        2 
} TBlendType;

CRGB ColorFromPalette(const CRGBPalette16 &pal, fl::u8 index,
                      fl::u8 brightness = 255,
                      TBlendType blendType = LINEARBLEND) FL_NOEXCEPT;

CRGB ColorFromPaletteExtended(const CRGBPalette16 &pal, fl::u16 index,
                              fl::u8 brightness, TBlendType blendType) FL_NOEXCEPT;

CRGB16 ColorFromPaletteHD(const CRGBPalette16 &pal, fl::u16 index,
                          fl::u8x8 brightness = fl::u8x8(1),
                          TBlendType blendType = LINEARBLEND) FL_NOEXCEPT;

inline CRGB16 ColorFromPaletteHD(const CRGBPalette16 &pal, fl::u16 index,
                                 fl::u8 brightness,
                                 TBlendType blendType = LINEARBLEND) FL_NOEXCEPT {
    const fl::u16 raw = brightness == 255 ? fl::u16(256) : brightness;
    return ColorFromPaletteHD(pal, index, fl::u8x8::from_raw(raw), blendType);
}

CRGB ColorFromPaletteExtended(const CRGBPalette32 &pal, fl::u16 index,
                              fl::u8 brightness, TBlendType blendType) FL_NOEXCEPT;

CRGB16 ColorFromPaletteHD(const CRGBPalette32 &pal, fl::u16 index,
                          fl::u8x8 brightness = fl::u8x8(1),
                          TBlendType blendType = LINEARBLEND) FL_NOEXCEPT;

inline CRGB16 ColorFromPaletteHD(const CRGBPalette32 &pal, fl::u16 index,
                                 fl::u8 brightness,
                                 TBlendType blendType = LINEARBLEND) FL_NOEXCEPT {
    const fl::u16 raw = brightness == 255 ? fl::u16(256) : brightness;
    return ColorFromPaletteHD(pal, index, fl::u8x8::from_raw(raw), blendType);
}

CRGB ColorFromPaletteExtended(const TProgmemRGBPalette16 &pal, fl::u16 index,
                              fl::u8 brightness = 255,
                              TBlendType blendType = LINEARBLEND) FL_NOEXCEPT;

CRGB16 ColorFromPaletteHD(const TProgmemRGBPalette16 &pal, fl::u16 index,
                          fl::u8x8 brightness = fl::u8x8(1),
                          TBlendType blendType = LINEARBLEND) FL_NOEXCEPT;

inline CRGB16 ColorFromPaletteHD(const TProgmemRGBPalette16 &pal, fl::u16 index,
                                 fl::u8 brightness,
                                 TBlendType blendType = LINEARBLEND) FL_NOEXCEPT {
    const fl::u16 raw = brightness == 255 ? fl::u16(256) : brightness;
    return ColorFromPaletteHD(pal, index, fl::u8x8::from_raw(raw), blendType);
}

CRGB ColorFromPaletteExtended(const TProgmemRGBPalette32 &pal, fl::u16 index,
                              fl::u8 brightness = 255,
                              TBlendType blendType = LINEARBLEND) FL_NOEXCEPT;

CRGB16 ColorFromPaletteHD(const TProgmemRGBPalette32 &pal, fl::u16 index,
                          fl::u8x8 brightness = fl::u8x8(1),
                          TBlendType blendType = LINEARBLEND) FL_NOEXCEPT;

inline CRGB16 ColorFromPaletteHD(const TProgmemRGBPalette32 &pal, fl::u16 index,
                                 fl::u8 brightness,
                                 TBlendType blendType = LINEARBLEND) FL_NOEXCEPT {
    const fl::u16 raw = brightness == 255 ? fl::u16(256) : brightness;
    return ColorFromPaletteHD(pal, index, fl::u8x8::from_raw(raw), blendType);
}

CRGB ColorFromPalette(const TProgmemRGBPalette16 &pal, fl::u8 index,
                      fl::u8 brightness = 255,
                      TBlendType blendType = LINEARBLEND) FL_NOEXCEPT;

CRGB ColorFromPalette(const CRGBPalette256 &pal, fl::u8 index,
                      fl::u8 brightness = 255, TBlendType blendType = NOBLEND) FL_NOEXCEPT;
 
// @author https://github.com/generalelectrix
CRGB ColorFromPaletteExtended(const CRGBPalette256 &pal, fl::u16 index,
                              fl::u8 brightness = 255,
                              TBlendType blendType = LINEARBLEND) FL_NOEXCEPT;

CRGB16 ColorFromPaletteHD(const CRGBPalette256 &pal, fl::u16 index,
                          fl::u8x8 brightness = fl::u8x8(1),
                          TBlendType blendType = LINEARBLEND) FL_NOEXCEPT;

inline CRGB16 ColorFromPaletteHD(const CRGBPalette256 &pal, fl::u16 index,
                                 fl::u8 brightness,
                                 TBlendType blendType = LINEARBLEND) FL_NOEXCEPT {
    const fl::u16 raw = brightness == 255 ? fl::u16(256) : brightness;
    return ColorFromPaletteHD(pal, index, fl::u8x8::from_raw(raw), blendType);
}

CHSV ColorFromPalette(const CHSVPalette16 &pal, fl::u8 index,
                      fl::u8 brightness = 255,
                      TBlendType blendType = LINEARBLEND) FL_NOEXCEPT;

CHSV ColorFromPalette(const CHSVPalette256 &pal, fl::u8 index,
                      fl::u8 brightness = 255, TBlendType blendType = NOBLEND) FL_NOEXCEPT;

CRGB ColorFromPalette(const CRGBPalette32 &pal, fl::u8 index,
                      fl::u8 brightness = 255,
                      TBlendType blendType = LINEARBLEND) FL_NOEXCEPT;

CRGB ColorFromPalette(const TProgmemRGBPalette32 &pal, fl::u8 index,
                      fl::u8 brightness = 255,
                      TBlendType blendType = LINEARBLEND) FL_NOEXCEPT;

CHSV ColorFromPalette(const CHSVPalette32 &pal, fl::u8 index,
                      fl::u8 brightness = 255,
                      TBlendType blendType = LINEARBLEND) FL_NOEXCEPT;

template <typename PALETTE>
void fill_palette(CRGB *L, fl::u16 N, fl::u8 startIndex, fl::u8 incIndex,
                  const PALETTE &pal, fl::u8 brightness = 255,
                  TBlendType blendType = LINEARBLEND) FL_NOEXCEPT {
    fl::u8 colorIndex = startIndex;
    for (fl::u16 i = 0; i < N; ++i) {
        L[i] = ColorFromPalette(pal, colorIndex, brightness, blendType);
        colorIndex += incIndex;
    }
}

template <typename PALETTE>
inline void fill_palette(fl::span<CRGB> L, fl::u8 startIndex, fl::u8 incIndex,
                         const PALETTE &pal, fl::u8 brightness = 255,
                         TBlendType blendType = LINEARBLEND) FL_NOEXCEPT {
    fill_palette(L.data(), static_cast<fl::u16>(L.size()), startIndex, incIndex,
                 pal, brightness, blendType);
}

template <typename PALETTE>
void fill_palette_circular(CRGB *L, fl::u16 N, fl::u8 startIndex,
                           const PALETTE &pal, fl::u8 brightness = 255,
                           TBlendType blendType = LINEARBLEND,
                           bool reversed = false) FL_NOEXCEPT {
    if (N == 0)
        return; // avoiding div/0
 
    const fl::u16 colorChange =
        65535 / N; // color change for each LED, * 256 for precision
    fl::u16 colorIndex = ((fl::u16)startIndex)
                          << 8; // offset for color index, with precision (*256)
 
    for (fl::u16 i = 0; i < N; ++i) {
        L[i] = ColorFromPalette(pal, (colorIndex >> 8), brightness, blendType);
        if (reversed)
            colorIndex -= colorChange;
        else
            colorIndex += colorChange;
    }
}

template <typename PALETTE>
inline void fill_palette_circular(fl::span<CRGB> L, fl::u8 startIndex,
                                  const PALETTE &pal, fl::u8 brightness = 255,
                                  TBlendType blendType = LINEARBLEND,
                                  bool reversed = false) FL_NOEXCEPT {
    fill_palette_circular(L.data(), static_cast<fl::u16>(L.size()), startIndex,
                          pal, brightness, blendType, reversed);
}

template <typename PALETTE>
void map_data_into_colors_through_palette(
    fl::u8 *dataArray, fl::u16 dataCount, CRGB *targetColorArray,
    const PALETTE &pal, fl::u8 brightness = 255, fl::u8 opacity = 255,
    TBlendType blendType = LINEARBLEND) FL_NOEXCEPT {
    for (fl::u16 i = 0; i < dataCount; ++i) {
        fl::u8 d = dataArray[i];
        CRGB rgb = ColorFromPalette(pal, d, brightness, blendType);
        if (opacity == 255) {
            targetColorArray[i] = rgb;
        } else {
            targetColorArray[i].nscale8(256 - opacity);
            rgb.nscale8_video(opacity);
            targetColorArray[i] += rgb;
        }
    }
}

template <typename PALETTE>
inline void map_data_into_colors_through_palette(
    fl::span<fl::u8> dataArray, fl::span<CRGB> targetColorArray,
    const PALETTE &pal, fl::u8 brightness = 255, fl::u8 opacity = 255,
    TBlendType blendType = LINEARBLEND) FL_NOEXCEPT {
    map_data_into_colors_through_palette(
        dataArray.data(), static_cast<fl::u16>(dataArray.size()),
        targetColorArray.data(), pal, brightness, opacity, blendType);
}

void nblendPaletteTowardPalette(CRGBPalette16 &currentPalette,
                                CRGBPalette16 &targetPalette,
                                fl::u8 maxChanges = 24) FL_NOEXCEPT;




fl::u8 applyGamma_video(fl::u8 brightness, float gamma) FL_NOEXCEPT;

CRGB applyGamma_video(const CRGB &orig, float gamma) FL_NOEXCEPT;

CRGB applyGamma_video(const CRGB &orig, float gammaR, float gammaG,
                      float gammaB) FL_NOEXCEPT;

CRGB &napplyGamma_video(CRGB &rgb, float gamma) FL_NOEXCEPT;

CRGB &napplyGamma_video(CRGB &rgb, float gammaR, float gammaG, float gammaB) FL_NOEXCEPT;

void napplyGamma_video(CRGB *rgbarray, fl::u16 count, float gamma) FL_NOEXCEPT;

inline void napplyGamma_video(fl::span<CRGB> rgbarray, float gamma) FL_NOEXCEPT {
    napplyGamma_video(rgbarray.data(), static_cast<fl::u16>(rgbarray.size()),
                      gamma);
}

void napplyGamma_video(CRGB *rgbarray, fl::u16 count, float gammaR,
                       float gammaG, float gammaB) FL_NOEXCEPT;

inline void napplyGamma_video(fl::span<CRGB> rgbarray, float gammaR,
                              float gammaG, float gammaB) FL_NOEXCEPT {
    napplyGamma_video(rgbarray.data(), static_cast<fl::u16>(rgbarray.size()),
                      gammaR, gammaG, gammaB);
}

 
} // namespace fl
 
FL_DISABLE_WARNING_POP