Function showRGBInternal

src/platforms/avr/clockless_avr.h:677–869

===== MAIN BIT-BANGING FUNCTION ===== This method is made static to force making register Y available to use for data on AVR - if the method is non-static, then gcc will use register Y for the this pointer. By making it static, Y register becomes available for general use. FUNCTION PURPOSE: Outputs RGB pixel data to WS2812/WS2811 LEDs using precisely timed bit-banging While outputting each byte (

	// 2. Output byte 1 (e.g., G) while preparing byte 2 (e.g., B)
	// 3. Output byte 2 (e.g., B) while preparing byte 0 of next pixel (e.g., next R)
	static void /*__attribute__((optimize("O0")))*/  /*__attribute__ ((always_inline))*/  showRGBInternal(PixelController<RGB_ORDER> & pixels)  {
		u8 *data = (u8*)pixels.mData;  // Pointer to pixel array
		data_ptr_t port = FastPin<DATA_PIN>::port();  // GPIO port register address
		data_t mask = FastPin<DATA_PIN>::mask();  // Pin bit mask
		u8 scale_base = 0;  // Scratch variable for scaling operations

		// FASTLED_REGISTER uint8_t *end = data + nLeds;

		// Compute port values for HIGH and LOW states
		data_t hi = *port | mask;   // Set data pin bit to 1 (HIGH), preserve other pins
		data_t lo = *port & ~mask;  // Clear data pin bit to 0 (LOW), preserve other pins
		*port = lo;  // Initialize line to LOW state

		// DOUBLE-BUFFER BYTES: b0=currently outputting, b1=next being prepared
		u8 b0 = 0;  // The byte currently being written out bit-by-bit
		u8 b1 = 0;  // The byte currently being loaded, dithered, and scaled for next output

		// Setup the pixel controller
		pixels.preStepFirstByteDithering();

		// ===== EXTRACT VARIABLES FOR ASM ACCESS =====
		// Pull all needed values into local variables so inline asm can reference them via ASM_VARS
		// These are mapped to AVR registers through the ASM_VARS constraint list

		// advanceBy: Stride to next pixel (typically 3 for RGB, 4 for RGBW, negative for reverse order)
		// Cast to int16 for sign extension (handles negative strides correctly)
		i16 advanceBy = pixels.advanceBy();
		u16 count = pixels.mLen;  // Number of pixels to output

		// s0, s1, s2: Scale factors for each color channel (brightness/color correction)
		// Range: 0-255 (0=off, 255=full brightness)
		// RO() handles RGB_ORDER remapping (e.g., RGB vs GRB vs BGR)
		u8 s0 = pixels.mColorAdjustment.premixed.raw[RO(0)];
		u8 s1 = pixels.mColorAdjustment.premixed.raw[RO(1)];
		u8 s2 = pixels.mColorAdjustment.premixed.raw[RO(2)];
#if (FASTLED_SCALE8_FIXED==1)
		// Scale8 fix: increment scale factors so 255 wraps to 0
		// Assembly code detects s==0 as special case to return unscaled value
		// This makes scale8(x, 255) return x instead of (x*255)/256
		s0++; s1++; s2++;
#endif

		// d0, d1, d2: Current dither values for each channel
		// Dithering reduces color banding by adding controlled temporal noise
		u8 d0 = pixels.d[RO(0)];
		u8 d1 = pixels.d[RO(1)];
		u8 d2 = pixels.d[RO(2)];

		// e0, e1, e2: Dither step values (d is updated by: d = e - d after each pixel)
		u8 e0 = pixels.e[RO(0)];
		u8 e1 = pixels.e[RO(1)];
		u8 e2 = pixels.e[RO(2)];

		u8 loopvar=0;  // Scratch variable for delay loops

		// ===== FIRST BYTE INITIALIZATION =====
		// Load and scale the very first byte (byte 0 of first pixel) before entering main loop
		// This has to be done in asm to keep gcc from messing up the asm code further down