upscaleRectangularPowerOf2()

void fl::upscaleRectangularPowerOf2	(	const CRGB *	input,
		CRGB *	output,
		u8	inputWidth,
		u8	inputHeight,
		u8	outputWidth,
		u8	outputHeight )

Optimized upscale for rectangular/line-by-line XY maps (power-of-2 version).

Parameters

input	The input grid to read from.
output	The output grid to write into the interpolated values.
inputWidth	The width of the input grid (must be power of 2).
inputHeight	The height of the input grid (must be power of 2).
outputWidth	The width of the output grid (must be power of 2).
outputHeight	The height of the output grid (must be power of 2). This version bypasses XY mapping overhead for rectangular layouts.

Definition at line 62 of file upscale.cpp.hpp.

                                                                                 {
    for (u8 y = 0; y < outputHeight; y++) {
        for (u8 x = 0; x < outputWidth; x++) {
            // Use 8-bit fixed-point arithmetic with 8 fractional bits
            // (scale factor of 256)
            u16 fx = ((u16)x * (inputWidth - 1) * 256) / (outputWidth - 1);
            u16 fy = ((u16)y * (inputHeight - 1) * 256) / (outputHeight - 1);
 
            u8 ix = fx >> 8; // Integer part
            u8 iy = fy >> 8;
            u8 dx = fx & 0xFF; // Fractional part
            u8 dy = fy & 0xFF;
 
            u8 ix1 = (ix + 1 < inputWidth) ? ix + 1 : ix;
            u8 iy1 = (iy + 1 < inputHeight) ? iy + 1 : iy;
 
            // Direct array access - no XY mapping overhead
            u16 i00 = iy * inputWidth + ix;
            u16 i10 = iy * inputWidth + ix1;
            u16 i01 = iy1 * inputWidth + ix;
            u16 i11 = iy1 * inputWidth + ix1;
 
            CRGB c00 = input[i00];
            CRGB c10 = input[i10];
            CRGB c01 = input[i01];
            CRGB c11 = input[i11];
 
            CRGB result;
            result.r =
                bilinearInterpolatePowerOf2(c00.r, c10.r, c01.r, c11.r, dx, dy);
            result.g =
                bilinearInterpolatePowerOf2(c00.g, c10.g, c01.g, c11.g, dx, dy);
            result.b =
                bilinearInterpolatePowerOf2(c00.b, c10.b, c01.b, c11.b, dx, dy);
 
            // Direct array access - no XY mapping overhead
            u16 idx = y * outputWidth + x;
            output[idx] = result;
        }
    }
}

References bilinearInterpolatePowerOf2(), x, and y.

Referenced by upscale().

Here is the call graph for this function:

Here is the caller graph for this function: