nonlin_ambience_design.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/signal/crossfade.hpp>
#include <pulp/signal/dc_blocker.hpp>
#include <pulp/signal/delay_line.hpp>
#include <pulp/signal/denormal.hpp>
#include <pulp/signal/rng.hpp>
#include <pulp/signal/smoothed_value.hpp>
#include <pulp/signal/tpt_filter.hpp>
#include <pulp/signal/units.hpp>
#include <pulp/signal/velvet_noise.hpp>
 
#include <algorithm>
#include <array>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <vector>
 
namespace pulp::signal {

enum class NonlinProgram {
    ambience = 0,  
    gated = 1,     
    reverse = 2,   
    nonlin2 = 3,   
};

namespace nonlin_ambience {

inline constexpr int kNumAllpass = 2;

inline constexpr double kAllpassDelaysMs[2] = {4.77, 6.13};

inline constexpr double kDiffusionDefault = 0.70;
inline constexpr double kDiffusionMax = 0.85;

inline constexpr double kNdMin = 800.0;
inline constexpr double kNdMax = 4000.0;

inline constexpr double kDensityRefPct = 60.0;

inline constexpr double kGammaDefault = 2.0;

inline constexpr double kAmbDropDb = 60.0;

inline constexpr double kFadeInFrac = 0.02;

inline constexpr double kGateHold = 0.70;
inline constexpr double kGateFall = 0.05;

inline constexpr double kRevRise = 0.85;
inline constexpr double kRevPow = 1.0;

inline constexpr int kNlHumps = 2;
inline constexpr double kNlDepth = 0.4;
inline constexpr double kNlHold = 0.85;

inline constexpr double kL1Budget = 4.0;

inline constexpr int kSegments = 8;

inline constexpr double kFcBright = 16000.0;
inline constexpr double kFcDark = 6000.0;

inline constexpr double kSwapFadeMs = 20.0;

inline constexpr double kParamSmoothMs = 20.0;

inline constexpr std::uint32_t kSeedRodd = 0x9E3779B9u;

inline constexpr std::uint32_t kDefaultSeed = 0x51EDu;

inline constexpr int kTapGuard = 32;

inline constexpr double kConverterFcLo = 80.0;
inline constexpr double kConverterFcHi = 15000.0;

inline constexpr int kConverterBitsMax = 16;
inline constexpr int kConverterBitSweep = 4;

inline constexpr double kConverterDcPole = 0.995;

inline constexpr double kMinLengthMs = 20.0;
inline constexpr double kMaxLengthMs = 2000.0;
inline constexpr double kMaxPredelayMs = 200.0;

inline constexpr double kMinDensityPct = 10.0;

inline constexpr double kNormFloor = 1e-20;

constexpr double allpass_l1_gain(double g) { return 1.0 + 2.0 * (g < 0.0 ? -g : g); }

inline constexpr double kDcBlockerL1Gain = 2.0;

inline double worst_case_gain(double diffusion = kDiffusionDefault,
                              bool converter_on = false) {
    double g = 1.0;
    for (int i = 0; i < kNumAllpass; ++i) g *= allpass_l1_gain(diffusion);
    return g * kL1Budget * (converter_on ? kDcBlockerL1Gain : 1.0);
}

inline double program_envelope(NonlinProgram program,
                               double tau,
                               double gate_hold = kGateHold,
                               double attack = kRevRise) {
    if (!(tau >= 0.0) || tau > 1.0) return 0.0;
 
    const double fade_in = kFadeInFrac > 0.0 ? std::min(1.0, tau / kFadeInFrac) : 1.0;
 
    switch (program) {
        case NonlinProgram::ambience: {
            // α from the drop in dB: E(1) = 10^(−A_drop/20).
            constexpr double kLn10 = 2.302585092994045684;
            const double alpha = kAmbDropDb * kLn10 / 20.0;
            return fade_in * std::exp(-alpha * tau);
        }
        case NonlinProgram::gated: {
            const double h = gate_hold;
            const double w = kGateFall;
            if (tau <= h) return 1.0;
            if (tau <= h + w) return 1.0 - (tau - h) / w;
            return 0.0;
        }
        case NonlinProgram::reverse: {
            const double r = attack > 0.0 ? attack : 1e-6;
            if (tau <= r) return std::pow(tau / r, kRevPow);
            return 1.0;  // brief plateau; the hard cut is at τ > 1, handled above
        }
        case NonlinProgram::nonlin2: {
            const double h = attack;
            if (tau > h) return 0.0;
            constexpr double kTwoPi = 6.283185307179586476925286766559;
            const double ripple =
                0.5 - 0.5 * std::cos(kTwoPi * static_cast<double>(kNlHumps) * tau);
            return fade_in * ((1.0 - kNlDepth) + kNlDepth * ripple);
        }
    }
    return 0.0;
}

inline double pulse_density(double u, double density_pct, double gamma) {
    const double nd_min = kNdMin * (density_pct / kDensityRefPct);
    const double clamped = std::clamp(u, 0.0, 1.0);
    return nd_min + (kNdMax - nd_min) * std::pow(clamped, gamma);
}

struct VelvetTapDesign {
    int delay = 0;
    double magnitude = 0.0;
    double gain = 0.0;
    int segment = 0;
    bool audible = false;
};
 
inline VelvetTapDesign design_velvet_tap(NonlinProgram program,
                                         double position_samples,
                                         double grid_samples,
                                         int window_samples,
                                         int predelay_samples,
                                         double gate_hold,
                                         double attack,
                                         const VelvetNoiseDrawT<double>& draw) noexcept {
    VelvetTapDesign result;
    // Public fail-closed domain: a non-empty window, non-negative finite grid
    // coordinates, normalized jitter, a ternary pulse sign, finite envelope
    // controls, and a predelay whose largest in-window tap cannot overflow.
    // Invalid input produces the default inaudible design before any floating
    // to integer conversion, division, square root, or signed addition.
    if (window_samples <= 0 || predelay_samples < 0 ||
        predelay_samples > std::numeric_limits<int>::max() - (window_samples - 1) ||
        !std::isfinite(position_samples) || position_samples < 0.0 ||
        !std::isfinite(grid_samples) || grid_samples < 0.0 ||
        !std::isfinite(draw.jitter) || draw.jitter < 0.0 || draw.jitter >= 1.0 ||
        (draw.sign != -1 && draw.sign != 1) ||
        !std::isfinite(gate_hold) || !std::isfinite(attack)) {
        return result;
    }
 
    const double candidate = position_samples +
                             draw.jitter * std::max(0.0, grid_samples - 1.0);
    if (!std::isfinite(candidate)) return result;
    const double bounded = std::clamp(candidate, 0.0,
                                      static_cast<double>(window_samples - 1));
    const int delay = static_cast<int>(std::lround(bounded));
    const double tau = static_cast<double>(delay) / static_cast<double>(window_samples);
    const double env = program_envelope(program, tau, gate_hold, attack);
    result.delay = predelay_samples + delay;
    result.audible = env > 0.0;
    if (!result.audible) return result;
    result.magnitude = env * std::sqrt(grid_samples);
    result.gain = static_cast<double>(draw.sign) * result.magnitude;
    int segment = std::clamp(static_cast<int>(tau * kSegments), 0, kSegments - 1);
    result.segment = program == NonlinProgram::reverse ? kSegments - 1 - segment : segment;
    return result;
}
 
}  // namespace nonlin_ambience
 
}  // namespace pulp::signal