scale16by8()

LIB8STATIC_ALWAYS_INLINE uint16_t scale16by8	(	uint16_t	i,
		fract8	scale )

Scale a 16-bit unsigned value by an 8-bit value, which is treated as the numerator of a fraction whose denominator is 256.

In other words, it computes i * (scale / 256)

Parameters

i	input value to scale
scale	scale factor, in n/256 units

Returns

scaled value

Definition at line 474 of file scale8.h.

                                                                       {
    if (scale == 0) {
        return 0; // Fixes non zero output when scale == 0 and
                  // FASTLED_SCALE8_FIXED==1
    }
#if SCALE16BY8_C == 1
    uint16_t result;
#if FASTLED_SCALE8_FIXED == 1
    result = (((uint32_t)(i) * (1 + ((uint32_t)scale))) >> 8);
#else
    result = (i * scale) / 256;
#endif
    return result;
#elif SCALE16BY8_AVRASM == 1
#if FASTLED_SCALE8_FIXED == 1
    uint16_t result = 0;
    asm volatile(
        // result.A = HighByte( (i.A x scale) + i.A )
        "  mul %A[i], %[scale]                 \n\t"
        "  add r0, %A[i]                       \n\t"
        //   "  adc r1, [zero]                      \n\t"
        //   "  mov %A[result], r1                  \n\t"
        "  adc %A[result], r1                  \n\t"
 
        // result.A-B += i.B x scale
        "  mul %B[i], %[scale]                 \n\t"
        "  add %A[result], r0                  \n\t"
        "  adc %B[result], r1                  \n\t"
 
        // cleanup r1
        "  clr __zero_reg__                    \n\t"
 
        // result.A-B += i.B
        "  add %A[result], %B[i]               \n\t"
        "  adc %B[result], __zero_reg__        \n\t"
 
        : [result] "+r"(result)
        : [i] "r"(i), [scale] "r"(scale)
        : "r0", "r1");
    return result;
#else
    uint16_t result = 0;
    asm volatile(
        // result.A = HighByte(i.A x j )
        "  mul %A[i], %[scale]                 \n\t"
        "  mov %A[result], r1                  \n\t"
        //"  clr %B[result]                      \n\t"
 
        // result.A-B += i.B x j
        "  mul %B[i], %[scale]                 \n\t"
        "  add %A[result], r0                  \n\t"
        "  adc %B[result], r1                  \n\t"
 
        // cleanup r1
        "  clr __zero_reg__                    \n\t"
 
        : [result] "+r"(result)
        : [i] "r"(i), [scale] "r"(scale)
        : "r0", "r1");
    return result;
#endif
#else
#error "No implementation for scale16by8 available."
#endif
}

References LIB8STATIC_ALWAYS_INLINE, and scale.

Referenced by fl::__builtin_five_bit_hd_gamma_bitshift(), fl::five_bit_bitshift(), fl::five_bit_hd_gamma_function(), lerp15by8(), lerp16by8(), and PixelController< RGB_ORDER, LANES, MASK >::loadAndScale_WS2816_HD().

Here is the caller graph for this function: