scale8()

LIB8STATIC_ALWAYS_INLINE uint8_t scale8	(	uint8_t	i,
		fract8	scale )

Scale one byte by a second one, 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

Note

Takes 4 clocks on AVR with MUL, 2 clocks on ARM

Examples

Fire2012WithPalette.ino, NoisePlusPalette.ino, Pacifica.ino, and XYMatrix.ino.

Definition at line 40 of file scale8.h.

                                                                 {
#if SCALE8_C == 1
#if (FASTLED_SCALE8_FIXED == 1)
    return (((uint16_t)i) * (1 + (uint16_t)(scale))) >> 8;
#else
    return ((uint16_t)i * (uint16_t)(scale)) >> 8;
#endif
#elif SCALE8_AVRASM == 1
#if defined(LIB8_ATTINY)
#if (FASTLED_SCALE8_FIXED == 1)
    uint8_t work = i;
#else
    uint8_t work = 0;
#endif
    uint8_t cnt = 0x80;
    asm volatile(
#if (FASTLED_SCALE8_FIXED == 1)
        "  inc %[scale]                 \n\t"
        "  breq DONE_%=                 \n\t"
        "  clr %[work]                  \n\t"
#endif
        "LOOP_%=:                       \n\t"
        /*"  sbrc %[scale], 0             \n\t"
        "  add %[work], %[i]            \n\t"
        "  ror %[work]                  \n\t"
        "  lsr %[scale]                 \n\t"
        "  clc                          \n\t"*/
        "  sbrc %[scale], 0             \n\t"
        "  add %[work], %[i]            \n\t"
        "  ror %[work]                  \n\t"
        "  lsr %[scale]                 \n\t"
        "  lsr %[cnt]                   \n\t"
        "brcc LOOP_%=                   \n\t"
        "DONE_%=:                       \n\t"
        : [work] "+r"(work), [cnt] "+r"(cnt)
        : [scale] "r"(scale), [i] "r"(i)
        :);
    return work;
#else
    asm volatile(
#if (FASTLED_SCALE8_FIXED == 1)
        // Multiply 8-bit i * 8-bit scale, giving 16-bit r1,r0
        "mul %0, %1          \n\t"
        // Add i to r0, possibly setting the carry flag
        "add r0, %0         \n\t"
        // load the immediate 0 into i (note, this does _not_ touch any flags)
        "ldi %0, 0x00       \n\t"
        // walk and chew gum at the same time
        "adc %0, r1          \n\t"
#else
        /* Multiply 8-bit i * 8-bit scale, giving 16-bit r1,r0 */
        "mul %0, %1          \n\t"
        /* Move the high 8-bits of the product (r1) back to i */
        "mov %0, r1          \n\t"
    /* Restore r1 to "0"; it's expected to always be that */
#endif
        "clr __zero_reg__    \n\t"
 
        : "+d"(i)    /* writes to i; r16-r31, restricted by ldi */
        : "r"(scale) /* uses scale */
        : "r0", "r1" /* clobbers r0, r1 */
    );
    /* Return the result */
    return i;
#endif
#else
#error "No implementation for scale8 available."
#endif
}

References LIB8STATIC_ALWAYS_INLINE, and scale.

Referenced by DATA_NOP::adjust(), beatsin8(), brighten8_lin(), brighten8_raw(), fl::ColorFromPalette(), fl::ColorFromPalette(), dim8_lin(), dim8_raw(), fl::Fire2012::draw(), ease8InOutQuad(), fl::fadeUsingColor(), fill_raw_2dnoise16into8(), fill_raw_2dnoise8(), fillnoise8(), fl::NoisePalette::fillnoise8(), Fire2012WithPalette(), Fire2023(), hsv2rgb_rainbow(), hsv2rgb_spectrum(), PixelController< RGB_ORDER, LANES, MASK >::init_binary_dithering(), lerp7by8(), lerp8by8(), PixelController< RGB_ORDER, LANES, MASK >::loadAndScale(), PixelController< RGB_ORDER, LANES, MASK >::loadAndScale(), loop(), map8(), fl::nblend(), fl::Pacifica::pacifica_add_whitecaps(), pacifica_add_whitecaps(), fl::Pacifica::pacifica_deepen_colors(), pacifica_deepen_colors(), rgb2hsv_approximate(), rgb_2_rgbw_exact(), rgb_2_rgbw_max_brightness(), rgb_2_rgbw_null_white_pixel(), rgb_2_rgbw_white_boosted(), PixelController< RGB_ORDER, LANES, MASK >::scale(), and PixelController< RGB_ORDER, LANES, MASK >::scale().

Here is the caller graph for this function: