klang.h

#pragma once
 
#include <stdio.h>
#include <stdlib.h>
#include <cmath>
#include <limits>
#include <assert.h>
#include <array>
#include <memory>
#include <vector>
#include <string>
#include <cstdarg>
#include <algorithm>
#include <type_traits>
#include <mutex>
#include <functional>
 
#include <float.h>
 
#ifdef __wasm__
#define THREAD_LOCAL
static inline float _sqrt(float x) { return __builtin_sqrtf(x); }
static inline float _abs(float x) { return __builtin_fabsf(x); }
#define SQRT _sqrt
#define SQRTF _sqrt
#define ABS _abs
#define FABS _abs
#endif
#ifdef __APPLE__
#define THREAD_LOCAL
#define SQRT ::sqrt
#define SQRTF ::sqrtf
#define ABS ::abs
#define FABS ::fabsf
#endif
#if defined(__WIN32__) || defined(WIN32)
#define THREAD_LOCAL thread_local
#define SQRT ::sqrt
#define SQRTF ::sqrtf
#define ABS ::abs
#define FABS ::fabsf
#endif
 
#if defined(DEBUG) || defined(_DEBUG)
  #define KLANG_DEBUG 1
#else
  #define KLANG_DEBUG 0
#endif
 
#ifndef GRAPH_SIZE
#define GRAPH_SIZE 44100
#endif
 
#define GRAPH_SERIES 4
 
// provide access to original math functions through std:: prefix
namespace std {
  namespace klang {
    template<typename TYPE> TYPE sqrt(TYPE x) { return SQRT(x); }
    template<typename TYPE> TYPE abs(TYPE x) { return ABS(x); }
  }
};
 
#define IS_SIMPLE_TYPE(type)
  static_assert(!std::is_polymorphic_v<type>, "signal has virtual table");
  static_assert(!std::has_virtual_destructor_v<type>, "signal has virtual destructor");
  static_assert(std::is_trivially_copyable_v<type>, "signal is not trivially copyable");
  static_assert(std::is_trivially_copy_assignable_v<type>, "signal is not trivially copy assignable");
  static_assert(std::is_trivially_copy_constructible_v<type>, "signal is not trivially copy assignable");
  static_assert(std::is_trivially_destructible_v<type>, "signal is not trivially copy assignable");
  static_assert(std::is_trivially_move_assignable_v<type>, "signal is not trivially copy assignable");
  static_assert(std::is_trivially_move_constructible_v<type>, "signal is not trivially copy assignable");
 
namespace klang {
 
    /// Klang language version (major.minor.build.debug)
  struct Version {
    unsigned char major, minor, build, extra;
    bool isDebug() const { return extra & 1; } }
  static constexpr version = { 0, 7, 0, KLANG_DEBUG };
 
    /// Klang mode identifiers (e.g. averages, level following)
  enum Mode { Peak, RMS, Mean };
 
  #define DENORMALISE 1.175494e-38f
 
    /// Constant scalar (pre-converted to double, float and int).
  struct constant {
 
        /// Create a constant from the given value.
    constexpr constant(double value) noexcept
      : d(value), f(static_cast<float>(value)), i(static_cast<int>(value)), inv(value == 0.0f ? 0.0f : static_cast<float>(1.0 / value)) { }
 
    const double d; //!< Constant as double
    const float f; //!< Constant as float
    const int i; //!< Constant as integer
    const float inv; //!< Inverse of constant
 
    constexpr operator float() const noexcept { return f; }
 
        /// Constant raised to the power, x.
    float operator^(float x) const { return std::pow(f, x); }
    float operator^(int x) const { return static_cast<float>(std::pow(d, x)); }
    float operator^(double x) const { return static_cast<float>(std::pow(d, x)); }
  };
 
  #define CONSTANT constexpr constant
 
#if __cplusplus == 201703L
  #pragma warning(disable:4996) // disable deprecated warning
    /// @internal
  template <typename T>
  inline constexpr bool is_literal = std::is_literal_type_v<T>;
#else
    /// @internal
  template <typename T>
  inline constexpr bool is_literal = std::is_trivially_constructible_v<T> && std::is_trivially_copyable_v<T> && std::is_trivially_destructible_v<T>;
#endif
    /// @internal
  template<typename Base, typename Derived>
  constexpr bool is_derived_from() {
    return std::is_base_of_v<Base, Derived>;
  }
    /// @internal
  template<typename Head, typename... Tail>
  constexpr bool are_scalars(Head&& head, Tail&&... tail) {
    using T = std::decay_t<decltype(head)>;
    return std::is_scalar_v<T> && ((sizeof... (Tail)) == 0 || are_scalars(std::forward<decltype(tail)>(tail)...));
  }
    /// @internal
  template <typename BASE, int EXP>
  inline constexpr BASE poweri(BASE base) {
    BASE result = 1;
    constexpr bool negative = EXP < 0;
    int exp = negative ? -EXP : EXP;
    while (exp > 0) {
      if (exp % 2 == 1)
        result *= base;
      base *= base;
      exp >>= 1;
    }
    return negative ? 1 / result : result;
  }
    /// @internal
  template <typename BASE, typename EXP>
  using power_t = typename std::conditional_t<std::is_integral_v<BASE>, float, BASE>;
 
    /// Raise @a base to the power @a exp.
  template <typename BASE, typename EXP, std::enable_if_t < is_literal<EXP>, bool>>
  inline constexpr power_t<BASE, EXP> power(BASE base, EXP exp) {
    if constexpr (std::is_integral_v<EXP>) {
      switch (exp) {
      case 0:  return (BASE)1;
      case 1:  return base;
      case 2:  return base * base;
      case 3:  return base * base * base;
      case 4:  return base * base * base * base;
      case -1: return (BASE)1 / base;
      case -2: return (BASE)1 / (base * base);
      case -3: return (BASE)1 / (base * base * base);
      case -4: return (BASE)1 / (base * base * base * base);
      default:
        return poweri<BASE, exp>(base);
      }
    } else if constexpr (std::is_floating_point_v<EXP>) {
      if constexpr (exp == (EXP)0)     return 1;
      else if constexpr (exp == (EXP)1)  return base;
      else if constexpr (exp == (EXP)2)  return base * base;
      else if constexpr (exp == (EXP)3)  return base * base * base;
      else if constexpr (exp == (EXP)4)  return base * base * base * base;
      else if constexpr (exp == (EXP)-1) return 1 / base;
      else if constexpr (exp == (EXP)-2) return 1 / (base * base);
      else if constexpr (exp == (EXP)-3) return 1 / (base * base * base);
      else if constexpr (exp == (EXP)-4) return 1 / (base * base * base * base);
    }
    return (BASE)std::pow(base, exp);;
  }
 
    /// Raise @a base to the power @a exp.
  template <typename BASE, typename EXP>
  inline constexpr power_t<BASE, EXP> power(BASE base, EXP exp) {
    if constexpr (std::is_integral_v<BASE>) {
      return power(float(base), exp);
    } else if constexpr (std::is_integral_v<EXP>) {
      switch (exp) {
      case 0:  return (BASE)1;
      case 1:  return base;
      case 2:  return base * base;
      case 3:  return base * base * base;
      case 4:  return base * base * base * base;
      case -1: return (BASE)1 / base;
      case -2: return (BASE)1 / (base * base);
      case -3: return (BASE)1 / (base * base * base);
      case -4: return (BASE)1 / (base * base * base * base);
      }
    } else if constexpr (std::is_floating_point_v<EXP>) {
      if (base == (BASE)10)  return (power_t<BASE, EXP>)::exp(exp * (EXP)2.3025850929940456840179914546843642076011014886287729760333279009);
      else if (exp == (EXP)0)  return (power_t<BASE, EXP>)1;
      else if (exp == (EXP)1)  return base;
      else if (exp == (EXP)2)  return base * base;
      else if (exp == (EXP)3)  return base * base * base;
      else if (exp == (EXP)4)  return base * base * base * base;
      else if (exp == (EXP)-1) return (power_t<BASE, EXP>)1 / base;
      else if (exp == (EXP)-2) return (power_t<BASE, EXP>)1 / (base * base);
      else if (exp == (EXP)-3) return (power_t<BASE, EXP>)1 / (base * base * base);
      else if (exp == (EXP)-4) return (power_t<BASE, EXP>)1 / (base * base * base * base);
    }
    return power_t<BASE, EXP>(std::pow(base, exp));
  }
 
    /// Return the minimum of two values.
  template<typename TYPE1, typename TYPE2> inline TYPE1 min(TYPE1 a, TYPE2 b) { return a < b ? a : (TYPE1)b; };
 
    /// Return the minimum of two values.
  template<typename TYPE1, typename TYPE2> inline TYPE1 max(TYPE1 a, TYPE2 b) { return a > b ? a : (TYPE1)b; };
 
    /// The mathematical constant, pi (and it's inverse).
  constexpr constant pi =    { 3.1415926535897932384626433832795 };
 
    /// The natural logorithm of 2 (and it's inverse).
  constexpr constant ln2 =   { 0.6931471805599453094172321214581 };
 
    /// The square root of 2 (and it's inverse).
  constexpr constant root2 = { 1.4142135623730950488016887242097 };
 
    /// Generates a random number between min and max. Use an integer types for whole numbers.
  template<typename TYPE>
  inline static TYPE random(const TYPE min, const TYPE max) { return rand() * ((max - min) / (TYPE)RAND_MAX) + min; }
 
    /// Set the random seed (to allow repeatable random generation).
  inline static void random(const unsigned int seed) { srand(seed); }
 
    /// A function that handles an event.
  typedef void event;
 
    /// Variable-sized array, pre-allocated to a max. capacity.
  template<typename TYPE, int CAPACITY>
  struct Array {
    TYPE items[CAPACITY];
    unsigned int count = 0;
 
        /// The maximum capacity of the array.
    static int capacity() { return CAPACITY; }
 
        /// The current number of items in the array.
    unsigned int size() const { return count; }
 
        /// Add the specified item to the end of the array.
    void add(const TYPE& item) {
      if(count < CAPACITY)
        items[count++] = item;
    }
 
        /// Add a blank item to the end of the array, returning a pointer that allows the item to be modified.
    TYPE* add() {
      if (count < CAPACITY)
        return &items[count++];
      return nullptr;
    }
 
        /// Clear the array contents. Only resets the item count, without wiping memory.
    void clear() { count = 0; }
 
        /// Find the maximum value in the array.
    float max() const {
      float max = 0.f;
      for (unsigned int i = 0; i < count; i++)
        if (abs(items[i]) > max)
          max = items[i];
      return max;
    }
 
        /// Find the mean average of values in the array.
    float mean() const {
      float sum = 0.f;
      for (unsigned int i = 0; i < count; i++)
        sum += abs(items[i]);
      return sum / count;
    }
 
        /// Find the root mean squared (RMS) average of values in the array.
    float rms() const {
      float sum = 0.f;
      for (unsigned int i = 0; i < count; i++)
        sum += items[i] * items[i];
      return sqrt(sum / count);
    }
 
        /// Normalises values in the array to the specified @a target, based on peak, mean, or RMS value;
    void normalise(float target = 1.f, int mode = Peak) {
      if (!count) return;
 
      const float current = (mode == Peak) ? max() : (mode == Mean) ? mean() : rms();
      const float scale = current == 0.f ? 0.f : target / current;
      for (int i = 0; i < count; i++)
        items[i] *= scale;
    }
 
        /// Returns a reference to the array item at the given index.
    TYPE& operator[](int index) { return items[index]; }
 
        /// Returns a read-only reference to the array item at the given index.
    const TYPE& operator[](int index) const { return items[index]; }
 
    /// Construct an array given the specified values.
    Array(std::initializer_list<TYPE> init_list) {
      count = std::min(static_cast<unsigned int>(init_list.size()), static_cast<unsigned int>(CAPACITY));
      std::copy_n(init_list.begin(), count, items);
    }
 
        /// Construct an empty array.
    Array() = default; // Default constructor to allow empty initialization
  };
 
    /// String of characters representing text.
  template<int SIZE>
  struct Text {
        /// The character buffer.
    char string[SIZE + 1] = { 0 };
 
        /// Maximum size of the string.
    int capacity() const { return SIZE; }
 
        /// Automatic cast to constant C-string.
    operator const char* () const { return string; }
 
        /// Return constant C-string.
    const char* c_str() const { return string; }
 
        /// Create a new Text object from a C-string.
    static Text from(const char* in) {
      Text text;
      text = in;
      return text;
    }
 
        /// Assign C-String to Text object.
    void operator=(const char* in) {
      memcpy(string, in, SIZE);
      string[SIZE] = 0;
    }
 
        ///  Returns true if Text matches the given C-string.
    bool operator==(const char* in) const {
      return strcmp(string, in) == 0;
    }
 
        ///  Returns true if Text does not matches the given C-string.
    bool operator!=(const char* in) const {
      return !operator==(in);
    }
  };
 
    /// A short Text object used to label controls.
  typedef Text<32> Caption;
 
  struct Output;
 
  struct relative;
 
    /// A mono audio signal (equivalent to a float).
  struct signal {
    float value;
 
    /// Create signal from a constant.
    signal(constant initial) : value(initial.f) { }
 
        /// Create signal from a 32-bit float..
    signal(const float initial = 0.f) : value(initial) { }
 
        /// Create signal from a 64-bit double.
    signal(const double initial) : value((const float)initial) { }
 
        /// Create signal from an 32-bit signed integer.
    signal(const int value) : value((const float)value) { }
 
    /// Feedback operator (prevents further processing of returned value).
    const signal& operator<<(const signal& input) {
      value = input;
      return *this;
    }
 
    /// Stream operator (feedforward; allows further processing)
    signal& operator>>(signal& destination) const {
      destination.value = value;
      return destination;
    }
 
        /// Assign processed output of \a in to signal.
    signal& operator=(Output& in);
        /// Adds processed output of \a in to signal.
    signal& operator+=(Output& in);
 
        /// Add (mix) another signal to the signal.
    signal& operator+=(const signal& x) { value += x.value; return *this; }
        /// Subtract another signal from the signal.
    signal& operator-=(const signal& x) { value -= x.value; return *this; }
        /// Multiply (modulate) signal by another signal.
        signal& operator*=(const signal& x) { value *= x.value; return *this; }
        /// Divide signal by another signal.
    signal& operator/=(const signal& x) { value /= x.value; return *this; }
 
        /// Add the specified amount to the signal.
    signal& operator+=(float x) { value += x; return *this; }
        /// Subtract the specified amount from the signal.
    signal& operator-=(float x) { value -= x; return *this; }
        /// Multiply signal by the specified amount.
    signal& operator*=(float x) { value *= x; return *this; }
        /// Divide signal by the specified amount.
    signal& operator/=(float x) { value /= x; return *this; }
 
        /// Add the specified amount to the signal.
    signal& operator+=(double x) { value += (float)x; return *this; }
        /// Subtract the specified amount from the signal.
    signal& operator-=(double x) { value -= (float)x; return *this; }
        /// Multiply signal by the specified amount.
    signal& operator*=(double x) { value *= (float)x; return *this; }
        /// Divide signal by the specified amount.
    signal& operator/=(double x) { value /= (float)x; return *this; }
 
        /// Add the specified amount to the signal.
    signal& operator+=(int x) { value += (float)x; return *this; }
        /// Subtract the specified amount from the signal.
    signal& operator-=(int x) { value -= (float)x; return *this; }
        /// Multiply signal by the specified amount.
    signal& operator*=(int x) { value *= (float)x; return *this; }
        /// Divide signal by the specified amount.
    signal& operator/=(int x) { value /= (float)x; return *this; }
 
        /// Add two signals together.
    signal operator+(float x) const { return value + x; }
        /// Subtract one signal from another.
    signal operator-(float x) const { return value - x; }
        /// Multiply (modulate) two signals.
    signal operator*(float x) const { return value * x; }
        /// Divide one signal by another.
    signal operator/(float x) const { return value / x; }
 
        /// Return a copy of the signal offset by x.
    signal operator+(double x) const { return value + (float)x; }
        /// Return a copy of the signal offset by -x.
    signal operator-(double x) const { return value - (float)x; }
        /// Return a copy of the signal scaled by x.
    signal operator*(double x) const { return value * (float)x; }
        /// Return a copy of the signal divided by.
    signal operator/(double x) const { return value / (float)x; }
 
        /// Return a copy of the signal offset by x.
    signal operator+(int x) const { return value + (float)x; }
        /// Return a copy of the signal offset by -x.
    signal operator-(int x) const { return value - (float)x; }
        /// Return a copy of the signal scaled by x.
    signal operator*(int x) const { return value * (float)x; }
        /// Return a copy of the signal divided by x.
    signal operator/(int x) const { return value / (float)x; }
 
        /// Return a copy of the signal raised to the power of x.
    signal operator^(float x) const { return power(value, x); }
        /// Return a copy of the signal raised to the power of x.
    signal operator^(double x) const { return power(value, x); }
        /// Return a copy of the signal raised to the power of x.
    signal operator^(int x) const { return power(value, x); }
 
    operator const float() const {  return value; }
    operator float&() {       return value; }
 
        /// Check if the signal contains a denormal value.
    bool isDenormal() const {
      const unsigned int bits = *(const unsigned int*)&value;
      return !(bits & 0x7F800000) && (bits & 0x007FFFFF);
    }
 
        /// Returns the number of channels (1 = mono).
    int channels() const { return 1; }
 
        /// Returns a copy of the signal to treat as a relative offset (e.g. for phase modulation).
    relative operator+() const; // unary + operator produces relative signal
        /// Returns a copy of the signal to treat as a relative offset (e.g. for phase modulation).
    relative relative() const;  // 
  };
 
  /// @internal signal MUST compile as a float
  static_assert(sizeof(signal) == sizeof(float), "signal != float");
  IS_SIMPLE_TYPE(signal)
 
  /// A signal used as an offset relative to another signal.
  struct relative : public signal { };
 
    /// Returns a copy of the signal to treat as a relative offset (e.g. for phase modulation).
  inline relative signal::operator+() const { return { value }; }
    /// Returns a copy of the signal to treat as a relative offset (e.g. for phase modulation).
  inline relative signal::relative() const { return { value }; }
 
  /// Stream a literal / constant / scalar type into a signal.
  inline static signal& operator>>(float input, signal& destination) { // CHECK: should this be signal, rather than float?
    destination << signal(input);
    return destination;
  }
 
  /// A multi-channel audio signal (e.g. stereo).
  template<int CHANNELS = 2>
  struct signals {
        /// @cond
    union {
      signal value[CHANNELS]; ///< Array of channel values.
            struct {
                signal l; ///< Left channel
                signal r; ///< Right channel
            };
    };
        /// @endcond
 
        /// Return the mono mix of a stereo channel.
    signal mono() const { return (l + r) * 0.5f; }
 
        /// Return a reference to the signal at the specified index (0 = left, 1 = right).
    signal& operator[](int index) { return value[index]; }
        /// Return a read-only reference to the signal  at the specified index (0 = left, 1 = right).
    const signal& operator[](int index) const { return value[index]; }
 
        /// Create a stereo signal with the given value.
    signals(float initial = 0.f) : l(initial), r(initial) { }
        /// Create a stereo signal with the given value.
    signals(double initial) : l((float)initial), r((float)initial) { }
        /// Create a stereo signal with the given value.
    signals(int initial) : l((float)initial), r((float)initial) { }
 
        /// Create a stereo signal with the given left and right value.
    signals(float left, float right) : l(left), r(right) { }
        /// Create a stereo signal with the given left and right value.
    signals(double left, double right) : l((float)left), r((float)right) { }
        /// Create a stereo signal with the given left and right value.
    signals(int left, int right) : l((float)left), r((float)right) { }
 
        /// Create a multi-channel signal with the given channel values.
    template <typename... Args, typename = std::enable_if_t<(std::is_convertible_v<Args, signal> && ...)>>
    signals(Args&... initial) : value{ initial... } { }
        /// Create a multi-channel signal with the given channel values.
    template <typename... Args, typename = std::enable_if_t<(std::is_scalar_v<Args> && ...)>>
    signals(Args... initial) : value { initial... } { }
 
        /// Returns the number of channels in the signal.
    int channels() const { return CHANNELS; }
 
        /// Feedback operator (prevents further processing of returned value).
    const signals& operator<<(const signals& input) {
      return this->operator=(input);
    }
 
        /// Stream operator (feedforward; allows further processing).
    signals& operator>>(signals& destination) const {
      destination = *this;
      return destination;
    }
 
        /// Add (mix) another signal to the signal.
        signals& operator+=(const signals x) { for (int v = 0; v < CHANNELS; v++) value[v] += x[v]; return *this; }
        /// Subtract another signal from the signal.
        signals& operator-=(const signals x) { for (int v = 0; v < CHANNELS; v++) value[v] -= x[v]; return *this; }
        /// Multiply (modulate) signal by another signal.
        signals& operator*=(const signals x) { for (int v = 0; v < CHANNELS; v++) value[v] *= x[v]; return *this; }
        /// Divide signal by another signal.
        signals& operator/=(const signals x) { for (int v = 0; v < CHANNELS; v++) value[v] /= x[v]; return *this; }
 
        /// Add two multi-channel signals together.
    signals operator+(const signals x) const { signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] += x[v]; return s; }
        /// Subtract one multi-channel signal from another.
        signals operator-(const signals x) const { signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] -= x[v]; return s; }
        /// Multiply (modulate) two multi-channel signals.
        signals operator*(const signals x) const { signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] *= x[v]; return s; }
        /// Divide one multi-channel signal by another.
    signals operator/(const signals x) const { signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] /= x[v]; return s; }
 
    //signals& operator+=(const signal x) { for (int v = 0; v < CHANNELS; v++) value[v] += x; return *this; }
    //signals& operator-=(const signal x) { for (int v = 0; v < CHANNELS; v++) value[v] -= x; return *this; }
    //signals& operator*=(const signal x) { for (int v = 0; v < CHANNELS; v++) value[v] *= x; return *this; }
    //signals& operator/=(const signal x) { for (int v = 0; v < CHANNELS; v++) value[v] /= x; return *this; }
 
        /// Return a copy of the multi-channel signal, adding a mono signal to each channel.
    signals operator+(const signal x) const { signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] += x; return s; }
        /// Return a copy of the multi-channel signal, subtracting a mono signal from each channel.
    signals operator-(const signal x) const { signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] -= x; return s; }
        /// Return a copy of the multi-channel signal, multiplying (modulating) each channel by a mono signal.
    signals operator*(const signal x) const { signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] *= x; return s; }
        /// Return a copy of the multi-channel signal, dividing each channel by a mono signal.
    signals operator/(const signal x) const { signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] /= x; return s; }
 
        /// Return a copy of the signal with each channel offset by x.
        signals operator+(float x) const { signals s = *this; for(int v = 0; v < CHANNELS; v++) s[v] += x; return s; }
        /// Return a copy of the signal with each channel offset by -x.
    signals operator-(float x) const { signals s = *this; for(int v = 0; v < CHANNELS; v++) s[v] -= x; return s; }
        /// Return a copy of the signal  with each channel scaled by x.
    signals operator*(float x) const { signals s = *this; for(int v = 0; v < CHANNELS; v++) s[v] *= x; return s; }
        /// Return a copy of the signal with each channel divided by x.
    signals operator/(float x) const { signals s = *this; for(int v = 0; v < CHANNELS; v++) s[v] /= x; return s; }
 
        /// Return a copy of the signal with each channel offset by x.
    signals operator+(double x) const { signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] += x; return s; }
        /// Return a copy of the signal with each channel offset by -x.
    signals operator-(double x) const { signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] -= x; return s; }
        /// Return a copy of the signal  with each channel scaled by x.
    signals operator*(double x) const { signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] *= x; return s; }
        /// Return a copy of the signal with each channel divided by x.
    signals operator/(double x) const { signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] /= x; return s; }
 
        /// Return a copy of the signal with each channel offset by x.
    signals operator+(int x) const { signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] += x; return s; }
        /// Return a copy of the signal with each channel offset by -x.
    signals operator-(int x) const { signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] -= x; return s; }
        /// Return a copy of the signal  with each channel scaled by x.
    signals operator*(int x) const { signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] *= x; return s; }
        /// Return a copy of the signal with each channel divided by x.
    signals operator/(int x) const { signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] /= x; return s; }
  };
 
    /// Return a copy of the signal with each channel offset by x.
  template<int CHANNELS = 2> inline signals<CHANNELS> operator+(float x, const signals<CHANNELS>& y) { return y + x; }
    /// Return a copy of the signal with each channel subtracted from  x.
  template<int CHANNELS = 2> inline signals<CHANNELS> operator-(float x, const signals<CHANNELS>& y) { return -y + x; }
    /// Return a copy of the signal  with each channel scaled by x.
  template<int CHANNELS = 2> inline signals<CHANNELS> operator*(float x, const signals<CHANNELS>& y) { return y * x; }
    /// Return a copy of the signal with each channel divided into x.
  template<int CHANNELS = 2> inline signals<CHANNELS> operator/(float x, const signals<CHANNELS>& y) {
    signals<CHANNELS> s = { 0.f };
    for(int c=0; c<CHANNELS; c++)
      s[c] = x / y[c];
    return std::move(s);
  }
 
    /// @cond
    /// Helper class for converting units / quantities
    struct Conversion : public signal {
        using signal::signal;
    //        operator klang::signal& () { return signal; };
    };
    /// @endcond
 
  /// A phase or wavetable increment.
  struct increment {
    float amount; ///< The current phase.
    const float size; ///< The length of a a full cycle (e.g. 2 pi or wavetable size)
 
        /// Create a phase increment (default to radians).
    increment(float amount, const float size = 2 * pi) : amount(amount), size(size) { }
        /// Create a phase increment (wavetable size).
    increment(float amount, int size) : amount(amount), size((float)size) { }
        /// Create a phase increment.
    increment(float amount, double size) : amount(amount), size((float)size) { }
 
        /// Set current phase.
    increment& operator=(float in) { amount = in; return *this;  }
  };
 
  struct Control;
 
  /// A signal used as a control parameter.
  struct param : public signal {
    param(constant in) : signal(in.f) { }
    param(const float initial = 0.f) : signal(initial) { }
    param(const signal& in) : signal(in) { }
    param(signal& in) : signal(in) { }
    param(Control& in); // see Control declaration
 
    param& operator+=(const increment& increment) {
      value += increment.amount;
      if (value >= increment.size)
        value -= increment.size;
      return *this;
    }
  };
 
  // param should also be binary compatible with float / signal
  static_assert(sizeof(param) == sizeof(float), "param != float");
 
  // support left-to-right and right-to-left signal flow
  inline static param& operator>>(param& from, param& to) {
    to << from;
    return to;
  }
 
    /// @cond
  struct params {
    param* parameters;
    const int size;
 
    params(param p) : parameters(new param[1]), size(1) { parameters[0] = p; }
    params(std::initializer_list<param> params) : parameters(new param[params.size()]), size((int)params.size()) {
      int index = 0;
      for(param p : params)
        parameters[index++] = p;
    }
 
    param& operator[](int index) { return parameters[index]; }
  };
    /// @endcond
 
  inline float fast_mod(float x, float y) {
    const unsigned int i = (((unsigned int)(x * (float(UINT_MAX) + 1.f) / y)) >> 9) | 0x3f800000;
    return (*(const float*)&i - 1.f) * y;
  }
 
  inline double fast_mod(double x, double y) {
    const unsigned long long i = (((unsigned long long)(x * (double(ULLONG_MAX) + 1.0) / y)) >> 12ULL) | 0x7FF0000000000000ULL;
    return (*(const double*)&i - 1.0) * y;
  }
 
  inline float fast_mod1(float x) {
    const unsigned int i = ((unsigned int)(x * (float(UINT_MAX) + 1.f)) >> 9) | 0x3f800000;
    return *(const float*)&i - 1.f;
  }
 
  inline double fast_mod1(double x) {
    const unsigned long long i = (((unsigned long long)(x * (double(ULLONG_MAX) + 1.0))) >> 12ULL) | 0x7FF0000000000000ULL;
    return (*(const double*)&i - 1.0);
  }
 
  inline float fast_mod2pi(float x) {
    constexpr float twoPi = float(2.0 * 3.1415926535897932384626433832795);
    const unsigned int i = (((unsigned int)(x * (float(UINT_MAX) + 1.f) / twoPi)) >> 9) | 0x3f800000;
    return (*(const float*)&i - 1.f) * twoPi;
  }
 
  inline float fast_modp(unsigned int x) {
    constexpr float twoPi = float(2.0 * 3.1415926535897932384626433832795);
    const unsigned int i = (x >> 9) | 0x3f800000;
    return (*(const float*)&i - 1.f) * twoPi;
  }
 
  inline double fast_mod2pi(double x) {
    constexpr double twoPi = (2.0 * 3.1415926535897932384626433832795);
    const unsigned long long i = (((unsigned long long)(x * (double(ULLONG_MAX) + 1.0) / twoPi)) >> 12ULL) | 0x7FF0000000000000ULL;
    return (*(const double*)&i - 1.0) * twoPi;
  }
 
  template<int SIZE>
  inline double fast_modi(double x) {
    constexpr double size = double(SIZE);
    constexpr double sizeInv = 1.0 / double(SIZE);
    const unsigned long long i = (((unsigned long long)(x * (double(ULLONG_MAX) + 1.0) * sizeInv)) >> 12ULL) | 0x7FF0000000000000ULL;
    return (*(const double*)&i - 1.0) * size;
  }
 
    /// Matrix processor
  //template<int X, int Y = X>
  struct Matrix {
    float v[4][4] = { 0 };
 
    float* operator[](int col) { return v[col]; }
    const float* operator[](int col) const { return v[col]; }
 
    float& operator()(int col, int row) { return v[col][row]; }
    float operator()(int col, int row) const { return v[col][row]; }
 
    signals<4> operator<<(const signals<4>& in) const {
      return { v[0][0] * in[0] + v[0][1] * in[1] + v[0][2] * in[2] + v[0][3] * in[3],
           v[1][0] * in[0] + v[1][1] * in[1] + v[1][2] * in[2] + v[1][3] * in[3],
           v[2][0] * in[0] + v[2][1] * in[1] + v[2][2] * in[2] + v[2][3] * in[3],
           v[3][0] * in[0] + v[3][1] * in[1] + v[3][2] * in[2] + v[3][3] * in[3] };
    }
  };
 
  inline signals<4> operator*(const signals<4>& in, const Matrix& m) {
    return { m[0][0] * in[0] + m[0][1] * in[1] + m[0][2] * in[2] + m[0][3] * in[3],
         m[1][0] * in[0] + m[1][1] * in[1] + m[1][2] * in[2] + m[1][3] * in[3],
         m[2][0] * in[0] + m[2][1] * in[1] + m[2][2] * in[2] + m[2][3] * in[3],
         m[3][0] * in[0] + m[3][1] * in[1] + m[3][2] * in[2] + m[3][3] * in[3] };
  }
 
  inline signals<4> operator>>(const signals<4>& in, const Matrix& m) { return operator*(in, m); }
 
    /// @cond
  template<typename TYPE, typename _TYPE>
  struct phase {
    static constexpr TYPE twoPi = TYPE(2.0 * 3.1415926535897932384626433832795);
 
    // represent phase using full range of uint32
    // (integer math, no conditionals, free oversampling)
    _TYPE i = 0;
 
    // convert float [0, 2pi) to uint32
    phase(TYPE phase = 0) {
      if constexpr (std::is_same<TYPE, double>()) {
        constexpr TYPE FUINTMAX = TYPE(ULLONG_MAX + 1.0) / twoPi; // (float)INT_MAX + 1.f;
        phase *= FUINTMAX;
        i = (_TYPE)phase;
      } else if constexpr (std::is_same<TYPE, float>()) {
        constexpr TYPE FUINTMAX = TYPE(UINT_MAX + 1.0) / twoPi; // (float)INT_MAX + 1.f;
        phase *= FUINTMAX;
        i = (_TYPE)phase;
      }
    }
 
    // convert uint32 to float [0, 1)
    operator TYPE() const {
      const _TYPE phase = (i >> 12ULL) | 0x3FF0000000000000ULL;
      return (*(const TYPE*)&phase - TYPE(1.0)) * twoPi;
    }
 
    //static void test() {
    //  phase p;
    //  assert((float)(p = 0.f).radians() == 0.f);
    //  assert((float)(p = pi / 2).radians() == pi / 2);
    //  assert((float)(p = pi).radians() == pi);
    //  assert((float)(p = 3 * pi / 2).radians() == 3 * pi / 2);
    //  assert((float)(p = 2 * pi).radians() == 0.f);
    //}
  };
    /// @endcond
 
    /// Control parameter (phase)
  struct Phase : public param {
    //INFO("Phase", 0.f, 0.f, 1.0f)
    using param::param;
    /*Phase(const float p = 0.f) : param(p) { };*/
 
    param& operator+=(float increment) {
      if (increment >= (2 * pi))
        return *this;
      value += increment;
      if (value > (2 * pi))
        value -= (2 * pi);
      return *this;
    }
 
    param& operator+=(const increment& increment) {
      if (increment.amount >= increment.size)
        return *this;
      value += increment.amount;
      if (value > increment.size)
        value -= increment.size;
      return *this;
    }
 
    Phase operator+(const increment& increment) const {
      if (increment.amount >= increment.size)
        return value;
      Phase value = Phase::value + increment.amount;
      if (value > increment.size)
        value -= increment.size;
      return value;
    }
 
    Phase operator%(float modulus) {
      return fast_mod(value, modulus);
    }
  };
 
  struct Frequency;
 
    /// Control parameter (pitch)
  struct Pitch : public param {
    //INFO("Pitch", 60.f, 0.f, 127.f)
    using param::param;
 
    //Pitch(float p = 60.f) : param(p) { };
    //Pitch(int p) : param((float)p) { };
 
    // convert note number to pitch class and octave (e.g. C#5)
    const char* text() const {
      THREAD_LOCAL static char buffer[32] = { 0 };
      const char* const notes[12] = { "C", "C#/Db", "D", "D#/Eb", "E", "F", "F#/Gb", "G", "G#/Ab", "A", "A#/Bb", "B" };
      snprintf(buffer, 32, "%s%d", notes[(int)value % 12], (int)value / 12);
      return buffer;
    }
 
        const Pitch* operator->() {
            Frequency = 440.f * power(2.f, (value - 69.f) / 12.f);
            return this;
        }
 
        THREAD_LOCAL static Conversion Frequency;
 
    template<typename TYPE> Pitch operator+(TYPE in) { return value + in; }
    template<typename TYPE> Pitch operator-(TYPE in) { return value - in; }
    template<typename TYPE> Pitch operator*(TYPE in) { return value * in; }
    template<typename TYPE> Pitch operator/(TYPE in) { return value / in; }
  };
 
    THREAD_LOCAL inline Conversion Pitch::Frequency;
 
//  inline THREAD_LOCAL Pitch::Convert Pitch::Frequency;
 
    /// Control parameter (frequency)
  struct Frequency : public param {
    //INFO("Frequency", 1000.f, -FLT_MAX, FLT_MAX)
    using param::param;
    Frequency(float f = 1000.f) : param(f) { };
  };
 
    /// Sample rate constants
  static struct SampleRate {
    float f;        ///< sample rate (float)
    int i;          ///< sample rate (integer)
    double d;       ///< sample rate (double)
    float inv;      ///< 1 / sample rate (inverse)
    float w;        ///< angular frequency (omega)
    float nyquist;  ///< nyquist frequency (f / 2)
 
    SampleRate(float sr) : f(sr), i(int(sr+0.001f)), d((double)sr), inv(1.f / sr), w(2.0f * pi * inv), nyquist(sr / 2.f) { }
 
    operator float() { return f; }
  } fs(44100); // sample rate
 
  struct Amplitude;
 
    /// Control parameter (idecibels)
  struct dB : public param {
    //INFO("dB", 0.f, -FLT_MAX, FLT_MAX)
    using param::param;
 
    dB(float gain = 0.f) : param(gain) { };
 
    const dB* operator->() {
      Amplitude = power(10, value * 0.05f);
      return this;
    }
 
    THREAD_LOCAL static Conversion Amplitude;
  };
 
  /// Control parameter (linear amplitude)
  struct Amplitude : public param {
    //INFO("Gain", 1.f, -FLT_MAX, FLT_MAX)
    using param::param;
 
    Amplitude(float a = 1.f) : param(a) { };
    Amplitude(const dB& db) {
      value = power(10, db.value * 0.05f); // 10 ^ (db * 0.05f);
    };
 
    //dB operator >> (dB) const {
    //  return 20.f * log10f(value);
    //}
    //operator dB() const {
    //  return 20.f * log10f(value);
    //}
 
    const Amplitude* operator->() const {
      dB = 20.f * log10f(value);
      return this;
    }
 
    THREAD_LOCAL static Conversion dB;
  };
 
  THREAD_LOCAL inline Conversion dB::Amplitude;
  THREAD_LOCAL inline Conversion Amplitude::dB;
 
    /// Control parameter (velocity)
  typedef Amplitude Velocity;
 
    /// UI control / parameter
  struct Control
  {
    enum Type
    {
      NONE, // no control (list terminator)
      ROTARY, // rotary knob (dial/pot)
      BUTTON, // push button (trigger)
      TOGGLE, // on/off switch (toggle)
      SLIDER, // linear slider (fader)
      MENU,   // drop-down list (menu; up to 128 items)
      METER,  // level meter (read-only: use setParameter() to set value)
      WHEEL,  // MIDI control (Pitch Bend / Mod Wheel only)
    };
 
        /// Control size
    struct Size
    {
      Size(int x = -1, int y = -1, int width = -1, int height = -1)
      : x(x), y(y), width(width), height(height) { }
 
      int x;
      int y;
      int width;
      int height;
 
      bool isAuto() const { return x == -1 && y == -1 && width == -1 && height == -1;  }
    };
 
    typedef Array<Caption, 128> Options;
 
    Caption name;           // name for control label / saved parameter
    Type type = NONE;       // control type (see above)
 
    float min;              // minimum control value (e.g. 0.0)
    float max;              // maximum control value (e.g. 1.0)
    float initial;          // initial value for control (e.g. 0.0)
 
    Size size;              // position (x,y) and size (height, width) of the control (use AUTO_SIZE for automatic layout)
    Options options;        // text options for menus and group buttons
 
    signal value;           // current control value
    signal smoothed;    // smoothed control value (filtered)
 
    operator signal& () { return value; }
    operator const signal&() const { return value; }
    operator param() const { return value; }
    operator float() const { return value.value; }
 
    static constexpr float smoothing = 0.999f;
    signal smooth() { return smoothed = smoothed * smoothing + (1.f - smoothing) * value; }
 
    operator Control*() { return this; }
 
    Control& set(float x) {
      value = std::clamp(x, min, max);
      return *this;
    }
 
    Control& operator+=(float x) { value += x; return *this; }
    Control& operator*=(float x) { value *= x; return *this; }
    Control& operator-=(float x) { value -= x; return *this; }
    Control& operator/=(float x) { value /= x; return *this; }
 
    //float operator+(float x) const { return value + x; }
    //float operator*(float x) const { return value * x; }
    //float operator-(float x) const { return value - x; }
    //float operator/(float x) const { return value / x; }
 
    template<typename TYPE> signal operator+(const Control& x) const { return value + x; }
    template<typename TYPE> signal operator*(const Control& x) const { return value * x; }
    template<typename TYPE> signal operator-(const Control& x) const { return value - x; }
    template<typename TYPE> signal operator/(const Control& x) const { return value / x; }
 
    template<typename TYPE> float operator+(TYPE x) const { return value + x; }
    template<typename TYPE> float operator*(TYPE x) const { return value * x; }
    template<typename TYPE> float operator-(TYPE x) const { return value - x; }
    template<typename TYPE> float operator/(TYPE x) const { return value / x; }
 
    template<typename TYPE> Control& operator<<(TYPE& in) { value = in; return *this;  }    // assign to control with processing
    template<typename TYPE> Control& operator<<(const TYPE& in) { value = in; return *this;  }  // assign to control without/after processing
 
    template<typename TYPE> TYPE& operator>>(TYPE& in) { return value >> in; }          // stream control to signal/object (allows processing)
    template<typename TYPE> const TYPE& operator>>(const TYPE& in) { return value >> in; }    // stream control to signal/object (no processing)
  };
 
  const Control::Size Automatic = { -1, -1, -1, -1 };
  const Control::Options NoOptions;
 
    /// Mapped UI control
  struct ControlMap {
    Control* control;
 
    ControlMap() : control(nullptr) { };
    ControlMap(Control& control) : control(&control) { };
 
    operator Control&() { return *control; }
    operator signal& () { return control->value; }
    operator const signal&() const { return control->value; }
    operator param() const { return control->value; }
    operator float() const { return control->value; }
    signal smooth() { return control->smooth(); }
 
    template<typename TYPE> Control& operator<<(TYPE& in) { control->value = in; return *control; }   // assign to control with processing
    template<typename TYPE> Control& operator<<(const TYPE& in) { control->value = in; return *control; } // assign to control without/after processing
  };
 
  IS_SIMPLE_TYPE(Control);
 
  inline param::param(Control& in) : signal(in.value) { }
 
  inline static Control Dial(const char* name, float min = 0.f, float max = 1.f, float initial = 0.f)
  { return { Caption::from(name), Control::ROTARY, min, max, initial, Automatic, NoOptions, initial };  }
 
  inline static Control Button(const char* name)
  { return { Caption::from(name), Control::BUTTON, 0, 1, 0.f, Automatic, NoOptions, 0.f };  }
 
  inline static Control Toggle(const char* name, bool initial = false)
  { return { Caption::from(name), Control::TOGGLE, 0, 1, initial ? 1.f : 0.f, Automatic, NoOptions, initial ? 1.f : 0.f}; }
 
  inline static Control Slider(const char* name, float min = 0.f, float max = 1.f, float initial = 0.f)
  { return { Caption::from(name), Control::SLIDER, min, max, initial, Automatic, NoOptions, initial }; }
 
  template<typename... Options>
  static Control Menu(const char* name, const Options... options)
  { Control::Options menu;
    const char* strings[] = { options... };
    int nbValues = sizeof...(options);
    for(int p=0; p<nbValues; p++)
      menu.add(Caption::from(strings[p]));
    return { Caption::from(name), Control::MENU, 0, menu.size() - 1.f, 0, Automatic, menu, 0 };
  }
 
  inline static Control Meter(const char* name, float min = 0.f, float max = 1.f, float initial = 0.f)
  { return { Caption::from(name), Control::METER, min, max, initial, Automatic, NoOptions, initial }; }
 
  inline static Control PitchBend()
  { return { { "PITCH\nBEND" }, Control::WHEEL, 0.f, 16384.f, 8192.f, Automatic, NoOptions, 8192.f }; }
 
  inline static Control ModWheel()
  { return { { "MOD\nWHEEL" }, Control::WHEEL, 0.f, 127.f, 0.f, Automatic, NoOptions, 0.f }; }
 
    /// Plugin UI controls
  struct Controls : Array<Control, 128>
  {
    float value[128] = { 0 };
 
    void operator+= (const Control& control) {
      items[count++] = control;
    }
 
    void operator= (const Controls& controls) {
      for (int c = 0; c < 128 && controls[c].type != Control::NONE; c++)
        operator+=(controls[c]);
    }
 
    void operator=(std::initializer_list<Control> controls) {
      for(auto control : controls)
        operator+=(control);
    }
 
    void add(const char* name, Control::Type type = Control::ROTARY, float min = 0.f, float max = 1.f, float initial = 0.f, Control::Size size = Automatic) {
      items[count].name = name;
      items[count].type = type;
      items[count].min = min;
      items[count].max = max;
      items[count].initial = initial;
      items[count].size = size;
      items[count++].value = initial;
    }
 
    bool changed() {
      bool changed = false;
      for (unsigned int c = 0; c < count; c++) {
        if (items[c].value != value[c]) {
          value[c] = items[c].value;
          changed = true;
        }
      }
      return changed;
    }
 
    //float& operator[](int index) { return items[index].value; }
    //signal operator[](int index) const { return items[index].value; }
 
    //Control& operator()(int index) { return items[index]; }
    //Control operator()(int index) const { return items[index]; }
  };
 
  typedef Array<float, 128> Values;
 
    /// Factory preset
  struct Preset {
    Caption name = { 0 };
    Values values;
  };
 
  //template<typename... Settings>
  //static Program Preset(const char* name, const Settings... settings)
  //{ Values values;
  //  float preset[] = { (float)settings... };
  //  int nbSettings = sizeof...(settings);
  //  for(int s=0; s<nbSettings; s++)
  //    values.add(preset[s]);
  //  return { Caption::from(name), values };
  //}
 
    /// Factory presets
  struct Presets : Array<Preset, 128> {
    void operator += (const Preset& preset) {
      items[count++] = preset;
    }
 
    void operator= (const Presets& presets) {
      for (int p = 0; p < 128 && presets[p].name[0]; p++)
        operator+=(presets[p]);
    }
 
    void operator=(std::initializer_list<Preset> presets) {
      for(auto preset : presets)
        operator+=(preset);
    }
 
    template<typename... Values>
    void add(const char* name, const Values... values) {
      items[count].name = name;
 
      const float preset[] = { values... };
      int nbValues = sizeof...(values);
      for(int p=0; p<nbValues; p++)
        items[count].values.add(preset[p]);
      count++;
    }
  };
 
    /// Audio buffer (mono)
  class buffer {
  protected:
    constexpr unsigned int capacity(unsigned int n) {
      // Decrement n to handle the case where n is already a power of 2
      n--;
      n |= n >> 1;
      n |= n >> 2;
      n |= n >> 4;
      n |= n >> 8;
      n |= n >> 16;
      // Increment n to get the next power of 2
      n++;
      return n;
    }
    const unsigned int mask = 0xFFFFFFFF;
    const bool owned = false;
    float* samples;
    signal* ptr;
    signal* end;
  public:
    typedef signal signal;
    const int size;
 
    buffer(float* buffer, int size)
    : owned(false), samples(buffer), size(size) {
      rewind();
    }
 
    buffer(float* buffer, int size, float initial)
    : owned(false), samples(buffer), size(size) {
      rewind();
      set(initial);
    }
 
    buffer(int size, float initial = 0)
    : mask(capacity(size) - 1), owned(true), samples(new float[capacity(size)]), size(size) {
      rewind();
      set(initial);
    }
 
    virtual ~buffer() {
      if (owned)
        delete[] samples;
    }
 
    void rewind(int offset = 0) {
#ifdef _MSC_VER
      _controlfp_s(nullptr, _DN_FLUSH, _MCW_DN);
#endif
      ptr = (signal*)&samples[offset];
      end = (signal*)&samples[size];
    }
 
    void clear() {
      memset(samples, 0, sizeof(float) * size);
    }
 
    void clear(int size) {
      memset(samples, 0, sizeof(float) * (size < buffer::size ? size : buffer::size));
    }
 
    int offset() const {
      return int((signal*)&samples[0] - ptr);
    }
 
    void set(float value = 0) {
      if (value == 0)
        clear();
      else for (int s = 0; s < size; s++)
        samples[s] = value;
    }
 
    signal& operator[](int offset) {
      return *(signal*)&samples[offset & mask]; // owned array can't write beyond allocation
    }
 
    signal operator[](float offset) {
      return ((const buffer*)this)->operator[](offset);
    }
 
    signal operator[](float offset) const {
      const float f = floorf(offset);
      const float frac = offset - f;
 
      const int i = (int)offset;
      const int j = (i == (size - 1)) ? 0 : (i + 1);
 
      return samples[i] * (1.f - frac) + samples[j] * frac;
    }
 
    const signal& operator[](int index) const {
      return *(const signal*)&samples[index];
    }
 
    operator signal& () {
      return *ptr;
    }
 
    operator const signal& () const {
      return *ptr;
    }
 
    explicit operator double() const {
      return *ptr;
    }
 
    bool finished() const {
      return ptr == end;
    }
 
    signal& operator++(int) {
      return *ptr++;
    }
 
    signal& operator=(const signal& in) {
      return *ptr = in;
    }
 
    signal& operator+=(const signal& in) {
      *ptr += in;
      return *this;
    }
 
    signal& operator*=(const signal& in) {
      *ptr *= in;
      return *this;
    }
 
    buffer& operator=(const buffer& in) {
      //assert(size == in.size);
      memcpy(samples, in.samples, size * sizeof(float));
      return *this;
    }
 
    buffer& operator<<(const signal& in) {
      *ptr = in;
      return *this;
    }
 
    const float* data() const { return samples; }
  };
 
    struct Graph;
  struct GraphPtr;
 
    /// Templates supporting common audio functionality
  namespace Generic {
 
        /// Audio input object
    template<typename SIGNAL>
    struct Input {
            virtual ~Input() { }
      SIGNAL in = { 0.f };
 
      // retrieve current input
      virtual const SIGNAL& input() const { return in; }
 
      // feedback input (include pre-processing, if any)
      virtual void operator<<(const SIGNAL& source) { in = source; input(); }
      virtual void input(const SIGNAL& source) { in = source; input(); }
 
    protected:
      // preprocess input (default: none)
      virtual void input() { }
    };
 
    /// Audio output object
    template<typename SIGNAL>
    struct Output {
      SIGNAL out = { 0.f };
 
      // returns previous output (without processing)
      virtual const SIGNAL& output() const { return out; }
 
      // pass output to destination (with processing)
      template<typename TYPE>
      TYPE& operator>>(TYPE& destination) { process(); return destination = out; }
 
      // returns output (with processing)
      virtual operator const SIGNAL&() { process(); return out; } // return processed output
      virtual operator const SIGNAL&() const { return out; } // return last output
 
      // arithmetic operations produce copies
      template<typename TYPE> SIGNAL operator+(TYPE& other) { process(); return out + (other); }
      template<typename TYPE> SIGNAL operator*(TYPE& other) { process(); return out * (other); }
      template<typename TYPE> SIGNAL operator-(TYPE& other) { process(); return out - (other); }
      template<typename TYPE> SIGNAL operator/(TYPE& other) { process(); return out / (other); }
 
    protected:
      // signal processing
      virtual void process() = 0;
    };
 
    //template<typename TYPE> inline signal operator+(TYPE other, Output& output) { return signal(output) + other; }
    //template<typename TYPE> inline signal operator*(TYPE other, Output& output) { return signal(output) * other; }
    //template<typename TYPE> inline signal operator-(TYPE other, Output& output) { return signal(other) - signal(output); }
    //template<typename TYPE> inline signal operator/(TYPE other, Output& output) { return signal(other) / signal(output); }
 
    // in-place arithmetic operations (CHECK: can these just be SIGNAL?)
    template<typename SIGNAL> inline SIGNAL operator+(float other, Output<SIGNAL>& output) { return SIGNAL(output) + other; }
    template<typename SIGNAL> inline SIGNAL operator*(float other, Output<SIGNAL>& output) { return SIGNAL(output) * other; }
    template<typename SIGNAL> inline SIGNAL operator-(float other, Output<SIGNAL>& output) { return SIGNAL(other) - SIGNAL(output); }
    template<typename SIGNAL> inline SIGNAL operator/(float other, Output<SIGNAL>& output) { return SIGNAL(other) / SIGNAL(output); }
 
    template<typename SIGNAL> inline SIGNAL operator+(Output<SIGNAL>& output, float other) { return SIGNAL(output) + other; }
    template<typename SIGNAL> inline SIGNAL operator*(Output<SIGNAL>& output, float other) { return SIGNAL(output) * other; }
    template<typename SIGNAL> inline SIGNAL operator-(Output<SIGNAL>& output, float other) { return SIGNAL(output) - other; }
    template<typename SIGNAL> inline SIGNAL operator/(Output<SIGNAL>& output, float other) { return SIGNAL(output) / other; }
 
    //inline signal operator+(Output& other, Output& output) { return signal(output) + signal(other); }
    //inline signal operator*(Output& other, Output& output) { return signal(output) * signal(other); }
    //inline signal operator-(Output& other, Output& output) { return signal(other) - signal(output); }
    //inline signal operator/(Output& other, Output& output) { return signal(other) / signal(output); }
 
        /// Signal generator object (output only)
    template<typename SIGNAL>
    struct Generator : public Output<SIGNAL> {
      using Output<SIGNAL>::out;
 
      // inline parameter(s) support
      template<typename... params>
      Output<SIGNAL>& operator()(params... p) {
        set(p...); return *this;
      }
 
      using Output<SIGNAL>::operator>>;
      using Output<SIGNAL>::process;
      operator const SIGNAL& () override { process(); return out; } // return processed output    
      operator const SIGNAL& () const override { return out; } // return last output    
 
    protected:
      // overrideable parameter setting (up to 8 parameters)
            /// @cond
      virtual void set(param) { };
      virtual void set(relative) { }; // relative alternative
      virtual void set(param, param) { };
      virtual void set(param, relative) { }; // relative alternative
      virtual void set(param, param, param) { };
      virtual void set(param, param, relative) { }; // relative alternative
      virtual void set(param, param, param, param) { };
      virtual void set(param, param, param, relative) { }; // relative alternative
      virtual void set(param, param, param, param, param) { };
      virtual void set(param, param, param, param, relative) { }; // relative alternative
      virtual void set(param, param, param, param, param, param) { };
      virtual void set(param, param, param, param, param, relative) { }; // relative alternative
      virtual void set(param, param, param, param, param, param, param) { };
      virtual void set(param, param, param, param, param, param, relative) { }; // relative alternative
      virtual void set(param, param, param, param, param, param, param, param) { };
      virtual void set(param, param, param, param, param, param, param, relative) { }; // relative alternative
            /// @endcond
    };
 
        /// Signal modifier object (input-output)
    template<typename SIGNAL>
    struct Modifier : public Input<SIGNAL>, public Output<SIGNAL> {
      using Input<SIGNAL>::in;
      using Output<SIGNAL>::out;
 
            virtual ~Modifier() { }
 
      // signal processing (input-output)
      operator const SIGNAL&() override { process(); return out; } // return processed output
      operator const SIGNAL&() const override { return out; } // return last output
 
      using Input<SIGNAL>::input;
      virtual void process() override { out = in; } // default to pass-through
 
      // inline parameter(s) support
      template<typename... params>
      Modifier<SIGNAL>& operator()(params... p) {
        set(p...); return *this;
      }
    protected:
      // overrideable parameter setting (up to 8 parameters)
            /// @cond
      virtual void set(param) { };
      virtual void set(param, param) { };
      virtual void set(param, param, param) { };
      virtual void set(param, param, param, param) { };
      virtual void set(param, param, param, param, param) { };
      virtual void set(param, param, param, param, param, param) { };
      virtual void set(param, param, param, param, param, param, param) { };
      virtual void set(param, param, param, param, param, param, param, param) { };
            /// @endcond
    };
 
    /// Applies a function to a signal (input-output)
    template<typename SIGNAL, typename... Args>
    struct Function : public Generic::Modifier<SIGNAL> {
            virtual ~Function() { }
 
      using Modifier<SIGNAL>::in;
      using Modifier<SIGNAL>::out;
 
      operator SIGNAL() {
        if (function)
          return evaluate();
        process();
        return out;
      };
      operator param() {
        if(function)
          return evaluate();
        return 2.f;
      }
 
            /// @cond
            // Helper to combine hash values
            template <typename T>
            inline void hash_combine(std::size_t& seed, const T& value) const {
                std::hash<T> hasher;
                seed ^= hasher(value) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
            }
 
            // Recursive function to hash each element of a tuple
            template <typename Tuple, std::size_t Index = 0>
            std::size_t hash_tuple(const Tuple& tuple) const {
                if constexpr (Index < std::tuple_size<Tuple>::value) {
                    std::size_t seed = hash_tuple<Tuple, Index + 1>(tuple);
                    hash_combine(seed, std::get<Index>(tuple));
                    return seed;
                } else {
                    return 0;
                }
            }
 
            operator void*() { return this; }
            uint64_t hash() const { return hash_tuple(tail(inputs)); }
            /// @endcond
 
      std::function<float(Args...)> function;
 
      static constexpr unsigned int ARGS = sizeof...(Args);
            unsigned int args() const { return ARGS; }
 
      std::tuple<Args...> inputs;
 
      // Helper function to extract the tail of a tuple
      template <typename First, typename... Rest>
      std::tuple<Rest...> tail(const std::tuple<First, Rest...>& t) const {
        return std::apply( [](const First&, const Rest&... rest) { return std::make_tuple(rest...); },t);
      }
 
      template<typename FunctionPtr>
      Function() : function(nullptr) { }
 
            template<typename FunctionPtr>
      Function(FunctionPtr function)
        : function(std::forward<FunctionPtr>(function)) {}
 
            template<typename FunctionPtr, typename... OtherArgs>
            Function(FunctionPtr function, OtherArgs... args)
                : function(std::forward<FunctionPtr>(function)) {
                    with(args...);
                }
 
            void input() override {
                std::get<0>(inputs) = in.value;
            }
 
            // get the first argument
            template <typename First, typename... Rest>
            First first(First first, Rest...) { return first; }
 
      // Function call operator to invoke the stored callable
            template<typename... FuncArgs>
      Function<SIGNAL,Args...>& operator()(const FuncArgs&... args) {
                if constexpr (ARGS > 1 && sizeof...(FuncArgs) == 1){
                    in = first(args...);
                    std::get<0>(inputs) = in.value;
                    return *this;
                } else if constexpr (ARGS == sizeof...(FuncArgs)){
                    in = first(args...);
                    inputs = std::tuple<Args...>(args...);
                    return *this;
                } else if constexpr (sizeof...(FuncArgs) == (ARGS - 1)){
                    inputs = std::tuple<Args...>(in.value, args...);
                    return *this;
                } else {
                    in = first(args...);
                    std::get<0>(inputs) = in.value;
                    return *this;
                }
      }
 
      // Function call operator to invoke the stored callable
      template<typename... FuncArgs>
      const float operator()(const FuncArgs&... args) const {
        signal in = this->in;
        std::tuple<Args...> inputs = this->inputs;
 
        // configure inputs
        if constexpr (ARGS > 1 && sizeof...(FuncArgs) == 1) {
          in = first(args...);
          std::get<0>(inputs) = in.value;
        } else if constexpr (ARGS == sizeof...(FuncArgs)) {
          in = first(args...);
          inputs = std::tuple<Args...>(args...);
        } else if constexpr (sizeof...(FuncArgs) == (ARGS - 1)) {
          inputs = std::tuple<Args...>(in.value, args...);
        } else {
          in = first(args...);
          std::get<0>(inputs) = in.value;
        }
 
        // return outputs
        if constexpr (ARGS > 1)
          return std::apply(function, inputs);
        else
          return function(in);
      }
 
            template<typename... FuncArgs>
            Function<SIGNAL,Args...>& with(FuncArgs... args){
                static_assert(sizeof...(FuncArgs) == (ARGS - 1), "with() arguments must have all but first argument.");
                inputs = std::tuple<Args...>(in.value, args...);
 
                return *this;
            }
 
      signal evaluate() const {
        if (!function)
          return 0.f;
                if constexpr (ARGS > 1)
          return std::apply(function, inputs);
                else
          return function(in);
      }
 
      virtual void process() override {
        out = evaluate();
      }
 
            klang::Graph& operator>>(klang::Graph& graph);
      klang::GraphPtr& operator>>(klang::GraphPtr& graph);
        };
 
        // deduction guide for functions
        template <typename... Args>
        Function(float(*)(Args...)) -> Function<signal, Args...>;
 
    template <typename... Args>
    Function() -> Function<signal, Args...>;
 
        /// A line graph plotter
    template<int SIZE>
    struct Graph {
      virtual ~Graph() { };
 
      size_t capacity() const { return SIZE; }
 
      struct Series;
 
            /// A data point
      struct Point {
        double x, y;
        bool valid() const { return !::isnan(x) && !::isinf(x) && !::isnan(y); } // NB: y can be +/- inf
 
        Series& operator>>(Series& series);
      };
 
      struct Axis;
 
            /// Data series
      struct Series : public Array<Point, SIZE + 1>, Input<signal> {
        virtual ~Series() { }
 
        void* function = nullptr;
        uint64_t hash = 0;
 
        using Array = Array<Point, SIZE + 1>;
        using Array::add;
        using Array::count;
        using Array::items;
 
        void add(double y) {
          add({ (double)Array::size(), y });
        }
 
        template<typename SIGNAL, typename... Args>
        void plot(Generic::Function<SIGNAL, Args...>& f, const Axis& x_axis) {
          constexpr int size = SIZE > 1024 ? 1024 : SIZE;
 
          if (function != (void*)f || hash != f.hash()) {
            clear();
            function = (void*)f;
            hash = f.hash();
            double x = 0;
            const double dx = x_axis.range() / size;
            for (int i = 0; i <= size; i++) {
              x = x_axis.min + i * dx;
              add({ x, (double)(signal)f(x) });
            }
          }
        }
 
        template<typename RETURN, typename ARG>
        void plot(RETURN(*f)(ARG), const Axis& x_axis) {
          constexpr int size = SIZE > 1024 ? 1024 : SIZE;
 
          if (function != (void*)f) {
            clear();
            function = (void*)f;
            hash = 0;
            double x = 0;
            const double dx = x_axis.range() / size;
            for (int i = 0; i <= size; i++) {
              x = x_axis.min + i * dx;
              add({ x, (double)(signal)f((float)x) });
            }
          }
        }
 
        bool operator==(const Series& in) const {
          if (count != in.count) return false;
          for (unsigned int i = 0; i < count; i++)
            if (items[i].x != in.items[i].x || items[i].y != in.items[i].y)
              return false;
          return true;
        }
 
        bool operator!=(const Series& in) const {
          return !operator==(in);
        }
 
        void clear() {
          function = nullptr;
          Array::clear();
        }
 
        using Input::input;
        void input() override {
          add(in);
        }
      };
 
            /// Graph axis
      struct Axis {
        double min = 0, max = 0;
        bool valid() const { return max != min; }
        double range() const { return max - min; }
        bool contains(double value) const { return value >= min && value <= max; }
        void clear() { min = max = 0; }
 
        void from(const Series& series, double Point::* axis) {
          if (!series.count) return;
          int points = 0;
          for (unsigned int p = 0; p < series.count; p++) {
            const Point& pt = series[p];
            if (pt.valid() && !::isinf(pt.*axis)) {
              if (!points || pt.*axis < min) min = pt.*axis;
              if (!points || pt.*axis > max) max = pt.*axis;
              points++;
            }
          }
          if (std::abs(max) < 0.0000000001) max = 0;
          if (std::abs(min) < 0.0000000001) min = 0;
          if (std::abs(max) > 1000000000.0) max = 0;
          if (std::abs(min) > 1000000000.0) min = 0;
          if (min > max) max = min = 0;
        }
      };
 
            /// Graph axes (x/y)
      struct Axes {
        Axis x, y;
        bool valid() const { return x.valid() && y.valid(); }
        void clear() { x = { 0,0 }; y = { 0,0 }; }
        bool contains(const Point& pt) const { return x.contains(pt.x) && y.contains(pt.y); }
      };
 
      void clear() {
        dirty = true;
        axes.clear();
        for (int s = 0; s < GRAPH_SERIES; s++)
          data[s].clear();
        data.clear();
      }
 
            /// @cond
      bool isActive() const {
        if (data.count)
          return true;
        for (int s = 0; s < GRAPH_SERIES; s++)
          if (data[s].count)
            return true;
        return false;
      }
            /// @endcond
 
            /// Graph data
      struct Data : public Array<Series, GRAPH_SERIES> {
        using Array<Series, GRAPH_SERIES>::items;
 
        Series* find(void* function) {
          for (int s = 0; s < GRAPH_SERIES; s++)
            if (this->operator[](s).function == function)
              return &items[s];
          return nullptr;
        }
      };
 
      Graph& operator()(double min, double max) {
        dirty = true;
        axes.x.min = min; axes.x.max = max;
        return *this;
      }
 
      Graph::Series& operator[](int index) {
        dirty = true;
        return data[index];
      }
 
      const Graph::Series& operator[](int index) const {
        return data[index];
      }
 
      Graph& operator()(double x_min, double x_max, double y_min, double y_max) {
        dirty = true;
        axes.x.min = x_min; axes.x.max = x_max;
        axes.y.min = y_min; axes.y.max = y_max;
        return *this;
      }
 
      operator Series& () {
        dirty = true;
        return data[0];
      }
 
            /// Plot the given Function
      template<typename SIGNAL, typename... Args>
      void plot(Generic::Function<SIGNAL, Args...>& function) {
        Graph::Series* series = Graph::data.find((void*)function);
        if (!series)
          series = Graph::data.add();
        if (series) {
          dirty = true;
          if (!axes.x.valid())
            axes.x = { -1, 1 };
          series->plot(function, axes.x);
        }
      }
 
            /// Plot the given function of x
      template<typename TYPE>
      void plot(TYPE(*function)(TYPE)) {
        Graph::Series* series = Graph::data.find((void*)function);
        if (!series)
          series = Graph::data.add();
        if (series) {
          dirty = true;
          if (!axes.x.valid())
            axes.x = { -1, 1 };
          series->plot(function, axes.x);
        }
      }
 
            /// Plot the given function for x plus additional arguments
      template<typename FUNCTION, typename... VALUES>
      void plot(FUNCTION f, VALUES... values) {
        thread_local static Function fun(f);
        Graph::Series* series = Graph::data.find((void*)fun);
        if (!series)
          series = Graph::data.add();
        if (series) {
          dirty = true;
          if (!axes.x.valid())
            axes.x = { -1, 1 };
          series->plot(fun.with(values...), axes.x);
        }
      }
 
            /// Add a data point (incrementing x)
      template<typename TYPE>
      void add(TYPE y) { data[0].add(y); dirty = true; }
            /// Add a data point
      void add(const Point pt) { data[0].add(pt); dirty = true; }
 
            /// Add a data point (incrementing x)
      template<typename TYPE>
      Graph& operator+=(TYPE y) { add(y); return *this; }
            /// Add a data point
      Graph& operator+=(const Point pt) { add(pt); return *this; }
 
            /// Plot the given function of x
      template<typename TYPE>
      Graph& operator=(TYPE(*function)(TYPE)) {
        plot(function);
        return *this;
      }
 
            /// Plot the given data points
      Graph& operator=(std::initializer_list<Point> values) {
        clear(); return operator+=(values);
      }
 
            /// Plot the given data points
      Graph& operator+=(std::initializer_list<Point> values) {
        for (const auto& value : values)
          add(value);
        return *this;
      }
 
            /// Plot the given function for x plus additional arguments
      template<typename... Args> Graph& operator<<(Function<Args...>& function) {
        plot(function.with());
        return *this;
      }
 
      template<typename TYPE> Graph& operator<<(TYPE& in) { add(in); return *this; } // with processing
      template<typename TYPE> Graph& operator<<(const TYPE& in) { add(in); return *this; } // without/after processing
 
      // returns the user-defined axes
      const Axes& getAxes() const { return axes; }
 
      // calculates axes based on data
      void getAxes(Axes& axes) const {
        if (!axes.x.valid()) {
          axes.x.clear();
          for (int s = 0; s < GRAPH_SERIES; s++)
            axes.x.from(data[s], &Point::x);
          if (!axes.y.valid() && axes.y.max != 0)
            axes.y.min = 0;
        }
        if (!axes.y.valid()) {
          axes.y.clear();
          for (int s = 0; s < GRAPH_SERIES; s++)
            axes.y.from(data[s], &Point::y);
          if (!axes.y.valid() && axes.y.max != 0)
            axes.y.min = 0;
        }
      }
 
      const Data& getData() const { return data; }
      bool isDirty() const { return dirty; }
      void setDirty(bool dirty) { Graph::dirty = dirty; }
 
      void truncate(unsigned int count) {
        if (count < data.count)
          data.count = count;
 
        for (int s = 0; s < GRAPH_SERIES; s++)
          if (count < data[s].count)
            data[s].count = count;
      }
 
    protected:
      Axes axes;
      Data data;
      bool dirty = false;
    };
 
    template<int SIZE>
    inline typename Graph<SIZE>::Series& Graph<SIZE>::Point::operator>>(Graph<SIZE>::Series& series) {
      series.add(*this);
      return series;
    }
 
        /// Audio oscillator object (output)
    template<typename SIGNAL>
    struct Oscillator : public Generator<SIGNAL> {
    protected:
      Phase increment;        // phase increment (per sample, in seconds or samples)
      Phase position = 0;       // phase position (in radians or wavetable size)
    public:
      Frequency frequency = 1000.f; // fundamental frequency of oscillator (in Hz)
      Phase offset = 0;       // phase offset (in radians - e.g. for modulation)
 
            virtual ~Oscillator() { }
      virtual void reset() { position = 0; }
 
      using Generator<SIGNAL>::set;
      virtual void set(param frequency) {
        Oscillator::frequency = frequency;
        increment = frequency * 2.f * pi.f / fs;
      }
 
      virtual void set(param frequency, param phase) {
        position = phase;
        set(frequency);
      }
 
      virtual void set(param frequency, relative phase) {
        set(frequency);
        set(phase);
      }
 
      virtual void set(relative phase) {
        offset = phase * (2 * pi);
      }
    };
  }
 
    /// Audio input object (mono)
  struct Input : Generic::Input<signal> { };
    /// Audio output object (mono)
  struct Output : Generic::Output<signal> { };
    /// Signal generator object (mono)
  struct Generator : Generic::Generator<signal> { };
    /// Signal modifier object (mono input-output)
  struct Modifier : public Generic::Modifier<signal> { };
    /// Audio oscillator object  (mono output)
  struct Oscillator : Generic::Oscillator<signal> { };
 
    /// @cond
  template <typename TYPE, typename SIGNAL>
  using GeneratorOrModifier = typename std::conditional<std::is_base_of<Generator, TYPE>::value, Generic::Generator<SIGNAL>,
                typename std::conditional<std::is_base_of<Modifier, TYPE>::value, Generic::Modifier<SIGNAL>, void>::type>::type;
    /// @endcond
 
    /// A parallel bank of multiple audio objects
  template<typename TYPE, int COUNT>
  struct Bank : public GeneratorOrModifier<TYPE, signals<COUNT>> {
    using GeneratorOrModifier<TYPE, signals<COUNT>>::in;
    using GeneratorOrModifier<TYPE, signals<COUNT>>::out;
 
    TYPE items[COUNT];
 
    TYPE& operator[](int index) { return items[index]; }
    const TYPE& operator[](int index) const { return items[index]; }
 
    template<typename... Args>
    void set(Args... args) {
      for (int n = 0; n < COUNT; n++)
        items[n].set(args...);
    }
 
    void input() override {
      for (int n = 0; n < COUNT; n++)
        in[n] >> items[n];
    }
 
    void process() override {
      for (int n = 0; n < COUNT; n++)
        items[n] >> out[n];
    }
  };
 
  /// Applies a function to a signal (input-output)
  template<typename... Args>
  struct Function : public Generic::Function<signal, Args...> {
 
    //static float Identity(float x) { return x; }
 
    //Function() : Generic::Function<signal, float>([](float x) -> float { return x; }) { }
 
    Function() : Generic::Function<signal, Args...>(nullptr) { }
 
    Function(std::function<float(Args...)> function) : Generic::Function<signal, Args...>(function) { }
 
    using Generic::Function<signal, Args...>::operator>>;
  };
 
    /// A line graph plotter
  struct Graph : public Generic::Graph<GRAPH_SIZE> {
    using Generic::Graph<GRAPH_SIZE>::operator=;
    using Generic::Graph<GRAPH_SIZE>::plot;
 
    /// Plot the given function for x plus additional arguments
    template<typename... Args> Graph& operator<<(Function<Args...>& function) {
      plot(function.with());
      return *this;
    }
  };
 
    /// @cond
  struct GraphPtr {
    std::unique_ptr<Graph> ptr;
 
    void check() {
      if (ptr.get() == nullptr)
        ptr = std::make_unique<Graph>();
    }
 
    Graph* operator->() { check(); return (klang::Graph*)ptr.get(); }
    operator Graph* () {  check(); return (klang::Graph*)ptr.get(); }
    operator Graph& () {  check(); return *(klang::Graph*)ptr.get(); }
 
    void clear() { check(); ptr->clear(); }
    bool isActive() const { return ptr ? ptr->isActive() : false; }
 
    Graph& operator()(double min, double max) { check(); return (Graph&)ptr->operator()(min, max);  }
 
    Graph::Series& operator[](int index) { check(); return ptr->operator[](index); }
    const Graph::Series& operator[](int index) const { static const Graph::Series none = Graph::Series(); return ptr ? ptr->operator[](index) : none; }
 
    Graph& operator()(double x_min, double x_max, double y_min, double y_max) { check(); return (Graph&)ptr->operator()(x_min, x_max, y_min, y_max); }
 
    operator Graph::Series& () { check(); return ptr->operator Graph::Series& (); }
 
    template<typename SIGNAL, typename... Args>
    void plot(Generic::Function<SIGNAL, Args...>& function) { check(); ((Graph*)(ptr.get()))->plot(function); }
 
    template<typename TYPE>
    void plot(TYPE(*function)(TYPE)) { check(); ((Graph*)(ptr.get()))->plot(function); }
 
    template<typename FUNCTION, typename... VALUES>
    void plot(FUNCTION f, VALUES... values) { check(); ((Graph*)(ptr.get()))->plot(f, values...); }
 
    template<typename TYPE> void add(TYPE y) { check(); ptr->add(y); }
    void add(const Graph::Point pt) { check(); ptr->add(pt); }
 
    template<typename TYPE> Graph& operator+=(TYPE y) { check(); return ptr->operator+=(y); }
    Graph& operator+=(const Graph::Point pt) { check(); return (Graph&)ptr->operator+=(pt); }
 
    template<typename TYPE> Graph& operator=(TYPE(*function)(TYPE)) { check(); return (Graph&)ptr->operator=(function); }
 
    Graph& operator=(std::initializer_list<Graph::Point> values) { check(); return (Graph&)ptr->operator=(values); }
    Graph& operator+=(std::initializer_list<Graph::Point> values) { check(); return (Graph&)ptr->operator+=(values); }
 
    template<typename... Args> Graph& operator<<(Generic::Function<Args...>& function) { plot(function.with()); return *this; }
    template<typename TYPE> Graph& operator<<(TYPE& in) { add(in); return *this; } // with processing
    template<typename TYPE> Graph& operator<<(const TYPE& in) { add(in); return *this; } // without/after processing
 
    const Graph::Axes& getAxes() const { static const Graph::Axes none; return ptr ? ptr->getAxes() : none; }
    void getAxes(Graph::Axes& axes) { check(); ptr->getAxes(axes); }
 
    const Graph::Data& getData() { check(); return ptr->getData(); }
    bool isDirty() const { return ptr ? ptr->isDirty() : false; }
    void setDirty(bool dirty) { if (ptr) ptr->setDirty(dirty); }
 
    void truncate(unsigned int count) { check(); ptr->truncate(count); }
  };
    /// @endcond
 
 
 
    // deduction guide for functions
    template <typename... Args>
    Function(float(*)(Args...)) -> Function<Args...>;
 
  //// deduction guide for functions
  //Function() -> Function<float>;
 
  THREAD_LOCAL static GraphPtr graph;
 
  template<typename SIGNAL, typename... Args>
  inline GraphPtr& Generic::Function<SIGNAL, Args...>::operator>>(klang::GraphPtr& graph) {
    graph.plot(*this);
    return graph;
  }
 
  template<typename TYPE>
  static GraphPtr& operator>>(TYPE(*function)(TYPE), klang::GraphPtr& graph) {
    graph->plot(function);
    return graph;
  }
 
  template<typename SIGNAL, typename... Args>
  inline Graph& Generic::Function<SIGNAL, Args...>::operator>>(klang::Graph& graph) {
    graph.plot(*this);
    return graph;
  }
 
  template<typename TYPE>
  static Graph& operator>>(TYPE(*function)(TYPE), Graph& graph) {
    graph.plot(function);
    return graph;
  }
 
  // syntax equivalence: a = b is the same as b >> a
  inline signal& signal::operator=(Output& b) {
    b >> *this;
    return *this;
  }
 
  // supports summing of multiple outputs
  inline signal& signal::operator+=(Output& in) { // e.g. out += osc;
    value += signal(in);
    return *this;
  }
 
    /// Square root function (audio object)
  inline static Function<float> sqrt(SQRTF);
    /// Absolute/rectify function (audio object)
  inline static Function<float> abs(FABS);
    /// Square function (audio object)
  inline static Function<float> sqr([](float x) -> float { return x * x; });
    /// Cube function (audio object)
  inline static Function<float> cube([](float x) -> float { return x * x * x; });
 
  #define sqrt klang::sqrt // avoid conflict with std::sqrt
  #define abs klang::abs   // avoid conflict with std::abs
 
    /// Debug text output
  struct Console : public Text<16384> {
    static std::mutex _lock;
    THREAD_LOCAL static Text<16384> last;
    int length = 0;
 
    void clear() {
      length = 0;
      string[0] = 0;
    }
 
    Console& operator=(const char* in) {
      std::lock_guard<std::mutex> lock(_lock);
      length = std::min(capacity(), (int)strlen(in));
      memcpy(string, in, length);
      string[length] = 0;
      return *this;
    }
 
    Console& operator=(const Console& in) {
      std::lock_guard<std::mutex> lock(_lock);
      length = std::min(capacity(), in.length);
      memcpy(string, in.string, length);
      string[length] = 0;
      return *this;
    }
 
    Console& operator+=(const char* in) {
      std::lock_guard<std::mutex> lock(_lock);
      const int len = std::max(0, std::min(capacity() - length, (int)strlen(in)));
      memcpy(&string[length], in, len);
      length += len;
      string[length] = 0;
      memcpy(&last, in, len);
      last.string[len] = 0;
      return *this;
    }
 
    bool hasText() const {
      return length != 0;
    }
 
    int getText(char* buffer) {
      //if (!length) return 0;
      std::lock_guard<std::mutex> lock(_lock);
      const int _length = length;
      memcpy(buffer, string, length);
      buffer[length] = 0; // null terminator
      clear();
      return _length;
    }
  };
 
  inline THREAD_LOCAL Text<16384> Console::last;
 
#define PROFILE(func, ...) debug.print("%-16s = %fns\n", #func "(" #__VA_ARGS__ ")", debug.profile(1000, func, __VA_ARGS__));
 
    /// The Klang debug interface
  struct Debug : Input {
 
        /// Audio buffer for debug output
    struct Buffer : private buffer {
      using buffer::clear;
      using buffer::rewind;
      using buffer::operator++;
      using buffer::operator signal&;
 
      Buffer() : buffer(16384) { }
 
      enum Content {
        Empty = 0,
        Notes = 1,
        Effect = 2,
        Synth = 3,
      } content = Empty;
 
      /*    void attach(float* buffer, int size) {
            Debug::buffer = new klang::buffer(buffer, size);
          }
 
          void detach() {
            klang::buffer* tmp = buffer;
            buffer = nullptr;
            delete tmp;
          }*/
 
      bool active = false;
      int used = 0;
 
      const float* get() {
        if (active) {
          active = false;
          return data();
        }
        else {
          return nullptr;
        }
      }
 
      Buffer& operator+=(const signal in) {
        active = true;
        buffer::operator+=(in);
        return *this;
      }
 
      template<typename TYPE>
      Buffer& operator+=(TYPE& in) {
        active = true;
        buffer::operator+=(in);
        return *this;
      }
 
      signal& operator>>(signal& destination) const {
        destination << *ptr;
        return destination;
      }
 
      operator const signal& () const {
        return *ptr;
      }
    };
 
    THREAD_LOCAL static Buffer buffer; // support multiple threads/instances
 
        /// Debug console output
    Console console;
 
    template <typename Func, typename... Args>
    inline static double profile(Func func, Args... args) {
      using namespace std::chrono;
 
      auto start = high_resolution_clock::now();
      func(args...);
      auto end = high_resolution_clock::now();
 
      auto duration = duration_cast<nanoseconds>(end - start).count();
      return (double)duration;
    }
 
    template <typename Func, typename... Args>
    inline static double profile(int times, Func func, Args... args) {
      double sum = 0;
      while (times--) {
        sum += profile(func, args...);
      }
      return sum / 1000000.0;
    }
 
        /// @cond
    struct Session {
      Session(float*, int size, Buffer::Content content) {
        //if (buffer) {
          //debug.attach(buffer, size);
        if (buffer.content != Buffer::Notes)
          buffer.clear(size);
        buffer.content = content;
        buffer.rewind();
        //}
      }
      ~Session() {
        //debug.detach();
      }
 
      bool hasAudio() const {
        return buffer.active;
      }
      const float* getAudio() const {
        return buffer.get();
      }
    };
        /// @endcond
 
    void print(const char* format, ...) {
      if (console.length < 10000) {
        THREAD_LOCAL static char string[1024] = { 0 };
        string[0] = 0;
        va_list args;                     // Initialize the variadic argument list
        va_start(args, format);           // Start variadic argument processing
        vsnprintf(string, 1024, format, args);  // Safely format the string into the buffer
        va_end(args);                     // Clean up the variadic argument list
        console += string;
      }
    }
 
    void printOnce(const char* format, ...) {
      if (console.length < 1024) {
        THREAD_LOCAL static char string[1024] = { 0 };
        string[0] = 0;
        va_list args;                     // Initialize the variadic argument list
        va_start(args, format);           // Start variadic argument processing
        vsnprintf(string, 1024, format, args);  // Safely format the string into the buffer
        va_end(args);                     // Clean up the variadic argument list
 
        if (console.last != string)
          console += string;
      }
    }
 
    bool hasText() const {
      return console.hasText();
    }
 
    int getText(char* buffer) {
      return console.getText(buffer);
    }
 
    operator const signal& () const {
      return buffer.operator const klang::signal & ();
    }
 
    using Input::input;
    void input() override {
      buffer += in;
    }
  };
 
  //inline static Debug::Buffer& operator>>(const signal source, Debug& debug) {
  //  return debug.buffer += source;
  //}
 
  //template<typename TYPE>
  //inline static Debug::Buffer& operator>>(TYPE& source, Debug& debug) {
  //  return debug.buffer += source;
  //}
 
  static Debug debug;
  inline THREAD_LOCAL Debug::Buffer Debug::buffer; //
  inline std::mutex Console::_lock;
 
#define FUNCTION(type) (void(*)(type, Result<type>&))[](type x, Result<type>& y)
 
    /// @cond
  template <typename TYPE>
  struct Result {
    TYPE* y = nullptr;
    int i = 0;
    TYPE sum = 0;
 
    Result(TYPE* array, int index) : y(&array[index]), i(index) { }
 
    TYPE& operator[](int index) {
      return *(y + index);
    }
 
    operator TYPE const () { return *y; }
 
    Result& operator=(const TYPE& in) {
      *y = in;
      return *this;
    }
 
    TYPE& operator++(int) { i++; return *++y; }
  };
    /// @endcond
 
    /// Lookup table object
  template<typename TYPE, int SIZE>
  struct Table : public Array<TYPE, SIZE> {
    typedef Array<TYPE, SIZE> Array;
    typedef Result<TYPE> Result;
 
    using Array::add;
 
    // single argument
    Table(TYPE(*function)(TYPE)) {
      for (int x = 0; x < SIZE; x++)
        add(function(x));
    }
 
    // double argument
    Table(void(*function)(TYPE, TYPE), TYPE arg) {
      Array::count = SIZE;
      for (int x = 0; x < SIZE; x++)
        Array::items[x] = function(x, arg);
    }
 
    // single argument (enhanced)
    Table(void(*function)(TYPE x, Result& y)) {
      Array::count = SIZE;
      Result y(Array::items, 0);
      for (int x = 0; x < SIZE; x++) {
        function((TYPE)x, y);
        y.sum += Array::items[x];
        y++;
      }
    }
 
    Table(std::initializer_list<TYPE> values) {
      for (TYPE value : values)
        add(value);
    }
 
    using Array::operator[];
    TYPE operator[](float index) {
      if (index < 0) return Array::items[0];
      else if (index >= (SIZE - 1)) return Array::items[SIZE - 1];
      else {
        const float x = std::floor(index);
        const int i = int(x);
        const float dx = index - x;
        const float dy = Array::items[i + 1] - Array::items[i];
        return Array::items[i] + dx * dy;
      }
    }
  };
 
    /// Audio delay object
  template<int SIZE>
  struct Delay : public Modifier {
    using Modifier::in;
    using Modifier::out;
 
    buffer buffer;
    float time = 1;
    int position = 0;
 
    Delay() : buffer(SIZE + 1, 0) { clear(); }
 
    void clear() {
      buffer.clear();
    }
 
    //void operator<<(const signal& input) override {
    void input() override {
      buffer++ = in;
      position++;
      if (buffer.finished()) {
        buffer.rewind();
        position = 0;
      }
    }
 
    signal tap(int delay) const {
      int read = (position - 1) - delay;
      if (read < 0)
        read += SIZE;
      return buffer[read];
    }
 
    signal tap(float delay) const {
      float read = (float)(position - 1) - delay;
      if (read < 0.f)
        read += SIZE;
 
      const float f = floor(read);
      delay = read - f;
 
      const int i = (int)read;
      const int j = (i == (SIZE - 1)) ? 0 : (i + 1);
 
      return buffer[i] * (1.f - delay) + buffer[j] * delay;
    }
 
    virtual void process() override {
      out = tap(time);
    }
 
    virtual void set(param delay) override {
      Delay::time = delay <= SIZE ? (float)delay : SIZE;
    }
 
    template<typename TIME>
    signal operator()(TIME& delay) {
      if constexpr (std::is_integral_v<TIME>)
        return tap((int)delay);
      else if constexpr (std::is_floating_point_v<TIME>)
        return tap((float)delay);
      else
        return tap((signal)delay);
    }
 
    template<typename TIME>
    signal operator()(const TIME& delay) {
      if constexpr (std::is_integral_v<TIME>)
        return tap((int)delay);
      else if constexpr (std::is_floating_point_v<TIME>)
        return tap((float)delay);
      else
        return tap((signal)delay);
    }
 
    unsigned int max() const { return SIZE; }
  };
 
    /// Wavetable-based oscillator
  class Wavetable : public Oscillator {
    using Oscillator::set;
  protected:
    buffer buffer;
    const int size;
  public:
    Wavetable(int size = 2048) : buffer(size), size(size) { }
 
    template<typename TYPE>
    Wavetable(TYPE oscillator, int size = 2048) : buffer(size), size(size) {
      operator=(oscillator);
    }
 
    signal& operator[](int index) {
      return buffer[index];
    }
 
    template<typename TYPE>
    Wavetable& operator=(TYPE& oscillator) {
      oscillator.set(fs / size);
      for (int s = 0; s < size; s++)
        buffer[s] = oscillator;
      return *this;
    }
 
    virtual void set(param frequency) override {
      Oscillator::frequency = frequency;
      increment = frequency * (size / fs);
    }
 
    virtual void set(param frequency, param phase) override {
      position = phase * float(size);
      set(frequency);
    }
 
    virtual void set(relative phase) override {
 
      offset = phase * float(size);
    }
 
    virtual void set(param frequency, relative phase) override {
      set(frequency);
      set(phase);
    }
 
    void process() override {
      position += { increment, size };
      out = buffer[position + offset /*klang::increment(offset, size)*/];
    }
  };
 
  /// Envelope object
  class Envelope : public Generator {
    using Generator::set;
 
  public:
 
    struct Follower;
 
    /// Abstract envelope ramp type
    struct Ramp : public Generator {
      float target;
      float rate;
      bool active = false;
    public:
 
      // Create a null ramp (full signal)
      Ramp(float value = 1.f) {
        setValue(value);
      }
 
      // Create a ramp from start to target over time (in seconds)
      Ramp(float start, float target, float time) {
        setValue(start);
        setTarget(target);
        setTime(time);
      }
 
      virtual ~Ramp() { }
 
      // Is ramp currently processing (ramping)?
      bool isActive() const {
        return active;
      }
 
      // Set a new target (retains rate)
      virtual void setTarget(float target) {
        Ramp::target = target;
        active = (out != target);
      }
 
      // Immediately jump to value (disables ramp)
      virtual void setValue(float value) {
        out = value;
        Ramp::target = value;
        active = false;
      }
 
      // Set rate of change (per sample)
      virtual void setRate(float rate) { Ramp::rate = rate; }
 
      // Set rate of change (by duration)
      virtual void setTime(float time) { Ramp::rate = time ? 1.f / (time * fs) : 0; }
 
      // Return the current output and advanced the ramp
      virtual signal operator++(int) = 0;
 
      void process() override { /* do nothing -> only process on ++ */ }
    };
 
    /// Linear envelope ramp (default)
    struct Linear : public Ramp {
 
      // Return the current output and process the next
      signal operator++(int) override {
        const signal output = out;
 
        if (active) {
          if (target > out) {
            out += rate;
            if (out >= target) {
              out = target;
              active = false;
            }
          }
          else {
            out -= rate;
            if (out <= target) {
              out = target;
              active = false;
            }
          }
        }
 
        return output;
      }
    };
 
        /// Envelope stage
    enum Stage { Sustain, Release, Off };
        /// Envelope mode
    enum Mode { Time, Rate };
 
    /// Envelope point (x,y)
    struct Point {
      float x, y;
 
      Point() : x(0), y(0) { }
 
      template<typename T1, typename T2>
      Point(T1 x, T2 y) : x(float(x)), y(float(y)) { }
    };
 
        /// @cond
    // Linked-list of points (for inline initialisation)
    struct Points : public Point {
      Points(float x, float y) {
        Point::x = x;
        Point::y = y;
        next = NULL;
      }
      ~Points() {
        delete next;
      }
 
      Points& operator()(float x, float y) {
        last().next = new Points(x, y);
        return *this;
      }
 
      Points& last() {
        return next ? next->last() : *this;
      }
 
      int count() const {
        return next ? 1 + next->count() : 1;
      }
 
      Points* next;
    };
        /// @endcond
 
    /// Envelope loop
    struct Loop {
      Loop(int from = -1, int to = -1) : start(from), end(to) {}
 
      void set(int from, int to) { start = from; end = to; }
      void reset() { start = end = -1; }
 
      bool isActive() const { return start != -1 && end != -1; }
 
      int start;
      int end;
    };
 
    // Default Envelope (full signal)
    Envelope() : ramp(new Linear()) {                   set(Points(0.f, 1.f));  }
 
    // Creates a new envelope from a list of points, e.g. Envelope env = Envelope::Points(0,1)(1,0);
    Envelope(const Points& points) : ramp(new Linear()) {         set(points);      }
 
    // Creates a new envelope from a list of points, e.g. Envelope env = { { 0,1 }, { 1,0 } };
    Envelope(std::initializer_list<Point> points) : ramp(new Linear()) {  set(points);      }
 
    // Creates a copy of an envelope from another envelope
    Envelope(const Envelope& in) : ramp(new Linear()) {           set(in.points);     }
 
    virtual ~Envelope() { }
 
    // Checks if the envelope is at a specified stage (Sustain, Release, Off)
    bool operator==(Stage stage) const { return Envelope::stage == stage; }
    bool operator!=(Stage stage) const { return Envelope::stage != stage; }
 
    operator float() const { return out; }
 
    // assign points (without recreating envelope)
    Envelope& operator=(std::initializer_list<Point> points) {
      set(points);
      return *this;
    }
 
    // Sets the envelope based on an array of points
    void set(const std::vector<Point>& points) {
      Envelope::points = points;
      initialise();
    }
 
    // Sets the envelope from a list of points, e.g. env.set( Envelope::Points(0,1)(1,0) );
    void set(const Points& point){
      points.clear();
 
      const Points* pPoint = &point;
      while(pPoint){
        points.push_back(*pPoint);
        pPoint = pPoint->next;
      }
 
      initialise();
    }
 
    // Converts envelope points based on relative time to absolute time
    void sequence() {
      float time = 0.f;
      for(Point& point : points) {
        const float delta = point.x;
        time += delta + 0.00001f;
        point.x = time;
      }
      initialise();
    }
 
    // Sets an envelope loop between two points
    void setLoop(int startPoint, int endPoint){
      if(startPoint >= 0 && endPoint < points.size())
        loop.set(startPoint, endPoint);
    }
 
    // Retrieve value at time (in seconds)
    signal at(param time) const {
      if (points.empty()) return 0;
      Point last = { 0, points[0].y };
      for (const Point& point : points) {
        if (point.x >= time) {
          const float dx = point.x - last.x;
          const float dy = point.y - last.y;
          const float x = time - last.x;
          return dx == 0 ? last.y : (last.y + x * dy / dx);
        }
        last = point;
      }
      return points.back().y;
    }
 
    // Resets the envelope loop
    void resetLoop(){
      loop.reset();
      if(stage == Sustain && (point+1) < points.size())
        setTarget(points[point+1], points[point].x);
    }
 
    // Sets the current stage of the envelope
    void setStage(Stage stage){ this->stage = stage; }
 
    // Returns the current stage of the envelope
    const Stage getStage() const { return stage; }
 
    // Returns the total length of the envelope (ignoring loops)
    float getLength() const { return points.size() ? points[points.size() - 1].x : 0.f; }
 
    // Trigger the release of the envelope
    virtual void release(float time, float level = 0.f){
      stage = Release;
      setTarget({ time, level }, 0);
      //ramp->setTime(time);
      //ramp->setTarget(0.f);
    }
 
    // Returns true if the envelope has finished (is off)
    bool finished() const {
      return getStage() == Stage::Off;
    }
 
    // Prepare envelope to (re)start
    void initialise(){
      point = 0;
      timeInc = 1.0f / fs;
      loop.reset();
      stage = Sustain;
      if(points.size()){
        out = points[0].y;
        ramp->setValue(points[0].y);
        if(points.size() > 1)
          setTarget(points[1], points[0].x);
      }else{
        out = 1.0f;
        ramp->setValue(1.0f);
      }
    }
 
    // Scales the envelope duration to specified length 
    void resize(float length){
      const float old_length = getLength();
      if(old_length == 0.0)
        return;
 
      const float multiplier = length / (fs * old_length);
      std::vector<Point>::iterator point = points.begin();
      while(point != points.end()){
        point->x *= multiplier;
        point++;
      }
 
      initialise();
    }
 
    // Set the current envelope target
    void setTarget(const Point& point, float time = 0.0){
      (this->*setTargetFunction)(point, time);
    }
 
    // Returns the output of the envelope and advances the envelope.
    signal& operator++(int){
      out = (*ramp)++;
 
      switch(stage){
      case Sustain:
        time += timeInc;
        if (!ramp->isActive()) { // envelop segment end reached
          if (loop.isActive() && (point + 1) >= loop.end) {
            point = loop.start;
            ramp->setValue(points[point].y);
            if (loop.start != loop.end)
              setTarget(points[point + 1], points[point].x);
          } else if ((point + 1) < points.size()) {
            if (mode() == Rate || time >= points[point + 1].x) { // reached target point
              point++;
              ramp->setValue(points[point].y); // make sure exact value is set
 
              if ((point + 1) < points.size()) // new target point?
                setTarget(points[point + 1], points[point].x);
            }
          } else {
            stage = Off;
          }
        } break;
      case Release:
        if (!ramp->isActive()) //if(out == 0.0)
          stage = Off;
        break;
      case Off:
        break;
      }
 
      return out;
    }
 
    void process() override { /* do nothing -> only process on ++ */
      out = *ramp;
    }
 
    // Retrieve a specified envelope point (read-only)
    const Point& operator[](int point) const {
      return points[point];
    }
 
    // Set the Ramp class (default: Envelope::Linear)
    void set(Ramp* ramp) {
      Envelope::ramp = std::shared_ptr<Ramp>(ramp);
      initialise();
    }
 
    void setMode(Mode mode) {
      if (mode == Time)
        setTargetFunction = &Envelope::setTargetTime;
      else
        setTargetFunction = &Envelope::setTargetRate;
    }
 
    Mode mode() const { return setTargetFunction == &Envelope::setTargetTime ? Time : Rate; }
 
  protected:
 
    void (Envelope::* setTargetFunction)(const Point& point, float time) = &Envelope::setTargetTime;
 
    void setTargetTime(const Point& point, float time = 0.0) {
      this->time = time;
      ramp->setTarget(point.y);
      ramp->setRate(abs(point.y - ramp->out) / ((point.x - time) * fs));
    }
 
    void setTargetRate(const Point& point, float rate = 0.0) {
      this->time = 0;
      if (point.x == 0) {
        ramp->setValue(point.y);
      } else {
        ramp->setTarget(point.y);
        ramp->setRate(point.x);
      }
    }
 
    std::vector<Point> points;
    Loop loop;
 
    int point;
    float time, timeInc;
    Stage stage;
 
    std::shared_ptr<Ramp> ramp;
  };
 
    /// Attack-Decay-Sustain-Release Envelope
  struct ADSR : public Envelope {
  private:
    using Envelope::Follower;
  public:
    param A, D, S, R;
 
    enum Mode { Time, Rate } mode = Time;
 
    ADSR() { set(0.5, 0.5, 1, 0.5); }
 
    void set(param attack, param decay, param sustain, param release) override {
      A = attack + 0.005f;
      D = decay + 0.005f;
      S = sustain;
      R = release + 0.005f;
 
      points.resize(3);
      points[0] = { 0, 0 };
      points[1] = { A, 1 };
      points[2] = { A + D, S };
 
      initialise();
      setLoop(2, 2);
    }
 
    void release(float time = 0.f, float level = 0.f) override {
      Envelope::release(time ? time : float(R), level);
    }
 
    bool operator==(Envelope::Stage stage) const {
      return getStage() == stage;
    }
  };
 
    /// FM operator
  template<class OSCILLATOR>
  struct Operator : public OSCILLATOR, public Input {
    Envelope env;
    Amplitude amp = 1.f;
 
    Operator& operator()(param f) { OSCILLATOR::set(f); return *this; }
    Operator& operator()(param f, relative phase) { OSCILLATOR::set(f, phase); return *this; }
    Operator& operator()(relative phase) { OSCILLATOR::set(phase); return *this; }
 
    virtual Operator& operator=(const Envelope::Points& points) {
      env = points;
      return *this;
    }
 
    virtual Operator& operator=(const Envelope& points) {
      env = points;
      return *this;
    }
 
    Operator& operator*(float amp) {
      Operator::amp = amp;
      return *this;
    }
 
    virtual void process() override {
      OSCILLATOR::set(+in);
      OSCILLATOR::process();
      OSCILLATOR::out *= env++ * amp;
    }
 
    inline Operator& operator>>(Operator& carrier) {
      carrier << *this;
      return carrier;
    }
  };
 
  template<class OSCILLATOR>
  inline const signal& operator>>(klang::signal modulator, Operator<OSCILLATOR>& carrier) {
    carrier << modulator;
    return carrier;
  }
 
    /// Base class for UI / MIDI controll
  struct Controller {
  protected:
    virtual event control(int index, float value) { };
    virtual event preset(int index) { };
    virtual event midi(int status, int byte1, int byte2) { };
  public:
    virtual void onControl(int index, float value) { control(index, value); };
    virtual void onPreset(int index) { preset(index); };
    virtual void onMIDI(int status, int byte1, int byte2) { midi(status, byte1, byte2); }
  };
 
    /// Base class for mini-plugin
  struct Plugin : public Controller {
    virtual ~Plugin() { }
 
    Controls controls;
    Presets presets;
  };
 
    /// Effect mini-plugin (mono)
  struct Effect : public Plugin, public Modifier {
    virtual ~Effect() { }
 
    virtual void prepare() { };
    virtual void process() { out = in; }
    virtual void process(buffer buffer) {
      prepare();
      while (!buffer.finished()) {
        input(buffer);
        process();
        buffer++ = out;
        debug.buffer++;
      }
    }
  };
 
    /// Base class for synthesiser notes
  template<class SYNTH>
  class NoteBase : public Controller {
    SYNTH* synth;
 
    class Controls {
      klang::Controls* controls = nullptr;
    public:
      Controls& operator=(klang::Controls& controls) { Controls::controls = &controls; return *this; }
      signal& operator[](int index) { return controls->operator[](index).operator signal&(); }
      const signal& operator[](int index) const { return controls->operator[](index).operator const signal&(); }
      unsigned int size() { return controls ? controls->size() : 0; }
    };
 
  protected:
    virtual event on(Pitch p, Velocity v) { }
    virtual event off(Velocity v = 0) { stage = Off; }
 
    SYNTH* getSynth() { return synth; }
  public:
    Pitch pitch;
    Velocity velocity;
    Controls controls;
 
    NoteBase() : synth(nullptr) { }
    virtual ~NoteBase() { }
 
    void attach(SYNTH* synth) {
      NoteBase::synth = synth;
      controls = synth->controls;
      init();
    }
 
    virtual void init() { }
 
    virtual void start(Pitch p, Velocity v) {
      stage = Onset;
      pitch = p;
      velocity = v;
      on(pitch, velocity);
      stage = Sustain;
    }
 
    virtual bool release(Velocity v = 0) {
      if (stage == Off)
        return true;
 
      if (stage != Release) {
        stage = Release;
        off(v);
      }
 
      return stage == Off;
    }
 
    virtual bool stop(Velocity v = 0) {
      stage = Off;
      return true;
    }
 
    bool finished() const { return stage == Off; }
 
    enum Stage { Onset, Sustain, Release, Off } stage = Off;
 
    virtual void controlChange(int controller, int value) { midi(0xB0, controller, value); };
  };
 
  struct Synth;
 
  /// Synthesiser note (mono)
  struct Note : public NoteBase<Synth>, public Generator {
    virtual void prepare() { }
    virtual void process() override = 0;
    virtual bool process(buffer buffer) {
      prepare();
      while (!buffer.finished()) {
        process();
        buffer++ = out;
        debug.buffer++;
      }
      return !finished();
    }
    virtual bool process(buffer* buffer) {
      return process(buffer[0]);
    }
  };
 
    /// Synthesiser note array
  template<class SYNTH, class NOTE = Note>
  struct Notes : Array<NOTE*, 128> {
    SYNTH* synth;
    typedef Array<NOTE*, 128> Array;
    using Array::items;
    using Array::count;
 
    Notes(SYNTH* synth) : synth(synth) {
      for (int n = 0; n < 128; n++)
        items[n] = nullptr;
    }
    virtual ~Notes();
 
    template<class TYPE>
    void add(int count) {
      for (int n = 0; n < count; n++) {
        TYPE* note = new TYPE();
        note->attach(synth);
        Array::add(note);
      }
    }
 
    // returns index of a 'free' note (stealing oldest, if required)
    unsigned int noteOns = 0;       // number of NoteOn events processed
    unsigned int noteStart[128] = { 0 };  // track age of notes (for note stealing)
 
    int assign(){
      // favour unused voices
      for (int i = 0; i < count; i++) {
        if (items[i]->stage == NOTE::Off){
          noteStart[i] = noteOns++;
          return i;
        }
      }
 
      // no free notes => steal oldest released note?
      int oldest = -1;
      unsigned int oldest_start = 0;
      for (int i = 0; i < count; i++) {
        if (items[i]->stage == NOTE::Release) {
          if(oldest == -1 || noteStart[i] < oldest_start){
            oldest = i;
            oldest_start = noteStart[i];
          }
        }
      }
      if(oldest != -1){
        noteStart[oldest] = noteOns++;
        return oldest;
      }
 
      // no available released notes => steal oldest playing note
      oldest = -1;
      oldest_start = 0;
      for (int i = 0; i < count; i++) {
        if(oldest == -1 || noteStart[i] < oldest_start){
          oldest = i;
          oldest_start = noteStart[i];
        }
      }
      noteStart[oldest] = noteOns++;
      return oldest;
    }
  };
 
  /// Synthesiser object (mono)
  struct Synth : public Effect {
    typedef Note Note;
 
    Notes<Synth, Note> notes;
 
    Synth() : notes(this) { }
    virtual ~Synth() { }
 
    //virtual void presetLoaded(int preset) { }
    //virtual void optionChanged(int param, int item) { }
    //virtual void buttonPressed(int param) { };
 
    int indexOf(Note* note) const {
      int index = 0;
      for (const auto* n : notes.items) {
        if (note == n)
          return index;
        index++;
      }
      return -1; // not found
    }
 
    // pass to synth and notes
    virtual event onControl(int index, float value) override {
      control(index, value);
      for (unsigned int n = 0; n < notes.count; n++)
        notes[n]->onControl(index, value);
    };
 
    // pass to synth and notes
    virtual event onPreset(int index) override {
      preset(index);
      for (unsigned int n = 0; n < notes.count; n++)
        notes[n]->onPreset(index);
    };
  };
 
  template<class SYNTH, class NOTE>
  inline Notes<SYNTH, NOTE>::~Notes() {
    for (unsigned int n = 0; n < count; n++) {
      NOTE* tmp = items[n];
      items[n] = nullptr;
      delete tmp;
    }
  }
 
  namespace Mono { using namespace klang; }
  namespace mono { using namespace klang; }
 
    /// Objects supporting stereo audio functionality.
  namespace Stereo {
        /// Stereo audio signal
    typedef signals<2> signal;
 
        /// Stereo sample frame
    struct frame {
      mono::signal& l;
      mono::signal& r;
 
      frame(mono::signal& left, mono::signal& right) : l(left), r(right) { }
      frame(signal& signal) : l(signal.l), r(signal.r) { }
 
      frame& operator+=(const frame& x) { l += x.l; r += x.r; return *this; }
      frame& operator-=(const frame& x) { l -= x.l; r -= x.r; return *this; }
      frame& operator*=(const frame& x) { l *= x.l; r *= x.r; return *this; }
      frame& operator/=(const frame& x) { l /= x.l; r /= x.r; return *this; }
 
      frame& operator+=(const signal x) { l += x.l; r += x.r; return *this; }
      frame& operator-=(const signal x) { l -= x.l; r -= x.r; return *this; }
      frame& operator*=(const signal x) { l *= x.l; r *= x.r; return *this; }
      frame& operator/=(const signal x) { l /= x.l; r /= x.r; return *this; }
 
      frame& operator+=(const mono::signal x) { l += x; r += x; return *this; }
      frame& operator-=(const mono::signal x) { l -= x; r -= x; return *this; }
      frame& operator*=(const mono::signal x) { l *= x; r *= x; return *this; }
      frame& operator/=(const mono::signal x) { l /= x; r /= x; return *this; }
 
      frame& operator+=(float x) { l += x; r += x; return *this; }
      frame& operator-=(float x) { l -= x; r -= x; return *this; }
      frame& operator*=(float x) { l *= x; r *= x; return *this; }
      frame& operator/=(float x) { l /= x; r /= x; return *this; }
 
      frame& operator+=(double x) { l += (float)x; r += (float)x; return *this; }
      frame& operator-=(double x) { l -= (float)x; r -= (float)x; return *this; }
      frame& operator*=(double x) { l *= (float)x; r *= (float)x; return *this; }
      frame& operator/=(double x) { l /= (float)x; r /= (float)x; return *this; }
 
      frame& operator+=(int x) { l += (float)x; r += (float)x; return *this; }
      frame& operator-=(int x) { l -= (float)x; r -= (float)x; return *this; }
      frame& operator*=(int x) { l *= (float)x; r *= (float)x; return *this; }
      frame& operator/=(int x) { l /= (float)x; r /= (float)x; return *this; }
 
      signal operator+(const signal x) const { return { l + x.l, r + x.r }; }
      signal operator-(const signal x) const { return { l - x.l, r - x.r }; }
      signal operator*(const signal x) const { return { l * x.l, r * x.r }; }
      signal operator/(const signal x) const { return { l / x.l, r / x.r }; }
 
      signal operator+(const mono::signal x) const { return { l + x, r + x }; }
      signal operator-(const mono::signal x) const { return { l - x, r - x }; }
      signal operator*(const mono::signal x) const { return { l * x, r * x }; }
      signal operator/(const mono::signal x) const { return { l / x, r / x }; }
 
      signal operator+(float x) const { return { l + x, r + x }; }
      signal operator-(float x) const { return { l - x, r - x }; }
      signal operator*(float x) const { return { l * x, r * x }; }
      signal operator/(float x) const { return { l / x, r / x }; }
 
      signal operator+(double x) const { return { l + (float)x, r + (float)x }; }
      signal operator-(double x) const { return { l - (float)x, r - (float)x }; }
      signal operator*(double x) const { return { l * (float)x, r * (float)x }; }
      signal operator/(double x) const { return { l / (float)x, r / (float)x }; }
 
      signal operator+(int x) const { return { l + (float)x, r + (float)x }; }
      signal operator-(int x) const { return { l - (float)x, r - (float)x }; }
      signal operator*(int x) const { return { l * (float)x, r * (float)x }; }
      signal operator/(int x) const { return { l / (float)x, r / (float)x }; }
 
      frame& operator=(const signal& signal) {
        l = signal.l;
        r = signal.r;
        return *this;
      }
 
      mono::signal mono() const {
        return (l + r) * 0.5f;
      }
    };
 
        /// Audio input object (stereo)
        struct Input : Generic::Input<signal> { virtual ~Input() {} };
        /// Audio output object (stereo)
        struct Output : Generic::Output<signal> { virtual ~Output() {} };
        /// Signal generator object (stereo output)
        struct Generator : Generic::Generator<signal> { virtual ~Generator() {} };
        /// Signal modifier object (stereo, input-output)
        struct Modifier : Generic::Modifier<signal> { virtual ~Modifier() {} };
        /// Audio oscillator object (stereo, output)
        struct Oscillator : Generic::Oscillator<signal> { virtual ~Oscillator() {} };
 
    //inline Modifier& operator>>(signal input, Modifier& modifier) {
    //  modifier << input;
    //  return modifier;
    //}
 
        /// Stereo audio buffer
    // interleaved access to non-interleaved stereo buffers
    struct buffer {
      typedef Stereo::signal signal;
      mono::buffer& left, right;
 
      buffer(const buffer& buffer) : left(buffer.left), right(buffer.right) { rewind(); }
      buffer(mono::buffer& left, mono::buffer& right) : left(left), right(right) { rewind(); }
 
      operator const signal() const { return { left, right }; }
      operator frame () {       return { left, right }; }
      bool finished() const {     return left.finished() && right.finished(); }
      frame operator++(int) {     return { left++, right++ }; }
 
      frame operator=(const signal& in) {
        return { left = in.l, right = in.r };
      }
 
      buffer& operator=(const buffer& in) {
        left = in.left;
        right = in.right;
        return *this;
      }
 
      buffer& operator+=(const signal& in) {
        left += in.l;
        right += in.r;
        return *this;
      }
 
      buffer& operator=(const frame& in) {    left = in.l;  right = in.r;   return *this; }
      buffer& operator+=(const frame& in) {   left += in.l; right += in.r;  return *this; }
      buffer& operator*=(const frame& in) {   left *= in.l; right *= in.r;  return *this; }
 
      buffer& operator=(const mono::signal in) {    left = in;  right = in; return *this; }
      buffer& operator+=(const mono::signal in) { left += in; right += in;return *this; }
      buffer& operator*=(const mono::signal in) { left *= in; right *= in;return *this; }
 
      frame operator[](int index) {
        return { left[index], right[index] };
      }
 
      signal operator[](int index) const {
        return { left[index], right[index] };
      }
 
      mono::buffer& channel(int index) {
        return index == 1 ? right : left;
      }
 
      void clear() {
        left.clear();
        right.clear();
      }
 
      void clear(int size) {
        left.clear(size);
        right.clear(size);
      }
 
      void rewind() {
        left.rewind();
        right.rewind();
      }
    };
 
        /// Stereo audio object adapter
    template<class TYPE>
    struct Bank : klang::Bank<TYPE, 2> { };
 
        /// Audio delay object (stereo)
    template<int SIZE>
    struct Delay : Bank<klang::Delay<SIZE>> {
      using Bank<klang::Delay<SIZE>>::items;
      using Bank<klang::Delay<SIZE>>::in;
      using Bank<klang::Delay<SIZE>>::out;
 
      void clear() {
        items[0].clear();
        items[1].clear();
      }
 
      klang::Delay<SIZE> &l, &r;
      Delay<SIZE>() : l(items[0]), r(items[1]) { }
 
      signal tap(int delay) const {
        int read = (items[0].position - 1) - delay;
        if (read < 0)
          read += SIZE;
        return { items[0].buffer[read], items[1].buffer[read] };
      }
 
      signal tap(float delay) const {
        float read = (float)(items[0].position - 1) - delay;
        if (read < 0.f)
          read += SIZE;
 
        const float f = floor(read);
        delay = read - f;
 
        const int i = (int)read;
        const int j = (i == (SIZE - 1)) ? 0 : (i + 1);
 
        return { items[0].buffer[i] * (1.f - delay) + items[0].buffer[j] * delay,
             items[1].buffer[i] * (1.f - delay) + items[1].buffer[j] * delay };
      }
 
      virtual void process() override {
        out = tap(items[0].time);
      }
 
      template<typename TIME>
      signal operator()(const TIME& delay) {
        if constexpr (std::is_integral_v<TIME>)
          return tap((int)delay);
        else if constexpr (std::is_floating_point_v<TIME>)
          return tap((float)delay);
        else if constexpr (std::is_same_v<TIME, signal>) // stereo signal (use for l/r delay times)
          return { items[0].tap(delay.l), items[1].tap(delay.r) };
        else
          return tap((klang::signal)delay); // else treat as single signal
      }
 
      unsigned int max() const { return SIZE; }
    };
 
        /// Stereo effect mini-plugin
    struct Effect : public Plugin, public Modifier {
      virtual ~Effect() { }
 
      virtual void prepare() { };
      virtual void process() { out = in; };
      virtual void process(Stereo::buffer buffer) {
        prepare();
        while (!buffer.finished()) {
          input(buffer);
          process();
          buffer++ = out;
          debug.buffer++;
        }
      }
    };
 
    struct Synth;
 
    /// Base class for stereo synthesiser note
    struct Note : public NoteBase<Synth>, public Generator {
      //virtual signal output() { return 0; };
 
      virtual void prepare() { }
      virtual void process() override = 0;
      virtual bool process(Stereo::buffer buffer) {
        prepare();
        while (!buffer.finished()) {
          process();
          buffer++ = out;
        }
        return !finished();
      }
      virtual bool process(mono::buffer* buffers) {
        buffer buffer = { buffers[0], buffers[1] };
        return process(buffer);
      }
    };
 
    /// Synthesier mini-plugin (stereo)
    struct Synth : public Effect {
      typedef Stereo::Note Note;
 
            /// Synthesiser note array (stereo)
      struct Notes : klang::Notes<Synth, Note> {
        using klang::Notes<Synth, Note>::Notes;
      } notes;
 
      Synth() : notes(this) { }
      virtual ~Synth() { }
 
      virtual void presetLoaded(int preset) { }
      virtual void optionChanged(int param, int item) { }
      virtual void buttonPressed(int param) { };
 
      int indexOf(Note* note) const {
        int index = 0;
        for (const auto* n : notes.items) {
          if (note == n) return
            index;
          index++;
        }
        return -1; // not found
      }
    };
  }
 
    /// @cond
  namespace stereo {
    using namespace Stereo;
  }
    /// @endcond
 
  /// Feed audio source to destination (with source processing)
  template<typename SOURCE, typename DESTINATION>
  inline DESTINATION& operator>>(SOURCE& source, DESTINATION& destination) {
        if constexpr (is_derived_from<Input, DESTINATION>())
      destination.input(source); // input to destination (enables overriding of <<)
    else if constexpr (is_derived_from<Stereo::Input, DESTINATION>())
      destination.input(source); // input to destination (enables overriding of <<)
    else
      destination << source; // copy to destination
    return destination;
  }
 
    /// Feed audio source to destination (no source processing)
  template<typename SOURCE, typename DESTINATION>
  inline DESTINATION& operator>>(const SOURCE& source, DESTINATION& destination) {
        if constexpr (is_derived_from<Input, DESTINATION>())
      destination.input(source); // input to destination (enables overriding of <<)
    else if constexpr (is_derived_from<Stereo::Input, DESTINATION>())
      destination.input(source); // input to destination (enables overriding of <<)
    else
      destination << source; // copy to destination
    return destination;
  }
 
    /// Common audio generators / oscillators.
  namespace Generators {
    using namespace klang;
 
        /// Simple oscillators
    namespace Basic {
            /// Sine wave oscillator
      struct Sine : public Oscillator {
        void process() {
          out = sin(position + offset);
          position += increment;
        }
      };
 
            /// Saw wave oscillator (aliased)
      struct Saw : public Oscillator {
        void process() {
          out = position * pi.inv - 1.f;
          position += increment;
        }
      };
 
            /// Triangle wave oscillator (aliased)
      struct Triangle : public Oscillator {
        void process() {
          out = abs(2.f * position * pi.inv - 2) - 1.f;
          position += increment;
        }
      };
 
            /// Square wave oscillator (aliased)
      struct Square : public Oscillator {
        void process() {
          out = position > pi ? 1.f : -1.f;
          position += increment;
        }
      };
 
            /// Pulse wave oscillator (aliased)
      struct Pulse : public Oscillator {
        param duty = 0.5f;
 
        using Oscillator::set;
        void set(param frequency, param phase, param duty) {
          set(frequency, phase);
          Pulse::duty = duty;
        }
 
        void process() {
          out = position > (duty * pi) ? 1.f : -1.f;
          position += increment;
        }
      };
 
            /// White noise generator
      struct Noise : public Generator {
        void process() {
          out = rand() * 2.f/(const float)RAND_MAX - 1.f;
        }
      };
    };
 
        /// Performance-optimised oscillators
    namespace Fast {
      constexpr float twoPi = float(2.0 * 3.1415926535897932384626433832795);
      constexpr float twoPiInv = float(1.0 / twoPi);
 
            /// Phase increment (optimised)
      struct Increment {
        // represent phase delta using full range of int32
                // (integer math, no conditionals, free oversampling)
        signed int amount = 0;
 
        void reset() { amount = 0; }
 
        // set increment given frequency (in Hz)
        void set(Frequency f) {
          constexpr float FC4 = float(261.62556530059862);      // Reference Freq (C4 = 261Hz)
          constexpr float FC4_FINTMAX = float(261.62556530059862 * 2147483648.0);
          const float FBASE = (FC4_FINTMAX) / klang::fs;
          amount = 2u * (signed int)(FBASE / FC4 * f);
        }
 
        // convert int32 to float [0, 2pi)
        operator float() const {
          const unsigned int i = (amount >> 9) | 0x3f800000;
          return *(const float*)&i - 1.f;
        }
 
        Increment operator+(const Increment& in) const {
          return { in.amount + amount };
        }
      };
 
            /// Oscillator phase (optimised)
      struct Phase {
        // represent phase using full range of uint32
        // (integer math, no conditionals, free oversampling)
        unsigned int position = 0;
 
        // convert float [0, 2pi) to uint32
        Phase& operator=(klang::Phase phase) {
          constexpr float FINTMAX = 2147483648.0f; // (float)INT_MAX + 1.f;
          phase = phase * FINTMAX / (2.f * pi);
          position = (unsigned int)phase;
          return *this;
 
          //position = 2u * (signed int)(phase * (float(INT_MAX) + 1.f) * twoPiInv);
          //return *this;
        }
 
        // convert uint32 to float [0, 1)
        operator float() const {
          const unsigned int i = (position >> 9) | 0x3f800000;
          return (*(const float*)&i - 1.f);
 
          //// = quarter-turn (pi/2) phase offset
          //unsigned int phase = position + 0x40000000;
 
          //// range reduce to [0,pi]
          //if (phase & 0x80000000) // cos(x) = cos(-x)
          //  phase = ~phase; 
 
          //// convert to float in range [-pi/2,pi/2)
          //phase = (phase >> 8) | 0x3f800000;
          //return *(float*)&phase * pi - 3.f/2.f * pi; // 1.0f + (phase / (2^31))
        }
 
        // returns offset phase
        float operator+(const Phase& offset) const {
 
          unsigned int phase = (position + offset.position) + 0x40000000; // = quarter-turn (pi/2) phase offset
          // range reduce to [0,pi]
          if (phase & 0x80000000) // cos(x) = cos(-x)
            phase = ~phase;
 
          // convert to float in range [-pi/2,pi/2)
          phase = (phase >> 8) | 0x3f800000;
          return *(float*)&phase * pi - 3.f / 2.f * pi; // 1.0f + (phase / (2^31))
        }
 
        // convert uint32 to float [0, 2pi)
        float radians() const {
          return operator float();
        }
 
        // applies increment and returns float [0, 2pi)
        //float operator+=(Increment i) {
        //  unsigned int phase = position + 0x40000000; // = quarter-turn (pi/2) phase offset
        //  position += i.amount;           // apply increment
 
        //  // range reduce to [0,pi]
        //  if (phase & 0x80000000) // cos(x) = cos(-x)
        //    phase = ~phase;
 
        //  // convert to float in range [-pi/2,pi/2)
        //  phase = (phase >> 8) | 0x3f800000;
        //  return *(float*)&phase * pi - 3 / 2.f * pi; // 1.0f + (phase / (2^31))
        //}
 
        // applies increment and returns float [0, 2pi)
        Phase& operator+=(const Increment i) {
          position += i.amount;           // apply increment
          return *this;
        }
 
        // applies increment and returns float [0, 2pi)
        //Phase operator+(const Phase& i) const {
        //  return { position + i.position };       // apply increment
        //}
 
        //// applies increment and returns float [0, 2pi)
        //float operator+=(Increment i) {
        //  unsigned int phase = position + 0x40000000; // = quarter-turn (pi/2) phase offset
        //  position += i.amount;           // apply increment
 
        //  // range reduce to [0,pi]
        //  if (phase & 0x80000000) // cos(x) = cos(-x)
        //    phase = ~phase; 
 
        //  // convert to float in range [-pi/2,pi/2)
        //  phase = (phase >> 8) | 0x3f800000;
        //  return *(float*)&phase * pi - 3/2.f * pi; // 1.0f + (phase / (2^31))
        //}
 
        //Phase& operator+(Phase offset) const {
        //  offset.position += position;
        //  return offset;
        //}
 
        //static void test() {
        //  Phase p;
        //  assert((float)(p = 0.f).radians() == 0.f);
        //  assert((float)(p = pi/2).radians() == pi/2);
        //  assert((float)(p = pi).radians() == pi);
        //  assert((float)(p = 3*pi/2).radians() == 3*pi/2);
        //  assert((float)(p = 2*pi).radians() == 0.f);
        //}
      };
 
      /// sin approximation [-pi/2, pi/2] using odd minimax polynomial (Robin Green)
      inline static float polysin(float x) {
        const float x2 = x * x;
        return (((-0.00018542f * x2 + 0.0083143f) * x2 - 0.16666f) * x2 + 1.0f) * x;
      }
 
      /// fast sine (based on V2/Farbrausch; using polysin)
      inline static float fastsin(float x)
      {
        // Range reduction to [0, 2pi]
        //x = fmodf(x, twoPi);
        //if (x < 0)      // support -ve phase (e.g. for FM)
        //  x += twoPi;   //
        x = fast_mod2pi(x);
 
        // Range reduction to [-pi/2, pi/2]
        if (x > 3/2.f * pi) // 3/2pi ... 2pi
          x -= twoPi; // (= translated)
        else if (x > pi/2)  // pi/2 ... 3pi/2
          x = pi - x;   // (= mirrored)
 
        return polysin(x);
      }
 
      /// fast sine (using polysin and integer math)
      inline static float fastsinp(unsigned int p)
      {
        // Range reduction to [0, 2pi]
        //x = fmodf(x, twoPi);
        //if (x < 0)      // support -ve phase (e.g. for FM)
        //  x += twoPi;   //
        float x = fast_modp(p);
 
        // Range reduction to [-pi/2, pi/2]
        if (x > 3.f/2.f * pi) // 3/2pi ... 2pi
          x -= twoPi;     // (= translated)
        else if (x > pi/2.f)  // pi/2 ... 3pi/2
          x = pi - x;     // (= mirrored)
 
        return polysin(x);
      }
 
            /// Sine wave oscillator (band-limited, optimised)
      struct Sine : public Oscillator {
        void reset() override {
          Sine::position = Oscillator::position = 0;
          Sine::offset = Oscillator::offset = 0;
          set(Oscillator::frequency, 0.f);
        }
 
        void set(param frequency) override {
          if (frequency != Oscillator::frequency) {
            Oscillator::frequency = frequency;
            increment.set(frequency);
          }
        }
 
        void set(param frequency, param phase) override { // set frequency and phase
          Sine::position = Oscillator::position = phase;
          Sine::offset = Oscillator::offset = 0;
          set(frequency);
        }
 
        void set(param frequency, relative phase) override { // set frequency and phase
          set(frequency);
          set(phase);
        }
 
        void set(relative phase) override { // set frequency and phase
          Sine::offset = Oscillator::offset = phase * twoPi;
        }
 
        void process() override {
          out = fastsinp(position.position + offset.position);
          position += increment;
        }
 
      protected:
        Fast::Increment increment;
        Fast::Phase position, offset;
      };
 
            /// Oscillator State Machine
      struct OSM {
        using Waveform = float(OSM::*)();
        const Waveform waveform;
 
        OSM(Waveform waveform) : waveform(waveform) { }
 
        enum State { // carry:old_up:new_up
          NewUp = 0b001, NewDown = 0b000,
          OldUp = 0b010, OldDown = 0b000,
          Carry = 0b100, NoCarry = 0b000,
 
          Down    = OldDown|NewDown|NoCarry,
          UpDown    = OldUp|NewDown|NoCarry,
          Up      = OldUp|NewUp|NoCarry,
          DownUpDown  = OldDown|NewDown|Carry,
          DownUp    = OldDown|NewUp|Carry,
          UpDownUp  = OldUp|NewUp|Carry
        };
 
        Fast::Increment increment;
        Fast::Phase offset;
        Fast::Phase duty;
        State state;
        float delta;
 
        // coeffeficients
        float f, omf, rcpf, rcpf2, col;
        float c1,c2;
 
        param frequency = 0; // cached to optimise updates
 
        void init() {
          state = (offset.position - increment.amount) < duty.position ? Up : Down;
          f = delta;
          omf = 1.f - f;
          rcpf2 = 2.f * (rcpf = 1.f / f);
          col = duty;
 
          c1 = 1.f / col;
          c2 = -1.f / (1.0f - col);
        }
 
        void set(param frequency) {
          if (OSM::frequency != frequency) {
            OSM::frequency = frequency;
            increment.set(frequency);
            delta = increment;
            init();
          }
        }
 
        void set(param frequency, param phase) {
          if (OSM::frequency != frequency) {
            OSM::frequency = frequency;
            increment.set(frequency);
            delta = increment;
          }
          offset = phase;
          init();
        }
 
        void set(param frequency, param phase, param duty) {
          if (OSM::frequency != frequency) {
            OSM::frequency = frequency;
            increment.set(frequency);
            delta = increment;
          }
          offset = phase;
          setDuty(duty);
        }
 
        void setDuty(param duty) {
          OSM::duty = duty * (2.f * pi);
          init();
        }
 
        State tick() {
          // old_up = new_up, new_up = (cnt < brpt)
          state = (State)(((state << 1) | (offset.position < duty.position)) & (NewUp|OldUp));
 
          // we added freq to cnt going from the previous sample to the current one.
          // so if cnt is less than freq, we carried.
          const State transition = (State)(state | (offset.position < (unsigned int)increment.amount ? DownUpDown : Down));
 
          // finally, tick the oscillator
          offset += increment;
 
          return transition;
        }
 
        inline static float sqr(float x) { return x * x; }
        inline float output() { return (this->*waveform)(); }
 
        //inline float saw() {
        //  const float f = delta;
        //  const float omf = 1.f - f;
        //  const float rcpf = 1.f / f;
        //  const float col = duty;
        //  const float c1 = 1.f / col;
        //  const float c2 = -1.f / (1.0f - col);
        //  const float p = offset - col;
        //  float y = 0.0f;
        //  // state machine action
        //  switch (tick()) {
        //  case Up:     y = c1 * (p + p - f); break; // average of linear function = just sample in the middle
        //  case Down:     y = c2 * (p + p - f); break; // again, average of a linear function
        //  case UpDown:   y = rcpf * (c2 * sqr(p) - c1 * sqr(p - f));      break;
        //  case DownUp:   y = -rcpf * (1.f + c2 * sqr(p + omf) - c1 * sqr(p)); break;
        //  case UpDownUp:   y = -rcpf * (1.f + c1 * omf * (p + p + omf));      break;
        //  case DownUpDown: y = -rcpf * (1.f + c2 * omf * (p + p + omf));      break;
        //  default:     y = -1; // should never happen
        //  }
        //  return y + 1.f;
        //}
 
        float saw() { return saw(offset - col, tick()); }
        inline float saw(const float p, const State state) const {
          // state machine action
          switch (state) {
          case Up:     return c1 * (p + p - f) + 1.f; break; // average of linear function = just sample in the middle
          case Down:     return c2 * (p + p - f) + 1.f; break; // again, average of a linear function
          case UpDown:   return rcpf * (c2 * sqr(p) - c1 * sqr(p - f)) + 1.f;      break;
          case DownUp:   return -rcpf * (1.f + c2 * sqr(p + omf) - c1 * sqr(p)) + 1.f; break;
          case UpDownUp:   return -rcpf * (1.f + c1 * omf * (p + p + omf)) + 1.f;      break;
          case DownUpDown: return -rcpf * (1.f + c2 * omf * (p + p + omf)) + 1.f;      break;
          default:     return 0.f; // should never happen
          }
        }
 
        float pulse() { return pulse(offset, tick()); }
        inline float pulse(const float p, const State state) const {
          // state machine action
          switch (state) {
          case Up:     return 1.f;              break;
          case Down:     return -1.f;             break;
          case UpDown:   return rcpf2 * (col - p) + 1.f;    break;
          case DownUp:   return rcpf2 * p - 1.f;        break;
          case UpDownUp:   return rcpf2 * (col - 1.0f) + 1.f;   break;
          case DownUpDown: return rcpf2 * col - 1.f;        break;
          default:     return 0; // should never happen
          }
        }
      };
 
            /// @cond
      struct Osm : public Oscillator {
        const float _Duty;
 
        Osm(OSM::Waveform waveform, float duty = 0.f) : _Duty(duty), osm(waveform) { osm.setDuty(_Duty); }
 
        void set(param frequency) {
          osm.set(frequency);
        }
 
        void set(param frequency, param phase) {
          osm.set(frequency, phase);
        }
 
        void set(param frequency, param phase, param duty) {
          osm.set(frequency, phase, duty);
        }
 
        void process() {
          out = osm.output();
        }
 
      protected:
        using Oscillator::set;
        OSM osm;
      };
            /// @endcond
 
            /// Saw wave oscillator (band-limited, optimised)
      struct Saw :    public Osm {  Saw()    : Osm(&OSM::saw, 0.f) {} };
            /// Triangle wave oscillator (band-limited, optimised)
      struct Triangle : public Osm {  Triangle() : Osm(&OSM::saw, 1.f) {} };
            /// Square wave oscillator (band-limited, optimised)
      struct Square :   public Osm {  Square()   : Osm(&OSM::pulse, 1.0f) {} };
            /// Pulse wave oscillator (band-limited, optimised)
      struct Pulse :    public Osm {  Pulse()    : Osm(&OSM::pulse, 0.5f) {} };
 
            /// White noise generator (optimised)
      struct Noise : public Generator {
        static constexpr unsigned int bias = 0b1000011100000000000000000000000;
                /// @cond
        union { unsigned int i; float f; };
                /// @endcond
        void process() {
          i = ((rand() & 0b111111111111111UL) << 1) | bias;
          out = f - 257.f;
        }
      };
    };
 
        /// Wavetable-based oscillators
    namespace Wavetables {
            /// Sine wave oscillator (wavetable)
      struct Sine : public Wavetable {
        Sine() : Wavetable(Basic::Sine()) { }
      };
 
            /// Saw wave oscillator (wavetable)
      struct Saw : public Wavetable {
        Saw() : Wavetable(Basic::Saw()) { }
      };
    }
  };
 
    /// Common audio filters.
  namespace Filters {
 
//    namespace Basic {
 
            /// Basic one-pole IIR filter.
      struct IIR : public Modifier {
                virtual ~IIR() { }
 
        float a, b;
 
        void set(param coeff) {
          a = coeff;
          b = 1 - a;
        }
 
        void process() {
          out = (a * in) + (b * out);
        }
      };
 
      /// Single-pole (one-pole, one-zero) First Order Filters
      namespace OnePole
      {
                /// Abstract filter class
        struct Filter : Modifier {
                    virtual ~Filter() { }
 
          float f = 0;    // cutoff f
          //float shelf = 1;  // shelving gain
 
          float /*a0 = 1*/ a1 = 0, b0 = 1, b1 = 0; //coefficients
 
          float exp0 = 0;
          //float tan0 = 0;
          float z = 0;  // filter state
 
          void reset() {
            a1 = 0;
            b0 = 1;
            b1 = 0;
            f = 0;
            z = 0;
          }
 
          void set(param f) {
            if (Filter::f != f) {
              Filter::f = f;
              //tan0 = tanf(0.5f * f * fs.w);
              init();
            }
          }
 
          virtual void init() = 0;
 
          void process() {
            out = b0 * in + b1 * z + a1 * out + DENORMALISE;
          }
        };
 
        /// Low-pass filter (LPF)
        struct LPF : Filter {
                    virtual ~LPF() { }
 
          void init() {
            const float exp0 = expf(-f * fs.w);
            b0 = 1 - exp0;
            a1 = exp0;
          }
 
          void process() {
            out = b0 * in + a1 * out + DENORMALISE;
          }
        };
 
        /// High-pass filter (HPF)
        struct HPF : Filter {
                    virtual ~HPF() { }
 
          void init() {
            const float exp0 = expf(-f * fs.w);
            b0 = 0.5f * (1.f + exp0);
            b1 = -b0;
            a1 = exp0;
          }
        };
      };
 
            /// One-pole Butterworth filter.
      namespace Butterworth {
                /// Low-pass filter (LPF).
        struct LPF : OnePole::Filter {
                    virtual ~LPF() { }
 
          void init() {
            const float c = 1.f / tanf(pi * f * fs.inv);
            constant a0 = { 1.f + c };
            b0 = a0.inv;  // b0 == b1
            a1 = (1.f - c) * a0.inv; // = (1-c) / a0
          }
          void process() {
            out = b0 * (in + z) - a1 * out;// +DENORMALISE;
            z = in;
          }
        };
      };
 
      /// Transposed Direct Form II Biquadratic Filter
      namespace Biquad {
 
                /// Abstract filter class
        struct Filter : Modifier
        {
                    virtual ~Filter() { }
 
          float f = 0;  // cutoff/centre f
          float Q = 0;  // Q (resonance)
 
          float /*a0 = 1*/ a1 = 0, a2 = 0, b0 = 1, b1 = 0, b2 = 0; // coefficients
 
          float a = 0;    // alpha
          float cos0 = 1;   // cos(omega)
          float sin0 = 0;   // sin(omega)
          float z[2] = { 0 }; // filter state
 
                    /// Reset filter state
          void reset() {
            f = 0;
            Q = 0;
            b0 = 1;
            a1 = a2 = b1 = b2 = 0;
            a = 0;
            z[0] = z[1] = 0;
          }
 
                    /// Set the filter cutoff (and Q)
          void set(param f, param Q = root2.inv) {
            if (Filter::f != f || Filter::Q != Q) {
              Filter::f = f;
              Filter::Q = Q;
 
              const float w = f * fs.w;
              cos0 = cosf(w);
              sin0 = sinf(w);
 
              if (Q < 0.5) Q = 0.5;
              a = sin0 / (2.f * Q);
              init();
            }
          }
 
          virtual void init() = 0;
 
                    /// Apply the biquad filter (Transposed Direct Form II)
          void process() noexcept {
            const float z0 = z[0];
            const float z1 = z[1];
            const float y = b0 * in + z0;
            z[0] = b1 * in - a1 * y + z1;
            z[1] = b2 * in - a2 * y;
            out = y;
          }
        };
 
        /// Low-pass filter (LPF)
        struct LPF : Filter {
                    virtual ~LPF() { }
 
          void init() override {
            constant a0 = { 1.f + a };
            a1 = a0.inv * (-2.f * cos0);
            a2 = a0.inv * (1.f - a);
 
            b2 = b0 = a0.inv * (1.f - cos0) * 0.5f;
            b1 = a0.inv * (1.f - cos0);
          }
        };
 
        typedef LPF HCF; ///< High-cut filter (HCF)
        typedef LPF HRF; ///< High-reject filter (HRF)
 
                /// High-pass filter (HPF)
        struct HPF : Filter {
                    virtual ~HPF() { }
 
          void init() {
            constant a0 = { 1.f + a };
            a1 = a0.inv * (-2.f * cos0);
            a2 = a0.inv * (1.f - a);
 
            b2 = b0 = a0.inv * (1.f + cos0) * 0.5f;
            b1 = a0.inv * -(1.f + cos0);
          }
        };
 
        typedef HPF LCF; ///< Low-cut filter (LCF)
        typedef HPF LRF; ///< Low-reject filter (LRF)
 
        /// Band-pass filter (BPF)
        struct BPF : Filter {
 
          enum Gain {
            ConstantSkirtGain,  ///< Constant Skirt Gain
            ConstantPeakGain    ///< Constant Peak Gain
          };
 
                    /// Set the constant gain mode.
          BPF& operator=(Gain gain) {
            init_gain = gain == ConstantSkirtGain ? &BPF::init_skirt : &BPF::init_peak;
            init();
            return *this;
          }
 
          using Init = void(BPF::*)(void); ///< @internal
          Init init_gain = &BPF::init_peak; ///< @internal
          void init() { (this->*init_gain)(); } ///< @internal
 
          /// @internal
          void init_skirt() {
                        // constant skirt gain
            constant a0 = { 1.f + a };
            a1 = a0.inv * (-2.f * cos0);
            a2 = a0.inv * (1.f - a);
 
            b0 = a0.inv * sin0 * 0.5f;
            b1 = 0;
            b2 = -b0;
          }
 
                    /// @internal
          void init_peak() {
            // constant peak gain
            constant a0 = { 1.f + a };
            a1 = a0.inv * (-2.f * cos0);
            a2 = a0.inv * (1.f - a);
 
            b0 = a0.inv * a;
            b1 = 0;
            b2 = a0.inv * -a;
          }
        };
 
        /// Band-Reject Filter (BRF)
        struct BRF : Filter {
          void init() {
            constant a0 = { 1.f + a };
            b1 = a1 = a0.inv * (-2.f * cos0);
            a2 = a0.inv * (1.f - a);
            b0 = b2 = a0.inv;
          }
        };
 
        typedef BRF BSF; ///< Band-stop filter (BSF)
 
        /// All-pass filter (APF)
        struct APF : Filter {
          void init() {
            constant a0 = { 1.f + a };
            b1 = a1 = a0.inv * (-2.f * cos0);
            b0 = a2 = a0.inv * (1.f - a);
            b2 = 1.f;
          }
        };
      }
//    }
  }
 
  /// Envelope follower (Peak / RMS)
  struct Envelope::Follower : Modifier {
 
    /// Attack / Release IIR Filter (~Butterworth when attack == release)
    struct AR : Modifier {
      param attack = 0;
      param release = 0;
 
      param A = 1, R = 1;
 
      void set(param attack, param release) {
        if (AR::attack != attack || AR::release != release) {
          AR::attack = attack;
          AR::release = release;
          A = 1.f - (attack == 0.f ? 0.f : expf(-1.0f / (fs * attack)));
          R = 1.f - (release == 0.f ? 0.f : expf(-1.0f / (fs * release)));
        }
      }
 
      void process() {
        const float smoothing = in > out ? A : R;
        (out + smoothing * (in - out)) >> out;
      }
    } ar;
 
    // Peak / RMS Envelope Follower (default; filter-based)
    Follower() { set(0.01f, 0.1f); }
    void set(param attack, param release) {
      ar.set(attack, release);
    }
 
    Follower& operator=(klang::Mode mode) {
      _process = (mode == RMS) ? &Follower::rms : &Follower::peak;
      return *this;
    }
 
    using Process = void(Follower::*)();
    Process _process = &Follower::rms;
 
    void process() {  (this->*_process)();  }
 
    void peak() { abs(in) >> ar >> out;         }
    void rms() {  (in * in) >> ar >> sqrt >> out;   }
 
    /// Window-based envelope follower
    template<int WINDOW>
    struct Window : Modifier
    {
      AR ar;
      buffer buffer;
      double sum = 0; // NB: must be 64-bit to avoid rounding errors
      static constexpr constant window = { WINDOW };
 
      Window() : buffer(WINDOW, 0) {
        set(0.01f, 0.1f);
      }
 
      void set(param attack, param release) {
        ar.set(attack, release);
      }
 
      Window& operator=(klang::Mode mode) {
        _process = (mode == RMS) ? &Window::rms : &Window::mean;
        return *this;
      }
 
      using Process = void(Window::*)();
      Process _process = &Window::rms;
 
      void process() { (this->*_process)(); }
 
      void mean() {
        sum -= double(buffer);
        abs(in) >> buffer;
        sum += double(buffer++);
        if (buffer.finished())
          buffer.rewind();
        sum * window.inv >> ar >> out;
      }
      void rms() {
        sum -= double(buffer);
        (in * in) >> buffer;
        sum += double(buffer++);
        if (buffer.finished())
          buffer.rewind();
        sum* window.inv >> sqrt >> ar >> out;
      }
    };
  };
 
  namespace basic {
    using namespace klang;
 
    using namespace Generators::Basic;
    using namespace Filters;
    using namespace Filters::Biquad;
  };
 
  namespace optimised {
    using namespace klang;
 
    using namespace Generators::Fast;
    using namespace Filters;
    using namespace Filters::Biquad;
  };
 
  namespace minimal {
    using namespace klang;
  };
 
  //using namespace optimised;
};
 
//using namespace klang;