custom_dsp.h

Go to the documentation of this file.

 
#if !defined(DSY_CUSTOM_DSP_H) && defined __cplusplus
#define DSY_CUSTOM_DSP_H
#include <math.h>
 
#include "basicmaths.h"
#undef min
#undef max
#undef abs
#undef exp
#undef sqrt
#undef pow
#undef log
#undef rand
#undef clamp
 
#define PI_F 3.1415927410125732421875f
#define TWOPI_F (2.0f * PI_F)
#define HALFPI_F (PI_F * 0.5f)
#define DSY_MIN(in, mn) (in < mn ? in : mn)
#define DSY_MAX(in, mx) (in > mx ? in : mx)
#define DSY_CLAMP(in, mn, mx) (DSY_MIN(DSY_MAX(in, mn), mx))
 
namespace daisysp
{
//Avoids division for random floats. e.g. rand() * kRandFrac
static constexpr float kRandFrac = 1.f / (float)RAND_MAX;
 
//Convert from semitones to other units. e.g. 2 ^ (kOneTwelfth * x)
static constexpr float kOneTwelfth = 1.f / 12.f;
 
inline float fmax(float a, float b)
{
    float r;
#ifdef ARM_MATH_CM7
    asm("vmaxnm.f32 %[d], %[n], %[m]" : [d] "=t"(r) : [n] "t"(a), [m] "t"(b) :);
#else
    r = (a > b) ? a : b;
#endif // ARM_MATH_CM7
    return r;
}
 
inline float fmin(float a, float b)
{
    float r;
#ifdef ARM_MATH_CM7
    asm("vminnm.f32 %[d], %[n], %[m]" : [d] "=t"(r) : [n] "t"(a), [m] "t"(b) :);
#else
    r = (a < b) ? a : b;
#endif // ARM_MATH_CM7
    return r;
}
 
inline float fclamp(float in, float min, float max)
{
    return fmin(fmax(in, min), max);
}
 
#if 0
inline float fastpower(float f, int n)
{
    long *lp, l;
    lp = (long *)(&f);
    l  = *lp;
    l -= 0x3F800000;
    l <<= (n - 1);
    l += 0x3F800000;
    *lp = l;
    return f;
}
#else
#define fastpower(f, n) (fast_powf(f, n))
#endif
 
inline float fastroot(float f, int n)
{
    long *lp, l;
    lp = (long *)(&f);
    l  = *lp;
    l -= 0x3F800000;
    l >>= (n = 1);
    l += 0x3F800000;
    *lp = l;
    return f;
}
 
#if 0
inline float pow10f(float f)
{
    return expf(2.302585092994046f * f);
}
#else
#define pow10f(x) (fast_powf(10.f, x))
#endif
 
/* Original code for fastlog2f by Dr. Paul Beckmann from the ARM community forum, adapted from the CMSIS-DSP library
About 25% performance increase over std::log10f
*/
#if 0
inline float fastlog2f(float f)
{
    float frac;
    int   exp;
    frac = frexpf(fabsf(f), &exp);
    f    = 1.23149591368684f;
    f *= frac;
    f += -4.11852516267426f;
    f *= frac;
    f += 6.02197014179219f;
    f *= frac;
    f += -3.13396450166353f;
    f += exp;
    return (f);
}
#else
#define fastlog2f(x) fast_log2f(x)
#endif
 
#if 0
inline float fastlog10f(float f)
{
    return fastlog2f(f) * 0.3010299956639812f;
}
#else
#define fastlog10f(x) fast_log10f(x)
#endif
 
inline float mtof(float m)
{
    return powf(2, (m - 69.0f) / 12.0f) * 440.0f;
}
 
 
inline void fonepole(float &out, float in, float coeff)
{
    out += coeff * (in - out);
}
 
template <typename T>
T median(T a, T b, T c)
{
    return (b < a) ? (b < c) ? (c < a) ? c : a : b
                   : (a < c) ? (c < b) ? c : b : a;
}
 
inline float ThisBlepSample(float t)
{
    return 0.5f * t * t;
}
 
inline float NextBlepSample(float t)
{
    t = 1.0f - t;
    return -0.5f * t * t;
}
 
inline float NextIntegratedBlepSample(float t)
{
    const float t1 = 0.5f * t;
    const float t2 = t1 * t1;
    const float t4 = t2 * t2;
    return 0.1875f - t1 + 1.5f * t2 - t4;
}
 
inline float ThisIntegratedBlepSample(float t)
{
    return NextIntegratedBlepSample(1.0f - t);
}
 
inline float SoftLimit(float x)
{
    return x * (27.f + x * x) / (27.f + 9.f * x * x);
}
 
inline float SoftClip(float x)
{
    if(x < -3.0f)
        return -1.0f;
    else if(x > 3.0f)
        return 1.0f;
    else
        return SoftLimit(x);
}
 
inline void TestFloat(float &x, float y = 0.f)
{
    if(!isnormal(x) && x != 0)
    {
#ifdef DEBUG
        asm("bkpt 255");
#else
        x = y;
#endif
    }
}
 
inline float soft_saturate(float in, float thresh)
{
    bool  flip;
    float val, out;
    //val = fabsf(in);
    flip = val < 0.0f;
    val  = flip ? -in : in;
    if(val < thresh)
    {
        out = in;
    }
    else if(val > 1.0f)
    {
        out = (thresh + 1.0f) / 2.0f;
        if(flip)
            out *= -1.0f;
    }
    else if(val > thresh)
    {
        float temp;
        temp = (val - thresh) / (1 - thresh);
        out  = thresh + (val - thresh) / (1.0f + (temp * temp));
        if(flip)
            out *= -1.0f;
    }
    return out;
    //    return val < thresh
    //               ? val
    //               : val > 1.0f
    //                     ? (thresh + 1.0f) / 2.0f
    //                     : thresh
    //                           + (val - thresh)
    //                                 / (1.0f
    //                                    + (((val - thresh) / (1.0f - thresh))
    //                                       * ((val - thresh) / (1.0f - thresh))));
}
} // namespace daisysp
#endif