remove more unused libraries

1 files changed, 0 insertions, 934 deletions

diff --git a/lib/lib8tion/lib8tion.h b/lib/lib8tion/lib8tion.h
deleted file mode 100644
index 4c770cbcb5..0000000000
--- a/lib/lib8tion/lib8tion.h
+++ /dev/null
@@ -1,934 +0,0 @@
-#ifndef __INC_LIB8TION_H
-#define __INC_LIB8TION_H
-
-/*
-
- Fast, efficient 8-bit math functions specifically
- designed for high-performance LED programming.
-
- Because of the AVR(Arduino) and ARM assembly language
- implementations provided, using these functions often
- results in smaller and faster code than the equivalent
- program using plain "C" arithmetic and logic.
-
-
- Included are:
-
-
- - Saturating unsigned 8-bit add and subtract.
-   Instead of wrapping around if an overflow occurs,
-   these routines just 'clamp' the output at a maxumum
-   of 255, or a minimum of 0.  Useful for adding pixel
-   values.  E.g., qadd8( 200, 100) = 255.
-
-     qadd8( i, j) == MIN( (i + j), 0xFF )
-     qsub8( i, j) == MAX( (i - j), 0 )
-
- - Saturating signed 8-bit ("7-bit") add.
-     qadd7( i, j) == MIN( (i + j), 0x7F)
-
-
- - Scaling (down) of unsigned 8- and 16- bit values.
-   Scaledown value is specified in 1/256ths.
-     scale8( i, sc) == (i * sc) / 256
-     scale16by8( i, sc) == (i * sc) / 256
-
-   Example: scaling a 0-255 value down into a
-   range from 0-99:
-     downscaled = scale8( originalnumber, 100);
-
-   A special version of scale8 is provided for scaling
-   LED brightness values, to make sure that they don't
-   accidentally scale down to total black at low
-   dimming levels, since that would look wrong:
-     scale8_video( i, sc) = ((i * sc) / 256) +? 1
-
-   Example: reducing an LED brightness by a
-   dimming factor:
-     new_bright = scale8_video( orig_bright, dimming);
-
-
- - Fast 8- and 16- bit unsigned random numbers.
-   Significantly faster than Arduino random(), but
-   also somewhat less random.  You can add entropy.
-     random8()       == random from 0..255
-     random8( n)     == random from 0..(N-1)
-     random8( n, m)  == random from N..(M-1)
-
-     random16()      == random from 0..65535
-     random16( n)    == random from 0..(N-1)
-     random16( n, m) == random from N..(M-1)
-
-     random16_set_seed( k)    ==  seed = k
-     random16_add_entropy( k) ==  seed += k
-
-
- - Absolute value of a signed 8-bit value.
-     abs8( i)     == abs( i)
-
-
- - 8-bit math operations which return 8-bit values.
-   These are provided mostly for completeness,
-   not particularly for performance.
-     mul8( i, j)  == (i * j) & 0xFF
-     add8( i, j)  == (i + j) & 0xFF
-     sub8( i, j)  == (i - j) & 0xFF
-
-
- - Fast 16-bit approximations of sin and cos.
-   Input angle is a uint16_t from 0-65535.
-   Output is a signed int16_t from -32767 to 32767.
-      sin16( x)  == sin( (x/32768.0) * pi) * 32767
-      cos16( x)  == cos( (x/32768.0) * pi) * 32767
-   Accurate to more than 99% in all cases.
-
- - Fast 8-bit approximations of sin and cos.
-   Input angle is a uint8_t from 0-255.
-   Output is an UNsigned uint8_t from 0 to 255.
-       sin8( x)  == (sin( (x/128.0) * pi) * 128) + 128
-       cos8( x)  == (cos( (x/128.0) * pi) * 128) + 128
-   Accurate to within about 2%.
-
-
- - Fast 8-bit "easing in/out" function.
-     ease8InOutCubic(x) == 3(x^i) - 2(x^3)
-     ease8InOutApprox(x) ==
-       faster, rougher, approximation of cubic easing
-     ease8InOutQuad(x) == quadratic (vs cubic) easing
-
- - Cubic, Quadratic, and Triangle wave functions.
-   Input is a uint8_t representing phase withing the wave,
-     similar to how sin8 takes an angle 'theta'.
-   Output is a uint8_t representing the amplitude of
-     the wave at that point.
-       cubicwave8( x)
-       quadwave8( x)
-       triwave8( x)
-
- - Square root for 16-bit integers.  About three times
-   faster and five times smaller than Arduino's built-in
-   generic 32-bit sqrt routine.
-     sqrt16( uint16_t x ) == sqrt( x)
-
- - Dimming and brightening functions for 8-bit
-   light values.
-     dim8_video( x)  == scale8_video( x, x)
-     dim8_raw( x)    == scale8( x, x)
-     dim8_lin( x)    == (x<128) ? ((x+1)/2) : scale8(x,x)
-     brighten8_video( x) == 255 - dim8_video( 255 - x)
-     brighten8_raw( x) == 255 - dim8_raw( 255 - x)
-     brighten8_lin( x) == 255 - dim8_lin( 255 - x)
-   The dimming functions in particular are suitable
-   for making LED light output appear more 'linear'.
-
-
- - Linear interpolation between two values, with the
-   fraction between them expressed as an 8- or 16-bit
-   fixed point fraction (fract8 or fract16).
-     lerp8by8(   fromU8, toU8, fract8 )
-     lerp16by8(  fromU16, toU16, fract8 )
-     lerp15by8(  fromS16, toS16, fract8 )
-       == from + (( to - from ) * fract8) / 256)
-     lerp16by16( fromU16, toU16, fract16 )
-       == from + (( to - from ) * fract16) / 65536)
-     map8( in, rangeStart, rangeEnd)
-       == map( in, 0, 255, rangeStart, rangeEnd);
-
- - Optimized memmove, memcpy, and memset, that are
-   faster than standard avr-libc 1.8.
-      memmove8( dest, src,  bytecount)
-      memcpy8(  dest, src,  bytecount)
-      memset8(  buf, value, bytecount)
-
- - Beat generators which return sine or sawtooth
-   waves in a specified number of Beats Per Minute.
-   Sine wave beat generators can specify a low and
-   high range for the output.  Sawtooth wave beat
-   generators always range 0-255 or 0-65535.
-     beatsin8( BPM, low8, high8)
-         = (sine(beatphase) * (high8-low8)) + low8
-     beatsin16( BPM, low16, high16)
-         = (sine(beatphase) * (high16-low16)) + low16
-     beatsin88( BPM88, low16, high16)
-         = (sine(beatphase) * (high16-low16)) + low16
-     beat8( BPM)  = 8-bit repeating sawtooth wave
-     beat16( BPM) = 16-bit repeating sawtooth wave
-     beat88( BPM88) = 16-bit repeating sawtooth wave
-   BPM is beats per minute in either simple form
-   e.g. 120, or Q8.8 fixed-point form.
-   BPM88 is beats per minute in ONLY Q8.8 fixed-point
-   form.
-
-Lib8tion is pronounced like 'libation': lie-BAY-shun
-
-*/
-
-
-
-#include <stdint.h>
-
-#define LIB8STATIC static inline
-#define LIB8STATIC_ALWAYS_INLINE static inline
-
-#if !defined(__AVR__)
-#include <string.h>
-// for memmove, memcpy, and memset if not defined here
-#endif
-
-#if defined(__arm__)
-
-#if defined(FASTLED_TEENSY3)
-// Can use Cortex M4 DSP instructions
-#define QADD8_C 0
-#define QADD7_C 0
-#define QADD8_ARM_DSP_ASM 1
-#define QADD7_ARM_DSP_ASM 1
-#else
-// Generic ARM
-#define QADD8_C 1
-#define QADD7_C 1
-#endif
-
-#define QSUB8_C 1
-#define SCALE8_C 1
-#define SCALE16BY8_C 1
-#define SCALE16_C 1
-#define ABS8_C 1
-#define MUL8_C 1
-#define QMUL8_C 1
-#define ADD8_C 1
-#define SUB8_C 1
-#define EASE8_C 1
-#define AVG8_C 1
-#define AVG7_C 1
-#define AVG16_C 1
-#define AVG15_C 1
-#define BLEND8_C 1
-
-
-#elif defined(__AVR__)
-
-// AVR ATmega and friends Arduino
-
-#define QADD8_C 0
-#define QADD7_C 0
-#define QSUB8_C 0
-#define ABS8_C 0
-#define ADD8_C 0
-#define SUB8_C 0
-#define AVG8_C 0
-#define AVG7_C 0
-#define AVG16_C 0
-#define AVG15_C 0
-
-#define QADD8_AVRASM 1
-#define QADD7_AVRASM 1
-#define QSUB8_AVRASM 1
-#define ABS8_AVRASM 1
-#define ADD8_AVRASM 1
-#define SUB8_AVRASM 1
-#define AVG8_AVRASM 1
-#define AVG7_AVRASM 1
-#define AVG16_AVRASM 1
-#define AVG15_AVRASM 1
-
-// Note: these require hardware MUL instruction
-//       -- sorry, ATtiny!
-#if !defined(LIB8_ATTINY)
-#define SCALE8_C 0
-#define SCALE16BY8_C 0
-#define SCALE16_C 0
-#define MUL8_C 0
-#define QMUL8_C 0
-#define EASE8_C 0
-#define BLEND8_C 0
-#define SCALE8_AVRASM 1
-#define SCALE16BY8_AVRASM 1
-#define SCALE16_AVRASM 1
-#define MUL8_AVRASM 1
-#define QMUL8_AVRASM 1
-#define EASE8_AVRASM 1
-#define CLEANUP_R1_AVRASM 1
-#define BLEND8_AVRASM 1
-#else
-// On ATtiny, we just use C implementations
-#define SCALE8_C 1
-#define SCALE16BY8_C 1
-#define SCALE16_C 1
-#define MUL8_C 1
-#define QMUL8_C 1
-#define EASE8_C 1
-#define BLEND8_C 1
-#define SCALE8_AVRASM 0
-#define SCALE16BY8_AVRASM 0
-#define SCALE16_AVRASM 0
-#define MUL8_AVRASM 0
-#define QMUL8_AVRASM 0
-#define EASE8_AVRASM 0
-#define BLEND8_AVRASM 0
-#endif
-
-#else
-
-// unspecified architecture, so
-// no ASM, everything in C
-#define QADD8_C 1
-#define QADD7_C 1
-#define QSUB8_C 1
-#define SCALE8_C 1
-#define SCALE16BY8_C 1
-#define SCALE16_C 1
-#define ABS8_C 1
-#define MUL8_C 1
-#define QMUL8_C 1
-#define ADD8_C 1
-#define SUB8_C 1
-#define EASE8_C 1
-#define AVG8_C 1
-#define AVG7_C 1
-#define AVG16_C 1
-#define AVG15_C 1
-#define BLEND8_C 1
-
-#endif
-
-///@defgroup lib8tion Fast math functions
-///A variety of functions for working with numbers.
-///@{
-
-
-///////////////////////////////////////////////////////////////////////
-//
-// typdefs for fixed-point fractional types.
-//
-// sfract7 should be interpreted as signed 128ths.
-// fract8 should be interpreted as unsigned 256ths.
-// sfract15 should be interpreted as signed 32768ths.
-// fract16 should be interpreted as unsigned 65536ths.
-//
-// Example: if a fract8 has the value "64", that should be interpreted
-//          as 64/256ths, or one-quarter.
-//
-//
-//  fract8   range is 0 to 0.99609375
-//                 in steps of 0.00390625
-//
-//  sfract7  range is -0.9921875 to 0.9921875
-//                 in steps of 0.0078125
-//
-//  fract16  range is 0 to 0.99998474121
-//                 in steps of 0.00001525878
-//
-//  sfract15 range is -0.99996948242 to 0.99996948242
-//                 in steps of 0.00003051757
-//
-
-/// ANSI unsigned short _Fract.  range is 0 to 0.99609375
-///                 in steps of 0.00390625
-typedef uint8_t   fract8;   ///< ANSI: unsigned short _Fract
-
-///  ANSI: signed short _Fract.  range is -0.9921875 to 0.9921875
-///                 in steps of 0.0078125
-typedef int8_t    sfract7;  ///< ANSI: signed   short _Fract
-
-///  ANSI: unsigned _Fract.  range is 0 to 0.99998474121
-///                 in steps of 0.00001525878
-typedef uint16_t  fract16;  ///< ANSI: unsigned       _Fract
-
-///  ANSI: signed _Fract.  range is -0.99996948242 to 0.99996948242
-///                 in steps of 0.00003051757
-typedef int16_t   sfract15; ///< ANSI: signed         _Fract
-
-
-// accumXY types should be interpreted as X bits of integer,
-//         and Y bits of fraction.
-//         E.g., accum88 has 8 bits of int, 8 bits of fraction
-
-typedef uint16_t  accum88;  ///< ANSI: unsigned short _Accum.  8 bits int, 8 bits fraction
-typedef int16_t   saccum78; ///< ANSI: signed   short _Accum.  7 bits int, 8 bits fraction
-typedef uint32_t  accum1616;///< ANSI: signed         _Accum. 16 bits int, 16 bits fraction
-typedef int32_t   saccum1516;///< ANSI: signed         _Accum. 15 bits int, 16 bits fraction
-typedef uint16_t  accum124; ///< no direct ANSI counterpart. 12 bits int, 4 bits fraction
-typedef int32_t   saccum114;///< no direct ANSI counterpart. 1 bit int, 14 bits fraction
-
-
-
-#include "math8.h"
-#include "scale8.h"
-#include "random8.h"
-#include "trig8.h"
-
-///////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-
-///////////////////////////////////////////////////////////////////////
-//
-// float-to-fixed and fixed-to-float conversions
-//
-// Note that anything involving a 'float' on AVR will be slower.
-
-/// sfract15ToFloat: conversion from sfract15 fixed point to
-///                  IEEE754 32-bit float.
-LIB8STATIC float sfract15ToFloat( sfract15 y)
-{
-    return y / 32768.0;
-}
-
-/// conversion from IEEE754 float in the range (-1,1)
-///                  to 16-bit fixed point.  Note that the extremes of
-///                  one and negative one are NOT representable.  The
-///                  representable range is basically
-LIB8STATIC sfract15 floatToSfract15( float f)
-{
-    return f * 32768.0;
-}
-
-
-
-///////////////////////////////////////////////////////////////////////
-//
-// memmove8, memcpy8, and memset8:
-//   alternatives to memmove, memcpy, and memset that are
-//   faster on AVR than standard avr-libc 1.8
-
-#if defined(__AVR__)
-void * memmove8( void * dst, const void * src, uint16_t num );
-void * memcpy8 ( void * dst, const void * src, uint16_t num )  __attribute__ ((noinline));
-void * memset8 ( void * ptr, uint8_t value, uint16_t num ) __attribute__ ((noinline)) ;
-#else
-// on non-AVR platforms, these names just call standard libc.
-#define memmove8 memmove
-#define memcpy8 memcpy
-#define memset8 memset
-#endif
-
-
-///////////////////////////////////////////////////////////////////////
-//
-// linear interpolation, such as could be used for Perlin noise, etc.
-//
-
-// A note on the structure of the lerp functions:
-// The cases for b>a and b<=a are handled separately for
-// speed: without knowing the relative order of a and b,
-// the value (a-b) might be overflow the width of a or b,
-// and have to be promoted to a wider, slower type.
-// To avoid that, we separate the two cases, and are able
-// to do all the math in the same width as the arguments,
-// which is much faster and smaller on AVR.
-
-/// linear interpolation between two unsigned 8-bit values,
-/// with 8-bit fraction
-LIB8STATIC uint8_t lerp8by8( uint8_t a, uint8_t b, fract8 frac)
-{
-    uint8_t result;
-    if( b > a) {
-        uint8_t delta = b - a;
-        uint8_t scaled = scale8( delta, frac);
-        result = a + scaled;
-    } else {
-        uint8_t delta = a - b;
-        uint8_t scaled = scale8( delta, frac);
-        result = a - scaled;
-    }
-    return result;
-}
-
-/// linear interpolation between two unsigned 16-bit values,
-/// with 16-bit fraction
-LIB8STATIC uint16_t lerp16by16( uint16_t a, uint16_t b, fract16 frac)
-{
-    uint16_t result;
-    if( b > a ) {
-        uint16_t delta = b - a;
-        uint16_t scaled = scale16(delta, frac);
-        result = a + scaled;
-    } else {
-        uint16_t delta = a - b;
-        uint16_t scaled = scale16( delta, frac);
-        result = a - scaled;
-    }
-    return result;
-}
-
-/// linear interpolation between two unsigned 16-bit values,
-/// with 8-bit fraction
-LIB8STATIC uint16_t lerp16by8( uint16_t a, uint16_t b, fract8 frac)
-{
-    uint16_t result;
-    if( b > a) {
-        uint16_t delta = b - a;
-        uint16_t scaled = scale16by8( delta, frac);
-        result = a + scaled;
-    } else {
-        uint16_t delta = a - b;
-        uint16_t scaled = scale16by8( delta, frac);
-        result = a - scaled;
-    }
-    return result;
-}
-
-/// linear interpolation between two signed 15-bit values,
-/// with 8-bit fraction
-LIB8STATIC int16_t lerp15by8( int16_t a, int16_t b, fract8 frac)
-{
-    int16_t result;
-    if( b > a) {
-        uint16_t delta = b - a;
-        uint16_t scaled = scale16by8( delta, frac);
-        result = a + scaled;
-    } else {
-        uint16_t delta = a - b;
-        uint16_t scaled = scale16by8( delta, frac);
-        result = a - scaled;
-    }
-    return result;
-}
-
-/// linear interpolation between two signed 15-bit values,
-/// with 8-bit fraction
-LIB8STATIC int16_t lerp15by16( int16_t a, int16_t b, fract16 frac)
-{
-    int16_t result;
-    if( b > a) {
-        uint16_t delta = b - a;
-        uint16_t scaled = scale16( delta, frac);
-        result = a + scaled;
-    } else {
-        uint16_t delta = a - b;
-        uint16_t scaled = scale16( delta, frac);
-        result = a - scaled;
-    }
-    return result;
-}
-
-///  map8: map from one full-range 8-bit value into a narrower
-/// range of 8-bit values, possibly a range of hues.
-///
-/// E.g. map myValue into a hue in the range blue..purple..pink..red
-/// hue = map8( myValue, HUE_BLUE, HUE_RED);
-///
-/// Combines nicely with the waveform functions (like sin8, etc)
-/// to produce continuous hue gradients back and forth:
-///
-///          hue = map8( sin8( myValue), HUE_BLUE, HUE_RED);
-///
-/// Mathematically simiar to lerp8by8, but arguments are more
-/// like Arduino's "map"; this function is similar to
-///
-///          map( in, 0, 255, rangeStart, rangeEnd)
-///
-/// but faster and specifically designed for 8-bit values.
-LIB8STATIC uint8_t map8( uint8_t in, uint8_t rangeStart, uint8_t rangeEnd)
-{
-    uint8_t rangeWidth = rangeEnd - rangeStart;
-    uint8_t out = scale8( in, rangeWidth);
-    out += rangeStart;
-    return out;
-}
-
-
-///////////////////////////////////////////////////////////////////////
-//
-// easing functions; see http://easings.net
-//
-
-/// ease8InOutQuad: 8-bit quadratic ease-in / ease-out function
-///                Takes around 13 cycles on AVR
-#if EASE8_C == 1
-LIB8STATIC uint8_t ease8InOutQuad( uint8_t i)
-{
-    uint8_t j = i;
-    if( j & 0x80 ) {
-        j = 255 - j;
-    }
-    uint8_t jj  = scale8(  j, j);
-    uint8_t jj2 = jj << 1;
-    if( i & 0x80 ) {
-        jj2 = 255 - jj2;
-    }
-    return jj2;
-}
-
-#elif EASE8_AVRASM == 1
-// This AVR asm version of ease8InOutQuad preserves one more
-// low-bit of precision than the C version, and is also slightly
-// smaller and faster.
-LIB8STATIC uint8_t ease8InOutQuad(uint8_t val) {
-    uint8_t j=val;
-    asm volatile (
-      "sbrc %[val], 7 \n"
-      "com %[j]       \n"
-      "mul %[j], %[j] \n"
-      "add r0, %[j]   \n"
-      "ldi %[j], 0    \n"
-      "adc %[j], r1   \n"
-      "lsl r0         \n" // carry = high bit of low byte of mul product
-      "rol %[j]       \n" // j = (j * 2) + carry // preserve add'l bit of precision
-      "sbrc %[val], 7 \n"
-      "com %[j]       \n"
-      "clr __zero_reg__   \n"
-      : [j] "+&a" (j)
-      : [val] "a" (val)
-      : "r0", "r1"
-      );
-    return j;
-}
-
-#else
-#error "No implementation for ease8InOutQuad available."
-#endif
-
-/// ease16InOutQuad: 16-bit quadratic ease-in / ease-out function
-// C implementation at this point
-LIB8STATIC uint16_t ease16InOutQuad( uint16_t i)
-{
-    uint16_t j = i;
-    if( j & 0x8000 ) {
-        j = 65535 - j;
-    }
-    uint16_t jj  = scale16( j, j);
-    uint16_t jj2 = jj << 1;
-    if( i & 0x8000 ) {
-        jj2 = 65535 - jj2;
-    }
-    return jj2;
-}
-
-
-/// ease8InOutCubic: 8-bit cubic ease-in / ease-out function
-///                 Takes around 18 cycles on AVR
-LIB8STATIC fract8 ease8InOutCubic( fract8 i)
-{
-    uint8_t ii  = scale8_LEAVING_R1_DIRTY(  i, i);
-    uint8_t iii = scale8_LEAVING_R1_DIRTY( ii, i);
-
-    uint16_t r1 = (3 * (uint16_t)(ii)) - ( 2 * (uint16_t)(iii));
-
-    /* the code generated for the above *'s automatically
-       cleans up R1, so there's no need to explicitily call
-       cleanup_R1(); */
-
-    uint8_t result = r1;
-
-    // if we got "256", return 255:
-    if( r1 & 0x100 ) {
-        result = 255;
-    }
-    return result;
-}
-
-/// ease8InOutApprox: fast, rough 8-bit ease-in/ease-out function
-///                   shaped approximately like 'ease8InOutCubic',
-///                   it's never off by more than a couple of percent
-///                   from the actual cubic S-curve, and it executes
-///                   more than twice as fast.  Use when the cycles
-///                   are more important than visual smoothness.
-///                   Asm version takes around 7 cycles on AVR.
-
-#if EASE8_C == 1
-LIB8STATIC fract8 ease8InOutApprox( fract8 i)
-{
-    if( i < 64) {
-        // start with slope 0.5
-        i /= 2;
-    } else if( i > (255 - 64)) {
-        // end with slope 0.5
-        i = 255 - i;
-        i /= 2;
-        i = 255 - i;
-    } else {
-        // in the middle, use slope 192/128 = 1.5
-        i -= 64;
-        i += (i / 2);
-        i += 32;
-    }
-
-    return i;
-}
-
-#elif EASE8_AVRASM == 1
-LIB8STATIC uint8_t ease8InOutApprox( fract8 i)
-{
-    // takes around 7 cycles on AVR
-    asm volatile (
-        "  subi %[i], 64         \n\t"
-        "  cpi  %[i], 128        \n\t"
-        "  brcc Lshift_%=        \n\t"
-
-        // middle case
-        "  mov __tmp_reg__, %[i] \n\t"
-        "  lsr __tmp_reg__       \n\t"
-        "  add %[i], __tmp_reg__ \n\t"
-        "  subi %[i], 224        \n\t"
-        "  rjmp Ldone_%=         \n\t"
-
-        // start or end case
-        "Lshift_%=:              \n\t"
-        "  lsr %[i]              \n\t"
-        "  subi %[i], 96         \n\t"
-
-        "Ldone_%=:               \n\t"
-
-        : [i] "+&a" (i)
-        :
-        : "r0", "r1"
-        );
-    return i;
-}
-#else
-#error "No implementation for ease8 available."
-#endif
-
-
-
-/// triwave8: triangle (sawtooth) wave generator.  Useful for
-///           turning a one-byte ever-increasing value into a
-///           one-byte value that oscillates up and down.
-///
-///           input         output
-///           0..127        0..254 (positive slope)
-///           128..255      254..0 (negative slope)
-///
-/// On AVR this function takes just three cycles.
-///
-LIB8STATIC uint8_t triwave8(uint8_t in)
-{
-    if( in & 0x80) {
-        in = 255 - in;
-    }
-    uint8_t out = in << 1;
-    return out;
-}
-
-
-// quadwave8 and cubicwave8: S-shaped wave generators (like 'sine').
-//           Useful for turning a one-byte 'counter' value into a
-//           one-byte oscillating value that moves smoothly up and down,
-//           with an 'acceleration' and 'deceleration' curve.
-//
-//           These are even faster than 'sin8', and have
-//           slightly different curve shapes.
-//
-
-/// quadwave8: quadratic waveform generator.  Spends just a little more
-///            time at the limits than 'sine' does.
-LIB8STATIC uint8_t quadwave8(uint8_t in)
-{
-    return ease8InOutQuad( triwave8( in));
-}
-
-/// cubicwave8: cubic waveform generator.  Spends visibly more time
-///             at the limits than 'sine' does.
-LIB8STATIC uint8_t cubicwave8(uint8_t in)
-{
-    return ease8InOutCubic( triwave8( in));
-}
-
-/// squarewave8: square wave generator.  Useful for
-///           turning a one-byte ever-increasing value
-///           into a one-byte value that is either 0 or 255.
-///           The width of the output 'pulse' is
-///           determined by the pulsewidth argument:
-///
-///~~~
-///           If pulsewidth is 255, output is always 255.
-///           If pulsewidth < 255, then
-///             if input < pulsewidth  then output is 255
-///             if input >= pulsewidth then output is 0
-///~~~
-///
-/// the output looking like:
-///
-///~~~
-///     255   +--pulsewidth--+
-///      .    |              |
-///      0    0              +--------(256-pulsewidth)--------
-///~~~
-///
-/// @param in
-/// @param pulsewidth
-/// @returns square wave output
-LIB8STATIC uint8_t squarewave8( uint8_t in, uint8_t pulsewidth)
-{
-    if( in < pulsewidth || (pulsewidth == 255)) {
-        return 255;
-    } else {
-        return 0;
-    }
-}
-
-
-// Beat generators - These functions produce waves at a given
-//                   number of 'beats per minute'.  Internally, they use
-//                   the Arduino function 'millis' to track elapsed time.
-//                   Accuracy is a bit better than one part in a thousand.
-//
-//       beat8( BPM ) returns an 8-bit value that cycles 'BPM' times
-//                    per minute, rising from 0 to 255, resetting to zero,
-//                    rising up again, etc..  The output of this function
-//                    is suitable for feeding directly into sin8, and cos8,
-//                    triwave8, quadwave8, and cubicwave8.
-//       beat16( BPM ) returns a 16-bit value that cycles 'BPM' times
-//                    per minute, rising from 0 to 65535, resetting to zero,
-//                    rising up again, etc.  The output of this function is
-//                    suitable for feeding directly into sin16 and cos16.
-//       beat88( BPM88) is the same as beat16, except that the BPM88 argument
-//                    MUST be in Q8.8 fixed point format, e.g. 120BPM must
-//                    be specified as 120*256 = 30720.
-//       beatsin8( BPM, uint8_t low, uint8_t high) returns an 8-bit value that
-//                    rises and falls in a sine wave, 'BPM' times per minute,
-//                    between the values of 'low' and 'high'.
-//       beatsin16( BPM, uint16_t low, uint16_t high) returns a 16-bit value
-//                    that rises and falls in a sine wave, 'BPM' times per
-//                    minute, between the values of 'low' and 'high'.
-//       beatsin88( BPM88, ...) is the same as beatsin16, except that the
-//                    BPM88 argument MUST be in Q8.8 fixed point format,
-//                    e.g. 120BPM must be specified as 120*256 = 30720.
-//
-//  BPM can be supplied two ways.  The simpler way of specifying BPM is as
-//  a simple 8-bit integer from 1-255, (e.g., "120").
-//  The more sophisticated way of specifying BPM allows for fractional
-//  "Q8.8" fixed point number (an 'accum88') with an 8-bit integer part and
-//  an 8-bit fractional part.  The easiest way to construct this is to multiply
-//  a floating point BPM value (e.g. 120.3) by 256, (e.g. resulting in 30796
-//  in this case), and pass that as the 16-bit BPM argument.
-//  "BPM88" MUST always be specified in Q8.8 format.
-//
-//  Originally designed to make an entire animation project pulse with brightness.
-//  For that effect, add this line just above your existing call to "FastLED.show()":
-//
-//     uint8_t bright = beatsin8( 60 /*BPM*/, 192 /*dimmest*/, 255 /*brightest*/ ));
-//     FastLED.setBrightness( bright );
-//     FastLED.show();
-//
-//  The entire animation will now pulse between brightness 192 and 255 once per second.
-
-
-// The beat generators need access to a millisecond counter.
-// On Arduino, this is "millis()".  On other platforms, you'll
-// need to provide a function with this signature:
-//   uint32_t get_millisecond_timer();
-// that provides similar functionality.
-// You can also force use of the get_millisecond_timer function
-// by #defining USE_GET_MILLISECOND_TIMER.
-#if (defined(ARDUINO) || defined(SPARK) || defined(FASTLED_HAS_MILLIS)) && !defined(USE_GET_MILLISECOND_TIMER)
-// Forward declaration of Arduino function 'millis'.
-//uint32_t millis();
-#define GET_MILLIS millis
-#else
-uint32_t get_millisecond_timer(void);
-#define GET_MILLIS get_millisecond_timer
-#endif
-
-// beat16 generates a 16-bit 'sawtooth' wave at a given BPM,
-///        with BPM specified in Q8.8 fixed-point format; e.g.
-///        for this function, 120 BPM MUST BE specified as
-///        120*256 = 30720.
-///        If you just want to specify "120", use beat16 or beat8.
-LIB8STATIC uint16_t beat88( accum88 beats_per_minute_88, uint32_t timebase)
-{
-    // BPM is 'beats per minute', or 'beats per 60000ms'.
-    // To avoid using the (slower) division operator, we
-    // want to convert 'beats per 60000ms' to 'beats per 65536ms',
-    // and then use a simple, fast bit-shift to divide by 65536.
-    //
-    // The ratio 65536:60000 is 279.620266667:256; we'll call it 280:256.
-    // The conversion is accurate to about 0.05%, more or less,
-    // e.g. if you ask for "120 BPM", you'll get about "119.93".
-    return (((GET_MILLIS()) - timebase) * beats_per_minute_88 * 280) >> 16;
-}
-
-/// beat16 generates a 16-bit 'sawtooth' wave at a given BPM
-LIB8STATIC uint16_t beat16( accum88 beats_per_minute, uint32_t timebase)
-{
-    // Convert simple 8-bit BPM's to full Q8.8 accum88's if needed
-    if( beats_per_minute < 256) beats_per_minute <<= 8;
-    return beat88(beats_per_minute, timebase);
-}
-
-/// beat8 generates an 8-bit 'sawtooth' wave at a given BPM
-LIB8STATIC uint8_t beat8( accum88 beats_per_minute, uint32_t timebase)
-{
-    return beat16( beats_per_minute, timebase) >> 8;
-}
-
-/// beatsin88 generates a 16-bit sine wave at a given BPM,
-///           that oscillates within a given range.
-///           For this function, BPM MUST BE SPECIFIED as
-///           a Q8.8 fixed-point value; e.g. 120BPM must be
-///           specified as 120*256 = 30720.
-///           If you just want to specify "120", use beatsin16 or beatsin8.
-LIB8STATIC uint16_t beatsin88( accum88 beats_per_minute_88, uint16_t lowest, uint16_t highest, uint32_t timebase, uint16_t phase_offset)
-{
-    uint16_t beat = beat88( beats_per_minute_88, timebase);
-    uint16_t beatsin = (sin16( beat + phase_offset) + 32768);
-    uint16_t rangewidth = highest - lowest;
-    uint16_t scaledbeat = scale16( beatsin, rangewidth);
-    uint16_t result = lowest + scaledbeat;
-    return result;
-}
-
-/// beatsin16 generates a 16-bit sine wave at a given BPM,
-///           that oscillates within a given range.
-LIB8STATIC uint16_t beatsin16(accum88 beats_per_minute, uint16_t lowest, uint16_t highest, uint32_t timebase, uint16_t phase_offset)
-{
-    uint16_t beat = beat16( beats_per_minute, timebase);
-    uint16_t beatsin = (sin16( beat + phase_offset) + 32768);
-    uint16_t rangewidth = highest - lowest;
-    uint16_t scaledbeat = scale16( beatsin, rangewidth);
-    uint16_t result = lowest + scaledbeat;
-    return result;
-}
-
-/// beatsin8 generates an 8-bit sine wave at a given BPM,
-///           that oscillates within a given range.
-LIB8STATIC uint8_t beatsin8( accum88 beats_per_minute, uint8_t lowest, uint8_t highest, uint32_t timebase, uint8_t phase_offset)
-{
-    uint8_t beat = beat8( beats_per_minute, timebase);
-    uint8_t beatsin = sin8( beat + phase_offset);
-    uint8_t rangewidth = highest - lowest;
-    uint8_t scaledbeat = scale8( beatsin, rangewidth);
-    uint8_t result = lowest + scaledbeat;
-    return result;
-}
-
-
-/// Return the current seconds since boot in a 16-bit value.  Used as part of the
-/// "every N time-periods" mechanism
-LIB8STATIC uint16_t seconds16(void)
-{
-    uint32_t ms = GET_MILLIS();
-    uint16_t s16;
-    s16 = ms / 1000;
-    return s16;
-}
-
-/// Return the current minutes since boot in a 16-bit value.  Used as part of the
-/// "every N time-periods" mechanism
-LIB8STATIC uint16_t minutes16(void)
-{
-    uint32_t ms = GET_MILLIS();
-    uint16_t m16;
-    m16 = (ms / (60000L)) & 0xFFFF;
-    return m16;
-}
-
-/// Return the current hours since boot in an 8-bit value.  Used as part of the
-/// "every N time-periods" mechanism
-LIB8STATIC uint8_t hours8(void)
-{
-    uint32_t ms = GET_MILLIS();
-    uint8_t h8;
-    h8 = (ms / (3600000L)) & 0xFF;
-    return h8;
-}
-
-///@}
-
-#endif