Added zero-crossing counter pitch detector. TO BE TESTED: filer stages, TO BE ADDED: frequency to MIDI

Author: giuliomoro

LibSource/PitchDetector.hpp

@@ -0,0 +1,102 @@
+#ifndef __PitchDetectors_hpp__
+#define __PitchDetectors_hpp__
+
+#include "FloatArray.h"
+
+class ZeroCrossingPitchDetector{
+private:
+  BiquadFilter *filter;
+  int numLowPassStages;
+  int numHighPassStages;
+  FloatArray counts;
+  FloatArray filterOutput;
+  float samplingRate;
+public:
+  ZeroCrossingPitchDetector(): samplingRate(48000), numLowPassStages(1), numHighPassStages(0){
+    init(0);
+  };
+  ZeroCrossingPitchDetector(float aSamplingRate, int aMaxBlocksize):numLowPassStages(1), numHighPassStages(0){
+    samplingRate=aSamplingRate;
+    init(aMaxBlocksize);
+  };
+  ZeroCrossingPitchDetector(float aSamplingRate, int aMaxBlocksize, int aNumLowPassStages, int aNumHighPassStages){
+    samplingRate=aSamplingRate;
+    init(aMaxBlocksize);
+  }
+  ~ZeroCrossingPitchDetector(){
+    FloatArray::destroy(counts);
+    FloatArray::destroy(filterOutput);
+    BiquadFilter::destroy(filter);
+  }
+  void init(int aMaxBlocksize){
+    setMaxBlocksize(aMaxBlocksize);
+    counts=FloatArray::create(10); //number of zcc to be averaged
+    counts.setAll(0);
+    filter=BiquadFilter::create(numLowPassStages+numHighPassStages);
+    setLowPassCutoff(0.03);
+    setHighPassCutoff(0.001);
+  };
+  void setSamplingRate(float aSamplingRate){
+    samplingRate=aSamplingRate;
+  }
+  void setMaxBlocksize(int aMaxBlocksize){
+    FloatArray::destroy(filterOutput);
+    filterOutput=FloatArray::create(aMaxBlocksize);
+  }
+  void setLowPassCutoff(float fc){
+    if(numLowPassStages<1)
+      return;
+    FilterStage stage0=filter->getFilterStage(0);
+    stage0.setLowPass(fc/samplingRate, FilterStage::BUTTERWORTH_Q);
+    for(int n=1; n<numLowPassStages; n++){
+      FilterStage stage=filter->getFilterStage(n);
+      stage.setCoefficients(FloatArray(stage0.getCoefficients(), 5));
+    }
+  };
+  void setHighPassCutoff(float fc){
+    if(numHighPassStages<1)
+      return;
+    FilterStage stage0=filter->getFilterStage(numLowPassStages);
+    stage0.setHighPass(fc/samplingRate, FilterStage::BUTTERWORTH_Q);
+    for(int n=numLowPassStages+1; n<numHighPassStages+numLowPassStages; n++){
+      FilterStage stage=filter->getFilterStage(n);
+      stage.setCoefficients(stage0.getCoefficients());
+    }
+  };
+  void process(FloatArray input){
+    ASSERT(input.getSize()<=filterOutput.getSize(), "wrong size");
+    static float lastValue=0;
+    static int countsPointer=0;
+    static float period=0;
+    static float count;
+    filter->process(input, filterOutput);
+    // filterOutput.copyTo(input);
+    for(int n=0; n<input.getSize(); n++){
+      float currentValue=filterOutput[n];
+      if(currentValue>0 && lastValue<=0){
+        /*
+         counts[countsPointer]=count; //Could use nearest neighbour, but
+         count=0;
+        */
+         //linear interpolation gives a better estimate of the zero crossing time: 
+        float offset=(-lastValue)/(lastValue+currentValue);
+        counts[countsPointer]=count+offset;
+        count=-offset;
+        countsPointer++;
+        if(countsPointer==counts.getSize()) //use counts as a circular buffer
+          countsPointer=0;
+      }
+      lastValue=currentValue;
+      count++;
+    }
+  }
+
+  float getFrequency(){
+    return samplingRate/counts.getMean();
+  }
+  BiquadFilter* getFilter(){
+    return filter;
+  }
+};
+
+#endif /* __PitchDetectors_hpp__ */

TestPatches/PitchDetectorTestPatch.hpp

@@ -0,0 +1,72 @@
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/*
+ 
+ 
+ LICENSE:
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ 
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ 
+ */
+
+
+/* created by the OWL team 2013 */
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+#ifndef __PitchDetectorTestPatch_hpp__
+#define __PitchDetectorTestPatch_hpp__
+
+#include "StompBox.h"
+
+class PitchDetectorTestPatch : public Patch {
+public:
+  BiquadFilter *filter;
+  ZeroCrossingPitchDetector zcc;
+  PitchDetectorTestPatch() : zcc(getSampleRate(), getBlockSize()){
+    registerParameter(PARAMETER_A, "Mix");
+    registerParameter(PARAMETER_B, "HP cutoff");
+    registerParameter(PARAMETER_C, "LP cutoff");
+    registerParameter(PARAMETER_D, "gain");
+  }
+  void processAudio(AudioBuffer &buffer){
+    FloatArray fa=buffer.getSamples(0);
+    float mix=getParameterValue(PARAMETER_A);
+    zcc.setHighPassCutoff(getParameterValue(PARAMETER_B)*500+50);
+    zcc.setLowPassCutoff(getParameterValue(PARAMETER_C)*1000+150);
+    zcc.process(fa);
+    float estimated=zcc.getFrequency();
+    float envelope=fa.getRms();
+    fa.multiply(1-mix);
+    for(int n=0;n<fa.getSize(); n++){
+      static float phase=0;
+      static float pastEnvelope=0;
+      phase += 2.0 * M_PI * estimated/getSampleRate();
+      if(phase > 2.0 * M_PI)
+        phase -= 2.0 * M_PI;
+      if(phase > 4.0*M_PI)
+        phase=0;
+      envelope=0.001*envelope + pastEnvelope*0.999;
+      pastEnvelope=envelope;
+      fa[n]+=sin(phase)*mix*envelope;
+    }
+    fa.multiply(getParameterValue(PARAMETER_D));
+    float *coeffs=zcc.getFilter()->getFilterStage(0).getCoefficients();
+    debugMessage("estimated envelope: ", estimated, envelope);
+    // debugMessage("coeffs: ", coeffs[3], coeffs[4], coeffs[2] );
+  }
+};
+
+#endif // __PitchDetectorTestPatch_hpp__