shithub: leaf

Download patch

ref: 214d58fca21ffd1b44f504d0c48f8cc60f54c52d
parent: 8eb793224654456f4a219abb4be6d434bd247c51
author: spiricom <jeff@snyderphonics.com>
date: Sat Jan 25 15:53:15 EST 2020

working formant correction, only tested with filtered noise so far

binary files a/.DS_Store b/.DS_Store differ
--- a/LEAF/Inc/leaf-effects.h
+++ b/LEAF/Inc/leaf-effects.h
@@ -261,7 +261,6 @@
     typedef struct _tFormantShifter
     {
         int ford;
-        int bufsize;
         float falph;
         float flamb;
         float* fk;
@@ -274,7 +273,7 @@
         float fhp;
         float flp;
         float flpa;
-        float** fbuff;
+        float* fbuff;
         float* ftvec;
         float fmute;
         float fmutealph;
--- a/LEAF/Inc/leaf-mempool.h
+++ b/LEAF/Inc/leaf-mempool.h
@@ -74,13 +74,10 @@
     } mpool_t;
     
     void mpool_create (char* memory, size_t size, mpool_t* pool);
-    
-<<<<<<< HEAD
+
     void* mpool_alloc(size_t size, mpool_t* pool);
     void* mpool_allocAndClear(size_t asize, mpool_t* pool);
-=======
-    void *mpool_alloc(size_t size, mpool_t* pool);
->>>>>>> b8628af4ceadb4749cd557e6bd3057c2639f3c97
+
     void mpool_free(void* ptr, mpool_t* pool);
     
     size_t mpool_get_size(mpool_t* pool);
@@ -89,10 +86,8 @@
     void leaf_pool_init(char* memory, size_t size);
     
     void* leaf_alloc(size_t size);
-<<<<<<< HEAD
     void* leaf_allocAndClear(size_t size);
-=======
->>>>>>> b8628af4ceadb4749cd557e6bd3057c2639f3c97
+
     void leaf_free(void* ptr);
     
     size_t leaf_pool_get_size(void);
@@ -106,7 +101,7 @@
     
     typedef struct _tMempool
     {
-        mpool_t* pool;
+        mpool_t pool;
     } _tMempool;
     
     typedef _tMempool* tMempool;
--- a/LEAF/Src/leaf-analysis.c
+++ b/LEAF/Src/leaf-analysis.c
@@ -41,7 +41,7 @@
 void    tEnvelopeFollower_initToPool    (tEnvelopeFollower* const ef, float attackThreshold, float decayCoeff, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tEnvelopeFollower* e = *ef = (_tEnvelopeFollower*) mpool_alloc(sizeof(_tEnvelopeFollower), m->pool);
+    _tEnvelopeFollower* e = *ef = (_tEnvelopeFollower*) mpool_alloc(sizeof(_tEnvelopeFollower), &m->pool);
     
     e->y = 0.0f;
     e->a_thresh = attackThreshold;
@@ -53,7 +53,7 @@
     _tMempool* m = *mp;
     _tEnvelopeFollower* e = *ef;
     
-    mpool_free(e, m->pool);
+    mpool_free(e, &m->pool);
 }
 
 float   tEnvelopeFollower_tick(tEnvelopeFollower* const ef, float x)
@@ -108,7 +108,7 @@
 void    tPowerFollower_initToPool   (tPowerFollower* const pf, float factor, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tPowerFollower* p = *pf = (_tPowerFollower*) mpool_alloc(sizeof(_tPowerFollower), m->pool);
+    _tPowerFollower* p = *pf = (_tPowerFollower*) mpool_alloc(sizeof(_tPowerFollower), &m->pool);
     
     p->curr=0.0f;
     p->factor=factor;
@@ -120,7 +120,7 @@
     _tMempool* m = *mp;
     _tPowerFollower* p = *pf;
     
-    mpool_free(p, m->pool);
+    mpool_free(p, &m->pool);
 }
 
 int     tPowerFollower_setFactor(tPowerFollower* const pf, float factor)
@@ -206,7 +206,7 @@
 void    tEnvPD_initToPool       (tEnvPD* const xpd, int ws, int hs, int bs, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tEnvPD* x = *xpd = (_tEnvPD*) mpool_alloc(sizeof(_tEnvPD), m->pool);
+    _tEnvPD* x = *xpd = (_tEnvPD*) mpool_allocAndClear(sizeof(_tEnvPD), &m->pool);
     
     int period = hs, npoints = ws;
     
@@ -251,60 +251,9 @@
     _tMempool* m = *mp;
     _tEnvPD* x = *xpd;
     
-    mpool_free(x, m->pool);
+    mpool_free(x, &m->pool);
 }
 
-void    tEnvPD_initToPool       (tEnvPD* const xpd, int ws, int hs, int bs, tMempool* const mp)
-{
-    _tMempool* m = *mp;
-    _tEnvPD* x = *xpd = (_tEnvPD*) mpool_alloc(sizeof(_tEnvPD), m->pool);
-    
-    int period = hs, npoints = ws;
-    
-    int i;
-    
-    if (npoints < 1) npoints = 1024;
-    if (period < 1) period = npoints/2;
-    if (period < npoints / MAXOVERLAP + 1)
-        period = npoints / MAXOVERLAP + 1;
-    
-    x->x_npoints = npoints;
-    x->x_phase = 0;
-    x->x_period = period;
-    
-    x->windowSize = npoints;
-    x->hopSize = period;
-    x->blockSize = bs;
-    
-    for (i = 0; i < MAXOVERLAP; i++) x->x_sumbuf[i] = 0;
-    for (i = 0; i < npoints; i++)
-        x->buf[i] = (1.0f - cosf((2 * PI * i) / npoints))/npoints;
-    for (; i < npoints+INITVSTAKEN; i++) x->buf[i] = 0;
-    
-    x->x_f = 0;
-    
-    x->x_allocforvs = INITVSTAKEN;
-    
-    // ~ ~ ~ dsp ~ ~ ~
-    if (x->x_period % x->blockSize)
-    {
-        x->x_realperiod = x->x_period + x->blockSize - (x->x_period % x->blockSize);
-    }
-    else
-    {
-        x->x_realperiod = x->x_period;
-    }
-    // ~ ~ ~ ~ ~ ~ ~ ~
-}
-
-void    tEnvPD_freeFromPool     (tEnvPD* const xpd, tMempool* const mp)
-{
-    _tMempool* m = *mp;
-    _tEnvPD* x = *xpd;
-    
-    mpool_free(x, m->pool);
-}
-
 float tEnvPD_tick (tEnvPD* const xpd)
 {
     _tEnvPD* x = *xpd;
@@ -374,7 +323,7 @@
 void    tAttackDetection_initToPool     (tAttackDetection* const ad, int blocksize, int atk, int rel, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    *ad = (_tAttackDetection*) mpool_alloc(sizeof(_tAttackDetection), m->pool);
+    *ad = (_tAttackDetection*) mpool_alloc(sizeof(_tAttackDetection), &m->pool);
     
     atkdtk_init(ad, blocksize, atk, rel);
 }
@@ -384,7 +333,7 @@
     _tMempool* m = *mp;
     _tAttackDetection* a = *ad;
     
-    mpool_free(a, m->pool);
+    mpool_free(a, &m->pool);
 }
 
 /*******Public Functions***********/
@@ -546,7 +495,7 @@
 void    tSNAC_initToPool    (tSNAC* const snac, int overlaparg, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tSNAC* s = *snac = (_tSNAC*) mpool_alloc(sizeof(_tSNAC), m->pool);
+    _tSNAC* s = *snac = (_tSNAC*) mpool_alloc(sizeof(_tSNAC), &m->pool);
     
     s->biasfactor = DEFBIAS;
     s->timeindex = 0;
@@ -555,19 +504,12 @@
     s->fidelity = 0.;
     s->minrms = DEFMINRMS;
     s->framesize = SNAC_FRAME_SIZE;
+
+    s->inputbuf = (float*) mpool_allocAndClear(sizeof(float) * SNAC_FRAME_SIZE, &m->pool);
+    s->processbuf = (float*) mpool_allocAndClear(sizeof(float) * (SNAC_FRAME_SIZE * 2), &m->pool);
+    s->spectrumbuf = (float*) mpool_allocAndClear(sizeof(float) * (SNAC_FRAME_SIZE / 2), &m->pool);
+    s->biasbuf = (float*) mpool_allocAndClear(sizeof(float) * SNAC_FRAME_SIZE, &m->pool);
     
-<<<<<<< HEAD
-    s->inputbuf = (float*) mpool_allocAndClear(sizeof(float) * SNAC_FRAME_SIZE, m->pool);
-    s->processbuf = (float*) mpool_allocAndClear(sizeof(float) * (SNAC_FRAME_SIZE * 2), m->pool);
-    s->spectrumbuf = (float*) mpool_allocAndClear(sizeof(float) * (SNAC_FRAME_SIZE / 2), m->pool);
-    s->biasbuf = (float*) mpool_allocAndClear(sizeof(float) * SNAC_FRAME_SIZE, m->pool);
-=======
-    s->inputbuf = (float*) mpool_alloc(sizeof(float) * SNAC_FRAME_SIZE, m->pool);
-    s->processbuf = (float*) mpool_alloc(sizeof(float) * (SNAC_FRAME_SIZE * 2), m->pool);
-    s->spectrumbuf = (float*) mpool_alloc(sizeof(float) * (SNAC_FRAME_SIZE / 2), m->pool);
-    s->biasbuf = (float*) mpool_alloc(sizeof(float) * SNAC_FRAME_SIZE, m->pool);
->>>>>>> b8628af4ceadb4749cd557e6bd3057c2639f3c97
-    
     snac_biasbuf(snac);
     tSNAC_setOverlap(snac, overlaparg);
 }
@@ -577,11 +519,11 @@
     _tMempool* m = *mp;
     _tSNAC* s = *snac;
     
-    mpool_free(s->inputbuf, m->pool);
-    mpool_free(s->processbuf, m->pool);
-    mpool_free(s->spectrumbuf, m->pool);
-    mpool_free(s->biasbuf, m->pool);
-    mpool_free(s, m->pool);
+    mpool_free(s->inputbuf, &m->pool);
+    mpool_free(s->processbuf, &m->pool);
+    mpool_free(s->spectrumbuf, &m->pool);
+    mpool_free(s->biasbuf, &m->pool);
+    mpool_free(s, &m->pool);
 }
 
 /******************************************************************************/
@@ -933,7 +875,7 @@
 void    tPeriodDetection_initToPool  (tPeriodDetection* const pd, float* in, float* out, int bufSize, int frameSize, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tPeriodDetection* p = *pd = (_tPeriodDetection*) mpool_alloc(sizeof(_tPeriodDetection), m->pool);
+    _tPeriodDetection* p = *pd = (_tPeriodDetection*) mpool_allocAndClear(sizeof(_tPeriodDetection), &m->pool);
     
     p->inBuffer = in;
     p->outBuffer = out;
@@ -963,7 +905,7 @@
     
     tEnvPD_freeFromPool(&p->env, mp);
     tSNAC_freeFromPool(&p->snac, mp);
-    mpool_free(p, m->pool);
+    mpool_free(p, &m->pool);
 }
 
 float tPeriodDetection_findPeriod (tPeriodDetection* pd, float sample)
@@ -1012,124 +954,3 @@
     _tPeriodDetection* p = *pd;
     p->windowSize = ws;
 }
-
-//===========================================================================
-// PERIODDETECTION
-//===========================================================================
-void    tPeriodDetection_init    (tPeriodDetection* const pd, float* in, float* out, int bufSize, int frameSize)
-{
-    _tPeriodDetection* p = *pd = (_tPeriodDetection*) leaf_alloc(sizeof(_tPeriodDetection));
-    
-    p->inBuffer = in;
-    p->outBuffer = out;
-    p->bufSize = bufSize;
-    p->frameSize = frameSize;
-    p->framesPerBuffer = p->bufSize / p->frameSize;
-    p->curBlock = 1;
-    p->lastBlock = 0;
-    p->index = 0;
-    
-    p->hopSize = DEFHOPSIZE;
-    p->windowSize = DEFWINDOWSIZE;
-    p->fba = FBA;
-    
-    tEnvPD_init(&p->env, p->windowSize, p->hopSize, p->frameSize);
-    
-    tSNAC_init(&p->snac, DEFOVERLAP);
-    
-    p->timeConstant = DEFTIMECONSTANT;
-    p->radius = expf(-1000.0f * p->hopSize * leaf.invSampleRate / p->timeConstant);
-}
-
-void tPeriodDetection_free (tPeriodDetection* const pd)
-{
-    _tPeriodDetection* p = *pd;
-    
-    tEnvPD_free(&p->env);
-    tSNAC_free(&p->snac);
-    leaf_free(p);
-}
-
-void    tPeriodDetection_initToPool  (tPeriodDetection* const pd, float* in, float* out, int bufSize, int frameSize, tMempool* const mp)
-{
-    _tMempool* m = *mp;
-    _tPeriodDetection* p = *pd = (_tPeriodDetection*) mpool_alloc(sizeof(_tPeriodDetection), m->pool);
-    
-    p->inBuffer = in;
-    p->outBuffer = out;
-    p->bufSize = bufSize;
-    p->frameSize = frameSize;
-    p->framesPerBuffer = p->bufSize / p->frameSize;
-    p->curBlock = 1;
-    p->lastBlock = 0;
-    p->index = 0;
-    
-    p->hopSize = DEFHOPSIZE;
-    p->windowSize = DEFWINDOWSIZE;
-    p->fba = FBA;
-    
-    tEnvPD_initToPool(&p->env, p->windowSize, p->hopSize, p->frameSize, mp);
-    
-    tSNAC_initToPool(&p->snac, DEFOVERLAP, mp);
-    
-    p->timeConstant = DEFTIMECONSTANT;
-    p->radius = expf(-1000.0f * p->hopSize * leaf.invSampleRate / p->timeConstant);
-}
-
-void    tPeriodDetection_freeFromPool       (tPeriodDetection* const pd, tMempool* const mp)
-{
-    _tMempool* m = *mp;
-    _tPeriodDetection* p = *pd;
-    
-    tEnvPD_freeFromPool(&p->env, mp);
-    tSNAC_freeFromPool(&p->snac, mp);
-    mpool_free(p, m->pool);
-}
-
-float tPeriodDetection_findPeriod (tPeriodDetection* pd, float sample)
-{
-    _tPeriodDetection* p = *pd;
-    
-    int i, iLast;
-    
-    i = (p->curBlock*p->frameSize);
-    iLast = (p->lastBlock*p->frameSize)+p->index;
-    
-    p->i = i;
-    p->iLast = iLast;
-    
-    p->inBuffer[i+p->index] = sample;
-    
-    p->index++;
-    p->indexstore = p->index;
-    if (p->index >= p->frameSize)
-    {
-        p->index = 0;
-        
-        tEnvPD_processBlock(&p->env, &(p->inBuffer[i]));
-        
-        tSNAC_ioSamples(&p->snac, &(p->inBuffer[i]), &(p->outBuffer[i]), p->frameSize);
-        p->period = tSNAC_getPeriod(&p->snac);
-        
-        p->curBlock++;
-        if (p->curBlock >= p->framesPerBuffer) p->curBlock = 0;
-        p->lastBlock++;
-        if (p->lastBlock >= p->framesPerBuffer) p->lastBlock = 0;
-    }
-    
-    // changed from period to p->period
-    return p->period;
-}
-
-void tPeriodDetection_setHopSize(tPeriodDetection* pd, int hs)
-{
-    _tPeriodDetection* p = *pd;
-    p->hopSize = hs;
-}
-
-void tPeriodDetection_setWindowSize(tPeriodDetection* pd, int ws)
-{
-    _tPeriodDetection* p = *pd;
-    p->windowSize = ws;
-}
-
--- a/LEAF/Src/leaf-delay.c
+++ b/LEAF/Src/leaf-delay.c
@@ -51,13 +51,13 @@
 void        tDelay_initToPool   (tDelay* const dl, uint32_t delay, uint32_t maxDelay, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tDelay* d = *dl = (_tDelay*) mpool_alloc(sizeof(_tDelay), m->pool);
+    _tDelay* d = *dl = (_tDelay*) mpool_alloc(sizeof(_tDelay), &m->pool);
     
     d->maxDelay = maxDelay;
     
     d->delay = delay;
     
-    d->buff = (float*) mpool_alloc(sizeof(float) * maxDelay, m->pool);
+    d->buff = (float*) mpool_alloc(sizeof(float) * maxDelay, &m->pool);
     
     d->inPoint = 0;
     d->outPoint = 0;
@@ -75,8 +75,8 @@
     _tMempool* m = *mp;
     _tDelay* d = *dl;
     
-    mpool_free(d->buff, m->pool);
-    mpool_free(d, m->pool);
+    mpool_free(d->buff, &m->pool);
+    mpool_free(d, &m->pool);
 }
 
 float   tDelay_tick (tDelay* const dl, float input)
@@ -211,7 +211,7 @@
 void    tLinearDelay_initToPool  (tLinearDelay* const dl, float delay, uint32_t maxDelay, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tLinearDelay* d = *dl = (_tLinearDelay*) mpool_alloc(sizeof(_tLinearDelay), m->pool);
+    _tLinearDelay* d = *dl = (_tLinearDelay*) mpool_alloc(sizeof(_tLinearDelay), &m->pool);
     
     d->maxDelay = maxDelay;
     
@@ -219,7 +219,7 @@
     else if (delay < 0.0f)  d->delay = 0.0f;
     else                    d->delay = delay;
     
-    d->buff = (float*) mpool_alloc(sizeof(float) * maxDelay, m->pool);
+    d->buff = (float*) mpool_alloc(sizeof(float) * maxDelay, &m->pool);
     
     d->gain = 1.0f;
     
@@ -237,12 +237,10 @@
     _tMempool* m = *mp;
     _tLinearDelay* d = *dl;
     
-    mpool_free(d->buff, m->pool);
-    mpool_free(d, m->pool);
+    mpool_free(d->buff, &m->pool);
+    mpool_free(d, &m->pool);
 }
 
-<<<<<<< HEAD
-
 void    tLinearDelay_clear(tLinearDelay* const dl)
 {
 	_tLinearDelay* d = *dl;
@@ -254,8 +252,6 @@
 
 }
 
-=======
->>>>>>> b8628af4ceadb4749cd557e6bd3057c2639f3c97
 float   tLinearDelay_tick (tLinearDelay* const dl, float input)
 {
     _tLinearDelay* d = *dl;
@@ -436,7 +432,7 @@
 void    tHermiteDelay_initToPool  (tHermiteDelay* const dl, float delay, uint32_t maxDelay, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tHermiteDelay* d = *dl = (_tHermiteDelay*) mpool_alloc(sizeof(_tHermiteDelay), m->pool);
+    _tHermiteDelay* d = *dl = (_tHermiteDelay*) mpool_alloc(sizeof(_tHermiteDelay), &m->pool);
 
     d->maxDelay = maxDelay;
 
@@ -444,7 +440,7 @@
     else if (delay < 0.0f)  d->delay = 0.0f;
     else                    d->delay = delay;
 
-    d->buff = (float*) mpool_alloc(sizeof(float) * maxDelay, m->pool);
+    d->buff = (float*) mpool_alloc(sizeof(float) * maxDelay, &m->pool);
 
     d->gain = 1.0f;
 
@@ -462,8 +458,8 @@
     _tMempool* m = *mp;
     _tHermiteDelay* d = *dl;
 
-    mpool_free(d->buff, m->pool);
-    mpool_free(d, m->pool);
+    mpool_free(d->buff, &m->pool);
+    mpool_free(d, &m->pool);
 }
 
 
@@ -661,7 +657,7 @@
 void    tAllpassDelay_initToPool  (tAllpassDelay* const dl, float delay, uint32_t maxDelay, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tAllpassDelay* d = *dl = (_tAllpassDelay*) mpool_alloc(sizeof(_tAllpassDelay), m->pool);
+    _tAllpassDelay* d = *dl = (_tAllpassDelay*) mpool_alloc(sizeof(_tAllpassDelay), &m->pool);
     
     d->maxDelay = maxDelay;
     
@@ -669,7 +665,7 @@
     else if (delay < 0.0f)  d->delay = 0.0f;
     else                    d->delay = delay;
     
-    d->buff = (float*) mpool_alloc(sizeof(float) * maxDelay, m->pool);
+    d->buff = (float*) mpool_alloc(sizeof(float) * maxDelay, &m->pool);
     
     d->gain = 1.0f;
     
@@ -689,8 +685,8 @@
     _tMempool* m = *mp;
     _tAllpassDelay* d = *dl;
     
-    mpool_free(d->buff, m->pool);
-    mpool_free(d, m->pool);
+    mpool_free(d->buff, &m->pool);
+    mpool_free(d, &m->pool);
 }
 
 float   tAllpassDelay_tick (tAllpassDelay* const dl, float input)
@@ -850,11 +846,11 @@
 void    tTapeDelay_initToPool  (tTapeDelay* const dl, float delay, uint32_t maxDelay, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tTapeDelay* d = *dl = (_tTapeDelay*) mpool_alloc(sizeof(_tTapeDelay), m->pool);
+    _tTapeDelay* d = *dl = (_tTapeDelay*) mpool_alloc(sizeof(_tTapeDelay), &m->pool);
     
     d->maxDelay = maxDelay;
     
-    d->buff = (float*) mpool_alloc(sizeof(float) * maxDelay, m->pool);
+    d->buff = (float*) mpool_alloc(sizeof(float) * maxDelay, &m->pool);
     
     d->gain = 1.0f;
     
@@ -873,8 +869,8 @@
     _tMempool* m = *mp;
     _tTapeDelay* d = *dl;
     
-    mpool_free(d->buff, m->pool);
-    mpool_free(d, m->pool);
+    mpool_free(d->buff, &m->pool);
+    mpool_free(d, &m->pool);
 }
 
 //#define SMOOTH_FACTOR 10.f
--- a/LEAF/Src/leaf-distortion.c
+++ b/LEAF/Src/leaf-distortion.c
@@ -45,7 +45,7 @@
 void    tSampleReducer_initToPool   (tSampleReducer* const sr, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tSampleReducer* s = *sr = (_tSampleReducer*) mpool_alloc(sizeof(_tSampleReducer), m->pool);
+    _tSampleReducer* s = *sr = (_tSampleReducer*) mpool_alloc(sizeof(_tSampleReducer), &m->pool);
     
     s->invRatio = 1.0f;
     s->hold = 0.0f;
@@ -57,7 +57,7 @@
     _tMempool* m = *mp;
     _tSampleReducer* s = *sr;
     
-    mpool_free(s, m->pool);
+    mpool_free(s, &m->pool);
 }
 
 float tSampleReducer_tick(tSampleReducer* const sr, float input)
@@ -117,7 +117,7 @@
 void    tOversampler_initToPool     (tOversampler* const osr, int ratio, oBool extraQuality, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tOversampler* os = *osr = (_tOversampler*) mpool_alloc(sizeof(_tOversampler), m->pool);
+    _tOversampler* os = *osr = (_tOversampler*) mpool_alloc(sizeof(_tOversampler), &m->pool);
     
     uint8_t offset = 0;
     if (extraQuality) offset = 6;
@@ -129,8 +129,8 @@
         os->numTaps = firNumTaps[idx];
         os->phaseLength = os->numTaps / os->ratio;
         os->pCoeffs = (float*) firCoeffs[idx];
-        os->upState = mpool_alloc(sizeof(float) * os->numTaps * 2, m->pool);
-        os->downState = mpool_alloc(sizeof(float) * os->numTaps * 2, m->pool);
+        os->upState = mpool_alloc(sizeof(float) * os->numTaps * 2, &m->pool);
+        os->downState = mpool_alloc(sizeof(float) * os->numTaps * 2, &m->pool);
     }
 }
 
@@ -139,9 +139,9 @@
     _tMempool* m = *mp;
     _tOversampler* os = *osr;
     
-    mpool_free(os->upState, m->pool);
-    mpool_free(os->downState, m->pool);
-    mpool_free(os, m->pool);
+    mpool_free(os->upState, &m->pool);
+    mpool_free(os->downState, &m->pool);
+    mpool_free(os, &m->pool);
 }
 
 float tOversampler_tick(tOversampler* const osr, float input, float (*effectTick)(float))
@@ -385,7 +385,7 @@
 void    tLockhartWavefolder_initToPool   (tLockhartWavefolder* const wf, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tLockhartWavefolder* w = *wf = (_tLockhartWavefolder*) mpool_alloc(sizeof(_tLockhartWavefolder), m->pool);
+    _tLockhartWavefolder* w = *wf = (_tLockhartWavefolder*) mpool_alloc(sizeof(_tLockhartWavefolder), &m->pool);
     
     w->Ln1 = 0.0;
     w->Fn1 = 0.0;
@@ -412,7 +412,7 @@
     _tMempool* m = *mp;
     _tLockhartWavefolder* w = *wf;
     
-    mpool_free(w, m->pool);
+    mpool_free(w, &m->pool);
 }
 
 double tLockhartWavefolderLambert(double x, double ln)
@@ -511,7 +511,7 @@
 void    tCrusher_initToPool   (tCrusher* const cr, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tCrusher* c = *cr = (_tCrusher*) mpool_alloc(sizeof(_tCrusher), m->pool);
+    _tCrusher* c = *cr = (_tCrusher*) mpool_alloc(sizeof(_tCrusher), &m->pool);
     
     c->op = 4;
     c->div = SCALAR;
@@ -526,7 +526,7 @@
     _tMempool* m = *mp;
     _tCrusher* c = *cr;
     tSampleReducer_freeFromPool(&c->sReducer, mp);
-    mpool_free(c, m->pool);
+    mpool_free(c, &m->pool);
 }
 
 float   tCrusher_tick    (tCrusher* const cr, float input)
--- a/LEAF/Src/leaf-dynamics.c
+++ b/LEAF/Src/leaf-dynamics.c
@@ -66,7 +66,7 @@
 void    tCompressor_initToPool  (tCompressor* const comp, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tCompressor* c = *comp = (_tCompressor*) mpool_alloc(sizeof(_tCompressor), m->pool);
+    _tCompressor* c = *comp = (_tCompressor*) mpool_alloc(sizeof(_tCompressor), &m->pool);
     
     c->tauAttack = 100;
     c->tauRelease = 100;
@@ -84,7 +84,7 @@
     _tMempool* m = *mp;
     _tCompressor* c = *comp;
     
-    mpool_free(c, m->pool);
+    mpool_free(c, &m->pool);
 }
 
 float tCompressor_tick(tCompressor* const comp, float in)
@@ -160,7 +160,7 @@
 void    tFeedbackLeveler_initToPool     (tFeedbackLeveler* const fb, float targetLevel, float factor, float strength, int mode, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tFeedbackLeveler* p = *fb = (_tFeedbackLeveler*) mpool_alloc(sizeof(_tFeedbackLeveler), m->pool);
+    _tFeedbackLeveler* p = *fb = (_tFeedbackLeveler*) mpool_alloc(sizeof(_tFeedbackLeveler), &m->pool);
     
     p->curr=0.0f;
     p->targetLevel=targetLevel;
@@ -175,7 +175,7 @@
     _tFeedbackLeveler* p = *fb;
     
     tPowerFollower_freeFromPool(&p->pwrFlw, mp);
-    mpool_free(p, m->pool);
+    mpool_free(p, &m->pool);
 }
 
 void     tFeedbackLeveler_setStrength(tFeedbackLeveler* const fb, float strength)
--- a/LEAF/Src/leaf-effects.c
+++ b/LEAF/Src/leaf-effects.c
@@ -62,7 +62,7 @@
 void    tTalkbox_initToPool     (tTalkbox* const voc, int bufsize, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tTalkbox* v = *voc = (_tTalkbox*) mpool_alloc(sizeof(_tTalkbox), m->pool);
+    _tTalkbox* v = *voc = (_tTalkbox*) mpool_alloc(sizeof(_tTalkbox), &m->pool);
     
     v->param[0] = 0.5f;  //wet
     v->param[1] = 0.0f;  //dry
@@ -71,11 +71,11 @@
     
     v->bufsize = bufsize;
     
-    v->car0 =   (float*) mpool_alloc(sizeof(float) * v->bufsize, m->pool);
-    v->car1 =   (float*) mpool_alloc(sizeof(float) * v->bufsize, m->pool);
-    v->window = (float*) mpool_alloc(sizeof(float) * v->bufsize, m->pool);
-    v->buf0 =   (float*) mpool_alloc(sizeof(float) * v->bufsize, m->pool);
-    v->buf1 =   (float*) mpool_alloc(sizeof(float) * v->bufsize, m->pool);
+    v->car0 =   (float*) mpool_alloc(sizeof(float) * v->bufsize, &m->pool);
+    v->car1 =   (float*) mpool_alloc(sizeof(float) * v->bufsize, &m->pool);
+    v->window = (float*) mpool_alloc(sizeof(float) * v->bufsize, &m->pool);
+    v->buf0 =   (float*) mpool_alloc(sizeof(float) * v->bufsize, &m->pool);
+    v->buf1 =   (float*) mpool_alloc(sizeof(float) * v->bufsize, &m->pool);
     
     tTalkbox_update(voc);
     tTalkbox_suspend(voc);
@@ -86,13 +86,13 @@
     _tMempool* m = *mp;
     _tTalkbox* v = *voc;
     
-    mpool_free(v->buf1, m->pool);
-    mpool_free(v->buf0, m->pool);
-    mpool_free(v->window, m->pool);
-    mpool_free(v->car1, m->pool);
-    mpool_free(v->car0, m->pool);
+    mpool_free(v->buf1, &m->pool);
+    mpool_free(v->buf0, &m->pool);
+    mpool_free(v->window, &m->pool);
+    mpool_free(v->car1, &m->pool);
+    mpool_free(v->car0, &m->pool);
     
-    mpool_free(v, m->pool);
+    mpool_free(v, &m->pool);
 }
 
 void tTalkbox_update(tTalkbox* const voc) ///update internal parameters...
@@ -305,7 +305,7 @@
 void    tVocoder_initToPool     (tVocoder* const voc, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tVocoder* v = *voc = (_tVocoder*) mpool_alloc(sizeof(_tVocoder), m->pool);
+    _tVocoder* v = *voc = (_tVocoder*) mpool_alloc(sizeof(_tVocoder), &m->pool);
     
     v->param[0] = 0.33f;  //input select
     v->param[1] = 0.50f;  //output dB
@@ -324,7 +324,7 @@
     _tMempool* m = *mp;
     _tVocoder* v = *voc;
     
-    mpool_free(v, m->pool);
+    mpool_free(v, &m->pool);
 }
 
 void        tVocoder_update      (tVocoder* const voc)
@@ -506,17 +506,11 @@
 // init
 void     tSOLAD_init(tSOLAD* const wp)
 {
-<<<<<<< HEAD
     _tSOLAD* w = *wp = (_tSOLAD*) leaf_allocAndClear(sizeof(_tSOLAD));
     
     w->pitchfactor = 1.;
     w->delaybuf = (float*) leaf_allocAndClear(sizeof(float) * (LOOPSIZE+16));
-=======
-    _tSOLAD* w = *wp = (_tSOLAD*) leaf_alloc(sizeof(_tSOLAD));
     
-    w->pitchfactor = 1.;
-    w->delaybuf = (float*) leaf_alloc(sizeof(float) * (LOOPSIZE+16));
->>>>>>> b8628af4ceadb4749cd557e6bd3057c2639f3c97
     solad_init(w);
 }
 
@@ -531,17 +525,12 @@
 void    tSOLAD_initToPool       (tSOLAD* const wp, tMempool* const mp)
 {
     _tMempool* m = *mp;
-<<<<<<< HEAD
-    _tSOLAD* w = *wp = (_tSOLAD*) mpool_allocAndClear(sizeof(_tSOLAD), m->pool);
+
+    _tSOLAD* w = *wp = (_tSOLAD*) mpool_allocAndClear(sizeof(_tSOLAD), &m->pool);
     
     w->pitchfactor = 1.;
-    w->delaybuf = (float*) mpool_allocAndClear(sizeof(float) * (LOOPSIZE+16), m->pool);
-=======
-    _tSOLAD* w = *wp = (_tSOLAD*) mpool_alloc(sizeof(_tSOLAD), m->pool);
-    
-    w->pitchfactor = 1.;
-    w->delaybuf = (float*) mpool_alloc(sizeof(float) * (LOOPSIZE+16), m->pool);
->>>>>>> b8628af4ceadb4749cd557e6bd3057c2639f3c97
+    w->delaybuf = (float*) mpool_allocAndClear(sizeof(float) * (LOOPSIZE+16), &m->pool);
+
     solad_init(w);
 }
 
@@ -550,8 +539,8 @@
     _tMempool* m = *mp;
     _tSOLAD* w = *wp;
     
-    mpool_free(w->delaybuf, m->pool);
-    mpool_free(w, m->pool);
+    mpool_free(w->delaybuf, &m->pool);
+    mpool_free(w, &m->pool);
 }
 
 // send one block of input samples, receive one block of output samples
@@ -919,11 +908,9 @@
 void    tPitchShift_initToPool      (tPitchShift* const psr, tPeriodDetection* const pd, float* out, int bufSize, tMempool* const mp)
 {
     _tMempool* m = *mp;
-<<<<<<< HEAD
-    _tPitchShift* ps = *psr = (_tPitchShift*) mpool_allocAndClear(sizeof(_tPitchShift), m->pool);
-=======
-    _tPitchShift* ps = *psr = (_tPitchShift*) mpool_alloc(sizeof(_tPitchShift), m->pool);
->>>>>>> b8628af4ceadb4749cd557e6bd3057c2639f3c97
+
+    _tPitchShift* ps = *psr = (_tPitchShift*) mpool_allocAndClear(sizeof(_tPitchShift), &m->pool);
+
     _tPeriodDetection* p = *pd;
     
     ps->p = pd;
@@ -951,7 +938,7 @@
     
     tSOLAD_freeFromPool(&ps->sola, mp);
     tHighpass_freeFromPool(&ps->hp, mp);
-    mpool_free(ps, m->pool);
+    mpool_free(ps, &m->pool);
 }
 
 void tPitchShift_setPitchFactor(tPitchShift* psr, float pf)
@@ -1073,23 +1060,14 @@
 
 void tRetune_init(tRetune* const rt, int numVoices, int bufSize, int frameSize)
 {
-<<<<<<< HEAD
     _tRetune* r = *rt = (_tRetune*) leaf_allocAndClear(sizeof(_tRetune));
-=======
-    _tRetune* r = *rt = (_tRetune*) leaf_alloc(sizeof(_tRetune));
->>>>>>> b8628af4ceadb4749cd557e6bd3057c2639f3c97
     
     r->bufSize = bufSize;
     r->frameSize = frameSize;
     r->numVoices = numVoices;
     
-<<<<<<< HEAD
     r->inBuffer = (float*) leaf_allocAndClear(sizeof(float) * r->bufSize);
     r->outBuffers = (float**) leaf_allocAndClear(sizeof(float*) * r->numVoices);
-=======
-    r->inBuffer = (float*) leaf_alloc(sizeof(float) * r->bufSize);
-    r->outBuffers = (float**) leaf_alloc(sizeof(float*) * r->numVoices);
->>>>>>> b8628af4ceadb4749cd557e6bd3057c2639f3c97
     
     r->hopSize = DEFHOPSIZE;
     r->windowSize = DEFWINDOWSIZE;
@@ -1098,7 +1076,6 @@
     
     r->inputPeriod = 0.0f;
     
-<<<<<<< HEAD
     r->ps = (tPitchShift*) leaf_allocAndClear(sizeof(tPitchShift) * r->numVoices);
     r->pitchFactor = (float*) leaf_allocAndClear(sizeof(float) * r->numVoices);
     r->tickOutput = (float*) leaf_allocAndClear(sizeof(float) * r->numVoices);
@@ -1105,14 +1082,6 @@
     for (int i = 0; i < r->numVoices; ++i)
     {
         r->outBuffers[i] = (float*) leaf_allocAndClear(sizeof(float) * r->bufSize);
-=======
-    r->ps = (tPitchShift*) leaf_alloc(sizeof(tPitchShift) * r->numVoices);
-    r->pitchFactor = (float*) leaf_alloc(sizeof(float) * r->numVoices);
-    r->tickOutput = (float*) leaf_alloc(sizeof(float) * r->numVoices);
-    for (int i = 0; i < r->numVoices; ++i)
-    {
-        r->outBuffers[i] = (float*) leaf_alloc(sizeof(float) * r->bufSize);
->>>>>>> b8628af4ceadb4749cd557e6bd3057c2639f3c97
     }
     
     tPeriodDetection_init(&r->pd, r->inBuffer, r->outBuffers[0], r->bufSize, r->frameSize);
@@ -1144,19 +1113,14 @@
 void    tRetune_initToPool      (tRetune* const rt, int numVoices, int bufSize, int frameSize, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tRetune* r = *rt = (_tRetune*) mpool_alloc(sizeof(_tRetune), m->pool);
+    _tRetune* r = *rt = (_tRetune*) mpool_alloc(sizeof(_tRetune), &m->pool);
     
     r->bufSize = bufSize;
     r->frameSize = frameSize;
     r->numVoices = numVoices;
     
-<<<<<<< HEAD
-    r->inBuffer = (float*) mpool_allocAndClear(sizeof(float) * r->bufSize, m->pool);
-    r->outBuffers = (float**) mpool_allocAndClear(sizeof(float*) * r->numVoices, m->pool);
-=======
-    r->inBuffer = (float*) mpool_alloc(sizeof(float) * r->bufSize, m->pool);
-    r->outBuffers = (float**) mpool_alloc(sizeof(float*) * r->numVoices, m->pool);
->>>>>>> b8628af4ceadb4749cd557e6bd3057c2639f3c97
+    r->inBuffer = (float*) mpool_allocAndClear(sizeof(float) * r->bufSize, &m->pool);
+    r->outBuffers = (float**) mpool_allocAndClear(sizeof(float*) * r->numVoices, &m->pool);
     
     r->hopSize = DEFHOPSIZE;
     r->windowSize = DEFWINDOWSIZE;
@@ -1164,22 +1128,13 @@
     tRetune_setTimeConstant(rt, DEFTIMECONSTANT);
     
     r->inputPeriod = 0.0f;
-    
-<<<<<<< HEAD
-    r->ps = (tPitchShift*) mpool_allocAndClear(sizeof(tPitchShift) * r->numVoices, m->pool);
-    r->pitchFactor = (float*) mpool_allocAndClear(sizeof(float) * r->numVoices, m->pool);
-    r->tickOutput = (float*) mpool_allocAndClear(sizeof(float) * r->numVoices, m->pool);
+
+    r->ps = (tPitchShift*) mpool_allocAndClear(sizeof(tPitchShift) * r->numVoices, &m->pool);
+    r->pitchFactor = (float*) mpool_allocAndClear(sizeof(float) * r->numVoices, &m->pool);
+    r->tickOutput = (float*) mpool_allocAndClear(sizeof(float) * r->numVoices, &m->pool);
     for (int i = 0; i < r->numVoices; ++i)
     {
-        r->outBuffers[i] = (float*) mpool_allocAndClear(sizeof(float) * r->bufSize, m->pool);
-=======
-    r->ps = (tPitchShift*) mpool_alloc(sizeof(tPitchShift) * r->numVoices, m->pool);
-    r->pitchFactor = (float*) mpool_alloc(sizeof(float) * r->numVoices, m->pool);
-    r->tickOutput = (float*) mpool_alloc(sizeof(float) * r->numVoices, m->pool);
-    for (int i = 0; i < r->numVoices; ++i)
-    {
-        r->outBuffers[i] = (float*) mpool_alloc(sizeof(float) * r->bufSize, m->pool);
->>>>>>> b8628af4ceadb4749cd557e6bd3057c2639f3c97
+        r->outBuffers[i] = (float*) mpool_allocAndClear(sizeof(float) * r->bufSize, &m->pool);
     }
     
     tPeriodDetection_initToPool(&r->pd, r->inBuffer, r->outBuffers[0], r->bufSize, r->frameSize, mp);
@@ -1199,14 +1154,14 @@
     for (int i = 0; i < r->numVoices; ++i)
     {
         tPitchShift_freeFromPool(&r->ps[i], mp);
-        mpool_free(r->outBuffers[i], m->pool);
+        mpool_free(r->outBuffers[i], &m->pool);
     }
-    mpool_free(r->tickOutput, m->pool);
-    mpool_free(r->pitchFactor, m->pool);
-    mpool_free(r->ps, m->pool);
-    mpool_free(r->inBuffer, m->pool);
-    mpool_free(r->outBuffers, m->pool);
-    mpool_free(r, m->pool);
+    mpool_free(r->tickOutput, &m->pool);
+    mpool_free(r->pitchFactor, &m->pool);
+    mpool_free(r->ps, &m->pool);
+    mpool_free(r->inBuffer, &m->pool);
+    mpool_free(r->outBuffers, &m->pool);
+    mpool_free(r, &m->pool);
 }
 
 float* tRetune_tick(tRetune* const rt, float sample)
@@ -1337,7 +1292,6 @@
     for (int i = 0; i < r->numVoices; ++i)
     {
         r->outBuffers[i] = (float*) leaf_alloc(sizeof(float) * r->bufSize);
-<<<<<<< HEAD
     }
     
     tPeriodDetection_init(&r->pd, r->inBuffer, r->outBuffers[0], r->bufSize, r->frameSize);
@@ -1347,17 +1301,6 @@
         tPitchShift_init(&r->ps[i], &r->pd, r->outBuffers[i], r->bufSize);
     }
     
-=======
-    }
-    
-    tPeriodDetection_init(&r->pd, r->inBuffer, r->outBuffers[0], r->bufSize, r->frameSize);
-    
-    for (int i = 0; i < r->numVoices; ++i)
-    {
-        tPitchShift_init(&r->ps[i], &r->pd, r->outBuffers[i], r->bufSize);
-    }
-    
->>>>>>> b8628af4ceadb4749cd557e6bd3057c2639f3c97
     r->inputPeriod = 0.0f;
 }
 
@@ -1382,14 +1325,14 @@
 void    tAutotune_initToPool        (tAutotune* const rt, int numVoices, int bufSize, int frameSize, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tAutotune* r = *rt = (_tAutotune*) mpool_alloc(sizeof(_tAutotune), m->pool);
+    _tAutotune* r = *rt = (_tAutotune*) mpool_alloc(sizeof(_tAutotune), &m->pool);
     
     r->bufSize = bufSize;
     r->frameSize = frameSize;
     r->numVoices = numVoices;
     
-    r->inBuffer = (float*) mpool_alloc(sizeof(float) * r->bufSize, m->pool);
-    r->outBuffers = (float**) mpool_alloc(sizeof(float*) * r->numVoices, m->pool);
+    r->inBuffer = (float*) mpool_alloc(sizeof(float) * r->bufSize, &m->pool);
+    r->outBuffers = (float**) mpool_alloc(sizeof(float*) * r->numVoices, &m->pool);
     
     r->hopSize = DEFHOPSIZE;
     r->windowSize = DEFWINDOWSIZE;
@@ -1398,12 +1341,12 @@
     
     
     
-    r->ps = (tPitchShift*) mpool_alloc(sizeof(tPitchShift) * r->numVoices, m->pool);
-    r->freq = (float*) mpool_alloc(sizeof(float) * r->numVoices, m->pool);
-    r->tickOutput = (float*) mpool_alloc(sizeof(float) * r->numVoices, m->pool);
+    r->ps = (tPitchShift*) mpool_alloc(sizeof(tPitchShift) * r->numVoices, &m->pool);
+    r->freq = (float*) mpool_alloc(sizeof(float) * r->numVoices, &m->pool);
+    r->tickOutput = (float*) mpool_alloc(sizeof(float) * r->numVoices, &m->pool);
     for (int i = 0; i < r->numVoices; ++i)
     {
-        r->outBuffers[i] = (float*) mpool_alloc(sizeof(float) * r->bufSize, m->pool);
+        r->outBuffers[i] = (float*) mpool_alloc(sizeof(float) * r->bufSize, &m->pool);
     }
     
     tPeriodDetection_initToPool(&r->pd, r->inBuffer, r->outBuffers[0], r->bufSize, r->frameSize, mp);
@@ -1425,14 +1368,14 @@
     for (int i = 0; i < r->numVoices; ++i)
     {
         tPitchShift_freeFromPool(&r->ps[i], mp);
-        mpool_free(r->outBuffers[i], m->pool);
+        mpool_free(r->outBuffers[i], &m->pool);
     }
-    mpool_free(r->tickOutput, m->pool);
-    mpool_free(r->freq, m->pool);
-    mpool_free(r->ps, m->pool);
-    mpool_free(r->inBuffer, m->pool);
-    mpool_free(r->outBuffers, m->pool);
-    mpool_free(r, m->pool);
+    mpool_free(r->tickOutput, &m->pool);
+    mpool_free(r->freq, &m->pool);
+    mpool_free(r->ps, &m->pool);
+    mpool_free(r->inBuffer, &m->pool);
+    mpool_free(r->outBuffers, &m->pool);
+    mpool_free(r, &m->pool);
 }
 
 float* tAutotune_tick(tAutotune* const rt, float sample)
@@ -1547,7 +1490,6 @@
     _tFormantShifter* fs = *fsr = (_tFormantShifter*) leaf_alloc(sizeof(_tFormantShifter));
     
     fs->ford = order;
-    fs->bufsize = bufsize;
     fs->fk = (float*) leaf_alloc(sizeof(float) * fs->ford);
     fs->fb = (float*) leaf_alloc(sizeof(float) * fs->ford);
     fs->fc = (float*) leaf_alloc(sizeof(float) * fs->ford);
@@ -1556,15 +1498,9 @@
     fs->fsig = (float*) leaf_alloc(sizeof(float) * fs->ford);
     fs->fsmooth = (float*) leaf_alloc(sizeof(float) * fs->ford);
     fs->ftvec = (float*) leaf_alloc(sizeof(float) * fs->ford);
-    
-    fs->fbuff = (float**) leaf_alloc(sizeof(float*) * fs->ford);
-    for (int i = 0; i < fs->ford; i++)
-    {
-        fs->fbuff[i] = (float*) leaf_alloc(sizeof(float) * fs->bufsize);
-    }
-    
-    
-    fs->falph = powf(0.001f, 80.0f / (leaf.sampleRate));
+    fs->fbuff = (float*) leaf_alloc(sizeof(float*) * fs->ford);
+
+    fs->falph = powf(0.001f, 10.0f / (leaf.sampleRate));
     fs->flamb = -(0.8517f*sqrtf(atanf(0.06583f*leaf.sampleRate))-0.1916f);
     fs->fhp = 0.0f;
     fs->flp = 0.0f;
@@ -1574,10 +1510,10 @@
     fs->cbi = 0;
     fs->intensity = 1.0f;
 	fs->invIntensity = 1.0f;
-	tHighpass_init(&fs->hp, 20.0f);
-	tHighpass_init(&fs->hp2, 20.0f);
-	tFeedbackLeveler_init(&fs->fbl1, 0.8f, 0.01f, 0.125f, 0);
-	tFeedbackLeveler_init(&fs->fbl2, 0.8f, 0.01f, 0.125f, 0);
+	tHighpass_init(&fs->hp, 10.0f);
+	tHighpass_init(&fs->hp2, 10.0f);
+	tFeedbackLeveler_init(&fs->fbl1, 0.8f, 0.005f, 0.125f, 0);
+	tFeedbackLeveler_init(&fs->fbl2, 0.8f, 0.005f, 0.125f, 0);
 }
 
 void tFormantShifter_free(tFormantShifter* const fsr)
@@ -1592,10 +1528,6 @@
     leaf_free(fs->fsig);
     leaf_free(fs->fsmooth);
     leaf_free(fs->ftvec);
-    for (int i = 0; i < fs->ford; i++)
-    {
-        leaf_free(fs->fbuff[i]);
-    }
     leaf_free(fs->fbuff);
     tHighpass_free(&fs->hp);
     tHighpass_free(&fs->hp2);
@@ -1607,26 +1539,22 @@
 void    tFormantShifter_initToPool      (tFormantShifter* const fsr, int bufsize, int order, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tFormantShifter* fs = *fsr = (_tFormantShifter*) mpool_alloc(sizeof(_tFormantShifter), m->pool);
+    _tFormantShifter* fs = *fsr = (_tFormantShifter*) mpool_alloc(sizeof(_tFormantShifter), &m->pool);
     
     fs->ford = order;
-    fs->bufsize = bufsize;
-    fs->fk = (float*) mpool_alloc(sizeof(float) * fs->ford, m->pool);
-    fs->fb = (float*) mpool_alloc(sizeof(float) * fs->ford, m->pool);
-    fs->fc = (float*) mpool_alloc(sizeof(float) * fs->ford, m->pool);
-    fs->frb = (float*) mpool_alloc(sizeof(float) * fs->ford, m->pool);
-    fs->frc = (float*) mpool_alloc(sizeof(float) * fs->ford, m->pool);
-    fs->fsig = (float*) mpool_alloc(sizeof(float) * fs->ford, m->pool);
-    fs->fsmooth = (float*) mpool_alloc(sizeof(float) * fs->ford, m->pool);
-    fs->ftvec = (float*) mpool_alloc(sizeof(float) * fs->ford, m->pool);
+    fs->fk = (float*) mpool_alloc(sizeof(float) * fs->ford, &m->pool);
+    fs->fb = (float*) mpool_alloc(sizeof(float) * fs->ford, &m->pool);
+    fs->fc = (float*) mpool_alloc(sizeof(float) * fs->ford, &m->pool);
+    fs->frb = (float*) mpool_alloc(sizeof(float) * fs->ford, &m->pool);
+    fs->frc = (float*) mpool_alloc(sizeof(float) * fs->ford, &m->pool);
+    fs->fsig = (float*) mpool_alloc(sizeof(float) * fs->ford, &m->pool);
+    fs->fsmooth = (float*) mpool_alloc(sizeof(float) * fs->ford, &m->pool);
+    fs->ftvec = (float*) mpool_alloc(sizeof(float) * fs->ford, &m->pool);
     
-    fs->fbuff = (float**) mpool_alloc(sizeof(float*) * fs->ford, m->pool);
-    for (int i = 0; i < fs->ford; i++)
-    {
-        fs->fbuff[i] = (float*) mpool_alloc(sizeof(float) * fs->bufsize, m->pool);
-    }
+    fs->fbuff = (float*) mpool_alloc(sizeof(float*) * fs->ford, &m->pool);
+
     
-    fs->falph = powf(0.001f, 80.0f / (leaf.sampleRate));
+    fs->falph = powf(0.001f, 10.0f / (leaf.sampleRate));
     fs->flamb = -(0.8517f*sqrtf(atanf(0.06583f*leaf.sampleRate))-0.1916f);
     fs->fhp = 0.0f;
     fs->flp = 0.0f;
@@ -1647,24 +1575,20 @@
     _tMempool* m = *mp;
     _tFormantShifter* fs = *fsr;
     
-    mpool_free(fs->fk, m->pool);
-    mpool_free(fs->fb, m->pool);
-    mpool_free(fs->fc, m->pool);
-    mpool_free(fs->frb, m->pool);
-    mpool_free(fs->frc, m->pool);
-    mpool_free(fs->fsig, m->pool);
-    mpool_free(fs->fsmooth, m->pool);
-    mpool_free(fs->ftvec, m->pool);
-    for (int i = 0; i < fs->ford; i++)
-    {
-        mpool_free(fs->fbuff[i], m->pool);
-    }
-    mpool_free(fs->fbuff, m->pool);
+    mpool_free(fs->fk, &m->pool);
+    mpool_free(fs->fb, &m->pool);
+    mpool_free(fs->fc, &m->pool);
+    mpool_free(fs->frb, &m->pool);
+    mpool_free(fs->frc, &m->pool);
+    mpool_free(fs->fsig, &m->pool);
+    mpool_free(fs->fsmooth, &m->pool);
+    mpool_free(fs->ftvec, &m->pool);
+    mpool_free(fs->fbuff, &m->pool);
     tHighpass_freeFromPool(&fs->hp, mp);
     tHighpass_freeFromPool(&fs->hp2, mp);
     tFeedbackLeveler_freeFromPool(&fs->fbl1, mp);
     tFeedbackLeveler_freeFromPool(&fs->fbl2, mp);
-    mpool_free(fs, m->pool);
+    mpool_free(fs, &m->pool);
 }
 
 float tFormantShifter_tick(tFormantShifter* const fsr, float in)
@@ -1676,11 +1600,11 @@
 {
     _tFormantShifter* fs = *fsr;
     in = tFeedbackLeveler_tick(&fs->fbl1, in * fs->intensity);
-    in = tHighpass_tick(&fs->hp, in);
+    in = tHighpass_tick(&fs->hp, in * 100.0f);
     
 
     float fa, fb, fc, foma, falph, ford, flamb, tf, fk;
-    int ti4;
+
     ford = fs->ford;
     falph = fs->falph;
     foma = (1.0f - falph);
@@ -1687,7 +1611,6 @@
     flamb = fs->flamb;
     
     tf = in;
-    ti4 = fs->cbi;
     
     fa = tf - fs->fhp;
     fs->fhp = tf;
@@ -1703,16 +1626,12 @@
         tf = fk/(fs->fsig[i] + 0.000001f);
         tf = tf*foma + fs->fsmooth[i]*falph;
         fs->fsmooth[i] = tf;
-        fs->fbuff[i][ti4] = tf;
+        fs->fbuff[i] = tf;
         fb = fc - tf*fa;
         fa = fa - tf*fc;
     }
-    fs->cbi++;
-    if(fs->cbi >= fs->bufsize)
-    {
-        fs->cbi = 0;
-    }
-    return fa;
+
+    return fa / 100.f;
     //return fa * fs->invIntensity;
 }
 
@@ -1721,14 +1640,12 @@
     _tFormantShifter* fs = *fsr;
     
     float fa, fb, fc, ford, flpa, flamb, tf, tf2, f0resp, f1resp, frlamb;
-    int ti4;
     ford = fs->ford;
 
     flpa = fs->flpa;
     flamb = fs->flamb;
-    tf = fs->shiftFactor * (1+flamb)/(1-flamb);
-    frlamb = (tf-1)/(tf+1);
-    ti4 = fs->cbi;
+    tf = fs->shiftFactor * (1.0f+flamb)/(1.0f-flamb);
+    frlamb = (tf-1.0f)/(tf+1.0f);
     
     tf2 = in;
     fa = 0.0f;
@@ -1736,7 +1653,7 @@
     for (int i=0; i<ford; i++)
     {
         fc = (fb-fs->frc[i])*frlamb + fs->frb[i];
-        tf = fs->fbuff[i][ti4];
+        tf = fs->fbuff[i];
         fb = fc - tf*fa;
         fs->ftvec[i] = tf*fc;
         fa = fa - fs->ftvec[i];
@@ -1749,12 +1666,12 @@
     f0resp = tf;
     
     //  second time: compute 1-response
-    fa = 1;
+    fa = 1.0f;
     fb = fa;
     for (int i=0; i<ford; i++)
     {
         fc = (fb-fs->frc[i])*frlamb + fs->frb[i];
-        tf = fs->fbuff[i][ti4];
+        tf = fs->fbuff[i];
         fb = fc - tf*fa;
         fs->ftvec[i] = tf*fc;
         fa = fa - fs->ftvec[i];
@@ -1787,7 +1704,7 @@
         fc = (fb-fs->frc[i])*frlamb + fs->frb[i];
         fs->frc[i] = fc;
         fs->frb[i] = fb;
-        tf = fs->fbuff[i][ti4];
+        tf = fs->fbuff[i];
         fb = fc - tf*fa;
         fa = fa - tf*fc;
     }
--- a/LEAF/Src/leaf-electrical.c
+++ b/LEAF/Src/leaf-electrical.c
@@ -181,7 +181,7 @@
 void    tWDF_initToPool             (tWDF* const wdf, WDFComponentType type, float value, tWDF* const rL, tWDF* const rR, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    *wdf = (_tWDF*) mpool_alloc(sizeof(_tWDF), m->pool);
+    *wdf = (_tWDF*) mpool_alloc(sizeof(_tWDF), &m->pool);
     
     wdf_init(wdf, type, value, rL, rR);
 }
@@ -191,7 +191,7 @@
     _tMempool* m = *mp;
     _tWDF* r = *wdf;
     
-    mpool_free(r, m->pool);
+    mpool_free(r, &m->pool);
 }
 
 float tWDF_tick(tWDF* const wdf, float sample, tWDF* const outputPoint, uint8_t paramsChanged)
--- a/LEAF/Src/leaf-envelopes.c
+++ b/LEAF/Src/leaf-envelopes.c
@@ -73,7 +73,7 @@
 void    tEnvelope_initToPool    (tEnvelope* const envlp, float attack, float decay, oBool loop, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tEnvelope* env = *envlp = (_tEnvelope*) mpool_alloc(sizeof(_tEnvelope), m->pool);
+    _tEnvelope* env = *envlp = (_tEnvelope*) mpool_alloc(sizeof(_tEnvelope), &m->pool);
     
     env->exp_buff = exp_decay;
     env->inc_buff = attack_decay_inc;
@@ -115,7 +115,7 @@
 {
     _tMempool* m = *mp;
     _tEnvelope* env = *envlp;
-    mpool_free(env, m->pool);
+    mpool_free(env, &m->pool);
 }
 
 void     tEnvelope_setAttack(tEnvelope* const envlp, float attack)
@@ -320,7 +320,7 @@
 void    tADSR_initToPool    (tADSR* const adsrenv, float attack, float decay, float sustain, float release, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tADSR* adsr = *adsrenv = (_tADSR*) mpool_alloc(sizeof(_tADSR), m->pool);
+    _tADSR* adsr = *adsrenv = (_tADSR*) mpool_alloc(sizeof(_tADSR), &m->pool);
     
     adsr->exp_buff = exp_decay;
     adsr->inc_buff = attack_decay_inc;
@@ -379,7 +379,7 @@
     _tMempool* m = *mp;
     _tADSR* adsr = *adsrenv;
     
-    mpool_free(adsr, m->pool);
+    mpool_free(adsr, &m->pool);
 }
 
 void     tADSR_setAttack(tADSR* const adsrenv, float attack)
@@ -594,7 +594,7 @@
 void    tRamp_initToPool    (tRamp* const r, float time, int samples_per_tick, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tRamp* ramp = *r = (_tRamp*) mpool_alloc(sizeof(_tRamp), m->pool);
+    _tRamp* ramp = *r = (_tRamp*) mpool_alloc(sizeof(_tRamp), &m->pool);
     
     ramp->inv_sr_ms = 1.0f/(leaf.sampleRate*0.001f);
     ramp->minimum_time = ramp->inv_sr_ms * samples_per_tick;
@@ -619,7 +619,7 @@
     _tMempool* m = *mp;
     _tRamp* ramp = *r;
     
-    mpool_free(ramp, m->pool);
+    mpool_free(ramp, &m->pool);
 }
 
 void     tRamp_setTime(tRamp* const ramp, float time)
@@ -706,7 +706,7 @@
 void    tExpSmooth_initToPool   (tExpSmooth* const expsmooth, float val, float factor, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tExpSmooth* smooth = *expsmooth = (_tExpSmooth*) mpool_alloc(sizeof(_tExpSmooth), m->pool);
+    _tExpSmooth* smooth = *expsmooth = (_tExpSmooth*) mpool_alloc(sizeof(_tExpSmooth), &m->pool);
     
     smooth->curr=val;
     smooth->dest=val;
@@ -721,7 +721,7 @@
     _tMempool* m = *mp;
     _tExpSmooth* smooth = *expsmooth;
     
-    mpool_free(smooth, m->pool);
+    mpool_free(smooth, &m->pool);
 }
 
 void     tExpSmooth_setFactor(tExpSmooth* const expsmooth, float factor)
--- a/LEAF/Src/leaf-filters.c
+++ b/LEAF/Src/leaf-filters.c
@@ -43,7 +43,7 @@
 void    tAllpass_initToPool     (tAllpass* const ft, float initDelay, uint32_t maxDelay, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tAllpass* f = *ft = (_tAllpass*) mpool_alloc(sizeof(_tAllpass), m->pool);
+    _tAllpass* f = *ft = (_tAllpass*) mpool_alloc(sizeof(_tAllpass), &m->pool);
     
     f->gain = 0.7f;
     
@@ -58,7 +58,7 @@
     _tAllpass* f = *ft;
     
     tLinearDelay_freeFromPool(&f->delay, mp);
-    mpool_free(f, m->pool);
+    mpool_free(f, &m->pool);
 }
 
 void    tAllpass_setDelay(tAllpass* const ft, float delay)
@@ -112,7 +112,7 @@
 void    tOnePole_initToPool     (tOnePole* const ft, float freq, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tOnePole* f = *ft = (_tOnePole*) mpool_alloc(sizeof(_tOnePole), m->pool);
+    _tOnePole* f = *ft = (_tOnePole*) mpool_alloc(sizeof(_tOnePole), &m->pool);
     
     f->gain = 1.0f;
     f->a0 = 1.0;
@@ -128,7 +128,7 @@
     _tMempool* m = *mp;
     _tOnePole* f = *ft;
     
-    mpool_free(f, m->pool);
+    mpool_free(f, &m->pool);
 }
 
 void    tOnePole_setB0(tOnePole* const ft, float b0)
@@ -215,7 +215,7 @@
 void    tTwoPole_initToPool     (tTwoPole* const ft, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tTwoPole* f = *ft = (_tTwoPole*) mpool_alloc(sizeof(_tTwoPole), m->pool);
+    _tTwoPole* f = *ft = (_tTwoPole*) mpool_alloc(sizeof(_tTwoPole), &m->pool);
     
     f->gain = 1.0f;
     f->a0 = 1.0;
@@ -230,7 +230,7 @@
     _tMempool* m = *mp;
     _tTwoPole* f = *ft;
     
-    mpool_free(f, m->pool);
+    mpool_free(f, &m->pool);
 }
 
 float   tTwoPole_tick(tTwoPole* const ft, float input)
@@ -341,7 +341,7 @@
 void    tOneZero_initToPool     (tOneZero* const ft, float theZero, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tOneZero* f = *ft = (_tOneZero*) mpool_alloc(sizeof(_tOneZero), m->pool);
+    _tOneZero* f = *ft = (_tOneZero*) mpool_alloc(sizeof(_tOneZero), &m->pool);
     
     f->gain = 1.0f;
     f->lastIn = 0.0f;
@@ -354,7 +354,7 @@
     _tMempool* m = *mp;
     _tOneZero* f = *ft;
     
-    mpool_free(f, m->pool);
+    mpool_free(f, &m->pool);
 }
 
 float   tOneZero_tick(tOneZero* const ft, float input)
@@ -456,7 +456,7 @@
 void    tTwoZero_initToPool     (tTwoZero* const ft, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tTwoZero* f = *ft = (_tTwoZero*) mpool_alloc(sizeof(_tTwoZero), m->pool);
+    _tTwoZero* f = *ft = (_tTwoZero*) mpool_alloc(sizeof(_tTwoZero), &m->pool);
     
     f->gain = 1.0f;
     f->lastIn[0] = 0.0f;
@@ -468,7 +468,7 @@
     _tMempool* m = *mp;
     _tTwoZero* f = *ft;
     
-    mpool_free(f, m->pool);
+    mpool_free(f, &m->pool);
 }
 
 float   tTwoZero_tick(tTwoZero* const ft, float input)
@@ -564,7 +564,7 @@
 void    tPoleZero_initToPool        (tPoleZero* const pzf, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tPoleZero* f = *pzf = (_tPoleZero*) mpool_alloc(sizeof(_tPoleZero), m->pool);
+    _tPoleZero* f = *pzf = (_tPoleZero*) mpool_alloc(sizeof(_tPoleZero), &m->pool);
     
     f->gain = 1.0f;
     f->b0 = 1.0;
@@ -579,7 +579,7 @@
     _tMempool* m = *mp;
     _tPoleZero* f = *pzf;
     
-    mpool_free(f, m->pool);
+    mpool_free(f, &m->pool);
 }
 
 void    tPoleZero_setB0(tPoleZero* const pzf, float b0)
@@ -695,7 +695,7 @@
 void    tBiQuad_initToPool     (tBiQuad* const ft, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tBiQuad* f = *ft = (_tBiQuad*) mpool_alloc(sizeof(_tBiQuad), m->pool);
+    _tBiQuad* f = *ft = (_tBiQuad*) mpool_alloc(sizeof(_tBiQuad), &m->pool);
     
     f->gain = 1.0f;
     
@@ -713,7 +713,7 @@
     _tMempool* m = *mp;
     _tBiQuad* f = *ft;
     
-    mpool_free(f, m->pool);
+    mpool_free(f, &m->pool);
 }
 
 float   tBiQuad_tick(tBiQuad* const ft, float input)
@@ -867,7 +867,7 @@
 void    tSVF_initToPool     (tSVF* const svff, SVFType type, float freq, float Q, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tSVF* svf = *svff = (_tSVF*) mpool_alloc(sizeof(_tSVF), m->pool);
+    _tSVF* svf = *svff = (_tSVF*) mpool_alloc(sizeof(_tSVF), &m->pool);
     
     svf->type = type;
     
@@ -886,7 +886,7 @@
     _tMempool* m = *mp;
     _tSVF* svf = *svff;
     
-    mpool_free(svf, m->pool);
+    mpool_free(svf, &m->pool);
 }
 
 float   tSVF_tick(tSVF* const svff, float v0)
@@ -956,7 +956,7 @@
 void    tEfficientSVF_initToPool    (tEfficientSVF* const svff, SVFType type, uint16_t input, float Q, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tEfficientSVF* svf = *svff = (_tEfficientSVF*) mpool_alloc(sizeof(_tEfficientSVF), m->pool);
+    _tEfficientSVF* svf = *svff = (_tEfficientSVF*) mpool_alloc(sizeof(_tEfficientSVF), &m->pool);
     
     svf->type = type;
     
@@ -975,7 +975,7 @@
     _tMempool* m = *mp;
     _tEfficientSVF* svf = *svff;
     
-    mpool_free(svf, m->pool);
+    mpool_free(svf, &m->pool);
 }
 
 float   tEfficientSVF_tick(tEfficientSVF* const svff, float v0)
@@ -1040,7 +1040,7 @@
 void    tHighpass_initToPool    (tHighpass* const ft, float freq, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tHighpass* f = *ft = (_tHighpass*) mpool_alloc(sizeof(_tHighpass), m->pool);
+    _tHighpass* f = *ft = (_tHighpass*) mpool_alloc(sizeof(_tHighpass), &m->pool);
     
     f->R = (1.0f - (freq * leaf.twoPiTimesInvSampleRate));
     f->ys = 0.0f;
@@ -1054,7 +1054,7 @@
     _tMempool* m = *mp;
     _tHighpass* f = *ft;
     
-    mpool_free(f, m->pool);
+    mpool_free(f, &m->pool);
 }
 
 void     tHighpass_setFreq(tHighpass* const ft, float freq)
@@ -1121,7 +1121,7 @@
 void    tButterworth_initToPool     (tButterworth* const ft, int N, float f1, float f2, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tButterworth* f = *ft = (_tButterworth*) mpool_alloc(sizeof(_tButterworth), m->pool);
+    _tButterworth* f = *ft = (_tButterworth*) mpool_alloc(sizeof(_tButterworth), &m->pool);
     
     f->f1 = f1;
     f->f2 = f2;
@@ -1149,7 +1149,7 @@
         tSVF_freeFromPool(&f->high[i], mp);
     }
     
-    mpool_free(f, m->pool);
+    mpool_free(f, &m->pool);
 }
 
 float tButterworth_tick(tButterworth* const ft, float samp)
@@ -1214,11 +1214,11 @@
 void    tFIR_initToPool     (tFIR* const firf, float* coeffs, int numTaps, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tFIR* fir = *firf = (_tFIR*) mpool_alloc(sizeof(_tFIR), m->pool);
+    _tFIR* fir = *firf = (_tFIR*) mpool_alloc(sizeof(_tFIR), &m->pool);
     
     fir->numTaps = numTaps;
     fir->coeff = coeffs;
-    fir->past = (float*) mpool_alloc(sizeof(float) * fir->numTaps, m->pool);
+    fir->past = (float*) mpool_alloc(sizeof(float) * fir->numTaps, &m->pool);
     for (int i = 0; i < fir->numTaps; ++i) fir->past[i] = 0.0f;
 }
 
@@ -1227,8 +1227,8 @@
     _tMempool* m = *mp;
     _tFIR* fir = *firf;
     
-    mpool_free(fir->past, m->pool);
-    mpool_free(fir, m->pool);
+    mpool_free(fir->past, &m->pool);
+    mpool_free(fir, &m->pool);
 }
 
 float	tFIR_tick(tFIR* const firf, float input)
--- a/LEAF/Src/leaf-instruments.c
+++ b/LEAF/Src/leaf-instruments.c
@@ -66,7 +66,7 @@
 void        t808Cowbell_initToPool      (t808Cowbell* const cowbellInst, int useStick, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _t808Cowbell* cowbell = *cowbellInst = (_t808Cowbell*) mpool_alloc(sizeof(_t808Cowbell), m->pool);
+    _t808Cowbell* cowbell = *cowbellInst = (_t808Cowbell*) mpool_alloc(sizeof(_t808Cowbell), &m->pool);
     
     tSquare_initToPool(&cowbell->p[0], mp);
     tSquare_setFreq(&cowbell->p[0], 540.0f);
@@ -107,7 +107,7 @@
     tHighpass_freeFromPool(&cowbell->highpass, mp);
     tNoise_freeFromPool(&cowbell->stick, mp);
     tEnvelope_freeFromPool(&cowbell->envStick, mp);
-    mpool_free(cowbell, m->pool);
+    mpool_free(cowbell, &m->pool);
 }
 
 void t808Cowbell_on(t808Cowbell* const cowbellInst, float vel)
@@ -242,7 +242,7 @@
 void    t808Hihat_initToPool  (t808Hihat* const hihatInst, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _t808Hihat* hihat = *hihatInst = (_t808Hihat*) mpool_alloc(sizeof(_t808Hihat), m->pool);
+    _t808Hihat* hihat = *hihatInst = (_t808Hihat*) mpool_alloc(sizeof(_t808Hihat), &m->pool);
     
     for (int i = 0; i < 6; i++)
     {
@@ -294,7 +294,7 @@
     
     tHighpass_freeFromPool(&hihat->highpass, mp);
     
-    mpool_free(hihat, m->pool);
+    mpool_free(hihat, &m->pool);
 }
 
 void t808Hihat_on(t808Hihat* const hihatInst, float vel)
@@ -454,7 +454,7 @@
 void    t808Snare_initToPool    (t808Snare* const snareInst, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _t808Snare* snare = *snareInst = (_t808Snare*) mpool_alloc(sizeof(_t808Snare), m->pool);
+    _t808Snare* snare = *snareInst = (_t808Snare*) mpool_alloc(sizeof(_t808Snare), &m->pool);
     
     float ratio[2] = {1.0, 1.5};
     for (int i = 0; i < 2; i++)
@@ -499,7 +499,7 @@
     tEnvelope_freeFromPool(&snare->noiseEnvGain, mp);
     tEnvelope_freeFromPool(&snare->noiseEnvFilter, mp);
     
-    mpool_free(snare, m->pool);
+    mpool_free(snare, &m->pool);
 }
 
 void t808Snare_on(t808Snare* const snareInst, float vel)
@@ -629,7 +629,7 @@
 void    t808Kick_initToPool (t808Kick* const kickInst, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _t808Kick* kick = *kickInst = (_t808Kick*) mpool_alloc(sizeof(_t808Kick), m->pool);
+    _t808Kick* kick = *kickInst = (_t808Kick*) mpool_alloc(sizeof(_t808Kick), &m->pool);
     
     tCycle_initToPool(&kick->tone, mp);
     kick->toneInitialFreq = 40.0f;
@@ -658,7 +658,7 @@
     tNoise_freeFromPool(&kick->noiseOsc, mp);
     tEnvelope_freeFromPool(&kick->noiseEnvGain, mp);
     
-    mpool_free(kick, m->pool);
+    mpool_free(kick, &m->pool);
 }
 
 float       t808Kick_tick                  (t808Kick* const kickInst)
--- a/LEAF/Src/leaf-mempool.c
+++ b/LEAF/Src/leaf-mempool.c
@@ -364,7 +364,7 @@
 {
     _tMempool* m = *mp = (_tMempool*) leaf_alloc(sizeof(_tMempool));
     
-    mpool_create (memory, size, m->pool);
+    mpool_create (memory, size, &m->pool);
 }
 
 void tMempool_free(tMempool* const mp)
@@ -377,9 +377,9 @@
 void    tMempool_initToPool     (tMempool* const mp, char* memory, size_t size, tMempool* const mem)
 {
     _tMempool* mm = *mem;
-    _tMempool* m = *mp = (_tMempool*) mpool_alloc(sizeof(_tMempool), mm->pool);
+    _tMempool* m = *mp = (_tMempool*) mpool_alloc(sizeof(_tMempool), &mm->pool);
     
-    mpool_create (memory, size, m->pool);
+    mpool_create (memory, size, &m->pool);
 }
 
 void    tMempool_freeFromPool   (tMempool* const mp, tMempool* const mem)
@@ -387,5 +387,5 @@
     _tMempool* mm = *mem;
     _tMempool* m = *mp;
     
-    mpool_free(m, mm->pool);
+    mpool_free(m, &mm->pool);
 }
--- a/LEAF/Src/leaf-midi.c
+++ b/LEAF/Src/leaf-midi.c
@@ -42,7 +42,7 @@
 void    tStack_initToPool           (tStack* const stack, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tStack* ns = *stack = (_tStack*) mpool_alloc(sizeof(_tStack), m->pool);
+    _tStack* ns = *stack = (_tStack*) mpool_alloc(sizeof(_tStack), &m->pool);
     
     ns->ordered = OFALSE;
     ns->size = 0;
@@ -57,7 +57,7 @@
     _tMempool* m = *mp;
     _tStack* ns = *stack;
     
-    mpool_free(ns, m->pool);
+    mpool_free(ns, &m->pool);
 }
 
 // If stack contains note, returns index. Else returns -1;
@@ -339,7 +339,7 @@
 void    tPoly_initToPool            (tPoly* const polyh, int maxNumVoices, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tPoly* poly = *polyh = (_tPoly*) mpool_alloc(sizeof(_tPoly), m->pool);
+    _tPoly* poly = *polyh = (_tPoly*) mpool_alloc(sizeof(_tPoly), &m->pool);
     
     poly->numVoices = maxNumVoices;
     poly->maxNumVoices = maxNumVoices;
@@ -359,14 +359,14 @@
     
     poly->glideTime = 5.0f;
     
-    poly->ramps = (tRamp*) mpool_alloc(sizeof(tRamp) * poly->maxNumVoices, m->pool);
-    poly->rampVals = (float*) mpool_alloc(sizeof(float) * poly->maxNumVoices, m->pool);
-    poly->firstReceived = (oBool*) mpool_alloc(sizeof(oBool) * poly->maxNumVoices, m->pool);
-    poly->voices = (int**) mpool_alloc(sizeof(int*) * poly->maxNumVoices, m->pool);
+    poly->ramps = (tRamp*) mpool_alloc(sizeof(tRamp) * poly->maxNumVoices, &m->pool);
+    poly->rampVals = (float*) mpool_alloc(sizeof(float) * poly->maxNumVoices, &m->pool);
+    poly->firstReceived = (oBool*) mpool_alloc(sizeof(oBool) * poly->maxNumVoices, &m->pool);
+    poly->voices = (int**) mpool_alloc(sizeof(int*) * poly->maxNumVoices, &m->pool);
     
     for (int i = 0; i < poly->maxNumVoices; ++i)
     {
-        poly->voices[i] = (int*) mpool_alloc(sizeof(int) * 2, m->pool);
+        poly->voices[i] = (int*) mpool_alloc(sizeof(int) * 2, &m->pool);
         poly->voices[i][0] = -1;
         poly->firstReceived[i] = OFALSE;
         
@@ -390,18 +390,18 @@
     for (int i = 0; i < poly->maxNumVoices; i++)
     {
         tRamp_freeFromPool(&poly->ramps[i], mp);
-        mpool_free(poly->voices[i], m->pool);
+        mpool_free(poly->voices[i], &m->pool);
     }
     tRamp_freeFromPool(&poly->pitchBendRamp, mp);
     tStack_freeFromPool(&poly->stack, mp);
     tStack_freeFromPool(&poly->orderStack, mp);
     
-    mpool_free(poly->voices, m->pool);
-    mpool_free(poly->ramps, m->pool);
-    mpool_free(poly->rampVals, m->pool);
-    mpool_free(poly->firstReceived, m->pool);
+    mpool_free(poly->voices, &m->pool);
+    mpool_free(poly->ramps, &m->pool);
+    mpool_free(poly->rampVals, &m->pool);
+    mpool_free(poly->firstReceived, &m->pool);
     
-    mpool_free(poly, m->pool);
+    mpool_free(poly, &m->pool);
 }
 
 void tPoly_tickPitch(tPoly* polyh)
--- a/LEAF/Src/leaf-oscillators.c
+++ b/LEAF/Src/leaf-oscillators.c
@@ -37,7 +37,7 @@
 void    tCycle_initToPool   (tCycle* const cy, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tCycle* c = *cy = (_tCycle*) mpool_alloc(sizeof(_tCycle), m->pool);
+    _tCycle* c = *cy = (_tCycle*) mpool_alloc(sizeof(_tCycle), &m->pool);
     
     c->inc      =  0.0f;
     c->phase    =  0.0f;
@@ -48,7 +48,7 @@
     _tMempool* m = *mp;
     _tCycle* c = *cy;
     
-    mpool_free(c, m->pool);
+    mpool_free(c, &m->pool);
 }
 
 int     tCycle_setFreq(tCycle* const cy, float freq)
@@ -108,7 +108,7 @@
 void    tTriangle_initToPool    (tTriangle* const cy, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tTriangle* c = *cy = (_tTriangle*) mpool_alloc(sizeof(_tTriangle), m->pool);
+    _tTriangle* c = *cy = (_tTriangle*) mpool_alloc(sizeof(_tTriangle), &m->pool);
     
     c->inc      =  0.0f;
     c->phase    =  0.0f;
@@ -119,7 +119,7 @@
     _tMempool* m = *mp;
     _tTriangle* c = *cy;
     
-    mpool_free(c, m->pool);
+    mpool_free(c, &m->pool);
 }
 
 int tTriangle_setFreq(tTriangle* const cy, float freq)
@@ -239,7 +239,7 @@
 void    tSquare_initToPool  (tSquare* const cy, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tSquare* c = *cy = (_tSquare*) mpool_alloc(sizeof(_tSquare), m->pool);
+    _tSquare* c = *cy = (_tSquare*) mpool_alloc(sizeof(_tSquare), &m->pool);
     
     c->inc      =  0.0f;
     c->phase    =  0.0f;
@@ -250,7 +250,7 @@
     _tMempool* m = *mp;
     _tSquare* c = *cy;
     
-    mpool_free(c, m->pool);
+    mpool_free(c, &m->pool);
 }
 
 int     tSquare_setFreq(tSquare* const cy, float freq)
@@ -368,7 +368,7 @@
 void    tSawtooth_initToPool    (tSawtooth* const cy, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tSawtooth* c = *cy = (_tSawtooth*) mpool_alloc(sizeof(_tSawtooth), m->pool);
+    _tSawtooth* c = *cy = (_tSawtooth*) mpool_alloc(sizeof(_tSawtooth), &m->pool);
     
     c->inc      = 0.0f;
     c->phase    = 0.0f;
@@ -379,7 +379,7 @@
     _tMempool* m = *mp;
     _tSawtooth* c = *cy;
     
-    mpool_free(c, m->pool);
+    mpool_free(c, &m->pool);
 }
 
 int     tSawtooth_setFreq(tSawtooth* const cy, float freq)
@@ -505,7 +505,7 @@
 void    tPhasor_initToPool  (tPhasor* const ph, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tPhasor* p = *ph = (_tPhasor*) mpool_alloc(sizeof(_tPhasor), m->pool);
+    _tPhasor* p = *ph = (_tPhasor*) mpool_alloc(sizeof(_tPhasor), &m->pool);
     
     p->phase = 0.0f;
     p->inc = 0.0f;
@@ -516,7 +516,7 @@
     _tMempool* m = *mp;
     _tPhasor* p = *ph;
     
-    mpool_free(p, m->pool);
+    mpool_free(p, &m->pool);
 }
 
 int     tPhasor_setFreq(tPhasor* const ph, float freq)
@@ -561,7 +561,7 @@
 void    tNoise_initToPool   (tNoise* const ns, NoiseType type, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tNoise* n = *ns = (_tNoise*) mpool_alloc(sizeof(_tNoise), m->pool);
+    _tNoise* n = *ns = (_tNoise*) mpool_alloc(sizeof(_tNoise), &m->pool);
     
     n->type = type;
     n->rand = leaf.random;
@@ -572,7 +572,7 @@
     _tMempool* m = *mp;
     _tNoise* n = *ns;
     
-    mpool_free(n, m->pool);
+    mpool_free(n, &m->pool);
 }
 
 float   tNoise_tick(tNoise* const ns)
@@ -646,7 +646,7 @@
 void    tNeuron_initToPool  (tNeuron* const nr, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tNeuron* n = *nr = (_tNeuron*) mpool_alloc(sizeof(_tNeuron), m->pool);
+    _tNeuron* n = *nr = (_tNeuron*) mpool_alloc(sizeof(_tNeuron), &m->pool);
     
     tPoleZero_initToPool(&n->f, mp);
     
@@ -681,7 +681,7 @@
     _tNeuron* n = *nr;
     
     tPoleZero_free(&n->f);
-    mpool_free(n, m->pool);
+    mpool_free(n, &m->pool);
 }
 
 void   tNeuron_reset(tNeuron* const nr)
--- a/LEAF/Src/leaf-physical.c
+++ b/LEAF/Src/leaf-physical.c
@@ -49,7 +49,7 @@
 void    tPluck_initToPool    (tPluck* const pl, float lowestFrequency, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tPluck* p = *pl = (_tPluck*) mpool_alloc(sizeof(_tPluck), m->pool);
+    _tPluck* p = *pl = (_tPluck*) mpool_alloc(sizeof(_tPluck), &m->pool);
     
     if ( lowestFrequency <= 0.0f )  lowestFrequency = 10.0f;
     
@@ -74,7 +74,7 @@
     tOneZero_freeFromPool(&p->loopFilter, mp);
     tAllpassDelay_freeFromPool(&p->delayLine, mp);
     
-    mpool_free(p, m->pool);
+    mpool_free(p, &m->pool);
 }
 
 float   tPluck_getLastOut    (tPluck* const pl)
@@ -204,7 +204,7 @@
 void    tKarplusStrong_initToPool   (tKarplusStrong* const pl, float lowestFrequency, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tKarplusStrong* p = *pl = (_tKarplusStrong*) mpool_alloc(sizeof(_tKarplusStrong), m->pool);
+    _tKarplusStrong* p = *pl = (_tKarplusStrong*) mpool_alloc(sizeof(_tKarplusStrong), &m->pool);
     
     if ( lowestFrequency <= 0.0f )  lowestFrequency = 8.0f;
     
@@ -246,7 +246,7 @@
         tBiQuad_freeFromPool(&p->biquad[i], mp);
     }
     
-    mpool_free(p, m->pool);
+    mpool_free(p, &m->pool);
 }
 
 float   tKarplusStrong_getLastOut    (tKarplusStrong* const pl)
@@ -441,7 +441,7 @@
                                          float levStrength, int levMode, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tSimpleLivingString* p = *pl = (_tSimpleLivingString*) mpool_alloc(sizeof(_tSimpleLivingString), m->pool);
+    _tSimpleLivingString* p = *pl = (_tSimpleLivingString*) mpool_alloc(sizeof(_tSimpleLivingString), &m->pool);
     
     p->curr=0.0f;
     tExpSmooth_initToPool(&p->wlSmooth, leaf.sampleRate/freq, 0.01, mp); // smoother for string wavelength (not freq, to avoid expensive divisions)
@@ -465,7 +465,7 @@
     tHighpass_freeFromPool(&p->DCblocker, mp);
     tFeedbackLeveler_freeFromPool(&p->fbLev, mp);
     
-    mpool_free(p, m->pool);
+    mpool_free(p, &m->pool);
 }
 
 void     tSimpleLivingString_setFreq(tSimpleLivingString* const pl, float freq)
@@ -603,7 +603,7 @@
                                      float levStrength, int levMode, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tLivingString* p = *pl = (_tLivingString*) mpool_alloc(sizeof(_tLivingString), m->pool);
+    _tLivingString* p = *pl = (_tLivingString*) mpool_alloc(sizeof(_tLivingString), &m->pool);
     
     p->curr=0.0f;
     tExpSmooth_initToPool(&p->wlSmooth, leaf.sampleRate/freq, 0.01, mp); // smoother for string wavelength (not freq, to avoid expensive divisions)
@@ -650,7 +650,7 @@
     tFeedbackLeveler_freeFromPool(&p->fbLevU, mp);
     tFeedbackLeveler_freeFromPool(&p->fbLevL, mp);
     
-    mpool_free(p, m->pool);
+    mpool_free(p, &m->pool);
 }
 
 void     tLivingString_setFreq(tLivingString* const pl, float freq)
@@ -795,7 +795,7 @@
 void    tReedTable_initToPool   (tReedTable* const pm, float offset, float slope, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tReedTable* p = *pm = (_tReedTable*) mpool_alloc(sizeof(_tReedTable), m->pool);
+    _tReedTable* p = *pm = (_tReedTable*) mpool_alloc(sizeof(_tReedTable), &m->pool);
     
     p->offset = offset;
     p->slope = slope;
@@ -806,7 +806,7 @@
     _tMempool* m = *mp;
     _tReedTable* p = *pm;
     
-    mpool_free(p, m->pool);
+    mpool_free(p, &m->pool);
 }
 
 float   tReedTable_tick      (tReedTable* const pm, float input)
--- a/LEAF/Src/leaf-reverb.c
+++ b/LEAF/Src/leaf-reverb.c
@@ -68,7 +68,7 @@
 void    tPRCReverb_initToPool   (tPRCReverb* const rev, float t60, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tPRCReverb* r = *rev = (_tPRCReverb*) mpool_alloc(sizeof(_tPRCReverb), m->pool);
+    _tPRCReverb* r = *rev = (_tPRCReverb*) mpool_alloc(sizeof(_tPRCReverb), &m->pool);
     
     if (t60 <= 0.0f) t60 = 0.001f;
     
@@ -110,7 +110,7 @@
     tDelay_freeFromPool(&r->allpassDelays[0], mp);
     tDelay_freeFromPool(&r->allpassDelays[1], mp);
     tDelay_freeFromPool(&r->combDelay, mp);
-    mpool_free(r, m->pool);
+    mpool_free(r, &m->pool);
 }
 
 void    tPRCReverb_setT60(tPRCReverb* const rev, float t60)
@@ -234,7 +234,7 @@
 void    tNReverb_initToPool     (tNReverb* const rev, float t60, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tNReverb* r = *rev = (_tNReverb*) mpool_alloc(sizeof(_tNReverb), m->pool);
+    _tNReverb* r = *rev = (_tNReverb*) mpool_alloc(sizeof(_tNReverb), &m->pool);
     
     if (t60 <= 0.0f) t60 = 0.001f;
     
@@ -287,7 +287,7 @@
         tLinearDelay_freeFromPool(&r->allpassDelays[i], mp);
     }
     
-    mpool_free(r, m->pool);
+    mpool_free(r, &m->pool);
 }
 
 void    tNReverb_setT60(tNReverb* const rev, float t60)
@@ -537,7 +537,7 @@
 void    tDattorroReverb_initToPool        (tDattorroReverb* const rev, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tDattorroReverb* r = *rev = (_tDattorroReverb*) mpool_alloc(sizeof(_tDattorroReverb), m->pool);
+    _tDattorroReverb* r = *rev = (_tDattorroReverb*) mpool_alloc(sizeof(_tDattorroReverb), &m->pool);
     
     r->size_max = 2.0f;
     r->size = 1.f;
@@ -636,7 +636,7 @@
     
     tCycle_freeFromPool(&r->f2_lfo, mp);
     
-    mpool_free(r, m->pool);
+    mpool_free(r, &m->pool);
 }
 
 float   tDattorroReverb_tick              (tDattorroReverb* const rev, float input)
--- a/LEAF/Src/leaf-sampling.c
+++ b/LEAF/Src/leaf-sampling.c
@@ -48,9 +48,9 @@
 void  tBuffer_initToPool (tBuffer* const sb, uint32_t length, tMempool* const mp)
 {
     _tMempool* m = *mp;
-    _tBuffer* s = *sb = (_tBuffer*) mpool_alloc(sizeof(_tBuffer), m->pool);
+    _tBuffer* s = *sb = (_tBuffer*) mpool_alloc(sizeof(_tBuffer), &m->pool);
     
-    s->buff = (float*) mpool_alloc( sizeof(float) * length, m->pool);
+    s->buff = (float*) mpool_alloc( sizeof(float) * length, &m->pool);
     
     s->bufferLength = length;
     s->recordedLength = 0;
@@ -63,8 +63,8 @@
     _tMempool* m = *mp;
     _tBuffer* s = *sb;
 
-    mpool_free(s->buff, m->pool);
-    mpool_free(s, m->pool);
+    mpool_free(s->buff, &m->pool);
+    mpool_free(s, &m->pool);
 }
 
 void tBuffer_tick (tBuffer* const sb, float sample)