lfo_sampling.hpp

Go to the documentation of this file.

#pragma once
#include <pulp/signal/osc/blep.hpp>
 
#include <cmath>
#include <cstdint>
 
namespace pulp::signal {

enum class LfoWave : std::uint8_t {
    sine,
    triangle,
    saw_up,
    saw_down,
    square,
    sample_hold,
    smooth_random,
};

struct LfoShapeParams {
    double pulse_width = 0.5;   
    double triangle_peak = 0.5; 
};

[[nodiscard]] constexpr bool lfo_wave_is_periodic(LfoWave wave) noexcept {
    return wave != LfoWave::sample_hold && wave != LfoWave::smooth_random;
}
 
namespace detail {
 
constexpr double kTwoPi = 6.283185307179586477;
 
[[nodiscard]] inline double wrap01(double x) noexcept {
    return x - std::floor(x);
}
 
[[nodiscard]] inline double clamp_open(double x) noexcept {
    return x < 1.0e-6 ? 1.0e-6 : (x > 1.0 - 1.0e-6 ? 1.0 - 1.0e-6 : x);
}

[[nodiscard]] inline double wave_integral_in_cycle(LfoWave wave, double x,
                                                   const LfoShapeParams& params) noexcept {
    switch (wave) {
    case LfoWave::sine:
        return (1.0 - std::cos(kTwoPi * x)) / kTwoPi;
    case LfoWave::triangle: {
        const double a = clamp_open(params.triangle_peak);
        if (x < a)
            return x * x / a - x;
        const double r = x - a;
        return r - r * r / (1.0 - a);
    }
    case LfoWave::saw_up:
        return x * x - x;
    case LfoWave::saw_down:
        return x - x * x;
    case LfoWave::square: {
        const double pw = clamp_open(params.pulse_width);
        return x < pw ? x : 2.0 * pw - x;
    }
    case LfoWave::sample_hold:
    case LfoWave::smooth_random:
    default:
        return 0.0;
    }
}

[[nodiscard]] inline double wave_integral_per_cycle(LfoWave wave,
                                                    const LfoShapeParams& params) noexcept {
    return wave == LfoWave::square ? 2.0 * clamp_open(params.pulse_width) - 1.0 : 0.0;
}
 
} // namespace detail

[[nodiscard]] inline double lfo_wave(LfoWave wave, double phase,
                                     const LfoShapeParams& params = {}) noexcept {
    const double p = detail::wrap01(phase);
    switch (wave) {
    case LfoWave::sine:
        return std::sin(detail::kTwoPi * p);
    case LfoWave::triangle: {
        const double a = detail::clamp_open(params.triangle_peak);
        return p < a ? -1.0 + 2.0 * p / a : 1.0 - 2.0 * (p - a) / (1.0 - a);
    }
    case LfoWave::saw_up:
        return 2.0 * p - 1.0;
    case LfoWave::saw_down:
        return 1.0 - 2.0 * p;
    case LfoWave::square:
        return p < detail::clamp_open(params.pulse_width) ? 1.0 : -1.0;
    case LfoWave::sample_hold:
    case LfoWave::smooth_random:
    default:
        return 0.0;
    }
}

[[nodiscard]] inline double lfo_wave_integral(LfoWave wave, double phase,
                                              const LfoShapeParams& params = {}) noexcept {
    const double whole = std::floor(phase);
    return whole * detail::wave_integral_per_cycle(wave, params) +
           detail::wave_integral_in_cycle(wave, phase - whole, params);
}

[[nodiscard]] inline double lfo_wave_mean(LfoWave wave, double from, double to,
                                          const LfoShapeParams& params = {}) noexcept {
    if (!(std::isfinite(from) && std::isfinite(to)))
        return 0.0;
    if (to < from) {
        const double t = from;
        from = to;
        to = t;
    }
    const double span = to - from;
    // Below this the difference of two integrals loses more digits than the
    // point value is wrong by.
    if (span < 1.0e-9)
        return lfo_wave(wave, from, params);
    return (lfo_wave_integral(wave, to, params) - lfo_wave_integral(wave, from, params)) / span;
}

[[nodiscard]] inline double lfo_wave_bandlimited(LfoWave wave, double phase, double increment,
                                                 const LfoShapeParams& params = {}) noexcept {
    const double p = detail::wrap01(phase);
    double value = lfo_wave(wave, p, params);
    if (!(increment > 0.0) || !std::isfinite(increment) || increment >= 1.0)
        return value;
    const double dt = increment;
 
    // The correction a corner at phase `at` contributes to the sample at `p`:
    // `after` when the corner lies within one step before p, `before` when it
    // lies within one step after p. `height` is a value jump (BLEP) or a
    // slope change per sample (BLAMP).
    const auto corner = [&](double at, double height, bool slope) {
        // Distance from the corner forward to this sample, in cycles, wrapped
        // so a corner at 0 is seen from both ends of the cycle.
        double behind = p - at;
        behind -= std::floor(behind);
        if (behind < dt) {
            // The corner is `behind` cycles before this sample: this is the
            // sample after it, and d (the corner's position past the previous
            // sample) is 1 - behind / dt.
            const double d = 1.0 - behind / dt;
            value += slope ? osc::poly_blamp(d, height).after : osc::poly_blep(d, height).after;
        }
        double ahead = at - p;
        ahead -= std::floor(ahead);
        if (ahead > 0.0 && ahead <= dt) {
            // The corner is `ahead` cycles after this sample: this is the
            // sample before it, with the corner `ahead / dt` of a step past it.
            const double d = ahead / dt;
            value += slope ? osc::poly_blamp(d, height).before : osc::poly_blep(d, height).before;
        }
    };
 
    switch (wave) {
    case LfoWave::saw_up:
        corner(0.0, -2.0, false);
        break; // +1 wraps to -1
    case LfoWave::saw_down:
        corner(0.0, +2.0, false);
        break; // -1 wraps to +1
    case LfoWave::square: {
        const double pw = detail::clamp_open(params.pulse_width);
        corner(0.0, +2.0, false);
        corner(pw, -2.0, false);
        break;
    }
    case LfoWave::triangle: {
        // Slopes per cycle: +2/a up to the apex, -2/(1-a) after it.
        const double a = detail::clamp_open(params.triangle_peak);
        const double turn = (2.0 / a + 2.0 / (1.0 - a)) * dt; // per sample
        corner(a, -turn, true);
        corner(0.0, +turn, true);
        break;
    }
    case LfoWave::sine:
    case LfoWave::sample_hold:
    case LfoWave::smooth_random:
    default:
        break;
    }
    return value;
}
 
} // namespace pulp::signal