encodeUCS7604()

template<typename OutputIterator>

void fl::encodeUCS7604	(	PixelIterator &	pixel_iter,
		size_t	num_leds,
		OutputIterator	out,
		UCS7604Mode	mode,
		const UCS7604CurrentControl &	current,
		bool	is_rgbw,
		const Gamma8 *	gamma = nullptr,
		bool	wide_source = false )

Encode complete UCS7604 frame (preamble + padding + pixel data)

Template Parameters

OutputIterator

Output iterator accepting uint8_t

Parameters

pixel_iter	PixelIterator with pixel data and scaling/gamma/dithering
num_leds	Number of LEDs to encode
out	Output iterator for complete frame
mode	UCS7604 protocol mode (8-bit/16-bit)
current	Current control settings (wire order RGBW)
is_rgbw	True for RGBW mode, false for RGB mode
gamma	Gamma8 LUT for 16-bit modes (nullable, ignored for 8-bit mode)

Note

Outputs: preamble (15 bytes) + padding (0-2 bytes) + LED data

Total output size is always divisible by 3 (required by UCS7604 protocol)

Definition at line 273 of file ucs7604.h.

                                                          {
    constexpr size_t PREAMBLE_LEN = 15;
 
#if FL_PLATFORM_HAS_TINY_MEMORY
    // No wide encoder exists on TINY, so the flag selects nothing there.
    FL_UNUSED(wide_source);
#endif
 
    // Padding comes from ucs7604FrameBytes() so the length callers predict and
    // the length written here are the same number by construction.
    const size_t led_data_size = num_leds * ucs7604BytesPerLed(mode, is_rgbw);
    const size_t padding =
        ucs7604FrameBytes(num_leds, mode, is_rgbw) - PREAMBLE_LEN - led_data_size;
 
    // Build preamble (15 bytes) with current control
    buildUCS7604Preamble(out, mode, current.r, current.g, current.b, current.w);
 
    // Add padding (0-2 zero bytes)
    for (size_t i = 0; i < padding; ++i) {
        *out++ = 0;
    }
 
    // Encode LED data based on mode and RGB/RGBW
    if (mode == UCS7604Mode::UCS7604_MODE_8BIT_800KHZ) {
        if (is_rgbw) {
            auto range = makeScaledPixelRangeRGBW(&pixel_iter);
            encodeUCS7604_8bit_RGBW(range.first, range.second, out);
        } else {
            auto range = makeScaledPixelRangeRGB(&pixel_iter);
            encodeUCS7604_8bit_RGB(range.first, range.second, out);
        }
    } else {
        // 16-bit modes -- fall back to gamma 2.8 if no gamma provided
        static fl::shared_ptr<const Gamma8> default_gamma;
        const Gamma8& g = gamma ? *gamma : *(default_gamma ? default_gamma : (default_gamma = Gamma8::getOrCreate(2.8f)));
        if (is_rgbw) {
            // RGBW stays on the gamma path: `ColorManagedPixelSource`
            // delegates its RGBW entry point to the legacy controller, so
            // there is no wide drive to consume here yet.
            auto range = makeScaledPixelRangeRGBW(&pixel_iter);
            encodeUCS7604_16bit_RGBW(range.first, range.second, out, g);
#if !FL_PLATFORM_HAS_TINY_MEMORY
        } else if (wide_source) {
            encodeUCS7604_16bit_RGB_wide(pixel_iter, out);
#endif
        } else {
            auto range = makeScaledPixelRangeRGB(&pixel_iter);
            encodeUCS7604_16bit_RGB(range.first, range.second, out, g);
        }
    }
}

References fl::UCS7604CurrentControl::b, buildUCS7604Preamble(), encodeUCS7604_16bit_RGB(), encodeUCS7604_16bit_RGB_wide(), encodeUCS7604_16bit_RGBW(), encodeUCS7604_8bit_RGB(), encodeUCS7604_8bit_RGBW(), FL_NO_EXCEPT, FL_UNUSED, g, fl::UCS7604CurrentControl::g, gamma(), fl::Gamma8::getOrCreate(), makeScaledPixelRangeRGB(), makeScaledPixelRangeRGBW(), fl::UCS7604CurrentControl::r, UCS7604_MODE_8BIT_800KHZ, ucs7604BytesPerLed(), ucs7604FrameBytes(), and fl::UCS7604CurrentControl::w.

Referenced by fl::UCS7604ControllerT< DATA_PIN, RGB_ORDER, fl::UCS7604Mode::UCS7604_MODE_8BIT_800KHZ, fl::TIMING_UCS7604_800KHZ, CLOCKLESS_CONTROLLER >::showPixels(), and fl::anonymous_namespace{channel.cpp.hpp}::writeUCS7604().

Here is the call graph for this function:

Here is the caller graph for this function: