noyes 0.9.2 → 1.0.0

data/VERSION

@@ -1 +1 @@
-0.9.2
+1.0.0

data/bin/nrec

@@ -107,6 +107,11 @@ def recognize file, options
       send_incremental_features file, client, client, bits, rate
     end
   end
+rescue Errno::ECONNREFUSED
+  puts "Connection refused."
+  puts "Possibly the IP address and port are incorrect."
+  puts "Or maybe the server is down.  Contact Talkhouse if this persists."
+  exit 2
 end
 
 ARGV.each do |file|

data/lib/{c_impl → cext}/array_list.c

@@ -1,58 +1,58 @@
 #include "ruby.h"
-#include "noyes.h"
-#include "rnoyes.h"
+#include "c_noyes.h"
+#include "r_noyes.h"
 
 static int id_push;
 
 VALUE cArrayList;
 
-static void free_n_list(void *p) {
-  n_list_free(p);
+static void free_clist(void *p) {
+  clist_free(p);
 }
 
 static VALUE t_init(VALUE self) {
-  NList *st = n_list_new();
-  VALUE stv = Data_Wrap_Struct(cArrayList, 0, free_n_list, st);
-  rb_iv_set(self, "@n_list", stv);
+  Clist *st = clist_new();
+  VALUE stv = Data_Wrap_Struct(cArrayList, 0, free_clist, st);
+  rb_iv_set(self, "@clist", stv);
   return self;
 }
 
 static VALUE t_size(VALUE self) {
-  NList *array;
-  VALUE arrayv = rb_iv_get(self, "@n_list");
-  Data_Get_Struct(arrayv, NList, array);
-  return INT2FIX(n_list_size(array));
+  Clist *array;
+  VALUE arrayv = rb_iv_get(self, "@clist");
+  Data_Get_Struct(arrayv, Clist, array);
+  return INT2FIX(clist_size(array));
 }
 
 static VALUE t_add(VALUE self, VALUE obj) {
-  NList *array;
-  VALUE arrayv = rb_iv_get(self, "@n_list");
-  Data_Get_Struct(arrayv, NList, array);
-  n_list_add(array, (void*)obj);
+  Clist *array;
+  VALUE arrayv = rb_iv_get(self, "@clist");
+  Data_Get_Struct(arrayv, Clist, array);
+  clist_add(array, (void*)obj);
   return Qnil;
 }
 
 static VALUE t_get(VALUE self, VALUE obj) {
-  NList *array;
-  VALUE arrayv = rb_iv_get(self, "@n_list");
-  Data_Get_Struct(arrayv, NList, array);
-  return (VALUE)n_list_get(array, FIX2INT(obj));
+  Clist *array;
+  VALUE arrayv = rb_iv_get(self, "@clist");
+  Data_Get_Struct(arrayv, Clist, array);
+  return (VALUE)clist_get(array, FIX2INT(obj));
 }
 
 static VALUE t_remove(VALUE self, VALUE start, VALUE finish) {
-  NList *array;
-  VALUE arrayv = rb_iv_get(self, "@n_list");
-  Data_Get_Struct(arrayv, NList, array);
+  Clist *array;
+  VALUE arrayv = rb_iv_get(self, "@clist");
+  Data_Get_Struct(arrayv, Clist, array);
   int b = FIX2INT(start);
   int e = FIX2INT(finish);
-  if (n_list_remove(array, b, e)) {
-    int s = n_list_size(array);
+  if (clist_remove(array, b, e)) {
+    int s = clist_size(array);
     rb_raise(rb_eArgError, "start = %d, finish = %d with size =  %d", b, e, s);
    }
   return Qnil;
 }
 
-void Init_n_list() {
+void Init_clist() {
   VALUE m_noyes_c = rb_define_module("NoyesC");
   cArrayList = rb_define_class_under(m_noyes_c, "ArrayList", rb_cObject);
   rb_define_method(cArrayList, "initialize", t_init, 0);

data/lib/cext/bent_cent_marker.c

@@ -0,0 +1,55 @@
+#include "ruby.h"
+#include "c_noyes.h"
+#include "r_noyes.h"
+
+VALUE cBentCentMarker;
+
+static void _bent_cent_marker_free(void *p) {
+  bent_cent_marker_free(p);
+}
+
+static VALUE t_init(VALUE self, VALUE args) {
+  double adjustment = 0.003;
+  double average_number = 1.0;
+  double background = 100.0;
+  double level = 0.0;
+  double min_signal = 0.0;
+  double threshold = 10.0;
+  int len = RARRAY_LEN(args);
+  if (len > 0)
+     threshold = NUM2INT(rb_ary_entry(args, 0));
+  if (len > 1)
+    adjustment = NUM2INT(rb_ary_entry(args, 1));
+  if (len > 2)
+    average_number = NUM2INT(rb_ary_entry(args, 2));
+  if (len > 3)
+    background = NUM2INT(rb_ary_entry(args, 3));
+  if (len > 4)
+    level = NUM2INT(rb_ary_entry(args, 4));
+  if (len > 5)
+    min_signal = NUM2INT(rb_ary_entry(args, 5));
+
+  BentCentMarker *pre = bent_cent_marker_new(threshold, adjustment,
+                        average_number, background, level, min_signal);
+
+  VALUE prev = Data_Wrap_Struct(cBentCentMarker, 0, _bent_cent_marker_free, pre);
+  rb_iv_set(self, "@bent_cent_marker", prev);
+  return self;
+}
+
+static VALUE t_left_shift(VALUE self, VALUE obj) {
+  Carr *M = r2carr(obj);
+  BentCentMarker *pre;
+  VALUE prev = rb_iv_get(self, "@bent_cent_marker");
+  Data_Get_Struct(prev, BentCentMarker, pre);
+  int res = bent_cent_marker_apply(pre, M);
+  carr_free(M);
+  return res ? Qtrue : Qfalse;
+}
+
+void Init_bent_cent_marker() {
+  VALUE m_noyes_c = rb_define_module("NoyesC");
+  cBentCentMarker = rb_define_class_under(m_noyes_c, "BentCentMarker", rb_cObject);
+  rb_define_method(cBentCentMarker, "initialize", t_init, -2);
+  rb_define_method(cBentCentMarker, "<<", t_left_shift, 1);
+}

data/lib/{c_impl/n_array_list.c → cext/c_array_list.c}

@@ -1,7 +1,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
-#include "n_array_list.h"
+#include "c_array_list.h"
 
 #define NLIST_INITIAL_CAPACITY 10
 #define NLIST_DELTA_CAPACITY 10
@@ -10,22 +10,22 @@
 #undef FALSE
 #define FALSE 0
 
-NList * n_list_new() {
-  NList * self;
-  self = malloc(sizeof(NList));
+Clist * clist_new() {
+  Clist * self;
+  self = malloc(sizeof(Clist));
   self->capacity = NLIST_INITIAL_CAPACITY;
   self->data = malloc(sizeof(void*) * self->capacity);
   self->size = 0;
   return self;
 }
 
-void n_list_free(NList * self) {
+void clist_free(Clist * self) {
   free(self->data);
   free(self);
 }
 
-int n_list_add(NList * self, void * object) {
-  int old_size = n_list_size(self);
+int clist_add(Clist * self, void * object) {
+  int old_size = clist_size(self);
   int new_capacity;
   void ** new_data;
 
@@ -42,7 +42,7 @@ int n_list_add(NList * self, void * object) {
   return TRUE;
 }
 
-int n_list_remove(NList * self, int start, int finish) {
+int clist_remove(Clist * self, int start, int finish) {
   if (start > finish || finish > self->size)
     return 1;
 
@@ -57,16 +57,16 @@ int n_list_remove(NList * self, int start, int finish) {
   return 0;
 }
 
-void * n_list_get(const NList * self, const int index) {
+void * clist_get(const Clist * self, const int index) {
   if (index < 0 || index > self->size)
     return NULL;
   return self->data[index];
 }
 
-int n_list_is_empty(const NList * self) {
-  return 0 == n_list_size(self);
+int clist_is_empty(const Clist * self) {
+  return 0 == clist_size(self);
 }
 
-int n_list_size(const NList * self) {
+int clist_size(const Clist * self) {
   return self->size;
 }

data/lib/cext/c_array_list.h

@@ -0,0 +1,18 @@
+#ifndef _N_ARRAY_LIST_H_
+#define _N_ARRAY_LIST_H_
+
+typedef struct {
+  int capacity;
+  void **data;
+  int size;
+} Clist;
+
+Clist * clist_new();
+void clist_free(Clist * self);
+int clist_size(const Clist * self);
+int clist_add(Clist * self, void * object);
+int clist_remove(Clist * self, int start, int finish);
+void * clist_get(const Clist * self, const int index);
+int clist_is_empty(const Clist * self);
+
+#endif

data/lib/{c_impl/n_bent_cent_marker.c → cext/c_bent_cent_marker.c}

@@ -1,23 +1,25 @@
-#include "noyes.h"
+#include "c_noyes.h"
 #include "math.h"
 #include "stdlib.h"
 
-BentCentMarker * new_bent_cent_marker() {
+BentCentMarker * bent_cent_marker_new(double threshold, double adjustment,
+                                      double average_number, double background,
+                                      double level, double min_signal) {
   BentCentMarker *self = malloc(sizeof(BentCentMarker));
-  self->adjustment = 0.003;
-  self->average_number = 1.0;
-  self->background = 100.0;
-  self->level = 0.0;
-  self->min_signal = 0.0;
-  self->threshold = 10.0;
+  self->adjustment = adjustment;
+  self->average_number = average_number;
+  self->background = background;
+  self->level = level;
+  self->min_signal = min_signal;
+  self->threshold = threshold;
   return self;
 }
 
-void free_bent_cent_marker(BentCentMarker *self) {
+void bent_cent_marker_free(BentCentMarker *self) {
   free(self);
 }
 
-double bent_cent_log_rms(BentCentMarker *self, NMatrix1 *pcm) {
+double bent_cent_log_rms(BentCentMarker *self, Carr *pcm) {
   double sum_of_squares = 0.0;
   int i;
   for (i=0;i<pcm->rows;++i) {
@@ -28,7 +30,7 @@ double bent_cent_log_rms(BentCentMarker *self, NMatrix1 *pcm) {
   return log(rms) * 20;
 }
 
-int bent_cent_marker_apply(BentCentMarker *self, NMatrix1 *pcm) {
+int bent_cent_marker_apply(BentCentMarker *self, Carr *pcm) {
   int is_speech = 0;
   double current = bent_cent_log_rms(self, pcm);
   if (current >= self->min_signal) {

data/lib/{c_impl/n_dft.c → cext/c_dft.c}

@@ -1,15 +1,15 @@
-#include "noyes.h"
+#include "c_noyes.h"
 #include "stdlib.h"
 #include "memory.h"
 #include "math.h"
 #include "stdio.h"
 
-NMatrix * dft(double * data, int datalen, int size) {
+Cmat * dft(double * data, int datalen, int size) {
     if (datalen> size) {
         fprintf(stderr,"Size(%d) must be larger than data length(%d)", size, datalen);
         return NULL;
     }
-    NMatrix *M = new_nmatrix(2, size);
+    Cmat *M = cmat_new(2, size);
     double * real = M->data[0];
     double * imag = M->data[1];
     int j=0,i;

data/lib/{c_impl/n_discrete_cosine_transform.c → cext/c_discrete_cosine_transform.c}

@@ -1,7 +1,7 @@
-#include "noyes.h"
+#include "c_noyes.h"
 #include "math.h"
 
-DiscreteCosineTransform * new_dct(int rows, int cols) {
+DiscreteCosineTransform * dct_new(int rows, int cols) {
   DiscreteCosineTransform *dct = malloc(sizeof(DiscreteCosineTransform));
   dct->melcos = malloc(rows *sizeof(double*));
   dct->rows = rows;
@@ -18,7 +18,7 @@ DiscreteCosineTransform * new_dct(int rows, int cols) {
   return dct;
 }
 
-void free_dct(DiscreteCosineTransform *dct) {
+void dct_free(DiscreteCosineTransform *dct) {
   int i;
   for (i=0;i<dct->rows;++i) {
     free(dct->melcos[i]);
@@ -27,8 +27,8 @@ void free_dct(DiscreteCosineTransform *dct) {
   free(dct);
 }
 
-NMatrix * dct_apply(DiscreteCosineTransform *self, NMatrix *data) {
-  NMatrix *M = new_nmatrix(data->rows, self->rows);
+Cmat * dct_apply(DiscreteCosineTransform *self, Cmat *data) {
+  Cmat *M = cmat_new(data->rows, self->rows);
   int i,j,k;
   for (i=0;i<M->rows;++i) {
     for (j=0;j<M->cols;++j) {

data/lib/{c_impl/n_hamming_window.c → cext/c_hamming_window.c}

@@ -1,7 +1,7 @@
-#include "noyes.h"
+#include "c_noyes.h"
 #include "math.h"
 
-HammingWindow * new_hamming_window(int window_size) {
+HammingWindow * hamming_window_new(int window_size) {
   HammingWindow *hw = malloc(sizeof(HammingWindow));
   hw->buf = malloc(window_size * sizeof(double));
   hw->buflen = window_size;
@@ -13,13 +13,13 @@ HammingWindow * new_hamming_window(int window_size) {
   return hw;
 }
 
-void free_hamming_window(HammingWindow *hw) {
+void hamming_window_free(HammingWindow *hw) {
   free(hw->buf);
   free(hw);
 }
 
-NMatrix * hamming_window_apply(HammingWindow *self, NMatrix* N) {
-  NMatrix *M = new_nmatrix(N->rows, N->cols);
+Cmat * hamming_window_apply(HammingWindow *self, Cmat* N) {
+  Cmat *M = cmat_new(N->rows, N->cols);
   int i,j;
   for (i=0;i<N->rows;++i) {
     for (j=0;j<N->cols;++j) {

data/lib/{c_impl/n_live_cmn.c → cext/c_live_cmn.c}

@@ -1,8 +1,8 @@
-#include "noyes.h"
+#include "c_noyes.h"
 #include "stdlib.h"
 #include "stdio.h"
 
-LiveCMN * new_live_cmn(int dimensions, double init_mean, int window_size,
+LiveCMN * live_cmn_new(int dimensions, double init_mean, int window_size,
                                                          int shift) {
   LiveCMN *cmn = malloc(sizeof(LiveCMN));
   cmn->init_mean = init_mean; 
@@ -16,7 +16,7 @@ LiveCMN * new_live_cmn(int dimensions, double init_mean, int window_size,
   return cmn;
 }
 
-void free_live_cmn(LiveCMN *cmn) {
+void live_cmn_free(LiveCMN *cmn) {
   free(cmn->sums);
   free(cmn->means);
   free(cmn);
@@ -51,12 +51,12 @@ static void live_cmn_update(LiveCMN *self) {
     }
 }
 
-NMatrix *live_cmn_apply(LiveCMN *self, NMatrix *dct) {
+Cmat *live_cmn_apply(LiveCMN *self, Cmat *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);
+  Cmat *cmn = cmat_new(dct->rows, dct->cols);
   int i,j;
   for (i=0;i<dct->rows;++i) {
       for (j=0;j<dct->cols;++j) {

data/lib/{c_impl/n_log_compressor.c → cext/c_log_compressor.c}

@@ -1,16 +1,16 @@
-#include "noyes.h"
+#include "c_noyes.h"
 #include "math.h"
 
-LogCompressor * new_log_compressor(double log_zero) {
+LogCompressor * log_compressor_new(double log_zero) {
   return malloc(sizeof(LogCompressor));
 }
 
-void free_log_compressor(LogCompressor *lc) {
+void log_compressor_free(LogCompressor *lc) {
   free(lc);
 }
 
-NMatrix * log_compressor_apply(LogCompressor *self, NMatrix *data) {
-  NMatrix *M = new_nmatrix(data->rows, data->cols);
+Cmat * log_compressor_apply(LogCompressor *self, Cmat *data) {
+  Cmat *M = cmat_new(data->rows, data->cols);
   int i, j;
   for (i=0;i<M->rows;++i) {
       for (j=0;j<M->cols;++j) {

data/lib/cext/c_matrix.c

@@ -0,0 +1,90 @@
+#include "c_noyes.h"
+#include "memory.h"
+
+// A 2 dimensional dense rectangular matrix "class".
+Cmat *cmat_new(int rows, int cols) {
+  Cmat *M = malloc(sizeof(Cmat));
+  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 cmat_free(Cmat *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".
+Carr *carr_new(int rows) {
+  Carr *M = malloc(sizeof(Carr));
+  M->data = malloc(rows * sizeof(double));
+  M->rows = rows;
+  return M;
+}
+
+void carr_free(Carr *M) {
+  if (M) {
+    free(M->data);
+    free(M);
+  }
+}
+
+// Converts a rectangular matrix to a list of one dimensional matrices.
+// Simultaneously frees the original rectangular matrix.  Actually, the matrix
+// does not have to be rectangular.  Column sizes may vary.
+Carr ** mat2arrs(Cmat *M) {
+  Carr **arrs = malloc(sizeof(Carr*) * M->rows);
+  int i;
+  for (i=0;i<M->rows;++i) {
+    arrs[i] = malloc(sizeof(Carr));
+    arrs[i]->data = M->data[i];
+    arrs[i]->rows = M->cols;
+  }
+  free(M->data);
+  free(M);
+  return arrs;
+}
+
+// Creates an array by appending columns of a rectangular matrix.  Does not
+// delete the original matrix.
+Carr *cmat_flatten(Cmat *M) {
+  Carr *flat = carr_new(M->rows * M->cols);
+  int i;
+  for (i=0;i<M->rows; ++i)
+    memcpy(flat->data + (M->cols * i), M->data[i], sizeof(double) * M->cols);
+
+  return flat;
+}
+
+// Converts an array of one dimensional arrays into a rectangular matrix.  It
+// frees these arrays in the process.  All arrays must have the same length.
+Cmat * arrs2mat(Carr **array, int size) {
+  if (size == 0) {
+    if (array != NULL)
+      free(array);
+    return NULL;
+  }
+  Cmat *mat = malloc(sizeof(Cmat));
+  mat->data = malloc(sizeof(double*) * size);
+  mat->rows = size;
+  mat->cols = array[0]->rows;
+  int i;
+  for (i=0; i<size; ++i) {
+    mat->data[i] = array[i]->data;
+    free(array[i]);
+  }
+  free(array);
+
+  return mat;
+}

data/lib/{c_impl/n_mel_filter.c → cext/c_mel_filter.c}

@@ -1,21 +1,21 @@
-#include "noyes.h"
+#include "c_noyes.h"
 #include "stdlib.h"
 #include "memory.h"
 #include "math.h"
 
-NMatrix1 * make_filter(double left, double center, double right,
+Carr * 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);
+  Cmat *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],
+      Carr * 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]);
@@ -27,12 +27,14 @@ MelFilter * new_mel_filter(int srate, int nfft, int nfilt, int lowerf, int upper
           double foo = temp->data[j+1];
           mf->weights[i][j] = foo;
       }
+      carr_free(temp);
   }
+  cmat_free(params);
   return mf;
 }
 
-NMatrix * mel_filter_apply(MelFilter* self, NMatrix * power_spectrum) {
-    NMatrix *melbanks = new_nmatrix(power_spectrum->rows, self->len);
+Cmat * mel_filter_apply(MelFilter* self, Cmat * power_spectrum) {
+    Cmat *melbanks = cmat_new(power_spectrum->rows, self->len);
     int i;
     for (i=0;i<power_spectrum->rows; ++i) {
         double * spectrum = power_spectrum->data[i];
@@ -55,7 +57,7 @@ NMatrix * mel_filter_apply(MelFilter* self, NMatrix * power_spectrum) {
     return melbanks;
 }
 
-void free_mel_filter(MelFilter* mf) {
+void mel_filter_free(MelFilter* mf) {
   int i;
   for (i=0;i<mf->len;++i) {
     free(mf->weights[i]);
@@ -85,7 +87,7 @@ double melinv(double m) {
 //    return result;
 //}
 
-NMatrix *make_bank_parameters(double srate, int nfft, int nfilt,
+Cmat *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));
@@ -111,7 +113,7 @@ NMatrix *make_bank_parameters(double srate, int nfft, int nfilt,
   nextEdgeMel += deltaFreqMel;
   double nextEdge = melinv(nextEdgeMel);
   rightEdge[nfilt-1] = determine_bin(nextEdge, deltaFreq);
-  NMatrix *fparams = new_nmatrix(nfilt, 5);
+  Cmat *fparams = cmat_new(nfilt, 5);
   for (i=0;i<nfilt;++i) {
       double initialFreqBin = determine_bin(leftEdge[i], deltaFreq);
       if (initialFreqBin < leftEdge[i]) {
@@ -128,10 +130,10 @@ NMatrix *make_bank_parameters(double srate, int nfft, int nfilt,
 
 // 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,
+Carr * 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);
+    Carr * filter = carr_new(nElements + 1);
     double height=1.0;
     double leftSlope = height / (center - left);
     double rightSlope = height / (center - right);

data/lib/cext/c_mfcc_16x8.c

@@ -0,0 +1,57 @@
+#include "c_noyes.h"
+
+// Mfcc16x8 is a convenience class that encapsulates an entire front end that
+// takes 16kHz audio and transforms it to work with 8kHz models.
+Mfcc16x8 * mfcc_16x8_new() {
+  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;
+  
+  Mfcc16x8 *self = malloc(sizeof(Mfcc16x8));
+  self->pre = new_preemphasizer(factor);
+  self->seg = new_segmenter(frame_size, shift);
+  self->ham = hamming_window_new(frame_size);
+  self->pow = new_power_spectrum(nfft);
+  self->mel = new_mel_filter(freq, nfft, nfilt, min_freq, max_freq);
+  self->log = log_compressor_new(log_zero);
+  self->dct = dct_new(dimensions, nfilt);
+  self->cmn = live_cmn_new(dimensions, cmn_init_mean, cmn_window_size, cmn_shift);
+  return self;
+}
+
+void mfcc_16x8_free(Mfcc16x8 *self) {
+  free(self->seg);
+  free(self->ham);
+  free(self->pow);
+  free(self->mel);
+  free(self->log);
+  free(self->dct);
+  free(self->cmn);
+  free(self);
+}
+
+Cmat *mfcc_16x8_apply(Mfcc16x8 *self, Carr * data) {
+  Cmat *M = NULL;
+  Cmat *N = NULL;
+  Carr *data1 = preemphasizer_apply(self->pre, data);
+  M = segmenter_apply(self->seg, data1); carr_free(data1);
+  if (!M)
+    return NULL;
+  N = hamming_window_apply(self->ham, M); cmat_free(M);
+  M = power_spectrum_apply(self->pow, N); cmat_free(N);
+  N = mel_filter_apply(self->mel, M); cmat_free(M);
+  M = log_compressor_apply(self->log, N); cmat_free(N);
+  N = dct_apply(self->dct, M); cmat_free(M);
+  M = live_cmn_apply(self->cmn, N); cmat_free(N);
+  return M;
+}