Diff [8212692b7d1df87a305b3fe5ac23ea343dd7fe04:f650860dacb65b347c215149b51e224d9061dbff] for / – aubio

TabularUnified examples/aubiomfcc.c ¶

-                      r8212692
+                      rf650860
 static int aubio_process(smpl_t **input, smpl_t **output, int nframes) {
+  unsigned int i;       /*channels*/
   unsigned int j;       /*frames*/
   for (j=0;j<(unsigned)nframes;j++) {
     if(usejack) {
+      /* write input to datanew */
+      fvec_write_sample(ibuf, input[0][j], pos);
+      /* put synthnew in output */
+      output[0][j] = fvec_read_sample(obuf, pos);
+      for (i=0;i<channels;i++) {
+        /* write input to datanew */
+        fvec_write_sample(ibuf, input[i][j], i, pos);
+        /* put synthnew in output */
+        output[i][j] = fvec_read_sample(obuf, i, pos);
+      }
+    }
     /*time for fft*/
 …
       //compute mag spectrum
       aubio_pvoc_do (pv, ibuf, fftgrain);
+      aubio_pvoc_do (pv,ibuf, fftgrain);
       //compute mfccs
 …
         outmsg("%f\t",frames*overlap_size/(float)samplerate);
         for (coef_cnt = 0; coef_cnt < n_coefs; coef_cnt++) {
             outmsg("%f ", fvec_read_sample (mfcc_out, coef_cnt) );
+            outmsg("%f ", fvec_read_sample (mfcc_out, 0, coef_cnt) );
+        }
         outmsg("\n");
 …
   /* phase vocoder */
   pv = new_aubio_pvoc (buffer_size, overlap_size);
+  pv = new_aubio_pvoc (buffer_size, overlap_size, channels);
   fftgrain = new_cvec (buffer_size);
+  fftgrain = new_cvec (buffer_size, channels);
   //populating the filter
   mfcc = new_aubio_mfcc(buffer_size, n_filters, n_coefs, samplerate);
   mfcc_out = new_fvec(n_coefs);
+  mfcc_out = new_fvec(n_coefs,channels);
   //process

TabularUnified examples/aubionotes.c ¶

-                      r8212692
+                      rf650860
 */
 #define AUBIO_UNSTABLE 1 // for fvec_median
+#define AUBIO_UNSTABLE 1 // for fvec_median_channel
 #include "utils.h"
 …
 static int aubio_process(smpl_t **input, smpl_t **output, int nframes) {
+  unsigned int i;       /*channels*/
   unsigned int j;       /*frames*/
   for (j=0;j<(unsigned)nframes;j++) {
     if(usejack) {
+      /* write input to datanew */
+      fvec_write_sample(ibuf, input[0][j], pos);
+      /* put synthnew in output */
+      output[0][j] = fvec_read_sample(obuf, pos);
+      for (i=0;i<channels;i++) {
+        /* write input to datanew */
+        fvec_write_sample(ibuf, input[i][j], i, pos);
+        /* put synthnew in output */
+        output[i][j] = fvec_read_sample(obuf, i, pos);
+      }
+    }
     /*time for fft*/
 …
       aubio_pitch_do (pitchdet, ibuf, pitch_obuf);
       pitch = fvec_read_sample(pitch_obuf, 0);
+      pitch = fvec_read_sample(pitch_obuf, 0, 0);
       if(median){
               note_append(note_buffer, pitch);
 …
       /* curlevel is negatif or 1 if silence */
       curlevel = aubio_level_detection(ibuf, silence);
       if (fvec_read_sample(onset, 0)) {
+      if (fvec_read_sample(onset, 0, 0)) {
               /* test for silence */
               if (curlevel == 1.) {
 …
                       for (pos = 0; pos < overlap_size; pos++){
                               obuf->data[pos] = woodblock->data[pos];
+                              obuf->data[0][pos] = woodblock->data[0][pos];
+                      }
+              }
 …
               } // if median
         for (pos = 0; pos < overlap_size; pos++)
           obuf->data[pos] = 0.;
+          obuf->data[0][pos] = 0.;
+      }
       /* end of block loop */
 …
   uint_t i = 0;
   for (i = 0; i < note_buffer->length - 1; i++) {
     note_buffer->data[i] = note_buffer->data[i + 1];
+    note_buffer->data[0][i] = note_buffer->data[0][i + 1];
+  }
   note_buffer->data[note_buffer->length - 1] = curnote;
+  note_buffer->data[0][note_buffer->length - 1] = curnote;
   return;
+}
 …
   uint_t i;
   for (i = 0; i < note_buffer->length; i++) {
     note_buffer2->data[i] = note_buffer->data[i];
+    note_buffer2->data[0][i] = note_buffer->data[0][i];
+  }
   return fvec_median (note_buffer2);
+  return fvec_median_channel (note_buffer2, 0);
+}
 …
   examples_common_init(argc,argv);
+  o = new_aubio_onset (onset_mode, buffer_size, overlap_size, samplerate);
+  o = new_aubio_onset (onset_mode, buffer_size, overlap_size, channels,
+          samplerate);
   if (threshold != 0.) aubio_onset_set_threshold (o, threshold);
   onset = new_fvec (1);
+  onset = new_fvec (1, channels);
   pitchdet = new_aubio_pitch (pitch_mode, buffer_size * 4,
           overlap_size, samplerate);
+          overlap_size, channels, samplerate);
   aubio_pitch_set_tolerance (pitchdet, 0.7);
   pitch_obuf = new_fvec (1);
+  pitch_obuf = new_fvec (1, channels);
   if (median) {
       note_buffer = new_fvec (median);
       note_buffer2 = new_fvec (median);
+      note_buffer = new_fvec (median, 1);
+      note_buffer2 = new_fvec (median, 1);
+  }

TabularUnified examples/aubioonset.c ¶

-                      r8212692
+                      rf650860
   for (j=0;j<(unsigned)nframes;j++) {
     if(usejack) {
+      /* write input to datanew */
+      fvec_write_sample(ibuf, input[0][j], pos);
+      /* put synthnew in output */
+      output[0][j] = fvec_read_sample(obuf, pos);
+      for (i=0;i<channels;i++) {
+        /* write input to datanew */
+        fvec_write_sample(ibuf, input[i][j], i, pos);
+        /* put synthnew in output */
+        output[i][j] = fvec_read_sample(obuf, i, pos);
+      }
+    }
     /*time for fft*/
     if (pos == overlap_size-1) {
+    if (pos == overlap_size-1) {
       /* block loop */
       aubio_onset_do (o, ibuf, onset);
       if ( fvec_read_sample(onset, 0) ) {
+      if (fvec_read_sample(onset, 0, 0)) {
         fvec_copy (woodblock, obuf);
       } else {
 …
+}
+static void
+process_print (void)
+{
+  /* output times in seconds, taking back some delay to ensure the label is
+   * _before_ the actual onset */
+  if (!verbose && usejack)
+    return;
+  smpl_t onset_found = fvec_read_sample (onset, 0);
+  if (onset_found) {
+    if (frames >= 4) {
+      outmsg ("%f\n", (frames - frames_delay + onset_found)
+          * overlap_size / (float) samplerate);
+    } else if (frames < frames_delay) {
+      outmsg ("%f\n", 0.);
+    }
+  }
+static void process_print (void) {
+      /* output times in seconds, taking back some
+       * delay to ensure the label is _before_ the
+       * actual onset */
+      if (!verbose && usejack) return;
+      smpl_t onset_found = fvec_read_sample(onset, 0, 0);
+      if (onset_found) {
+        if(frames >= 4) {
+          outmsg("%f\n",(frames - frames_delay + onset_found)
+                  *overlap_size/(float)samplerate);
+        } else if (frames < frames_delay) {
+          outmsg("%f\n",0.);
+        }
+      }
+}
 …
   examples_common_init(argc,argv);
+  o = new_aubio_onset (onset_mode, buffer_size, overlap_size, samplerate);
+  o = new_aubio_onset (onset_mode, buffer_size, overlap_size, channels,
+          samplerate);
   if (threshold != 0.) aubio_onset_set_threshold (o, threshold);
   onset = new_fvec (1);
+  onset = new_fvec (1, channels);
   examples_common_process(aubio_process,process_print);

TabularUnified examples/aubiopitch.c ¶

-                      r8212692
+                      rf650860
 static int aubio_process(smpl_t **input, smpl_t **output, int nframes) {
+  unsigned int i;       /*channels*/
   unsigned int j;       /*frames*/
   for (j=0;j<(unsigned)nframes;j++) {
     if(usejack) {
+      /* write input to datanew */
+      fvec_write_sample(ibuf, input[0][j], pos);
+      /* put synthnew in output */
+      output[0][j] = fvec_read_sample(obuf, pos);
+      for (i=0;i<channels;i++) {
+        /* write input to datanew */
+        fvec_write_sample(ibuf, input[i][j], i, pos);
+        /* put synthnew in output */
+        output[i][j] = fvec_read_sample(obuf, i, pos);
+      }
+    }
     /*time for fft*/
 …
       /* block loop */
       aubio_pitch_do (o, ibuf, pitch);
       if (fvec_read_sample(pitch, 0)) {
+      if (fvec_read_sample(pitch, 0, 0)) {
         for (pos = 0; pos < overlap_size; pos++){
           // TODO, play sine at this freq
 …
 static void process_print (void) {
       if (!verbose && usejack) return;
       smpl_t pitch_found = fvec_read_sample(pitch, 0);
+      smpl_t pitch_found = fvec_read_sample(pitch, 0, 0);
       outmsg("%f %f\n",(frames)
               *overlap_size/(float)samplerate, pitch_found);
 …
   examples_common_init(argc,argv);
+  o = new_aubio_pitch (onset_mode, buffer_size, overlap_size, samplerate);
+  pitch = new_fvec (1);
+  o = new_aubio_pitch (onset_mode, buffer_size, overlap_size, channels,
+          samplerate);
+  pitch = new_fvec (1, channels);
   examples_common_process(aubio_process,process_print);

TabularUnified examples/aubioquiet.c ¶

-                      r8212692
+                      rf650860
 int aubio_process(smpl_t **input, smpl_t **output, int nframes);
 int aubio_process(smpl_t **input, smpl_t **output, int nframes) {
+  unsigned int i;       /*channels*/
   unsigned int j;       /*frames*/
   for (j=0;j<(unsigned)nframes;j++) {
     if(usejack) {
+      /* write input to datanew */
+      fvec_write_sample(ibuf, input[0][j], pos);
+      /* put synthnew in output */
+      output[0][j] = fvec_read_sample(obuf, pos);
+      for (i=0;i<channels;i++) {
+        /* write input to datanew */
+        fvec_write_sample(ibuf, input[i][j], i, pos);
+        /* put synthnew in output */
+        output[i][j] = fvec_read_sample(obuf, i, pos);
+      }
+    }
     /*time for fft*/
 …
       /* test for silence */
       if (aubio_silence_detection(ibuf, silence)==1) {
         if (wassilence==1) issilence = 1;
         else issilence = 2;
+        if (wassilence==1) issilence = 1;
+        else issilence = 2;
         wassilence=1;
       } else {
         if (wassilence<=0) issilence = 0;
         else issilence = -1;
+        if (wassilence<=0) issilence = 0;
+        else issilence = -1;
         wassilence=0;
+      }

TabularUnified examples/aubiotrack.c ¶

-                      r8212692
+                      rf650860
 static int aubio_process(smpl_t **input, smpl_t **output, int nframes) {
+  unsigned int i;       /*channels*/
   unsigned int j;       /*frames*/
   for (j=0;j<(unsigned)nframes;j++) {
     if(usejack) {
+      /* write input to datanew */
+      fvec_write_sample(ibuf, input[0][j], pos);
+      /* put synthnew in output */
+      output[0][j] = fvec_read_sample(obuf, pos);
+      for (i=0;i<channels;i++) {
+        /* write input to datanew */
+        fvec_write_sample(ibuf, input[i][j], i, pos);
+        /* put synthnew in output */
+        output[i][j] = fvec_read_sample(obuf, i, pos);
+      }
+    }
     /*time for fft*/
 …
       /* block loop */
       aubio_tempo_do (bt,ibuf,tempo_out);
       istactus = fvec_read_sample (tempo_out, 0);
       isonset = fvec_read_sample (tempo_out, 1);
+      istactus = fvec_read_sample (tempo_out, 0, 0);
+      isonset = fvec_read_sample (tempo_out, 0, 1);
       if (istactus > 0.) {
         fvec_copy (woodblock, obuf);
 …
   examples_common_init(argc,argv);
   tempo_out = new_fvec(2);
   bt = new_aubio_tempo(onset_mode,buffer_size,overlap_size, samplerate);
+  tempo_out = new_fvec(2,channels);
+  bt = new_aubio_tempo(onset_mode,buffer_size,overlap_size,channels, samplerate);
   if (threshold != 0.) aubio_tempo_set_threshold (bt, threshold);

TabularUnified examples/sndfileio.c ¶

-                      r8212692
+                      rf650860
         aubio_sndfile_t * f = AUBIO_NEW(aubio_sndfile_t);
         f->samplerate    = fmodel->samplerate;
         f->channels      = 1; //fmodel->channels;
+        f->channels      = fmodel->channels;
         f->format        = fmodel->format;
         aubio_sndfile_open_wo(f, outputname);
 …
 /* read frames from file in data
  *  return the number of frames actually read */
 int aubio_sndfile_read(aubio_sndfile_t * f, int frames, fvec_t ** read) {
+int aubio_sndfile_read(aubio_sndfile_t * f, int frames, fvec_t * read) {
         sf_count_t read_frames;
         int i,j, channels = f->channels;
 …
         /* de-interleaving data  */
         for (i=0; i<channels; i++) {
                 pread = (smpl_t *)fvec_get_data(read[i]);
+                pread = (smpl_t *)fvec_get_channel(read,i);
                 for (j=0; j<aread; j++) {
                         pread[j] = (smpl_t)f->tmpdata[channels*j+i];
 …
+}
-int
-aubio_sndfile_read_mono (aubio_sndfile_t * f, int frames, fvec_t * read)
+{
-  sf_count_t read_frames;
-  int i, j, channels = f->channels;
-  int nsamples = frames * channels;
-  int aread;
-  smpl_t *pread;
-  /* allocate data for de/interleaving reallocated when needed. */
-  if (nsamples >= f->size) {
-    AUBIO_ERR ("Maximum aubio_sndfile_read buffer size exceeded.");
-    return -1;
-    /*
-    AUBIO_FREE(f->tmpdata);
-    f->tmpdata = AUBIO_ARRAY(float,nsamples);
-    */
+  }
-  //f->size = nsamples;
-  /* do actual reading */
-  read_frames = sf_read_float (f->handle, f->tmpdata, nsamples);
-  aread = (int) FLOOR (read_frames / (float) channels);
-  /* de-interleaving data  */
-  pread = (smpl_t *) fvec_get_data (read);
-  for (i = 0; i < channels; i++) {
-    for (j = 0; j < aread; j++) {
-      pread[j] += (smpl_t) f->tmpdata[channels * j + i];
+    }
+  }
-  for (j = 0; j < aread; j++) {
-    pread[j] /= (smpl_t)channels;
+  }
-  return aread;
+}
 /* write 'frames' samples to file from data
  *   return the number of frames actually written
  */
 int aubio_sndfile_write(aubio_sndfile_t * f, int frames, fvec_t ** write) {
+int aubio_sndfile_write(aubio_sndfile_t * f, int frames, fvec_t * write) {
         sf_count_t written_frames = 0;
         int i, j,       channels = f->channels;
 …
         /* interleaving data  */
         for (i=0; i<channels; i++) {
                 pwrite = (smpl_t *)fvec_get_data(write[i]);
+                pwrite = (smpl_t *)fvec_get_channel(write,i);
                 for (j=0; j<frames; j++) {
                         f->tmpdata[channels*j+i] = (float)pwrite[j];

TabularUnified examples/sndfileio.h ¶

-                      r8212692
+                      rf650860
  * Read frames data from file
  */
 int aubio_sndfile_read(aubio_sndfile_t * file, int frames, fvec_t ** read);
+int aubio_sndfile_read(aubio_sndfile_t * file, int frames, fvec_t * read);
 /**
  * Write data of length frames to file
  */
 int aubio_sndfile_write(aubio_sndfile_t * file, int frames, fvec_t ** write);
+int aubio_sndfile_write(aubio_sndfile_t * file, int frames, fvec_t * write);
 /**
  * Close file and delete file object

TabularUnified examples/utils.c ¶

-                      r8212692
+                      rf650860
 uint_t buffer_size = 512;       //1024;
 uint_t overlap_size = 256;      //512;
+uint_t channels = 1;
 uint_t samplerate = 44100;
 …
     if (verbose)
       aubio_sndfile_info (file);
+    channels = aubio_sndfile_channels (file);
     samplerate = aubio_sndfile_samplerate (file);
     if (output_filename != NULL)
 …
 examples_common_del (void)
+{
-  uint_t i;
   del_fvec (ibuf);
   del_fvec (obuf);
 …
 #if HAVE_JACK
     debug ("Jack init ...\n");
     jack_setup = new_aubio_jack (1, 1,
+    jack_setup = new_aubio_jack (channels, channels,
 , 1, (aubio_process_func_t) process_func);
     debug ("Jack activation ...\n");
 …
     frames = 0;
     while ((signed) overlap_size ==
         aubio_sndfile_read_mono (file, overlap_size, ibuf)) {
       process_func (&ibuf->data, &obuf->data, overlap_size);
+    while ((signed) overlap_size == aubio_sndfile_read (file, overlap_size,
+            ibuf)) {
+      process_func (ibuf->data, obuf->data, overlap_size);
       print ();
       if (output_filename != NULL) {
         aubio_sndfile_write (fileout, overlap_size, &obuf);
+        aubio_sndfile_write (fileout, overlap_size, obuf);
+      }
       frames++;
 …
   fvec_zeros(obuf);
   for (i = 0; (signed) i < frames_delay; i++) {
     process_func (&ibuf->data, &obuf->data, overlap_size);
+    process_func (ibuf->data, obuf->data, overlap_size);
     print ();
+  }

TabularUnified examples/utils.h ¶

r8212692	rf650860
74	74	extern uint_t buffer_size;
75	75	extern uint_t overlap_size;
	76	extern uint_t channels;
76	77	extern uint_t samplerate;
77	78

TabularUnified interfaces/python/aubio-types.h ¶

-                      r8212692
+                      rf650860
 #include <aubio.h>
 #define Py_default_vector_length 1024
 #define Py_default_vector_height 1
+#define Py_default_vector_length   1024
+#define Py_default_vector_channels 1
 #define Py_aubio_default_samplerate 44100
 …
 #endif
+// special python type for cvec
+/**
+Defining this constant to 1 will allow PyAubio_CastToFvec to convert from data
+types different than NPY_FLOAT to and fvec, and therefore creating a copy of
+it.
+*/
+#define AUBIO_DO_CASTING 0
+typedef struct
+{
+  PyObject_HEAD
+  fvec_t * o;
+  uint_t length;
+  uint_t channels;
+} Py_fvec;
+extern PyTypeObject Py_fvecType;
+extern PyObject *PyAubio_FvecToArray (Py_fvec * self);
+extern PyObject *PyAubio_CFvecToArray (fvec_t * self);
+extern Py_fvec *PyAubio_ArrayToFvec (PyObject * self);
 typedef struct
+{
 …
 } Py_cvec;
 extern PyTypeObject Py_cvecType;
+extern PyObject *PyAubio_CvecToArray (Py_cvec * self);
+extern Py_cvec *PyAubio_ArrayToCvec (PyObject * self);
-// defined in aubio-proxy.c
-extern PyObject *PyAubio_CFvecToArray (fvec_t * self);
-extern fvec_t *PyAubio_ArrayToCFvec (PyObject * self);
-extern Py_cvec *PyAubio_CCvecToPyCvec (cvec_t * self);
-extern cvec_t *PyAubio_ArrayToCCvec (PyObject *input);
-extern PyObject *PyAubio_CFmatToArray (fmat_t * self);
-extern fmat_t *PyAubio_ArrayToCFmat (PyObject *input);
-// hand written wrappers
 extern PyTypeObject Py_filterType;
 …
 extern PyTypeObject Py_pvocType;

TabularUnified interfaces/python/aubiomodule.c ¶

-                      r8212692
+                      rf650860
+{
   PyObject *input;
   fvec_t *vec;
+  Py_fvec *vec;
   smpl_t alpha;
   PyObject *result;
 …
+  }
   vec = PyAubio_ArrayToCFvec (input);
+  vec = PyAubio_ArrayToFvec (input);
   if (vec == NULL) {
 …
   // compute the function
   result = Py_BuildValue ("f", fvec_alpha_norm (vec, alpha));
+  result = Py_BuildValue ("f", fvec_alpha_norm (vec->o, alpha));
   if (result == NULL) {
     return NULL;
 …
+{
   PyObject *input;
   fvec_t *vec;
+  Py_fvec *vec;
   PyObject *result;
 …
+  }
   vec = PyAubio_ArrayToCFvec (input);
+  vec = PyAubio_ArrayToFvec (input);
   if (vec == NULL) {
 …
   // compute the function
   result = Py_BuildValue ("f", aubio_zero_crossing_rate (vec));
+  result = Py_BuildValue ("f", aubio_zero_crossing_rate (vec->o));
   if (result == NULL) {
     return NULL;
 …
 static char Py_min_removal_doc[] = "compute zero crossing rate";
 static PyObject *
+static PyObject *
 Py_min_removal(PyObject * self, PyObject * args)
+{
   PyObject *input;
   fvec_t *vec;
+  Py_fvec *vec;
   if (!PyArg_ParseTuple (args, "O:min_removal", &input)) {
 …
+  }
   vec = PyAubio_ArrayToCFvec (input);
+  vec = PyAubio_ArrayToFvec (input);
   if (vec == NULL) {
 …
   // compute the function
   fvec_min_removal (vec);
+  fvec_min_removal (vec->o);
   // since this function does not return, we could return None
   //return Py_None;
   // however it is convenient to return the modified vector
   return (PyObject *) PyAubio_CFvecToArray(vec);
+  // however it is convenient to return the modified vector
+  return (PyObject *) PyAubio_FvecToArray(vec);
   // or even without converting it back to an array
   //Py_INCREF(vec);
 …
 static PyMethodDef aubio_methods[] = {
   {"alpha_norm", Py_alpha_norm, METH_VARARGS, Py_alpha_norm_doc},
   {"zero_crossing_rate", Py_zero_crossing_rate, METH_VARARGS,
+  {"zero_crossing_rate", Py_zero_crossing_rate, METH_VARARGS,
     Py_zero_crossing_rate_doc},
   {"min_removal", Py_min_removal, METH_VARARGS, Py_min_removal_doc},
 …
   int err;
+  if (   (PyType_Ready (&Py_cvecType) < 0)
+      || (PyType_Ready (&Py_filterType) < 0)
+      || (PyType_Ready (&Py_filterbankType) < 0)
+      || (PyType_Ready (&Py_fftType) < 0)
+      || (PyType_Ready (&Py_pvocType) < 0)
+  if ((PyType_Ready (&Py_fvecType) < 0)
+      || (PyType_Ready (&Py_cvecType) < 0)
+      || (PyType_Ready (&Py_filterType) < 0)
+      || (PyType_Ready (&Py_filterbankType) < 0)
+      || (PyType_Ready (&Py_fftType) < 0)
+      || (PyType_Ready (&Py_pvocType) < 0)
       // generated objects
       || (generated_types_ready() < 0 )
 …
+  }
+  Py_INCREF (&Py_fvecType);
+  PyModule_AddObject (m, "fvec", (PyObject *) & Py_fvecType);
   Py_INCREF (&Py_cvecType);
   PyModule_AddObject (m, "cvec", (PyObject *) & Py_cvecType);

TabularUnified interfaces/python/aubiowraphell.h ¶

-                      r8212692
+                      rf650860
 // some more helpers
 #define AUBIO_NEW_VEC(name, type, lengthval) \
+#define AUBIO_NEW_VEC(name, type, lengthval, channelsval) \
   name = (type *) PyObject_New (type, & type ## Type); \
+  name->channels = channelsval; \
   name->length = lengthval;

TabularUnified interfaces/python/gen_pyobject.py ¶

-                      r8212692
+                      rf650860
 # move into the C library at some point.
 defaultsizes = {
     'resampler':    'input->length * self->ratio',
     'specdesc':     '1',
     'onset':        '1',
     'pitchyin':     '1',
     'pitchyinfft':  '1',
     'pitchschmitt': '1',
     'pitchmcomb':   '1',
     'pitchfcomb':   '1',
     'pitch':        '1',
     'tss':          'self->hop_size',
     'mfcc':         'self->n_coeffs',
     'beattracking': 'self->hop_size',
     'tempo':        '1',
     'peakpicker':   '1',
+    'resampler':    ('input->length * self->ratio', 'input->channels'),
+    'specdesc':     ('1', 'fftgrain->channels'),
+    'onset':        ('1', 'self->channels'),
+    'pitchyin':     ('1', 'in->channels'),
+    'pitchyinfft':  ('1', 'in->channels'),
+    'pitchschmitt': ('1', 'in->channels'),
+    'pitchmcomb':   ('1', 'self->channels'),
+    'pitchfcomb':   ('1', 'self->channels'),
+    'pitch':        ('1', 'self->channels'),
+    'tss':          ('self->hop_size', 'self->channels'),
+    'mfcc':         ('self->n_coeffs', 'in->channels'),
+    'beattracking': ('self->hop_size', 'self->channels'),
+    'tempo':        ('1', 'self->channels'),
+    'peakpicker':   ('1', 'self->channels'),
+}
 …
     'hop_size': 'Py_default_vector_length / 2',
     # these should be alright
+    'channels': 'Py_default_vector_channels',
     'samplerate': 'Py_aubio_default_samplerate',
     # now for the non obvious ones
 …
+}
+# python to aubio
+# aubio to pyaubio
+aubio2pyaubio = {
+    'fvec_t*': 'Py_fvec',
+    'cvec_t*': 'Py_cvec',
+}
+# array to aubio
 aubiovecfrompyobj = {
     'fvec_t*': 'PyAubio_ArrayToCFvec',
     'cvec_t*': 'PyAubio_ArrayToCCvec',
+}
 # aubio to python
+    'fvec_t*': 'PyAubio_ArrayToFvec',
+    'cvec_t*': 'PyAubio_ArrayToCvec',
+}
+# aubio to array
 aubiovectopyobj = {
+    'fvec_t*': 'PyAubio_FvecToArray',
+    'cvec_t*': 'PyAubio_CvecToArray',
+}
+aubiovectopyobj_new = {
     'fvec_t*': 'PyAubio_CFvecToArray',
     'cvec_t*': 'PyAubio_CCvecToPyCvec',
+    'cvec_t*': 'PyAubio_CCvecToArray',
     'smpl_t': 'PyFloat_FromDouble',
+}
 …
     newparams = get_params_types_names(newfunc)
     # self->param1, self->param2, self->param3
+    if len(newparams):
+        selfparams = ', self->'+', self->'.join([p[1] for p in newparams])
+    else:
+        selfparams = ''
+    selfparams = ', self->'.join([p[1] for p in newparams])
     # "param1", "param2", "param3"
     paramnames = ", ".join(["\""+p[1]+"\"" for p in newparams])
 …
 Py_%(name)s_new (PyTypeObject * pytype, PyObject * args, PyObject * kwds)
+{
-  Py_%(name)s *self;
 """ % locals()
     for ptype, pname in newparams:
 …
 """ % locals()
     # now the actual PyArg_Parse
     if len(paramnames):
         s += """\
+    s += """\
+  Py_%(name)s *self;
   static char *kwlist[] = { %(paramnames)s, NULL };
 …
     return NULL;
+  }
-""" % locals()
-    s += """\
   self = (Py_%(name)s *) pytype->tp_alloc (pytype, 0);
 …
+}
 AUBIO_INIT(%(name)s %(selfparams)s)
+AUBIO_INIT(%(name)s, self->%(selfparams)s)
 AUBIO_DEL(%(name)s)
 …
     inputdefs = "\n  ".join(["PyObject * " + p[-1] + "_obj;" for p in inputparams])
     inputvecs = "\n  ".join(map(lambda p: \
                 p[0] + p[-1] + ";", inputparams))
+                aubio2pyaubio[p[0]]+" * " + p[-1] + ";", inputparams))
     parseinput = ""
     for p in inputparams:
 …
         #assert len(outputparams) == 1, \
         #    "too many output parameters"
         outputvecs = "\n  ".join([p[0] + p[-1] + ";" for p in outputparams])
+        outputvecs = "\n  ".join([aubio2pyaubio[p[0]]+" * " + p[-1] + ";" for p in outputparams])
         outputcreate = "\n  ".join(["""\
+  %(name)s = new_%(autype)s (%(length)s);""" % \
+    {'name': p[-1], 'pytype': p[0], 'autype': p[0][:-3],
+        'length': defaultsizes[name]} \
+AUBIO_NEW_VEC(%(name)s, %(pytype)s, %(length)s, %(channels)s)
+  %(name)s->o = new_%(autype)s (%(length)s, %(channels)s);""" % \
+    {'name': p[-1], 'pytype': aubio2pyaubio[p[0]], 'autype': p[0][:-3],
+        'length': defaultsizes[name][0], 'channels': defaultsizes[name][1]} \
         for p in outputparams])
         if len(outputparams) > 1:
 …
     # build the parameters for the  _do() call
     doparams_string = "self->o, " + ", ".join([p[-1] for p in doparams])
+    doparams_string = "self->o, " + ", ".join([p[-1]+"->o" for p in doparams])
     # put it all together
 …
             "get method has more than one parameter %s" % params
         getter_args = "self->o"
         returnval = "(PyObject *)" + aubiovectopyobj[out_type] + " (tmp)"
+        returnval = "(PyObject *)" + aubiovectopyobj_new[out_type] + " (tmp)"
         shortname = method_name.split(name+'_')[-1]
         method_defs += """\

TabularUnified interfaces/python/py-cvec.c ¶

-                      r8212692
+                      rf650860
 class cvec():
     def __init__(self, length = 1024):
+    def __init__(self, length = 1024, channels = 1):
         self.length = length
         self.norm = array(length)
         self.phas = array(length)
+        self.channels = channels
+        self.norm = array(length, channels)
+        self.phas = array(length, channels)
 */
 static char Py_cvec_doc[] = "cvec object";
 …
 Py_cvec_new (PyTypeObject * type, PyObject * args, PyObject * kwds)
+{
   int length= 0;
+  int length= 0, channels = 0;
   Py_cvec *self;
   static char *kwlist[] = { "length", NULL };
   if (!PyArg_ParseTupleAndKeywords (args, kwds, "|I", kwlist,
           &length)) {
+  static char *kwlist[] = { "length", "channels", NULL };
+  if (!PyArg_ParseTupleAndKeywords (args, kwds, "|II", kwlist,
+          &length, &channels)) {
     return NULL;
+  }
 …
   self->length = Py_default_vector_length / 2 + 1;
+  self->channels = Py_default_vector_channels;
   if (self == NULL) {
 …
+  }
+  if (channels > 0) {
+    self->channels = channels;
+  } else if (channels < 0) {
+    PyErr_SetString (PyExc_ValueError,
+        "can not use negative number of channels");
+    return NULL;
+  }
   return (PyObject *) self;
+}
 …
 Py_cvec_init (Py_cvec * self, PyObject * args, PyObject * kwds)
+{
   self->o = new_cvec ((self->length - 1) * 2);
+  self->o = new_cvec ((self->length - 1) * 2, self->channels);
   if (self->o == NULL) {
     return -1;
 …
   PyObject *result = NULL;
   format = PyString_FromString ("aubio cvec of %d elements");
+  format = PyString_FromString ("aubio cvec of %d elements with %d channels");
   if (format == NULL) {
     goto fail;
+  }
   args = Py_BuildValue ("I", self->length);
+  args = Py_BuildValue ("II", self->length, self->channels);
   if (args == NULL) {
     goto fail;
+  }
   cvec_print ( self->o );
+  //cvec_print ( self->o );
   result = PyString_Format (format, args);
 …
+}
+Py_cvec *
+PyAubio_ArrayToCvec (PyObject *input) {
+  PyObject *array;
+  Py_cvec *vec;
+  uint_t i;
+  // parsing input object into a Py_cvec
+  if (PyObject_TypeCheck (input, &Py_cvecType)) {
+    // input is an cvec, nothing else to do
+    vec = (Py_cvec *) input;
+  } else if (PyArray_Check(input)) {
+    // we got an array, convert it to an cvec
+    if (PyArray_NDIM (input) == 0) {
+      PyErr_SetString (PyExc_ValueError, "input array is a scalar");
+      goto fail;
+    } else if (PyArray_NDIM (input) > 2) {
+      PyErr_SetString (PyExc_ValueError,
+          "input array has more than two dimensions");
+      goto fail;
+    }
+    if (!PyArray_ISFLOAT (input)) {
+      PyErr_SetString (PyExc_ValueError, "input array should be float");
+      goto fail;
+#if AUBIO_DO_CASTING
+    } else if (PyArray_TYPE (input) != AUBIO_NPY_SMPL) {
+      // input data type is not float32, casting
+      array = PyArray_Cast ( (PyArrayObject*) input, AUBIO_NPY_SMPL);
+      if (array == NULL) {
+        PyErr_SetString (PyExc_IndexError, "failed converting to NPY_FLOAT");
+        goto fail;
+      }
+#else
+    } else if (PyArray_TYPE (input) != AUBIO_NPY_SMPL) {
+      PyErr_SetString (PyExc_ValueError, "input array should be float32");
+      goto fail;
+#endif
+    } else {
+      // input data type is float32, nothing else to do
+      array = input;
+    }
+    // create a new cvec object
+    vec = (Py_cvec*) PyObject_New (Py_cvec, &Py_cvecType);
+    if (PyArray_NDIM (array) == 1) {
+      PyErr_SetString (PyExc_ValueError,
+          "input array should be have at least two rows for norm and phas");
+      goto fail;
+    } else if (PyArray_NDIM (array) == 2) {
+      vec->channels = 1;
+      vec->length = PyArray_SIZE (array);
+    } else {
+      vec->channels = PyArray_DIM (array, 0) / 2;
+      vec->length = PyArray_DIM (array, 1);
+    }
+    // no need to really allocate cvec, just its struct member
+    // vec->o = new_cvec (vec->length, vec->channels);
+    vec->o = (cvec_t *)malloc(sizeof(cvec_t));
+    vec->o->length = vec->length; vec->o->channels = vec->channels;
+    vec->o->norm = (smpl_t**)malloc(vec->o->channels * sizeof(smpl_t*));
+    vec->o->phas = (smpl_t**)malloc(vec->o->channels * sizeof(smpl_t*));
+    // hat data[i] point to array line
+    for (i = 0; i < vec->channels; i+=2) {
+      vec->o->norm[i] = (smpl_t *) PyArray_GETPTR1 (array, i);
+      vec->o->phas[i] = (smpl_t *) PyArray_GETPTR1 (array, i+1);
+    }
+  } else {
+    PyErr_SetString (PyExc_ValueError, "can only accept array or cvec as input");
+    return NULL;
+  }
+  return vec;
+fail:
+  return NULL;
+}
+PyObject *
+PyAubio_CvecToArray (Py_cvec * self)
+{
+  PyObject *array = NULL;
+  uint_t i;
+  npy_intp dims[] = { self->o->length, 1 };
+  PyObject *concat = PyList_New (0), *tmp = NULL;
+  for (i = 0; i < self->channels; i++) {
+    tmp = PyArray_SimpleNewFromData (1, dims, NPY_FLOAT, self->o->norm[i]);
+    PyList_Append (concat, tmp);
+    Py_DECREF (tmp);
+    tmp = PyArray_SimpleNewFromData (1, dims, NPY_FLOAT, self->o->phas[i]);
+    PyList_Append (concat, tmp);
+    Py_DECREF (tmp);
+  }
+  array = PyArray_FromObject (concat, NPY_FLOAT, 2, 2);
+  Py_DECREF (concat);
+  return array;
+}
 PyObject *
 PyAubio_CvecNormToArray (Py_cvec * self)
+{
+  PyObject *array = NULL;
+  uint_t i;
   npy_intp dims[] = { self->o->length, 1 };
+  return PyArray_SimpleNewFromData (1, dims, NPY_FLOAT, self->o->norm);
+  PyObject *concat = PyList_New (0), *tmp = NULL;
+  for (i = 0; i < self->channels; i++) {
+    tmp = PyArray_SimpleNewFromData (1, dims, NPY_FLOAT, self->o->norm[i]);
+    PyList_Append (concat, tmp);
+    Py_DECREF (tmp);
+  }
+  array = PyArray_FromObject (concat, NPY_FLOAT, 2, 2);
+  Py_DECREF (concat);
+  return array;
+}
 …
 PyAubio_CvecPhasToArray (Py_cvec * self)
+{
+  PyObject *array = NULL;
+  uint_t i;
   npy_intp dims[] = { self->o->length, 1 };
+  return PyArray_SimpleNewFromData (1, dims, NPY_FLOAT, self->o->phas);
+  PyObject *concat = PyList_New (0), *tmp = NULL;
+  for (i = 0; i < self->channels; i++) {
+    tmp = PyArray_SimpleNewFromData (1, dims, NPY_FLOAT, self->o->phas[i]);
+    PyList_Append (concat, tmp);
+    Py_DECREF (tmp);
+  }
+  array = PyArray_FromObject (concat, NPY_FLOAT, 2, 2);
+  Py_DECREF (concat);
+  return array;
+}
 …
 Py_cvec_set_norm (Py_cvec * vec, PyObject *input, void * closure)
+{
+  uint_t i;
   PyObject * array;
   if (input == NULL) {
 …
     // check input array dimensions
     if (PyArray_NDIM (array) != 1) {
       PyErr_Format (PyExc_ValueError,
           "input array has %d dimensions, not 1",
           PyArray_NDIM (array));
       goto fail;
     } else {
+    if (PyArray_NDIM (array) == 1) {
+      if (vec->channels != 1) {
+          PyErr_SetString (PyExc_ValueError,
+                  "input array should have more than one channel");
+          goto fail;
+      }
       if (vec->o->length != PyArray_SIZE (array)) {
           PyErr_Format (PyExc_ValueError,
 …
           goto fail;
+      }
+    }
+    vec->o->norm = (smpl_t *) PyArray_GETPTR1 (array, 0);
+    } else {
+      if (vec->channels != PyArray_DIM (array, 0)) {
+          PyErr_Format (PyExc_ValueError,
+                  "input array has %d channels, but vector has %d channels",
+                  PyArray_DIM (array, 0), vec->channels);
+          goto fail;
+      }
+      if (vec->o->length != PyArray_DIM (array, 1)) {
+          PyErr_Format (PyExc_ValueError,
+                  "input array has length %d, but vector has length %d",
+                  PyArray_DIM (array, 1), vec->o->length);
+          goto fail;
+      }
+    }
+    for (i = 0; i < vec->channels; i++) {
+      vec->o->norm[i] = (smpl_t *) PyArray_GETPTR1 (array, i);
+    }
   } else {
 …
 Py_cvec_set_phas (Py_cvec * vec, PyObject *input, void * closure)
+{
+  uint_t i;
   PyObject * array;
   if (input == NULL) {
 …
     // check input array dimensions
     if (PyArray_NDIM (array) != 1) {
       PyErr_Format (PyExc_ValueError,
           "input array has %d dimensions, not 1",
           PyArray_NDIM (array));
       goto fail;
     } else {
+    if (PyArray_NDIM (array) == 1) {
+      if (vec->channels != 1) {
+          PyErr_SetString (PyExc_ValueError,
+                  "input array should have more than one channel");
+          goto fail;
+      }
       if (vec->o->length != PyArray_SIZE (array)) {
           PyErr_Format (PyExc_ValueError,
 …
           goto fail;
+      }
+    }
+    vec->o->phas = (smpl_t *) PyArray_GETPTR1 (array, 0);
+    } else {
+      if (vec->channels != PyArray_DIM (array, 0)) {
+          PyErr_Format (PyExc_ValueError,
+                  "input array has %d channels, but vector has %d channels",
+                  PyArray_DIM (array, 0), vec->channels);
+          goto fail;
+      }
+      if (vec->o->length != PyArray_DIM (array, 1)) {
+          PyErr_Format (PyExc_ValueError,
+                  "input array has length %d, but vector has length %d",
+                  PyArray_DIM (array, 1), vec->o->length);
+          goto fail;
+      }
+    }
+    for (i = 0; i < vec->channels; i++) {
+      vec->o->phas[i] = (smpl_t *) PyArray_GETPTR1 (array, i);
+    }
   } else {
 …
 fail:
   return 1;
+}
+static Py_ssize_t
+Py_cvec_getchannels (Py_cvec * self)
+{
+  return self->channels;
+}
+static PyObject *
+Py_cvec_getitem (Py_cvec * self, Py_ssize_t index)
+{
+  PyObject *array;
+  if (index < 0 || index >= self->channels) {
+    PyErr_SetString (PyExc_IndexError, "no such channel");
+    return NULL;
+  }
+  npy_intp dims[] = { self->length, 1 };
+  array = PyArray_SimpleNewFromData (1, dims, NPY_FLOAT, self->o->norm[index]);
+  return array;
+}
+static int
+Py_cvec_setitem (Py_cvec * self, Py_ssize_t index, PyObject * o)
+{
+  PyObject *array;
+  if (index < 0 || index >= self->channels) {
+    PyErr_SetString (PyExc_IndexError, "no such channel");
+    return -1;
+  }
+  array = PyArray_FROM_OT (o, NPY_FLOAT);
+  if (array == NULL) {
+    PyErr_SetString (PyExc_ValueError, "should be an array of float");
+    goto fail;
+  }
+  if (PyArray_NDIM (array) != 1) {
+    PyErr_SetString (PyExc_ValueError, "should be a one-dimensional array");
+    goto fail;
+  }
+  if (PyArray_SIZE (array) != self->length) {
+    PyErr_SetString (PyExc_ValueError,
+        "should be an array of same length as target cvec");
+    goto fail;
+  }
+  self->o->norm[index] = (smpl_t *) PyArray_GETPTR1 (array, 0);
+  return 0;
+fail:
+  return -1;
+}
 …
   {"length", T_INT, offsetof (Py_cvec, length), READONLY,
       "length attribute"},
+  {"channels", T_INT, offsetof (Py_cvec, channels), READONLY,
+      "channels attribute"},
   {NULL}                        /* Sentinel */
 };
 static PyMethodDef Py_cvec_methods[] = {
+  {"__array__", (PyCFunction) PyAubio_CvecToArray, METH_NOARGS,
+      "Returns the content of this cvec as a numpy array"},
   {NULL}
 };
 …
 static PyGetSetDef Py_cvec_getseters[] = {
   {"norm", (getter)Py_cvec_get_norm, (setter)Py_cvec_set_norm,
       "Numpy vector of shape (length,) containing the magnitude",
+      "Content of the magnitude of this cvec",
       NULL},
   {"phas", (getter)Py_cvec_get_phas, (setter)Py_cvec_set_phas,
       "Numpy vector of shape (length,) containing the phase",
+      "Content of the magnitude of this cvec",
       NULL},
   {NULL} /* sentinel */
 };
+static PySequenceMethods Py_cvec_tp_as_sequence = {
+  (lenfunc) Py_cvec_getchannels,        /* sq_length         */
+,                                    /* sq_concat         */
+,                                    /* sq_repeat         */
+  (ssizeargfunc) Py_cvec_getitem,       /* sq_item           */
+,                                    /* sq_slice          */
+  (ssizeobjargproc) Py_cvec_setitem,    /* sq_ass_item       */
+,                                    /* sq_ass_slice      */
+,                                    /* sq_contains       */
+,                                    /* sq_inplace_concat */
+,                                    /* sq_inplace_repeat */
+};
 PyTypeObject Py_cvecType = {
 …
   (reprfunc) Py_cvec_repr,      /* tp_repr           */
 ,                            /* tp_as_number      */
 , //&Py_cvec_tp_as_sequence,      /* tp_as_sequence    */
+  &Py_cvec_tp_as_sequence,      /* tp_as_sequence    */
 ,                            /* tp_as_mapping     */
 ,                            /* tp_hash           */

TabularUnified interfaces/python/py-fft.c ¶

-                      r8212692
+                      rf650860
 static char Py_fft_doc[] = "fft object";
 AUBIO_DECLARE(fft, uint_t win_s)
+AUBIO_DECLARE(fft, uint_t win_s; uint_t channels)
 //AUBIO_NEW(fft)
 …
 Py_fft_new (PyTypeObject * type, PyObject * args, PyObject * kwds)
+{
   int win_s = 0;
+  int win_s = 0, channels = 0;
   Py_fft *self;
   static char *kwlist[] = { "win_s", NULL };
+  static char *kwlist[] = { "win_s", "channels", NULL };
   if (!PyArg_ParseTupleAndKeywords (args, kwds, "|I", kwlist,
           &win_s)) {
+  if (!PyArg_ParseTupleAndKeywords (args, kwds, "|II", kwlist,
+          &win_s, &channels)) {
     return NULL;
+  }
 …
   self->win_s = Py_default_vector_length;
+  self->channels = Py_default_vector_channels;
   if (self == NULL) {
 …
+  }
+  if (channels > 0) {
+    self->channels = channels;
+  } else if (channels < 0) {
+    PyErr_SetString (PyExc_ValueError,
+        "can not use negative number of filters");
+    return NULL;
+  }
   return (PyObject *) self;
+}
 AUBIO_INIT(fft, self->win_s)
+AUBIO_INIT(fft, self->win_s, self->channels)
 AUBIO_DEL(fft)
 …
+{
   PyObject *input;
   fvec_t *vec;
   cvec_t *output;
+  Py_fvec *vec;
+  Py_cvec *output;
   if (!PyArg_ParseTuple (args, "O", &input)) {
 …
+  }
   vec = PyAubio_ArrayToCFvec (input);
+  vec = PyAubio_ArrayToFvec (input);
   if (vec == NULL) {
 …
+  }
+  output = new_cvec(((Py_fft *) self)->win_s);
+  output = (Py_cvec*) PyObject_New (Py_cvec, &Py_cvecType);
+  output->channels = vec->channels;
+  output->length = ((Py_fft *) self)->win_s;
+  output->o = new_cvec(((Py_fft *) self)->win_s, vec->channels);
   // compute the function
+  aubio_fft_do (((Py_fft *)self)->o, vec, output);
+  return (PyObject *)PyAubio_CCvecToPyCvec(output);
+  aubio_fft_do (((Py_fft *)self)->o, vec->o, output->o);
+  Py_INCREF(output);
+  return (PyObject *)output;
+  //return (PyObject *)PyAubio_CvecToArray(output);
+}
 …
   {"win_s", T_INT, offsetof (Py_fft, win_s), READONLY,
     "size of the window"},
+  {"channels", T_INT, offsetof (Py_fft, channels), READONLY,
+    "number of channels"},
 AUBIO_MEMBERS_STOP(fft)
 static PyObject *
 Py_fft_rdo(Py_fft * self, PyObject * args)
+Py_fft_rdo(PyObject * self, PyObject * args)
+{
   PyObject *input;
   cvec_t *vec;
   fvec_t *output;
+  Py_cvec *vec;
+  Py_fvec *output;
   if (!PyArg_ParseTuple (args, "O", &input)) {
 …
+  }
   vec = PyAubio_ArrayToCCvec (input);
+  vec = PyAubio_ArrayToCvec (input);
   if (vec == NULL) {
 …
+  }
+  output = new_fvec(self->win_s);
+  output = (Py_fvec*) PyObject_New (Py_fvec, &Py_fvecType);
+  output->channels = vec->channels;
+  output->length = ((Py_fft *) self)->win_s;
+  output->o = new_fvec(output->length, output->channels);
   // compute the function
   aubio_fft_rdo (((Py_fft *)self)->o, vec, output);
   return (PyObject *)PyAubio_CFvecToArray(output);
+  aubio_fft_rdo (((Py_fft *)self)->o, vec->o, output->o);
+  return (PyObject *)PyAubio_FvecToArray(output);
+}

TabularUnified interfaces/python/py-filter.c ¶

-                      r8212692
+                      rf650860
   aubio_filter_t * o;
   uint_t order;
+  uint_t channels;
 } Py_filter;
 …
 Py_filter_new (PyTypeObject * type, PyObject * args, PyObject * kwds)
+{
   int order= 0;
+  int order= 0, channels = 0;
   Py_filter *self;
   static char *kwlist[] = { "order", NULL };
+  static char *kwlist[] = { "order", "channels", NULL };
   if (!PyArg_ParseTupleAndKeywords (args, kwds, "|I", kwlist,
           &order)) {
+  if (!PyArg_ParseTupleAndKeywords (args, kwds, "|II", kwlist,
+          &order, &channels)) {
     return NULL;
+  }
 …
   self->order = 7;
+  self->channels = Py_default_vector_channels;
   if (order > 0) {
 …
+  }
+  if (channels > 0) {
+    self->channels = channels;
+  } else if (channels < 0) {
+    PyErr_SetString (PyExc_ValueError,
+        "can not use negative number of channels");
+    return NULL;
+  }
   return (PyObject *) self;
+}
 …
 Py_filter_init (Py_filter * self, PyObject * args, PyObject * kwds)
+{
   self->o = new_aubio_filter (self->order);
+  self->o = new_aubio_filter (self->order, self->channels);
   if (self->o == NULL) {
     return -1;
 …
 static PyObject *
 Py_filter_do(Py_filter * self, PyObject * args)
+Py_filter_do(PyObject * self, PyObject * args)
+{
   PyObject *input;
   fvec_t *vec;
+  Py_fvec *vec;
   if (!PyArg_ParseTuple (args, "O:digital_filter.do", &input)) {
 …
+  }
   vec = PyAubio_ArrayToCFvec (input);
+  vec = PyAubio_ArrayToFvec (input);
   if (vec == NULL) {
 …
   // compute the function
+  fvec_t * out = new_fvec(vec->length);
+  aubio_filter_do_outplace (self->o, vec, out);
+  return PyAubio_CFvecToArray(out);
+#if 1
+  aubio_filter_do (((Py_filter *)self)->o, vec->o);
+  Py_INCREF(vec);
+  return (PyObject *)vec;
+#else
+  Py_fvec *copy = (Py_fvec*) PyObject_New (Py_fvec, &Py_fvecType);
+  copy->o = new_fvec(vec->o->length, vec->o->channels);
+  aubio_filter_do_outplace (((Py_filter *)self)->o, vec->o, copy->o);
+  return (PyObject *)copy;
+#endif
+}
 …
   {"order", T_INT, offsetof (Py_filter, order), READONLY,
       "order of the filter"},
+  {"channels", T_INT, offsetof (Py_filter, channels), READONLY,
+      "number of channels"},
   {NULL}                        /* Sentinel */
 };

TabularUnified interfaces/python/py-filterbank.c ¶

-                      r8212692
+                      rf650860
+{
   PyObject *input;
   cvec_t *vec;
   fvec_t *out;
+  Py_cvec *vec;
+  Py_fvec *output;
   if (!PyArg_ParseTuple (args, "O", &input)) {
 …
+  }
   vec = PyAubio_ArrayToCCvec (input);
+  vec = PyAubio_ArrayToCvec (input);
   if (vec == NULL) {
 …
+  }
+  out = new_fvec (self->n_filters);
+  output = (Py_fvec*) PyObject_New (Py_fvec, &Py_fvecType);
+  output->channels = vec->channels;
+  output->length = self->n_filters;
+  output->o = new_fvec(self->n_filters, vec->channels);
   // compute the function
   aubio_filterbank_do (self->o, vec, out);
   return (PyObject *)PyAubio_CFvecToArray(out);
+  aubio_filterbank_do (self->o, vec->o, output->o);
+  return (PyObject *)PyAubio_FvecToArray(output);
+}
 …
   PyObject *input;
   uint_t samplerate;
   fvec_t *freqs;
+  Py_fvec *freqs;
   if (!PyArg_ParseTuple (args, "OI", &input, &samplerate)) {
     return NULL;
 …
+  }
   freqs = PyAubio_ArrayToCFvec (input);
+  freqs = PyAubio_ArrayToFvec (input);
   if (freqs == NULL) {
 …
   err = aubio_filterbank_set_triangle_bands (self->o,
       freqs, samplerate);
+      freqs->o, samplerate);
   if (err > 0) {
     PyErr_SetString (PyExc_ValueError,
 …
 Py_filterbank_get_coeffs (Py_filterbank * self, PyObject *unused)
+{
+  return (PyObject *)PyAubio_CFmatToArray(
+      aubio_filterbank_get_coeffs (self->o) );
+  Py_fvec *output = (Py_fvec *) PyObject_New (Py_fvec, &Py_fvecType);
+  output->channels = self->n_filters;
+  output->length = self->win_s / 2 + 1;
+  output->o = aubio_filterbank_get_coeffs (self->o);
+  return (PyObject *)PyAubio_FvecToArray(output);
+}

TabularUnified interfaces/python/py-phasevoc.c ¶

-                      r8212692
+                      rf650860
 static char Py_pvoc_doc[] = "pvoc object";
 AUBIO_DECLARE(pvoc, uint_t win_s; uint_t hop_s)
+AUBIO_DECLARE(pvoc, uint_t win_s; uint_t hop_s; uint_t channels)
 //AUBIO_NEW(pvoc)
 …
 Py_pvoc_new (PyTypeObject * type, PyObject * args, PyObject * kwds)
+{
   int win_s = 0, hop_s = 0;
+  int win_s = 0, hop_s = 0, channels = 0;
   Py_pvoc *self;
   static char *kwlist[] = { "win_s", "hop_s", NULL };
+  static char *kwlist[] = { "win_s", "hop_s", "channels", NULL };
   if (!PyArg_ParseTupleAndKeywords (args, kwds, "|II", kwlist,
           &win_s, &hop_s)) {
+  if (!PyArg_ParseTupleAndKeywords (args, kwds, "|III", kwlist,
+          &win_s, &hop_s, &channels)) {
     return NULL;
+  }
 …
   self->win_s = Py_default_vector_length;
   self->hop_s = Py_default_vector_length/2;
+  self->channels = Py_default_vector_channels;
   if (self == NULL) {
 …
+  }
+  if (channels > 0) {
+    self->channels = channels;
+  } else if (channels < 0) {
+    PyErr_SetString (PyExc_ValueError,
+        "can not use negative number of filters");
+    return NULL;
+  }
   return (PyObject *) self;
+}
 AUBIO_INIT(pvoc, self->win_s, self->hop_s)
+AUBIO_INIT(pvoc, self->win_s, self->hop_s, self->channels)
 AUBIO_DEL(pvoc)
 static PyObject *
 Py_pvoc_do(Py_pvoc * self, PyObject * args)
+Py_pvoc_do(PyObject * self, PyObject * args)
+{
   PyObject *input;
   fvec_t *vec;
   cvec_t *output;
+  Py_fvec *vec;
+  Py_cvec *output;
   if (!PyArg_ParseTuple (args, "O", &input)) {
 …
+  }
   vec = PyAubio_ArrayToCFvec (input);
+  vec = PyAubio_ArrayToFvec (input);
   if (vec == NULL) {
 …
+  }
+  output = new_cvec(self->win_s);
+  output = (Py_cvec*) PyObject_New (Py_cvec, &Py_cvecType);
+  output->channels = vec->channels;
+  output->length = ((Py_pvoc *) self)->win_s;
+  output->o = new_cvec(((Py_pvoc *) self)->win_s, vec->channels);
   // compute the function
+  aubio_pvoc_do (self->o, vec, output);
+  return (PyObject *)PyAubio_CCvecToPyCvec(output);
+  aubio_pvoc_do (((Py_pvoc *)self)->o, vec->o, output->o);
+  Py_INCREF(output);
+  return (PyObject *)output;
+  //return (PyObject *)PyAubio_CvecToArray(output);
+}
 …
   {"hop_s", T_INT, offsetof (Py_pvoc, hop_s), READONLY,
     "size of the hop"},
+  {"channels", T_INT, offsetof (Py_pvoc, channels), READONLY,
+    "number of channels"},
 AUBIO_MEMBERS_STOP(pvoc)
 static PyObject *
 Py_pvoc_rdo(Py_pvoc * self, PyObject * args)
+Py_pvoc_rdo(PyObject * self, PyObject * args)
+{
   PyObject *input;
   cvec_t *vec;
   fvec_t *output;
+  Py_cvec *vec;
+  Py_fvec *output;
   if (!PyArg_ParseTuple (args, "O", &input)) {
 …
+  }
   vec = PyAubio_ArrayToCCvec (input);
+  vec = PyAubio_ArrayToCvec (input);
   if (vec == NULL) {
 …
+  }
+  output = new_fvec(self->hop_s);
+  output = (Py_fvec*) PyObject_New (Py_fvec, &Py_fvecType);
+  output->channels = vec->channels;
+  output->length = ((Py_pvoc *) self)->hop_s;
+  output->o = new_fvec(output->length, output->channels);
   // compute the function
   aubio_pvoc_rdo (self->o, vec, output);
   return (PyObject *)PyAubio_CFvecToArray(output);
+  aubio_pvoc_rdo (((Py_pvoc *)self)->o, vec->o, output->o);
+  return (PyObject *)PyAubio_FvecToArray(output);
+}

TabularUnified interfaces/python/setup.py ¶

-                      r8212692
+                      rf650860
         Extension("_aubio",
             ["aubiomodule.c",
             "aubioproxy.c",
+            "py-fvec.c",
             "py-cvec.c",
-            # example without macro
             "py-filter.c",
             # macroised
+            # macroised
             "py-filterbank.c",
             "py-fft.c",

TabularUnified interfaces/python/test_aubio.py ¶

-                      r8212692
+                      rf650860
 from numpy.testing import TestCase, run_module_suite
+from numpy.testing import assert_equal
+from _aubio import *
+from numpy import array
+AUBIO_DO_CASTING = 0
 class aubiomodule_test_case(TestCase):
   def test_import(self):
+  def setUp(self):
     """ try importing aubio """
+    import aubio
+  def test_vector(self):
+    a = fvec()
+    a.length, a.channels
+    a[0]
+    array(a)
+    a = fvec(10)
+    a = fvec(1, 2)
+    array(a).T
+    a[0] = range(a.length)
+    a[1][0] = 2
+  def test_wrong_values(self):
+    self.assertRaises (ValueError, fvec, -10)
+    self.assertRaises (ValueError, fvec, 1, -1)
+    a = fvec(2, 3)
+    self.assertRaises (IndexError, a.__getitem__, 3)
+    self.assertRaises (IndexError, a[0].__getitem__, 2)
+  def test_alpha_norm_of_fvec(self):
+    a = fvec(2, 2)
+    self.assertEquals (alpha_norm(a, 1), 0)
+    a[0] = [1, 2]
+    self.assertEquals (alpha_norm(a, 1), 1.5)
+    a[1] = [1, 2]
+    self.assertEquals (alpha_norm(a, 1), 3)
+    a[0] = [0, 1]; a[1] = [1, 0]
+    self.assertEquals (alpha_norm(a, 2), 1)
+  def test_alpha_norm_of_array_of_float32(self):
+    # check scalar fails
+    a = array(1, dtype = 'float32')
+    self.assertRaises (ValueError, alpha_norm, a, 1)
+    # check 3d array fails
+    a = array([[[1,2],[3,4]]], dtype = 'float32')
+    self.assertRaises (ValueError, alpha_norm, a, 1)
+    # check 1d array
+    a = array(range(10), dtype = 'float32')
+    self.assertEquals (alpha_norm(a, 1), 4.5)
+    # check 2d array
+    a = array([range(10), range(10)], dtype = 'float32')
+    self.assertEquals (alpha_norm(a, 1), 9)
+  def test_alpha_norm_of_array_of_int(self):
+    a = array(1, dtype = 'int')
+    self.assertRaises (ValueError, alpha_norm, a, 1)
+    a = array([[[1,2],[3,4]]], dtype = 'int')
+    self.assertRaises (ValueError, alpha_norm, a, 1)
+    a = array(range(10), dtype = 'int')
+    self.assertRaises (ValueError, alpha_norm, a, 1)
+  def test_alpha_norm_of_array_of_string (self):
+    a = "hello"
+    self.assertRaises (ValueError, alpha_norm, a, 1)
+  def test_zero_crossing_rate(self):
+    a = array([0,1,-1], dtype='float32')
+    self.assertEquals (zero_crossing_rate(a), 1./3 )
+    a = array([0.]*100, dtype='float32')
+    self.assertEquals (zero_crossing_rate(a), 0 )
+    a = array([-1.]*100, dtype='float32')
+    self.assertEquals (zero_crossing_rate(a), 0 )
+    a = array([1.]*100, dtype='float32')
+    self.assertEquals (zero_crossing_rate(a), 0 )
+  def test_alpha_norm_of_array_of_float64(self):
+    # check scalar fail
+    a = array(1, dtype = 'float64')
+    self.assertRaises (ValueError, alpha_norm, a, 1)
+    # check 3d array fail
+    a = array([[[1,2],[3,4]]], dtype = 'float64')
+    self.assertRaises (ValueError, alpha_norm, a, 1)
+    if AUBIO_DO_CASTING:
+      # check float64 1d array fail
+      a = array(range(10), dtype = 'float64')
+      self.assertEquals (alpha_norm(a, 1), 4.5)
+      # check float64 2d array fail
+      a = array([range(10), range(10)], dtype = 'float64')
+      self.assertEquals (alpha_norm(a, 1), 9)
+    else:
+      # check float64 1d array fail
+      a = array(range(10), dtype = 'float64')
+      self.assertRaises (ValueError, alpha_norm, a, 1)
+      # check float64 2d array fail
+      a = array([range(10), range(10)], dtype = 'float64')
+      self.assertRaises (ValueError, alpha_norm, a, 1)
+  def test_fvec_min_removal_of_array(self):
+    a = array([20,1,19], dtype='float32')
+    b = min_removal(a)
+    assert_equal (array(b), [19, 0, 18])
+    assert_equal (b, [19, 0, 18])
+    assert_equal (a, b)
+    a[0] = 0
+    assert_equal (a, b)
+  def test_fvec_min_removal_of_array_float64(self):
+    a = array([20,1,19], dtype='float64')
+    if AUBIO_DO_CASTING:
+      b = min_removal(a)
+      assert_equal (array(b), [19, 0, 18])
+      assert_equal (b, [19, 0, 18])
+      #assert_equal (a, b)
+    else:
+      self.assertRaises (ValueError, min_removal, a)
+  def test_fvec_min_removal_of_fvec(self):
+    a = fvec(3, 1)
+    a[0] = [20, 1, 19]
+    b = min_removal(a)
+    assert_equal (array(b), [19, 0, 18])
+    assert_equal (b, [19, 0, 18])
+    assert_equal (a, b)
 if __name__ == '__main__':

TabularUnified interfaces/python/test_fft.py ¶

-                      r8212692
+                      rf650860
 from numpy.testing import assert_equal, assert_almost_equal
 # WARNING: numpy also has an fft object
 from aubio import fvec, fft, cvec
+from _aubio import fft, fvec, cvec
 from numpy import array, shape
 from math import pi
 …
   def test_members(self):
     f = fft()
+    assert_equal (f.win_s, 1024)
+    assert_equal ([f.win_s, f.channels], [1024, 1])
+    f = fft(2048, 4)
+    assert_equal ([f.win_s, f.channels], [2048, 4])
   def test_output_dimensions(self):
     """ check the dimensions of output """
     win_s = 1024
     timegrain = fvec(win_s)
     f = fft(win_s)
+    win_s, chan = 1024, 3
+    timegrain = fvec(win_s, chan)
+    f = fft(win_s, chan)
     fftgrain = f (timegrain)
+    assert_equal (array(fftgrain), 0)
+    assert_equal (shape(fftgrain), (chan * 2, win_s/2+1))
     assert_equal (fftgrain.norm, 0)
     assert_equal (shape(fftgrain.norm), (win_s/2+1,))
+    assert_equal (shape(fftgrain.norm), (chan, win_s/2+1))
     assert_equal (fftgrain.phas, 0)
     assert_equal (shape(fftgrain.phas), (win_s/2+1,))
+    assert_equal (shape(fftgrain.phas), (chan, win_s/2+1))
   def test_zeros(self):
     """ check the transform of zeros """
     win_s = 512
     timegrain = fvec(win_s)
     f = fft(win_s)
+    win_s, chan = 512, 3
+    timegrain = fvec(win_s, chan)
+    f = fft(win_s, chan)
     fftgrain = f(timegrain)
     assert_equal ( fftgrain.norm == 0, True )
 …
     from random import random
     from math import floor
     win_s = 256
+    win_s, chan = 256, 1
     i = floor(random()*win_s)
     impulse = pi * random()
     f = fft(win_s)
     timegrain = fvec(win_s)
     timegrain[i] = impulse
+    f = fft(win_s, chan)
+    timegrain = fvec(win_s, chan)
+    timegrain[0][i] = impulse
     fftgrain = f ( timegrain )
     #self.plot_this ( fftgrain.phas )
+    #self.plot_this ( fftgrain.phas[0] )
     assert_almost_equal ( fftgrain.norm, impulse, decimal = 6 )
     assert_equal ( fftgrain.phas <= pi, True)
 …
     from random import random
     from math import floor
     win_s = 256
+    win_s, chan = 256, 1
     i = 0
     impulse = -10.
     f = fft(win_s)
     timegrain = fvec(win_s)
     timegrain[i] = impulse
+    f = fft(win_s, chan)
+    timegrain = fvec(win_s, chan)
+    timegrain[0][i] = impulse
     fftgrain = f ( timegrain )
     #self.plot_this ( fftgrain.phas )
+    #self.plot_this ( fftgrain.phas[0] )
     assert_almost_equal ( fftgrain.norm, abs(impulse), decimal = 6 )
     if impulse < 0:
       # phase can be pi or -pi, as it is not unwrapped
       assert_almost_equal ( abs(fftgrain.phas[1:-1]) , pi, decimal = 6 )
       assert_almost_equal ( fftgrain.phas[0], pi, decimal = 6)
       assert_almost_equal ( fftgrain.phas[-1], pi, decimal = 6)
+      assert_almost_equal ( abs(fftgrain.phas[0][1:-1]) , pi, decimal = 6 )
+      assert_almost_equal ( fftgrain.phas[0][0], pi, decimal = 6)
+      assert_almost_equal ( fftgrain.phas[0][-1], pi, decimal = 6)
     else:
       assert_equal ( fftgrain.phas[1:-1] == 0, True)
       assert_equal ( fftgrain.phas[0] == 0, True)
       assert_equal ( fftgrain.phas[-1] == 0, True)
+      assert_equal ( fftgrain.phas[0][1:-1] == 0, True)
+      assert_equal ( fftgrain.phas[0][0] == 0, True)
+      assert_equal ( fftgrain.phas[0][-1] == 0, True)
     # now check the resynthesis
     synthgrain = f.rdo ( fftgrain )
 …
   def test_impulse_at_zero(self):
     """ check the transform of one impulse at a index 0 """
     win_s = 1024
+    """ check the transform of one impulse at a index 0 in one channel """
+    win_s, chan = 1024, 2
     impulse = pi
     f = fft(win_s)
     timegrain = fvec(win_s)
     timegrain[0] = impulse
+    f = fft(win_s, chan)
+    timegrain = fvec(win_s, chan)
+    timegrain[0][0] = impulse
     fftgrain = f ( timegrain )
     #self.plot_this ( fftgrain.phas )
     assert_equal ( fftgrain.phas[0], 0)
     assert_equal ( fftgrain.phas[1], 0)
+    assert_almost_equal (fftgrain.norm[0], impulse, decimal = 6 )
+    assert_almost_equal ( fftgrain.norm[0], impulse, decimal = 6 )
+    assert_equal ( fftgrain.norm[0], impulse)
   def test_rdo_before_do(self):
     """ check running fft.rdo before fft.do works """
     win_s = 1024
+    win_s, chan = 1024, 2
     impulse = pi
     f = fft(win_s)
     fftgrain = cvec(win_s)
+    f = fft(win_s, chan)
+    fftgrain = cvec(win_s, chan)
     t = f.rdo( fftgrain )
     assert_equal ( t, 0 )

TabularUnified interfaces/python/test_filter.py ¶

-                      r8212692
+                      rf650860
 from numpy.testing import TestCase, run_module_suite
 from numpy.testing import assert_equal, assert_almost_equal
 from aubio import fvec, digital_filter
+from _aubio import *
 from numpy import array
 …
   def test_members(self):
     f = digital_filter()
     assert_equal (f.order, 7)
     f = digital_filter(5)
     assert_equal (f.order, 5)
+    assert_equal ([f.channels, f.order], [1, 7])
+    f = digital_filter(5, 2)
+    assert_equal ([f.channels, f.order], [2, 5])
     f(fvec())
   def test_cweighting_error(self):
     f = digital_filter (2)
+    f = digital_filter (2, 1)
     self.assertRaises ( ValueError, f.set_c_weighting, 44100 )
     f = digital_filter (8)
+    f = digital_filter (8, 1)
     self.assertRaises ( ValueError, f.set_c_weighting, 44100 )
     f = digital_filter (5)
+    f = digital_filter (5, 1)
     self.assertRaises ( ValueError, f.set_c_weighting, 4000 )
     f = digital_filter (5)
+    f = digital_filter (5, 1)
     self.assertRaises ( ValueError, f.set_c_weighting, 193000 )
     f = digital_filter (7)
+    f = digital_filter (7, 1)
     self.assertRaises ( ValueError, f.set_a_weighting, 193000 )
     f = digital_filter (5)
+    f = digital_filter (5, 1)
     self.assertRaises ( ValueError, f.set_a_weighting, 192000 )
   def test_c_weighting(self):
     expected = array_from_text_file('c_weighting_test_simple.expected')
     f = digital_filter(5)
+    f = digital_filter(5, 1)
     f.set_c_weighting(44100)
     v = fvec(32)
     v[12] = .5
+    v[0][12] = .5
     u = f(v)
     assert_almost_equal (expected[1], u)
 …
   def test_a_weighting(self):
     expected = array_from_text_file('a_weighting_test_simple.expected')
     f = digital_filter(7)
+    f = digital_filter(7, 1)
     f.set_a_weighting(44100)
     v = fvec(32)
     v[12] = .5
+    v[0][12] = .5
     u = f(v)
     assert_almost_equal (expected[1], u)
 …
   def test_a_weighting_parted(self):
     expected = array_from_text_file('a_weighting_test_simple.expected')
     f = digital_filter(7)
+    f = digital_filter(7, 1)
     f.set_a_weighting(44100)
     v = fvec(16)
     v[12] = .5
+    v[0][12] = .5
     u = f(v)
     assert_almost_equal (expected[1][:16], u)

TabularUnified interfaces/python/test_filterbank.py ¶

-                      r8212692
+                      rf650860
 from numpy.testing import assert_equal, assert_almost_equal
 from numpy import array, shape
 from aubio import cvec, filterbank
+from _aubio import *
 class aubio_filter_test_case(TestCase):
 …
     a = f.get_coeffs()
     a.T
-    assert_equal(shape (a), (40, 512/2 + 1) )
   def test_other_slaney(self):
 …
       #print "sum is", sum(sum(a))
   def test_triangle_freqs_zeros(self):
+  def test_triangle_freqs(self):
     f = filterbank(9, 1024)
     freq_list = [40, 80, 200, 400, 800, 1600, 3200, 6400, 12800, 15000, 24000]
 …
     f.set_triangle_bands(freqs, 48000)
     f.get_coeffs().T
+    assert_equal ( f(cvec(1024)), 0)
+  def test_triangle_freqs_ones(self):
+    f = filterbank(9, 1024)
+    freq_list = [40, 80, 200, 400, 800, 1600, 3200, 6400, 12800, 15000, 24000]
+    freqs = array(freq_list, dtype = 'float32')
+    f.set_triangle_bands(freqs, 48000)
+    f.get_coeffs().T
+    assert_equal ( f(cvec(1024)), [0] * 9)
     spec = cvec(1024)
+    spec.norm[:] = 1
+    assert_almost_equal ( f(spec),
+            [ 0.02070313,  0.02138672,  0.02127604,  0.02135417,
+.02133301, 0.02133301,  0.02133311,  0.02133334,  0.02133345])
+    spec[0][40:100] = 100
+    #print f(spec)
 if __name__ == '__main__':

TabularUnified interfaces/python/test_onsetdetection.py ¶

-                      r8212692
+                      rf650860
 from numpy.testing import assert_equal, assert_almost_equal
 # WARNING: numpy also has an fft object
 from aubio import specdesc, cvec
+from _aubio import cvec, specdesc
 from numpy import array, shape, arange, zeros, log
 from math import pi
 …
     def test_members(self):
         o = specdesc()
+        assert_equal ([o.buf_size, o.method],
+            [1024, "default"])
+        assert_equal ([o.buf_size, o.channels, o.method],
+            [1024, 1, "default"])
+        o = specdesc("complex", 512, 2)
+        assert_equal ([o.buf_size, o.channels, o.method],
+            [512, 2, "complex"])
     def test_hfc(self):
 …
         a = arange(c.length, dtype='float32')
         c.norm = a
         assert_equal (a, c.norm)
+        assert_equal (a, c.norm[0])
         assert_equal ( sum(a*(a+1)), o(c))
 …
         a = arange(c.length, dtype='float32')
         c.norm = a
         assert_equal (a, c.norm)
+        assert_equal (a, c.norm[0])
         # the previous run was on zeros, so previous frames are still 0
         # so we have sqrt ( abs ( r2 ^ 2) ) == r2

TabularUnified interfaces/python/test_phasevoc.py ¶

-                      r8212692
+                      rf650860
 from numpy.testing import TestCase, run_module_suite
 from numpy.testing import assert_equal, assert_almost_equal
 from aubio import fvec, cvec, pvoc
+from _aubio import *
 from numpy import array, shape
 …
   def test_steps_two_channels(self):
     """ check the resynthesis of steps is correct """
     f = pvoc(1024, 512)
     t1 = fvec(512)
     t2 = fvec(512)
+    f = pvoc(1024, 512, 2)
+    t1 = fvec(512, 2)
+    t2 = fvec(512, 2)
     # positive step in first channel
     t1[100:200] = .1
+    t1[0][100:200] = .1
     # positive step in second channel
     t1[20:50] = -.1
+    t1[1][20:50] = -.1
     s1 = f(t1)
     r1 = f.rdo(s1)
 …
   def test_steps_three_random_channels(self):
     from random import random
+    f = pvoc(64, 16)
+    t0 = fvec(16)
+    t1 = fvec(16)
+    for i in xrange(16):
+        t1[i] = random() * 2. - 1.
+    f = pvoc(64, 16, 3)
+    t0 = fvec(16, 3)
+    t1 = fvec(16, 3)
+    for i in xrange(3):
+      for j in xrange(16):
+        t1[i][j] = random() * 2. - 1.
     t2 = f.rdo(f(t1))
     t2 = f.rdo(f(t0))

TabularUnified src/aubio.h ¶

-                      r8212692
+                      rf650860
   Two basic structures are being used in aubio: ::fvec_t and ::cvec_t. The
   ::fvec_t structures are used to store vectors of floating pointer number.
   ::cvec_t are used to store complex number, as two vectors of norm and phase
   elements.
+  ::fvec_t structures are used to store vectors of floating pointer number,
+  optionally on several channels. ::cvec_t are used to store complex number,
+  as two vectors of norm and phase elements, also on several channels.
   Additionally, the ::lvec_t structure can be used to store floating point
   numbers in double precision. They are mostly used to store filter
   coefficients, to avoid instability.
   \subsection objects Available objects
 …
   // fast Fourier transform (FFT)
   aubio_fft_t *fft = new_aubio_fft (winsize);
+  aubio_fft_t *fft = new_aubio_fft (winsize, channels);
   // phase vocoder
   aubio_pvoc_t *pv = new_aubio_pvoc (winsize, stepsize);
   // onset detection
   aubio_onset_t *onset = new_aubio_onset (method, winsize, stepsize, samplerate);
   // pitch detection
   aubio_pitch_t *pitch = new_aubio_pitch (method, winsize, stepsize, samplerate);
+  aubio_pvoc_t *pv = new_aubio_pvoc (winsize, stepsize, channels);
+  // onset detection
+  aubio_onset_t *onset = new_aubio_onset (method, winsize, stepsize, channels, samplerate);
+  // pitch detection
+  aubio_pitch_t *pitch = new_aubio_pitch (method, winsize, stepsize, channels, samplerate);
   // beat tracking
   aubio_tempo_t *tempo = new_aubio_tempo (method, winsize, stepsize, samplerate);
+  aubio_tempo_t *tempo = new_aubio_tempo (method, winsize, stepsize, channels, samplerate);
   \endcode
 …
   Here is a simple example that creates an A-Weighting filter and applies it to a
   vector.
   \code
   // set window size, and sampling rate
   uint_t winsize = 1024, sr = 44100;
+  // set channels, window size, and sampling rate
+  uint_t channels = 2, winsize = 1024, sr = 44100;
   // create a vector
   fvec_t *this_buffer = new_fvec (winsize);
+  fvec_t *this_buffer = new_fvec (winsize, channels);
   // create the a-weighting filter
   aubio_filter_t *this_filter = new_aubio_filter_a_weighting (sr);
+  aubio_filter_t *this_filter = new_aubio_filter_a_weighting (channels, sr);
   while (running) {
     // here some code to put some data in this_buffer
 …
     aubio_filter_do (this_filter, this_buffer);
     // here some code to get some data from this_buffer
+    // here some code to get some data from this_buffer
     // ...
+  }
   // and free the structures
   del_aubio_filter (this_filter);
 …
   \section download Download
   Latest versions, further documentation, examples, wiki, and mailing lists can
   be found at http://aubio.org .
  */
 …
   Programmers just need to include this file as:
   @code
     #include <aubio/aubio.h>
   @endcode
  */
 …
 #include "cvec.h"
 #include "lvec.h"
-#include "fmat.h"
 #include "musicutils.h"
 #include "temporal/resampler.h"

TabularUnified src/cvec.c ¶

-                      r8212692
+                      rf650860
 #include "cvec.h"
 cvec_t * new_cvec( uint_t length) {
+cvec_t * new_cvec( uint_t length, uint_t channels) {
   cvec_t * s = AUBIO_NEW(cvec_t);
+  uint_t j;
+  uint_t i,j;
+  s->channels = channels;
   s->length = length/2 + 1;
+  s->norm = AUBIO_ARRAY(smpl_t,s->length);
+  s->phas = AUBIO_ARRAY(smpl_t,s->length);
+  for (j=0; j< s->length; j++) {
+    s->norm[j]=0.;
+    s->phas[j]=0.;
+  s->norm = AUBIO_ARRAY(smpl_t*,s->channels);
+  s->phas = AUBIO_ARRAY(smpl_t*,s->channels);
+  for (i=0; i< s->channels; i++) {
+    s->norm[i] = AUBIO_ARRAY(smpl_t,s->length);
+    s->phas[i] = AUBIO_ARRAY(smpl_t,s->length);
+    for (j=0; j< s->length; j++) {
+      s->norm[i][j]=0.;
+      s->phas[i][j]=0.;
+    }
+  }
   return s;
 …
 void del_cvec(cvec_t *s) {
+  uint_t i;
+  for (i=0; i<s->channels; i++) {
+    AUBIO_FREE(s->norm[i]);
+    AUBIO_FREE(s->phas[i]);
+  }
   AUBIO_FREE(s->norm);
   AUBIO_FREE(s->phas);
 …
+}
 void cvec_write_norm(cvec_t *s, smpl_t data, uint_t position) {
   s->norm[position] = data;
+void cvec_write_norm(cvec_t *s, smpl_t data, uint_t channel, uint_t position) {
+  s->norm[channel][position] = data;
+}
 void cvec_write_phas(cvec_t *s, smpl_t data, uint_t position) {
   s->phas[position] = data;
+void cvec_write_phas(cvec_t *s, smpl_t data, uint_t channel, uint_t position) {
+  s->phas[channel][position] = data;
+}
 smpl_t cvec_read_norm(cvec_t *s, uint_t position) {
   return s->norm[position];
+smpl_t cvec_read_norm(cvec_t *s, uint_t channel, uint_t position) {
+  return s->norm[channel][position];
+}
 smpl_t cvec_read_phas(cvec_t *s, uint_t position) {
   return s->phas[position];
+smpl_t cvec_read_phas(cvec_t *s, uint_t channel, uint_t position) {
+  return s->phas[channel][position];
+}
+smpl_t * cvec_get_norm(cvec_t *s) {
+void cvec_put_norm_channel(cvec_t *s, smpl_t * data, uint_t channel) {
+  s->norm[channel] = data;
+}
+void cvec_put_phas_channel(cvec_t *s, smpl_t * data, uint_t channel) {
+  s->phas[channel] = data;
+}
+smpl_t * cvec_get_norm_channel(cvec_t *s, uint_t channel) {
+  return s->norm[channel];
+}
+smpl_t * cvec_get_phas_channel(cvec_t *s, uint_t channel) {
+  return s->phas[channel];
+}
+smpl_t ** cvec_get_norm(cvec_t *s) {
   return s->norm;
+}
 smpl_t * cvec_get_phas(cvec_t *s) {
+smpl_t ** cvec_get_phas(cvec_t *s) {
   return s->phas;
+}
 …
 void cvec_print(cvec_t *s) {
+  uint_t j;
+  AUBIO_MSG("norm: ");
+  for (j=0; j< s->length; j++) {
+    AUBIO_MSG(AUBIO_SMPL_FMT " ", s->norm[j]);
+  uint_t i,j;
+  for (i=0; i< s->channels; i++) {
+    AUBIO_MSG("norm: ");
+    for (j=0; j< s->length; j++) {
+      AUBIO_MSG(AUBIO_SMPL_FMT " ", s->norm[i][j]);
+    }
+    AUBIO_MSG("\n");
+    AUBIO_MSG("phas: ");
+    for (j=0; j< s->length; j++) {
+      AUBIO_MSG(AUBIO_SMPL_FMT " ", s->phas[i][j]);
+    }
+    AUBIO_MSG("\n");
+  }
-  AUBIO_MSG("\n");
-  AUBIO_MSG("phas: ");
-  for (j=0; j< s->length; j++) {
-    AUBIO_MSG(AUBIO_SMPL_FMT " ", s->phas[j]);
+  }
-  AUBIO_MSG("\n");
+}
 void cvec_set(cvec_t *s, smpl_t val) {
+  uint_t j;
+  for (j=0; j< s->length; j++) {
+    s->norm[j] = val;
+  uint_t i,j;
+  for (i=0; i< s->channels; i++) {
+    for (j=0; j< s->length; j++) {
+      s->norm[i][j] = val;
+    }
+  }
+}

TabularUnified src/cvec.h ¶

-                      r8212692
+                      rf650860
 typedef struct {
   uint_t length;   /**< length of buffer = (requested length)/2 + 1 */
+  smpl_t *norm;   /**< norm array of size [length] */
+  smpl_t *phas;   /**< phase array of size [length] */
+  uint_t channels; /**< number of channels */
+  smpl_t **norm;   /**< norm array of size [length] * [channels] */
+  smpl_t **phas;   /**< phase array of size [length] * [channels] */
 } cvec_t;
 …
   This function creates a cvec_t structure holding two arrays of size
   [length/2+1], corresponding to the norm and phase values of the
+  [length/2+1] * channels, corresponding to the norm and phase values of the
   spectral frame. The length stored in the structure is the actual size of both
   arrays, not the length of the complex and symetrical vector, specified as
 …
   \param length the length of the buffer to create
+*/
+cvec_t * new_cvec(uint_t length);
+  \param channels the number of channels in the buffer
+*/
+cvec_t * new_cvec(uint_t length, uint_t channels);
 /** cvec_t buffer deletion function
 …
   Note that this function is not used in the aubio library, since the same
   result can be obtained by assigning vec->norm[position]. Its purpose
+  result can be obtained by assigning vec->norm[channel][position]. Its purpose
   is to access these values from wrappers, as created by swig.
   \param s vector to write to
+  \param data norm value to write in s->norm[position]
+  \param data norm value to write in s->norm[channel][position]
+  \param channel channel to write to
   \param position sample position to write to
 */
 void cvec_write_norm(cvec_t *s, smpl_t data, uint_t position);
+void cvec_write_norm(cvec_t *s, smpl_t data, uint_t channel, uint_t position);
 /** write phase value in a complex buffer
   Note that this function is not used in the aubio library, since the same
   result can be obtained by assigning vec->phas[position]. Its purpose
+  result can be obtained by assigning vec->phas[channel][position]. Its purpose
   is to access these values from wrappers, as created by swig.
   \param s vector to write to
+  \param data phase value to write in s->phas[position]
+  \param data phase value to write in s->phas[channel][position]
+  \param channel channel to write to
   \param position sample position to write to
 */
 void cvec_write_phas(cvec_t *s, smpl_t data, uint_t position);
+void cvec_write_phas(cvec_t *s, smpl_t data, uint_t channel, uint_t position);
 /** read norm value from a complex buffer
   Note that this function is not used in the aubio library, since the same
+  result can be obtained with vec->norm[position]. Its purpose is to
+  access these values from wrappers, as created by swig.
+  \param s vector to read from
+  result can be obtained with vec->norm[channel][position]. Its purpose is to
+  access these values from wrappers, as created by swig.
+  \param s vector to read from
+  \param channel channel to read from
   \param position sample position to read from
 */
 smpl_t cvec_read_norm(cvec_t *s, uint_t position);
+smpl_t cvec_read_norm(cvec_t *s, uint_t channel, uint_t position);
 /** read phase value from a complex buffer
   Note that this function is not used in the aubio library, since the same
+  result can be obtained with vec->phas[position]. Its purpose is to
+  access these values from wrappers, as created by swig.
+  \param s vector to read from
+  result can be obtained with vec->phas[channel][position]. Its purpose is to
+  access these values from wrappers, as created by swig.
+  \param s vector to read from
+  \param channel channel to read from
   \param position sample position to read from
 */
+smpl_t cvec_read_phas(cvec_t *s, uint_t position);
+smpl_t cvec_read_phas(cvec_t *s, uint_t channel, uint_t position);
+/** write norm channel in a complex buffer
+  Note that this function is not used in the aubio library, since the same
+  result can be obtained by assigning vec->norm[channel]. Its purpose is to
+  access these values from wrappers, as created by swig.
+  \param s vector to write to
+  \param data norm vector of [length] samples to write in s->norm[channel]
+  \param channel channel to write to
+*/
+void cvec_put_norm_channel(cvec_t *s, smpl_t * data, uint_t channel);
+/** write phase channel in a complex buffer
+  Note that this function is not used in the aubio library, since the same
+  result can be obtained by assigning vec->phas[channel]. Its purpose is to
+  access these values from wrappers, as created by swig.
+  \param s vector to write to
+  \param data phase vector of [length] samples to write in s->phas[channel]
+  \param channel channel to write to
+*/
+void cvec_put_phas_channel(cvec_t *s, smpl_t * data, uint_t channel);
+/** read norm channel from a complex buffer
+  Note that this function is not used in the aubio library, since the same
+  result can be obtained with vec->norm[channel]. Its purpose is to access
+  these values from wrappers, as created by swig.
+  \param s vector to read from
+  \param channel channel to read from
+*/
+smpl_t * cvec_get_norm_channel(cvec_t *s, uint_t channel);
+/** write phase channel in a complex buffer
+  Note that this function is not used in the aubio library, since the same
+  result can be obtained with vec->phas[channel]. Its purpose is to access
+  these values from wrappers, as created by swig.
+  \param s vector to read from
+  \param channel channel to read from
+*/
+smpl_t * cvec_get_phas_channel(cvec_t *s, uint_t channel);
 /** read norm data from a complex buffer
 …
 */
 smpl_t * cvec_get_norm(cvec_t *s);
+smpl_t ** cvec_get_norm(cvec_t *s);
 /** read phase data from a complex buffer
 …
 */
 smpl_t * cvec_get_phas(cvec_t *s);
+smpl_t ** cvec_get_phas(cvec_t *s);
 /** print out cvec data

TabularUnified src/fvec.c ¶

-                      r8212692
+                      rf650860
 #include "fvec.h"
 fvec_t * new_fvec( uint_t length) {
+fvec_t * new_fvec( uint_t length, uint_t channels) {
   fvec_t * s = AUBIO_NEW(fvec_t);
+  uint_t j;
+  uint_t i,j;
+  s->channels = channels;
   s->length = length;
+  s->data = AUBIO_ARRAY(smpl_t, s->length);
+  for (j=0; j< s->length; j++) {
+    s->data[j]=0.;
+  s->data = AUBIO_ARRAY(smpl_t*,s->channels);
+  for (i=0; i< s->channels; i++) {
+    s->data[i] = AUBIO_ARRAY(smpl_t, s->length);
+    for (j=0; j< s->length; j++) {
+      s->data[i][j]=0.;
+    }
+  }
   return s;
 …
 void del_fvec(fvec_t *s) {
+  uint_t i;
+  for (i=0; i<s->channels; i++) {
+    AUBIO_FREE(s->data[i]);
+  }
   AUBIO_FREE(s->data);
   AUBIO_FREE(s);
+}
+void fvec_write_sample(fvec_t *s, smpl_t data, uint_t position) {
+  s->data[position] = data;
+void fvec_write_sample(fvec_t *s, smpl_t data, uint_t channel, uint_t position) {
+  s->data[channel][position] = data;
+}
+smpl_t fvec_read_sample(fvec_t *s, uint_t channel, uint_t position) {
+  return s->data[channel][position];
+}
+void fvec_put_channel(fvec_t *s, smpl_t * data, uint_t channel) {
+  s->data[channel] = data;
+}
+smpl_t * fvec_get_channel(fvec_t *s, uint_t channel) {
+  return s->data[channel];
+}
+smpl_t fvec_read_sample(fvec_t *s, uint_t position) {
+  return s->data[position];
+}
+smpl_t * fvec_get_data(fvec_t *s) {
+smpl_t ** fvec_get_data(fvec_t *s) {
   return s->data;
+}
 …
 void fvec_print(fvec_t *s) {
+  uint_t j;
+  for (j=0; j< s->length; j++) {
+    AUBIO_MSG(AUBIO_SMPL_FMT " ", s->data[j]);
+  uint_t i,j;
+  for (i=0; i< s->channels; i++) {
+    for (j=0; j< s->length; j++) {
+      AUBIO_MSG(AUBIO_SMPL_FMT " ", s->data[i][j]);
+    }
+    AUBIO_MSG("\n");
+  }
-  AUBIO_MSG("\n");
+}
 void fvec_set(fvec_t *s, smpl_t val) {
+  uint_t j;
+  for (j=0; j< s->length; j++) {
+    s->data[j] = val;
+  uint_t i,j;
+  for (i=0; i< s->channels; i++) {
+    for (j=0; j< s->length; j++) {
+      s->data[i][j] = val;
+    }
+  }
+}
 …
 void fvec_rev(fvec_t *s) {
+  uint_t j;
+  for (j=0; j< FLOOR(s->length/2); j++) {
+    ELEM_SWAP(s->data[j], s->data[s->length-1-j]);
+  uint_t i,j;
+  for (i=0; i< s->channels; i++) {
+    for (j=0; j< FLOOR(s->length/2); j++) {
+      ELEM_SWAP(s->data[i][j], s->data[i][s->length-1-j]);
+    }
+  }
+}
 void fvec_weight(fvec_t *s, fvec_t *weight) {
   uint_t j;
+  uint_t i,j;
   uint_t length = MIN(s->length, weight->length);
+  for (j=0; j< length; j++) {
+    s->data[j] *= weight->data[j];
+  for (i=0; i< s->channels; i++) {
+    for (j=0; j< length; j++) {
+      s->data[i][j] *= weight->data[0][j];
+    }
+  }
+}
 void fvec_copy(fvec_t *s, fvec_t *t) {
+  uint_t j;
+  uint_t i,j;
+  uint_t channels = MIN(s->channels, t->channels);
   uint_t length = MIN(s->length, t->length);
+  if (s->channels != t->channels) {
+    AUBIO_ERR("warning, trying to copy %d channels to %d channels\n",
+            s->channels, t->channels);
+  }
   if (s->length != t->length) {
     AUBIO_WRN("trying to copy %d elements to %d elements \n",
+    AUBIO_ERR("warning, trying to copy %d elements to %d elements \n",
             s->length, t->length);
+  }
+  for (j=0; j< length; j++) {
+    t->data[j] = s->data[j];
+  for (i=0; i< channels; i++) {
+    for (j=0; j< length; j++) {
+      t->data[i][j] = s->data[i][j];
+    }
+  }
+}

TabularUnified src/fvec.h ¶

-                      r8212692
+                      rf650860
 typedef struct {
   uint_t length;   /**< length of buffer */
+  smpl_t *data;   /**< data array of size [length] */
+  uint_t channels; /**< number of channels */
+  smpl_t **data;   /**< data array of size [length] * [channels] */
 } fvec_t;
 …
   \param length the length of the buffer to create
+  \param channels the number of channels in the buffer
 */
 fvec_t * new_fvec(uint_t length);
+fvec_t * new_fvec(uint_t length, uint_t channels);
 /** fvec_t buffer deletion function
 …
   Note that this function is not used in the aubio library, since the same
   result can be obtained using vec->data[position]. Its purpose is to
+  result can be obtained using vec->data[channel][position]. Its purpose is to
   access these values from wrappers, as created by swig.
   \param s vector to read from
+  \param channel channel to read from
   \param position sample position to read from
 */
 smpl_t fvec_read_sample(fvec_t *s, uint_t position);
+smpl_t fvec_read_sample(fvec_t *s, uint_t channel, uint_t position);
 /** write sample value in a buffer
   Note that this function is not used in the aubio library, since the same
   result can be obtained by assigning vec->data[position]. Its purpose
+  result can be obtained by assigning vec->data[channel][position]. Its purpose
   is to access these values from wrappers, as created by swig.
   \param s vector to write to
+  \param data value to write in s->data[position]
+  \param data value to write in s->data[channel][position]
+  \param channel channel to write to
   \param position sample position to write to
 */
+void  fvec_write_sample(fvec_t *s, smpl_t data, uint_t position);
+void  fvec_write_sample(fvec_t *s, smpl_t data, uint_t channel, uint_t position);
+/** read channel vector from a buffer
+  Note that this function is not used in the aubio library, since the same
+  result can be obtained with vec->data[channel]. Its purpose is to access
+  these values from wrappers, as created by swig.
+  \param s vector to read from
+  \param channel channel to read from
+*/
+smpl_t * fvec_get_channel(fvec_t *s, uint_t channel);
+/** write channel vector into a buffer
+  Note that this function is not used in the aubio library, since the same
+  result can be obtained by assigning vec->data[channel]. Its purpose is to
+  access these values from wrappers, as created by swig.
+  \param s vector to write to
+  \param data vector of [length] values to write
+  \param channel channel to write to
+*/
+void fvec_put_channel(fvec_t *s, smpl_t * data, uint_t channel);
 /** read data from a buffer
 …
 */
 smpl_t * fvec_get_data(fvec_t *s);
+smpl_t ** fvec_get_data(fvec_t *s);
 /** print out fvec data

TabularUnified src/lvec.c ¶

-                      r8212692
+                      rf650860
 #include "lvec.h"
 lvec_t * new_lvec( uint_t length) {
+lvec_t * new_lvec( uint_t length, uint_t channels) {
   lvec_t * s = AUBIO_NEW(lvec_t);
+  uint_t j;
+  uint_t i,j;
+  s->channels = channels;
   s->length = length;
+  s->data = AUBIO_ARRAY(lsmp_t, s->length);
+  for (j=0; j< s->length; j++) {
+    s->data[j]=0.;
+  s->data = AUBIO_ARRAY(lsmp_t*,s->channels);
+  for (i=0; i< s->channels; i++) {
+    s->data[i] = AUBIO_ARRAY(lsmp_t, s->length);
+    for (j=0; j< s->length; j++) {
+      s->data[i][j]=0.;
+    }
+  }
   return s;
 …
 void del_lvec(lvec_t *s) {
+  uint_t i;
+  for (i=0; i<s->channels; i++) {
+    AUBIO_FREE(s->data[i]);
+  }
   AUBIO_FREE(s->data);
   AUBIO_FREE(s);
+}
 void lvec_write_sample(lvec_t *s, lsmp_t data, uint_t position) {
   s->data[position] = data;
+void lvec_write_sample(lvec_t *s, lsmp_t data, uint_t channel, uint_t position) {
+  s->data[channel][position] = data;
+}
+lsmp_t lvec_read_sample(lvec_t *s, uint_t position) {
+  return s->data[position];
+lsmp_t lvec_read_sample(lvec_t *s, uint_t channel, uint_t position) {
+  return s->data[channel][position];
+}
+void lvec_put_channel(lvec_t *s, lsmp_t * data, uint_t channel) {
+  s->data[channel] = data;
+}
+lsmp_t * lvec_get_channel(lvec_t *s, uint_t channel) {
+  return s->data[channel];
+}
 lsmp_t * lvec_get_data(lvec_t *s) {
+lsmp_t ** lvec_get_data(lvec_t *s) {
   return s->data;
+}
 …
 void lvec_print(lvec_t *s) {
+  uint_t j;
+  for (j=0; j< s->length; j++) {
+    AUBIO_MSG(AUBIO_LSMP_FMT " ", s->data[j]);
+  uint_t i,j;
+  for (i=0; i< s->channels; i++) {
+    for (j=0; j< s->length; j++) {
+      AUBIO_MSG(AUBIO_LSMP_FMT " ", s->data[i][j]);
+    }
+    AUBIO_MSG("\n");
+  }
-  AUBIO_MSG("\n");
+}
 void lvec_set(lvec_t *s, smpl_t val) {
+  uint_t j;
+  for (j=0; j< s->length; j++) {
+    s->data[j] = val;
+  uint_t i,j;
+  for (i=0; i< s->channels; i++) {
+    for (j=0; j< s->length; j++) {
+      s->data[i][j] = val;
+    }
+  }
+}

TabularUnified src/lvec.h ¶

-                      r8212692
+                      rf650860
 typedef struct {
   uint_t length;   /**< length of buffer */
+  lsmp_t *data;   /**< data array of size [length] */
+  uint_t channels; /**< number of channels */
+  lsmp_t **data;   /**< data array of size [length] * [channels] */
 } lvec_t;
 …
   \param length the length of the buffer to create
+  \param channels the number of channels in the buffer
 */
 lvec_t * new_lvec(uint_t length);
+lvec_t * new_lvec(uint_t length, uint_t channels);
 /** lvec_t buffer deletion function
 …
   Note that this function is not used in the aubio library, since the same
   result can be obtained using vec->data[position]. Its purpose is to
+  result can be obtained using vec->data[channel][position]. Its purpose is to
   access these values from wrappers, as created by swig.
   \param s vector to read from
+  \param channel channel to read from
   \param position sample position to read from
 */
 lsmp_t lvec_read_sample(lvec_t *s, uint_t position);
+lsmp_t lvec_read_sample(lvec_t *s, uint_t channel, uint_t position);
 /** write sample value in a buffer
   Note that this function is not used in the aubio library, since the same
   result can be obtained by assigning vec->data[position]. Its purpose
+  result can be obtained by assigning vec->data[channel][position]. Its purpose
   is to access these values from wrappers, as created by swig.
   \param s vector to write to
+  \param data value to write in s->data[position]
+  \param data value to write in s->data[channel][position]
+  \param channel channel to write to
   \param position sample position to write to
 */
+void  lvec_write_sample(lvec_t *s, lsmp_t data, uint_t position);
+void  lvec_write_sample(lvec_t *s, lsmp_t data, uint_t channel, uint_t position);
+/** read channel vector from a buffer
+  Note that this function is not used in the aubio library, since the same
+  result can be obtained with vec->data[channel]. Its purpose is to access
+  these values from wrappers, as created by swig.
+  \param s vector to read from
+  \param channel channel to read from
+*/
+lsmp_t * lvec_get_channel(lvec_t *s, uint_t channel);
+/** write channel vector into a buffer
+  Note that this function is not used in the aubio library, since the same
+  result can be obtained by assigning vec->data[channel]. Its purpose is to
+  access these values from wrappers, as created by swig.
+  \param s vector to write to
+  \param data vector of [length] values to write
+  \param channel channel to write to
+*/
+void lvec_put_channel(lvec_t *s, lsmp_t * data, uint_t channel);
 /** read data from a buffer
 …
 */
 lsmp_t * lvec_get_data(lvec_t *s);
+lsmp_t ** lvec_get_data(lvec_t *s);
 /** print out lvec data

TabularUnified src/mathutils.c ¶

-                      r8212692
+                      rf650860
 new_aubio_window (char_t * window_type, uint_t size)
+{
+  fvec_t * win = new_fvec (size);
+  smpl_t * w = win->data;
+  // create fvec of size x 1 channel
+  fvec_t * win = new_fvec( size, 1);
+  smpl_t * w = win->data[0];
   uint_t i;
   aubio_window_type wintype;
 …
 fvec_mean (fvec_t * s)
+{
+  uint_t i, j;
+  smpl_t tmp = 0.0;
+  for (i = 0; i < s->channels; i++)
+    for (j = 0; j < s->length; j++)
+      tmp += s->data[i][j];
+  return tmp / (smpl_t) (s->length);
+}
+smpl_t
+fvec_mean_channel (fvec_t * s, uint_t i)
+{
   uint_t j;
   smpl_t tmp = 0.0;
+  for (j = 0; j < s->length; j++) {
+    tmp += s->data[j];
+  }
+  for (j = 0; j < s->length; j++)
+      tmp += s->data[i][j];
   return tmp / (smpl_t) (s->length);
+}
 …
 fvec_sum (fvec_t * s)
+{
   uint_t j;
+  uint_t i, j;
   smpl_t tmp = 0.0;
+  for (j = 0; j < s->length; j++) {
+    tmp += s->data[j];
+  for (i = 0; i < s->channels; i++) {
+    for (j = 0; j < s->length; j++) {
+      tmp += s->data[i][j];
+    }
+  }
   return tmp;
 …
 fvec_max (fvec_t * s)
+{
   uint_t j;
+  uint_t i, j;
   smpl_t tmp = 0.0;
+  for (j = 0; j < s->length; j++) {
+    tmp = (tmp > s->data[j]) ? tmp : s->data[j];
+  for (i = 0; i < s->channels; i++) {
+    for (j = 0; j < s->length; j++) {
+      tmp = (tmp > s->data[i][j]) ? tmp : s->data[i][j];
+    }
+  }
   return tmp;
 …
 fvec_min (fvec_t * s)
+{
+  uint_t j;
+  smpl_t tmp = s->data[0];
+  for (j = 0; j < s->length; j++) {
+    tmp = (tmp < s->data[j]) ? tmp : s->data[j];
+  uint_t i, j;
+  smpl_t tmp = s->data[0][0];
+  for (i = 0; i < s->channels; i++) {
+    for (j = 0; j < s->length; j++) {
+      tmp = (tmp < s->data[i][j]) ? tmp : s->data[i][j];
+    }
+  }
   return tmp;
 …
 fvec_min_elem (fvec_t * s)
+{
+  uint_t j, pos = 0.;
+  smpl_t tmp = s->data[0];
+  for (j = 0; j < s->length; j++) {
+    pos = (tmp < s->data[j]) ? pos : j;
+    tmp = (tmp < s->data[j]) ? tmp : s->data[j];
+  uint_t i, j, pos = 0.;
+  smpl_t tmp = s->data[0][0];
+  for (i = 0; i < s->channels; i++) {
+    for (j = 0; j < s->length; j++) {
+      pos = (tmp < s->data[i][j]) ? pos : j;
+      tmp = (tmp < s->data[i][j]) ? tmp : s->data[i][j];
+    }
+  }
   return pos;
 …
 fvec_max_elem (fvec_t * s)
+{
   uint_t j, pos = 0;
+  uint_t i, j, pos = 0;
   smpl_t tmp = 0.0;
+  for (j = 0; j < s->length; j++) {
+    pos = (tmp > s->data[j]) ? pos : j;
+    tmp = (tmp > s->data[j]) ? tmp : s->data[j];
+  for (i = 0; i < s->channels; i++) {
+    for (j = 0; j < s->length; j++) {
+      pos = (tmp > s->data[i][j]) ? pos : j;
+      tmp = (tmp > s->data[i][j]) ? tmp : s->data[i][j];
+    }
+  }
   return pos;
 …
 fvec_shift (fvec_t * s)
+{
+  uint_t j;
+  for (j = 0; j < s->length / 2; j++) {
+    ELEM_SWAP (s->data[j], s->data[j + s->length / 2]);
+  uint_t i, j;
+  for (i = 0; i < s->channels; i++) {
+    for (j = 0; j < s->length / 2; j++) {
+      ELEM_SWAP (s->data[i][j], s->data[i][j + s->length / 2]);
+    }
+  }
+}
 …
+{
   smpl_t energy = 0.;
+  uint_t j;
+  for (j = 0; j < f->length; j++) {
+    energy += SQR (f->data[j]);
+  uint_t i, j;
+  for (i = 0; i < f->channels; i++) {
+    for (j = 0; j < f->length; j++) {
+      energy += SQR (f->data[i][j]);
+    }
+  }
   return energy;
 …
+{
   smpl_t hfc = 0.;
+  uint_t j;
+  for (j = 0; j < v->length; j++) {
+    hfc += (j + 1) * v->data[j];
+  uint_t i, j;
+  for (i = 0; i < v->channels; i++) {
+    for (j = 0; j < v->length; j++) {
+      hfc += (i + 1) * v->data[i][j];
+    }
+  }
   return hfc;
 …
 fvec_alpha_norm (fvec_t * o, smpl_t alpha)
+{
   uint_t j;
+  uint_t i, j;
   smpl_t tmp = 0.;
+  for (j = 0; j < o->length; j++) {
+    tmp += POW (ABS (o->data[j]), alpha);
+  for (i = 0; i < o->channels; i++) {
+    for (j = 0; j < o->length; j++) {
+      tmp += POW (ABS (o->data[i][j]), alpha);
+    }
+  }
   return POW (tmp / o->length, 1. / alpha);
 …
 fvec_alpha_normalise (fvec_t * o, smpl_t alpha)
+{
   uint_t j;
+  uint_t i, j;
   smpl_t norm = fvec_alpha_norm (o, alpha);
+  for (j = 0; j < o->length; j++) {
+    o->data[j] /= norm;
+  for (i = 0; i < o->channels; i++) {
+    for (j = 0; j < o->length; j++) {
+      o->data[i][j] /= norm;
+    }
+  }
+}
 …
 fvec_add (fvec_t * o, smpl_t val)
+{
+  uint_t j;
+  for (j = 0; j < o->length; j++) {
+    o->data[j] += val;
+  uint_t i, j;
+  for (i = 0; i < o->channels; i++) {
+    for (j = 0; j < o->length; j++) {
+      o->data[i][j] += val;
+    }
+  }
+}
 void fvec_adapt_thres(fvec_t * vec, fvec_t * tmp,
     uint_t post, uint_t pre) {
   uint_t length = vec->length, j;
+    uint_t post, uint_t pre, uint_t channel) {
+  uint_t length = vec->length, i=channel, j;
   for (j=0;j<length;j++) {
     vec->data[j] -= fvec_moving_thres(vec, tmp, post, pre, j);
+    vec->data[i][j] -= fvec_moving_thres(vec, tmp, post, pre, j, i);
+  }
+}
 …
 smpl_t
 fvec_moving_thres (fvec_t * vec, fvec_t * tmpvec,
     uint_t post, uint_t pre, uint_t pos)
+{
   uint_t k;
   smpl_t *medar = (smpl_t *) tmpvec->data;
+    uint_t post, uint_t pre, uint_t pos, uint_t channel)
+{
+  uint_t i = channel, k;
+  smpl_t *medar = (smpl_t *) tmpvec->data[i];
   uint_t win_length = post + pre + 1;
   uint_t length = vec->length;
 …
       medar[k] = 0.;            /* 0-padding at the beginning */
     for (k = post + 1 - pos; k < win_length; k++)
       medar[k] = vec->data[k + pos - post];
+      medar[k] = vec->data[0][k + pos - post];
     /* the buffer is fully defined */
   } else if (pos + pre < length) {
     for (k = 0; k < win_length; k++)
       medar[k] = vec->data[k + pos - post];
+      medar[k] = vec->data[0][k + pos - post];
     /* pre part of the buffer does not exist */
   } else {
     for (k = 0; k < length - pos + post; k++)
       medar[k] = vec->data[k + pos - post];
+      medar[k] = vec->data[0][k + pos - post];
     for (k = length - pos + post; k < win_length; k++)
       medar[k] = 0.;            /* 0-padding at the end */
+  }
   return fvec_median (tmpvec);
+}
 smpl_t fvec_median (fvec_t * input) {
+  return fvec_median_channel (tmpvec, i);
+}
+smpl_t fvec_median_channel (fvec_t * input, uint_t channel) {
   uint_t n = input->length;
   smpl_t * arr = (smpl_t *) input->data;
+  smpl_t * arr = (smpl_t *) input->data[channel];
   uint_t low, high ;
   uint_t median;
 …
+}
 smpl_t fvec_quadint (fvec_t * x, uint_t pos) {
+smpl_t fvec_quadint (fvec_t * x, uint_t pos, uint_t i) {
   smpl_t s0, s1, s2;
   uint_t x0 = (pos < 1) ? pos : pos - 1;
   uint_t x2 = (pos + 1 < x->length) ? pos + 1 : pos;
   if (x0 == pos) return (x->data[pos] <= x->data[x2]) ? pos : x2;
   if (x2 == pos) return (x->data[pos] <= x->data[x0]) ? pos : x0;
   s0 = x->data[x0];
   s1 = x->data[pos];
   s2 = x->data[x2];
+  if (x0 == pos) return (x->data[i][pos] <= x->data[i][x2]) ? pos : x2;
+  if (x2 == pos) return (x->data[i][pos] <= x->data[i][x0]) ? pos : x0;
+  s0 = x->data[i][x0];
+  s1 = x->data[i][pos];
+  s2 = x->data[i][x2];
   return pos + 0.5 * (s2 - s0 ) / (s2 - 2.* s1 + s0);
+}
 uint_t fvec_peakpick(fvec_t * onset, uint_t pos) {
+  uint_t tmp=0;
+  tmp = (onset->data[pos] > onset->data[pos-1]
+      &&  onset->data[pos] > onset->data[pos+1]
+      &&  onset->data[pos] > 0.);
+  uint_t i=0, tmp=0;
+  /*for (i=0;i<onset->channels;i++)*/
+  tmp = (onset->data[i][pos] > onset->data[i][pos-1]
+      &&  onset->data[i][pos] > onset->data[i][pos+1]
+      &&  onset->data[i][pos] > 0.);
   return tmp;
+}
 …
 aubio_zero_crossing_rate (fvec_t * input)
+{
   uint_t j;
+  uint_t i = 0, j;
   uint_t zcr = 0;
   for (j = 1; j < input->length; j++) {
     // previous was strictly negative
     if (input->data[j - 1] < 0.) {
+    if (input->data[i][j - 1] < 0.) {
       // current is positive or null
       if (input->data[j] >= 0.) {
+      if (input->data[i][j] >= 0.) {
         zcr += 1;
+      }
 …
     } else {
       // current is strictly negative
       if (input->data[j] < 0.) {
+      if (input->data[i][j] < 0.) {
         zcr += 1;
+      }
 …
 aubio_autocorr (fvec_t * input, fvec_t * output)
+{
   uint_t i, j, length = input->length;
+  uint_t i, j, k, length = input->length;
   smpl_t *data, *acf;
   smpl_t tmp = 0;
+  data = input->data;
+  acf = output->data;
+  for (i = 0; i < length; i++) {
+    tmp = 0.;
+    for (j = i; j < length; j++) {
+      tmp += data[j - i] * data[j];
+    }
+    acf[i] = tmp / (smpl_t) (length - i);
+  for (k = 0; k < input->channels; k++) {
+    data = input->data[k];
+    acf = output->data[k];
+    for (i = 0; i < length; i++) {
+      tmp = 0.;
+      for (j = i; j < length; j++) {
+        tmp += data[j - i] * data[j];
+      }
+      acf[i] = tmp / (smpl_t) (length - i);
+    }
+  }
+}

TabularUnified src/mathutils.h ¶

-                      r8212692
+                      rf650860
 */
 smpl_t fvec_mean (fvec_t * s);
+/** compute the mean of a vector channel
+  \param s vector to compute mean from
+  \param i channel to compute mean from
+  \return the mean of v
+*/
+smpl_t fvec_mean_channel (fvec_t * s, uint_t i);
 /** find the max of a vector
 …
 */
 smpl_t fvec_moving_thres (fvec_t * v, fvec_t * tmp, uint_t post, uint_t pre,
     uint_t pos);
+    uint_t pos, uint_t channel);
 /** apply adaptive threshold to a vector
 …
 */
+void fvec_adapt_thres (fvec_t * v, fvec_t * tmp, uint_t post, uint_t pre);
+void fvec_adapt_thres (fvec_t * v, fvec_t * tmp, uint_t post, uint_t pre,
+    uint_t channel);
 /** returns the median of a vector
 …
   \param v vector to get median from
+  \param channel channel to get median from
   \return the median of v
 */
 smpl_t fvec_median (fvec_t * v);
+smpl_t fvec_median_channel (fvec_t * v, uint_t channel);
 /** finds exact peak index by quadratic interpolation*/
 smpl_t fvec_quadint (fvec_t * x, uint_t pos);
+smpl_t fvec_quadint (fvec_t * x, uint_t pos, uint_t channel);
 /** Quadratic interpolation using Lagrange polynomial.

TabularUnified src/onset/onset.c ¶

-                      r8212692
+                      rf650860
   smpl_t isonset = 0;
   smpl_t wasonset = 0;
+  uint_t i;
   aubio_pvoc_do (o->pv,input, o->fftgrain);
   aubio_specdesc_do (o->od,o->fftgrain, o->of);
+  /*if (usedoubled) {
+    aubio_specdesc_do (o2,fftgrain, onset2);
+    onset->data[0][0] *= onset2->data[0][0];
+  }*/
   aubio_peakpicker_do(o->pp, o->of, onset);
+  isonset = onset->data[0];
+  wasonset = o->wasonset->data[0];
+  for (i = 0; i < input->channels; i++) {
+  isonset = onset->data[i][0];
+  wasonset = o->wasonset->data[i][0];
   if (isonset > 0.) {
     if (aubio_silence_detection(input, o->silence)==1) {
 …
     wasonset++;
+  }
+  o->wasonset->data[0] = wasonset;
+  onset->data[0] = isonset;
+  o->wasonset->data[i][0] = wasonset;
+  onset->data[i][0] = isonset;
+  }
   return;
+}
 …
 /* Allocate memory for an onset detection */
 aubio_onset_t * new_aubio_onset (char_t * onset_mode,
     uint_t buf_size, uint_t hop_size, uint_t samplerate)
+    uint_t buf_size, uint_t hop_size, uint_t channels, uint_t samplerate)
+{
   aubio_onset_t * o = AUBIO_NEW(aubio_onset_t);
 …
   o->minioi    = 4;
   o->silence   = -70;
   o->wasonset  = new_fvec(1);
+  o->wasonset  = new_fvec(1, channels);
   o->samplerate = samplerate;
   o->hop_size = hop_size;
   o->pv = new_aubio_pvoc(buf_size, hop_size);
   o->pp = new_aubio_peakpicker();
+  o->pv = new_aubio_pvoc(buf_size, hop_size, channels);
+  o->pp = new_aubio_peakpicker(channels);
   aubio_peakpicker_set_threshold (o->pp, o->threshold);
   o->od = new_aubio_specdesc(onset_mode,buf_size);
   o->fftgrain = new_cvec(buf_size);
   o->of = new_fvec(1);
+  o->od = new_aubio_specdesc(onset_mode,buf_size,channels);
+  o->fftgrain = new_cvec(buf_size,channels);
+  o->of = new_fvec(1, channels);
   /*if (usedoubled)    {
     o2 = new_aubio_specdesc(onset_type2,buffer_size);
     onset2 = new_fvec(1);
+    o2 = new_aubio_specdesc(onset_type2,buffer_size,channels);
+    onset2 = new_fvec(1 , channels);
   }*/
   return o;

TabularUnified src/onset/onset.h ¶

-                      r8212692
+                      rf650860
   \param buf_size buffer size for phase vocoder
   \param hop_size hop size for phase vocoder
+  \param channels number of channels
   \param samplerate sampling rate of the input signal
 */
 aubio_onset_t * new_aubio_onset (char_t * method,
     uint_t buf_size, uint_t hop_size, uint_t samplerate);
+    uint_t buf_size, uint_t hop_size, uint_t channels, uint_t samplerate);
 /** execute onset detection

TabularUnified src/onset/peakpicker.c ¶

-                      r8212692
+                      rf650860
 /** function pointer to thresholding function */
 typedef smpl_t (*aubio_thresholdfn_t)(fvec_t *input);
+typedef smpl_t (*aubio_thresholdfn_t)(fvec_t *input, uint_t channel);
 /** function pointer to peak-picking function */
 typedef uint_t (*aubio_pickerfn_t)(fvec_t *input, uint_t pos);
 …
   fvec_t *scratch;
+  /** number of channels to analyse */
+  uint_t channels;
         /** \bug should be used to calculate filter coefficients */
   /* cutoff: low-pass filter cutoff [0.34, 1] */
 …
   smpl_t mean = 0., median = 0.;
   uint_t length = p->win_post + p->win_pre + 1;
+  uint_t j = 0;
+  /* store onset in onset_keep */
+  /* shift all elements but last, then write last */
+  for (j = 0; j < length - 1; j++) {
+    onset_keep->data[j] = onset_keep->data[j + 1];
+    onset_proc->data[j] = onset_keep->data[j];
+  uint_t i, j = 0;
+  for (i = 0; i < p->channels; i++) {
+    /* store onset in onset_keep */
+    /* shift all elements but last, then write last */
+    for (j = 0; j < length - 1; j++) {
+      onset_keep->data[i][j] = onset_keep->data[i][j + 1];
+      onset_proc->data[i][j] = onset_keep->data[i][j];
+    }
+    onset_keep->data[i][length - 1] = onset->data[i][0];
+    onset_proc->data[i][length - 1] = onset->data[i][0];
+  }
-  onset_keep->data[length - 1] = onset->data[0];
-  onset_proc->data[length - 1] = onset->data[0];
   /* filter onset_proc */
 …
   aubio_filter_do_filtfilt (p->biquad, onset_proc, scratch);
+  /* calculate mean and median for onset_proc */
+  mean = fvec_mean (onset_proc);
+  /* copy to scratch */
+  for (j = 0; j < length; j++)
+    scratch->data[j] = onset_proc->data[j];
+  median = p->thresholdfn (scratch);
+  /* shift peek array */
+  for (j = 0; j < 3 - 1; j++)
+    onset_peek->data[j] = onset_peek->data[j + 1];
+  /* calculate new tresholded value */
+  thresholded->data[0] =
+      onset_proc->data[p->win_post] - median - mean * p->threshold;
+  onset_peek->data[2] = thresholded->data[0];
+  out->data[0] = (p->pickerfn) (onset_peek, 1);
+  if (out->data[0]) {
+    out->data[0] = fvec_quadint (onset_peek, 1);
+  for (i = 0; i < p->channels; i++) {
+    /* calculate mean and median for onset_proc */
+    mean = fvec_mean_channel (onset_proc, i);
+    /* copy to scratch */
+    for (j = 0; j < length; j++)
+      scratch->data[i][j] = onset_proc->data[i][j];
+    median = p->thresholdfn (scratch, i);
+    /* shift peek array */
+    for (j = 0; j < 3 - 1; j++)
+      onset_peek->data[i][j] = onset_peek->data[i][j + 1];
+    /* calculate new tresholded value */
+    thresholded->data[i][0] =
+        onset_proc->data[i][p->win_post] - median - mean * p->threshold;
+    onset_peek->data[i][2] = thresholded->data[i][0];
+    out->data[i][0] = (p->pickerfn) (onset_peek, 1);
+    if (out->data[i][0]) {
+      out->data[i][0] = fvec_quadint (onset_peek, 1, i);
+    }
+  }
+}
 …
 aubio_peakpicker_t *
 new_aubio_peakpicker ()
+new_aubio_peakpicker (uint_t channels)
+{
   aubio_peakpicker_t *t = AUBIO_NEW (aubio_peakpicker_t);
 …
   t->win_post = 5;
   t->win_pre = 1;
+  t->thresholdfn = (aubio_thresholdfn_t) (fvec_median); /* (fvec_mean); */
+  //channels = 1;
+  t->channels = channels;
+  t->thresholdfn = (aubio_thresholdfn_t) (fvec_median_channel); /* (fvec_mean); */
   t->pickerfn = (aubio_pickerfn_t) (fvec_peakpick);
   t->scratch = new_fvec (t->win_post + t->win_pre + 1);
   t->onset_keep = new_fvec (t->win_post + t->win_pre + 1);
   t->onset_proc = new_fvec (t->win_post + t->win_pre + 1);
   t->onset_peek = new_fvec (3);
   t->thresholded = new_fvec (1);
+  t->scratch = new_fvec (t->win_post + t->win_pre + 1, channels);
+  t->onset_keep = new_fvec (t->win_post + t->win_pre + 1, channels);
+  t->onset_proc = new_fvec (t->win_post + t->win_pre + 1, channels);
+  t->onset_peek = new_fvec (3, channels);
+  t->thresholded = new_fvec (1, channels);
   /* cutoff: low-pass filter with cutoff reduced frequency at 0.34
 …
    */
   t->biquad = new_aubio_filter_biquad (0.15998789, 0.31997577, 0.15998789,
       -0.59488894, 0.23484048);
+      -0.59488894, 0.23484048, channels);
   return t;

TabularUnified src/onset/peakpicker.h ¶

r8212692	rf650860
36	36
37	37	/** peak-picker creation function */
38		aubio_peakpicker_t * new_aubio_peakpicker(~~void~~);
	38	aubio_peakpicker_t * new_aubio_peakpicker(uint_t channels);
39	39	/** real time peak picking function */
40	40	void aubio_peakpicker_do(aubio_peakpicker_t * p, fvec_t * in, fvec_t * out);

TabularUnified src/pitch/pitch.c ¶

-                      r8212692
+                      rf650860
 aubio_pitch_t *
 new_aubio_pitch (char_t * pitch_mode,
     uint_t bufsize, uint_t hopsize, uint_t samplerate)
+    uint_t bufsize, uint_t hopsize, uint_t channels, uint_t samplerate)
+{
   aubio_pitch_t *p = AUBIO_NEW (aubio_pitch_t);
 …
   switch (p->type) {
     case aubio_pitcht_yin:
       p->buf = new_fvec (bufsize);
+      p->buf = new_fvec (bufsize, channels);
       p->yin = new_aubio_pitchyin (bufsize);
       p->callback = aubio_pitch_do_yin;
 …
       break;
     case aubio_pitcht_mcomb:
       p->pv = new_aubio_pvoc (bufsize, hopsize);
       p->fftgrain = new_cvec (bufsize);
       p->mcomb = new_aubio_pitchmcomb (bufsize, hopsize);
       p->filter = new_aubio_filter_c_weighting (samplerate);
+      p->pv = new_aubio_pvoc (bufsize, hopsize, channels);
+      p->fftgrain = new_cvec (bufsize, channels);
+      p->mcomb = new_aubio_pitchmcomb (bufsize, hopsize, channels);
+      p->filter = new_aubio_filter_c_weighting (samplerate, channels);
       p->callback = aubio_pitch_do_mcomb;
       break;
     case aubio_pitcht_fcomb:
       p->buf = new_fvec (bufsize);
       p->fcomb = new_aubio_pitchfcomb (bufsize, hopsize);
+      p->buf = new_fvec (bufsize, channels);
+      p->fcomb = new_aubio_pitchfcomb (bufsize, hopsize, channels);
       p->callback = aubio_pitch_do_fcomb;
       break;
     case aubio_pitcht_schmitt:
       p->buf = new_fvec (bufsize);
+      p->buf = new_fvec (bufsize, channels);
       p->schmitt = new_aubio_pitchschmitt (bufsize);
       p->callback = aubio_pitch_do_schmitt;
       break;
     case aubio_pitcht_yinfft:
       p->buf = new_fvec (bufsize);
+      p->buf = new_fvec (bufsize, channels);
       p->yinfft = new_aubio_pitchyinfft (bufsize);
       p->callback = aubio_pitch_do_yinfft;
 …
 aubio_pitch_slideblock (aubio_pitch_t * p, fvec_t * ibuf)
+{
   uint_t j = 0, overlap_size = 0;
+  uint_t i, j = 0, overlap_size = 0;
   overlap_size = p->buf->length - ibuf->length;
+  for (j = 0; j < overlap_size; j++) {
+    p->buf->data[j] = p->buf->data[j + ibuf->length];
+  }
+  for (j = 0; j < ibuf->length; j++) {
+    p->buf->data[j + overlap_size] = ibuf->data[j];
+  for (i = 0; i < p->buf->channels; i++) {
+    for (j = 0; j < overlap_size; j++) {
+      p->buf->data[i][j] = p->buf->data[i][j + ibuf->length];
+    }
+  }
+  for (i = 0; i < ibuf->channels; i++) {
+    for (j = 0; j < ibuf->length; j++) {
+      p->buf->data[i][j + overlap_size] = ibuf->data[i][j];
+    }
+  }
+}
 …
 aubio_pitch_do (aubio_pitch_t * p, fvec_t * ibuf, fvec_t * obuf)
+{
+  uint_t i;
   p->callback (p, ibuf, obuf);
+  obuf->data[0] = p->freqconv (obuf->data[0], p->srate, p->bufsize);
+  for (i = 0; i < obuf->channels; i++) {
+    p->freqconv (obuf->data[i][0], p->srate, p->bufsize);
+  }
+}
 …
 aubio_pitch_do_mcomb (aubio_pitch_t * p, fvec_t * ibuf, fvec_t * obuf)
+{
+  uint_t i;
   aubio_filter_do (p->filter, ibuf);
   aubio_pvoc_do (p->pv, ibuf, p->fftgrain);
   aubio_pitchmcomb_do (p->mcomb, p->fftgrain, obuf);
+  obuf->data[0] = aubio_bintofreq (obuf->data[0], p->srate, p->bufsize);
+  for (i = 0; i < obuf->channels; i++) {
+    obuf->data[i][0] = aubio_bintofreq (obuf->data[i][0], p->srate, p->bufsize);
+  }
+}
 …
+{
   smpl_t pitch = 0.;
+  uint_t i;
   aubio_pitch_slideblock (p, ibuf);
   aubio_pitchyin_do (p->yin, p->buf, obuf);
+  pitch = obuf->data[0];
+  if (pitch > 0) {
+    pitch = p->srate / (pitch + 0.);
+  } else {
+    pitch = 0.;
+  }
+  obuf->data[0] = pitch;
+  for (i = 0; i < obuf->channels; i++) {
+    pitch = obuf->data[i][0];
+    if (pitch > 0) {
+      pitch = p->srate / (pitch + 0.);
+    } else {
+      pitch = 0.;
+    }
+    obuf->data[i][0] = pitch;
+  }
+}
 …
+{
   smpl_t pitch = 0.;
+  uint_t i;
   aubio_pitch_slideblock (p, ibuf);
   aubio_pitchyinfft_do (p->yinfft, p->buf, obuf);
+  pitch = obuf->data[0];
+  if (pitch > 0) {
+    pitch = p->srate / (pitch + 0.);
+  } else {
+    pitch = 0.;
+  }
+  obuf->data[0] = pitch;
+  for (i = 0; i < obuf->channels; i++) {
+    pitch = obuf->data[i][0];
+    if (pitch > 0) {
+      pitch = p->srate / (pitch + 0.);
+    } else {
+      pitch = 0.;
+    }
+    obuf->data[i][0] = pitch;
+  }
+}
 …
 aubio_pitch_do_fcomb (aubio_pitch_t * p, fvec_t * ibuf, fvec_t * out)
+{
+  uint_t i;
   aubio_pitch_slideblock (p, ibuf);
   aubio_pitchfcomb_do (p->fcomb, p->buf, out);
+  out->data[0] = aubio_bintofreq (out->data[0], p->srate, p->bufsize);
+  for (i = 0; i < out->channels; i++) {
+    out->data[i][0] = aubio_bintofreq (out->data[i][0], p->srate, p->bufsize);
+  }
+}
 …
+{
   smpl_t period, pitch = 0.;
+  uint_t i;
   aubio_pitch_slideblock (p, ibuf);
   aubio_pitchschmitt_do (p->schmitt, p->buf, out);
+  period = out->data[0];
+  if (period > 0) {
+    pitch = p->srate / period;
+  } else {
+    pitch = 0.;
+  }
+  out->data[0] = pitch;
+}
+  for (i = 0; i < out->channels; i++) {
+    period = out->data[i][0];
+    if (period > 0) {
+      pitch = p->srate / period;
+    } else {
+      pitch = 0.;
+    }
+    out->data[i][0] = pitch;
+  }
+}

TabularUnified src/pitch/pitch.h ¶

-                      r8212692
+                      rf650860
   \param o pitch detection object as returned by new_aubio_pitch()
   \param in input signal of size [hop_size]
   \param out output pitch candidates of size [1]
+  \param in input signal of size [hop_size x channels]
+  \param out output pitch candidates of size [1 x channels]
 */
 …
   \param buf_size size of the input buffer to analyse
   \param hop_size step size between two consecutive analysis instant
+  \param channels number of channels to analyse
   \param samplerate sampling rate of the signal
 */
 aubio_pitch_t *new_aubio_pitch (char_t * method,
     uint_t buf_size, uint_t hop_size, uint_t samplerate);
+    uint_t buf_size, uint_t hop_size, uint_t channels, uint_t samplerate);
 /** set the output unit of the pitch detection object

TabularUnified src/pitch/pitchfcomb.c ¶

-                      r8212692
+                      rf650860
 aubio_pitchfcomb_t *
 new_aubio_pitchfcomb (uint_t bufsize, uint_t hopsize)
+new_aubio_pitchfcomb (uint_t bufsize, uint_t hopsize, uint_t channels)
+{
   aubio_pitchfcomb_t *p = AUBIO_NEW (aubio_pitchfcomb_t);
   p->fftSize = bufsize;
   p->stepSize = hopsize;
   p->winput = new_fvec (bufsize);
   p->fftOut = new_cvec (bufsize);
   p->fftLastPhase = new_fvec (bufsize);
   p->fft = new_aubio_fft (bufsize);
+  p->winput = new_fvec (bufsize, 1);
+  p->fftOut = new_cvec (bufsize, 1);
+  p->fftLastPhase = new_fvec (bufsize, channels);
+  p->fft = new_aubio_fft (bufsize, 1);
   p->win = new_aubio_window ("hanning", bufsize);
   return p;
 …
 aubio_pitchfcomb_do (aubio_pitchfcomb_t * p, fvec_t * input, fvec_t * output)
+{
   uint_t k, l, maxharm = 0;
+  uint_t i, k, l, maxharm = 0;
   smpl_t phaseDifference = TWO_PI * (smpl_t) p->stepSize / (smpl_t) p->fftSize;
   aubio_fpeak_t peaks[MAX_PEAKS];
+  for (k = 0; k < MAX_PEAKS; k++) {
+    peaks[k].db = -200.;
+    peaks[k].bin = 0.;
+  }
+  for (i = 0; i < input->channels; i++) {
   for (k = 0; k < input->length; k++) {
     p->winput->data[k] = p->win->data[k] * input->data[k];
+  }
   aubio_fft_do (p->fft, p->winput, p->fftOut);
+    for (k = 0; k < MAX_PEAKS; k++) {
+      peaks[k].db = -200.;
+      peaks[k].bin = 0.;
+    }
+  for (k = 0; k <= p->fftSize / 2; k++) {
+    smpl_t
+        magnitude =
+. * LOG10 (2. * p->fftOut->norm[k] / (smpl_t) p->fftSize),
+        phase = p->fftOut->phas[k], tmp, bin;
+    for (k = 0; k < input->length; k++) {
+      p->winput->data[0][k] = p->win->data[0][k] * input->data[i][k];
+    }
+    aubio_fft_do (p->fft, p->winput, p->fftOut);
+    /* compute phase difference */
+    tmp = phase - p->fftLastPhase->data[k];
+    p->fftLastPhase->data[k] = phase;
+    for (k = 0; k <= p->fftSize / 2; k++) {
+      smpl_t
+          magnitude =
+. * LOG10 (2. * p->fftOut->norm[0][k] / (smpl_t) p->fftSize),
+          phase = p->fftOut->phas[0][k], tmp, bin;
+    /* subtract expected phase difference */
+    tmp -= (smpl_t) k *phaseDifference;
+      /* compute phase difference */
+      tmp = phase - p->fftLastPhase->data[i][k];
+      p->fftLastPhase->data[i][k] = phase;
     /* map delta phase into +/- Pi interval */
     tmp = aubio_unwrap2pi (tmp);
+      /* subtract expected phase difference */
+      tmp -= (smpl_t) k *phaseDifference;
     /* get deviation from bin frequency from the +/- Pi interval */
     tmp = p->fftSize / (smpl_t) p->stepSize * tmp / (TWO_PI);
+      /* map delta phase into +/- Pi interval */
+      tmp = aubio_unwrap2pi (tmp);
     /* compute the k-th partials' true bin */
     bin = (smpl_t) k + tmp;
+      /* get deviation from bin frequency from the +/- Pi interval */
+      tmp = p->fftSize / (smpl_t) p->stepSize * tmp / (TWO_PI);
+    if (bin > 0.0 && magnitude > peaks[0].db) {       // && magnitude < 0) {
+      memmove (peaks + 1, peaks, sizeof (aubio_fpeak_t) * (MAX_PEAKS - 1));
+      peaks[0].bin = bin;
+      peaks[0].db = magnitude;
+      /* compute the k-th partials' true bin */
+      bin = (smpl_t) k + tmp;
+      if (bin > 0.0 && magnitude > peaks[0].db) {       // && magnitude < 0) {
+        memmove (peaks + 1, peaks, sizeof (aubio_fpeak_t) * (MAX_PEAKS - 1));
+        peaks[0].bin = bin;
+        peaks[0].db = magnitude;
+      }
+    }
+  }
+  k = 0;
+  for (l = 1; l < MAX_PEAKS && peaks[l].bin > 0.0; l++) {
+    sint_t harmonic;
+    for (harmonic = 5; harmonic > 1; harmonic--) {
+      if (peaks[0].bin / peaks[l].bin < harmonic + .02 &&
+          peaks[0].bin / peaks[l].bin > harmonic - .02) {
+        if (harmonic > (sint_t) maxharm && peaks[0].db < peaks[l].db / 2) {
+          maxharm = harmonic;
+          k = l;
+    k = 0;
+    for (l = 1; l < MAX_PEAKS && peaks[l].bin > 0.0; l++) {
+      sint_t harmonic;
+      for (harmonic = 5; harmonic > 1; harmonic--) {
+        if (peaks[0].bin / peaks[l].bin < harmonic + .02 &&
+            peaks[0].bin / peaks[l].bin > harmonic - .02) {
+          if (harmonic > (sint_t) maxharm && peaks[0].db < peaks[l].db / 2) {
+            maxharm = harmonic;
+            k = l;
+          }
+        }
+      }
+    }
+    output->data[i][0] = peaks[k].bin;
+    /* quick hack to clean output a bit */
+    if (peaks[k].bin > 5000.)
+      output->data[i][0] = 0.;
+  }
-  output->data[0] = peaks[k].bin;
-  /* quick hack to clean output a bit */
-  if (peaks[k].bin > 5000.)
-    output->data[0] = 0.;
+}

TabularUnified src/pitch/pitchfcomb.h ¶

-                      r8212692
+                      rf650860
   \param buf_size size of the input buffer to analyse
   \param hop_size step size between two consecutive analysis instant
+  \param channels number of channels to detect pitch on
 */
+aubio_pitchfcomb_t *new_aubio_pitchfcomb (uint_t buf_size, uint_t hop_size);
+aubio_pitchfcomb_t *new_aubio_pitchfcomb (uint_t buf_size, uint_t hop_size,
+    uint_t channels);
 /** deletion of the pitch detection object

TabularUnified src/pitch/pitchmcomb.c ¶

-                      r8212692
+                      rf650860
 aubio_pitchmcomb_do (aubio_pitchmcomb_t * p, cvec_t * fftgrain, fvec_t * output)
+{
   uint_t j;
+  uint_t i, j;
   smpl_t instfreq;
   fvec_t *newmag = (fvec_t *) p->newmag;
   //smpl_t hfc; //fe=instfreq(theta1,theta,ops); //theta1=theta;
   /* copy incoming grain to newmag */
+  for (j = 0; j < newmag->length; j++)
+    newmag->data[j] = fftgrain->norm[j];
+  /* detect only if local energy > 10. */
+  //if (fvec_local_energy(newmag)>10.) {
+  //hfc = fvec_local_hfc(newmag); //not used
+  aubio_pitchmcomb_spectral_pp (p, newmag);
+  aubio_pitchmcomb_combdet (p, newmag);
+  //aubio_pitchmcomb_sort_cand_freq(p->candidates,p->ncand);
+  //return p->candidates[p->goodcandidate]->ebin;
+  j = (uint_t) FLOOR (p->candidates[p->goodcandidate]->ebin + .5);
+  instfreq = aubio_unwrap2pi (fftgrain->phas[j]
+      - p->theta->data[j] - j * p->phasediff);
+  instfreq *= p->phasefreq;
+  /* store phase for next run */
+  for (j = 0; j < p->theta->length; j++) {
+    p->theta->data[j] = fftgrain->phas[j];
+  }
+  //return p->candidates[p->goodcandidate]->ebin;
+  output->data[0] =
+      FLOOR (p->candidates[p->goodcandidate]->ebin + .5) + instfreq;
+  /*} else {
+     return -1.;
+     } */
+  for (i = 0; i < fftgrain->channels; i++) {
+    for (j = 0; j < newmag->length; j++)
+      newmag->data[0][j] = fftgrain->norm[i][j];
+    /* detect only if local energy > 10. */
+    //if (fvec_local_energy(newmag)>10.) {
+    //hfc = fvec_local_hfc(newmag); //not used
+    aubio_pitchmcomb_spectral_pp (p, newmag);
+    aubio_pitchmcomb_combdet (p, newmag);
+    //aubio_pitchmcomb_sort_cand_freq(p->candidates,p->ncand);
+    //return p->candidates[p->goodcandidate]->ebin;
+    j = (uint_t) FLOOR (p->candidates[p->goodcandidate]->ebin + .5);
+    instfreq = aubio_unwrap2pi (fftgrain->phas[i][j]
+        - p->theta->data[i][j] - j * p->phasediff);
+    instfreq *= p->phasefreq;
+    /* store phase for next run */
+    for (j = 0; j < p->theta->length; j++) {
+      p->theta->data[i][j] = fftgrain->phas[i][j];
+    }
+    //return p->candidates[p->goodcandidate]->ebin;
+    output->data[i][0] =
+        FLOOR (p->candidates[p->goodcandidate]->ebin + .5) + instfreq;
+    /*} else {
+       return -1.;
+       } */
+  }
+}
 …
 aubio_pitch_cands (aubio_pitchmcomb_t * p, cvec_t * fftgrain, smpl_t * cands)
+{
   uint_t j;
+  uint_t i = 0, j;
   uint_t k;
   fvec_t *newmag = (fvec_t *) p->newmag;
 …
   /* copy incoming grain to newmag */
   for (j = 0; j < newmag->length; j++)
     newmag->data[j] = fftgrain->norm[j];
+    newmag->data[i][j] = fftgrain->norm[i][j];
   /* detect only if local energy > 10. */
   if (fvec_local_energy (newmag) > 10.) {
 …
   fvec_t *mag = (fvec_t *) p->scratch;
   fvec_t *tmp = (fvec_t *) p->scratch2;
   uint_t j;
+  uint_t i = 0, j;
   uint_t length = mag->length;
   /* copy newmag to mag (scracth) */
   for (j = 0; j < length; j++) {
     mag->data[j] = newmag->data[j];
+    mag->data[i][j] = newmag->data[i][j];
+  }
   fvec_min_removal (mag);       /* min removal          */
 …
   /* skipped *//* low pass filtering   */
   /** \bug fvec_moving_thres may write out of bounds */
   fvec_adapt_thres (mag, tmp, p->win_post, p->win_pre);      /* adaptative threshold */
+  fvec_adapt_thres (mag, tmp, p->win_post, p->win_pre, i);      /* adaptative threshold */
   fvec_add (mag, -p->threshold);        /* fixed threshold      */
+  {
 …
     count = aubio_pitchmcomb_quadpick (peaks, mag);
     for (j = 0; j < count; j++)
       peaks[j].mag = newmag->data[peaks[j].bin];
+      peaks[j].mag = newmag->data[i][peaks[j].bin];
     /* reset non peaks */
     for (j = count; j < length; j++)
 …
         candidate[l]->ecomb[k] = peaks[position].ebin;
         candidate[l]->ene +=    /* ecomb rounded to nearest int */
             POW (newmag->data[(uint_t) FLOOR (candidate[l]->ecomb[k] + .5)],
+            POW (newmag->data[0][(uint_t) FLOOR (candidate[l]->ecomb[k] + .5)],
 .25);
         candidate[l]->len += 1. / curlen;
 …
 aubio_pitchmcomb_quadpick (aubio_spectralpeak_t * spectral_peaks, fvec_t * X)
+{
+  uint_t j, ispeak, count = 0;
+  for (j = 1; j < X->length - 1; j++) {
+    ispeak = fvec_peakpick (X, j);
+    if (ispeak) {
+      count += ispeak;
+      spectral_peaks[count - 1].bin = j;
+      spectral_peaks[count - 1].ebin = fvec_quadint (X, j) - 1.;
+    }
+  }
+  uint_t i, j, ispeak, count = 0;
+  for (i = 0; i < X->channels; i++)
+    for (j = 1; j < X->length - 1; j++) {
+      ispeak = fvec_peakpick (X, j);
+      if (ispeak) {
+        count += ispeak;
+        spectral_peaks[count - 1].bin = j;
+        spectral_peaks[count - 1].ebin = fvec_quadint (X, j, i) - 1.;
+      }
+    }
   return count;
+}
 …
 aubio_pitchmcomb_t *
 new_aubio_pitchmcomb (uint_t bufsize, uint_t hopsize)
+new_aubio_pitchmcomb (uint_t bufsize, uint_t hopsize, uint_t channels)
+{
   aubio_pitchmcomb_t *p = AUBIO_NEW (aubio_pitchmcomb_t);
 …
   //p->biquad = new_biquad(0.1600,0.3200,0.1600, -0.5949, 0.2348);
   /* allocate temp memory */
   p->newmag = new_fvec (spec_size);
+  p->newmag = new_fvec (spec_size, 1);
   /* array for median */
   p->scratch = new_fvec (spec_size);
+  p->scratch = new_fvec (spec_size, 1);
   /* array for phase */
   p->theta = new_fvec (spec_size);
+  p->theta = new_fvec (spec_size, channels);
   /* array for adaptative threshold */
   p->scratch2 = new_fvec (p->win_post + p->win_pre + 1);
+  p->scratch2 = new_fvec (p->win_post + p->win_pre + 1, 1);
   /* array of spectral peaks */
   p->peaks = AUBIO_ARRAY (aubio_spectralpeak_t, spec_size);

TabularUnified src/pitch/pitchmcomb.h ¶

-                      r8212692
+                      rf650860
   \param buf_size size of the input buffer to analyse
   \param hop_size step size between two consecutive analysis instant
+  \param channels number of channels to analyse
   \param samplerate sampling rate of the signal
 */
+aubio_pitchmcomb_t *new_aubio_pitchmcomb (uint_t buf_size, uint_t hop_size);
+aubio_pitchmcomb_t *new_aubio_pitchmcomb (uint_t buf_size, uint_t hop_size,
+    uint_t channels);
 /** deletion of the pitch detection object

TabularUnified src/pitch/pitchschmitt.c ¶

-                      r8212692
+                      rf650860
     fvec_t * output)
+{
+  uint_t j;
+  for (j = 0; j < input->length; j++) {
+    p->buf[j] = input->data[j] * 32768.;
+  uint_t i, j;
+  for (i = 0; i < input->channels; i++) {
+    for (j = 0; j < input->length; j++) {
+      p->buf[j] = input->data[i][j] * 32768.;
+    }
+    output->data[i][0] = aubio_schmittS16LE (p, input->length, p->buf);
+  }
-  output->data[0] = aubio_schmittS16LE (p, input->length, p->buf);
+}

TabularUnified src/pitch/pitchyin.c ¶

-                      r8212692
+                      rf650860
+{
   aubio_pitchyin_t *o = AUBIO_NEW (aubio_pitchyin_t);
   o->yin = new_fvec (bufsize / 2);
+  o->yin = new_fvec (bufsize / 2, 1);
   o->tol = 0.15;
   return o;
 …
 aubio_pitchyin_diff (fvec_t * input, fvec_t * yin)
+{
   uint_t j, tau;
+  uint_t c, j, tau;
   smpl_t tmp;
+  for (tau = 0; tau < yin->length; tau++) {
+    yin->data[tau] = 0.;
+  }
+  for (tau = 1; tau < yin->length; tau++) {
+    for (j = 0; j < yin->length; j++) {
+      tmp = input->data[j] - input->data[j + tau];
+      yin->data[tau] += SQR (tmp);
+  for (c = 0; c < input->channels; c++) {
+    for (tau = 0; tau < yin->length; tau++) {
+      yin->data[c][tau] = 0.;
+    }
+    for (tau = 1; tau < yin->length; tau++) {
+      for (j = 0; j < yin->length; j++) {
+        tmp = input->data[c][j] - input->data[c][j + tau];
+        yin->data[c][tau] += SQR (tmp);
+      }
+    }
+  }
 …
 aubio_pitchyin_getcum (fvec_t * yin)
+{
   uint_t tau;
+  uint_t c, tau;
   smpl_t tmp;
+  tmp = 0.;
+  yin->data[0] = 1.;
+  //AUBIO_DBG("%f\t",yin->data[0]);
+  for (tau = 1; tau < yin->length; tau++) {
+    tmp += yin->data[tau];
+    yin->data[tau] *= tau / tmp;
+    //AUBIO_DBG("%f\t",yin->data[tau]);
+  for (c = 0; c < yin->channels; c++) {
+    tmp = 0.;
+    yin->data[c][0] = 1.;
+    //AUBIO_DBG("%f\t",yin->data[c][0]);
+    for (tau = 1; tau < yin->length; tau++) {
+      tmp += yin->data[c][tau];
+      yin->data[c][tau] *= tau / tmp;
+      //AUBIO_DBG("%f\t",yin->data[c][tau]);
+    }
+    //AUBIO_DBG("\n");
+  }
-  //AUBIO_DBG("\n");
+}
 …
 aubio_pitchyin_getpitch (fvec_t * yin)
+{
   uint_t tau = 1;
+  uint_t c = 0, tau = 1;
   do {
     if (yin->data[tau] < 0.1) {
       while (yin->data[tau + 1] < yin->data[tau]) {
+    if (yin->data[c][tau] < 0.1) {
+      while (yin->data[c][tau + 1] < yin->data[c][tau]) {
         tau++;
+      }
 …
   smpl_t tol = o->tol;
   fvec_t *yin = o->yin;
   uint_t j, tau = 0;
+  uint_t c, j, tau = 0;
   sint_t period;
   smpl_t tmp = 0., tmp2 = 0.;
+  yin->data[0] = 1.;
+  for (tau = 1; tau < yin->length; tau++) {
+    yin->data[tau] = 0.;
+    for (j = 0; j < yin->length; j++) {
+      tmp = input->data[j] - input->data[j + tau];
+      yin->data[tau] += SQR (tmp);
+  for (c = 0; c < input->channels; c++) {
+    yin->data[c][0] = 1.;
+    for (tau = 1; tau < yin->length; tau++) {
+      yin->data[c][tau] = 0.;
+      for (j = 0; j < yin->length; j++) {
+        tmp = input->data[c][j] - input->data[c][j + tau];
+        yin->data[c][tau] += SQR (tmp);
+      }
+      tmp2 += yin->data[c][tau];
+      yin->data[c][tau] *= tau / tmp2;
+      period = tau - 3;
+      if (tau > 4 && (yin->data[c][period] < tol) &&
+          (yin->data[c][period] < yin->data[c][period + 1])) {
+        out->data[c][0] = fvec_quadint (yin, period, c);
+        goto beach;
+      }
+    }
+    tmp2 += yin->data[tau];
+    yin->data[tau] *= tau / tmp2;
+    period = tau - 3;
+    if (tau > 4 && (yin->data[period] < tol) &&
+        (yin->data[period] < yin->data[period + 1])) {
+      out->data[0] = fvec_quadint (yin, period);
+      goto beach;
+    }
+    out->data[c][0] = fvec_quadint (yin, fvec_min_elem (yin), c);
+  beach:
+    continue;
+  }
+  out->data[0] = fvec_quadint (yin, fvec_min_elem (yin));
+beach:
+  return;
+  //return 0;
+}

TabularUnified src/pitch/pitchyinfft.c ¶

-                      r8212692
+                      rf650860
+{
   aubio_pitchyinfft_t *p = AUBIO_NEW (aubio_pitchyinfft_t);
   p->winput = new_fvec (bufsize);
   p->fft = new_aubio_fft (bufsize);
   p->fftout = new_cvec (bufsize);
   p->sqrmag = new_fvec (bufsize);
   p->res = new_cvec (bufsize);
   p->yinfft = new_fvec (bufsize / 2 + 1);
+  p->winput = new_fvec (bufsize, 1);
+  p->fft = new_aubio_fft (bufsize, 1);
+  p->fftout = new_cvec (bufsize, 1);
+  p->sqrmag = new_fvec (bufsize, 1);
+  p->res = new_cvec (bufsize, 1);
+  p->yinfft = new_fvec (bufsize / 2 + 1, 1);
   p->tol = 0.85;
   p->win = new_aubio_window ("hanningz", bufsize);
+  p->weight = new_fvec (bufsize / 2 + 1);
+  uint_t i = 0, j = 1;
+  smpl_t freq = 0, a0 = 0, a1 = 0, f0 = 0, f1 = 0;
+  for (i = 0; i < p->weight->length; i++) {
+    freq = (smpl_t) i / (smpl_t) bufsize *(smpl_t) 44100.;
+    while (freq > freqs[j]) {
+      j += 1;
+  p->weight = new_fvec (bufsize / 2 + 1, 1);
+  {
+    uint_t i = 0, j = 1;
+    smpl_t freq = 0, a0 = 0, a1 = 0, f0 = 0, f1 = 0;
+    for (i = 0; i < p->weight->length; i++) {
+      freq = (smpl_t) i / (smpl_t) bufsize *(smpl_t) 44100.;
+      while (freq > freqs[j]) {
+        j += 1;
+      }
+      a0 = weight[j - 1];
+      f0 = freqs[j - 1];
+      a1 = weight[j];
+      f1 = freqs[j];
+      if (f0 == f1) {           // just in case
+        p->weight->data[0][i] = a0;
+      } else if (f0 == 0) {     // y = ax+b
+        p->weight->data[0][i] = (a1 - a0) / f1 * freq + a0;
+      } else {
+        p->weight->data[0][i] = (a1 - a0) / (f1 - f0) * freq +
+            (a0 - (a1 - a0) / (f1 / f0 - 1.));
+      }
+      while (freq > freqs[j]) {
+        j += 1;
+      }
+      //AUBIO_DBG("%f\n",p->weight->data[0][i]);
+      p->weight->data[0][i] = DB2LIN (p->weight->data[0][i]);
+      //p->weight->data[0][i] = SQRT(DB2LIN(p->weight->data[0][i]));
+    }
-    a0 = weight[j - 1];
-    f0 = freqs[j - 1];
-    a1 = weight[j];
-    f1 = freqs[j];
-    if (f0 == f1) {           // just in case
-      p->weight->data[i] = a0;
-    } else if (f0 == 0) {     // y = ax+b
-      p->weight->data[i] = (a1 - a0) / f1 * freq + a0;
-    } else {
-      p->weight->data[i] = (a1 - a0) / (f1 - f0) * freq +
-          (a0 - (a1 - a0) / (f1 / f0 - 1.));
+    }
-    while (freq > freqs[j]) {
-      j += 1;
+    }
-    //AUBIO_DBG("%f\n",p->weight->data[i]);
-    p->weight->data[i] = DB2LIN (p->weight->data[i]);
-    //p->weight->data[i] = SQRT(DB2LIN(p->weight->data[i]));
+  }
   return p;
 …
 aubio_pitchyinfft_do (aubio_pitchyinfft_t * p, fvec_t * input, fvec_t * output)
+{
   uint_t tau, l;
+  uint_t i, tau, l;
   uint_t halfperiod;
   smpl_t tmp, sum;
   cvec_t *res = (cvec_t *) p->res;
   fvec_t *yin = (fvec_t *) p->yinfft;
+  l = 0;
+  tmp = 0.;
+  sum = 0.;
+  for (l = 0; l < input->length; l++) {
+    p->winput->data[l] = p->win->data[l] * input->data[l];
+  }
+  aubio_fft_do (p->fft, p->winput, p->fftout);
+  for (l = 0; l < p->fftout->length; l++) {
+    p->sqrmag->data[l] = SQR (p->fftout->norm[l]);
+    p->sqrmag->data[l] *= p->weight->data[l];
+  }
+  for (l = 1; l < p->fftout->length; l++) {
+    p->sqrmag->data[(p->fftout->length - 1) * 2 - l] =
+        SQR (p->fftout->norm[l]);
+    p->sqrmag->data[(p->fftout->length - 1) * 2 - l] *=
+        p->weight->data[l];
+  }
+  for (l = 0; l < p->sqrmag->length / 2 + 1; l++) {
+    sum += p->sqrmag->data[l];
+  }
+  sum *= 2.;
+  aubio_fft_do (p->fft, p->sqrmag, res);
+  yin->data[0] = 1.;
+  for (tau = 1; tau < yin->length; tau++) {
+    yin->data[tau] = sum - res->norm[tau] * COS (res->phas[tau]);
+    tmp += yin->data[tau];
+    yin->data[tau] *= tau / tmp;
+  }
+  tau = fvec_min_elem (yin);
+  if (yin->data[tau] < p->tol) {
+    /* no interpolation */
+    //return tau;
+    /* 3 point quadratic interpolation */
+    //return fvec_quadint_min(yin,tau,1);
+    /* additional check for (unlikely) octave doubling in higher frequencies */
+    if (tau > 35) {
+      output->data[0] = fvec_quadint (yin, tau);
+  for (i = 0; i < input->channels; i++) {
+    l = 0;
+    tmp = 0.;
+    sum = 0.;
+    for (l = 0; l < input->length; l++) {
+      p->winput->data[0][l] = p->win->data[0][l] * input->data[i][l];
+    }
+    aubio_fft_do (p->fft, p->winput, p->fftout);
+    for (l = 0; l < p->fftout->length; l++) {
+      p->sqrmag->data[0][l] = SQR (p->fftout->norm[0][l]);
+      p->sqrmag->data[0][l] *= p->weight->data[0][l];
+    }
+    for (l = 1; l < p->fftout->length; l++) {
+      p->sqrmag->data[0][(p->fftout->length - 1) * 2 - l] =
+          SQR (p->fftout->norm[0][l]);
+      p->sqrmag->data[0][(p->fftout->length - 1) * 2 - l] *=
+          p->weight->data[0][l];
+    }
+    for (l = 0; l < p->sqrmag->length / 2 + 1; l++) {
+      sum += p->sqrmag->data[0][l];
+    }
+    sum *= 2.;
+    aubio_fft_do (p->fft, p->sqrmag, res);
+    yin->data[0][0] = 1.;
+    for (tau = 1; tau < yin->length; tau++) {
+      yin->data[0][tau] = sum - res->norm[0][tau] * COS (res->phas[0][tau]);
+      tmp += yin->data[0][tau];
+      yin->data[0][tau] *= tau / tmp;
+    }
+    tau = fvec_min_elem (yin);
+    if (yin->data[0][tau] < p->tol) {
+      /* no interpolation */
+      //return tau;
+      /* 3 point quadratic interpolation */
+      //return fvec_quadint_min(yin,tau,1);
+      /* additional check for (unlikely) octave doubling in higher frequencies */
+      if (tau > 35) {
+        output->data[i][0] = fvec_quadint (yin, tau, i);
+      } else {
+        /* should compare the minimum value of each interpolated peaks */
+        halfperiod = FLOOR (tau / 2 + .5);
+        if (yin->data[0][halfperiod] < p->tol)
+          output->data[i][0] = fvec_quadint (yin, halfperiod, i);
+        else
+          output->data[i][0] = fvec_quadint (yin, tau, i);
+      }
     } else {
+      /* should compare the minimum value of each interpolated peaks */
+      halfperiod = FLOOR (tau / 2 + .5);
+      if (yin->data[halfperiod] < p->tol)
+        output->data[0] = fvec_quadint (yin, halfperiod);
+      else
+        output->data[0] = fvec_quadint (yin, tau);
+      output->data[i][0] = 0.;
+    }
-  } else {
-    output->data[0] = 0.;
+  }
+}

TabularUnified src/spectral/fft.c ¶

-                      r8212692
+                      rf650860
 struct _aubio_fft_t {
   uint_t winsize;
+  uint_t channels;
   uint_t fft_size;
   real_t *in, *out;
 …
 };
 aubio_fft_t * new_aubio_fft(uint_t winsize) {
+aubio_fft_t * new_aubio_fft(uint_t winsize, uint_t channels) {
   aubio_fft_t * s = AUBIO_NEW(aubio_fft_t);
   uint_t i;
   s->winsize  = winsize;
+  s->channels = channels;
   /* allocate memory */
   s->in       = AUBIO_ARRAY(real_t,winsize);
   s->out      = AUBIO_ARRAY(real_t,winsize);
   s->compspec = new_fvec(winsize);
+  s->compspec = new_fvec(winsize,channels);
   /* create plans */
 #ifdef HAVE_COMPLEX_H
 …
 void aubio_fft_do_complex(aubio_fft_t * s, fvec_t * input, fvec_t * compspec) {
+  uint_t j;
+  for (j=0; j < s->winsize; j++) {
+    s->in[j] = input->data[j];
+  }
+  fftw_execute(s->pfw);
+#ifdef HAVE_COMPLEX_H
+  compspec->data[0] = REAL(s->specdata[0]);
+  for (j = 1; j < s->fft_size -1 ; j++) {
+    compspec->data[j] = REAL(s->specdata[j]);
+    compspec->data[compspec->length - j] = IMAG(s->specdata[j]);
+  }
+  compspec->data[s->fft_size-1] = REAL(s->specdata[s->fft_size-1]);
+#else
+  for (j = 0; j < s->fft_size; j++) {
+    compspec->data[j] = s->specdata[j];
+  }
+#endif
+  uint_t i, j;
+  for (i = 0; i < s->channels; i++) {
+    for (j=0; j < s->winsize; j++) {
+      s->in[j] = input->data[i][j];
+    }
+    fftw_execute(s->pfw);
+#ifdef HAVE_COMPLEX_H
+    compspec->data[i][0] = REAL(s->specdata[0]);
+    for (j = 1; j < s->fft_size -1 ; j++) {
+      compspec->data[i][j] = REAL(s->specdata[j]);
+      compspec->data[i][compspec->length - j] = IMAG(s->specdata[j]);
+    }
+    compspec->data[i][s->fft_size-1] = REAL(s->specdata[s->fft_size-1]);
+#else
+    for (j = 0; j < s->fft_size; j++) {
+      compspec->data[i][j] = s->specdata[j];
+    }
+#endif
+  }
+}
 void aubio_fft_rdo_complex(aubio_fft_t * s, fvec_t * compspec, fvec_t * output) {
   uint_t j;
+  uint_t i, j;
   const smpl_t renorm = 1./(smpl_t)s->winsize;
+#ifdef HAVE_COMPLEX_H
+  s->specdata[0] = compspec->data[0];
+  for (j=1; j < s->fft_size - 1; j++) {
+    s->specdata[j] = compspec->data[j] +
+      I * compspec->data[compspec->length - j];
+  }
+  s->specdata[s->fft_size - 1] = compspec->data[s->fft_size - 1];
+#else
+  for (j=0; j < s->fft_size; j++) {
+    s->specdata[j] = compspec->data[j];
+  }
+#endif
+  fftw_execute(s->pbw);
+  for (j = 0; j < output->length; j++) {
+    output->data[j] = s->out[j]*renorm;
+  for (i = 0; i < compspec->channels; i++) {
+#ifdef HAVE_COMPLEX_H
+    s->specdata[0] = compspec->data[i][0];
+    for (j=1; j < s->fft_size - 1; j++) {
+      s->specdata[j] = compspec->data[i][j] +
+        I * compspec->data[i][compspec->length - j];
+    }
+    s->specdata[s->fft_size - 1] = compspec->data[i][s->fft_size - 1];
+#else
+    for (j=0; j < s->fft_size; j++) {
+      s->specdata[j] = compspec->data[i][j];
+    }
+#endif
+    fftw_execute(s->pbw);
+    for (j = 0; j < output->length; j++) {
+      output->data[i][j] = s->out[j]*renorm;
+    }
+  }
+}
 …
 void aubio_fft_get_phas(fvec_t * compspec, cvec_t * spectrum) {
+  uint_t j;
+  if (compspec->data[0] < 0) {
+    spectrum->phas[0] = PI;
+  } else {
+    spectrum->phas[0] = 0.;
+  }
+  for (j=1; j < spectrum->length - 1; j++) {
+    spectrum->phas[j] = ATAN2(compspec->data[compspec->length-j],
+        compspec->data[j]);
+  }
+  if (compspec->data[compspec->length/2] < 0) {
+    spectrum->phas[spectrum->length - 1] = PI;
+  } else {
+    spectrum->phas[spectrum->length - 1] = 0.;
+  uint_t i, j;
+  for (i = 0; i < spectrum->channels; i++) {
+    if (compspec->data[i][0] < 0) {
+      spectrum->phas[i][0] = PI;
+    } else {
+      spectrum->phas[i][0] = 0.;
+    }
+    for (j=1; j < spectrum->length - 1; j++) {
+      spectrum->phas[i][j] = ATAN2(compspec->data[i][compspec->length-j],
+          compspec->data[i][j]);
+    }
+    if (compspec->data[i][compspec->length/2] < 0) {
+      spectrum->phas[i][spectrum->length - 1] = PI;
+    } else {
+      spectrum->phas[i][spectrum->length - 1] = 0.;
+    }
+  }
+}
 void aubio_fft_get_norm(fvec_t * compspec, cvec_t * spectrum) {
+  uint_t j = 0;
+  spectrum->norm[0] = ABS(compspec->data[0]);
+  for (j=1; j < spectrum->length - 1; j++) {
+    spectrum->norm[j] = SQRT(SQR(compspec->data[j])
+        + SQR(compspec->data[compspec->length - j]) );
+  }
+  spectrum->norm[spectrum->length-1] =
+    ABS(compspec->data[compspec->length/2]);
+  uint_t i, j = 0;
+  for (i = 0; i < spectrum->channels; i++) {
+    spectrum->norm[i][0] = ABS(compspec->data[i][0]);
+    for (j=1; j < spectrum->length - 1; j++) {
+      spectrum->norm[i][j] = SQRT(SQR(compspec->data[i][j])
+          + SQR(compspec->data[i][compspec->length - j]) );
+    }
+    spectrum->norm[i][spectrum->length-1] =
+      ABS(compspec->data[i][compspec->length/2]);
+  }
+}
 void aubio_fft_get_imag(cvec_t * spectrum, fvec_t * compspec) {
+  uint_t j;
+  for (j = 1; j < ( compspec->length + 1 ) / 2 /*- 1 + 1*/; j++) {
+    compspec->data[compspec->length - j] =
+      spectrum->norm[j]*SIN(spectrum->phas[j]);
+  uint_t i, j;
+  for (i = 0; i < compspec->channels; i++) {
+    for (j = 1; j < ( compspec->length + 1 ) / 2 /*- 1 + 1*/; j++) {
+      compspec->data[i][compspec->length - j] =
+        spectrum->norm[i][j]*SIN(spectrum->phas[i][j]);
+    }
+  }
+}
 void aubio_fft_get_real(cvec_t * spectrum, fvec_t * compspec) {
+  uint_t j;
+  for (j = 0; j < compspec->length / 2 + 1; j++) {
+    compspec->data[j] =
+      spectrum->norm[j]*COS(spectrum->phas[j]);
+  }
+}
+  uint_t i, j;
+  for (i = 0; i < compspec->channels; i++) {
+    for (j = 0; j < compspec->length / 2 + 1; j++) {
+      compspec->data[i][j] =
+        spectrum->norm[i][j]*COS(spectrum->phas[i][j]);
+    }
+  }
+}

TabularUnified src/spectral/fft.h ¶

-                      r8212692
+                      rf650860
   \param size length of the FFT
+  \param channels number of channels
 */
 aubio_fft_t * new_aubio_fft (uint_t size);
+aubio_fft_t * new_aubio_fft(uint_t size, uint_t channels);
 /** delete FFT object

TabularUnified src/spectral/filterbank.c ¶

-                      r8212692
+                      rf650860
 #include "aubio_priv.h"
 #include "fvec.h"
-#include "fmat.h"
 #include "cvec.h"
 #include "spectral/filterbank.h"
 …
   uint_t win_s;
   uint_t n_filters;
   fmat_t *filters;
+  fvec_t *filters;
 };
 …
   fb->n_filters = n_filters;
   /* allocate filter tables, a matrix of length win_s and of height n_filters */
   fb->filters = new_fmat (win_s / 2 + 1, n_filters);
+  /* allocate filter tables, an fvec of length win_s and of filter_cnt channel */
+  fb->filters = new_fvec (win_s / 2 + 1, n_filters);
   return fb;
 …
 del_aubio_filterbank (aubio_filterbank_t * fb)
+{
   del_fmat (fb->filters);
+  del_fvec (fb->filters);
   AUBIO_FREE (fb);
+}
 …
 aubio_filterbank_do (aubio_filterbank_t * f, cvec_t * in, fvec_t * out)
+{
   uint_t j, fn;
+  uint_t i, j, fn;
   /* apply filter to all input channel, provided out has enough channels */
+  uint_t max_channels = MIN (in->channels, out->channels);
   uint_t max_filters = MIN (f->n_filters, out->length);
   uint_t max_length = MIN (in->length, f->filters->length);
 …
   fvec_zeros (out);
   /* for each filter */
   for (fn = 0; fn < max_filters; fn++) {
+  /* apply filters on all channels */
+  for (i = 0; i < max_channels; i++) {
+    /* for each sample */
+    for (j = 0; j < max_length; j++) {
+      out->data[fn] += in->norm[j] * f->filters->data[fn][j];
+    /* for each filter */
+    for (fn = 0; fn < max_filters; fn++) {
+      /* for each sample */
+      for (j = 0; j < max_length; j++) {
+        out->data[i][fn] += in->norm[i][j] * f->filters->data[fn][j];
+      }
+    }
+  }
 …
+}
 fmat_t *
+fvec_t *
 aubio_filterbank_get_coeffs (aubio_filterbank_t * f)
+{
 …
 uint_t
 aubio_filterbank_set_coeffs (aubio_filterbank_t * f, fmat_t * filter_coeffs)
+aubio_filterbank_set_coeffs (aubio_filterbank_t * f, fvec_t * filters)
+{
   fmat_copy(filter_coeffs, f->filters);
+  fvec_copy(filters, f->filters);
   return 0;
+}

TabularUnified src/spectral/filterbank.h ¶

-                      r8212692
+                      rf650860
 void aubio_filterbank_do (aubio_filterbank_t * fb, cvec_t * in, fvec_t * out);
 /** return a pointer to the matrix object containing all filter coefficients
+/** return a pointer to the fvec object containing all filter coefficients
   \param f filterbank object to get coefficients from
  */
 fmat_t *aubio_filterbank_get_coeffs (aubio_filterbank_t * f);
+fvec_t *aubio_filterbank_get_coeffs (aubio_filterbank_t * f);
 /** copy filter coefficients to the filterbank
 …
  */
 uint_t aubio_filterbank_set_coeffs (aubio_filterbank_t * f, fmat_t * filters);
+uint_t aubio_filterbank_set_coeffs (aubio_filterbank_t * f, fvec_t * filters);
 #ifdef __cplusplus

TabularUnified src/spectral/filterbank_mel.c ¶

-                      r8212692
+                      rf650860
 #include "aubio_priv.h"
-#include "fmat.h"
 #include "fvec.h"
 #include "cvec.h"
 …
+{
   fmat_t *filters = aubio_filterbank_get_coeffs (fb);
   uint_t n_filters = filters->height, win_s = filters->length;
+  fvec_t *filters = aubio_filterbank_get_coeffs (fb);
+  uint_t n_filters = filters->channels, win_s = filters->length;
   uint_t fn;                    /* filter counter */
 …
+  }
   if (freqs->data[freqs->length - 1] > samplerate / 2) {
+  if (freqs->data[0][freqs->length - 1] > samplerate / 2) {
     AUBIO_WRN ("Nyquist frequency is %fHz, but highest frequency band ends at \
 %fHz\n", samplerate / 2, freqs->data[freqs->length - 1]);
+%fHz\n", samplerate / 2, freqs->data[0][freqs->length - 1]);
+  }
   /* convenience reference to lower/center/upper frequency for each triangle */
   fvec_t *lower_freqs = new_fvec (n_filters);
   fvec_t *upper_freqs = new_fvec (n_filters);
   fvec_t *center_freqs = new_fvec (n_filters);
+  fvec_t *lower_freqs = new_fvec (n_filters, 1);
+  fvec_t *upper_freqs = new_fvec (n_filters, 1);
+  fvec_t *center_freqs = new_fvec (n_filters, 1);
   /* height of each triangle */
   fvec_t *triangle_heights = new_fvec (n_filters);
+  fvec_t *triangle_heights = new_fvec (n_filters, 1);
   /* lookup table of each bin frequency in hz */
   fvec_t *fft_freqs = new_fvec (win_s);
+  fvec_t *fft_freqs = new_fvec (win_s, 1);
   /* fill up the lower/center/upper */
   for (fn = 0; fn < n_filters; fn++) {
     lower_freqs->data[fn] = freqs->data[fn];
     center_freqs->data[fn] = freqs->data[fn + 1];
     upper_freqs->data[fn] = freqs->data[fn + 2];
+    lower_freqs->data[0][fn] = freqs->data[0][fn];
+    center_freqs->data[0][fn] = freqs->data[0][fn + 1];
+    upper_freqs->data[0][fn] = freqs->data[0][fn + 2];
+  }
   /* compute triangle heights so that each triangle has unit area */
   for (fn = 0; fn < n_filters; fn++) {
     triangle_heights->data[fn] =
 . / (upper_freqs->data[fn] - lower_freqs->data[fn]);
+    triangle_heights->data[0][fn] =
+. / (upper_freqs->data[0][fn] - lower_freqs->data[0][fn]);
+  }
   /* fill fft_freqs lookup table, which assigns the frequency in hz to each bin */
   for (bin = 0; bin < win_s; bin++) {
     fft_freqs->data[bin] =
+    fft_freqs->data[0][bin] =
         aubio_bintofreq (bin, samplerate, (win_s - 1) * 2);
+  }
   /* zeroing of all filters */
   fmat_zeros (filters);
+  fvec_zeros (filters);
   if (fft_freqs->data[1] >= lower_freqs->data[0]) {
+  if (fft_freqs->data[0][1] >= lower_freqs->data[0][0]) {
     /* - 1 to make sure we don't miss the smallest power of two */
     uint_t min_win_s =
         (uint_t) FLOOR (samplerate / lower_freqs->data[0]) - 1;
+        (uint_t) FLOOR (samplerate / lower_freqs->data[0][0]) - 1;
     AUBIO_WRN ("Lowest frequency bin (%.2fHz) is higher than lowest frequency \
 band (%.2f-%.2fHz). Consider increasing the window size from %d to %d.\n",
         fft_freqs->data[1], lower_freqs->data[0],
         upper_freqs->data[0], (win_s - 1) * 2,
+        fft_freqs->data[0][1], lower_freqs->data[0][0],
+        upper_freqs->data[0][0], (win_s - 1) * 2,
         aubio_next_power_of_two (min_win_s));
+  }
 …
     /* skip first elements */
     for (bin = 0; bin < win_s - 1; bin++) {
       if (fft_freqs->data[bin] <= lower_freqs->data[fn] &&
           fft_freqs->data[bin + 1] > lower_freqs->data[fn]) {
+      if (fft_freqs->data[0][bin] <= lower_freqs->data[0][fn] &&
+          fft_freqs->data[0][bin + 1] > lower_freqs->data[0][fn]) {
         bin++;
         break;
 …
     /* compute positive slope step size */
     smpl_t riseInc =
         triangle_heights->data[fn] /
         (center_freqs->data[fn] - lower_freqs->data[fn]);
+        triangle_heights->data[0][fn] /
+        (center_freqs->data[0][fn] - lower_freqs->data[0][fn]);
     /* compute coefficients in positive slope */
     for (; bin < win_s - 1; bin++) {
       filters->data[fn][bin] =
           (fft_freqs->data[bin] - lower_freqs->data[fn]) * riseInc;
+          (fft_freqs->data[0][bin] - lower_freqs->data[0][fn]) * riseInc;
       if (fft_freqs->data[bin + 1] >= center_freqs->data[fn]) {
+      if (fft_freqs->data[0][bin + 1] >= center_freqs->data[0][fn]) {
         bin++;
         break;
 …
     /* compute negative slope step size */
     smpl_t downInc =
         triangle_heights->data[fn] /
         (upper_freqs->data[fn] - center_freqs->data[fn]);
+        triangle_heights->data[0][fn] /
+        (upper_freqs->data[0][fn] - center_freqs->data[0][fn]);
     /* compute coefficents in negative slope */
     for (; bin < win_s - 1; bin++) {
       filters->data[fn][bin] +=
           (upper_freqs->data[fn] - fft_freqs->data[bin]) * downInc;
+          (upper_freqs->data[0][fn] - fft_freqs->data[0][bin]) * downInc;
       if (filters->data[fn][bin] < 0.) {
 …
+      }
       if (fft_freqs->data[bin + 1] >= upper_freqs->data[fn])
+      if (fft_freqs->data[0][bin + 1] >= upper_freqs->data[0][fn])
         break;
+    }
 …
   /* buffers to compute filter frequencies */
   fvec_t *freqs = new_fvec (n_filters + 2);
+  fvec_t *freqs = new_fvec (n_filters + 2, 1);
   /* first step: fill all the linear filter frequencies */
   for (fn = 0; fn < linearFilters; fn++) {
     freqs->data[fn] = lowestFrequency + fn * linearSpacing;
+    freqs->data[0][fn] = lowestFrequency + fn * linearSpacing;
+  }
   smpl_t lastlinearCF = freqs->data[fn - 1];
+  smpl_t lastlinearCF = freqs->data[0][fn - 1];
   /* second step: fill all the log filter frequencies */
   for (fn = 0; fn < logFilters + 2; fn++) {
     freqs->data[fn + linearFilters] =
+    freqs->data[0][fn + linearFilters] =
         lastlinearCF * (POW (logSpacing, fn + 1));
+  }

TabularUnified src/spectral/mfcc.c ¶

-                      r8212692
+                      rf650860
 #include "aubio_priv.h"
 #include "fvec.h"
-#include "fmat.h"
 #include "cvec.h"
 #include "mathutils.h"
 …
   aubio_filterbank_t *fb;   /** filter bank */
   fvec_t *in_dct;           /** input buffer for dct * [fb->n_filters] */
   fmat_t *dct_coeffs;       /** DCT transform n_filters * n_coeffs */
+  fvec_t *dct_coeffs;       /** DCT transform n_filters * n_coeffs */
 };
 …
   /* allocating buffers */
   mfcc->in_dct = new_fvec (n_filters);
+  mfcc->in_dct = new_fvec (n_filters, 1);
   mfcc->dct_coeffs = new_fmat (n_coefs, n_filters);
+  mfcc->dct_coeffs = new_fvec (n_coefs, n_filters);
   /* compute DCT transform dct_coeffs[i][j] as
 …
 aubio_mfcc_do (aubio_mfcc_t * mf, cvec_t * in, fvec_t * out)
+{
   uint_t j, k;
+  uint_t i, j, k;
   /* compute filterbank */
 …
   /* compute discrete cosine transform */
+  for (j = 0; j < mf->n_filters; j++) {
+    for (k = 0; k < mf->n_coefs; k++) {
+      out->data[k] += mf->in_dct->data[j]
+          * mf->dct_coeffs->data[j][k];
+  for (i = 0; i < out->channels; i++) {
+    for (j = 0; j < mf->n_filters; j++) {
+      for (k = 0; k < mf->n_coefs; k++) {
+        out->data[i][k] += mf->in_dct->data[i][j]
+            * mf->dct_coeffs->data[j][k];
+      }
+    }
+  }

TabularUnified src/spectral/phasevoc.c ¶

-                      r8212692
+                      rf650860
   uint_t win_s;       /** grain length */
   uint_t hop_s;       /** overlap step */
+  uint_t channels;    /** number of channels */
   aubio_fft_t * fft;  /** fft object */
   fvec_t * synth;     /** cur output grain [win_s] */
 …
 void aubio_pvoc_do(aubio_pvoc_t *pv, fvec_t * datanew, cvec_t *fftgrain) {
+  /* slide  */
+  aubio_pvoc_swapbuffers(pv->data->data,pv->dataold->data,
+      datanew->data,pv->win_s,pv->hop_s);
+  uint_t i;
+  for (i=0; i<pv->channels; i++) {
+    /* slide  */
+    aubio_pvoc_swapbuffers(pv->data->data[i],pv->dataold->data[i],
+        datanew->data[i],pv->win_s,pv->hop_s);
+  }
   /* windowing */
   fvec_weight(pv->data, pv->w);
 …
 void aubio_pvoc_rdo(aubio_pvoc_t *pv,cvec_t * fftgrain, fvec_t * synthnew) {
+  uint_t i;
   /* calculate rfft */
   aubio_fft_rdo(pv->fft,fftgrain,pv->synth);
   /* unshift */
   fvec_shift(pv->synth);
+  aubio_pvoc_addsynth(pv->synth->data,pv->synthold->data,
+      synthnew->data,pv->win_s,pv->hop_s);
+  for (i=0; i<pv->channels; i++) {
+    aubio_pvoc_addsynth(pv->synth->data[i],pv->synthold->data[i],
+        synthnew->data[i],pv->win_s,pv->hop_s);
+  }
+}
 aubio_pvoc_t * new_aubio_pvoc (uint_t win_s, uint_t hop_s) {
+aubio_pvoc_t * new_aubio_pvoc (uint_t win_s, uint_t hop_s, uint_t channels) {
   aubio_pvoc_t * pv = AUBIO_NEW(aubio_pvoc_t);
 …
+  }
   pv->fft      = new_aubio_fft (win_s);
+  pv->fft      = new_aubio_fft(win_s,channels);
   /* remember old */
   pv->data     = new_fvec (win_s);
   pv->synth    = new_fvec (win_s);
+  pv->data     = new_fvec (win_s, channels);
+  pv->synth    = new_fvec (win_s, channels);
   /* new input output */
   pv->dataold  = new_fvec  (win_s-hop_s);
   pv->synthold = new_fvec (win_s-hop_s);
+  pv->dataold  = new_fvec  (win_s-hop_s, channels);
+  pv->synthold = new_fvec (win_s-hop_s, channels);
   pv->w        = new_aubio_window ("hanningz", win_s);
+  pv->channels = channels;
   pv->hop_s    = hop_s;
   pv->win_s    = win_s;

TabularUnified src/spectral/phasevoc.h ¶

-                      r8212692
+                      rf650860
   using a HanningZ window and a swapped version of the signal to simplify the
   phase relationships across frames. The window sizes and overlap are specified
   at creation time.
+  at creation time. Multiple channels are fully supported.
 */
 …
   \param win_s size of analysis buffer (and length the FFT transform)
   \param hop_s step size between two consecutive analysis
+  \param channels number of channels
 */
 aubio_pvoc_t * new_aubio_pvoc (uint_t win_s, uint_t hop_s);
+aubio_pvoc_t * new_aubio_pvoc (uint_t win_s, uint_t hop_s, uint_t channels);
 /** delete phase vocoder object
 …
 /** compute spectral frame
   This function accepts an input vector of size [hop_s]. The
+  This function accepts an input vector of size [channels]x[hop_s]. The
   analysis buffer is rotated and filled with the new data. After windowing of
   this signal window, the Fourier transform is computed and returned in
 …
   This function takes an input spectral frame fftgrain of size
   [buf_s] and computes its inverse Fourier transform. Overlap-add
+  [channels]x[buf_s] and computes its inverse Fourier transform. Overlap-add
   synthesis is then computed using the previously synthetised frames, and the
   output stored in out.
 …
 */
 uint_t aubio_pvoc_get_hop(aubio_pvoc_t* pv);
+/** get channel number
+  \param pv phase vocoder to get the number of channels from
+*/
+uint_t aubio_pvoc_get_channels(aubio_pvoc_t* pv);
 #ifdef __cplusplus

TabularUnified src/spectral/specdesc.c ¶

-                      r8212692
+                      rf650860
 void aubio_specdesc_energy  (aubio_specdesc_t *o UNUSED,
     cvec_t * fftgrain, fvec_t * onset) {
+  uint_t j;
+  onset->data[0] = 0.;
+  for (j=0;j<fftgrain->length;j++) {
+    onset->data[0] += SQR(fftgrain->norm[j]);
+  uint_t i,j;
+  for (i=0;i<fftgrain->channels;i++) {
+    onset->data[i][0] = 0.;
+    for (j=0;j<fftgrain->length;j++) {
+      onset->data[i][0] += SQR(fftgrain->norm[i][j]);
+    }
+  }
+}
 …
 void aubio_specdesc_hfc(aubio_specdesc_t *o UNUSED,
     cvec_t * fftgrain, fvec_t * onset){
+  uint_t j;
+  onset->data[0] = 0.;
+  for (j=0;j<fftgrain->length;j++) {
+    onset->data[0] += (j+1)*fftgrain->norm[j];
+  uint_t i,j;
+  for (i=0;i<fftgrain->channels;i++) {
+    onset->data[i][0] = 0.;
+    for (j=0;j<fftgrain->length;j++) {
+      onset->data[i][0] += (j+1)*fftgrain->norm[i][j];
+    }
+  }
+}
 …
 /* Complex Domain Method onset detection function */
 void aubio_specdesc_complex (aubio_specdesc_t *o, cvec_t * fftgrain, fvec_t * onset) {
   uint_t j;
+  uint_t i, j;
   uint_t nbins = fftgrain->length;
+  onset->data[0] = 0.;
+  for (j=0;j<nbins; j++)  {
+    // compute the predicted phase
+    o->dev1->data[j] = 2. * o->theta1->data[j] - o->theta2->data[j];
+    // compute the euclidean distance in the complex domain
+    // sqrt ( r_1^2 + r_2^2 - 2 * r_1 * r_2 * \cos ( \phi_1 - \phi_2 ) )
+    onset->data[0] +=
+      SQRT (ABS (SQR (o->oldmag->data[j]) + SQR (fftgrain->norm[j])
+            - 2. * o->oldmag->data[j] * fftgrain->norm[j]
+            * COS (o->dev1->data[j] - fftgrain->phas[j])));
+    /* swap old phase data (need to remember 2 frames behind)*/
+    o->theta2->data[j] = o->theta1->data[j];
+    o->theta1->data[j] = fftgrain->phas[j];
+    /* swap old magnitude data (1 frame is enough) */
+    o->oldmag->data[j] = fftgrain->norm[j];
+  for (i=0;i<fftgrain->channels; i++)  {
+    onset->data[i][0] = 0.;
+    for (j=0;j<nbins; j++)  {
+      // compute the predicted phase
+      o->dev1->data[i][j] = 2. * o->theta1->data[i][j] - o->theta2->data[i][j];
+      // compute the euclidean distance in the complex domain
+      // sqrt ( r_1^2 + r_2^2 - 2 * r_1 * r_2 * \cos ( \phi_1 - \phi_2 ) )
+      onset->data[i][0] +=
+        SQRT (ABS (SQR (o->oldmag->data[i][j]) + SQR (fftgrain->norm[i][j])
+              - 2. * o->oldmag->data[i][j] * fftgrain->norm[i][j]
+              * COS (o->dev1->data[i][j] - fftgrain->phas[i][j])));
+      /* swap old phase data (need to remember 2 frames behind)*/
+      o->theta2->data[i][j] = o->theta1->data[i][j];
+      o->theta1->data[i][j] = fftgrain->phas[i][j];
+      /* swap old magnitude data (1 frame is enough) */
+      o->oldmag->data[i][j] = fftgrain->norm[i][j];
+    }
+  }
+}
 …
 void aubio_specdesc_phase(aubio_specdesc_t *o,
     cvec_t * fftgrain, fvec_t * onset){
   uint_t j;
+  uint_t i, j;
   uint_t nbins = fftgrain->length;
+  onset->data[0] = 0.0;
+  o->dev1->data[0]=0.;
+  for ( j=0;j<nbins; j++ )  {
+    o->dev1->data[j] =
+      aubio_unwrap2pi(
+          fftgrain->phas[j]
+          -2.0*o->theta1->data[j]
+          +o->theta2->data[j]);
+    if ( o->threshold < fftgrain->norm[j] )
+      o->dev1->data[j] = ABS(o->dev1->data[j]);
+    else
+      o->dev1->data[j] = 0.0;
+    /* keep a track of the past frames */
+    o->theta2->data[j] = o->theta1->data[j];
+    o->theta1->data[j] = fftgrain->phas[j];
+  }
+  /* apply o->histogram */
+  aubio_hist_dyn_notnull(o->histog,o->dev1);
+  /* weight it */
+  aubio_hist_weight(o->histog);
+  /* its mean is the result */
+  onset->data[0] = aubio_hist_mean(o->histog);
+  //onset->data[0] = fvec_mean(o->dev1);
+  for (i=0;i<fftgrain->channels; i++)  {
+    onset->data[i][0] = 0.0;
+    o->dev1->data[i][0]=0.;
+    for ( j=0;j<nbins; j++ )  {
+      o->dev1->data[i][j] =
+        aubio_unwrap2pi(
+            fftgrain->phas[i][j]
+            -2.0*o->theta1->data[i][j]
+            +o->theta2->data[i][j]);
+      if ( o->threshold < fftgrain->norm[i][j] )
+        o->dev1->data[i][j] = ABS(o->dev1->data[i][j]);
+      else
+        o->dev1->data[i][j] = 0.0;
+      /* keep a track of the past frames */
+      o->theta2->data[i][j] = o->theta1->data[i][j];
+      o->theta1->data[i][j] = fftgrain->phas[i][j];
+    }
+    /* apply o->histogram */
+    aubio_hist_dyn_notnull(o->histog,o->dev1);
+    /* weight it */
+    aubio_hist_weight(o->histog);
+    /* its mean is the result */
+    onset->data[i][0] = aubio_hist_mean(o->histog);
+    //onset->data[i][0] = fvec_mean(o->dev1);
+  }
+}
 …
 void aubio_specdesc_specdiff(aubio_specdesc_t *o,
     cvec_t * fftgrain, fvec_t * onset){
   uint_t j;
+  uint_t i, j;
   uint_t nbins = fftgrain->length;
+    onset->data[0] = 0.0;
+  for (i=0;i<fftgrain->channels; i++)  {
+    onset->data[i][0] = 0.0;
     for (j=0;j<nbins; j++)  {
       o->dev1->data[j] = SQRT(
           ABS(SQR( fftgrain->norm[j])
             - SQR(o->oldmag->data[j])));
       if (o->threshold < fftgrain->norm[j] )
         o->dev1->data[j] = ABS(o->dev1->data[j]);
+      o->dev1->data[i][j] = SQRT(
+          ABS(SQR( fftgrain->norm[i][j])
+            - SQR(o->oldmag->data[i][j])));
+      if (o->threshold < fftgrain->norm[i][j] )
+        o->dev1->data[i][j] = ABS(o->dev1->data[i][j]);
       else
         o->dev1->data[j] = 0.0;
       o->oldmag->data[j] = fftgrain->norm[j];
+        o->dev1->data[i][j] = 0.0;
+      o->oldmag->data[i][j] = fftgrain->norm[i][j];
+    }
 …
     aubio_hist_weight(o->histog);
     /* its mean is the result */
+    onset->data[0] = aubio_hist_mean(o->histog);
+    onset->data[i][0] = aubio_hist_mean(o->histog);
+  }
+}
 …
  * negative (1.+) and infinite values (+1.e-10) */
 void aubio_specdesc_kl(aubio_specdesc_t *o, cvec_t * fftgrain, fvec_t * onset){
+  uint_t j;
+    onset->data[0] = 0.;
+  uint_t i,j;
+  for (i=0;i<fftgrain->channels;i++) {
+    onset->data[i][0] = 0.;
     for (j=0;j<fftgrain->length;j++) {
+      onset->data[0] += fftgrain->norm[j]
+        *LOG(1.+fftgrain->norm[j]/(o->oldmag->data[j]+1.e-10));
+      o->oldmag->data[j] = fftgrain->norm[j];
+    }
+    if (isnan(onset->data[0])) onset->data[0] = 0.;
+      onset->data[i][0] += fftgrain->norm[i][j]
+        *LOG(1.+fftgrain->norm[i][j]/(o->oldmag->data[i][j]+1.e-10));
+      o->oldmag->data[i][j] = fftgrain->norm[i][j];
+    }
+    if (isnan(onset->data[i][0])) onset->data[i][0] = 0.;
+  }
+}
 …
  * negative (1.+) and infinite values (+1.e-10) */
 void aubio_specdesc_mkl(aubio_specdesc_t *o, cvec_t * fftgrain, fvec_t * onset){
+  uint_t j;
+    onset->data[0] = 0.;
+  uint_t i,j;
+  for (i=0;i<fftgrain->channels;i++) {
+    onset->data[i][0] = 0.;
     for (j=0;j<fftgrain->length;j++) {
+      onset->data[0] += LOG(1.+fftgrain->norm[j]/(o->oldmag->data[j]+1.e-10));
+      o->oldmag->data[j] = fftgrain->norm[j];
+    }
+    if (isnan(onset->data[0])) onset->data[0] = 0.;
+      onset->data[i][0] += LOG(1.+fftgrain->norm[i][j]/(o->oldmag->data[i][j]+1.e-10));
+      o->oldmag->data[i][j] = fftgrain->norm[i][j];
+    }
+    if (isnan(onset->data[i][0])) onset->data[i][0] = 0.;
+  }
+}
 /* Spectral flux */
 void aubio_specdesc_specflux(aubio_specdesc_t *o, cvec_t * fftgrain, fvec_t * onset){
+  uint_t j;
+  onset->data[0] = 0.;
+  for (j=0;j<fftgrain->length;j++) {
+    if (fftgrain->norm[j] > o->oldmag->data[j])
+      onset->data[0] += fftgrain->norm[j] - o->oldmag->data[j];
+    o->oldmag->data[j] = fftgrain->norm[j];
+  uint_t i, j;
+  for (i=0;i<fftgrain->channels;i++) {
+    onset->data[i][0] = 0.;
+    for (j=0;j<fftgrain->length;j++) {
+      if (fftgrain->norm[i][j] > o->oldmag->data[i][j])
+        onset->data[i][0] += fftgrain->norm[i][j] - o->oldmag->data[i][j];
+      o->oldmag->data[i][j] = fftgrain->norm[i][j];
+    }
+  }
+}
 …
  */
 aubio_specdesc_t *
+new_aubio_specdesc (char_t * onset_mode, uint_t size){
+new_aubio_specdesc (char_t * onset_mode,
+    uint_t size, uint_t channels){
   aubio_specdesc_t * o = AUBIO_NEW(aubio_specdesc_t);
   uint_t rsize = size/2+1;
 …
       /* the other approaches will need some more memory spaces */
     case aubio_onset_complex:
       o->oldmag = new_fvec(rsize);
       o->dev1   = new_fvec(rsize);
       o->theta1 = new_fvec(rsize);
       o->theta2 = new_fvec(rsize);
+      o->oldmag = new_fvec(rsize,channels);
+      o->dev1   = new_fvec(rsize,channels);
+      o->theta1 = new_fvec(rsize,channels);
+      o->theta2 = new_fvec(rsize,channels);
       break;
     case aubio_onset_phase:
       o->dev1   = new_fvec(rsize);
       o->theta1 = new_fvec(rsize);
       o->theta2 = new_fvec(rsize);
       o->histog = new_aubio_hist(0.0, PI, 10);
+      o->dev1   = new_fvec(rsize,channels);
+      o->theta1 = new_fvec(rsize,channels);
+      o->theta2 = new_fvec(rsize,channels);
+      o->histog = new_aubio_hist(0.0, PI, 10, channels);
       o->threshold = 0.1;
       break;
     case aubio_onset_specdiff:
       o->oldmag = new_fvec(rsize);
       o->dev1   = new_fvec(rsize);
       o->histog = new_aubio_hist(0.0, PI, 10);
+      o->oldmag = new_fvec(rsize,channels);
+      o->dev1   = new_fvec(rsize,channels);
+      o->histog = new_aubio_hist(0.0, PI, 10, channels);
       o->threshold = 0.1;
       break;
 …
     case aubio_onset_mkl:
     case aubio_onset_specflux:
       o->oldmag = new_fvec(rsize);
+      o->oldmag = new_fvec(rsize,channels);
       break;
     default:

TabularUnified src/spectral/specdesc.h ¶

-                      r8212692
+                      rf650860
   All of the following spectral description functions take as arguments the FFT
   of a windowed signal (as created with aubio_pvoc). They output one smpl_t per
   buffer (stored in a vector of size [1]).
+  buffer and per channel (stored in a vector of size [channels]x[1]).
   A list of the spectral description methods currently available follows.
 …
   \param method spectral description method
   \param buf_size length of the input spectrum frame
+  \param channels number of input channels
 */
+aubio_specdesc_t *new_aubio_specdesc (char_t * method, uint_t buf_size);
+aubio_specdesc_t *new_aubio_specdesc (char_t * method, uint_t buf_size,
+    uint_t channels);
 /** deletion of a spectral descriptor

TabularUnified src/spectral/statistics.c ¶

-                      r8212692
+                      rf650860
 smpl_t
 cvec_sum (cvec_t * s)
+cvec_sum_channel (cvec_t * s, uint_t i)
+{
   uint_t j;
   smpl_t tmp = 0.0;
+  for (j = 0; j < s->length; j++) {
+    tmp += s->norm[j];
+  }
+  for (j = 0; j < s->length; j++)
+      tmp += s->norm[i][j];
   return tmp;
+}
 smpl_t
 cvec_mean (cvec_t * s)
+cvec_mean_channel (cvec_t * s, uint_t i)
+{
   return cvec_sum (s) / (smpl_t) (s->length);
+  return cvec_sum_channel(s, i) / (smpl_t) (s->length);
+}
 smpl_t
 cvec_centroid (cvec_t * spec)
+cvec_centroid_channel (cvec_t * spec, uint_t i)
+{
   smpl_t sum = 0., sc = 0.;
   uint_t j;
   sum = cvec_sum (spec);
+  sum = cvec_sum_channel (spec, i);
   if (sum == 0.) {
     return 0.;
   } else {
     for (j = 0; j < spec->length; j++) {
       sc += (smpl_t) j *spec->norm[j];
+      sc += (smpl_t) j *spec->norm[i][j];
+    }
     return sc / sum;
 …
 smpl_t
 cvec_moment (cvec_t * spec, uint_t order)
+cvec_moment_channel (cvec_t * spec, uint_t i, uint_t order)
+{
   smpl_t sum = 0., centroid = 0., sc = 0.;
   uint_t j;
   sum = cvec_sum (spec);
+  sum = cvec_sum_channel (spec, i);
   if (sum == 0.) {
     return 0.;
   } else {
     centroid = cvec_centroid (spec);
+    centroid = cvec_centroid_channel (spec, i);
     for (j = 0; j < spec->length; j++) {
       sc += (smpl_t) POW(j - centroid, order) * spec->norm[j];
+      sc += (smpl_t) POW(j - centroid, order) * spec->norm[i][j];
+    }
     return sc / sum;
 …
     fvec_t * desc)
+{
+  desc->data[0] = cvec_centroid (spec);
+  uint_t i;
+  for (i = 0; i < spec->channels; i++) {
+    desc->data[i][0] = cvec_centroid_channel (spec, i);
+  }
+}
 …
     fvec_t * desc)
+{
+  desc->data[0] = cvec_moment (spec, 2);
+  uint_t i;
+  for (i = 0; i < spec->channels; i++) {
+    desc->data[i][0] = cvec_moment_channel (spec, i, 2);
+  }
+}
 …
     fvec_t * desc)
+{
+  smpl_t spread;
+  spread = cvec_moment (spec, 2);
+  if (spread == 0) {
+    desc->data[0] = 0.;
+  } else {
+    desc->data[0] = cvec_moment (spec, 3);
+    desc->data[0] /= POW ( SQRT (spread), 3);
+  uint_t i; smpl_t spread;
+  for (i = 0; i < spec->channels; i++) {
+    spread = cvec_moment_channel (spec, i, 2);
+    if (spread == 0) {
+      desc->data[i][0] = 0.;
+    } else {
+      desc->data[i][0] = cvec_moment_channel (spec, i, 3);
+      desc->data[i][0] /= POW ( SQRT (spread), 3);
+    }
+  }
+}
 …
     fvec_t * desc)
+{
+  smpl_t spread;
+  spread = cvec_moment (spec, 2);
+  if (spread == 0) {
+    desc->data[0] = 0.;
+  } else {
+    desc->data[0] = cvec_moment (spec, 4);
+    desc->data[0] /= SQR (spread);
+  uint_t i; smpl_t spread;
+  for (i = 0; i < spec->channels; i++) {
+    spread = cvec_moment_channel (spec, i, 2);
+    if (spread == 0) {
+      desc->data[i][0] = 0.;
+    } else {
+      desc->data[i][0] = cvec_moment_channel (spec, i, 4);
+      desc->data[i][0] /= SQR (spread);
+    }
+  }
+}
 …
     fvec_t * desc)
+{
   uint_t j;
+  uint_t i, j;
   smpl_t norm = 0, sum = 0.;
   // compute N * sum(j**2) - sum(j)**2
 …
   // sum_0^N(j) = length * (length + 1) / 2
   norm -= SQR( (spec->length) * (spec->length - 1.) / 2. );
+  sum = cvec_sum (spec);
+  desc->data[0] = 0.;
+  if (sum == 0.) {
+    return;
+  } else {
+    for (j = 0; j < spec->length; j++) {
+      desc->data[0] += j * spec->norm[j];
+  for (i = 0; i < spec->channels; i++) {
+    sum = cvec_sum_channel (spec, i);
+    desc->data[i][0] = 0.;
+    if (sum == 0.) {
+      break;
+    } else {
+      for (j = 0; j < spec->length; j++) {
+        desc->data[i][0] += j * spec->norm[i][j];
+      }
+      desc->data[i][0] *= spec->length;
+      desc->data[i][0] -= sum * spec->length * (spec->length - 1) / 2.;
+      desc->data[i][0] /= norm;
+      desc->data[i][0] /= sum;
+    }
-    desc->data[0] *= spec->length;
-    desc->data[0] -= sum * spec->length * (spec->length - 1) / 2.;
-    desc->data[0] /= norm;
-    desc->data[0] /= sum;
+  }
+}
 …
     fvec_t * desc)
+{
+  uint_t j; smpl_t sum;
+  sum = cvec_sum (spec);
+  desc->data[0] = 0;
+  if (sum == 0.) {
+    return;
+  } else {
+    sum -= spec->norm[0];
+    for (j = 1; j < spec->length; j++) {
+      desc->data[0] += (spec->norm[j] - spec->norm[0]) / j;
+  uint_t i, j; smpl_t sum;
+  for (i = 0; i < spec->channels; i++) {
+    sum = cvec_sum_channel (spec, i);
+    desc->data[i][0] = 0;
+    if (sum == 0.) {
+      break;
+    } else {
+      sum -= spec->norm[i][0];
+      for (j = 1; j < spec->length; j++) {
+        desc->data[i][0] += (spec->norm[i][j] - spec->norm[i][0]) / j;
+      }
+      desc->data[i][0] /= sum;
+    }
-    desc->data[0] /= sum;
+  }
+}
 …
     fvec_t *desc)
+{
+  uint_t j; smpl_t cumsum, rollsum;
+  cumsum = 0.; rollsum = 0.;
+  for (j = 0; j < spec->length; j++) {
+    cumsum += SQR (spec->norm[j]);
+  }
+  if (cumsum == 0) {
+    desc->data[0] = 0.;
+  } else {
+    cumsum *= 0.95;
+    j = 0;
+    while (rollsum < cumsum) {
+      rollsum += SQR (spec->norm[j]);
+      j++;
+  uint_t i, j; smpl_t cumsum, rollsum;
+  for (i = 0; i < spec->channels; i++) {
+    cumsum = 0.; rollsum = 0.;
+    for (j = 0; j < spec->length; j++) {
+      cumsum += SQR (spec->norm[i][j]);
+    }
+    desc->data[0] = j;
+    if (cumsum == 0) {
+      desc->data[i][0] = 0.;
+    } else {
+      cumsum *= 0.95;
+      j = 0;
+      while (rollsum < cumsum) {
+        rollsum += SQR (spec->norm[i][j]);
+        j++;
+      }
+      desc->data[i][0] = j;
+    }
+  }
+}

TabularUnified src/spectral/tss.c ¶

-                      r8212692
+                      rf650860
     cvec_t * trans, cvec_t * stead)
+{
   uint_t j;
+  uint_t i,j;
   uint_t test;
   uint_t nbins     = input->length;
+  uint_t channels  = input->channels;
   smpl_t alpha     = o->alpha;
   smpl_t beta      = o->beta;
   smpl_t parm      = o->parm;
   smpl_t * dev    = (smpl_t *)o->dev->data;
   smpl_t * oft1   = (smpl_t *)o->oft1->data;
   smpl_t * oft2   = (smpl_t *)o->oft2->data;
   smpl_t * theta1 = (smpl_t *)o->theta1->data;
   smpl_t * theta2 = (smpl_t *)o->theta2->data;
+  smpl_t ** dev    = (smpl_t **)o->dev->data;
+  smpl_t ** oft1   = (smpl_t **)o->oft1->data;
+  smpl_t ** oft2   = (smpl_t **)o->oft2->data;
+  smpl_t ** theta1 = (smpl_t **)o->theta1->data;
+  smpl_t ** theta2 = (smpl_t **)o->theta2->data;
   /* second phase derivative */
+  for (j=0;j<nbins; j++){
+    dev[j] = aubio_unwrap2pi(input->phas[j]
+        -2.0*theta1[j]+theta2[j]);
+    theta2[j] = theta1[j];
+    theta1[j] = input->phas[j];
+  }
+  for (i=0;i<channels; i++){
+    for (j=0;j<nbins; j++){
+      dev[i][j] = aubio_unwrap2pi(input->phas[i][j]
+          -2.0*theta1[i][j]+theta2[i][j]);
+      theta2[i][j] = theta1[i][j];
+      theta1[i][j] = input->phas[i][j];
+    }
   for (j=0;j<nbins; j++){
     /* transient analysis */
     test = (ABS(dev[j]) > parm*oft1[j]);
     trans->norm[j] = input->norm[j] * test;
     trans->phas[j] = input->phas[j] * test;
+  }
+    for (j=0;j<nbins; j++){
+      /* transient analysis */
+      test = (ABS(dev[i][j]) > parm*oft1[i][j]);
+      trans->norm[i][j] = input->norm[i][j] * test;
+      trans->phas[i][j] = input->phas[i][j] * test;
+    }
   for (j=0;j<nbins; j++){
     /* steady state analysis */
     test = (ABS(dev[j]) < parm*oft2[j]);
     stead->norm[j] = input->norm[j] * test;
     stead->phas[j] = input->phas[j] * test;
+    for (j=0;j<nbins; j++){
+      /* steady state analysis */
+      test = (ABS(dev[i][j]) < parm*oft2[i][j]);
+      stead->norm[i][j] = input->norm[i][j] * test;
+      stead->phas[i][j] = input->phas[i][j] * test;
+    /*increase sstate probability for sines */
+    test = (trans->norm[j]==0.);
+    oft1[j]  = test;
+    test = (stead->norm[j]==0.);
+    oft2[j]  = test;
+    test = (trans->norm[j]>0.);
+    oft1[j] += alpha*test;
+    test = (stead->norm[j]>0.);
+    oft2[j] += alpha*test;
+    test = (oft1[j]>1. && trans->norm[j]>0.);
+    oft1[j] += beta*test;
+    test = (oft2[j]>1. && stead->norm[j]>0.);
+    oft2[j] += beta*test;
+      /*increase sstate probability for sines */
+      test = (trans->norm[i][j]==0.);
+      oft1[i][j]  = test;
+      test = (stead->norm[i][j]==0.);
+      oft2[i][j]  = test;
+      test = (trans->norm[i][j]>0.);
+      oft1[i][j] += alpha*test;
+      test = (stead->norm[i][j]>0.);
+      oft2[i][j] += alpha*test;
+      test = (oft1[i][j]>1. && trans->norm[i][j]>0.);
+      oft1[i][j] += beta*test;
+      test = (oft2[i][j]>1. && stead->norm[i][j]>0.);
+      oft2[i][j] += beta*test;
+    }
+  }
+}
 …
+}
 aubio_tss_t * new_aubio_tss(uint_t buf_size, uint_t hop_size)
+aubio_tss_t * new_aubio_tss(uint_t buf_size, uint_t hop_size, uint_t channels)
+{
   aubio_tss_t * o = AUBIO_NEW(aubio_tss_t);
 …
   o->beta = 4.;
   o->parm = o->threshold*o->thrsfact;
   o->theta1 = new_fvec(rsize);
   o->theta2 = new_fvec(rsize);
   o->oft1 = new_fvec(rsize);
   o->oft2 = new_fvec(rsize);
   o->dev = new_fvec(rsize);
+  o->theta1 = new_fvec(rsize,channels);
+  o->theta2 = new_fvec(rsize,channels);
+  o->oft1 = new_fvec(rsize,channels);
+  o->oft2 = new_fvec(rsize,channels);
+  o->dev = new_fvec(rsize,channels);
   return o;
+}

TabularUnified src/spectral/tss.h ¶

-                      r8212692
+                      rf650860
   \param buf_size buffer size
   \param hop_size step size
+  \param channels number of input channels
 */
 aubio_tss_t *new_aubio_tss (uint_t buf_size, uint_t hop_size);
+aubio_tss_t *new_aubio_tss (uint_t buf_size, uint_t hop_size, uint_t channels);
 /** delete tss object

TabularUnified src/tempo/beattracking.c ¶

-                      r8212692
+                      rf650860
 aubio_beattracking_t *
 new_aubio_beattracking (uint_t winlen)
+new_aubio_beattracking (uint_t winlen, uint_t channels)
+{
 …
   p->rayparam = rayparam;
   p->step = step;
   p->rwv = new_fvec (laglen);
   p->gwv = new_fvec (laglen);
   p->dfwv = new_fvec (winlen);
   p->dfrev = new_fvec (winlen);
   p->acf = new_fvec (winlen);
   p->acfout = new_fvec (laglen);
   p->phwv = new_fvec (2 * laglen);
   p->phout = new_fvec (winlen);
+  p->rwv = new_fvec (laglen, 1);
+  p->gwv = new_fvec (laglen, 1);
+  p->dfwv = new_fvec (winlen, 1);
+  p->dfrev = new_fvec (winlen, channels);
+  p->acf = new_fvec (winlen, channels);
+  p->acfout = new_fvec (laglen, channels);
+  p->phwv = new_fvec (2 * laglen, 1);
+  p->phout = new_fvec (winlen, channels);
   p->timesig = 0;
 …
   /* exponential weighting, dfwv = 0.5 when i =  43 */
   for (i = 0; i < winlen; i++) {
     p->dfwv->data[i] = (EXP ((LOG (2.0) / rayparam) * (i + 1)))
+    p->dfwv->data[0][i] = (EXP ((LOG (2.0) / rayparam) * (i + 1)))
         / dfwvnorm;
+  }
   for (i = 0; i < (laglen); i++) {
     p->rwv->data[i] = ((smpl_t) (i + 1.) / SQR ((smpl_t) rayparam)) *
+    p->rwv->data[0][i] = ((smpl_t) (i + 1.) / SQR ((smpl_t) rayparam)) *
         EXP ((-SQR ((smpl_t) (i + 1.)) / (2. * SQR ((smpl_t) rayparam))));
+  }
 …
     for (a = 1; a <= numelem; a++) {
       for (b = (1 - a); b < a; b++) {
         bt->acfout->data[i] += bt->acf->data[a * (i + 1) + b - 1]
+        bt->acfout->data[0][i] += bt->acf->data[0][a * (i + 1) + b - 1]
             * 1. / (2. * a - 1.);
+      }
 …
   /* find non-zero Rayleigh period */
   maxindex = fvec_max_elem (bt->acfout);
   bt->rp = maxindex ? fvec_quadint (bt->acfout, maxindex) : 1;
+  bt->rp = maxindex ? fvec_quadint (bt->acfout, maxindex, 0) : 1;
   //rp = (maxindex==127) ? 43 : maxindex; //rayparam
   bt->rp = (maxindex == bt->acfout->length - 1) ? bt->rayparam : maxindex;      //rayparam
 …
   for (i = 0; i < bp; i++) {
     for (k = 0; k < kmax; k++) {
       bt->phout->data[i] += bt->dfrev->data[i + (uint_t) ROUND (bp * k)];
+      bt->phout->data[0][i] += bt->dfrev->data[0][i + (uint_t) ROUND (bp * k)];
+    }
+  }
 …
     phase = step - bt->lastbeat;
   } else {
     phase = fvec_quadint (bt->phout, maxindex);
+    phase = fvec_quadint (bt->phout, maxindex, 0);
+  }
   /* take back one frame delay */
 …
   if (beat >= 0) {
     //AUBIO_DBG ("beat: %d, %f, %f\n", i, bp, beat);
     output->data[i] = beat;
+    output->data[0][i] = beat;
     i++;
+  }
 …
     beat += bp;
     //AUBIO_DBG ("beat: %d, %f, %f\n", i, bp, beat);
     output->data[i] = beat;
+    output->data[0][i] = beat;
     i++;
+  }
 …
   bt->lastbeat = beat;
   /* store the number of beats in this frame as the first element */
   output->data[0] = i;
+  output->data[0][0] = i;
+}
 …
   if (acflen > 6 * gp + 2) {
     for (k = -2; k < 2; k++) {
       three_energy += acf->data[3 * gp + k];
       four_energy += acf->data[4 * gp + k];
+      three_energy += acf->data[0][3 * gp + k];
+      four_energy += acf->data[0][4 * gp + k];
+    }
   } else {
     /*Expanded to be more accurate in time sig estimation */
     for (k = -2; k < 2; k++) {
       three_energy += acf->data[3 * gp + k] + acf->data[6 * gp + k];
       four_energy += acf->data[4 * gp + k] + acf->data[2 * gp + k];
+      three_energy += acf->data[0][3 * gp + k] + acf->data[0][6 * gp + k];
+      four_energy += acf->data[0][4 * gp + k] + acf->data[0][2 * gp + k];
+    }
+  }
 …
       for (a = 1; a <= bt->timesig; a++) {
         for (b = (1 - a); b < a; b++) {
           acfout->data[i] += acf->data[a * (i + 1) + b - 1];
+          acfout->data[0][i] += acf->data[0][a * (i + 1) + b - 1];
+        }
+      }
+    }
     fvec_weight (acfout, bt->gwv);
     gp = fvec_quadint (acfout, fvec_max_elem (acfout));
+    gp = fvec_quadint (acfout, fvec_max_elem (acfout), 0);
     /*
        while(gp<32) gp =gp*2;
 …
     bt->timesig = fvec_gettimesig (acf, acflen, gp);
     for (j = 0; j < laglen; j++)
       bt->gwv->data[j] =
+      bt->gwv->data[0][j] =
           EXP (-.5 * SQR ((smpl_t) (j + 1. - gp)) / SQR (bt->g_var));
     flagconst = 0;
 …
     if (step > bt->lastbeat) {
       for (j = 0; j < 2 * laglen; j++) {
         bt->phwv->data[j] =
+        bt->phwv->data[0][j] =
             EXP (-.5 * SQR ((smpl_t) (1. + j - step +
                     bt->lastbeat)) / (bp / 8.));
 …
+{
   if (bt->timesig != 0 && bt->counter == 0 && bt->flagstep == 0) {
     return 5168. / fvec_quadint (bt->acfout, bt->bp);
+    return 5168. / fvec_quadint (bt->acfout, bt->bp, 0);
   } else {
     return 0.;

TabularUnified src/tempo/beattracking.h ¶

-                      r8212692
+                      rf650860
   \param hop_size number of onset detection samples [512]
+  \param channels number (not functionnal) [1]
 */
 aubio_beattracking_t * new_aubio_beattracking(uint_t hop_size);
+aubio_beattracking_t * new_aubio_beattracking(uint_t hop_size, uint_t channels);
 /** track the beat

TabularUnified src/tempo/tempo.c ¶

-                      r8212692
+                      rf650860
   /*if (usedoubled) {
     aubio_specdesc_do(o2,fftgrain, onset2);
     onset->data[0] *= onset2->data[0];
+    onset->data[0][0] *= onset2->data[0][0];
   }*/
   /* execute every overlap_size*step */
 …
     /* rotate dfframe */
     for (i = 0 ; i < winlen - step; i++ )
       o->dfframe->data[i] = o->dfframe->data[i+step];
+      o->dfframe->data[0][i] = o->dfframe->data[0][i+step];
     for (i = winlen - step ; i < winlen; i++ )
       o->dfframe->data[i] = 0.;
+      o->dfframe->data[0][i] = 0.;
     o->blockpos = -1;
+  }
   o->blockpos++;
   aubio_peakpicker_do (o->pp, o->of, o->onset);
   tempo->data[1] = o->onset->data[0];
+  tempo->data[0][1] = o->onset->data[0][0];
   thresholded = aubio_peakpicker_get_thresholded_input(o->pp);
   o->dfframe->data[winlen - step + o->blockpos] = thresholded->data[0];
+  o->dfframe->data[0][winlen - step + o->blockpos] = thresholded->data[0][0];
   /* end of second level loop */
   tempo->data[0] = 0; /* reset tactus */
+  tempo->data[0][0] = 0; /* reset tactus */
   i=0;
   for (i = 1; i < o->out->data[0]; i++ ) {
+  for (i = 1; i < o->out->data[0][0]; i++ ) {
     /* if current frame is a predicted tactus */
     if (o->blockpos == FLOOR(o->out->data[i])) {
       tempo->data[0] = o->out->data[i] - FLOOR(o->out->data[i]); /* set tactus */
+    if (o->blockpos == FLOOR(o->out->data[0][i])) {
+      tempo->data[0][0] = o->out->data[0][i] - FLOOR(o->out->data[0][i]); /* set tactus */
       /* test for silence */
       if (aubio_silence_detection(input, o->silence)==1) {
         tempo->data[1] = 0; /* unset onset */
+        tempo->data[0][1] = 0; /* unset onset */
+      }
+    }
 …
 /* Allocate memory for an tempo detection */
 aubio_tempo_t * new_aubio_tempo (char_t * onset_mode,
     uint_t buf_size, uint_t hop_size, uint_t samplerate)
+    uint_t buf_size, uint_t hop_size, uint_t channels, uint_t samplerate)
+{
   aubio_tempo_t * o = AUBIO_NEW(aubio_tempo_t);
 …
   o->silence = -90.;
   o->blockpos = 0;
   o->dfframe  = new_fvec(o->winlen);
   o->fftgrain = new_cvec(buf_size);
   o->out      = new_fvec(o->step);
   o->pv       = new_aubio_pvoc(buf_size, hop_size);
   o->pp       = new_aubio_peakpicker();
+  o->dfframe  = new_fvec(o->winlen,channels);
+  o->fftgrain = new_cvec(buf_size, channels);
+  o->out      = new_fvec(o->step,channels);
+  o->pv       = new_aubio_pvoc(buf_size, hop_size, channels);
+  o->pp       = new_aubio_peakpicker(channels);
   aubio_peakpicker_set_threshold (o->pp, o->threshold);
   o->od       = new_aubio_specdesc(onset_mode,buf_size);
   o->of       = new_fvec(1);
   o->bt       = new_aubio_beattracking(o->winlen);
   o->onset    = new_fvec(1);
+  o->od       = new_aubio_specdesc(onset_mode,buf_size,channels);
+  o->of       = new_fvec(1, channels);
+  o->bt       = new_aubio_beattracking(o->winlen,channels);
+  o->onset    = new_fvec(1, channels);
   /*if (usedoubled)    {
     o2 = new_aubio_specdesc(type_onset2,buffer_size);
     onset2 = new_fvec(1);
+    o2 = new_aubio_specdesc(type_onset2,buffer_size,channels);
+    onset2 = new_fvec(1 , channels);
   }*/
   return o;

TabularUnified src/tempo/tempo.h ¶

r8212692	rf650860
40	40	/** create tempo detection object */
41	41	aubio_tempo_t * new_aubio_tempo (char_t * method,
42		uint_t buf_size, uint_t hop_size, uint_t samplerate);
	42	uint_t buf_size, uint_t hop_size, uint_t channels, uint_t samplerate);
43	43
44	44	/** execute tempo detection */

TabularUnified src/temporal/a_weighting.c ¶

-                      r8212692
+                      rf650860
   lvec_t *bs = aubio_filter_get_feedforward (f);
   lvec_t *as = aubio_filter_get_feedback (f);
   lsmp_t *b = bs->data, *a = as->data;
+  lsmp_t *b = bs->data[0], *a = as->data[0];
   uint_t order = aubio_filter_get_order (f);
 …
 aubio_filter_t *
 new_aubio_filter_a_weighting (uint_t samplerate)
+new_aubio_filter_a_weighting (uint_t channels, uint_t samplerate)
+{
   aubio_filter_t *f = new_aubio_filter (7);
+  aubio_filter_t *f = new_aubio_filter (7, channels);
   aubio_filter_set_a_weighting (f, samplerate);
   return f;

TabularUnified src/temporal/a_weighting.h ¶

-                      r8212692
+                      rf650860
 /** create new A-design filter
+  \param channels number of channels to allocate
   \param samplerate sampling frequency of the signal to filter. Should be one of
 , 11025, 16000, 22050, 24000, 32000, 44100, 48000, 88200, 96000, and
 …
 */
+aubio_filter_t *new_aubio_filter_a_weighting (uint_t samplerate);
+aubio_filter_t *new_aubio_filter_a_weighting (uint_t channels,
+    uint_t samplerate);
 /** set feedback and feedforward coefficients of a A-weighting filter

TabularUnified src/temporal/biquad.c ¶

-                      r8212692
+                      rf650860
     return AUBIO_FAIL;
+  }
   bs->data[0] = b0;
   bs->data[1] = b1;
   bs->data[2] = b2;
   as->data[0] = 1.;
   as->data[1] = a1;
   as->data[1] = a2;
+  bs->data[0][0] = b0;
+  bs->data[0][1] = b1;
+  bs->data[0][2] = b2;
+  as->data[0][0] = 1.;
+  as->data[0][1] = a1;
+  as->data[0][1] = a2;
   return AUBIO_OK;
+}
 aubio_filter_t *
+new_aubio_filter_biquad (lsmp_t b0, lsmp_t b1, lsmp_t b2, lsmp_t a1, lsmp_t a2)
+new_aubio_filter_biquad (lsmp_t b0, lsmp_t b1, lsmp_t b2, lsmp_t a1, lsmp_t a2,
+    uint_t channels)
+{
   aubio_filter_t *f = new_aubio_filter (3);
+  aubio_filter_t *f = new_aubio_filter (3, channels);
   aubio_filter_set_biquad (f, b0, b1, b2, a1, a2);
   return f;

TabularUnified src/temporal/biquad.h ¶

-                      r8212692
+                      rf650860
   \param a1 feedback filter coefficient
   \param a2 feedback filter coefficient
+  \param channels number of channels to allocate
 */
 aubio_filter_t *new_aubio_filter_biquad (lsmp_t b0, lsmp_t b1, lsmp_t b2,
     lsmp_t a1, lsmp_t a2);
+    lsmp_t a1, lsmp_t a2, uint_t channels);
 #ifdef __cplusplus

TabularUnified src/temporal/c_weighting.c ¶

-                      r8212692
+                      rf650860
   lvec_t *bs = aubio_filter_get_feedforward (f);
   lvec_t *as = aubio_filter_get_feedback (f);
   lsmp_t *b = bs->data, *a = as->data;
+  lsmp_t *b = bs->data[0], *a = as->data[0];
   uint_t order = aubio_filter_get_order (f);
 …
+}
 aubio_filter_t * new_aubio_filter_c_weighting (uint_t samplerate) {
   aubio_filter_t * f = new_aubio_filter(5);
+aubio_filter_t * new_aubio_filter_c_weighting (uint_t channels, uint_t samplerate) {
+  aubio_filter_t * f = new_aubio_filter(5, channels);
   aubio_filter_set_c_weighting (f, samplerate);
   return f;

TabularUnified src/temporal/c_weighting.h ¶

-                      r8212692
+                      rf650860
 /** create new C-design filter
+  \param channels number of channels to allocate
   \param samplerate sampling frequency of the signal to filter. Should be one of
 , 11025, 16000, 22050, 24000, 32000, 44100, 48000, 88200, 96000, and
 …
 */
+aubio_filter_t *new_aubio_filter_c_weighting (uint_t samplerate);
+aubio_filter_t *new_aubio_filter_c_weighting (uint_t channels,
+    uint_t samplerate);
 /** set feedback and feedforward coefficients of a C-weighting filter

TabularUnified src/temporal/filter.c ¶

-                      r8212692
+                      rf650860
 aubio_filter_do (aubio_filter_t * f, fvec_t * in)
+{
   uint_t j, l, order = f->order;
   lsmp_t *x = f->x->data;
   lsmp_t *y = f->y->data;
   lsmp_t *a = f->a->data;
   lsmp_t *b = f->b->data;
+  uint_t i, j, l, order = f->order;
+  lsmp_t *x;
+  lsmp_t *y;
+  lsmp_t *a = f->a->data[0];
+  lsmp_t *b = f->b->data[0];
+  for (j = 0; j < in->length; j++) {
+    /* new input */
+    x[0] = KILL_DENORMAL (in->data[j]);
+    y[0] = b[0] * x[0];
+    for (l = 1; l < order; l++) {
+      y[0] += b[l] * x[l];
+      y[0] -= a[l] * y[l];
+  for (i = 0; i < in->channels; i++) {
+    x = f->x->data[i];
+    y = f->y->data[i];
+    for (j = 0; j < in->length; j++) {
+      /* new input */
+      x[0] = KILL_DENORMAL (in->data[i][j]);
+      y[0] = b[0] * x[0];
+      for (l = 1; l < order; l++) {
+        y[0] += b[l] * x[l];
+        y[0] -= a[l] * y[l];
+      }
+      /* new output */
+      in->data[i][j] = y[0];
+      /* store for next sample */
+      for (l = order - 1; l > 0; l--) {
+        x[l] = x[l - 1];
+        y[l] = y[l - 1];
+      }
+    }
+    /* new output */
+    in->data[j] = y[0];
+    /* store for next sample */
+    for (l = order - 1; l > 0; l--) {
+      x[l] = x[l - 1];
+      y[l] = y[l - 1];
+    }
+    /* store for next run */
+    f->x->data[i] = x;
+    f->y->data[i] = y;
+  }
+}
 …
 aubio_filter_do_filtfilt (aubio_filter_t * f, fvec_t * in, fvec_t * tmp)
+{
   uint_t j;
+  uint_t j, i = 0;
   uint_t length = in->length;
   /* apply filtering */
 …
   /* mirror */
   for (j = 0; j < length; j++)
     tmp->data[length - j - 1] = in->data[j];
+    tmp->data[i][length - j - 1] = in->data[i][j];
   /* apply filtering on mirrored */
   aubio_filter_do (f, tmp);
 …
   /* invert back */
   for (j = 0; j < length; j++)
     in->data[j] = tmp->data[length - j - 1];
+    in->data[i][j] = tmp->data[i][length - j - 1];
+}
 …
 aubio_filter_t *
 new_aubio_filter (uint_t order)
+new_aubio_filter (uint_t order, uint_t channels)
+{
   aubio_filter_t *f = AUBIO_NEW (aubio_filter_t);
   f->x = new_lvec (order);
   f->y = new_lvec (order);
   f->a = new_lvec (order);
   f->b = new_lvec (order);
+  f->x = new_lvec (order, channels);
+  f->y = new_lvec (order, channels);
+  f->a = new_lvec (order, 1);
+  f->b = new_lvec (order, 1);
   /* by default, samplerate is not set */
   f->samplerate = 0;
   f->order = order;
   /* set default to identity */
   f->a->data[1] = 1.;
+  f->a->data[0][1] = 1.;
   return f;
+}

TabularUnified src/temporal/filter.h ¶

-                      r8212692
+                      rf650860
   Digital filter
   This object stores a digital filter of order \f$n\f$.
+  This object stores a digital filter of order \f$n\f$ for \f$c\f$ channels.
   It contains the following data:
     - \f$ n*1 b_i \f$ feedforward coefficients
 …
 /** create new filter object
   This function creates a new ::aubio_filter_t object, given the order of the
   filter.
+  This function creates a new ::aubio_filter_t object, given an order
+  and a specific number of channels.
   \param order order of the filter (number of coefficients)
+  \param channels number of channels to allocate
   \return the newly created filter object
 */
 aubio_filter_t *new_aubio_filter (uint_t order);
+aubio_filter_t *new_aubio_filter (uint_t order, uint_t channels);
 /** delete a filter object

TabularUnified src/temporal/resampler.c ¶

-                      r8212692
+                      rf650860
 aubio_resampler_do (aubio_resampler_t * s, fvec_t * input, fvec_t * output)
+{
+  uint_t i;
   s->proc->input_frames = input->length;
   s->proc->output_frames = output->length;
   s->proc->src_ratio = (double) s->ratio;
+  /* make SRC_PROC data point to input outputs */
+  s->proc->data_in = (float *) input->data;
+  s->proc->data_out = (float *) output->data;
+  /* do resampling */
+  src_process (s->stat, s->proc);
+  for (i = 0; i < input->channels; i++) {
+    /* make SRC_PROC data point to input outputs */
+    s->proc->data_in = (float *) input->data[i];
+    s->proc->data_out = (float *) output->data[i];
+    /* do resampling */
+    src_process (s->stat, s->proc);
+  }
+}
 …
 void
 del_aubio_resampler (aubio_resampler_t * s UNUSED)
+del_aubio_resampler (aubio_resampler_t * s)
+{
+}
 void
 aubio_resampler_do (aubio_resampler_t * s UNUSED, fvec_t * input UNUSED, fvec_t * output UNUSED)
+aubio_resampler_do (aubio_resampler_t * s, fvec_t * input, fvec_t * output)
+{
+}

TabularUnified src/utils/hist.c ¶

-                      r8212692
+                      rf650860
   fvec_t * hist;
   uint_t nelems;
+  uint_t channels;
   fvec_t * cent;
   aubio_scale_t *scaler;
 …
  * Object creation/deletion calls
  */
 aubio_hist_t * new_aubio_hist (smpl_t ilow, smpl_t ihig, uint_t nelems){
+aubio_hist_t * new_aubio_hist (smpl_t ilow, smpl_t ihig, uint_t nelems, uint_t channels){
   aubio_hist_t * s = AUBIO_NEW(aubio_hist_t);
   smpl_t step = (ihig-ilow)/(smpl_t)(nelems);
   smpl_t accum = step;
   uint_t i;
+  s->channels = channels;
   s->nelems = nelems;
   s->hist = new_fvec(nelems);
   s->cent = new_fvec(nelems);
+  s->hist = new_fvec(nelems, channels);
+  s->cent = new_fvec(nelems, 1);
   /* use scale to map ilow/ihig -> 0/nelems */
   s->scaler = new_aubio_scale(ilow,ihig,0,nelems);
   /* calculate centers now once */
   s->cent->data[0] = ilow + 0.5 * step;
+  s->cent->data[0][0] = ilow + 0.5 * step;
   for (i=1; i < s->nelems; i++, accum+=step )
     s->cent->data[i] = s->cent->data[0] + accum;
+    s->cent->data[0][i] = s->cent->data[0][0] + accum;
   return s;
 …
  */
 void aubio_hist_do (aubio_hist_t *s, fvec_t *input) {
   uint_t j;
+  uint_t i,j;
   sint_t tmp = 0;
   aubio_scale_do(s->scaler, input);
   /* reset data */
+  fvec_zeros(s->hist);
+  for (i=0; i < s->channels; i++)
+    for (j=0; j < s->nelems; j++)
+      s->hist->data[i][j] = 0;
   /* run accum */
+  for (j=0;  j < input->length; j++)
+  {
+    tmp = (sint_t)FLOOR(input->data[j]);
+    if ((tmp >= 0) && (tmp < (sint_t)s->nelems)) {
+      s->hist->data[tmp] += 1;
+  for (i=0; i < input->channels; i++)
+    for (j=0;  j < input->length; j++)
+    {
+      tmp = (sint_t)FLOOR(input->data[i][j]);
+      if ((tmp >= 0) && (tmp < (sint_t)s->nelems))
+        s->hist->data[i][tmp] += 1;
+    }
+  }
+}
 void aubio_hist_do_notnull (aubio_hist_t *s, fvec_t *input) {
   uint_t j;
+  uint_t i,j;
   sint_t tmp = 0;
   aubio_scale_do(s->scaler, input);
   /* reset data */
+  fvec_zeros(s->hist);
+  for (i=0; i < s->channels; i++)
+    for (j=0; j < s->nelems; j++)
+      s->hist->data[i][j] = 0;
   /* run accum */
+  for (j=0;  j < input->length; j++) {
+    if (input->data[j] != 0) {
+      tmp = (sint_t)FLOOR(input->data[j]);
+      if ((tmp >= 0) && (tmp < (sint_t)s->nelems))
+        s->hist->data[tmp] += 1;
+  for (i=0; i < input->channels; i++)
+    for (j=0;  j < input->length; j++) {
+      if (input->data[i][j] != 0) {
+        tmp = (sint_t)FLOOR(input->data[i][j]);
+        if ((tmp >= 0) && (tmp < (sint_t)s->nelems))
+          s->hist->data[i][tmp] += 1;
+      }
+    }
+  }
+}
 void aubio_hist_dyn_notnull (aubio_hist_t *s, fvec_t *input) {
   uint_t i;
+  uint_t i,j;
   sint_t tmp = 0;
   smpl_t ilow = fvec_min(input);
 …
   /* recalculate centers */
   s->cent->data[0] = ilow + 0.5f * step;
+  s->cent->data[0][0] = ilow + 0.5f * step;
   for (i=1; i < s->nelems; i++)
     s->cent->data[i] = s->cent->data[0] + i * step;
+    s->cent->data[0][i] = s->cent->data[0][0] + i * step;
   /* scale */
 …
   /* reset data */
+  fvec_zeros(s->hist);
+  for (i=0; i < s->channels; i++)
+    for (j=0; j < s->nelems; j++)
+      s->hist->data[i][j] = 0;
   /* run accum */
+  for (i=0;  i < input->length; i++) {
+    if (input->data[i] != 0) {
+      tmp = (sint_t)FLOOR(input->data[i]);
+      if ((tmp >= 0) && (tmp < (sint_t)s->nelems))
+        s->hist->data[tmp] += 1;
+  for (i=0; i < input->channels; i++)
+    for (j=0;  j < input->length; j++) {
+      if (input->data[i][j] != 0) {
+        tmp = (sint_t)FLOOR(input->data[i][j]);
+        if ((tmp >= 0) && (tmp < (sint_t)s->nelems))
+          s->hist->data[i][tmp] += 1;
+      }
+    }
+  }
+}
 void aubio_hist_weight (aubio_hist_t *s) {
+  uint_t j;
+  for (j=0; j < s->nelems; j++) {
+    s->hist->data[j] *= s->cent->data[j];
+  }
+  uint_t i,j;
+  for (i=0; i < s->channels; i++)
+    for (j=0; j < s->nelems; j++) {
+      s->hist->data[i][j] *= s->cent->data[0][j];
+    }
+}
 smpl_t aubio_hist_mean (aubio_hist_t *s) {
   uint_t j;
+  uint_t i,j;
   smpl_t tmp = 0.0;
+  for (j=0; j < s->nelems; j++)
+    tmp += s->hist->data[j];
+  for (i=0; i < s->channels; i++)
+    for (j=0; j < s->nelems; j++)
+      tmp += s->hist->data[i][j];
   return tmp/(smpl_t)(s->nelems);
+}

TabularUnified src/utils/hist.h ¶

-                      r8212692
+                      rf650860
  * \param fhig maximum input
  * \param nelems number of histogram columns
+ * \param channels number of channels
  */
 aubio_hist_t * new_aubio_hist(smpl_t flow, smpl_t fhig, uint_t nelems);
+aubio_hist_t * new_aubio_hist(smpl_t flow, smpl_t fhig, uint_t nelems, uint_t channels);
 /** histogram deletion */
 void del_aubio_hist(aubio_hist_t *s);

TabularUnified src/utils/scale.c ¶

-                      r8212692
+                      rf650860
 void aubio_scale_do (aubio_scale_t *s, fvec_t *input)
+{
+  uint_t j;
+  for (j=0;  j < input->length; j++){
+    input->data[j] -= s->ilow;
+    input->data[j] *= s->scaler;
+    input->data[j] += s->olow;
+  uint_t i, j;
+  for (i=0; i < input->channels; i++){
+    for (j=0;  j < input->length; j++){
+      input->data[i][j] -= s->ilow;
+      input->data[i][j] *= s->scaler;
+      input->data[i][j] += s->olow;
+    }
+  }
+}

TabularUnified src/vecutils.c ¶

-                      r8212692
+                      rf650860
 void TYPE ## _ ## OPNAME (TYPE ## _t *o) \
 { \
+  uint_t j; \
+  for (j = 0; j < o->length; j++) { \
+    o->OBJ[j] = OP (o->OBJ[j]); \
+  uint_t i,j; \
+  for (i = 0; i < o->channels; i++) { \
+    for (j = 0; j < o->length; j++) { \
+      o->OBJ[i][j] = OP (o->OBJ[i][j]); \
+    } \
   } \
+}
 …
 void fvec_pow (fvec_t *s, smpl_t power)
+{
+  uint_t j;
+  for (j = 0; j < s->length; j++) {
+    s->data[j] = POW(s->data[j], power);
+  uint_t i,j;
+  for (i = 0; i < s->channels; i++) {
+    for (j = 0; j < s->length; j++) {
+      s->data[i][j] = POW(s->data[i][j], power);
+    }
+  }
+}
 …
 void cvec_pow (cvec_t *s, smpl_t power)
+{
+  uint_t j;
+  for (j = 0; j < s->length; j++) {
+    s->norm[j] = POW(s->norm[j], power);
+  uint_t i,j;
+  for (i = 0; i < s->channels; i++) {
+    for (j = 0; j < s->length; j++) {
+      s->norm[i][j] = POW(s->norm[i][j], power);
+    }
+  }
+}

TabularUnified swig/aubio.i ¶

-                      r8212692
+                      rf650860
 /* fvec */
 fvec_t * new_fvec(uint_t length);
+fvec_t * new_fvec(uint_t length, uint_t channels);
 void del_fvec(fvec_t *s);
+smpl_t fvec_read_sample(fvec_t *s, uint_t position);
+void fvec_write_sample(fvec_t *s, smpl_t data, uint_t position);
+smpl_t * fvec_get_data(fvec_t *s);
+smpl_t fvec_read_sample(fvec_t *s, uint_t channel, uint_t position);
+void fvec_write_sample(fvec_t *s, smpl_t data, uint_t channel, uint_t position);
+smpl_t * fvec_get_channel(fvec_t *s, uint_t channel);
+void fvec_put_channel(fvec_t *s, smpl_t * data, uint_t channel);
+smpl_t ** fvec_get_data(fvec_t *s);
 /* cvec */
 cvec_t * new_cvec(uint_t length);
+cvec_t * new_cvec(uint_t length, uint_t channels);
 void del_cvec(cvec_t *s);
+void cvec_write_norm(cvec_t *s, smpl_t data, uint_t position);
+void cvec_write_phas(cvec_t *s, smpl_t data, uint_t position);
+smpl_t cvec_read_norm(cvec_t *s, uint_t position);
+smpl_t cvec_read_phas(cvec_t *s, uint_t position);
+smpl_t * cvec_get_norm(cvec_t *s);
+smpl_t * cvec_get_phas(cvec_t *s);
+void cvec_write_norm(cvec_t *s, smpl_t data, uint_t channel, uint_t position);
+void cvec_write_phas(cvec_t *s, smpl_t data, uint_t channel, uint_t position);
+smpl_t cvec_read_norm(cvec_t *s, uint_t channel, uint_t position);
+smpl_t cvec_read_phas(cvec_t *s, uint_t channel, uint_t position);
+void cvec_put_norm_channel(cvec_t *s, smpl_t * data, uint_t channel);
+void cvec_put_phas_channel(cvec_t *s, smpl_t * data, uint_t channel);
+smpl_t * cvec_get_norm_channel(cvec_t *s, uint_t channel);
+smpl_t * cvec_get_phas_channel(cvec_t *s, uint_t channel);
+smpl_t ** cvec_get_norm(cvec_t *s);
+smpl_t ** cvec_get_phas(cvec_t *s);
 /* fft */
 aubio_fft_t * new_aubio_fft(uint_t size);
+aubio_fft_t * new_aubio_fft(uint_t size, uint_t channels);
 void del_aubio_fft(aubio_fft_t * s);
 void aubio_fft_do (aubio_fft_t *s, fvec_t * input, cvec_t * spectrum);
 …
 /* filter */
 aubio_filter_t * new_aubio_filter(uint_t order);
+aubio_filter_t * new_aubio_filter(uint_t order, uint_t channels);
 void aubio_filter_do(aubio_filter_t * b, fvec_t * in);
 void aubio_filter_do_outplace(aubio_filter_t * b, fvec_t * in, fvec_t * out);
 …
 /* a_weighting */
 aubio_filter_t * new_aubio_filter_a_weighting (uint_t samplerate);
+aubio_filter_t * new_aubio_filter_a_weighting (uint_t channels, uint_t samplerate);
 uint_t aubio_filter_set_a_weighting (aubio_filter_t * b, uint_t samplerate);
 /* c_weighting */
 aubio_filter_t * new_aubio_filter_c_weighting (uint_t samplerate);
+aubio_filter_t * new_aubio_filter_c_weighting (uint_t channels, uint_t samplerate);
 uint_t aubio_filter_set_c_weighting (aubio_filter_t * b, uint_t samplerate);
 /* biquad */
 aubio_filter_t * new_aubio_filter_biquad(lsmp_t b1, lsmp_t b2, lsmp_t b3, lsmp_t a2, lsmp_t a3);
+aubio_filter_t * new_aubio_filter_biquad(lsmp_t b1, lsmp_t b2, lsmp_t b3, lsmp_t a2, lsmp_t a3, uint_t channels);
 uint_t aubio_filter_set_biquad (aubio_filter_t * b, lsmp_t b1, lsmp_t b2, lsmp_t b3, lsmp_t a2, lsmp_t a3);
 …
 /* pvoc */
 aubio_pvoc_t * new_aubio_pvoc (uint_t win_s, uint_t hop_s);
+aubio_pvoc_t * new_aubio_pvoc (uint_t win_s, uint_t hop_s, uint_t channels);
 void del_aubio_pvoc(aubio_pvoc_t *pv);
 void aubio_pvoc_do(aubio_pvoc_t *pv, fvec_t *in, cvec_t * fftgrain);
 …
 /* pitch detection */
 aubio_pitch_t *new_aubio_pitch (char *pitch_mode,
     uint_t bufsize, uint_t hopsize, uint_t samplerate);
+    uint_t bufsize, uint_t hopsize, uint_t channels, uint_t samplerate);
 void aubio_pitch_do (aubio_pitch_t * p, fvec_t * ibuf, fvec_t * obuf);
 uint_t aubio_pitch_set_tolerance(aubio_pitch_t *p, smpl_t thres);
 …
 /* tempo */
 aubio_tempo_t * new_aubio_tempo (char_t * mode,
     uint_t buf_size, uint_t hop_size, uint_t samplerate);
+    uint_t buf_size, uint_t hop_size, uint_t channels, uint_t samplerate);
 void aubio_tempo_do (aubio_tempo_t *o, fvec_t * input, fvec_t * tempo);
 uint_t aubio_tempo_set_silence(aubio_tempo_t * o, smpl_t silence);
 …
 void aubio_specdesc_do (aubio_specdesc_t * o, cvec_t * fftgrain,
   fvec_t * desc);
+aubio_specdesc_t *new_aubio_specdesc (char_t * method, uint_t buf_size);
+aubio_specdesc_t *new_aubio_specdesc (char_t * method, uint_t buf_size,
+  uint_t channels);
 void del_aubio_specdesc (aubio_specdesc_t * o);
 /* peak picker */
 aubio_peakpicker_t * new_aubio_peakpicker();
+aubio_peakpicker_t * new_aubio_peakpicker(uint_t channels);
 void aubio_peakpicker_do(aubio_peakpicker_t * p, fvec_t * in, fvec_t * out);
 fvec_t * aubio_peakpicker_get_thresholded_input(aubio_peakpicker_t * p);
 …
 aubio_sndfile_t * new_aubio_sndfile_wo(aubio_sndfile_t * existingfile, const char * outputname);
 void aubio_sndfile_info(aubio_sndfile_t * file);
 int aubio_sndfile_write(aubio_sndfile_t * file, int frames, fvec_t ** write);
 int aubio_sndfile_read(aubio_sndfile_t * file, int frames, fvec_t ** read);
+int aubio_sndfile_write(aubio_sndfile_t * file, int frames, fvec_t * write);
+int aubio_sndfile_read(aubio_sndfile_t * file, int frames, fvec_t * read);
 int del_aubio_sndfile(aubio_sndfile_t * file);
 uint_t aubio_sndfile_channels(aubio_sndfile_t * file);

TabularUnified tests/src/temporal/test-aweighting.c ¶

-                      r8212692
+                      rf650860
   uint_t nrates = 6;
   uint_t samplerate, i = 0;
+  uint_t channels = 2;
   for ( samplerate = rates[i]; i < nrates ; i++ ) {
     f = new_aubio_filter_a_weighting (samplerate);
+    f = new_aubio_filter_a_weighting (channels, samplerate);
     del_aubio_filter (f);
     f = new_aubio_filter (7);
+    f = new_aubio_filter (7, channels*2);
     aubio_filter_set_a_weighting (f, samplerate);
     del_aubio_filter (f);
 …
   // samplerate unknown
   f = new_aubio_filter_a_weighting (4200);
+  f = new_aubio_filter_a_weighting (channels, 4200);
   del_aubio_filter (f);
   // order to small
   f = new_aubio_filter (2);
+  f = new_aubio_filter (2, channels*2);
   aubio_filter_set_a_weighting (f, samplerate);
   del_aubio_filter (f);
   // order to big
   f = new_aubio_filter (12);
+  f = new_aubio_filter (12, channels*2);
   aubio_filter_set_a_weighting (f, samplerate);
   del_aubio_filter (f);

TabularUnified tests/src/temporal/test-cweighting.c ¶

-                      r8212692
+                      rf650860
   uint_t nrates = 6;
   uint_t samplerate, i = 0;
+  uint_t channels = 2;
   for ( samplerate = rates[i]; i < nrates ; i++ ) {
     f = new_aubio_filter_c_weighting (samplerate);
+    f = new_aubio_filter_c_weighting (channels, samplerate);
     del_aubio_filter (f);
     f = new_aubio_filter (5);
+    f = new_aubio_filter (5, channels*2);
     aubio_filter_set_c_weighting (f, samplerate);
     del_aubio_filter (f);
 …
   // samplerate unknown
   f = new_aubio_filter_c_weighting (4200);
+  f = new_aubio_filter_c_weighting (channels, 4200);
   del_aubio_filter (f);
   // order to small
   f = new_aubio_filter (2);
+  f = new_aubio_filter (2, channels*2);
   aubio_filter_set_c_weighting (f, samplerate);
   del_aubio_filter (f);
   // order to big
   f = new_aubio_filter (12);
+  f = new_aubio_filter (12, channels*2);
   aubio_filter_set_c_weighting (f, samplerate);
   del_aubio_filter (f);

TabularUnified tests/src/test-beattracking.c ¶

-                      r8212692
+                      rf650860
         /* allocate some memory */
         uint_t win_s      = 1024;                       /* window size */
+        fvec_t * in       = new_fvec (win_s); /* input buffer */
+        fvec_t * out      = new_fvec (win_s/4);     /* input buffer */
+        uint_t channels   = 1;                          /* number of channel */
+        fvec_t * in       = new_fvec (win_s, channels); /* input buffer */
+        fvec_t * out      = new_fvec (win_s/4, channels);     /* input buffer */
         /* allocate fft and other memory space */
         aubio_beattracking_t * tempo  = new_aubio_beattracking(win_s);
+        aubio_beattracking_t * tempo  = new_aubio_beattracking(win_s, channels);
         uint_t i = 0;

TabularUnified tests/src/test-biquad.c ¶

-                      r8212692
+                      rf650860
         /* allocate some memory */
         uint_t win_s      = 1024;                       /* window size */
+        fvec_t * in       = new_fvec (win_s); /* input buffer */
+        aubio_filter_t * o = new_aubio_filter_biquad(0.3,0.2,0.1,0.2,0.3);
+        uint_t channels   = 1;                          /* number of channel */
+        fvec_t * in       = new_fvec (win_s, channels); /* input buffer */
+        aubio_filter_t * o = new_aubio_filter_biquad(0.3,0.2,0.1,0.2,0.3, channels);
         aubio_filter_do_filtfilt(o,in,in);

TabularUnified tests/src/test-cvec.c ¶

-                      r8212692
+                      rf650860
         /* allocate some memory */
         uint_t win_s      = 1024;                       /* window size */
+        cvec_t * sp       = new_cvec (win_s); /* input buffer */
+        uint_t channels   = 1;                          /* number of channel */
+        cvec_t * sp       = new_cvec (win_s, channels); /* input buffer */
         del_cvec(sp);

TabularUnified tests/src/test-fft.c ¶

-                      r8212692
+                      rf650860
         /* allocate some memory */
         uint_t win_s      = 8;                       /* window size        */
+        fvec_t * in       = new_fvec (win_s); /* input buffer       */
+        cvec_t * fftgrain = new_cvec (win_s); /* fft norm and phase */
+        fvec_t * out      = new_fvec (win_s); /* output buffer      */
+        in->data[0] = 1;
+        in->data[1] = 2;
+        in->data[2] = 3;
+        in->data[3] = 4;
+        in->data[4] = 5;
+        in->data[5] = 6;
+        in->data[6] = 5;
+        in->data[7] = 6;
+        uint_t channels   = 1;                        /* number of channels */
+        fvec_t * in       = new_fvec (win_s, channels); /* input buffer       */
+        cvec_t * fftgrain = new_cvec (win_s, channels); /* fft norm and phase */
+        fvec_t * out      = new_fvec (win_s, channels); /* output buffer      */
+        in->data[0][0] = 1;
+        in->data[0][1] = 2;
+        in->data[0][2] = 3;
+        in->data[0][3] = 4;
+        in->data[0][4] = 5;
+        in->data[0][5] = 6;
+        in->data[0][6] = 5;
+        in->data[0][7] = 6;
         /* allocate fft and other memory space */
         aubio_fft_t * fft = new_aubio_fft(win_s);
+        aubio_fft_t * fft = new_aubio_fft(win_s,channels);
         /* fill input with some data */
         fvec_print(in);

TabularUnified tests/src/test-filter.c ¶

-                      r8212692
+                      rf650860
   /* allocate some memory */
   uint_t win_s = 32;            /* window size */
+  fvec_t *in = new_fvec (win_s);      /* input buffer */
+  fvec_t *out = new_fvec (win_s);     /* input buffer */
+  uint_t channels = 1;          /* number of channel */
+  fvec_t *in = new_fvec (win_s, channels);      /* input buffer */
+  fvec_t *out = new_fvec (win_s, channels);     /* input buffer */
   aubio_filter_t *o = new_aubio_filter_c_weighting (44100);
   in->data[12] = 0.5;
+  aubio_filter_t *o = new_aubio_filter_c_weighting (channels, 44100);
+  in->data[0][12] = 0.5;
   fvec_print (in);
   aubio_filter_do (o, in);
 …
   del_aubio_filter (o);
   o = new_aubio_filter_c_weighting (44100);
   in->data[12] = 0.5;
+  o = new_aubio_filter_c_weighting (channels, 44100);
+  in->data[0][12] = 0.5;
   fvec_print (in);
   aubio_filter_do_outplace (o, in, out);
 …
   del_aubio_filter (o);
   o = new_aubio_filter_c_weighting (44100);
   in->data[12] = 0.5;
+  o = new_aubio_filter_c_weighting (channels, 44100);
+  in->data[0][12] = 0.5;
   fvec_print (in);
   aubio_filter_do_filtfilt (o, in, out);

TabularUnified tests/src/test-filterbank.c ¶

-                      r8212692
+                      rf650860
   /* allocate some memory */
   uint_t win_s = 1024;          /* window size */
+  uint_t channels = 2;          /* number of channel */
   uint_t n_filters = 13;        /* number of filters */
   cvec_t *in = new_cvec (win_s);      /* input buffer */
   fvec_t *out = new_fvec (win_s);     /* input buffer */
   fmat_t *coeffs = NULL;
+  cvec_t *in = new_cvec (win_s, channels);      /* input buffer */
+  fvec_t *out = new_fvec (win_s, channels);     /* input buffer */
+  fvec_t *coeffs = NULL;
   /* allocate fft and other memory space */
 …
+  }
-  /*
   if (fvec_max (coeffs) != 0.) {
     return -1;
 …
     return -1;
+  }
-  */
   fmat_print (coeffs);
+  fvec_print (coeffs);
   aubio_filterbank_do (o, in, out);

TabularUnified tests/src/test-filterbank_mel.c ¶

-                      r8212692
+                      rf650860
   /* allocate some memory */
   uint_t win_s = 512;           /* fft size */
+  uint_t channels = 2;          /* number of channel */
   uint_t n_filters = 40;        /* number of filters */
   cvec_t *in = new_cvec (win_s);      /* input buffer */
   fvec_t *out = new_fvec (win_s);     /* input buffer */
   fmat_t *coeffs = NULL;
+  cvec_t *in = new_cvec (win_s, channels);      /* input buffer */
+  fvec_t *out = new_fvec (win_s, channels);     /* input buffer */
+  fvec_t *coeffs = NULL;
   smpl_t samplerate = 16000.;
 …
+  }
   //fmat_print (coeffs);
+  //fvec_print (coeffs);
   //fprintf(stderr, "%f\n", fvec_sum(coeffs));

TabularUnified tests/src/test-fvec.c ¶

-                      r8212692
+                      rf650860
         /* allocate some memory */
         uint_t win_s      = 1024;                       /* window size */
+        fvec_t * in       = new_fvec (win_s); /* input buffer */
+        uint_t channels   = 1;                          /* number of channel */
+        fvec_t * in       = new_fvec (win_s, channels); /* input buffer */
         del_fvec(in);

TabularUnified tests/src/test-hist.c ¶

r8212692	rf650860
8	8	uint_t length;
9	9	for (length = 1; length < 10; length ++ ) {
10		aubio_hist_t *o = new_aubio_hist(0, 1, length);
	10	aubio_hist_t *o = new_aubio_hist(0, 1, length, 5);
11	11	fvec_t *t = new_aubio_window("hanning", length);
12	12	aubio_hist_do(o,t);

TabularUnified tests/src/test-mfcc.c ¶

-                      r8212692
+                      rf650860
   /* allocate some memory */
   uint_t win_s = 512;           /* fft size */
+  uint_t channels = 1;          /* number of channel */
   uint_t n_filters = 40;        /* number of filters */
   uint_t n_coefs = 13;          /* number of coefficients */
   cvec_t *in = new_cvec (win_s);      /* input buffer */
   fvec_t *out = new_fvec (n_coefs);     /* input buffer */
+  cvec_t *in = new_cvec (win_s, channels);      /* input buffer */
+  fvec_t *out = new_fvec (n_coefs, channels);     /* input buffer */
   smpl_t samplerate = 16000.;

TabularUnified tests/src/test-onset.c ¶

-                      r8212692
+                      rf650860
         /* allocate some memory */
         uint_t win_s      = 1024;                       /* window size */
+        fvec_t * in       = new_fvec (win_s/4); /* input buffer */
+        fvec_t * out      = new_fvec (2);     /* input buffer */
+        aubio_onset_t * onset  = new_aubio_onset("complex", win_s, win_s/4, 44100.);
+        uint_t channels   = 1;                          /* number of channel */
+        fvec_t * in       = new_fvec (win_s/4, channels); /* input buffer */
+        fvec_t * out      = new_fvec (2, channels);     /* input buffer */
+        aubio_onset_t * onset  = new_aubio_onset("complex", win_s, win_s/4, channels, 44100.);
         uint_t i = 0;

TabularUnified tests/src/test-onsetdetection.c ¶

-                      r8212692
+                      rf650860
+{
   uint_t win_s = 1024;          /* window size */
+  cvec_t *in = new_cvec (win_s);      /* input buffer */
+  fvec_t *out = new_fvec (1); /* input buffer */
+  uint_t channels = 1;          /* number of channel */
+  cvec_t *in = new_cvec (win_s, channels);      /* input buffer */
+  fvec_t *out = new_fvec (1, channels); /* input buffer */
   aubio_specdesc_t *o;
   o = new_aubio_specdesc ("energy", win_s);
+  o = new_aubio_specdesc ("energy", win_s, channels);
   aubio_specdesc_do (o, in, out);
   del_aubio_specdesc (o);
   o = new_aubio_specdesc ("energy", win_s);
+  o = new_aubio_specdesc ("energy", win_s, channels);
   aubio_specdesc_do (o, in, out);
   del_aubio_specdesc (o);
   o = new_aubio_specdesc ("hfc", win_s);
+  o = new_aubio_specdesc ("hfc", win_s, channels);
   aubio_specdesc_do (o, in, out);
   del_aubio_specdesc (o);
   o = new_aubio_specdesc ("complex", win_s);
+  o = new_aubio_specdesc ("complex", win_s, channels);
   aubio_specdesc_do (o, in, out);
   del_aubio_specdesc (o);
   o = new_aubio_specdesc ("phase", win_s);
+  o = new_aubio_specdesc ("phase", win_s, channels);
   aubio_specdesc_do (o, in, out);
   del_aubio_specdesc (o);
   o = new_aubio_specdesc ("kl", win_s);
+  o = new_aubio_specdesc ("kl", win_s, channels);
   aubio_specdesc_do (o, in, out);
   del_aubio_specdesc (o);
   o = new_aubio_specdesc ("mkl", win_s);
+  o = new_aubio_specdesc ("mkl", win_s, channels);
   aubio_specdesc_do (o, in, out);
   del_aubio_specdesc (o);

TabularUnified tests/src/test-peakpick.c ¶

-                      r8212692
+                      rf650860
         /* allocate some memory */
         uint_t win_s      = 1024;                       /* window size */
+        fvec_t * in       = new_fvec (win_s); /* input buffer */
+        fvec_t * out      = new_fvec (1); /* input buffer */
+        aubio_peakpicker_t * o = new_aubio_peakpicker();
+        uint_t channels   = 1;                          /* number of channel */
+        fvec_t * in       = new_fvec (win_s, channels); /* input buffer */
+        fvec_t * out      = new_fvec (1, channels); /* input buffer */
+        aubio_peakpicker_t * o = new_aubio_peakpicker(1);
         aubio_peakpicker_set_threshold (o, 0.3);

TabularUnified tests/src/test-phasevoc-jack.c ¶

-                      r8212692
+                      rf650860
 uint_t pos      = 0;  /* frames%dspblocksize for jack loop */
 fvec_t * in[2];
 cvec_t * fftgrain[2];
 fvec_t * out[2];
+fvec_t * in;
+cvec_t * fftgrain;
+fvec_t * out;
 aubio_pvoc_t * pv[2];
+aubio_pvoc_t * pv;
 int aubio_process(float **input, float **output, int nframes);
 …
 int main(){
         /* allocate some memory */
+  uint_t i;
+    for (i=0;i<channels;i++) {
+        in[i]       = new_fvec (hop_s); /* input buffer       */
+        fftgrain[i] = new_cvec (win_s); /* fft norm and phase */
+        out[i]      = new_fvec (hop_s); /* output buffer      */
+        in       = new_fvec (hop_s, channels); /* input buffer       */
+        fftgrain = new_cvec (win_s, channels); /* fft norm and phase */
+        out      = new_fvec (hop_s, channels); /* output buffer      */
         /* allocate fft and other memory space */
+        pv[i] = new_aubio_pvoc(win_s,hop_s);
+    }
+        pv = new_aubio_pvoc(win_s,hop_s,channels);
 #ifdef HAVE_JACK
 …
 #endif
+    for (i=0;i<channels;i++) {
+        del_aubio_pvoc(pv[i]);
+        del_cvec(fftgrain[i]);
+        del_fvec(in[i]);
+        del_fvec(out[i]);
+    }
+        del_aubio_pvoc(pv);
+        del_cvec(fftgrain);
+        del_fvec(in);
+        del_fvec(out);
         aubio_cleanup();
         return 0;
 …
     for (i=0;i<channels;i++) {
       /* write input to datanew */
       fvec_write_sample(in[i], input[i][j], pos);
+      fvec_write_sample(in, input[i][j], i, pos);
       /* put synthnew in output */
       output[i][j] = fvec_read_sample(out[i], pos);
+      output[i][j] = fvec_read_sample(out, i, pos);
+    }
     /*time for fft*/
     if (pos == hop_s-1) {
       /* block loop */
+    for (i=0;i<channels;i++) {
+      aubio_pvoc_do (pv[i], in[i], fftgrain[i]);
+      aubio_pvoc_do (pv,in, fftgrain);
       // zero phases of first channel
       for (i=0;i<fftgrain[i]->length;i++) fftgrain[0]->phas[i] = 0.;
+      for (i=0;i<fftgrain->length;i++) fftgrain->phas[0][i] = 0.;
       // double phases of second channel
       for (i=0;i<fftgrain[i]->length;i++) {
         fftgrain[1]->phas[i] =
           aubio_unwrap2pi (fftgrain[1]->phas[i] * 2.);
+      for (i=0;i<fftgrain->length;i++) {
+        fftgrain->phas[1][i] =
+          aubio_unwrap2pi (fftgrain->phas[1][i] * 2.);
+      }
       // copy second channel to third one
       aubio_pvoc_rdo(pv[i], fftgrain[i], out[i]);
+      aubio_pvoc_rdo(pv,fftgrain,out);
       pos = -1;
+    }
+    }
     pos++;

TabularUnified tests/src/test-phasevoc.c ¶

-                      r8212692
+                      rf650860
         uint_t win_s    = 1024; /* window size                       */
         uint_t hop_s    = 256;  /* hop size                          */
+        uint_t channels = 4;  /* number of channels                */
         /* allocate some memory */
         fvec_t * in       = new_fvec (hop_s); /* input buffer       */
         cvec_t * fftgrain = new_cvec (win_s); /* fft norm and phase */
         fvec_t * out      = new_fvec (hop_s); /* output buffer      */
+        fvec_t * in       = new_fvec (hop_s, channels); /* input buffer       */
+        cvec_t * fftgrain = new_cvec (win_s, channels); /* fft norm and phase */
+        fvec_t * out      = new_fvec (hop_s, channels); /* output buffer      */
         /* allocate fft and other memory space */
         aubio_pvoc_t * pv = new_aubio_pvoc(win_s,hop_s);
+        aubio_pvoc_t * pv = new_aubio_pvoc(win_s,hop_s,channels);
         /* fill input with some data */
         printf("initialised\n");

TabularUnified tests/src/test-pitchdetection.c ¶

-                      r8212692
+                      rf650860
   uint_t hop_s = win_s / 4;     /* hop size */
   uint_t samplerate = 44100;    /* samplerate */
+  fvec_t *in = new_fvec (hop_s);      /* input buffer */
+  fvec_t *out = new_fvec (1); /* input buffer */
+  uint_t channels = 1;          /* number of channel */
+  fvec_t *in = new_fvec (hop_s, channels);      /* input buffer */
+  fvec_t *out = new_fvec (1, channels); /* input buffer */
   aubio_pitch_t *o =
       new_aubio_pitch ("default", win_s, hop_s, samplerate);
+      new_aubio_pitch ("default", win_s, hop_s, channels, samplerate);
   uint_t i = 0;

TabularUnified tests/src/test-pitchfcomb.c ¶

-                      r8212692
+                      rf650860
         uint_t win_s      = 1024;                       /* window size */
         uint_t hop_s      = win_s/4;                    /* hop size */
+        fvec_t * in       = new_fvec (hop_s); /* input buffer */
+        fvec_t * out      = new_fvec (1);
+        uint_t channels   = 3;                          /* number of channel */
+        fvec_t * in       = new_fvec (hop_s, channels); /* input buffer */
+        fvec_t * out      = new_fvec (1, channels);
         aubio_pitchfcomb_t * o  = new_aubio_pitchfcomb (
           win_s, hop_s);
+          win_s, hop_s, channels);
         uint_t i = 0;

TabularUnified tests/src/test-pitchmcomb.c ¶

-                      r8212692
+                      rf650860
         uint_t win_s      = 1024;                       /* window size */
         uint_t hop_s      = win_s/4;                    /* hop size */
+        cvec_t * in       = new_cvec (win_s); /* input buffer */
+        fvec_t * out      = new_fvec (1); /* input buffer */
+        uint_t channels   = 1;                          /* number of channel */
+        cvec_t * in       = new_cvec (win_s, channels); /* input buffer */
+        fvec_t * out      = new_fvec (1, channels); /* input buffer */
         aubio_pitchmcomb_t * o  = new_aubio_pitchmcomb(win_s, hop_s);
+        aubio_pitchmcomb_t * o  = new_aubio_pitchmcomb(win_s, hop_s, channels);
         uint_t i = 0;

TabularUnified tests/src/test-pitchschmitt.c ¶

-                      r8212692
+                      rf650860
         /* allocate some memory */
         uint_t win_s      = 1024;                       /* window size */
         fvec_t * in       = new_fvec (win_s); /* input buffer */
         fvec_t * out = new_fvec (1); /* input buffer */
+        fvec_t * in       = new_fvec (win_s, 1); /* input buffer */
+        fvec_t * out = new_fvec (1, 1); /* input buffer */
         aubio_pitchschmitt_t * o  = new_aubio_pitchschmitt(win_s);
         uint_t i = 0;

TabularUnified tests/src/test-pitchyin.c ¶

-                      r8212692
+                      rf650860
         /* allocate some memory */
         uint_t win_s      = 1024;                       /* window size */
+        fvec_t * in       = new_fvec (win_s); /* input buffer */
+        fvec_t * out      = new_fvec (win_s/2); /* input buffer */
+        uint_t channels   = 1;                          /* number of channel */
+        fvec_t * in       = new_fvec (win_s, channels); /* input buffer */
+        fvec_t * out      = new_fvec (win_s/2, channels); /* input buffer */
         aubio_pitchyin_t *p = new_aubio_pitchyin (win_s);
         uint_t i = 0;

TabularUnified tests/src/test-pitchyinfft.c ¶

-                      r8212692
+                      rf650860
         /* allocate some memory */
         uint_t win_s      = 1024;                       /* window size */
+        fvec_t * in       = new_fvec (win_s); /* input buffer */
+        fvec_t * out      = new_fvec (1); /* output pitch periods */
+        uint_t channels   = 1;                          /* number of channel */
+        fvec_t * in       = new_fvec (win_s, channels); /* input buffer */
+        fvec_t * out      = new_fvec (1, channels); /* output pitch periods */
         aubio_pitchyinfft_t * o  = new_aubio_pitchyinfft(win_s);
         aubio_pitchyinfft_set_tolerance (o, 0.2);

TabularUnified tests/src/test-resample.c ¶

-                      r8212692
+                      rf650860
   /* allocate some memory */
   uint_t win_s = 1024;          /* window size */
+  uint_t channels = 1;          /* number of channel */
   smpl_t ratio = 0.5;
   fvec_t *in = new_fvec (win_s);      /* input buffer */
   fvec_t *out = new_fvec ((uint_t) (win_s * ratio));  /* input buffer */
+  fvec_t *in = new_fvec (win_s, channels);      /* input buffer */
+  fvec_t *out = new_fvec ((uint_t) (win_s * ratio), channels);  /* input buffer */
   aubio_resampler_t *o = new_aubio_resampler (0.5, 0);
   uint_t i = 0;

TabularUnified tests/src/test-scale.c ¶

-                      r8212692
+                      rf650860
         /* allocate some memory */
         uint_t win_s      = 1024;                       /* window size */
+        fvec_t * in       = new_fvec (win_s); /* input buffer */
+        uint_t channels   = 1;                          /* number of channel */
+        fvec_t * in       = new_fvec (win_s, channels); /* input buffer */
         aubio_scale_t * o = new_aubio_scale(0,1,2,3);
         aubio_scale_set_limits (o,0,1,2,3);

TabularUnified tests/src/test-tempo.c ¶

-                      r8212692
+                      rf650860
         /* allocate some memory */
         uint_t win_s      = 1024;                       /* window size */
+        fvec_t * in       = new_fvec (win_s); /* input buffer */
+        fvec_t * out      = new_fvec (2);     /* input buffer */
+        aubio_tempo_t * o  = new_aubio_tempo("complex", win_s, win_s/4, 44100.);
+        uint_t channels   = 1;                          /* number of channel */
+        fvec_t * in       = new_fvec (win_s, channels); /* input buffer */
+        fvec_t * out      = new_fvec (2, channels);     /* input buffer */
+        aubio_tempo_t * o  = new_aubio_tempo("complex", win_s, win_s/4, channels, 44100.);
         uint_t i = 0;

TabularUnified tests/src/test-tss.c ¶

-                      r8212692
+                      rf650860
         uint_t win_s    = 1024; /* window size                       */
         uint_t hop_s    = 256;  /* hop size                          */
+        uint_t channels = 4;  /* number of channels                */
         /* allocate some memory */
         fvec_t * in       = new_fvec (hop_s); /* input buffer       */
         cvec_t * fftgrain = new_cvec (win_s); /* fft norm and phase */
         cvec_t * cstead   = new_cvec (win_s); /* fft norm and phase */
         cvec_t * ctrans   = new_cvec (win_s); /* fft norm and phase */
         fvec_t * stead    = new_fvec (hop_s); /* output buffer      */
         fvec_t * trans    = new_fvec (hop_s); /* output buffer      */
+        fvec_t * in       = new_fvec (hop_s, channels); /* input buffer       */
+        cvec_t * fftgrain = new_cvec (win_s, channels); /* fft norm and phase */
+        cvec_t * cstead   = new_cvec (win_s, channels); /* fft norm and phase */
+        cvec_t * ctrans   = new_cvec (win_s, channels); /* fft norm and phase */
+        fvec_t * stead    = new_fvec (hop_s, channels); /* output buffer      */
+        fvec_t * trans    = new_fvec (hop_s, channels); /* output buffer      */
         /* allocate fft and other memory space */
         aubio_pvoc_t * pv = new_aubio_pvoc (win_s,hop_s);
         aubio_pvoc_t * pvt = new_aubio_pvoc(win_s,hop_s);
         aubio_pvoc_t * pvs = new_aubio_pvoc(win_s,hop_s);
+        aubio_pvoc_t * pv = new_aubio_pvoc (win_s,hop_s,channels);
+        aubio_pvoc_t * pvt = new_aubio_pvoc(win_s,hop_s,channels);
+        aubio_pvoc_t * pvs = new_aubio_pvoc(win_s,hop_s,channels);
         aubio_tss_t *  tss = new_aubio_tss(win_s,hop_s);
+        aubio_tss_t *  tss = new_aubio_tss(win_s,hop_s,channels);
         /* fill input with some data */
         printf("initialised\n");

aubio

Context Navigation

Changes in / [8212692:f650860]

Legend:

TabularUnified examples/aubiomfcc.c ¶

TabularUnified examples/aubionotes.c ¶

TabularUnified examples/aubioonset.c ¶

TabularUnified examples/aubiopitch.c ¶

TabularUnified examples/aubioquiet.c ¶

TabularUnified examples/aubiotrack.c ¶

TabularUnified examples/sndfileio.c ¶

TabularUnified examples/sndfileio.h ¶

TabularUnified examples/utils.c ¶

TabularUnified examples/utils.h ¶

TabularUnified interfaces/python/aubio-types.h ¶

TabularUnified interfaces/python/aubiomodule.c ¶

TabularUnified interfaces/python/aubiowraphell.h ¶

TabularUnified interfaces/python/gen_pyobject.py ¶

TabularUnified interfaces/python/py-cvec.c ¶

TabularUnified interfaces/python/py-fft.c ¶

TabularUnified interfaces/python/py-filter.c ¶

TabularUnified interfaces/python/py-filterbank.c ¶

TabularUnified interfaces/python/py-phasevoc.c ¶

TabularUnified interfaces/python/setup.py ¶

TabularUnified interfaces/python/test_aubio.py ¶

TabularUnified interfaces/python/test_fft.py ¶

TabularUnified interfaces/python/test_filter.py ¶

TabularUnified interfaces/python/test_filterbank.py ¶

TabularUnified interfaces/python/test_onsetdetection.py ¶

TabularUnified interfaces/python/test_phasevoc.py ¶

TabularUnified src/aubio.h ¶

TabularUnified src/cvec.c ¶

TabularUnified src/cvec.h ¶

TabularUnified src/fvec.c ¶

TabularUnified src/fvec.h ¶

TabularUnified src/lvec.c ¶

TabularUnified src/lvec.h ¶

TabularUnified src/mathutils.c ¶

TabularUnified src/mathutils.h ¶

TabularUnified src/onset/onset.c ¶

TabularUnified src/onset/onset.h ¶

TabularUnified src/onset/peakpicker.c ¶

TabularUnified src/onset/peakpicker.h ¶

TabularUnified src/pitch/pitch.c ¶

TabularUnified src/pitch/pitch.h ¶

TabularUnified src/pitch/pitchfcomb.c ¶

TabularUnified src/pitch/pitchfcomb.h ¶

TabularUnified src/pitch/pitchmcomb.c ¶

TabularUnified src/pitch/pitchmcomb.h ¶

TabularUnified src/pitch/pitchschmitt.c ¶

TabularUnified src/pitch/pitchyin.c ¶

TabularUnified src/pitch/pitchyinfft.c ¶

TabularUnified src/spectral/fft.c ¶

TabularUnified src/spectral/fft.h ¶

TabularUnified src/spectral/filterbank.c ¶

TabularUnified src/spectral/filterbank.h ¶

TabularUnified src/spectral/filterbank_mel.c ¶

TabularUnified src/spectral/mfcc.c ¶

TabularUnified src/spectral/phasevoc.c ¶

TabularUnified src/spectral/phasevoc.h ¶

TabularUnified src/spectral/specdesc.c ¶

TabularUnified src/spectral/specdesc.h ¶

TabularUnified src/spectral/statistics.c ¶

TabularUnified src/spectral/tss.c ¶

TabularUnified src/spectral/tss.h ¶

TabularUnified src/tempo/beattracking.c ¶

TabularUnified src/tempo/beattracking.h ¶

TabularUnified src/tempo/tempo.c ¶

TabularUnified src/tempo/tempo.h ¶

TabularUnified src/temporal/a_weighting.c ¶

TabularUnified src/temporal/a_weighting.h ¶

TabularUnified src/temporal/biquad.c ¶

TabularUnified src/temporal/biquad.h ¶

TabularUnified src/temporal/c_weighting.c ¶

TabularUnified src/temporal/c_weighting.h ¶

TabularUnified src/temporal/filter.c ¶

TabularUnified src/temporal/filter.h ¶

TabularUnified src/temporal/resampler.c ¶

TabularUnified src/utils/hist.c ¶

TabularUnified src/utils/hist.h ¶