encodeAPA102_AutoBrightness()

template<typename InputIterator, typename OutputIterator>

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

Encode pixel data in APA102 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

Extracts global brightness from max component of first pixel

APA102 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 131 of file apa102.h.

                                                                  {
    if (first == last) {
        // Preserve a complete frame even at zero LEDs. This matters when a
        // previously longer cascade is reconfigured through the public API.
        *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
    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::writeAPA102().

Here is the caller graph for this function: