leaf-analysis.h

/*==============================================================================
 
 leaf-analysis.h
 Created: 25 Oct 2019 10:30:52am
 Author:  Matthew Wang
 
 ==============================================================================*/
 
#ifndef LEAF_ANALYSIS_H_INCLUDED
#define LEAF_ANALYSIS_H_INCLUDED
 
#ifdef __cplusplus
extern "C" {
#endif
    
    //==============================================================================
    
#include "leaf-global.h"
#include "leaf-mempool.h"
#include "leaf-distortion.h"
#include "leaf-math.h"
#include "leaf-filters.h"
#include "leaf-envelopes.h"
#include "leaf-delay.h"
    
    //==============================================================================
    
    typedef struct _tEnvelopeFollower
    {
        
        tMempool mempool;
        float y;
        float a_thresh;
        float d_coeff;
        
    } _tEnvelopeFollower;
    
    typedef _tEnvelopeFollower* tEnvelopeFollower;
    
    void    tEnvelopeFollower_init          (tEnvelopeFollower* const follower, float attackThreshold, float decayCoefficient, LEAF* const leaf);
    void    tEnvelopeFollower_initToPool    (tEnvelopeFollower* const follower, float attackThreshold, float decayCoefficient, tMempool* const mempool);
    void    tEnvelopeFollower_free          (tEnvelopeFollower* const follower);
    
    float   tEnvelopeFollower_tick          (tEnvelopeFollower* const follower, float sample);
    void    tEnvelopeFollower_setDecayCoefficient    (tEnvelopeFollower* const follower, float decayCoefficient);
    void    tEnvelopeFollower_setAttackThreshold  (tEnvelopeFollower* const follower, float attackThreshold);
    
    /* Zero Crossing Detector */
    typedef struct _tZeroCrossingCounter
    {
        
        tMempool mempool;
        int count;
        int maxWindowSize;
        int currentWindowSize;
        float invCurrentWindowSize;
        float* inBuffer;
        uint16_t* countBuffer;
        int prevPosition;
        int position;
    } _tZeroCrossingCounter;
    
    typedef _tZeroCrossingCounter* tZeroCrossingCounter;
    
    void    tZeroCrossingCounter_init         (tZeroCrossingCounter* const, int maxWindowSize, LEAF* const leaf);
    void    tZeroCrossingCounter_initToPool   (tZeroCrossingCounter* const, int maxWindowSize, tMempool* const mempool);
    void    tZeroCrossingCounter_free         (tZeroCrossingCounter* const);
    
    float   tZeroCrossingCounter_tick         (tZeroCrossingCounter* const, float input);
    void    tZeroCrossingCounter_setWindowSize    (tZeroCrossingCounter* const, float windowSize);
    
    // ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
    
    /* PowerEnvelopeFollower */
    typedef struct _tPowerFollower
    {
        
        tMempool mempool;
        float factor, oneminusfactor;
        float curr;
        
    } _tPowerFollower;
    
    typedef _tPowerFollower* tPowerFollower;
    
    void    tPowerFollower_init         (tPowerFollower* const, float factor, LEAF* const leaf);
    void    tPowerFollower_initToPool   (tPowerFollower* const, float factor, tMempool* const);
    void    tPowerFollower_free         (tPowerFollower* const);
    
    float   tPowerFollower_tick         (tPowerFollower* const, float input);
    float   tPowerFollower_getPower     (tPowerFollower* const);
    void    tPowerFollower_setFactor    (tPowerFollower* const, float factor);
    
    // ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
    
#define MAXOVERLAP 32
#define INITVSTAKEN 64
#define ENV_WINDOW_SIZE 1024
#define ENV_HOP_SIZE 256
    
    typedef struct _tEnvPD
    {
        
        tMempool mempool;
        float buf[ENV_WINDOW_SIZE + INITVSTAKEN];
        int x_phase;                    /* number of points since last output */
        int x_period;                   /* requested period of output */
        int x_realperiod;               /* period rounded up to vecsize multiple */
        int x_npoints;                  /* analysis window size in samples */
        float x_result;                 /* result to output */
        float x_sumbuf[MAXOVERLAP];     /* summing buffer */
        float x_f;
        int windowSize, hopSize, blockSize;
        int x_allocforvs;               /* extra buffer for DSP vector size */
    } _tEnvPD;
    
    typedef _tEnvPD* tEnvPD;
    
    void    tEnvPD_init             (tEnvPD* const, int windowSize, int hopSize, int blockSize, LEAF* const leaf);
    void    tEnvPD_initToPool       (tEnvPD* const, int windowSize, int hopSize, int blockSize, tMempool* const);
    void    tEnvPD_free             (tEnvPD* const);
    
    float   tEnvPD_tick             (tEnvPD* const);
    void    tEnvPD_processBlock     (tEnvPD* const, float* in);
    
    // ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
    
#define DEFBLOCKSIZE 1024
#define DEFTHRESHOLD 6
#define DEFATTACK    10
#define DEFRELEASE    10
    
    typedef struct _tAttackDetection
    {
        tMempool mempool;
        float env;
        
        //Attack & Release times in msec
        int atk;
        int rel;
        
        //Attack & Release coefficients based on times
        float atk_coeff;
        float rel_coeff;
        
        int blocksize;
        int samplerate;
        
        //RMS amplitude of previous block - used to decide if attack is present
        float prevAmp;
        
        float threshold;
    } _tAttackDetection;
    
    typedef _tAttackDetection* tAttackDetection;
    
    void    tAttackDetection_init           (tAttackDetection* const, int blocksize, int atk, int rel, LEAF* const leaf);
    void    tAttackDetection_initToPool     (tAttackDetection* const, int blocksize, int atk, int rel, tMempool* const);
    void    tAttackDetection_free           (tAttackDetection* const);
    
    void    tAttackDetection_setBlocksize   (tAttackDetection* const, int size);
    void    tAttackDetection_setSamplerate  (tAttackDetection* const, int inRate);
    void    tAttackDetection_setAttack      (tAttackDetection* const, int inAtk);
    void    tAttackDetection_setRelease     (tAttackDetection* const, int inRel);
    void    tAttackDetection_setThreshold   (tAttackDetection* const, float thres);
    int     tAttackDetection_detect         (tAttackDetection* const, float *in);
    
    //==============================================================================
    
#define SNAC_FRAME_SIZE 1024           // default analysis framesize // should be the same as (or smaller than?) PS_FRAME_SIZE
#define DEFOVERLAP 1                // default overlap
#define DEFBIAS 0.2f        // default bias
#define DEFMINRMS 0.003f   // default minimum RMS
#define SEEK 0.85f       // seek-length as ratio of framesize
    
    typedef struct _tSNAC
    {
        tMempool mempool;
        
        float* inputbuf;
        float* processbuf;
        float* spectrumbuf;
        float* biasbuf;
        uint16_t timeindex;
        uint16_t framesize;
        uint16_t overlap;
        uint16_t periodindex;
        
        float periodlength;
        float fidelity;
        float biasfactor;
        float minrms;
        
    } _tSNAC;
    
    typedef _tSNAC* tSNAC;
    
    void    tSNAC_init          (tSNAC* const, int overlaparg, LEAF* const leaf);
    void    tSNAC_initToPool    (tSNAC* const, int overlaparg, tMempool* const);
    void    tSNAC_free          (tSNAC* const);
    
    void    tSNAC_ioSamples     (tSNAC *s, float *in, int size);
    void    tSNAC_setOverlap    (tSNAC *s, int lap);
    void    tSNAC_setBias       (tSNAC *s, float bias);
    void    tSNAC_setMinRMS     (tSNAC *s, float rms);
    
    /*To get freq, perform SAMPLE_RATE/snac_getperiod() */
    float   tSNAC_getPeriod     (tSNAC *s);
    float   tSNAC_getFidelity   (tSNAC *s);
    
#define DEFPITCHRATIO 1.0f
#define DEFTIMECONSTANT 100.0f
#define DEFHOPSIZE 64
#define DEFWINDOWSIZE 64
#define FBA 20
#define HPFREQ 20.0f
    
    typedef struct _tPeriodDetection
    {
        tMempool mempool;
        
        tEnvPD env;
        tSNAC snac;
        float* inBuffer;
        float* outBuffer;
        int frameSize;
        int bufSize;
        int framesPerBuffer;
        int curBlock;
        int lastBlock;
        int i;
        int indexstore;
        int iLast;
        int index;
        float period;
        
        uint16_t hopSize;
        uint16_t windowSize;
        uint8_t fba;
        
        float timeConstant;
        float radius;
        float max;
        float lastmax;
        float deltamax;
        
        float fidelityThreshold;
        
        float history;
        float alpha;
        float tolerance;
        
    } _tPeriodDetection;
    
    typedef _tPeriodDetection* tPeriodDetection;
    
    void    tPeriodDetection_init               (tPeriodDetection* const, float* in, int bufSize, int frameSize, LEAF* const leaf);
    void    tPeriodDetection_initToPool         (tPeriodDetection* const, float* in, int bufSize, int frameSize, tMempool* const);
    void    tPeriodDetection_free               (tPeriodDetection* const);
    
    float   tPeriodDetection_tick               (tPeriodDetection* const, float sample);
    float   tPeriodDetection_getPeriod          (tPeriodDetection* const);
    float   tPeriodDetection_getFidelity        (tPeriodDetection* pd);
    void    tPeriodDetection_setHopSize         (tPeriodDetection* const, int hs);
    void    tPeriodDetection_setWindowSize      (tPeriodDetection* const, int ws);
    void    tPeriodDetection_setFidelityThreshold(tPeriodDetection* const, float threshold);
    void    tPeriodDetection_setAlpha           (tPeriodDetection* const, float alpha);
    void    tPeriodDetection_setTolerance       (tPeriodDetection* const, float tolerance);
    
    //==============================================================================
    
    // Maybe keep from here to tPeriodDetector internal?
    typedef struct _tZeroCrossingInfo
    {
        
        tMempool mempool;
        
        float _before_crossing;
        float _after_crossing;
        
        float             _peak;
        int               _leading_edge;// = undefined_edge; int_min
        int               _trailing_edge;// = undefined_edge;
        float             _width;// = 0.0f;
    } _tZeroCrossingInfo;
    
    typedef _tZeroCrossingInfo* tZeroCrossingInfo;
    
    void    tZeroCrossingInfo_init  (tZeroCrossingInfo* const, LEAF* const leaf);
    void    tZeroCrossingInfo_initToPool    (tZeroCrossingInfo* const, tMempool* const);
    void    tZeroCrossingInfo_free  (tZeroCrossingInfo* const);
    
    int     tZeroCrossingInfo_tick(tZeroCrossingInfo* const, float s);
    int     tZeroCrossingInfo_getState(tZeroCrossingInfo* const);
    void    tZeroCrossingInfo_updatePeak(tZeroCrossingInfo* const, float s, int pos);
    int     tZeroCrossingInfo_period(tZeroCrossingInfo* const, tZeroCrossingInfo* const next);
    float   tZeroCrossingInfo_fractionalPeriod(tZeroCrossingInfo* const, tZeroCrossingInfo* const next);
    int     tZeroCrossingInfo_getWidth(tZeroCrossingInfo* const);
    
    //==============================================================================
    
    typedef struct _tZeroCrossingCollector
    {
        
        tMempool mempool;
        
        tZeroCrossingInfo* _info;
        unsigned int _size;
        unsigned int _pos;
        unsigned int _mask;
        
        float                _prev;// = 0.0f;
        float                _hysteresis;
        int                  _state;// = false;
        int                  _num_edges;// = 0;
        int                  _window_size;
        int                  _frame;// = 0;
        int                  _ready;// = false;
        float                _peak_update;// = 0.0f;
        float                _peak;// = 0.0f;
    } _tZeroCrossingCollector;
    
    typedef _tZeroCrossingCollector* tZeroCrossingCollector;
    
    void    tZeroCrossingCollector_init  (tZeroCrossingCollector* const, int windowSize, float hysteresis, LEAF* const leaf);
    void    tZeroCrossingCollector_initToPool    (tZeroCrossingCollector* const, int windowSize, float hysteresis, tMempool* const);
    void    tZeroCrossingCollector_free  (tZeroCrossingCollector* const);
    
    int     tZeroCrossingCollector_tick(tZeroCrossingCollector* const, float s);
    int     tZeroCrossingCollector_getState(tZeroCrossingCollector* const);
    
    int     tZeroCrossingCollector_getNumEdges(tZeroCrossingCollector* const zc);
    int     tZeroCrossingCollector_getCapacity(tZeroCrossingCollector* const zc);
    int     tZeroCrossingCollector_getFrame(tZeroCrossingCollector* const zc);
    int     tZeroCrossingCollector_getWindowSize(tZeroCrossingCollector* const zc);
    
    int     tZeroCrossingCollector_isReady(tZeroCrossingCollector* const zc);
    float   tZeroCrossingCollector_getPeak(tZeroCrossingCollector* const zc);
    int     tZeroCrossingCollector_isReset(tZeroCrossingCollector* const zc);
    
    tZeroCrossingInfo const tZeroCrossingCollector_getCrossing(tZeroCrossingCollector* const zc, int index);
 
    void    tZeroCrossingCollector_setHysteresis(tZeroCrossingCollector* const zc, float hysteresis);
    
    //==============================================================================
    
    typedef struct _tBitset
    {
        
        tMempool mempool;
        
        unsigned int _value_size;
        unsigned int _size;
        unsigned int _bit_size;
        unsigned int* _bits;
    } _tBitset;
    
    typedef _tBitset* tBitset;
    
    void    tBitset_init    (tBitset* const bitset, int numBits, LEAF* const leaf);
    void    tBitset_initToPool  (tBitset* const bitset, int numBits, tMempool* const mempool);
    void    tBitset_free    (tBitset* const bitset);
    
    int     tBitset_get     (tBitset* const bitset, int index);
    unsigned int*   tBitset_getData   (tBitset* const bitset);
    
    void    tBitset_set     (tBitset* const bitset, int index, unsigned int val);
    void    tBitset_setMultiple (tBitset* const bitset, int index, int n, unsigned int val);
 
    int     tBitset_getSize (tBitset* const bitset);
    void    tBitset_clear   (tBitset* const bitset);
 
    
    //==============================================================================
    
    typedef struct _tBACF
    {
        
        tMempool mempool;
        
        tBitset _bitset;
        unsigned int _mid_array;
    } _tBACF;
    
    typedef _tBACF* tBACF;
    
    void    tBACF_init  (tBACF* const bacf, tBitset* const bitset, LEAF* const leaf);
    void    tBACF_initToPool    (tBACF* const bacf, tBitset* const bitset, tMempool* const mempool);
    void    tBACF_free  (tBACF* const bacf);
    
    int     tBACF_getCorrelation    (tBACF* const bacf, int pos);
    void    tBACF_set  (tBACF* const bacf, tBitset* const bitset);
    
    //==============================================================================
    
#define PULSE_THRESHOLD 0.6f
#define HARMONIC_PERIODICITY_FACTOR 16 //16
#define PERIODICITY_DIFF_FACTOR 0.008f //0.008f
    
    typedef struct _auto_correlation_info
    {
        int               _i1;// = -1;
        int               _i2;// = -1;
        int               _period;// = -1;
        float             _periodicity;// = 0.0f;
        unsigned int      _harmonic;
    } _auto_correlation_info;
    
    typedef struct _sub_collector
    {
        
        tMempool mempool;
        
        float             _first_period;
        
        _auto_correlation_info _fundamental;
        
        // passed in, not initialized
        tZeroCrossingCollector    _zc;
        
        float             _harmonic_threshold;
        float             _periodicity_diff_threshold;
        int               _range;
    } _sub_collector;
 
    typedef struct _period_info
    {
        float period; // -1.0f
        float periodicity;
    } _period_info;
 
    typedef struct _tPeriodDetector
    {
        tMempool mempool;
        
        tZeroCrossingCollector          _zc;
        _period_info            _fundamental;
        unsigned int            _min_period;
        int                     _range;
        tBitset                 _bits;
        float                   _weight;
        unsigned int            _mid_point;
        float                   _periodicity_diff_threshold;
        float                   _predicted_period;// = -1.0f;
        unsigned int            _edge_mark;// = 0;
        unsigned int            _predict_edge;// = 0;
        unsigned int            _num_pulses; // = 0;
        int                     _half_empty; // 0;
        
        tBACF                   _bacf;
        
    } _tPeriodDetector;
    
    typedef _tPeriodDetector* tPeriodDetector;
    
    void    tPeriodDetector_init    (tPeriodDetector* const detector, float lowestFreq, float highestFreq, float hysteresis, LEAF* const leaf);
    void    tPeriodDetector_initToPool  (tPeriodDetector* const detector, float lowestFreq, float highestFreq, float hysteresis, tMempool* const mempool);
    void    tPeriodDetector_free    (tPeriodDetector* const detector);
    
    int     tPeriodDetector_tick    (tPeriodDetector* const detector, float sample);
    
    // get the periodicity for a given harmonic
    float   tPeriodDetector_getPeriod   (tPeriodDetector* const detector);
    float   tPeriodDetector_getPeriodicity  (tPeriodDetector* const detector);
    float   tPeriodDetector_harmonic    (tPeriodDetector* const detector, int harmonicIndex);
    float   tPeriodDetector_predictPeriod   (tPeriodDetector* const detector);
    int     tPeriodDetector_isReady (tPeriodDetector* const detector);
    int     tPeriodDetector_isReset (tPeriodDetector* const detector);
 
    void    tPeriodDetector_setHysteresis   (tPeriodDetector* const detector, float hysteresis);
    
    //==============================================================================
    
#define ONSET_PERIODICITY 0.95f
#define MIN_PERIODICITY 0.9f
#define DEFAULT_HYSTERESIS -200.0f
 
    typedef struct _pitch_info
    {
        float frequency;
        float periodicity;
    } _pitch_info;
    
    typedef struct _tPitchDetector
    {
        
        tMempool mempool;
        
        tPeriodDetector _pd;
        _pitch_info _current;
        int _frames_after_shift;// = 0;
        
    } _tPitchDetector;
    
    typedef _tPitchDetector* tPitchDetector;
    
    void    tPitchDetector_init (tPitchDetector* const detector, float lowestFreq, float highestFreq, LEAF* const leaf);
    void    tPitchDetector_initToPool   (tPitchDetector* const detector, float lowestFreq, float highestFreq, tMempool* const mempool);
    void    tPitchDetector_free (tPitchDetector* const detector);
    
    int     tPitchDetector_tick    (tPitchDetector* const detector, float sample);
    float   tPitchDetector_getFrequency    (tPitchDetector* const detector);
    float   tPitchDetector_getPeriodicity  (tPitchDetector* const detector);
    float   tPitchDetector_harmonic    (tPitchDetector* const detector, int harmonicIndex);
    float   tPitchDetector_predictFrequency (tPitchDetector* const detector);
    int     tPitchDetector_indeterminate    (tPitchDetector* const detector);
    
    void    tPitchDetector_setHysteresis    (tPitchDetector* const detector, float hysteresis);
    
    
    //==============================================================================
    
    typedef struct _tDualPitchDetector
    {
        tMempool mempool;
        
        tPeriodDetection _pd1;
        tPitchDetector _pd2;
        _pitch_info _current;
        float _mean;
        float _predicted_frequency;
        int _first;
        
        float highest, lowest;
        float thresh;
 
    } _tDualPitchDetector;
    
    typedef _tDualPitchDetector* tDualPitchDetector;
    
    void    tDualPitchDetector_init (tDualPitchDetector* const detector, float lowestFreq, float highestFreq, float* inBuffer, int bufSize, LEAF* const leaf);
    void    tDualPitchDetector_initToPool   (tDualPitchDetector* const detector, float lowestFreq, float highestFreq, float* inBuffer, int bufSize, tMempool* const mempool);
    void    tDualPitchDetector_free (tDualPitchDetector* const detector);
    
    int     tDualPitchDetector_tick    (tDualPitchDetector* const detector, float sample);
    float   tDualPitchDetector_getFrequency    (tDualPitchDetector* const detector);
    float   tDualPitchDetector_getPeriodicity  (tDualPitchDetector* const detector);
    float   tDualPitchDetector_harmonic    (tDualPitchDetector* const detector, int harmonicIndex);
    float   tDualPitchDetector_predictFrequency (tDualPitchDetector* const detector);
    
    void    tDualPitchDetector_setHysteresis    (tDualPitchDetector* const detector, float hysteresis);
    void    tDualPitchDetector_setPeriodicityThreshold (tDualPitchDetector* const detector, float thresh);
    
    
    
    
#ifdef __cplusplus
}
#endif
 
#endif  // LEAF_ANALYSIS_H_INCLUDED
 
//==============================================================================