noyes 0.6.1 → 0.8.0

data/lib/c_impl/n_fast_8k_mfcc.c

@@ -0,0 +1,55 @@
+#include "noyes.h"
+
+Fast8kMfcc * new_fast_8k_mfcc() {
+  double factor = 0.97;
+  int nfilt = 32;
+  int min_freq = 200;
+  int max_freq = 3700;
+  int nfft = 256*2;
+  int freq = 8000*2;
+  int shift = 80*2;
+  int frame_size = 205*2;
+  double log_zero = -0.00001;
+  int dimensions=13;
+  int cmn_init_mean=45.0;
+  int cmn_window_size=100;
+  int cmn_shift=160;
+  
+  Fast8kMfcc *self = malloc(sizeof(Fast8kMfcc));
+  self->pre = new_preemphasizer(factor);
+  self->seg = new_segmenter(frame_size, shift);
+  self->ham = new_hamming_window(frame_size);
+  self->pow = new_power_spectrum(nfft);
+  self->mel = new_mel_filter(freq, nfft, nfilt, min_freq, max_freq);
+  self->log = new_log_compressor(log_zero);
+  self->dct = new_dct(dimensions, nfilt);
+  self->cmn = new_live_cmn(dimensions, cmn_init_mean, cmn_window_size, cmn_shift);
+  return self;
+}
+
+void free_fast_8k_mfcc(Fast8kMfcc *self) {
+  free(self->seg);
+  free(self->ham);
+  free(self->pow);
+  free(self->mel);
+  free(self->log);
+  free(self->dct);
+  free(self->cmn);
+  free(self);
+}
+
+NMatrix *fast_8k_mfcc_apply(Fast8kMfcc *self, NMatrix1 * data) {
+  NMatrix *M = NULL;
+  NMatrix *N = NULL;
+  NMatrix1 *data1 = preemphasizer_apply(self->pre, data);
+  M = segmenter_apply(self->seg, data1); free_nmatrix1(data1);
+  if (!M)
+    return NULL;
+  N = hamming_window_apply(self->ham, M); free_nmatrix(M);
+  M = power_spectrum_apply(self->pow, N); free_nmatrix(N);
+  N = mel_filter_apply(self->mel, M); free_nmatrix(M);
+  M = log_compressor_apply(self->log, N); free_nmatrix(N);
+  N = dct_apply(self->dct, M); free_nmatrix(M);
+  M = live_cmn_apply(self->cmn, N); free_nmatrix(N);
+  return M;
+}

data/lib/c_impl/n_hamming_window.c

@@ -0,0 +1,30 @@
+#include "noyes.h"
+#include "math.h"
+
+HammingWindow * new_hamming_window(int window_size) {
+  HammingWindow *hw = malloc(sizeof(HammingWindow));
+  hw->buf = malloc(window_size * sizeof(double));
+  hw->buflen = window_size;
+  double twopi = M_PI * 2;
+  int i;
+  for (i=0;i<window_size;++i) {
+      hw->buf[i] = 0.54 - 0.46*cos(twopi*i/(window_size-1));
+  }
+  return hw;
+}
+
+void free_hamming_window(HammingWindow *hw) {
+  free(hw->buf);
+  free(hw);
+}
+
+NMatrix * hamming_window_apply(HammingWindow *self, NMatrix* N) {
+  NMatrix *M = new_nmatrix(N->rows, N->cols);
+  int i,j;
+  for (i=0;i<N->rows;++i) {
+    for (j=0;j<N->cols;++j) {
+        M->data[i][j] = self->buf[j] * N->data[i][j];
+    }
+  }
+  return M;
+}

data/lib/c_impl/n_live_cmn.c

@@ -0,0 +1,72 @@
+#include "noyes.h"
+#include "stdlib.h"
+#include "stdio.h"
+
+LiveCMN * new_live_cmn(int dimensions, double init_mean, int window_size,
+                                                         int shift) {
+  LiveCMN *cmn = malloc(sizeof(LiveCMN));
+  cmn->init_mean = init_mean; 
+  cmn->window_size = window_size;
+  cmn->shift = shift;
+  cmn->sums = calloc(dimensions, sizeof(double));
+  cmn->dimensions = dimensions;
+  cmn->means = calloc(dimensions, sizeof(double));
+  cmn->means[0] = init_mean;
+  cmn->frame_count=0;
+  return cmn;
+}
+
+void free_live_cmn(LiveCMN *cmn) {
+  free(cmn->sums);
+  free(cmn->means);
+  free(cmn);
+}
+
+static void live_cmn_reset(LiveCMN *self) {
+    int i;
+    for (i=0; i<self->dimensions; ++i) {
+        self->sums[i] = 0.0;
+    }
+    for (i=0; i<self->dimensions; ++i) {
+        self->means[i] = 0.0;
+    }
+    self->means[0] = self->init_mean;
+    self->frame_count = 0;
+}
+
+static void live_cmn_update(LiveCMN *self) {
+    double per_frame = 1.0 / self->frame_count;
+    int i;
+    for (i=0; i< self->dimensions; ++i) {
+        self->means[i] = self->sums[i] * per_frame;
+    }
+    
+    if (self->means[0] > 70 || self->means[0] < 5) {
+        live_cmn_reset(self);
+    } else if (self->frame_count >= self->shift) {
+        for (i=0; i < self->dimensions; ++i) {
+            self->sums[i] = self->sums[i] * per_frame * self->window_size;
+            self->frame_count = self->window_size;
+        }
+    }
+}
+
+NMatrix *live_cmn_apply(LiveCMN *self, NMatrix *dct) {
+  if (dct->cols != self->dimensions) {
+      fprintf(stderr, "Wrong number of dimensions in live_cmn_apply\n");
+      return NULL;
+  }
+  NMatrix *cmn = new_nmatrix(dct->rows, dct->cols);
+  int i,j;
+  for (i=0;i<dct->rows;++i) {
+      for (j=0;j<dct->cols;++j) {
+          self->sums[j] += dct->data[i][j];
+          cmn->data[i][j] = dct->data[i][j] - self->means[j];
+      }
+      ++self->frame_count;
+      if (self->frame_count > self->shift) {
+        live_cmn_update(self);
+      }
+  }
+  return cmn;
+}

data/lib/c_impl/n_log_compressor.c

@@ -0,0 +1,21 @@
+#include "noyes.h"
+#include "math.h"
+
+LogCompressor * new_log_compressor(double log_zero) {
+  return malloc(sizeof(LogCompressor));
+}
+
+void free_log_compressor(LogCompressor *lc) {
+  free(lc);
+}
+
+NMatrix * log_compressor_apply(LogCompressor *self, NMatrix *data) {
+  NMatrix *M = new_nmatrix(data->rows, data->cols);
+  int i, j;
+  for (i=0;i<M->rows;++i) {
+      for (j=0;j<M->cols;++j) {
+          M->data[i][j] = data->data[i][j] > 0 ? log(data->data[i][j]) : self->log_zero;
+      }
+  }
+  return M;
+}

data/lib/c_impl/n_matrix.c

@@ -0,0 +1,40 @@
+#include "noyes.h"
+
+// A 2 dimensional matrix "class".
+NMatrix *new_nmatrix(int rows, int cols) {
+  NMatrix *M = malloc(sizeof(NMatrix));
+  M->data = malloc(rows * sizeof(double*));
+  int i;
+  for (i=0;i<rows;++i) {
+    M->data[i] = malloc(cols * sizeof(double));
+  }
+  M->rows = rows;
+  M->cols = cols;
+  return M;
+}
+
+void free_nmatrix(NMatrix *M) {
+  if (M) {
+    int i;
+    for (i=0;i<M->rows;++i) {
+      free(M->data[i]);
+    }
+    free(M->data);
+    free(M);
+  }
+}
+
+// A 1 dimensional matrix "class".
+NMatrix1 *new_nmatrix1(int rows) {
+  NMatrix1 *M = malloc(sizeof(NMatrix1));
+  M->data = malloc(rows * sizeof(double));
+  M->rows = rows;
+  return M;
+}
+
+void free_nmatrix1(NMatrix1 *M) {
+  if (M) {
+    free(M->data);
+    free(M);
+  }
+}

data/lib/c_impl/n_mel_filter.c

@@ -0,0 +1,152 @@
+#include "noyes.h"
+#include "stdlib.h"
+#include "memory.h"
+#include "math.h"
+
+NMatrix1 * make_filter(double left, double center, double right,
+                               double initFreq, double delta);
+
+MelFilter * new_mel_filter(int srate, int nfft, int nfilt, int lowerf, int upperf) {
+  MelFilter *mf = malloc(sizeof(MelFilter));
+  NMatrix *params = make_bank_parameters(srate, nfft, nfilt, lowerf, upperf);
+  mf->len = params->rows;
+  mf->indices = malloc(params->rows * sizeof(int));
+  mf->weights = malloc(params->rows * sizeof(double*));
+  mf->weightlens = malloc(params->rows * sizeof(int));
+  int i;
+  for (i=0; i<params->rows;++i) {
+      NMatrix1 * temp = make_filter(params->data[i][0], params->data[i][1],
+                                    params->data[i][2], params->data[i][3],
+                                    params->data[i][4]);
+      mf->indices[i] = round(temp->data[0]);
+      int weightlen = temp->rows-1;
+      mf->weights[i] = malloc(sizeof(double) * weightlen);
+      mf->weightlens[i] = weightlen;
+      int j;
+      for (j=0; j<weightlen; ++j) {
+          double foo = temp->data[j+1];
+          mf->weights[i][j] = foo;
+      }
+  }
+  return mf;
+}
+
+NMatrix * mel_filter_apply(MelFilter* self, NMatrix * power_spectrum) {
+    NMatrix *melbanks = new_nmatrix(power_spectrum->rows, self->len);
+    int i;
+    for (i=0;i<power_spectrum->rows; ++i) {
+        double * spectrum = power_spectrum->data[i];
+        int j;
+        for (j=0;j<self->len; ++j) {
+            int initialIndex = self->indices[j];
+            int lenw = self->weightlens[j];
+            double * w = self->weights[j];
+            double output = 0.0;
+            int k;
+            for (k=0;k<lenw;++k) {
+                int index = initialIndex + k; 
+                if (index < power_spectrum->cols) {
+                    output += spectrum[index] * w[k];
+                }
+            }
+            melbanks->data[i][j] = output;
+        } 
+    }
+    return melbanks;
+}
+
+void free_mel_filter(MelFilter* mf) {
+  int i;
+  for (i=0;i<mf->len;++i) {
+    free(mf->weights[i]);
+  }
+  free(mf->weights);
+  free(mf->weightlens);
+  free(mf->indices); 
+}
+
+double mel(double f) {
+    return 2595.0 * log10(1.0 + f/700.0);
+}
+
+static double determine_bin(double inFreq,double stepFreq) {
+    return stepFreq * round(inFreq / stepFreq);
+}
+
+double melinv(double m) {
+    return 700.0 * (pow(10, m/2595.0) - 1.0);
+}
+
+//static double[] melinv_array(double[] m) {
+//    double[] result = new double[m.length];
+//    for (int i=0;i<m.length;++i) {
+//        result[i] = melinv(m[i]);
+//    }
+//    return result;
+//}
+
+NMatrix *make_bank_parameters(double srate, int nfft, int nfilt,
+                                      double lowerf, double upperf) { 
+  double * leftEdge = alloca(nfilt*sizeof(double));
+  double * rightEdge = alloca(nfilt*sizeof(double));
+  double * centerFreq = alloca(nfilt*sizeof(double));
+  double melmax = mel(upperf);
+  double melmin = mel(lowerf);
+  double deltaFreqMel = (melmax - melmin) / (nfilt + 1.0);
+  double deltaFreq = srate/nfft;
+  leftEdge[0] = determine_bin(lowerf, deltaFreq);
+  double nextEdgeMel = melmin;
+  int i;
+  for (i=0;i<nfilt;++i) {
+      nextEdgeMel += deltaFreqMel;
+      double nextEdge = melinv(nextEdgeMel);
+      centerFreq[i] = determine_bin(nextEdge, deltaFreq);
+      if (i > 0) { 
+          rightEdge[i-1] = centerFreq[i];
+      } if (i < nfilt -1) {
+          leftEdge[i+1] = centerFreq[i];
+      }
+  }
+  
+  nextEdgeMel += deltaFreqMel;
+  double nextEdge = melinv(nextEdgeMel);
+  rightEdge[nfilt-1] = determine_bin(nextEdge, deltaFreq);
+  NMatrix *fparams = new_nmatrix(nfilt, 5);
+  for (i=0;i<nfilt;++i) {
+      double initialFreqBin = determine_bin(leftEdge[i], deltaFreq);
+      if (initialFreqBin < leftEdge[i]) {
+          initialFreqBin += deltaFreq;
+      }
+      fparams->data[i][0] = leftEdge[i];
+      fparams->data[i][1] = centerFreq[i];
+      fparams->data[i][2] = rightEdge[i];
+      fparams->data[i][3] = initialFreqBin;
+      fparams->data[i][4] = deltaFreq;
+  }
+  return fparams;
+}
+
+// Returns an array of weights with one additional element at the zero
+// location containing the starting index.
+NMatrix1 * make_filter(double left, double center, double right,
+                               double initFreq, double delta) {
+    int nElements = round((right - left)/ delta + 1);
+    NMatrix1 * filter = new_nmatrix1(nElements + 1);
+    double height=1.0;
+    double leftSlope = height / (center - left);
+    double rightSlope = height / (center - right);
+    int indexFW =1;
+    filter->data[0] = round(initFreq/delta);
+    double current;
+    for (current=initFreq; current<=right; current+= delta) {
+        if (current < center) {
+            filter->data[indexFW] = leftSlope * (current - left);
+        } else {
+            filter->data[indexFW] = height + rightSlope * (current - center);
+        }
+        indexFW += 1;
+    }
+
+    return filter;
+}
+

data/lib/c_impl/n_power_spec.c

@@ -0,0 +1,27 @@
+#include "noyes.h"
+#include "stdlib.h"
+#include "math.h"
+
+PowerSpectrum * new_power_spectrum(int nfft) {
+  PowerSpectrum *ps = malloc(sizeof(PowerSpectrum));
+  ps->nfft = nfft;
+  ps->n_uniq_fft_points = nfft/2 + 1;
+  return ps;
+}
+
+void free_power_spectrum(PowerSpectrum * self) {
+  free(self);
+}
+
+NMatrix *power_spectrum_apply(PowerSpectrum *self, NMatrix *data) {
+  NMatrix *ps = new_nmatrix(data->rows, self->n_uniq_fft_points);
+  int i,j;
+  for (i=0;i<data->rows;++i) {
+      NMatrix * ffts = dft(data->data[i], data->cols, self->nfft);
+      for (j=0;j<self->n_uniq_fft_points;++j) {
+          ps->data[i][j] = pow(ffts->data[0][j],2) + pow(ffts->data[1][j],2);
+      }
+      free_nmatrix(ffts);
+  } 
+  return ps;
+}

data/lib/c_impl/n_preemphasis.c

@@ -0,0 +1,25 @@
+#include "noyes.h"
+
+Preemphasizer * new_preemphasizer(double factor) {
+  Preemphasizer *self = malloc(sizeof(Preemphasizer));
+  self->factor = factor;
+  self->prior = 0;
+  return self;
+}
+
+void free_preemphasizer(Preemphasizer *self) {
+  free(self);
+}
+
+NMatrix1 *preemphasizer_apply(Preemphasizer *self, NMatrix1 *data) {
+    NMatrix1 *res = new_nmatrix1(data->rows);
+    double current_prior = self->prior;
+    self->prior = data->data[data->rows-1];
+    int i;
+    for (i = 0; i < data->rows; ++i) {
+        double current = data->data[i];
+        res->data[i] = current - self->factor * current_prior;
+        current_prior = current;
+    }
+    return res;
+}

data/lib/c_impl/n_segmenter.c

@@ -0,0 +1,61 @@
+#include "noyes.h"
+#include "memory.h"
+
+Segmenter * new_segmenter(int winsz, int winshift) {
+  Segmenter *s = malloc(sizeof(Segmenter));
+  s->buf = NULL;
+  s->buflen = 0;
+  s->winsz = winsz;
+  s->winshift = winshift;
+  return s;
+};
+
+void free_segmenter(Segmenter *s) {
+  if (s->buf) {
+    free(s->buf);
+  }
+ 
+  free(s);
+}
+
+NMatrix * segmenter_apply(Segmenter* self, NMatrix1 *data) {
+  double * combo;
+  int combolen = 0;
+  if (self->buf != NULL) {
+      combolen = self->buflen + data->rows;
+      combo = alloca((combolen) * sizeof(double));
+      memcpy(combo, self->buf, self->buflen * sizeof(double));
+      memcpy(combo + self->buflen, data->data, data->rows * sizeof(double));
+  } else {
+      combo = alloca((data->rows) * sizeof(double));
+      combolen = data->rows;
+      memcpy(combo, data->data, combolen * sizeof(double));
+  }
+  if (combolen < self->winsz + self->winshift * 5) {
+      self->buf = realloc(self->buf, combolen * sizeof(double));
+      memcpy(self->buf, combo, combolen*sizeof(double));
+      self->buflen = combolen;
+      return NULL;
+  } else {
+      self->buf = NULL;
+  }
+  NMatrix *M = new_nmatrix((combolen - self->winsz)/ self->winshift+1, self->winsz);
+  int i = 0;
+  int j=0;
+  while (i+self->winsz <= combolen) {
+    memcpy(M->data[j++], combo + i, self->winsz * sizeof(double));
+    i+=self->winshift;
+  }
+  
+  int bufsize = combolen- i;
+  if (bufsize > 0) {
+      // Copy the tail end of combo into buf.
+      self->buf = realloc(self->buf, bufsize * sizeof(double));
+      self->buflen = bufsize;
+      memcpy(self->buf, combo + (combolen - bufsize), bufsize*sizeof(double));
+  } else {
+      self->buf = NULL;
+      self->buflen = 0;
+  }
+  return M;
+}

data/lib/c_impl/noyes.h

@@ -0,0 +1,151 @@
+#include "stdlib.h"
+#ifndef _NOYES_H_
+#define _NOYES_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Matrix handling routines.
+typedef struct {
+  double **data;
+  int rows;
+  int cols;
+} NMatrix;
+
+typedef struct {
+  double ***data;
+  int rows;
+  int cols;
+  int z;
+} NMatrix3;
+
+typedef struct {
+  double *data;
+  int rows;
+} NMatrix1;
+
+NMatrix *new_nmatrix(int rows, int cols);
+void free_nmatrix(NMatrix *);
+
+NMatrix1 *new_nmatrix1(int rows);
+void free_nmatrix1(NMatrix1 *);
+
+// Preemphasizer
+typedef struct {
+  double factor;
+  double prior;
+} Preemphasizer;
+
+Preemphasizer * new_preemphasizer(double factor);
+void free_preemphasizer(Preemphasizer *self);
+NMatrix1 *preemphasizer_apply(Preemphasizer *self, NMatrix1 *data);
+
+// Segmenter
+typedef struct {
+  double * buf;
+  size_t buflen;
+  int winsz;
+  int winshift;
+} Segmenter;
+
+Segmenter * new_segmenter(int winsz, int winshift);
+void free_segmenter(Segmenter *s);
+NMatrix * segmenter_apply(Segmenter* self, NMatrix1 *data);
+
+// Hamming Window
+typedef struct {
+  double * buf;
+  size_t buflen;
+} HammingWindow;
+
+HammingWindow * new_hamming_window(int window_size);
+void free_hamming_window(HammingWindow *s);
+NMatrix * hamming_window_apply(HammingWindow* self, NMatrix *data);
+
+// Power spectrum
+typedef struct {
+   int nfft, n_uniq_fft_points;
+} PowerSpectrum;
+
+PowerSpectrum * new_power_spectrum(int nfft);
+void free_power_spectrum(PowerSpectrum *);
+NMatrix *power_spectrum_apply(PowerSpectrum *self, NMatrix *data);
+NMatrix * dft(double * data, int datalen, int size);
+
+// Mel Filter
+typedef struct {
+  int len;
+  int * indices;
+  double ** weights;
+  int *weightlens;
+} MelFilter;
+
+MelFilter * new_mel_filter(int srate, int nfft, int nfilt, int lowerf,
+                                                            int upperf);
+void free_mel_filter(MelFilter* mf);
+NMatrix *make_bank_parameters(double srate, int nfft, int nfilt,
+                                      double lowerf, double upperf); 
+NMatrix * mel_filter_apply(MelFilter* self, NMatrix * power_spectrum);
+NMatrix1 * make_filter(double left, double center, double right,
+                               double initFreq, double delta);
+double melinv(double m);
+double mel(double m);
+
+// Log Compressor
+typedef struct {
+  double log_zero;
+} LogCompressor;
+
+LogCompressor * new_log_compressor(double log_zero);
+void free_log_compressor(LogCompressor *lc);
+NMatrix * log_compressor_apply(LogCompressor *self, NMatrix *data);
+
+// Discrete Cosine Transform
+typedef struct {
+  int rows;
+  int cols;
+  double **melcos;
+} DiscreteCosineTransform;
+
+DiscreteCosineTransform * new_dct(int order, int ncol);
+void free_dct(DiscreteCosineTransform *dct);
+NMatrix * dct_apply(DiscreteCosineTransform *self, NMatrix *data);
+
+typedef struct {
+  double * sums;
+  double * means;
+  double init_mean;
+  int dimensions;
+  int frame_count;
+  int window_size;
+  int shift;
+} LiveCMN;
+
+LiveCMN * new_live_cmn(int dimensions, double init_mean, int window_size, int shift);
+void free_live_cmn(LiveCMN *lcmn);
+NMatrix *live_cmn_apply(LiveCMN *self, NMatrix *data);
+
+
+// Fast 8k mfcc
+// This strings together all the algorithms necessary to make mfcc's from an 8k
+// signal so you don't have to.
+typedef struct {
+  Preemphasizer *pre;
+  Segmenter *seg;
+  HammingWindow *ham;
+  PowerSpectrum *pow;
+  MelFilter *mel;
+  LogCompressor *log;
+  DiscreteCosineTransform *dct;
+  LiveCMN *cmn;
+} Fast8kMfcc;
+
+Fast8kMfcc* new_fast_8k_mfcc();
+void free_fast_8k_mfcc(Fast8kMfcc *self);
+NMatrix *fast_8k_mfcc_apply(Fast8kMfcc *self, NMatrix1 *data);
+
+#ifdef __cplusplus
+}
+#endif
+#endif