scale16()

LIB8STATIC uint16_t scale16	(	uint16_t	i,
		fract16	scale )

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

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

Parameters

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

Returns

scaled value

Examples

Pacifica.ino.

Definition at line 540 of file scale8.h.

                                                       {
#if SCALE16_C == 1
    uint16_t result;
#if FASTLED_SCALE8_FIXED == 1
    result = ((uint32_t)(i) * (1 + (uint32_t)(scale))) / 65536;
#else
    result = ((uint32_t)(i) * (uint32_t)(scale)) / 65536;
#endif
    return result;
#elif SCALE16_AVRASM == 1
#if FASTLED_SCALE8_FIXED == 1
    // implemented sort of like
    //   result = ((i * scale) + i ) / 65536
    //
    // why not like this, you may ask?
    //   result = (i * (scale+1)) / 65536
    // the answer is that if scale is 65535, then scale+1
    // will be zero, which is not what we want.
    uint32_t result;
    asm volatile(
        // result.A-B  = i.A x scale.A
        "  mul %A[i], %A[scale]                 \n\t"
        //  save results...
        // basic idea:
        //"  mov %A[result], r0                 \n\t"
        //"  mov %B[result], r1                 \n\t"
        // which can be written as...
        "  movw %A[result], r0                   \n\t"
        // Because we're going to add i.A-B to
        // result.A-D, we DO need to keep both
        // the r0 and r1 portions of the product
        // UNlike in the 'unfixed scale8' version.
        // So the movw here is needed.
        : [result] "=r"(result)
        : [i] "r"(i), [scale] "r"(scale)
        : "r0", "r1");
 
    asm volatile(
        // result.C-D  = i.B x scale.B
        "  mul %B[i], %B[scale]                 \n\t"
        //"  mov %C[result], r0                 \n\t"
        //"  mov %D[result], r1                 \n\t"
        "  movw %C[result], r0                   \n\t"
        : [result] "+r"(result)
        : [i] "r"(i), [scale] "r"(scale)
        : "r0", "r1");
 
    const uint8_t zero = 0;
    asm volatile(
        // result.B-D += i.B x scale.A
        "  mul %B[i], %A[scale]                 \n\t"
 
        "  add %B[result], r0                   \n\t"
        "  adc %C[result], r1                   \n\t"
        "  adc %D[result], %[zero]              \n\t"
 
        // result.B-D += i.A x scale.B
        "  mul %A[i], %B[scale]                 \n\t"
 
        "  add %B[result], r0                   \n\t"
        "  adc %C[result], r1                   \n\t"
        "  adc %D[result], %[zero]              \n\t"
 
        // cleanup r1
        "  clr r1                               \n\t"
 
        : [result] "+r"(result)
        : [i] "r"(i), [scale] "r"(scale), [zero] "r"(zero)
        : "r0", "r1");
 
    asm volatile(
        // result.A-D += i.A-B
        "  add %A[result], %A[i]                \n\t"
        "  adc %B[result], %B[i]                \n\t"
        "  adc %C[result], %[zero]              \n\t"
        "  adc %D[result], %[zero]              \n\t"
        : [result] "+r"(result)
        : [i] "r"(i), [zero] "r"(zero));
 
    result = result >> 16;
    return result;
#else
    uint32_t result;
    asm volatile(
        // result.A-B  = i.A x scale.A
        "  mul %A[i], %A[scale]                 \n\t"
        //  save results...
        // basic idea:
        //"  mov %A[result], r0                 \n\t"
        //"  mov %B[result], r1                 \n\t"
        // which can be written as...
        "  movw %A[result], r0                   \n\t"
        // We actually don't need to do anything with r0,
        // as result.A is never used again here, so we
        // could just move the high byte, but movw is
        // one clock cycle, just like mov, so might as
        // well, in case we want to use this code for
        // a generic 16x16 multiply somewhere.
 
        : [result] "=r"(result)
        : [i] "r"(i), [scale] "r"(scale)
        : "r0", "r1");
 
    asm volatile(
        // result.C-D  = i.B x scale.B
        "  mul %B[i], %B[scale]                 \n\t"
        //"  mov %C[result], r0                 \n\t"
        //"  mov %D[result], r1                 \n\t"
        "  movw %C[result], r0                   \n\t"
        : [result] "+r"(result)
        : [i] "r"(i), [scale] "r"(scale)
        : "r0", "r1");
 
    const uint8_t zero = 0;
    asm volatile(
        // result.B-D += i.B x scale.A
        "  mul %B[i], %A[scale]                 \n\t"
 
        "  add %B[result], r0                   \n\t"
        "  adc %C[result], r1                   \n\t"
        "  adc %D[result], %[zero]              \n\t"
 
        // result.B-D += i.A x scale.B
        "  mul %A[i], %B[scale]                 \n\t"
 
        "  add %B[result], r0                   \n\t"
        "  adc %C[result], r1                   \n\t"
        "  adc %D[result], %[zero]              \n\t"
 
        // cleanup r1
        "  clr r1                               \n\t"
 
        : [result] "+r"(result)
        : [i] "r"(i), [scale] "r"(scale), [zero] "r"(zero)
        : "r0", "r1");
 
    result = result >> 16;
    return result;
#endif
#else
#error "No implementation for scale16 available."
#endif
}

References LIB8STATIC, and scale.

Referenced by beatsin16(), beatsin88(), ease16InOutQuad(), fill_raw_2dnoise16(), lerp15by16(), lerp16by16(), fl::Pacifica::pacifica_one_layer(), and pacifica_one_layer().

Here is the caller graph for this function: