Added VIbrato

Author: aure

Sources/CSoundpipeAudioKit/Effects/VibratoDSP.mm

@@ -0,0 +1,78 @@
+// Copyright AudioKit. All Rights Reserved.
+
+#include "SoundpipeDSPBase.h"
+#include "ParameterRamper.h"
+#include "Soundpipe.h"
+
+enum VibratoParameter : AUParameterAddress {
+    VibratoParameterSpeed,
+    VibratoParameterDepth
+};
+
+class VibratoDSP : public SoundpipeDSPBase {
+private:
+    sp_osc *vibrato;
+    sp_pshift *pshift;
+    sp_ftbl *sine;
+    ParameterRamper speedRamp;
+    ParameterRamper depthRamp;
+
+public:
+    VibratoDSP() {
+        parameters[VibratoParameterSpeed] = &speedRamp;
+        parameters[VibratoParameterDepth] = &depthRamp;
+    }
+
+    void init(int channelCount, double sampleRate) override {
+        SoundpipeDSPBase::init(channelCount, sampleRate);
+        
+        sp_ftbl_create(sp, &sine, 4096);
+        sp_gen_sine(sp, sine);
+        
+        sp_osc_create(&vibrato);
+        sp_osc_init(sp, vibrato, sine, 0);
+        
+        sp_pshift_create(&pshift);
+        sp_pshift_init(sp, pshift);
+    }
+
+    void deinit() override {
+        SoundpipeDSPBase::deinit();
+        sp_osc_destroy(&vibrato);
+        sp_pshift_destroy(&pshift);
+        sp_ftbl_destroy(&sine);
+    }
+
+    void reset() override {
+        SoundpipeDSPBase::reset();
+        if (!isInitialized) return;
+        sp_osc_init(sp, vibrato, sine, 0);
+    }
+
+    void process(FrameRange range) override {
+        float vibrato_out = 0;
+
+        for (int i : range) {
+            float speed = speedRamp.getAndStep();
+            float depth = depthRamp.getAndStep();
+            
+            vibrato->freq = speed;
+            sp_osc_compute(sp, vibrato, NULL, &vibrato_out);
+            *pshift->shift = vibrato_out * depth;
+            
+            float leftIn = inputSample(0, i);
+            float rightIn = inputSample(1, i);
+
+            float leftOut, rightOut;
+            sp_pshift_compute(sp, pshift, &leftIn, &leftOut);
+            sp_pshift_compute(sp, pshift, &rightIn, &rightOut);
+            
+            outputSample(0, i) = leftOut;
+            outputSample(1, i) = rightOut;
+        }
+    }
+};
+
+AK_REGISTER_DSP(VibratoDSP, "vbrt")
+AK_REGISTER_PARAMETER(VibratoParameterSpeed)
+AK_REGISTER_PARAMETER(VibratoParameterDepth)

Sources/Soundpipe/modules/Custom Soundpipe Modules/Yin.c

@@ -0,0 +1,229 @@
+#include <stdint.h> /* For standard interger types (int16_t) */
+#include <stdlib.h> /* For call to malloc */
+#include <math.h>
+#include "Yin.h"
+
+/* ------------------------------------------------------------------------------------------
+--------------------------------------------------------------------------- PRIVATE FUNCTIONS
+-------------------------------------------------------------------------------------------*/
+
+/**
+ * Step 1: Calculates the squared difference of the signal with a shifted version of itself.
+ * @param buffer Buffer of samples to process. 
+ *
+ * This is the Yin algorithms tweak on autocorellation. Read http://audition.ens.fr/adc/pdf/2002_JASA_YIN.pdf
+ * for more details on what is in here and why it's done this way.
+ */
+void Yin_difference(Yin *yin, int16_t* buffer){
+	int16_t i;
+	int16_t tau;
+	float delta;
+
+	/* Calculate the difference for difference shift values (tau) for the half of the samples */
+	for(tau = 0 ; tau < yin->halfBufferSize; tau++){
+
+		/* Take the difference of the signal with a shifted version of itself, then square it.
+		 * (This is the Yin algorithm's tweak on autocorellation) */ 
+		for(i = 0; i < yin->halfBufferSize; i++) {
+
+            if (isnan(yin->yinBuffer[tau])) {
+                yin->yinBuffer[tau] = 0.0f;
+            }
+
+			delta = buffer[i] - buffer[i + tau];
+			yin->yinBuffer[tau] += delta * delta;
+		}
+	}
+}
+
+
+/**
+ * Step 2: Calculate the cumulative mean on the normalised difference calculated in step 1
+ * @param yin #Yin structure with information about the signal
+ *
+ * This goes through the Yin autocorellation values and finds out roughly where shift is which 
+ * produced the smallest difference
+ */
+void Yin_cumulativeMeanNormalizedDifference(Yin *yin){
+	int16_t tau;
+	float runningSum = 0;
+	yin->yinBuffer[0] = 1;
+
+	/* Sum all the values in the autocorellation buffer and nomalise the result, replacing
+	 * the value in the autocorellation buffer with a cumulative mean of the normalised difference */
+	for (tau = 1; tau < yin->halfBufferSize; tau++) {
+		runningSum += yin->yinBuffer[tau];
+		yin->yinBuffer[tau] *= tau / runningSum;
+	}
+}
+
+/**
+ * Step 3: Search through the normalised cumulative mean array and find values that are over the threshold
+ * @return Shift (tau) which caused the best approximate autocorellation. -1 if no suitable value is found over the threshold.
+ */
+int16_t Yin_absoluteThreshold(Yin *yin){
+	int16_t tau;
+
+	/* Search through the array of cumulative mean values, and look for ones that are over the threshold 
+	 * The first two positions in yinBuffer are always so start at the third (index 2) */
+	for (tau = 2; tau < yin->halfBufferSize ; tau++) {
+		if (yin->yinBuffer[tau] < yin->threshold) {
+			while (tau + 1 < yin->halfBufferSize && yin->yinBuffer[tau + 1] < yin->yinBuffer[tau]) {
+				tau++;
+			}
+			/* found tau, exit loop and return
+			 * store the probability
+			 * From the YIN paper: The yin->threshold determines the list of
+			 * candidates admitted to the set, and can be interpreted as the
+			 * proportion of aperiodic power tolerated
+			 * within a periodic signal.
+			 *
+			 * Since we want the periodicity and and not aperiodicity:
+			 * periodicity = 1 - aperiodicity */
+			yin->probability = 1 - yin->yinBuffer[tau];
+			break;
+		}
+	}
+
+	/* if no pitch found, tau => -1 */
+	if (tau == yin->halfBufferSize || yin->yinBuffer[tau] >= yin->threshold) {
+		tau = -1;
+		yin->probability = 0;
+	}
+
+	return tau;
+}
+
+/**
+ * Step 5: Interpolate the shift value (tau) to improve the pitch estimate.
+ * @param  yin         [description]
+ * @param  tauEstimate [description]
+ * @return             [description]
+ *
+ * The 'best' shift value for autocorellation is most likely not an interger shift of the signal.
+ * As we only autocorellated using integer shifts we should check that there isn't a better fractional 
+ * shift value.
+ */
+float Yin_parabolicInterpolation(Yin *yin, int16_t tauEstimate) {
+	float betterTau;
+	int16_t x0;
+	int16_t x2;
+	
+	/* Calculate the first polynomial coeffcient based on the current estimate of tau */
+	if (tauEstimate < 1) {
+		x0 = tauEstimate;
+	} 
+	else {
+		x0 = tauEstimate - 1;
+	}
+
+	/* Calculate the second polynomial coeffcient based on the current estimate of tau */
+	if (tauEstimate + 1 < yin->halfBufferSize) {
+		x2 = tauEstimate + 1;
+	} 
+	else {
+		x2 = tauEstimate;
+	}
+
+	/* Algorithm to parabolically interpolate the shift value tau to find a better estimate */
+	if (x0 == tauEstimate) {
+		if (yin->yinBuffer[tauEstimate] <= yin->yinBuffer[x2]) {
+			betterTau = tauEstimate;
+		} 
+		else {
+			betterTau = x2;
+		}
+	} 
+	else if (x2 == tauEstimate) {
+		if (yin->yinBuffer[tauEstimate] <= yin->yinBuffer[x0]) {
+			betterTau = tauEstimate;
+		} 
+		else {
+			betterTau = x0;
+		}
+	} 
+	else {
+		float s0, s1, s2;
+		s0 = yin->yinBuffer[x0];
+		s1 = yin->yinBuffer[tauEstimate];
+		s2 = yin->yinBuffer[x2];
+		// fixed AUBIO implementation, thanks to Karl Helgason:
+		// (2.0f * s1 - s2 - s0) was incorrectly multiplied with -1
+		betterTau = tauEstimate + (s2 - s0) / (2 * (2 * s1 - s2 - s0));
+	}
+
+
+	return betterTau;
+}
+
+
+
+
+
+/* ------------------------------------------------------------------------------------------
+---------------------------------------------------------------------------- PUBLIC FUNCTIONS
+-------------------------------------------------------------------------------------------*/
+
+
+
+/**
+ * Initialise the Yin pitch detection object
+ * @param yin        Yin pitch detection object to initialise
+ * @param bufferSize Length of the audio buffer to analyse
+ * @param threshold  Allowed uncertainty (e.g 0.05 will return a pitch with ~95% probability)
+ */
+void Yin_init(Yin *yin, int16_t bufferSize, float threshold, int sampleRate) {
+	/* Initialise the fields of the Yin structure passed in */
+	yin->bufferSize = bufferSize;
+	yin->halfBufferSize = bufferSize / 2;
+	yin->probability = 0.0;
+	yin->threshold = threshold;
+    yin->sampleRate = (float)sampleRate / 8;
+
+	/* Allocate the autocorellation buffer and initialise it to zero */
+	yin->yinBuffer = (float *) malloc(sizeof(float)* yin->halfBufferSize);
+
+	int16_t i;
+	for(i = 0; i < yin->halfBufferSize; i++){
+		yin->yinBuffer[i] = 0;
+	}
+}
+
+/**
+ * Runs the Yin pitch detection algortihm
+ * @param  yin    Initialised Yin object
+ * @param  buffer Buffer of samples to analyse
+ * @return        Fundamental frequency of the signal in Hz. Returns -1 if pitch can't be found
+ */
+float Yin_getPitch(Yin *yin, int16_t* buffer) {
+	int16_t tauEstimate = -1;
+	float pitchInHertz = -1;
+	
+	/* Step 1: Calculates the squared difference of the signal with a shifted version of itself. */
+	Yin_difference(yin, buffer);
+	
+	/* Step 2: Calculate the cumulative mean on the normalised difference calculated in step 1 */
+	Yin_cumulativeMeanNormalizedDifference(yin);
+	
+	/* Step 3: Search through the normalised cumulative mean array and find values that are over the threshold */
+	tauEstimate = Yin_absoluteThreshold(yin);
+	
+	/* Step 5: Interpolate the shift value (tau) to improve the pitch estimate. */
+	if(tauEstimate != -1){
+		pitchInHertz = yin->sampleRate / Yin_parabolicInterpolation(yin, tauEstimate);
+	}
+	
+	return pitchInHertz;
+}
+
+/**
+ * Certainty of the pitch found 
+ * @param  yin Yin object that has been run over a buffer
+ * @return     Returns the certainty of the note found as a decimal (i.e 0.3 is 30%)
+ */
+float Yin_getProbability(Yin *yin){
+	return yin->probability;
+}
+
+
+

Sources/Soundpipe/modules/Custom Soundpipe Modules/Yin.h

@@ -0,0 +1,46 @@
+#ifndef Yin_h
+#define Yin_h
+
+#include <stdint.h>
+
+#define YIN_DEFAULT_THRESHOLD 0.15
+
+/**
+ * @struct  Yin
+ * @breif	Object to encapsulate the parameters for the Yin pitch detection algorithm 
+ */
+typedef struct _Yin {
+	int16_t bufferSize;			/**< Size of the audio buffer to be analysed */
+	int16_t halfBufferSize;		/**< Half the buffer length */
+	float* yinBuffer;		/**< Buffer that stores the results of the intermediate processing steps of the algorithm */
+	float probability;		/**< Probability that the pitch found is correct as a decimal (i.e 0.85 is 85%) */
+	float threshold;		/**< Allowed uncertainty in the result as a decimal (i.e 0.15 is 15%) */
+    float sampleRate;
+} Yin;
+
+/**
+ * Initialise the Yin pitch detection object
+ * @param yin        Yin pitch detection object to initialise
+ * @param bufferSize Length of the audio buffer to analyse
+ * @param threshold  Allowed uncertainty (e.g 0.05 will return a pitch with ~95% probability)
+ */
+void Yin_init(Yin *yin, int16_t bufferSize, float threshold, int sampleRate);
+
+/**
+ * Runs the Yin pitch detection algortihm
+ * @param  yin    Initialised Yin object
+ * @param  buffer Buffer of samples to analyse
+ * @return        Fundamental frequency of the signal in Hz. Returns -1 if pitch can't be found
+ */
+float Yin_getPitch(Yin *yin, int16_t* buffer);
+
+/**
+ * Certainty of the pitch found 
+ * @param  yin Yin object that has been run over a buffer
+ * @return     Returns the certainty of the note found as a decimal (i.e 0.3 is 30%)
+ */
+float Yin_getProbability(Yin *yin);
+	
+
+
+#endif