speaker-calibration 2.0.0 → 2.1.0

package/src/tasks/impulse-response/mlsGen/mlsGen.hpp

@@ -0,0 +1,304 @@
+#ifndef SPEAKER_CALIBRATION_SRC_TASKS_IMPULSE_RESPOMSE_MLSGEN_MLSGEN_HPP_
+#define SPEAKER_CALIBRATION_SRC_TASKS_IMPULSE_RESPOMSE_MLSGEN_MLSGEN_HPP_
+
+// setup emscripten for vscode intelli sense:
+// https://gist.github.com/wayou/59f3a8e4fbab050fbb32e94dd9582660'
+#ifdef __EMSCRIPTEN__
+#include <emscripten/bind.h>
+#include <emscripten/val.h>
+#endif
+
+#include "kiss_fft.h"
+
+/**
+ * @brief Exposes methods for generating an MLS signal, and calculating the
+ * impulse response of a recording. This class is compiled to webassembly using
+ * emscripten, embind, and val.
+ *
+ */
+class MLSGen {
+ private:
+  // MLS parameters
+  long N; // mls factor
+  long P; // len of mls
+  long C; // len of recorded signals
+
+  // Async Clock Adjustment Parameters
+  long srcSR;
+  long sinkSR;
+
+  // MLS data
+  bool *mls;
+  long *tagL;
+  long *tagS;
+  float *generatedSignal;  // MLS signal at +- 1
+
+  // IR data
+  float *recordedSignal; // isolated mls signal
+  float *recordedSignals; // full capture
+  float *perm; // permutation of recorded signals
+  float *resp; // impulse response of recorded signals
+ 
+
+  // Internals
+  void GenerateSignal();
+  void generateMls();
+  void fastHadamard();
+  void permuteSignal();
+  void permuteResponse();
+  void generateTagL();
+  void generateTagS();
+  void estimateDiff();
+  void computeCorrelation();
+  void computeFilter();
+
+ public:
+  /**
+   * @brief Construct a new MLSGen object with the given factor and
+   * sampling frequencies.
+   *
+   * @param N - number of bits
+   * @param srcSR - source sampling frequency
+   * @param sinkSR - sink sampling frequency
+   */
+  MLSGen(long N, long srcSR, long sinkSR);
+
+#ifndef __EMSCRIPTEN__
+  /**
+   * @brief Destruct the MLSGen object.
+   * @return void
+   */
+  ~MLSGen();
+#endif
+
+#ifdef __EMSCRIPTEN__
+  /**
+   * @brief Destroy the MLSGen object
+   *
+   */
+  void Destruct();
+
+  /**
+   * @brief Generates an MLS signal according to the parameters set in the
+   * constructor. Returns a memory view of the MLS signal.
+   *
+   * @return emscripten::val
+   */
+  emscripten::val getMLS();
+
+  /**
+   * @brief Get the Recorded Signals Memory View object. This memory view can
+   * then be set in the javascript code.
+   *
+   * @return emscripten::val
+   */
+  emscripten::val setRecordedSignalsMemoryView(long sizeRecordedSignals);
+
+  emscripten::val getRecordedSignalsMemoryView();
+
+  /**
+   * @brief Get the Impulse Response. Returns a memory view of the impulse
+   * response.
+   *
+   * @return emscripten::val
+   */
+  emscripten::val getImpulseResponse();
+#endif
+};
+
+void MLSGen::GenerateSignal() {
+  long i;
+  for (i = 0; i < P; i++)  // Simulate a system with h = {2, 0.4, 0.2, -0.1,
+                           // -0.8}, just an example
+  {
+    recordedSignal[i] = 2.0 * generatedSignal[(P + i - 0) % P] +
+                        0.4 * generatedSignal[(P + i - 1) % P] +
+                        0.2 * generatedSignal[(P + i - 2) % P] -
+                        0.1 * generatedSignal[(P + i - 3) % P] -
+                        0.8 * generatedSignal[(P + i - 4) % P];
+  }
+}
+
+void MLSGen::generateMls() {
+  const long maxNoTaps = 18;
+  const bool tapsTab[16][18] = {
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+      1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0,
+      0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
+      0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+  bool taps[maxNoTaps];
+  long i, j;
+  bool *delayLine = new bool[maxNoTaps];
+  long sum;
+  for (i = 0; i < N; i++)  // copy the N’th taps table
+  {
+    taps[i] = tapsTab[maxNoTaps - N][i];
+    delayLine[i] = 1;
+  }
+  for (i = 0; i < P; i++)  // Generate an MLS by summing the taps mod 2
+  {
+    sum = 0;
+    for (j = 0; j < N; j++) {
+      sum += taps[j] * delayLine[j];
+    }
+    sum &= 1;  // mod 2
+    mls[i] = delayLine[N - 1];
+    for (j = N - 2; j >= 0; j--) {
+      delayLine[j + 1] = delayLine[j];
+    }
+    delayLine[0] = *(bool *)&sum;
+  }
+  delete[] delayLine;
+}
+
+void MLSGen::fastHadamard() {
+  long i, i1, j, k, k1, k2, P1;
+  double temp;
+  P1 = P + 1;
+  k1 = P1;
+  for (k = 0; k < N; k++) {
+    k2 = k1 >> 1;
+    for (j = 0; j < k2; j++) {
+      for (i = j; i < P1; i = i + k1) {
+        i1 = i + k2;
+        temp = perm[i] + perm[i1];
+        perm[i1] = perm[i] - perm[i1];
+        perm[i] = temp;
+      }
+    }
+    k1 = k1 >> 1;
+  }
+}
+
+void MLSGen::permuteSignal() {
+  long i;
+  double dc = 0;
+  for (i = 0; i < P; i++) dc += recordedSignal[i];
+  perm[0] = -dc;
+  for (i = 0; i < P; i++)  // Just a permutation of the measured signal
+    perm[tagS[i]] = recordedSignal[i];
+}
+
+void MLSGen::permuteResponse() {
+  long i;
+  const double fact = 1 / double(P + 1);
+  for (i = 0; i < P; i++)  // Just a permutation of the impulse response
+  {
+    resp[i] = perm[tagL[i]] * fact;
+  }
+  resp[P] = 0;
+}
+
+void MLSGen::generateTagL() {
+  long i, j;
+  long *colSum = new long[P];
+  long *index = new long[N];
+  for (i = 0; i < P; i++)  // Run through all the columns in the autocorr matrix
+  {
+    colSum[i] = 0;
+    for (j = 0; j < N; j++)  // Find colSum as the value of the first N elements
+                             // regarded as a binary number
+    {
+      colSum[i] += mls[(P + i - j) % P] << (N - 1 - j);
+    }
+    for (j = 0; j < N; j++)  // Figure out if colSum is a 2^j number and store
+                             // the column as the j’th index
+    {
+      if (colSum[i] == (1 << j)) index[j] = i;
+    }
+  }
+  for (i = 0; i < P; i++)  // For each row in the L matrix
+  {
+    tagL[i] = 0;
+    for (j = 0; j < N; j++)  // Find the tagL as the value of the rows in the L
+                             // matrix regarded as a binary number
+    {
+      tagL[i] += mls[(P + index[j] - i) % P] * (1 << j);
+    }
+  }
+  delete[] colSum;
+  delete[] index;
+}
+
+void MLSGen::generateTagS() {
+  long i, j;
+  for (i = 0; i < P; i++)  // For each column in the S matrix
+  {
+    tagS[i] = 0;
+    for (j = 0; j < N; j++)  // Find the tagS as the value of the columns in the
+                             // S matrix regarded as a binary number
+    {
+      tagS[i] += mls[(P + i - j) % P] * (1 << (N - 1 - j));
+    }
+  }
+}
+
+  // #compute_correlation = (recorded, generated, P) => {
+
+  //   // cross correlate to find the best match
+  //   size = len(v) * len(generated);
+  //   const fftr2r_x = new fftw.r2r.fft1d(size);
+  //   const xCorr = fftr2r_x.backward(
+  //     fftr2r_x.forward(v - v_avg) * fftr2r_x.forward(g_reversed - g_avg)
+  //   );
+  //   fftr2r_x.dispose(); // manual garbage collection
+  //   const lag = this.#argMax(xCorr) - Math.floor(v.length / 2);
+
+  //   // auto correlate to find the sampling difference
+  //   size = len(v) * len(v);
+  //   const fftr2r_auto = new fftw.r2r.fft1d(size);
+  //   const autoCorr_full = fftr2r_auto.backward(
+  //     fftr2r_auto.forward(v) * fftr2r_auto.forward(v_reversed)
+  //   );
+  //   const autoCorr = autoCorr_full.slice(len(autoCorr_full) - len(v), len(autoCorr_full));
+  //   const inflection = this.#npdiff(Math.sign(this.#npdiff(autoCorr)));
+  //   const peaks = inflection.map((x, i) => (x < 0 ? 1 : 0));
+  // };
+
+void MLSGen::computeCorrelation() {
+  // inverse FFT of size C
+  kiss_fft_cfg xcor_cfg = kiss_fft_alloc(C,1,0,0 );
+  kiss_fft_cpx *xcor_in = new kiss_fft_cpx[C];
+  kiss_fft_cpx *xcor_out = new kiss_fft_cpx[C];
+
+  // set up input and output arrays
+  for(int i = 0; i < C; i++) {
+    xcor_in[i].r = recordedSignals[i];
+    xcor_in[i].i = 0;
+  }
+
+  // compute iFFT
+  kiss_fft( xcor_cfg , xcor_in , xcor_out );
+  // free memory
+  kiss_fft_free(xcor_cfg);
+
+  // find max index
+  int max_index = 0;
+  double max_value = 0;
+  for(int i = 0; i < C; i++) {
+    if(xcor_out[i].r > max_value) {
+      max_index = i;
+      max_value = xcor_out[i].r;
+    }
+  }
+
+  // use max index to compute lag
+  int lag = max_index - C/2;
+
+
+}
+
+void MLSGen::computeFilter() {
+
+}
+
+
+#endif  // SPEAKER_CALIBRATION_SRC_TASKS_IMPULSE_RESPOMSE_MLSGEN_MLSGEN_HPP_

package/src/tasks/impulse-response/mlsGen/mlsGenInterface.js

@@ -0,0 +1,131 @@
+/* eslint-disable prefer-destructuring */
+/* eslint-disable dot-notation */
+// eslint-disable-next-line import/extensions
+const createMLSGenModule = require('../../../../dist/mlsGen.js');
+
+/**
+ * MLSGenInterface provides a class for interfacing with the MLSGen WASM module.
+ */
+class MlsGenInterface {
+  /** @private */
+  #mlsOrder;
+
+  /** @private */
+  #WASMInstance; // the WASM module instance
+
+  /** @private */
+  #MLSGenInstance; // the MLSGen object instance
+
+  /**
+   * Creates an instance of MlsGenInterface.
+   * Makes a call to the WASM glue code to load the WASM module.
+   *
+   * @param WASMInstance
+   * @param mlsOrder
+   * @param sourceSamplingRate
+   * @param sinkSamplingRate
+   * @example
+   */
+  constructor(WASMInstance, mlsOrder, sourceSamplingRate, sinkSamplingRate) {
+    this.#mlsOrder = mlsOrder;
+    this.#WASMInstance = WASMInstance;
+
+    console.warn('initializing MLSGen, need to manually garbage collect');
+    this.#MLSGenInstance = new this.#WASMInstance['MLSGen'](
+      mlsOrder,
+      sourceSamplingRate,
+      sinkSamplingRate
+    );
+  }
+
+  /**
+   * Factory function that provide an asynchronous function that fetches the WASM module
+   * and returns a promise that resolves when the module is loaded.
+   *
+   * @param mlsOrder
+   * @param sourceSamplingRate - The sampling rate of the source audio.
+   * @param sinkSamplingRate - The sampling rate of the sink audio.
+   * @returns MlsGenInterface.
+   * @example
+   */
+  static factory = async (mlsOrder, sourceSamplingRate, sinkSamplingRate) => {
+    if (sourceSamplingRate === undefined || sinkSamplingRate === undefined) {
+      throw new Error('sourceSamplingRate and sinkSamplingRate must be defined');
+    }
+    return new MlsGenInterface(
+      await createMLSGenModule().then(instance => instance),
+      mlsOrder,
+      sourceSamplingRate,
+      sinkSamplingRate
+    );
+  };
+
+  /**
+   * A Higher-Order function that takes an async callback function that access the MLSGen object,
+   * providing safe garbage collection.
+   *
+   * @param func
+   * @param args
+   * @param funcsWithParams
+   * @example
+   */
+  withGarbageCollection = async funcsWithParams => {
+    try {
+      for (let i = 0; i < funcsWithParams.length; i += 1) {
+        const funcWithParams = funcsWithParams[i];
+        // eslint-disable-next-line no-await-in-loop
+        await funcWithParams();
+      }
+    } catch (error) {
+      console.error(error);
+    } finally {
+      // garbage collect
+      if (
+        this !== undefined &&
+        this !== null &&
+        this.#MLSGenInstance !== undefined &&
+        this.#MLSGenInstance !== null
+      ) {
+        this.#MLSGenInstance['Destruct'](); // Call the destructor
+        this.#MLSGenInstance['delete'](); // Delete the object
+        console.warn(`GARBAGE COLLECTION: deleted MLSGen`);
+        this.#WASMInstance['doLeakCheck'](); // Check for memory leaks
+      }
+    }
+  };
+
+  /**
+   * Calculate and return the Impulse Response of the recorded signal.
+   *
+   * @returns
+   * @example
+   */
+  getImpulseResponse = () => this.#MLSGenInstance['getImpulseResponse']();
+
+  /**
+   * Given a recorded MLS signal, this function sets the recordedSignal property of the MLSGen object.
+   *
+   * @param signals
+   * @example
+   */
+  setRecordedSignals = signals => {
+    // get memory view
+    const averagedSignals = this.average(signals);
+    const recordedSignalsMemoryView = this.#MLSGenInstance['setRecordedSignalsMemoryView'](
+      averagedSignals.byteLength
+    );
+    for (let i = 0; i < averagedSignals.length; i += 1) {
+      recordedSignalsMemoryView[i] = averagedSignals[i];
+    }
+  };
+
+  /**
+   * Calculate the Maximum Length Sequence (MLS) with period P = 2^N - 1
+   * using the MLSGen WASM module.
+   *
+   * @example
+   */
+  getMLS = () => this.#MLSGenInstance['getMLS']();
+}
+
+export default MlsGenInterface;

package/src/tasks/impulse-response/mlsGen/mlsGenTest.cpp

@@ -0,0 +1,181 @@
+#include "stdio.h"
+
+void GenerateSignal(bool *mls, double *signal, long P) {
+  long i;
+  double *input = new double[P];
+  for (i = 0; i < P; i++)  // Change 0 to 1 and 1 to -1
+  {
+    input[i] = -2 * mls[i] + 1;
+  }
+  for (i = 0; i < P; i++)  // Simulate a system with h = {2, 0.4, 0.2, -0.1,
+                           // -0.8}, just an example
+  {
+    signal[i] = 2.0 * input[(P + i - 0) % P] + 0.4 * input[(P + i - 1) % P] +
+                0.2 * input[(P + i - 2) % P] - 0.1 * input[(P + i - 3) % P] -
+                0.8 * input[(P + i - 4) % P];
+  }
+  delete[] input;
+}
+
+void GenerateMls(bool *mls, long P, long N) {
+  const long maxNoTaps = 18;
+  const bool tapsTab[16][18] = {
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+      1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0,
+      0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
+      0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+  bool taps[maxNoTaps];
+  long i, j;
+  bool *delayLine = new bool[maxNoTaps];
+  long sum;
+  for (i = 0; i < N; i++)  // copy the N'th taps table
+  {
+    taps[i] = tapsTab[maxNoTaps - N][i];
+    delayLine[i] = 1;
+  }
+  for (i = 0; i < P; i++)  // Generate an MLS by summing the taps mod 2
+  {
+    sum = 0;
+    for (j = 0; j < N; j++) {
+      sum += taps[j] * delayLine[j];
+    }
+    sum &= 1;  // mod 2
+    mls[i] = delayLine[N - 1];
+    for (j = N - 2; j >= 0; j--) {
+      delayLine[j + 1] = delayLine[j];
+    }
+    delayLine[0] = *(bool *)&sum;
+  }
+  delete[] delayLine;
+}
+
+void FastHadamard(double *x, long P1, long N) {
+  long i, i1, j, k, k1, k2;
+  double temp;
+  k1 = P1;
+  for (k = 0; k < N; k++) {
+    k2 = k1 >> 1;
+    for (j = 0; j < k2; j++) {
+      for (i = j; i < P1; i = i + k1) {
+        i1 = i + k2;
+        temp = x[i] + x[i1];
+        x[i1] = x[i] - x[i1];
+        x[i] = temp;
+      }
+    }
+    k1 = k1 >> 1;
+  }
+}
+
+void PermuteSignal(double *sig, double *perm, long *tagS, long P) {
+  long i;
+  double dc = 0;
+  for (i = 0; i < P; i++) dc += sig[i];
+  perm[0] = -dc;
+  for (i = 0; i < P; i++) {  // Just a permutation of the measured signal
+    perm[tagS[i]] = sig[i];
+  }
+}
+void PermuteResponse(double *perm, double *resp, long *tagL, long P) {
+  long i;
+  const double fact = 1 / double(P + 1);
+  for (i = 0; i < P; i++)  // Just a permutation of the impulse response
+  {
+    resp[i] = perm[tagL[i]] * fact;
+  }
+  resp[P] = 0;
+}
+
+void GeneratetagL(bool *mls, long *tagL, long P, long N) {
+  long i, j;
+  long *colSum = new long[P];
+  long *index = new long[N];
+  for (i = 0; i < P; i++)  // Run through all the columns in the autocorr matrix
+  {
+    colSum[i] = 0;
+    for (j = 0; j < N; j++)  // Find colSum as the value of the first N elements
+                             // regarded as a binary number
+    {
+      colSum[i] += mls[(P + i - j) % P] << (N - 1 - j);
+    }
+    for (j = 0; j < N; j++)  // Figure out if colSum is a 2^j number and store
+                             // the column as the j'th index
+    {
+      if (colSum[i] == (1 << j)) index[j] = i;
+    }
+  }
+  for (i = 0; i < P; i++)  // For each row in the L matrix
+  {
+    tagL[i] = 0;
+    for (j = 0; j < N; j++)  // Find the tagL as the value of the rows in the L
+                             // matrix regarded as a binary number
+    {
+      tagL[i] += mls[(P + index[j] - i) % P] * (1 << j);
+    }
+  }
+  delete[] colSum;
+  delete[] index;
+}
+
+void GeneratetagS(bool *mls, long *tagS, long P, long N) {
+  long i, j;
+  for (i = 0; i < P; i++)  // For each column in the S matrix
+  {
+    tagS[i] = 0;
+    for (j = 0; j < N; j++)  // Find the tagS as the value of the columns in the
+                             // S matrix regarded as a binary number
+    {
+      tagS[i] += mls[(P + i - j) % P] * (1 << (N - 1 - j));
+    }
+  }
+}
+
+int main() {
+  const long N = 18;
+  const long P = (1 << N) - 1;
+  long i;
+  bool *mls = new bool[P];
+  long *tagL = new long[P];
+  long *tagS = new long[P];
+  double *signal = new double[P];
+  double *perm = new double[P + 1];
+  double *resp = new double[P + 1];
+  GenerateMls(mls, P, N);         // Generate the Maximum length sequence
+  GeneratetagL(mls, tagL, P, N);  // Generate tagL for the L matrix
+  GeneratetagS(mls, tagS, P, N);  // Generate tagS for the S matrix
+  GenerateSignal(mls, signal,
+                 P);  // Do a simulated measurement and get the signal
+  PermuteSignal(signal, perm, tagS, P);  // Permute the signal according to tagS
+  FastHadamard(perm, P + 1, N);          // Do a Hadamard transform in place
+  PermuteResponse(perm, resp, tagL,
+                  P);  // Permute the impulseresponse according to tagL
+
+  printf("The mls is:\n");
+  for (i = 0; i < 10; i++) printf("%d\n", mls[i]);
+  printf("The tagL is:\n");
+  for (i = 0; i < 10; i++) printf("%ld\n", tagL[i]);
+  printf("The tagS is:\n");
+  for (i = 0; i < 10; i++) printf("%ld\n", tagS[i]);
+  printf("The signal is:\n");
+  for (i = 0; i < 10; i++) printf("%f\n", signal[i]);
+  printf("The permuted signal is:\n");
+  for (i = 0; i < 10; i++) printf("%f\n", perm[i]);
+  printf("Impulse response:\n");
+  for (i = 0; i < 10; i++) printf("%10.5f\n", resp[i]);
+  delete[] mls;
+  delete[] tagL;
+  delete[] tagS;
+  delete[] signal;
+  delete[] perm;
+  delete[] resp;
+
+  return 0;
+}

package/src/tasks/volume/volume.cpp

@@ -0,0 +1,3 @@
+#include "volume.hpp"
+
+#include <sanitizer/lsan_interface.h>

package/src/tasks/volume/volume.hpp

@@ -0,0 +1,23 @@
+#ifndef SPEAKER_CALIBRATION_SRC_TASKS_VOLUMME_VOLUME_HPP_
+#define SPEAKER_CALIBRATION_SRC_TASKS_VOLUMME_VOLUME_HPP_
+
+// setup emscripten for vscode intelli sense:
+// https://gist.github.com/wayou/59f3a8e4fbab050fbb32e94dd9582660'
+#ifdef __EMSCRIPTEN__
+#include <emscripten/bind.h>
+#include <emscripten/val.h>
+#endif
+
+#include <math.h>
+
+class Volume {
+    private:
+    const long REF_POWER = 2 * pow(10, -10);
+    const long REF_PRESSURE = 2 * pow(10, -5);
+    const long TARGET_RANGE[2] = { 3.5, 4.5 };
+    long sampleRate;
+    long *sineSignal;
+    long *recordedSineSignal;
+}
+
+#endif // SPEAKER_CALIBRATION_SRC_TASKS_VOLUMME_VOLUME_HPP_