commit b5f38990ed07d2e751149ad7b6d2e5adbe148a27 parent 139ab8b5c2030d432ec258887f852a274582a862 Author: jatinchowdhury18 <[email protected]> Date: Mon, 2 Aug 2021 15:56:02 -0400 Improve Hysteresis processor performance (#210) * Refactor hysteresis processor * Improved method of converting to double precision for hysteresis processing * Implement hysteresis with interleaved SIMD instructions * Attempt to fix JUCE modules * Fix submodule and linking errors * Fix speed unit test threshold * Fix .gitignore Co-authored-by: jatinchowdhury18 <[email protected]> Diffstat:
15 files changed, 621 insertions(+), 313 deletions(-)
diff --git a/.gitignore b/.gitignore @@ -15,6 +15,7 @@ Builds BinaryData.h BinaryData*.cpp build*/ +Bin*/ JuceLibraryCode LV2.mak diff --git a/.gitmodules b/.gitmodules @@ -10,3 +10,6 @@ [submodule "Plugin/modules/JUCE"] path = Plugin/modules/JUCE url = https://github.com/lv2-porting-project/JUCE +[submodule "Plugin/modules/chowdsp_juce_dsp"] + path = Plugin/modules/chowdsp_juce_dsp + url = https://github.com/Chowdhury-DSP/chowdsp_juce_dsp diff --git a/CHANGELOG.md b/CHANGELOG.md @@ -3,7 +3,9 @@ All notable changes to this project will be documented in this file. ## UNRELEASED +- Improved hysteresis engine performance by ~1.5x. - Improved oversampling menu with choices for linear vs. minimum phase and real-time vs. offline rendering. +- Made oversampling choices preset-agnostic. - Further improved performance for Hysteresis "STN" mode. ## [2.8.0] - 2021-04-20 diff --git a/Plugin/Source/Headless/CMakeLists.txt b/Plugin/Source/Headless/CMakeLists.txt @@ -16,6 +16,7 @@ target_sources(ChowTapeModel_Headless PRIVATE ScreenshotHelper.cpp UnitTests/UnitTests.cpp + UnitTests/HysteresisOpsTest.cpp UnitTests/MixGroupsTest.cpp UnitTests/SpeedTest.cpp UnitTests/STNTest.cpp diff --git a/Plugin/Source/Headless/UnitTests/HysteresisOpsTest.cpp b/Plugin/Source/Headless/UnitTests/HysteresisOpsTest.cpp @@ -0,0 +1,97 @@ +#include "Processors/Hysteresis/HysteresisProcessing.h" + +class HysteresisOpsTest : public UnitTest +{ +public: + using Vec2 = dsp::SIMDRegister<double>; + + HysteresisOpsTest() : UnitTest ("HysteresisOpsTest") + { + } + + void testLangevin() + { +#if HYSTERESIS_USE_SIMD + double x[] = { 1.0, 2.0, 0.0, -1.0, -0.5 }; + for (auto x_val : x) + { + auto coth = 1.0 / std::tanh (x_val); + + auto near_zero = x_val < 0.001 && x_val > -0.001; + auto near_zero_vec = Vec2::lessThan (x_val, (Vec2) 0.001) & Vec2::greaterThan (x_val, (Vec2) -0.001); + + auto double_val = ! near_zero ? (coth) - (1.0 / x_val) : x_val / 3.0; + auto vec_val = HysteresisOps::langevin ((Vec2) x_val, (Vec2) coth, near_zero_vec).get (0); + expectWithinAbsoluteError (double_val, vec_val, 1.0e-12); + + double_val = ! near_zero ? (1.0 / (x_val * x_val)) - (coth * coth) + 1.0 : (1.0 / 3.0); + vec_val = HysteresisOps::langevinD ((Vec2) x_val, (Vec2) coth, near_zero_vec).get (0); + expectWithinAbsoluteError (double_val, vec_val, 1.0e-12); + + double_val = ! near_zero ? 2.0 * coth * (coth * coth - 1.0) - (2.0 / (x_val * x_val * x_val)) : (-2.0 / 15.0) * x_val; + vec_val = HysteresisOps::langevinD2 ((Vec2) x_val, (Vec2) coth, near_zero_vec).get (0); + expectWithinAbsoluteError (double_val, vec_val, 1.0e-12); + } +#endif + } + + void testSignOps() + { +#if HYSTERESIS_USE_SIMD + auto testFunc = [=] (Vec2 H_d, Vec2 M_diff, Vec2 nc, double kap1_exp, double f1_exp) { + const auto delta = ((Vec2) 1.0 & Vec2::greaterThanOrEqual (H_d, (Vec2) 0.0)) - ((Vec2) 1.0 & Vec2::lessThan (H_d, (Vec2) 0.0)); + const auto delta_M = Vec2::equal (chowdsp::signumSIMD (delta), chowdsp::signumSIMD (M_diff)); + + auto kap1 = (Vec2) nc & delta_M; + auto f1 = (Vec2) nc * delta; + + expectWithinAbsoluteError (kap1.get (0), kap1_exp, 1.0e-12); + expectWithinAbsoluteError (f1.get (0), f1_exp, 1.0e-12); + }; + + testFunc (0.0, 0.0, 1.0, 0.0, 1.0); + testFunc (0.5, 0.5, 1.0, 1.0, 1.0); + testFunc (-0.5, 0.5, 1.0, 0.0, -1.0); + testFunc (-0.5, -0.5, 1.0, 1.0, -1.0); +#endif + } + + void testFullHysteresis() + { + double x[10] = { 1.0, 2.0, 0.0, -1.0, -0.5, -0.1, -0.0, 0.0000012, 0.25, 0.0 }; + double y[10] = { 0.000645624, 0.00145275, 0.000202604, -0.000795881, -0.000370124, -0.000108995, 1.76298e-05, -1.28477e-05, 0.000171267, 3.31988e-05 }; + + HysteresisProcessing hProc; + hProc.setSampleRate (48000.0); + hProc.reset(); + hProc.cook (0.5, 0.5, 0.5, false); + +#if HYSTERESIS_USE_SIMD + for (int n = 0; n < 10; ++n) + { + x[n] = hProc.process<SolverType::NR4> ((Vec2) (x[n] * 0.001)).get (0); + expectWithinAbsoluteError (x[n], y[n], 1.0e-6); + } +#else + for (int n = 0; n < 10; ++n) + x[n] = hProc.process<SolverType::NR4> (x[n] * 0.001); + + std::copy(x, x + 10, std::ostream_iterator<double>(std::cout, ", ")); + std::cout << std::endl; +#endif + } + + void runTest() override + { + beginTest ("Langevin Test"); + testLangevin(); + + beginTest ("Sign Ops Test"); + testSignOps(); + + beginTest ("Hysteresis Process Test"); + testFullHysteresis(); + } +}; + +static HysteresisOpsTest hysteresisOpsTest; diff --git a/Plugin/Source/Headless/UnitTests/SpeedTest.cpp b/Plugin/Source/Headless/UnitTests/SpeedTest.cpp @@ -39,7 +39,12 @@ public: auto duration = (end - start) / 1000.0f; logMessage ("Plugin processing time: " + String (duration) + " seconds"); + + #if JUCE_WINDOWS expectLessThan (duration, 1.0, "Plugin is not fast enough!"); + #else + expectLessThan (duration, 5.0, "Plugin is not fast enough!"); + #endif } }; diff --git a/Plugin/Source/Processors/Hysteresis/HysteresisOps.h b/Plugin/Source/Processors/Hysteresis/HysteresisOps.h @@ -0,0 +1,147 @@ +#pragma once + +#include <JuceHeader.h> +#include <cmath> + +#define HYSTERESIS_USE_SIMD 1 + +namespace HysteresisOps +{ +using namespace chowdsp::SIMDUtils; + +struct HysteresisState +{ + // parameter values + double M_s = 1.0; + double a = M_s / 4.0; + static constexpr double alpha = 1.6e-3; + double k = 0.47875; + double c = 1.7e-1; + + // Save calculations + double nc = 1 - c; + double M_s_oa = M_s / a; + double M_s_oa_talpha = alpha * M_s / a; + double M_s_oa_tc = c * M_s / a; + double M_s_oa_tc_talpha = alpha * c * M_s / a; + double M_s_oaSq_tc_talpha = alpha * c * M_s / (a * a); + double M_s_oaSq_tc_talphaSq = alpha * alpha * c * M_s / (a * a); + + // temp vars +#if HYSTERESIS_USE_SIMD + dsp::SIMDRegister<double> Q, M_diff, L_prime, kap1, f1Denom, f1, f2, f3; + dsp::SIMDRegister<double> coth = 0.0; + dsp::SIMDRegister<double>::vMaskType nearZero; +#else + double Q, M_diff, L_prime, kap1, f1Denom, f1, f2, f3; + double coth = 0.0; + bool nearZero = false; +#endif +}; + +constexpr double ONE_THIRD = 1.0 / 3.0; +constexpr double NEG_TWO_OVER_15 = -2.0 / 15.0; + +constexpr inline int sign (double x) +{ + return (x > 0.0) - (x < 0.0); +} + +/** Langevin function */ +template<typename Float, typename Bool> +static inline Float langevin (Float x, Float coth, Bool nearZero) noexcept +{ +#if HYSTERESIS_USE_SIMD + auto notNearZero = ~ nearZero; + return ((coth - ((Float) 1.0 / x)) & notNearZero) + ((x / 3.0) & nearZero); +#else + return ! nearZero ? (coth) - (1.0 / x) : x / 3.0; +#endif +} + +/** Derivative of Langevin function */ +template<typename Float, typename Bool> +static inline Float langevinD (Float x, Float coth, Bool nearZero) noexcept +{ +#if HYSTERESIS_USE_SIMD + auto notNearZero = ~ nearZero; + return ((((Float) 1.0 / (x * x)) - (coth * coth) + 1.0) & notNearZero) + ((Float) ONE_THIRD & nearZero); +#else + return ! nearZero ? (1.0 / (x * x)) - (coth * coth) + 1.0 : ONE_THIRD; +#endif +} + +/** 2nd derivative of Langevin function */ +template<typename Float, typename Bool> +static inline Float langevinD2 (Float x, Float coth, Bool nearZero) noexcept +{ +#if HYSTERESIS_USE_SIMD + auto notNearZero = ~ nearZero; + return (((Float) 2.0 * coth * (coth * coth - 1.0) - ((Float) 2.0 / (x * x * x))) & notNearZero) + + ((x * NEG_TWO_OVER_15) & nearZero); +#else + return ! nearZero + ? 2.0 * coth * (coth * coth - 1.0) - (2.0 / (x * x * x)) + : NEG_TWO_OVER_15 * x; +#endif +} + +/** Derivative by alpha transform */ +template<typename Float> +static inline Float deriv (Float x_n, Float x_n1, Float x_d_n1, Float T) noexcept +{ + const Float dAlpha = 0.75; + return ((((Float) 1.0 + dAlpha) / T) * (x_n - x_n1)) - dAlpha * x_d_n1; +} + +/** hysteresis function dM/dt */ +template<typename Float> +static inline Float hysteresisFunc (Float M, Float H, Float H_d, HysteresisState& hp) noexcept +{ + hp.Q = (H + M * hp.alpha) * (1.0 / hp.a); + +#if HYSTERESIS_USE_SIMD + hp.coth = (Float) 1.0 / tanhSIMD (hp.Q); + hp.nearZero = Float::lessThan (hp.Q, (Float) 0.001) & Float::greaterThan (hp.Q, (Float) -0.001); +#else + hp.coth = 1.0 / std::tanh (hp.Q); + hp.nearZero = hp.Q < 0.001 && hp.Q > -0.001; +#endif + + hp.M_diff = langevin (hp.Q, hp.coth, hp.nearZero) * hp.M_s - M; + +#if HYSTERESIS_USE_SIMD + const auto delta = ((Float) 1.0 & Float::greaterThanOrEqual (H_d, (Float) 0.0)) - ((Float) 1.0 & Float::lessThan (H_d, (Float) 0.0)); + const auto delta_M = Float::equal (chowdsp::signumSIMD (delta), chowdsp::signumSIMD (hp.M_diff)); + hp.kap1 = (Float) hp.nc & delta_M; +#else + const auto delta = (Float) ((H_d >= 0.0) - (H_d < 0.0)); + const auto delta_M = (Float) (sign (delta) == sign (hp.M_diff)); + hp.kap1 = (Float) hp.nc * delta_M; +#endif + + hp.L_prime = langevinD (hp.Q, hp.coth, hp.nearZero); + + hp.f1Denom = ((Float) hp.nc * delta) * hp.k - (Float) hp.alpha * hp.M_diff; + hp.f1 = hp.kap1 * hp.M_diff / hp.f1Denom; + hp.f2 = hp.L_prime * hp.M_s_oa_tc; + hp.f3 = (Float) 1.0 - (hp.L_prime * hp.M_s_oa_tc_talpha); + + return H_d * (hp.f1 + hp.f2) / hp.f3; +} + +// derivative of hysteresis func w.r.t M (depends on cached values from computing hysteresisFunc) +template<typename Float> +static inline Float hysteresisFuncPrime (Float H_d, Float dMdt, HysteresisState& hp) noexcept +{ + const Float L_prime2 = langevinD2 (hp.Q, hp.coth, hp.nearZero); + const Float M_diff2 = hp.L_prime * hp.M_s_oa_talpha - 1.0; + + const Float f1_p = hp.kap1 * ((M_diff2 / hp.f1Denom) + hp.M_diff * hp.alpha * M_diff2 / (hp.f1Denom * hp.f1Denom)); + const Float f2_p = L_prime2 * hp.M_s_oaSq_tc_talpha; + const Float f3_p = L_prime2 * (-hp.M_s_oaSq_tc_talphaSq); + + return H_d * (f1_p + f2_p) / hp.f3 - dMdt * f3_p / hp.f3; +} + +} // namespace HysteresisOps diff --git a/Plugin/Source/Processors/Hysteresis/HysteresisProcessing.cpp b/Plugin/Source/Processors/Hysteresis/HysteresisProcessing.cpp @@ -1,20 +1,8 @@ #include "HysteresisProcessing.h" #include <math.h> -namespace -{ -constexpr double ONE_THIRD = 1.0 / 3.0; -constexpr double NEG_TWO_OVER_15 = -2.0 / 15.0; -} // namespace - -inline int sign (double x) -{ - return (x > 0.0) - (x < 0.0); -} - HysteresisProcessing::HysteresisProcessing() { - solver = &HysteresisProcessing::NR; } void HysteresisProcessing::reset() @@ -23,8 +11,8 @@ void HysteresisProcessing::reset() H_n1 = 0.0; H_d_n1 = 0.0; - coth = 0.0; - nearZero = false; + hpState.coth = 0.0; + hpState.nearZero = false; } void HysteresisProcessing::setSampleRate (double newSR) @@ -39,183 +27,26 @@ void HysteresisProcessing::cook (float drive, float width, float sat, bool v1) { hysteresisSTN.setParams (sat, width); - M_s = 0.5 + 1.5 * (1.0 - (double) sat); - a = M_s / (0.01 + 6.0 * (double) drive); - c = std::sqrt (1.0f - (double) width) - 0.01; - k = 0.47875; + hpState.M_s = 0.5 + 1.5 * (1.0 - (double) sat); + hpState.a = hpState.M_s / (0.01 + 6.0 * (double) drive); + hpState.c = std::sqrt (1.0f - (double) width) - 0.01; + hpState.k = 0.47875; upperLim = 20.0; if (v1) { - k = 27.0e3; - c = 1.7e-1; - M_s *= 50000.0; - a = M_s / (0.01 + 40.0 * (double) drive); + hpState.k = 27.0e3; + hpState.c = 1.7e-1; + hpState.M_s *= 50000.0; + hpState.a = hpState.M_s / (0.01 + 40.0 * (double) drive); upperLim = 100000.0; } - nc = 1.0 - c; - M_s_oa = M_s / a; - M_s_oa_talpha = alpha * M_s_oa; - M_s_oa_tc = c * M_s_oa; - M_s_oa_tc_talpha = alpha * M_s_oa_tc; - M_s_oaSq_tc_talpha = M_s_oa_tc_talpha / a; - M_s_oaSq_tc_talphaSq = alpha * M_s_oaSq_tc_talpha; -} - -void HysteresisProcessing::setSolver (SolverType solverType) -{ - // defaults - numIter = 0; - solver = &HysteresisProcessing::NR; - - switch (solverType) - { - case SolverType::RK4: - solver = &HysteresisProcessing::RK4; - return; - - case SolverType::STN: - solver = &HysteresisProcessing::STN; - return; - - case SolverType::NR4: - numIter = 4; - return; - - case SolverType::NR8: - numIter = 8; - return; - - default: // RK2 - solver = &HysteresisProcessing::RK2; - }; -} - -inline double HysteresisProcessing::langevin (double x) const noexcept -{ - if (! nearZero) - return (coth) - (1.0 / x); - else - return x / 3.0; -} - -inline double HysteresisProcessing::langevinD (double x) const noexcept -{ - if (! nearZero) - return (1.0 / (x * x)) - (coth * coth) + 1.0; - else - return ONE_THIRD; -} - -inline double HysteresisProcessing::langevinD2 (double x) const noexcept -{ - if (! nearZero) - return 2.0 * coth * (coth * coth - 1.0) - (2.0 / (x * x * x)); - else - return NEG_TWO_OVER_15 * x; - ; -} - -inline double HysteresisProcessing::hysteresisFunc (double M, double H, double H_d) noexcept -{ - Q = (H + alpha * M) / a; - coth = 1.0 / std::tanh (Q); - nearZero = Q < 0.001 && Q > -0.001; - - M_diff = M_s * langevin (Q) - M; - - delta = (double) ((H_d >= 0.0) - (H_d < 0.0)); - delta_M = (double) (sign (delta) == sign (M_diff)); - - L_prime = langevinD (Q); - - kap1 = nc * delta_M; - f1Denom = nc * delta * k - alpha * M_diff; - f1 = kap1 * M_diff / f1Denom; - f2 = M_s_oa_tc * L_prime; - f3 = 1.0 - (M_s_oa_tc_talpha * L_prime); - - return H_d * (f1 + f2) / f3; -} - -inline double HysteresisProcessing::hysteresisFuncPrime (double H_d, double dMdt) const noexcept -{ - const double L_prime2 = langevinD2 (Q); - const double M_diff2 = M_s_oa_talpha * L_prime - 1.0; - - const double f1_p = kap1 * ((M_diff2 / f1Denom) + M_diff * alpha * M_diff2 / (f1Denom * f1Denom)); - const double f2_p = M_s_oaSq_tc_talpha * L_prime2; - const double f3_p = -M_s_oaSq_tc_talphaSq * L_prime2; - - return H_d * (f1_p + f2_p) / f3 - dMdt * f3_p / f3; -} - -inline double HysteresisProcessing::RK2 (double H, double H_d) noexcept -{ - const double k1 = T * hysteresisFunc (M_n1, H_n1, H_d_n1); - const double k2 = T * hysteresisFunc (M_n1 + (k1 / 2.0), (H + H_n1) / 2.0, (H_d + H_d_n1) / 2.0); - - return M_n1 + k2; -} - -double HysteresisProcessing::RK4 (double H, double H_d) noexcept -{ - const double H_1_2 = (H + H_n1) / 2.0; - const double H_d_1_2 = (H_d + H_d_n1) / 2.0; - - const double k1 = T * hysteresisFunc (M_n1, H_n1, H_d_n1); - const double k2 = T * hysteresisFunc (M_n1 + (k1 / 2.0), H_1_2, H_d_1_2); - const double k3 = T * hysteresisFunc (M_n1 + (k2 / 2.0), H_1_2, H_d_1_2); - const double k4 = T * hysteresisFunc (M_n1 + k3, H, H_d); - - return M_n1 + k1 / 6.0 + k2 / 3.0 + k3 / 3.0 + k4 / 6.0; -} - -inline double HysteresisProcessing::NR (double H, double H_d) noexcept -{ - double M = M_n1; - const double last_dMdt = hysteresisFunc (M_n1, H_n1, H_d_n1); - - double dMdt, dMdtPrime, deltaNR; - for (int n = 0; n < numIter; n += 4) - { - // loop #1 - dMdt = hysteresisFunc (M, H, H_d); - dMdtPrime = hysteresisFuncPrime (H_d, dMdt); - deltaNR = (M - M_n1 - Talpha * (dMdt + last_dMdt)) / (1.0 - Talpha * dMdtPrime); - M -= deltaNR; - - // loop #2 - dMdt = hysteresisFunc (M, H, H_d); - dMdtPrime = hysteresisFuncPrime (H_d, dMdt); - deltaNR = (M - M_n1 - Talpha * (dMdt + last_dMdt)) / (1.0 - Talpha * dMdtPrime); - M -= deltaNR; - - // loop #3 - dMdt = hysteresisFunc (M, H, H_d); - dMdtPrime = hysteresisFuncPrime (H_d, dMdt); - deltaNR = (M - M_n1 - Talpha * (dMdt + last_dMdt)) / (1.0 - Talpha * dMdtPrime); - M -= deltaNR; - - // loop #4 - dMdt = hysteresisFunc (M, H, H_d); - dMdtPrime = hysteresisFuncPrime (H_d, dMdt); - deltaNR = (M - M_n1 - Talpha * (dMdt + last_dMdt)) / (1.0 - Talpha * dMdtPrime); - M -= deltaNR; - } - - return M; -} - -inline double HysteresisProcessing::STN (double H, double H_d) noexcept -{ - double input alignas (16)[5] = { H, H_d, H_n1, H_d_n1, M_n1 }; - - // scale derivatives - input[1] *= HysteresisSTN::diffMakeup; - input[3] *= HysteresisSTN::diffMakeup; - FloatVectorOperations::multiply (input, 0.7071 / a, 4); // scale by drive param - - return hysteresisSTN.process (input) + M_n1; + hpState.nc = 1.0 - hpState.c; + hpState.M_s_oa = hpState.M_s / hpState.a; + hpState.M_s_oa_talpha = hpState.alpha * hpState.M_s_oa; + hpState.M_s_oa_tc = hpState.c * hpState.M_s_oa; + hpState.M_s_oa_tc_talpha = hpState.alpha * hpState.M_s_oa_tc; + hpState.M_s_oaSq_tc_talpha = hpState.M_s_oa_tc_talpha / hpState.a; + hpState.M_s_oaSq_tc_talphaSq = hpState.alpha * hpState.M_s_oaSq_tc_talpha; } diff --git a/Plugin/Source/Processors/Hysteresis/HysteresisProcessing.h b/Plugin/Source/Processors/Hysteresis/HysteresisProcessing.h @@ -1,8 +1,8 @@ #ifndef HYSTERESISPROCESSING_H_INCLUDED #define HYSTERESISPROCESSING_H_INCLUDED +#include "HysteresisOps.h" #include "HysteresisSTN.h" -#include "JuceHeader.h" enum SolverType { @@ -28,18 +28,46 @@ public: void setSampleRate (double newSR); void cook (float drive, float width, float sat, bool v1); - void setSolver (SolverType solverType); /* Process a single sample */ - inline double process (double H) noexcept + template<SolverType solver, typename Float> + inline Float process (Float H) noexcept { - double H_d = deriv (H, H_n1, H_d_n1); - double M = (this->*solver) (H, H_d); + auto H_d = HysteresisOps::deriv (H, H_n1, H_d_n1, (Float) T); + + Float M; + switch (solver) + { + case RK2: + M = RK2Solver (H, H_d); + break; + case RK4: + M = RK4Solver (H, H_d); + break; + case NR4: + M = NRSolver<4> (H, H_d); + break; + case NR8: + M = NRSolver<8> (H, H_d); + break; + case STN: + M = STNSolver (H, H_d); + break; + + default: + M = 0.0; + }; // check for instability + #if HYSTERESIS_USE_SIMD + auto notIllCondition = ~ (chowdsp::SIMDUtils::isnanSIMD (M) | Float::greaterThan (M, (Float) upperLim)); + M = M & notIllCondition; + H_d = H_d & notIllCondition; + #else bool illCondition = std::isnan (M) || M > upperLim; M = illCondition ? 0.0 : M; H_d = illCondition ? 0.0 : H_d; + #endif M_n1 = M; H_n1 = H; @@ -49,66 +77,112 @@ public: } private: - inline double langevin (double x) const noexcept; // Langevin function - inline double langevinD (double x) const noexcept; // Derivative of Langevin function - inline double langevinD2 (double x) const noexcept; // 2nd derivative of Langevin function - inline double deriv (double x_n, double x_n1, double x_d_n1) const noexcept // Derivative by alpha transform + // runge-kutta solvers + template<typename Float> + inline Float RK2Solver (Float H, Float H_d) noexcept { - constexpr double dAlpha = 0.75; - return (((1.0 + dAlpha) / T) * (x_n - x_n1)) - dAlpha * x_d_n1; + const Float k1 = HysteresisOps::hysteresisFunc (M_n1, H_n1, H_d_n1, hpState) * T; + const Float k2 = HysteresisOps::hysteresisFunc (M_n1 + (k1 * 0.5), (H + H_n1) * 0.5, (H_d + H_d_n1) * 0.5, hpState) * T; + + return M_n1 + k2; } - // hysteresis function dM/dt - inline double hysteresisFunc (double M, double H, double H_d) noexcept; + template<typename Float> + inline Float RK4Solver (Float H, Float H_d) noexcept + { + const Float H_1_2 = (H + H_n1) * 0.5; + const Float H_d_1_2 = (H_d + H_d_n1) * 0.5; - // derivative of hysteresis func w.r.t M (depends on cached values from computing hysteresisFunc) - inline double hysteresisFuncPrime (double H_d, double dMdt) const noexcept; + const Float k1 = HysteresisOps::hysteresisFunc (M_n1, H_n1, H_d_n1, hpState) * T; + const Float k2 = HysteresisOps::hysteresisFunc (M_n1 + (k1 * 0.5), H_1_2, H_d_1_2, hpState) * T; + const Float k3 = HysteresisOps::hysteresisFunc (M_n1 + (k2 * 0.5), H_1_2, H_d_1_2, hpState) * T; + const Float k4 = HysteresisOps::hysteresisFunc (M_n1 + k3, H, H_d, hpState) * T; - // runge-kutta solvers - inline double RK2 (double H, double H_d) noexcept; - inline double RK4 (double H, double H_d) noexcept; + constexpr double oneSixth = 1.0 / 6.0; + constexpr double oneThird = 1.0 / 3.0; + return M_n1 + k1 * oneSixth + k2 * oneThird + k3 * oneThird + k4 * oneSixth; + } // newton-raphson solvers - inline double NR (double H, double H_d) noexcept; - int numIter = 0; + template<int nIterations, typename Float> + inline Float NRSolver (Float H, Float H_d) noexcept + { + using namespace chowdsp::SIMDUtils; + + Float M = M_n1; + const Float last_dMdt = HysteresisOps::hysteresisFunc (M_n1, H_n1, H_d_n1, hpState); + + Float dMdt, dMdtPrime, deltaNR; + for (int n = 0; n < nIterations; ++n) + { + dMdt = HysteresisOps::hysteresisFunc (M, H, H_d, hpState); + dMdtPrime = HysteresisOps::hysteresisFuncPrime (H_d, dMdt, hpState); + deltaNR = (M - M_n1 - (Float) Talpha * (dMdt + last_dMdt)) / (Float (1.0) - (Float) Talpha * dMdtPrime); + M -= deltaNR; + } + + return M; + } // state transition network solver - inline double STN (double H, double H_d) noexcept; - HysteresisSTN hysteresisSTN; + template<typename Float> + inline Float STNSolver (Float H, Float H_d) noexcept + { +#if HYSTERESIS_USE_SIMD + double H_arr[2], H_d_arr[2], H_n1_arr[2], H_d_n1_arr[2], M_n1_arr[2]; + double M_out alignas (16)[2]; - // solver function pointer - using Solver = double (HysteresisProcessing::*) (double, double); - Solver solver; + H.copyToRawArray (H_arr); + H_d.copyToRawArray (H_d_arr); + H_n1.copyToRawArray (H_n1_arr); + H_d_n1.copyToRawArray (H_d_n1_arr); + M_n1.copyToRawArray (M_n1_arr); + + for (int ch = 0; ch < 2; ++ch) + { + double input alignas (16)[5] = { H_arr[ch], H_d_arr[ch], H_n1_arr[ch], H_d_n1_arr[ch], M_n1_arr[ch] }; + + // scale derivatives + input[1] *= HysteresisSTN::diffMakeup; + input[3] *= HysteresisSTN::diffMakeup; + FloatVectorOperations::multiply (input, 0.7071 / hpState.a, 4); // scale by drive param + + M_out[ch] = hysteresisSTN.process (input) + M_n1_arr[ch]; + } + + return Float::fromRawArray (M_out); + +#else + double input alignas (16)[5] = { H, H_d, H_n1, H_d_n1, M_n1 }; + + // scale derivatives + input[1] *= HysteresisSTN::diffMakeup; + input[3] *= HysteresisSTN::diffMakeup; + FloatVectorOperations::multiply (input, 0.7071 / hpState.a, 4); // scale by drive param + + return hysteresisSTN.process (input) + M_n1; +#endif + } // parameter values double fs = 48000.0; double T = 1.0 / fs; double Talpha = T / 1.9; - double M_s = 1.0; - double a = M_s / 4.0; - const double alpha = 1.6e-3; - double k = 0.47875; - double c = 1.7e-1; double upperLim = 20.0; - // Save calculations - double nc = 1 - c; - double M_s_oa = M_s / a; - double M_s_oa_talpha = alpha * M_s / a; - double M_s_oa_tc = c * M_s / a; - double M_s_oa_tc_talpha = alpha * c * M_s / a; - double M_s_oaSq_tc_talpha = alpha * c * M_s / (a * a); - double M_s_oaSq_tc_talphaSq = alpha * alpha * c * M_s / (a * a); - // state variables +#if HYSTERESIS_USE_SIMD + dsp::SIMDRegister<double> M_n1 = 0.0; + dsp::SIMDRegister<double> H_n1 = 0.0; + dsp::SIMDRegister<double> H_d_n1 = 0.0; +#else double M_n1 = 0.0; double H_n1 = 0.0; double H_d_n1 = 0.0; +#endif - // temp vars - double Q, M_diff, delta, delta_M, L_prime, kap1, f1Denom, f1, f2, f3; - double coth = 0.0; - bool nearZero = false; + HysteresisSTN hysteresisSTN; + HysteresisOps::HysteresisState hpState; JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (HysteresisProcessing) }; diff --git a/Plugin/Source/Processors/Hysteresis/HysteresisProcessor.cpp b/Plugin/Source/Processors/Hysteresis/HysteresisProcessor.cpp @@ -1,10 +1,47 @@ #include "HysteresisProcessor.h" +namespace +{ enum { numSteps = 500, }; +constexpr double v1Norm = 1.414 / 10000.0; + +template<typename T> +static void interleaveSamples (const T** source, T* dest, int numSamples, int numChannels) +{ + for (int chan = 0; chan < numChannels; ++chan) + { + auto i = chan; + auto src = source [chan]; + + for (int j = 0; j < numSamples; ++j) + { + dest [i] = src [j]; + i += numChannels; + } + } +} + +template<typename T> +static void deinterleaveSamples (const T* source, T** dest, int numSamples, int numChannels) +{ + for (int chan = 0; chan < numChannels; ++chan) + { + auto i = chan; + auto dst = dest [chan]; + + for (int j = 0; j < numSamples; ++j) + { + dst [j] = source [i]; + i += numChannels; + } + } +} +} // namespace + HysteresisProcessor::HysteresisProcessor (AudioProcessorValueTreeState& vts, const AudioProcessor& p) : osManager (vts, p) { driveParam = vts.getRawParameterValue ("drive"); @@ -18,8 +55,9 @@ HysteresisProcessor::HysteresisProcessor (AudioProcessorValueTreeState& vts, con drive[ch].reset (numSteps); width[ch].reset (numSteps); sat[ch].reset (numSteps); - makeup[ch].reset (numSteps); } + + makeup.reset (numSteps); } void HysteresisProcessor::createParameterLayout (std::vector<std::unique_ptr<RangedAudioParameter>>& params) @@ -36,65 +74,53 @@ void HysteresisProcessor::createParameterLayout (std::vector<std::unique_ptr<Ran void HysteresisProcessor::setSolver (int newSolver) { if (newSolver == SolverType::NUM_SOLVERS) // V1 - { useV1 = true; - newSolver = 1; // RK4 - } else - { useV1 = false; - } - for (int ch = 0; ch < 2; ++ch) - hProcs[ch].setSolver (static_cast<SolverType> (newSolver)); + solver = useV1 ? RK4 : static_cast<SolverType> (newSolver); // set clip level for solver - switch (newSolver) + switch (solver) { - case 0: // RK2 - case 1: // RK4 - clipLevel = 10.0f; + case RK2: + case RK4: + clipLevel = 10.0; return; - case 2: // NR4 - case 3: // NR8 - clipLevel = 12.5f; + case NR4: + case NR8: + clipLevel = 12.5; return; default: - clipLevel = 20.0f; + clipLevel = 20.0; }; } -float HysteresisProcessor::calcMakeup() +double HysteresisProcessor::calcMakeup() { - return (1.0f + 0.6f * width[0].getTargetValue()) / (0.5f + 1.5f * (1.0f - sat[0].getTargetValue())); + return (1.0 + 0.6 * width[0].getTargetValue()) / (0.5 + 1.5 * (1.0 - sat[0].getTargetValue())); } void HysteresisProcessor::setDrive (float newDrive) { for (int ch = 0; ch < 2; ++ch) { - drive[ch].setTargetValue (newDrive); + drive[ch].setTargetValue ((double) newDrive); } } void HysteresisProcessor::setWidth (float newWidth) { for (int ch = 0; ch < 2; ++ch) - { - width[ch].setTargetValue (newWidth); - makeup[ch].setTargetValue (calcMakeup()); - } + width[ch].setTargetValue ((double) newWidth); } void HysteresisProcessor::setSaturation (float newSaturation) { for (int ch = 0; ch < 2; ++ch) - { - sat[ch].setTargetValue (newSaturation); - makeup[ch].setTargetValue (calcMakeup()); - } + sat[ch].setTargetValue ((double) newSaturation); } void HysteresisProcessor::setOversampling() @@ -114,12 +140,12 @@ void HysteresisProcessor::setOversampling() void HysteresisProcessor::calcBiasFreq() { - biasFreq = fs * osManager.getOSFactor() / 2.0f; + biasFreq = fs * osManager.getOSFactor() / 2.0; } void HysteresisProcessor::prepareToPlay (double sampleRate, int samplesPerBlock) { - fs = (float) sampleRate; + fs = sampleRate; wasV1 = useV1; calcBiasFreq(); @@ -128,20 +154,29 @@ void HysteresisProcessor::prepareToPlay (double sampleRate, int samplesPerBlock) drive[ch].skip (numSteps); width[ch].skip (numSteps); sat[ch].skip (numSteps); - makeup[ch].skip (numSteps); hProcs[ch].setSampleRate (sampleRate * osManager.getOSFactor()); hProcs[ch].cook (drive[ch].getCurrentValue(), width[ch].getCurrentValue(), sat[ch].getCurrentValue(), wasV1); hProcs[ch].reset(); - biasAngle[ch] = 0.0f; + biasAngle[ch] = 0.0; } + + makeup.skip (numSteps); osManager.prepareToPlay (sampleRate, samplesPerBlock); for (int ch = 0; ch < 2; ++ch) dcBlocker[ch].prepare (sampleRate, dcFreq); + doubleBuffer.setSize (2, samplesPerBlock); bypass.prepare (samplesPerBlock, bypass.toBool (onOffParam)); + +#if HYSTERESIS_USE_SIMD + const auto maxOSBlockSize = (uint32) samplesPerBlock * 16; + interleaved = dsp::AudioBlock<Vec2> (interleavedBlockData, 1, maxOSBlockSize); + zero = dsp::AudioBlock<double> (zeroData, Vec2::size(), maxOSBlockSize); + zero.clear(); +#endif } void HysteresisProcessor::releaseResources() @@ -165,6 +200,7 @@ void HysteresisProcessor::processBlock (AudioBuffer<float>& buffer, MidiBuffer& setDrive (*driveParam); setSaturation (*satParam); setWidth (1.0f - *widthParam); + makeup.setTargetValue (calcMakeup()); setOversampling(); bool needsSmoothing = drive[0].isSmoothing() || width[0].isSmoothing() || sat[0].isSmoothing() || wasV1 != useV1; @@ -185,44 +221,134 @@ void HysteresisProcessor::processBlock (AudioBuffer<float>& buffer, MidiBuffer& clipLevel, buffer.getNumSamples()); - dsp::AudioBlock<float> block (buffer); - dsp::AudioBlock<float> osBlock = osManager.getOversampler()->processSamplesUp (block); + doubleBuffer.makeCopyOf (buffer, true); - if (needsSmoothing) + dsp::AudioBlock<double> block (doubleBuffer); + dsp::AudioBlock<double> osBlock = osManager.getOversampler()->processSamplesUp (block); + +#if HYSTERESIS_USE_SIMD + const auto n = osBlock.getNumSamples(); + auto* inout = channelPointers.getData(); + for (size_t ch = 0; ch < Vec2::size(); ++ch) + inout[ch] = (ch < osBlock.getNumChannels() ? const_cast<double*> (osBlock.getChannelPointer (ch)) : zero.getChannelPointer (ch)); + + // interleave channels + interleaveSamples (inout, reinterpret_cast<double*> (interleaved.getChannelPointer (0)), + static_cast<int> (n), static_cast<int> (Vec2::size())); + + auto processBlock = interleaved.getSubBlock (0, n); +#else + auto processBlock = osBlock; +#endif + + if (useV1) { - if (useV1) - processSmoothV1 (osBlock); + if (needsSmoothing) + processSmoothV1 (processBlock); else - processSmooth (osBlock); + processV1 (processBlock); } else { - if (useV1) - processV1 (osBlock); - else - process (osBlock); + switch (solver) + { + case RK2: + if (needsSmoothing) + processSmooth<RK2> (processBlock); + else + process<RK2> (processBlock); + break; + case RK4: + if (needsSmoothing) + processSmooth<RK4> (processBlock); + else + process<RK4> (processBlock); + break; + case NR4: + if (needsSmoothing) + processSmooth<NR4> (processBlock); + else + process<NR4> (processBlock); + break; + case NR8: + if (needsSmoothing) + processSmooth<NR8> (processBlock); + else + process<NR8> (processBlock); + break; + case STN: + if (needsSmoothing) + processSmooth<STN> (processBlock); + else + process<STN> (processBlock); + break; + default: + jassertfalse; // unknown solver! + }; } +#if HYSTERESIS_USE_SIMD + // de-interleave channels + deinterleaveSamples (reinterpret_cast<double*> (interleaved.getChannelPointer (0)), + const_cast<double**> (inout), + static_cast<int> (n), static_cast<int> (Vec2::size())); +#endif + osManager.getOversampler()->processSamplesDown (block); + buffer.makeCopyOf (doubleBuffer, true); applyDCBlockers (buffer); bypass.processBlockOut (buffer, bypass.toBool (onOffParam)); } -void HysteresisProcessor::process (dsp::AudioBlock<float>& block) +template <typename T, typename SmoothType> +void applyMakeup (dsp::AudioBlock<T>& block, SmoothType& makeup) +{ +#if 1 // HYSTERESIS_USE_SIMD + const auto numSamples = block.getNumSamples(); + const auto numChannels = block.getNumChannels(); + + if (makeup.isSmoothing()) + { + for (size_t i = 0; i < numSamples; ++i) + { + const auto scaler = makeup.getNextValue(); + + for (size_t ch = 0; ch < numChannels; ++ch) + block.getChannelPointer (ch)[i] *= scaler; + } + } + else + { + const auto scaler = makeup.getTargetValue(); + for (size_t ch = 0; ch < numChannels; ++ch) + { + auto* x = block.getChannelPointer (ch); + for (size_t i = 0; i < numSamples; ++i) + x[i] *= scaler; + } + } +#else + block *= makeup; +#endif +} + +template <SolverType solverType, typename T> +void HysteresisProcessor::process (dsp::AudioBlock<T>& block) { for (size_t channel = 0; channel < block.getNumChannels(); ++channel) { auto* x = block.getChannelPointer (channel); for (size_t samp = 0; samp < block.getNumSamples(); samp++) - { - x[samp] = (float) hProcs[channel].process ((double) x[samp]) * makeup[channel].getNextValue(); - } + x[samp] = hProcs[channel].process<solverType> (x[samp]); } + + applyMakeup (block, makeup); } -void HysteresisProcessor::processSmooth (dsp::AudioBlock<float>& block) +template <SolverType solverType, typename T> +void HysteresisProcessor::processSmooth (dsp::AudioBlock<T>& block) { for (size_t channel = 0; channel < block.getNumChannels(); ++channel) { @@ -230,35 +356,36 @@ void HysteresisProcessor::processSmooth (dsp::AudioBlock<float>& block) for (size_t samp = 0; samp < block.getNumSamples(); samp++) { hProcs[channel].cook (drive[channel].getNextValue(), width[channel].getNextValue(), sat[channel].getNextValue(), false); - - x[samp] = (float) hProcs[channel].process ((double) x[samp]) * makeup[channel].getNextValue(); + x[samp] = hProcs[channel].process<solverType> (x[samp]); } } + + applyMakeup (block, makeup); } -void HysteresisProcessor::processV1 (dsp::AudioBlock<float>& block) +template<typename T> +void HysteresisProcessor::processV1 (dsp::AudioBlock<T>& block) { - const auto angleDelta = MathConstants<float>::twoPi * biasFreq / (fs * osManager.getOSFactor()); + const auto angleDelta = MathConstants<double>::twoPi * biasFreq / (fs * osManager.getOSFactor()); for (size_t channel = 0; channel < block.getNumChannels(); ++channel) { auto* x = block.getChannelPointer (channel); for (size_t samp = 0; samp < block.getNumSamples(); samp++) { - float bias = biasGain * (1.0f - width[channel].getCurrentValue()) * std::sin (biasAngle[channel]); + auto bias = biasGain * (1.0 - width[channel].getCurrentValue()) * std::sin (biasAngle[channel]); biasAngle[channel] += angleDelta; - biasAngle[channel] -= MathConstants<float>::twoPi * (biasAngle[channel] >= MathConstants<float>::twoPi); + biasAngle[channel] -= MathConstants<double>::twoPi * (biasAngle[channel] >= MathConstants<double>::twoPi); - x[samp] = (float) hProcs[channel].process (10000.0 * (double) (x[samp] + bias)); + x[samp] = hProcs[channel].process<RK4> ((x[samp] + bias) * 10000.0) * v1Norm; } - - FloatVectorOperations::multiply (x, 1.414f / 10000.0f, (int) block.getNumSamples()); } } -void HysteresisProcessor::processSmoothV1 (dsp::AudioBlock<float>& block) +template<typename T> +void HysteresisProcessor::processSmoothV1 (dsp::AudioBlock<T>& block) { - const auto angleDelta = MathConstants<float>::twoPi * biasFreq / (fs * osManager.getOSFactor()); + const auto angleDelta = MathConstants<double>::twoPi * biasFreq / (fs * osManager.getOSFactor()); for (size_t channel = 0; channel < block.getNumChannels(); ++channel) { @@ -267,14 +394,12 @@ void HysteresisProcessor::processSmoothV1 (dsp::AudioBlock<float>& block) { hProcs[channel].cook (drive[channel].getNextValue(), width[channel].getNextValue(), sat[channel].getNextValue(), true); - float bias = biasGain * (1.0f - width[channel].getCurrentValue()) * std::sin (biasAngle[channel]); + auto bias = biasGain * (1.0 - width[channel].getCurrentValue()) * std::sin (biasAngle[channel]); biasAngle[channel] += angleDelta; - biasAngle[channel] -= MathConstants<float>::twoPi * (biasAngle[channel] >= MathConstants<float>::twoPi); + biasAngle[channel] -= MathConstants<double>::twoPi * (biasAngle[channel] >= MathConstants<double>::twoPi); - x[samp] = (float) hProcs[channel].process (10000.0 * (double) (x[samp] + bias)); + x[samp] = hProcs[channel].process<RK4> ((x[samp] + bias) * 10000.0) * v1Norm; } - - FloatVectorOperations::multiply (x, 1.414f / 10000.0f, (int) block.getNumSamples()); } } diff --git a/Plugin/Source/Processors/Hysteresis/HysteresisProcessor.h b/Plugin/Source/Processors/Hysteresis/HysteresisProcessor.h @@ -32,13 +32,17 @@ private: void setSaturation (float newSat); void setWidth (float newWidth); void setOversampling(); - float calcMakeup(); + double calcMakeup(); void calcBiasFreq(); - void process (dsp::AudioBlock<float>& block); - void processSmooth (dsp::AudioBlock<float>& block); - void processV1 (dsp::AudioBlock<float>& block); - void processSmoothV1 (dsp::AudioBlock<float>& block); + template <SolverType solverType, typename T> + void process (dsp::AudioBlock<T>& block); + template <SolverType solverType, typename T> + void processSmooth (dsp::AudioBlock<T>& block); + template <typename T> + void processV1 (dsp::AudioBlock<T>& block); + template <typename T> + void processSmoothV1 (dsp::AudioBlock<T>& block); void applyDCBlockers (AudioBuffer<float>& buffer); std::atomic<float>* driveParam = nullptr; @@ -47,26 +51,37 @@ private: std::atomic<float>* modeParam = nullptr; std::atomic<float>* onOffParam = nullptr; - SmoothedValue<float, ValueSmoothingTypes::Linear> drive[2]; - SmoothedValue<float, ValueSmoothingTypes::Linear> width[2]; - SmoothedValue<float, ValueSmoothingTypes::Linear> sat[2]; - SmoothedValue<float, ValueSmoothingTypes::Multiplicative> makeup[2]; + SmoothedValue<double, ValueSmoothingTypes::Linear> drive[2]; + SmoothedValue<double, ValueSmoothingTypes::Linear> width[2]; + SmoothedValue<double, ValueSmoothingTypes::Linear> sat[2]; + SmoothedValue<double, ValueSmoothingTypes::Multiplicative> makeup; - float fs = 44100.0f; + double fs = 44100.0f; HysteresisProcessing hProcs[2]; + SolverType solver; OversamplingManager osManager; // needs oversampling to avoid aliasing DCBlocker dcBlocker[2]; - const float dcFreq = 35.0f; + static constexpr double dcFreq = 35.0; - float biasGain = 10.0f; - float biasFreq = 48000.0f; - float biasAngle[2]; + double biasGain = 10.0; + double biasFreq = 48000.0; + double biasAngle[2]; bool wasV1 = false, useV1 = false; - float clipLevel = 20.0f; + double clipLevel = 20.0; + AudioBuffer<double> doubleBuffer; BypassProcessor bypass; +#if HYSTERESIS_USE_SIMD + using Vec2 = dsp::SIMDRegister<double>; + dsp::AudioBlock<Vec2> interleaved; + dsp::AudioBlock<double> zero; + + HeapBlock<char> interleavedBlockData, zeroData; + HeapBlock<const double*> channelPointers { Vec2::size() }; +#endif + JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (HysteresisProcessor) }; diff --git a/Plugin/Source/Processors/Hysteresis/OversamplingManager.cpp b/Plugin/Source/Processors/Hysteresis/OversamplingManager.cpp @@ -10,8 +10,8 @@ OversamplingManager::OversamplingManager (const AudioProcessorValueTreeState& vt for (int i = 0; i < numOSChoices; ++i) { - overSample[i] = std::make_unique<dsp::Oversampling<float>> (2, i, dsp::Oversampling<float>::filterHalfBandPolyphaseIIR); - overSample[i + numOSChoices] = std::make_unique<dsp::Oversampling<float>> (2, i, dsp::Oversampling<float>::filterHalfBandFIREquiripple); + overSample[i] = std::make_unique<dsp::Oversampling<double>> (2, i, dsp::Oversampling<double>::filterHalfBandPolyphaseIIR); + overSample[i + numOSChoices] = std::make_unique<dsp::Oversampling<double>> (2, i, dsp::Oversampling<double>::filterHalfBandFIREquiripple); } } diff --git a/Plugin/Source/Processors/Hysteresis/OversamplingManager.h b/Plugin/Source/Processors/Hysteresis/OversamplingManager.h @@ -16,10 +16,10 @@ public: bool updateOSFactor(); static int getOSIndex (float osFactor, float osMode) { return (int) osFactor + (numOSChoices * (int) osMode); } - float getLatencySamples() const noexcept { return overSample[curOS]->getLatencyInSamples(); } - float getLatencyMilliseconds (int osIndex) const noexcept { return (overSample[osIndex]->getLatencyInSamples() / sampleRate) * 1000.0f; } + float getLatencySamples() const noexcept { return (float) overSample[curOS]->getLatencyInSamples(); } + float getLatencyMilliseconds (int osIndex) const noexcept { return ((float) overSample[osIndex]->getLatencyInSamples() / sampleRate) * 1000.0f; } - dsp::Oversampling<float>* getOversampler() { return overSample[curOS].get(); } + dsp::Oversampling<double>* getOversampler() { return overSample[curOS].get(); } private: std::atomic<float>* osParam = nullptr; @@ -33,7 +33,7 @@ private: float sampleRate = 48000.0f; static constexpr int numOSChoices = 5; - std::unique_ptr<dsp::Oversampling<float>> overSample[2 * numOSChoices]; + std::unique_ptr<dsp::Oversampling<double>> overSample[2 * numOSChoices]; const AudioProcessor& proc; diff --git a/Plugin/modules/CMakeLists.txt b/Plugin/modules/CMakeLists.txt @@ -5,6 +5,7 @@ message(STATUS "VERSION for JUCE: ${juce_version}") juce_add_modules(foleys_gui_magic) juce_add_modules(chowdsp_utils) +juce_add_modules(chowdsp_juce_dsp) # Using RTNeural with XSimd backend set(RTNEURAL_XSIMD ON CACHE BOOL "Use RTNeural with XSimd backend" FORCE) @@ -18,8 +19,9 @@ target_link_libraries(juce_plugin_modules BinaryData juce::juce_audio_utils juce::juce_audio_plugin_client - foleys_gui_magic + chowdsp_juce_dsp chowdsp_utils + foleys_gui_magic RTNeural PUBLIC juce::juce_recommended_config_flags @@ -27,6 +29,8 @@ target_link_libraries(juce_plugin_modules warning_flags ) +target_include_directories(juce_plugin_modules PUBLIC RTNeural/modules/xsimd/include) + target_compile_definitions(juce_plugin_modules PUBLIC JUCE_DISPLAY_SPLASH_SCREEN=0 @@ -36,6 +40,8 @@ target_compile_definitions(juce_plugin_modules JUCE_VST3_CAN_REPLACE_VST2=0 FOLEYS_SHOW_GUI_EDITOR_PALLETTE=0 FOLEYS_ENABLE_BINARY_DATA=1 + CHOWDSP_USE_XSIMD=1 + CHOWDSP_USE_CUSTOM_JUCE_DSP=1 JucePlugin_Manufacturer="chowdsp" JucePlugin_VersionString="${CMAKE_PROJECT_VERSION}" JucePlugin_Name="${CMAKE_PROJECT_NAME}" diff --git a/Plugin/modules/chowdsp_juce_dsp b/Plugin/modules/chowdsp_juce_dsp @@ -0,0 +1 @@ +Subproject commit 7f1a01b4461e1e6a7d00e0c55b08054d11b58e9f