Added PitchCorrect

Author: aure

Sources/CSoundpipeAudioKit/Effects/PitchCorrectDSP.mm

@@ -0,0 +1,106 @@
+// Copyright AudioKit. All Rights Reserved.
+
+#include "SoundpipeDSPBase.h"
+#include "ParameterRamper.h"
+#include "Soundpipe.h"
+#include "autotune.h"
+
+enum PitchCorrectParameter : AUParameterAddress {
+    PitchCorrectParameterSpeed,
+    PitchCorrectParameterAmount
+};
+
+class PitchCorrectDSP : public SoundpipeDSPBase {
+private:
+    sp_rms *rms_l;
+    sp_rms *rms_r;
+    autotune *autotune_l;
+    autotune *autotune_r;
+    ParameterRamper speedRamp;
+    ParameterRamper amountRamp;
+
+public:
+    PitchCorrectDSP() {
+        parameters[PitchCorrectParameterSpeed] = &speedRamp;
+        parameters[PitchCorrectParameterAmount] = &amountRamp;
+    }
+
+    void init(int channelCount, double sampleRate) override {
+        SoundpipeDSPBase::init(channelCount, sampleRate);
+        sp_rms_create(&rms_l);
+        sp_rms_init(sp, rms_l);
+        sp_rms_create(&rms_r);
+        sp_rms_init(sp, rms_r);
+        autotune_create(&autotune_l);
+        autotune_init(sp, autotune_l);
+        autotune_create(&autotune_r);
+        autotune_init(sp, autotune_r);
+        
+        // Create chromatic scale from A220 to A440
+        float scale[13] = {
+            220.0,  // A
+            233.08, // A#/Bb
+            246.94, // B
+            261.63, // C
+            277.18, // C#/Db
+            293.66, // D
+            311.13, // D#/Eb
+            329.63, // E
+            349.23, // F
+            369.99, // F#/Gb
+            392.00, // G
+            415.30, // G#/Ab
+            440.00  // A
+        };
+        
+        autotune_set_scale_freqs(autotune_l, scale, 13);
+        autotune_set_scale_freqs(autotune_r, scale, 13);
+    }
+
+    void deinit() override {
+        SoundpipeDSPBase::deinit();
+        sp_rms_destroy(&rms_l);
+        sp_rms_destroy(&rms_r);
+    }
+
+    void reset() override {
+        SoundpipeDSPBase::reset();
+        if (!isInitialized) return;
+        sp_rms_init(sp, rms_l);
+        sp_rms_init(sp, rms_r);
+    }
+
+    void process(FrameRange range) override {
+        for (int i : range) {
+            float speed = speedRamp.getAndStep();
+            float amount = amountRamp.getAndStep();
+
+            float leftIn = inputSample(0, i);
+            float rightIn = inputSample(1, i);
+            
+            float rms_l_out = 0;
+            float rms_r_out = 0;
+            
+            float leftOut = 0, rightOut = 0;
+            
+            autotune_set_speed(autotune_l, speed);
+            autotune_set_amount(autotune_l, amount);
+
+            autotune_set_speed(autotune_r, speed);
+            autotune_set_amount(autotune_r, amount);
+        
+            sp_rms_compute(sp, rms_l, &leftIn, &rms_l_out);
+            autotune_compute(sp, autotune_l, &leftIn, &leftOut, rms_l_out);
+            
+            sp_rms_compute(sp, rms_r, &rightIn, &rms_r_out);
+            autotune_compute(sp, autotune_r, &rightIn, &rightOut, rms_r_out);
+            
+            outputSample(0, i) = leftOut;
+            outputSample(1, i) = rightOut;
+        }
+    }
+};
+
+AK_REGISTER_DSP(PitchCorrectDSP, "pcrt")
+AK_REGISTER_PARAMETER(PitchCorrectParameterSpeed)
+AK_REGISTER_PARAMETER(PitchCorrectParameterAmount)

Sources/Soundpipe/include/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

Sources/Soundpipe/include/arp.h

@@ -0,0 +1,21 @@
+#ifndef arp_h
+#define arp_h
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#include "soundpipe.h"
+#include "pitchshift.h"
+
+typedef struct {
+    sp_delay *dels;
+    sp_pshift *pshifts;
+    int num_steps;
+} arp;
+
+int arp_create(arp **p);
+int arp_init(sp_data *sp, arp *p);
+int arp_compute(sp_data *sp, arp *p, float *in, float autotune_freq, float *out);
+
+#endif /* arp_h */

Sources/Soundpipe/include/autotune.h

@@ -0,0 +1,63 @@
+#ifndef autotune_h
+#define autotune_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include "soundpipe.h"
+#include "Yin.h"
+#include "circular_buffer.h"
+#include "pitchshift.h"
+#include "pitchshift2.h"
+#include "pitchcalculate.h"
+
+typedef struct {
+    pitchcalculate *pcalc;
+    pitchshift2 *pshift2;
+    Yin *yin;
+    circular_buffer *buff;
+    sp_butlp *lpf;
+    sp_port *scale_freq_port;
+    int16_t *intBuffer;
+    int yin_downsample_acc;
+    bool correction_mode_active;
+    float detected_freq;
+    float cur_correction_amt_cents;
+    float base_freq;
+    float target_freq;
+    float pshift_freq_ratio;
+    float cur_freq_ratio;
+    int scale_freq_index_acc;
+    int unknown_freq_acc;
+    float nearest_scale_freq_index;
+    float nearest_scale_freq;
+    float amount;
+    float speed;
+    bool should_smooth_scale_idx;
+    bool should_smooth_target_freq;
+
+    bool should_update_scale_freqs;
+    float *autotune_scale_freqs;
+    int autotune_scale_freqs_count;
+    float *tmp_scale_freqs;
+    int tmp_scale_freqs_count;
+} autotune;
+
+int autotune_create(autotune **p);
+int autotune_init(sp_data *sp, autotune *p);
+int autotune_compute(sp_data *sp, autotune *p, float *in, float *out, float rms);
+int autotune_set_scale_freqs(autotune *p, float *frequencies, int count);
+int autotune_set_amount(autotune *p, float amount);
+int autotune_set_speed(autotune *p, float speed);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* autotune_h */
+

Sources/Soundpipe/include/circular_buffer.h

@@ -0,0 +1,25 @@
+#ifndef circular_buffer_h
+#define circular_buffer_h
+
+#include <stdio.h>
+
+typedef struct circular_buffer {
+    void *buffer;     // data buffer
+    void *buffer_end; // end of data buffer
+    size_t capacity;  // maximum number of items in the buffer
+    size_t count;     // number of items in the buffer
+    size_t writePos;  // the write position
+    size_t readPos;   // the read position
+    size_t sz;        // size of each item in the buffer
+    void *head;       // pointer to head
+    void *tail;       // pointer to tail
+} circular_buffer;
+
+void cb_init(circular_buffer *cb, size_t capacity, size_t sz);
+void cb_free(circular_buffer *cb);
+void cb_push_back(circular_buffer *cb, const void *item);
+void cb_read_at_index_behind_write(circular_buffer *cb, int idx, void **value);
+void cb_pop_front(circular_buffer *cb, void *item);
+void cb_pop_multiple(circular_buffer *cb, int16_t *itemArray, int count, int moveReadheadBy);
+
+#endif /* circular_buffer_h */

Sources/Soundpipe/include/equalizer.h

@@ -0,0 +1,21 @@
+#ifndef equalizer_h
+#define equalizer_h
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#include "soundpipe.h"
+
+typedef struct equalizer {
+    sp_eqfil *eq1;
+    sp_eqfil *eq2;
+    sp_eqfil *eq3;
+    sp_eqfil *eq4;
+} equalizer;
+
+int equalizer_create(equalizer **eq);
+int equalizer_init(sp_data *sp, equalizer *eq);
+int equalizer_compute(sp_data *sp, equalizer *eq, float *in, float *out);
+
+#endif /* equalizer_h */

Sources/Soundpipe/include/harmonizer.h

@@ -0,0 +1,26 @@
+#ifndef harmonizer_h
+#define harmonizer_h
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#include "soundpipe.h"
+#include "pitchshift.h"
+
+typedef struct {
+    smbpitchshift *pshift1;
+    smbpitchshift *pshift2;
+    smbpitchshift *pshift3;
+    smbpitchshift *pshift4;
+    int scale_freq_index;
+    int num_harmonies;
+    int mode;
+} harmonizer;
+
+int harmonizer_create(harmonizer **p);
+int harmonizer_init(sp_data *sp, harmonizer *p);
+int harmonizer_set_scale_freqs(float *frequencies, int count);
+int harmonizer_compute(sp_data *sp, harmonizer *p, float *in, int scale_freq_index, float *out);
+
+#endif /* harmonizer_h */

Sources/Soundpipe/include/interpolate.h

@@ -0,0 +1,82 @@
+#ifndef interpolate_h
+#define interpolate_h
+
+#include <math.h>
+
+// This functions finds the determinant of Matrix
+double determinantOfMatrix(double mat[3][3]) {
+    double ans;
+    ans = mat[0][0] * (mat[1][1] * mat[2][2] - mat[2][1] * mat[1][2])
+          - mat[0][1] * (mat[1][0] * mat[2][2] - mat[1][2] * mat[2][0])
+          + mat[0][2] * (mat[1][0] * mat[2][1] - mat[1][1] * mat[2][0]);
+    return ans;
+}
+
+// This function finds the solution of system of
+// linear equations using cramer's rule
+void findSolution(double coeff[3][4], double solution[3]) {
+    // Matrix d using coeff as given in cramer's rule
+    double d[3][3] = {
+        { coeff[0][0], coeff[0][1], coeff[0][2] },
+        { coeff[1][0], coeff[1][1], coeff[1][2] },
+        { coeff[2][0], coeff[2][1], coeff[2][2] },
+    };
+    // Matrix d1 using coeff as given in cramer's rule
+    double d1[3][3] = {
+        { coeff[0][3], coeff[0][1], coeff[0][2] },
+        { coeff[1][3], coeff[1][1], coeff[1][2] },
+        { coeff[2][3], coeff[2][1], coeff[2][2] },
+    };
+    // Matrix d2 using coeff as given in cramer's rule
+    double d2[3][3] = {
+        { coeff[0][0], coeff[0][3], coeff[0][2] },
+        { coeff[1][0], coeff[1][3], coeff[1][2] },
+        { coeff[2][0], coeff[2][3], coeff[2][2] },
+    };
+    // Matrix d3 using coeff as given in cramer's rule
+    double d3[3][3] = {
+        { coeff[0][0], coeff[0][1], coeff[0][3] },
+        { coeff[1][0], coeff[1][1], coeff[1][3] },
+        { coeff[2][0], coeff[2][1], coeff[2][3] },
+    };
+
+    // Calculating Determinant of Matrices d, d1, d2, d3
+    double D = determinantOfMatrix(d);
+    double D1 = determinantOfMatrix(d1);
+    double D2 = determinantOfMatrix(d2);
+    double D3 = determinantOfMatrix(d3);
+
+    // Case 1
+    if (D != 0) {
+        // Coeff have a unique solution. Apply Cramer's Rule
+        double x = D1 / D;
+        double y = D2 / D;
+        double z = D3 / D;
+        solution[0] = x;
+        solution[1] = y;
+        solution[2] = z;
+    }
+    // Case 2
+    else {
+        if (D1 == 0 && D2 == 0 && D3 == 0)
+            printf("Infinite solutions\n");
+        else if (D1 != 0 || D2 != 0 || D3 != 0)
+            printf("No solutions\n");
+    }
+}
+
+void interpolate_min(float off1, float val1, float off2, float val2, float off3, float val3, float *min_out) {
+    double coeff[3][4] = {
+        { powf(off1, 2), off1, 1, val1 },
+        { powf(off2, 2), off2, 1, val2 },
+        { powf(off3, 2), off3, 1, val3 },
+    };
+
+    double solution[3] = { 0, 0, 0 };
+
+    findSolution(coeff, solution);
+
+    *min_out = (-1 * solution[1]) / (2 * solution[0]); // minimum of quadratic function (-b / 2a)
+}
+
+#endif /* interpolate_h */