trying out some ways to improve and optimize pitch detection

Matthew Wang committed 6 years ago

Commit f253eaf1 parent a8e41584 files · +118 −58Browse files

Unified · Split

4 files

leaf/Inc/leaf-analysis.h +1 −0
leaf/Inc/leaf-effects.h +18 −11
leaf/Src/leaf-analysis.c +41 −22
leaf/Src/leaf-effects.c +58 −25

@@ -909,6 +909,7 @@ extern "C" { · 908 unmodified lines
909	float _mean;	909	float _mean;
910	float _predicted_frequency;	910	float _predicted_frequency;
911	int _first;	911	int _first;
		912	int sub;
912		913
913	} _tDualPitchDetector;	914	} _tDualPitchDetector;
914		915

leaf/Inc/leaf-effects.h+18−11

      @} */
-#define LOOPSIZE (2048*2)      // (4096*2) // loop size must be power of two
+//#define LOOPSIZE (2048*2)      // (4096*2) // loop size must be power of two
-#define LOOPMASK (LOOPSIZE - 1)
+//#define LOOPMASK (LOOPSIZE - 1)
 #define PITCHFACTORDEFAULT 1.0f
 #define INITPERIOD 64.0f
-#define MAXPERIOD (float)((LOOPSIZE - w->blocksize) * 0.8f)
+//#define MAXPERIOD (float)((LOOPSIZE - w->blocksize) * 0.8f)
 #define MINPERIOD 8.0f
     typedef struct _tSOLAD
         tAttackDetection ad;
         tHighpass hp;
+        int loopSize;
         uint16_t timeindex;              // current reference time, write index
         uint16_t blocksize;              // signal input / output block size
         float pitchfactor;        // pitch factor between 0.25 and 4
     typedef _tSOLAD* tSOLAD;
-    void    tSOLAD_init             (tSOLAD* const, LEAF* const leaf);
+    void    tSOLAD_init             (tSOLAD* const, int loopSize, LEAF* const leaf);
-    void    tSOLAD_initToPool       (tSOLAD* const, tMempool* const);
+    void    tSOLAD_initToPool       (tSOLAD* const, int loopSize, tMempool* const);
     void    tSOLAD_free             (tSOLAD* const);
     // send one block of input samples, receive one block of output samples
         float* inBuffer;
         int bufSize;
         int index;
+        float pickiness;
     } _tPitchShift;
     typedef _tPitchShift* tPitchShift;
-    void    tPitchShift_init (tPitchShift* const, tDualPitchDetector* const, LEAF* const leaf);
+    void    tPitchShift_init (tPitchShift* const, tDualPitchDetector* const, int bufSize, LEAF* const leaf);
-    void    tPitchShift_initToPool (tPitchShift* const, tDualPitchDetector* const, tMempool* const);
+    void    tPitchShift_initToPool (tPitchShift* const, tDualPitchDetector* const, int bufSize, tMempool* const);
     void    tPitchShift_free (tPitchShift* const);
-    void    tPitchShift_shiftBy (tPitchShift* const, float factor, float* in, float* out, int bufSize);
+    void    tPitchShift_shiftBy (tPitchShift* const, float factor, float* in, float* out);
-    void    tPitchShift_shiftTo (tPitchShift* const, float freq, float* in, float* out, int bufSize);
+    void    tPitchShift_shiftTo (tPitchShift* const, float freq, float* in, float* out);
+    void    tPitchShift_setPickiness (tPitchShift* const, float p);
     /*!
      @defgroup tsimpleretune tSimpleRetune
         int bufSize;
         int index;
-        void (*shiftFunction)(tPitchShift* const, float, float*, float*, int);
+        void (*shiftFunction)(tPitchShift* const, float, float*, float*);
         float* shiftValues;
         int numVoices;
     float   tSimpleRetune_tick                  (tSimpleRetune* const, float sample);
     void    tSimpleRetune_setMode               (tSimpleRetune* const, int mode);
     void    tSimpleRetune_setNumVoices          (tSimpleRetune* const, int numVoices);
+    void    tSimpleRetune_setPickiness          (tSimpleRetune* const, float p);
     void    tSimpleRetune_tuneVoices            (tSimpleRetune* const, float* t);
     void    tSimpleRetune_tuneVoice             (tSimpleRetune* const, int voice, float t);
     float   tSimpleRetune_getInputFrequency     (tSimpleRetune* const);
         float* output;
-        void (*shiftFunction)(tPitchShift* const, float, float*, float*, int);
+        void (*shiftFunction)(tPitchShift* const, float, float*, float*);
         float* shiftValues;
         int numVoices;
     float*  tRetune_tick                (tRetune* const, float sample);
     void    tRetune_setMode             (tRetune* const, int mode);
     void    tRetune_setNumVoices        (tRetune* const, int numVoices);
+    void    tRetune_setPickiness        (tRetune* const, float p);
     void    tRetune_tuneVoices          (tRetune* const, float* t);
     void    tRetune_tuneVoice           (tRetune* const, int voice, float t);
     float   tRetune_getInputFrequency   (tRetune* const);

leaf/Src/leaf-analysis.c+41−22

     _tPitchDetector* p = *detector = (_tPitchDetector*) mpool_alloc(sizeof(_tPitchDetector), m);
     p->mempool = m;
-    tPeriodDetector_initToPool(&p->_pd, lowestFreq, highestFreq, DEFAULT_HYSTERESIS, mempool);
+    tPeriodDetector_initToPool(&p->_pd, lowestFreq, highestFreq, -120.0f, mempool);
     p->_current.frequency = 0.0f;
     p->_current.periodicity = 0.0f;
     p->_frames_after_shift = 0;
     _tDualPitchDetector* p = *detector = (_tDualPitchDetector*) mpool_alloc(sizeof(_tDualPitchDetector), m);
     p->mempool = m;
-    tPitchDetector_initToPool(&p->_pd1, lowestFreq, highestFreq, mempool);
+    tPitchDetector_initToPool(&p->_pd1, lowestFreq*2.0f, highestFreq*2.0f, mempool);
-    tPitchDetector_initToPool(&p->_pd2, lowestFreq, highestFreq, mempool);
+    tPitchDetector_initToPool(&p->_pd2, lowestFreq*2.0f, highestFreq*2.0f, mempool);
     p->_current.frequency = 0.0f;
     p->_current.periodicity = 0.0f;
     p->_mean = lowestFreq + ((highestFreq - lowestFreq) / 2.0f);
     p->_predicted_frequency = 0.0f;
     p->_first = 1;
+    p->sub = 0;
 }
 void    tDualPitchDetector_free (tDualPitchDetector* const detector)
 {
     _tDualPitchDetector* p = *detector;
-    int pd1_ready = tPitchDetector_tick(&p->_pd1, sample);
+    int pd1_ready;
-    int pd2_ready = tPitchDetector_tick(&p->_pd2, -sample);
+    if (!(p->sub % 2))
+    {
+        pd1_ready = tPitchDetector_tick(&p->_pd2, sample);
+        p->sub = 0;
+    }
+    else
+    {
+        pd1_ready = tPitchDetector_tick(&p->_pd1, sample);
+    }
+    p->sub++;
-    if (pd1_ready || pd2_ready)
+    if (pd1_ready)
     {
         int pd1_indeterminate = tPitchDetector_indeterminate(&p->_pd1);
         int pd2_indeterminate = tPitchDetector_indeterminate(&p->_pd2);
+        int disagreement = 0;
         if (!pd1_indeterminate && !pd2_indeterminate)
         {
             _pitch_info _i1 = p->_pd1->_current;
             _pitch_info _i2 = p->_pd2->_current;
-            float pd1_diff = fabsf(_i1.frequency - p->_mean);
+            float pd1_diff = fabsf(_i1.frequency*0.5f - p->_mean);
-            float pd2_diff = fabsf(_i2.frequency - p->_mean);
+            float pd2_diff = fabsf(_i2.frequency*0.5f - p->_mean);
-            _pitch_info i = (pd1_diff < pd2_diff) ? _i1 : _i2;
+            _pitch_info i1 = _i1;
+            i1.frequency = i1.frequency*0.5f;
+            _pitch_info i2 = _i2;
+            i2.frequency = i2.frequency*0.5f;
+            _pitch_info i = (pd1_diff < pd2_diff) ? i1 : i2;
+            disagreement = fabsf(pd1_diff - pd2_diff) > 2.0f;
-            if (p->_first)
+            if (!disagreement) {
-            {
+                if (p->_first)
-                p->_current = i;
+                {
-                p->_mean = p->_current.frequency;
+                    p->_current = i;
-                p->_first = 0;
+                    p->_mean = p->_current.frequency;
-                p->_predicted_frequency = 0.0f;
+                    p->_first = 0;
-            }
+                    p->_predicted_frequency = 0.0f;
-            else
+                }
-            {
+                else
-                p->_current = i;
+                {
-                p->_mean = (0.222222f * p->_current.frequency) + (0.777778f * p->_mean);
+                    p->_current = i;
-                p->_predicted_frequency = 0.0f;
+                    p->_mean = (0.2222222 * p->_current.frequency) + (0.7777778 * p->_mean);
+                    p->_predicted_frequency = 0.0f;
+                }
             }
         }
         }
     }
-    return pd1_ready || pd2_ready;
+    return pd1_ready;
 }
 float   tDualPitchDetector_getFrequency    (tDualPitchDetector* const detector)

leaf/Src/leaf-effects.c+58−25

 /******************************************************************************/
 // init
-void tSOLAD_init (tSOLAD* const wp, LEAF* const leaf)
+void tSOLAD_init (tSOLAD* const wp, int loopSize, LEAF* const leaf)
 {
-    tSOLAD_initToPool(wp, &leaf->mempool);
+    tSOLAD_initToPool(wp, loopSize, &leaf->mempool);
 }
-void tSOLAD_initToPool (tSOLAD* const wp, tMempool* const mp)
+void tSOLAD_initToPool (tSOLAD* const wp, int loopSize, tMempool* const mp)
 {
     _tMempool* m = *mp;
     _tSOLAD* w = *wp = (_tSOLAD*) mpool_calloc(sizeof(_tSOLAD), m);
     w->mempool = m;
+    w->loopSize = loopSize;
     w->pitchfactor = 1.;
-    w->delaybuf = (float*) mpool_calloc(sizeof(float) * LOOPSIZE, m);
+    w->delaybuf = (float*) mpool_calloc(sizeof(float) * w->loopSize, m);
     w->timeindex = 0;
     w->xfadevalue = -1;
     {
         float sample = tHighpass_tick(&w->hp, in[0]);
         w->delaybuf[0] = sample;
-        w->delaybuf[LOOPSIZE] = sample;   // copy one sample for interpolation
+        w->delaybuf[w->loopSize] = sample;   // copy one sample for interpolation
         n--;
         i++;
         in++;
     else pitchdown(w, out);
     w->timeindex += blocksize;
-    w->timeindex &= LOOPMASK;
+    w->timeindex &= (w->loopSize - 1);
 }
 // set periodicity analysis data
 {
     _tSOLAD* w = *wp;
-    if(period > MAXPERIOD) period = MAXPERIOD;
+    float maxPeriod = (float)((w->loopSize - w->blocksize) * 0.8f);
+    if(period > maxPeriod) period = maxPeriod;
     if(period > MINPERIOD) w->period = period;  // ignore period when too small
 }
 {
     _tSOLAD* w = *wp;
-    int n = LOOPSIZE;
+    int n = w->loopSize;
     float *buf = w->delaybuf;
     while(n--) *buf++ = 0;
 static void pitchdown(_tSOLAD* const w, float *out)
 {
     int n = w->blocksize;
-    float refindex = (float)(w->timeindex + LOOPSIZE); // no negative values!
+    float refindex = (float)(w->timeindex + w->loopSize); // no negative values!
     float pitchfactor = w->pitchfactor;
     float period = w->period;
     float readlag = w->readlag;
 static void pitchup(_tSOLAD* const w, float *out)
 {
     int n = w->blocksize;
-    float refindex = (float)(w->timeindex + LOOPSIZE); // no negative values
+    float refindex = (float)(w->timeindex + w->loopSize); // no negative values
     float pitchfactor = w->pitchfactor;
     float period = w->period;
     float readlag = w->readlag;
     int index = (int)floatindex;
     float fraction = floatindex - (float)index;
     float *buf = w->delaybuf;
-    index &= LOOPMASK;
+    index &= (w->loopSize - 1);
     return (buf[index] + (fraction * (buf[index+1] - buf[index])));
 }
 // PITCHSHIFT
 //============================================================================================================
-void tPitchShift_init (tPitchShift* const psr, tDualPitchDetector* const dpd, LEAF* const leaf)
+void tPitchShift_init (tPitchShift* const psr, tDualPitchDetector* const dpd, int bufSize, LEAF* const leaf)
 {
-    tPitchShift_initToPool(psr, dpd, &leaf->mempool);
+    tPitchShift_initToPool(psr, dpd, bufSize, &leaf->mempool);
 }
-void tPitchShift_initToPool (tPitchShift* const psr, tDualPitchDetector* const dpd, tMempool* const mp)
+void tPitchShift_initToPool (tPitchShift* const psr, tDualPitchDetector* const dpd, int bufSize, tMempool* const mp)
 {
     _tMempool* m = *mp;
     _tPitchShift* ps = *psr = (_tPitchShift*) mpool_alloc(sizeof(_tPitchShift), m);
     ps->mempool = m;
     ps->pd = *dpd;
+    ps->bufSize = bufSize;
+    ps->pickiness = 0.95f;
-    tSOLAD_initToPool(&ps->sola, mp);
+    tSOLAD_initToPool(&ps->sola, pow(2.0, ceil(log2(ps->bufSize * 2.0))), mp);
     tSOLAD_setPitchFactor(&ps->sola, DEFPITCHRATIO);
 }
     mpool_free((char*)ps, ps->mempool);
 }
-void tPitchShift_shiftBy (tPitchShift* const psr, float factor, float* in, float* out, int bufSize)
+void tPitchShift_shiftBy (tPitchShift* const psr, float factor, float* in, float* out)
 {
     _tPitchShift* ps = *psr;
     LEAF* leaf = ps->mempool->leaf;
     float detected = tDualPitchDetector_getFrequency(&ps->pd);
-    if (detected > 0.0f)
+    float periodicity = tDualPitchDetector_getPeriodicity(&ps->pd);
+    if (detected > 0.0f && periodicity > ps->pickiness)
     {
         float period = leaf->sampleRate / detected;
         tSOLAD_setPeriod(&ps->sola, period);
         tSOLAD_setPitchFactor(&ps->sola, factor);
     }
-    tSOLAD_ioSamples(&ps->sola, in, out, bufSize);
+    tSOLAD_ioSamples(&ps->sola, in, out, ps->bufSize);
 }
-void    tPitchShift_shiftTo (tPitchShift* const psr, float freq, float* in, float* out, int bufSize)
+void    tPitchShift_shiftTo (tPitchShift* const psr, float freq, float* in, float* out)
 {
     _tPitchShift* ps = *psr;
     LEAF* leaf = ps->mempool->leaf;
     float detected = tDualPitchDetector_getFrequency(&ps->pd);
-    if (detected > 0.0f)
+    float periodicity = tDualPitchDetector_getPeriodicity(&ps->pd);
+    if (detected > 0.0f && periodicity > ps->pickiness)
     {
         float period = 1.0f / detected;
         float factor = freq * period;
         tSOLAD_setPitchFactor(&ps->sola, factor);
     }
-    tSOLAD_ioSamples(&ps->sola, in, out, bufSize);
+    tSOLAD_ioSamples(&ps->sola, in, out, ps->bufSize);
+}
+void    tPitchShift_setPickiness (tPitchShift* const psr, float p)
+{
+    _tPitchShift* ps = *psr;
+    ps->pickiness = p;
 }
     for (int i = 0; i < r->numVoices; ++i)
     {
-        tPitchShift_initToPool(&r->ps[i], &r->dp, mp);
+        tPitchShift_initToPool(&r->ps[i], &r->dp, r->bufSize, mp);
     }
     r->shiftFunction = &tPitchShift_shiftBy;
     {
         for (int i = 0; i < r->numVoices; ++i)
         {
-            r->shiftFunction(&r->ps[i], r->shiftValues[i], r->inBuffer, r->outBuffer, r->bufSize);
+            r->shiftFunction(&r->ps[i], r->shiftValues[i], r->inBuffer, r->outBuffer);
         }
         r->index = 0;
     }
     tSimpleRetune_initToPool(rt, minInputFreq, maxInputFreq, numVoices, bufSize, &mempool);
 }
+void tSimpleRetune_setPickiness (tSimpleRetune* const rt, float p)
+{
+    _tSimpleRetune* r = *rt;
+    for (int i = 0; i < r->numVoices; ++i)
+    {
+        tPitchShift_setPickiness(&r->ps[i], p);
+    }
+}
 void tSimpleRetune_tuneVoices(tSimpleRetune* const rt, float* t)
 {
     _tSimpleRetune* r = *rt;
     for (int i = 0; i < r->numVoices; ++i)
     {
-        tPitchShift_initToPool(&r->ps[i], &r->dp, mp);
+        tPitchShift_initToPool(&r->ps[i], &r->dp, r->bufSize, mp);
         r->outBuffers[i] = (float*) mpool_calloc(sizeof(float) * r->bufSize, m);
     }
     {
         for (int i = 0; i < r->numVoices; ++i)
         {
-            r->shiftFunction(&r->ps[i], r->shiftValues[i], r->inBuffer, r->outBuffers[i], r->bufSize);
+            r->shiftFunction(&r->ps[i], r->shiftValues[i], r->inBuffer, r->outBuffers[i]);
         }
         r->index = 0;
     }
     else r->shiftFunction = &tPitchShift_shiftBy;
 }
+void tRetune_setPickiness (tRetune* const rt, float p)
+{
+    _tRetune* r = *rt;
+    for (int i = 0; i < r->numVoices; ++i)
+    {
+        tPitchShift_setPickiness(&r->ps[i], p);
+    }
+}
 void tRetune_setNumVoices(tRetune* const rt, int numVoices)
 {
     _tRetune* r = *rt;

trying out some ways to improve and optimize pitch detection

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code