initial commit

* combine all source files into this monorepo

* convert all third-party source packages into submodules

* small fixes due to changes in latest third-part packages

7 files changed, 685 insertions, 0 deletions

diff --git a/gui/examples/1_convolve_simple.cpp b/gui/examples/1_convolve_simple.cpp
new file mode 100644
index 0000000..95877f1
--- /dev/null
+++ b/gui/examples/1_convolve_simple.cpp
@@ -0,0 +1,30 @@
+/**
+ * 1_convolve_simple.cpp
+ * Written by Clyne Sullivan.
+ *
+ * Computes a convolution in the simplest way possible. While the code is brief, it lacks many
+ * possible optimizations. The convolution's result will not fill the output buffer either, as the
+ * transient response is not calculated.
+ */
+
+Sample* process_data(Samples samples)
+{
+    // Define our output buffer.
+    static Samples buffer;
+
+    // Define our filter
+    constexpr unsigned int filter_size = 3;
+	float filter[filter_size] = {
+        0.3333, 0.3333, 0.3333
+    };
+
+    // Begin convolving:
+    // SIZE is the size of the sample buffer.
+    for (int n = 0; n < SIZE - (filter_size - 1); n++) {
+        buffer[n] = 0;
+        for (int k = 0; k < filter_size; k++)
+            buffer[n] += samples[n + k] * filter[k];
+    }
+
+    return buffer;
+}
diff --git a/gui/examples/2_convolve_overlap_save.cpp b/gui/examples/2_convolve_overlap_save.cpp
new file mode 100644
index 0000000..5651f3e
--- /dev/null
+++ b/gui/examples/2_convolve_overlap_save.cpp
@@ -0,0 +1,47 @@
+/**
+ * 2_convolve_overlap_save.cpp
+ * Written by Clyne Sullivan.
+ *
+ * This convolution examples takes an overlap-save approach, where samples from the previous run
+ * are saved so that the overall operation is not interrupted (i.e. the observed output will
+ * transition smoothly between processed "chunks").
+ *
+ * Note that there are still improvements that can be made to the code; for example, notice every
+ * spot where an integer/float conversion is necessary. Operations like these may slow down the
+ * computation.
+ */
+
+Sample* process_data(Samples samples)
+{
+    static Samples buffer;
+
+    constexpr unsigned int filter_size = 3;
+	float filter[filter_size] = {
+        0.3333, 0.3333, 0.3333
+    };
+
+    // Keep a buffer of extra samples for overlap-save
+    static Sample prev[filter_size];
+
+    for (int n = 0; n < SIZE; n++) {
+        buffer[n] = 0;
+
+        for (int k = 0; k < filter_size; k++) {
+            int i = n - (filter_size - 1) + k;
+
+            // If i is >= 0, access current sample buffer.
+            // If i is < 0, provide the previous samples from the 'prev' buffer
+            if (i >= 0)
+                buffer[n] += samples[i] * filter[k];
+            else
+                buffer[n] += prev[filter_size - 1 + i] * filter[k];
+        }
+    }
+
+    // Save samples for the next convolution run
+    for (int i = 0; i < filter_size; i++)
+        prev[i] = samples[SIZE - filter_size + i];
+
+    return buffer;
+}
+
diff --git a/gui/examples/3_fir.cpp b/gui/examples/3_fir.cpp
new file mode 100644
index 0000000..b6d8751
--- /dev/null
+++ b/gui/examples/3_fir.cpp
@@ -0,0 +1,47 @@
+/**
+ * 3_fir.cpp
+ * Written by Clyne Sullivan.
+ *
+ * The below code was written for applying FIR filters. While this is still essentially an overlap-
+ * save convolution, other optimizations have been made to allow for larger filters to be applied
+ * within the available execution time. Samples are also normalized so that they center around zero.
+ */
+
+Sample* process_data(Samples samples)
+{
+    static Samples buffer;
+
+	// Define the filter:
+	constexpr unsigned int filter_size = 3;
+	static float filter[filter_size] = {
+        // Put filter values here (note: precision will be truncated for 'float' size).
+        0.3333, 0.3333, 0.3333
+	};
+
+    // Do an overlap-save convolution
+    static Sample prev[filter_size];
+
+    for (int n = 0; n < SIZE; n++) {
+        // Using a float variable for accumulation allows for better code optimization
+        float v = 0;
+
+        for (int k = 0; k < filter_size; k++) {
+            int i = n - (filter_size - 1) + k;
+
+            auto s = i >= 0 ? samples[i] : prev[filter_size - 1 + i];
+			// Sample values are 0 to 4095. Below, the original sample is normalized to a -1.0 to
+            // 1.0 range for calculation.
+            v += (s / 2048.f - 1) * filter[k];
+        }
+
+        // Return value to sample range of 0-4095.
+        buffer[n] = (v + 1) * 2048.f;
+    }
+
+    // Save samples for next convolution
+    for (int i = 0; i < filter_size; i++)
+        prev[i] = samples[SIZE - filter_size + i];
+
+    return buffer;
+}
+
diff --git a/gui/examples/4_fir_pro.cpp b/gui/examples/4_fir_pro.cpp
new file mode 100644
index 0000000..1771cd5
--- /dev/null
+++ b/gui/examples/4_fir_pro.cpp
@@ -0,0 +1,478 @@
+#include <cstdint>
+using float32_t = float;
+
+typedef struct
+{
+    uint16_t numTaps;     /**< number of filter coefficients in the filter. */
+    float32_t *pState;    /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+    float32_t *pCoeffs;   /**< points to the coefficient array. The array is of length numTaps. */
+} arm_fir_instance_f32;
+
+static void arm_fir_f32(const arm_fir_instance_f32 * S, float32_t * pSrc, float32_t * pDst, uint32_t blockSize);
+
+Sample* process_data(Samples samples)
+{
+	// 1. Define our array sizes (Be sure to set Run > Set buffer size... to below value!)
+	constexpr unsigned int buffer_size = 500;
+	constexpr unsigned int filter_size = 100;
+
+	// 2. Define our filter and the working arrays
+	static float filter[filter_size] = {
+		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
+		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
+		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
+		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
+		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
+		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
+		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
+		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
+		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
+		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f
+	};
+	static float input[buffer_size];
+	static float output[buffer_size];
+	static float working[buffer_size + filter_size];
+
+	// 3. Scale 0-4095 interger sample values to +/- 1.0 floats
+	for (unsigned int i = 0; i < SIZE; i++)
+		input[i] = (samples[i] - 2048) / 2048.f;
+
+	// 4. Compute the FIR
+	arm_fir_instance_f32 fir { filter_size, working, filter };
+	arm_fir_f32(&fir, input, output, SIZE);
+
+	// 5. Convert float results back to 0-4095 range for output
+	for (unsigned int i = 0; i < SIZE; i++)
+		samples[i] = output[i] * 2048.f + 2048;
+
+    return samples;
+}
+
+// Below taken from the CMSIS DSP Library (find it on GitHub)
+void arm_fir_f32(
+	const arm_fir_instance_f32 * S,
+	float32_t * pSrc,
+	float32_t * pDst,
+	uint32_t blockSize)
+{
+   float32_t *pState = S->pState;                 /* State pointer */
+   float32_t *pCoeffs = S->pCoeffs;               /* Coefficient pointer */
+   float32_t *pStateCurnt;                        /* Points to the current sample of the state */
+   float32_t *px, *pb;                            /* Temporary pointers for state and coefficient buffers */
+   float32_t acc0, acc1, acc2, acc3, acc4, acc5, acc6, acc7;     /* Accumulators */
+   float32_t x0, x1, x2, x3, x4, x5, x6, x7, c0;  /* Temporary variables to hold state and coefficient values */
+   uint32_t numTaps = S->numTaps;                 /* Number of filter coefficients in the filter */
+   uint32_t i, tapCnt, blkCnt;                    /* Loop counters */
+   float32_t p0,p1,p2,p3,p4,p5,p6,p7;             /* Temporary product values */
+
+   /* S->pState points to state array which contains previous frame (numTaps - 1) samples */
+   /* pStateCurnt points to the location where the new input data should be written */
+   pStateCurnt = &(S->pState[(numTaps - 1u)]);
+
+   /* Apply loop unrolling and compute 8 output values simultaneously.  
+    * The variables acc0 ... acc7 hold output values that are being computed:  
+    *  
+    *    acc0 =  b[numTaps-1] * x[n-numTaps-1] + b[numTaps-2] * x[n-numTaps-2] + b[numTaps-3] * x[n-numTaps-3] +...+ b[0] * x[0]  
+    *    acc1 =  b[numTaps-1] * x[n-numTaps] +   b[numTaps-2] * x[n-numTaps-1] + b[numTaps-3] * x[n-numTaps-2] +...+ b[0] * x[1]  
+    *    acc2 =  b[numTaps-1] * x[n-numTaps+1] + b[numTaps-2] * x[n-numTaps] +   b[numTaps-3] * x[n-numTaps-1] +...+ b[0] * x[2]  
+    *    acc3 =  b[numTaps-1] * x[n-numTaps+2] + b[numTaps-2] * x[n-numTaps+1] + b[numTaps-3] * x[n-numTaps]   +...+ b[0] * x[3]  
+    */
+   blkCnt = blockSize >> 3;
+
+   /* First part of the processing with loop unrolling.  Compute 8 outputs at a time.  
+   ** a second loop below computes the remaining 1 to 7 samples. */
+   while(blkCnt > 0u)
+   {
+      /* Copy four new input samples into the state buffer */
+      *pStateCurnt++ = *pSrc++;
+      *pStateCurnt++ = *pSrc++;
+      *pStateCurnt++ = *pSrc++;
+      *pStateCurnt++ = *pSrc++;
+
+      /* Set all accumulators to zero */
+      acc0 = 0.0f;
+      acc1 = 0.0f;
+      acc2 = 0.0f;
+      acc3 = 0.0f;
+      acc4 = 0.0f;
+      acc5 = 0.0f;
+      acc6 = 0.0f;
+      acc7 = 0.0f;		
+
+      /* Initialize state pointer */
+      px = pState;
+
+      /* Initialize coeff pointer */
+      pb = (pCoeffs);		
+   
+      /* This is separated from the others to avoid 
+       * a call to __aeabi_memmove which would be slower
+       */
+      *pStateCurnt++ = *pSrc++;
+      *pStateCurnt++ = *pSrc++;
+      *pStateCurnt++ = *pSrc++;
+      *pStateCurnt++ = *pSrc++;
+
+      /* Read the first seven samples from the state buffer:  x[n-numTaps], x[n-numTaps-1], x[n-numTaps-2] */
+      x0 = *px++;
+      x1 = *px++;
+      x2 = *px++;
+      x3 = *px++;
+      x4 = *px++;
+      x5 = *px++;
+      x6 = *px++;
+
+      /* Loop unrolling.  Process 8 taps at a time. */
+      tapCnt = numTaps >> 3u;
+      
+      /* Loop over the number of taps.  Unroll by a factor of 8.  
+       ** Repeat until we've computed numTaps-8 coefficients. */
+      while(tapCnt > 0u)
+      {
+         /* Read the b[numTaps-1] coefficient */
+         c0 = *(pb++);
+
+         /* Read x[n-numTaps-3] sample */
+         x7 = *(px++);
+
+         /* acc0 +=  b[numTaps-1] * x[n-numTaps] */
+         p0 = x0 * c0;
+
+         /* acc1 +=  b[numTaps-1] * x[n-numTaps-1] */
+         p1 = x1 * c0;
+
+         /* acc2 +=  b[numTaps-1] * x[n-numTaps-2] */
+         p2 = x2 * c0;
+
+         /* acc3 +=  b[numTaps-1] * x[n-numTaps-3] */
+         p3 = x3 * c0;
+
+         /* acc4 +=  b[numTaps-1] * x[n-numTaps-4] */
+         p4 = x4 * c0;
+
+         /* acc1 +=  b[numTaps-1] * x[n-numTaps-5] */
+         p5 = x5 * c0;
+
+         /* acc2 +=  b[numTaps-1] * x[n-numTaps-6] */
+         p6 = x6 * c0;
+
+         /* acc3 +=  b[numTaps-1] * x[n-numTaps-7] */
+         p7 = x7 * c0;
+         
+         /* Read the b[numTaps-2] coefficient */
+         c0 = *(pb++);
+
+         /* Read x[n-numTaps-4] sample */
+         x0 = *(px++);
+         
+         acc0 += p0;
+         acc1 += p1;
+         acc2 += p2;
+         acc3 += p3;
+         acc4 += p4;
+         acc5 += p5;
+         acc6 += p6;
+         acc7 += p7;
+
+
+         /* Perform the multiply-accumulate */
+         p0 = x1 * c0;
+         p1 = x2 * c0;   
+         p2 = x3 * c0;   
+         p3 = x4 * c0;   
+         p4 = x5 * c0;   
+         p5 = x6 * c0;   
+         p6 = x7 * c0;   
+         p7 = x0 * c0;   
+         
+         /* Read the b[numTaps-3] coefficient */
+         c0 = *(pb++);
+
+         /* Read x[n-numTaps-5] sample */
+         x1 = *(px++);
+         
+         acc0 += p0;
+         acc1 += p1;
+         acc2 += p2;
+         acc3 += p3;
+         acc4 += p4;
+         acc5 += p5;
+         acc6 += p6;
+         acc7 += p7;
+
+         /* Perform the multiply-accumulates */      
+         p0 = x2 * c0;
+         p1 = x3 * c0;   
+         p2 = x4 * c0;   
+         p3 = x5 * c0;   
+         p4 = x6 * c0;   
+         p5 = x7 * c0;   
+         p6 = x0 * c0;   
+         p7 = x1 * c0;   
+
+         /* Read the b[numTaps-4] coefficient */
+         c0 = *(pb++);
+
+         /* Read x[n-numTaps-6] sample */
+         x2 = *(px++);
+         
+         acc0 += p0;
+         acc1 += p1;
+         acc2 += p2;
+         acc3 += p3;
+         acc4 += p4;
+         acc5 += p5;
+         acc6 += p6;
+         acc7 += p7;
+
+         /* Perform the multiply-accumulates */      
+         p0 = x3 * c0;
+         p1 = x4 * c0;   
+         p2 = x5 * c0;   
+         p3 = x6 * c0;   
+         p4 = x7 * c0;   
+         p5 = x0 * c0;   
+         p6 = x1 * c0;   
+         p7 = x2 * c0;   
+
+         /* Read the b[numTaps-4] coefficient */
+         c0 = *(pb++);
+
+         /* Read x[n-numTaps-6] sample */
+         x3 = *(px++);
+         
+         acc0 += p0;
+         acc1 += p1;
+         acc2 += p2;
+         acc3 += p3;
+         acc4 += p4;
+         acc5 += p5;
+         acc6 += p6;
+         acc7 += p7;
+
+         /* Perform the multiply-accumulates */      
+         p0 = x4 * c0;
+         p1 = x5 * c0;   
+         p2 = x6 * c0;   
+         p3 = x7 * c0;   
+         p4 = x0 * c0;   
+         p5 = x1 * c0;   
+         p6 = x2 * c0;   
+         p7 = x3 * c0;   
+
+         /* Read the b[numTaps-4] coefficient */
+         c0 = *(pb++);
+
+         /* Read x[n-numTaps-6] sample */
+         x4 = *(px++);
+         
+         acc0 += p0;
+         acc1 += p1;
+         acc2 += p2;
+         acc3 += p3;
+         acc4 += p4;
+         acc5 += p5;
+         acc6 += p6;
+         acc7 += p7;
+
+         /* Perform the multiply-accumulates */      
+         p0 = x5 * c0;
+         p1 = x6 * c0;   
+         p2 = x7 * c0;   
+         p3 = x0 * c0;   
+         p4 = x1 * c0;   
+         p5 = x2 * c0;   
+         p6 = x3 * c0;   
+         p7 = x4 * c0;   
+
+         /* Read the b[numTaps-4] coefficient */
+         c0 = *(pb++);
+
+         /* Read x[n-numTaps-6] sample */
+         x5 = *(px++);
+         
+         acc0 += p0;
+         acc1 += p1;
+         acc2 += p2;
+         acc3 += p3;
+         acc4 += p4;
+         acc5 += p5;
+         acc6 += p6;
+         acc7 += p7;
+
+         /* Perform the multiply-accumulates */      
+         p0 = x6 * c0;
+         p1 = x7 * c0;   
+         p2 = x0 * c0;   
+         p3 = x1 * c0;   
+         p4 = x2 * c0;   
+         p5 = x3 * c0;   
+         p6 = x4 * c0;   
+         p7 = x5 * c0;   
+
+         /* Read the b[numTaps-4] coefficient */
+         c0 = *(pb++);
+
+         /* Read x[n-numTaps-6] sample */
+         x6 = *(px++);
+         
+         acc0 += p0;
+         acc1 += p1;
+         acc2 += p2;
+         acc3 += p3;
+         acc4 += p4;
+         acc5 += p5;
+         acc6 += p6;
+         acc7 += p7;
+
+         /* Perform the multiply-accumulates */      
+         p0 = x7 * c0;
+         p1 = x0 * c0;   
+         p2 = x1 * c0;   
+         p3 = x2 * c0;   
+         p4 = x3 * c0;   
+         p5 = x4 * c0;   
+         p6 = x5 * c0;   
+         p7 = x6 * c0;   
+
+         tapCnt--;
+         
+         acc0 += p0;
+         acc1 += p1;
+         acc2 += p2;
+         acc3 += p3;
+         acc4 += p4;
+         acc5 += p5;
+         acc6 += p6;
+         acc7 += p7;
+      }
+
+      /* If the filter length is not a multiple of 8, compute the remaining filter taps */
+      tapCnt = numTaps % 0x8u;
+
+      while(tapCnt > 0u)
+      {
+         /* Read coefficients */
+         c0 = *(pb++);
+
+         /* Fetch 1 state variable */
+         x7 = *(px++);
+
+         /* Perform the multiply-accumulates */      
+         p0 = x0 * c0;
+         p1 = x1 * c0;   
+         p2 = x2 * c0;   
+         p3 = x3 * c0;   
+         p4 = x4 * c0;   
+         p5 = x5 * c0;   
+         p6 = x6 * c0;   
+         p7 = x7 * c0;   
+
+         /* Reuse the present sample states for next sample */
+         x0 = x1;
+         x1 = x2;
+         x2 = x3;
+         x3 = x4;
+         x4 = x5;
+         x5 = x6;
+         x6 = x7;
+         
+         acc0 += p0;
+         acc1 += p1;
+         acc2 += p2;
+         acc3 += p3;
+         acc4 += p4;
+         acc5 += p5;
+         acc6 += p6;
+         acc7 += p7;
+
+         /* Decrement the loop counter */
+         tapCnt--;
+      }
+
+      /* Advance the state pointer by 8 to process the next group of 8 samples */
+      pState = pState + 8;
+
+      /* The results in the 8 accumulators, store in the destination buffer. */
+      *pDst++ = acc0;
+      *pDst++ = acc1;
+      *pDst++ = acc2;
+      *pDst++ = acc3;
+      *pDst++ = acc4;
+      *pDst++ = acc5;
+      *pDst++ = acc6;
+      *pDst++ = acc7;
+
+      blkCnt--;
+   }
+
+   /* If the blockSize is not a multiple of 8, compute any remaining output samples here.  
+   ** No loop unrolling is used. */
+   blkCnt = blockSize % 0x8u;
+
+   while(blkCnt > 0u)
+   {
+      /* Copy one sample at a time into state buffer */
+      *pStateCurnt++ = *pSrc++;
+
+      /* Set the accumulator to zero */
+      acc0 = 0.0f;
+
+      /* Initialize state pointer */
+      px = pState;
+
+      /* Initialize Coefficient pointer */
+      pb = (pCoeffs);
+
+      i = numTaps;
+
+      /* Perform the multiply-accumulates */
+      do
+      {
+         acc0 += *px++ * *pb++;
+         i--;
+
+      } while(i > 0u);
+
+      /* The result is store in the destination buffer. */
+      *pDst++ = acc0;
+
+      /* Advance state pointer by 1 for the next sample */
+      pState = pState + 1;
+
+      blkCnt--;
+   }
+
+   /* Processing is complete.  
+   ** Now copy the last numTaps - 1 samples to the start of the state buffer.  
+   ** This prepares the state buffer for the next function call. */
+
+   /* Points to the start of the state buffer */
+   pStateCurnt = S->pState;
+
+   tapCnt = (numTaps - 1u) >> 2u;
+
+   /* copy data */
+   while(tapCnt > 0u)
+   {
+      *pStateCurnt++ = *pState++;
+      *pStateCurnt++ = *pState++;
+      *pStateCurnt++ = *pState++;
+      *pStateCurnt++ = *pState++;
+
+      /* Decrement the loop counter */
+      tapCnt--;
+   }
+
+   /* Calculate remaining number of copies */
+   tapCnt = (numTaps - 1u) % 0x4u;
+
+   /* Copy the remaining q31_t data */
+   while(tapCnt > 0u)
+   {
+      *pStateCurnt++ = *pState++;
+
+      /* Decrement the loop counter */
+      tapCnt--;
+   }
+}
diff --git a/gui/examples/5_fir_differentiator.cpp b/gui/examples/5_fir_differentiator.cpp
new file mode 100644
index 0000000..1500dee
--- /dev/null
+++ b/gui/examples/5_fir_differentiator.cpp
@@ -0,0 +1,30 @@
+/**
+ * 5_fir_differentiator.cpp
+ * Written by Clyne Sullivan.
+ *
+ * Does an FIR differentiation on the incoming signal, so that the output is representative of the
+ * rate of change of the input.
+ * A scaling factor is applied so that the output's form is more clearly visible.
+ */
+
+Sample* process_data(Samples samples)
+{
+    constexpr int scaling_factor = 4;
+    static Samples output;
+    static Sample prev = 2048;
+
+    // Compute the first output value using the saved sample.
+    output[0] = 2048 + ((samples[0] - prev) * scaling_factor);
+
+	for (unsigned int i = 1; i < SIZE; i++) {
+        // Take the rate of change and scale it.
+        // 2048 is added as the output should be centered in the voltage range.
+		output[i] = 2048 + ((samples[i] - samples[i - 1]) * scaling_factor);
+    }
+
+	// Save the last sample for the next iteration.
+    prev = samples[SIZE - 1];
+
+    return output;
+}
+
diff --git a/gui/examples/6_iir_test.cpp b/gui/examples/6_iir_test.cpp
new file mode 100644
index 0000000..e0b266d
--- /dev/null
+++ b/gui/examples/6_iir_test.cpp
@@ -0,0 +1,23 @@
+/**
+ * 6_iir_test.cpp
+ * Written by Clyne Sullivan.
+ *
+ * Implements a simple infinite impulse response (IIR) filter using an alpha
+ * parameter.
+ * To build upon this example, try setting `alpha` with a parameter knob:
+ * alpha = param1() / 4095.0
+ */
+
+Sample* process_data(Samples samples)
+{
+	constexpr float alpha = 0.7;
+
+	static Sample prev = 2048;
+
+	samples[0] = (1 - alpha) * samples[0] + alpha * prev;
+	for (unsigned int i = 1; i < SIZE; i++)
+		samples[i] = (1 - alpha) * samples[i] + alpha * samples[i - 1];
+	prev = samples[SIZE - 1];
+
+	return samples;
+}
diff --git a/gui/examples/7_iir_echo.cpp b/gui/examples/7_iir_echo.cpp
new file mode 100644
index 0000000..75bf56e
--- /dev/null
+++ b/gui/examples/7_iir_echo.cpp
@@ -0,0 +1,30 @@
+/**
+ * 7_iir_echo.cpp
+ * Written by Clyne Sullivan.
+ *
+ * This filter produces an echo of the given input. There are two parameters:
+ * alpha controls the feedback gain, and D controls the echo/delay length.
+ */
+
+Sample* process_data(Samples samples)
+{
+	constexpr float alpha = 0.75;
+	constexpr unsigned int D = 100;
+
+	static Samples output;
+	static Sample prev[D]; // prev[0] = output[0 - D]
+
+	// Do calculations with previous output
+	for (unsigned int i = 0; i < D; i++)
+		output[i] = samples[i] + alpha * (prev[i] - 2048);
+
+	// Do calculations with current samples
+	for (unsigned int i = D; i < SIZE; i++)
+		output[i] = samples[i] + alpha * (output[i - D] - 2048);
+
+	// Save outputs for next computation
+	for (unsigned int i = 0; i < D; i++)
+		prev[i] = output[SIZE - (D - i)];
+
+	return output;
+}