encodeSK9822_AutoBrightness()

template<typename InputIterator, typename OutputIterator>

FL_NO_INLINE_IF_AVR void fl::encodeSK9822_AutoBrightness	(	InputIterator	first,
		InputIterator	last,
		OutputIterator	out )

Encode pixel data in SK9822 format (auto-detected brightness from first pixel)

Template Parameters

InputIterator	Iterator yielding fl::array<u8, 3> (3 bytes in wire order)
OutputIterator	Output iterator accepting uint8_t

Parameters

first	Iterator to first pixel
last	Iterator past last pixel
out	Output iterator for encoded bytes

Note

SK9822 uses BGR wire order: pixel[0]=Blue, pixel[1]=Green, pixel[2]=Red

Uses O2 optimization to avoid AVR register allocation issues with LTO

Marked noinline on AVR to prevent register exhaustion from divisions

Definition at line 122 of file sk9822.h.

                                                                  {
    if (first == last) {
        // Keep zero LEDs as a full frame, matching the non-auto encoder.
        *out++ = 0x00; *out++ = 0x00; *out++ = 0x00; *out++ = 0x00;
        *out++ = 0xFF; *out++ = 0xFF; *out++ = 0xFF; *out++ = 0xFF;
        return;
    }
 
    // Start frame
    *out++ = 0x00;
    *out++ = 0x00;
    *out++ = 0x00;
    *out++ = 0x00;
 
    // Extract global brightness from first pixel
    const fl::array<u8, BYTES_PER_PIXEL_RGB>& first_pixel = *first;
    const u16 maxBrightness = 0x1F;
    // Use sequential comparisons to avoid nested fl::max (helps AVR register allocation)
    u8 max_rg = (first_pixel[2] > first_pixel[1]) ? first_pixel[2] : first_pixel[1];
    u8 max_component = (max_rg > first_pixel[0]) ? max_rg : first_pixel[0];
    u16 brightness = ((((u16)max_component + 1) * maxBrightness - 1) >> 8) + 1;
    u8 global_brightness = static_cast<u8>(brightness);
 
    // Write first LED with extracted brightness (BGR order: 0=B, 1=G, 2=R)
    u8 s0 = (maxBrightness * first_pixel[2] + (brightness >> 1)) / brightness;  // Red
    u8 s1 = (maxBrightness * first_pixel[1] + (brightness >> 1)) / brightness;  // Green
    u8 s2 = (maxBrightness * first_pixel[0] + (brightness >> 1)) / brightness;  // Blue
 
    *out++ = 0xE0 | (global_brightness & 0x1F);
    *out++ = s2;  // Blue
    *out++ = s1;  // Green
    *out++ = s0;  // Red
    ++first;
 
    // Write remaining LEDs (count as we go)
    size_t num_leds = 1;  // Already wrote first pixel
    while (first != last) {
        const fl::array<u8, BYTES_PER_PIXEL_RGB>& pixel = *first;
        *out++ = 0xE0 | (global_brightness & 0x1F);
        *out++ = pixel[0];  // Index 0 (BGR order: Blue)
        *out++ = pixel[1];  // Index 1 (BGR order: Green)
        *out++ = pixel[2];  // Index 2 (BGR order: Red)
        ++first;
        ++num_leds;
    }
 
    // End frame: all ones clock the final data through the cascade.
    size_t end_dwords = (num_leds / 32) + 1;
    for (size_t i = 0; i < end_dwords * 4; i++) {
        *out++ = 0xFF;
    }
}

References brightness, and FL_NO_EXCEPT.

Referenced by fl::PixelIterator::writeSK9822().

Here is the caller graph for this function: