LibBasicFunctions.h

Go to the documentation of this file.

/**************************************************************************/
#include <cstddef>
#include <new>
#include <atomic>
#include <cmath>
 
#include <arm_math.h>
#include "sysPlatform/SysTypes.h"
#include "sysPlatform/AudioStream.h"
 
#include "Aviate/Aviate.h"
#include "Aviate/AviateTypes.h"
#include "Aviate/ForwardDeclares.h"
 
#ifndef AVIATE_LIBBASICFUNCTIONS_H_
#define AVIATE_LIBBASICFUNCTIONS_H_
 
namespace Aviate {
 
extern const size_t AUDIO_BLOCK_SIZE_BYTES;
 
/**************************************************************************/
struct AVIATE_API QueuePosition {
    int offset; 
    int index;  
};
 
QueuePosition AVIATE_API calcQueuePosition(float milliseconds);
 
QueuePosition AVIATE_API calcQueuePosition(size_t numSamples);
 
size_t AVIATE_API calcAudioSamples(float milliseconds);
 
float AVIATE_API calcAudioTimeMs(size_t numSamples);
 
size_t AVIATE_API calcOffset(QueuePosition position);
 
void AVIATE_API clearAudioBlock(audio_block_t *block);
 
void AVIATE_API alphaBlend(audio_block_t *out, audio_block_t *dry, audio_block_t* wet, float mix);
 
void AVIATE_API gainAdjust(audio_block_t *out, audio_block_t *in, float vol, int coeffShift = 0);
 
void AVIATE_API combine(audio_block_t *out, audio_block_t *in0, audio_block_t *in1);
 
float AVIATE_API calcVolumeExp(float volumeIn);
 
float AVIATE_API convertLinearToLogPow(float inputValue, float midpoint = 0.8f);
 
float AVIATE_API log2Fast(float input);
 
float AVIATE_API log10Fast(float input);
 
float AVIATE_API dbfsFast(int16_t inputAbs);
 
float dbfsFast(float inputAbs);
 
uint16_t AVIATE_API getPeakAbsIntegerValue(const int16_t* audioDataPtr);
 
template<typename T>
T AVIATE_API saturate(T val, T min, T max) {
    if (val < min) { return min; }
    if (val > max) { return max; }
    return val;
}
 
/**************************************************************************/
class AVIATE_API AudioDelay {
public:
    AudioDelay() = delete;
 
    AudioDelay(size_t maxSamples);
 
    AudioDelay(float maxDelayTimeMs);
 
    //AudioDelay(baCore::ExtMemSlot *slot);
    AudioDelay(SramMemSlot* slot);
 
    virtual ~AudioDelay();
 
    audio_block_t *addBlock(audio_block_t *blockIn);
 
    audio_block_t *getBlock(size_t index);
 
    size_t getMaxDelaySamples();
 
    bool getSamples(audio_block_t *dest, size_t offsetSamples, size_t numSamples = AUDIO_SAMPLES_PER_BLOCK);
 
    bool getSamples(int16_t *dest, size_t offsetSamples, size_t numSamples);
 
 
    bool interpolateDelay(int16_t *extendedSourceBuffer, int16_t *destBuffer, float fraction, size_t numSamples = AUDIO_SAMPLES_PER_BLOCK);
 
    SramMemSlot* getSlot() const;
 
    bool setSpiDmaCopyBuffer(void);
 
    RingBuffer<audio_block_t*> *getRingBuffer() const;
 
private:
 
    enum class MemType : unsigned {
        MEM_INTERNAL = 0, 
        MEM_EXTERNAL      
    };
 
    MemType m_type;                                       
    RingBuffer<audio_block_t *> *m_ringBuffer = nullptr;  
    SramMemSlot *m_slot = nullptr;                        
    size_t m_maxDelaySamples = 0;                         
    bool m_getSamples(int16_t *dest, size_t offsetSamples, size_t numSamples); 
};
 
/**************************************************************************/
class AVIATE_API IirBiQuadFilter {
public:
    IirBiQuadFilter() = delete;
    IirBiQuadFilter(unsigned numStages, const int32_t *coeffs, int coeffShift = 0);
 
    virtual ~IirBiQuadFilter();
 
    void changeFilterCoeffs(unsigned numStages, const int32_t *coeffs, int coeffShift = 0);
 
    bool process(int16_t *output, int16_t *input, size_t numSamples);
private:
    const unsigned NUM_STAGES;
    int32_t *m_coeffs = nullptr;
 
    // ARM DSP Math library filter instance
    arm_biquad_casd_df1_inst_q31 m_iirCfg;
    int32_t *m_state = nullptr;
};
 
/**************************************************************************/
class AVIATE_API IirBiQuadFilterHQ {
public:
    IirBiQuadFilterHQ() = delete;
    IirBiQuadFilterHQ(unsigned maxNumStages, const int32_t *coeffs, int coeffShift = 0);
    virtual ~IirBiQuadFilterHQ();
 
    void changeFilterCoeffs(unsigned numStages, const int32_t *coeffs, int coeffShift = 0);
 
    bool process(int16_t *output, int16_t *input, size_t numSamples);
private:
    const unsigned NUM_STAGES;
    int32_t *m_coeffs = nullptr;
 
    // ARM DSP Math library filter instance
    arm_biquad_cas_df1_32x64_ins_q31 m_iirCfg;
    int64_t *m_state = nullptr;
};
 
/**************************************************************************/
class AVIATE_API IirBiQuadFilterFloat {
public:
    IirBiQuadFilterFloat() = delete;
 
    IirBiQuadFilterFloat(unsigned maxNumStages, const float *coeffs);
    virtual ~IirBiQuadFilterFloat();  
 
    void changeFilterCoeffs(unsigned numStages, const float *coeffs);
 
    bool process(float *output, float *input, size_t numSamples);
private:
    const unsigned NUM_STAGES;
    float *m_coeffs = nullptr;
 
    // ARM DSP Math library filter instance
    arm_biquad_cascade_df2T_instance_f32 m_iirCfg;
    float *m_state = nullptr;
 
};
 
/**************************************************************************/
template <typename T>
class AVIATE_API ParameterAutomation
{
public:
    enum class Function : unsigned {
        NOT_CONFIGURED = 0, 
        HOLD,         
        LINEAR,       
        EXPONENTIAL,  
        LOGARITHMIC,  
        PARABOLIC,    
        LOOKUP_TABLE  
    };
    ParameterAutomation();  
 
    ParameterAutomation(T startValue, T endValue, size_t durationSamples,     Function function = Function::LINEAR);
 
    ParameterAutomation(T startValue, T endValue, float durationMilliseconds, Function function = Function::LINEAR);
    virtual ~ParameterAutomation();  
 
    void reconfigure(T startValue, T endValue, size_t durationSamples,     Function function = Function::LINEAR);
 
    void reconfigure(T startValue, T endValue, float durationMilliseconds, Function function = Function::LINEAR);
 
    void trigger();
 
    T getNextValue();
 
    bool isFinished();
 
private:
    Function m_function;
    T m_startValue;
    T m_endValue;
    bool m_running = false;
    float m_currentValueX; 
    size_t m_duration;
    //float m_coeffs[3]; ///< some general coefficient storage
    float m_slopeX;
    float m_scaleY;
    bool m_positiveSlope = true;
};
 
 
constexpr int MAX_PARAMETER_SEQUENCES = 32;  
 
template <typename T>
class AVIATE_API ParameterAutomationSequence
{
public:
    ParameterAutomationSequence() = delete;
 
    ParameterAutomationSequence(int numStages);
    virtual ~ParameterAutomationSequence();  
 
    void setupParameter(int index, T startValue, T endValue, size_t durationSamples, typename ParameterAutomation<T>::Function function);
 
    void setupParameter(int index, T startValue, T endValue, float durationMilliseconds, typename ParameterAutomation<T>::Function function);
 
    void trigger();
 
    T getNextValue();
 
    bool isFinished();
 
private:
    ParameterAutomation<T> *m_paramArray[MAX_PARAMETER_SEQUENCES];
    int m_currentIndex = 0;
    int m_numStages = 0;
    bool m_running = false;
};
 
enum class Waveform : unsigned {
    SINE,     
    TRIANGLE, 
    SQUARE,   
    SAWTOOTH, 
    RANDOM,   
    NUM_WAVEFORMS, 
};
 
/**************************************************************************/
template <class T>
class AVIATE_API LowFrequencyOscillatorVector {
public:
    LowFrequencyOscillatorVector();
 
    LowFrequencyOscillatorVector(Waveform waveform);
    virtual ~LowFrequencyOscillatorVector();  
 
    void setWaveform(Waveform waveform);
 
    void setRateAudio(float frequencyHz);
 
    void setRateRatio(float ratio);
 
    void setRoundnessFactor(float roundness);
 
    T *getNextVector();
 
private:
    void m_updatePhase(); 
    void m_initPhase(T radiansPerSample); 
    Waveform m_waveform  = Waveform::SINE; 
    T* m_phaseVec        = nullptr; 
    T m_radiansPerBlock  = 0.0f; 
    T m_radiansPerSample = 0.0f; 
    T* m_outputVec       = nullptr; 
 
    std::atomic_flag m_phaseLock = ATOMIC_FLAG_INIT; 
    float            m_roundness   = 0.01f; 
 
    static constexpr unsigned NUM_RANDOM_SEGMENTS = 4;
    static constexpr float    RANDOM_SLEW_FACTOR = 0.001f;
 
    unsigned         m_previousPhaseSegment = 0; 
    float            m_randTargetValue;          
    float            m_accumulator = 0.0f;
 
    const T PI_F = 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899; 
    const T TWO_PI_F = 2.0 *  3.14159265358979323846264338327950288419716939937510582097494459230781640628620899; 
    const T PI_DIV2_F = 0.5 *  3.14159265358979323846264338327950288419716939937510582097494459230781640628620899; 
    const T THREE_PI_DIV2_F = 1.5 *  3.14159265358979323846264338327950288419716939937510582097494459230781640628620899; 
    const T TRIANGE_POS_SLOPE = 2.0f/PI_F;
    const T TRIANGE_NEG_SLOPE = -2.0f/PI_F;
    const T SAWTOOTH_SLOPE = 1.0f/PI_F;
};
 
/**************************************************************************/
class AVIATE_API Compressor {
public:
 
    Compressor();  
    virtual ~Compressor();  
 
    bool processFloat(float *output, float *input, size_t numSamples);
 
    void setInputGain(float gain);
 
    void setThresholdDb(float thresholdDb);
    void setRatio(float ratio);
 
    void setAttackMs(unsigned attackMs);
 
    void setReleaseMs(unsigned releaseMs);
 
private:
 
    // Parameters
    float m_thresholdDb = 0;
    float m_ratio = 0;
    float m_inputGain = 0;
    float m_attackMs = 0;
    float m_releaseMs = 0;
 
    // Storage variables
    float m_ratioInv = 0;
    float m_threshold = 0;
    float m_gainRelease = 0;
    float m_gainAttack = 0;
    float m_prevEnvelope = 0;
    float m_compGain = 0;
};
 
} // namespace Aviate
 
 
#endif /* AVIATE_LIBBASICFUNCTIONS_H_ */